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