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