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