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