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(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  94         { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  95         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  96         { }                                     /* Terminating entry */
  97 };
  98
  99 MODULE_DEVICE_TABLE(usb, id_table);
 100
 101 static struct usb_driver pl2303_driver = {
 102         .name =         "pl2303",
 103         .probe =        usb_serial_probe,
 104         .disconnect =   usb_serial_disconnect,
 105         .id_table =     id_table,
 106         .suspend =      usb_serial_suspend,
 107         .resume =       usb_serial_resume,
 108         .no_dynamic_id =        1,
 109         .supports_autosuspend = 1,
 110 };
 111
 112 #define SET_LINE_REQUEST_TYPE           0x21
 113 #define SET_LINE_REQUEST                0x20
 114
 115 #define SET_CONTROL_REQUEST_TYPE        0x21
 116 #define SET_CONTROL_REQUEST             0x22
 117 #define CONTROL_DTR                     0x01
 118 #define CONTROL_RTS                     0x02
 119
 120 #define BREAK_REQUEST_TYPE              0x21
 121 #define BREAK_REQUEST                   0x23
 122 #define BREAK_ON                        0xffff
 123 #define BREAK_OFF                       0x0000
 124
 125 #define GET_LINE_REQUEST_TYPE           0xa1
 126 #define GET_LINE_REQUEST                0x21
 127
 128 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 129 #define VENDOR_WRITE_REQUEST            0x01
 130
 131 #define VENDOR_READ_REQUEST_TYPE        0xc0
 132 #define VENDOR_READ_REQUEST             0x01
 133
 134 #define UART_STATE                      0x08
 135 #define UART_STATE_TRANSIENT_MASK       0x74
 136 #define UART_DCD                        0x01
 137 #define UART_DSR                        0x02
 138 #define UART_BREAK_ERROR                0x04
 139 #define UART_RING                       0x08
 140 #define UART_FRAME_ERROR                0x10
 141 #define UART_PARITY_ERROR               0x20
 142 #define UART_OVERRUN_ERROR              0x40
 143 #define UART_CTS                        0x80
 144
 145
 146 enum pl2303_type {
 147         type_0,         /* don't know the difference between type 0 and */
 148         type_1,         /* type 1, until someone from prolific tells us... */
 149         HX,             /* HX version of the pl2303 chip */
 150 };
 151
 152 struct pl2303_private {
 153         spinlock_t lock;
 154         struct pl2303_buf *buf;
 155         int write_urb_in_use;
 156         wait_queue_head_t delta_msr_wait;
 157         u8 line_control;
 158         u8 line_status;
 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         /* The PL2303 is reported to lose bytes if you change
 531            serial settings even to the same values as before. Thus
 532            we actually need to filter in this specific case */
 533
 534         if (!tty_termios_hw_change(tty->termios, old_termios))
 535                 return;
 536
 537         cflag = tty->termios->c_cflag;
 538
 539         buf = kzalloc(7, GFP_KERNEL);
 540         if (!buf) {
 541                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 542                 /* Report back no change occurred */
 543                 *tty->termios = *old_termios;
 544                 return;
 545         }
 546
 547         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 548                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 549                             0, 0, buf, 7, 100);
 550         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 551             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 552
 553         if (cflag & CSIZE) {
 554                 switch (cflag & CSIZE) {
 555                 case CS5:
 556                         buf[6] = 5;
 557                         break;
 558                 case CS6:
 559                         buf[6] = 6;
 560                         break;
 561                 case CS7:
 562                         buf[6] = 7;
 563                         break;
 564                 default:
 565                 case CS8:
 566                         buf[6] = 8;
 567                         break;
 568                 }
 569                 dbg("%s - data bits = %d", __func__, buf[6]);
 570         }
 571
 572         baud = tty_get_baud_rate(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(tty, baud, baud);
 650
 651         kfree(buf);
 652 }
 653
 654 static void pl2303_close(struct tty_struct *tty,
 655                         struct usb_serial_port *port, struct file *filp)
 656 {
 657         struct pl2303_private *priv = usb_get_serial_port_data(port);
 658         unsigned long flags;
 659         unsigned int c_cflag;
 660         int bps;
 661         long timeout;
 662         wait_queue_t wait;
 663
 664         dbg("%s - port %d", __func__, port->number);
 665
 666         /* wait for data to drain from the buffer */
 667         spin_lock_irqsave(&priv->lock, flags);
 668         timeout = PL2303_CLOSING_WAIT;
 669         init_waitqueue_entry(&wait, current);
 670         add_wait_queue(&tty->write_wait, &wait);
 671         for (;;) {
 672                 set_current_state(TASK_INTERRUPTIBLE);
 673                 if (pl2303_buf_data_avail(priv->buf) == 0 ||
 674                     timeout == 0 || signal_pending(current) ||
 675                     port->serial->disconnected)
 676                         break;
 677                 spin_unlock_irqrestore(&priv->lock, flags);
 678                 timeout = schedule_timeout(timeout);
 679                 spin_lock_irqsave(&priv->lock, flags);
 680         }
 681         set_current_state(TASK_RUNNING);
 682         remove_wait_queue(&tty->write_wait, &wait);
 683         /* clear out any remaining data in the buffer */
 684         pl2303_buf_clear(priv->buf);
 685         spin_unlock_irqrestore(&priv->lock, flags);
 686
 687         /* wait for characters to drain from the device */
 688         /* (this is long enough for the entire 256 byte */
 689         /* pl2303 hardware buffer to drain with no flow */
 690         /* control for data rates of 1200 bps or more, */
 691         /* for lower rates we should really know how much */
 692         /* data is in the buffer to compute a delay */
 693         /* that is not unnecessarily long) */
 694         bps = tty_get_baud_rate(tty);
 695         if (bps > 1200)
 696                 timeout = max((HZ*2560)/bps, HZ/10);
 697         else
 698                 timeout = 2*HZ;
 699         schedule_timeout_interruptible(timeout);
 700
 701         /* shutdown our urbs */
 702         dbg("%s - shutting down urbs", __func__);
 703         usb_kill_urb(port->write_urb);
 704         usb_kill_urb(port->read_urb);
 705         usb_kill_urb(port->interrupt_in_urb);
 706
 707         if (tty) {
 708                 c_cflag = tty->termios->c_cflag;
 709                 if (c_cflag & HUPCL) {
 710                         /* drop DTR and RTS */
 711                         spin_lock_irqsave(&priv->lock, flags);
 712                         priv->line_control = 0;
 713                         spin_unlock_irqrestore(&priv->lock, flags);
 714                         set_control_lines(port->serial->dev, 0);
 715                 }
 716         }
 717 }
 718
 719 static int pl2303_open(struct tty_struct *tty,
 720                         struct usb_serial_port *port, struct file *filp)
 721 {
 722         struct ktermios tmp_termios;
 723         struct usb_serial *serial = port->serial;
 724         struct pl2303_private *priv = usb_get_serial_port_data(port);
 725         int result;
 726
 727         dbg("%s -  port %d", __func__, port->number);
 728
 729         if (priv->type != HX) {
 730                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 731                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 732         } else {
 733                 /* reset upstream data pipes */
 734                 pl2303_vendor_write(8, 0, serial);
 735                 pl2303_vendor_write(9, 0, serial);
 736         }
 737
 738         /* Setup termios */
 739         if (tty)
 740                 pl2303_set_termios(tty, port, &tmp_termios);
 741
 742         /* FIXME: need to assert RTS and DTR if CRTSCTS off */
 743
 744         dbg("%s - submitting read urb", __func__);
 745         port->read_urb->dev = serial->dev;
 746         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 747         if (result) {
 748                 dev_err(&port->dev, "%s - failed submitting read urb,"
 749                         " error %d\n", __func__, result);
 750                 pl2303_close(tty, port, NULL);
 751                 return -EPROTO;
 752         }
 753
 754         dbg("%s - submitting interrupt urb", __func__);
 755         port->interrupt_in_urb->dev = serial->dev;
 756         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 757         if (result) {
 758                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 759                         " error %d\n", __func__, result);
 760                 pl2303_close(tty, port, NULL);
 761                 return -EPROTO;
 762         }
 763         return 0;
 764 }
 765
 766 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 767                            unsigned int set, unsigned int clear)
 768 {
 769         struct usb_serial_port *port = tty->driver_data;
 770         struct pl2303_private *priv = usb_get_serial_port_data(port);
 771         unsigned long flags;
 772         u8 control;
 773
 774         if (!usb_get_intfdata(port->serial->interface))
 775                 return -ENODEV;
 776
 777         spin_lock_irqsave(&priv->lock, flags);
 778         if (set & TIOCM_RTS)
 779                 priv->line_control |= CONTROL_RTS;
 780         if (set & TIOCM_DTR)
 781                 priv->line_control |= CONTROL_DTR;
 782         if (clear & TIOCM_RTS)
 783                 priv->line_control &= ~CONTROL_RTS;
 784         if (clear & TIOCM_DTR)
 785                 priv->line_control &= ~CONTROL_DTR;
 786         control = priv->line_control;
 787         spin_unlock_irqrestore(&priv->lock, flags);
 788
 789         return set_control_lines(port->serial->dev, control);
 790 }
 791
 792 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 793 {
 794         struct usb_serial_port *port = tty->driver_data;
 795         struct pl2303_private *priv = usb_get_serial_port_data(port);
 796         unsigned long flags;
 797         unsigned int mcr;
 798         unsigned int status;
 799         unsigned int result;
 800
 801         dbg("%s (%d)", __func__, port->number);
 802
 803         if (!usb_get_intfdata(port->serial->interface))
 804                 return -ENODEV;
 805
 806         spin_lock_irqsave(&priv->lock, flags);
 807         mcr = priv->line_control;
 808         status = priv->line_status;
 809         spin_unlock_irqrestore(&priv->lock, flags);
 810
 811         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 812                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 813                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 814                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 815                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 816                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 817
 818         dbg("%s - result = %x", __func__, result);
 819
 820         return result;
 821 }
 822
 823 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 824 {
 825         struct pl2303_private *priv = usb_get_serial_port_data(port);
 826         unsigned long flags;
 827         unsigned int prevstatus;
 828         unsigned int status;
 829         unsigned int changed;
 830
 831         spin_lock_irqsave(&priv->lock, flags);
 832         prevstatus = priv->line_status;
 833         spin_unlock_irqrestore(&priv->lock, flags);
 834
 835         while (1) {
 836                 interruptible_sleep_on(&priv->delta_msr_wait);
 837                 /* see if a signal did it */
 838                 if (signal_pending(current))
 839                         return -ERESTARTSYS;
 840
 841                 spin_lock_irqsave(&priv->lock, flags);
 842                 status = priv->line_status;
 843                 spin_unlock_irqrestore(&priv->lock, flags);
 844
 845                 changed = prevstatus ^ status;
 846
 847                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 848                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 849                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 850                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 851                         return 0;
 852                 }
 853                 prevstatus = status;
 854         }
 855         /* NOTREACHED */
 856         return 0;
 857 }
 858
 859 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 860                         unsigned int cmd, unsigned long arg)
 861 {
 862         struct usb_serial_port *port = tty->driver_data;
 863         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 864
 865         switch (cmd) {
 866         case TIOCMIWAIT:
 867                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 868                 return wait_modem_info(port, arg);
 869         default:
 870                 dbg("%s not supported = 0x%04x", __func__, cmd);
 871                 break;
 872         }
 873         return -ENOIOCTLCMD;
 874 }
 875
 876 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 877 {
 878         struct usb_serial_port *port = tty->driver_data;
 879         struct usb_serial *serial = port->serial;
 880         u16 state;
 881         int result;
 882
 883         dbg("%s - port %d", __func__, port->number);
 884
 885         if (break_state == 0)
 886                 state = BREAK_OFF;
 887         else
 888                 state = BREAK_ON;
 889         dbg("%s - turning break %s", __func__,
 890                         state == BREAK_OFF ? "off" : "on");
 891
 892         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 893                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 894                                  0, NULL, 0, 100);
 895         if (result)
 896                 dbg("%s - error sending break = %d", __func__, result);
 897 }
 898
 899 static void pl2303_shutdown(struct usb_serial *serial)
 900 {
 901         int i;
 902         struct pl2303_private *priv;
 903
 904         dbg("%s", __func__);
 905
 906         for (i = 0; i < serial->num_ports; ++i) {
 907                 priv = usb_get_serial_port_data(serial->port[i]);
 908                 if (priv) {
 909                         pl2303_buf_free(priv->buf);
 910                         kfree(priv);
 911                         usb_set_serial_port_data(serial->port[i], NULL);
 912                 }
 913         }
 914 }
 915
 916 static void pl2303_update_line_status(struct usb_serial_port *port,
 917                                       unsigned char *data,
 918                                       unsigned int actual_length)
 919 {
 920
 921         struct pl2303_private *priv = usb_get_serial_port_data(port);
 922         unsigned long flags;
 923         u8 status_idx = UART_STATE;
 924         u8 length = UART_STATE + 1;
 925         u16 idv, idp;
 926
 927         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 928         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 929
 930
 931         if (idv == SIEMENS_VENDOR_ID) {
 932                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 933                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 934                     idp == SIEMENS_PRODUCT_ID_X75) {
 935
 936                         length = 1;
 937                         status_idx = 0;
 938                 }
 939         }
 940
 941         if (actual_length < length)
 942                 return;
 943
 944         /* Save off the uart status for others to look at */
 945         spin_lock_irqsave(&priv->lock, flags);
 946         priv->line_status = data[status_idx];
 947         spin_unlock_irqrestore(&priv->lock, flags);
 948         wake_up_interruptible(&priv->delta_msr_wait);
 949 }
 950
 951 static void pl2303_read_int_callback(struct urb *urb)
 952 {
 953         struct usb_serial_port *port =  urb->context;
 954         unsigned char *data = urb->transfer_buffer;
 955         unsigned int actual_length = urb->actual_length;
 956         int status = urb->status;
 957         int retval;
 958
 959         dbg("%s (%d)", __func__, port->number);
 960
 961         switch (status) {
 962         case 0:
 963                 /* success */
 964                 break;
 965         case -ECONNRESET:
 966         case -ENOENT:
 967         case -ESHUTDOWN:
 968                 /* this urb is terminated, clean up */
 969                 dbg("%s - urb shutting down with status: %d", __func__,
 970                     status);
 971                 return;
 972         default:
 973                 dbg("%s - nonzero urb status received: %d", __func__,
 974                     status);
 975                 goto exit;
 976         }
 977
 978         usb_serial_debug_data(debug, &port->dev, __func__,
 979                               urb->actual_length, urb->transfer_buffer);
 980
 981         pl2303_update_line_status(port, data, actual_length);
 982
 983 exit:
 984         retval = usb_submit_urb(urb, GFP_ATOMIC);
 985         if (retval)
 986                 dev_err(&urb->dev->dev,
 987                         "%s - usb_submit_urb failed with result %d\n",
 988                         __func__, retval);
 989 }
 990
 991 static void pl2303_read_bulk_callback(struct urb *urb)
 992 {
 993         struct usb_serial_port *port =  urb->context;
 994         struct pl2303_private *priv = usb_get_serial_port_data(port);
 995         struct tty_struct *tty;
 996         unsigned char *data = urb->transfer_buffer;
 997         unsigned long flags;
 998         int i;
 999         int result;
1000         int status = urb->status;
1001         u8 line_status;
1002         char tty_flag;
1003
1004         dbg("%s - port %d", __func__, port->number);
1005
1006         if (status) {
1007                 dbg("%s - urb status = %d", __func__, status);
1008                 if (!port->port.count) {
1009                         dbg("%s - port is closed, exiting.", __func__);
1010                         return;
1011                 }
1012                 if (status == -EPROTO) {
1013                         /* PL2303 mysteriously fails with -EPROTO reschedule
1014                          * the read */
1015                         dbg("%s - caught -EPROTO, resubmitting the urb",
1016                             __func__);
1017                         urb->dev = port->serial->dev;
1018                         result = usb_submit_urb(urb, GFP_ATOMIC);
1019                         if (result)
1020                                 dev_err(&urb->dev->dev, "%s - failed"
1021                                         " resubmitting read urb, error %d\n",
1022                                         __func__, result);
1023                         return;
1024                 }
1025                 dbg("%s - unable to handle the error, exiting.", __func__);
1026                 return;
1027         }
1028
1029         usb_serial_debug_data(debug, &port->dev, __func__,
1030                               urb->actual_length, data);
1031
1032         /* get tty_flag from status */
1033         tty_flag = TTY_NORMAL;
1034
1035         spin_lock_irqsave(&priv->lock, flags);
1036         line_status = priv->line_status;
1037         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1038         spin_unlock_irqrestore(&priv->lock, flags);
1039         wake_up_interruptible(&priv->delta_msr_wait);
1040
1041         /* break takes precedence over parity, */
1042         /* which takes precedence over framing errors */
1043         if (line_status & UART_BREAK_ERROR)
1044                 tty_flag = TTY_BREAK;
1045         else if (line_status & UART_PARITY_ERROR)
1046                 tty_flag = TTY_PARITY;
1047         else if (line_status & UART_FRAME_ERROR)
1048                 tty_flag = TTY_FRAME;
1049         dbg("%s - tty_flag = %d", __func__, tty_flag);
1050
1051         tty = tty_port_tty_get(&port->port);
1052         if (tty && urb->actual_length) {
1053                 tty_buffer_request_room(tty, urb->actual_length + 1);
1054                 /* overrun is special, not associated with a char */
1055                 if (line_status & UART_OVERRUN_ERROR)
1056                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1057                 for (i = 0; i < urb->actual_length; ++i)
1058                         tty_insert_flip_char(tty, data[i], tty_flag);
1059                 tty_flip_buffer_push(tty);
1060         }
1061         tty_kref_put(tty);
1062         /* Schedule the next read _if_ we are still open */
1063         if (port->port.count) {
1064                 urb->dev = port->serial->dev;
1065                 result = usb_submit_urb(urb, GFP_ATOMIC);
1066                 if (result)
1067                         dev_err(&urb->dev->dev, "%s - failed resubmitting"
1068                                 " read urb, error %d\n", __func__, result);
1069         }
1070
1071         return;
1072 }
1073
1074 static void pl2303_write_bulk_callback(struct urb *urb)
1075 {
1076         struct usb_serial_port *port =  urb->context;
1077         struct pl2303_private *priv = usb_get_serial_port_data(port);
1078         int result;
1079         int status = urb->status;
1080
1081         dbg("%s - port %d", __func__, port->number);
1082
1083         switch (status) {
1084         case 0:
1085                 /* success */
1086                 break;
1087         case -ECONNRESET:
1088         case -ENOENT:
1089         case -ESHUTDOWN:
1090                 /* this urb is terminated, clean up */
1091                 dbg("%s - urb shutting down with status: %d", __func__,
1092                     status);
1093                 priv->write_urb_in_use = 0;
1094                 return;
1095         default:
1096                 /* error in the urb, so we have to resubmit it */
1097                 dbg("%s - Overflow in write", __func__);
1098                 dbg("%s - nonzero write bulk status received: %d", __func__,
1099                     status);
1100                 port->write_urb->transfer_buffer_length = 1;
1101                 port->write_urb->dev = port->serial->dev;
1102                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1103                 if (result)
1104                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1105                                 " urb, error %d\n", __func__, result);
1106                 else
1107                         return;
1108         }
1109
1110         priv->write_urb_in_use = 0;
1111
1112         /* send any buffered data */
1113         pl2303_send(port);
1114 }
1115
1116 /* All of the device info needed for the PL2303 SIO serial converter */
1117 static struct usb_serial_driver pl2303_device = {
1118         .driver = {
1119                 .owner =        THIS_MODULE,
1120                 .name =         "pl2303",
1121         },
1122         .id_table =             id_table,
1123         .usb_driver =           &pl2303_driver,
1124         .num_ports =            1,
1125         .open =                 pl2303_open,
1126         .close =                pl2303_close,
1127         .write =                pl2303_write,
1128         .ioctl =                pl2303_ioctl,
1129         .break_ctl =            pl2303_break_ctl,
1130         .set_termios =          pl2303_set_termios,
1131         .tiocmget =             pl2303_tiocmget,
1132         .tiocmset =             pl2303_tiocmset,
1133         .read_bulk_callback =   pl2303_read_bulk_callback,
1134         .read_int_callback =    pl2303_read_int_callback,
1135         .write_bulk_callback =  pl2303_write_bulk_callback,
1136         .write_room =           pl2303_write_room,
1137         .chars_in_buffer =      pl2303_chars_in_buffer,
1138         .attach =               pl2303_startup,
1139         .shutdown =             pl2303_shutdown,
1140 };
1141
1142 static int __init pl2303_init(void)
1143 {
1144         int retval;
1145
1146         retval = usb_serial_register(&pl2303_device);
1147         if (retval)
1148                 goto failed_usb_serial_register;
1149         retval = usb_register(&pl2303_driver);
1150         if (retval)
1151                 goto failed_usb_register;
1152         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1153         return 0;
1154 failed_usb_register:
1155         usb_serial_deregister(&pl2303_device);
1156 failed_usb_serial_register:
1157         return retval;
1158 }
1159
1160 static void __exit pl2303_exit(void)
1161 {
1162         usb_deregister(&pl2303_driver);
1163         usb_serial_deregister(&pl2303_device);
1164 }
1165
1166 module_init(pl2303_init);
1167 module_exit(pl2303_exit);
1168
1169 MODULE_DESCRIPTION(DRIVER_DESC);
1170 MODULE_LICENSE("GPL");
1171
1172 module_param(debug, bool, S_IRUGO | S_IWUSR);
1173 MODULE_PARM_DESC(debug, "Debug enabled or not");
1174