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