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                         if (tmp > 256) {
 364                                 tmp %= 256;
 365                         }
 366                         buf[0] = tmp;
 367                 }
 368         }
 369
 370         /* For reference buf[4]=0 is 1 stop bits */
 371         /* For reference buf[4]=1 is 1.5 stop bits */
 372         /* For reference buf[4]=2 is 2 stop bits */
 373         if (cflag & CSTOPB) {
 374                 /* NOTE: Comply with "real" UARTs / RS232:
 375                  *       use 1.5 instead of 2 stop bits with 5 data bits
 376                  */
 377                 if ((cflag & CSIZE) == CS5) {
 378                         buf[4] = 1;
 379                         dbg("%s - stop bits = 1.5", __func__);
 380                 } else {
 381                         buf[4] = 2;
 382                         dbg("%s - stop bits = 2", __func__);
 383                 }
 384         } else {
 385                 buf[4] = 0;
 386                 dbg("%s - stop bits = 1", __func__);
 387         }
 388
 389         if (cflag & PARENB) {
 390                 /* For reference buf[5]=0 is none parity */
 391                 /* For reference buf[5]=1 is odd parity */
 392                 /* For reference buf[5]=2 is even parity */
 393                 /* For reference buf[5]=3 is mark parity */
 394                 /* For reference buf[5]=4 is space parity */
 395                 if (cflag & PARODD) {
 396                         if (cflag & CMSPAR) {
 397                                 buf[5] = 3;
 398                                 dbg("%s - parity = mark", __func__);
 399                         } else {
 400                                 buf[5] = 1;
 401                                 dbg("%s - parity = odd", __func__);
 402                         }
 403                 } else {
 404                         if (cflag & CMSPAR) {
 405                                 buf[5] = 4;
 406                                 dbg("%s - parity = space", __func__);
 407                         } else {
 408                                 buf[5] = 2;
 409                                 dbg("%s - parity = even", __func__);
 410                         }
 411                 }
 412         } else {
 413                 buf[5] = 0;
 414                 dbg("%s - parity = none", __func__);
 415         }
 416
 417         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 418                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 419                             0, 0, buf, 7, 100);
 420         dbg("0x21:0x20:0:0  %d", i);
 421
 422         /* change control lines if we are switching to or from B0 */
 423         spin_lock_irqsave(&priv->lock, flags);
 424         control = priv->line_control;
 425         if ((cflag & CBAUD) == B0)
 426                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 427         else if ((old_termios->c_cflag & CBAUD) == B0)
 428                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 429         if (control != priv->line_control) {
 430                 control = priv->line_control;
 431                 spin_unlock_irqrestore(&priv->lock, flags);
 432                 set_control_lines(serial->dev, control);
 433         } else {
 434                 spin_unlock_irqrestore(&priv->lock, flags);
 435         }
 436
 437         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 438
 439         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 440                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 441                             0, 0, buf, 7, 100);
 442         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 443              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 444
 445         if (cflag & CRTSCTS) {
 446                 if (priv->type == HX)
 447                         pl2303_vendor_write(0x0, 0x61, serial);
 448                 else
 449                         pl2303_vendor_write(0x0, 0x41, serial);
 450         } else {
 451                 pl2303_vendor_write(0x0, 0x0, serial);
 452         }
 453
 454         /* Save resulting baud rate */
 455         if (baud)
 456                 tty_encode_baud_rate(tty, baud, baud);
 457
 458         kfree(buf);
 459 }
 460
 461 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 462 {
 463         struct pl2303_private *priv = usb_get_serial_port_data(port);
 464         unsigned long flags;
 465         u8 control;
 466
 467         spin_lock_irqsave(&priv->lock, flags);
 468         /* Change DTR and RTS */
 469         if (on)
 470                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 471         else
 472                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 473         control = priv->line_control;
 474         spin_unlock_irqrestore(&priv->lock, flags);
 475         set_control_lines(port->serial->dev, control);
 476 }
 477
 478 static void pl2303_close(struct usb_serial_port *port)
 479 {
 480         dbg("%s - port %d", __func__, port->number);
 481
 482         usb_serial_generic_close(port);
 483         usb_kill_urb(port->interrupt_in_urb);
 484 }
 485
 486 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 487 {
 488         struct ktermios tmp_termios;
 489         struct usb_serial *serial = port->serial;
 490         struct pl2303_private *priv = usb_get_serial_port_data(port);
 491         int result;
 492
 493         dbg("%s -  port %d", __func__, port->number);
 494
 495         if (priv->type != HX) {
 496                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 497                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 498         } else {
 499                 /* reset upstream data pipes */
 500                 pl2303_vendor_write(8, 0, serial);
 501                 pl2303_vendor_write(9, 0, serial);
 502         }
 503
 504         /* Setup termios */
 505         if (tty)
 506                 pl2303_set_termios(tty, port, &tmp_termios);
 507
 508         dbg("%s - submitting read urb", __func__);
 509         result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
 510         if (result) {
 511                 pl2303_close(port);
 512                 return -EPROTO;
 513         }
 514
 515         dbg("%s - submitting interrupt urb", __func__);
 516         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 517         if (result) {
 518                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 519                         " error %d\n", __func__, result);
 520                 pl2303_close(port);
 521                 return -EPROTO;
 522         }
 523         port->port.drain_delay = 256;
 524         return 0;
 525 }
 526
 527 static int pl2303_tiocmset(struct tty_struct *tty,
 528                            unsigned int set, unsigned int clear)
 529 {
 530         struct usb_serial_port *port = tty->driver_data;
 531         struct pl2303_private *priv = usb_get_serial_port_data(port);
 532         unsigned long flags;
 533         u8 control;
 534
 535         if (!usb_get_intfdata(port->serial->interface))
 536                 return -ENODEV;
 537
 538         spin_lock_irqsave(&priv->lock, flags);
 539         if (set & TIOCM_RTS)
 540                 priv->line_control |= CONTROL_RTS;
 541         if (set & TIOCM_DTR)
 542                 priv->line_control |= CONTROL_DTR;
 543         if (clear & TIOCM_RTS)
 544                 priv->line_control &= ~CONTROL_RTS;
 545         if (clear & TIOCM_DTR)
 546                 priv->line_control &= ~CONTROL_DTR;
 547         control = priv->line_control;
 548         spin_unlock_irqrestore(&priv->lock, flags);
 549
 550         return set_control_lines(port->serial->dev, control);
 551 }
 552
 553 static int pl2303_tiocmget(struct tty_struct *tty)
 554 {
 555         struct usb_serial_port *port = tty->driver_data;
 556         struct pl2303_private *priv = usb_get_serial_port_data(port);
 557         unsigned long flags;
 558         unsigned int mcr;
 559         unsigned int status;
 560         unsigned int result;
 561
 562         dbg("%s (%d)", __func__, port->number);
 563
 564         if (!usb_get_intfdata(port->serial->interface))
 565                 return -ENODEV;
 566
 567         spin_lock_irqsave(&priv->lock, flags);
 568         mcr = priv->line_control;
 569         status = priv->line_status;
 570         spin_unlock_irqrestore(&priv->lock, flags);
 571
 572         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 573                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 574                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 575                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 576                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 577                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 578
 579         dbg("%s - result = %x", __func__, result);
 580
 581         return result;
 582 }
 583
 584 static int pl2303_carrier_raised(struct usb_serial_port *port)
 585 {
 586         struct pl2303_private *priv = usb_get_serial_port_data(port);
 587         if (priv->line_status & UART_DCD)
 588                 return 1;
 589         return 0;
 590 }
 591
 592 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 593 {
 594         struct pl2303_private *priv = usb_get_serial_port_data(port);
 595         unsigned long flags;
 596         unsigned int prevstatus;
 597         unsigned int status;
 598         unsigned int changed;
 599
 600         spin_lock_irqsave(&priv->lock, flags);
 601         prevstatus = priv->line_status;
 602         spin_unlock_irqrestore(&priv->lock, flags);
 603
 604         while (1) {
 605                 interruptible_sleep_on(&priv->delta_msr_wait);
 606                 /* see if a signal did it */
 607                 if (signal_pending(current))
 608                         return -ERESTARTSYS;
 609
 610                 spin_lock_irqsave(&priv->lock, flags);
 611                 status = priv->line_status;
 612                 spin_unlock_irqrestore(&priv->lock, flags);
 613
 614                 changed = prevstatus ^ status;
 615
 616                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 617                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 618                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 619                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 620                         return 0;
 621                 }
 622                 prevstatus = status;
 623         }
 624         /* NOTREACHED */
 625         return 0;
 626 }
 627
 628 static int pl2303_ioctl(struct tty_struct *tty,
 629                         unsigned int cmd, unsigned long arg)
 630 {
 631         struct serial_struct ser;
 632         struct usb_serial_port *port = tty->driver_data;
 633         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 634
 635         switch (cmd) {
 636         case TIOCGSERIAL:
 637                 memset(&ser, 0, sizeof ser);
 638                 ser.type = PORT_16654;
 639                 ser.line = port->serial->minor;
 640                 ser.port = port->number;
 641                 ser.baud_base = 460800;
 642
 643                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 644                         return -EFAULT;
 645
 646                 return 0;
 647
 648         case TIOCMIWAIT:
 649                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 650                 return wait_modem_info(port, arg);
 651         default:
 652                 dbg("%s not supported = 0x%04x", __func__, cmd);
 653                 break;
 654         }
 655         return -ENOIOCTLCMD;
 656 }
 657
 658 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 659 {
 660         struct usb_serial_port *port = tty->driver_data;
 661         struct usb_serial *serial = port->serial;
 662         u16 state;
 663         int result;
 664
 665         dbg("%s - port %d", __func__, port->number);
 666
 667         if (break_state == 0)
 668                 state = BREAK_OFF;
 669         else
 670                 state = BREAK_ON;
 671         dbg("%s - turning break %s", __func__,
 672                         state == BREAK_OFF ? "off" : "on");
 673
 674         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 675                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 676                                  0, NULL, 0, 100);
 677         if (result)
 678                 dbg("%s - error sending break = %d", __func__, result);
 679 }
 680
 681 static void pl2303_release(struct usb_serial *serial)
 682 {
 683         int i;
 684         struct pl2303_private *priv;
 685
 686         dbg("%s", __func__);
 687
 688         for (i = 0; i < serial->num_ports; ++i) {
 689                 priv = usb_get_serial_port_data(serial->port[i]);
 690                 kfree(priv);
 691         }
 692 }
 693
 694 static void pl2303_update_line_status(struct usb_serial_port *port,
 695                                       unsigned char *data,
 696                                       unsigned int actual_length)
 697 {
 698
 699         struct pl2303_private *priv = usb_get_serial_port_data(port);
 700         struct tty_struct *tty;
 701         unsigned long flags;
 702         u8 status_idx = UART_STATE;
 703         u8 length = UART_STATE + 1;
 704         u8 prev_line_status;
 705         u16 idv, idp;
 706
 707         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 708         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 709
 710
 711         if (idv == SIEMENS_VENDOR_ID) {
 712                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 713                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 714                     idp == SIEMENS_PRODUCT_ID_X75) {
 715
 716                         length = 1;
 717                         status_idx = 0;
 718                 }
 719         }
 720
 721         if (actual_length < length)
 722                 return;
 723
 724         /* Save off the uart status for others to look at */
 725         spin_lock_irqsave(&priv->lock, flags);
 726         prev_line_status = priv->line_status;
 727         priv->line_status = data[status_idx];
 728         spin_unlock_irqrestore(&priv->lock, flags);
 729         if (priv->line_status & UART_BREAK_ERROR)
 730                 usb_serial_handle_break(port);
 731         wake_up_interruptible(&priv->delta_msr_wait);
 732
 733         tty = tty_port_tty_get(&port->port);
 734         if (!tty)
 735                 return;
 736         if ((priv->line_status ^ prev_line_status) & UART_DCD)
 737                 usb_serial_handle_dcd_change(port, tty,
 738                                 priv->line_status & UART_DCD);
 739         tty_kref_put(tty);
 740 }
 741
 742 static void pl2303_read_int_callback(struct urb *urb)
 743 {
 744         struct usb_serial_port *port =  urb->context;
 745         unsigned char *data = urb->transfer_buffer;
 746         unsigned int actual_length = urb->actual_length;
 747         int status = urb->status;
 748         int retval;
 749
 750         dbg("%s (%d)", __func__, port->number);
 751
 752         switch (status) {
 753         case 0:
 754                 /* success */
 755                 break;
 756         case -ECONNRESET:
 757         case -ENOENT:
 758         case -ESHUTDOWN:
 759                 /* this urb is terminated, clean up */
 760                 dbg("%s - urb shutting down with status: %d", __func__,
 761                     status);
 762                 return;
 763         default:
 764                 dbg("%s - nonzero urb status received: %d", __func__,
 765                     status);
 766                 goto exit;
 767         }
 768
 769         usb_serial_debug_data(debug, &port->dev, __func__,
 770                               urb->actual_length, urb->transfer_buffer);
 771
 772         pl2303_update_line_status(port, data, actual_length);
 773
 774 exit:
 775         retval = usb_submit_urb(urb, GFP_ATOMIC);
 776         if (retval)
 777                 dev_err(&urb->dev->dev,
 778                         "%s - usb_submit_urb failed with result %d\n",
 779                         __func__, retval);
 780 }
 781
 782 static void pl2303_process_read_urb(struct urb *urb)
 783 {
 784         struct usb_serial_port *port = urb->context;
 785         struct pl2303_private *priv = usb_get_serial_port_data(port);
 786         struct tty_struct *tty;
 787         unsigned char *data = urb->transfer_buffer;
 788         char tty_flag = TTY_NORMAL;
 789         unsigned long flags;
 790         u8 line_status;
 791         int i;
 792
 793         /* update line status */
 794         spin_lock_irqsave(&priv->lock, flags);
 795         line_status = priv->line_status;
 796         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 797         spin_unlock_irqrestore(&priv->lock, flags);
 798         wake_up_interruptible(&priv->delta_msr_wait);
 799
 800         if (!urb->actual_length)
 801                 return;
 802
 803         tty = tty_port_tty_get(&port->port);
 804         if (!tty)
 805                 return;
 806
 807         /* break takes precedence over parity, */
 808         /* which takes precedence over framing errors */
 809         if (line_status & UART_BREAK_ERROR)
 810                 tty_flag = TTY_BREAK;
 811         else if (line_status & UART_PARITY_ERROR)
 812                 tty_flag = TTY_PARITY;
 813         else if (line_status & UART_FRAME_ERROR)
 814                 tty_flag = TTY_FRAME;
 815         dbg("%s - tty_flag = %d", __func__, tty_flag);
 816
 817         /* overrun is special, not associated with a char */
 818         if (line_status & UART_OVERRUN_ERROR)
 819                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 820
 821         if (port->port.console && port->sysrq) {
 822                 for (i = 0; i < urb->actual_length; ++i)
 823                         if (!usb_serial_handle_sysrq_char(port, data[i]))
 824                                 tty_insert_flip_char(tty, data[i], tty_flag);
 825         } else {
 826                 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
 827                                                         urb->actual_length);
 828         }
 829
 830         tty_flip_buffer_push(tty);
 831         tty_kref_put(tty);
 832 }
 833
 834 /* All of the device info needed for the PL2303 SIO serial converter */
 835 static struct usb_serial_driver pl2303_device = {
 836         .driver = {
 837                 .owner =        THIS_MODULE,
 838                 .name =         "pl2303",
 839         },
 840         .id_table =             id_table,
 841         .usb_driver =           &pl2303_driver,
 842         .num_ports =            1,
 843         .bulk_in_size =         256,
 844         .bulk_out_size =        256,
 845         .open =                 pl2303_open,
 846         .close =                pl2303_close,
 847         .dtr_rts =              pl2303_dtr_rts,
 848         .carrier_raised =       pl2303_carrier_raised,
 849         .ioctl =                pl2303_ioctl,
 850         .break_ctl =            pl2303_break_ctl,
 851         .set_termios =          pl2303_set_termios,
 852         .tiocmget =             pl2303_tiocmget,
 853         .tiocmset =             pl2303_tiocmset,
 854         .process_read_urb =     pl2303_process_read_urb,
 855         .read_int_callback =    pl2303_read_int_callback,
 856         .attach =               pl2303_startup,
 857         .release =              pl2303_release,
 858 };
 859
 860 static int __init pl2303_init(void)
 861 {
 862         int retval;
 863
 864         retval = usb_serial_register(&pl2303_device);
 865         if (retval)
 866                 goto failed_usb_serial_register;
 867         retval = usb_register(&pl2303_driver);
 868         if (retval)
 869                 goto failed_usb_register;
 870         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 871         return 0;
 872 failed_usb_register:
 873         usb_serial_deregister(&pl2303_device);
 874 failed_usb_serial_register:
 875         return retval;
 876 }
 877
 878 static void __exit pl2303_exit(void)
 879 {
 880         usb_deregister(&pl2303_driver);
 881         usb_serial_deregister(&pl2303_device);
 882 }
 883
 884 module_init(pl2303_init);
 885 module_exit(pl2303_exit);
 886
 887 MODULE_DESCRIPTION(DRIVER_DESC);
 888 MODULE_LICENSE("GPL");
 889
 890 module_param(debug, bool, S_IRUGO | S_IWUSR);
 891 MODULE_PARM_DESC(debug, "Debug enabled or not");
 892