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