drivers/usb/serial/pl2303.c

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