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

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

嵌入式Linux

开发平台：

Unix_Linux

nmclan_cs.c：源码内容
  1. /* ----------------------------------------------------------------------------
  2. Linux PCMCIA ethernet adapter driver for the New Media Ethernet LAN.
  3.   nmclan_cs.c,v 0.16 1995/07/01 06:42:17 rpao Exp rpao
  5.   The Ethernet LAN uses the Advanced Micro Devices (AMD) Am79C940 Media
  6.   Access Controller for Ethernet (MACE).  It is essentially the Am2150
  7.   PCMCIA Ethernet card contained in the Am2150 Demo Kit.
  9. Written by Roger C. Pao <rpao@paonet.org>
  10.   Copyright 1995 Roger C. Pao
  12.   This software may be used and distributed according to the terms of
  13.   the GNU General Public License.
  15. Ported to Linux 1.3.* network driver environment by
  16.   Matti Aarnio <mea@utu.fi>
  18. References
  20.   Am2150 Technical Reference Manual, Revision 1.0, August 17, 1993
  21.   Am79C940 (MACE) Data Sheet, 1994
  22.   Am79C90 (C-LANCE) Data Sheet, 1994
  23.   Linux PCMCIA Programmer's Guide v1.17
  24.   /usr/src/linux/net/inet/dev.c, Linux kernel 1.2.8
  26.   Eric Mears, New Media Corporation
  27.   Tom Pollard, New Media Corporation
  28.   Dean Siasoyco, New Media Corporation
  29.   Ken Lesniak, Silicon Graphics, Inc. <lesniak@boston.sgi.com>
  30.   Donald Becker <becker@scyld.com>
  31.   David Hinds <dahinds@users.sourceforge.net>
  33.   The Linux client driver is based on the 3c589_cs.c client driver by
  34.   David Hinds.
  36.   The Linux network driver outline is based on the 3c589_cs.c driver,
  37.   the 8390.c driver, and the example skeleton.c kernel code, which are
  38.   by Donald Becker.
  40.   The Am2150 network driver hardware interface code is based on the
  41.   OS/9000 driver for the New Media Ethernet LAN by Eric Mears.
  43.   Special thanks for testing and help in debugging this driver goes
  44.   to Ken Lesniak.
  46. -------------------------------------------------------------------------------
  47. Driver Notes and Issues
  48. -------------------------------------------------------------------------------
  50. 1. Developed on a Dell 320SLi
  51.    PCMCIA Card Services 2.6.2
  52.    Linux dell 1.2.10 #1 Thu Jun 29 20:23:41 PDT 1995 i386
  54. 2. rc.pcmcia may require loading pcmcia_core with io_speed=300:
  55.    'insmod pcmcia_core.o io_speed=300'.
  56.    This will avoid problems with fast systems which causes rx_framecnt
  57.    to return random values.
  59. 3. If hot extraction does not work for you, use 'ifconfig eth0 down'
  60.    before extraction.
  62. 4. There is a bad slow-down problem in this driver.
  64. 5. Future: Multicast processing.  In the meantime, do _not_ compile your
  65.    kernel with multicast ip enabled.
  67. -------------------------------------------------------------------------------
  68. History
  69. -------------------------------------------------------------------------------
  70. Log: nmclan_cs.c,v
  71.  * Revision 0.16  1995/07/01  06:42:17  rpao
  72.  * Bug fix: nmclan_reset() called CardServices incorrectly.
  73.  *
  74.  * Revision 0.15  1995/05/24  08:09:47  rpao
  75.  * Re-implement MULTI_TX dev->tbusy handling.
  76.  *
  77.  * Revision 0.14  1995/05/23  03:19:30  rpao
  78.  * Added, in nmclan_config(), "tuple.Attributes = 0;".
  79.  * Modified MACE ID check to ignore chip revision level.
  80.  * Avoid tx_free_frames race condition between _start_xmit and _interrupt.
  81.  *
  82.  * Revision 0.13  1995/05/18  05:56:34  rpao
  83.  * Statistics changes.
  84.  * Bug fix: nmclan_reset did not enable TX and RX: call restore_multicast_list.
  85.  * Bug fix: mace_interrupt checks ~MACE_IMR_DEFAULT.  Fixes driver lockup.
  86.  *
  87.  * Revision 0.12  1995/05/14  00:12:23  rpao
  88.  * Statistics overhaul.
  89.  *
  91. 95/05/13 rpao V0.10a
  92. Bug fix: MACE statistics counters used wrong I/O ports.
  93. Bug fix: mace_interrupt() needed to allow statistics to be
  94. processed without RX or TX interrupts pending.
  95. 95/05/11 rpao V0.10
  96. Multiple transmit request processing.
  97. Modified statistics to use MACE counters where possible.
  98. 95/05/10 rpao V0.09 Bug fix: Must use IO_DATA_PATH_WIDTH_AUTO.
  99. *Released
  100. 95/05/10 rpao V0.08
  101. Bug fix: Make all non-exported functions private by using
  102. static keyword.
  103. Bug fix: Test IntrCnt _before_ reading MACE_IR.
  104. 95/05/10 rpao V0.07 Statistics.
  105. 95/05/09 rpao V0.06 Fix rx_framecnt problem by addition of PCIC wait states.
  107. ---------------------------------------------------------------------------- */
  109. #define DRV_NAME "nmclan_cs"
  110. #define DRV_VERSION "0.16"
  113. /* ----------------------------------------------------------------------------
  114. Conditional Compilation Options
  115. ---------------------------------------------------------------------------- */
  117. #define MULTI_TX 0
  118. #define RESET_ON_TIMEOUT 1
  119. #define TX_INTERRUPTABLE 1
  120. #define RESET_XILINX 0
  122. /* ----------------------------------------------------------------------------
  123. Include Files
  124. ---------------------------------------------------------------------------- */
  126. #include <linux/module.h>
  127. #include <linux/kernel.h>
  128. #include <linux/init.h>
  129. #include <linux/sched.h>
  130. #include <linux/ptrace.h>
  131. #include <linux/slab.h>
  132. #include <linux/string.h>
  133. #include <linux/timer.h>
  134. #include <linux/interrupt.h>
  135. #include <linux/in.h>
  136. #include <linux/delay.h>
  137. #include <linux/ethtool.h>
  139. #include <asm/uaccess.h>
  140. #include <asm/io.h>
  141. #include <asm/system.h>
  142. #include <asm/bitops.h>
  144. #include <linux/netdevice.h>
  145. #include <linux/etherdevice.h>
  146. #include <linux/skbuff.h>
  147. #include <linux/if_arp.h>
  148. #include <linux/ioport.h>
  150. #include <pcmcia/version.h>
  151. #include <pcmcia/cs_types.h>
  152. #include <pcmcia/cs.h>
  153. #include <pcmcia/cisreg.h>
  154. #include <pcmcia/cistpl.h>
  155. #include <pcmcia/ds.h>
  157. /* ----------------------------------------------------------------------------
  158. Defines
  159. ---------------------------------------------------------------------------- */
  161. #define ETHER_ADDR_LEN ETH_ALEN
  162. /* 6 bytes in an Ethernet Address */
  163. #define MACE_LADRF_LEN 8
  164. /* 8 bytes in Logical Address Filter */
  166. /* Loop Control Defines */
  167. #define MACE_MAX_IR_ITERATIONS 10
  168. #define MACE_MAX_RX_ITERATIONS 12
  169. /*
  170. TBD: Dean brought this up, and I assumed the hardware would
  171. handle it:
  173. If MACE_MAX_RX_ITERATIONS is > 1, rx_framecnt may still be
  174. non-zero when the isr exits.  We may not get another interrupt
  175. to process the remaining packets for some time.
  176. */
  178. /*
  179. The Am2150 has a Xilinx XC3042 field programmable gate array (FPGA)
  180. which manages the interface between the MACE and the PCMCIA bus.  It
  181. also includes buffer management for the 32K x 8 SRAM to control up to
  182. four transmit and 12 receive frames at a time.
  183. */
  184. #define AM2150_MAX_TX_FRAMES 4
  185. #define AM2150_MAX_RX_FRAMES 12
  187. /* Am2150 Ethernet Card I/O Mapping */
  188. #define AM2150_RCV 0x00
  189. #define AM2150_XMT 0x04
  190. #define AM2150_XMT_SKIP 0x09
  191. #define AM2150_RCV_NEXT 0x0A
  192. #define AM2150_RCV_FRAME_COUNT 0x0B
  193. #define AM2150_MACE_BANK 0x0C
  194. #define AM2150_MACE_BASE 0x10
  196. /* MACE Registers */
  197. #define MACE_RCVFIFO 0
  198. #define MACE_XMTFIFO 1
  199. #define MACE_XMTFC 2
  200. #define MACE_XMTFS 3
  201. #define MACE_XMTRC 4
  202. #define MACE_RCVFC 5
  203. #define MACE_RCVFS 6
  204. #define MACE_FIFOFC 7
  205. #define MACE_IR 8
  206. #define MACE_IMR 9
  207. #define MACE_PR 10
  208. #define MACE_BIUCC 11
  209. #define MACE_FIFOCC 12
  210. #define MACE_MACCC 13
  211. #define MACE_PLSCC 14
  212. #define MACE_PHYCC 15
  213. #define MACE_CHIPIDL 16
  214. #define MACE_CHIPIDH 17
  215. #define MACE_IAC 18
  216. /* Reserved */
  217. #define MACE_LADRF 20
  218. #define MACE_PADR 21
  219. /* Reserved */
  220. /* Reserved */
  221. #define MACE_MPC 24
  222. /* Reserved */
  223. #define MACE_RNTPC 26
  224. #define MACE_RCVCC 27
  225. /* Reserved */
  226. #define MACE_UTR 29
  227. #define MACE_RTR1 30
  228. #define MACE_RTR2 31
  230. /* MACE Bit Masks */
  231. #define MACE_XMTRC_EXDEF 0x80
  232. #define MACE_XMTRC_XMTRC 0x0F
  234. #define MACE_XMTFS_XMTSV 0x80
  235. #define MACE_XMTFS_UFLO 0x40
  236. #define MACE_XMTFS_LCOL 0x20
  237. #define MACE_XMTFS_MORE 0x10
  238. #define MACE_XMTFS_ONE 0x08
  239. #define MACE_XMTFS_DEFER 0x04
  240. #define MACE_XMTFS_LCAR 0x02
  241. #define MACE_XMTFS_RTRY 0x01
  243. #define MACE_RCVFS_RCVSTS 0xF000
  244. #define MACE_RCVFS_OFLO 0x8000
  245. #define MACE_RCVFS_CLSN 0x4000
  246. #define MACE_RCVFS_FRAM 0x2000
  247. #define MACE_RCVFS_FCS 0x1000
  249. #define MACE_FIFOFC_RCVFC 0xF0
  250. #define MACE_FIFOFC_XMTFC 0x0F
  252. #define MACE_IR_JAB 0x80
  253. #define MACE_IR_BABL 0x40
  254. #define MACE_IR_CERR 0x20
  255. #define MACE_IR_RCVCCO 0x10
  256. #define MACE_IR_RNTPCO 0x08
  257. #define MACE_IR_MPCO 0x04
  258. #define MACE_IR_RCVINT 0x02
  259. #define MACE_IR_XMTINT 0x01
  261. #define MACE_MACCC_PROM 0x80
  262. #define MACE_MACCC_DXMT2PD 0x40
  263. #define MACE_MACCC_EMBA 0x20
  264. #define MACE_MACCC_RESERVED 0x10
  265. #define MACE_MACCC_DRCVPA 0x08
  266. #define MACE_MACCC_DRCVBC 0x04
  267. #define MACE_MACCC_ENXMT 0x02
  268. #define MACE_MACCC_ENRCV 0x01
  270. #define MACE_PHYCC_LNKFL 0x80
  271. #define MACE_PHYCC_DLNKTST 0x40
  272. #define MACE_PHYCC_REVPOL 0x20
  273. #define MACE_PHYCC_DAPC 0x10
  274. #define MACE_PHYCC_LRT 0x08
  275. #define MACE_PHYCC_ASEL 0x04
  276. #define MACE_PHYCC_RWAKE 0x02
  277. #define MACE_PHYCC_AWAKE 0x01
  279. #define MACE_IAC_ADDRCHG 0x80
  280. #define MACE_IAC_PHYADDR 0x04
  281. #define MACE_IAC_LOGADDR 0x02
  283. #define MACE_UTR_RTRE 0x80
  284. #define MACE_UTR_RTRD 0x40
  285. #define MACE_UTR_RPA 0x20
  286. #define MACE_UTR_FCOLL 0x10
  287. #define MACE_UTR_RCVFCSE 0x08
  288. #define MACE_UTR_LOOP_INCL_MENDEC 0x06
  289. #define MACE_UTR_LOOP_NO_MENDEC 0x04
  290. #define MACE_UTR_LOOP_EXTERNAL 0x02
  291. #define MACE_UTR_LOOP_NONE 0x00
  292. #define MACE_UTR_RESERVED 0x01
  294. /* Switch MACE register bank (only 0 and 1 are valid) */
  295. #define MACEBANK(win_num) outb((win_num), ioaddr + AM2150_MACE_BANK)
  297. #define MACE_IMR_DEFAULT 
  298.   (0xFF - 
  299.     ( 
  300.       MACE_IR_CERR | 
  301.       MACE_IR_RCVCCO | 
  302.       MACE_IR_RNTPCO | 
  303.       MACE_IR_MPCO | 
  304.       MACE_IR_RCVINT | 
  305.       MACE_IR_XMTINT 
  306.     ) 
  307.   )
  308. #undef MACE_IMR_DEFAULT
  309. #define MACE_IMR_DEFAULT 0x00 /* New statistics handling: grab everything */
  311. #define TX_TIMEOUT ((400*HZ)/1000)
  313. /* ----------------------------------------------------------------------------
  314. Type Definitions
  315. ---------------------------------------------------------------------------- */
  317. typedef struct _mace_statistics {
  318.     /* MACE_XMTFS */
  319.     int xmtsv;
  320.     int uflo;
  321.     int lcol;
  322.     int more;
  323.     int one;
  324.     int defer;
  325.     int lcar;
  326.     int rtry;
  328.     /* MACE_XMTRC */
  329.     int exdef;
  330.     int xmtrc;
  332.     /* RFS1--Receive Status (RCVSTS) */
  333.     int oflo;
  334.     int clsn;
  335.     int fram;
  336.     int fcs;
  338.     /* RFS2--Runt Packet Count (RNTPC) */
  339.     int rfs_rntpc;
  341.     /* RFS3--Receive Collision Count (RCVCC) */
  342.     int rfs_rcvcc;
  344.     /* MACE_IR */
  345.     int jab;
  346.     int babl;
  347.     int cerr;
  348.     int rcvcco;
  349.     int rntpco;
  350.     int mpco;
  352.     /* MACE_MPC */
  353.     int mpc;
  355.     /* MACE_RNTPC */
  356.     int rntpc;
  358.     /* MACE_RCVCC */
  359.     int rcvcc;
  360. } mace_statistics;
  362. typedef struct _mace_private {
  363.     dev_link_t link;
  364.     struct net_device dev;
  365.     dev_node_t node;
  366.     struct net_device_stats linux_stats; /* Linux statistics counters */
  367.     mace_statistics mace_stats; /* MACE chip statistics counters */
  369.     /* restore_multicast_list() state variables */
  370.     int multicast_ladrf[MACE_LADRF_LEN]; /* Logical address filter */
  371.     int multicast_num_addrs;
  373.     char tx_free_frames; /* Number of free transmit frame buffers */
  374.     char tx_irq_disabled; /* MACE TX interrupt disabled */
  375. } mace_private;
  377. /* ----------------------------------------------------------------------------
  378. Private Global Variables
  379. ---------------------------------------------------------------------------- */
  381. #ifdef PCMCIA_DEBUG
  382. static char rcsid[] =
  383. "nmclan_cs.c,v 0.16 1995/07/01 06:42:17 rpao Exp rpao";
  384. static char *version =
  385. DRV_NAME " " DRV_VERSION " (Roger C. Pao)";
  386. #endif
  388. static dev_info_t dev_info="nmclan_cs";
  389. static dev_link_t *dev_list;
  391. static char *if_names[]={
  392.     "Auto", "10baseT", "BNC",
  393. };
  395. /* ----------------------------------------------------------------------------
  396. Parameters
  397. These are the parameters that can be set during loading with
  398. 'insmod'.
  399. ---------------------------------------------------------------------------- */
  401. MODULE_DESCRIPTION("New Media PCMCIA ethernet driver");
  402. MODULE_LICENSE("GPL");
  404. #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
  406. static int irq_list[4] = { -1 };
  407. MODULE_PARM(irq_list, "1-4i");
  409. /* 0=auto, 1=10baseT, 2 = 10base2, default=auto */
  410. INT_MODULE_PARM(if_port, 0);
  411. /* Bit map of interrupts to choose from */
  412. INT_MODULE_PARM(irq_mask, 0xdeb8);
  414. #ifdef PCMCIA_DEBUG
  415. INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  416. #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  417. #else
  418. #define DEBUG(n, args...)
  419. #endif
  421. /* ----------------------------------------------------------------------------
  422. Function Prototypes
  423. ---------------------------------------------------------------------------- */
  425. static void nmclan_config(dev_link_t *link);
  426. static void nmclan_release(u_long arg);
  427. static int nmclan_event(event_t event, int priority,
  428. event_callback_args_t *args);
  430. static void nmclan_reset(struct net_device *dev);
  431. static int mace_config(struct net_device *dev, struct ifmap *map);
  432. static int mace_open(struct net_device *dev);
  433. static int mace_close(struct net_device *dev);
  434. static int mace_start_xmit(struct sk_buff *skb, struct net_device *dev);
  435. static void mace_tx_timeout(struct net_device *dev);
  436. static void mace_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  437. static struct net_device_stats *mace_get_stats(struct net_device *dev);
  438. static int mace_rx(struct net_device *dev, unsigned char RxCnt);
  439. static void restore_multicast_list(struct net_device *dev);
  441. static void set_multicast_list(struct net_device *dev);
  443. static dev_link_t *nmclan_attach(void);
  444. static void nmclan_detach(dev_link_t *);
  446. /* ----------------------------------------------------------------------------
  447. flush_stale_links
  448. Clean up stale device structures
  449. ---------------------------------------------------------------------------- */
  451. static void flush_stale_links(void)
  452. {
  453.     dev_link_t *link, *next;
  454.     for (link = dev_list; link; link = next) {
  455. next = link->next;
  456. if (link->state & DEV_STALE_LINK)
  457.     nmclan_detach(link);
  458.     }
  459. }
  461. /* ----------------------------------------------------------------------------
  462. cs_error
  463. Report a Card Services related error.
  464. ---------------------------------------------------------------------------- */
  466. static void cs_error(client_handle_t handle, int func, int ret)
  467. {
  468.     error_info_t err = { func, ret };
  469.     CardServices(ReportError, handle, &err);
  470. }
  472. /* ----------------------------------------------------------------------------
  473. nmclan_attach
  474. Creates an "instance" of the driver, allocating local data
  475. structures for one device.  The device is registered with Card
  476. Services.
  477. ---------------------------------------------------------------------------- */
  479. static dev_link_t *nmclan_attach(void)
  480. {
  481.     mace_private *lp;
  482.     dev_link_t *link;
  483.     struct net_device *dev;
  484.     client_reg_t client_reg;
  485.     int i, ret;
  487.     DEBUG(0, "nmclan_attach()n");
  488.     DEBUG(1, "%sn", rcsid);
  489.     flush_stale_links();
  491.     /* Create new ethernet device */
  492.     lp = kmalloc(sizeof(*lp), GFP_KERNEL);
  493.     if (!lp) return NULL;
  494.     memset(lp, 0, sizeof(*lp));
  495.     link = &lp->link; dev = &lp->dev;
  496.     link->priv = dev->priv = link->irq.Instance = lp;
  498.     link->release.function = &nmclan_release;
  499.     link->release.data = (u_long)link;
  500.     link->io.NumPorts1 = 32;
  501.     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
  502.     link->io.IOAddrLines = 5;
  503.     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
  504.     link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
  505.     if (irq_list[0] == -1)
  506. link->irq.IRQInfo2 = irq_mask;
  507.     else
  508. for (i = 0; i < 4; i++)
  509.     link->irq.IRQInfo2 |= 1 << irq_list[i];
  510.     link->irq.Handler = &mace_interrupt;
  511.     link->conf.Attributes = CONF_ENABLE_IRQ;
  512.     link->conf.Vcc = 50;
  513.     link->conf.IntType = INT_MEMORY_AND_IO;
  514.     link->conf.ConfigIndex = 1;
  515.     link->conf.Present = PRESENT_OPTION;
  517.     lp->tx_free_frames=AM2150_MAX_TX_FRAMES;
  519.     dev->hard_start_xmit = &mace_start_xmit;
  520.     dev->set_config = &mace_config;
  521.     dev->get_stats = &mace_get_stats;
  522.     dev->set_multicast_list = &set_multicast_list;
  523.     ether_setup(dev);
  524.     dev->open = &mace_open;
  525.     dev->stop = &mace_close;
  526. #ifdef HAVE_TX_TIMEOUT
  527.     dev->tx_timeout = mace_tx_timeout;
  528.     dev->watchdog_timeo = TX_TIMEOUT;
  529. #endif
  531.     /* Register with Card Services */
  532.     link->next = dev_list;
  533.     dev_list = link;
  534.     client_reg.dev_info = &dev_info;
  535.     client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
  536.     client_reg.EventMask =
  537. CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
  538. CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
  539. CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
  540.     client_reg.event_handler = &nmclan_event;
  541.     client_reg.Version = 0x0210;
  542.     client_reg.event_callback_args.client_data = link;
  543.     ret = CardServices(RegisterClient, &link->handle, &client_reg);
  544.     if (ret != 0) {
  545. cs_error(link->handle, RegisterClient, ret);
  546. nmclan_detach(link);
  547. return NULL;
  548.     }
  550.     return link;
  551. } /* nmclan_attach */
  553. /* ----------------------------------------------------------------------------
  554. nmclan_detach
  555. This deletes a driver "instance".  The device is de-registered
  556. with Card Services.  If it has been released, all local data
  557. structures are freed.  Otherwise, the structures will be freed
  558. when the device is released.
  559. ---------------------------------------------------------------------------- */
  561. static void nmclan_detach(dev_link_t *link)
  562. {
  563.     mace_private *lp = link->priv;
  564.     dev_link_t **linkp;
  566.     DEBUG(0, "nmclan_detach(0x%p)n", link);
  568.     /* Locate device structure */
  569.     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
  570. if (*linkp == link) break;
  571.     if (*linkp == NULL)
  572. return;
  574.     del_timer(&link->release);
  575.     if (link->state & DEV_CONFIG) {
  576. nmclan_release((u_long)link);
  577. if (link->state & DEV_STALE_CONFIG) {
  578.     link->state |= DEV_STALE_LINK;
  579.     return;
  580. }
  581.     }
  583.     if (link->handle)
  584. CardServices(DeregisterClient, link->handle);
  586.     /* Unlink device structure, free bits */
  587.     *linkp = link->next;
  588.     if (link->dev)
  589. unregister_netdev(&lp->dev);
  590.     kfree(lp);
  592. } /* nmclan_detach */
  594. /* ----------------------------------------------------------------------------
  595. mace_read
  596. Reads a MACE register.  This is bank independent; however, the
  597. caller must ensure that this call is not interruptable.  We are
  598. assuming that during normal operation, the MACE is always in
  599. bank 0.
  600. ---------------------------------------------------------------------------- */
  601. static int mace_read(ioaddr_t ioaddr, int reg)
  602. {
  603.   int data = 0xFF;
  604.   unsigned long flags;
  606.   switch (reg >> 4) {
  607.     case 0: /* register 0-15 */
  608.       data = inb(ioaddr + AM2150_MACE_BASE + reg);
  609.       break;
  610.     case 1: /* register 16-31 */
  611.       save_flags(flags);
  612.       cli();
  613.       MACEBANK(1);
  614.       data = inb(ioaddr + AM2150_MACE_BASE + (reg & 0x0F));
  615.       MACEBANK(0);
  616.       restore_flags(flags);
  617.       break;
  618.   }
  619.   return (data & 0xFF);
  620. } /* mace_read */
  622. /* ----------------------------------------------------------------------------
  623. mace_write
  624. Writes to a MACE register.  This is bank independent; however,
  625. the caller must ensure that this call is not interruptable.  We
  626. are assuming that during normal operation, the MACE is always in
  627. bank 0.
  628. ---------------------------------------------------------------------------- */
  629. static void mace_write(ioaddr_t ioaddr, int reg, int data)
  630. {
  631.   unsigned long flags;
  633.   switch (reg >> 4) {
  634.     case 0: /* register 0-15 */
  635.       outb(data & 0xFF, ioaddr + AM2150_MACE_BASE + reg);
  636.       break;
  637.     case 1: /* register 16-31 */
  638.       save_flags(flags);
  639.       cli();
  640.       MACEBANK(1);
  641.       outb(data & 0xFF, ioaddr + AM2150_MACE_BASE + (reg & 0x0F));
  642.       MACEBANK(0);
  643.       restore_flags(flags);
  644.       break;
  645.   }
  646. } /* mace_write */
  648. /* ----------------------------------------------------------------------------
  649. mace_init
  650. Resets the MACE chip.
  651. ---------------------------------------------------------------------------- */
  652. static void mace_init(ioaddr_t ioaddr, char *enet_addr)
  653. {
  654.   int i;
  656.   /* MACE Software reset */
  657.   mace_write(ioaddr, MACE_BIUCC, 1);
  658.   while (mace_read(ioaddr, MACE_BIUCC) & 0x01) {
  659.     /* Wait for reset bit to be cleared automatically after <= 200ns */;
  660.   }
  661.   mace_write(ioaddr, MACE_BIUCC, 0);
  663.   /* The Am2150 requires that the MACE FIFOs operate in burst mode. */
  664.   mace_write(ioaddr, MACE_FIFOCC, 0x0F);
  666.   mace_write(ioaddr, MACE_RCVFC, 0); /* Disable Auto Strip Receive */
  667.   mace_write(ioaddr, MACE_IMR, 0xFF); /* Disable all interrupts until _open */
  669.   /*
  670.    * Bit 2-1 PORTSEL[1-0] Port Select.
  671.    * 00 AUI/10Base-2
  672.    * 01 10Base-T
  673.    * 10 DAI Port (reserved in Am2150)
  674.    * 11 GPSI
  675.    * For this card, only the first two are valid.
  676.    * So, PLSCC should be set to
  677.    * 0x00 for 10Base-2
  678.    * 0x02 for 10Base-T
  679.    * Or just set ASEL in PHYCC below!
  680.    */
  681.   switch (if_port) {
  682.     case 1:
  683.       mace_write(ioaddr, MACE_PLSCC, 0x02);
  684.       break;
  685.     case 2:
  686.       mace_write(ioaddr, MACE_PLSCC, 0x00);
  687.       break;
  688.     default:
  689.       mace_write(ioaddr, MACE_PHYCC, /* ASEL */ 4);
  690.       /* ASEL Auto Select.  When set, the PORTSEL[1-0] bits are overridden,
  691.  and the MACE device will automatically select the operating media
  692.  interface port. */
  693.       break;
  694.   }
  696.   mace_write(ioaddr, MACE_IAC, MACE_IAC_ADDRCHG | MACE_IAC_PHYADDR);
  697.   /* Poll ADDRCHG bit */
  698.   while (mace_read(ioaddr, MACE_IAC) & MACE_IAC_ADDRCHG)
  699.     ;
  700.   /* Set PADR register */
  701.   for (i = 0; i < ETHER_ADDR_LEN; i++)
  702.     mace_write(ioaddr, MACE_PADR, enet_addr[i]);
  704.   /* MAC Configuration Control Register should be written last */
  705.   /* Let set_multicast_list set this. */
  706.   /* mace_write(ioaddr, MACE_MACCC, MACE_MACCC_ENXMT | MACE_MACCC_ENRCV); */
  707.   mace_write(ioaddr, MACE_MACCC, 0x00);
  708. } /* mace_init */
  710. /* ----------------------------------------------------------------------------
  711. nmclan_config
  712. This routine is scheduled to run after a CARD_INSERTION event
  713. is received, to configure the PCMCIA socket, and to make the
  714. ethernet device available to the system.
  715. ---------------------------------------------------------------------------- */
  717. #define CS_CHECK(fn, args...) 
  718. while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed
  720. static void nmclan_config(dev_link_t *link)
  721. {
  722.   client_handle_t handle = link->handle;
  723.   mace_private *lp = link->priv;
  724.   struct net_device *dev = &lp->dev;
  725.   tuple_t tuple;
  726.   cisparse_t parse;
  727.   u_char buf[64];
  728.   int i, last_ret, last_fn;
  729.   ioaddr_t ioaddr;
  731.   DEBUG(0, "nmclan_config(0x%p)n", link);
  733.   tuple.Attributes = 0;
  734.   tuple.TupleData = buf;
  735.   tuple.TupleDataMax = 64;
  736.   tuple.TupleOffset = 0;
  737.   tuple.DesiredTuple = CISTPL_CONFIG;
  738.   CS_CHECK(GetFirstTuple, handle, &tuple);
  739.   CS_CHECK(GetTupleData, handle, &tuple);
  740.   CS_CHECK(ParseTuple, handle, &tuple, &parse);
  741.   link->conf.ConfigBase = parse.config.base;
  743.   /* Configure card */
  744.   link->state |= DEV_CONFIG;
  746.   CS_CHECK(RequestIO, handle, &link->io);
  747.   CS_CHECK(RequestIRQ, handle, &link->irq);
  748.   CS_CHECK(RequestConfiguration, handle, &link->conf);
  749.   dev->irq = link->irq.AssignedIRQ;
  750.   dev->base_addr = link->io.BasePort1;
  751.   i = register_netdev(dev);
  752.   if (i != 0) {
  753.     printk(KERN_NOTICE "nmclan_cs: register_netdev() failedn");
  754.     goto failed;
  755.   }
  757.   ioaddr = dev->base_addr;
  759.   /* Read the ethernet address from the CIS. */
  760.   tuple.DesiredTuple = 0x80 /* CISTPL_CFTABLE_ENTRY_MISC */;
  761.   tuple.TupleData = buf;
  762.   tuple.TupleDataMax = 64;
  763.   tuple.TupleOffset = 0;
  764.   CS_CHECK(GetFirstTuple, handle, &tuple);
  765.   CS_CHECK(GetTupleData, handle, &tuple);
  766.   memcpy(dev->dev_addr, tuple.TupleData, ETHER_ADDR_LEN);
  768.   /* Verify configuration by reading the MACE ID. */
  769.   {
  770.     char sig[2];
  772.     sig[0] = mace_read(ioaddr, MACE_CHIPIDL);
  773.     sig[1] = mace_read(ioaddr, MACE_CHIPIDH);
  774.     if ((sig[0] == 0x40) && ((sig[1] & 0x0F) == 0x09)) {
  775.       DEBUG(0, "nmclan_cs configured: mace id=%x %xn",
  776.     sig[0], sig[1]);
  777.     } else {
  778.       printk(KERN_NOTICE "nmclan_cs: mace id not found: %x %x should"
  779.      " be 0x40 0x?9n", sig[0], sig[1]);
  780.       link->state &= ~DEV_CONFIG_PENDING;
  781.       return;
  782.     }
  783.   }
  785.   mace_init(ioaddr, dev->dev_addr);
  787.   /* The if_port symbol can be set when the module is loaded */
  788.   if (if_port <= 2)
  789.     dev->if_port = if_port;
  790.   else
  791.     printk(KERN_NOTICE "nmclan_cs: invalid if_port requestedn");
  793.   strcpy(lp->node.dev_name, dev->name);
  794.   link->dev = &lp->node;
  795.   link->state &= ~DEV_CONFIG_PENDING;
  797.   printk(KERN_INFO "%s: nmclan: port %#3lx, irq %d, %s port, hw_addr ",
  798.  dev->name, dev->base_addr, dev->irq, if_names[dev->if_port]);
  799.   for (i = 0; i < 6; i++)
  800.       printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "n"));
  801.   return;
  803. cs_failed:
  804.     cs_error(link->handle, last_fn, last_ret);
  805. failed:
  806.     nmclan_release((u_long)link);
  807.     return;
  809. } /* nmclan_config */
  811. /* ----------------------------------------------------------------------------
  812. nmclan_release
  813. After a card is removed, nmclan_release() will unregister the
  814. net device, and release the PCMCIA configuration.  If the device
  815. is still open, this will be postponed until it is closed.
  816. ---------------------------------------------------------------------------- */
  817. static void nmclan_release(u_long arg)
  818. {
  819.   dev_link_t *link = (dev_link_t *)arg;
  821.   DEBUG(0, "nmclan_release(0x%p)n", link);
  823.   if (link->open) {
  824.     DEBUG(1, "nmclan_cs: release postponed, '%s' "
  825.   "still openn", link->dev->dev_name);
  826.     link->state |= DEV_STALE_CONFIG;
  827.     return;
  828.   }
  830.   CardServices(ReleaseConfiguration, link->handle);
  831.   CardServices(ReleaseIO, link->handle, &link->io);
  832.   CardServices(ReleaseIRQ, link->handle, &link->irq);
  834.   link->state &= ~DEV_CONFIG;
  836. } /* nmclan_release */
  838. /* ----------------------------------------------------------------------------
  839. nmclan_event
  840. The card status event handler.  Mostly, this schedules other
  841. stuff to run after an event is received.  A CARD_REMOVAL event
  842. also sets some flags to discourage the net drivers from trying
  843. to talk to the card any more.
  844. ---------------------------------------------------------------------------- */
  845. static int nmclan_event(event_t event, int priority,
  846.        event_callback_args_t *args)
  847. {
  848.   dev_link_t *link = args->client_data;
  849.   mace_private *lp = link->priv;
  850.   struct net_device *dev = &lp->dev;
  852.   DEBUG(1, "nmclan_event(0x%06x)n", event);
  854.   switch (event) {
  855.     case CS_EVENT_CARD_REMOVAL:
  856.       link->state &= ~DEV_PRESENT;
  857.       if (link->state & DEV_CONFIG) {
  858. netif_device_detach(dev);
  859. mod_timer(&link->release, jiffies + HZ/20);
  860.       }
  861.       break;
  862.     case CS_EVENT_CARD_INSERTION:
  863.       link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
  864.       nmclan_config(link);
  865.       break;
  866.     case CS_EVENT_PM_SUSPEND:
  867.       link->state |= DEV_SUSPEND;
  868.       /* Fall through... */
  869.     case CS_EVENT_RESET_PHYSICAL:
  870.       if (link->state & DEV_CONFIG) {
  871. if (link->open)
  872.   netif_device_detach(dev);
  873. CardServices(ReleaseConfiguration, link->handle);
  874.       }
  875.       break;
  876.     case CS_EVENT_PM_RESUME:
  877.       link->state &= ~DEV_SUSPEND;
  878.       /* Fall through... */
  879.     case CS_EVENT_CARD_RESET:
  880.       if (link->state & DEV_CONFIG) {
  881. CardServices(RequestConfiguration, link->handle, &link->conf);
  882. if (link->open) {
  883.   nmclan_reset(dev);
  884.   netif_device_attach(dev);
  885. }
  886.       }
  887.       break;
  888.     case CS_EVENT_RESET_REQUEST:
  889.       return 1;
  890.       break;
  891.   }
  892.   return 0;
  893. } /* nmclan_event */
  895. /* ----------------------------------------------------------------------------
  896. nmclan_reset
  897. Reset and restore all of the Xilinx and MACE registers.
  898. ---------------------------------------------------------------------------- */
  899. static void nmclan_reset(struct net_device *dev)
  900. {
  901.   mace_private *lp = dev->priv;
  903. #if RESET_XILINX
  904.   dev_link_t *link = &lp->link;
  905.   conf_reg_t reg;
  906.   u_long OrigCorValue; 
  908.   /* Save original COR value */
  909.   reg.Function = 0;
  910.   reg.Action = CS_READ;
  911.   reg.Offset = CISREG_COR;
  912.   reg.Value = 0;
  913.   CardServices(AccessConfigurationRegister, link->handle, &reg);
  914.   OrigCorValue = reg.Value;
  916.   /* Reset Xilinx */
  917.   reg.Action = CS_WRITE;
  918.   reg.Offset = CISREG_COR;
  919.   DEBUG(1, "nmclan_reset: OrigCorValue=0x%lX, resetting...n",
  920. OrigCorValue);
  921.   reg.Value = COR_SOFT_RESET;
  922.   CardServices(AccessConfigurationRegister, link->handle, &reg);
  923.   /* Need to wait for 20 ms for PCMCIA to finish reset. */
  925.   /* Restore original COR configuration index */
  926.   reg.Value = COR_LEVEL_REQ | (OrigCorValue & COR_CONFIG_MASK);
  927.   CardServices(AccessConfigurationRegister, link->handle, &reg);
  928.   /* Xilinx is now completely reset along with the MACE chip. */
  929.   lp->tx_free_frames=AM2150_MAX_TX_FRAMES;
  931. #endif /* #if RESET_XILINX */
  933.   /* Xilinx is now completely reset along with the MACE chip. */
  934.   lp->tx_free_frames=AM2150_MAX_TX_FRAMES;
  936.   /* Reinitialize the MACE chip for operation. */
  937.   mace_init(dev->base_addr, dev->dev_addr);
  938.   mace_write(dev->base_addr, MACE_IMR, MACE_IMR_DEFAULT);
  940.   /* Restore the multicast list and enable TX and RX. */
  941.   restore_multicast_list(dev);
  942. } /* nmclan_reset */
  944. /* ----------------------------------------------------------------------------
  945. mace_config
  946. [Someone tell me what this is supposed to do?  Is if_port a defined
  947. standard?  If so, there should be defines to indicate 1=10Base-T,
  948. 2=10Base-2, etc. including limited automatic detection.]
  949. ---------------------------------------------------------------------------- */
  950. static int mace_config(struct net_device *dev, struct ifmap *map)
  951. {
  952.   if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
  953.     if (map->port <= 2) {
  954.       dev->if_port = map->port;
  955.       printk(KERN_INFO "%s: switched to %s portn", dev->name,
  956.      if_names[dev->if_port]);
  957.     } else
  958.       return -EINVAL;
  959.   }
  960.   return 0;
  961. } /* mace_config */
  963. /* ----------------------------------------------------------------------------
  964. mace_open
  965. Open device driver.
  966. ---------------------------------------------------------------------------- */
  967. static int mace_open(struct net_device *dev)
  968. {
  969.   ioaddr_t ioaddr = dev->base_addr;
  970.   mace_private *lp = dev->priv;
  971.   dev_link_t *link = &lp->link;
  973.   if (!DEV_OK(link))
  974.     return -ENODEV;
  976.   link->open++;
  977.   MOD_INC_USE_COUNT;
  979.   MACEBANK(0);
  981.   netif_start_queue(dev);
  982.   nmclan_reset(dev);
  984.   return 0; /* Always succeed */
  985. } /* mace_open */
  987. /* ----------------------------------------------------------------------------
  988. mace_close
  989. Closes device driver.
  990. ---------------------------------------------------------------------------- */
  991. static int mace_close(struct net_device *dev)
  992. {
  993.   ioaddr_t ioaddr = dev->base_addr;
  994.   mace_private *lp = dev->priv;
  995.   dev_link_t *link = &lp->link;
  997.   DEBUG(2, "%s: shutting down ethercard.n", dev->name);
  999.   /* Mask off all interrupts from the MACE chip. */
  1000.   outb(0xFF, ioaddr + AM2150_MACE_BASE + MACE_IMR);
  1002.   link->open--;
  1003.   netif_stop_queue(dev);
  1004.   if (link->state & DEV_STALE_CONFIG)
  1005.     mod_timer(&link->release, jiffies + HZ/20);
  1007.   MOD_DEC_USE_COUNT;
  1009.   return 0;
  1010. } /* mace_close */
  1012. static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1013. {
  1014. u32 ethcmd;
  1016. /* dev_ioctl() in ../../net/core/dev.c has already checked
  1017.    capable(CAP_NET_ADMIN), so don't bother with that here.  */
  1019. if (get_user(ethcmd, (u32 *)useraddr))
  1020. return -EFAULT;
  1022. switch (ethcmd) {
  1024. case ETHTOOL_GDRVINFO: {
  1025. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1026. strcpy (info.driver, DRV_NAME);
  1027. strcpy (info.version, DRV_VERSION);
  1028. sprintf(info.bus_info, "PCMCIA 0x%lx", dev->base_addr);
  1029. if (copy_to_user (useraddr, &info, sizeof (info)))
  1030. return -EFAULT;
  1031. return 0;
  1032. }
  1034. #ifdef PCMCIA_DEBUG
  1035. /* get message-level */
  1036. case ETHTOOL_GMSGLVL: {
  1037. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1038. edata.data = pc_debug;
  1039. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1040. return -EFAULT;
  1041. return 0;
  1042. }
  1043. /* set message-level */
  1044. case ETHTOOL_SMSGLVL: {
  1045. struct ethtool_value edata;
  1046. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1047. return -EFAULT;
  1048. pc_debug = edata.data;
  1049. return 0;
  1050. }
  1051. #endif
  1053. default:
  1054. break;
  1055. }
  1057. return -EOPNOTSUPP;
  1058. }
  1060. static int smc91c92_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1061. {
  1062. switch (cmd) {
  1063. case SIOCETHTOOL:
  1064. return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1066. default:
  1067. return -EOPNOTSUPP;
  1068. }
  1069. return 0;
  1070. }
  1072. /* ----------------------------------------------------------------------------
  1073. mace_start_xmit
  1074. This routine begins the packet transmit function.  When completed,
  1075. it will generate a transmit interrupt.
  1077. According to /usr/src/linux/net/inet/dev.c, if _start_xmit
  1078. returns 0, the "packet is now solely the responsibility of the
  1079. driver."  If _start_xmit returns non-zero, the "transmission
  1080. failed, put skb back into a list."
  1081. ---------------------------------------------------------------------------- */
  1083. static void mace_tx_timeout(struct net_device *dev)
  1084. {
  1085.   mace_private *lp = (mace_private *)dev->priv;
  1086.   dev_link_t *link = &lp->link;
  1088.   printk(KERN_NOTICE "%s: transmit timed out -- ", dev->name);
  1089. #if RESET_ON_TIMEOUT
  1090.   printk("resetting cardn");
  1091.   CardServices(ResetCard, link->handle);
  1092. #else /* #if RESET_ON_TIMEOUT */
  1093.   printk("NOT resetting cardn");
  1094. #endif /* #if RESET_ON_TIMEOUT */
  1095.   dev->trans_start = jiffies;
  1096.   netif_wake_queue(dev);
  1097. }
  1099. static int mace_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1100. {
  1101.   mace_private *lp = (mace_private *)dev->priv;
  1102.   ioaddr_t ioaddr = dev->base_addr;
  1104.   netif_stop_queue(dev);
  1106.   DEBUG(3, "%s: mace_start_xmit(length = %ld) called.n",
  1107. dev->name, (long)skb->len);
  1109. #if (!TX_INTERRUPTABLE)
  1110.   /* Disable MACE TX interrupts. */
  1111.   outb(MACE_IMR_DEFAULT | MACE_IR_XMTINT,
  1112.     ioaddr + AM2150_MACE_BASE + MACE_IMR);
  1113.   lp->tx_irq_disabled=1;
  1114. #endif /* #if (!TX_INTERRUPTABLE) */
  1116.   {
  1117.     /* This block must not be interrupted by another transmit request!
  1118.        mace_tx_timeout will take care of timer-based retransmissions from
  1119.        the upper layers.  The interrupt handler is guaranteed never to
  1120.        service a transmit interrupt while we are in here.
  1121.     */
  1123.     lp->linux_stats.tx_bytes += skb->len;
  1124.     lp->tx_free_frames--;
  1126.     /* WARNING: Write the _exact_ number of bytes written in the header! */
  1127.     /* Put out the word header [must be an outw()] . . . */
  1128.     outw(skb->len, ioaddr + AM2150_XMT);
  1129.     /* . . . and the packet [may be any combination of outw() and outb()] */
  1130.     outsw(ioaddr + AM2150_XMT, skb->data, skb->len >> 1);
  1131.     if (skb->len & 1) {
  1132.       /* Odd byte transfer */
  1133.       outb(skb->data[skb->len-1], ioaddr + AM2150_XMT);
  1134.     }
  1136.     dev->trans_start = jiffies;
  1138. #if MULTI_TX
  1139.     if (lp->tx_free_frames > 0)
  1140.       netif_start_queue(dev);
  1141. #endif /* #if MULTI_TX */
  1142.   }
  1144. #if (!TX_INTERRUPTABLE)
  1145.   /* Re-enable MACE TX interrupts. */
  1146.   lp->tx_irq_disabled=0;
  1147.   outb(MACE_IMR_DEFAULT, ioaddr + AM2150_MACE_BASE + MACE_IMR);
  1148. #endif /* #if (!TX_INTERRUPTABLE) */
  1150.   dev_kfree_skb(skb);
  1152.   return 0;
  1153. } /* mace_start_xmit */
  1155. /* ----------------------------------------------------------------------------
  1156. mace_interrupt
  1157. The interrupt handler.
  1158. ---------------------------------------------------------------------------- */
  1159. static void mace_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1160. {
  1161.   mace_private *lp = (mace_private *)dev_id;
  1162.   struct net_device *dev = &lp->dev;
  1163.   ioaddr_t ioaddr = dev->base_addr;
  1164.   int status;
  1165.   int IntrCnt = MACE_MAX_IR_ITERATIONS;
  1167.   if (dev == NULL) {
  1168.     DEBUG(2, "mace_interrupt(): irq 0x%X for unknown device.n",
  1169.   irq);
  1170.     return;
  1171.   }
  1173.   if (lp->tx_irq_disabled) {
  1174.     printk(
  1175.       (lp->tx_irq_disabled?
  1176.        KERN_NOTICE "%s: Interrupt with tx_irq_disabled "
  1177.        "[isr=%02X, imr=%02X]n": 
  1178.        KERN_NOTICE "%s: Re-entering the interrupt handler "
  1179.        "[isr=%02X, imr=%02X]n"),
  1180.       dev->name,
  1181.       inb(ioaddr + AM2150_MACE_BASE + MACE_IR),
  1182.       inb(ioaddr + AM2150_MACE_BASE + MACE_IMR)
  1183.     );
  1184.     /* WARNING: MACE_IR has been read! */
  1185.     return;
  1186.   }
  1188.   if (!netif_device_present(dev)) {
  1189.     DEBUG(2, "%s: interrupt from dead cardn", dev->name);
  1190.     goto exception;
  1191.   }
  1193.   do {
  1194.     /* WARNING: MACE_IR is a READ/CLEAR port! */
  1195.     status = inb(ioaddr + AM2150_MACE_BASE + MACE_IR);
  1197.     DEBUG(3, "mace_interrupt: irq 0x%X status 0x%X.n", irq, status);
  1199.     if (status & MACE_IR_RCVINT) {
  1200.       mace_rx(dev, MACE_MAX_RX_ITERATIONS);
  1201.     }
  1203.     if (status & MACE_IR_XMTINT) {
  1204.       unsigned char fifofc;
  1205.       unsigned char xmtrc;
  1206.       unsigned char xmtfs;
  1208.       fifofc = inb(ioaddr + AM2150_MACE_BASE + MACE_FIFOFC);
  1209.       if ((fifofc & MACE_FIFOFC_XMTFC)==0) {
  1210. lp->linux_stats.tx_errors++;
  1211. outb(0xFF, ioaddr + AM2150_XMT_SKIP);
  1212.       }
  1214.       /* Transmit Retry Count (XMTRC, reg 4) */
  1215.       xmtrc = inb(ioaddr + AM2150_MACE_BASE + MACE_XMTRC);
  1216.       if (xmtrc & MACE_XMTRC_EXDEF) lp->mace_stats.exdef++;
  1217.       lp->mace_stats.xmtrc += (xmtrc & MACE_XMTRC_XMTRC);
  1219.       if (
  1220.         (xmtfs = inb(ioaddr + AM2150_MACE_BASE + MACE_XMTFS)) &
  1221.         MACE_XMTFS_XMTSV /* Transmit Status Valid */
  1222.       ) {
  1223. lp->mace_stats.xmtsv++;
  1225. if (xmtfs & ~MACE_XMTFS_XMTSV) {
  1226.   if (xmtfs & MACE_XMTFS_UFLO) {
  1227.     /* Underflow.  Indicates that the Transmit FIFO emptied before
  1228.        the end of frame was reached. */
  1229.     lp->mace_stats.uflo++;
  1230.   }
  1231.   if (xmtfs & MACE_XMTFS_LCOL) {
  1232.     /* Late Collision */
  1233.     lp->mace_stats.lcol++;
  1234.   }
  1235.   if (xmtfs & MACE_XMTFS_MORE) {
  1236.     /* MORE than one retry was needed */
  1237.     lp->mace_stats.more++;
  1238.   }
  1239.   if (xmtfs & MACE_XMTFS_ONE) {
  1240.     /* Exactly ONE retry occurred */
  1241.     lp->mace_stats.one++;
  1242.   }
  1243.   if (xmtfs & MACE_XMTFS_DEFER) {
  1244.     /* Transmission was defered */
  1245.     lp->mace_stats.defer++;
  1246.   }
  1247.   if (xmtfs & MACE_XMTFS_LCAR) {
  1248.     /* Loss of carrier */
  1249.     lp->mace_stats.lcar++;
  1250.   }
  1251.   if (xmtfs & MACE_XMTFS_RTRY) {
  1252.     /* Retry error: transmit aborted after 16 attempts */
  1253.     lp->mace_stats.rtry++;
  1254.   }
  1255.         } /* if (xmtfs & ~MACE_XMTFS_XMTSV) */
  1257.       } /* if (xmtfs & MACE_XMTFS_XMTSV) */
  1259.       lp->linux_stats.tx_packets++;
  1260.       lp->tx_free_frames++;
  1261.       netif_wake_queue(dev);
  1262.     } /* if (status & MACE_IR_XMTINT) */
  1264.     if (status & ~MACE_IMR_DEFAULT & ~MACE_IR_RCVINT & ~MACE_IR_XMTINT) {
  1265.       if (status & MACE_IR_JAB) {
  1266.         /* Jabber Error.  Excessive transmit duration (20-150ms). */
  1267.         lp->mace_stats.jab++;
  1268.       }
  1269.       if (status & MACE_IR_BABL) {
  1270.         /* Babble Error.  >1518 bytes transmitted. */
  1271.         lp->mace_stats.babl++;
  1272.       }
  1273.       if (status & MACE_IR_CERR) {
  1274. /* Collision Error.  CERR indicates the absence of the
  1275.    Signal Quality Error Test message after a packet
  1276.    transmission. */
  1277.         lp->mace_stats.cerr++;
  1278.       }
  1279.       if (status & MACE_IR_RCVCCO) {
  1280.         /* Receive Collision Count Overflow; */
  1281.         lp->mace_stats.rcvcco++;
  1282.       }
  1283.       if (status & MACE_IR_RNTPCO) {
  1284.         /* Runt Packet Count Overflow */
  1285.         lp->mace_stats.rntpco++;
  1286.       }
  1287.       if (status & MACE_IR_MPCO) {
  1288.         /* Missed Packet Count Overflow */
  1289.         lp->mace_stats.mpco++;
  1290.       }
  1291.     } /* if (status & ~MACE_IMR_DEFAULT & ~MACE_IR_RCVINT & ~MACE_IR_XMTINT) */
  1293.   } while ((status & ~MACE_IMR_DEFAULT) && (--IntrCnt));
  1295. exception:
  1296.   return;
  1297. } /* mace_interrupt */
  1299. /* ----------------------------------------------------------------------------
  1300. mace_rx
  1301. Receives packets.
  1302. ---------------------------------------------------------------------------- */
  1303. static int mace_rx(struct net_device *dev, unsigned char RxCnt)
  1304. {
  1305.   mace_private *lp = (mace_private *)dev->priv;
  1306.   ioaddr_t ioaddr = dev->base_addr;
  1307.   unsigned char rx_framecnt;
  1308.   unsigned short rx_status;
  1310.   while (
  1311.     ((rx_framecnt = inb(ioaddr + AM2150_RCV_FRAME_COUNT)) > 0) &&
  1312.     (rx_framecnt <= 12) && /* rx_framecnt==0xFF if card is extracted. */
  1313.     (RxCnt--)
  1314.   ) {
  1315.     rx_status = inw(ioaddr + AM2150_RCV);
  1317.     DEBUG(3, "%s: in mace_rx(), framecnt 0x%X, rx_status"
  1318.   " 0x%X.n", dev->name, rx_framecnt, rx_status);
  1320.     if (rx_status & MACE_RCVFS_RCVSTS) { /* Error, update stats. */
  1321.       lp->linux_stats.rx_errors++;
  1322.       if (rx_status & MACE_RCVFS_OFLO) {
  1323.         lp->mace_stats.oflo++;
  1324.       }
  1325.       if (rx_status & MACE_RCVFS_CLSN) {
  1326.         lp->mace_stats.clsn++;
  1327.       }
  1328.       if (rx_status & MACE_RCVFS_FRAM) {
  1329. lp->mace_stats.fram++;
  1330.       }
  1331.       if (rx_status & MACE_RCVFS_FCS) {
  1332.         lp->mace_stats.fcs++;
  1333.       }
  1334.     } else {
  1335.       short pkt_len = (rx_status & ~MACE_RCVFS_RCVSTS) - 4;
  1336.         /* Auto Strip is off, always subtract 4 */
  1337.       struct sk_buff *skb;
  1339.       lp->mace_stats.rfs_rntpc += inb(ioaddr + AM2150_RCV);
  1340.         /* runt packet count */
  1341.       lp->mace_stats.rfs_rcvcc += inb(ioaddr + AM2150_RCV);
  1342.         /* rcv collision count */
  1344.       DEBUG(3, "    receiving packet size 0x%X rx_status"
  1345.     " 0x%X.n", pkt_len, rx_status);
  1347.       skb = dev_alloc_skb(pkt_len+2);
  1349.       if (skb != NULL) {
  1350. skb->dev = dev;
  1352. skb_reserve(skb, 2);
  1353. insw(ioaddr + AM2150_RCV, skb_put(skb, pkt_len), pkt_len>>1);
  1354. if (pkt_len & 1)
  1355.     *(skb->tail-1) = inb(ioaddr + AM2150_RCV);
  1356. skb->protocol = eth_type_trans(skb, dev);
  1358. netif_rx(skb); /* Send the packet to the upper (protocol) layers. */
  1360. dev->last_rx = jiffies;
  1361. lp->linux_stats.rx_packets++;
  1362. lp->linux_stats.rx_bytes += skb->len;
  1363. outb(0xFF, ioaddr + AM2150_RCV_NEXT); /* skip to next frame */
  1364. continue;
  1365.       } else {
  1366. DEBUG(1, "%s: couldn't allocate a sk_buff of size"
  1367.       " %d.n", dev->name, pkt_len);
  1368. lp->linux_stats.rx_dropped++;
  1369.       }
  1370.     }
  1371.     outb(0xFF, ioaddr + AM2150_RCV_NEXT); /* skip to next frame */
  1372.   } /* while */
  1374.   return 0;
  1375. } /* mace_rx */
  1377. /* ----------------------------------------------------------------------------
  1378. pr_linux_stats
  1379. ---------------------------------------------------------------------------- */
  1380. static void pr_linux_stats(struct net_device_stats *pstats)
  1381. {
  1382.   DEBUG(2, "pr_linux_statsn");
  1383.   DEBUG(2, " rx_packets=%-7ld        tx_packets=%ldn",
  1384. (long)pstats->rx_packets, (long)pstats->tx_packets);
  1385.   DEBUG(2, " rx_errors=%-7ld         tx_errors=%ldn",
  1386. (long)pstats->rx_errors, (long)pstats->tx_errors);
  1387.   DEBUG(2, " rx_dropped=%-7ld        tx_dropped=%ldn",
  1388. (long)pstats->rx_dropped, (long)pstats->tx_dropped);
  1389.   DEBUG(2, " multicast=%-7ld         collisions=%ldn",
  1390. (long)pstats->multicast, (long)pstats->collisions);
  1392.   DEBUG(2, " rx_length_errors=%-7ld  rx_over_errors=%ldn",
  1393. (long)pstats->rx_length_errors, (long)pstats->rx_over_errors);
  1394.   DEBUG(2, " rx_crc_errors=%-7ld     rx_frame_errors=%ldn",
  1395. (long)pstats->rx_crc_errors, (long)pstats->rx_frame_errors);
  1396.   DEBUG(2, " rx_fifo_errors=%-7ld    rx_missed_errors=%ldn",
  1397. (long)pstats->rx_fifo_errors, (long)pstats->rx_missed_errors);
  1399.   DEBUG(2, " tx_aborted_errors=%-7ld tx_carrier_errors=%ldn",
  1400. (long)pstats->tx_aborted_errors, (long)pstats->tx_carrier_errors);
  1401.   DEBUG(2, " tx_fifo_errors=%-7ld    tx_heartbeat_errors=%ldn",
  1402. (long)pstats->tx_fifo_errors, (long)pstats->tx_heartbeat_errors);
  1403.   DEBUG(2, " tx_window_errors=%ldn",
  1404. (long)pstats->tx_window_errors);
  1405. } /* pr_linux_stats */
  1407. /* ----------------------------------------------------------------------------
  1408. pr_mace_stats
  1409. ---------------------------------------------------------------------------- */
  1410. static void pr_mace_stats(mace_statistics *pstats)
  1411. {
  1412.   DEBUG(2, "pr_mace_statsn");
  1414.   DEBUG(2, " xmtsv=%-7d             uflo=%dn",
  1415. pstats->xmtsv, pstats->uflo);
  1416.   DEBUG(2, " lcol=%-7d              more=%dn",
  1417. pstats->lcol, pstats->more);
  1418.   DEBUG(2, " one=%-7d               defer=%dn",
  1419. pstats->one, pstats->defer);
  1420.   DEBUG(2, " lcar=%-7d              rtry=%dn",
  1421. pstats->lcar, pstats->rtry);
  1423.   /* MACE_XMTRC */
  1424.   DEBUG(2, " exdef=%-7d             xmtrc=%dn",
  1425. pstats->exdef, pstats->xmtrc);
  1427.   /* RFS1--Receive Status (RCVSTS) */
  1428.   DEBUG(2, " oflo=%-7d              clsn=%dn",
  1429. pstats->oflo, pstats->clsn);
  1430.   DEBUG(2, " fram=%-7d              fcs=%dn",
  1431. pstats->fram, pstats->fcs);
  1433.   /* RFS2--Runt Packet Count (RNTPC) */
  1434.   /* RFS3--Receive Collision Count (RCVCC) */
  1435.   DEBUG(2, " rfs_rntpc=%-7d         rfs_rcvcc=%dn",
  1436. pstats->rfs_rntpc, pstats->rfs_rcvcc);
  1438.   /* MACE_IR */
  1439.   DEBUG(2, " jab=%-7d               babl=%dn",
  1440. pstats->jab, pstats->babl);
  1441.   DEBUG(2, " cerr=%-7d              rcvcco=%dn",
  1442. pstats->cerr, pstats->rcvcco);
  1443.   DEBUG(2, " rntpco=%-7d            mpco=%dn",
  1444. pstats->rntpco, pstats->mpco);
  1446.   /* MACE_MPC */
  1447.   DEBUG(2, " mpc=%dn", pstats->mpc);
  1449.   /* MACE_RNTPC */
  1450.   DEBUG(2, " rntpc=%dn", pstats->rntpc);
  1452.   /* MACE_RCVCC */
  1453.   DEBUG(2, " rcvcc=%dn", pstats->rcvcc);
  1455. } /* pr_mace_stats */
  1457. /* ----------------------------------------------------------------------------
  1458. update_stats
  1459. Update statistics.  We change to register window 1, so this
  1460. should be run single-threaded if the device is active. This is
  1461. expected to be a rare operation, and it's simpler for the rest
  1462. of the driver to assume that window 0 is always valid rather
  1463. than use a special window-state variable.
  1465. oflo & uflo should _never_ occur since it would mean the Xilinx
  1466. was not able to transfer data between the MACE FIFO and the
  1467. card's SRAM fast enough.  If this happens, something is
  1468. seriously wrong with the hardware.
  1469. ---------------------------------------------------------------------------- */
  1470. static void update_stats(ioaddr_t ioaddr, struct net_device *dev)
  1471. {
  1472.   mace_private *lp = (mace_private *)dev->priv;
  1474.   lp->mace_stats.rcvcc += mace_read(ioaddr, MACE_RCVCC);
  1475.   lp->mace_stats.rntpc += mace_read(ioaddr, MACE_RNTPC);
  1476.   lp->mace_stats.mpc += mace_read(ioaddr, MACE_MPC);
  1477.   /* At this point, mace_stats is fully updated for this call.
  1478.      We may now update the linux_stats. */
  1480.   /* The MACE has no equivalent for linux_stats field which are commented
  1481.      out. */
  1483.   /* lp->linux_stats.multicast; */
  1484.   lp->linux_stats.collisions = 
  1485.     lp->mace_stats.rcvcco * 256 + lp->mace_stats.rcvcc;
  1486.     /* Collision: The MACE may retry sending a packet 15 times
  1487.        before giving up.  The retry count is in XMTRC.
  1488.        Does each retry constitute a collision?
  1489.        If so, why doesn't the RCVCC record these collisions? */
  1491.   /* detailed rx_errors: */
  1492.   lp->linux_stats.rx_length_errors = 
  1493.     lp->mace_stats.rntpco * 256 + lp->mace_stats.rntpc;
  1494.   /* lp->linux_stats.rx_over_errors */
  1495.   lp->linux_stats.rx_crc_errors = lp->mace_stats.fcs;
  1496.   lp->linux_stats.rx_frame_errors = lp->mace_stats.fram;
  1497.   lp->linux_stats.rx_fifo_errors = lp->mace_stats.oflo;
  1498.   lp->linux_stats.rx_missed_errors = 
  1499.     lp->mace_stats.mpco * 256 + lp->mace_stats.mpc;
  1501.   /* detailed tx_errors */
  1502.   lp->linux_stats.tx_aborted_errors = lp->mace_stats.rtry;
  1503.   lp->linux_stats.tx_carrier_errors = lp->mace_stats.lcar;
  1504.     /* LCAR usually results from bad cabling. */
  1505.   lp->linux_stats.tx_fifo_errors = lp->mace_stats.uflo;
  1506.   lp->linux_stats.tx_heartbeat_errors = lp->mace_stats.cerr;
  1507.   /* lp->linux_stats.tx_window_errors; */
  1509.   return;
  1510. } /* update_stats */
  1512. /* ----------------------------------------------------------------------------
  1513. mace_get_stats
  1514. Gathers ethernet statistics from the MACE chip.
  1515. ---------------------------------------------------------------------------- */
  1516. static struct net_device_stats *mace_get_stats(struct net_device *dev)
  1517. {
  1518.   mace_private *lp = (mace_private *)dev->priv;
  1520.   update_stats(dev->base_addr, dev);
  1522.   DEBUG(1, "%s: updating the statistics.n", dev->name);
  1523.   pr_linux_stats(&lp->linux_stats);
  1524.   pr_mace_stats(&lp->mace_stats);
  1526.   return &lp->linux_stats;
  1527. } /* net_device_stats */
  1529. /* ----------------------------------------------------------------------------
  1530. updateCRC
  1531. Modified from Am79C90 data sheet.
  1532. ---------------------------------------------------------------------------- */
  1534. #if BROKEN_MULTICAST
  1536. static void updateCRC(int *CRC, int bit)
  1537. {
  1538.   int poly[]={
  1539.     1,1,1,0, 1,1,0,1,
  1540.     1,0,1,1, 1,0,0,0,
  1541.     1,0,0,0, 0,0,1,1,
  1542.     0,0,1,0, 0,0,0,0
  1543.   }; /* CRC polynomial.  poly[n] = coefficient of the x**n term of the
  1544. CRC generator polynomial. */
  1546.   int j;
  1548.   /* shift CRC and control bit (CRC[32]) */
  1549.   for (j = 32; j > 0; j--)
  1550.     CRC[j] = CRC[j-1];
  1551.   CRC[0] = 0;
  1553.   /* If bit XOR(control bit) = 1, set CRC = CRC XOR polynomial. */
  1554.   if (bit ^ CRC[32])
  1555.     for (j = 0; j < 32; j++)
  1556.       CRC[j] ^= poly[j];
  1557. } /* updateCRC */
  1559. /* ----------------------------------------------------------------------------
  1560. BuildLAF
  1561. Build logical address filter.
  1562. Modified from Am79C90 data sheet.
  1564. Input
  1565. ladrf: logical address filter (contents initialized to 0)
  1566. adr: ethernet address
  1567. ---------------------------------------------------------------------------- */
  1568. static void BuildLAF(int *ladrf, int *adr)
  1569. {
  1570.   int CRC[33]={1}; /* CRC register, 1 word/bit + extra control bit */
  1572.   int i, byte; /* temporary array indices */
  1573.   int hashcode; /* the output object */
  1575.   CRC[32]=0;
  1577.   for (byte = 0; byte < 6; byte++)
  1578.     for (i = 0; i < 8; i++)
  1579.       updateCRC(CRC, (adr[byte] >> i) & 1);
  1581.   hashcode = 0;
  1582.   for (i = 0; i < 6; i++)
  1583.     hashcode = (hashcode << 1) + CRC[i];
  1585.   byte = hashcode >> 3;
  1586.   ladrf[byte] |= (1 << (hashcode & 7));
  1588. #ifdef PCMCIA_DEBUG
  1589.   if (pc_debug > 2) {
  1590.     printk(KERN_DEBUG "    adr =");
  1591.     for (i = 0; i < 6; i++)
  1592.       printk(" %02X", adr[i]);
  1593.     printk("n" KERN_DEBUG "    hashcode = %d(decimal), ladrf[0:63]"
  1594.    " =", hashcode);
  1595.     for (i = 0; i < 8; i++)
  1596.       printk(" %02X", ladrf[i]);
  1597.     printk("n");
  1598.   }
  1599. #endif
  1600. } /* BuildLAF */
  1602. /* ----------------------------------------------------------------------------
  1603. restore_multicast_list
  1604. Restores the multicast filter for MACE chip to the last
  1605. set_multicast_list() call.
  1607. Input
  1608. multicast_num_addrs
  1609. multicast_ladrf[]
  1610. ---------------------------------------------------------------------------- */
  1611. static void restore_multicast_list(struct net_device *dev)
  1612. {
  1613.   mace_private *lp = (mace_private *)dev->priv;
  1614.   int num_addrs = lp->multicast_num_addrs;
  1615.   int *ladrf = lp->multicast_ladrf;
  1616.   ioaddr_t ioaddr = dev->base_addr;
  1617.   int i;
  1619.   DEBUG(2, "%s: restoring Rx mode to %d addresses.n",
  1620. dev->name, num_addrs);
  1622.   if (num_addrs > 0) {
  1624.     DEBUG(1, "Attempt to restore multicast list detected.n");
  1626.     mace_write(ioaddr, MACE_IAC, MACE_IAC_ADDRCHG | MACE_IAC_LOGADDR);
  1627.     /* Poll ADDRCHG bit */
  1628.     while (mace_read(ioaddr, MACE_IAC) & MACE_IAC_ADDRCHG)
  1629.       ;
  1630.     /* Set LADRF register */
  1631.     for (i = 0; i < MACE_LADRF_LEN; i++)
  1632.       mace_write(ioaddr, MACE_LADRF, ladrf[i]);
  1634.     mace_write(ioaddr, MACE_UTR, MACE_UTR_RCVFCSE | MACE_UTR_LOOP_EXTERNAL);
  1635.     mace_write(ioaddr, MACE_MACCC, MACE_MACCC_ENXMT | MACE_MACCC_ENRCV);
  1637.   } else if (num_addrs < 0) {
  1639.     /* Promiscuous mode: receive all packets */
  1640.     mace_write(ioaddr, MACE_UTR, MACE_UTR_LOOP_EXTERNAL);
  1641.     mace_write(ioaddr, MACE_MACCC,
  1642.       MACE_MACCC_PROM | MACE_MACCC_ENXMT | MACE_MACCC_ENRCV
  1643.     );
  1645.   } else {
  1647.     /* Normal mode */
  1648.     mace_write(ioaddr, MACE_UTR, MACE_UTR_LOOP_EXTERNAL);
  1649.     mace_write(ioaddr, MACE_MACCC, MACE_MACCC_ENXMT | MACE_MACCC_ENRCV);
  1651.   }
  1652. } /* restore_multicast_list */
  1654. /* ----------------------------------------------------------------------------
  1655. set_multicast_list
  1656. Set or clear the multicast filter for this adaptor.
  1658. Input
  1659. num_addrs == -1 Promiscuous mode, receive all packets
  1660. num_addrs == 0 Normal mode, clear multicast list
  1661. num_addrs > 0 Multicast mode, receive normal and MC packets, and do
  1662. best-effort filtering.
  1663. Output
  1664. multicast_num_addrs
  1665. multicast_ladrf[]
  1666. ---------------------------------------------------------------------------- */
  1668. static void set_multicast_list(struct net_device *dev)
  1669. {
  1670.   mace_private *lp = (mace_private *)dev->priv;
  1671.   int adr[ETHER_ADDR_LEN] = {0}; /* Ethernet address */
  1672.   int i;
  1673.   struct dev_mc_list *dmi = dev->mc_list;
  1675. #ifdef PCMCIA_DEBUG
  1676.   if (pc_debug > 1) {
  1677.     static int old;
  1678.     if (dev->mc_count != old) {
  1679.       old = dev->mc_count;
  1680.       DEBUG(0, "%s: setting Rx mode to %d addresses.n",
  1681.     dev->name, old);
  1682.     }
  1683.   }
  1684. #endif
  1686.   /* Set multicast_num_addrs. */
  1687.   lp->multicast_num_addrs = dev->mc_count;
  1689.   /* Set multicast_ladrf. */
  1690.   if (num_addrs > 0) {
  1691.     /* Calculate multicast logical address filter */
  1692.     memset(lp->multicast_ladrf, 0, MACE_LADRF_LEN);
  1693.     for (i = 0; i < dev->mc_count; i++) {
  1694.       memcpy(adr, dmi->dmi_addr, ETHER_ADDR_LEN);
  1695.       dmi = dmi->next;
  1696.       BuildLAF(lp->multicast_ladrf, adr);
  1697.     }
  1698.   }
  1700.   restore_multicast_list(dev);
  1702. } /* set_multicast_list */
  1704. #endif /* BROKEN_MULTICAST */
  1706. static void restore_multicast_list(struct net_device *dev)
  1707. {
  1708.   ioaddr_t ioaddr = dev->base_addr;
  1710.   DEBUG(2, "%s: restoring Rx mode to %d addresses.n", dev->name,
  1711. ((mace_private *)(dev->priv))->multicast_num_addrs);
  1713.   if (dev->flags & IFF_PROMISC) {
  1714.     /* Promiscuous mode: receive all packets */
  1715.     mace_write(ioaddr, MACE_UTR, MACE_UTR_LOOP_EXTERNAL);
  1716.     mace_write(ioaddr, MACE_MACCC,
  1717.       MACE_MACCC_PROM | MACE_MACCC_ENXMT | MACE_MACCC_ENRCV
  1718.     );
  1719.   } else {
  1720.     /* Normal mode */
  1721.     mace_write(ioaddr, MACE_UTR, MACE_UTR_LOOP_EXTERNAL);
  1722.     mace_write(ioaddr, MACE_MACCC, MACE_MACCC_ENXMT | MACE_MACCC_ENRCV);
  1723.   }
  1724. } /* restore_multicast_list */
  1726. static void set_multicast_list(struct net_device *dev)
  1727. {
  1728.   mace_private *lp = (mace_private *)dev->priv;
  1730. #ifdef PCMCIA_DEBUG
  1731.   if (pc_debug > 1) {
  1732.     static int old;
  1733.     if (dev->mc_count != old) {
  1734.       old = dev->mc_count;
  1735.       DEBUG(0, "%s: setting Rx mode to %d addresses.n",
  1736.     dev->name, old);
  1737.     }
  1738.   }
  1739. #endif
  1741.   lp->multicast_num_addrs = dev->mc_count;
  1742.   restore_multicast_list(dev);
  1744. } /* set_multicast_list */
  1746. /* ----------------------------------------------------------------------------
  1747. init_nmclan_cs
  1748. ---------------------------------------------------------------------------- */
  1750. static int __init init_nmclan_cs(void)
  1751. {
  1752.   servinfo_t serv;
  1753.   DEBUG(0, "%sn", version);
  1754.   CardServices(GetCardServicesInfo, &serv);
  1755.   if (serv.Revision != CS_RELEASE_CODE) {
  1756.     printk(KERN_NOTICE "nmclan_cs: Card Services release does not match!n");
  1757.     return -1;
  1758.   }
  1759.   register_pccard_driver(&dev_info, &nmclan_attach, &nmclan_detach);
  1760.   return 0;
  1761. }
  1763. /* ----------------------------------------------------------------------------
  1764. exit_nmclan_cs
  1765. ---------------------------------------------------------------------------- */
  1767. static void __exit exit_nmclan_cs(void)
  1768. {
  1769.     DEBUG(0, "nmclan_cs: unloadingn");
  1770.     unregister_pccard_driver(&dev_info);
  1771.     while (dev_list != NULL)
  1772. nmclan_detach(dev_list);
  1773. }
  1775. module_init(init_nmclan_cs);
  1776. module_exit(exit_nmclan_cs);