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

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

嵌入式Linux

开发平台：

Unix_Linux

farsync.c：源码内容
  1. /*
  2.  *      FarSync X21 driver for Linux (2.4.x kernel version)
  3.  *
  4.  *      Actually sync driver for X.21, V.35 and V.24 on FarSync T-series cards
  5.  *
  6.  *      Copyright (C) 2001 FarSite Communications Ltd.
  7.  *      www.farsite.co.uk
  8.  *
  9.  *      This program is free software; you can redistribute it and/or
  10.  *      modify it under the terms of the GNU General Public License
  11.  *      as published by the Free Software Foundation; either version
  12.  *      2 of the License, or (at your option) any later version.
  13.  *
  14.  *      Author: R.J.Dunlop      <bob.dunlop@farsite.co.uk>
  15.  */
  17. #include <linux/module.h>
  18. #include <linux/kernel.h>
  19. #include <linux/pci.h>
  20. #include <linux/ioport.h>
  21. #include <linux/netdevice.h>
  22. #include <linux/init.h>
  23. #include <linux/if_arp.h>
  24. #include <asm/uaccess.h>
  25. #include <net/syncppp.h>
  27. #include "farsync.h"
  30. /*
  31.  *      Module info
  32.  */
  33. MODULE_AUTHOR("R.J.Dunlop <bob.dunlop@farsite.co.uk>");
  34. MODULE_DESCRIPTION("FarSync T-Series X21 driver. FarSite Communications Ltd.");
  36. EXPORT_NO_SYMBOLS;
  39. /*      Driver configuration and global parameters
  40.  *      ==========================================
  41.  */
  43. /*      Number of ports (per card) supported
  44.  */
  45. #define FST_MAX_PORTS           4
  48. /*      PCI vendor and device IDs
  49.  */
  50. #define FSC_PCI_VENDOR_ID       0x1619  /* FarSite Communications Ltd */
  51. #define T2P_PCI_DEVICE_ID       0x0400  /* T2P X21 2 port card */
  52. #define T4P_PCI_DEVICE_ID       0x0440  /* T4P X21 4 port card */
  55. /*      Default parameters for the link
  56.  */
  57. #define FST_TX_QUEUE_LEN        100     /* At 8Mbps a longer queue length is
  58.                                          * useful, the syncppp module forces
  59.                                          * this down assuming a slower line I
  60.                                          * guess.
  61.                                          */
  62. #define FST_MAX_MTU             8000    /* Huge but possible */
  63. #define FST_DEF_MTU             1500    /* Common sane value */
  65. #define FST_TX_TIMEOUT          (2*HZ)
  68. #ifdef ARPHRD_RAWHDLC
  69. #define ARPHRD_MYTYPE   ARPHRD_RAWHDLC  /* Raw frames */
  70. #else
  71. #define ARPHRD_MYTYPE   ARPHRD_HDLC     /* Cisco-HDLC (keepalives etc) */
  72. #endif
  75. /*      Card shared memory layout
  76.  *      =========================
  77.  */
  78. #pragma pack(1)
  80. /*      This information is derived in part from the FarSite FarSync Smc.h
  81.  *      file. Unfortunately various name clashes and the non-portability of the
  82.  *      bit field declarations in that file have meant that I have chosen to
  83.  *      recreate the information here.
  84.  *
  85.  *      The SMC (Shared Memory Configuration) has a version number that is
  86.  *      incremented every time there is a significant change. This number can
  87.  *      be used to check that we have not got out of step with the firmware
  88.  *      contained in the .CDE files.
  89.  */
  90. #define SMC_VERSION 11
  92. #define FST_MEMSIZE 0x100000    /* Size of card memory (1Mb) */
  94. #define SMC_BASE 0x00002000L    /* Base offset of the shared memory window main
  95.                                  * configuration structure */
  96. #define BFM_BASE 0x00010000L    /* Base offset of the shared memory window DMA
  97.                                  * buffers */
  99. #define LEN_TX_BUFFER 8192      /* Size of packet buffers */
  100. #define LEN_RX_BUFFER 8192
  102. #define LEN_SMALL_TX_BUFFER 256 /* Size of obsolete buffs used for DOS diags */
  103. #define LEN_SMALL_RX_BUFFER 256
  105. #define NUM_TX_BUFFER 2         /* Must be power of 2. Fixed by firmware */
  106. #define NUM_RX_BUFFER 8
  108. /* Interrupt retry time in milliseconds */
  109. #define INT_RETRY_TIME 2
  112. /*      The Am186CH/CC processors support a SmartDMA mode using circular pools
  113.  *      of buffer descriptors. The structure is almost identical to that used
  114.  *      in the LANCE Ethernet controllers. Details available as PDF from the
  115.  *      AMD web site: http://www.amd.com/products/epd/processors/
  116.  *                    2.16bitcont/3.am186cxfa/a21914/21914.pdf
  117.  */
  118. struct txdesc {                 /* Transmit descriptor */
  119.         volatile u16 ladr;      /* Low order address of packet. This is a
  120.                                  * linear address in the Am186 memory space
  121.                                  */
  122.         volatile u8  hadr;      /* High order address. Low 4 bits only, high 4
  123.                                  * bits must be zero
  124.                                  */
  125.         volatile u8  bits;      /* Status and config */
  126.         volatile u16 bcnt;      /* 2s complement of packet size in low 15 bits.
  127.                                  * Transmit terminal count interrupt enable in
  128.                                  * top bit.
  129.                                  */
  130.                  u16 unused;    /* Not used in Tx */
  131. };
  133. struct rxdesc {                 /* Receive descriptor */
  134.         volatile u16 ladr;      /* Low order address of packet */
  135.         volatile u8  hadr;      /* High order address */
  136.         volatile u8  bits;      /* Status and config */
  137.         volatile u16 bcnt;      /* 2s complement of buffer size in low 15 bits.
  138.                                  * Receive terminal count interrupt enable in
  139.                                  * top bit.
  140.                                  */
  141.         volatile u16 mcnt;      /* Message byte count (15 bits) */
  142. };
  144. /* Convert a length into the 15 bit 2's complement */
  145. /* #define cnv_bcnt(len)   (( ~(len) + 1 ) & 0x7FFF ) */
  146. /* Since we need to set the high bit to enable the completion interrupt this
  147.  * can be made a lot simpler
  148.  */
  149. #define cnv_bcnt(len)   (-(len))
  151. /* Status and config bits for the above */
  152. #define DMA_OWN         0x80            /* SmartDMA owns the descriptor */
  153. #define TX_STP          0x02            /* Tx: start of packet */
  154. #define TX_ENP          0x01            /* Tx: end of packet */
  155. #define RX_ERR          0x40            /* Rx: error (OR of next 4 bits) */
  156. #define RX_FRAM         0x20            /* Rx: framing error */
  157. #define RX_OFLO         0x10            /* Rx: overflow error */
  158. #define RX_CRC          0x08            /* Rx: CRC error */
  159. #define RX_HBUF         0x04            /* Rx: buffer error */
  160. #define RX_STP          0x02            /* Rx: start of packet */
  161. #define RX_ENP          0x01            /* Rx: end of packet */
  164. /* Interrupts from the card are caused by various events and these are presented
  165.  * in a circular buffer as several events may be processed on one physical int
  166.  */
  167. #define MAX_CIRBUFF     32
  169. struct cirbuff {
  170.         u8 rdindex;             /* read, then increment and wrap */
  171.         u8 wrindex;             /* write, then increment and wrap */
  172.         u8 evntbuff[MAX_CIRBUFF];
  173. };
  175. /* Interrupt event codes.
  176.  * Where appropriate the two low order bits indicate the port number
  177.  */
  178. #define CTLA_CHG        0x18    /* Control signal changed */
  179. #define CTLB_CHG        0x19
  180. #define CTLC_CHG        0x1A
  181. #define CTLD_CHG        0x1B
  183. #define INIT_CPLT       0x20    /* Initialisation complete */
  184. #define INIT_FAIL       0x21    /* Initialisation failed */
  186. #define ABTA_SENT       0x24    /* Abort sent */
  187. #define ABTB_SENT       0x25
  188. #define ABTC_SENT       0x26
  189. #define ABTD_SENT       0x27
  191. #define TXA_UNDF        0x28    /* Transmission underflow */
  192. #define TXB_UNDF        0x29
  193. #define TXC_UNDF        0x2A
  194. #define TXD_UNDF        0x2B
  197. /* Port physical configuration. See farsync.h for field values */
  198. struct port_cfg {
  199.         u16  lineInterface;     /* Physical interface type */
  200.         u8   x25op;             /* Unused at present */
  201.         u8   internalClock;     /* 1 => internal clock, 0 => external */
  202.         u32  lineSpeed;         /* Speed in bps */
  203. };
  205. /* Finally sling all the above together into the shared memory structure.
  206.  * Sorry it's a hodge podge of arrays, structures and unused bits, it's been
  207.  * evolving under NT for some time so I guess we're stuck with it.
  208.  * The structure starts at offset SMC_BASE.
  209.  * See farsync.h for some field values.
  210.  */
  211. struct fst_shared {
  212.                                 /* DMA descriptor rings */
  213.         struct rxdesc rxDescrRing[FST_MAX_PORTS][NUM_RX_BUFFER];
  214.         struct txdesc txDescrRing[FST_MAX_PORTS][NUM_TX_BUFFER];
  216.                                 /* Obsolete small buffers */
  217.         u8  smallRxBuffer[FST_MAX_PORTS][NUM_RX_BUFFER][LEN_SMALL_RX_BUFFER];
  218.         u8  smallTxBuffer[FST_MAX_PORTS][NUM_TX_BUFFER][LEN_SMALL_TX_BUFFER];
  220.         u8  taskStatus;         /* 0x00 => initialising, 0x01 => running,
  221.                                  * 0xFF => halted
  222.                                  */
  224.         u8  interruptHandshake; /* Set to 0x01 by adapter to signal interrupt,
  225.                                  * set to 0xEE by host to acknowledge interrupt
  226.                                  */
  228.         u16 smcVersion;         /* Must match SMC_VERSION */
  230.         u32 smcFirmwareVersion; /* 0xIIVVRRBB where II = product ID, VV = major
  231.                                  * version, RR = revision and BB = build
  232.                                  */
  234.         u16 txa_done;           /* Obsolete completion flags */
  235.         u16 rxa_done;
  236.         u16 txb_done;
  237.         u16 rxb_done;
  238.         u16 txc_done;
  239.         u16 rxc_done;
  240.         u16 txd_done;
  241.         u16 rxd_done;
  243.         u16 mailbox[4];         /* Diagnostics mailbox. Not used */
  245.         struct cirbuff interruptEvent;  /* interrupt causes */
  247.         u32 v24IpSts[FST_MAX_PORTS];    /* V.24 control input status */
  248.         u32 v24OpSts[FST_MAX_PORTS];    /* V.24 control output status */
  250.         struct port_cfg portConfig[FST_MAX_PORTS];
  252.         u16 clockStatus[FST_MAX_PORTS]; /* lsb: 0=> present, 1=> absent */
  254.         u16 cableStatus;                /* lsb: 0=> present, 1=> absent */
  256.         u16 txDescrIndex[FST_MAX_PORTS]; /* transmit descriptor ring index */
  257.         u16 rxDescrIndex[FST_MAX_PORTS]; /* receive descriptor ring index */
  259.         u16 portMailbox[FST_MAX_PORTS][2];      /* command, modifier */
  260.         u16 cardMailbox[4];                     /* Not used */
  262.                                 /* Number of times that card thinks the host has
  263.                                  * missed an interrupt by not acknowledging
  264.                                  * within 2mS (I guess NT has problems)
  265.                                  */
  266.         u32 interruptRetryCount;
  268.                                 /* Driver private data used as an ID. We'll not
  269.                                  * use this on Linux I'd rather keep such things
  270.                                  * in main memory rather than on the PCI bus
  271.                                  */
  272.         u32 portHandle[FST_MAX_PORTS];
  274.                                 /* Count of Tx underflows for stats */
  275.         u32 transmitBufferUnderflow[FST_MAX_PORTS];
  277.                                 /* Debounced V.24 control input status */
  278.         u32 v24DebouncedSts[FST_MAX_PORTS];
  280.                                 /* Adapter debounce timers. Don't touch */
  281.         u32 ctsTimer[FST_MAX_PORTS];
  282.         u32 ctsTimerRun[FST_MAX_PORTS];
  283.         u32 dcdTimer[FST_MAX_PORTS];
  284.         u32 dcdTimerRun[FST_MAX_PORTS];
  286.         u32 numberOfPorts;      /* Number of ports detected at startup */
  288.         u16 _reserved[64];
  290.         u16 cardMode;           /* Bit-mask to enable features:
  291.                                  * Bit 0: 1 enables LED identify mode
  292.                                  */
  294.         u16 portScheduleOffset;
  296.         u32 endOfSmcSignature;  /* endOfSmcSignature MUST be the last member of
  297.                                  * the structure and marks the end of the shared
  298.                                  * memory. Adapter code initializes its value as
  299.                                  * END_SIG.
  300.                                  */
  301. };
  303. /* endOfSmcSignature value */
  304. #define END_SIG                 0x12345678
  306. /* Mailbox values. (portMailbox) */
  307. #define NOP             0       /* No operation */
  308. #define ACK             1       /* Positive acknowledgement to PC driver */
  309. #define NAK             2       /* Negative acknowledgement to PC driver */
  310. #define STARTPORT       3       /* Start an HDLC port */
  311. #define STOPPORT        4       /* Stop an HDLC port */
  312. #define ABORTTX         5       /* Abort the transmitter for a port */
  313. #define SETV24O         6       /* Set V24 outputs */
  316. /* Larger buffers are positioned in memory at offset BFM_BASE */
  317. struct buf_window {
  318.         u8 txBuffer[FST_MAX_PORTS][NUM_TX_BUFFER][LEN_TX_BUFFER];
  319.         u8 rxBuffer[FST_MAX_PORTS][NUM_RX_BUFFER][LEN_RX_BUFFER];
  320. };
  322. /* Calculate offset of a buffer object within the shared memory window */
  323. #define BUF_OFFSET(X)   ((unsigned int)&(((struct buf_window *)BFM_BASE)->X))
  325. #pragma pack()
  328. /*      Device driver private information
  329.  *      =================================
  330.  */
  331. /*      Per port (line or channel) information
  332.  */
  333. struct fst_port_info {
  334.         void                   *if_ptr; /* Some drivers describe this as a
  335.                                          * general purpose pointer. However if
  336.                                          * using syncPPP it has a very specific
  337.                                          * purpose: it must be the first item in
  338.                                          * the structure pointed to by dev->priv
  339.                                          * and must in turn point to the
  340.                                          * associated ppp_device structure.
  341.                                          */
  342.         struct fst_card_info   *card;   /* Card we're associated with */
  343.         int                     index;  /* Port index on the card */
  344.         int                     proto;  /* Protocol we are running */
  345.         int                     hwif;   /* Line hardware (lineInterface copy) */
  346.         int                     run;    /* Port is running */
  347.         int                     rxpos;  /* Next Rx buffer to use */
  348.         int                     txpos;  /* Next Tx buffer to use */
  349.         int                     txipos; /* Next Tx buffer to check for free */
  350.         int                     txcnt;  /* Count of Tx buffers in use */
  351.         struct net_device      *dev;    /* Kernel network device entry */
  352.         struct net_device_stats stats;  /* Standard statistics */
  353.         struct ppp_device       pppdev; /* Link to syncPPP */
  354. };
  356. /*      Per card information
  357.  */
  358. struct fst_card_info {
  359.         char          *mem;             /* Card memory mapped to kernel space */
  360.         char          *ctlmem;          /* Control memory for PCI cards */
  361.         unsigned int   phys_mem;        /* Physical memory window address */
  362.         unsigned int   phys_ctlmem;     /* Physical control memory address */
  363.         unsigned int   irq;             /* Interrupt request line number */
  364.         unsigned int   nports;          /* Number of serial ports */
  365.         unsigned int   type;            /* Type index of card */
  366.         unsigned int   state;           /* State of card */
  367.         spinlock_t     card_lock;       /* Lock for SMP access */
  368.         unsigned short pci_conf;        /* PCI card config in I/O space */
  369.                                         /* Per port info */
  370.         struct fst_port_info ports[ FST_MAX_PORTS ];
  371. };
  374. /*
  375.  *      Shared memory window access macros
  376.  *
  377.  *      We have a nice memory based structure above, which could be directly
  378.  *      mapped on i386 but might not work on other architectures unless we use
  379.  *      the readb,w,l and writeb,w,l macros. Unfortunately these macros take
  380.  *      physical offsets so we have to convert. The only saving grace is that
  381.  *      this should all collapse back to a simple indirection eventually.
  382.  */
  383. #define WIN_OFFSET(X)   ((long)&(((struct fst_shared *)SMC_BASE)->X))
  385. #define FST_RDB(C,E)    readb ((C)->mem + WIN_OFFSET(E))
  386. #define FST_RDW(C,E)    readw ((C)->mem + WIN_OFFSET(E))
  387. #define FST_RDL(C,E)    readl ((C)->mem + WIN_OFFSET(E))
  389. #define FST_WRB(C,E,B)  writeb ((B), (C)->mem + WIN_OFFSET(E))
  390. #define FST_WRW(C,E,W)  writew ((W), (C)->mem + WIN_OFFSET(E))
  391. #define FST_WRL(C,E,L)  writel ((L), (C)->mem + WIN_OFFSET(E))
  394. /*
  395.  *      Debug support
  396.  */
  397. #if FST_DEBUG
  399. static int fst_debug_mask = { FST_DEBUG };
  401. /* Most common debug activity is to print something if the corresponding bit
  402.  * is set in the debug mask. Note: this uses a non-ANSI extension in GCC to
  403.  * support variable numbers of macro parameters. The inverted if prevents us
  404.  * eating someone else's else clause.
  405.  */
  406. #define dbg(F,fmt,A...) if ( ! ( fst_debug_mask & (F))) 
  407.                                 ; 
  408.                         else 
  409.                                 printk ( KERN_DEBUG FST_NAME ": " fmt, ## A )
  411. #else
  412. # define dbg(X...)      /* NOP */
  413. #endif
  416. /*      Printing short cuts
  417.  */
  418. #define printk_err(fmt,A...)    printk ( KERN_ERR     FST_NAME ": " fmt, ## A )
  419. #define printk_warn(fmt,A...)   printk ( KERN_WARNING FST_NAME ": " fmt, ## A )
  420. #define printk_info(fmt,A...)   printk ( KERN_INFO    FST_NAME ": " fmt, ## A )
  423. /*
  424.  *      PCI ID lookup table
  425.  */
  426. static struct pci_device_id fst_pci_dev_id[] __devinitdata = {
  427.         { FSC_PCI_VENDOR_ID, T2P_PCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
  428.                                         FST_TYPE_T2P },
  429.         { FSC_PCI_VENDOR_ID, T4P_PCI_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
  430.                                         FST_TYPE_T4P },
  431.         { 0, }                          /* End */
  432. };
  434. MODULE_DEVICE_TABLE ( pci, fst_pci_dev_id );
  437. /*      Card control functions
  438.  *      ======================
  439.  */
  440. /*      Place the processor in reset state
  441.  *
  442.  * Used to be a simple write to card control space but a glitch in the latest
  443.  * AMD Am186CH processor means that we now have to do it by asserting and de-
  444.  * asserting the PLX chip PCI Adapter Software Reset. Bit 30 in CNTRL register
  445.  * at offset 0x50.
  446.  */
  447. static inline void
  448. fst_cpureset ( struct fst_card_info *card )
  449. {
  450.         unsigned int regval;
  452.         regval = inl ( card->pci_conf + 0x50 );
  454.         outl ( regval |  0x40000000, card->pci_conf + 0x50 );
  455.         outl ( regval & ~0x40000000, card->pci_conf + 0x50 );
  456. }
  458. /*      Release the processor from reset
  459.  */
  460. static inline void
  461. fst_cpurelease ( struct fst_card_info *card )
  462. {
  463.         (void) readb ( card->ctlmem );
  464. }
  466. /*      Clear the cards interrupt flag
  467.  */
  468. static inline void
  469. fst_clear_intr ( struct fst_card_info *card )
  470. {
  471.         /* Poke the appropriate PLX chip register (same as enabling interrupts)
  472.          */
  473.         outw ( 0x0543, card->pci_conf + 0x4C );
  474. }
  476. /*      Disable card interrupts
  477.  */
  478. static inline void
  479. fst_disable_intr ( struct fst_card_info *card )
  480. {
  481.         outw ( 0x0000, card->pci_conf + 0x4C );
  482. }
  485. /*      Issue a Mailbox command for a port.
  486.  *      Note we issue them on a fire and forget basis, not expecting to see an
  487.  *      error and not waiting for completion.
  488.  */
  489. static void
  490. fst_issue_cmd ( struct fst_port_info *port, unsigned short cmd )
  491. {
  492.         struct fst_card_info *card;
  493.         unsigned short mbval;
  494.         unsigned long flags;
  495.         int safety;
  497.         card = port->card;
  498.         spin_lock_irqsave ( &card->card_lock, flags );
  499.         mbval = FST_RDW ( card, portMailbox[port->index][0]);
  501.         safety = 0;
  502.         /* Wait for any previous command to complete */
  503.         while ( mbval > NAK )
  504.         {
  505.                 spin_unlock_irqrestore ( &card->card_lock, flags );
  506.                 schedule_timeout ( 1 );
  507.                 spin_lock_irqsave ( &card->card_lock, flags );
  509.                 if ( ++safety > 1000 )
  510.                 {
  511.                         printk_err ("Mailbox safety timeoutn");
  512.                         break;
  513.                 }
  515.                 mbval = FST_RDW ( card, portMailbox[port->index][0]);
  516.         }
  517.         if ( safety > 0 )
  518.         {
  519.                 dbg ( DBG_CMD,"Mailbox clear after %d jiffiesn", safety );
  520.         }
  521.         if ( mbval == NAK )
  522.         {
  523.                 dbg ( DBG_CMD,"issue_cmd: previous command was NAK'dn");
  524.         }
  526.         FST_WRW ( card, portMailbox[port->index][0], cmd );
  528.         if ( cmd == ABORTTX || cmd == STARTPORT )
  529.         {
  530.                 port->txpos  = 0;
  531.                 port->txipos = 0;
  532.                 port->txcnt  = 0;
  533.         }
  535.         spin_unlock_irqrestore ( &card->card_lock, flags );
  536. }
  539. /*      Port output signals control
  540.  */
  541. static inline void
  542. fst_op_raise ( struct fst_port_info *port, unsigned int outputs )
  543. {
  544.         outputs |= FST_RDL ( port->card, v24OpSts[port->index]);
  545.         FST_WRL ( port->card, v24OpSts[port->index], outputs );
  547.         if ( port->run )
  548.                 fst_issue_cmd ( port, SETV24O );
  549. }
  551. static inline void
  552. fst_op_lower ( struct fst_port_info *port, unsigned int outputs )
  553. {
  554.         outputs = ~outputs & FST_RDL ( port->card, v24OpSts[port->index]);
  555.         FST_WRL ( port->card, v24OpSts[port->index], outputs );
  557.         if ( port->run )
  558.                 fst_issue_cmd ( port, SETV24O );
  559. }
  562. /*
  563.  *      Setup port Rx buffers
  564.  */
  565. static void
  566. fst_rx_config ( struct fst_port_info *port )
  567. {
  568.         int i;
  569.         int pi;
  570.         unsigned int offset;
  571.         unsigned long flags;
  572.         struct fst_card_info *card;
  574.         pi   = port->index;
  575.         card = port->card;
  576.         spin_lock_irqsave ( &card->card_lock, flags );
  577.         for ( i = 0 ; i < NUM_RX_BUFFER ; i++ )
  578.         {
  579.                 offset = BUF_OFFSET ( rxBuffer[pi][i][0]);
  581.                 FST_WRW ( card, rxDescrRing[pi][i].ladr, (u16) offset );
  582.                 FST_WRB ( card, rxDescrRing[pi][i].hadr, (u8)( offset >> 16 ));
  583.                 FST_WRW ( card, rxDescrRing[pi][i].bcnt,
  584.                                         cnv_bcnt ( LEN_RX_BUFFER ));
  585.                 FST_WRW ( card, rxDescrRing[pi][i].mcnt, 0 );
  586.                 FST_WRB ( card, rxDescrRing[pi][i].bits, DMA_OWN );
  587.         }
  588.         port->rxpos  = 0;
  589.         spin_unlock_irqrestore ( &card->card_lock, flags );
  590. }
  593. /*
  594.  *      Setup port Tx buffers
  595.  */
  596. static void
  597. fst_tx_config ( struct fst_port_info *port )
  598. {
  599.         int i;
  600.         int pi;
  601.         unsigned int offset;
  602.         unsigned long flags;
  603.         struct fst_card_info *card;
  605.         pi   = port->index;
  606.         card = port->card;
  607.         spin_lock_irqsave ( &card->card_lock, flags );
  608.         for ( i = 0 ; i < NUM_TX_BUFFER ; i++ )
  609.         {
  610.                 offset = BUF_OFFSET ( txBuffer[pi][i][0]);
  612.                 FST_WRW ( card, txDescrRing[pi][i].ladr, (u16) offset );
  613.                 FST_WRB ( card, txDescrRing[pi][i].hadr, (u8)( offset >> 16 ));
  614.                 FST_WRW ( card, txDescrRing[pi][i].bcnt, 0 );
  615.                 FST_WRB ( card, txDescrRing[pi][i].bits, 0 );
  616.         }
  617.         port->txpos  = 0;
  618.         port->txipos = 0;
  619.         port->txcnt  = 0;
  620.         spin_unlock_irqrestore ( &card->card_lock, flags );
  621. }
  624. /*      Control signal change interrupt event
  625.  */
  626. static void
  627. fst_intr_ctlchg ( struct fst_card_info *card, struct fst_port_info *port )
  628. {
  629.         int signals;
  631.         signals = FST_RDL ( card, v24DebouncedSts[port->index]);
  633.         if ( signals & (( port->hwif == X21 ) ? IPSTS_INDICATE : IPSTS_DCD ))
  634.         {
  635.                 if ( ! netif_carrier_ok ( port->dev ))
  636.                 {
  637.                         dbg ( DBG_INTR,"DCD activen");
  639.                         /* Poke sPPP to renegotiate */
  640.                         if ( port->proto == FST_HDLC || port->proto == FST_PPP )
  641.                         {
  642.                                 sppp_reopen ( port->dev );
  643.                         }
  645.                         netif_carrier_on ( port->dev );
  646.                 }
  647.         }
  648.         else
  649.         {
  650.                 if ( netif_carrier_ok ( port->dev ))
  651.                 {
  652.                         dbg ( DBG_INTR,"DCD lostn");
  653.                         netif_carrier_off ( port->dev );
  654.                 }
  655.         }
  656. }
  659. /*      Rx complete interrupt
  660.  */
  661. static void
  662. fst_intr_rx ( struct fst_card_info *card, struct fst_port_info *port )
  663. {
  664.         unsigned char dmabits;
  665.         int pi;
  666.         int rxp;
  667.         unsigned short len;
  668.         struct sk_buff *skb;
  669.         int i;
  672.         /* Check we have a buffer to process */
  673.         pi  = port->index;
  674.         rxp = port->rxpos;
  675.         dmabits = FST_RDB ( card, rxDescrRing[pi][rxp].bits );
  676.         if ( dmabits & DMA_OWN )
  677.         {
  678.                 dbg ( DBG_RX | DBG_INTR,"intr_rx: No buffer port %d pos %dn",
  679.                                         pi, rxp );
  680.                 return;
  681.         }
  683.         /* Get buffer length */
  684.         len = FST_RDW ( card, rxDescrRing[pi][rxp].mcnt );
  685.         /* Discard the CRC */
  686.         len -= 2;
  688.         /* Check buffer length and for other errors. We insist on one packet
  689.          * in one buffer. This simplifies things greatly and since we've
  690.          * allocated 8K it shouldn't be a real world limitation
  691.          */
  692.         dbg ( DBG_RX,"intr_rx: %d,%d: flags %x len %dn", pi, rxp, dmabits,
  693.                                         len );
  694.         if ( dmabits != ( RX_STP | RX_ENP ) || len > LEN_RX_BUFFER - 2 )
  695.         {
  696.                 port->stats.rx_errors++;
  698.                 /* Update error stats and discard buffer */
  699.                 if ( dmabits & RX_OFLO )
  700.                 {
  701.                         port->stats.rx_fifo_errors++;
  702.                 }
  703.                 if ( dmabits & RX_CRC )
  704.                 {
  705.                         port->stats.rx_crc_errors++;
  706.                 }
  707.                 if ( dmabits & RX_FRAM )
  708.                 {
  709.                         port->stats.rx_frame_errors++;
  710.                 }
  711.                 if ( dmabits == ( RX_STP | RX_ENP ))
  712.                 {
  713.                         port->stats.rx_length_errors++;
  714.                 }
  716.                 /* Discard buffer descriptors until we see the end of packet
  717.                  * marker
  718.                  */
  719.                 i = 0;
  720.                 while (( dmabits & ( DMA_OWN | RX_ENP )) == 0 )
  721.                 {
  722.                         FST_WRB ( card, rxDescrRing[pi][rxp].bits, DMA_OWN );
  723.                         if ( ++rxp >= NUM_RX_BUFFER )
  724.                                 rxp = 0;
  725.                         if ( ++i > NUM_RX_BUFFER )
  726.                         {
  727.                                 dbg ( DBG_ASS,"intr_rx: Discarding more bufs"
  728.                                                 " than we haven");
  729.                                 break;
  730.                         }
  731.                         dmabits = FST_RDB ( card, rxDescrRing[pi][rxp].bits );
  732.                 }
  734.                 /* Discard the terminal buffer */
  735.                 if ( ! ( dmabits & DMA_OWN ))
  736.                 {
  737.                         FST_WRB ( card, rxDescrRing[pi][rxp].bits, DMA_OWN );
  738.                         if ( ++rxp >= NUM_RX_BUFFER )
  739.                                 rxp = 0;
  740.                 }
  741.                 port->rxpos = rxp;
  742.                 return;
  743.         }
  745.         /* Allocate SKB */
  746.         if (( skb = dev_alloc_skb ( len )) == NULL )
  747.         {
  748.                 dbg ( DBG_RX,"intr_rx: can't allocate buffern");
  750.                 port->stats.rx_dropped++;
  752.                 /* Return descriptor to card */
  753.                 FST_WRB ( card, rxDescrRing[pi][rxp].bits, DMA_OWN );
  755.                 if ( ++rxp >= NUM_RX_BUFFER )
  756.                         port->rxpos = 0;
  757.                 else
  758.                         port->rxpos = rxp;
  759.                 return;
  760.         }
  762.         memcpy_fromio ( skb_put ( skb, len ),
  763.                                 card->mem + BUF_OFFSET ( rxBuffer[pi][rxp][0]),
  764.                                 len );
  766.         /* Reset buffer descriptor */
  767.         FST_WRB ( card, rxDescrRing[pi][rxp].bits, DMA_OWN );
  768.         if ( ++rxp >= NUM_RX_BUFFER )
  769.                 port->rxpos = 0;
  770.         else
  771.                 port->rxpos = rxp;
  773.         /* Update stats */
  774.         port->stats.rx_packets++;
  775.         port->stats.rx_bytes += len;
  777.         /* Push upstream */
  778.         if ( port->proto == FST_HDLC || port->proto == FST_PPP )
  779.         {
  780.                 /* Mark for further processing by sPPP module */
  781.                 skb->protocol = htons ( ETH_P_WAN_PPP );
  782.         }
  783.         else
  784.         {
  785.                 /* DEC customer specific protocol (since nothing defined for
  786.                  * marking raw data), at least one other driver uses this value
  787.                  * for this purpose.
  788.                  */
  789.                 skb->protocol = htons ( ETH_P_CUST );
  790.                 skb->pkt_type = PACKET_HOST;
  791.         }
  792.         skb->mac.raw = skb->data;
  793.         skb->dev = port->dev;
  794.         netif_rx ( skb );
  796.         port->dev->last_rx = jiffies;
  797. }
  800. /*
  801.  *      The interrupt service routine
  802.  *      Dev_id is our fst_card_info pointer
  803.  */
  804. static void
  805. fst_intr ( int irq, void *dev_id, struct pt_regs *regs )
  806. {
  807.         struct fst_card_info *card;
  808.         struct fst_port_info *port;
  809.         int rdidx;                      /* Event buffer indices */
  810.         int wridx;
  811.         int event;                      /* Actual event for processing */
  812.         int pi;
  814.         if (( card = dev_id ) == NULL )
  815.         {
  816.                 dbg ( DBG_INTR,"intr: spurious %dn", irq );
  817.                 return;
  818.         }
  820.         dbg ( DBG_INTR,"intr: %d %pn", irq, card );
  822.         spin_lock ( &card->card_lock );
  824.         /* Clear and reprime the interrupt source */
  825.         fst_clear_intr ( card );
  827.         /* Set the software acknowledge */
  828.         FST_WRB ( card, interruptHandshake, 0xEE );
  830.         /* Drain the event queue */
  831.         rdidx = FST_RDB ( card, interruptEvent.rdindex );
  832.         wridx = FST_RDB ( card, interruptEvent.wrindex );
  833.         while ( rdidx != wridx )
  834.         {
  835.                 event = FST_RDB ( card, interruptEvent.evntbuff[rdidx]);
  837.                 port = &card->ports[event & 0x03];
  839.                 dbg ( DBG_INTR,"intr: %xn", event );
  841.                 switch ( event )
  842.                 {
  843.                 case CTLA_CHG:
  844.                 case CTLB_CHG:
  845.                 case CTLC_CHG:
  846.                 case CTLD_CHG:
  847.                         if ( port->run && port->dev != NULL )
  848.                                 fst_intr_ctlchg ( card, port );
  849.                         break;
  851.                 case ABTA_SENT:
  852.                 case ABTB_SENT:
  853.                 case ABTC_SENT:
  854.                 case ABTD_SENT:
  855.                         dbg ( DBG_TX,"Abort complete port %dn", event & 0x03 );
  856.                         break;
  858.                 case TXA_UNDF:
  859.                 case TXB_UNDF:
  860.                 case TXC_UNDF:
  861.                 case TXD_UNDF:
  862.                         /* Difficult to see how we'd get this given that we
  863.                          * always load up the entire packet for DMA.
  864.                          */
  865.                         dbg ( DBG_TX,"Tx underflow port %dn", event & 0x03 );
  867.                         port->stats.tx_errors++;
  868.                         port->stats.tx_fifo_errors++;
  869.                         break;
  871.                 case INIT_CPLT:
  872.                         dbg ( DBG_INIT,"Card init OK intrn");
  873.                         break;
  875.                 case INIT_FAIL:
  876.                         dbg ( DBG_INIT,"Card init FAILED intrn");
  877.                         card->state = FST_IFAILED;
  878.                         break;
  880.                 default:
  881.                         printk_err ("intr: unknown card event code. ignoredn");
  882.                         break;
  883.                 }
  885.                 /* Bump and wrap the index */
  886.                 if ( ++rdidx >= MAX_CIRBUFF )
  887.                         rdidx = 0;
  888.         }
  889.         FST_WRB ( card, interruptEvent.rdindex, rdidx );
  891.         for ( pi = 0, port = card->ports ; pi < card->nports ; pi++, port++ )
  892.         {
  893.                 if ( port->dev == NULL || ! port->run )
  894.                         continue;
  896.                 /* Check for rx completions */
  897.                 while ( ! ( FST_RDB ( card, rxDescrRing[pi][port->rxpos].bits )
  898.                                                                 & DMA_OWN ))
  899.                 {
  900.                         fst_intr_rx ( card, port );
  901.                 }
  903.                 /* Check for Tx completions */
  904.                 while ( port->txcnt > 0 && ! ( FST_RDB ( card,
  905.                         txDescrRing[pi][port->txipos].bits ) & DMA_OWN ))
  906.                 {
  907.                         --port->txcnt;
  908.                         if ( ++port->txipos >= NUM_TX_BUFFER )
  909.                                 port->txipos = 0;
  910.                         netif_wake_queue ( port->dev );
  911.                 }
  912.         }
  914.         spin_unlock ( &card->card_lock );
  915. }
  918. /*      Check that the shared memory configuration is one that we can handle
  919.  *      and that some basic parameters are correct
  920.  */
  921. static void
  922. check_started_ok ( struct fst_card_info *card )
  923. {
  924.         int i;
  926.         /* Check structure version and end marker */
  927.         if ( FST_RDW ( card, smcVersion ) != SMC_VERSION )
  928.         {
  929.                 printk_err ("Bad shared memory version %d expected %dn",
  930.                                 FST_RDW ( card, smcVersion ), SMC_VERSION );
  931.                 card->state = FST_BADVERSION;
  932.                 return;
  933.         }
  934.         if ( FST_RDL ( card, endOfSmcSignature ) != END_SIG )
  935.         {
  936.                 printk_err ("Missing shared memory signaturen");
  937.                 card->state = FST_BADVERSION;
  938.                 return;
  939.         }
  940.         /* Firmware status flag, 0x00 = initialising, 0x01 = OK, 0xFF = fail */
  941.         if (( i = FST_RDB ( card, taskStatus )) == 0x01 )
  942.         {
  943.                 card->state = FST_RUNNING;
  944.         }
  945.         else if ( i == 0xFF )
  946.         {
  947.                 printk_err ("Firmware initialisation failed. Card haltedn");
  948.                 card->state = FST_HALTED;
  949.                 return;
  950.         }
  951.         else if ( i != 0x00 )
  952.         {
  953.                 printk_err ("Unknown firmware status 0x%xn", i );
  954.                 card->state = FST_HALTED;
  955.                 return;
  956.         }
  958.         /* Finally check the number of ports reported by firmware against the
  959.          * number we assumed at card detection. Should never happen with
  960.          * existing firmware etc so we just report it for the moment.
  961.          */
  962.         if ( FST_RDL ( card, numberOfPorts ) != card->nports )
  963.         {
  964.                 printk_warn ("Port count mismatch."
  965.                                 " Firmware thinks %d we say %dn",
  966.                                 FST_RDL ( card, numberOfPorts ), card->nports );
  967.         }
  968. }
  971. static int
  972. fst_change_mtu ( struct net_device *dev, int new_mtu )
  973. {
  974.         if ( new_mtu < 128 || new_mtu > FST_MAX_MTU )
  975.                 return -EINVAL;
  976.         dev->mtu = new_mtu;
  977.         return 0;
  978. }
  981. /* Sooner or later you can't avoid a forward declaration */
  982. static int fst_ioctl ( struct net_device *dev, struct ifreq *ifr, int cmd );
  984. static int
  985. switch_proto ( struct fst_port_info *port, int new_proto )
  986. {
  987.         int err;
  988.         int orig_mtu;
  989.         struct net_device *dev;
  991.         dev = port->dev;
  993.         /* Turn off sPPP module ? */
  994.         if (( new_proto != FST_HDLC && new_proto != FST_PPP )
  995.                 && ( port->proto == FST_HDLC || port->proto == FST_PPP ))
  996.         {
  997.                 sppp_close ( port->pppdev.dev );
  998.                 sppp_detach ( port->pppdev.dev );
  1000.                 /* Reset some fields overwritten by sPPP */
  1001.                 dev->hard_header     = NULL;
  1002.                 dev->rebuild_header  = NULL;
  1003.                 dev->tx_queue_len    = FST_TX_QUEUE_LEN;
  1004.                 dev->type            = ARPHRD_MYTYPE;
  1005.                 dev->addr_len        = 0;
  1006.                 dev->hard_header_len = 0;
  1007.                 dev->do_ioctl        = fst_ioctl;
  1008.                 dev->change_mtu      = fst_change_mtu;
  1009.                 dev->flags           = IFF_POINTOPOINT|IFF_NOARP;
  1011.                 return 0;
  1012.         }
  1014.         /* Turn on sPPP ? */
  1015.         if (( new_proto == FST_HDLC || new_proto == FST_PPP )
  1016.                 && ( port->proto != FST_HDLC && port->proto != FST_PPP ))
  1017.         {
  1018.                 orig_mtu = dev->mtu;
  1020.                 /* Attach to sync PPP module */
  1021.                 port->pppdev.dev = dev;
  1022.                 sppp_attach ( &port->pppdev );
  1024.                 if ( orig_mtu < dev->mtu )
  1025.                         dev->change_mtu ( dev, orig_mtu );
  1027.                 /* Claw back the ioctl routine. We promise to be good and call
  1028.                  * the sync PPP routines once we've eliminated our functions.
  1029.                  */
  1030.                 dev->do_ioctl = fst_ioctl;
  1032.                 /* Set the mode */
  1033.                 if ( new_proto == FST_HDLC )
  1034.                 {
  1035.                         err = sppp_do_ioctl ( port->pppdev.dev, NULL,
  1036.                                                                 SPPPIOCCISCO );
  1037.                 }
  1038.                 else
  1039.                 {
  1040.                         err = sppp_do_ioctl ( port->pppdev.dev, NULL,
  1041.                                                                 SPPPIOCPPP );
  1042.                 }
  1044.                 /* Open the device */
  1045.                 if ( err == 0 )
  1046.                 {
  1047.                         (void) sppp_open ( port->dev );
  1048.                 }
  1050.                 return err;
  1051.         }
  1053.         /* Switch sPPP mode to that desired */
  1054.         err = 0;
  1055.         if ( new_proto == FST_HDLC && port->pppdev.dev != NULL )
  1056.         {
  1057.                 err = sppp_do_ioctl ( port->pppdev.dev, NULL, SPPPIOCCISCO );
  1058.         }
  1059.         else if ( new_proto == FST_PPP && port->pppdev.dev != NULL )
  1060.         {
  1061.                 err = sppp_do_ioctl ( port->pppdev.dev, NULL, SPPPIOCPPP );
  1062.         }
  1064.         /* Anything else is switching from one raw mode to another which is
  1065.          * basically a NOP
  1066.          */
  1068.         return err;
  1069. }
  1072. static int
  1073. set_conf_from_info ( struct fst_card_info *card, struct fst_port_info *port,
  1074.                 struct fstioc_info *info )
  1075. {
  1076.         int err;
  1078.         /* Set things according to the user set valid flags */
  1079.         err = 0;
  1080.         if ( info->valid & FSTVAL_PROTO )
  1081.         {
  1082.                 if ( port->proto != info->proto )
  1083.                 {
  1084.                         err = switch_proto ( port, info->proto );
  1085.                         if ( err == 0 )
  1086.                                 port->proto = info->proto;
  1087.                 }
  1088.         }
  1089.         if ( info->valid & FSTVAL_CABLE )
  1090.         {
  1091.                 FST_WRB ( card, portConfig[port->index].lineInterface,
  1092.                                         info->lineInterface );
  1093.                 port->hwif = info->lineInterface;
  1094.         }
  1095.         if ( info->valid & FSTVAL_SPEED )
  1096.         {
  1097.                 FST_WRL ( card, portConfig[port->index].lineSpeed,
  1098.                                         info->lineSpeed );
  1099.                 FST_WRB ( card, portConfig[port->index].internalClock,
  1100.                                         info->internalClock );
  1101.         }
  1102.         if ( info->valid & FSTVAL_MODE )
  1103.         {
  1104.                 FST_WRW ( card, cardMode, info->cardMode );
  1105.         }
  1106. #if FST_DEBUG
  1107.         if ( info->valid & FSTVAL_DEBUG )
  1108.         {
  1109.                 fst_debug_mask = info->debug;
  1110.         }
  1111. #endif
  1113.         return err;
  1114. }
  1116. static void
  1117. gather_conf_info ( struct fst_card_info *card, struct fst_port_info *port,
  1118.                 struct fstioc_info *info )
  1119. {
  1120.         int i;
  1122.         memset ( info, 0, sizeof ( struct fstioc_info ));
  1124.         i = port->index;
  1125.         info->nports = card->nports;
  1126.         info->type   = card->type;
  1127.         info->state  = card->state;
  1128.         info->proto  = port->proto;
  1129.         info->index  = i;
  1130. #if FST_DEBUG
  1131.         info->debug  = fst_debug_mask;
  1132. #endif
  1134.         /* Only mark information as valid if card is running.
  1135.          * Copy the data anyway in case it is useful for diagnostics
  1136.          */
  1137.         info->valid
  1138.                 = (( card->state == FST_RUNNING ) ? FSTVAL_ALL : FSTVAL_CARD )
  1139. #if FST_DEBUG
  1140.                 | FSTVAL_DEBUG
  1141. #endif
  1142.                 ;
  1144.         info->lineInterface = FST_RDW ( card, portConfig[i].lineInterface );
  1145.         info->internalClock = FST_RDB ( card, portConfig[i].internalClock );
  1146.         info->lineSpeed     = FST_RDL ( card, portConfig[i].lineSpeed );
  1147.         info->v24IpSts      = FST_RDL ( card, v24IpSts[i] );
  1148.         info->v24OpSts      = FST_RDL ( card, v24OpSts[i] );
  1149.         info->clockStatus   = FST_RDW ( card, clockStatus[i] );
  1150.         info->cableStatus   = FST_RDW ( card, cableStatus );
  1151.         info->cardMode      = FST_RDW ( card, cardMode );
  1152.         info->smcFirmwareVersion  = FST_RDL ( card, smcFirmwareVersion );
  1153. }
  1156. static int
  1157. fst_ioctl ( struct net_device *dev, struct ifreq *ifr, int cmd )
  1158. {
  1159.         struct fst_card_info *card;
  1160.         struct fst_port_info *port;
  1161.         struct fstioc_write wrthdr;
  1162.         struct fstioc_info info;
  1163.         unsigned long flags;
  1165.         dbg ( DBG_IOCTL,"ioctl: %x, %pn", cmd, ifr->ifr_data );
  1167.         port = dev->priv;
  1168.         card = port->card;
  1170.         if ( !capable ( CAP_NET_ADMIN ))
  1171.                 return -EPERM;
  1173.         switch ( cmd )
  1174.         {
  1175.         case FSTCPURESET:
  1176.                 fst_cpureset ( card );
  1177.                 card->state = FST_RESET;
  1178.                 return 0;
  1180.         case FSTCPURELEASE:
  1181.                 fst_cpurelease ( card );
  1182.                 card->state = FST_STARTING;
  1183.                 return 0;
  1185.         case FSTWRITE:                  /* Code write (download) */
  1187.                 /* First copy in the header with the length and offset of data
  1188.                  * to write
  1189.                  */
  1190.                 if ( ifr->ifr_data == NULL )
  1191.                 {
  1192.                         return -EINVAL;
  1193.                 }
  1194.                 if ( copy_from_user ( &wrthdr, ifr->ifr_data,
  1195.                                         sizeof ( struct fstioc_write )))
  1196.                 {
  1197.                         return -EFAULT;
  1198.                 }
  1200.                 /* Sanity check the parameters. We don't support partial writes
  1201.                  * when going over the top
  1202.                  */
  1203.                 if ( wrthdr.size > FST_MEMSIZE || wrthdr.offset > FST_MEMSIZE
  1204.                                 || wrthdr.size + wrthdr.offset > FST_MEMSIZE )
  1205.                 {
  1206.                         return -ENXIO;
  1207.                 }
  1209.                 /* Now copy the data to the card.
  1210.                  * This will probably break on some architectures.
  1211.                  * I'll fix it when I have something to test on.
  1212.                  */
  1213.                 if ( copy_from_user ( card->mem + wrthdr.offset,
  1214.                                 ifr->ifr_data + sizeof ( struct fstioc_write ),
  1215.                                 wrthdr.size ))
  1216.                 {
  1217.                         return -EFAULT;
  1218.                 }
  1220.                 /* Writes to the memory of a card in the reset state constitute
  1221.                  * a download
  1222.                  */
  1223.                 if ( card->state == FST_RESET )
  1224.                 {
  1225.                         card->state = FST_DOWNLOAD;
  1226.                 }
  1227.                 return 0;
  1229.         case FSTGETCONF:
  1231.                 /* If card has just been started check the shared memory config
  1232.                  * version and marker
  1233.                  */
  1234.                 if ( card->state == FST_STARTING )
  1235.                 {
  1236.                         check_started_ok ( card );
  1238.                         /* If everything checked out enable card interrupts */
  1239.                         if ( card->state == FST_RUNNING )
  1240.                         {
  1241.                                 spin_lock_irqsave ( &card->card_lock, flags );
  1242.                                 fst_clear_intr ( card );
  1243.                                 FST_WRB ( card, interruptHandshake, 0xEE );
  1244.                                 spin_unlock_irqrestore ( &card->card_lock,
  1245.                                                                 flags );
  1246.                         }
  1247.                 }
  1249.                 if ( ifr->ifr_data == NULL )
  1250.                 {
  1251.                         return -EINVAL;
  1252.                 }
  1254.                 gather_conf_info ( card, port, &info );
  1256.                 if ( copy_to_user ( ifr->ifr_data, &info, sizeof ( info )))
  1257.                 {
  1258.                         return -EFAULT;
  1259.                 }
  1260.                 return 0;
  1262.         case FSTSETCONF:
  1264.                 if ( copy_from_user ( &info,  ifr->ifr_data, sizeof ( info )))
  1265.                 {
  1266.                         return -EFAULT;
  1267.                 }
  1269.                 return set_conf_from_info ( card, port, &info );
  1271.         default:
  1272.                 /* Not one of ours. Pass it through to sPPP package */
  1273.                 if ( port->proto == FST_HDLC || port->proto == FST_PPP )
  1274.                         return sppp_do_ioctl ( dev, ifr, cmd );
  1275.                 else
  1276.                         return -EINVAL;
  1277.         }
  1278. }
  1281. static void
  1282. fst_openport ( struct fst_port_info *port )
  1283. {
  1284.         int signals;
  1286.         /* Only init things if card is actually running. This allows open to
  1287.          * succeed for downloads etc.
  1288.          */
  1289.         if ( port->card->state == FST_RUNNING )
  1290.         {
  1291.                 if ( port->run )
  1292.                 {
  1293.                         dbg ( DBG_OPEN,"open: found port already runningn");
  1295.                         fst_issue_cmd ( port, STOPPORT );
  1296.                         port->run = 0;
  1297.                 }
  1299.                 fst_rx_config ( port );
  1300.                 fst_tx_config ( port );
  1301.                 fst_op_raise ( port, OPSTS_RTS | OPSTS_DTR );
  1303.                 fst_issue_cmd ( port, STARTPORT );
  1304.                 port->run = 1;
  1306.                 signals = FST_RDL ( port->card, v24DebouncedSts[port->index]);
  1307.                 if ( signals & (( port->hwif == X21 ) ? IPSTS_INDICATE
  1308.                                                       : IPSTS_DCD ))
  1309.                         netif_carrier_on ( port->dev );
  1310.                 else
  1311.                         netif_carrier_off ( port->dev );
  1312.         }
  1313. }
  1315. static void
  1316. fst_closeport ( struct fst_port_info *port )
  1317. {
  1318.         if ( port->card->state == FST_RUNNING )
  1319.         {
  1320.                 if ( port->run )
  1321.                 {
  1322.                         port->run = 0;
  1323.                         fst_op_lower ( port, OPSTS_RTS | OPSTS_DTR );
  1325.                         fst_issue_cmd ( port, STOPPORT );
  1326.                 }
  1327.                 else
  1328.                 {
  1329.                         dbg ( DBG_OPEN,"close: port not runningn");
  1330.                 }
  1331.         }
  1332. }
  1335. static int
  1336. fst_open ( struct net_device *dev )
  1337. {
  1338.         struct fst_card_info *card;
  1339.         struct fst_port_info *port;
  1340.         int orig_mtu;
  1341.         int err;
  1343.         MOD_INC_USE_COUNT;
  1345.         port = dev->priv;
  1346.         card = port->card;
  1348.         switch ( port->proto )
  1349.         {
  1350.         case FST_HDLC:
  1351.         case FST_PPP:
  1353.                 orig_mtu = dev->mtu;
  1355.                 /* Attach to sync PPP module */
  1356.                 port->pppdev.dev = dev;
  1357.                 sppp_attach ( &port->pppdev );
  1359.                 if ( orig_mtu < dev->mtu )
  1360.                         dev->change_mtu ( dev, orig_mtu );
  1362.                 /* Claw back the ioctl routine. We promise to be good and call
  1363.                  * the sync PPP routines once we've eliminated our functions.
  1364.                  */
  1365.                 dev->do_ioctl = fst_ioctl;
  1367.                 err = sppp_do_ioctl ( dev, NULL, port->proto == FST_HDLC
  1368.                                                 ? SPPPIOCCISCO : SPPPIOCPPP );
  1369.                 if ( err )
  1370. {
  1371. sppp_detach ( dev );
  1372. MOD_DEC_USE_COUNT;
  1373. return err;
  1374. }
  1376.                 err = sppp_open ( dev );
  1377.                 if ( err )
  1378. {
  1379. sppp_detach ( dev );
  1380. MOD_DEC_USE_COUNT;
  1381. return err;
  1382. }
  1383.                 break;
  1385.         case FST_MONITOR:
  1386.         case FST_RAW:
  1387.                 break;
  1389.         default:
  1390.                 dbg ( DBG_OPEN,"open: Unknown proto %dn", port->proto );
  1391.                 break;
  1392.         }
  1394.         fst_openport ( port );
  1396.         netif_wake_queue ( dev );
  1397.         return 0;
  1398. }
  1400. static int
  1401. fst_close ( struct net_device *dev )
  1402. {
  1403.         struct fst_port_info *port;
  1405.         port = dev->priv;
  1407.         netif_stop_queue ( dev );
  1408.         switch ( port->proto )
  1409.         {
  1410.         case FST_HDLC:
  1411.         case FST_PPP:
  1412.                 sppp_close ( dev );
  1413.                 sppp_detach ( dev );
  1414.                 break;
  1416.         case FST_MONITOR:
  1417.         case FST_RAW:
  1418.                 break;
  1420.         default:
  1421.                 dbg ( DBG_OPEN,"close: Unknown proto %dn", port->proto );
  1422.                 break;
  1423.         }
  1425.         fst_closeport ( port );
  1427.         MOD_DEC_USE_COUNT;
  1428.         return 0;
  1429. }
  1432. static void
  1433. fst_tx_timeout ( struct net_device *dev )
  1434. {
  1435.         struct fst_port_info *port;
  1437.         dbg ( DBG_INTR | DBG_TX,"tx_timeoutn");
  1439.         port = dev->priv;
  1441.         port->stats.tx_errors++;
  1442.         port->stats.tx_aborted_errors++;
  1444.         if ( port->txcnt > 0 )
  1445.                 fst_issue_cmd ( port, ABORTTX );
  1447.         dev->trans_start = jiffies;
  1448.         netif_wake_queue ( dev );
  1449. }
  1452. static int
  1453. fst_start_xmit ( struct sk_buff *skb, struct net_device *dev )
  1454. {
  1455.         struct fst_card_info *card;
  1456.         struct fst_port_info *port;
  1457.         unsigned char dmabits;
  1458.         unsigned long flags;
  1459.         int pi;
  1460.         int txp;
  1462.         port = dev->priv;
  1463.         card = port->card;
  1465.         /* Drop packet if in monitor (rx only) mode */
  1466.         if ( port->proto == FST_MONITOR )
  1467.         {
  1468.                 dev_kfree_skb ( skb );
  1469.                 return 0;
  1470.         }
  1472.         /* Drop packet with error if we don't have carrier */
  1473.         if ( ! netif_carrier_ok ( dev ))
  1474.         {
  1475.                 dev_kfree_skb ( skb );
  1476.                 port->stats.tx_errors++;
  1477.                 port->stats.tx_carrier_errors++;
  1478.                 return 0;
  1479.         }
  1481.         /* Drop it if it's too big! MTU failure ? */
  1482.         if ( skb->len > LEN_TX_BUFFER )
  1483.         {
  1484.                 dbg ( DBG_TX,"Packet too large %d vs %dn", skb->len,
  1485.                                                 LEN_TX_BUFFER );
  1486.                 dev_kfree_skb ( skb );
  1487.                 port->stats.tx_errors++;
  1488.                 return 0;
  1489.         }
  1491.         /* Check we have a buffer */
  1492.         pi = port->index;
  1493.         spin_lock_irqsave ( &card->card_lock, flags );
  1494.         txp = port->txpos;
  1495.         dmabits = FST_RDB ( card, txDescrRing[pi][txp].bits );
  1496.         if ( dmabits & DMA_OWN )
  1497.         {
  1498.                 spin_unlock_irqrestore ( &card->card_lock, flags );
  1499.                 dbg ( DBG_TX,"Out of Tx buffersn");
  1500.                 dev_kfree_skb ( skb );
  1501.                 port->stats.tx_errors++;
  1502.                 return 0;
  1503.         }
  1504.         if ( ++port->txpos >= NUM_TX_BUFFER )
  1505.                 port->txpos = 0;
  1507.         if ( ++port->txcnt >= NUM_TX_BUFFER )
  1508.                 netif_stop_queue ( dev );
  1510.         /* Release the card lock before we copy the data as we now have
  1511.          * exclusive access to the buffer.
  1512.          */
  1513.         spin_unlock_irqrestore ( &card->card_lock, flags );
  1515.         /* Enqueue the packet */
  1516.         memcpy_toio ( card->mem + BUF_OFFSET ( txBuffer[pi][txp][0]),
  1517.                                                 skb->data, skb->len );
  1518.         FST_WRW ( card, txDescrRing[pi][txp].bcnt, cnv_bcnt ( skb->len ));
  1519.         FST_WRB ( card, txDescrRing[pi][txp].bits, DMA_OWN | TX_STP | TX_ENP );
  1521.         port->stats.tx_packets++;
  1522.         port->stats.tx_bytes += skb->len;
  1524.         dev_kfree_skb ( skb );
  1526.         dev->trans_start = jiffies;
  1527.         return 0;
  1528. }
  1531. static struct net_device_stats *
  1532. fst_get_stats ( struct net_device *dev )
  1533. {
  1534.         struct fst_port_info *port;
  1536.         if (( port = dev->priv ) != NULL )
  1537.                 return &port->stats;
  1538.         else
  1539.                 return NULL;
  1540. }
  1543. /*
  1544.  *      Card setup having checked hardware resources.
  1545.  *      Should be pretty bizarre if we get an error here (kernel memory
  1546.  *      exhaustion is one possibility). If we do see a problem we report it
  1547.  *      via a printk and leave the corresponding interface and all that follow
  1548.  *      disabled.
  1549.  */
  1550. static char *type_strings[] __devinitdata = {
  1551.         "no hardware",                  /* Should never be seen */
  1552.         "FarSync T2P",
  1553.         "FarSync T4P"
  1554. };
  1556. static void __devinit
  1557. fst_init_card ( struct fst_card_info *card )
  1558. {
  1559.         int i;
  1560.         int err;
  1561.         struct net_device *dev;
  1563.         /* We're working on a number of ports based on the card ID. If the
  1564.          * firmware detects something different later (should never happen)
  1565.          * we'll have to revise it in some way then.
  1566.          */
  1567.         for ( i = 0 ; i < card->nports ; i++ )
  1568.         {
  1569.                 card->ports[i].if_ptr = &card->ports[i].pppdev;
  1570.                 card->ports[i].card   = card;
  1571.                 card->ports[i].index  = i;
  1572.                 card->ports[i].proto  = FST_HDLC;
  1573.                 card->ports[i].run    = 0;
  1575.                 dev = kmalloc ( sizeof ( struct net_device ), GFP_KERNEL );
  1576.                 if ( dev == NULL )
  1577.                 {
  1578.                         printk_err ("Cannot allocate net_device for port %dn",
  1579.                                         i );
  1580.                         /* No point going any further */
  1581.                         card->nports = i;
  1582.                         break;
  1583.                 }
  1584.                 memset ( dev, 0, sizeof ( struct net_device ));
  1585.                 card->ports[i].dev = dev;
  1587.                 if ( dev_alloc_name ( dev, FST_NDEV_NAME "%d") < 0 )
  1588.                 {
  1589.                         printk_err ("Cannot allocate i/f name for port %dn",
  1590.                                         i );
  1591.                         kfree ( dev );
  1592.                         card->nports = i;
  1593.                         break;
  1594.                 }
  1596.                 /* Fill in remainder of the net device info */
  1597.                                 /* Since this is a PCI setup this is purely
  1598.                                  * informational. Give them the buffer addresses
  1599.                                  * and basic card I/O.
  1600.                                  */
  1601.                 dev->mem_start   = card->phys_mem
  1602.                                  + BUF_OFFSET ( txBuffer[i][0][0]);
  1603.                 dev->mem_end     = card->phys_mem
  1604.                                  + BUF_OFFSET ( txBuffer[i][NUM_TX_BUFFER][0]);
  1605.                 dev->rmem_start  = card->phys_mem
  1606.                                  + BUF_OFFSET ( rxBuffer[i][0][0]);
  1607.                 dev->rmem_end    = card->phys_mem
  1608.                                  + BUF_OFFSET ( rxBuffer[i][NUM_RX_BUFFER][0]);
  1609.                 dev->base_addr   = card->pci_conf;
  1610.                 dev->irq         = card->irq;
  1612.                 dev->get_stats          = fst_get_stats;
  1613.                 dev->mtu                = FST_DEF_MTU;
  1614.                 dev->change_mtu         = fst_change_mtu;
  1615.                 dev->priv               = &card->ports[i];
  1616.                 dev->tx_queue_len       = FST_TX_QUEUE_LEN;
  1617.                 dev->type               = ARPHRD_MYTYPE;
  1618.                 dev->addr_len           = 0;
  1619.                 dev->open               = fst_open;
  1620.                 dev->stop               = fst_close;
  1621.                 dev->hard_start_xmit    = fst_start_xmit;
  1622.                 dev->do_ioctl           = fst_ioctl;
  1623.                 dev->watchdog_timeo     = FST_TX_TIMEOUT;
  1624.                 dev->tx_timeout         = fst_tx_timeout;
  1625.                 dev->flags              = IFF_POINTOPOINT|IFF_NOARP;
  1627.                 if (( err = register_netdev ( dev )) < 0 )
  1628.                 {
  1629.                         printk_err ("Cannot register %s (errno %d)n",
  1630.                                         dev->name, -err );
  1631.                         kfree ( dev );
  1632.                         card->nports = i;
  1633.                         break;
  1634.                 }
  1635.         }
  1637.         spin_lock_init ( &card->card_lock );
  1639.         printk ( KERN_INFO "%s-%s: %s IRQ%d, %d portsn",
  1640.                         card->ports[0].dev->name,
  1641.                         card->ports[card->nports-1].dev->name,
  1642.                         type_strings[card->type], card->irq, card->nports );
  1643. }
  1646. /*
  1647.  *      Initialise card when detected.
  1648.  *      Returns 0 to indicate success, or errno otherwise.
  1649.  */
  1650. static int __devinit
  1651. fst_add_one ( struct pci_dev *pdev, const struct pci_device_id *ent )
  1652. {
  1653.         static int firsttime_done = 0;
  1654.         struct fst_card_info *card;
  1655.         int err = 0;
  1657.         if ( ! firsttime_done )
  1658.         {
  1659.                 printk ( KERN_INFO "FarSync X21 driver " FST_USER_VERSION
  1660.                                 " (c) 2001 FarSite Communications Ltd.n");
  1661.                 firsttime_done = 1;
  1662.         }
  1664.         /* Allocate driver private data */
  1665.         card = kmalloc ( sizeof ( struct fst_card_info ),  GFP_KERNEL);
  1666.         if (card == NULL)
  1667.         {
  1668.                 printk_err ("FarSync card found but insufficient memory for"
  1669.                                 " driver storagen");
  1670.                 return -ENOMEM;
  1671.         }
  1672.         memset ( card, 0, sizeof ( struct fst_card_info ));
  1674.         /* Record info we need*/
  1675.         card->irq         = pdev->irq;
  1676.         card->pci_conf    = pci_resource_start ( pdev, 1 );
  1677.         card->phys_mem    = pci_resource_start ( pdev, 2 );
  1678.         card->phys_ctlmem = pci_resource_start ( pdev, 3 );
  1680.         card->type        = ent->driver_data;
  1681.         card->nports      = ( ent->driver_data == FST_TYPE_T2P ) ? 2 : 4;
  1683.         card->state       = FST_UNINIT;
  1685.         dbg ( DBG_PCI,"type %d nports %d irq %dn", card->type,
  1686.                         card->nports, card->irq );
  1687.         dbg ( DBG_PCI,"conf %04x mem %08x ctlmem %08xn",
  1688.                         card->pci_conf, card->phys_mem, card->phys_ctlmem );
  1690.         /* Check we can get access to the memory and I/O regions */
  1691.         if ( ! request_region ( card->pci_conf, 0x80,"PLX config regs"))
  1692.         {
  1693.                 printk_err ("Unable to get config I/O @ 0x%04Xn",
  1694.                                                 card->pci_conf );
  1695.                 err = -ENODEV;
  1696.                 goto error_free_card;
  1697.         }
  1698.         if ( ! request_mem_region ( card->phys_mem, FST_MEMSIZE,"Shared RAM"))
  1699.         {
  1700.                 printk_err ("Unable to get main memory @ 0x%08Xn",
  1701.                                                 card->phys_mem );
  1702.                 err = -ENODEV;
  1703.                 goto error_release_io;
  1704.         }
  1705.         if ( ! request_mem_region ( card->phys_ctlmem, 0x10,"Control memory"))
  1706.         {
  1707.                 printk_err ("Unable to get control memory @ 0x%08Xn",
  1708.                                                 card->phys_ctlmem );
  1709.                 err = -ENODEV;
  1710.                 goto error_release_mem;
  1711.         }
  1713.         /* Try to enable the device */
  1714.         if (( err = pci_enable_device ( pdev )) != 0 )
  1715.         {
  1716.                 printk_err ("Failed to enable card. Err %dn", -err );
  1717.                 goto error_release_ctlmem;
  1718.         }
  1720.         /* Get virtual addresses of memory regions */
  1721.         if (( card->mem = ioremap ( card->phys_mem, FST_MEMSIZE )) == NULL )
  1722.         {
  1723.                 printk_err ("Physical memory remap failedn");
  1724.                 err = -ENODEV;
  1725.                 goto error_release_ctlmem;
  1726.         }
  1727.         if (( card->ctlmem = ioremap ( card->phys_ctlmem, 0x10 )) == NULL )
  1728.         {
  1729.                 printk_err ("Control memory remap failedn");
  1730.                 err = -ENODEV;
  1731.                 goto error_unmap_mem;
  1732.         }
  1733.         dbg ( DBG_PCI,"kernel mem %p, ctlmem %pn", card->mem, card->ctlmem);
  1735.         /* Reset the card's processor */
  1736.         fst_cpureset ( card );
  1737.         card->state = FST_RESET;
  1739.         /* Register the interrupt handler */
  1740.         if ( request_irq ( card->irq, fst_intr, SA_SHIRQ, FST_DEV_NAME, card ))
  1741.         {
  1743.                 printk_err ("Unable to register interrupt %dn", card->irq );
  1744.                 err = -ENODEV;
  1745.                 goto error_unmap_ctlmem;
  1746.         }
  1748.         /* Record driver data for later use */
  1749.         pci_set_drvdata(pdev, card);
  1751.         /* Remainder of card setup */
  1752.         fst_init_card ( card );
  1754.         return 0;                       /* Success */
  1757.                                         /* Failure. Release resources */
  1758. error_unmap_ctlmem:
  1759.         iounmap ( card->ctlmem );
  1761. error_unmap_mem:
  1762.         iounmap ( card->mem );
  1764. error_release_ctlmem:
  1765.         release_mem_region ( card->phys_ctlmem, 0x10 );
  1767. error_release_mem:
  1768.         release_mem_region ( card->phys_mem, FST_MEMSIZE );
  1770. error_release_io:
  1771.         release_region ( card->pci_conf, 0x80 );
  1773. error_free_card:
  1774.         kfree ( card );
  1775.         return err;
  1776. }
  1779. /*
  1780.  *      Cleanup and close down a card
  1781.  */
  1782. static void __devexit
  1783. fst_remove_one ( struct pci_dev *pdev )
  1784. {
  1785.         struct fst_card_info *card;
  1786.         int i;
  1788.         card = pci_get_drvdata(pdev);
  1790.         for ( i = 0 ; i < card->nports ; i++ )
  1791.         {
  1792.                 unregister_netdev ( card->ports[i].dev );
  1793.                 kfree ( card->ports[i].dev );
  1794.         }
  1796.         fst_disable_intr ( card );
  1797.         free_irq ( card->irq, card );
  1799.         iounmap ( card->ctlmem );
  1800.         iounmap ( card->mem );
  1802.         release_mem_region ( card->phys_ctlmem, 0x10 );
  1803.         release_mem_region ( card->phys_mem, FST_MEMSIZE );
  1804.         release_region ( card->pci_conf, 0x80 );
  1806.         kfree ( card );
  1807. }
  1809. static struct pci_driver fst_driver = {
  1810.         name:           FST_NAME,
  1811.         id_table:       fst_pci_dev_id,
  1812.         probe:          fst_add_one,
  1813.         remove:         __devexit_p(fst_remove_one),
  1814.         suspend:        NULL,
  1815.         resume:         NULL,
  1816. };
  1818. static int __init
  1819. fst_init(void)
  1820. {
  1821.         return pci_module_init ( &fst_driver );
  1822. }
  1824. static void __exit
  1825. fst_cleanup_module(void)
  1826. {
  1827.         pci_unregister_driver ( &fst_driver );
  1828. }
  1830. module_init ( fst_init );
  1831. module_exit ( fst_cleanup_module );
  1833. MODULE_LICENSE("GPL");