drivers/usb/serial/pl2303.c

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