?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: use DIV_ROUND_UP
[linux-2.6/x86.git] / drivers / usb / serial / io_ti.c
blob6afee30a6a5ce03c1c1f5045c8f9546dc5667a2e
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 __FUNCTION__, 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 __FUNCTION__, 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", __FUNCTION__, port_number, mask);
348
349 return TIWriteCommandSync (port->serial->dev,
350 UMPC_PURGE_PORT,
351 (__u8)(UMPM_UART1_PORT + port_number),
352 mask,
353 NULL,
354 0);
355 }
356
357 /**
358 * TIReadDownloadMemory - Read edgeport memory from TI chip
359 * @dev: usb device pointer
360 * @start_address: Device CPU address at which to read
361 * @length: Length of above data
362 * @address_type: Can read both XDATA and I2C
363 * @buffer: pointer to input data buffer
364 */
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", __FUNCTION__, start_address, length);
373
374 /* Read in blocks of 64 bytes
375 * (TI firmware can't handle more than 64 byte reads)
376 */
377 while (length) {
378 if (length > 64)
379 read_length= 64;
380 else
381 read_length = (__u8)length;
382
383 if (read_length > 1) {
384 dbg ("%s - @ %x for %d", __FUNCTION__,
385 start_address, read_length);
386 }
387 be_start_address = cpu_to_be16 (start_address);
388 status = TIReadVendorRequestSync (dev,
389 UMPC_MEMORY_READ, // Request
390 (__u16)address_type, // wValue (Address type)
391 (__force __u16)be_start_address, // wIndex (Address to read)
392 buffer, // TransferBuffer
393 read_length); // TransferBufferLength
394
395 if (status) {
396 dbg ("%s - ERROR %x", __FUNCTION__, status);
397 return status;
398 }
399
400 if (read_length > 1) {
401 usb_serial_debug_data(debug, &dev->dev, __FUNCTION__,
402 read_length, buffer);
403 }
404
405 /* Update pointers/length */
406 start_address += read_length;
407 buffer += read_length;
408 length -= read_length;
409 }
410
411 return status;
412 }
413
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", __FUNCTION__, status);
438 return status;
439 }
440 }
441
442 dbg ("%s - start_address = %x, length = %d", __FUNCTION__, start_address, length);
443 usb_serial_debug_data(debug, &serial->serial->dev->dev, __FUNCTION__, length, buffer);
444
445 serial->TiReadI2C = 1;
446
447 return status;
448 }
449
450 /* Write given block to TI EPROM memory */
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", __FUNCTION__, start_address, length);
476 usb_serial_debug_data(debug, &serial->serial->dev->dev, __FUNCTION__, length, buffer);
477
478 return status;
479 }
480
481
482 /* Write edgeport I2C memory to TI chip */
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", __FUNCTION__, start_address, write_length);
498 usb_serial_debug_data(debug, &serial->serial->dev->dev, __FUNCTION__, write_length, buffer);
499
500 /* Write first page */
501 be_start_address = cpu_to_be16 (start_address);
502 status = TISendVendorRequestSync (serial->serial->dev,
503 UMPC_MEMORY_WRITE, // Request
504 (__u16)address_type, // wValue
505 (__force __u16)be_start_address, // wIndex
506 buffer, // TransferBuffer
507 write_length);
508 if (status) {
509 dbg ("%s - ERROR %d", __FUNCTION__, status);
510 return status;
511 }
512
513 length -= write_length;
514 start_address += write_length;
515 buffer += write_length;
516
517 /* We should be aligned now -- can write max page size bytes at a time */
518 while (length) {
519 if (length > EPROM_PAGE_SIZE)
520 write_length = EPROM_PAGE_SIZE;
521 else
522 write_length = length;
523
524 dbg ("%s - Page Write Addr = %x, length = %d", __FUNCTION__, start_address, write_length);
525 usb_serial_debug_data(debug, &serial->serial->dev->dev, __FUNCTION__, write_length, buffer);
526
527 /* Write next page */
528 be_start_address = cpu_to_be16 (start_address);
529 status = TISendVendorRequestSync (serial->serial->dev,
530 UMPC_MEMORY_WRITE, // Request
531 (__u16)address_type, // wValue
532 (__force __u16)be_start_address, // wIndex
533 buffer, // TransferBuffer
534 write_length); // TransferBufferLength
535 if (status) {
536 dev_err (&serial->serial->dev->dev, "%s - ERROR %d\n", __FUNCTION__, status);
537 return status;
538 }
539
540 length -= write_length;
541 start_address += write_length;
542 buffer += write_length;
543 }
544 return status;
545 }
546
547 /* Examine the UMP DMA registers and LSR
548 *
549 * Check the MSBit of the X and Y DMA byte count registers.
550 * A zero in this bit indicates that the TX DMA buffers are empty
551 * then check the TX Empty bit in the UART.
552 */
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", __FUNCTION__);
563 return -ENOMEM;
564 }
565
566 lsr = kmalloc (1, GFP_KERNEL); /* Sigh, that's right, just one byte,
567 as not all platforms can do DMA
568 from stack */
569 if (!lsr) {
570 kfree(oedb);
571 return -ENOMEM;
572 }
573 /* Read the DMA Count Registers */
574 status = TIReadRam (port->port->serial->dev,
575 port->dma_address,
576 sizeof( *oedb),
577 (void *)oedb);
578
579 if (status)
580 goto exit_is_tx_active;
581
582 dbg ("%s - XByteCount 0x%X", __FUNCTION__, oedb->XByteCount);
583
584 /* and the LSR */
585 status = TIReadRam (port->port->serial->dev,
586 port->uart_base + UMPMEM_OFFS_UART_LSR,
587 1,
588 lsr);
589
590 if (status)
591 goto exit_is_tx_active;
592 dbg ("%s - LSR = 0x%X", __FUNCTION__, *lsr);
593
594 /* If either buffer has data or we are transmitting then return TRUE */
595 if ((oedb->XByteCount & 0x80 ) != 0 )
596 bytes_left += 64;
597
598 if ((*lsr & UMP_UART_LSR_TX_MASK ) == 0 )
599 bytes_left += 1;
600
601 /* We return Not Active if we get any kind of error */
602 exit_is_tx_active:
603 dbg ("%s - return %d", __FUNCTION__, 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", __FUNCTION__, dev->config->desc.bNumInterfaces);
668 dbg ("%s - MAX Power = %d", __FUNCTION__, dev->config->desc.bMaxPower*2);
669
670 if (dev->config->desc.bNumInterfaces != 1) {
671 dev_err (&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __FUNCTION__);
672 return -ENODEV;
673 }
674
675 return 0;
676 }
677
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", __FUNCTION__, 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", __FUNCTION__);
773 return -ENOMEM;
774 }
775 buffer = kmalloc (TI_MAX_I2C_SIZE, GFP_KERNEL);
776 if (!buffer) {
777 dev_err (dev, "%s - out of memory when allocating buffer\n", __FUNCTION__);
778 kfree (rom_desc);
779 return -ENOMEM;
780 }
781
782 // Read the first byte (Signature0) must be 0x52 or 0x10
783 status = TIReadRom (serial, 0, 1, buffer);
784 if (status)
785 goto ExitTiValidateI2cImage;
786
787 if (*buffer != UMP5152 && *buffer != UMP3410) {
788 dev_err (dev, "%s - invalid buffer signature\n", __FUNCTION__);
789 status = -ENODEV;
790 goto ExitTiValidateI2cImage;
791 }
792
793 do {
794 // Validate the I2C
795 status = TIReadRom (serial,
796 start_address,
797 sizeof(struct ti_i2c_desc),
798 (__u8 *)rom_desc);
799 if (status)
800 break;
801
802 if ((start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size) > TI_MAX_I2C_SIZE) {
803 status = -ENODEV;
804 dbg ("%s - structure too big, erroring out.", __FUNCTION__);
805 break;
806 }
807
808 dbg ("%s Type = 0x%x", __FUNCTION__, rom_desc->Type);
809
810 // Skip type 2 record
811 ttype = rom_desc->Type & 0x0f;
812 if ( ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
813 && ttype != I2C_DESC_TYPE_FIRMWARE_AUTO ) {
814 // Read the descriptor data
815 status = TIReadRom(serial,
816 start_address+sizeof(struct ti_i2c_desc),
817 rom_desc->Size,
818 buffer);
819 if (status)
820 break;
821
822 status = ValidChecksum(rom_desc, buffer);
823 if (status)
824 break;
825 }
826 start_address = start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size;
827
828 } while ((rom_desc->Type != I2C_DESC_TYPE_ION) && (start_address < TI_MAX_I2C_SIZE));
829
830 if ((rom_desc->Type != I2C_DESC_TYPE_ION) || (start_address > TI_MAX_I2C_SIZE))
831 status = -ENODEV;
832
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", __FUNCTION__);
849 return -ENOMEM;
850 }
851 start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_ION, rom_desc);
852
853 if (!start_address) {
854 dbg ("%s - Edge Descriptor not found in I2C", __FUNCTION__);
855 status = -ENODEV;
856 goto exit;
857 }
858
859 // Read the descriptor data
860 status = TIReadRom (serial,
861 start_address+sizeof(struct ti_i2c_desc),
862 rom_desc->Size,
863 buffer);
864 if (status)
865 goto exit;
866
867 status = ValidChecksum(rom_desc, buffer);
868
869 desc = (struct edge_ti_manuf_descriptor *)buffer;
870 dbg ( "%s - IonConfig 0x%x", __FUNCTION__, desc->IonConfig );
871 dbg ( "%s - Version %d", __FUNCTION__, desc->Version );
872 dbg ( "%s - Cpu/Board 0x%x", __FUNCTION__, desc->CpuRev_BoardRev );
873 dbg ( "%s - NumPorts %d", __FUNCTION__, desc->NumPorts );
874 dbg ( "%s - NumVirtualPorts %d", __FUNCTION__, desc->NumVirtualPorts );
875 dbg ( "%s - TotalPorts %d", __FUNCTION__, desc->TotalPorts );
876
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", __FUNCTION__);
906 return -ENOMEM;
907 }
908
909 // Set entire image of 0xffs
910 memset (buffer, 0xff, buffer_size);
911
912 // Copy version number into firmware record
913 firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
914
915 firmware_rec->Ver_Major = OperationalCodeImageVersion.MajorVersion;
916 firmware_rec->Ver_Minor = OperationalCodeImageVersion.MinorVersion;
917
918 // Pointer to fw_down memory image
919 img_header = (struct ti_i2c_image_header *)&PagableOperationalCodeImage[0];
920
921 memcpy (buffer + sizeof(struct ti_i2c_firmware_rec),
922 &PagableOperationalCodeImage[sizeof(struct ti_i2c_image_header)],
923 le16_to_cpu(img_header->Length));
924
925 for (i=0; i < buffer_size; i++) {
926 cs = (__u8)(cs + buffer[i]);
927 }
928
929 kfree (buffer);
930
931 // Build new header
932 i2c_header = (struct ti_i2c_desc *)header;
933 firmware_rec = (struct ti_i2c_firmware_rec*)i2c_header->Data;
934
935 i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK;
936 i2c_header->Size = (__u16)buffer_size;
937 i2c_header->CheckSum = cs;
938 firmware_rec->Ver_Major = OperationalCodeImageVersion.MajorVersion;
939 firmware_rec->Ver_Minor = OperationalCodeImageVersion.MinorVersion;
940
941 return 0;
942 }
943
944 /* Try to figure out what type of I2c we have */
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", __FUNCTION__, status);
959 else
960 dbg ("%s - read 2 data = 0x%x", __FUNCTION__, data);
961 if ((!status) && (data == UMP5152 || data == UMP3410)) {
962 dbg ("%s - ROM_TYPE_II", __FUNCTION__);
963 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
964 return 0;
965 }
966
967 // Try to read type 3
968 status = TIReadVendorRequestSync (serial->serial->dev,
969 UMPC_MEMORY_READ, // Request
970 DTK_ADDR_SPACE_I2C_TYPE_III, // wValue (Address type)
971 0, // wIndex
972 &data, // TransferBuffer
973 0x01); // TransferBufferLength
974 if (status)
975 dbg ("%s - read 3 status error = %d", __FUNCTION__, status);
976 else
977 dbg ("%s - read 2 data = 0x%x", __FUNCTION__, data);
978 if ((!status) && (data == UMP5152 || data == UMP3410)) {
979 dbg ("%s - ROM_TYPE_III", __FUNCTION__);
980 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
981 return 0;
982 }
983
984 dbg ("%s - Unknown", __FUNCTION__);
985 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
986 return -ENODEV;
987 }
988
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", __FUNCTION__);
1067 return -ENODEV;
1068 }
1069
1070 // Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
1071 // if we have more than one endpoint we are definitely in download mode
1072 if (interface->bNumEndpoints > 1)
1073 serial->product_info.TiMode = TI_MODE_DOWNLOAD;
1074 else
1075 // Otherwise we will remain in configuring mode
1076 serial->product_info.TiMode = TI_MODE_CONFIGURING;
1077
1078 // Save Download Version Number
1079 OperationalCodeImageVersion.MajorVersion = PagableOperationalCodeImageVersion.MajorVersion;
1080 OperationalCodeImageVersion.MinorVersion = PagableOperationalCodeImageVersion.MinorVersion;
1081 OperationalCodeImageVersion.BuildNumber = PagableOperationalCodeImageVersion.BuildNumber;
1082
1083 /********************************************************************/
1084 /* Download Mode */
1085 /********************************************************************/
1086 if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
1087 struct ti_i2c_desc *rom_desc;
1088
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", __FUNCTION__);
1103 return -ENOMEM;
1104 }
1105 status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
1106 if (status) {
1107 kfree (ti_manuf_desc);
1108 return status;
1109 }
1110
1111 // Check version number of ION descriptor
1112 if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
1113 dbg ( "%s - Wrong CPU Rev %d (Must be 2)", __FUNCTION__,
1114 TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
1115 kfree (ti_manuf_desc);
1116 return -EINVAL;
1117 }
1118
1119 rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
1120 if (!rom_desc) {
1121 dev_err (dev, "%s - out of memory.\n", __FUNCTION__);
1122 kfree (ti_manuf_desc);
1123 return -ENOMEM;
1124 }
1125
1126 // Search for type 2 record (firmware record)
1127 if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc)) != 0) {
1128 struct ti_i2c_firmware_rec *firmware_version;
1129 __u8 record;
1130
1131 dbg ("%s - Found Type FIRMWARE (Type 2) record", __FUNCTION__);
1132
1133 firmware_version = kmalloc (sizeof (*firmware_version), GFP_KERNEL);
1134 if (!firmware_version) {
1135 dev_err (dev, "%s - out of memory.\n", __FUNCTION__);
1136 kfree (rom_desc);
1137 kfree (ti_manuf_desc);
1138 return -ENOMEM;
1139 }
1140
1141 // Validate version number
1142 // Read the descriptor data
1143 status = TIReadRom (serial,
1144 start_address+sizeof(struct ti_i2c_desc),
1145 sizeof(struct ti_i2c_firmware_rec),
1146 (__u8 *)firmware_version);
1147 if (status) {
1148 kfree (firmware_version);
1149 kfree (rom_desc);
1150 kfree (ti_manuf_desc);
1151 return status;
1152 }
1153
1154 // Check version number of download with current version in I2c
1155 download_cur_ver = (firmware_version->Ver_Major << 8) +
1156 (firmware_version->Ver_Minor);
1157 download_new_ver = (OperationalCodeImageVersion.MajorVersion << 8) +
1158 (OperationalCodeImageVersion.MinorVersion);
1159
1160 dbg ("%s - >>>Firmware Versions Device %d.%d Driver %d.%d",
1161 __FUNCTION__,
1162 firmware_version->Ver_Major,
1163 firmware_version->Ver_Minor,
1164 OperationalCodeImageVersion.MajorVersion,
1165 OperationalCodeImageVersion.MinorVersion);
1166
1167 // Check if we have an old version in the I2C and update if necessary
1168 if (download_cur_ver != download_new_ver) {
1169 dbg ("%s - Update I2C Download from %d.%d to %d.%d",
1170 __FUNCTION__,
1171 firmware_version->Ver_Major,
1172 firmware_version->Ver_Minor,
1173 OperationalCodeImageVersion.MajorVersion,
1174 OperationalCodeImageVersion.MinorVersion);
1175
1176 // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
1177 // This will force the UMP to come up in Boot Mode. Then while in boot mode, the driver
1178 // will download the latest firmware (padded to 15.5k) into the UMP ram.
1179 // And finally when the device comes back up in download mode the driver will cause
1180 // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
1181 // the record type from 0xf2 to 0x02.
1182
1183 record = I2C_DESC_TYPE_FIRMWARE_BLANK;
1184
1185 // Change the I2C Firmware record type to 0xf2 to trigger an update
1186 status = TIWriteRom (serial,
1187 start_address,
1188 sizeof(record),
1189 &record);
1190 if (status) {
1191 kfree (firmware_version);
1192 kfree (rom_desc);
1193 kfree (ti_manuf_desc);
1194 return status;
1195 }
1196
1197 // verify the write -- must do this in order for write to
1198 // complete before we do the hardware reset
1199 status = TIReadRom (serial,
1200 start_address,
1201 sizeof(record),
1202 &record);
1203
1204 if (status) {
1205 kfree (firmware_version);
1206 kfree (rom_desc);
1207 kfree (ti_manuf_desc);
1208 return status;
1209 }
1210
1211 if (record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
1212 dev_err (dev, "%s - error resetting device\n", __FUNCTION__);
1213 kfree (firmware_version);
1214 kfree (rom_desc);
1215 kfree (ti_manuf_desc);
1216 return -ENODEV;
1217 }
1218
1219 dbg ("%s - HARDWARE RESET", __FUNCTION__);
1220
1221 // Reset UMP -- Back to BOOT MODE
1222 status = TISendVendorRequestSync (serial->serial->dev,
1223 UMPC_HARDWARE_RESET, // Request
1224 0, // wValue
1225 0, // wIndex
1226 NULL, // TransferBuffer
1227 0); // TransferBufferLength
1228
1229 dbg ( "%s - HARDWARE RESET return %d", __FUNCTION__, status);
1230
1231 /* return an error on purpose. */
1232 kfree (firmware_version);
1233 kfree (rom_desc);
1234 kfree (ti_manuf_desc);
1235 return -ENODEV;
1236 }
1237 kfree (firmware_version);
1238 }
1239 // Search for type 0xF2 record (firmware blank record)
1240 else if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
1241 #define HEADER_SIZE (sizeof(struct ti_i2c_desc) + sizeof(struct ti_i2c_firmware_rec))
1242 __u8 *header;
1243 __u8 *vheader;
1244
1245 header = kmalloc (HEADER_SIZE, GFP_KERNEL);
1246 if (!header) {
1247 dev_err (dev, "%s - out of memory.\n", __FUNCTION__);
1248 kfree (rom_desc);
1249 kfree (ti_manuf_desc);
1250 return -ENOMEM;
1251 }
1252
1253 vheader = kmalloc (HEADER_SIZE, GFP_KERNEL);
1254 if (!vheader) {
1255 dev_err (dev, "%s - out of memory.\n", __FUNCTION__);
1256 kfree (header);
1257 kfree (rom_desc);
1258 kfree (ti_manuf_desc);
1259 return -ENOMEM;
1260 }
1261
1262 dbg ("%s - Found Type BLANK FIRMWARE (Type F2) record", __FUNCTION__);
1263
1264 // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
1265 // This will force the UMP to come up in Boot Mode. Then while in boot mode, the driver
1266 // will download the latest firmware (padded to 15.5k) into the UMP ram.
1267 // And finally when the device comes back up in download mode the driver will cause
1268 // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
1269 // the record type from 0xf2 to 0x02.
1270 status = BuildI2CFirmwareHeader(header, dev);
1271 if (status) {
1272 kfree (vheader);
1273 kfree (header);
1274 kfree (rom_desc);
1275 kfree (ti_manuf_desc);
1276 return status;
1277 }
1278
1279 // Update I2C with type 0xf2 record with correct size and checksum
1280 status = TIWriteRom (serial,
1281 start_address,
1282 HEADER_SIZE,
1283 header);
1284 if (status) {
1285 kfree (vheader);
1286 kfree (header);
1287 kfree (rom_desc);
1288 kfree (ti_manuf_desc);
1289 return status;
1290 }
1291
1292 // verify the write -- must do this in order for write to
1293 // complete before we do the hardware reset
1294 status = TIReadRom (serial,
1295 start_address,
1296 HEADER_SIZE,
1297 vheader);
1298
1299 if (status) {
1300 dbg ("%s - can't read header back", __FUNCTION__);
1301 kfree (vheader);
1302 kfree (header);
1303 kfree (rom_desc);
1304 kfree (ti_manuf_desc);
1305 return status;
1306 }
1307 if (memcmp(vheader, header, HEADER_SIZE)) {
1308 dbg ("%s - write download record failed", __FUNCTION__);
1309 kfree (vheader);
1310 kfree (header);
1311 kfree (rom_desc);
1312 kfree (ti_manuf_desc);
1313 return status;
1314 }
1315
1316 kfree (vheader);
1317 kfree (header);
1318
1319 dbg ("%s - Start firmware update", __FUNCTION__);
1320
1321 // Tell firmware to copy download image into I2C
1322 status = TISendVendorRequestSync (serial->serial->dev,
1323 UMPC_COPY_DNLD_TO_I2C, // Request
1324 0, // wValue
1325 0, // wIndex
1326 NULL, // TransferBuffer
1327 0); // TransferBufferLength
1328
1329 dbg ("%s - Update complete 0x%x", __FUNCTION__, status);
1330 if (status) {
1331 dev_err (dev, "%s - UMPC_COPY_DNLD_TO_I2C failed\n", __FUNCTION__);
1332 kfree (rom_desc);
1333 kfree (ti_manuf_desc);
1334 return status;
1335 }
1336 }
1337
1338 // The device is running the download code
1339 kfree (rom_desc);
1340 kfree (ti_manuf_desc);
1341 return 0;
1342 }
1343
1344 /********************************************************************/
1345 /* Boot Mode */
1346 /********************************************************************/
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", __FUNCTION__,
1356 le16_to_cpu(serial->serial->dev->descriptor.idVendor));
1357 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1358 goto StayInBootMode;
1359 }
1360
1361 // We have an ION device (I2c Must be programmed)
1362 // Determine I2C image type
1363 if (TIGetI2cTypeInBootMode(serial)) {
1364 goto StayInBootMode;
1365 }
1366
1367 // Registry variable set?
1368 if (TIStayInBootMode) {
1369 dbg ("%s - TIStayInBootMode", __FUNCTION__);
1370 goto StayInBootMode;
1371 }
1372
1373 // Check for ION Vendor ID and that the I2C is valid
1374 if (!TiValidateI2cImage(serial)) {
1375 struct ti_i2c_image_header *header;
1376 int i;
1377 __u8 cs = 0;
1378 __u8 *buffer;
1379 int buffer_size;
1380
1381 /* Validate Hardware version number
1382 * Read Manufacturing Descriptor from TI Based Edgeport
1383 */
1384 ti_manuf_desc = kmalloc (sizeof (*ti_manuf_desc), GFP_KERNEL);
1385 if (!ti_manuf_desc) {
1386 dev_err (dev, "%s - out of memory.\n", __FUNCTION__);
1387 return -ENOMEM;
1388 }
1389 status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
1390 if (status) {
1391 kfree (ti_manuf_desc);
1392 goto StayInBootMode;
1393 }
1394
1395 // Check for version 2
1396 if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
1397 dbg ("%s - Wrong CPU Rev %d (Must be 2)", __FUNCTION__,
1398 TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
1399 kfree (ti_manuf_desc);
1400 goto StayInBootMode;
1401 }
1402
1403 kfree (ti_manuf_desc);
1404
1405 // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
1406 // This will force the UMP to come up in Boot Mode. Then while in boot mode, the driver
1407 // will download the latest firmware (padded to 15.5k) into the UMP ram.
1408 // And finally when the device comes back up in download mode the driver will cause
1409 // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
1410 // the record type from 0xf2 to 0x02.
1411
1412 /*
1413 * Do we really have to copy the whole firmware image,
1414 * or could we do this in place!
1415 */
1416
1417 // Allocate a 15.5k buffer + 3 byte header
1418 buffer_size = (((1024 * 16) - 512) + sizeof(struct ti_i2c_image_header));
1419 buffer = kmalloc (buffer_size, GFP_KERNEL);
1420 if (!buffer) {
1421 dev_err (dev, "%s - out of memory\n", __FUNCTION__);
1422 return -ENOMEM;
1423 }
1424
1425 // Initialize the buffer to 0xff (pad the buffer)
1426 memset (buffer, 0xff, buffer_size);
1427
1428 memcpy (buffer, &PagableOperationalCodeImage[0], PagableOperationalCodeSize);
1429
1430 for(i = sizeof(struct ti_i2c_image_header); i < buffer_size; i++) {
1431 cs = (__u8)(cs + buffer[i]);
1432 }
1433
1434 header = (struct ti_i2c_image_header *)buffer;
1435
1436 // update length and checksum after padding
1437 header->Length = cpu_to_le16((__u16)(buffer_size - sizeof(struct ti_i2c_image_header)));
1438 header->CheckSum = cs;
1439
1440 // Download the operational code
1441 dbg ("%s - Downloading operational code image (TI UMP)", __FUNCTION__);
1442 status = TIDownloadCodeImage (serial, buffer, buffer_size);
1443
1444 kfree (buffer);
1445
1446 if (status) {
1447 dbg ("%s - Error downloading operational code image", __FUNCTION__);
1448 return status;
1449 }
1450
1451 // Device will reboot
1452 serial->product_info.TiMode = TI_MODE_TRANSITIONING;
1453
1454 dbg ("%s - Download successful -- Device rebooting...", __FUNCTION__);
1455
1456 /* return an error on purpose */
1457 return -ENODEV;
1458 }
1459
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", __FUNCTION__);
1474 port->shadow_mcr |= MCR_DTR;
1475
1476 return TIWriteCommandSync (port->port->serial->dev,
1477 UMPC_SET_CLR_DTR,
1478 (__u8)(UMPM_UART1_PORT + port_number),
1479 1, /* set */
1480 NULL,
1481 0);
1482 }
1483
1484 static int TIClearDtr (struct edgeport_port *port)
1485 {
1486 int port_number = port->port->number - port->port->serial->minor;
1487
1488 dbg ("%s", __FUNCTION__);
1489 port->shadow_mcr &= ~MCR_DTR;
1490
1491 return TIWriteCommandSync (port->port->serial->dev,
1492 UMPC_SET_CLR_DTR,
1493 (__u8)(UMPM_UART1_PORT + port_number),
1494 0, /* clear */
1495 NULL,
1496 0);
1497 }
1498
1499 static int TISetRts (struct edgeport_port *port)
1500 {
1501 int port_number = port->port->number - port->port->serial->minor;
1502
1503 dbg ("%s", __FUNCTION__);
1504 port->shadow_mcr |= MCR_RTS;
1505
1506 return TIWriteCommandSync (port->port->serial->dev,
1507 UMPC_SET_CLR_RTS,
1508 (__u8)(UMPM_UART1_PORT + port_number),
1509 1, /* set */
1510 NULL,
1511 0);
1512 }
1513
1514 static int TIClearRts (struct edgeport_port *port)
1515 {
1516 int port_number = port->port->number - port->port->serial->minor;
1517
1518 dbg ("%s", __FUNCTION__);
1519 port->shadow_mcr &= ~MCR_RTS;
1520
1521 return TIWriteCommandSync (port->port->serial->dev,
1522 UMPC_SET_CLR_RTS,
1523 (__u8)(UMPM_UART1_PORT + port_number),
1524 0, /* clear */
1525 NULL,
1526 0);
1527 }
1528
1529 static int TISetLoopBack (struct edgeport_port *port)
1530 {
1531 int port_number = port->port->number - port->port->serial->minor;
1532
1533 dbg ("%s", __FUNCTION__);
1534
1535 return TIWriteCommandSync (port->port->serial->dev,
1536 UMPC_SET_CLR_LOOPBACK,
1537 (__u8)(UMPM_UART1_PORT + port_number),
1538 1, /* set */
1539 NULL,
1540 0);
1541 }
1542
1543 static int TIClearLoopBack (struct edgeport_port *port)
1544 {
1545 int port_number = port->port->number - port->port->serial->minor;
1546
1547 dbg ("%s", __FUNCTION__);
1548
1549 return TIWriteCommandSync (port->port->serial->dev,
1550 UMPC_SET_CLR_LOOPBACK,
1551 (__u8)(UMPM_UART1_PORT + port_number),
1552 0, /* clear */
1553 NULL,
1554 0);
1555 }
1556
1557 static int TISetBreak (struct edgeport_port *port)
1558 {
1559 int port_number = port->port->number - port->port->serial->minor;
1560
1561 dbg ("%s", __FUNCTION__);
1562
1563 return TIWriteCommandSync (port->port->serial->dev,
1564 UMPC_SET_CLR_BREAK,
1565 (__u8)(UMPM_UART1_PORT + port_number),
1566 1, /* set */
1567 NULL,
1568 0);
1569 }
1570
1571 static int TIClearBreak (struct edgeport_port *port)
1572 {
1573 int port_number = port->port->number - port->port->serial->minor;
1574
1575 dbg ("%s", __FUNCTION__);
1576
1577 return TIWriteCommandSync (port->port->serial->dev,
1578 UMPC_SET_CLR_BREAK,
1579 (__u8)(UMPM_UART1_PORT + port_number),
1580 0, /* clear */
1581 NULL,
1582 0);
1583 }
1584
1585 static int TIRestoreMCR (struct edgeport_port *port, __u8 mcr)
1586 {
1587 int status = 0;
1588
1589 dbg ("%s - %x", __FUNCTION__, mcr);
1590
1591 if (mcr & MCR_DTR)
1592 status = TISetDtr (port);
1593 else
1594 status = TIClearDtr (port);
1595
1596 if (status)
1597 return status;
1598
1599 if (mcr & MCR_RTS)
1600 status = TISetRts (port);
1601 else
1602 status = TIClearRts (port);
1603
1604 if (status)
1605 return status;
1606
1607 if (mcr & MCR_LOOPBACK)
1608 status = TISetLoopBack (port);
1609 else
1610 status = TIClearLoopBack (port);
1611
1612 return status;
1613 }
1614
1615
1616
1617 /* Convert TI LSR to standard UART flags */
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", __FUNCTION__, msr);
1644
1645 if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR | EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
1646 icount = &edge_port->icount;
1647
1648 /* update input line counters */
1649 if (msr & EDGEPORT_MSR_DELTA_CTS)
1650 icount->cts++;
1651 if (msr & EDGEPORT_MSR_DELTA_DSR)
1652 icount->dsr++;
1653 if (msr & EDGEPORT_MSR_DELTA_CD)
1654 icount->dcd++;
1655 if (msr & EDGEPORT_MSR_DELTA_RI)
1656 icount->rng++;
1657 wake_up_interruptible (&edge_port->delta_msr_wait);
1658 }
1659
1660 /* Save the new modem status */
1661 edge_port->shadow_msr = msr & 0xf0;
1662
1663 tty = edge_port->port->tty;
1664 /* handle CTS flow control */
1665 if (tty && C_CRTSCTS(tty)) {
1666 if (msr & EDGEPORT_MSR_CTS) {
1667 tty->hw_stopped = 0;
1668 tty_wakeup(tty);
1669 } else {
1670 tty->hw_stopped = 1;
1671 }
1672 }
1673
1674 return;
1675 }
1676
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", __FUNCTION__, new_lsr);
1683
1684 edge_port->shadow_lsr = lsr;
1685
1686 if (new_lsr & LSR_BREAK) {
1687 /*
1688 * Parity and Framing errors only count if they
1689 * occur exclusive of a break being received.
1690 */
1691 new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
1692 }
1693
1694 /* Place LSR data byte into Rx buffer */
1695 if (lsr_data && edge_port->port->tty)
1696 edge_tty_recv(&edge_port->port->dev, edge_port->port->tty, &data, 1);
1697
1698 /* update input line counters */
1699 icount = &edge_port->icount;
1700 if (new_lsr & LSR_BREAK)
1701 icount->brk++;
1702 if (new_lsr & LSR_OVER_ERR)
1703 icount->overrun++;
1704 if (new_lsr & LSR_PAR_ERR)
1705 icount->parity++;
1706 if (new_lsr & LSR_FRM_ERR)
1707 icount->frame++;
1708 }
1709
1710
1711 static void edge_interrupt_callback (struct urb *urb)
1712 {
1713 struct edgeport_serial *edge_serial = (struct edgeport_serial *)urb->context;
1714 struct usb_serial_port *port;
1715 struct edgeport_port *edge_port;
1716 unsigned char *data = urb->transfer_buffer;
1717 int length = urb->actual_length;
1718 int port_number;
1719 int function;
1720 int retval;
1721 __u8 lsr;
1722 __u8 msr;
1723 int status = urb->status;
1724
1725 dbg("%s", __FUNCTION__);
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 __FUNCTION__, status);
1737 return;
1738 default:
1739 dev_err(&urb->dev->dev, "%s - nonzero urb status received: "
1740 "%d\n", __FUNCTION__, status);
1741 goto exit;
1742 }
1743
1744 if (!length) {
1745 dbg ("%s - no data in urb", __FUNCTION__);
1746 goto exit;
1747 }
1748
1749 usb_serial_debug_data(debug, &edge_serial->serial->dev->dev, __FUNCTION__, length, data);
1750
1751 if (length != 2) {
1752 dbg ("%s - expecting packet of size 2, got %d", __FUNCTION__, length);
1753 goto exit;
1754 }
1755
1756 port_number = TIUMP_GET_PORT_FROM_CODE (data[0]);
1757 function = TIUMP_GET_FUNC_FROM_CODE (data[0]);
1758 dbg ("%s - port_number %d, function %d, info 0x%x",
1759 __FUNCTION__, port_number, function, data[1]);
1760 port = edge_serial->serial->port[port_number];
1761 edge_port = usb_get_serial_port_data(port);
1762 if (!edge_port) {
1763 dbg ("%s - edge_port not found", __FUNCTION__);
1764 return;
1765 }
1766 switch (function) {
1767 case TIUMP_INTERRUPT_CODE_LSR:
1768 lsr = MapLineStatus(data[1]);
1769 if (lsr & UMP_UART_LSR_DATA_MASK) {
1770 /* Save the LSR event for bulk read completion routine */
1771 dbg ("%s - LSR Event Port %u LSR Status = %02x",
1772 __FUNCTION__, port_number, lsr);
1773 edge_port->lsr_event = 1;
1774 edge_port->lsr_mask = lsr;
1775 } else {
1776 dbg ("%s - ===== Port %d LSR Status = %02x ======",
1777 __FUNCTION__, port_number, lsr);
1778 handle_new_lsr (edge_port, 0, lsr, 0);
1779 }
1780 break;
1781
1782 case TIUMP_INTERRUPT_CODE_MSR: // MSR
1783 /* Copy MSR from UMP */
1784 msr = data[1];
1785 dbg ("%s - ===== Port %u MSR Status = %02x ======\n",
1786 __FUNCTION__, port_number, msr);
1787 handle_new_msr (edge_port, msr);
1788 break;
1789
1790 default:
1791 dev_err (&urb->dev->dev, "%s - Unknown Interrupt code from UMP %x\n",
1792 __FUNCTION__, data[1]);
1793 break;
1794
1795 }
1796
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 __FUNCTION__, retval);
1802 }
1803
1804 static void edge_bulk_in_callback (struct urb *urb)
1805 {
1806 struct edgeport_port *edge_port = (struct edgeport_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", __FUNCTION__);
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 __FUNCTION__, status);
1825 return;
1826 default:
1827 dev_err (&urb->dev->dev,"%s - nonzero read bulk status received: %d\n",
1828 __FUNCTION__, status);
1829 }
1830
1831 if (status == -EPIPE)
1832 goto exit;
1833
1834 if (status) {
1835 dev_err(&urb->dev->dev,"%s - stopping read!\n", __FUNCTION__);
1836 return;
1837 }
1838
1839 port_number = edge_port->port->number - edge_port->port->serial->minor;
1840
1841 if (edge_port->lsr_event) {
1842 edge_port->lsr_event = 0;
1843 dbg ("%s ===== Port %u LSR Status = %02x, Data = %02x ======",
1844 __FUNCTION__, port_number, edge_port->lsr_mask, *data);
1845 handle_new_lsr (edge_port, 1, edge_port->lsr_mask, *data);
1846 /* Adjust buffer length/pointer */
1847 --urb->actual_length;
1848 ++data;
1849 }
1850
1851 tty = edge_port->port->tty;
1852 if (tty && urb->actual_length) {
1853 usb_serial_debug_data(debug, &edge_port->port->dev, __FUNCTION__, urb->actual_length, data);
1854
1855 if (edge_port->close_pending) {
1856 dbg ("%s - close is pending, dropping data on the floor.", __FUNCTION__);
1857 } else {
1858 edge_tty_recv(&edge_port->port->dev, tty, data, urb->actual_length);
1859 }
1860 edge_port->icount.rx += urb->actual_length;
1861 }
1862
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 __FUNCTION__, 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 __FUNCTION__, 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 = (struct usb_serial_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", __FUNCTION__, 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 __FUNCTION__, status);
1918 return;
1919 default:
1920 dev_err(&urb->dev->dev, "%s - nonzero write bulk status "
1921 "received: %d\n", __FUNCTION__, 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", __FUNCTION__, port->number);
1940
1941 if (edge_port == NULL)
1942 return -ENODEV;
1943
1944 if (port->tty)
1945 port->tty->low_latency = low_latency;
1946
1947 port_number = port->number - port->serial->minor;
1948 switch (port_number) {
1949 case 0:
1950 edge_port->uart_base = UMPMEM_BASE_UART1;
1951 edge_port->dma_address = UMPD_OEDB1_ADDRESS;
1952 break;
1953 case 1:
1954 edge_port->uart_base = UMPMEM_BASE_UART2;
1955 edge_port->dma_address = UMPD_OEDB2_ADDRESS;
1956 break;
1957 default:
1958 dev_err (&port->dev, "Unknown port number!!!\n");
1959 return -ENODEV;
1960 }
1961
1962 dbg ("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
1963 __FUNCTION__, port_number, edge_port->uart_base, edge_port->dma_address);
1964
1965 dev = port->serial->dev;
1966
1967 memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
1968 init_waitqueue_head (&edge_port->delta_msr_wait);
1969
1970 /* turn off loopback */
1971 status = TIClearLoopBack (edge_port);
1972 if (status) {
1973 dev_err(&port->dev,"%s - cannot send clear loopback command, %d\n",
1974 __FUNCTION__, status);
1975 return status;
1976 }
1977
1978 /* set up the port settings */
1979 edge_set_termios (port, port->tty->termios);
1980
1981 /* open up the port */
1982
1983 /* milliseconds to timeout for DMA transfer */
1984 transaction_timeout = 2;
1985
1986 edge_port->ump_read_timeout = max (20, ((transaction_timeout * 3) / 2) );
1987
1988 // milliseconds to timeout for DMA transfer
1989 open_settings = (u8)(UMP_DMA_MODE_CONTINOUS |
1990 UMP_PIPE_TRANS_TIMEOUT_ENA |
1991 (transaction_timeout << 2));
1992
1993 dbg ("%s - Sending UMPC_OPEN_PORT", __FUNCTION__);
1994
1995 /* Tell TI to open and start the port */
1996 status = TIWriteCommandSync (dev,
1997 UMPC_OPEN_PORT,
1998 (u8)(UMPM_UART1_PORT + port_number),
1999 open_settings,
2000 NULL,
2001 0);
2002 if (status) {
2003 dev_err(&port->dev,"%s - cannot send open command, %d\n", __FUNCTION__, status);
2004 return status;
2005 }
2006
2007 /* Start the DMA? */
2008 status = TIWriteCommandSync (dev,
2009 UMPC_START_PORT,
2010 (u8)(UMPM_UART1_PORT + port_number),
2011 0,
2012 NULL,
2013 0);
2014 if (status) {
2015 dev_err(&port->dev,"%s - cannot send start DMA command, %d\n", __FUNCTION__, status);
2016 return status;
2017 }
2018
2019 /* Clear TX and RX buffers in UMP */
2020 status = TIPurgeDataSync (port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
2021 if (status) {
2022 dev_err(&port->dev,"%s - cannot send clear buffers command, %d\n", __FUNCTION__, status);
2023 return status;
2024 }
2025
2026 /* Read Initial MSR */
2027 status = TIReadVendorRequestSync (dev,
2028 UMPC_READ_MSR, // Request
2029 0, // wValue
2030 (__u16)(UMPM_UART1_PORT + port_number), // wIndex (Address)
2031 &edge_port->shadow_msr, // TransferBuffer
2032 1); // TransferBufferLength
2033 if (status) {
2034 dev_err(&port->dev,"%s - cannot send read MSR command, %d\n", __FUNCTION__, status);
2035 return status;
2036 }
2037
2038 dbg ("ShadowMSR 0x%X", edge_port->shadow_msr);
2039
2040 /* Set Initial MCR */
2041 edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
2042 dbg ("ShadowMCR 0x%X", edge_port->shadow_mcr);
2043
2044 edge_serial = edge_port->edge_serial;
2045 if (mutex_lock_interruptible(&edge_serial->es_lock))
2046 return -ERESTARTSYS;
2047 if (edge_serial->num_ports_open == 0) {
2048 /* we are the first port to be opened, let's post the interrupt urb */
2049 urb = edge_serial->serial->port[0]->interrupt_in_urb;
2050 if (!urb) {
2051 dev_err (&port->dev, "%s - no interrupt urb present, exiting\n", __FUNCTION__);
2052 status = -EINVAL;
2053 goto release_es_lock;
2054 }
2055 urb->complete = edge_interrupt_callback;
2056 urb->context = edge_serial;
2057 urb->dev = dev;
2058 status = usb_submit_urb (urb, GFP_KERNEL);
2059 if (status) {
2060 dev_err (&port->dev, "%s - usb_submit_urb failed with value %d\n", __FUNCTION__, status);
2061 goto release_es_lock;
2062 }
2063 }
2064
2065 /*
2066 * reset the data toggle on the bulk endpoints to work around bug in
2067 * host controllers where things get out of sync some times
2068 */
2069 usb_clear_halt (dev, port->write_urb->pipe);
2070 usb_clear_halt (dev, port->read_urb->pipe);
2071
2072 /* start up our bulk read urb */
2073 urb = port->read_urb;
2074 if (!urb) {
2075 dev_err (&port->dev, "%s - no read urb present, exiting\n", __FUNCTION__);
2076 status = -EINVAL;
2077 goto unlink_int_urb;
2078 }
2079 edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2080 urb->complete = edge_bulk_in_callback;
2081 urb->context = edge_port;
2082 urb->dev = dev;
2083 status = usb_submit_urb (urb, GFP_KERNEL);
2084 if (status) {
2085 dev_err (&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __FUNCTION__, status);
2086 goto unlink_int_urb;
2087 }
2088
2089 ++edge_serial->num_ports_open;
2090
2091 dbg("%s - exited", __FUNCTION__);
2092
2093 goto release_es_lock;
2094
2095 unlink_int_urb:
2096 if (edge_port->edge_serial->num_ports_open == 0)
2097 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2098 release_es_lock:
2099 mutex_unlock(&edge_serial->es_lock);
2100 return status;
2101 }
2102
2103 static void edge_close (struct usb_serial_port *port, struct file *filp)
2104 {
2105 struct edgeport_serial *edge_serial;
2106 struct edgeport_port *edge_port;
2107 int port_number;
2108 int status;
2109
2110 dbg("%s - port %d", __FUNCTION__, port->number);
2111
2112 edge_serial = usb_get_serial_data(port->serial);
2113 edge_port = usb_get_serial_port_data(port);
2114 if ((edge_serial == NULL) || (edge_port == NULL))
2115 return;
2116
2117 /* The bulkreadcompletion routine will check
2118 * this flag and dump add read data */
2119 edge_port->close_pending = 1;
2120
2121 /* chase the port close and flush */
2122 TIChasePort (edge_port, (HZ*closing_wait)/100, 1);
2123
2124 usb_kill_urb(port->read_urb);
2125 usb_kill_urb(port->write_urb);
2126 edge_port->ep_write_urb_in_use = 0;
2127
2128 /* assuming we can still talk to the device,
2129 * send a close port command to it */
2130 dbg("%s - send umpc_close_port", __FUNCTION__);
2131 port_number = port->number - port->serial->minor;
2132 status = TIWriteCommandSync (port->serial->dev,
2133 UMPC_CLOSE_PORT,
2134 (__u8)(UMPM_UART1_PORT + port_number),
2135 0,
2136 NULL,
2137 0);
2138 mutex_lock(&edge_serial->es_lock);
2139 --edge_port->edge_serial->num_ports_open;
2140 if (edge_port->edge_serial->num_ports_open <= 0) {
2141 /* last port is now closed, let's shut down our interrupt urb */
2142 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2143 edge_port->edge_serial->num_ports_open = 0;
2144 }
2145 mutex_unlock(&edge_serial->es_lock);
2146 edge_port->close_pending = 0;
2147
2148 dbg("%s - exited", __FUNCTION__);
2149 }
2150
2151 static int edge_write (struct usb_serial_port *port, const unsigned char *data, int count)
2152 {
2153 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2154 unsigned long flags;
2155
2156 dbg("%s - port %d", __FUNCTION__, port->number);
2157
2158 if (count == 0) {
2159 dbg("%s - write request of 0 bytes", __FUNCTION__);
2160 return 0;
2161 }
2162
2163 if (edge_port == NULL)
2164 return -ENODEV;
2165 if (edge_port->close_pending == 1)
2166 return -ENODEV;
2167
2168 spin_lock_irqsave(&edge_port->ep_lock, flags);
2169 count = edge_buf_put(edge_port->ep_out_buf, data, count);
2170 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2171
2172 edge_send(port);
2173
2174 return count;
2175 }
2176
2177 static void edge_send(struct usb_serial_port *port)
2178 {
2179 int count, result;
2180 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2181 struct tty_struct *tty = port->tty;
2182 unsigned long flags;
2183
2184
2185 dbg("%s - port %d", __FUNCTION__, port->number);
2186
2187 spin_lock_irqsave(&edge_port->ep_lock, flags);
2188
2189 if (edge_port->ep_write_urb_in_use) {
2190 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2191 return;
2192 }
2193
2194 count = edge_buf_get(edge_port->ep_out_buf,
2195 port->write_urb->transfer_buffer,
2196 port->bulk_out_size);
2197
2198 if (count == 0) {
2199 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2200 return;
2201 }
2202
2203 edge_port->ep_write_urb_in_use = 1;
2204
2205 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2206
2207 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, port->write_urb->transfer_buffer);
2208
2209 /* set up our urb */
2210 usb_fill_bulk_urb (port->write_urb, port->serial->dev,
2211 usb_sndbulkpipe (port->serial->dev,
2212 port->bulk_out_endpointAddress),
2213 port->write_urb->transfer_buffer, count,
2214 edge_bulk_out_callback,
2215 port);
2216
2217 /* send the data out the bulk port */
2218 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
2219 if (result) {
2220 dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __FUNCTION__, result);
2221 edge_port->ep_write_urb_in_use = 0;
2222 // TODO: reschedule edge_send
2223 } else {
2224 edge_port->icount.tx += count;
2225 }
2226
2227 /* wakeup any process waiting for writes to complete */
2228 /* there is now more room in the buffer for new writes */
2229 if (tty) {
2230 /* let the tty driver wakeup if it has a special write_wakeup function */
2231 tty_wakeup(tty);
2232 }
2233 }
2234
2235 static int edge_write_room (struct usb_serial_port *port)
2236 {
2237 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2238 int room = 0;
2239 unsigned long flags;
2240
2241 dbg("%s - port %d", __FUNCTION__, port->number);
2242
2243 if (edge_port == NULL)
2244 return -ENODEV;
2245 if (edge_port->close_pending == 1)
2246 return -ENODEV;
2247
2248 spin_lock_irqsave(&edge_port->ep_lock, flags);
2249 room = edge_buf_space_avail(edge_port->ep_out_buf);
2250 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2251
2252 dbg("%s - returns %d", __FUNCTION__, room);
2253 return room;
2254 }
2255
2256 static int edge_chars_in_buffer (struct usb_serial_port *port)
2257 {
2258 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2259 int chars = 0;
2260 unsigned long flags;
2261
2262 dbg("%s - port %d", __FUNCTION__, port->number);
2263
2264 if (edge_port == NULL)
2265 return -ENODEV;
2266 if (edge_port->close_pending == 1)
2267 return -ENODEV;
2268
2269 spin_lock_irqsave(&edge_port->ep_lock, flags);
2270 chars = edge_buf_data_avail(edge_port->ep_out_buf);
2271 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2272
2273 dbg ("%s - returns %d", __FUNCTION__, chars);
2274 return chars;
2275 }
2276
2277 static void edge_throttle (struct usb_serial_port *port)
2278 {
2279 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2280 struct tty_struct *tty;
2281 int status;
2282
2283 dbg("%s - port %d", __FUNCTION__, port->number);
2284
2285 if (edge_port == NULL)
2286 return;
2287
2288 tty = port->tty;
2289 if (!tty) {
2290 dbg ("%s - no tty available", __FUNCTION__);
2291 return;
2292 }
2293
2294 /* if we are implementing XON/XOFF, send the stop character */
2295 if (I_IXOFF(tty)) {
2296 unsigned char stop_char = STOP_CHAR(tty);
2297 status = edge_write (port, &stop_char, 1);
2298 if (status <= 0) {
2299 dev_err(&port->dev, "%s - failed to write stop character, %d\n", __FUNCTION__, status);
2300 }
2301 }
2302
2303 /* if we are implementing RTS/CTS, stop reads */
2304 /* and the Edgeport will clear the RTS line */
2305 if (C_CRTSCTS(tty))
2306 stop_read(edge_port);
2307
2308 }
2309
2310 static void edge_unthrottle (struct usb_serial_port *port)
2311 {
2312 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2313 struct tty_struct *tty;
2314 int status;
2315
2316 dbg("%s - port %d", __FUNCTION__, port->number);
2317
2318 if (edge_port == NULL)
2319 return;
2320
2321 tty = port->tty;
2322 if (!tty) {
2323 dbg ("%s - no tty available", __FUNCTION__);
2324 return;
2325 }
2326
2327 /* if we are implementing XON/XOFF, send the start character */
2328 if (I_IXOFF(tty)) {
2329 unsigned char start_char = START_CHAR(tty);
2330 status = edge_write (port, &start_char, 1);
2331 if (status <= 0) {
2332 dev_err(&port->dev, "%s - failed to write start character, %d\n", __FUNCTION__, status);
2333 }
2334 }
2335
2336 /* if we are implementing RTS/CTS, restart reads */
2337 /* are the Edgeport will assert the RTS line */
2338 if (C_CRTSCTS(tty)) {
2339 status = restart_read(edge_port);
2340 if (status)
2341 dev_err(&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __FUNCTION__, status);
2342 }
2343
2344 }
2345
2346 static void stop_read(struct edgeport_port *edge_port)
2347 {
2348 unsigned long flags;
2349
2350 spin_lock_irqsave(&edge_port->ep_lock, flags);
2351
2352 if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
2353 edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;
2354 edge_port->shadow_mcr &= ~MCR_RTS;
2355
2356 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2357 }
2358
2359 static int restart_read(struct edgeport_port *edge_port)
2360 {
2361 struct urb *urb;
2362 int status = 0;
2363 unsigned long flags;
2364
2365 spin_lock_irqsave(&edge_port->ep_lock, flags);
2366
2367 if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {
2368 urb = edge_port->port->read_urb;
2369 urb->complete = edge_bulk_in_callback;
2370 urb->context = edge_port;
2371 urb->dev = edge_port->port->serial->dev;
2372 status = usb_submit_urb(urb, GFP_ATOMIC);
2373 }
2374 edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2375 edge_port->shadow_mcr |= MCR_RTS;
2376
2377 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2378
2379 return status;
2380 }
2381
2382 static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios)
2383 {
2384 struct ump_uart_config *config;
2385 struct tty_struct *tty;
2386 int baud;
2387 unsigned cflag;
2388 int status;
2389 int port_number = edge_port->port->number - edge_port->port->serial->minor;
2390
2391 dbg("%s - port %d", __FUNCTION__, edge_port->port->number);
2392
2393 tty = edge_port->port->tty;
2394
2395 config = kmalloc (sizeof (*config), GFP_KERNEL);
2396 if (!config) {
2397 dev_err (&edge_port->port->dev, "%s - out of memory\n", __FUNCTION__);
2398 return;
2399 }
2400
2401 cflag = tty->termios->c_cflag;
2402
2403 config->wFlags = 0;
2404
2405 /* These flags must be set */
2406 config->wFlags |= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
2407 config->wFlags |= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
2408 config->bUartMode = (__u8)(edge_port->bUartMode);
2409
2410 switch (cflag & CSIZE) {
2411 case CS5:
2412 config->bDataBits = UMP_UART_CHAR5BITS;
2413 dbg ("%s - data bits = 5", __FUNCTION__);
2414 break;
2415 case CS6:
2416 config->bDataBits = UMP_UART_CHAR6BITS;
2417 dbg ("%s - data bits = 6", __FUNCTION__);
2418 break;
2419 case CS7:
2420 config->bDataBits = UMP_UART_CHAR7BITS;
2421 dbg ("%s - data bits = 7", __FUNCTION__);
2422 break;
2423 default:
2424 case CS8:
2425 config->bDataBits = UMP_UART_CHAR8BITS;
2426 dbg ("%s - data bits = 8", __FUNCTION__);
2427 break;
2428 }
2429
2430 if (cflag & PARENB) {
2431 if (cflag & PARODD) {
2432 config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2433 config->bParity = UMP_UART_ODDPARITY;
2434 dbg("%s - parity = odd", __FUNCTION__);
2435 } else {
2436 config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2437 config->bParity = UMP_UART_EVENPARITY;
2438 dbg("%s - parity = even", __FUNCTION__);
2439 }
2440 } else {
2441 config->bParity = UMP_UART_NOPARITY;
2442 dbg("%s - parity = none", __FUNCTION__);
2443 }
2444
2445 if (cflag & CSTOPB) {
2446 config->bStopBits = UMP_UART_STOPBIT2;
2447 dbg("%s - stop bits = 2", __FUNCTION__);
2448 } else {
2449 config->bStopBits = UMP_UART_STOPBIT1;
2450 dbg("%s - stop bits = 1", __FUNCTION__);
2451 }
2452
2453 /* figure out the flow control settings */
2454 if (cflag & CRTSCTS) {
2455 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
2456 config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
2457 dbg("%s - RTS/CTS is enabled", __FUNCTION__);
2458 } else {
2459 dbg("%s - RTS/CTS is disabled", __FUNCTION__);
2460 tty->hw_stopped = 0;
2461 restart_read(edge_port);
2462 }
2463
2464 /* if we are implementing XON/XOFF, set the start and stop character in the device */
2465 if (I_IXOFF(tty) || I_IXON(tty)) {
2466 config->cXon = START_CHAR(tty);
2467 config->cXoff = STOP_CHAR(tty);
2468
2469 /* if we are implementing INBOUND XON/XOFF */
2470 if (I_IXOFF(tty)) {
2471 config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
2472 dbg ("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2473 __FUNCTION__, config->cXon, config->cXoff);
2474 } else {
2475 dbg ("%s - INBOUND XON/XOFF is disabled", __FUNCTION__);
2476 }
2477
2478 /* if we are implementing OUTBOUND XON/XOFF */
2479 if (I_IXON(tty)) {
2480 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
2481 dbg ("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2482 __FUNCTION__, config->cXon, config->cXoff);
2483 } else {
2484 dbg ("%s - OUTBOUND XON/XOFF is disabled", __FUNCTION__);
2485 }
2486 }
2487
2488 tty->termios->c_cflag &= ~CMSPAR;
2489
2490 /* Round the baud rate */
2491 baud = tty_get_baud_rate(tty);
2492 if (!baud) {
2493 /* pick a default, any default... */
2494 baud = 9600;
2495 } else
2496 tty_encode_baud_rate(tty, baud, baud);
2497
2498 edge_port->baud_rate = baud;
2499 config->wBaudRate = (__u16)((461550L + baud/2) / baud);
2500
2501 /* FIXME: Recompute actual baud from divisor here */
2502
2503 dbg ("%s - baud rate = %d, wBaudRate = %d", __FUNCTION__, baud, config->wBaudRate);
2504
2505 dbg ("wBaudRate: %d", (int)(461550L / config->wBaudRate));
2506 dbg ("wFlags: 0x%x", config->wFlags);
2507 dbg ("bDataBits: %d", config->bDataBits);
2508 dbg ("bParity: %d", config->bParity);
2509 dbg ("bStopBits: %d", config->bStopBits);
2510 dbg ("cXon: %d", config->cXon);
2511 dbg ("cXoff: %d", config->cXoff);
2512 dbg ("bUartMode: %d", config->bUartMode);
2513
2514 /* move the word values into big endian mode */
2515 cpu_to_be16s (&config->wFlags);
2516 cpu_to_be16s (&config->wBaudRate);
2517
2518 status = TIWriteCommandSync (edge_port->port->serial->dev,
2519 UMPC_SET_CONFIG,
2520 (__u8)(UMPM_UART1_PORT + port_number),
2521 0,
2522 (__u8 *)config,
2523 sizeof(*config));
2524 if (status) {
2525 dbg ("%s - error %d when trying to write config to device",
2526 __FUNCTION__, status);
2527 }
2528
2529 kfree (config);
2530
2531 return;
2532 }
2533
2534 static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
2535 {
2536 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2537 struct tty_struct *tty = port->tty;
2538 unsigned int cflag;
2539
2540 cflag = tty->termios->c_cflag;
2541
2542 dbg("%s - clfag %08x iflag %08x", __FUNCTION__,
2543 tty->termios->c_cflag, tty->termios->c_iflag);
2544 dbg("%s - old clfag %08x old iflag %08x", __FUNCTION__,
2545 old_termios->c_cflag, old_termios->c_iflag);
2546
2547 dbg("%s - port %d", __FUNCTION__, port->number);
2548
2549 if (edge_port == NULL)
2550 return;
2551
2552 /* change the port settings to the new ones specified */
2553 change_port_settings (edge_port, old_termios);
2554
2555 return;
2556 }
2557
2558 static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear)
2559 {
2560 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2561 unsigned int mcr;
2562 unsigned long flags;
2563
2564 dbg("%s - port %d", __FUNCTION__, port->number);
2565
2566 spin_lock_irqsave(&edge_port->ep_lock, flags);
2567 mcr = edge_port->shadow_mcr;
2568 if (set & TIOCM_RTS)
2569 mcr |= MCR_RTS;
2570 if (set & TIOCM_DTR)
2571 mcr |= MCR_DTR;
2572 if (set & TIOCM_LOOP)
2573 mcr |= MCR_LOOPBACK;
2574
2575 if (clear & TIOCM_RTS)
2576 mcr &= ~MCR_RTS;
2577 if (clear & TIOCM_DTR)
2578 mcr &= ~MCR_DTR;
2579 if (clear & TIOCM_LOOP)
2580 mcr &= ~MCR_LOOPBACK;
2581
2582 edge_port->shadow_mcr = mcr;
2583 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2584
2585 TIRestoreMCR (edge_port, mcr);
2586
2587 return 0;
2588 }
2589
2590 static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
2591 {
2592 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2593 unsigned int result = 0;
2594 unsigned int msr;
2595 unsigned int mcr;
2596 unsigned long flags;
2597
2598 dbg("%s - port %d", __FUNCTION__, port->number);
2599
2600 spin_lock_irqsave(&edge_port->ep_lock, flags);
2601
2602 msr = edge_port->shadow_msr;
2603 mcr = edge_port->shadow_mcr;
2604 result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
2605 | ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
2606 | ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
2607 | ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */
2608 | ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
2609 | ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
2610
2611
2612 dbg("%s -- %x", __FUNCTION__, result);
2613 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2614
2615 return result;
2616 }
2617
2618 static int get_serial_info (struct edgeport_port *edge_port, struct serial_struct __user *retinfo)
2619 {
2620 struct serial_struct tmp;
2621
2622 if (!retinfo)
2623 return -EFAULT;
2624
2625 memset(&tmp, 0, sizeof(tmp));
2626
2627 tmp.type = PORT_16550A;
2628 tmp.line = edge_port->port->serial->minor;
2629 tmp.port = edge_port->port->number;
2630 tmp.irq = 0;
2631 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
2632 tmp.xmit_fifo_size = edge_port->port->bulk_out_size;
2633 tmp.baud_base = 9600;
2634 tmp.close_delay = 5*HZ;
2635 tmp.closing_wait = closing_wait;
2636 // tmp.custom_divisor = state->custom_divisor;
2637 // tmp.hub6 = state->hub6;
2638 // tmp.io_type = state->io_type;
2639
2640
2641 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2642 return -EFAULT;
2643 return 0;
2644 }
2645
2646 static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
2647 {
2648 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2649 struct async_icount cnow;
2650 struct async_icount cprev;
2651
2652 dbg("%s - port %d, cmd = 0x%x", __FUNCTION__, port->number, cmd);
2653
2654 switch (cmd) {
2655 case TIOCINQ:
2656 dbg("%s - (%d) TIOCINQ", __FUNCTION__, port->number);
2657 // return get_number_bytes_avail(edge_port, (unsigned int *) arg);
2658 break;
2659
2660 case TIOCSERGETLSR:
2661 dbg("%s - (%d) TIOCSERGETLSR", __FUNCTION__, port->number);
2662 // return get_lsr_info(edge_port, (unsigned int *) arg);
2663 break;
2664
2665 case TIOCGSERIAL:
2666 dbg("%s - (%d) TIOCGSERIAL", __FUNCTION__, port->number);
2667 return get_serial_info(edge_port, (struct serial_struct __user *) arg);
2668 break;
2669
2670 case TIOCSSERIAL:
2671 dbg("%s - (%d) TIOCSSERIAL", __FUNCTION__, port->number);
2672 break;
2673
2674 case TIOCMIWAIT:
2675 dbg("%s - (%d) TIOCMIWAIT", __FUNCTION__, port->number);
2676 cprev = edge_port->icount;
2677 while (1) {
2678 interruptible_sleep_on(&edge_port->delta_msr_wait);
2679 /* see if a signal did it */
2680 if (signal_pending(current))
2681 return -ERESTARTSYS;
2682 cnow = edge_port->icount;
2683 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2684 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2685 return -EIO; /* no change => error */
2686 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2687 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2688 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2689 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2690 return 0;
2691 }
2692 cprev = cnow;
2693 }
2694 /* not reached */
2695 break;
2696
2697 case TIOCGICOUNT:
2698 dbg ("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __FUNCTION__,
2699 port->number, edge_port->icount.rx, edge_port->icount.tx);
2700 if (copy_to_user((void __user *)arg, &edge_port->icount, sizeof(edge_port->icount)))
2701 return -EFAULT;
2702 return 0;
2703 }
2704
2705 return -ENOIOCTLCMD;
2706 }
2707
2708 static void edge_break (struct usb_serial_port *port, int break_state)
2709 {
2710 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2711 int status;
2712
2713 dbg ("%s - state = %d", __FUNCTION__, break_state);
2714
2715 /* chase the port close */
2716 TIChasePort (edge_port, 0, 0);
2717
2718 if (break_state == -1) {
2719 status = TISetBreak (edge_port);
2720 } else {
2721 status = TIClearBreak (edge_port);
2722 }
2723 if (status) {
2724 dbg ("%s - error %d sending break set/clear command.",
2725 __FUNCTION__, status);
2726 }
2727 }
2728
2729 static int edge_startup (struct usb_serial *serial)
2730 {
2731 struct edgeport_serial *edge_serial;
2732 struct edgeport_port *edge_port;
2733 struct usb_device *dev;
2734 int status;
2735 int i;
2736
2737 dev = serial->dev;
2738
2739 /* create our private serial structure */
2740 edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2741 if (edge_serial == NULL) {
2742 dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
2743 return -ENOMEM;
2744 }
2745 mutex_init(&edge_serial->es_lock);
2746 edge_serial->serial = serial;
2747 usb_set_serial_data(serial, edge_serial);
2748
2749 status = TIDownloadFirmware (edge_serial);
2750 if (status) {
2751 kfree (edge_serial);
2752 return status;
2753 }
2754
2755 /* set up our port private structures */
2756 for (i = 0; i < serial->num_ports; ++i) {
2757 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
2758 if (edge_port == NULL) {
2759 dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
2760 goto cleanup;
2761 }
2762 spin_lock_init(&edge_port->ep_lock);
2763 edge_port->ep_out_buf = edge_buf_alloc(EDGE_OUT_BUF_SIZE);
2764 if (edge_port->ep_out_buf == NULL) {
2765 dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
2766 kfree(edge_port);
2767 goto cleanup;
2768 }
2769 edge_port->port = serial->port[i];
2770 edge_port->edge_serial = edge_serial;
2771 usb_set_serial_port_data(serial->port[i], edge_port);
2772 edge_port->bUartMode = default_uart_mode;
2773 }
2774
2775 return 0;
2776
2777 cleanup:
2778 for (--i; i>=0; --i) {
2779 edge_port = usb_get_serial_port_data(serial->port[i]);
2780 edge_buf_free(edge_port->ep_out_buf);
2781 kfree(edge_port);
2782 usb_set_serial_port_data(serial->port[i], NULL);
2783 }
2784 kfree (edge_serial);
2785 usb_set_serial_data(serial, NULL);
2786 return -ENOMEM;
2787 }
2788
2789 static void edge_shutdown (struct usb_serial *serial)
2790 {
2791 int i;
2792 struct edgeport_port *edge_port;
2793
2794 dbg ("%s", __FUNCTION__);
2795
2796 for (i = 0; i < serial->num_ports; ++i) {
2797 edge_port = usb_get_serial_port_data(serial->port[i]);
2798 edge_remove_sysfs_attrs(edge_port->port);
2799 edge_buf_free(edge_port->ep_out_buf);
2800 kfree(edge_port);
2801 usb_set_serial_port_data(serial->port[i], NULL);
2802 }
2803 kfree(usb_get_serial_data(serial));
2804 usb_set_serial_data(serial, NULL);
2805 }
2806
2807
2808 /* Sysfs Attributes */
2809
2810 static ssize_t show_uart_mode(struct device *dev,
2811 struct device_attribute *attr, char *buf)
2812 {
2813 struct usb_serial_port *port = to_usb_serial_port(dev);
2814 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2815
2816 return sprintf(buf, "%d\n", edge_port->bUartMode);
2817 }
2818
2819 static ssize_t store_uart_mode(struct device *dev,
2820 struct device_attribute *attr, const char *valbuf, size_t count)
2821 {
2822 struct usb_serial_port *port = to_usb_serial_port(dev);
2823 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2824 unsigned int v = simple_strtoul(valbuf, NULL, 0);
2825
2826 dbg("%s: setting uart_mode = %d", __FUNCTION__, v);
2827
2828 if (v < 256)
2829 edge_port->bUartMode = v;
2830 else
2831 dev_err(dev, "%s - uart_mode %d is invalid\n", __FUNCTION__, v);
2832
2833 return count;
2834 }
2835
2836 static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode, store_uart_mode);
2837
2838 static int edge_create_sysfs_attrs(struct usb_serial_port *port)
2839 {
2840 return device_create_file(&port->dev, &dev_attr_uart_mode);
2841 }
2842
2843 static int edge_remove_sysfs_attrs(struct usb_serial_port *port)
2844 {
2845 device_remove_file(&port->dev, &dev_attr_uart_mode);
2846 return 0;
2847 }
2848
2849
2850 /* Circular Buffer */
2851
2852 /*
2853 * edge_buf_alloc
2854 *
2855 * Allocate a circular buffer and all associated memory.
2856 */
2857
2858 static struct edge_buf *edge_buf_alloc(unsigned int size)
2859 {
2860 struct edge_buf *eb;
2861
2862
2863 if (size == 0)
2864 return NULL;
2865
2866 eb = kmalloc(sizeof(struct edge_buf), GFP_KERNEL);
2867 if (eb == NULL)
2868 return NULL;
2869
2870 eb->buf_buf = kmalloc(size, GFP_KERNEL);
2871 if (eb->buf_buf == NULL) {
2872 kfree(eb);
2873 return NULL;
2874 }
2875
2876 eb->buf_size = size;
2877 eb->buf_get = eb->buf_put = eb->buf_buf;
2878
2879 return eb;
2880 }
2881
2882
2883 /*
2884 * edge_buf_free
2885 *
2886 * Free the buffer and all associated memory.
2887 */
2888
2889 static void edge_buf_free(struct edge_buf *eb)
2890 {
2891 if (eb) {
2892 kfree(eb->buf_buf);
2893 kfree(eb);
2894 }
2895 }
2896
2897
2898 /*
2899 * edge_buf_clear
2900 *
2901 * Clear out all data in the circular buffer.
2902 */
2903
2904 static void edge_buf_clear(struct edge_buf *eb)
2905 {
2906 if (eb != NULL)
2907 eb->buf_get = eb->buf_put;
2908 /* equivalent to a get of all data available */
2909 }
2910
2911
2912 /*
2913 * edge_buf_data_avail
2914 *
2915 * Return the number of bytes of data available in the circular
2916 * buffer.
2917 */
2918
2919 static unsigned int edge_buf_data_avail(struct edge_buf *eb)
2920 {
2921 if (eb != NULL)
2922 return ((eb->buf_size + eb->buf_put - eb->buf_get) % eb->buf_size);
2923 else
2924 return 0;
2925 }
2926
2927
2928 /*
2929 * edge_buf_space_avail
2930 *
2931 * Return the number of bytes of space available in the circular
2932 * buffer.
2933 */
2934
2935 static unsigned int edge_buf_space_avail(struct edge_buf *eb)
2936 {
2937 if (eb != NULL)
2938 return ((eb->buf_size + eb->buf_get - eb->buf_put - 1) % eb->buf_size);
2939 else
2940 return 0;
2941 }
2942
2943
2944 /*
2945 * edge_buf_put
2946 *
2947 * Copy data data from a user buffer and put it into the circular buffer.
2948 * Restrict to the amount of space available.
2949 *
2950 * Return the number of bytes copied.
2951 */
2952
2953 static unsigned int edge_buf_put(struct edge_buf *eb, const char *buf,
2954 unsigned int count)
2955 {
2956 unsigned int len;
2957
2958
2959 if (eb == NULL)
2960 return 0;
2961
2962 len = edge_buf_space_avail(eb);
2963 if (count > len)
2964 count = len;
2965
2966 if (count == 0)
2967 return 0;
2968
2969 len = eb->buf_buf + eb->buf_size - eb->buf_put;
2970 if (count > len) {
2971 memcpy(eb->buf_put, buf, len);
2972 memcpy(eb->buf_buf, buf+len, count - len);
2973 eb->buf_put = eb->buf_buf + count - len;
2974 } else {
2975 memcpy(eb->buf_put, buf, count);
2976 if (count < len)
2977 eb->buf_put += count;
2978 else /* count == len */
2979 eb->buf_put = eb->buf_buf;
2980 }
2981
2982 return count;
2983 }
2984
2985
2986 /*
2987 * edge_buf_get
2988 *
2989 * Get data from the circular buffer and copy to the given buffer.
2990 * Restrict to the amount of data available.
2991 *
2992 * Return the number of bytes copied.
2993 */
2994
2995 static unsigned int edge_buf_get(struct edge_buf *eb, char *buf,
2996 unsigned int count)
2997 {
2998 unsigned int len;
2999
3000
3001 if (eb == NULL)
3002 return 0;
3003
3004 len = edge_buf_data_avail(eb);
3005 if (count > len)
3006 count = len;
3007
3008 if (count == 0)
3009 return 0;
3010
3011 len = eb->buf_buf + eb->buf_size - eb->buf_get;
3012 if (count > len) {
3013 memcpy(buf, eb->buf_get, len);
3014 memcpy(buf+len, eb->buf_buf, count - len);
3015 eb->buf_get = eb->buf_buf + count - len;
3016 } else {
3017 memcpy(buf, eb->buf_get, count);
3018 if (count < len)
3019 eb->buf_get += count;
3020 else /* count == len */
3021 eb->buf_get = eb->buf_buf;
3022 }
3023
3024 return count;
3025 }
3026
3027
3028 static struct usb_serial_driver edgeport_1port_device = {
3029 .driver = {
3030 .owner = THIS_MODULE,
3031 .name = "edgeport_ti_1",
3032 },
3033 .description = "Edgeport TI 1 port adapter",
3034 .usb_driver = &io_driver,
3035 .id_table = edgeport_1port_id_table,
3036 .num_interrupt_in = 1,
3037 .num_bulk_in = 1,
3038 .num_bulk_out = 1,
3039 .num_ports = 1,
3040 .open = edge_open,
3041 .close = edge_close,
3042 .throttle = edge_throttle,
3043 .unthrottle = edge_unthrottle,
3044 .attach = edge_startup,
3045 .shutdown = edge_shutdown,
3046 .port_probe = edge_create_sysfs_attrs,
3047 .ioctl = edge_ioctl,
3048 .set_termios = edge_set_termios,
3049 .tiocmget = edge_tiocmget,
3050 .tiocmset = edge_tiocmset,
3051 .write = edge_write,
3052 .write_room = edge_write_room,
3053 .chars_in_buffer = edge_chars_in_buffer,
3054 .break_ctl = edge_break,
3055 .read_int_callback = edge_interrupt_callback,
3056 .read_bulk_callback = edge_bulk_in_callback,
3057 .write_bulk_callback = edge_bulk_out_callback,
3058 };
3059
3060 static struct usb_serial_driver edgeport_2port_device = {
3061 .driver = {
3062 .owner = THIS_MODULE,
3063 .name = "edgeport_ti_2",
3064 },
3065 .description = "Edgeport TI 2 port adapter",
3066 .usb_driver = &io_driver,
3067 .id_table = edgeport_2port_id_table,
3068 .num_interrupt_in = 1,
3069 .num_bulk_in = 2,
3070 .num_bulk_out = 2,
3071 .num_ports = 2,
3072 .open = edge_open,
3073 .close = edge_close,
3074 .throttle = edge_throttle,
3075 .unthrottle = edge_unthrottle,
3076 .attach = edge_startup,
3077 .shutdown = edge_shutdown,
3078 .port_probe = edge_create_sysfs_attrs,
3079 .ioctl = edge_ioctl,
3080 .set_termios = edge_set_termios,
3081 .tiocmget = edge_tiocmget,
3082 .tiocmset = edge_tiocmset,
3083 .write = edge_write,
3084 .write_room = edge_write_room,
3085 .chars_in_buffer = edge_chars_in_buffer,
3086 .break_ctl = edge_break,
3087 .read_int_callback = edge_interrupt_callback,
3088 .read_bulk_callback = edge_bulk_in_callback,
3089 .write_bulk_callback = edge_bulk_out_callback,
3090 };
3091
3092
3093 static int __init edgeport_init(void)
3094 {
3095 int retval;
3096 retval = usb_serial_register(&edgeport_1port_device);
3097 if (retval)
3098 goto failed_1port_device_register;
3099 retval = usb_serial_register(&edgeport_2port_device);
3100 if (retval)
3101 goto failed_2port_device_register;
3102 retval = usb_register(&io_driver);
3103 if (retval)
3104 goto failed_usb_register;
3105 info(DRIVER_DESC " " DRIVER_VERSION);
3106 return 0;
3107 failed_usb_register:
3108 usb_serial_deregister(&edgeport_2port_device);
3109 failed_2port_device_register:
3110 usb_serial_deregister(&edgeport_1port_device);
3111 failed_1port_device_register:
3112 return retval;
3113 }
3114
3115 static void __exit edgeport_exit (void)
3116 {
3117 usb_deregister (&io_driver);
3118 usb_serial_deregister (&edgeport_1port_device);
3119 usb_serial_deregister (&edgeport_2port_device);
3120 }
3121
3122 module_init(edgeport_init);
3123 module_exit(edgeport_exit);
3124
3125 /* Module information */
3126 MODULE_AUTHOR(DRIVER_AUTHOR);
3127 MODULE_DESCRIPTION(DRIVER_DESC);
3128 MODULE_LICENSE("GPL");
3129
3130 module_param(debug, bool, S_IRUGO | S_IWUSR);
3131 MODULE_PARM_DESC(debug, "Debug enabled or not");
3132
3133 module_param(low_latency, bool, S_IRUGO | S_IWUSR);
3134 MODULE_PARM_DESC(low_latency, "Low latency enabled or not");
3135
3136 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
3137 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
3138
3139 module_param(ignore_cpu_rev, bool, S_IRUGO | S_IWUSR);
3140 MODULE_PARM_DESC(ignore_cpu_rev, "Ignore the cpu revision when connecting to a device");
3141
3142 module_param(default_uart_mode, int, S_IRUGO | S_IWUSR);
3143 MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");
3144
x86 "subsystem" repository