source: src/linux/universal/linux-3.18/drivers/usb/serial/io_ti.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

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