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         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", __func__, 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", __func__, 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, __func__, 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", __func__, 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 tty_struct *tty, struct usb_serial_port *port,
 461                                 const unsigned char *buf, 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", __func__, 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 tty_struct *tty)
 481 {
 482         struct usb_serial_port *port = tty->driver_data;
 483         struct pl2303_private *priv = usb_get_serial_port_data(port);
 484         int room = 0;
 485         unsigned long flags;
 486
 487         dbg("%s - port %d", __func__, port->number);
 488
 489         spin_lock_irqsave(&priv->lock, flags);
 490         room = pl2303_buf_space_avail(priv->buf);
 491         spin_unlock_irqrestore(&priv->lock, flags);
 492
 493         dbg("%s - returns %d", __func__, room);
 494         return room;
 495 }
 496
 497 static int pl2303_chars_in_buffer(struct tty_struct *tty)
 498 {
 499         struct usb_serial_port *port = tty->driver_data;
 500         struct pl2303_private *priv = usb_get_serial_port_data(port);
 501         int chars = 0;
 502         unsigned long flags;
 503
 504         dbg("%s - port %d", __func__, port->number);
 505
 506         spin_lock_irqsave(&priv->lock, flags);
 507         chars = pl2303_buf_data_avail(priv->buf);
 508         spin_unlock_irqrestore(&priv->lock, flags);
 509
 510         dbg("%s - returns %d", __func__, chars);
 511         return chars;
 512 }
 513
 514 static void pl2303_set_termios(struct tty_struct *tty,
 515                 struct usb_serial_port *port, struct ktermios *old_termios)
 516 {
 517         struct usb_serial *serial = port->serial;
 518         struct pl2303_private *priv = usb_get_serial_port_data(port);
 519         unsigned long flags;
 520         unsigned int cflag;
 521         unsigned char *buf;
 522         int baud;
 523         int i;
 524         u8 control;
 525
 526         dbg("%s -  port %d", __func__, port->number);
 527
 528         /* The PL2303 is reported to lose bytes if you change
 529            serial settings even to the same values as before. Thus
 530            we actually need to filter in this specific case */
 531
 532         if (!tty_termios_hw_change(tty->termios, old_termios))
 533                 return;
 534
 535         cflag = tty->termios->c_cflag;
 536
 537         buf = kzalloc(7, GFP_KERNEL);
 538         if (!buf) {
 539                 dev_err(&port->dev, "%s - out of memory.\n", __func__);
 540                 /* Report back no change occurred */
 541                 *tty->termios = *old_termios;
 542                 return;
 543         }
 544
 545         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 546                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 547                             0, 0, buf, 7, 100);
 548         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 549             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 550
 551         if (cflag & CSIZE) {
 552                 switch (cflag & CSIZE) {
 553                 case CS5:
 554                         buf[6] = 5;
 555                         break;
 556                 case CS6:
 557                         buf[6] = 6;
 558                         break;
 559                 case CS7:
 560                         buf[6] = 7;
 561                         break;
 562                 default:
 563                 case CS8:
 564                         buf[6] = 8;
 565                         break;
 566                 }
 567                 dbg("%s - data bits = %d", __func__, buf[6]);
 568         }
 569
 570         baud = tty_get_baud_rate(tty);
 571         dbg("%s - baud = %d", __func__, baud);
 572         if (baud) {
 573                 buf[0] = baud & 0xff;
 574                 buf[1] = (baud >> 8) & 0xff;
 575                 buf[2] = (baud >> 16) & 0xff;
 576                 buf[3] = (baud >> 24) & 0xff;
 577         }
 578
 579         /* For reference buf[4]=0 is 1 stop bits */
 580         /* For reference buf[4]=1 is 1.5 stop bits */
 581         /* For reference buf[4]=2 is 2 stop bits */
 582         if (cflag & CSTOPB) {
 583                 buf[4] = 2;
 584                 dbg("%s - stop bits = 2", __func__);
 585         } else {
 586                 buf[4] = 0;
 587                 dbg("%s - stop bits = 1", __func__);
 588         }
 589
 590         if (cflag & PARENB) {
 591                 /* For reference buf[5]=0 is none parity */
 592                 /* For reference buf[5]=1 is odd parity */
 593                 /* For reference buf[5]=2 is even parity */
 594                 /* For reference buf[5]=3 is mark parity */
 595                 /* For reference buf[5]=4 is space parity */
 596                 if (cflag & PARODD) {
 597                         buf[5] = 1;
 598                         dbg("%s - parity = odd", __func__);
 599                 } else {
 600                         buf[5] = 2;
 601                         dbg("%s - parity = even", __func__);
 602                 }
 603         } else {
 604                 buf[5] = 0;
 605                 dbg("%s - parity = none", __func__);
 606         }
 607
 608         i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 609                             SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
 610                             0, 0, buf, 7, 100);
 611         dbg("0x21:0x20:0:0  %d", i);
 612
 613         /* change control lines if we are switching to or from B0 */
 614         spin_lock_irqsave(&priv->lock, flags);
 615         control = priv->line_control;
 616         if ((cflag & CBAUD) == B0)
 617                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
 618         else
 619                 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
 620         if (control != priv->line_control) {
 621                 control = priv->line_control;
 622                 spin_unlock_irqrestore(&priv->lock, flags);
 623                 set_control_lines(serial->dev, control);
 624         } else {
 625                 spin_unlock_irqrestore(&priv->lock, flags);
 626         }
 627
 628         buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
 629
 630         i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 631                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
 632                             0, 0, buf, 7, 100);
 633         dbg("0xa1:0x21:0:0  %d - %x %x %x %x %x %x %x", i,
 634              buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
 635
 636         if (cflag & CRTSCTS) {
 637                 if (priv->type == HX)
 638                         pl2303_vendor_write(0x0, 0x61, serial);
 639                 else
 640                         pl2303_vendor_write(0x0, 0x41, serial);
 641         } else {
 642                 pl2303_vendor_write(0x0, 0x0, serial);
 643         }
 644
 645         /* FIXME: Need to read back resulting baud rate */
 646         if (baud)
 647                 tty_encode_baud_rate(tty, baud, baud);
 648
 649         kfree(buf);
 650 }
 651
 652 static void pl2303_close(struct tty_struct *tty,
 653                         struct usb_serial_port *port, struct file *filp)
 654 {
 655         struct pl2303_private *priv = usb_get_serial_port_data(port);
 656         unsigned long flags;
 657         unsigned int c_cflag;
 658         int bps;
 659         long timeout;
 660         wait_queue_t wait;
 661
 662         dbg("%s - port %d", __func__, port->number);
 663
 664         /* wait for data to drain from the buffer */
 665         spin_lock_irqsave(&priv->lock, flags);
 666         timeout = PL2303_CLOSING_WAIT;
 667         init_waitqueue_entry(&wait, current);
 668         add_wait_queue(&tty->write_wait, &wait);
 669         for (;;) {
 670                 set_current_state(TASK_INTERRUPTIBLE);
 671                 if (pl2303_buf_data_avail(priv->buf) == 0 ||
 672                     timeout == 0 || signal_pending(current) ||
 673                     port->serial->disconnected)
 674                         break;
 675                 spin_unlock_irqrestore(&priv->lock, flags);
 676                 timeout = schedule_timeout(timeout);
 677                 spin_lock_irqsave(&priv->lock, flags);
 678         }
 679         set_current_state(TASK_RUNNING);
 680         remove_wait_queue(&tty->write_wait, &wait);
 681         /* clear out any remaining data in the buffer */
 682         pl2303_buf_clear(priv->buf);
 683         spin_unlock_irqrestore(&priv->lock, flags);
 684
 685         /* wait for characters to drain from the device */
 686         /* (this is long enough for the entire 256 byte */
 687         /* pl2303 hardware buffer to drain with no flow */
 688         /* control for data rates of 1200 bps or more, */
 689         /* for lower rates we should really know how much */
 690         /* data is in the buffer to compute a delay */
 691         /* that is not unnecessarily long) */
 692         bps = tty_get_baud_rate(tty);
 693         if (bps > 1200)
 694                 timeout = max((HZ*2560)/bps, HZ/10);
 695         else
 696                 timeout = 2*HZ;
 697         schedule_timeout_interruptible(timeout);
 698
 699         /* shutdown our urbs */
 700         dbg("%s - shutting down urbs", __func__);
 701         usb_kill_urb(port->write_urb);
 702         usb_kill_urb(port->read_urb);
 703         usb_kill_urb(port->interrupt_in_urb);
 704
 705         if (tty) {
 706                 c_cflag = tty->termios->c_cflag;
 707                 if (c_cflag & HUPCL) {
 708                         /* drop DTR and RTS */
 709                         spin_lock_irqsave(&priv->lock, flags);
 710                         priv->line_control = 0;
 711                         spin_unlock_irqrestore(&priv->lock, flags);
 712                         set_control_lines(port->serial->dev, 0);
 713                 }
 714         }
 715 }
 716
 717 static int pl2303_open(struct tty_struct *tty,
 718                         struct usb_serial_port *port, struct file *filp)
 719 {
 720         struct ktermios tmp_termios;
 721         struct usb_serial *serial = port->serial;
 722         struct pl2303_private *priv = usb_get_serial_port_data(port);
 723         int result;
 724
 725         dbg("%s -  port %d", __func__, port->number);
 726
 727         if (priv->type != HX) {
 728                 usb_clear_halt(serial->dev, port->write_urb->pipe);
 729                 usb_clear_halt(serial->dev, port->read_urb->pipe);
 730         } else {
 731                 /* reset upstream data pipes */
 732                 pl2303_vendor_write(8, 0, serial);
 733                 pl2303_vendor_write(9, 0, serial);
 734         }
 735
 736         /* Setup termios */
 737         if (tty)
 738                 pl2303_set_termios(tty, port, &tmp_termios);
 739
 740         /* FIXME: need to assert RTS and DTR if CRTSCTS off */
 741
 742         dbg("%s - submitting read urb", __func__);
 743         port->read_urb->dev = serial->dev;
 744         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
 745         if (result) {
 746                 dev_err(&port->dev, "%s - failed submitting read urb,"
 747                         " error %d\n", __func__, result);
 748                 pl2303_close(tty, port, NULL);
 749                 return -EPROTO;
 750         }
 751
 752         dbg("%s - submitting interrupt urb", __func__);
 753         port->interrupt_in_urb->dev = serial->dev;
 754         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 755         if (result) {
 756                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 757                         " error %d\n", __func__, result);
 758                 pl2303_close(tty, port, NULL);
 759                 return -EPROTO;
 760         }
 761         return 0;
 762 }
 763
 764 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
 765                            unsigned int set, unsigned int clear)
 766 {
 767         struct usb_serial_port *port = tty->driver_data;
 768         struct pl2303_private *priv = usb_get_serial_port_data(port);
 769         unsigned long flags;
 770         u8 control;
 771
 772         if (!usb_get_intfdata(port->serial->interface))
 773                 return -ENODEV;
 774
 775         spin_lock_irqsave(&priv->lock, flags);
 776         if (set & TIOCM_RTS)
 777                 priv->line_control |= CONTROL_RTS;
 778         if (set & TIOCM_DTR)
 779                 priv->line_control |= CONTROL_DTR;
 780         if (clear & TIOCM_RTS)
 781                 priv->line_control &= ~CONTROL_RTS;
 782         if (clear & TIOCM_DTR)
 783                 priv->line_control &= ~CONTROL_DTR;
 784         control = priv->line_control;
 785         spin_unlock_irqrestore(&priv->lock, flags);
 786
 787         return set_control_lines(port->serial->dev, control);
 788 }
 789
 790 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
 791 {
 792         struct usb_serial_port *port = tty->driver_data;
 793         struct pl2303_private *priv = usb_get_serial_port_data(port);
 794         unsigned long flags;
 795         unsigned int mcr;
 796         unsigned int status;
 797         unsigned int result;
 798
 799         dbg("%s (%d)", __func__, port->number);
 800
 801         if (!usb_get_intfdata(port->serial->interface))
 802                 return -ENODEV;
 803
 804         spin_lock_irqsave(&priv->lock, flags);
 805         mcr = priv->line_control;
 806         status = priv->line_status;
 807         spin_unlock_irqrestore(&priv->lock, flags);
 808
 809         result = ((mcr & CONTROL_DTR)           ? TIOCM_DTR : 0)
 810                   | ((mcr & CONTROL_RTS)        ? TIOCM_RTS : 0)
 811                   | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 812                   | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 813                   | ((status & UART_RING)       ? TIOCM_RI  : 0)
 814                   | ((status & UART_DCD)        ? TIOCM_CD  : 0);
 815
 816         dbg("%s - result = %x", __func__, result);
 817
 818         return result;
 819 }
 820
 821 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 822 {
 823         struct pl2303_private *priv = usb_get_serial_port_data(port);
 824         unsigned long flags;
 825         unsigned int prevstatus;
 826         unsigned int status;
 827         unsigned int changed;
 828
 829         spin_lock_irqsave(&priv->lock, flags);
 830         prevstatus = priv->line_status;
 831         spin_unlock_irqrestore(&priv->lock, flags);
 832
 833         while (1) {
 834                 interruptible_sleep_on(&priv->delta_msr_wait);
 835                 /* see if a signal did it */
 836                 if (signal_pending(current))
 837                         return -ERESTARTSYS;
 838
 839                 spin_lock_irqsave(&priv->lock, flags);
 840                 status = priv->line_status;
 841                 spin_unlock_irqrestore(&priv->lock, flags);
 842
 843                 changed = prevstatus ^ status;
 844
 845                 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
 846                     ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
 847                     ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
 848                     ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
 849                         return 0;
 850                 }
 851                 prevstatus = status;
 852         }
 853         /* NOTREACHED */
 854         return 0;
 855 }
 856
 857 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
 858                         unsigned int cmd, unsigned long arg)
 859 {
 860         struct usb_serial_port *port = tty->driver_data;
 861         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 862
 863         switch (cmd) {
 864         case TIOCMIWAIT:
 865                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 866                 return wait_modem_info(port, arg);
 867         default:
 868                 dbg("%s not supported = 0x%04x", __func__, cmd);
 869                 break;
 870         }
 871         return -ENOIOCTLCMD;
 872 }
 873
 874 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
 875 {
 876         struct usb_serial_port *port = tty->driver_data;
 877         struct usb_serial *serial = port->serial;
 878         u16 state;
 879         int result;
 880
 881         dbg("%s - port %d", __func__, port->number);
 882
 883         if (break_state == 0)
 884                 state = BREAK_OFF;
 885         else
 886                 state = BREAK_ON;
 887         dbg("%s - turning break %s", __func__,
 888                         state == BREAK_OFF ? "off" : "on");
 889
 890         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 891                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
 892                                  0, NULL, 0, 100);
 893         if (result)
 894                 dbg("%s - error sending break = %d", __func__, result);
 895 }
 896
 897 static void pl2303_shutdown(struct usb_serial *serial)
 898 {
 899         int i;
 900         struct pl2303_private *priv;
 901
 902         dbg("%s", __func__);
 903
 904         for (i = 0; i < serial->num_ports; ++i) {
 905                 priv = usb_get_serial_port_data(serial->port[i]);
 906                 if (priv) {
 907                         pl2303_buf_free(priv->buf);
 908                         kfree(priv);
 909                         usb_set_serial_port_data(serial->port[i], NULL);
 910                 }
 911         }
 912 }
 913
 914 static void pl2303_update_line_status(struct usb_serial_port *port,
 915                                       unsigned char *data,
 916                                       unsigned int actual_length)
 917 {
 918
 919         struct pl2303_private *priv = usb_get_serial_port_data(port);
 920         unsigned long flags;
 921         u8 status_idx = UART_STATE;
 922         u8 length = UART_STATE + 1;
 923         u16 idv, idp;
 924
 925         idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
 926         idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
 927
 928
 929         if (idv == SIEMENS_VENDOR_ID) {
 930                 if (idp == SIEMENS_PRODUCT_ID_X65 ||
 931                     idp == SIEMENS_PRODUCT_ID_SX1 ||
 932                     idp == SIEMENS_PRODUCT_ID_X75) {
 933
 934                         length = 1;
 935                         status_idx = 0;
 936                 }
 937         }
 938
 939         if (actual_length < length)
 940                 return;
 941
 942         /* Save off the uart status for others to look at */
 943         spin_lock_irqsave(&priv->lock, flags);
 944         priv->line_status = data[status_idx];
 945         spin_unlock_irqrestore(&priv->lock, flags);
 946         wake_up_interruptible(&priv->delta_msr_wait);
 947 }
 948
 949 static void pl2303_read_int_callback(struct urb *urb)
 950 {
 951         struct usb_serial_port *port =  urb->context;
 952         unsigned char *data = urb->transfer_buffer;
 953         unsigned int actual_length = urb->actual_length;
 954         int status = urb->status;
 955         int retval;
 956
 957         dbg("%s (%d)", __func__, port->number);
 958
 959         switch (status) {
 960         case 0:
 961                 /* success */
 962                 break;
 963         case -ECONNRESET:
 964         case -ENOENT:
 965         case -ESHUTDOWN:
 966                 /* this urb is terminated, clean up */
 967                 dbg("%s - urb shutting down with status: %d", __func__,
 968                     status);
 969                 return;
 970         default:
 971                 dbg("%s - nonzero urb status received: %d", __func__,
 972                     status);
 973                 goto exit;
 974         }
 975
 976         usb_serial_debug_data(debug, &port->dev, __func__,
 977                               urb->actual_length, urb->transfer_buffer);
 978
 979         pl2303_update_line_status(port, data, actual_length);
 980
 981 exit:
 982         retval = usb_submit_urb(urb, GFP_ATOMIC);
 983         if (retval)
 984                 dev_err(&urb->dev->dev,
 985                         "%s - usb_submit_urb failed with result %d\n",
 986                         __func__, retval);
 987 }
 988
 989 static void pl2303_read_bulk_callback(struct urb *urb)
 990 {
 991         struct usb_serial_port *port =  urb->context;
 992         struct pl2303_private *priv = usb_get_serial_port_data(port);
 993         struct tty_struct *tty;
 994         unsigned char *data = urb->transfer_buffer;
 995         unsigned long flags;
 996         int i;
 997         int result;
 998         int status = urb->status;
 999         u8 line_status;
1000         char tty_flag;
1001
1002         dbg("%s - port %d", __func__, port->number);
1003
1004         if (status) {
1005                 dbg("%s - urb status = %d", __func__, status);
1006                 if (!port->port.count) {
1007                         dbg("%s - port is closed, exiting.", __func__);
1008                         return;
1009                 }
1010                 if (status == -EPROTO) {
1011                         /* PL2303 mysteriously fails with -EPROTO reschedule
1012                          * the read */
1013                         dbg("%s - caught -EPROTO, resubmitting the urb",
1014                             __func__);
1015                         urb->dev = port->serial->dev;
1016                         result = usb_submit_urb(urb, GFP_ATOMIC);
1017                         if (result)
1018                                 dev_err(&urb->dev->dev, "%s - failed"
1019                                         " resubmitting read urb, error %d\n",
1020                                         __func__, result);
1021                         return;
1022                 }
1023                 dbg("%s - unable to handle the error, exiting.", __func__);
1024                 return;
1025         }
1026
1027         usb_serial_debug_data(debug, &port->dev, __func__,
1028                               urb->actual_length, data);
1029
1030         /* get tty_flag from status */
1031         tty_flag = TTY_NORMAL;
1032
1033         spin_lock_irqsave(&priv->lock, flags);
1034         line_status = priv->line_status;
1035         priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1036         spin_unlock_irqrestore(&priv->lock, flags);
1037         wake_up_interruptible(&priv->delta_msr_wait);
1038
1039         /* break takes precedence over parity, */
1040         /* which takes precedence over framing errors */
1041         if (line_status & UART_BREAK_ERROR)
1042                 tty_flag = TTY_BREAK;
1043         else if (line_status & UART_PARITY_ERROR)
1044                 tty_flag = TTY_PARITY;
1045         else if (line_status & UART_FRAME_ERROR)
1046                 tty_flag = TTY_FRAME;
1047         dbg("%s - tty_flag = %d", __func__, tty_flag);
1048
1049         tty = tty_port_tty_get(&port->port);
1050         if (tty && urb->actual_length) {
1051                 tty_buffer_request_room(tty, urb->actual_length + 1);
1052                 /* overrun is special, not associated with a char */
1053                 if (line_status & UART_OVERRUN_ERROR)
1054                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1055                 for (i = 0; i < urb->actual_length; ++i)
1056                         tty_insert_flip_char(tty, data[i], tty_flag);
1057                 tty_flip_buffer_push(tty);
1058         }
1059         tty_kref_put(tty);
1060         /* Schedule the next read _if_ we are still open */
1061         if (port->port.count) {
1062                 urb->dev = port->serial->dev;
1063                 result = usb_submit_urb(urb, GFP_ATOMIC);
1064                 if (result)
1065                         dev_err(&urb->dev->dev, "%s - failed resubmitting"
1066                                 " read urb, error %d\n", __func__, result);
1067         }
1068
1069         return;
1070 }
1071
1072 static void pl2303_write_bulk_callback(struct urb *urb)
1073 {
1074         struct usb_serial_port *port =  urb->context;
1075         struct pl2303_private *priv = usb_get_serial_port_data(port);
1076         int result;
1077         int status = urb->status;
1078
1079         dbg("%s - port %d", __func__, port->number);
1080
1081         switch (status) {
1082         case 0:
1083                 /* success */
1084                 break;
1085         case -ECONNRESET:
1086         case -ENOENT:
1087         case -ESHUTDOWN:
1088                 /* this urb is terminated, clean up */
1089                 dbg("%s - urb shutting down with status: %d", __func__,
1090                     status);
1091                 priv->write_urb_in_use = 0;
1092                 return;
1093         default:
1094                 /* error in the urb, so we have to resubmit it */
1095                 dbg("%s - Overflow in write", __func__);
1096                 dbg("%s - nonzero write bulk status received: %d", __func__,
1097                     status);
1098                 port->write_urb->transfer_buffer_length = 1;
1099                 port->write_urb->dev = port->serial->dev;
1100                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1101                 if (result)
1102                         dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1103                                 " urb, error %d\n", __func__, result);
1104                 else
1105                         return;
1106         }
1107
1108         priv->write_urb_in_use = 0;
1109
1110         /* send any buffered data */
1111         pl2303_send(port);
1112 }
1113
1114 /* All of the device info needed for the PL2303 SIO serial converter */
1115 static struct usb_serial_driver pl2303_device = {
1116         .driver = {
1117                 .owner =        THIS_MODULE,
1118                 .name =         "pl2303",
1119         },
1120         .id_table =             id_table,
1121         .usb_driver =           &pl2303_driver,
1122         .num_ports =            1,
1123         .open =                 pl2303_open,
1124         .close =                pl2303_close,
1125         .write =                pl2303_write,
1126         .ioctl =                pl2303_ioctl,
1127         .break_ctl =            pl2303_break_ctl,
1128         .set_termios =          pl2303_set_termios,
1129         .tiocmget =             pl2303_tiocmget,
1130         .tiocmset =             pl2303_tiocmset,
1131         .read_bulk_callback =   pl2303_read_bulk_callback,
1132         .read_int_callback =    pl2303_read_int_callback,
1133         .write_bulk_callback =  pl2303_write_bulk_callback,
1134         .write_room =           pl2303_write_room,
1135         .chars_in_buffer =      pl2303_chars_in_buffer,
1136         .attach =               pl2303_startup,
1137         .shutdown =             pl2303_shutdown,
1138 };
1139
1140 static int __init pl2303_init(void)
1141 {
1142         int retval;
1143
1144         retval = usb_serial_register(&pl2303_device);
1145         if (retval)
1146                 goto failed_usb_serial_register;
1147         retval = usb_register(&pl2303_driver);
1148         if (retval)
1149                 goto failed_usb_register;
1150         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1151         return 0;
1152 failed_usb_register:
1153         usb_serial_deregister(&pl2303_device);
1154 failed_usb_serial_register:
1155         return retval;
1156 }
1157
1158 static void __exit pl2303_exit(void)
1159 {
1160         usb_deregister(&pl2303_driver);
1161         usb_serial_deregister(&pl2303_device);
1162 }
1163
1164 module_init(pl2303_init);
1165 module_exit(pl2303_exit);
1166
1167 MODULE_DESCRIPTION(DRIVER_DESC);
1168 MODULE_LICENSE("GPL");
1169
1170 module_param(debug, bool, S_IRUGO | S_IWUSR);
1171 MODULE_PARM_DESC(debug, "Debug enabled or not");
1172