← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/net/macsonic.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/macsonic.c
1
 
/*
2
 
 * macsonic.c
3
 
 *
4
 
 * (C) 2005 Finn Thain
5
 
 *
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.
9
 
 *
10
 
 * (C) 1998 Alan Cox
11
 
 *
12
 
 * Debugging Andreas Ehliar, Michael Schmitz
13
 
 *
14
 
 * Based on code
15
 
 * (C) 1996 by Thomas Bogendoerfer (tsbogend@bigbug.franken.de)
16
 
 *
17
 
 * This driver is based on work from Andreas Busse, but most of
18
 
 * the code is rewritten.
19
 
 *
20
 
 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
21
 
 *
22
 
 * A driver for the Mac onboard Sonic ethernet chip.
23
 
 *
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.
27
 
 *
28
 
 * 99/01/03 MSch: upgraded to version 0.92 of the core driver, fixed.
29
 
 *
30
 
 * 00/10/31 sammy@oh.verio.com: Updated driver for 2.4 kernels, fixed problems
31
 
 *          on centris.
32
 
 */
33
 
 
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>
42
 
#include <linux/in.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>
54
 
 
55
 
#include <asm/bootinfo.h>
56
 
#include <asm/system.h>
57
 
#include <asm/pgtable.h>
58
 
#include <asm/io.h>
59
 
#include <asm/hwtest.h>
60
 
#include <asm/dma.h>
61
 
#include <asm/macintosh.h>
62
 
#include <asm/macints.h>
63
 
#include <asm/mac_via.h>
64
 
 
65
 
static char mac_sonic_string[] = "macsonic";
66
 
 
67
 
#include "sonic.h"
68
 
 
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) \
73
 
              + lp->reg_offset))
74
 
#define SONIC_WRITE(reg,val) (nubus_writew(val, dev->base_addr + (reg * 4) \
75
 
              + lp->reg_offset))
76
 
 
77
 
/* use 0 for production, 1 for verification, >1 for debug */
78
 
#ifdef SONIC_DEBUG
79
 
static unsigned int sonic_debug = SONIC_DEBUG;
80
 
#else
81
 
static unsigned int sonic_debug = 1;
82
 
#endif
83
 
 
84
 
static int sonic_version_printed;
85
 
 
86
 
/* For onboard SONIC */
87
 
#define ONBOARD_SONIC_REGISTERS 0x50F0A000
88
 
#define ONBOARD_SONIC_PROM_BASE 0x50f08000
89
 
 
90
 
enum macsonic_type {
91
 
        MACSONIC_DUODOCK,
92
 
        MACSONIC_APPLE,
93
 
        MACSONIC_APPLE16,
94
 
        MACSONIC_DAYNA,
95
 
        MACSONIC_DAYNALINK
96
 
};
97
 
 
98
 
/* For the built-in SONIC in the Duo Dock */
99
 
#define DUODOCK_SONIC_REGISTERS 0xe10000
100
 
#define DUODOCK_SONIC_PROM_BASE 0xe12000
101
 
 
102
 
/* For Apple-style NuBus SONIC */
103
 
#define APPLE_SONIC_REGISTERS   0
104
 
#define APPLE_SONIC_PROM_BASE   0x40000
105
 
 
106
 
/* Daynalink LC SONIC */
107
 
#define DAYNALINK_PROM_BASE 0x400000
108
 
 
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
115
 
 
116
 
#define SONIC_READ_PROM(addr) nubus_readb(prom_addr+addr)
117
 
 
118
 
/*
119
 
 * For reversing the PROM address
120
 
 */
121
 
 
122
 
static inline void bit_reverse_addr(unsigned char addr[6])
123
 
{
124
 
        int i;
125
 
 
126
 
        for(i = 0; i < 6; i++)
127
 
                addr[i] = bitrev8(addr[i]);
128
 
}
129
 
 
130
 
static irqreturn_t macsonic_interrupt(int irq, void *dev_id)
131
 
{
132
 
        irqreturn_t result;
133
 
        unsigned long flags;
134
 
 
135
 
        local_irq_save(flags);
136
 
        result = sonic_interrupt(irq, dev_id);
137
 
        local_irq_restore(flags);
138
 
        return result;
139
 
}
140
 
 
141
 
static int macsonic_open(struct net_device* dev)
142
 
