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