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