drivers/usb/serial/pl2303.c

   1 /*
   2  * Prolific PL2303 USB to serial adaptor driver
   3  *
   4  * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2003 IBM Corp.
   6  *
   7  * Original driver for 2.2.x by anonymous
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License version
  11  *      2 as published by the Free Software Foundation.
  12  *
  13  * See Documentation/usb/usb-serial.txt for more information on using this
  14  * driver
  15  *
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/errno.h>
  20 #include <linux/init.h>
  21 #include <linux/slab.h>
  22 #include <linux/tty.h>
  23 #include <linux/tty_driver.h>
  24 #include <linux/tty_flip.h>
  25 #include <linux/serial.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/usb.h>
  31 #include <linux/usb/serial.h>
  32 #include "pl2303.h"
  33
  34 /*
  35  * Version Information
  36  */
  37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
  38
  39 static int debug;
  40
  41 #define PL2303_CLOSING_WAIT     (30*HZ)
  42
  43 #define PL2303_BUF_SIZE         1024
  44 #define PL2303_TMP_BUF_SIZE     1024
  45
  46 struct pl2303_buf {
  47         unsigned int    buf_size;
  48         char            *buf_buf;
  49         char            *buf_get;
  50         char            *buf_put;
  51 };
  52
  53 static const struct usb_device_id id_table[] = {
  54         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
  55         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  56         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  57         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  58         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  59         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
  60         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
  61         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
  62         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
  63         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  64         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  65         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
  66         { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  67         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  68         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  69         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  70         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  71         { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  72         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  73         { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  74         { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  75         { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  76         { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  77         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  78         { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
  79         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
  80         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
  81         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
  82         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
  83         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
  84         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  85         { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  86         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  87         { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  88         { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  89         { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  90         { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  91         { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  92         { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
  93         { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  94         { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  95         { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  96         { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  97         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  98         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
  99         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
 100         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
 101         { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
 102         { }                                     /* Terminating entry */
 103 };
 104
 105 MODULE_DEVICE_TABLE(usb, id_table);
 106
 107 static struct usb_driver pl2303_driver = {
 108         .name =         "pl2303",
 109         .probe =        usb_serial_probe,
 110         .disconnect =   usb_serial_disconnect,
 111         .id_table =     id_table,
 112         .suspend =      usb_serial_suspend,
 113         .resume =       usb_serial_resume,
 114         .no_dynamic_id =        1,
 115         .supports_autosuspend = 1,
 116 };
 117
 118 #define SET_LINE_REQUEST_TYPE           0x21
 119 #define SET_LINE_REQUEST                0x20
 120
 121 #define SET_CONTROL_REQUEST_TYPE        0x21
 122 #define SET_CONTROL_REQUEST             0x22
 123 #define CONTROL_DTR                     0x01
 124 #define CONTROL_RTS                     0x02
 125
 126 #define BREAK_REQUEST_TYPE              0x21
 127 #define BREAK_REQUEST                   0x23
 128 #define BREAK_ON                        0xffff
 129 #define BREAK_OFF                       0x0000
 130
 131 #define GET_LINE_REQUEST_TYPE           0xa1
 132 #define GET_LINE_REQUEST                0x21
 133
 134 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 135 #define VENDOR_WRITE_REQUEST            0x01
 136
 137 #define VENDOR_READ_REQUEST_TYPE        0xc0
 138 #define VENDOR_READ_REQUEST             0x01
 139
 140 #define UART_STATE                      0x08
 141 #define UART_STATE_TRANSIENT_MASK       0x74
 142 #define UART_DCD                        0x01
 143 #define UART_DSR                        0x02
 144 #define UART_BREAK_ERROR                0x04
 145 #define UART_RING                       0x08
 146 #define UART_FRAME_ERROR                0x10
 147 #define UART_PARITY_ERROR               0x20
 148 #define UART_OVERRUN_ERROR              0x40
 149 #define UART_CTS                        0x80
 150
 151
 152 enum pl2303_type {
 153         type_0,         /* don't know the difference between type 0 and */
 154         type_1,         /* type 1, until someone from prolific tells us... */
 155         HX,             /* HX version of the pl2303 chip */
 156 };
 157
 158 struct pl2303_private {
 159         spinlock_t lock;
 160         struct pl2303_buf *buf;
 161         int write_urb_in_use;
 162         wait_queue_head_t delta_msr_wait;
 163         u8 line_control;
 164         u8 line_status;
 165         enum pl2303_type type;
 166 };
 167
 168 /*
 169  * pl2303_buf_alloc
 170  *
 171  * Allocate a circular buffer and all associated memory.
 172  */
 173 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
 174 {
 175         struct pl2303_buf *pb;
 176
 177         if (size == 0)
 178                 return NULL;
 179
 180         pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
 181         if (pb == NULL)
 182                 return NULL;
 183
 184         pb->buf_buf = kmalloc(size, GFP_KERNEL);
 185         if (pb->buf_buf == NULL) {
 186                 kfree(pb);
 187                 return NULL;
 188         }
 189
 190         pb->buf_size = size;
 191         pb->buf_get = pb->buf_put = pb->buf_buf;
 192
 193         return pb;
 194 }
 195
 196 /*
 197  * pl2303_buf_free
 198  *
 199  * Free the buffer and all associated memory.
 200  */
 201 static void pl2303_buf_free(struct pl2303_buf *pb)
 202 {
 203         if (pb) {
 204                 kfree(pb->buf_buf);
 205                 kfree(pb);
 206         }
 207 }
 208
 209 /*
 210  * pl2303_buf_clear
 211  *
 212  * Clear out all data in the circular buffer.
 213  */
 214 static void pl2303_buf_clear(struct pl2303_buf *pb)
 215 {
 216         if (pb != NULL)
 217                 pb->buf_get = pb->buf_put;
 218                 /* equivalent to a get of all data available */
 219 }
 220
 221 /*
 222  * pl2303_buf_data_avail
 223  *
 224  * Return the number of bytes of data available in the circular
 225  * buffer.
 226  */
 227 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
 228 {
 229         if (pb == NULL)
 230                 return 0;
 231
 232         return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
 233 }
 234
 235 /*
 236  * pl2303_buf_space_avail
 237  *
 238  * Return the number of bytes of space available in the circular
 239  * buffer.
 240  */
 241 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
 242 {
 243         if (pb == NULL)
 244                 return 0;
 245
 246         return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
 247 }
 248
 249 /*
 250  * pl2303_buf_put
 251  *
 252  * Copy data data from a user buffer and put it into the circular buffer.
 253  * Restrict to the amount of space available.
 254  *
 255  * Return the number of bytes copied.
 256  */
 257 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
 258                                    unsigned int count)
 259 {
 260         unsigned int len;
 261
 262         if (pb == NULL)
 263                 return 0;
 264
 265         len  = pl2303_buf_space_avail(pb);
 266         if (count > len)
 267                 count = len;
 268
 269         if (count == 0)
 270                 return 0;
 271
 272         len = pb->buf_buf + pb->buf_size - pb->buf_put;
 273         if (count > len) {
 274                 memcpy(pb->buf_put, buf, len);
 275                 memcpy(pb->buf_buf, buf+len, count - len);
 276                 pb->buf_put = pb->buf_buf + count - len;
 277         } else {
 278                 memcpy(pb->buf_put, buf, count);
 279                 if (count < len)
 280                         pb->buf_put += count;
 281                 else /* count == len */
 282                         pb->buf_put = pb->buf_buf;
 283         }
 284
 285         return count;
 286 }
 287
 288 /*
 289  * pl2303_buf_get
 290  *
 291  * Get data from the circular buffer and copy to the given buffer.
 292  * Restrict to the amount of data available.
 293  *
 294  * Return the number of bytes copied.
 295  */
 296 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
 297                                    unsigned int count)
 298 {
 299         unsigned int len;
 300
 301         if (pb == NULL)
 302                 return 0;
 303
 304         len = pl2303_buf_data_avail(pb);
 305         if (count > len)
 306                 count = len;
 307
 308         if (count == 0)
 309                 return 0;
 310
 311         len = pb->buf_buf + pb->buf_size - pb->buf_get;
 312         if (count > len) {
 313                 memcpy(buf, pb->buf_get, len);
 314                 memcpy(buf+len, pb->buf_buf, count - len);
 315                 pb->buf_get = pb->buf_buf + count - len;
 316         } else {
 317                 memcpy(buf, pb->buf_get, count);
 318                 if (count < len)
 319                         pb->buf_get += count;
 320                 else /* count == len */
 321                         pb->buf_get = pb->buf_buf;
 322         }
 323
 324         return count;
 325 }
 326
 327 static int pl2303_vendor_read(__u16 value, __u16 index,
 328                 struct usb_serial *serial, unsigned char *buf)
 329 {
 330         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 331                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 332                         value, index, buf, 1, 100);
 333         dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", VENDOR_READ_REQUEST_TYPE,
 334                         VENDOR_READ_REQUEST, value, index, res, buf[0]);
 335         return res;
 336 }
 337
 338 static int pl2303_vendor_write(__u16 value, __u16 index,
 339                 struct usb_serial *serial)
 340 {
 341         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 342                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 343                         value, index, NULL, 0, 100);
 344         dbg("0x%x:0x%x:0x%x:0x%x  %d", VENDOR_WRITE_REQUEST_TYPE,
 345                         VENDOR_WRITE_REQUEST, value, index, res);
 346         return res;
 347 }
 348
 349 static int pl2303_startup(struct usb_serial *serial)
 350 {
 351         struct pl2303_private *priv;
 352         enum pl2303_type type = type_0;
 353         unsigned char *buf;
 354         int i;
 355
 356         buf = kmalloc(10, GFP_KERNEL);
 357         if (buf == NULL)
 358                 return -ENOMEM;
 359
 360         if (serial->dev->descriptor.bDeviceClass == 0x02)
 361                 type = type_0;
 362         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 363                 type = HX;
 364         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 365                 type = type_1;
 366         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 367                 type = type_1;
 368         dbg("device type: %d", type);
 369
 370         for (i = 0; i < serial->num_ports; ++i) {
 371                 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
 372                 if (!priv)
 373                         goto cleanup;
 374                 spin_lock_init(&priv->lock);
 375                 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
 376                 if (priv->buf == NULL) {
 377                         kfree(priv);
 378                         goto cleanup;
 379                 }
 380                 init_waitqueue_head(&priv->delta_msr_wait);
 381                 priv->type = type;
 382                 usb_set_serial_port_data(serial->port[i], priv);
 383         }
 384
 385         pl2303_vendor_read(0x8484, 0, serial, buf);
 386         pl2303_vendor_write(0x0404, 0, serial);
 387         pl2303_vendor_read(0x8484, 0, serial, buf);
 388         pl2303_vendor_read(0x8383, 0, serial, buf);
 389         pl2303_vendor_read(0x8484, 0, serial, buf);
 390         pl2303_vendor_write(0x0404, 1, serial);
 391         pl2303_vendor_read(0x8484, 0, serial, buf);
 392         pl2303_vendor_read(0x8383, 0, serial, buf);
 393         pl2303_vendor_write(0, 1, serial);
 394         pl2303_vendor_write(1, 0, serial);
 395         if (type == HX)
 396                 pl2303_vendor_write(2, 0x44, serial);
 397         else
 398                 pl2303_vendor_write(2, 0x24, serial);
 399
 400         kfree(buf);
 401         return 0;
 402
 403 cleanup:
 404         kfree(buf);
 405         for (--i; i >= 0; --i) {
 406                 priv = usb_get_serial_port_data(serial->port[i]);
 407                 pl2303_buf_free(priv->buf);
 408                 kfree(priv);
 409                 usb_set_serial_port_data(serial->port[i], NULL);
 410         }
 411         return -ENOMEM;
 412 }
 413
 414 static int set_control_lines(struct usb_device *dev, u8 value)
 415 {
 416         int retval;
 417
 418         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 419                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 420                                  value, 0, NULL, 0, 100);
 421         dbg("%s - value = %d, retval = %d", __func__, value, retval);
 422         return retval;
 423 }
 424
 425 static void pl2303_send(struct usb_serial_port *port)
 426 {
 427         int count, result;
 428         struct pl2303_private *priv = usb_get_serial_port_data(port);
 429         unsigned long flags;
 430
 431         dbg("%s - port %d", __func__, port->number);
 432
 433         spin_lock_irqsave(&priv->lock, flags);
 434
 435         if (priv->write_urb_in_use) {
 436                 spin_unlock_irqrestore(&priv->lock, flags);
 437                 return;
 438         }
 439
 440         count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
 441                                port->bulk_out_size);
 442
 443         if (count == 0) {
 444                 spin_unlock_irqrestore(&priv->lock, flags);
 445                 return;
 446         }
 447
 448         priv->write_urb_in_use = 1;
 449
 450         spin_unlock_irqrestore(&priv->lock, flags);
 451
 452         usb_serial_debug_data(debug, &port->dev, __func__, count,
 453                               port->write_urb->transfer_buffer);
 454
 455         port->write_urb->transfer_buffer_length = count;
 456         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 457         if (result) {
 458                 dev_err(&port->dev, "%s - failed submitting write urb,"
 459                         " error %d\n", __func__, result);
 460                 priv->write_urb_in_use = 0;
 461                 /* TODO: reschedule pl2303_send */
 462         }
 463
 464         usb_serial_port_softint(port);
 465 }
 466
 467 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
 468                                 const unsigned char *buf, int count)
 469 {
 470         struct pl2303_private *priv = usb_get_serial_port_data(port);
 471         unsigned long flags;
 472
 473         dbg("%s - port %d, %d bytes", __func__, port->number, count);
 474
 475         if (!count)
 476                 return count;
 477
 478         spin_lock_irqsave(&priv->lock, flags);
 479         count = pl2303_buf_put(priv->buf, buf, count);
 480         spin_unlock_irqrestore(&priv->lock, flags);
 481
 482         pl2303_send(port);
 483
 484         return count;
 485 }
 486
 487 static int pl2303_write_room(struct tty_struct *tty)
 488 {
 489         struct usb_serial_port *port = tty->driver_data;
 490         struct pl2303_private *priv = usb_get_serial_port_data(port);
 491         int room = 0;
 492         unsigned long flags;
 493
 494         dbg("%s - port %d", __func__, port->number);
 495
 496         spin_lock_irqsave(&priv->lock, flags);
 497         room = pl2303_buf_space_avail(priv->buf);
 498         spin_unlock_irqrestore(&priv->lock, flags);
 499
 500         dbg("%s - returns %d", __func__, room);
 501         return room;
 502 }
 503
 504 static int pl2303_chars_in_buffer(struct tty_struct *tty)
 505 {
 506         struct usb_serial_port *port = tty->driver_data;
 507         struct pl2303_private *priv = usb_get_serial_port_data(port);
 508         int chars = 0;
 509         unsigned long flags;
 510
 511         dbg("%s - port %d", __func__, port->number);
 512
 513         spin_lock_irqsave(&priv->lock, flags);
 514         chars = pl2303_buf_data_avail(priv->buf);
 515         spin_unlock_irqrestore(&priv->lock, flags);
 516
 517         dbg("%s - returns %d", __func__, chars);
 518         return chars;
 519 }
 520
 521 static void pl2303_set_termios(struct tty_struct *tty,
 522                 struct usb_serial_port *port, struct ktermios *old_termios)
 523 {
 524         struct usb_serial *serial = port->serial;
 525         struct pl2303_private *priv = usb_get_serial_port_data(port);
 526         unsigned long flags;
 527         unsigned int cflag;
 528         unsigned char *buf;
 529         int baud;
 530         int i;
 531         u8 control;
 532         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
 533                                  4800, 7200, 9600, 14400, 19200, 28800, 38400,
 534                                  57600, 115200, 230400, 460800, 614400,
 535                                  921600, 1228800, 2457600, 3000000, 6000000 };
 536         int baud_floor, baud_ceil;
 537         int k;
 538
 539         dbg("%s -  port %d", __func__, port->number);
 540
 541         /* The PL2303 is reported to lose bytes if you change
 542            serial settings even to the same values as before. Thus
 543            we actually need to filter in this specific case */
 544
 545         if (!tty_termios_hw_change(tty->termios, old_termios))
 546                 return;
 547
 548         cflag = tty->termios->c_cflag;
 549
 550         buf = kzalloc(7, GFP_KERNEL);
 551         if (!buf) {
 552                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 553                 /* Report back no change occurred */
 554                 *tty->termios = *old_termios;
 555                 return;
 556         }
 557
 558         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 559                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 560                             0, 0, buf, 7, 100);
 561         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 562             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 563
 564         if (cflag & CSIZE) {
 565                 switch (cflag & CSIZE) {
 566                 case CS5:
 567                         buf[6] = 5;
 568                         break;
 569                 case CS6:
 570                         buf[6] = 6;
 571                         break;
 572                 case CS7:
 573                         buf[6] = 7;
 574                         break;
 575                 default:
 576                 case CS8:
 577                         buf[6] = 8;
 578                         break;
 579                 }
 580                 dbg("%s - data bits = %d", __func__, buf[6]);
 581         }
 582
 583         /* For reference buf[0]:buf[3] baud rate value */
 584         /* NOTE: Only the values defined in baud_sup are supported !
 585          *       => if unsupported values are set, the PL2303 seems to use
 586          *          9600 baud (at least my PL2303X always does)
 587          */
 588         baud = tty_get_baud_rate(tty);
 589         dbg("%s - baud requested = %d", __func__, baud);
 590         if (baud) {
 591                 /* Set baudrate to nearest supported value */
 592                 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
 593                         if (baud_sup[k] / baud) {
 594                                 baud_ceil = baud_sup[k];
 595                                 if (k==0) {
 596                                         baud = baud_ceil;
 597                                 } else {
 598                                         baud_floor = baud_sup[k-1];
 599                                         if ((baud_ceil % baud)
 600                                             > (baud % baud_floor))
 601                                                 baud = baud_floor;
 602                                         else
 603                                                 baud = baud_ceil;
 604                                 }
 605                                 break;
 606                         }
 607                 }
 608                 if (baud > 1228800) {
 609                         /* type_0, type_1 only support up to 1228800 baud */
 610                         if (priv->type != HX)
 611                                 baud = 1228800;
 612                         else if (baud > 6000000)
 613                                 baud = 6000000;
 614                 }
 615                 dbg("%s - baud set = %d", __func__, baud);
 616                 buf[0] = baud & 0xff;
 617                 buf[1] = (baud >> 8) & 0xff;
 618                 buf[2] = (baud >> 16) & 0xff;
 619                 buf[3] = (baud >> 24) & 0xff;
 620         }
 621
 622         /* For reference buf[4]=0 is 1 stop bits */
 623         /* For reference buf[4]=1 is 1.5 stop bits */
 624         /* For reference buf[4]=2 is 2 stop bits */
 625         if (cflag & CSTOPB) {
 626                 /* NOTE: Comply with "real" UARTs / RS232:
 627                  *       use 1.5 instead of 2 stop bits with 5 data bits
 628                  */
 629                 if ((cflag & CSIZE) == CS5) {
 630                         buf[4] = 1;
 631                         dbg("%s - stop bits = 1.5", __func__);
 632                 } else {
 633                         buf[4] = 2;
 634                         dbg("%s - stop bits = 2", __func__);
 635                 }
 636         } else {
 637                 buf[4] = 0;
 638                 dbg("%s - stop bits = 1", __func__);
 639         }
 640
 641         if (cflag & PARENB) {
 642                 /* For reference buf[5]=0 is none parity */
 643                 /* For reference buf[5]=1 is odd parity */
 644                 /* For reference buf[5]=2 is even parity */
 645                 /* For reference buf[5]=3 is mark parity */
 646                 /* For reference buf[5]=4 is space parity */
 647                 if (cflag & PARODD) {
 648                         if (cflag & CMSPAR) {
 649                                 buf[5] = 3;
 650                                 dbg("%s - parity = mark", __func__);
 651                         } else {
 652                                 buf[5] = 1;
 653                                 dbg("%s - parity = odd", __func__);
 654                         }
 655                 } else {
 656                         if (cflag & CMSPAR) {
 657                                 buf[5] = 4;
 658                                 dbg("%s - parity = space", __func__);
 659                         } else {
 660                                 buf[5] = 2;
 661                                 dbg("%s - parity = even", __func__);
 662                         }
 663                 }
 664         } else {
 665                 buf[5] = 0;
 666                 dbg("%s - parity = none", __func__);
 667         }
 668
 669         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 670                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 671                             0, 0, buf, 7, 100);
 672         dbg("0x21:0x20:0:0  %d", i);
 673
 674         /* change control lines if we are switching to or from B0 */
 675         spin_lock_irqsave(&priv->lock, flags);
 676         control = priv->line_control;
 677         if ((cflag & CBAUD) == B0)
 678                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 679         else
 680                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 681         if (control != priv->line_control) {
 682                 control = priv->line_control;
 683                 spin_unlock_irqrestore(&priv->lock, flags);
 684                 set_control_lines(serial->dev, control);
 685         } else {
 686                 spin_unlock_irqrestore(&priv->lock, flags);
 687         }
 688
 689         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 690
 691         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 692                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 693                             0, 0, buf, 7, 100);
 694         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 695              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 696
 697         if (cflag & CRTSCTS) {
 698                 if (priv->type == HX)
 699                         pl2303_vendor_write(0x0, 0x61, serial);
 700                 else
 701                         pl2303_vendor_write(0x0, 0x41, serial);
 702         } else {
 703                 pl2303_vendor_write(0x0, 0x0, serial);
 704         }
 705
 706         /* Save resulting baud rate */
 707         if (baud)
 708                 tty_encode_baud_rate(tty, baud, baud);
 709
 710         kfree(buf);
 711 }
 712
 713 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 714 {
 715         struct pl2303_private *priv = usb_get_serial_port_data(port);
 716         unsigned long flags;
 717         u8 control;
 718
 719         spin_lock_irqsave(&priv->lock, flags);
 720         /* Change DTR and RTS */
 721         if (on)
 722                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 723         else
 724                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 725         control = priv->line_control;
 726         spin_unlock_irqrestore(&priv->lock, flags);
 727         set_control_lines(port->serial->dev, control);
 728 }
 729
 730 static void pl2303_close(struct usb_serial_port *port)
 731 {
 732         struct pl2303_private *priv = usb_get_serial_port_data(port);
 733         unsigned long flags;
 734
 735         dbg("%s - port %d", __func__, port->number);
 736
 737         spin_lock_irqsave(&priv->lock, flags);
 738         /* clear out any remaining data in the buffer */
 739         pl2303_buf_clear(priv->buf);
 740         spin_unlock_irqrestore(&priv->lock, flags);
 741
 742         /* shutdown our urbs */
 743         dbg("%s - shutting down urbs", __func__);
 744         usb_kill_urb(port->write_urb);
 745         usb_kill_urb(port->read_urb);
 746         usb_kill_urb(port->interrupt_in_urb);
 747
 748 }
 749
 750 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 751 {
 752         struct ktermios tmp_termios;
 753         struct usb_serial *serial = port->serial;
 754         struct pl2303_private *priv = usb_get_serial_port_data(port);
 755         int result;
 756
 757         dbg("%s -  port %d", __func__, port->number);
 758
 759         if (priv->type != HX) {
 760                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 761                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 762         } else {
 763                 /* reset upstream data pipes */
 764                 pl2303_vendor_write(8, 0, serial);
 765                 pl2303_vendor_write(9, 0, serial);
 766         }
 767
 768         /* Setup termios */
 769         if (tty)
 770                 pl2303_set_termios(tty, port, &tmp_termios);
 771
 772         dbg("%s - submitting read urb", __func__);
 773         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 774         if (result) {
 775                 dev_err(&port->dev, "%s - failed submitting read urb,"
 776                         " error %d\n", __func__, result);
 777                 pl2303_close(port);
 778                 return -EPROTO;
 779         }
 780
 781         dbg("%s - submitting interrupt urb", __func__);
 782         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 783         if (result) {
 784                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 785                         " error %d\n", __func__, result);
 786                 pl2303_close(port);
 787                 return -EPROTO;
 788         }
 789         port->port.drain_delay = 256;
 790         return 0;
 791 }
 792
 793 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 794                            unsigned int set, unsigned int clear)
 795 {
 796         struct usb_serial_port *port = tty->driver_data;
 797         struct pl2303_private *priv = usb_get_serial_port_data(port);
 798         unsigned long flags;
 799         u8 control;
 800
 801         if (!usb_get_intfdata(port->serial->interface))
 802                 return -ENODEV;
 803
 804         spin_lock_irqsave(&priv->lock, flags);
 805         if (set & TIOCM_RTS)
 806                 priv->line_control |= CONTROL_RTS;
 807         if (set & TIOCM_DTR)
 808                 priv->line_control |= CONTROL_DTR;
 809         if (clear & TIOCM_RTS)
 810                 priv->line_control &= ~CONTROL_RTS;
 811         if (clear & TIOCM_DTR)
 812                 priv->line_control &= ~CONTROL_DTR;
 813         control = priv->line_control;
 814         spin_unlock_irqrestore(&priv->lock, flags);
 815
 816         return set_control_lines(port->serial->dev, control);
 817 }
 818
 819 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 820 {
 821         struct usb_serial_port *port = tty->driver_data;
 822         struct pl2303_private *priv = usb_get_serial_port_data(port);
 823         unsigned long flags;
 824         unsigned int mcr;
 825         unsigned int status;
 826         unsigned int result;
 827
 828         dbg("%s (%d)", __func__, port->number);
 829
 830         if (!usb_get_intfdata(port->serial->interface))
 831                 return -ENODEV;
 832
 833         spin_lock_irqsave(&priv->lock, flags);
 834         mcr = priv->line_control;
 835         status = priv->line_status;
 836         spin_unlock_irqrestore(&priv->lock, flags);
 837
 838         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 839                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 840                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 841                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 842                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 843                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 844
 845         dbg("%s - result = %x", __func__, result);
 846
 847         return result;
 848 }
 849
 850 static int pl2303_carrier_raised(struct usb_serial_port *port)
 851 {
 852         struct pl2303_private *priv = usb_get_serial_port_data(port);
 853         if (priv->line_status & UART_DCD)
 854                 return 1;
 855         return 0;
 856 }
 857
 858 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 859 {
 860         struct pl2303_private *priv = usb_get_serial_port_data(port);
 861         unsigned long flags;
 862         unsigned int prevstatus;
 863         unsigned int status;
 864         unsigned int changed;
 865
 866         spin_lock_irqsave(&priv->lock, flags);
 867         prevstatus = priv->line_status;
 868         spin_unlock_irqrestore(&priv->lock, flags);
 869
 870         while (1) {
 871                 interruptible_sleep_on(&priv->delta_msr_wait);
 872                 /* see if a signal did it */
 873                 if (signal_pending(current))
 874                         return -ERESTARTSYS;
 875
 876                 spin_lock_irqsave(&priv->lock, flags);
 877                 status = priv->line_status;
 878                 spin_unlock_irqrestore(&priv->lock, flags);
 879
 880                 changed = prevstatus ^ status;
 881
 882                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 883                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 884                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 885                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 886                         return 0;
 887                 }
 888                 prevstatus = status;
 889         }
 890         /* NOTREACHED */
 891         return 0;
 892 }
 893
 894 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 895                         unsigned int cmd, unsigned long arg)
 896 {
 897         struct serial_struct ser;
 898         struct usb_serial_port *port = tty->driver_data;
 899         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 900
 901         switch (cmd) {
 902         case TIOCGSERIAL:
 903                 memset(&ser, 0, sizeof ser);
 904                 ser.type = PORT_16654;
 905                 ser.line = port->serial->minor;
 906                 ser.port = port->number;
 907                 ser.baud_base = 460800;
 908
 909                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 910                         return -EFAULT;
 911
 912                 return 0;
 913
 914         case TIOCMIWAIT:
 915                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 916                 return wait_modem_info(port, arg);
 917         default:
 918                 dbg("%s not supported = 0x%04x", __func__, cmd);
 919                 break;
 920         }
 921         return -ENOIOCTLCMD;
 922 }
 923
 924 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 925 {
 926         struct usb_serial_port *port = tty->driver_data;
 927         struct usb_serial *serial = port->serial;
 928         u16 state;
 929         int result;
 930
 931         dbg("%s - port %d", __func__, port->number);
 932
 933         if (break_state == 0)
 934                 state = BREAK_OFF;
 935         else
 936                 state = BREAK_ON;
 937         dbg("%s - turning break %s", __func__,
 938                         state == BREAK_OFF ? "off" : "on");
 939
 940         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 941                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 942                                  0, NULL, 0, 100);
 943         if (result)
 944                 dbg("%s - error sending break = %d", __func__, result);
 945 }
 946
 947 static void pl2303_release(struct usb_serial *serial)
 948 {
 949         int i;
 950         struct pl2303_private *priv;
 951
 952         dbg("%s", __func__);
 953
 954         for (i = 0; i < serial->num_ports; ++i) {
 955                 priv = usb_get_serial_port_data(serial->port[i]);
 956                 if (priv) {
 957                         pl2303_buf_free(priv->buf);
 958                         kfree(priv);
 959                 }
 960         }
 961 }
 962
 963 static void pl2303_update_line_status(struct usb_serial_port *port,
 964                                       unsigned char *data,
 965                                       unsigned int actual_length)
 966 {
 967
 968         struct pl2303_private *priv = usb_get_serial_port_data(port);
 969         unsigned long flags;
 970         u8 status_idx = UART_STATE;
 971         u8 length = UART_STATE + 1;
 972         u16 idv, idp;
 973
 974         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 975         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 976
 977
 978         if (idv == SIEMENS_VENDOR_ID) {
 979                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 980                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 981                     idp == SIEMENS_PRODUCT_ID_X75) {
 982
 983                         length = 1;
 984                         status_idx = 0;
 985                 }
 986         }
 987
 988         if (actual_length < length)
 989                 return;
 990
 991         /* Save off the uart status for others to look at */
 992         spin_lock_irqsave(&priv->lock, flags);
 993         priv->line_status = data[status_idx];
 994         spin_unlock_irqrestore(&priv->lock, flags);
 995         if (priv->line_status & UART_BREAK_ERROR)
 996                 usb_serial_handle_break(port);
 997         wake_up_interruptible(&priv->delta_msr_wait);
 998 }
 999
