?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / usb / serial / pl2303.c
blobae3ec1a64008b65e2b10f4a95152ea74e6c23729
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 port->serial->disconnected)
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
WRT350N Kernel Patches