1 /* drivers/net/ax88796.c
3 * Copyright 2005,2007 Simtec Electronics
4 * Ben Dooks <ben@simtec.co.uk>
6 * Asix AX88796 10/100 Ethernet controller support
7 * Based on ne.c, by Donald Becker, et-al.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/isapnp.h>
18 #include <linux/init.h>
19 #include <linux/interrupt.h>
21 #include <linux/platform_device.h>
22 #include <linux/delay.h>
23 #include <linux/timer.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
27 #include <linux/mii.h>
28 #include <linux/eeprom_93cx6.h>
29 #include <linux/slab.h>
31 #include <net/ax88796.h>
33 #include <asm/system.h>
37 /* Rename the lib8390.c functions to show that they are in this driver */
38 #define __ei_open ax_ei_open
39 #define __ei_close ax_ei_close
40 #define __ei_poll ax_ei_poll
41 #define __ei_start_xmit ax_ei_start_xmit
42 #define __ei_tx_timeout ax_ei_tx_timeout
43 #define __ei_get_stats ax_ei_get_stats
44 #define __ei_set_multicast_list ax_ei_set_multicast_list
45 #define __ei_interrupt ax_ei_interrupt
46 #define ____alloc_ei_netdev ax__alloc_ei_netdev
47 #define __NS8390_init ax_NS8390_init
49 /* force unsigned long back to 'void __iomem *' */
50 #define ax_convert_addr(_a) ((void __force __iomem *)(_a))
52 #define ei_inb(_a) readb(ax_convert_addr(_a))
53 #define ei_outb(_v, _a) writeb(_v, ax_convert_addr(_a))
55 #define ei_inb_p(_a) ei_inb(_a)
56 #define ei_outb_p(_v, _a) ei_outb(_v, _a)
58 /* define EI_SHIFT() to take into account our register offsets */
59 #define EI_SHIFT(x) (ei_local->reg_offset[(x)])
61 /* Ensure we have our RCR base value */
62 #define AX88796_PLATFORM
64 static unsigned char version
[] = "ax88796.c: Copyright 2005,2007 Simtec Electronics\n";
68 #define DRV_NAME "ax88796"
69 #define DRV_VERSION "1.00"
72 #define NE_CMD EI_SHIFT(0x00)
73 #define NE_RESET EI_SHIFT(0x1f)
74 #define NE_DATAPORT EI_SHIFT(0x10)
76 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
77 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
78 #define NESM_START_PG 0x40 /* First page of TX buffer */
79 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
81 /* device private data */
84 struct timer_list mii_timer
;
86 struct mii_if_info mii
;
90 struct platform_device
*dev
;
92 struct resource
*mem2
;
93 struct ax_plat_data
*plat
;
95 unsigned char running
;
96 unsigned char resume_open
;
97 unsigned int irqflags
;
99 u32 reg_offsets
[0x20];
102 static inline struct ax_device
*to_ax_dev(struct net_device
*dev
)
104 struct ei_device
*ei_local
= netdev_priv(dev
);
105 return (struct ax_device
*)(ei_local
+ 1);
111 * do an initial probe for the card to check wether it exists
114 static int ax_initial_check(struct net_device
*dev
)
116 struct ei_device
*ei_local
= netdev_priv(dev
);
117 void __iomem
*ioaddr
= ei_local
->mem
;
121 reg0
= ei_inb(ioaddr
);
125 ei_outb(E8390_NODMA
+ E8390_PAGE1
+ E8390_STOP
, ioaddr
+ E8390_CMD
);
126 regd
= ei_inb(ioaddr
+ 0x0d);
127 ei_outb(0xff, ioaddr
+ 0x0d);
128 ei_outb(E8390_NODMA
+ E8390_PAGE0
, ioaddr
+ E8390_CMD
);
129 ei_inb(ioaddr
+ EN0_COUNTER0
); /* Clear the counter by reading. */
130 if (ei_inb(ioaddr
+ EN0_COUNTER0
) != 0) {
131 ei_outb(reg0
, ioaddr
);
132 ei_outb(regd
, ioaddr
+ 0x0d); /* Restore the old values. */
140 * Hard reset the card. This used to pause for the same period that a
141 * 8390 reset command required, but that shouldn't be necessary.
143 static void ax_reset_8390(struct net_device
*dev
)
145 struct ei_device
*ei_local
= netdev_priv(dev
);
146 struct ax_device
*ax
= to_ax_dev(dev
);
147 unsigned long reset_start_time
= jiffies
;
148 void __iomem
*addr
= (void __iomem
*)dev
->base_addr
;
151 dev_dbg(&ax
->dev
->dev
, "resetting the 8390 t=%ld\n", jiffies
);
153 ei_outb(ei_inb(addr
+ NE_RESET
), addr
+ NE_RESET
);
156 ei_local
->dmaing
= 0;
158 /* This check _should_not_ be necessary, omit eventually. */
159 while ((ei_inb(addr
+ EN0_ISR
) & ENISR_RESET
) == 0) {
160 if (jiffies
- reset_start_time
> 2 * HZ
/ 100) {
161 dev_warn(&ax
->dev
->dev
, "%s: %s did not complete.\n",
162 __func__
, dev
->name
);
167 ei_outb(ENISR_RESET
, addr
+ EN0_ISR
); /* Ack intr. */
171 static void ax_get_8390_hdr(struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
,
174 struct ei_device
*ei_local
= netdev_priv(dev
);
175 struct ax_device
*ax
= to_ax_dev(dev
);
176 void __iomem
*nic_base
= ei_local
->mem
;
178 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
179 if (ei_local
->dmaing
) {
180 dev_err(&ax
->dev
->dev
, "%s: DMAing conflict in %s "
181 "[DMAstat:%d][irqlock:%d].\n",
183 ei_local
->dmaing
, ei_local
->irqlock
);
187 ei_local
->dmaing
|= 0x01;
188 ei_outb(E8390_NODMA
+ E8390_PAGE0
+ E8390_START
, nic_base
+ NE_CMD
);
189 ei_outb(sizeof(struct e8390_pkt_hdr
), nic_base
+ EN0_RCNTLO
);
190 ei_outb(0, nic_base
+ EN0_RCNTHI
);
191 ei_outb(0, nic_base
+ EN0_RSARLO
); /* On page boundary */
192 ei_outb(ring_page
, nic_base
+ EN0_RSARHI
);
193 ei_outb(E8390_RREAD
+E8390_START
, nic_base
+ NE_CMD
);
195 if (ei_local
->word16
)
196 readsw(nic_base
+ NE_DATAPORT
, hdr
,
197 sizeof(struct e8390_pkt_hdr
) >> 1);
199 readsb(nic_base
+ NE_DATAPORT
, hdr
,
200 sizeof(struct e8390_pkt_hdr
));
202 ei_outb(ENISR_RDC
, nic_base
+ EN0_ISR
); /* Ack intr. */
203 ei_local
->dmaing
&= ~0x01;
205 le16_to_cpus(&hdr
->count
);
210 * Block input and output, similar to the Crynwr packet driver. If
211 * you are porting to a new ethercard, look at the packet driver
212 * source for hints. The NEx000 doesn't share the on-board packet
213 * memory -- you have to put the packet out through the "remote DMA"
214 * dataport using ei_outb.
216 static void ax_block_input(struct net_device
*dev
, int count
,
217 struct sk_buff
*skb
, int ring_offset
)
219 struct ei_device
*ei_local
= netdev_priv(dev
);
220 struct ax_device
*ax
= to_ax_dev(dev
);
221 void __iomem
*nic_base
= ei_local
->mem
;
222 char *buf
= skb
->data
;
224 if (ei_local
->dmaing
) {
225 dev_err(&ax
->dev
->dev
,
226 "%s: DMAing conflict in %s "
227 "[DMAstat:%d][irqlock:%d].\n",
229 ei_local
->dmaing
, ei_local
->irqlock
);
233 ei_local
->dmaing
|= 0x01;
235 ei_outb(E8390_NODMA
+E8390_PAGE0
+E8390_START
, nic_base
+ NE_CMD
);
236 ei_outb(count
& 0xff, nic_base
+ EN0_RCNTLO
);
237 ei_outb(count
>> 8, nic_base
+ EN0_RCNTHI
);
238 ei_outb(ring_offset
& 0xff, nic_base
+ EN0_RSARLO
);
239 ei_outb(ring_offset
>> 8, nic_base
+ EN0_RSARHI
);
240 ei_outb(E8390_RREAD
+E8390_START
, nic_base
+ NE_CMD
);
242 if (ei_local
->word16
) {
243 readsw(nic_base
+ NE_DATAPORT
, buf
, count
>> 1);
245 buf
[count
-1] = ei_inb(nic_base
+ NE_DATAPORT
);
248 readsb(nic_base
+ NE_DATAPORT
, buf
, count
);
251 ei_local
->dmaing
&= ~1;
254 static void ax_block_output(struct net_device
*dev
, int count
,
255 const unsigned char *buf
, const int start_page
)
257 struct ei_device
*ei_local
= netdev_priv(dev
);
258 struct ax_device
*ax
= to_ax_dev(dev
);
259 void __iomem
*nic_base
= ei_local
->mem
;
260 unsigned long dma_start
;
263 * Round the count up for word writes. Do we need to do this?
264 * What effect will an odd byte count have on the 8390? I
265 * should check someday.
267 if (ei_local
->word16
&& (count
& 0x01))
270 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
271 if (ei_local
->dmaing
) {
272 dev_err(&ax
->dev
->dev
, "%s: DMAing conflict in %s."
273 "[DMAstat:%d][irqlock:%d]\n",
275 ei_local
->dmaing
, ei_local
->irqlock
);
279 ei_local
->dmaing
|= 0x01;
280 /* We should already be in page 0, but to be safe... */
281 ei_outb(E8390_PAGE0
+E8390_START
+E8390_NODMA
, nic_base
+ NE_CMD
);
283 ei_outb(ENISR_RDC
, nic_base
+ EN0_ISR
);
285 /* Now the normal output. */
286 ei_outb(count
& 0xff, nic_base
+ EN0_RCNTLO
);
287 ei_outb(count
>> 8, nic_base
+ EN0_RCNTHI
);
288 ei_outb(0x00, nic_base
+ EN0_RSARLO
);
289 ei_outb(start_page
, nic_base
+ EN0_RSARHI
);
291 ei_outb(E8390_RWRITE
+E8390_START
, nic_base
+ NE_CMD
);
292 if (ei_local
->word16
)
293 writesw(nic_base
+ NE_DATAPORT
, buf
, count
>> 1);
295 writesb(nic_base
+ NE_DATAPORT
, buf
, count
);
299 while ((ei_inb(nic_base
+ EN0_ISR
) & ENISR_RDC
) == 0) {
300 if (jiffies
- dma_start
> 2 * HZ
/ 100) { /* 20ms */
301 dev_warn(&ax
->dev
->dev
,
302 "%s: timeout waiting for Tx RDC.\n", dev
->name
);
304 ax_NS8390_init(dev
, 1);
309 ei_outb(ENISR_RDC
, nic_base
+ EN0_ISR
); /* Ack intr. */
310 ei_local
->dmaing
&= ~0x01;
313 /* definitions for accessing MII/EEPROM interface */
315 #define AX_MEMR EI_SHIFT(0x14)
316 #define AX_MEMR_MDC BIT(0)
317 #define AX_MEMR_MDIR BIT(1)
318 #define AX_MEMR_MDI BIT(2)
319 #define AX_MEMR_MDO BIT(3)
320 #define AX_MEMR_EECS BIT(4)
321 #define AX_MEMR_EEI BIT(5)
322 #define AX_MEMR_EEO BIT(6)
323 #define AX_MEMR_EECLK BIT(7)
328 * write the specified set of bits to the phy
331 ax_mii_ei_outbits(struct net_device
*dev
, unsigned int bits
, int len
)
333 struct ei_device
*ei_local
= netdev_priv(dev
);
334 void __iomem
*memr_addr
= (void __iomem
*)dev
->base_addr
+ AX_MEMR
;
337 /* clock low, data to output mode */
338 memr
= ei_inb(memr_addr
);
339 memr
&= ~(AX_MEMR_MDC
| AX_MEMR_MDIR
);
340 ei_outb(memr
, memr_addr
);
342 for (len
--; len
>= 0; len
--) {
343 if (bits
& (1 << len
))
346 memr
&= ~AX_MEMR_MDO
;
348 ei_outb(memr
, memr_addr
);
352 ei_outb(memr
| AX_MEMR_MDC
, memr_addr
);
356 ei_outb(memr
, memr_addr
);
359 /* leaves the clock line low, mdir input */
360 memr
|= AX_MEMR_MDIR
;
361 ei_outb(memr
, (void __iomem
*)dev
->base_addr
+ AX_MEMR
);
367 * read a specified number of bits from the phy
370 ax_phy_ei_inbits(struct net_device
*dev
, int no
)
372 struct ei_device
*ei_local
= netdev_priv(dev
);
373 void __iomem
*memr_addr
= (void __iomem
*)dev
->base_addr
+ AX_MEMR
;
375 unsigned int result
= 0;
377 /* clock low, data to input mode */
378 memr
= ei_inb(memr_addr
);
379 memr
&= ~AX_MEMR_MDC
;
380 memr
|= AX_MEMR_MDIR
;
381 ei_outb(memr
, memr_addr
);
383 for (no
--; no
>= 0; no
--) {
384 ei_outb(memr
| AX_MEMR_MDC
, memr_addr
);
388 if (ei_inb(memr_addr
) & AX_MEMR_MDI
)
391 ei_outb(memr
, memr_addr
);
400 * use the low level bit shifting routines to send the address
401 * and command to the specified phy
404 ax_phy_issueaddr(struct net_device
*dev
, int phy_addr
, int reg
, int opc
)
407 pr_debug("%s: dev %p, %04x, %04x, %d\n",
408 __func__
, dev
, phy_addr
, reg
, opc
);
410 ax_mii_ei_outbits(dev
, 0x3f, 6); /* pre-amble */
411 ax_mii_ei_outbits(dev
, 1, 2); /* frame-start */
412 ax_mii_ei_outbits(dev
, opc
, 2); /* op code */
413 ax_mii_ei_outbits(dev
, phy_addr
, 5); /* phy address */
414 ax_mii_ei_outbits(dev
, reg
, 5); /* reg address */
418 ax_phy_read(struct net_device
*dev
, int phy_addr
, int reg
)
420 struct ei_device
*ei_local
= netdev_priv(dev
);
424 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
426 ax_phy_issueaddr(dev
, phy_addr
, reg
, 2);
428 result
= ax_phy_ei_inbits(dev
, 17);
429 result
&= ~(3 << 16);
431 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
434 pr_debug("%s: %04x.%04x => read %04x\n", __func__
,
435 phy_addr
, reg
, result
);
441 ax_phy_write(struct net_device
*dev
, int phy_addr
, int reg
, int value
)
443 struct ei_device
*ei
= netdev_priv(dev
);
444 struct ax_device
*ax
= to_ax_dev(dev
);
447 dev_dbg(&ax
->dev
->dev
, "%s: %p, %04x, %04x %04x\n",
448 __func__
, dev
, phy_addr
, reg
, value
);
450 spin_lock_irqsave(&ei
->page_lock
, flags
);
452 ax_phy_issueaddr(dev
, phy_addr
, reg
, 1);
453 ax_mii_ei_outbits(dev
, 2, 2); /* send TA */
454 ax_mii_ei_outbits(dev
, value
, 16);
456 spin_unlock_irqrestore(&ei
->page_lock
, flags
);
459 static void ax_mii_expiry(unsigned long data
)
461 struct net_device
*dev
= (struct net_device
*)data
;
462 struct ax_device
*ax
= to_ax_dev(dev
);
465 spin_lock_irqsave(&ax
->mii_lock
, flags
);
466 mii_check_media(&ax
->mii
, netif_msg_link(ax
), 0);
467 spin_unlock_irqrestore(&ax
->mii_lock
, flags
);
470 ax
->mii_timer
.expires
= jiffies
+ HZ
*2;
471 add_timer(&ax
->mii_timer
);
475 static int ax_open(struct net_device
*dev
)
477 struct ax_device
*ax
= to_ax_dev(dev
);
478 struct ei_device
*ei_local
= netdev_priv(dev
);
481 dev_dbg(&ax
->dev
->dev
, "%s: open\n", dev
->name
);
483 ret
= request_irq(dev
->irq
, ax_ei_interrupt
, ax
->irqflags
,
488 ret
= ax_ei_open(dev
);
490 free_irq(dev
->irq
, dev
);
494 /* turn the phy on (if turned off) */
496 ei_outb(ax
->plat
->gpoc_val
, ei_local
->mem
+ EI_SHIFT(0x17));
499 /* start the MII timer */
501 init_timer(&ax
->mii_timer
);
503 ax
->mii_timer
.expires
= jiffies
+ 1;
504 ax
->mii_timer
.data
= (unsigned long) dev
;
505 ax
->mii_timer
.function
= ax_mii_expiry
;
507 add_timer(&ax
->mii_timer
);
512 static int ax_close(struct net_device
*dev
)
514 struct ax_device
*ax
= to_ax_dev(dev
);
515 struct ei_device
*ei_local
= netdev_priv(dev
);
517 dev_dbg(&ax
->dev
->dev
, "%s: close\n", dev
->name
);
519 /* turn the phy off */
521 ei_outb(ax
->plat
->gpoc_val
| (1 << 6),
522 ei_local
->mem
+ EI_SHIFT(0x17));
527 del_timer_sync(&ax
->mii_timer
);
530 free_irq(dev
->irq
, dev
);
534 static int ax_ioctl(struct net_device
*dev
, struct ifreq
*req
, int cmd
)
536 struct ax_device
*ax
= to_ax_dev(dev
);
540 if (!netif_running(dev
))
543 spin_lock_irqsave(&ax
->mii_lock
, flags
);
544 rc
= generic_mii_ioctl(&ax
->mii
, if_mii(req
), cmd
, NULL
);
545 spin_unlock_irqrestore(&ax
->mii_lock
, flags
);
552 static void ax_get_drvinfo(struct net_device
*dev
,
553 struct ethtool_drvinfo
*info
)
555 struct ax_device
*ax
= to_ax_dev(dev
);
557 strcpy(info
->driver
, DRV_NAME
);
558 strcpy(info
->version
, DRV_VERSION
);
559 strcpy(info
->bus_info
, ax
->dev
->name
);
562 static int ax_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
564 struct ax_device
*ax
= to_ax_dev(dev
);
567 spin_lock_irqsave(&ax
->mii_lock
, flags
);
568 mii_ethtool_gset(&ax
->mii
, cmd
);
569 spin_unlock_irqrestore(&ax
->mii_lock
, flags
);
574 static int ax_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
576 struct ax_device
*ax
= to_ax_dev(dev
);
580 spin_lock_irqsave(&ax
->mii_lock
, flags
);
581 rc
= mii_ethtool_sset(&ax
->mii
, cmd
);
582 spin_unlock_irqrestore(&ax
->mii_lock
, flags
);
587 static int ax_nway_reset(struct net_device
*dev
)
589 struct ax_device
*ax
= to_ax_dev(dev
);
590 return mii_nway_restart(&ax
->mii
);
593 static u32
ax_get_link(struct net_device
*dev
)
595 struct ax_device
*ax
= to_ax_dev(dev
);
596 return mii_link_ok(&ax
->mii
);
599 static const struct ethtool_ops ax_ethtool_ops
= {
600 .get_drvinfo
= ax_get_drvinfo
,
601 .get_settings
= ax_get_settings
,
602 .set_settings
= ax_set_settings
,
603 .nway_reset
= ax_nway_reset
,
604 .get_link
= ax_get_link
,
607 #ifdef CONFIG_AX88796_93CX6
608 static void ax_eeprom_register_read(struct eeprom_93cx6
*eeprom
)
610 struct ei_device
*ei_local
= eeprom
->data
;
611 u8 reg
= ei_inb(ei_local
->mem
+ AX_MEMR
);
613 eeprom
->reg_data_in
= reg
& AX_MEMR_EEI
;
614 eeprom
->reg_data_out
= reg
& AX_MEMR_EEO
; /* Input pin */
615 eeprom
->reg_data_clock
= reg
& AX_MEMR_EECLK
;
616 eeprom
->reg_chip_select
= reg
& AX_MEMR_EECS
;
619 static void ax_eeprom_register_write(struct eeprom_93cx6
*eeprom
)
621 struct ei_device
*ei_local
= eeprom
->data
;
622 u8 reg
= ei_inb(ei_local
->mem
+ AX_MEMR
);
624 reg
&= ~(AX_MEMR_EEI
| AX_MEMR_EECLK
| AX_MEMR_EECS
);
626 if (eeprom
->reg_data_in
)
628 if (eeprom
->reg_data_clock
)
629 reg
|= AX_MEMR_EECLK
;
630 if (eeprom
->reg_chip_select
)
633 ei_outb(reg
, ei_local
->mem
+ AX_MEMR
);
638 static const struct net_device_ops ax_netdev_ops
= {
640 .ndo_stop
= ax_close
,
641 .ndo_do_ioctl
= ax_ioctl
,
643 .ndo_start_xmit
= ax_ei_start_xmit
,
644 .ndo_tx_timeout
= ax_ei_tx_timeout
,
645 .ndo_get_stats
= ax_ei_get_stats
,
646 .ndo_set_multicast_list
= ax_ei_set_multicast_list
,
647 .ndo_validate_addr
= eth_validate_addr
,
648 .ndo_set_mac_address
= eth_mac_addr
,
649 .ndo_change_mtu
= eth_change_mtu
,
650 #ifdef CONFIG_NET_POLL_CONTROLLER
651 .ndo_poll_controller
= ax_ei_poll
,
657 static void ax_initial_setup(struct net_device
*dev
, struct ei_device
*ei_local
)
659 void __iomem
*ioaddr
= ei_local
->mem
;
660 struct ax_device
*ax
= to_ax_dev(dev
);
663 ei_outb(E8390_NODMA
+ E8390_PAGE0
+ E8390_STOP
, ioaddr
+ E8390_CMD
);
665 /* set to byte access */
666 ei_outb(ax
->plat
->dcr_val
& ~1, ioaddr
+ EN0_DCFG
);
667 ei_outb(ax
->plat
->gpoc_val
, ioaddr
+ EI_SHIFT(0x17));
673 * initialise the specified device, taking care to note the MAC
674 * address it may already have (if configured), ensure
675 * the device is ready to be used by lib8390.c and registerd with
678 static int ax_init_dev(struct net_device
*dev
, int first_init
)
680 struct ei_device
*ei_local
= netdev_priv(dev
);
681 struct ax_device
*ax
= to_ax_dev(dev
);
682 void __iomem
*ioaddr
= ei_local
->mem
;
683 unsigned int start_page
;
684 unsigned int stop_page
;
688 ret
= ax_initial_check(dev
);
692 /* setup goes here */
694 ax_initial_setup(dev
, ei_local
);
696 /* read the mac from the card prom if we need it */
698 if (first_init
&& ax
->plat
->flags
& AXFLG_HAS_EEPROM
) {
699 unsigned char SA_prom
[32];
701 for (i
= 0; i
< sizeof(SA_prom
); i
+= 2) {
702 SA_prom
[i
] = ei_inb(ioaddr
+ NE_DATAPORT
);
703 SA_prom
[i
+ 1] = ei_inb(ioaddr
+ NE_DATAPORT
);
706 if (ax
->plat
->wordlength
== 2)
707 for (i
= 0; i
< 16; i
++)
708 SA_prom
[i
] = SA_prom
[i
+i
];
710 memcpy(dev
->dev_addr
, SA_prom
, 6);
713 #ifdef CONFIG_AX88796_93CX6
714 if (first_init
&& ax
->plat
->flags
& AXFLG_HAS_93CX6
) {
715 unsigned char mac_addr
[6];
716 struct eeprom_93cx6 eeprom
;
718 eeprom
.data
= ei_local
;
719 eeprom
.register_read
= ax_eeprom_register_read
;
720 eeprom
.register_write
= ax_eeprom_register_write
;
721 eeprom
.width
= PCI_EEPROM_WIDTH_93C56
;
723 eeprom_93cx6_multiread(&eeprom
, 0,
724 (__le16 __force
*)mac_addr
,
725 sizeof(mac_addr
) >> 1);
727 memcpy(dev
->dev_addr
, mac_addr
, 6);
730 if (ax
->plat
->wordlength
== 2) {
731 /* We must set the 8390 for word mode. */
732 ei_outb(ax
->plat
->dcr_val
, ei_local
->mem
+ EN0_DCFG
);
733 start_page
= NESM_START_PG
;
734 stop_page
= NESM_STOP_PG
;
736 start_page
= NE1SM_START_PG
;
737 stop_page
= NE1SM_STOP_PG
;
741 * load the mac-address from the device if this is the first
742 * time we've initialised
745 if (ax
->plat
->flags
& AXFLG_MAC_FROMDEV
) {
746 ei_outb(E8390_NODMA
+ E8390_PAGE1
+ E8390_STOP
,
747 ei_local
->mem
+ E8390_CMD
); /* 0x61 */
748 for (i
= 0; i
< ETHER_ADDR_LEN
; i
++)
750 ei_inb(ioaddr
+ EN1_PHYS_SHIFT(i
));
753 if ((ax
->plat
->flags
& AXFLG_MAC_FROMPLATFORM
) &&
755 memcpy(dev
->dev_addr
, ax
->plat
->mac_addr
,
761 ei_local
->name
= "AX88796";
762 ei_local
->tx_start_page
= start_page
;
763 ei_local
->stop_page
= stop_page
;
764 ei_local
->word16
= (ax
->plat
->wordlength
== 2);
765 ei_local
->rx_start_page
= start_page
+ TX_PAGES
;
767 #ifdef PACKETBUF_MEMSIZE
768 /* Allow the packet buffer size to be overridden by know-it-alls. */
769 ei_local
->stop_page
= ei_local
->tx_start_page
+ PACKETBUF_MEMSIZE
;
772 ei_local
->reset_8390
= &ax_reset_8390
;
773 ei_local
->block_input
= &ax_block_input
;
774 ei_local
->block_output
= &ax_block_output
;
775 ei_local
->get_8390_hdr
= &ax_get_8390_hdr
;
778 dev
->netdev_ops
= &ax_netdev_ops
;
779 dev
->ethtool_ops
= &ax_ethtool_ops
;
781 ax
->msg_enable
= NETIF_MSG_LINK
;
782 ax
->mii
.phy_id_mask
= 0x1f;
783 ax
->mii
.reg_num_mask
= 0x1f;
784 ax
->mii
.phy_id
= 0x10; /* onboard phy */
785 ax
->mii
.force_media
= 0;
786 ax
->mii
.full_duplex
= 0;
787 ax
->mii
.mdio_read
= ax_phy_read
;
788 ax
->mii
.mdio_write
= ax_phy_write
;
791 ax_NS8390_init(dev
, 0);
794 dev_info(&ax
->dev
->dev
, "%dbit, irq %d, %lx, MAC: %pM\n",
795 ei_local
->word16
? 16 : 8, dev
->irq
, dev
->base_addr
,
798 ret
= register_netdev(dev
);
806 free_irq(dev
->irq
, dev
);
811 static int ax_remove(struct platform_device
*_dev
)
813 struct net_device
*dev
= platform_get_drvdata(_dev
);
814 struct ei_device
*ei_local
= netdev_priv(dev
);
815 struct ax_device
*ax
;
819 unregister_netdev(dev
);
820 free_irq(dev
->irq
, dev
);
822 iounmap(ei_local
->mem
);
823 release_resource(ax
->mem
);
828 release_resource(ax
->mem2
);
840 * This is the entry point when the platform device system uses to
841 * notify us of a new device to attach to. Allocate memory, find the
842 * resources and information passed, and map the necessary registers.
844 static int ax_probe(struct platform_device
*pdev
)
846 struct net_device
*dev
;
847 struct ei_device
*ei_local
;
848 struct ax_device
*ax
;
849 struct resource
*res
;
853 dev
= ax__alloc_ei_netdev(sizeof(struct ax_device
));
857 /* ok, let's setup our device */
858 ei_local
= netdev_priv(dev
);
861 memset(ax
, 0, sizeof(struct ax_device
));
863 spin_lock_init(&ax
->mii_lock
);
866 ax
->plat
= pdev
->dev
.platform_data
;
867 platform_set_drvdata(pdev
, dev
);
869 ei_local
->rxcr_base
= ax
->plat
->rcr_val
;
871 /* find the platform resources */
872 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
874 dev_err(&pdev
->dev
, "no IRQ specified\n");
879 dev
->irq
= res
->start
;
880 ax
->irqflags
= res
->flags
& IRQF_TRIGGER_MASK
;
882 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
884 dev_err(&pdev
->dev
, "no MEM specified\n");
889 size
= (res
->end
- res
->start
) + 1;
892 * setup the register offsets from either the platform data or
893 * by using the size of the resource provided
895 if (ax
->plat
->reg_offsets
)
896 ei_local
->reg_offset
= ax
->plat
->reg_offsets
;
898 ei_local
->reg_offset
= ax
->reg_offsets
;
899 for (ret
= 0; ret
< 0x18; ret
++)
900 ax
->reg_offsets
[ret
] = (size
/ 0x18) * ret
;
903 ax
->mem
= request_mem_region(res
->start
, size
, pdev
->name
);
904 if (ax
->mem
== NULL
) {
905 dev_err(&pdev
->dev
, "cannot reserve registers\n");
910 ei_local
->mem
= ioremap(res
->start
, size
);
911 dev
->base_addr
= (unsigned long)ei_local
->mem
;
913 if (ei_local
->mem
== NULL
) {
914 dev_err(&pdev
->dev
, "Cannot ioremap area (%08llx,%08llx)\n",
915 (unsigned long long)res
->start
,
916 (unsigned long long)res
->end
);
922 /* look for reset area */
924 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
926 if (!ax
->plat
->reg_offsets
) {
927 for (ret
= 0; ret
< 0x20; ret
++)
928 ax
->reg_offsets
[ret
] = (size
/ 0x20) * ret
;
933 size
= (res
->end
- res
->start
) + 1;
935 ax
->mem2
= request_mem_region(res
->start
, size
, pdev
->name
);
936 if (ax
->mem2
== NULL
) {
937 dev_err(&pdev
->dev
, "cannot reserve registers\n");
942 ax
->map2
= ioremap(res
->start
, size
);
943 if (ax
->map2
== NULL
) {
944 dev_err(&pdev
->dev
, "cannot map reset register\n");
949 ei_local
->reg_offset
[0x1f] = ax
->map2
- ei_local
->mem
;
952 /* got resources, now initialise and register device */
954 ret
= ax_init_dev(dev
, 1);
958 if (ax
->map2
== NULL
)
964 release_resource(ax
->mem2
);
968 iounmap(ei_local
->mem
);
971 release_resource(ax
->mem
);
980 /* suspend and resume */
983 static int ax_suspend(struct platform_device
*dev
, pm_message_t state
)
985 struct net_device
*ndev
= platform_get_drvdata(dev
);
986 struct ax_device
*ax
= to_ax_dev(ndev
);
988 ax
->resume_open
= ax
->running
;
990 netif_device_detach(ndev
);
996 static int ax_resume(struct platform_device
*pdev
)
998 struct net_device
*ndev
= platform_get_drvdata(pdev
);
999 struct ax_device
*ax
= to_ax_dev(ndev
);
1001 ax_initial_setup(ndev
, netdev_priv(ndev
));
1002 ax_NS8390_init(ndev
, ax
->resume_open
);
1003 netif_device_attach(ndev
);
1005 if (ax
->resume_open
)
1012 #define ax_suspend NULL
1013 #define ax_resume NULL
1016 static struct platform_driver axdrv
= {
1019 .owner
= THIS_MODULE
,
1022 .remove
= ax_remove
,
1023 .suspend
= ax_suspend
,
1024 .resume
= ax_resume
,
1027 static int __init
axdrv_init(void)
1029 return platform_driver_register(&axdrv
);
1032 static void __exit
axdrv_exit(void)
1034 platform_driver_unregister(&axdrv
);
1037 module_init(axdrv_init
);
1038 module_exit(axdrv_exit
);
1040 MODULE_DESCRIPTION("AX88796 10/100 Ethernet platform driver");
1041 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
1042 MODULE_LICENSE("GPL v2");
1043 MODULE_ALIAS("platform:ax88796");