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