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