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