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