drivers/usb/misc/speedtch.c

   1 /******************************************************************************
   2  *  speedtouch.c  -  Alcatel SpeedTouch USB xDSL modem driver
   3  *
   4  *  Copyright (C) 2001, Alcatel
   5  *  Copyright (C) 2003, Duncan Sands
   6  *
   7  *  This program is free software; you can redistribute it and/or modify it
   8  *  under the terms of the GNU General Public License as published by the Free
   9  *  Software Foundation; either version 2 of the License, or (at your option)
  10  *  any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful, but WITHOUT
  13  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  *  more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License along with
  18  *  this program; if not, write to the Free Software Foundation, Inc., 59
  19  *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  ******************************************************************************/
  22
  23 /*
  24  *  Written by Johan Verrept, maintained by Duncan Sands (duncan.sands@free.fr)
  25  *
  26  *  1.7+:       - See the check-in logs
  27  *
  28  *  1.6:        - No longer opens a connection if the firmware is not loaded
  29  *              - Added support for the speedtouch 330
  30  *              - Removed the limit on the number of devices
  31  *              - Module now autoloads on device plugin
  32  *              - Merged relevant parts of sarlib
  33  *              - Replaced the kernel thread with a tasklet
  34  *              - New packet transmission code
  35  *              - Changed proc file contents
  36  *              - Fixed all known SMP races
  37  *              - Many fixes and cleanups
  38  *              - Various fixes by Oliver Neukum (oliver@neukum.name)
  39  *
  40  *  1.5A:       - Version for inclusion in 2.5 series kernel
  41  *              - Modifications by Richard Purdie (rpurdie@rpsys.net)
  42  *              - made compatible with kernel 2.5.6 onwards by changing
  43  *              udsl_usb_send_data_context->urb to a pointer and adding code
  44  *              to alloc and free it
  45  *              - remove_wait_queue() added to udsl_atm_processqueue_thread()
  46  *
  47  *  1.5:        - fixed memory leak when atmsar_decode_aal5 returned NULL.
  48  *              (reported by stephen.robinson@zen.co.uk)
  49  *
  50  *  1.4:        - changed the spin_lock() under interrupt to spin_lock_irqsave()
  51  *              - unlink all active send urbs of a vcc that is being closed.
  52  *
  53  *  1.3.1:      - added the version number
  54  *
  55  *  1.3:        - Added multiple send urb support
  56  *              - fixed memory leak and vcc->tx_inuse starvation bug
  57  *                when not enough memory left in vcc.
  58  *
  59  *  1.2:        - Fixed race condition in udsl_usb_send_data()
  60  *  1.1:        - Turned off packet debugging
  61  *
  62  */
  63
  64 #include <asm/semaphore.h>
  65 #include <linux/module.h>
  66 #include <linux/moduleparam.h>
  67 #include <linux/kernel.h>
  68 #include <linux/sched.h>
  69 #include <linux/timer.h>
  70 #include <linux/errno.h>
  71 #include <linux/proc_fs.h>
  72 #include <linux/slab.h>
  73 #include <linux/list.h>
  74 #include <asm/uaccess.h>
  75 #include <linux/smp_lock.h>
  76 #include <linux/interrupt.h>
  77 #include <linux/atm.h>
  78 #include <linux/atmdev.h>
  79 #include <linux/crc32.h>
  80 #include <linux/init.h>
  81
  82 /*
  83 #define DEBUG
  84 #define VERBOSE_DEBUG
  85 */
  86
  87 #include <linux/usb.h>
  88
  89 #ifdef DEBUG
  90 #define DEBUG_ON(x)     BUG_ON(x)
  91 #else
  92 #define DEBUG_ON(x)     do { if (x); } while (0)
  93 #endif
  94
  95 #ifdef VERBOSE_DEBUG
  96 static int udsl_print_packet (const unsigned char *data, int len);
  97 #define PACKETDEBUG(arg...)     udsl_print_packet (arg)
  98 #define vdbg(arg...)            dbg (arg)
  99 #else
 100 #define PACKETDEBUG(arg...)
 101 #define vdbg(arg...)
 102 #endif
 103
 104 #define DRIVER_AUTHOR   "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
 105 #define DRIVER_DESC     "Alcatel SpeedTouch USB driver"
 106 #define DRIVER_VERSION  "1.7"
 107
 108 static const char udsl_driver_name [] = "speedtch";
 109
 110 #define SPEEDTOUCH_VENDORID             0x06b9
 111 #define SPEEDTOUCH_PRODUCTID            0x4061
 112
 113 #define UDSL_MAX_RCV_URBS               4
 114 #define UDSL_MAX_SND_URBS               4
 115 #define UDSL_MAX_RCV_BUFS               8
 116 #define UDSL_MAX_SND_BUFS               8
 117 #define UDSL_MAX_RCV_BUF_SIZE           1024 /* ATM cells */
 118 #define UDSL_MAX_SND_BUF_SIZE           1024 /* ATM cells */
 119 #define UDSL_DEFAULT_RCV_URBS           2
 120 #define UDSL_DEFAULT_SND_URBS           2
 121 #define UDSL_DEFAULT_RCV_BUFS           4
 122 #define UDSL_DEFAULT_SND_BUFS           4
 123 #define UDSL_DEFAULT_RCV_BUF_SIZE       64 /* ATM cells */
 124 #define UDSL_DEFAULT_SND_BUF_SIZE       64 /* ATM cells */
 125
 126 static unsigned int num_rcv_urbs = UDSL_DEFAULT_RCV_URBS;
 127 static unsigned int num_snd_urbs = UDSL_DEFAULT_SND_URBS;
 128 static unsigned int num_rcv_bufs = UDSL_DEFAULT_RCV_BUFS;
 129 static unsigned int num_snd_bufs = UDSL_DEFAULT_SND_BUFS;
 130 static unsigned int rcv_buf_size = UDSL_DEFAULT_RCV_BUF_SIZE;
 131 static unsigned int snd_buf_size = UDSL_DEFAULT_SND_BUF_SIZE;
 132
 133 module_param (num_rcv_urbs, uint, 0444);
 134 MODULE_PARM_DESC (num_rcv_urbs, "Number of urbs used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_URBS) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_URBS) ")");
 135
 136 module_param (num_snd_urbs, uint, 0444);
 137 MODULE_PARM_DESC (num_snd_urbs, "Number of urbs used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_URBS) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_URBS) ")");
 138
 139 module_param (num_rcv_bufs, uint, 0444);
 140 MODULE_PARM_DESC (num_rcv_bufs, "Number of buffers used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_BUFS) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_BUFS) ")");
 141
 142 module_param (num_snd_bufs, uint, 0444);
 143 MODULE_PARM_DESC (num_snd_bufs, "Number of buffers used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_BUFS) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_BUFS) ")");
 144
 145 module_param (rcv_buf_size, uint, 0444);
 146 MODULE_PARM_DESC (rcv_buf_size, "Size of the buffers used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_BUF_SIZE) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_BUF_SIZE) ")");
 147
 148 module_param (snd_buf_size, uint, 0444);
 149 MODULE_PARM_DESC (snd_buf_size, "Size of the buffers used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_BUF_SIZE) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_BUF_SIZE) ")");
 150
 151 #define UDSL_IOCTL_LINE_UP              1
 152 #define UDSL_IOCTL_LINE_DOWN            2
 153
 154 #define UDSL_ENDPOINT_DATA_OUT          0x07
 155 #define UDSL_ENDPOINT_DATA_IN           0x87
 156
 157 #define ATM_CELL_HEADER                 (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
 158 #define UDSL_NUM_CELLS(x)               (((x) + ATM_AAL5_TRAILER + ATM_CELL_PAYLOAD - 1) / ATM_CELL_PAYLOAD)
 159
 160 #define hex2int(c) ( (c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9) )
 161
 162 static struct usb_device_id udsl_usb_ids [] = {
 163         { USB_DEVICE (SPEEDTOUCH_VENDORID, SPEEDTOUCH_PRODUCTID) },
 164         { }
 165 };
 166
 167 MODULE_DEVICE_TABLE (usb, udsl_usb_ids);
 168
 169 /* receive */
 170
 171 struct udsl_receive_buffer {
 172         struct list_head list;
 173         unsigned char *base;
 174         unsigned int filled_cells;
 175 };
 176
 177 struct udsl_receiver {
 178         struct list_head list;
 179         struct udsl_receive_buffer *buffer;
 180         struct urb *urb;
 181         struct udsl_instance_data *instance;
 182 };
 183
 184 struct udsl_vcc_data {
 185         /* vpi/vci lookup */
 186         struct list_head list;
 187         short vpi;
 188         int vci;
 189         struct atm_vcc *vcc;
 190
 191         /* raw cell reassembly */
 192         struct sk_buff *sarb;
 193 };
 194
 195 /* send */
 196
 197 struct udsl_send_buffer {
 198         struct list_head list;
 199         unsigned char *base;
 200         unsigned char *free_start;
 201         unsigned int free_cells;
 202 };
 203
 204 struct udsl_sender {
 205         struct list_head list;
 206         struct udsl_send_buffer *buffer;
 207         struct urb *urb;
 208         struct udsl_instance_data *instance;
 209 };
 210
 211 struct udsl_control {
 212         struct atm_skb_data atm_data;
 213         unsigned int num_cells;
 214         unsigned int num_entire;
 215         unsigned int pdu_padding;
 216         unsigned char cell_header [ATM_CELL_HEADER];
 217         unsigned char aal5_trailer [ATM_AAL5_TRAILER];
 218 };
 219
 220 #define UDSL_SKB(x)             ((struct udsl_control *)(x)->cb)
 221
 222 /* main driver data */
 223
 224 struct udsl_instance_data {
 225         struct semaphore serialize;
 226
 227         /* USB device part */
 228         struct usb_device *usb_dev;
 229         char description [64];
 230         int firmware_loaded;
 231
 232         /* ATM device part */
 233         struct atm_dev *atm_dev;
 234         struct list_head vcc_list;
 235
 236         /* receive */
 237         struct udsl_receiver receivers [UDSL_MAX_RCV_URBS];
 238         struct udsl_receive_buffer receive_buffers [UDSL_MAX_RCV_BUFS];
 239
 240         spinlock_t receive_lock;
 241         struct list_head spare_receivers;
 242         struct list_head filled_receive_buffers;
 243
 244         struct tasklet_struct receive_tasklet;
 245         struct list_head spare_receive_buffers;
 246
 247         /* send */
 248         struct udsl_sender senders [UDSL_MAX_SND_URBS];
 249         struct udsl_send_buffer send_buffers [UDSL_MAX_SND_BUFS];
 250
 251         struct sk_buff_head sndqueue;
 252
 253         spinlock_t send_lock;
 254         struct list_head spare_senders;
 255         struct list_head spare_send_buffers;
 256
 257         struct tasklet_struct send_tasklet;
 258         struct sk_buff *current_skb;                    /* being emptied */
 259         struct udsl_send_buffer *current_buffer;        /* being filled */
 260         struct list_head filled_send_buffers;
 261 };
 262
 263 /* ATM */
 264
 265 static void udsl_atm_dev_close (struct atm_dev *dev);
 266 static int udsl_atm_open (struct atm_vcc *vcc);
 267 static void udsl_atm_close (struct atm_vcc *vcc);
 268 static int udsl_atm_ioctl (struct atm_dev *dev, unsigned int cmd, void *arg);
 269 static int udsl_atm_send (struct atm_vcc *vcc, struct sk_buff *skb);
 270 static int udsl_atm_proc_read (struct atm_dev *atm_dev, loff_t *pos, char *page);
 271
 272 static struct atmdev_ops udsl_atm_devops = {
 273         .dev_close =    udsl_atm_dev_close,
 274         .open =         udsl_atm_open,
 275         .close =        udsl_atm_close,
 276         .ioctl =        udsl_atm_ioctl,
 277         .send =         udsl_atm_send,
 278         .proc_read =    udsl_atm_proc_read,
 279         .owner =        THIS_MODULE,
 280 };
 281
 282 /* USB */
 283
 284 static int udsl_usb_probe (struct usb_interface *intf, const struct usb_device_id *id);
 285 static void udsl_usb_disconnect (struct usb_interface *intf);
 286 static int udsl_usb_ioctl (struct usb_interface *intf, unsigned int code, void *user_data);
 287
 288 static struct usb_driver udsl_usb_driver = {
 289         .owner =        THIS_MODULE,
 290         .name =         udsl_driver_name,
 291         .probe =        udsl_usb_probe,
 292         .disconnect =   udsl_usb_disconnect,
 293         .ioctl =        udsl_usb_ioctl,
 294         .id_table =     udsl_usb_ids,
 295 };
 296
 297
 298 /*************
 299 **  decode  **
 300 *************/
 301
 302 static inline struct udsl_vcc_data *udsl_find_vcc (struct udsl_instance_data *instance, short vpi, int vci)
 303 {
 304         struct udsl_vcc_data *vcc;
 305
 306         list_for_each_entry (vcc, &instance->vcc_list, list)
 307                 if ((vcc->vci == vci) && (vcc->vpi == vpi))
 308                         return vcc;
 309         return NULL;
 310 }
 311
 312 static void udsl_extract_cells (struct udsl_instance_data *instance, unsigned char *source, unsigned int howmany)
 313 {
 314         struct udsl_vcc_data *cached_vcc = NULL;
 315         struct atm_vcc *vcc;
 316         struct sk_buff *sarb;
 317         struct udsl_vcc_data *vcc_data;
 318         int cached_vci = 0;
 319         unsigned int i;
 320         int pti;
 321         int vci;
 322         short cached_vpi = 0;
 323         short vpi;
 324
 325         for (i = 0; i < howmany; i++, source += ATM_CELL_SIZE) {
 326                 vpi = ((source [0] & 0x0f) << 4) | (source [1] >> 4);
 327                 vci = ((source [1] & 0x0f) << 12) | (source [2] << 4) | (source [3] >> 4);
 328                 pti = (source [3] & 0x2) != 0;
 329
 330                 vdbg ("udsl_extract_cells: vpi %hd, vci %d, pti %d", vpi, vci, pti);
 331
 332                 if (cached_vcc && (vci == cached_vci) && (vpi == cached_vpi))
 333                         vcc_data = cached_vcc;
 334                 else if ((vcc_data = udsl_find_vcc (instance, vpi, vci))) {
 335                         cached_vcc = vcc_data;
 336                         cached_vpi = vpi;
 337                         cached_vci = vci;
 338                 } else {
 339                         dbg ("udsl_extract_cells: unknown vpi/vci (%hd/%d)!", vpi, vci);
 340                         continue;
 341                 }
 342
 343                 vcc = vcc_data->vcc;
 344                 sarb = vcc_data->sarb;
 345
 346                 if (sarb->tail + ATM_CELL_PAYLOAD > sarb->end) {
 347                         dbg ("udsl_extract_cells: buffer overrun (sarb->len %u, vcc: 0x%p)!", sarb->len, vcc);
 348                         /* discard cells already received */
 349                         skb_trim (sarb, 0);
 350                 }
 351
 352                 memcpy (sarb->tail, source + ATM_CELL_HEADER, ATM_CELL_PAYLOAD);
 353                 __skb_put (sarb, ATM_CELL_PAYLOAD);
 354
 355                 if (pti) {
 356                         struct sk_buff *skb;
 357                         unsigned int length;
 358                         unsigned int pdu_length;
 359
 360                         length = (source [ATM_CELL_SIZE - 6] << 8) + source [ATM_CELL_SIZE - 5];
 361
 362                         /* guard against overflow */
 363                         if (length > ATM_MAX_AAL5_PDU) {
 364                                 dbg ("udsl_extract_cells: bogus length %u (vcc: 0x%p)!", length, vcc);
 365                                 atomic_inc (&vcc->stats->rx_err);
 366                                 goto out;
 367                         }
 368
 369                         pdu_length = UDSL_NUM_CELLS (length) * ATM_CELL_PAYLOAD;
 370
 371                         if (sarb->len < pdu_length) {
 372                                 dbg ("udsl_extract_cells: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!", pdu_length, sarb->len, vcc);
 373                                 atomic_inc (&vcc->stats->rx_err);
 374                                 goto out;
 375                         }
 376
 377                         if (crc32_be (~0, sarb->tail - pdu_length, pdu_length) != 0xc704dd7b) {
 378                                 dbg ("udsl_extract_cells: packet failed crc check (vcc: 0x%p)!", vcc);
 379                                 atomic_inc (&vcc->stats->rx_err);
 380                                 goto out;
 381                         }
 382
 383                         vdbg ("udsl_extract_cells: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", length, pdu_length, vcc);
 384
 385                         if (!(skb = dev_alloc_skb (length))) {
 386                                 dbg ("udsl_extract_cells: no memory for skb (length: %u)!", length);
 387                                 atomic_inc (&vcc->stats->rx_drop);
 388                                 goto out;
 389                         }
 390
 391                         vdbg ("udsl_extract_cells: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", skb, skb->truesize);
 392
 393                         if (!atm_charge (vcc, skb->truesize)) {
 394                                 dbg ("udsl_extract_cells: failed atm_charge (skb->truesize: %u)!", skb->truesize);
 395                                 dev_kfree_skb (skb);
 396                                 goto out; /* atm_charge increments rx_drop */
 397                         }
 398
 399                         memcpy (skb->data, sarb->tail - pdu_length, length);
 400                         __skb_put (skb, length);
 401
 402                         vdbg ("udsl_extract_cells: sending skb 0x%p, skb->len %u, skb->truesize %u", skb, skb->len, skb->truesize);
 403
 404                         PACKETDEBUG (skb->data, skb->len);
 405
 406                         vcc->push (vcc, skb);
 407
 408                         atomic_inc (&vcc->stats->rx);
 409 out:
 410                         skb_trim (sarb, 0);
 411                 }
 412         }
 413 }
 414
 415
 416 /*************
 417 **  encode  **
 418 *************/
 419
 420 static const unsigned char zeros [ATM_CELL_PAYLOAD];
 421
 422 static void udsl_groom_skb (struct atm_vcc *vcc, struct sk_buff *skb)
 423 {
 424         struct udsl_control *ctrl = UDSL_SKB (skb);
 425         unsigned int zero_padding;
 426         u32 crc;
 427
 428         ctrl->atm_data.vcc = vcc;
 429         ctrl->cell_header [0] = vcc->vpi >> 4;
 430         ctrl->cell_header [1] = (vcc->vpi << 4) | (vcc->vci >> 12);
 431         ctrl->cell_header [2] = vcc->vci >> 4;
 432         ctrl->cell_header [3] = vcc->vci << 4;
 433         ctrl->cell_header [4] = 0xec;
 434
 435         ctrl->num_cells = UDSL_NUM_CELLS (skb->len);
 436         ctrl->num_entire = skb->len / ATM_CELL_PAYLOAD;
 437
 438         zero_padding = ctrl->num_cells * ATM_CELL_PAYLOAD - skb->len - ATM_AAL5_TRAILER;
 439
 440         if (ctrl->num_entire + 1 < ctrl->num_cells)
 441                 ctrl->pdu_padding = zero_padding - (ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
 442         else
 443                 ctrl->pdu_padding = zero_padding;
 444
 445         ctrl->aal5_trailer [0] = 0; /* UU = 0 */
 446         ctrl->aal5_trailer [1] = 0; /* CPI = 0 */
 447         ctrl->aal5_trailer [2] = skb->len >> 8;
 448         ctrl->aal5_trailer [3] = skb->len;
 449
 450         crc = crc32_be (~0, skb->data, skb->len);
 451         crc = crc32_be (crc, zeros, zero_padding);
 452         crc = crc32_be (crc, ctrl->aal5_trailer, 4);
 453         crc = ~crc;
 454
 455         ctrl->aal5_trailer [4] = crc >> 24;
 456         ctrl->aal5_trailer [5] = crc >> 16;
 457         ctrl->aal5_trailer [6] = crc >> 8;
 458         ctrl->aal5_trailer [7] = crc;
 459 }
 460
 461 static unsigned int udsl_write_cells (unsigned int howmany, struct sk_buff *skb, unsigned char **target_p)
 462 {
 463         struct udsl_control *ctrl = UDSL_SKB (skb);
 464         unsigned char *target = *target_p;
 465         unsigned int nc, ne, i;
 466
 467         vdbg ("udsl_write_cells: howmany=%u, skb->len=%d, num_cells=%u, num_entire=%u, pdu_padding=%u", howmany, skb->len, ctrl->num_cells, ctrl->num_entire, ctrl->pdu_padding);
 468
 469         nc = ctrl->num_cells;
 470         ne = min (howmany, ctrl->num_entire);
 471
 472         for (i = 0; i < ne; i++) {
 473                 memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
 474                 target += ATM_CELL_HEADER;
 475                 memcpy (target, skb->data, ATM_CELL_PAYLOAD);
 476                 target += ATM_CELL_PAYLOAD;
 477                 __skb_pull (skb, ATM_CELL_PAYLOAD);
 478         }
 479
 480         ctrl->num_entire -= ne;
 481
 482         if (!(ctrl->num_cells -= ne) || !(howmany -= ne))
 483                 goto out;
 484
 485         memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
 486         target += ATM_CELL_HEADER;
 487         memcpy (target, skb->data, skb->len);
 488         target += skb->len;
 489         __skb_pull (skb, skb->len);
 490         memset (target, 0, ctrl->pdu_padding);
 491         target += ctrl->pdu_padding;
 492
 493         if (--ctrl->num_cells) {
 494                 if (!--howmany) {
 495                         ctrl->pdu_padding = ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
 496                         goto out;
 497                 }
 498
 499                 memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
 500                 target += ATM_CELL_HEADER;
 501                 memset (target, 0, ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
 502                 target += ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
 503
 504                 DEBUG_ON (--ctrl->num_cells);
 505         }
 506
 507         memcpy (target, ctrl->aal5_trailer, ATM_AAL5_TRAILER);
 508         target += ATM_AAL5_TRAILER;
 509         /* set pti bit in last cell */
 510         *(target + 3 - ATM_CELL_SIZE) |= 0x2;
 511
 512 out:
 513         *target_p = target;
 514         return nc - ctrl->num_cells;
 515 }
 516
 517
 518 /**************
 519 **  receive  **
 520 **************/
 521
 522 static void udsl_complete_receive (struct urb *urb, struct pt_regs *regs)
 523 {
 524         struct udsl_receive_buffer *buf;
 525         struct udsl_instance_data *instance;
 526         struct udsl_receiver *rcv;
 527         unsigned long flags;
 528
 529         if (!urb || !(rcv = urb->context)) {
 530                 dbg ("udsl_complete_receive: bad urb!");
 531                 return;
 532         }
 533
 534         instance = rcv->instance;
 535         buf = rcv->buffer;
 536
 537         buf->filled_cells = urb->actual_length / ATM_CELL_SIZE;
 538
 539         vdbg ("udsl_complete_receive: urb 0x%p, status %d, actual_length %d, filled_cells %u, rcv 0x%p, buf 0x%p", urb, urb->status, urb->actual_length, buf->filled_cells, rcv, buf);
 540
 541         DEBUG_ON (buf->filled_cells > rcv_buf_size);
 542
 543         /* may not be in_interrupt() */
 544         spin_lock_irqsave (&instance->receive_lock, flags);
 545         list_add (&rcv->list, &instance->spare_receivers);
 546         list_add_tail (&buf->list, &instance->filled_receive_buffers);
 547         if (likely (!urb->status))
 548                 tasklet_schedule (&instance->receive_tasklet);
 549         spin_unlock_irqrestore (&instance->receive_lock, flags);
 550 }
 551
 552 static void udsl_process_receive (unsigned long data)
 553 {
 554         struct udsl_receive_buffer *buf;
 555         struct udsl_instance_data *instance = (struct udsl_instance_data *) data;
 556         struct udsl_receiver *rcv;
 557         int err;
 558
 559 made_progress:
 560         while (!list_empty (&instance->spare_receive_buffers)) {
 561                 spin_lock_irq (&instance->receive_lock);
 562                 if (list_empty (&instance->spare_receivers)) {
 563                         spin_unlock_irq (&instance->receive_lock);
 564                         break;
 565                 }
 566                 rcv = list_entry (instance->spare_receivers.next, struct udsl_receiver, list);
 567                 list_del (&rcv->list);
 568                 spin_unlock_irq (&instance->receive_lock);
 569
 570                 buf = list_entry (instance->spare_receive_buffers.next, struct udsl_receive_buffer, list);
 571                 list_del (&buf->list);
 572
 573                 rcv->buffer = buf;
 574
 575                 usb_fill_bulk_urb (rcv->urb,
 576                                    instance->usb_dev,
 577                                    usb_rcvbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
 578                                    buf->base,
 579                                    rcv_buf_size * ATM_CELL_SIZE,
 580                                    udsl_complete_receive,
 581                                    rcv);
 582
 583                 vdbg ("udsl_process_receive: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 584
 585                 if ((err = usb_submit_urb(rcv->urb, GFP_ATOMIC)) < 0) {
 586                         dbg ("udsl_process_receive: urb submission failed (%d)!", err);
 587                         list_add (&buf->list, &instance->spare_receive_buffers);
 588                         spin_lock_irq (&instance->receive_lock);
 589                         list_add (&rcv->list, &instance->spare_receivers);
 590                         spin_unlock_irq (&instance->receive_lock);
 591                         break;
 592                 }
 593         }
 594
 595         spin_lock_irq (&instance->receive_lock);
 596         if (list_empty (&instance->filled_receive_buffers)) {
 597                 spin_unlock_irq (&instance->receive_lock);
 598                 return; /* done - no more buffers */
 599         }
 600         buf = list_entry (instance->filled_receive_buffers.next, struct udsl_receive_buffer, list);
 601         list_del (&buf->list);
 602         spin_unlock_irq (&instance->receive_lock);
 603         vdbg ("udsl_process_receive: processing buf 0x%p", buf);
 604         udsl_extract_cells (instance, buf->base, buf->filled_cells);
 605         list_add (&buf->list, &instance->spare_receive_buffers);
 606         goto made_progress;
 607 }
 608
 609
 610 /***********
 611 **  send  **
 612 ***********/
 613
 614 static void udsl_complete_send (struct urb *urb, struct pt_regs *regs)
 615 {
 616         struct udsl_instance_data *instance;
 617         struct udsl_sender *snd;
 618         unsigned long flags;
 619
 620         if (!urb || !(snd = urb->context) || !(instance = snd->instance)) {
 621                 dbg ("udsl_complete_send: bad urb!");
 622                 return;
 623         }
 624
 625         vdbg ("udsl_complete_send: urb 0x%p, status %d, snd 0x%p, buf 0x%p", urb, urb->status, snd, snd->buffer);
 626
 627         /* may not be in_interrupt() */
 628         spin_lock_irqsave (&instance->send_lock, flags);
 629         list_add (&snd->list, &instance->spare_senders);
 630         list_add (&snd->buffer->list, &instance->spare_send_buffers);
 631         tasklet_schedule (&instance->send_tasklet);
 632         spin_unlock_irqrestore (&instance->send_lock, flags);
 633 }
 634
 635 static void udsl_process_send (unsigned long data)
 636 {
 637         struct udsl_send_buffer *buf;
 638         struct udsl_instance_data *instance = (struct udsl_instance_data *) data;
 639         struct sk_buff *skb;
 640         struct udsl_sender *snd;
 641         int err;
 642         unsigned int num_written;
 643
 644 made_progress:
 645         spin_lock_irq (&instance->send_lock);
 646         while (!list_empty (&instance->spare_senders)) {
 647                 if (!list_empty (&instance->filled_send_buffers)) {
 648                         buf = list_entry (instance->filled_send_buffers.next, struct udsl_send_buffer, list);
 649                         list_del (&buf->list);
 650                 } else if ((buf = instance->current_buffer)) {
 651                         instance->current_buffer = NULL;
 652                 } else /* all buffers empty */
 653                         break;
 654
 655                 snd = list_entry (instance->spare_senders.next, struct udsl_sender, list);
 656                 list_del (&snd->list);
 657                 spin_unlock_irq (&instance->send_lock);
 658
 659                 snd->buffer = buf;
 660                 usb_fill_bulk_urb (snd->urb,
 661                                    instance->usb_dev,
 662                                    usb_sndbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
 663                                    buf->base,
 664                                    (snd_buf_size - buf->free_cells) * ATM_CELL_SIZE,
 665                                    udsl_complete_send,
 666                                    snd);
 667
 668                 vdbg ("udsl_process_send: submitting urb 0x%p (%d cells), snd 0x%p, buf 0x%p", snd->urb, snd_buf_size - buf->free_cells, snd, buf);
 669
 670                 if ((err = usb_submit_urb(snd->urb, GFP_ATOMIC)) < 0) {
 671                         dbg ("udsl_process_send: urb submission failed (%d)!", err);
 672                         spin_lock_irq (&instance->send_lock);
 673                         list_add (&snd->list, &instance->spare_senders);
 674                         spin_unlock_irq (&instance->send_lock);
 675                         list_add (&buf->list, &instance->filled_send_buffers);
 676                         return; /* bail out */
 677                 }
 678
 679                 spin_lock_irq (&instance->send_lock);
 680         } /* while */
 681         spin_unlock_irq (&instance->send_lock);
 682
 683         if (!instance->current_skb && !(instance->current_skb = skb_dequeue (&instance->sndqueue)))
 684                 return; /* done - no more skbs */
 685
 686         skb = instance->current_skb;
 687
 688         if (!(buf = instance->current_buffer)) {
 689                 spin_lock_irq (&instance->send_lock);
 690                 if (list_empty (&instance->spare_send_buffers)) {
 691                         instance->current_buffer = NULL;
 692                         spin_unlock_irq (&instance->send_lock);
 693                         return; /* done - no more buffers */
 694                 }
 695                 buf = list_entry (instance->spare_send_buffers.next, struct udsl_send_buffer, list);
 696                 list_del (&buf->list);
 697                 spin_unlock_irq (&instance->send_lock);
 698
 699                 buf->free_start = buf->base;
 700                 buf->free_cells = snd_buf_size;
 701
 702                 instance->current_buffer = buf;
 703         }
 704
 705         num_written = udsl_write_cells (buf->free_cells, skb, &buf->free_start);
 706
 707         vdbg ("udsl_process_send: wrote %u cells from skb 0x%p to buffer 0x%p", num_written, skb, buf);
 708
 709         if (!(buf->free_cells -= num_written)) {
 710                 list_add_tail (&buf->list, &instance->filled_send_buffers);
 711                 instance->current_buffer = NULL;
 712         }
 713
 714         vdbg ("udsl_process_send: buffer contains %d cells, %d left", snd_buf_size - buf->free_cells, buf->free_cells);
 715
 716         if (!UDSL_SKB (skb)->num_cells) {
 717                 struct atm_vcc *vcc = UDSL_SKB (skb)->atm_data.vcc;
 718
 719                 if (vcc->pop)
 720                         vcc->pop (vcc, skb);
 721                 else
 722                         dev_kfree_skb (skb);
 723                 instance->current_skb = NULL;
 724
 725                 atomic_inc (&vcc->stats->tx);
 726         }
 727
 728         goto made_progress;
 729 }
 730
 731 static void udsl_cancel_send (struct udsl_instance_data *instance, struct atm_vcc *vcc)
 732 {
 733         struct sk_buff *skb, *n;
 734
 735         dbg ("udsl_cancel_send entered");
 736         spin_lock_irq (&instance->sndqueue.lock);
 737         for (skb = instance->sndqueue.next, n = skb->next; skb != (struct sk_buff *)&instance->sndqueue; skb = n, n = skb->next)
 738                 if (UDSL_SKB (skb)->atm_data.vcc == vcc) {
 739                         dbg ("udsl_cancel_send: popping skb 0x%p", skb);
 740                         __skb_unlink (skb, &instance->sndqueue);
 741                         if (vcc->pop)
 742                                 vcc->pop (vcc, skb);
 743                         else
 744                                 dev_kfree_skb (skb);
 745                 }
 746         spin_unlock_irq (&instance->sndqueue.lock);
 747
 748         tasklet_disable (&instance->send_tasklet);
 749         if ((skb = instance->current_skb) && (UDSL_SKB (skb)->atm_data.vcc == vcc)) {
 750                 dbg ("udsl_cancel_send: popping current skb (0x%p)", skb);
 751                 instance->current_skb = NULL;
 752                 if (vcc->pop)
 753                         vcc->pop (vcc, skb);
 754                 else
 755                         dev_kfree_skb (skb);
 756         }
 757         tasklet_enable (&instance->send_tasklet);
 758         dbg ("udsl_cancel_send done");
 759 }
 760
 761 static int udsl_atm_send (struct atm_vcc *vcc, struct sk_buff *skb)
 762 {
 763         struct udsl_instance_data *instance = vcc->dev->dev_data;
 764
 765         vdbg ("udsl_atm_send called (skb 0x%p, len %u)", skb, skb->len);
 766
 767         if (!instance || !instance->usb_dev) {
 768                 dbg ("udsl_atm_send: NULL data!");
 769                 return -ENODEV;
 770         }
 771
 772         if (vcc->qos.aal != ATM_AAL5) {
 773                 dbg ("udsl_atm_send: unsupported ATM type %d!", vcc->qos.aal);
 774                 return -EINVAL;
 775         }
 776
 777         if (skb->len > ATM_MAX_AAL5_PDU) {
 778                 dbg ("udsl_atm_send: packet too long (%d vs %d)!", skb->len, ATM_MAX_AAL5_PDU);
 779                 return -EINVAL;
 780         }
 781
 782         PACKETDEBUG (skb->data, skb->len);
 783
 784         udsl_groom_skb (vcc, skb);
 785         skb_queue_tail (&instance->sndqueue, skb);
 786         tasklet_schedule (&instance->send_tasklet);
 787
 788         return 0;
 789 }
 790
 791
 792 /**********
 793 **  ATM  **
 794 **********/
 795
 796 static void udsl_atm_dev_close (struct atm_dev *dev)
 797 {
 798         struct udsl_instance_data *instance = dev->dev_data;
 799
 800         if (!instance) {
 801                 dbg ("udsl_atm_dev_close: NULL instance!");
 802                 return;
 803         }
 804
 805         dbg ("udsl_atm_dev_close: queue has %u elements", instance->sndqueue.qlen);
 806
 807         tasklet_kill (&instance->receive_tasklet);
 808         tasklet_kill (&instance->send_tasklet);
 809         kfree (instance);
 810         dev->dev_data = NULL;
 811 }
 812
 813 static int udsl_atm_proc_read (struct atm_dev *atm_dev, loff_t *pos, char *page)
 814 {
 815         struct udsl_instance_data *instance = atm_dev->dev_data;
 816         int left = *pos;
 817
 818         if (!instance) {
 819                 dbg ("udsl_atm_proc_read: NULL instance!");
 820                 return -ENODEV;
 821         }
 822
 823         if (!left--)
 824                 return sprintf (page, "%s\n", instance->description);
 825
 826         if (!left--)
 827                 return sprintf (page, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
 828                                 atm_dev->esi [0], atm_dev->esi [1], atm_dev->esi [2],
 829                                 atm_dev->esi [3], atm_dev->esi [4], atm_dev->esi [5]);
 830
 831         if (!left--)
 832                 return sprintf (page, "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
 833                                 atomic_read (&atm_dev->stats.aal5.tx),
 834                                 atomic_read (&atm_dev->stats.aal5.tx_err),
 835                                 atomic_read (&atm_dev->stats.aal5.rx),
 836                                 atomic_read (&atm_dev->stats.aal5.rx_err),
 837                                 atomic_read (&atm_dev->stats.aal5.rx_drop));
 838
 839         if (!left--) {
 840                 switch (atm_dev->signal) {
 841                 case ATM_PHY_SIG_FOUND:
 842                         sprintf (page, "Line up");
 843                         break;
 844                 case ATM_PHY_SIG_LOST:
 845                         sprintf (page, "Line down");
 846                         break;
 847                 default:
 848                         sprintf (page, "Line state unknown");
 849                         break;
 850                 }
 851
 852                 if (instance->usb_dev) {
 853                         if (!instance->firmware_loaded)
 854                                 strcat (page, ", no firmware\n");
 855                         else
 856                                 strcat (page, ", firmware loaded\n");
 857                 } else
 858                         strcat (page, ", disconnected\n");
 859
 860                 return strlen (page);
 861         }
 862
 863         return 0;
 864 }
 865
 866 static int udsl_atm_open (struct atm_vcc *vcc)
 867 {
 868         struct udsl_instance_data *instance = vcc->dev->dev_data;
 869         struct udsl_vcc_data *new;
 870         unsigned int max_pdu;
 871         int vci = vcc->vci;
 872         short vpi = vcc->vpi;
 873
 874         dbg ("udsl_atm_open: vpi %hd, vci %d", vpi, vci);
 875
 876         if (!instance || !instance->usb_dev) {
 877                 dbg ("udsl_atm_open: NULL data!");
 878                 return -ENODEV;
 879         }
 880
 881         /* only support AAL5 */
 882         if ((vcc->qos.aal != ATM_AAL5) || (vcc->qos.rxtp.max_sdu < 0) || (vcc->qos.rxtp.max_sdu > ATM_MAX_AAL5_PDU)) {
 883                 dbg ("udsl_atm_open: unsupported ATM type %d!", vcc->qos.aal);
 884                 return -EINVAL;
 885         }
 886
 887         if (!instance->firmware_loaded) {
 888                 dbg ("udsl_atm_open: firmware not loaded!");
 889                 return -EAGAIN;
 890         }
 891
 892         down (&instance->serialize); /* vs self, udsl_atm_close */
 893
 894         if (udsl_find_vcc (instance, vpi, vci)) {
 895                 dbg ("udsl_atm_open: %hd/%d already in use!", vpi, vci);
 896                 up (&instance->serialize);
 897                 return -EADDRINUSE;
 898         }
 899
 900         if (!(new = kmalloc (sizeof (struct udsl_vcc_data), GFP_KERNEL))) {
 901                 dbg ("udsl_atm_open: no memory for vcc_data!");
 902                 up (&instance->serialize);
 903                 return -ENOMEM;
 904         }
 905
 906         memset (new, 0, sizeof (struct udsl_vcc_data));
 907         new->vcc = vcc;
 908         new->vpi = vpi;
 909         new->vci = vci;
 910
 911         /* udsl_extract_cells requires at least one cell */
 912         max_pdu = max (1, UDSL_NUM_CELLS (vcc->qos.rxtp.max_sdu)) * ATM_CELL_PAYLOAD;
 913         if (!(new->sarb = alloc_skb (max_pdu, GFP_KERNEL))) {
 914                 dbg ("udsl_atm_open: no memory for SAR buffer!");
 915                 kfree (new);
 916                 up (&instance->serialize);
 917                 return -ENOMEM;
 918         }
 919
 920         vcc->dev_data = new;
 921
 922         tasklet_disable (&instance->receive_tasklet);
 923         list_add (&new->list, &instance->vcc_list);
 924         tasklet_enable (&instance->receive_tasklet);
 925
 926         set_bit (ATM_VF_ADDR, &vcc->flags);
 927         set_bit (ATM_VF_PARTIAL, &vcc->flags);
 928         set_bit (ATM_VF_READY, &vcc->flags);
 929
 930         up (&instance->serialize);
 931
 932         tasklet_schedule (&instance->receive_tasklet);
 933
 934         dbg ("udsl_atm_open: allocated vcc data 0x%p (max_pdu: %u)", new, max_pdu);
 935
 936         return 0;
 937 }
 938
 939 static void udsl_atm_close (struct atm_vcc *vcc)
 940 {
 941         struct udsl_instance_data *instance = vcc->dev->dev_data;
 942         struct udsl_vcc_data *vcc_data = vcc->dev_data;
 943
 944         dbg ("udsl_atm_close called");
 945
 946         if (!instance || !vcc_data) {
 947                 dbg ("udsl_atm_close: NULL data!");
 948                 return;
 949         }
 950
 951         dbg ("udsl_atm_close: deallocating vcc 0x%p with vpi %d vci %d", vcc_data, vcc_data->vpi, vcc_data->vci);
 952
 953         udsl_cancel_send (instance, vcc);
 954
 955         down (&instance->serialize); /* vs self, udsl_atm_open */
 956
 957         tasklet_disable (&instance->receive_tasklet);
 958         list_del (&vcc_data->list);
 959         tasklet_enable (&instance->receive_tasklet);
 960
 961         kfree_skb (vcc_data->sarb);
 962         vcc_data->sarb = NULL;
 963
 964         kfree (vcc_data);
 965         vcc->dev_data = NULL;
 966
 967         vcc->vpi = ATM_VPI_UNSPEC;
 968         vcc->vci = ATM_VCI_UNSPEC;
 969         clear_bit (ATM_VF_READY, &vcc->flags);
 970         clear_bit (ATM_VF_PARTIAL, &vcc->flags);
 971         clear_bit (ATM_VF_ADDR, &vcc->flags);
 972
 973         up (&instance->serialize);
 974
 975         dbg ("udsl_atm_close successful");
 976 }
 977
 978 static int udsl_atm_ioctl (struct atm_dev *dev, unsigned int cmd, void *arg)
 979 {
 980         switch (cmd) {
 981         case ATM_QUERYLOOP:
 982                 return put_user (ATM_LM_NONE, (int *) arg) ? -EFAULT : 0;
 983         default:
 984                 return -ENOIOCTLCMD;
 985         }
 986 }
 987
 988
 989 /**********
 990 **  USB  **
 991 **********/
 992
 993 static int udsl_set_alternate (struct udsl_instance_data *instance)
 994 {
 995         down (&instance->serialize); /* vs self */
 996         if (!instance->firmware_loaded) {
 997                 int ret;
 998
 999                 if ((ret = usb_set_interface (instance->usb_dev, 1, 1)) < 0) {
1000                         dbg ("udsl_set_alternate: usb_set_interface returned %d!", ret);
1001                         up (&instance->serialize);
1002                         return ret;
1003                 }
1004                 instance->firmware_loaded = 1;
1005         }
1006         up (&instance->serialize);
1007
1008         tasklet_schedule (&instance->receive_tasklet);
1009
1010         return 0;
1011 }
1012
1013 static int udsl_usb_ioctl (struct usb_interface *intf, unsigned int code, void *user_data)
1014 {
1015         struct udsl_instance_data *instance = usb_get_intfdata (intf);
1016
1017         dbg ("udsl_usb_ioctl entered");
1018
1019         if (!instance) {
1020                 dbg ("udsl_usb_ioctl: NULL instance!");
1021                 return -ENODEV;
1022         }
1023
1024         switch (code) {
1025         case UDSL_IOCTL_LINE_UP:
1026                 instance->atm_dev->signal = ATM_PHY_SIG_FOUND;
1027                 return udsl_set_alternate (instance);
1028         case UDSL_IOCTL_LINE_DOWN:
1029                 instance->atm_dev->signal = ATM_PHY_SIG_LOST;
1030                 return 0;
1031         default:
1032                 return -ENOTTY;
1033         }
1034 }
1035
1036 static int udsl_usb_probe (struct usb_interface *intf, const struct usb_device_id *id)
1037 {
1038         struct usb_device *dev = interface_to_usbdev(intf);
1039         int ifnum = intf->altsetting->desc.bInterfaceNumber;
1040         struct udsl_instance_data *instance;
1041         unsigned char mac_str [13];
1042         int i, length;
1043         char *buf;
1044
1045         dbg ("udsl_usb_probe: trying device with vendor=0x%x, product=0x%x, ifnum %d",
1046              dev->descriptor.idVendor, dev->descriptor.idProduct, ifnum);
1047
1048         if ((dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) ||
1049             (dev->descriptor.idVendor != SPEEDTOUCH_VENDORID) ||
1050             (dev->descriptor.idProduct != SPEEDTOUCH_PRODUCTID) || (ifnum != 1))
1051                 return -ENODEV;
1052
1053         dbg ("udsl_usb_probe: device accepted");
1054
1055         /* instance init */
1056         if (!(instance = kmalloc (sizeof (struct udsl_instance_data), GFP_KERNEL))) {
1057                 dbg ("udsl_usb_probe: no memory for instance data!");
1058                 return -ENOMEM;
1059         }
1060
1061         memset (instance, 0, sizeof (struct udsl_instance_data));
1062
1063         init_MUTEX (&instance->serialize);
1064
1065         instance->usb_dev = dev;
1066
1067         INIT_LIST_HEAD (&instance->vcc_list);
1068
1069         spin_lock_init (&instance->receive_lock);
1070         INIT_LIST_HEAD (&instance->spare_receivers);
1071         INIT_LIST_HEAD (&instance->filled_receive_buffers);
1072
1073         tasklet_init (&instance->receive_tasklet, udsl_process_receive, (unsigned long) instance);
1074         INIT_LIST_HEAD (&instance->spare_receive_buffers);
1075
1076         skb_queue_head_init (&instance->sndqueue);
1077
1078         spin_lock_init (&instance->send_lock);
1079         INIT_LIST_HEAD (&instance->spare_senders);
1080         INIT_LIST_HEAD (&instance->spare_send_buffers);
1081
1082         tasklet_init (&instance->send_tasklet, udsl_process_send, (unsigned long) instance);
1083         INIT_LIST_HEAD (&instance->filled_send_buffers);
1084
1085         /* receive init */
1086         for (i = 0; i < num_rcv_urbs; i++) {
1087                 struct udsl_receiver *rcv = &(instance->receivers [i]);
1088
1089                 if (!(rcv->urb = usb_alloc_urb (0, GFP_KERNEL))) {
1090                         dbg ("udsl_usb_probe: no memory for receive urb %d!", i);
1091                         goto fail;
1092                 }
1093
1094                 rcv->instance = instance;
1095
1096                 list_add (&rcv->list, &instance->spare_receivers);
1097         }
1098
1099         for (i = 0; i < num_rcv_bufs; i++) {
1100                 struct udsl_receive_buffer *buf = &(instance->receive_buffers [i]);
1101
1102                 if (!(buf->base = kmalloc (rcv_buf_size * ATM_CELL_SIZE, GFP_KERNEL))) {
1103                         dbg ("udsl_usb_probe: no memory for receive buffer %d!", i);
1104                         goto fail;
1105                 }
1106
1107                 list_add (&buf->list, &instance->spare_receive_buffers);
1108         }
1109
1110         /* send init */
1111         for (i = 0; i < num_snd_urbs; i++) {
1112                 struct udsl_sender *snd = &(instance->senders [i]);
1113
1114                 if (!(snd->urb = usb_alloc_urb (0, GFP_KERNEL))) {
1115                         dbg ("udsl_usb_probe: no memory for send urb %d!", i);
1116                         goto fail;
1117                 }
1118
1119                 snd->instance = instance;
1120
1121                 list_add (&snd->list, &instance->spare_senders);
1122         }
1123
1124         for (i = 0; i < num_snd_bufs; i++) {
1125                 struct udsl_send_buffer *buf = &(instance->send_buffers [i]);
1126
1127                 if (!(buf->base = kmalloc (snd_buf_size * ATM_CELL_SIZE, GFP_KERNEL))) {
1128                         dbg ("udsl_usb_probe: no memory for send buffer %d!", i);
1129                         goto fail;
1130                 }
1131
1132                 list_add (&buf->list, &instance->spare_send_buffers);
1133         }
1134
1135         /* ATM init */
1136         if (!(instance->atm_dev = atm_dev_register (udsl_driver_name, &udsl_atm_devops, -1, 0))) {
1137                 dbg ("udsl_usb_probe: failed to register ATM device!");
1138                 goto fail;
1139         }
1140
1141         instance->atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
1142         instance->atm_dev->ci_range.vci_bits = ATM_CI_MAX;
1143         instance->atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
1144
1145         /* temp init ATM device, set to 128kbit */
1146         instance->atm_dev->link_rate = 128 * 1000 / 424;
1147
1148         /* set MAC address, it is stored in the serial number */
1149         memset (instance->atm_dev->esi, 0, sizeof (instance->atm_dev->esi));
1150         if (usb_string (dev, dev->descriptor.iSerialNumber, mac_str, sizeof (mac_str)) == 12)
1151                 for (i = 0; i < 6; i++)
1152                         instance->atm_dev->esi [i] = (hex2int (mac_str [i * 2]) * 16) + (hex2int (mac_str [i * 2 + 1]));
1153
1154         /* device description */
1155         buf = instance->description;
1156         length = sizeof (instance->description);
1157
1158         if ((i = usb_string (dev, dev->descriptor.iProduct, buf, length)) < 0)
1159                 goto finish;
1160
1161         buf += i;
1162         length -= i;
1163
1164         i = scnprintf (buf, length, " (");
1165         buf += i;
1166         length -= i;
1167
1168         if (length <= 0 || (i = usb_make_path (dev, buf, length)) < 0)
1169                 goto finish;
1170
1171         buf += i;
1172         length -= i;
1173
1174         snprintf (buf, length, ")");
1175
1176 finish:
1177         /* ready for ATM callbacks */
1178         wmb ();
1179         instance->atm_dev->dev_data = instance;
1180
1181         usb_set_intfdata (intf, instance);
1182
1183         return 0;
1184
1185 fail:
1186         for (i = 0; i < num_snd_bufs; i++)
1187                 kfree (instance->send_buffers [i].base);
1188
1189         for (i = 0; i < num_snd_urbs; i++)
1190                 usb_free_urb (instance->senders [i].urb);
1191
1192         for (i = 0; i < num_rcv_bufs; i++)
1193                 kfree (instance->receive_buffers [i].base);
1194
1195         for (i = 0; i < num_rcv_urbs; i++)
1196                 usb_free_urb (instance->receivers [i].urb);
1197
1198         kfree (instance);
1199
1200         return -ENOMEM;
1201 }
1202
1203 static void udsl_usb_disconnect (struct usb_interface *intf)
1204 {
1205         struct udsl_instance_data *instance = usb_get_intfdata (intf);
1206         struct list_head *pos;
1207         unsigned int count;
1208         int result, i;
1209
1210         dbg ("udsl_usb_disconnect entered");
1211
1212         usb_set_intfdata (intf, NULL);
1213
1214         if (!instance) {
1215                 dbg ("udsl_usb_disconnect: NULL instance!");
1216                 return;
1217         }
1218
1219         /* receive finalize */
1220         tasklet_disable (&instance->receive_tasklet);
1221
1222         for (i = 0; i < num_rcv_urbs; i++)
1223                 if ((result = usb_unlink_urb (instance->receivers [i].urb)) < 0)
1224                         dbg ("udsl_usb_disconnect: usb_unlink_urb on receive urb %d returned %d!", i, result);
1225
1226         /* wait for completion handlers to finish */
1227         do {
1228                 count = 0;
1229                 spin_lock_irq (&instance->receive_lock);
1230                 list_for_each (pos, &instance->spare_receivers)
1231                         DEBUG_ON (++count > num_rcv_urbs);
1232                 spin_unlock_irq (&instance->receive_lock);
1233
1234                 dbg ("udsl_usb_disconnect: found %u spare receivers", count);
1235
1236                 if (count == num_rcv_urbs)
1237                         break;
1238
1239                 set_current_state (TASK_RUNNING);
1240                 schedule ();
1241         } while (1);
1242
1243         /* no need to take the spinlock */
1244         INIT_LIST_HEAD (&instance->filled_receive_buffers);
1245         INIT_LIST_HEAD (&instance->spare_receive_buffers);
1246
1247         tasklet_enable (&instance->receive_tasklet);
1248
1249         for (i = 0; i < num_rcv_urbs; i++)
1250                 usb_free_urb (instance->receivers [i].urb);
1251
1252         for (i = 0; i < num_rcv_bufs; i++)
1253                 kfree (instance->receive_buffers [i].base);
1254
1255         /* send finalize */
1256         tasklet_disable (&instance->send_tasklet);
1257
1258         for (i = 0; i < num_snd_urbs; i++)
1259                 if ((result = usb_unlink_urb (instance->senders [i].urb)) < 0)
1260                         dbg ("udsl_usb_disconnect: usb_unlink_urb on send urb %d returned %d!", i, result);
1261
1262         /* wait for completion handlers to finish */
1263         do {
1264                 count = 0;
1265                 spin_lock_irq (&instance->send_lock);
1266                 list_for_each (pos, &instance->spare_senders)
1267                         DEBUG_ON (++count > num_snd_urbs);
1268                 spin_unlock_irq (&instance->send_lock);
1269
1270                 dbg ("udsl_usb_disconnect: found %u spare senders", count);
1271
1272                 if (count == num_snd_urbs)
1273                         break;
1274
1275                 set_current_state (TASK_RUNNING);
1276                 schedule ();
1277         } while (1);
1278
1279         /* no need to take the spinlock */
1280         INIT_LIST_HEAD (&instance->spare_senders);
1281         INIT_LIST_HEAD (&instance->spare_send_buffers);
1282         instance->current_buffer = NULL;
1283
1284         tasklet_enable (&instance->send_tasklet);
1285
1286         for (i = 0; i < num_snd_urbs; i++)
1287                 usb_free_urb (instance->senders [i].urb);
1288
1289         for (i = 0; i < num_snd_bufs; i++)
1290                 kfree (instance->send_buffers [i].base);
1291
1292         wmb ();
1293         instance->usb_dev = NULL;
1294
1295         /* ATM finalize */
1296         shutdown_atm_dev (instance->atm_dev); /* frees instance, kills tasklets */
1297 }
1298
1299
1300 /***********
1301 **  init  **
1302 ***********/
1303
1304 static int __init udsl_usb_init (void)
1305 {
1306         dbg ("udsl_usb_init: driver version " DRIVER_VERSION);
1307
1308         if (sizeof (struct udsl_control) > sizeof (((struct sk_buff *)0)->cb)) {
1309                 printk (KERN_ERR __FILE__ ": unusable with this kernel!\n");
1310                 return -EIO;
1311         }
1312
1313         if ((num_rcv_urbs > UDSL_MAX_RCV_URBS) || (num_snd_urbs > UDSL_MAX_SND_URBS) ||
1314             (num_rcv_bufs > UDSL_MAX_RCV_BUFS) || (num_snd_bufs > UDSL_MAX_SND_BUFS) ||
1315             (rcv_buf_size > UDSL_MAX_RCV_BUF_SIZE) || (snd_buf_size > UDSL_MAX_SND_BUF_SIZE))
1316                 return -EINVAL;
1317
1318         return usb_register (&udsl_usb_driver);
1319 }
1320
1321 static void __exit udsl_usb_cleanup (void)
1322 {
1323         dbg ("udsl_usb_cleanup entered");
1324
1325         usb_deregister (&udsl_usb_driver);
1326 }
1327
1328 module_init (udsl_usb_init);
1329 module_exit (udsl_usb_cleanup);
1330
1331 MODULE_AUTHOR (DRIVER_AUTHOR);
1332 MODULE_DESCRIPTION (DRIVER_DESC);
1333 MODULE_LICENSE ("GPL");
1334
1335
1336 /************
1337 **  debug  **
1338 ************/
1339
1340 #ifdef VERBOSE_DEBUG
1341 static int udsl_print_packet (const unsigned char *data, int len)
1342 {
1343         unsigned char buffer [256];
1344         int i = 0, j = 0;
1345
1346         for (i = 0; i < len;) {
1347                 buffer [0] = '\0';
1348                 sprintf (buffer, "%.3d :", i);
1349                 for (j = 0; (j < 16) && (i < len); j++, i++) {
1350                         sprintf (buffer, "%s %2.2x", buffer, data [i]);
1351                 }
1352                 dbg ("%s", buffer);
1353         }
1354         return i;
1355 }
1356 #endif