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