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