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(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
  90         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
  91         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
  92         { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
  93         { }                                     /* Terminating entry */
  94 };
  95
  96 MODULE_DEVICE_TABLE(usb, id_table);
  97
  98 static struct usb_driver pl2303_driver = {
  99         .name =         "pl2303",
 100         .probe =        usb_serial_probe,
 101         .disconnect =   usb_serial_disconnect,
 102         .id_table =     id_table,
 103         .suspend =      usb_serial_suspend,
 104         .resume =       usb_serial_resume,
 105         .no_dynamic_id =        1,
 106         .supports_autosuspend = 1,
 107 };
 108
 109 #define SET_LINE_REQUEST_TYPE           0x21
 110 #define SET_LINE_REQUEST                0x20
 111
 112 #define SET_CONTROL_REQUEST_TYPE        0x21
 113 #define SET_CONTROL_REQUEST             0x22
 114 #define CONTROL_DTR                     0x01
 115 #define CONTROL_RTS                     0x02
 116
 117 #define BREAK_REQUEST_TYPE              0x21
 118 #define BREAK_REQUEST                   0x23
 119 #define BREAK_ON                        0xffff
 120 #define BREAK_OFF                       0x0000
 121
 122 #define GET_LINE_REQUEST_TYPE           0xa1
 123 #define GET_LINE_REQUEST                0x21
 124
 125 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 126 #define VENDOR_WRITE_REQUEST            0x01
 127
 128 #define VENDOR_READ_REQUEST_TYPE        0xc0
 129 #define VENDOR_READ_REQUEST             0x01
 130
 131 #define UART_STATE                      0x08
 132 #define UART_STATE_TRANSIENT_MASK       0x74
 133 #define UART_DCD                        0x01
 134 #define UART_DSR                        0x02
 135 #define UART_BREAK_ERROR                0x04
 136 #define UART_RING                       0x08
 137 #define UART_FRAME_ERROR                0x10
 138 #define UART_PARITY_ERROR               0x20
 139 #define UART_OVERRUN_ERROR              0x40
 140 #define UART_CTS                        0x80
 141
 142
 143 enum pl2303_type {
 144         type_0,         /* don't know the difference between type 0 and */
 145         type_1,         /* type 1, until someone from prolific tells us... */
 146         HX,             /* HX version of the pl2303 chip */
 147 };
 148
 149 struct pl2303_private {
 150         spinlock_t lock;
 151         wait_queue_head_t delta_msr_wait;
 152         u8 line_control;
 153         u8 line_status;
 154         enum pl2303_type type;
 155 };
 156
 157 static int pl2303_vendor_read(__u16 value, __u16 index,
 158                 struct usb_serial *serial, unsigned char *buf)
 159 {
 160         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 161                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 162                         value, index, buf, 1, 100);
 163         dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", VENDOR_READ_REQUEST_TYPE,
 164                         VENDOR_READ_REQUEST, value, index, res, buf[0]);
 165         return res;
 166 }
 167
 168 static int pl2303_vendor_write(__u16 value, __u16 index,
 169                 struct usb_serial *serial)
 170 {
 171         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 172                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 173                         value, index, NULL, 0, 100);
 174         dbg("0x%x:0x%x:0x%x:0x%x  %d", VENDOR_WRITE_REQUEST_TYPE,
 175                         VENDOR_WRITE_REQUEST, value, index, res);
 176         return res;
 177 }
 178
 179 static int pl2303_startup(struct usb_serial *serial)
 180 {
 181         struct pl2303_private *priv;
 182         enum pl2303_type type = type_0;
 183         unsigned char *buf;
 184         int i;
 185
 186         buf = kmalloc(10, GFP_KERNEL);
 187         if (buf == NULL)
 188                 return -ENOMEM;
 189
 190         if (serial->dev->descriptor.bDeviceClass == 0x02)
 191                 type = type_0;
 192         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 193                 type = HX;
 194         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 195                 type = type_1;
 196         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 197                 type = type_1;
 198         dbg("device type: %d", type);
 199
 200         for (i = 0; i < serial->num_ports; ++i) {
 201                 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
 202                 if (!priv)
 203                         goto cleanup;
 204                 spin_lock_init(&priv->lock);
 205                 init_waitqueue_head(&priv->delta_msr_wait);
 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                 buf[0] = baud & 0xff;
 345                 buf[1] = (baud >> 8) & 0xff;
 346                 buf[2] = (baud >> 16) & 0xff;
 347                 buf[3] = (baud >> 24) & 0xff;
 348         }
 349
 350         /* For reference buf[4]=0 is 1 stop bits */
 351         /* For reference buf[4]=1 is 1.5 stop bits */
 352         /* For reference buf[4]=2 is 2 stop bits */
 353         if (cflag & CSTOPB) {
 354                 /* NOTE: Comply with "real" UARTs / RS232:
 355                  *       use 1.5 instead of 2 stop bits with 5 data bits
 356                  */
 357                 if ((cflag & CSIZE) == CS5) {
 358                         buf[4] = 1;
 359                         dbg("%s - stop bits = 1.5", __func__);
 360                 } else {
 361                         buf[4] = 2;
 362                         dbg("%s - stop bits = 2", __func__);
 363                 }
 364         } else {
 365                 buf[4] = 0;
 366                 dbg("%s - stop bits = 1", __func__);
 367         }
 368
 369         if (cflag & PARENB) {
 370                 /* For reference buf[5]=0 is none parity */
 371                 /* For reference buf[5]=1 is odd parity */
 372                 /* For reference buf[5]=2 is even parity */
 373                 /* For reference buf[5]=3 is mark parity */
 374                 /* For reference buf[5]=4 is space parity */
 375                 if (cflag & PARODD) {
 376                         if (cflag & CMSPAR) {
 377                                 buf[5] = 3;
 378                                 dbg("%s - parity = mark", __func__);
 379                         } else {
 380                                 buf[5] = 1;
 381                                 dbg("%s - parity = odd", __func__);
 382                         }
 383                 } else {
 384                         if (cflag & CMSPAR) {
 385                                 buf[5] = 4;
 386                                 dbg("%s - parity = space", __func__);
 387                         } else {
 388                                 buf[5] = 2;
 389                                 dbg("%s - parity = even", __func__);
 390                         }
 391                 }
 392         } else {
 393                 buf[5] = 0;
 394                 dbg("%s - parity = none", __func__);
 395         }
 396
 397         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 398                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 399                             0, 0, buf, 7, 100);
 400         dbg("0x21:0x20:0:0  %d", i);
 401
 402         /* change control lines if we are switching to or from B0 */
 403         spin_lock_irqsave(&priv->lock, flags);
 404         control = priv->line_control;
 405         if ((cflag & CBAUD) == B0)
 406                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 407         else
 408                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 409         if (control != priv->line_control) {
 410                 control = priv->line_control;
 411                 spin_unlock_irqrestore(&priv->lock, flags);
 412                 set_control_lines(serial->dev, control);
 413         } else {
 414                 spin_unlock_irqrestore(&priv->lock, flags);
 415         }
 416
 417         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 418
 419         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 420                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 421                             0, 0, buf, 7, 100);
 422         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 423              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 424
 425         if (cflag & CRTSCTS) {
 426                 if (priv->type == HX)
 427                         pl2303_vendor_write(0x0, 0x61, serial);
 428                 else
 429                         pl2303_vendor_write(0x0, 0x41, serial);
 430         } else {
 431                 pl2303_vendor_write(0x0, 0x0, serial);
 432         }
 433
 434         /* Save resulting baud rate */
 435         if (baud)
 436                 tty_encode_baud_rate(tty, baud, baud);
 437
 438         kfree(buf);
 439 }
 440
 441 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 442 {
 443         struct pl2303_private *priv = usb_get_serial_port_data(port);
 444         unsigned long flags;
 445         u8 control;
 446
 447         spin_lock_irqsave(&priv->lock, flags);
 448         /* Change DTR and RTS */
 449         if (on)
 450                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 451         else
 452                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 453         control = priv->line_control;
 454         spin_unlock_irqrestore(&priv->lock, flags);
 455         set_control_lines(port->serial->dev, control);
 456 }
 457
 458 static void pl2303_close(struct usb_serial_port *port)
 459 {
 460         dbg("%s - port %d", __func__, port->number);
 461
 462         usb_serial_generic_close(port);
 463         usb_kill_urb(port->interrupt_in_urb);
 464 }
 465
 466 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 467 {
 468         struct ktermios tmp_termios;
 469         struct usb_serial *serial = port->serial;
 470         struct pl2303_private *priv = usb_get_serial_port_data(port);
 471         int result;
 472
 473         dbg("%s -  port %d", __func__, port->number);
 474
 475         if (priv->type != HX) {
 476                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 477                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 478         } else {
 479                 /* reset upstream data pipes */
 480                 pl2303_vendor_write(8, 0, serial);
 481                 pl2303_vendor_write(9, 0, serial);
 482         }
 483
 484         /* Setup termios */
 485         if (tty)
 486                 pl2303_set_termios(tty, port, &tmp_termios);
 487
 488         dbg("%s - submitting read urb", __func__);
 489         result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
 490         if (result) {
 491                 pl2303_close(port);
 492                 return -EPROTO;
 493         }
 494
 495         dbg("%s - submitting interrupt urb", __func__);
 496         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 497         if (result) {
 498                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 499                         " error %d\n", __func__, result);
 500                 pl2303_close(port);
 501                 return -EPROTO;
 502         }
 503         port->port.drain_delay = 256;
 504         return 0;
 505 }
 506
 507 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 508                            unsigned int set, unsigned int clear)
 509 {
 510         struct usb_serial_port *port = tty->driver_data;
 511         struct pl2303_private *priv = usb_get_serial_port_data(port);
 512         unsigned long flags;
 513         u8 control;
 514
 515         if (!usb_get_intfdata(port->serial->interface))
 516                 return -ENODEV;
 517
 518         spin_lock_irqsave(&priv->lock, flags);
 519         if (set & TIOCM_RTS)
 520                 priv->line_control |= CONTROL_RTS;
 521         if (set & TIOCM_DTR)
 522                 priv->line_control |= CONTROL_DTR;
 523         if (clear & TIOCM_RTS)
 524                 priv->line_control &= ~CONTROL_RTS;
 525         if (clear & TIOCM_DTR)
 526                 priv->line_control &= ~CONTROL_DTR;
 527         control = priv->line_control;
 528         spin_unlock_irqrestore(&priv->lock, flags);
 529
 530         return set_control_lines(port->serial->dev, control);
 531 }
 532
 533 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 534 {
 535         struct usb_serial_port *port = tty->driver_data;
 536         struct pl2303_private *priv = usb_get_serial_port_data(port);
 537         unsigned long flags;
 538         unsigned int mcr;
 539         unsigned int status;
 540         unsigned int result;
 541
 542         dbg("%s (%d)", __func__, port->number);
 543
 544         if (!usb_get_intfdata(port->serial->interface))
 545                 return -ENODEV;
 546
 547         spin_lock_irqsave(&priv->lock, flags);
 548         mcr = priv->line_control;
 549         status = priv->line_status;
 550         spin_unlock_irqrestore(&priv->lock, flags);
 551
 552         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 553                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 554                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 555                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 556                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 557                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 558
 559         dbg("%s - result = %x", __func__, result);
 560
 561         return result;
 562 }
 563
 564 static int pl2303_carrier_raised(struct usb_serial_port *port)
 565 {
 566         struct pl2303_private *priv = usb_get_serial_port_data(port);
 567         if (priv->line_status & UART_DCD)
 568                 return 1;
 569         return 0;
 570 }
 571
 572 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 573 {
 574         struct pl2303_private *priv = usb_get_serial_port_data(port);
 575         unsigned long flags;
 576         unsigned int prevstatus;
 577         unsigned int status;
 578         unsigned int changed;
 579
 580         spin_lock_irqsave(&priv->lock, flags);
 581         prevstatus = priv->line_status;
 582         spin_unlock_irqrestore(&priv->lock, flags);
 583
 584         while (1) {
 585                 interruptible_sleep_on(&priv->delta_msr_wait);
 586                 /* see if a signal did it */
 587                 if (signal_pending(current))
 588                         return -ERESTARTSYS;
 589
 590                 spin_lock_irqsave(&priv->lock, flags);
 591                 status = priv->line_status;
 592                 spin_unlock_irqrestore(&priv->lock, flags);
 593
 594                 changed = prevstatus ^ status;
 595
 596                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 597                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 598                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 599                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 600                         return 0;
 601                 }
 602                 prevstatus = status;
 603         }
 604         /* NOTREACHED */
 605         return 0;
 606 }
 607
 608 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 609                         unsigned int cmd, unsigned long arg)
 610 {
 611         struct serial_struct ser;
 612         struct usb_serial_port *port = tty->driver_data;
 613         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 614
 615         switch (cmd) {
 616         case TIOCGSERIAL:
 617                 memset(&ser, 0, sizeof ser);
 618                 ser.type = PORT_16654;
 619                 ser.line = port->serial->minor;
 620                 ser.port = port->number;
 621                 ser.baud_base = 460800;
 622
 623                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 624                         return -EFAULT;
 625
 626                 return 0;
 627
 628         case TIOCMIWAIT:
 629                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 630                 return wait_modem_info(port, arg);
 631         default:
 632                 dbg("%s not supported = 0x%04x", __func__, cmd);
 633                 break;
 634         }
 635         return -ENOIOCTLCMD;
 636 }
 637
 638 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 639 {
 640         struct usb_serial_port *port = tty->driver_data;
 641         struct usb_serial *serial = port->serial;
 642         u16 state;
 643         int result;
 644
 645         dbg("%s - port %d", __func__, port->number);
 646
 647         if (break_state == 0)
 648                 state = BREAK_OFF;
 649         else
 650                 state = BREAK_ON;
 651         dbg("%s - turning break %s", __func__,
 652                         state == BREAK_OFF ? "off" : "on");
 653
 654         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 655                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 656                                  0, NULL, 0, 100);
 657         if (result)
 658                 dbg("%s - error sending break = %d", __func__, result);
 659 }
 660
 661 static void pl2303_release(struct usb_serial *serial)
 662 {
 663         int i;
 664         struct pl2303_private *priv;
 665
 666         dbg("%s", __func__);
 667
 668         for (i = 0; i < serial->num_ports; ++i) {
 669                 priv = usb_get_serial_port_data(serial->port[i]);
 670                 kfree(priv);
 671         }
 672 }
 673
 674 static void pl2303_update_line_status(struct usb_serial_port *port,
 675                                       unsigned char *data,
 676                                       unsigned int actual_length)
 677 {
 678
 679         struct pl2303_private *priv = usb_get_serial_port_data(port);
 680         unsigned long flags;
 681         u8 status_idx = UART_STATE;
 682         u8 length = UART_STATE + 1;
 683         u16 idv, idp;
 684
 685         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 686         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 687
 688
 689         if (idv == SIEMENS_VENDOR_ID) {
 690                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 691                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 692                     idp == SIEMENS_PRODUCT_ID_X75) {
 693
 694                         length = 1;
 695                         status_idx = 0;
 696                 }
 697         }
 698
 699         if (actual_length < length)
 700                 return;
 701
 702         /* Save off the uart status for others to look at */
 703         spin_lock_irqsave(&priv->lock, flags);
 704         priv->line_status = data[status_idx];
 705         spin_unlock_irqrestore(&priv->lock, flags);
 706         if (priv->line_status & UART_BREAK_ERROR)
 707                 usb_serial_handle_break(port);
 708         wake_up_interruptible(&priv->delta_msr_wait);
 709 }
 710
 711 static void pl2303_read_int_callback(struct urb *urb)
 712 {
 713         struct usb_serial_port *port =  urb->context;
 714         unsigned char *data = urb->transfer_buffer;
 715         unsigned int actual_length = urb->actual_length;
 716         int status = urb->status;
 717         int retval;
 718
 719         dbg("%s (%d)", __func__, port->number);
 720
 721         switch (status) {
 722         case 0:
 723                 /* success */
 724                 break;
 725         case -ECONNRESET:
 726         case -ENOENT:
 727         case -ESHUTDOWN:
 728                 /* this urb is terminated, clean up */
 729                 dbg("%s - urb shutting down with status: %d", __func__,
 730                     status);
 731                 return;
 732         default:
 733                 dbg("%s - nonzero urb status received: %d", __func__,
 734                     status);
 735                 goto exit;
 736         }
 737
 738         usb_serial_debug_data(debug, &port->dev, __func__,
 739                               urb->actual_length, urb->transfer_buffer);
 740
 741         pl2303_update_line_status(port, data, actual_length);
 742
 743 exit:
 744         retval = usb_submit_urb(urb, GFP_ATOMIC);
 745         if (retval)
 746                 dev_err(&urb->dev->dev,
 747                         "%s - usb_submit_urb failed with result %d\n",
 748                         __func__, retval);
 749 }
 750
 751 static void pl2303_process_read_urb(struct urb *urb)
 752 {
 753         struct usb_serial_port *port = urb->context;
 754         struct pl2303_private *priv = usb_get_serial_port_data(port);
 755         struct tty_struct *tty;
 756         unsigned char *data = urb->transfer_buffer;
 757         char tty_flag = TTY_NORMAL;
 758         unsigned long flags;
 759         u8 line_status;
 760         int i;
 761
 762         /* update line status */
 763         spin_lock_irqsave(&priv->lock, flags);
 764         line_status = priv->line_status;
 765         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 766         spin_unlock_irqrestore(&priv->lock, flags);
 767         wake_up_interruptible(&priv->delta_msr_wait);
 768
 769         if (!urb->actual_length)
 770                 return;
 771
 772         tty = tty_port_tty_get(&port->port);
 773         if (!tty)
 774                 return;
 775
 776         /* break takes precedence over parity, */
 777         /* which takes precedence over framing errors */
 778         if (line_status & UART_BREAK_ERROR)
 779                 tty_flag = TTY_BREAK;
 780         else if (line_status & UART_PARITY_ERROR)
 781                 tty_flag = TTY_PARITY;
 782         else if (line_status & UART_FRAME_ERROR)
 783                 tty_flag = TTY_FRAME;
 784         dbg("%s - tty_flag = %d", __func__, tty_flag);
 785
 786         /* overrun is special, not associated with a char */
 787         if (line_status & UART_OVERRUN_ERROR)
 788                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 789
 790         if (port->port.console && port->sysrq) {
 791                 for (i = 0; i < urb->actual_length; ++i)
 792                         if (!usb_serial_handle_sysrq_char(port, data[i]))
 793                                 tty_insert_flip_char(tty, data[i], tty_flag);
 794         } else {
 795                 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
 796                                                         urb->actual_length);
 797         }
 798
 799         tty_flip_buffer_push(tty);
 800         tty_kref_put(tty);
 801 }
 802
 803 /* All of the device info needed for the PL2303 SIO serial converter */
 804 static struct usb_serial_driver pl2303_device = {
 805         .driver = {
 806                 .owner =        THIS_MODULE,
 807                 .name =         "pl2303",
 808         },
 809         .id_table =             id_table,
 810         .usb_driver =           &pl2303_driver,
 811         .num_ports =            1,
 812         .bulk_in_size =         256,
 813         .bulk_out_size =        256,
 814         .open =                 pl2303_open,
 815         .close =                pl2303_close,
 816         .dtr_rts =              pl2303_dtr_rts,
 817         .carrier_raised =       pl2303_carrier_raised,
 818         .ioctl =                pl2303_ioctl,
 819         .break_ctl =            pl2303_break_ctl,
 820         .set_termios =          pl2303_set_termios,
 821         .tiocmget =             pl2303_tiocmget,
 822         .tiocmset =             pl2303_tiocmset,
 823         .process_read_urb =     pl2303_process_read_urb,
 824         .read_int_callback =    pl2303_read_int_callback,
 825         .attach =               pl2303_startup,
 826         .release =              pl2303_release,
 827 };
 828
 829 static int __init pl2303_init(void)
 830 {
 831         int retval;
 832
 833         retval = usb_serial_register(&pl2303_device);
 834         if (retval)
 835                 goto failed_usb_serial_register;
 836         retval = usb_register(&pl2303_driver);
 837         if (retval)
 838                 goto failed_usb_register;
 839         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 840         return 0;
 841 failed_usb_register:
 842         usb_serial_deregister(&pl2303_device);
 843 failed_usb_serial_register:
 844         return retval;
 845 }
 846
 847 static void __exit pl2303_exit(void)
 848 {
 849         usb_deregister(&pl2303_driver);
 850         usb_serial_deregister(&pl2303_device);
 851 }
 852
 853 module_init(pl2303_init);
 854 module_exit(pl2303_exit);
 855
 856 MODULE_DESCRIPTION(DRIVER_DESC);
 857 MODULE_LICENSE("GPL");
 858
 859 module_param(debug, bool, S_IRUGO | S_IWUSR);
 860 MODULE_PARM_DESC(debug, "Debug enabled or not");
 861