drivers/usb/serial/pl2303.c

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