projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add support for Atheros SoC (used in Fonera, Meraki) - Merry Christmas, everybody :)
[openwrt/openwrt.git] / target / linux / atheros-2.6 / patches / 130-ar2313_ethernet.patch
1 diff -urN linux.old/drivers/net/ar2313/ar2313.c linux.eth/drivers/net/ar2313/ar2313.c
2 --- linux.old/drivers/net/ar2313/ar2313.c 1970-01-01 01:00:00.000000000 +0100
3 +++ linux.eth/drivers/net/ar2313/ar2313.c 2006-12-16 04:30:44.000000000 +0100
4 @@ -0,0 +1,1545 @@
5 +/*
6 + * ar2313.c: Linux driver for the Atheros AR231z Ethernet device.
7 + *
8 + * Copyright (C) 2004 by Sameer Dekate <sdekate@arubanetworks.com>
9 + * Copyright (C) 2006 Imre Kaloz <kaloz@openwrt.org>
10 + * Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org>
11 + *
12 + * Thanks to Atheros for providing hardware and documentation
13 + * enabling me to write this driver.
14 + *
15 + * This program is free software; you can redistribute it and/or modify
16 + * it under the terms of the GNU General Public License as published by
17 + * the Free Software Foundation; either version 2 of the License, or
18 + * (at your option) any later version.
19 + *
20 + * Additional credits:
21 + * This code is taken from John Taylor's Sibyte driver and then
22 + * modified for the AR2313.
23 + */
24 +
25 +#include <linux/autoconf.h>
26 +#include <linux/module.h>
27 +#include <linux/version.h>
28 +#include <linux/types.h>
29 +#include <linux/errno.h>
30 +#include <linux/ioport.h>
31 +#include <linux/pci.h>
32 +#include <linux/netdevice.h>
33 +#include <linux/etherdevice.h>
34 +#include <linux/skbuff.h>
35 +#include <linux/init.h>
36 +#include <linux/delay.h>
37 +#include <linux/mm.h>
38 +#include <linux/highmem.h>
39 +#include <linux/sockios.h>
40 +#include <linux/pkt_sched.h>
41 +#include <linux/compile.h>
42 +#include <linux/mii.h>
43 +#include <linux/ethtool.h>
44 +#include <linux/ctype.h>
45 +#include <linux/platform_device.h>
46 +
47 +#include <net/sock.h>
48 +#include <net/ip.h>
49 +
50 +#include <asm/system.h>
51 +#include <asm/io.h>
52 +#include <asm/irq.h>
53 +#include <asm/byteorder.h>
54 +#include <asm/uaccess.h>
55 +#include <asm/bootinfo.h>
56 +
57 +#include <ar531x_platform.h>
58 +
59 +#undef INDEX_DEBUG
60 +#define DEBUG 0
61 +#define DEBUG_TX 0
62 +#define DEBUG_RX 0
63 +#define DEBUG_INT 0
64 +#define DEBUG_MC 0
65 +#define DEBUG_ERR 1
66 +
67 +#ifndef min
68 +#define min(a,b) (((a)<(b))?(a):(b))
69 +#endif
70 +
71 +#ifndef SMP_CACHE_BYTES
72 +#define SMP_CACHE_BYTES L1_CACHE_BYTES
73 +#endif
74 +
75 +#ifndef SET_MODULE_OWNER
76 +#define SET_MODULE_OWNER(dev) {do{} while(0);}
77 +#define AR2313_MOD_INC_USE_COUNT MOD_INC_USE_COUNT
78 +#define AR2313_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT
79 +#else
80 +#define AR2313_MOD_INC_USE_COUNT {do{} while(0);}
81 +#define AR2313_MOD_DEC_USE_COUNT {do{} while(0);}
82 +#endif
83 +
84 +#define PHYSADDR(a) ((_ACAST32_ (a)) & 0x1fffffff)
85 +
86 +static char ifname[5] = "bond";
87 +
88 +module_param_string(ifname, ifname, 5, 0);
89 +
90 +#define AR2313_MBOX_SET_BIT 0x8
91 +
92 +#define BOARD_IDX_STATIC 0
93 +#define BOARD_IDX_OVERFLOW -1
94 +
95 +#include "ar2313_msg.h"
96 +#include "platform.h"
97 +#include "dma.h"
98 +#include "ar2313.h"
99 +
100 +/*
101 + * New interrupt handler strategy:
102 + *
103 + * An old interrupt handler worked using the traditional method of
104 + * replacing an skbuff with a new one when a packet arrives. However
105 + * the rx rings do not need to contain a static number of buffer
106 + * descriptors, thus it makes sense to move the memory allocation out
107 + * of the main interrupt handler and do it in a bottom half handler
108 + * and only allocate new buffers when the number of buffers in the
109 + * ring is below a certain threshold. In order to avoid starving the
110 + * NIC under heavy load it is however necessary to force allocation
111 + * when hitting a minimum threshold. The strategy for alloction is as
112 + * follows:
113 + *
114 + * RX_LOW_BUF_THRES - allocate buffers in the bottom half
115 + * RX_PANIC_LOW_THRES - we are very low on buffers, allocate
116 + * the buffers in the interrupt handler
117 + * RX_RING_THRES - maximum number of buffers in the rx ring
118 + *
119 + * One advantagous side effect of this allocation approach is that the
120 + * entire rx processing can be done without holding any spin lock
121 + * since the rx rings and registers are totally independent of the tx
122 + * ring and its registers. This of course includes the kmalloc's of
123 + * new skb's. Thus start_xmit can run in parallel with rx processing
124 + * and the memory allocation on SMP systems.
125 + *
126 + * Note that running the skb reallocation in a bottom half opens up
127 + * another can of races which needs to be handled properly. In
128 + * particular it can happen that the interrupt handler tries to run
129 + * the reallocation while the bottom half is either running on another
130 + * CPU or was interrupted on the same CPU. To get around this the
131 + * driver uses bitops to prevent the reallocation routines from being
132 + * reentered.
133 + *
134 + * TX handling can also be done without holding any spin lock, wheee
135 + * this is fun! since tx_csm is only written to by the interrupt
136 + * handler.
137 + */
138 +
139 +/*
140 + * Threshold values for RX buffer allocation - the low water marks for
141 + * when to start refilling the rings are set to 75% of the ring
142 + * sizes. It seems to make sense to refill the rings entirely from the
143 + * intrrupt handler once it gets below the panic threshold, that way
144 + * we don't risk that the refilling is moved to another CPU when the
145 + * one running the interrupt handler just got the slab code hot in its
146 + * cache.
147 + */
148 +#define RX_RING_SIZE AR2313_DESCR_ENTRIES
149 +#define RX_PANIC_THRES (RX_RING_SIZE/4)
150 +#define RX_LOW_THRES ((3*RX_RING_SIZE)/4)
151 +#define CRC_LEN 4
152 +#define RX_OFFSET 2
153 +
154 +#define AR2313_BUFSIZE (AR2313_MTU + ETH_HLEN + CRC_LEN + RX_OFFSET)
155 +
156 +#ifdef MODULE
157 +MODULE_AUTHOR("Sameer Dekate <sdekate@arubanetworks.com>, Imre Kaloz <kaloz@openwrt.org>, Felix Fietkau <nbd@openwrt.org>");
158 +MODULE_DESCRIPTION("AR2313 Ethernet driver");
159 +#endif
160 +
161 +#if DEBUG
162 +static char version[] __initdata =
163 + "ar2313.c: v0.03 2006/07/12 sdekate@arubanetworks.com\n";
164 +#endif /* DEBUG */
165 +
166 +#define virt_to_phys(x) ((u32)(x) & 0x1fffffff)
167 +
168 +// prototypes
169 +static short armiiread(short phy, short reg);
170 +static void armiiwrite(short phy, short reg, short data);
171 +#ifdef TX_TIMEOUT
172 +static void ar2313_tx_timeout(struct net_device *dev);
173 +#endif
174 +static void ar2313_halt(struct net_device *dev);
175 +static void rx_tasklet_func(unsigned long data);
176 +static void ar2313_multicast_list(struct net_device *dev);
177 +
178 +static int probed __initdata = 0;
179 +static unsigned long ar_eth_base;
180 +static unsigned long ar_dma_base;
181 +static unsigned long ar_int_base;
182 +static unsigned long ar_int_mac_mask;
183 +static unsigned long ar_int_phy_mask;
184 +
185 +#ifndef ERR
186 +#define ERR(fmt, args...) printk("%s: " fmt, __func__, ##args)
187 +#endif
188 +
189 +
190 +int __init ar2313_probe(struct platform_device *pdev)
191 +{
192 + struct net_device *dev;
193 + struct ar2313_private *sp;
194 + struct ar531x_eth *cfg;
195 + struct resource *res;
196 + int version_disp;
197 + char name[64] ;
198 +
199 + if (probed)
200 + return -ENODEV;
201 + probed++;
202 +
203 + version_disp = 0;
204 + sprintf(name, "%s%%d", ifname) ;
205 + dev = alloc_etherdev(sizeof(struct ar2313_private));
206 +
207 + if (dev == NULL) {
208 + printk(KERN_ERR "ar2313: Unable to allocate net_device structure!\n");
209 + return -ENOMEM;
210 + }
211 +
212 + SET_MODULE_OWNER(dev);
213 + platform_set_drvdata(pdev, dev);
214 +
215 + sp = dev->priv;
216 + sp->dev = dev;
217 + cfg = pdev->dev.platform_data;
218 +
219 + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "eth_membase");
220 + if (!res)
221 + return -ENODEV;
222 +
223 + sp->link = 0;
224 + ar_eth_base = res->start;
225 + ar_dma_base = ar_eth_base + 0x1000;
226 + ar_int_base = cfg->reset_base;
227 + ar_int_mac_mask = cfg->reset_mac;
228 + ar_int_phy_mask = cfg->reset_phy;
229 + sp->phy = cfg->phy;
230 +
231 + dev->irq = platform_get_irq_byname(pdev, "eth_irq");
232 +
233 + spin_lock_init(&sp->lock);
234 +
235 + /* initialize func pointers */
236 + dev->open = &ar2313_open;
237 + dev->stop = &ar2313_close;
238 + dev->hard_start_xmit = &ar2313_start_xmit;
239 +
240 + dev->get_stats = &ar2313_get_stats;
241 + dev->set_multicast_list = &ar2313_multicast_list;
242 +#ifdef TX_TIMEOUT
243 + dev->tx_timeout = ar2313_tx_timeout;
244 + dev->watchdog_timeo = AR2313_TX_TIMEOUT;
245 +#endif
246 + dev->do_ioctl = &ar2313_ioctl;
247 +
248 + // SAMEER: do we need this?
249 + dev->features |= NETIF_F_SG | NETIF_F_HIGHDMA;
250 +
251 + tasklet_init(&sp->rx_tasklet, rx_tasklet_func, (unsigned long) dev);
252 + tasklet_disable(&sp->rx_tasklet);
253 +
254 + /* display version info if adapter is found */
255 + if (!version_disp) {
256 + /* set display flag to TRUE so that */
257 + /* we only display this string ONCE */
258 + version_disp = 1;
259 +#if DEBUG
260 + printk(version);
261 +#endif /* DEBUG */
262 + }
263 +
264 +#if 0
265 + request_region(PHYSADDR(ar_eth_base), ETHERNET_SIZE*ETHERNET_MACS,
266 + "AR2313ENET");
267 +#endif
268 +
269 + sp->eth_regs = ioremap_nocache(PHYSADDR(ar_eth_base), sizeof(*sp->eth_regs));
270 + if (!sp->eth_regs) {
271 + printk("Can't remap eth registers\n");
272 + return(-ENXIO);
273 + }
274 +
275 + sp->dma_regs = ioremap_nocache(PHYSADDR(ar_eth_base + 0x1000), sizeof(*sp->dma_regs));
276 + dev->base_addr = (unsigned int) sp->dma_regs;
277 + if (!sp->dma_regs) {
278 + printk("Can't remap DMA registers\n");
279 + return(-ENXIO);
280 + }
281 +
282 + sp->int_regs = ioremap_nocache(PHYSADDR(ar_int_base), 4);
283 + if (!sp->int_regs) {
284 + printk("Can't remap INTERRUPT registers\n");
285 + return(-ENXIO);
286 + }
287 +
288 + strncpy(sp->name, "Atheros AR2313", sizeof (sp->name) - 1);
289 + sp->name [sizeof (sp->name) - 1] = '\0';
290 +
291 + {
292 + /* XXX: Will have to rewrite this part later */
293 + char *configstart;
294 + unsigned char def_mac[6] = {0, 0xaa, 0xbb, 0xcc, 0xdd, 0xee};
295 +
296 + configstart = (char *) cfg->board_config;
297 +
298 + if (!configstart) {
299 + printk("no valid mac found, using defaults");
300 + memcpy(dev->dev_addr, def_mac, 6);
301 + } else {
302 + memcpy(dev->dev_addr, ((u8 *)configstart)+102, 6);
303 + }
304 + }
305 +
306 + sp->board_idx = BOARD_IDX_STATIC;
307 +
308 + if (ar2313_init(dev)) {
309 + /*
310 + * ar2313_init() calls ar2313_init_cleanup() on error.
311 + */
312 + kfree(dev);
313 + return -ENODEV;
314 + }
315 +
316 + if (register_netdev(dev)){
317 + printk("%s: register_netdev failed\n", __func__);
318 + return -1;
319 + }
320 +
321 + printk("%s: %s: %02x:%02x:%02x:%02x:%02x:%02x, irq %d\n",
322 + dev->name, sp->name,
323 + dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
324 + dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5],
325 + dev->irq);
326 +
327 + /* start link poll timer */
328 + ar2313_setup_timer(dev);
329 +
330 + return 0;
331 +}
332 +
333 +#if 0
334 +static void ar2313_dump_regs(struct net_device *dev)
335 +{
336 + unsigned int *ptr, i;
337 + struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
338 +
339 + ptr = (unsigned int *)sp->eth_regs;
340 + for(i=0; i< (sizeof(ETHERNET_STRUCT)/ sizeof(unsigned int)); i++, ptr++) {
341 + printk("ENET: %08x = %08x\n", (int)ptr, *ptr);
342 + }
343 +
344 + ptr = (unsigned int *)sp->dma_regs;
345 + for(i=0; i< (sizeof(DMA)/ sizeof(unsigned int)); i++, ptr++) {
346 + printk("DMA: %08x = %08x\n", (int)ptr, *ptr);
347 + }
348 +
349 + ptr = (unsigned int *)sp->int_regs;
350 + for(i=0; i< (sizeof(INTERRUPT)/ sizeof(unsigned int)); i++, ptr++){
351 + printk("INT: %08x = %08x\n", (int)ptr, *ptr);
352 + }
353 +
354 + for (i = 0; i < AR2313_DESCR_ENTRIES; i++) {
355 + ar2313_descr_t *td = &sp->tx_ring[i];
356 + printk("Tx desc %2d: %08x %08x %08x %08x\n", i,
357 + td->status, td->devcs, td->addr, td->descr);
358 + }
359 +}
360 +#endif
361 +
362 +#ifdef TX_TIMEOUT
363 +static void
364 +ar2313_tx_timeout(struct net_device *dev)
365 +{
366 + struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
367 + unsigned long flags;
368 +
369 +#if DEBUG_TX
370 + printk("Tx timeout\n");
371 +#endif
372 + spin_lock_irqsave(&sp->lock, flags);
373 + ar2313_restart(dev);
374 + spin_unlock_irqrestore(&sp->lock, flags);
375 +}
376 +#endif
377 +
378 +#if DEBUG_MC
379 +static void
380 +printMcList(struct net_device *dev)
381 +{
382 + struct dev_mc_list *list = dev->mc_list;
383 + int num=0, i;
384 + while(list){
385 + printk("%d MC ADDR ", num);
386 + for(i=0;i<list->dmi_addrlen;i++) {
387 + printk(":%02x", list->dmi_addr[i]);
388 + }
389 + list = list->next;
390 + printk("\n");
391 + }
392 +}
393 +#endif
394 +
395 +/*
396 + * Set or clear the multicast filter for this adaptor.
397 + * THIS IS ABSOLUTE CRAP, disabled
398 + */
399 +static void
400 +ar2313_multicast_list(struct net_device *dev)
401 +{
402 + /*
403 + * Always listen to broadcasts and
404 + * treat IFF bits independently
405 + */
406 + struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
407 + unsigned int recognise;
408 +
409 + recognise = sp->eth_regs->mac_control;
410 +
411 + if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
412 + recognise |= MAC_CONTROL_PR;
413 + } else {
414 + recognise &= ~MAC_CONTROL_PR;
415 + }
416 +
417 + if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
418 +#if DEBUG_MC
419 + printMcList(dev);
420 + printk("%s: all MULTICAST mc_count %d\n", __FUNCTION__, dev->mc_count);
421 +#endif
422 + recognise |= MAC_CONTROL_PM;/* all multicast */
423 + } else if (dev->mc_count > 0) {
424 +#if DEBUG_MC
425 + printMcList(dev);
426 + printk("%s: mc_count %d\n", __FUNCTION__, dev->mc_count);
427 +#endif
428 + recognise |= MAC_CONTROL_PM; /* for the time being */
429 + }
430 +#if DEBUG_MC
431 + printk("%s: setting %08x to %08x\n", __FUNCTION__, (int)sp->eth_regs, recognise);
432 +#endif
433 +
434 + sp->eth_regs->mac_control = recognise;
435 +}
436 +
437 +static void rx_tasklet_cleanup(struct net_device *dev)
438 +{
439 + struct ar2313_private *sp = dev->priv;
440 +
441 + /*
442 + * Tasklet may be scheduled. Need to get it removed from the list
443 + * since we're about to free the struct.
444 + */
445 +
446 + sp->unloading = 1;
447 + tasklet_enable(&sp->rx_tasklet);
448 + tasklet_kill(&sp->rx_tasklet);
449 +}
450 +
451 +static int __exit ar2313_remove(struct platform_device *pdev)
452 +{
453 + struct net_device *dev = platform_get_drvdata(pdev);
454 + rx_tasklet_cleanup(dev);
455 + ar2313_init_cleanup(dev);
456 + unregister_netdev(dev);
457 + kfree(dev);
458 + return 0;
459 +}
460 +
461 +
462 +/*
463 + * Restart the AR2313 ethernet controller.
464 + */
465 +static int ar2313_restart(struct net_device *dev)
466 +{
467 + /* disable interrupts */
468 + disable_irq(dev->irq);
469 +
470 + /* stop mac */
471 + ar2313_halt(dev);
472 +
473 + /* initialize */
474 + ar2313_init(dev);
475 +
476 + /* enable interrupts */
477 + enable_irq(dev->irq);
478 +
479 + return 0;
480 +}
481 +
482 +static struct platform_driver ar2313_driver = {
483 + .driver.name = "ar531x-eth",
484 + .probe = ar2313_probe,
485 + .remove = ar2313_remove,
486 +};
487 +
488 +int __init ar2313_module_init(void)
489 +{
490 + return platform_driver_register(&ar2313_driver);
491 +}
492 +
493 +void __exit ar2313_module_cleanup(void)
494 +{
495 + platform_driver_unregister(&ar2313_driver);
496 +}
497 +
498 +module_init(ar2313_module_init);
499 +module_exit(ar2313_module_cleanup);
500 +
501 +
502 +static void ar2313_free_descriptors(struct net_device *dev)
503 +{
504 + struct ar2313_private *sp = dev->priv;
505 + if (sp->rx_ring != NULL) {
506 + kfree((void*)KSEG0ADDR(sp->rx_ring));
507 + sp->rx_ring = NULL;
508 + sp->tx_ring = NULL;
509 + }
510 +}
511 +
512 +
513 +static int ar2313_allocate_descriptors(struct net_device *dev)
514 +{
515 + struct ar2313_private *sp = dev->priv;
516 + int size;
517 + int j;
518 + ar2313_descr_t *space;
519 +
520 + if(sp->rx_ring != NULL){
521 + printk("%s: already done.\n", __FUNCTION__);
522 + return 0;
523 + }
524 +
525 + size = (sizeof(ar2313_descr_t) * (AR2313_DESCR_ENTRIES * AR2313_QUEUES));
526 + space = kmalloc(size, GFP_KERNEL);
527 + if (space == NULL)
528 + return 1;
529 +
530 + /* invalidate caches */
531 + dma_cache_inv((unsigned int)space, size);
532 +
533 + /* now convert pointer to KSEG1 */
534 + space = (ar2313_descr_t *)KSEG1ADDR(space);
535 +
536 + memset((void *)space, 0, size);
537 +
538 + sp->rx_ring = space;
539 + space += AR2313_DESCR_ENTRIES;
540 +
541 + sp->tx_ring = space;
542 + space += AR2313_DESCR_ENTRIES;
543 +
544 + /* Initialize the transmit Descriptors */
545 + for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
546 + ar2313_descr_t *td = &sp->tx_ring[j];
547 + td->status = 0;
548 + td->devcs = DMA_TX1_CHAINED;
549 + td->addr = 0;
550 + td->descr = K1_TO_PHYS(&sp->tx_ring[(j+1) & (AR2313_DESCR_ENTRIES-1)]);
551 + }
552 +
553 + return 0;
554 +}
555 +
556 +
557 +/*
558 + * Generic cleanup handling data allocated during init. Used when the
559 + * module is unloaded or if an error occurs during initialization
560 + */
561 +static void ar2313_init_cleanup(struct net_device *dev)
562 +{
563 + struct ar2313_private *sp = dev->priv;
564 + struct sk_buff *skb;
565 + int j;
566 +
567 + ar2313_free_descriptors(dev);
568 +
569 + if (sp->eth_regs) iounmap((void*)sp->eth_regs);
570 + if (sp->dma_regs) iounmap((void*)sp->dma_regs);
571 +
572 + if (sp->rx_skb) {
573 + for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
574 + skb = sp->rx_skb[j];
575 + if (skb) {
576 + sp->rx_skb[j] = NULL;
577 + dev_kfree_skb(skb);
578 + }
579 + }
580 + kfree(sp->rx_skb);
581 + sp->rx_skb = NULL;
582 + }
583 +
584 + if (sp->tx_skb) {
585 + for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
586 + skb = sp->tx_skb[j];
587 + if (skb) {
588 + sp->tx_skb[j] = NULL;
589 + dev_kfree_skb(skb);
590 + }
591 + }
592 + kfree(sp->tx_skb);
593 + sp->tx_skb = NULL;
594 + }
595 +}
596 +
597 +static int ar2313_setup_timer(struct net_device *dev)
598 +{
599 + struct ar2313_private *sp = dev->priv;
600 +
601 + init_timer(&sp->link_timer);
602 +
603 + sp->link_timer.function = ar2313_link_timer_fn;
604 + sp->link_timer.data = (int) dev;
605 + sp->link_timer.expires = jiffies + HZ;
606 +
607 + add_timer(&sp->link_timer);
608 + return 0;
609 +
610 +}
611 +
612 +static void ar2313_link_timer_fn(unsigned long data)
613 +{
614 + struct net_device *dev = (struct net_device *) data;
615 + struct ar2313_private *sp = dev->priv;
616 +
617 + // see if the link status changed
618 + // This was needed to make sure we set the PHY to the
619 + // autonegotiated value of half or full duplex.
620 + ar2313_check_link(dev);
621 +
622 + // Loop faster when we don't have link.
623 + // This was needed to speed up the AP bootstrap time.
624 + if(sp->link == 0) {
625 + mod_timer(&sp->link_timer, jiffies + HZ/2);
626 + } else {
627 + mod_timer(&sp->link_timer, jiffies + LINK_TIMER);
628 + }
629 +}
630 +
631 +static void ar2313_check_link(struct net_device *dev)
632 +{
633 + struct ar2313_private *sp = dev->priv;
634 + u16 phyData;
635 +
636 + phyData = armiiread(sp->phy, MII_BMSR);
637 + if (sp->phyData != phyData) {
638 + if (phyData & BMSR_LSTATUS) {
639 + /* link is present, ready link partner ability to deterine duplexity */
640 + int duplex = 0;
641 + u16 reg;
642 +
643 + sp->link = 1;
644 + reg = armiiread(sp->phy, MII_BMCR);
645 + if (reg & BMCR_ANENABLE) {
646 + /* auto neg enabled */
647 + reg = armiiread(sp->phy, MII_LPA);
648 + duplex = (reg & (LPA_100FULL|LPA_10FULL))? 1:0;
649 + } else {
650 + /* no auto neg, just read duplex config */
651 + duplex = (reg & BMCR_FULLDPLX)? 1:0;
652 + }
653 +
654 + printk(KERN_INFO "%s: Configuring MAC for %s duplex\n", dev->name,
655 + (duplex)? "full":"half");
656 +
657 + if (duplex) {
658 + /* full duplex */
659 + sp->eth_regs->mac_control = ((sp->eth_regs->mac_control | MAC_CONTROL_F) &
660 + ~MAC_CONTROL_DRO);
661 + } else {
662 + /* half duplex */
663 + sp->eth_regs->mac_control = ((sp->eth_regs->mac_control | MAC_CONTROL_DRO) &
664 + ~MAC_CONTROL_F);
665 + }
666 + } else {
667 + /* no link */
668 + sp->link = 0;
669 + }
670 + sp->phyData = phyData;
671 + }
672 +}
673 +
674 +static int
675 +ar2313_reset_reg(struct net_device *dev)
676 +{
677 + struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
678 + unsigned int ethsal, ethsah;
679 + unsigned int flags;
680 +
681 + *sp->int_regs |= ar_int_mac_mask;
682 + mdelay(10);
683 + *sp->int_regs &= ~ar_int_mac_mask;
684 + mdelay(10);
685 + *sp->int_regs |= ar_int_phy_mask;
686 + mdelay(10);
687 + *sp->int_regs &= ~ar_int_phy_mask;
688 + mdelay(10);
689 +
690 + sp->dma_regs->bus_mode = (DMA_BUS_MODE_SWR);
691 + mdelay(10);
692 + sp->dma_regs->bus_mode = ((32 << DMA_BUS_MODE_PBL_SHIFT) | DMA_BUS_MODE_BLE);
693 +
694 + /* enable interrupts */
695 + sp->dma_regs->intr_ena = (DMA_STATUS_AIS |
696 + DMA_STATUS_NIS |
697 + DMA_STATUS_RI |
698 + DMA_STATUS_TI |
699 + DMA_STATUS_FBE);
700 + sp->dma_regs->xmt_base = K1_TO_PHYS(sp->tx_ring);
701 + sp->dma_regs->rcv_base = K1_TO_PHYS(sp->rx_ring);
702 + sp->dma_regs->control = (DMA_CONTROL_SR | DMA_CONTROL_ST | DMA_CONTROL_SF);
703 +
704 + sp->eth_regs->flow_control = (FLOW_CONTROL_FCE);
705 + sp->eth_regs->vlan_tag = (0x8100);
706 +
707 + /* Enable Ethernet Interface */
708 + flags = (MAC_CONTROL_TE | /* transmit enable */
709 + MAC_CONTROL_PM | /* pass mcast */
710 + MAC_CONTROL_F | /* full duplex */
711 + MAC_CONTROL_HBD); /* heart beat disabled */
712 +
713 + if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
714 + flags |= MAC_CONTROL_PR;
715 + }
716 + sp->eth_regs->mac_control = flags;
717 +
718 + /* Set all Ethernet station address registers to their initial values */
719 + ethsah = ((((u_int)(dev->dev_addr[5]) << 8) & (u_int)0x0000FF00) |
720 + (((u_int)(dev->dev_addr[4]) << 0) & (u_int)0x000000FF));
721 +
722 + ethsal = ((((u_int)(dev->dev_addr[3]) << 24) & (u_int)0xFF000000) |
723 + (((u_int)(dev->dev_addr[2]) << 16) & (u_int)0x00FF0000) |
724 + (((u_int)(dev->dev_addr[1]) << 8) & (u_int)0x0000FF00) |
725 + (((u_int)(dev->dev_addr[0]) << 0) & (u_int)0x000000FF) );
726 +
727 + sp->eth_regs->mac_addr[0] = ethsah;
728 + sp->eth_regs->mac_addr[1] = ethsal;
729 +
730 + mdelay(10);
731 +
732 + return(0);
733 +}
734 +
735 +
736 +static int ar2313_init(struct net_device *dev)
737 +{
738 + struct ar2313_private *sp = dev->priv;
739 + int ecode=0;
740 +
741 + /*
742 + * Allocate descriptors
743 + */
744 + if (ar2313_allocate_descriptors(dev)) {
745 + printk("%s: %s: ar2313_allocate_descriptors failed\n",
746 + dev->name, __FUNCTION__);
747 + ecode = -EAGAIN;
748 + goto init_error;
749 + }
750 +
751 + /*
752 + * Get the memory for the skb rings.
753 + */
754 + if(sp->rx_skb == NULL) {
755 + sp->rx_skb = kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES, GFP_KERNEL);
756 + if (!(sp->rx_skb)) {
757 + printk("%s: %s: rx_skb kmalloc failed\n",
758 + dev->name, __FUNCTION__);
759 + ecode = -EAGAIN;
760 + goto init_error;
761 + }
762 + }
763 + memset(sp->rx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
764 +
765 + if(sp->tx_skb == NULL) {
766 + sp->tx_skb = kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES, GFP_KERNEL);
767 + if (!(sp->tx_skb)) {
768 + printk("%s: %s: tx_skb kmalloc failed\n",
769 + dev->name, __FUNCTION__);
770 + ecode = -EAGAIN;
771 + goto init_error;
772 + }
773 + }
774 + memset(sp->tx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
775 +
776 + /*
777 + * Set tx_csm before we start receiving interrupts, otherwise
778 + * the interrupt handler might think it is supposed to process
779 + * tx ints before we are up and running, which may cause a null
780 + * pointer access in the int handler.
781 + */
782 + sp->rx_skbprd = 0;
783 + sp->cur_rx = 0;
784 + sp->tx_prd = 0;
785 + sp->tx_csm = 0;
786 +
787 + /*
788 + * Zero the stats before starting the interface
789 + */
790 + memset(&sp->stats, 0, sizeof(sp->stats));
791 +
792 + /*
793 + * We load the ring here as there seem to be no way to tell the
794 + * firmware to wipe the ring without re-initializing it.
795 + */
796 + ar2313_load_rx_ring(dev, RX_RING_SIZE);
797 +
798 + /*
799 + * Init hardware
800 + */
801 + ar2313_reset_reg(dev);
802 +
803 + /*
804 + * Get the IRQ
805 + */
806 + ecode = request_irq(dev->irq, &ar2313_interrupt, IRQF_SHARED | IRQF_DISABLED | IRQF_SAMPLE_RANDOM, dev->name, dev);
807 + if (ecode) {
808 + printk(KERN_WARNING "%s: %s: Requested IRQ %d is busy\n",
809 + dev->name, __FUNCTION__, dev->irq);
810 + goto init_error;
811 + }
812 +
813 +
814 + tasklet_enable(&sp->rx_tasklet);
815 +
816 + return 0;
817 +
818 + init_error:
819 + ar2313_init_cleanup(dev);
820 + return ecode;
821 +}
822 +
823 +/*
824 + * Load the rx ring.
825 + *
826 + * Loading rings is safe without holding the spin lock since this is
827 + * done only before the device is enabled, thus no interrupts are
828 + * generated and by the interrupt handler/tasklet handler.
829 + */
830 +static void ar2313_load_rx_ring(struct net_device *dev, int nr_bufs)
831 +{
832 +
833 + struct ar2313_private *sp = ((struct net_device *)dev)->priv;
834 + short i, idx;
835 +
836 + idx = sp->rx_skbprd;
837 +
838 + for (i = 0; i < nr_bufs; i++) {
839 + struct sk_buff *skb;
840 + ar2313_descr_t *rd;
841 +
842 + if (sp->rx_skb[idx]) {
843 +#if DEBUG_RX
844 + printk(KERN_INFO "ar2313 rx refill full\n");
845 +#endif /* DEBUG */
846 + break;
847 + }
848 +
849 + // partha: create additional room for the second GRE fragment
850 + skb = alloc_skb(AR2313_BUFSIZE+128, GFP_ATOMIC);
851 + if (!skb) {
852 + printk("\n\n\n\n %s: No memory in system\n\n\n\n", __FUNCTION__);
853 + break;
854 + }
855 + // partha: create additional room in the front for tx pkt capture
856 + skb_reserve(skb, 32);
857 +
858 + /*
859 + * Make sure IP header starts on a fresh cache line.
860 + */
861 + skb->dev = dev;
862 + skb_reserve(skb, RX_OFFSET);
863 + sp->rx_skb[idx] = skb;
864 +
865 + rd = (ar2313_descr_t *) &sp->rx_ring[idx];
866 +
867 + /* initialize dma descriptor */
868 + rd->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
869 + DMA_RX1_CHAINED);
870 + rd->addr = virt_to_phys(skb->data);
871 + rd->descr = virt_to_phys(&sp->rx_ring[(idx+1) & (AR2313_DESCR_ENTRIES-1)]);
872 + rd->status = DMA_RX_OWN;
873 +
874 + idx = DSC_NEXT(idx);
875 + }
876 +
877 + if (!i) {
878 +#if DEBUG_ERR
879 + printk(KERN_INFO "Out of memory when allocating standard receive buffers\n");
880 +#endif /* DEBUG */
881 + } else {
882 + sp->rx_skbprd = idx;
883 + }
884 +
885 + return;
886 +}
887 +
888 +#define AR2313_MAX_PKTS_PER_CALL 64
889 +
890 +static int ar2313_rx_int(struct net_device *dev)
891 +{
892 + struct ar2313_private *sp = dev->priv;
893 + struct sk_buff *skb, *skb_new;
894 + ar2313_descr_t *rxdesc;
895 + unsigned int status;
896 + u32 idx;
897 + int pkts = 0;
898 + int rval;
899 +
900 + idx = sp->cur_rx;
901 +
902 + /* process at most the entire ring and then wait for another interrupt */
903 + while(1) {
904 +
905 + rxdesc = &sp->rx_ring[idx];
906 + status = rxdesc->status;
907 + if (status & DMA_RX_OWN) {
908 + /* SiByte owns descriptor or descr not yet filled in */
909 + rval = 0;
910 + break;
911 + }
912 +
913 + if (++pkts > AR2313_MAX_PKTS_PER_CALL) {
914 + rval = 1;
915 + break;
916 + }
917 +
918 +#if DEBUG_RX
919 + printk("index %d\n", idx);
920 + printk("RX status %08x\n", rxdesc->status);
921 + printk("RX devcs %08x\n", rxdesc->devcs );
922 + printk("RX addr %08x\n", rxdesc->addr );
923 + printk("RX descr %08x\n", rxdesc->descr );
924 +#endif
925 +
926 + if ((status & (DMA_RX_ERROR|DMA_RX_ERR_LENGTH)) &&
927 + (!(status & DMA_RX_LONG))){
928 +#if DEBUG_RX
929 + printk("%s: rx ERROR %08x\n", __FUNCTION__, status);
930 +#endif
931 + sp->stats.rx_errors++;
932 + sp->stats.rx_dropped++;
933 +
934 + /* add statistics counters */
935 + if (status & DMA_RX_ERR_CRC) sp->stats.rx_crc_errors++;
936 + if (status & DMA_RX_ERR_COL) sp->stats.rx_over_errors++;
937 + if (status & DMA_RX_ERR_LENGTH)
938 + sp->stats.rx_length_errors++;
939 + if (status & DMA_RX_ERR_RUNT) sp->stats.rx_over_errors++;
940 + if (status & DMA_RX_ERR_DESC) sp->stats.rx_over_errors++;
941 +
942 + } else {
943 + /* alloc new buffer. */
944 + skb_new = dev_alloc_skb(AR2313_BUFSIZE + RX_OFFSET + 128);
945 + if (skb_new != NULL) {
946 +
947 + skb = sp->rx_skb[idx];
948 + /* set skb */
949 + skb_put(skb, ((status >> DMA_RX_LEN_SHIFT) & 0x3fff) - CRC_LEN);
950 +
951 +#ifdef CONFIG_MERLOT
952 + if ((dev->am_pkt_handler == NULL) ||
953 + (dev->am_pkt_handler(skb, dev) == 0)) {
954 +#endif
955 + sp->stats.rx_bytes += skb->len;
956 + skb->protocol = eth_type_trans(skb, dev);
957 + /* pass the packet to upper layers */
958 +
959 +#ifdef CONFIG_MERLOT
960 + if (dev->asap_netif_rx)
961 + dev->asap_netif_rx(skb);
962 + else
963 +#endif
964 + netif_rx(skb);
965 +#ifdef CONFIG_MERLOT
966 + }
967 +#endif
968 + skb_new->dev = dev;
969 + /* 16 bit align */
970 + skb_reserve(skb_new, RX_OFFSET+32);
971 + /* reset descriptor's curr_addr */
972 + rxdesc->addr = virt_to_phys(skb_new->data);
973 +
974 + sp->stats.rx_packets++;
975 + sp->rx_skb[idx] = skb_new;
976 +
977 + } else {
978 + sp->stats.rx_dropped++;
979 + }
980 + }
981 +
982 + rxdesc->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
983 + DMA_RX1_CHAINED);
984 + rxdesc->status = DMA_RX_OWN;
985 +
986 + idx = DSC_NEXT(idx);
987 + }
988 +
989 + sp->cur_rx = idx;
990 +
991 + return rval;
992 +}
993 +
994 +
995 +static void ar2313_tx_int(struct net_device *dev)
996 +{
997 + struct ar2313_private *sp = dev->priv;
998 + u32 idx;
999 + struct sk_buff *skb;
1000 + ar2313_descr_t *txdesc;
1001 + unsigned int status=0;
1002 +
1003 + idx = sp->tx_csm;
1004 +
1005 + while (idx != sp->tx_prd) {
1006 +
1007 + txdesc = &sp->tx_ring[idx];
1008 +
1009 +#if DEBUG_TX
1010 + printk("%s: TXINT: csm=%d idx=%d prd=%d status=%x devcs=%x addr=%08x descr=%x\n",
1011 + dev->name, sp->tx_csm, idx, sp->tx_prd,
1012 + txdesc->status, txdesc->devcs, txdesc->addr, txdesc->descr);
1013 +#endif /* DEBUG */
1014 +
1015 + if ((status = txdesc->status) & DMA_TX_OWN) {
1016 + /* ar2313 dma still owns descr */
1017 + break;
1018 + }
1019 + /* done with this descriptor */
1020 + dma_unmap_single(NULL, txdesc->addr, txdesc->devcs & DMA_TX1_BSIZE_MASK, DMA_TO_DEVICE);
1021 + txdesc->status = 0;
1022 +
1023 + if (status & DMA_TX_ERROR){
1024 + sp->stats.tx_errors++;
1025 + sp->stats.tx_dropped++;
1026 + if(status & DMA_TX_ERR_UNDER)
1027 + sp->stats.tx_fifo_errors++;
1028 + if(status & DMA_TX_ERR_HB)
1029 + sp->stats.tx_heartbeat_errors++;
1030 + if(status & (DMA_TX_ERR_LOSS |
1031 + DMA_TX_ERR_LINK))
1032 + sp->stats.tx_carrier_errors++;
1033 + if (status & (DMA_TX_ERR_LATE|
1034 + DMA_TX_ERR_COL |
1035 + DMA_TX_ERR_JABBER |
1036 + DMA_TX_ERR_DEFER))
1037 + sp->stats.tx_aborted_errors++;
1038 + } else {
1039 + /* transmit OK */
1040 + sp->stats.tx_packets++;
1041 + }
1042 +
1043 + skb = sp->tx_skb[idx];
1044 + sp->tx_skb[idx] = NULL;
1045 + idx = DSC_NEXT(idx);
1046 + sp->stats.tx_bytes += skb->len;
1047 + dev_kfree_skb_irq(skb);
1048 + }
1049 +
1050 + sp->tx_csm = idx;
1051 +
1052 + return;
1053 +}
1054 +
1055 +
1056 +static void
1057 +rx_tasklet_func(unsigned long data)
1058 +{
1059 + struct net_device *dev = (struct net_device *) data;
1060 + struct ar2313_private *sp = dev->priv;
1061 +
1062 + if (sp->unloading) {
1063 + return;
1064 + }
1065 +
1066 + if (ar2313_rx_int(dev)) {
1067 + tasklet_hi_schedule(&sp->rx_tasklet);
1068 + }
1069 + else {
1070 + unsigned long flags;
1071 + spin_lock_irqsave(&sp->lock, flags);
1072 + sp->dma_regs->intr_ena |= DMA_STATUS_RI;
1073 + spin_unlock_irqrestore(&sp->lock, flags);
1074 + }
1075 +}
1076 +
1077 +static void
1078 +rx_schedule(struct net_device *dev)
1079 +{
1080 + struct ar2313_private *sp = dev->priv;
1081 +
1082 + sp->dma_regs->intr_ena &= ~DMA_STATUS_RI;
1083 +
1084 + tasklet_hi_schedule(&sp->rx_tasklet);
1085 +}
1086 +
1087 +static irqreturn_t ar2313_interrupt(int irq, void *dev_id)
1088 +{
1089 + struct net_device *dev = (struct net_device *)dev_id;
1090 + struct ar2313_private *sp = dev->priv;
1091 + unsigned int status, enabled;
1092 +
1093 + /* clear interrupt */
1094 + /*
1095 + * Don't clear RI bit if currently disabled.
1096 + */
1097 + status = sp->dma_regs->status;
1098 + enabled = sp->dma_regs->intr_ena;
1099 + sp->dma_regs->status = status & enabled;
1100 +
1101 + if (status & DMA_STATUS_NIS) {
1102 + /* normal status */
1103 + /*
1104 + * Don't schedule rx processing if interrupt
1105 + * is already disabled.
1106 + */
1107 + if (status & enabled & DMA_STATUS_RI) {
1108 + /* receive interrupt */
1109 + rx_schedule(dev);
1110 + }
1111 + if (status & DMA_STATUS_TI) {
1112 + /* transmit interrupt */
1113 + ar2313_tx_int(dev);
1114 + }
1115 + }
1116 +
1117 + if (status & DMA_STATUS_AIS) {
1118 +#if DEBUG_INT
1119 + printk("%s: AIS set %08x & %x\n", __FUNCTION__,
1120 + status, (DMA_STATUS_FBE | DMA_STATUS_TPS));
1121 +#endif
1122 + /* abnormal status */
1123 + if (status & (DMA_STATUS_FBE | DMA_STATUS_TPS)) {
1124 + ar2313_restart(dev);
1125 + }
1126 + }
1127 + return IRQ_HANDLED;
1128 +}
1129 +
1130 +
1131 +static int ar2313_open(struct net_device *dev)
1132 +{
1133 + struct ar2313_private *sp;
1134 +
1135 + sp = dev->priv;
1136 +
1137 + dev->mtu = 1500;
1138 + netif_start_queue(dev);
1139 +
1140 + sp->eth_regs->mac_control |= MAC_CONTROL_RE;
1141 +
1142 + AR2313_MOD_INC_USE_COUNT;
1143 +
1144 + return 0;
1145 +}
1146 +
1147 +static void ar2313_halt(struct net_device *dev)
1148 +{
1149 + struct ar2313_private *sp = dev->priv;
1150 + int j;
1151 +
1152 + tasklet_disable(&sp->rx_tasklet);
1153 +
1154 + /* kill the MAC */
1155 + sp->eth_regs->mac_control &= ~(MAC_CONTROL_RE | /* disable Receives */
1156 + MAC_CONTROL_TE); /* disable Transmits */
1157 + /* stop dma */
1158 + sp->dma_regs->control = 0;
1159 + sp->dma_regs->bus_mode = DMA_BUS_MODE_SWR;
1160 +
1161 + /* place phy and MAC in reset */
1162 + *sp->int_regs |= (ar_int_mac_mask | ar_int_phy_mask);
1163 +
1164 + /* free buffers on tx ring */
1165 + for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
1166 + struct sk_buff *skb;
1167 + ar2313_descr_t *txdesc;
1168 +
1169 + txdesc = &sp->tx_ring[j];
1170 + txdesc->descr = 0;
1171 +
1172 + skb = sp->tx_skb[j];
1173 + if (skb) {
1174 + dev_kfree_skb(skb);
1175 + sp->tx_skb[j] = NULL;
1176 + }
1177 + }
1178 +}
1179 +
1180 +/*
1181 + * close should do nothing. Here's why. It's called when
1182 + * 'ifconfig bond0 down' is run. If it calls free_irq then
1183 + * the irq is gone forever ! When bond0 is made 'up' again,
1184 + * the ar2313_open () does not call request_irq (). Worse,
1185 + * the call to ar2313_halt() generates a WDOG reset due to
1186 + * the write to 'sp->int_regs' and the box reboots.
1187 + * Commenting this out is good since it allows the
1188 + * system to resume when bond0 is made up again.
1189 + */
1190 +static int ar2313_close(struct net_device *dev)
1191 +{
1192 +#if 0
1193 + /*
1194 + * Disable interrupts
1195 + */
1196 + disable_irq(dev->irq);
1197 +
1198 + /*
1199 + * Without (or before) releasing irq and stopping hardware, this
1200 + * is an absolute non-sense, by the way. It will be reset instantly
1201 + * by the first irq.
1202 + */
1203 + netif_stop_queue(dev);
1204 +
1205 + /* stop the MAC and DMA engines */
1206 + ar2313_halt(dev);
1207 +
1208 + /* release the interrupt */
1209 + free_irq(dev->irq, dev);
1210 +
1211 +#endif
1212 + AR2313_MOD_DEC_USE_COUNT;
1213 + return 0;
1214 +}
1215 +
1216 +static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev)
1217 +{
1218 + struct ar2313_private *sp = dev->priv;
1219 + ar2313_descr_t *td;
1220 + u32 idx;
1221 +
1222 + idx = sp->tx_prd;
1223 + td = &sp->tx_ring[idx];
1224 +
1225 + if (td->status & DMA_TX_OWN) {
1226 +#if DEBUG_TX
1227 + printk("%s: No space left to Tx\n", __FUNCTION__);
1228 +#endif
1229 + /* free skbuf and lie to the caller that we sent it out */
1230 + sp->stats.tx_dropped++;
1231 + dev_kfree_skb(skb);
1232 +
1233 + /* restart transmitter in case locked */
1234 + sp->dma_regs->xmt_poll = 0;
1235 + return 0;
1236 + }
1237 +
1238 + /* Setup the transmit descriptor. */
1239 + td->devcs = ((skb->len << DMA_TX1_BSIZE_SHIFT) |
1240 + (DMA_TX1_LS|DMA_TX1_IC|DMA_TX1_CHAINED));
1241 + td->addr = dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE);
1242 + td->status = DMA_TX_OWN;
1243 +
1244 + /* kick transmitter last */
1245 + sp->dma_regs->xmt_poll = 0;
1246 +
1247 +#if DEBUG_TX
1248 + printk("index %d\n", idx);
1249 + printk("TX status %08x\n", td->status);
1250 + printk("TX devcs %08x\n", td->devcs );
1251 + printk("TX addr %08x\n", td->addr );
1252 + printk("TX descr %08x\n", td->descr );
1253 +#endif
1254 +
1255 + sp->tx_skb[idx] = skb;
1256 + idx = DSC_NEXT(idx);
1257 + sp->tx_prd = idx;
1258 +
1259 + //dev->trans_start = jiffies;
1260 +
1261 + return 0;
1262 +}
1263 +
1264 +static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1265 +{
1266 + struct ar2313_private *np = dev->priv;
1267 + u32 tmp;
1268 +
1269 + ecmd->supported =
1270 + (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
1271 + SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1272 + SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
1273 +
1274 + ecmd->port = PORT_TP;
1275 + /* only supports internal transceiver */
1276 + ecmd->transceiver = XCVR_INTERNAL;
1277 + /* not sure what this is for */
1278 + ecmd->phy_address = 1;
1279 +
1280 + ecmd->advertising = ADVERTISED_MII;
1281 + tmp = armiiread(np->phy, MII_ADVERTISE);
1282 + if (tmp & ADVERTISE_10HALF)
1283 + ecmd->advertising |= ADVERTISED_10baseT_Half;
1284 + if (tmp & ADVERTISE_10FULL)
1285 + ecmd->advertising |= ADVERTISED_10baseT_Full;
1286 + if (tmp & ADVERTISE_100HALF)
1287 + ecmd->advertising |= ADVERTISED_100baseT_Half;
1288 + if (tmp & ADVERTISE_100FULL)
1289 + ecmd->advertising |= ADVERTISED_100baseT_Full;
1290 +
1291 + tmp = armiiread(np->phy, MII_BMCR);
1292 + if (tmp & BMCR_ANENABLE) {
1293 + ecmd->advertising |= ADVERTISED_Autoneg;
1294 + ecmd->autoneg = AUTONEG_ENABLE;
1295 + } else {
1296 + ecmd->autoneg = AUTONEG_DISABLE;
1297 + }
1298 +
1299 + if (ecmd->autoneg == AUTONEG_ENABLE) {
1300 + tmp = armiiread(np->phy, MII_LPA);
1301 + if (tmp & (LPA_100FULL|LPA_10FULL)) {
1302 + ecmd->duplex = DUPLEX_FULL;
1303 + } else {
1304 + ecmd->duplex = DUPLEX_HALF;
1305 + }
1306 + if (tmp & (LPA_100FULL|LPA_100HALF)) {
1307 + ecmd->speed = SPEED_100;
1308 + } else {
1309 + ecmd->speed = SPEED_10;
1310 + }
1311 + } else {
1312 + if (tmp & BMCR_FULLDPLX) {
1313 + ecmd->duplex = DUPLEX_FULL;
1314 + } else {
1315 + ecmd->duplex = DUPLEX_HALF;
1316 + }
1317 + if (tmp & BMCR_SPEED100) {
1318 + ecmd->speed = SPEED_100;
1319 + } else {
1320 + ecmd->speed = SPEED_10;
1321 + }
1322 + }
1323 +
1324 + /* ignore maxtxpkt, maxrxpkt for now */
1325 +
1326 + return 0;
1327 +}
1328 +
1329 +static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1330 +{
1331 + struct ar2313_private *np = dev->priv;
1332 + u32 tmp;
1333 +
1334 + if (ecmd->speed != SPEED_10 && ecmd->speed != SPEED_100)
1335 + return -EINVAL;
1336 + if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1337 + return -EINVAL;
1338 + if (ecmd->port != PORT_TP)
1339 + return -EINVAL;
1340 + if (ecmd->transceiver != XCVR_INTERNAL)
1341 + return -EINVAL;
1342 + if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
1343 + return -EINVAL;
1344 + /* ignore phy_address, maxtxpkt, maxrxpkt for now */
1345 +
1346 + /* WHEW! now lets bang some bits */
1347 +
1348 + tmp = armiiread(np->phy, MII_BMCR);
1349 + if (ecmd->autoneg == AUTONEG_ENABLE) {
1350 + /* turn on autonegotiation */
1351 + tmp |= BMCR_ANENABLE;
1352 + printk("%s: Enabling auto-neg\n", dev->name);
1353 + } else {
1354 + /* turn off auto negotiation, set speed and duplexity */
1355 + tmp &= ~(BMCR_ANENABLE | BMCR_SPEED100 | BMCR_FULLDPLX);
1356 + if (ecmd->speed == SPEED_100)
1357 + tmp |= BMCR_SPEED100;
1358 + if (ecmd->duplex == DUPLEX_FULL)
1359 + tmp |= BMCR_FULLDPLX;
1360 + printk("%s: Hard coding %d/%s\n", dev->name,
1361 + (ecmd->speed == SPEED_100)? 100:10,
1362 + (ecmd->duplex == DUPLEX_FULL)? "full":"half");
1363 + }
1364 + armiiwrite(np->phy, MII_BMCR, tmp);
1365 + np->phyData = 0;
1366 + return 0;
1367 +}
1368 +
1369 +static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
1370 +{
1371 + struct ar2313_private *np = dev->priv;
1372 + u32 cmd;
1373 +
1374 + if (get_user(cmd, (u32 *)useraddr))
1375 + return -EFAULT;
1376 +
1377 + switch (cmd) {
1378 + /* get settings */
1379 + case ETHTOOL_GSET: {
1380 + struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1381 + spin_lock_irq(&np->lock);
1382 + netdev_get_ecmd(dev, &ecmd);
1383 + spin_unlock_irq(&np->lock);
1384 + if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1385 + return -EFAULT;
1386 + return 0;
1387 + }
1388 + /* set settings */
1389 + case ETHTOOL_SSET: {
1390 + struct ethtool_cmd ecmd;
1391 + int r;
1392 + if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1393 + return -EFAULT;
1394 + spin_lock_irq(&np->lock);
1395 + r = netdev_set_ecmd(dev, &ecmd);
1396 + spin_unlock_irq(&np->lock);
1397 + return r;
1398 + }
1399 + /* restart autonegotiation */
1400 + case ETHTOOL_NWAY_RST: {
1401 + int tmp;
1402 + int r = -EINVAL;
1403 + /* if autoneg is off, it's an error */
1404 + tmp = armiiread(np->phy, MII_BMCR);
1405 + if (tmp & BMCR_ANENABLE) {
1406 + tmp |= (BMCR_ANRESTART);
1407 + armiiwrite(np->phy, MII_BMCR, tmp);
1408 + r = 0;
1409 + }
1410 + return r;
1411 + }
1412 + /* get link status */
1413 + case ETHTOOL_GLINK: {
1414 + struct ethtool_value edata = {ETHTOOL_GLINK};
1415 + edata.data = (armiiread(np->phy, MII_BMSR)&BMSR_LSTATUS) ? 1:0;
1416 + if (copy_to_user(useraddr, &edata, sizeof(edata)))
1417 + return -EFAULT;
1418 + return 0;
1419 + }
1420 + }
1421 +
1422 + return -EOPNOTSUPP;
1423 +}
1424 +
1425 +static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1426 +{
1427 + struct mii_ioctl_data *data = (struct mii_ioctl_data *)&ifr->ifr_data;
1428 +
1429 + switch (cmd) {
1430 + case SIOCDEVPRIVATE: {
1431 + struct ar2313_cmd scmd;
1432 +
1433 + if (copy_from_user(&scmd, ifr->ifr_data, sizeof(scmd)))
1434 + return -EFAULT;
1435 +
1436 +#if DEBUG
1437 + printk("%s: ioctl devprivate c=%d a=%x l=%d m=%d d=%x,%x\n",
1438 + dev->name, scmd.cmd,
1439 + scmd.address, scmd.length,
1440 + scmd.mailbox, scmd.data[0], scmd.data[1]);
1441 +#endif /* DEBUG */
1442 +
1443 + switch (scmd.cmd) {
1444 + case AR2313_READ_DATA:
1445 + if(scmd.length==4){
1446 + scmd.data[0] = *((u32*)scmd.address);
1447 + } else if(scmd.length==2) {
1448 + scmd.data[0] = *((u16*)scmd.address);
1449 + } else if (scmd.length==1) {
1450 + scmd.data[0] = *((u8*)scmd.address);
1451 + } else {
1452 + return -EOPNOTSUPP;
1453 + }
1454 + if(copy_to_user(ifr->ifr_data, &scmd, sizeof(scmd)))
1455 + return -EFAULT;
1456 + break;
1457 +
1458 + case AR2313_WRITE_DATA:
1459 + if(scmd.length==4){
1460 + *((u32*)scmd.address) = scmd.data[0];
1461 + } else if(scmd.length==2) {
1462 + *((u16*)scmd.address) = scmd.data[0];
1463 + } else if (scmd.length==1) {
1464 + *((u8*)scmd.address) = scmd.data[0];
1465 + } else {
1466 + return -EOPNOTSUPP;
1467 + }
1468 + break;
1469 +
1470 + case AR2313_GET_VERSION:
1471 + // SAMEER: sprintf((char*) &scmd, "%s", ARUBA_VERSION);
1472 + if(copy_to_user(ifr->ifr_data, &scmd, sizeof(scmd)))
1473 + return -EFAULT;
1474 + break;
1475 +
1476 + default:
1477 + return -EOPNOTSUPP;
1478 + }
1479 + return 0;
1480 + }
1481 +
1482 + case SIOCETHTOOL:
1483 + return netdev_ethtool_ioctl(dev, (void *) ifr->ifr_data);
1484 +
1485 + case SIOCGMIIPHY: /* Get address of MII PHY in use. */
1486 + data->phy_id = 1;
1487 + /* Fall Through */
1488 +
1489 + case SIOCGMIIREG: /* Read MII PHY register. */
1490 + case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
1491 + data->val_out = armiiread(data->phy_id & 0x1f,
1492 + data->reg_num & 0x1f);
1493 + return 0;
1494 + case SIOCSMIIREG: /* Write MII PHY register. */
1495 + case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
1496 + if (!capable(CAP_NET_ADMIN))
1497 + return -EPERM;
1498 + armiiwrite(data->phy_id & 0x1f,
1499 + data->reg_num & 0x1f, data->val_in);
1500 + return 0;
1501 +
1502 + case SIOCSIFHWADDR:
1503 + if (copy_from_user(dev->dev_addr, ifr->ifr_data, sizeof(dev->dev_addr)))
1504 + return -EFAULT;
1505 + return 0;
1506 +
1507 + case SIOCGIFHWADDR:
1508 + if (copy_to_user(ifr->ifr_data, dev->dev_addr, sizeof(dev->dev_addr)))
1509 + return -EFAULT;
1510 + return 0;
1511 +
1512 + default:
1513 + break;
1514 + }
1515 +
1516 + return -EOPNOTSUPP;
1517 +}
1518 +
1519 +static struct net_device_stats *ar2313_get_stats(struct net_device *dev)
1520 +{
1521 + struct ar2313_private *sp = dev->priv;
1522 + return &sp->stats;
1523 +}
1524 +
1525 +static short
1526 +armiiread(short phy, short reg)
1527 +{
1528 + volatile ETHERNET_STRUCT * ethernet;
1529 +
1530 + ethernet = (volatile ETHERNET_STRUCT *)(ar_eth_base); /* always MAC 0 */
1531 + ethernet->mii_addr = ((reg << MII_ADDR_REG_SHIFT) |
1532 + (phy << MII_ADDR_PHY_SHIFT));
1533 + while (ethernet->mii_addr & MII_ADDR_BUSY);
1534 + return (ethernet->mii_data >> MII_DATA_SHIFT);
1535 +}
1536 +
1537 +static void
1538 +armiiwrite(short phy, short reg, short data)
1539 +{
1540 + volatile ETHERNET_STRUCT * ethernet;
1541 +
1542 + ethernet = (volatile ETHERNET_STRUCT *)(ar_eth_base); /* always MAC 0 */
1543 + while (ethernet->mii_addr & MII_ADDR_BUSY);
1544 + ethernet->mii_data = data << MII_DATA_SHIFT;
1545 + ethernet->mii_addr = ((reg << MII_ADDR_REG_SHIFT) |
1546 + (phy << MII_ADDR_PHY_SHIFT) |
1547 + MII_ADDR_WRITE);
1548 +}
1549 +
1550 diff -urN linux.old/drivers/net/ar2313/ar2313.h linux.eth/drivers/net/ar2313/ar2313.h
1551 --- linux.old/drivers/net/ar2313/ar2313.h 1970-01-01 01:00:00.000000000 +0100
1552 +++ linux.eth/drivers/net/ar2313/ar2313.h 2006-12-16 04:30:11.000000000 +0100
1553 @@ -0,0 +1,191 @@
1554 +#ifndef _AR2313_H_
1555 +#define _AR2313_H_
1556 +
1557 +#include <linux/autoconf.h>
1558 +#include <asm/bootinfo.h>
1559 +#include "platform.h"
1560 +
1561 +extern unsigned long mips_machtype;
1562 +
1563 +#undef ETHERNET_BASE
1564 +#define ETHERNET_BASE ar_eth_base
1565 +#define ETHERNET_SIZE 0x00100000
1566 +#define ETHERNET_MACS 2
1567 +
1568 +#undef DMA_BASE
1569 +#define DMA_BASE ar_dma_base
1570 +#define DMA_SIZE 0x00100000
1571 +
1572 +
1573 +/*
1574 + * probe link timer - 5 secs
1575 + */
1576 +#define LINK_TIMER (5*HZ)
1577 +
1578 +/*
1579 + * Interrupt register base address
1580 + */
1581 +#define INTERRUPT_BASE PHYS_TO_K1(ar_int_base)
1582 +
1583 +/*
1584 + * Reset Register
1585 + */
1586 +#define AR531X_RESET (AR531X_RESETTMR + 0x0020)
1587 +#define RESET_SYSTEM 0x00000001 /* cold reset full system */
1588 +#define RESET_PROC 0x00000002 /* cold reset MIPS core */
1589 +#define RESET_WLAN0 0x00000004 /* cold reset WLAN MAC and BB */
1590 +#define RESET_EPHY0 0x00000008 /* cold reset ENET0 phy */
1591 +#define RESET_EPHY1 0x00000010 /* cold reset ENET1 phy */
1592 +#define RESET_ENET0 0x00000020 /* cold reset ENET0 mac */
1593 +#define RESET_ENET1 0x00000040 /* cold reset ENET1 mac */
1594 +
1595 +#define IS_DMA_TX_INT(X) (((X) & (DMA_STATUS_TI)) != 0)
1596 +#define IS_DMA_RX_INT(X) (((X) & (DMA_STATUS_RI)) != 0)
1597 +#define IS_DRIVER_OWNED(X) (((X) & (DMA_TX_OWN)) == 0)
1598 +
1599 +#ifndef K1_TO_PHYS
1600 +// hack
1601 +#define K1_TO_PHYS(x) (((unsigned int)(x)) & 0x1FFFFFFF) /* kseg1 to physical */
1602 +#endif
1603 +
1604 +#ifndef PHYS_TO_K1
1605 +// hack
1606 +#define PHYS_TO_K1(x) (((unsigned int)(x)) | 0xA0000000) /* physical to kseg1 */
1607 +#endif
1608 +
1609 +#define AR2313_TX_TIMEOUT (HZ/4)
1610 +
1611 +/*
1612 + * Rings
1613 + */
1614 +#define DSC_RING_ENTRIES_SIZE (AR2313_DESCR_ENTRIES * sizeof(struct desc))
1615 +#define DSC_NEXT(idx) ((idx + 1) & (AR2313_DESCR_ENTRIES - 1))
1616 +
1617 +static inline int tx_space (u32 csm, u32 prd)
1618 +{
1619 + return (csm - prd - 1) & (AR2313_DESCR_ENTRIES - 1);
1620 +}
1621 +
1622 +#if MAX_SKB_FRAGS
1623 +#define TX_RESERVED (MAX_SKB_FRAGS+1) /* +1 for message header */
1624 +#define tx_ring_full(csm, prd) (tx_space(csm, prd) <= TX_RESERVED)
1625 +#else
1626 +#define tx_ring_full 0
1627 +#endif
1628 +
1629 +#define AR2313_MBGET 2
1630 +#define AR2313_MBSET 3
1631 +#define AR2313_PCI_RECONFIG 4
1632 +#define AR2313_PCI_DUMP 5
1633 +#define AR2313_TEST_PANIC 6
1634 +#define AR2313_TEST_NULLPTR 7
1635 +#define AR2313_READ_DATA 8
1636 +#define AR2313_WRITE_DATA 9
1637 +#define AR2313_GET_VERSION 10
1638 +#define AR2313_TEST_HANG 11
1639 +#define AR2313_SYNC 12
1640 +
1641 +
1642 +struct ar2313_cmd {
1643 + u32 cmd;
1644 + u32 address; /* virtual address of image */
1645 + u32 length; /* size of image to download */
1646 + u32 mailbox; /* mailbox to get/set */
1647 + u32 data[2]; /* contents of mailbox to read/write */
1648 +};
1649 +
1650 +
1651 +/*
1652 + * Struct private for the Sibyte.
1653 + *
1654 + * Elements are grouped so variables used by the tx handling goes
1655 + * together, and will go into the same cache lines etc. in order to
1656 + * avoid cache line contention between the rx and tx handling on SMP.
1657 + *
1658 + * Frequently accessed variables are put at the beginning of the
1659 + * struct to help the compiler generate better/shorter code.
1660 + */
1661 +struct ar2313_private
1662 +{
1663 + struct net_device *dev;
1664 + int version;
1665 + u32 mb[2];
1666 +
1667 + volatile ETHERNET_STRUCT *eth_regs;
1668 + volatile DMA *dma_regs;
1669 + volatile u32 *int_regs;
1670 +
1671 + spinlock_t lock; /* Serialise access to device */
1672 +
1673 + /*
1674 + * RX and TX descriptors, must be adjacent
1675 + */
1676 + ar2313_descr_t *rx_ring;
1677 + ar2313_descr_t *tx_ring;
1678 +
1679 +
1680 + struct sk_buff **rx_skb;
1681 + struct sk_buff **tx_skb;
1682 +
1683 + /*
1684 + * RX elements
1685 + */
1686 + u32 rx_skbprd;
1687 + u32 cur_rx;
1688 +
1689 + /*
1690 + * TX elements
1691 + */
1692 + u32 tx_prd;
1693 + u32 tx_csm;
1694 +
1695 + /*
1696 + * Misc elements
1697 + */
1698 + int board_idx;
1699 + char name[48];
1700 + struct net_device_stats stats;
1701 + struct {
1702 + u32 address;
1703 + u32 length;
1704 + char *mapping;
1705 + } desc;
1706 +
1707 +
1708 + struct timer_list link_timer;
1709 + unsigned short phy; /* merlot phy = 1, samsung phy = 0x1f */
1710 + unsigned short mac;
1711 + unsigned short link; /* 0 - link down, 1 - link up */
1712 + u16 phyData;
1713 +
1714 + struct tasklet_struct rx_tasklet;
1715 + int unloading;
1716 +};
1717 +
1718 +
1719 +/*
1720 + * Prototypes
1721 + */
1722 +static int ar2313_init(struct net_device *dev);
1723 +#ifdef TX_TIMEOUT
1724 +static void ar2313_tx_timeout(struct net_device *dev);
1725 +#endif
1726 +#if 0
1727 +static void ar2313_multicast_list(struct net_device *dev);
1728 +#endif
1729 +static int ar2313_restart(struct net_device *dev);
1730 +#if DEBUG
1731 +static void ar2313_dump_regs(struct net_device *dev);
1732 +#endif
1733 +static void ar2313_load_rx_ring(struct net_device *dev, int bufs);
1734 +static irqreturn_t ar2313_interrupt(int irq, void *dev_id);
1735 +static int ar2313_open(struct net_device *dev);
1736 +static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev);
1737 +static int ar2313_close(struct net_device *dev);
1738 +static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
1739 +static void ar2313_init_cleanup(struct net_device *dev);
1740 +static int ar2313_setup_timer(struct net_device *dev);
1741 +static void ar2313_link_timer_fn(unsigned long data);
1742 +static void ar2313_check_link(struct net_device *dev);
1743 +static struct net_device_stats *ar2313_get_stats(struct net_device *dev);
1744 +#endif /* _AR2313_H_ */
1745 diff -urN linux.old/drivers/net/ar2313/ar2313_msg.h linux.eth/drivers/net/ar2313/ar2313_msg.h
1746 --- linux.old/drivers/net/ar2313/ar2313_msg.h 1970-01-01 01:00:00.000000000 +0100
1747 +++ linux.eth/drivers/net/ar2313/ar2313_msg.h 2006-12-16 04:30:11.000000000 +0100
1748 @@ -0,0 +1,17 @@
1749 +#ifndef _AR2313_MSG_H_
1750 +#define _AR2313_MSG_H_
1751 +
1752 +#define AR2313_MTU 1692
1753 +#define AR2313_PRIOS 1
1754 +#define AR2313_QUEUES (2*AR2313_PRIOS)
1755 +
1756 +#define AR2313_DESCR_ENTRIES 64
1757 +
1758 +typedef struct {
1759 + volatile unsigned int status; // OWN, Device control and status.
1760 + volatile unsigned int devcs; // pkt Control bits + Length
1761 + volatile unsigned int addr; // Current Address.
1762 + volatile unsigned int descr; // Next descriptor in chain.
1763 +} ar2313_descr_t;
1764 +
1765 +#endif /* _AR2313_MSG_H_ */
1766 diff -urN linux.old/drivers/net/ar2313/dma.h linux.eth/drivers/net/ar2313/dma.h
1767 --- linux.old/drivers/net/ar2313/dma.h 1970-01-01 01:00:00.000000000 +0100
1768 +++ linux.eth/drivers/net/ar2313/dma.h 2006-12-16 04:30:11.000000000 +0100
1769 @@ -0,0 +1,135 @@
1770 +#ifndef __ARUBA_DMA_H__
1771 +#define __ARUBA_DMA_H__
1772 +
1773 +/*******************************************************************************
1774 + *
1775 + * Copyright 2002 Integrated Device Technology, Inc.
1776 + * All rights reserved.
1777 + *
1778 + * DMA register definition.
1779 + *
1780 + * File : $Id: dma.h,v 1.3 2002/06/06 18:34:03 astichte Exp $
1781 + *
1782 + * Author : ryan.holmQVist@idt.com
1783 + * Date : 20011005
1784 + * Update :
1785 + * $Log: dma.h,v $
1786 + * Revision 1.3 2002/06/06 18:34:03 astichte
1787 + * Added XXX_PhysicalAddress and XXX_VirtualAddress
1788 + *
1789 + * Revision 1.2 2002/06/05 18:30:46 astichte
1790 + * Removed IDTField
1791 + *
1792 + * Revision 1.1 2002/05/29 17:33:21 sysarch
1793 + * jba File moved from vcode/include/idt/acacia
1794 + *
1795 + *
1796 + ******************************************************************************/
1797 +
1798 +#define AR_BIT(x) (1 << (x))
1799 +#define DMA_RX_ERR_CRC AR_BIT(1)
1800 +#define DMA_RX_ERR_DRIB AR_BIT(2)
1801 +#define DMA_RX_ERR_MII AR_BIT(3)
1802 +#define DMA_RX_EV2 AR_BIT(5)
1803 +#define DMA_RX_ERR_COL AR_BIT(6)
1804 +#define DMA_RX_LONG AR_BIT(7)
1805 +#define DMA_RX_LS AR_BIT(8) /* last descriptor */
1806 +#define DMA_RX_FS AR_BIT(9) /* first descriptor */
1807 +#define DMA_RX_MF AR_BIT(10) /* multicast frame */
1808 +#define DMA_RX_ERR_RUNT AR_BIT(11) /* runt frame */
1809 +#define DMA_RX_ERR_LENGTH AR_BIT(12) /* length error */
1810 +#define DMA_RX_ERR_DESC AR_BIT(14) /* descriptor error */
1811 +#define DMA_RX_ERROR AR_BIT(15) /* error summary */
1812 +#define DMA_RX_LEN_MASK 0x3fff0000
1813 +#define DMA_RX_LEN_SHIFT 16
1814 +#define DMA_RX_FILT AR_BIT(30)
1815 +#define DMA_RX_OWN AR_BIT(31) /* desc owned by DMA controller */
1816 +
1817 +#define DMA_RX1_BSIZE_MASK 0x000007ff
1818 +#define DMA_RX1_BSIZE_SHIFT 0
1819 +#define DMA_RX1_CHAINED AR_BIT(24)
1820 +#define DMA_RX1_RER AR_BIT(25)
1821 +
1822 +#define DMA_TX_ERR_UNDER AR_BIT(1) /* underflow error */
1823 +#define DMA_TX_ERR_DEFER AR_BIT(2) /* excessive deferral */
1824 +#define DMA_TX_COL_MASK 0x78
1825 +#define DMA_TX_COL_SHIFT 3
1826 +#define DMA_TX_ERR_HB AR_BIT(7) /* hearbeat failure */
1827 +#define DMA_TX_ERR_COL AR_BIT(8) /* excessive collisions */
1828 +#define DMA_TX_ERR_LATE AR_BIT(9) /* late collision */
1829 +#define DMA_TX_ERR_LINK AR_BIT(10) /* no carrier */
1830 +#define DMA_TX_ERR_LOSS AR_BIT(11) /* loss of carrier */
1831 +#define DMA_TX_ERR_JABBER AR_BIT(14) /* transmit jabber timeout */
1832 +#define DMA_TX_ERROR AR_BIT(15) /* frame aborted */
1833 +#define DMA_TX_OWN AR_BIT(31) /* descr owned by DMA controller */
1834 +
1835 +#define DMA_TX1_BSIZE_MASK 0x000007ff
1836 +#define DMA_TX1_BSIZE_SHIFT 0
1837 +#define DMA_TX1_CHAINED AR_BIT(24) /* chained descriptors */
1838 +#define DMA_TX1_TER AR_BIT(25) /* transmit end of ring */
1839 +#define DMA_TX1_FS AR_BIT(29) /* first segment */
1840 +#define DMA_TX1_LS AR_BIT(30) /* last segment */
1841 +#define DMA_TX1_IC AR_BIT(31) /* interrupt on completion */
1842 +
1843 +#define RCVPKT_LENGTH(X) (X >> 16) /* Received pkt Length */
1844 +
1845 +#define MAC_CONTROL_RE AR_BIT(2) /* receive enable */
1846 +#define MAC_CONTROL_TE AR_BIT(3) /* transmit enable */
1847 +#define MAC_CONTROL_DC AR_BIT(5) /* Deferral check*/
1848 +#define MAC_CONTROL_ASTP AR_BIT(8) /* Auto pad strip */
1849 +#define MAC_CONTROL_DRTY AR_BIT(10) /* Disable retry */
1850 +#define MAC_CONTROL_DBF AR_BIT(11) /* Disable bcast frames */
1851 +#define MAC_CONTROL_LCC AR_BIT(12) /* late collision ctrl */
1852 +#define MAC_CONTROL_HP AR_BIT(13) /* Hash Perfect filtering */
1853 +#define MAC_CONTROL_HASH AR_BIT(14) /* Unicast hash filtering */
1854 +#define MAC_CONTROL_HO AR_BIT(15) /* Hash only filtering */
1855 +#define MAC_CONTROL_PB AR_BIT(16) /* Pass Bad frames */
1856 +#define MAC_CONTROL_IF AR_BIT(17) /* Inverse filtering */
1857 +#define MAC_CONTROL_PR AR_BIT(18) /* promiscuous mode (valid frames only) */
1858 +#define MAC_CONTROL_PM AR_BIT(19) /* pass multicast */
1859 +#define MAC_CONTROL_F AR_BIT(20) /* full-duplex */
1860 +#define MAC_CONTROL_DRO AR_BIT(23) /* Disable Receive Own */
1861 +#define MAC_CONTROL_HBD AR_BIT(28) /* heart-beat disabled (MUST BE SET) */
1862 +#define MAC_CONTROL_BLE AR_BIT(30) /* big endian mode */
1863 +#define MAC_CONTROL_RA AR_BIT(31) /* receive all (valid and invalid frames) */
1864 +
1865 +#define MII_ADDR_BUSY AR_BIT(0)
1866 +#define MII_ADDR_WRITE AR_BIT(1)
1867 +#define MII_ADDR_REG_SHIFT 6
1868 +#define MII_ADDR_PHY_SHIFT 11
1869 +#define MII_DATA_SHIFT 0
1870 +
1871 +#define FLOW_CONTROL_FCE AR_BIT(1)
1872 +
1873 +#define DMA_BUS_MODE_SWR AR_BIT(0) /* software reset */
1874 +#define DMA_BUS_MODE_BLE AR_BIT(7) /* big endian mode */
1875 +#define DMA_BUS_MODE_PBL_SHIFT 8 /* programmable burst length 32 */
1876 +#define DMA_BUS_MODE_DBO AR_BIT(20) /* big-endian descriptors */
1877 +
1878 +#define DMA_STATUS_TI AR_BIT(0) /* transmit interrupt */
1879 +#define DMA_STATUS_TPS AR_BIT(1) /* transmit process stopped */
1880 +#define DMA_STATUS_TU AR_BIT(2) /* transmit buffer unavailable */
1881 +#define DMA_STATUS_TJT AR_BIT(3) /* transmit buffer timeout */
1882 +#define DMA_STATUS_UNF AR_BIT(5) /* transmit underflow */
1883 +#define DMA_STATUS_RI AR_BIT(6) /* receive interrupt */
1884 +#define DMA_STATUS_RU AR_BIT(7) /* receive buffer unavailable */
1885 +#define DMA_STATUS_RPS AR_BIT(8) /* receive process stopped */
1886 +#define DMA_STATUS_ETI AR_BIT(10) /* early transmit interrupt */
1887 +#define DMA_STATUS_FBE AR_BIT(13) /* fatal bus interrupt */
1888 +#define DMA_STATUS_ERI AR_BIT(14) /* early receive interrupt */
1889 +#define DMA_STATUS_AIS AR_BIT(15) /* abnormal interrupt summary */
1890 +#define DMA_STATUS_NIS AR_BIT(16) /* normal interrupt summary */
1891 +#define DMA_STATUS_RS_SHIFT 17 /* receive process state */
1892 +#define DMA_STATUS_TS_SHIFT 20 /* transmit process state */
1893 +#define DMA_STATUS_EB_SHIFT 23 /* error bits */
1894 +
1895 +#define DMA_CONTROL_SR AR_BIT(1) /* start receive */
1896 +#define DMA_CONTROL_ST AR_BIT(13) /* start transmit */
1897 +#define DMA_CONTROL_SF AR_BIT(21) /* store and forward */
1898 +
1899 +#endif // __ARUBA_DMA_H__
1900 +
1901 +
1902 +
1903 +
1904 +
1905 diff -urN linux.old/drivers/net/ar2313/Makefile linux.eth/drivers/net/ar2313/Makefile
1906 --- linux.old/drivers/net/ar2313/Makefile 1970-01-01 01:00:00.000000000 +0100
1907 +++ linux.eth/drivers/net/ar2313/Makefile 2006-12-16 04:30:11.000000000 +0100
1908 @@ -0,0 +1,5 @@
1909 +#
1910 +# Makefile for the AR2313 ethernet driver
1911 +#
1912 +
1913 +obj-$(CONFIG_AR2313) += ar2313.o
1914 diff -urN linux.old/drivers/net/ar2313/platform.h linux.eth/drivers/net/ar2313/platform.h
1915 --- linux.old/drivers/net/ar2313/platform.h 1970-01-01 01:00:00.000000000 +0100
1916 +++ linux.eth/drivers/net/ar2313/platform.h 2006-12-16 04:30:11.000000000 +0100
1917 @@ -0,0 +1,128 @@
1918 +/********************************************************************************
1919 + Title: $Source: platform.h,v $
1920 +
1921 + Author: Dan Steinberg
1922 + Copyright Integrated Device Technology 2001
1923 +
1924 + Purpose: AR2313 Register/Bit Definitions
1925 +
1926 + Update:
1927 + $Log: platform.h,v $
1928 +
1929 + Notes: See Merlot architecture spec for complete details. Note, all
1930 + addresses are virtual addresses in kseg1 (Uncached, Unmapped).
1931 +
1932 +********************************************************************************/
1933 +
1934 +#ifndef PLATFORM_H
1935 +#define PLATFORM_H
1936 +
1937 +#define BIT(x) (1 << (x))
1938 +
1939 +#define RESET_BASE 0xBC003020
1940 +#define RESET_VALUE 0x00000001
1941 +
1942 +/********************************************************************
1943 + * Device controller
1944 + ********************************************************************/
1945 +typedef struct {
1946 + volatile unsigned int flash0;
1947 +} DEVICE;
1948 +
1949 +#define device (*((volatile DEVICE *) DEV_CTL_BASE))
1950 +
1951 +// DDRC register
1952 +#define DEV_WP (1<<26)
1953 +
1954 +/********************************************************************
1955 + * DDR controller
1956 + ********************************************************************/
1957 +typedef struct {
1958 + volatile unsigned int ddrc0;
1959 + volatile unsigned int ddrc1;
1960 + volatile unsigned int ddrrefresh;
1961 +} DDR;
1962 +
1963 +#define ddr (*((volatile DDR *) DDR_BASE))
1964 +
1965 +// DDRC register
1966 +#define DDRC_CS(i) ((i&0x3)<<0)
1967 +#define DDRC_WE (1<<2)
1968 +
1969 +/********************************************************************
1970 + * Ethernet interfaces
1971 + ********************************************************************/
1972 +#define ETHERNET_BASE 0xB8200000
1973 +
1974 +//
1975 +// New Combo structure for Both Eth0 AND eth1
1976 +//
1977 +typedef struct {
1978 + volatile unsigned int mac_control; /* 0x00 */
1979 + volatile unsigned int mac_addr[2]; /* 0x04 - 0x08*/
1980 + volatile unsigned int mcast_table[2]; /* 0x0c - 0x10 */
1981 + volatile unsigned int mii_addr; /* 0x14 */
1982 + volatile unsigned int mii_data; /* 0x18 */
1983 + volatile unsigned int flow_control; /* 0x1c */
1984 + volatile unsigned int vlan_tag; /* 0x20 */
1985 + volatile unsigned int pad[7]; /* 0x24 - 0x3c */
1986 + volatile unsigned int ucast_table[8]; /* 0x40-0x5c */
1987 +
1988 +} ETHERNET_STRUCT;
1989 +
1990 +/********************************************************************
1991 + * Interrupt controller
1992 + ********************************************************************/
1993 +
1994 +typedef struct {
1995 + volatile unsigned int wdog_control; /* 0x08 */
1996 + volatile unsigned int wdog_timer; /* 0x0c */
1997 + volatile unsigned int misc_status; /* 0x10 */
1998 + volatile unsigned int misc_mask; /* 0x14 */
1999 + volatile unsigned int global_status; /* 0x18 */
2000 + volatile unsigned int reserved; /* 0x1c */
2001 + volatile unsigned int reset_control; /* 0x20 */
2002 +} INTERRUPT;
2003 +
2004 +#define interrupt (*((volatile INTERRUPT *) INTERRUPT_BASE))
2005 +
2006 +#define INTERRUPT_MISC_TIMER BIT(0)
2007 +#define INTERRUPT_MISC_AHBPROC BIT(1)
2008 +#define INTERRUPT_MISC_AHBDMA BIT(2)
2009 +#define INTERRUPT_MISC_GPIO BIT(3)
2010 +#define INTERRUPT_MISC_UART BIT(4)
2011 +#define INTERRUPT_MISC_UARTDMA BIT(5)
2012 +#define INTERRUPT_MISC_WATCHDOG BIT(6)
2013 +#define INTERRUPT_MISC_LOCAL BIT(7)
2014 +
2015 +#define INTERRUPT_GLOBAL_ETH BIT(2)
2016 +#define INTERRUPT_GLOBAL_WLAN BIT(3)
2017 +#define INTERRUPT_GLOBAL_MISC BIT(4)
2018 +#define INTERRUPT_GLOBAL_ITIMER BIT(5)
2019 +
2020 +/********************************************************************
2021 + * DMA controller
2022 + ********************************************************************/
2023 +#define DMA_BASE 0xB8201000
2024 +
2025 +typedef struct {
2026 + volatile unsigned int bus_mode; /* 0x00 (CSR0) */
2027 + volatile unsigned int xmt_poll; /* 0x04 (CSR1) */
2028 + volatile unsigned int rcv_poll; /* 0x08 (CSR2) */
2029 + volatile unsigned int rcv_base; /* 0x0c (CSR3) */
2030 + volatile unsigned int xmt_base; /* 0x10 (CSR4) */
2031 + volatile unsigned int status; /* 0x14 (CSR5) */
2032 + volatile unsigned int control; /* 0x18 (CSR6) */
2033 + volatile unsigned int intr_ena; /* 0x1c (CSR7) */
2034 + volatile unsigned int rcv_missed; /* 0x20 (CSR8) */
2035 + volatile unsigned int reserved[11]; /* 0x24-0x4c (CSR9-19) */
2036 + volatile unsigned int cur_tx_buf_addr; /* 0x50 (CSR20) */
2037 + volatile unsigned int cur_rx_buf_addr; /* 0x50 (CSR21) */
2038 +} DMA;
2039 +
2040 +#define dma (*((volatile DMA *) DMA_BASE))
2041 +
2042 +// macro to convert from virtual to physical address
2043 +#define phys_addr(x) (x & 0x1fffffff)
2044 +
2045 +#endif /* PLATFORM_H */
2046 diff -urN linux.old/drivers/net/Kconfig linux.eth/drivers/net/Kconfig
2047 --- linux.old/drivers/net/Kconfig 2006-12-14 23:53:29.000000000 +0100
2048 +++ linux.eth/drivers/net/Kconfig 2006-12-16 04:30:11.000000000 +0100
2049 @@ -313,6 +313,12 @@
2050
2051 source "drivers/net/arm/Kconfig"
2052
2053 +config AR2313
2054 + tristate "AR2313 Ethernet support"
2055 + depends on NET_ETHERNET && AR531X
2056 + help
2057 + Support for the AR231x/531x ethernet controller
2058 +
2059 config MACE
2060 tristate "MACE (Power Mac ethernet) support"
2061 depends on NET_ETHERNET && PPC_PMAC && PPC32
2062 diff -urN linux.old/drivers/net/Makefile linux.eth/drivers/net/Makefile
2063 --- linux.old/drivers/net/Makefile 2006-12-14 23:53:29.000000000 +0100
2064 +++ linux.eth/drivers/net/Makefile 2006-12-16 04:30:11.000000000 +0100
2065 @@ -9,6 +9,7 @@
2066 obj-$(CONFIG_EHEA) += ehea/
2067 obj-$(CONFIG_BONDING) += bonding/
2068 obj-$(CONFIG_GIANFAR) += gianfar_driver.o
2069 +obj-$(CONFIG_AR2313) += ar2313/
2070
2071 gianfar_driver-objs := gianfar.o \
2072 gianfar_ethtool.o \
OpenWrt Source Repository