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_dtr_rts(struct usb_serial_port *port, int on)
 656 {
 657         struct pl2303_private *priv = usb_get_serial_port_data(port);
 658         unsigned long flags;
 659         u8 control;
 660
 661         spin_lock_irqsave(&priv->lock, flags);
 662         /* Change DTR and RTS */
 663         if (on)
 664                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 665         else
 666                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 667         control = priv->line_control;
 668         spin_unlock_irqrestore(&priv->lock, flags);
 669         set_control_lines(port->serial->dev, control);
 670 }
 671
 672 static void pl2303_close(struct usb_serial_port *port)
 673 {
 674         struct pl2303_private *priv = usb_get_serial_port_data(port);
 675         unsigned long flags;
 676
 677         dbg("%s - port %d", __func__, port->number);
 678
 679         spin_lock_irqsave(&priv->lock, flags);
 680         /* clear out any remaining data in the buffer */
 681         pl2303_buf_clear(priv->buf);
 682         spin_unlock_irqrestore(&priv->lock, flags);
 683
 684         /* shutdown our urbs */
 685         dbg("%s - shutting down urbs", __func__);
 686         usb_kill_urb(port->write_urb);
 687         usb_kill_urb(port->read_urb);
 688         usb_kill_urb(port->interrupt_in_urb);
 689
 690 }
 691
 692 static int pl2303_open(struct tty_struct *tty,
 693                         struct usb_serial_port *port, struct file *filp)
 694 {
 695         struct ktermios tmp_termios;
 696         struct usb_serial *serial = port->serial;
 697         struct pl2303_private *priv = usb_get_serial_port_data(port);
 698         int result;
 699
 700         dbg("%s -  port %d", __func__, port->number);
 701
 702         if (priv->type != HX) {
 703                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 704                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 705         } else {
 706                 /* reset upstream data pipes */
 707                 pl2303_vendor_write(8, 0, serial);
 708                 pl2303_vendor_write(9, 0, serial);
 709         }
 710
 711         /* Setup termios */
 712         if (tty)
 713                 pl2303_set_termios(tty, port, &tmp_termios);
 714
 715         /* FIXME: need to assert RTS and DTR if CRTSCTS off */
 716
 717         dbg("%s - submitting read urb", __func__);
 718         port->read_urb->dev = serial->dev;
 719         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 720         if (result) {
 721                 dev_err(&port->dev, "%s - failed submitting read urb,"
 722                         " error %d\n", __func__, result);
 723                 pl2303_close(port);
 724                 return -EPROTO;
 725         }
 726
 727         dbg("%s - submitting interrupt urb", __func__);
 728         port->interrupt_in_urb->dev = serial->dev;
 729         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 730         if (result) {
 731                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 732                         " error %d\n", __func__, result);
 733                 pl2303_close(port);
 734                 return -EPROTO;
 735         }
 736         port->port.drain_delay = 256;
 737         return 0;
 738 }
 739
 740 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 741                            unsigned int set, unsigned int clear)
 742 {
 743         struct usb_serial_port *port = tty->driver_data;
 744         struct pl2303_private *priv = usb_get_serial_port_data(port);
 745         unsigned long flags;
 746         u8 control;
 747
 748         if (!usb_get_intfdata(port->serial->interface))
 749                 return -ENODEV;
 750
 751         spin_lock_irqsave(&priv->lock, flags);
 752         if (set & TIOCM_RTS)
 753                 priv->line_control |= CONTROL_RTS;
 754         if (set & TIOCM_DTR)
 755                 priv->line_control |= CONTROL_DTR;
 756         if (clear & TIOCM_RTS)
 757                 priv->line_control &= ~CONTROL_RTS;
 758         if (clear & TIOCM_DTR)
 759                 priv->line_control &= ~CONTROL_DTR;
 760         control = priv->line_control;
 761         spin_unlock_irqrestore(&priv->lock, flags);
 762
 763         return set_control_lines(port->serial->dev, control);
 764 }
 765
 766 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 767 {
 768         struct usb_serial_port *port = tty->driver_data;
 769         struct pl2303_private *priv = usb_get_serial_port_data(port);
 770         unsigned long flags;
 771         unsigned int mcr;
 772         unsigned int status;
 773         unsigned int result;
 774
 775         dbg("%s (%d)", __func__, port->number);
 776
 777         if (!usb_get_intfdata(port->serial->interface))
 778                 return -ENODEV;
 779
 780         spin_lock_irqsave(&priv->lock, flags);
 781         mcr = priv->line_control;
 782         status = priv->line_status;
 783         spin_unlock_irqrestore(&priv->lock, flags);
 784
 785         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 786                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 787                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 788                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 789                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 790                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 791
 792         dbg("%s - result = %x", __func__, result);
 793
 794         return result;
 795 }
 796
 797 static int pl2303_carrier_raised(struct usb_serial_port *port)
 798 {
 799         struct pl2303_private *priv = usb_get_serial_port_data(port);
 800         if (priv->line_status & UART_DCD)
 801                 return 1;
 802         return 0;
 803 }
 804
 805 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 806 {
 807         struct pl2303_private *priv = usb_get_serial_port_data(port);
 808         unsigned long flags;
 809         unsigned int prevstatus;
 810         unsigned int status;
 811         unsigned int changed;
 812
 813         spin_lock_irqsave(&priv->lock, flags);
 814         prevstatus = priv->line_status;
 815         spin_unlock_irqrestore(&priv->lock, flags);
 816
 817         while (1) {
 818                 interruptible_sleep_on(&priv->delta_msr_wait);
 819                 /* see if a signal did it */
 820                 if (signal_pending(current))
 821                         return -ERESTARTSYS;
 822
 823                 spin_lock_irqsave(&priv->lock, flags);
 824                 status = priv->line_status;
 825                 spin_unlock_irqrestore(&priv->lock, flags);
 826
 827                 changed = prevstatus ^ status;
 828
 829                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 830                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 831                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 832                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 833                         return 0;
 834                 }
 835                 prevstatus = status;
 836         }
 837         /* NOTREACHED */
 838         return 0;
 839 }
 840
 841 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 842                         unsigned int cmd, unsigned long arg)
 843 {
 844         struct usb_serial_port *port = tty->driver_data;
 845         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 846
 847         switch (cmd) {
 848         case TIOCMIWAIT:
 849                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 850                 return wait_modem_info(port, arg);
 851         default:
 852                 dbg("%s not supported = 0x%04x", __func__, cmd);
 853                 break;
 854         }
 855         return -ENOIOCTLCMD;
 856 }
 857
 858 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 859 {
 860         struct usb_serial_port *port = tty->driver_data;
 861         struct usb_serial *serial = port->serial;
 862         u16 state;
 863         int result;
 864
 865         dbg("%s - port %d", __func__, port->number);
 866
 867         if (break_state == 0)
 868                 state = BREAK_OFF;
 869         else
 870                 state = BREAK_ON;
 871         dbg("%s - turning break %s", __func__,
 872                         state == BREAK_OFF ? "off" : "on");
 873
 874         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 875                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 876                                  0, NULL, 0, 100);
 877         if (result)
 878                 dbg("%s - error sending break = %d", __func__, result);
 879 }
 880
 881 static void pl2303_shutdown(struct usb_serial *serial)
 882 {
 883         int i;
 884         struct pl2303_private *priv;
 885
 886         dbg("%s", __func__);
 887
 888         for (i = 0; i < serial->num_ports; ++i) {
 889                 priv = usb_get_serial_port_data(serial->port[i]);
 890                 if (priv) {
 891                         pl2303_buf_free(priv->buf);
 892                         kfree(priv);
 893                         usb_set_serial_port_data(serial->port[i], NULL);
 894                 }
 895         }
 896 }
 897
 898 static void pl2303_update_line_status(struct usb_serial_port *port,
 899                                       unsigned char *data,
 900                                       unsigned int actual_length)
 901 {
 902
 903         struct pl2303_private *priv = usb_get_serial_port_data(port);
 904         unsigned long flags;
 905         u8 status_idx = UART_STATE;
 906         u8 length = UART_STATE + 1;
 907         u16 idv, idp;
 908
 909         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 910         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 911
 912
 913         if (idv == SIEMENS_VENDOR_ID) {
 914                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 915                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 916                     idp == SIEMENS_PRODUCT_ID_X75) {
 917
 918                         length = 1;
 919                         status_idx = 0;
 920                 }
 921         }
 922
 923         if (actual_length < length)
 924                 return;
 925
 926         /* Save off the uart status for others to look at */
 927         spin_lock_irqsave(&priv->lock, flags);
 928         priv->line_status = data[status_idx];
 929         spin_unlock_irqrestore(&priv->lock, flags);
 930         wake_up_interruptible(&priv->delta_msr_wait);
 931 }
 932
 933 static void pl2303_read_int_callback(struct urb *urb)
 934 {
 935         struct usb_serial_port *port =  urb->context;
 936         unsigned char *data = urb->transfer_buffer;
 937         unsigned int actual_length = urb->actual_length;
 938         int status = urb->status;
 939         int retval;
 940
 941         dbg("%s (%d)", __func__, port->number);
 942
 943         switch (status) {
 944         case 0:
 945                 /* success */
 946                 break;
 947         case -ECONNRESET:
 948         case -ENOENT:
 949         case -ESHUTDOWN:
 950                 /* this urb is terminated, clean up */
 951                 dbg("%s - urb shutting down with status: %d", __func__,
 952                     status);
 953                 return;
 954         default:
 955                 dbg("%s - nonzero urb status received: %d", __func__,
 956                     status);
 957                 goto exit;
 958         }
 959
 960         usb_serial_debug_data(debug, &port->dev, __func__,
 961                               urb->actual_length, urb->transfer_buffer);
 962
 963         pl2303_update_line_status(port, data, actual_length);
 964
 965 exit:
 966         retval = usb_submit_urb(urb, GFP_ATOMIC);
 967         if (retval)
 968                 dev_err(&urb->dev->dev,
 969                         "%s - usb_submit_urb failed with result %d\n",
 970                         __func__, retval);
 971 }
 972
 973 static void pl2303_read_bulk_callback(struct urb *urb)
 974 {
 975         struct usb_serial_port *port =  urb->context;
 976         struct pl2303_private *priv = usb_get_serial_port_data(port);
 977         struct tty_struct *tty;
 978         unsigned char *data = urb->transfer_buffer;
 979         unsigned long flags;
 980         int i;
 981         int result;
 982         int status = urb->status;
 983         u8 line_status;
 984         char tty_flag;
 985
 986         dbg("%s - port %d", __func__, port->number);
 987
 988         if (status) {
 989                 dbg("%s - urb status = %d", __func__, status);
 990                 if (!port->port.count) {
 991                         dbg("%s - port is closed, exiting.", __func__);
 992                         return;
 993                 }
 994                 if (status == -EPROTO) {
 995                         /* PL2303 mysteriously fails with -EPROTO reschedule
 996                          * the read */
 997                         dbg("%s - caught -EPROTO, resubmitting the urb",
 998                             __func__);
 999                         urb->dev = port->serial->dev;
1000                         result = usb_submit_urb(urb, GFP_ATOMIC);
1001                         if (result)
1002                                 dev_err(&urb->dev->dev, "%s - failed"
1003                                         " resubmitting read urb, error %d\n",
1004                                         __func__, result);
1005                         return;
1006                 }
1007                 dbg("%s - unable to handle the error, exiting.", __func__);
1008                 return;
1009         }
1010
1011         usb_serial_debug_data(debug, &port->dev, __func__,
1012                               urb->actual_length, data);
1013
1014         /* get tty_flag from status */
1015         tty_flag = TTY_NORMAL;
1016
1017         spin_lock_irqsave(&priv->lock, flags);
1018         line_status = priv->line_status;
1019         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1020         spin_unlock_irqrestore(&priv->lock, flags);
1021         wake_up_interruptible(&priv->delta_msr_wait);
1022
1023         /* break takes precedence over parity, */
1024         /* which takes precedence over framing errors */
1025         if (line_status & UART_BREAK_ERROR)
1026                 tty_flag = TTY_BREAK;
1027         else if (line_status & UART_PARITY_ERROR)
1028                 tty_flag = TTY_PARITY;
1029         else if (line_status & UART_FRAME_ERROR)
1030                 tty_flag = TTY_FRAME;
1031         dbg("%s - tty_flag = %d", __func__, tty_flag);
1032
1033         tty = tty_port_tty_get(&port->port);
1034         if (tty && urb->actual_length) {
1035                 tty_buffer_request_room(tty, urb->actual_length + 1);
1036                 /* overrun is special, not associated with a char */
1037                 if (line_status & UART_OVERRUN_ERROR)
1038                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1039                 for (i = 0; i < urb->actual_length; ++i)
1040                         tty_insert_flip_char(tty, data[i], tty_flag);
1041                 tty_flip_buffer_push(tty);
1042         }
1043         tty_kref_put(tty);
1044         /* Schedule the next read _if_ we are still open */
1045         if (port->port.count) {
1046                 urb->dev = port->serial->dev;
1047                 result = usb_submit_urb(urb, GFP_ATOMIC);
1048                 if (result)
1049                         dev_err(&urb->dev->dev, "%s - failed resubmitting"
1050                                 " read urb, error %d\n", __func__, result);
1051         }
1052
1053         return;
1054 }
1055
1056 static void pl2303_write_bulk_callback(struct urb *urb)
1057 {
1058         struct usb_serial_port *port =  urb->context;
1059         struct pl2303_private *priv = usb_get_serial_port_data(port);
1060         int result;
1061         int status = urb->status;
1062
1063         dbg("%s - port %d", __func__, port->number);
1064
1065         switch (status) {
1066         case 0:
1067                 /* success */
1068                 break;
1069         case -ECONNRESET:
1070         case -ENOENT:
1071         case -ESHUTDOWN:
1072                 /* this urb is terminated, clean up */
1073                 dbg("%s - urb shutting down with status: %d", __func__,
1074                     status);
1075                 priv->write_urb_in_use = 0;
1076                 return;
1077         default:
1078                 /* error in the urb, so we have to resubmit it */
1079                 dbg("%s - Overflow in write", __func__);
1080                 dbg("%s - nonzero write bulk status received: %d", __func__,
1081                     status);
1082                 port->write_urb->transfer_buffer_length = 1;
1083                 port->write_urb->dev = port->serial->dev;
1084                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1085                 if (result)
1086                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1087                                 " urb, error %d\n", __func__, result);
1088                 else
1089                         return;
1090         }
1091
1092         priv->write_urb_in_use = 0;
1093
1094         /* send any buffered data */
1095         pl2303_send(port);
1096 }
1097
1098 /* All of the device info needed for the PL2303 SIO serial converter */
1099 static struct usb_serial_driver pl2303_device = {
1100         .driver = {
1101                 .owner =        THIS_MODULE,
1102                 .name =         "pl2303",
1103         },
1104         .id_table =             id_table,
1105         .usb_driver =           &pl2303_driver,
1106         .num_ports =            1,
1107         .open =                 pl2303_open,
1108         .close =                pl2303_close,
1109         .dtr_rts =              pl2303_dtr_rts,
1110         .carrier_raised =       pl2303_carrier_raised,
1111         .write =                pl2303_write,
1112         .ioctl =                pl2303_ioctl,
1113         .break_ctl =            pl2303_break_ctl,
1114         .set_termios =          pl2303_set_termios,
1115         .tiocmget =             pl2303_tiocmget,
1116         .tiocmset =             pl2303_tiocmset,
1117         .read_bulk_callback =   pl2303_read_bulk_callback,
1118         .read_int_callback =    pl2303_read_int_callback,
1119         .write_bulk_callback =  pl2303_write_bulk_callback,
1120         .write_room =           pl2303_write_room,
1121         .chars_in_buffer =      pl2303_chars_in_buffer,
1122         .attach =               pl2303_startup,
1123         .shutdown =             pl2303_shutdown,
1124 };
1125
1126 static int __init pl2303_init(void)
1127 {
1128         int retval;
1129
1130         retval = usb_serial_register(&pl2303_device);
1131         if (retval)
1132                 goto failed_usb_serial_register;
1133         retval = usb_register(&pl2303_driver);
1134         if (retval)
1135                 goto failed_usb_register;
1136         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1137         return 0;
1138 failed_usb_register:
1139         usb_serial_deregister(&pl2303_device);
1140 failed_usb_serial_register:
1141         return retval;
1142 }
1143
1144 static void __exit pl2303_exit(void)
1145 {
1146         usb_deregister(&pl2303_driver);
1147         usb_serial_deregister(&pl2303_device);
1148 }
1149
1150 module_init(pl2303_init);
1151 module_exit(pl2303_exit);
1152
1153 MODULE_DESCRIPTION(DRIVER_DESC);
1154 MODULE_LICENSE("GPL");
1155
1156 module_param(debug, bool, S_IRUGO | S_IWUSR);
1157 MODULE_PARM_DESC(debug, "Debug enabled or not");
1158