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