drivers/usb/atm/usb_atm.c

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