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

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

嵌入式Linux

开发平台：

Unix_Linux

etherh.c：源码内容
  1. /*
  2.  *  linux/drivers/acorn/net/etherh.c
  3.  *
  4.  *  Copyright (C) 2000-2002 Russell King
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License version 2 as
  8.  * published by the Free Software Foundation.
  9.  *
  10.  * NS8390 I-cubed EtherH and ANT EtherM specific driver
  11.  * Thanks to I-Cubed for information on their cards.
  12.  * EtherM conversion (C) 1999 Chris Kemp and Tim Watterton
  13.  * EtherM integration (C) 2000 Aleph One Ltd (Tak-Shing Chan)
  14.  * EtherM integration re-engineered by Russell King.
  15.  *
  16.  * Changelog:
  17.  *  08-12-1996 RMK 1.00 Created
  18.  * RMK 1.03 Added support for EtherLan500 cards
  19.  *  23-11-1997 RMK 1.04 Added media autodetection
  20.  *  16-04-1998 RMK 1.05 Improved media autodetection
  21.  *  10-02-2000 RMK 1.06 Updated for 2.3.43
  22.  *  13-05-2000 RMK 1.07 Updated for 2.3.99-pre8
  23.  *  12-10-1999  CK/TEW EtherM driver first release
  24.  *  21-12-2000 TTC EtherH/EtherM integration
  25.  *  25-12-2000 RMK 1.08 Clean integration of EtherM into this driver.
  26.  *  03-01-2002 RMK 1.09 Always enable IRQs if we're in the nic slot.
  27.  */
  29. #include <linux/module.h>
  30. #include <linux/kernel.h>
  31. #include <linux/sched.h>
  32. #include <linux/types.h>
  33. #include <linux/fcntl.h>
  34. #include <linux/interrupt.h>
  35. #include <linux/ptrace.h>
  36. #include <linux/ioport.h>
  37. #include <linux/in.h>
  38. #include <linux/slab.h>
  39. #include <linux/string.h>
  40. #include <linux/errno.h>
  41. #include <linux/netdevice.h>
  42. #include <linux/etherdevice.h>
  43. #include <linux/skbuff.h>
  44. #include <linux/delay.h>
  45. #include <linux/init.h>
  47. #include <asm/system.h>
  48. #include <asm/bitops.h>
  49. #include <asm/ecard.h>
  50. #include <asm/io.h>
  51. #include <asm/irq.h>
  53. #include "../../net/8390.h"
  55. #define NET_DEBUG  0
  56. #define DEBUG_INIT 2
  58. static unsigned int net_debug = NET_DEBUG;
  60. static const card_ids __init etherh_cids[] = {
  61. { MANU_ANT, PROD_ANT_ETHERM      },
  62. { MANU_I3,  PROD_I3_ETHERLAN500  },
  63. { MANU_I3,  PROD_I3_ETHERLAN600  },
  64. { MANU_I3,  PROD_I3_ETHERLAN600A },
  65. { 0xffff,   0xffff }
  66. };
  68. struct etherh_priv {
  69. unsigned int id;
  70. unsigned int ctrl_port;
  71. unsigned int ctrl;
  72. };
  74. MODULE_AUTHOR("Russell King");
  75. MODULE_DESCRIPTION("EtherH/EtherM driver");
  76. MODULE_LICENSE("GPL");
  78. static char version[] __initdata =
  79. "EtherH/EtherM Driver (c) 2002 Russell King v1.09n";
  81. #define ETHERH500_DATAPORT 0x200 /* MEMC */
  82. #define ETHERH500_NS8390 0x000 /* MEMC */
  83. #define ETHERH500_CTRLPORT 0x200 /* IOC  */
  85. #define ETHERH600_DATAPORT 16 /* MEMC */
  86. #define ETHERH600_NS8390 0x200 /* MEMC */
  87. #define ETHERH600_CTRLPORT 0x080 /* MEMC */
  89. #define ETHERH_CP_IE 1
  90. #define ETHERH_CP_IF 2
  91. #define ETHERH_CP_HEARTBEAT 2
  93. #define ETHERH_TX_START_PAGE 1
  94. #define ETHERH_STOP_PAGE 127
  96. /*
  97.  * These came from CK/TEW
  98.  */
  99. #define ETHERM_DATAPORT 0x080 /* MEMC */
  100. #define ETHERM_NS8390 0x200 /* MEMC */
  101. #define ETHERM_CTRLPORT 0x08f /* MEMC */
  103. #define ETHERM_TX_START_PAGE 64
  104. #define ETHERM_STOP_PAGE 127
  106. /* ------------------------------------------------------------------------ */
  108. static inline void etherh_set_ctrl(struct etherh_priv *eh, unsigned int mask)
  109. {
  110. eh->ctrl |= mask;
  111. outb(eh->ctrl, eh->ctrl_port);
  112. }
  114. static inline void etherh_clr_ctrl(struct etherh_priv *eh, unsigned int mask)
  115. {
  116. eh->ctrl &= ~mask;
  117. outb(eh->ctrl, eh->ctrl_port);
  118. }
  120. static inline unsigned int etherh_get_stat(struct etherh_priv *eh)
  121. {
  122. return inb(eh->ctrl_port);
  123. }
  128. static void etherh_irq_enable(ecard_t *ec, int irqnr)
  129. {
  130. struct etherh_priv *eh = ec->irq_data;
  132. etherh_set_ctrl(eh, ETHERH_CP_IE);
  133. }
  135. static void etherh_irq_disable(ecard_t *ec, int irqnr)
  136. {
  137. struct etherh_priv *eh = ec->irq_data;
  139. etherh_clr_ctrl(eh, ETHERH_CP_IE);
  140. }
  142. static expansioncard_ops_t etherh_ops = {
  143. irqenable: etherh_irq_enable,
  144. irqdisable: etherh_irq_disable,
  145. };
  150. static void
  151. etherh_setif(struct net_device *dev)
  152. {
  153. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  154. struct etherh_priv *eh = (struct etherh_priv *)dev->rmem_start;
  155. unsigned long addr, flags;
  157. save_flags_cli(flags);
  159. /* set the interface type */
  160. switch (eh->id) {
  161. case PROD_I3_ETHERLAN600:
  162. case PROD_I3_ETHERLAN600A:
  163. addr = dev->base_addr + EN0_RCNTHI;
  165. switch (dev->if_port) {
  166. case IF_PORT_10BASE2:
  167. outb((inb(addr) & 0xf8) | 1, addr);
  168. break;
  169. case IF_PORT_10BASET:
  170. outb((inb(addr) & 0xf8), addr);
  171. break;
  172. }
  173. break;
  175. case PROD_I3_ETHERLAN500:
  176. switch (dev->if_port) {
  177. case IF_PORT_10BASE2:
  178. etherh_clr_ctrl(eh, ETHERH_CP_IF);
  179. break;
  181. case IF_PORT_10BASET:
  182. etherh_set_ctrl(eh, ETHERH_CP_IF);
  183. break;
  184. }
  185. break;
  187. default:
  188. break;
  189. }
  191. restore_flags(flags);
  192. }
  194. static int
  195. etherh_getifstat(struct net_device *dev)
  196. {
  197. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  198. struct etherh_priv *eh = (struct etherh_priv *)dev->rmem_start;
  199. int stat = 0;
  201. switch (eh->id) {
  202. case PROD_I3_ETHERLAN600:
  203. case PROD_I3_ETHERLAN600A:
  204. switch (dev->if_port) {
  205. case IF_PORT_10BASE2:
  206. stat = 1;
  207. break;
  208. case IF_PORT_10BASET:
  209. stat = inb(dev->base_addr+EN0_RCNTHI) & 4;
  210. break;
  211. }
  212. break;
  214. case PROD_I3_ETHERLAN500:
  215. switch (dev->if_port) {
  216. case IF_PORT_10BASE2:
  217. stat = 1;
  218. break;
  219. case IF_PORT_10BASET:
  220. stat = etherh_get_stat(eh) & ETHERH_CP_HEARTBEAT;
  221. break;
  222. }
  223. break;
  225. default:
  226. stat = 0;
  227. break;
  228. }
  230. return stat != 0;
  231. }
  233. /*
  234.  * Configure the interface.  Note that we ignore the other
  235.  * parts of ifmap, since its mostly meaningless for this driver.
  236.  */
  237. static int etherh_set_config(struct net_device *dev, struct ifmap *map)
  238. {
  239. switch (map->port) {
  240. case IF_PORT_10BASE2:
  241. case IF_PORT_10BASET:
  242. /*
  243.  * If the user explicitly sets the interface
  244.  * media type, turn off automedia detection.
  245.  */
  246. dev->flags &= ~IFF_AUTOMEDIA;
  247. dev->if_port = map->port;
  248. break;
  250. default:
  251. return -EINVAL;
  252. }
  254. etherh_setif(dev);
  256. return 0;
  257. }
  259. /*
  260.  * Reset the 8390 (hard reset).  Note that we can't actually do this.
  261.  */
  262. static void
  263. etherh_reset(struct net_device *dev)
  264. {
  265. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  267. outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, dev->base_addr);
  269. /*
  270.  * See if we need to change the interface type.
  271.  * Note that we use 'interface_num' as a flag
  272.  * to indicate that we need to change the media.
  273.  */
  274. if (dev->flags & IFF_AUTOMEDIA && ei_local->interface_num) {
  275. ei_local->interface_num = 0;
  277. if (dev->if_port == IF_PORT_10BASET)
  278. dev->if_port = IF_PORT_10BASE2;
  279. else
  280. dev->if_port = IF_PORT_10BASET;
  282. etherh_setif(dev);
  283. }
  284. }
  286. /*
  287.  * Write a block of data out to the 8390
  288.  */
  289. static void
  290. etherh_block_output (struct net_device *dev, int count, const unsigned char *buf, int start_page)
  291. {
  292. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  293. unsigned int addr, dma_addr;
  294. unsigned long dma_start;
  296. if (ei_local->dmaing) {
  297. printk(KERN_ERR "%s: DMAing conflict in etherh_block_input: "
  298. " DMAstat %d irqlock %dn", dev->name,
  299. ei_local->dmaing, ei_local->irqlock);
  300. return;
  301. }
  303. /*
  304.  * Make sure we have a round number of bytes if we're in word mode.
  305.  */
  306. if (count & 1 && ei_local->word16)
  307. count++;
  309. ei_local->dmaing = 1;
  311. addr = dev->base_addr;
  312. dma_addr = dev->mem_start;
  314. count = (count + 1) & ~1;
  315. outb (E8390_NODMA | E8390_PAGE0 | E8390_START, addr + E8390_CMD);
  317. outb (0x42, addr + EN0_RCNTLO);
  318. outb (0x00, addr + EN0_RCNTHI);
  319. outb (0x42, addr + EN0_RSARLO);
  320. outb (0x00, addr + EN0_RSARHI);
  321. outb (E8390_RREAD | E8390_START, addr + E8390_CMD);
  323. udelay (1);
  325. outb (ENISR_RDC, addr + EN0_ISR);
  326. outb (count, addr + EN0_RCNTLO);
  327. outb (count >> 8, addr + EN0_RCNTHI);
  328. outb (0, addr + EN0_RSARLO);
  329. outb (start_page, addr + EN0_RSARHI);
  330. outb (E8390_RWRITE | E8390_START, addr + E8390_CMD);
  332. if (ei_local->word16)
  333. outsw (dma_addr, buf, count >> 1);
  334. else
  335. outsb (dma_addr, buf, count);
  337. dma_start = jiffies;
  339. while ((inb (addr + EN0_ISR) & ENISR_RDC) == 0)
  340. if (jiffies - dma_start > 2*HZ/100) { /* 20ms */
  341. printk(KERN_ERR "%s: timeout waiting for TX RDCn",
  342. dev->name);
  343. etherh_reset (dev);
  344. NS8390_init (dev, 1);
  345. break;
  346. }
  348. outb (ENISR_RDC, addr + EN0_ISR);
  349. ei_local->dmaing = 0;
  350. }
  352. /*
  353.  * Read a block of data from the 8390
  354.  */
  355. static void
  356. etherh_block_input (struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
  357. {
  358. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  359. unsigned int addr, dma_addr;
  360. unsigned char *buf;
  362. if (ei_local->dmaing) {
  363. printk(KERN_ERR "%s: DMAing conflict in etherh_block_input: "
  364. " DMAstat %d irqlock %dn", dev->name,
  365. ei_local->dmaing, ei_local->irqlock);
  366. return;
  367. }
  369. ei_local->dmaing = 1;
  371. addr = dev->base_addr;
  372. dma_addr = dev->mem_start;
  374. buf = skb->data;
  375. outb (E8390_NODMA | E8390_PAGE0 | E8390_START, addr + E8390_CMD);
  376. outb (count, addr + EN0_RCNTLO);
  377. outb (count >> 8, addr + EN0_RCNTHI);
  378. outb (ring_offset, addr + EN0_RSARLO);
  379. outb (ring_offset >> 8, addr + EN0_RSARHI);
  380. outb (E8390_RREAD | E8390_START, addr + E8390_CMD);
  382. if (ei_local->word16) {
  383. insw (dma_addr, buf, count >> 1);
  384. if (count & 1)
  385. buf[count - 1] = inb (dma_addr);
  386. } else
  387. insb (dma_addr, buf, count);
  389. outb (ENISR_RDC, addr + EN0_ISR);
  390. ei_local->dmaing = 0;
  391. }
  393. /*
  394.  * Read a header from the 8390
  395.  */
  396. static void
  397. etherh_get_header (struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
  398. {
  399. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  400. unsigned int addr, dma_addr;
  402. if (ei_local->dmaing) {
  403. printk(KERN_ERR "%s: DMAing conflict in etherh_get_header: "
  404. " DMAstat %d irqlock %dn", dev->name,
  405. ei_local->dmaing, ei_local->irqlock);
  406. return;
  407. }
  409. ei_local->dmaing = 1;
  411. addr = dev->base_addr;
  412. dma_addr = dev->mem_start;
  414. outb (E8390_NODMA | E8390_PAGE0 | E8390_START, addr + E8390_CMD);
  415. outb (sizeof (*hdr), addr + EN0_RCNTLO);
  416. outb (0, addr + EN0_RCNTHI);
  417. outb (0, addr + EN0_RSARLO);
  418. outb (ring_page, addr + EN0_RSARHI);
  419. outb (E8390_RREAD | E8390_START, addr + E8390_CMD);
  421. if (ei_local->word16)
  422. insw (dma_addr, hdr, sizeof (*hdr) >> 1);
  423. else
  424. insb (dma_addr, hdr, sizeof (*hdr));
  426. outb (ENISR_RDC, addr + EN0_ISR);
  427. ei_local->dmaing = 0;
  428. }
  430. /*
  431.  * Open/initialize the board.  This is called (in the current kernel)
  432.  * sometime after booting when the 'ifconfig' program is run.
  433.  *
  434.  * This routine should set everything up anew at each open, even
  435.  * registers that "should" only need to be set once at boot, so that
  436.  * there is non-reboot way to recover if something goes wrong.
  437.  */
  438. static int
  439. etherh_open(struct net_device *dev)
  440. {
  441. struct ei_device *ei_local = (struct ei_device *) dev->priv;
  443. if (request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))
  444. return -EAGAIN;
  446. /*
  447.  * Make sure that we aren't going to change the
  448.  * media type on the next reset - we are about to
  449.  * do automedia manually now.
  450.  */
  451. ei_local->interface_num = 0;
  453. /*
  454.  * If we are doing automedia detection, do it now.
  455.  * This is more reliable than the 8390's detection.
  456.  */
  457. if (dev->flags & IFF_AUTOMEDIA) {
  458. dev->if_port = IF_PORT_10BASET;
  459. etherh_setif(dev);
  460. mdelay(1);
  461. if (!etherh_getifstat(dev)) {
  462. dev->if_port = IF_PORT_10BASE2;
  463. etherh_setif(dev);
  464. }
  465. } else
  466. etherh_setif(dev);
  468. etherh_reset(dev);
  469. ei_open(dev);
  471. return 0;
  472. }
  474. /*
  475.  * The inverse routine to etherh_open().
  476.  */
  477. static int
  478. etherh_close(struct net_device *dev)
  479. {
  480. ei_close (dev);
  481. free_irq (dev->irq, dev);
  482. return 0;
  483. }
  485. /*
  486.  * Initialisation
  487.  */
  489. static void __init etherh_banner(void)
  490. {
  491. static int version_printed;
  493. if (net_debug && version_printed++ == 0)
  494. printk(KERN_INFO "%s", version);
  495. }
  497. /*
  498.  * Read the ethernet address string from the on board rom.
  499.  * This is an ascii string...
  500.  */
  501. static int __init etherh_addr(char *addr, struct expansion_card *ec)
  502. {
  503. struct in_chunk_dir cd;
  504. char *s;
  506. if (ecard_readchunk(&cd, ec, 0xf5, 0) && (s = strchr(cd.d.string, '('))) {
  507. int i;
  508. for (i = 0; i < 6; i++) {
  509. addr[i] = simple_strtoul(s + 1, &s, 0x10);
  510. if (*s != (i == 5? ')' : ':'))
  511. break;
  512. }
  513. if (i == 6)
  514. return 0;
  515. }
  516. return ENODEV;
  517. }
  519. /*
  520.  * Create an ethernet address from the system serial number.
  521.  */
  522. static int __init etherm_addr(char *addr)
  523. {
  524. unsigned int serial;
  526. if (system_serial_low == 0 && system_serial_high == 0)
  527. return ENODEV;
  529. serial = system_serial_low | system_serial_high;
  531. addr[0] = 0;
  532. addr[1] = 0;
  533. addr[2] = 0xa4;
  534. addr[3] = 0x10 + (serial >> 24);
  535. addr[4] = serial >> 16;
  536. addr[5] = serial >> 8;
  537. return 0;
  538. }
  540. static u32 etherh_regoffsets[16];
  541. static u32 etherm_regoffsets[16];
  543. static struct net_device * __init etherh_init_one(struct expansion_card *ec)
  544. {
  545. struct ei_device *ei_local;
  546. struct net_device *dev;
  547. struct etherh_priv *eh;
  548. const char *dev_type;
  549. int i, size;
  551. etherh_banner();
  553. ecard_claim(ec);
  555. dev = init_etherdev(NULL, 0);
  556. if (!dev)
  557. goto out;
  559. eh = kmalloc(sizeof(struct etherh_priv), GFP_KERNEL);
  560. if (!eh)
  561. goto out_nopriv;
  563. SET_MODULE_OWNER(dev);
  565. dev->open = etherh_open;
  566. dev->stop = etherh_close;
  567. dev->set_config = etherh_set_config;
  568. dev->irq = ec->irq;
  569. dev->base_addr = ecard_address(ec, ECARD_MEMC, 0);
  570. dev->rmem_start = (unsigned long)eh;
  572. /*
  573.  * IRQ and control port handling
  574.  */
  575. ec->ops = &etherh_ops;
  576. ec->irq_data = eh;
  577. eh->ctrl = 0;
  578. eh->id = ec->cid.product;
  580. switch (ec->cid.product) {
  581. case PROD_ANT_ETHERM:
  582. if (etherm_addr(dev->dev_addr))
  583. goto free;
  584. dev->base_addr += ETHERM_NS8390;
  585. dev->mem_start  = dev->base_addr + ETHERM_DATAPORT;
  586. eh->ctrl_port   = dev->base_addr + ETHERM_CTRLPORT;
  587. break;
  589. case PROD_I3_ETHERLAN500:
  590. if (etherh_addr(dev->dev_addr, ec))
  591. goto free;
  592. dev->base_addr += ETHERH500_NS8390;
  593. dev->mem_start  = dev->base_addr + ETHERH500_DATAPORT;
  594. eh->ctrl_port   = ecard_address (ec, ECARD_IOC, ECARD_FAST)
  595.   + ETHERH500_CTRLPORT;
  596. break;
  598. case PROD_I3_ETHERLAN600:
  599. case PROD_I3_ETHERLAN600A:
  600. if (etherh_addr(dev->dev_addr, ec))
  601. goto free;
  602. dev->base_addr += ETHERH600_NS8390;
  603. dev->mem_start  = dev->base_addr + ETHERH600_DATAPORT;
  604. eh->ctrl_port   = dev->base_addr + ETHERH600_CTRLPORT;
  605. break;
  607. default:
  608. printk(KERN_ERR "%s: unknown card type %xn",
  609.        dev->name, ec->cid.product);
  610. goto free;
  611. }
  613. size = 16;
  614. if (ec->cid.product == PROD_ANT_ETHERM)
  615. size <<= 3;
  617. if (!request_region(dev->base_addr, size, dev->name))
  618. goto free;
  620. if (ethdev_init(dev))
  621. goto release;
  623. /*
  624.  * If we're in the NIC slot, make sure the IRQ is enabled
  625.  */
  626. if (dev->irq == 11)
  627. etherh_set_ctrl(eh, ETHERH_CP_IE);
  629. /*
  630.  * Unfortunately, ethdev_init eventually calls
  631.  * ether_setup, which re-writes dev->flags.
  632.  */
  633. switch (ec->cid.product) {
  634. case PROD_ANT_ETHERM:
  635. dev_type = "ANT EtherM";
  636. dev->if_port = IF_PORT_UNKNOWN;
  637. break;
  639. case PROD_I3_ETHERLAN500:
  640. dev_type = "i3 EtherH 500";
  641. dev->if_port = IF_PORT_UNKNOWN;
  642. break;
  644. case PROD_I3_ETHERLAN600:
  645. dev_type = "i3 EtherH 600";
  646. dev->flags  |= IFF_PORTSEL | IFF_AUTOMEDIA;
  647. dev->if_port = IF_PORT_10BASET;
  648. break;
  650. case PROD_I3_ETHERLAN600A:
  651. dev_type = "i3 EtherH 600A";
  652. dev->flags  |= IFF_PORTSEL | IFF_AUTOMEDIA;
  653. dev->if_port = IF_PORT_10BASET;
  654. break;
  656. default:
  657. dev_type = "unknown";
  658. break;
  659. }
  661. printk(KERN_INFO "%s: %s in slot %d, ",
  662. dev->name, dev_type, ec->slot_no);
  664. for (i = 0; i < 6; i++)
  665. printk("%2.2x%c", dev->dev_addr[i], i == 5 ? 'n' : ':');
  667. ei_local = (struct ei_device *) dev->priv;
  668. if (ec->cid.product == PROD_ANT_ETHERM) {
  669. ei_local->tx_start_page = ETHERM_TX_START_PAGE;
  670. ei_local->stop_page     = ETHERM_STOP_PAGE;
  671. ei_local->reg_offset    = etherm_regoffsets;
  672. } else {
  673. ei_local->tx_start_page = ETHERH_TX_START_PAGE;
  674. ei_local->stop_page     = ETHERH_STOP_PAGE;
  675. ei_local->reg_offset    = etherh_regoffsets;
  676. }
  678. ei_local->name          = dev->name;
  679. ei_local->word16        = 1;
  680. ei_local->rx_start_page = ei_local->tx_start_page + TX_PAGES;
  681. ei_local->reset_8390    = etherh_reset;
  682. ei_local->block_input   = etherh_block_input;
  683. ei_local->block_output  = etherh_block_output;
  684. ei_local->get_8390_hdr  = etherh_get_header;
  685. ei_local->interface_num = 0;
  687. etherh_reset(dev);
  688. NS8390_init(dev, 0);
  689. return dev;
  691. release:
  692. release_region(dev->base_addr, 16);
  693. free:
  694. kfree(eh);
  695. out_nopriv:
  696. unregister_netdev(dev);
  697. kfree(dev);
  698. out:
  699. ecard_release(ec);
  700. return NULL;
  701. }
  703. #define MAX_ETHERH_CARDS 2
  705. static struct net_device *e_dev[MAX_ETHERH_CARDS];
  706. static struct expansion_card *e_card[MAX_ETHERH_CARDS];
  708. static int __init etherh_init(void)
  709. {
  710. int i, ret = -ENODEV;
  712. for (i = 0; i < 16; i++) {
  713. etherh_regoffsets[i] = i;
  714. etherm_regoffsets[i] = i << 3;
  715. }
  717. ecard_startfind();
  719. for (i = 0; i < MAX_ECARDS; i++) {
  720. struct expansion_card *ec;
  721. struct net_device *dev;
  723. ec = ecard_find(0, etherh_cids);
  724. if (!ec)
  725. break;
  727. dev = etherh_init_one(ec);
  728. if (!dev)
  729. break;
  731. e_card[i] = ec;
  732. e_dev[i]  = dev;
  733. ret = 0;
  734. }
  736. return ret;
  737. }
  739. static void __exit etherh_exit(void)
  740. {
  741. int i;
  743. for (i = 0; i < MAX_ETHERH_CARDS; i++) {
  744. if (e_dev[i]) {
  745. int size;
  746. unregister_netdev(e_dev[i]);
  747. size = 16;
  748. if (e_card[i]->cid.product == PROD_ANT_ETHERM)
  749. size <<= 3;
  750. release_region(e_dev[i]->base_addr, size);
  751. kfree(e_dev[i]);
  752. e_dev[i] = NULL;
  753. }
  754. if (e_card[i]) {
  755. e_card[i]->ops = NULL;
  756. kfree(e_card[i]->irq_data);
  757. ecard_release(e_card[i]);
  758. e_card[i] = NULL;
  759. }
  760. }
  761. }
  763. module_init(etherh_init);
  764. module_exit(etherh_exit);