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