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->interface->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->interface->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         port->port.drain_delay = 256;
 239
 240         return 0;
 241 }
 242
 243 static int pl2303_port_remove(struct usb_serial_port *port)
 244 {
 245         struct pl2303_private *priv;
 246
 247         priv = usb_get_serial_port_data(port);
 248         kfree(priv);
 249
 250         return 0;
 251 }
 252
 253 static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
 254 {
 255         struct usb_device *dev = port->serial->dev;
 256         int retval;
 257
 258         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 259                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 260                                  value, 0, NULL, 0, 100);
 261         dev_dbg(&port->dev, "%s - value = %d, retval = %d\n", __func__,
 262                 value, retval);
 263         return retval;
 264 }
 265
 266 static void pl2303_set_termios(struct tty_struct *tty,
 267                 struct usb_serial_port *port, struct ktermios *old_termios)
 268 {
 269         struct usb_serial *serial = port->serial;
 270         struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
 271         struct pl2303_private *priv = usb_get_serial_port_data(port);
 272         unsigned long flags;
 273         unsigned int cflag;
 274         unsigned char *buf;
 275         int baud;
 276         int i;
 277         u8 control;
 278         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
 279                                  4800, 7200, 9600, 14400, 19200, 28800, 38400,
 280                                  57600, 115200, 230400, 460800, 500000, 614400,
 281                                  921600, 1228800, 2457600, 3000000, 6000000 };
 282         int baud_floor, baud_ceil;
 283         int k;
 284
 285         /* The PL2303 is reported to lose bytes if you change
 286            serial settings even to the same values as before. Thus
 287            we actually need to filter in this specific case */
 288
 289         if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
 290                 return;
 291
 292         cflag = tty->termios.c_cflag;
 293
 294         buf = kzalloc(7, GFP_KERNEL);
 295         if (!buf) {
 296                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 297                 /* Report back no change occurred */
 298                 if (old_termios)
 299                         tty->termios = *old_termios;
 300                 return;
 301         }
 302
 303         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 304                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 305                             0, 0, buf, 7, 100);
 306         dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %7ph\n", i, buf);
 307
 308         if (cflag & CSIZE) {
 309                 switch (cflag & CSIZE) {
 310                 case CS5:
 311                         buf[6] = 5;
 312                         break;
 313                 case CS6:
 314                         buf[6] = 6;
 315                         break;
 316                 case CS7:
 317                         buf[6] = 7;
 318                         break;
 319                 default:
 320                 case CS8:
 321                         buf[6] = 8;
 322                         break;
 323                 }
 324                 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
 325         }
 326
 327         /* For reference buf[0]:buf[3] baud rate value */
 328         /* NOTE: Only the values defined in baud_sup are supported !
 329          *       => if unsupported values are set, the PL2303 seems to use
 330          *          9600 baud (at least my PL2303X always does)
 331          */
 332         baud = tty_get_baud_rate(tty);
 333         dev_dbg(&port->dev, "baud requested = %d\n", baud);
 334         if (baud) {
 335                 /* Set baudrate to nearest supported value */
 336                 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
 337                         if (baud_sup[k] / baud) {
 338                                 baud_ceil = baud_sup[k];
 339                                 if (k==0) {
 340                                         baud = baud_ceil;
 341                                 } else {
 342                                         baud_floor = baud_sup[k-1];
 343                                         if ((baud_ceil % baud)
 344                                             > (baud % baud_floor))
 345                                                 baud = baud_floor;
 346                                         else
 347                                                 baud = baud_ceil;
 348                                 }
 349                                 break;
 350                         }
 351                 }
 352                 if (baud > 1228800) {
 353                         /* type_0, type_1 only support up to 1228800 baud */
 354                         if (spriv->type != HX)
 355                                 baud = 1228800;
 356                         else if (baud > 6000000)
 357                                 baud = 6000000;
 358                 }
 359                 dev_dbg(&port->dev, "baud set = %d\n", baud);
 360                 if (baud <= 115200) {
 361                         buf[0] = baud & 0xff;
 362                         buf[1] = (baud >> 8) & 0xff;
 363                         buf[2] = (baud >> 16) & 0xff;
 364                         buf[3] = (baud >> 24) & 0xff;
 365                 } else {
 366                         /* apparently the formula for higher speeds is:
 367                          * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
 368                          */
 369                         unsigned tmp = 12*1000*1000*32 / baud;
 370                         buf[3] = 0x80;
 371                         buf[2] = 0;
 372                         buf[1] = (tmp >= 256);
 373                         while (tmp >= 256) {
 374                                 tmp >>= 2;
 375                                 buf[1] <<= 1;
 376                         }
 377                         buf[0] = tmp;
 378                 }
 379         }
 380
 381         /* For reference buf[4]=0 is 1 stop bits */
 382         /* For reference buf[4]=1 is 1.5 stop bits */
 383         /* For reference buf[4]=2 is 2 stop bits */
 384         if (cflag & CSTOPB) {
 385                 /* NOTE: Comply with "real" UARTs / RS232:
 386                  *       use 1.5 instead of 2 stop bits with 5 data bits
 387                  */
 388                 if ((cflag & CSIZE) == CS5) {
 389                         buf[4] = 1;
 390                         dev_dbg(&port->dev, "stop bits = 1.5\n");
 391                 } else {
 392                         buf[4] = 2;
 393                         dev_dbg(&port->dev, "stop bits = 2\n");
 394                 }
 395         } else {
 396                 buf[4] = 0;
 397                 dev_dbg(&port->dev, "stop bits = 1\n");
 398         }
 399
 400         if (cflag & PARENB) {
 401                 /* For reference buf[5]=0 is none parity */
 402                 /* For reference buf[5]=1 is odd parity */
 403                 /* For reference buf[5]=2 is even parity */
 404                 /* For reference buf[5]=3 is mark parity */
 405                 /* For reference buf[5]=4 is space parity */
 406                 if (cflag & PARODD) {
 407                         if (cflag & CMSPAR) {
 408                                 buf[5] = 3;
 409                                 dev_dbg(&port->dev, "parity = mark\n");
 410                         } else {
 411                                 buf[5] = 1;
 412                                 dev_dbg(&port->dev, "parity = odd\n");
 413                         }
 414                 } else {
 415                         if (cflag & CMSPAR) {
 416                                 buf[5] = 4;
 417                                 dev_dbg(&port->dev, "parity = space\n");
 418                         } else {
 419                                 buf[5] = 2;
 420                                 dev_dbg(&port->dev, "parity = even\n");
 421                         }
 422                 }
 423         } else {
 424                 buf[5] = 0;
 425                 dev_dbg(&port->dev, "parity = none\n");
 426         }
 427
 428         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 429                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 430                             0, 0, buf, 7, 100);
 431         dev_dbg(&port->dev, "0x21:0x20:0:0  %d\n", i);
 432
 433         /* change control lines if we are switching to or from B0 */
 434         spin_lock_irqsave(&priv->lock, flags);
 435         control = priv->line_control;
 436         if ((cflag & CBAUD) == B0)
 437                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 438         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 439                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 440         if (control != priv->line_control) {
 441                 control = priv->line_control;
 442                 spin_unlock_irqrestore(&priv->lock, flags);
 443                 pl2303_set_control_lines(port, control);
 444         } else {
 445                 spin_unlock_irqrestore(&priv->lock, flags);
 446         }
 447
 448         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 449
 450         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 451                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 452                             0, 0, buf, 7, 100);
 453         dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %7ph\n", i, buf);
 454
 455         if (cflag & CRTSCTS) {
 456                 if (spriv->type == HX)
 457                         pl2303_vendor_write(0x0, 0x61, serial);
 458                 else
 459                         pl2303_vendor_write(0x0, 0x41, serial);
 460         } else {
 461                 pl2303_vendor_write(0x0, 0x0, serial);
 462         }
 463
 464         /* Save resulting baud rate */
 465         if (baud)
 466                 tty_encode_baud_rate(tty, baud, baud);
 467
 468         kfree(buf);
 469 }
 470
 471 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 472 {
 473         struct pl2303_private *priv = usb_get_serial_port_data(port);
 474         unsigned long flags;
 475         u8 control;
 476
 477         spin_lock_irqsave(&priv->lock, flags);
 478         /* Change DTR and RTS */
 479         if (on)
 480                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 481         else
 482                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 483         control = priv->line_control;
 484         spin_unlock_irqrestore(&priv->lock, flags);
 485         pl2303_set_control_lines(port, control);
 486 }
 487
 488 static void pl2303_close(struct usb_serial_port *port)
 489 {
 490         usb_serial_generic_close(port);
 491         usb_kill_urb(port->interrupt_in_urb);
 492 }
 493
 494 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 495 {
 496         struct usb_serial *serial = port->serial;
 497         struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
 498         int result;
 499
 500         if (spriv->type != HX) {
 501                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 502                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 503         } else {
 504                 /* reset upstream data pipes */
 505                 pl2303_vendor_write(8, 0, serial);
 506                 pl2303_vendor_write(9, 0, serial);
 507         }
 508
 509         /* Setup termios */
 510         if (tty)
 511                 pl2303_set_termios(tty, port, NULL);
 512
 513         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 514         if (result) {
 515                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 516                         " error %d\n", __func__, result);
 517                 return result;
 518         }
 519
 520         result = usb_serial_generic_open(tty, port);
 521         if (result) {
 522                 usb_kill_urb(port->interrupt_in_urb);
 523                 return result;
 524         }
 525
 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 pl2303_private *priv = usb_get_serial_port_data(port);
 534         unsigned long flags;
 535         u8 control;
 536         int ret;
 537
 538         spin_lock_irqsave(&priv->lock, flags);
 539         if (set & TIOCM_RTS)
 540                 priv->line_control |= CONTROL_RTS;
 541         if (set & TIOCM_DTR)
 542                 priv->line_control |= CONTROL_DTR;
 543         if (clear & TIOCM_RTS)
 544                 priv->line_control &= ~CONTROL_RTS;
 545         if (clear & TIOCM_DTR)
 546                 priv->line_control &= ~CONTROL_DTR;
 547         control = priv->line_control;
 548         spin_unlock_irqrestore(&priv->lock, flags);
 549
 550         ret = pl2303_set_control_lines(port, control);
 551         if (ret)
 552                 return usb_translate_errors(ret);
 553
 554         return 0;
 555 }
 556
 557 static int pl2303_tiocmget(struct tty_struct *tty)
 558 {
 559         struct usb_serial_port *port = tty->driver_data;
 560         struct pl2303_private *priv = usb_get_serial_port_data(port);
 561         unsigned long flags;
 562         unsigned int mcr;
 563         unsigned int status;
 564         unsigned int result;
 565
 566         spin_lock_irqsave(&priv->lock, flags);
 567         mcr = priv->line_control;
 568         status = priv->line_status;
 569         spin_unlock_irqrestore(&priv->lock, flags);
 570
 571         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 572                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 573                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 574                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 575                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 576                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 577
 578         dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
 579
 580         return result;
 581 }
 582
 583 static int pl2303_carrier_raised(struct usb_serial_port *port)
 584 {
 585         struct pl2303_private *priv = usb_get_serial_port_data(port);
 586         if (priv->line_status & UART_DCD)
 587                 return 1;
 588         return 0;
 589 }
 590
 591 static int pl2303_tiocmiwait(struct tty_struct *tty, unsigned long arg)
 592 {
 593         struct usb_serial_port *port = tty->driver_data;
 594         struct pl2303_private *priv = usb_get_serial_port_data(port);
 595         unsigned long flags;
 596         unsigned int prevstatus;
 597         unsigned int status;
 598         unsigned int changed;
 599
 600         spin_lock_irqsave(&priv->lock, flags);
 601         prevstatus = priv->line_status;
 602         spin_unlock_irqrestore(&priv->lock, flags);
 603
 604         while (1) {
 605                 interruptible_sleep_on(&port->port.delta_msr_wait);
 606                 /* see if a signal did it */
 607                 if (signal_pending(current))
 608                         return -ERESTARTSYS;
 609
 610                 if (port->serial->disconnected)
 611                         return -EIO;
 612
 613                 spin_lock_irqsave(&priv->lock, flags);
 614                 status = priv->line_status;
 615                 spin_unlock_irqrestore(&priv->lock, flags);
 616
 617                 changed = prevstatus ^ status;
 618
 619                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 620                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 621                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 622                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 623                         return 0;
 624                 }
 625                 prevstatus = status;
 626         }
 627         /* NOTREACHED */
 628         return 0;
 629 }
 630
 631 static int pl2303_ioctl(struct tty_struct *tty,
 632                         unsigned int cmd, unsigned long arg)
 633 {
 634         struct serial_struct ser;
 635         struct usb_serial_port *port = tty->driver_data;
 636
 637         dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
 638
 639         switch (cmd) {
 640         case TIOCGSERIAL:
 641                 memset(&ser, 0, sizeof ser);
 642                 ser.type = PORT_16654;
 643                 ser.line = port->minor;
 644                 ser.port = port->port_number;
 645                 ser.baud_base = 460800;
 646
 647                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 648                         return -EFAULT;
 649
 650                 return 0;
 651         default:
 652                 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
 653                 break;
 654         }
 655         return -ENOIOCTLCMD;
 656 }
 657
 658 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 659 {
 660         struct usb_serial_port *port = tty->driver_data;
 661         struct usb_serial *serial = port->serial;
 662         u16 state;
 663         int result;
 664
 665         if (break_state == 0)
 666                 state = BREAK_OFF;
 667         else
 668                 state = BREAK_ON;
 669         dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
 670                         state == BREAK_OFF ? "off" : "on");
 671
 672         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 673                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 674                                  0, NULL, 0, 100);
 675         if (result)
 676                 dev_err(&port->dev, "error sending break = %d\n", result);
 677 }
 678
 679 static void pl2303_update_line_status(struct usb_serial_port *port,
 680                                       unsigned char *data,
 681                                       unsigned int actual_length)
 682 {
 683
 684         struct pl2303_private *priv = usb_get_serial_port_data(port);
 685         struct tty_struct *tty;
 686         unsigned long flags;
 687         u8 status_idx = UART_STATE;
 688         u8 length = UART_STATE + 1;
 689         u8 prev_line_status;
 690         u16 idv, idp;
 691
 692         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 693         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 694
 695
 696         if (idv == SIEMENS_VENDOR_ID) {
 697                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 698                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 699                     idp == SIEMENS_PRODUCT_ID_X75) {
 700
 701                         length = 1;
 702                         status_idx = 0;
 703                 }
 704         }
 705
 706         if (actual_length < length)
 707                 return;
 708
 709         /* Save off the uart status for others to look at */
 710         spin_lock_irqsave(&priv->lock, flags);
 711         prev_line_status = priv->line_status;
 712         priv->line_status = data[status_idx];
 713         spin_unlock_irqrestore(&priv->lock, flags);
 714         if (priv->line_status & UART_BREAK_ERROR)
 715                 usb_serial_handle_break(port);
 716         wake_up_interruptible(&port->port.delta_msr_wait);
 717
 718         tty = tty_port_tty_get(&port->port);
 719         if (!tty)
 720                 return;
 721         if ((priv->line_status ^ prev_line_status) & UART_DCD)
 722                 usb_serial_handle_dcd_change(port, tty,
 723                                 priv->line_status & UART_DCD);
 724         tty_kref_put(tty);
 725 }
 726
 727 static void pl2303_read_int_callback(struct urb *urb)
 728 {
 729         struct usb_serial_port *port =  urb->context;
 730         unsigned char *data = urb->transfer_buffer;
 731         unsigned int actual_length = urb->actual_length;
 732         int status = urb->status;
 733         int retval;
 734
 735         switch (status) {
 736         case 0:
 737                 /* success */
 738                 break;
 739         case -ECONNRESET:
 740         case -ENOENT:
 741         case -ESHUTDOWN:
 742                 /* this urb is terminated, clean up */
 743                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 744                         __func__, status);
 745                 return;
 746         default:
 747                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 748                         __func__, status);
 749                 goto exit;
 750         }
 751
 752         usb_serial_debug_data(&port->dev, __func__,
 753                               urb->actual_length, urb->transfer_buffer);
 754
 755         pl2303_update_line_status(port, data, actual_length);
 756
 757 exit:
 758         retval = usb_submit_urb(urb, GFP_ATOMIC);
 759         if (retval)
 760                 dev_err(&port->dev,
 761                         "%s - usb_submit_urb failed with result %d\n",
 762                         __func__, retval);
 763 }
 764
 765 static void pl2303_process_read_urb(struct urb *urb)
 766 {
 767         struct usb_serial_port *port = urb->context;
 768         struct pl2303_private *priv = usb_get_serial_port_data(port);
 769         unsigned char *data = urb->transfer_buffer;
 770         char tty_flag = TTY_NORMAL;
 771         unsigned long flags;
 772         u8 line_status;
 773         int i;
 774
 775         /* update line status */
 776         spin_lock_irqsave(&priv->lock, flags);
 777         line_status = priv->line_status;
 778         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 779         spin_unlock_irqrestore(&priv->lock, flags);
 780         wake_up_interruptible(&port->port.delta_msr_wait);
 781
 782         if (!urb->actual_length)
 783                 return;
 784
 785         /* break takes precedence over parity, */
 786         /* which takes precedence over framing errors */
 787         if (line_status & UART_BREAK_ERROR)
 788                 tty_flag = TTY_BREAK;
 789         else if (line_status & UART_PARITY_ERROR)
 790                 tty_flag = TTY_PARITY;
 791         else if (line_status & UART_FRAME_ERROR)
 792                 tty_flag = TTY_FRAME;
 793         dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
 794
 795         /* overrun is special, not associated with a char */
 796         if (line_status & UART_OVERRUN_ERROR)
 797                 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 798
 799         if (port->port.console && port->sysrq) {
 800                 for (i = 0; i < urb->actual_length; ++i)
 801                         if (!usb_serial_handle_sysrq_char(port, data[i]))
 802                                 tty_insert_flip_char(&port->port, data[i],
 803                                                 tty_flag);
 804         } else {
 805                 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
 806                                                         urb->actual_length);
 807         }
 808
 809         tty_flip_buffer_push(&port->port);
 810 }
 811
 812 /* All of the device info needed for the PL2303 SIO serial converter */
 813 static struct usb_serial_driver pl2303_device = {
 814         .driver = {
 815                 .owner =        THIS_MODULE,
 816                 .name =         "pl2303",
 817         },
 818         .id_table =             id_table,
 819         .num_ports =            1,
 820         .bulk_in_size =         256,
 821         .bulk_out_size =        256,
 822         .open =                 pl2303_open,
 823         .close =                pl2303_close,
 824         .dtr_rts =              pl2303_dtr_rts,
 825         .carrier_raised =       pl2303_carrier_raised,
 826         .ioctl =                pl2303_ioctl,
 827         .break_ctl =            pl2303_break_ctl,
 828         .set_termios =          pl2303_set_termios,
 829         .tiocmget =             pl2303_tiocmget,
 830         .tiocmset =             pl2303_tiocmset,
 831         .tiocmiwait =           pl2303_tiocmiwait,
 832         .process_read_urb =     pl2303_process_read_urb,
 833         .read_int_callback =    pl2303_read_int_callback,
 834         .attach =               pl2303_startup,
 835         .release =              pl2303_release,
 836         .port_probe =           pl2303_port_probe,
 837         .port_remove =          pl2303_port_remove,
 838 };
 839
 840 static struct usb_serial_driver * const serial_drivers[] = {
 841         &pl2303_device, NULL
 842 };
 843
 844 module_usb_serial_driver(serial_drivers, id_table);
 845
 846 MODULE_DESCRIPTION(DRIVER_DESC);
 847 MODULE_LICENSE("GPL");