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