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