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