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