drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   6  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License version
  10  *      2 as published by the Free Software Foundation.
  11  *
  12  * This driver was originally based on the ACM driver by Armin Fuerst (which was
  13  * based on a driver by Brad Keryan)
  14  *
  15  * See Documentation/usb/usb-serial.txt for more information on using this
  16  * driver
  17  *
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/tty.h>
  25 #include <linux/tty_driver.h>
  26 #include <linux/tty_flip.h>
  27 #include <linux/module.h>
  28 #include <linux/moduleparam.h>
  29 #include <linux/seq_file.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/mutex.h>
  32 #include <linux/list.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/usb.h>
  35 #include <linux/usb/serial.h>
  36 #include "pl2303.h"
  37
  38 /*
  39  * Version Information
  40  */
  41 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
  42 #define DRIVER_DESC "USB Serial Driver core"
  43
  44 static void port_free(struct usb_serial_port *port);
  45
  46 /* Driver structure we register with the USB core */
  47 static struct usb_driver usb_serial_driver = {
  48         .name =         "usbserial",
  49         .probe =        usb_serial_probe,
  50         .disconnect =   usb_serial_disconnect,
  51         .suspend =      usb_serial_suspend,
  52         .resume =       usb_serial_resume,
  53         .no_dynamic_id =        1,
  54 };
  55
  56 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  57    the MODULE_DEVICE_TABLE declarations in each serial driver
  58    cause the "hotplug" program to pull in whatever module is necessary
  59    via modprobe, and modprobe will load usbserial because the serial
  60    drivers depend on it.
  61 */
  62
  63 static int debug;
  64 /* initially all NULL */
  65 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
  66 static DEFINE_MUTEX(table_lock);
  67 static LIST_HEAD(usb_serial_driver_list);
  68
  69 struct usb_serial *usb_serial_get_by_index(unsigned index)
  70 {
  71         struct usb_serial *serial;
  72
  73         mutex_lock(&table_lock);
  74         serial = serial_table[index];
  75
  76         if (serial)
  77                 kref_get(&serial->kref);
  78         mutex_unlock(&table_lock);
  79         return serial;
  80 }
  81
  82 static struct usb_serial *get_free_serial(struct usb_serial *serial,
  83                                         int num_ports, unsigned int *minor)
  84 {
  85         unsigned int i, j;
  86         int good_spot;
  87
  88         dbg("%s %d", __func__, num_ports);
  89
  90         *minor = 0;
  91         mutex_lock(&table_lock);
  92         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
  93                 if (serial_table[i])
  94                         continue;
  95
  96                 good_spot = 1;
  97                 for (j = 1; j <= num_ports-1; ++j)
  98                         if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
  99                                 good_spot = 0;
 100                                 i += j;
 101                                 break;
 102                         }
 103                 if (good_spot == 0)
 104                         continue;
 105
 106                 *minor = i;
 107                 j = 0;
 108                 dbg("%s - minor base = %d", __func__, *minor);
 109                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
 110                         serial_table[i] = serial;
 111                         serial->port[j++]->number = i;
 112                 }
 113                 mutex_unlock(&table_lock);
 114                 return serial;
 115         }
 116         mutex_unlock(&table_lock);
 117         return NULL;
 118 }
 119
 120 static void return_serial(struct usb_serial *serial)
 121 {
 122         int i;
 123
 124         dbg("%s", __func__);
 125
 126         for (i = 0; i < serial->num_ports; ++i)
 127                 serial_table[serial->minor + i] = NULL;
 128 }
 129
 130 static void destroy_serial(struct kref *kref)
 131 {
 132         struct usb_serial *serial;
 133         struct usb_serial_port *port;
 134         int i;
 135
 136         serial = to_usb_serial(kref);
 137
 138         dbg("%s - %s", __func__, serial->type->description);
 139
 140         /* return the minor range that this device had */
 141         if (serial->minor != SERIAL_TTY_NO_MINOR)
 142                 return_serial(serial);
 143
 144         /* If this is a "fake" port, we have to clean it up here, as it will
 145          * not get cleaned up in port_release() as it was never registered with
 146          * the driver core */
 147         if (serial->num_ports < serial->num_port_pointers) {
 148                 for (i = serial->num_ports;
 149                                         i < serial->num_port_pointers; ++i) {
 150                         port = serial->port[i];
 151                         if (!port)
 152                                 continue;
 153                         port_free(port);
 154                 }
 155         }
 156
 157         usb_put_dev(serial->dev);
 158
 159         /* free up any memory that we allocated */
 160         kfree(serial);
 161 }
 162
 163 void usb_serial_put(struct usb_serial *serial)
 164 {
 165         mutex_lock(&table_lock);
 166         kref_put(&serial->kref, destroy_serial);
 167         mutex_unlock(&table_lock);
 168 }
 169
 170 /*****************************************************************************
 171  * Driver tty interface functions
 172  *****************************************************************************/
 173 static int serial_open (struct tty_struct *tty, struct file *filp)
 174 {
 175         struct usb_serial *serial;
 176         struct usb_serial_port *port;
 177         unsigned int portNumber;
 178         int retval = 0;
 179
 180         dbg("%s", __func__);
 181
 182         /* get the serial object associated with this tty pointer */
 183         serial = usb_serial_get_by_index(tty->index);
 184         if (!serial) {
 185                 tty->driver_data = NULL;
 186                 return -ENODEV;
 187         }
 188
 189         mutex_lock(&serial->disc_mutex);
 190         portNumber = tty->index - serial->minor;
 191         port = serial->port[portNumber];
 192         if (!port || serial->disconnected)
 193                 retval = -ENODEV;
 194         else
 195                 get_device(&port->dev);
 196         /*
 197          * Note: Our locking order requirement does not allow port->mutex
 198          * to be acquired while serial->disc_mutex is held.
 199          */
 200         mutex_unlock(&serial->disc_mutex);
 201         if (retval)
 202                 goto bailout_serial_put;
 203
 204         if (mutex_lock_interruptible(&port->mutex)) {
 205                 retval = -ERESTARTSYS;
 206                 goto bailout_port_put;
 207         }
 208
 209         ++port->port.count;
 210
 211         /* set up our port structure making the tty driver
 212          * remember our port object, and us it */
 213         tty->driver_data = port;
 214         tty_port_tty_set(&port->port, tty);
 215
 216         if (port->port.count == 1) {
 217
 218                 /* lock this module before we call it
 219                  * this may fail, which means we must bail out,
 220                  * safe because we are called with BKL held */
 221                 if (!try_module_get(serial->type->driver.owner)) {
 222                         retval = -ENODEV;
 223                         goto bailout_mutex_unlock;
 224                 }
 225
 226                 mutex_lock(&serial->disc_mutex);
 227                 if (serial->disconnected)
 228                         retval = -ENODEV;
 229                 else
 230                         retval = usb_autopm_get_interface(serial->interface);
 231                 if (retval)
 232                         goto bailout_module_put;
 233
 234                 /* only call the device specific open if this
 235                  * is the first time the port is opened */
 236                 retval = serial->type->open(tty, port, filp);
 237                 if (retval)
 238                         goto bailout_interface_put;
 239                 mutex_unlock(&serial->disc_mutex);
 240         }
 241
 242         mutex_unlock(&port->mutex);
 243         return 0;
 244
 245 bailout_interface_put:
 246         usb_autopm_put_interface(serial->interface);
 247 bailout_module_put:
 248         mutex_unlock(&serial->disc_mutex);
 249         module_put(serial->type->driver.owner);
 250 bailout_mutex_unlock:
 251         port->port.count = 0;
 252         tty->driver_data = NULL;
 253         tty_port_tty_set(&port->port, NULL);
 254         mutex_unlock(&port->mutex);
 255 bailout_port_put:
 256         put_device(&port->dev);
 257 bailout_serial_put:
 258         usb_serial_put(serial);
 259         return retval;
 260 }
 261
 262 static void serial_close(struct tty_struct *tty, struct file *filp)
 263 {
 264         struct usb_serial_port *port = tty->driver_data;
 265         struct usb_serial *serial;
 266         struct module *owner;
 267         int count;
 268
 269         if (!port)
 270                 return;
 271
 272         dbg("%s - port %d", __func__, port->number);
 273
 274         mutex_lock(&port->mutex);
 275         serial = port->serial;
 276         owner = serial->type->driver.owner;
 277
 278         if (port->port.count == 0) {
 279                 mutex_unlock(&port->mutex);
 280                 return;
 281         }
 282
 283         if (port->port.count == 1)
 284                 /* only call the device specific close if this
 285                  * port is being closed by the last owner. Ensure we do
 286                  * this before we drop the port count. The call is protected
 287                  * by the port mutex
 288                  */
 289                 serial->type->close(tty, port, filp);
 290
 291         if (port->port.count == (port->console ? 2 : 1)) {
 292                 struct tty_struct *tty = tty_port_tty_get(&port->port);
 293                 if (tty) {
 294                         /* We must do this before we drop the port count to
 295                            zero. */
 296                         if (tty->driver_data)
 297                                 tty->driver_data = NULL;
 298                         tty_port_tty_set(&port->port, NULL);
 299                         tty_kref_put(tty);
 300                 }
 301         }
 302
 303         --port->port.count;
 304         count = port->port.count;
 305         mutex_unlock(&port->mutex);
 306         put_device(&port->dev);
 307
 308         /* Mustn't dereference port any more */
 309         if (count == 0) {
 310                 mutex_lock(&serial->disc_mutex);
 311                 if (!serial->disconnected)
 312                         usb_autopm_put_interface(serial->interface);
 313                 mutex_unlock(&serial->disc_mutex);
 314         }
 315         usb_serial_put(serial);
 316
 317         /* Mustn't dereference serial any more */
 318         if (count == 0)
 319                 module_put(owner);
 320 }
 321
 322 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 323                                                                 int count)
 324 {
 325         struct usb_serial_port *port = tty->driver_data;
 326         int retval = -ENODEV;
 327
 328         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 329                 goto exit;
 330
 331         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 332
 333         /* count is managed under the mutex lock for the tty so cannot
 334            drop to zero until after the last close completes */
 335         WARN_ON(!port->port.count);
 336
 337         /* pass on to the driver specific version of this function */
 338         retval = port->serial->type->write(tty, port, buf, count);
 339
 340 exit:
 341         return retval;
 342 }
 343
 344 static int serial_write_room(struct tty_struct *tty)
 345 {
 346         struct usb_serial_port *port = tty->driver_data;
 347         dbg("%s - port %d", __func__, port->number);
 348         WARN_ON(!port->port.count);
 349         /* pass on to the driver specific version of this function */
 350         return port->serial->type->write_room(tty);
 351 }
 352
 353 static int serial_chars_in_buffer(struct tty_struct *tty)
 354 {
 355         struct usb_serial_port *port = tty->driver_data;
 356         dbg("%s = port %d", __func__, port->number);
 357
 358         WARN_ON(!port->port.count);
 359         /* if the device was unplugged then any remaining characters
 360            fell out of the connector ;) */
 361         if (port->serial->disconnected)
 362                 return 0;
 363         /* pass on to the driver specific version of this function */
 364         return port->serial->type->chars_in_buffer(tty);
 365 }
 366
 367 static void serial_throttle(struct tty_struct *tty)
 368 {
 369         struct usb_serial_port *port = tty->driver_data;
 370         dbg("%s - port %d", __func__, port->number);
 371
 372         WARN_ON(!port->port.count);
 373         /* pass on to the driver specific version of this function */
 374         if (port->serial->type->throttle)
 375                 port->serial->type->throttle(tty);
 376 }
 377
 378 static void serial_unthrottle(struct tty_struct *tty)
 379 {
 380         struct usb_serial_port *port = tty->driver_data;
 381         dbg("%s - port %d", __func__, port->number);
 382
 383         WARN_ON(!port->port.count);
 384         /* pass on to the driver specific version of this function */
 385         if (port->serial->type->unthrottle)
 386                 port->serial->type->unthrottle(tty);
 387 }
 388
 389 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 390                                         unsigned int cmd, unsigned long arg)
 391 {
 392         struct usb_serial_port *port = tty->driver_data;
 393         int retval = -ENODEV;
 394
 395         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 396
 397         WARN_ON(!port->port.count);
 398
 399         /* pass on to the driver specific version of this function
 400            if it is available */
 401         if (port->serial->type->ioctl) {
 402                 retval = port->serial->type->ioctl(tty, file, cmd, arg);
 403         } else
 404                 retval = -ENOIOCTLCMD;
 405         return retval;
 406 }
 407
 408 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 409 {
 410         struct usb_serial_port *port = tty->driver_data;
 411         dbg("%s - port %d", __func__, port->number);
 412
 413         WARN_ON(!port->port.count);
 414         /* pass on to the driver specific version of this function
 415            if it is available */
 416         if (port->serial->type->set_termios)
 417                 port->serial->type->set_termios(tty, port, old);
 418         else
 419                 tty_termios_copy_hw(tty->termios, old);
 420 }
 421
 422 static int serial_break(struct tty_struct *tty, int break_state)
 423 {
 424         struct usb_serial_port *port = tty->driver_data;
 425
 426         dbg("%s - port %d", __func__, port->number);
 427
 428         WARN_ON(!port->port.count);
 429         /* pass on to the driver specific version of this function
 430            if it is available */
 431         if (port->serial->type->break_ctl)
 432                 port->serial->type->break_ctl(tty, break_state);
 433         return 0;
 434 }
 435
 436 static int serial_proc_show(struct seq_file *m, void *v)
 437 {
 438         struct usb_serial *serial;
 439         int i;
 440         char tmp[40];
 441
 442         dbg("%s", __func__);
 443         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 444         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 445                 serial = usb_serial_get_by_index(i);
 446                 if (serial == NULL)
 447                         continue;
 448
 449                 seq_printf(m, "%d:", i);
 450                 if (serial->type->driver.owner)
 451                         seq_printf(m, " module:%s",
 452                                 module_name(serial->type->driver.owner));
 453                 seq_printf(m, " name:\"%s\"",
 454                                 serial->type->description);
 455                 seq_printf(m, " vendor:%04x product:%04x",
 456                         le16_to_cpu(serial->dev->descriptor.idVendor),
 457                         le16_to_cpu(serial->dev->descriptor.idProduct));
 458                 seq_printf(m, " num_ports:%d", serial->num_ports);
 459                 seq_printf(m, " port:%d", i - serial->minor + 1);
 460                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 461                 seq_printf(m, " path:%s", tmp);
 462
 463                 seq_putc(m, '\n');
 464                 usb_serial_put(serial);
 465         }
 466         return 0;
 467 }
 468
 469 static int serial_proc_open(struct inode *inode, struct file *file)
 470 {
 471         return single_open(file, serial_proc_show, NULL);
 472 }
 473
 474 static const struct file_operations serial_proc_fops = {
 475         .owner          = THIS_MODULE,
 476         .open           = serial_proc_open,
 477         .read           = seq_read,
 478         .llseek         = seq_lseek,
 479         .release        = single_release,
 480 };
 481
 482 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 483 {
 484         struct usb_serial_port *port = tty->driver_data;
 485
 486         dbg("%s - port %d", __func__, port->number);
 487
 488         WARN_ON(!port->port.count);
 489         if (port->serial->type->tiocmget)
 490                 return port->serial->type->tiocmget(tty, file);
 491         return -EINVAL;
 492 }
 493
 494 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 495                             unsigned int set, unsigned int clear)
 496 {
 497         struct usb_serial_port *port = tty->driver_data;
 498
 499         dbg("%s - port %d", __func__, port->number);
 500
 501         WARN_ON(!port->port.count);
 502         if (port->serial->type->tiocmset)
 503                 return port->serial->type->tiocmset(tty, file, set, clear);
 504         return -EINVAL;
 505 }
 506
 507 /*
 508  * We would be calling tty_wakeup here, but unfortunately some line
 509  * disciplines have an annoying habit of calling tty->write from
 510  * the write wakeup callback (e.g. n_hdlc.c).
 511  */
 512 void usb_serial_port_softint(struct usb_serial_port *port)
 513 {
 514         schedule_work(&port->work);
 515 }
 516 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 517
 518 static void usb_serial_port_work(struct work_struct *work)
 519 {
 520         struct usb_serial_port *port =
 521                 container_of(work, struct usb_serial_port, work);
 522         struct tty_struct *tty;
 523
 524         dbg("%s - port %d", __func__, port->number);
 525
 526         tty = tty_port_tty_get(&port->port);
 527         if (!tty)
 528                 return;
 529
 530         tty_wakeup(tty);
 531         tty_kref_put(tty);
 532 }
 533
 534 static void port_release(struct device *dev)
 535 {
 536         struct usb_serial_port *port = to_usb_serial_port(dev);
 537
 538         dbg ("%s - %s", __func__, dev_name(dev));
 539         port_free(port);
 540 }
 541
 542 static void kill_traffic(struct usb_serial_port *port)
 543 {
 544         usb_kill_urb(port->read_urb);
 545         usb_kill_urb(port->write_urb);
 546         /*
 547          * This is tricky.
 548          * Some drivers submit the read_urb in the
 549          * handler for the write_urb or vice versa
 550          * this order determines the order in which
 551          * usb_kill_urb() must be used to reliably
 552          * kill the URBs. As it is unknown here,
 553          * both orders must be used in turn.
 554          * The call below is not redundant.
 555          */
 556         usb_kill_urb(port->read_urb);
 557         usb_kill_urb(port->interrupt_in_urb);
 558         usb_kill_urb(port->interrupt_out_urb);
 559 }
 560
 561 static void port_free(struct usb_serial_port *port)
 562 {
 563         /*
 564          * Stop all the traffic before cancelling the work, so that
 565          * nobody will restart it by calling usb_serial_port_softint.
 566          */
 567         kill_traffic(port);
 568         cancel_work_sync(&port->work);
 569
 570         usb_free_urb(port->read_urb);
 571         usb_free_urb(port->write_urb);
 572         usb_free_urb(port->interrupt_in_urb);
 573         usb_free_urb(port->interrupt_out_urb);
 574         kfree(port->bulk_in_buffer);
 575         kfree(port->bulk_out_buffer);
 576         kfree(port->interrupt_in_buffer);
 577         kfree(port->interrupt_out_buffer);
 578         kfree(port);
 579 }
 580
 581 static struct usb_serial *create_serial(struct usb_device *dev,
 582                                         struct usb_interface *interface,
 583                                         struct usb_serial_driver *driver)
 584 {
 585         struct usb_serial *serial;
 586
 587         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 588         if (!serial) {
 589                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 590                 return NULL;
 591         }
 592         serial->dev = usb_get_dev(dev);
 593         serial->type = driver;
 594         serial->interface = interface;
 595         kref_init(&serial->kref);
 596         mutex_init(&serial->disc_mutex);
 597         serial->minor = SERIAL_TTY_NO_MINOR;
 598
 599         return serial;
 600 }
 601
 602 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 603                                             struct usb_serial_driver *drv)
 604 {
 605         struct usb_dynid *dynid;
 606
 607         spin_lock(&drv->dynids.lock);
 608         list_for_each_entry(dynid, &drv->dynids.list, node) {
 609                 if (usb_match_one_id(intf, &dynid->id)) {
 610                         spin_unlock(&drv->dynids.lock);
 611                         return &dynid->id;
 612                 }
 613         }
 614         spin_unlock(&drv->dynids.lock);
 615         return NULL;
 616 }
 617
 618 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 619                                                 struct usb_interface *intf)
 620 {
 621         const struct usb_device_id *id;
 622
 623         id = usb_match_id(intf, drv->id_table);
 624         if (id) {
 625                 dbg("static descriptor matches");
 626                 goto exit;
 627         }
 628         id = match_dynamic_id(intf, drv);
 629         if (id)
 630                 dbg("dynamic descriptor matches");
 631 exit:
 632         return id;
 633 }
 634
 635 static struct usb_serial_driver *search_serial_device(
 636                                         struct usb_interface *iface)
 637 {
 638         const struct usb_device_id *id;
 639         struct usb_serial_driver *drv;
 640
 641         /* Check if the usb id matches a known device */
 642         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 643                 id = get_iface_id(drv, iface);
 644                 if (id)
 645                         return drv;
 646         }
 647
 648         return NULL;
 649 }
 650
 651 int usb_serial_probe(struct usb_interface *interface,
 652                                const struct usb_device_id *id)
 653 {
 654         struct usb_device *dev = interface_to_usbdev(interface);
 655         struct usb_serial *serial = NULL;
 656         struct usb_serial_port *port;
 657         struct usb_host_interface *iface_desc;
 658         struct usb_endpoint_descriptor *endpoint;
 659         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 660         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 661         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 662         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 663         struct usb_serial_driver *type = NULL;
 664         int retval;
 665         unsigned int minor;
 666         int buffer_size;
 667         int i;
 668         int num_interrupt_in = 0;
 669         int num_interrupt_out = 0;
 670         int num_bulk_in = 0;
 671         int num_bulk_out = 0;
 672         int num_ports = 0;
 673         int max_endpoints;
 674
 675         lock_kernel(); /* guard against unloading a serial driver module */
 676         type = search_serial_device(interface);
 677         if (!type) {
 678                 unlock_kernel();
 679                 dbg("none matched");
 680                 return -ENODEV;
 681         }
 682
 683         serial = create_serial(dev, interface, type);
 684         if (!serial) {
 685                 unlock_kernel();
 686                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 687                 return -ENOMEM;
 688         }
 689
 690         /* if this device type has a probe function, call it */
 691         if (type->probe) {
 692                 const struct usb_device_id *id;
 693
 694                 if (!try_module_get(type->driver.owner)) {
 695                         unlock_kernel();
 696                         dev_err(&interface->dev,
 697                                 "module get failed, exiting\n");
 698                         kfree(serial);
 699                         return -EIO;
 700                 }
 701
 702                 id = get_iface_id(type, interface);
 703                 retval = type->probe(serial, id);
 704                 module_put(type->driver.owner);
 705
 706                 if (retval) {
 707                         unlock_kernel();
 708                         dbg("sub driver rejected device");
 709                         kfree(serial);
 710                         return retval;
 711                 }
 712         }
 713
 714         /* descriptor matches, let's find the endpoints needed */
 715         /* check out the endpoints */
 716         iface_desc = interface->cur_altsetting;
 717         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 718                 endpoint = &iface_desc->endpoint[i].desc;
 719
 720                 if (usb_endpoint_is_bulk_in(endpoint)) {
 721                         /* we found a bulk in endpoint */
 722                         dbg("found bulk in on endpoint %d", i);
 723                         bulk_in_endpoint[num_bulk_in] = endpoint;
 724                         ++num_bulk_in;
 725                 }
 726
 727                 if (usb_endpoint_is_bulk_out(endpoint)) {
 728                         /* we found a bulk out endpoint */
 729                         dbg("found bulk out on endpoint %d", i);
 730                         bulk_out_endpoint[num_bulk_out] = endpoint;
 731                         ++num_bulk_out;
 732                 }
 733
 734                 if (usb_endpoint_is_int_in(endpoint)) {
 735                         /* we found a interrupt in endpoint */
 736                         dbg("found interrupt in on endpoint %d", i);
 737                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 738                         ++num_interrupt_in;
 739                 }
 740
 741                 if (usb_endpoint_is_int_out(endpoint)) {
 742                         /* we found an interrupt out endpoint */
 743                         dbg("found interrupt out on endpoint %d", i);
 744                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 745                         ++num_interrupt_out;
 746                 }
 747         }
 748
 749 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 750         /* BEGIN HORRIBLE HACK FOR PL2303 */
 751         /* this is needed due to the looney way its endpoints are set up */
 752         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 753              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 754             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 755              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 756             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 757              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 758             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 759              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 760                 if (interface != dev->actconfig->interface[0]) {
 761                         /* check out the endpoints of the other interface*/
 762                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 763                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 764                                 endpoint = &iface_desc->endpoint[i].desc;
 765                                 if (usb_endpoint_is_int_in(endpoint)) {
 766                                         /* we found a interrupt in endpoint */
 767                                         dbg("found interrupt in for Prolific device on separate interface");
 768                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 769                                         ++num_interrupt_in;
 770                                 }
 771                         }
 772                 }
 773
 774                 /* Now make sure the PL-2303 is configured correctly.
 775                  * If not, give up now and hope this hack will work
 776                  * properly during a later invocation of usb_serial_probe
 777                  */
 778                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 779                         unlock_kernel();
 780                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 781                         kfree(serial);
 782                         return -ENODEV;
 783                 }
 784         }
 785         /* END HORRIBLE HACK FOR PL2303 */
 786 #endif
 787
 788 #ifdef CONFIG_USB_SERIAL_GENERIC
 789         if (type == &usb_serial_generic_device) {
 790                 num_ports = num_bulk_out;
 791                 if (num_ports == 0) {
 792                         unlock_kernel();
 793                         dev_err(&interface->dev,
 794                             "Generic device with no bulk out, not allowed.\n");
 795                         kfree(serial);
 796                         return -EIO;
 797                 }
 798         }
 799 #endif
 800         if (!num_ports) {
 801                 /* if this device type has a calc_num_ports function, call it */
 802                 if (type->calc_num_ports) {
 803                         if (!try_module_get(type->driver.owner)) {
 804                                 unlock_kernel();
 805                                 dev_err(&interface->dev,
 806                                         "module get failed, exiting\n");
 807                                 kfree(serial);
 808                                 return -EIO;
 809                         }
 810                         num_ports = type->calc_num_ports(serial);
 811                         module_put(type->driver.owner);
 812                 }
 813                 if (!num_ports)
 814                         num_ports = type->num_ports;
 815         }
 816
 817         serial->num_ports = num_ports;
 818         serial->num_bulk_in = num_bulk_in;
 819         serial->num_bulk_out = num_bulk_out;
 820         serial->num_interrupt_in = num_interrupt_in;
 821         serial->num_interrupt_out = num_interrupt_out;
 822
 823         /* found all that we need */
 824         dev_info(&interface->dev, "%s converter detected\n",
 825                         type->description);
 826
 827         /* create our ports, we need as many as the max endpoints */
 828         /* we don't use num_ports here because some devices have more
 829            endpoint pairs than ports */
 830         max_endpoints = max(num_bulk_in, num_bulk_out);
 831         max_endpoints = max(max_endpoints, num_interrupt_in);
 832         max_endpoints = max(max_endpoints, num_interrupt_out);
 833         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 834         serial->num_port_pointers = max_endpoints;
 835         unlock_kernel();
 836
 837         dbg("%s - setting up %d port structures for this device",
 838                                                 __func__, max_endpoints);
 839         for (i = 0; i < max_endpoints; ++i) {
 840                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 841                 if (!port)
 842                         goto probe_error;
 843                 tty_port_init(&port->port);
 844                 port->serial = serial;
 845                 spin_lock_init(&port->lock);
 846                 mutex_init(&port->mutex);
 847                 INIT_WORK(&port->work, usb_serial_port_work);
 848                 serial->port[i] = port;
 849         }
 850
 851         /* set up the endpoint information */
 852         for (i = 0; i < num_bulk_in; ++i) {
 853                 endpoint = bulk_in_endpoint[i];
 854                 port = serial->port[i];
 855                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 856                 if (!port->read_urb) {
 857                         dev_err(&interface->dev, "No free urbs available\n");
 858                         goto probe_error;
 859                 }
 860                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 861                 port->bulk_in_size = buffer_size;
 862                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 863                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 864                 if (!port->bulk_in_buffer) {
 865                         dev_err(&interface->dev,
 866                                         "Couldn't allocate bulk_in_buffer\n");
 867                         goto probe_error;
 868                 }
 869                 usb_fill_bulk_urb(port->read_urb, dev,
 870                                 usb_rcvbulkpipe(dev,
 871                                                 endpoint->bEndpointAddress),
 872                                 port->bulk_in_buffer, buffer_size,
 873                                 serial->type->read_bulk_callback, port);
 874         }
 875
 876         for (i = 0; i < num_bulk_out; ++i) {
 877                 endpoint = bulk_out_endpoint[i];
 878                 port = serial->port[i];
 879                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 880                 if (!port->write_urb) {
 881                         dev_err(&interface->dev, "No free urbs available\n");
 882                         goto probe_error;
 883                 }
 884                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 885                 port->bulk_out_size = buffer_size;
 886                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 887                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 888                 if (!port->bulk_out_buffer) {
 889                         dev_err(&interface->dev,
 890                                         "Couldn't allocate bulk_out_buffer\n");
 891                         goto probe_error;
 892                 }
 893                 usb_fill_bulk_urb(port->write_urb, dev,
 894                                 usb_sndbulkpipe(dev,
 895                                         endpoint->bEndpointAddress),
 896                                 port->bulk_out_buffer, buffer_size,
 897                                 serial->type->write_bulk_callback, port);
 898         }
 899
 900         if (serial->type->read_int_callback) {
 901                 for (i = 0; i < num_interrupt_in; ++i) {
 902                         endpoint = interrupt_in_endpoint[i];
 903                         port = serial->port[i];
 904                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 905                         if (!port->interrupt_in_urb) {
 906                                 dev_err(&interface->dev,
 907                                                 "No free urbs available\n");
 908                                 goto probe_error;
 909                         }
 910                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 911                         port->interrupt_in_endpointAddress =
 912                                                 endpoint->bEndpointAddress;
 913                         port->interrupt_in_buffer = kmalloc(buffer_size,
 914                                                                 GFP_KERNEL);
 915                         if (!port->interrupt_in_buffer) {
 916                                 dev_err(&interface->dev,
 917                                     "Couldn't allocate interrupt_in_buffer\n");
 918                                 goto probe_error;
 919                         }
 920                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 921                                 usb_rcvintpipe(dev,
 922                                                 endpoint->bEndpointAddress),
 923                                 port->interrupt_in_buffer, buffer_size,
 924                                 serial->type->read_int_callback, port,
 925                                 endpoint->bInterval);
 926                 }
 927         } else if (num_interrupt_in) {
 928                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
 929         }
 930
 931         if (serial->type->write_int_callback) {
 932                 for (i = 0; i < num_interrupt_out; ++i) {
 933                         endpoint = interrupt_out_endpoint[i];
 934                         port = serial->port[i];
 935                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 936                         if (!port->interrupt_out_urb) {
 937                                 dev_err(&interface->dev,
 938                                                 "No free urbs available\n");
 939                                 goto probe_error;
 940                         }
 941                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 942                         port->interrupt_out_size = buffer_size;
 943                         port->interrupt_out_endpointAddress =
 944                                                 endpoint->bEndpointAddress;
 945                         port->interrupt_out_buffer = kmalloc(buffer_size,
 946                                                                 GFP_KERNEL);
 947                         if (!port->interrupt_out_buffer) {
 948                                 dev_err(&interface->dev,
 949                                   "Couldn't allocate interrupt_out_buffer\n");
 950                                 goto probe_error;
 951                         }
 952                         usb_fill_int_urb(port->interrupt_out_urb, dev,
 953                                 usb_sndintpipe(dev,
 954                                                   endpoint->bEndpointAddress),
 955                                 port->interrupt_out_buffer, buffer_size,
 956                                 serial->type->write_int_callback, port,
 957                                 endpoint->bInterval);
 958                 }
 959         } else if (num_interrupt_out) {
 960                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
 961         }
 962
 963         /* if this device type has an attach function, call it */
 964         if (type->attach) {
 965                 if (!try_module_get(type->driver.owner)) {
 966                         dev_err(&interface->dev,
 967                                         "module get failed, exiting\n");
 968                         goto probe_error;
 969                 }
 970                 retval = type->attach(serial);
 971                 module_put(type->driver.owner);
 972                 if (retval < 0)
 973                         goto probe_error;
 974                 if (retval > 0) {
 975                         /* quietly accept this device, but don't bind to a
 976                            serial port as it's about to disappear */
 977                         serial->num_ports = 0;
 978                         goto exit;
 979                 }
 980         }
 981
 982         if (get_free_serial(serial, num_ports, &minor) == NULL) {
 983                 dev_err(&interface->dev, "No more free serial devices\n");
 984                 goto probe_error;
 985         }
 986         serial->minor = minor;
 987
 988         /* register all of the individual ports with the driver core */
 989         for (i = 0; i < num_ports; ++i) {
 990                 port = serial->port[i];
 991                 port->dev.parent = &interface->dev;
 992                 port->dev.driver = NULL;
 993                 port->dev.bus = &usb_serial_bus_type;
 994                 port->dev.release = &port_release;
 995
 996                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
 997                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
 998                 retval = device_register(&port->dev);
 999                 if (retval)
1000                         dev_err(&port->dev, "Error registering port device, "
1001                                 "continuing\n");
1002         }
1003
1004         usb_serial_console_init(debug, minor);
1005
1006 exit:
1007         /* success */
1008         usb_set_intfdata(interface, serial);
1009         return 0;
1010
1011 probe_error:
1012         for (i = 0; i < num_bulk_in; ++i) {
1013                 port = serial->port[i];
1014                 if (!port)
1015                         continue;
1016                 usb_free_urb(port->read_urb);
1017                 kfree(port->bulk_in_buffer);
1018         }
1019         for (i = 0; i < num_bulk_out; ++i) {
1020                 port = serial->port[i];
1021                 if (!port)
1022                         continue;
1023                 usb_free_urb(port->write_urb);
1024                 kfree(port->bulk_out_buffer);
1025         }
1026         for (i = 0; i < num_interrupt_in; ++i) {
1027                 port = serial->port[i];
1028                 if (!port)
1029                         continue;
1030                 usb_free_urb(port->interrupt_in_urb);
1031                 kfree(port->interrupt_in_buffer);
1032         }
1033         for (i = 0; i < num_interrupt_out; ++i) {
1034                 port = serial->port[i];
1035                 if (!port)
1036                         continue;
1037                 usb_free_urb(port->interrupt_out_urb);
1038                 kfree(port->interrupt_out_buffer);
1039         }
1040
1041         /* free up any memory that we allocated */
1042         for (i = 0; i < serial->num_port_pointers; ++i)
1043                 kfree(serial->port[i]);
1044         kfree(serial);
1045         return -EIO;
1046 }
1047 EXPORT_SYMBOL_GPL(usb_serial_probe);
1048
1049 void usb_serial_disconnect(struct usb_interface *interface)
1050 {
1051         int i;
1052         struct usb_serial *serial = usb_get_intfdata(interface);
1053         struct device *dev = &interface->dev;
1054         struct usb_serial_port *port;
1055
1056         usb_serial_console_disconnect(serial);
1057         dbg("%s", __func__);
1058
1059         mutex_lock(&serial->disc_mutex);
1060         usb_set_intfdata(interface, NULL);
1061         /* must set a flag, to signal subdrivers */
1062         serial->disconnected = 1;
1063         mutex_unlock(&serial->disc_mutex);
1064
1065         /* Unfortunately, many of the sub-drivers expect the port structures
1066          * to exist when their shutdown method is called, so we have to go
1067          * through this awkward two-step unregistration procedure.
1068          */
1069         for (i = 0; i < serial->num_ports; ++i) {
1070                 port = serial->port[i];
1071                 if (port) {
1072                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1073                         if (tty) {
1074                                 tty_hangup(tty);
1075                                 tty_kref_put(tty);
1076                         }
1077                         kill_traffic(port);
1078                         cancel_work_sync(&port->work);
1079                         device_del(&port->dev);
1080                 }
1081         }
1082         serial->type->shutdown(serial);
1083         for (i = 0; i < serial->num_ports; ++i) {
1084                 port = serial->port[i];
1085                 if (port) {
1086                         put_device(&port->dev);
1087                         serial->port[i] = NULL;
1088                 }
1089         }
1090
1091         /* let the last holder of this object
1092          * cause it to be cleaned up */
1093         usb_serial_put(serial);
1094         dev_info(dev, "device disconnected\n");
1095 }
1096 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1097
1098 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1099 {
1100         struct usb_serial *serial = usb_get_intfdata(intf);
1101         struct usb_serial_port *port;
1102         int i, r = 0;
1103
1104         serial->suspending = 1;
1105
1106         for (i = 0; i < serial->num_ports; ++i) {
1107                 port = serial->port[i];
1108                 if (port)
1109                         kill_traffic(port);
1110         }
1111
1112         if (serial->type->suspend)
1113                 r = serial->type->suspend(serial, message);
1114
1115         return r;
1116 }
1117 EXPORT_SYMBOL(usb_serial_suspend);
1118
1119 int usb_serial_resume(struct usb_interface *intf)
1120 {
1121         struct usb_serial *serial = usb_get_intfdata(intf);
1122         int rv;
1123
1124         serial->suspending = 0;
1125         if (serial->type->resume)
1126                 rv = serial->type->resume(serial);
1127         else
1128                 rv = usb_serial_generic_resume(serial);
1129
1130         return rv;
1131 }
1132 EXPORT_SYMBOL(usb_serial_resume);
1133
1134 static const struct tty_operations serial_ops = {
1135         .open =                 serial_open,
1136         .close =                serial_close,
1137         .write =                serial_write,
1138         .write_room =           serial_write_room,
1139         .ioctl =                serial_ioctl,
1140         .set_termios =          serial_set_termios,
1141         .throttle =             serial_throttle,
1142         .unthrottle =           serial_unthrottle,
1143         .break_ctl =            serial_break,
1144         .chars_in_buffer =      serial_chars_in_buffer,
1145         .tiocmget =             serial_tiocmget,
1146         .tiocmset =             serial_tiocmset,
1147         .proc_fops =            &serial_proc_fops,
1148 };
1149
1150 struct tty_driver *usb_serial_tty_driver;
1151
1152 static int __init usb_serial_init(void)
1153 {
1154         int i;
1155         int result;
1156
1157         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1158         if (!usb_serial_tty_driver)
1159                 return -ENOMEM;
1160
1161         /* Initialize our global data */
1162         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1163                 serial_table[i] = NULL;
1164
1165         result = bus_register(&usb_serial_bus_type);
1166         if (result) {
1167                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1168                        "failed\n", __func__);
1169                 goto exit_bus;
1170         }
1171
1172         usb_serial_tty_driver->owner = THIS_MODULE;
1173         usb_serial_tty_driver->driver_name = "usbserial";
1174         usb_serial_tty_driver->name =   "ttyUSB";
1175         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1176         usb_serial_tty_driver->minor_start = 0;
1177         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1178         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1179         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1180                                                 TTY_DRIVER_DYNAMIC_DEV;
1181         usb_serial_tty_driver->init_termios = tty_std_termios;
1182         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1183                                                         | HUPCL | CLOCAL;
1184         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1185         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1186         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1187         result = tty_register_driver(usb_serial_tty_driver);
1188         if (result) {
1189                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1190                        __func__);
1191                 goto exit_reg_driver;
1192         }
1193
1194         /* register the USB driver */
1195         result = usb_register(&usb_serial_driver);
1196         if (result < 0) {
1197                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1198                        __func__);
1199                 goto exit_tty;
1200         }
1201
1202         /* register the generic driver, if we should */
1203         result = usb_serial_generic_register(debug);
1204         if (result < 0) {
1205                 printk(KERN_ERR "usb-serial: %s - registering generic "
1206                        "driver failed\n", __func__);
1207                 goto exit_generic;
1208         }
1209
1210         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1211
1212         return result;
1213
1214 exit_generic:
1215         usb_deregister(&usb_serial_driver);
1216
1217 exit_tty:
1218         tty_unregister_driver(usb_serial_tty_driver);
1219
1220 exit_reg_driver:
1221         bus_unregister(&usb_serial_bus_type);
1222
1223 exit_bus:
1224         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1225                __func__, result);
1226         put_tty_driver(usb_serial_tty_driver);
1227         return result;
1228 }
1229
1230
1231 static void __exit usb_serial_exit(void)
1232 {
1233         usb_serial_console_exit();
1234
1235         usb_serial_generic_deregister();
1236
1237         usb_deregister(&usb_serial_driver);
1238         tty_unregister_driver(usb_serial_tty_driver);
1239         put_tty_driver(usb_serial_tty_driver);
1240         bus_unregister(&usb_serial_bus_type);
1241 }
1242
1243
1244 module_init(usb_serial_init);
1245 module_exit(usb_serial_exit);
1246
1247 #define set_to_generic_if_null(type, function)                          \
1248         do {                                                            \
1249                 if (!type->function) {                                  \
1250                         type->function = usb_serial_generic_##function; \
1251                         dbg("Had to override the " #function            \
1252                                 " usb serial operation with the generic one.");\
1253                         }                                               \
1254         } while (0)
1255
1256 static void fixup_generic(struct usb_serial_driver *device)
1257 {
1258         set_to_generic_if_null(device, open);
1259         set_to_generic_if_null(device, write);
1260         set_to_generic_if_null(device, close);
1261         set_to_generic_if_null(device, write_room);
1262         set_to_generic_if_null(device, chars_in_buffer);
1263         set_to_generic_if_null(device, read_bulk_callback);
1264         set_to_generic_if_null(device, write_bulk_callback);
1265         set_to_generic_if_null(device, shutdown);
1266 }
1267
1268 int usb_serial_register(struct usb_serial_driver *driver)
1269 {
1270         /* must be called with BKL held */
1271         int retval;
1272
1273         if (usb_disabled())
1274                 return -ENODEV;
1275
1276         fixup_generic(driver);
1277
1278         if (!driver->description)
1279                 driver->description = driver->driver.name;
1280
1281         /* Add this device to our list of devices */
1282         list_add(&driver->driver_list, &usb_serial_driver_list);
1283
1284         retval = usb_serial_bus_register(driver);
1285         if (retval) {
1286                 printk(KERN_ERR "usb-serial: problem %d when registering "
1287                        "driver %s\n", retval, driver->description);
1288                 list_del(&driver->driver_list);
1289         } else
1290                 printk(KERN_INFO "USB Serial support registered for %s\n",
1291                                                 driver->description);
1292
1293         return retval;
1294 }
1295 EXPORT_SYMBOL_GPL(usb_serial_register);
1296
1297
1298 void usb_serial_deregister(struct usb_serial_driver *device)
1299 {
1300         /* must be called with BKL held */
1301         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1302                device->description);
1303         list_del(&device->driver_list);
1304         usb_serial_bus_deregister(device);
1305 }
1306 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1307
1308 /* Module information */
1309 MODULE_AUTHOR(DRIVER_AUTHOR);
1310 MODULE_DESCRIPTION(DRIVER_DESC);
1311 MODULE_LICENSE("GPL");
1312
1313 module_param(debug, bool, S_IRUGO | S_IWUSR);
1314 MODULE_PARM_DESC(debug, "Debug enabled or not");