1 /* mac8390.c: New driver for 8390-based Nubus (or Nubus-alike)
2 Ethernet cards on Linux */
3 /* Based on the former daynaport.c driver, by Alan Cox. Some code
4 taken from or inspired by skeleton.c by Donald Becker, acenic.c by
5 Jes Sorensen, and ne2k-pci.c by Donald Becker and Paul Gortmaker.
7 This software may be used and distributed according to the terms of
8 the GNU Public License, incorporated herein by reference. */
10 /* 2000-02-28: support added for Dayna and Kinetics cards by
11 A.G.deWijn@phys.uu.nl */
12 /* 2000-04-04: support added for Dayna2 by bart@etpmod.phys.tue.nl */
13 /* 2001-04-18: support for DaynaPort E/LC-M by rayk@knightsmanor.org */
14 /* 2001-05-15: support for Cabletron ported from old daynaport driver
15 * and fixed access to Sonic Sys card which masquerades as a Farallon
16 * by rayk@knightsmanor.org */
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/types.h>
21 #include <linux/fcntl.h>
22 #include <linux/interrupt.h>
23 #include <linux/ptrace.h>
24 #include <linux/ioport.h>
25 #include <linux/nubus.h>
27 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/netdevice.h>
32 #include <linux/etherdevice.h>
33 #include <linux/skbuff.h>
34 #include <linux/bitops.h>
36 #include <asm/system.h>
39 #include <asm/hwtest.h>
40 #include <asm/macints.h>
44 #define WD_START_PG 0x00 /* First page of TX buffer */
45 #define CABLETRON_RX_START_PG 0x00 /* First page of RX buffer */
46 #define CABLETRON_RX_STOP_PG 0x30 /* Last page +1 of RX ring */
47 #define CABLETRON_TX_START_PG CABLETRON_RX_STOP_PG /* First page of TX buffer */
49 /* Unfortunately it seems we have to hardcode these for the moment */
50 /* Shouldn't the card know about this? Does anyone know where to read it off the card? Do we trust the data provided by the card? */
52 #define DAYNA_8390_BASE 0x80000
53 #define DAYNA_8390_MEM 0x00000
55 #define KINETICS_8390_BASE 0x80000
56 #define KINETICS_8390_MEM 0x00000
58 #define CABLETRON_8390_BASE 0x90000
59 #define CABLETRON_8390_MEM 0x00000
65 MAC8390_FARALLON
, /* Apple, Asante, and Farallon are all compatible */
76 static const char * cardname
[] = {
90 static int word16
[] = {
99 1, /* sonic systems */
104 /* on which cards do we use NuBus resources? */
105 static int useresources
[] = {
114 1, /* sonic systems */
119 static char version
[] __initdata
=
120 "mac8390.c: v0.4 2001-05-15 David Huggins-Daines <dhd@debian.org> and others\n";
122 extern enum mac8390_type
mac8390_ident(struct nubus_dev
* dev
);
123 extern int mac8390_memsize(unsigned long membase
);
124 extern int mac8390_memtest(struct net_device
* dev
);
125 static int mac8390_initdev(struct net_device
* dev
, struct nubus_dev
* ndev
,
126 enum mac8390_type type
);
128 static int mac8390_open(struct net_device
* dev
);
129 static int mac8390_close(struct net_device
* dev
);
130 static void mac8390_no_reset(struct net_device
*dev
);
132 /* Sane (32-bit chunk memory read/write) - Apple/Asante/Farallon do this*/
133 static void sane_get_8390_hdr(struct net_device
*dev
,
134 struct e8390_pkt_hdr
*hdr
, int ring_page
);
135 static void sane_block_input(struct net_device
* dev
, int count
,
136 struct sk_buff
* skb
, int ring_offset
);
137 static void sane_block_output(struct net_device
* dev
, int count
,
138 const unsigned char * buf
, const int start_page
);
140 /* dayna_memcpy to and from card */
141 static void dayna_memcpy_fromcard(struct net_device
*dev
, void *to
,
142 int from
, int count
);
143 static void dayna_memcpy_tocard(struct net_device
*dev
, int to
,
144 const void *from
, int count
);
146 /* Dayna - Dayna/Kinetics use this */
147 static void dayna_get_8390_hdr(struct net_device
*dev
,
148 struct e8390_pkt_hdr
*hdr
, int ring_page
);
149 static void dayna_block_input(struct net_device
*dev
, int count
,
150 struct sk_buff
*skb
, int ring_offset
);
151 static void dayna_block_output(struct net_device
*dev
, int count
,
152 const unsigned char *buf
, int start_page
);
154 #define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c))
155 #define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c))
157 /* Slow Sane (16-bit chunk memory read/write) Cabletron uses this */
158 static void slow_sane_get_8390_hdr(struct net_device
*dev
,
159 struct e8390_pkt_hdr
*hdr
, int ring_page
);
160 static void slow_sane_block_input(struct net_device
*dev
, int count
,
161 struct sk_buff
*skb
, int ring_offset
);
162 static void slow_sane_block_output(struct net_device
*dev
, int count
,
163 const unsigned char *buf
, int start_page
);
164 static void word_memcpy_tocard(void *tp
, const void *fp
, int count
);
165 static void word_memcpy_fromcard(void *tp
, const void *fp
, int count
);
167 enum mac8390_type __init
mac8390_ident(struct nubus_dev
* dev
)
169 if (dev
->dr_sw
== NUBUS_DRSW_ASANTE
)
170 return MAC8390_ASANTE
;
171 if (dev
->dr_sw
== NUBUS_DRSW_FARALLON
)
172 return MAC8390_FARALLON
;
173 if (dev
->dr_sw
== NUBUS_DRSW_KINETICS
)
174 return MAC8390_KINETICS
;
175 if (dev
->dr_sw
== NUBUS_DRSW_DAYNA
)
176 return MAC8390_DAYNA
;
177 if (dev
->dr_sw
== NUBUS_DRSW_DAYNA2
)
178 return MAC8390_DAYNA2
;
179 if (dev
->dr_sw
== NUBUS_DRSW_DAYNA_LC
)
180 return MAC8390_DAYNA3
;
181 if (dev
->dr_hw
== NUBUS_DRHW_CABLETRON
)
182 return MAC8390_CABLETRON
;
186 int __init
mac8390_memsize(unsigned long membase
)
191 local_irq_save(flags
);
192 /* Check up to 32K in 4K increments */
193 for (i
= 0; i
< 8; i
++) {
194 volatile unsigned short *m
= (unsigned short *) (membase
+ (i
* 0x1000));
196 /* Unwriteable - we have a fully decoded card and the
198 if (hwreg_present(m
) == 0)
201 /* write a distinctive byte */
203 /* check that we read back what we wrote */
204 if (*m
!= (0xA5A0 | i
))
207 /* check for partial decode and wrap */
208 for (j
= 0; j
< i
; j
++) {
209 volatile unsigned short *p
= (unsigned short *) (membase
+ (j
* 0x1000));
210 if (*p
!= (0xA5A0 | j
))
214 local_irq_restore(flags
);
215 /* in any case, we stopped once we tried one block too many,
216 or once we reached 32K */
220 struct net_device
* __init
mac8390_probe(int unit
)
222 struct net_device
*dev
;
223 volatile unsigned short *i
;
224 int version_disp
= 0;
225 struct nubus_dev
* ndev
= NULL
;
228 struct nubus_dir dir
;
229 struct nubus_dirent ent
;
231 static unsigned int slots
;
233 enum mac8390_type cardtype
;
235 /* probably should check for Nubus instead */
238 return ERR_PTR(-ENODEV
);
240 dev
= alloc_ei_netdev();
242 return ERR_PTR(-ENOMEM
);
245 sprintf(dev
->name
, "eth%d", unit
);
247 SET_MODULE_OWNER(dev
);
249 while ((ndev
= nubus_find_type(NUBUS_CAT_NETWORK
, NUBUS_TYPE_ETHERNET
, ndev
))) {
250 /* Have we seen it already? */
251 if (slots
& (1<<ndev
->board
->slot
))
253 slots
|= 1<<ndev
->board
->slot
;
255 if ((cardtype
= mac8390_ident(ndev
)) == MAC8390_NONE
)
258 if (version_disp
== 0) {
263 dev
->irq
= SLOT2IRQ(ndev
->board
->slot
);
264 /* This is getting to be a habit */
265 dev
->base_addr
= ndev
->board
->slot_addr
| ((ndev
->board
->slot
&0xf) << 20);
267 /* Get some Nubus info - we will trust the card's idea
268 of where its memory and registers are. */
270 if (nubus_get_func_dir(ndev
, &dir
) == -1) {
271 printk(KERN_ERR
"%s: Unable to get Nubus functional"
272 " directory for slot %X!\n",
273 dev
->name
, ndev
->board
->slot
);
277 /* Get the MAC address */
278 if ((nubus_find_rsrc(&dir
, NUBUS_RESID_MAC_ADDRESS
, &ent
)) == -1) {
279 printk(KERN_INFO
"%s: Couldn't get MAC address!\n",
283 nubus_get_rsrc_mem(dev
->dev_addr
, &ent
, 6);
284 /* Some Sonic Sys cards masquerade as Farallon */
285 if (cardtype
== MAC8390_FARALLON
&&
286 dev
->dev_addr
[0] == 0x0 &&
287 dev
->dev_addr
[1] == 0x40 &&
288 dev
->dev_addr
[2] == 0x10) {
289 /* This is really Sonic Sys card */
290 cardtype
= MAC8390_SONICSYS
;
294 if (useresources
[cardtype
] == 1) {
295 nubus_rewinddir(&dir
);
296 if (nubus_find_rsrc(&dir
, NUBUS_RESID_MINOR_BASEOS
, &ent
) == -1) {
297 printk(KERN_ERR
"%s: Memory offset resource"
298 " for slot %X not found!\n",
299 dev
->name
, ndev
->board
->slot
);
302 nubus_get_rsrc_mem(&offset
, &ent
, 4);
303 dev
->mem_start
= dev
->base_addr
+ offset
;
304 /* yes, this is how the Apple driver does it */
305 dev
->base_addr
= dev
->mem_start
+ 0x10000;
306 nubus_rewinddir(&dir
);
307 if (nubus_find_rsrc(&dir
, NUBUS_RESID_MINOR_LENGTH
, &ent
) == -1) {
308 printk(KERN_INFO
"%s: Memory length resource"
309 " for slot %X not found"
311 dev
->name
, ndev
->board
->slot
);
312 offset
= mac8390_memsize(dev
->mem_start
);
314 nubus_get_rsrc_mem(&offset
, &ent
, 4);
316 dev
->mem_end
= dev
->mem_start
+ offset
;
319 case MAC8390_KINETICS
:
320 case MAC8390_DAYNA
: /* it's the same */
322 (int)(ndev
->board
->slot_addr
+
325 (int)(ndev
->board
->slot_addr
+
329 mac8390_memsize(dev
->mem_start
);
331 case MAC8390_CABLETRON
:
333 (int)(ndev
->board
->slot_addr
+
334 CABLETRON_8390_BASE
);
336 (int)(ndev
->board
->slot_addr
+
338 /* The base address is unreadable if 0x00
339 * has been written to the command register
340 * Reset the chip by writing E8390_NODMA +
341 * E8390_PAGE0 + E8390_STOP just to be
344 i
= (void *)dev
->base_addr
;
348 mac8390_memsize(dev
->mem_start
);
352 printk(KERN_ERR
"Card type %s is"
353 " unsupported, sorry\n",
359 /* Do the nasty 8390 stuff */
360 if (!mac8390_initdev(dev
, ndev
, cardtype
))
366 err
= register_netdev(dev
);
377 MODULE_AUTHOR("David Huggins-Daines <dhd@debian.org> and others");
378 MODULE_DESCRIPTION("Macintosh NS8390-based Nubus Ethernet driver");
379 MODULE_LICENSE("GPL");
381 /* overkill, of course */
382 static struct net_device
*dev_mac8390
[15];
383 int init_module(void)
386 for (i
= 0; i
< 15; i
++) {
387 struct net_device
*dev
= mac8390_probe(-1);
393 printk(KERN_NOTICE
"mac8390.c: No useable cards found, driver NOT installed.\n");
399 void cleanup_module(void)
402 for (i
= 0; i
< 15; i
++) {
403 struct net_device
*dev
= dev_mac890
[i
];
405 unregister_netdev(dev
);
413 static int __init
mac8390_initdev(struct net_device
* dev
, struct nubus_dev
* ndev
,
414 enum mac8390_type type
)
416 static u32 fwrd4_offsets
[16]={
422 static u32 back4_offsets
[16]={
428 static u32 fwrd2_offsets
[16]={
437 /* Now fill in our stuff */
438 dev
->open
= &mac8390_open
;
439 dev
->stop
= &mac8390_close
;
440 #ifdef CONFIG_NET_POLL_CONTROLLER
441 dev
->poll_controller
= ei_poll
;
444 /* GAR, ei_status is actually a macro even though it looks global */
445 ei_status
.name
= cardname
[type
];
446 ei_status
.word16
= word16
[type
];
448 /* Cabletron's TX/RX buffers are backwards */
449 if (type
== MAC8390_CABLETRON
) {
450 ei_status
.tx_start_page
= CABLETRON_TX_START_PG
;
451 ei_status
.rx_start_page
= CABLETRON_RX_START_PG
;
452 ei_status
.stop_page
= CABLETRON_RX_STOP_PG
;
453 ei_status
.rmem_start
= dev
->mem_start
;
454 ei_status
.rmem_end
= dev
->mem_start
+ CABLETRON_RX_STOP_PG
*256;
456 ei_status
.tx_start_page
= WD_START_PG
;
457 ei_status
.rx_start_page
= WD_START_PG
+ TX_PAGES
;
458 ei_status
.stop_page
= (dev
->mem_end
- dev
->mem_start
)/256;
459 ei_status
.rmem_start
= dev
->mem_start
+ TX_PAGES
*256;
460 ei_status
.rmem_end
= dev
->mem_end
;
463 /* Fill in model-specific information and functions */
465 case MAC8390_SONICSYS
:
466 /* 16 bit card, register map is reversed */
467 ei_status
.reset_8390
= &mac8390_no_reset
;
468 ei_status
.block_input
= &slow_sane_block_input
;
469 ei_status
.block_output
= &slow_sane_block_output
;
470 ei_status
.get_8390_hdr
= &slow_sane_get_8390_hdr
;
471 ei_status
.reg_offset
= back4_offsets
;
474 case MAC8390_FARALLON
:
479 /* 32 bit card, register map is reversed */
481 ei_status
.reset_8390
= &mac8390_no_reset
;
482 ei_status
.block_input
= &sane_block_input
;
483 ei_status
.block_output
= &sane_block_output
;
484 ei_status
.get_8390_hdr
= &sane_get_8390_hdr
;
485 ei_status
.reg_offset
= back4_offsets
;
488 case MAC8390_CABLETRON
:
489 /* 16 bit card, register map is short forward */
490 ei_status
.reset_8390
= &mac8390_no_reset
;
491 ei_status
.block_input
= &slow_sane_block_input
;
492 ei_status
.block_output
= &slow_sane_block_output
;
493 ei_status
.get_8390_hdr
= &slow_sane_get_8390_hdr
;
494 ei_status
.reg_offset
= fwrd2_offsets
;
498 case MAC8390_KINETICS
:
500 /* dayna and similar */
501 ei_status
.reset_8390
= &mac8390_no_reset
;
502 ei_status
.block_input
= &dayna_block_input
;
503 ei_status
.block_output
= &dayna_block_output
;
504 ei_status
.get_8390_hdr
= &dayna_get_8390_hdr
;
505 ei_status
.reg_offset
= fwrd4_offsets
;
509 printk(KERN_ERR
"Card type %s is unsupported, sorry\n", cardname
[type
]);
515 /* Good, done, now spit out some messages */
516 printk(KERN_INFO
"%s: %s in slot %X (type %s)\n",
517 dev
->name
, ndev
->board
->name
, ndev
->board
->slot
, cardname
[type
]);
518 printk(KERN_INFO
"MAC ");
521 for (i
= 0; i
< 6; i
++) {
522 printk("%2.2x", dev
->dev_addr
[i
]);
527 printk(" IRQ %d, shared memory at %#lx-%#lx, %d-bit access.\n",
528 dev
->irq
, dev
->mem_start
, dev
->mem_end
-1,
529 access_bitmode
?32:16);
533 static int mac8390_open(struct net_device
*dev
)
536 if (request_irq(dev
->irq
, ei_interrupt
, 0, "8390 Ethernet", dev
)) {
537 printk ("%s: unable to get IRQ %d.\n", dev
->name
, dev
->irq
);
543 static int mac8390_close(struct net_device
*dev
)
545 free_irq(dev
->irq
, dev
);
550 static void mac8390_no_reset(struct net_device
*dev
)
554 printk("reset not supported\n");
558 /* dayna_memcpy_fromio/dayna_memcpy_toio */
559 /* directly from daynaport.c by Alan Cox */
560 static void dayna_memcpy_fromcard(struct net_device
*dev
, void *to
, int from
, int count
)
562 volatile unsigned short *ptr
;
563 unsigned short *target
=to
;
564 from
<<=1; /* word, skip overhead */
565 ptr
=(unsigned short *)(dev
->mem_start
+from
);
568 *((char *)target
)++ = *(((char *)ptr
++)-1);
573 *target
++=*ptr
++; /* Copy and */
574 ptr
++; /* skip cruft */
581 unsigned short v
=*ptr
;
582 *((char *)target
)=v
>>8;
586 static void dayna_memcpy_tocard(struct net_device
*dev
, int to
, const void *from
, int count
)
588 volatile unsigned short *ptr
;
589 const unsigned short *src
=from
;
590 to
<<=1; /* word, skip overhead */
591 ptr
=(unsigned short *)(dev
->mem_start
+to
);
593 if (to
&2) { /* avoid a byte write (stomps on other data) */
594 ptr
[-1] = (ptr
[-1]&0xFF00)|*((unsigned char *)src
)++;
600 *ptr
++=*src
++; /* Copy and */
601 ptr
++; /* skip cruft */
608 unsigned short v
=*src
;
609 /* card doesn't like byte writes */
610 *ptr
=(*ptr
&0x00FF)|(v
&0xFF00);
614 /* sane block input/output */
615 static void sane_get_8390_hdr(struct net_device
*dev
,
616 struct e8390_pkt_hdr
*hdr
, int ring_page
)
618 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
619 memcpy_fromio((void *)hdr
, (char *)dev
->mem_start
+ hdr_start
, 4);
621 hdr
->count
= swab16(hdr
->count
);
624 static void sane_block_input(struct net_device
*dev
, int count
,
625 struct sk_buff
*skb
, int ring_offset
)
627 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
628 unsigned long xfer_start
= xfer_base
+ dev
->mem_start
;
630 if (xfer_start
+ count
> ei_status
.rmem_end
) {
631 /* We must wrap the input move. */
632 int semi_count
= ei_status
.rmem_end
- xfer_start
;
633 memcpy_fromio(skb
->data
, (char *)dev
->mem_start
+ xfer_base
, semi_count
);
635 memcpy_toio(skb
->data
+ semi_count
, (char *)ei_status
.rmem_start
, count
);
637 memcpy_fromio(skb
->data
, (char *)dev
->mem_start
+ xfer_base
, count
);
641 static void sane_block_output(struct net_device
*dev
, int count
,
642 const unsigned char *buf
, int start_page
)
644 long shmem
= (start_page
- WD_START_PG
)<<8;
646 memcpy_toio((char *)dev
->mem_start
+ shmem
, buf
, count
);
649 /* dayna block input/output */
650 static void dayna_get_8390_hdr(struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
, int ring_page
)
652 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
654 dayna_memcpy_fromcard(dev
, (void *)hdr
, hdr_start
, 4);
656 hdr
->count
=(hdr
->count
&0xFF)<<8|(hdr
->count
>>8);
659 static void dayna_block_input(struct net_device
*dev
, int count
, struct sk_buff
*skb
, int ring_offset
)
661 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
662 unsigned long xfer_start
= xfer_base
+dev
->mem_start
;
664 /* Note the offset math is done in card memory space which is word
665 per long onto our space. */
667 if (xfer_start
+ count
> ei_status
.rmem_end
)
669 /* We must wrap the input move. */
670 int semi_count
= ei_status
.rmem_end
- xfer_start
;
671 dayna_memcpy_fromcard(dev
, skb
->data
, xfer_base
, semi_count
);
673 dayna_memcpy_fromcard(dev
, skb
->data
+ semi_count
,
674 ei_status
.rmem_start
- dev
->mem_start
,
679 dayna_memcpy_fromcard(dev
, skb
->data
, xfer_base
, count
);
683 static void dayna_block_output(struct net_device
*dev
, int count
, const unsigned char *buf
,
686 long shmem
= (start_page
- WD_START_PG
)<<8;
688 dayna_memcpy_tocard(dev
, shmem
, buf
, count
);
691 /* Cabletron block I/O */
692 static void slow_sane_get_8390_hdr(struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
,
695 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
696 word_memcpy_fromcard((void *)hdr
, (char *)dev
->mem_start
+hdr_start
, 4);
697 /* Register endianism - fix here rather than 8390.c */
698 hdr
->count
= (hdr
->count
&0xFF)<<8|(hdr
->count
>>8);
701 static void slow_sane_block_input(struct net_device
*dev
, int count
, struct sk_buff
*skb
,
704 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
705 unsigned long xfer_start
= xfer_base
+dev
->mem_start
;
707 if (xfer_start
+ count
> ei_status
.rmem_end
)
709 /* We must wrap the input move. */
710 int semi_count
= ei_status
.rmem_end
- xfer_start
;
711 word_memcpy_fromcard(skb
->data
, (char *)dev
->mem_start
+
712 xfer_base
, semi_count
);
714 word_memcpy_fromcard(skb
->data
+ semi_count
,
715 (char *)ei_status
.rmem_start
, count
);
719 word_memcpy_fromcard(skb
->data
, (char *)dev
->mem_start
+
724 static void slow_sane_block_output(struct net_device
*dev
, int count
, const unsigned char *buf
,
727 long shmem
= (start_page
- WD_START_PG
)<<8;
729 word_memcpy_tocard((char *)dev
->mem_start
+ shmem
, buf
, count
);
732 static void word_memcpy_tocard(void *tp
, const void *fp
, int count
)
734 volatile unsigned short *to
= tp
;
735 const unsigned short *from
= fp
;
744 static void word_memcpy_fromcard(void *tp
, const void *fp
, int count
)
746 unsigned short *to
= tp
;
747 const volatile unsigned short *from
= fp
;