?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding support for MOXA ART SoC. Testing port of linux-2.6.32.60-moxart.
[linux-3.6.7-moxart.git] / drivers / usb / serial / pl2303.c
blob4d8d2100d6e00dd32b3691e4d618806f341771b5
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 bool debug;
40
41 static const struct usb_device_id id_table[] = {
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
52 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
53 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
54 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
55 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
56 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
57 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
58 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
59 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
60 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
61 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
62 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
63 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
64 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
65 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
66 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
67 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
68 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
72 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
73 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
74 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
75 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
76 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
77 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
78 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
79 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
80 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
81 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
82 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
83 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
84 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
85 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
86 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
87 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
88 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
89 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
90 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
91 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
92 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
93 { } /* Terminating entry */
94 };
95
96 MODULE_DEVICE_TABLE(usb, id_table);
97
98 #define SET_LINE_REQUEST_TYPE 0x21
99 #define SET_LINE_REQUEST 0x20
100
101 #define SET_CONTROL_REQUEST_TYPE 0x21
102 #define SET_CONTROL_REQUEST 0x22
103 #define CONTROL_DTR 0x01
104 #define CONTROL_RTS 0x02
105
106 #define BREAK_REQUEST_TYPE 0x21
107 #define BREAK_REQUEST 0x23
108 #define BREAK_ON 0xffff
109 #define BREAK_OFF 0x0000
110
111 #define GET_LINE_REQUEST_TYPE 0xa1
112 #define GET_LINE_REQUEST 0x21
113
114 #define VENDOR_WRITE_REQUEST_TYPE 0x40
115 #define VENDOR_WRITE_REQUEST 0x01
116
117 #define VENDOR_READ_REQUEST_TYPE 0xc0
118 #define VENDOR_READ_REQUEST 0x01
119
120 #define UART_STATE 0x08
121 #define UART_STATE_TRANSIENT_MASK 0x74
122 #define UART_DCD 0x01
123 #define UART_DSR 0x02
124 #define UART_BREAK_ERROR 0x04
125 #define UART_RING 0x08
126 #define UART_FRAME_ERROR 0x10
127 #define UART_PARITY_ERROR 0x20
128 #define UART_OVERRUN_ERROR 0x40
129 #define UART_CTS 0x80
130
131
132 enum pl2303_type {
133 type_0, /* don't know the difference between type 0 and */
134 type_1, /* type 1, until someone from prolific tells us... */
135 HX, /* HX version of the pl2303 chip */
136 };
137
138 struct pl2303_serial_private {
139 enum pl2303_type type;
140 };
141
142 struct pl2303_private {
143 spinlock_t lock;
144 wait_queue_head_t delta_msr_wait;
145 u8 line_control;
146 u8 line_status;
147 };
148
149 static int pl2303_vendor_read(__u16 value, __u16 index,
150 struct usb_serial *serial, unsigned char *buf)
151 {
152 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
153 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
154 value, index, buf, 1, 100);
155 dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x %d - %x\n",
156 VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
157 res, buf[0]);
158 return res;
159 }
160
161 static int pl2303_vendor_write(__u16 value, __u16 index,
162 struct usb_serial *serial)
163 {
164 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
165 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
166 value, index, NULL, 0, 100);
167 dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x %d\n",
168 VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
169 res);
170 return res;
171 }
172
173 static int pl2303_startup(struct usb_serial *serial)
174 {
175 struct pl2303_serial_private *spriv;
176 enum pl2303_type type = type_0;
177 unsigned char *buf;
178
179 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
180 if (!spriv)
181 return -ENOMEM;
182
183 buf = kmalloc(10, GFP_KERNEL);
184 if (!buf) {
185 kfree(spriv);
186 return -ENOMEM;
187 }
188
189 if (serial->dev->descriptor.bDeviceClass == 0x02)
190 type = type_0;
191 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
192 type = HX;
193 else if (serial->dev->descriptor.bDeviceClass == 0x00)
194 type = type_1;
195 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
196 type = type_1;
197 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
198
199 spriv->type = type;
200 usb_set_serial_data(serial, spriv);
201
202 pl2303_vendor_read(0x8484, 0, serial, buf);
203 pl2303_vendor_write(0x0404, 0, serial);
204 pl2303_vendor_read(0x8484, 0, serial, buf);
205 pl2303_vendor_read(0x8383, 0, serial, buf);
206 pl2303_vendor_read(0x8484, 0, serial, buf);
207 pl2303_vendor_write(0x0404, 1, serial);
208 pl2303_vendor_read(0x8484, 0, serial, buf);
209 pl2303_vendor_read(0x8383, 0, serial, buf);
210 pl2303_vendor_write(0, 1, serial);
211 pl2303_vendor_write(1, 0, serial);
212 if (type == HX)
213 pl2303_vendor_write(2, 0x44, serial);
214 else
215 pl2303_vendor_write(2, 0x24, serial);
216
217 kfree(buf);
218 return 0;
219 }
220
221 static void pl2303_release(struct usb_serial *serial)
222 {
223 struct pl2303_serial_private *spriv;
224
225 spriv = usb_get_serial_data(serial);
226 kfree(spriv);
227 }
228
229 static int pl2303_port_probe(struct usb_serial_port *port)
230 {
231 struct pl2303_private *priv;
232
233 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
234 if (!priv)
235 return -ENOMEM;
236
237 spin_lock_init(&priv->lock);
238 init_waitqueue_head(&priv->delta_msr_wait);
239
240 usb_set_serial_port_data(port, priv);
241
242 return 0;
243 }
244
245 static int pl2303_port_remove(struct usb_serial_port *port)
246 {
247 struct pl2303_private *priv;
248
249 priv = usb_get_serial_port_data(port);
250 kfree(priv);
251
252 return 0;
253 }
254
255 static int set_control_lines(struct usb_device *dev, u8 value)
256 {
257 int retval;
258
259 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
260 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
261 value, 0, NULL, 0, 100);
262 dev_dbg(&dev->dev, "%s - value = %d, retval = %d\n", __func__,
263 value, retval);
264 return retval;
265 }
266
267 static void pl2303_set_termios(struct tty_struct *tty,
268 struct usb_serial_port *port, struct ktermios *old_termios)
269 {
270 struct usb_serial *serial = port->serial;
271 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
272 struct pl2303_private *priv = usb_get_serial_port_data(port);
273 unsigned long flags;
274 unsigned int cflag;
275 unsigned char *buf;
276 int baud;
277 int i;
278 u8 control;
279 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
280 4800, 7200, 9600, 14400, 19200, 28800, 38400,
281 57600, 115200, 230400, 460800, 614400,
282 921600, 1228800, 2457600, 3000000, 6000000 };
283 int baud_floor, baud_ceil;
284 int k;
285
286 /* The PL2303 is reported to lose bytes if you change
287 serial settings even to the same values as before. Thus
288 we actually need to filter in this specific case */
289
290 if (!tty_termios_hw_change(tty->termios, old_termios))
291 return;
292
293 cflag = tty->termios->c_cflag;
294
295 buf = kzalloc(7, GFP_KERNEL);
296 if (!buf) {
297 dev_err(&port->dev, "%s - out of memory.\n", __func__);
298 /* Report back no change occurred */
299 *tty->termios = *old_termios;
300 return;
301 }
302
303 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
304 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
305 0, 0, buf, 7, 100);
306 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x\n", i,
307 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
308
309 if (cflag & CSIZE) {
310 switch (cflag & CSIZE) {
311 case CS5:
312 buf[6] = 5;
313 break;
314 case CS6:
315 buf[6] = 6;
316 break;
317 case CS7:
318 buf[6] = 7;
319 break;
320 default:
321 case CS8:
322 buf[6] = 8;
323 break;
324 }
325 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
326 }
327
328 /* For reference buf[0]:buf[3] baud rate value */
329 /* NOTE: Only the values defined in baud_sup are supported !
330 * => if unsupported values are set, the PL2303 seems to use
331 * 9600 baud (at least my PL2303X always does)
332 */
333 baud = tty_get_baud_rate(tty);
334 dev_dbg(&port->dev, "baud requested = %d\n", baud);
335 if (baud) {
336 /* Set baudrate to nearest supported value */
337 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
338 if (baud_sup[k] / baud) {
339 baud_ceil = baud_sup[k];
340 if (k==0) {
341 baud = baud_ceil;
342 } else {
343 baud_floor = baud_sup[k-1];
344 if ((baud_ceil % baud)
345 > (baud % baud_floor))
346 baud = baud_floor;
347 else
348 baud = baud_ceil;
349 }
350 break;
351 }
352 }
353 if (baud > 1228800) {
354 /* type_0, type_1 only support up to 1228800 baud */
355 if (spriv->type != HX)
356 baud = 1228800;
357 else if (baud > 6000000)
358 baud = 6000000;
359 }
360 dev_dbg(&port->dev, "baud set = %d\n", baud);
361 if (baud <= 115200) {
362 buf[0] = baud & 0xff;
363 buf[1] = (baud >> 8) & 0xff;
364 buf[2] = (baud >> 16) & 0xff;
365 buf[3] = (baud >> 24) & 0xff;
366 } else {
367 /* apparently the formula for higher speeds is:
368 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
369 */
370 unsigned tmp = 12*1000*1000*32 / baud;
371 buf[3] = 0x80;
372 buf[2] = 0;
373 buf[1] = (tmp >= 256);
374 while (tmp >= 256) {
375 tmp >>= 2;
376 buf[1] <<= 1;
377 }
378 buf[0] = tmp;
379 }
380 }
381
382 /* For reference buf[4]=0 is 1 stop bits */
383 /* For reference buf[4]=1 is 1.5 stop bits */
384 /* For reference buf[4]=2 is 2 stop bits */
385 if (cflag & CSTOPB) {
386 /* NOTE: Comply with "real" UARTs / RS232:
387 * use 1.5 instead of 2 stop bits with 5 data bits
388 */
389 if ((cflag & CSIZE) == CS5) {
390 buf[4] = 1;
391 dev_dbg(&port->dev, "stop bits = 1.5\n");
392 } else {
393 buf[4] = 2;
394 dev_dbg(&port->dev, "stop bits = 2\n");
395 }
396 } else {
397 buf[4] = 0;
398 dev_dbg(&port->dev, "stop bits = 1\n");
399 }
400
401 if (cflag & PARENB) {
402 /* For reference buf[5]=0 is none parity */
403 /* For reference buf[5]=1 is odd parity */
404 /* For reference buf[5]=2 is even parity */
405 /* For reference buf[5]=3 is mark parity */
406 /* For reference buf[5]=4 is space parity */
407 if (cflag & PARODD) {
408 if (cflag & CMSPAR) {
409 buf[5] = 3;
410 dev_dbg(&port->dev, "parity = mark\n");
411 } else {
412 buf[5] = 1;
413 dev_dbg(&port->dev, "parity = odd\n");
414 }
415 } else {
416 if (cflag & CMSPAR) {
417 buf[5] = 4;
418 dev_dbg(&port->dev, "parity = space\n");
419 } else {
420 buf[5] = 2;
421 dev_dbg(&port->dev, "parity = even\n");
422 }
423 }
424 } else {
425 buf[5] = 0;
426 dev_dbg(&port->dev, "parity = none\n");
427 }
428
429 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
430 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
431 0, 0, buf, 7, 100);
432 dev_dbg(&port->dev, "0x21:0x20:0:0 %d\n", i);
433
434 /* change control lines if we are switching to or from B0 */
435 spin_lock_irqsave(&priv->lock, flags);
436 control = priv->line_control;
437 if ((cflag & CBAUD) == B0)
438 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
439 else if ((old_termios->c_cflag & CBAUD) == B0)
440 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
441 if (control != priv->line_control) {
442 control = priv->line_control;
443 spin_unlock_irqrestore(&priv->lock, flags);
444 set_control_lines(serial->dev, control);
445 } else {
446 spin_unlock_irqrestore(&priv->lock, flags);
447 }
448
449 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
450
451 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
452 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
453 0, 0, buf, 7, 100);
454 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x\n", i,
455 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
456
457 if (cflag & CRTSCTS) {
458 if (spriv->type == HX)
459 pl2303_vendor_write(0x0, 0x61, serial);
460 else
461 pl2303_vendor_write(0x0, 0x41, serial);
462 } else {
463 pl2303_vendor_write(0x0, 0x0, serial);
464 }
465
466 /* Save resulting baud rate */
467 if (baud)
468 tty_encode_baud_rate(tty, baud, baud);
469
470 kfree(buf);
471 }
472
473 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
474 {
475 struct pl2303_private *priv = usb_get_serial_port_data(port);
476 unsigned long flags;
477 u8 control;
478
479 spin_lock_irqsave(&priv->lock, flags);
480 /* Change DTR and RTS */
481 if (on)
482 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
483 else
484 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
485 control = priv->line_control;
486 spin_unlock_irqrestore(&priv->lock, flags);
487 set_control_lines(port->serial->dev, control);
488 }
489
490 static void pl2303_close(struct usb_serial_port *port)
491 {
492 usb_serial_generic_close(port);
493 usb_kill_urb(port->interrupt_in_urb);
494 }
495
496 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
497 {
498 struct ktermios tmp_termios;
499 struct usb_serial *serial = port->serial;
500 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
501 int result;
502
503 if (spriv->type != HX) {
504 usb_clear_halt(serial->dev, port->write_urb->pipe);
505 usb_clear_halt(serial->dev, port->read_urb->pipe);
506 } else {
507 /* reset upstream data pipes */
508 pl2303_vendor_write(8, 0, serial);
509 pl2303_vendor_write(9, 0, serial);
510 }
511
512 /* Setup termios */
513 if (tty)
514 pl2303_set_termios(tty, port, &tmp_termios);
515
516 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
517 if (result) {
518 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
519 " error %d\n", __func__, result);
520 return result;
521 }
522
523 result = usb_serial_generic_open(tty, port);
524 if (result) {
525 usb_kill_urb(port->interrupt_in_urb);
526 return result;
527 }
528
529 port->port.drain_delay = 256;
530 return 0;
531 }
532
533 static int pl2303_tiocmset(struct tty_struct *tty,
534 unsigned int set, unsigned int clear)
535 {
536 struct usb_serial_port *port = tty->driver_data;
537 struct usb_serial *serial = port->serial;
538 struct pl2303_private *priv = usb_get_serial_port_data(port);
539 unsigned long flags;
540 u8 control;
541 int ret;
542
543 spin_lock_irqsave(&priv->lock, flags);
544 if (set & TIOCM_RTS)
545 priv->line_control |= CONTROL_RTS;
546 if (set & TIOCM_DTR)
547 priv->line_control |= CONTROL_DTR;
548 if (clear & TIOCM_RTS)
549 priv->line_control &= ~CONTROL_RTS;
550 if (clear & TIOCM_DTR)
551 priv->line_control &= ~CONTROL_DTR;
552 control = priv->line_control;
553 spin_unlock_irqrestore(&priv->lock, flags);
554
555 mutex_lock(&serial->disc_mutex);
556 if (!serial->disconnected)
557 ret = set_control_lines(serial->dev, control);
558 else
559 ret = -ENODEV;
560 mutex_unlock(&serial->disc_mutex);
561
562 return ret;
563 }
564
565 static int pl2303_tiocmget(struct tty_struct *tty)
566 {
567 struct usb_serial_port *port = tty->driver_data;
568 struct pl2303_private *priv = usb_get_serial_port_data(port);
569 unsigned long flags;
570 unsigned int mcr;
571 unsigned int status;
572 unsigned int result;
573
574 spin_lock_irqsave(&priv->lock, flags);
575 mcr = priv->line_control;
576 status = priv->line_status;
577 spin_unlock_irqrestore(&priv->lock, flags);
578
579 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
580 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
581 | ((status & UART_CTS) ? TIOCM_CTS : 0)
582 | ((status & UART_DSR) ? TIOCM_DSR : 0)
583 | ((status & UART_RING) ? TIOCM_RI : 0)
584 | ((status & UART_DCD) ? TIOCM_CD : 0);
585
586 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
587
588 return result;
589 }
590
591 static int pl2303_carrier_raised(struct usb_serial_port *port)
592 {
593 struct pl2303_private *priv = usb_get_serial_port_data(port);
594 if (priv->line_status & UART_DCD)
595 return 1;
596 return 0;
597 }
598
599 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
600 {
601 struct pl2303_private *priv = usb_get_serial_port_data(port);
602 unsigned long flags;
603 unsigned int prevstatus;
604 unsigned int status;
605 unsigned int changed;
606
607 spin_lock_irqsave(&priv->lock, flags);
608 prevstatus = priv->line_status;
609 spin_unlock_irqrestore(&priv->lock, flags);
610
611 while (1) {
612 interruptible_sleep_on(&priv->delta_msr_wait);
613 /* see if a signal did it */
614 if (signal_pending(current))
615 return -ERESTARTSYS;
616
617 spin_lock_irqsave(&priv->lock, flags);
618 status = priv->line_status;
619 spin_unlock_irqrestore(&priv->lock, flags);
620
621 changed = prevstatus ^ status;
622
623 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
624 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
625 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
626 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
627 return 0;
628 }
629 prevstatus = status;
630 }
631 /* NOTREACHED */
632 return 0;
633 }
634
635 static int pl2303_ioctl(struct tty_struct *tty,
636 unsigned int cmd, unsigned long arg)
637 {
638 struct serial_struct ser;
639 struct usb_serial_port *port = tty->driver_data;
640
641 dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
642
643 switch (cmd) {
644 case TIOCGSERIAL:
645 memset(&ser, 0, sizeof ser);
646 ser.type = PORT_16654;
647 ser.line = port->serial->minor;
648 ser.port = port->number;
649 ser.baud_base = 460800;
650
651 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
652 return -EFAULT;
653
654 return 0;
655
656 case TIOCMIWAIT:
657 dev_dbg(&port->dev, "%s TIOCMIWAIT\n", __func__);
658 return wait_modem_info(port, arg);
659 default:
660 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
661 break;
662 }
663 return -ENOIOCTLCMD;
664 }
665
666 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
667 {
668 struct usb_serial_port *port = tty->driver_data;
669 struct usb_serial *serial = port->serial;
670 u16 state;
671 int result;
672
673 if (break_state == 0)
674 state = BREAK_OFF;
675 else
676 state = BREAK_ON;
677 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
678 state == BREAK_OFF ? "off" : "on");
679
680 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
681 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
682 0, NULL, 0, 100);
683 if (result)
684 dev_err(&port->dev, "error sending break = %d\n", result);
685 }
686
687 static void pl2303_update_line_status(struct usb_serial_port *port,
688 unsigned char *data,
689 unsigned int actual_length)
690 {
691
692 struct pl2303_private *priv = usb_get_serial_port_data(port);
693 struct tty_struct *tty;
694 unsigned long flags;
695 u8 status_idx = UART_STATE;
696 u8 length = UART_STATE + 1;
697 u8 prev_line_status;
698 u16 idv, idp;
699
700 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
701 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
702
703
704 if (idv == SIEMENS_VENDOR_ID) {
705 if (idp == SIEMENS_PRODUCT_ID_X65 ||
706 idp == SIEMENS_PRODUCT_ID_SX1 ||
707 idp == SIEMENS_PRODUCT_ID_X75) {
708
709 length = 1;
710 status_idx = 0;
711 }
712 }
713
714 if (actual_length < length)
715 return;
716
717 /* Save off the uart status for others to look at */
718 spin_lock_irqsave(&priv->lock, flags);
719 prev_line_status = priv->line_status;
720 priv->line_status = data[status_idx];
721 spin_unlock_irqrestore(&priv->lock, flags);
722 if (priv->line_status & UART_BREAK_ERROR)
723 usb_serial_handle_break(port);
724 wake_up_interruptible(&priv->delta_msr_wait);
725
726 tty = tty_port_tty_get(&port->port);
727 if (!tty)
728 return;
729 if ((priv->line_status ^ prev_line_status) & UART_DCD)
730 usb_serial_handle_dcd_change(port, tty,
731 priv->line_status & UART_DCD);
732 tty_kref_put(tty);
733 }
734
735 static void pl2303_read_int_callback(struct urb *urb)
736 {
737 struct usb_serial_port *port = urb->context;
738 unsigned char *data = urb->transfer_buffer;
739 unsigned int actual_length = urb->actual_length;
740 int status = urb->status;
741 int retval;
742
743 switch (status) {
744 case 0:
745 /* success */
746 break;
747 case -ECONNRESET:
748 case -ENOENT:
749 case -ESHUTDOWN:
750 /* this urb is terminated, clean up */
751 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
752 __func__, status);
753 return;
754 default:
755 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
756 __func__, status);
757 goto exit;
758 }
759
760 usb_serial_debug_data(debug, &port->dev, __func__,
761 urb->actual_length, urb->transfer_buffer);
762
763 pl2303_update_line_status(port, data, actual_length);
764
765 exit:
766 retval = usb_submit_urb(urb, GFP_ATOMIC);
767 if (retval)
768 dev_err(&port->dev,
769 "%s - usb_submit_urb failed with result %d\n",
770 __func__, retval);
771 }
772
773 static void pl2303_process_read_urb(struct urb *urb)
774 {
775 struct usb_serial_port *port = urb->context;
776 struct pl2303_private *priv = usb_get_serial_port_data(port);
777 struct tty_struct *tty;
778 unsigned char *data = urb->transfer_buffer;
779 char tty_flag = TTY_NORMAL;
780 unsigned long flags;
781 u8 line_status;
782 int i;
783
784 /* update line status */
785 spin_lock_irqsave(&priv->lock, flags);
786 line_status = priv->line_status;
787 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
788 spin_unlock_irqrestore(&priv->lock, flags);
789 wake_up_interruptible(&priv->delta_msr_wait);
790
791 if (!urb->actual_length)
792 return;
793
794 tty = tty_port_tty_get(&port->port);
795 if (!tty)
796 return;
797
798 /* break takes precedence over parity, */
799 /* which takes precedence over framing errors */
800 if (line_status & UART_BREAK_ERROR)
801 tty_flag = TTY_BREAK;
802 else if (line_status & UART_PARITY_ERROR)
803 tty_flag = TTY_PARITY;
804 else if (line_status & UART_FRAME_ERROR)
805 tty_flag = TTY_FRAME;
806 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
807
808 /* overrun is special, not associated with a char */
809 if (line_status & UART_OVERRUN_ERROR)
810 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
811
812 if (port->port.console && port->sysrq) {
813 for (i = 0; i < urb->actual_length; ++i)
814 if (!usb_serial_handle_sysrq_char(port, data[i]))
815 tty_insert_flip_char(tty, data[i], tty_flag);
816 } else {
817 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
818 urb->actual_length);
819 }
820
821 tty_flip_buffer_push(tty);
822 tty_kref_put(tty);
823 }
824
825 /* All of the device info needed for the PL2303 SIO serial converter */
826 static struct usb_serial_driver pl2303_device = {
827 .driver = {
828 .owner = THIS_MODULE,
829 .name = "pl2303",
830 },
831 .id_table = id_table,
832 .num_ports = 1,
833 .bulk_in_size = 256,
834 .bulk_out_size = 256,
835 .open = pl2303_open,
836 .close = pl2303_close,
837 .dtr_rts = pl2303_dtr_rts,
838 .carrier_raised = pl2303_carrier_raised,
839 .ioctl = pl2303_ioctl,
840 .break_ctl = pl2303_break_ctl,
841 .set_termios = pl2303_set_termios,
842 .tiocmget = pl2303_tiocmget,
843 .tiocmset = pl2303_tiocmset,
844 .process_read_urb = pl2303_process_read_urb,
845 .read_int_callback = pl2303_read_int_callback,
846 .attach = pl2303_startup,
847 .release = pl2303_release,
848 .port_probe = pl2303_port_probe,
849 .port_remove = pl2303_port_remove,
850 };
851
852 static struct usb_serial_driver * const serial_drivers[] = {
853 &pl2303_device, NULL
854 };
855
856 module_usb_serial_driver(serial_drivers, id_table);
857
858 MODULE_DESCRIPTION(DRIVER_DESC);
859 MODULE_LICENSE("GPL");
860
861 module_param(debug, bool, S_IRUGO | S_IWUSR);
862 MODULE_PARM_DESC(debug, "Debug enabled or not");
863
Linux ARM platform port for MOXA ART SoC