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