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

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

Linux/Unix编程

开发平台：

Unix_Linux

io_edgeport.c：源码内容
  1. /*
  2.  * Edgeport USB Serial Converter driver
  3.  *
  4.  * Copyright(c) 2000 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.  * Edgeport/4
  14.  * Edgeport/4t
  15.  * Edgeport/2
  16.  * Edgeport/4i
  17.  * Edgeport/2i
  18.  * Edgeport/421
  19.  * Edgeport/21
  20.  * Rapidport/4
  21.  * Edgeport/8
  22.  * Edgeport/2D8
  23.  * Edgeport/4D8
  24.  * Edgeport/8i
  25.  *
  26.  * Version history:
  27.  * 
  28.  * 2.3 2002_03_08 greg kroah-hartman
  29.  * - fixed bug when multiple devices were attached at the same time.
  30.  *
  31.  * 2.2 2001_11_14 greg kroah-hartman
  32.  * - fixed bug in edge_close that kept the port from being used more
  33.  *   than once.
  34.  * - fixed memory leak on device removal.
  35.  * - fixed potential double free of memory when command urb submitting
  36.  *   failed.
  37.  * - other small cleanups when the device is removed
  38.  *
  39.  * 2.1 2001_07_09 greg kroah-hartman
  40.  * - added support for TIOCMBIS and TIOCMBIC.
  41.  *
  42.  *     (04/08/2001) gb
  43.  * - Identify version on module load.
  44.  *
  45.  * 2.0 2001_03_05 greg kroah-hartman
  46.  * - reworked entire driver to fit properly in with the other usb-serial
  47.  *   drivers.  Occasional oopses still happen, but it's a good start.
  48.  *
  49.  * 1.2.3 (02/23/2001) greg kroah-hartman
  50.  * - changed device table to work properly for 2.4.x final format.
  51.  * - fixed problem with dropping data at high data rates.
  52.  *
  53.  * 1.2.2 (11/27/2000) greg kroah-hartman
  54.  * - cleaned up more NTisms.
  55.  * - Added device table for 2.4.0-test11
  56.  *
  57.  * 1.2.1 (11/08/2000) greg kroah-hartman
  58.  * - Started to clean up NTisms.
  59.  * - Fixed problem with dev field of urb for kernels >= 2.4.0-test9
  60.  *
  61.  * 1.2 (10/17/2000) David Iacovelli
  62.  *  Remove all EPIC code and GPL source
  63.  *  Fix RELEVANT_IFLAG macro to include flow control 
  64.  *  changes port configuration changes.
  65.  *  Fix redefinition of SERIAL_MAGIC
  66.  *  Change all timeout values to 5 seconds
  67.  *  Tried to fix the UHCI multiple urb submission, but failed miserably.
  68.  *  it seems to work fine with OHCI.
  69.  *  ( Greg take a look at the #if 0 at end of WriteCmdUsb() we must 
  70.  *    find a way to work arount this UHCI bug )
  71.  *
  72.  * 1.1 (10/11/2000) David Iacovelli
  73.  *  Fix XON/XOFF flow control to support both IXON and IXOFF
  74.  *
  75.  * 0.9.27 (06/30/2000) David Iacovelli
  76.  *  Added transmit queue and now allocate urb for command writes.
  77.  *
  78.  * 0.9.26 (06/29/2000) David Iacovelli
  79.  *  Add support for 80251 based edgeport
  80.  *
  81.  * 0.9.25 (06/27/2000) David Iacovelli
  82.  *  Do not close the port if it has multiple opens.
  83.  *
  84.  * 0.9.24 (05/26/2000) David Iacovelli
  85.  *  Add IOCTLs to support RXTX and JAVA POS 
  86.  *  and first cut at running BlackBox Demo
  87.  *
  88.  * 0.9.23 (05/24/2000) David Iacovelli
  89.  *  Add IOCTLs to support RXTX and JAVA POS
  90.  *
  91.  * 0.9.22 (05/23/2000) David Iacovelli
  92.  *  fixed bug in enumeration.  If epconfig turns on mapping by
  93.  *  path after a device is already plugged in, we now update
  94.  *  the mapping correctly
  95.  *
  96.  * 0.9.21 (05/16/2000) David Iacovelli
  97.  *  Added BlockUntilChaseResp() to also wait for txcredits
  98.  *  Updated the way we allocate and handle write URBs 
  99.  * Add debug code to dump buffers
  100.  *
  101.  * 0.9.20 (05/01/2000) David Iacovelli
  102.  * change driver to use usb/tts/
  103.  *
  104.  * 0.9.19 (05/01/2000) David Iacovelli
  105.  *  Update code to compile if DEBUG is off
  106.  *
  107.  * 0.9.18 (04/28/2000) David Iacovelli
  108.  *  cleanup and test tty_register with devfs
  109.  *
  110.  * 0.9.17 (04/27/2000) greg kroah-hartman
  111.  *  changed tty_register around to be like the way it
  112.  *  was before, but now it works properly with devfs.
  113.  *
  114.  * 0.9.16 (04/26/2000) david iacovelli
  115.  *  Fixed bug in GetProductInfo()
  116.  *
  117.  * 0.9.15 (04/25/2000) david iacovelli
  118.  * Updated enumeration
  119.  *
  120.  * 0.9.14 (04/24/2000) david iacovelli
  121.  *  Removed all config/status IOCTLS and 
  122.  *  converted to using /proc/edgeport
  123.  *  still playing with devfs
  124.  *
  125.  * 0.9.13 (04/24/2000) david iacovelli
  126.  *  Removed configuration based on ttyUSB0
  127.  *  Added support for configuration using /prod/edgeport
  128.  *  first attempt at using devfs (not working yet!)
  129.  *  Added IOCTL to GetProductInfo()
  130.  *  Added support for custom baud rates
  131.  * Add support for random port numbers
  132.  *
  133.  * 0.9.12 (04/18/2000) david iacovelli
  134.  * added additional configuration IOCTLs
  135.  *  use ttyUSB0 for configuration
  136.  *
  137.  * 0.9.11 (04/17/2000) greg kroah-hartman
  138.  * fixed module initialization race conditions.
  139.  * made all urbs dynamically allocated.
  140.  * made driver devfs compatible. now it only registers the tty device
  141.  * when the device is actually plugged in.
  142.  *
  143.  * 0.9.10 (04/13/2000) greg kroah-hartman
  144.  * added proc interface framework.
  145.  *
  146.  * 0.9.9 (04/13/2000) david iacovelli
  147.  * added enumeration code and ioctls to configure the device
  148.  *
  149.  * 0.9.8 (04/12/2000) david iacovelli
  150.  *  Change interrupt read start when device is plugged in
  151.  *  and stop when device is removed
  152.  * process interrupt reads when all ports are closed 
  153.  *  (keep value of rxBytesAvail consistent with the edgeport)
  154.  *  set the USB_BULK_QUEUE flag so that we can shove a bunch 
  155.  *  of urbs at once down the pipe 
  156.  *
  157.  * 0.9.7 (04/10/2000) david iacovelli
  158.  *  start to add enumeration code.
  159.  *  generate serial number for epic devices
  160.  *  add support for kdb
  161.  *
  162.  * 0.9.6 (03/30/2000) david iacovelli
  163.  *  add IOCTL to get string, manufacture, and boot descriptors
  164.  *
  165.  * 0.9.5 (03/14/2000) greg kroah-hartman
  166.  * more error checking added to SerialOpen to try to fix UHCI open problem
  167.  *
  168.  * 0.9.4 (03/09/2000) greg kroah-hartman
  169.  * added more error checking to handle oops when data is hanging
  170.  * around and tty is abruptly closed.
  171.  *
  172.  * 0.9.3 (03/09/2000) david iacovelli
  173.  * Add epic support for xon/xoff chars
  174.  * play with performance
  175.  *
  176.  * 0.9.2 (03/08/2000) greg kroah-hartman
  177.  * changed most "info" calls to "dbg"
  178.  * implemented flow control properly in the termios call
  179.  *
  180.  * 0.9.1 (03/08/2000) david iacovelli
  181.  * added EPIC support
  182.  * enabled bootloader update
  183.  *
  184.  * 0.9 (03/08/2000) greg kroah-hartman
  185.  * Release to IO networks.
  186.  * Integrated changes that David made
  187.  *  made getting urbs for writing SMP safe
  188.  *
  189.  * 0.8 (03/07/2000) greg kroah-hartman
  190.  * Release to IO networks.
  191.  * Fixed problems that were seen in code by David.
  192.  *  Now both Edgeport/4 and Edgeport/2 works properly.
  193.  *  Changed most of the functions to use port instead of serial.
  194.  *
  195.  * 0.7 (02/27/2000) greg kroah-hartman
  196.  * Milestone 3 release.
  197.  * Release to IO Networks
  198.  * ioctl for waiting on line change implemented.
  199.  * ioctl for getting statistics implemented.
  200.  * multiport support working.
  201.  * lsr and msr registers are now handled properly.
  202.  * change break now hooked up and working.
  203.  * support for all known Edgeport devices.
  204.  *
  205.  * 0.6 (02/22/2000) greg kroah-hartman
  206.  * Release to IO networks.
  207.  * CHASE is implemented correctly when port is closed.
  208.  * SerialOpen now blocks correctly until port is fully opened.
  209.  *
  210.  * 0.5 (02/20/2000) greg kroah-hartman
  211.  * Release to IO networks.
  212.  * Known problems:
  213.  * modem status register changes are not sent on to the user
  214.  * CHASE is not implemented when the port is closed.
  215.  *
  216.  * 0.4 (02/16/2000) greg kroah-hartman
  217.  * Second cut at the CeBit demo.
  218.  * Doesn't leak memory on every write to the port
  219.  * Still small leaks on startup.
  220.  * Added support for Edgeport/2 and Edgeport/8
  221.  *
  222.  * 0.3 (02/15/2000) greg kroah-hartman
  223.  * CeBit demo release.
  224.  * Force the line settings to 4800, 8, 1, e for the demo.
  225.  * Warning! This version leaks memory like crazy!
  226.  *
  227.  * 0.2 (01/30/2000) greg kroah-hartman
  228.  * Milestone 1 release.
  229.  * Device is found by USB subsystem, enumerated, fimware is downloaded
  230.  * and the descriptors are printed to the debug log, config is set, and
  231.  * green light starts to blink. Open port works, and data can be sent
  232.  * and received at the default settings of the UART. Loopback connector
  233.  * and debug log confirms this.
  234.  * 
  235.  * 0.1 (01/23/2000) greg kroah-hartman
  236.  * Initial release to help IO Networks try to set up their test system. 
  237.  * Edgeport4 is recognized, firmware is downloaded, config is set so 
  238.  * device blinks green light every 3 sec. Port is bound, but opening,
  239.  * closing, and sending data do not work properly.
  240.  * 
  241.  */
  243. #include <linux/config.h>
  244. #include <linux/kernel.h>
  245. #include <linux/errno.h>
  246. #include <linux/init.h>
  247. #include <linux/slab.h>
  248. #include <linux/tty.h>
  249. #include <linux/tty_driver.h>
  250. #include <linux/tty_flip.h>
  251. #include <linux/module.h>
  252. #include <linux/spinlock.h>
  253. #include <linux/serial.h>
  254. #include <linux/ioctl.h>
  255. #include <asm/uaccess.h>
  256. #include <linux/usb.h>
  258. #ifdef CONFIG_USB_SERIAL_DEBUG
  259. static int debug = 1;
  260. #else
  261. static int debug;
  262. #endif
  264. #include "usb-serial.h"
  266. #include "io_edgeport.h"
  267. #include "io_ionsp.h" /* info for the iosp messages */
  268. #include "io_16654.h" /* 16654 UART defines */
  270. /*
  271.  * Version Information
  272.  */
  273. #define DRIVER_VERSION "v2.3"
  274. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
  275. #define DRIVER_DESC "Edgeport USB Serial Driver"
  277. /* First, the latest boot code - for first generation edgeports */
  278. #define IMAGE_ARRAY_NAME BootCodeImage_GEN1
  279. #define IMAGE_VERSION_NAME BootCodeImageVersion_GEN1
  280. #include "io_fw_boot.h" /* the bootloader firmware to download to a device, if it needs it */
  282. /* for second generation edgeports */
  283. #define IMAGE_ARRAY_NAME BootCodeImage_GEN2
  284. #define IMAGE_VERSION_NAME BootCodeImageVersion_GEN2
  285. #include "io_fw_boot2.h" /* the bootloader firmware to download to a device, if it needs it */
  287. /* Then finally the main run-time operational code - for first generation edgeports */
  288. #define IMAGE_ARRAY_NAME OperationalCodeImage_GEN1
  289. #define IMAGE_VERSION_NAME OperationalCodeImageVersion_GEN1
  290. #include "io_fw_down.h" /* Define array OperationalCodeImage[] */
  292. /* for second generation edgeports */
  293. #define IMAGE_ARRAY_NAME OperationalCodeImage_GEN2
  294. #define IMAGE_VERSION_NAME OperationalCodeImageVersion_GEN2
  295. #include "io_fw_down2.h" /* Define array OperationalCodeImage[] */
  298. #define MAX_NAME_LEN 64
  301. #define CHASE_TIMEOUT (5*HZ) /* 5 seconds */
  302. #define OPEN_TIMEOUT (5*HZ) /* 5 seconds */
  303. #define COMMAND_TIMEOUT (5*HZ) /* 5 seconds */
  305. #ifndef SERIAL_MAGIC
  306. #define SERIAL_MAGIC 0x6702
  307. #endif
  308. #define PORT_MAGIC 0x7301
  311. /* receive port state */
  312. enum RXSTATE {
  313. EXPECT_HDR1 = 0, /* Expect header byte 1 */
  314. EXPECT_HDR2 = 1, /* Expect header byte 2 */
  315. EXPECT_DATA = 2, /* Expect 'RxBytesRemaining' data */
  316. EXPECT_HDR3 = 3, /* Expect header byte 3 (for status hdrs only) */
  317. };
  320. /* Transmit Fifo 
  321.  * This Transmit queue is an extension of the edgeport Rx buffer. 
  322.  * The maximum amount of data buffered in both the edgeport 
  323.  * Rx buffer (maxTxCredits) and this buffer will never exceed maxTxCredits.
  324.  */
  325. struct TxFifo {
  326. unsigned int head; /* index to head pointer (write) */
  327. unsigned int tail; /* index to tail pointer (read)  */
  328. unsigned int count; /* Bytes in queue */
  329. unsigned int size; /* Max size of queue (equal to Max number of TxCredits) */
  330. unsigned char *fifo; /* allocated Buffer */
  331. };
  333. /* This structure holds all of the local port information */
  334. struct edgeport_port {
  335. __u16 txCredits; /* our current credits for this port */
  336. __u16 maxTxCredits; /* the max size of the port */
  338. struct TxFifo txfifo; /* transmit fifo -- size will be maxTxCredits */
  339. struct urb *write_urb; /* write URB for this port */
  340. char write_in_progress; /* TRUE while a write URB is outstanding */
  342. __u8 shadowLCR; /* last LCR value received */
  343. __u8 shadowMCR; /* last MCR value received */
  344. __u8 shadowMSR; /* last MSR value received */
  345. __u8 shadowLSR; /* last LSR value received */
  346. __u8 shadowXonChar; /* last value set as XON char in Edgeport */
  347. __u8 shadowXoffChar; /* last value set as XOFF char in Edgeport */
  348. __u8 validDataMask;
  349. __u32 baudRate;
  351. char open;
  352. char openPending;
  353. char commandPending;
  354. char closePending;
  355. char chaseResponsePending;
  357. wait_queue_head_t wait_chase; /* for handling sleeping while waiting for chase to finish */
  358. wait_queue_head_t wait_open; /* for handling sleeping while waiting for open to finish */
  359. wait_queue_head_t wait_command; /* for handling sleeping while waiting for command to finish */
  360. wait_queue_head_t delta_msr_wait; /* for handling sleeping while waiting for msr change to happen */
  362. struct async_icount icount;
  363. struct usb_serial_port *port; /* loop back to the owner of this object */
  364. };
  367. /* This structure holds all of the individual device information */
  368. struct edgeport_serial {
  369. char name[MAX_NAME_LEN+1]; /* string name of this device */
  371. struct edge_manuf_descriptor manuf_descriptor; /* the manufacturer descriptor */
  372. struct edge_boot_descriptor boot_descriptor; /* the boot firmware descriptor */
  373. struct edgeport_product_info product_info; /* Product Info */
  375. __u8 interrupt_in_endpoint; /* the interrupt endpoint handle */
  376. unsigned char * interrupt_in_buffer; /* the buffer we use for the interrupt endpoint */
  377. struct urb * interrupt_read_urb; /* our interrupt urb */
  379. __u8 bulk_in_endpoint; /* the bulk in endpoint handle */
  380. unsigned char * bulk_in_buffer; /* the buffer we use for the bulk in endpoint */
  381. struct urb * read_urb; /* our bulk read urb */
  383. __u8 bulk_out_endpoint; /* the bulk out endpoint handle */
  385. __s16 rxBytesAvail; /* the number of bytes that we need to read from this device */
  387. enum RXSTATE rxState; /* the current state of the bulk receive processor */
  388. __u8 rxHeader1; /* receive header byte 1 */
  389. __u8 rxHeader2; /* receive header byte 2 */
  390. __u8 rxHeader3; /* receive header byte 3 */
  391. __u8 rxPort; /* the port that we are currently receiving data for */
  392. __u8 rxStatusCode; /* the receive status code */
  393. __u8 rxStatusParam; /* the receive status paramater */
  394. __s16 rxBytesRemaining; /* the number of port bytes left to read */
  395. struct usb_serial *serial; /* loop back to the owner of this object */
  396. };
  398. /* baud rate information */
  399. struct divisor_table_entry {
  400. __u32   BaudRate;
  401. __u16  Divisor;
  402. };
  404. //
  405. // Define table of divisors for Rev A EdgePort/4 hardware
  406. // These assume a 3.6864MHz crystal, the standard /16, and
  407. // MCR.7 = 0.
  408. //
  409. static struct divisor_table_entry divisor_table[] = {
  410. {   75, 3072},  
  411. {   110, 2095}, /* 2094.545455 => 230450   => .0217 % over */
  412. {   134, 1713}, /* 1713.011152 => 230398.5 => .00065% under */
  413. {   150, 1536},
  414. {   300, 768},
  415. {   600, 384},
  416. {   1200, 192},
  417. {   1800, 128},
  418. {   2400, 96},
  419. {   4800, 48},
  420. {   7200, 32},
  421. {   9600, 24},
  422. {   14400, 16},
  423. {   19200, 12},
  424. {   38400, 6},
  425. {   57600, 4},
  426. {   115200, 2},
  427. {   230400, 1},
  428. };
  430. /* local variables */
  431. static int CmdUrbs = 0; /* Number of outstanding Command Write Urbs */
  434. /* local function prototypes */
  436. /* function prototypes for all URB callbacks */
  437. static void edge_interrupt_callback (struct urb *urb);
  438. static void edge_bulk_in_callback (struct urb *urb);
  439. static void edge_bulk_out_data_callback (struct urb *urb);
  440. static void edge_bulk_out_cmd_callback (struct urb *urb);
  442. /* function prototypes for the usbserial callbacks */
  443. static int  edge_open (struct usb_serial_port *port, struct file *filp);
  444. static void edge_close (struct usb_serial_port *port, struct file *filp);
  445. static int  edge_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
  446. static int  edge_write_room (struct usb_serial_port *port);
  447. static int  edge_chars_in_buffer (struct usb_serial_port *port);
  448. static void edge_throttle (struct usb_serial_port *port);
  449. static void edge_unthrottle (struct usb_serial_port *port);
  450. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios);
  451. static int  edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
  452. static void edge_break (struct usb_serial_port *port, int break_state);
  453. static int  edge_startup (struct usb_serial *serial);
  454. static void edge_shutdown (struct usb_serial *serial);
  457. #include "io_tables.h" /* all of the devices that this driver supports */
  460. /* function prototypes for all of our local functions */
  461. static int  process_rcvd_data (struct edgeport_serial *edge_serial, unsigned char *buffer, __u16 bufferLength);
  462. static void process_rcvd_status (struct edgeport_serial *edge_serial, __u8 byte2, __u8 byte3);
  463. static void handle_new_msr (struct edgeport_port *edge_port, __u8 newMsr);
  464. static void handle_new_lsr (struct edgeport_port *edge_port, __u8 lsrData, __u8 lsr, __u8 data);
  465. static int  send_iosp_ext_cmd (struct edgeport_port *edge_port, __u8 command, __u8 param);
  466. static int  calc_baud_rate_divisor (int baud_rate, int *divisor);
  467. static int  send_cmd_write_baud_rate (struct edgeport_port *edge_port, int baudRate);
  468. static void change_port_settings (struct edgeport_port *edge_port, struct termios *old_termios);
  469. static int  send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue);
  470. static int  write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer, int writeLength);
  471. static void send_more_port_data (struct edgeport_serial *edge_serial, struct edgeport_port *edge_port);
  473. static int  sram_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  474. static int  rom_read (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  475. static int  rom_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  476. static void get_manufacturing_desc (struct edgeport_serial *edge_serial);
  477. static void get_boot_desc (struct edgeport_serial *edge_serial);
  478. static void load_application_firmware (struct edgeport_serial *edge_serial);
  481. static void unicode_to_ascii (char *string, short *unicode, int unicode_size);
  487. // ************************************************************************
  488. // ************************************************************************
  489. // ************************************************************************
  490. // ************************************************************************
  492. /************************************************************************
  493.  * *
  494.  * update_edgeport_E2PROM() Compare current versions of *
  495.  * Boot ROM and Manufacture  *
  496.  * Descriptors with versions *
  497.  * embedded in this driver *
  498.  * *
  499.  ************************************************************************/
  500. static void update_edgeport_E2PROM (struct edgeport_serial *edge_serial)
  501. {
  502. __u32 BootCurVer;
  503. __u32 BootNewVer;
  504. __u8 BootMajorVersion;                  
  505. __u8 BootMinorVersion;                  
  506. __u16 BootBuildNumber;
  507. __u8 *BootImage;      
  508. __u32 BootSize;
  509. struct edge_firmware_image_record *record;
  510. unsigned char *firmware;
  511. int response;
  514. switch (edge_serial->product_info.iDownloadFile) {
  515. case EDGE_DOWNLOAD_FILE_I930:
  516. BootMajorVersion = BootCodeImageVersion_GEN1.MajorVersion;
  517. BootMinorVersion = BootCodeImageVersion_GEN1.MinorVersion;
  518. BootBuildNumber = BootCodeImageVersion_GEN1.BuildNumber;
  519. BootImage = &BootCodeImage_GEN1[0];
  520. BootSize = sizeof( BootCodeImage_GEN1 );
  521. break;
  523. case EDGE_DOWNLOAD_FILE_80251:
  524. BootMajorVersion = BootCodeImageVersion_GEN2.MajorVersion;
  525. BootMinorVersion = BootCodeImageVersion_GEN2.MinorVersion;
  526. BootBuildNumber = BootCodeImageVersion_GEN2.BuildNumber;
  527. BootImage = &BootCodeImage_GEN2[0];
  528. BootSize = sizeof( BootCodeImage_GEN2 );
  529. break;
  531. default:
  532. return;
  533. }
  535. // Check Boot Image Version
  536. BootCurVer = (edge_serial->boot_descriptor.MajorVersion << 24) +
  537.      (edge_serial->boot_descriptor.MinorVersion << 16) +
  538.       edge_serial->boot_descriptor.BuildNumber;
  540. BootNewVer = (BootMajorVersion << 24) +
  541.      (BootMinorVersion << 16) +
  542.       BootBuildNumber;
  544. dbg("Current Boot Image version %d.%d.%d",
  545.     edge_serial->boot_descriptor.MajorVersion,
  546.     edge_serial->boot_descriptor.MinorVersion,
  547.     edge_serial->boot_descriptor.BuildNumber);
  550. if (BootNewVer > BootCurVer) {
  551. dbg("**Update Boot Image from %d.%d.%d to %d.%d.%d",
  552.     edge_serial->boot_descriptor.MajorVersion,
  553.     edge_serial->boot_descriptor.MinorVersion,
  554.     edge_serial->boot_descriptor.BuildNumber,
  555.     BootMajorVersion,
  556.     BootMinorVersion,
  557.     BootBuildNumber);
  560. dbg("Downloading new Boot Image");
  562. firmware = BootImage;
  564. for (;;) {
  565. record = (struct edge_firmware_image_record *)firmware;
  566. response = rom_write (edge_serial->serial, record->ExtAddr, record->Addr, record->Len, &record->Data[0]);
  567. if (response < 0) {
  568. err("sram_write failed (%x, %x, %d)", record->ExtAddr, record->Addr, record->Len);
  569. break;
  570. }
  571. firmware += sizeof (struct edge_firmware_image_record) + record->Len;
  572. if (firmware >= &BootImage[BootSize]) {
  573. break;
  574. }
  575. }
  576. } else {
  577. dbg("Boot Image -- already up to date");
  578. }
  579. }
  582. /************************************************************************
  583.  * *
  584.  *  Get string descriptor from device *
  585.  * *
  586.  ************************************************************************/
  587. static int get_string (struct usb_device *dev, int Id, char *string)
  588. {
  589. struct usb_string_descriptor StringDesc;
  590. struct usb_string_descriptor *pStringDesc;
  592. dbg("%s - USB String ID = %d", __FUNCTION__, Id );
  594. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc, sizeof(StringDesc))) {
  595. return 0;
  596. }
  598. pStringDesc = kmalloc (StringDesc.bLength, GFP_KERNEL);
  600. if (!pStringDesc) {
  601. return 0;
  602. }
  604. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc, StringDesc.bLength )) {
  605. kfree(pStringDesc);
  606. return 0;
  607. }
  609. unicode_to_ascii(string,  pStringDesc->wData,     pStringDesc->bLength/2-1);
  611. kfree(pStringDesc);
  612. return strlen(string);
  613. }
  616. #if 0
  617. /************************************************************************
  618.  *
  619.  *  Get string descriptor from device
  620.  *
  621.  ************************************************************************/
  622. static int get_string_desc (struct usb_device *dev, int Id, struct usb_string_descriptor **pRetDesc)
  623. {
  624. struct usb_string_descriptor StringDesc;
  625. struct usb_string_descriptor *pStringDesc;
  627. dbg("%s - USB String ID = %d", __FUNCTION__, Id );
  629. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc, sizeof(StringDesc))) {
  630. return 0;
  631. }
  633. pStringDesc = kmalloc (StringDesc.bLength, GFP_KERNEL);
  635. if (!pStringDesc) {
  636. return -1;
  637. }
  639. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc, StringDesc.bLength )) {
  640. kfree(pStringDesc);
  641. return -1;
  642. }
  644. *pRetDesc = pStringDesc;
  645. return 0;
  646. }
  647. #endif
  649. static void get_product_info(struct edgeport_serial *edge_serial)
  650. {
  651. struct edgeport_product_info *product_info = &edge_serial->product_info;
  653. memset (product_info, 0, sizeof(struct edgeport_product_info));
  655. product_info->ProductId = (__u16)(edge_serial->serial->dev->descriptor.idProduct & ~ION_DEVICE_ID_GENERATION_2);
  656. product_info->NumPorts = edge_serial->manuf_descriptor.NumPorts;
  657. product_info->ProdInfoVer = 0;
  659. product_info->RomSize = edge_serial->manuf_descriptor.RomSize;
  660. product_info->RamSize = edge_serial->manuf_descriptor.RamSize;
  661. product_info->CpuRev = edge_serial->manuf_descriptor.CpuRev;
  662. product_info->BoardRev = edge_serial->manuf_descriptor.BoardRev;
  664. product_info->BootMajorVersion = edge_serial->boot_descriptor.MajorVersion;
  665. product_info->BootMinorVersion = edge_serial->boot_descriptor.MinorVersion;
  666. product_info->BootBuildNumber = edge_serial->boot_descriptor.BuildNumber;
  668. memcpy(product_info->ManufactureDescDate, edge_serial->manuf_descriptor.DescDate, sizeof(edge_serial->manuf_descriptor.DescDate));
  670. // check if this is 2nd generation hardware
  671. if (edge_serial->serial->dev->descriptor.idProduct & ION_DEVICE_ID_GENERATION_2) {
  672. product_info->FirmwareMajorVersion = OperationalCodeImageVersion_GEN2.MajorVersion;
  673. product_info->FirmwareMinorVersion = OperationalCodeImageVersion_GEN2.MinorVersion;
  674. product_info->FirmwareBuildNumber = OperationalCodeImageVersion_GEN2.BuildNumber;
  675. product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251;
  676. } else {
  677. product_info->FirmwareMajorVersion = OperationalCodeImageVersion_GEN1.MajorVersion;
  678. product_info->FirmwareMinorVersion = OperationalCodeImageVersion_GEN1.MinorVersion;
  679. product_info->FirmwareBuildNumber = OperationalCodeImageVersion_GEN1.BuildNumber;
  680. product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930;
  681. }
  683. // Determine Product type and set appropriate flags
  684. switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) {
  685. case ION_DEVICE_ID_EDGEPORT_COMPATIBLE:
  686. case ION_DEVICE_ID_EDGEPORT_4T:
  687. case ION_DEVICE_ID_EDGEPORT_4:
  688. case ION_DEVICE_ID_EDGEPORT_2:
  689. case ION_DEVICE_ID_EDGEPORT_8_DUAL_CPU:
  690. case ION_DEVICE_ID_EDGEPORT_8:
  691. case ION_DEVICE_ID_EDGEPORT_421:
  692. case ION_DEVICE_ID_EDGEPORT_21:
  693. case ION_DEVICE_ID_EDGEPORT_2_DIN:
  694. case ION_DEVICE_ID_EDGEPORT_4_DIN:
  695. case ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU:
  696. product_info->IsRS232 = 1;
  697. break;
  699. case ION_DEVICE_ID_EDGEPORT_2I:    // Edgeport/2 RS422/RS485
  700. product_info->IsRS422 = 1;
  701. product_info->IsRS485 = 1;
  702. break;
  704. case ION_DEVICE_ID_EDGEPORT_8I:    // Edgeport/4 RS422
  705. case ION_DEVICE_ID_EDGEPORT_4I:    // Edgeport/4 RS422
  706. product_info->IsRS422 = 1;
  707. break;
  708. }
  710. // Dump Product Info structure
  711. dbg("**Product Information:");
  712. dbg("  ProductId             %x", product_info->ProductId );
  713. dbg("  NumPorts              %d", product_info->NumPorts );
  714. dbg("  ProdInfoVer           %d", product_info->ProdInfoVer );
  715. dbg("  IsServer              %d", product_info->IsServer);
  716. dbg("  IsRS232               %d", product_info->IsRS232 );
  717. dbg("  IsRS422               %d", product_info->IsRS422 );
  718. dbg("  IsRS485               %d", product_info->IsRS485 );
  719. dbg("  RomSize               %d", product_info->RomSize );
  720. dbg("  RamSize               %d", product_info->RamSize );
  721. dbg("  CpuRev                %x", product_info->CpuRev  );
  722. dbg("  BoardRev              %x", product_info->BoardRev);
  723. dbg("  BootMajorVersion      %d.%d.%d", product_info->BootMajorVersion,
  724.     product_info->BootMinorVersion,
  725.     product_info->BootBuildNumber);
  726. dbg("  FirmwareMajorVersion  %d.%d.%d", product_info->FirmwareMajorVersion,
  727.     product_info->FirmwareMinorVersion,
  728.     product_info->FirmwareBuildNumber);
  729. dbg("  ManufactureDescDate   %d/%d/%d", product_info->ManufactureDescDate[0],
  730.     product_info->ManufactureDescDate[1],
  731.     product_info->ManufactureDescDate[2]+1900);
  732. dbg("  iDownloadFile         0x%x",     product_info->iDownloadFile);
  734. }
  737. /************************************************************************/
  738. /************************************************************************/
  739. /*            U S B  C A L L B A C K   F U N C T I O N S                */
  740. /*            U S B  C A L L B A C K   F U N C T I O N S                */
  741. /************************************************************************/
  742. /************************************************************************/
  744. /*****************************************************************************
  745.  * edge_interrupt_callback
  746.  * this is the callback function for when we have received data on the 
  747.  * interrupt endpoint.
  748.  *****************************************************************************/
  749. static void edge_interrupt_callback (struct urb *urb)
  750. {
  751. struct edgeport_serial *edge_serial = (struct edgeport_serial *)urb->context;
  752. struct edgeport_port *edge_port;
  753. struct usb_serial_port *port;
  754. unsigned char *data = urb->transfer_buffer;
  755. int length = urb->actual_length;
  756. int bytes_avail;
  757. int position;
  758. int txCredits;
  759. int portNumber;
  760. int result;
  762. dbg("%s", __FUNCTION__);
  764. if (serial_paranoia_check (edge_serial->serial, __FUNCTION__)) {
  765. return;
  766. }
  768. if (urb->status) {
  769. dbg("%s - nonzero control read status received: %d", __FUNCTION__, urb->status);
  770. return;
  771. }
  773. // process this interrupt-read even if there are no ports open
  774. if (length) {
  775. usb_serial_debug_data (__FILE__, __FUNCTION__, length, data);
  777. if (length > 1) {
  778. bytes_avail = data[0] | (data[1] << 8);
  779. if (bytes_avail) {
  780. edge_serial->rxBytesAvail += bytes_avail;
  781. dbg("%s - bytes_avail = %d, rxBytesAvail %d", __FUNCTION__, bytes_avail, edge_serial->rxBytesAvail);
  783. if ((edge_serial->rxBytesAvail > 0) &&
  784.     (edge_serial->read_urb->status != -EINPROGRESS)) {
  785. dbg(" --- Posting a read");
  787. /* we have pending bytes on the bulk in pipe, send a request */
  788. edge_serial->read_urb->dev = edge_serial->serial->dev;
  789. result = usb_submit_urb(edge_serial->read_urb);
  790. if (result) {
  791. dbg("%s - usb_submit_urb(read bulk) failed with result = %d", __FUNCTION__, result);
  792. }
  793. }
  794. }
  795. }
  796. /* grab the txcredits for the ports if available */
  797. position = 2;
  798. portNumber = 0;
  799. while ((position < length) && (portNumber < edge_serial->serial->num_ports)) {
  800. txCredits = data[position] | (data[position+1] << 8);
  801. if (txCredits) {
  802. port = &edge_serial->serial->port[portNumber];
  803. if (port_paranoia_check (port, __FUNCTION__) == 0) {
  804. edge_port = (struct edgeport_port *)port->private;
  805. if (edge_port->open) {
  806. edge_port->txCredits += txCredits;
  807. dbg("%s - txcredits for port%d = %d", __FUNCTION__, portNumber, edge_port->txCredits);
  809. /* tell the tty driver that something has changed */
  810. if (edge_port->port->tty)
  811. wake_up_interruptible(&edge_port->port->tty->write_wait);
  813. // Since we have more credit, check if more data can be sent
  814. send_more_port_data(edge_serial, edge_port);
  815. }
  816. }
  817. }
  818. position += 2;
  819. ++portNumber;
  820. }
  821. }
  822. }
  825. /*****************************************************************************
  826.  * edge_bulk_in_callback
  827.  * this is the callback function for when we have received data on the 
  828.  * bulk in endpoint.
  829.  *****************************************************************************/
  830. static void edge_bulk_in_callback (struct urb *urb)
  831. {
  832. struct edgeport_serial *edge_serial = (struct edgeport_serial *)urb->context;
  833. unsigned char *data = urb->transfer_buffer;
  834. int status;
  835. __u16 raw_data_length;
  837. dbg("%s", __FUNCTION__);
  839. if (serial_paranoia_check (edge_serial->serial, __FUNCTION__)) {
  840. return;
  841. }
  843. if (urb->status) {
  844. dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
  845. return;
  846. }
  848. if (urb->actual_length) {
  849. raw_data_length = urb->actual_length;
  851. usb_serial_debug_data (__FILE__, __FUNCTION__, raw_data_length, data);
  853. /* decrement our rxBytes available by the number that we just got */
  854. edge_serial->rxBytesAvail -= raw_data_length;
  856. dbg("%s - Received = %d, rxBytesAvail %d", __FUNCTION__, raw_data_length, edge_serial->rxBytesAvail);
  858. process_rcvd_data (edge_serial, data, urb->actual_length);
  860. /* check to see if there's any more data for us to read */
  861. if ((edge_serial->rxBytesAvail > 0) &&
  862.     (edge_serial->read_urb->status != -EINPROGRESS)) {
  863. dbg(" --- Posting a read");
  865. /* there is, so resubmit our urb */
  866. edge_serial->read_urb->dev = edge_serial->serial->dev;
  867. status = usb_submit_urb(edge_serial->read_urb);
  868. if (status) {
  869. err("%s - usb_submit_urb(read bulk) failed, status = %d", __FUNCTION__, status);
  870. }
  871. }
  872. }
  873. }
  876. /*****************************************************************************
  877.  * edge_bulk_out_data_callback
  878.  * this is the callback function for when we have finished sending serial data
  879.  * on the bulk out endpoint.
  880.  *****************************************************************************/
  881. static void edge_bulk_out_data_callback (struct urb *urb)
  882. {
  883. struct edgeport_port *edge_port = (struct edgeport_port *)urb->context;
  884. struct tty_struct *tty;
  886. dbg("%s", __FUNCTION__);
  888. if (port_paranoia_check (edge_port->port, __FUNCTION__)) {
  889. return;
  890. }
  892. if (urb->status) {
  893. dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
  894. }
  896. tty = edge_port->port->tty;
  898. if (tty) {
  899. /* let the tty driver wakeup if it has a special write_wakeup function */
  900. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
  901. (tty->ldisc.write_wakeup)(tty);
  902. }
  904. /* tell the tty driver that something has changed */
  905. wake_up_interruptible(&tty->write_wait);
  906. }
  908. // Release the Write URB
  909. edge_port->write_in_progress = FALSE;
  911. // Check if more data needs to be sent
  912. send_more_port_data((struct edgeport_serial *)(edge_port->port->serial->private), edge_port);
  913. }
  916. /*****************************************************************************
  917.  * BulkOutCmdCallback
  918.  * this is the callback function for when we have finished sending a command
  919.  * on the bulk out endpoint.
  920.  *****************************************************************************/
  921. static void edge_bulk_out_cmd_callback (struct urb *urb)
  922. {
  923. struct edgeport_port *edge_port = (struct edgeport_port *)urb->context;
  924. struct tty_struct *tty;
  925. int status = urb->status;
  927. dbg("%s", __FUNCTION__);
  929. CmdUrbs--;
  930. dbg("%s - FREE URB %p (outstanding %d)", __FUNCTION__, urb, CmdUrbs);
  933. /* clean up the transfer buffer */
  934. if (urb->transfer_buffer != NULL) {
  935. kfree(urb->transfer_buffer);
  936. }
  938. // Free the command urb
  939. usb_unlink_urb (urb);
  940. usb_free_urb   (urb);
  942. if (port_paranoia_check (edge_port->port, __FUNCTION__)) {
  943. return;
  944. }
  946. if (status) {
  947. dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, status);
  948. return;
  949. }
  951. /* Get pointer to tty */
  952. tty = edge_port->port->tty;
  954. /* tell the tty driver that something has changed */
  955. if (tty)
  956. wake_up_interruptible(&tty->write_wait);
  958. /* we have completed the command */
  959. edge_port->commandPending = FALSE;
  960. wake_up_interruptible(&edge_port->wait_command);
  961. }
  964. /*****************************************************************************
  965.  * Driver tty interface functions
  966.  *****************************************************************************/
  968. /*****************************************************************************
  969.  * SerialOpen
  970.  * this function is called by the tty driver when a port is opened
  971.  * If successful, we return 0
  972.  * Otherwise we return a negative error number.
  973.  *****************************************************************************/
  974. static int edge_open (struct usb_serial_port *port, struct file * filp)
  975. {
  976. struct edgeport_port *edge_port = (struct edgeport_port *)port->private;
  977. struct usb_serial *serial;
  978. struct edgeport_serial *edge_serial;
  979. int response;
  980. int timeout;
  982. if (port_paranoia_check (port, __FUNCTION__))
  983. return -ENODEV;
  985. dbg("%s - port %d", __FUNCTION__, port->number);
  987. if (edge_port == NULL)
  988. return -ENODEV;
  990. /* force low_latency on so that our tty_push actually forces the data through, 
  991.    otherwise it is scheduled, and with high data rates (like with OHCI) data
  992.    can get lost. */
  993. if (port->tty)
  994. port->tty->low_latency = 1;
  996. /* see if we've set up our endpoint info yet (can't set it up in edge_startup
  997.    as the structures were not set up at that time.) */
  998. serial = port->serial;
  999. edge_serial = (struct edgeport_serial *)serial->private;
  1000. if (edge_serial == NULL) {
  1001. return -ENODEV;
  1002. }
  1003. if (edge_serial->interrupt_in_buffer == NULL) {
  1004. struct usb_serial_port *port0 = &serial->port[0];
  1006. /* not set up yet, so do it now */
  1007. edge_serial->interrupt_in_buffer = port0->interrupt_in_buffer;
  1008. edge_serial->interrupt_in_endpoint = port0->interrupt_in_endpointAddress;
  1009. edge_serial->interrupt_read_urb = port0->interrupt_in_urb;
  1010. edge_serial->bulk_in_buffer = port0->bulk_in_buffer;
  1011. edge_serial->bulk_in_endpoint = port0->bulk_in_endpointAddress;
  1012. edge_serial->read_urb = port0->read_urb;
  1013. edge_serial->bulk_out_endpoint = port0->bulk_out_endpointAddress;
  1015. /* set up our interrupt urb */
  1016. FILL_INT_URB(edge_serial->interrupt_read_urb,
  1017.      serial->dev,
  1018.      usb_rcvintpipe(serial->dev,
  1019.     port0->interrupt_in_endpointAddress),
  1020.      port0->interrupt_in_buffer,
  1021.      edge_serial->interrupt_read_urb->transfer_buffer_length,
  1022.      edge_interrupt_callback, edge_serial,
  1023.      edge_serial->interrupt_read_urb->interval);
  1025. /* set up our bulk in urb */
  1026. FILL_BULK_URB(edge_serial->read_urb, serial->dev,
  1027.       usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress),
  1028.       port0->bulk_in_buffer,
  1029.       edge_serial->read_urb->transfer_buffer_length,
  1030.       edge_bulk_in_callback, edge_serial);
  1032. /* start interrupt read for this edgeport
  1033.  * this interrupt will continue as long as the edgeport is connected */
  1034. response = usb_submit_urb (edge_serial->interrupt_read_urb);
  1035. if (response) {
  1036. err("%s - Error %d submitting control urb", __FUNCTION__, response);
  1037. }
  1038. }
  1040. /* initialize our wait queues */
  1041. init_waitqueue_head(&edge_port->wait_open);
  1042. init_waitqueue_head(&edge_port->wait_chase);
  1043. init_waitqueue_head(&edge_port->delta_msr_wait);
  1044. init_waitqueue_head(&edge_port->wait_command);
  1046. /* initialize our icount structure */
  1047. memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
  1049. /* initialize our port settings */
  1050. edge_port->txCredits            = 0; /* Can't send any data yet */
  1051. edge_port->shadowMCR            = MCR_MASTER_IE; /* Must always set this bit to enable ints! */
  1052. edge_port->chaseResponsePending = FALSE;
  1054. /* send a open port command */
  1055. edge_port->openPending = TRUE;
  1056. edge_port->open        = FALSE;
  1057. response = send_iosp_ext_cmd (edge_port, IOSP_CMD_OPEN_PORT, 0);
  1059. if (response < 0) {
  1060. err("%s - error sending open port command", __FUNCTION__);
  1061. edge_port->openPending = FALSE;
  1062. return -ENODEV;
  1063. }
  1065. /* now wait for the port to be completly opened */
  1066. timeout = OPEN_TIMEOUT;
  1067. while (timeout && edge_port->openPending == TRUE) {
  1068. timeout = interruptible_sleep_on_timeout (&edge_port->wait_open, timeout);
  1069. }
  1071. if (edge_port->open == FALSE) {
  1072. /* open timed out */
  1073. dbg("%s - open timedout", __FUNCTION__);
  1074. edge_port->openPending = FALSE;
  1075. return -ENODEV;
  1076. }
  1078. /* create the txfifo */
  1079. edge_port->txfifo.head = 0;
  1080. edge_port->txfifo.tail = 0;
  1081. edge_port->txfifo.count = 0;
  1082. edge_port->txfifo.size = edge_port->maxTxCredits;
  1083. edge_port->txfifo.fifo = kmalloc (edge_port->maxTxCredits, GFP_KERNEL);
  1085. if (!edge_port->txfifo.fifo) {
  1086. dbg("%s - no memory", __FUNCTION__);
  1087. edge_close (port, filp);
  1088. return -ENOMEM;
  1089. }
  1091. /* Allocate a URB for the write */
  1092. edge_port->write_urb = usb_alloc_urb (0);
  1094. if (!edge_port->write_urb) {
  1095. dbg("%s - no memory", __FUNCTION__);
  1096. edge_close (port, filp);
  1097. return -ENOMEM;
  1098. }
  1100. dbg("%s(%d) - Initialize TX fifo to %d bytes", __FUNCTION__, port->number, edge_port->maxTxCredits);
  1102. dbg("%s exited", __FUNCTION__);
  1104. return 0;
  1105. }
  1108. /************************************************************************
  1109.  *
  1110.  * block_until_chase_response
  1111.  *
  1112.  * This function will block the close until one of the following:
  1113.  * 1. Response to our Chase comes from Edgeport
  1114.  * 2. A timout of 10 seconds without activity has expired
  1115.  *    (1K of Edgeport data @ 2400 baud ==> 4 sec to empty)
  1116.  *
  1117.  ************************************************************************/
  1118. static void block_until_chase_response(struct edgeport_port *edge_port)
  1119. {
  1120. __u16 lastCredits;
  1121. int timeout = 1*HZ;
  1122. int wait = 10;
  1124. while (1) {
  1125. // Save Last credits
  1126. lastCredits = edge_port->txCredits;
  1128. // Did we get our Chase response
  1129. if (edge_port->chaseResponsePending == FALSE) {
  1130. dbg("%s - Got Chase Response", __FUNCTION__);
  1132. // did we get all of our credit back?
  1133. if (edge_port->txCredits == edge_port->maxTxCredits ) {
  1134. dbg("%s - Got all credits", __FUNCTION__);
  1135. return;
  1136. }
  1137. }
  1139. // Block the thread for a while
  1140. interruptible_sleep_on_timeout (&edge_port->wait_chase, timeout);
  1142. if (lastCredits == edge_port->txCredits) {
  1143. // No activity.. count down.
  1144. wait--;
  1145. if (wait == 0) {
  1146. edge_port->chaseResponsePending = FALSE;
  1147. dbg("%s - Chase TIMEOUT", __FUNCTION__);
  1148. return;
  1149. }
  1150. } else {
  1151. // Reset timout value back to 10 seconds
  1152. dbg("%s - Last %d, Current %d", __FUNCTION__, lastCredits, edge_port->txCredits);
  1153. wait = 10;
  1154. }
  1155. }
  1156. }
  1159. /************************************************************************
  1160.  *
  1161.  * block_until_tx_empty
  1162.  *
  1163.  * This function will block the close until one of the following:
  1164.  * 1. TX count are 0
  1165.  * 2. The edgeport has stopped
  1166.  * 3. A timout of 3 seconds without activity has expired
  1167.  *
  1168.  ************************************************************************/
  1169. static void block_until_tx_empty (struct edgeport_port *edge_port)
  1170. {
  1171. struct TxFifo *fifo = &edge_port->txfifo;
  1172. __u32 lastCount;
  1173. int timeout = HZ/10;
  1174. int wait = 30;
  1176. while (1) {
  1177. // Save Last count
  1178. lastCount = fifo->count;
  1180. // Is the Edgeport Buffer empty?
  1181. if (lastCount == 0) {
  1182. dbg("%s - TX Buffer Empty", __FUNCTION__);
  1183. return;
  1184. }
  1186. // Block the thread for a while
  1187. interruptible_sleep_on_timeout (&edge_port->wait_chase, timeout);
  1189. dbg("%s wait", __FUNCTION__);
  1191. if (lastCount == fifo->count) {
  1192. // No activity.. count down.
  1193. wait--;
  1194. if (wait == 0) {
  1195. dbg("%s - TIMEOUT", __FUNCTION__);
  1196. return;
  1197. }
  1198. } else {
  1199. // Reset timout value back to seconds
  1200. wait = 30;
  1201. }
  1202. }
  1203. }
  1206. /*****************************************************************************
  1207.  * edge_close
  1208.  * this function is called by the tty driver when a port is closed
  1209.  *****************************************************************************/
  1210. static void edge_close (struct usb_serial_port *port, struct file * filp)
  1211. {
  1212. struct usb_serial *serial;
  1213. struct edgeport_serial *edge_serial;
  1214. struct edgeport_port *edge_port;
  1215. int status;
  1217. if (port_paranoia_check (port, __FUNCTION__))
  1218. return;
  1220. dbg("%s - port %d", __FUNCTION__, port->number);
  1221.  
  1222. serial = get_usb_serial (port, __FUNCTION__);
  1223. if (!serial)
  1224. return;
  1226. edge_serial = (struct edgeport_serial *)serial->private;
  1227. edge_port = (struct edgeport_port *)port->private;
  1228. if ((edge_serial == NULL) || (edge_port == NULL))
  1229. return;
  1231. if (serial->dev) {
  1232. // block until tx is empty
  1233. block_until_tx_empty(edge_port);
  1235. edge_port->closePending = TRUE;
  1237. /* flush and chase */
  1238. edge_port->chaseResponsePending = TRUE;
  1240. dbg("%s - Sending IOSP_CMD_CHASE_PORT", __FUNCTION__);
  1241. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_CHASE_PORT, 0);
  1242. if (status == 0) {
  1243. // block until chase finished
  1244. block_until_chase_response(edge_port);
  1245. } else {
  1246. edge_port->chaseResponsePending = FALSE;
  1247. }
  1249. /* close the port */
  1250. dbg("%s - Sending IOSP_CMD_CLOSE_PORT", __FUNCTION__);
  1251. send_iosp_ext_cmd (edge_port, IOSP_CMD_CLOSE_PORT, 0);
  1253. //port->close = TRUE;
  1254. edge_port->closePending = FALSE;
  1255. edge_port->open = FALSE;
  1256. edge_port->openPending = FALSE;
  1258. if (edge_port->write_urb) {
  1259. usb_unlink_urb (edge_port->write_urb);
  1260. }
  1261. }
  1263. if (edge_port->write_urb) {
  1264. /* if this urb had a transfer buffer already (old transfer) free it */
  1265. if (edge_port->write_urb->transfer_buffer != NULL) {
  1266. kfree(edge_port->write_urb->transfer_buffer);
  1267. }
  1268. usb_free_urb   (edge_port->write_urb);
  1269. }
  1270. if (edge_port->txfifo.fifo) {
  1271. kfree(edge_port->txfifo.fifo);
  1272. }
  1274. dbg("%s exited", __FUNCTION__);
  1275. }   
  1277. /*****************************************************************************
  1278.  * SerialWrite
  1279.  * this function is called by the tty driver when data should be written to
  1280.  * the port.
  1281.  * If successful, we return the number of bytes written, otherwise we return
  1282.  * a negative error number.
  1283.  *****************************************************************************/
  1284. static int edge_write (struct usb_serial_port *port, int from_user, const unsigned char *data, int count)
  1285. {
  1286.         struct edgeport_port *edge_port = (struct edgeport_port *)port->private;
  1287. struct TxFifo *fifo;
  1288. int copySize;
  1289. int bytesleft;
  1290. int firsthalf;
  1291. int secondhalf;
  1293. dbg("%s - port %d", __FUNCTION__, port->number);
  1295. if (edge_port == NULL)
  1296. return -ENODEV;
  1298. // get a pointer to the Tx fifo
  1299. fifo = &edge_port->txfifo;
  1301. // calculate number of bytes to put in fifo
  1302. copySize = min ((unsigned int)count, (edge_port->txCredits - fifo->count));
  1304. dbg("%s(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes", __FUNCTION__, 
  1305.     port->number, count, edge_port->txCredits - fifo->count, copySize);
  1307. /* catch writes of 0 bytes which the tty driver likes to give us, and when txCredits is empty */
  1308. if (copySize == 0) {
  1309. dbg("%s - copySize = Zero", __FUNCTION__);
  1310. return 0;
  1311. }
  1313. // queue the data
  1314. // since we can never overflow the buffer we do not have to check for full condition
  1316. // the copy is done is two parts -- first fill to the end of the buffer
  1317. // then copy the reset from the start of the buffer 
  1319. bytesleft = fifo->size - fifo->head;
  1320. firsthalf = min (bytesleft, copySize);
  1321. dbg("%s - copy %d bytes of %d into fifo ", __FUNCTION__, firsthalf, bytesleft);
  1323. /* now copy our data */
  1324. if (from_user) {
  1325. if (copy_from_user(&fifo->fifo[fifo->head], data, firsthalf))
  1326. return -EFAULT;
  1327. } else {
  1328. memcpy(&fifo->fifo[fifo->head], data, firsthalf);
  1329. }  
  1331. // update the index and size
  1332. fifo->head  += firsthalf;
  1333. fifo->count += firsthalf;
  1335. // wrap the index
  1336. if (fifo->head == fifo->size) {
  1337. fifo->head = 0;
  1338. }
  1340. secondhalf = copySize-firsthalf;
  1342. if (secondhalf) {
  1343. dbg("%s - copy rest of data %d", __FUNCTION__, secondhalf);
  1344. if (from_user) {
  1345. if (copy_from_user(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf))
  1346. return -EFAULT;
  1347. } else {
  1348. memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf);
  1349. }
  1350. // update the index and size
  1351. fifo->count += secondhalf;
  1352. fifo->head  += secondhalf;
  1353. // No need to check for wrap since we can not get to end of fifo in this part
  1354. }
  1356. if (copySize) {
  1357. usb_serial_debug_data (__FILE__, __FUNCTION__, copySize, data);
  1358. }
  1360. send_more_port_data((struct edgeport_serial *)port->serial->private, edge_port);
  1362. dbg("%s wrote %d byte(s) TxCredits %d, Fifo %d", __FUNCTION__, copySize, edge_port->txCredits, fifo->count);
  1364. return copySize;   
  1365. }
  1368. /************************************************************************
  1369.  *
  1370.  * send_more_port_data()
  1371.  *
  1372.  * This routine attempts to write additional UART transmit data
  1373.  * to a port over the USB bulk pipe. It is called (1) when new
  1374.  * data has been written to a port's TxBuffer from higher layers
  1375.  * (2) when the peripheral sends us additional TxCredits indicating
  1376.  * that it can accept more Tx data for a given port; and (3) when
  1377.  * a bulk write completes successfully and we want to see if we
  1378.  * can transmit more.
  1379.  *
  1380.  ************************************************************************/
  1381. static void send_more_port_data(struct edgeport_serial *edge_serial, struct edgeport_port *edge_port)
  1382. {
  1383. struct TxFifo *fifo = &edge_port->txfifo;
  1384. struct urb *urb;
  1385. unsigned char *buffer;
  1386. int status;
  1387. int count;
  1388. int bytesleft;
  1389. int firsthalf;
  1390. int secondhalf;
  1392. dbg("%s(%d)", __FUNCTION__, edge_port->port->number);
  1394. if (edge_port->write_in_progress ||
  1395.     !edge_port->open             ||
  1396.     (fifo->count == 0)) {
  1397. dbg("%s(%d) EXIT - fifo %d, PendingWrite = %d", __FUNCTION__, edge_port->port->number, fifo->count, edge_port->write_in_progress);
  1398. return;
  1399. }
  1401. // since the amount of data in the fifo will always fit into the
  1402. // edgeport buffer we do not need to check the write length
  1404. // Do we have enough credits for this port to make it worthwhile
  1405. // to bother queueing a write. If it's too small, say a few bytes,
  1406. // it's better to wait for more credits so we can do a larger
  1407. // write.
  1408. if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits)) {
  1409. dbg("%s(%d) Not enough credit - fifo %d TxCredit %d", __FUNCTION__, edge_port->port->number, fifo->count, edge_port->txCredits );
  1410. return;
  1411. }
  1413. // lock this write
  1414. edge_port->write_in_progress = TRUE;
  1416. // get a pointer to the write_urb
  1417. urb = edge_port->write_urb;
  1419. /* if this urb had a transfer buffer already (old transfer) free it */
  1420. if (urb->transfer_buffer != NULL) {
  1421. kfree(urb->transfer_buffer);
  1422. urb->transfer_buffer = NULL;
  1423. }
  1425. /* build the data header for the buffer and port that we are about to send out */
  1426. count = fifo->count;
  1427. buffer = kmalloc (count+2, GFP_ATOMIC);
  1428. if (buffer == NULL) {
  1429. err("%s - no more kernel memory...", __FUNCTION__);
  1430. edge_port->write_in_progress = FALSE;
  1431. return;
  1432. }
  1433. buffer[0] = IOSP_BUILD_DATA_HDR1 (edge_port->port->number - edge_port->port->serial->minor, count);
  1434. buffer[1] = IOSP_BUILD_DATA_HDR2 (edge_port->port->number - edge_port->port->serial->minor, count);
  1436. /* now copy our data */
  1437. bytesleft =  fifo->size - fifo->tail;
  1438. firsthalf = min (bytesleft, count);
  1439. memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf);
  1440. fifo->tail  += firsthalf;
  1441. fifo->count -= firsthalf;
  1442. if (fifo->tail == fifo->size) {
  1443. fifo->tail = 0;
  1444. }
  1446. secondhalf = count-firsthalf;
  1447. if (secondhalf) {
  1448. memcpy(&buffer[2+firsthalf], &fifo->fifo[fifo->tail], secondhalf);
  1449. fifo->tail  += secondhalf;
  1450. fifo->count -= secondhalf;
  1451. }
  1453. if (count) {
  1454. usb_serial_debug_data (__FILE__, __FUNCTION__, count, &buffer[2]);
  1455. }
  1457. /* fill up the urb with all of our data and submit it */
  1458. FILL_BULK_URB (urb, edge_serial->serial->dev, 
  1459.        usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
  1460.        buffer, count+2, edge_bulk_out_data_callback, edge_port);
  1462. /* set the USB_BULK_QUEUE flag so that we can shove a bunch of urbs at once down the pipe */
  1463. urb->transfer_flags |= USB_QUEUE_BULK;
  1465. urb->dev = edge_serial->serial->dev;
  1466. status = usb_submit_urb(urb);
  1467. if (status) {
  1468. /* something went wrong */
  1469. dbg("%s - usb_submit_urb(write bulk) failed", __FUNCTION__);
  1470. edge_port->write_in_progress = FALSE;
  1471. } else {
  1472. /* decrement the number of credits we have by the number we just sent */
  1473. edge_port->txCredits -= count;
  1474. edge_port->icount.tx += count;
  1475. }
  1476. dbg("%s wrote %d byte(s) TxCredit %d, Fifo %d", __FUNCTION__, count, edge_port->txCredits, fifo->count);
  1477. }
  1480. /*****************************************************************************
  1481.  * edge_write_room
  1482.  * this function is called by the tty driver when it wants to know how many
  1483.  * bytes of data we can accept for a specific port.
  1484.  * If successful, we return the amount of room that we have for this port
  1485.  * (the txCredits), 
  1486.  * Otherwise we return a negative error number.
  1487.  *****************************************************************************/
  1488. static int edge_write_room (struct usb_serial_port *port)
  1489. {
  1490. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1491. int room;
  1493. dbg("%s", __FUNCTION__);
  1495. if (edge_port == NULL)
  1496. return -ENODEV;
  1497. if (edge_port->closePending == TRUE)
  1498. return -ENODEV;
  1500. dbg("%s - port %d", __FUNCTION__, port->number);
  1502. if (!edge_port->open) {
  1503. dbg("%s - port not opened", __FUNCTION__);
  1504. return -EINVAL;
  1505. }
  1507. // total of both buffers is still txCredit
  1508. room = edge_port->txCredits - edge_port->txfifo.count;
  1510. dbg("%s - returns %d", __FUNCTION__, room);
  1511. return room;
  1512. }
  1515. /*****************************************************************************
  1516.  * edge_chars_in_buffer
  1517.  * this function is called by the tty driver when it wants to know how many
  1518.  * bytes of data we currently have outstanding in the port (data that has
  1519.  * been written, but hasn't made it out the port yet)
  1520.  * If successful, we return the number of bytes left to be written in the 
  1521.  * system, 
  1522.  * Otherwise we return a negative error number.
  1523.  *****************************************************************************/
  1524. static int edge_chars_in_buffer (struct usb_serial_port *port)
  1525. {
  1526. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1527. int num_chars;
  1529. dbg("%s", __FUNCTION__);
  1531. if (edge_port == NULL)
  1532. return -ENODEV;
  1533. if (edge_port->closePending == TRUE)
  1534. return -ENODEV;
  1536. if (!edge_port->open) {
  1537. dbg("%s - port not opened", __FUNCTION__);
  1538. return -EINVAL;
  1539. }
  1541. num_chars = edge_port->maxTxCredits - edge_port->txCredits + edge_port->txfifo.count;
  1542. if (num_chars) {
  1543. dbg("%s(port %d) - returns %d", __FUNCTION__, port->number, num_chars);
  1544. }
  1546. return num_chars;
  1547. }
  1550. /*****************************************************************************
  1551.  * SerialThrottle
  1552.  * this function is called by the tty driver when it wants to stop the data
  1553.  * being read from the port.
  1554.  *****************************************************************************/
  1555. static void edge_throttle (struct usb_serial_port *port)
  1556. {
  1557. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1558. struct tty_struct *tty;
  1559. int status;
  1561. dbg("%s - port %d", __FUNCTION__, port->number);
  1563. if (edge_port == NULL)
  1564. return;
  1566. if (!edge_port->open) {
  1567. dbg("%s - port not opened", __FUNCTION__);
  1568. return;
  1569. }
  1571. tty = port->tty;
  1572. if (!tty) {
  1573. dbg ("%s - no tty available", __FUNCTION__);
  1574. return;
  1575. }
  1577. /* if we are implementing XON/XOFF, send the stop character */
  1578. if (I_IXOFF(tty)) {
  1579. unsigned char stop_char = STOP_CHAR(tty);
  1580. status = edge_write (port, 0, &stop_char, 1);
  1581. if (status <= 0) {
  1582. return;
  1583. }
  1584. }
  1586. /* if we are implementing RTS/CTS, toggle that line */
  1587. if (tty->termios->c_cflag & CRTSCTS) {
  1588. edge_port->shadowMCR &= ~MCR_RTS;
  1589. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  1590. if (status != 0) {
  1591. return;
  1592. }
  1593. }
  1595. return;
  1596. }
  1599. /*****************************************************************************
  1600.  * edge_unthrottle
  1601.  * this function is called by the tty driver when it wants to resume the data
  1602.  * being read from the port (called after SerialThrottle is called)
  1603.  *****************************************************************************/
  1604. static void edge_unthrottle (struct usb_serial_port *port)
  1605. {
  1606. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1607. struct tty_struct *tty;
  1608. int status;
  1610. dbg("%s - port %d", __FUNCTION__, port->number);
  1612. if (edge_port == NULL)
  1613. return;
  1615. if (!edge_port->open) {
  1616. dbg("%s - port not opened", __FUNCTION__);
  1617. return;
  1618. }
  1620. tty = port->tty;
  1621. if (!tty) {
  1622. dbg ("%s - no tty available", __FUNCTION__);
  1623. return;
  1624. }
  1626. /* if we are implementing XON/XOFF, send the start character */
  1627. if (I_IXOFF(tty)) {
  1628. unsigned char start_char = START_CHAR(tty);
  1629. status = edge_write (port, 0, &start_char, 1);
  1630. if (status <= 0) {
  1631. return;
  1632. }
  1633. }
  1635. /* if we are implementing RTS/CTS, toggle that line */
  1636. if (tty->termios->c_cflag & CRTSCTS) {
  1637. edge_port->shadowMCR |= MCR_RTS;
  1638. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  1639. if (status != 0) {
  1640. return;
  1641. }
  1642. }
  1644. return;
  1645. }
  1648. /*****************************************************************************
  1649.  * SerialSetTermios
  1650.  * this function is called by the tty driver when it wants to change the termios structure
  1651.  *****************************************************************************/
  1652. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios)
  1653. {
  1654. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1655. struct tty_struct *tty = port->tty;
  1656. unsigned int cflag;
  1658. if (!port->tty || !port->tty->termios) {
  1659. dbg ("%s - no tty or termios", __FUNCTION__);
  1660. return;
  1661. }
  1663. cflag = tty->termios->c_cflag;
  1664. /* check that they really want us to change something */
  1665. if (old_termios) {
  1666. if ((cflag == old_termios->c_cflag) &&
  1667.     (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) {
  1668. dbg("%s - nothing to change", __FUNCTION__);
  1669. return;
  1670. }
  1671. }
  1673. dbg("%s - clfag %08x iflag %08x", __FUNCTION__, 
  1674.     tty->termios->c_cflag,
  1675.     RELEVANT_IFLAG(tty->termios->c_iflag));
  1676. if (old_termios) {
  1677. dbg("%s - old clfag %08x old iflag %08x", __FUNCTION__,
  1678.     old_termios->c_cflag,
  1679.     RELEVANT_IFLAG(old_termios->c_iflag));
  1680. }
  1682. dbg("%s - port %d", __FUNCTION__, port->number);
  1684. if (edge_port == NULL)
  1685. return;
  1687. if (!edge_port->open) {
  1688. dbg("%s - port not opened", __FUNCTION__);
  1689. return;
  1690. }
  1692. /* change the port settings to the new ones specified */
  1693. change_port_settings (edge_port, old_termios);
  1695. return;
  1696. }
  1699. /*****************************************************************************
  1700.  * get_lsr_info - get line status register info
  1701.  *
  1702.  * Purpose: Let user call ioctl() to get info when the UART physically
  1703.  *      is emptied.  On bus types like RS485, the transmitter must
  1704.  *      release the bus after transmitting. This must be done when
  1705.  *      the transmit shift register is empty, not be done when the
  1706.  *      transmit holding register is empty.  This functionality
  1707.  *      allows an RS485 driver to be written in user space. 
  1708.  *****************************************************************************/
  1709. static int get_lsr_info(struct edgeport_port *edge_port, unsigned int *value)
  1710. {
  1711. unsigned int result = 0;
  1713. if (edge_port->maxTxCredits == edge_port->txCredits &&
  1714.     edge_port->txfifo.count == 0) {
  1715. dbg("%s -- Empty", __FUNCTION__);
  1716. result = TIOCSER_TEMT;
  1717. }
  1719. if (copy_to_user(value, &result, sizeof(int)))
  1720. return -EFAULT;
  1721. return 0;
  1722. }
  1724. static int get_number_bytes_avail(struct edgeport_port *edge_port, unsigned int *value)
  1725. {
  1726. unsigned int result = 0;
  1727. struct tty_struct *tty = edge_port->port->tty;
  1729. if (!tty)
  1730. return -ENOIOCTLCMD;
  1732. result = tty->read_cnt;
  1734. dbg("%s(%d) = %d", __FUNCTION__,  edge_port->port->number, result);
  1735. if (copy_to_user(value, &result, sizeof(int)))
  1736. return -EFAULT;
  1737. //return 0;
  1738. return -ENOIOCTLCMD;
  1739. }
  1741. static int set_modem_info(struct edgeport_port *edge_port, unsigned int cmd, unsigned int *value)
  1742. {
  1743. unsigned int mcr = edge_port->shadowMCR;
  1744. unsigned int arg;
  1746. if (copy_from_user(&arg, value, sizeof(int)))
  1747. return -EFAULT;
  1749. switch (cmd) {
  1750. case TIOCMBIS:
  1751. if (arg & TIOCM_RTS)
  1752. mcr |= MCR_RTS;
  1753. if (arg & TIOCM_DTR)
  1754. mcr |= MCR_RTS;
  1755. if (arg & TIOCM_LOOP)
  1756. mcr |= MCR_LOOPBACK;
  1757. break;
  1759. case TIOCMBIC:
  1760. if (arg & TIOCM_RTS)
  1761. mcr &= ~MCR_RTS;
  1762. if (arg & TIOCM_DTR)
  1763. mcr &= ~MCR_RTS;
  1764. if (arg & TIOCM_LOOP)
  1765. mcr &= ~MCR_LOOPBACK;
  1766. break;
  1768. case TIOCMSET:
  1769. /* turn off the RTS and DTR and LOOPBACK 
  1770.  * and then only turn on what was asked to */
  1771. mcr &=  ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK);
  1772. mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0);
  1773. mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0);
  1774. mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0);
  1775. break;
  1776. }
  1778. edge_port->shadowMCR = mcr;
  1780. send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  1782. return 0;
  1783. }
  1785. static int get_modem_info(struct edgeport_port *edge_port, unsigned int *value)
  1786. {
  1787. unsigned int result = 0;
  1788. unsigned int msr = edge_port->shadowMSR;
  1789. unsigned int mcr = edge_port->shadowMCR;
  1791. result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0)   /* 0x002 */
  1792.   | ((mcr & MCR_RTS) ? TIOCM_RTS: 0)   /* 0x004 */
  1793.   | ((msr & MSR_CTS) ? TIOCM_CTS: 0)   /* 0x020 */
  1794.   | ((msr & MSR_CD) ? TIOCM_CAR: 0)   /* 0x040 */
  1795.   | ((msr & MSR_RI) ? TIOCM_RI:  0)   /* 0x080 */
  1796.   | ((msr & MSR_DSR) ? TIOCM_DSR: 0);  /* 0x100 */
  1799. dbg("%s -- %x", __FUNCTION__, result);
  1801. if (copy_to_user(value, &result, sizeof(int)))
  1802. return -EFAULT;
  1803. return 0;
  1804. }
  1808. static int get_serial_info(struct edgeport_port *edge_port, struct serial_struct * retinfo)
  1809. {
  1810. struct serial_struct tmp;
  1812. if (!retinfo)
  1813. return -EFAULT;
  1815. memset(&tmp, 0, sizeof(tmp));
  1817. tmp.type = PORT_16550A;
  1818. tmp.line = edge_port->port->serial->minor;
  1819. tmp.port = edge_port->port->number;
  1820. tmp.irq = 0;
  1821. tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
  1822. tmp.xmit_fifo_size = edge_port->maxTxCredits;
  1823. tmp.baud_base = 9600;
  1824. tmp.close_delay = 5*HZ;
  1825. tmp.closing_wait = 30*HZ;
  1826. // tmp.custom_divisor = state->custom_divisor;
  1827. // tmp.hub6 = state->hub6;
  1828. // tmp.io_type = state->io_type;
  1831. if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
  1832. return -EFAULT;
  1833. return 0;
  1834. }
  1838. /*****************************************************************************
  1839.  * SerialIoctl
  1840.  * this function handles any ioctl calls to the driver
  1841.  *****************************************************************************/
  1842. static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
  1843. {
  1844. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1845. struct async_icount cnow;
  1846. struct async_icount cprev;
  1847. struct serial_icounter_struct icount;
  1850. dbg("%s - port %d, cmd = 0x%x", __FUNCTION__, port->number, cmd);
  1852. switch (cmd) {
  1853. // return number of bytes available
  1854. case TIOCINQ:
  1855. dbg("%s (%d) TIOCINQ", __FUNCTION__,  port->number);
  1856. return get_number_bytes_avail(edge_port, (unsigned int *) arg);
  1857. break;
  1859. case TIOCSERGETLSR:
  1860. dbg("%s (%d) TIOCSERGETLSR", __FUNCTION__,  port->number);
  1861. return get_lsr_info(edge_port, (unsigned int *) arg);
  1862. return 0;
  1864. case TIOCMBIS:
  1865. case TIOCMBIC:
  1866. case TIOCMSET:
  1867. dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __FUNCTION__,  port->number);
  1868. return set_modem_info(edge_port, cmd, (unsigned int *) arg);
  1870. case TIOCMGET:  
  1871. dbg("%s (%d) TIOCMGET", __FUNCTION__,  port->number);
  1872. return get_modem_info(edge_port, (unsigned int *) arg);
  1874. case TIOCGSERIAL:
  1875. dbg("%s (%d) TIOCGSERIAL", __FUNCTION__,  port->number);
  1876. return get_serial_info(edge_port, (struct serial_struct *) arg);
  1878. case TIOCSSERIAL:
  1879. dbg("%s (%d) TIOCSSERIAL", __FUNCTION__,  port->number);
  1880. break;
  1882. case TIOCMIWAIT:
  1883. dbg("%s (%d) TIOCMIWAIT", __FUNCTION__,  port->number);
  1884. cprev = edge_port->icount;
  1885. while (1) {
  1886. interruptible_sleep_on(&edge_port->delta_msr_wait);
  1887. /* see if a signal did it */
  1888. if (signal_pending(current))
  1889. return -ERESTARTSYS;
  1890. cnow = edge_port->icount;
  1891. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
  1892.     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  1893. return -EIO; /* no change => error */
  1894. if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  1895.     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  1896.     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  1897.     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
  1898. return 0;
  1899. }
  1900. cprev = cnow;
  1901. }
  1902. /* NOTREACHED */
  1903. break;
  1905. case TIOCGICOUNT:
  1906. cnow = edge_port->icount;
  1907. icount.cts = cnow.cts;
  1908. icount.dsr = cnow.dsr;
  1909. icount.rng = cnow.rng;
  1910. icount.dcd = cnow.dcd;
  1911. icount.rx = cnow.rx;
  1912. icount.tx = cnow.tx;
  1913. icount.frame = cnow.frame;
  1914. icount.overrun = cnow.overrun;
  1915. icount.parity = cnow.parity;
  1916. icount.brk = cnow.brk;
  1917. icount.buf_overrun = cnow.buf_overrun;
  1919. dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __FUNCTION__,  port->number, icount.rx, icount.tx );
  1920. if (copy_to_user((void *)arg, &icount, sizeof(icount)))
  1921. return -EFAULT;
  1922. return 0;
  1923. }
  1925. return -ENOIOCTLCMD;
  1926. }
  1929. /*****************************************************************************
  1930.  * SerialBreak
  1931.  * this function sends a break to the port
  1932.  *****************************************************************************/
  1933. static void edge_break (struct usb_serial_port *port, int break_state)
  1934. {
  1935. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1936. int status;
  1938. /* flush and chase */
  1939. edge_port->chaseResponsePending = TRUE;
  1941. dbg("%s - Sending IOSP_CMD_CHASE_PORT", __FUNCTION__);
  1942. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_CHASE_PORT, 0);
  1943. if (status == 0) {
  1944. // block until chase finished
  1945. block_until_chase_response(edge_port);
  1946. } else {
  1947. edge_port->chaseResponsePending = FALSE;
  1948. }
  1950. if (break_state == -1) {
  1951. dbg("%s - Sending IOSP_CMD_SET_BREAK", __FUNCTION__);
  1952. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_BREAK, 0);
  1953. } else {
  1954. dbg("%s - Sending IOSP_CMD_CLEAR_BREAK", __FUNCTION__);
  1955. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_CLEAR_BREAK, 0);
  1956. }
  1957. if (status) {
  1958. dbg("%s - error sending break set/clear command.", __FUNCTION__);
  1959. }
  1961. return;
  1962. }
  1965. /*****************************************************************************
  1966.  * process_rcvd_data
  1967.  * this function handles the data received on the bulk in pipe.
  1968.  *****************************************************************************/
  1969. static int process_rcvd_data (struct edgeport_serial *edge_serial, unsigned char * buffer, __u16 bufferLength)
  1970. {
  1971. struct usb_serial_port *port;
  1972. struct edgeport_port *edge_port;
  1973. struct tty_struct *tty;
  1974. __u16 lastBufferLength;
  1975. __u16 rxLen;
  1976. int i;
  1978. dbg("%s", __FUNCTION__);
  1980. lastBufferLength = bufferLength + 1;
  1982. while (bufferLength > 0) {
  1983. /* failsafe incase we get a message that we don't understand */
  1984. if (lastBufferLength == bufferLength) {
  1985. dbg("%s - stuck in loop, exiting it.", __FUNCTION__);
  1986. break;
  1987. }
  1988. lastBufferLength = bufferLength;
  1990. switch (edge_serial->rxState) {
  1991. case EXPECT_HDR1:
  1992. edge_serial->rxHeader1 = *buffer;
  1993. ++buffer;
  1994. --bufferLength;
  1996. if (bufferLength == 0) {
  1997. edge_serial->rxState = EXPECT_HDR2;
  1998. break;
  1999. }
  2000. /* otherwise, drop on through */
  2002. case EXPECT_HDR2:
  2003. edge_serial->rxHeader2 = *buffer;
  2004. ++buffer;
  2005. --bufferLength;
  2007. dbg("%s - Hdr1=%02X Hdr2=%02X", __FUNCTION__, edge_serial->rxHeader1, edge_serial->rxHeader2);
  2009. // Process depending on whether this header is
  2010. // data or status
  2012. if (IS_CMD_STAT_HDR(edge_serial->rxHeader1)) {
  2013. // Decode this status header and goto EXPECT_HDR1 (if we
  2014. // can process the status with only 2 bytes), or goto
  2015. // EXPECT_HDR3 to get the third byte.
  2017. edge_serial->rxPort       = IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
  2018. edge_serial->rxStatusCode = IOSP_GET_STATUS_CODE(edge_serial->rxHeader1);
  2020. if (!IOSP_STATUS_IS_2BYTE(edge_serial->rxStatusCode)) {
  2021. // This status needs additional bytes. Save what we have
  2022. // and then wait for more data.
  2023. edge_serial->rxStatusParam = edge_serial->rxHeader2;
  2025. edge_serial->rxState = EXPECT_HDR3;
  2026. break;
  2027. }
  2029. // We have all the header bytes, process the status now
  2030. process_rcvd_status (edge_serial, edge_serial->rxHeader2, 0);
  2032. edge_serial->rxState = EXPECT_HDR1;
  2033. break;
  2034. } else {
  2035. edge_serial->rxPort = IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
  2036. edge_serial->rxBytesRemaining = IOSP_GET_HDR_DATA_LEN(edge_serial->rxHeader1, edge_serial->rxHeader2);
  2038. dbg("%s - Data for Port %u Len %u", __FUNCTION__, edge_serial->rxPort, edge_serial->rxBytesRemaining);
  2040. //ASSERT( DevExt->RxPort < DevExt->NumPorts );
  2041. //ASSERT( DevExt->RxBytesRemaining < IOSP_MAX_DATA_LENGTH );
  2043. if (bufferLength == 0 ) {
  2044. edge_serial->rxState = EXPECT_DATA;
  2045. break;
  2046. }
  2047. // Else, drop through
  2048. }
  2050. case EXPECT_DATA: // Expect data
  2052. if (bufferLength < edge_serial->rxBytesRemaining) {
  2053. rxLen = bufferLength;
  2054. edge_serial->rxState = EXPECT_DATA; // Expect data to start next buffer
  2055. } else {
  2056. // BufLen >= RxBytesRemaining
  2057. rxLen = edge_serial->rxBytesRemaining;
  2058. edge_serial->rxState = EXPECT_HDR1; // Start another header next time
  2059. }
  2061. bufferLength -= rxLen;
  2062. edge_serial->rxBytesRemaining -= rxLen;
  2064. /* spit this data back into the tty driver if this port is open */
  2065. if (rxLen) {
  2066. port = &edge_serial->serial->port[edge_serial->rxPort];
  2067. if (port_paranoia_check (port, __FUNCTION__) == 0) {
  2068. edge_port = (struct edgeport_port *)port->private;
  2069. if (edge_port->open) {
  2070. tty = edge_port->port->tty;
  2071. if (tty) {
  2072. dbg("%s - Sending %d bytes to TTY for port %d", __FUNCTION__, rxLen, edge_serial->rxPort);
  2073. for (i = 0; i < rxLen ; ++i) {
  2074. /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
  2075. if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
  2076. tty_flip_buffer_push(tty);
  2077. }
  2078. /* this doesn't actually push the data through unless tty->low_latency is set */
  2079. tty_insert_flip_char(tty, buffer[i], 0);
  2080. }
  2081. tty_flip_buffer_push(tty);
  2082. }
  2083. edge_port->icount.rx += rxLen;
  2084. }
  2085. }
  2086. buffer += rxLen;
  2087. }
  2089. break;
  2091. case EXPECT_HDR3: // Expect 3rd byte of status header
  2092. edge_serial->rxHeader3 = *buffer;
  2093. ++buffer;
  2094. --bufferLength;
  2096. // We have all the header bytes, process the status now
  2097. process_rcvd_status (edge_serial, edge_serial->rxStatusParam, edge_serial->rxHeader3);
  2098. edge_serial->rxState = EXPECT_HDR1;
  2099. break;
  2101. }
  2102. }
  2104. return 0;
  2105. }
  2108. /*****************************************************************************
  2109.  * process_rcvd_status
  2110.  * this function handles the any status messages received on the bulk in pipe.
  2111.  *****************************************************************************/
  2112. static void process_rcvd_status (struct edgeport_serial *edge_serial, __u8 byte2, __u8 byte3)
  2113. {
  2114. struct usb_serial_port *port;
  2115. struct edgeport_port *edge_port;
  2116. __u8 code = edge_serial->rxStatusCode;
  2118. /* switch the port pointer to the one being currently talked about */
  2119. port = &edge_serial->serial->port[edge_serial->rxPort];
  2120. if (port_paranoia_check (port, __FUNCTION__)) {
  2121. return;
  2122. }
  2123. edge_port = (struct edgeport_port *)port->private;
  2124. if (edge_port == NULL) {
  2125. err("%s - edge_port == NULL for port %d", __FUNCTION__, edge_serial->rxPort);
  2126. return;
  2127. }
  2129. dbg("%s - port %d", __FUNCTION__, edge_serial->rxPort);
  2131. if (code == IOSP_EXT_STATUS) {
  2132. switch (byte2) {
  2133. case IOSP_EXT_STATUS_CHASE_RSP:
  2134. // we want to do EXT status regardless of port open/closed 
  2135. dbg("%s - Port %u EXT CHASE_RSP Data = %02x", __FUNCTION__, edge_serial->rxPort, byte3 );
  2136. // Currently, the only EXT_STATUS is Chase, so process here instead of one more call
  2137. // to one more subroutine. If/when more EXT_STATUS, there'll be more work to do.
  2138. // Also, we currently clear flag and close the port regardless of content of above's Byte3.
  2139. // We could choose to do something else when Byte3 says Timeout on Chase from Edgeport,
  2140. // like wait longer in block_until_chase_response, but for now we don't. 
  2141. edge_port->chaseResponsePending = FALSE;
  2142. wake_up_interruptible (&edge_port->wait_chase);
  2143. return;
  2145. case IOSP_EXT_STATUS_RX_CHECK_RSP:
  2146. dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============n", __FUNCTION__, edge_serial->rxPort, byte3 );
  2147. //Port->RxCheckRsp = TRUE;
  2148. return;
  2149. }
  2150. }
  2152. if (code == IOSP_STATUS_OPEN_RSP) {
  2153. edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3);
  2154. edge_port->maxTxCredits = edge_port->txCredits;
  2155. dbg("%s - Port %u Open Response Inital MSR = %02x TxBufferSize = %d", __FUNCTION__, edge_serial->rxPort, byte2, edge_port->txCredits);
  2156. handle_new_msr (edge_port, byte2);
  2158. /* send the current line settings to the port so we are in sync with any further termios calls */
  2159. if (edge_port->port->tty)
  2160. change_port_settings (edge_port, edge_port->port->tty->termios);
  2162. /* we have completed the open */
  2163. edge_port->openPending = FALSE;
  2164. edge_port->open = TRUE;
  2165. wake_up_interruptible(&edge_port->wait_open);
  2166. return;
  2167. }
  2169. // If port is closed, silently discard all rcvd status. We can
  2170. // have cases where buffered status is received AFTER the close
  2171. // port command is sent to the Edgeport.
  2172. if ((!edge_port->open ) || (edge_port->closePending)) {
  2173. return;
  2174. }
  2176. switch (code) {
  2177. // Not currently sent by Edgeport
  2178. case IOSP_STATUS_LSR:
  2179. dbg("%s - Port %u LSR Status = %02x", __FUNCTION__, edge_serial->rxPort, byte2);
  2180. handle_new_lsr (edge_port, FALSE, byte2, 0);
  2181. break;
  2183. case IOSP_STATUS_LSR_DATA:
  2184. dbg("%s - Port %u LSR Status = %02x, Data = %02x", __FUNCTION__, edge_serial->rxPort, byte2, byte3);
  2185. // byte2 is LSR Register
  2186. // byte3 is broken data byte
  2187. handle_new_lsr (edge_port, TRUE, byte2, byte3);
  2188. break;
  2189. //
  2190. // case IOSP_EXT_4_STATUS:
  2191. // dbg("%s - Port %u LSR Status = %02x Data = %02x", __FUNCTION__, edge_serial->rxPort, byte2, byte3);
  2192. // break;
  2193. //
  2194. case IOSP_STATUS_MSR:
  2195. dbg("%s - Port %u MSR Status = %02x", __FUNCTION__, edge_serial->rxPort, byte2);
  2197. // Process this new modem status and generate appropriate
  2198. // events, etc, based on the new status. This routine
  2199. // also saves the MSR in Port->ShadowMsr.
  2200. handle_new_msr(edge_port, byte2);
  2201. break;
  2203. default:
  2204. dbg("%s - Unrecognized IOSP status code %un", __FUNCTION__, code);
  2205. break;
  2206. }
  2208. return;
  2209. }
  2212. /*****************************************************************************
  2213.  * handle_new_msr
  2214.  * this function handles any change to the msr register for a port.
  2215.  *****************************************************************************/
  2216. static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
  2217. {
  2218. struct  async_icount *icount;
  2220. dbg("%s %02x", __FUNCTION__, newMsr);
  2222. if (newMsr & (MSR_DELTA_CTS | MSR_DELTA_DSR | MSR_DELTA_RI | MSR_DELTA_CD)) {
  2223. icount = &edge_port->icount;
  2225. /* update input line counters */
  2226. if (newMsr & MSR_DELTA_CTS) {
  2227. icount->cts++;
  2228. }
  2229. if (newMsr & MSR_DELTA_DSR) {
  2230. icount->dsr++;
  2231. }
  2232. if (newMsr & MSR_DELTA_CD) {
  2233. icount->dcd++;
  2234. }
  2235. if (newMsr & MSR_DELTA_RI) {
  2236. icount->rng++;
  2237. }
  2238. wake_up_interruptible(&edge_port->delta_msr_wait);
  2239. }
  2241. /* Save the new modem status */
  2242. edge_port->shadowMSR = newMsr & 0xf0;
  2244. return;
  2245. }
  2248. /*****************************************************************************
  2249.  * handle_new_lsr
  2250.  * this function handles any change to the lsr register for a port.
  2251.  *****************************************************************************/
  2252. static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, __u8 lsr, __u8 data)
  2253. {
  2254. __u8    newLsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
  2255. struct  async_icount *icount;
  2257. dbg("%s - %02x", __FUNCTION__, newLsr);
  2259. edge_port->shadowLSR = lsr;
  2261. if (newLsr & LSR_BREAK) {
  2262. //
  2263. // Parity and Framing errors only count if they
  2264. // occur exclusive of a break being
  2265. // received.
  2266. //
  2267. newLsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
  2268. }
  2270. /* Place LSR data byte into Rx buffer */
  2271. if (lsrData && edge_port->port->tty) {
  2272. tty_insert_flip_char(edge_port->port->tty, data, 0);
  2273. tty_flip_buffer_push(edge_port->port->tty);
  2274. }
  2276. /* update input line counters */
  2277. icount = &edge_port->icount;
  2278. if (newLsr & LSR_BREAK) {
  2279. icount->brk++;
  2280. }
  2281. if (newLsr & LSR_OVER_ERR) {
  2282. icount->overrun++;
  2283. }
  2284. if (newLsr & LSR_PAR_ERR) {
  2285. icount->parity++;
  2286. }
  2287. if (newLsr & LSR_FRM_ERR) {
  2288. icount->frame++;
  2289. }
  2291. return;
  2292. }
  2295. /****************************************************************************
  2296.  * sram_write
  2297.  * writes a number of bytes to the Edgeport device's sram starting at the 
  2298.  * given address.
  2299.  * If successful returns the number of bytes written, otherwise it returns
  2300.  * a negative error number of the problem.
  2301.  ****************************************************************************/
  2302. static int sram_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2303. {
  2304. int result;
  2305. __u16 current_length;
  2306. unsigned char *transfer_buffer;
  2308. // dbg("%s - %x, %x, %d", __FUNCTION__, extAddr, addr, length);
  2310. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2311. if (!transfer_buffer) {
  2312. err("%s - kmalloc(%d) failed.n", __FUNCTION__, 64);
  2313. return -ENOMEM;
  2314. }
  2316. /* need to split these writes up into 64 byte chunks */
  2317. result = 0;
  2318. while (length > 0) {
  2319. if (length > 64) {
  2320. current_length = 64;
  2321. } else {
  2322. current_length = length;
  2323. }
  2324. // dbg("%s - writing %x, %x, %d", __FUNCTION__, extAddr, addr, current_length);
  2325. memcpy (transfer_buffer, data, current_length);
  2326. result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), USB_REQUEST_ION_WRITE_RAM, 
  2327.   0x40, addr, extAddr, transfer_buffer, current_length, 300);
  2328. if (result < 0)
  2329. break;
  2330. length -= current_length;
  2331. addr += current_length;
  2332. data += current_length;
  2333. }       
  2335. kfree (transfer_buffer);
  2336. return result;
  2337. }
  2340. /****************************************************************************
  2341.  * rom_write
  2342.  * writes a number of bytes to the Edgeport device's ROM starting at the
  2343.  * given address.
  2344.  * If successful returns the number of bytes written, otherwise it returns
  2345.  * a negative error number of the problem.
  2346.  ****************************************************************************/
  2347. static int rom_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2348. {
  2349. int result;
  2350. __u16 current_length;
  2351. unsigned char *transfer_buffer;
  2353. // dbg("%s - %x, %x, %d", __FUNCTION__, extAddr, addr, length);
  2355. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2356. if (!transfer_buffer) {
  2357. err("%s - kmalloc(%d) failed.n", __FUNCTION__, 64);
  2358. return -ENOMEM;
  2359. }
  2361. /* need to split these writes up into 64 byte chunks */
  2362. result = 0;
  2363. while (length > 0) {
  2364. if (length > 64) {
  2365. current_length = 64;
  2366. } else {
  2367. current_length = length;
  2368. }
  2369. // dbg("%s - writing %x, %x, %d", __FUNCTION__, extAddr, addr, current_length);
  2370. memcpy (transfer_buffer, data, current_length);
  2371. result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), USB_REQUEST_ION_WRITE_ROM, 
  2372.   0x40, addr, extAddr, transfer_buffer, current_length, 300);
  2373. if (result < 0)
  2374. break;
  2375. length -= current_length;
  2376. addr += current_length;
  2377. data += current_length;
  2378. }       
  2380. kfree (transfer_buffer);
  2381. return result;
  2382. }
  2385. /****************************************************************************
  2386.  * rom_read
  2387.  * reads a number of bytes from the Edgeport device starting at the given
  2388.  * address.
  2389.  * If successful returns the number of bytes read, otherwise it returns
  2390.  * a negative error number of the problem.
  2391.  ****************************************************************************/
  2392. static int rom_read (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2393. {
  2394. int result;
  2395. __u16 current_length;
  2396. unsigned char *transfer_buffer;
  2398. dbg("%s - %x, %x, %d", __FUNCTION__, extAddr, addr, length);
  2400. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2401. if (!transfer_buffer) {
  2402. err("%s - kmalloc(%d) failed.n", __FUNCTION__, 64);
  2403. return -ENOMEM;
  2404. }
  2406. /* need to split these reads up into 64 byte chunks */
  2407. result = 0;
  2408. while (length > 0) {
  2409. if (length > 64) {
  2410. current_length = 64;
  2411. } else {
  2412. current_length = length;
  2413. }
  2414. // dbg("%s - %x, %x, %d", __FUNCTION__, extAddr, addr, current_length);
  2415. result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0), USB_REQUEST_ION_READ_ROM, 
  2416.   0xC0, addr, extAddr, transfer_buffer, current_length, 300);
  2417. if (result < 0)
  2418. break;
  2419. memcpy (data, transfer_buffer, current_length);
  2420. length -= current_length;
  2421. addr += current_length;
  2422. data += current_length;
  2423. }       
  2425. kfree (transfer_buffer);
  2426. return result;
  2427. }
  2430. /****************************************************************************
  2431.  * send_iosp_ext_cmd
  2432.  * Is used to send a IOSP message to the Edgeport device
  2433.  ****************************************************************************/
  2434. static int send_iosp_ext_cmd (struct edgeport_port *edge_port, __u8 command, __u8 param)
  2435. {
  2436. unsigned char   *buffer;
  2437. unsigned char   *currentCommand;
  2438. int             length = 0;
  2439. int             status = 0;
  2441. dbg("%s - %d, %d", __FUNCTION__, command, param);
  2443. buffer =  kmalloc (10, GFP_ATOMIC);
  2444. if (!buffer) {
  2445. err("%s - kmalloc(%d) failed.n", __FUNCTION__, 10);
  2446. return -ENOMEM;
  2447. }
  2449. currentCommand = buffer;
  2451. MAKE_CMD_EXT_CMD (&currentCommand, &length,
  2452.   edge_port->port->number - edge_port->port->serial->minor,
  2453.   command, param);
  2455. status = write_cmd_usb (edge_port, buffer, length);
  2456. if (status) {
  2457. /* something bad happened, let's free up the memory */
  2458. kfree(buffer);
  2459. }
  2461. return status;
  2462. }
  2465. /*****************************************************************************
  2466.  * write_cmd_usb
  2467.  * this function writes the given buffer out to the bulk write endpoint.
  2468.  *****************************************************************************/
  2469. static int write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer, int length)
  2470. {
  2471. struct edgeport_serial *edge_serial = (struct edgeport_serial *)edge_port->port->serial->private;
  2472. int status = 0;
  2473. struct urb *urb;
  2474. int timeout;
  2476. usb_serial_debug_data (__FILE__, __FUNCTION__, length, buffer);
  2478. /* Allocate our next urb */
  2479. urb = usb_alloc_urb (0);
  2480. if (!urb)
  2481. return -ENOMEM;
  2483. CmdUrbs++;
  2484. dbg("%s - ALLOCATE URB %p (outstanding %d)", __FUNCTION__, urb, CmdUrbs);
  2486. FILL_BULK_URB (urb, edge_serial->serial->dev, 
  2487.        usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
  2488.        buffer, length, edge_bulk_out_cmd_callback, edge_port);
  2490. /* set the USB_BULK_QUEUE flag so that we can shove a bunch of urbs at once down the pipe */
  2491. urb->transfer_flags |= USB_QUEUE_BULK;
  2493. edge_port->commandPending = TRUE;
  2494. status = usb_submit_urb(urb);
  2496. if (status) {
  2497. /* something went wrong */
  2498. dbg("%s - usb_submit_urb(write bulk) failed", __FUNCTION__);
  2499. usb_unlink_urb (urb);
  2500. usb_free_urb   (urb);
  2501. return status;
  2502. }
  2504. // wait for command to finish
  2505. timeout = COMMAND_TIMEOUT;
  2506. #if 0
  2507. while (timeout && edge_port->commandPending == TRUE) {
  2508. timeout = interruptible_sleep_on_timeout (&edge_port->wait_command, timeout);
  2509. }
  2511. if (edge_port->commandPending == TRUE) {
  2512. /* command timed out */
  2513. dbg("%s - command timed out", __FUNCTION__);
  2514. status = -EINVAL;
  2515. }
  2516. #endif
  2517. return status;
  2518. }
  2521. /*****************************************************************************
  2522.  * send_cmd_write_baud_rate
  2523.  * this function sends the proper command to change the baud rate of the
  2524.  * specified port.
  2525.  *****************************************************************************/
  2526. static int send_cmd_write_baud_rate (struct edgeport_port *edge_port, int baudRate)
  2527. {
  2528. unsigned char *cmdBuffer;
  2529. unsigned char *currCmd;
  2530. int cmdLen = 0;
  2531. int divisor;
  2532. int status;
  2533. unsigned char number = edge_port->port->number - edge_port->port->serial->minor;
  2535. dbg("%s - port = %d, baud = %d", __FUNCTION__, edge_port->port->number, baudRate);
  2537. status = calc_baud_rate_divisor (baudRate, &divisor);
  2538. if (status) {
  2539. err("%s - bad baud rate", __FUNCTION__);
  2540. return status;
  2541. }
  2543. // Alloc memory for the string of commands.
  2544. cmdBuffer =  kmalloc (0x100, GFP_ATOMIC);
  2545. if (!cmdBuffer) {
  2546. err("%s - kmalloc(%d) failed.n", __FUNCTION__, 0x100);
  2547. return -ENOMEM;
  2548. }
  2549. currCmd = cmdBuffer;
  2551. // Enable access to divisor latch
  2552. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, LCR, LCR_DL_ENABLE );
  2554. // Write the divisor itself
  2555. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, DLL, LOW8 (divisor) );
  2556. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, DLM, HIGH8(divisor) );
  2558. // Restore original value to disable access to divisor latch
  2559. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, LCR, edge_port->shadowLCR);
  2561. status = write_cmd_usb(edge_port, cmdBuffer, cmdLen );
  2562. if (status) {
  2563. /* something bad happened, let's free up the memory */
  2564. kfree (cmdBuffer);
  2565. }
  2567. return status;
  2568. }
  2571. /*****************************************************************************
  2572.  * calc_baud_rate_divisor
  2573.  * this function calculates the proper baud rate divisor for the specified
  2574.  * baud rate.
  2575.  *****************************************************************************/
  2576. static int calc_baud_rate_divisor (int baudrate, int *divisor)
  2577. {
  2578. int i;
  2579. __u16 custom;
  2580. __u16 round1;
  2581. __u16 round;
  2584. dbg("%s - %d", __FUNCTION__, baudrate);
  2586. for (i = 0; i < NUM_ENTRIES(divisor_table); i++) {
  2587. if ( divisor_table[i].BaudRate == baudrate ) {
  2588. *divisor = divisor_table[i].Divisor;
  2589. return 0;
  2590. }
  2591. }
  2593. // We have tried all of the standard baud rates
  2594. // lets try to calculate the divisor for this baud rate
  2595. // Make sure the baud rate is reasonable
  2596. if (baudrate > 75 &&  baudrate < 230400) {
  2597. // get divisor
  2598. custom = (__u16)(230400L  / baudrate);
  2600. // Check for round off
  2601. round1 = (__u16)(2304000L / baudrate);
  2602. round = (__u16)(round1 - (custom * 10));
  2603. if (round > 4) {
  2604. custom++;
  2605. }
  2606. *divisor = custom;
  2608. dbg("%s - Baud %d = %dn", __FUNCTION__, baudrate, custom);
  2609. return 0;
  2610. }
  2612. return -1;
  2613. }
  2616. /*****************************************************************************
  2617.  * send_cmd_write_uart_register
  2618.  * this function builds up a uart register message and sends to to the device.
  2619.  *****************************************************************************/
  2620. static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue)
  2621. {
  2622. unsigned char *cmdBuffer;
  2623. unsigned char *currCmd;
  2624. unsigned long cmdLen = 0;
  2625. int status;
  2627. dbg("%s - write to %s register 0x%02x", (regNum == MCR) ? "MCR" : "LCR", __FUNCTION__, regValue);
  2629. // Alloc memory for the string of commands.
  2630. cmdBuffer = kmalloc (0x10, GFP_ATOMIC);
  2631. if (cmdBuffer == NULL ) {
  2632. return -ENOMEM;
  2633. }
  2635. currCmd = cmdBuffer;
  2637. // Build a cmd in the buffer to write the given register
  2638. MAKE_CMD_WRITE_REG (&currCmd, &cmdLen,
  2639.     edge_port->port->number - edge_port->port->serial->minor,
  2640.     regNum, regValue);
  2642. status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
  2643. if (status) {
  2644. /* something bad happened, let's free up the memory */
  2645. kfree (cmdBuffer);
  2646. }
  2648. return status;
  2649. }
  2652. /*****************************************************************************
  2653.  * change_port_settings
  2654.  * This routine is called to set the UART on the device to match the specified
  2655.  * new settings.
  2656.  *****************************************************************************/
  2657. static void change_port_settings (struct edgeport_port *edge_port, struct termios *old_termios)
  2658. {
  2659. struct tty_struct *tty;
  2660. int baud;
  2661. unsigned cflag;
  2662. __u8 mask = 0xff;
  2663. __u8 lData;
  2664. __u8 lParity;
  2665. __u8 lStop;
  2666. __u8 rxFlow;
  2667. __u8 txFlow;
  2668. int status;
  2670. dbg("%s - port %d", __FUNCTION__, edge_port->port->number);
  2672. if ((!edge_port->open) &&
  2673.     (!edge_port->openPending)) {
  2674. dbg("%s - port not opened", __FUNCTION__);
  2675. return;
  2676. }
  2678. tty = edge_port->port->tty;
  2679. if ((!tty) ||
  2680.     (!tty->termios)) {
  2681. dbg("%s - no tty structures", __FUNCTION__);
  2682. return;
  2683. }
  2685. cflag = tty->termios->c_cflag;
  2687. switch (cflag & CSIZE) {
  2688. case CS5:   lData = LCR_BITS_5; mask = 0x1f;    dbg("%s - data bits = 5", __FUNCTION__);   break;
  2689. case CS6:   lData = LCR_BITS_6; mask = 0x3f;    dbg("%s - data bits = 6", __FUNCTION__);   break;
  2690. case CS7:   lData = LCR_BITS_7; mask = 0x7f;    dbg("%s - data bits = 7", __FUNCTION__);   break;
  2691. default:
  2692. case CS8:   lData = LCR_BITS_8;                 dbg("%s - data bits = 8", __FUNCTION__);   break;
  2693. }
  2695. lParity = LCR_PAR_NONE;
  2696. if (cflag & PARENB) {
  2697. if (cflag & PARODD) {
  2698. lParity = LCR_PAR_ODD;
  2699. dbg("%s - parity = odd", __FUNCTION__);
  2700. } else {
  2701. lParity = LCR_PAR_EVEN;
  2702. dbg("%s - parity = even", __FUNCTION__);
  2703. }
  2704. } else {
  2705. dbg("%s - parity = none", __FUNCTION__);
  2706. }
  2708. if (cflag & CSTOPB) {
  2709. lStop = LCR_STOP_2;
  2710. dbg("%s - stop bits = 2", __FUNCTION__);
  2711. } else {
  2712. lStop = LCR_STOP_1;
  2713. dbg("%s - stop bits = 1", __FUNCTION__);
  2714. }
  2716. /* figure out the flow control settings */
  2717. rxFlow = txFlow = 0x00;
  2718. if (cflag & CRTSCTS) {
  2719. rxFlow |= IOSP_RX_FLOW_RTS;
  2720. txFlow |= IOSP_TX_FLOW_CTS;
  2721. dbg("%s - RTS/CTS is enabled", __FUNCTION__);
  2722. } else {
  2723. dbg("%s - RTS/CTS is disabled", __FUNCTION__);
  2724. }
  2726. /* if we are implementing XON/XOFF, set the start and stop character in the device */
  2727. if (I_IXOFF(tty) || I_IXON(tty)) {
  2728. unsigned char stop_char  = STOP_CHAR(tty);
  2729. unsigned char start_char = START_CHAR(tty);
  2731. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_XON_CHAR, start_char);
  2732. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_XOFF_CHAR, stop_char);
  2734. /* if we are implementing INBOUND XON/XOFF */
  2735. if (I_IXOFF(tty)) {
  2736. rxFlow |= IOSP_RX_FLOW_XON_XOFF;
  2737. dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x", __FUNCTION__, start_char, stop_char);
  2738. } else {
  2739. dbg("%s - INBOUND XON/XOFF is disabled", __FUNCTION__);
  2740. }
  2742. /* if we are implementing OUTBOUND XON/XOFF */
  2743. if (I_IXON(tty)) {
  2744. txFlow |= IOSP_TX_FLOW_XON_XOFF;
  2745. dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x", __FUNCTION__, start_char, stop_char);
  2746. } else {
  2747. dbg("%s - OUTBOUND XON/XOFF is disabled", __FUNCTION__);
  2748. }
  2749. }
  2751. /* Set flow control to the configured value */
  2752. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_RX_FLOW, rxFlow);
  2753. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_TX_FLOW, txFlow);
  2756. edge_port->shadowLCR &= ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
  2757. edge_port->shadowLCR |= (lData | lParity | lStop);
  2759. edge_port->validDataMask = mask;
  2761. /* Send the updated LCR value to the EdgePort */
  2762. status = send_cmd_write_uart_register(edge_port, LCR, edge_port->shadowLCR);
  2763. if (status != 0) {
  2764. return;
  2765. }
  2767. /* set up the MCR register and send it to the EdgePort */
  2768. edge_port->shadowMCR = MCR_MASTER_IE;
  2769. if (cflag & CBAUD) {
  2770. edge_port->shadowMCR |= (MCR_DTR | MCR_RTS);
  2771. }
  2772. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  2773. if (status != 0) {
  2774. return;
  2775. }
  2777. /* Determine divisor based on baud rate */
  2778. baud = tty_get_baud_rate(tty);
  2779. if (!baud) {
  2780. /* pick a default, any default... */
  2781. baud = 9600;
  2782. }
  2784. dbg("%s - baud rate = %d", __FUNCTION__, baud);
  2785. status = send_cmd_write_baud_rate (edge_port, baud);
  2787. return;
  2788. }
  2791. /****************************************************************************
  2792.  * unicode_to_ascii
  2793.  * Turns a string from Unicode into ASCII.
  2794.  * Doesn't do a good job with any characters that are outside the normal
  2795.  * ASCII range, but it's only for debugging...
  2796.  ****************************************************************************/
  2797. static void unicode_to_ascii (char *string, short *unicode, int unicode_size)
  2798. {
  2799. int i;
  2800. for (i = 0; i < unicode_size; ++i) {
  2801. string[i] = (char)(unicode[i]);
  2802. }
  2803. string[unicode_size] = 0x00;
  2804. }
  2807. /****************************************************************************
  2808.  * get_manufacturing_desc
  2809.  * reads in the manufacturing descriptor and stores it into the serial 
  2810.  * structure.
  2811.  ****************************************************************************/
  2812. static void get_manufacturing_desc (struct edgeport_serial *edge_serial)
  2813. {
  2814. int response;
  2816. dbg("getting manufacturer descriptor");
  2818. response = rom_read (edge_serial->serial, (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16, 
  2819.     (__u16)(EDGE_MANUF_DESC_ADDR & 0x0000ffff), EDGE_MANUF_DESC_LEN,
  2820.     (__u8 *)(&edge_serial->manuf_descriptor));
  2822. if (response < 1) {
  2823. err("error in getting manufacturer descriptor");
  2824. } else {
  2825. char string[30];
  2826. dbg("**Manufacturer Descriptor");
  2827. dbg("  RomSize:        %dK", edge_serial->manuf_descriptor.RomSize);
  2828. dbg("  RamSize:        %dK", edge_serial->manuf_descriptor.RamSize);
  2829. dbg("  CpuRev:         %d", edge_serial->manuf_descriptor.CpuRev);
  2830. dbg("  BoardRev:       %d", edge_serial->manuf_descriptor.BoardRev);
  2831. dbg("  NumPorts:       %d", edge_serial->manuf_descriptor.NumPorts);
  2832. dbg("  DescDate:       %d/%d/%d", edge_serial->manuf_descriptor.DescDate[0], edge_serial->manuf_descriptor.DescDate[1], edge_serial->manuf_descriptor.DescDate[2]+1900);
  2833. unicode_to_ascii (string, edge_serial->manuf_descriptor.SerialNumber, edge_serial->manuf_descriptor.SerNumLength/2-1);
  2834. dbg("  SerialNumber: %s", string);
  2835. unicode_to_ascii (string, edge_serial->manuf_descriptor.AssemblyNumber, edge_serial->manuf_descriptor.AssemblyNumLength/2-1);
  2836. dbg("  AssemblyNumber: %s", string);
  2837. unicode_to_ascii (string, edge_serial->manuf_descriptor.OemAssyNumber, edge_serial->manuf_descriptor.OemAssyNumLength/2-1);
  2838. dbg("  OemAssyNumber:  %s", string);
  2839. dbg("  UartType:       %d", edge_serial->manuf_descriptor.UartType);
  2840. dbg("  IonPid:         %d", edge_serial->manuf_descriptor.IonPid);
  2841. dbg("  IonConfig:      %d", edge_serial->manuf_descriptor.IonConfig);
  2842. }
  2843. }
  2846. /****************************************************************************
  2847.  * get_boot_desc
  2848.  * reads in the bootloader descriptor and stores it into the serial 
  2849.  * structure.
  2850.  ****************************************************************************/
  2851. static void get_boot_desc (struct edgeport_serial *edge_serial)
  2852. {
  2853. int response;
  2855. dbg("getting boot descriptor");
  2857. response = rom_read (edge_serial->serial, (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16, 
  2858.     (__u16)(EDGE_BOOT_DESC_ADDR & 0x0000ffff), EDGE_BOOT_DESC_LEN,
  2859.     (__u8 *)(&edge_serial->boot_descriptor));
  2861. if (response < 1) {
  2862. err("error in getting boot descriptor");
  2863. } else {
  2864. dbg("**Boot Descriptor:");
  2865. dbg("  BootCodeLength: %d", edge_serial->boot_descriptor.BootCodeLength);
  2866. dbg("  MajorVersion:   %d", edge_serial->boot_descriptor.MajorVersion);
  2867. dbg("  MinorVersion:   %d", edge_serial->boot_descriptor.MinorVersion);
  2868. dbg("  BuildNumber:    %d", edge_serial->boot_descriptor.BuildNumber);
  2869. dbg("  Capabilities:   0x%x", edge_serial->boot_descriptor.Capabilities);
  2870. dbg("  UConfig0:       %d", edge_serial->boot_descriptor.UConfig0);
  2871. dbg("  UConfig1:       %d", edge_serial->boot_descriptor.UConfig1);
  2872. }
  2873. }
  2876. /****************************************************************************
  2877.  * load_application_firmware
  2878.  * This is called to load the application firmware to the device
  2879.  ****************************************************************************/
  2880. static void load_application_firmware (struct edgeport_serial *edge_serial)
  2881. {
  2882. struct edge_firmware_image_record *record;
  2883. unsigned char *firmware;
  2884. unsigned char *FirmwareImage;
  2885. int ImageSize;
  2886. int response;
  2889. switch (edge_serial->product_info.iDownloadFile) {
  2890. case EDGE_DOWNLOAD_FILE_I930:
  2891. dbg("downloading firmware version (930) %d.%d.%d", 
  2892.     OperationalCodeImageVersion_GEN1.MajorVersion, 
  2893.     OperationalCodeImageVersion_GEN1.MinorVersion, 
  2894.     OperationalCodeImageVersion_GEN1.BuildNumber);
  2895. firmware = &OperationalCodeImage_GEN1[0];
  2896. FirmwareImage = &OperationalCodeImage_GEN1[0];
  2897. ImageSize = sizeof(OperationalCodeImage_GEN1);
  2898. break;
  2900. case EDGE_DOWNLOAD_FILE_80251:
  2901. dbg("downloading firmware version (80251) %d.%d.%d", 
  2902.     OperationalCodeImageVersion_GEN2.MajorVersion, 
  2903.     OperationalCodeImageVersion_GEN2.MinorVersion, 
  2904.     OperationalCodeImageVersion_GEN2.BuildNumber);
  2905. firmware = &OperationalCodeImage_GEN2[0];
  2906. FirmwareImage = &OperationalCodeImage_GEN2[0];
  2907. ImageSize = sizeof(OperationalCodeImage_GEN2);
  2908. break;
  2910. case EDGE_DOWNLOAD_FILE_NONE:
  2911. dbg     ("No download file specified, skipping downloadn");
  2912. return;
  2914. default:
  2915. return;
  2916. }
  2919. for (;;) {
  2920. record = (struct edge_firmware_image_record *)firmware;
  2921. response = sram_write (edge_serial->serial, record->ExtAddr, record->Addr, record->Len, &record->Data[0]);
  2922. if (response < 0) {
  2923. err("sram_write failed (%x, %x, %d)", record->ExtAddr, record->Addr, record->Len);
  2924. break;
  2925. }
  2926. firmware += sizeof (struct edge_firmware_image_record) + record->Len;
  2927. if (firmware >= &FirmwareImage[ImageSize]) {
  2928. break;
  2929. }
  2930. }
  2932. dbg("sending exec_dl_code");
  2933. response = usb_control_msg (edge_serial->serial->dev, 
  2934.     usb_sndctrlpipe(edge_serial->serial->dev, 0), 
  2935.     USB_REQUEST_ION_EXEC_DL_CODE, 
  2936.     0x40, 0x4000, 0x0001, NULL, 0, 3000);
  2938. return;
  2939. }
  2944. /****************************************************************************
  2945.  * edge_startup
  2946.  ****************************************************************************/
  2947. static int edge_startup (struct usb_serial *serial)
  2948. {
  2949. struct edgeport_serial *edge_serial;
  2950. struct edgeport_port *edge_port;
  2951. struct usb_device *dev;
  2952. int i;
  2954. dev = serial->dev;
  2956. /* create our private serial structure */
  2957. edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
  2958. if (edge_serial == NULL) {
  2959. err("%s - Out of memory", __FUNCTION__);
  2960. return -ENOMEM;
  2961. }
  2962. memset (edge_serial, 0, sizeof(struct edgeport_serial));
  2963. edge_serial->serial = serial;
  2964. serial->private = edge_serial;
  2966. /* get the name for the device from the device */
  2967. if ( (i = get_string(dev, dev->descriptor.iManufacturer, &edge_serial->name[0])) != 0) {
  2968. edge_serial->name[i-1] = ' ';
  2969. }
  2971. get_string(dev, dev->descriptor.iProduct, &edge_serial->name[i]);
  2973. info("%s detected", edge_serial->name);
  2975. /* get the manufacturing descriptor for this device */
  2976. get_manufacturing_desc (edge_serial);
  2978. /* get the boot descriptor */
  2979. get_boot_desc (edge_serial);
  2981. get_product_info(edge_serial);
  2983. /* set the number of ports from the manufacturing description */
  2984. /* serial->num_ports = serial->product_info.NumPorts; */
  2985. if (edge_serial->product_info.NumPorts != serial->num_ports) {
  2986. warn("%s - Device Reported %d serial ports vs core "
  2987.      "thinking we have %d ports, email greg@kroah.com this info.",
  2988.      __FUNCTION__, edge_serial->product_info.NumPorts, 
  2989.      serial->num_ports);
  2990. }
  2992. dbg("%s - time 1 %ld", __FUNCTION__, jiffies);
  2994. /* now load the application firmware into this device */
  2995. load_application_firmware (edge_serial);
  2997. dbg("%s - time 2 %ld", __FUNCTION__, jiffies);
  2999. /* Check current Edgeport EEPROM and update if necessary */
  3000. update_edgeport_E2PROM (edge_serial);
  3002. dbg("%s - time 3 %ld", __FUNCTION__, jiffies);
  3004. /* set the configuration to use #1 */
  3005. // dbg("set_configuration 1");
  3006. // usb_set_configuration (dev, 1);
  3008. /* we set up the pointers to the endpoints in the edge_open function, 
  3009.  * as the structures aren't created yet. */
  3011. /* set up our port private structures */
  3012. for (i = 0; i < serial->num_ports; ++i) {
  3013. edge_port = kmalloc (sizeof(struct edgeport_port), GFP_KERNEL);
  3014. if (edge_port == NULL) {
  3015. err("%s - Out of memory", __FUNCTION__);
  3016. return -ENOMEM;
  3017. }
  3018. memset (edge_port, 0, sizeof(struct edgeport_port));
  3019. edge_port->port = &serial->port[i];
  3020. serial->port[i].private = edge_port;
  3021. }
  3023. return 0;
  3024. }
  3028. /****************************************************************************
  3029.  * edge_shutdown
  3030.  * This function is called whenever the device is removed from the usb bus.
  3031.  ****************************************************************************/
  3032. static void edge_shutdown (struct usb_serial *serial)
  3033. {
  3034. int i;
  3036. dbg("%s", __FUNCTION__);
  3038. /* stop reads and writes on all ports */
  3039. for (i=0; i < serial->num_ports; ++i) {
  3040. kfree (serial->port[i].private);
  3041. serial->port[i].private = NULL;
  3042. }
  3043. kfree (serial->private);
  3044. serial->private = NULL;
  3045. }
  3048. /****************************************************************************
  3049.  * edgeport_init
  3050.  * This is called by the module subsystem, or on startup to initialize us
  3051.  ****************************************************************************/
  3052. int __init edgeport_init(void)
  3053. {
  3054. usb_serial_register (&edgeport_1port_device);
  3055. usb_serial_register (&edgeport_2port_device);
  3056. usb_serial_register (&edgeport_4port_device);
  3057. usb_serial_register (&edgeport_8port_device);
  3058. info(DRIVER_DESC " " DRIVER_VERSION);
  3059. return 0;
  3060. }
  3064. /****************************************************************************
  3065.  * edgeport_exit
  3066.  * Called when the driver is about to be unloaded.
  3067.  ****************************************************************************/
  3068. void __exit edgeport_exit (void)
  3069. {
  3070. usb_serial_deregister (&edgeport_1port_device);
  3071. usb_serial_deregister (&edgeport_2port_device);
  3072. usb_serial_deregister (&edgeport_4port_device);
  3073. usb_serial_deregister (&edgeport_8port_device);
  3074. }
  3076. module_init(edgeport_init);
  3077. module_exit(edgeport_exit);
  3079. /* Module information */
  3080. MODULE_AUTHOR( DRIVER_AUTHOR );
  3081. MODULE_DESCRIPTION( DRIVER_DESC );
  3082. MODULE_LICENSE("GPL");
  3084. MODULE_PARM(debug, "i");
  3085. MODULE_PARM_DESC(debug, "Debug enabled or not");