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