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
 103 #include <asm/system.h>
 104 #include <asm/bitops.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 /* Probe for the CS8900 card in slot E.  We won't bother looking
 172    anywhere else until we have a really good reason to do so. */
 173 struct net_device * __init mac89x0_probe(int unit)
 174 {
 175         struct net_device *dev;
 176         static int once_is_enough;
 177         struct net_local *lp;
 178         static unsigned version_printed;
 179         int i, slot;
 180         unsigned rev_type = 0;
 181         unsigned long ioaddr;
 182         unsigned short sig;
 183         int err = -ENODEV;
 184         DECLARE_MAC_BUF(mac);
 185
 186         dev = alloc_etherdev(sizeof(struct net_local));
 187         if (!dev)
 188                 return ERR_PTR(-ENOMEM);
 189
 190         if (unit >= 0) {
 191                 sprintf(dev->name, "eth%d", unit);
 192                 netdev_boot_setup_check(dev);
 193         }
 194
 195         if (once_is_enough)
 196                 goto out;
 197         once_is_enough = 1;
 198
 199         /* We might have to parameterize this later */
 200         slot = 0xE;
 201         /* Get out now if there's a real NuBus card in slot E */
 202         if (nubus_find_slot(slot, NULL) != NULL)
 203                 goto out;
 204
 205         /* The pseudo-ISA bits always live at offset 0x300 (gee,
 206            wonder why...) */
 207         ioaddr = (unsigned long)
 208                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
 209         {
 210                 unsigned long flags;
 211                 int card_present;
 212
 213                 local_irq_save(flags);
 214                 card_present = hwreg_present((void*) ioaddr+4)
 215                   && hwreg_present((void*) ioaddr + DATA_PORT);
 216                 local_irq_restore(flags);
 217
 218                 if (!card_present)
 219                         goto out;
 220         }
 221
 222         nubus_writew(0, ioaddr + ADD_PORT);
 223         sig = nubus_readw(ioaddr + DATA_PORT);
 224         if (sig != swab16(CHIP_EISA_ID_SIG))
 225                 goto out;
 226
 227         /* Initialize the net_device structure. */
 228         lp = netdev_priv(dev);
 229
 230         /* Fill in the 'dev' fields. */
 231         dev->base_addr = ioaddr;
 232         dev->mem_start = (unsigned long)
 233                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
 234         dev->mem_end = dev->mem_start + 0x1000;
 235
 236         /* Turn on shared memory */
 237         writereg_io(dev, PP_BusCTL, MEMORY_ON);
 238
 239         /* get the chip type */
 240         rev_type = readreg(dev, PRODUCT_ID_ADD);
 241         lp->chip_type = rev_type &~ REVISON_BITS;
 242         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 243
 244         /* Check the chip type and revision in order to set the correct send command
 245         CS8920 revision C and CS8900 revision F can use the faster send. */
 246         lp->send_cmd = TX_AFTER_381;
 247         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 248                 lp->send_cmd = TX_NOW;
 249         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 250                 lp->send_cmd = TX_NOW;
 251
 252         if (net_debug && version_printed++ == 0)
 253                 printk(version);
 254
 255         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
 256                dev->name,
 257                lp->chip_type==CS8900?'0':'2',
 258                lp->chip_type==CS8920M?"M":"",
 259                lp->chip_revision,
 260                dev->base_addr);
 261
 262         /* Try to read the MAC address */
 263         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
 264                 printk("\nmac89x0: No EEPROM, giving up now.\n");
 265                 goto out1;
 266         } else {
 267                 for (i = 0; i < ETH_ALEN; i += 2) {
 268                         /* Big-endian (why??!) */
 269                         unsigned short s = readreg(dev, PP_IA + i);
 270                         dev->dev_addr[i] = s >> 8;
 271                         dev->dev_addr[i+1] = s & 0xff;
 272                 }
 273         }
 274
 275         dev->irq = SLOT2IRQ(slot);
 276
 277         /* print the IRQ and ethernet address. */
 278
 279         printk(" IRQ %d ADDR %s\n",
 280                dev->irq, print_mac(mac, dev->dev_addr));
 281
 282         dev->open               = net_open;
 283         dev->stop               = net_close;
 284         dev->hard_start_xmit = net_send_packet;
 285         dev->get_stats  = net_get_stats;
 286         dev->set_multicast_list = &set_multicast_list;
 287         dev->set_mac_address = &set_mac_address;
 288
 289         err = register_netdev(dev);
 290         if (err)
 291                 goto out1;
 292         return 0;
 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 1;
 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->trans_start = jiffies;
 407         dev_kfree_skb (skb);
 408
 409         return 0;
 410 }
 411
 412 /* The typical workload of the driver:
 413    Handle the network interface interrupts. */
 414 static irqreturn_t net_interrupt(int irq, void *dev_id)
 415 {
 416         struct net_device *dev = dev_id;
 417         struct net_local *lp;
 418         int ioaddr, status;
 419
 420         if (dev == NULL) {
 421                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 422                 return IRQ_NONE;
 423         }
 424
 425         ioaddr = dev->base_addr;
 426         lp = netdev_priv(dev);
 427
 428         /* we MUST read all the events out of the ISQ, otherwise we'll never
 429            get interrupted again.  As a consequence, we can't have any limit
 430            on the number of times we loop in the interrupt handler.  The
 431            hardware guarantees that eventually we'll run out of events.  Of
 432            course, if you're on a slow machine, and packets are arriving
 433            faster than you can read them off, you're screwed.  Hasta la
 434            vista, baby!  */
 435         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
 436                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
 437                 switch(status & ISQ_EVENT_MASK) {
 438                 case ISQ_RECEIVER_EVENT:
 439                         /* Got a packet(s). */
 440                         net_rx(dev);
 441                         break;
 442                 case ISQ_TRANSMITTER_EVENT:
 443                         lp->stats.tx_packets++;
 444                         netif_wake_queue(dev);
 445                         if ((status & TX_OK) == 0) lp->stats.tx_errors++;
 446                         if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
 447                         if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
 448                         if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
 449                         if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
 450                         break;
 451                 case ISQ_BUFFER_EVENT:
 452                         if (status & READY_FOR_TX) {
 453                                 /* we tried to transmit a packet earlier,
 454                                    but inexplicably ran out of buffers.
 455                                    That shouldn't happen since we only ever
 456                                    load one packet.  Shrug.  Do the right
 457                                    thing anyway. */
 458                                 netif_wake_queue(dev);
 459                         }
 460                         if (status & TX_UNDERRUN) {
 461                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
 462                                 lp->send_underrun++;
 463                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
 464                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
 465                         }
 466                         break;
 467                 case ISQ_RX_MISS_EVENT:
 468                         lp->stats.rx_missed_errors += (status >>6);
 469                         break;
 470                 case ISQ_TX_COL_EVENT:
 471                         lp->stats.collisions += (status >>6);
 472                         break;
 473                 }
 474         }
 475         return IRQ_HANDLED;
 476 }
 477
 478 /* We have a good packet(s), get it/them out of the buffers. */
 479 static void
 480 net_rx(struct net_device *dev)
 481 {
 482         struct net_local *lp = netdev_priv(dev);
 483         struct sk_buff *skb;
 484         int status, length;
 485
 486         status = readreg(dev, PP_RxStatus);
 487         if ((status & RX_OK) == 0) {
 488                 lp->stats.rx_errors++;
 489                 if (status & RX_RUNT) lp->stats.rx_length_errors++;
 490                 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
 491                 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
 492                         /* per str 172 */
 493                         lp->stats.rx_crc_errors++;
 494                 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
 495                 return;
 496         }
 497
 498         length = readreg(dev, PP_RxLength);
 499         /* Malloc up new buffer. */
 500         skb = alloc_skb(length, GFP_ATOMIC);
 501         if (skb == NULL) {
 502                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 503                 lp->stats.rx_dropped++;
 504                 return;
 505         }
 506         skb_put(skb, length);
 507
 508         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
 509                                 length);
 510
 511         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
 512                                  dev->name, length,
 513                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
 514                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
 515
 516         skb->protocol=eth_type_trans(skb,dev);
 517         netif_rx(skb);
 518         dev->last_rx = jiffies;
 519         lp->stats.rx_packets++;
 520         lp->stats.rx_bytes += length;
 521 }
 522
 523 /* The inverse routine to net_open(). */
 524 static int
 525 net_close(struct net_device *dev)
 526 {
 527
 528         writereg(dev, PP_RxCFG, 0);
 529         writereg(dev, PP_TxCFG, 0);
 530         writereg(dev, PP_BufCFG, 0);
 531         writereg(dev, PP_BusCTL, 0);
 532
 533         netif_stop_queue(dev);
 534
 535         free_irq(dev->irq, dev);
 536
 537         /* Update the statistics here. */
 538
 539         return 0;
 540
 541 }
 542
 543 /* Get the current statistics.  This may be called with the card open or
 544    closed. */
 545 static struct net_device_stats *
 546 net_get_stats(struct net_device *dev)
 547 {
 548         struct net_local *lp = netdev_priv(dev);
 549         unsigned long flags;
 550
 551         local_irq_save(flags);
 552         /* Update the statistics from the device registers. */
 553         lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
 554         lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
 555         local_irq_restore(flags);
 556
 557         return &lp->stats;
 558 }
 559
 560 static void set_multicast_list(struct net_device *dev)
 561 {
 562         struct net_local *lp = netdev_priv(dev);
 563
 564         if(dev->flags&IFF_PROMISC)
 565         {
 566                 lp->rx_mode = RX_ALL_ACCEPT;
 567         }
 568         else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
 569         {
 570                 /* The multicast-accept list is initialized to accept-all, and we
 571                    rely on higher-level filtering for now. */
 572                 lp->rx_mode = RX_MULTCAST_ACCEPT;
 573         }
 574         else
 575                 lp->rx_mode = 0;
 576
 577         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
 578
 579         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
 580         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
 581              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
 582 }
 583
 584
 585 static int set_mac_address(struct net_device *dev, void *addr)
 586 {
 587         int i;
 588         printk("%s: Setting MAC address to ", dev->name);
 589         for (i = 0; i < 6; i++)
 590                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
 591         printk(".\n");
 592         /* set the Ethernet address */
 593         for (i=0; i < ETH_ALEN/2; i++)
 594                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 595
 596         return 0;
 597 }
 598
 599 #ifdef MODULE
 600
 601 static struct net_device *dev_cs89x0;
 602 static int debug;
 603
 604 module_param(debug, int, 0);
 605 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
 606 MODULE_LICENSE("GPL");
 607
 608 int __init
 609 init_module(void)
 610 {
 611         net_debug = debug;
 612         dev_cs89x0 = mac89x0_probe(-1);
 613         if (IS_ERR(dev_cs89x0)) {
 614                 printk(KERN_WARNING "mac89x0.c: No card found\n");
 615                 return PTR_ERR(dev_cs89x0);
 616         }
 617         return 0;
 618 }
 619
 620 void
 621 cleanup_module(void)
 622 {
 623         unregister_netdev(dev_cs89x0);
 624         nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
 625         free_netdev(dev_cs89x0);
 626 }
 627 #endif /* MODULE */
 628
 629 /*
 630  * Local variables:
 631  *  compile-command: "m68k-linux-gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -ffixed-a2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h   -c -o mac89x0.o mac89x0.c"
 632  *  version-control: t
 633  *  kept-new-versions: 5
 634  *  c-indent-level: 8
 635  *  tab-width: 8
 636  * End:
 637  *
 638  */