linux/drivers/net/ethernet/natsemi/macsonic.c
<<
>>
Prefs
   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/ioport.h>
  41#include <linux/in.h>
  42#include <linux/string.h>
  43#include <linux/delay.h>
  44#include <linux/nubus.h>
  45#include <linux/errno.h>
  46#include <linux/netdevice.h>
  47#include <linux/etherdevice.h>
  48#include <linux/skbuff.h>
  49#include <linux/platform_device.h>
  50#include <linux/dma-mapping.h>
  51#include <linux/bitrev.h>
  52#include <linux/slab.h>
  53
  54#include <asm/pgtable.h>
  55#include <asm/io.h>
  56#include <asm/hwtest.h>
  57#include <asm/dma.h>
  58#include <asm/macintosh.h>
  59#include <asm/macints.h>
  60#include <asm/mac_via.h>
  61
  62static char mac_sonic_string[] = "macsonic";
  63
  64#include "sonic.h"
  65
  66/* These should basically be bus-size and endian independent (since
  67   the SONIC is at least smart enough that it uses the same endianness
  68   as the host, unlike certain less enlightened Macintosh NICs) */
  69#define SONIC_READ(reg) (nubus_readw(dev->base_addr + (reg * 4) \
  70              + lp->reg_offset))
  71#define SONIC_WRITE(reg,val) (nubus_writew(val, dev->base_addr + (reg * 4) \
  72              + lp->reg_offset))
  73
  74/* use 0 for production, 1 for verification, >1 for debug */
  75#ifdef SONIC_DEBUG
  76static unsigned int sonic_debug = SONIC_DEBUG;
  77#else
  78static unsigned int sonic_debug = 1;
  79#endif
  80
  81static int sonic_version_printed;
  82
  83/* For onboard SONIC */
  84#define ONBOARD_SONIC_REGISTERS 0x50F0A000
  85#define ONBOARD_SONIC_PROM_BASE 0x50f08000
  86
  87enum macsonic_type {
  88        MACSONIC_DUODOCK,
  89        MACSONIC_APPLE,
  90        MACSONIC_APPLE16,
  91        MACSONIC_DAYNA,
  92        MACSONIC_DAYNALINK
  93};
  94
  95/* For the built-in SONIC in the Duo Dock */
  96#define DUODOCK_SONIC_REGISTERS 0xe10000
  97#define DUODOCK_SONIC_PROM_BASE 0xe12000
  98
  99/* For Apple-style NuBus SONIC */
 100#define APPLE_SONIC_REGISTERS   0
 101#define APPLE_SONIC_PROM_BASE   0x40000
 102
 103/* Daynalink LC SONIC */
 104#define DAYNALINK_PROM_BASE 0x400000
 105
 106/* For Dayna-style NuBus SONIC (haven't seen one yet) */
 107#define DAYNA_SONIC_REGISTERS   0x180000
 108/* This is what OpenBSD says.  However, this is definitely in NuBus
 109   ROM space so we should be able to get it by walking the NuBus
 110   resource directories */
 111#define DAYNA_SONIC_MAC_ADDR    0xffe004
 112
 113#define SONIC_READ_PROM(addr) nubus_readb(prom_addr+addr)
 114
 115/*
 116 * For reversing the PROM address
 117 */
 118
 119static inline void bit_reverse_addr(unsigned char addr[6])
 120{
 121        int i;
 122
 123        for(i = 0; i < 6; i++)
 124                addr[i] = bitrev8(addr[i]);
 125}
 126
 127static irqreturn_t macsonic_interrupt(int irq, void *dev_id)
 128{
 129        irqreturn_t result;
 130        unsigned long flags;
 131
 132        local_irq_save(flags);
 133        result = sonic_interrupt(irq, dev_id);
 134        local_irq_restore(flags);
 135        return result;
 136}
 137
 138static int macsonic_open(struct net_device* dev)
 139{
 140        int retval;
 141
 142        retval = request_irq(dev->irq, sonic_interrupt, 0, "sonic", dev);
 143        if (retval) {
 144                printk(KERN_ERR "%s: unable to get IRQ %d.\n",
 145                                dev->name, dev->irq);
 146                goto err;
 147        }
 148        /* Under the A/UX interrupt scheme, the onboard SONIC interrupt comes
 149         * in at priority level 3. However, we sometimes get the level 2 inter-
 150         * rupt as well, which must prevent re-entrance of the sonic handler.
 151         */
 152        if (dev->irq == IRQ_AUTO_3) {
 153                retval = request_irq(IRQ_NUBUS_9, macsonic_interrupt, 0,
 154                                     "sonic", dev);
 155                if (retval) {
 156                        printk(KERN_ERR "%s: unable to get IRQ %d.\n",
 157                                        dev->name, IRQ_NUBUS_9);
 158                        goto err_irq;
 159                }
 160        }
 161        retval = sonic_open(dev);
 162        if (retval)
 163                goto err_irq_nubus;
 164        return 0;
 165
 166err_irq_nubus:
 167        if (dev->irq == IRQ_AUTO_3)
 168                free_irq(IRQ_NUBUS_9, dev);
 169err_irq:
 170        free_irq(dev->irq, dev);
 171err:
 172        return retval;
 173}
 174
 175static int macsonic_close(struct net_device* dev)
 176{
 177        int err;
 178        err = sonic_close(dev);
 179        free_irq(dev->irq, dev);
 180        if (dev->irq == IRQ_AUTO_3)
 181                free_irq(IRQ_NUBUS_9, dev);
 182        return err;
 183}
 184
 185static const struct net_device_ops macsonic_netdev_ops = {
 186        .ndo_open               = macsonic_open,
 187        .ndo_stop               = macsonic_close,
 188        .ndo_start_xmit         = sonic_send_packet,
 189        .ndo_set_rx_mode        = sonic_multicast_list,
 190        .ndo_tx_timeout         = sonic_tx_timeout,
 191        .ndo_get_stats          = sonic_get_stats,
 192        .ndo_validate_addr      = eth_validate_addr,
 193        .ndo_change_mtu         = eth_change_mtu,
 194        .ndo_set_mac_address    = eth_mac_addr,
 195};
 196
 197static int macsonic_init(struct net_device *dev)
 198{
 199        struct sonic_local* lp = netdev_priv(dev);
 200
 201        /* Allocate the entire chunk of memory for the descriptors.
 202           Note that this cannot cross a 64K boundary. */
 203        lp->descriptors = dma_alloc_coherent(lp->device,
 204                                             SIZEOF_SONIC_DESC *
 205                                             SONIC_BUS_SCALE(lp->dma_bitmode),
 206                                             &lp->descriptors_laddr,
 207                                             GFP_KERNEL);
 208        if (lp->descriptors == NULL)
 209                return -ENOMEM;
 210
 211        /* Now set up the pointers to point to the appropriate places */
 212        lp->cda = lp->descriptors;
 213        lp->tda = lp->cda + (SIZEOF_SONIC_CDA
 214                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 215        lp->rda = lp->tda + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
 216                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 217        lp->rra = lp->rda + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
 218                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 219
 220        lp->cda_laddr = lp->descriptors_laddr;
 221        lp->tda_laddr = lp->cda_laddr + (SIZEOF_SONIC_CDA
 222                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 223        lp->rda_laddr = lp->tda_laddr + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
 224                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 225        lp->rra_laddr = lp->rda_laddr + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
 226                             * SONIC_BUS_SCALE(lp->dma_bitmode));
 227
 228        dev->netdev_ops = &macsonic_netdev_ops;
 229        dev->watchdog_timeo = TX_TIMEOUT;
 230
 231        /*
 232         * clear tally counter
 233         */
 234        SONIC_WRITE(SONIC_CRCT, 0xffff);
 235        SONIC_WRITE(SONIC_FAET, 0xffff);
 236        SONIC_WRITE(SONIC_MPT, 0xffff);
 237
 238        return 0;
 239}
 240
 241#define INVALID_MAC(mac) (memcmp(mac, "\x08\x00\x07", 3) && \
 242                          memcmp(mac, "\x00\xA0\x40", 3) && \
 243                          memcmp(mac, "\x00\x80\x19", 3) && \
 244                          memcmp(mac, "\x00\x05\x02", 3))
 245
 246static void mac_onboard_sonic_ethernet_addr(struct net_device *dev)
 247{
 248        struct sonic_local *lp = netdev_priv(dev);
 249        const int prom_addr = ONBOARD_SONIC_PROM_BASE;
 250        unsigned short val;
 251
 252        /*
 253         * On NuBus boards we can sometimes look in the ROM resources.
 254         * No such luck for comm-slot/onboard.
 255         * On the PowerBook 520, the PROM base address is a mystery.
 256         */
 257        if (hwreg_present((void *)prom_addr)) {
 258                int i;
 259
 260                for (i = 0; i < 6; i++)
 261                        dev->dev_addr[i] = SONIC_READ_PROM(i);
 262                if (!INVALID_MAC(dev->dev_addr))
 263                        return;
 264
 265                /*
 266                 * Most of the time, the address is bit-reversed. The NetBSD
 267                 * source has a rather long and detailed historical account of
 268                 * why this is so.
 269                 */
 270                bit_reverse_addr(dev->dev_addr);
 271                if (!INVALID_MAC(dev->dev_addr))
 272                        return;
 273
 274                /*
 275                 * If we still have what seems to be a bogus address, we'll
 276                 * look in the CAM. The top entry should be ours.
 277                 */
 278                printk(KERN_WARNING "macsonic: MAC address in PROM seems "
 279                                    "to be invalid, trying CAM\n");
 280        } else {
 281                printk(KERN_WARNING "macsonic: cannot read MAC address from "
 282                                    "PROM, trying CAM\n");
 283        }
 284
 285        /* This only works if MacOS has already initialized the card. */
 286
 287        SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
 288        SONIC_WRITE(SONIC_CEP, 15);
 289
 290        val = SONIC_READ(SONIC_CAP2);
 291        dev->dev_addr[5] = val >> 8;
 292        dev->dev_addr[4] = val & 0xff;
 293        val = SONIC_READ(SONIC_CAP1);
 294        dev->dev_addr[3] = val >> 8;
 295        dev->dev_addr[2] = val & 0xff;
 296        val = SONIC_READ(SONIC_CAP0);
 297        dev->dev_addr[1] = val >> 8;
 298        dev->dev_addr[0] = val & 0xff;
 299
 300        if (!INVALID_MAC(dev->dev_addr))
 301                return;
 302
 303        /* Still nonsense ... messed up someplace! */
 304
 305        printk(KERN_WARNING "macsonic: MAC address in CAM entry 15 "
 306                            "seems invalid, will use a random MAC\n");
 307        eth_hw_addr_random(dev);
 308}
 309
 310static int mac_onboard_sonic_probe(struct net_device *dev)
 311{
 312        struct sonic_local* lp = netdev_priv(dev);
 313        int sr;
 314        int commslot = 0;
 315
 316        if (!MACH_IS_MAC)
 317                return -ENODEV;
 318
 319        printk(KERN_INFO "Checking for internal Macintosh ethernet (SONIC).. ");
 320
 321        /* Bogus probing, on the models which may or may not have
 322           Ethernet (BTW, the Ethernet *is* always at the same
 323           address, and nothing else lives there, at least if Apple's
 324           documentation is to be believed) */
 325        if (macintosh_config->ident == MAC_MODEL_Q630 ||
 326            macintosh_config->ident == MAC_MODEL_P588 ||
 327            macintosh_config->ident == MAC_MODEL_P575 ||
 328            macintosh_config->ident == MAC_MODEL_C610) {
 329                int card_present;
 330
 331                card_present = hwreg_present((void*)ONBOARD_SONIC_REGISTERS);
 332                if (!card_present) {
 333                        printk("none.\n");
 334                        return -ENODEV;
 335                }
 336                commslot = 1;
 337        }
 338
 339        printk("yes\n");
 340
 341        /* Danger!  My arms are flailing wildly!  You *must* set lp->reg_offset
 342         * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
 343        dev->base_addr = ONBOARD_SONIC_REGISTERS;
 344        if (via_alt_mapping)
 345                dev->irq = IRQ_AUTO_3;
 346        else
 347                dev->irq = IRQ_NUBUS_9;
 348
 349        if (!sonic_version_printed) {
 350                printk(KERN_INFO "%s", version);
 351                sonic_version_printed = 1;
 352        }
 353        printk(KERN_INFO "%s: onboard / comm-slot SONIC at 0x%08lx\n",
 354               dev_name(lp->device), dev->base_addr);
 355
 356        /* The PowerBook's SONIC is 16 bit always. */
 357        if (macintosh_config->ident == MAC_MODEL_PB520) {
 358                lp->reg_offset = 0;
 359                lp->dma_bitmode = SONIC_BITMODE16;
 360                sr = SONIC_READ(SONIC_SR);
 361        } else if (commslot) {
 362                /* Some of the comm-slot cards are 16 bit.  But some
 363                   of them are not.  The 32-bit cards use offset 2 and
 364                   have known revisions, we try reading the revision
 365                   register at offset 2, if we don't get a known revision
 366                   we assume 16 bit at offset 0.  */
 367                lp->reg_offset = 2;
 368                lp->dma_bitmode = SONIC_BITMODE16;
 369
 370                sr = SONIC_READ(SONIC_SR);
 371                if (sr == 0x0004 || sr == 0x0006 || sr == 0x0100 || sr == 0x0101)
 372                        /* 83932 is 0x0004 or 0x0006, 83934 is 0x0100 or 0x0101 */
 373                        lp->dma_bitmode = SONIC_BITMODE32;
 374                else {
 375                        lp->dma_bitmode = SONIC_BITMODE16;
 376                        lp->reg_offset = 0;
 377                        sr = SONIC_READ(SONIC_SR);
 378                }
 379        } else {
 380                /* All onboard cards are at offset 2 with 32 bit DMA. */
 381                lp->reg_offset = 2;
 382                lp->dma_bitmode = SONIC_BITMODE32;
 383                sr = SONIC_READ(SONIC_SR);
 384        }
 385        printk(KERN_INFO
 386               "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
 387               dev_name(lp->device), sr, lp->dma_bitmode?32:16, lp->reg_offset);
 388
 389#if 0 /* This is sometimes useful to find out how MacOS configured the card. */
 390        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
 391               SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 392#endif
 393
 394        /* Software reset, then initialize control registers. */
 395        SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
 396
 397        SONIC_WRITE(SONIC_DCR, SONIC_DCR_EXBUS | SONIC_DCR_BMS |
 398                               SONIC_DCR_RFT1  | SONIC_DCR_TFT0 |
 399                               (lp->dma_bitmode ? SONIC_DCR_DW : 0));
 400
 401        /* This *must* be written back to in order to restore the
 402         * extended programmable output bits, as it may not have been
 403         * initialised since the hardware reset. */
 404        SONIC_WRITE(SONIC_DCR2, 0);
 405
 406        /* Clear *and* disable interrupts to be on the safe side */
 407        SONIC_WRITE(SONIC_IMR, 0);
 408        SONIC_WRITE(SONIC_ISR, 0x7fff);
 409
 410        /* Now look for the MAC address. */
 411        mac_onboard_sonic_ethernet_addr(dev);
 412
 413        /* Shared init code */
 414        return macsonic_init(dev);
 415}
 416
 417static int mac_nubus_sonic_ethernet_addr(struct net_device *dev,
 418                                         unsigned long prom_addr, int id)
 419{
 420        int i;
 421        for(i = 0; i < 6; i++)
 422                dev->dev_addr[i] = SONIC_READ_PROM(i);
 423
 424        /* Some of the addresses are bit-reversed */
 425        if (id != MACSONIC_DAYNA)
 426                bit_reverse_addr(dev->dev_addr);
 427
 428        return 0;
 429}
 430
 431static int macsonic_ident(struct nubus_dev *ndev)
 432{
 433        if (ndev->dr_hw == NUBUS_DRHW_ASANTE_LC &&
 434            ndev->dr_sw == NUBUS_DRSW_SONIC_LC)
 435                return MACSONIC_DAYNALINK;
 436        if (ndev->dr_hw == NUBUS_DRHW_SONIC &&
 437            ndev->dr_sw == NUBUS_DRSW_APPLE) {
 438                /* There has to be a better way to do this... */
 439                if (strstr(ndev->board->name, "DuoDock"))
 440                        return MACSONIC_DUODOCK;
 441                else
 442                        return MACSONIC_APPLE;
 443        }
 444
 445        if (ndev->dr_hw == NUBUS_DRHW_SMC9194 &&
 446            ndev->dr_sw == NUBUS_DRSW_DAYNA)
 447                return MACSONIC_DAYNA;
 448
 449        if (ndev->dr_hw == NUBUS_DRHW_APPLE_SONIC_LC &&
 450            ndev->dr_sw == 0) { /* huh? */
 451                return MACSONIC_APPLE16;
 452        }
 453        return -1;
 454}
 455
 456static int mac_nubus_sonic_probe(struct net_device *dev)
 457{
 458        static int slots;
 459        struct nubus_dev* ndev = NULL;
 460        struct sonic_local* lp = netdev_priv(dev);
 461        unsigned long base_addr, prom_addr;
 462        u16 sonic_dcr;
 463        int id = -1;
 464        int reg_offset, dma_bitmode;
 465
 466        /* Find the first SONIC that hasn't been initialized already */
 467        while ((ndev = nubus_find_type(NUBUS_CAT_NETWORK,
 468                                       NUBUS_TYPE_ETHERNET, ndev)) != NULL)
 469        {
 470                /* Have we seen it already? */
 471                if (slots & (1<<ndev->board->slot))
 472                        continue;
 473                slots |= 1<<ndev->board->slot;
 474
 475                /* Is it one of ours? */
 476                if ((id = macsonic_ident(ndev)) != -1)
 477                        break;
 478        }
 479
 480        if (ndev == NULL)
 481                return -ENODEV;
 482
 483        switch (id) {
 484        case MACSONIC_DUODOCK:
 485                base_addr = ndev->board->slot_addr + DUODOCK_SONIC_REGISTERS;
 486                prom_addr = ndev->board->slot_addr + DUODOCK_SONIC_PROM_BASE;
 487                sonic_dcr = SONIC_DCR_EXBUS | SONIC_DCR_RFT0 | SONIC_DCR_RFT1 |
 488                            SONIC_DCR_TFT0;
 489                reg_offset = 2;
 490                dma_bitmode = SONIC_BITMODE32;
 491                break;
 492        case MACSONIC_APPLE:
 493                base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
 494                prom_addr = ndev->board->slot_addr + APPLE_SONIC_PROM_BASE;
 495                sonic_dcr = SONIC_DCR_BMS | SONIC_DCR_RFT1 | SONIC_DCR_TFT0;
 496                reg_offset = 0;
 497                dma_bitmode = SONIC_BITMODE32;
 498                break;
 499        case MACSONIC_APPLE16:
 500                base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
 501                prom_addr = ndev->board->slot_addr + APPLE_SONIC_PROM_BASE;
 502                sonic_dcr = SONIC_DCR_EXBUS | SONIC_DCR_RFT1 | SONIC_DCR_TFT0 |
 503                            SONIC_DCR_PO1 | SONIC_DCR_BMS;
 504                reg_offset = 0;
 505                dma_bitmode = SONIC_BITMODE16;
 506                break;
 507        case MACSONIC_DAYNALINK:
 508                base_addr = ndev->board->slot_addr + APPLE_SONIC_REGISTERS;
 509                prom_addr = ndev->board->slot_addr + DAYNALINK_PROM_BASE;
 510                sonic_dcr = SONIC_DCR_RFT1 | SONIC_DCR_TFT0 |
 511                            SONIC_DCR_PO1 | SONIC_DCR_BMS;
 512                reg_offset = 0;
 513                dma_bitmode = SONIC_BITMODE16;
 514                break;
 515        case MACSONIC_DAYNA:
 516                base_addr = ndev->board->slot_addr + DAYNA_SONIC_REGISTERS;
 517                prom_addr = ndev->board->slot_addr + DAYNA_SONIC_MAC_ADDR;
 518                sonic_dcr = SONIC_DCR_BMS |
 519                            SONIC_DCR_RFT1 | SONIC_DCR_TFT0 | SONIC_DCR_PO1;
 520                reg_offset = 0;
 521                dma_bitmode = SONIC_BITMODE16;
 522                break;
 523        default:
 524                printk(KERN_ERR "macsonic: WTF, id is %d\n", id);
 525                return -ENODEV;
 526        }
 527
 528        /* Danger!  My arms are flailing wildly!  You *must* set lp->reg_offset
 529         * and dev->base_addr before using SONIC_READ() or SONIC_WRITE() */
 530        dev->base_addr = base_addr;
 531        lp->reg_offset = reg_offset;
 532        lp->dma_bitmode = dma_bitmode;
 533        dev->irq = SLOT2IRQ(ndev->board->slot);
 534
 535        if (!sonic_version_printed) {
 536                printk(KERN_INFO "%s", version);
 537                sonic_version_printed = 1;
 538        }
 539        printk(KERN_INFO "%s: %s in slot %X\n",
 540               dev_name(lp->device), ndev->board->name, ndev->board->slot);
 541        printk(KERN_INFO "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
 542               dev_name(lp->device), SONIC_READ(SONIC_SR), dma_bitmode?32:16, reg_offset);
 543
 544#if 0 /* This is sometimes useful to find out how MacOS configured the card. */
 545        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
 546               SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 547#endif
 548
 549        /* Software reset, then initialize control registers. */
 550        SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
 551        SONIC_WRITE(SONIC_DCR, sonic_dcr | (dma_bitmode ? SONIC_DCR_DW : 0));
 552        /* This *must* be written back to in order to restore the
 553         * extended programmable output bits, since it may not have been
 554         * initialised since the hardware reset. */
 555        SONIC_WRITE(SONIC_DCR2, 0);
 556
 557        /* Clear *and* disable interrupts to be on the safe side */
 558        SONIC_WRITE(SONIC_IMR, 0);
 559        SONIC_WRITE(SONIC_ISR, 0x7fff);
 560
 561        /* Now look for the MAC address. */
 562        if (mac_nubus_sonic_ethernet_addr(dev, prom_addr, id) != 0)
 563                return -ENODEV;
 564
 565        /* Shared init code */
 566        return macsonic_init(dev);
 567}
 568
 569static int mac_sonic_probe(struct platform_device *pdev)
 570{
 571        struct net_device *dev;
 572        struct sonic_local *lp;
 573        int err;
 574
 575        dev = alloc_etherdev(sizeof(struct sonic_local));
 576        if (!dev)
 577                return -ENOMEM;
 578
 579        lp = netdev_priv(dev);
 580        lp->device = &pdev->dev;
 581        SET_NETDEV_DEV(dev, &pdev->dev);
 582        platform_set_drvdata(pdev, dev);
 583
 584        /* This will catch fatal stuff like -ENOMEM as well as success */
 585        err = mac_onboard_sonic_probe(dev);
 586        if (err == 0)
 587                goto found;
 588        if (err != -ENODEV)
 589                goto out;
 590        err = mac_nubus_sonic_probe(dev);
 591        if (err)
 592                goto out;
 593found:
 594        err = register_netdev(dev);
 595        if (err)
 596                goto out;
 597
 598        printk("%s: MAC %pM IRQ %d\n", dev->name, dev->dev_addr, dev->irq);
 599
 600        return 0;
 601
 602out:
 603        free_netdev(dev);
 604
 605        return err;
 606}
 607
 608MODULE_DESCRIPTION("Macintosh SONIC ethernet driver");
 609module_param(sonic_debug, int, 0);
 610MODULE_PARM_DESC(sonic_debug, "macsonic debug level (1-4)");
 611MODULE_ALIAS("platform:macsonic");
 612
 613#include "sonic.c"
 614
 615static int mac_sonic_device_remove(struct platform_device *pdev)
 616{
 617        struct net_device *dev = platform_get_drvdata(pdev);
 618        struct sonic_local* lp = netdev_priv(dev);
 619
 620        unregister_netdev(dev);
 621        dma_free_coherent(lp->device, SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
 622                          lp->descriptors, lp->descriptors_laddr);
 623        free_netdev(dev);
 624
 625        return 0;
 626}
 627
 628static struct platform_driver mac_sonic_driver = {
 629        .probe  = mac_sonic_probe,
 630        .remove = mac_sonic_device_remove,
 631        .driver = {
 632                .name   = mac_sonic_string,
 633        },
 634};
 635
 636module_platform_driver(mac_sonic_driver);
 637