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