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