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