{
143
 
        int retval;
144
 
 
145
 
        retval = request_irq(dev->irq, sonic_interrupt, IRQ_FLG_FAST,
146
 
                                "sonic", dev);
147
 
        if (retval) {
148
 
                printk(KERN_ERR "%s: unable to get IRQ %d.\n",
149
 
                                dev->name, dev->irq);
150
 
                goto err;
151
 
        }
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.
155
 
         */
156
 
        if (dev->irq == IRQ_AUTO_3) {
157
 
                retval = request_irq(IRQ_NUBUS_9, macsonic_interrupt,
158
 
                                        IRQ_FLG_FAST, "sonic", dev);
159
 
                if (retval) {
160
 
                        printk(KERN_ERR "%s: unable to get IRQ %d.\n",
161
 
                                        dev->name, IRQ_NUBUS_9);
162
 
                        goto err_irq;
163
 
                }
164
 
        }
165
 
        retval = sonic_open(dev);
166
 
        if (retval)
167
 
                goto err_irq_nubus;
168
 
        return 0;
169
 
 
170
 
err_irq_nubus:
171
 
        if (dev->irq == IRQ_AUTO_3)
172
 
                free_irq(IRQ_NUBUS_9, dev);
173
 
err_irq:
174
 
        free_irq(dev->irq, dev);
175
 
err:
176
 
        return retval;
177
 
}
178
 
 
179
 
static int macsonic_close(struct net_device* dev)
180
 
{
181
 
        int err;
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);
186
 
        return err;
187
 
}
188
 
 
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_multicast_list = 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,
199
 
};
200
 
 
201
 
static int __devinit macsonic_init(struct net_device *dev)
202
 
{
203
 
        struct sonic_local* lp = netdev_priv(dev);
204
 
 
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));
212
 
                return -ENOMEM;
213
 
        }
214
 
 
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));
223
 
 
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));
231
 
 
232
 
        dev->netdev_ops = &macsonic_netdev_ops;
233
 
        dev->watchdog_timeo = TX_TIMEOUT;
234
 
 
235
 
        /*
236
 
         * clear tally counter
237
 
         */
238
 
        SONIC_WRITE(SONIC_CRCT, 0xffff);
239
 
        SONIC_WRITE(SONIC_FAET, 0xffff);
240
 
        SONIC_WRITE(SONIC_MPT, 0xffff);
241
 
 
242
 
        return 0;
243
 
}
244
 
 
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))
249
 
 
250
 
static void __devinit mac_onboard_sonic_ethernet_addr(struct net_device *dev)
251
 
{
252
 
        struct sonic_local *lp = netdev_priv(dev);
253
 
        const int prom_addr = ONBOARD_SONIC_PROM_BASE;
254
 
        unsigned short val;
255
 
 
256
 
        /*
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.
260
 
         */
261
 
        if (hwreg_present((void *)prom_addr)) {
262
 
                int i;
263
 
 
264
 
                for (i = 0; i < 6; i++)
265
 
                        dev->dev_addr[i] = SONIC_READ_PROM(i);
266
 
                if (!INVALID_MAC(dev->dev_addr))
267
 
                        return;
268
 
 
269
 
                /*
270
 
                 * Most of the time, the address is bit-reversed. The NetBSD
271
 
                 * source has a rather long and detailed historical account of
272
 
                 * why this is so.
273
 
                 */
274
 
                bit_reverse_addr(dev->dev_addr);
275
 
                if (!INVALID_MAC(dev->dev_addr))
276
 
                        return;
277
 
 
278
 
                /*
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.
281
 
                 */
282
 
                printk(KERN_WARNING "macsonic: MAC address in PROM seems "
283
 
                                    "to be invalid, trying CAM\n");
284
 
        } else {
285
 
                printk(KERN_WARNING "macsonic: cannot read MAC address from "
286
 
                                    "PROM, trying CAM\n");
287
 
        }
288
 
 
289
 
        /* This only works if MacOS has already initialized the card. */
290
 
 
291
 
        SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
292
 
        SONIC_WRITE(SONIC_CEP, 15);
293
 
 
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;
303
 
 
304
 
        if (!INVALID_MAC(dev->dev_addr))
305
 
                return;
306
 
 
307
 
        /* Still nonsense ... messed up someplace! */
308
 
 
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);
312
 
}
313
 
 
314
 
static int __devinit mac_onboard_sonic_probe(struct net_device *dev)
315
 
{
316
 
        /* Bwahahaha */
317
 
        static int once_is_more_than_enough;
318
 
        struct sonic_local* lp = netdev_priv(dev);
319
 
        int sr;
320
 
        int commslot = 0;
321
 
 
322
 
        if (once_is_more_than_enough)
323
 
                return -ENODEV;
324
 
        once_is_more_than_enough = 1;
325
 
 
326
 
        if (!MACH_IS_MAC)
327
 
                return -ENODEV;
328
 
 
329
 
        if (macintosh_config->ether_type != MAC_ETHER_SONIC)
330
 
                return -ENODEV;
331
 
 
332
 
        printk(KERN_INFO "Checking for internal Macintosh ethernet (SONIC).. ");
333
 
 
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) {
342
 
                unsigned long flags;
343
 
                int card_present;
344
 
 
345
 
                local_irq_save(flags);
346
 
                card_present = hwreg_present((void*)ONBOARD_SONIC_REGISTERS);
347
 
                local_irq_restore(flags);
348
 
 
349
 
                if (!card_present) {
350
 
                        printk("none.\n");
351
 
                        return -ENODEV;
352
 
                }
353
 
                commslot = 1;
354
 
        }
