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