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