projects / deliverable / linux.git / blob
? search:


01d0c70d60e9b41129b44e76893958990f780b10
[deliverable/linux.git] / drivers / usb / serial / ti_usb_3410_5052.c
1 /* vi: ts=8 sw=8
2 *
3 * TI 3410/5052 USB Serial Driver
4 *
5 * Copyright (C) 2004 Texas Instruments
6 *
7 * This driver is based on the Linux io_ti driver, which is
8 * Copyright (C) 2000-2002 Inside Out Networks
9 * Copyright (C) 2001-2002 Greg Kroah-Hartman
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * For questions or problems with this driver, contact Texas Instruments
17 * technical support, or Al Borchers <alborchers@steinerpoint.com>, or
18 * Peter Berger <pberger@brimson.com>.
19 */
20
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/firmware.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/tty.h>
27 #include <linux/tty_driver.h>
28 #include <linux/tty_flip.h>
29 #include <linux/module.h>
30 #include <linux/spinlock.h>
31 #include <linux/ioctl.h>
32 #include <linux/serial.h>
33 #include <linux/circ_buf.h>
34 #include <linux/mutex.h>
35 #include <linux/uaccess.h>
36 #include <linux/usb.h>
37 #include <linux/usb/serial.h>
38
39 #include "ti_usb_3410_5052.h"
40
41 /* Defines */
42
43 #define TI_DRIVER_VERSION "v0.9"
44 #define TI_DRIVER_AUTHOR "Al Borchers <alborchers@steinerpoint.com>"
45 #define TI_DRIVER_DESC "TI USB 3410/5052 Serial Driver"
46
47 #define TI_FIRMWARE_BUF_SIZE 16284
48
49 #define TI_WRITE_BUF_SIZE 1024
50
51 #define TI_TRANSFER_TIMEOUT 2
52
53 #define TI_DEFAULT_LOW_LATENCY 0
54 #define TI_DEFAULT_CLOSING_WAIT 4000 /* in .01 secs */
55
56 /* supported setserial flags */
57 #define TI_SET_SERIAL_FLAGS (ASYNC_LOW_LATENCY)
58
59 /* read urb states */
60 #define TI_READ_URB_RUNNING 0
61 #define TI_READ_URB_STOPPING 1
62 #define TI_READ_URB_STOPPED 2
63
64 #define TI_EXTRA_VID_PID_COUNT 5
65
66
67 /* Structures */
68
69 struct ti_port {
70 int tp_is_open;
71 __u8 tp_msr;
72 __u8 tp_lsr;
73 __u8 tp_shadow_mcr;
74 __u8 tp_uart_mode; /* 232 or 485 modes */
75 unsigned int tp_uart_base_addr;
76 int tp_flags;
77 int tp_closing_wait;/* in .01 secs */
78 struct async_icount tp_icount;
79 wait_queue_head_t tp_msr_wait; /* wait for msr change */
80 wait_queue_head_t tp_write_wait;
81 struct ti_device *tp_tdev;
82 struct usb_serial_port *tp_port;
83 spinlock_t tp_lock;
84 int tp_read_urb_state;
85 int tp_write_urb_in_use;
86 struct circ_buf *tp_write_buf;
87 };
88
89 struct ti_device {
90 struct mutex td_open_close_lock;
91 int td_open_port_count;
92 struct usb_serial *td_serial;
93 int td_is_3410;
94 int td_urb_error;
95 };
96
97
98 /* Function Declarations */
99
100 static int ti_startup(struct usb_serial *serial);
101 static void ti_shutdown(struct usb_serial *serial);
102 static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
103 struct file *file);
104 static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
105 struct file *file);
106 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
107 const unsigned char *data, int count);
108 static int ti_write_room(struct tty_struct *tty);
109 static int ti_chars_in_buffer(struct tty_struct *tty);
110 static void ti_throttle(struct tty_struct *tty);
111 static void ti_unthrottle(struct tty_struct *tty);
112 static int ti_ioctl(struct tty_struct *tty, struct file *file,
113 unsigned int cmd, unsigned long arg);
114 static void ti_set_termios(struct tty_struct *tty,
115 struct usb_serial_port *port, struct ktermios *old_termios);
116 static int ti_tiocmget(struct tty_struct *tty, struct file *file);
117 static int ti_tiocmset(struct tty_struct *tty, struct file *file,
118 unsigned int set, unsigned int clear);
119 static void ti_break(struct tty_struct *tty, int break_state);
120 static void ti_interrupt_callback(struct urb *urb);
121 static void ti_bulk_in_callback(struct urb *urb);
122 static void ti_bulk_out_callback(struct urb *urb);
123
124 static void ti_recv(struct device *dev, struct tty_struct *tty,
125 unsigned char *data, int length);
126 static void ti_send(struct ti_port *tport);
127 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr);
128 static int ti_get_lsr(struct ti_port *tport);
129 static int ti_get_serial_info(struct ti_port *tport,
130 struct serial_struct __user *ret_arg);
131 static int ti_set_serial_info(struct tty_struct *tty, struct ti_port *tport,
132 struct serial_struct __user *new_arg);
133 static void ti_handle_new_msr(struct ti_port *tport, __u8 msr);
134
135 static void ti_drain(struct ti_port *tport, unsigned long timeout, int flush);
136
137 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty);
138 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty);
139
140 static int ti_command_out_sync(struct ti_device *tdev, __u8 command,
141 __u16 moduleid, __u16 value, __u8 *data, int size);
142 static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
143 __u16 moduleid, __u16 value, __u8 *data, int size);
144
145 static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
146 __u8 mask, __u8 byte);
147
148 static int ti_download_firmware(struct ti_device *tdev, int type);
149
150 /* circular buffer */
151 static struct circ_buf *ti_buf_alloc(void);
152 static void ti_buf_free(struct circ_buf *cb);
153 static void ti_buf_clear(struct circ_buf *cb);
154 static int ti_buf_data_avail(struct circ_buf *cb);
155 static int ti_buf_space_avail(struct circ_buf *cb);
156 static int ti_buf_put(struct circ_buf *cb, const char *buf, int count);
157 static int ti_buf_get(struct circ_buf *cb, char *buf, int count);
158
159
160 /* Data */
161
162 /* module parameters */
163 static int debug;
164 static int low_latency = TI_DEFAULT_LOW_LATENCY;
165 static int closing_wait = TI_DEFAULT_CLOSING_WAIT;
166 static ushort vendor_3410[TI_EXTRA_VID_PID_COUNT];
167 static unsigned int vendor_3410_count;
168 static ushort product_3410[TI_EXTRA_VID_PID_COUNT];
169 static unsigned int product_3410_count;
170 static ushort vendor_5052[TI_EXTRA_VID_PID_COUNT];
171 static unsigned int vendor_5052_count;
172 static ushort product_5052[TI_EXTRA_VID_PID_COUNT];
173 static unsigned int product_5052_count;
174
175 /* supported devices */
176 /* the array dimension is the number of default entries plus */
177 /* TI_EXTRA_VID_PID_COUNT user defined entries plus 1 terminating */
178 /* null entry */
179 static struct usb_device_id ti_id_table_3410[1+TI_EXTRA_VID_PID_COUNT+1] = {
180 { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
181 { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
182 };
183
184 static struct usb_device_id ti_id_table_5052[4+TI_EXTRA_VID_PID_COUNT+1] = {
185 { USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
186 { USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
187 { USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
188 { USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
189 };
190
191 static struct usb_device_id ti_id_table_combined[] = {
192 { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
193 { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
194 { USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
195 { USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
196 { USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
197 { USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
198 { }
199 };
200
201 static struct usb_driver ti_usb_driver = {
202 .name = "ti_usb_3410_5052",
203 .probe = usb_serial_probe,
204 .disconnect = usb_serial_disconnect,
205 .id_table = ti_id_table_combined,
206 .no_dynamic_id = 1,
207 };
208
209 static struct usb_serial_driver ti_1port_device = {
210 .driver = {
211 .owner = THIS_MODULE,
212 .name = "ti_usb_3410_5052_1",
213 },
214 .description = "TI USB 3410 1 port adapter",
215 .usb_driver = &ti_usb_driver,
216 .id_table = ti_id_table_3410,
217 .num_ports = 1,
218 .attach = ti_startup,
219 .shutdown = ti_shutdown,
220 .open = ti_open,
221 .close = ti_close,
222 .write = ti_write,
223 .write_room = ti_write_room,
224 .chars_in_buffer = ti_chars_in_buffer,
225 .throttle = ti_throttle,
226 .unthrottle = ti_unthrottle,
227 .ioctl = ti_ioctl,
228 .set_termios = ti_set_termios,
229 .tiocmget = ti_tiocmget,
230 .tiocmset = ti_tiocmset,
231 .break_ctl = ti_break,
232 .read_int_callback = ti_interrupt_callback,
233 .read_bulk_callback = ti_bulk_in_callback,
234 .write_bulk_callback = ti_bulk_out_callback,
235 };
236
237 static struct usb_serial_driver ti_2port_device = {
238 .driver = {
239 .owner = THIS_MODULE,
240 .name = "ti_usb_3410_5052_2",
241 },
242 .description = "TI USB 5052 2 port adapter",
243 .usb_driver = &ti_usb_driver,
244 .id_table = ti_id_table_5052,
245 .num_ports = 2,
246 .attach = ti_startup,
247 .shutdown = ti_shutdown,
248 .open = ti_open,
249 .close = ti_close,
250 .write = ti_write,
251 .write_room = ti_write_room,
252 .chars_in_buffer = ti_chars_in_buffer,
253 .throttle = ti_throttle,
254 .unthrottle = ti_unthrottle,
255 .ioctl = ti_ioctl,
256 .set_termios = ti_set_termios,
257 .tiocmget = ti_tiocmget,
258 .tiocmset = ti_tiocmset,
259 .break_ctl = ti_break,
260 .read_int_callback = ti_interrupt_callback,
261 .read_bulk_callback = ti_bulk_in_callback,
262 .write_bulk_callback = ti_bulk_out_callback,
263 };
264
265
266 /* Module */
267
268 MODULE_AUTHOR(TI_DRIVER_AUTHOR);
269 MODULE_DESCRIPTION(TI_DRIVER_DESC);
270 MODULE_VERSION(TI_DRIVER_VERSION);
271 MODULE_LICENSE("GPL");
272
273 MODULE_FIRMWARE("ti_3410.fw");
274 MODULE_FIRMWARE("ti_5052.fw");
275
276 module_param(debug, bool, S_IRUGO | S_IWUSR);
277 MODULE_PARM_DESC(debug, "Enable debugging, 0=no, 1=yes");
278
279 module_param(low_latency, bool, S_IRUGO | S_IWUSR);
280 MODULE_PARM_DESC(low_latency,
281 "TTY low_latency flag, 0=off, 1=on, default is off");
282
283 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
284 MODULE_PARM_DESC(closing_wait,
285 "Maximum wait for data to drain in close, in .01 secs, default is 4000");
286
287 module_param_array(vendor_3410, ushort, &vendor_3410_count, S_IRUGO);
288 MODULE_PARM_DESC(vendor_3410,
289 "Vendor ids for 3410 based devices, 1-5 short integers");
290 module_param_array(product_3410, ushort, &product_3410_count, S_IRUGO);
291 MODULE_PARM_DESC(product_3410,
292 "Product ids for 3410 based devices, 1-5 short integers");
293 module_param_array(vendor_5052, ushort, &vendor_5052_count, S_IRUGO);
294 MODULE_PARM_DESC(vendor_5052,
295 "Vendor ids for 5052 based devices, 1-5 short integers");
296 module_param_array(product_5052, ushort, &product_5052_count, S_IRUGO);
297 MODULE_PARM_DESC(product_5052,
298 "Product ids for 5052 based devices, 1-5 short integers");
299
300 MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
301
302
303 /* Functions */
304
305 static int __init ti_init(void)
306 {
307 int i, j;
308 int ret;
309
310 /* insert extra vendor and product ids */
311 j = ARRAY_SIZE(ti_id_table_3410) - TI_EXTRA_VID_PID_COUNT - 1;
312 for (i = 0; i < min(vendor_3410_count, product_3410_count); i++, j++) {
313 ti_id_table_3410[j].idVendor = vendor_3410[i];
314 ti_id_table_3410[j].idProduct = product_3410[i];
315 ti_id_table_3410[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
316 }
317 j = ARRAY_SIZE(ti_id_table_5052) - TI_EXTRA_VID_PID_COUNT - 1;
318 for (i = 0; i < min(vendor_5052_count, product_5052_count); i++, j++) {
319 ti_id_table_5052[j].idVendor = vendor_5052[i];
320 ti_id_table_5052[j].idProduct = product_5052[i];
321 ti_id_table_5052[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
322 }
323
324 ret = usb_serial_register(&ti_1port_device);
325 if (ret)
326 goto failed_1port;
327 ret = usb_serial_register(&ti_2port_device);
328 if (ret)
329 goto failed_2port;
330
331 ret = usb_register(&ti_usb_driver);
332 if (ret)
333 goto failed_usb;
334
335 printk(KERN_INFO KBUILD_MODNAME ": " TI_DRIVER_VERSION ":"
336 TI_DRIVER_DESC "\n");
337
338 return 0;
339
340 failed_usb:
341 usb_serial_deregister(&ti_2port_device);
342 failed_2port:
343 usb_serial_deregister(&ti_1port_device);
344 failed_1port:
345 return ret;
346 }
347
348
349 static void __exit ti_exit(void)
350 {
351 usb_serial_deregister(&ti_1port_device);
352 usb_serial_deregister(&ti_2port_device);
353 usb_deregister(&ti_usb_driver);
354 }
355
356
357 module_init(ti_init);
358 module_exit(ti_exit);
359
360
361 static int ti_startup(struct usb_serial *serial)
362 {
363 struct ti_device *tdev;
364 struct ti_port *tport;
365 struct usb_device *dev = serial->dev;
366 int status;
367 int i;
368
369
370 dbg("%s - product 0x%4X, num configurations %d, configuration value %d",
371 __func__, le16_to_cpu(dev->descriptor.idProduct),
372 dev->descriptor.bNumConfigurations,
373 dev->actconfig->desc.bConfigurationValue);
374
375 /* create device structure */
376 tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
377 if (tdev == NULL) {
378 dev_err(&dev->dev, "%s - out of memory\n", __func__);
379 return -ENOMEM;
380 }
381 mutex_init(&tdev->td_open_close_lock);
382 tdev->td_serial = serial;
383 usb_set_serial_data(serial, tdev);
384
385 /* determine device type */
386 if (usb_match_id(serial->interface, ti_id_table_3410))
387 tdev->td_is_3410 = 1;
388 dbg("%s - device type is %s", __func__,
389 tdev->td_is_3410 ? "3410" : "5052");
390
391 /* if we have only 1 configuration, download firmware */
392 if (dev->descriptor.bNumConfigurations == 1) {
393 if (tdev->td_is_3410)
394 status = ti_download_firmware(tdev, 3410);
395 else
396 status = ti_download_firmware(tdev, 5052);
397 if (status)
398 goto free_tdev;
399
400 /* 3410 must be reset, 5052 resets itself */
401 if (tdev->td_is_3410) {
402 msleep_interruptible(100);
403 usb_reset_device(dev);
404 }
405
406 status = -ENODEV;
407 goto free_tdev;
408 }
409
410 /* the second configuration must be set */
411 if (dev->actconfig->desc.bConfigurationValue == TI_BOOT_CONFIG) {
412 status = usb_driver_set_configuration(dev, TI_ACTIVE_CONFIG);
413 status = status ? status : -ENODEV;
414 goto free_tdev;
415 }
416
417 /* set up port structures */
418 for (i = 0; i < serial->num_ports; ++i) {
419 tport = kzalloc(sizeof(struct ti_port), GFP_KERNEL);
420 if (tport == NULL) {
421 dev_err(&dev->dev, "%s - out of memory\n", __func__);
422 status = -ENOMEM;
423 goto free_tports;
424 }
425 spin_lock_init(&tport->tp_lock);
426 tport->tp_uart_base_addr = (i == 0 ?
427 TI_UART1_BASE_ADDR : TI_UART2_BASE_ADDR);
428 tport->tp_flags = low_latency ? ASYNC_LOW_LATENCY : 0;
429 tport->tp_closing_wait = closing_wait;
430 init_waitqueue_head(&tport->tp_msr_wait);
431 init_waitqueue_head(&tport->tp_write_wait);
432 tport->tp_write_buf = ti_buf_alloc();
433 if (tport->tp_write_buf == NULL) {
434 dev_err(&dev->dev, "%s - out of memory\n", __func__);
435 kfree(tport);
436 status = -ENOMEM;
437 goto free_tports;
438 }
439 tport->tp_port = serial->port[i];
440 tport->tp_tdev = tdev;
441 usb_set_serial_port_data(serial->port[i], tport);
442 tport->tp_uart_mode = 0; /* default is RS232 */
443 }
444
445 return 0;
446
447 free_tports:
448 for (--i; i >= 0; --i) {
449 tport = usb_get_serial_port_data(serial->port[i]);
450 ti_buf_free(tport->tp_write_buf);
451 kfree(tport);
452 usb_set_serial_port_data(serial->port[i], NULL);
453 }
454 free_tdev:
455 kfree(tdev);
456 usb_set_serial_data(serial, NULL);
457 return status;
458 }
459
460
461 static void ti_shutdown(struct usb_serial *serial)
462 {
463 int i;
464 struct ti_device *tdev = usb_get_serial_data(serial);
465 struct ti_port *tport;
466
467 dbg("%s", __func__);
468
469 for (i = 0; i < serial->num_ports; ++i) {
470 tport = usb_get_serial_port_data(serial->port[i]);
471 if (tport) {
472 ti_buf_free(tport->tp_write_buf);
473 kfree(tport);
474 usb_set_serial_port_data(serial->port[i], NULL);
475 }
476 }
477
478 kfree(tdev);
479 usb_set_serial_data(serial, NULL);
480 }
481
482
483 static int ti_open(struct tty_struct *tty,
484 struct usb_serial_port *port, struct file *file)
485 {
486 struct ti_port *tport = usb_get_serial_port_data(port);
487 struct ti_device *tdev;
488 struct usb_device *dev;
489 struct urb *urb;
490 int port_number;
491 int status;
492 __u16 open_settings = (__u8)(TI_PIPE_MODE_CONTINOUS |
493 TI_PIPE_TIMEOUT_ENABLE |
494 (TI_TRANSFER_TIMEOUT << 2));
495
496 dbg("%s - port %d", __func__, port->number);
497
498 if (tport == NULL)
499 return -ENODEV;
500
501 dev = port->serial->dev;
502 tdev = tport->tp_tdev;
503
504 /* only one open on any port on a device at a time */
505 if (mutex_lock_interruptible(&tdev->td_open_close_lock))
506 return -ERESTARTSYS;
507
508 if (tty)
509 tty->low_latency =
510 (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
511
512 port_number = port->number - port->serial->minor;
513
514 memset(&(tport->tp_icount), 0x00, sizeof(tport->tp_icount));
515
516 tport->tp_msr = 0;
517 tport->tp_shadow_mcr |= (TI_MCR_RTS | TI_MCR_DTR);
518
519 /* start interrupt urb the first time a port is opened on this device */
520 if (tdev->td_open_port_count == 0) {
521 dbg("%s - start interrupt in urb", __func__);
522 urb = tdev->td_serial->port[0]->interrupt_in_urb;
523 if (!urb) {
524 dev_err(&port->dev, "%s - no interrupt urb\n",
525 __func__);
526 status = -EINVAL;
527 goto release_lock;
528 }
529 urb->complete = ti_interrupt_callback;
530 urb->context = tdev;
531 urb->dev = dev;
532 status = usb_submit_urb(urb, GFP_KERNEL);
533 if (status) {
534 dev_err(&port->dev,
535 "%s - submit interrupt urb failed, %d\n",
536 __func__, status);
537 goto release_lock;
538 }
539 }
540
541 if (tty)
542 ti_set_termios(tty, port, tty->termios);
543
544 dbg("%s - sending TI_OPEN_PORT", __func__);
545 status = ti_command_out_sync(tdev, TI_OPEN_PORT,
546 (__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
547 if (status) {
548 dev_err(&port->dev, "%s - cannot send open command, %d\n",
549 __func__, status);
550 goto unlink_int_urb;
551 }
552
553 dbg("%s - sending TI_START_PORT", __func__);
554 status = ti_command_out_sync(tdev, TI_START_PORT,
555 (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
556 if (status) {
557 dev_err(&port->dev, "%s - cannot send start command, %d\n",
558 __func__, status);
559 goto unlink_int_urb;
560 }
561
562 dbg("%s - sending TI_PURGE_PORT", __func__);
563 status = ti_command_out_sync(tdev, TI_PURGE_PORT,
564 (__u8)(TI_UART1_PORT + port_number), TI_PURGE_INPUT, NULL, 0);
565 if (status) {
566 dev_err(&port->dev, "%s - cannot clear input buffers, %d\n",
567 __func__, status);
568 goto unlink_int_urb;
569 }
570 status = ti_command_out_sync(tdev, TI_PURGE_PORT,
571 (__u8)(TI_UART1_PORT + port_number), TI_PURGE_OUTPUT, NULL, 0);
572 if (status) {
573 dev_err(&port->dev, "%s - cannot clear output buffers, %d\n",
574 __func__, status);
575 goto unlink_int_urb;
576 }
577
578 /* reset the data toggle on the bulk endpoints to work around bug in
579 * host controllers where things get out of sync some times */
580 usb_clear_halt(dev, port->write_urb->pipe);
581 usb_clear_halt(dev, port->read_urb->pipe);
582
583 if (tty)
584 ti_set_termios(tty, port, tty->termios);
585
586 dbg("%s - sending TI_OPEN_PORT (2)", __func__);
587 status = ti_command_out_sync(tdev, TI_OPEN_PORT,
588 (__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
589 if (status) {
590 dev_err(&port->dev, "%s - cannot send open command (2), %d\n",
591 __func__, status);
592 goto unlink_int_urb;
593 }
594
595 dbg("%s - sending TI_START_PORT (2)", __func__);
596 status = ti_command_out_sync(tdev, TI_START_PORT,
597 (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
598 if (status) {
599 dev_err(&port->dev, "%s - cannot send start command (2), %d\n",
600 __func__, status);
601 goto unlink_int_urb;
602 }
603
604 /* start read urb */
605 dbg("%s - start read urb", __func__);
606 urb = port->read_urb;
607 if (!urb) {
608 dev_err(&port->dev, "%s - no read urb\n", __func__);
609 status = -EINVAL;
610 goto unlink_int_urb;
611 }
612 tport->tp_read_urb_state = TI_READ_URB_RUNNING;
613 urb->complete = ti_bulk_in_callback;
614 urb->context = tport;
615 urb->dev = dev;
616 status = usb_submit_urb(urb, GFP_KERNEL);
617 if (status) {
618 dev_err(&port->dev, "%s - submit read urb failed, %d\n",
619 __func__, status);
620 goto unlink_int_urb;
621 }
622
623 tport->tp_is_open = 1;
624 ++tdev->td_open_port_count;
625
626 goto release_lock;
627
628 unlink_int_urb:
629 if (tdev->td_open_port_count == 0)
630 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
631 release_lock:
632 mutex_unlock(&tdev->td_open_close_lock);
633 dbg("%s - exit %d", __func__, status);
634 return status;
635 }
636
637
638 static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
639 struct file *file)
640 {
641 struct ti_device *tdev;
642 struct ti_port *tport;
643 int port_number;
644 int status;
645 int do_unlock;
646
647 dbg("%s - port %d", __func__, port->number);
648
649 tdev = usb_get_serial_data(port->serial);
650 tport = usb_get_serial_port_data(port);
651 if (tdev == NULL || tport == NULL)
652 return;
653
654 tport->tp_is_open = 0;
655
656 ti_drain(tport, (tport->tp_closing_wait*HZ)/100, 1);
657
658 usb_kill_urb(port->read_urb);
659 usb_kill_urb(port->write_urb);
660 tport->tp_write_urb_in_use = 0;
661
662 port_number = port->number - port->serial->minor;
663
664 dbg("%s - sending TI_CLOSE_PORT", __func__);
665 status = ti_command_out_sync(tdev, TI_CLOSE_PORT,
666 (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
667 if (status)
668 dev_err(&port->dev,
669 "%s - cannot send close port command, %d\n"
670 , __func__, status);
671
672 /* if mutex_lock is interrupted, continue anyway */
673 do_unlock = !mutex_lock_interruptible(&tdev->td_open_close_lock);
674 --tport->tp_tdev->td_open_port_count;
675 if (tport->tp_tdev->td_open_port_count <= 0) {
676 /* last port is closed, shut down interrupt urb */
677 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
678 tport->tp_tdev->td_open_port_count = 0;
679 }
680 if (do_unlock)
681 mutex_unlock(&tdev->td_open_close_lock);
682
683 dbg("%s - exit", __func__);
684 }
685
686
687 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
688 const unsigned char *data, int count)
689 {
690 struct ti_port *tport = usb_get_serial_port_data(port);
691 unsigned long flags;
692
693 dbg("%s - port %d", __func__, port->number);
694
695 if (count == 0) {
696 dbg("%s - write request of 0 bytes", __func__);
697 return 0;
698 }
699
700 if (tport == NULL || !tport->tp_is_open)
701 return -ENODEV;
702
703 spin_lock_irqsave(&tport->tp_lock, flags);
704 count = ti_buf_put(tport->tp_write_buf, data, count);
705 spin_unlock_irqrestore(&tport->tp_lock, flags);
706
707 ti_send(tport);
708
709 return count;
710 }
711
712
713 static int ti_write_room(struct tty_struct *tty)
714 {
715 struct usb_serial_port *port = tty->driver_data;
716 struct ti_port *tport = usb_get_serial_port_data(port);
717 int room = 0;
718 unsigned long flags;
719
720 dbg("%s - port %d", __func__, port->number);
721
722 if (tport == NULL)
723 return -ENODEV;
724
725 spin_lock_irqsave(&tport->tp_lock, flags);
726 room = ti_buf_space_avail(tport->tp_write_buf);
727 spin_unlock_irqrestore(&tport->tp_lock, flags);
728
729 dbg("%s - returns %d", __func__, room);
730 return room;
731 }
732
733
734 static int ti_chars_in_buffer(struct tty_struct *tty)
735 {
736 struct usb_serial_port *port = tty->driver_data;
737 struct ti_port *tport = usb_get_serial_port_data(port);
738 int chars = 0;
739 unsigned long flags;
740
741 dbg("%s - port %d", __func__, port->number);
742
743 if (tport == NULL)
744 return -ENODEV;
745
746 spin_lock_irqsave(&tport->tp_lock, flags);
747 chars = ti_buf_data_avail(tport->tp_write_buf);
748 spin_unlock_irqrestore(&tport->tp_lock, flags);
749
750 dbg("%s - returns %d", __func__, chars);
751 return chars;
752 }
753
754
755 static void ti_throttle(struct tty_struct *tty)
756 {
757 struct usb_serial_port *port = tty->driver_data;
758 struct ti_port *tport = usb_get_serial_port_data(port);
759
760 dbg("%s - port %d", __func__, port->number);
761
762 if (tport == NULL)
763 return;
764
765 if (I_IXOFF(tty) || C_CRTSCTS(tty))
766 ti_stop_read(tport, tty);
767
768 }
769
770
771 static void ti_unthrottle(struct tty_struct *tty)
772 {
773 struct usb_serial_port *port = tty->driver_data;
774 struct ti_port *tport = usb_get_serial_port_data(port);
775 int status;
776
777 dbg("%s - port %d", __func__, port->number);
778
779 if (tport == NULL)
780 return;
781
782 if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
783 status = ti_restart_read(tport, tty);
784 if (status)
785 dev_err(&port->dev, "%s - cannot restart read, %d\n",
786 __func__, status);
787 }
788 }
789
790
791 static int ti_ioctl(struct tty_struct *tty, struct file *file,
792 unsigned int cmd, unsigned long arg)
793 {
794 struct usb_serial_port *port = tty->driver_data;
795 struct ti_port *tport = usb_get_serial_port_data(port);
796 struct async_icount cnow;
797 struct async_icount cprev;
798
799 dbg("%s - port %d, cmd = 0x%04X", __func__, port->number, cmd);
800
801 if (tport == NULL)
802 return -ENODEV;
803
804 switch (cmd) {
805 case TIOCGSERIAL:
806 dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
807 return ti_get_serial_info(tport,
808 (struct serial_struct __user *)arg);
809 case TIOCSSERIAL:
810 dbg("%s - (%d) TIOCSSERIAL", __func__, port->number);
811 return ti_set_serial_info(tty, tport,
812 (struct serial_struct __user *)arg);
813 case TIOCMIWAIT:
814 dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
815 cprev = tport->tp_icount;
816 while (1) {
817 interruptible_sleep_on(&tport->tp_msr_wait);
818 if (signal_pending(current))
819 return -ERESTARTSYS;
820 cnow = tport->tp_icount;
821 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
822 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
823 return -EIO; /* no change => error */
824 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
825 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
826 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
827 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)))
828 return 0;
829 cprev = cnow;
830 }
831 break;
832 case TIOCGICOUNT:
833 dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d",
834 __func__, port->number,
835 tport->tp_icount.rx, tport->tp_icount.tx);
836 if (copy_to_user((void __user *)arg, &tport->tp_icount,
837 sizeof(tport->tp_icount)))
838 return -EFAULT;
839 return 0;
840 }
841 return -ENOIOCTLCMD;
842 }
843
844
845 static void ti_set_termios(struct tty_struct *tty,
846 struct usb_serial_port *port, struct ktermios *old_termios)
847 {
848 struct ti_port *tport = usb_get_serial_port_data(port);
849 struct ti_uart_config *config;
850 tcflag_t cflag, iflag;
851 int baud;
852 int status;
853 int port_number = port->number - port->serial->minor;
854 unsigned int mcr;
855
856 dbg("%s - port %d", __func__, port->number);
857
858 cflag = tty->termios->c_cflag;
859 iflag = tty->termios->c_iflag;
860
861 dbg("%s - cflag %08x, iflag %08x", __func__, cflag, iflag);
862 dbg("%s - old clfag %08x, old iflag %08x", __func__,
863 old_termios->c_cflag, old_termios->c_iflag);
864
865 if (tport == NULL)
866 return;
867
868 config = kmalloc(sizeof(*config), GFP_KERNEL);
869 if (!config) {
870 dev_err(&port->dev, "%s - out of memory\n", __func__);
871 return;
872 }
873
874 config->wFlags = 0;
875
876 /* these flags must be set */
877 config->wFlags |= TI_UART_ENABLE_MS_INTS;
878 config->wFlags |= TI_UART_ENABLE_AUTO_START_DMA;
879 config->bUartMode = (__u8)(tport->tp_uart_mode);
880
881 switch (cflag & CSIZE) {
882 case CS5:
883 config->bDataBits = TI_UART_5_DATA_BITS;
884 break;
885 case CS6:
886 config->bDataBits = TI_UART_6_DATA_BITS;
887 break;
888 case CS7:
889 config->bDataBits = TI_UART_7_DATA_BITS;
890 break;
891 default:
892 case CS8:
893 config->bDataBits = TI_UART_8_DATA_BITS;
894 break;
895 }
896
897 /* CMSPAR isn't supported by this driver */
898 tty->termios->c_cflag &= ~CMSPAR;
899
900 if (cflag & PARENB) {
901 if (cflag & PARODD) {
902 config->wFlags |= TI_UART_ENABLE_PARITY_CHECKING;
903 config->bParity = TI_UART_ODD_PARITY;
904 } else {
905 config->wFlags |= TI_UART_ENABLE_PARITY_CHECKING;
906 config->bParity = TI_UART_EVEN_PARITY;
907 }
908 } else {
909 config->wFlags &= ~TI_UART_ENABLE_PARITY_CHECKING;
910 config->bParity = TI_UART_NO_PARITY;
911 }
912
913 if (cflag & CSTOPB)
914 config->bStopBits = TI_UART_2_STOP_BITS;
915 else
916 config->bStopBits = TI_UART_1_STOP_BITS;
917
918 if (cflag & CRTSCTS) {
919 /* RTS flow control must be off to drop RTS for baud rate B0 */
920 if ((cflag & CBAUD) != B0)
921 config->wFlags |= TI_UART_ENABLE_RTS_IN;
922 config->wFlags |= TI_UART_ENABLE_CTS_OUT;
923 } else {
924 tty->hw_stopped = 0;
925 ti_restart_read(tport, tty);
926 }
927
928 if (I_IXOFF(tty) || I_IXON(tty)) {
929 config->cXon = START_CHAR(tty);
930 config->cXoff = STOP_CHAR(tty);
931
932 if (I_IXOFF(tty))
933 config->wFlags |= TI_UART_ENABLE_X_IN;
934 else
935 ti_restart_read(tport, tty);
936
937 if (I_IXON(tty))
938 config->wFlags |= TI_UART_ENABLE_X_OUT;
939 }
940
941 baud = tty_get_baud_rate(tty);
942 if (!baud)
943 baud = 9600;
944 if (tport->tp_tdev->td_is_3410)
945 config->wBaudRate = (__u16)((923077 + baud/2) / baud);
946 else
947 config->wBaudRate = (__u16)((461538 + baud/2) / baud);
948
949 /* FIXME: Should calculate resulting baud here and report it back */
950 if ((cflag & CBAUD) != B0)
951 tty_encode_baud_rate(tty, baud, baud);
952
953 dbg("%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d",
954 __func__, baud, config->wBaudRate, config->wFlags, config->bDataBits, config->bParity, config->bStopBits, config->cXon, config->cXoff, config->bUartMode);
955
956 cpu_to_be16s(&config->wBaudRate);
957 cpu_to_be16s(&config->wFlags);
958
959 status = ti_command_out_sync(tport->tp_tdev, TI_SET_CONFIG,
960 (__u8)(TI_UART1_PORT + port_number), 0, (__u8 *)config,
961 sizeof(*config));
962 if (status)
963 dev_err(&port->dev, "%s - cannot set config on port %d, %d\n",
964 __func__, port_number, status);
965
966 /* SET_CONFIG asserts RTS and DTR, reset them correctly */
967 mcr = tport->tp_shadow_mcr;
968 /* if baud rate is B0, clear RTS and DTR */
969 if ((cflag & CBAUD) == B0)
970 mcr &= ~(TI_MCR_DTR | TI_MCR_RTS);
971 status = ti_set_mcr(tport, mcr);
972 if (status)
973 dev_err(&port->dev,
974 "%s - cannot set modem control on port %d, %d\n",
975 __func__, port_number, status);
976
977 kfree(config);
978 }
979
980
981 static int ti_tiocmget(struct tty_struct *tty, struct file *file)
982 {
983 struct usb_serial_port *port = tty->driver_data;
984 struct ti_port *tport = usb_get_serial_port_data(port);
985 unsigned int result;
986 unsigned int msr;
987 unsigned int mcr;
988 unsigned long flags;
989
990 dbg("%s - port %d", __func__, port->number);
991
992 if (tport == NULL)
993 return -ENODEV;
994
995 spin_lock_irqsave(&tport->tp_lock, flags);
996 msr = tport->tp_msr;
997 mcr = tport->tp_shadow_mcr;
998 spin_unlock_irqrestore(&tport->tp_lock, flags);
999
1000 result = ((mcr & TI_MCR_DTR) ? TIOCM_DTR : 0)
1001 | ((mcr & TI_MCR_RTS) ? TIOCM_RTS : 0)
1002 | ((mcr & TI_MCR_LOOP) ? TIOCM_LOOP : 0)
1003 | ((msr & TI_MSR_CTS) ? TIOCM_CTS : 0)
1004 | ((msr & TI_MSR_CD) ? TIOCM_CAR : 0)
1005 | ((msr & TI_MSR_RI) ? TIOCM_RI : 0)
1006 | ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0);
1007
1008 dbg("%s - 0x%04X", __func__, result);
1009
1010 return result;
1011 }
1012
1013
1014 static int ti_tiocmset(struct tty_struct *tty, struct file *file,
1015 unsigned int set, unsigned int clear)
1016 {
1017 struct usb_serial_port *port = tty->driver_data;
1018 struct ti_port *tport = usb_get_serial_port_data(port);
1019 unsigned int mcr;
1020 unsigned long flags;
1021
1022 dbg("%s - port %d", __func__, port->number);
1023
1024 if (tport == NULL)
1025 return -ENODEV;
1026
1027 spin_lock_irqsave(&tport->tp_lock, flags);
1028 mcr = tport->tp_shadow_mcr;
1029
1030 if (set & TIOCM_RTS)
1031 mcr |= TI_MCR_RTS;
1032 if (set & TIOCM_DTR)
1033 mcr |= TI_MCR_DTR;
1034 if (set & TIOCM_LOOP)
1035 mcr |= TI_MCR_LOOP;
1036
1037 if (clear & TIOCM_RTS)
1038 mcr &= ~TI_MCR_RTS;
1039 if (clear & TIOCM_DTR)
1040 mcr &= ~TI_MCR_DTR;
1041 if (clear & TIOCM_LOOP)
1042 mcr &= ~TI_MCR_LOOP;
1043 spin_unlock_irqrestore(&tport->tp_lock, flags);
1044
1045 return ti_set_mcr(tport, mcr);
1046 }
1047
1048
1049 static void ti_break(struct tty_struct *tty, int break_state)
1050 {
1051 struct usb_serial_port *port = tty->driver_data;
1052 struct ti_port *tport = usb_get_serial_port_data(port);
1053 int status;
1054
1055 dbg("%s - state = %d", __func__, break_state);
1056
1057 if (tport == NULL)
1058 return;
1059
1060 ti_drain(tport, (tport->tp_closing_wait*HZ)/100, 0);
1061
1062 status = ti_write_byte(tport->tp_tdev,
1063 tport->tp_uart_base_addr + TI_UART_OFFSET_LCR,
1064 TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0);
1065
1066 if (status)
1067 dbg("%s - error setting break, %d", __func__, status);
1068 }
1069
1070
1071 static void ti_interrupt_callback(struct urb *urb)
1072 {
1073 struct ti_device *tdev = urb->context;
1074 struct usb_serial_port *port;
1075 struct usb_serial *serial = tdev->td_serial;
1076 struct ti_port *tport;
1077 struct device *dev = &urb->dev->dev;
1078 unsigned char *data = urb->transfer_buffer;
1079 int length = urb->actual_length;
1080 int port_number;
1081 int function;
1082 int status = urb->status;
1083 int retval;
1084 __u8 msr;
1085
1086 dbg("%s", __func__);
1087
1088 switch (status) {
1089 case 0:
1090 break;
1091 case -ECONNRESET:
1092 case -ENOENT:
1093 case -ESHUTDOWN:
1094 dbg("%s - urb shutting down, %d", __func__, status);
1095 tdev->td_urb_error = 1;
1096 return;
1097 default:
1098 dev_err(dev, "%s - nonzero urb status, %d\n",
1099 __func__, status);
1100 tdev->td_urb_error = 1;
1101 goto exit;
1102 }
1103
1104 if (length != 2) {
1105 dbg("%s - bad packet size, %d", __func__, length);
1106 goto exit;
1107 }
1108
1109 if (data[0] == TI_CODE_HARDWARE_ERROR) {
1110 dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]);
1111 goto exit;
1112 }
1113
1114 port_number = TI_GET_PORT_FROM_CODE(data[0]);
1115 function = TI_GET_FUNC_FROM_CODE(data[0]);
1116
1117 dbg("%s - port_number %d, function %d, data 0x%02X",
1118 __func__, port_number, function, data[1]);
1119
1120 if (port_number >= serial->num_ports) {
1121 dev_err(dev, "%s - bad port number, %d\n",
1122 __func__, port_number);
1123 goto exit;
1124 }
1125
1126 port = serial->port[port_number];
1127
1128 tport = usb_get_serial_port_data(port);
1129 if (!tport)
1130 goto exit;
1131
1132 switch (function) {
1133 case TI_CODE_DATA_ERROR:
1134 dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
1135 __func__, port_number, data[1]);
1136 break;
1137
1138 case TI_CODE_MODEM_STATUS:
1139 msr = data[1];
1140 dbg("%s - port %d, msr 0x%02X", __func__, port_number, msr);
1141 ti_handle_new_msr(tport, msr);
1142 break;
1143
1144 default:
1145 dev_err(dev, "%s - unknown interrupt code, 0x%02X\n",
1146 __func__, data[1]);
1147 break;
1148 }
1149
1150 exit:
1151 retval = usb_submit_urb(urb, GFP_ATOMIC);
1152 if (retval)
1153 dev_err(dev, "%s - resubmit interrupt urb failed, %d\n",
1154 __func__, retval);
1155 }
1156
1157
1158 static void ti_bulk_in_callback(struct urb *urb)
1159 {
1160 struct ti_port *tport = urb->context;
1161 struct usb_serial_port *port = tport->tp_port;
1162 struct device *dev = &urb->dev->dev;
1163 int status = urb->status;
1164 int retval = 0;
1165 struct tty_struct *tty;
1166
1167 dbg("%s", __func__);
1168
1169 switch (status) {
1170 case 0:
1171 break;
1172 case -ECONNRESET:
1173 case -ENOENT:
1174 case -ESHUTDOWN:
1175 dbg("%s - urb shutting down, %d", __func__, status);
1176 tport->tp_tdev->td_urb_error = 1;
1177 wake_up_interruptible(&tport->tp_write_wait);
1178 return;
1179 default:
1180 dev_err(dev, "%s - nonzero urb status, %d\n",
1181 __func__, status);
1182 tport->tp_tdev->td_urb_error = 1;
1183 wake_up_interruptible(&tport->tp_write_wait);
1184 }
1185
1186 if (status == -EPIPE)
1187 goto exit;
1188
1189 if (status) {
1190 dev_err(dev, "%s - stopping read!\n", __func__);
1191 return;
1192 }
1193
1194 tty = tty_port_tty_get(&port->port);
1195 if (tty && urb->actual_length) {
1196 usb_serial_debug_data(debug, dev, __func__,
1197 urb->actual_length, urb->transfer_buffer);
1198
1199 if (!tport->tp_is_open)
1200 dbg("%s - port closed, dropping data", __func__);
1201 else
1202 ti_recv(&urb->dev->dev, tty,
1203 urb->transfer_buffer,
1204 urb->actual_length);
1205
1206 spin_lock(&tport->tp_lock);
1207 tport->tp_icount.rx += urb->actual_length;
1208 spin_unlock(&tport->tp_lock);
1209 tty_kref_put(tty);
1210 }
1211
1212 exit:
1213 /* continue to read unless stopping */
1214 spin_lock(&tport->tp_lock);
1215 if (tport->tp_read_urb_state == TI_READ_URB_RUNNING) {
1216 urb->dev = port->serial->dev;
1217 retval = usb_submit_urb(urb, GFP_ATOMIC);
1218 } else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING) {
1219 tport->tp_read_urb_state = TI_READ_URB_STOPPED;
1220 }
1221 spin_unlock(&tport->tp_lock);
1222 if (retval)
1223 dev_err(dev, "%s - resubmit read urb failed, %d\n",
1224 __func__, retval);
1225 }
1226
1227
1228 static void ti_bulk_out_callback(struct urb *urb)
1229 {
1230 struct ti_port *tport = urb->context;
1231 struct usb_serial_port *port = tport->tp_port;
1232 struct device *dev = &urb->dev->dev;
1233 int status = urb->status;
1234
1235 dbg("%s - port %d", __func__, port->number);
1236
1237 tport->tp_write_urb_in_use = 0;
1238
1239 switch (status) {
1240 case 0:
1241 break;
1242 case -ECONNRESET:
1243 case -ENOENT:
1244 case -ESHUTDOWN:
1245 dbg("%s - urb shutting down, %d", __func__, status);
1246 tport->tp_tdev->td_urb_error = 1;
1247 wake_up_interruptible(&tport->tp_write_wait);
1248 return;
1249 default:
1250 dev_err(dev, "%s - nonzero urb status, %d\n",
1251 __func__, status);
1252 tport->tp_tdev->td_urb_error = 1;
1253 wake_up_interruptible(&tport->tp_write_wait);
1254 }
1255
1256 /* send any buffered data */
1257 ti_send(tport);
1258 }
1259
1260
1261 static void ti_recv(struct device *dev, struct tty_struct *tty,
1262 unsigned char *data, int length)
1263 {
1264 int cnt;
1265
1266 do {
1267 cnt = tty_buffer_request_room(tty, length);
1268 if (cnt < length) {
1269 dev_err(dev, "%s - dropping data, %d bytes lost\n",
1270 __func__, length - cnt);
1271 if (cnt == 0)
1272 break;
1273 }
1274 tty_insert_flip_string(tty, data, cnt);
1275 tty_flip_buffer_push(tty);
1276 data += cnt;
1277 length -= cnt;
1278 } while (length > 0);
1279
1280 }
1281
1282
1283 static void ti_send(struct ti_port *tport)
1284 {
1285 int count, result;
1286 struct usb_serial_port *port = tport->tp_port;
1287 struct tty_struct *tty = tty_port_tty_get(&port->port); /* FIXME */
1288 unsigned long flags;
1289
1290
1291 dbg("%s - port %d", __func__, port->number);
1292
1293 spin_lock_irqsave(&tport->tp_lock, flags);
1294
1295 if (tport->tp_write_urb_in_use)
1296 goto unlock;
1297
1298 count = ti_buf_get(tport->tp_write_buf,
1299 port->write_urb->transfer_buffer,
1300 port->bulk_out_size);
1301
1302 if (count == 0)
1303 goto unlock;
1304
1305 tport->tp_write_urb_in_use = 1;
1306
1307 spin_unlock_irqrestore(&tport->tp_lock, flags);
1308
1309 usb_serial_debug_data(debug, &port->dev, __func__, count,
1310 port->write_urb->transfer_buffer);
1311
1312 usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1313 usb_sndbulkpipe(port->serial->dev,
1314 port->bulk_out_endpointAddress),
1315 port->write_urb->transfer_buffer, count,
1316 ti_bulk_out_callback, tport);
1317
1318 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1319 if (result) {
1320 dev_err(&port->dev, "%s - submit write urb failed, %d\n",
1321 __func__, result);
1322 tport->tp_write_urb_in_use = 0;
1323 /* TODO: reschedule ti_send */
1324 } else {
1325 spin_lock_irqsave(&tport->tp_lock, flags);
1326 tport->tp_icount.tx += count;
1327 spin_unlock_irqrestore(&tport->tp_lock, flags);
1328 }
1329
1330 /* more room in the buffer for new writes, wakeup */
1331 if (tty)
1332 tty_wakeup(tty);
1333 tty_kref_put(tty);
1334 wake_up_interruptible(&tport->tp_write_wait);
1335 return;
1336 unlock:
1337 spin_unlock_irqrestore(&tport->tp_lock, flags);
1338 tty_kref_put(tty);
1339 return;
1340 }
1341
1342
1343 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
1344 {
1345 unsigned long flags;
1346 int status;
1347
1348 status = ti_write_byte(tport->tp_tdev,
1349 tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
1350 TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);
1351
1352 spin_lock_irqsave(&tport->tp_lock, flags);
1353 if (!status)
1354 tport->tp_shadow_mcr = mcr;
1355 spin_unlock_irqrestore(&tport->tp_lock, flags);
1356
1357 return status;
1358 }
1359
1360
1361 static int ti_get_lsr(struct ti_port *tport)
1362 {
1363 int size, status;
1364 struct ti_device *tdev = tport->tp_tdev;
1365 struct usb_serial_port *port = tport->tp_port;
1366 int port_number = port->number - port->serial->minor;
1367 struct ti_port_status *data;
1368
1369 dbg("%s - port %d", __func__, port->number);
1370
1371 size = sizeof(struct ti_port_status);
1372 data = kmalloc(size, GFP_KERNEL);
1373 if (!data) {
1374 dev_err(&port->dev, "%s - out of memory\n", __func__);
1375 return -ENOMEM;
1376 }
1377
1378 status = ti_command_in_sync(tdev, TI_GET_PORT_STATUS,
1379 (__u8)(TI_UART1_PORT+port_number), 0, (__u8 *)data, size);
1380 if (status) {
1381 dev_err(&port->dev,
1382 "%s - get port status command failed, %d\n",
1383 __func__, status);
1384 goto free_data;
1385 }
1386
1387 dbg("%s - lsr 0x%02X", __func__, data->bLSR);
1388
1389 tport->tp_lsr = data->bLSR;
1390
1391 free_data:
1392 kfree(data);
1393 return status;
1394 }
1395
1396
1397 static int ti_get_serial_info(struct ti_port *tport,
1398 struct serial_struct __user *ret_arg)
1399 {
1400 struct usb_serial_port *port = tport->tp_port;
1401 struct serial_struct ret_serial;
1402
1403 if (!ret_arg)
1404 return -EFAULT;
1405
1406 memset(&ret_serial, 0, sizeof(ret_serial));
1407
1408 ret_serial.type = PORT_16550A;
1409 ret_serial.line = port->serial->minor;
1410 ret_serial.port = port->number - port->serial->minor;
1411 ret_serial.flags = tport->tp_flags;
1412 ret_serial.xmit_fifo_size = TI_WRITE_BUF_SIZE;
1413 ret_serial.baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800;
1414 ret_serial.closing_wait = tport->tp_closing_wait;
1415
1416 if (copy_to_user(ret_arg, &ret_serial, sizeof(*ret_arg)))
1417 return -EFAULT;
1418
1419 return 0;
1420 }
1421
1422
1423 static int ti_set_serial_info(struct tty_struct *tty, struct ti_port *tport,
1424 struct serial_struct __user *new_arg)
1425 {
1426 struct serial_struct new_serial;
1427
1428 if (copy_from_user(&new_serial, new_arg, sizeof(new_serial)))
1429 return -EFAULT;
1430
1431 tport->tp_flags = new_serial.flags & TI_SET_SERIAL_FLAGS;
1432 tty->low_latency = (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1433 tport->tp_closing_wait = new_serial.closing_wait;
1434
1435 return 0;
1436 }
1437
1438
1439 static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
1440 {
1441 struct async_icount *icount;
1442 struct tty_struct *tty;
1443 unsigned long flags;
1444
1445 dbg("%s - msr 0x%02X", __func__, msr);
1446
1447 if (msr & TI_MSR_DELTA_MASK) {
1448 spin_lock_irqsave(&tport->tp_lock, flags);
1449 icount = &tport->tp_icount;
1450 if (msr & TI_MSR_DELTA_CTS)
1451 icount->cts++;
1452 if (msr & TI_MSR_DELTA_DSR)
1453 icount->dsr++;
1454 if (msr & TI_MSR_DELTA_CD)
1455 icount->dcd++;
1456 if (msr & TI_MSR_DELTA_RI)
1457 icount->rng++;
1458 wake_up_interruptible(&tport->tp_msr_wait);
1459 spin_unlock_irqrestore(&tport->tp_lock, flags);
1460 }
1461
1462 tport->tp_msr = msr & TI_MSR_MASK;
1463
1464 /* handle CTS flow control */
1465 tty = tty_port_tty_get(&tport->tp_port->port);
1466 if (tty && C_CRTSCTS(tty)) {
1467 if (msr & TI_MSR_CTS) {
1468 tty->hw_stopped = 0;
1469 tty_wakeup(tty);
1470 } else {
1471 tty->hw_stopped = 1;
1472 }
1473 }
1474 tty_kref_put(tty);
1475 }
1476
1477
1478 static void ti_drain(struct ti_port *tport, unsigned long timeout, int flush)
1479 {
1480 struct ti_device *tdev = tport->tp_tdev;
1481 struct usb_serial_port *port = tport->tp_port;
1482 wait_queue_t wait;
1483
1484 dbg("%s - port %d", __func__, port->number);
1485
1486 spin_lock_irq(&tport->tp_lock);
1487
1488 /* wait for data to drain from the buffer */
1489 tdev->td_urb_error = 0;
1490 init_waitqueue_entry(&wait, current);
1491 add_wait_queue(&tport->tp_write_wait, &wait);
1492 for (;;) {
1493 set_current_state(TASK_INTERRUPTIBLE);
1494 if (ti_buf_data_avail(tport->tp_write_buf) == 0
1495 || timeout == 0 || signal_pending(current)
1496 || tdev->td_urb_error
1497 || port->serial->disconnected) /* disconnect */
1498 break;
1499 spin_unlock_irq(&tport->tp_lock);
1500 timeout = schedule_timeout(timeout);
1501 spin_lock_irq(&tport->tp_lock);
1502 }
1503 set_current_state(TASK_RUNNING);
1504 remove_wait_queue(&tport->tp_write_wait, &wait);
1505
1506 /* flush any remaining data in the buffer */
1507 if (flush)
1508 ti_buf_clear(tport->tp_write_buf);
1509
1510 spin_unlock_irq(&tport->tp_lock);
1511
1512 mutex_lock(&port->serial->disc_mutex);
1513 /* wait for data to drain from the device */
1514 /* wait for empty tx register, plus 20 ms */
1515 timeout += jiffies;
1516 tport->tp_lsr &= ~TI_LSR_TX_EMPTY;
1517 while ((long)(jiffies - timeout) < 0 && !signal_pending(current)
1518 && !(tport->tp_lsr&TI_LSR_TX_EMPTY) && !tdev->td_urb_error
1519 && !port->serial->disconnected) {
1520 if (ti_get_lsr(tport))
1521 break;
1522 mutex_unlock(&port->serial->disc_mutex);
1523 msleep_interruptible(20);
1524 mutex_lock(&port->serial->disc_mutex);
1525 }
1526 mutex_unlock(&port->serial->disc_mutex);
1527 }
1528
1529
1530 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty)
1531 {
1532 unsigned long flags;
1533
1534 spin_lock_irqsave(&tport->tp_lock, flags);
1535
1536 if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1537 tport->tp_read_urb_state = TI_READ_URB_STOPPING;
1538
1539 spin_unlock_irqrestore(&tport->tp_lock, flags);
1540 }
1541
1542
1543 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
1544 {
1545 struct urb *urb;
1546 int status = 0;
1547 unsigned long flags;
1548
1549 spin_lock_irqsave(&tport->tp_lock, flags);
1550
1551 if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
1552 tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1553 urb = tport->tp_port->read_urb;
1554 spin_unlock_irqrestore(&tport->tp_lock, flags);
1555 urb->complete = ti_bulk_in_callback;
1556 urb->context = tport;
1557 urb->dev = tport->tp_port->serial->dev;
1558 status = usb_submit_urb(urb, GFP_KERNEL);
1559 } else {
1560 tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1561 spin_unlock_irqrestore(&tport->tp_lock, flags);
1562 }
1563
1564 return status;
1565 }
1566
1567
1568 static int ti_command_out_sync(struct ti_device *tdev, __u8 command,
1569 __u16 moduleid, __u16 value, __u8 *data, int size)
1570 {
1571 int status;
1572
1573 status = usb_control_msg(tdev->td_serial->dev,
1574 usb_sndctrlpipe(tdev->td_serial->dev, 0), command,
1575 (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT),
1576 value, moduleid, data, size, 1000);
1577
1578 if (status == size)
1579 status = 0;
1580
1581 if (status > 0)
1582 status = -ECOMM;
1583
1584 return status;
1585 }
1586
1587
1588 static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
1589 __u16 moduleid, __u16 value, __u8 *data, int size)
1590 {
1591 int status;
1592
1593 status = usb_control_msg(tdev->td_serial->dev,
1594 usb_rcvctrlpipe(tdev->td_serial->dev, 0), command,
1595 (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN),
1596 value, moduleid, data, size, 1000);
1597
1598 if (status == size)
1599 status = 0;
1600
1601 if (status > 0)
1602 status = -ECOMM;
1603
1604 return status;
1605 }
1606
1607
1608 static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
1609 __u8 mask, __u8 byte)
1610 {
1611 int status;
1612 unsigned int size;
1613 struct ti_write_data_bytes *data;
1614 struct device *dev = &tdev->td_serial->dev->dev;
1615
1616 dbg("%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X",
1617 __func__, addr, mask, byte);
1618
1619 size = sizeof(struct ti_write_data_bytes) + 2;
1620 data = kmalloc(size, GFP_KERNEL);
1621 if (!data) {
1622 dev_err(dev, "%s - out of memory\n", __func__);
1623 return -ENOMEM;
1624 }
1625
1626 data->bAddrType = TI_RW_DATA_ADDR_XDATA;
1627 data->bDataType = TI_RW_DATA_BYTE;
1628 data->bDataCounter = 1;
1629 data->wBaseAddrHi = cpu_to_be16(addr>>16);
1630 data->wBaseAddrLo = cpu_to_be16(addr);
1631 data->bData[0] = mask;
1632 data->bData[1] = byte;
1633
1634 status = ti_command_out_sync(tdev, TI_WRITE_DATA, TI_RAM_PORT, 0,
1635 (__u8 *)data, size);
1636
1637 if (status < 0)
1638 dev_err(dev, "%s - failed, %d\n", __func__, status);
1639
1640 kfree(data);
1641
1642 return status;
1643 }
1644
1645 static int ti_do_download(struct usb_device *dev, int pipe,
1646 u8 *buffer, int size)
1647 {
1648 int pos;
1649 u8 cs = 0;
1650 int done;
1651 struct ti_firmware_header *header;
1652 int status;
1653 int len;
1654
1655 for (pos = sizeof(struct ti_firmware_header); pos < size; pos++)
1656 cs = (__u8)(cs + buffer[pos]);
1657
1658 header = (struct ti_firmware_header *)buffer;
1659 header->wLength = cpu_to_le16((__u16)(size
1660 - sizeof(struct ti_firmware_header)));
1661 header->bCheckSum = cs;
1662
1663 dbg("%s - downloading firmware", __func__);
1664 for (pos = 0; pos < size; pos += done) {
1665 len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
1666 status = usb_bulk_msg(dev, pipe, buffer + pos, len,
1667 &done, 1000);
1668 if (status)
1669 break;
1670 }
1671 return status;
1672 }
1673
1674 static int ti_download_firmware(struct ti_device *tdev, int type)
1675 {
1676 int status = -ENOMEM;
1677 int buffer_size;
1678 __u8 *buffer;
1679 struct usb_device *dev = tdev->td_serial->dev;
1680 unsigned int pipe = usb_sndbulkpipe(dev,
1681 tdev->td_serial->port[0]->bulk_out_endpointAddress);
1682 const struct firmware *fw_p;
1683 char buf[32];
1684 sprintf(buf, "ti_usb-%d.bin", type);
1685
1686 if (request_firmware(&fw_p, buf, &dev->dev)) {
1687 dev_err(&dev->dev, "%s - firmware not found\n", __func__);
1688 return -ENOENT;
1689 }
1690 if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
1691 dev_err(&dev->dev, "%s - firmware too large\n", __func__);
1692 return -ENOENT;
1693 }
1694
1695 buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
1696 buffer = kmalloc(buffer_size, GFP_KERNEL);
1697 if (buffer) {
1698 memcpy(buffer, fw_p->data, fw_p->size);
1699 memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
1700 status = ti_do_download(dev, pipe, buffer, fw_p->size);
1701 kfree(buffer);
1702 }
1703 release_firmware(fw_p);
1704 if (status) {
1705 dev_err(&dev->dev, "%s - error downloading firmware, %d\n",
1706 __func__, status);
1707 return status;
1708 }
1709
1710 dbg("%s - download successful", __func__);
1711
1712 return 0;
1713 }
1714
1715
1716 /* Circular Buffer Functions */
1717
1718 /*
1719 * ti_buf_alloc
1720 *
1721 * Allocate a circular buffer and all associated memory.
1722 */
1723
1724 static struct circ_buf *ti_buf_alloc(void)
1725 {
1726 struct circ_buf *cb;
1727
1728 cb = kmalloc(sizeof(struct circ_buf), GFP_KERNEL);
1729 if (cb == NULL)
1730 return NULL;
1731
1732 cb->buf = kmalloc(TI_WRITE_BUF_SIZE, GFP_KERNEL);
1733 if (cb->buf == NULL) {
1734 kfree(cb);
1735 return NULL;
1736 }
1737
1738 ti_buf_clear(cb);
1739
1740 return cb;
1741 }
1742
1743
1744 /*
1745 * ti_buf_free
1746 *
1747 * Free the buffer and all associated memory.
1748 */
1749
1750 static void ti_buf_free(struct circ_buf *cb)
1751 {
1752 kfree(cb->buf);
1753 kfree(cb);
1754 }
1755
1756
1757 /*
1758 * ti_buf_clear
1759 *
1760 * Clear out all data in the circular buffer.
1761 */
1762
1763 static void ti_buf_clear(struct circ_buf *cb)
1764 {
1765 cb->head = cb->tail = 0;
1766 }
1767
1768
1769 /*
1770 * ti_buf_data_avail
1771 *
1772 * Return the number of bytes of data available in the circular
1773 * buffer.
1774 */
1775
1776 static int ti_buf_data_avail(struct circ_buf *cb)
1777 {
1778 return CIRC_CNT(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
1779 }
1780
1781
1782 /*
1783 * ti_buf_space_avail
1784 *
1785 * Return the number of bytes of space available in the circular
1786 * buffer.
1787 */
1788
1789 static int ti_buf_space_avail(struct circ_buf *cb)
1790 {
1791 return CIRC_SPACE(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
1792 }
1793
1794
1795 /*
1796 * ti_buf_put
1797 *
1798 * Copy data data from a user buffer and put it into the circular buffer.
1799 * Restrict to the amount of space available.
1800 *
1801 * Return the number of bytes copied.
1802 */
1803
1804 static int ti_buf_put(struct circ_buf *cb, const char *buf, int count)
1805 {
1806 int c, ret = 0;
1807
1808 while (1) {
1809 c = CIRC_SPACE_TO_END(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
1810 if (count < c)
1811 c = count;
1812 if (c <= 0)
1813 break;
1814 memcpy(cb->buf + cb->head, buf, c);
1815 cb->head = (cb->head + c) & (TI_WRITE_BUF_SIZE-1);
1816 buf += c;
1817 count -= c;
1818 ret += c;
1819 }
1820
1821 return ret;
1822 }
1823
1824
1825 /*
1826 * ti_buf_get
1827 *
1828 * Get data from the circular buffer and copy to the given buffer.
1829 * Restrict to the amount of data available.
1830 *
1831 * Return the number of bytes copied.
1832 */
1833
1834 static int ti_buf_get(struct circ_buf *cb, char *buf, int count)
1835 {
1836 int c, ret = 0;
1837
1838 while (1) {
1839 c = CIRC_CNT_TO_END(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
1840 if (count < c)
1841 c = count;
1842 if (c <= 0)
1843 break;
1844 memcpy(buf, cb->buf + cb->tail, c);
1845 cb->tail = (cb->tail + c) & (TI_WRITE_BUF_SIZE-1);
1846 buf += c;
1847 count -= c;
1848 ret += c;
1849 }
1850
1851 return ret;
1852 }
Linux kernel - Deliverables
This page took 0.06586 seconds and 4 git commands to generate.