git.oblomov.eu Git - 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 #define PL2303_BUF_SIZE         1024
  44 #define PL2303_TMP_BUF_SIZE     1024
  45
  46 struct pl2303_buf {
  47         unsigned int    buf_size;
  48         char            *buf_buf;
  49         char            *buf_get;
  50         char            *buf_put;
  51 };
  52
  53 static struct usb_device_id id_table [] = {
  54         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
  55         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  56         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  57         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  58         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  59         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
  60         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
  61         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
  62         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  63         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  64         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
  65         { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  66         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  67         { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  68         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  69         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  70         { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  71         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  72         { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  73         { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  74         { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  75         { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  76         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  77         { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
  78         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
  79         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
  80         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
  81         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
  82         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
  83         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  84         { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  85         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  86         { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  87         { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  88         { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  89         { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  90         { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  91         { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
  92         { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  93         { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  94         { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  95         { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  96         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  97         { }                                     /* Terminating entry */
  98 };
  99
 100 MODULE_DEVICE_TABLE(usb, id_table);
 101
 102 static struct usb_driver pl2303_driver = {
 103         .name =         "pl2303",
 104         .probe =        usb_serial_probe,
 105         .disconnect =   usb_serial_disconnect,
 106         .id_table =     id_table,
 107         .suspend =      usb_serial_suspend,
 108         .resume =       usb_serial_resume,
 109         .no_dynamic_id =        1,
 110         .supports_autosuspend = 1,
 111 };
 112
 113 #define SET_LINE_REQUEST_TYPE           0x21
 114 #define SET_LINE_REQUEST                0x20
 115
 116 #define SET_CONTROL_REQUEST_TYPE        0x21
 117 #define SET_CONTROL_REQUEST             0x22
 118 #define CONTROL_DTR                     0x01
 119 #define CONTROL_RTS                     0x02
 120
 121 #define BREAK_REQUEST_TYPE              0x21
 122 #define BREAK_REQUEST                   0x23
 123 #define BREAK_ON                        0xffff
 124 #define BREAK_OFF                       0x0000
 125
 126 #define GET_LINE_REQUEST_TYPE           0xa1
 127 #define GET_LINE_REQUEST                0x21
 128
 129 #define VENDOR_WRITE_REQUEST_TYPE       0x40
 130 #define VENDOR_WRITE_REQUEST            0x01
 131
 132 #define VENDOR_READ_REQUEST_TYPE        0xc0
 133 #define VENDOR_READ_REQUEST             0x01
 134
 135 #define UART_STATE                      0x08
 136 #define UART_STATE_TRANSIENT_MASK       0x74
 137 #define UART_DCD                        0x01
 138 #define UART_DSR                        0x02
 139 #define UART_BREAK_ERROR                0x04
 140 #define UART_RING                       0x08
 141 #define UART_FRAME_ERROR                0x10
 142 #define UART_PARITY_ERROR               0x20
 143 #define UART_OVERRUN_ERROR              0x40
 144 #define UART_CTS                        0x80
 145
 146
 147 enum pl2303_type {
 148         type_0,         /* don't know the difference between type 0 and */
 149         type_1,         /* type 1, until someone from prolific tells us... */
 150         HX,             /* HX version of the pl2303 chip */
 151 };
 152
 153 struct pl2303_private {
 154         spinlock_t lock;
 155         struct pl2303_buf *buf;
 156         int write_urb_in_use;
 157         wait_queue_head_t delta_msr_wait;
 158         u8 line_control;
 159         u8 line_status;
 160         enum pl2303_type type;
 161 };
 162
 163 /*
 164  * pl2303_buf_alloc
 165  *
 166  * Allocate a circular buffer and all associated memory.
 167  */
 168 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
 169 {
 170         struct pl2303_buf *pb;
 171
 172         if (size == 0)
 173                 return NULL;
 174
 175         pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
 176         if (pb == NULL)
 177                 return NULL;
 178
 179         pb->buf_buf = kmalloc(size, GFP_KERNEL);
 180         if (pb->buf_buf == NULL) {
 181                 kfree(pb);
 182                 return NULL;
 183         }
 184
 185         pb->buf_size = size;
 186         pb->buf_get = pb->buf_put = pb->buf_buf;
 187
 188         return pb;
 189 }
 190
 191 /*
 192  * pl2303_buf_free
 193  *
 194  * Free the buffer and all associated memory.
 195  */
 196 static void pl2303_buf_free(struct pl2303_buf *pb)
 197 {
 198         if (pb) {
 199                 kfree(pb->buf_buf);
 200                 kfree(pb);
 201         }
 202 }
 203
 204 /*
 205  * pl2303_buf_clear
 206  *
 207  * Clear out all data in the circular buffer.
 208  */
 209 static void pl2303_buf_clear(struct pl2303_buf *pb)
 210 {
 211         if (pb != NULL)
 212                 pb->buf_get = pb->buf_put;
 213                 /* equivalent to a get of all data available */
 214 }
 215
 216 /*
 217  * pl2303_buf_data_avail
 218  *
 219  * Return the number of bytes of data available in the circular
 220  * buffer.
 221  */
 222 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
 223 {
 224         if (pb == NULL)
 225                 return 0;
 226
 227         return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
 228 }
 229
 230 /*
 231  * pl2303_buf_space_avail
 232  *
 233  * Return the number of bytes of space available in the circular
 234  * buffer.
 235  */
 236 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
 237 {
 238         if (pb == NULL)
 239                 return 0;
 240
 241         return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
 242 }
 243
 244 /*
 245  * pl2303_buf_put
 246  *
 247  * Copy data data from a user buffer and put it into the circular buffer.
 248  * Restrict to the amount of space available.
 249  *
 250  * Return the number of bytes copied.
 251  */
 252 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
 253                                    unsigned int count)
 254 {
 255         unsigned int len;
 256
 257         if (pb == NULL)
 258                 return 0;
 259
 260         len  = pl2303_buf_space_avail(pb);
 261         if (count > len)
 262                 count = len;
 263
 264         if (count == 0)
 265                 return 0;
 266
 267         len = pb->buf_buf + pb->buf_size - pb->buf_put;
 268         if (count > len) {
 269                 memcpy(pb->buf_put, buf, len);
 270                 memcpy(pb->buf_buf, buf+len, count - len);
 271                 pb->buf_put = pb->buf_buf + count - len;
 272         } else {
 273                 memcpy(pb->buf_put, buf, count);
 274                 if (count < len)
 275                         pb->buf_put += count;
 276                 else /* count == len */
 277                         pb->buf_put = pb->buf_buf;
 278         }
 279
 280         return count;
 281 }
 282
 283 /*
 284  * pl2303_buf_get
 285  *
 286  * Get data from the circular buffer and copy to the given buffer.
 287  * Restrict to the amount of data available.
 288  *
 289  * Return the number of bytes copied.
 290  */
 291 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
 292                                    unsigned int count)
 293 {
 294         unsigned int len;
 295
 296         if (pb == NULL)
 297                 return 0;
 298
 299         len = pl2303_buf_data_avail(pb);
 300         if (count > len)
 301                 count = len;
 302
 303         if (count == 0)
 304                 return 0;
 305
 306         len = pb->buf_buf + pb->buf_size - pb->buf_get;
 307         if (count > len) {
 308                 memcpy(buf, pb->buf_get, len);
 309                 memcpy(buf+len, pb->buf_buf, count - len);
 310                 pb->buf_get = pb->buf_buf + count - len;
 311         } else {
 312                 memcpy(buf, pb->buf_get, count);
 313                 if (count < len)
 314                         pb->buf_get += count;
 315                 else /* count == len */
 316                         pb->buf_get = pb->buf_buf;
 317         }
 318
 319         return count;
 320 }
 321
 322 static int pl2303_vendor_read(__u16 value, __u16 index,
 323                 struct usb_serial *serial, unsigned char *buf)
 324 {
 325         int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 326                         VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
 327                         value, index, buf, 1, 100);
 328         dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", VENDOR_READ_REQUEST_TYPE,
 329                         VENDOR_READ_REQUEST, value, index, res, buf[0]);
 330         return res;
 331 }
 332
 333 static int pl2303_vendor_write(__u16 value, __u16 index,
 334                 struct usb_serial *serial)
 335 {
 336         int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 337                         VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
 338                         value, index, NULL, 0, 100);
 339         dbg("0x%x:0x%x:0x%x:0x%x  %d", VENDOR_WRITE_REQUEST_TYPE,
 340                         VENDOR_WRITE_REQUEST, value, index, res);
 341         return res;
 342 }
 343
 344 static int pl2303_startup(struct usb_serial *serial)
 345 {
 346         struct pl2303_private *priv;
 347         enum pl2303_type type = type_0;
 348         unsigned char *buf;
 349         int i;
 350
 351         buf = kmalloc(10, GFP_KERNEL);
 352         if (buf == NULL)
 353                 return -ENOMEM;
 354
 355         if (serial->dev->descriptor.bDeviceClass == 0x02)
 356                 type = type_0;
 357         else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
 358                 type = HX;
 359         else if (serial->dev->descriptor.bDeviceClass == 0x00)
 360                 type = type_1;
 361         else if (serial->dev->descriptor.bDeviceClass == 0xFF)
 362                 type = type_1;
 363         dbg("device type: %d", type);
 364
 365         for (i = 0; i < serial->num_ports; ++i) {
 366                 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
 367                 if (!priv)
 368                         goto cleanup;
 369                 spin_lock_init(&priv->lock);
 370                 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
 371                 if (priv->buf == NULL) {
 372                         kfree(priv);
 373                         goto cleanup;
 374                 }
 375                 init_waitqueue_head(&priv->delta_msr_wait);
 376                 priv->type = type;
 377                 usb_set_serial_port_data(serial->port[i], priv);
 378         }
 379
 380         pl2303_vendor_read(0x8484, 0, serial, buf);
 381         pl2303_vendor_write(0x0404, 0, serial);
 382         pl2303_vendor_read(0x8484, 0, serial, buf);
 383         pl2303_vendor_read(0x8383, 0, serial, buf);
 384         pl2303_vendor_read(0x8484, 0, serial, buf);
 385         pl2303_vendor_write(0x0404, 1, serial);
 386         pl2303_vendor_read(0x8484, 0, serial, buf);
 387         pl2303_vendor_read(0x8383, 0, serial, buf);
 388         pl2303_vendor_write(0, 1, serial);
 389         pl2303_vendor_write(1, 0, serial);
 390         if (type == HX)
 391                 pl2303_vendor_write(2, 0x44, serial);
 392         else
 393                 pl2303_vendor_write(2, 0x24, serial);
 394
 395         kfree(buf);
 396         return 0;
 397
 398 cleanup:
 399         kfree(buf);
 400         for (--i; i >= 0; --i) {
 401                 priv = usb_get_serial_port_data(serial->port[i]);
 402                 pl2303_buf_free(priv->buf);
 403                 kfree(priv);
 404                 usb_set_serial_port_data(serial->port[i], NULL);
 405         }
 406         return -ENOMEM;
 407 }
 408
 409 static int set_control_lines(struct usb_device *dev, u8 value)
 410 {
 411         int retval;
 412
 413         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 414                                  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
 415                                  value, 0, NULL, 0, 100);
 416         dbg("%s - value = %d, retval = %d", __func__, value, retval);
 417         return retval;
 418 }
 419
 420 static void pl2303_send(struct usb_serial_port *port)
 421 {
 422         int count, result;
 423         struct pl2303_private *priv = usb_get_serial_port_data(port);
 424         unsigned long flags;
 425
 426         dbg("%s - port %d", __func__, port->number);
 427
 428         spin_lock_irqsave(&priv->lock, flags);
 429
 430         if (priv->write_urb_in_use) {
 431                 spin_unlock_irqrestore(&priv->lock, flags);
 432                 return;
 433         }
 434
 435         count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
 436                                port->bulk_out_size);
 437
 438         if (count == 0) {
 439                 spin_unlock_irqrestore(&priv->lock, flags);
 440                 return;
 441         }
 442
 443         priv->write_urb_in_use = 1;
 444
 445         spin_unlock_irqrestore(&priv->lock, flags);
 446
 447         usb_serial_debug_data(debug, &port->dev, __func__, count,
 448                               port->write_urb->transfer_buffer);
 449
 450         port->write_urb->transfer_buffer_length = count;
 451         port->write_urb->dev = port->serial->dev;
 452         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 453         if (result) {
 454                 dev_err(&port->dev, "%s - failed submitting write urb,"
 455                         " error %d\n", __func__, result);
 456                 priv->write_urb_in_use = 0;
 457                 /* TODO: reschedule pl2303_send */
 458         }
 459
 460         usb_serial_port_softint(port);
 461 }
 462
 463 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
 464                                 const unsigned char *buf, int count)
 465 {
 466         struct pl2303_private *priv = usb_get_serial_port_data(port);
 467         unsigned long flags;
 468
 469         dbg("%s - port %d, %d bytes", __func__, port->number, count);
 470
 471         if (!count)
 472                 return count;
 473
 474         spin_lock_irqsave(&priv->lock, flags);
 475         count = pl2303_buf_put(priv->buf, buf, count);
 476         spin_unlock_irqrestore(&priv->lock, flags);
 477
 478         pl2303_send(port);
 479
 480         return count;
 481 }
 482
 483 static int pl2303_write_room(struct tty_struct *tty)
 484 {
 485         struct usb_serial_port *port = tty->driver_data;
 486         struct pl2303_private *priv = usb_get_serial_port_data(port);
 487         int room = 0;
 488         unsigned long flags;
 489
 490         dbg("%s - port %d", __func__, port->number);
 491
 492         spin_lock_irqsave(&priv->lock, flags);
 493         room = pl2303_buf_space_avail(priv->buf);
 494         spin_unlock_irqrestore(&priv->lock, flags);
 495
 496         dbg("%s - returns %d", __func__, room);
 497         return room;
 498 }
 499
 500 static int pl2303_chars_in_buffer(struct tty_struct *tty)
 501 {
 502         struct usb_serial_port *port = tty->driver_data;
 503         struct pl2303_private *priv = usb_get_serial_port_data(port);
 504         int chars = 0;
 505         unsigned long flags;
 506
 507         dbg("%s - port %d", __func__, port->number);
 508
 509         spin_lock_irqsave(&priv->lock, flags);
 510         chars = pl2303_buf_data_avail(priv->buf);
 511         spin_unlock_irqrestore(&priv->lock, flags);
 512
 513         dbg("%s - returns %d", __func__, chars);
 514         return chars;
 515 }
 516
 517 static void pl2303_set_termios(struct tty_struct *tty,
 518                 struct usb_serial_port *port, struct ktermios *old_termios)
 519 {
 520         struct usb_serial *serial = port->serial;
 521         struct pl2303_private *priv = usb_get_serial_port_data(port);
 522         unsigned long flags;
 523         unsigned int cflag;
 524         unsigned char *buf;
 525         int baud;
 526         int i;
 527         u8 control;
 528
 529         dbg("%s -  port %d", __func__, port->number);
 530
 531         /* The PL2303 is reported to lose bytes if you change
 532            serial settings even to the same values as before. Thus
 533            we actually need to filter in this specific case */
 534
 535         if (!tty_termios_hw_change(tty->termios, old_termios))
 536                 return;
 537
 538         cflag = tty->termios->c_cflag;
 539
 540         buf = kzalloc(7, GFP_KERNEL);
 541         if (!buf) {
 542                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 543                 /* Report back no change occurred */
 544                 *tty->termios = *old_termios;
 545                 return;
 546         }
 547
 548         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 549                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 550                             0, 0, buf, 7, 100);
 551         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 552             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 553
 554         if (cflag & CSIZE) {
 555                 switch (cflag & CSIZE) {
 556                 case CS5:
 557                         buf[6] = 5;
 558                         break;
 559                 case CS6:
 560                         buf[6] = 6;
 561                         break;
 562                 case CS7:
 563                         buf[6] = 7;
 564                         break;
 565                 default:
 566                 case CS8:
 567                         buf[6] = 8;
 568                         break;
 569                 }
 570                 dbg("%s - data bits = %d", __func__, buf[6]);
 571         }
 572
 573         baud = tty_get_baud_rate(tty);
 574         dbg("%s - baud = %d", __func__, baud);
 575         if (baud) {
 576                 buf[0] = baud & 0xff;
 577                 buf[1] = (baud >> 8) & 0xff;
 578                 buf[2] = (baud >> 16) & 0xff;
 579                 buf[3] = (baud >> 24) & 0xff;
 580         }
 581
 582         /* For reference buf[4]=0 is 1 stop bits */
 583         /* For reference buf[4]=1 is 1.5 stop bits */
 584         /* For reference buf[4]=2 is 2 stop bits */
 585         if (cflag & CSTOPB) {
 586                 buf[4] = 2;
 587                 dbg("%s - stop bits = 2", __func__);
 588         } else {
 589                 buf[4] = 0;
 590                 dbg("%s - stop bits = 1", __func__);
 591         }
 592
 593         if (cflag & PARENB) {
 594                 /* For reference buf[5]=0 is none parity */
 595                 /* For reference buf[5]=1 is odd parity */
 596                 /* For reference buf[5]=2 is even parity */
 597                 /* For reference buf[5]=3 is mark parity */
 598                 /* For reference buf[5]=4 is space parity */
 599                 if (cflag & PARODD) {
 600                         buf[5] = 1;
 601                         dbg("%s - parity = odd", __func__);
 602                 } else {
 603                         buf[5] = 2;
 604                         dbg("%s - parity = even", __func__);
 605                 }
 606         } else {
 607                 buf[5] = 0;
 608                 dbg("%s - parity = none", __func__);
 609         }
 610
 611         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 612                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 613                             0, 0, buf, 7, 100);
 614         dbg("0x21:0x20:0:0  %d", i);
 615
 616         /* change control lines if we are switching to or from B0 */
 617         spin_lock_irqsave(&priv->lock, flags);
 618         control = priv->line_control;
 619         if ((cflag & CBAUD) == B0)
 620                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 621         else
 622                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 623         if (control != priv->line_control) {
 624                 control = priv->line_control;
 625                 spin_unlock_irqrestore(&priv->lock, flags);
 626                 set_control_lines(serial->dev, control);
 627         } else {
 628                 spin_unlock_irqrestore(&priv->lock, flags);
 629         }
 630
 631         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 632
 633         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 634                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 635                             0, 0, buf, 7, 100);
 636         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 637              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 638
 639         if (cflag & CRTSCTS) {
 640                 if (priv->type == HX)
 641                         pl2303_vendor_write(0x0, 0x61, serial);
 642                 else
 643                         pl2303_vendor_write(0x0, 0x41, serial);
 644         } else {
 645                 pl2303_vendor_write(0x0, 0x0, serial);
 646         }
 647
 648         /* FIXME: Need to read back resulting baud rate */
 649         if (baud)
 650                 tty_encode_baud_rate(tty, baud, baud);
 651
 652         kfree(buf);
 653 }
 654
 655 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
 656 {
 657         struct pl2303_private *priv = usb_get_serial_port_data(port);
 658         unsigned long flags;
 659         u8 control;
 660
 661         spin_lock_irqsave(&priv->lock, flags);
 662         /* Change DTR and RTS */
 663         if (on)
 664                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 665         else
 666                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 667         control = priv->line_control;
 668         spin_unlock_irqrestore(&priv->lock, flags);
 669         set_control_lines(port->serial->dev, control);
 670 }
 671
 672 static void pl2303_close(struct usb_serial_port *port)
 673 {
 674         struct pl2303_private *priv = usb_get_serial_port_data(port);
 675         unsigned long flags;
 676
 677         dbg("%s - port %d", __func__, port->number);
 678
 679         spin_lock_irqsave(&priv->lock, flags);
 680         /* clear out any remaining data in the buffer */
 681         pl2303_buf_clear(priv->buf);
 682         spin_unlock_irqrestore(&priv->lock, flags);
 683
 684         /* shutdown our urbs */
 685         dbg("%s - shutting down urbs", __func__);
 686         usb_kill_urb(port->write_urb);
 687         usb_kill_urb(port->read_urb);
 688         usb_kill_urb(port->interrupt_in_urb);
 689
 690 }
 691
 692 static int pl2303_open(struct tty_struct *tty,
 693                         struct usb_serial_port *port, struct file *filp)
 694 {
 695         struct ktermios tmp_termios;
 696         struct usb_serial *serial = port->serial;
 697         struct pl2303_private *priv = usb_get_serial_port_data(port);
 698         int result;
 699
 700         dbg("%s -  port %d", __func__, port->number);
 701
 702         if (priv->type != HX) {
 703                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 704                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 705         } else {
 706                 /* reset upstream data pipes */
 707                 pl2303_vendor_write(8, 0, serial);
 708                 pl2303_vendor_write(9, 0, serial);
 709         }
 710
 711         /* Setup termios */
 712         if (tty)
 713                 pl2303_set_termios(tty, port, &tmp_termios);
 714
 715         /* FIXME: need to assert RTS and DTR if CRTSCTS off */
 716
 717         dbg("%s - submitting read urb", __func__);
 718         port->read_urb->dev = serial->dev;
 719         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 720         if (result) {
 721                 dev_err(&port->dev, "%s - failed submitting read urb,"
 722                         " error %d\n", __func__, result);
 723                 pl2303_close(port);
 724                 return -EPROTO;
 725         }
 726
 727         dbg("%s - submitting interrupt urb", __func__);
 728         port->interrupt_in_urb->dev = serial->dev;
 729         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 730         if (result) {
 731                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 732                         " error %d\n", __func__, result);
 733                 pl2303_close(port);
 734                 return -EPROTO;
 735         }
 736         port->port.drain_delay = 256;
 737         return 0;
 738 }
 739
 740 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 741                            unsigned int set, unsigned int clear)
 742 {
 743         struct usb_serial_port *port = tty->driver_data;
 744         struct pl2303_private *priv = usb_get_serial_port_data(port);
 745         unsigned long flags;
 746         u8 control;
 747
 748         if (!usb_get_intfdata(port->serial->interface))
 749                 return -ENODEV;
 750
 751         spin_lock_irqsave(&priv->lock, flags);
 752         if (set & TIOCM_RTS)
 753                 priv->line_control |= CONTROL_RTS;
 754         if (set & TIOCM_DTR)
 755                 priv->line_control |= CONTROL_DTR;
 756         if (clear & TIOCM_RTS)
 757                 priv->line_control &= ~CONTROL_RTS;
 758         if (clear & TIOCM_DTR)
 759                 priv->line_control &= ~CONTROL_DTR;
 760         control = priv->line_control;
 761         spin_unlock_irqrestore(&priv->lock, flags);
 762
 763         return set_control_lines(port->serial->dev, control);
 764 }
 765
 766 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 767 {
 768         struct usb_serial_port *port = tty->driver_data;
 769         struct pl2303_private *priv = usb_get_serial_port_data(port);
 770         unsigned long flags;
 771         unsigned int mcr;
 772         unsigned int status;
 773         unsigned int result;
 774
 775         dbg("%s (%d)", __func__, port->number);
 776
 777         if (!usb_get_intfdata(port->serial->interface))
 778                 return -ENODEV;
 779
 780         spin_lock_irqsave(&priv->lock, flags);
 781         mcr = priv->line_control;
 782         status = priv->line_status;
 783         spin_unlock_irqrestore(&priv->lock, flags);
 784
 785         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 786                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 787                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 788                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 789                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 790                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 791
 792         dbg("%s - result = %x", __func__, result);
 793
 794         return result;
 795 }
 796
 797 static int pl2303_carrier_raised(struct usb_serial_port *port)
 798 {
 799         struct pl2303_private *priv = usb_get_serial_port_data(port);
 800         if (priv->line_status & UART_DCD)
 801                 return 1;
 802         return 0;
 803 }
 804
 805 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 806 {
 807         struct pl2303_private *priv = usb_get_serial_port_data(port);
 808         unsigned long flags;
 809         unsigned int prevstatus;
 810         unsigned int status;
 811         unsigned int changed;
 812
 813         spin_lock_irqsave(&priv->lock, flags);
 814         prevstatus = priv->line_status;
 815         spin_unlock_irqrestore(&priv->lock, flags);
 816
 817         while (1) {
 818                 interruptible_sleep_on(&priv->delta_msr_wait);
 819                 /* see if a signal did it */
 820                 if (signal_pending(current))
 821                         return -ERESTARTSYS;
 822
 823                 spin_lock_irqsave(&priv->lock, flags);
 824                 status = priv->line_status;
 825                 spin_unlock_irqrestore(&priv->lock, flags);
 826
 827                 changed = prevstatus ^ status;
 828
 829                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 830                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 831                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 832                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 833                         return 0;
 834                 }
 835                 prevstatus = status;
 836         }
 837         /* NOTREACHED */
 838         return 0;
 839 }
 840
 841 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 842                         unsigned int cmd, unsigned long arg)
 843 {
 844         struct usb_serial_port *port = tty->driver_data;
 845         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 846
 847         switch (cmd) {
 848         case TIOCMIWAIT:
 849                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 850                 return wait_modem_info(port, arg);
 851         default:
 852                 dbg("%s not supported = 0x%04x", __func__, cmd);
 853                 break;
 854         }
 855         return -ENOIOCTLCMD;
 856 }
 857
 858 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 859 {
 860         struct usb_serial_port *port = tty->driver_data;
 861         struct usb_serial *serial = port->serial;
 862         u16 state;
 863         int result;
 864
 865         dbg("%s - port %d", __func__, port->number);
 866
 867         if (break_state == 0)
 868                 state = BREAK_OFF;
 869         else
 870                 state = BREAK_ON;
 871         dbg("%s - turning break %s", __func__,
 872                         state == BREAK_OFF ? "off" : "on");
 873
 874         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 875                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 876                                  0, NULL, 0, 100);
 877         if (result)
 878                 dbg("%s - error sending break = %d", __func__, result);
 879 }
 880
 881 static void pl2303_release(struct usb_serial *serial)
 882 {
 883         int i;
 884         struct pl2303_private *priv;
 885
 886         dbg("%s", __func__);
 887
 888         for (i = 0; i < serial->num_ports; ++i) {
 889                 priv = usb_get_serial_port_data(serial->port[i]);
 890                 if (priv) {
 891                         pl2303_buf_free(priv->buf);
 892                         kfree(priv);
 893                 }
 894         }
 895 }
 896
 897 static void pl2303_update_line_status(struct usb_serial_port *port,
 898                                       unsigned char *data,
 899                                       unsigned int actual_length)
 900 {
 901
 902         struct pl2303_private *priv = usb_get_serial_port_data(port);
 903         unsigned long flags;
 904         u8 status_idx = UART_STATE;
 905         u8 length = UART_STATE + 1;
 906         u16 idv, idp;
 907
 908         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 909         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 910
 911
 912         if (idv == SIEMENS_VENDOR_ID) {
 913                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 914                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 915                     idp == SIEMENS_PRODUCT_ID_X75) {
 916
 917                         length = 1;
 918                         status_idx = 0;
 919                 }
 920         }
 921
 922         if (actual_length < length)
 923                 return;
 924
 925         /* Save off the uart status for others to look at */
 926         spin_lock_irqsave(&priv->lock, flags);
 927         priv->line_status = data[status_idx];
 928         spin_unlock_irqrestore(&priv->lock, flags);
 929         if (priv->line_status & UART_BREAK_ERROR)
 930                 usb_serial_handle_break(port);
 931         wake_up_interruptible(&priv->delta_msr_wait);
 932 }
 933
 934 static void pl2303_read_int_callback(struct urb *urb)
 935 {
 936         struct usb_serial_port *port =  urb->context;
 937         unsigned char *data = urb->transfer_buffer;
 938         unsigned int actual_length = urb->actual_length;
 939         int status = urb->status;
 940         int retval;
 941
 942         dbg("%s (%d)", __func__, port->number);
 943
 944         switch (status) {
 945         case 0:
 946                 /* success */
 947                 break;
 948         case -ECONNRESET:
 949         case -ENOENT:
 950         case -ESHUTDOWN:
 951                 /* this urb is terminated, clean up */
 952                 dbg("%s - urb shutting down with status: %d", __func__,
 953                     status);
 954                 return;
 955         default:
 956                 dbg("%s - nonzero urb status received: %d", __func__,
 957                     status);
 958                 goto exit;
 959         }
 960
 961         usb_serial_debug_data(debug, &port->dev, __func__,
 962                               urb->actual_length, urb->transfer_buffer);
 963
 964         pl2303_update_line_status(port, data, actual_length);
 965
 966 exit:
 967         retval = usb_submit_urb(urb, GFP_ATOMIC);
 968         if (retval)
 969                 dev_err(&urb->dev->dev,
 970                         "%s - usb_submit_urb failed with result %d\n",
 971                         __func__, retval);
 972 }
 973
 974 static void pl2303_read_bulk_callback(struct urb *urb)
 975 {
 976         struct usb_serial_port *port =  urb->context;
 977         struct pl2303_private *priv = usb_get_serial_port_data(port);
 978         struct tty_struct *tty;
 979         unsigned char *data = urb->transfer_buffer;
 980         unsigned long flags;
 981         int i;
 982         int result;
 983         int status = urb->status;
 984         u8 line_status;
 985         char tty_flag;
 986
 987         dbg("%s - port %d", __func__, port->number);
 988
 989         if (status) {
 990                 dbg("%s - urb status = %d", __func__, status);
 991                 if (!port->port.count) {
 992                         dbg("%s - port is closed, exiting.", __func__);
 993                         return;
 994                 }
 995                 if (status == -EPROTO) {
 996                         /* PL2303 mysteriously fails with -EPROTO reschedule
 997                          * the read */
 998                         dbg("%s - caught -EPROTO, resubmitting the urb",
 999                             __func__);
1000                         urb->dev = port->serial->dev;
1001                         result = usb_submit_urb(urb, GFP_ATOMIC);
1002                         if (result)
1003                                 dev_err(&urb->dev->dev, "%s - failed"
1004                                         " resubmitting read urb, error %d\n",
1005                                         __func__, result);
1006                         return;
1007                 }
1008                 dbg("%s - unable to handle the error, exiting.", __func__);
1009                 return;
1010         }
1011
1012         usb_serial_debug_data(debug, &port->dev, __func__,
1013                               urb->actual_length, data);
1014
1015         /* get tty_flag from status */
1016         tty_flag = TTY_NORMAL;
1017
1018         spin_lock_irqsave(&priv->lock, flags);
1019         line_status = priv->line_status;
1020         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1021         spin_unlock_irqrestore(&priv->lock, flags);
1022         wake_up_interruptible(&priv->delta_msr_wait);
1023
1024         /* break takes precedence over parity, */
1025         /* which takes precedence over framing errors */
1026         if (line_status & UART_BREAK_ERROR)
1027                 tty_flag = TTY_BREAK;
1028         else if (line_status & UART_PARITY_ERROR)
1029                 tty_flag = TTY_PARITY;
1030         else if (line_status & UART_FRAME_ERROR)
1031                 tty_flag = TTY_FRAME;
1032         dbg("%s - tty_flag = %d", __func__, tty_flag);
1033
1034         tty = tty_port_tty_get(&port->port);
1035         if (tty && urb->actual_length) {
1036                 tty_buffer_request_room(tty, urb->actual_length + 1);
1037                 /* overrun is special, not associated with a char */
1038                 if (line_status & UART_OVERRUN_ERROR)
1039                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1040                 for (i = 0; i < urb->actual_length; ++i)
1041                         if (!usb_serial_handle_sysrq_char(port, data[i]))
1042                                 tty_insert_flip_char(tty, data[i], tty_flag);
1043                 tty_flip_buffer_push(tty);
1044         }
1045         tty_kref_put(tty);
1046         /* Schedule the next read _if_ we are still open */
1047         if (port->port.count) {
1048                 urb->dev = port->serial->dev;
1049                 result = usb_submit_urb(urb, GFP_ATOMIC);
1050                 if (result)
1051                         dev_err(&urb->dev->dev, "%s - failed resubmitting"
1052                                 " read urb, error %d\n", __func__, result);
1053         }
1054
1055         return;
1056 }
1057
1058 static void pl2303_write_bulk_callback(struct urb *urb)
1059 {
1060         struct usb_serial_port *port =  urb->context;
1061         struct pl2303_private *priv = usb_get_serial_port_data(port);
1062         int result;
1063         int status = urb->status;
1064
1065         dbg("%s - port %d", __func__, port->number);
1066
1067         switch (status) {
1068         case 0:
1069                 /* success */
1070                 break;
1071         case -ECONNRESET:
1072         case -ENOENT:
1073         case -ESHUTDOWN:
1074                 /* this urb is terminated, clean up */
1075                 dbg("%s - urb shutting down with status: %d", __func__,
1076                     status);
1077                 priv->write_urb_in_use = 0;
1078                 return;
1079         default:
1080                 /* error in the urb, so we have to resubmit it */
1081                 dbg("%s - Overflow in write", __func__);
1082                 dbg("%s - nonzero write bulk status received: %d", __func__,
1083                     status);
1084                 port->write_urb->transfer_buffer_length = 1;
1085                 port->write_urb->dev = port->serial->dev;
1086                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1087                 if (result)
1088                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1089                                 " urb, error %d\n", __func__, result);
1090                 else
1091                         return;
1092         }
1093
1094         priv->write_urb_in_use = 0;
1095
1096         /* send any buffered data */
1097         pl2303_send(port);
1098 }
1099
1100 /* All of the device info needed for the PL2303 SIO serial converter */
1101 static struct usb_serial_driver pl2303_device = {
1102         .driver = {
1103                 .owner =        THIS_MODULE,
1104                 .name =         "pl2303",
1105         },
1106         .id_table =             id_table,
1107         .usb_driver =           &pl2303_driver,
1108         .num_ports =            1,
1109         .open =                 pl2303_open,
1110         .close =                pl2303_close,
1111         .dtr_rts =              pl2303_dtr_rts,
1112         .carrier_raised =       pl2303_carrier_raised,
1113         .write =                pl2303_write,
1114         .ioctl =                pl2303_ioctl,
1115         .break_ctl =            pl2303_break_ctl,
1116         .set_termios =          pl2303_set_termios,
1117         .tiocmget =             pl2303_tiocmget,
1118         .tiocmset =             pl2303_tiocmset,
1119         .read_bulk_callback =   pl2303_read_bulk_callback,
1120         .read_int_callback =    pl2303_read_int_callback,
1121         .write_bulk_callback =  pl2303_write_bulk_callback,
1122         .write_room =           pl2303_write_room,
1123         .chars_in_buffer =      pl2303_chars_in_buffer,
1124         .attach =               pl2303_startup,
1125         .release =              pl2303_release,
1126 };
1127
1128 static int __init pl2303_init(void)
1129 {
1130         int retval;
1131
1132         retval = usb_serial_register(&pl2303_device);
1133         if (retval)
1134                 goto failed_usb_serial_register;
1135         retval = usb_register(&pl2303_driver);
1136         if (retval)
1137                 goto failed_usb_register;
1138         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1139         return 0;
1140 failed_usb_register:
1141         usb_serial_deregister(&pl2303_device);
1142 failed_usb_serial_register:
1143         return retval;
1144 }
1145
1146 static void __exit pl2303_exit(void)
1147 {
1148         usb_deregister(&pl2303_driver);
1149         usb_serial_deregister(&pl2303_device);
1150 }
1151
1152 module_init(pl2303_init);
1153 module_exit(pl2303_exit);
1154
1155 MODULE_DESCRIPTION(DRIVER_DESC);
1156 MODULE_LICENSE("GPL");
1157
1158 module_param(debug, bool, S_IRUGO | S_IWUSR);
1159 MODULE_PARM_DESC(debug, "Debug enabled or not");
1160