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