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         { }                                     /* Terminating entry */
 101 };
 102
 103 MODULE_DEVICE_TABLE(usb, id_table);
 104
 105 static struct usb_driver pl2303_driver = {
 106         .name =         "pl2303",
 107         .probe =        usb_serial_probe,
 108         .disconnect =   usb_serial_disconnect,
 109         .id_table =     id_table,
 110         .suspend =      usb_serial_suspend,
 111         .resume =       usb_serial_resume,
 112         .no_dynamic_id =        1,
 113         .supports_autosuspend = 1,
 114 };
 115
 116 #define SET_LINE_REQUEST_TYPE           0x21
 117 #define SET_LINE_REQUEST                0x20
 118
 119 #define SET_CONTROL_REQUEST_TYPE        0x21
 120 #define SET_CONTROL_REQUEST             0x22
 121 #define CONTROL_DTR                     0x01
 122 #define CONTROL_RTS                     0x02
 123
 124 #define BREAK_REQUEST_TYPE              0x21
 125 #define BREAK_REQUEST                   0x23
 126 #define BREAK_ON                        0xffff
 127 #define BREAK_OFF                       0x0000
 128
 129 #define GET_LINE_REQUEST_TYPE           0xa1
 130 #define GET_LINE_REQUEST                0x21
 131
 132 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 133 #define VENDOR_WRITE_REQUEST            0x01
 134
 135 #define VENDOR_READ_REQUEST_TYPE        0xc0
 136 #define VENDOR_READ_REQUEST             0x01
 137
 138 #define UART_STATE                      0x08
 139 #define UART_STATE_TRANSIENT_MASK       0x74
 140 #define UART_DCD                        0x01
 141 #define UART_DSR                        0x02
 142 #define UART_BREAK_ERROR                0x04
 143 #define UART_RING                       0x08
 144 #define UART_FRAME_ERROR                0x10
 145 #define UART_PARITY_ERROR               0x20
 146 #define UART_OVERRUN_ERROR              0x40
 147 #define UART_CTS                        0x80
 148
 149
 150 enum pl2303_type {
 151         type_0,         /* don't know the difference between type 0 and */
 152         type_1,         /* type 1, until someone from prolific tells us... */
 153         HX,             /* HX version of the pl2303 chip */
 154 };
 155
 156 struct pl2303_private {
 157         spinlock_t lock;
 158         struct pl2303_buf *buf;
 159         int write_urb_in_use;
 160         wait_queue_head_t delta_msr_wait;
 161         u8 line_control;
 162         u8 line_status;
 163         enum pl2303_type type;
 164 };
 165
 166 /*
 167  * pl2303_buf_alloc
 168  *
 169  * Allocate a circular buffer and all associated memory.
 170  */
 171 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
 172 {
 173         struct pl2303_buf *pb;
 174
 175         if (size == 0)
 176                 return NULL;
 177
 178         pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
 179         if (pb == NULL)
 180                 return NULL;
 181
 182         pb->buf_buf = kmalloc(size, GFP_KERNEL);
 183         if (pb->buf_buf == NULL) {
 184                 kfree(pb);
 185                 return NULL;
 186         }
 187
 188         pb->buf_size = size;
 189         pb->buf_get = pb->buf_put = pb->buf_buf;
 190
 191         return pb;
 192 }
 193
 194 /*
 195  * pl2303_buf_free
 196  *
 197  * Free the buffer and all associated memory.
 198  */
 199 static void pl2303_buf_free(struct pl2303_buf *pb)
 200 {
 201         if (pb) {
 202                 kfree(pb->buf_buf);
 203                 kfree(pb);
 204         }
 205 }
 206
 207 /*
 208  * pl2303_buf_clear
 209  *
 210  * Clear out all data in the circular buffer.
 211  */
 212 static void pl2303_buf_clear(struct pl2303_buf *pb)
 213 {
 214         if (pb != NULL)
 215                 pb->buf_get = pb->buf_put;
 216                 /* equivalent to a get of all data available */
 217 }
 218
 219 /*
 220  * pl2303_buf_data_avail
 221  *
 222  * Return the number of bytes of data available in the circular
 223  * buffer.
 224  */
 225 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
 226 {
 227         if (pb == NULL)
 228                 return 0;
 229
 230         return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
 231 }
 232
 233 /*
 234  * pl2303_buf_space_avail
 235  *
 236  * Return the number of bytes of space available in the circular
 237  * buffer.
 238  */
 239 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
 240 {
 241         if (pb == NULL)
 242                 return 0;
 243
 244         return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
 245 }
 246
 247 /*
 248  * pl2303_buf_put
 249  *
 250  * Copy data data from a user buffer and put it into the circular buffer.
 251  * Restrict to the amount of space available.
 252  *
 253  * Return the number of bytes copied.
 254  */
 255 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
 256                                    unsigned int count)
 257 {
 258         unsigned int len;
 259
 260         if (pb == NULL)
 261                 return 0;
 262
 263         len  = pl2303_buf_space_avail(pb);
 264         if (count > len)
 265                 count = len;
 266
 267         if (count == 0)
 268                 return 0;
 269
 270         len = pb->buf_buf + pb->buf_size - pb->buf_put;
 271         if (count > len) {
 272                 memcpy(pb->buf_put, buf, len);
 273                 memcpy(pb->buf_buf, buf+len, count - len);
 274                 pb->buf_put = pb->buf_buf + count - len;
 275         } else {
 276                 memcpy(pb->buf_put, buf, count);
 277                 if (count < len)
 278                         pb->buf_put += count;
 279                 else /* count == len */
 280                         pb->buf_put = pb->buf_buf;
 281         }
 282
 283         return count;
 284 }
 285
 286 /*
 287  * pl2303_buf_get
 288  *
 289  * Get data from the circular buffer and copy to the given buffer.
 290  * Restrict to the amount of data available.
 291  *
 292  * Return the number of bytes copied.
 293  */
 294 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
 295                                    unsigned int count)
 296 {
 297         unsigned int len;
 298
 299         if (pb == NULL)
 300                 return 0;
 301
 302         len = pl2303_buf_data_avail(pb);
 303         if (count > len)
 304                 count = len;
 305
 306         if (count == 0)
 307                 return 0;
 308
 309         len = pb->buf_buf + pb->buf_size - pb->buf_get;
 310         if (count > len) {
 311                 memcpy(buf, pb->buf_get, len);
 312                 memcpy(buf+len, pb->buf_buf, count - len);
 313                 pb->buf_get = pb->buf_buf + count - len;
 314         } else {
 315                 memcpy(buf, pb->buf_get, count);
 316                 if (count < len)
 317                         pb->buf_get += count;
 318                 else /* count == len */
 319                         pb->buf_get = pb->buf_buf;
 320         }
 321
 322         return count;
 323 }
 324
 325 static int pl2303_vendor_read(__u16 value, __u16 index,
 326                 struct usb_serial *serial, unsigned char *buf)
 327 {
 328         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 329                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 330                         value, index, buf, 1, 100);
 331         dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", VENDOR_READ_REQUEST_TYPE,
 332                         VENDOR_READ_REQUEST, value, index, res, buf[0]);
 333         return res;
 334 }
 335
 336 static int pl2303_vendor_write(__u16 value, __u16 index,
 337                 struct usb_serial *serial)
 338 {
 339         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 340                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 341                         value, index, NULL, 0, 100);
 342         dbg("0x%x:0x%x:0x%x:0x%x  %d", VENDOR_WRITE_REQUEST_TYPE,
 343                         VENDOR_WRITE_REQUEST, value, index, res);
 344         return res;
 345 }
 346
 347 static int pl2303_startup(struct usb_serial *serial)
 348 {
 349         struct pl2303_private *priv;
 350         enum pl2303_type type = type_0;
 351         unsigned char *buf;
 352         int i;
 353
 354         buf = kmalloc(10, GFP_KERNEL);
 355         if (buf == NULL)
 356                 return -ENOMEM;
 357
 358         if (serial->dev->descriptor.bDeviceClass == 0x02)
 359                 type = type_0;
 360         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 361                 type = HX;
 362         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 363                 type = type_1;
 364         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 365                 type = type_1;
 366         dbg("device type: %d", type);
 367
 368         for (i = 0; i < serial->num_ports; ++i) {
 369                 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
 370                 if (!priv)
 371                         goto cleanup;
 372                 spin_lock_init(&priv->lock);
 373                 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
 374                 if (priv->buf == NULL) {
 375                         kfree(priv);
 376                         goto cleanup;
 377                 }
 378                 init_waitqueue_head(&priv->delta_msr_wait);
 379                 priv->type = type;
 380                 usb_set_serial_port_data(serial->port[i], priv);
 381         }
 382
 383         pl2303_vendor_read(0x8484, 0, serial, buf);
 384         pl2303_vendor_write(0x0404, 0, serial);
 385         pl2303_vendor_read(0x8484, 0, serial, buf);
 386         pl2303_vendor_read(0x8383, 0, serial, buf);
 387         pl2303_vendor_read(0x8484, 0, serial, buf);
 388         pl2303_vendor_write(0x0404, 1, serial);
 389         pl2303_vendor_read(0x8484, 0, serial, buf);
 390         pl2303_vendor_read(0x8383, 0, serial, buf);
 391         pl2303_vendor_write(0, 1, serial);
 392         pl2303_vendor_write(1, 0, serial);
 393         if (type == HX)
 394                 pl2303_vendor_write(2, 0x44, serial);
 395         else
 396                 pl2303_vendor_write(2, 0x24, serial);
 397
 398         kfree(buf);
 399         return 0;
 400
 401 cleanup:
 402         kfree(buf);
 403         for (--i; i >= 0; --i) {
 404                 priv = usb_get_serial_port_data(serial->port[i]);
 405                 pl2303_buf_free(priv->buf);
 406                 kfree(priv);
 407                 usb_set_serial_port_data(serial->port[i], NULL);
 408         }
 409         return -ENOMEM;
 410 }
 411
 412 static int set_control_lines(struct usb_device *dev, u8 value)
 413 {
 414         int retval;
 415
 416         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 417                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 418                                  value, 0, NULL, 0, 100);
 419         dbg("%s - value = %d, retval = %d", __func__, value, retval);
 420         return retval;
 421 }
 422
 423 static void pl2303_send(struct usb_serial_port *port)
 424 {
 425         int count, result;
 426         struct pl2303_private *priv = usb_get_serial_port_data(port);
 427         unsigned long flags;
 428
 429         dbg("%s - port %d", __func__, port->number);
 430
 431         spin_lock_irqsave(&priv->lock, flags);
 432
 433         if (priv->write_urb_in_use) {
 434                 spin_unlock_irqrestore(&priv->lock, flags);
 435                 return;
 436         }
 437
 438         count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
 439                                port->bulk_out_size);
 440
 441         if (count == 0) {
 442                 spin_unlock_irqrestore(&priv->lock, flags);
 443                 return;
 444         }
 445
 446         priv->write_urb_in_use = 1;
 447
 448         spin_unlock_irqrestore(&priv->lock, flags);
 449
 450         usb_serial_debug_data(debug, &port->dev, __func__, count,
 451                               port->write_urb->transfer_buffer);
 452
 453         port->write_urb->transfer_buffer_length = count;
 454         port->write_urb->dev = port->serial->dev;
 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         port->read_urb->dev = serial->dev;
 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         port->interrupt_in_urb->dev = serial->dev;
 783         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 784         if (result) {
 785                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 786                         " error %d\n", __func__, result);
 787                 pl2303_close(port);
 788                 return -EPROTO;
 789         }
 790         port->port.drain_delay = 256;
 791         return 0;
 792 }
 793
 794 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 795                            unsigned int set, unsigned int clear)
 796 {
 797         struct usb_serial_port *port = tty->driver_data;
 798         struct pl2303_private *priv = usb_get_serial_port_data(port);
 799         unsigned long flags;
 800         u8 control;
 801
 802         if (!usb_get_intfdata(port->serial->interface))
 803                 return -ENODEV;
 804
 805         spin_lock_irqsave(&priv->lock, flags);
 806         if (set & TIOCM_RTS)
 807                 priv->line_control |= CONTROL_RTS;
 808         if (set & TIOCM_DTR)
 809                 priv->line_control |= CONTROL_DTR;
 810         if (clear & TIOCM_RTS)
 811                 priv->line_control &= ~CONTROL_RTS;
 812         if (clear & TIOCM_DTR)
 813                 priv->line_control &= ~CONTROL_DTR;
 814         control = priv->line_control;
 815         spin_unlock_irqrestore(&priv->lock, flags);
 816
 817         return set_control_lines(port->serial->dev, control);
 818 }
 819
 820 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 821 {
 822         struct usb_serial_port *port = tty->driver_data;
 823         struct pl2303_private *priv = usb_get_serial_port_data(port);
 824         unsigned long flags;
 825         unsigned int mcr;
 826         unsigned int status;
 827         unsigned int result;
 828
 829         dbg("%s (%d)", __func__, port->number);
 830
 831         if (!usb_get_intfdata(port->serial->interface))
 832                 return -ENODEV;
 833
 834         spin_lock_irqsave(&priv->lock, flags);
 835         mcr = priv->line_control;
 836         status = priv->line_status;
 837         spin_unlock_irqrestore(&priv->lock, flags);
 838
 839         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 840                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 841                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 842                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 843                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 844                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 845
 846         dbg("%s - result = %x", __func__, result);
 847
 848         return result;
 849 }
 850
 851 static int pl2303_carrier_raised(struct usb_serial_port *port)
 852 {
 853         struct pl2303_private *priv = usb_get_serial_port_data(port);
 854         if (priv->line_status & UART_DCD)
 855                 return 1;
 856         return 0;
 857 }
 858
 859 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 860 {
 861         struct pl2303_private *priv = usb_get_serial_port_data(port);
 862         unsigned long flags;
 863         unsigned int prevstatus;
 864         unsigned int status;
 865         unsigned int changed;
 866
 867         spin_lock_irqsave(&priv->lock, flags);
 868         prevstatus = priv->line_status;
 869         spin_unlock_irqrestore(&priv->lock, flags);
 870
 871         while (1) {
 872                 interruptible_sleep_on(&priv->delta_msr_wait);
 873                 /* see if a signal did it */
 874                 if (signal_pending(current))
 875                         return -ERESTARTSYS;
 876
 877                 spin_lock_irqsave(&priv->lock, flags);
 878                 status = priv->line_status;
 879                 spin_unlock_irqrestore(&priv->lock, flags);
 880
 881                 changed = prevstatus ^ status;
 882
 883                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 884                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 885                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 886                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 887                         return 0;
 888                 }
 889                 prevstatus = status;
 890         }
 891         /* NOTREACHED */
 892         return 0;
 893 }
 894
 895 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 896                         unsigned int cmd, unsigned long arg)
 897 {
 898         struct serial_struct ser;
 899         struct usb_serial_port *port = tty->driver_data;
 900         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 901
 902         switch (cmd) {
 903         case TIOCGSERIAL:
 904                 memset(&ser, 0, sizeof ser);
 905                 ser.type = PORT_16654;
 906                 ser.line = port->serial->minor;
 907                 ser.port = port->number;
 908                 ser.baud_base = 460800;
 909
 910                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 911                         return -EFAULT;
 912
 913                 return 0;
 914
 915         case TIOCMIWAIT:
 916                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 917                 return wait_modem_info(port, arg);
 918         default:
 919                 dbg("%s not supported = 0x%04x", __func__, cmd);
 920                 break;
 921         }
 922         return -ENOIOCTLCMD;
 923 }
 924
 925 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 926 {
 927         struct usb_serial_port *port = tty->driver_data;
 928         struct usb_serial *serial = port->serial;
 929         u16 state;
 930         int result;
 931
 932         dbg("%s - port %d", __func__, port->number);
 933
 934         if (break_state == 0)
 935                 state = BREAK_OFF;
 936         else
 937                 state = BREAK_ON;
 938         dbg("%s - turning break %s", __func__,
 939                         state == BREAK_OFF ? "off" : "on");
 940
 941         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 942                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 943                                  0, NULL, 0, 100);
 944         if (result)
 945                 dbg("%s - error sending break = %d", __func__, result);
 946 }
 947
 948 static void pl2303_release(struct usb_serial *serial)
 949 {
 950         int i;
 951         struct pl2303_private *priv;
 952
 953         dbg("%s", __func__);
 954
 955         for (i = 0; i < serial->num_ports; ++i) {
 956                 priv = usb_get_serial_port_data(serial->port[i]);
 957                 if (priv) {
 958                         pl2303_buf_free(priv->buf);
 959                         kfree(priv);
 960                 }
 961         }
 962 }
 963
 964 static void pl2303_update_line_status(struct usb_serial_port *port,
 965                                       unsigned char *data,
 966                                       unsigned int actual_length)
 967 {
 968
 969         struct pl2303_private *priv = usb_get_serial_port_data(port);
 970         unsigned long flags;
 971         u8 status_idx = UART_STATE;
 972         u8 length = UART_STATE + 1;
 973         u16 idv, idp;
 974
 975         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 976         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 977
 978
 979         if (idv == SIEMENS_VENDOR_ID) {
 980                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 981                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 982                     idp == SIEMENS_PRODUCT_ID_X75) {
 983
 984                         length = 1;
 985                         status_idx = 0;
 986                 }
 987         }
 988
 989         if (actual_length < length)
 990                 return;
 991
 992         /* Save off the uart status for others to look at */
 993         spin_lock_irqsave(&priv->lock, flags);
 994         priv->line_status = data[status_idx];
 995         spin_unlock_irqrestore(&priv->lock, flags);
 996         if (priv->line_status & UART_BREAK_ERROR)
 997                 usb_serial_handle_break(port);
 998         wake_up_interruptible(&priv->delta_msr_wait);
 999 }
