projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


a975bb80303f9ddad9b6ef62394a1d2889fcbf5a
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / usb / serial / mct_u232.c
1 /*
2 * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
3 *
4 * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is largely derived from the Belkin USB Serial Adapter Driver
12 * (see belkin_sa.[ch]). All of the information about the device was acquired
13 * by using SniffUSB on Windows98. For technical details see mct_u232.h.
14 *
15 * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
16 * do the reverse engineering and how to write a USB serial device driver.
17 *
18 * TO BE DONE, TO BE CHECKED:
19 * DTR/RTS signal handling may be incomplete or incorrect. I have mainly
20 * implemented what I have seen with SniffUSB or found in belkin_sa.c.
21 * For further TODOs check also belkin_sa.c.
22 */
23
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/tty.h>
29 #include <linux/tty_driver.h>
30 #include <linux/tty_flip.h>
31 #include <linux/module.h>
32 #include <linux/spinlock.h>
33 #include <linux/uaccess.h>
34 #include <asm/unaligned.h>
35 #include <linux/usb.h>
36 #include <linux/usb/serial.h>
37 #include <linux/serial.h>
38 #include <linux/ioctl.h>
39 #include "mct_u232.h"
40
41 /*
42 * Version Information
43 */
44 #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */
45 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
46 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
47
48 static int debug;
49
50 /*
51 * Function prototypes
52 */
53 static int mct_u232_startup(struct usb_serial *serial);
54 static void mct_u232_release(struct usb_serial *serial);
55 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
56 static void mct_u232_close(struct usb_serial_port *port);
57 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
58 static void mct_u232_read_int_callback(struct urb *urb);
59 static void mct_u232_set_termios(struct tty_struct *tty,
60 struct usb_serial_port *port, struct ktermios *old);
61 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
62 static int mct_u232_tiocmget(struct tty_struct *tty);
63 static int mct_u232_tiocmset(struct tty_struct *tty,
64 unsigned int set, unsigned int clear);
65 static int mct_u232_ioctl(struct tty_struct *tty,
66 unsigned int cmd, unsigned long arg);
67 static int mct_u232_get_icount(struct tty_struct *tty,
68 struct serial_icounter_struct *icount);
69 static void mct_u232_throttle(struct tty_struct *tty);
70 static void mct_u232_unthrottle(struct tty_struct *tty);
71
72
73 /*
74 * All of the device info needed for the MCT USB-RS232 converter.
75 */
76 static const struct usb_device_id id_table_combined[] = {
77 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
78 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
79 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
80 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
81 { } /* Terminating entry */
82 };
83
84 MODULE_DEVICE_TABLE(usb, id_table_combined);
85
86 static struct usb_driver mct_u232_driver = {
87 .name = "mct_u232",
88 .probe = usb_serial_probe,
89 .disconnect = usb_serial_disconnect,
90 .id_table = id_table_combined,
91 .no_dynamic_id = 1,
92 };
93
94 static struct usb_serial_driver mct_u232_device = {
95 .driver = {
96 .owner = THIS_MODULE,
97 .name = "mct_u232",
98 },
99 .description = "MCT U232",
100 .usb_driver = &mct_u232_driver,
101 .id_table = id_table_combined,
102 .num_ports = 1,
103 .open = mct_u232_open,
104 .close = mct_u232_close,
105 .dtr_rts = mct_u232_dtr_rts,
106 .throttle = mct_u232_throttle,
107 .unthrottle = mct_u232_unthrottle,
108 .read_int_callback = mct_u232_read_int_callback,
109 .set_termios = mct_u232_set_termios,
110 .break_ctl = mct_u232_break_ctl,
111 .tiocmget = mct_u232_tiocmget,
112 .tiocmset = mct_u232_tiocmset,
113 .attach = mct_u232_startup,
114 .release = mct_u232_release,
115 .ioctl = mct_u232_ioctl,
116 .get_icount = mct_u232_get_icount,
117 };
118
119 struct mct_u232_private {
120 spinlock_t lock;
121 unsigned int control_state; /* Modem Line Setting (TIOCM) */
122 unsigned char last_lcr; /* Line Control Register */
123 unsigned char last_lsr; /* Line Status Register */
124 unsigned char last_msr; /* Modem Status Register */
125 unsigned int rx_flags; /* Throttling flags */
126 struct async_icount icount;
127 wait_queue_head_t msr_wait; /* for handling sleeping while waiting
128 for msr change to happen */
129 };
130
131 #define THROTTLED 0x01
132
133 /*
134 * Handle vendor specific USB requests
135 */
136
137 #define WDR_TIMEOUT 5000 /* default urb timeout */
138
139 /*
140 * Later day 2.6.0-test kernels have new baud rates like B230400 which
141 * we do not know how to support. We ignore them for the moment.
142 */
143 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
144 speed_t value, speed_t *result)
145 {
146 *result = value;
147
148 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
149 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
150 switch (value) {
151 case 300:
152 return 0x01;
153 case 600:
154 return 0x02; /* this one not tested */
155 case 1200:
156 return 0x03;
157 case 2400:
158 return 0x04;
159 case 4800:
160 return 0x06;
161 case 9600:
162 return 0x08;
163 case 19200:
164 return 0x09;
165 case 38400:
166 return 0x0a;
167 case 57600:
168 return 0x0b;
169 case 115200:
170 return 0x0c;
171 default:
172 *result = 9600;
173 return 0x08;
174 }
175 } else {
176 /* FIXME: Can we use any divider - should we do
177 divider = 115200/value;
178 real baud = 115200/divider */
179 switch (value) {
180 case 300: break;
181 case 600: break;
182 case 1200: break;
183 case 2400: break;
184 case 4800: break;
185 case 9600: break;
186 case 19200: break;
187 case 38400: break;
188 case 57600: break;
189 case 115200: break;
190 default:
191 value = 9600;
192 *result = 9600;
193 }
194 return 115200/value;
195 }
196 }
197
198 static int mct_u232_set_baud_rate(struct tty_struct *tty,
199 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
200 {
201 unsigned int divisor;
202 int rc;
203 unsigned char *buf;
204 unsigned char cts_enable_byte = 0;
205 speed_t speed;
206
207 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
208 if (buf == NULL)
209 return -ENOMEM;
210
211 divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
212 put_unaligned_le32(cpu_to_le32(divisor), buf);
213 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
214 MCT_U232_SET_BAUD_RATE_REQUEST,
215 MCT_U232_SET_REQUEST_TYPE,
216 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
217 WDR_TIMEOUT);
218 if (rc < 0) /*FIXME: What value speed results */
219 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
220 value, rc);
221 else
222 tty_encode_baud_rate(tty, speed, speed);
223 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
224
225 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
226 always sends two extra USB 'device request' messages after the
227 'baud rate change' message. The actual functionality of the
228 request codes in these messages is not fully understood but these
229 particular codes are never seen in any operation besides a baud
230 rate change. Both of these messages send a single byte of data.
231 In the first message, the value of this byte is always zero.
232
233 The second message has been determined experimentally to control
234 whether data will be transmitted to a device which is not asserting
235 the 'CTS' signal. If the second message's data byte is zero, data
236 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
237 flow control). if the second message's data byte is nonzero (a
238 value of 1 is used by this driver), data will not be transmitted to
239 a device which is not asserting 'CTS'.
240 */
241
242 buf[0] = 0;
243 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
244 MCT_U232_SET_UNKNOWN1_REQUEST,
245 MCT_U232_SET_REQUEST_TYPE,
246 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
247 WDR_TIMEOUT);
248 if (rc < 0)
249 dev_err(&port->dev, "Sending USB device request code %d "
250 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
251 rc);
252
253 if (port && C_CRTSCTS(tty))
254 cts_enable_byte = 1;
255
256 dbg("set_baud_rate: send second control message, data = %02X",
257 cts_enable_byte);
258 buf[0] = cts_enable_byte;
259 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
260 MCT_U232_SET_CTS_REQUEST,
261 MCT_U232_SET_REQUEST_TYPE,
262 0, 0, buf, MCT_U232_SET_CTS_SIZE,
263 WDR_TIMEOUT);
264 if (rc < 0)
265 dev_err(&port->dev, "Sending USB device request code %d "
266 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
267
268 kfree(buf);
269 return rc;
270 } /* mct_u232_set_baud_rate */
271
272 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
273 {
274 int rc;
275 unsigned char *buf;
276
277 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
278 if (buf == NULL)
279 return -ENOMEM;
280
281 buf[0] = lcr;
282 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
283 MCT_U232_SET_LINE_CTRL_REQUEST,
284 MCT_U232_SET_REQUEST_TYPE,
285 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
286 WDR_TIMEOUT);
287 if (rc < 0)
288 dev_err(&serial->dev->dev,
289 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
290 dbg("set_line_ctrl: 0x%x", lcr);
291 kfree(buf);
292 return rc;
293 } /* mct_u232_set_line_ctrl */
294
295 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
296 unsigned int control_state)
297 {
298 int rc;
299 unsigned char mcr;
300 unsigned char *buf;
301
302 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
303 if (buf == NULL)
304 return -ENOMEM;
305
306 mcr = MCT_U232_MCR_NONE;
307 if (control_state & TIOCM_DTR)
308 mcr |= MCT_U232_MCR_DTR;
309 if (control_state & TIOCM_RTS)
310 mcr |= MCT_U232_MCR_RTS;
311
312 buf[0] = mcr;
313 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
314 MCT_U232_SET_MODEM_CTRL_REQUEST,
315 MCT_U232_SET_REQUEST_TYPE,
316 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
317 WDR_TIMEOUT);
318 if (rc < 0)
319 dev_err(&serial->dev->dev,
320 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
321 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
322
323 kfree(buf);
324 return rc;
325 } /* mct_u232_set_modem_ctrl */
326
327 static int mct_u232_get_modem_stat(struct usb_serial *serial,
328 unsigned char *msr)
329 {
330 int rc;
331 unsigned char *buf;
332
333 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
334 if (buf == NULL) {
335 *msr = 0;
336 return -ENOMEM;
337 }
338 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
339 MCT_U232_GET_MODEM_STAT_REQUEST,
340 MCT_U232_GET_REQUEST_TYPE,
341 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
342 WDR_TIMEOUT);
343 if (rc < 0) {
344 dev_err(&serial->dev->dev,
345 "Get MODEM STATus failed (error = %d)\n", rc);
346 *msr = 0;
347 } else {
348 *msr = buf[0];
349 }
350 dbg("get_modem_stat: 0x%x", *msr);
351 kfree(buf);
352 return rc;
353 } /* mct_u232_get_modem_stat */
354
355 static void mct_u232_msr_to_icount(struct async_icount *icount,
356 unsigned char msr)
357 {
358 /* Translate Control Line states */
359 if (msr & MCT_U232_MSR_DDSR)
360 icount->dsr++;
361 if (msr & MCT_U232_MSR_DCTS)
362 icount->cts++;
363 if (msr & MCT_U232_MSR_DRI)
364 icount->rng++;
365 if (msr & MCT_U232_MSR_DCD)
366 icount->dcd++;
367 } /* mct_u232_msr_to_icount */
368
369 static void mct_u232_msr_to_state(unsigned int *control_state,
370 unsigned char msr)
371 {
372 /* Translate Control Line states */
373 if (msr & MCT_U232_MSR_DSR)
374 *control_state |= TIOCM_DSR;
375 else
376 *control_state &= ~TIOCM_DSR;
377 if (msr & MCT_U232_MSR_CTS)
378 *control_state |= TIOCM_CTS;
379 else
380 *control_state &= ~TIOCM_CTS;
381 if (msr & MCT_U232_MSR_RI)
382 *control_state |= TIOCM_RI;
383 else
384 *control_state &= ~TIOCM_RI;
385 if (msr & MCT_U232_MSR_CD)
386 *control_state |= TIOCM_CD;
387 else
388 *control_state &= ~TIOCM_CD;
389 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
390 } /* mct_u232_msr_to_state */
391
392 /*
393 * Driver's tty interface functions
394 */
395
396 static int mct_u232_startup(struct usb_serial *serial)
397 {
398 struct mct_u232_private *priv;
399 struct usb_serial_port *port, *rport;
400
401 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
402 if (!priv)
403 return -ENOMEM;
404 spin_lock_init(&priv->lock);
405 init_waitqueue_head(&priv->msr_wait);
406 usb_set_serial_port_data(serial->port[0], priv);
407
408 init_waitqueue_head(&serial->port[0]->write_wait);
409
410 /* Puh, that's dirty */
411 port = serial->port[0];
412 rport = serial->port[1];
413 /* No unlinking, it wasn't submitted yet. */
414 usb_free_urb(port->read_urb);
415 port->read_urb = rport->interrupt_in_urb;
416 rport->interrupt_in_urb = NULL;
417 port->read_urb->context = port;
418
419 return 0;
420 } /* mct_u232_startup */
421
422
423 static void mct_u232_release(struct usb_serial *serial)
424 {
425 struct mct_u232_private *priv;
426 int i;
427
428 dbg("%s", __func__);
429
430 for (i = 0; i < serial->num_ports; ++i) {
431 /* My special items, the standard routines free my urbs */
432 priv = usb_get_serial_port_data(serial->port[i]);
433 kfree(priv);
434 }
435 } /* mct_u232_release */
436
437 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
438 {
439 struct usb_serial *serial = port->serial;
440 struct mct_u232_private *priv = usb_get_serial_port_data(port);
441 int retval = 0;
442 unsigned int control_state;
443 unsigned long flags;
444 unsigned char last_lcr;
445 unsigned char last_msr;
446
447 dbg("%s port %d", __func__, port->number);
448
449 /* Compensate for a hardware bug: although the Sitecom U232-P25
450 * device reports a maximum output packet size of 32 bytes,
451 * it seems to be able to accept only 16 bytes (and that's what
452 * SniffUSB says too...)
453 */
454 if (le16_to_cpu(serial->dev->descriptor.idProduct)
455 == MCT_U232_SITECOM_PID)
456 port->bulk_out_size = 16;
457
458 /* Do a defined restart: the normal serial device seems to
459 * always turn on DTR and RTS here, so do the same. I'm not
460 * sure if this is really necessary. But it should not harm
461 * either.
462 */
463 spin_lock_irqsave(&priv->lock, flags);
464 if (tty && (tty->termios->c_cflag & CBAUD))
465 priv->control_state = TIOCM_DTR | TIOCM_RTS;
466 else
467 priv->control_state = 0;
468
469 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
470 MCT_U232_PARITY_NONE |
471 MCT_U232_STOP_BITS_1);
472 control_state = priv->control_state;
473 last_lcr = priv->last_lcr;
474 spin_unlock_irqrestore(&priv->lock, flags);
475 mct_u232_set_modem_ctrl(serial, control_state);
476 mct_u232_set_line_ctrl(serial, last_lcr);
477
478 /* Read modem status and update control state */
479 mct_u232_get_modem_stat(serial, &last_msr);
480 spin_lock_irqsave(&priv->lock, flags);
481 priv->last_msr = last_msr;
482 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
483 spin_unlock_irqrestore(&priv->lock, flags);
484
485 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
486 if (retval) {
487 dev_err(&port->dev,
488 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
489 port->read_urb->pipe, retval);
490 goto error;
491 }
492
493 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
494 if (retval) {
495 usb_kill_urb(port->read_urb);
496 dev_err(&port->dev,
497 "usb_submit_urb(read int) failed pipe 0x%x err %d",
498 port->interrupt_in_urb->pipe, retval);
499 goto error;
500 }
501 return 0;
502
503 error:
504 return retval;
505 } /* mct_u232_open */
506
507 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
508 {
509 unsigned int control_state;
510 struct mct_u232_private *priv = usb_get_serial_port_data(port);
511
512 mutex_lock(&port->serial->disc_mutex);
513 if (!port->serial->disconnected) {
514 /* drop DTR and RTS */
515 spin_lock_irq(&priv->lock);
516 if (on)
517 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
518 else
519 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
520 control_state = priv->control_state;
521 spin_unlock_irq(&priv->lock);
522 mct_u232_set_modem_ctrl(port->serial, control_state);
523 }
524 mutex_unlock(&port->serial->disc_mutex);
525 }
526
527 static void mct_u232_close(struct usb_serial_port *port)
528 {
529 dbg("%s port %d", __func__, port->number);
530
531 if (port->serial->dev) {
532 /* shutdown our urbs */
533 usb_kill_urb(port->write_urb);
534 usb_kill_urb(port->read_urb);
535 usb_kill_urb(port->interrupt_in_urb);
536 }
537 } /* mct_u232_close */
538
539
540 static void mct_u232_read_int_callback(struct urb *urb)
541 {
542 struct usb_serial_port *port = urb->context;
543 struct mct_u232_private *priv = usb_get_serial_port_data(port);
544 struct usb_serial *serial = port->serial;
545 struct tty_struct *tty;
546 unsigned char *data = urb->transfer_buffer;
547 int retval;
548 int status = urb->status;
549 unsigned long flags;
550
551 switch (status) {
552 case 0:
553 /* success */
554 break;
555 case -ECONNRESET:
556 case -ENOENT:
557 case -ESHUTDOWN:
558 /* this urb is terminated, clean up */
559 dbg("%s - urb shutting down with status: %d",
560 __func__, status);
561 return;
562 default:
563 dbg("%s - nonzero urb status received: %d",
564 __func__, status);
565 goto exit;
566 }
567
568 if (!serial) {
569 dbg("%s - bad serial pointer, exiting", __func__);
570 return;
571 }
572
573 dbg("%s - port %d", __func__, port->number);
574 usb_serial_debug_data(debug, &port->dev, __func__,
575 urb->actual_length, data);
576
577 /*
578 * Work-a-round: handle the 'usual' bulk-in pipe here
579 */
580 if (urb->transfer_buffer_length > 2) {
581 if (urb->actual_length) {
582 tty = tty_port_tty_get(&port->port);
583 if (tty) {
584 tty_insert_flip_string(tty, data,
585 urb->actual_length);
586 tty_flip_buffer_push(tty);
587 }
588 tty_kref_put(tty);
589 }
590 goto exit;
591 }
592
593 /*
594 * The interrupt-in pipe signals exceptional conditions (modem line
595 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
596 */
597 spin_lock_irqsave(&priv->lock, flags);
598 priv->last_msr = data[MCT_U232_MSR_INDEX];
599
600 /* Record Control Line states */
601 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
602
603 mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
604
605 #if 0
606 /* Not yet handled. See belkin_sa.c for further information */
607 /* Now to report any errors */
608 priv->last_lsr = data[MCT_U232_LSR_INDEX];
609 /*
610 * fill in the flip buffer here, but I do not know the relation
611 * to the current/next receive buffer or characters. I need
612 * to look in to this before committing any code.
613 */
614 if (priv->last_lsr & MCT_U232_LSR_ERR) {
615 tty = tty_port_tty_get(&port->port);
616 /* Overrun Error */
617 if (priv->last_lsr & MCT_U232_LSR_OE) {
618 }
619 /* Parity Error */
620 if (priv->last_lsr & MCT_U232_LSR_PE) {
621 }
622 /* Framing Error */
623 if (priv->last_lsr & MCT_U232_LSR_FE) {
624 }
625 /* Break Indicator */
626 if (priv->last_lsr & MCT_U232_LSR_BI) {
627 }
628 tty_kref_put(tty);
629 }
630 #endif
631 wake_up_interruptible(&priv->msr_wait);
632 spin_unlock_irqrestore(&priv->lock, flags);
633 exit:
634 retval = usb_submit_urb(urb, GFP_ATOMIC);
635 if (retval)
636 dev_err(&port->dev,
637 "%s - usb_submit_urb failed with result %d\n",
638 __func__, retval);
639 } /* mct_u232_read_int_callback */
640
641 static void mct_u232_set_termios(struct tty_struct *tty,
642 struct usb_serial_port *port,
643 struct ktermios *old_termios)
644 {
645 struct usb_serial *serial = port->serial;
646 struct mct_u232_private *priv = usb_get_serial_port_data(port);
647 struct ktermios *termios = tty->termios;
648 unsigned int cflag = termios->c_cflag;
649 unsigned int old_cflag = old_termios->c_cflag;
650 unsigned long flags;
651 unsigned int control_state;
652 unsigned char last_lcr;
653
654 /* get a local copy of the current port settings */
655 spin_lock_irqsave(&priv->lock, flags);
656 control_state = priv->control_state;
657 spin_unlock_irqrestore(&priv->lock, flags);
658 last_lcr = 0;
659
660 /*
661 * Update baud rate.
662 * Do not attempt to cache old rates and skip settings,
663 * disconnects screw such tricks up completely.
664 * Premature optimization is the root of all evil.
665 */
666
667 /* reassert DTR and RTS on transition from B0 */
668 if ((old_cflag & CBAUD) == B0) {
669 dbg("%s: baud was B0", __func__);
670 control_state |= TIOCM_DTR | TIOCM_RTS;
671 mct_u232_set_modem_ctrl(serial, control_state);
672 }
673
674 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
675
676 if ((cflag & CBAUD) == B0) {
677 dbg("%s: baud is B0", __func__);
678 /* Drop RTS and DTR */
679 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
680 mct_u232_set_modem_ctrl(serial, control_state);
681 }
682
683 /*
684 * Update line control register (LCR)
685 */
686
687 /* set the parity */
688 if (cflag & PARENB)
689 last_lcr |= (cflag & PARODD) ?
690 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
691 else
692 last_lcr |= MCT_U232_PARITY_NONE;
693
694 /* set the number of data bits */
695 switch (cflag & CSIZE) {
696 case CS5:
697 last_lcr |= MCT_U232_DATA_BITS_5; break;
698 case CS6:
699 last_lcr |= MCT_U232_DATA_BITS_6; break;
700 case CS7:
701 last_lcr |= MCT_U232_DATA_BITS_7; break;
702 case CS8:
703 last_lcr |= MCT_U232_DATA_BITS_8; break;
704 default:
705 dev_err(&port->dev,
706 "CSIZE was not CS5-CS8, using default of 8\n");
707 last_lcr |= MCT_U232_DATA_BITS_8;
708 break;
709 }
710
711 termios->c_cflag &= ~CMSPAR;
712
713 /* set the number of stop bits */
714 last_lcr |= (cflag & CSTOPB) ?
715 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
716
717 mct_u232_set_line_ctrl(serial, last_lcr);
718
719 /* save off the modified port settings */
720 spin_lock_irqsave(&priv->lock, flags);
721 priv->control_state = control_state;
722 priv->last_lcr = last_lcr;
723 spin_unlock_irqrestore(&priv->lock, flags);
724 } /* mct_u232_set_termios */
725
726 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
727 {
728 struct usb_serial_port *port = tty->driver_data;
729 struct usb_serial *serial = port->serial;
730 struct mct_u232_private *priv = usb_get_serial_port_data(port);
731 unsigned char lcr;
732 unsigned long flags;
733
734 dbg("%sstate=%d", __func__, break_state);
735
736 spin_lock_irqsave(&priv->lock, flags);
737 lcr = priv->last_lcr;
738
739 if (break_state)
740 lcr |= MCT_U232_SET_BREAK;
741 spin_unlock_irqrestore(&priv->lock, flags);
742
743 mct_u232_set_line_ctrl(serial, lcr);
744 } /* mct_u232_break_ctl */
745
746
747 static int mct_u232_tiocmget(struct tty_struct *tty)
748 {
749 struct usb_serial_port *port = tty->driver_data;
750 struct mct_u232_private *priv = usb_get_serial_port_data(port);
751 unsigned int control_state;
752 unsigned long flags;
753
754 dbg("%s", __func__);
755
756 spin_lock_irqsave(&priv->lock, flags);
757 control_state = priv->control_state;
758 spin_unlock_irqrestore(&priv->lock, flags);
759
760 return control_state;
761 }
762
763 static int mct_u232_tiocmset(struct tty_struct *tty,
764 unsigned int set, unsigned int clear)
765 {
766 struct usb_serial_port *port = tty->driver_data;
767 struct usb_serial *serial = port->serial;
768 struct mct_u232_private *priv = usb_get_serial_port_data(port);
769 unsigned int control_state;
770 unsigned long flags;
771
772 dbg("%s", __func__);
773
774 spin_lock_irqsave(&priv->lock, flags);
775 control_state = priv->control_state;
776
777 if (set & TIOCM_RTS)
778 control_state |= TIOCM_RTS;
779 if (set & TIOCM_DTR)
780 control_state |= TIOCM_DTR;
781 if (clear & TIOCM_RTS)
782 control_state &= ~TIOCM_RTS;
783 if (clear & TIOCM_DTR)
784 control_state &= ~TIOCM_DTR;
785
786 priv->control_state = control_state;
787 spin_unlock_irqrestore(&priv->lock, flags);
788 return mct_u232_set_modem_ctrl(serial, control_state);
789 }
790
791 static void mct_u232_throttle(struct tty_struct *tty)
792 {
793 struct usb_serial_port *port = tty->driver_data;
794 struct mct_u232_private *priv = usb_get_serial_port_data(port);
795 unsigned int control_state;
796
797 dbg("%s - port %d", __func__, port->number);
798
799 spin_lock_irq(&priv->lock);
800 priv->rx_flags |= THROTTLED;
801 if (C_CRTSCTS(tty)) {
802 priv->control_state &= ~TIOCM_RTS;
803 control_state = priv->control_state;
804 spin_unlock_irq(&priv->lock);
805 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
806 } else {
807 spin_unlock_irq(&priv->lock);
808 }
809 }
810
811 static void mct_u232_unthrottle(struct tty_struct *tty)
812 {
813 struct usb_serial_port *port = tty->driver_data;
814 struct mct_u232_private *priv = usb_get_serial_port_data(port);
815 unsigned int control_state;
816
817 dbg("%s - port %d", __func__, port->number);
818
819 spin_lock_irq(&priv->lock);
820 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
821 priv->rx_flags &= ~THROTTLED;
822 priv->control_state |= TIOCM_RTS;
823 control_state = priv->control_state;
824 spin_unlock_irq(&priv->lock);
825 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
826 } else {
827 spin_unlock_irq(&priv->lock);
828 }
829 }
830
831 static int mct_u232_ioctl(struct tty_struct *tty,
832 unsigned int cmd, unsigned long arg)
833 {
834 DEFINE_WAIT(wait);
835 struct usb_serial_port *port = tty->driver_data;
836 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
837 struct async_icount cnow, cprev;
838 unsigned long flags;
839
840 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
841
842 switch (cmd) {
843
844 case TIOCMIWAIT:
845
846 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
847
848 spin_lock_irqsave(&mct_u232_port->lock, flags);
849 cprev = mct_u232_port->icount;
850 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
851 for ( ; ; ) {
852 prepare_to_wait(&mct_u232_port->msr_wait,
853 &wait, TASK_INTERRUPTIBLE);
854 schedule();
855 finish_wait(&mct_u232_port->msr_wait, &wait);
856 /* see if a signal did it */
857 if (signal_pending(current))
858 return -ERESTARTSYS;
859 spin_lock_irqsave(&mct_u232_port->lock, flags);
860 cnow = mct_u232_port->icount;
861 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
862 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
863 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
864 return -EIO; /* no change => error */
865 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
866 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
867 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
868 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
869 return 0;
870 }
871 cprev = cnow;
872 }
873
874 }
875 return -ENOIOCTLCMD;
876 }
877
878 static int mct_u232_get_icount(struct tty_struct *tty,
879 struct serial_icounter_struct *icount)
880 {
881 struct usb_serial_port *port = tty->driver_data;
882 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
883 struct async_icount *ic = &mct_u232_port->icount;
884 unsigned long flags;
885
886 spin_lock_irqsave(&mct_u232_port->lock, flags);
887
888 icount->cts = ic->cts;
889 icount->dsr = ic->dsr;
890 icount->rng = ic->rng;
891 icount->dcd = ic->dcd;
892 icount->rx = ic->rx;
893 icount->tx = ic->tx;
894 icount->frame = ic->frame;
895 icount->overrun = ic->overrun;
896 icount->parity = ic->parity;
897 icount->brk = ic->brk;
898 icount->buf_overrun = ic->buf_overrun;
899
900 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
901
902 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
903 __func__, port->number, icount->rx, icount->tx);
904 return 0;
905 }
906
907 static int __init mct_u232_init(void)
908 {
909 int retval;
910 retval = usb_serial_register(&mct_u232_device);
911 if (retval)
912 goto failed_usb_serial_register;
913 retval = usb_register(&mct_u232_driver);
914 if (retval)
915 goto failed_usb_register;
916 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
917 DRIVER_DESC "\n");
918 return 0;
919 failed_usb_register:
920 usb_serial_deregister(&mct_u232_device);
921 failed_usb_serial_register:
922 return retval;
923 }
924
925
926 static void __exit mct_u232_exit(void)
927 {
928 usb_deregister(&mct_u232_driver);
929 usb_serial_deregister(&mct_u232_device);
930 }
931
932 module_init(mct_u232_init);
933 module_exit(mct_u232_exit);
934
935 MODULE_AUTHOR(DRIVER_AUTHOR);
936 MODULE_DESCRIPTION(DRIVER_DESC);
937 MODULE_LICENSE("GPL");
938
939 module_param(debug, bool, S_IRUGO | S_IWUSR);
940 MODULE_PARM_DESC(debug, "Debug enabled or not");
kernel source for telekom puls (alcatel/mediatek)