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/interrupt.h>
39 #include <linux/init.h>
40 #include <linux/ioport.h>
42 #include <linux/slab.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>
53 #include <asm/bootinfo.h>
54 #include <asm/system.h>
55 #include <asm/pgtable.h>
57 #include <asm/hwtest.h>
59 #include <asm/macintosh.h>
60 #include <asm/macints.h>
61 #include <asm/mac_via.h>
63 static char mac_sonic_string
[] = "macsonic";
64 static struct platform_device
*mac_sonic_device
;
68 /* These should basically be bus-size and endian independent (since
69 the SONIC is at least smart enough that it uses the same endianness
70 as the host, unlike certain less enlightened Macintosh NICs) */
71 #define SONIC_READ(reg) (nubus_readw(dev->base_addr + (reg * 4) \
73 #define SONIC_WRITE(reg,val) (nubus_writew(val, dev->base_addr + (reg * 4) \
76 /* use 0 for production, 1 for verification, >1 for debug */
78 static unsigned int sonic_debug
= SONIC_DEBUG
;
80 static unsigned int sonic_debug
= 1;
83 static int sonic_version_printed
;
85 extern int mac_onboard_sonic_probe(struct net_device
* dev
);
86 extern int mac_nubus_sonic_probe(struct net_device
* dev
);
88 /* For onboard SONIC */
89 #define ONBOARD_SONIC_REGISTERS 0x50F0A000
90 #define ONBOARD_SONIC_PROM_BASE 0x50f08000
100 /* For the built-in SONIC in the Duo Dock */
101 #define DUODOCK_SONIC_REGISTERS 0xe10000
102 #define DUODOCK_SONIC_PROM_BASE 0xe12000
104 /* For Apple-style NuBus SONIC */
105 #define APPLE_SONIC_REGISTERS 0
106 #define APPLE_SONIC_PROM_BASE 0x40000
108 /* Daynalink LC SONIC */
109 #define DAYNALINK_PROM_BASE 0x400000
111 /* For Dayna-style NuBus SONIC (haven't seen one yet) */
112 #define DAYNA_SONIC_REGISTERS 0x180000
113 /* This is what OpenBSD says. However, this is definitely in NuBus
114 ROM space so we should be able to get it by walking the NuBus
115 resource directories */
116 #define DAYNA_SONIC_MAC_ADDR 0xffe004
118 #define SONIC_READ_PROM(addr) nubus_readb(prom_addr+addr)
121 * For reversing the PROM address
124 static inline void bit_reverse_addr(unsigned char addr
[6])
128 for(i
= 0; i
< 6; i
++)
129 addr
[i
] = bitrev8(addr
[i
]);
132 int __init
macsonic_init(struct net_device
* dev
)
134 struct sonic_local
* lp
= netdev_priv(dev
);
136 /* Allocate the entire chunk of memory for the descriptors.
137 Note that this cannot cross a 64K boundary. */
138 if ((lp
->descriptors
= dma_alloc_coherent(lp
->device
,
139 SIZEOF_SONIC_DESC
* SONIC_BUS_SCALE(lp
->dma_bitmode
),
140 &lp
->descriptors_laddr
, GFP_KERNEL
)) == NULL
) {
141 printk(KERN_ERR
"%s: couldn't alloc DMA memory for descriptors.\n", lp
->device
->bus_id
);
145 /* Now set up the pointers to point to the appropriate places */
146 lp
->cda
= lp
->descriptors
;
147 lp
->tda
= lp
->cda
+ (SIZEOF_SONIC_CDA
148 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
149 lp
->rda
= lp
->tda
+ (SIZEOF_SONIC_TD
* SONIC_NUM_TDS
150 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
151 lp
->rra
= lp
->rda
+ (SIZEOF_SONIC_RD
* SONIC_NUM_RDS
152 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
154 lp
->cda_laddr
= lp
->descriptors_laddr
;
155 lp
->tda_laddr
= lp
->cda_laddr
+ (SIZEOF_SONIC_CDA
156 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
157 lp
->rda_laddr
= lp
->tda_laddr
+ (SIZEOF_SONIC_TD
* SONIC_NUM_TDS
158 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
159 lp
->rra_laddr
= lp
->rda_laddr
+ (SIZEOF_SONIC_RD
* SONIC_NUM_RDS
160 * SONIC_BUS_SCALE(lp
->dma_bitmode
));
162 dev
->open
= sonic_open
;
163 dev
->stop
= sonic_close
;
164 dev
->hard_start_xmit
= sonic_send_packet
;
165 dev
->get_stats
= sonic_get_stats
;
166 dev
->set_multicast_list
= &sonic_multicast_list
;
167 dev
->tx_timeout
= sonic_tx_timeout
;
168 dev
->watchdog_timeo
= TX_TIMEOUT
;
171 * clear tally counter
173 SONIC_WRITE(SONIC_CRCT
, 0xffff);
174 SONIC_WRITE(SONIC_FAET
, 0xffff);
175 SONIC_WRITE(SONIC_MPT
, 0xffff);
180 int __init
mac_onboard_sonic_ethernet_addr(struct net_device
* dev
)
182 struct sonic_local
*lp
= netdev_priv(dev
);
183 const int prom_addr
= ONBOARD_SONIC_PROM_BASE
;
186 /* On NuBus boards we can sometimes look in the ROM resources.
187 No such luck for comm-slot/onboard. */
188 for(i
= 0; i
< 6; i
++)
189 dev
->dev_addr
[i
] = SONIC_READ_PROM(i
);
191 /* Most of the time, the address is bit-reversed. The NetBSD
192 source has a rather long and detailed historical account of
194 if (memcmp(dev
->dev_addr
, "\x08\x00\x07", 3) &&
195 memcmp(dev
->dev_addr
, "\x00\xA0\x40", 3) &&
196 memcmp(dev
->dev_addr
, "\x00\x80\x19", 3) &&
197 memcmp(dev
->dev_addr
, "\x00\x05\x02", 3))
198 bit_reverse_addr(dev
->dev_addr
);
202 /* If we still have what seems to be a bogus address, we'll
203 look in the CAM. The top entry should be ours. */
204 /* Danger! This only works if MacOS has already initialized
206 if (memcmp(dev
->dev_addr
, "\x08\x00\x07", 3) &&
207 memcmp(dev
->dev_addr
, "\x00\xA0\x40", 3) &&
208 memcmp(dev
->dev_addr
, "\x00\x80\x19", 3) &&
209 memcmp(dev
->dev_addr
, "\x00\x05\x02", 3))
213 printk(KERN_INFO
"macsonic: PROM seems to be wrong, trying CAM entry 15\n");
215 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
216 SONIC_WRITE(SONIC_CEP
, 15);
218 val
= SONIC_READ(SONIC_CAP2
);
219 dev
->dev_addr
[5] = val
>> 8;
220 dev
->dev_addr
[4] = val
& 0xff;
221 val
= SONIC_READ(SONIC_CAP1
);
222 dev
->dev_addr
[3] = val
>> 8;
223 dev
->dev_addr
[2] = val
& 0xff;
224 val
= SONIC_READ(SONIC_CAP0
);
225 dev
->dev_addr
[1] = val
>> 8;
226 dev
->dev_addr
[0] = val
& 0xff;
228 printk(KERN_INFO
"HW Address from CAM 15: ");
229 for (i
= 0; i
< 6; i
++) {
230 printk("%2.2x", dev
->dev_addr
[i
]);
237 if (memcmp(dev
->dev_addr
, "\x08\x00\x07", 3) &&
238 memcmp(dev
->dev_addr
, "\x00\xA0\x40", 3) &&
239 memcmp(dev
->dev_addr
, "\x00\x80\x19", 3) &&
240 memcmp(dev
->dev_addr
, "\x00\x05\x02", 3))
243 * Still nonsense ... messed up someplace!
245 printk(KERN_ERR
"macsonic: ERROR (INVALID MAC)\n");
250 int __init
mac_onboard_sonic_probe(struct net_device
* dev
)
253 static int once_is_more_than_enough
;
254 struct sonic_local
* lp
= netdev_priv(dev
);
258 if (once_is_more_than_enough
)
260 once_is_more_than_enough
= 1;
265 if (macintosh_config
->ether_type
!= MAC_ETHER_SONIC
)
268 printk(KERN_INFO
"Checking for internal Macintosh ethernet (SONIC).. ");
270 /* Bogus probing, on the models which may or may not have
271 Ethernet (BTW, the Ethernet *is* always at the same
272 address, and nothing else lives there, at least if Apple's
273 documentation is to be believed) */
274 if (macintosh_config
->ident
== MAC_MODEL_Q630
||
275 macintosh_config
->ident
== MAC_MODEL_P588
||
276 macintosh_config
->ident
== MAC_MODEL_P575
||
277 macintosh_config
->ident
== MAC_MODEL_C610
) {
281 local_irq_save(flags
);
282 card_present
= hwreg_present((void*)ONBOARD_SONIC_REGISTERS
);
283 local_irq_restore(flags
);
294 /* Danger! My arms are flailing wildly! You *must* set lp->reg_offset
295 * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
296 dev
->base_addr
= ONBOARD_SONIC_REGISTERS
;
298 dev
->irq
= IRQ_AUTO_3
;
300 dev
->irq
= IRQ_NUBUS_9
;
302 if (!sonic_version_printed
) {
303 printk(KERN_INFO
"%s", version
);
304 sonic_version_printed
= 1;
306 printk(KERN_INFO
"%s: onboard / comm-slot SONIC at 0x%08lx\n",
307 lp
->device
->bus_id
, dev
->base_addr
);
309 /* The PowerBook's SONIC is 16 bit always. */
310 if (macintosh_config
->ident
== MAC_MODEL_PB520
) {
312 lp
->dma_bitmode
= SONIC_BITMODE16
;
313 sr
= SONIC_READ(SONIC_SR
);
314 } else if (commslot
) {
315 /* Some of the comm-slot cards are 16 bit. But some
316 of them are not. The 32-bit cards use offset 2 and
317 have known revisions, we try reading the revision
318 register at offset 2, if we don't get a known revision
319 we assume 16 bit at offset 0. */
321 lp
->dma_bitmode
= SONIC_BITMODE16
;
323 sr
= SONIC_READ(SONIC_SR
);
324 if (sr
== 0x0004 || sr
== 0x0006 || sr
== 0x0100 || sr
== 0x0101)
325 /* 83932 is 0x0004 or 0x0006, 83934 is 0x0100 or 0x0101 */
326 lp
->dma_bitmode
= SONIC_BITMODE32
;
328 lp
->dma_bitmode
= SONIC_BITMODE16
;
330 sr
= SONIC_READ(SONIC_SR
);
333 /* All onboard cards are at offset 2 with 32 bit DMA. */
335 lp
->dma_bitmode
= SONIC_BITMODE32
;
336 sr
= SONIC_READ(SONIC_SR
);
339 "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
340 lp
->device
->bus_id
, sr
, lp
->dma_bitmode
?32:16, lp
->reg_offset
);
342 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
343 printk(KERN_INFO
"%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp
->device
->bus_id
,
344 SONIC_READ(SONIC_DCR
) & 0xffff, SONIC_READ(SONIC_DCR2
) & 0xffff);
347 /* Software reset, then initialize control registers. */
348 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
350 SONIC_WRITE(SONIC_DCR
, SONIC_DCR_EXBUS
| SONIC_DCR_BMS
|
351 SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
352 (lp
->dma_bitmode
? SONIC_DCR_DW
: 0));
354 /* This *must* be written back to in order to restore the
355 * extended programmable output bits, as it may not have been
356 * initialised since the hardware reset. */
357 SONIC_WRITE(SONIC_DCR2
, 0);
359 /* Clear *and* disable interrupts to be on the safe side */
360 SONIC_WRITE(SONIC_IMR
, 0);
361 SONIC_WRITE(SONIC_ISR
, 0x7fff);
363 /* Now look for the MAC address. */
364 if (mac_onboard_sonic_ethernet_addr(dev
) != 0)
367 /* Shared init code */
368 return macsonic_init(dev
);
371 int __init
mac_nubus_sonic_ethernet_addr(struct net_device
* dev
,
372 unsigned long prom_addr
,
376 for(i
= 0; i
< 6; i
++)
377 dev
->dev_addr
[i
] = SONIC_READ_PROM(i
);
379 /* Some of the addresses are bit-reversed */
380 if (id
!= MACSONIC_DAYNA
)
381 bit_reverse_addr(dev
->dev_addr
);
386 int __init
macsonic_ident(struct nubus_dev
* ndev
)
388 if (ndev
->dr_hw
== NUBUS_DRHW_ASANTE_LC
&&
389 ndev
->dr_sw
== NUBUS_DRSW_SONIC_LC
)
390 return MACSONIC_DAYNALINK
;
391 if (ndev
->dr_hw
== NUBUS_DRHW_SONIC
&&
392 ndev
->dr_sw
== NUBUS_DRSW_APPLE
) {
393 /* There has to be a better way to do this... */
394 if (strstr(ndev
->board
->name
, "DuoDock"))
395 return MACSONIC_DUODOCK
;
397 return MACSONIC_APPLE
;
400 if (ndev
->dr_hw
== NUBUS_DRHW_SMC9194
&&
401 ndev
->dr_sw
== NUBUS_DRSW_DAYNA
)
402 return MACSONIC_DAYNA
;
404 if (ndev
->dr_hw
== NUBUS_DRHW_SONIC_LC
&&
405 ndev
->dr_sw
== 0) { /* huh? */
406 return MACSONIC_APPLE16
;
411 int __init
mac_nubus_sonic_probe(struct net_device
* dev
)
414 struct nubus_dev
* ndev
= NULL
;
415 struct sonic_local
* lp
= netdev_priv(dev
);
416 unsigned long base_addr
, prom_addr
;
419 int reg_offset
, dma_bitmode
;
421 /* Find the first SONIC that hasn't been initialized already */
422 while ((ndev
= nubus_find_type(NUBUS_CAT_NETWORK
,
423 NUBUS_TYPE_ETHERNET
, ndev
)) != NULL
)
425 /* Have we seen it already? */
426 if (slots
& (1<<ndev
->board
->slot
))
428 slots
|= 1<<ndev
->board
->slot
;
430 /* Is it one of ours? */
431 if ((id
= macsonic_ident(ndev
)) != -1)
439 case MACSONIC_DUODOCK
:
440 base_addr
= ndev
->board
->slot_addr
+ DUODOCK_SONIC_REGISTERS
;
441 prom_addr
= ndev
->board
->slot_addr
+ DUODOCK_SONIC_PROM_BASE
;
442 sonic_dcr
= SONIC_DCR_EXBUS
| SONIC_DCR_RFT0
| SONIC_DCR_RFT1
|
445 dma_bitmode
= SONIC_BITMODE32
;
448 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
449 prom_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_PROM_BASE
;
450 sonic_dcr
= SONIC_DCR_BMS
| SONIC_DCR_RFT1
| SONIC_DCR_TFT0
;
452 dma_bitmode
= SONIC_BITMODE32
;
454 case MACSONIC_APPLE16
:
455 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
456 prom_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_PROM_BASE
;
457 sonic_dcr
= SONIC_DCR_EXBUS
| SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
458 SONIC_DCR_PO1
| SONIC_DCR_BMS
;
460 dma_bitmode
= SONIC_BITMODE16
;
462 case MACSONIC_DAYNALINK
:
463 base_addr
= ndev
->board
->slot_addr
+ APPLE_SONIC_REGISTERS
;
464 prom_addr
= ndev
->board
->slot_addr
+ DAYNALINK_PROM_BASE
;
465 sonic_dcr
= SONIC_DCR_RFT1
| SONIC_DCR_TFT0
|
466 SONIC_DCR_PO1
| SONIC_DCR_BMS
;
468 dma_bitmode
= SONIC_BITMODE16
;
471 base_addr
= ndev
->board
->slot_addr
+ DAYNA_SONIC_REGISTERS
;
472 prom_addr
= ndev
->board
->slot_addr
+ DAYNA_SONIC_MAC_ADDR
;
473 sonic_dcr
= SONIC_DCR_BMS
|
474 SONIC_DCR_RFT1
| SONIC_DCR_TFT0
| SONIC_DCR_PO1
;
476 dma_bitmode
= SONIC_BITMODE16
;
479 printk(KERN_ERR
"macsonic: WTF, id is %d\n", id
);
483 /* Danger! My arms are flailing wildly! You *must* set lp->reg_offset
484 * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
485 dev
->base_addr
= base_addr
;
486 lp
->reg_offset
= reg_offset
;
487 lp
->dma_bitmode
= dma_bitmode
;
488 dev
->irq
= SLOT2IRQ(ndev
->board
->slot
);
490 if (!sonic_version_printed
) {
491 printk(KERN_INFO
"%s", version
);
492 sonic_version_printed
= 1;
494 printk(KERN_INFO
"%s: %s in slot %X\n",
495 lp
->device
->bus_id
, ndev
->board
->name
, ndev
->board
->slot
);
496 printk(KERN_INFO
"%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
497 lp
->device
->bus_id
, SONIC_READ(SONIC_SR
), dma_bitmode
?32:16, reg_offset
);
499 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
500 printk(KERN_INFO
"%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp
->device
->bus_id
,
501 SONIC_READ(SONIC_DCR
) & 0xffff, SONIC_READ(SONIC_DCR2
) & 0xffff);
504 /* Software reset, then initialize control registers. */
505 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
506 SONIC_WRITE(SONIC_DCR
, sonic_dcr
| (dma_bitmode
? SONIC_DCR_DW
: 0));
507 /* This *must* be written back to in order to restore the
508 * extended programmable output bits, since it may not have been
509 * initialised since the hardware reset. */
510 SONIC_WRITE(SONIC_DCR2
, 0);
512 /* Clear *and* disable interrupts to be on the safe side */
513 SONIC_WRITE(SONIC_IMR
, 0);
514 SONIC_WRITE(SONIC_ISR
, 0x7fff);
516 /* Now look for the MAC address. */
517 if (mac_nubus_sonic_ethernet_addr(dev
, prom_addr
, id
) != 0)
520 /* Shared init code */
521 return macsonic_init(dev
);
524 static int __init
mac_sonic_probe(struct platform_device
*device
)
526 struct net_device
*dev
;
527 struct sonic_local
*lp
;
531 dev
= alloc_etherdev(sizeof(struct sonic_local
));
535 lp
= netdev_priv(dev
);
536 lp
->device
= &device
->dev
;
537 SET_NETDEV_DEV(dev
, &device
->dev
);
538 SET_MODULE_OWNER(dev
);
540 /* This will catch fatal stuff like -ENOMEM as well as success */
541 err
= mac_onboard_sonic_probe(dev
);
546 err
= mac_nubus_sonic_probe(dev
);
550 err
= register_netdev(dev
);
554 printk("%s: MAC ", dev
->name
);
555 for (i
= 0; i
< 6; i
++) {
556 printk("%2.2x", dev
->dev_addr
[i
]);
560 printk(" IRQ %d\n", dev
->irq
);
570 MODULE_DESCRIPTION("Macintosh SONIC ethernet driver");
571 module_param(sonic_debug
, int, 0);
572 MODULE_PARM_DESC(sonic_debug
, "macsonic debug level (1-4)");
574 #define SONIC_IRQ_FLAG IRQ_FLG_FAST
578 static int __devexit
mac_sonic_device_remove (struct platform_device
*device
)
580 struct net_device
*dev
= platform_get_drvdata(device
);
581 struct sonic_local
* lp
= netdev_priv(dev
);
583 unregister_netdev (dev
);
584 dma_free_coherent(lp
->device
, SIZEOF_SONIC_DESC
* SONIC_BUS_SCALE(lp
->dma_bitmode
),
585 lp
->descriptors
, lp
->descriptors_laddr
);
591 static struct platform_driver mac_sonic_driver
= {
592 .probe
= mac_sonic_probe
,
593 .remove
= __devexit_p(mac_sonic_device_remove
),
595 .name
= mac_sonic_string
,
599 static int __init
mac_sonic_init_module(void)
603 if ((err
= platform_driver_register(&mac_sonic_driver
))) {
604 printk(KERN_ERR
"Driver registration failed\n");
608 mac_sonic_device
= platform_device_alloc(mac_sonic_string
, 0);
609 if (!mac_sonic_device
) {
613 if (platform_device_add(mac_sonic_device
)) {
614 platform_device_put(mac_sonic_device
);
615 mac_sonic_device
= NULL
;
621 platform_driver_unregister(&mac_sonic_driver
);
626 static void __exit
mac_sonic_cleanup_module(void)
628 platform_driver_unregister(&mac_sonic_driver
);
630 if (mac_sonic_device
) {
631 platform_device_unregister(mac_sonic_device
);
632 mac_sonic_device
= NULL
;
636 module_init(mac_sonic_init_module
);
637 module_exit(mac_sonic_cleanup_module
);