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 const struct usb_device_id id_table[] = {
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
51 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
52 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
53 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
54 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
55 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
56 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
57 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
58 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
59 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
60 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
61 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
62 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
63 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
64 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
65 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
66 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
67 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
68 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
70 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) },
71 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
72 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
73 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
74 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
75 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
76 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
77 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
78 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
79 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
80 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
81 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
82 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
83 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
84 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
85 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
86 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
87 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
88 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
89 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
90 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
91 { }
92};
93
94MODULE_DEVICE_TABLE(usb, id_table);
95
96#define SET_LINE_REQUEST_TYPE 0x21
97#define SET_LINE_REQUEST 0x20
98
99#define SET_CONTROL_REQUEST_TYPE 0x21
100#define SET_CONTROL_REQUEST 0x22
101#define CONTROL_DTR 0x01
102#define CONTROL_RTS 0x02
103
104#define BREAK_REQUEST_TYPE 0x21
105#define BREAK_REQUEST 0x23
106#define BREAK_ON 0xffff
107#define BREAK_OFF 0x0000
108
109#define GET_LINE_REQUEST_TYPE 0xa1
110#define GET_LINE_REQUEST 0x21
111
112#define VENDOR_WRITE_REQUEST_TYPE 0x40
113#define VENDOR_WRITE_REQUEST 0x01
114
115#define VENDOR_READ_REQUEST_TYPE 0xc0
116#define VENDOR_READ_REQUEST 0x01
117
118#define UART_STATE 0x08
119#define UART_STATE_TRANSIENT_MASK 0x74
120#define UART_DCD 0x01
121#define UART_DSR 0x02
122#define UART_BREAK_ERROR 0x04
123#define UART_RING 0x08
124#define UART_FRAME_ERROR 0x10
125#define UART_PARITY_ERROR 0x20
126#define UART_OVERRUN_ERROR 0x40
127#define UART_CTS 0x80
128
129
130enum pl2303_type {
131 type_0,
132 type_1,
133 HX,
134};
135
136struct pl2303_serial_private {
137 enum pl2303_type type;
138};
139
140struct pl2303_private {
141 spinlock_t lock;
142 u8 line_control;
143 u8 line_status;
144};
145
146static int pl2303_vendor_read(__u16 value, __u16 index,
147 struct usb_serial *serial, unsigned char *buf)
148{
149 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
150 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
151 value, index, buf, 1, 100);
152 dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x %d - %x\n",
153 VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
154 res, buf[0]);
155 return res;
156}
157
158static int pl2303_vendor_write(__u16 value, __u16 index,
159 struct usb_serial *serial)
160{
161 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
162 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
163 value, index, NULL, 0, 100);
164 dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x %d\n",
165 VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
166 res);
167 return res;
168}
169
170static int pl2303_startup(struct usb_serial *serial)
171{
172 struct pl2303_serial_private *spriv;
173 enum pl2303_type type = type_0;
174 unsigned char *buf;
175
176 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
177 if (!spriv)
178 return -ENOMEM;
179
180 buf = kmalloc(10, GFP_KERNEL);
181 if (!buf) {
182 kfree(spriv);
183 return -ENOMEM;
184 }
185
186 if (serial->dev->descriptor.bDeviceClass == 0x02)
187 type = type_0;
188 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
189 type = HX;
190 else if (serial->dev->descriptor.bDeviceClass == 0x00)
191 type = type_1;
192 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
193 type = type_1;
194 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
195
196 spriv->type = type;
197 usb_set_serial_data(serial, spriv);
198
199 pl2303_vendor_read(0x8484, 0, serial, buf);
200 pl2303_vendor_write(0x0404, 0, serial);
201 pl2303_vendor_read(0x8484, 0, serial, buf);
202 pl2303_vendor_read(0x8383, 0, serial, buf);
203 pl2303_vendor_read(0x8484, 0, serial, buf);
204 pl2303_vendor_write(0x0404, 1, serial);
205 pl2303_vendor_read(0x8484, 0, serial, buf);
206 pl2303_vendor_read(0x8383, 0, serial, buf);
207 pl2303_vendor_write(0, 1, serial);
208 pl2303_vendor_write(1, 0, serial);
209 if (type == HX)
210 pl2303_vendor_write(2, 0x44, serial);
211 else
212 pl2303_vendor_write(2, 0x24, serial);
213
214 kfree(buf);
215 return 0;
216}
217
218static void pl2303_release(struct usb_serial *serial)
219{
220 struct pl2303_serial_private *spriv;
221
222 spriv = usb_get_serial_data(serial);
223 kfree(spriv);
224}
225
226static int pl2303_port_probe(struct usb_serial_port *port)
227{
228 struct pl2303_private *priv;
229
230 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
231 if (!priv)
232 return -ENOMEM;
233
234 spin_lock_init(&priv->lock);
235
236 usb_set_serial_port_data(port, priv);
237
238 return 0;
239}
240
241static int pl2303_port_remove(struct usb_serial_port *port)
242{
243 struct pl2303_private *priv;
244
245 priv = usb_get_serial_port_data(port);
246 kfree(priv);
247
248 return 0;
249}
250
251static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
252{
253 struct usb_device *dev = port->serial->dev;
254 int retval;
255
256 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
257 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
258 value, 0, NULL, 0, 100);
259 dev_dbg(&port->dev, "%s - value = %d, retval = %d\n", __func__,
260 value, retval);
261 return retval;
262}
263
264static void pl2303_set_termios(struct tty_struct *tty,
265 struct usb_serial_port *port, struct ktermios *old_termios)
266{
267 struct usb_serial *serial = port->serial;
268 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
269 struct pl2303_private *priv = usb_get_serial_port_data(port);
270 unsigned long flags;
271 unsigned int cflag;
272 unsigned char *buf;
273 int baud;
274 int i;
275 u8 control;
276 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
277 4800, 7200, 9600, 14400, 19200, 28800, 38400,
278 57600, 115200, 230400, 460800, 500000, 614400,
279 921600, 1228800, 2457600, 3000000, 6000000 };
280 int baud_floor, baud_ceil;
281 int k;
282
283
284
285
286
287 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
288 return;
289
290 cflag = tty->termios.c_cflag;
291
292 buf = kzalloc(7, GFP_KERNEL);
293 if (!buf) {
294 dev_err(&port->dev, "%s - out of memory.\n", __func__);
295
296 if (old_termios)
297 tty->termios = *old_termios;
298 return;
299 }
300
301 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
302 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
303 0, 0, buf, 7, 100);
304 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %7ph\n", i, buf);
305
306 if (cflag & CSIZE) {
307 switch (cflag & CSIZE) {
308 case CS5:
309 buf[6] = 5;
310 break;
311 case CS6:
312 buf[6] = 6;
313 break;
314 case CS7:
315 buf[6] = 7;
316 break;
317 default:
318 case CS8:
319 buf[6] = 8;
320 break;
321 }
322 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
323 }
324
325
326
327
328
329
330 baud = tty_get_baud_rate(tty);
331 dev_dbg(&port->dev, "baud requested = %d\n", baud);
332 if (baud) {
333
334 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
335 if (baud_sup[k] / baud) {
336 baud_ceil = baud_sup[k];
337 if (k==0) {
338 baud = baud_ceil;
339 } else {
340 baud_floor = baud_sup[k-1];
341 if ((baud_ceil % baud)
342 > (baud % baud_floor))
343 baud = baud_floor;
344 else
345 baud = baud_ceil;
346 }
347 break;
348 }
349 }
350 if (baud > 1228800) {
351
352 if (spriv->type != HX)
353 baud = 1228800;
354 else if (baud > 6000000)
355 baud = 6000000;
356 }
357 dev_dbg(&port->dev, "baud set = %d\n", baud);
358 if (baud <= 115200) {
359 buf[0] = baud & 0xff;
360 buf[1] = (baud >> 8) & 0xff;
361 buf[2] = (baud >> 16) & 0xff;
362 buf[3] = (baud >> 24) & 0xff;
363 } else {
364
365
366
367 unsigned tmp = 12*1000*1000*32 / baud;
368 buf[3] = 0x80;
369 buf[2] = 0;
370 buf[1] = (tmp >= 256);
371 while (tmp >= 256) {
372 tmp >>= 2;
373 buf[1] <<= 1;
374 }
375 buf[0] = tmp;
376 }
377 }
378
379
380
381
382 if (cflag & CSTOPB) {
383
384
385
386 if ((cflag & CSIZE) == CS5) {
387 buf[4] = 1;
388 dev_dbg(&port->dev, "stop bits = 1.5\n");
389 } else {
390 buf[4] = 2;
391 dev_dbg(&port->dev, "stop bits = 2\n");
392 }
393 } else {
394 buf[4] = 0;
395 dev_dbg(&port->dev, "stop bits = 1\n");
396 }
397
398 if (cflag & PARENB) {
399
400
401
402
403
404 if (cflag & PARODD) {
405 if (cflag & CMSPAR) {
406 buf[5] = 3;
407 dev_dbg(&port->dev, "parity = mark\n");
408 } else {
409 buf[5] = 1;
410 dev_dbg(&port->dev, "parity = odd\n");
411 }
412 } else {
413 if (cflag & CMSPAR) {
414 buf[5] = 4;
415 dev_dbg(&port->dev, "parity = space\n");
416 } else {
417 buf[5] = 2;
418 dev_dbg(&port->dev, "parity = even\n");
419 }
420 }
421 } else {
422 buf[5] = 0;
423 dev_dbg(&port->dev, "parity = none\n");
424 }
425
426 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
427 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
428 0, 0, buf, 7, 100);
429 dev_dbg(&port->dev, "0x21:0x20:0:0 %d\n", i);
430
431
432 spin_lock_irqsave(&priv->lock, flags);
433 control = priv->line_control;
434 if ((cflag & CBAUD) == B0)
435 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
436 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
437 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
438 if (control != priv->line_control) {
439 control = priv->line_control;
440 spin_unlock_irqrestore(&priv->lock, flags);
441 pl2303_set_control_lines(port, control);
442 } else {
443 spin_unlock_irqrestore(&priv->lock, flags);
444 }
445
446 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
447
448 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
449 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
450 0, 0, buf, 7, 100);
451 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %7ph\n", i, buf);
452
453 if (cflag & CRTSCTS) {
454 if (spriv->type == HX)
455 pl2303_vendor_write(0x0, 0x61, serial);
456 else
457 pl2303_vendor_write(0x0, 0x41, serial);
458 } else {
459 pl2303_vendor_write(0x0, 0x0, serial);
460 }
461
462
463 if (baud)
464 tty_encode_baud_rate(tty, baud, baud);
465
466 kfree(buf);
467}
468
469static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
470{
471 struct pl2303_private *priv = usb_get_serial_port_data(port);
472 unsigned long flags;
473 u8 control;
474
475 spin_lock_irqsave(&priv->lock, flags);
476
477 if (on)
478 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
479 else
480 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
481 control = priv->line_control;
482 spin_unlock_irqrestore(&priv->lock, flags);
483 pl2303_set_control_lines(port, control);
484}
485
486static void pl2303_close(struct usb_serial_port *port)
487{
488 usb_serial_generic_close(port);
489 usb_kill_urb(port->interrupt_in_urb);
490}
491
492static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
493{
494 struct usb_serial *serial = port->serial;
495 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
496 int result;
497
498 if (spriv->type != HX) {
499 usb_clear_halt(serial->dev, port->write_urb->pipe);
500 usb_clear_halt(serial->dev, port->read_urb->pipe);
501 } else {
502
503 pl2303_vendor_write(8, 0, serial);
504 pl2303_vendor_write(9, 0, serial);
505 }
506
507
508 if (tty)
509 pl2303_set_termios(tty, port, NULL);
510
511 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
512 if (result) {
513 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
514 " error %d\n", __func__, result);
515 return result;
516 }
517
518 result = usb_serial_generic_open(tty, port);
519 if (result) {
520 usb_kill_urb(port->interrupt_in_urb);
521 return result;
522 }
523
524 port->port.drain_delay = 256;
525 return 0;
526}
527
528static int pl2303_tiocmset(struct tty_struct *tty,
529 unsigned int set, unsigned int clear)
530{
531 struct usb_serial_port *port = tty->driver_data;
532 struct pl2303_private *priv = usb_get_serial_port_data(port);
533 unsigned long flags;
534 u8 control;
535 int ret;
536
537 spin_lock_irqsave(&priv->lock, flags);
538 if (set & TIOCM_RTS)
539 priv->line_control |= CONTROL_RTS;
540 if (set & TIOCM_DTR)
541 priv->line_control |= CONTROL_DTR;
542 if (clear & TIOCM_RTS)
543 priv->line_control &= ~CONTROL_RTS;
544 if (clear & TIOCM_DTR)
545 priv->line_control &= ~CONTROL_DTR;
546 control = priv->line_control;
547 spin_unlock_irqrestore(&priv->lock, flags);
548
549 ret = pl2303_set_control_lines(port, control);
550 if (ret)
551 return usb_translate_errors(ret);
552
553 return 0;
554}
555
556static int pl2303_tiocmget(struct tty_struct *tty)
557{
558 struct usb_serial_port *port = tty->driver_data;
559 struct pl2303_private *priv = usb_get_serial_port_data(port);
560 unsigned long flags;
561 unsigned int mcr;
562 unsigned int status;
563 unsigned int result;
564
565 spin_lock_irqsave(&priv->lock, flags);
566 mcr = priv->line_control;
567 status = priv->line_status;
568 spin_unlock_irqrestore(&priv->lock, flags);
569
570 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
571 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
572 | ((status & UART_CTS) ? TIOCM_CTS : 0)
573 | ((status & UART_DSR) ? TIOCM_DSR : 0)
574 | ((status & UART_RING) ? TIOCM_RI : 0)
575 | ((status & UART_DCD) ? TIOCM_CD : 0);
576
577 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
578
579 return result;
580}
581
582static int pl2303_carrier_raised(struct usb_serial_port *port)
583{
584 struct pl2303_private *priv = usb_get_serial_port_data(port);
585 if (priv->line_status & UART_DCD)
586 return 1;
587 return 0;
588}
589
590static int pl2303_tiocmiwait(struct tty_struct *tty, unsigned long arg)
591{
592 struct usb_serial_port *port = tty->driver_data;
593 struct pl2303_private *priv = usb_get_serial_port_data(port);
594 unsigned long flags;
595 unsigned int prevstatus;
596 unsigned int status;
597 unsigned int changed;
598
599 spin_lock_irqsave(&priv->lock, flags);
600 prevstatus = priv->line_status;
601 spin_unlock_irqrestore(&priv->lock, flags);
602
603 while (1) {
604 interruptible_sleep_on(&port->port.delta_msr_wait);
605
606 if (signal_pending(current))
607 return -ERESTARTSYS;
608
609 if (port->serial->disconnected)
610 return -EIO;
611
612 spin_lock_irqsave(&priv->lock, flags);
613 status = priv->line_status;
614 spin_unlock_irqrestore(&priv->lock, flags);
615
616 changed = prevstatus ^ status;
617
618 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
619 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
620 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
621 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
622 return 0;
623 }
624 prevstatus = status;
625 }
626
627 return 0;
628}
629
630static int pl2303_ioctl(struct tty_struct *tty,
631 unsigned int cmd, unsigned long arg)
632{
633 struct serial_struct ser;
634 struct usb_serial_port *port = tty->driver_data;
635
636 dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
637
638 switch (cmd) {
639 case TIOCGSERIAL:
640 memset(&ser, 0, sizeof ser);
641 ser.type = PORT_16654;
642 ser.line = port->minor;
643 ser.port = port->port_number;
644 ser.baud_base = 460800;
645
646 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
647 return -EFAULT;
648
649 return 0;
650 default:
651 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
652 break;
653 }
654 return -ENOIOCTLCMD;
655}
656
657static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
658{
659 struct usb_serial_port *port = tty->driver_data;
660 struct usb_serial *serial = port->serial;
661 u16 state;
662 int result;
663
664 if (break_state == 0)
665 state = BREAK_OFF;
666 else
667 state = BREAK_ON;
668 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
669 state == BREAK_OFF ? "off" : "on");
670
671 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
672 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
673 0, NULL, 0, 100);
674 if (result)
675 dev_err(&port->dev, "error sending break = %d\n", result);
676}
677
678static void pl2303_update_line_status(struct usb_serial_port *port,
679 unsigned char *data,
680 unsigned int actual_length)
681{
682
683 struct pl2303_private *priv = usb_get_serial_port_data(port);
684 struct tty_struct *tty;
685 unsigned long flags;
686 u8 status_idx = UART_STATE;
687 u8 length = UART_STATE + 1;
688 u8 prev_line_status;
689 u16 idv, idp;
690
691 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
692 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
693
694
695 if (idv == SIEMENS_VENDOR_ID) {
696 if (idp == SIEMENS_PRODUCT_ID_X65 ||
697 idp == SIEMENS_PRODUCT_ID_SX1 ||
698 idp == SIEMENS_PRODUCT_ID_X75) {
699
700 length = 1;
701 status_idx = 0;
702 }
703 }
704
705 if (actual_length < length)
706 return;
707
708
709 spin_lock_irqsave(&priv->lock, flags);
710 prev_line_status = priv->line_status;
711 priv->line_status = data[status_idx];
712 spin_unlock_irqrestore(&priv->lock, flags);
713 if (priv->line_status & UART_BREAK_ERROR)
714 usb_serial_handle_break(port);
715 wake_up_interruptible(&port->port.delta_msr_wait);
716
717 tty = tty_port_tty_get(&port->port);
718 if (!tty)
719 return;
720 if ((priv->line_status ^ prev_line_status) & UART_DCD)
721 usb_serial_handle_dcd_change(port, tty,
722 priv->line_status & UART_DCD);
723 tty_kref_put(tty);
724}
725
726static void pl2303_read_int_callback(struct urb *urb)
727{
728 struct usb_serial_port *port = urb->context;
729 unsigned char *data = urb->transfer_buffer;
730 unsigned int actual_length = urb->actual_length;
731 int status = urb->status;
732 int retval;
733
734 switch (status) {
735 case 0:
736
737 break;
738 case -ECONNRESET:
739 case -ENOENT:
740 case -ESHUTDOWN:
741
742 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
743 __func__, status);
744 return;
745 default:
746 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
747 __func__, status);
748 goto exit;
749 }
750
751 usb_serial_debug_data(&port->dev, __func__,
752 urb->actual_length, urb->transfer_buffer);
753
754 pl2303_update_line_status(port, data, actual_length);
755
756exit:
757 retval = usb_submit_urb(urb, GFP_ATOMIC);
758 if (retval)
759 dev_err(&port->dev,
760 "%s - usb_submit_urb failed with result %d\n",
761 __func__, retval);
762}
763
764static void pl2303_process_read_urb(struct urb *urb)
765{
766 struct usb_serial_port *port = urb->context;
767 struct pl2303_private *priv = usb_get_serial_port_data(port);
768 unsigned char *data = urb->transfer_buffer;
769 char tty_flag = TTY_NORMAL;
770 unsigned long flags;
771 u8 line_status;
772 int i;
773
774
775 spin_lock_irqsave(&priv->lock, flags);
776 line_status = priv->line_status;
777 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
778 spin_unlock_irqrestore(&priv->lock, flags);
779 wake_up_interruptible(&port->port.delta_msr_wait);
780
781 if (!urb->actual_length)
782 return;
783
784
785
786 if (line_status & UART_BREAK_ERROR)
787 tty_flag = TTY_BREAK;
788 else if (line_status & UART_PARITY_ERROR)
789 tty_flag = TTY_PARITY;
790 else if (line_status & UART_FRAME_ERROR)
791 tty_flag = TTY_FRAME;
792 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
793
794
795 if (line_status & UART_OVERRUN_ERROR)
796 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
797
798 if (port->port.console && port->sysrq) {
799 for (i = 0; i < urb->actual_length; ++i)
800 if (!usb_serial_handle_sysrq_char(port, data[i]))
801 tty_insert_flip_char(&port->port, data[i],
802 tty_flag);
803 } else {
804 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
805 urb->actual_length);
806 }
807
808 tty_flip_buffer_push(&port->port);
809}
810
811
812static struct usb_serial_driver pl2303_device = {
813 .driver = {
814 .owner = THIS_MODULE,
815 .name = "pl2303",
816 },
817 .id_table = id_table,
818 .num_ports = 1,
819 .bulk_in_size = 256,
820 .bulk_out_size = 256,
821 .open = pl2303_open,
822 .close = pl2303_close,
823 .dtr_rts = pl2303_dtr_rts,
824 .carrier_raised = pl2303_carrier_raised,
825 .ioctl = pl2303_ioctl,
826 .break_ctl = pl2303_break_ctl,
827 .set_termios = pl2303_set_termios,
828 .tiocmget = pl2303_tiocmget,
829 .tiocmset = pl2303_tiocmset,
830 .tiocmiwait = pl2303_tiocmiwait,
831 .process_read_urb = pl2303_process_read_urb,
832 .read_int_callback = pl2303_read_int_callback,
833 .attach = pl2303_startup,
834 .release = pl2303_release,
835 .port_probe = pl2303_port_probe,
836 .port_remove = pl2303_port_remove,
837};
838
839static struct usb_serial_driver * const serial_drivers[] = {
840 &pl2303_device, NULL
841};
842
843module_usb_serial_driver(serial_drivers, id_table);
844
845MODULE_DESCRIPTION(DRIVER_DESC);
846MODULE_LICENSE("GPL");
847
