git.oblomov.eu Git - linux-2.6/blob - drivers/usb/serial/pl2303.c

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