355
 
 
356
 
        printk("yes\n");
357
 
 
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;
361
 
        if (via_alt_mapping)
362
 
                dev->irq = IRQ_AUTO_3;
363
 
        else
364
 
                dev->irq = IRQ_NUBUS_9;
365
 
 
366
 
        if (!sonic_version_printed) {
367
 
                printk(KERN_INFO "%s", version);
368
 
                sonic_version_printed = 1;
369
 
        }
370
 
        printk(KERN_INFO "%s: onboard / comm-slot SONIC at 0x%08lx\n",
371
 
               dev_name(lp->device), dev->base_addr);
372
 
 
373
 
        /* The PowerBook's SONIC is 16 bit always. */
374
 
        if (macintosh_config->ident == MAC_MODEL_PB520) {
375
 
                lp->reg_offset = 0;
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.  */
384
 
                lp->reg_offset = 2;
385
 
                lp->dma_bitmode = SONIC_BITMODE16;
386
 
 
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;
391
 
                else {
392
 
                        lp->dma_bitmode = SONIC_BITMODE16;
393
 
                        lp->reg_offset = 0;
394
 
                        sr = SONIC_READ(SONIC_SR);
395
 
                }
396
 
        } else {
397
 
                /* All onboard cards are at offset 2 with 32 bit DMA. */
398
 
                lp->reg_offset = 2;
399
 
                lp->dma_bitmode = SONIC_BITMODE32;
400
 
                sr = SONIC_READ(SONIC_SR);
401
 
        }
402
 
        printk(KERN_INFO
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);
405
 
 
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);
409
 
#endif
410
 
 
411
 
        /* Software reset, then initialize control registers. */
412
 
        SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
413
 
 
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));
417
 
 
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);
422
 
 
423
 
        /* Clear *and* disable interrupts to be on the safe side */
424
 
        SONIC_WRITE(SONIC_IMR, 0);
425
 
        SONIC_WRITE(SONIC_ISR, 0x7fff);
426
 
 
427
 
        /* Now look for the MAC address. */
428
 
        mac_onboard_sonic_ethernet_addr(dev);
429
 
 
430
 
        /* Shared init code */
431
 
        return macsonic_init(dev);
432
 
}
433
 
 
434
 
static int __devinit mac_nubus_sonic_ethernet_addr(struct net_device *dev,
435
 
                                                unsigned long prom_addr,
436
 
                                                int id)
437
 
{
438
 
        int i;
439
 
        for(i = 0; i < 6; i++)
440
 
                dev->dev_addr[i] = SONIC_READ_PROM(i);
441
 
 
442
 
        /* Some of the addresses are bit-reversed */
443
 
        if (id != MACSONIC_DAYNA)
444
 
                bit_reverse_addr(dev->dev_addr);
445
 
 
446
 
        return 0;
447
 
}
448
 
 
449
 
static int __devinit macsonic_ident(struct nubus_dev *ndev)
450
 
{
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;
459
 
                else
460
 
                        return MACSONIC_APPLE;
461
 
        }
462
 
 
463
 
        if (ndev->dr_hw == NUBUS_DRHW_SMC9194 &&
464
 
            ndev->dr_sw == NUBUS_DRSW_DAYNA)
465
 
                return MACSONIC_DAYNA;
466
 
 
467
 
        if (ndev->dr_hw == NUBUS_DRHW_APPLE_SONIC_LC &&
468
 
            ndev->dr_sw == 0) { /* huh? */
469
 
                return MACSONIC_APPLE16;
470
 
        }
471
 
        return -1;
472
 
}
473
 
 
474
 
static int __devinit mac_nubus_sonic_probe(struct net_device *dev)
475
 
{
476
 
        static int slots;
477
 
        struct nubus_dev* ndev = NULL;
478
 
        struct sonic_local* lp = netdev_priv(dev);
479
 
        unsigned long base_addr, prom_addr;
480
 
        u16 sonic_dcr;
481
 
        int id = -1;
482
 
        int reg_offset, dma_bitmode;
483
 
 
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)
487
 
        {
488
 
                /* Have we seen it already? */
489
 
                if (slots & (1<<ndev->board->slot))
490
 
                        continue;
491
 
                slots |= 1<<ndev->board->slot;
492
 
 
493
 
                /* Is it one of ours? */
494
 
                if ((id = macsonic_ident(ndev)) != -1)
495
 
                        break;
496
 
        }
