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