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