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 #define PRINTK(x) printk x
  77
  78 /*
  79   Sources:
  80
  81         Crynwr packet driver epktisa.
  82
  83         Crystal Semiconductor data sheets.
  84
  85 */
  86
  87 #include <linux/kernel.h>
  88 #include <linux/types.h>
  89 #include <linux/fcntl.h>
  90 #include <linux/interrupt.h>
  91 #include <linux/ioport.h>
  92 #include <linux/in.h>
  93 #include <linux/slab.h>
  94 #include <linux/string.h>
  95 #include <linux/nubus.h>
  96 #include <linux/errno.h>
  97 #include <linux/init.h>
  98 #include <linux/netdevice.h>
  99 #include <linux/etherdevice.h>
 100 #include <linux/skbuff.h>
 101 #include <linux/delay.h>
 102 #include <linux/bitops.h>
 103
 104 #include <asm/system.h>
 105 #include <asm/io.h>
 106 #include <asm/hwtest.h>
 107 #include <asm/macints.h>
 108
 109 #include "cs89x0.h"
 110
 111 static unsigned int net_debug = NET_DEBUG;
 112
 113 /* Information that need to be kept for each board. */
 114 struct net_local {
 115         struct net_device_stats stats;
 116         int chip_type;          /* one of: CS8900, CS8920, CS8920M */
 117         char chip_revision;     /* revision letter of the chip ('A'...) */
 118         int send_cmd;           /* the propercommand used to send a packet. */
 119         int rx_mode;
 120         int curr_rx_cfg;
 121         int send_underrun;      /* keep track of how many underruns in a row we get */
 122         struct sk_buff *skb;
 123 };
 124
 125 /* Index to functions, as function prototypes. */
 126
 127 #if 0
 128 extern void reset_chip(struct net_device *dev);
 129 #endif
 130 static int net_open(struct net_device *dev);
 131 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
 132 static irqreturn_t net_interrupt(int irq, void *dev_id);
 133 static void set_multicast_list(struct net_device *dev);
 134 static void net_rx(struct net_device *dev);
 135 static int net_close(struct net_device *dev);
 136 static struct net_device_stats *net_get_stats(struct net_device *dev);
 137 static int set_mac_address(struct net_device *dev, void *addr);
 138
 139
 140 /* Example routines you must write ;->. */
 141 #define tx_done(dev) 1
 142
 143 /* For reading/writing registers ISA-style */
 144 static inline int
 145 readreg_io(struct net_device *dev, int portno)
 146 {
 147         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 148         return swab16(nubus_readw(dev->base_addr + DATA_PORT));
 149 }
 150
 151 static inline void
 152 writereg_io(struct net_device *dev, int portno, int value)
 153 {
 154         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 155         nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
 156 }
 157
 158 /* These are for reading/writing registers in shared memory */
 159 static inline int
 160 readreg(struct net_device *dev, int portno)
 161 {
 162         return swab16(nubus_readw(dev->mem_start + portno));
 163 }
 164
 165 static inline void
 166 writereg(struct net_device *dev, int portno, int value)
 167 {
 168         nubus_writew(swab16(value), dev->mem_start + portno);
 169 }
 170
 171 static const struct net_device_ops mac89x0_netdev_ops = {
 172         .ndo_open               = net_open,
 173         .ndo_stop               = net_close,
 174         .ndo_start_xmit         = net_send_packet,
 175         .ndo_get_stats          = net_get_stats,
 176         .ndo_set_multicast_list = set_multicast_list,
 177         .ndo_set_mac_address    = set_mac_address,
 178         .ndo_validate_addr      = eth_validate_addr,
 179         .ndo_change_mtu         = eth_change_mtu,
 180 };
 181
 182 /* Probe for the CS8900 card in slot E.  We won't bother looking
 183    anywhere else until we have a really good reason to do so. */
 184 struct net_device * __init mac89x0_probe(int unit)
 185 {
 186         struct net_device *dev;
 187         static int once_is_enough;
 188         struct net_local *lp;
 189         static unsigned version_printed;
 190         int i, slot;
 191         unsigned rev_type = 0;
 192         unsigned long ioaddr;
 193         unsigned short sig;
 194         int err = -ENODEV;
 195
 196         if (!MACH_IS_MAC)
 197                 return ERR_PTR(-ENODEV);
 198
 199         dev = alloc_etherdev(sizeof(struct net_local));
 200         if (!dev)
 201                 return ERR_PTR(-ENOMEM);
 202
 203         if (unit >= 0) {
 204                 sprintf(dev->name, "eth%d", unit);
 205                 netdev_boot_setup_check(dev);
 206         }
 207
 208         if (once_is_enough)
 209                 goto out;
 210         once_is_enough = 1;
 211
 212         /* We might have to parameterize this later */
 213         slot = 0xE;
 214         /* Get out now if there's a real NuBus card in slot E */
 215         if (nubus_find_slot(slot, NULL) != NULL)
 216                 goto out;
 217
 218         /* The pseudo-ISA bits always live at offset 0x300 (gee,
 219            wonder why...) */
 220         ioaddr = (unsigned long)
 221                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
 222         {
 223                 unsigned long flags;
 224                 int card_present;
 225
 226                 local_irq_save(flags);
 227                 card_present = hwreg_present((void*) ioaddr+4)
 228                   && hwreg_present((void*) ioaddr + DATA_PORT);
 229                 local_irq_restore(flags);
 230
 231                 if (!card_present)
 232                         goto out;
 233         }
 234
 235         nubus_writew(0, ioaddr + ADD_PORT);
 236         sig = nubus_readw(ioaddr + DATA_PORT);
 237         if (sig != swab16(CHIP_EISA_ID_SIG))
 238                 goto out;
 239
 240         /* Initialize the net_device structure. */
 241         lp = netdev_priv(dev);
 242
 243         /* Fill in the 'dev' fields. */
 244         dev->base_addr = ioaddr;
 245         dev->mem_start = (unsigned long)
 246                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
 247         dev->mem_end = dev->mem_start + 0x1000;
 248
 249         /* Turn on shared memory */
 250         writereg_io(dev, PP_BusCTL, MEMORY_ON);
 251
 252         /* get the chip type */
 253         rev_type = readreg(dev, PRODUCT_ID_ADD);
 254         lp->chip_type = rev_type &~ REVISON_BITS;
 255         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 256
 257         /* Check the chip type and revision in order to set the correct send command
 258         CS8920 revision C and CS8900 revision F can use the faster send. */
 259         lp->send_cmd = TX_AFTER_381;
 260         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 261                 lp->send_cmd = TX_NOW;
 262         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 263                 lp->send_cmd = TX_NOW;
 264
 265         if (net_debug && version_printed++ == 0)
 266                 printk(version);
 267
 268         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
 269                dev->name,
 270                lp->chip_type==CS8900?'0':'2',
 271                lp->chip_type==CS8920M?"M":"",
 272                lp->chip_revision,
 273                dev->base_addr);
 274
 275         /* Try to read the MAC address */
 276         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
 277                 printk("\nmac89x0: No EEPROM, giving up now.\n");
 278                 goto out1;
 279         } else {
 280                 for (i = 0; i < ETH_ALEN; i += 2) {
 281                         /* Big-endian (why??!) */
 282                         unsigned short s = readreg(dev, PP_IA + i);
 283                         dev->dev_addr[i] = s >> 8;
 284                         dev->dev_addr[i+1] = s & 0xff;
 285                 }
 286         }
 287
 288         dev->irq = SLOT2IRQ(slot);
 289
 290         /* print the IRQ and ethernet address. */
 291
 292         printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
 293
 294         dev->netdev_ops         = &mac89x0_netdev_ops;
 295
 296         err = register_netdev(dev);
 297         if (err)
 298                 goto out1;
 299         return NULL;
 300 out1:
 301         nubus_writew(0, dev->base_addr + ADD_PORT);
 302 out:
 303         free_netdev(dev);
 304         return ERR_PTR(err);
 305 }
 306
 307 #if 0
 308 /* This is useful for something, but I don't know what yet. */
 309 void __init reset_chip(struct net_device *dev)
 310 {
 311         int reset_start_time;
 312
 313         writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
 314
 315         /* wait 30 ms */
 316         msleep_interruptible(30);
 317
 318         /* Wait until the chip is reset */
 319         reset_start_time = jiffies;
 320         while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
 321                 ;
 322 }
 323 #endif
 324
 325 /* Open/initialize the board.  This is called (in the current kernel)
 326    sometime after booting when the 'ifconfig' program is run.
 327
 328    This routine should set everything up anew at each open, even
 329    registers that "should" only need to be set once at boot, so that
 330    there is non-reboot way to recover if something goes wrong.
 331    */
 332 static int
 333 net_open(struct net_device *dev)
 334 {
 335         struct net_local *lp = netdev_priv(dev);
 336         int i;
 337
 338         /* Disable the interrupt for now */
 339         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
 340
 341         /* Grab the interrupt */
 342         if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
 343                 return -EAGAIN;
 344
 345         /* Set up the IRQ - Apparently magic */
 346         if (lp->chip_type == CS8900)
 347                 writereg(dev, PP_CS8900_ISAINT, 0);
 348         else
 349                 writereg(dev, PP_CS8920_ISAINT, 0);
 350
 351         /* set the Ethernet address */
 352         for (i=0; i < ETH_ALEN/2; i++)
 353                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 354
 355         /* Turn on both receive and transmit operations */
 356         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
 357
 358         /* Receive only error free packets addressed to this card */
 359         lp->rx_mode = 0;
 360         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
 361
 362         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
 363
 364         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
 365
 366         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
 367                TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
 368
 369         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
 370                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
 371
 372         /* now that we've got our act together, enable everything */
 373         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
 374         netif_start_queue(dev);
 375         return 0;
 376 }
 377
 378 static int
 379 net_send_packet(struct sk_buff *skb, struct net_device *dev)
 380 {
 381         struct net_local *lp = netdev_priv(dev);
 382         unsigned long flags;
 383
 384         if (net_debug > 3)
 385                 printk("%s: sent %d byte packet of type %x\n",
 386                        dev->name, skb->len,
 387                        (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 388                        | skb->data[ETH_ALEN+ETH_ALEN+1]);
 389
 390         /* keep the upload from being interrupted, since we
 391            ask the chip to start transmitting before the
 392            whole packet has been completely uploaded. */
 393         local_irq_save(flags);
 394         netif_stop_queue(dev);
 395
 396         /* initiate a transmit sequence */
 397         writereg(dev, PP_TxCMD, lp->send_cmd);
 398         writereg(dev, PP_TxLength, skb->len);
 399
 400         /* Test to see if the chip has allocated memory for the packet */
 401         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
 402                 /* Gasp!  It hasn't.  But that shouldn't happen since
 403                    we're waiting for TxOk, so return 1 and requeue this packet. */
 404                 local_irq_restore(flags);
 405                 return 1;
 406         }
 407
 408         /* Write the contents of the packet */
 409         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
 410                                   skb->len+1);
 411
 412         local_irq_restore(flags);
 413         dev->trans_start = jiffies;
 414         dev_kfree_skb (skb);
 415
 416         return 0;
 417 }
 418
 419 /* The typical workload of the driver:
 420    Handle the network interface interrupts. */
 421 static irqreturn_t net_interrupt(int irq, void *dev_id)
 422 {
 423         struct net_device *dev = dev_id;
 424         struct net_local *lp;
 425         int ioaddr, status;
 426
 427         if (dev == NULL) {
 428                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 429                 return IRQ_NONE;
 430         }
 431
 432         ioaddr = dev->base_addr;
 433         lp = netdev_priv(dev);
 434
 435         /* we MUST read all the events out of the ISQ, otherwise we'll never
 436            get interrupted again.  As a consequence, we can't have any limit
 437            on the number of times we loop in the interrupt handler.  The
 438            hardware guarantees that eventually we'll run out of events.  Of
 439            course, if you're on a slow machine, and packets are arriving
 440            faster than you can read them off, you're screwed.  Hasta la
 441            vista, baby!  */
 442         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
 443                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
 444                 switch(status & ISQ_EVENT_MASK) {
 445                 case ISQ_RECEIVER_EVENT:
 446                         /* Got a packet(s). */
 447                         net_rx(dev);
 448                         break;
 449                 case ISQ_TRANSMITTER_EVENT:
 450                         lp->stats.tx_packets++;
 451                         netif_wake_queue(dev);
 452                         if ((status & TX_OK) == 0) lp->stats.tx_errors++;
 453                         if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
 454                         if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
 455                         if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
 456                         if (status & TX_16_COL) lp->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                         lp->stats.rx_missed_errors += (status >>6);
 476                         break;
 477                 case ISQ_TX_COL_EVENT:
 478                         lp->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 net_local *lp = netdev_priv(dev);
 490         struct sk_buff *skb;
 491         int status, length;
 492
 493         status = readreg(dev, PP_RxStatus);
 494         if ((status & RX_OK) == 0) {
 495                 lp->stats.rx_errors++;
 496                 if (status & RX_RUNT) lp->stats.rx_length_errors++;
 497                 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
 498                 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
 499                         /* per str 172 */
 500                         lp->stats.rx_crc_errors++;
 501                 if (status & RX_DRIBBLE) lp->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                 lp->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         lp->stats.rx_packets++;
 526         lp->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         struct net_local *lp = netdev_priv(dev);
 555         unsigned long flags;
 556
 557         local_irq_save(flags);
 558         /* Update the statistics from the device registers. */
 559         lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
 560         lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
 561         local_irq_restore(flags);
 562
 563         return &lp->stats;
 564 }
 565
 566 static void set_multicast_list(struct net_device *dev)
 567 {
 568         struct net_local *lp = netdev_priv(dev);
 569
 570         if(dev->flags&IFF_PROMISC)
 571         {
 572                 lp->rx_mode = RX_ALL_ACCEPT;
 573         }
 574         else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
 575         {
 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         int i;
 594         printk("%s: Setting MAC address to ", dev->name);
 595         for (i = 0; i < 6; i++)
 596                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
 597         printk(".\n");
 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 */