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