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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
io_edgeport.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：96k
源码类别：

嵌入式Linux

开发平台：

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 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.2 2001_11_14 greg kroah-hartman
  29.  * - fixed bug in edge_close that kept the port from being used more
  30.  *   than once.
  31.  * - fixed memory leak on device removal.
  32.  * - fixed potential double free of memory when command urb submitting
  33.  *   failed.
  34.  * - other small cleanups when the device is removed
  35.  *
  36.  * 2.1 2001_07_09 greg kroah-hartman
  37.  * - added support for TIOCMBIS and TIOCMBIC.
  38.  *
  39.  *     (04/08/2001) gb
  40.  * - Identify version on module load.
  41.  *
  42.  * 2.0 2001_03_05 greg kroah-hartman
  43.  * - reworked entire driver to fit properly in with the other usb-serial
  44.  *   drivers.  Occasional oopses still happen, but it's a good start.
  45.  *
  46.  * 1.2.3 (02/23/2001) greg kroah-hartman
  47.  * - changed device table to work properly for 2.4.x final format.
  48.  * - fixed problem with dropping data at high data rates.
  49.  *
  50.  * 1.2.2 (11/27/2000) greg kroah-hartman
  51.  * - cleaned up more NTisms.
  52.  * - Added device table for 2.4.0-test11
  53.  *
  54.  * 1.2.1 (11/08/2000) greg kroah-hartman
  55.  * - Started to clean up NTisms.
  56.  * - Fixed problem with dev field of urb for kernels >= 2.4.0-test9
  57.  *
  58.  * 1.2 (10/17/2000) David Iacovelli
  59.  *  Remove all EPIC code and GPL source
  60.  *  Fix RELEVANT_IFLAG macro to include flow control 
  61.  *  changes port configuration changes.
  62.  *  Fix redefinition of SERIAL_MAGIC
  63.  *  Change all timeout values to 5 seconds
  64.  *  Tried to fix the UHCI multiple urb submission, but failed miserably.
  65.  *  it seems to work fine with OHCI.
  66.  *  ( Greg take a look at the #if 0 at end of WriteCmdUsb() we must 
  67.  *    find a way to work arount this UHCI bug )
  68.  *
  69.  * 1.1 (10/11/2000) David Iacovelli
  70.  *  Fix XON/XOFF flow control to support both IXON and IXOFF
  71.  *
  72.  * 0.9.27 (06/30/2000) David Iacovelli
  73.  *  Added transmit queue and now allocate urb for command writes.
  74.  *
  75.  * 0.9.26 (06/29/2000) David Iacovelli
  76.  *  Add support for 80251 based edgeport
  77.  *
  78.  * 0.9.25 (06/27/2000) David Iacovelli
  79.  *  Do not close the port if it has multiple opens.
  80.  *
  81.  * 0.9.24 (05/26/2000) David Iacovelli
  82.  *  Add IOCTLs to support RXTX and JAVA POS 
  83.  *  and first cut at running BlackBox Demo
  84.  *
  85.  * 0.9.23 (05/24/2000) David Iacovelli
  86.  *  Add IOCTLs to support RXTX and JAVA POS
  87.  *
  88.  * 0.9.22 (05/23/2000) David Iacovelli
  89.  *  fixed bug in enumeration.  If epconfig turns on mapping by
  90.  *  path after a device is already plugged in, we now update
  91.  *  the mapping correctly
  92.  *
  93.  * 0.9.21 (05/16/2000) David Iacovelli
  94.  *  Added BlockUntilChaseResp() to also wait for txcredits
  95.  *  Updated the way we allocate and handle write URBs 
  96.  * Add debug code to dump buffers
  97.  *
  98.  * 0.9.20 (05/01/2000) David Iacovelli
  99.  * change driver to use usb/tts/
  100.  *
  101.  * 0.9.19 (05/01/2000) David Iacovelli
  102.  *  Update code to compile if DEBUG is off
  103.  *
  104.  * 0.9.18 (04/28/2000) David Iacovelli
  105.  *  cleanup and test tty_register with devfs
  106.  *
  107.  * 0.9.17 (04/27/2000) greg kroah-hartman
  108.  *  changed tty_register around to be like the way it
  109.  *  was before, but now it works properly with devfs.
  110.  *
  111.  * 0.9.16 (04/26/2000) david iacovelli
  112.  *  Fixed bug in GetProductInfo()
  113.  *
  114.  * 0.9.15 (04/25/2000) david iacovelli
  115.  * Updated enumeration
  116.  *
  117.  * 0.9.14 (04/24/2000) david iacovelli
  118.  *  Removed all config/status IOCTLS and 
  119.  *  converted to using /proc/edgeport
  120.  *  still playing with devfs
  121.  *
  122.  * 0.9.13 (04/24/2000) david iacovelli
  123.  *  Removed configuration based on ttyUSB0
  124.  *  Added support for configuration using /prod/edgeport
  125.  *  first attempt at using devfs (not working yet!)
  126.  *  Added IOCTL to GetProductInfo()
  127.  *  Added support for custom baud rates
  128.  * Add support for random port numbers
  129.  *
  130.  * 0.9.12 (04/18/2000) david iacovelli
  131.  * added additional configuration IOCTLs
  132.  *  use ttyUSB0 for configuration
  133.  *
  134.  * 0.9.11 (04/17/2000) greg kroah-hartman
  135.  * fixed module initialization race conditions.
  136.  * made all urbs dynamically allocated.
  137.  * made driver devfs compatible. now it only registers the tty device
  138.  * when the device is actually plugged in.
  139.  *
  140.  * 0.9.10 (04/13/2000) greg kroah-hartman
  141.  * added proc interface framework.
  142.  *
  143.  * 0.9.9 (04/13/2000) david iacovelli
  144.  * added enumeration code and ioctls to configure the device
  145.  *
  146.  * 0.9.8 (04/12/2000) david iacovelli
  147.  *  Change interrupt read start when device is plugged in
  148.  *  and stop when device is removed
  149.  * process interrupt reads when all ports are closed 
  150.  *  (keep value of rxBytesAvail consistent with the edgeport)
  151.  *  set the USB_BULK_QUEUE flag so that we can shove a bunch 
  152.  *  of urbs at once down the pipe 
  153.  *
  154.  * 0.9.7 (04/10/2000) david iacovelli
  155.  *  start to add enumeration code.
  156.  *  generate serial number for epic devices
  157.  *  add support for kdb
  158.  *
  159.  * 0.9.6 (03/30/2000) david iacovelli
  160.  *  add IOCTL to get string, manufacture, and boot descriptors
  161.  *
  162.  * 0.9.5 (03/14/2000) greg kroah-hartman
  163.  * more error checking added to SerialOpen to try to fix UHCI open problem
  164.  *
  165.  * 0.9.4 (03/09/2000) greg kroah-hartman
  166.  * added more error checking to handle oops when data is hanging
  167.  * around and tty is abruptly closed.
  168.  *
  169.  * 0.9.3 (03/09/2000) david iacovelli
  170.  * Add epic support for xon/xoff chars
  171.  * play with performance
  172.  *
  173.  * 0.9.2 (03/08/2000) greg kroah-hartman
  174.  * changed most "info" calls to "dbg"
  175.  * implemented flow control properly in the termios call
  176.  *
  177.  * 0.9.1 (03/08/2000) david iacovelli
  178.  * added EPIC support
  179.  * enabled bootloader update
  180.  *
  181.  * 0.9 (03/08/2000) greg kroah-hartman
  182.  * Release to IO networks.
  183.  * Integrated changes that David made
  184.  *  made getting urbs for writing SMP safe
  185.  *
  186.  * 0.8 (03/07/2000) greg kroah-hartman
  187.  * Release to IO networks.
  188.  * Fixed problems that were seen in code by David.
  189.  *  Now both Edgeport/4 and Edgeport/2 works properly.
  190.  *  Changed most of the functions to use port instead of serial.
  191.  *
  192.  * 0.7 (02/27/2000) greg kroah-hartman
  193.  * Milestone 3 release.
  194.  * Release to IO Networks
  195.  * ioctl for waiting on line change implemented.
  196.  * ioctl for getting statistics implemented.
  197.  * multiport support working.
  198.  * lsr and msr registers are now handled properly.
  199.  * change break now hooked up and working.
  200.  * support for all known Edgeport devices.
  201.  *
  202.  * 0.6 (02/22/2000) greg kroah-hartman
  203.  * Release to IO networks.
  204.  * CHASE is implemented correctly when port is closed.
  205.  * SerialOpen now blocks correctly until port is fully opened.
  206.  *
  207.  * 0.5 (02/20/2000) greg kroah-hartman
  208.  * Release to IO networks.
  209.  * Known problems:
  210.  * modem status register changes are not sent on to the user
  211.  * CHASE is not implemented when the port is closed.
  212.  *
  213.  * 0.4 (02/16/2000) greg kroah-hartman
  214.  * Second cut at the CeBit demo.
  215.  * Doesn't leak memory on every write to the port
  216.  * Still small leaks on startup.
  217.  * Added support for Edgeport/2 and Edgeport/8
  218.  *
  219.  * 0.3 (02/15/2000) greg kroah-hartman
  220.  * CeBit demo release.
  221.  * Force the line settings to 4800, 8, 1, e for the demo.
  222.  * Warning! This version leaks memory like crazy!
  223.  *
  224.  * 0.2 (01/30/2000) greg kroah-hartman
  225.  * Milestone 1 release.
  226.  * Device is found by USB subsystem, enumerated, fimware is downloaded
  227.  * and the descriptors are printed to the debug log, config is set, and
  228.  * green light starts to blink. Open port works, and data can be sent
  229.  * and received at the default settings of the UART. Loopback connector
  230.  * and debug log confirms this.
  231.  * 
  232.  * 0.1 (01/23/2000) greg kroah-hartman
  233.  * Initial release to help IO Networks try to set up their test system. 
  234.  * Edgeport4 is recognized, firmware is downloaded, config is set so 
  235.  * device blinks green light every 3 sec. Port is bound, but opening,
  236.  * closing, and sending data do not work properly.
  237.  * 
  238.  */
  240. #include <linux/config.h>
  241. #include <linux/kernel.h>
  242. #include <linux/sched.h>
  243. #include <linux/signal.h>
  244. #include <linux/errno.h>
  245. #include <linux/poll.h>
  246. #include <linux/init.h>
  247. #include <linux/slab.h>
  248. #include <linux/fcntl.h>
  249. #include <linux/tty.h>
  250. #include <linux/tty_driver.h>
  251. #include <linux/tty_flip.h>
  252. #include <linux/module.h>
  253. #include <linux/spinlock.h>
  254. #include <linux/serial.h>
  255. #include <linux/ioctl.h>
  256. #include <linux/proc_fs.h>
  257. #include <linux/usb.h>
  259. #ifdef CONFIG_USB_SERIAL_DEBUG
  260. static int debug = 1;
  261. #else
  262. static int debug;
  263. #endif
  265. #include "usb-serial.h"
  267. #include "io_edgeport.h"
  268. #include "io_ionsp.h" /* info for the iosp messages */
  269. #include "io_16654.h" /* 16654 UART defines */
  271. /*
  272.  * Version Information
  273.  */
  274. #define DRIVER_VERSION "v2.2"
  275. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
  276. #define DRIVER_DESC "Edgeport USB Serial Driver"
  278. /* First, the latest boot code - for first generation edgeports */
  279. #define IMAGE_ARRAY_NAME BootCodeImage_GEN1
  280. #define IMAGE_VERSION_NAME BootCodeImageVersion_GEN1
  281. #include "io_fw_boot.h" /* the bootloader firmware to download to a device, if it needs it */
  283. /* for second generation edgeports */
  284. #define IMAGE_ARRAY_NAME BootCodeImage_GEN2
  285. #define IMAGE_VERSION_NAME BootCodeImageVersion_GEN2
  286. #include "io_fw_boot2.h" /* the bootloader firmware to download to a device, if it needs it */
  288. /* Then finally the main run-time operational code - for first generation edgeports */
  289. #define IMAGE_ARRAY_NAME OperationalCodeImage_GEN1
  290. #define IMAGE_VERSION_NAME OperationalCodeImageVersion_GEN1
  291. #include "io_fw_down.h" /* Define array OperationalCodeImage[] */
  293. /* for second generation edgeports */
  294. #define IMAGE_ARRAY_NAME OperationalCodeImage_GEN2
  295. #define IMAGE_VERSION_NAME OperationalCodeImageVersion_GEN2
  296. #include "io_fw_down2.h" /* Define array OperationalCodeImage[] */
  299. #define MAX_NAME_LEN 64
  302. #define CHASE_TIMEOUT (5*HZ) /* 5 seconds */
  303. #define OPEN_TIMEOUT (5*HZ) /* 5 seconds */
  304. #define COMMAND_TIMEOUT (5*HZ) /* 5 seconds */
  306. #ifndef SERIAL_MAGIC
  307. #define SERIAL_MAGIC 0x6702
  308. #endif
  309. #define PORT_MAGIC 0x7301
  312. /* receive port state */
  313. enum RXSTATE {
  314. EXPECT_HDR1 = 0, /* Expect header byte 1 */
  315. EXPECT_HDR2 = 1, /* Expect header byte 2 */
  316. EXPECT_DATA = 2, /* Expect 'RxBytesRemaining' data */
  317. EXPECT_HDR3 = 3, /* Expect header byte 3 (for status hdrs only) */
  318. };
  321. /* Transmit Fifo 
  322.  * This Transmit queue is an extension of the edgeport Rx buffer. 
  323.  * The maximum amount of data buffered in both the edgeport 
  324.  * Rx buffer (maxTxCredits) and this buffer will never exceed maxTxCredits.
  325.  */
  326. struct TxFifo {
  327. unsigned int head; /* index to head pointer (write) */
  328. unsigned int tail; /* index to tail pointer (read)  */
  329. unsigned int count; /* Bytes in queue */
  330. unsigned int size; /* Max size of queue (equal to Max number of TxCredits) */
  331. unsigned char *fifo; /* allocated Buffer */
  332. };
  334. /* This structure holds all of the local port information */
  335. struct edgeport_port {
  336. __u16 txCredits; /* our current credits for this port */
  337. __u16 maxTxCredits; /* the max size of the port */
  339. struct TxFifo txfifo; /* transmit fifo -- size will be maxTxCredits */
  340. struct urb *write_urb; /* write URB for this port */
  341. char write_in_progress; /* TRUE while a write URB is outstanding */
  343. __u8 shadowLCR; /* last LCR value received */
  344. __u8 shadowMCR; /* last MCR value received */
  345. __u8 shadowMSR; /* last MSR value received */
  346. __u8 shadowLSR; /* last LSR value received */
  347. __u8 shadowXonChar; /* last value set as XON char in Edgeport */
  348. __u8 shadowXoffChar; /* last value set as XOFF char in Edgeport */
  349. __u8 validDataMask;
  350. __u32 baudRate;
  352. char open;
  353. char openPending;
  354. char commandPending;
  355. char closePending;
  356. char chaseResponsePending;
  358. wait_queue_head_t wait_chase; /* for handling sleeping while waiting for chase to finish */
  359. wait_queue_head_t wait_open; /* for handling sleeping while waiting for open to finish */
  360. wait_queue_head_t wait_command; /* for handling sleeping while waiting for command to finish */
  361. wait_queue_head_t delta_msr_wait; /* for handling sleeping while waiting for msr change to happen */
  363. struct async_icount icount;
  364. struct usb_serial_port *port; /* loop back to the owner of this object */
  365. };
  368. /* This structure holds all of the individual device information */
  369. struct edgeport_serial {
  370. char name[MAX_NAME_LEN+1]; /* string name of this device */
  372. EDGE_MANUF_DESCRIPTOR manuf_descriptor; /* the manufacturer descriptor */
  373. EDGE_BOOT_DESCRIPTOR boot_descriptor; /* the boot firmware descriptor */
  374. struct edgeport_product_info product_info; /* Product Info */
  376. __u8 interrupt_in_endpoint; /* the interrupt endpoint handle */
  377. unsigned char * interrupt_in_buffer; /* the buffer we use for the interrupt endpoint */
  378. struct urb * interrupt_read_urb; /* our interrupt urb */
  380. __u8 bulk_in_endpoint; /* the bulk in endpoint handle */
  381. unsigned char * bulk_in_buffer; /* the buffer we use for the bulk in endpoint */
  382. struct urb * read_urb; /* our bulk read urb */
  384. __u8 bulk_out_endpoint; /* the bulk out endpoint handle */
  386. __s16 rxBytesAvail; /* the number of bytes that we need to read from this device */
  388. enum RXSTATE rxState; /* the current state of the bulk receive processor */
  389. __u8 rxHeader1; /* receive header byte 1 */
  390. __u8 rxHeader2; /* receive header byte 2 */
  391. __u8 rxHeader3; /* receive header byte 3 */
  392. __u8 rxPort; /* the port that we are currently receiving data for */
  393. __u8 rxStatusCode; /* the receive status code */
  394. __u8 rxStatusParam; /* the receive status paramater */
  395. __s16 rxBytesRemaining; /* the number of port bytes left to read */
  396. struct usb_serial *serial; /* loop back to the owner of this object */
  397. };
  399. /* baud rate information */
  400. typedef struct _DIVISOR_TABLE_ENTRY {
  401. __u32   BaudRate;
  402. __u16  Divisor;
  403. } DIVISOR_TABLE_ENTRY, *PDIVISOR_TABLE_ENTRY;
  405. //
  406. // Define table of divisors for Rev A EdgePort/4 hardware
  407. // These assume a 3.6864MHz crystal, the standard /16, and
  408. // MCR.7 = 0.
  409. //
  410. static DIVISOR_TABLE_ENTRY  DivisorTable[] = {
  411. {   75, 3072},  
  412. {   110, 2095}, /* 2094.545455 => 230450   => .0217 % over */
  413. {   134, 1713}, /* 1713.011152 => 230398.5 => .00065% under */
  414. {   150, 1536},
  415. {   300, 768},
  416. {   600, 384},
  417. {   1200, 192},
  418. {   1800, 128},
  419. {   2400, 96},
  420. {   4800, 48},
  421. {   7200, 32},
  422. {   9600, 24},
  423. {   14400, 16},
  424. {   19200, 12},
  425. {   38400, 6},
  426. {   57600, 4},
  427. {   115200, 2},
  428. {   230400, 1},
  429. };
  431. /* local variables */
  432. static int CmdUrbs = 0; /* Number of outstanding Command Write Urbs */
  435. /* local function prototypes */
  437. /* function prototypes for all URB callbacks */
  438. static void edge_interrupt_callback (struct urb *urb);
  439. static void edge_bulk_in_callback (struct urb *urb);
  440. static void edge_bulk_out_data_callback (struct urb *urb);
  441. static void edge_bulk_out_cmd_callback (struct urb *urb);
  443. /* function prototypes for the usbserial callbacks */
  444. static int  edge_open (struct usb_serial_port *port, struct file *filp);
  445. static void edge_close (struct usb_serial_port *port, struct file *filp);
  446. static int  edge_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
  447. static int  edge_write_room (struct usb_serial_port *port);
  448. static int  edge_chars_in_buffer (struct usb_serial_port *port);
  449. static void edge_throttle (struct usb_serial_port *port);
  450. static void edge_unthrottle (struct usb_serial_port *port);
  451. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios);
  452. static int  edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
  453. static void edge_break (struct usb_serial_port *port, int break_state);
  454. static int  edge_startup (struct usb_serial *serial);
  455. static void edge_shutdown (struct usb_serial *serial);
  458. #include "io_tables.h" /* all of the devices that this driver supports */
  461. /* function prototypes for all of our local functions */
  462. static int  process_rcvd_data (struct edgeport_serial *edge_serial, unsigned char *buffer, __u16 bufferLength);
  463. static void process_rcvd_status (struct edgeport_serial *edge_serial, __u8 byte2, __u8 byte3);
  464. static void handle_new_msr (struct edgeport_port *edge_port, __u8 newMsr);
  465. static void handle_new_lsr (struct edgeport_port *edge_port, __u8 lsrData, __u8 lsr, __u8 data);
  466. static int  send_iosp_ext_cmd (struct edgeport_port *edge_port, __u8 command, __u8 param);
  467. static int  calc_baud_rate_divisor (int baud_rate, int *divisor);
  468. static int  send_cmd_write_baud_rate (struct edgeport_port *edge_port, int baudRate);
  469. static void change_port_settings (struct edgeport_port *edge_port, struct termios *old_termios);
  470. static int  send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue);
  471. static int  write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer, int writeLength);
  472. static void send_more_port_data (struct edgeport_serial *edge_serial, struct edgeport_port *edge_port);
  474. static int  sram_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  475. static int  rom_read (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  476. static int  rom_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data);
  477. static void get_manufacturing_desc (struct edgeport_serial *edge_serial);
  478. static void get_boot_desc (struct edgeport_serial *edge_serial);
  479. static void load_application_firmware (struct edgeport_serial *edge_serial);
  482. static void unicode_to_ascii (char *string, short *unicode, int unicode_size);
  488. // ************************************************************************
  489. // ************************************************************************
  490. // ************************************************************************
  491. // ************************************************************************
  493. /************************************************************************
  494.  * *
  495.  * update_edgeport_E2PROM() Compare current versions of *
  496.  * Boot ROM and Manufacture  *
  497.  * Descriptors with versions *
  498.  * embedded in this driver *
  499.  * *
  500.  ************************************************************************/
  501. static void update_edgeport_E2PROM (struct edgeport_serial *edge_serial)
  502. {
  503. __u32 BootCurVer;
  504. __u32 BootNewVer;
  505. __u8 BootMajorVersion;                  
  506. __u8 BootMinorVersion;                  
  507. __u16 BootBuildNumber;
  508. __u8 *BootImage;      
  509. __u32 BootSize;
  510. PEDGE_FIRMWARE_IMAGE_RECORD record;
  511. unsigned char *firmware;
  512. int response;
  515. switch (edge_serial->product_info.iDownloadFile) {
  516. case EDGE_DOWNLOAD_FILE_I930:
  517. BootMajorVersion = BootCodeImageVersion_GEN1.MajorVersion;
  518. BootMinorVersion = BootCodeImageVersion_GEN1.MinorVersion;
  519. BootBuildNumber = BootCodeImageVersion_GEN1.BuildNumber;
  520. BootImage = &BootCodeImage_GEN1[0];
  521. BootSize = sizeof( BootCodeImage_GEN1 );
  522. break;
  524. case EDGE_DOWNLOAD_FILE_80251:
  525. BootMajorVersion = BootCodeImageVersion_GEN2.MajorVersion;
  526. BootMinorVersion = BootCodeImageVersion_GEN2.MinorVersion;
  527. BootBuildNumber = BootCodeImageVersion_GEN2.BuildNumber;
  528. BootImage = &BootCodeImage_GEN2[0];
  529. BootSize = sizeof( BootCodeImage_GEN2 );
  530. break;
  532. default:
  533. return;
  534. }
  536. // Check Boot Image Version
  537. BootCurVer = (edge_serial->boot_descriptor.MajorVersion << 24) +
  538.      (edge_serial->boot_descriptor.MinorVersion << 16) +
  539.       edge_serial->boot_descriptor.BuildNumber;
  541. BootNewVer = (BootMajorVersion << 24) +
  542.      (BootMinorVersion << 16) +
  543.       BootBuildNumber;
  545. dbg("Current Boot Image version %d.%d.%d",
  546.     edge_serial->boot_descriptor.MajorVersion,
  547.     edge_serial->boot_descriptor.MinorVersion,
  548.     edge_serial->boot_descriptor.BuildNumber);
  551. if (BootNewVer > BootCurVer) {
  552. dbg("**Update Boot Image from %d.%d.%d to %d.%d.%d",
  553.     edge_serial->boot_descriptor.MajorVersion,
  554.     edge_serial->boot_descriptor.MinorVersion,
  555.     edge_serial->boot_descriptor.BuildNumber,
  556.     BootMajorVersion,
  557.     BootMinorVersion,
  558.     BootBuildNumber);
  561. dbg("Downloading new Boot Image");
  563. firmware = BootImage;
  565. for (;;) {
  566. record = (PEDGE_FIRMWARE_IMAGE_RECORD)firmware;
  567. response = rom_write (edge_serial->serial, record->ExtAddr, record->Addr, record->Len, &record->Data[0]);
  568. if (response < 0) {
  569. err("sram_write failed (%x, %x, %d)", record->ExtAddr, record->Addr, record->Len);
  570. break;
  571. }
  572. firmware += sizeof (EDGE_FIRMWARE_IMAGE_RECORD) + record->Len;
  573. if (firmware >= &BootImage[BootSize]) {
  574. break;
  575. }
  576. }
  577. } else {
  578. dbg("Boot Image -- already up to date");
  579. }
  580. }
  583. /************************************************************************
  584.  * *
  585.  *  Get string descriptor from device *
  586.  * *
  587.  ************************************************************************/
  588. static int get_string (struct usb_device *dev, int Id, char *string)
  589. {
  590. struct usb_string_descriptor StringDesc;
  591. struct usb_string_descriptor *pStringDesc;
  593. dbg(__FUNCTION__ " - USB String ID = %d", Id );
  595. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc, sizeof(StringDesc))) {
  596. return 0;
  597. }
  599. pStringDesc = kmalloc (StringDesc.bLength, GFP_KERNEL);
  601. if (!pStringDesc) {
  602. return 0;
  603. }
  605. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc, StringDesc.bLength )) {
  606. kfree(pStringDesc);
  607. return 0;
  608. }
  610. unicode_to_ascii(string,  pStringDesc->wData,     pStringDesc->bLength/2-1);
  612. kfree(pStringDesc);
  613. return strlen(string);
  614. }
  617. #if 0
  618. /************************************************************************
  619.  *
  620.  *  Get string descriptor from device
  621.  *
  622.  ************************************************************************/
  623. static int get_string_desc (struct usb_device *dev, int Id, struct usb_string_descriptor **pRetDesc)
  624. {
  625. struct usb_string_descriptor StringDesc;
  626. struct usb_string_descriptor *pStringDesc;
  628. dbg(__FUNCTION__ " - USB String ID = %d", Id );
  630. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc, sizeof(StringDesc))) {
  631. return 0;
  632. }
  634. pStringDesc = kmalloc (StringDesc.bLength, GFP_KERNEL);
  636. if (!pStringDesc) {
  637. return -1;
  638. }
  640. if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc, StringDesc.bLength )) {
  641. kfree(pStringDesc);
  642. return -1;
  643. }
  645. *pRetDesc = pStringDesc;
  646. return 0;
  647. }
  648. #endif
  650. static void get_product_info(struct edgeport_serial *edge_serial)
  651. {
  652. struct edgeport_product_info *product_info = &edge_serial->product_info;
  654. memset (product_info, 0, sizeof(struct edgeport_product_info));
  656. product_info->ProductId = (__u16)(edge_serial->serial->dev->descriptor.idProduct & ~ION_DEVICE_ID_GENERATION_2);
  657. product_info->NumPorts = edge_serial->manuf_descriptor.NumPorts;
  658. product_info->ProdInfoVer = 0;
  660. product_info->RomSize = edge_serial->manuf_descriptor.RomSize;
  661. product_info->RamSize = edge_serial->manuf_descriptor.RamSize;
  662. product_info->CpuRev = edge_serial->manuf_descriptor.CpuRev;
  663. product_info->BoardRev = edge_serial->manuf_descriptor.BoardRev;
  665. product_info->BootMajorVersion = edge_serial->boot_descriptor.MajorVersion;
  666. product_info->BootMinorVersion = edge_serial->boot_descriptor.MinorVersion;
  667. product_info->BootBuildNumber = edge_serial->boot_descriptor.BuildNumber;
  669. memcpy(product_info->ManufactureDescDate, edge_serial->manuf_descriptor.DescDate, sizeof(edge_serial->manuf_descriptor.DescDate));
  671. // check if this is 2nd generation hardware
  672. if (edge_serial->serial->dev->descriptor.idProduct & ION_DEVICE_ID_GENERATION_2) {
  673. product_info->FirmwareMajorVersion = OperationalCodeImageVersion_GEN2.MajorVersion;
  674. product_info->FirmwareMinorVersion = OperationalCodeImageVersion_GEN2.MinorVersion;
  675. product_info->FirmwareBuildNumber = OperationalCodeImageVersion_GEN2.BuildNumber;
  676. product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251;
  677. } else {
  678. product_info->FirmwareMajorVersion = OperationalCodeImageVersion_GEN1.MajorVersion;
  679. product_info->FirmwareMinorVersion = OperationalCodeImageVersion_GEN1.MinorVersion;
  680. product_info->FirmwareBuildNumber = OperationalCodeImageVersion_GEN1.BuildNumber;
  681. product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930;
  682. }
  684. // Determine Product type and set appropriate flags
  685. switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) {
  686. case ION_DEVICE_ID_EDGEPORT_COMPATIBLE:
  687. case ION_DEVICE_ID_EDGEPORT_4T:
  688. case ION_DEVICE_ID_EDGEPORT_4:
  689. case ION_DEVICE_ID_EDGEPORT_2:
  690. case ION_DEVICE_ID_EDGEPORT_8_DUAL_CPU:
  691. case ION_DEVICE_ID_EDGEPORT_8:
  692. case ION_DEVICE_ID_EDGEPORT_421:
  693. case ION_DEVICE_ID_EDGEPORT_21:
  694. case ION_DEVICE_ID_EDGEPORT_2_DIN:
  695. case ION_DEVICE_ID_EDGEPORT_4_DIN:
  696. case ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU:
  697. product_info->IsRS232 = 1;
  698. break;
  700. case ION_DEVICE_ID_EDGEPORT_2I:    // Edgeport/2 RS422/RS485
  701. product_info->IsRS422 = 1;
  702. product_info->IsRS485 = 1;
  703. break;
  705. case ION_DEVICE_ID_EDGEPORT_8I:    // Edgeport/4 RS422
  706. case ION_DEVICE_ID_EDGEPORT_4I:    // Edgeport/4 RS422
  707. product_info->IsRS422 = 1;
  708. break;
  709. }
  711. // Dump Product Info structure
  712. dbg("**Product Information:");
  713. dbg("  ProductId             %x", product_info->ProductId );
  714. dbg("  NumPorts              %d", product_info->NumPorts );
  715. dbg("  ProdInfoVer           %d", product_info->ProdInfoVer );
  716. dbg("  IsServer              %d", product_info->IsServer);
  717. dbg("  IsRS232               %d", product_info->IsRS232 );
  718. dbg("  IsRS422               %d", product_info->IsRS422 );
  719. dbg("  IsRS485               %d", product_info->IsRS485 );
  720. dbg("  RomSize               %d", product_info->RomSize );
  721. dbg("  RamSize               %d", product_info->RamSize );
  722. dbg("  CpuRev                %x", product_info->CpuRev  );
  723. dbg("  BoardRev              %x", product_info->BoardRev);
  724. dbg("  BootMajorVersion      %d.%d.%d", product_info->BootMajorVersion,
  725.     product_info->BootMinorVersion,
  726.     product_info->BootBuildNumber);
  727. dbg("  FirmwareMajorVersion  %d.%d.%d", product_info->FirmwareMajorVersion,
  728.     product_info->FirmwareMinorVersion,
  729.     product_info->FirmwareBuildNumber);
  730. dbg("  ManufactureDescDate   %d/%d/%d", product_info->ManufactureDescDate[0],
  731.     product_info->ManufactureDescDate[1],
  732.     product_info->ManufactureDescDate[2]+1900);
  733. dbg("  iDownloadFile         0x%x",     product_info->iDownloadFile);
  735. }
  738. /************************************************************************/
  739. /************************************************************************/
  740. /*            U S B  C A L L B A C K   F U N C T I O N S                */
  741. /*            U S B  C A L L B A C K   F U N C T I O N S                */
  742. /************************************************************************/
  743. /************************************************************************/
  745. /*****************************************************************************
  746.  * edge_interrupt_callback
  747.  * this is the callback function for when we have received data on the 
  748.  * interrupt endpoint.
  749.  *****************************************************************************/
  750. static void edge_interrupt_callback (struct urb *urb)
  751. {
  752. struct edgeport_serial *edge_serial = (struct edgeport_serial *)urb->context;
  753. struct edgeport_port *edge_port;
  754. struct usb_serial_port *port;
  755. unsigned char *data = urb->transfer_buffer;
  756. int length = urb->actual_length;
  757. int bytes_avail;
  758. int position;
  759. int txCredits;
  760. int portNumber;
  761. int result;
  763. dbg(__FUNCTION__);
  765. if (serial_paranoia_check (edge_serial->serial, __FUNCTION__)) {
  766. return;
  767. }
  769. if (urb->status) {
  770. dbg(__FUNCTION__" - nonzero control read status received: %d", urb->status);
  771. return;
  772. }
  774. // process this interrupt-read even if there are no ports open
  775. if (length) {
  776. usb_serial_debug_data (__FILE__, __FUNCTION__, length, data);
  778. if (length > 1) {
  779. bytes_avail = data[0] | (data[1] << 8);
  780. if (bytes_avail) {
  781. edge_serial->rxBytesAvail += bytes_avail;
  782. dbg(__FUNCTION__" - bytes_avail = %d, rxBytesAvail %d", bytes_avail, edge_serial->rxBytesAvail);
  784. if ((edge_serial->rxBytesAvail > 0) &&
  785.     (edge_serial->read_urb->status != -EINPROGRESS)) {
  786. dbg(" --- Posting a read");
  788. /* we have pending bytes on the bulk in pipe, send a request */
  789. edge_serial->read_urb->dev = edge_serial->serial->dev;
  790. result = usb_submit_urb(edge_serial->read_urb);
  791. if (result) {
  792. dbg(__FUNCTION__" - usb_submit_urb(read bulk) failed with result = %d", result);
  793. }
  794. }
  795. }
  796. }
  797. /* grab the txcredits for the ports if available */
  798. position = 2;
  799. portNumber = 0;
  800. while ((position < length) && (portNumber < edge_serial->serial->num_ports)) {
  801. txCredits = data[position] | (data[position+1] << 8);
  802. if (txCredits) {
  803. port = &edge_serial->serial->port[portNumber];
  804. if (port_paranoia_check (port, __FUNCTION__) == 0) {
  805. edge_port = (struct edgeport_port *)port->private;
  806. if (edge_port->open) {
  807. edge_port->txCredits += txCredits;
  808. dbg(__FUNCTION__" - txcredits for port%d = %d", portNumber, edge_port->txCredits);
  810. /* tell the tty driver that something has changed */
  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(__FUNCTION__);
  839. if (serial_paranoia_check (edge_serial->serial, __FUNCTION__)) {
  840. return;
  841. }
  843. if (urb->status) {
  844. dbg(__FUNCTION__" - nonzero read bulk status received: %d", 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(__FUNCTION__" - Received = %d, rxBytesAvail %d", 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(__FUNCTION__" - usb_submit_urb(read bulk) failed, status = %d", 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(__FUNCTION__);
  888. if (port_paranoia_check (edge_port->port, __FUNCTION__)) {
  889. return;
  890. }
  892. if (urb->status) {
  893. dbg(__FUNCTION__" - nonzero write bulk status received: %d", urb->status);
  894. }
  896. tty = edge_port->port->tty;
  898. /* let the tty driver wakeup if it has a special write_wakeup function */
  899. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
  900. (tty->ldisc.write_wakeup)(tty);
  901. }
  903. /* tell the tty driver that something has changed */
  904. wake_up_interruptible(&tty->write_wait);
  906. // Release the Write URB
  907. edge_port->write_in_progress = FALSE;
  909. // Check if more data needs to be sent
  910. send_more_port_data((struct edgeport_serial *)(edge_port->port->serial->private), edge_port);
  911. }
  914. /*****************************************************************************
  915.  * BulkOutCmdCallback
  916.  * this is the callback function for when we have finished sending a command
  917.  * on the bulk out endpoint.
  918.  *****************************************************************************/
  919. static void edge_bulk_out_cmd_callback (struct urb *urb)
  920. {
  921. struct edgeport_port *edge_port = (struct edgeport_port *)urb->context;
  922. struct tty_struct *tty;
  923. int status = urb->status;
  925. dbg(__FUNCTION__);
  927. CmdUrbs--;
  928. dbg(__FUNCTION__" - FREE URB %p (outstanding %d)", urb, CmdUrbs);
  931. /* clean up the transfer buffer */
  932. if (urb->transfer_buffer != NULL) {
  933. kfree(urb->transfer_buffer);
  934. }
  936. // Free the command urb
  937. usb_unlink_urb (urb);
  938. usb_free_urb   (urb);
  940. if (port_paranoia_check (edge_port->port, __FUNCTION__)) {
  941. return;
  942. }
  944. if (status) {
  945. dbg(__FUNCTION__" - nonzero write bulk status received: %d", status);
  946. return;
  947. }
  949. /* Get pointer to tty */
  950. tty = edge_port->port->tty;
  952. /* tell the tty driver that something has changed */
  953. wake_up_interruptible(&tty->write_wait);
  955. /* we have completed the command */
  956. edge_port->commandPending = FALSE;
  957. wake_up_interruptible(&edge_port->wait_command);
  958. }
  961. /*****************************************************************************
  962.  * Driver tty interface functions
  963.  *****************************************************************************/
  965. /*****************************************************************************
  966.  * SerialOpen
  967.  * this function is called by the tty driver when a port is opened
  968.  * If successful, we return 0
  969.  * Otherwise we return a negative error number.
  970.  *****************************************************************************/
  971. static int edge_open (struct usb_serial_port *port, struct file * filp)
  972. {
  973. struct edgeport_port *edge_port = (struct edgeport_port *)port->private;
  974. struct usb_serial *serial;
  975. struct edgeport_serial *edge_serial;
  976. int response;
  977. int timeout;
  979. if (port_paranoia_check (port, __FUNCTION__))
  980. return -ENODEV;
  982. dbg(__FUNCTION__ " - port %d", port->number);
  984. if (edge_port == NULL)
  985. return -ENODEV;
  987. ++port->open_count;
  988. MOD_INC_USE_COUNT;
  990. if (!port->active) {
  991. port->active = 1;
  993. /* force low_latency on so that our tty_push actually forces the data through, 
  994.    otherwise it is scheduled, and with high data rates (like with OHCI) data
  995.    can get lost. */
  996. port->tty->low_latency = 1;
  998. /* see if we've set up our endpoint info yet (can't set it up in edge_startup
  999.    as the structures were not set up at that time.) */
  1000. serial = port->serial;
  1001. edge_serial = (struct edgeport_serial *)serial->private;
  1002. if (edge_serial == NULL) {
  1003. port->active = 0;
  1004. port->open_count = 0;
  1005. MOD_DEC_USE_COUNT;
  1006. return -ENODEV;
  1007. }
  1008. if (edge_serial->interrupt_in_buffer == NULL) {
  1009. struct usb_serial_port *port0 = &serial->port[0];
  1011. /* not set up yet, so do it now */
  1012. edge_serial->interrupt_in_buffer = port0->interrupt_in_buffer;
  1013. edge_serial->interrupt_in_endpoint = port0->interrupt_in_endpointAddress;
  1014. edge_serial->interrupt_read_urb = port0->interrupt_in_urb;
  1015. edge_serial->bulk_in_buffer = port0->bulk_in_buffer;
  1016. edge_serial->bulk_in_endpoint = port0->bulk_in_endpointAddress;
  1017. edge_serial->read_urb = port0->read_urb;
  1018. edge_serial->bulk_out_endpoint = port0->bulk_out_endpointAddress;
  1020. /* set up our interrupt urb */
  1021. FILL_INT_URB(edge_serial->interrupt_read_urb,
  1022.      serial->dev,
  1023.      usb_rcvintpipe(serial->dev,
  1024.             port0->interrupt_in_endpointAddress),
  1025.      port0->interrupt_in_buffer,
  1026.      edge_serial->interrupt_read_urb->transfer_buffer_length,
  1027.      edge_interrupt_callback, edge_serial,
  1028.      edge_serial->interrupt_read_urb->interval);
  1030. /* set up our bulk in urb */
  1031. FILL_BULK_URB(edge_serial->read_urb, serial->dev,
  1032.       usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress),
  1033.       port0->bulk_in_buffer,
  1034.       edge_serial->read_urb->transfer_buffer_length,
  1035.       edge_bulk_in_callback, edge_serial);
  1037. /* start interrupt read for this edgeport
  1038.  * this interrupt will continue as long as the edgeport is connected */
  1039. response = usb_submit_urb (edge_serial->interrupt_read_urb);
  1040. if (response) {
  1041. err(__FUNCTION__" - Error %d submitting control urb", response);
  1042. }
  1043. }
  1045. /* initialize our wait queues */
  1046. init_waitqueue_head(&edge_port->wait_open);
  1047. init_waitqueue_head(&edge_port->wait_chase);
  1048. init_waitqueue_head(&edge_port->delta_msr_wait);
  1049. init_waitqueue_head(&edge_port->wait_command);
  1051. /* initialize our icount structure */
  1052. memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
  1054. /* initialize our port settings */
  1055. edge_port->txCredits            = 0; /* Can't send any data yet */
  1056. edge_port->shadowMCR            = MCR_MASTER_IE; /* Must always set this bit to enable ints! */
  1057. edge_port->chaseResponsePending = FALSE;
  1059. /* send a open port command */
  1060. edge_port->openPending = TRUE;
  1061. edge_port->open        = FALSE;
  1062. response = send_iosp_ext_cmd (edge_port, IOSP_CMD_OPEN_PORT, 0);
  1064. if (response < 0) {
  1065. err(__FUNCTION__" - error sending open port command");
  1066. edge_port->openPending = FALSE;
  1067. port->active = 0;
  1068. port->open_count = 0;
  1069. MOD_DEC_USE_COUNT;
  1070. return -ENODEV;
  1071. }
  1073. /* now wait for the port to be completly opened */
  1074. timeout = OPEN_TIMEOUT;
  1075. while (timeout && edge_port->openPending == TRUE) {
  1076. timeout = interruptible_sleep_on_timeout (&edge_port->wait_open, timeout);
  1077. }
  1079. if (edge_port->open == FALSE) {
  1080. /* open timed out */
  1081. dbg(__FUNCTION__" - open timedout");
  1082. edge_port->openPending = FALSE;
  1083. port->active = 0;
  1084. port->open_count = 0;
  1085. MOD_DEC_USE_COUNT;
  1086. return -ENODEV;
  1087. }
  1089. /* create the txfifo */
  1090. edge_port->txfifo.head = 0;
  1091. edge_port->txfifo.tail = 0;
  1092. edge_port->txfifo.count = 0;
  1093. edge_port->txfifo.size = edge_port->maxTxCredits;
  1094. edge_port->txfifo.fifo = kmalloc (edge_port->maxTxCredits, GFP_KERNEL);
  1096. if (!edge_port->txfifo.fifo) {
  1097. dbg(__FUNCTION__" - no memory");
  1098. edge_close (port, filp);
  1099. return -ENOMEM;
  1100. }
  1102. /* Allocate a URB for the write */
  1103. edge_port->write_urb = usb_alloc_urb (0);
  1105. if (!edge_port->write_urb) {
  1106. dbg(__FUNCTION__" - no memory");
  1107. edge_close (port, filp);
  1108. return -ENOMEM;
  1109. }
  1111. dbg(__FUNCTION__"(%d) - Initialize TX fifo to %d bytes", port->number, edge_port->maxTxCredits);
  1112. }
  1114. dbg(__FUNCTION__" exited");
  1116. return 0;
  1117. }
  1120. /************************************************************************
  1121.  *
  1122.  * block_until_chase_response
  1123.  *
  1124.  * This function will block the close until one of the following:
  1125.  * 1. Response to our Chase comes from Edgeport
  1126.  * 2. A timout of 10 seconds without activity has expired
  1127.  *    (1K of Edgeport data @ 2400 baud ==> 4 sec to empty)
  1128.  *
  1129.  ************************************************************************/
  1130. static void block_until_chase_response(struct edgeport_port *edge_port)
  1131. {
  1132. __u16 lastCredits;
  1133. int timeout = 1*HZ;
  1134. int wait = 10;
  1136. while (1) {
  1137. // Save Last credits
  1138. lastCredits = edge_port->txCredits;
  1140. // Did we get our Chase response
  1141. if (edge_port->chaseResponsePending == FALSE) {
  1142. dbg(__FUNCTION__" - Got Chase Response");
  1144. // did we get all of our credit back?
  1145. if (edge_port->txCredits == edge_port->maxTxCredits ) {
  1146. dbg(__FUNCTION__" - Got all credits");
  1147. return;
  1148. }
  1149. }
  1151. // Block the thread for a while
  1152. interruptible_sleep_on_timeout (&edge_port->wait_chase, timeout);
  1154. if (lastCredits == edge_port->txCredits) {
  1155. // No activity.. count down.
  1156. wait--;
  1157. if (wait == 0) {
  1158. edge_port->chaseResponsePending = FALSE;
  1159. dbg(__FUNCTION__" - Chase TIMEOUT");
  1160. return;
  1161. }
  1162. } else {
  1163. // Reset timout value back to 10 seconds
  1164. dbg(__FUNCTION__" - Last %d, Current %d", lastCredits, edge_port->txCredits);
  1165. wait = 10;
  1166. }
  1167. }
  1168. }
  1171. /************************************************************************
  1172.  *
  1173.  * block_until_tx_empty
  1174.  *
  1175.  * This function will block the close until one of the following:
  1176.  * 1. TX count are 0
  1177.  * 2. The edgeport has stopped
  1178.  * 3. A timout of 3 seconds without activity has expired
  1179.  *
  1180.  ************************************************************************/
  1181. static void block_until_tx_empty (struct edgeport_port *edge_port)
  1182. {
  1183. struct TxFifo *fifo = &edge_port->txfifo;
  1184. __u32 lastCount;
  1185. int timeout = HZ/10;
  1186. int wait = 30;
  1188. while (1) {
  1189. // Save Last count
  1190. lastCount = fifo->count;
  1192. // Is the Edgeport Buffer empty?
  1193. if (lastCount == 0) {
  1194. dbg(__FUNCTION__" - TX Buffer Empty");
  1195. return;
  1196. }
  1198. // Block the thread for a while
  1199. interruptible_sleep_on_timeout (&edge_port->wait_chase, timeout);
  1201. dbg(__FUNCTION__ " wait");
  1203. if (lastCount == fifo->count) {
  1204. // No activity.. count down.
  1205. wait--;
  1206. if (wait == 0) {
  1207. dbg(__FUNCTION__" - TIMEOUT");
  1208. return;
  1209. }
  1210. } else {
  1211. // Reset timout value back to seconds
  1212. wait = 30;
  1213. }
  1214. }
  1215. }
  1218. /*****************************************************************************
  1219.  * edge_close
  1220.  * this function is called by the tty driver when a port is closed
  1221.  *****************************************************************************/
  1222. static void edge_close (struct usb_serial_port *port, struct file * filp)
  1223. {
  1224. struct usb_serial *serial;
  1225. struct edgeport_serial *edge_serial;
  1226. struct edgeport_port *edge_port;
  1227. int status;
  1229. if (port_paranoia_check (port, __FUNCTION__))
  1230. return;
  1232. dbg(__FUNCTION__ " - port %d", port->number);
  1233.  
  1234. serial = get_usb_serial (port, __FUNCTION__);
  1235. if (!serial)
  1236. return;
  1238. edge_serial = (struct edgeport_serial *)serial->private;
  1239. edge_port = (struct edgeport_port *)port->private;
  1240. if ((edge_serial == NULL) || (edge_port == NULL))
  1241. return;
  1243. --port->open_count;
  1245. if (port->open_count <= 0) {
  1246. if (serial->dev) {
  1247. // block until tx is empty
  1248. block_until_tx_empty(edge_port);
  1250. edge_port->closePending = TRUE;
  1252. /* flush and chase */
  1253. edge_port->chaseResponsePending = TRUE;
  1255. dbg(__FUNCTION__" - Sending IOSP_CMD_CHASE_PORT");
  1256. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_CHASE_PORT, 0);
  1257. if (status == 0) {
  1258. // block until chase finished
  1259. block_until_chase_response(edge_port);
  1260. } else {
  1261. edge_port->chaseResponsePending = FALSE;
  1262. }
  1264. /* close the port */
  1265. dbg(__FUNCTION__" - Sending IOSP_CMD_CLOSE_PORT");
  1266. send_iosp_ext_cmd (edge_port, IOSP_CMD_CLOSE_PORT, 0);
  1268. //port->close = TRUE;
  1269. edge_port->closePending = FALSE;
  1270. edge_port->open = FALSE;
  1271. edge_port->openPending = FALSE;
  1273. if (edge_port->write_urb) {
  1274. usb_unlink_urb (edge_port->write_urb);
  1275. }
  1276. }
  1278. if (edge_port->write_urb) {
  1279. /* if this urb had a transfer buffer already (old transfer) free it */
  1280. if (edge_port->write_urb->transfer_buffer != NULL) {
  1281. kfree(edge_port->write_urb->transfer_buffer);
  1282. }
  1283. usb_free_urb   (edge_port->write_urb);
  1284. }
  1285. if (edge_port->txfifo.fifo) {
  1286. kfree(edge_port->txfifo.fifo);
  1287. }
  1288. port->active = 0;
  1289. port->open_count = 0;
  1290. }
  1292. MOD_DEC_USE_COUNT;
  1293. dbg(__FUNCTION__" exited");
  1294. }   
  1296. /*****************************************************************************
  1297.  * SerialWrite
  1298.  * this function is called by the tty driver when data should be written to
  1299.  * the port.
  1300.  * If successful, we return the number of bytes written, otherwise we return
  1301.  * a negative error number.
  1302.  *****************************************************************************/
  1303. static int edge_write (struct usb_serial_port *port, int from_user, const unsigned char *data, int count)
  1304. {
  1305.         struct edgeport_port *edge_port = (struct edgeport_port *)port->private;
  1306. struct TxFifo *fifo;
  1307. int copySize;
  1308. int bytesleft;
  1309. int firsthalf;
  1310. int secondhalf;
  1312. dbg(__FUNCTION__ " - port %d", port->number);
  1314. if (edge_port == NULL)
  1315. return -ENODEV;
  1317. // get a pointer to the Tx fifo
  1318. fifo = &edge_port->txfifo;
  1320. // calculate number of bytes to put in fifo
  1321. copySize = min ((unsigned int)count, (edge_port->txCredits - fifo->count));
  1323. dbg(__FUNCTION__"(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes", 
  1324.     port->number, count, edge_port->txCredits - fifo->count, copySize);
  1326. /* catch writes of 0 bytes which the tty driver likes to give us, and when txCredits is empty */
  1327. if (copySize == 0) {
  1328. dbg (__FUNCTION__" - copySize = Zero");
  1329. return 0;
  1330. }
  1332. // queue the data
  1333. // since we can never overflow the buffer we do not have to check for full condition
  1335. // the copy is done is two parts -- first fill to the end of the buffer
  1336. // then copy the reset from the start of the buffer 
  1338. bytesleft = fifo->size - fifo->head;
  1339. firsthalf = min (bytesleft, copySize);
  1340. dbg (__FUNCTION__" - copy %d bytes of %d into fifo ", firsthalf, bytesleft);
  1342. /* now copy our data */
  1343. if (from_user) {
  1344. if (copy_from_user(&fifo->fifo[fifo->head], data, firsthalf))
  1345. return -EFAULT;
  1346. } else {
  1347. memcpy(&fifo->fifo[fifo->head], data, firsthalf);
  1348. }  
  1350. // update the index and size
  1351. fifo->head  += firsthalf;
  1352. fifo->count += firsthalf;
  1354. // wrap the index
  1355. if (fifo->head == fifo->size) {
  1356. fifo->head = 0;
  1357. }
  1359. secondhalf = copySize-firsthalf;
  1361. if (secondhalf) {
  1362. dbg (__FUNCTION__" - copy rest of data %d", secondhalf);
  1363. if (from_user) {
  1364. if (copy_from_user(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf))
  1365. return -EFAULT;
  1366. } else {
  1367. memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf);
  1368. }
  1369. // update the index and size
  1370. fifo->count += secondhalf;
  1371. fifo->head  += secondhalf;
  1372. // No need to check for wrap since we can not get to end of fifo in this part
  1373. }
  1375. if (copySize) {
  1376. usb_serial_debug_data (__FILE__, __FUNCTION__, copySize, data);
  1377. }
  1379. send_more_port_data((struct edgeport_serial *)port->serial->private, edge_port);
  1381. dbg(__FUNCTION__" wrote %d byte(s) TxCredits %d, Fifo %d", copySize, edge_port->txCredits, fifo->count);
  1383. return copySize;   
  1384. }
  1387. /************************************************************************
  1388.  *
  1389.  * send_more_port_data()
  1390.  *
  1391.  * This routine attempts to write additional UART transmit data
  1392.  * to a port over the USB bulk pipe. It is called (1) when new
  1393.  * data has been written to a port's TxBuffer from higher layers
  1394.  * (2) when the peripheral sends us additional TxCredits indicating
  1395.  * that it can accept more Tx data for a given port; and (3) when
  1396.  * a bulk write completes successfully and we want to see if we
  1397.  * can transmit more.
  1398.  *
  1399.  ************************************************************************/
  1400. static void send_more_port_data(struct edgeport_serial *edge_serial, struct edgeport_port *edge_port)
  1401. {
  1402. struct TxFifo *fifo = &edge_port->txfifo;
  1403. struct urb *urb;
  1404. unsigned char *buffer;
  1405. int status;
  1406. int count;
  1407. int bytesleft;
  1408. int firsthalf;
  1409. int secondhalf;
  1411. dbg(__FUNCTION__"(%d)", edge_port->port->number);
  1413. if (edge_port->write_in_progress ||
  1414.     !edge_port->open             ||
  1415.     (fifo->count == 0)) {
  1416. dbg(__FUNCTION__"(%d) EXIT - fifo %d, PendingWrite = %d", edge_port->port->number, fifo->count, edge_port->write_in_progress);
  1417. return;
  1418. }
  1420. // since the amount of data in the fifo will always fit into the
  1421. // edgeport buffer we do not need to check the write length
  1423. // Do we have enough credits for this port to make it worthwhile
  1424. // to bother queueing a write. If it's too small, say a few bytes,
  1425. // it's better to wait for more credits so we can do a larger
  1426. // write.
  1427. if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits)) {
  1428. dbg(__FUNCTION__"(%d) Not enough credit - fifo %d TxCredit %d", edge_port->port->number, fifo->count, edge_port->txCredits );
  1429. return;
  1430. }
  1432. // lock this write
  1433. edge_port->write_in_progress = TRUE;
  1435. // get a pointer to the write_urb
  1436. urb = edge_port->write_urb;
  1438. /* if this urb had a transfer buffer already (old transfer) free it */
  1439. if (urb->transfer_buffer != NULL) {
  1440. kfree(urb->transfer_buffer);
  1441. urb->transfer_buffer = NULL;
  1442. }
  1444. /* build the data header for the buffer and port that we are about to send out */
  1445. count = fifo->count;
  1446. buffer = kmalloc (count+2, GFP_KERNEL);
  1447. if (buffer == NULL) {
  1448. err(__FUNCTION__" - no more kernel memory...");
  1449. edge_port->write_in_progress = FALSE;
  1450. return;
  1451. }
  1452. buffer[0] = IOSP_BUILD_DATA_HDR1 (edge_port->port->number, count);
  1453. buffer[1] = IOSP_BUILD_DATA_HDR2 (edge_port->port->number, count);
  1455. /* now copy our data */
  1456. bytesleft =  fifo->size - fifo->tail;
  1457. firsthalf = min (bytesleft, count);
  1458. memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf);
  1459. fifo->tail  += firsthalf;
  1460. fifo->count -= firsthalf;
  1461. if (fifo->tail == fifo->size) {
  1462. fifo->tail = 0;
  1463. }
  1465. secondhalf = count-firsthalf;
  1466. if (secondhalf) {
  1467. memcpy(&buffer[2+firsthalf], &fifo->fifo[fifo->tail], secondhalf);
  1468. fifo->tail  += secondhalf;
  1469. fifo->count -= secondhalf;
  1470. }
  1472. if (count) {
  1473. usb_serial_debug_data (__FILE__, __FUNCTION__, count, &buffer[2]);
  1474. }
  1476. /* fill up the urb with all of our data and submit it */
  1477. FILL_BULK_URB (urb, edge_serial->serial->dev, 
  1478.        usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
  1479.        buffer, count+2, edge_bulk_out_data_callback, edge_port);
  1481. /* set the USB_BULK_QUEUE flag so that we can shove a bunch of urbs at once down the pipe */
  1482. urb->transfer_flags |= USB_QUEUE_BULK;
  1484. urb->dev = edge_serial->serial->dev;
  1485. status = usb_submit_urb(urb);
  1486. if (status) {
  1487. /* something went wrong */
  1488. dbg(__FUNCTION__" - usb_submit_urb(write bulk) failed");
  1489. edge_port->write_in_progress = FALSE;
  1490. } else {
  1491. /* decrement the number of credits we have by the number we just sent */
  1492. edge_port->txCredits -= count;
  1493. edge_port->icount.tx += count;
  1494. }
  1495. dbg(__FUNCTION__" wrote %d byte(s) TxCredit %d, Fifo %d", count, edge_port->txCredits, fifo->count);
  1496. }
  1499. /*****************************************************************************
  1500.  * edge_write_room
  1501.  * this function is called by the tty driver when it wants to know how many
  1502.  * bytes of data we can accept for a specific port.
  1503.  * If successful, we return the amount of room that we have for this port
  1504.  * (the txCredits), 
  1505.  * Otherwise we return a negative error number.
  1506.  *****************************************************************************/
  1507. static int edge_write_room (struct usb_serial_port *port)
  1508. {
  1509. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1510. int room;
  1512. dbg(__FUNCTION__);
  1514. if (edge_port == NULL)
  1515. return -ENODEV;
  1516. if (edge_port->closePending == TRUE)
  1517. return -ENODEV;
  1519. dbg(__FUNCTION__" - port %d", port->number);
  1521. if (!edge_port->open) {
  1522. dbg (__FUNCTION__" - port not opened");
  1523. return -EINVAL;
  1524. }
  1526. // total of both buffers is still txCredit
  1527. room = edge_port->txCredits - edge_port->txfifo.count;
  1529. dbg(__FUNCTION__" - returns %d", room);
  1530. return room;
  1531. }
  1534. /*****************************************************************************
  1535.  * edge_chars_in_buffer
  1536.  * this function is called by the tty driver when it wants to know how many
  1537.  * bytes of data we currently have outstanding in the port (data that has
  1538.  * been written, but hasn't made it out the port yet)
  1539.  * If successful, we return the number of bytes left to be written in the 
  1540.  * system, 
  1541.  * Otherwise we return a negative error number.
  1542.  *****************************************************************************/
  1543. static int edge_chars_in_buffer (struct usb_serial_port *port)
  1544. {
  1545. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1546. int num_chars;
  1548. dbg(__FUNCTION__);
  1550. if (edge_port == NULL)
  1551. return -ENODEV;
  1552. if (edge_port->closePending == TRUE)
  1553. return -ENODEV;
  1555. if (!edge_port->open) {
  1556. dbg (__FUNCTION__" - port not opened");
  1557. return -EINVAL;
  1558. }
  1560. num_chars = edge_port->maxTxCredits - edge_port->txCredits + edge_port->txfifo.count;
  1561. if (num_chars) {
  1562. dbg(__FUNCTION__"(port %d) - returns %d", port->number, num_chars);
  1563. }
  1565. return num_chars;
  1566. }
  1569. /*****************************************************************************
  1570.  * SerialThrottle
  1571.  * this function is called by the tty driver when it wants to stop the data
  1572.  * being read from the port.
  1573.  *****************************************************************************/
  1574. static void edge_throttle (struct usb_serial_port *port)
  1575. {
  1576. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1577. struct tty_struct *tty;
  1578. int status;
  1580. dbg(__FUNCTION__" - port %d", port->number);
  1582. if (edge_port == NULL)
  1583. return;
  1585. if (!edge_port->open) {
  1586. dbg (__FUNCTION__" - port not opened");
  1587. return;
  1588. }
  1590. tty = port->tty;
  1592. /* if we are implementing XON/XOFF, send the stop character */
  1593. if (I_IXOFF(tty)) {
  1594. unsigned char stop_char = STOP_CHAR(tty);
  1595. status = edge_write (port, 0, &stop_char, 1);
  1596. if (status <= 0) {
  1597. return;
  1598. }
  1599. }
  1601. /* if we are implementing RTS/CTS, toggle that line */
  1602. if (tty->termios->c_cflag & CRTSCTS) {
  1603. edge_port->shadowMCR &= ~MCR_RTS;
  1604. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  1605. if (status != 0) {
  1606. return;
  1607. }
  1608. }
  1610. return;
  1611. }
  1614. /*****************************************************************************
  1615.  * edge_unthrottle
  1616.  * this function is called by the tty driver when it wants to resume the data
  1617.  * being read from the port (called after SerialThrottle is called)
  1618.  *****************************************************************************/
  1619. static void edge_unthrottle (struct usb_serial_port *port)
  1620. {
  1621. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1622. struct tty_struct *tty;
  1623. int status;
  1625. dbg(__FUNCTION__" - port %d", port->number);
  1627. if (edge_port == NULL)
  1628. return;
  1630. if (!edge_port->open) {
  1631. dbg (__FUNCTION__" - port not opened");
  1632. return;
  1633. }
  1635. tty = port->tty;
  1637. /* if we are implementing XON/XOFF, send the start character */
  1638. if (I_IXOFF(tty)) {
  1639. unsigned char start_char = START_CHAR(tty);
  1640. status = edge_write (port, 0, &start_char, 1);
  1641. if (status <= 0) {
  1642. return;
  1643. }
  1644. }
  1646. /* if we are implementing RTS/CTS, toggle that line */
  1647. if (tty->termios->c_cflag & CRTSCTS) {
  1648. edge_port->shadowMCR |= MCR_RTS;
  1649. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  1650. if (status != 0) {
  1651. return;
  1652. }
  1653. }
  1655. return;
  1656. }
  1659. /*****************************************************************************
  1660.  * SerialSetTermios
  1661.  * this function is called by the tty driver when it wants to change the termios structure
  1662.  *****************************************************************************/
  1663. static void edge_set_termios (struct usb_serial_port *port, struct termios *old_termios)
  1664. {
  1665. struct edgeport_port *edge_port = (struct edgeport_port *)(port->private);
  1666. struct tty_struct *tty = port->tty;
  1667. unsigned int cflag = tty->termios->c_cflag;
  1669. dbg(__FUNCTION__" - clfag %08x %08x iflag %08x %08x", 
  1670.     tty->termios->c_cflag,
  1671.     old_termios->c_cflag,
  1672.     RELEVANT_IFLAG(tty->termios->c_iflag),
  1673.     RELEVANT_IFLAG(old_termios->c_iflag)
  1674.    );
  1676. /* check that they really want us to change something */
  1677. if (old_termios) {
  1678. if ((cflag == old_termios->c_cflag) &&
  1679.     (RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) {
  1680. dbg(__FUNCTION__" - nothing to change");
  1681. return;
  1682. }
  1683. }
  1685. dbg(__FUNCTION__" - port %d", port->number);
  1687. if (edge_port == NULL)
  1688. return;
  1690. if (!edge_port->open) {
  1691. dbg (__FUNCTION__" - port not opened");
  1692. return;
  1693. }
  1695. /* change the port settings to the new ones specified */
  1696. change_port_settings (edge_port, old_termios);
  1698. return;
  1699. }
  1702. /*****************************************************************************
  1703.  * get_lsr_info - get line status register info
  1704.  *
  1705.  * Purpose: Let user call ioctl() to get info when the UART physically
  1706.  *      is emptied.  On bus types like RS485, the transmitter must
  1707.  *      release the bus after transmitting. This must be done when
  1708.  *      the transmit shift register is empty, not be done when the
  1709.  *      transmit holding register is empty.  This functionality
  1710.  *      allows an RS485 driver to be written in user space. 
  1711.  *****************************************************************************/
  1712. static int get_lsr_info(struct edgeport_port *edge_port, unsigned int *value)
  1713. {
  1714. unsigned int result = 0;
  1716. if (edge_port->maxTxCredits == edge_port->txCredits &&
  1717.     edge_port->txfifo.count == 0) {
  1718. dbg(__FUNCTION__" -- Empty");
  1719. result = TIOCSER_TEMT;
  1720. }
  1722. if (copy_to_user(value, &result, sizeof(int)))
  1723. return -EFAULT;
  1724. return 0;
  1725. }
  1727. static int get_number_bytes_avail(struct edgeport_port *edge_port, unsigned int *value)
  1728. {
  1729. unsigned int result = 0;
  1730. struct tty_struct *tty = edge_port->port->tty;
  1732. result = tty->read_cnt;
  1734. dbg(__FUNCTION__"(%d) = %d",  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(__FUNCTION__" -- %x", 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(__FUNCTION__" - port %d, cmd = 0x%x", port->number, cmd);
  1852. switch (cmd) {
  1853. // return number of bytes available
  1854. case TIOCINQ:
  1855. dbg(__FUNCTION__" (%d) TIOCINQ",  port->number);
  1856. return get_number_bytes_avail(edge_port, (unsigned int *) arg);
  1857. break;
  1859. case TIOCSERGETLSR:
  1860. dbg(__FUNCTION__" (%d) TIOCSERGETLSR",  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(__FUNCTION__" (%d) TIOCMSET/TIOCMBIC/TIOCMSET",  port->number);
  1868. return set_modem_info(edge_port, cmd, (unsigned int *) arg);
  1870. case TIOCMGET:  
  1871. dbg(__FUNCTION__" (%d) TIOCMGET",  port->number);
  1872. return get_modem_info(edge_port, (unsigned int *) arg);
  1874. case TIOCGSERIAL:
  1875. dbg(__FUNCTION__" (%d) TIOCGSERIAL",  port->number);
  1876. return get_serial_info(edge_port, (struct serial_struct *) arg);
  1878. case TIOCSSERIAL:
  1879. dbg(__FUNCTION__" (%d) TIOCSSERIAL",  port->number);
  1880. break;
  1882. case TIOCMIWAIT:
  1883. dbg(__FUNCTION__" (%d) TIOCMIWAIT",  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(__FUNCTION__" (%d) TIOCGICOUNT RX=%d, TX=%d",  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(__FUNCTION__" - Sending IOSP_CMD_CHASE_PORT");
  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(__FUNCTION__" - Sending IOSP_CMD_SET_BREAK");
  1952. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_BREAK, 0);
  1953. } else {
  1954. dbg(__FUNCTION__" - Sending IOSP_CMD_CLEAR_BREAK");
  1955. status = send_iosp_ext_cmd (edge_port, IOSP_CMD_CLEAR_BREAK, 0);
  1956. }
  1957. if (status) {
  1958. dbg(__FUNCTION__" - error sending break set/clear command.");
  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(__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(__FUNCTION__" - stuck in loop, exiting it.");
  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(__FUNCTION__" - Hdr1=%02X Hdr2=%02X", 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(__FUNCTION__" - Data for Port %u Len %u", 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 (__FUNCTION__" - Sending %d bytes to TTY for port %d", 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 (__FUNCTION__ " - edge_port == NULL for port %d", edge_serial->rxPort);
  2126. return;
  2127. }
  2129. dbg(__FUNCTION__" - port %d", 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(__FUNCTION__" - Port %u EXT CHASE_RSP Data = %02x", 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( __FUNCTION__" ========== Port %u CHECK_RSP Sequence = %02x =============n", 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 (__FUNCTION__" - Port %u Open Response Inital MSR = %02x TxBufferSize = %d", 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. change_port_settings (edge_port, edge_port->port->tty->termios);
  2161. /* we have completed the open */
  2162. edge_port->openPending = FALSE;
  2163. edge_port->open = TRUE;
  2164. wake_up_interruptible(&edge_port->wait_open);
  2165. return;
  2166. }
  2168. // If port is closed, silently discard all rcvd status. We can
  2169. // have cases where buffered status is received AFTER the close
  2170. // port command is sent to the Edgeport.
  2171. if ((!edge_port->open ) || (edge_port->closePending)) {
  2172. return;
  2173. }
  2175. switch (code) {
  2176. // Not currently sent by Edgeport
  2177. case IOSP_STATUS_LSR:
  2178. dbg(__FUNCTION__" - Port %u LSR Status = %02x", edge_serial->rxPort, byte2);
  2179. handle_new_lsr (edge_port, FALSE, byte2, 0);
  2180. break;
  2182. case IOSP_STATUS_LSR_DATA:
  2183. dbg(__FUNCTION__" - Port %u LSR Status = %02x, Data = %02x", edge_serial->rxPort, byte2, byte3);
  2184. // byte2 is LSR Register
  2185. // byte3 is broken data byte
  2186. handle_new_lsr (edge_port, TRUE, byte2, byte3);
  2187. break;
  2188. //
  2189. // case IOSP_EXT_4_STATUS:
  2190. // dbg(__FUNCTION__" - Port %u LSR Status = %02x Data = %02x", edge_serial->rxPort, byte2, byte3);
  2191. // break;
  2192. //
  2193. case IOSP_STATUS_MSR:
  2194. dbg(__FUNCTION__" - Port %u MSR Status = %02x", edge_serial->rxPort, byte2);
  2196. // Process this new modem status and generate appropriate
  2197. // events, etc, based on the new status. This routine
  2198. // also saves the MSR in Port->ShadowMsr.
  2199. handle_new_msr(edge_port, byte2);
  2200. break;
  2202. default:
  2203. dbg(__FUNCTION__" - Unrecognized IOSP status code %un", code);
  2204. break;
  2205. }
  2207. return;
  2208. }
  2211. /*****************************************************************************
  2212.  * handle_new_msr
  2213.  * this function handles any change to the msr register for a port.
  2214.  *****************************************************************************/
  2215. static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
  2216. {
  2217. struct  async_icount *icount;
  2219. dbg(__FUNCTION__" %02x", newMsr);
  2221. if (newMsr & (MSR_DELTA_CTS | MSR_DELTA_DSR | MSR_DELTA_RI | MSR_DELTA_CD)) {
  2222. icount = &edge_port->icount;
  2224. /* update input line counters */
  2225. if (newMsr & MSR_DELTA_CTS) {
  2226. icount->cts++;
  2227. }
  2228. if (newMsr & MSR_DELTA_DSR) {
  2229. icount->dsr++;
  2230. }
  2231. if (newMsr & MSR_DELTA_CD) {
  2232. icount->dcd++;
  2233. }
  2234. if (newMsr & MSR_DELTA_RI) {
  2235. icount->rng++;
  2236. }
  2237. wake_up_interruptible(&edge_port->delta_msr_wait);
  2238. }
  2240. /* Save the new modem status */
  2241. edge_port->shadowMSR = newMsr & 0xf0;
  2243. return;
  2244. }
  2247. /*****************************************************************************
  2248.  * handle_new_lsr
  2249.  * this function handles any change to the lsr register for a port.
  2250.  *****************************************************************************/
  2251. static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, __u8 lsr, __u8 data)
  2252. {
  2253. __u8    newLsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
  2254. struct  async_icount *icount;
  2256. dbg(__FUNCTION__" - %02x", newLsr);
  2258. edge_port->shadowLSR = lsr;
  2260. if (newLsr & LSR_BREAK) {
  2261. //
  2262. // Parity and Framing errors only count if they
  2263. // occur exclusive of a break being
  2264. // received.
  2265. //
  2266. newLsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
  2267. }
  2269. /* Place LSR data byte into Rx buffer */
  2270. if (lsrData) {
  2271. tty_insert_flip_char(edge_port->port->tty, data, 0);
  2272. tty_flip_buffer_push(edge_port->port->tty);
  2273. }
  2275. /* update input line counters */
  2276. icount = &edge_port->icount;
  2277. if (newLsr & LSR_BREAK) {
  2278. icount->brk++;
  2279. }
  2280. if (newLsr & LSR_OVER_ERR) {
  2281. icount->overrun++;
  2282. }
  2283. if (newLsr & LSR_PAR_ERR) {
  2284. icount->parity++;
  2285. }
  2286. if (newLsr & LSR_FRM_ERR) {
  2287. icount->frame++;
  2288. }
  2290. return;
  2291. }
  2294. /****************************************************************************
  2295.  * sram_write
  2296.  * writes a number of bytes to the Edgeport device's sram starting at the 
  2297.  * given address.
  2298.  * If successful returns the number of bytes written, otherwise it returns
  2299.  * a negative error number of the problem.
  2300.  ****************************************************************************/
  2301. static int sram_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2302. {
  2303. int result;
  2304. __u16 current_length;
  2305. unsigned char *transfer_buffer;
  2307. // dbg (__FUNCTION__" - %x, %x, %d", extAddr, addr, length);
  2309. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2310. if (!transfer_buffer) {
  2311. err(__FUNCTION__" - kmalloc(%d) failed.n", 64);
  2312. return -ENOMEM;
  2313. }
  2315. /* need to split these writes up into 64 byte chunks */
  2316. result = 0;
  2317. while (length > 0) {
  2318. if (length > 64) {
  2319. current_length = 64;
  2320. } else {
  2321. current_length = length;
  2322. }
  2323. // dbg (__FUNCTION__" - writing %x, %x, %d", extAddr, addr, current_length);
  2324. memcpy (transfer_buffer, data, current_length);
  2325. result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), USB_REQUEST_ION_WRITE_RAM, 
  2326.   0x40, addr, extAddr, transfer_buffer, current_length, 300);
  2327. if (result < 0)
  2328. break;
  2329. length -= current_length;
  2330. addr += current_length;
  2331. data += current_length;
  2332. }       
  2334. kfree (transfer_buffer);
  2335. return result;
  2336. }
  2339. /****************************************************************************
  2340.  * rom_write
  2341.  * writes a number of bytes to the Edgeport device's ROM starting at the
  2342.  * given address.
  2343.  * If successful returns the number of bytes written, otherwise it returns
  2344.  * a negative error number of the problem.
  2345.  ****************************************************************************/
  2346. static int rom_write (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2347. {
  2348. int result;
  2349. __u16 current_length;
  2350. unsigned char *transfer_buffer;
  2352. // dbg (__FUNCTION__" - %x, %x, %d", extAddr, addr, length);
  2354. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2355. if (!transfer_buffer) {
  2356. err(__FUNCTION__" - kmalloc(%d) failed.n", 64);
  2357. return -ENOMEM;
  2358. }
  2360. /* need to split these writes up into 64 byte chunks */
  2361. result = 0;
  2362. while (length > 0) {
  2363. if (length > 64) {
  2364. current_length = 64;
  2365. } else {
  2366. current_length = length;
  2367. }
  2368. // dbg (__FUNCTION__" - writing %x, %x, %d", extAddr, addr, current_length);
  2369. memcpy (transfer_buffer, data, current_length);
  2370. result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), USB_REQUEST_ION_WRITE_ROM, 
  2371.   0x40, addr, extAddr, transfer_buffer, current_length, 300);
  2372. if (result < 0)
  2373. break;
  2374. length -= current_length;
  2375. addr += current_length;
  2376. data += current_length;
  2377. }       
  2379. kfree (transfer_buffer);
  2380. return result;
  2381. }
  2384. /****************************************************************************
  2385.  * rom_read
  2386.  * reads a number of bytes from the Edgeport device starting at the given
  2387.  * address.
  2388.  * If successful returns the number of bytes read, otherwise it returns
  2389.  * a negative error number of the problem.
  2390.  ****************************************************************************/
  2391. static int rom_read (struct usb_serial *serial, __u16 extAddr, __u16 addr, __u16 length, __u8 *data)
  2392. {
  2393. int result;
  2394. __u16 current_length;
  2395. unsigned char *transfer_buffer;
  2397. dbg (__FUNCTION__" - %x, %x, %d", extAddr, addr, length);
  2399. transfer_buffer =  kmalloc (64, GFP_KERNEL);
  2400. if (!transfer_buffer) {
  2401. err(__FUNCTION__" - kmalloc(%d) failed.n", 64);
  2402. return -ENOMEM;
  2403. }
  2405. /* need to split these reads up into 64 byte chunks */
  2406. result = 0;
  2407. while (length > 0) {
  2408. if (length > 64) {
  2409. current_length = 64;
  2410. } else {
  2411. current_length = length;
  2412. }
  2413. // dbg (__FUNCTION__" - %x, %x, %d", extAddr, addr, current_length);
  2414. result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0), USB_REQUEST_ION_READ_ROM, 
  2415.   0xC0, addr, extAddr, transfer_buffer, current_length, 300);
  2416. if (result < 0)
  2417. break;
  2418. memcpy (data, transfer_buffer, current_length);
  2419. length -= current_length;
  2420. addr += current_length;
  2421. data += current_length;
  2422. }       
  2424. kfree (transfer_buffer);
  2425. return result;
  2426. }
  2429. /****************************************************************************
  2430.  * send_iosp_ext_cmd
  2431.  * Is used to send a IOSP message to the Edgeport device
  2432.  ****************************************************************************/
  2433. static int send_iosp_ext_cmd (struct edgeport_port *edge_port, __u8 command, __u8 param)
  2434. {
  2435. unsigned char   *buffer;
  2436. unsigned char   *currentCommand;
  2437. int             length = 0;
  2438. int             status = 0;
  2440. dbg(__FUNCTION__" - %d, %d", command, param);
  2442. buffer =  kmalloc (10, GFP_KERNEL);
  2443. if (!buffer) {
  2444. err(__FUNCTION__" - kmalloc(%d) failed.n", 10);
  2445. return -ENOMEM;
  2446. }
  2448. currentCommand = buffer;
  2450. MAKE_CMD_EXT_CMD( &currentCommand, &length, edge_port->port->number, command, param);
  2452. status = write_cmd_usb (edge_port, buffer, length);
  2453. if (status) {
  2454. /* something bad happened, let's free up the memory */
  2455. kfree(buffer);
  2456. }
  2458. return status;
  2459. }
  2462. /*****************************************************************************
  2463.  * write_cmd_usb
  2464.  * this function writes the given buffer out to the bulk write endpoint.
  2465.  *****************************************************************************/
  2466. static int write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer, int length)
  2467. {
  2468. struct edgeport_serial *edge_serial = (struct edgeport_serial *)edge_port->port->serial->private;
  2469. int status = 0;
  2470. urb_t *urb;
  2471. int timeout;
  2473. usb_serial_debug_data (__FILE__, __FUNCTION__, length, buffer);
  2475. /* Allocate our next urb */
  2476. urb = usb_alloc_urb (0);
  2477. if (!urb)
  2478. return -ENOMEM;
  2480. CmdUrbs++;
  2481. dbg(__FUNCTION__" - ALLOCATE URB %p (outstanding %d)", urb, CmdUrbs);
  2483. FILL_BULK_URB (urb, edge_serial->serial->dev, 
  2484.        usb_sndbulkpipe(edge_serial->serial->dev, edge_serial->bulk_out_endpoint),
  2485.        buffer, length, edge_bulk_out_cmd_callback, edge_port);
  2487. /* set the USB_BULK_QUEUE flag so that we can shove a bunch of urbs at once down the pipe */
  2488. urb->transfer_flags |= USB_QUEUE_BULK;
  2490. edge_port->commandPending = TRUE;
  2491. status = usb_submit_urb(urb);
  2493. if (status) {
  2494. /* something went wrong */
  2495. dbg(__FUNCTION__" - usb_submit_urb(write bulk) failed");
  2496. usb_unlink_urb (urb);
  2497. usb_free_urb   (urb);
  2498. return status;
  2499. }
  2501. // wait for command to finish
  2502. timeout = COMMAND_TIMEOUT;
  2503. #if 0
  2504. while (timeout && edge_port->commandPending == TRUE) {
  2505. timeout = interruptible_sleep_on_timeout (&edge_port->wait_command, timeout);
  2506. }
  2508. if (edge_port->commandPending == TRUE) {
  2509. /* command timed out */
  2510. dbg(__FUNCTION__" - command timed out");
  2511. status = -EINVAL;
  2512. }
  2513. #endif
  2514. return status;
  2515. }
  2518. /*****************************************************************************
  2519.  * send_cmd_write_baud_rate
  2520.  * this function sends the proper command to change the baud rate of the
  2521.  * specified port.
  2522.  *****************************************************************************/
  2523. static int send_cmd_write_baud_rate (struct edgeport_port *edge_port, int baudRate)
  2524. {
  2525. unsigned char *cmdBuffer;
  2526. unsigned char *currCmd;
  2527. int cmdLen = 0;
  2528. int divisor;
  2529. int status;
  2530. unsigned char number = edge_port->port->number;
  2532. dbg(__FUNCTION__" - port = %d, baud = %d", number, baudRate);
  2534. status = calc_baud_rate_divisor (baudRate, &divisor);
  2535. if (status) {
  2536. err(__FUNCTION__" - bad baud rate");
  2537. return status;
  2538. }
  2540. // Alloc memory for the string of commands.
  2541. cmdBuffer =  kmalloc (0x100, GFP_KERNEL);
  2542. if (!cmdBuffer) {
  2543. err(__FUNCTION__" - kmalloc(%d) failed.n", 0x100);
  2544. return -ENOMEM;
  2545. }
  2546. currCmd = cmdBuffer;
  2548. // Enable access to divisor latch
  2549. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, LCR, LCR_DL_ENABLE );
  2551. // Write the divisor itself
  2552. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, DLL, LOW8 (divisor) );
  2553. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, DLM, HIGH8(divisor) );
  2555. // Restore original value to disable access to divisor latch
  2556. MAKE_CMD_WRITE_REG( &currCmd, &cmdLen, number, LCR, edge_port->shadowLCR);
  2558. status = write_cmd_usb(edge_port, cmdBuffer, cmdLen );
  2559. if (status) {
  2560. /* something bad happened, let's free up the memory */
  2561. kfree (cmdBuffer);
  2562. }
  2564. return status;
  2565. }
  2568. /*****************************************************************************
  2569.  * calc_baud_rate_divisor
  2570.  * this function calculates the proper baud rate divisor for the specified
  2571.  * baud rate.
  2572.  *****************************************************************************/
  2573. static int calc_baud_rate_divisor (int baudrate, int *divisor)
  2574. {
  2575. int i;
  2576. __u16 custom;
  2577. __u16 round1;
  2578. __u16 round;
  2581. dbg(__FUNCTION__" - %d", baudrate);
  2583. for (i = 0; i < NUM_ENTRIES(DivisorTable); i++) {
  2584. if ( DivisorTable[i].BaudRate == baudrate ) {
  2585. *divisor = DivisorTable[i].Divisor;
  2586. return 0;
  2587. }
  2588. }
  2590. // We have tried all of the standard baud rates
  2591. // lets try to calculate the divisor for this baud rate
  2592. // Make sure the baud rate is reasonable
  2593. if (baudrate > 75 &&  baudrate < 230400) {
  2594. // get divisor
  2595. custom = (__u16)(230400L  / baudrate);
  2597. // Check for round off
  2598. round1 = (__u16)(2304000L / baudrate);
  2599. round = (__u16)(round1 - (custom * 10));
  2600. if (round > 4) {
  2601. custom++;
  2602. }
  2603. *divisor = custom;
  2605. dbg(__FUNCTION__" - Baud %d = %dn", baudrate, custom);
  2606. return 0;
  2607. }
  2609. return -1;
  2610. }
  2613. /*****************************************************************************
  2614.  * send_cmd_write_uart_register
  2615.  * this function builds up a uart register message and sends to to the device.
  2616.  *****************************************************************************/
  2617. static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue)
  2618. {
  2619. unsigned char *cmdBuffer;
  2620. unsigned char *currCmd;
  2621. unsigned long cmdLen = 0;
  2622. int status;
  2624. dbg (__FUNCTION__" - write to %s register 0x%02x", (regNum == MCR) ? "MCR" : "LCR", regValue);
  2626. // Alloc memory for the string of commands.
  2627. cmdBuffer = kmalloc (0x10, GFP_KERNEL);
  2628. if (cmdBuffer == NULL ) {
  2629. return -ENOMEM;
  2630. }
  2632. currCmd = cmdBuffer;
  2634. // Build a cmd in the buffer to write the given register
  2635. MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, edge_port->port->number, regNum, regValue);
  2637. status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
  2638. if (status) {
  2639. /* something bad happened, let's free up the memory */
  2640. kfree (cmdBuffer);
  2641. }
  2643. return status;
  2644. }
  2647. /*****************************************************************************
  2648.  * change_port_settings
  2649.  * This routine is called to set the UART on the device to match the specified
  2650.  * new settings.
  2651.  *****************************************************************************/
  2652. static void change_port_settings (struct edgeport_port *edge_port, struct termios *old_termios)
  2653. {
  2654. struct tty_struct *tty;
  2655. int baud;
  2656. unsigned cflag;
  2657. __u8 mask = 0xff;
  2658. __u8 lData;
  2659. __u8 lParity;
  2660. __u8 lStop;
  2661. __u8 rxFlow;
  2662. __u8 txFlow;
  2663. int status;
  2665. dbg(__FUNCTION__" - port %d", edge_port->port->number);
  2667. if ((!edge_port->open) &&
  2668.     (!edge_port->openPending)) {
  2669. dbg(__FUNCTION__" - port not opened");
  2670. return;
  2671. }
  2673. tty = edge_port->port->tty;
  2674. if ((!tty) ||
  2675.     (!tty->termios)) {
  2676. dbg(__FUNCTION__" - no tty structures");
  2677. return;
  2678. }
  2680. cflag = tty->termios->c_cflag;
  2682. switch (cflag & CSIZE) {
  2683. case CS5:   lData = LCR_BITS_5; mask = 0x1f;    dbg(__FUNCTION__" - data bits = 5");   break;
  2684. case CS6:   lData = LCR_BITS_6; mask = 0x3f;    dbg(__FUNCTION__" - data bits = 6");   break;
  2685. case CS7:   lData = LCR_BITS_7; mask = 0x7f;    dbg(__FUNCTION__" - data bits = 7");   break;
  2686. default:
  2687. case CS8:   lData = LCR_BITS_8;                 dbg(__FUNCTION__" - data bits = 8");   break;
  2688. }
  2690. lParity = LCR_PAR_NONE;
  2691. if (cflag & PARENB) {
  2692. if (cflag & PARODD) {
  2693. lParity = LCR_PAR_ODD;
  2694. dbg(__FUNCTION__" - parity = odd");
  2695. } else {
  2696. lParity = LCR_PAR_EVEN;
  2697. dbg(__FUNCTION__" - parity = even");
  2698. }
  2699. } else {
  2700. dbg(__FUNCTION__" - parity = none");
  2701. }
  2703. if (cflag & CSTOPB) {
  2704. lStop = LCR_STOP_2;
  2705. dbg(__FUNCTION__" - stop bits = 2");
  2706. } else {
  2707. lStop = LCR_STOP_1;
  2708. dbg(__FUNCTION__" - stop bits = 1");
  2709. }
  2711. /* figure out the flow control settings */
  2712. rxFlow = txFlow = 0x00;
  2713. if (cflag & CRTSCTS) {
  2714. rxFlow |= IOSP_RX_FLOW_RTS;
  2715. txFlow |= IOSP_TX_FLOW_CTS;
  2716. dbg(__FUNCTION__" - RTS/CTS is enabled");
  2717. } else {
  2718. dbg(__FUNCTION__" - RTS/CTS is disabled");
  2719. }
  2721. /* if we are implementing XON/XOFF, set the start and stop character in the device */
  2722. if (I_IXOFF(tty) || I_IXON(tty)) {
  2723. unsigned char stop_char  = STOP_CHAR(tty);
  2724. unsigned char start_char = START_CHAR(tty);
  2726. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_XON_CHAR, start_char);
  2727. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_XOFF_CHAR, stop_char);
  2729. /* if we are implementing INBOUND XON/XOFF */
  2730. if (I_IXOFF(tty)) {
  2731. rxFlow |= IOSP_RX_FLOW_XON_XOFF;
  2732. dbg(__FUNCTION__" - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x", start_char, stop_char);
  2733. } else {
  2734. dbg(__FUNCTION__" - INBOUND XON/XOFF is disabled");
  2735. }
  2737. /* if we are implementing OUTBOUND XON/XOFF */
  2738. if (I_IXON(tty)) {
  2739. txFlow |= IOSP_TX_FLOW_XON_XOFF;
  2740. dbg(__FUNCTION__" - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x", start_char, stop_char);
  2741. } else {
  2742. dbg(__FUNCTION__" - OUTBOUND XON/XOFF is disabled");
  2743. }
  2744. }
  2746. /* Set flow control to the configured value */
  2747. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_RX_FLOW, rxFlow);
  2748. send_iosp_ext_cmd (edge_port, IOSP_CMD_SET_TX_FLOW, txFlow);
  2751. edge_port->shadowLCR &= ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
  2752. edge_port->shadowLCR |= (lData | lParity | lStop);
  2754. edge_port->validDataMask = mask;
  2756. /* Send the updated LCR value to the EdgePort */
  2757. status = send_cmd_write_uart_register(edge_port, LCR, edge_port->shadowLCR);
  2758. if (status != 0) {
  2759. return;
  2760. }
  2762. /* set up the MCR register and send it to the EdgePort */
  2763. edge_port->shadowMCR = MCR_MASTER_IE;
  2764. if (cflag & CBAUD) {
  2765. edge_port->shadowMCR |= (MCR_DTR | MCR_RTS);
  2766. }
  2767. status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
  2768. if (status != 0) {
  2769. return;
  2770. }
  2772. /* Determine divisor based on baud rate */
  2773. baud = tty_get_baud_rate(tty);
  2774. if (!baud) {
  2775. /* pick a default, any default... */
  2776. baud = 9600;
  2777. }
  2779. dbg(__FUNCTION__ " - baud rate = %d", baud);
  2780. status = send_cmd_write_baud_rate (edge_port, baud);
  2782. return;
  2783. }
  2786. /****************************************************************************
  2787.  * unicode_to_ascii
  2788.  * Turns a string from Unicode into ASCII.
  2789.  * Doesn't do a good job with any characters that are outside the normal
  2790.  * ASCII range, but it's only for debugging...
  2791.  ****************************************************************************/
  2792. static void unicode_to_ascii (char *string, short *unicode, int unicode_size)
  2793. {
  2794. int i;
  2795. for (i = 0; i < unicode_size; ++i) {
  2796. string[i] = (char)(unicode[i]);
  2797. }
  2798. string[unicode_size] = 0x00;
  2799. }
  2802. /****************************************************************************
  2803.  * get_manufacturing_desc
  2804.  * reads in the manufacturing descriptor and stores it into the serial 
  2805.  * structure.
  2806.  ****************************************************************************/
  2807. static void get_manufacturing_desc (struct edgeport_serial *edge_serial)
  2808. {
  2809. int response;
  2811. dbg("getting manufacturer descriptor");
  2813. response = rom_read (edge_serial->serial, (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16, 
  2814.     (__u16)(EDGE_MANUF_DESC_ADDR & 0x0000ffff), EDGE_MANUF_DESC_LEN,
  2815.     (__u8 *)(&edge_serial->manuf_descriptor));
  2817. if (response < 1) {
  2818. err("error in getting manufacturer descriptor");
  2819. } else {
  2820. char string[30];
  2821. dbg("**Manufacturer Descriptor");
  2822. dbg("  RomSize:        %dK", edge_serial->manuf_descriptor.RomSize);
  2823. dbg("  RamSize:        %dK", edge_serial->manuf_descriptor.RamSize);
  2824. dbg("  CpuRev:         %d", edge_serial->manuf_descriptor.CpuRev);
  2825. dbg("  BoardRev:       %d", edge_serial->manuf_descriptor.BoardRev);
  2826. dbg("  NumPorts:       %d", edge_serial->manuf_descriptor.NumPorts);
  2827. dbg("  DescDate:       %d/%d/%d", edge_serial->manuf_descriptor.DescDate[0], edge_serial->manuf_descriptor.DescDate[1], edge_serial->manuf_descriptor.DescDate[2]+1900);
  2828. unicode_to_ascii (string, edge_serial->manuf_descriptor.SerialNumber, edge_serial->manuf_descriptor.SerNumLength/2-1);
  2829. dbg("  SerialNumber: %s", string);
  2830. unicode_to_ascii (string, edge_serial->manuf_descriptor.AssemblyNumber, edge_serial->manuf_descriptor.AssemblyNumLength/2-1);
  2831. dbg("  AssemblyNumber: %s", string);
  2832. unicode_to_ascii (string, edge_serial->manuf_descriptor.OemAssyNumber, edge_serial->manuf_descriptor.OemAssyNumLength/2-1);
  2833. dbg("  OemAssyNumber:  %s", string);
  2834. dbg("  UartType:       %d", edge_serial->manuf_descriptor.UartType);
  2835. dbg("  IonPid:         %d", edge_serial->manuf_descriptor.IonPid);
  2836. dbg("  IonConfig:      %d", edge_serial->manuf_descriptor.IonConfig);
  2837. }
  2838. }
  2841. /****************************************************************************
  2842.  * get_boot_desc
  2843.  * reads in the bootloader descriptor and stores it into the serial 
  2844.  * structure.
  2845.  ****************************************************************************/
  2846. static void get_boot_desc (struct edgeport_serial *edge_serial)
  2847. {
  2848. int response;
  2850. dbg("getting boot descriptor");
  2852. response = rom_read (edge_serial->serial, (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16, 
  2853.     (__u16)(EDGE_BOOT_DESC_ADDR & 0x0000ffff), EDGE_BOOT_DESC_LEN,
  2854.     (__u8 *)(&edge_serial->boot_descriptor));
  2856. if (response < 1) {
  2857. err("error in getting boot descriptor");
  2858. } else {
  2859. dbg("**Boot Descriptor:");
  2860. dbg("  BootCodeLength: %d", edge_serial->boot_descriptor.BootCodeLength);
  2861. dbg("  MajorVersion:   %d", edge_serial->boot_descriptor.MajorVersion);
  2862. dbg("  MinorVersion:   %d", edge_serial->boot_descriptor.MinorVersion);
  2863. dbg("  BuildNumber:    %d", edge_serial->boot_descriptor.BuildNumber);
  2864. dbg("  Capabilities:   0x%x", edge_serial->boot_descriptor.Capabilities);
  2865. dbg("  UConfig0:       %d", edge_serial->boot_descriptor.UConfig0);
  2866. dbg("  UConfig1:       %d", edge_serial->boot_descriptor.UConfig1);
  2867. }
  2868. }
  2871. /****************************************************************************
  2872.  * load_application_firmware
  2873.  * This is called to load the application firmware to the device
  2874.  ****************************************************************************/
  2875. static void load_application_firmware (struct edgeport_serial *edge_serial)
  2876. {
  2877. PEDGE_FIRMWARE_IMAGE_RECORD record;
  2878. unsigned char *firmware;
  2879. unsigned char *FirmwareImage;
  2880. int ImageSize;
  2881. int response;
  2884. switch (edge_serial->product_info.iDownloadFile) {
  2885. case EDGE_DOWNLOAD_FILE_I930:
  2886. dbg("downloading firmware version (930) %d.%d.%d", 
  2887.     OperationalCodeImageVersion_GEN1.MajorVersion, 
  2888.     OperationalCodeImageVersion_GEN1.MinorVersion, 
  2889.     OperationalCodeImageVersion_GEN1.BuildNumber);
  2890. firmware = &OperationalCodeImage_GEN1[0];
  2891. FirmwareImage = &OperationalCodeImage_GEN1[0];
  2892. ImageSize = sizeof(OperationalCodeImage_GEN1);
  2893. break;
  2895. case EDGE_DOWNLOAD_FILE_80251:
  2896. dbg("downloading firmware version (80251) %d.%d.%d", 
  2897.     OperationalCodeImageVersion_GEN2.MajorVersion, 
  2898.     OperationalCodeImageVersion_GEN2.MinorVersion, 
  2899.     OperationalCodeImageVersion_GEN2.BuildNumber);
  2900. firmware = &OperationalCodeImage_GEN2[0];
  2901. FirmwareImage = &OperationalCodeImage_GEN2[0];
  2902. ImageSize = sizeof(OperationalCodeImage_GEN2);
  2903. break;
  2905. case EDGE_DOWNLOAD_FILE_NONE:
  2906. dbg     ("No download file specified, skipping downloadn");
  2907. return;
  2909. default:
  2910. return;
  2911. }
  2914. for (;;) {
  2915. record = (PEDGE_FIRMWARE_IMAGE_RECORD)firmware;
  2916. response = sram_write (edge_serial->serial, record->ExtAddr, record->Addr, record->Len, &record->Data[0]);
  2917. if (response < 0) {
  2918. err("sram_write failed (%x, %x, %d)", record->ExtAddr, record->Addr, record->Len);
  2919. break;
  2920. }
  2921. firmware += sizeof (EDGE_FIRMWARE_IMAGE_RECORD) + record->Len;
  2922. if (firmware >= &FirmwareImage[ImageSize]) {
  2923. break;
  2924. }
  2925. }
  2927. dbg("sending exec_dl_code");
  2928. response = usb_control_msg (edge_serial->serial->dev, 
  2929.     usb_sndctrlpipe(edge_serial->serial->dev, 0), 
  2930.     USB_REQUEST_ION_EXEC_DL_CODE, 
  2931.     0x40, 0x4000, 0x0001, NULL, 0, 3000);
  2933. return;
  2934. }
  2939. /****************************************************************************
  2940.  * edge_startup
  2941.  ****************************************************************************/
  2942. static int edge_startup (struct usb_serial *serial)
  2943. {
  2944. struct edgeport_serial *edge_serial;
  2945. struct edgeport_port *edge_port;
  2946. struct usb_device *dev;
  2947. int i;
  2949. dev = serial->dev;
  2951. /* create our private serial structure */
  2952. edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
  2953. if (edge_serial == NULL) {
  2954. err(__FUNCTION__" - Out of memory");
  2955. return -ENOMEM;
  2956. }
  2957. memset (edge_serial, 0, sizeof(struct edgeport_serial));
  2958. edge_serial->serial = serial;
  2959. serial->private = edge_serial;
  2961. /* get the name for the device from the device */
  2962. if ( (i = get_string(dev, dev->descriptor.iManufacturer, &edge_serial->name[0])) != 0) {
  2963. edge_serial->name[i-1] = ' ';
  2964. }
  2966. get_string(dev, dev->descriptor.iProduct, &edge_serial->name[i]);
  2968. info("%s detected", edge_serial->name);
  2970. /* get the manufacturing descriptor for this device */
  2971. get_manufacturing_desc (edge_serial);
  2973. /* get the boot descriptor */
  2974. get_boot_desc (edge_serial);
  2976. get_product_info(edge_serial);
  2978. /* set the number of ports from the manufacturing description */
  2979. /* serial->num_ports = serial->product_info.NumPorts; */
  2980. if (edge_serial->product_info.NumPorts != serial->num_ports) {
  2981. warn(__FUNCTION__ " - Device Reported %d serial ports vs core "
  2982.      "thinking we have %d ports, email greg@kroah.com this info.",
  2983.      edge_serial->product_info.NumPorts, serial->num_ports);
  2984. }
  2986. dbg(__FUNCTION__ " - time 1 %ld", jiffies);
  2988. /* now load the application firmware into this device */
  2989. load_application_firmware (edge_serial);
  2991. dbg(__FUNCTION__ " - time 2 %ld", jiffies);
  2993. /* Check current Edgeport EEPROM and update if necessary */
  2994. update_edgeport_E2PROM (edge_serial);
  2996. dbg(__FUNCTION__ " - time 3 %ld", jiffies);
  2998. /* set the configuration to use #1 */
  2999. // dbg("set_configuration 1");
  3000. // usb_set_configuration (dev, 1);
  3002. /* we set up the pointers to the endpoints in the edge_open function, 
  3003.  * as the structures aren't created yet. */
  3005. /* set up our port private structures */
  3006. for (i = 0; i < serial->num_ports; ++i) {
  3007. edge_port = kmalloc (sizeof(struct edgeport_port), GFP_KERNEL);
  3008. if (edge_port == NULL) {
  3009. err(__FUNCTION__" - Out of memory");
  3010. return -ENOMEM;
  3011. }
  3012. memset (edge_port, 0, sizeof(struct edgeport_port));
  3013. edge_port->port = &serial->port[i];
  3014. serial->port[i].private = edge_port;
  3015. }
  3017. return 0;
  3018. }
  3022. /****************************************************************************
  3023.  * edge_shutdown
  3024.  * This function is called whenever the device is removed from the usb bus.
  3025.  ****************************************************************************/
  3026. static void edge_shutdown (struct usb_serial *serial)
  3027. {
  3028. int i;
  3030. dbg (__FUNCTION__);
  3032. /* stop reads and writes on all ports */
  3033. for (i=0; i < serial->num_ports; ++i) {
  3034. while (serial->port[i].open_count > 0) {
  3035. edge_close (&serial->port[i], NULL);
  3036. }
  3037. kfree (serial->port[i].private);
  3038. serial->port[i].private = NULL;
  3039. }
  3040. kfree (serial->private);
  3041. serial->private = NULL;
  3042. }
  3045. /****************************************************************************
  3046.  * edgeport_init
  3047.  * This is called by the module subsystem, or on startup to initialize us
  3048.  ****************************************************************************/
  3049. int __init edgeport_init(void)
  3050. {
  3051. usb_serial_register (&edgeport_1port_device);
  3052. usb_serial_register (&edgeport_2port_device);
  3053. usb_serial_register (&edgeport_4port_device);
  3054. usb_serial_register (&edgeport_8port_device);
  3055. info(DRIVER_DESC " " DRIVER_VERSION);
  3056. return 0;
  3057. }
  3061. /****************************************************************************
  3062.  * edgeport_exit
  3063.  * Called when the driver is about to be unloaded.
  3064.  ****************************************************************************/
  3065. void __exit edgeport_exit (void)
  3066. {
  3067. usb_serial_deregister (&edgeport_1port_device);
  3068. usb_serial_deregister (&edgeport_2port_device);
  3069. usb_serial_deregister (&edgeport_4port_device);
  3070. usb_serial_deregister (&edgeport_8port_device);
  3071. }
  3073. module_init(edgeport_init);
  3074. module_exit(edgeport_exit);
  3076. /* Module information */
  3077. MODULE_AUTHOR( DRIVER_AUTHOR );
  3078. MODULE_DESCRIPTION( DRIVER_DESC );
  3079. MODULE_LICENSE("GPL");
  3081. MODULE_PARM(debug, "i");
  3082. MODULE_PARM_DESC(debug, "Debug enabled or not");