?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sata_inic162x: update TF read handling
[linux-2.6/verdex.git] / drivers / usb / serial / io_ti.c
blob05e4fa730730fb4439b72f3a4cdfb658d0d445f0
1 /*
2 * Edgeport USB Serial Converter driver
3 *
4 * Copyright (C) 2000-2002 Inside Out Networks, All rights reserved.
5 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * Supports the following devices:
13 * EP/1 EP/2 EP/4 EP/21 EP/22 EP/221 EP/42 EP/421 WATCHPORT
14 *
15 * For questions or problems with this driver, contact Inside Out
16 * Networks technical support, or Peter Berger <pberger@brimson.com>,
17 * or Al Borchers <alborchers@steinerpoint.com>.
18 *
19 * Version history:
20 *
21 * July 11, 2002 Removed 4 port device structure since all TI UMP
22 * chips have only 2 ports
23 * David Iacovelli (davidi@ionetworks.com)
24 *
25 */
26
27 #include <linux/kernel.h>
28 #include <linux/jiffies.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/tty.h>
33 #include <linux/tty_driver.h>
34 #include <linux/tty_flip.h>
35 #include <linux/module.h>
36 #include <linux/spinlock.h>
37 #include <linux/mutex.h>
38 #include <linux/serial.h>
39 #include <linux/ioctl.h>
40 #include <asm/uaccess.h>
41 #include <linux/usb.h>
42 #include <linux/usb/serial.h>
43
44 #include "io_16654.h"
45 #include "io_usbvend.h"
46 #include "io_ti.h"
47
48 /*
49 * Version Information
50 */
51 #define DRIVER_VERSION "v0.7mode043006"
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
65 struct 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 */
91 struct product_info
92 {
93 int TiMode; // Current TI Mode
94 __u8 hardware_type; // Type of hardware
95 } __attribute__((packed));
96
97 /* circular buffer */
98 struct edge_buf {
99 unsigned int buf_size;
100 char *buf_buf;
101 char *buf_get;
102 char *buf_put;
103 };
104
105 struct 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
132 struct 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
136 struct mutex es_lock;
137 int num_ports_open;
138 struct usb_serial *serial;
139 };
140
141
142 /* Devices that this driver supports */
143 static 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
163 static 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) },
176 /* The 4, 8 and 16 port devices show up as multiple 2 port devices */
177 { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
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) },
182 { }
183 };
184
185 /* Devices that this driver supports */
186 static 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) },
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) },
220 { }
221 };
222
223 MODULE_DEVICE_TABLE (usb, id_table_combined);
224
225 static struct usb_driver io_driver = {
226 .name = "io_ti",
227 .probe = usb_serial_probe,
228 .disconnect = usb_serial_disconnect,
229 .id_table = id_table_combined,
230 .no_dynamic_id = 1,
231 };
232
233
234 static struct EDGE_FIRMWARE_VERSION_INFO OperationalCodeImageVersion;
235
236 static int debug;
237
238 static int TIStayInBootMode = 0;
239 static int low_latency = EDGE_LOW_LATENCY;
240 static int closing_wait = EDGE_CLOSING_WAIT;
241 static int ignore_cpu_rev = 0;
242 static int default_uart_mode = 0; /* RS232 */
243
244
245 static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned char *data, int length);
246
247 static void stop_read(struct edgeport_port *edge_port);
248 static int restart_read(struct edgeport_port *edge_port);
249
250 static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios);
251 static void edge_send(struct usb_serial_port *port);
252
253 /* sysfs attributes */
254 static int edge_create_sysfs_attrs(struct usb_serial_port *port);
255 static int edge_remove_sysfs_attrs(struct usb_serial_port *port);
256
257 /* circular buffer */
258 static struct edge_buf *edge_buf_alloc(unsigned int size);
259 static void edge_buf_free(struct edge_buf *eb);
260 static void edge_buf_clear(struct edge_buf *eb);
261 static unsigned int edge_buf_data_avail(struct edge_buf *eb);
262 static unsigned int edge_buf_space_avail(struct edge_buf *eb);
263 static unsigned int edge_buf_put(struct edge_buf *eb, const char *buf,
264 unsigned int count);
265 static unsigned int edge_buf_get(struct edge_buf *eb, char *buf,
266 unsigned int count);
267
268
269 static 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 __func__, size, status);
294 return -ECOMM;
295 }
296 return 0;
297 }
298
299 static 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 __func__, size, status);
324 return -ECOMM;
325 }
326 return 0;
327 }
328
329 static 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 */
343 static 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", __func__, 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 */
365 static 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", __func__, 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", __func__,
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", __func__, status);
397 return status;
398 }
399
400 if (read_length > 1) {
401 usb_serial_debug_data(debug, &dev->dev, __func__,
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
414 static 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 */
424 static 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", __func__, status);
438 return status;
439 }
440 }
441
442 dbg ("%s - start_address = %x, length = %d", __func__, start_address, length);
443 usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, length, buffer);
444
445 serial->TiReadI2C = 1;
446
447 return status;
448 }
449
450 /* Write given block to TI EPROM memory */
451 static 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", __func__, start_address, length);
476 usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, length, buffer);
477
478 return status;
479 }
480
481
482 /* Write edgeport I2C memory to TI chip */
483 static 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", __func__, start_address, write_length);
498 usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, 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", __func__, 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", __func__, start_address, write_length);
525 usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, 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", __func__, 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 */
553 static 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", __func__);
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", __func__, 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", __func__, *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 */
602 exit_is_tx_active:
603 dbg ("%s - return %d", __func__, bytes_left );
604
605 kfree(lsr);
606 kfree(oedb);
607 return bytes_left;
608 }
609
610 static 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, DIV_ROUND_UP(10000, baud_rate)));
658 }
659
660 static 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", __func__, dev->config->desc.bNumInterfaces);
668 dbg ("%s - MAX Power = %d", __func__, 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", __func__);
672 return -ENODEV;
673 }
674
675 return 0;
676 }
677
678 static 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
698 static 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 */
719 static 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 */
745 static 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", __func__, rom_desc->CheckSum, cs);
755 return -EINVAL;
756 }
757 return 0;
758 }
759
760 /* Make sure that the I2C image is good */
761 static 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", __func__);
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", __func__);
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", __func__);
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.", __func__);
805 break;
806 }
807
808 dbg ("%s Type = 0x%x", __func__, 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
833 ExitTiValidateI2cImage:
834 kfree (buffer);
835 kfree (rom_desc);
836 return status;
837 }
838
839 static 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", __func__);
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", __func__);
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", __func__, desc->IonConfig );
871 dbg ( "%s - Version %d", __func__, desc->Version );
872 dbg ( "%s - Cpu/Board 0x%x", __func__, desc->CpuRev_BoardRev );
873 dbg ( "%s - NumPorts %d", __func__, desc->NumPorts );
874 dbg ( "%s - NumVirtualPorts %d", __func__, desc->NumVirtualPorts );
875 dbg ( "%s - TotalPorts %d", __func__, desc->TotalPorts );
876
877 exit:
878 kfree (rom_desc);
879 return status;
880 }
881
882 /* Build firmware header used for firmware update */
883 static 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", __func__);
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 */
945 static 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", __func__, status);
959 else
960 dbg ("%s - read 2 data = 0x%x", __func__, data);
961 if ((!status) && (data == UMP5152 || data == UMP3410)) {
962 dbg ("%s - ROM_TYPE_II", __func__);
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", __func__, status);
976 else
977 dbg ("%s - read 2 data = 0x%x", __func__, data);
978 if ((!status) && (data == UMP5152 || data == UMP3410)) {
979 dbg ("%s - ROM_TYPE_III", __func__);
980 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
981 return 0;
982 }
983
984 dbg ("%s - Unknown", __func__);
985 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
986 return -ENODEV;
987 }
988
989 static 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) */
1004 static 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!!!
1030 static 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 */
1041 static 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", __func__);
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
1089 dbg("%s - RUNNING IN DOWNLOAD MODE", __func__);
1090
1091 status = TiValidateI2cImage (serial);
1092 if (status) {
1093 dbg("%s - DOWNLOAD MODE -- BAD I2C", __func__);
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", __func__);
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)", __func__,
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", __func__);
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", __func__);
1132
1133 firmware_version = kmalloc (sizeof (*firmware_version), GFP_KERNEL);
1134 if (!firmware_version) {
1135 dev_err (dev, "%s - out of memory.\n", __func__);
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 __func__,
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 __func__,
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", __func__);
1213 kfree (firmware_version);
1214 kfree (rom_desc);
1215 kfree (ti_manuf_desc);
1216 return -ENODEV;
1217 }
1218
1219 dbg ("%s - HARDWARE RESET", __func__);
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", __func__, 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", __func__);
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", __func__);
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", __func__);
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", __func__);
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", __func__);
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", __func__);
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", __func__, status);
1330 if (status) {
1331 dev_err (dev, "%s - UMPC_COPY_DNLD_TO_I2C failed\n", __func__);
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 /********************************************************************/
1347 dbg("%s - RUNNING IN BOOT MODE", __func__);
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", __func__,
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", __func__);
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", __func__);
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)", __func__,
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", __func__);
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)", __func__);
1442 status = TIDownloadCodeImage (serial, buffer, buffer_size);
1443
1444 kfree (buffer);
1445
1446 if (status) {
1447 dbg ("%s - Error downloading operational code image", __func__);
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...", __func__);
1455
1456 /* return an error on purpose */
1457 return -ENODEV;
1458 }
1459
1460 StayInBootMode:
1461 // Eprom is invalid or blank stay in boot mode
1462 dbg("%s - STAYING IN BOOT MODE", __func__);
1463 serial->product_info.TiMode = TI_MODE_BOOT;
1464
1465 return 0;
1466 }
1467
1468
1469 static int TISetDtr (struct edgeport_port *port)
1470 {
1471 int port_number = port->port->number - port->port->serial->minor;
1472
1473 dbg ("%s", __func__);
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
1484 static int TIClearDtr (struct edgeport_port *port)
1485 {
1486 int port_number = port->port->number - port->port->serial->minor;
1487
1488 dbg ("%s", __func__);
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
1499 static int TISetRts (struct edgeport_port *port)
1500 {
1501 int port_number = port->port->number - port->port->serial->minor;
1502
1503 dbg ("%s", __func__);
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
1514 static int TIClearRts (struct edgeport_port *port)
1515 {
1516 int port_number = port->port->number - port->port->serial->minor;
1517
1518 dbg ("%s", __func__);
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
1529 static int TISetLoopBack (struct edgeport_port *port)
1530 {
1531 int port_number = port->port->number - port->port->serial->minor;
1532
1533 dbg ("%s", __func__);
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
1543 static int TIClearLoopBack (struct edgeport_port *port)
1544 {
1545 int port_number = port->port->number - port->port->serial->minor;
1546
1547 dbg ("%s", __func__);
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
1557 static int TISetBreak (struct edgeport_port *port)
1558 {
1559 int port_number = port->port->number - port->port->serial->minor;
1560
1561 dbg ("%s", __func__);
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
1571 static int TIClearBreak (struct edgeport_port *port)
1572 {
1573 int port_number = port->port->number - port->port->serial->minor;
1574
1575 dbg ("%s", __func__);
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
1585 static int TIRestoreMCR (struct edgeport_port *port, __u8 mcr)
1586 {
1587 int status = 0;
1588
1589 dbg ("%s - %x", __func__, 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 */
1618 static __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
1638 static 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", __func__, 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
1677 static 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", __func__, 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
1711 static void edge_interrupt_callback (struct urb *urb)
1712 {
1713 struct edgeport_serial *edge_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;
1720 int retval;
1721 __u8 lsr;
1722 __u8 msr;
1723 int status = urb->status;
1724
1725 dbg("%s", __func__);
1726
1727 switch (status) {
1728 case 0:
1729 /* success */
1730 break;
1731 case -ECONNRESET:
1732 case -ENOENT:
1733 case -ESHUTDOWN:
1734 /* this urb is terminated, clean up */
1735 dbg("%s - urb shutting down with status: %d",
1736 __func__, status);
1737 return;
1738 default:
1739 dev_err(&urb->dev->dev, "%s - nonzero urb status received: "
1740 "%d\n", __func__, status);
1741 goto exit;
1742 }
1743
1744 if (!length) {
1745 dbg ("%s - no data in urb", __func__);
1746 goto exit;
1747 }
1748
1749 usb_serial_debug_data(debug, &edge_serial->serial->dev->dev, __func__, length, data);
1750
1751 if (length != 2) {
1752 dbg ("%s - expecting packet of size 2, got %d", __func__, 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 __func__, 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", __func__);
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 __func__, 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 __func__, 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 __func__, 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 __func__, data[1]);
1793 break;
1794
1795 }
1796
1797 exit:
1798 retval = usb_submit_urb (urb, GFP_ATOMIC);
1799 if (retval)
1800 dev_err (&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
1801 __func__, retval);
1802 }
1803
1804 static void edge_bulk_in_callback (struct urb *urb)
1805 {
1806 struct edgeport_port *edge_port = urb->context;
1807 unsigned char *data = urb->transfer_buffer;
1808 struct tty_struct *tty;
1809 int retval = 0;
1810 int port_number;
1811 int status = urb->status;
1812
1813 dbg("%s", __func__);
1814
1815 switch (status) {
1816 case 0:
1817 /* success */
1818 break;
1819 case -ECONNRESET:
1820 case -ENOENT:
1821 case -ESHUTDOWN:
1822 /* this urb is terminated, clean up */
1823 dbg("%s - urb shutting down with status: %d",
1824 __func__, status);
1825 return;
1826 default:
1827 dev_err (&urb->dev->dev,"%s - nonzero read bulk status received: %d\n",
1828 __func__, status);
1829 }
1830
1831 if (status == -EPIPE)
1832 goto exit;
1833
1834 if (status) {
1835 dev_err(&urb->dev->dev,"%s - stopping read!\n", __func__);
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 __func__, 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, __func__, urb->actual_length, data);
1854
1855 if (edge_port->close_pending) {
1856 dbg ("%s - close is pending, dropping data on the floor.", __func__);
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
1863 exit:
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;
1868 retval = usb_submit_urb(urb, GFP_ATOMIC);
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);
1873 if (retval)
1874 dev_err (&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
1875 __func__, retval);
1876 }
1877
1878 static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned char *data, int length)
1879 {
1880 int cnt;
1881
1882 do {
1883 cnt = tty_buffer_request_room(tty, length);
1884 if (cnt < length) {
1885 dev_err(dev, "%s - dropping data, %d bytes lost\n",
1886 __func__, length - cnt);
1887 if(cnt == 0)
1888 break;
1889 }
1890 tty_insert_flip_string(tty, data, cnt);
1891 data += cnt;
1892 length -= cnt;
1893 } while (length > 0);
1894
1895 tty_flip_buffer_push(tty);
1896 }
1897
1898 static void edge_bulk_out_callback (struct urb *urb)
1899 {
1900 struct usb_serial_port *port = urb->context;
1901 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1902 int status = urb->status;
1903
1904 dbg ("%s - port %d", __func__, port->number);
1905
1906 edge_port->ep_write_urb_in_use = 0;
1907
1908 switch (status) {
1909 case 0:
1910 /* success */
1911 break;
1912 case -ECONNRESET:
1913 case -ENOENT:
1914 case -ESHUTDOWN:
1915 /* this urb is terminated, clean up */
1916 dbg("%s - urb shutting down with status: %d",
1917 __func__, status);
1918 return;
1919 default:
1920 dev_err(&urb->dev->dev, "%s - nonzero write bulk status "
1921 "received: %d\n", __func__, status);
1922 }
1923
1924 /* send any buffered data */
1925 edge_send(port);
1926 }
1927
1928 static 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", __func__, port->number);
1940
1941 if (edge_port == NULL)
1942 return -ENODEV;
1943
1944 port->tty->low_latency = low_latency;
1945
1946 port_number = port->number - port->serial->minor;
1947 switch (port_number) {
1948 case 0:
1949 edge_port->uart_base = UMPMEM_BASE_UART1;
1950 edge_port->dma_address = UMPD_OEDB1_ADDRESS;
1951 break;
1952 case 1:
1953 edge_port->uart_base = UMPMEM_BASE_UART2;
1954 edge_port->dma_address = UMPD_OEDB2_ADDRESS;
1955 break;
1956 default:
1957 dev_err (&port->dev, "Unknown port number!!!\n");
1958 return -ENODEV;
1959 }
1960
1961 dbg ("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
1962 __func__, port_number, edge_port->uart_base, edge_port->dma_address);
1963
1964 dev = port->serial->dev;
1965
1966 memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
1967 init_waitqueue_head (&edge_port->delta_msr_wait);
1968
1969 /* turn off loopback */
1970 status = TIClearLoopBack (edge_port);
1971 if (status) {
1972 dev_err(&port->dev,"%s - cannot send clear loopback command, %d\n",
1973 __func__, status);
1974 return status;
1975 }
1976
1977 /* set up the port settings */
1978 edge_set_termios (port, port->tty->termios);
1979
1980 /* open up the port */
1981
1982 /* milliseconds to timeout for DMA transfer */
1983 transaction_timeout = 2;
1984
1985 edge_port->ump_read_timeout = max (20, ((transaction_timeout * 3) / 2) );
1986
1987 // milliseconds to timeout for DMA transfer
1988 open_settings = (u8)(UMP_DMA_MODE_CONTINOUS |
1989 UMP_PIPE_TRANS_TIMEOUT_ENA |
1990 (transaction_timeout << 2));
1991
1992 dbg ("%s - Sending UMPC_OPEN_PORT", __func__);
1993
1994 /* Tell TI to open and start the port */
1995 status = TIWriteCommandSync (dev,
1996 UMPC_OPEN_PORT,
1997 (u8)(UMPM_UART1_PORT + port_number),
1998 open_settings,
1999 NULL,
2000 0);
2001 if (status) {
2002 dev_err(&port->dev,"%s - cannot send open command, %d\n", __func__, status);
2003 return status;
2004 }
2005
2006 /* Start the DMA? */
2007 status = TIWriteCommandSync (dev,
2008 UMPC_START_PORT,
2009 (u8)(UMPM_UART1_PORT + port_number),
2010 0,
2011 NULL,
2012 0);
2013 if (status) {
2014 dev_err(&port->dev,"%s - cannot send start DMA command, %d\n", __func__, status);
2015 return status;
2016 }
2017
2018 /* Clear TX and RX buffers in UMP */
2019 status = TIPurgeDataSync (port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
2020 if (status) {
2021 dev_err(&port->dev,"%s - cannot send clear buffers command, %d\n", __func__, status);
2022 return status;
2023 }
2024
2025 /* Read Initial MSR */
2026 status = TIReadVendorRequestSync (dev,
2027 UMPC_READ_MSR, // Request
2028 0, // wValue
2029 (__u16)(UMPM_UART1_PORT + port_number), // wIndex (Address)
2030 &edge_port->shadow_msr, // TransferBuffer
2031 1); // TransferBufferLength
2032 if (status) {
2033 dev_err(&port->dev,"%s - cannot send read MSR command, %d\n", __func__, status);
2034 return status;
2035 }
2036
2037 dbg ("ShadowMSR 0x%X", edge_port->shadow_msr);
2038
2039 /* Set Initial MCR */
2040 edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
2041 dbg ("ShadowMCR 0x%X", edge_port->shadow_mcr);
2042
2043 edge_serial = edge_port->edge_serial;
2044 if (mutex_lock_interruptible(&edge_serial->es_lock))
2045 return -ERESTARTSYS;
2046 if (edge_serial->num_ports_open == 0) {
2047 /* we are the first port to be opened, let's post the interrupt urb */
2048 urb = edge_serial->serial->port[0]->interrupt_in_urb;
2049 if (!urb) {
2050 dev_err (&port->dev, "%s - no interrupt urb present, exiting\n", __func__);
2051 status = -EINVAL;
2052 goto release_es_lock;
2053 }
2054 urb->complete = edge_interrupt_callback;
2055 urb->context = edge_serial;
2056 urb->dev = dev;
2057 status = usb_submit_urb (urb, GFP_KERNEL);
2058 if (status) {
2059 dev_err (&port->dev, "%s - usb_submit_urb failed with value %d\n", __func__, status);
2060 goto release_es_lock;
2061 }
2062 }
2063
2064 /*
2065 * reset the data toggle on the bulk endpoints to work around bug in
2066 * host controllers where things get out of sync some times
2067 */
2068 usb_clear_halt (dev, port->write_urb->pipe);
2069 usb_clear_halt (dev, port->read_urb->pipe);
2070
2071 /* start up our bulk read urb */
2072 urb = port->read_urb;
2073 if (!urb) {
2074 dev_err (&port->dev, "%s - no read urb present, exiting\n", __func__);
2075 status = -EINVAL;
2076 goto unlink_int_urb;
2077 }
2078 edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2079 urb->complete = edge_bulk_in_callback;
2080 urb->context = edge_port;
2081 urb->dev = dev;
2082 status = usb_submit_urb (urb, GFP_KERNEL);
2083 if (status) {
2084 dev_err (&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __func__, status);
2085 goto unlink_int_urb;
2086 }
2087
2088 ++edge_serial->num_ports_open;
2089
2090 dbg("%s - exited", __func__);
2091
2092 goto release_es_lock;
2093
2094 unlink_int_urb:
2095 if (edge_port->edge_serial->num_ports_open == 0)
2096 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2097 release_es_lock:
2098 mutex_unlock(&edge_serial->es_lock);
2099 return status;
2100 }
2101
2102 static void edge_close (struct usb_serial_port *port, struct file *filp)
2103 {
2104 struct edgeport_serial *edge_serial;
2105 struct edgeport_port *edge_port;
2106 int port_number;
2107 int status;
2108
2109 dbg("%s - port %d", __func__, port->number);
2110
2111 edge_serial = usb_get_serial_data(port->serial);
2112 edge_port = usb_get_serial_port_data(port);
2113 if ((edge_serial == NULL) || (edge_port == NULL))
2114 return;
2115
2116 /* The bulkreadcompletion routine will check
2117 * this flag and dump add read data */
2118 edge_port->close_pending = 1;
2119
2120 /* chase the port close and flush */
2121 TIChasePort (edge_port, (HZ*closing_wait)/100, 1);
2122
2123 usb_kill_urb(port->read_urb);
2124 usb_kill_urb(port->write_urb);
2125 edge_port->ep_write_urb_in_use = 0;
2126
2127 /* assuming we can still talk to the device,
2128 * send a close port command to it */
2129 dbg("%s - send umpc_close_port", __func__);
2130 port_number = port->number - port->serial->minor;
2131 status = TIWriteCommandSync (port->serial->dev,
2132 UMPC_CLOSE_PORT,
2133 (__u8)(UMPM_UART1_PORT + port_number),
2134 0,
2135 NULL,
2136 0);
2137 mutex_lock(&edge_serial->es_lock);
2138 --edge_port->edge_serial->num_ports_open;
2139 if (edge_port->edge_serial->num_ports_open <= 0) {
2140 /* last port is now closed, let's shut down our interrupt urb */
2141 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2142 edge_port->edge_serial->num_ports_open = 0;
2143 }
2144 mutex_unlock(&edge_serial->es_lock);
2145 edge_port->close_pending = 0;
2146
2147 dbg("%s - exited", __func__);
2148 }
2149
2150 static int edge_write (struct usb_serial_port *port, const unsigned char *data, int count)
2151 {
2152 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2153 unsigned long flags;
2154
2155 dbg("%s - port %d", __func__, port->number);
2156
2157 if (count == 0) {
2158 dbg("%s - write request of 0 bytes", __func__);
2159 return 0;
2160 }
2161
2162 if (edge_port == NULL)
2163 return -ENODEV;
2164 if (edge_port->close_pending == 1)
2165 return -ENODEV;
2166
2167 spin_lock_irqsave(&edge_port->ep_lock, flags);
2168 count = edge_buf_put(edge_port->ep_out_buf, data, count);
2169 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2170
2171 edge_send(port);
2172
2173 return count;
2174 }
2175
2176 static void edge_send(struct usb_serial_port *port)
2177 {
2178 int count, result;
2179 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2180 struct tty_struct *tty = port->tty;
2181 unsigned long flags;
2182
2183
2184 dbg("%s - port %d", __func__, port->number);
2185
2186 spin_lock_irqsave(&edge_port->ep_lock, flags);
2187
2188 if (edge_port->ep_write_urb_in_use) {
2189 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2190 return;
2191 }
2192
2193 count = edge_buf_get(edge_port->ep_out_buf,
2194 port->write_urb->transfer_buffer,
2195 port->bulk_out_size);
2196
2197 if (count == 0) {
2198 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2199 return;
2200 }
2201
2202 edge_port->ep_write_urb_in_use = 1;
2203
2204 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2205
2206 usb_serial_debug_data(debug, &port->dev, __func__, count, port->write_urb->transfer_buffer);
2207
2208 /* set up our urb */
2209 usb_fill_bulk_urb (port->write_urb, port->serial->dev,
2210 usb_sndbulkpipe (port->serial->dev,
2211 port->bulk_out_endpointAddress),
2212 port->write_urb->transfer_buffer, count,
2213 edge_bulk_out_callback,
2214 port);
2215
2216 /* send the data out the bulk port */
2217 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
2218 if (result) {
2219 dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__, result);
2220 edge_port->ep_write_urb_in_use = 0;
2221 // TODO: reschedule edge_send
2222 } else {
2223 edge_port->icount.tx += count;
2224 }
2225
2226 /* wakeup any process waiting for writes to complete */
2227 /* there is now more room in the buffer for new writes */
2228 if (tty) {
2229 /* let the tty driver wakeup if it has a special write_wakeup function */
2230 tty_wakeup(tty);
2231 }
2232 }
2233
2234 static int edge_write_room (struct usb_serial_port *port)
2235 {
2236 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2237 int room = 0;
2238 unsigned long flags;
2239
2240 dbg("%s - port %d", __func__, port->number);
2241
2242 if (edge_port == NULL)
2243 return -ENODEV;
2244 if (edge_port->close_pending == 1)
2245 return -ENODEV;
2246
2247 spin_lock_irqsave(&edge_port->ep_lock, flags);
2248 room = edge_buf_space_avail(edge_port->ep_out_buf);
2249 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2250
2251 dbg("%s - returns %d", __func__, room);
2252 return room;
2253 }
2254
2255 static int edge_chars_in_buffer (struct usb_serial_port *port)
2256 {
2257 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2258 int chars = 0;
2259 unsigned long flags;
2260
2261 dbg("%s - port %d", __func__, port->number);
2262
2263 if (edge_port == NULL)
2264 return -ENODEV;
2265 if (edge_port->close_pending == 1)
2266 return -ENODEV;
2267
2268 spin_lock_irqsave(&edge_port->ep_lock, flags);
2269 chars = edge_buf_data_avail(edge_port->ep_out_buf);
2270 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2271
2272 dbg ("%s - returns %d", __func__, chars);
2273 return chars;
2274 }
2275
2276 static void edge_throttle (struct usb_serial_port *port)
2277 {
2278 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2279 struct tty_struct *tty;
2280 int status;
2281
2282 dbg("%s - port %d", __func__, port->number);
2283
2284 if (edge_port == NULL)
2285 return;
2286
2287 tty = port->tty;
2288 if (!tty) {
2289 dbg ("%s - no tty available", __func__);
2290 return;
2291 }
2292
2293 /* if we are implementing XON/XOFF, send the stop character */
2294 if (I_IXOFF(tty)) {
2295 unsigned char stop_char = STOP_CHAR(tty);
2296 status = edge_write (port, &stop_char, 1);
2297 if (status <= 0) {
2298 dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
2299 }
2300 }
2301
2302 /* if we are implementing RTS/CTS, stop reads */
2303 /* and the Edgeport will clear the RTS line */
2304 if (C_CRTSCTS(tty))
2305 stop_read(edge_port);
2306
2307 }
2308
2309 static void edge_unthrottle (struct usb_serial_port *port)
2310 {
2311 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2312 struct tty_struct *tty;
2313 int status;
2314
2315 dbg("%s - port %d", __func__, port->number);
2316
2317 if (edge_port == NULL)
2318 return;
2319
2320 tty = port->tty;
2321 if (!tty) {
2322 dbg ("%s - no tty available", __func__);
2323 return;
2324 }
2325
2326 /* if we are implementing XON/XOFF, send the start character */
2327 if (I_IXOFF(tty)) {
2328 unsigned char start_char = START_CHAR(tty);
2329 status = edge_write (port, &start_char, 1);
2330 if (status <= 0) {
2331 dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
2332 }
2333 }
2334
2335 /* if we are implementing RTS/CTS, restart reads */
2336 /* are the Edgeport will assert the RTS line */
2337 if (C_CRTSCTS(tty)) {
2338 status = restart_read(edge_port);
2339 if (status)
2340 dev_err(&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __func__, status);
2341 }
2342
2343 }
2344
2345 static void stop_read(struct edgeport_port *edge_port)
2346 {
2347 unsigned long flags;
2348
2349 spin_lock_irqsave(&edge_port->ep_lock, flags);
2350
2351 if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
2352 edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;
2353 edge_port->shadow_mcr &= ~MCR_RTS;
2354
2355 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2356 }
2357
2358 static int restart_read(struct edgeport_port *edge_port)
2359 {
2360 struct urb *urb;
2361 int status = 0;
2362 unsigned long flags;
2363
2364 spin_lock_irqsave(&edge_port->ep_lock, flags);
2365
2366 if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {
2367 urb = edge_port->port->read_urb;
2368 urb->complete = edge_bulk_in_callback;
2369 urb->context = edge_port;
2370 urb->dev = edge_port->port->serial->dev;
2371 status = usb_submit_urb(urb, GFP_ATOMIC);
2372 }
2373 edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2374 edge_port->shadow_mcr |= MCR_RTS;
2375
2376 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2377
2378 return status;
2379 }
2380
2381 static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios)
2382 {
2383 struct ump_uart_config *config;
2384 struct tty_struct *tty;
2385 int baud;
2386 unsigned cflag;
2387 int status;
2388 int port_number = edge_port->port->number - edge_port->port->serial->minor;
2389
2390 dbg("%s - port %d", __func__, edge_port->port->number);
2391
2392 tty = edge_port->port->tty;
2393
2394 config = kmalloc (sizeof (*config), GFP_KERNEL);
2395 if (!config) {
2396 dev_err (&edge_port->port->dev, "%s - out of memory\n", __func__);
2397 return;
2398 }
2399
2400 cflag = tty->termios->c_cflag;
2401
2402 config->wFlags = 0;
2403
2404 /* These flags must be set */
2405 config->wFlags |= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
2406 config->wFlags |= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
2407 config->bUartMode = (__u8)(edge_port->bUartMode);
2408
2409 switch (cflag & CSIZE) {
2410 case CS5:
2411 config->bDataBits = UMP_UART_CHAR5BITS;
2412 dbg ("%s - data bits = 5", __func__);
2413 break;
2414 case CS6:
2415 config->bDataBits = UMP_UART_CHAR6BITS;
2416 dbg ("%s - data bits = 6", __func__);
2417 break;
2418 case CS7:
2419 config->bDataBits = UMP_UART_CHAR7BITS;
2420 dbg ("%s - data bits = 7", __func__);
2421 break;
2422 default:
2423 case CS8:
2424 config->bDataBits = UMP_UART_CHAR8BITS;
2425 dbg ("%s - data bits = 8", __func__);
2426 break;
2427 }
2428
2429 if (cflag & PARENB) {
2430 if (cflag & PARODD) {
2431 config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2432 config->bParity = UMP_UART_ODDPARITY;
2433 dbg("%s - parity = odd", __func__);
2434 } else {
2435 config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2436 config->bParity = UMP_UART_EVENPARITY;
2437 dbg("%s - parity = even", __func__);
2438 }
2439 } else {
2440 config->bParity = UMP_UART_NOPARITY;
2441 dbg("%s - parity = none", __func__);
2442 }
2443
2444 if (cflag & CSTOPB) {
2445 config->bStopBits = UMP_UART_STOPBIT2;
2446 dbg("%s - stop bits = 2", __func__);
2447 } else {
2448 config->bStopBits = UMP_UART_STOPBIT1;
2449 dbg("%s - stop bits = 1", __func__);
2450 }
2451
2452 /* figure out the flow control settings */
2453 if (cflag & CRTSCTS) {
2454 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
2455 config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
2456 dbg("%s - RTS/CTS is enabled", __func__);
2457 } else {
2458 dbg("%s - RTS/CTS is disabled", __func__);
2459 tty->hw_stopped = 0;
2460 restart_read(edge_port);
2461 }
2462
2463 /* if we are implementing XON/XOFF, set the start and stop character in the device */
2464 if (I_IXOFF(tty) || I_IXON(tty)) {
2465 config->cXon = START_CHAR(tty);
2466 config->cXoff = STOP_CHAR(tty);
2467
2468 /* if we are implementing INBOUND XON/XOFF */
2469 if (I_IXOFF(tty)) {
2470 config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
2471 dbg ("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2472 __func__, config->cXon, config->cXoff);
2473 } else {
2474 dbg ("%s - INBOUND XON/XOFF is disabled", __func__);
2475 }
2476
2477 /* if we are implementing OUTBOUND XON/XOFF */
2478 if (I_IXON(tty)) {
2479 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
2480 dbg ("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2481 __func__, config->cXon, config->cXoff);
2482 } else {
2483 dbg ("%s - OUTBOUND XON/XOFF is disabled", __func__);
2484 }
2485 }
2486
2487 tty->termios->c_cflag &= ~CMSPAR;
2488
2489 /* Round the baud rate */
2490 baud = tty_get_baud_rate(tty);
2491 if (!baud) {
2492 /* pick a default, any default... */
2493 baud = 9600;
2494 } else
2495 tty_encode_baud_rate(tty, baud, baud);
2496
2497 edge_port->baud_rate = baud;
2498 config->wBaudRate = (__u16)((461550L + baud/2) / baud);
2499
2500 /* FIXME: Recompute actual baud from divisor here */
2501
2502 dbg ("%s - baud rate = %d, wBaudRate = %d", __func__, baud, config->wBaudRate);
2503
2504 dbg ("wBaudRate: %d", (int)(461550L / config->wBaudRate));
2505 dbg ("wFlags: 0x%x", config->wFlags);
2506 dbg ("bDataBits: %d", config->bDataBits);
2507 dbg ("bParity: %d", config->bParity);
2508 dbg ("bStopBits: %d", config->bStopBits);
2509 dbg ("cXon: %d", config->cXon);
2510 dbg ("cXoff: %d", config->cXoff);
2511 dbg ("bUartMode: %d", config->bUartMode);
2512
2513 /* move the word values into big endian mode */
2514 cpu_to_be16s (&config->wFlags);
2515 cpu_to_be16s (&config->wBaudRate);
2516
2517 status = TIWriteCommandSync (edge_port->port->serial->dev,
2518 UMPC_SET_CONFIG,
2519 (__u8)(UMPM_UART1_PORT + port_number),
2520 0,
2521 (__u8 *)config,
2522 sizeof(*config));
2523 if (status) {
2524 dbg ("%s - error %d when trying to write config to device",
2525 __func__, status);
2526 }
2527
2528 kfree (config);
2529
2530 return;
2531 }
2532
2533 static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
2534 {
2535 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2536 struct tty_struct *tty = port->tty;
2537 unsigned int cflag;
2538
2539 cflag = tty->termios->c_cflag;
2540
2541 dbg("%s - clfag %08x iflag %08x", __func__,
2542 tty->termios->c_cflag, tty->termios->c_iflag);
2543 dbg("%s - old clfag %08x old iflag %08x", __func__,
2544 old_termios->c_cflag, old_termios->c_iflag);
2545
2546 dbg("%s - port %d", __func__, port->number);
2547
2548 if (edge_port == NULL)
2549 return;
2550
2551 /* change the port settings to the new ones specified */
2552 change_port_settings (edge_port, old_termios);
2553
2554 return;
2555 }
2556
2557 static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear)
2558 {
2559 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2560 unsigned int mcr;
2561 unsigned long flags;
2562
2563 dbg("%s - port %d", __func__, port->number);
2564
2565 spin_lock_irqsave(&edge_port->ep_lock, flags);
2566 mcr = edge_port->shadow_mcr;
2567 if (set & TIOCM_RTS)
2568 mcr |= MCR_RTS;
2569 if (set & TIOCM_DTR)
2570 mcr |= MCR_DTR;
2571 if (set & TIOCM_LOOP)
2572 mcr |= MCR_LOOPBACK;
2573
2574 if (clear & TIOCM_RTS)
2575 mcr &= ~MCR_RTS;
2576 if (clear & TIOCM_DTR)
2577 mcr &= ~MCR_DTR;
2578 if (clear & TIOCM_LOOP)
2579 mcr &= ~MCR_LOOPBACK;
2580
2581 edge_port->shadow_mcr = mcr;
2582 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2583
2584 TIRestoreMCR (edge_port, mcr);
2585
2586 return 0;
2587 }
2588
2589 static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
2590 {
2591 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2592 unsigned int result = 0;
2593 unsigned int msr;
2594 unsigned int mcr;
2595 unsigned long flags;
2596
2597 dbg("%s - port %d", __func__, port->number);
2598
2599 spin_lock_irqsave(&edge_port->ep_lock, flags);
2600
2601 msr = edge_port->shadow_msr;
2602 mcr = edge_port->shadow_mcr;
2603 result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
2604 | ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
2605 | ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
2606 | ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */
2607 | ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
2608 | ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
2609
2610
2611 dbg("%s -- %x", __func__, result);
2612 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2613
2614 return result;
2615 }
2616
2617 static int get_serial_info (struct edgeport_port *edge_port, struct serial_struct __user *retinfo)
2618 {
2619 struct serial_struct tmp;
2620
2621 if (!retinfo)
2622 return -EFAULT;
2623
2624 memset(&tmp, 0, sizeof(tmp));
2625
2626 tmp.type = PORT_16550A;
2627 tmp.line = edge_port->port->serial->minor;
2628 tmp.port = edge_port->port->number;
2629 tmp.irq = 0;
2630 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
2631 tmp.xmit_fifo_size = edge_port->port->bulk_out_size;
2632 tmp.baud_base = 9600;
2633 tmp.close_delay = 5*HZ;
2634 tmp.closing_wait = closing_wait;
2635 // tmp.custom_divisor = state->custom_divisor;
2636 // tmp.hub6 = state->hub6;
2637 // tmp.io_type = state->io_type;
2638
2639
2640 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2641 return -EFAULT;
2642 return 0;
2643 }
2644
2645 static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
2646 {
2647 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2648 struct async_icount cnow;
2649 struct async_icount cprev;
2650
2651 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
2652
2653 switch (cmd) {
2654 case TIOCINQ:
2655 dbg("%s - (%d) TIOCINQ", __func__, port->number);
2656 // return get_number_bytes_avail(edge_port, (unsigned int *) arg);
2657 break;
2658
2659 case TIOCSERGETLSR:
2660 dbg("%s - (%d) TIOCSERGETLSR", __func__, port->number);
2661 // return get_lsr_info(edge_port, (unsigned int *) arg);
2662 break;
2663
2664 case TIOCGSERIAL:
2665 dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
2666 return get_serial_info(edge_port, (struct serial_struct __user *) arg);
2667 break;
2668
2669 case TIOCSSERIAL:
2670 dbg("%s - (%d) TIOCSSERIAL", __func__, port->number);
2671 break;
2672
2673 case TIOCMIWAIT:
2674 dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
2675 cprev = edge_port->icount;
2676 while (1) {
2677 interruptible_sleep_on(&edge_port->delta_msr_wait);
2678 /* see if a signal did it */
2679 if (signal_pending(current))
2680 return -ERESTARTSYS;
2681 cnow = edge_port->icount;
2682 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2683 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2684 return -EIO; /* no change => error */
2685 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2686 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2687 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2688 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2689 return 0;
2690 }
2691 cprev = cnow;
2692 }
2693 /* not reached */
2694 break;
2695
2696 case TIOCGICOUNT:
2697 dbg ("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
2698 port->number, edge_port->icount.rx, edge_port->icount.tx);
2699 if (copy_to_user((void __user *)arg, &edge_port->icount, sizeof(edge_port->icount)))
2700 return -EFAULT;
2701 return 0;
2702 }
2703
2704 return -ENOIOCTLCMD;
2705 }
2706
2707 static void edge_break (struct usb_serial_port *port, int break_state)
2708 {
2709 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2710 int status;
2711
2712 dbg ("%s - state = %d", __func__, break_state);
2713
2714 /* chase the port close */
2715 TIChasePort (edge_port, 0, 0);
2716
2717 if (break_state == -1) {
2718 status = TISetBreak (edge_port);
2719 } else {
2720 status = TIClearBreak (edge_port);
2721 }
2722 if (status) {
2723 dbg ("%s - error %d sending break set/clear command.",
2724 __func__, status);
2725 }
2726 }
2727
2728 static int edge_startup (struct usb_serial *serial)
2729 {
2730 struct edgeport_serial *edge_serial;
2731 struct edgeport_port *edge_port;
2732 struct usb_device *dev;
2733 int status;
2734 int i;
2735
2736 dev = serial->dev;
2737
2738 /* create our private serial structure */
2739 edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2740 if (edge_serial == NULL) {
2741 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2742 return -ENOMEM;
2743 }
2744 mutex_init(&edge_serial->es_lock);
2745 edge_serial->serial = serial;
2746 usb_set_serial_data(serial, edge_serial);
2747
2748 status = TIDownloadFirmware (edge_serial);
2749 if (status) {
2750 kfree (edge_serial);
2751 return status;
2752 }
2753
2754 /* set up our port private structures */
2755 for (i = 0; i < serial->num_ports; ++i) {
2756 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
2757 if (edge_port == NULL) {
2758 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2759 goto cleanup;
2760 }
2761 spin_lock_init(&edge_port->ep_lock);
2762 edge_port->ep_out_buf = edge_buf_alloc(EDGE_OUT_BUF_SIZE);
2763 if (edge_port->ep_out_buf == NULL) {
2764 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2765 kfree(edge_port);
2766 goto cleanup;
2767 }
2768 edge_port->port = serial->port[i];
2769 edge_port->edge_serial = edge_serial;
2770 usb_set_serial_port_data(serial->port[i], edge_port);
2771 edge_port->bUartMode = default_uart_mode;
2772 }
2773
2774 return 0;
2775
2776 cleanup:
2777 for (--i; i>=0; --i) {
2778 edge_port = usb_get_serial_port_data(serial->port[i]);
2779 edge_buf_free(edge_port->ep_out_buf);
2780 kfree(edge_port);
2781 usb_set_serial_port_data(serial->port[i], NULL);
2782 }
2783 kfree (edge_serial);
2784 usb_set_serial_data(serial, NULL);
2785 return -ENOMEM;
2786 }
2787
2788 static void edge_shutdown (struct usb_serial *serial)
2789 {
2790 int i;
2791 struct edgeport_port *edge_port;
2792
2793 dbg ("%s", __func__);
2794
2795 for (i = 0; i < serial->num_ports; ++i) {
2796 edge_port = usb_get_serial_port_data(serial->port[i]);
2797 edge_remove_sysfs_attrs(edge_port->port);
2798 edge_buf_free(edge_port->ep_out_buf);
2799 kfree(edge_port);
2800 usb_set_serial_port_data(serial->port[i], NULL);
2801 }
2802 kfree(usb_get_serial_data(serial));
2803 usb_set_serial_data(serial, NULL);
2804 }
2805
2806
2807 /* Sysfs Attributes */
2808
2809 static ssize_t show_uart_mode(struct device *dev,
2810 struct device_attribute *attr, char *buf)
2811 {
2812 struct usb_serial_port *port = to_usb_serial_port(dev);
2813 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2814
2815 return sprintf(buf, "%d\n", edge_port->bUartMode);
2816 }
2817
2818 static ssize_t store_uart_mode(struct device *dev,
2819 struct device_attribute *attr, const char *valbuf, size_t count)
2820 {
2821 struct usb_serial_port *port = to_usb_serial_port(dev);
2822 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2823 unsigned int v = simple_strtoul(valbuf, NULL, 0);
2824
2825 dbg("%s: setting uart_mode = %d", __func__, v);
2826
2827 if (v < 256)
2828 edge_port->bUartMode = v;
2829 else
2830 dev_err(dev, "%s - uart_mode %d is invalid\n", __func__, v);
2831
2832 return count;
2833 }
2834
2835 static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode, store_uart_mode);
2836
2837 static int edge_create_sysfs_attrs(struct usb_serial_port *port)
2838 {
2839 return device_create_file(&port->dev, &dev_attr_uart_mode);
2840 }
2841
2842 static int edge_remove_sysfs_attrs(struct usb_serial_port *port)
2843 {
2844 device_remove_file(&port->dev, &dev_attr_uart_mode);
2845 return 0;
2846 }
2847
2848
2849 /* Circular Buffer */
2850
2851 /*
2852 * edge_buf_alloc
2853 *
2854 * Allocate a circular buffer and all associated memory.
2855 */
2856
2857 static struct edge_buf *edge_buf_alloc(unsigned int size)
2858 {
2859 struct edge_buf *eb;
2860
2861
2862 if (size == 0)
2863 return NULL;
2864
2865 eb = kmalloc(sizeof(struct edge_buf), GFP_KERNEL);
2866 if (eb == NULL)
2867 return NULL;
2868
2869 eb->buf_buf = kmalloc(size, GFP_KERNEL);
2870 if (eb->buf_buf == NULL) {
2871 kfree(eb);
2872 return NULL;
2873 }
2874
2875 eb->buf_size = size;
2876 eb->buf_get = eb->buf_put = eb->buf_buf;
2877
2878 return eb;
2879 }
2880
2881
2882 /*
2883 * edge_buf_free
2884 *
2885 * Free the buffer and all associated memory.
2886 */
2887
2888 static void edge_buf_free(struct edge_buf *eb)
2889 {
2890 if (eb) {
2891 kfree(eb->buf_buf);
2892 kfree(eb);
2893 }
2894 }
2895
2896
2897 /*
2898 * edge_buf_clear
2899 *
2900 * Clear out all data in the circular buffer.
2901 */
2902
2903 static void edge_buf_clear(struct edge_buf *eb)
2904 {
2905 if (eb != NULL)
2906 eb->buf_get = eb->buf_put;
2907 /* equivalent to a get of all data available */
2908 }
2909
2910
2911 /*
2912 * edge_buf_data_avail
2913 *
2914 * Return the number of bytes of data available in the circular
2915 * buffer.
2916 */
2917
2918 static unsigned int edge_buf_data_avail(struct edge_buf *eb)
2919 {
2920 if (eb != NULL)
2921 return ((eb->buf_size + eb->buf_put - eb->buf_get) % eb->buf_size);
2922 else
2923 return 0;
2924 }
2925
2926
2927 /*
2928 * edge_buf_space_avail
2929 *
2930 * Return the number of bytes of space available in the circular
2931 * buffer.
2932 */
2933
2934 static unsigned int edge_buf_space_avail(struct edge_buf *eb)
2935 {
2936 if (eb != NULL)
2937 return ((eb->buf_size + eb->buf_get - eb->buf_put - 1) % eb->buf_size);
2938 else
2939 return 0;
2940 }
2941
2942
2943 /*
2944 * edge_buf_put
2945 *
2946 * Copy data data from a user buffer and put it into the circular buffer.
2947 * Restrict to the amount of space available.
2948 *
2949 * Return the number of bytes copied.
2950 */
2951
2952 static unsigned int edge_buf_put(struct edge_buf *eb, const char *buf,
2953 unsigned int count)
2954 {
2955 unsigned int len;
2956
2957
2958 if (eb == NULL)
2959 return 0;
2960
2961 len = edge_buf_space_avail(eb);
2962 if (count > len)
2963 count = len;
2964
2965 if (count == 0)
2966 return 0;
2967
2968 len = eb->buf_buf + eb->buf_size - eb->buf_put;
2969 if (count > len) {
2970 memcpy(eb->buf_put, buf, len);
2971 memcpy(eb->buf_buf, buf+len, count - len);
2972 eb->buf_put = eb->buf_buf + count - len;
2973 } else {
2974 memcpy(eb->buf_put, buf, count);
2975 if (count < len)
2976 eb->buf_put += count;
2977 else /* count == len */
2978 eb->buf_put = eb->buf_buf;
2979 }
2980
2981 return count;
2982 }
2983
2984
2985 /*
2986 * edge_buf_get
2987 *
2988 * Get data from the circular buffer and copy to the given buffer.
2989 * Restrict to the amount of data available.
2990 *
2991 * Return the number of bytes copied.
2992 */
2993
2994 static unsigned int edge_buf_get(struct edge_buf *eb, char *buf,
2995 unsigned int count)
2996 {
2997 unsigned int len;
2998
2999
3000 if (eb == NULL)
3001 return 0;
3002
3003 len = edge_buf_data_avail(eb);
3004 if (count > len)
3005 count = len;
3006
3007 if (count == 0)
3008 return 0;
3009
3010 len = eb->buf_buf + eb->buf_size - eb->buf_get;
3011 if (count > len) {
3012 memcpy(buf, eb->buf_get, len);
3013 memcpy(buf+len, eb->buf_buf, count - len);
3014 eb->buf_get = eb->buf_buf + count - len;
3015 } else {
3016 memcpy(buf, eb->buf_get, count);
3017 if (count < len)
3018 eb->buf_get += count;
3019 else /* count == len */
3020 eb->buf_get = eb->buf_buf;
3021 }
3022
3023 return count;
3024 }
3025
3026
3027 static struct usb_serial_driver edgeport_1port_device = {
3028 .driver = {
3029 .owner = THIS_MODULE,
3030 .name = "edgeport_ti_1",
3031 },
3032 .description = "Edgeport TI 1 port adapter",
3033 .usb_driver = &io_driver,
3034 .id_table = edgeport_1port_id_table,
3035 .num_ports = 1,
3036 .open = edge_open,
3037 .close = edge_close,
3038 .throttle = edge_throttle,
3039 .unthrottle = edge_unthrottle,
3040 .attach = edge_startup,
3041 .shutdown = edge_shutdown,
3042 .port_probe = edge_create_sysfs_attrs,
3043 .ioctl = edge_ioctl,
3044 .set_termios = edge_set_termios,
3045 .tiocmget = edge_tiocmget,
3046 .tiocmset = edge_tiocmset,
3047 .write = edge_write,
3048 .write_room = edge_write_room,
3049 .chars_in_buffer = edge_chars_in_buffer,
3050 .break_ctl = edge_break,
3051 .read_int_callback = edge_interrupt_callback,
3052 .read_bulk_callback = edge_bulk_in_callback,
3053 .write_bulk_callback = edge_bulk_out_callback,
3054 };
3055
3056 static struct usb_serial_driver edgeport_2port_device = {
3057 .driver = {
3058 .owner = THIS_MODULE,
3059 .name = "edgeport_ti_2",
3060 },
3061 .description = "Edgeport TI 2 port adapter",
3062 .usb_driver = &io_driver,
3063 .id_table = edgeport_2port_id_table,
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,
3071 .port_probe = edge_create_sysfs_attrs,
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
3086 static 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;
3100 failed_usb_register:
3101 usb_serial_deregister(&edgeport_2port_device);
3102 failed_2port_device_register:
3103 usb_serial_deregister(&edgeport_1port_device);
3104 failed_1port_device_register:
3105 return retval;
3106 }
3107
3108 static 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
3115 module_init(edgeport_init);
3116 module_exit(edgeport_exit);
3117
3118 /* Module information */
3119 MODULE_AUTHOR(DRIVER_AUTHOR);
3120 MODULE_DESCRIPTION(DRIVER_DESC);
3121 MODULE_LICENSE("GPL");
3122
3123 module_param(debug, bool, S_IRUGO | S_IWUSR);
3124 MODULE_PARM_DESC(debug, "Debug enabled or not");
3125
3126 module_param(low_latency, bool, S_IRUGO | S_IWUSR);
3127 MODULE_PARM_DESC(low_latency, "Low latency enabled or not");
3128
3129 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
3130 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
3131
3132 module_param(ignore_cpu_rev, bool, S_IRUGO | S_IWUSR);
3133 MODULE_PARM_DESC(ignore_cpu_rev, "Ignore the cpu revision when connecting to a device");
3134
3135 module_param(default_uart_mode, int, S_IRUGO | S_IWUSR);
3136 MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");
3137
Verdex Pro support