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(WINCHIPHEAD_VENDOR_ID, WINCHIPHEAD_USBSER_PRODUCT_ID) },
  95         { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
  96         { }                                     /* Terminating entry */
  97 };
  98
  99 MODULE_DEVICE_TABLE(usb, id_table);
 100
 101 static struct usb_driver pl2303_driver = {
 102         .name =         "pl2303",
 103         .probe =        usb_serial_probe,
 104         .disconnect =   usb_serial_disconnect,
 105         .id_table =     id_table,
 106         .suspend =      usb_serial_suspend,
 107         .resume =       usb_serial_resume,
 108         .no_dynamic_id =        1,
 109         .supports_autosuspend = 1,
 110 };
 111
 112 #define SET_LINE_REQUEST_TYPE           0x21
 113 #define SET_LINE_REQUEST                0x20
 114
 115 #define SET_CONTROL_REQUEST_TYPE        0x21
 116 #define SET_CONTROL_REQUEST             0x22
 117 #define CONTROL_DTR                     0x01
 118 #define CONTROL_RTS                     0x02
 119
 120 #define BREAK_REQUEST_TYPE              0x21
 121 #define BREAK_REQUEST                   0x23
 122 #define BREAK_ON                        0xffff
 123 #define BREAK_OFF                       0x0000
 124
 125 #define GET_LINE_REQUEST_TYPE           0xa1
 126 #define GET_LINE_REQUEST                0x21
 127
 128 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 129 #define VENDOR_WRITE_REQUEST            0x01
 130
 131 #define VENDOR_READ_REQUEST_TYPE        0xc0
 132 #define VENDOR_READ_REQUEST             0x01
 133
 134 #define UART_STATE                      0x08
 135 #define UART_STATE_TRANSIENT_MASK       0x74
 136 #define UART_DCD                        0x01
 137 #define UART_DSR                        0x02
 138 #define UART_BREAK_ERROR                0x04
 139 #define UART_RING                       0x08
 140 #define UART_FRAME_ERROR                0x10
 141 #define UART_PARITY_ERROR               0x20
 142 #define UART_OVERRUN_ERROR              0x40
 143 #define UART_CTS                        0x80
 144
 145
 146 enum pl2303_type {
 147         type_0,         /* don't know the difference between type 0 and */
 148         type_1,         /* type 1, until someone from prolific tells us... */
 149         HX,             /* HX version of the pl2303 chip */
 150 };
 151
 152 struct pl2303_private {
 153         spinlock_t lock;
 154         wait_queue_head_t delta_msr_wait;
 155         u8 line_control;
 156         u8 line_status;
 157         enum pl2303_type type;
 158 };
 159
 160 static int pl2303_vendor_read(__u16 value, __u16 index,
 161                 struct usb_serial *serial, unsigned char *buf)
 162 {
 163         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 164                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 165                         value, index, buf, 1, 100);
 166         dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", VENDOR_READ_REQUEST_TYPE,
 167                         VENDOR_READ_REQUEST, value, index, res, buf[0]);
 168         return res;
 169 }
 170
 171 static int pl2303_vendor_write(__u16 value, __u16 index,
 172                 struct usb_serial *serial)
 173 {
 174         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 175                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 176                         value, index, NULL, 0, 100);
 177         dbg("0x%x:0x%x:0x%x:0x%x  %d", VENDOR_WRITE_REQUEST_TYPE,
 178                         VENDOR_WRITE_REQUEST, value, index, res);
 179         return res;
 180 }
 181
 182 static int pl2303_startup(struct usb_serial *serial)
 183 {
 184         struct pl2303_private *priv;
 185         enum pl2303_type type = type_0;
 186         unsigned char *buf;
 187         int i;
 188
 189         buf = kmalloc(10, GFP_KERNEL);
 190         if (buf == NULL)
 191                 return -ENOMEM;
 192
 193         if (serial->dev->descriptor.bDeviceClass == 0x02)
 194                 type = type_0;
 195         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 196                 type = HX;
 197         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 198                 type = type_1;
 199         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 200                 type = type_1;
 201         dbg("device type: %d", type);
 202
 203         for (i = 0; i < serial->num_ports; ++i) {
 204                 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
 205                 if (!priv)
 206                         goto cleanup;
 207                 spin_lock_init(&priv->lock);
 208                 init_waitqueue_head(&priv->delta_msr_wait);
 209                 priv->type = type;
 210                 usb_set_serial_port_data(serial->port[i], priv);
 211         }
 212
 213         pl2303_vendor_read(0x8484, 0, serial, buf);
 214         pl2303_vendor_write(0x0404, 0, serial);
 215         pl2303_vendor_read(0x8484, 0, serial, buf);
 216         pl2303_vendor_read(0x8383, 0, serial, buf);
 217         pl2303_vendor_read(0x8484, 0, serial, buf);
 218         pl2303_vendor_write(0x0404, 1, serial);
 219         pl2303_vendor_read(0x8484, 0, serial, buf);
 220         pl2303_vendor_read(0x8383, 0, serial, buf);
 221         pl2303_vendor_write(0, 1, serial);
 222         pl2303_vendor_write(1, 0, serial);
 223         if (type == HX)
 224                 pl2303_vendor_write(2, 0x44, serial);
 225         else
 226                 pl2303_vendor_write(2, 0x24, serial);
 227
 228         kfree(buf);
 229         return 0;
 230
 231 cleanup:
 232         kfree(buf);
 233         for (--i; i >= 0; --i) {
 234                 priv = usb_get_serial_port_data(serial->port[i]);
 235                 kfree(priv);
 236                 usb_set_serial_port_data(serial->port[i], NULL);
 237         }
 238         return -ENOMEM;
 239 }
 240
 241 static int set_control_lines(struct usb_device *dev, u8 value)
 242 {
 243         int retval;
 244
 245         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 246                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 247                                  value, 0, NULL, 0, 100);
 248         dbg("%s - value = %d, retval = %d", __func__, value, retval);
 249         return retval;
 250 }
 251
 252 static void pl2303_set_termios(struct tty_struct *tty,
 253                 struct usb_serial_port *port, struct ktermios *old_termios)
 254 {
 255         struct usb_serial *serial = port->serial;
 256         struct pl2303_private *priv = usb_get_serial_port_data(port);
 257         unsigned long flags;
 258         unsigned int cflag;
 259         unsigned char *buf;
 260         int baud;
 261         int i;
 262         u8 control;
 263         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
 264                                  4800, 7200, 9600, 14400, 19200, 28800, 38400,
 265                                  57600, 115200, 230400, 460800, 614400,
 266                                  921600, 1228800, 2457600, 3000000, 6000000 };
 267         int baud_floor, baud_ceil;
 268         int k;
 269
 270         dbg("%s -  port %d", __func__, port->number);
 271
 272         /* The PL2303 is reported to lose bytes if you change
 273            serial settings even to the same values as before. Thus
 274            we actually need to filter in this specific case */
 275
 276         if (!tty_termios_hw_change(tty->termios, old_termios))
 277                 return;
 278
 279         cflag = tty->termios->c_cflag;
 280
 281         buf = kzalloc(7, GFP_KERNEL);
 282         if (!buf) {
 283                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 284                 /* Report back no change occurred */
 285                 *tty->termios = *old_termios;
 286                 return;
 287         }
 288
 289         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 290                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 291                             0, 0, buf, 7, 100);
 292         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 293             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 294
 295         if (cflag & CSIZE) {
 296                 switch (cflag & CSIZE) {
 297                 case CS5:
 298                         buf[6] = 5;
 299                         break;
 300                 case CS6:
 301                         buf[6] = 6;
 302                         break;
 303                 case CS7:
 304                         buf[6] = 7;
 305                         break;
 306                 default:
 307                 case CS8:
 308                         buf[6] = 8;
 309                         break;
 310                 }
 311                 dbg("%s - data bits = %d", __func__, buf[6]);
 312         }
 313
 314         /* For reference buf[0]:buf[3] baud rate value */
 315         /* NOTE: Only the values defined in baud_sup are supported !
 316          *       => if unsupported values are set, the PL2303 seems to use
 317          *          9600 baud (at least my PL2303X always does)
 318          */
 319         baud = tty_get_baud_rate(tty);
 320         dbg("%s - baud requested = %d", __func__, baud);
 321         if (baud) {
 322                 /* Set baudrate to nearest supported value */
 323                 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
 324                         if (baud_sup[k] / baud) {
 325                                 baud_ceil = baud_sup[k];
 326                                 if (k==0) {
 327                                         baud = baud_ceil;
 328                                 } else {
 329                                         baud_floor = baud_sup[k-1];
 330                                         if ((baud_ceil % baud)
 331                                             > (baud % baud_floor))
 332                                                 baud = baud_floor;
 333                                         else
 334                                                 baud = baud_ceil;
 335                                 }
 336                                 break;
 337                         }
 338                 }
 339                 if (baud > 1228800) {
 340                         /* type_0, type_1 only support up to 1228800 baud */
 341                         if (priv->type != HX)
 342                                 baud = 1228800;
 343                         else if (baud > 6000000)
 344                                 baud = 6000000;
 345                 }
 346                 dbg("%s - baud set = %d", __func__, baud);
 347                 if (baud <= 115200) {
 348                         buf[0] = baud & 0xff;
 349                         buf[1] = (baud >> 8) & 0xff;
 350                         buf[2] = (baud >> 16) & 0xff;
 351                         buf[3] = (baud >> 24) & 0xff;
 352                 } else {
 353                         /* apparently the formula for higher speeds is:
 354                          * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
 355                          */
 356                         unsigned tmp = 12*1000*1000*32 / baud;
 357                         buf[3] = 0x80;
 358                         buf[2] = 0;
 359                         buf[1] = (tmp >= 256);
 360                         while (tmp >= 256) {
 361                                 tmp >>= 2;
 362                                 buf[1] <<= 1;
 363                         }
 364                         buf[0] = tmp;
 365                 }
 366         }
 367
 368         /* For reference buf[4]=0 is 1 stop bits */
 369         /* For reference buf[4]=1 is 1.5 stop bits */
 370         /* For reference buf[4]=2 is 2 stop bits */
 371         if (cflag & CSTOPB) {
 372                 /* NOTE: Comply with "real" UARTs / RS232:
 373                  *       use 1.5 instead of 2 stop bits with 5 data bits
 374                  */
 375                 if ((cflag & CSIZE) == CS5) {
 376                         buf[4] = 1;
 377                         dbg("%s - stop bits = 1.5", __func__);
 378                 } else {
 379                         buf[4] = 2;
 380                         dbg("%s - stop bits = 2", __func__);
 381                 }
 382         } else {
 383                 buf[4] = 0;
 384                 dbg("%s - stop bits = 1", __func__);
 385         }
 386
 387         if (cflag & PARENB) {
 388                 /* For reference buf[5]=0 is none parity */
 389                 /* For reference buf[5]=1 is odd parity */
 390                 /* For reference buf[5]=2 is even parity */
 391                 /* For reference buf[5]=3 is mark parity */
 392                 /* For reference buf[5]=4 is space parity */
 393                 if (cflag & PARODD) {
 394                         if (cflag & CMSPAR) {
 395                                 buf[5] = 3;
 396                                 dbg("%s - parity = mark", __func__);
 397                         } else {
 398                                 buf[5] = 1;
 399                                 dbg("%s - parity = odd", __func__);
 400                         }
 401                 } else {
 402                         if (cflag & CMSPAR) {
 403                                 buf[5] = 4;
 404                                 dbg("%s - parity = space", __func__);
 405                         } else {
 406                                 buf[5] = 2;
 407                                 dbg("%s - parity = even", __func__);
 408                         }
 409                 }
 410         } else {
 411                 buf[5] = 0;
 412                 dbg("%s - parity = none", __func__);
 413         }
 414
 415         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 416                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 417                             0, 0, buf, 7, 100);
 418         dbg("0x21:0x20:0:0  %d", i);
 419
 420         /* change control lines if we are switching to or from B0 */
 421         spin_lock_irqsave(&priv->lock, flags);
 422         control = priv->line_control;
 423         if ((cflag & CBAUD) == B0)
 424                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 425         else
 426                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 427         if (control != priv->line_control) {
 428                 control = priv->line_control;
 429                 spin_unlock_irqrestore(&priv->lock, flags);
 430                 set_control_lines(serial->dev, control);
 431         } else {
 432                 spin_unlock_irqrestore(&priv->lock, flags);
 433         }
 434
 435         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 436
 437         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 438                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 439                             0, 0, buf, 7, 100);
 440         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 441              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 442
 443         if (cflag & CRTSCTS) {
 444                 if (priv->type == HX)
 445                         pl2303_vendor_write(0x0, 0x61, serial);
 446                 else
 447                         pl2303_vendor_write(0x0, 0x41, serial);
 448         } else {
 449                 pl2303_vendor_write(0x0, 0x0, serial);
 450         }
 451
 452         /* Save resulting baud rate */
 453         if (baud)
 454                 tty_encode_baud_rate(tty, baud, baud);
 455
 456         kfree(buf);
 457 }
 458
 459 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 460 {
 461         struct pl2303_private *priv = usb_get_serial_port_data(port);
 462         unsigned long flags;
 463         u8 control;
 464
 465         spin_lock_irqsave(&priv->lock, flags);
 466         /* Change DTR and RTS */
 467         if (on)
 468                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 469         else
 470                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 471         control = priv->line_control;
 472         spin_unlock_irqrestore(&priv->lock, flags);
 473         set_control_lines(port->serial->dev, control);
 474 }
 475
 476 static void pl2303_close(struct usb_serial_port *port)
 477 {
 478         dbg("%s - port %d", __func__, port->number);
 479
 480         usb_serial_generic_close(port);
 481         usb_kill_urb(port->interrupt_in_urb);
 482 }
 483
 484 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 485 {
 486         struct ktermios tmp_termios;
 487         struct usb_serial *serial = port->serial;
 488         struct pl2303_private *priv = usb_get_serial_port_data(port);
 489         int result;
 490
 491         dbg("%s -  port %d", __func__, port->number);
 492
 493         if (priv->type != HX) {
 494                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 495                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 496         } else {
 497                 /* reset upstream data pipes */
 498                 pl2303_vendor_write(8, 0, serial);
 499                 pl2303_vendor_write(9, 0, serial);
 500         }
 501
 502         /* Setup termios */
 503         if (tty)
 504                 pl2303_set_termios(tty, port, &tmp_termios);
 505
 506         dbg("%s - submitting interrupt urb", __func__);
 507         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 508         if (result) {
 509                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 510                         " error %d\n", __func__, result);
 511                 return result;
 512         }
 513
 514         result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
 515         if (result) {
 516                 usb_kill_urb(port->interrupt_in_urb);
 517                 return result;
 518         }
 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