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