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