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