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         struct net_device_stats stats;
 114         int chip_type;          /* one of: CS8900, CS8920, CS8920M */
 115         char chip_revision;     /* revision letter of the chip ('A'...) */
 116         int send_cmd;           /* the propercommand used to send a packet. */
 117         int rx_mode;
 118         int curr_rx_cfg;
 119         int send_underrun;      /* keep track of how many underruns in a row we get */
 120         struct sk_buff *skb;
 121 };
 122
 123 /* Index to functions, as function prototypes. */
 124
 125 #if 0
 126 extern void reset_chip(struct net_device *dev);
 127 #endif
 128 static int net_open(struct net_device *dev);
 129 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
 130 static irqreturn_t net_interrupt(int irq, void *dev_id);
 131 static void set_multicast_list(struct net_device *dev);
 132 static void net_rx(struct net_device *dev);
 133 static int net_close(struct net_device *dev);
 134 static struct net_device_stats *net_get_stats(struct net_device *dev);
 135 static int set_mac_address(struct net_device *dev, void *addr);
 136
 137
 138 /* Example routines you must write ;->. */
 139 #define tx_done(dev) 1
 140
 141 /* For reading/writing registers ISA-style */
 142 static inline int
 143 readreg_io(struct net_device *dev, int portno)
 144 {
 145         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 146         return swab16(nubus_readw(dev->base_addr + DATA_PORT));
 147 }
 148
 149 static inline void
 150 writereg_io(struct net_device *dev, int portno, int value)
 151 {
 152         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 153         nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
 154 }
 155
 156 /* These are for reading/writing registers in shared memory */
 157 static inline int
 158 readreg(struct net_device *dev, int portno)
 159 {
 160         return swab16(nubus_readw(dev->mem_start + portno));
 161 }
 162
 163 static inline void
 164 writereg(struct net_device *dev, int portno, int value)
 165 {
 166         nubus_writew(swab16(value), dev->mem_start + portno);
 167 }
 168
 169 static const struct net_device_ops mac89x0_netdev_ops = {
 170         .ndo_open               = net_open,
 171         .ndo_stop               = net_close,
 172         .ndo_start_xmit         = net_send_packet,
 173         .ndo_get_stats          = net_get_stats,
 174         .ndo_set_multicast_list = set_multicast_list,
 175         .ndo_set_mac_address    = set_mac_address,
 176         .ndo_validate_addr      = eth_validate_addr,
 177         .ndo_change_mtu         = eth_change_mtu,
 178 };
 179
 180 /* Probe for the CS8900 card in slot E.  We won't bother looking
 181    anywhere else until we have a really good reason to do so. */
 182 struct net_device * __init mac89x0_probe(int unit)
 183 {
 184         struct net_device *dev;
 185         static int once_is_enough;
 186         struct net_local *lp;
 187         static unsigned version_printed;
 188         int i, slot;
 189         unsigned rev_type = 0;
 190         unsigned long ioaddr;
 191         unsigned short sig;
 192         int err = -ENODEV;
 193
 194         if (!MACH_IS_MAC)
 195                 return ERR_PTR(-ENODEV);
 196
 197         dev = alloc_etherdev(sizeof(struct net_local));
 198         if (!dev)
 199                 return ERR_PTR(-ENOMEM);
 200
 201         if (unit >= 0) {
 202                 sprintf(dev->name, "eth%d", unit);
 203                 netdev_boot_setup_check(dev);
 204         }
 205
 206         if (once_is_enough)
 207                 goto out;
 208         once_is_enough = 1;
 209
 210         /* We might have to parameterize this later */
 211         slot = 0xE;
 212         /* Get out now if there's a real NuBus card in slot E */
 213         if (nubus_find_slot(slot, NULL) != NULL)
 214                 goto out;
 215
 216         /* The pseudo-ISA bits always live at offset 0x300 (gee,
 217            wonder why...) */
 218         ioaddr = (unsigned long)
 219                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
 220         {
 221                 unsigned long flags;
 222                 int card_present;
 223
 224                 local_irq_save(flags);
 225                 card_present = (hwreg_present((void*) ioaddr+4) &&
 226                                 hwreg_present((void*) ioaddr + DATA_PORT));
 227                 local_irq_restore(flags);
 228
 229                 if (!card_present)
 230                         goto out;
 231         }
 232
 233         nubus_writew(0, ioaddr + ADD_PORT);
 234         sig = nubus_readw(ioaddr + DATA_PORT);
 235         if (sig != swab16(CHIP_EISA_ID_SIG))
 236                 goto out;
 237
 238         /* Initialize the net_device structure. */
 239         lp = netdev_priv(dev);
 240
 241         /* Fill in the 'dev' fields. */
 242         dev->base_addr = ioaddr;
 243         dev->mem_start = (unsigned long)
 244                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
 245         dev->mem_end = dev->mem_start + 0x1000;
 246
 247         /* Turn on shared memory */
 248         writereg_io(dev, PP_BusCTL, MEMORY_ON);
 249
 250         /* get the chip type */
 251         rev_type = readreg(dev, PRODUCT_ID_ADD);
 252         lp->chip_type = rev_type &~ REVISON_BITS;
 253         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 254
 255         /* Check the chip type and revision in order to set the correct send command
 256         CS8920 revision C and CS8900 revision F can use the faster send. */
 257         lp->send_cmd = TX_AFTER_381;
 258         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 259                 lp->send_cmd = TX_NOW;
 260         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 261                 lp->send_cmd = TX_NOW;
 262
 263         if (net_debug && version_printed++ == 0)
 264                 printk(version);
 265
 266         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
 267                dev->name,
 268                lp->chip_type==CS8900?'0':'2',
 269                lp->chip_type==CS8920M?"M":"",
 270                lp->chip_revision,
 271                dev->base_addr);
 272
 273         /* Try to read the MAC address */
 274         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
 275                 printk("\nmac89x0: No EEPROM, giving up now.\n");
 276                 goto out1;
 277         } else {
 278                 for (i = 0; i < ETH_ALEN; i += 2) {
 279                         /* Big-endian (why??!) */
 280                         unsigned short s = readreg(dev, PP_IA + i);
 281                         dev->dev_addr[i] = s >> 8;
 282                         dev->dev_addr[i+1] = s & 0xff;
 283                 }
 284         }
 285
 286         dev->irq = SLOT2IRQ(slot);
 287
 288         /* print the IRQ and ethernet address. */
 289
 290         printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
 291
 292         dev->netdev_ops         = &mac89x0_netdev_ops;
 293
 294         err = register_netdev(dev);
 295         if (err)
 296                 goto out1;
 297         return NULL;
 298 out1:
 299         nubus_writew(0, dev->base_addr + ADD_PORT);
 300 out:
 301         free_netdev(dev);
 302         return ERR_PTR(err);
 303 }
 304
 305 #if 0
 306 /* This is useful for something, but I don't know what yet. */
 307 void __init reset_chip(struct net_device *dev)
 308 {
 309         int reset_start_time;
 310
 311         writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
 312
 313         /* wait 30 ms */
 314         msleep_interruptible(30);
 315
 316         /* Wait until the chip is reset */
 317         reset_start_time = jiffies;
 318         while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
 319                 ;
 320 }
 321 #endif
 322
 323 /* Open/initialize the board.  This is called (in the current kernel)
 324    sometime after booting when the 'ifconfig' program is run.
 325
 326    This routine should set everything up anew at each open, even
 327    registers that "should" only need to be set once at boot, so that
 328    there is non-reboot way to recover if something goes wrong.
 329    */
 330 static int
 331 net_open(struct net_device *dev)
 332 {
 333         struct net_local *lp = netdev_priv(dev);
 334         int i;
 335
 336         /* Disable the interrupt for now */
 337         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
 338
 339         /* Grab the interrupt */
 340         if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
 341                 return -EAGAIN;
 342
 343         /* Set up the IRQ - Apparently magic */
 344         if (lp->chip_type == CS8900)
 345                 writereg(dev, PP_CS8900_ISAINT, 0);
 346         else
 347                 writereg(dev, PP_CS8920_ISAINT, 0);
 348
 349         /* set the Ethernet address */
 350         for (i=0; i < ETH_ALEN/2; i++)
 351                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 352
 353         /* Turn on both receive and transmit operations */
 354         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
 355
 356         /* Receive only error free packets addressed to this card */
 357         lp->rx_mode = 0;
 358         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
 359
 360         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
 361
 362         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
 363
 364         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
 365                TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
 366
 367         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
 368                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
 369
 370         /* now that we've got our act together, enable everything */
 371         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
 372         netif_start_queue(dev);
 373         return 0;
 374 }
 375
 376 static int
 377 net_send_packet(struct sk_buff *skb, struct net_device *dev)
 378 {
 379         struct net_local *lp = netdev_priv(dev);
 380         unsigned long flags;
 381
 382         if (net_debug > 3)
 383                 printk("%s: sent %d byte packet of type %x\n",
 384                        dev->name, skb->len,
 385                        (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 386                        | skb->data[ETH_ALEN+ETH_ALEN+1]);
 387
 388         /* keep the upload from being interrupted, since we
 389            ask the chip to start transmitting before the
 390            whole packet has been completely uploaded. */
 391         local_irq_save(flags);
 392         netif_stop_queue(dev);
 393
 394         /* initiate a transmit sequence */
 395         writereg(dev, PP_TxCMD, lp->send_cmd);
 396         writereg(dev, PP_TxLength, skb->len);
 397
 398         /* Test to see if the chip has allocated memory for the packet */
 399         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
 400                 /* Gasp!  It hasn't.  But that shouldn't happen since
 401                    we're waiting for TxOk, so return 1 and requeue this packet. */
 402                 local_irq_restore(flags);
 403                 return NETDEV_TX_BUSY;
 404         }
 405
 406         /* Write the contents of the packet */
 407         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
 408                                   skb->len+1);
 409
 410         local_irq_restore(flags);
 411         dev->trans_start = jiffies;
 412         dev_kfree_skb (skb);
 413
 414         return NETDEV_TX_OK;
 415 }
 416
 417 /* The typical workload of the driver:
 418    Handle the network interface interrupts. */
 419 static irqreturn_t net_interrupt(int irq, void *dev_id)
 420 {
 421         struct net_device *dev = dev_id;
 422         struct net_local *lp;
 423         int ioaddr, status;
 424
 425         if (dev == NULL) {
 426                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 427                 return IRQ_NONE;
 428         }
 429
 430         ioaddr = dev->base_addr;
 431         lp = netdev_priv(dev);
 432
 433         /* we MUST read all the events out of the ISQ, otherwise we'll never
 434            get interrupted again.  As a consequence, we can't have any limit
 435            on the number of times we loop in the interrupt handler.  The
 436            hardware guarantees that eventually we'll run out of events.  Of
 437            course, if you're on a slow machine, and packets are arriving
 438            faster than you can read them off, you're screwed.  Hasta la
 439            vista, baby!  */
 440         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
 441                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
 442                 switch(status & ISQ_EVENT_MASK) {
 443                 case ISQ_RECEIVER_EVENT:
 444                         /* Got a packet(s). */
 445                         net_rx(dev);
 446                         break;
 447                 case ISQ_TRANSMITTER_EVENT:
 448                         lp->stats.tx_packets++;
 449                         netif_wake_queue(dev);
 450                         if ((status & TX_OK) == 0) lp->stats.tx_errors++;
 451                         if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
 452                         if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
 453                         if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
 454                         if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
 455                         break;
 456                 case ISQ_BUFFER_EVENT:
 457                         if (status & READY_FOR_TX) {
 458                                 /* we tried to transmit a packet earlier,
 459                                    but inexplicably ran out of buffers.
 460                                    That shouldn't happen since we only ever
 461                                    load one packet.  Shrug.  Do the right
 462                                    thing anyway. */
 463                                 netif_wake_queue(dev);
 464                         }
 465                         if (status & TX_UNDERRUN) {
 466                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
 467                                 lp->send_underrun++;
 468                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
 469                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
 470                         }
 471                         break;
 472                 case ISQ_RX_MISS_EVENT:
 473                         lp->stats.rx_missed_errors += (status >>6);
 474                         break;
 475                 case ISQ_TX_COL_EVENT:
 476                         lp->stats.collisions += (status >>6);
 477                         break;
 478                 }
 479         }
 480         return IRQ_HANDLED;
 481 }
 482
 483 /* We have a good packet(s), get it/them out of the buffers. */
 484 static void
 485 net_rx(struct net_device *dev)
 486 {
 487         struct net_local *lp = netdev_priv(dev);
 488         struct sk_buff *skb;
 489         int status, length;
 490
 491         status = readreg(dev, PP_RxStatus);
 492         if ((status & RX_OK) == 0) {
 493                 lp->stats.rx_errors++;
 494                 if (status & RX_RUNT) lp->stats.rx_length_errors++;
 495                 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
 496                 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
 497                         /* per str 172 */
 498                         lp->stats.rx_crc_errors++;
 499                 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
 500                 return;
 501         }
 502
 503         length = readreg(dev, PP_RxLength);
 504         /* Malloc up new buffer. */
 505         skb = alloc_skb(length, GFP_ATOMIC);
 506         if (skb == NULL) {
 507                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 508                 lp->stats.rx_dropped++;
 509                 return;
 510         }
 511         skb_put(skb, length);
 512
 513         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
 514                                 length);
 515
 516         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
 517                                  dev->name, length,
 518                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 519                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
 520
 521         skb->protocol=eth_type_trans(skb,dev);
 522         netif_rx(skb);
 523         lp->stats.rx_packets++;
 524         lp->stats.rx_bytes += length;
 525 }
 526
 527 /* The inverse routine to net_open(). */
 528 static int
 529 net_close(struct net_device *dev)
 530 {
 531
 532         writereg(dev, PP_RxCFG, 0);
 533         writereg(dev, PP_TxCFG, 0);
 534         writereg(dev, PP_BufCFG, 0);
 535         writereg(dev, PP_BusCTL, 0);
 536
 537         netif_stop_queue(dev);
 538
 539         free_irq(dev->irq, dev);
 540
 541         /* Update the statistics here. */
 542
 543         return 0;
 544
 545 }
 546
 547 /* Get the current statistics.  This may be called with the card open or
 548    closed. */
 549 static struct net_device_stats *
 550 net_get_stats(struct net_device *dev)
 551 {
 552         struct net_local *lp = netdev_priv(dev);
 553         unsigned long flags;
 554
 555         local_irq_save(flags);
 556         /* Update the statistics from the device registers. */
 557         lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
 558         lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
 559         local_irq_restore(flags);
 560
 561         return &lp->stats;
 562 }
 563
 564 static void set_multicast_list(struct net_device *dev)
 565 {
 566         struct net_local *lp = netdev_priv(dev);
 567
 568         if(dev->flags&IFF_PROMISC)
 569         {
 570                 lp->rx_mode = RX_ALL_ACCEPT;
 571         } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
 572                 /* The multicast-accept list is initialized to accept-all, and we
 573                    rely on higher-level filtering for now. */
 574                 lp->rx_mode = RX_MULTCAST_ACCEPT;
 575         }
 576         else
 577                 lp->rx_mode = 0;
 578
 579         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
 580
 581         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
 582         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
 583              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
 584 }
 585
 586
 587 static int set_mac_address(struct net_device *dev, void *addr)
 588 {
 589         int i;
 590         printk("%s: Setting MAC address to ", dev->name);
 591         for (i = 0; i < 6; i++)
 592                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
 593         printk(".\n");
 594         /* set the Ethernet address */
 595         for (i=0; i < ETH_ALEN/2; i++)
 596                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 597
 598         return 0;
 599 }
 600
 601 #ifdef MODULE
 602
 603 static struct net_device *dev_cs89x0;
 604 static int debug;
 605
 606 module_param(debug, int, 0);
 607 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
 608 MODULE_LICENSE("GPL");
 609
 610 int __init
 611 init_module(void)
 612 {
 613         net_debug = debug;
 614         dev_cs89x0 = mac89x0_probe(-1);
 615         if (IS_ERR(dev_cs89x0)) {
 616                 printk(KERN_WARNING "mac89x0.c: No card found\n");
 617                 return PTR_ERR(dev_cs89x0);
 618         }
 619         return 0;
 620 }
 621
 622 void
 623 cleanup_module(void)
 624 {
 625         unregister_netdev(dev_cs89x0);
 626         nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
 627         free_netdev(dev_cs89x0);
 628 }
 629 #endif /* MODULE */