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