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

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

Linux/Unix编程

开发平台：

Unix_Linux

fmvj18x_cs.c：源码内容
  1. /*======================================================================
  2.     fmvj18x_cs.c 2.6 2001/09/17
  4.     A fmvj18x (and its compatibles) PCMCIA client driver
  6.     Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
  8.     TDK LAK-CD021 and CONTEC C-NET(PC)C support added by 
  9.     Nobuhiro Katayama, kata-n@po.iijnet.or.jp
  11.     The PCMCIA client code is based on code written by David Hinds.
  12.     Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
  13.     but is actually largely Donald Becker's AT1700 driver, which
  14.     carries the following attribution:
  16.     Written 1993-94 by Donald Becker.
  18.     Copyright 1993 United States Government as represented by the
  19.     Director, National Security Agency.
  20.     
  21.     This software may be used and distributed according to the terms
  22.     of the GNU General Public License, incorporated herein by reference.
  23.     
  24.     The author may be reached as becker@scyld.com, or C/O
  25.     Scyld Computing Corporation
  26.     410 Severn Ave., Suite 210
  27.     Annapolis MD 21403
  28.    
  29. ======================================================================*/
  31. #define DRV_NAME "fmvj18x_cs"
  32. #define DRV_VERSION "2.6"
  34. #include <linux/module.h>
  35. #include <linux/kernel.h>
  36. #include <linux/init.h>
  37. #include <linux/sched.h>
  38. #include <linux/ptrace.h>
  39. #include <linux/slab.h>
  40. #include <linux/string.h>
  41. #include <linux/timer.h>
  42. #include <linux/interrupt.h>
  43. #include <linux/in.h>
  44. #include <linux/delay.h>
  45. #include <linux/ethtool.h>
  47. #include <asm/uaccess.h>
  48. #include <asm/io.h>
  49. #include <asm/system.h>
  51. #include <linux/netdevice.h>
  52. #include <linux/etherdevice.h>
  53. #include <linux/skbuff.h>
  54. #include <linux/if_arp.h>
  55. #include <linux/ioport.h>
  56. #include <linux/crc32.h>
  58. #include <pcmcia/version.h>
  59. #include <pcmcia/cs_types.h>
  60. #include <pcmcia/cs.h>
  61. #include <pcmcia/cistpl.h>
  62. #include <pcmcia/ciscode.h>
  63. #include <pcmcia/ds.h>
  65. /*====================================================================*/
  67. /* Module parameters */
  68. #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
  70. /* Bit map of interrupts to choose from */
  71. /* This means pick from 15, 14, 12, 11, 10, 9, 7, 5, 4, and 3 */
  72. INT_MODULE_PARM(irq_mask, 0xdeb8);
  73. static int irq_list[4] = { -1 };
  74. MODULE_PARM(irq_list, "1-4i");
  76. /* SRAM configuration */
  77. /* 0:4KB*2 TX buffer   else:8KB*2 TX buffer */
  78. INT_MODULE_PARM(sram_config, 0);
  80. #ifdef PCMCIA_DEBUG
  81. INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  82. #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  83. static char *version = DRV_NAME ".c " DRV_VERSION " 2001/09/17";
  84. #else
  85. #define DEBUG(n, args...)
  86. #endif
  88. /*====================================================================*/
  89. /*
  90.     PCMCIA event handlers
  91.  */
  92. static void fmvj18x_config(dev_link_t *link);
  93. static int fmvj18x_get_hwinfo(dev_link_t *link, u_char *node_id);
  94. static void fmvj18x_release(u_long arg);
  95. static int fmvj18x_event(event_t event, int priority,
  96.   event_callback_args_t *args);
  97. static dev_link_t *fmvj18x_attach(void);
  98. static void fmvj18x_detach(dev_link_t *);
  100. /*
  101.     LAN controller(MBH86960A) specific routines
  102.  */
  103. static int fjn_config(struct net_device *dev, struct ifmap *map);
  104. static int fjn_open(struct net_device *dev);
  105. static int fjn_close(struct net_device *dev);
  106. static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev);
  107. static void fjn_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  108. static void fjn_rx(struct net_device *dev);
  109. static void fjn_reset(struct net_device *dev);
  110. static struct net_device_stats *fjn_get_stats(struct net_device *dev);
  111. static void set_rx_mode(struct net_device *dev);
  112. static void fjn_tx_timeout(struct net_device *dev);
  113. static int fjn_ioctl(struct net_device *, struct ifreq *, int);
  115. static dev_info_t dev_info = "fmvj18x_cs";
  116. static dev_link_t *dev_list;
  118. /*
  119.     card type
  120.  */
  121. typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN, 
  122.        XXX10304
  123. } cardtype_t;
  125. #define MANFID_UNGERMANN 0x02c0
  127. /*
  128.     driver specific data structure
  129. */
  130. typedef struct local_info_t {
  131.     dev_link_t link;
  132.     struct net_device dev;
  133.     dev_node_t node;
  134.     struct net_device_stats stats;
  135.     long open_time;
  136.     uint tx_started:1;
  137.     uint tx_queue;
  138.     u_short tx_queue_len;
  139.     cardtype_t cardtype;
  140.     u_short sent;
  141.     u_char mc_filter[8];
  142. } local_info_t;
  144. #define MC_FILTERBREAK 64
  146. /*====================================================================*/
  147. /* 
  148.     ioport offset from the base address 
  149.  */
  150. #define TX_STATUS               0 /* transmit status register */
  151. #define RX_STATUS               1 /* receive status register */
  152. #define TX_INTR                 2 /* transmit interrupt mask register */
  153. #define RX_INTR                 3 /* receive interrupt mask register */
  154. #define TX_MODE                 4 /* transmit mode register */
  155. #define RX_MODE                 5 /* receive mode register */
  156. #define CONFIG_0                6 /* configuration register 0 */
  157. #define CONFIG_1                7 /* configuration register 1 */
  159. #define NODE_ID                 8 /* node ID register            (bank 0) */
  160. #define MAR_ADR                 8 /* multicast address registers (bank 1) */
  162. #define DATAPORT                8 /* buffer mem port registers   (bank 2) */
  163. #define TX_START               10 /* transmit start register */
  164. #define COL_CTRL               11 /* 16 collision control register */
  165. #define BMPR12                 12 /* reserved */
  166. #define BMPR13                 13 /* reserved */
  167. #define RX_SKIP                14 /* skip received packet register */
  169. #define LAN_CTRL               16 /* LAN card control register */
  171. #define MAC_ID               0x1a /* hardware address */
  172. #define UNGERMANN_MAC_ID     0x18 /* UNGERMANN-BASS hardware address */
  174. /* 
  175.     control bits 
  176.  */
  177. #define ENA_TMT_OK           0x80
  178. #define ENA_TMT_REC          0x20
  179. #define ENA_COL              0x04
  180. #define ENA_16_COL           0x02
  181. #define ENA_TBUS_ERR         0x01
  183. #define ENA_PKT_RDY          0x80
  184. #define ENA_BUS_ERR          0x40
  185. #define ENA_LEN_ERR          0x08
  186. #define ENA_ALG_ERR          0x04
  187. #define ENA_CRC_ERR          0x02
  188. #define ENA_OVR_FLO          0x01
  190. /* flags */
  191. #define F_TMT_RDY            0x80 /* can accept new packet */
  192. #define F_NET_BSY            0x40 /* carrier is detected */
  193. #define F_TMT_OK             0x20 /* send packet successfully */
  194. #define F_SRT_PKT            0x10 /* short packet error */
  195. #define F_COL_ERR            0x04 /* collision error */
  196. #define F_16_COL             0x02 /* 16 collision error */
  197. #define F_TBUS_ERR           0x01 /* bus read error */
  199. #define F_PKT_RDY            0x80 /* packet(s) in buffer */
  200. #define F_BUS_ERR            0x40 /* bus read error */
  201. #define F_LEN_ERR            0x08 /* short packet */
  202. #define F_ALG_ERR            0x04 /* frame error */
  203. #define F_CRC_ERR            0x02 /* CRC error */
  204. #define F_OVR_FLO            0x01 /* overflow error */
  206. #define F_BUF_EMP            0x40 /* receive buffer is empty */
  208. #define F_SKP_PKT            0x05 /* drop packet in buffer */
  210. /* default bitmaps */
  211. #define D_TX_INTR  ( ENA_TMT_OK )
  212. #define D_RX_INTR  ( ENA_PKT_RDY | ENA_LEN_ERR 
  213.    | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
  214. #define TX_STAT_M  ( F_TMT_RDY )
  215. #define RX_STAT_M  ( F_PKT_RDY | F_LEN_ERR 
  216.                    | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
  218. /* commands */
  219. #define D_TX_MODE            0x06 /* no tests, detect carrier */
  220. #define ID_MATCHED           0x02 /* (RX_MODE) */
  221. #define RECV_ALL             0x03 /* (RX_MODE) */
  222. #define CONFIG0_DFL          0x5a /* 16bit bus, 4K x 2 Tx queues */
  223. #define CONFIG0_DFL_1        0x5e /* 16bit bus, 8K x 2 Tx queues */
  224. #define CONFIG0_RST          0xda /* Data Link Controller off (CONFIG_0) */
  225. #define CONFIG0_RST_1        0xde /* Data Link Controller off (CONFIG_0) */
  226. #define BANK_0               0xa0 /* bank 0 (CONFIG_1) */
  227. #define BANK_1               0xa4 /* bank 1 (CONFIG_1) */
  228. #define BANK_2               0xa8 /* bank 2 (CONFIG_1) */
  229. #define CHIP_OFF             0x80 /* contrl chip power off (CONFIG_1) */
  230. #define DO_TX                0x80 /* do transmit packet */
  231. #define SEND_PKT             0x81 /* send a packet */
  232. #define AUTO_MODE            0x07 /* Auto skip packet on 16 col detected */
  233. #define MANU_MODE            0x03 /* Stop and skip packet on 16 col */
  234. #define TDK_AUTO_MODE        0x47 /* Auto skip packet on 16 col detected */
  235. #define TDK_MANU_MODE        0x43 /* Stop and skip packet on 16 col */
  236. #define INTR_OFF             0x0d /* LAN controller ignores interrupts */
  237. #define INTR_ON              0x1d /* LAN controller will catch interrupts */
  239. #define TX_TIMEOUT ((400*HZ)/1000)
  241. #define BANK_0U              0x20 /* bank 0 (CONFIG_1) */
  242. #define BANK_1U              0x24 /* bank 1 (CONFIG_1) */
  243. #define BANK_2U              0x28 /* bank 2 (CONFIG_1) */
  245. /*======================================================================
  247.     This bit of code is used to avoid unregistering network devices
  248.     at inappropriate times.  2.2 and later kernels are fairly picky
  249.     about when this can happen.
  250.     
  251. ======================================================================*/
  253. static void flush_stale_links(void)
  254. {
  255.     dev_link_t *link, *next;
  256.     for (link = dev_list; link; link = next) {
  257. next = link->next;
  258. if (link->state & DEV_STALE_LINK)
  259.     fmvj18x_detach(link);
  260.     }
  261. }
  263. /*====================================================================*/
  265. static void cs_error(client_handle_t handle, int func, int ret)
  266. {
  267.     error_info_t err = { func, ret };
  268.     CardServices(ReportError, handle, &err);
  269. }
  271. /*====================================================================*/
  273. static dev_link_t *fmvj18x_attach(void)
  274. {
  275.     local_info_t *lp;
  276.     dev_link_t *link;
  277.     struct net_device *dev;
  278.     client_reg_t client_reg;
  279.     int i, ret;
  280.     
  281.     DEBUG(0, "fmvj18x_attach()n");
  282.     flush_stale_links();
  284.     /* Make up a FMVJ18x specific data structure */
  285.     lp = kmalloc(sizeof(*lp), GFP_KERNEL);
  286.     if (!lp) return NULL;
  287.     memset(lp, 0, sizeof(*lp));
  288.     link = &lp->link; dev = &lp->dev;
  289.     link->priv = dev->priv = link->irq.Instance = lp;
  291.     link->release.function = &fmvj18x_release;
  292.     link->release.data = (u_long)link;
  294.     /* The io structure describes IO port mapping */
  295.     link->io.NumPorts1 = 32;
  296.     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
  297.     link->io.IOAddrLines = 5;
  299.     /* Interrupt setup */
  300.     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
  301.     link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
  302.     if (irq_list[0] == -1)
  303. link->irq.IRQInfo2 = irq_mask;
  304.     else
  305. for (i = 0; i < 4; i++)
  306.     link->irq.IRQInfo2 |= 1 << irq_list[i];
  307.     link->irq.Handler = &fjn_interrupt;
  308.     
  309.     /* General socket configuration */
  310.     link->conf.Attributes = CONF_ENABLE_IRQ;
  311.     link->conf.Vcc = 50;
  312.     link->conf.IntType = INT_MEMORY_AND_IO;
  314.     /* The FMVJ18x specific entries in the device structure. */
  315.     dev->hard_start_xmit = &fjn_start_xmit;
  316.     dev->set_config = &fjn_config;
  317.     dev->get_stats = &fjn_get_stats;
  318.     dev->set_multicast_list = &set_rx_mode;
  319.     ether_setup(dev);
  320.     dev->open = &fjn_open;
  321.     dev->stop = &fjn_close;
  322. #ifdef HAVE_TX_TIMEOUT
  323.     dev->tx_timeout = fjn_tx_timeout;
  324.     dev->watchdog_timeo = TX_TIMEOUT;
  325. #endif
  326.     dev->do_ioctl = fjn_ioctl;
  327.     
  328.     /* Register with Card Services */
  329.     link->next = dev_list;
  330.     dev_list = link;
  331.     client_reg.dev_info = &dev_info;
  332.     client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
  333.     client_reg.EventMask =
  334. CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
  335. CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
  336. CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
  337.     client_reg.event_handler = &fmvj18x_event;
  338.     client_reg.Version = 0x0210;
  339.     client_reg.event_callback_args.client_data = link;
  340.     ret = CardServices(RegisterClient, &link->handle, &client_reg);
  341.     if (ret != 0) {
  342. cs_error(link->handle, RegisterClient, ret);
  343. fmvj18x_detach(link);
  344. return NULL;
  345.     }
  347.     return link;
  348. } /* fmvj18x_attach */
  350. /*====================================================================*/
  352. static void fmvj18x_detach(dev_link_t *link)
  353. {
  354.     local_info_t *lp = link->priv;
  355.     dev_link_t **linkp;
  356.     
  357.     DEBUG(0, "fmvj18x_detach(0x%p)n", link);
  358.     
  359.     /* Locate device structure */
  360.     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
  361. if (*linkp == link) break;
  362.     if (*linkp == NULL)
  363. return;
  365.     del_timer_sync(&link->release);
  366.     if (link->state & DEV_CONFIG) {
  367. fmvj18x_release((u_long)link);
  368. if (link->state & DEV_STALE_CONFIG) {
  369.     link->state |= DEV_STALE_LINK;
  370.     return;
  371. }
  372.     }
  374.     /* Break the link with Card Services */
  375.     if (link->handle)
  376. CardServices(DeregisterClient, link->handle);
  377.     
  378.     /* Unlink device structure, free pieces */
  379.     *linkp = link->next;
  380.     if (link->dev)
  381. unregister_netdev(&lp->dev);
  382.     kfree(lp);
  383.     
  384. } /* fmvj18x_detach */
  386. /*====================================================================*/
  388. #define CS_CHECK(fn, args...) 
  389. while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed
  391. static void fmvj18x_config(dev_link_t *link)
  392. {
  393.     client_handle_t handle = link->handle;
  394.     local_info_t *lp = link->priv;
  395.     struct net_device *dev = &lp->dev;
  396.     tuple_t tuple;
  397.     cisparse_t parse;
  398.     u_short buf[32];
  399.     int i, last_fn, last_ret, ret;
  400.     ioaddr_t ioaddr;
  401.     cardtype_t cardtype;
  402.     char *card_name = "unknown";
  403.     u_char *node_id;
  404.     
  405.     DEBUG(0, "fmvj18x_config(0x%p)n", link);
  407.     /*
  408.        This reads the card's CONFIG tuple to find its configuration
  409.        registers.
  410.     */
  411.     tuple.DesiredTuple = CISTPL_CONFIG;
  412.     CS_CHECK(GetFirstTuple, handle, &tuple);
  413.     tuple.TupleData = (u_char *)buf;
  414.     tuple.TupleDataMax = 64;
  415.     tuple.TupleOffset = 0;
  416.     CS_CHECK(GetTupleData, handle, &tuple);
  417.     CS_CHECK(ParseTuple, handle, &tuple, &parse);
  418.     
  419.     /* Configure card */
  420.     link->state |= DEV_CONFIG;
  422.     link->conf.ConfigBase = parse.config.base; 
  423.     link->conf.Present = parse.config.rmask[0];
  425.     tuple.DesiredTuple = CISTPL_FUNCE;
  426.     tuple.TupleOffset = 0;
  427.     if (CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS) {
  428. /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
  429. tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
  430. CS_CHECK(GetFirstTuple, handle, &tuple);
  431. CS_CHECK(GetTupleData, handle, &tuple);
  432. CS_CHECK(ParseTuple, handle, &tuple, &parse);
  433. link->conf.ConfigIndex = parse.cftable_entry.index;
  434. tuple.DesiredTuple = CISTPL_MANFID;
  435. if (CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS)
  436.     CS_CHECK(GetTupleData, handle, &tuple);
  437. else
  438.     buf[0] = 0xffff;
  439. switch (le16_to_cpu(buf[0])) {
  440. case MANFID_TDK:
  441.     cardtype = TDK;
  442.     if (le16_to_cpu(buf[1]) == PRODID_TDK_CF010) {
  443. cs_status_t status;
  444. CardServices(GetStatus, handle, &status);
  445. if (status.CardState & CS_EVENT_3VCARD)
  446.     link->conf.Vcc = 33; /* inserted in 3.3V slot */
  447.     }
  448.     break;
  449. case MANFID_CONTEC:
  450.     cardtype = CONTEC;
  451.     break;
  452. case MANFID_FUJITSU:
  453.     if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10302)
  454.                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
  455.                    but these are MBH10304 based card. */ 
  456. cardtype = MBH10304;
  457.     else if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10304)
  458. cardtype = MBH10304;
  459.     else
  460. cardtype = LA501;
  461.     break;
  462. default:
  463.     cardtype = MBH10304;
  464. }
  465.     } else {
  466. /* old type card */
  467. tuple.DesiredTuple = CISTPL_MANFID;
  468. if (CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS)
  469.     CS_CHECK(GetTupleData, handle, &tuple);
  470. else
  471.     buf[0] = 0xffff;
  472. switch (le16_to_cpu(buf[0])) {
  473. case MANFID_FUJITSU:
  474.     if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10304) {
  475. cardtype = XXX10304;    /* MBH10304 with buggy CIS */
  476.         link->conf.ConfigIndex = 0x20;
  477.     } else {
  478. cardtype = MBH10302;    /* NextCom NC5310, etc. */
  479. link->conf.ConfigIndex = 1;
  480.     }
  481.     break;
  482. case MANFID_UNGERMANN:
  483.     cardtype = UNGERMANN;
  484.     /*
  485.        Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
  486.        0x380,0x3c0 only for ioport.
  487.     */
  488.     for (link->io.BasePort1 = 0x300; link->io.BasePort1 < 0x3e0;
  489. link->io.BasePort1 += 0x20) {
  490. ret = CardServices(RequestIO, link->handle, &link->io);
  491. if (ret == CS_SUCCESS) {
  492. /* calculate ConfigIndex value */
  493. link->conf.ConfigIndex = 
  494.     ((link->io.BasePort1 & 0x0f0) >> 3) | 0x22;
  495. goto req_irq;
  496. }
  497.     }
  498.     /* if ioport allocation is failed, goto failed */
  499.     printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failedn");
  500.     goto failed;
  501. default:
  502.     cardtype = MBH10302;
  503.     link->conf.ConfigIndex = 1;
  504. }
  505.     }
  507.     CS_CHECK(RequestIO, link->handle, &link->io);
  508. req_irq:
  509.     CS_CHECK(RequestIRQ, link->handle, &link->irq);
  510.     CS_CHECK(RequestConfiguration, link->handle, &link->conf);
  511.     dev->irq = link->irq.AssignedIRQ;
  512.     dev->base_addr = link->io.BasePort1;
  513.     if (register_netdev(dev) != 0) {
  514. printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failedn");
  515. goto failed;
  516.     }
  518.     ioaddr = dev->base_addr;
  520.     /* Reset controller */
  521.     if( sram_config == 0 ) 
  522. outb(CONFIG0_RST, ioaddr + CONFIG_0);
  523.     else
  524. outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
  526.     /* Power On chip and select bank 0 */
  527.     if(cardtype == UNGERMANN)
  528. outb(BANK_0U, ioaddr + CONFIG_1);
  529.     else
  530. outb(BANK_0, ioaddr + CONFIG_1);
  531.     
  532.     /* Set hardware address */
  533.     switch (cardtype) {
  534.     case MBH10304:
  535.     case TDK:
  536.     case LA501:
  537.     case CONTEC:
  538. tuple.DesiredTuple = CISTPL_FUNCE;
  539. tuple.TupleOffset = 0;
  540. CS_CHECK(GetFirstTuple, handle, &tuple);
  541. tuple.TupleOffset = 0;
  542. CS_CHECK(GetTupleData, handle, &tuple);
  543. if (cardtype == MBH10304) {
  544.     /* MBH10304's CIS_FUNCE is corrupted */
  545.     node_id = &(tuple.TupleData[5]);
  546.     card_name = "FMV-J182";
  547. } else {
  548.     while (tuple.TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID ) {
  549. CS_CHECK(GetNextTuple, handle, &tuple) ;
  550. CS_CHECK(GetTupleData, handle, &tuple) ;
  551.     }
  552.     node_id = &(tuple.TupleData[2]);
  553.     if( cardtype == TDK ) {
  554. card_name = "TDK LAK-CD021";
  555.     } else if( cardtype == LA501 ) {
  556. card_name = "LA501";
  557.     } else {
  558. card_name = "C-NET(PC)C";
  559.     }
  560. }
  561. /* Read MACID from CIS */
  562. for (i = 0; i < 6; i++)
  563.     dev->dev_addr[i] = node_id[i];
  564. break;
  565.     case UNGERMANN:
  566. /* Read MACID from register */
  567. for (i = 0; i < 6; i++) 
  568.     dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
  569. card_name = "Access/CARD";
  570. break;
  571.     case XXX10304:
  572. /* Read MACID from Buggy CIS */
  573. if (fmvj18x_get_hwinfo(link, tuple.TupleData) == -1) {
  574.     printk(KERN_NOTICE "fmvj18x_cs: unable to read hardware net address.n");
  575.     unregister_netdev(dev);
  576.     goto failed;
  577. }
  578. for (i = 0 ; i < 6; i++) {
  579.     dev->dev_addr[i] = tuple.TupleData[i];
  580. }
  581. card_name = "FMV-J182";
  582. break;
  583.     case MBH10302:
  584.     default:
  585. /* Read MACID from register */
  586. for (i = 0; i < 6; i++) 
  587.     dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
  588. card_name = "FMV-J181";
  589. break;
  590.     }
  592.     strcpy(lp->node.dev_name, dev->name);
  593.     link->dev = &lp->node;
  594.     link->state &= ~DEV_CONFIG_PENDING;
  596.     lp->cardtype = cardtype;
  597.     /* print current configuration */
  598.     printk(KERN_INFO "%s: %s, sram %s, port %#3lx, irq %d, hw_addr ", 
  599.    dev->name, card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2", 
  600.    dev->base_addr, dev->irq);
  601.     for (i = 0; i < 6; i++)
  602. printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "n"));
  604.     return;
  605.     
  606. cs_failed:
  607.     /* All Card Services errors end up here */
  608.     cs_error(link->handle, last_fn, last_ret);
  609. failed:
  610.     fmvj18x_release((u_long)link);
  612. } /* fmvj18x_config */
  613. /*====================================================================*/
  615. static int fmvj18x_get_hwinfo(dev_link_t *link, u_char *node_id)
  616. {
  617.     win_req_t req;
  618.     memreq_t mem;
  619.     u_char *base;
  620.     int i, j;
  622.     /* Allocate a small memory window */
  623.     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
  624.     req.Base = 0; req.Size = 0;
  625.     req.AccessSpeed = 0;
  626.     link->win = (window_handle_t)link->handle;
  627.     i = CardServices(RequestWindow, &link->win, &req);
  628.     if (i != CS_SUCCESS) {
  629. cs_error(link->handle, RequestWindow, i);
  630. return -1;
  631.     }
  633.     base = ioremap(req.Base, req.Size);
  634.     mem.Page = 0;
  635.     mem.CardOffset = 0;
  636.     CardServices(MapMemPage, link->win, &mem);
  638.     /*
  639.      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
  640.      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
  641.      *  'xx' is garbage.
  642.      *  'yy' is MAC address.
  643.     */ 
  644.     for (i = 0; i < 0x200; i++) {
  645. if (readb(base+i*2) == 0x22) {
  646.     if (readb(base+(i-1)*2) == 0xff
  647.      && readb(base+(i+5)*2) == 0x04
  648.      && readb(base+(i+6)*2) == 0x06
  649.      && readb(base+(i+13)*2) == 0xff) 
  650. break;
  651. }
  652.     }
  654.     if (i != 0x200) {
  655. for (j = 0 ; j < 6; j++,i++) {
  656.     node_id[j] = readb(base+(i+7)*2);
  657. }
  658.     }
  660.     iounmap(base);
  661.     j = CardServices(ReleaseWindow, link->win);
  662.     if (j != CS_SUCCESS)
  663. cs_error(link->handle, ReleaseWindow, j);
  664.     return (i != 0x200) ? 0 : -1;
  666. } /* fmvj18x_get_hwinfo */
  667. /*====================================================================*/
  669. static void fmvj18x_release(u_long arg)
  670. {
  671.     dev_link_t *link = (dev_link_t *)arg;
  673.     DEBUG(0, "fmvj18x_release(0x%p)n", link);
  675.     /*
  676.        If the device is currently in use, we won't release until it
  677.        is actually closed.
  678.     */
  679.     if (link->open) {
  680. DEBUG(1, "fmvj18x_cs: release postponed, '%s' "
  681.       "still openn", link->dev->dev_name);
  682. link->state |= DEV_STALE_CONFIG;
  683. return;
  684.     }
  686.     /* Don't bother checking to see if these succeed or not */
  687.     CardServices(ReleaseWindow, link->win);
  688.     CardServices(ReleaseConfiguration, link->handle);
  689.     CardServices(ReleaseIO, link->handle, &link->io);
  690.     CardServices(ReleaseIRQ, link->handle, &link->irq);
  691.     
  692.     link->state &= ~DEV_CONFIG;
  693.     
  694. } /* fmvj18x_release */
  696. /*====================================================================*/
  698. static int fmvj18x_event(event_t event, int priority,
  699.   event_callback_args_t *args)
  700. {
  701.     dev_link_t *link = args->client_data;
  702.     local_info_t *lp = link->priv;
  703.     struct net_device *dev = &lp->dev;
  705.     DEBUG(1, "fmvj18x_event(0x%06x)n", event);
  706.     
  707.     switch (event) {
  708.     case CS_EVENT_CARD_REMOVAL:
  709. link->state &= ~DEV_PRESENT;
  710. if (link->state & DEV_CONFIG) {
  711.     netif_device_detach(dev);
  712.     mod_timer(&link->release, jiffies + HZ/20);
  713. }
  714. break;
  715.     case CS_EVENT_CARD_INSERTION:
  716. link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
  717. fmvj18x_config(link);
  718. break;
  719.     case CS_EVENT_PM_SUSPEND:
  720. link->state |= DEV_SUSPEND;
  721. /* Fall through... */
  722.     case CS_EVENT_RESET_PHYSICAL:
  723. if (link->state & DEV_CONFIG) {
  724.     if (link->open)
  725. netif_device_detach(dev);
  726.     CardServices(ReleaseConfiguration, link->handle);
  727. }
  728. break;
  729.     case CS_EVENT_PM_RESUME:
  730. link->state &= ~DEV_SUSPEND;
  731. /* Fall through... */
  732.     case CS_EVENT_CARD_RESET:
  733. if (link->state & DEV_CONFIG) {
  734.     CardServices(RequestConfiguration, link->handle, &link->conf);
  735.     if (link->open) {
  736. fjn_reset(dev);
  737. netif_device_attach(dev);
  738.     }
  739. }
  740. break;
  741.     }
  742.     return 0;
  743. } /* fmvj18x_event */
  745. /*====================================================================*/
  747. static int __init init_fmvj18x_cs(void)
  748. {
  749.     servinfo_t serv;
  750.     DEBUG(0, "%sn", version);
  751.     CardServices(GetCardServicesInfo, &serv);
  752.     if (serv.Revision != CS_RELEASE_CODE) {
  753. printk(KERN_NOTICE "fmvj18x: Card Services release "
  754.        "does not match!n");
  755. return -1;
  756.     }
  757.     register_pccard_driver(&dev_info, &fmvj18x_attach, &fmvj18x_detach);
  758.     return 0;
  759. }
  761. static void __exit exit_fmvj18x_cs(void)
  762. {
  763.     DEBUG(0, "fmvj18x_cs: unloadingn");
  764.     unregister_pccard_driver(&dev_info);
  765.     while (dev_list != NULL)
  766. fmvj18x_detach(dev_list);
  767. }
  769. module_init(init_fmvj18x_cs);
  770. module_exit(exit_fmvj18x_cs);
  772. /*====================================================================*/
  774. static void fjn_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  775. {
  776.     local_info_t *lp = dev_id;
  777.     struct net_device *dev = &lp->dev;
  778.     ioaddr_t ioaddr;
  779.     unsigned short tx_stat, rx_stat;
  781.     if (lp == NULL) {
  782.         printk(KERN_NOTICE "fjn_interrupt(): irq %d for "
  783.        "unknown device.n", irq);
  784.         return;
  785.     }
  786.     ioaddr = dev->base_addr;
  788.     /* avoid multiple interrupts */
  789.     outw(0x0000, ioaddr + TX_INTR);
  791.     /* wait for a while */
  792.     udelay(1);
  794.     /* get status */
  795.     tx_stat = inb(ioaddr + TX_STATUS);
  796.     rx_stat = inb(ioaddr + RX_STATUS);
  798.     /* clear status */
  799.     outb(tx_stat, ioaddr + TX_STATUS);
  800.     outb(rx_stat, ioaddr + RX_STATUS);
  801.     
  802.     DEBUG(4, "%s: interrupt, rx_status %02x.n", dev->name, rx_stat);
  803.     DEBUG(4, "               tx_status %02x.n", tx_stat);
  804.     
  805.     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
  806. /* there is packet(s) in rx buffer */
  807. fjn_rx(dev);
  808.     }
  809.     if (tx_stat & F_TMT_RDY) {
  810. lp->stats.tx_packets += lp->sent ;
  811.         lp->sent = 0 ;
  812. if (lp->tx_queue) {
  813.     outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
  814.     lp->sent = lp->tx_queue ;
  815.     lp->tx_queue = 0;
  816.     lp->tx_queue_len = 0;
  817.     dev->trans_start = jiffies;
  818. } else {
  819.     lp->tx_started = 0;
  820. }
  821. netif_wake_queue(dev);
  822.     }
  823.     DEBUG(4, "%s: exiting interrupt,n", dev->name);
  824.     DEBUG(4, "    tx_status %02x, rx_status %02x.n", tx_stat, rx_stat);
  826.     outb(D_TX_INTR, ioaddr + TX_INTR);
  827.     outb(D_RX_INTR, ioaddr + RX_INTR);
  829. } /* fjn_interrupt */
  831. /*====================================================================*/
  833. static void fjn_tx_timeout(struct net_device *dev)
  834. {
  835.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  836.     ioaddr_t ioaddr = dev->base_addr;
  838.     printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?n",
  839.    dev->name, htons(inw(ioaddr + TX_STATUS)),
  840.    inb(ioaddr + TX_STATUS) & F_TMT_RDY
  841.    ? "IRQ conflict" : "network cable problem");
  842.     printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
  843.    "%04x %04x %04x %04x %04x.n",
  844.    dev->name, htons(inw(ioaddr + 0)),
  845.    htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
  846.    htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
  847.    htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
  848.    htons(inw(ioaddr +14)));
  849.     lp->stats.tx_errors++;
  850.     /* ToDo: We should try to restart the adaptor... */
  851.     cli();
  853.     fjn_reset(dev);
  855.     lp->tx_started = 0;
  856.     lp->tx_queue = 0;
  857.     lp->tx_queue_len = 0;
  858.     lp->sent = 0;
  859.     lp->open_time = jiffies;
  860.     sti();
  861.     netif_wake_queue(dev);
  862. }
  864. static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev)
  865. {
  866.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  867.     ioaddr_t ioaddr = dev->base_addr;
  869.     netif_stop_queue(dev);
  871.     {
  872. short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  873. unsigned char *buf = skb->data;
  875. if (length > ETH_FRAME_LEN) {
  876.     printk(KERN_NOTICE "%s: Attempting to send a large packet"
  877.    " (%d bytes).n", dev->name, length);
  878.     return 1;
  879. }
  881. DEBUG(4, "%s: Transmitting a packet of length %lu.n",
  882.       dev->name, (unsigned long)skb->len);
  883. lp->stats.tx_bytes += skb->len;
  885. /* Disable both interrupts. */
  886. outw(0x0000, ioaddr + TX_INTR);
  888. /* wait for a while */
  889. udelay(1);
  891. outw(length, ioaddr + DATAPORT);
  892. outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
  894. lp->tx_queue++;
  895. lp->tx_queue_len += ((length+3) & ~1);
  897. if (lp->tx_started == 0) {
  898.     /* If the Tx is idle, always trigger a transmit. */
  899.     outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
  900.     lp->sent = lp->tx_queue ;
  901.     lp->tx_queue = 0;
  902.     lp->tx_queue_len = 0;
  903.     dev->trans_start = jiffies;
  904.     lp->tx_started = 1;
  905.     netif_start_queue(dev);
  906. } else {
  907.     if( sram_config == 0 ) {
  908. if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
  909.     /* Yes, there is room for one more packet. */
  910.     netif_start_queue(dev);
  911.     } else {
  912. if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) && 
  913. lp->tx_queue < 127 )
  914.     /* Yes, there is room for one more packet. */
  915.     netif_start_queue(dev);
  916.     }
  917. }
  919. /* Re-enable interrupts */
  920. outb(D_TX_INTR, ioaddr + TX_INTR);
  921. outb(D_RX_INTR, ioaddr + RX_INTR);
  922.     }
  923.     dev_kfree_skb (skb);
  925.     return 0;
  926. } /* fjn_start_xmit */
  928. /*====================================================================*/
  930. static void fjn_reset(struct net_device *dev)
  931. {
  932.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  933.     ioaddr_t ioaddr = dev->base_addr;
  934.     int i;
  936.     DEBUG(4, "fjn_reset(%s) called.n",dev->name);
  938.     /* Reset controller */
  939.     if( sram_config == 0 ) 
  940. outb(CONFIG0_RST, ioaddr + CONFIG_0);
  941.     else
  942. outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
  944.     /* Power On chip and select bank 0 */
  945.     if( lp->cardtype == UNGERMANN)
  946. outb(BANK_0U, ioaddr + CONFIG_1);
  947.     else
  948. outb(BANK_0, ioaddr + CONFIG_1);
  950.     /* Set Tx modes */
  951.     outb(D_TX_MODE, ioaddr + TX_MODE);
  952.     /* set Rx modes */
  953.     outb(ID_MATCHED, ioaddr + RX_MODE);
  955.     /* Set hardware address */
  956.     for (i = 0; i < 6; i++) 
  957.         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
  959.     /* Switch to bank 1 */
  960.     if ( lp->cardtype == UNGERMANN )
  961. outb(BANK_1U, ioaddr + CONFIG_1);
  962.     else
  963. outb(BANK_1, ioaddr + CONFIG_1);
  965.     /* set the multicast table to accept none. */
  966.     for (i = 0; i < 6; i++) 
  967.         outb(0x00, ioaddr + MAR_ADR + i);
  969.     /* Switch to bank 2 (runtime mode) */
  970.     if ( lp->cardtype == UNGERMANN )
  971. outb(BANK_2U, ioaddr + CONFIG_1);
  972.     else
  973. outb(BANK_2, ioaddr + CONFIG_1);
  975.     /* set 16col ctrl bits */
  976.     if( lp->cardtype == TDK || lp->cardtype == CONTEC) 
  977.         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
  978.     else
  979.         outb(AUTO_MODE, ioaddr + COL_CTRL);
  981.     /* clear Reserved Regs */
  982.     outb(0x00, ioaddr + BMPR12);
  983.     outb(0x00, ioaddr + BMPR13);
  985.     /* reset Skip packet reg. */
  986.     outb(0x01, ioaddr + RX_SKIP);
  988.     /* Enable Tx and Rx */
  989.     if( sram_config == 0 )
  990. outb(CONFIG0_DFL, ioaddr + CONFIG_0);
  991.     else
  992. outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
  994.     /* Init receive pointer ? */
  995.     inw(ioaddr + DATAPORT);
  996.     inw(ioaddr + DATAPORT);
  998.     /* Clear all status */
  999.     outb(0xff, ioaddr + TX_STATUS);
  1000.     outb(0xff, ioaddr + RX_STATUS);
  1002.     if( lp->cardtype != TDK ) 
  1003.      outb(INTR_OFF, ioaddr + LAN_CTRL);
  1005.     /* Turn on Rx interrupts */
  1006.     outb(D_TX_INTR, ioaddr + TX_INTR);
  1007.     outb(D_RX_INTR, ioaddr + RX_INTR);
  1009.     /* Turn on interrupts from LAN card controller */
  1010.     if( lp->cardtype != TDK ) 
  1011. outb(INTR_ON, ioaddr + LAN_CTRL);
  1012. } /* fjn_reset */
  1014. /*====================================================================*/
  1016. static void fjn_rx(struct net_device *dev)
  1017. {
  1018.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  1019.     ioaddr_t ioaddr = dev->base_addr;
  1020.     int boguscount = 10; /* 5 -> 10: by agy 19940922 */
  1022.     DEBUG(4, "%s: in rx_packet(), rx_status %02x.n",
  1023.   dev->name, inb(ioaddr + RX_STATUS));
  1025.     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
  1026. u_short status = inw(ioaddr + DATAPORT);
  1028. DEBUG(4, "%s: Rxing packet mode %02x status %04x.n",
  1029.       dev->name, inb(ioaddr + RX_MODE), status);
  1030. #ifndef final_version
  1031. if (status == 0) {
  1032.     outb(F_SKP_PKT, ioaddr + RX_SKIP);
  1033.     break;
  1034. }
  1035. #endif
  1036. if ((status & 0xF0) != 0x20) { /* There was an error. */
  1037.     lp->stats.rx_errors++;
  1038.     if (status & F_LEN_ERR) lp->stats.rx_length_errors++;
  1039.     if (status & F_ALG_ERR) lp->stats.rx_frame_errors++;
  1040.     if (status & F_CRC_ERR) lp->stats.rx_crc_errors++;
  1041.     if (status & F_OVR_FLO) lp->stats.rx_over_errors++;
  1042. } else {
  1043.     u_short pkt_len = inw(ioaddr + DATAPORT);
  1044.     /* Malloc up new buffer. */
  1045.     struct sk_buff *skb;
  1047.     if (pkt_len > 1550) {
  1048. printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
  1049.        "large packet, size %d.n", dev->name, pkt_len);
  1050. outb(F_SKP_PKT, ioaddr + RX_SKIP);
  1051. lp->stats.rx_errors++;
  1052. break;
  1053.     }
  1054.     skb = dev_alloc_skb(pkt_len+2);
  1055.     if (skb == NULL) {
  1056. printk(KERN_NOTICE "%s: Memory squeeze, dropping "
  1057.        "packet (len %d).n", dev->name, pkt_len);
  1058. outb(F_SKP_PKT, ioaddr + RX_SKIP);
  1059. lp->stats.rx_dropped++;
  1060. break;
  1061.     }
  1062.     skb->dev = dev;
  1064.     skb_reserve(skb, 2);
  1065.     insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
  1066.     (pkt_len + 1) >> 1);
  1067.     skb->protocol = eth_type_trans(skb, dev);
  1069. #ifdef PCMCIA_DEBUG
  1070.     if (pc_debug > 5) {
  1071. int i;
  1072. printk(KERN_DEBUG "%s: Rxed packet of length %d: ",
  1073.        dev->name, pkt_len);
  1074. for (i = 0; i < 14; i++)
  1075.     printk(" %02x", skb->data[i]);
  1076. printk(".n");
  1077.     }
  1078. #endif
  1080.     netif_rx(skb);
  1081.     dev->last_rx = jiffies;
  1082.     lp->stats.rx_packets++;
  1083.     lp->stats.rx_bytes += pkt_len;
  1084. }
  1085. if (--boguscount <= 0)
  1086.     break;
  1087.     }
  1089.     /* If any worth-while packets have been received, dev_rint()
  1090.    has done a netif_wake_queue() for us and will work on them
  1091.    when we get to the bottom-half routine. */
  1092. /*
  1093.     if( lp->cardtype != TDK ) {
  1094. int i;
  1095. for (i = 0; i < 20; i++) {
  1096.     if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
  1097. break;
  1098.     (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
  1099.     outb(F_SKP_PKT, ioaddr + RX_SKIP);
  1100. }
  1102. if (i > 0)
  1103.     DEBUG(5, "%s: Exint Rx packet with mode %02x after "
  1104.   "%d ticks.n", dev->name, inb(ioaddr + RX_MODE), i);
  1105.     }
  1106. */
  1108.     return;
  1109. } /* fjn_rx */
  1111. /*====================================================================*/
  1113. static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1114. {
  1115. u32 ethcmd;
  1117. /* dev_ioctl() in ../../net/core/dev.c has already checked
  1118.    capable(CAP_NET_ADMIN), so don't bother with that here.  */
  1120. if (get_user(ethcmd, (u32 *)useraddr))
  1121. return -EFAULT;
  1123. switch (ethcmd) {
  1125. case ETHTOOL_GDRVINFO: {
  1126. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1127. strcpy (info.driver, DRV_NAME);
  1128. strcpy (info.version, DRV_VERSION);
  1129. sprintf(info.bus_info, "PCMCIA 0x%lx", dev->base_addr);
  1130. if (copy_to_user (useraddr, &info, sizeof (info)))
  1131. return -EFAULT;
  1132. return 0;
  1133. }
  1135. #ifdef PCMCIA_DEBUG
  1136. /* get message-level */
  1137. case ETHTOOL_GMSGLVL: {
  1138. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1139. edata.data = pc_debug;
  1140. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1141. return -EFAULT;
  1142. return 0;
  1143. }
  1144. /* set message-level */
  1145. case ETHTOOL_SMSGLVL: {
  1146. struct ethtool_value edata;
  1147. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1148. return -EFAULT;
  1149. pc_debug = edata.data;
  1150. return 0;
  1151. }
  1152. #endif
  1154. default:
  1155. break;
  1156. }
  1158. return -EOPNOTSUPP;
  1159. }
  1161. static int fjn_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1162. {
  1163. switch (cmd) {
  1164. case SIOCETHTOOL:
  1165. return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1167. default:
  1168. return -EOPNOTSUPP;
  1169. }
  1170. }
  1172. static int fjn_config(struct net_device *dev, struct ifmap *map){
  1173.     return 0;
  1174. }
  1176. static int fjn_open(struct net_device *dev)
  1177. {
  1178.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  1179.     dev_link_t *link = &lp->link;
  1181.     DEBUG(4, "fjn_open('%s').n", dev->name);
  1183.     if (!DEV_OK(link))
  1184. return -ENODEV;
  1185.     
  1186.     link->open++;
  1187.     
  1188.     fjn_reset(dev);
  1189.     
  1190.     lp->tx_started = 0;
  1191.     lp->tx_queue = 0;
  1192.     lp->tx_queue_len = 0;
  1193.     lp->open_time = jiffies;
  1194.     netif_start_queue(dev);
  1195.     
  1196.     MOD_INC_USE_COUNT;
  1198.     return 0;
  1199. } /* fjn_open */
  1201. /*====================================================================*/
  1203. static int fjn_close(struct net_device *dev)
  1204. {
  1205.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  1206.     dev_link_t *link = &lp->link;
  1207.     ioaddr_t ioaddr = dev->base_addr;
  1209.     DEBUG(4, "fjn_close('%s').n", dev->name);
  1211.     lp->open_time = 0;
  1212.     netif_stop_queue(dev);
  1214.     /* Set configuration register 0 to disable Tx and Rx. */
  1215.     if( sram_config == 0 ) 
  1216. outb(CONFIG0_RST ,ioaddr + CONFIG_0);
  1217.     else
  1218. outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
  1220.     /* Update the statistics -- ToDo. */
  1222.     /* Power-down the chip.  Green, green, green! */
  1223.     outb(CHIP_OFF ,ioaddr + CONFIG_1);
  1225.     /* Set the ethernet adaptor disable IRQ */
  1226.     if( lp->cardtype != TDK ) 
  1227. outb(INTR_OFF, ioaddr + LAN_CTRL);
  1229.     link->open--;
  1230.     if (link->state & DEV_STALE_CONFIG)
  1231. mod_timer(&link->release, jiffies + HZ/20);
  1232.     MOD_DEC_USE_COUNT;
  1234.     return 0;
  1235. } /* fjn_close */
  1237. /*====================================================================*/
  1239. static struct net_device_stats *fjn_get_stats(struct net_device *dev)
  1240. {
  1241.     local_info_t *lp = (local_info_t *)dev->priv;
  1242.     return &lp->stats;
  1243. } /* fjn_get_stats */
  1245. /*====================================================================*/
  1247. /*
  1248.   Set the multicast/promiscuous mode for this adaptor.
  1249. */
  1251. static void set_rx_mode(struct net_device *dev)
  1252. {
  1253.     ioaddr_t ioaddr = dev->base_addr;
  1254.     struct local_info_t *lp = (struct local_info_t *)dev->priv;
  1255.     unsigned char mc_filter[8];  /* Multicast hash filter */
  1256.     unsigned long flags;
  1257.     int i;
  1258.     
  1259.     if (dev->flags & IFF_PROMISC) {
  1260. /* Unconditionally log net taps. */
  1261. printk("%s: Promiscuous mode enabled.n", dev->name);
  1262. memset(mc_filter, 0xff, sizeof(mc_filter));
  1263. outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
  1264.     } else if (dev->mc_count > MC_FILTERBREAK
  1265.        ||  (dev->flags & IFF_ALLMULTI)) {
  1266. /* Too many to filter perfectly -- accept all multicasts. */
  1267. memset(mc_filter, 0xff, sizeof(mc_filter));
  1268. outb(2, ioaddr + RX_MODE); /* Use normal mode. */
  1269.     } else if (dev->mc_count == 0) {
  1270. memset(mc_filter, 0x00, sizeof(mc_filter));
  1271. outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
  1272.     } else {
  1273. struct dev_mc_list *mclist;
  1274. int i;
  1276. memset(mc_filter, 0, sizeof(mc_filter));
  1277. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  1278.      i++, mclist = mclist->next)
  1279.     set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f,
  1280.     mc_filter);
  1281.     }
  1282.     
  1283.     save_flags(flags);
  1284.     cli();
  1285.     if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
  1286. int saved_bank = inb(ioaddr + CONFIG_1);
  1287. /* Switch to bank 1 and set the multicast table. */
  1288. outb(0xe4, ioaddr + CONFIG_1);
  1289. for (i = 0; i < 8; i++)
  1290.     outb(mc_filter[i], ioaddr + 8 + i);
  1291. memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
  1292. outb(saved_bank, ioaddr + CONFIG_1);
  1293.     }
  1294.     restore_flags(flags);
  1295. }
  1296. MODULE_LICENSE("GPL");