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