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