SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/atm/usbatm.c

   1 /******************************************************************************
   2  *  usbatm.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, Roman Kagan
   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, Duncan Sands (duncan.sands@free.fr) and David Woodhouse
  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  *              usbatm_usb_send_data_context->urb to a pointer and adding code
  45  *              to alloc and free it
  46  *              - remove_wait_queue() added to usbatm_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 usbatm_usb_send_data()
  61  *  1.1:        - Turned off packet debugging
  62  *
  63  */
  64
  65 #include "usbatm.h"
  66
  67 #include <asm/uaccess.h>
  68 #include <linux/crc32.h>
  69 #include <linux/errno.h>
  70 #include <linux/init.h>
  71 #include <linux/interrupt.h>
  72 #include <linux/kernel.h>
  73 #include <linux/module.h>
  74 #include <linux/moduleparam.h>
  75 #include <linux/netdevice.h>
  76 #include <linux/proc_fs.h>
  77 #include <linux/sched.h>
  78 #include <linux/signal.h>
  79 #include <linux/slab.h>
  80 #include <linux/smp_lock.h>
  81 #include <linux/stat.h>
  82 #include <linux/timer.h>
  83 #include <linux/wait.h>
  84
  85 #ifdef VERBOSE_DEBUG
  86 static int usbatm_print_packet(const unsigned char *data, int len);
  87 #define PACKETDEBUG(arg...)     usbatm_print_packet (arg)
  88 #define vdbg(arg...)            dbg (arg)
  89 #else
  90 #define PACKETDEBUG(arg...)
  91 #define vdbg(arg...)
  92 #endif
  93
  94 #define DRIVER_AUTHOR   "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
  95 #define DRIVER_VERSION  "1.9"
  96 #define DRIVER_DESC     "Generic USB ATM/DSL I/O, version " DRIVER_VERSION
  97
  98 static const char usbatm_driver_name[] = "usbatm";
  99
 100 #define UDSL_MAX_RCV_URBS               16
 101 #define UDSL_MAX_SND_URBS               16
 102 #define UDSL_MAX_RCV_BUF_SIZE           1024    /* ATM cells */
 103 #define UDSL_MAX_SND_BUF_SIZE           1024    /* ATM cells */
 104 #define UDSL_DEFAULT_RCV_URBS           4
 105 #define UDSL_DEFAULT_SND_URBS           4
 106 #define UDSL_DEFAULT_RCV_BUF_SIZE       64      /* ATM cells */
 107 #define UDSL_DEFAULT_SND_BUF_SIZE       64      /* ATM cells */
 108
 109 #define ATM_CELL_HEADER                 (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
 110
 111 #define THROTTLE_MSECS                  100     /* delay to recover processing after urb submission fails */
 112
 113 static unsigned int num_rcv_urbs = UDSL_DEFAULT_RCV_URBS;
 114 static unsigned int num_snd_urbs = UDSL_DEFAULT_SND_URBS;
 115 static unsigned int rcv_buf_size = UDSL_DEFAULT_RCV_BUF_SIZE;
 116 static unsigned int snd_buf_size = UDSL_DEFAULT_SND_BUF_SIZE;
 117
 118 module_param(num_rcv_urbs, uint, S_IRUGO);
 119 MODULE_PARM_DESC(num_rcv_urbs,
 120                  "Number of urbs used for reception (range: 0-"
 121                  __MODULE_STRING(UDSL_MAX_RCV_URBS) ", default: "
 122                  __MODULE_STRING(UDSL_DEFAULT_RCV_URBS) ")");
 123
 124 module_param(num_snd_urbs, uint, S_IRUGO);
 125 MODULE_PARM_DESC(num_snd_urbs,
 126                  "Number of urbs used for transmission (range: 0-"
 127                  __MODULE_STRING(UDSL_MAX_SND_URBS) ", default: "
 128                  __MODULE_STRING(UDSL_DEFAULT_SND_URBS) ")");
 129
 130 module_param(rcv_buf_size, uint, S_IRUGO);
 131 MODULE_PARM_DESC(rcv_buf_size,
 132                  "Size of the buffers used for reception in ATM cells (range: 1-"
 133                  __MODULE_STRING(UDSL_MAX_RCV_BUF_SIZE) ", default: "
 134                  __MODULE_STRING(UDSL_DEFAULT_RCV_BUF_SIZE) ")");
 135
 136 module_param(snd_buf_size, uint, S_IRUGO);
 137 MODULE_PARM_DESC(snd_buf_size,
 138                  "Size of the buffers used for transmission in ATM cells (range: 1-"
 139                  __MODULE_STRING(UDSL_MAX_SND_BUF_SIZE) ", default: "
 140                  __MODULE_STRING(UDSL_DEFAULT_SND_BUF_SIZE) ")");
 141
 142
 143 /* receive */
 144
 145 struct usbatm_vcc_data {
 146         /* vpi/vci lookup */
 147         struct list_head list;
 148         short vpi;
 149         int vci;
 150         struct atm_vcc *vcc;
 151
 152         /* raw cell reassembly */
 153         struct sk_buff *sarb;
 154 };
 155
 156
 157 /* send */
 158
 159 struct usbatm_control {
 160         struct atm_skb_data atm;
 161         u32 len;
 162         u32 crc;
 163 };
 164
 165 #define UDSL_SKB(x)             ((struct usbatm_control *)(x)->cb)
 166
 167
 168 /* ATM */
 169
 170 static void usbatm_atm_dev_close(struct atm_dev *atm_dev);
 171 static int usbatm_atm_open(struct atm_vcc *vcc);
 172 static void usbatm_atm_close(struct atm_vcc *vcc);
 173 static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd, void __user * arg);
 174 static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
 175 static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page);
 176
 177 static struct atmdev_ops usbatm_atm_devops = {
 178         .dev_close      = usbatm_atm_dev_close,
 179         .open           = usbatm_atm_open,
 180         .close          = usbatm_atm_close,
 181         .ioctl          = usbatm_atm_ioctl,
 182         .send           = usbatm_atm_send,
 183         .proc_read      = usbatm_atm_proc_read,
 184         .owner          = THIS_MODULE,
 185 };
 186
 187
 188 /***********
 189 **  misc  **
 190 ***********/
 191
 192 static inline unsigned int usbatm_pdu_length(unsigned int length)
 193 {
 194         length += ATM_CELL_PAYLOAD - 1 + ATM_AAL5_TRAILER;
 195         return length - length % ATM_CELL_PAYLOAD;
 196 }
 197
 198 static inline void usbatm_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 199 {
 200         if (vcc->pop)
 201                 vcc->pop(vcc, skb);
 202         else
 203                 dev_kfree_skb_any(skb);
 204 }
 205
 206
 207 /***********
 208 **  urbs  **
 209 ************/
 210
 211 static struct urb *usbatm_pop_urb(struct usbatm_channel *channel)
 212 {
 213         struct urb *urb;
 214
 215         spin_lock_irq(&channel->lock);
 216         if (list_empty(&channel->list)) {
 217                 spin_unlock_irq(&channel->lock);
 218                 return NULL;
 219         }
 220
 221         urb = list_entry(channel->list.next, struct urb, urb_list);
 222         list_del(&urb->urb_list);
 223         spin_unlock_irq(&channel->lock);
 224
 225         return urb;
 226 }
 227
 228 static int usbatm_submit_urb(struct urb *urb)
 229 {
 230         struct usbatm_channel *channel = urb->context;
 231         int ret;
 232
 233         vdbg("%s: submitting urb 0x%p, size %u",
 234              __func__, urb, urb->transfer_buffer_length);
 235
 236         ret = usb_submit_urb(urb, GFP_ATOMIC);
 237         if (ret) {
 238                 if (printk_ratelimit())
 239                         atm_warn(channel->usbatm, "%s: urb 0x%p submission failed (%d)!\n",
 240                                 __func__, urb, ret);
 241
 242                 /* consider all errors transient and return the buffer back to the queue */
 243                 urb->status = -EAGAIN;
 244                 spin_lock_irq(&channel->lock);
 245
 246                 /* must add to the front when sending; doesn't matter when receiving */
 247                 list_add(&urb->urb_list, &channel->list);
 248
 249                 spin_unlock_irq(&channel->lock);
 250
 251                 /* make sure the channel doesn't stall */
 252                 mod_timer(&channel->delay, jiffies + msecs_to_jiffies(THROTTLE_MSECS));
 253         }
 254
 255         return ret;
 256 }
 257
 258 static void usbatm_complete(struct urb *urb, struct pt_regs *regs)
 259 {
 260         struct usbatm_channel *channel = urb->context;
 261         unsigned long flags;
 262
 263         vdbg("%s: urb 0x%p, status %d, actual_length %d",
 264              __func__, urb, urb->status, urb->actual_length);
 265
 266         /* usually in_interrupt(), but not always */
 267         spin_lock_irqsave(&channel->lock, flags);
 268
 269         /* must add to the back when receiving; doesn't matter when sending */
 270         list_add_tail(&urb->urb_list, &channel->list);
 271
 272         spin_unlock_irqrestore(&channel->lock, flags);
 273
 274         if (unlikely(urb->status)) {
 275                 if (printk_ratelimit())
 276                         atm_warn(channel->usbatm, "%s: urb 0x%p failed (%d)!\n",
 277                                 __func__, urb, urb->status);
 278                 /* throttle processing in case of an error */
 279                 mod_timer(&channel->delay, jiffies + msecs_to_jiffies(THROTTLE_MSECS));
 280         } else
 281                 tasklet_schedule(&channel->tasklet);
 282 }
 283
 284
 285 /*************
 286 **  decode  **
 287 *************/
 288
 289 static inline struct usbatm_vcc_data *usbatm_find_vcc(struct usbatm_data *instance,
 290                                                   short vpi, int vci)
 291 {
 292         struct usbatm_vcc_data *vcc_data;
 293
 294         list_for_each_entry(vcc_data, &instance->vcc_list, list)
 295                 if ((vcc_data->vci == vci) && (vcc_data->vpi == vpi))
 296                         return vcc_data;
 297         return NULL;
 298 }
 299
 300 static void usbatm_extract_cells(struct usbatm_data *instance,
 301                                unsigned char *source, unsigned int avail_data)
 302 {
 303         struct usbatm_vcc_data *cached_vcc = NULL;
 304         struct atm_vcc *vcc;
 305         struct sk_buff *sarb;
 306         unsigned int stride = instance->rx_channel.stride;
 307         int vci, cached_vci = 0;
 308         short vpi, cached_vpi = 0;
 309         u8 pti;
 310
 311         for (; avail_data >= stride; avail_data -= stride, source += stride) {
 312                 vpi = ((source[0] & 0x0f) << 4)  | (source[1] >> 4);
 313                 vci = ((source[1] & 0x0f) << 12) | (source[2] << 4) | (source[3] >> 4);
 314                 pti = ((source[3] & 0xe) >> 1);
 315
 316                 vdbg("%s: vpi %hd, vci %d, pti %d", __func__, vpi, vci, pti);
 317
 318                 if ((vci != cached_vci) || (vpi != cached_vpi)) {
 319                         cached_vpi = vpi;
 320                         cached_vci = vci;
 321
 322                         cached_vcc = usbatm_find_vcc(instance, vpi, vci);
 323
 324                         if (!cached_vcc)
 325                                 atm_rldbg(instance, "%s: unknown vpi/vci (%hd/%d)!\n", __func__, vpi, vci);
 326                 }
 327
 328                 if (!cached_vcc)
 329                         continue;
 330
 331                 vcc = cached_vcc->vcc;
 332
 333                 /* OAM F5 end-to-end */
 334                 if (pti == ATM_PTI_E2EF5) {
 335                         if (printk_ratelimit())
 336                                 atm_warn(instance, "%s: OAM not supported (vpi %d, vci %d)!\n",
 337                                         __func__, vpi, vci);
 338                         atomic_inc(&vcc->stats->rx_err);
 339                         continue;
 340                 }
 341
 342                 sarb = cached_vcc->sarb;
 343
 344                 if (sarb->tail + ATM_CELL_PAYLOAD > sarb->end) {
 345                         atm_rldbg(instance, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
 346                                         __func__, sarb->len, vcc);
 347                         /* discard cells already received */
 348                         skb_trim(sarb, 0);
 349                         UDSL_ASSERT(sarb->tail + ATM_CELL_PAYLOAD <= sarb->end);
 350                 }
 351
 352                 memcpy(sarb->tail, source + ATM_CELL_HEADER, ATM_CELL_PAYLOAD);
 353                 __skb_put(sarb, ATM_CELL_PAYLOAD);
 354
 355                 if (pti & 1) {
 356                         struct sk_buff *skb;
 357                         unsigned int length;
 358                         unsigned int pdu_length;
 359
 360                         length = (source[ATM_CELL_SIZE - 6] << 8) + source[ATM_CELL_SIZE - 5];
 361
 362                         /* guard against overflow */
 363                         if (length > ATM_MAX_AAL5_PDU) {
 364                                 atm_rldbg(instance, "%s: bogus length %u (vcc: 0x%p)!\n",
 365                                                 __func__, length, vcc);
 366                                 atomic_inc(&vcc->stats->rx_err);
 367                                 goto out;
 368                         }
 369
 370                         pdu_length = usbatm_pdu_length(length);
 371
 372                         if (sarb->len < pdu_length) {
 373                                 atm_rldbg(instance, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
 374                                                 __func__, pdu_length, sarb->len, vcc);
 375                                 atomic_inc(&vcc->stats->rx_err);
 376                                 goto out;
 377                         }
 378
 379                         if (crc32_be(~0, sarb->tail - pdu_length, pdu_length) != 0xc704dd7b) {
 380                                 atm_rldbg(instance, "%s: packet failed crc check (vcc: 0x%p)!\n",
 381                                                 __func__, vcc);
 382                                 atomic_inc(&vcc->stats->rx_err);
 383                                 goto out;
 384                         }
 385
 386                         vdbg("%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", __func__, length, pdu_length, vcc);
 387
 388                         if (!(skb = dev_alloc_skb(length))) {
 389                                 if (printk_ratelimit())
 390                                         atm_err(instance, "%s: no memory for skb (length: %u)!\n",
 391                                                         __func__, length);
 392                                 atomic_inc(&vcc->stats->rx_drop);
 393                                 goto out;
 394                         }
 395
 396                         vdbg("%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", __func__, skb, skb->truesize);
 397
 398                         if (!atm_charge(vcc, skb->truesize)) {
 399                                 atm_rldbg(instance, "%s: failed atm_charge (skb->truesize: %u)!\n",
 400                                                 __func__, skb->truesize);
 401                                 dev_kfree_skb_any(skb);
 402                                 goto out;       /* atm_charge increments rx_drop */
 403                         }
 404
 405                         memcpy(skb->data, sarb->tail - pdu_length, length);
 406                         __skb_put(skb, length);
 407
 408                         vdbg("%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
 409                              __func__, skb, skb->len, skb->truesize);
 410
 411                         PACKETDEBUG(skb->data, skb->len);
 412
 413                         vcc->push(vcc, skb);
 414
 415                         atomic_inc(&vcc->stats->rx);
 416                 out:
 417                         skb_trim(sarb, 0);
 418                 }
 419         }
 420 }
 421
 422
 423 /*************
 424 **  encode  **
 425 *************/
 426
 427 static unsigned int usbatm_write_cells(struct usbatm_data *instance,
 428                                        struct sk_buff *skb,
 429                                        u8 *target, unsigned int avail_space)
 430 {
 431         struct usbatm_control *ctrl = UDSL_SKB(skb);
 432         struct atm_vcc *vcc = ctrl->atm.vcc;
 433         unsigned int num_written;
 434         unsigned int stride = instance->tx_channel.stride;
 435
 436         vdbg("%s: skb->len=%d, avail_space=%u", __func__, skb->len, avail_space);
 437         UDSL_ASSERT(!(avail_space % stride));
 438
 439         for (num_written = 0; num_written < avail_space && ctrl->len;
 440              num_written += stride, target += stride) {
 441                 unsigned int data_len = min_t(unsigned int, skb->len, ATM_CELL_PAYLOAD);
 442                 unsigned int left = ATM_CELL_PAYLOAD - data_len;
 443                 u8 *ptr = target;
 444
 445                 ptr[0] = vcc->vpi >> 4;
 446                 ptr[1] = (vcc->vpi << 4) | (vcc->vci >> 12);
 447                 ptr[2] = vcc->vci >> 4;
 448                 ptr[3] = vcc->vci << 4;
 449                 ptr[4] = 0xec;
 450                 ptr += ATM_CELL_HEADER;
 451
 452                 memcpy(ptr, skb->data, data_len);
 453                 ptr += data_len;
 454                 __skb_pull(skb, data_len);
 455
 456                 if(!left)
 457                         continue;
 458
 459                 memset(ptr, 0, left);
 460
 461                 if (left >= ATM_AAL5_TRAILER) { /* trailer will go in this cell */
 462                         u8 *trailer = target + ATM_CELL_SIZE - ATM_AAL5_TRAILER;
 463                         /* trailer[0] = 0;              UU = 0 */
 464                         /* trailer[1] = 0;              CPI = 0 */
 465                         trailer[2] = ctrl->len >> 8;
 466                         trailer[3] = ctrl->len;
 467
 468                         ctrl->crc = ~ crc32_be(ctrl->crc, ptr, left - 4);
 469
 470                         trailer[4] = ctrl->crc >> 24;
 471                         trailer[5] = ctrl->crc >> 16;
 472                         trailer[6] = ctrl->crc >> 8;
 473                         trailer[7] = ctrl->crc;
 474
 475                         target[3] |= 0x2;       /* adjust PTI */
 476
 477                         ctrl->len = 0;          /* tag this skb finished */
 478                 }
 479                 else
 480                         ctrl->crc = crc32_be(ctrl->crc, ptr, left);
 481         }
 482
 483         return num_written;
 484 }
 485
 486
 487 /**************
 488 **  receive  **
 489 **************/
 490
 491 static void usbatm_rx_process(unsigned long data)
 492 {
 493         struct usbatm_data *instance = (struct usbatm_data *)data;
 494         struct urb *urb;
 495
 496         while ((urb = usbatm_pop_urb(&instance->rx_channel))) {
 497                 vdbg("%s: processing urb 0x%p", __func__, urb);
 498
 499                 if (usb_pipeisoc(urb->pipe)) {
 500                         int i;
 501                         for (i = 0; i < urb->number_of_packets; i++)
 502                                 if (!urb->iso_frame_desc[i].status)
 503                                         usbatm_extract_cells(instance,
 504                                                              (u8 *)urb->transfer_buffer + urb->iso_frame_desc[i].offset,
 505                                                              urb->iso_frame_desc[i].actual_length);
 506                 }
 507                 else
 508                         if (!urb->status)
 509                                 usbatm_extract_cells(instance, urb->transfer_buffer, urb->actual_length);
 510
 511                 if (usbatm_submit_urb(urb))
 512                         return;
 513         }
 514 }
 515
 516
 517 /***********
 518 **  send  **
 519 ***********/
 520
 521 static void usbatm_tx_process(unsigned long data)
 522 {
 523         struct usbatm_data *instance = (struct usbatm_data *)data;
 524         struct sk_buff *skb = instance->current_skb;
 525         struct urb *urb = NULL;
 526         const unsigned int buf_size = instance->tx_channel.buf_size;
 527         unsigned int num_written = 0;
 528         u8 *buffer = NULL;
 529
 530         if (!skb)
 531                 skb = skb_dequeue(&instance->sndqueue);
 532
 533         while (skb) {
 534                 if (!urb) {
 535                         urb = usbatm_pop_urb(&instance->tx_channel);
 536                         if (!urb)
 537                                 break;          /* no more senders */
 538                         buffer = urb->transfer_buffer;
 539                         num_written = (urb->status == -EAGAIN) ?
 540                                 urb->transfer_buffer_length : 0;
 541                 }
 542
 543                 num_written += usbatm_write_cells(instance, skb,
 544                                                   buffer + num_written,
 545                                                   buf_size - num_written);
 546
 547                 vdbg("%s: wrote %u bytes from skb 0x%p to urb 0x%p",
 548                      __func__, num_written, skb, urb);
 549
 550                 if (!UDSL_SKB(skb)->len) {
 551                         struct atm_vcc *vcc = UDSL_SKB(skb)->atm.vcc;
 552
 553                         usbatm_pop(vcc, skb);
 554                         atomic_inc(&vcc->stats->tx);
 555
 556                         skb = skb_dequeue(&instance->sndqueue);
 557                 }
 558
 559                 if (num_written == buf_size || (!skb && num_written)) {
 560                         urb->transfer_buffer_length = num_written;
 561
 562                         if (usbatm_submit_urb(urb))
 563                                 break;
 564                         urb = NULL;
 565                 }
 566         }
 567
 568         instance->current_skb = skb;
 569 }
 570
 571 static void usbatm_cancel_send(struct usbatm_data *instance,
 572                                struct atm_vcc *vcc)
 573 {
 574         struct sk_buff *skb, *n;
 575
 576         atm_dbg(instance, "%s entered\n", __func__);
 577         spin_lock_irq(&instance->sndqueue.lock);
 578         for (skb = instance->sndqueue.next, n = skb->next;
 579              skb != (struct sk_buff *)&instance->sndqueue;
 580              skb = n, n = skb->next)
 581                 if (UDSL_SKB(skb)->atm.vcc == vcc) {
 582                         atm_dbg(instance, "%s: popping skb 0x%p\n", __func__, skb);
 583                         __skb_unlink(skb, &instance->sndqueue);
 584                         usbatm_pop(vcc, skb);
 585                 }
 586         spin_unlock_irq(&instance->sndqueue.lock);
 587
 588         tasklet_disable(&instance->tx_channel.tasklet);
 589         if ((skb = instance->current_skb) && (UDSL_SKB(skb)->atm.vcc == vcc)) {
 590                 atm_dbg(instance, "%s: popping current skb (0x%p)\n", __func__, skb);
 591                 instance->current_skb = NULL;
 592                 usbatm_pop(vcc, skb);
 593         }
 594         tasklet_enable(&instance->tx_channel.tasklet);
 595         atm_dbg(instance, "%s done\n", __func__);
 596 }
 597
 598 static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
 599 {
 600         struct usbatm_data *instance = vcc->dev->dev_data;
 601         struct usbatm_control *ctrl = UDSL_SKB(skb);
 602         int err;
 603
 604         vdbg("%s called (skb 0x%p, len %u)", __func__, skb, skb->len);
 605
 606         /* racy disconnection check - fine */
 607         if (!instance || instance->disconnected) {
 608 #ifdef DEBUG
 609                 if (printk_ratelimit())
 610                         printk(KERN_DEBUG "%s: %s!\n", __func__, instance ? "disconnected" : "NULL instance");
 611 #endif
 612                 err = -ENODEV;
 613                 goto fail;
 614         }
 615
 616         if (vcc->qos.aal != ATM_AAL5) {
 617                 atm_rldbg(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal);
 618                 err = -EINVAL;
 619                 goto fail;
 620         }
 621
 622         if (skb->len > ATM_MAX_AAL5_PDU) {
 623                 atm_rldbg(instance, "%s: packet too long (%d vs %d)!\n",
 624                                 __func__, skb->len, ATM_MAX_AAL5_PDU);
 625                 err = -EINVAL;
 626                 goto fail;
 627         }
 628
 629         PACKETDEBUG(skb->data, skb->len);
 630
 631         /* initialize the control block */
 632         ctrl->atm.vcc = vcc;
 633         ctrl->len = skb->len;
 634         ctrl->crc = crc32_be(~0, skb->data, skb->len);
 635
 636         skb_queue_tail(&instance->sndqueue, skb);
 637         tasklet_schedule(&instance->tx_channel.tasklet);
 638
 639         return 0;
 640
 641  fail:
 642         usbatm_pop(vcc, skb);
 643         return err;
 644 }
 645
 646
 647 /********************
 648 **  bean counting  **
 649 ********************/
 650
 651 static void usbatm_destroy_instance(struct kref *kref)
 652 {
 653         struct usbatm_data *instance = container_of(kref, struct usbatm_data, refcount);
 654
 655         dbg("%s", __func__);
 656
 657         tasklet_kill(&instance->rx_channel.tasklet);
 658         tasklet_kill(&instance->tx_channel.tasklet);
 659         usb_put_dev(instance->usb_dev);
 660         kfree(instance);
 661 }
 662
 663 static void usbatm_get_instance(struct usbatm_data *instance)
 664 {
 665         dbg("%s", __func__);
 666
 667         kref_get(&instance->refcount);
 668 }
 669
 670 static void usbatm_put_instance(struct usbatm_data *instance)
 671 {
 672         dbg("%s", __func__);
 673
 674         kref_put(&instance->refcount, usbatm_destroy_instance);
 675 }
 676
 677
 678 /**********
 679 **  ATM  **
 680 **********/
 681
 682 static void usbatm_atm_dev_close(struct atm_dev *atm_dev)
 683 {
 684         struct usbatm_data *instance = atm_dev->dev_data;
 685
 686         dbg("%s", __func__);
 687
 688         if (!instance)
 689                 return;
 690
 691         atm_dev->dev_data = NULL; /* catch bugs */
 692         usbatm_put_instance(instance);  /* taken in usbatm_atm_init */
 693 }
 694
 695 static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page)
 696 {
 697         struct usbatm_data *instance = atm_dev->dev_data;
 698         int left = *pos;
 699
 700         if (!instance) {
 701                 dbg("%s: NULL instance!", __func__);
 702                 return -ENODEV;
 703         }
 704
 705         if (!left--)
 706                 return sprintf(page, "%s\n", instance->description);
 707
 708         if (!left--)
 709                 return sprintf(page, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
 710                                atm_dev->esi[0], atm_dev->esi[1],
 711                                atm_dev->esi[2], atm_dev->esi[3],
 712                                atm_dev->esi[4], atm_dev->esi[5]);
 713
 714         if (!left--)
 715                 return sprintf(page,
 716                                "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
 717                                atomic_read(&atm_dev->stats.aal5.tx),
 718                                atomic_read(&atm_dev->stats.aal5.tx_err),
 719                                atomic_read(&atm_dev->stats.aal5.rx),
 720                                atomic_read(&atm_dev->stats.aal5.rx_err),
 721                                atomic_read(&atm_dev->stats.aal5.rx_drop));
 722
 723         if (!left--) {
 724                 if (instance->disconnected)
 725                         return sprintf(page, "Disconnected\n");
 726                 else
 727                         switch (atm_dev->signal) {
 728                         case ATM_PHY_SIG_FOUND:
 729                                 return sprintf(page, "Line up\n");
 730                         case ATM_PHY_SIG_LOST:
 731                                 return sprintf(page, "Line down\n");
 732                         default:
 733                                 return sprintf(page, "Line state unknown\n");
 734                         }
 735         }
 736
 737         return 0;
 738 }
 739
 740 static int usbatm_atm_open(struct atm_vcc *vcc)
 741 {
 742         struct usbatm_data *instance = vcc->dev->dev_data;
 743         struct usbatm_vcc_data *new = NULL;
 744         int ret;
 745         int vci = vcc->vci;
 746         short vpi = vcc->vpi;
 747
 748         if (!instance) {
 749                 dbg("%s: NULL data!", __func__);
 750                 return -ENODEV;
 751         }
 752
 753         atm_dbg(instance, "%s: vpi %hd, vci %d\n", __func__, vpi, vci);
 754
 755         /* only support AAL5 */
 756         if ((vcc->qos.aal != ATM_AAL5)) {
 757                 atm_warn(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal);
 758                 return -EINVAL;
 759         }
 760
 761         /* sanity checks */
 762         if ((vcc->qos.rxtp.max_sdu < 0) || (vcc->qos.rxtp.max_sdu > ATM_MAX_AAL5_PDU)) {
 763                 atm_dbg(instance, "%s: max_sdu %d out of range!\n", __func__, vcc->qos.rxtp.max_sdu);
 764                 return -EINVAL;
 765         }
 766
 767         down(&instance->serialize);     /* vs self, usbatm_atm_close, usbatm_usb_disconnect */
 768
 769         if (instance->disconnected) {
 770                 atm_dbg(instance, "%s: disconnected!\n", __func__);
 771                 ret = -ENODEV;
 772                 goto fail;
 773         }
 774
 775         if (usbatm_find_vcc(instance, vpi, vci)) {
 776                 atm_dbg(instance, "%s: %hd/%d already in use!\n", __func__, vpi, vci);
 777                 ret = -EADDRINUSE;
 778                 goto fail;
 779         }
 780
 781         if (!(new = kzalloc(sizeof(struct usbatm_vcc_data), GFP_KERNEL))) {
 782                 atm_err(instance, "%s: no memory for vcc_data!\n", __func__);
 783                 ret = -ENOMEM;
 784                 goto fail;
 785         }
 786
 787         new->vcc = vcc;
 788         new->vpi = vpi;
 789         new->vci = vci;
 790
 791         new->sarb = alloc_skb(usbatm_pdu_length(vcc->qos.rxtp.max_sdu), GFP_KERNEL);
 792         if (!new->sarb) {
 793                 atm_err(instance, "%s: no memory for SAR buffer!\n", __func__);
 794                 ret = -ENOMEM;
 795                 goto fail;
 796         }
 797
 798         vcc->dev_data = new;
 799
 800         tasklet_disable(&instance->rx_channel.tasklet);
 801         list_add(&new->list, &instance->vcc_list);
 802         tasklet_enable(&instance->rx_channel.tasklet);
 803
 804         set_bit(ATM_VF_ADDR, &vcc->flags);
 805         set_bit(ATM_VF_PARTIAL, &vcc->flags);
 806         set_bit(ATM_VF_READY, &vcc->flags);
 807
 808         up(&instance->serialize);
 809
 810         atm_dbg(instance, "%s: allocated vcc data 0x%p\n", __func__, new);
 811
 812         return 0;
 813
 814 fail:
 815         kfree(new);
 816         up(&instance->serialize);
 817         return ret;
 818 }
 819
 820 static void usbatm_atm_close(struct atm_vcc *vcc)
 821 {
 822         struct usbatm_data *instance = vcc->dev->dev_data;
 823         struct usbatm_vcc_data *vcc_data = vcc->dev_data;
 824
 825         if (!instance || !vcc_data) {
 826                 dbg("%s: NULL data!", __func__);
 827                 return;
 828         }
 829
 830         atm_dbg(instance, "%s entered\n", __func__);
 831
 832         atm_dbg(instance, "%s: deallocating vcc 0x%p with vpi %d vci %d\n",
 833                 __func__, vcc_data, vcc_data->vpi, vcc_data->vci);
 834
 835         usbatm_cancel_send(instance, vcc);
 836
 837         down(&instance->serialize);     /* vs self, usbatm_atm_open, usbatm_usb_disconnect */
 838
 839         tasklet_disable(&instance->rx_channel.tasklet);
 840         list_del(&vcc_data->list);
 841         tasklet_enable(&instance->rx_channel.tasklet);
 842
 843         kfree_skb(vcc_data->sarb);
 844         vcc_data->sarb = NULL;
 845
 846         kfree(vcc_data);
 847         vcc->dev_data = NULL;
 848
 849         vcc->vpi = ATM_VPI_UNSPEC;
 850         vcc->vci = ATM_VCI_UNSPEC;
 851         clear_bit(ATM_VF_READY, &vcc->flags);
 852         clear_bit(ATM_VF_PARTIAL, &vcc->flags);
 853         clear_bit(ATM_VF_ADDR, &vcc->flags);
 854
 855         up(&instance->serialize);
 856
 857         atm_dbg(instance, "%s successful\n", __func__);
 858 }
 859
 860 static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd,
 861                           void __user * arg)
 862 {
 863         struct usbatm_data *instance = atm_dev->dev_data;
 864
 865         if (!instance || instance->disconnected) {
 866                 dbg("%s: %s!", __func__, instance ? "disconnected" : "NULL instance");
 867                 return -ENODEV;
 868         }
 869
 870         switch (cmd) {
 871         case ATM_QUERYLOOP:
 872                 return put_user(ATM_LM_NONE, (int __user *)arg) ? -EFAULT : 0;
 873         default:
 874                 return -ENOIOCTLCMD;
 875         }
 876 }
 877
 878 static int usbatm_atm_init(struct usbatm_data *instance)
 879 {
 880         struct atm_dev *atm_dev;
 881         int ret, i;
 882
 883         /* ATM init.  The ATM initialization scheme suffers from an intrinsic race
 884          * condition: callbacks we register can be executed at once, before we have
 885          * initialized the struct atm_dev.  To protect against this, all callbacks
 886          * abort if atm_dev->dev_data is NULL. */
 887         atm_dev = atm_dev_register(instance->driver_name, &usbatm_atm_devops, -1, NULL);
 888         if (!atm_dev) {
 889                 usb_err(instance, "%s: failed to register ATM device!\n", __func__);
 890                 return -1;
 891         }
 892
 893         instance->atm_dev = atm_dev;
 894
 895         atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
 896         atm_dev->ci_range.vci_bits = ATM_CI_MAX;
 897         atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
 898
 899         /* temp init ATM device, set to 128kbit */
 900         atm_dev->link_rate = 128 * 1000 / 424;
 901
 902         if (instance->driver->atm_start && ((ret = instance->driver->atm_start(instance, atm_dev)) < 0)) {
 903                 atm_err(instance, "%s: atm_start failed: %d!\n", __func__, ret);
 904                 goto fail;
 905         }
 906
 907         usbatm_get_instance(instance);  /* dropped in usbatm_atm_dev_close */
 908
 909         /* ready for ATM callbacks */
 910         mb();
 911         atm_dev->dev_data = instance;
 912
 913         /* submit all rx URBs */
 914         for (i = 0; i < num_rcv_urbs; i++)
 915                 usbatm_submit_urb(instance->urbs[i]);
 916
 917         return 0;
 918
 919  fail:
 920         instance->atm_dev = NULL;
 921         atm_dev_deregister(atm_dev); /* usbatm_atm_dev_close will eventually be called */
 922         return ret;
 923 }
 924
 925
 926 /**********
 927 **  USB  **
 928 **********/
 929
 930 static int usbatm_do_heavy_init(void *arg)
 931 {
 932         struct usbatm_data *instance = arg;
 933         int ret;
 934
 935         daemonize(instance->driver->driver_name);
 936         allow_signal(SIGTERM);
 937
 938         complete(&instance->thread_started);
 939
 940         ret = instance->driver->heavy_init(instance, instance->usb_intf);
 941
 942         if (!ret)
 943                 ret = usbatm_atm_init(instance);
 944
 945         down(&instance->serialize);
 946         instance->thread_pid = -1;
 947         up(&instance->serialize);
 948
 949         complete_and_exit(&instance->thread_exited, ret);
 950 }
 951
 952 static int usbatm_heavy_init(struct usbatm_data *instance)
 953 {
 954         int ret = kernel_thread(usbatm_do_heavy_init, instance, CLONE_KERNEL);
 955
 956         if (ret < 0) {
 957                 usb_err(instance, "%s: failed to create kernel_thread (%d)!\n", __func__, ret);
 958                 return ret;
 959         }
 960
 961         down(&instance->serialize);
 962         instance->thread_pid = ret;
 963         up(&instance->serialize);
 964
 965         wait_for_completion(&instance->thread_started);
 966
 967         return 0;
 968 }
 969
 970 static void usbatm_tasklet_schedule(unsigned long data)
 971 {
 972         tasklet_schedule((struct tasklet_struct *) data);
 973 }
 974
 975 static inline void usbatm_init_channel(struct usbatm_channel *channel)
 976 {
 977         spin_lock_init(&channel->lock);
 978         INIT_LIST_HEAD(&channel->list);
 979         channel->delay.function = usbatm_tasklet_schedule;
 980         channel->delay.data = (unsigned long) &channel->tasklet;
 981         init_timer(&channel->delay);
 982 }
 983
 984 int usbatm_usb_probe(struct usb_interface *intf, const struct usb_device_id *id,
 985                      struct usbatm_driver *driver)
 986 {
 987         struct device *dev = &intf->dev;
 988         struct usb_device *usb_dev = interface_to_usbdev(intf);
 989         struct usbatm_data *instance;
 990         char *buf;
 991         int error = -ENOMEM;
 992         int i, length;
 993
 994         dev_dbg(dev, "%s: trying driver %s with vendor=%04x, product=%04x, ifnum %2d\n",
 995                         __func__, driver->driver_name,
 996                         le16_to_cpu(usb_dev->descriptor.idVendor),
 997                         le16_to_cpu(usb_dev->descriptor.idProduct),
 998                         intf->altsetting->desc.bInterfaceNumber);
 999
1000         /* instance init */
1001         instance = kzalloc(sizeof(*instance) + sizeof(struct urb *) * (num_rcv_urbs + num_snd_urbs), GFP_KERNEL);
1002         if (!instance) {
1003                 dev_err(dev, "%s: no memory for instance data!\n", __func__);
1004                 return -ENOMEM;
1005         }
1006
1007         /* public fields */
1008
1009         instance->driver = driver;
1010         snprintf(instance->driver_name, sizeof(instance->driver_name), driver->driver_name);
1011
1012         instance->usb_dev = usb_dev;
1013         instance->usb_intf = intf;
1014
1015         buf = instance->description;
1016         length = sizeof(instance->description);
1017
1018         if ((i = usb_string(usb_dev, usb_dev->descriptor.iProduct, buf, length)) < 0)
1019                 goto bind;
1020
1021         buf += i;
1022         length -= i;
1023
1024         i = scnprintf(buf, length, " (");
1025         buf += i;
1026         length -= i;
1027
1028         if (length <= 0 || (i = usb_make_path(usb_dev, buf, length)) < 0)
1029                 goto bind;
1030
1031         buf += i;
1032         length -= i;
1033
1034         snprintf(buf, length, ")");
1035
1036  bind:
1037         if (driver->bind && (error = driver->bind(instance, intf, id)) < 0) {
1038                         dev_err(dev, "%s: bind failed: %d!\n", __func__, error);
1039                         goto fail_free;
1040         }
1041
1042         /* private fields */
1043
1044         kref_init(&instance->refcount);         /* dropped in usbatm_usb_disconnect */
1045         init_MUTEX(&instance->serialize);
1046
1047         instance->thread_pid = -1;
1048         init_completion(&instance->thread_started);
1049         init_completion(&instance->thread_exited);
1050
1051         INIT_LIST_HEAD(&instance->vcc_list);
1052
1053         usbatm_init_channel(&instance->rx_channel);
1054         usbatm_init_channel(&instance->tx_channel);
1055         tasklet_init(&instance->rx_channel.tasklet, usbatm_rx_process, (unsigned long)instance);
1056         tasklet_init(&instance->tx_channel.tasklet, usbatm_tx_process, (unsigned long)instance);
1057         instance->rx_channel.endpoint = usb_rcvbulkpipe(usb_dev, driver->in);
1058         instance->tx_channel.endpoint = usb_sndbulkpipe(usb_dev, driver->out);
1059         instance->rx_channel.stride = ATM_CELL_SIZE + driver->rx_padding;
1060         instance->tx_channel.stride = ATM_CELL_SIZE + driver->tx_padding;
1061         instance->rx_channel.buf_size = rcv_buf_size * instance->rx_channel.stride;
1062         instance->tx_channel.buf_size = snd_buf_size * instance->tx_channel.stride;
1063         instance->rx_channel.usbatm = instance->tx_channel.usbatm = instance;
1064
1065         skb_queue_head_init(&instance->sndqueue);
1066
1067         for (i = 0; i < num_rcv_urbs + num_snd_urbs; i++) {
1068                 struct urb *urb;
1069                 u8 *buffer;
1070                 unsigned int iso_packets = 0, iso_size = 0;
1071                 struct usbatm_channel *channel = i < num_rcv_urbs ?
1072                         &instance->rx_channel : &instance->tx_channel;
1073
1074                 if (usb_pipeisoc(channel->endpoint)) {
1075                         /* don't expect iso out endpoints */
1076                         iso_size = usb_maxpacket(instance->usb_dev, channel->endpoint, 0);
1077                         iso_size -= iso_size % channel->stride; /* alignment */
1078                         BUG_ON(!iso_size);
1079                         iso_packets = (channel->buf_size - 1) / iso_size + 1;
1080                 }
1081
1082                 urb = usb_alloc_urb(iso_packets, GFP_KERNEL);
1083                 if (!urb) {
1084                         dev_err(dev, "%s: no memory for urb %d!\n", __func__, i);
1085                         error = -ENOMEM;
1086                         goto fail_unbind;
1087                 }
1088
1089                 instance->urbs[i] = urb;
1090
1091                 /* zero the tx padding to avoid leaking information */
1092                 buffer = kzalloc(channel->buf_size, GFP_KERNEL);
1093                 if (!buffer) {
1094                         dev_err(dev, "%s: no memory for buffer %d!\n", __func__, i);
1095                         error = -ENOMEM;
1096                         goto fail_unbind;
1097                 }
1098
1099                 usb_fill_bulk_urb(urb, instance->usb_dev, channel->endpoint,
1100                                   buffer, channel->buf_size, usbatm_complete, channel);
1101                 if (iso_packets) {
1102                         int j;
1103                         urb->interval = 1;
1104                         urb->transfer_flags = URB_ISO_ASAP;
1105                         urb->number_of_packets = iso_packets;
1106                         for (j = 0; j < iso_packets; j++) {
1107                                 urb->iso_frame_desc[j].offset = iso_size * j;
1108                                 urb->iso_frame_desc[j].length = min_t(int, iso_size,
1109                                                                       channel->buf_size - urb->iso_frame_desc[j].offset);
1110                         }
1111                 }
1112
1113                 /* put all tx URBs on the list of spares */
1114                 if (i >= num_rcv_urbs)
1115                         list_add_tail(&urb->urb_list, &channel->list);
1116
1117                 vdbg("%s: alloced buffer 0x%p buf size %u urb 0x%p",
1118                      __func__, urb->transfer_buffer, urb->transfer_buffer_length, urb);
1119         }
1120
1121         if (!(instance->flags & UDSL_SKIP_HEAVY_INIT) && driver->heavy_init) {
1122                 error = usbatm_heavy_init(instance);
1123         } else {
1124                 complete(&instance->thread_exited);     /* pretend that heavy_init was run */
1125                 error = usbatm_atm_init(instance);
1126         }
1127
1128         if (error < 0)
1129                 goto fail_unbind;
1130
1131         usb_get_dev(usb_dev);
1132         usb_set_intfdata(intf, instance);
1133
1134         return 0;
1135
1136  fail_unbind:
1137         if (instance->driver->unbind)
1138                 instance->driver->unbind(instance, intf);
1139  fail_free:
1140         for (i = 0; i < num_rcv_urbs + num_snd_urbs; i++) {
1141                 if (instance->urbs[i])
1142                         kfree(instance->urbs[i]->transfer_buffer);
1143                 usb_free_urb(instance->urbs[i]);
1144         }
1145
1146         kfree (instance);
1147
1148         return error;
1149 }
1150 EXPORT_SYMBOL_GPL(usbatm_usb_probe);
1151
1152 void usbatm_usb_disconnect(struct usb_interface *intf)
1153 {
1154         struct device *dev = &intf->dev;
1155         struct usbatm_data *instance = usb_get_intfdata(intf);
1156         struct usbatm_vcc_data *vcc_data;
1157         int i;
1158
1159         dev_dbg(dev, "%s entered\n", __func__);
1160
1161         if (!instance) {
1162                 dev_dbg(dev, "%s: NULL instance!\n", __func__);
1163                 return;
1164         }
1165
1166         usb_set_intfdata(intf, NULL);
1167
1168         down(&instance->serialize);
1169         instance->disconnected = 1;
1170         if (instance->thread_pid >= 0)
1171                 kill_proc(instance->thread_pid, SIGTERM, 1);
1172         up(&instance->serialize);
1173
1174         wait_for_completion(&instance->thread_exited);
1175
1176         down(&instance->serialize);
1177         list_for_each_entry(vcc_data, &instance->vcc_list, list)
1178                 vcc_release_async(vcc_data->vcc, -EPIPE);
1179         up(&instance->serialize);
1180
1181         tasklet_disable(&instance->rx_channel.tasklet);
1182         tasklet_disable(&instance->tx_channel.tasklet);
1183
1184         for (i = 0; i < num_rcv_urbs + num_snd_urbs; i++)
1185                 usb_kill_urb(instance->urbs[i]);
1186
1187         del_timer_sync(&instance->rx_channel.delay);
1188         del_timer_sync(&instance->tx_channel.delay);
1189
1190         /* turn usbatm_[rt]x_process into something close to a no-op */
1191         /* no need to take the spinlock */
1192         INIT_LIST_HEAD(&instance->rx_channel.list);
1193         INIT_LIST_HEAD(&instance->tx_channel.list);
1194
1195         tasklet_enable(&instance->rx_channel.tasklet);
1196         tasklet_enable(&instance->tx_channel.tasklet);
1197
1198         if (instance->atm_dev && instance->driver->atm_stop)
1199                 instance->driver->atm_stop(instance, instance->atm_dev);
1200
1201         if (instance->driver->unbind)
1202                 instance->driver->unbind(instance, intf);
1203
1204         instance->driver_data = NULL;
1205
1206         for (i = 0; i < num_rcv_urbs + num_snd_urbs; i++) {
1207                 kfree(instance->urbs[i]->transfer_buffer);
1208                 usb_free_urb(instance->urbs[i]);
1209         }
1210
1211         /* ATM finalize */
1212         if (instance->atm_dev)
1213                 atm_dev_deregister(instance->atm_dev);
1214
1215         usbatm_put_instance(instance);  /* taken in usbatm_usb_probe */
1216 }
1217 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect);
1218
1219
1220 /***********
1221 **  init  **
1222 ***********/
1223
1224 static int __init usbatm_usb_init(void)
1225 {
1226         dbg("%s: driver version %s", __func__, DRIVER_VERSION);
1227
1228         if (sizeof(struct usbatm_control) > sizeof(((struct sk_buff *) 0)->cb)) {
1229                 printk(KERN_ERR "%s unusable with this kernel!\n", usbatm_driver_name);
1230                 return -EIO;
1231         }
1232
1233         if ((num_rcv_urbs > UDSL_MAX_RCV_URBS)
1234             || (num_snd_urbs > UDSL_MAX_SND_URBS)
1235             || (rcv_buf_size < 1)
1236             || (rcv_buf_size > UDSL_MAX_RCV_BUF_SIZE)
1237             || (snd_buf_size < 1)
1238             || (snd_buf_size > UDSL_MAX_SND_BUF_SIZE))
1239                 return -EINVAL;
1240
1241         return 0;
1242 }
1243 module_init(usbatm_usb_init);
1244
1245 static void __exit usbatm_usb_exit(void)
1246 {
1247         dbg("%s", __func__);
1248 }
1249 module_exit(usbatm_usb_exit);
1250
1251 MODULE_AUTHOR(DRIVER_AUTHOR);
1252 MODULE_DESCRIPTION(DRIVER_DESC);
1253 MODULE_LICENSE("GPL");
1254 MODULE_VERSION(DRIVER_VERSION);
1255
1256 /************
1257 **  debug  **
1258 ************/
1259
1260 #ifdef VERBOSE_DEBUG
1261 static int usbatm_print_packet(const unsigned char *data, int len)
1262 {
1263         unsigned char buffer[256];
1264         int i = 0, j = 0;
1265
1266         for (i = 0; i < len;) {
1267                 buffer[0] = '\0';
1268                 sprintf(buffer, "%.3d :", i);
1269                 for (j = 0; (j < 16) && (i < len); j++, i++) {
1270                         sprintf(buffer, "%s %2.2x", buffer, data[i]);
1271                 }
1272                 dbg("%s", buffer);
1273         }
1274         return i;
1275 }
1276 #endif