Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
io_ti.c
Go to the documentation of this file.
1 /*
2  * Edgeport USB Serial Converter driver
3  *
4  * Copyright (C) 2000-2002 Inside Out Networks, All rights reserved.
5  * Copyright (C) 2001-2002 Greg Kroah-Hartman <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * Supports the following devices:
13  * EP/1 EP/2 EP/4 EP/21 EP/22 EP/221 EP/42 EP/421 WATCHPORT
14  *
15  * For questions or problems with this driver, contact Inside Out
16  * Networks technical support, or Peter Berger <[email protected]>,
17  * or Al Borchers <[email protected]>.
18  */
19 
20 #include <linux/kernel.h>
21 #include <linux/jiffies.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/tty.h>
26 #include <linux/tty_driver.h>
27 #include <linux/tty_flip.h>
28 #include <linux/module.h>
29 #include <linux/spinlock.h>
30 #include <linux/mutex.h>
31 #include <linux/serial.h>
32 #include <linux/kfifo.h>
33 #include <linux/ioctl.h>
34 #include <linux/firmware.h>
35 #include <linux/uaccess.h>
36 #include <linux/usb.h>
37 #include <linux/usb/serial.h>
38 
39 #include "io_16654.h"
40 #include "io_usbvend.h"
41 #include "io_ti.h"
42 
43 /*
44  * Version Information
45  */
46 #define DRIVER_VERSION "v0.7mode043006"
47 #define DRIVER_AUTHOR "Greg Kroah-Hartman <[email protected]> and David Iacovelli"
48 #define DRIVER_DESC "Edgeport USB Serial Driver"
49 
50 #define EPROM_PAGE_SIZE 64
51 
52 
53 /* different hardware types */
54 #define HARDWARE_TYPE_930 0
55 #define HARDWARE_TYPE_TIUMP 1
56 
57 /* IOCTL_PRIVATE_TI_GET_MODE Definitions */
58 #define TI_MODE_CONFIGURING 0 /* Device has not entered start device */
59 #define TI_MODE_BOOT 1 /* Staying in boot mode */
60 #define TI_MODE_DOWNLOAD 2 /* Made it to download mode */
61 #define TI_MODE_TRANSITIONING 3 /* Currently in boot mode but
62  transitioning to download mode */
63 
64 /* read urb state */
65 #define EDGE_READ_URB_RUNNING 0
66 #define EDGE_READ_URB_STOPPING 1
67 #define EDGE_READ_URB_STOPPED 2
68 
69 #define EDGE_CLOSING_WAIT 4000 /* in .01 sec */
70 
71 #define EDGE_OUT_BUF_SIZE 1024
72 
73 
74 /* Product information read from the Edgeport */
75 struct product_info {
76  int TiMode; /* Current TI Mode */
77  __u8 hardware_type; /* Type of hardware */
78 } __attribute__((packed));
79 
80 struct edgeport_port {
81  __u16 uart_base;
82  __u16 dma_address;
83  __u8 shadow_msr;
84  __u8 shadow_mcr;
85  __u8 shadow_lsr;
86  __u8 lsr_mask;
87  __u32 ump_read_timeout; /* Number of milliseconds the UMP will
88  wait without data before completing
89  a read short */
90  int baud_rate;
91  int close_pending;
92  int lsr_event;
93  struct async_icount icount;
94  wait_queue_head_t delta_msr_wait; /* for handling sleeping while
95  waiting for msr change to
96  happen */
97  struct edgeport_serial *edge_serial;
98  struct usb_serial_port *port;
99  __u8 bUartMode; /* Port type, 0: RS232, etc. */
100  spinlock_t ep_lock;
101  int ep_read_urb_state;
102  int ep_write_urb_in_use;
103  struct kfifo write_fifo;
104 };
105 
106 struct edgeport_serial {
107  struct product_info product_info;
108  u8 TI_I2C_Type; /* Type of I2C in UMP */
109  u8 TiReadI2C; /* Set to TRUE if we have read the
110  I2c in Boot Mode */
111  struct mutex es_lock;
112  int num_ports_open;
113  struct usb_serial *serial;
114 };
115 
116 
117 /* Devices that this driver supports */
118 static const struct usb_device_id edgeport_1port_id_table[] = {
119  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
120  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
121  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
122  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
123  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
124  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
125  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
126  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
127  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
128  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
129  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
130  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
131  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
132  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
133  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
134  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
135  { }
136 };
137 
138 static const struct usb_device_id edgeport_2port_id_table[] = {
139  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
140  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
141  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
142  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
143  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
144  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
145  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
146  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
147  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
148  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
149  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
150  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
151  /* The 4, 8 and 16 port devices show up as multiple 2 port devices */
152  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
153  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
154  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
155  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
156  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
157  { }
158 };
159 
160 /* Devices that this driver supports */
161 static const struct usb_device_id id_table_combined[] = {
162  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
163  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
164  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
165  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
166  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
167  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
168  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
169  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
170  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
171  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
172  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
173  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
174  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
175  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
176  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
177  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
178  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
179  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
180  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
181  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
182  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
183  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
184  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
185  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
186  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
187  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
188  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
189  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
190  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
191  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
192  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
193  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
194  { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
195  { }
196 };
197 
198 MODULE_DEVICE_TABLE(usb, id_table_combined);
199 
200 static unsigned char OperationalMajorVersion;
201 static unsigned char OperationalMinorVersion;
202 static unsigned short OperationalBuildNumber;
203 
204 static int closing_wait = EDGE_CLOSING_WAIT;
205 static bool ignore_cpu_rev;
206 static int default_uart_mode; /* RS232 */
207 
208 static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
209  unsigned char *data, int length);
210 
211 static void stop_read(struct edgeport_port *edge_port);
212 static int restart_read(struct edgeport_port *edge_port);
213 
214 static void edge_set_termios(struct tty_struct *tty,
215  struct usb_serial_port *port, struct ktermios *old_termios);
216 static void edge_send(struct tty_struct *tty);
217 
218 /* sysfs attributes */
219 static int edge_create_sysfs_attrs(struct usb_serial_port *port);
220 static int edge_remove_sysfs_attrs(struct usb_serial_port *port);
221 
222 
223 static int ti_vread_sync(struct usb_device *dev, __u8 request,
224  __u16 value, __u16 index, u8 *data, int size)
225 {
226  int status;
227 
228  status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
229  (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN),
230  value, index, data, size, 1000);
231  if (status < 0)
232  return status;
233  if (status != size) {
234  dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
235  __func__, size, status);
236  return -ECOMM;
237  }
238  return 0;
239 }
240 
241 static int ti_vsend_sync(struct usb_device *dev, __u8 request,
242  __u16 value, __u16 index, u8 *data, int size)
243 {
244  int status;
245 
246  status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
247  (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT),
248  value, index, data, size, 1000);
249  if (status < 0)
250  return status;
251  if (status != size) {
252  dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
253  __func__, size, status);
254  return -ECOMM;
255  }
256  return 0;
257 }
258 
259 static int send_cmd(struct usb_device *dev, __u8 command,
260  __u8 moduleid, __u16 value, u8 *data,
261  int size)
262 {
263  return ti_vsend_sync(dev, command, value, moduleid, data, size);
264 }
265 
266 /* clear tx/rx buffers and fifo in TI UMP */
267 static int purge_port(struct usb_serial_port *port, __u16 mask)
268 {
269  int port_number = port->number - port->serial->minor;
270 
271  dev_dbg(&port->dev, "%s - port %d, mask %x\n", __func__, port_number, mask);
272 
273  return send_cmd(port->serial->dev,
274  UMPC_PURGE_PORT,
275  (__u8)(UMPM_UART1_PORT + port_number),
276  mask,
277  NULL,
278  0);
279 }
280 
289 static int read_download_mem(struct usb_device *dev, int start_address,
290  int length, __u8 address_type, __u8 *buffer)
291 {
292  int status = 0;
293  __u8 read_length;
294  __be16 be_start_address;
295 
296  dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, length);
297 
298  /* Read in blocks of 64 bytes
299  * (TI firmware can't handle more than 64 byte reads)
300  */
301  while (length) {
302  if (length > 64)
303  read_length = 64;
304  else
305  read_length = (__u8)length;
306 
307  if (read_length > 1) {
308  dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, read_length);
309  }
310  be_start_address = cpu_to_be16(start_address);
311  status = ti_vread_sync(dev, UMPC_MEMORY_READ,
312  (__u16)address_type,
313  (__force __u16)be_start_address,
314  buffer, read_length);
315 
316  if (status) {
317  dev_dbg(&dev->dev, "%s - ERROR %x\n", __func__, status);
318  return status;
319  }
320 
321  if (read_length > 1)
322  usb_serial_debug_data(&dev->dev, __func__, read_length, buffer);
323 
324  /* Update pointers/length */
325  start_address += read_length;
326  buffer += read_length;
327  length -= read_length;
328  }
329 
330  return status;
331 }
332 
333 static int read_ram(struct usb_device *dev, int start_address,
334  int length, __u8 *buffer)
335 {
336  return read_download_mem(dev, start_address, length,
337  DTK_ADDR_SPACE_XDATA, buffer);
338 }
339 
340 /* Read edgeport memory to a given block */
341 static int read_boot_mem(struct edgeport_serial *serial,
342  int start_address, int length, __u8 *buffer)
343 {
344  int status = 0;
345  int i;
346 
347  for (i = 0; i < length; i++) {
348  status = ti_vread_sync(serial->serial->dev,
349  UMPC_MEMORY_READ, serial->TI_I2C_Type,
350  (__u16)(start_address+i), &buffer[i], 0x01);
351  if (status) {
352  dev_dbg(&serial->serial->dev->dev, "%s - ERROR %x\n", __func__, status);
353  return status;
354  }
355  }
356 
357  dev_dbg(&serial->serial->dev->dev, "%s - start_address = %x, length = %d\n",
358  __func__, start_address, length);
359  usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
360 
361  serial->TiReadI2C = 1;
362 
363  return status;
364 }
365 
366 /* Write given block to TI EPROM memory */
367 static int write_boot_mem(struct edgeport_serial *serial,
368  int start_address, int length, __u8 *buffer)
369 {
370  int status = 0;
371  int i;
372  u8 *temp;
373 
374  /* Must do a read before write */
375  if (!serial->TiReadI2C) {
376  temp = kmalloc(1, GFP_KERNEL);
377  if (!temp) {
378  dev_err(&serial->serial->dev->dev,
379  "%s - out of memory\n", __func__);
380  return -ENOMEM;
381  }
382  status = read_boot_mem(serial, 0, 1, temp);
383  kfree(temp);
384  if (status)
385  return status;
386  }
387 
388  for (i = 0; i < length; ++i) {
389  status = ti_vsend_sync(serial->serial->dev,
390  UMPC_MEMORY_WRITE, buffer[i],
391  (__u16)(i + start_address), NULL, 0);
392  if (status)
393  return status;
394  }
395 
396  dev_dbg(&serial->serial->dev->dev, "%s - start_sddr = %x, length = %d\n", __func__, start_address, length);
397  usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
398 
399  return status;
400 }
401 
402 
403 /* Write edgeport I2C memory to TI chip */
404 static int write_i2c_mem(struct edgeport_serial *serial,
405  int start_address, int length, __u8 address_type, __u8 *buffer)
406 {
407  struct device *dev = &serial->serial->dev->dev;
408  int status = 0;
409  int write_length;
410  __be16 be_start_address;
411 
412  /* We can only send a maximum of 1 aligned byte page at a time */
413 
414  /* calculate the number of bytes left in the first page */
415  write_length = EPROM_PAGE_SIZE -
416  (start_address & (EPROM_PAGE_SIZE - 1));
417 
418  if (write_length > length)
419  write_length = length;
420 
421  dev_dbg(dev, "%s - BytesInFirstPage Addr = %x, length = %d\n",
422  __func__, start_address, write_length);
423  usb_serial_debug_data(dev, __func__, write_length, buffer);
424 
425  /* Write first page */
426  be_start_address = cpu_to_be16(start_address);
427  status = ti_vsend_sync(serial->serial->dev,
428  UMPC_MEMORY_WRITE, (__u16)address_type,
429  (__force __u16)be_start_address,
430  buffer, write_length);
431  if (status) {
432  dev_dbg(dev, "%s - ERROR %d\n", __func__, status);
433  return status;
434  }
435 
436  length -= write_length;
437  start_address += write_length;
438  buffer += write_length;
439 
440  /* We should be aligned now -- can write
441  max page size bytes at a time */
442  while (length) {
443  if (length > EPROM_PAGE_SIZE)
444  write_length = EPROM_PAGE_SIZE;
445  else
446  write_length = length;
447 
448  dev_dbg(dev, "%s - Page Write Addr = %x, length = %d\n",
449  __func__, start_address, write_length);
450  usb_serial_debug_data(dev, __func__, write_length, buffer);
451 
452  /* Write next page */
453  be_start_address = cpu_to_be16(start_address);
454  status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE,
455  (__u16)address_type,
456  (__force __u16)be_start_address,
457  buffer, write_length);
458  if (status) {
459  dev_err(dev, "%s - ERROR %d\n", __func__, status);
460  return status;
461  }
462 
463  length -= write_length;
464  start_address += write_length;
465  buffer += write_length;
466  }
467  return status;
468 }
469 
470 /* Examine the UMP DMA registers and LSR
471  *
472  * Check the MSBit of the X and Y DMA byte count registers.
473  * A zero in this bit indicates that the TX DMA buffers are empty
474  * then check the TX Empty bit in the UART.
475  */
476 static int tx_active(struct edgeport_port *port)
477 {
478  int status;
479  struct out_endpoint_desc_block *oedb;
480  __u8 *lsr;
481  int bytes_left = 0;
482 
483  oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);
484  if (!oedb) {
485  dev_err(&port->port->dev, "%s - out of memory\n", __func__);
486  return -ENOMEM;
487  }
488 
489  lsr = kmalloc(1, GFP_KERNEL); /* Sigh, that's right, just one byte,
490  as not all platforms can do DMA
491  from stack */
492  if (!lsr) {
493  kfree(oedb);
494  return -ENOMEM;
495  }
496  /* Read the DMA Count Registers */
497  status = read_ram(port->port->serial->dev, port->dma_address,
498  sizeof(*oedb), (void *)oedb);
499  if (status)
500  goto exit_is_tx_active;
501 
502  dev_dbg(&port->port->dev, "%s - XByteCount 0x%X\n", __func__, oedb->XByteCount);
503 
504  /* and the LSR */
505  status = read_ram(port->port->serial->dev,
506  port->uart_base + UMPMEM_OFFS_UART_LSR, 1, lsr);
507 
508  if (status)
509  goto exit_is_tx_active;
510  dev_dbg(&port->port->dev, "%s - LSR = 0x%X\n", __func__, *lsr);
511 
512  /* If either buffer has data or we are transmitting then return TRUE */
513  if ((oedb->XByteCount & 0x80) != 0)
514  bytes_left += 64;
515 
516  if ((*lsr & UMP_UART_LSR_TX_MASK) == 0)
517  bytes_left += 1;
518 
519  /* We return Not Active if we get any kind of error */
520 exit_is_tx_active:
521  dev_dbg(&port->port->dev, "%s - return %d\n", __func__, bytes_left);
522 
523  kfree(lsr);
524  kfree(oedb);
525  return bytes_left;
526 }
527 
528 static void chase_port(struct edgeport_port *port, unsigned long timeout,
529  int flush)
530 {
531  int baud_rate;
532  struct tty_struct *tty = tty_port_tty_get(&port->port->port);
533  struct usb_serial *serial = port->port->serial;
534  wait_queue_t wait;
535  unsigned long flags;
536 
537  if (!timeout)
538  timeout = (HZ * EDGE_CLOSING_WAIT)/100;
539 
540  /* wait for data to drain from the buffer */
541  spin_lock_irqsave(&port->ep_lock, flags);
542  init_waitqueue_entry(&wait, current);
543  add_wait_queue(&tty->write_wait, &wait);
544  for (;;) {
545  set_current_state(TASK_INTERRUPTIBLE);
546  if (kfifo_len(&port->write_fifo) == 0
547  || timeout == 0 || signal_pending(current)
548  || serial->disconnected)
549  /* disconnect */
550  break;
551  spin_unlock_irqrestore(&port->ep_lock, flags);
552  timeout = schedule_timeout(timeout);
553  spin_lock_irqsave(&port->ep_lock, flags);
554  }
555  set_current_state(TASK_RUNNING);
556  remove_wait_queue(&tty->write_wait, &wait);
557  if (flush)
558  kfifo_reset_out(&port->write_fifo);
559  spin_unlock_irqrestore(&port->ep_lock, flags);
560  tty_kref_put(tty);
561 
562  /* wait for data to drain from the device */
563  timeout += jiffies;
564  while ((long)(jiffies - timeout) < 0 && !signal_pending(current)
565  && !serial->disconnected) {
566  /* not disconnected */
567  if (!tx_active(port))
568  break;
569  msleep(10);
570  }
571 
572  /* disconnected */
573  if (serial->disconnected)
574  return;
575 
576  /* wait one more character time, based on baud rate */
577  /* (tx_active doesn't seem to wait for the last byte) */
578  baud_rate = port->baud_rate;
579  if (baud_rate == 0)
580  baud_rate = 50;
581  msleep(max(1, DIV_ROUND_UP(10000, baud_rate)));
582 }
583 
584 static int choose_config(struct usb_device *dev)
585 {
586  /*
587  * There may be multiple configurations on this device, in which case
588  * we would need to read and parse all of them to find out which one
589  * we want. However, we just support one config at this point,
590  * configuration # 1, which is Config Descriptor 0.
591  */
592 
593  dev_dbg(&dev->dev, "%s - Number of Interfaces = %d\n",
594  __func__, dev->config->desc.bNumInterfaces);
595  dev_dbg(&dev->dev, "%s - MAX Power = %d\n",
596  __func__, dev->config->desc.bMaxPower * 2);
597 
598  if (dev->config->desc.bNumInterfaces != 1) {
599  dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);
600  return -ENODEV;
601  }
602 
603  return 0;
604 }
605 
606 static int read_rom(struct edgeport_serial *serial,
607  int start_address, int length, __u8 *buffer)
608 {
609  int status;
610 
611  if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
612  status = read_download_mem(serial->serial->dev,
613  start_address,
614  length,
615  serial->TI_I2C_Type,
616  buffer);
617  } else {
618  status = read_boot_mem(serial, start_address, length,
619  buffer);
620  }
621  return status;
622 }
623 
624 static int write_rom(struct edgeport_serial *serial, int start_address,
625  int length, __u8 *buffer)
626 {
627  if (serial->product_info.TiMode == TI_MODE_BOOT)
628  return write_boot_mem(serial, start_address, length,
629  buffer);
630 
631  if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)
632  return write_i2c_mem(serial, start_address, length,
633  serial->TI_I2C_Type, buffer);
634  return -EINVAL;
635 }
636 
637 
638 
639 /* Read a descriptor header from I2C based on type */
640 static int get_descriptor_addr(struct edgeport_serial *serial,
641  int desc_type, struct ti_i2c_desc *rom_desc)
642 {
643  int start_address;
644  int status;
645 
646  /* Search for requested descriptor in I2C */
647  start_address = 2;
648  do {
649  status = read_rom(serial,
650  start_address,
651  sizeof(struct ti_i2c_desc),
652  (__u8 *)rom_desc);
653  if (status)
654  return 0;
655 
656  if (rom_desc->Type == desc_type)
657  return start_address;
658 
659  start_address = start_address + sizeof(struct ti_i2c_desc)
660  + rom_desc->Size;
661 
662  } while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);
663 
664  return 0;
665 }
666 
667 /* Validate descriptor checksum */
668 static int valid_csum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
669 {
670  __u16 i;
671  __u8 cs = 0;
672 
673  for (i = 0; i < rom_desc->Size; i++)
674  cs = (__u8)(cs + buffer[i]);
675 
676  if (cs != rom_desc->CheckSum) {
677  pr_debug("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
678  return -EINVAL;
679  }
680  return 0;
681 }
682 
683 /* Make sure that the I2C image is good */
684 static int check_i2c_image(struct edgeport_serial *serial)
685 {
686  struct device *dev = &serial->serial->dev->dev;
687  int status = 0;
688  struct ti_i2c_desc *rom_desc;
689  int start_address = 2;
690  __u8 *buffer;
691  __u16 ttype;
692 
693  rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
694  if (!rom_desc) {
695  dev_err(dev, "%s - out of memory\n", __func__);
696  return -ENOMEM;
697  }
698  buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);
699  if (!buffer) {
700  dev_err(dev, "%s - out of memory when allocating buffer\n",
701  __func__);
702  kfree(rom_desc);
703  return -ENOMEM;
704  }
705 
706  /* Read the first byte (Signature0) must be 0x52 or 0x10 */
707  status = read_rom(serial, 0, 1, buffer);
708  if (status)
709  goto out;
710 
711  if (*buffer != UMP5152 && *buffer != UMP3410) {
712  dev_err(dev, "%s - invalid buffer signature\n", __func__);
713  status = -ENODEV;
714  goto out;
715  }
716 
717  do {
718  /* Validate the I2C */
719  status = read_rom(serial,
720  start_address,
721  sizeof(struct ti_i2c_desc),
722  (__u8 *)rom_desc);
723  if (status)
724  break;
725 
726  if ((start_address + sizeof(struct ti_i2c_desc) +
727  rom_desc->Size) > TI_MAX_I2C_SIZE) {
728  status = -ENODEV;
729  dev_dbg(dev, "%s - structure too big, erroring out.\n", __func__);
730  break;
731  }
732 
733  dev_dbg(dev, "%s Type = 0x%x\n", __func__, rom_desc->Type);
734 
735  /* Skip type 2 record */
736  ttype = rom_desc->Type & 0x0f;
737  if (ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
738  && ttype != I2C_DESC_TYPE_FIRMWARE_AUTO) {
739  /* Read the descriptor data */
740  status = read_rom(serial, start_address +
741  sizeof(struct ti_i2c_desc),
742  rom_desc->Size, buffer);
743  if (status)
744  break;
745 
746  status = valid_csum(rom_desc, buffer);
747  if (status)
748  break;
749  }
750  start_address = start_address + sizeof(struct ti_i2c_desc) +
751  rom_desc->Size;
752 
753  } while ((rom_desc->Type != I2C_DESC_TYPE_ION) &&
754  (start_address < TI_MAX_I2C_SIZE));
755 
756  if ((rom_desc->Type != I2C_DESC_TYPE_ION) ||
757  (start_address > TI_MAX_I2C_SIZE))
758  status = -ENODEV;
759 
760 out:
761  kfree(buffer);
762  kfree(rom_desc);
763  return status;
764 }
765 
766 static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
767 {
768  int status;
769  int start_address;
770  struct ti_i2c_desc *rom_desc;
771  struct edge_ti_manuf_descriptor *desc;
772  struct device *dev = &serial->serial->dev->dev;
773 
774  rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
775  if (!rom_desc) {
776  dev_err(dev, "%s - out of memory\n", __func__);
777  return -ENOMEM;
778  }
779  start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
780  rom_desc);
781 
782  if (!start_address) {
783  dev_dbg(dev, "%s - Edge Descriptor not found in I2C\n", __func__);
784  status = -ENODEV;
785  goto exit;
786  }
787 
788  /* Read the descriptor data */
789  status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc),
790  rom_desc->Size, buffer);
791  if (status)
792  goto exit;
793 
794  status = valid_csum(rom_desc, buffer);
795 
796  desc = (struct edge_ti_manuf_descriptor *)buffer;
797  dev_dbg(dev, "%s - IonConfig 0x%x\n", __func__, desc->IonConfig);
798  dev_dbg(dev, "%s - Version %d\n", __func__, desc->Version);
799  dev_dbg(dev, "%s - Cpu/Board 0x%x\n", __func__, desc->CpuRev_BoardRev);
800  dev_dbg(dev, "%s - NumPorts %d\n", __func__, desc->NumPorts);
801  dev_dbg(dev, "%s - NumVirtualPorts %d\n", __func__, desc->NumVirtualPorts);
802  dev_dbg(dev, "%s - TotalPorts %d\n", __func__, desc->TotalPorts);
803 
804 exit:
805  kfree(rom_desc);
806  return status;
807 }
808 
809 /* Build firmware header used for firmware update */
810 static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
811 {
812  __u8 *buffer;
813  int buffer_size;
814  int i;
815  int err;
816  __u8 cs = 0;
817  struct ti_i2c_desc *i2c_header;
818  struct ti_i2c_image_header *img_header;
819  struct ti_i2c_firmware_rec *firmware_rec;
820  const struct firmware *fw;
821  const char *fw_name = "edgeport/down3.bin";
822 
823  /* In order to update the I2C firmware we must change the type 2 record
824  * to type 0xF2. This will force the UMP to come up in Boot Mode.
825  * Then while in boot mode, the driver will download the latest
826  * firmware (padded to 15.5k) into the UMP ram. And finally when the
827  * device comes back up in download mode the driver will cause the new
828  * firmware to be copied from the UMP Ram to I2C and the firmware will
829  * update the record type from 0xf2 to 0x02.
830  */
831 
832  /* Allocate a 15.5k buffer + 2 bytes for version number
833  * (Firmware Record) */
834  buffer_size = (((1024 * 16) - 512 ) +
835  sizeof(struct ti_i2c_firmware_rec));
836 
837  buffer = kmalloc(buffer_size, GFP_KERNEL);
838  if (!buffer) {
839  dev_err(dev, "%s - out of memory\n", __func__);
840  return -ENOMEM;
841  }
842 
843  // Set entire image of 0xffs
844  memset(buffer, 0xff, buffer_size);
845 
846  err = request_firmware(&fw, fw_name, dev);
847  if (err) {
848  dev_err(dev, "Failed to load image \"%s\" err %d\n",
849  fw_name, err);
850  kfree(buffer);
851  return err;
852  }
853 
854  /* Save Download Version Number */
855  OperationalMajorVersion = fw->data[0];
856  OperationalMinorVersion = fw->data[1];
857  OperationalBuildNumber = fw->data[2] | (fw->data[3] << 8);
858 
859  /* Copy version number into firmware record */
860  firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
861 
862  firmware_rec->Ver_Major = OperationalMajorVersion;
863  firmware_rec->Ver_Minor = OperationalMinorVersion;
864 
865  /* Pointer to fw_down memory image */
866  img_header = (struct ti_i2c_image_header *)&fw->data[4];
867 
868  memcpy(buffer + sizeof(struct ti_i2c_firmware_rec),
869  &fw->data[4 + sizeof(struct ti_i2c_image_header)],
870  le16_to_cpu(img_header->Length));
871 
872  release_firmware(fw);
873 
874  for (i=0; i < buffer_size; i++) {
875  cs = (__u8)(cs + buffer[i]);
876  }
877 
878  kfree(buffer);
879 
880  /* Build new header */
881  i2c_header = (struct ti_i2c_desc *)header;
882  firmware_rec = (struct ti_i2c_firmware_rec*)i2c_header->Data;
883 
884  i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK;
885  i2c_header->Size = (__u16)buffer_size;
886  i2c_header->CheckSum = cs;
887  firmware_rec->Ver_Major = OperationalMajorVersion;
888  firmware_rec->Ver_Minor = OperationalMinorVersion;
889 
890  return 0;
891 }
892 
893 /* Try to figure out what type of I2c we have */
894 static int i2c_type_bootmode(struct edgeport_serial *serial)
895 {
896  struct device *dev = &serial->serial->dev->dev;
897  int status;
898  u8 *data;
899 
900  data = kmalloc(1, GFP_KERNEL);
901  if (!data) {
902  dev_err(dev, "%s - out of memory\n", __func__);
903  return -ENOMEM;
904  }
905 
906  /* Try to read type 2 */
907  status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
908  DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);
909  if (status)
910  dev_dbg(dev, "%s - read 2 status error = %d\n", __func__, status);
911  else
912  dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
913  if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
914  dev_dbg(dev, "%s - ROM_TYPE_II\n", __func__);
915  serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
916  goto out;
917  }
918 
919  /* Try to read type 3 */
920  status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
921  DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);
922  if (status)
923  dev_dbg(dev, "%s - read 3 status error = %d\n", __func__, status);
924  else
925  dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
926  if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
927  dev_dbg(dev, "%s - ROM_TYPE_III\n", __func__);
928  serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
929  goto out;
930  }
931 
932  dev_dbg(dev, "%s - Unknown\n", __func__);
933  serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
934  status = -ENODEV;
935 out:
936  kfree(data);
937  return status;
938 }
939 
940 static int bulk_xfer(struct usb_serial *serial, void *buffer,
941  int length, int *num_sent)
942 {
943  int status;
944 
945  status = usb_bulk_msg(serial->dev,
946  usb_sndbulkpipe(serial->dev,
947  serial->port[0]->bulk_out_endpointAddress),
948  buffer, length, num_sent, 1000);
949  return status;
950 }
951 
952 /* Download given firmware image to the device (IN BOOT MODE) */
953 static int download_code(struct edgeport_serial *serial, __u8 *image,
954  int image_length)
955 {
956  int status = 0;
957  int pos;
958  int transfer;
959  int done;
960 
961  /* Transfer firmware image */
962  for (pos = 0; pos < image_length; ) {
963  /* Read the next buffer from file */
964  transfer = image_length - pos;
965  if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)
966  transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;
967 
968  /* Transfer data */
969  status = bulk_xfer(serial->serial, &image[pos],
970  transfer, &done);
971  if (status)
972  break;
973  /* Advance buffer pointer */
974  pos += done;
975  }
976 
977  return status;
978 }
979 
980 /* FIXME!!! */
981 static int config_boot_dev(struct usb_device *dev)
982 {
983  return 0;
984 }
985 
986 static int ti_cpu_rev(struct edge_ti_manuf_descriptor *desc)
987 {
988  return TI_GET_CPU_REVISION(desc->CpuRev_BoardRev);
989 }
990 
997 static int download_fw(struct edgeport_serial *serial)
998 {
999  struct device *dev = &serial->serial->dev->dev;
1000  int status = 0;
1001  int start_address;
1002  struct edge_ti_manuf_descriptor *ti_manuf_desc;
1003  struct usb_interface_descriptor *interface;
1004  int download_cur_ver;
1005  int download_new_ver;
1006 
1007  /* This routine is entered by both the BOOT mode and the Download mode
1008  * We can determine which code is running by the reading the config
1009  * descriptor and if we have only one bulk pipe it is in boot mode
1010  */
1011  serial->product_info.hardware_type = HARDWARE_TYPE_TIUMP;
1012 
1013  /* Default to type 2 i2c */
1014  serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1015 
1016  status = choose_config(serial->serial->dev);
1017  if (status)
1018  return status;
1019 
1020  interface = &serial->serial->interface->cur_altsetting->desc;
1021  if (!interface) {
1022  dev_err(dev, "%s - no interface set, error!\n", __func__);
1023  return -ENODEV;
1024  }
1025 
1026  /*
1027  * Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
1028  * if we have more than one endpoint we are definitely in download
1029  * mode
1030  */
1031  if (interface->bNumEndpoints > 1)
1032  serial->product_info.TiMode = TI_MODE_DOWNLOAD;
1033  else
1034  /* Otherwise we will remain in configuring mode */
1035  serial->product_info.TiMode = TI_MODE_CONFIGURING;
1036 
1037  /********************************************************************/
1038  /* Download Mode */
1039  /********************************************************************/
1040  if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
1041  struct ti_i2c_desc *rom_desc;
1042 
1043  dev_dbg(dev, "%s - RUNNING IN DOWNLOAD MODE\n", __func__);
1044 
1045  status = check_i2c_image(serial);
1046  if (status) {
1047  dev_dbg(dev, "%s - DOWNLOAD MODE -- BAD I2C\n", __func__);
1048  return status;
1049  }
1050 
1051  /* Validate Hardware version number
1052  * Read Manufacturing Descriptor from TI Based Edgeport
1053  */
1054  ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
1055  if (!ti_manuf_desc) {
1056  dev_err(dev, "%s - out of memory.\n", __func__);
1057  return -ENOMEM;
1058  }
1059  status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
1060  if (status) {
1061  kfree(ti_manuf_desc);
1062  return status;
1063  }
1064 
1065  /* Check version number of ION descriptor */
1066  if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1067  dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1068  __func__, ti_cpu_rev(ti_manuf_desc));
1069  kfree(ti_manuf_desc);
1070  return -EINVAL;
1071  }
1072 
1073  rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
1074  if (!rom_desc) {
1075  dev_err(dev, "%s - out of memory.\n", __func__);
1076  kfree(ti_manuf_desc);
1077  return -ENOMEM;
1078  }
1079 
1080  /* Search for type 2 record (firmware record) */
1081  start_address = get_descriptor_addr(serial,
1082  I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);
1083  if (start_address != 0) {
1084  struct ti_i2c_firmware_rec *firmware_version;
1085  u8 *record;
1086 
1087  dev_dbg(dev, "%s - Found Type FIRMWARE (Type 2) record\n", __func__);
1088 
1089  firmware_version = kmalloc(sizeof(*firmware_version),
1090  GFP_KERNEL);
1091  if (!firmware_version) {
1092  dev_err(dev, "%s - out of memory.\n", __func__);
1093  kfree(rom_desc);
1094  kfree(ti_manuf_desc);
1095  return -ENOMEM;
1096  }
1097 
1098  /* Validate version number
1099  * Read the descriptor data
1100  */
1101  status = read_rom(serial, start_address +
1102  sizeof(struct ti_i2c_desc),
1103  sizeof(struct ti_i2c_firmware_rec),
1104  (__u8 *)firmware_version);
1105  if (status) {
1106  kfree(firmware_version);
1107  kfree(rom_desc);
1108  kfree(ti_manuf_desc);
1109  return status;
1110  }
1111 
1112  /* Check version number of download with current
1113  version in I2c */
1114  download_cur_ver = (firmware_version->Ver_Major << 8) +
1115  (firmware_version->Ver_Minor);
1116  download_new_ver = (OperationalMajorVersion << 8) +
1117  (OperationalMinorVersion);
1118 
1119  dev_dbg(dev, "%s - >> FW Versions Device %d.%d Driver %d.%d\n",
1120  __func__, firmware_version->Ver_Major,
1121  firmware_version->Ver_Minor,
1122  OperationalMajorVersion,
1123  OperationalMinorVersion);
1124 
1125  /* Check if we have an old version in the I2C and
1126  update if necessary */
1127  if (download_cur_ver < download_new_ver) {
1128  dev_dbg(dev, "%s - Update I2C dld from %d.%d to %d.%d\n",
1129  __func__,
1130  firmware_version->Ver_Major,
1131  firmware_version->Ver_Minor,
1132  OperationalMajorVersion,
1133  OperationalMinorVersion);
1134 
1135  record = kmalloc(1, GFP_KERNEL);
1136  if (!record) {
1137  dev_err(dev, "%s - out of memory.\n",
1138  __func__);
1139  kfree(firmware_version);
1140  kfree(rom_desc);
1141  kfree(ti_manuf_desc);
1142  return -ENOMEM;
1143  }
1144  /* In order to update the I2C firmware we must
1145  * change the type 2 record to type 0xF2. This
1146  * will force the UMP to come up in Boot Mode.
1147  * Then while in boot mode, the driver will
1148  * download the latest firmware (padded to
1149  * 15.5k) into the UMP ram. Finally when the
1150  * device comes back up in download mode the
1151  * driver will cause the new firmware to be
1152  * copied from the UMP Ram to I2C and the
1153  * firmware will update the record type from
1154  * 0xf2 to 0x02.
1155  */
1156  *record = I2C_DESC_TYPE_FIRMWARE_BLANK;
1157 
1158  /* Change the I2C Firmware record type to
1159  0xf2 to trigger an update */
1160  status = write_rom(serial, start_address,
1161  sizeof(*record), record);
1162  if (status) {
1163  kfree(record);
1164  kfree(firmware_version);
1165  kfree(rom_desc);
1166  kfree(ti_manuf_desc);
1167  return status;
1168  }
1169 
1170  /* verify the write -- must do this in order
1171  * for write to complete before we do the
1172  * hardware reset
1173  */
1174  status = read_rom(serial,
1175  start_address,
1176  sizeof(*record),
1177  record);
1178  if (status) {
1179  kfree(record);
1180  kfree(firmware_version);
1181  kfree(rom_desc);
1182  kfree(ti_manuf_desc);
1183  return status;
1184  }
1185 
1186  if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
1187  dev_err(dev, "%s - error resetting device\n", __func__);
1188  kfree(record);
1189  kfree(firmware_version);
1190  kfree(rom_desc);
1191  kfree(ti_manuf_desc);
1192  return -ENODEV;
1193  }
1194 
1195  dev_dbg(dev, "%s - HARDWARE RESET\n", __func__);
1196 
1197  /* Reset UMP -- Back to BOOT MODE */
1198  status = ti_vsend_sync(serial->serial->dev,
1199  UMPC_HARDWARE_RESET,
1200  0, 0, NULL, 0);
1201 
1202  dev_dbg(dev, "%s - HARDWARE RESET return %d\n", __func__, status);
1203 
1204  /* return an error on purpose. */
1205  kfree(record);
1206  kfree(firmware_version);
1207  kfree(rom_desc);
1208  kfree(ti_manuf_desc);
1209  return -ENODEV;
1210  }
1211  kfree(firmware_version);
1212  }
1213  /* Search for type 0xF2 record (firmware blank record) */
1214  else if ((start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
1215 #define HEADER_SIZE (sizeof(struct ti_i2c_desc) + \
1216  sizeof(struct ti_i2c_firmware_rec))
1217  __u8 *header;
1218  __u8 *vheader;
1219 
1220  header = kmalloc(HEADER_SIZE, GFP_KERNEL);
1221  if (!header) {
1222  dev_err(dev, "%s - out of memory.\n", __func__);
1223  kfree(rom_desc);
1224  kfree(ti_manuf_desc);
1225  return -ENOMEM;
1226  }
1227 
1228  vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);
1229  if (!vheader) {
1230  dev_err(dev, "%s - out of memory.\n", __func__);
1231  kfree(header);
1232  kfree(rom_desc);
1233  kfree(ti_manuf_desc);
1234  return -ENOMEM;
1235  }
1236 
1237  dev_dbg(dev, "%s - Found Type BLANK FIRMWARE (Type F2) record\n", __func__);
1238 
1239  /*
1240  * In order to update the I2C firmware we must change
1241  * the type 2 record to type 0xF2. This will force the
1242  * UMP to come up in Boot Mode. Then while in boot
1243  * mode, the driver will download the latest firmware
1244  * (padded to 15.5k) into the UMP ram. Finally when the
1245  * device comes back up in download mode the driver
1246  * will cause the new firmware to be copied from the
1247  * UMP Ram to I2C and the firmware will update the
1248  * record type from 0xf2 to 0x02.
1249  */
1250  status = build_i2c_fw_hdr(header, dev);
1251  if (status) {
1252  kfree(vheader);
1253  kfree(header);
1254  kfree(rom_desc);
1255  kfree(ti_manuf_desc);
1256  return -EINVAL;
1257  }
1258 
1259  /* Update I2C with type 0xf2 record with correct
1260  size and checksum */
1261  status = write_rom(serial,
1262  start_address,
1263  HEADER_SIZE,
1264  header);
1265  if (status) {
1266  kfree(vheader);
1267  kfree(header);
1268  kfree(rom_desc);
1269  kfree(ti_manuf_desc);
1270  return -EINVAL;
1271  }
1272 
1273  /* verify the write -- must do this in order for
1274  write to complete before we do the hardware reset */
1275  status = read_rom(serial, start_address,
1276  HEADER_SIZE, vheader);
1277 
1278  if (status) {
1279  dev_dbg(dev, "%s - can't read header back\n", __func__);
1280  kfree(vheader);
1281  kfree(header);
1282  kfree(rom_desc);
1283  kfree(ti_manuf_desc);
1284  return status;
1285  }
1286  if (memcmp(vheader, header, HEADER_SIZE)) {
1287  dev_dbg(dev, "%s - write download record failed\n", __func__);
1288  kfree(vheader);
1289  kfree(header);
1290  kfree(rom_desc);
1291  kfree(ti_manuf_desc);
1292  return -EINVAL;
1293  }
1294 
1295  kfree(vheader);
1296  kfree(header);
1297 
1298  dev_dbg(dev, "%s - Start firmware update\n", __func__);
1299 
1300  /* Tell firmware to copy download image into I2C */
1301  status = ti_vsend_sync(serial->serial->dev,
1302  UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);
1303 
1304  dev_dbg(dev, "%s - Update complete 0x%x\n", __func__, status);
1305  if (status) {
1306  dev_err(dev,
1307  "%s - UMPC_COPY_DNLD_TO_I2C failed\n",
1308  __func__);
1309  kfree(rom_desc);
1310  kfree(ti_manuf_desc);
1311  return status;
1312  }
1313  }
1314 
1315  // The device is running the download code
1316  kfree(rom_desc);
1317  kfree(ti_manuf_desc);
1318  return 0;
1319  }
1320 
1321  /********************************************************************/
1322  /* Boot Mode */
1323  /********************************************************************/
1324  dev_dbg(dev, "%s - RUNNING IN BOOT MODE\n", __func__);
1325 
1326  /* Configure the TI device so we can use the BULK pipes for download */
1327  status = config_boot_dev(serial->serial->dev);
1328  if (status)
1329  return status;
1330 
1331  if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)
1332  != USB_VENDOR_ID_ION) {
1333  dev_dbg(dev, "%s - VID = 0x%x\n", __func__,
1334  le16_to_cpu(serial->serial->dev->descriptor.idVendor));
1335  serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1336  goto stayinbootmode;
1337  }
1338 
1339  /* We have an ION device (I2c Must be programmed)
1340  Determine I2C image type */
1341  if (i2c_type_bootmode(serial))
1342  goto stayinbootmode;
1343 
1344  /* Check for ION Vendor ID and that the I2C is valid */
1345  if (!check_i2c_image(serial)) {
1346  struct ti_i2c_image_header *header;
1347  int i;
1348  __u8 cs = 0;
1349  __u8 *buffer;
1350  int buffer_size;
1351  int err;
1352  const struct firmware *fw;
1353  const char *fw_name = "edgeport/down3.bin";
1354 
1355  /* Validate Hardware version number
1356  * Read Manufacturing Descriptor from TI Based Edgeport
1357  */
1358  ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
1359  if (!ti_manuf_desc) {
1360  dev_err(dev, "%s - out of memory.\n", __func__);
1361  return -ENOMEM;
1362  }
1363  status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
1364  if (status) {
1365  kfree(ti_manuf_desc);
1366  goto stayinbootmode;
1367  }
1368 
1369  /* Check for version 2 */
1370  if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1371  dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1372  __func__, ti_cpu_rev(ti_manuf_desc));
1373  kfree(ti_manuf_desc);
1374  goto stayinbootmode;
1375  }
1376 
1377  kfree(ti_manuf_desc);
1378 
1379  /*
1380  * In order to update the I2C firmware we must change the type
1381  * 2 record to type 0xF2. This will force the UMP to come up
1382  * in Boot Mode. Then while in boot mode, the driver will
1383  * download the latest firmware (padded to 15.5k) into the
1384  * UMP ram. Finally when the device comes back up in download
1385  * mode the driver will cause the new firmware to be copied
1386  * from the UMP Ram to I2C and the firmware will update the
1387  * record type from 0xf2 to 0x02.
1388  *
1389  * Do we really have to copy the whole firmware image,
1390  * or could we do this in place!
1391  */
1392 
1393  /* Allocate a 15.5k buffer + 3 byte header */
1394  buffer_size = (((1024 * 16) - 512) +
1395  sizeof(struct ti_i2c_image_header));
1396  buffer = kmalloc(buffer_size, GFP_KERNEL);
1397  if (!buffer) {
1398  dev_err(dev, "%s - out of memory\n", __func__);
1399  return -ENOMEM;
1400  }
1401 
1402  /* Initialize the buffer to 0xff (pad the buffer) */
1403  memset(buffer, 0xff, buffer_size);
1404 
1405  err = request_firmware(&fw, fw_name, dev);
1406  if (err) {
1407  dev_err(dev, "Failed to load image \"%s\" err %d\n",
1408  fw_name, err);
1409  kfree(buffer);
1410  return err;
1411  }
1412  memcpy(buffer, &fw->data[4], fw->size - 4);
1413  release_firmware(fw);
1414 
1415  for (i = sizeof(struct ti_i2c_image_header);
1416  i < buffer_size; i++) {
1417  cs = (__u8)(cs + buffer[i]);
1418  }
1419 
1420  header = (struct ti_i2c_image_header *)buffer;
1421 
1422  /* update length and checksum after padding */
1423  header->Length = cpu_to_le16((__u16)(buffer_size -
1424  sizeof(struct ti_i2c_image_header)));
1425  header->CheckSum = cs;
1426 
1427  /* Download the operational code */
1428  dev_dbg(dev, "%s - Downloading operational code image (TI UMP)\n", __func__);
1429  status = download_code(serial, buffer, buffer_size);
1430 
1431  kfree(buffer);
1432 
1433  if (status) {
1434  dev_dbg(dev, "%s - Error downloading operational code image\n", __func__);
1435  return status;
1436  }
1437 
1438  /* Device will reboot */
1439  serial->product_info.TiMode = TI_MODE_TRANSITIONING;
1440 
1441  dev_dbg(dev, "%s - Download successful -- Device rebooting...\n", __func__);
1442 
1443  /* return an error on purpose */
1444  return -ENODEV;
1445  }
1446 
1447 stayinbootmode:
1448  /* Eprom is invalid or blank stay in boot mode */
1449  dev_dbg(dev, "%s - STAYING IN BOOT MODE\n", __func__);
1450  serial->product_info.TiMode = TI_MODE_BOOT;
1451 
1452  return 0;
1453 }
1454 
1455 
1456 static int ti_do_config(struct edgeport_port *port, int feature, int on)
1457 {
1458  int port_number = port->port->number - port->port->serial->minor;
1459  on = !!on; /* 1 or 0 not bitmask */
1460  return send_cmd(port->port->serial->dev,
1461  feature, (__u8)(UMPM_UART1_PORT + port_number),
1462  on, NULL, 0);
1463 }
1464 
1465 
1466 static int restore_mcr(struct edgeport_port *port, __u8 mcr)
1467 {
1468  int status = 0;
1469 
1470  dev_dbg(&port->port->dev, "%s - %x\n", __func__, mcr);
1471 
1472  status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);
1473  if (status)
1474  return status;
1475  status = ti_do_config(port, UMPC_SET_CLR_RTS, mcr & MCR_RTS);
1476  if (status)
1477  return status;
1478  return ti_do_config(port, UMPC_SET_CLR_LOOPBACK, mcr & MCR_LOOPBACK);
1479 }
1480 
1481 /* Convert TI LSR to standard UART flags */
1482 static __u8 map_line_status(__u8 ti_lsr)
1483 {
1484  __u8 lsr = 0;
1485 
1486 #define MAP_FLAG(flagUmp, flagUart) \
1487  if (ti_lsr & flagUmp) \
1488  lsr |= flagUart;
1489 
1490  MAP_FLAG(UMP_UART_LSR_OV_MASK, LSR_OVER_ERR) /* overrun */
1491  MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR) /* parity error */
1492  MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR) /* framing error */
1493  MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK) /* break detected */
1494  MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL) /* rx data available */
1495  MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY) /* tx hold reg empty */
1496 
1497 #undef MAP_FLAG
1498 
1499  return lsr;
1500 }
1501 
1502 static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
1503 {
1504  struct async_icount *icount;
1505  struct tty_struct *tty;
1506 
1507  dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, msr);
1508 
1509  if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
1510  EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
1511  icount = &edge_port->icount;
1512 
1513  /* update input line counters */
1514  if (msr & EDGEPORT_MSR_DELTA_CTS)
1515  icount->cts++;
1516  if (msr & EDGEPORT_MSR_DELTA_DSR)
1517  icount->dsr++;
1518  if (msr & EDGEPORT_MSR_DELTA_CD)
1519  icount->dcd++;
1520  if (msr & EDGEPORT_MSR_DELTA_RI)
1521  icount->rng++;
1522  wake_up_interruptible(&edge_port->delta_msr_wait);
1523  }
1524 
1525  /* Save the new modem status */
1526  edge_port->shadow_msr = msr & 0xf0;
1527 
1528  tty = tty_port_tty_get(&edge_port->port->port);
1529  /* handle CTS flow control */
1530  if (tty && C_CRTSCTS(tty)) {
1531  if (msr & EDGEPORT_MSR_CTS) {
1532  tty->hw_stopped = 0;
1533  tty_wakeup(tty);
1534  } else {
1535  tty->hw_stopped = 1;
1536  }
1537  }
1538  tty_kref_put(tty);
1539 }
1540 
1541 static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
1542  __u8 lsr, __u8 data)
1543 {
1544  struct async_icount *icount;
1545  __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR |
1546  LSR_FRM_ERR | LSR_BREAK));
1547  struct tty_struct *tty;
1548 
1549  dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);
1550 
1551  edge_port->shadow_lsr = lsr;
1552 
1553  if (new_lsr & LSR_BREAK)
1554  /*
1555  * Parity and Framing errors only count if they
1556  * occur exclusive of a break being received.
1557  */
1558  new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
1559 
1560  /* Place LSR data byte into Rx buffer */
1561  if (lsr_data) {
1562  tty = tty_port_tty_get(&edge_port->port->port);
1563  if (tty) {
1564  edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
1565  tty_kref_put(tty);
1566  }
1567  }
1568 
1569  /* update input line counters */
1570  icount = &edge_port->icount;
1571  if (new_lsr & LSR_BREAK)
1572  icount->brk++;
1573  if (new_lsr & LSR_OVER_ERR)
1574  icount->overrun++;
1575  if (new_lsr & LSR_PAR_ERR)
1576  icount->parity++;
1577  if (new_lsr & LSR_FRM_ERR)
1578  icount->frame++;
1579 }
1580 
1581 
1582 static void edge_interrupt_callback(struct urb *urb)
1583 {
1584  struct edgeport_serial *edge_serial = urb->context;
1585  struct usb_serial_port *port;
1586  struct edgeport_port *edge_port;
1587  struct device *dev;
1588  unsigned char *data = urb->transfer_buffer;
1589  int length = urb->actual_length;
1590  int port_number;
1591  int function;
1592  int retval;
1593  __u8 lsr;
1594  __u8 msr;
1595  int status = urb->status;
1596 
1597  switch (status) {
1598  case 0:
1599  /* success */
1600  break;
1601  case -ECONNRESET:
1602  case -ENOENT:
1603  case -ESHUTDOWN:
1604  /* this urb is terminated, clean up */
1605  dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1606  __func__, status);
1607  return;
1608  default:
1609  dev_err(&urb->dev->dev, "%s - nonzero urb status received: "
1610  "%d\n", __func__, status);
1611  goto exit;
1612  }
1613 
1614  if (!length) {
1615  dev_dbg(&urb->dev->dev, "%s - no data in urb\n", __func__);
1616  goto exit;
1617  }
1618 
1619  dev = &edge_serial->serial->dev->dev;
1620  usb_serial_debug_data(dev, __func__, length, data);
1621 
1622  if (length != 2) {
1623  dev_dbg(dev, "%s - expecting packet of size 2, got %d\n", __func__, length);
1624  goto exit;
1625  }
1626 
1627  port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);
1628  function = TIUMP_GET_FUNC_FROM_CODE(data[0]);
1629  dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
1630  port_number, function, data[1]);
1631  port = edge_serial->serial->port[port_number];
1632  edge_port = usb_get_serial_port_data(port);
1633  if (!edge_port) {
1634  dev_dbg(dev, "%s - edge_port not found\n", __func__);
1635  return;
1636  }
1637  switch (function) {
1638  case TIUMP_INTERRUPT_CODE_LSR:
1639  lsr = map_line_status(data[1]);
1640  if (lsr & UMP_UART_LSR_DATA_MASK) {
1641  /* Save the LSR event for bulk read
1642  completion routine */
1643  dev_dbg(dev, "%s - LSR Event Port %u LSR Status = %02x\n",
1644  __func__, port_number, lsr);
1645  edge_port->lsr_event = 1;
1646  edge_port->lsr_mask = lsr;
1647  } else {
1648  dev_dbg(dev, "%s - ===== Port %d LSR Status = %02x ======\n",
1649  __func__, port_number, lsr);
1650  handle_new_lsr(edge_port, 0, lsr, 0);
1651  }
1652  break;
1653 
1654  case TIUMP_INTERRUPT_CODE_MSR: /* MSR */
1655  /* Copy MSR from UMP */
1656  msr = data[1];
1657  dev_dbg(dev, "%s - ===== Port %u MSR Status = %02x ======\n",
1658  __func__, port_number, msr);
1659  handle_new_msr(edge_port, msr);
1660  break;
1661 
1662  default:
1663  dev_err(&urb->dev->dev,
1664  "%s - Unknown Interrupt code from UMP %x\n",
1665  __func__, data[1]);
1666  break;
1667 
1668  }
1669 
1670 exit:
1671  retval = usb_submit_urb(urb, GFP_ATOMIC);
1672  if (retval)
1673  dev_err(&urb->dev->dev,
1674  "%s - usb_submit_urb failed with result %d\n",
1675  __func__, retval);
1676 }
1677 
1678 static void edge_bulk_in_callback(struct urb *urb)
1679 {
1680  struct edgeport_port *edge_port = urb->context;
1681  struct device *dev = &edge_port->port->dev;
1682  unsigned char *data = urb->transfer_buffer;
1683  struct tty_struct *tty;
1684  int retval = 0;
1685  int port_number;
1686  int status = urb->status;
1687 
1688  switch (status) {
1689  case 0:
1690  /* success */
1691  break;
1692  case -ECONNRESET:
1693  case -ENOENT:
1694  case -ESHUTDOWN:
1695  /* this urb is terminated, clean up */
1696  dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
1697  return;
1698  default:
1699  dev_err(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", __func__, status);
1700  }
1701 
1702  if (status == -EPIPE)
1703  goto exit;
1704 
1705  if (status) {
1706  dev_err(&urb->dev->dev, "%s - stopping read!\n", __func__);
1707  return;
1708  }
1709 
1710  port_number = edge_port->port->number - edge_port->port->serial->minor;
1711 
1712  if (edge_port->lsr_event) {
1713  edge_port->lsr_event = 0;
1714  dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
1715  __func__, port_number, edge_port->lsr_mask, *data);
1716  handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);
1717  /* Adjust buffer length/pointer */
1718  --urb->actual_length;
1719  ++data;
1720  }
1721 
1722  tty = tty_port_tty_get(&edge_port->port->port);
1723  if (tty && urb->actual_length) {
1724  usb_serial_debug_data(dev, __func__, urb->actual_length, data);
1725  if (edge_port->close_pending)
1726  dev_dbg(dev, "%s - close pending, dropping data on the floor\n",
1727  __func__);
1728  else
1729  edge_tty_recv(dev, tty, data, urb->actual_length);
1730  edge_port->icount.rx += urb->actual_length;
1731  }
1732  tty_kref_put(tty);
1733 
1734 exit:
1735  /* continue read unless stopped */
1736  spin_lock(&edge_port->ep_lock);
1737  if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
1738  retval = usb_submit_urb(urb, GFP_ATOMIC);
1739  else if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPING)
1740  edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPED;
1741 
1742  spin_unlock(&edge_port->ep_lock);
1743  if (retval)
1744  dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);
1745 }
1746 
1747 static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
1748  unsigned char *data, int length)
1749 {
1750  int queued;
1751 
1752  queued = tty_insert_flip_string(tty, data, length);
1753  if (queued < length)
1754  dev_err(dev, "%s - dropping data, %d bytes lost\n",
1755  __func__, length - queued);
1756  tty_flip_buffer_push(tty);
1757 }
1758 
1759 static void edge_bulk_out_callback(struct urb *urb)
1760 {
1761  struct usb_serial_port *port = urb->context;
1762  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1763  int status = urb->status;
1764  struct tty_struct *tty;
1765 
1766  edge_port->ep_write_urb_in_use = 0;
1767 
1768  switch (status) {
1769  case 0:
1770  /* success */
1771  break;
1772  case -ECONNRESET:
1773  case -ENOENT:
1774  case -ESHUTDOWN:
1775  /* this urb is terminated, clean up */
1776  dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1777  __func__, status);
1778  return;
1779  default:
1780  dev_err_console(port, "%s - nonzero write bulk status "
1781  "received: %d\n", __func__, status);
1782  }
1783 
1784  /* send any buffered data */
1785  tty = tty_port_tty_get(&port->port);
1786  edge_send(tty);
1787  tty_kref_put(tty);
1788 }
1789 
1790 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
1791 {
1792  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1793  struct edgeport_serial *edge_serial;
1794  struct usb_device *dev;
1795  struct urb *urb;
1796  int port_number;
1797  int status;
1798  u16 open_settings;
1799  u8 transaction_timeout;
1800 
1801  if (edge_port == NULL)
1802  return -ENODEV;
1803 
1804  port_number = port->number - port->serial->minor;
1805  switch (port_number) {
1806  case 0:
1807  edge_port->uart_base = UMPMEM_BASE_UART1;
1808  edge_port->dma_address = UMPD_OEDB1_ADDRESS;
1809  break;
1810  case 1:
1811  edge_port->uart_base = UMPMEM_BASE_UART2;
1812  edge_port->dma_address = UMPD_OEDB2_ADDRESS;
1813  break;
1814  default:
1815  dev_err(&port->dev, "Unknown port number!!!\n");
1816  return -ENODEV;
1817  }
1818 
1819  dev_dbg(&port->dev, "%s - port_number = %d, uart_base = %04x, dma_address = %04x\n",
1820  __func__, port_number, edge_port->uart_base, edge_port->dma_address);
1821 
1822  dev = port->serial->dev;
1823 
1824  memset(&(edge_port->icount), 0x00, sizeof(edge_port->icount));
1825  init_waitqueue_head(&edge_port->delta_msr_wait);
1826 
1827  /* turn off loopback */
1828  status = ti_do_config(edge_port, UMPC_SET_CLR_LOOPBACK, 0);
1829  if (status) {
1830  dev_err(&port->dev,
1831  "%s - cannot send clear loopback command, %d\n",
1832  __func__, status);
1833  return status;
1834  }
1835 
1836  /* set up the port settings */
1837  if (tty)
1838  edge_set_termios(tty, port, &tty->termios);
1839 
1840  /* open up the port */
1841 
1842  /* milliseconds to timeout for DMA transfer */
1843  transaction_timeout = 2;
1844 
1845  edge_port->ump_read_timeout =
1846  max(20, ((transaction_timeout * 3) / 2));
1847 
1848  /* milliseconds to timeout for DMA transfer */
1849  open_settings = (u8)(UMP_DMA_MODE_CONTINOUS |
1850  UMP_PIPE_TRANS_TIMEOUT_ENA |
1851  (transaction_timeout << 2));
1852 
1853  dev_dbg(&port->dev, "%s - Sending UMPC_OPEN_PORT\n", __func__);
1854 
1855  /* Tell TI to open and start the port */
1856  status = send_cmd(dev, UMPC_OPEN_PORT,
1857  (u8)(UMPM_UART1_PORT + port_number), open_settings, NULL, 0);
1858  if (status) {
1859  dev_err(&port->dev, "%s - cannot send open command, %d\n",
1860  __func__, status);
1861  return status;
1862  }
1863 
1864  /* Start the DMA? */
1865  status = send_cmd(dev, UMPC_START_PORT,
1866  (u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);
1867  if (status) {
1868  dev_err(&port->dev, "%s - cannot send start DMA command, %d\n",
1869  __func__, status);
1870  return status;
1871  }
1872 
1873  /* Clear TX and RX buffers in UMP */
1874  status = purge_port(port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
1875  if (status) {
1876  dev_err(&port->dev,
1877  "%s - cannot send clear buffers command, %d\n",
1878  __func__, status);
1879  return status;
1880  }
1881 
1882  /* Read Initial MSR */
1883  status = ti_vread_sync(dev, UMPC_READ_MSR, 0,
1884  (__u16)(UMPM_UART1_PORT + port_number),
1885  &edge_port->shadow_msr, 1);
1886  if (status) {
1887  dev_err(&port->dev, "%s - cannot send read MSR command, %d\n",
1888  __func__, status);
1889  return status;
1890  }
1891 
1892  dev_dbg(&port->dev, "ShadowMSR 0x%X\n", edge_port->shadow_msr);
1893 
1894  /* Set Initial MCR */
1895  edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
1896  dev_dbg(&port->dev, "ShadowMCR 0x%X\n", edge_port->shadow_mcr);
1897 
1898  edge_serial = edge_port->edge_serial;
1899  if (mutex_lock_interruptible(&edge_serial->es_lock))
1900  return -ERESTARTSYS;
1901  if (edge_serial->num_ports_open == 0) {
1902  /* we are the first port to open, post the interrupt urb */
1903  urb = edge_serial->serial->port[0]->interrupt_in_urb;
1904  if (!urb) {
1905  dev_err(&port->dev,
1906  "%s - no interrupt urb present, exiting\n",
1907  __func__);
1908  status = -EINVAL;
1909  goto release_es_lock;
1910  }
1911  urb->context = edge_serial;
1912  status = usb_submit_urb(urb, GFP_KERNEL);
1913  if (status) {
1914  dev_err(&port->dev,
1915  "%s - usb_submit_urb failed with value %d\n",
1916  __func__, status);
1917  goto release_es_lock;
1918  }
1919  }
1920 
1921  /*
1922  * reset the data toggle on the bulk endpoints to work around bug in
1923  * host controllers where things get out of sync some times
1924  */
1925  usb_clear_halt(dev, port->write_urb->pipe);
1926  usb_clear_halt(dev, port->read_urb->pipe);
1927 
1928  /* start up our bulk read urb */
1929  urb = port->read_urb;
1930  if (!urb) {
1931  dev_err(&port->dev, "%s - no read urb present, exiting\n",
1932  __func__);
1933  status = -EINVAL;
1934  goto unlink_int_urb;
1935  }
1936  edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
1937  urb->context = edge_port;
1938  status = usb_submit_urb(urb, GFP_KERNEL);
1939  if (status) {
1940  dev_err(&port->dev,
1941  "%s - read bulk usb_submit_urb failed with value %d\n",
1942  __func__, status);
1943  goto unlink_int_urb;
1944  }
1945 
1946  ++edge_serial->num_ports_open;
1947 
1948  goto release_es_lock;
1949 
1950 unlink_int_urb:
1951  if (edge_port->edge_serial->num_ports_open == 0)
1952  usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
1953 release_es_lock:
1954  mutex_unlock(&edge_serial->es_lock);
1955  return status;
1956 }
1957 
1958 static void edge_close(struct usb_serial_port *port)
1959 {
1960  struct edgeport_serial *edge_serial;
1961  struct edgeport_port *edge_port;
1962  struct usb_serial *serial = port->serial;
1963  int port_number;
1964 
1965  edge_serial = usb_get_serial_data(port->serial);
1966  edge_port = usb_get_serial_port_data(port);
1967  if (edge_serial == NULL || edge_port == NULL)
1968  return;
1969 
1970  /* The bulkreadcompletion routine will check
1971  * this flag and dump add read data */
1972  edge_port->close_pending = 1;
1973 
1974  /* chase the port close and flush */
1975  chase_port(edge_port, (HZ * closing_wait) / 100, 1);
1976 
1977  usb_kill_urb(port->read_urb);
1978  usb_kill_urb(port->write_urb);
1979  edge_port->ep_write_urb_in_use = 0;
1980 
1981  /* assuming we can still talk to the device,
1982  * send a close port command to it */
1983  dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__);
1984  port_number = port->number - port->serial->minor;
1985 
1986  mutex_lock(&serial->disc_mutex);
1987  if (!serial->disconnected) {
1988  send_cmd(serial->dev,
1989  UMPC_CLOSE_PORT,
1990  (__u8)(UMPM_UART1_PORT + port_number),
1991  0,
1992  NULL,
1993  0);
1994  }
1995  mutex_unlock(&serial->disc_mutex);
1996 
1997  mutex_lock(&edge_serial->es_lock);
1998  --edge_port->edge_serial->num_ports_open;
1999  if (edge_port->edge_serial->num_ports_open <= 0) {
2000  /* last port is now closed, let's shut down our interrupt urb */
2001  usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2002  edge_port->edge_serial->num_ports_open = 0;
2003  }
2004  mutex_unlock(&edge_serial->es_lock);
2005  edge_port->close_pending = 0;
2006 }
2007 
2008 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
2009  const unsigned char *data, int count)
2010 {
2011  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2012 
2013  if (count == 0) {
2014  dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
2015  return 0;
2016  }
2017 
2018  if (edge_port == NULL)
2019  return -ENODEV;
2020  if (edge_port->close_pending == 1)
2021  return -ENODEV;
2022 
2023  count = kfifo_in_locked(&edge_port->write_fifo, data, count,
2024  &edge_port->ep_lock);
2025  edge_send(tty);
2026 
2027  return count;
2028 }
2029 
2030 static void edge_send(struct tty_struct *tty)
2031 {
2032  struct usb_serial_port *port = tty->driver_data;
2033  int count, result;
2034  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2035  unsigned long flags;
2036 
2037  spin_lock_irqsave(&edge_port->ep_lock, flags);
2038 
2039  if (edge_port->ep_write_urb_in_use) {
2040  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2041  return;
2042  }
2043 
2044  count = kfifo_out(&edge_port->write_fifo,
2045  port->write_urb->transfer_buffer,
2046  port->bulk_out_size);
2047 
2048  if (count == 0) {
2049  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2050  return;
2051  }
2052 
2053  edge_port->ep_write_urb_in_use = 1;
2054 
2055  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2056 
2057  usb_serial_debug_data(&port->dev, __func__, count, port->write_urb->transfer_buffer);
2058 
2059  /* set up our urb */
2060  port->write_urb->transfer_buffer_length = count;
2061 
2062  /* send the data out the bulk port */
2063  result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
2064  if (result) {
2065  dev_err_console(port,
2066  "%s - failed submitting write urb, error %d\n",
2067  __func__, result);
2068  edge_port->ep_write_urb_in_use = 0;
2069  /* TODO: reschedule edge_send */
2070  } else
2071  edge_port->icount.tx += count;
2072 
2073  /* wakeup any process waiting for writes to complete */
2074  /* there is now more room in the buffer for new writes */
2075  if (tty)
2076  tty_wakeup(tty);
2077 }
2078 
2079 static int edge_write_room(struct tty_struct *tty)
2080 {
2081  struct usb_serial_port *port = tty->driver_data;
2082  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2083  int room = 0;
2084  unsigned long flags;
2085 
2086  if (edge_port == NULL)
2087  return 0;
2088  if (edge_port->close_pending == 1)
2089  return 0;
2090 
2091  spin_lock_irqsave(&edge_port->ep_lock, flags);
2092  room = kfifo_avail(&edge_port->write_fifo);
2093  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2094 
2095  dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
2096  return room;
2097 }
2098 
2099 static int edge_chars_in_buffer(struct tty_struct *tty)
2100 {
2101  struct usb_serial_port *port = tty->driver_data;
2102  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2103  int chars = 0;
2104  unsigned long flags;
2105 
2106  if (edge_port == NULL)
2107  return 0;
2108  if (edge_port->close_pending == 1)
2109  return 0;
2110 
2111  spin_lock_irqsave(&edge_port->ep_lock, flags);
2112  chars = kfifo_len(&edge_port->write_fifo);
2113  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2114 
2115  dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
2116  return chars;
2117 }
2118 
2119 static void edge_throttle(struct tty_struct *tty)
2120 {
2121  struct usb_serial_port *port = tty->driver_data;
2122  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2123  int status;
2124 
2125  if (edge_port == NULL)
2126  return;
2127 
2128  /* if we are implementing XON/XOFF, send the stop character */
2129  if (I_IXOFF(tty)) {
2130  unsigned char stop_char = STOP_CHAR(tty);
2131  status = edge_write(tty, port, &stop_char, 1);
2132  if (status <= 0) {
2133  dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
2134  }
2135  }
2136 
2137  /* if we are implementing RTS/CTS, stop reads */
2138  /* and the Edgeport will clear the RTS line */
2139  if (C_CRTSCTS(tty))
2140  stop_read(edge_port);
2141 
2142 }
2143 
2144 static void edge_unthrottle(struct tty_struct *tty)
2145 {
2146  struct usb_serial_port *port = tty->driver_data;
2147  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2148  int status;
2149 
2150  if (edge_port == NULL)
2151  return;
2152 
2153  /* if we are implementing XON/XOFF, send the start character */
2154  if (I_IXOFF(tty)) {
2155  unsigned char start_char = START_CHAR(tty);
2156  status = edge_write(tty, port, &start_char, 1);
2157  if (status <= 0) {
2158  dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
2159  }
2160  }
2161  /* if we are implementing RTS/CTS, restart reads */
2162  /* are the Edgeport will assert the RTS line */
2163  if (C_CRTSCTS(tty)) {
2164  status = restart_read(edge_port);
2165  if (status)
2166  dev_err(&port->dev,
2167  "%s - read bulk usb_submit_urb failed: %d\n",
2168  __func__, status);
2169  }
2170 
2171 }
2172 
2173 static void stop_read(struct edgeport_port *edge_port)
2174 {
2175  unsigned long flags;
2176 
2177  spin_lock_irqsave(&edge_port->ep_lock, flags);
2178 
2179  if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
2180  edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;
2181  edge_port->shadow_mcr &= ~MCR_RTS;
2182 
2183  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2184 }
2185 
2186 static int restart_read(struct edgeport_port *edge_port)
2187 {
2188  struct urb *urb;
2189  int status = 0;
2190  unsigned long flags;
2191 
2192  spin_lock_irqsave(&edge_port->ep_lock, flags);
2193 
2194  if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {
2195  urb = edge_port->port->read_urb;
2196  status = usb_submit_urb(urb, GFP_ATOMIC);
2197  }
2198  edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2199  edge_port->shadow_mcr |= MCR_RTS;
2200 
2201  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2202 
2203  return status;
2204 }
2205 
2206 static void change_port_settings(struct tty_struct *tty,
2207  struct edgeport_port *edge_port, struct ktermios *old_termios)
2208 {
2209  struct device *dev = &edge_port->port->dev;
2210  struct ump_uart_config *config;
2211  int baud;
2212  unsigned cflag;
2213  int status;
2214  int port_number = edge_port->port->number -
2215  edge_port->port->serial->minor;
2216 
2217  dev_dbg(dev, "%s - port %d\n", __func__, edge_port->port->number);
2218 
2219  config = kmalloc (sizeof (*config), GFP_KERNEL);
2220  if (!config) {
2221  tty->termios = *old_termios;
2222  dev_err(dev, "%s - out of memory\n", __func__);
2223  return;
2224  }
2225 
2226  cflag = tty->termios.c_cflag;
2227 
2228  config->wFlags = 0;
2229 
2230  /* These flags must be set */
2231  config->wFlags |= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
2232  config->wFlags |= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
2233  config->bUartMode = (__u8)(edge_port->bUartMode);
2234 
2235  switch (cflag & CSIZE) {
2236  case CS5:
2237  config->bDataBits = UMP_UART_CHAR5BITS;
2238  dev_dbg(dev, "%s - data bits = 5\n", __func__);
2239  break;
2240  case CS6:
2241  config->bDataBits = UMP_UART_CHAR6BITS;
2242  dev_dbg(dev, "%s - data bits = 6\n", __func__);
2243  break;
2244  case CS7:
2245  config->bDataBits = UMP_UART_CHAR7BITS;
2246  dev_dbg(dev, "%s - data bits = 7\n", __func__);
2247  break;
2248  default:
2249  case CS8:
2250  config->bDataBits = UMP_UART_CHAR8BITS;
2251  dev_dbg(dev, "%s - data bits = 8\n", __func__);
2252  break;
2253  }
2254 
2255  if (cflag & PARENB) {
2256  if (cflag & PARODD) {
2257  config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2258  config->bParity = UMP_UART_ODDPARITY;
2259  dev_dbg(dev, "%s - parity = odd\n", __func__);
2260  } else {
2261  config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2262  config->bParity = UMP_UART_EVENPARITY;
2263  dev_dbg(dev, "%s - parity = even\n", __func__);
2264  }
2265  } else {
2266  config->bParity = UMP_UART_NOPARITY;
2267  dev_dbg(dev, "%s - parity = none\n", __func__);
2268  }
2269 
2270  if (cflag & CSTOPB) {
2271  config->bStopBits = UMP_UART_STOPBIT2;
2272  dev_dbg(dev, "%s - stop bits = 2\n", __func__);
2273  } else {
2274  config->bStopBits = UMP_UART_STOPBIT1;
2275  dev_dbg(dev, "%s - stop bits = 1\n", __func__);
2276  }
2277 
2278  /* figure out the flow control settings */
2279  if (cflag & CRTSCTS) {
2280  config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
2281  config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
2282  dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
2283  } else {
2284  dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
2285  tty->hw_stopped = 0;
2286  restart_read(edge_port);
2287  }
2288 
2289  /* if we are implementing XON/XOFF, set the start and stop
2290  character in the device */
2291  config->cXon = START_CHAR(tty);
2292  config->cXoff = STOP_CHAR(tty);
2293 
2294  /* if we are implementing INBOUND XON/XOFF */
2295  if (I_IXOFF(tty)) {
2296  config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
2297  dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2298  __func__, config->cXon, config->cXoff);
2299  } else
2300  dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);
2301 
2302  /* if we are implementing OUTBOUND XON/XOFF */
2303  if (I_IXON(tty)) {
2304  config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
2305  dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2306  __func__, config->cXon, config->cXoff);
2307  } else
2308  dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);
2309 
2310  tty->termios.c_cflag &= ~CMSPAR;
2311 
2312  /* Round the baud rate */
2313  baud = tty_get_baud_rate(tty);
2314  if (!baud) {
2315  /* pick a default, any default... */
2316  baud = 9600;
2317  } else
2318  tty_encode_baud_rate(tty, baud, baud);
2319 
2320  edge_port->baud_rate = baud;
2321  config->wBaudRate = (__u16)((461550L + baud/2) / baud);
2322 
2323  /* FIXME: Recompute actual baud from divisor here */
2324 
2325  dev_dbg(dev, "%s - baud rate = %d, wBaudRate = %d\n", __func__, baud, config->wBaudRate);
2326 
2327  dev_dbg(dev, "wBaudRate: %d\n", (int)(461550L / config->wBaudRate));
2328  dev_dbg(dev, "wFlags: 0x%x\n", config->wFlags);
2329  dev_dbg(dev, "bDataBits: %d\n", config->bDataBits);
2330  dev_dbg(dev, "bParity: %d\n", config->bParity);
2331  dev_dbg(dev, "bStopBits: %d\n", config->bStopBits);
2332  dev_dbg(dev, "cXon: %d\n", config->cXon);
2333  dev_dbg(dev, "cXoff: %d\n", config->cXoff);
2334  dev_dbg(dev, "bUartMode: %d\n", config->bUartMode);
2335 
2336  /* move the word values into big endian mode */
2337  cpu_to_be16s(&config->wFlags);
2338  cpu_to_be16s(&config->wBaudRate);
2339 
2340  status = send_cmd(edge_port->port->serial->dev, UMPC_SET_CONFIG,
2341  (__u8)(UMPM_UART1_PORT + port_number),
2342  0, (__u8 *)config, sizeof(*config));
2343  if (status)
2344  dev_dbg(dev, "%s - error %d when trying to write config to device\n",
2345  __func__, status);
2346  kfree(config);
2347 }
2348 
2349 static void edge_set_termios(struct tty_struct *tty,
2350  struct usb_serial_port *port, struct ktermios *old_termios)
2351 {
2352  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2353  unsigned int cflag;
2354 
2355  cflag = tty->termios.c_cflag;
2356 
2357  dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
2358  tty->termios.c_cflag, tty->termios.c_iflag);
2359  dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
2360  old_termios->c_cflag, old_termios->c_iflag);
2361  dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
2362 
2363  if (edge_port == NULL)
2364  return;
2365  /* change the port settings to the new ones specified */
2366  change_port_settings(tty, edge_port, old_termios);
2367 }
2368 
2369 static int edge_tiocmset(struct tty_struct *tty,
2370  unsigned int set, unsigned int clear)
2371 {
2372  struct usb_serial_port *port = tty->driver_data;
2373  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2374  unsigned int mcr;
2375  unsigned long flags;
2376 
2377  spin_lock_irqsave(&edge_port->ep_lock, flags);
2378  mcr = edge_port->shadow_mcr;
2379  if (set & TIOCM_RTS)
2380  mcr |= MCR_RTS;
2381  if (set & TIOCM_DTR)
2382  mcr |= MCR_DTR;
2383  if (set & TIOCM_LOOP)
2384  mcr |= MCR_LOOPBACK;
2385 
2386  if (clear & TIOCM_RTS)
2387  mcr &= ~MCR_RTS;
2388  if (clear & TIOCM_DTR)
2389  mcr &= ~MCR_DTR;
2390  if (clear & TIOCM_LOOP)
2391  mcr &= ~MCR_LOOPBACK;
2392 
2393  edge_port->shadow_mcr = mcr;
2394  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2395 
2396  restore_mcr(edge_port, mcr);
2397  return 0;
2398 }
2399 
2400 static int edge_tiocmget(struct tty_struct *tty)
2401 {
2402  struct usb_serial_port *port = tty->driver_data;
2403  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2404  unsigned int result = 0;
2405  unsigned int msr;
2406  unsigned int mcr;
2407  unsigned long flags;
2408 
2409  spin_lock_irqsave(&edge_port->ep_lock, flags);
2410 
2411  msr = edge_port->shadow_msr;
2412  mcr = edge_port->shadow_mcr;
2413  result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
2414  | ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
2415  | ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
2416  | ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */
2417  | ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
2418  | ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
2419 
2420 
2421  dev_dbg(&port->dev, "%s -- %x\n", __func__, result);
2422  spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2423 
2424  return result;
2425 }
2426 
2427 static int edge_get_icount(struct tty_struct *tty,
2428  struct serial_icounter_struct *icount)
2429 {
2430  struct usb_serial_port *port = tty->driver_data;
2431  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2432  struct async_icount *ic = &edge_port->icount;
2433 
2434  icount->cts = ic->cts;
2435  icount->dsr = ic->dsr;
2436  icount->rng = ic->rng;
2437  icount->dcd = ic->dcd;
2438  icount->tx = ic->tx;
2439  icount->rx = ic->rx;
2440  icount->frame = ic->frame;
2441  icount->parity = ic->parity;
2442  icount->overrun = ic->overrun;
2443  icount->brk = ic->brk;
2444  icount->buf_overrun = ic->buf_overrun;
2445  return 0;
2446 }
2447 
2448 static int get_serial_info(struct edgeport_port *edge_port,
2449  struct serial_struct __user *retinfo)
2450 {
2451  struct serial_struct tmp;
2452 
2453  if (!retinfo)
2454  return -EFAULT;
2455 
2456  memset(&tmp, 0, sizeof(tmp));
2457 
2458  tmp.type = PORT_16550A;
2459  tmp.line = edge_port->port->serial->minor;
2460  tmp.port = edge_port->port->number;
2461  tmp.irq = 0;
2462  tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
2463  tmp.xmit_fifo_size = edge_port->port->bulk_out_size;
2464  tmp.baud_base = 9600;
2465  tmp.close_delay = 5*HZ;
2466  tmp.closing_wait = closing_wait;
2467 
2468  if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2469  return -EFAULT;
2470  return 0;
2471 }
2472 
2473 static int edge_ioctl(struct tty_struct *tty,
2474  unsigned int cmd, unsigned long arg)
2475 {
2476  struct usb_serial_port *port = tty->driver_data;
2477  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2478  struct async_icount cnow;
2479  struct async_icount cprev;
2480 
2481  dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd);
2482 
2483  switch (cmd) {
2484  case TIOCGSERIAL:
2485  dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);
2486  return get_serial_info(edge_port,
2487  (struct serial_struct __user *) arg);
2488  case TIOCMIWAIT:
2489  dev_dbg(&port->dev, "%s - TIOCMIWAIT\n", __func__);
2490  cprev = edge_port->icount;
2491  while (1) {
2492  interruptible_sleep_on(&edge_port->delta_msr_wait);
2493  /* see if a signal did it */
2494  if (signal_pending(current))
2495  return -ERESTARTSYS;
2496  cnow = edge_port->icount;
2497  if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2498  cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2499  return -EIO; /* no change => error */
2500  if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2501  ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2502  ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2503  ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
2504  return 0;
2505  }
2506  cprev = cnow;
2507  }
2508  /* not reached */
2509  break;
2510  }
2511  return -ENOIOCTLCMD;
2512 }
2513 
2514 static void edge_break(struct tty_struct *tty, int break_state)
2515 {
2516  struct usb_serial_port *port = tty->driver_data;
2517  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2518  int status;
2519  int bv = 0; /* Off */
2520 
2521  /* chase the port close */
2522  chase_port(edge_port, 0, 0);
2523 
2524  if (break_state == -1)
2525  bv = 1; /* On */
2526  status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
2527  if (status)
2528  dev_dbg(&port->dev, "%s - error %d sending break set/clear command.\n",
2529  __func__, status);
2530 }
2531 
2532 static int edge_startup(struct usb_serial *serial)
2533 {
2534  struct edgeport_serial *edge_serial;
2535  int status;
2536 
2537  /* create our private serial structure */
2538  edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2539  if (edge_serial == NULL) {
2540  dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2541  return -ENOMEM;
2542  }
2543  mutex_init(&edge_serial->es_lock);
2544  edge_serial->serial = serial;
2545  usb_set_serial_data(serial, edge_serial);
2546 
2547  status = download_fw(edge_serial);
2548  if (status) {
2549  kfree(edge_serial);
2550  return status;
2551  }
2552 
2553  return 0;
2554 }
2555 
2556 static void edge_disconnect(struct usb_serial *serial)
2557 {
2558 }
2559 
2560 static void edge_release(struct usb_serial *serial)
2561 {
2562  kfree(usb_get_serial_data(serial));
2563 }
2564 
2565 static int edge_port_probe(struct usb_serial_port *port)
2566 {
2567  struct edgeport_port *edge_port;
2568  int ret;
2569 
2570  edge_port = kzalloc(sizeof(*edge_port), GFP_KERNEL);
2571  if (!edge_port)
2572  return -ENOMEM;
2573 
2574  ret = kfifo_alloc(&edge_port->write_fifo, EDGE_OUT_BUF_SIZE,
2575  GFP_KERNEL);
2576  if (ret) {
2577  kfree(edge_port);
2578  return -ENOMEM;
2579  }
2580 
2581  spin_lock_init(&edge_port->ep_lock);
2582  edge_port->port = port;
2583  edge_port->edge_serial = usb_get_serial_data(port->serial);
2584  edge_port->bUartMode = default_uart_mode;
2585 
2586  usb_set_serial_port_data(port, edge_port);
2587 
2588  ret = edge_create_sysfs_attrs(port);
2589  if (ret) {
2590  kfifo_free(&edge_port->write_fifo);
2591  kfree(edge_port);
2592  return ret;
2593  }
2594 
2595  return 0;
2596 }
2597 
2598 static int edge_port_remove(struct usb_serial_port *port)
2599 {
2600  struct edgeport_port *edge_port;
2601 
2602  edge_port = usb_get_serial_port_data(port);
2603 
2604  edge_remove_sysfs_attrs(port);
2605  kfifo_free(&edge_port->write_fifo);
2606  kfree(edge_port);
2607 
2608  return 0;
2609 }
2610 
2611 /* Sysfs Attributes */
2612 
2613 static ssize_t show_uart_mode(struct device *dev,
2614  struct device_attribute *attr, char *buf)
2615 {
2616  struct usb_serial_port *port = to_usb_serial_port(dev);
2617  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2618 
2619  return sprintf(buf, "%d\n", edge_port->bUartMode);
2620 }
2621 
2622 static ssize_t store_uart_mode(struct device *dev,
2623  struct device_attribute *attr, const char *valbuf, size_t count)
2624 {
2625  struct usb_serial_port *port = to_usb_serial_port(dev);
2626  struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2627  unsigned int v = simple_strtoul(valbuf, NULL, 0);
2628 
2629  dev_dbg(dev, "%s: setting uart_mode = %d\n", __func__, v);
2630 
2631  if (v < 256)
2632  edge_port->bUartMode = v;
2633  else
2634  dev_err(dev, "%s - uart_mode %d is invalid\n", __func__, v);
2635 
2636  return count;
2637 }
2638 
2639 static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode,
2640  store_uart_mode);
2641 
2642 static int edge_create_sysfs_attrs(struct usb_serial_port *port)
2643 {
2644  return device_create_file(&port->dev, &dev_attr_uart_mode);
2645 }
2646 
2647 static int edge_remove_sysfs_attrs(struct usb_serial_port *port)
2648 {
2649  device_remove_file(&port->dev, &dev_attr_uart_mode);
2650  return 0;
2651 }
2652 
2653 
2654 static struct usb_serial_driver edgeport_1port_device = {
2655  .driver = {
2656  .owner = THIS_MODULE,
2657  .name = "edgeport_ti_1",
2658  },
2659  .description = "Edgeport TI 1 port adapter",
2660  .id_table = edgeport_1port_id_table,
2661  .num_ports = 1,
2662  .open = edge_open,
2663  .close = edge_close,
2664  .throttle = edge_throttle,
2665  .unthrottle = edge_unthrottle,
2666  .attach = edge_startup,
2667  .disconnect = edge_disconnect,
2668  .release = edge_release,
2669  .port_probe = edge_port_probe,
2670  .port_remove = edge_port_remove,
2671  .ioctl = edge_ioctl,
2672  .set_termios = edge_set_termios,
2673  .tiocmget = edge_tiocmget,
2674  .tiocmset = edge_tiocmset,
2675  .get_icount = edge_get_icount,
2676  .write = edge_write,
2677  .write_room = edge_write_room,
2678  .chars_in_buffer = edge_chars_in_buffer,
2679  .break_ctl = edge_break,
2680  .read_int_callback = edge_interrupt_callback,
2681  .read_bulk_callback = edge_bulk_in_callback,
2682  .write_bulk_callback = edge_bulk_out_callback,
2683 };
2684 
2685 static struct usb_serial_driver edgeport_2port_device = {
2686  .driver = {
2687  .owner = THIS_MODULE,
2688  .name = "edgeport_ti_2",
2689  },
2690  .description = "Edgeport TI 2 port adapter",
2691  .id_table = edgeport_2port_id_table,
2692  .num_ports = 2,
2693  .open = edge_open,
2694  .close = edge_close,
2695  .throttle = edge_throttle,
2696  .unthrottle = edge_unthrottle,
2697  .attach = edge_startup,
2698  .disconnect = edge_disconnect,
2699  .release = edge_release,
2700  .port_probe = edge_port_probe,
2701  .port_remove = edge_port_remove,
2702  .ioctl = edge_ioctl,
2703  .set_termios = edge_set_termios,
2704  .tiocmget = edge_tiocmget,
2705  .tiocmset = edge_tiocmset,
2706  .write = edge_write,
2707  .write_room = edge_write_room,
2708  .chars_in_buffer = edge_chars_in_buffer,
2709  .break_ctl = edge_break,
2710  .read_int_callback = edge_interrupt_callback,
2711  .read_bulk_callback = edge_bulk_in_callback,
2712  .write_bulk_callback = edge_bulk_out_callback,
2713 };
2714 
2715 static struct usb_serial_driver * const serial_drivers[] = {
2716  &edgeport_1port_device, &edgeport_2port_device, NULL
2717 };
2718 
2719 module_usb_serial_driver(serial_drivers, id_table_combined);
2720 
2721 MODULE_AUTHOR(DRIVER_AUTHOR);
2722 MODULE_DESCRIPTION(DRIVER_DESC);
2723 MODULE_LICENSE("GPL");
2724 MODULE_FIRMWARE("edgeport/down3.bin");
2725 
2726 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
2727 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
2728 
2729 module_param(ignore_cpu_rev, bool, S_IRUGO | S_IWUSR);
2730 MODULE_PARM_DESC(ignore_cpu_rev,
2731  "Ignore the cpu revision when connecting to a device");
2732 
2733 module_param(default_uart_mode, int, S_IRUGO | S_IWUSR);
2734 MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");
Generated on Thu Jan 10 2013 14:38:18 for Linux Kernel by   doxygen 1.8.2