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