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