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