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