1000 static void pl2303_read_int_callback(struct urb *urb)
1001 {
1002         struct usb_serial_port *port =  urb->context;
1003         unsigned char *data = urb->transfer_buffer;
1004         unsigned int actual_length = urb->actual_length;
1005         int status = urb->status;
1006         int retval;
1007
1008         dbg("%s (%d)", __func__, port->number);
1009
1010         switch (status) {
1011         case 0:
1012                 /* success */
1013                 break;
1014         case -ECONNRESET:
1015         case -ENOENT:
1016         case -ESHUTDOWN:
1017                 /* this urb is terminated, clean up */
1018                 dbg("%s - urb shutting down with status: %d", __func__,
1019                     status);
1020                 return;
1021         default:
1022                 dbg("%s - nonzero urb status received: %d", __func__,
1023                     status);
1024                 goto exit;
1025         }
1026
1027         usb_serial_debug_data(debug, &port->dev, __func__,
1028                               urb->actual_length, urb->transfer_buffer);
1029
1030         pl2303_update_line_status(port, data, actual_length);
1031
1032 exit:
1033         retval = usb_submit_urb(urb, GFP_ATOMIC);
1034         if (retval)
1035                 dev_err(&urb->dev->dev,
1036                         "%s - usb_submit_urb failed with result %d\n",
1037                         __func__, retval);
1038 }
1039
1040 static void pl2303_push_data(struct tty_struct *tty,
1041                 struct usb_serial_port *port, struct urb *urb,
1042                 u8 line_status)
1043 {
1044         unsigned char *data = urb->transfer_buffer;
1045         /* get tty_flag from status */
1046         char tty_flag = TTY_NORMAL;
1047         /* break takes precedence over parity, */
1048         /* which takes precedence over framing errors */
1049         if (line_status & UART_BREAK_ERROR)
1050                 tty_flag = TTY_BREAK;
1051         else if (line_status & UART_PARITY_ERROR)
1052                 tty_flag = TTY_PARITY;
1053         else if (line_status & UART_FRAME_ERROR)
1054                 tty_flag = TTY_FRAME;
1055         dbg("%s - tty_flag = %d", __func__, tty_flag);
1056
1057         /* overrun is special, not associated with a char */
1058         if (line_status & UART_OVERRUN_ERROR)
1059                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1060
1061         if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq))
1062                 tty_insert_flip_string(tty, data, urb->actual_length);
1063         else {
1064                 int i;
1065                 for (i = 0; i < urb->actual_length; ++i)
1066                         if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
1067                                 tty_insert_flip_char(tty, data[i], tty_flag);
1068         }
1069         tty_flip_buffer_push(tty);
1070 }
1071
1072 static void pl2303_read_bulk_callback(struct urb *urb)
1073 {
1074         struct usb_serial_port *port =  urb->context;
1075         struct pl2303_private *priv = usb_get_serial_port_data(port);
1076         struct tty_struct *tty;
1077         unsigned long flags;
1078         int result;
1079         int status = urb->status;
1080         u8 line_status;
1081
1082         dbg("%s - port %d", __func__, port->number);
1083
1084         if (status) {
1085                 dbg("%s - urb status = %d", __func__, status);
1086                 if (status == -EPROTO) {
1087                         /* PL2303 mysteriously fails with -EPROTO reschedule
1088                          * the read */
1089                         dbg("%s - caught -EPROTO, resubmitting the urb",
1090                             __func__);
1091                         result = usb_submit_urb(urb, GFP_ATOMIC);
1092                         if (result)
1093                                 dev_err(&urb->dev->dev, "%s - failed"
1094                                         " resubmitting read urb, error %d\n",
1095                                         __func__, result);
1096                         return;
1097                 }
1098                 dbg("%s - unable to handle the error, exiting.", __func__);
1099                 return;
1100         }
1101
1102         usb_serial_debug_data(debug, &port->dev, __func__,
1103                               urb->actual_length, urb->transfer_buffer);
1104
1105         spin_lock_irqsave(&priv->lock, flags);
1106         line_status = priv->line_status;
1107         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1108         spin_unlock_irqrestore(&priv->lock, flags);
1109         wake_up_interruptible(&priv->delta_msr_wait);
1110
1111         tty = tty_port_tty_get(&port->port);
1112         if (tty && urb->actual_length) {
1113                 pl2303_push_data(tty, port, urb, line_status);
1114         }
1115         tty_kref_put(tty);
1116         /* Schedule the next read _if_ we are still open */
1117         result = usb_submit_urb(urb, GFP_ATOMIC);
1118         if (result && result != -EPERM)
1119                 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1120                         " read urb, error %d\n", __func__, result);
1121 }
1122
1123 static void pl2303_write_bulk_callback(struct urb *urb)
1124 {
1125         struct usb_serial_port *port =  urb->context;
1126         struct pl2303_private *priv = usb_get_serial_port_data(port);
1127         int result;
1128         int status = urb->status;
1129
1130         dbg("%s - port %d", __func__, port->number);
1131
1132         switch (status) {
1133         case 0:
1134                 /* success */
1135                 break;
1136         case -ECONNRESET:
1137         case -ENOENT:
1138         case -ESHUTDOWN:
1139                 /* this urb is terminated, clean up */
1140                 dbg("%s - urb shutting down with status: %d", __func__,
1141                     status);
1142                 priv->write_urb_in_use = 0;
1143                 return;
1144         default:
1145                 /* error in the urb, so we have to resubmit it */
1146                 dbg("%s - Overflow in write", __func__);
1147                 dbg("%s - nonzero write bulk status received: %d", __func__,
1148                     status);
1149                 port->write_urb->transfer_buffer_length = 1;
1150                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1151                 if (result)
1152                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1153                                 " urb, error %d\n", __func__, result);
1154                 else
1155                         return;
1156         }
1157
1158         priv->write_urb_in_use = 0;
1159
1160         /* send any buffered data */
1161         pl2303_send(port);
1162 }
1163
1164 /* All of the device info needed for the PL2303 SIO serial converter */
1165 static struct usb_serial_driver pl2303_device = {
1166         .driver = {
1167                 .owner =        THIS_MODULE,
1168                 .name =         "pl2303",
1169         },
1170         .id_table =             id_table,
1171         .usb_driver =           &pl2303_driver,
1172         .num_ports =            1,
1173         .open =                 pl2303_open,
1174         .close =                pl2303_close,
1175         .dtr_rts =              pl2303_dtr_rts,
1176         .carrier_raised =       pl2303_carrier_raised,
1177         .write =                pl2303_write,
1178         .ioctl =                pl2303_ioctl,
1179         .break_ctl =            pl2303_break_ctl,
1180         .set_termios =          pl2303_set_termios,
1181         .tiocmget =             pl2303_tiocmget,
1182         .tiocmset =             pl2303_tiocmset,
1183         .read_bulk_callback =   pl2303_read_bulk_callback,
1184         .read_int_callback =    pl2303_read_int_callback,
1185         .write_bulk_callback =  pl2303_write_bulk_callback,
1186         .write_room =           pl2303_write_room,
1187         .chars_in_buffer =      pl2303_chars_in_buffer,
1188         .attach =               pl2303_startup,
1189         .release =              pl2303_release,
1190 };
1191
1192 static int __init pl2303_init(void)
1193 {
1194         int retval;
1195
1196         retval = usb_serial_register(&pl2303_device);
1197         if (retval)
1198                 goto failed_usb_serial_register;
1199         retval = usb_register(&pl2303_driver);
1200         if (retval)
1201                 goto failed_usb_register;
1202         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1203         return 0;
1204 failed_usb_register:
1205         usb_serial_deregister(&pl2303_device);
1206 failed_usb_serial_register:
1207         return retval;
1208 }
1209
1210 static void __exit pl2303_exit(void)
1211 {
1212         usb_deregister(&pl2303_driver);
1213         usb_serial_deregister(&pl2303_device);
1214 }
1215
1216 module_init(pl2303_init);
1217 module_exit(pl2303_exit);
1218
1219 MODULE_DESCRIPTION(DRIVER_DESC);
1220 MODULE_LICENSE("GPL");
1221
1222 module_param(debug, bool, S_IRUGO | S_IWUSR);
1223 MODULE_PARM_DESC(debug, "Debug enabled or not");
1224