497
 
 
498
 
        if (ndev == NULL)
499
 
                return -ENODEV;
500
 
 
501
 
        switch (id) {
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 |
506
 
                            SONIC_DCR_TFT0;
507
 
                reg_offset = 2;
508
 
                dma_bitmode = SONIC_BITMODE32;
509
 
                break;
510
 
        case MACSONIC_APPLE:
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;
514
 
                reg_offset = 0;
515
 
                dma_bitmode = SONIC_BITMODE32;
516
 
                break;
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;
522
 
                reg_offset = 0;
523
 
                dma_bitmode = SONIC_BITMODE16;
524
 
                break;
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;
530
 
                reg_offset = 0;
531
 
                dma_bitmode = SONIC_BITMODE16;
532
 
                break;
533
 
        case MACSONIC_DAYNA:
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;
538
 
                reg_offset = 0;
539
 
                dma_bitmode = SONIC_BITMODE16;
540
 
                break;
541
 
        default:
542
 
                printk(KERN_ERR "macsonic: WTF, id is %d\n", id);
543
 
                return -ENODEV;
544
 
        }
545
 
 
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);
552
 
 
553
 
        if (!sonic_version_printed) {
554
 
                printk(KERN_INFO "%s", version);
555
 
                sonic_version_printed = 1;
556
 
        }
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);
561
 
 
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);
565
 
#endif
566
 
 
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);
574
 
 
575
 
        /* Clear *and* disable interrupts to be on the safe side */
576
 
        SONIC_WRITE(SONIC_IMR, 0);
577
 
        SONIC_WRITE(SONIC_ISR, 0x7fff);
578
 
 
579
 
        /* Now look for the MAC address. */
580
 
        if (mac_nubus_sonic_ethernet_addr(dev, prom_addr, id) != 0)
581
 
                return -ENODEV;
582
 
 
583
 
        /* Shared init code */
584
 
        return macsonic_init(dev);
585
 
}
586
 
 
587
 
static int __devinit mac_sonic_probe(struct platform_device *pdev)
588
 
{
589
 
        struct net_device *dev;
590
 
        struct sonic_local *lp;
591
 
        int err;
592
 
 
593
 
        dev = alloc_etherdev(sizeof(struct sonic_local));
594
 
        if (!dev)
595
 
                return -ENOMEM;
596
 
 
597
 
        lp = netdev_priv(dev);
598
 
        lp->device = &pdev->dev;
599
 
        SET_NETDEV_DEV(dev, &pdev->dev);
600
 
        platform_set_drvdata(pdev, dev);
601
 
 
602
 
        /* This will catch fatal stuff like -ENOMEM as well as success */
603
 
        err = mac_onboard_sonic_probe(dev);
604
 
        if (err == 0)
605
 
                goto found;
606
 
        if (err != -ENODEV)
607
 
                goto out;
608
 
        err = mac_nubus_sonic_probe(dev);
609
 
        if (err)
610
 
                goto out;
611
 
found:
612
 
        err = register_netdev(dev);
613
 
        if (err)
614
 
                goto out;
615
 
 
616
 
        printk("%s: MAC %pM IRQ %d\n", dev->name, dev->dev_addr, dev->irq);
617
 
 
618
 
        return 0;
619
 
 
620
 
out:
621
 
        free_netdev(dev);
622
 
 
623
 
        return err;
624
 
}
625
 
 
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");
630
 
 
631
 
#include "sonic.c"
632
 
 
633
 
static int __devexit mac_sonic_device_remove (struct platform_device *pdev)
634
 
{
635
 
        struct net_device *dev = platform_get_drvdata(pdev);
636
 
        struct sonic_local* lp = netdev_priv(dev);
637
 
 
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);
641
 
        free_netdev(dev);
642
 
 
643
 
        return 0;
644
 
}
645
 
 
646
 
static struct platform_driver mac_sonic_driver = {
647
 
        .probe  = mac_sonic_probe,
648
 
        .remove = __devexit_p(mac_sonic_device_remove),
649
 
        .driver = {
650
 
                .name   = mac_sonic_string,
651
 
                .owner  = THIS_MODULE,
652
 
        },
653
 
};
654
 
 
655
 
static int __init mac_sonic_init_module(void)
656
 
{
657
 
        return platform_driver_register(&mac_sonic_driver);
658
 
}
659
 
 
660
 
static void __exit mac_sonic_cleanup_module(void)
661
 
{
662
 
        platform_driver_unregister(&mac_sonic_driver);
663
 
}
664
 
 
665
 
module_init(mac_sonic_init_module);
666
 
module_exit(mac_sonic_cleanup_module);