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     "Generic USB ATM/DSL I/O, 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 inline void udsl_fill_cell_header(unsigned char *target, struct atm_vcc *vcc)
 315 {
 316         target[0] = vcc->vpi >> 4;
 317         target[1] = (vcc->vpi << 4) | (vcc->vci >> 12);
 318         target[2] = vcc->vci >> 4;
 319         target[3] = vcc->vci << 4;
 320         target[4] = 0xec;
 321 }
 322
 323 static const unsigned char zeros[ATM_CELL_PAYLOAD];
 324
 325 static void udsl_groom_skb(struct atm_vcc *vcc, struct sk_buff *skb)
 326 {
 327         struct udsl_control *ctrl = UDSL_SKB(skb);
 328         unsigned int zero_padding;
 329         u32 crc;
 330
 331         ctrl->atm_data.vcc = vcc;
 332
 333         ctrl->num_cells = UDSL_NUM_CELLS(skb->len);
 334         ctrl->num_entire = skb->len / ATM_CELL_PAYLOAD;
 335
 336         zero_padding = ctrl->num_cells * ATM_CELL_PAYLOAD - skb->len - ATM_AAL5_TRAILER;
 337
 338         if (ctrl->num_entire + 1 < ctrl->num_cells)
 339                 ctrl->pdu_padding = zero_padding - (ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
 340         else
 341                 ctrl->pdu_padding = zero_padding;
 342
 343         ctrl->aal5_trailer[0] = 0;      /* UU = 0 */
 344         ctrl->aal5_trailer[1] = 0;      /* CPI = 0 */
 345         ctrl->aal5_trailer[2] = skb->len >> 8;
 346         ctrl->aal5_trailer[3] = skb->len;
 347
 348         crc = crc32_be(~0, skb->data, skb->len);
 349         crc = crc32_be(crc, zeros, zero_padding);
 350         crc = crc32_be(crc, ctrl->aal5_trailer, 4);
 351         crc = ~crc;
 352
 353         ctrl->aal5_trailer[4] = crc >> 24;
 354         ctrl->aal5_trailer[5] = crc >> 16;
 355         ctrl->aal5_trailer[6] = crc >> 8;
 356         ctrl->aal5_trailer[7] = crc;
 357 }
 358
 359 static unsigned int udsl_write_cells(struct udsl_instance_data *instance,
 360                                      unsigned int howmany, struct sk_buff *skb,
 361                                      unsigned char **target_p)
 362 {
 363         struct udsl_control *ctrl = UDSL_SKB(skb);
 364         unsigned char *target = *target_p;
 365         unsigned int nc, ne, i;
 366
 367         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);
 368
 369         nc = ctrl->num_cells;
 370         ne = min(howmany, ctrl->num_entire);
 371
 372         for (i = 0; i < ne; i++) {
 373                 udsl_fill_cell_header(target, ctrl->atm_data.vcc);
 374                 target += ATM_CELL_HEADER;
 375                 memcpy(target, skb->data, ATM_CELL_PAYLOAD);
 376                 target += ATM_CELL_PAYLOAD;
 377                 if (instance->snd_padding) {
 378                         memset(target, 0, instance->snd_padding);
 379                         target += instance->snd_padding;
 380                 }
 381                 __skb_pull(skb, ATM_CELL_PAYLOAD);
 382         }
 383
 384         ctrl->num_entire -= ne;
 385
 386         if (!(ctrl->num_cells -= ne) || !(howmany -= ne))
 387                 goto out;
 388
 389         udsl_fill_cell_header(target, ctrl->atm_data.vcc);
 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                 if (instance->snd_padding) {
 404                         memset(target, 0, instance->snd_padding);
 405                         target += instance->snd_padding;
 406                 }
 407                 udsl_fill_cell_header(target, ctrl->atm_data.vcc);
 408                 target += ATM_CELL_HEADER;
 409                 memset(target, 0, ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
 410                 target += ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
 411
 412                 --ctrl->num_cells;
 413                 UDSL_ASSERT(!ctrl->num_cells);
 414         }
 415
 416         memcpy(target, ctrl->aal5_trailer, ATM_AAL5_TRAILER);
 417         target += ATM_AAL5_TRAILER;
 418         /* set pti bit in last cell */
 419         *(target + 3 - ATM_CELL_SIZE) |= 0x2;
 420         if (instance->snd_padding) {
 421                 memset(target, 0, instance->snd_padding);
 422                 target += instance->snd_padding;
 423         }
 424  out:
 425         *target_p = target;
 426         return nc - ctrl->num_cells;
 427 }
 428
 429 /**************
 430 **  receive  **
 431 **************/
 432
 433 static void udsl_complete_receive(struct urb *urb, struct pt_regs *regs)
 434 {
 435         struct udsl_receive_buffer *buf;
 436         struct udsl_instance_data *instance;
 437         struct udsl_receiver *rcv;
 438         unsigned long flags;
 439
 440         if (!urb || !(rcv = urb->context)) {
 441                 dbg("udsl_complete_receive: bad urb!");
 442                 return;
 443         }
 444
 445         instance = rcv->instance;
 446         buf = rcv->buffer;
 447
 448         buf->filled_cells = urb->actual_length / (ATM_CELL_SIZE + instance->rcv_padding);
 449
 450         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);
 451
 452         UDSL_ASSERT(buf->filled_cells <= rcv_buf_size);
 453
 454         /* may not be in_interrupt() */
 455         spin_lock_irqsave(&instance->receive_lock, flags);
 456         list_add(&rcv->list, &instance->spare_receivers);
 457         list_add_tail(&buf->list, &instance->filled_receive_buffers);
 458         if (likely(!urb->status))
 459                 tasklet_schedule(&instance->receive_tasklet);
 460         spin_unlock_irqrestore(&instance->receive_lock, flags);
 461 }
 462
 463 static void udsl_process_receive(unsigned long data)
 464 {
 465         struct udsl_receive_buffer *buf;
 466         struct udsl_instance_data *instance = (struct udsl_instance_data *)data;
 467         struct udsl_receiver *rcv;
 468         int err;
 469
 470  made_progress:
 471         while (!list_empty(&instance->spare_receive_buffers)) {
 472                 spin_lock_irq(&instance->receive_lock);
 473                 if (list_empty(&instance->spare_receivers)) {
 474                         spin_unlock_irq(&instance->receive_lock);
 475                         break;
 476                 }
 477                 rcv = list_entry(instance->spare_receivers.next,
 478                                  struct udsl_receiver, list);
 479                 list_del(&rcv->list);
 480                 spin_unlock_irq(&instance->receive_lock);
 481
 482                 buf = list_entry(instance->spare_receive_buffers.next,
 483                                  struct udsl_receive_buffer, list);
 484                 list_del(&buf->list);
 485
 486                 rcv->buffer = buf;
 487
 488                 usb_fill_bulk_urb(rcv->urb, instance->usb_dev,
 489                                   usb_rcvbulkpipe(instance->usb_dev, instance->data_endpoint),
 490                                   buf->base,
 491                                   rcv_buf_size * (ATM_CELL_SIZE + instance->rcv_padding),
 492                                   udsl_complete_receive, rcv);
 493
 494                 vdbg("udsl_process_receive: sending urb 0x%p, rcv 0x%p, buf 0x%p",
 495                      rcv->urb, rcv, buf);
 496
 497                 if ((err = usb_submit_urb(rcv->urb, GFP_ATOMIC)) < 0) {
 498                         dbg("udsl_process_receive: urb submission failed (%d)!", err);
 499                         list_add(&buf->list, &instance->spare_receive_buffers);
 500                         spin_lock_irq(&instance->receive_lock);
 501                         list_add(&rcv->list, &instance->spare_receivers);
 502                         spin_unlock_irq(&instance->receive_lock);
 503                         break;
 504                 }
 505         }
 506
 507         spin_lock_irq(&instance->receive_lock);
 508         if (list_empty(&instance->filled_receive_buffers)) {
 509                 spin_unlock_irq(&instance->receive_lock);
 510                 return;         /* done - no more buffers */
 511         }
 512         buf = list_entry(instance->filled_receive_buffers.next,
 513                          struct udsl_receive_buffer, list);
 514         list_del(&buf->list);
 515         spin_unlock_irq(&instance->receive_lock);
 516
 517         vdbg("udsl_process_receive: processing buf 0x%p", buf);
 518         udsl_extract_cells(instance, buf->base, buf->filled_cells);
 519         list_add(&buf->list, &instance->spare_receive_buffers);
 520         goto made_progress;
 521 }
 522
 523 /***********
 524 **  send  **
 525 ***********/
 526
 527 static void udsl_complete_send(struct urb *urb, struct pt_regs *regs)
 528 {
 529         struct udsl_instance_data *instance;
 530         struct udsl_sender *snd;
 531         unsigned long flags;
 532
 533         if (!urb || !(snd = urb->context) || !(instance = snd->instance)) {
 534                 dbg("udsl_complete_send: bad urb!");
 535                 return;
 536         }
 537
 538         vdbg("udsl_complete_send: urb 0x%p, status %d, snd 0x%p, buf 0x%p", urb,
 539              urb->status, snd, snd->buffer);
 540
 541         /* may not be in_interrupt() */
 542         spin_lock_irqsave(&instance->send_lock, flags);
 543         list_add(&snd->list, &instance->spare_senders);
 544         list_add(&snd->buffer->list, &instance->spare_send_buffers);
 545         tasklet_schedule(&instance->send_tasklet);
 546         spin_unlock_irqrestore(&instance->send_lock, flags);
 547 }
 548
 549 static void udsl_process_send(unsigned long data)
 550 {
 551         struct udsl_send_buffer *buf;
 552         struct udsl_instance_data *instance = (struct udsl_instance_data *)data;
 553         struct sk_buff *skb;
 554         struct udsl_sender *snd;
 555         int err;
 556         unsigned int num_written;
 557
 558  made_progress:
 559         spin_lock_irq(&instance->send_lock);
 560         while (!list_empty(&instance->spare_senders)) {
 561                 if (!list_empty(&instance->filled_send_buffers)) {
 562                         buf = list_entry(instance->filled_send_buffers.next,
 563                                          struct udsl_send_buffer, list);
 564                         list_del(&buf->list);
 565                 } else if ((buf = instance->current_buffer)) {
 566                         instance->current_buffer = NULL;
 567                 } else          /* all buffers empty */
 568                         break;
 569
 570                 snd = list_entry(instance->spare_senders.next,
 571                                  struct udsl_sender, list);
 572                 list_del(&snd->list);
 573                 spin_unlock_irq(&instance->send_lock);
 574
 575                 snd->buffer = buf;
 576                 usb_fill_bulk_urb(snd->urb, instance->usb_dev,
 577                                   usb_sndbulkpipe(instance->usb_dev, instance->data_endpoint),
 578                                   buf->base,
 579                                   (snd_buf_size - buf->free_cells) * (ATM_CELL_SIZE + instance->snd_padding),
 580                                   udsl_complete_send, snd);
 581
 582                 vdbg("udsl_process_send: submitting urb 0x%p (%d cells), snd 0x%p, buf 0x%p",
 583                      snd->urb, snd_buf_size - buf->free_cells, snd, buf);
 584
 585                 if ((err = usb_submit_urb(snd->urb, GFP_ATOMIC)) < 0) {
 586                         dbg("udsl_process_send: urb submission failed (%d)!", err);
 587                         spin_lock_irq(&instance->send_lock);
 588                         list_add(&snd->list, &instance->spare_senders);
 589                         spin_unlock_irq(&instance->send_lock);
 590                         list_add(&buf->list, &instance->filled_send_buffers);
 591                         return; /* bail out */
 592                 }
 593
 594                 spin_lock_irq(&instance->send_lock);
 595         }                       /* while */
 596         spin_unlock_irq(&instance->send_lock);
 597
 598         if (!instance->current_skb)
 599                 instance->current_skb = skb_dequeue(&instance->sndqueue);
 600         if (!instance->current_skb)
 601                 return;         /* done - no more skbs */
 602
 603         skb = instance->current_skb;
 604
 605         if (!(buf = instance->current_buffer)) {
 606                 spin_lock_irq(&instance->send_lock);
 607                 if (list_empty(&instance->spare_send_buffers)) {
 608                         instance->current_buffer = NULL;
 609                         spin_unlock_irq(&instance->send_lock);
 610                         return; /* done - no more buffers */
 611                 }
 612                 buf = list_entry(instance->spare_send_buffers.next,
 613                                struct udsl_send_buffer, list);
 614                 list_del(&buf->list);
 615                 spin_unlock_irq(&instance->send_lock);
 616
 617                 buf->free_start = buf->base;
 618                 buf->free_cells = snd_buf_size;
 619
 620                 instance->current_buffer = buf;
 621         }
 622
 623         num_written = udsl_write_cells(instance, buf->free_cells, skb, &buf->free_start);
 624
 625         vdbg("udsl_process_send: wrote %u cells from skb 0x%p to buffer 0x%p",
 626              num_written, skb, buf);
 627
 628         if (!(buf->free_cells -= num_written)) {
 629                 list_add_tail(&buf->list, &instance->filled_send_buffers);
 630                 instance->current_buffer = NULL;
 631         }
 632
 633         vdbg("udsl_process_send: buffer contains %d cells, %d left",
 634              snd_buf_size - buf->free_cells, buf->free_cells);
 635
 636         if (!UDSL_SKB(skb)->num_cells) {
 637                 struct atm_vcc *vcc = UDSL_SKB(skb)->atm_data.vcc;
 638
 639                 udsl_pop(vcc, skb);
 640                 instance->current_skb = NULL;
 641
 642                 atomic_inc(&vcc->stats->tx);
 643         }
 644
 645         goto made_progress;
 646 }
 647
 648 static void udsl_cancel_send(struct udsl_instance_data *instance,
 649                              struct atm_vcc *vcc)
 650 {
 651         struct sk_buff *skb, *n;
 652
 653         dbg("udsl_cancel_send entered");
 654         spin_lock_irq(&instance->sndqueue.lock);
 655         for (skb = instance->sndqueue.next, n = skb->next;
 656              skb != (struct sk_buff *)&instance->sndqueue;
 657              skb = n, n = skb->next)
 658                 if (UDSL_SKB(skb)->atm_data.vcc == vcc) {
 659                         dbg("udsl_cancel_send: popping skb 0x%p", skb);
 660                         __skb_unlink(skb, &instance->sndqueue);
 661                         udsl_pop(vcc, skb);
 662                 }
 663         spin_unlock_irq(&instance->sndqueue.lock);
 664
 665         tasklet_disable(&instance->send_tasklet);
 666         if ((skb = instance->current_skb) && (UDSL_SKB(skb)->atm_data.vcc == vcc)) {
 667                 dbg("udsl_cancel_send: popping current skb (0x%p)", skb);
 668                 instance->current_skb = NULL;
 669                 udsl_pop(vcc, skb);
 670         }
 671         tasklet_enable(&instance->send_tasklet);
 672         dbg("udsl_cancel_send done");
 673 }
 674
 675 static int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
 676 {
 677         struct udsl_instance_data *instance = vcc->dev->dev_data;
 678         int err;
 679
 680         vdbg("udsl_atm_send called (skb 0x%p, len %u)", skb, skb->len);
 681
 682         if (!instance) {
 683                 dbg("udsl_atm_send: NULL data!");
 684                 err = -ENODEV;
 685                 goto fail;
 686         }
 687
 688         if (vcc->qos.aal != ATM_AAL5) {
 689                 dbg("udsl_atm_send: unsupported ATM type %d!", vcc->qos.aal);
 690                 err = -EINVAL;
 691                 goto fail;
 692         }
 693
 694         if (skb->len > ATM_MAX_AAL5_PDU) {
 695                 dbg("udsl_atm_send: packet too long (%d vs %d)!", skb->len,
 696                     ATM_MAX_AAL5_PDU);
 697                 err = -EINVAL;
 698                 goto fail;
 699         }
 700
 701         PACKETDEBUG(skb->data, skb->len);
 702
 703         udsl_groom_skb(vcc, skb);
 704         skb_queue_tail(&instance->sndqueue, skb);
 705         tasklet_schedule(&instance->send_tasklet);
 706
 707         return 0;
 708
 709  fail:
 710         udsl_pop(vcc, skb);
 711         return err;
 712 }
 713
 714 /********************
 715 **  bean counting  **
 716 ********************/
 717
 718 static void udsl_destroy_instance(struct kref *kref)
 719 {
 720         struct udsl_instance_data *instance =
 721             container_of(kref, struct udsl_instance_data, refcount);
 722
 723         tasklet_kill(&instance->receive_tasklet);
 724         tasklet_kill(&instance->send_tasklet);
 725         usb_put_dev(instance->usb_dev);
 726         kfree(instance);
 727 }
 728
 729 void udsl_get_instance(struct udsl_instance_data *instance)
 730 {
 731         kref_get(&instance->refcount);
 732 }
 733
 734 void udsl_put_instance(struct udsl_instance_data *instance)
 735 {
 736         kref_put(&instance->refcount, udsl_destroy_instance);
 737 }
 738
 739 /**********
 740 **  ATM  **
 741 **********/
 742
 743 static void udsl_atm_dev_close(struct atm_dev *dev)
 744 {
 745         struct udsl_instance_data *instance = dev->dev_data;
 746
 747         dev->dev_data = NULL;
 748         udsl_put_instance(instance);
 749 }
 750
 751 static int udsl_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page)
 752 {
 753         struct udsl_instance_data *instance = atm_dev->dev_data;
 754         int left = *pos;
 755
 756         if (!instance) {
 757                 dbg("udsl_atm_proc_read: NULL instance!");
 758                 return -ENODEV;
 759         }
 760
 761         if (!left--)
 762                 return sprintf(page, "%s\n", instance->description);
 763
 764         if (!left--)
 765                 return sprintf(page, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
 766                                atm_dev->esi[0], atm_dev->esi[1],
 767                                atm_dev->esi[2], atm_dev->esi[3],
 768                                atm_dev->esi[4], atm_dev->esi[5]);
 769
 770         if (!left--)
 771                 return sprintf(page,
 772                                "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
 773                                atomic_read(&atm_dev->stats.aal5.tx),
 774                                atomic_read(&atm_dev->stats.aal5.tx_err),
 775                                atomic_read(&atm_dev->stats.aal5.rx),
 776                                atomic_read(&atm_dev->stats.aal5.rx_err),
 777                                atomic_read(&atm_dev->stats.aal5.rx_drop));
 778
 779         if (!left--) {
 780                 switch (atm_dev->signal) {
 781                 case ATM_PHY_SIG_FOUND:
 782                         sprintf(page, "Line up");
 783                         break;
 784                 case ATM_PHY_SIG_LOST:
 785                         sprintf(page, "Line down");
 786                         break;
 787                 default:
 788                         sprintf(page, "Line state unknown");
 789                         break;
 790                 }
 791
 792                 if (instance->usb_dev->state == USB_STATE_NOTATTACHED)
 793                         strcat(page, ", disconnected\n");
 794                 else {
 795                         if (instance->status == UDSL_LOADED_FIRMWARE)
 796                                 strcat(page, ", firmware loaded\n");
 797                         else if (instance->status == UDSL_LOADING_FIRMWARE)
 798                                 strcat(page, ", firmware loading\n");
 799                         else
 800                                 strcat(page, ", no firmware\n");
 801                 }
 802
 803                 return strlen(page);
 804         }
 805
 806         return 0;
 807 }
 808
 809 static int udsl_atm_open(struct atm_vcc *vcc)
 810 {
 811         struct udsl_instance_data *instance = vcc->dev->dev_data;
 812         struct udsl_vcc_data *new;
 813         unsigned int max_pdu;
 814         int vci = vcc->vci;
 815         short vpi = vcc->vpi;
 816         int err;
 817
 818         dbg("udsl_atm_open: vpi %hd, vci %d", vpi, vci);
 819
 820         if (!instance) {
 821                 dbg("udsl_atm_open: NULL data!");
 822                 return -ENODEV;
 823         }
 824
 825         /* only support AAL5 */
 826         if ((vcc->qos.aal != ATM_AAL5) || (vcc->qos.rxtp.max_sdu < 0)
 827             || (vcc->qos.rxtp.max_sdu > ATM_MAX_AAL5_PDU)) {
 828                 dbg("udsl_atm_open: unsupported ATM type %d!", vcc->qos.aal);
 829                 return -EINVAL;
 830         }
 831
 832         if (instance->firmware_wait &&
 833             (err = instance->firmware_wait(instance)) < 0) {
 834                 dbg("udsl_atm_open: firmware not loaded (%d)!", err);
 835                 return err;
 836         }
 837
 838         down(&instance->serialize);     /* vs self, udsl_atm_close */
 839
 840         if (udsl_find_vcc(instance, vpi, vci)) {
 841                 dbg("udsl_atm_open: %hd/%d already in use!", vpi, vci);
 842                 up(&instance->serialize);
 843                 return -EADDRINUSE;
 844         }
 845
 846         if (!(new = kmalloc(sizeof(struct udsl_vcc_data), GFP_KERNEL))) {
 847                 dbg("udsl_atm_open: no memory for vcc_data!");
 848                 up(&instance->serialize);
 849                 return -ENOMEM;
 850         }
 851
 852         memset(new, 0, sizeof(struct udsl_vcc_data));
 853         new->vcc = vcc;
 854         new->vpi = vpi;
 855         new->vci = vci;
 856
 857         /* udsl_extract_cells requires at least one cell */
 858         max_pdu = max(1, UDSL_NUM_CELLS(vcc->qos.rxtp.max_sdu)) * ATM_CELL_PAYLOAD;
 859         if (!(new->sarb = alloc_skb(max_pdu, GFP_KERNEL))) {
 860                 dbg("udsl_atm_open: no memory for SAR buffer!");
 861                 kfree(new);
 862                 up(&instance->serialize);
 863                 return -ENOMEM;
 864         }
 865
 866         vcc->dev_data = new;
 867
 868         tasklet_disable(&instance->receive_tasklet);
 869         list_add(&new->list, &instance->vcc_list);
 870         tasklet_enable(&instance->receive_tasklet);
 871
 872         set_bit(ATM_VF_ADDR, &vcc->flags);
 873         set_bit(ATM_VF_PARTIAL, &vcc->flags);
 874         set_bit(ATM_VF_READY, &vcc->flags);
 875
 876         up(&instance->serialize);
 877
 878         tasklet_schedule(&instance->receive_tasklet);
 879
 880         dbg("udsl_atm_open: allocated vcc data 0x%p (max_pdu: %u)", new, max_pdu);
 881
 882         return 0;
 883 }
 884
 885 static void udsl_atm_close(struct atm_vcc *vcc)
 886 {
 887         struct udsl_instance_data *instance = vcc->dev->dev_data;
 888         struct udsl_vcc_data *vcc_data = vcc->dev_data;
 889
 890         dbg("udsl_atm_close called");
 891
 892         if (!instance || !vcc_data) {
 893                 dbg("udsl_atm_close: NULL data!");
 894                 return;
 895         }
 896
 897         dbg("udsl_atm_close: deallocating vcc 0x%p with vpi %d vci %d",
 898             vcc_data, vcc_data->vpi, vcc_data->vci);
 899
 900         udsl_cancel_send(instance, vcc);
 901
 902         down(&instance->serialize);     /* vs self, udsl_atm_open */
 903
 904         tasklet_disable(&instance->receive_tasklet);
 905         list_del(&vcc_data->list);
 906         tasklet_enable(&instance->receive_tasklet);
 907
 908         kfree_skb(vcc_data->sarb);
 909         vcc_data->sarb = NULL;
 910
 911         kfree(vcc_data);
 912         vcc->dev_data = NULL;
 913
 914         vcc->vpi = ATM_VPI_UNSPEC;
 915         vcc->vci = ATM_VCI_UNSPEC;
 916         clear_bit(ATM_VF_READY, &vcc->flags);
 917         clear_bit(ATM_VF_PARTIAL, &vcc->flags);
 918         clear_bit(ATM_VF_ADDR, &vcc->flags);
 919
 920         up(&instance->serialize);
 921
 922         dbg("udsl_atm_close successful");
 923 }
 924
 925 static int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd,
 926                           void __user * arg)
 927 {
 928         switch (cmd) {
 929         case ATM_QUERYLOOP:
 930                 return put_user(ATM_LM_NONE, (int __user *)arg) ? -EFAULT : 0;
 931         default:
 932                 return -ENOIOCTLCMD;
 933         }
 934 }
 935
 936 /**********
 937 **  USB  **
 938 **********/
 939
 940 int udsl_instance_setup(struct usb_device *dev,
 941                         struct udsl_instance_data *instance)
 942 {
 943         char *buf;
 944         int i, length;
 945
 946         kref_init(&instance->refcount); /* one for USB */
 947         udsl_get_instance(instance);    /* one for ATM */
 948
 949         init_MUTEX(&instance->serialize);
 950
 951         instance->usb_dev = dev;
 952
 953         INIT_LIST_HEAD(&instance->vcc_list);
 954
 955         instance->status = UDSL_NO_FIRMWARE;
 956         init_waitqueue_head(&instance->firmware_waiters);
 957
 958         spin_lock_init(&instance->receive_lock);
 959         INIT_LIST_HEAD(&instance->spare_receivers);
 960         INIT_LIST_HEAD(&instance->filled_receive_buffers);
 961
 962         tasklet_init(&instance->receive_tasklet, udsl_process_receive, (unsigned long)instance);
 963         INIT_LIST_HEAD(&instance->spare_receive_buffers);
 964
 965         skb_queue_head_init(&instance->sndqueue);
 966
 967         spin_lock_init(&instance->send_lock);
 968         INIT_LIST_HEAD(&instance->spare_senders);
 969         INIT_LIST_HEAD(&instance->spare_send_buffers);
 970
 971         tasklet_init(&instance->send_tasklet, udsl_process_send,
 972                      (unsigned long)instance);
 973         INIT_LIST_HEAD(&instance->filled_send_buffers);
 974
 975         /* receive init */
 976         for (i = 0; i < num_rcv_urbs; i++) {
 977                 struct udsl_receiver *rcv = &(instance->receivers[i]);
 978
 979                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 980                         dbg("udsl_usb_probe: no memory for receive urb %d!", i);
 981                         goto fail;
 982                 }
 983
 984                 rcv->instance = instance;
 985
 986                 list_add(&rcv->list, &instance->spare_receivers);
 987         }
 988
 989         for (i = 0; i < num_rcv_bufs; i++) {
 990                 struct udsl_receive_buffer *buf =
 991                     &(instance->receive_buffers[i]);
 992
 993                 buf->base = kmalloc(rcv_buf_size * (ATM_CELL_SIZE + instance->rcv_padding),
 994                                     GFP_KERNEL);
 995                 if (!buf->base) {
 996                         dbg("udsl_usb_probe: no memory for receive buffer %d!", i);
 997                         goto fail;
 998                 }
 999
1000                 list_add(&buf->list, &instance->spare_receive_buffers);
1001         }
1002
1003         /* send init */
1004         for (i = 0; i < num_snd_urbs; i++) {
1005                 struct udsl_sender *snd = &(instance->senders[i]);
1006
1007                 if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1008                         dbg("udsl_usb_probe: no memory for send urb %d!", i);
1009                         goto fail;
1010                 }
1011
1012                 snd->instance = instance;
1013
1014                 list_add(&snd->list, &instance->spare_senders);
1015         }
1016
1017         for (i = 0; i < num_snd_bufs; i++) {
1018                 struct udsl_send_buffer *buf = &(instance->send_buffers[i]);
1019
1020                 buf->base = kmalloc(snd_buf_size * (ATM_CELL_SIZE + instance->snd_padding),
1021                                     GFP_KERNEL);
1022                 if (!buf->base) {
1023                         dbg("udsl_usb_probe: no memory for send buffer %d!", i);
1024                         goto fail;
1025                 }
1026
1027                 list_add(&buf->list, &instance->spare_send_buffers);
1028         }
1029
1030         /* ATM init */
1031         instance->atm_dev = atm_dev_register(instance->driver_name,
1032                                              &udsl_atm_devops, -1, NULL);
1033         if (!instance->atm_dev) {
1034                 dbg("udsl_usb_probe: failed to register ATM device!");
1035                 goto fail;
1036         }
1037
1038         instance->atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
1039         instance->atm_dev->ci_range.vci_bits = ATM_CI_MAX;
1040         instance->atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
1041
1042         /* temp init ATM device, set to 128kbit */
1043         instance->atm_dev->link_rate = 128 * 1000 / 424;
1044
1045         /* device description */
1046         buf = instance->description;
1047         length = sizeof(instance->description);
1048
1049         if ((i = usb_string(dev, dev->descriptor.iProduct, buf, length)) < 0)
1050                 goto finish;
1051
1052         buf += i;
1053         length -= i;
1054
1055         i = scnprintf(buf, length, " (");
1056         buf += i;
1057         length -= i;
1058
1059         if (length <= 0 || (i = usb_make_path(dev, buf, length)) < 0)
1060                 goto finish;
1061
1062         buf += i;
1063         length -= i;
1064
1065         snprintf(buf, length, ")");
1066
1067  finish:
1068         /* ready for ATM callbacks */
1069         wmb();
1070         instance->atm_dev->dev_data = instance;
1071
1072         usb_get_dev(dev);
1073
1074         return 0;
1075
1076  fail:
1077         for (i = 0; i < num_snd_bufs; i++)
1078                 kfree(instance->send_buffers[i].base);
1079
1080         for (i = 0; i < num_snd_urbs; i++)
1081                 usb_free_urb(instance->senders[i].urb);
1082
1083         for (i = 0; i < num_rcv_bufs; i++)
1084                 kfree(instance->receive_buffers[i].base);
1085
1086         for (i = 0; i < num_rcv_urbs; i++)
1087                 usb_free_urb(instance->receivers[i].urb);
1088
1089         return -ENOMEM;
1090 }
1091
1092 void udsl_instance_disconnect(struct udsl_instance_data *instance)
1093 {
1094         int i;
1095
1096         dbg("udsl_instance_disconnect entered");
1097
1098         if (!instance) {
1099                 dbg("udsl_instance_disconnect: NULL instance!");
1100                 return;
1101         }
1102
1103         /* receive finalize */
1104         tasklet_disable(&instance->receive_tasklet);
1105
1106         for (i = 0; i < num_rcv_urbs; i++)
1107                 usb_kill_urb(instance->receivers[i].urb);
1108
1109         /* no need to take the spinlock */
1110         INIT_LIST_HEAD(&instance->filled_receive_buffers);
1111         INIT_LIST_HEAD(&instance->spare_receive_buffers);
1112
1113         tasklet_enable(&instance->receive_tasklet);
1114
1115         for (i = 0; i < num_rcv_urbs; i++)
1116                 usb_free_urb(instance->receivers[i].urb);
1117
1118         for (i = 0; i < num_rcv_bufs; i++)
1119                 kfree(instance->receive_buffers[i].base);
1120
1121         /* send finalize */
1122         tasklet_disable(&instance->send_tasklet);
1123
1124         for (i = 0; i < num_snd_urbs; i++)
1125                 usb_kill_urb(instance->senders[i].urb);
1126
1127         /* no need to take the spinlock */
1128         INIT_LIST_HEAD(&instance->spare_senders);
1129         INIT_LIST_HEAD(&instance->spare_send_buffers);
1130         instance->current_buffer = NULL;
1131
1132         tasklet_enable(&instance->send_tasklet);
1133
1134         for (i = 0; i < num_snd_urbs; i++)
1135                 usb_free_urb(instance->senders[i].urb);
1136
1137         for (i = 0; i < num_snd_bufs; i++)
1138                 kfree(instance->send_buffers[i].base);
1139
1140         /* ATM finalize */
1141         shutdown_atm_dev(instance->atm_dev);
1142 }
1143
1144 EXPORT_SYMBOL_GPL(udsl_get_instance);
1145 EXPORT_SYMBOL_GPL(udsl_put_instance);
1146 EXPORT_SYMBOL_GPL(udsl_instance_setup);
1147 EXPORT_SYMBOL_GPL(udsl_instance_disconnect);
1148
1149 /***********
1150 **  init  **
1151 ***********/
1152
1153 static int __init udsl_usb_init(void)
1154 {
1155         dbg("udsl_usb_init: driver version " DRIVER_VERSION);
1156
1157         if (sizeof(struct udsl_control) > sizeof(((struct sk_buff *) 0)->cb)) {
1158                 printk(KERN_ERR __FILE__ ": unusable with this kernel!\n");
1159                 return -EIO;
1160         }
1161
1162         if ((num_rcv_urbs > UDSL_MAX_RCV_URBS)
1163             || (num_snd_urbs > UDSL_MAX_SND_URBS)
1164             || (num_rcv_bufs > UDSL_MAX_RCV_BUFS)
1165             || (num_snd_bufs > UDSL_MAX_SND_BUFS)
1166             || (rcv_buf_size > UDSL_MAX_RCV_BUF_SIZE)
1167             || (snd_buf_size > UDSL_MAX_SND_BUF_SIZE))
1168                 return -EINVAL;
1169
1170         return 0;
1171 }
1172
1173 static void __exit udsl_usb_exit(void)
1174 {
1175 }
1176
1177 module_init(udsl_usb_init);
1178 module_exit(udsl_usb_exit);
1179
1180 MODULE_AUTHOR(DRIVER_AUTHOR);
1181 MODULE_DESCRIPTION(DRIVER_DESC);
1182 MODULE_LICENSE("GPL");
1183 MODULE_VERSION(DRIVER_VERSION);
1184
1185 /************
1186 **  debug  **
1187 ************/
1188
1189 #ifdef VERBOSE_DEBUG
1190 static int udsl_print_packet(const unsigned char *data, int len)
1191 {
1192         unsigned char buffer[256];
1193         int i = 0, j = 0;
1194
1195         for (i = 0; i < len;) {
1196                 buffer[0] = '\0';
1197                 sprintf(buffer, "%.3d :", i);
1198                 for (j = 0; (j < 16) && (i < len); j++, i++) {
1199                         sprintf(buffer, "%s %2.2x", buffer, data[i]);
1200                 }
1201                 dbg("%s", buffer);
1202         }
1203         return i;
1204 }
1205 #endif