SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/serial/pl2303.c

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