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