开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
io_ti.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：71k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

io_ti.c：源码内容
  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
  14.  *
  15.  * Version history:
  16.  *
  17.  * July 11, 2002  Removed 4 port device structure since all TI UMP 
  18.  * chips have only 2 ports 
  19.  * David Iacovelli (davidi@ionetworks.com)
  20.  *
  21.  */
  23. #include <linux/config.h>
  24. #include <linux/kernel.h>
  25. #include <linux/errno.h>
  26. #include <linux/init.h>
  27. #include <linux/slab.h>
  28. #include <linux/tty.h>
  29. #include <linux/tty_driver.h>
  30. #include <linux/tty_flip.h>
  31. #include <linux/module.h>
  32. #include <linux/spinlock.h>
  33. #include <linux/serial.h>
  34. #include <linux/ioctl.h>
  35. #include <asm/uaccess.h>
  36. #include <linux/usb.h>
  38. #ifdef CONFIG_USB_SERIAL_DEBUG
  39. static int debug = 1;
  40. #else
  41. static int debug;
  42. #endif
  44. #include "usb-serial.h"
  46. #include "io_16654.h"
  47. #include "io_usbvend.h"
  48. #include "io_ti.h"
  50. /*
  51.  * Version Information
  52.  */
  53. #define DRIVER_VERSION "v0.2"
  54. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
  55. #define DRIVER_DESC "Edgeport USB Serial Driver"
  58. /* firmware image code */
  59. #define IMAGE_VERSION_NAME PagableOperationalCodeImageVersion
  60. #define IMAGE_ARRAY_NAME PagableOperationalCodeImage
  61. #define IMAGE_SIZE PagableOperationalCodeSize
  62. #include "io_fw_down3.h" /* Define array OperationalCodeImage[] */
  64. #define EPROM_PAGE_SIZE 64
  67. struct edgeport_uart_buf_desc {
  68. __u32 count; // Number of bytes currently in buffer
  69. };
  71. /* different hardware types */
  72. #define HARDWARE_TYPE_930 0
  73. #define HARDWARE_TYPE_TIUMP 1
  75. // IOCTL_PRIVATE_TI_GET_MODE Definitions
  76. #define TI_MODE_CONFIGURING 0   // Device has not entered start device 
  77. #define TI_MODE_BOOT 1   // Staying in boot mode
  78. #define TI_MODE_DOWNLOAD 2   // Made it to download mode
  79. #define TI_MODE_TRANSITIONING 3   // Currently in boot mode but transitioning to download mode
  82. /* Product information read from the Edgeport */
  83. struct product_info
  84. {
  85. int TiMode; // Current TI Mode
  86. __u8 hardware_type; // Type of hardware
  87. } __attribute__((packed));
  90. struct edgeport_port {
  91. __u16 uart_base;
  92. __u16 dma_address;
  93. __u8 shadow_msr;
  94. __u8 shadow_mcr;
  95. __u8 shadow_lsr;
  96. __u8 lsr_mask;
  97. __u32 ump_read_timeout; /* Number of miliseconds the UMP will
  98.    wait without data before completing
  99.    a read short */
  100. int baud_rate;
  101. int close_pending;
  102. int lsr_event;
  103. struct edgeport_uart_buf_desc tx;
  104. struct async_icount icount;
  105. wait_queue_head_t delta_msr_wait; /* for handling sleeping while
  106.    waiting for msr change to
  107.    happen */
  108. struct edgeport_serial *edge_serial;
  109. struct usb_serial_port *port;
  110. };
  112. struct edgeport_serial {
  113. struct product_info product_info;
  114. u8 TI_I2C_Type; // Type of I2C in UMP
  115. u8 TiReadI2C; // Set to TRUE if we have read the I2c in Boot Mode
  116. int num_ports_open;
  117. struct usb_serial *serial;
  118. };
  121. /* Devices that this driver supports */
  122. static struct usb_device_id edgeport_1port_id_table [] = {
  123. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
  124. { }
  125. };
  127. static struct usb_device_id edgeport_2port_id_table [] = {
  128. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
  129. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
  130. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
  131. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421_BOOT) },
  132. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421_DOWN) },
  133. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
  134. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21_BOOT) },
  135. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21_DOWN) },
  136. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
  137. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
  138. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
  139. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22) },
  140. { }
  141. };
  143. /* Devices that this driver supports */
  144. static __devinitdata struct usb_device_id id_table_combined [] = {
  145. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
  146. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
  147. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
  148. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
  149. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421_BOOT) },
  150. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421_DOWN) },
  151. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
  152. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21_BOOT) },
  153. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21_DOWN) },
  154. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
  155. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
  156. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
  157. { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22) },
  158. { }
  159. };
  161. MODULE_DEVICE_TABLE (usb, id_table_combined);
  164. static struct EDGE_FIRMWARE_VERSION_INFO OperationalCodeImageVersion;
  166. static int TIStayInBootMode = 0;
  167. static int ignore_cpu_rev = 0;
  171. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios);
  173. static int TIReadVendorRequestSync (struct usb_device *dev,
  174. __u8 request,
  175. __u16 value,
  176. __u16 index,
  177. u8  *data,
  178. int size)
  179. {
  180. int status;
  182. status = usb_control_msg (dev,
  183. usb_rcvctrlpipe(dev, 0),
  184. request,
  185. (USB_TYPE_VENDOR | 
  186.  USB_RECIP_DEVICE | 
  187.  USB_DIR_IN),
  188. value,
  189. index,
  190. data,
  191. size,
  192. HZ);
  193. if (status < 0)
  194. return status;
  195. if (status != size) {
  196. dbg ("%s - wanted to write %d, but only wrote %d",
  197.      __FUNCTION__, size, status);
  198. return -ECOMM;
  199. }
  200. return 0;
  201. }
  203. static int TISendVendorRequestSync (struct usb_device *dev,
  204. __u8 request,
  205. __u16 value,
  206. __u16 index,
  207. u8  *data,
  208. int size)
  209. {
  210. int status;
  212. status = usb_control_msg (dev,
  213. usb_sndctrlpipe(dev, 0),
  214. request,
  215. (USB_TYPE_VENDOR | 
  216.  USB_RECIP_DEVICE | 
  217.  USB_DIR_OUT),
  218. value,
  219. index,
  220. data,
  221. size,
  222. HZ);
  224. if (status < 0)
  225. return status;
  226. if (status != size) {
  227. dbg ("%s - wanted to write %d, but only wrote %d",
  228.      __FUNCTION__, size, status);
  229. return -ECOMM;
  230. }
  231. return 0;
  232. }
  234. static int TIWriteCommandSync (struct usb_device *dev, __u8 command,
  235. __u8 moduleid, __u16 value, u8 *data,
  236. int size)
  237. {
  238. return TISendVendorRequestSync (dev,
  239.   command,    // Request
  240.   value, // wValue 
  241.   moduleid, // wIndex
  242.   data, // TransferBuffer
  243.   size); // TransferBufferLength
  245. }
  248. /* clear tx/rx buffers and fifo in TI UMP */
  249. static int TIPurgeDataSync (struct usb_serial_port *port, __u16 mask)
  250. {
  251. int port_number = port->number - port->serial->minor;
  253. dbg ("%s - port %d, mask %x", __FUNCTION__, port_number, mask);
  255. return TIWriteCommandSync (port->serial->dev,
  256. UMPC_PURGE_PORT,
  257. (__u8)(UMPM_UART1_PORT + port_number),
  258. mask,
  259. NULL,
  260. 0);
  261. }
  263. /**
  264.  * TIReadDownloadMemory - Read edgeport memory from TI chip
  265.  * @dev: usb device pointer
  266.  * @address: Device CPU address at which to read
  267.  * @length: Length of above data
  268.  * @address_type: Can read both XDATA and I2C
  269.  * @buffer: pointer to input data buffer
  270.  */
  271. int TIReadDownloadMemory (struct usb_device *dev, int start_address, int length,
  272.   __u8 address_type, __u8 *buffer)
  273. {
  274. int status = 0;
  275. __u8 read_length;
  276. __u16 be_start_address;
  278. dbg ("%s - @ %x for %d", __FUNCTION__, start_address, length);
  280. /* Read in blocks of 64 bytes
  281.  * (TI firmware can't handle more than 64 byte reads)
  282.  */
  283. while (length) {
  284. if (length > 64)
  285. read_length= 64;
  286. else
  287. read_length = (__u8)length;
  289. if (read_length > 1) {
  290. dbg ("%s - @ %x for %d", __FUNCTION__, 
  291.      start_address, read_length);
  292. }
  293. be_start_address = cpu_to_be16 (start_address);
  294. status = TIReadVendorRequestSync (dev,
  295.   UMPC_MEMORY_READ, // Request
  296.   (__u16)address_type, // wValue (Address type)
  297.   be_start_address, // wIndex (Address to read)
  298.   buffer, // TransferBuffer
  299.   read_length); // TransferBufferLength
  301. if (status) {
  302. dbg ("%s - ERROR %x", __FUNCTION__, status);
  303. return status;
  304. }
  306. if (read_length > 1) {
  307. usb_serial_debug_data (__FILE__, __FUNCTION__,
  308.        read_length, buffer);
  309. }
  311. /* Update pointers/length */
  312. start_address += read_length;
  313. buffer += read_length;
  314. length -= read_length;
  315. }
  317. return status;
  318. }
  320. int TIReadRam (struct usb_device *dev, int start_address, int length, __u8 *buffer)
  321. {
  322. return TIReadDownloadMemory (dev,
  323.      start_address,
  324.      length,
  325.      DTK_ADDR_SPACE_XDATA,
  326.      buffer);
  327. }
  329. /* Read edgeport memory to a given block */
  330. static int TIReadBootMemory (struct edgeport_serial *serial, int start_address, int length, __u8 * buffer)
  331. {
  332. int status = 0;
  333. int i;
  335. for (i=0; i< length; i++) {
  336. status = TIReadVendorRequestSync (serial->serial->dev,
  337. UMPC_MEMORY_READ, // Request
  338. serial->TI_I2C_Type, // wValue (Address type)
  339. (__u16)(start_address+i), // wIndex
  340. &buffer[i], // TransferBuffer
  341. 0x01); // TransferBufferLength
  342. if (status) {
  343. dbg ("%s - ERROR %x", __FUNCTION__, status);
  344. return status;
  345. }
  346. }
  348. dbg ("%s - start_address = %x, length = %d", __FUNCTION__, start_address, length);
  349. usb_serial_debug_data (__FILE__, __FUNCTION__, length, buffer);
  351. serial->TiReadI2C = 1;
  353. return status;
  354. }
  356. /* Write given block to TI EPROM memory */
  357. static int TIWriteBootMemory (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
  358. {
  359. int status = 0;
  360. int i;
  361. __u8 temp;
  363. /* Must do a read before write */
  364. if (!serial->TiReadI2C) {
  365. status = TIReadBootMemory(serial, 0, 1, &temp);
  366. if (status)
  367. return status;
  368. }
  370. for (i=0; i < length; ++i) {
  371. status = TISendVendorRequestSync (serial->serial->dev,
  372. UMPC_MEMORY_WRITE, // Request
  373. buffer[i], // wValue
  374. (__u16)(i+start_address), // wIndex
  375. NULL, // TransferBuffer
  376. 0); // TransferBufferLength
  377. if (status)
  378. return status;
  379. }
  381.    dbg ("%s - start_sddr = %x, length = %d", __FUNCTION__, start_address, length);
  382. usb_serial_debug_data (__FILE__, __FUNCTION__, length, buffer);
  384. return status;
  385. }
  388. /* Write edgeport I2C memory to TI chip */
  389. static int TIWriteDownloadI2C (struct edgeport_serial *serial, int start_address, int length, __u8 address_type, __u8 *buffer)
  390. {
  391. int status = 0;
  392. int write_length;
  393. __u16 be_start_address;
  395. /* We can only send a maximum of 1 aligned byte page at a time */
  397. /* calulate the number of bytes left in the first page */
  398. write_length = EPROM_PAGE_SIZE - (start_address & (EPROM_PAGE_SIZE - 1));
  400. if (write_length > length)
  401. write_length = length;
  403. dbg ("%s - BytesInFirstPage Addr = %x, length = %d", __FUNCTION__, start_address, write_length);
  404. usb_serial_debug_data (__FILE__, __FUNCTION__, write_length, buffer);
  406. /* Write first page */
  407. be_start_address = cpu_to_be16 (start_address);
  408. status = TISendVendorRequestSync (serial->serial->dev,
  409. UMPC_MEMORY_WRITE, // Request
  410. (__u16)address_type, // wValue
  411. be_start_address, // wIndex
  412. buffer, // TransferBuffer
  413. write_length);
  414. if (status) {
  415. dbg ("%s - ERROR %d", __FUNCTION__, status);
  416. return status;
  417. }
  419. length -= write_length;
  420. start_address += write_length;
  421. buffer += write_length;
  423. /* We should be aligned now -- can write max page size bytes at a time */
  424. while (length) {
  425. if (length > EPROM_PAGE_SIZE)
  426. write_length = EPROM_PAGE_SIZE;
  427. else
  428. write_length = length;
  430. dbg ("%s - Page Write Addr = %x, length = %d", __FUNCTION__, start_address, write_length);
  431. usb_serial_debug_data (__FILE__, __FUNCTION__, write_length, buffer);
  433. /* Write next page */
  434. be_start_address = cpu_to_be16 (start_address);
  435. status = TISendVendorRequestSync (serial->serial->dev,
  436. UMPC_MEMORY_WRITE, // Request
  437. (__u16)address_type, // wValue
  438. be_start_address, // wIndex
  439. buffer,    // TransferBuffer
  440. write_length); // TransferBufferLength
  441. if (status) {
  442. dbg ("%s - ERROR %d", __FUNCTION__, status);
  443. return status;
  444. }
  446. length -= write_length;
  447. start_address += write_length;
  448. buffer += write_length;
  449. }
  450. return status;
  451. }
  453. /* Examine the UMP DMA registers and LSR
  454.  * 
  455.  * Check the MSBit of the X and Y DMA byte count registers.
  456.  * A zero in this bit indicates that the TX DMA buffers are empty
  457.  * then check the TX Empty bit in the UART.
  458.  */
  459. static int TIIsTxActive (struct edgeport_port *port)
  460. {
  461. int status;
  462. struct out_endpoint_desc_block *oedb;
  463. __u8 lsr;
  464. int bytes_left = 0;
  466. oedb = kmalloc (sizeof (* oedb), GFP_KERNEL);
  467. if (!oedb) {
  468. err ("%s - out of memory", __FUNCTION__);
  469. return -ENOMEM;
  470. }
  472. /* Read the DMA Count Registers */
  473. status = TIReadRam (port->port->serial->dev,
  474.     port->dma_address,
  475.     sizeof( *oedb),
  476.     (void *)oedb);
  478. if (status)
  479. goto exit_is_tx_active;
  481. dbg ("%s - XByteCount    0x%X", __FUNCTION__, oedb->XByteCount);
  483. /* and the LSR */
  484. status = TIReadRam (port->port->serial->dev, 
  485.     port->uart_base + UMPMEM_OFFS_UART_LSR,
  486.     1,
  487.     &lsr);
  489. if (status)
  490. goto exit_is_tx_active;
  491. dbg ("%s - LSR = 0x%X", __FUNCTION__, lsr);
  493. /* If either buffer has data or we are transmitting then return TRUE */
  494. if ((oedb->XByteCount & 0x80 ) != 0 )
  495. bytes_left += 64;
  497. if ((lsr & UMP_UART_LSR_TX_MASK ) == 0 )
  498. bytes_left += 1;
  500. /* We return Not Active if we get any kind of error */
  501. exit_is_tx_active:
  502. dbg ("%s - return %d", __FUNCTION__, bytes_left );
  503. return bytes_left;
  504. }
  506. static void TIChasePort(struct edgeport_port *port)
  507. {
  508. int loops;
  509. int last_count;
  510. int write_size;
  512. restart_tx_loop:
  513. // Base the LoopTime on the baud rate
  514. if (port->baud_rate == 0)
  515. port->baud_rate = 1200;
  517. write_size = port->tx.count;
  518. loops = max(100, (100*write_size)/(port->baud_rate/10));
  519. dbg ("%s - write_size %d, baud %d loop = %d", __FUNCTION__,
  520.      write_size, port->baud_rate, loops);
  522. while (1) {
  523. // Save Last count
  524. last_count = port->tx.count;
  526. dbg ("%s - Tx Buffer Size = %d loops = %d", __FUNCTION__,
  527.      last_count, loops);
  529. /* Is the Edgeport Buffer empty? */
  530. if (port->tx.count == 0)
  531. break;
  533. /* Block the thread for 10ms */
  534. wait_ms (10);
  536. if (last_count == port->tx.count) {
  537. /* No activity.. count down. */
  538. --loops;
  539. if (loops == 0) {
  540. dbg ("%s - Wait for TxEmpty - TIMEOUT",
  541.      __FUNCTION__);
  542. return;
  543. }
  544. } else {
  545. /* Reset timeout value back to a minimum of 1 second */
  546. dbg ("%s - Wait for TxEmpty  Reset Count", __FUNCTION__);
  547. goto restart_tx_loop;
  548. }
  549. }
  551. dbg ("%s - Local Tx Buffer Empty -- Waiting for TI UMP to EMPTY X/Y and FIFO",
  552.      __FUNCTION__);
  554. write_size = TIIsTxActive (port);
  555. loops = max(50, (100*write_size)/(port->baud_rate/10));
  556. dbg ("%s - write_size %d, baud %d loop = %d", __FUNCTION__, 
  557.      write_size, port->baud_rate, loops);
  559. while (1) {
  560. /* This function takes 4 ms; */
  561. if (!TIIsTxActive (port)) {
  562. /* Delay a few char times */
  563. wait_ms (50);
  564. dbg ("%s - Empty", __FUNCTION__);
  565. return;
  566. }
  568. --loops;
  569. if (loops == 0) {
  570. dbg ("%s - TIMEOUT", __FUNCTION__);
  571. return;
  572. }
  573. }
  574. }
  576. static int TIChooseConfiguration (struct usb_device *dev)
  577. {
  578. // There may be multiple configurations on this device, in which case
  579. // we would need to read and parse all of them to find out which one
  580. // we want. However, we just support one config at this point,
  581. // configuration # 1, which is Config Descriptor 0.
  583. dbg ("%s - Number of Interfaces = %d", __FUNCTION__, dev->config->bNumInterfaces);
  584. dbg ("%s - MAX Power            = %d", __FUNCTION__, dev->config->MaxPower*2);
  586. if (dev->config->bNumInterfaces != 1) {
  587. err ("%s - bNumInterfaces is not 1, ERROR!", __FUNCTION__);
  588. return -ENODEV;
  589. }
  591. return 0;
  592. }
  594. int TIReadRom (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
  595. {
  596. int status;
  598. if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
  599. status = TIReadDownloadMemory (serial->serial->dev,
  600.        start_address,
  601.        length,
  602.        serial->TI_I2C_Type,
  603.        buffer);
  604. } else {
  605. status = TIReadBootMemory (serial,
  606.    start_address,
  607.    length,
  608.    buffer);
  609. }
  611. return status;
  612. }
  614. int TIWriteRom (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
  615. {
  616. if (serial->product_info.TiMode == TI_MODE_BOOT)
  617. return TIWriteBootMemory (serial,
  618.   start_address,
  619.   length,
  620.   buffer);
  622. if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)
  623. return TIWriteDownloadI2C (serial,
  624.    start_address,
  625.    length,
  626.    serial->TI_I2C_Type,
  627.    buffer);
  629. return -EINVAL;
  630. }
  634. /* Read a descriptor header from I2C based on type */
  635. static int TIGetDescriptorAddress (struct edgeport_serial *serial, int desc_type, struct ti_i2c_desc *rom_desc)
  636. {
  637. int start_address;
  638. int status;
  640. /* Search for requested descriptor in I2C */
  641. start_address = 2;
  642. do {
  643. status = TIReadRom (serial,
  644.    start_address,
  645.    sizeof(struct ti_i2c_desc),
  646.    (__u8 *)rom_desc );
  647. if (status)
  648. return 0;
  650. if (rom_desc->Type == desc_type)
  651. return start_address;
  653. start_address = start_address + sizeof(struct ti_i2c_desc) +  rom_desc->Size;
  655. } while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);
  657. return 0;
  658. }
  660. /* Validate descriptor checksum */
  661. static int ValidChecksum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
  662. {
  663. __u16 i;
  664. __u8 cs = 0;
  666. for (i=0; i < rom_desc->Size; i++) {
  667. cs = (__u8)(cs + buffer[i]);
  668. }
  669. if (cs != rom_desc->CheckSum) {
  670. dbg ("%s - Mismatch %x - %x", __FUNCTION__, rom_desc->CheckSum, cs);
  671. return -EINVAL;
  672. }
  673. return 0;
  674. }
  676. /* Make sure that the I2C image is good */
  677. static int TiValidateI2cImage (struct edgeport_serial *serial)
  678. {
  679. int status = 0;
  680. struct ti_i2c_desc *rom_desc;
  681. int start_address = 2;
  682. __u8 *buffer;
  684. rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
  685. if (!rom_desc) {
  686. err ("%s - out of memory", __FUNCTION__);
  687. return -ENOMEM;
  688. }
  689. buffer = kmalloc (TI_MAX_I2C_SIZE, GFP_KERNEL);
  690. if (!buffer) {
  691. err ("%s - out of memory when allocating buffer", __FUNCTION__);
  692. kfree (rom_desc);
  693. return -ENOMEM;
  694. }
  696. // Read the first byte (Signature0) must be 0x52
  697. status = TIReadRom (serial, 0, 1, buffer);
  698. if (status)
  699. goto ExitTiValidateI2cImage; 
  701. if (*buffer != 0x52) {
  702. err ("%s - invalid buffer signature", __FUNCTION__);
  703. status = -ENODEV;
  704. goto ExitTiValidateI2cImage;
  705. }
  707. do {
  708. // Validate the I2C
  709. status = TIReadRom (serial,
  710. start_address,
  711. sizeof(struct ti_i2c_desc),
  712. (__u8 *)rom_desc);
  713. if (status)
  714. break;
  716. if ((start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size) > TI_MAX_I2C_SIZE) {
  717. status = -ENODEV;
  718. dbg ("%s - structure too big, erroring out.", __FUNCTION__);
  719. break;
  720. }
  722. dbg ("%s Type = 0x%x", __FUNCTION__, rom_desc->Type);
  724. // Skip type 2 record
  725. if ((rom_desc->Type & 0x0f) != I2C_DESC_TYPE_FIRMWARE_BASIC) {
  726. // Read the descriptor data
  727. status = TIReadRom(serial,
  728. start_address+sizeof(struct ti_i2c_desc),
  729. rom_desc->Size,
  730. buffer);
  731. if (status)
  732. break;
  734. status = ValidChecksum(rom_desc, buffer);
  735. if (status)
  736. break;
  737. }
  738. start_address = start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size;
  740. } while ((rom_desc->Type != I2C_DESC_TYPE_ION) && (start_address < TI_MAX_I2C_SIZE));
  742. if ((rom_desc->Type != I2C_DESC_TYPE_ION) || (start_address > TI_MAX_I2C_SIZE))
  743. status = -ENODEV;
  745. ExitTiValidateI2cImage:
  746. kfree (buffer);
  747. kfree (rom_desc);
  748. return status;
  749. }
  751. static int TIReadManufDescriptor (struct edgeport_serial *serial, __u8 *buffer)
  752. {
  753. int status;
  754. int start_address;
  755. struct ti_i2c_desc *rom_desc;
  756. struct edge_ti_manuf_descriptor *desc;
  758. rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
  759. if (!rom_desc) {
  760. err ("%s - out of memory", __FUNCTION__);
  761. return -ENOMEM;
  762. }
  763. start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_ION, rom_desc);
  765. if (!start_address) {
  766. dbg ("%s - Edge Descriptor not found in I2C", __FUNCTION__);
  767. status = -ENODEV;
  768. goto exit;
  769. }
  771. // Read the descriptor data
  772. status = TIReadRom (serial,
  773. start_address+sizeof(struct ti_i2c_desc),
  774. rom_desc->Size,
  775. buffer);
  776. if (status)
  777. goto exit;
  779. status = ValidChecksum(rom_desc, buffer);
  781. desc = (struct edge_ti_manuf_descriptor *)buffer;
  782. dbg ( "%s - IonConfig      0x%x", __FUNCTION__, desc->IonConfig  );
  783. dbg ( "%s - Version          %d", __FUNCTION__, desc->Version    );
  784. dbg ( "%s - Cpu/Board      0x%x", __FUNCTION__, desc->CpuRev_BoardRev );
  785. dbg ( "%s - NumPorts         %d", __FUNCTION__, desc->NumPorts   );
  786. dbg ( "%s - NumVirtualPorts  %d", __FUNCTION__, desc->NumVirtualPorts );
  787. dbg ( "%s - TotalPorts       %d", __FUNCTION__, desc->TotalPorts   );
  789. exit:
  790. kfree (rom_desc);
  791. return status;
  792. }
  794. /* Build firmware header used for firmware update */
  795. static int BuildI2CFirmwareHeader (__u8 *header)
  796. {
  797. __u8 *buffer;
  798. int buffer_size;
  799. int i;
  800. __u8 cs = 0;
  801. struct ti_i2c_desc *i2c_header;
  802. struct ti_i2c_image_header *img_header;
  803. struct ti_i2c_firmware_rec *firmware_rec;
  805. // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
  806. // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
  807. // will download the latest firmware (padded to 15.5k) into the UMP ram. 
  808. // And finally when the device comes back up in download mode the driver will cause 
  809. // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
  810. // the record type from 0xf2 to 0x02.
  812. // Allocate a 15.5k buffer + 2 bytes for version number (Firmware Record)
  813. buffer_size = (((1024 * 16) - 512 )+ sizeof(struct ti_i2c_firmware_rec));
  815. buffer = kmalloc (buffer_size, GFP_KERNEL);
  816. if (!buffer) {
  817. err ("%s - out of memory", __FUNCTION__);
  818. return -ENOMEM;
  819. }
  821. // Set entire image of 0xffs
  822. memset (buffer, 0xff, buffer_size);
  824. // Copy version number into firmware record
  825. firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
  827. firmware_rec->Ver_Major = OperationalCodeImageVersion.MajorVersion;
  828. firmware_rec->Ver_Minor = OperationalCodeImageVersion.MinorVersion;
  830. // Pointer to fw_down memory image
  831. img_header = (struct ti_i2c_image_header *)&PagableOperationalCodeImage[0];
  833. memcpy (buffer + sizeof(struct ti_i2c_firmware_rec),
  834. &PagableOperationalCodeImage[sizeof(struct ti_i2c_image_header)],
  835. img_header->Length);
  837. for (i=0; i < buffer_size; i++) {
  838. cs = (__u8)(cs + buffer[i]);
  839. }
  841. kfree (buffer);
  843. // Build new header
  844. i2c_header =  (struct ti_i2c_desc *)header;
  845. firmware_rec =  (struct ti_i2c_firmware_rec*)i2c_header->Data;
  847. i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK;
  848. i2c_header->Size = (__u16)buffer_size;
  849. i2c_header->CheckSum = cs;
  850. firmware_rec->Ver_Major = OperationalCodeImageVersion.MajorVersion;
  851. firmware_rec->Ver_Minor = OperationalCodeImageVersion.MinorVersion;
  853. return 0;
  854. }
  856. /* Try to figure out what type of I2c we have */
  857. static int TIGetI2cTypeInBootMode (struct edgeport_serial *serial)
  858. {
  859. int status;
  860. __u8 data;
  862. // Try to read type 2
  863. status = TIReadVendorRequestSync (serial->serial->dev,
  864. UMPC_MEMORY_READ, // Request
  865. DTK_ADDR_SPACE_I2C_TYPE_II, // wValue (Address type)
  866. 0,   // wIndex
  867. &data, // TransferBuffer
  868. 0x01); // TransferBufferLength
  869. if (status)
  870. dbg ("%s - read 2 status error = %d", __FUNCTION__, status);
  871. else
  872. dbg ("%s - read 2 data = 0x%x", __FUNCTION__, data);
  873. if ((!status) && data == 0x52) {
  874. dbg ("%s - ROM_TYPE_II", __FUNCTION__);
  875. serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
  876. return 0;
  877. }
  879. // Try to read type 3
  880. status = TIReadVendorRequestSync (serial->serial->dev,
  881. UMPC_MEMORY_READ, // Request
  882. DTK_ADDR_SPACE_I2C_TYPE_III, // wValue (Address type)
  883. 0, // wIndex
  884. &data, // TransferBuffer
  885. 0x01); // TransferBufferLength
  886. if (status)
  887. dbg ("%s - read 3 status error = %d", __FUNCTION__, status);
  888. else
  889. dbg ("%s - read 2 data = 0x%x", __FUNCTION__, data);
  890. if ((!status) && data == 0x52) {
  891. dbg ("%s - ROM_TYPE_III", __FUNCTION__);
  892. serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
  893. return 0;
  894. }
  896. dbg ("%s - Unknown", __FUNCTION__);
  897. serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
  898. return -ENODEV;
  899. }
  901. static int TISendBulkTransferSync (struct usb_serial *serial, void *buffer, int length, int *num_sent)
  902. {
  903. int status;
  905. status = usb_bulk_msg (serial->dev,
  906. usb_sndbulkpipe(serial->dev,
  907. serial->port[0].bulk_out_endpointAddress),
  908. buffer,
  909. length,
  910. num_sent,
  911. HZ);
  912. return status;
  913. }
  915. /* Download given firmware image to the device (IN BOOT MODE) */
  916. static int TIDownloadCodeImage (struct edgeport_serial *serial, __u8 *image, int image_length)
  917. {
  918. int status = 0;
  919. int pos;
  920. int transfer;
  921. int done;
  923. // Transfer firmware image
  924. for (pos = 0; pos < image_length; ) {
  925. // Read the next buffer from file
  926. transfer = image_length - pos;
  927. if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)
  928. transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;
  930. // Transfer data
  931. status = TISendBulkTransferSync (serial->serial, &image[pos], transfer, &done);
  932. if (status)
  933. break;
  934. // Advance buffer pointer
  935. pos += done;
  936. }
  938. return status;
  939. }
  941. // FIXME!!!
  942. static int TIConfigureBootDevice (struct usb_device *dev)
  943. {
  944. return 0;
  945. }
  947. /**
  948.  * DownloadTIFirmware - Download run-time operating firmware to the TI5052
  949.  * 
  950.  * This routine downloads the main operating code into the TI5052, using the
  951.  * boot code already burned into E2PROM or ROM.
  952.  */
  953. static int TIDownloadFirmware (struct edgeport_serial *serial)
  954. {
  955. int status = 0;
  956. int start_address;
  957. struct edge_ti_manuf_descriptor *ti_manuf_desc;
  958. struct usb_interface_descriptor *interface;
  959. int download_cur_ver;
  960. int download_new_ver;
  962. /* This routine is entered by both the BOOT mode and the Download mode
  963.  * We can determine which code is running by the reading the config
  964.  * descriptor and if we have only one bulk pipe it is in boot mode
  965.  */
  966. serial->product_info.hardware_type = HARDWARE_TYPE_TIUMP;
  968. /* Default to type 2 i2c */
  969. serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
  971. status = TIChooseConfiguration (serial->serial->dev);
  972. if (status)
  973. return status;
  975. interface = serial->serial->dev->config->interface->altsetting;
  976. if (!interface) {
  977. err ("%s - no interface set, error!", __FUNCTION__);
  978. return -ENODEV;
  979. }
  981. // Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
  982. // if we have more than one endpoint we are definitely in download mode
  983. if (interface->bNumEndpoints > 1)
  984. serial->product_info.TiMode = TI_MODE_DOWNLOAD;
  985. else
  986. // Otherwise we will remain in configuring mode
  987. serial->product_info.TiMode = TI_MODE_CONFIGURING;
  989. // Save Download Version Number
  990. OperationalCodeImageVersion.MajorVersion = PagableOperationalCodeImageVersion.MajorVersion;
  991. OperationalCodeImageVersion.MinorVersion = PagableOperationalCodeImageVersion.MinorVersion;
  992. OperationalCodeImageVersion.BuildNumber  = PagableOperationalCodeImageVersion.BuildNumber;
  994. /********************************************************************/
  995. /* Download Mode */
  996. /********************************************************************/
  997. if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
  998. struct ti_i2c_desc *rom_desc;
  1000. dbg ("%s - <<<<<<<<<<<<<<<RUNNING IN DOWNLOAD MODE>>>>>>>>>>", __FUNCTION__);
  1002. status = TiValidateI2cImage (serial);
  1003. if (status) {
  1004. dbg ("%s - <<<<<<<<<<<<<<<DOWNLOAD MODE -- BAD I2C >>>>>>>>>>",
  1005.      __FUNCTION__);
  1006. return status;
  1007. }
  1009. /* Validate Hardware version number
  1010.  * Read Manufacturing Descriptor from TI Based Edgeport
  1011.  */
  1012. ti_manuf_desc = kmalloc (sizeof (*ti_manuf_desc), GFP_KERNEL);
  1013. if (!ti_manuf_desc) {
  1014. err ("%s - out of memory.", __FUNCTION__);
  1015. return -ENOMEM;
  1016. }
  1017. status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
  1018. if (status) {
  1019. kfree (ti_manuf_desc);
  1020. return status;
  1021. }
  1023. // Check version number of ION descriptor
  1024. if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
  1025. dbg ( "%s - Wrong CPU Rev %d (Must be 2)", __FUNCTION__, 
  1026.      TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
  1027. kfree (ti_manuf_desc);
  1028.     return -EINVAL;
  1029. }
  1031. rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
  1032. if (!rom_desc) {
  1033. err ("%s - out of memory.", __FUNCTION__);
  1034. kfree (ti_manuf_desc);
  1035. return -ENOMEM;
  1036. }
  1038. // Search for type 2 record (firmware record)
  1039. if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc)) != 0) {
  1040. struct ti_i2c_firmware_rec *firmware_version;
  1041. __u8 record;
  1043. dbg ("%s - Found Type FIRMWARE (Type 2) record", __FUNCTION__);
  1045. firmware_version = kmalloc (sizeof (*firmware_version), GFP_KERNEL);
  1046. if (!firmware_version) {
  1047. err ("%s - out of memory.", __FUNCTION__);
  1048. kfree (rom_desc);
  1049. kfree (ti_manuf_desc);
  1050. return -ENOMEM;
  1051. }
  1053. // Validate version number
  1054. // Read the descriptor data
  1055. status = TIReadRom (serial,
  1056. start_address+sizeof(struct ti_i2c_desc),
  1057. sizeof(struct ti_i2c_firmware_rec),
  1058. (__u8 *)firmware_version);
  1059. if (status) {
  1060. kfree (firmware_version);
  1061. kfree (rom_desc);
  1062. kfree (ti_manuf_desc);
  1063. return status;
  1064. }
  1066. // Check version number of download with current version in I2c
  1067. download_cur_ver = (firmware_version->Ver_Major << 8) + 
  1068.    (firmware_version->Ver_Minor);
  1069. download_new_ver = (OperationalCodeImageVersion.MajorVersion << 8) +
  1070.    (OperationalCodeImageVersion.MinorVersion);
  1072. dbg ("%s - >>>Firmware Versions Device %d.%d  Driver %d.%d",
  1073.      __FUNCTION__,
  1074.      firmware_version->Ver_Major,
  1075.      firmware_version->Ver_Minor,
  1076.      OperationalCodeImageVersion.MajorVersion,
  1077.      OperationalCodeImageVersion.MinorVersion);
  1079. // Check if we have an old version in the I2C and update if necessary
  1080. if (download_cur_ver != download_new_ver) {
  1081. dbg ("%s - Update I2C Download from %d.%d to %d.%d",
  1082.      __FUNCTION__,
  1083.      firmware_version->Ver_Major,
  1084.      firmware_version->Ver_Minor,
  1085.      OperationalCodeImageVersion.MajorVersion,
  1086.      OperationalCodeImageVersion.MinorVersion);
  1088. // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
  1089. // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
  1090. // will download the latest firmware (padded to 15.5k) into the UMP ram. 
  1091. // And finally when the device comes back up in download mode the driver will cause 
  1092. // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
  1093. // the record type from 0xf2 to 0x02.
  1095. record = I2C_DESC_TYPE_FIRMWARE_BLANK;
  1097. // Change the I2C Firmware record type to 0xf2 to trigger an update
  1098. status = TIWriteRom (serial,
  1099. start_address,
  1100. sizeof(record),
  1101. &record);
  1102. if (status) {
  1103. kfree (firmware_version);
  1104. kfree (rom_desc);
  1105. kfree (ti_manuf_desc);
  1106. return status;
  1107. }
  1109. // verify the write -- must do this in order for write to 
  1110. // complete before we do the hardware reset
  1111. status = TIReadRom (serial,
  1112. start_address,
  1113. sizeof(record),
  1114. &record);
  1116. if (status) {
  1117. kfree (firmware_version);
  1118. kfree (rom_desc);
  1119. kfree (ti_manuf_desc);
  1120. return status;
  1121. }
  1123. if (record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
  1124. err ("%s - error resetting device", __FUNCTION__);
  1125. kfree (firmware_version);
  1126. kfree (rom_desc);
  1127. kfree (ti_manuf_desc);
  1128. return -ENODEV;
  1129. }
  1131. dbg ("%s - HARDWARE RESET", __FUNCTION__);
  1133. // Reset UMP -- Back to BOOT MODE
  1134. status = TISendVendorRequestSync (serial->serial->dev,
  1135. UMPC_HARDWARE_RESET, // Request
  1136. 0, // wValue
  1137. 0, // wIndex
  1138. NULL, // TransferBuffer
  1139. 0); // TransferBufferLength
  1141. dbg ( "%s - HARDWARE RESET return %d", __FUNCTION__, status);
  1143. /* return an error on purpose. */
  1144. return -ENODEV;
  1145. }
  1146. }
  1147. // Search for type 0xF2 record (firmware blank record)
  1148. else if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
  1149. #define HEADER_SIZE (sizeof(struct ti_i2c_desc) + sizeof(struct ti_i2c_firmware_rec))
  1150. __u8 *header;
  1151. __u8 *vheader;
  1153. header  = kmalloc (HEADER_SIZE, GFP_KERNEL);
  1154. if (!header) {
  1155. err ("%s - out of memory.", __FUNCTION__);
  1156. kfree (rom_desc);
  1157. kfree (ti_manuf_desc);
  1158. return -ENOMEM;
  1159. }
  1161. vheader = kmalloc (HEADER_SIZE, GFP_KERNEL);
  1162. if (!vheader) {
  1163. err ("%s - out of memory.", __FUNCTION__);
  1164. kfree (header);
  1165. kfree (rom_desc);
  1166. kfree (ti_manuf_desc);
  1167. return -ENOMEM;
  1168. }
  1170. dbg ("%s - Found Type BLANK FIRMWARE (Type F2) record", __FUNCTION__);
  1172. // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
  1173. // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
  1174. // will download the latest firmware (padded to 15.5k) into the UMP ram. 
  1175. // And finally when the device comes back up in download mode the driver will cause 
  1176. // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
  1177. // the record type from 0xf2 to 0x02.
  1178. status = BuildI2CFirmwareHeader(header);
  1179. if (status) {
  1180. kfree (vheader);
  1181. kfree (header);
  1182. kfree (rom_desc);
  1183. kfree (ti_manuf_desc);
  1184. return status;
  1185. }
  1187. // Update I2C with type 0xf2 record with correct size and checksum
  1188. status = TIWriteRom (serial,
  1189. start_address,
  1190. HEADER_SIZE,
  1191. header);
  1192. if (status) {
  1193. kfree (vheader);
  1194. kfree (header);
  1195. kfree (rom_desc);
  1196. kfree (ti_manuf_desc);
  1197. return status;
  1198. }
  1200. // verify the write -- must do this in order for write to 
  1201. // complete before we do the hardware reset
  1202. status = TIReadRom (serial,
  1203. start_address,
  1204. HEADER_SIZE,
  1205. vheader);
  1207. if (status) {
  1208. dbg ("%s - can't read header back", __FUNCTION__);
  1209. kfree (vheader);
  1210. kfree (header);
  1211. kfree (rom_desc);
  1212. kfree (ti_manuf_desc);
  1213. return status;
  1214. }
  1215. if (memcmp(vheader, header, HEADER_SIZE)) {
  1216. dbg ("%s - write download record failed", __FUNCTION__);
  1217. kfree (vheader);
  1218. kfree (header);
  1219. kfree (rom_desc);
  1220. kfree (ti_manuf_desc);
  1221. return status;
  1222. }
  1224. kfree (vheader);
  1225. kfree (header);
  1227. dbg ("%s - Start firmware update", __FUNCTION__);
  1229. // Tell firmware to copy download image into I2C 
  1230. status = TISendVendorRequestSync (serial->serial->dev,
  1231. UMPC_COPY_DNLD_TO_I2C, // Request
  1232. 0, // wValue 
  1233. 0, // wIndex
  1234. NULL, // TransferBuffer
  1235. 0); // TransferBufferLength
  1237.    dbg ("%s - Update complete 0x%x", __FUNCTION__, status);
  1238. if (status) {
  1239. dbg ("%s - UMPC_COPY_DNLD_TO_I2C failed", __FUNCTION__);
  1240. kfree (rom_desc);
  1241. kfree (ti_manuf_desc);
  1242. return status;
  1243. }
  1244. }
  1246. // The device is running the download code
  1247. kfree (rom_desc);
  1248. kfree (ti_manuf_desc);
  1249. return 0;
  1250. }
  1252. /********************************************************************/
  1253. /* Boot Mode */
  1254. /********************************************************************/
  1255. dbg ("%s - <<<<<<<<<<<<<<<RUNNING IN BOOT MODE>>>>>>>>>>>>>>>",
  1256.      __FUNCTION__);
  1258. // Configure the TI device so we can use the BULK pipes for download
  1259. status = TIConfigureBootDevice (serial->serial->dev);
  1260. if (status)
  1261. return status;
  1263. if (serial->serial->dev->descriptor.idVendor != USB_VENDOR_ID_ION) {
  1264. dbg ("%s - VID = 0x%x", __FUNCTION__,
  1265.      serial->serial->dev->descriptor.idVendor);
  1266. serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
  1267. goto StayInBootMode;
  1268. }
  1270. // We have an ION device (I2c Must be programmed)
  1271. // Determine I2C image type
  1272. if (TIGetI2cTypeInBootMode(serial)) {
  1273. goto StayInBootMode;
  1274. }
  1276. // Registry variable set?
  1277. if (TIStayInBootMode) {
  1278. dbg ("%s - TIStayInBootMode", __FUNCTION__);
  1279. goto StayInBootMode;
  1280. }
  1282. // Check for ION Vendor ID and that the I2C is valid
  1283. if (!TiValidateI2cImage(serial)) {
  1284. struct ti_i2c_image_header *header;
  1285. int i;
  1286. __u8 cs = 0;
  1287. __u8 *buffer;
  1288. int buffer_size;
  1290. /* Validate Hardware version number
  1291.  * Read Manufacturing Descriptor from TI Based Edgeport
  1292.  */
  1293. ti_manuf_desc = kmalloc (sizeof (*ti_manuf_desc), GFP_KERNEL);
  1294. if (!ti_manuf_desc) {
  1295. err ("%s - out of memory.", __FUNCTION__);
  1296. return -ENOMEM;
  1297. }
  1298. status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
  1299. if (status) {
  1300. kfree (ti_manuf_desc);
  1301. goto StayInBootMode;
  1302. }
  1304. // Check for version 2
  1305. if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
  1306. dbg ("%s - Wrong CPU Rev %d (Must be 2)", __FUNCTION__,
  1307.      TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
  1308. kfree (ti_manuf_desc);
  1309. goto StayInBootMode;
  1310. }
  1312. kfree (ti_manuf_desc);
  1314. // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
  1315. // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
  1316. // will download the latest firmware (padded to 15.5k) into the UMP ram. 
  1317. // And finally when the device comes back up in download mode the driver will cause 
  1318. // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
  1319. // the record type from 0xf2 to 0x02.
  1321. /*
  1322.  * Do we really have to copy the whole firmware image,
  1323.  * or could we do this in place!
  1324.  */
  1326. // Allocate a 15.5k buffer + 3 byte header
  1327. buffer_size = (((1024 * 16) - 512) + sizeof(struct ti_i2c_image_header));
  1328. buffer = kmalloc (buffer_size, GFP_KERNEL);
  1329. if (!buffer) {
  1330. err ("%s - out of memory", __FUNCTION__);
  1331. return -ENOMEM;
  1332. }
  1334. // Initialize the buffer to 0xff (pad the buffer)
  1335. memset (buffer, 0xff, buffer_size);
  1337. memcpy (buffer, &PagableOperationalCodeImage[0], PagableOperationalCodeSize);
  1339. for(i = sizeof(struct ti_i2c_image_header); i < buffer_size; i++) {
  1340. cs = (__u8)(cs + buffer[i]);
  1341. }
  1343. header = (struct ti_i2c_image_header *)buffer;
  1345. // update length and checksum after padding
  1346. header->Length   = (__u16)(buffer_size - sizeof(struct ti_i2c_image_header));
  1347. header->CheckSum = cs;
  1349. // Download the operational code 
  1350. dbg ("%s - Downloading operational code image (TI UMP)", __FUNCTION__);
  1351. status = TIDownloadCodeImage (serial, buffer, buffer_size);
  1353. kfree (buffer);
  1355. if (status) {
  1356.    dbg ("%s - Error downloading operational code image", __FUNCTION__);
  1357. return status;
  1358. }
  1360. // Device will reboot
  1361. serial->product_info.TiMode = TI_MODE_TRANSITIONING;
  1363.    dbg ("%s - Download successful -- Device rebooting...", __FUNCTION__);
  1365. /* return an error on purpose */
  1366. return -ENODEV;
  1367. }
  1369. StayInBootMode:
  1370. // Eprom is invalid or blank stay in boot mode
  1371. dbg ("%s - <<<<<<<<<<<<<<<STAYING IN BOOT MODE>>>>>>>>>>>>", __FUNCTION__);
  1372. serial->product_info.TiMode = TI_MODE_BOOT;
  1374. return 0;
  1375. }
  1378. static int TISetDtr (struct edgeport_port *port)
  1379. {
  1380. int port_number = port->port->number - port->port->serial->minor;
  1382. dbg ("%s", __FUNCTION__);
  1383. port->shadow_mcr |= MCR_DTR;
  1385. return TIWriteCommandSync (port->port->serial->dev,
  1386. UMPC_SET_CLR_DTR,
  1387. (__u8)(UMPM_UART1_PORT + port_number),
  1388. 1, /* set */
  1389. NULL,
  1390. 0);
  1391. }
  1393. static int TIClearDtr (struct edgeport_port *port)
  1394. {
  1395. int port_number = port->port->number - port->port->serial->minor;
  1397. dbg ("%s", __FUNCTION__);
  1398. port->shadow_mcr &= ~MCR_DTR;
  1400. return TIWriteCommandSync (port->port->serial->dev,
  1401. UMPC_SET_CLR_DTR,
  1402. (__u8)(UMPM_UART1_PORT + port_number),
  1403. 0, /* clear */
  1404. NULL,
  1405. 0);
  1406. }
  1408. static int TISetRts (struct edgeport_port *port)
  1409. {
  1410. int port_number = port->port->number - port->port->serial->minor;
  1412. dbg ("%s", __FUNCTION__);
  1413. port->shadow_mcr |= MCR_RTS;
  1415. return TIWriteCommandSync (port->port->serial->dev,
  1416. UMPC_SET_CLR_RTS,
  1417. (__u8)(UMPM_UART1_PORT + port_number),
  1418. 1, /* set */
  1419. NULL,
  1420. 0);
  1421. }
  1423. static int TIClearRts (struct edgeport_port *port)
  1424. {
  1425. int port_number = port->port->number - port->port->serial->minor;
  1427. dbg ("%s", __FUNCTION__);
  1428. port->shadow_mcr &= ~MCR_RTS;
  1430. return TIWriteCommandSync (port->port->serial->dev,
  1431. UMPC_SET_CLR_RTS,
  1432. (__u8)(UMPM_UART1_PORT + port_number),
  1433. 0, /* clear */
  1434. NULL,
  1435. 0);
  1436. }
  1438. static int TISetLoopBack (struct edgeport_port *port)
  1439. {
  1440. int port_number = port->port->number - port->port->serial->minor;
  1442. dbg ("%s", __FUNCTION__);
  1444. return TIWriteCommandSync (port->port->serial->dev,
  1445. UMPC_SET_CLR_LOOPBACK,
  1446. (__u8)(UMPM_UART1_PORT + port_number),
  1447. 1, /* set */
  1448. NULL,
  1449. 0);
  1450. }
  1452. static int TIClearLoopBack (struct edgeport_port *port)
  1453. {
  1454. int port_number = port->port->number - port->port->serial->minor;
  1456. dbg ("%s", __FUNCTION__);
  1458. return TIWriteCommandSync (port->port->serial->dev,
  1459. UMPC_SET_CLR_LOOPBACK,
  1460. (__u8)(UMPM_UART1_PORT + port_number),
  1461. 0, /* clear */
  1462. NULL,
  1463. 0);
  1464. }
  1466. static int TISetBreak (struct edgeport_port *port)
  1467. {
  1468. int port_number = port->port->number - port->port->serial->minor;
  1470. dbg ("%s", __FUNCTION__);
  1472. return TIWriteCommandSync (port->port->serial->dev,
  1473. UMPC_SET_CLR_BREAK,
  1474. (__u8)(UMPM_UART1_PORT + port_number),
  1475. 1, /* set */
  1476. NULL,
  1477. 0);
  1478. }
  1480. static int TIClearBreak (struct edgeport_port *port)
  1481. {
  1482. int port_number = port->port->number - port->port->serial->minor;
  1484. dbg ("%s", __FUNCTION__);
  1486. return TIWriteCommandSync (port->port->serial->dev,
  1487. UMPC_SET_CLR_BREAK,
  1488. (__u8)(UMPM_UART1_PORT + port_number),
  1489. 0, /* clear */
  1490. NULL,
  1491. 0);
  1492. }
  1494. static int TIRestoreMCR (struct edgeport_port *port, __u8 mcr)
  1495. {
  1496. int status = 0;
  1498. dbg ("%s - %x", __FUNCTION__, mcr);
  1500. if (mcr & MCR_DTR)
  1501. status = TISetDtr (port);
  1502. else
  1503. status = TIClearDtr (port);
  1505. if (status)
  1506. return status;
  1508. if (mcr & MCR_RTS)
  1509. status = TISetRts (port);
  1510. else
  1511. status = TIClearRts (port);
  1513. if (status)
  1514. return status;
  1516. if (mcr & MCR_LOOPBACK)
  1517. status = TISetLoopBack (port);
  1518. else
  1519. status = TIClearLoopBack (port);
  1521. return status;
  1522. }
  1526. /* Convert TI LSR to standard UART flags */
  1527. static __u8 MapLineStatus (__u8 ti_lsr)
  1528. {
  1529. __u8 lsr = 0;
  1531. #define MAP_FLAG(flagUmp, flagUart)    
  1532. if (ti_lsr & flagUmp) lsr |= flagUart;
  1534. MAP_FLAG(UMP_UART_LSR_OV_MASK, LSR_OVER_ERR) /* overrun */
  1535. MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR) /* parity error */
  1536. MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR) /* framing error */
  1537. MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK) /* break detected */
  1538. MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL) /* receive data available */
  1539. MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY) /* transmit holding register empty */
  1541. #undef MAP_FLAG
  1543. return lsr;
  1544. }
  1546. static void handle_new_msr (struct edgeport_port *edge_port, __u8 msr)
  1547. {
  1548. struct async_icount *icount;
  1550. dbg ("%s - %02x", __FUNCTION__, msr);
  1552. if (msr & (MSR_DELTA_CTS | MSR_DELTA_DSR | MSR_DELTA_RI | MSR_DELTA_CD)) {
  1553. icount = &edge_port->icount;
  1555. /* update input line counters */
  1556. if (msr & MSR_DELTA_CTS)
  1557. icount->cts++;
  1558. if (msr & MSR_DELTA_DSR)
  1559. icount->dsr++;
  1560. if (msr & MSR_DELTA_CD)
  1561. icount->dcd++;
  1562. if (msr & MSR_DELTA_RI)
  1563. icount->rng++;
  1564. wake_up_interruptible (&edge_port->delta_msr_wait);
  1565. }
  1567. /* Save the new modem status */
  1568. edge_port->shadow_msr = msr & 0xf0;
  1570. return;
  1571. }
  1573. static void handle_new_lsr (struct edgeport_port *edge_port, int lsr_data, __u8 lsr, __u8 data)
  1574. {
  1575. struct async_icount *icount;
  1576. __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
  1578. dbg ("%s - %02x", __FUNCTION__, new_lsr);
  1580. edge_port->shadow_lsr = lsr;
  1582. if (new_lsr & LSR_BREAK) {
  1583. /*
  1584.  * Parity and Framing errors only count if they
  1585.  * occur exclusive of a break being received.
  1586.  */
  1587. new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
  1588. }
  1590. /* Place LSR data byte into Rx buffer */
  1591. if (lsr_data && edge_port->port->tty) {
  1592. tty_insert_flip_char(edge_port->port->tty, data, 0);
  1593. tty_flip_buffer_push(edge_port->port->tty);
  1594. }
  1596. /* update input line counters */
  1597. icount = &edge_port->icount;
  1598. if (new_lsr & LSR_BREAK)
  1599. icount->brk++;
  1600. if (new_lsr & LSR_OVER_ERR)
  1601. icount->overrun++;
  1602. if (new_lsr & LSR_PAR_ERR)
  1603. icount->parity++;
  1604. if (new_lsr & LSR_FRM_ERR)
  1605. icount->frame++;
  1606. }
  1609. static void edge_interrupt_callback (struct urb *urb)
  1610. {
  1611. struct edgeport_serial *edge_serial = (struct edgeport_serial *)urb->context;
  1612. struct usb_serial_port *port;
  1613. struct edgeport_port *edge_port;
  1614. unsigned char *data = urb->transfer_buffer;
  1615. int length = urb->actual_length;
  1616. int port_number;
  1617. int function;
  1618. __u8 lsr;
  1619. __u8 msr;
  1621. dbg("%s", __FUNCTION__);
  1623. if (serial_paranoia_check (edge_serial->serial, __FUNCTION__)) {
  1624. return;
  1625. }
  1627. if (urb->status) {
  1628. dbg("%s - nonzero control read status received: %d", __FUNCTION__, urb->status);
  1629. return;
  1630. }
  1632. if (!length) {
  1633. dbg ("%s - no data in urb", __FUNCTION__);
  1634. return;
  1635. }
  1637. usb_serial_debug_data (__FILE__, __FUNCTION__, length, data);
  1639. if (length != 2) {
  1640. dbg ("%s - expecting packet of size 2, got %d", __FUNCTION__, length);
  1641. return;
  1642. }
  1644. port_number = TIUMP_GET_PORT_FROM_CODE (data[0]);
  1645. function    = TIUMP_GET_FUNC_FROM_CODE (data[0]);
  1646. dbg ("%s - port_number %d, function %d, info 0x%x",
  1647.      __FUNCTION__, port_number, function, data[1]);
  1648. port = &edge_serial->serial->port[port_number];
  1649. if (port_paranoia_check (port, __FUNCTION__)) {
  1650. dbg ("%s - change found for port that is not present",
  1651.      __FUNCTION__);
  1652. return;
  1653. }
  1654. edge_port = port->private;
  1655. if (!edge_port) {
  1656. dbg ("%s - edge_port not found", __FUNCTION__);
  1657. return;
  1658. }
  1659. switch (function) {
  1660. case TIUMP_INTERRUPT_CODE_LSR:
  1661. lsr = MapLineStatus(data[1]);
  1662. if (lsr & UMP_UART_LSR_DATA_MASK) {
  1663. /* Save the LSR event for bulk read completion routine */
  1664. dbg ("%s - LSR Event Port %u LSR Status = %02x",
  1665.      __FUNCTION__, port_number, lsr);
  1666. edge_port->lsr_event = 1;
  1667. edge_port->lsr_mask = lsr;
  1668. } else {
  1669. dbg ("%s - ===== Port %d LSR Status = %02x ======",
  1670.      __FUNCTION__, port_number, lsr);
  1671. handle_new_lsr (edge_port, 0, lsr, 0);
  1672. }
  1673. break;
  1675. case TIUMP_INTERRUPT_CODE_MSR: // MSR
  1676. /* Copy MSR from UMP */
  1677. msr = data[1];
  1678. dbg ("%s - ===== Port %u MSR Status = %02x ======n",
  1679.      __FUNCTION__, port_number, msr);
  1680. handle_new_msr (edge_port, msr);
  1681. break;
  1683. default:
  1684. err ("%s - Unknown Interrupt code from UMP %xn",
  1685.      __FUNCTION__, data[1]);
  1686. break;
  1688. }
  1689. }
  1691. static void edge_bulk_in_callback (struct urb *urb)
  1692. {
  1693. struct edgeport_port *edge_port = (struct edgeport_port *)urb->context;
  1694. unsigned char *data = urb->transfer_buffer;
  1695. struct tty_struct *tty;
  1696. int status;
  1697. int i;
  1698. int port_number;
  1700. dbg("%s", __FUNCTION__);
  1702. if (port_paranoia_check (edge_port->port, __FUNCTION__))
  1703. return;
  1705. if (urb->status) {
  1706. dbg ("%s - nonzero read bulk status received: %d",
  1707.      __FUNCTION__, urb->status);
  1709. if (urb->status == -EPIPE) {
  1710. /* clear any problem that might have happened on this pipe */
  1711. usb_clear_halt (edge_port->port->serial->dev, urb->pipe);
  1712. goto exit;
  1713. }
  1714. return;
  1715. }
  1717. port_number = edge_port->port->number - edge_port->port->serial->minor;
  1719. if (edge_port->lsr_event) {
  1720. edge_port->lsr_event = 0;
  1721. dbg ("%s ===== Port %u LSR Status = %02x, Data = %02x ======",
  1722.      __FUNCTION__, port_number, edge_port->lsr_mask, *data);
  1723. handle_new_lsr (edge_port, 1, edge_port->lsr_mask, *data);
  1724. /* Adjust buffer length/pointer */
  1725. --urb->actual_length;
  1726. ++data;
  1727. }
  1729. tty = edge_port->port->tty;
  1730. if (tty && urb->actual_length) {
  1731. usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
  1733. if (edge_port->close_pending) {
  1734. dbg ("%s - close is pending, dropping data on the floor.", __FUNCTION__);
  1735. } else {
  1736. for (i = 0; i < urb->actual_length ; ++i) {
  1737. /* if we insert more than TTY_FLIPBUF_SIZE characters,
  1738.  * we drop them. */
  1739. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  1740. tty_flip_buffer_push(tty);
  1741. }
  1742. /* this doesn't actually push the data through unless
  1743.  * tty->low_latency is set */
  1744. tty_insert_flip_char(tty, data[i], 0);
  1745. }
  1746. tty_flip_buffer_push(tty);
  1747. }
  1748. edge_port->icount.rx += urb->actual_length;
  1749. }
  1751. exit:
  1752. /* continue always trying to read */
  1753. urb->dev = edge_port->port->serial->dev;
  1754. status = usb_submit_urb (urb);
  1755. if (status)
  1756. err ("%s - usb_submit_urb failed with result %d",
  1757.      __FUNCTION__, status);
  1758. }
  1760. static void edge_bulk_out_callback (struct urb *urb)
  1761. {
  1762. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  1763. struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
  1764. struct tty_struct *tty;
  1766. dbg ("%s - port %d", __FUNCTION__, port->number);
  1768. if (!serial) {
  1769. dbg ("%s - bad serial pointer, exiting", __FUNCTION__);
  1770. return;
  1771. }
  1773. if (urb->status) {
  1774. dbg ("%s - nonzero write bulk status received: %d",
  1775.      __FUNCTION__, urb->status);
  1777. if (urb->status == -EPIPE) {
  1778. /* clear any problem that might have happened on this pipe */
  1779. usb_clear_halt (serial->dev, urb->pipe);
  1780. }
  1781. return;
  1782. }
  1784. tty = port->tty;
  1785. if (tty) {
  1786. /* let the tty driver wakeup if it has a special write_wakeup function */
  1787. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
  1788. (tty->ldisc.write_wakeup)(tty);
  1789. }
  1791. /* tell the tty driver that something has changed */
  1792. wake_up_interruptible(&tty->write_wait);
  1793. }
  1794. }
  1796. static int edge_open (struct usb_serial_port *port, struct file * filp)
  1797. {
  1798. struct edgeport_port *edge_port = (struct edgeport_port *)port->private;
  1799. struct edgeport_serial *edge_serial;
  1800. struct usb_device *dev;
  1801. struct urb *urb;
  1802. int port_number;
  1803. int status;
  1804. u16 open_settings;
  1805. u8 transaction_timeout;
  1807. if (port_paranoia_check (port, __FUNCTION__))
  1808. return -ENODEV;
  1810. dbg("%s - port %d", __FUNCTION__, port->number);
  1812. if (edge_port == NULL)
  1813. return -ENODEV;
  1815. /* force low_latency on so that our tty_push actually forces the data through, 
  1816.    otherwise it is scheduled, and with high data rates (like with OHCI) data
  1817.    can get lost. */
  1818. if (port->tty)
  1819. port->tty->low_latency = 1;
  1821. port_number = port->number - port->serial->minor;
  1822. switch (port_number) {
  1823. case 0:
  1824. edge_port->uart_base = UMPMEM_BASE_UART1;
  1825. edge_port->dma_address = UMPD_OEDB1_ADDRESS;
  1826. break;
  1827. case 1:
  1828. edge_port->uart_base = UMPMEM_BASE_UART2;
  1829. edge_port->dma_address = UMPD_OEDB2_ADDRESS;
  1830. break;
  1831. default:
  1832. err ("Unknown port number!!!");
  1833. return -ENODEV;
  1834. }
  1836. dbg ("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
  1837.      __FUNCTION__, port_number, edge_port->uart_base, edge_port->dma_address);
  1839. dev = port->serial->dev;
  1841. memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
  1842. init_waitqueue_head (&edge_port->delta_msr_wait);
  1844. /* turn off loopback */
  1845. status = TIClearLoopBack (edge_port);
  1846. if (status)
  1847. return status;
  1849. /* set up the port settings */
  1850. edge_set_termios (port, NULL);
  1852. /* open up the port */
  1854. /* milliseconds to timeout for DMA transfer */
  1855. transaction_timeout = 2;
  1857. edge_port->ump_read_timeout = max (20, ((transaction_timeout * 3) / 2) );
  1859. // milliseconds to timeout for DMA transfer
  1860. open_settings = (u8)(UMP_DMA_MODE_CONTINOUS | 
  1861.      UMP_PIPE_TRANS_TIMEOUT_ENA | 
  1862.      (transaction_timeout << 2));
  1864. dbg ("%s - Sending UMPC_OPEN_PORT", __FUNCTION__);
  1866. /* Tell TI to open and start the port */
  1867. status = TIWriteCommandSync (dev,
  1868. UMPC_OPEN_PORT,
  1869. (u8)(UMPM_UART1_PORT + port_number),
  1870. open_settings,
  1871. NULL,
  1872. 0);
  1873. if (status)
  1874. return status;
  1876. /* Start the DMA? */
  1877. status = TIWriteCommandSync (dev,
  1878. UMPC_START_PORT,
  1879. (u8)(UMPM_UART1_PORT + port_number),
  1880. 0,
  1881. NULL,
  1882. 0);
  1883. if (status)
  1884. return status;
  1886. /* Clear TX and RX buffers in UMP */
  1887. status = TIPurgeDataSync (port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
  1888. if (status)
  1889. return status;
  1891. /* Read Initial MSR */
  1892. status = TIReadVendorRequestSync (dev,
  1893. UMPC_READ_MSR, // Request
  1894. 0, // wValue
  1895. (__u16)(UMPM_UART1_PORT + port_number), // wIndex (Address)
  1896. &edge_port->shadow_msr, // TransferBuffer
  1897. 1); // TransferBufferLength
  1898. if (status)
  1899. return status;
  1901. dbg ("ShadowMSR 0x%X", edge_port->shadow_msr);
  1902.  
  1903. edge_serial = edge_port->edge_serial;
  1904. if (edge_serial->num_ports_open == 0) {
  1905. dbg ("%s - setting up bulk in urb", __FUNCTION__);
  1906. /* we are the first port to be opened, let's post the interrupt urb */
  1907. urb = edge_serial->serial->port[0].interrupt_in_urb;
  1908. if (!urb) {
  1909. err ("%s - no interrupt urb present, exiting", __FUNCTION__);
  1910. return -EINVAL;
  1911. }
  1912. urb->complete = edge_interrupt_callback;
  1913. urb->context = edge_serial;
  1914. urb->dev = dev;
  1915. status = usb_submit_urb (urb);
  1916. if (status) {
  1917. err ("%s - usb_submit_urb failed with value %d", __FUNCTION__, status);
  1918. return status;
  1919. }
  1920. }
  1922. /*
  1923.  * reset the data toggle on the bulk endpoints to work around bug in
  1924.  * host controllers where things get out of sync some times
  1925.  */
  1926. usb_clear_halt (dev, port->write_urb->pipe);
  1927. usb_clear_halt (dev, port->read_urb->pipe);
  1929. /* start up our bulk read urb */
  1930. urb = port->read_urb;
  1931. if (!urb) {
  1932. err ("%s - no read urb present, exiting", __FUNCTION__);
  1933. return -EINVAL;
  1934. }
  1935. urb->complete = edge_bulk_in_callback;
  1936. urb->context = edge_port;
  1937. urb->dev = dev;
  1938. status = usb_submit_urb (urb);
  1939. if (status) {
  1940. err ("%s - read bulk usb_submit_urb failed with value %d", __FUNCTION__, status);
  1941. return status;
  1942. }
  1944. ++edge_serial->num_ports_open;
  1946. dbg("%s - exited", __FUNCTION__);
  1948. return 0;
  1949. }
  1951. static void edge_close (struct usb_serial_port *port, struct file * filp)
  1952. {
  1953. struct usb_serial *serial;
  1954. struct edgeport_serial *edge_serial;
  1955. struct edgeport_port *edge_port;
  1956. int port_number;
  1957. int status;
  1959. if (port_paranoia_check (port, __FUNCTION__))
  1960. return;
  1962. dbg("%s - port %d", __FUNCTION__, port->number);
  1963.  
  1964. serial = get_usb_serial (port, __FUNCTION__);
  1965. if (!serial)
  1966. return;
  1968. edge_serial = (struct edgeport_serial *)serial->private;
  1969. edge_port = (struct edgeport_port *)port->private;
  1970. if ((edge_serial == NULL) || (edge_port == NULL))
  1971. return;
  1973. if (serial->dev) {
  1974. /* The bulkreadcompletion routine will check 
  1975.  * this flag and dump add read data */
  1976. edge_port->close_pending = 1;
  1978. /* chase the port close */
  1979. TIChasePort (edge_port);
  1981. usb_unlink_urb (port->read_urb);
  1983. /* assuming we can still talk to the device,
  1984.  * send a close port command to it */
  1985. dbg("%s - send umpc_close_port", __FUNCTION__);
  1986. port_number = port->number - port->serial->minor;
  1987. status = TIWriteCommandSync (port->serial->dev,
  1988.      UMPC_CLOSE_PORT,
  1989.      (__u8)(UMPM_UART1_PORT + port_number),
  1990.      0,
  1991.      NULL,
  1992.      0);
  1993. --edge_port->edge_serial->num_ports_open;
  1994. if (edge_port->edge_serial->num_ports_open <= 0) {
  1995. /* last port is now closed, let's shut down our interrupt urb */
  1996. usb_unlink_urb (serial->port[0].interrupt_in_urb);
  1997. edge_port->edge_serial->num_ports_open = 0;
  1998. }
  1999. edge_port->close_pending = 0;
  2000. }
  2002. dbg("%s - exited", __FUNCTION__);
  2003. }
  2005. static int edge_write (struct usb_serial_port *port, int from_user, const unsigned char *data, int count)
  2006. {
  2007. struct usb_serial *serial = port->serial;
  2008. struct edgeport_port *edge_port = port->private;
  2009. int result;
  2011. dbg("%s - port %d", __FUNCTION__, port->number);
  2013. if (count == 0) {
  2014. dbg("%s - write request of 0 bytes", __FUNCTION__);
  2015. return 0;
  2016. }
  2018. if (edge_port == NULL)
  2019. return -ENODEV;
  2020. if (edge_port->close_pending == 1)
  2021. return -ENODEV;
  2023. if (port->write_urb->status == -EINPROGRESS) {
  2024. dbg ("%s - already writing", __FUNCTION__);
  2025. return 0;
  2026. }
  2028. count = min (count, port->bulk_out_size);
  2030. if (from_user) {
  2031. if (copy_from_user(port->write_urb->transfer_buffer, data, count))
  2032. return -EFAULT;
  2033. } else {
  2034. memcpy (port->write_urb->transfer_buffer, data, count);
  2035. }
  2037. usb_serial_debug_data (__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer);
  2039. /* set up our urb */
  2040. usb_fill_bulk_urb (port->write_urb, serial->dev,
  2041.    usb_sndbulkpipe (serial->dev,
  2042.     port->bulk_out_endpointAddress),
  2043.    port->write_urb->transfer_buffer, count,
  2044.    edge_bulk_out_callback,
  2045.    port);
  2047. /* send the data out the bulk port */
  2048. result = usb_submit_urb(port->write_urb);
  2049. if (result)
  2050. err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
  2051. else
  2052. result = count;
  2054. if (result > 0)
  2055. edge_port->icount.tx += count;
  2057. return result;
  2058. }
  2060. static int edge_write_room (struct usb_serial_port *port)
  2061. {
  2062. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2063. int room = 0;
  2065. dbg("%s", __FUNCTION__);
  2067. if (edge_port == NULL)
  2068. return -ENODEV;
  2069. if (edge_port->close_pending == 1)
  2070. return -ENODEV;
  2072. dbg("%s - port %d", __FUNCTION__, port->number);
  2074. if (port->write_urb->status != -EINPROGRESS)
  2075. room = port->bulk_out_size;
  2077. dbg("%s - returns %d", __FUNCTION__, room);
  2078. return room;
  2079. }
  2081. static int edge_chars_in_buffer (struct usb_serial_port *port)
  2082. {
  2083. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2084. int chars = 0;
  2086. dbg("%s", __FUNCTION__);
  2088. if (edge_port == NULL)
  2089. return -ENODEV;
  2090. if (edge_port->close_pending == 1)
  2091. return -ENODEV;
  2093. dbg("%s - port %d", __FUNCTION__, port->number);
  2095. if (port->write_urb->status == -EINPROGRESS)
  2096. chars = port->write_urb->transfer_buffer_length;
  2098. dbg ("%s - returns %d", __FUNCTION__, chars);
  2099. return chars;
  2100. }
  2102. static void edge_throttle (struct usb_serial_port *port)
  2103. {
  2104. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2105. struct tty_struct *tty;
  2106. int status;
  2108. dbg("%s - port %d", __FUNCTION__, port->number);
  2110. if (edge_port == NULL)
  2111. return;
  2113. tty = port->tty;
  2114. if (!tty) {
  2115. dbg ("%s - no tty available", __FUNCTION__);
  2116. return;
  2117. }
  2118. /* if we are implementing XON/XOFF, send the stop character */
  2119. if (I_IXOFF(tty)) {
  2120. unsigned char stop_char = STOP_CHAR(tty);
  2121. status = edge_write (port, 0, &stop_char, 1);
  2122. if (status <= 0) {
  2123. return;
  2124. }
  2125. }
  2127. /* if we are implementing RTS/CTS, toggle that line */
  2128. if (tty->termios->c_cflag & CRTSCTS) {
  2129. status = TIClearRts (edge_port);
  2130. }
  2132. usb_unlink_urb (port->read_urb);
  2133. }
  2135. static void edge_unthrottle (struct usb_serial_port *port)
  2136. {
  2137. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2138. struct tty_struct *tty;
  2139. int status;
  2141. dbg("%s - port %d", __FUNCTION__, port->number);
  2143. if (edge_port == NULL)
  2144. return;
  2146. tty = port->tty;
  2147. if (!tty) {
  2148. dbg ("%s - no tty available", __FUNCTION__);
  2149. return;
  2150. }
  2152. /* if we are implementing XON/XOFF, send the start character */
  2153. if (I_IXOFF(tty)) {
  2154. unsigned char start_char = START_CHAR(tty);
  2155. status = edge_write (port, 0, &start_char, 1);
  2156. if (status <= 0) {
  2157. return;
  2158. }
  2159. }
  2161. /* if we are implementing RTS/CTS, toggle that line */
  2162. if (tty->termios->c_cflag & CRTSCTS) {
  2163. status = TISetRts (edge_port);
  2164. }
  2166. port->read_urb->dev = port->serial->dev;
  2167. status = usb_submit_urb (port->read_urb);
  2168. if (status) {
  2169. err ("%s - usb_submit_urb failed with value %d", __FUNCTION__, status);
  2170. }
  2171. }
  2174. static void change_port_settings (struct edgeport_port *edge_port, struct termios *old_termios)
  2175. {
  2176. struct ump_uart_config *config;
  2177. struct tty_struct *tty;
  2178. int baud;
  2179. int round;
  2180. unsigned cflag;
  2181. int status;
  2182. int port_number = edge_port->port->number - edge_port->port->serial->minor;
  2184. dbg("%s - port %d", __FUNCTION__, edge_port->port->number);
  2186. tty = edge_port->port->tty;
  2187. if ((!tty) ||
  2188.     (!tty->termios)) {
  2189. dbg("%s - no tty structures", __FUNCTION__);
  2190. return;
  2191. }
  2193. config = kmalloc (sizeof (*config), GFP_KERNEL);
  2194. if (!config) {
  2195. err ("%s - out of memory", __FUNCTION__);
  2196. return;
  2197. }
  2199. cflag = tty->termios->c_cflag;
  2201. config->wFlags = 0;
  2203. /* These flags must be set */
  2204. config->wFlags |= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
  2205. config->wFlags |= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
  2206. config->bUartMode = 0;
  2208. switch (cflag & CSIZE) {
  2209. case CS5:
  2210.     config->bDataBits = UMP_UART_CHAR5BITS;
  2211.     dbg ("%s - data bits = 5", __FUNCTION__);
  2212.     break;
  2213. case CS6:
  2214.     config->bDataBits = UMP_UART_CHAR6BITS;
  2215.     dbg ("%s - data bits = 6", __FUNCTION__);
  2216.     break;
  2217. case CS7:
  2218.     config->bDataBits = UMP_UART_CHAR7BITS;
  2219.     dbg ("%s - data bits = 7", __FUNCTION__);
  2220.     break;
  2221. default:
  2222. case CS8:
  2223.     config->bDataBits = UMP_UART_CHAR8BITS;
  2224.     dbg ("%s - data bits = 8", __FUNCTION__);
  2225.     break;
  2226. }
  2228. if (cflag & PARENB) {
  2229. if (cflag & PARODD) {
  2230. config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
  2231. config->bParity = UMP_UART_ODDPARITY;
  2232. dbg("%s - parity = odd", __FUNCTION__);
  2233. } else {
  2234. config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
  2235. config->bParity = UMP_UART_EVENPARITY;
  2236. dbg("%s - parity = even", __FUNCTION__);
  2237. }
  2238. } else {
  2239. config->bParity = UMP_UART_NOPARITY; 
  2240. dbg("%s - parity = none", __FUNCTION__);
  2241. }
  2243. if (cflag & CSTOPB) {
  2244. config->bStopBits = UMP_UART_STOPBIT2;
  2245. dbg("%s - stop bits = 2", __FUNCTION__);
  2246. } else {
  2247. config->bStopBits = UMP_UART_STOPBIT1;
  2248. dbg("%s - stop bits = 1", __FUNCTION__);
  2249. }
  2251. /* figure out the flow control settings */
  2252. if (cflag & CRTSCTS) {
  2253. config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
  2254. config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
  2255. dbg("%s - RTS/CTS is enabled", __FUNCTION__);
  2256. } else {
  2257. dbg("%s - RTS/CTS is disabled", __FUNCTION__);
  2258. }
  2260. /* if we are implementing XON/XOFF, set the start and stop character in the device */
  2261. if (I_IXOFF(tty) || I_IXON(tty)) {
  2262. config->cXon  = START_CHAR(tty);
  2263. config->cXoff = STOP_CHAR(tty);
  2265. /* if we are implementing INBOUND XON/XOFF */
  2266. if (I_IXOFF(tty)) {
  2267. config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
  2268. dbg ("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
  2269.      __FUNCTION__, config->cXon, config->cXoff);
  2270. } else {
  2271. dbg ("%s - INBOUND XON/XOFF is disabled", __FUNCTION__);
  2272. }
  2274. /* if we are implementing OUTBOUND XON/XOFF */
  2275. if (I_IXON(tty)) {
  2276. config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
  2277. dbg ("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
  2278.      __FUNCTION__, config->cXon, config->cXoff);
  2279. } else {
  2280. dbg ("%s - OUTBOUND XON/XOFF is disabled", __FUNCTION__);
  2281. }
  2282. }
  2284. /* Round the baud rate */
  2285. baud = tty_get_baud_rate(tty);
  2286. if (!baud) {
  2287. /* pick a default, any default... */
  2288. baud = 9600;
  2289. }
  2290. config->wBaudRate = (__u16)(461550L / baud);
  2291. round = 4615500L / baud;
  2292. if ((round - (config->wBaudRate * 10)) >= 5)
  2293. config->wBaudRate++;
  2295. dbg ("%s - baud rate = %d, wBaudRate = %d", __FUNCTION__, baud, config->wBaudRate);
  2297. dbg ("wBaudRate:   %d", (int)(461550L / config->wBaudRate));
  2298. dbg ("wFlags:    0x%x", config->wFlags);
  2299. dbg ("bDataBits:   %d", config->bDataBits);
  2300. dbg ("bParity:     %d", config->bParity);
  2301. dbg ("bStopBits:   %d", config->bStopBits);
  2302. dbg ("cXon:        %d", config->cXon);
  2303. dbg ("cXoff:       %d", config->cXoff);
  2304. dbg ("bUartMode:   %d", config->bUartMode);
  2306. /* move the word values into big endian mode */
  2307. cpu_to_be16s (&config->wFlags);
  2308. cpu_to_be16s (&config->wBaudRate);
  2310. status = TIWriteCommandSync (edge_port->port->serial->dev,
  2311. UMPC_SET_CONFIG,
  2312. (__u8)(UMPM_UART1_PORT + port_number),
  2313. 0,
  2314. (__u8 *)config,
  2315. sizeof(*config));
  2316. if (status) {
  2317. dbg ("%s - error %d when trying to write config to device",
  2318.      __FUNCTION__, status);
  2319. }
  2321. kfree (config);
  2323. return;
  2324. }
  2326. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios)
  2327. {
  2328. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2329. struct tty_struct *tty = port->tty;
  2330. unsigned int cflag;
  2332. if (!port->tty || !port->tty->termios) {
  2333. dbg ("%s - no tty or termios", __FUNCTION__);
  2334. return;
  2335. }
  2337. cflag = tty->termios->c_cflag;
  2338. /* check that they really want us to change something */
  2339. if (old_termios) {
  2340. if ((cflag == old_termios->c_cflag) &&
  2341.     (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) {
  2342. dbg ("%s - nothing to change", __FUNCTION__);
  2343. return;
  2344. }
  2345. }
  2347. dbg("%s - clfag %08x iflag %08x", __FUNCTION__, 
  2348.     tty->termios->c_cflag,
  2349.     RELEVANT_IFLAG(tty->termios->c_iflag));
  2350. if (old_termios) {
  2351. dbg("%s - old clfag %08x old iflag %08x", __FUNCTION__,
  2352.     old_termios->c_cflag,
  2353.     RELEVANT_IFLAG(old_termios->c_iflag));
  2354. }
  2356. dbg("%s - port %d", __FUNCTION__, port->number);
  2358. if (edge_port == NULL)
  2359. return;
  2361. /* change the port settings to the new ones specified */
  2362. change_port_settings (edge_port, old_termios);
  2364. return;
  2365. }
  2367. static int set_modem_info (struct edgeport_port *edge_port, unsigned int cmd, unsigned int *value)
  2368. {
  2369. unsigned int mcr = edge_port->shadow_mcr;
  2370. unsigned int arg;
  2372. if (copy_from_user(&arg, value, sizeof(int)))
  2373. return -EFAULT;
  2375. switch (cmd) {
  2376. case TIOCMBIS:
  2377. if (arg & TIOCM_RTS)
  2378. mcr |= MCR_RTS;
  2379. if (arg & TIOCM_DTR)
  2380. mcr |= MCR_RTS;
  2381. if (arg & TIOCM_LOOP)
  2382. mcr |= MCR_LOOPBACK;
  2383. break;
  2385. case TIOCMBIC:
  2386. if (arg & TIOCM_RTS)
  2387. mcr &= ~MCR_RTS;
  2388. if (arg & TIOCM_DTR)
  2389. mcr &= ~MCR_RTS;
  2390. if (arg & TIOCM_LOOP)
  2391. mcr &= ~MCR_LOOPBACK;
  2392. break;
  2394. case TIOCMSET:
  2395. /* turn off the RTS and DTR and LOOPBACK 
  2396.  * and then only turn on what was asked to */
  2397. mcr &=  ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK);
  2398. mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0);
  2399. mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0);
  2400. mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0);
  2401. break;
  2402. }
  2404. edge_port->shadow_mcr = mcr;
  2406. TIRestoreMCR (edge_port, mcr);
  2408. return 0;
  2409. }
  2411. static int get_modem_info (struct edgeport_port *edge_port, unsigned int *value)
  2412. {
  2413. unsigned int result = 0;
  2414. unsigned int msr = edge_port->shadow_msr;
  2415. unsigned int mcr = edge_port->shadow_mcr;
  2417. result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0)   /* 0x002 */
  2418.   | ((mcr & MCR_RTS) ? TIOCM_RTS: 0)   /* 0x004 */
  2419.   | ((msr & MSR_CTS) ? TIOCM_CTS: 0)   /* 0x020 */
  2420.   | ((msr & MSR_CD) ? TIOCM_CAR: 0)   /* 0x040 */
  2421.   | ((msr & MSR_RI) ? TIOCM_RI:  0)   /* 0x080 */
  2422.   | ((msr & MSR_DSR) ? TIOCM_DSR: 0);  /* 0x100 */
  2425. dbg("%s -- %x", __FUNCTION__, result);
  2427. if (copy_to_user(value, &result, sizeof(int)))
  2428. return -EFAULT;
  2429. return 0;
  2430. }
  2432. static int get_serial_info (struct edgeport_port *edge_port, struct serial_struct * retinfo)
  2433. {
  2434. struct serial_struct tmp;
  2436. if (!retinfo)
  2437. return -EFAULT;
  2439. memset(&tmp, 0, sizeof(tmp));
  2441. tmp.type = PORT_16550A;
  2442. tmp.line = edge_port->port->serial->minor;
  2443. tmp.port = edge_port->port->number;
  2444. tmp.irq = 0;
  2445. tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
  2446. tmp.xmit_fifo_size = edge_port->port->bulk_out_size;
  2447. tmp.baud_base = 9600;
  2448. tmp.close_delay = 5*HZ;
  2449. tmp.closing_wait = 30*HZ;
  2450. // tmp.custom_divisor = state->custom_divisor;
  2451. // tmp.hub6 = state->hub6;
  2452. // tmp.io_type = state->io_type;
  2455. if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
  2456. return -EFAULT;
  2457. return 0;
  2458. }
  2460. static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
  2461. {
  2462. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2463. struct async_icount cnow;
  2464. struct async_icount cprev;
  2466. dbg("%s - port %d, cmd = 0x%x", __FUNCTION__, port->number, cmd);
  2468. switch (cmd) {
  2469. case TIOCINQ:
  2470. dbg("%s - (%d) TIOCINQ", __FUNCTION__, port->number);
  2471. // return get_number_bytes_avail(edge_port, (unsigned int *) arg);
  2472. break;
  2474. case TIOCSERGETLSR:
  2475. dbg("%s - (%d) TIOCSERGETLSR", __FUNCTION__, port->number);
  2476. // return get_lsr_info(edge_port, (unsigned int *) arg);
  2477. break;
  2479. case TIOCMBIS:
  2480. case TIOCMBIC:
  2481. case TIOCMSET:
  2482. dbg("%s - (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __FUNCTION__, port->number);
  2483. return set_modem_info(edge_port, cmd, (unsigned int *) arg);
  2484. break;
  2486. case TIOCMGET:  
  2487. dbg("%s - (%d) TIOCMGET", __FUNCTION__, port->number);
  2488. return get_modem_info(edge_port, (unsigned int *) arg);
  2489. break;
  2491. case TIOCGSERIAL:
  2492. dbg("%s - (%d) TIOCGSERIAL", __FUNCTION__, port->number);
  2493. return get_serial_info(edge_port, (struct serial_struct *) arg);
  2494. break;
  2496. case TIOCSSERIAL:
  2497. dbg("%s - (%d) TIOCSSERIAL", __FUNCTION__, port->number);
  2498. break;
  2500. case TIOCMIWAIT:
  2501. dbg("%s - (%d) TIOCMIWAIT", __FUNCTION__, port->number);
  2502. cprev = edge_port->icount;
  2503. while (1) {
  2504. interruptible_sleep_on(&edge_port->delta_msr_wait);
  2505. /* see if a signal did it */
  2506. if (signal_pending(current))
  2507. return -ERESTARTSYS;
  2508. cnow = edge_port->icount;
  2509. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
  2510.     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  2511. return -EIO; /* no change => error */
  2512. if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  2513.     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  2514.     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  2515.     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
  2516. return 0;
  2517. }
  2518. cprev = cnow;
  2519. }
  2520. /* not reached */
  2521. break;
  2523. case TIOCGICOUNT:
  2524. dbg ("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __FUNCTION__,
  2525.      port->number, edge_port->icount.rx, edge_port->icount.tx);
  2526. if (copy_to_user((void *)arg, &edge_port->icount, sizeof(edge_port->icount)))
  2527. return -EFAULT;
  2528. return 0;
  2529. }
  2531. return -ENOIOCTLCMD;
  2532. }
  2534. static void edge_break (struct usb_serial_port *port, int break_state)
  2535. {
  2536. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  2537. int status;
  2539. dbg ("%s - state = %d", __FUNCTION__, break_state);
  2541. /* chase the port close */
  2542. TIChasePort (edge_port);
  2544. if (break_state == -1) {
  2545. status = TISetBreak (edge_port);
  2546. } else {
  2547. status = TIClearBreak (edge_port);
  2548. }
  2549. if (status) {
  2550. dbg ("%s - error %d sending break set/clear command.",
  2551.      __FUNCTION__, status);
  2552. }
  2553. }
  2555. static int edge_startup (struct usb_serial *serial)
  2556. {
  2557. struct edgeport_serial *edge_serial;
  2558. struct edgeport_port *edge_port;
  2559. struct usb_device *dev;
  2560. int status;
  2561. int i;
  2563. dev = serial->dev;
  2565. /* create our private serial structure */
  2566. edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
  2567. if (edge_serial == NULL) {
  2568. err("%s - Out of memory", __FUNCTION__);
  2569. return -ENOMEM;
  2570. }
  2571. memset (edge_serial, 0, sizeof(struct edgeport_serial));
  2572. edge_serial->serial = serial;
  2573. serial->private = edge_serial;
  2575. status = TIDownloadFirmware (edge_serial);
  2576. if (status) {
  2577. kfree (edge_serial);
  2578. return status;
  2579. }
  2581. /* set up our port private structures */
  2582. for (i = 0; i < serial->num_ports; ++i) {
  2583. edge_port = kmalloc (sizeof(struct edgeport_port), GFP_KERNEL);
  2584. if (edge_port == NULL) {
  2585. err("%s - Out of memory", __FUNCTION__);
  2586. return -ENOMEM;
  2587. }
  2588. memset (edge_port, 0, sizeof(struct edgeport_port));
  2589. edge_port->port = &serial->port[i];
  2590. edge_port->edge_serial = edge_serial;
  2591. serial->port[i].private = edge_port;
  2592. }
  2594. return 0;
  2595. }
  2597. static void edge_shutdown (struct usb_serial *serial)
  2598. {
  2599. int i;
  2601. dbg ("%s", __FUNCTION__);
  2603. for (i=0; i < serial->num_ports; ++i) {
  2604. kfree (serial->port[i].private);
  2605. serial->port[i].private = NULL;
  2606. }
  2607. kfree (serial->private);
  2608. serial->private = NULL;
  2609. }
  2612. static struct usb_serial_device_type edgeport_1port_device = {
  2613. owner: THIS_MODULE,
  2614. name: "Edgeport TI 1 port adapter",
  2615. id_table: edgeport_1port_id_table,
  2616. num_interrupt_in: 1,
  2617. num_bulk_in: 1,
  2618. num_bulk_out: 1,
  2619. num_ports: 1,
  2620. open: edge_open,
  2621. close: edge_close,
  2622. throttle: edge_throttle,
  2623. unthrottle: edge_unthrottle,
  2624. startup: edge_startup,
  2625. shutdown: edge_shutdown,
  2626. ioctl: edge_ioctl,
  2627. set_termios: edge_set_termios,
  2628. write: edge_write,
  2629. write_room: edge_write_room,
  2630. chars_in_buffer: edge_chars_in_buffer,
  2631. break_ctl: edge_break,
  2632. };
  2634. static struct usb_serial_device_type edgeport_2port_device = {
  2635. owner: THIS_MODULE,
  2636. name: "Edgeport TI 2 port adapter",
  2637. id_table: edgeport_2port_id_table,
  2638. num_interrupt_in: 1,
  2639. num_bulk_in: 2,
  2640. num_bulk_out: 2,
  2641. num_ports: 2,
  2642. open: edge_open,
  2643. close: edge_close,
  2644. throttle: edge_throttle,
  2645. unthrottle: edge_unthrottle,
  2646. startup: edge_startup,
  2647. shutdown: edge_shutdown,
  2648. ioctl: edge_ioctl,
  2649. set_termios: edge_set_termios,
  2650. write: edge_write,
  2651. write_room: edge_write_room,
  2652. chars_in_buffer: edge_chars_in_buffer,
  2653. break_ctl: edge_break,
  2654. };
  2657. static int __init edgeport_init(void)
  2658. {
  2659. usb_serial_register (&edgeport_1port_device);
  2660. usb_serial_register (&edgeport_2port_device);
  2661. info(DRIVER_DESC " " DRIVER_VERSION);
  2662. return 0;
  2663. }
  2665. static void __exit edgeport_exit (void)
  2666. {
  2667. usb_serial_deregister (&edgeport_1port_device);
  2668. usb_serial_deregister (&edgeport_2port_device);
  2669. }
  2671. module_init(edgeport_init);
  2672. module_exit(edgeport_exit);
  2674. /* Module information */
  2675. MODULE_AUTHOR(DRIVER_AUTHOR);
  2676. MODULE_DESCRIPTION(DRIVER_DESC);
  2677. MODULE_LICENSE("GPL");
  2679. MODULE_PARM(debug, "i");
  2680. MODULE_PARM_DESC(debug, "Debug enabled or not");
  2682. MODULE_PARM(ignore_cpu_rev, "i");
  2683. MODULE_PARM_DESC(ignore_cpu_rev, "Ignore the cpu revision when connecting to a device");