drivers/usb/serial/pl2303.c

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