1000
1001 static void pl2303_read_int_callback(struct urb *urb)
1002 {
1003         struct usb_serial_port *port =  urb->context;
1004         unsigned char *data = urb->transfer_buffer;
1005         unsigned int actual_length = urb->actual_length;
1006         int status = urb->status;
1007         int retval;
1008
1009         dbg("%s (%d)", __func__, port->number);
1010
1011         switch (status) {
1012         case 0:
1013                 /* success */
1014                 break;
1015         case -ECONNRESET:
1016         case -ENOENT:
1017         case -ESHUTDOWN:
1018                 /* this urb is terminated, clean up */
1019                 dbg("%s - urb shutting down with status: %d", __func__,
1020                     status);
1021                 return;
1022         default:
1023                 dbg("%s - nonzero urb status received: %d", __func__,
1024                     status);
1025                 goto exit;
1026         }
1027
1028         usb_serial_debug_data(debug, &port->dev, __func__,
1029                               urb->actual_length, urb->transfer_buffer);
1030
1031         pl2303_update_line_status(port, data, actual_length);
1032
1033 exit:
1034         retval = usb_submit_urb(urb, GFP_ATOMIC);
1035         if (retval)
1036                 dev_err(&urb->dev->dev,
1037                         "%s - usb_submit_urb failed with result %d\n",
1038                         __func__, retval);
1039 }
1040
1041 static void pl2303_push_data(struct tty_struct *tty,
1042                 struct usb_serial_port *port, struct urb *urb,
1043                 u8 line_status)
1044 {
1045         unsigned char *data = urb->transfer_buffer;
1046         /* get tty_flag from status */
1047         char tty_flag = TTY_NORMAL;
1048         /* break takes precedence over parity, */
1049         /* which takes precedence over framing errors */
1050         if (line_status & UART_BREAK_ERROR)
1051                 tty_flag = TTY_BREAK;
1052         else if (line_status & UART_PARITY_ERROR)
1053                 tty_flag = TTY_PARITY;
1054         else if (line_status & UART_FRAME_ERROR)
1055                 tty_flag = TTY_FRAME;
1056         dbg("%s - tty_flag = %d", __func__, tty_flag);
1057
1058         /* overrun is special, not associated with a char */
1059         if (line_status & UART_OVERRUN_ERROR)
1060                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1061
1062         if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq))
1063                 tty_insert_flip_string(tty, data, urb->actual_length);
1064         else {
1065                 int i;
1066                 for (i = 0; i < urb->actual_length; ++i)
1067                         if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
1068                                 tty_insert_flip_char(tty, data[i], tty_flag);
1069         }
1070         tty_flip_buffer_push(tty);
1071 }
1072
1073 static void pl2303_read_bulk_callback(struct urb *urb)
1074 {
1075         struct usb_serial_port *port =  urb->context;
1076         struct pl2303_private *priv = usb_get_serial_port_data(port);
1077         struct tty_struct *tty;
1078         unsigned long flags;
1079         int result;
1080         int status = urb->status;
1081         u8 line_status;
1082
1083         dbg("%s - port %d", __func__, port->number);
1084
1085         if (status) {
1086                 dbg("%s - urb status = %d", __func__, status);
1087                 if (status == -EPROTO) {
1088                         /* PL2303 mysteriously fails with -EPROTO reschedule
1089                          * the read */
1090                         dbg("%s - caught -EPROTO, resubmitting the urb",
1091                             __func__);
1092                         urb->dev = port->serial->dev;
1093                         result = usb_submit_urb(urb, GFP_ATOMIC);
1094                         if (result)
1095                                 dev_err(&urb->dev->dev, "%s - failed"
1096                                         " resubmitting read urb, error %d\n",
1097                                         __func__, result);
1098                         return;
1099                 }
1100                 dbg("%s - unable to handle the error, exiting.", __func__);
1101                 return;
1102         }
1103
1104         usb_serial_debug_data(debug, &port->dev, __func__,
1105                               urb->actual_length, urb->transfer_buffer);
1106
1107         spin_lock_irqsave(&priv->lock, flags);
1108         line_status = priv->line_status;
1109         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1110         spin_unlock_irqrestore(&priv->lock, flags);
1111         wake_up_interruptible(&priv->delta_msr_wait);
1112
1113         tty = tty_port_tty_get(&port->port);
1114         if (tty && urb->actual_length) {
1115                 pl2303_push_data(tty, port, urb, line_status);
1116         }
1117         tty_kref_put(tty);
1118         /* Schedule the next read _if_ we are still open */
1119         urb->dev = port->serial->dev;
1120         result = usb_submit_urb(urb, GFP_ATOMIC);
1121         if (result && result != -EPERM)
1122                 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1123                         " read urb, error %d\n", __func__, result);
1124 }
1125
1126 static void pl2303_write_bulk_callback(struct urb *urb)
1127 {
1128         struct usb_serial_port *port =  urb->context;
1129         struct pl2303_private *priv = usb_get_serial_port_data(port);
1130         int result;
1131         int status = urb->status;
1132
1133         dbg("%s - port %d", __func__, port->number);
1134
1135         switch (status) {
1136         case 0:
1137                 /* success */
1138                 break;
1139         case -ECONNRESET:
1140         case -ENOENT:
1141         case -ESHUTDOWN:
1142                 /* this urb is terminated, clean up */
1143                 dbg("%s - urb shutting down with status: %d", __func__,
1144                     status);
1145                 priv->write_urb_in_use = 0;
1146                 return;
1147         default:
1148                 /* error in the urb, so we have to resubmit it */
1149                 dbg("%s - Overflow in write", __func__);
1150                 dbg("%s - nonzero write bulk status received: %d", __func__,
1151                     status);
1152                 port->write_urb->transfer_buffer_length = 1;
1153                 port->write_urb->dev = port->serial->dev;
1154                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1155                 if (result)
1156                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1157                                 " urb, error %d\n", __func__, result);
1158                 else
1159                         return;
1160         }
1161
1162         priv->write_urb_in_use = 0;
1163
1164         /* send any buffered data */
1165         pl2303_send(port);
1166 }
1167
1168 /* All of the device info needed for the PL2303 SIO serial converter */
1169 static struct usb_serial_driver pl2303_device = {
1170         .driver = {
1171                 .owner =        THIS_MODULE,
1172                 .name =         "pl2303",
1173         },
1174         .id_table =             id_table,
1175         .usb_driver =           &pl2303_driver,
1176         .num_ports =            1,
1177         .open =                 pl2303_open,
1178         .close =                pl2303_close,
1179         .dtr_rts =              pl2303_dtr_rts,
1180         .carrier_raised =       pl2303_carrier_raised,
1181         .write =                pl2303_write,
1182         .ioctl =                pl2303_ioctl,
1183         .break_ctl =            pl2303_break_ctl,
1184         .set_termios =          pl2303_set_termios,
1185         .tiocmget =             pl2303_tiocmget,
1186         .tiocmset =             pl2303_tiocmset,
1187         .read_bulk_callback =   pl2303_read_bulk_callback,
1188         .read_int_callback =    pl2303_read_int_callback,
1189         .write_bulk_callback =  pl2303_write_bulk_callback,
1190         .write_room =           pl2303_write_room,
1191         .chars_in_buffer =      pl2303_chars_in_buffer,
1192         .attach =               pl2303_startup,
1193         .release =              pl2303_release,
1194 };
1195
1196 static int __init pl2303_init(void)
1197 {
1198         int retval;
1199
1200         retval = usb_serial_register(&pl2303_device);
1201         if (retval)
1202                 goto failed_usb_serial_register;
1203         retval = usb_register(&pl2303_driver);
1204         if (retval)
1205                 goto failed_usb_register;
1206         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1207         return 0;
1208 failed_usb_register:
1209         usb_serial_deregister(&pl2303_device);
1210 failed_usb_serial_register:
1211         return retval;
1212 }
1213
1214 static void __exit pl2303_exit(void)
1215 {
1216         usb_deregister(&pl2303_driver);
1217         usb_serial_deregister(&pl2303_device);
1218 }
1219
1220 module_init(pl2303_init);
1221 module_exit(pl2303_exit);
1222
1223 MODULE_DESCRIPTION(DRIVER_DESC);
1224 MODULE_LICENSE("GPL");
1225
1226 module_param(debug, bool, S_IRUGO | S_IWUSR);
1227 MODULE_PARM_DESC(debug, "Debug enabled or not");
1228