?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tty: pl2303 needs identifiers for Siemens S81 as well as EF81
[linux-2.6/verdex.git] / drivers / usb / serial / pl2303.c
blob751a533a4347e7324725afb8948b75fcb2437bbd
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_close(struct tty_struct *tty,
656 struct usb_serial_port *port, struct file *filp)
657 {
658 struct pl2303_private *priv = usb_get_serial_port_data(port);
659 unsigned long flags;
660 unsigned int c_cflag;
661 int bps;
662 long timeout;
663 wait_queue_t wait;
664
665 dbg("%s - port %d", __func__, port->number);
666
667 /* wait for data to drain from the buffer */
668 spin_lock_irqsave(&priv->lock, flags);
669 timeout = PL2303_CLOSING_WAIT;
670 init_waitqueue_entry(&wait, current);
671 add_wait_queue(&tty->write_wait, &wait);
672 for (;;) {
673 set_current_state(TASK_INTERRUPTIBLE);
674 if (pl2303_buf_data_avail(priv->buf) == 0 ||
675 timeout == 0 || signal_pending(current) ||
676 port->serial->disconnected)
677 break;
678 spin_unlock_irqrestore(&priv->lock, flags);
679 timeout = schedule_timeout(timeout);
680 spin_lock_irqsave(&priv->lock, flags);
681 }
682 set_current_state(TASK_RUNNING);
683 remove_wait_queue(&tty->write_wait, &wait);
684 /* clear out any remaining data in the buffer */
685 pl2303_buf_clear(priv->buf);
686 spin_unlock_irqrestore(&priv->lock, flags);
687
688 /* wait for characters to drain from the device */
689 /* (this is long enough for the entire 256 byte */
690 /* pl2303 hardware buffer to drain with no flow */
691 /* control for data rates of 1200 bps or more, */
692 /* for lower rates we should really know how much */
693 /* data is in the buffer to compute a delay */
694 /* that is not unnecessarily long) */
695 bps = tty_get_baud_rate(tty);
696 if (bps > 1200)
697 timeout = max((HZ*2560)/bps, HZ/10);
698 else
699 timeout = 2*HZ;
700 schedule_timeout_interruptible(timeout);
701
702 /* shutdown our urbs */
703 dbg("%s - shutting down urbs", __func__);
704 usb_kill_urb(port->write_urb);
705 usb_kill_urb(port->read_urb);
706 usb_kill_urb(port->interrupt_in_urb);
707
708 if (tty) {
709 c_cflag = tty->termios->c_cflag;
710 if (c_cflag & HUPCL) {
711 /* drop DTR and RTS */
712 spin_lock_irqsave(&priv->lock, flags);
713 priv->line_control = 0;
714 spin_unlock_irqrestore(&priv->lock, flags);
715 set_control_lines(port->serial->dev, 0);
716 }
717 }
718 }
719
720 static int pl2303_open(struct tty_struct *tty,
721 struct usb_serial_port *port, struct file *filp)
722 {
723 struct ktermios tmp_termios;
724 struct usb_serial *serial = port->serial;
725 struct pl2303_private *priv = usb_get_serial_port_data(port);
726 int result;
727
728 dbg("%s - port %d", __func__, port->number);
729
730 if (priv->type != HX) {
731 usb_clear_halt(serial->dev, port->write_urb->pipe);
732 usb_clear_halt(serial->dev, port->read_urb->pipe);
733 } else {
734 /* reset upstream data pipes */
735 pl2303_vendor_write(8, 0, serial);
736 pl2303_vendor_write(9, 0, serial);
737 }
738
739 /* Setup termios */
740 if (tty)
741 pl2303_set_termios(tty, port, &tmp_termios);
742
743 /* FIXME: need to assert RTS and DTR if CRTSCTS off */
744
745 dbg("%s - submitting read urb", __func__);
746 port->read_urb->dev = serial->dev;
747 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
748 if (result) {
749 dev_err(&port->dev, "%s - failed submitting read urb,"
750 " error %d\n", __func__, result);
751 pl2303_close(tty, port, NULL);
752 return -EPROTO;
753 }
754
755 dbg("%s - submitting interrupt urb", __func__);
756 port->interrupt_in_urb->dev = serial->dev;
757 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
758 if (result) {
759 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
760 " error %d\n", __func__, result);
761 pl2303_close(tty, port, NULL);
762 return -EPROTO;
763 }
764 return 0;
765 }
766
767 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
768 unsigned int set, unsigned int clear)
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 u8 control;
774
775 if (!usb_get_intfdata(port->serial->interface))
776 return -ENODEV;
777
778 spin_lock_irqsave(&priv->lock, flags);
779 if (set & TIOCM_RTS)
780 priv->line_control |= CONTROL_RTS;
781 if (set & TIOCM_DTR)
782 priv->line_control |= CONTROL_DTR;
783 if (clear & TIOCM_RTS)
784 priv->line_control &= ~CONTROL_RTS;
785 if (clear & TIOCM_DTR)
786 priv->line_control &= ~CONTROL_DTR;
787 control = priv->line_control;
788 spin_unlock_irqrestore(&priv->lock, flags);
789
790 return set_control_lines(port->serial->dev, control);
791 }
792
793 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
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 unsigned int mcr;
799 unsigned int status;
800 unsigned int result;
801
802 dbg("%s (%d)", __func__, port->number);
803
804 if (!usb_get_intfdata(port->serial->interface))
805 return -ENODEV;
806
807 spin_lock_irqsave(&priv->lock, flags);
808 mcr = priv->line_control;
809 status = priv->line_status;
810 spin_unlock_irqrestore(&priv->lock, flags);
811
812 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
813 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
814 | ((status & UART_CTS) ? TIOCM_CTS : 0)
815 | ((status & UART_DSR) ? TIOCM_DSR : 0)
816 | ((status & UART_RING) ? TIOCM_RI : 0)
817 | ((status & UART_DCD) ? TIOCM_CD : 0);
818
819 dbg("%s - result = %x", __func__, result);
820
821 return result;
822 }
823
824 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
825 {
826 struct pl2303_private *priv = usb_get_serial_port_data(port);
827 unsigned long flags;
828 unsigned int prevstatus;
829 unsigned int status;
830 unsigned int changed;
831
832 spin_lock_irqsave(&priv->lock, flags);
833 prevstatus = priv->line_status;
834 spin_unlock_irqrestore(&priv->lock, flags);
835
836 while (1) {
837 interruptible_sleep_on(&priv->delta_msr_wait);
838 /* see if a signal did it */
839 if (signal_pending(current))
840 return -ERESTARTSYS;
841
842 spin_lock_irqsave(&priv->lock, flags);
843 status = priv->line_status;
844 spin_unlock_irqrestore(&priv->lock, flags);
845
846 changed = prevstatus ^ status;
847
848 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
849 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
850 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
851 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
852 return 0;
853 }
854 prevstatus = status;
855 }
856 /* NOTREACHED */
857 return 0;
858 }
859
860 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
861 unsigned int cmd, unsigned long arg)
862 {
863 struct usb_serial_port *port = tty->driver_data;
864 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
865
866 switch (cmd) {
867 case TIOCMIWAIT:
868 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
869 return wait_modem_info(port, arg);
870 default:
871 dbg("%s not supported = 0x%04x", __func__, cmd);
872 break;
873 }
874 return -ENOIOCTLCMD;
875 }
876
877 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
878 {
879 struct usb_serial_port *port = tty->driver_data;
880 struct usb_serial *serial = port->serial;
881 u16 state;
882 int result;
883
884 dbg("%s - port %d", __func__, port->number);
885
886 if (break_state == 0)
887 state = BREAK_OFF;
888 else
889 state = BREAK_ON;
890 dbg("%s - turning break %s", __func__,
891 state == BREAK_OFF ? "off" : "on");
892
893 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
894 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
895 0, NULL, 0, 100);
896 if (result)
897 dbg("%s - error sending break = %d", __func__, result);
898 }
899
900 static void pl2303_shutdown(struct usb_serial *serial)
901 {
902 int i;
903 struct pl2303_private *priv;
904
905 dbg("%s", __func__);
906
907 for (i = 0; i < serial->num_ports; ++i) {
908 priv = usb_get_serial_port_data(serial->port[i]);
909 if (priv) {
910 pl2303_buf_free(priv->buf);
911 kfree(priv);
912 usb_set_serial_port_data(serial->port[i], NULL);
913 }
914 }
915 }
916
917 static void pl2303_update_line_status(struct usb_serial_port *port,
918 unsigned char *data,
919 unsigned int actual_length)
920 {
921
922 struct pl2303_private *priv = usb_get_serial_port_data(port);
923 unsigned long flags;
924 u8 status_idx = UART_STATE;
925 u8 length = UART_STATE + 1;
926 u16 idv, idp;
927
928 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
929 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
930
931
932 if (idv == SIEMENS_VENDOR_ID) {
933 if (idp == SIEMENS_PRODUCT_ID_X65 ||
934 idp == SIEMENS_PRODUCT_ID_SX1 ||
935 idp == SIEMENS_PRODUCT_ID_X75) {
936
937 length = 1;
938 status_idx = 0;
939 }
940 }
941
942 if (actual_length < length)
943 return;
944
945 /* Save off the uart status for others to look at */
946 spin_lock_irqsave(&priv->lock, flags);
947 priv->line_status = data[status_idx];
948 spin_unlock_irqrestore(&priv->lock, flags);
949 wake_up_interruptible(&priv->delta_msr_wait);
950 }
951
952 static void pl2303_read_int_callback(struct urb *urb)
953 {
954 struct usb_serial_port *port = urb->context;
955 unsigned char *data = urb->transfer_buffer;
956 unsigned int actual_length = urb->actual_length;
957 int status = urb->status;
958 int retval;
959
960 dbg("%s (%d)", __func__, port->number);
961
962 switch (status) {
963 case 0:
964 /* success */
965 break;
966 case -ECONNRESET:
967 case -ENOENT:
968 case -ESHUTDOWN:
969 /* this urb is terminated, clean up */
970 dbg("%s - urb shutting down with status: %d", __func__,
971 status);
972 return;
973 default:
974 dbg("%s - nonzero urb status received: %d", __func__,
975 status);
976 goto exit;
977 }
978
979 usb_serial_debug_data(debug, &port->dev, __func__,
980 urb->actual_length, urb->transfer_buffer);
981
982 pl2303_update_line_status(port, data, actual_length);
983
984 exit:
985 retval = usb_submit_urb(urb, GFP_ATOMIC);
986 if (retval)
987 dev_err(&urb->dev->dev,
988 "%s - usb_submit_urb failed with result %d\n",
989 __func__, retval);
990 }
991
992 static void pl2303_read_bulk_callback(struct urb *urb)
993 {
994 struct usb_serial_port *port = urb->context;
995 struct pl2303_private *priv = usb_get_serial_port_data(port);
996 struct tty_struct *tty;
997 unsigned char *data = urb->transfer_buffer;
998 unsigned long flags;
999 int i;
1000 int result;
1001 int status = urb->status;
1002 u8 line_status;
1003 char tty_flag;
1004
1005 dbg("%s - port %d", __func__, port->number);
1006
1007 if (status) {
1008 dbg("%s - urb status = %d", __func__, status);
1009 if (!port->port.count) {
1010 dbg("%s - port is closed, exiting.", __func__);
1011 return;
1012 }
1013 if (status == -EPROTO) {
1014 /* PL2303 mysteriously fails with -EPROTO reschedule
1015 * the read */
1016 dbg("%s - caught -EPROTO, resubmitting the urb",
1017 __func__);
1018 urb->dev = port->serial->dev;
1019 result = usb_submit_urb(urb, GFP_ATOMIC);
1020 if (result)
1021 dev_err(&urb->dev->dev, "%s - failed"
1022 " resubmitting read urb, error %d\n",
1023 __func__, result);
1024 return;
1025 }
1026 dbg("%s - unable to handle the error, exiting.", __func__);
1027 return;
1028 }
1029
1030 usb_serial_debug_data(debug, &port->dev, __func__,
1031 urb->actual_length, data);
1032
1033 /* get tty_flag from status */
1034 tty_flag = TTY_NORMAL;
1035
1036 spin_lock_irqsave(&priv->lock, flags);
1037 line_status = priv->line_status;
1038 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1039 spin_unlock_irqrestore(&priv->lock, flags);
1040 wake_up_interruptible(&priv->delta_msr_wait);
1041
1042 /* break takes precedence over parity, */
1043 /* which takes precedence over framing errors */
1044 if (line_status & UART_BREAK_ERROR)
1045 tty_flag = TTY_BREAK;
1046 else if (line_status & UART_PARITY_ERROR)
1047 tty_flag = TTY_PARITY;
1048 else if (line_status & UART_FRAME_ERROR)
1049 tty_flag = TTY_FRAME;
1050 dbg("%s - tty_flag = %d", __func__, tty_flag);
1051
1052 tty = tty_port_tty_get(&port->port);
1053 if (tty && urb->actual_length) {
1054 tty_buffer_request_room(tty, urb->actual_length + 1);
1055 /* overrun is special, not associated with a char */
1056 if (line_status & UART_OVERRUN_ERROR)
1057 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1058 for (i = 0; i < urb->actual_length; ++i)
1059 tty_insert_flip_char(tty, data[i], tty_flag);
1060 tty_flip_buffer_push(tty);
1061 }
1062 tty_kref_put(tty);
1063 /* Schedule the next read _if_ we are still open */
1064 if (port->port.count) {
1065 urb->dev = port->serial->dev;
1066 result = usb_submit_urb(urb, GFP_ATOMIC);
1067 if (result)
1068 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1069 " read urb, error %d\n", __func__, result);
1070 }
1071
1072 return;
1073 }
1074
1075 static void pl2303_write_bulk_callback(struct urb *urb)
1076 {
1077 struct usb_serial_port *port = urb->context;
1078 struct pl2303_private *priv = usb_get_serial_port_data(port);
1079 int result;
1080 int status = urb->status;
1081
1082 dbg("%s - port %d", __func__, port->number);
1083
1084 switch (status) {
1085 case 0:
1086 /* success */
1087 break;
1088 case -ECONNRESET:
1089 case -ENOENT:
1090 case -ESHUTDOWN:
1091 /* this urb is terminated, clean up */
1092 dbg("%s - urb shutting down with status: %d", __func__,
1093 status);
1094 priv->write_urb_in_use = 0;
1095 return;
1096 default:
1097 /* error in the urb, so we have to resubmit it */
1098 dbg("%s - Overflow in write", __func__);
1099 dbg("%s - nonzero write bulk status received: %d", __func__,
1100 status);
1101 port->write_urb->transfer_buffer_length = 1;
1102 port->write_urb->dev = port->serial->dev;
1103 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1104 if (result)
1105 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1106 " urb, error %d\n", __func__, result);
1107 else
1108 return;
1109 }
1110
1111 priv->write_urb_in_use = 0;
1112
1113 /* send any buffered data */
1114 pl2303_send(port);
1115 }
1116
1117 /* All of the device info needed for the PL2303 SIO serial converter */
1118 static struct usb_serial_driver pl2303_device = {
1119 .driver = {
1120 .owner = THIS_MODULE,
1121 .name = "pl2303",
1122 },
1123 .id_table = id_table,
1124 .usb_driver = &pl2303_driver,
1125 .num_ports = 1,
1126 .open = pl2303_open,
1127 .close = pl2303_close,
1128 .write = pl2303_write,
1129 .ioctl = pl2303_ioctl,
1130 .break_ctl = pl2303_break_ctl,
1131 .set_termios = pl2303_set_termios,
1132 .tiocmget = pl2303_tiocmget,
1133 .tiocmset = pl2303_tiocmset,
1134 .read_bulk_callback = pl2303_read_bulk_callback,
1135 .read_int_callback = pl2303_read_int_callback,
1136 .write_bulk_callback = pl2303_write_bulk_callback,
1137 .write_room = pl2303_write_room,
1138 .chars_in_buffer = pl2303_chars_in_buffer,
1139 .attach = pl2303_startup,
1140 .shutdown = pl2303_shutdown,
1141 };
1142
1143 static int __init pl2303_init(void)
1144 {
1145 int retval;
1146
1147 retval = usb_serial_register(&pl2303_device);
1148 if (retval)
1149 goto failed_usb_serial_register;
1150 retval = usb_register(&pl2303_driver);
1151 if (retval)
1152 goto failed_usb_register;
1153 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1154 return 0;
1155 failed_usb_register:
1156 usb_serial_deregister(&pl2303_device);
1157 failed_usb_serial_register:
1158 return retval;
1159 }
1160
1161 static void __exit pl2303_exit(void)
1162 {
1163 usb_deregister(&pl2303_driver);
1164 usb_serial_deregister(&pl2303_device);
1165 }
1166
1167 module_init(pl2303_init);
1168 module_exit(pl2303_exit);
1169
1170 MODULE_DESCRIPTION(DRIVER_DESC);
1171 MODULE_LICENSE("GPL");
1172
1173 module_param(debug, bool, S_IRUGO | S_IWUSR);
1174 MODULE_PARM_DESC(debug, "Debug enabled or not");
1175
Verdex Pro support