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