AX88796 network driver
[linux-2.6.git] / drivers / net / ax88796.c
1 /* drivers/net/ax88796.c
2  *
3  * Copyright 2005,2007 Simtec Electronics
4  *      Ben Dooks <ben@simtec.co.uk>
5  *
6  * Asix AX88796 10/100 Ethernet controller support
7  *      Based on ne.c, by Donald Becker, et-al.
8  *
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.
12 */
13
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>
20 #include <linux/platform_device.h>
21 #include <linux/delay.h>
22 #include <linux/timer.h>
23 #include <linux/netdevice.h>
24 #include <linux/etherdevice.h>
25 #include <linux/ethtool.h>
26 #include <linux/mii.h>
27
28 #include <net/ax88796.h>
29
30 #include <asm/system.h>
31 #include <asm/io.h>
32
33 static int phy_debug = 0;
34
35 /* Rename the lib8390.c functions to show that they are in this driver */
36 #define __ei_open       ax_ei_open
37 #define __ei_close      ax_ei_close
38 #define __ei_poll       ax_ei_poll
39 #define __ei_tx_timeout ax_ei_tx_timeout
40 #define __ei_interrupt  ax_ei_interrupt
41 #define ____alloc_ei_netdev ax__alloc_ei_netdev
42 #define __NS8390_init   ax_NS8390_init
43
44 /* force unsigned long back to 'void __iomem *' */
45 #define ax_convert_addr(_a) ((void __force __iomem *)(_a))
46
47 #define ei_inb(_a)      readb(ax_convert_addr(_a))
48 #define ei_outb(_v, _a) writeb(_v, ax_convert_addr(_a))
49
50 #define ei_inb_p(_a)    ei_inb(_a)
51 #define ei_outb_p(_v, _a) ei_outb(_v, _a)
52
53 /* define EI_SHIFT() to take into account our register offsets */
54 #define EI_SHIFT(x)     (ei_local->reg_offset[(x)])
55
56 /* Ensure we have our RCR base value */
57 #define AX88796_PLATFORM
58
59 static unsigned char version[] = "ax88796.c: Copyright 2005,2007 Simtec Electronics\n";
60
61 #include "lib8390.c"
62
63 #define DRV_NAME "ax88796"
64 #define DRV_VERSION "1.00"
65
66 /* from ne.c */
67 #define NE_CMD          EI_SHIFT(0x00)
68 #define NE_RESET        EI_SHIFT(0x1f)
69 #define NE_DATAPORT     EI_SHIFT(0x10)
70
71 #define NE1SM_START_PG  0x20    /* First page of TX buffer */
72 #define NE1SM_STOP_PG   0x40    /* Last page +1 of RX ring */
73 #define NESM_START_PG   0x40    /* First page of TX buffer */
74 #define NESM_STOP_PG    0x80    /* Last page +1 of RX ring */
75
76 /* device private data */
77
78 struct ax_device {
79         struct timer_list        mii_timer;
80         spinlock_t               mii_lock;
81         struct mii_if_info       mii;
82
83         u32                      msg_enable;
84         void __iomem            *map2;
85         struct platform_device  *dev;
86         struct resource         *mem;
87         struct resource         *mem2;
88         struct ax_plat_data     *plat;
89
90         unsigned char            running;
91         unsigned char            resume_open;
92
93         u32                      reg_offsets[0x20];
94 };
95
96 static inline struct ax_device *to_ax_dev(struct net_device *dev)
97 {
98         struct ei_device *ei_local = netdev_priv(dev);
99         return (struct ax_device *)(ei_local+1);
100 }
101
102 /* ax_initial_check
103  *
104  * do an initial probe for the card to check wether it exists
105  * and is functional
106  */
107
108 static int ax_initial_check(struct net_device *dev)
109 {
110         struct ei_device *ei_local = netdev_priv(dev);
111         void __iomem *ioaddr = ei_local->mem;
112         int reg0;
113         int regd;
114
115         reg0 = ei_inb(ioaddr);
116         if (reg0 == 0xFF)
117                 return -ENODEV;
118
119         ei_outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, ioaddr + E8390_CMD);
120         regd = ei_inb(ioaddr + 0x0d);
121         ei_outb(0xff, ioaddr + 0x0d);
122         ei_outb(E8390_NODMA+E8390_PAGE0, ioaddr + E8390_CMD);
123         ei_inb(ioaddr + EN0_COUNTER0); /* Clear the counter by reading. */
124         if (ei_inb(ioaddr + EN0_COUNTER0) != 0) {
125                 ei_outb(reg0, ioaddr);
126                 ei_outb(regd, ioaddr + 0x0d);   /* Restore the old values. */
127                 return -ENODEV;
128         }
129
130         return 0;
131 }
132
133 /* Hard reset the card.  This used to pause for the same period that a
134    8390 reset command required, but that shouldn't be necessary. */
135
136 static void ax_reset_8390(struct net_device *dev)
137 {
138         struct ei_device *ei_local = netdev_priv(dev);
139         unsigned long reset_start_time = jiffies;
140         void __iomem *addr = (void __iomem *)dev->base_addr;
141
142         if (ei_debug > 1)
143                 printk(KERN_DEBUG "resetting the 8390 t=%ld...", jiffies);
144
145         ei_outb(ei_inb(addr + NE_RESET), addr + NE_RESET);
146
147         ei_status.txing = 0;
148         ei_status.dmaing = 0;
149
150         /* This check _should_not_ be necessary, omit eventually. */
151         while ((ei_inb(addr + EN0_ISR) & ENISR_RESET) == 0) {
152                 if (jiffies - reset_start_time > 2*HZ/100) {
153                         printk(KERN_WARNING "%s: %s did not complete.\n",
154                                __FUNCTION__, dev->name);
155                         break;
156                 }
157         }
158
159         ei_outb(ENISR_RESET, addr + EN0_ISR);   /* Ack intr. */
160 }
161
162
163 static void ax_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
164                             int ring_page)
165 {
166         struct ei_device *ei_local = netdev_priv(dev);
167         void __iomem *nic_base = ei_local->mem;
168
169         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
170         if (ei_status.dmaing) {
171                 printk(KERN_EMERG "%s: DMAing conflict in %s [DMAstat:%d][irqlock:%d].\n",
172                         dev->name, __FUNCTION__,
173                        ei_status.dmaing, ei_status.irqlock);
174                 return;
175         }
176
177         ei_status.dmaing |= 0x01;
178         ei_outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
179         ei_outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
180         ei_outb(0, nic_base + EN0_RCNTHI);
181         ei_outb(0, nic_base + EN0_RSARLO);              /* On page boundary */
182         ei_outb(ring_page, nic_base + EN0_RSARHI);
183         ei_outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
184
185         if (ei_status.word16)
186                 readsw(nic_base + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
187         else
188                 readsb(nic_base + NE_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr));
189
190         ei_outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
191         ei_status.dmaing &= ~0x01;
192
193         le16_to_cpus(&hdr->count);
194 }
195
196
197 /* Block input and output, similar to the Crynwr packet driver.  If you
198    are porting to a new ethercard, look at the packet driver source for hints.
199    The NEx000 doesn't share the on-board packet memory -- you have to put
200    the packet out through the "remote DMA" dataport using ei_outb. */
201
202 static void ax_block_input(struct net_device *dev, int count,
203                            struct sk_buff *skb, int ring_offset)
204 {
205         struct ei_device *ei_local = netdev_priv(dev);
206         void __iomem *nic_base = ei_local->mem;
207         char *buf = skb->data;
208
209         if (ei_status.dmaing) {
210                 printk(KERN_EMERG "%s: DMAing conflict in ax_block_input "
211                         "[DMAstat:%d][irqlock:%d].\n",
212                         dev->name, ei_status.dmaing, ei_status.irqlock);
213                 return;
214         }
215
216         ei_status.dmaing |= 0x01;
217
218         ei_outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
219         ei_outb(count & 0xff, nic_base + EN0_RCNTLO);
220         ei_outb(count >> 8, nic_base + EN0_RCNTHI);
221         ei_outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
222         ei_outb(ring_offset >> 8, nic_base + EN0_RSARHI);
223         ei_outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
224
225         if (ei_status.word16) {
226                 readsw(nic_base + NE_DATAPORT, buf, count >> 1);
227                 if (count & 0x01)
228                         buf[count-1] = ei_inb(nic_base + NE_DATAPORT);
229
230         } else {
231                 readsb(nic_base + NE_DATAPORT, buf, count);
232         }
233
234         ei_status.dmaing &= ~1;
235 }
236
237 static void ax_block_output(struct net_device *dev, int count,
238                             const unsigned char *buf, const int start_page)
239 {
240         struct ei_device *ei_local = netdev_priv(dev);
241         void __iomem *nic_base = ei_local->mem;
242         unsigned long dma_start;
243
244         /* Round the count up for word writes.  Do we need to do this?
245            What effect will an odd byte count have on the 8390?
246            I should check someday. */
247
248         if (ei_status.word16 && (count & 0x01))
249                 count++;
250
251         /* This *shouldn't* happen. If it does, it's the last thing you'll see */
252         if (ei_status.dmaing) {
253                 printk(KERN_EMERG "%s: DMAing conflict in %s."
254                         "[DMAstat:%d][irqlock:%d]\n",
255                         dev->name, __FUNCTION__,
256                        ei_status.dmaing, ei_status.irqlock);
257                 return;
258         }
259
260         ei_status.dmaing |= 0x01;
261         /* We should already be in page 0, but to be safe... */
262         ei_outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
263
264         ei_outb(ENISR_RDC, nic_base + EN0_ISR);
265
266         /* Now the normal output. */
267         ei_outb(count & 0xff, nic_base + EN0_RCNTLO);
268         ei_outb(count >> 8,   nic_base + EN0_RCNTHI);
269         ei_outb(0x00, nic_base + EN0_RSARLO);
270         ei_outb(start_page, nic_base + EN0_RSARHI);
271
272         ei_outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
273         if (ei_status.word16) {
274                 writesw(nic_base + NE_DATAPORT, buf, count>>1);
275         } else {
276                 writesb(nic_base + NE_DATAPORT, buf, count);
277         }
278
279         dma_start = jiffies;
280
281         while ((ei_inb(nic_base + EN0_ISR) & ENISR_RDC) == 0) {
282                 if (jiffies - dma_start > 2*HZ/100) {           /* 20ms */
283                         printk(KERN_WARNING "%s: timeout waiting for Tx RDC.\n", dev->name);
284                         ax_reset_8390(dev);
285                         ax_NS8390_init(dev,1);
286                         break;
287                 }
288         }
289
290         ei_outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
291         ei_status.dmaing &= ~0x01;
292         return;
293 }
294
295 /* definitions for accessing MII/EEPROM interface */
296
297 #define AX_MEMR                 EI_SHIFT(0x14)
298 #define AX_MEMR_MDC             (1<<0)
299 #define AX_MEMR_MDIR            (1<<1)
300 #define AX_MEMR_MDI             (1<<2)
301 #define AX_MEMR_MDO             (1<<3)
302 #define AX_MEMR_EECS            (1<<4)
303 #define AX_MEMR_EEI             (1<<5)
304 #define AX_MEMR_EEO             (1<<6)
305 #define AX_MEMR_EECLK           (1<<7)
306
307 /* ax_mii_ei_outbits
308  *
309  * write the specified set of bits to the phy
310 */
311
312 static void
313 ax_mii_ei_outbits(struct net_device *dev, unsigned int bits, int len)
314 {
315         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
316         void __iomem *memr_addr = (void __iomem *)dev->base_addr + AX_MEMR;
317         unsigned int memr;
318
319         /* clock low, data to output mode */
320         memr = ei_inb(memr_addr);
321         memr &= ~(AX_MEMR_MDC | AX_MEMR_MDIR);
322         ei_outb(memr, memr_addr);
323
324         for (len--; len >= 0; len--) {
325                 if (bits & (1 << len))
326                         memr |= AX_MEMR_MDO;
327                 else
328                         memr &= ~AX_MEMR_MDO;
329
330                 ei_outb(memr, memr_addr);
331
332                 /* clock high */
333
334                 ei_outb(memr | AX_MEMR_MDC, memr_addr);
335                 udelay(1);
336
337                 /* clock low */
338                 ei_outb(memr, memr_addr);
339         }
340
341         /* leaves the clock line low, mdir input */
342         memr |= AX_MEMR_MDIR;
343         ei_outb(memr, (void __iomem *)dev->base_addr + AX_MEMR);
344 }
345
346 /* ax_phy_ei_inbits
347  *
348  * read a specified number of bits from the phy
349 */
350
351 static unsigned int
352 ax_phy_ei_inbits(struct net_device *dev, int no)
353 {
354         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
355         void __iomem *memr_addr = (void __iomem *)dev->base_addr + AX_MEMR;
356         unsigned int memr;
357         unsigned int result = 0;
358
359         /* clock low, data to input mode */
360         memr = ei_inb(memr_addr);
361         memr &= ~AX_MEMR_MDC;
362         memr |= AX_MEMR_MDIR;
363         ei_outb(memr, memr_addr);
364
365         for (no--; no >= 0; no--) {
366                 ei_outb(memr | AX_MEMR_MDC, memr_addr);
367
368                 udelay(1);
369
370                 if (ei_inb(memr_addr) & AX_MEMR_MDI)
371                         result |= (1<<no);
372
373                 ei_outb(memr, memr_addr);
374         }
375
376         return result;
377 }
378
379 /* ax_phy_issueaddr
380  *
381  * use the low level bit shifting routines to send the address
382  * and command to the specified phy
383 */
384
385 static void
386 ax_phy_issueaddr(struct net_device *dev, int phy_addr, int reg, int opc)
387 {
388         if (phy_debug)
389                 pr_debug("%s: dev %p, %04x, %04x, %d\n",
390                         __FUNCTION__, dev, phy_addr, reg, opc);
391
392         ax_mii_ei_outbits(dev, 0x3f, 6);        /* pre-amble */
393         ax_mii_ei_outbits(dev, 1, 2);           /* frame-start */
394         ax_mii_ei_outbits(dev, opc, 2);         /* op code */
395         ax_mii_ei_outbits(dev, phy_addr, 5);    /* phy address */
396         ax_mii_ei_outbits(dev, reg, 5);         /* reg address */
397 }
398
399 static int
400 ax_phy_read(struct net_device *dev, int phy_addr, int reg)
401 {
402         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
403         unsigned long flags;
404         unsigned int result;
405
406         spin_lock_irqsave(&ei_local->page_lock, flags);
407
408         ax_phy_issueaddr(dev, phy_addr, reg, 2);
409
410         result = ax_phy_ei_inbits(dev, 17);
411         result &= ~(3<<16);
412
413         spin_unlock_irqrestore(&ei_local->page_lock, flags);
414
415         if (phy_debug)
416                 pr_debug("%s: %04x.%04x => read %04x\n", __FUNCTION__,
417                          phy_addr, reg, result);
418
419         return result;
420 }
421
422 static void
423 ax_phy_write(struct net_device *dev, int phy_addr, int reg, int value)
424 {
425         struct ei_device *ei = (struct ei_device *) netdev_priv(dev);
426         unsigned long flags;
427
428         printk(KERN_DEBUG "%s: %p, %04x, %04x %04x\n",
429                __FUNCTION__, dev, phy_addr, reg, value);
430
431         spin_lock_irqsave(&ei->page_lock, flags);
432
433         ax_phy_issueaddr(dev, phy_addr, reg, 1);
434         ax_mii_ei_outbits(dev, 2, 2);           /* send TA */
435         ax_mii_ei_outbits(dev, value, 16);
436
437         spin_unlock_irqrestore(&ei->page_lock, flags);
438 }
439
440 static void ax_mii_expiry(unsigned long data)
441 {
442         struct net_device *dev = (struct net_device *)data;
443         struct ax_device  *ax = to_ax_dev(dev);
444         unsigned long flags;
445
446         spin_lock_irqsave(&ax->mii_lock, flags);
447         mii_check_media(&ax->mii, netif_msg_link(ax), 0);
448         spin_unlock_irqrestore(&ax->mii_lock, flags);
449
450         if (ax->running) {
451                 ax->mii_timer.expires = jiffies + HZ*2;
452                 add_timer(&ax->mii_timer);
453         }
454 }
455
456 static int ax_open(struct net_device *dev)
457 {
458         struct ax_device  *ax = to_ax_dev(dev);
459         struct ei_device *ei_local = netdev_priv(dev);
460         int ret;
461
462         dev_dbg(ax->dev, "%s: open\n", dev->name);
463
464         ret = request_irq(dev->irq, ax_ei_interrupt, 0, dev->name, dev);
465         if (ret)
466                 return ret;
467
468         ret = ax_ei_open(dev);
469         if (ret)
470                 return ret;
471
472         /* turn the phy on (if turned off) */
473
474         ei_outb(ax->plat->gpoc_val, ei_local->mem + EI_SHIFT(0x17));
475         ax->running = 1;
476
477         /* start the MII timer */
478
479         init_timer(&ax->mii_timer);
480
481         ax->mii_timer.expires  = jiffies+1;
482         ax->mii_timer.data     = (unsigned long) dev;
483         ax->mii_timer.function = ax_mii_expiry;
484
485         add_timer(&ax->mii_timer);
486
487         return 0;
488 }
489
490 static int ax_close(struct net_device *dev)
491 {
492         struct ax_device *ax = to_ax_dev(dev);
493         struct ei_device *ei_local = netdev_priv(dev);
494
495         dev_dbg(ax->dev, "%s: close\n", dev->name);
496
497         /* turn the phy off */
498
499         ei_outb(ax->plat->gpoc_val | (1<<6),
500                ei_local->mem + EI_SHIFT(0x17));
501
502         ax->running = 0;
503         wmb();
504
505         del_timer_sync(&ax->mii_timer);
506         ax_ei_close(dev);
507
508         free_irq(dev->irq, dev);
509         return 0;
510 }
511
512 static int ax_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
513 {
514         struct ax_device *ax = to_ax_dev(dev);
515         unsigned long flags;
516         int rc;
517
518         if (!netif_running(dev))
519                 return -EINVAL;
520
521         spin_lock_irqsave(&ax->mii_lock, flags);
522         rc = generic_mii_ioctl(&ax->mii, if_mii(req), cmd, NULL);
523         spin_unlock_irqrestore(&ax->mii_lock, flags);
524
525         return rc;
526 }
527
528 /* ethtool ops */
529
530 static void ax_get_drvinfo(struct net_device *dev,
531                            struct ethtool_drvinfo *info)
532 {
533         struct ax_device *ax = to_ax_dev(dev);
534
535         strcpy(info->driver, DRV_NAME);
536         strcpy(info->version, DRV_VERSION);
537         strcpy(info->bus_info, ax->dev->name);
538 }
539
540 static int ax_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
541 {
542         struct ax_device *ax = to_ax_dev(dev);
543         unsigned long flags;
544
545         spin_lock_irqsave(&ax->mii_lock, flags);
546         mii_ethtool_gset(&ax->mii, cmd);
547         spin_lock_irqsave(&ax->mii_lock, flags);
548
549         return 0;
550 }
551
552 static int ax_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
553 {
554         struct ax_device *ax = to_ax_dev(dev);
555         unsigned long flags;
556         int rc;
557
558         spin_lock_irqsave(&ax->mii_lock, flags);
559         rc = mii_ethtool_sset(&ax->mii, cmd);
560         spin_lock_irqsave(&ax->mii_lock, flags);
561
562         return rc;
563 }
564
565 static int ax_nway_reset(struct net_device *dev)
566 {
567         struct ax_device *ax = to_ax_dev(dev);
568         return mii_nway_restart(&ax->mii);
569 }
570
571 static u32 ax_get_link(struct net_device *dev)
572 {
573         struct ax_device *ax = to_ax_dev(dev);
574         return mii_link_ok(&ax->mii);
575 }
576
577 static const struct ethtool_ops ax_ethtool_ops = {
578         .get_drvinfo            = ax_get_drvinfo,
579         .get_settings           = ax_get_settings,
580         .set_settings           = ax_set_settings,
581         .nway_reset             = ax_nway_reset,
582         .get_link               = ax_get_link,
583         .get_perm_addr          = ethtool_op_get_perm_addr,
584 };
585
586 /* setup code */
587
588 static void ax_initial_setup(struct net_device *dev, struct ei_device *ei_local)
589 {
590         void __iomem *ioaddr = ei_local->mem;
591         struct ax_device *ax = to_ax_dev(dev);
592
593         /* Select page 0*/
594         ei_outb(E8390_NODMA+E8390_PAGE0+E8390_STOP, ioaddr + E8390_CMD);
595
596         /* set to byte access */
597         ei_outb(ax->plat->dcr_val & ~1, ioaddr + EN0_DCFG);
598         ei_outb(ax->plat->gpoc_val, ioaddr + EI_SHIFT(0x17));
599 }
600
601 /* ax_init_dev
602  *
603  * initialise the specified device, taking care to note the MAC
604  * address it may already have (if configured), ensure
605  * the device is ready to be used by lib8390.c and registerd with
606  * the network layer.
607  */
608
609 static int ax_init_dev(struct net_device *dev, int first_init)
610 {
611         struct ei_device *ei_local = netdev_priv(dev);
612         struct ax_device *ax = to_ax_dev(dev);
613         void __iomem *ioaddr = ei_local->mem;
614         unsigned int start_page;
615         unsigned int stop_page;
616         int ret;
617         int i;
618
619         ret = ax_initial_check(dev);
620         if (ret)
621                 goto err_out;
622
623         /* setup goes here */
624
625         ax_initial_setup(dev, ei_local);
626
627         /* read the mac from the card prom if we need it */
628
629         if (first_init && ax->plat->flags & AXFLG_HAS_EEPROM) {
630                 unsigned char SA_prom[32];
631
632                 for(i = 0; i < sizeof(SA_prom); i+=2) {
633                         SA_prom[i] = ei_inb(ioaddr + NE_DATAPORT);
634                         SA_prom[i+1] = ei_inb(ioaddr + NE_DATAPORT);
635                 }
636
637                 if (ax->plat->wordlength == 2)
638                         for (i = 0; i < 16; i++)
639                                 SA_prom[i] = SA_prom[i+i];
640
641                 memcpy(dev->dev_addr,  SA_prom, 6);
642         }
643
644         if (ax->plat->wordlength == 2) {
645                 /* We must set the 8390 for word mode. */
646                 ei_outb(ax->plat->dcr_val, ei_local->mem + EN0_DCFG);
647                 start_page = NESM_START_PG;
648                 stop_page = NESM_STOP_PG;
649         } else {
650                 start_page = NE1SM_START_PG;
651                 stop_page = NE1SM_STOP_PG;
652         }
653
654         /* load the mac-address from the device if this is the
655          * first time we've initialised */
656
657         if (first_init && ax->plat->flags & AXFLG_MAC_FROMDEV) {
658                 ei_outb(E8390_NODMA + E8390_PAGE1 + E8390_STOP,
659                         ei_local->mem + E8390_CMD); /* 0x61 */
660
661                 for (i = 0 ; i < ETHER_ADDR_LEN ; i++)
662                         dev->dev_addr[i] = ei_inb(ioaddr + EN1_PHYS_SHIFT(i));
663         }
664
665         ax_reset_8390(dev);
666
667         ei_status.name = "AX88796";
668         ei_status.tx_start_page = start_page;
669         ei_status.stop_page = stop_page;
670         ei_status.word16 = (ax->plat->wordlength == 2);
671         ei_status.rx_start_page = start_page + TX_PAGES;
672
673 #ifdef PACKETBUF_MEMSIZE
674          /* Allow the packet buffer size to be overridden by know-it-alls. */
675         ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
676 #endif
677
678         ei_status.reset_8390    = &ax_reset_8390;
679         ei_status.block_input   = &ax_block_input;
680         ei_status.block_output  = &ax_block_output;
681         ei_status.get_8390_hdr  = &ax_get_8390_hdr;
682         ei_status.priv = 0;
683
684         dev->open               = ax_open;
685         dev->stop               = ax_close;
686         dev->do_ioctl           = ax_ioctl;
687         dev->ethtool_ops        = &ax_ethtool_ops;
688
689         ax->msg_enable          = NETIF_MSG_LINK;
690         ax->mii.phy_id_mask     = 0x1f;
691         ax->mii.reg_num_mask    = 0x1f;
692         ax->mii.phy_id          = 0x10;         /* onboard phy */
693         ax->mii.force_media     = 0;
694         ax->mii.full_duplex     = 0;
695         ax->mii.mdio_read       = ax_phy_read;
696         ax->mii.mdio_write      = ax_phy_write;
697         ax->mii.dev             = dev;
698
699 #ifdef CONFIG_NET_POLL_CONTROLLER
700         dev->poll_controller = ax_ei_poll;
701 #endif
702         ax_NS8390_init(dev, 0);
703
704         if (first_init) {
705                 printk("AX88796: %dbit, irq %d, %lx, MAC: ",
706                        ei_status.word16 ? 16:8, dev->irq, dev->base_addr);
707
708                 for (i = 0; i < ETHER_ADDR_LEN; i++)
709                         printk("%2.2x%c", dev->dev_addr[i],
710                                (i < (ETHER_ADDR_LEN-1) ? ':' : ' '));
711
712                 printk("\n");
713         }
714
715         ret = register_netdev(dev);
716         if (ret)
717                 goto out_irq;
718
719         return 0;
720
721  out_irq:
722         /* cleanup irq */
723         free_irq(dev->irq, dev);
724  err_out:
725         return ret;
726 }
727
728 static int ax_remove(struct platform_device *_dev)
729 {
730         struct net_device *dev = platform_get_drvdata(_dev);
731         struct ax_device  *ax;
732
733         ax = to_ax_dev(dev);
734
735         unregister_netdev(dev);
736         free_irq(dev->irq, dev);
737
738         iounmap(ei_status.mem);
739         release_resource(ax->mem);
740         kfree(ax->mem);
741
742         if (ax->map2) {
743                 iounmap(ax->map2);
744                 release_resource(ax->mem2);
745                 kfree(ax->mem2);
746         }
747
748         free_netdev(dev);
749
750         return 0;
751 }
752
753 /* ax_probe
754  *
755  * This is the entry point when the platform device system uses to
756  * notify us of a new device to attach to. Allocate memory, find
757  * the resources and information passed, and map the necessary registers.
758 */
759
760 static int ax_probe(struct platform_device *pdev)
761 {
762         struct net_device *dev;
763         struct ax_device  *ax;
764         struct resource   *res;
765         size_t size;
766         int ret;
767
768         dev = ax__alloc_ei_netdev(sizeof(struct ax_device));
769         if (dev == NULL)
770                 return -ENOMEM;
771
772         /* ok, let's setup our device */
773         ax = to_ax_dev(dev);
774
775         memset(ax, 0, sizeof(struct ax_device));
776
777         spin_lock_init(&ax->mii_lock);
778
779         ax->dev = pdev;
780         ax->plat = pdev->dev.platform_data;
781         platform_set_drvdata(pdev, dev);
782
783         ei_status.rxcr_base  = ax->plat->rcr_val;
784
785         /* find the platform resources */
786
787         dev->irq  = platform_get_irq(pdev, 0);
788         if (dev->irq < 0) {
789                 dev_err(&pdev->dev, "no IRQ specified\n");
790                 ret = -ENXIO;
791                 goto exit_mem;
792         }
793
794         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
795         if (res == NULL) {
796                 dev_err(&pdev->dev, "no MEM specified\n");
797                 ret = -ENXIO;
798                 goto exit_mem;
799         }
800
801         size = (res->end - res->start) + 1;
802
803         /* setup the register offsets from either the platform data
804          * or by using the size of the resource provided */
805
806         if (ax->plat->reg_offsets)
807                 ei_status.reg_offset = ax->plat->reg_offsets;
808         else {
809                 ei_status.reg_offset = ax->reg_offsets;
810                 for (ret = 0; ret < 0x18; ret++)
811                         ax->reg_offsets[ret] = (size / 0x18) * ret;
812         }
813
814         ax->mem = request_mem_region(res->start, size, pdev->name);
815         if (ax->mem == NULL) {
816                 dev_err(&pdev->dev, "cannot reserve registers\n");
817                 ret = -ENXIO;
818                 goto exit_mem;
819         }
820
821         ei_status.mem = ioremap(res->start, size);
822         dev->base_addr = (long)ei_status.mem;
823
824         if (ei_status.mem == NULL) {
825                 dev_err(&pdev->dev, "Cannot ioremap area (%08zx,%08zx)\n",
826                         res->start, res->end);
827
828                 ret = -ENXIO;
829                 goto exit_req;
830         }
831
832         /* look for reset area */
833
834         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
835         if (res == NULL) {
836                 if (!ax->plat->reg_offsets) {
837                         for (ret = 0; ret < 0x20; ret++)
838                                 ax->reg_offsets[ret] = (size / 0x20) * ret;
839                 }
840
841                 ax->map2 = NULL;
842         } else {
843                 size = (res->end - res->start) + 1;
844
845                 ax->mem2 = request_mem_region(res->start, size, pdev->name);
846                 if (ax->mem == NULL) {
847                         dev_err(&pdev->dev, "cannot reserve registers\n");
848                         ret = -ENXIO;
849                         goto exit_mem1;
850                 }
851
852                 ax->map2 = ioremap(res->start, size);
853                 if (ax->map2 == NULL) {
854                         dev_err(&pdev->dev, "cannot map reset register");
855                         ret = -ENXIO;
856                         goto exit_mem2;
857                 }
858
859                 ei_status.reg_offset[0x1f] = ax->map2 - ei_status.mem;
860         }
861
862         /* got resources, now initialise and register device */
863
864         ret = ax_init_dev(dev, 1);
865         if (!ret)
866                 return 0;
867
868         if (ax->map2 == NULL)
869                 goto exit_mem1;
870
871         iounmap(ax->map2);
872
873  exit_mem2:
874         release_resource(ax->mem2);
875         kfree(ax->mem2);
876
877  exit_mem1:
878         iounmap(ei_status.mem);
879
880  exit_req:
881         release_resource(ax->mem);
882         kfree(ax->mem);
883
884  exit_mem:
885         free_netdev(dev);
886
887         return ret;
888 }
889
890 /* suspend and resume */
891
892 #ifdef CONFIG_PM
893 static int ax_suspend(struct platform_device *dev, pm_message_t state)
894 {
895         struct net_device *ndev = platform_get_drvdata(dev);
896         struct ax_device  *ax = to_ax_dev(ndev);
897
898         ax->resume_open = ax->running;
899
900         netif_device_detach(ndev);
901         ax_close(ndev);
902
903         return 0;
904 }
905
906 static int ax_resume(struct platform_device *pdev)
907 {
908         struct net_device *ndev = platform_get_drvdata(pdev);
909         struct ax_device  *ax = to_ax_dev(ndev);
910
911         ax_initial_setup(ndev, netdev_priv(ndev));
912         ax_NS8390_init(ndev, ax->resume_open);
913         netif_device_attach(ndev);
914
915         if (ax->resume_open)
916                 ax_open(ndev);
917
918         return 0;
919 }
920
921 #else
922 #define ax_suspend NULL
923 #define ax_resume  NULL
924 #endif
925
926 static struct platform_driver axdrv = {
927         .driver = {
928                 .name           = "ax88796",
929                 .owner          = THIS_MODULE,
930         },
931         .probe          = ax_probe,
932         .remove         = ax_remove,
933         .suspend        = ax_suspend,
934         .resume         = ax_resume,
935 };
936
937 static int __init axdrv_init(void)
938 {
939         return platform_driver_register(&axdrv);
940 }
941
942 static void __exit axdrv_exit(void)
943 {
944         platform_driver_unregister(&axdrv);
945 }
946
947 module_init(axdrv_init);
948 module_exit(axdrv_exit);
949
950 MODULE_DESCRIPTION("AX88796 10/100 Ethernet platform driver");
951 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
952 MODULE_LICENSE("GPL v2");