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