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