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