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