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