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 interrupt urb", __func__);
 506         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 507         if (result) {
 508                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 509                         " error %d\n", __func__, result);
 510                 return result;
 511         }
 512
 513         result = usb_serial_generic_open(tty, port);
 514         if (result) {
 515                 usb_kill_urb(port->interrupt_in_urb);
 516                 return result;
 517         }
 518
 519         port->port.drain_delay = 256;
 520         return 0;
 521 }
 522
 523 static int pl2303_tiocmset(struct tty_struct *tty,
 524                            unsigned int set, unsigned int clear)
 525 {
 526         struct usb_serial_port *port = tty->driver_data;
 527         struct pl2303_private *priv = usb_get_serial_port_data(port);
 528         unsigned long flags;
 529         u8 control;
 530
 531         if (!usb_get_intfdata(port->serial->interface))
 532                 return -ENODEV;
 533
 534         spin_lock_irqsave(&priv->lock, flags);
 535         if (set & TIOCM_RTS)
 536                 priv->line_control |= CONTROL_RTS;
 537         if (set & TIOCM_DTR)
 538                 priv->line_control |= CONTROL_DTR;
 539         if (clear & TIOCM_RTS)
 540                 priv->line_control &= ~CONTROL_RTS;
 541         if (clear & TIOCM_DTR)
 542                 priv->line_control &= ~CONTROL_DTR;
 543         control = priv->line_control;
 544         spin_unlock_irqrestore(&priv->lock, flags);
 545
 546         return set_control_lines(port->serial->dev, control);
 547 }
 548
 549 static int pl2303_tiocmget(struct tty_struct *tty)
 550 {
 551         struct usb_serial_port *port = tty->driver_data;
 552         struct pl2303_private *priv = usb_get_serial_port_data(port);
 553         unsigned long flags;
 554         unsigned int mcr;
 555         unsigned int status;
 556         unsigned int result;
 557
 558         dbg("%s (%d)", __func__, port->number);
 559
 560         if (!usb_get_intfdata(port->serial->interface))
 561                 return -ENODEV;
 562
 563         spin_lock_irqsave(&priv->lock, flags);
 564         mcr = priv->line_control;
 565         status = priv->line_status;
 566         spin_unlock_irqrestore(&priv->lock, flags);
 567
 568         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 569                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 570                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 571                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 572                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 573                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 574
 575         dbg("%s - result = %x", __func__, result);
 576
 577         return result;
 578 }
 579
 580 static int pl2303_carrier_raised(struct usb_serial_port *port)
 581 {
 582         struct pl2303_private *priv = usb_get_serial_port_data(port);
 583         if (priv->line_status & UART_DCD)
 584                 return 1;
 585         return 0;
 586 }
 587
 588 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 589 {
 590         struct pl2303_private *priv = usb_get_serial_port_data(port);
 591         unsigned long flags;
 592         unsigned int prevstatus;
 593         unsigned int status;
 594         unsigned int changed;
 595
 596         spin_lock_irqsave(&priv->lock, flags);
 597         prevstatus = priv->line_status;
 598         spin_unlock_irqrestore(&priv->lock, flags);
 599
 600         while (1) {
 601                 interruptible_sleep_on(&priv->delta_msr_wait);
 602                 /* see if a signal did it */
 603                 if (signal_pending(current))
 604                         return -ERESTARTSYS;
 605
 606                 spin_lock_irqsave(&priv->lock, flags);
 607                 status = priv->line_status;
 608                 spin_unlock_irqrestore(&priv->lock, flags);
 609
 610                 changed = prevstatus ^ status;
 611
 612                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 613                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 614                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 615                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 616                         return 0;
 617                 }
 618                 prevstatus = status;
 619         }
 620         /* NOTREACHED */
 621         return 0;
 622 }
 623
 624 static int pl2303_ioctl(struct tty_struct *tty,
 625                         unsigned int cmd, unsigned long arg)
 626 {
 627         struct serial_struct ser;
 628         struct usb_serial_port *port = tty->driver_data;
 629         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 630
 631         switch (cmd) {
 632         case TIOCGSERIAL:
 633                 memset(&ser, 0, sizeof ser);
 634                 ser.type = PORT_16654;
 635                 ser.line = port->serial->minor;
 636                 ser.port = port->number;
 637                 ser.baud_base = 460800;
 638
 639                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 640                         return -EFAULT;
 641
 642                 return 0;
 643
 644         case TIOCMIWAIT:
 645                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 646                 return wait_modem_info(port, arg);
 647         default:
 648                 dbg("%s not supported = 0x%04x", __func__, cmd);
 649                 break;
 650         }
 651         return -ENOIOCTLCMD;
 652 }
 653
 654 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 655 {
 656         struct usb_serial_port *port = tty->driver_data;
 657         struct usb_serial *serial = port->serial;
 658         u16 state;
 659         int result;
 660
 661         dbg("%s - port %d", __func__, port->number);
 662
 663         if (break_state == 0)
 664                 state = BREAK_OFF;
 665         else
 666                 state = BREAK_ON;
 667         dbg("%s - turning break %s", __func__,
 668                         state == BREAK_OFF ? "off" : "on");
 669
 670         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 671                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 672                                  0, NULL, 0, 100);
 673         if (result)
 674                 dbg("%s - error sending break = %d", __func__, result);
 675 }
 676
 677 static void pl2303_release(struct usb_serial *serial)
 678 {
 679         int i;
 680         struct pl2303_private *priv;
 681
 682         dbg("%s", __func__);
 683
 684         for (i = 0; i < serial->num_ports; ++i) {
 685                 priv = usb_get_serial_port_data(serial->port[i]);
 686                 kfree(priv);
 687         }
 688 }
 689
 690 static void pl2303_update_line_status(struct usb_serial_port *port,
 691                                       unsigned char *data,
 692                                       unsigned int actual_length)
 693 {
 694
 695         struct pl2303_private *priv = usb_get_serial_port_data(port);
 696         struct tty_struct *tty;
 697         unsigned long flags;
 698         u8 status_idx = UART_STATE;
 699         u8 length = UART_STATE + 1;
 700         u8 prev_line_status;
 701         u16 idv, idp;
 702
 703         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 704         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 705
 706
 707         if (idv == SIEMENS_VENDOR_ID) {
 708                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 709                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 710                     idp == SIEMENS_PRODUCT_ID_X75) {
 711
 712                         length = 1;
 713                         status_idx = 0;
 714                 }
 715         }
 716
 717         if (actual_length < length)
 718                 return;
 719
 720         /* Save off the uart status for others to look at */
 721         spin_lock_irqsave(&priv->lock, flags);
 722         prev_line_status = priv->line_status;
 723         priv->line_status = data[status_idx];
 724         spin_unlock_irqrestore(&priv->lock, flags);
 725         if (priv->line_status & UART_BREAK_ERROR)
 726                 usb_serial_handle_break(port);
 727         wake_up_interruptible(&priv->delta_msr_wait);
 728
 729         tty = tty_port_tty_get(&port->port);
 730         if (!tty)
 731                 return;
 732         if ((priv->line_status ^ prev_line_status) & UART_DCD)
 733                 usb_serial_handle_dcd_change(port, tty,
 734                                 priv->line_status & UART_DCD);
 735         tty_kref_put(tty);
 736 }
 737
 738 static void pl2303_read_int_callback(struct urb *urb)
 739 {
 740         struct usb_serial_port *port =  urb->context;
 741         unsigned char *data = urb->transfer_buffer;
 742         unsigned int actual_length = urb->actual_length;
 743         int status = urb->status;
 744         int retval;
 745
 746         dbg("%s (%d)", __func__, port->number);
 747
 748         switch (status) {
 749         case 0:
 750                 /* success */
 751                 break;
 752         case -ECONNRESET:
 753         case -ENOENT:
 754         case -ESHUTDOWN:
 755                 /* this urb is terminated, clean up */
 756                 dbg("%s - urb shutting down with status: %d", __func__,
 757                     status);
 758                 return;
 759         default:
 760                 dbg("%s - nonzero urb status received: %d", __func__,
 761                     status);
 762                 goto exit;
 763         }
 764
 765         usb_serial_debug_data(debug, &port->dev, __func__,
 766                               urb->actual_length, urb->transfer_buffer);
 767
 768         pl2303_update_line_status(port, data, actual_length);
 769
 770 exit:
 771         retval = usb_submit_urb(urb, GFP_ATOMIC);
 772         if (retval)
 773                 dev_err(&urb->dev->dev,
 774                         "%s - usb_submit_urb failed with result %d\n",
 775                         __func__, retval);
 776 }
 777
 778 static void pl2303_process_read_urb(struct urb *urb)
 779 {
 780         struct usb_serial_port *port = urb->context;
 781         struct pl2303_private *priv = usb_get_serial_port_data(port);
 782         struct tty_struct *tty;
 783         unsigned char *data = urb->transfer_buffer;
 784         char tty_flag = TTY_NORMAL;
 785         unsigned long flags;
 786         u8 line_status;
 787         int i;
 788
 789         /* update line status */
 790         spin_lock_irqsave(&priv->lock, flags);
 791         line_status = priv->line_status;
 792         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 793         spin_unlock_irqrestore(&priv->lock, flags);
 794         wake_up_interruptible(&priv->delta_msr_wait);
 795
 796         if (!urb->actual_length)
 797                 return;
 798
 799         tty = tty_port_tty_get(&port->port);
 800         if (!tty)
 801                 return;
 802
 803         /* break takes precedence over parity, */
 804         /* which takes precedence over framing errors */
 805         if (line_status & UART_BREAK_ERROR)
 806                 tty_flag = TTY_BREAK;
 807         else if (line_status & UART_PARITY_ERROR)
 808                 tty_flag = TTY_PARITY;
 809         else if (line_status & UART_FRAME_ERROR)
 810                 tty_flag = TTY_FRAME;
 811         dbg("%s - tty_flag = %d", __func__, tty_flag);
 812
 813         /* overrun is special, not associated with a char */
 814         if (line_status & UART_OVERRUN_ERROR)
 815                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 816
 817         if (port->port.console && port->sysrq) {
 818                 for (i = 0; i < urb->actual_length; ++i)
 819                         if (!usb_serial_handle_sysrq_char(port, data[i]))
 820                                 tty_insert_flip_char(tty, data[i], tty_flag);
 821         } else {
 822                 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
 823                                                         urb->actual_length);
 824         }
 825
 826         tty_flip_buffer_push(tty);
 827         tty_kref_put(tty);
 828 }
 829
 830 /* All of the device info needed for the PL2303 SIO serial converter */
 831 static struct usb_serial_driver pl2303_device = {
 832         .driver = {
 833                 .owner =        THIS_MODULE,
 834                 .name =         "pl2303",
 835         },
 836         .id_table =             id_table,
 837         .usb_driver =           &pl2303_driver,
 838         .num_ports =            1,
 839         .bulk_in_size =         256,
 840         .bulk_out_size =        256,
 841         .open =                 pl2303_open,
 842         .close =                pl2303_close,
 843         .dtr_rts =              pl2303_dtr_rts,
 844         .carrier_raised =       pl2303_carrier_raised,
 845         .ioctl =                pl2303_ioctl,
 846         .break_ctl =            pl2303_break_ctl,
 847         .set_termios =          pl2303_set_termios,
 848         .tiocmget =             pl2303_tiocmget,
 849         .tiocmset =             pl2303_tiocmset,
 850         .process_read_urb =     pl2303_process_read_urb,
 851         .read_int_callback =    pl2303_read_int_callback,
 852         .attach =               pl2303_startup,
 853         .release =              pl2303_release,
 854 };
 855
 856 static int __init pl2303_init(void)
 857 {
 858         int retval;
 859
 860         retval = usb_serial_register(&pl2303_device);
 861         if (retval)
 862                 goto failed_usb_serial_register;
 863         retval = usb_register(&pl2303_driver);
 864         if (retval)
 865                 goto failed_usb_register;
 866         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 867         return 0;
 868 failed_usb_register:
 869         usb_serial_deregister(&pl2303_device);
 870 failed_usb_serial_register:
 871         return retval;
 872 }
 873
 874 static void __exit pl2303_exit(void)
 875 {
 876         usb_deregister(&pl2303_driver);
 877         usb_serial_deregister(&pl2303_device);
 878 }
 879
 880 module_init(pl2303_init);
 881 module_exit(pl2303_exit);
 882
 883 MODULE_DESCRIPTION(DRIVER_DESC);
 884 MODULE_LICENSE("GPL");
 885
 886 module_param(debug, bool, S_IRUGO | S_IWUSR);
 887 MODULE_PARM_DESC(debug, "Debug enabled or not");
 888