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 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(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
  99         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
 100         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_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         port->write_urb->dev = port->serial->dev;
 456         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 457         if (result) {
 458                 dev_err(&port->dev, "%s - failed submitting write urb,"
 459                         " error %d\n", __func__, result);
 460                 priv->write_urb_in_use = 0;
 461                 /* TODO: reschedule pl2303_send */
 462         }
 463
 464         usb_serial_port_softint(port);
 465 }
 466
 467 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
 468                                 const unsigned char *buf, int count)
 469 {
 470         struct pl2303_private *priv = usb_get_serial_port_data(port);
 471         unsigned long flags;
 472
 473         dbg("%s - port %d, %d bytes", __func__, port->number, count);
 474
 475         if (!count)
 476                 return count;
 477
 478         spin_lock_irqsave(&priv->lock, flags);
 479         count = pl2303_buf_put(priv->buf, buf, count);
 480         spin_unlock_irqrestore(&priv->lock, flags);
 481
 482         pl2303_send(port);
 483
 484         return count;
 485 }
 486
 487 static int pl2303_write_room(struct tty_struct *tty)
 488 {
 489         struct usb_serial_port *port = tty->driver_data;
 490         struct pl2303_private *priv = usb_get_serial_port_data(port);
 491         int room = 0;
 492         unsigned long flags;
 493
 494         dbg("%s - port %d", __func__, port->number);
 495
 496         spin_lock_irqsave(&priv->lock, flags);
 497         room = pl2303_buf_space_avail(priv->buf);
 498         spin_unlock_irqrestore(&priv->lock, flags);
 499
 500         dbg("%s - returns %d", __func__, room);
 501         return room;
 502 }
 503
 504 static int pl2303_chars_in_buffer(struct tty_struct *tty)
 505 {
 506         struct usb_serial_port *port = tty->driver_data;
 507         struct pl2303_private *priv = usb_get_serial_port_data(port);
 508         int chars = 0;
 509         unsigned long flags;
 510
 511         dbg("%s - port %d", __func__, port->number);
 512
 513         spin_lock_irqsave(&priv->lock, flags);
 514         chars = pl2303_buf_data_avail(priv->buf);
 515         spin_unlock_irqrestore(&priv->lock, flags);
 516
 517         dbg("%s - returns %d", __func__, chars);
 518         return chars;
 519 }
 520
 521 static void pl2303_set_termios(struct tty_struct *tty,
 522                 struct usb_serial_port *port, struct ktermios *old_termios)
 523 {
 524         struct usb_serial *serial = port->serial;
 525         struct pl2303_private *priv = usb_get_serial_port_data(port);
 526         unsigned long flags;
 527         unsigned int cflag;
 528         unsigned char *buf;
 529         int baud;
 530         int i;
 531         u8 control;
 532         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
 533                                  4800, 7200, 9600, 14400, 19200, 28800, 38400,
 534                                  57600, 115200, 230400, 460800, 614400,
 535                                  921600, 1228800, 2457600, 3000000, 6000000 };
 536         int baud_floor, baud_ceil;
 537         int k;
 538
 539         dbg("%s -  port %d", __func__, port->number);
 540
 541         /* The PL2303 is reported to lose bytes if you change
 542            serial settings even to the same values as before. Thus
 543            we actually need to filter in this specific case */
 544
 545         if (!tty_termios_hw_change(tty->termios, old_termios))
 546                 return;
 547
 548         cflag = tty->termios->c_cflag;
 549
 550         buf = kzalloc(7, GFP_KERNEL);
 551         if (!buf) {
 552                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 553                 /* Report back no change occurred */
 554                 *tty->termios = *old_termios;
 555                 return;
 556         }
 557
 558         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 559                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 560                             0, 0, buf, 7, 100);
 561         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 562             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 563
 564         if (cflag & CSIZE) {
 565                 switch (cflag & CSIZE) {
 566                 case CS5:
 567                         buf[6] = 5;
 568                         break;
 569                 case CS6:
 570                         buf[6] = 6;
 571                         break;
 572                 case CS7:
 573                         buf[6] = 7;
 574                         break;
 575                 default:
 576                 case CS8:
 577                         buf[6] = 8;
 578                         break;
 579                 }
 580                 dbg("%s - data bits = %d", __func__, buf[6]);
 581         }
 582
 583         /* For reference buf[0]:buf[3] baud rate value */
 584         /* NOTE: Only the values defined in baud_sup are supported !
 585          *       => if unsupported values are set, the PL2303 seems to use
 586          *          9600 baud (at least my PL2303X always does)
 587          */
 588         baud = tty_get_baud_rate(tty);
 589         dbg("%s - baud requested = %d", __func__, baud);
 590         if (baud) {
 591                 /* Set baudrate to nearest supported value */
 592                 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
 593                         if (baud_sup[k] / baud) {
 594                                 baud_ceil = baud_sup[k];
 595                                 if (k==0) {
 596                                         baud = baud_ceil;
 597                                 } else {
 598                                         baud_floor = baud_sup[k-1];
 599                                         if ((baud_ceil % baud)
 600                                             > (baud % baud_floor))
 601                                                 baud = baud_floor;
 602                                         else
 603                                                 baud = baud_ceil;
 604                                 }
 605                                 break;
 606                         }
 607                 }
 608                 if (baud > 1228800) {
 609                         /* type_0, type_1 only support up to 1228800 baud */
 610                         if (priv->type != HX)
 611                                 baud = 1228800;
 612                         else if (baud > 6000000)
 613                                 baud = 6000000;
 614                 }
 615                 dbg("%s - baud set = %d", __func__, baud);
 616                 buf[0] = baud & 0xff;
 617                 buf[1] = (baud >> 8) & 0xff;
 618                 buf[2] = (baud >> 16) & 0xff;
 619                 buf[3] = (baud >> 24) & 0xff;
 620         }
 621
 622         /* For reference buf[4]=0 is 1 stop bits */
 623         /* For reference buf[4]=1 is 1.5 stop bits */
 624         /* For reference buf[4]=2 is 2 stop bits */
 625         if (cflag & CSTOPB) {
 626                 /* NOTE: Comply with "real" UARTs / RS232:
 627                  *       use 1.5 instead of 2 stop bits with 5 data bits
 628                  */
 629                 if ((cflag & CSIZE) == CS5) {
 630                         buf[4] = 1;
 631                         dbg("%s - stop bits = 1.5", __func__);
 632                 } else {
 633                         buf[4] = 2;
 634                         dbg("%s - stop bits = 2", __func__);
 635                 }
 636         } else {
 637                 buf[4] = 0;
 638                 dbg("%s - stop bits = 1", __func__);
 639         }
 640
 641         if (cflag & PARENB) {
 642                 /* For reference buf[5]=0 is none parity */
 643                 /* For reference buf[5]=1 is odd parity */
 644                 /* For reference buf[5]=2 is even parity */
 645                 /* For reference buf[5]=3 is mark parity */
 646                 /* For reference buf[5]=4 is space parity */
 647                 if (cflag & PARODD) {
 648                         if (cflag & CMSPAR) {
 649                                 buf[5] = 3;
 650                                 dbg("%s - parity = mark", __func__);
 651                         } else {
 652                                 buf[5] = 1;
 653                                 dbg("%s - parity = odd", __func__);
 654                         }
 655                 } else {
 656                         if (cflag & CMSPAR) {
 657                                 buf[5] = 4;
 658                                 dbg("%s - parity = space", __func__);
 659                         } else {
 660                                 buf[5] = 2;
 661                                 dbg("%s - parity = even", __func__);
 662                         }
 663                 }
 664         } else {
 665                 buf[5] = 0;
 666                 dbg("%s - parity = none", __func__);
 667         }
 668
 669         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 670                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 671                             0, 0, buf, 7, 100);
 672         dbg("0x21:0x20:0:0  %d", i);
 673
 674         /* change control lines if we are switching to or from B0 */
 675         spin_lock_irqsave(&priv->lock, flags);
 676         control = priv->line_control;
 677         if ((cflag & CBAUD) == B0)
 678                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 679         else
 680                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 681         if (control != priv->line_control) {
 682                 control = priv->line_control;
 683                 spin_unlock_irqrestore(&priv->lock, flags);
 684                 set_control_lines(serial->dev, control);
 685         } else {
 686                 spin_unlock_irqrestore(&priv->lock, flags);
 687         }
 688
 689         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 690
 691         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 692                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 693                             0, 0, buf, 7, 100);
 694         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 695              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 696
 697         if (cflag & CRTSCTS) {
 698                 if (priv->type == HX)
 699                         pl2303_vendor_write(0x0, 0x61, serial);
 700                 else
 701                         pl2303_vendor_write(0x0, 0x41, serial);
 702         } else {
 703                 pl2303_vendor_write(0x0, 0x0, serial);
 704         }
 705
 706         /* Save resulting baud rate */
 707         if (baud)
 708                 tty_encode_baud_rate(tty, baud, baud);
 709
 710         kfree(buf);
 711 }
 712
 713 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 714 {
 715         struct pl2303_private *priv = usb_get_serial_port_data(port);
 716         unsigned long flags;
 717         u8 control;
 718
 719         spin_lock_irqsave(&priv->lock, flags);
 720         /* Change DTR and RTS */
 721         if (on)
 722                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 723         else
 724                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 725         control = priv->line_control;
 726         spin_unlock_irqrestore(&priv->lock, flags);
 727         set_control_lines(port->serial->dev, control);
 728 }
 729
 730 static void pl2303_close(struct usb_serial_port *port)
 731 {
 732         struct pl2303_private *priv = usb_get_serial_port_data(port);
 733         unsigned long flags;
 734
 735         dbg("%s - port %d", __func__, port->number);
 736
 737         spin_lock_irqsave(&priv->lock, flags);
 738         /* clear out any remaining data in the buffer */
 739         pl2303_buf_clear(priv->buf);
 740         spin_unlock_irqrestore(&priv->lock, flags);
 741
 742         /* shutdown our urbs */
 743         dbg("%s - shutting down urbs", __func__);
 744         usb_kill_urb(port->write_urb);
 745         usb_kill_urb(port->read_urb);
 746         usb_kill_urb(port->interrupt_in_urb);
 747
 748 }
 749
 750 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 751 {
 752         struct ktermios tmp_termios;
 753         struct usb_serial *serial = port->serial;
 754         struct pl2303_private *priv = usb_get_serial_port_data(port);
 755         int result;
 756
 757         dbg("%s -  port %d", __func__, port->number);
 758
 759         if (priv->type != HX) {
 760                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 761                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 762         } else {
 763                 /* reset upstream data pipes */
 764                 pl2303_vendor_write(8, 0, serial);
 765                 pl2303_vendor_write(9, 0, serial);
 766         }
 767
 768         /* Setup termios */
 769         if (tty)
 770                 pl2303_set_termios(tty, port, &tmp_termios);
 771
 772         dbg("%s - submitting read urb", __func__);
 773         port->read_urb->dev = serial->dev;
 774         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 775         if (result) {
 776                 dev_err(&port->dev, "%s - failed submitting read urb,"
 777                         " error %d\n", __func__, result);
 778                 pl2303_close(port);
 779                 return -EPROTO;
 780         }
 781
 782         dbg("%s - submitting interrupt urb", __func__);
 783         port->interrupt_in_urb->dev = serial->dev;
 784         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 785         if (result) {
 786                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 787                         " error %d\n", __func__, result);
 788                 pl2303_close(port);
 789                 return -EPROTO;
 790         }
 791         port->port.drain_delay = 256;
 792         return 0;
 793 }
 794
 795 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 796                            unsigned int set, unsigned int clear)
 797 {
 798         struct usb_serial_port *port = tty->driver_data;
 799         struct pl2303_private *priv = usb_get_serial_port_data(port);
 800         unsigned long flags;
 801         u8 control;
 802
 803         if (!usb_get_intfdata(port->serial->interface))
 804                 return -ENODEV;
 805
 806         spin_lock_irqsave(&priv->lock, flags);
 807         if (set & TIOCM_RTS)
 808                 priv->line_control |= CONTROL_RTS;
 809         if (set & TIOCM_DTR)
 810                 priv->line_control |= CONTROL_DTR;
 811         if (clear & TIOCM_RTS)
 812                 priv->line_control &= ~CONTROL_RTS;
 813         if (clear & TIOCM_DTR)
 814                 priv->line_control &= ~CONTROL_DTR;
 815         control = priv->line_control;
 816         spin_unlock_irqrestore(&priv->lock, flags);
 817
 818         return set_control_lines(port->serial->dev, control);
 819 }
 820
 821 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 822 {
 823         struct usb_serial_port *port = tty->driver_data;
 824         struct pl2303_private *priv = usb_get_serial_port_data(port);
 825         unsigned long flags;
 826         unsigned int mcr;
 827         unsigned int status;
 828         unsigned int result;
 829
 830         dbg("%s (%d)", __func__, port->number);
 831
 832         if (!usb_get_intfdata(port->serial->interface))
 833                 return -ENODEV;
 834
 835         spin_lock_irqsave(&priv->lock, flags);
 836         mcr = priv->line_control;
 837         status = priv->line_status;
 838         spin_unlock_irqrestore(&priv->lock, flags);
 839
 840         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 841                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 842                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 843                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 844                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 845                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 846
 847         dbg("%s - result = %x", __func__, result);
 848
 849         return result;
 850 }
 851
 852 static int pl2303_carrier_raised(struct usb_serial_port *port)
 853 {
 854         struct pl2303_private *priv = usb_get_serial_port_data(port);
 855         if (priv->line_status & UART_DCD)
 856                 return 1;
 857         return 0;
 858 }
 859
 860 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 861 {
 862         struct pl2303_private *priv = usb_get_serial_port_data(port);
 863         unsigned long flags;
 864         unsigned int prevstatus;
 865         unsigned int status;
 866         unsigned int changed;
 867
 868         spin_lock_irqsave(&priv->lock, flags);
 869         prevstatus = priv->line_status;
 870         spin_unlock_irqrestore(&priv->lock, flags);
 871
 872         while (1) {
 873                 interruptible_sleep_on(&priv->delta_msr_wait);
 874                 /* see if a signal did it */
 875                 if (signal_pending(current))
 876                         return -ERESTARTSYS;
 877
 878                 spin_lock_irqsave(&priv->lock, flags);
 879                 status = priv->line_status;
 880                 spin_unlock_irqrestore(&priv->lock, flags);
 881
 882                 changed = prevstatus ^ status;
 883
 884                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 885                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 886                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 887                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 888                         return 0;
 889                 }
 890                 prevstatus = status;
 891         }
 892         /* NOTREACHED */
 893         return 0;
 894 }
 895
 896 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 897                         unsigned int cmd, unsigned long arg)
 898 {
 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 TIOCMIWAIT:
 904                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 905                 return wait_modem_info(port, arg);
 906         default:
 907                 dbg("%s not supported = 0x%04x", __func__, cmd);
 908                 break;
 909         }
 910         return -ENOIOCTLCMD;
 911 }
 912
 913 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 914 {
 915         struct usb_serial_port *port = tty->driver_data;
 916         struct usb_serial *serial = port->serial;
 917         u16 state;
 918         int result;
 919
 920         dbg("%s - port %d", __func__, port->number);
 921
 922         if (break_state == 0)
 923                 state = BREAK_OFF;
 924         else
 925                 state = BREAK_ON;
 926         dbg("%s - turning break %s", __func__,
 927                         state == BREAK_OFF ? "off" : "on");
 928
 929         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 930                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 931                                  0, NULL, 0, 100);
 932         if (result)
 933                 dbg("%s - error sending break = %d", __func__, result);
 934 }
 935
 936 static void pl2303_release(struct usb_serial *serial)
 937 {
 938         int i;
 939         struct pl2303_private *priv;
 940
 941         dbg("%s", __func__);
 942
 943         for (i = 0; i < serial->num_ports; ++i) {
 944                 priv = usb_get_serial_port_data(serial->port[i]);
 945                 if (priv) {
 946                         pl2303_buf_free(priv->buf);
 947                         kfree(priv);
 948                 }
 949         }
 950 }
 951
 952 static void pl2303_update_line_status(struct usb_serial_port *port,
 953                                       unsigned char *data,
 954                                       unsigned int actual_length)
 955 {
 956
 957         struct pl2303_private *priv = usb_get_serial_port_data(port);
 958         unsigned long flags;
 959         u8 status_idx = UART_STATE;
 960         u8 length = UART_STATE + 1;
 961         u16 idv, idp;
 962
 963         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 964         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 965
 966
 967         if (idv == SIEMENS_VENDOR_ID) {
 968                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 969                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 970                     idp == SIEMENS_PRODUCT_ID_X75) {
 971
 972                         length = 1;
 973                         status_idx = 0;
 974                 }
 975         }
 976
 977         if (actual_length < length)
 978                 return;
 979
 980         /* Save off the uart status for others to look at */
 981         spin_lock_irqsave(&priv->lock, flags);
 982         priv->line_status = data[status_idx];
 983         spin_unlock_irqrestore(&priv->lock, flags);
 984         if (priv->line_status & UART_BREAK_ERROR)
 985                 usb_serial_handle_break(port);
 986         wake_up_interruptible(&priv->delta_msr_wait);
 987 }
 988
 989 static void pl2303_read_int_callback(struct urb *urb)
 990 {
 991         struct usb_serial_port *port =  urb->context;
 992         unsigned char *data = urb->transfer_buffer;
 993         unsigned int actual_length = urb->actual_length;
 994         int status = urb->status;
 995         int retval;
 996
 997         dbg("%s (%d)", __func__, port->number);
 998
 999         switch (status) {
1000         case 0:
1001                 /* success */
1002                 break;
1003         case -ECONNRESET:
1004         case -ENOENT:
1005         case -ESHUTDOWN:
1006                 /* this urb is terminated, clean up */
1007                 dbg("%s - urb shutting down with status: %d", __func__,
1008                     status);
1009                 return;
1010         default:
1011                 dbg("%s - nonzero urb status received: %d", __func__,
1012                     status);
1013                 goto exit;
1014         }
1015
1016         usb_serial_debug_data(debug, &port->dev, __func__,
1017                               urb->actual_length, urb->transfer_buffer);
1018
1019         pl2303_update_line_status(port, data, actual_length);
1020
1021 exit:
1022         retval = usb_submit_urb(urb, GFP_ATOMIC);
1023         if (retval)
1024                 dev_err(&urb->dev->dev,
1025                         "%s - usb_submit_urb failed with result %d\n",
1026                         __func__, retval);
1027 }
1028
1029 static void pl2303_push_data(struct tty_struct *tty,
1030                 struct usb_serial_port *port, struct urb *urb,
1031                 u8 line_status)
1032 {
1033         unsigned char *data = urb->transfer_buffer;
1034         /* get tty_flag from status */
1035         char tty_flag = TTY_NORMAL;
1036         /* break takes precedence over parity, */
1037         /* which takes precedence over framing errors */
1038         if (line_status & UART_BREAK_ERROR)
1039                 tty_flag = TTY_BREAK;
1040         else if (line_status & UART_PARITY_ERROR)
1041                 tty_flag = TTY_PARITY;
1042         else if (line_status & UART_FRAME_ERROR)
1043                 tty_flag = TTY_FRAME;
1044         dbg("%s - tty_flag = %d", __func__, tty_flag);
1045
1046         tty_buffer_request_room(tty, urb->actual_length + 1);
1047         /* overrun is special, not associated with a char */
1048         if (line_status & UART_OVERRUN_ERROR)
1049                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1050
1051         if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq))
1052                 tty_insert_flip_string(tty, data, urb->actual_length);
1053         else {
1054                 int i;
1055                 for (i = 0; i < urb->actual_length; ++i)
1056                         if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
1057                                 tty_insert_flip_char(tty, data[i], tty_flag);
1058         }
1059         tty_flip_buffer_push(tty);
1060 }
1061
1062 static void pl2303_read_bulk_callback(struct urb *urb)
1063 {
1064         struct usb_serial_port *port =  urb->context;
1065         struct pl2303_private *priv = usb_get_serial_port_data(port);
1066         struct tty_struct *tty;
1067         unsigned long flags;
1068         int result;
1069         int status = urb->status;
1070         u8 line_status;
1071
1072         dbg("%s - port %d", __func__, port->number);
1073
1074         if (status) {
1075                 dbg("%s - urb status = %d", __func__, status);
1076                 if (!port->port.count) {
1077                         dbg("%s - port is closed, exiting.", __func__);
1078                         return;
1079                 }
1080                 if (status == -EPROTO) {
1081                         /* PL2303 mysteriously fails with -EPROTO reschedule
1082                          * the read */
1083                         dbg("%s - caught -EPROTO, resubmitting the urb",
1084                             __func__);
1085                         urb->dev = port->serial->dev;
1086                         result = usb_submit_urb(urb, GFP_ATOMIC);
1087                         if (result)
1088                                 dev_err(&urb->dev->dev, "%s - failed"
1089                                         " resubmitting read urb, error %d\n",
1090                                         __func__, result);
1091                         return;
1092                 }
1093                 dbg("%s - unable to handle the error, exiting.", __func__);
1094                 return;
1095         }
1096
1097         usb_serial_debug_data(debug, &port->dev, __func__,
1098                               urb->actual_length, urb->transfer_buffer);
1099
1100         spin_lock_irqsave(&priv->lock, flags);
1101         line_status = priv->line_status;
1102         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1103         spin_unlock_irqrestore(&priv->lock, flags);
1104         wake_up_interruptible(&priv->delta_msr_wait);
1105
1106         tty = tty_port_tty_get(&port->port);
1107         if (tty && urb->actual_length) {
1108                 pl2303_push_data(tty, port, urb, line_status);
1109         }
1110         tty_kref_put(tty);
1111         /* Schedule the next read _if_ we are still open */
1112         if (port->port.count) {
1113                 urb->dev = port->serial->dev;
1114                 result = usb_submit_urb(urb, GFP_ATOMIC);
1115                 if (result)
1116                         dev_err(&urb->dev->dev, "%s - failed resubmitting"
1117                                 " read urb, error %d\n", __func__, result);
1118         }
1119
1120         return;
1121 }
1122
1123 static void pl2303_write_bulk_callback(struct urb *urb)
1124 {
1125         struct usb_serial_port *port =  urb->context;
1126         struct pl2303_private *priv = usb_get_serial_port_data(port);
1127         int result;
1128         int status = urb->status;
1129
1130         dbg("%s - port %d", __func__, port->number);
1131
1132         switch (status) {
1133         case 0:
1134                 /* success */
1135                 break;
1136         case -ECONNRESET:
1137         case -ENOENT:
1138         case -ESHUTDOWN:
1139                 /* this urb is terminated, clean up */
1140                 dbg("%s - urb shutting down with status: %d", __func__,
1141                     status);
1142                 priv->write_urb_in_use = 0;
1143                 return;
1144         default:
1145                 /* error in the urb, so we have to resubmit it */
1146                 dbg("%s - Overflow in write", __func__);
1147                 dbg("%s - nonzero write bulk status received: %d", __func__,
1148                     status);
1149                 port->write_urb->transfer_buffer_length = 1;
1150                 port->write_urb->dev = port->serial->dev;
1151                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1152                 if (result)
1153                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1154                                 " urb, error %d\n", __func__, result);
1155                 else
1156                         return;
1157         }
1158
1159         priv->write_urb_in_use = 0;
1160
1161         /* send any buffered data */
1162         pl2303_send(port);
1163 }
1164
1165 /* All of the device info needed for the PL2303 SIO serial converter */
1166 static struct usb_serial_driver pl2303_device = {
1167         .driver = {
1168                 .owner =        THIS_MODULE,
1169                 .name =         "pl2303",
1170         },
1171         .id_table =             id_table,
1172         .usb_driver =           &pl2303_driver,
1173         .num_ports =            1,
1174         .open =                 pl2303_open,
1175         .close =                pl2303_close,
1176         .dtr_rts =              pl2303_dtr_rts,
1177         .carrier_raised =       pl2303_carrier_raised,
1178         .write =                pl2303_write,
1179         .ioctl =                pl2303_ioctl,
1180         .break_ctl =            pl2303_break_ctl,
1181         .set_termios =          pl2303_set_termios,
1182         .tiocmget =             pl2303_tiocmget,
1183         .tiocmset =             pl2303_tiocmset,
1184         .read_bulk_callback =   pl2303_read_bulk_callback,
1185         .read_int_callback =    pl2303_read_int_callback,
1186         .write_bulk_callback =  pl2303_write_bulk_callback,
1187         .write_room =           pl2303_write_room,
1188         .chars_in_buffer =      pl2303_chars_in_buffer,
1189         .attach =               pl2303_startup,
1190         .release =              pl2303_release,
1191 };
1192
1193 static int __init pl2303_init(void)
1194 {
1195         int retval;
1196
1197         retval = usb_serial_register(&pl2303_device);
1198         if (retval)
1199                 goto failed_usb_serial_register;
1200         retval = usb_register(&pl2303_driver);
1201         if (retval)
1202                 goto failed_usb_register;
1203         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1204         return 0;
1205 failed_usb_register:
1206         usb_serial_deregister(&pl2303_device);
1207 failed_usb_serial_register:
1208         return retval;
1209 }
1210
1211 static void __exit pl2303_exit(void)
1212 {
1213         usb_deregister(&pl2303_driver);
1214         usb_serial_deregister(&pl2303_device);
1215 }
1216
1217 module_init(pl2303_init);
1218 module_exit(pl2303_exit);
1219
1220 MODULE_DESCRIPTION(DRIVER_DESC);
1221 MODULE_LICENSE("GPL");
1222
1223 module_param(debug, bool, S_IRUGO | S_IWUSR);
1224 MODULE_PARM_DESC(debug, "Debug enabled or not");
1225