drivers/net/mac89x0.c

Name: Public Git Hosting - davej-history.git/blob - drivers/net/mac89x0.c
Rating: 4.4 (3932 reviews)
 1 /* cs89x0.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 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
 53 static char*version =
 54 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
 55
 56 /* ======================= configure the driver here ======================= */
 57
 58 /* use 0 for production, 1 for verification, >2 for debug */
 59 #ifndef NET_DEBUG
 60 #define NET_DEBUG 0
 61 #endif
 62
 63 /* ======================= end of configuration ======================= */
 64
 65
 66 /* Always include 'config.h' first in case the user wants to turn on
 67  or override something. */
 68 #include <linux/module.h>
 69
 70 #define PRINTK(x) printk x
 71
 72 /*
 73  Sources:
 74
 75  Crynwr packet driver epktisa.
 76
 77  Crystal Semiconductor data sheets.
 78
 79 */
 80
 81 #include <linux/kernel.h>
 82 #include <linux/sched.h>
 83 #include <linux/types.h>
 84 #include <linux/fcntl.h>
 85 #include <linux/interrupt.h>
 86 #include <linux/ptrace.h>
 87 #include <linux/ioport.h>
 88 #include <linux/in.h>
 89 #include <linux/malloc.h>
 90 #include <linux/string.h>
 91 #include <linux/nubus.h>
 92 #include <asm/system.h>
 93 #include <asm/bitops.h>
 94 #include <asm/io.h>
 95 #include <asm/hwtest.h>
 96 #include <asm/macints.h>
 97 #include <linux/errno.h>
 98 #include <linux/init.h>
 99
 100 #include <linux/netdevice.h>
 101 #include <linux/etherdevice.h>
 102 #include <linux/skbuff.h>
 103 #include"cs89x0.h"
 104
 105 static unsigned int net_debug = NET_DEBUG;
 106
 107 /* Information that need to be kept for each board. */
 108 struct net_local {
 109 struct net_device_stats stats;
 110 int chip_type;/* one of: CS8900, CS8920, CS8920M */
 111 char chip_revision;/* revision letter of the chip ('A'...) */
 112 int send_cmd;/* the propercommand used to send a packet. */
 113 int rx_mode;
 114 int curr_rx_cfg;
 115 int send_underrun;/* keep track of how many underruns in a row we get */
 116 struct sk_buff *skb;
 117 };
 118
 119 /* Index to functions, as function prototypes. */
 120
 121 externintmac89x0_probe(struct net_device *dev);
 122 #if 0
 123 externvoidreset_chip(struct net_device *dev);
 124 #endif
 125 static intnet_open(struct net_device *dev);
 126 static intnet_send_packet(struct sk_buff *skb,struct net_device *dev);
 127 static voidnet_interrupt(int irq,void*dev_id,struct pt_regs *regs);
 128 static voidset_multicast_list(struct net_device *dev);
 129 static voidnet_rx(struct net_device *dev);
 130 static intnet_close(struct net_device *dev);
 131 static struct net_device_stats *net_get_stats(struct net_device *dev);
 132 static intset_mac_address(struct net_device *dev,void*addr);
 133
 134
 135 /* Example routines you must write ;->. */
 136 #define tx_done(dev) 1
 137
 138 /* For reading/writing registers ISA-style */
 139 static intinline
 140 readreg_io(struct net_device *dev,int portno)
 141 {
 142 writew(swab16(portno), dev->base_addr + ADD_PORT);
 143 returnswab16(readw(dev->base_addr + DATA_PORT));
 144 }
 145
 146 static voidinline
 147 writereg_io(struct net_device *dev,int portno,int value)
 148 {
 149 writew(swab16(portno), dev->base_addr + ADD_PORT);
 150 writew(swab16(value), dev->base_addr + DATA_PORT);
 151 }
 152
 153 /* These are for reading/writing registers in shared memory */
 154 static intinline
 155 readreg(struct net_device *dev,int portno)
 156 {
 157 returnswab16(readw(dev->mem_start + portno));
 158 }
 159
 160 static voidinline
 161 writereg(struct net_device *dev,int portno,int value)
 162 {
 163 writew(swab16(value), dev->mem_start + portno);
 164 }
 165
 166 /* Probe for the CS8900 card in slot E. We won't bother looking
 167  anywhere else until we have a really good reason to do so. */
 168 int __init mac89x0_probe(struct net_device *dev)
 169 {
 170 static int once_is_enough =0;
 171 struct net_local *lp;
 172 static unsigned version_printed =0;
 173 int i, slot;
 174 unsigned rev_type =0;
 175 unsigned long ioaddr;
 176 unsigned short sig;
 177
 178 SET_MODULE_OWNER(dev);
 179
 180 if(once_is_enough)
 181 return-ENODEV;
 182  once_is_enough =1;
 183
 184 /* We might have to parameterize this later */
 185  slot =0xE;
 186 /* Get out now if there's a real NuBus card in slot E */
 187 if(nubus_find_slot(slot, NULL) != NULL)
 188 return-ENODEV;
 189
 190 /* The pseudo-ISA bits always live at offset 0x300 (gee,
 191  wonder why...) */
 192  ioaddr = (unsigned long)
 193 nubus_slot_addr(slot) | (((slot&0xf) <<20) + DEFAULTIOBASE);
 194 {
 195 unsigned long flags;
 196 int card_present;
 197
 198 save_flags(flags);
 199 cli();
 200  card_present =hwreg_present((void*) ioaddr+4)
 201 &&hwreg_present((void*) ioaddr + DATA_PORT);
 202 restore_flags(flags);
 203
 204 if(!card_present)
 205 return-ENODEV;
 206 }
 207
 208 writew(0, ioaddr + ADD_PORT);
 209  sig =readw(ioaddr + DATA_PORT);
 210 if(sig !=swab16(CHIP_EISA_ID_SIG))
 211 return-ENODEV;
 212
 213 /* Initialize the net_device structure. */
 214 if(dev->priv == NULL) {
 215  dev->priv =kmalloc(sizeof(struct net_local), GFP_KERNEL);
 216 memset(dev->priv,0,sizeof(struct net_local));
 217 }
 218  lp = (struct net_local *)dev->priv;
 219
 220 /* Fill in the 'dev' fields. */
 221  dev->base_addr = ioaddr;
 222  dev->mem_start = (unsigned long)
 223 nubus_slot_addr(slot) | (((slot&0xf) <<20) + MMIOBASE);
 224  dev->mem_end = dev->mem_start +0x1000;
 225
 226 /* Turn on shared memory */
 227 writereg_io(dev, PP_BusCTL, MEMORY_ON);
 228
 229 /* get the chip type */
 230  rev_type =readreg(dev, PRODUCT_ID_ADD);
 231  lp->chip_type = rev_type &~ REVISON_BITS;
 232  lp->chip_revision = ((rev_type & REVISON_BITS) >>8) +'A';
 233
 234 /* Check the chip type and revision in order to set the correct send command
 235  CS8920 revision C and CS8900 revision F can use the faster send. */
 236  lp->send_cmd = TX_AFTER_381;
 237 if(lp->chip_type == CS8900 && lp->chip_revision >='F')
 238  lp->send_cmd = TX_NOW;
 239 if(lp->chip_type != CS8900 && lp->chip_revision >='C')
 240  lp->send_cmd = TX_NOW;
 241
 242 if(net_debug && version_printed++ ==0)
 243 printk(version);
 244
 245 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
 246  dev->name,
 247  lp->chip_type==CS8900?'0':'2',
 248  lp->chip_type==CS8920M?"M":"",
 249  lp->chip_revision,
 250  dev->base_addr);
 251
 252 /* Try to read the MAC address */
 253 if((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) ==0) {
 254 printk("\nmac89x0: No EEPROM, giving up now.\n");
 255 return-ENODEV;
 256 }else{
 257 for(i =0; i < ETH_ALEN; i +=2) {
 258 /* Big-endian (why??!) */
 259 unsigned short s =readreg(dev, PP_IA + i);
 260  dev->dev_addr[i] = s >>8;
 261  dev->dev_addr[i+1] = s &0xff;
 262 }
 263 }
 264
 265  dev->irq =SLOT2IRQ(slot);
 266 printk(" IRQ %d ADDR ", dev->irq);
 267
 268 /* print the ethernet address. */
 269 for(i =0; i < ETH_ALEN; i++)
 270 printk("%2.2x%s", dev->dev_addr[i],
 271 ((i < ETH_ALEN-1) ?":":""));
 272
 273  dev->open = net_open;
 274  dev->stop = net_close;
 275  dev->hard_start_xmit = net_send_packet;
 276  dev->get_stats = net_get_stats;
 277  dev->set_multicast_list = &set_multicast_list;
 278  dev->set_mac_address = &set_mac_address;
 279
 280 /* Fill in the fields of the net_device structure with ethernet values. */
 281 ether_setup(dev);
 282
 283 printk("\n");
 284 return0;
 285 }
 286
 287 #if 0
 288 /* This is useful for something, but I don't know what yet. */
 289 void __init reset_chip(struct net_device *dev)
 290 {
 291 int reset_start_time;
 292
 293 writereg(dev, PP_SelfCTL,readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
 294
 295 /* wait 30 ms */
 296  current->state = TASK_INTERRUPTIBLE;
 297 schedule_timeout(30*HZ/1000);
 298
 299 /* Wait until the chip is reset */
 300  reset_start_time = jiffies;
 301 while( (readreg(dev, PP_SelfST) & INIT_DONE) ==0&& jiffies - reset_start_time <2)
 302 ;
 303 }
 304 #endif
 305
 306 /* Open/initialize the board. This is called (in the current kernel)
 307  sometime after booting when the 'ifconfig' program is run.
 308
 309  This routine should set everything up anew at each open, even
 310  registers that "should" only need to be set once at boot, so that
 311  there is non-reboot way to recover if something goes wrong.
 312  */
 313 static int
 314 net_open(struct net_device *dev)
 315 {
 316 struct net_local *lp = (struct net_local *)dev->priv;
 317 int i;
 318
 319 /* Disable the interrupt for now */
 320 writereg(dev, PP_BusCTL,readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
 321
 322 /* Grab the interrupt */
 323 if(request_irq(dev->irq, &net_interrupt,0,"cs89x0", dev))
 324 return-EAGAIN;
 325
 326 /* Set up the IRQ - Apparently magic */
 327 if(lp->chip_type == CS8900)
 328 writereg(dev, PP_CS8900_ISAINT,0);
 329 else
 330 writereg(dev, PP_CS8920_ISAINT,0);
 331
 332 /* set the Ethernet address */
 333 for(i=0; i < ETH_ALEN/2; i++)
 334 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] <<8));
 335
 336 /* Turn on both receive and transmit operations */
 337 writereg(dev, PP_LineCTL,readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
 338
 339 /* Receive only error free packets addressed to this card */
 340  lp->rx_mode =0;
 341 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
 342
 343  lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
 344
 345 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
 346
 347 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
 348  TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
 349
 350 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
 351  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
 352
 353 /* now that we've got our act together, enable everything */
 354 writereg(dev, PP_BusCTL,readreg(dev, PP_BusCTL) | ENABLE_IRQ);
 355 netif_start_queue(dev);
 356 return0;
 357 }
 358
 359 static int
 360 net_send_packet(struct sk_buff *skb,struct net_device *dev)
 361 {
 362 if(dev->tbusy) {
 363 /* If we get here, some higher level has decided we are broken.
 364  There should really be a "kick me" function call instead. */
 365 int tickssofar = jiffies - dev->trans_start;
 366 if(tickssofar <5)
 367 return1;
 368 if(net_debug >0)printk("%s: transmit timed out, %s?\n", dev->name,
 369 tx_done(dev) ?"IRQ conflict":"network cable problem");
 370 /* Try to restart the adaptor. */
 371  dev->tbusy=0;
 372  dev->trans_start = jiffies;
 373 }
 374
 375 /* Block a timer-based transmit from overlapping. This could better be
 376  done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 377 if(test_and_set_bit(0, (void*)&dev->tbusy) !=0)
 378 printk("%s: Transmitter access conflict.\n", dev->name);
 379 else{
 380 struct net_local *lp = (struct net_local *)dev->priv;
 381 unsigned long flags;
 382
 383 if(net_debug >3)
 384 printk("%s: sent %d byte packet of type %x\n",
 385  dev->name, skb->len,
 386 (skb->data[ETH_ALEN+ETH_ALEN] <<8)
 387 | skb->data[ETH_ALEN+ETH_ALEN+1]);
 388
 389 /* keep the upload from being interrupted, since we
 390  ask the chip to start transmitting before the
 391  whole packet has been completely uploaded. */
 392 save_flags(flags);
 393 cli();
 394
 395 /* initiate a transmit sequence */
 396 writereg(dev, PP_TxCMD, lp->send_cmd);
 397 writereg(dev, PP_TxLength, skb->len);
 398
 399 /* Test to see if the chip has allocated memory for the packet */
 400 if((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) ==0) {
 401 /* Gasp! It hasn't. But that shouldn't happen since
 402  we're waiting for TxOk, so return 1 and requeue this packet. */
 403 restore_flags(flags);
 404 return1;
 405 }
 406
 407 /* Write the contents of the packet */
 408 memcpy_toio(dev->mem_start + PP_TxFrame, skb->data, skb->len+1);
 409
 410 restore_flags(flags);
 411  dev->trans_start = jiffies;
 412 }
 413 dev_kfree_skb(skb);
 414
 415 return0;
 416 }
 417 \f
 418 /* The typical workload of the driver:
 419  Handle the network interface interrupts. */
 420 static voidnet_interrupt(int irq,void*dev_id,struct pt_regs * regs)
 421 {
 422 struct net_device *dev = dev_id;
 423 struct net_local *lp;
 424 int ioaddr, status;
 425
 426 if(dev == NULL) {
 427 printk("net_interrupt(): irq %d for unknown device.\n", irq);
 428 return;
 429 }
 430 if(dev->interrupt)
 431 printk("%s: Re-entering the interrupt handler.\n", dev->name);
 432  dev->interrupt =1;
 433
 434  ioaddr = dev->base_addr;
 435  lp = (struct net_local *)dev->priv;
 436
 437 /* we MUST read all the events out of the ISQ, otherwise we'll never
 438  get interrupted again. As a consequence, we can't have any limit
 439  on the number of times we loop in the interrupt handler. The
 440  hardware guarantees that eventually we'll run out of events. Of
 441  course, if you're on a slow machine, and packets are arriving
 442  faster than you can read them off, you're screwed. Hasta la
 443  vista, baby! */
 444 while((status =swab16(readw(dev->base_addr + ISQ_PORT)))) {
 445 if(net_debug >4)printk("%s: event=%04x\n", dev->name, status);
 446 switch(status & ISQ_EVENT_MASK) {
 447 case ISQ_RECEIVER_EVENT:
 448 /* Got a packet(s). */
 449 net_rx(dev);
 450 break;
 451 case ISQ_TRANSMITTER_EVENT:
 452  lp->stats.tx_packets++;
 453  dev->tbusy =0;
 454 mark_bh(NET_BH);/* Inform upper layers. */
 455 if((status & TX_OK) ==0) lp->stats.tx_errors++;
 456 if(status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
 457 if(status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
 458 if(status & TX_LATE_COL) lp->stats.tx_window_errors++;
 459 if(status & TX_16_COL) lp->stats.tx_aborted_errors++;
 460 break;
 461 case ISQ_BUFFER_EVENT:
 462 if(status & READY_FOR_TX) {
 463 /* we tried to transmit a packet earlier,
 464  but inexplicably ran out of buffers.
 465  That shouldn't happen since we only ever
 466  load one packet. Shrug. Do the right
 467  thing anyway. */
 468  dev->tbusy =0;
 469 mark_bh(NET_BH);/* Inform upper layers. */
 470 }
 471 if(status & TX_UNDERRUN) {
 472 if(net_debug >0)printk("%s: transmit underrun\n", dev->name);
 473  lp->send_underrun++;
 474 if(lp->send_underrun ==3) lp->send_cmd = TX_AFTER_381;
 475 else if(lp->send_underrun ==6) lp->send_cmd = TX_AFTER_ALL;
 476 }
 477 break;
 478 case ISQ_RX_MISS_EVENT:
 479  lp->stats.rx_missed_errors += (status >>6);
 480 break;
 481 case ISQ_TX_COL_EVENT:
 482  lp->stats.collisions += (status >>6);
 483 break;
 484 }
 485 }
 486  dev->interrupt =0;
 487 return;
 488 }
 489
 490 /* We have a good packet(s), get it/them out of the buffers. */
 491 static void
 492 net_rx(struct net_device *dev)
 493 {
 494 struct net_local *lp = (struct net_local *)dev->priv;
 495 struct sk_buff *skb;
 496 int status, length;
 497
 498  status =readreg(dev, PP_RxStatus);
 499 if((status & RX_OK) ==0) {
 500  lp->stats.rx_errors++;
 501 if(status & RX_RUNT) lp->stats.rx_length_errors++;
 502 if(status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
 503 if(status & RX_CRC_ERROR)if(!(status & (RX_EXTRA_DATA|RX_RUNT)))
 504 /* per str 172 */
 505  lp->stats.rx_crc_errors++;
 506 if(status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
 507 return;
 508 }
 509
 510  length =readreg(dev, PP_RxLength);
 511 /* Malloc up new buffer. */
 512  skb =alloc_skb(length, GFP_ATOMIC);
 513 if(skb == NULL) {
 514 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 515  lp->stats.rx_dropped++;
 516 return;
 517 }
 518  skb->len = length;
 519  skb->dev = dev;
 520
 521 memcpy_fromio(skb->data, dev->mem_start + PP_RxFrame, length);
 522
 523 if(net_debug >3)printk("%s: received %d byte packet of type %x\n",
 524  dev->name, length,
 525 (skb->data[ETH_ALEN+ETH_ALEN] <<8)
 526 | skb->data[ETH_ALEN+ETH_ALEN+1]);
 527
 528  skb->protocol=eth_type_trans(skb,dev);
 529 netif_rx(skb);
 530  lp->stats.rx_packets++;
 531  lp->stats.rx_bytes+=skb->len;
 532 return;
 533 }
 534
 535 /* The inverse routine to net_open(). */
 536 static int
 537 net_close(struct net_device *dev)
 538 {
 539
 540 writereg(dev, PP_RxCFG,0);
 541 writereg(dev, PP_TxCFG,0);
 542 writereg(dev, PP_BufCFG,0);
 543 writereg(dev, PP_BusCTL,0);
 544
 545 netif_stop_queue(dev);
 546
 547 free_irq(dev->irq, dev);
 548
 549 /* Update the statistics here. */
 550
 551 return0;
 552
 553 }
 554
 555 /* Get the current statistics. This may be called with the card open or
 556  closed. */
 557 static struct net_device_stats *
 558 net_get_stats(struct net_device *dev)
 559 {
 560 struct net_local *lp = (struct net_local *)dev->priv;
 561
 562 cli();
 563 /* Update the statistics from the device registers. */
 564  lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >>6);
 565  lp->stats.collisions += (readreg(dev, PP_TxCol) >>6);
 566 sti();
 567
 568 return&lp->stats;
 569 }
 570
 571 static voidset_multicast_list(struct net_device *dev)
 572 {
 573 struct net_local *lp = (struct net_local *)dev->priv;
 574
 575 if(dev->flags&IFF_PROMISC)
 576 {
 577  lp->rx_mode = RX_ALL_ACCEPT;
 578 }
 579 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
 580 {
 581 /* The multicast-accept list is initialized to accept-all, and we
 582  rely on higher-level filtering for now. */
 583  lp->rx_mode = RX_MULTCAST_ACCEPT;
 584 }
 585 else
 586  lp->rx_mode =0;
 587
 588 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
 589
 590 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
 591 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
 592 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) :0));
 593 }
 594
 595
 596 static intset_mac_address(struct net_device *dev,void*addr)
 597 {
 598 int i;
 599 if(dev->start)
 600 return-EBUSY;
 601 printk("%s: Setting MAC address to ", dev->name);
 602 for(i =0; i <6; i++)
 603 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char*)addr)[i]);
 604 printk(".\n");
 605 /* set the Ethernet address */
 606 for(i=0; i < ETH_ALEN/2; i++)
 607 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] <<8));
 608
 609 return0;
 610 }
 611
 612 #ifdef MODULE
 613
 614 static struct net_device dev_cs89x0;
 615 static int debug;
 616
 617 MODULE_PARM(debug,"i");
 618
 619 EXPORT_NO_SYMBOLS;
 620
 621 int
 622 init_module(void)
 623 {
 624 struct net_local *lp;
 625
 626  net_debug = debug;
 627  dev_cs89x0.init = mac89x0_probe;
 628  dev_cs89x0.priv =kmalloc(sizeof(struct net_local), GFP_KERNEL);
 629 memset(dev_cs89x0.priv,0,sizeof(struct net_local));
 630  lp = (struct net_local *)dev_cs89x0.priv;
 631
 632 if(register_netdev(&dev_cs89x0) !=0) {
 633 printk(KERN_WARNING "mac89x0.c: No card found\n");
 634 return-ENXIO;
 635 }
 636 return0;
 637 }
 638
 639 void
 640 cleanup_module(void)
 641 {
 642
 643 #endif
 644 #ifdef MODULE
 645 writew(0, dev_cs89x0.base_addr + ADD_PORT);
 646 #endif
 647 #ifdef MODULE
 648
 649 if(dev_cs89x0.priv != NULL) {
 650 /* Free up the private structure, or leak memory :-) */
 651 unregister_netdev(&dev_cs89x0);
 652 kfree(dev_cs89x0.priv);
 653  dev_cs89x0.priv = NULL;/* gets re-allocated by cs89x0_probe1 */
 654 }
 655 }
 656 #endif/* MODULE */
 657 \f
 658 /*
 659  * Local variables:
 660  * 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"
 661  * version-control: t
 662  * kept-new-versions: 5
 663  * c-indent-level: 8
 664  * tab-width: 8
 665  * End:
 666  *
 667  */