]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/usb/serial/pl2303.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/async_tx
[mirror_ubuntu-zesty-kernel.git] / drivers / usb / serial / pl2303.c
1 /*
2 * Prolific PL2303 USB to serial adaptor driver
3 *
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
6 *
7 * Original driver for 2.2.x by anonymous
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
12 *
13 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 *
16 */
17
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/tty.h>
23 #include <linux/tty_driver.h>
24 #include <linux/tty_flip.h>
25 #include <linux/serial.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/spinlock.h>
29 #include <linux/uaccess.h>
30 #include <linux/usb.h>
31 #include <linux/usb/serial.h>
32 #include "pl2303.h"
33
34 /*
35 * Version Information
36 */
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
38
39 static int debug;
40
41 #define PL2303_CLOSING_WAIT (30*HZ)
42
43 #define PL2303_BUF_SIZE 1024
44 #define PL2303_TMP_BUF_SIZE 1024
45
46 struct pl2303_buf {
47 unsigned int buf_size;
48 char *buf_buf;
49 char *buf_get;
50 char *buf_put;
51 };
52
53 static const 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) }, /* Benq/Siemens 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 { } /* Terminating entry */
101 };
102
103 MODULE_DEVICE_TABLE(usb, id_table);
104
105 static 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
150 enum pl2303_type {
151 type_0, /* don't know the difference between type 0 and */
152 type_1, /* type 1, until someone from prolific tells us... */
153 HX, /* HX version of the pl2303 chip */
154 };
155
156 struct 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 * pl2303_buf_alloc
168 *
169 * Allocate a circular buffer and all associated memory.
170 */
171 static 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 * pl2303_buf_free
196 *
197 * Free the buffer and all associated memory.
198 */
199 static 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 * pl2303_buf_clear
209 *
210 * Clear out all data in the circular buffer.
211 */
212 static void pl2303_buf_clear(struct pl2303_buf *pb)
213 {
214 if (pb != NULL)
215 pb->buf_get = pb->buf_put;
216 /* equivalent to a get of all data available */
217 }
218
219 /*
220 * pl2303_buf_data_avail
221 *
222 * Return the number of bytes of data available in the circular
223 * buffer.
224 */
225 static 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 * pl2303_buf_space_avail
235 *
236 * Return the number of bytes of space available in the circular
237 * buffer.
238 */
239 static 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 * pl2303_buf_put
249 *
250 * Copy data data from a user buffer and put it into the circular buffer.
251 * Restrict to the amount of space available.
252 *
253 * Return the number of bytes copied.
254 */
255 static 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 /* count == len */
280 pb->buf_put = pb->buf_buf;
281 }
282
283 return count;
284 }
285
286 /*
287 * pl2303_buf_get
288 *
289 * Get data from the circular buffer and copy to the given buffer.
290 * Restrict to the amount of data available.
291 *
292 * Return the number of bytes copied.
293 */
294 static 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 /* count == len */
319 pb->buf_get = pb->buf_buf;
320 }
321
322 return count;
323 }
324
325 static 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
336 static 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
347 static 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
401 cleanup:
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
412 static 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
423 static 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 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 /* TODO: reschedule pl2303_send */
460 }
461
462 usb_serial_port_softint(port);
463 }
464
465 static 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
485 static 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
502 static 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
519 static 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 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
531 4800, 7200, 9600, 14400, 19200, 28800, 38400,
532 57600, 115200, 230400, 460800, 614400,
533 921600, 1228800, 2457600, 3000000, 6000000 };
534 int baud_floor, baud_ceil;
535 int k;
536
537 dbg("%s - port %d", __func__, port->number);
538
539 /* The PL2303 is reported to lose bytes if you change
540 serial settings even to the same values as before. Thus
541 we actually need to filter in this specific case */
542
543 if (!tty_termios_hw_change(tty->termios, old_termios))
544 return;
545
546 cflag = tty->termios->c_cflag;
547
548 buf = kzalloc(7, GFP_KERNEL);
549 if (!buf) {
550 dev_err(&port->dev, "%s - out of memory.\n", __func__);
551 /* Report back no change occurred */
552 *tty->termios = *old_termios;
553 return;
554 }
555
556 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
557 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
558 0, 0, buf, 7, 100);
559 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
560 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
561
562 if (cflag & CSIZE) {
563 switch (cflag & CSIZE) {
564 case CS5:
565 buf[6] = 5;
566 break;
567 case CS6:
568 buf[6] = 6;
569 break;
570 case CS7:
571 buf[6] = 7;
572 break;
573 default:
574 case CS8:
575 buf[6] = 8;
576 break;
577 }
578 dbg("%s - data bits = %d", __func__, buf[6]);
579 }
580
581 /* For reference buf[0]:buf[3] baud rate value */
582 /* NOTE: Only the values defined in baud_sup are supported !
583 * => if unsupported values are set, the PL2303 seems to use
584 * 9600 baud (at least my PL2303X always does)
585 */
586 baud = tty_get_baud_rate(tty);
587 dbg("%s - baud requested = %d", __func__, baud);
588 if (baud) {
589 /* Set baudrate to nearest supported value */
590 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
591 if (baud_sup[k] / baud) {
592 baud_ceil = baud_sup[k];
593 if (k==0) {
594 baud = baud_ceil;
595 } else {
596 baud_floor = baud_sup[k-1];
597 if ((baud_ceil % baud)
598 > (baud % baud_floor))
599 baud = baud_floor;
600 else
601 baud = baud_ceil;
602 }
603 break;
604 }
605 }
606 if (baud > 1228800) {
607 /* type_0, type_1 only support up to 1228800 baud */
608 if (priv->type != HX)
609 baud = 1228800;
610 else if (baud > 6000000)
611 baud = 6000000;
612 }
613 dbg("%s - baud set = %d", __func__, baud);
614 buf[0] = baud & 0xff;
615 buf[1] = (baud >> 8) & 0xff;
616 buf[2] = (baud >> 16) & 0xff;
617 buf[3] = (baud >> 24) & 0xff;
618 }
619
620 /* For reference buf[4]=0 is 1 stop bits */
621 /* For reference buf[4]=1 is 1.5 stop bits */
622 /* For reference buf[4]=2 is 2 stop bits */
623 if (cflag & CSTOPB) {
624 /* NOTE: Comply with "real" UARTs / RS232:
625 * use 1.5 instead of 2 stop bits with 5 data bits
626 */
627 if ((cflag & CSIZE) == CS5) {
628 buf[4] = 1;
629 dbg("%s - stop bits = 1.5", __func__);
630 } else {
631 buf[4] = 2;
632 dbg("%s - stop bits = 2", __func__);
633 }
634 } else {
635 buf[4] = 0;
636 dbg("%s - stop bits = 1", __func__);
637 }
638
639 if (cflag & PARENB) {
640 /* For reference buf[5]=0 is none parity */
641 /* For reference buf[5]=1 is odd parity */
642 /* For reference buf[5]=2 is even parity */
643 /* For reference buf[5]=3 is mark parity */
644 /* For reference buf[5]=4 is space parity */
645 if (cflag & PARODD) {
646 if (cflag & CMSPAR) {
647 buf[5] = 3;
648 dbg("%s - parity = mark", __func__);
649 } else {
650 buf[5] = 1;
651 dbg("%s - parity = odd", __func__);
652 }
653 } else {
654 if (cflag & CMSPAR) {
655 buf[5] = 4;
656 dbg("%s - parity = space", __func__);
657 } else {
658 buf[5] = 2;
659 dbg("%s - parity = even", __func__);
660 }
661 }
662 } else {
663 buf[5] = 0;
664 dbg("%s - parity = none", __func__);
665 }
666
667 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
668 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
669 0, 0, buf, 7, 100);
670 dbg("0x21:0x20:0:0 %d", i);
671
672 /* change control lines if we are switching to or from B0 */
673 spin_lock_irqsave(&priv->lock, flags);
674 control = priv->line_control;
675 if ((cflag & CBAUD) == B0)
676 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
677 else
678 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
679 if (control != priv->line_control) {
680 control = priv->line_control;
681 spin_unlock_irqrestore(&priv->lock, flags);
682 set_control_lines(serial->dev, control);
683 } else {
684 spin_unlock_irqrestore(&priv->lock, flags);
685 }
686
687 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
688
689 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
690 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
691 0, 0, buf, 7, 100);
692 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
693 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
694
695 if (cflag & CRTSCTS) {
696 if (priv->type == HX)
697 pl2303_vendor_write(0x0, 0x61, serial);
698 else
699 pl2303_vendor_write(0x0, 0x41, serial);
700 } else {
701 pl2303_vendor_write(0x0, 0x0, serial);
702 }
703
704 /* Save resulting baud rate */
705 if (baud)
706 tty_encode_baud_rate(tty, baud, baud);
707
708 kfree(buf);
709 }
710
711 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
712 {
713 struct pl2303_private *priv = usb_get_serial_port_data(port);
714 unsigned long flags;
715 u8 control;
716
717 spin_lock_irqsave(&priv->lock, flags);
718 /* Change DTR and RTS */
719 if (on)
720 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
721 else
722 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
723 control = priv->line_control;
724 spin_unlock_irqrestore(&priv->lock, flags);
725 set_control_lines(port->serial->dev, control);
726 }
727
728 static void pl2303_close(struct usb_serial_port *port)
729 {
730 struct pl2303_private *priv = usb_get_serial_port_data(port);
731 unsigned long flags;
732
733 dbg("%s - port %d", __func__, port->number);
734
735 spin_lock_irqsave(&priv->lock, flags);
736 /* clear out any remaining data in the buffer */
737 pl2303_buf_clear(priv->buf);
738 spin_unlock_irqrestore(&priv->lock, flags);
739
740 /* shutdown our urbs */
741 dbg("%s - shutting down urbs", __func__);
742 usb_kill_urb(port->write_urb);
743 usb_kill_urb(port->read_urb);
744 usb_kill_urb(port->interrupt_in_urb);
745
746 }
747
748 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
749 {
750 struct ktermios tmp_termios;
751 struct usb_serial *serial = port->serial;
752 struct pl2303_private *priv = usb_get_serial_port_data(port);
753 int result;
754
755 dbg("%s - port %d", __func__, port->number);
756
757 if (priv->type != HX) {
758 usb_clear_halt(serial->dev, port->write_urb->pipe);
759 usb_clear_halt(serial->dev, port->read_urb->pipe);
760 } else {
761 /* reset upstream data pipes */
762 pl2303_vendor_write(8, 0, serial);
763 pl2303_vendor_write(9, 0, serial);
764 }
765
766 /* Setup termios */
767 if (tty)
768 pl2303_set_termios(tty, port, &tmp_termios);
769
770 dbg("%s - submitting read urb", __func__);
771 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
772 if (result) {
773 dev_err(&port->dev, "%s - failed submitting read urb,"
774 " error %d\n", __func__, result);
775 pl2303_close(port);
776 return -EPROTO;
777 }
778
779 dbg("%s - submitting interrupt urb", __func__);
780 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
781 if (result) {
782 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
783 " error %d\n", __func__, result);
784 pl2303_close(port);
785 return -EPROTO;
786 }
787 port->port.drain_delay = 256;
788 return 0;
789 }
790
791 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
792 unsigned int set, unsigned int clear)
793 {
794 struct usb_serial_port *port = tty->driver_data;
795 struct pl2303_private *priv = usb_get_serial_port_data(port);
796 unsigned long flags;
797 u8 control;
798
799 if (!usb_get_intfdata(port->serial->interface))
800 return -ENODEV;
801
802 spin_lock_irqsave(&priv->lock, flags);
803 if (set & TIOCM_RTS)
804 priv->line_control |= CONTROL_RTS;
805 if (set & TIOCM_DTR)
806 priv->line_control |= CONTROL_DTR;
807 if (clear & TIOCM_RTS)
808 priv->line_control &= ~CONTROL_RTS;
809 if (clear & TIOCM_DTR)
810 priv->line_control &= ~CONTROL_DTR;
811 control = priv->line_control;
812 spin_unlock_irqrestore(&priv->lock, flags);
813
814 return set_control_lines(port->serial->dev, control);
815 }
816
817 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
818 {
819 struct usb_serial_port *port = tty->driver_data;
820 struct pl2303_private *priv = usb_get_serial_port_data(port);
821 unsigned long flags;
822 unsigned int mcr;
823 unsigned int status;
824 unsigned int result;
825
826 dbg("%s (%d)", __func__, port->number);
827
828 if (!usb_get_intfdata(port->serial->interface))
829 return -ENODEV;
830
831 spin_lock_irqsave(&priv->lock, flags);
832 mcr = priv->line_control;
833 status = priv->line_status;
834 spin_unlock_irqrestore(&priv->lock, flags);
835
836 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
837 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
838 | ((status & UART_CTS) ? TIOCM_CTS : 0)
839 | ((status & UART_DSR) ? TIOCM_DSR : 0)
840 | ((status & UART_RING) ? TIOCM_RI : 0)
841 | ((status & UART_DCD) ? TIOCM_CD : 0);
842
843 dbg("%s - result = %x", __func__, result);
844
845 return result;
846 }
847
848 static int pl2303_carrier_raised(struct usb_serial_port *port)
849 {
850 struct pl2303_private *priv = usb_get_serial_port_data(port);
851 if (priv->line_status & UART_DCD)
852 return 1;
853 return 0;
854 }
855
856 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
857 {
858 struct pl2303_private *priv = usb_get_serial_port_data(port);
859 unsigned long flags;
860 unsigned int prevstatus;
861 unsigned int status;
862 unsigned int changed;
863
864 spin_lock_irqsave(&priv->lock, flags);
865 prevstatus = priv->line_status;
866 spin_unlock_irqrestore(&priv->lock, flags);
867
868 while (1) {
869 interruptible_sleep_on(&priv->delta_msr_wait);
870 /* see if a signal did it */
871 if (signal_pending(current))
872 return -ERESTARTSYS;
873
874 spin_lock_irqsave(&priv->lock, flags);
875 status = priv->line_status;
876 spin_unlock_irqrestore(&priv->lock, flags);
877
878 changed = prevstatus ^ status;
879
880 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
881 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
882 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
883 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
884 return 0;
885 }
886 prevstatus = status;
887 }
888 /* NOTREACHED */
889 return 0;
890 }
891
892 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
893 unsigned int cmd, unsigned long arg)
894 {
895 struct serial_struct ser;
896 struct usb_serial_port *port = tty->driver_data;
897 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
898
899 switch (cmd) {
900 case TIOCGSERIAL:
901 memset(&ser, 0, sizeof ser);
902 ser.type = PORT_16654;
903 ser.line = port->serial->minor;
904 ser.port = port->number;
905 ser.baud_base = 460800;
906
907 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
908 return -EFAULT;
909
910 return 0;
911
912 case TIOCMIWAIT:
913 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
914 return wait_modem_info(port, arg);
915 default:
916 dbg("%s not supported = 0x%04x", __func__, cmd);
917 break;
918 }
919 return -ENOIOCTLCMD;
920 }
921
922 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
923 {
924 struct usb_serial_port *port = tty->driver_data;
925 struct usb_serial *serial = port->serial;
926 u16 state;
927 int result;
928
929 dbg("%s - port %d", __func__, port->number);
930
931 if (break_state == 0)
932 state = BREAK_OFF;
933 else
934 state = BREAK_ON;
935 dbg("%s - turning break %s", __func__,
936 state == BREAK_OFF ? "off" : "on");
937
938 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
939 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
940 0, NULL, 0, 100);
941 if (result)
942 dbg("%s - error sending break = %d", __func__, result);
943 }
944
945 static void pl2303_release(struct usb_serial *serial)
946 {
947 int i;
948 struct pl2303_private *priv;
949
950 dbg("%s", __func__);
951
952 for (i = 0; i < serial->num_ports; ++i) {
953 priv = usb_get_serial_port_data(serial->port[i]);
954 if (priv) {
955 pl2303_buf_free(priv->buf);
956 kfree(priv);
957 }
958 }
959 }
960
961 static void pl2303_update_line_status(struct usb_serial_port *port,
962 unsigned char *data,
963 unsigned int actual_length)
964 {
965
966 struct pl2303_private *priv = usb_get_serial_port_data(port);
967 unsigned long flags;
968 u8 status_idx = UART_STATE;
969 u8 length = UART_STATE + 1;
970 u16 idv, idp;
971
972 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
973 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
974
975
976 if (idv == SIEMENS_VENDOR_ID) {
977 if (idp == SIEMENS_PRODUCT_ID_X65 ||
978 idp == SIEMENS_PRODUCT_ID_SX1 ||
979 idp == SIEMENS_PRODUCT_ID_X75) {
980
981 length = 1;
982 status_idx = 0;
983 }
984 }
985
986 if (actual_length < length)
987 return;
988
989 /* Save off the uart status for others to look at */
990 spin_lock_irqsave(&priv->lock, flags);
991 priv->line_status = data[status_idx];
992 spin_unlock_irqrestore(&priv->lock, flags);
993 if (priv->line_status & UART_BREAK_ERROR)
994 usb_serial_handle_break(port);
995 wake_up_interruptible(&priv->delta_msr_wait);
996 }
997
998 static void pl2303_read_int_callback(struct urb *urb)
999 {
1000 struct usb_serial_port *port = urb->context;
1001 unsigned char *data = urb->transfer_buffer;
1002 unsigned int actual_length = urb->actual_length;
1003 int status = urb->status;
1004 int retval;
1005
1006 dbg("%s (%d)", __func__, port->number);
1007
1008 switch (status) {
1009 case 0:
1010 /* success */
1011 break;
1012 case -ECONNRESET:
1013 case -ENOENT:
1014 case -ESHUTDOWN:
1015 /* this urb is terminated, clean up */
1016 dbg("%s - urb shutting down with status: %d", __func__,
1017 status);
1018 return;
1019 default:
1020 dbg("%s - nonzero urb status received: %d", __func__,
1021 status);
1022 goto exit;
1023 }
1024
1025 usb_serial_debug_data(debug, &port->dev, __func__,
1026 urb->actual_length, urb->transfer_buffer);
1027
1028 pl2303_update_line_status(port, data, actual_length);
1029
1030 exit:
1031 retval = usb_submit_urb(urb, GFP_ATOMIC);
1032 if (retval)
1033 dev_err(&urb->dev->dev,
1034 "%s - usb_submit_urb failed with result %d\n",
1035 __func__, retval);
1036 }
1037
1038 static void pl2303_push_data(struct tty_struct *tty,
1039 struct usb_serial_port *port, struct urb *urb,
1040 u8 line_status)
1041 {
1042 unsigned char *data = urb->transfer_buffer;
1043 /* get tty_flag from status */
1044 char tty_flag = TTY_NORMAL;
1045 /* break takes precedence over parity, */
1046 /* which takes precedence over framing errors */
1047 if (line_status & UART_BREAK_ERROR)
1048 tty_flag = TTY_BREAK;
1049 else if (line_status & UART_PARITY_ERROR)
1050 tty_flag = TTY_PARITY;
1051 else if (line_status & UART_FRAME_ERROR)
1052 tty_flag = TTY_FRAME;
1053 dbg("%s - tty_flag = %d", __func__, tty_flag);
1054
1055 /* overrun is special, not associated with a char */
1056 if (line_status & UART_OVERRUN_ERROR)
1057 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1058
1059 if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq))
1060 tty_insert_flip_string(tty, data, urb->actual_length);
1061 else {
1062 int i;
1063 for (i = 0; i < urb->actual_length; ++i)
1064 if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
1065 tty_insert_flip_char(tty, data[i], tty_flag);
1066 }
1067 tty_flip_buffer_push(tty);
1068 }
1069
1070 static void pl2303_read_bulk_callback(struct urb *urb)
1071 {
1072 struct usb_serial_port *port = urb->context;
1073 struct pl2303_private *priv = usb_get_serial_port_data(port);
1074 struct tty_struct *tty;
1075 unsigned long flags;
1076 int result;
1077 int status = urb->status;
1078 u8 line_status;
1079
1080 dbg("%s - port %d", __func__, port->number);
1081
1082 if (status) {
1083 dbg("%s - urb status = %d", __func__, status);
1084 if (status == -EPROTO) {
1085 /* PL2303 mysteriously fails with -EPROTO reschedule
1086 * the read */
1087 dbg("%s - caught -EPROTO, resubmitting the urb",
1088 __func__);
1089 result = usb_submit_urb(urb, GFP_ATOMIC);
1090 if (result)
1091 dev_err(&urb->dev->dev, "%s - failed"
1092 " resubmitting read urb, error %d\n",
1093 __func__, result);
1094 return;
1095 }
1096 dbg("%s - unable to handle the error, exiting.", __func__);
1097 return;
1098 }
1099
1100 usb_serial_debug_data(debug, &port->dev, __func__,
1101 urb->actual_length, urb->transfer_buffer);
1102
1103 spin_lock_irqsave(&priv->lock, flags);
1104 line_status = priv->line_status;
1105 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1106 spin_unlock_irqrestore(&priv->lock, flags);
1107 wake_up_interruptible(&priv->delta_msr_wait);
1108
1109 tty = tty_port_tty_get(&port->port);
1110 if (tty && urb->actual_length) {
1111 pl2303_push_data(tty, port, urb, line_status);
1112 }
1113 tty_kref_put(tty);
1114 /* Schedule the next read _if_ we are still open */
1115 result = usb_submit_urb(urb, GFP_ATOMIC);
1116 if (result && result != -EPERM)
1117 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1118 " read urb, error %d\n", __func__, result);
1119 }
1120
1121 static void pl2303_write_bulk_callback(struct urb *urb)
1122 {
1123 struct usb_serial_port *port = urb->context;
1124 struct pl2303_private *priv = usb_get_serial_port_data(port);
1125 int result;
1126 int status = urb->status;
1127
1128 dbg("%s - port %d", __func__, port->number);
1129
1130 switch (status) {
1131 case 0:
1132 /* success */
1133 break;
1134 case -ECONNRESET:
1135 case -ENOENT:
1136 case -ESHUTDOWN:
1137 /* this urb is terminated, clean up */
1138 dbg("%s - urb shutting down with status: %d", __func__,
1139 status);
1140 priv->write_urb_in_use = 0;
1141 return;
1142 default:
1143 /* error in the urb, so we have to resubmit it */
1144 dbg("%s - Overflow in write", __func__);
1145 dbg("%s - nonzero write bulk status received: %d", __func__,
1146 status);
1147 port->write_urb->transfer_buffer_length = 1;
1148 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1149 if (result)
1150 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1151 " urb, error %d\n", __func__, result);
1152 else
1153 return;
1154 }
1155
1156 priv->write_urb_in_use = 0;
1157
1158 /* send any buffered data */
1159 pl2303_send(port);
1160 }
1161
1162 /* All of the device info needed for the PL2303 SIO serial converter */
1163 static struct usb_serial_driver pl2303_device = {
1164 .driver = {
1165 .owner = THIS_MODULE,
1166 .name = "pl2303",
1167 },
1168 .id_table = id_table,
1169 .usb_driver = &pl2303_driver,
1170 .num_ports = 1,
1171 .open = pl2303_open,
1172 .close = pl2303_close,
1173 .dtr_rts = pl2303_dtr_rts,
1174 .carrier_raised = pl2303_carrier_raised,
1175 .write = pl2303_write,
1176 .ioctl = pl2303_ioctl,
1177 .break_ctl = pl2303_break_ctl,
1178 .set_termios = pl2303_set_termios,
1179 .tiocmget = pl2303_tiocmget,
1180 .tiocmset = pl2303_tiocmset,
1181 .read_bulk_callback = pl2303_read_bulk_callback,
1182 .read_int_callback = pl2303_read_int_callback,
1183 .write_bulk_callback = pl2303_write_bulk_callback,
1184 .write_room = pl2303_write_room,
1185 .chars_in_buffer = pl2303_chars_in_buffer,
1186 .attach = pl2303_startup,
1187 .release = pl2303_release,
1188 };
1189
1190 static int __init pl2303_init(void)
1191 {
1192 int retval;
1193
1194 retval = usb_serial_register(&pl2303_device);
1195 if (retval)
1196 goto failed_usb_serial_register;
1197 retval = usb_register(&pl2303_driver);
1198 if (retval)
1199 goto failed_usb_register;
1200 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1201 return 0;
1202 failed_usb_register:
1203 usb_serial_deregister(&pl2303_device);
1204 failed_usb_serial_register:
1205 return retval;
1206 }
1207
1208 static void __exit pl2303_exit(void)
1209 {
1210 usb_deregister(&pl2303_driver);
1211 usb_serial_deregister(&pl2303_device);
1212 }
1213
1214 module_init(pl2303_init);
1215 module_exit(pl2303_exit);
1216
1217 MODULE_DESCRIPTION(DRIVER_DESC);
1218 MODULE_LICENSE("GPL");
1219
1220 module_param(debug, bool, S_IRUGO | S_IWUSR);
1221 MODULE_PARM_DESC(debug, "Debug enabled or not");
1222
ubuntu-zesty-kernel mirror