projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[ARM] Kirkwood: merge net2big_v2 and net5big_v2 board setups
[deliverable/linux.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 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
101 { } /* Terminating entry */
102 };
103
104 MODULE_DEVICE_TABLE(usb, id_table);
105
106 static struct usb_driver pl2303_driver = {
107 .name = "pl2303",
108 .probe = usb_serial_probe,
109 .disconnect = usb_serial_disconnect,
110 .id_table = id_table,
111 .suspend = usb_serial_suspend,
112 .resume = usb_serial_resume,
113 .no_dynamic_id = 1,
114 .supports_autosuspend = 1,
115 };
116
117 #define SET_LINE_REQUEST_TYPE 0x21
118 #define SET_LINE_REQUEST 0x20
119
120 #define SET_CONTROL_REQUEST_TYPE 0x21
121 #define SET_CONTROL_REQUEST 0x22
122 #define CONTROL_DTR 0x01
123 #define CONTROL_RTS 0x02
124
125 #define BREAK_REQUEST_TYPE 0x21
126 #define BREAK_REQUEST 0x23
127 #define BREAK_ON 0xffff
128 #define BREAK_OFF 0x0000
129
130 #define GET_LINE_REQUEST_TYPE 0xa1
131 #define GET_LINE_REQUEST 0x21
132
133 #define VENDOR_WRITE_REQUEST_TYPE 0x40
134 #define VENDOR_WRITE_REQUEST 0x01
135
136 #define VENDOR_READ_REQUEST_TYPE 0xc0
137 #define VENDOR_READ_REQUEST 0x01
138
139 #define UART_STATE 0x08
140 #define UART_STATE_TRANSIENT_MASK 0x74
141 #define UART_DCD 0x01
142 #define UART_DSR 0x02
143 #define UART_BREAK_ERROR 0x04
144 #define UART_RING 0x08
145 #define UART_FRAME_ERROR 0x10
146 #define UART_PARITY_ERROR 0x20
147 #define UART_OVERRUN_ERROR 0x40
148 #define UART_CTS 0x80
149
150
151 enum pl2303_type {
152 type_0, /* don't know the difference between type 0 and */
153 type_1, /* type 1, until someone from prolific tells us... */
154 HX, /* HX version of the pl2303 chip */
155 };
156
157 struct pl2303_private {
158 spinlock_t lock;
159 struct pl2303_buf *buf;
160 int write_urb_in_use;
161 wait_queue_head_t delta_msr_wait;
162 u8 line_control;
163 u8 line_status;
164 enum pl2303_type type;
165 };
166
167 /*
168 * pl2303_buf_alloc
169 *
170 * Allocate a circular buffer and all associated memory.
171 */
172 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
173 {
174 struct pl2303_buf *pb;
175
176 if (size == 0)
177 return NULL;
178
179 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
180 if (pb == NULL)
181 return NULL;
182
183 pb->buf_buf = kmalloc(size, GFP_KERNEL);
184 if (pb->buf_buf == NULL) {
185 kfree(pb);
186 return NULL;
187 }
188
189 pb->buf_size = size;
190 pb->buf_get = pb->buf_put = pb->buf_buf;
191
192 return pb;
193 }
194
195 /*
196 * pl2303_buf_free
197 *
198 * Free the buffer and all associated memory.
199 */
200 static void pl2303_buf_free(struct pl2303_buf *pb)
201 {
202 if (pb) {
203 kfree(pb->buf_buf);
204 kfree(pb);
205 }
206 }
207
208 /*
209 * pl2303_buf_clear
210 *
211 * Clear out all data in the circular buffer.
212 */
213 static void pl2303_buf_clear(struct pl2303_buf *pb)
214 {
215 if (pb != NULL)
216 pb->buf_get = pb->buf_put;
217 /* equivalent to a get of all data available */
218 }
219
220 /*
221 * pl2303_buf_data_avail
222 *
223 * Return the number of bytes of data available in the circular
224 * buffer.
225 */
226 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
227 {
228 if (pb == NULL)
229 return 0;
230
231 return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
232 }
233
234 /*
235 * pl2303_buf_space_avail
236 *
237 * Return the number of bytes of space available in the circular
238 * buffer.
239 */
240 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
241 {
242 if (pb == NULL)
243 return 0;
244
245 return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
246 }
247
248 /*
249 * pl2303_buf_put
250 *
251 * Copy data data from a user buffer and put it into the circular buffer.
252 * Restrict to the amount of space available.
253 *
254 * Return the number of bytes copied.
255 */
256 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
257 unsigned int count)
258 {
259 unsigned int len;
260
261 if (pb == NULL)
262 return 0;
263
264 len = pl2303_buf_space_avail(pb);
265 if (count > len)
266 count = len;
267
268 if (count == 0)
269 return 0;
270
271 len = pb->buf_buf + pb->buf_size - pb->buf_put;
272 if (count > len) {
273 memcpy(pb->buf_put, buf, len);
274 memcpy(pb->buf_buf, buf+len, count - len);
275 pb->buf_put = pb->buf_buf + count - len;
276 } else {
277 memcpy(pb->buf_put, buf, count);
278 if (count < len)
279 pb->buf_put += count;
280 else /* count == len */
281 pb->buf_put = pb->buf_buf;
282 }
283
284 return count;
285 }
286
287 /*
288 * pl2303_buf_get
289 *
290 * Get data from the circular buffer and copy to the given buffer.
291 * Restrict to the amount of data available.
292 *
293 * Return the number of bytes copied.
294 */
295 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
296 unsigned int count)
297 {
298 unsigned int len;
299
300 if (pb == NULL)
301 return 0;
302
303 len = pl2303_buf_data_avail(pb);
304 if (count > len)
305 count = len;
306
307 if (count == 0)
308 return 0;
309
310 len = pb->buf_buf + pb->buf_size - pb->buf_get;
311 if (count > len) {
312 memcpy(buf, pb->buf_get, len);
313 memcpy(buf+len, pb->buf_buf, count - len);
314 pb->buf_get = pb->buf_buf + count - len;
315 } else {
316 memcpy(buf, pb->buf_get, count);
317 if (count < len)
318 pb->buf_get += count;
319 else /* count == len */
320 pb->buf_get = pb->buf_buf;
321 }
322
323 return count;
324 }
325
326 static int pl2303_vendor_read(__u16 value, __u16 index,
327 struct usb_serial *serial, unsigned char *buf)
328 {
329 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
330 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
331 value, index, buf, 1, 100);
332 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
333 VENDOR_READ_REQUEST, value, index, res, buf[0]);
334 return res;
335 }
336
337 static int pl2303_vendor_write(__u16 value, __u16 index,
338 struct usb_serial *serial)
339 {
340 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
341 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
342 value, index, NULL, 0, 100);
343 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
344 VENDOR_WRITE_REQUEST, value, index, res);
345 return res;
346 }
347
348 static int pl2303_startup(struct usb_serial *serial)
349 {
350 struct pl2303_private *priv;
351 enum pl2303_type type = type_0;
352 unsigned char *buf;
353 int i;
354
355 buf = kmalloc(10, GFP_KERNEL);
356 if (buf == NULL)
357 return -ENOMEM;
358
359 if (serial->dev->descriptor.bDeviceClass == 0x02)
360 type = type_0;
361 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
362 type = HX;
363 else if (serial->dev->descriptor.bDeviceClass == 0x00)
364 type = type_1;
365 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
366 type = type_1;
367 dbg("device type: %d", type);
368
369 for (i = 0; i < serial->num_ports; ++i) {
370 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
371 if (!priv)
372 goto cleanup;
373 spin_lock_init(&priv->lock);
374 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
375 if (priv->buf == NULL) {
376 kfree(priv);
377 goto cleanup;
378 }
379 init_waitqueue_head(&priv->delta_msr_wait);
380 priv->type = type;
381 usb_set_serial_port_data(serial->port[i], priv);
382 }
383
384 pl2303_vendor_read(0x8484, 0, serial, buf);
385 pl2303_vendor_write(0x0404, 0, serial);
386 pl2303_vendor_read(0x8484, 0, serial, buf);
387 pl2303_vendor_read(0x8383, 0, serial, buf);
388 pl2303_vendor_read(0x8484, 0, serial, buf);
389 pl2303_vendor_write(0x0404, 1, serial);
390 pl2303_vendor_read(0x8484, 0, serial, buf);
391 pl2303_vendor_read(0x8383, 0, serial, buf);
392 pl2303_vendor_write(0, 1, serial);
393 pl2303_vendor_write(1, 0, serial);
394 if (type == HX)
395 pl2303_vendor_write(2, 0x44, serial);
396 else
397 pl2303_vendor_write(2, 0x24, serial);
398
399 kfree(buf);
400 return 0;
401
402 cleanup:
403 kfree(buf);
404 for (--i; i >= 0; --i) {
405 priv = usb_get_serial_port_data(serial->port[i]);
406 pl2303_buf_free(priv->buf);
407 kfree(priv);
408 usb_set_serial_port_data(serial->port[i], NULL);
409 }
410 return -ENOMEM;
411 }
412
413 static int set_control_lines(struct usb_device *dev, u8 value)
414 {
415 int retval;
416
417 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
418 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
419 value, 0, NULL, 0, 100);
420 dbg("%s - value = %d, retval = %d", __func__, value, retval);
421 return retval;
422 }
423
424 static void pl2303_send(struct usb_serial_port *port)
425 {
426 int count, result;
427 struct pl2303_private *priv = usb_get_serial_port_data(port);
428 unsigned long flags;
429
430 dbg("%s - port %d", __func__, port->number);
431
432 spin_lock_irqsave(&priv->lock, flags);
433
434 if (priv->write_urb_in_use) {
435 spin_unlock_irqrestore(&priv->lock, flags);
436 return;
437 }
438
439 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
440 port->bulk_out_size);
441
442 if (count == 0) {
443 spin_unlock_irqrestore(&priv->lock, flags);
444 return;
445 }
446
447 priv->write_urb_in_use = 1;
448
449 spin_unlock_irqrestore(&priv->lock, flags);
450
451 usb_serial_debug_data(debug, &port->dev, __func__, count,
452 port->write_urb->transfer_buffer);
453
454 port->write_urb->transfer_buffer_length = count;
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 /* TODO: reschedule pl2303_send */
461 }
462
463 usb_serial_port_softint(port);
464 }
465
466 static 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
486 static 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
503 static 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
520 static 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 /* The PL2303 is reported to lose bytes if you change
541 serial settings even to the same values as before. Thus
542 we actually need to filter in this specific case */
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 /* Report back no change occurred */
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 /* For reference buf[0]:buf[3] baud rate value */
583 /* NOTE: Only the values defined in baud_sup are supported !
584 * => if unsupported values are set, the PL2303 seems to use
585 * 9600 baud (at least my PL2303X always does)
586 */
587 baud = tty_get_baud_rate(tty);
588 dbg("%s - baud requested = %d", __func__, baud);
589 if (baud) {
590 /* Set baudrate to nearest supported value */
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 /* type_0, type_1 only support up to 1228800 baud */
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 /* For reference buf[4]=0 is 1 stop bits */
622 /* For reference buf[4]=1 is 1.5 stop bits */
623 /* For reference buf[4]=2 is 2 stop bits */
624 if (cflag & CSTOPB) {
625 /* NOTE: Comply with "real" UARTs / RS232:
626 * use 1.5 instead of 2 stop bits with 5 data bits
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 /* For reference buf[5]=0 is none parity */
642 /* For reference buf[5]=1 is odd parity */
643 /* For reference buf[5]=2 is even parity */
644 /* For reference buf[5]=3 is mark parity */
645 /* For reference buf[5]=4 is space parity */
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 /* change control lines if we are switching to or from B0 */
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 /* Save resulting baud rate */
706 if (baud)
707 tty_encode_baud_rate(tty, baud, baud);
708
709 kfree(buf);
710 }
711
712 static 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 /* Change DTR and RTS */
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
729 static 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 /* clear out any remaining data in the buffer */
738 pl2303_buf_clear(priv->buf);
739 spin_unlock_irqrestore(&priv->lock, flags);
740
741 /* shutdown our urbs */
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
749 static 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 /* reset upstream data pipes */
763 pl2303_vendor_write(8, 0, serial);
764 pl2303_vendor_write(9, 0, serial);
765 }
766
767 /* Setup termios */
768 if (tty)
769 pl2303_set_termios(tty, port, &tmp_termios);
770
771 dbg("%s - submitting read urb", __func__);
772 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
773 if (result) {
774 dev_err(&port->dev, "%s - failed submitting read urb,"
775 " error %d\n", __func__, result);
776 pl2303_close(port);
777 return -EPROTO;
778 }
779
780 dbg("%s - submitting interrupt urb", __func__);
781 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
782 if (result) {
783 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
784 " error %d\n", __func__, result);
785 pl2303_close(port);
786 return -EPROTO;
787 }
788 port->port.drain_delay = 256;
789 return 0;
790 }
791
792 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
793 unsigned int set, unsigned int clear)
794 {
795 struct usb_serial_port *port = tty->driver_data;
796 struct pl2303_private *priv = usb_get_serial_port_data(port);
797 unsigned long flags;
798 u8 control;
799
800 if (!usb_get_intfdata(port->serial->interface))
801 return -ENODEV;
802
803 spin_lock_irqsave(&priv->lock, flags);
804 if (set & TIOCM_RTS)
805 priv->line_control |= CONTROL_RTS;
806 if (set & TIOCM_DTR)
807 priv->line_control |= CONTROL_DTR;
808 if (clear & TIOCM_RTS)
809 priv->line_control &= ~CONTROL_RTS;
810 if (clear & TIOCM_DTR)
811 priv->line_control &= ~CONTROL_DTR;
812 control = priv->line_control;
813 spin_unlock_irqrestore(&priv->lock, flags);
814
815 return set_control_lines(port->serial->dev, control);
816 }
817
818 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
819 {
820 struct usb_serial_port *port = tty->driver_data;
821 struct pl2303_private *priv = usb_get_serial_port_data(port);
822 unsigned long flags;
823 unsigned int mcr;
824 unsigned int status;
825 unsigned int result;
826
827 dbg("%s (%d)", __func__, port->number);
828
829 if (!usb_get_intfdata(port->serial->interface))
830 return -ENODEV;
831
832 spin_lock_irqsave(&priv->lock, flags);
833 mcr = priv->line_control;
834 status = priv->line_status;
835 spin_unlock_irqrestore(&priv->lock, flags);
836
837 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
838 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
839 | ((status & UART_CTS) ? TIOCM_CTS : 0)
840 | ((status & UART_DSR) ? TIOCM_DSR : 0)
841 | ((status & UART_RING) ? TIOCM_RI : 0)
842 | ((status & UART_DCD) ? TIOCM_CD : 0);
843
844 dbg("%s - result = %x", __func__, result);
845
846 return result;
847 }
848
849 static int pl2303_carrier_raised(struct usb_serial_port *port)
850 {
851 struct pl2303_private *priv = usb_get_serial_port_data(port);
852 if (priv->line_status & UART_DCD)
853 return 1;
854 return 0;
855 }
856
857 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
858 {
859 struct pl2303_private *priv = usb_get_serial_port_data(port);
860 unsigned long flags;
861 unsigned int prevstatus;
862 unsigned int status;
863 unsigned int changed;
864
865 spin_lock_irqsave(&priv->lock, flags);
866 prevstatus = priv->line_status;
867 spin_unlock_irqrestore(&priv->lock, flags);
868
869 while (1) {
870 interruptible_sleep_on(&priv->delta_msr_wait);
871 /* see if a signal did it */
872 if (signal_pending(current))
873 return -ERESTARTSYS;
874
875 spin_lock_irqsave(&priv->lock, flags);
876 status = priv->line_status;
877 spin_unlock_irqrestore(&priv->lock, flags);
878
879 changed = prevstatus ^ status;
880
881 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
882 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
883 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
884 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
885 return 0;
886 }
887 prevstatus = status;
888 }
889 /* NOTREACHED */
890 return 0;
891 }
892
893 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
894 unsigned int cmd, unsigned long arg)
895 {
896 struct serial_struct ser;
897 struct usb_serial_port *port = tty->driver_data;
898 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
899
900 switch (cmd) {
901 case TIOCGSERIAL:
902 memset(&ser, 0, sizeof ser);
903 ser.type = PORT_16654;
904 ser.line = port->serial->minor;
905 ser.port = port->number;
906 ser.baud_base = 460800;
907
908 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
909 return -EFAULT;
910
911 return 0;
912
913 case TIOCMIWAIT:
914 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
915 return wait_modem_info(port, arg);
916 default:
917 dbg("%s not supported = 0x%04x", __func__, cmd);
918 break;
919 }
920 return -ENOIOCTLCMD;
921 }
922
923 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
924 {
925 struct usb_serial_port *port = tty->driver_data;
926 struct usb_serial *serial = port->serial;
927 u16 state;
928 int result;
929
930 dbg("%s - port %d", __func__, port->number);
931
932 if (break_state == 0)
933 state = BREAK_OFF;
934 else
935 state = BREAK_ON;
936 dbg("%s - turning break %s", __func__,
937 state == BREAK_OFF ? "off" : "on");
938
939 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
940 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
941 0, NULL, 0, 100);
942 if (result)
943 dbg("%s - error sending break = %d", __func__, result);
944 }
945
946 static void pl2303_release(struct usb_serial *serial)
947 {
948 int i;
949 struct pl2303_private *priv;
950
951 dbg("%s", __func__);
952
953 for (i = 0; i < serial->num_ports; ++i) {
954 priv = usb_get_serial_port_data(serial->port[i]);
955 if (priv) {
956 pl2303_buf_free(priv->buf);
957 kfree(priv);
958 }
959 }
960 }
961
962 static void pl2303_update_line_status(struct usb_serial_port *port,
963 unsigned char *data,
964 unsigned int actual_length)
965 {
966
967 struct pl2303_private *priv = usb_get_serial_port_data(port);
968 unsigned long flags;
969 u8 status_idx = UART_STATE;
970 u8 length = UART_STATE + 1;
971 u16 idv, idp;
972
973 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
974 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
975
976
977 if (idv == SIEMENS_VENDOR_ID) {
978 if (idp == SIEMENS_PRODUCT_ID_X65 ||
979 idp == SIEMENS_PRODUCT_ID_SX1 ||
980 idp == SIEMENS_PRODUCT_ID_X75) {
981
982 length = 1;
983 status_idx = 0;
984 }
985 }
986
987 if (actual_length < length)
988 return;
989
990 /* Save off the uart status for others to look at */
991 spin_lock_irqsave(&priv->lock, flags);
992 priv->line_status = data[status_idx];
993 spin_unlock_irqrestore(&priv->lock, flags);
994 if (priv->line_status & UART_BREAK_ERROR)
995 usb_serial_handle_break(port);
996 wake_up_interruptible(&priv->delta_msr_wait);
997 }
998
999 static void pl2303_read_int_callback(struct urb *urb)
1000 {
1001 struct usb_serial_port *port = urb->context;
1002 unsigned char *data = urb->transfer_buffer;
1003 unsigned int actual_length = urb->actual_length;
1004 int status = urb->status;
1005 int retval;
1006
1007 dbg("%s (%d)", __func__, port->number);
1008
1009 switch (status) {
1010 case 0:
1011 /* success */
1012 break;
1013 case -ECONNRESET:
1014 case -ENOENT:
1015 case -ESHUTDOWN:
1016 /* this urb is terminated, clean up */
1017 dbg("%s - urb shutting down with status: %d", __func__,
1018 status);
1019 return;
1020 default:
1021 dbg("%s - nonzero urb status received: %d", __func__,
1022 status);
1023 goto exit;
1024 }
1025
1026 usb_serial_debug_data(debug, &port->dev, __func__,
1027 urb->actual_length, urb->transfer_buffer);
1028
1029 pl2303_update_line_status(port, data, actual_length);
1030
1031 exit:
1032 retval = usb_submit_urb(urb, GFP_ATOMIC);
1033 if (retval)
1034 dev_err(&urb->dev->dev,
1035 "%s - usb_submit_urb failed with result %d\n",
1036 __func__, retval);
1037 }
1038
1039 static void pl2303_push_data(struct tty_struct *tty,
1040 struct usb_serial_port *port, struct urb *urb,
1041 u8 line_status)
1042 {
1043 unsigned char *data = urb->transfer_buffer;
1044 /* get tty_flag from status */
1045 char tty_flag = TTY_NORMAL;
1046 /* break takes precedence over parity, */
1047 /* which takes precedence over framing errors */
1048 if (line_status & UART_BREAK_ERROR)
1049 tty_flag = TTY_BREAK;
1050 else if (line_status & UART_PARITY_ERROR)
1051 tty_flag = TTY_PARITY;
1052 else if (line_status & UART_FRAME_ERROR)
1053 tty_flag = TTY_FRAME;
1054 dbg("%s - tty_flag = %d", __func__, tty_flag);
1055
1056 /* overrun is special, not associated with a char */
1057 if (line_status & UART_OVERRUN_ERROR)
1058 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1059
1060 if (tty_flag == TTY_NORMAL && !(port->console && port->sysrq))
1061 tty_insert_flip_string(tty, data, urb->actual_length);
1062 else {
1063 int i;
1064 for (i = 0; i < urb->actual_length; ++i)
1065 if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
1066 tty_insert_flip_char(tty, data[i], tty_flag);
1067 }
1068 tty_flip_buffer_push(tty);
1069 }
1070
1071 static void pl2303_read_bulk_callback(struct urb *urb)
1072 {
1073 struct usb_serial_port *port = urb->context;
1074 struct pl2303_private *priv = usb_get_serial_port_data(port);
1075 struct tty_struct *tty;
1076 unsigned long flags;
1077 int result;
1078 int status = urb->status;
1079 u8 line_status;
1080
1081 dbg("%s - port %d", __func__, port->number);
1082
1083 if (status) {
1084 dbg("%s - urb status = %d", __func__, status);
1085 if (status == -EPROTO) {
1086 /* PL2303 mysteriously fails with -EPROTO reschedule
1087 * the read */
1088 dbg("%s - caught -EPROTO, resubmitting the urb",
1089 __func__);
1090 result = usb_submit_urb(urb, GFP_ATOMIC);
1091 if (result)
1092 dev_err(&urb->dev->dev, "%s - failed"
1093 " resubmitting read urb, error %d\n",
1094 __func__, result);
1095 return;
1096 }
1097 dbg("%s - unable to handle the error, exiting.", __func__);
1098 return;
1099 }
1100
1101 usb_serial_debug_data(debug, &port->dev, __func__,
1102 urb->actual_length, urb->transfer_buffer);
1103
1104 spin_lock_irqsave(&priv->lock, flags);
1105 line_status = priv->line_status;
1106 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1107 spin_unlock_irqrestore(&priv->lock, flags);
1108 wake_up_interruptible(&priv->delta_msr_wait);
1109
1110 tty = tty_port_tty_get(&port->port);
1111 if (tty && urb->actual_length) {
1112 pl2303_push_data(tty, port, urb, line_status);
1113 }
1114 tty_kref_put(tty);
1115 /* Schedule the next read _if_ we are still open */
1116 result = usb_submit_urb(urb, GFP_ATOMIC);
1117 if (result && result != -EPERM)
1118 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1119 " read urb, error %d\n", __func__, result);
1120 }
1121
1122 static 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 /* success */
1134 break;
1135 case -ECONNRESET:
1136 case -ENOENT:
1137 case -ESHUTDOWN:
1138 /* this urb is terminated, clean up */
1139 dbg("%s - urb shutting down with status: %d", __func__,
1140 status);
1141 priv->write_urb_in_use = 0;
1142 return;
1143 default:
1144 /* error in the urb, so we have to resubmit it */
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 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1150 if (result)
1151 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1152 " urb, error %d\n", __func__, result);
1153 else
1154 return;
1155 }
1156
1157 priv->write_urb_in_use = 0;
1158
1159 /* send any buffered data */
1160 pl2303_send(port);
1161 }
1162
1163 /* All of the device info needed for the PL2303 SIO serial converter */
1164 static struct usb_serial_driver pl2303_device = {
1165 .driver = {
1166 .owner = THIS_MODULE,
1167 .name = "pl2303",
1168 },
1169 .id_table = id_table,
1170 .usb_driver = &pl2303_driver,
1171 .num_ports = 1,
1172 .open = pl2303_open,
1173 .close = pl2303_close,
1174 .dtr_rts = pl2303_dtr_rts,
1175 .carrier_raised = pl2303_carrier_raised,
1176 .write = pl2303_write,
1177 .ioctl = pl2303_ioctl,
1178 .break_ctl = pl2303_break_ctl,
1179 .set_termios = pl2303_set_termios,
1180 .tiocmget = pl2303_tiocmget,
1181 .tiocmset = pl2303_tiocmset,
1182 .read_bulk_callback = pl2303_read_bulk_callback,
1183 .read_int_callback = pl2303_read_int_callback,
1184 .write_bulk_callback = pl2303_write_bulk_callback,
1185 .write_room = pl2303_write_room,
1186 .chars_in_buffer = pl2303_chars_in_buffer,
1187 .attach = pl2303_startup,
1188 .release = pl2303_release,
1189 };
1190
1191 static int __init pl2303_init(void)
1192 {
1193 int retval;
1194
1195 retval = usb_serial_register(&pl2303_device);
1196 if (retval)
1197 goto failed_usb_serial_register;
1198 retval = usb_register(&pl2303_driver);
1199 if (retval)
1200 goto failed_usb_register;
1201 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1202 return 0;
1203 failed_usb_register:
1204 usb_serial_deregister(&pl2303_device);
1205 failed_usb_serial_register:
1206 return retval;
1207 }
1208
1209 static void __exit pl2303_exit(void)
1210 {
1211 usb_deregister(&pl2303_driver);
1212 usb_serial_deregister(&pl2303_device);
1213 }
1214
1215 module_init(pl2303_init);
1216 module_exit(pl2303_exit);
1217
1218 MODULE_DESCRIPTION(DRIVER_DESC);
1219 MODULE_LICENSE("GPL");
1220
1221 module_param(debug, bool, S_IRUGO | S_IWUSR);
1222 MODULE_PARM_DESC(debug, "Debug enabled or not");
1223
Linux kernel - Deliverables
This page took 0.06888 seconds and 5 git commands to generate.