Commit | Line | Data |
---|---|---|
92aa674d SH |
1 | /* |
2 | * drivers/net/netx-eth.c | |
3 | * | |
4 | * Copyright (c) 2005 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 | |
8 | * as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | */ | |
19 | ||
92aa674d SH |
20 | #include <linux/init.h> |
21 | #include <linux/module.h> | |
22 | #include <linux/kernel.h> | |
23 | #include <linux/delay.h> | |
24 | ||
25 | #include <linux/netdevice.h> | |
26 | #include <linux/platform_device.h> | |
27 | #include <linux/etherdevice.h> | |
28 | #include <linux/skbuff.h> | |
29 | #include <linux/mii.h> | |
30 | ||
31 | #include <asm/io.h> | |
a09e64fb RK |
32 | #include <mach/hardware.h> |
33 | #include <mach/netx-regs.h> | |
34 | #include <mach/pfifo.h> | |
35 | #include <mach/xc.h> | |
36 | #include <mach/eth.h> | |
92aa674d SH |
37 | |
38 | /* XC Fifo Offsets */ | |
39 | #define EMPTY_PTR_FIFO(xcno) (0 + ((xcno) << 3)) /* Index of the empty pointer FIFO */ | |
40 | #define IND_FIFO_PORT_HI(xcno) (1 + ((xcno) << 3)) /* Index of the FIFO where received */ | |
41 | /* Data packages are indicated by XC */ | |
42 | #define IND_FIFO_PORT_LO(xcno) (2 + ((xcno) << 3)) /* Index of the FIFO where received */ | |
43 | /* Data packages are indicated by XC */ | |
44 | #define REQ_FIFO_PORT_HI(xcno) (3 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ | |
45 | /* have to be indicated by ARM which */ | |
46 | /* shall be sent */ | |
47 | #define REQ_FIFO_PORT_LO(xcno) (4 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ | |
48 | /* have to be indicated by ARM which shall */ | |
49 | /* be sent */ | |
50 | #define CON_FIFO_PORT_HI(xcno) (5 + ((xcno) << 3)) /* Index of the FIFO where sent Data packages */ | |
51 | /* are confirmed */ | |
52 | #define CON_FIFO_PORT_LO(xcno) (6 + ((xcno) << 3)) /* Index of the FIFO where sent Data */ | |
53 | /* packages are confirmed */ | |
54 | #define PFIFO_MASK(xcno) (0x7f << (xcno*8)) | |
55 | ||
56 | #define FIFO_PTR_FRAMELEN_SHIFT 0 | |
57 | #define FIFO_PTR_FRAMELEN_MASK (0x7ff << 0) | |
58 | #define FIFO_PTR_FRAMELEN(len) (((len) << 0) & FIFO_PTR_FRAMELEN_MASK) | |
59 | #define FIFO_PTR_TIMETRIG (1<<11) | |
60 | #define FIFO_PTR_MULTI_REQ | |
61 | #define FIFO_PTR_ORIGIN (1<<14) | |
62 | #define FIFO_PTR_VLAN (1<<15) | |
63 | #define FIFO_PTR_FRAMENO_SHIFT 16 | |
64 | #define FIFO_PTR_FRAMENO_MASK (0x3f << 16) | |
65 | #define FIFO_PTR_FRAMENO(no) (((no) << 16) & FIFO_PTR_FRAMENO_MASK) | |
66 | #define FIFO_PTR_SEGMENT_SHIFT 22 | |
67 | #define FIFO_PTR_SEGMENT_MASK (0xf << 22) | |
68 | #define FIFO_PTR_SEGMENT(seg) (((seg) & 0xf) << 22) | |
69 | #define FIFO_PTR_ERROR_SHIFT 28 | |
70 | #define FIFO_PTR_ERROR_MASK (0xf << 28) | |
71 | ||
72 | #define ISR_LINK_STATUS_CHANGE (1<<4) | |
73 | #define ISR_IND_LO (1<<3) | |
74 | #define ISR_CON_LO (1<<2) | |
75 | #define ISR_IND_HI (1<<1) | |
76 | #define ISR_CON_HI (1<<0) | |
77 | ||
78 | #define ETH_MAC_LOCAL_CONFIG 0x1560 | |
79 | #define ETH_MAC_4321 0x1564 | |
80 | #define ETH_MAC_65 0x1568 | |
81 | ||
82 | #define MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT 16 | |
83 | #define MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK (0xf<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) | |
84 | #define MAC_TRAFFIC_CLASS_ARRANGEMENT(x) (((x)<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) & MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK) | |
85 | #define LOCAL_CONFIG_LINK_STATUS_IRQ_EN (1<<24) | |
86 | #define LOCAL_CONFIG_CON_LO_IRQ_EN (1<<23) | |
87 | #define LOCAL_CONFIG_CON_HI_IRQ_EN (1<<22) | |
88 | #define LOCAL_CONFIG_IND_LO_IRQ_EN (1<<21) | |
89 | #define LOCAL_CONFIG_IND_HI_IRQ_EN (1<<20) | |
90 | ||
91 | #define CARDNAME "netx-eth" | |
92 | ||
93 | /* LSB must be zero */ | |
94 | #define INTERNAL_PHY_ADR 0x1c | |
95 | ||
96 | struct netx_eth_priv { | |
97 | void __iomem *sram_base, *xpec_base, *xmac_base; | |
98 | int id; | |
92aa674d SH |
99 | struct mii_if_info mii; |
100 | u32 msg_enable; | |
101 | struct xc *xc; | |
102 | spinlock_t lock; | |
103 | }; | |
104 | ||
105 | static void netx_eth_set_multicast_list(struct net_device *ndev) | |
106 | { | |
107 | /* implement me */ | |
108 | } | |
109 | ||
110 | static int | |
111 | netx_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) | |
112 | { | |
113 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
114 | unsigned char *buf = skb->data; | |
115 | unsigned int len = skb->len; | |
116 | ||
117 | spin_lock_irq(&priv->lock); | |
118 | memcpy_toio(priv->sram_base + 1560, (void *)buf, len); | |
119 | if (len < 60) { | |
120 | memset_io(priv->sram_base + 1560 + len, 0, 60 - len); | |
121 | len = 60; | |
122 | } | |
123 | ||
124 | pfifo_push(REQ_FIFO_PORT_LO(priv->id), | |
125 | FIFO_PTR_SEGMENT(priv->id) | | |
126 | FIFO_PTR_FRAMENO(1) | | |
127 | FIFO_PTR_FRAMELEN(len)); | |
128 | ||
e2ac455a DM |
129 | ndev->stats.tx_packets++; |
130 | ndev->stats.tx_bytes += skb->len; | |
92aa674d SH |
131 | |
132 | netif_stop_queue(ndev); | |
133 | spin_unlock_irq(&priv->lock); | |
134 | dev_kfree_skb(skb); | |
135 | ||
6ed10654 | 136 | return NETDEV_TX_OK; |
92aa674d SH |
137 | } |
138 | ||
139 | static void netx_eth_receive(struct net_device *ndev) | |
140 | { | |
141 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
142 | unsigned int val, frameno, seg, len; | |
143 | unsigned char *data; | |
144 | struct sk_buff *skb; | |
145 | ||
146 | val = pfifo_pop(IND_FIFO_PORT_LO(priv->id)); | |
147 | ||
148 | frameno = (val & FIFO_PTR_FRAMENO_MASK) >> FIFO_PTR_FRAMENO_SHIFT; | |
149 | seg = (val & FIFO_PTR_SEGMENT_MASK) >> FIFO_PTR_SEGMENT_SHIFT; | |
150 | len = (val & FIFO_PTR_FRAMELEN_MASK) >> FIFO_PTR_FRAMELEN_SHIFT; | |
151 | ||
152 | skb = dev_alloc_skb(len); | |
153 | if (unlikely(skb == NULL)) { | |
154 | printk(KERN_NOTICE "%s: Low memory, packet dropped.\n", | |
155 | ndev->name); | |
e2ac455a | 156 | ndev->stats.rx_dropped++; |
92aa674d SH |
157 | return; |
158 | } | |
159 | ||
160 | data = skb_put(skb, len); | |
161 | ||
162 | memcpy_fromio(data, priv->sram_base + frameno * 1560, len); | |
163 | ||
164 | pfifo_push(EMPTY_PTR_FIFO(priv->id), | |
165 | FIFO_PTR_SEGMENT(seg) | FIFO_PTR_FRAMENO(frameno)); | |
166 | ||
92aa674d SH |
167 | skb->protocol = eth_type_trans(skb, ndev); |
168 | netif_rx(skb); | |
9a262d5c AB |
169 | ndev->stats.rx_packets++; |
170 | ndev->stats.rx_bytes += len; | |
92aa674d SH |
171 | } |
172 | ||
173 | static irqreturn_t | |
7d12e780 | 174 | netx_eth_interrupt(int irq, void *dev_id) |
92aa674d SH |
175 | { |
176 | struct net_device *ndev = dev_id; | |
177 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
178 | int status; | |
179 | unsigned long flags; | |
180 | ||
181 | spin_lock_irqsave(&priv->lock, flags); | |
182 | ||
183 | status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); | |
184 | while (status) { | |
185 | int fill_level; | |
186 | writel(status, NETX_PFIFO_XPEC_ISR(priv->id)); | |
187 | ||
188 | if ((status & ISR_CON_HI) || (status & ISR_IND_HI)) | |
189 | printk("%s: unexpected status: 0x%08x\n", | |
b39d66a8 | 190 | __func__, status); |
92aa674d SH |
191 | |
192 | fill_level = | |
193 | readl(NETX_PFIFO_FILL_LEVEL(IND_FIFO_PORT_LO(priv->id))); | |
194 | while (fill_level--) | |
195 | netx_eth_receive(ndev); | |
196 | ||
197 | if (status & ISR_CON_LO) | |
198 | netif_wake_queue(ndev); | |
199 | ||
200 | if (status & ISR_LINK_STATUS_CHANGE) | |
201 | mii_check_media(&priv->mii, netif_msg_link(priv), 1); | |
202 | ||
203 | status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); | |
204 | } | |
205 | spin_unlock_irqrestore(&priv->lock, flags); | |
206 | return IRQ_HANDLED; | |
207 | } | |
208 | ||
92aa674d SH |
209 | static int netx_eth_open(struct net_device *ndev) |
210 | { | |
211 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
212 | ||
213 | if (request_irq | |
a0607fd3 | 214 | (ndev->irq, netx_eth_interrupt, IRQF_SHARED, ndev->name, ndev)) |
92aa674d SH |
215 | return -EAGAIN; |
216 | ||
217 | writel(ndev->dev_addr[0] | | |
218 | ndev->dev_addr[1]<<8 | | |
219 | ndev->dev_addr[2]<<16 | | |
220 | ndev->dev_addr[3]<<24, | |
221 | priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); | |
222 | writel(ndev->dev_addr[4] | | |
223 | ndev->dev_addr[5]<<8, | |
224 | priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_65); | |
225 | ||
226 | writel(LOCAL_CONFIG_LINK_STATUS_IRQ_EN | | |
227 | LOCAL_CONFIG_CON_LO_IRQ_EN | | |
228 | LOCAL_CONFIG_CON_HI_IRQ_EN | | |
229 | LOCAL_CONFIG_IND_LO_IRQ_EN | | |
230 | LOCAL_CONFIG_IND_HI_IRQ_EN, | |
231 | priv->xpec_base + NETX_XPEC_RAM_START_OFS + | |
232 | ETH_MAC_LOCAL_CONFIG); | |
233 | ||
234 | mii_check_media(&priv->mii, netif_msg_link(priv), 1); | |
235 | netif_start_queue(ndev); | |
236 | ||
237 | return 0; | |
238 | } | |
239 | ||
240 | static int netx_eth_close(struct net_device *ndev) | |
241 | { | |
242 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
243 | ||
244 | netif_stop_queue(ndev); | |
245 | ||
246 | writel(0, | |
247 | priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_LOCAL_CONFIG); | |
248 | ||
249 | free_irq(ndev->irq, ndev); | |
250 | ||
251 | return 0; | |
252 | } | |
253 | ||
254 | static void netx_eth_timeout(struct net_device *ndev) | |
255 | { | |
256 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
257 | int i; | |
258 | ||
259 | printk(KERN_ERR "%s: transmit timed out, resetting\n", ndev->name); | |
260 | ||
261 | spin_lock_irq(&priv->lock); | |
262 | ||
263 | xc_reset(priv->xc); | |
264 | xc_start(priv->xc); | |
265 | ||
266 | for (i=2; i<=18; i++) | |
267 | pfifo_push(EMPTY_PTR_FIFO(priv->id), | |
268 | FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); | |
269 | ||
270 | spin_unlock_irq(&priv->lock); | |
271 | ||
272 | netif_wake_queue(ndev); | |
273 | } | |
274 | ||
275 | static int | |
276 | netx_eth_phy_read(struct net_device *ndev, int phy_id, int reg) | |
277 | { | |
278 | unsigned int val; | |
279 | ||
280 | val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | | |
281 | MIIMU_REGADDR(reg) | MIIMU_PHY_NRES; | |
282 | ||
283 | writel(val, NETX_MIIMU); | |
284 | while (readl(NETX_MIIMU) & MIIMU_SNRDY); | |
285 | ||
286 | return readl(NETX_MIIMU) >> 16; | |
287 | ||
288 | } | |
289 | ||
290 | static void | |
291 | netx_eth_phy_write(struct net_device *ndev, int phy_id, int reg, int value) | |
292 | { | |
293 | unsigned int val; | |
294 | ||
295 | val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | | |
296 | MIIMU_REGADDR(reg) | MIIMU_PHY_NRES | MIIMU_OPMODE_WRITE | | |
297 | MIIMU_DATA(value); | |
298 | ||
299 | writel(val, NETX_MIIMU); | |
300 | while (readl(NETX_MIIMU) & MIIMU_SNRDY); | |
301 | } | |
302 | ||
cd732de2 AB |
303 | static const struct net_device_ops netx_eth_netdev_ops = { |
304 | .ndo_open = netx_eth_open, | |
305 | .ndo_stop = netx_eth_close, | |
306 | .ndo_start_xmit = netx_eth_hard_start_xmit, | |
307 | .ndo_tx_timeout = netx_eth_timeout, | |
308 | .ndo_set_multicast_list = netx_eth_set_multicast_list, | |
309 | .ndo_change_mtu = eth_change_mtu, | |
310 | .ndo_validate_addr = eth_validate_addr, | |
311 | .ndo_set_mac_address = eth_mac_addr, | |
312 | }; | |
313 | ||
92aa674d SH |
314 | static int netx_eth_enable(struct net_device *ndev) |
315 | { | |
316 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
317 | unsigned int mac4321, mac65; | |
318 | int running, i; | |
319 | ||
320 | ether_setup(ndev); | |
321 | ||
cd732de2 | 322 | ndev->netdev_ops = &netx_eth_netdev_ops; |
92aa674d | 323 | ndev->watchdog_timeo = msecs_to_jiffies(5000); |
92aa674d SH |
324 | |
325 | priv->msg_enable = NETIF_MSG_LINK; | |
326 | priv->mii.phy_id_mask = 0x1f; | |
327 | priv->mii.reg_num_mask = 0x1f; | |
328 | priv->mii.force_media = 0; | |
329 | priv->mii.full_duplex = 0; | |
330 | priv->mii.dev = ndev; | |
331 | priv->mii.mdio_read = netx_eth_phy_read; | |
332 | priv->mii.mdio_write = netx_eth_phy_write; | |
333 | priv->mii.phy_id = INTERNAL_PHY_ADR + priv->id; | |
334 | ||
335 | running = xc_running(priv->xc); | |
336 | xc_stop(priv->xc); | |
337 | ||
338 | /* if the xc engine is already running, assume the bootloader has | |
339 | * loaded the firmware for us | |
340 | */ | |
341 | if (running) { | |
342 | /* get Node Address from hardware */ | |
343 | mac4321 = readl(priv->xpec_base + | |
344 | NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); | |
345 | mac65 = readl(priv->xpec_base + | |
346 | NETX_XPEC_RAM_START_OFS + ETH_MAC_65); | |
347 | ||
348 | ndev->dev_addr[0] = mac4321 & 0xff; | |
349 | ndev->dev_addr[1] = (mac4321 >> 8) & 0xff; | |
350 | ndev->dev_addr[2] = (mac4321 >> 16) & 0xff; | |
351 | ndev->dev_addr[3] = (mac4321 >> 24) & 0xff; | |
352 | ndev->dev_addr[4] = mac65 & 0xff; | |
353 | ndev->dev_addr[5] = (mac65 >> 8) & 0xff; | |
354 | } else { | |
355 | if (xc_request_firmware(priv->xc)) { | |
356 | printk(CARDNAME ": requesting firmware failed\n"); | |
357 | return -ENODEV; | |
358 | } | |
359 | } | |
360 | ||
361 | xc_reset(priv->xc); | |
362 | xc_start(priv->xc); | |
363 | ||
364 | if (!is_valid_ether_addr(ndev->dev_addr)) | |
365 | printk("%s: Invalid ethernet MAC address. Please " | |
366 | "set using ifconfig\n", ndev->name); | |
367 | ||
368 | for (i=2; i<=18; i++) | |
369 | pfifo_push(EMPTY_PTR_FIFO(priv->id), | |
370 | FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); | |
371 | ||
372 | return register_netdev(ndev); | |
373 | ||
374 | } | |
375 | ||
376 | static int netx_eth_drv_probe(struct platform_device *pdev) | |
377 | { | |
378 | struct netx_eth_priv *priv; | |
379 | struct net_device *ndev; | |
380 | struct netxeth_platform_data *pdata; | |
381 | int ret; | |
382 | ||
383 | ndev = alloc_etherdev(sizeof (struct netx_eth_priv)); | |
384 | if (!ndev) { | |
385 | printk("%s: could not allocate device.\n", CARDNAME); | |
386 | ret = -ENOMEM; | |
387 | goto exit; | |
388 | } | |
92aa674d SH |
389 | SET_NETDEV_DEV(ndev, &pdev->dev); |
390 | ||
391 | platform_set_drvdata(pdev, ndev); | |
392 | ||
393 | priv = netdev_priv(ndev); | |
394 | ||
395 | pdata = (struct netxeth_platform_data *)pdev->dev.platform_data; | |
396 | priv->xc = request_xc(pdata->xcno, &pdev->dev); | |
397 | if (!priv->xc) { | |
398 | dev_err(&pdev->dev, "unable to request xc engine\n"); | |
399 | ret = -ENODEV; | |
400 | goto exit_free_netdev; | |
401 | } | |
402 | ||
403 | ndev->irq = priv->xc->irq; | |
404 | priv->id = pdev->id; | |
405 | priv->xpec_base = priv->xc->xpec_base; | |
406 | priv->xmac_base = priv->xc->xmac_base; | |
407 | priv->sram_base = priv->xc->sram_base; | |
408 | ||
2cc002c4 UKK |
409 | spin_lock_init(&priv->lock); |
410 | ||
92aa674d SH |
411 | ret = pfifo_request(PFIFO_MASK(priv->id)); |
412 | if (ret) { | |
413 | printk("unable to request PFIFO\n"); | |
414 | goto exit_free_xc; | |
415 | } | |
416 | ||
417 | ret = netx_eth_enable(ndev); | |
418 | if (ret) | |
419 | goto exit_free_pfifo; | |
420 | ||
421 | return 0; | |
422 | exit_free_pfifo: | |
423 | pfifo_free(PFIFO_MASK(priv->id)); | |
424 | exit_free_xc: | |
425 | free_xc(priv->xc); | |
426 | exit_free_netdev: | |
427 | platform_set_drvdata(pdev, NULL); | |
428 | free_netdev(ndev); | |
429 | exit: | |
430 | return ret; | |
431 | } | |
432 | ||
433 | static int netx_eth_drv_remove(struct platform_device *pdev) | |
434 | { | |
435 | struct net_device *ndev = dev_get_drvdata(&pdev->dev); | |
436 | struct netx_eth_priv *priv = netdev_priv(ndev); | |
437 | ||
438 | platform_set_drvdata(pdev, NULL); | |
439 | ||
440 | unregister_netdev(ndev); | |
441 | xc_stop(priv->xc); | |
442 | free_xc(priv->xc); | |
443 | free_netdev(ndev); | |
444 | pfifo_free(PFIFO_MASK(priv->id)); | |
445 | ||
446 | return 0; | |
447 | } | |
448 | ||
449 | static int netx_eth_drv_suspend(struct platform_device *pdev, pm_message_t state) | |
450 | { | |
451 | dev_err(&pdev->dev, "suspend not implemented\n"); | |
452 | return 0; | |
453 | } | |
454 | ||
455 | static int netx_eth_drv_resume(struct platform_device *pdev) | |
456 | { | |
457 | dev_err(&pdev->dev, "resume not implemented\n"); | |
458 | return 0; | |
459 | } | |
460 | ||
461 | static struct platform_driver netx_eth_driver = { | |
462 | .probe = netx_eth_drv_probe, | |
463 | .remove = netx_eth_drv_remove, | |
464 | .suspend = netx_eth_drv_suspend, | |
465 | .resume = netx_eth_drv_resume, | |
466 | .driver = { | |
467 | .name = CARDNAME, | |
468 | .owner = THIS_MODULE, | |
469 | }, | |
470 | }; | |
471 | ||
472 | static int __init netx_eth_init(void) | |
473 | { | |
474 | unsigned int phy_control, val; | |
475 | ||
476 | printk("NetX Ethernet driver\n"); | |
477 | ||
478 | phy_control = PHY_CONTROL_PHY_ADDRESS(INTERNAL_PHY_ADR>>1) | | |
479 | PHY_CONTROL_PHY1_MODE(PHY_MODE_ALL) | | |
480 | PHY_CONTROL_PHY1_AUTOMDIX | | |
481 | PHY_CONTROL_PHY1_EN | | |
482 | PHY_CONTROL_PHY0_MODE(PHY_MODE_ALL) | | |
483 | PHY_CONTROL_PHY0_AUTOMDIX | | |
484 | PHY_CONTROL_PHY0_EN | | |
485 | PHY_CONTROL_CLK_XLATIN; | |
486 | ||
487 | val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); | |
488 | writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); | |
489 | ||
490 | writel(phy_control | PHY_CONTROL_RESET, NETX_SYSTEM_PHY_CONTROL); | |
491 | udelay(100); | |
492 | ||
493 | val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); | |
494 | writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); | |
495 | ||
496 | writel(phy_control, NETX_SYSTEM_PHY_CONTROL); | |
497 | ||
498 | return platform_driver_register(&netx_eth_driver); | |
499 | } | |
500 | ||
501 | static void __exit netx_eth_cleanup(void) | |
502 | { | |
503 | platform_driver_unregister(&netx_eth_driver); | |
504 | } | |
505 | ||
506 | module_init(netx_eth_init); | |
507 | module_exit(netx_eth_cleanup); | |
508 | ||
509 | MODULE_AUTHOR("Sascha Hauer, Pengutronix"); | |
510 | MODULE_LICENSE("GPL"); | |
72abb461 | 511 | MODULE_ALIAS("platform:" CARDNAME); |
36c04a61 BH |
512 | MODULE_FIRMWARE("xc0.bin"); |
513 | MODULE_FIRMWARE("xc1.bin"); | |
514 | MODULE_FIRMWARE("xc2.bin"); |