projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
module_param: make bool parameters really bool (drivers & misc)
[deliverable/linux.git] / drivers / usb / serial / pl2303.c
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 #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(SMART_VENDOR_ID, SMART_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 interrupt urb", __func__);
506 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
507 if (result) {
508 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
509 " error %d\n", __func__, result);
510 return result;
511 }
512
513 result = usb_serial_generic_open(tty, port);
514 if (result) {
515 usb_kill_urb(port->interrupt_in_urb);
516 return result;
517 }
518
519 port->port.drain_delay = 256;
520 return 0;
521 }
522
523 static int pl2303_tiocmset(struct tty_struct *tty,
524 unsigned int set, unsigned int clear)
525 {
526 struct usb_serial_port *port = tty->driver_data;
527 struct pl2303_private *priv = usb_get_serial_port_data(port);
528 unsigned long flags;
529 u8 control;
530
531 if (!usb_get_intfdata(port->serial->interface))
532 return -ENODEV;
533
534 spin_lock_irqsave(&priv->lock, flags);
535 if (set & TIOCM_RTS)
536 priv->line_control |= CONTROL_RTS;
537 if (set & TIOCM_DTR)
538 priv->line_control |= CONTROL_DTR;
539 if (clear & TIOCM_RTS)
540 priv->line_control &= ~CONTROL_RTS;
541 if (clear & TIOCM_DTR)
542 priv->line_control &= ~CONTROL_DTR;
543 control = priv->line_control;
544 spin_unlock_irqrestore(&priv->lock, flags);
545
546 return set_control_lines(port->serial->dev, control);
547 }
548
549 static int pl2303_tiocmget(struct tty_struct *tty)
550 {
551 struct usb_serial_port *port = tty->driver_data;
552 struct pl2303_private *priv = usb_get_serial_port_data(port);
553 unsigned long flags;
554 unsigned int mcr;
555 unsigned int status;
556 unsigned int result;
557
558 dbg("%s (%d)", __func__, port->number);
559
560 if (!usb_get_intfdata(port->serial->interface))
561 return -ENODEV;
562
563 spin_lock_irqsave(&priv->lock, flags);
564 mcr = priv->line_control;
565 status = priv->line_status;
566 spin_unlock_irqrestore(&priv->lock, flags);
567
568 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
569 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
570 | ((status & UART_CTS) ? TIOCM_CTS : 0)
571 | ((status & UART_DSR) ? TIOCM_DSR : 0)
572 | ((status & UART_RING) ? TIOCM_RI : 0)
573 | ((status & UART_DCD) ? TIOCM_CD : 0);
574
575 dbg("%s - result = %x", __func__, result);
576
577 return result;
578 }
579
580 static int pl2303_carrier_raised(struct usb_serial_port *port)
581 {
582 struct pl2303_private *priv = usb_get_serial_port_data(port);
583 if (priv->line_status & UART_DCD)
584 return 1;
585 return 0;
586 }
587
588 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
589 {
590 struct pl2303_private *priv = usb_get_serial_port_data(port);
591 unsigned long flags;
592 unsigned int prevstatus;
593 unsigned int status;
594 unsigned int changed;
595
596 spin_lock_irqsave(&priv->lock, flags);
597 prevstatus = priv->line_status;
598 spin_unlock_irqrestore(&priv->lock, flags);
599
600 while (1) {
601 interruptible_sleep_on(&priv->delta_msr_wait);
602 /* see if a signal did it */
603 if (signal_pending(current))
604 return -ERESTARTSYS;
605
606 spin_lock_irqsave(&priv->lock, flags);
607 status = priv->line_status;
608 spin_unlock_irqrestore(&priv->lock, flags);
609
610 changed = prevstatus ^ status;
611
612 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
613 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
614 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
615 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
616 return 0;
617 }
618 prevstatus = status;
619 }
620 /* NOTREACHED */
621 return 0;
622 }
623
624 static int pl2303_ioctl(struct tty_struct *tty,
625 unsigned int cmd, unsigned long arg)
626 {
627 struct serial_struct ser;
628 struct usb_serial_port *port = tty->driver_data;
629 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
630
631 switch (cmd) {
632 case TIOCGSERIAL:
633 memset(&ser, 0, sizeof ser);
634 ser.type = PORT_16654;
635 ser.line = port->serial->minor;
636 ser.port = port->number;
637 ser.baud_base = 460800;
638
639 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
640 return -EFAULT;
641
642 return 0;
643
644 case TIOCMIWAIT:
645 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
646 return wait_modem_info(port, arg);
647 default:
648 dbg("%s not supported = 0x%04x", __func__, cmd);
649 break;
650 }
651 return -ENOIOCTLCMD;
652 }
653
654 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
655 {
656 struct usb_serial_port *port = tty->driver_data;
657 struct usb_serial *serial = port->serial;
658 u16 state;
659 int result;
660
661 dbg("%s - port %d", __func__, port->number);
662
663 if (break_state == 0)
664 state = BREAK_OFF;
665 else
666 state = BREAK_ON;
667 dbg("%s - turning break %s", __func__,
668 state == BREAK_OFF ? "off" : "on");
669
670 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
671 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
672 0, NULL, 0, 100);
673 if (result)
674 dbg("%s - error sending break = %d", __func__, result);
675 }
676
677 static void pl2303_release(struct usb_serial *serial)
678 {
679 int i;
680 struct pl2303_private *priv;
681
682 dbg("%s", __func__);
683
684 for (i = 0; i < serial->num_ports; ++i) {
685 priv = usb_get_serial_port_data(serial->port[i]);
686 kfree(priv);
687 }
688 }
689
690 static void pl2303_update_line_status(struct usb_serial_port *port,
691 unsigned char *data,
692 unsigned int actual_length)
693 {
694
695 struct pl2303_private *priv = usb_get_serial_port_data(port);
696 struct tty_struct *tty;
697 unsigned long flags;
698 u8 status_idx = UART_STATE;
699 u8 length = UART_STATE + 1;
700 u8 prev_line_status;
701 u16 idv, idp;
702
703 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
704 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
705
706
707 if (idv == SIEMENS_VENDOR_ID) {
708 if (idp == SIEMENS_PRODUCT_ID_X65 ||
709 idp == SIEMENS_PRODUCT_ID_SX1 ||
710 idp == SIEMENS_PRODUCT_ID_X75) {
711
712 length = 1;
713 status_idx = 0;
714 }
715 }
716
717 if (actual_length < length)
718 return;
719
720 /* Save off the uart status for others to look at */
721 spin_lock_irqsave(&priv->lock, flags);
722 prev_line_status = priv->line_status;
723 priv->line_status = data[status_idx];
724 spin_unlock_irqrestore(&priv->lock, flags);
725 if (priv->line_status & UART_BREAK_ERROR)
726 usb_serial_handle_break(port);
727 wake_up_interruptible(&priv->delta_msr_wait);
728
729 tty = tty_port_tty_get(&port->port);
730 if (!tty)
731 return;
732 if ((priv->line_status ^ prev_line_status) & UART_DCD)
733 usb_serial_handle_dcd_change(port, tty,
734 priv->line_status & UART_DCD);
735 tty_kref_put(tty);
736 }
737
738 static void pl2303_read_int_callback(struct urb *urb)
739 {
740 struct usb_serial_port *port = urb->context;
741 unsigned char *data = urb->transfer_buffer;
742 unsigned int actual_length = urb->actual_length;
743 int status = urb->status;
744 int retval;
745
746 dbg("%s (%d)", __func__, port->number);
747
748 switch (status) {
749 case 0:
750 /* success */
751 break;
752 case -ECONNRESET:
753 case -ENOENT:
754 case -ESHUTDOWN:
755 /* this urb is terminated, clean up */
756 dbg("%s - urb shutting down with status: %d", __func__,
757 status);
758 return;
759 default:
760 dbg("%s - nonzero urb status received: %d", __func__,
761 status);
762 goto exit;
763 }
764
765 usb_serial_debug_data(debug, &port->dev, __func__,
766 urb->actual_length, urb->transfer_buffer);
767
768 pl2303_update_line_status(port, data, actual_length);
769
770 exit:
771 retval = usb_submit_urb(urb, GFP_ATOMIC);
772 if (retval)
773 dev_err(&urb->dev->dev,
774 "%s - usb_submit_urb failed with result %d\n",
775 __func__, retval);
776 }
777
778 static void pl2303_process_read_urb(struct urb *urb)
779 {
780 struct usb_serial_port *port = urb->context;
781 struct pl2303_private *priv = usb_get_serial_port_data(port);
782 struct tty_struct *tty;
783 unsigned char *data = urb->transfer_buffer;
784 char tty_flag = TTY_NORMAL;
785 unsigned long flags;
786 u8 line_status;
787 int i;
788
789 /* update line status */
790 spin_lock_irqsave(&priv->lock, flags);
791 line_status = priv->line_status;
792 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
793 spin_unlock_irqrestore(&priv->lock, flags);
794 wake_up_interruptible(&priv->delta_msr_wait);
795
796 if (!urb->actual_length)
797 return;
798
799 tty = tty_port_tty_get(&port->port);
800 if (!tty)
801 return;
802
803 /* break takes precedence over parity, */
804 /* which takes precedence over framing errors */
805 if (line_status & UART_BREAK_ERROR)
806 tty_flag = TTY_BREAK;
807 else if (line_status & UART_PARITY_ERROR)
808 tty_flag = TTY_PARITY;
809 else if (line_status & UART_FRAME_ERROR)
810 tty_flag = TTY_FRAME;
811 dbg("%s - tty_flag = %d", __func__, tty_flag);
812
813 /* overrun is special, not associated with a char */
814 if (line_status & UART_OVERRUN_ERROR)
815 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
816
817 if (port->port.console && port->sysrq) {
818 for (i = 0; i < urb->actual_length; ++i)
819 if (!usb_serial_handle_sysrq_char(port, data[i]))
820 tty_insert_flip_char(tty, data[i], tty_flag);
821 } else {
822 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
823 urb->actual_length);
824 }
825
826 tty_flip_buffer_push(tty);
827 tty_kref_put(tty);
828 }
829
830 /* All of the device info needed for the PL2303 SIO serial converter */
831 static struct usb_serial_driver pl2303_device = {
832 .driver = {
833 .owner = THIS_MODULE,
834 .name = "pl2303",
835 },
836 .id_table = id_table,
837 .usb_driver = &pl2303_driver,
838 .num_ports = 1,
839 .bulk_in_size = 256,
840 .bulk_out_size = 256,
841 .open = pl2303_open,
842 .close = pl2303_close,
843 .dtr_rts = pl2303_dtr_rts,
844 .carrier_raised = pl2303_carrier_raised,
845 .ioctl = pl2303_ioctl,
846 .break_ctl = pl2303_break_ctl,
847 .set_termios = pl2303_set_termios,
848 .tiocmget = pl2303_tiocmget,
849 .tiocmset = pl2303_tiocmset,
850 .process_read_urb = pl2303_process_read_urb,
851 .read_int_callback = pl2303_read_int_callback,
852 .attach = pl2303_startup,
853 .release = pl2303_release,
854 };
855
856 static int __init pl2303_init(void)
857 {
858 int retval;
859
860 retval = usb_serial_register(&pl2303_device);
861 if (retval)
862 goto failed_usb_serial_register;
863 retval = usb_register(&pl2303_driver);
864 if (retval)
865 goto failed_usb_register;
866 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
867 return 0;
868 failed_usb_register:
869 usb_serial_deregister(&pl2303_device);
870 failed_usb_serial_register:
871 return retval;
872 }
873
874 static void __exit pl2303_exit(void)
875 {
876 usb_deregister(&pl2303_driver);
877 usb_serial_deregister(&pl2303_device);
878 }
879
880 module_init(pl2303_init);
881 module_exit(pl2303_exit);
882
883 MODULE_DESCRIPTION(DRIVER_DESC);
884 MODULE_LICENSE("GPL");
885
886 module_param(debug, bool, S_IRUGO | S_IWUSR);
887 MODULE_PARM_DESC(debug, "Debug enabled or not");
888
Linux kernel - Deliverables
This page took 0.04942 seconds and 5 git commands to generate.