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 const struct usb_device_id id_table[] = {
  40         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
  41         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  42         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  43         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  44         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  45         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
  46         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
  47         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
  48         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
  49         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
  50         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  51         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  52         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
  53         { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  54         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  55         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  56         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  57         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  58         { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  59         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  60         { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  61         { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  62         { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  63         { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  64         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  65         { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
  66         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
  67         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
  68         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
  69         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
  70         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
  71         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  72         { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  73         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  74         { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  75         { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  76         { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  77         { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  78         { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  79         { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
  80         { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  81         { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  82         { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  83         { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  84         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  85         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
  86         { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
  87         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
  88         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
  89         { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
  90         { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
  91         { }                                     /* Terminating entry */
  92 };
  93
  94 MODULE_DEVICE_TABLE(usb, id_table);
  95
  96 #define SET_LINE_REQUEST_TYPE           0x21
  97 #define SET_LINE_REQUEST                0x20
  98
  99 #define SET_CONTROL_REQUEST_TYPE        0x21
 100 #define SET_CONTROL_REQUEST             0x22
 101 #define CONTROL_DTR                     0x01
 102 #define CONTROL_RTS                     0x02
 103
 104 #define BREAK_REQUEST_TYPE              0x21
 105 #define BREAK_REQUEST                   0x23
 106 #define BREAK_ON                        0xffff
 107 #define BREAK_OFF                       0x0000
 108
 109 #define GET_LINE_REQUEST_TYPE           0xa1
 110 #define GET_LINE_REQUEST                0x21
 111
 112 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 113 #define VENDOR_WRITE_REQUEST            0x01
 114
 115 #define VENDOR_READ_REQUEST_TYPE        0xc0
 116 #define VENDOR_READ_REQUEST             0x01
 117
 118 #define UART_STATE                      0x08
 119 #define UART_STATE_TRANSIENT_MASK       0x74
 120 #define UART_DCD                        0x01
 121 #define UART_DSR                        0x02
 122 #define UART_BREAK_ERROR                0x04
 123 #define UART_RING                       0x08
 124 #define UART_FRAME_ERROR                0x10
 125 #define UART_PARITY_ERROR               0x20
 126 #define UART_OVERRUN_ERROR              0x40
 127 #define UART_CTS                        0x80
 128
 129
 130 enum pl2303_type {
 131         type_0,         /* don't know the difference between type 0 and */
 132         type_1,         /* type 1, until someone from prolific tells us... */
 133         HX,             /* HX version of the pl2303 chip */
 134 };
 135
 136 struct pl2303_serial_private {
 137         enum pl2303_type type;
 138 };
 139
 140 struct pl2303_private {
 141         spinlock_t lock;
 142         u8 line_control;
 143         u8 line_status;
 144 };
 145
 146 static int pl2303_vendor_read(__u16 value, __u16 index,
 147                 struct usb_serial *serial, unsigned char *buf)
 148 {
 149         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 150                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 151                         value, index, buf, 1, 100);
 152         dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x  %d - %x\n",
 153                 VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
 154                 res, buf[0]);
 155         return res;
 156 }
 157
 158 static int pl2303_vendor_write(__u16 value, __u16 index,
 159                 struct usb_serial *serial)
 160 {
 161         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 162                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 163                         value, index, NULL, 0, 100);
 164         dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x  %d\n",
 165                 VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
 166                 res);
 167         return res;
 168 }
 169
 170 static int pl2303_startup(struct usb_serial *serial)
 171 {
 172         struct pl2303_serial_private *spriv;
 173         enum pl2303_type type = type_0;
 174         unsigned char *buf;
 175
 176         spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
 177         if (!spriv)
 178                 return -ENOMEM;
 179
 180         buf = kmalloc(10, GFP_KERNEL);
 181         if (!buf) {
 182                 kfree(spriv);
 183                 return -ENOMEM;
 184         }
 185
 186         if (serial->dev->descriptor.bDeviceClass == 0x02)
 187                 type = type_0;
 188         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 189                 type = HX;
 190         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 191                 type = type_1;
 192         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 193                 type = type_1;
 194         dev_dbg(&serial->interface->dev, "device type: %d\n", type);
 195
 196         spriv->type = type;
 197         usb_set_serial_data(serial, spriv);
 198
 199         pl2303_vendor_read(0x8484, 0, serial, buf);
 200         pl2303_vendor_write(0x0404, 0, serial);
 201         pl2303_vendor_read(0x8484, 0, serial, buf);
 202         pl2303_vendor_read(0x8383, 0, serial, buf);
 203         pl2303_vendor_read(0x8484, 0, serial, buf);
 204         pl2303_vendor_write(0x0404, 1, serial);
 205         pl2303_vendor_read(0x8484, 0, serial, buf);
 206         pl2303_vendor_read(0x8383, 0, serial, buf);
 207         pl2303_vendor_write(0, 1, serial);
 208         pl2303_vendor_write(1, 0, serial);
 209         if (type == HX)
 210                 pl2303_vendor_write(2, 0x44, serial);
 211         else
 212                 pl2303_vendor_write(2, 0x24, serial);
 213
 214         kfree(buf);
 215         return 0;
 216 }
 217
 218 static void pl2303_release(struct usb_serial *serial)
 219 {
 220         struct pl2303_serial_private *spriv;
 221
 222         spriv = usb_get_serial_data(serial);
 223         kfree(spriv);
 224 }
 225
 226 static int pl2303_port_probe(struct usb_serial_port *port)
 227 {
 228         struct pl2303_private *priv;
 229
 230         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 231         if (!priv)
 232                 return -ENOMEM;
 233
 234         spin_lock_init(&priv->lock);
 235
 236         usb_set_serial_port_data(port, priv);
 237
 238         return 0;
 239 }
 240
 241 static int pl2303_port_remove(struct usb_serial_port *port)
 242 {
 243         struct pl2303_private *priv;
 244
 245         priv = usb_get_serial_port_data(port);
 246         kfree(priv);
 247
 248         return 0;
 249 }
 250
 251 static int set_control_lines(struct usb_device *dev, u8 value)
 252 {
 253         int retval;
 254
 255         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 256                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 257                                  value, 0, NULL, 0, 100);
 258         dev_dbg(&dev->dev, "%s - value = %d, retval = %d\n", __func__,
 259                 value, retval);
 260         return retval;
 261 }
 262
 263 static void pl2303_set_termios(struct tty_struct *tty,
 264                 struct usb_serial_port *port, struct ktermios *old_termios)
 265 {
 266         struct usb_serial *serial = port->serial;
 267         struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
 268         struct pl2303_private *priv = usb_get_serial_port_data(port);
 269         unsigned long flags;
 270         unsigned int cflag;
 271         unsigned char *buf;
 272         int baud;
 273         int i;
 274         u8 control;
 275         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
 276                                  4800, 7200, 9600, 14400, 19200, 28800, 38400,
 277                                  57600, 115200, 230400, 460800, 614400,
 278                                  921600, 1228800, 2457600, 3000000, 6000000 };
 279         int baud_floor, baud_ceil;
 280         int k;
 281
 282         /* The PL2303 is reported to lose bytes if you change
 283            serial settings even to the same values as before. Thus
 284            we actually need to filter in this specific case */
 285
 286         if (!tty_termios_hw_change(&tty->termios, old_termios))
 287                 return;
 288
 289         cflag = tty->termios.c_cflag;
 290
 291         buf = kzalloc(7, GFP_KERNEL);
 292         if (!buf) {
 293                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 294                 /* Report back no change occurred */
 295                 tty->termios = *old_termios;
 296                 return;
 297         }
 298
 299         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 300                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 301                             0, 0, buf, 7, 100);
 302         dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x\n", i,
 303             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 304
 305         if (cflag & CSIZE) {
 306                 switch (cflag & CSIZE) {
 307                 case CS5:
 308                         buf[6] = 5;
 309                         break;
 310                 case CS6:
 311                         buf[6] = 6;
 312                         break;
 313                 case CS7:
 314                         buf[6] = 7;
 315                         break;
 316                 default:
 317                 case CS8:
 318                         buf[6] = 8;
 319                         break;
 320                 }
 321                 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
 322         }
 323
 324         /* For reference buf[0]:buf[3] baud rate value */
 325         /* NOTE: Only the values defined in baud_sup are supported !
 326          *       => if unsupported values are set, the PL2303 seems to use
 327          *          9600 baud (at least my PL2303X always does)
 328          */
 329         baud = tty_get_baud_rate(tty);
 330         dev_dbg(&port->dev, "baud requested = %d\n", baud);
 331         if (baud) {
 332                 /* Set baudrate to nearest supported value */
 333                 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
 334                         if (baud_sup[k] / baud) {
 335                                 baud_ceil = baud_sup[k];
 336                                 if (k==0) {
 337                                         baud = baud_ceil;
 338                                 } else {
 339                                         baud_floor = baud_sup[k-1];
 340                                         if ((baud_ceil % baud)
 341                                             > (baud % baud_floor))
 342                                                 baud = baud_floor;
 343                                         else
 344                                                 baud = baud_ceil;
 345                                 }
 346                                 break;
 347                         }
 348                 }
 349                 if (baud > 1228800) {
 350                         /* type_0, type_1 only support up to 1228800 baud */
 351                         if (spriv->type != HX)
 352                                 baud = 1228800;
 353                         else if (baud > 6000000)
 354                                 baud = 6000000;
 355                 }
 356                 dev_dbg(&port->dev, "baud set = %d\n", baud);
 357                 if (baud <= 115200) {
 358                         buf[0] = baud & 0xff;
 359                         buf[1] = (baud >> 8) & 0xff;
 360                         buf[2] = (baud >> 16) & 0xff;
 361                         buf[3] = (baud >> 24) & 0xff;
 362                 } else {
 363                         /* apparently the formula for higher speeds is:
 364                          * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
 365                          */
 366                         unsigned tmp = 12*1000*1000*32 / baud;
 367                         buf[3] = 0x80;
 368                         buf[2] = 0;
 369                         buf[1] = (tmp >= 256);
 370                         while (tmp >= 256) {
 371                                 tmp >>= 2;
 372                                 buf[1] <<= 1;
 373                         }
 374                         buf[0] = tmp;
 375                 }
 376         }
 377
 378         /* For reference buf[4]=0 is 1 stop bits */
 379         /* For reference buf[4]=1 is 1.5 stop bits */
 380         /* For reference buf[4]=2 is 2 stop bits */
 381         if (cflag & CSTOPB) {
 382                 /* NOTE: Comply with "real" UARTs / RS232:
 383                  *       use 1.5 instead of 2 stop bits with 5 data bits
 384                  */
 385                 if ((cflag & CSIZE) == CS5) {
 386                         buf[4] = 1;
 387                         dev_dbg(&port->dev, "stop bits = 1.5\n");
 388                 } else {
 389                         buf[4] = 2;
 390                         dev_dbg(&port->dev, "stop bits = 2\n");
 391                 }
 392         } else {
 393                 buf[4] = 0;
 394                 dev_dbg(&port->dev, "stop bits = 1\n");
 395         }
 396
 397         if (cflag & PARENB) {
 398                 /* For reference buf[5]=0 is none parity */
 399                 /* For reference buf[5]=1 is odd parity */
 400                 /* For reference buf[5]=2 is even parity */
 401                 /* For reference buf[5]=3 is mark parity */
 402                 /* For reference buf[5]=4 is space parity */
 403                 if (cflag & PARODD) {
 404                         if (cflag & CMSPAR) {
 405                                 buf[5] = 3;
 406                                 dev_dbg(&port->dev, "parity = mark\n");
 407                         } else {
 408                                 buf[5] = 1;
 409                                 dev_dbg(&port->dev, "parity = odd\n");
 410                         }
 411                 } else {
 412                         if (cflag & CMSPAR) {
 413                                 buf[5] = 4;
 414                                 dev_dbg(&port->dev, "parity = space\n");
 415                         } else {
 416                                 buf[5] = 2;
 417                                 dev_dbg(&port->dev, "parity = even\n");
 418                         }
 419                 }
 420         } else {
 421                 buf[5] = 0;
 422                 dev_dbg(&port->dev, "parity = none\n");
 423         }
 424
 425         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 426                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 427                             0, 0, buf, 7, 100);
 428         dev_dbg(&port->dev, "0x21:0x20:0:0  %d\n", i);
 429
 430         /* change control lines if we are switching to or from B0 */
 431         spin_lock_irqsave(&priv->lock, flags);
 432         control = priv->line_control;
 433         if ((cflag & CBAUD) == B0)
 434                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 435         else if ((old_termios->c_cflag & CBAUD) == B0)
 436                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 437         if (control != priv->line_control) {
 438                 control = priv->line_control;
 439                 spin_unlock_irqrestore(&priv->lock, flags);
 440                 set_control_lines(serial->dev, control);
 441         } else {
 442                 spin_unlock_irqrestore(&priv->lock, flags);
 443         }
 444
 445         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 446
 447         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 448                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 449                             0, 0, buf, 7, 100);
 450         dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x\n", i,
 451              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 452
 453         if (cflag & CRTSCTS) {
 454                 if (spriv->type == HX)
 455                         pl2303_vendor_write(0x0, 0x61, serial);
 456                 else
 457                         pl2303_vendor_write(0x0, 0x41, serial);
 458         } else {
 459                 pl2303_vendor_write(0x0, 0x0, serial);
 460         }
 461
 462         /* Save resulting baud rate */
 463         if (baud)
 464                 tty_encode_baud_rate(tty, baud, baud);
 465
 466         kfree(buf);
 467 }
 468
 469 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 470 {
 471         struct pl2303_private *priv = usb_get_serial_port_data(port);
 472         unsigned long flags;
 473         u8 control;
 474
 475         spin_lock_irqsave(&priv->lock, flags);
 476         /* Change DTR and RTS */
 477         if (on)
 478                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 479         else
 480                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 481         control = priv->line_control;
 482         spin_unlock_irqrestore(&priv->lock, flags);
 483         set_control_lines(port->serial->dev, control);
 484 }
 485
 486 static void pl2303_close(struct usb_serial_port *port)
 487 {
 488         usb_serial_generic_close(port);
 489         usb_kill_urb(port->interrupt_in_urb);
 490 }
 491
 492 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 493 {
 494         struct ktermios tmp_termios;
 495         struct usb_serial *serial = port->serial;
 496         struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
 497         int result;
 498
 499         if (spriv->type != HX) {
 500                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 501                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 502         } else {
 503                 /* reset upstream data pipes */
 504                 pl2303_vendor_write(8, 0, serial);
 505                 pl2303_vendor_write(9, 0, serial);
 506         }
 507
 508         /* Setup termios */
 509         if (tty)
 510                 pl2303_set_termios(tty, port, &tmp_termios);
 511
 512         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 513         if (result) {
 514                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 515                         " error %d\n", __func__, result);
 516                 return result;
 517         }
 518
 519         result = usb_serial_generic_open(tty, port);
 520         if (result) {
 521                 usb_kill_urb(port->interrupt_in_urb);
 522                 return result;
 523         }
 524
 525         port->port.drain_delay = 256;
 526         return 0;
 527 }
 528
 529 static int pl2303_tiocmset(struct tty_struct *tty,
 530                            unsigned int set, unsigned int clear)
 531 {
 532         struct usb_serial_port *port = tty->driver_data;
 533         struct usb_serial *serial = port->serial;
 534         struct pl2303_private *priv = usb_get_serial_port_data(port);
 535         unsigned long flags;
 536         u8 control;
 537         int ret;
 538
 539         spin_lock_irqsave(&priv->lock, flags);
 540         if (set & TIOCM_RTS)
 541                 priv->line_control |= CONTROL_RTS;
 542         if (set & TIOCM_DTR)
 543                 priv->line_control |= CONTROL_DTR;
 544         if (clear & TIOCM_RTS)
 545                 priv->line_control &= ~CONTROL_RTS;
 546         if (clear & TIOCM_DTR)
 547                 priv->line_control &= ~CONTROL_DTR;
 548         control = priv->line_control;
 549         spin_unlock_irqrestore(&priv->lock, flags);
 550
 551         mutex_lock(&serial->disc_mutex);
 552         if (!serial->disconnected)
 553                 ret = set_control_lines(serial->dev, control);
 554         else
 555                 ret = -ENODEV;
 556         mutex_unlock(&serial->disc_mutex);
 557
 558         return ret;
 559 }
 560
 561 static int pl2303_tiocmget(struct tty_struct *tty)
 562 {
 563         struct usb_serial_port *port = tty->driver_data;
 564         struct pl2303_private *priv = usb_get_serial_port_data(port);
 565         unsigned long flags;
 566         unsigned int mcr;
 567         unsigned int status;
 568         unsigned int result;
 569
 570         spin_lock_irqsave(&priv->lock, flags);
 571         mcr = priv->line_control;
 572         status = priv->line_status;
 573         spin_unlock_irqrestore(&priv->lock, flags);
 574
 575         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 576                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 577                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 578                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 579                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 580                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 581
 582         dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
 583
 584         return result;
 585 }
 586
 587 static int pl2303_carrier_raised(struct usb_serial_port *port)
 588 {
 589         struct pl2303_private *priv = usb_get_serial_port_data(port);
 590         if (priv->line_status & UART_DCD)
 591                 return 1;
 592         return 0;
 593 }
 594
 595 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 596 {
 597         struct pl2303_private *priv = usb_get_serial_port_data(port);
 598         unsigned long flags;
 599         unsigned int prevstatus;
 600         unsigned int status;
 601         unsigned int changed;
 602
 603         spin_lock_irqsave(&priv->lock, flags);
 604         prevstatus = priv->line_status;
 605         spin_unlock_irqrestore(&priv->lock, flags);
 606
 607         while (1) {
 608                 interruptible_sleep_on(&port->delta_msr_wait);
 609                 /* see if a signal did it */
 610                 if (signal_pending(current))
 611                         return -ERESTARTSYS;
 612
 613                 if (port->serial->disconnected)
 614                         return -EIO;
 615
 616                 spin_lock_irqsave(&priv->lock, flags);
 617                 status = priv->line_status;
 618                 spin_unlock_irqrestore(&priv->lock, flags);
 619
 620                 changed = prevstatus ^ status;
 621
 622                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 623                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 624                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 625                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 626                         return 0;
 627                 }
 628                 prevstatus = status;
 629         }
 630         /* NOTREACHED */
 631         return 0;
 632 }
 633
 634 static int pl2303_ioctl(struct tty_struct *tty,
 635                         unsigned int cmd, unsigned long arg)
 636 {
 637         struct serial_struct ser;
 638         struct usb_serial_port *port = tty->driver_data;
 639
 640         dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
 641
 642         switch (cmd) {
 643         case TIOCGSERIAL:
 644                 memset(&ser, 0, sizeof ser);
 645                 ser.type = PORT_16654;
 646                 ser.line = port->serial->minor;
 647                 ser.port = port->number;
 648                 ser.baud_base = 460800;
 649
 650                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 651                         return -EFAULT;
 652
 653                 return 0;
 654
 655         case TIOCMIWAIT:
 656                 dev_dbg(&port->dev, "%s TIOCMIWAIT\n", __func__);
 657                 return wait_modem_info(port, arg);
 658         default:
 659                 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
 660                 break;
 661         }
 662         return -ENOIOCTLCMD;
 663 }
 664
 665 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 666 {
 667         struct usb_serial_port *port = tty->driver_data;
 668         struct usb_serial *serial = port->serial;
 669         u16 state;
 670         int result;
 671
 672         if (break_state == 0)
 673                 state = BREAK_OFF;
 674         else
 675                 state = BREAK_ON;
 676         dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
 677                         state == BREAK_OFF ? "off" : "on");
 678
 679         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 680                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 681                                  0, NULL, 0, 100);
 682         if (result)
 683                 dev_err(&port->dev, "error sending break = %d\n", result);
 684 }
 685
 686 static void pl2303_update_line_status(struct usb_serial_port *port,
 687                                       unsigned char *data,
 688                                       unsigned int actual_length)
 689 {
 690
 691         struct pl2303_private *priv = usb_get_serial_port_data(port);
 692         struct tty_struct *tty;
 693         unsigned long flags;
 694         u8 status_idx = UART_STATE;
 695         u8 length = UART_STATE + 1;
 696         u8 prev_line_status;
 697         u16 idv, idp;
 698
 699         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 700         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 701
 702
 703         if (idv == SIEMENS_VENDOR_ID) {
 704                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 705                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 706                     idp == SIEMENS_PRODUCT_ID_X75) {
 707
 708                         length = 1;
 709                         status_idx = 0;
 710                 }
 711         }
 712
 713         if (actual_length < length)
 714                 return;
 715
 716         /* Save off the uart status for others to look at */
 717         spin_lock_irqsave(&priv->lock, flags);
 718         prev_line_status = priv->line_status;
 719         priv->line_status = data[status_idx];
 720         spin_unlock_irqrestore(&priv->lock, flags);
 721         if (priv->line_status & UART_BREAK_ERROR)
 722                 usb_serial_handle_break(port);
 723         wake_up_interruptible(&port->delta_msr_wait);
 724
 725         tty = tty_port_tty_get(&port->port);
 726         if (!tty)
 727                 return;
 728         if ((priv->line_status ^ prev_line_status) & UART_DCD)
 729                 usb_serial_handle_dcd_change(port, tty,
 730                                 priv->line_status & UART_DCD);
 731         tty_kref_put(tty);
 732 }
 733
 734 static void pl2303_read_int_callback(struct urb *urb)
 735 {
 736         struct usb_serial_port *port =  urb->context;
 737         unsigned char *data = urb->transfer_buffer;
 738         unsigned int actual_length = urb->actual_length;
 739         int status = urb->status;
 740         int retval;
 741
 742         switch (status) {
 743         case 0:
 744                 /* success */
 745                 break;
 746         case -ECONNRESET:
 747         case -ENOENT:
 748         case -ESHUTDOWN:
 749                 /* this urb is terminated, clean up */
 750                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 751                         __func__, status);
 752                 return;
 753         default:
 754                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 755                         __func__, status);
 756                 goto exit;
 757         }
 758
 759         usb_serial_debug_data(&port->dev, __func__,
 760                               urb->actual_length, urb->transfer_buffer);
 761
 762         pl2303_update_line_status(port, data, actual_length);
 763
 764 exit:
 765         retval = usb_submit_urb(urb, GFP_ATOMIC);
 766         if (retval)
 767                 dev_err(&port->dev,
 768                         "%s - usb_submit_urb failed with result %d\n",
 769                         __func__, retval);
 770 }
 771
 772 static void pl2303_process_read_urb(struct urb *urb)
 773 {
 774         struct usb_serial_port *port = urb->context;
 775         struct pl2303_private *priv = usb_get_serial_port_data(port);
 776         unsigned char *data = urb->transfer_buffer;
 777         char tty_flag = TTY_NORMAL;
 778         unsigned long flags;
 779         u8 line_status;
 780         int i;
 781
 782         /* update line status */
 783         spin_lock_irqsave(&priv->lock, flags);
 784         line_status = priv->line_status;
 785         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 786         spin_unlock_irqrestore(&priv->lock, flags);
 787         wake_up_interruptible(&port->delta_msr_wait);
 788
 789         if (!urb->actual_length)
 790                 return;
 791
 792         /* break takes precedence over parity, */
 793         /* which takes precedence over framing errors */
 794         if (line_status & UART_BREAK_ERROR)
 795                 tty_flag = TTY_BREAK;
 796         else if (line_status & UART_PARITY_ERROR)
 797                 tty_flag = TTY_PARITY;
 798         else if (line_status & UART_FRAME_ERROR)
 799                 tty_flag = TTY_FRAME;
 800         dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
 801
 802         /* overrun is special, not associated with a char */
 803         if (line_status & UART_OVERRUN_ERROR)
 804                 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 805
 806         if (port->port.console && port->sysrq) {
 807                 for (i = 0; i < urb->actual_length; ++i)
 808                         if (!usb_serial_handle_sysrq_char(port, data[i]))
 809                                 tty_insert_flip_char(&port->port, data[i],
 810                                                 tty_flag);
 811         } else {
 812                 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
 813                                                         urb->actual_length);
 814         }
 815
 816         tty_flip_buffer_push(&port->port);
 817 }
 818
 819 /* All of the device info needed for the PL2303 SIO serial converter */
 820 static struct usb_serial_driver pl2303_device = {
 821         .driver = {
 822                 .owner =        THIS_MODULE,
 823                 .name =         "pl2303",
 824         },
 825         .id_table =             id_table,
 826         .num_ports =            1,
 827         .bulk_in_size =         256,
 828         .bulk_out_size =        256,
 829         .open =                 pl2303_open,
 830         .close =                pl2303_close,
 831         .dtr_rts =              pl2303_dtr_rts,
 832         .carrier_raised =       pl2303_carrier_raised,
 833         .ioctl =                pl2303_ioctl,
 834         .break_ctl =            pl2303_break_ctl,
 835         .set_termios =          pl2303_set_termios,
 836         .tiocmget =             pl2303_tiocmget,
 837         .tiocmset =             pl2303_tiocmset,
 838         .process_read_urb =     pl2303_process_read_urb,
 839         .read_int_callback =    pl2303_read_int_callback,
 840         .attach =               pl2303_startup,
 841         .release =              pl2303_release,
 842         .port_probe =           pl2303_port_probe,
 843         .port_remove =          pl2303_port_remove,
 844 };
 845
 846 static struct usb_serial_driver * const serial_drivers[] = {
 847         &pl2303_device, NULL
 848 };
 849
 850 module_usb_serial_driver(serial_drivers, id_table);
 851
 852 MODULE_DESCRIPTION(DRIVER_DESC);
 853 MODULE_LICENSE("GPL");