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