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