?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: serial: add IDs for WinChipHead USB->RS232 adapter
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / pl2303.c
blob0a7275eab03a1aeba126cae6549e1a7acfe9cb5a
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 buf[0] = baud & 0xff;
347 buf[1] = (baud >> 8) & 0xff;
348 buf[2] = (baud >> 16) & 0xff;
349 buf[3] = (baud >> 24) & 0xff;
350 }
351
352 /* For reference buf[4]=0 is 1 stop bits */
353 /* For reference buf[4]=1 is 1.5 stop bits */
354 /* For reference buf[4]=2 is 2 stop bits */
355 if (cflag & CSTOPB) {
356 /* NOTE: Comply with "real" UARTs / RS232:
357 * use 1.5 instead of 2 stop bits with 5 data bits
358 */
359 if ((cflag & CSIZE) == CS5) {
360 buf[4] = 1;
361 dbg("%s - stop bits = 1.5", __func__);
362 } else {
363 buf[4] = 2;
364 dbg("%s - stop bits = 2", __func__);
365 }
366 } else {
367 buf[4] = 0;
368 dbg("%s - stop bits = 1", __func__);
369 }
370
371 if (cflag & PARENB) {
372 /* For reference buf[5]=0 is none parity */
373 /* For reference buf[5]=1 is odd parity */
374 /* For reference buf[5]=2 is even parity */
375 /* For reference buf[5]=3 is mark parity */
376 /* For reference buf[5]=4 is space parity */
377 if (cflag & PARODD) {
378 if (cflag & CMSPAR) {
379 buf[5] = 3;
380 dbg("%s - parity = mark", __func__);
381 } else {
382 buf[5] = 1;
383 dbg("%s - parity = odd", __func__);
384 }
385 } else {
386 if (cflag & CMSPAR) {
387 buf[5] = 4;
388 dbg("%s - parity = space", __func__);
389 } else {
390 buf[5] = 2;
391 dbg("%s - parity = even", __func__);
392 }
393 }
394 } else {
395 buf[5] = 0;
396 dbg("%s - parity = none", __func__);
397 }
398
399 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
400 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
401 0, 0, buf, 7, 100);
402 dbg("0x21:0x20:0:0 %d", i);
403
404 /* change control lines if we are switching to or from B0 */
405 spin_lock_irqsave(&priv->lock, flags);
406 control = priv->line_control;
407 if ((cflag & CBAUD) == B0)
408 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
409 else
410 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
411 if (control != priv->line_control) {
412 control = priv->line_control;
413 spin_unlock_irqrestore(&priv->lock, flags);
414 set_control_lines(serial->dev, control);
415 } else {
416 spin_unlock_irqrestore(&priv->lock, flags);
417 }
418
419 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
420
421 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
422 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
423 0, 0, buf, 7, 100);
424 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
425 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
426
427 if (cflag & CRTSCTS) {
428 if (priv->type == HX)
429 pl2303_vendor_write(0x0, 0x61, serial);
430 else
431 pl2303_vendor_write(0x0, 0x41, serial);
432 } else {
433 pl2303_vendor_write(0x0, 0x0, serial);
434 }
435
436 /* Save resulting baud rate */
437 if (baud)
438 tty_encode_baud_rate(tty, baud, baud);
439
440 kfree(buf);
441 }
442
443 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
444 {
445 struct pl2303_private *priv = usb_get_serial_port_data(port);
446 unsigned long flags;
447 u8 control;
448
449 spin_lock_irqsave(&priv->lock, flags);
450 /* Change DTR and RTS */
451 if (on)
452 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
453 else
454 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
455 control = priv->line_control;
456 spin_unlock_irqrestore(&priv->lock, flags);
457 set_control_lines(port->serial->dev, control);
458 }
459
460 static void pl2303_close(struct usb_serial_port *port)
461 {
462 dbg("%s - port %d", __func__, port->number);
463
464 usb_serial_generic_close(port);
465 usb_kill_urb(port->interrupt_in_urb);
466 }
467
468 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
469 {
470 struct ktermios tmp_termios;
471 struct usb_serial *serial = port->serial;
472 struct pl2303_private *priv = usb_get_serial_port_data(port);
473 int result;
474
475 dbg("%s - port %d", __func__, port->number);
476
477 if (priv->type != HX) {
478 usb_clear_halt(serial->dev, port->write_urb->pipe);
479 usb_clear_halt(serial->dev, port->read_urb->pipe);
480 } else {
481 /* reset upstream data pipes */
482 pl2303_vendor_write(8, 0, serial);
483 pl2303_vendor_write(9, 0, serial);
484 }
485
486 /* Setup termios */
487 if (tty)
488 pl2303_set_termios(tty, port, &tmp_termios);
489
490 dbg("%s - submitting read urb", __func__);
491 result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
492 if (result) {
493 pl2303_close(port);
494 return -EPROTO;
495 }
496
497 dbg("%s - submitting interrupt urb", __func__);
498 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
499 if (result) {
500 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
501 " error %d\n", __func__, result);
502 pl2303_close(port);
503 return -EPROTO;
504 }
505 port->port.drain_delay = 256;
506 return 0;
507 }
508
509 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
510 unsigned int set, unsigned int clear)
511 {
512 struct usb_serial_port *port = tty->driver_data;
513 struct pl2303_private *priv = usb_get_serial_port_data(port);
514 unsigned long flags;
515 u8 control;
516
517 if (!usb_get_intfdata(port->serial->interface))
518 return -ENODEV;
519
520 spin_lock_irqsave(&priv->lock, flags);
521 if (set & TIOCM_RTS)
522 priv->line_control |= CONTROL_RTS;
523 if (set & TIOCM_DTR)
524 priv->line_control |= CONTROL_DTR;
525 if (clear & TIOCM_RTS)
526 priv->line_control &= ~CONTROL_RTS;
527 if (clear & TIOCM_DTR)
528 priv->line_control &= ~CONTROL_DTR;
529 control = priv->line_control;
530 spin_unlock_irqrestore(&priv->lock, flags);
531
532 return set_control_lines(port->serial->dev, control);
533 }
534
535 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
536 {
537 struct usb_serial_port *port = tty->driver_data;
538 struct pl2303_private *priv = usb_get_serial_port_data(port);
539 unsigned long flags;
540 unsigned int mcr;
541 unsigned int status;
542 unsigned int result;
543
544 dbg("%s (%d)", __func__, port->number);
545
546 if (!usb_get_intfdata(port->serial->interface))
547 return -ENODEV;
548
549 spin_lock_irqsave(&priv->lock, flags);
550 mcr = priv->line_control;
551 status = priv->line_status;
552 spin_unlock_irqrestore(&priv->lock, flags);
553
554 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
555 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
556 | ((status & UART_CTS) ? TIOCM_CTS : 0)
557 | ((status & UART_DSR) ? TIOCM_DSR : 0)
558 | ((status & UART_RING) ? TIOCM_RI : 0)
559 | ((status & UART_DCD) ? TIOCM_CD : 0);
560
561 dbg("%s - result = %x", __func__, result);
562
563 return result;
564 }
565
566 static int pl2303_carrier_raised(struct usb_serial_port *port)
567 {
568 struct pl2303_private *priv = usb_get_serial_port_data(port);
569 if (priv->line_status & UART_DCD)
570 return 1;
571 return 0;
572 }
573
574 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
575 {
576 struct pl2303_private *priv = usb_get_serial_port_data(port);
577 unsigned long flags;
578 unsigned int prevstatus;
579 unsigned int status;
580 unsigned int changed;
581
582 spin_lock_irqsave(&priv->lock, flags);
583 prevstatus = priv->line_status;
584 spin_unlock_irqrestore(&priv->lock, flags);
585
586 while (1) {
587 interruptible_sleep_on(&priv->delta_msr_wait);
588 /* see if a signal did it */
589 if (signal_pending(current))
590 return -ERESTARTSYS;
591
592 spin_lock_irqsave(&priv->lock, flags);
593 status = priv->line_status;
594 spin_unlock_irqrestore(&priv->lock, flags);
595
596 changed = prevstatus ^ status;
597
598 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
599 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
600 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
601 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
602 return 0;
603 }
604 prevstatus = status;
605 }
606 /* NOTREACHED */
607 return 0;
608 }
609
610 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
611 unsigned int cmd, unsigned long arg)
612 {
613 struct serial_struct ser;
614 struct usb_serial_port *port = tty->driver_data;
615 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
616
617 switch (cmd) {
618 case TIOCGSERIAL:
619 memset(&ser, 0, sizeof ser);
620 ser.type = PORT_16654;
621 ser.line = port->serial->minor;
622 ser.port = port->number;
623 ser.baud_base = 460800;
624
625 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
626 return -EFAULT;
627
628 return 0;
629
630 case TIOCMIWAIT:
631 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
632 return wait_modem_info(port, arg);
633 default:
634 dbg("%s not supported = 0x%04x", __func__, cmd);
635 break;
636 }
637 return -ENOIOCTLCMD;
638 }
639
640 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
641 {
642 struct usb_serial_port *port = tty->driver_data;
643 struct usb_serial *serial = port->serial;
644 u16 state;
645 int result;
646
647 dbg("%s - port %d", __func__, port->number);
648
649 if (break_state == 0)
650 state = BREAK_OFF;
651 else
652 state = BREAK_ON;
653 dbg("%s - turning break %s", __func__,
654 state == BREAK_OFF ? "off" : "on");
655
656 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
657 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
658 0, NULL, 0, 100);
659 if (result)
660 dbg("%s - error sending break = %d", __func__, result);
661 }
662
663 static void pl2303_release(struct usb_serial *serial)
664 {
665 int i;
666 struct pl2303_private *priv;
667
668 dbg("%s", __func__);
669
670 for (i = 0; i < serial->num_ports; ++i) {
671 priv = usb_get_serial_port_data(serial->port[i]);
672 kfree(priv);
673 }
674 }
675
676 static void pl2303_update_line_status(struct usb_serial_port *port,
677 unsigned char *data,
678 unsigned int actual_length)
679 {
680
681 struct pl2303_private *priv = usb_get_serial_port_data(port);
682 struct tty_struct *tty;
683 unsigned long flags;
684 u8 status_idx = UART_STATE;
685 u8 length = UART_STATE + 1;
686 u8 prev_line_status;
687 u16 idv, idp;
688
689 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
690 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
691
692
693 if (idv == SIEMENS_VENDOR_ID) {
694 if (idp == SIEMENS_PRODUCT_ID_X65 ||
695 idp == SIEMENS_PRODUCT_ID_SX1 ||
696 idp == SIEMENS_PRODUCT_ID_X75) {
697
698 length = 1;
699 status_idx = 0;
700 }
701 }
702
703 if (actual_length < length)
704 return;
705
706 /* Save off the uart status for others to look at */
707 spin_lock_irqsave(&priv->lock, flags);
708 prev_line_status = priv->line_status;
709 priv->line_status = data[status_idx];
710 spin_unlock_irqrestore(&priv->lock, flags);
711 if (priv->line_status & UART_BREAK_ERROR)
712 usb_serial_handle_break(port);
713 wake_up_interruptible(&priv->delta_msr_wait);
714
715 tty = tty_port_tty_get(&port->port);
716 if (!tty)
717 return;
718 if ((priv->line_status ^ prev_line_status) & UART_DCD)
719 usb_serial_handle_dcd_change(port, tty,
720 priv->line_status & UART_DCD);
721 tty_kref_put(tty);
722 }
723
724 static void pl2303_read_int_callback(struct urb *urb)
725 {
726 struct usb_serial_port *port = urb->context;
727 unsigned char *data = urb->transfer_buffer;
728 unsigned int actual_length = urb->actual_length;
729 int status = urb->status;
730 int retval;
731
732 dbg("%s (%d)", __func__, port->number);
733
734 switch (status) {
735 case 0:
736 /* success */
737 break;
738 case -ECONNRESET:
739 case -ENOENT:
740 case -ESHUTDOWN:
741 /* this urb is terminated, clean up */
742 dbg("%s - urb shutting down with status: %d", __func__,
743 status);
744 return;
745 default:
746 dbg("%s - nonzero urb status received: %d", __func__,
747 status);
748 goto exit;
749 }
750
751 usb_serial_debug_data(debug, &port->dev, __func__,
752 urb->actual_length, urb->transfer_buffer);
753
754 pl2303_update_line_status(port, data, actual_length);
755
756 exit:
757 retval = usb_submit_urb(urb, GFP_ATOMIC);
758 if (retval)
759 dev_err(&urb->dev->dev,
760 "%s - usb_submit_urb failed with result %d\n",
761 __func__, retval);
762 }
763
764 static void pl2303_process_read_urb(struct urb *urb)
765 {
766 struct usb_serial_port *port = urb->context;
767 struct pl2303_private *priv = usb_get_serial_port_data(port);
768 struct tty_struct *tty;
769 unsigned char *data = urb->transfer_buffer;
770 char tty_flag = TTY_NORMAL;
771 unsigned long flags;
772 u8 line_status;
773 int i;
774
775 /* update line status */
776 spin_lock_irqsave(&priv->lock, flags);
777 line_status = priv->line_status;
778 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
779 spin_unlock_irqrestore(&priv->lock, flags);
780 wake_up_interruptible(&priv->delta_msr_wait);
781
782 if (!urb->actual_length)
783 return;
784
785 tty = tty_port_tty_get(&port->port);
786 if (!tty)
787 return;
788
789 /* break takes precedence over parity, */
790 /* which takes precedence over framing errors */
791 if (line_status & UART_BREAK_ERROR)
792 tty_flag = TTY_BREAK;
793 else if (line_status & UART_PARITY_ERROR)
794 tty_flag = TTY_PARITY;
795 else if (line_status & UART_FRAME_ERROR)
796 tty_flag = TTY_FRAME;
797 dbg("%s - tty_flag = %d", __func__, tty_flag);
798
799 /* overrun is special, not associated with a char */
800 if (line_status & UART_OVERRUN_ERROR)
801 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
802
803 if (port->port.console && port->sysrq) {
804 for (i = 0; i < urb->actual_length; ++i)
805 if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
806 tty_insert_flip_char(tty, data[i], tty_flag);
807 } else {
808 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
809 urb->actual_length);
810 }
811
812 tty_flip_buffer_push(tty);
813 tty_kref_put(tty);
814 }
815
816 /* All of the device info needed for the PL2303 SIO serial converter */
817 static struct usb_serial_driver pl2303_device = {
818 .driver = {
819 .owner = THIS_MODULE,
820 .name = "pl2303",
821 },
822 .id_table = id_table,
823 .usb_driver = &pl2303_driver,
824 .num_ports = 1,
825 .bulk_in_size = 256,
826 .bulk_out_size = 256,
827 .open = pl2303_open,
828 .close = pl2303_close,
829 .dtr_rts = pl2303_dtr_rts,
830 .carrier_raised = pl2303_carrier_raised,
831 .ioctl = pl2303_ioctl,
832 .break_ctl = pl2303_break_ctl,
833 .set_termios = pl2303_set_termios,
834 .tiocmget = pl2303_tiocmget,
835 .tiocmset = pl2303_tiocmset,
836 .process_read_urb = pl2303_process_read_urb,
837 .read_int_callback = pl2303_read_int_callback,
838 .attach = pl2303_startup,
839 .release = pl2303_release,
840 };
841
842 static int __init pl2303_init(void)
843 {
844 int retval;
845
846 retval = usb_serial_register(&pl2303_device);
847 if (retval)
848 goto failed_usb_serial_register;
849 retval = usb_register(&pl2303_driver);
850 if (retval)
851 goto failed_usb_register;
852 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
853 return 0;
854 failed_usb_register:
855 usb_serial_deregister(&pl2303_device);
856 failed_usb_serial_register:
857 return retval;
858 }
859
860 static void __exit pl2303_exit(void)
861 {
862 usb_deregister(&pl2303_driver);
863 usb_serial_deregister(&pl2303_device);
864 }
865
866 module_init(pl2303_init);
867 module_exit(pl2303_exit);
868
869 MODULE_DESCRIPTION(DRIVER_DESC);
870 MODULE_LICENSE("GPL");
871
872 module_param(debug, bool, S_IRUGO | S_IWUSR);
873 MODULE_PARM_DESC(debug, "Debug enabled or not");
874
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree