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