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