2 * linux/drivers/acorn/net/etherh.c
4 * Copyright (C) 2000-2002 Russell King
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.
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.
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.
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/fcntl.h>
33 #include <linux/interrupt.h>
34 #include <linux/ioport.h>
36 #include <linux/string.h>
37 #include <linux/errno.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/ethtool.h>
41 #include <linux/skbuff.h>
42 #include <linux/delay.h>
43 #include <linux/device.h>
44 #include <linux/init.h>
45 #include <linux/bitops.h>
46 #include <linux/jiffies.h>
48 #include <asm/system.h>
49 #include <asm/ecard.h>
52 #define EI_SHIFT(x) (ei_local->reg_offset[x])
54 #define ei_inb(_p) readb((void __iomem *)_p)
55 #define ei_outb(_v,_p) writeb(_v,(void __iomem *)_p)
56 #define ei_inb_p(_p) readb((void __iomem *)_p)
57 #define ei_outb_p(_v,_p) writeb(_v,(void __iomem *)_p)
62 #define DRV_NAME "etherh"
63 #define DRV_VERSION "1.11"
65 static char version
[] __initdata
=
66 "EtherH/EtherM Driver (c) 2002-2004 Russell King " DRV_VERSION
"\n";
68 #include "../lib8390.c"
70 static unsigned int net_debug
= NET_DEBUG
;
73 void __iomem
*ioc_fast
;
75 void __iomem
*dma_base
;
77 void __iomem
*ctrl_port
;
83 unsigned long ns8390_offset
;
84 unsigned long dataport_offset
;
85 unsigned long ctrlport_offset
;
89 unsigned char tx_start_page
;
90 unsigned char stop_page
;
93 MODULE_AUTHOR("Russell King");
94 MODULE_DESCRIPTION("EtherH/EtherM driver");
95 MODULE_LICENSE("GPL");
97 #define ETHERH500_DATAPORT 0x800 /* MEMC */
98 #define ETHERH500_NS8390 0x000 /* MEMC */
99 #define ETHERH500_CTRLPORT 0x800 /* IOC */
101 #define ETHERH600_DATAPORT 0x040 /* MEMC */
102 #define ETHERH600_NS8390 0x800 /* MEMC */
103 #define ETHERH600_CTRLPORT 0x200 /* MEMC */
105 #define ETHERH_CP_IE 1
106 #define ETHERH_CP_IF 2
107 #define ETHERH_CP_HEARTBEAT 2
109 #define ETHERH_TX_START_PAGE 1
110 #define ETHERH_STOP_PAGE 127
113 * These came from CK/TEW
115 #define ETHERM_DATAPORT 0x200 /* MEMC */
116 #define ETHERM_NS8390 0x800 /* MEMC */
117 #define ETHERM_CTRLPORT 0x23c /* MEMC */
119 #define ETHERM_TX_START_PAGE 64
120 #define ETHERM_STOP_PAGE 127
122 /* ------------------------------------------------------------------------ */
124 #define etherh_priv(dev) \
125 ((struct etherh_priv *)(((char *)netdev_priv(dev)) + sizeof(struct ei_device)))
127 static inline void etherh_set_ctrl(struct etherh_priv
*eh
, unsigned char mask
)
129 unsigned char ctrl
= eh
->ctrl
| mask
;
131 writeb(ctrl
, eh
->ctrl_port
);
134 static inline void etherh_clr_ctrl(struct etherh_priv
*eh
, unsigned char mask
)
136 unsigned char ctrl
= eh
->ctrl
& ~mask
;
138 writeb(ctrl
, eh
->ctrl_port
);
141 static inline unsigned int etherh_get_stat(struct etherh_priv
*eh
)
143 return readb(eh
->ctrl_port
);
149 static void etherh_irq_enable(ecard_t
*ec
, int irqnr
)
151 struct etherh_priv
*eh
= ec
->irq_data
;
153 etherh_set_ctrl(eh
, ETHERH_CP_IE
);
156 static void etherh_irq_disable(ecard_t
*ec
, int irqnr
)
158 struct etherh_priv
*eh
= ec
->irq_data
;
160 etherh_clr_ctrl(eh
, ETHERH_CP_IE
);
163 static expansioncard_ops_t etherh_ops
= {
164 .irqenable
= etherh_irq_enable
,
165 .irqdisable
= etherh_irq_disable
,
172 etherh_setif(struct net_device
*dev
)
174 struct ei_device
*ei_local
= netdev_priv(dev
);
178 local_irq_save(flags
);
180 /* set the interface type */
181 switch (etherh_priv(dev
)->id
) {
182 case PROD_I3_ETHERLAN600
:
183 case PROD_I3_ETHERLAN600A
:
184 addr
= (void __iomem
*)dev
->base_addr
+ EN0_RCNTHI
;
186 switch (dev
->if_port
) {
187 case IF_PORT_10BASE2
:
188 writeb((readb(addr
) & 0xf8) | 1, addr
);
190 case IF_PORT_10BASET
:
191 writeb((readb(addr
) & 0xf8), addr
);
196 case PROD_I3_ETHERLAN500
:
197 switch (dev
->if_port
) {
198 case IF_PORT_10BASE2
:
199 etherh_clr_ctrl(etherh_priv(dev
), ETHERH_CP_IF
);
202 case IF_PORT_10BASET
:
203 etherh_set_ctrl(etherh_priv(dev
), ETHERH_CP_IF
);
212 local_irq_restore(flags
);
216 etherh_getifstat(struct net_device
*dev
)
218 struct ei_device
*ei_local
= netdev_priv(dev
);
222 switch (etherh_priv(dev
)->id
) {
223 case PROD_I3_ETHERLAN600
:
224 case PROD_I3_ETHERLAN600A
:
225 addr
= (void __iomem
*)dev
->base_addr
+ EN0_RCNTHI
;
226 switch (dev
->if_port
) {
227 case IF_PORT_10BASE2
:
230 case IF_PORT_10BASET
:
231 stat
= readb(addr
) & 4;
236 case PROD_I3_ETHERLAN500
:
237 switch (dev
->if_port
) {
238 case IF_PORT_10BASE2
:
241 case IF_PORT_10BASET
:
242 stat
= etherh_get_stat(etherh_priv(dev
)) & ETHERH_CP_HEARTBEAT
;
256 * Configure the interface. Note that we ignore the other
257 * parts of ifmap, since its mostly meaningless for this driver.
259 static int etherh_set_config(struct net_device
*dev
, struct ifmap
*map
)
262 case IF_PORT_10BASE2
:
263 case IF_PORT_10BASET
:
265 * If the user explicitly sets the interface
266 * media type, turn off automedia detection.
268 dev
->flags
&= ~IFF_AUTOMEDIA
;
269 dev
->if_port
= map
->port
;
282 * Reset the 8390 (hard reset). Note that we can't actually do this.
285 etherh_reset(struct net_device
*dev
)
287 struct ei_device
*ei_local
= netdev_priv(dev
);
288 void __iomem
*addr
= (void __iomem
*)dev
->base_addr
;
290 writeb(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, addr
);
293 * See if we need to change the interface type.
294 * Note that we use 'interface_num' as a flag
295 * to indicate that we need to change the media.
297 if (dev
->flags
& IFF_AUTOMEDIA
&& ei_local
->interface_num
) {
298 ei_local
->interface_num
= 0;
300 if (dev
->if_port
== IF_PORT_10BASET
)
301 dev
->if_port
= IF_PORT_10BASE2
;
303 dev
->if_port
= IF_PORT_10BASET
;
310 * Write a block of data out to the 8390
313 etherh_block_output (struct net_device
*dev
, int count
, const unsigned char *buf
, int start_page
)
315 struct ei_device
*ei_local
= netdev_priv(dev
);
316 unsigned long dma_start
;
317 void __iomem
*dma_base
, *addr
;
319 if (ei_local
->dmaing
) {
320 printk(KERN_ERR
"%s: DMAing conflict in etherh_block_input: "
321 " DMAstat %d irqlock %d\n", dev
->name
,
322 ei_local
->dmaing
, ei_local
->irqlock
);
327 * Make sure we have a round number of bytes if we're in word mode.
329 if (count
& 1 && ei_local
->word16
)
332 ei_local
->dmaing
= 1;
334 addr
= (void __iomem
*)dev
->base_addr
;
335 dma_base
= etherh_priv(dev
)->dma_base
;
337 count
= (count
+ 1) & ~1;
338 writeb (E8390_NODMA
| E8390_PAGE0
| E8390_START
, addr
+ E8390_CMD
);
340 writeb (0x42, addr
+ EN0_RCNTLO
);
341 writeb (0x00, addr
+ EN0_RCNTHI
);
342 writeb (0x42, addr
+ EN0_RSARLO
);
343 writeb (0x00, addr
+ EN0_RSARHI
);
344 writeb (E8390_RREAD
| E8390_START
, addr
+ E8390_CMD
);
348 writeb (ENISR_RDC
, addr
+ EN0_ISR
);
349 writeb (count
, addr
+ EN0_RCNTLO
);
350 writeb (count
>> 8, addr
+ EN0_RCNTHI
);
351 writeb (0, addr
+ EN0_RSARLO
);
352 writeb (start_page
, addr
+ EN0_RSARHI
);
353 writeb (E8390_RWRITE
| E8390_START
, addr
+ E8390_CMD
);
355 if (ei_local
->word16
)
356 writesw (dma_base
, buf
, count
>> 1);
358 writesb (dma_base
, buf
, count
);
362 while ((readb (addr
+ EN0_ISR
) & ENISR_RDC
) == 0)
363 if (time_after(jiffies
, dma_start
+ 2*HZ
/100)) { /* 20ms */
364 printk(KERN_ERR
"%s: timeout waiting for TX RDC\n",
367 __NS8390_init (dev
, 1);
371 writeb (ENISR_RDC
, addr
+ EN0_ISR
);
372 ei_local
->dmaing
= 0;
376 * Read a block of data from the 8390
379 etherh_block_input (struct net_device
*dev
, int count
, struct sk_buff
*skb
, int ring_offset
)
381 struct ei_device
*ei_local
= netdev_priv(dev
);
383 void __iomem
*dma_base
, *addr
;
385 if (ei_local
->dmaing
) {
386 printk(KERN_ERR
"%s: DMAing conflict in etherh_block_input: "
387 " DMAstat %d irqlock %d\n", dev
->name
,
388 ei_local
->dmaing
, ei_local
->irqlock
);
392 ei_local
->dmaing
= 1;
394 addr
= (void __iomem
*)dev
->base_addr
;
395 dma_base
= etherh_priv(dev
)->dma_base
;
398 writeb (E8390_NODMA
| E8390_PAGE0
| E8390_START
, addr
+ E8390_CMD
);
399 writeb (count
, addr
+ EN0_RCNTLO
);
400 writeb (count
>> 8, addr
+ EN0_RCNTHI
);
401 writeb (ring_offset
, addr
+ EN0_RSARLO
);
402 writeb (ring_offset
>> 8, addr
+ EN0_RSARHI
);
403 writeb (E8390_RREAD
| E8390_START
, addr
+ E8390_CMD
);
405 if (ei_local
->word16
) {
406 readsw (dma_base
, buf
, count
>> 1);
408 buf
[count
- 1] = readb (dma_base
);
410 readsb (dma_base
, buf
, count
);
412 writeb (ENISR_RDC
, addr
+ EN0_ISR
);
413 ei_local
->dmaing
= 0;
417 * Read a header from the 8390
420 etherh_get_header (struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
, int ring_page
)
422 struct ei_device
*ei_local
= netdev_priv(dev
);
423 void __iomem
*dma_base
, *addr
;
425 if (ei_local
->dmaing
) {
426 printk(KERN_ERR
"%s: DMAing conflict in etherh_get_header: "
427 " DMAstat %d irqlock %d\n", dev
->name
,
428 ei_local
->dmaing
, ei_local
->irqlock
);
432 ei_local
->dmaing
= 1;
434 addr
= (void __iomem
*)dev
->base_addr
;
435 dma_base
= etherh_priv(dev
)->dma_base
;
437 writeb (E8390_NODMA
| E8390_PAGE0
| E8390_START
, addr
+ E8390_CMD
);
438 writeb (sizeof (*hdr
), addr
+ EN0_RCNTLO
);
439 writeb (0, addr
+ EN0_RCNTHI
);
440 writeb (0, addr
+ EN0_RSARLO
);
441 writeb (ring_page
, addr
+ EN0_RSARHI
);
442 writeb (E8390_RREAD
| E8390_START
, addr
+ E8390_CMD
);
444 if (ei_local
->word16
)
445 readsw (dma_base
, hdr
, sizeof (*hdr
) >> 1);
447 readsb (dma_base
, hdr
, sizeof (*hdr
));
449 writeb (ENISR_RDC
, addr
+ EN0_ISR
);
450 ei_local
->dmaing
= 0;
454 * Open/initialize the board. This is called (in the current kernel)
455 * sometime after booting when the 'ifconfig' program is run.
457 * This routine should set everything up anew at each open, even
458 * registers that "should" only need to be set once at boot, so that
459 * there is non-reboot way to recover if something goes wrong.
462 etherh_open(struct net_device
*dev
)
464 struct ei_device
*ei_local
= netdev_priv(dev
);
466 if (!is_valid_ether_addr(dev
->dev_addr
)) {
467 printk(KERN_WARNING
"%s: invalid ethernet MAC address\n",
472 if (request_irq(dev
->irq
, __ei_interrupt
, 0, dev
->name
, dev
))
476 * Make sure that we aren't going to change the
477 * media type on the next reset - we are about to
478 * do automedia manually now.
480 ei_local
->interface_num
= 0;
483 * If we are doing automedia detection, do it now.
484 * This is more reliable than the 8390's detection.
486 if (dev
->flags
& IFF_AUTOMEDIA
) {
487 dev
->if_port
= IF_PORT_10BASET
;
490 if (!etherh_getifstat(dev
)) {
491 dev
->if_port
= IF_PORT_10BASE2
;
504 * The inverse routine to etherh_open().
507 etherh_close(struct net_device
*dev
)
510 free_irq (dev
->irq
, dev
);
518 static void __init
etherh_banner(void)
520 static int version_printed
;
522 if (net_debug
&& version_printed
++ == 0)
523 printk(KERN_INFO
"%s", version
);
527 * Read the ethernet address string from the on board rom.
528 * This is an ascii string...
530 static int __devinit
etherh_addr(char *addr
, struct expansion_card
*ec
)
532 struct in_chunk_dir cd
;
535 if (!ecard_readchunk(&cd
, ec
, 0xf5, 0)) {
536 printk(KERN_ERR
"%s: unable to read podule description string\n",
541 s
= strchr(cd
.d
.string
, '(');
545 for (i
= 0; i
< 6; i
++) {
546 addr
[i
] = simple_strtoul(s
+ 1, &s
, 0x10);
547 if (*s
!= (i
== 5? ')' : ':'))
555 printk(KERN_ERR
"%s: unable to parse MAC address: %s\n",
556 dev_name(&ec
->dev
), cd
.d
.string
);
563 * Create an ethernet address from the system serial number.
565 static int __init
etherm_addr(char *addr
)
569 if (system_serial_low
== 0 && system_serial_high
== 0)
572 serial
= system_serial_low
| system_serial_high
;
577 addr
[3] = 0x10 + (serial
>> 24);
578 addr
[4] = serial
>> 16;
579 addr
[5] = serial
>> 8;
583 static void etherh_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
585 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
586 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
587 strlcpy(info
->bus_info
, dev_name(dev
->dev
.parent
),
588 sizeof(info
->bus_info
));
591 static int etherh_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
593 cmd
->supported
= etherh_priv(dev
)->supported
;
594 ethtool_cmd_speed_set(cmd
, SPEED_10
);
595 cmd
->duplex
= DUPLEX_HALF
;
596 cmd
->port
= dev
->if_port
== IF_PORT_10BASET
? PORT_TP
: PORT_BNC
;
597 cmd
->autoneg
= (dev
->flags
& IFF_AUTOMEDIA
?
598 AUTONEG_ENABLE
: AUTONEG_DISABLE
);
602 static int etherh_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
604 switch (cmd
->autoneg
) {
606 dev
->flags
|= IFF_AUTOMEDIA
;
609 case AUTONEG_DISABLE
:
612 dev
->if_port
= IF_PORT_10BASET
;
616 dev
->if_port
= IF_PORT_10BASE2
;
622 dev
->flags
&= ~IFF_AUTOMEDIA
;
634 static const struct ethtool_ops etherh_ethtool_ops
= {
635 .get_settings
= etherh_get_settings
,
636 .set_settings
= etherh_set_settings
,
637 .get_drvinfo
= etherh_get_drvinfo
,
640 static const struct net_device_ops etherh_netdev_ops
= {
641 .ndo_open
= etherh_open
,
642 .ndo_stop
= etherh_close
,
643 .ndo_set_config
= etherh_set_config
,
644 .ndo_start_xmit
= __ei_start_xmit
,
645 .ndo_tx_timeout
= __ei_tx_timeout
,
646 .ndo_get_stats
= __ei_get_stats
,
647 .ndo_set_multicast_list
= __ei_set_multicast_list
,
648 .ndo_validate_addr
= eth_validate_addr
,
649 .ndo_set_mac_address
= eth_mac_addr
,
650 .ndo_change_mtu
= eth_change_mtu
,
651 #ifdef CONFIG_NET_POLL_CONTROLLER
652 .ndo_poll_controller
= __ei_poll
,
656 static u32 etherh_regoffsets
[16];
657 static u32 etherm_regoffsets
[16];
660 etherh_probe(struct expansion_card
*ec
, const struct ecard_id
*id
)
662 const struct etherh_data
*data
= id
->data
;
663 struct ei_device
*ei_local
;
664 struct net_device
*dev
;
665 struct etherh_priv
*eh
;
670 ret
= ecard_request_resources(ec
);
674 dev
= ____alloc_ei_netdev(sizeof(struct etherh_priv
));
680 SET_NETDEV_DEV(dev
, &ec
->dev
);
682 dev
->netdev_ops
= ðerh_netdev_ops
;
684 dev
->ethtool_ops
= ðerh_ethtool_ops
;
686 if (data
->supported
& SUPPORTED_Autoneg
)
687 dev
->flags
|= IFF_AUTOMEDIA
;
688 if (data
->supported
& SUPPORTED_TP
) {
689 dev
->flags
|= IFF_PORTSEL
;
690 dev
->if_port
= IF_PORT_10BASET
;
691 } else if (data
->supported
& SUPPORTED_BNC
) {
692 dev
->flags
|= IFF_PORTSEL
;
693 dev
->if_port
= IF_PORT_10BASE2
;
695 dev
->if_port
= IF_PORT_UNKNOWN
;
697 eh
= etherh_priv(dev
);
698 eh
->supported
= data
->supported
;
700 eh
->id
= ec
->cid
.product
;
701 eh
->memc
= ecardm_iomap(ec
, ECARD_RES_MEMC
, 0, PAGE_SIZE
);
707 eh
->ctrl_port
= eh
->memc
;
708 if (data
->ctrl_ioc
) {
709 eh
->ioc_fast
= ecardm_iomap(ec
, ECARD_RES_IOCFAST
, 0, PAGE_SIZE
);
714 eh
->ctrl_port
= eh
->ioc_fast
;
717 dev
->base_addr
= (unsigned long)eh
->memc
+ data
->ns8390_offset
;
718 eh
->dma_base
= eh
->memc
+ data
->dataport_offset
;
719 eh
->ctrl_port
+= data
->ctrlport_offset
;
722 * IRQ and control port handling - only for non-NIC slot cards.
724 if (ec
->slot_no
!= 8) {
725 ecard_setirq(ec
, ðerh_ops
, eh
);
728 * If we're in the NIC slot, make sure the IRQ is enabled
730 etherh_set_ctrl(eh
, ETHERH_CP_IE
);
733 ei_local
= netdev_priv(dev
);
734 spin_lock_init(&ei_local
->page_lock
);
736 if (ec
->cid
.product
== PROD_ANT_ETHERM
) {
737 etherm_addr(dev
->dev_addr
);
738 ei_local
->reg_offset
= etherm_regoffsets
;
740 etherh_addr(dev
->dev_addr
, ec
);
741 ei_local
->reg_offset
= etherh_regoffsets
;
744 ei_local
->name
= dev
->name
;
745 ei_local
->word16
= 1;
746 ei_local
->tx_start_page
= data
->tx_start_page
;
747 ei_local
->rx_start_page
= ei_local
->tx_start_page
+ TX_PAGES
;
748 ei_local
->stop_page
= data
->stop_page
;
749 ei_local
->reset_8390
= etherh_reset
;
750 ei_local
->block_input
= etherh_block_input
;
751 ei_local
->block_output
= etherh_block_output
;
752 ei_local
->get_8390_hdr
= etherh_get_header
;
753 ei_local
->interface_num
= 0;
756 __NS8390_init(dev
, 0);
758 ret
= register_netdev(dev
);
762 printk(KERN_INFO
"%s: %s in slot %d, %pM\n",
763 dev
->name
, data
->name
, ec
->slot_no
, dev
->dev_addr
);
765 ecard_set_drvdata(ec
, dev
);
772 ecard_release_resources(ec
);
777 static void __devexit
etherh_remove(struct expansion_card
*ec
)
779 struct net_device
*dev
= ecard_get_drvdata(ec
);
781 ecard_set_drvdata(ec
, NULL
);
783 unregister_netdev(dev
);
787 ecard_release_resources(ec
);
790 static struct etherh_data etherm_data
= {
791 .ns8390_offset
= ETHERM_NS8390
,
792 .dataport_offset
= ETHERM_NS8390
+ ETHERM_DATAPORT
,
793 .ctrlport_offset
= ETHERM_NS8390
+ ETHERM_CTRLPORT
,
794 .name
= "ANT EtherM",
795 .supported
= SUPPORTED_10baseT_Half
,
796 .tx_start_page
= ETHERM_TX_START_PAGE
,
797 .stop_page
= ETHERM_STOP_PAGE
,
800 static struct etherh_data etherlan500_data
= {
801 .ns8390_offset
= ETHERH500_NS8390
,
802 .dataport_offset
= ETHERH500_NS8390
+ ETHERH500_DATAPORT
,
803 .ctrlport_offset
= ETHERH500_CTRLPORT
,
805 .name
= "i3 EtherH 500",
806 .supported
= SUPPORTED_10baseT_Half
,
807 .tx_start_page
= ETHERH_TX_START_PAGE
,
808 .stop_page
= ETHERH_STOP_PAGE
,
811 static struct etherh_data etherlan600_data
= {
812 .ns8390_offset
= ETHERH600_NS8390
,
813 .dataport_offset
= ETHERH600_NS8390
+ ETHERH600_DATAPORT
,
814 .ctrlport_offset
= ETHERH600_NS8390
+ ETHERH600_CTRLPORT
,
815 .name
= "i3 EtherH 600",
816 .supported
= SUPPORTED_10baseT_Half
| SUPPORTED_TP
| SUPPORTED_BNC
| SUPPORTED_Autoneg
,
817 .tx_start_page
= ETHERH_TX_START_PAGE
,
818 .stop_page
= ETHERH_STOP_PAGE
,
821 static struct etherh_data etherlan600a_data
= {
822 .ns8390_offset
= ETHERH600_NS8390
,
823 .dataport_offset
= ETHERH600_NS8390
+ ETHERH600_DATAPORT
,
824 .ctrlport_offset
= ETHERH600_NS8390
+ ETHERH600_CTRLPORT
,
825 .name
= "i3 EtherH 600A",
826 .supported
= SUPPORTED_10baseT_Half
| SUPPORTED_TP
| SUPPORTED_BNC
| SUPPORTED_Autoneg
,
827 .tx_start_page
= ETHERH_TX_START_PAGE
,
828 .stop_page
= ETHERH_STOP_PAGE
,
831 static const struct ecard_id etherh_ids
[] = {
832 { MANU_ANT
, PROD_ANT_ETHERM
, ðerm_data
},
833 { MANU_I3
, PROD_I3_ETHERLAN500
, ðerlan500_data
},
834 { MANU_I3
, PROD_I3_ETHERLAN600
, ðerlan600_data
},
835 { MANU_I3
, PROD_I3_ETHERLAN600A
, ðerlan600a_data
},
839 static struct ecard_driver etherh_driver
= {
840 .probe
= etherh_probe
,
841 .remove
= __devexit_p(etherh_remove
),
842 .id_table
= etherh_ids
,
848 static int __init
etherh_init(void)
852 for (i
= 0; i
< 16; i
++) {
853 etherh_regoffsets
[i
] = i
<< 2;
854 etherm_regoffsets
[i
] = i
<< 5;
857 return ecard_register_driver(ðerh_driver
);
860 static void __exit
etherh_exit(void)
862 ecard_remove_driver(ðerh_driver
);
865 module_init(etherh_init
);
866 module_exit(etherh_exit
);