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