drivers/usb/serial/pl2303.c

   1 /*
   2  * Prolific PL2303 USB to serial adaptor driver
   3  *
   4  * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2003 IBM Corp.
   6  *
   7  * Original driver for 2.2.x by anonymous
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License version
  11  *      2 as published by the Free Software Foundation.
  12  *
  13  * See Documentation/usb/usb-serial.txt for more information on using this
  14  * driver
  15  *
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/errno.h>
  20 #include <linux/init.h>
  21 #include <linux/slab.h>
  22 #include <linux/tty.h>
  23 #include <linux/tty_driver.h>
  24 #include <linux/tty_flip.h>
  25 #include <linux/serial.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/usb.h>
  31 #include <linux/usb/serial.h>
  32 #include "pl2303.h"
  33
  34 /*
  35  * Version Information
  36  */
  37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
  38
  39 static int debug;
  40
  41 #define PL2303_CLOSING_WAIT     (30*HZ)
  42
  43 static const struct usb_device_id id_table[] = {
  44         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
  45         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  46         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  47         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  48         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  49         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
  50         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
  51         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
  52         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
  53         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
  54         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  55         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  56         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
  57         { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  58         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  59         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  60         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  61         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  62         { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  63         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  64         { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  65         { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  66         { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  67         { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  68         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  69         { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
  70         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
  71         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
  72         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
  73         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
  74         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
  75         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  76         { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  77         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  78         { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  79         { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  80         { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  81         { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  82         { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  83         { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
  84         { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  85         { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  86         { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  87         { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  88         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  89         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
  90         { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
  91         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
  92         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
  93         { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
  94         { USB_DEVICE(WINCHIPHEAD_VENDOR_ID, WINCHIPHEAD_USBSER_PRODUCT_ID) },
  95         { }                                     /* 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                 buf[0] = baud & 0xff;
 347                 buf[1] = (baud >> 8) & 0xff;
 348                 buf[2] = (baud >> 16) & 0xff;
 349                 buf[3] = (baud >> 24) & 0xff;
 350         }
 351
 352         /* For reference buf[4]=0 is 1 stop bits */
 353         /* For reference buf[4]=1 is 1.5 stop bits */
 354         /* For reference buf[4]=2 is 2 stop bits */
 355         if (cflag & CSTOPB) {
 356                 /* NOTE: Comply with "real" UARTs / RS232:
 357                  *       use 1.5 instead of 2 stop bits with 5 data bits
 358                  */
 359                 if ((cflag & CSIZE) == CS5) {
 360                         buf[4] = 1;
 361                         dbg("%s - stop bits = 1.5", __func__);
 362                 } else {
 363                         buf[4] = 2;
 364                         dbg("%s - stop bits = 2", __func__);
 365                 }
 366         } else {
 367                 buf[4] = 0;
 368                 dbg("%s - stop bits = 1", __func__);
 369         }
 370
 371         if (cflag & PARENB) {
 372                 /* For reference buf[5]=0 is none parity */
 373                 /* For reference buf[5]=1 is odd parity */
 374                 /* For reference buf[5]=2 is even parity */
 375                 /* For reference buf[5]=3 is mark parity */
 376                 /* For reference buf[5]=4 is space parity */
 377                 if (cflag & PARODD) {
 378                         if (cflag & CMSPAR) {
 379                                 buf[5] = 3;
 380                                 dbg("%s - parity = mark", __func__);
 381                         } else {
 382                                 buf[5] = 1;
 383                                 dbg("%s - parity = odd", __func__);
 384                         }
 385                 } else {
 386                         if (cflag & CMSPAR) {
 387                                 buf[5] = 4;
 388                                 dbg("%s - parity = space", __func__);
 389                         } else {
 390                                 buf[5] = 2;
 391                                 dbg("%s - parity = even", __func__);
 392                         }
 393                 }
 394         } else {
 395                 buf[5] = 0;
 396                 dbg("%s - parity = none", __func__);
 397         }
 398
 399         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 400                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 401                             0, 0, buf, 7, 100);
 402         dbg("0x21:0x20:0:0  %d", i);
 403
 404         /* change control lines if we are switching to or from B0 */
 405         spin_lock_irqsave(&priv->lock, flags);
 406         control = priv->line_control;
 407         if ((cflag & CBAUD) == B0)
 408                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 409         else
 410                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 411         if (control != priv->line_control) {
 412                 control = priv->line_control;
 413                 spin_unlock_irqrestore(&priv->lock, flags);
 414                 set_control_lines(serial->dev, control);
 415         } else {
 416                 spin_unlock_irqrestore(&priv->lock, flags);
 417         }
 418
 419         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 420
 421         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 422                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 423                             0, 0, buf, 7, 100);
 424         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 425              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 426
 427         if (cflag & CRTSCTS) {
 428                 if (priv->type == HX)
 429                         pl2303_vendor_write(0x0, 0x61, serial);
 430                 else
 431                         pl2303_vendor_write(0x0, 0x41, serial);
 432         } else {
 433                 pl2303_vendor_write(0x0, 0x0, serial);
 434         }
 435
 436         /* Save resulting baud rate */
 437         if (baud)
 438                 tty_encode_baud_rate(tty, baud, baud);
 439
 440         kfree(buf);
 441 }
 442
 443 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 444 {
 445         struct pl2303_private *priv = usb_get_serial_port_data(port);
 446         unsigned long flags;
 447         u8 control;
 448
 449         spin_lock_irqsave(&priv->lock, flags);
 450         /* Change DTR and RTS */
 451         if (on)
 452                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 453         else
 454                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 455         control = priv->line_control;
 456         spin_unlock_irqrestore(&priv->lock, flags);
 457         set_control_lines(port->serial->dev, control);
 458 }
 459
 460 static void pl2303_close(struct usb_serial_port *port)
 461 {
 462         dbg("%s - port %d", __func__, port->number);
 463
 464         usb_serial_generic_close(port);
 465         usb_kill_urb(port->interrupt_in_urb);
 466 }
 467
 468 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 469 {
 470         struct ktermios tmp_termios;
 471         struct usb_serial *serial = port->serial;
 472         struct pl2303_private *priv = usb_get_serial_port_data(port);
 473         int result;
 474
 475         dbg("%s -  port %d", __func__, port->number);
 476
 477         if (priv->type != HX) {
 478                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 479                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 480         } else {
 481                 /* reset upstream data pipes */
 482                 pl2303_vendor_write(8, 0, serial);
 483                 pl2303_vendor_write(9, 0, serial);
 484         }
 485
 486         /* Setup termios */
 487         if (tty)
 488                 pl2303_set_termios(tty, port, &tmp_termios);
 489
 490         dbg("%s - submitting read urb", __func__);
 491         result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
 492         if (result) {
 493                 pl2303_close(port);
 494                 return -EPROTO;
 495         }
 496
 497         dbg("%s - submitting interrupt urb", __func__);
 498         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 499         if (result) {
 500                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 501                         " error %d\n", __func__, result);
 502                 pl2303_close(port);
 503                 return -EPROTO;
 504         }
 505         port->port.drain_delay = 256;
 506         return 0;
 507 }
 508
 509 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 510                            unsigned int set, unsigned int clear)
 511 {
 512         struct usb_serial_port *port = tty->driver_data;
 513         struct pl2303_private *priv = usb_get_serial_port_data(port);
 514         unsigned long flags;
 515         u8 control;
 516
 517         if (!usb_get_intfdata(port->serial->interface))
 518                 return -ENODEV;
 519
 520         spin_lock_irqsave(&priv->lock, flags);
 521         if (set & TIOCM_RTS)
 522                 priv->line_control |= CONTROL_RTS;
 523         if (set & TIOCM_DTR)
 524                 priv->line_control |= CONTROL_DTR;
 525         if (clear & TIOCM_RTS)
 526                 priv->line_control &= ~CONTROL_RTS;
 527         if (clear & TIOCM_DTR)
 528                 priv->line_control &= ~CONTROL_DTR;
 529         control = priv->line_control;
 530         spin_unlock_irqrestore(&priv->lock, flags);
 531
 532         return set_control_lines(port->serial->dev, control);
 533 }
 534
 535 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 536 {
 537         struct usb_serial_port *port = tty->driver_data;
 538         struct pl2303_private *priv = usb_get_serial_port_data(port);
 539         unsigned long flags;
 540         unsigned int mcr;
 541         unsigned int status;
 542         unsigned int result;
 543
 544         dbg("%s (%d)", __func__, port->number);
 545
 546         if (!usb_get_intfdata(port->serial->interface))
 547                 return -ENODEV;
 548
 549         spin_lock_irqsave(&priv->lock, flags);
 550         mcr = priv->line_control;
 551         status = priv->line_status;
 552         spin_unlock_irqrestore(&priv->lock, flags);
 553
 554         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 555                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 556                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 557                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 558                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 559                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 560
 561         dbg("%s - result = %x", __func__, result);
 562
 563         return result;
 564 }
 565
 566 static int pl2303_carrier_raised(struct usb_serial_port *port)
 567 {
 568         struct pl2303_private *priv = usb_get_serial_port_data(port);
 569         if (priv->line_status & UART_DCD)
 570                 return 1;
 571         return 0;
 572 }
 573
 574 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 575 {
 576         struct pl2303_private *priv = usb_get_serial_port_data(port);
 577         unsigned long flags;
 578         unsigned int prevstatus;
 579         unsigned int status;
 580         unsigned int changed;
 581
 582         spin_lock_irqsave(&priv->lock, flags);
 583         prevstatus = priv->line_status;
 584         spin_unlock_irqrestore(&priv->lock, flags);
 585
 586         while (1) {
 587                 interruptible_sleep_on(&priv->delta_msr_wait);
 588                 /* see if a signal did it */
 589                 if (signal_pending(current))
 590                         return -ERESTARTSYS;
 591
 592                 spin_lock_irqsave(&priv->lock, flags);
 593                 status = priv->line_status;
 594                 spin_unlock_irqrestore(&priv->lock, flags);
 595
 596                 changed = prevstatus ^ status;
 597
 598                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 599                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 600                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 601                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 602                         return 0;
 603                 }
 604                 prevstatus = status;
 605         }
 606         /* NOTREACHED */
 607         return 0;
 608 }
 609
 610 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 611                         unsigned int cmd, unsigned long arg)
 612 {
 613         struct serial_struct ser;
 614         struct usb_serial_port *port = tty->driver_data;
 615         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 616
 617         switch (cmd) {
 618         case TIOCGSERIAL:
 619                 memset(&ser, 0, sizeof ser);
 620                 ser.type = PORT_16654;
 621                 ser.line = port->serial->minor;
 622                 ser.port = port->number;
 623                 ser.baud_base = 460800;
 624
 625                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 626                         return -EFAULT;
 627
 628                 return 0;
 629
 630         case TIOCMIWAIT:
 631                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 632                 return wait_modem_info(port, arg);
 633         default:
 634                 dbg("%s not supported = 0x%04x", __func__, cmd);
 635                 break;
 636         }
 637         return -ENOIOCTLCMD;
 638 }
 639
 640 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 641 {
 642         struct usb_serial_port *port = tty->driver_data;
 643         struct usb_serial *serial = port->serial;
 644         u16 state;
 645         int result;
 646
 647         dbg("%s - port %d", __func__, port->number);
 648
 649         if (break_state == 0)
 650                 state = BREAK_OFF;
 651         else
 652                 state = BREAK_ON;
 653         dbg("%s - turning break %s", __func__,
 654                         state == BREAK_OFF ? "off" : "on");
 655
 656         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 657                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 658                                  0, NULL, 0, 100);
 659         if (result)
 660                 dbg("%s - error sending break = %d", __func__, result);
 661 }
 662
 663 static void pl2303_release(struct usb_serial *serial)
 664 {
 665         int i;
 666         struct pl2303_private *priv;
 667
 668         dbg("%s", __func__);
 669
 670         for (i = 0; i < serial->num_ports; ++i) {
 671                 priv = usb_get_serial_port_data(serial->port[i]);
 672                 kfree(priv);
 673         }
 674 }
 675
 676 static void pl2303_update_line_status(struct usb_serial_port *port,
 677                                       unsigned char *data,
 678                                       unsigned int actual_length)
 679 {
 680
 681         struct pl2303_private *priv = usb_get_serial_port_data(port);
 682         struct tty_struct *tty;
 683         unsigned long flags;
 684         u8 status_idx = UART_STATE;
 685         u8 length = UART_STATE + 1;
 686         u8 prev_line_status;
 687         u16 idv, idp;
 688
 689         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 690         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 691
 692
 693         if (idv == SIEMENS_VENDOR_ID) {
 694                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 695                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 696                     idp == SIEMENS_PRODUCT_ID_X75) {
 697
 698                         length = 1;
 699                         status_idx = 0;
 700                 }
 701         }
 702
 703         if (actual_length < length)
 704                 return;
 705
 706         /* Save off the uart status for others to look at */
 707         spin_lock_irqsave(&priv->lock, flags);
 708         prev_line_status = priv->line_status;
 709         priv->line_status = data[status_idx];
 710         spin_unlock_irqrestore(&priv->lock, flags);
 711         if (priv->line_status & UART_BREAK_ERROR)
 712                 usb_serial_handle_break(port);
 713         wake_up_interruptible(&priv->delta_msr_wait);
 714
 715         tty = tty_port_tty_get(&port->port);
 716         if (!tty)
 717                 return;
 718         if ((priv->line_status ^ prev_line_status) & UART_DCD)
 719                 usb_serial_handle_dcd_change(port, tty,
 720                                 priv->line_status & UART_DCD);
 721         tty_kref_put(tty);
 722 }
 723
 724 static void pl2303_read_int_callback(struct urb *urb)
 725 {
 726         struct usb_serial_port *port =  urb->context;
 727         unsigned char *data = urb->transfer_buffer;
 728         unsigned int actual_length = urb->actual_length;
 729         int status = urb->status;
 730         int retval;
 731
 732         dbg("%s (%d)", __func__, port->number);
 733
 734         switch (status) {
 735         case 0:
 736                 /* success */
 737                 break;
 738         case -ECONNRESET:
 739         case -ENOENT:
 740         case -ESHUTDOWN:
 741                 /* this urb is terminated, clean up */
 742                 dbg("%s - urb shutting down with status: %d", __func__,
 743                     status);
 744                 return;
 745         default:
 746                 dbg("%s - nonzero urb status received: %d", __func__,
 747                     status);
 748                 goto exit;
 749         }
 750
 751         usb_serial_debug_data(debug, &port->dev, __func__,
 752                               urb->actual_length, urb->transfer_buffer);
 753
 754         pl2303_update_line_status(port, data, actual_length);
 755
 756 exit:
 757         retval = usb_submit_urb(urb, GFP_ATOMIC);
 758         if (retval)
 759                 dev_err(&urb->dev->dev,
 760                         "%s - usb_submit_urb failed with result %d\n",
 761                         __func__, retval);
 762 }
 763
 764 static void pl2303_process_read_urb(struct urb *urb)
 765 {
 766         struct usb_serial_port *port = urb->context;
 767         struct pl2303_private *priv = usb_get_serial_port_data(port);
 768         struct tty_struct *tty;
 769         unsigned char *data = urb->transfer_buffer;
 770         char tty_flag = TTY_NORMAL;
 771         unsigned long flags;
 772         u8 line_status;
 773         int i;
 774
 775         /* update line status */
 776         spin_lock_irqsave(&priv->lock, flags);
 777         line_status = priv->line_status;
 778         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 779         spin_unlock_irqrestore(&priv->lock, flags);
 780         wake_up_interruptible(&priv->delta_msr_wait);
 781
 782         if (!urb->actual_length)
 783                 return;
 784
 785         tty = tty_port_tty_get(&port->port);
 786         if (!tty)
 787                 return;
 788
 789         /* break takes precedence over parity, */
 790         /* which takes precedence over framing errors */
 791         if (line_status & UART_BREAK_ERROR)
 792                 tty_flag = TTY_BREAK;
 793         else if (line_status & UART_PARITY_ERROR)
 794                 tty_flag = TTY_PARITY;
 795         else if (line_status & UART_FRAME_ERROR)
 796                 tty_flag = TTY_FRAME;
 797         dbg("%s - tty_flag = %d", __func__, tty_flag);
 798
 799         /* overrun is special, not associated with a char */
 800         if (line_status & UART_OVERRUN_ERROR)
 801                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 802
 803         if (port->port.console && port->sysrq) {
 804                 for (i = 0; i < urb->actual_length; ++i)
 805                         if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
 806                                 tty_insert_flip_char(tty, data[i], tty_flag);
 807         } else {
 808                 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
 809                                                         urb->actual_length);
 810         }
 811
 812         tty_flip_buffer_push(tty);
 813         tty_kref_put(tty);
 814 }
 815
 816 /* All of the device info needed for the PL2303 SIO serial converter */
 817 static struct usb_serial_driver pl2303_device = {
 818         .driver = {
 819                 .owner =        THIS_MODULE,
 820                 .name =         "pl2303",
 821         },
 822         .id_table =             id_table,
 823         .usb_driver =           &pl2303_driver,
 824         .num_ports =            1,
 825         .bulk_in_size =         256,
 826         .bulk_out_size =        256,
 827         .open =                 pl2303_open,
 828         .close =                pl2303_close,
 829         .dtr_rts =              pl2303_dtr_rts,
 830         .carrier_raised =       pl2303_carrier_raised,
 831         .ioctl =                pl2303_ioctl,
 832         .break_ctl =            pl2303_break_ctl,
 833         .set_termios =          pl2303_set_termios,
 834         .tiocmget =             pl2303_tiocmget,
 835         .tiocmset =             pl2303_tiocmset,
 836         .process_read_urb =     pl2303_process_read_urb,
 837         .read_int_callback =    pl2303_read_int_callback,
 838         .attach =               pl2303_startup,
 839         .release =              pl2303_release,
 840 };
 841
 842 static int __init pl2303_init(void)
 843 {
 844         int retval;
 845
 846         retval = usb_serial_register(&pl2303_device);
 847         if (retval)
 848                 goto failed_usb_serial_register;
 849         retval = usb_register(&pl2303_driver);
 850         if (retval)
 851                 goto failed_usb_register;
 852         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 853         return 0;
 854 failed_usb_register:
 855         usb_serial_deregister(&pl2303_device);
 856 failed_usb_serial_register:
 857         return retval;
 858 }
 859
 860 static void __exit pl2303_exit(void)
 861 {
 862         usb_deregister(&pl2303_driver);
 863         usb_serial_deregister(&pl2303_device);
 864 }
 865
 866 module_init(pl2303_init);
 867 module_exit(pl2303_exit);
 868
 869 MODULE_DESCRIPTION(DRIVER_DESC);
 870 MODULE_LICENSE("GPL");
 871
 872 module_param(debug, bool, S_IRUGO | S_IWUSR);
 873 MODULE_PARM_DESC(debug, "Debug enabled or not");
 874