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