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