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