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