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