release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/net/mac89x0.c

   1 /* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
   2 /*
   3         Written 1996 by Russell Nelson, with reference to skeleton.c
   4         written 1993-1994 by Donald Becker.
   5
   6         This software may be used and distributed according to the terms
   7         of the GNU General Public License, incorporated herein by reference.
   8
   9         The author may be reached at nelson@crynwr.com, Crynwr
  10         Software, 11 Grant St., Potsdam, NY 13676
  11
  12   Changelog:
  13
  14   Mike Cruse        : mcruse@cti-ltd.com
  15                     : Changes for Linux 2.0 compatibility.
  16                     : Added dev_id parameter in net_interrupt(),
  17                     : request_irq() and free_irq(). Just NULL for now.
  18
  19   Mike Cruse        : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
  20                     : in net_open() and net_close() so kerneld would know
  21                     : that the module is in use and wouldn't eject the
  22                     : driver prematurely.
  23
  24   Mike Cruse        : Rewrote init_module() and cleanup_module using 8390.c
  25                     : as an example. Disabled autoprobing in init_module(),
  26                     : not a good thing to do to other devices while Linux
  27                     : is running from all accounts.
  28
  29   Alan Cox          : Removed 1.2 support, added 2.1 extra counters.
  30
  31   David Huggins-Daines <dhd@debian.org>
  32
  33   Split this off into mac89x0.c, and gutted it of all parts which are
  34   not relevant to the existing CS8900 cards on the Macintosh
  35   (i.e. basically the Daynaport CS and LC cards).  To be precise:
  36
  37     * Removed all the media-detection stuff, because these cards are
  38     TP-only.
  39
  40     * Lobotomized the ISA interrupt bogosity, because these cards use
  41     a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
  42
  43     * Basically eliminated everything not relevant to getting the
  44     cards minimally functioning on the Macintosh.
  45
  46   I might add that these cards are badly designed even from the Mac
  47   standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
  48   I/O space and NuBus interrupts for these cards, but neglected to
  49   provide anything even remotely resembling a NuBus ROM.  Therefore we
  50   have to probe for them in a brain-damaged ISA-like fashion.
  51
  52   Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
  53   check kmalloc and release the allocated memory on failure in
  54   mac89x0_probe and in init_module
  55   use local_irq_{save,restore}(flags) in net_get_stat, not just
  56   local_irq_{dis,en}able()
  57 */
  58
  59 static char *version =
  60 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
  61
  62 /* ======================= configure the driver here ======================= */
  63
  64 /* use 0 for production, 1 for verification, >2 for debug */
  65 #ifndef NET_DEBUG
  66 #define NET_DEBUG 0
  67 #endif
  68
  69 /* ======================= end of configuration ======================= */
  70
  71
  72 /* Always include 'config.h' first in case the user wants to turn on
  73    or override something. */
  74 #include <linux/module.h>
  75
  76 /*
  77   Sources:
  78
  79         Crynwr packet driver epktisa.
  80
  81         Crystal Semiconductor data sheets.
  82
  83 */
  84
  85 #include <linux/kernel.h>
  86 #include <linux/types.h>
  87 #include <linux/fcntl.h>
  88 #include <linux/interrupt.h>
  89 #include <linux/ioport.h>
  90 #include <linux/in.h>
  91 #include <linux/string.h>
  92 #include <linux/nubus.h>
  93 #include <linux/errno.h>
  94 #include <linux/init.h>
  95 #include <linux/netdevice.h>
  96 #include <linux/etherdevice.h>
  97 #include <linux/skbuff.h>
  98 #include <linux/delay.h>
  99 #include <linux/bitops.h>
 100 #include <linux/gfp.h>
 101
 102 #include <asm/system.h>
 103 #include <asm/io.h>
 104 #include <asm/hwtest.h>
 105 #include <asm/macints.h>
 106
 107 #include "cs89x0.h"
 108
 109 static unsigned int net_debug = NET_DEBUG;
 110
 111 /* Information that need to be kept for each board. */
 112 struct net_local {
 113         int chip_type;          /* one of: CS8900, CS8920, CS8920M */
 114         char chip_revision;     /* revision letter of the chip ('A'...) */
 115         int send_cmd;           /* the propercommand used to send a packet. */
 116         int rx_mode;
 117         int curr_rx_cfg;
 118         int send_underrun;      /* keep track of how many underruns in a row we get */
 119         struct sk_buff *skb;
 120 };
 121
 122 /* Index to functions, as function prototypes. */
 123
 124 static int net_open(struct net_device *dev);
 125 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
 126 static irqreturn_t net_interrupt(int irq, void *dev_id);
 127 static void set_multicast_list(struct net_device *dev);
 128 static void net_rx(struct net_device *dev);
 129 static int net_close(struct net_device *dev);
 130 static struct net_device_stats *net_get_stats(struct net_device *dev);
 131 static int set_mac_address(struct net_device *dev, void *addr);
 132
 133
 134 /* Example routines you must write ;->. */
 135 #define tx_done(dev) 1
 136
 137 /* For reading/writing registers ISA-style */
 138 static inline int
 139 readreg_io(struct net_device *dev, int portno)
 140 {
 141         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 142         return swab16(nubus_readw(dev->base_addr + DATA_PORT));
 143 }
 144
 145 static inline void
 146 writereg_io(struct net_device *dev, int portno, int value)
 147 {
 148         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 149         nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
 150 }
 151
 152 /* These are for reading/writing registers in shared memory */
 153 static inline int
 154 readreg(struct net_device *dev, int portno)
 155 {
 156         return swab16(nubus_readw(dev->mem_start + portno));
 157 }
 158
 159 static inline void
 160 writereg(struct net_device *dev, int portno, int value)
 161 {
 162         nubus_writew(swab16(value), dev->mem_start + portno);
 163 }
 164
 165 static const struct net_device_ops mac89x0_netdev_ops = {
 166         .ndo_open               = net_open,
 167         .ndo_stop               = net_close,
 168         .ndo_start_xmit         = net_send_packet,
 169         .ndo_get_stats          = net_get_stats,
 170         .ndo_set_multicast_list = set_multicast_list,
 171         .ndo_set_mac_address    = set_mac_address,
 172         .ndo_validate_addr      = eth_validate_addr,
 173         .ndo_change_mtu         = eth_change_mtu,
 174 };
 175
 176 /* Probe for the CS8900 card in slot E.  We won't bother looking
 177    anywhere else until we have a really good reason to do so. */
 178 struct net_device * __init mac89x0_probe(int unit)
 179 {
 180         struct net_device *dev;
 181         static int once_is_enough;
 182         struct net_local *lp;
 183         static unsigned version_printed;
 184         int i, slot;
 185         unsigned rev_type = 0;
 186         unsigned long ioaddr;
 187         unsigned short sig;
 188         int err = -ENODEV;
 189
 190         if (!MACH_IS_MAC)
 191                 return ERR_PTR(-ENODEV);
 192
 193         dev = alloc_etherdev(sizeof(struct net_local));
 194         if (!dev)
 195                 return ERR_PTR(-ENOMEM);
 196
 197         if (unit >= 0) {
 198                 sprintf(dev->name, "eth%d", unit);
 199                 netdev_boot_setup_check(dev);
 200         }
 201
 202         if (once_is_enough)
 203                 goto out;
 204         once_is_enough = 1;
 205
 206         /* We might have to parameterize this later */
 207         slot = 0xE;
 208         /* Get out now if there's a real NuBus card in slot E */
 209         if (nubus_find_slot(slot, NULL) != NULL)
 210                 goto out;
 211
 212         /* The pseudo-ISA bits always live at offset 0x300 (gee,
 213            wonder why...) */
 214         ioaddr = (unsigned long)
 215                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
 216         {
 217                 unsigned long flags;
 218                 int card_present;
 219
 220                 local_irq_save(flags);
 221                 card_present = (hwreg_present((void*) ioaddr+4) &&
 222                                 hwreg_present((void*) ioaddr + DATA_PORT));
 223                 local_irq_restore(flags);
 224
 225                 if (!card_present)
 226                         goto out;
 227         }
 228
 229         nubus_writew(0, ioaddr + ADD_PORT);
 230         sig = nubus_readw(ioaddr + DATA_PORT);
 231         if (sig != swab16(CHIP_EISA_ID_SIG))
 232                 goto out;
 233
 234         /* Initialize the net_device structure. */
 235         lp = netdev_priv(dev);
 236
 237         /* Fill in the 'dev' fields. */
 238         dev->base_addr = ioaddr;
 239         dev->mem_start = (unsigned long)
 240                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
 241         dev->mem_end = dev->mem_start + 0x1000;
 242
 243         /* Turn on shared memory */
 244         writereg_io(dev, PP_BusCTL, MEMORY_ON);
 245
 246         /* get the chip type */
 247         rev_type = readreg(dev, PRODUCT_ID_ADD);
 248         lp->chip_type = rev_type &~ REVISON_BITS;
 249         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 250
 251         /* Check the chip type and revision in order to set the correct send command
 252         CS8920 revision C and CS8900 revision F can use the faster send. */
 253         lp->send_cmd = TX_AFTER_381;
 254         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 255                 lp->send_cmd = TX_NOW;
 256         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 257                 lp->send_cmd = TX_NOW;
 258
 259         if (net_debug && version_printed++ == 0)
 260                 printk(version);
 261
 262         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
 263                dev->name,
 264                lp->chip_type==CS8900?'0':'2',
 265                lp->chip_type==CS8920M?"M":"",
 266                lp->chip_revision,
 267                dev->base_addr);
 268
 269         /* Try to read the MAC address */
 270         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
 271                 printk("\nmac89x0: No EEPROM, giving up now.\n");
 272                 goto out1;
 273         } else {
 274                 for (i = 0; i < ETH_ALEN; i += 2) {
 275                         /* Big-endian (why??!) */
 276                         unsigned short s = readreg(dev, PP_IA + i);
 277                         dev->dev_addr[i] = s >> 8;
 278                         dev->dev_addr[i+1] = s & 0xff;
 279                 }
 280         }
 281
 282         dev->irq = SLOT2IRQ(slot);
 283
 284         /* print the IRQ and ethernet address. */
 285
 286         printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
 287
 288         dev->netdev_ops         = &mac89x0_netdev_ops;
 289
 290         err = register_netdev(dev);
 291         if (err)
 292                 goto out1;
 293         return NULL;
 294 out1:
 295         nubus_writew(0, dev->base_addr + ADD_PORT);
 296 out:
 297         free_netdev(dev);
 298         return ERR_PTR(err);
 299 }
 300
 301
 302 /* Open/initialize the board.  This is called (in the current kernel)
 303    sometime after booting when the 'ifconfig' program is run.
 304
 305    This routine should set everything up anew at each open, even
 306    registers that "should" only need to be set once at boot, so that
 307    there is non-reboot way to recover if something goes wrong.
 308    */
 309 static int
 310 net_open(struct net_device *dev)
 311 {
 312         struct net_local *lp = netdev_priv(dev);
 313         int i;
 314
 315         /* Disable the interrupt for now */
 316         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
 317
 318         /* Grab the interrupt */
 319         if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
 320                 return -EAGAIN;
 321
 322         /* Set up the IRQ - Apparently magic */
 323         if (lp->chip_type == CS8900)
 324                 writereg(dev, PP_CS8900_ISAINT, 0);
 325         else
 326                 writereg(dev, PP_CS8920_ISAINT, 0);
 327
 328         /* set the Ethernet address */
 329         for (i=0; i < ETH_ALEN/2; i++)
 330                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 331
 332         /* Turn on both receive and transmit operations */
 333         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
 334
 335         /* Receive only error free packets addressed to this card */
 336         lp->rx_mode = 0;
 337         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
 338
 339         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
 340
 341         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
 342
 343         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
 344                TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
 345
 346         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
 347                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
 348
 349         /* now that we've got our act together, enable everything */
 350         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
 351         netif_start_queue(dev);
 352         return 0;
 353 }
 354
 355 static int
 356 net_send_packet(struct sk_buff *skb, struct net_device *dev)
 357 {
 358         struct net_local *lp = netdev_priv(dev);
 359         unsigned long flags;
 360
 361         if (net_debug > 3)
 362                 printk("%s: sent %d byte packet of type %x\n",
 363                        dev->name, skb->len,
 364                        (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 365                        | skb->data[ETH_ALEN+ETH_ALEN+1]);
 366
 367         /* keep the upload from being interrupted, since we
 368            ask the chip to start transmitting before the
 369            whole packet has been completely uploaded. */
 370         local_irq_save(flags);
 371         netif_stop_queue(dev);
 372
 373         /* initiate a transmit sequence */
 374         writereg(dev, PP_TxCMD, lp->send_cmd);
 375         writereg(dev, PP_TxLength, skb->len);
 376
 377         /* Test to see if the chip has allocated memory for the packet */
 378         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
 379                 /* Gasp!  It hasn't.  But that shouldn't happen since
 380                    we're waiting for TxOk, so return 1 and requeue this packet. */
 381                 local_irq_restore(flags);
 382                 return NETDEV_TX_BUSY;
 383         }
 384
 385         /* Write the contents of the packet */
 386         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
 387                                   skb->len+1);
 388
 389         local_irq_restore(flags);
 390         dev_kfree_skb (skb);
 391
 392         return NETDEV_TX_OK;
 393 }
 394
 395 /* The typical workload of the driver:
 396    Handle the network interface interrupts. */
 397 static irqreturn_t net_interrupt(int irq, void *dev_id)
 398 {
 399         struct net_device *dev = dev_id;
 400         struct net_local *lp;
 401         int ioaddr, status;
 402
 403         if (dev == NULL) {
 404                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 405                 return IRQ_NONE;
 406         }
 407
 408         ioaddr = dev->base_addr;
 409         lp = netdev_priv(dev);
 410
 411         /* we MUST read all the events out of the ISQ, otherwise we'll never
 412            get interrupted again.  As a consequence, we can't have any limit
 413            on the number of times we loop in the interrupt handler.  The
 414            hardware guarantees that eventually we'll run out of events.  Of
 415            course, if you're on a slow machine, and packets are arriving
 416            faster than you can read them off, you're screwed.  Hasta la
 417            vista, baby!  */
 418         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
 419                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
 420                 switch(status & ISQ_EVENT_MASK) {
 421                 case ISQ_RECEIVER_EVENT:
 422                         /* Got a packet(s). */
 423                         net_rx(dev);
 424                         break;
 425                 case ISQ_TRANSMITTER_EVENT:
 426                         dev->stats.tx_packets++;
 427                         netif_wake_queue(dev);
 428                         if ((status & TX_OK) == 0)
 429                                 dev->stats.tx_errors++;
 430                         if (status & TX_LOST_CRS)
 431                                 dev->stats.tx_carrier_errors++;
 432                         if (status & TX_SQE_ERROR)
 433                                 dev->stats.tx_heartbeat_errors++;
 434                         if (status & TX_LATE_COL)
 435                                 dev->stats.tx_window_errors++;
 436                         if (status & TX_16_COL)
 437                                 dev->stats.tx_aborted_errors++;
 438                         break;
 439                 case ISQ_BUFFER_EVENT:
 440                         if (status & READY_FOR_TX) {
 441                                 /* we tried to transmit a packet earlier,
 442                                    but inexplicably ran out of buffers.
 443                                    That shouldn't happen since we only ever
 444                                    load one packet.  Shrug.  Do the right
 445                                    thing anyway. */
 446                                 netif_wake_queue(dev);
 447                         }
 448                         if (status & TX_UNDERRUN) {
 449                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
 450                                 lp->send_underrun++;
 451                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
 452                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
 453                         }
 454                         break;
 455                 case ISQ_RX_MISS_EVENT:
 456                         dev->stats.rx_missed_errors += (status >> 6);
 457                         break;
 458                 case ISQ_TX_COL_EVENT:
 459                         dev->stats.collisions += (status >> 6);
 460                         break;
 461                 }
 462         }
 463         return IRQ_HANDLED;
 464 }
 465
 466 /* We have a good packet(s), get it/them out of the buffers. */
 467 static void
 468 net_rx(struct net_device *dev)
 469 {
 470         struct sk_buff *skb;
 471         int status, length;
 472
 473         status = readreg(dev, PP_RxStatus);
 474         if ((status & RX_OK) == 0) {
 475                 dev->stats.rx_errors++;
 476                 if (status & RX_RUNT)
 477                                 dev->stats.rx_length_errors++;
 478                 if (status & RX_EXTRA_DATA)
 479                                 dev->stats.rx_length_errors++;
 480                 if ((status & RX_CRC_ERROR) &&
 481                     !(status & (RX_EXTRA_DATA|RX_RUNT)))
 482                         /* per str 172 */
 483                         dev->stats.rx_crc_errors++;
 484                 if (status & RX_DRIBBLE)
 485                                 dev->stats.rx_frame_errors++;
 486                 return;
 487         }
 488
 489         length = readreg(dev, PP_RxLength);
 490         /* Malloc up new buffer. */
 491         skb = alloc_skb(length, GFP_ATOMIC);
 492         if (skb == NULL) {
 493                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 494                 dev->stats.rx_dropped++;
 495                 return;
 496         }
 497         skb_put(skb, length);
 498
 499         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
 500                                 length);
 501
 502         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
 503                                  dev->name, length,
 504                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 505                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
 506
 507         skb->protocol=eth_type_trans(skb,dev);
 508         netif_rx(skb);
 509         dev->stats.rx_packets++;
 510         dev->stats.rx_bytes += length;
 511 }
 512
 513 /* The inverse routine to net_open(). */
 514 static int
 515 net_close(struct net_device *dev)
 516 {
 517
 518         writereg(dev, PP_RxCFG, 0);
 519         writereg(dev, PP_TxCFG, 0);
 520         writereg(dev, PP_BufCFG, 0);
 521         writereg(dev, PP_BusCTL, 0);
 522
 523         netif_stop_queue(dev);
 524
 525         free_irq(dev->irq, dev);
 526
 527         /* Update the statistics here. */
 528
 529         return 0;
 530
 531 }
 532
 533 /* Get the current statistics.  This may be called with the card open or
 534    closed. */
 535 static struct net_device_stats *
 536 net_get_stats(struct net_device *dev)
 537 {
 538         unsigned long flags;
 539
 540         local_irq_save(flags);
 541         /* Update the statistics from the device registers. */
 542         dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
 543         dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
 544         local_irq_restore(flags);
 545
 546         return &dev->stats;
 547 }
 548
 549 static void set_multicast_list(struct net_device *dev)
 550 {
 551         struct net_local *lp = netdev_priv(dev);
 552
 553         if(dev->flags&IFF_PROMISC)
 554         {
 555                 lp->rx_mode = RX_ALL_ACCEPT;
 556         } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
 557                 /* The multicast-accept list is initialized to accept-all, and we
 558                    rely on higher-level filtering for now. */
 559                 lp->rx_mode = RX_MULTCAST_ACCEPT;
 560         }
 561         else
 562                 lp->rx_mode = 0;
 563
 564         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
 565
 566         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
 567         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
 568              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
 569 }
 570
 571
 572 static int set_mac_address(struct net_device *dev, void *addr)
 573 {
 574         int i;
 575         printk("%s: Setting MAC address to ", dev->name);
 576         for (i = 0; i < 6; i++)
 577                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
 578         printk(".\n");
 579         /* set the Ethernet address */
 580         for (i=0; i < ETH_ALEN/2; i++)
 581                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 582
 583         return 0;
 584 }
 585
 586 #ifdef MODULE
 587
 588 static struct net_device *dev_cs89x0;
 589 static int debug;
 590
 591 module_param(debug, int, 0);
 592 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
 593 MODULE_LICENSE("GPL");
 594
 595 int __init
 596 init_module(void)
 597 {
 598         net_debug = debug;
 599         dev_cs89x0 = mac89x0_probe(-1);
 600         if (IS_ERR(dev_cs89x0)) {
 601                 printk(KERN_WARNING "mac89x0.c: No card found\n");
 602                 return PTR_ERR(dev_cs89x0);
 603         }
 604         return 0;
 605 }
 606
 607 void
 608 cleanup_module(void)
 609 {
 610         unregister_netdev(dev_cs89x0);
 611         nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
 612         free_netdev(dev_cs89x0);
 613 }
 614 #endif /* MODULE */