6 * Converted to DMA API, converted to unified driver model, made it work as
7 * a module again, and from the mac68k project, introduced more 32-bit cards
8 * and dhd's support for 16-bit cards.
12 * Debugging Andreas Ehliar, Michael Schmitz
15 * (C) 1996 by Thomas Bogendoerfer (tsbogend@bigbug.franken.de)
17 * This driver is based on work from Andreas Busse, but most of
18 * the code is rewritten.
20 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
22 * A driver for the Mac onboard Sonic ethernet chip.
24 * 98/12/21 MSch: judged from tests on Q800, it's basically working,
25 * but eating up both receive and transmit resources
26 * and duplicating packets. Needs more testing.
28 * 99/01/03 MSch: upgraded to version 0.92 of the core driver, fixed.
30 * 00/10/31 sammy@oh.verio.com: Updated driver for 2.4 kernels, fixed problems
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/types.h>
37 #include <linux/fcntl.h>
38 #include <linux/gfp.h>
39 #include <linux/interrupt.h>
40 #include <linux/init.h>
41 #include <linux/ioport.h>
43 #include <linux/string.h>
44 #include <linux/delay.h>
45 #include <linux/nubus.h>
46 #include <linux/errno.h>
47 #include <linux/netdevice.h>
48 #include <linux/etherdevice.h>
49 #include <linux/skbuff.h>
50 #include <linux/platform_device.h>
51 #include <linux/dma-mapping.h>
52 #include <linux/bitrev.h>
53 #include <linux/slab.h>
55 #include <asm/bootinfo.h>
56 #include <asm/system.h>
57 #include <asm/pgtable.h>
59 #include <asm/hwtest.h>
61 #include <asm/macintosh.h>
62 #include <asm/macints.h>
63 #include <asm/mac_via.h>
65 static char mac_sonic_string
[] = "macsonic";
69 /* These should basically be bus-size and endian independent (since
70 the SONIC is at least smart enough that it uses the same endianness
71 as the host, unlike certain less enlightened Macintosh NICs) */
72 #define SONIC_READ(reg) (nubus_readw(dev->base_addr + (reg * 4) \
74 #define SONIC_WRITE(reg,val) (nubus_writew(val, dev->base_addr + (reg * 4) \
77 /* use 0 for production, 1 for verification, >1 for debug */
79 static unsigned int sonic_debug
= SONIC_DEBUG
;
81 static unsigned int sonic_debug
= 1;
84 static int sonic_version_printed
;
86 /* For onboard SONIC */
87 #define ONBOARD_SONIC_REGISTERS 0x50F0A000
88 #define ONBOARD_SONIC_PROM_BASE 0x50f08000
98 /* For the built-in SONIC in the Duo Dock */
99 #define DUODOCK_SONIC_REGISTERS 0xe10000
100 #define DUODOCK_SONIC_PROM_BASE 0xe12000
102 /* For Apple-style NuBus SONIC */
103 #define APPLE_SONIC_REGISTERS 0
104 #define APPLE_SONIC_PROM_BASE 0x40000
106 /* Daynalink LC SONIC */
107 #define DAYNALINK_PROM_BASE 0x400000
109 /* For Dayna-style NuBus SONIC (haven't seen one yet) */
110 #define DAYNA_SONIC_REGISTERS 0x180000
111 /* This is what OpenBSD says. However, this is definitely in NuBus
112 ROM space so we should be able to get it by walking the NuBus
113 resource directories */
114 #define DAYNA_SONIC_MAC_ADDR 0xffe004
116 #define SONIC_READ_PROM(addr) nubus_readb(prom_addr+addr)
119 * For reversing the PROM address
122 static inline void bit_reverse_addr(unsigned char addr
[6])
126 for(i
= 0; i
< 6; i
++)
127 addr
[i
] = bitrev8(addr
[i
]);
130 static irqreturn_t
macsonic_interrupt(int irq
, void *dev_id
)
135 local_irq_save(flags
);
136 result
= sonic_interrupt(irq
, dev_id
);
137 local_irq_restore(flags
);
141 static int macsonic_open(struct net_device
* dev
)
145 retval
= request_irq(dev
->irq
, sonic_interrupt
, IRQ_FLG_FAST
,
148 printk(KERN_ERR
"%s: unable to get IRQ %d.\n",
149 dev
->name
, dev
->irq
);
152 /* Under the A/UX interrupt scheme, the onboard SONIC interrupt comes
153 * in at priority level 3. However, we sometimes get the level 2 inter-
154 * rupt as well, which must prevent re-entrance of the sonic handler.
156 if (dev
->irq
== IRQ_AUTO_3
) {
157 retval
= request_irq(IRQ_NUBUS_9
, macsonic_interrupt
,
158 IRQ_FLG_FAST
, "sonic", dev
);
160 printk(KERN_ERR
"%s: unable to get IRQ %d.\n",
161 dev
->name
, IRQ_NUBUS_9
);
165 retval
= sonic_open(dev
);
171 if (dev
->irq
== IRQ_AUTO_3
)
172 free_irq(IRQ_NUBUS_9
, dev
);
174 free_irq(dev
->irq
, dev
);
179 static int macsonic_close(struct net_device
* dev
)
182 err
= sonic_close(dev
);
183 free_irq(dev
->irq
, dev
);
184 if (dev
->irq
== IRQ_AUTO_3
)
185 free_irq(IRQ_NUBUS_9
, dev
);
189 static const struct net_device_ops macsonic_netdev_ops
= {
190 .ndo_open
= macsonic_open
,
191 .ndo_stop
= macsonic_close
,
192 .ndo_start_xmit
= sonic_send_packet
,
193 .ndo_set_rx_mode
= sonic_multicast_list
,
194 .ndo_tx_timeout
= sonic_tx_timeout
,
195 .ndo_get_stats
= sonic_get_stats
,
196 .ndo_validate_addr
= eth_validate_addr
,
197 .ndo_change_mtu
= eth_change_mtu
,
198 .ndo_set_mac_address
= eth_mac_addr
,
201 static int __devinit
macsonic_init(struct net_device
*dev
)
203 struct sonic_local
* lp
= netdev_priv(dev
);
205 /* Allocate the entire chunk of memory for the descriptors.
206 Note that this cannot cross a 64K boundary. */
207 if ((lp
->descriptors
= dma_alloc_coherent(lp
->device
,
208 SIZEOF_SONIC_DESC
* SONIC_BUS_SCALE(lp
->dma_bitmode
),
209 &lp
->descriptors_laddr
, GFP_KERNEL
)) == NULL
) {
210 printk(KERN_ERR
"%s: couldn't alloc DMA memory for descriptors.\n",
211 dev_name(lp
->device
));
215 /* Now set up the pointers to point to the appropriate places */
216 lp
->cda
= lp
->descriptors
;
217 lp
->tda
= lp
->cda
+ (SIZEOF_SONIC_CDA
218 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
219 lp
->rda
= lp
->tda
+ (SIZEOF_SONIC_TD
* SONIC_NUM_TDS
220 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
221 lp
->rra
= lp
->rda
+ (SIZEOF_SONIC_RD
* SONIC_NUM_RDS
222 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
224 lp
->cda_laddr
= lp
->descriptors_laddr
;
225 lp
->tda_laddr
= lp
->cda_laddr
+ (SIZEOF_SONIC_CDA
226 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
227 lp
->rda_laddr
= lp
->tda_laddr
+ (SIZEOF_SONIC_TD
* SONIC_NUM_TDS
228 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
229 lp
->rra_laddr
= lp
->rda_laddr
+ (SIZEOF_SONIC_RD
* SONIC_NUM_RDS
230 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
232 dev
->netdev_ops
= &macsonic_netdev_ops
;
233 dev
->watchdog_timeo
= TX_TIMEOUT
;
236 * clear tally counter
238 SONIC_WRITE(SONIC_CRCT
, 0xffff);
239 SONIC_WRITE(SONIC_FAET
, 0xffff);
240 SONIC_WRITE(SONIC_MPT
, 0xffff);
245 #define INVALID_MAC(mac) (memcmp(mac, "\x08\x00\x07", 3) && \
246 memcmp(mac, "\x00\xA0\x40", 3) && \
247 memcmp(mac, "\x00\x80\x19", 3) && \
248 memcmp(mac, "\x00\x05\x02", 3))
250 static void __devinit
mac_onboard_sonic_ethernet_addr(struct net_device
*dev
)
252 struct sonic_local
*lp
= netdev_priv(dev
);
253 const int prom_addr
= ONBOARD_SONIC_PROM_BASE
;
257 * On NuBus boards we can sometimes look in the ROM resources.
258 * No such luck for comm-slot/onboard.
259 * On the PowerBook 520, the PROM base address is a mystery.
261 if (hwreg_present((void *)prom_addr
)) {
264 for (i
= 0; i
< 6; i
++)
265 dev
->dev_addr
[i
] = SONIC_READ_PROM(i
);
266 if (!INVALID_MAC(dev
->dev_addr
))
270 * Most of the time, the address is bit-reversed. The NetBSD
271 * source has a rather long and detailed historical account of
274 bit_reverse_addr(dev
->dev_addr
);
275 if (!INVALID_MAC(dev
->dev_addr
))
279 * If we still have what seems to be a bogus address, we'll
280 * look in the CAM. The top entry should be ours.
282 printk(KERN_WARNING
"macsonic: MAC address in PROM seems "
283 "to be invalid, trying CAM\n");
285 printk(KERN_WARNING
"macsonic: cannot read MAC address from "
286 "PROM, trying CAM\n");
289 /* This only works if MacOS has already initialized the card. */
291 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
292 SONIC_WRITE(SONIC_CEP
, 15);
294 val
= SONIC_READ(SONIC_CAP2
);
295 dev
->dev_addr
[5] = val
>> 8;
296 dev
->dev_addr
[4] = val
& 0xff;
297 val
= SONIC_READ(SONIC_CAP1
);
298 dev
->dev_addr
[3] = val
>> 8;
299 dev
->dev_addr
[2] = val
& 0xff;
300 val
= SONIC_READ(SONIC_CAP0
);
301 dev
->dev_addr
[1] = val
>> 8;
302 dev
->dev_addr
[0] = val
& 0xff;
304 if (!INVALID_MAC(dev
->dev_addr
))
307 /* Still nonsense ... messed up someplace! */
309 printk(KERN_WARNING
"macsonic: MAC address in CAM entry 15 "
310 "seems invalid, will use a random MAC\n");
311 random_ether_addr(dev
->dev_addr
);
314 static int __devinit
mac_onboard_sonic_probe(struct net_device
*dev
)
317 static int once_is_more_than_enough
;
318 struct sonic_local
* lp
= netdev_priv(dev
);
322 if (once_is_more_than_enough
)
324 once_is_more_than_enough
= 1;
329 if (macintosh_config
->ether_type
!= MAC_ETHER_SONIC
)
332 printk(KERN_INFO
"Checking for internal Macintosh ethernet (SONIC).. ");
334 /* Bogus probing, on the models which may or may not have
335 Ethernet (BTW, the Ethernet *is* always at the same
336 address, and nothing else lives there, at least if Apple's
337 documentation is to be believed) */
338 if (macintosh_config
->ident
== MAC_MODEL_Q630
||
339 macintosh_config
->ident
== MAC_MODEL_P588
||
340 macintosh_config
->ident
== MAC_MODEL_P575
||
341 macintosh_config
->ident
== MAC_MODEL_C610
) {
345 local_irq_save(flags
);
346 card_present
= hwreg_present((void*)ONBOARD_SONIC_REGISTERS
);
347 local_irq_restore(flags
);
358 /* Danger! My arms are flailing wildly! You *must* set lp->reg_offset
359 * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
360 dev
->base_addr
= ONBOARD_SONIC_REGISTERS
;
362 dev
->irq
= IRQ_AUTO_3
;
364 dev
->irq
= IRQ_NUBUS_9
;
366 if (!sonic_version_printed
) {
367 printk(KERN_INFO
"%s", version
);
368 sonic_version_printed
= 1;
370 printk(KERN_INFO
"%s: onboard / comm-slot SONIC at 0x%08lx\n",
371 dev_name(lp
->device
), dev
->base_addr
);
373 /* The PowerBook's SONIC is 16 bit always. */
374 if (macintosh_config
->ident
== MAC_MODEL_PB520
) {
376 lp
->dma_bitmode
= SONIC_BITMODE16
;
377 sr
= SONIC_READ(SONIC_SR
);
378 } else if (commslot
) {
379 /* Some of the comm-slot cards are 16 bit. But some
380 of them are not. The 32-bit cards use offset 2 and
381 have known revisions, we try reading the revision
382 register at offset 2, if we don't get a known revision
383 we assume 16 bit at offset 0. */
385 lp
->dma_bitmode
= SONIC_BITMODE16
;
387 sr
= SONIC_READ(SONIC_SR
);
388 if (sr
== 0x0004 || sr
== 0x0006 || sr
== 0x0100 || sr
== 0x0101)
389 /* 83932 is 0x0004 or 0x0006, 83934 is 0x0100 or 0x0101 */
390 lp
->dma_bitmode
= SONIC_BITMODE32
;
392 lp
->dma_bitmode
= SONIC_BITMODE16
;
394 sr
= SONIC_READ(SONIC_SR
);
397 /* All onboard cards are at offset 2 with 32 bit DMA. */
399 lp
->dma_bitmode
= SONIC_BITMODE32
;
400 sr
= SONIC_READ(SONIC_SR
);
403 "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
404 dev_name(lp
->device
), sr
, lp
->dma_bitmode
?32:16, lp
->reg_offset
);
406 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
407 printk(KERN_INFO
"%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp
->device
),
408 SONIC_READ(SONIC_DCR
) & 0xffff, SONIC_READ(SONIC_DCR2
) & 0xffff);
411 /* Software reset, then initialize control registers. */
412 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
414 SONIC_WRITE(SONIC_DCR
, SONIC_DCR_EXBUS
| SONIC_DCR_BMS
|
415 SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
416 (lp
->dma_bitmode
? SONIC_DCR_DW
: 0));
418 /* This *must* be written back to in order to restore the
419 * extended programmable output bits, as it may not have been
420 * initialised since the hardware reset. */
421 SONIC_WRITE(SONIC_DCR2
, 0);
423 /* Clear *and* disable interrupts to be on the safe side */
424 SONIC_WRITE(SONIC_IMR
, 0);
425 SONIC_WRITE(SONIC_ISR
, 0x7fff);
427 /* Now look for the MAC address. */
428 mac_onboard_sonic_ethernet_addr(dev
);
430 /* Shared init code */
431 return macsonic_init(dev
);
434 static int __devinit
mac_nubus_sonic_ethernet_addr(struct net_device
*dev
,
435 unsigned long prom_addr
,
439 for(i
= 0; i
< 6; i
++)
440 dev
->dev_addr
[i
] = SONIC_READ_PROM(i
);
442 /* Some of the addresses are bit-reversed */
443 if (id
!= MACSONIC_DAYNA
)
444 bit_reverse_addr(dev
->dev_addr
);
449 static int __devinit
macsonic_ident(struct nubus_dev
*ndev
)
451 if (ndev
->dr_hw
== NUBUS_DRHW_ASANTE_LC
&&
452 ndev
->dr_sw
== NUBUS_DRSW_SONIC_LC
)
453 return MACSONIC_DAYNALINK
;
454 if (ndev
->dr_hw
== NUBUS_DRHW_SONIC
&&
455 ndev
->dr_sw
== NUBUS_DRSW_APPLE
) {
456 /* There has to be a better way to do this... */
457 if (strstr(ndev
->board
->name
, "DuoDock"))
458 return MACSONIC_DUODOCK
;
460 return MACSONIC_APPLE
;
463 if (ndev
->dr_hw
== NUBUS_DRHW_SMC9194
&&
464 ndev
->dr_sw
== NUBUS_DRSW_DAYNA
)
465 return MACSONIC_DAYNA
;
467 if (ndev
->dr_hw
== NUBUS_DRHW_APPLE_SONIC_LC
&&
468 ndev
->dr_sw
== 0) { /* huh? */
469 return MACSONIC_APPLE16
;
474 static int __devinit
mac_nubus_sonic_probe(struct net_device
*dev
)
477 struct nubus_dev
* ndev
= NULL
;
478 struct sonic_local
* lp
= netdev_priv(dev
);
479 unsigned long base_addr
, prom_addr
;
482 int reg_offset
, dma_bitmode
;
484 /* Find the first SONIC that hasn't been initialized already */
485 while ((ndev
= nubus_find_type(NUBUS_CAT_NETWORK
,
486 NUBUS_TYPE_ETHERNET
, ndev
)) != NULL
)
488 /* Have we seen it already? */
489 if (slots
& (1<<ndev
->board
->slot
))
491 slots
|= 1<<ndev
->board
->slot
;
493 /* Is it one of ours? */
494 if ((id
= macsonic_ident(ndev
)) != -1)
502 case MACSONIC_DUODOCK
:
503 base_addr
= ndev
->board
->slot_addr
+ DUODOCK_SONIC_REGISTERS
;
504 prom_addr
= ndev
->board
->slot_addr
+ DUODOCK_SONIC_PROM_BASE
;
505 sonic_dcr
= SONIC_DCR_EXBUS
| SONIC_DCR_RFT0
| SONIC_DCR_RFT1
|
508 dma_bitmode
= SONIC_BITMODE32
;
511 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
512 prom_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_PROM_BASE
;
513 sonic_dcr
= SONIC_DCR_BMS
| SONIC_DCR_RFT1
| SONIC_DCR_TFT0
;
515 dma_bitmode
= SONIC_BITMODE32
;
517 case MACSONIC_APPLE16
:
518 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
519 prom_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_PROM_BASE
;
520 sonic_dcr
= SONIC_DCR_EXBUS
| SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
521 SONIC_DCR_PO1
| SONIC_DCR_BMS
;
523 dma_bitmode
= SONIC_BITMODE16
;
525 case MACSONIC_DAYNALINK
:
526 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
527 prom_addr
= ndev
->board
->slot_addr
+ DAYNALINK_PROM_BASE
;
528 sonic_dcr
= SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
529 SONIC_DCR_PO1
| SONIC_DCR_BMS
;
531 dma_bitmode
= SONIC_BITMODE16
;
534 base_addr
= ndev
->board
->slot_addr
+ DAYNA_SONIC_REGISTERS
;
535 prom_addr
= ndev
->board
->slot_addr
+ DAYNA_SONIC_MAC_ADDR
;
536 sonic_dcr
= SONIC_DCR_BMS
|
537 SONIC_DCR_RFT1
| SONIC_DCR_TFT0
| SONIC_DCR_PO1
;
539 dma_bitmode
= SONIC_BITMODE16
;
542 printk(KERN_ERR
"macsonic: WTF, id is %d\n", id
);
546 /* Danger! My arms are flailing wildly! You *must* set lp->reg_offset
547 * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
548 dev
->base_addr
= base_addr
;
549 lp
->reg_offset
= reg_offset
;
550 lp
->dma_bitmode
= dma_bitmode
;
551 dev
->irq
= SLOT2IRQ(ndev
->board
->slot
);
553 if (!sonic_version_printed
) {
554 printk(KERN_INFO
"%s", version
);
555 sonic_version_printed
= 1;
557 printk(KERN_INFO
"%s: %s in slot %X\n",
558 dev_name(lp
->device
), ndev
->board
->name
, ndev
->board
->slot
);
559 printk(KERN_INFO
"%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
560 dev_name(lp
->device
), SONIC_READ(SONIC_SR
), dma_bitmode
?32:16, reg_offset
);
562 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
563 printk(KERN_INFO
"%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp
->device
),
564 SONIC_READ(SONIC_DCR
) & 0xffff, SONIC_READ(SONIC_DCR2
) & 0xffff);
567 /* Software reset, then initialize control registers. */
568 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
569 SONIC_WRITE(SONIC_DCR
, sonic_dcr
| (dma_bitmode
? SONIC_DCR_DW
: 0));
570 /* This *must* be written back to in order to restore the
571 * extended programmable output bits, since it may not have been
572 * initialised since the hardware reset. */
573 SONIC_WRITE(SONIC_DCR2
, 0);
575 /* Clear *and* disable interrupts to be on the safe side */
576 SONIC_WRITE(SONIC_IMR
, 0);
577 SONIC_WRITE(SONIC_ISR
, 0x7fff);
579 /* Now look for the MAC address. */
580 if (mac_nubus_sonic_ethernet_addr(dev
, prom_addr
, id
) != 0)
583 /* Shared init code */
584 return macsonic_init(dev
);
587 static int __devinit
mac_sonic_probe(struct platform_device
*pdev
)
589 struct net_device
*dev
;
590 struct sonic_local
*lp
;
593 dev
= alloc_etherdev(sizeof(struct sonic_local
));
597 lp
= netdev_priv(dev
);
598 lp
->device
= &pdev
->dev
;
599 SET_NETDEV_DEV(dev
, &pdev
->dev
);
600 platform_set_drvdata(pdev
, dev
);
602 /* This will catch fatal stuff like -ENOMEM as well as success */
603 err
= mac_onboard_sonic_probe(dev
);
608 err
= mac_nubus_sonic_probe(dev
);
612 err
= register_netdev(dev
);
616 printk("%s: MAC %pM IRQ %d\n", dev
->name
, dev
->dev_addr
, dev
->irq
);
626 MODULE_DESCRIPTION("Macintosh SONIC ethernet driver");
627 module_param(sonic_debug
, int, 0);
628 MODULE_PARM_DESC(sonic_debug
, "macsonic debug level (1-4)");
629 MODULE_ALIAS("platform:macsonic");
633 static int __devexit
mac_sonic_device_remove (struct platform_device
*pdev
)
635 struct net_device
*dev
= platform_get_drvdata(pdev
);
636 struct sonic_local
* lp
= netdev_priv(dev
);
638 unregister_netdev(dev
);
639 dma_free_coherent(lp
->device
, SIZEOF_SONIC_DESC
* SONIC_BUS_SCALE(lp
->dma_bitmode
),
640 lp
->descriptors
, lp
->descriptors_laddr
);
646 static struct platform_driver mac_sonic_driver
= {
647 .probe
= mac_sonic_probe
,
648 .remove
= __devexit_p(mac_sonic_device_remove
),
650 .name
= mac_sonic_string
,
651 .owner
= THIS_MODULE
,
655 static int __init
mac_sonic_init_module(void)
657 return platform_driver_register(&mac_sonic_driver
);
660 static void __exit
mac_sonic_cleanup_module(void)
662 platform_driver_unregister(&mac_sonic_driver
);
665 module_init(mac_sonic_init_module
);
666 module_exit(mac_sonic_cleanup_module
);