SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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         unsigned long flags;
 460
 461         dbg("%s - port %d", __func__, port->number);
 462
 463         spin_lock_irqsave(&port->lock, flags);
 464         /* clear out any remaining data in the buffer */
 465         kfifo_reset_out(&port->write_fifo);
 466         spin_unlock_irqrestore(&port->lock, flags);
 467
 468         /* shutdown our urbs */
 469         dbg("%s - shutting down urbs", __func__);
 470         usb_kill_urb(port->write_urb);
 471         usb_kill_urb(port->read_urb);
 472         usb_kill_urb(port->interrupt_in_urb);
 473
 474 }
 475
 476 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 477 {
 478         struct ktermios tmp_termios;
 479         struct usb_serial *serial = port->serial;
 480         struct pl2303_private *priv = usb_get_serial_port_data(port);
 481         int result;
 482
 483         dbg("%s -  port %d", __func__, port->number);
 484
 485         if (priv->type != HX) {
 486                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 487                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 488         } else {
 489                 /* reset upstream data pipes */
 490                 pl2303_vendor_write(8, 0, serial);
 491                 pl2303_vendor_write(9, 0, serial);
 492         }
 493
 494         /* Setup termios */
 495         if (tty)
 496                 pl2303_set_termios(tty, port, &tmp_termios);
 497
 498         dbg("%s - submitting read urb", __func__);
 499         result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
 500         if (result) {
 501                 pl2303_close(port);
 502                 return -EPROTO;
 503         }
 504
 505         dbg("%s - submitting interrupt urb", __func__);
 506         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 507         if (result) {
 508                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 509                         " error %d\n", __func__, result);
 510                 pl2303_close(port);
 511                 return -EPROTO;
 512         }
 513         port->port.drain_delay = 256;
 514         return 0;
 515 }
 516
 517 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 518                            unsigned int set, unsigned int clear)
 519 {
 520         struct usb_serial_port *port = tty->driver_data;
 521         struct pl2303_private *priv = usb_get_serial_port_data(port);
 522         unsigned long flags;
 523         u8 control;
 524
 525         if (!usb_get_intfdata(port->serial->interface))
 526                 return -ENODEV;
 527
 528         spin_lock_irqsave(&priv->lock, flags);
 529         if (set & TIOCM_RTS)
 530                 priv->line_control |= CONTROL_RTS;
 531         if (set & TIOCM_DTR)
 532                 priv->line_control |= CONTROL_DTR;
 533         if (clear & TIOCM_RTS)
 534                 priv->line_control &= ~CONTROL_RTS;
 535         if (clear & TIOCM_DTR)
 536                 priv->line_control &= ~CONTROL_DTR;
 537         control = priv->line_control;
 538         spin_unlock_irqrestore(&priv->lock, flags);
 539
 540         return set_control_lines(port->serial->dev, control);
 541 }
 542
 543 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 544 {
 545         struct usb_serial_port *port = tty->driver_data;
 546         struct pl2303_private *priv = usb_get_serial_port_data(port);
 547         unsigned long flags;
 548         unsigned int mcr;
 549         unsigned int status;
 550         unsigned int result;
 551
 552         dbg("%s (%d)", __func__, port->number);
 553
 554         if (!usb_get_intfdata(port->serial->interface))
 555                 return -ENODEV;
 556
 557         spin_lock_irqsave(&priv->lock, flags);
 558         mcr = priv->line_control;
 559         status = priv->line_status;
 560         spin_unlock_irqrestore(&priv->lock, flags);
 561
 562         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 563                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 564                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 565                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 566                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 567                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 568
 569         dbg("%s - result = %x", __func__, result);
 570
 571         return result;
 572 }
 573
 574 static int pl2303_carrier_raised(struct usb_serial_port *port)
 575 {
 576         struct pl2303_private *priv = usb_get_serial_port_data(port);
 577         if (priv->line_status & UART_DCD)
 578                 return 1;
 579         return 0;
 580 }
 581
 582 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 583 {
 584         struct pl2303_private *priv = usb_get_serial_port_data(port);
 585         unsigned long flags;
 586         unsigned int prevstatus;
 587         unsigned int status;
 588         unsigned int changed;
 589
 590         spin_lock_irqsave(&priv->lock, flags);
 591         prevstatus = priv->line_status;
 592         spin_unlock_irqrestore(&priv->lock, flags);
 593
 594         while (1) {
 595                 interruptible_sleep_on(&priv->delta_msr_wait);
 596                 /* see if a signal did it */
 597                 if (signal_pending(current))
 598                         return -ERESTARTSYS;
 599
 600                 spin_lock_irqsave(&priv->lock, flags);
 601                 status = priv->line_status;
 602                 spin_unlock_irqrestore(&priv->lock, flags);
 603
 604                 changed = prevstatus ^ status;
 605
 606                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 607                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 608                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 609                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 610                         return 0;
 611                 }
 612                 prevstatus = status;
 613         }
 614         /* NOTREACHED */
 615         return 0;
 616 }
 617
 618 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 619                         unsigned int cmd, unsigned long arg)
 620 {
 621         struct serial_struct ser;
 622         struct usb_serial_port *port = tty->driver_data;
 623         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 624
 625         switch (cmd) {
 626         case TIOCGSERIAL:
 627                 memset(&ser, 0, sizeof ser);
 628                 ser.type = PORT_16654;
 629                 ser.line = port->serial->minor;
 630                 ser.port = port->number;
 631                 ser.baud_base = 460800;
 632
 633                 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
 634                         return -EFAULT;
 635
 636                 return 0;
 637
 638         case TIOCMIWAIT:
 639                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 640                 return wait_modem_info(port, arg);
 641         default:
 642                 dbg("%s not supported = 0x%04x", __func__, cmd);
 643                 break;
 644         }
 645         return -ENOIOCTLCMD;
 646 }
 647
 648 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 649 {
 650         struct usb_serial_port *port = tty->driver_data;
 651         struct usb_serial *serial = port->serial;
 652         u16 state;
 653         int result;
 654
 655         dbg("%s - port %d", __func__, port->number);
 656
 657         if (break_state == 0)
 658                 state = BREAK_OFF;
 659         else
 660                 state = BREAK_ON;
 661         dbg("%s - turning break %s", __func__,
 662                         state == BREAK_OFF ? "off" : "on");
 663
 664         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 665                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 666                                  0, NULL, 0, 100);
 667         if (result)
 668                 dbg("%s - error sending break = %d", __func__, result);
 669 }
 670
 671 static void pl2303_release(struct usb_serial *serial)
 672 {
 673         int i;
 674         struct pl2303_private *priv;
 675
 676         dbg("%s", __func__);
 677
 678         for (i = 0; i < serial->num_ports; ++i) {
 679                 priv = usb_get_serial_port_data(serial->port[i]);
 680                 kfree(priv);
 681         }
 682 }
 683
 684 static void pl2303_update_line_status(struct usb_serial_port *port,
 685                                       unsigned char *data,
 686                                       unsigned int actual_length)
 687 {
 688
 689         struct pl2303_private *priv = usb_get_serial_port_data(port);
 690         unsigned long flags;
 691         u8 status_idx = UART_STATE;
 692         u8 length = UART_STATE + 1;
 693         u16 idv, idp;
 694
 695         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 696         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 697
 698
 699         if (idv == SIEMENS_VENDOR_ID) {
 700                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 701                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 702                     idp == SIEMENS_PRODUCT_ID_X75) {
 703
 704                         length = 1;
 705                         status_idx = 0;
 706                 }
 707         }
 708
 709         if (actual_length < length)
 710                 return;
 711
 712         /* Save off the uart status for others to look at */
 713         spin_lock_irqsave(&priv->lock, flags);
 714         priv->line_status = data[status_idx];
 715         spin_unlock_irqrestore(&priv->lock, flags);
 716         if (priv->line_status & UART_BREAK_ERROR)
 717                 usb_serial_handle_break(port);
 718         wake_up_interruptible(&priv->delta_msr_wait);
 719 }
 720
 721 static void pl2303_read_int_callback(struct urb *urb)
 722 {
 723         struct usb_serial_port *port =  urb->context;
 724         unsigned char *data = urb->transfer_buffer;
 725         unsigned int actual_length = urb->actual_length;
 726         int status = urb->status;
 727         int retval;
 728
 729         dbg("%s (%d)", __func__, port->number);
 730
 731         switch (status) {
 732         case 0:
 733                 /* success */
 734                 break;
 735         case -ECONNRESET:
 736         case -ENOENT:
 737         case -ESHUTDOWN:
 738                 /* this urb is terminated, clean up */
 739                 dbg("%s - urb shutting down with status: %d", __func__,
 740                     status);
 741                 return;
 742         default:
 743                 dbg("%s - nonzero urb status received: %d", __func__,
 744                     status);
 745                 goto exit;
 746         }
 747
 748         usb_serial_debug_data(debug, &port->dev, __func__,
 749                               urb->actual_length, urb->transfer_buffer);
 750
 751         pl2303_update_line_status(port, data, actual_length);
 752
 753 exit:
 754         retval = usb_submit_urb(urb, GFP_ATOMIC);
 755         if (retval)
 756                 dev_err(&urb->dev->dev,
 757                         "%s - usb_submit_urb failed with result %d\n",
 758                         __func__, retval);
 759 }
 760
 761 static void pl2303_process_read_urb(struct urb *urb)
 762 {
 763         struct usb_serial_port *port = urb->context;
 764         struct pl2303_private *priv = usb_get_serial_port_data(port);
 765         struct tty_struct *tty;
 766         unsigned char *data = urb->transfer_buffer;
 767         char tty_flag = TTY_NORMAL;
 768         unsigned long flags;
 769         u8 line_status;
 770         int i;
 771
 772         /* update line status */
 773         spin_lock_irqsave(&priv->lock, flags);
 774         line_status = priv->line_status;
 775         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
 776         spin_unlock_irqrestore(&priv->lock, flags);
 777         wake_up_interruptible(&priv->delta_msr_wait);
 778
 779         if (!urb->actual_length)
 780                 return;
 781
 782         tty = tty_port_tty_get(&port->port);
 783         if (!tty)
 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         dbg("%s - tty_flag = %d", __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(tty, 0, TTY_OVERRUN);
 799
 800         if (tty_flag == TTY_NORMAL && !(port->port.console && port->sysrq))
 801                 tty_insert_flip_string(tty, data, urb->actual_length);
 802         else {
 803                 for (i = 0; i < urb->actual_length; ++i)
 804                         if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
 805                                 tty_insert_flip_char(tty, data[i], tty_flag);
 806         }
 807
 808         tty_flip_buffer_push(tty);
 809         tty_kref_put(tty);
 810 }
 811
 812 /* All of the device info needed for the PL2303 SIO serial converter */
 813 static struct usb_serial_driver pl2303_device = {
 814         .driver = {
 815                 .owner =        THIS_MODULE,
 816                 .name =         "pl2303",
 817         },
 818         .id_table =             id_table,
 819         .usb_driver =           &pl2303_driver,
 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         .process_read_urb =     pl2303_process_read_urb,
 833         .read_int_callback =    pl2303_read_int_callback,
 834         .attach =               pl2303_startup,
 835         .release =              pl2303_release,
 836 };
 837
 838 static int __init pl2303_init(void)
 839 {
 840         int retval;
 841
 842         retval = usb_serial_register(&pl2303_device);
 843         if (retval)
 844                 goto failed_usb_serial_register;
 845         retval = usb_register(&pl2303_driver);
 846         if (retval)
 847                 goto failed_usb_register;
 848         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 849         return 0;
 850 failed_usb_register:
 851         usb_serial_deregister(&pl2303_device);
 852 failed_usb_serial_register:
 853         return retval;
 854 }
 855
 856 static void __exit pl2303_exit(void)
 857 {
 858         usb_deregister(&pl2303_driver);
 859         usb_serial_deregister(&pl2303_device);
 860 }
 861
 862 module_init(pl2303_init);
 863 module_exit(pl2303_exit);
 864
 865 MODULE_DESCRIPTION(DRIVER_DESC);
 866 MODULE_LICENSE("GPL");
 867
 868 module_param(debug, bool, S_IRUGO | S_IWUSR);
 869 MODULE_PARM_DESC(debug, "Debug enabled or not");
 870