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