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