projects / deliverable / linux.git / blob
? search:


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