1 /* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
3 Written 1996 by Russell Nelson, with reference to skeleton.c
4 written 1993-1994 by Donald Becker.
6 This software may be used and distributed according to the terms
7 of the GNU General Public License, incorporated herein by reference.
9 The author may be reached at nelson@crynwr.com, Crynwr
10 Software, 11 Grant St., Potsdam, NY 13676
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.
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
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.
29 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
31 David Huggins-Daines <dhd@debian.org>
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:
37 * Removed all the media-detection stuff, because these cards are
40 * Lobotomized the ISA interrupt bogosity, because these cards use
41 a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
43 * Basically eliminated everything not relevant to getting the
44 cards minimally functioning on the Macintosh.
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.
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()
59 static char *version =
60 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
62 /* ======================= configure the driver here ======================= */
64 /* use 0 for production, 1 for verification, >2 for debug */
69 /* ======================= end of configuration ======================= */
72 /* Always include 'config.h' first in case the user wants to turn on
73 or override something. */
74 #include <linux/module.h>
76 #define PRINTK(x) printk x
81 Crynwr packet driver epktisa.
83 Crystal Semiconductor data sheets.
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>
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>
103 #include <asm/system.h>
104 #include <asm/bitops.h>
106 #include <asm/hwtest.h>
107 #include <asm/macints.h>
111 static unsigned int net_debug = NET_DEBUG;
113 /* Information that need to be kept for each board. */
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. */
121 int send_underrun; /* keep track of how many underruns in a row we get */
125 /* Index to functions, as function prototypes. */
128 extern void reset_chip(struct net_device *dev);
130 static int net_open(struct net_device *dev);
131 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
132 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
133 static void set_multicast_list(struct net_device *dev);
134 static void net_rx(struct net_device *dev);
135 static int net_close(struct net_device *dev);
136 static struct net_device_stats *net_get_stats(struct net_device *dev);
137 static int set_mac_address(struct net_device *dev, void *addr);
140 /* Example routines you must write ;->. */
141 #define tx_done(dev) 1
143 /* For reading/writing registers ISA-style */
145 readreg_io(struct net_device *dev, int portno)
147 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
148 return swab16(nubus_readw(dev->base_addr + DATA_PORT));
152 writereg_io(struct net_device *dev, int portno, int value)
154 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
155 nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
158 /* These are for reading/writing registers in shared memory */
160 readreg(struct net_device *dev, int portno)
162 return swab16(nubus_readw(dev->mem_start + portno));
166 writereg(struct net_device *dev, int portno, int value)
168 nubus_writew(swab16(value), dev->mem_start + portno);
171 /* Probe for the CS8900 card in slot E. We won't bother looking
172 anywhere else until we have a really good reason to do so. */
173 struct net_device * __init mac89x0_probe(int unit)
175 struct net_device *dev;
176 static int once_is_enough;
177 struct net_local *lp;
178 static unsigned version_printed;
180 unsigned rev_type = 0;
181 unsigned long ioaddr;
185 dev = alloc_etherdev(sizeof(struct net_local));
187 return ERR_PTR(-ENOMEM);
190 sprintf(dev->name, "eth%d", unit);
191 netdev_boot_setup_check(dev);
194 SET_MODULE_OWNER(dev);
200 /* We might have to parameterize this later */
202 /* Get out now if there's a real NuBus card in slot E */
203 if (nubus_find_slot(slot, NULL) != NULL)
206 /* The pseudo-ISA bits always live at offset 0x300 (gee,
208 ioaddr = (unsigned long)
209 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
214 local_irq_save(flags);
215 card_present = hwreg_present((void*) ioaddr+4)
216 && hwreg_present((void*) ioaddr + DATA_PORT);
217 local_irq_restore(flags);
223 nubus_writew(0, ioaddr + ADD_PORT);
224 sig = nubus_readw(ioaddr + DATA_PORT);
225 if (sig != swab16(CHIP_EISA_ID_SIG))
228 /* Initialize the net_device structure. */
229 lp = netdev_priv(dev);
231 /* Fill in the 'dev' fields. */
232 dev->base_addr = ioaddr;
233 dev->mem_start = (unsigned long)
234 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
235 dev->mem_end = dev->mem_start + 0x1000;
237 /* Turn on shared memory */
238 writereg_io(dev, PP_BusCTL, MEMORY_ON);
240 /* get the chip type */
241 rev_type = readreg(dev, PRODUCT_ID_ADD);
242 lp->chip_type = rev_type &~ REVISON_BITS;
243 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
245 /* Check the chip type and revision in order to set the correct send command
246 CS8920 revision C and CS8900 revision F can use the faster send. */
247 lp->send_cmd = TX_AFTER_381;
248 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
249 lp->send_cmd = TX_NOW;
250 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
251 lp->send_cmd = TX_NOW;
253 if (net_debug && version_printed++ == 0)
256 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
258 lp->chip_type==CS8900?'0':'2',
259 lp->chip_type==CS8920M?"M":"",
263 /* Try to read the MAC address */
264 if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
265 printk("\nmac89x0: No EEPROM, giving up now.\n");
268 for (i = 0; i < ETH_ALEN; i += 2) {
269 /* Big-endian (why??!) */
270 unsigned short s = readreg(dev, PP_IA + i);
271 dev->dev_addr[i] = s >> 8;
272 dev->dev_addr[i+1] = s & 0xff;
276 dev->irq = SLOT2IRQ(slot);
277 printk(" IRQ %d ADDR ", dev->irq);
279 /* print the ethernet address. */
280 for (i = 0; i < ETH_ALEN; i++)
281 printk("%2.2x%s", dev->dev_addr[i],
282 ((i < ETH_ALEN-1) ? ":" : ""));
285 dev->open = net_open;
286 dev->stop = net_close;
287 dev->hard_start_xmit = net_send_packet;
288 dev->get_stats = net_get_stats;
289 dev->set_multicast_list = &set_multicast_list;
290 dev->set_mac_address = &set_mac_address;
292 err = register_netdev(dev);
297 nubus_writew(0, dev->base_addr + ADD_PORT);
304 /* This is useful for something, but I don't know what yet. */
305 void __init reset_chip(struct net_device *dev)
307 int reset_start_time;
309 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
312 msleep_interruptible(30);
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)
321 /* Open/initialize the board. This is called (in the current kernel)
322 sometime after booting when the 'ifconfig' program is run.
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.
329 net_open(struct net_device *dev)
331 struct net_local *lp = netdev_priv(dev);
334 /* Disable the interrupt for now */
335 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
337 /* Grab the interrupt */
338 if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
341 /* Set up the IRQ - Apparently magic */
342 if (lp->chip_type == CS8900)
343 writereg(dev, PP_CS8900_ISAINT, 0);
345 writereg(dev, PP_CS8920_ISAINT, 0);
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));
351 /* Turn on both receive and transmit operations */
352 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
354 /* Receive only error free packets addressed to this card */
356 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
358 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
360 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
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);
365 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
366 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
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);
375 net_send_packet(struct sk_buff *skb, struct net_device *dev)
378 /* If we get here, some higher level has decided we are broken.
379 There should really be a "kick me" function call instead. */
380 int tickssofar = jiffies - dev->trans_start;
383 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
384 tx_done(dev) ? "IRQ conflict" : "network cable problem");
385 /* Try to restart the adaptor. */
387 dev->trans_start = jiffies;
390 /* Block a timer-based transmit from overlapping. This could better be
391 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
392 if (test_and_set_bit(0, (void*)&dev->tbusy) != 0)
393 printk("%s: Transmitter access conflict.\n", dev->name);
395 struct net_local *lp = netdev_priv(dev);
399 printk("%s: sent %d byte packet of type %x\n",
401 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
402 | skb->data[ETH_ALEN+ETH_ALEN+1]);
404 /* keep the upload from being interrupted, since we
405 ask the chip to start transmitting before the
406 whole packet has been completely uploaded. */
407 local_irq_save(flags);
409 /* initiate a transmit sequence */
410 writereg(dev, PP_TxCMD, lp->send_cmd);
411 writereg(dev, PP_TxLength, skb->len);
413 /* Test to see if the chip has allocated memory for the packet */
414 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
415 /* Gasp! It hasn't. But that shouldn't happen since
416 we're waiting for TxOk, so return 1 and requeue this packet. */
417 local_irq_restore(flags);
421 /* Write the contents of the packet */
422 memcpy_toio(dev->mem_start + PP_TxFrame, skb->data, skb->len+1);
424 local_irq_restore(flags);
425 dev->trans_start = jiffies;
432 /* The typical workload of the driver:
433 Handle the network interface interrupts. */
434 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
436 struct net_device *dev = dev_id;
437 struct net_local *lp;
441 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
445 printk("%s: Re-entering the interrupt handler.\n", dev->name);
448 ioaddr = dev->base_addr;
449 lp = netdev_priv(dev);
451 /* we MUST read all the events out of the ISQ, otherwise we'll never
452 get interrupted again. As a consequence, we can't have any limit
453 on the number of times we loop in the interrupt handler. The
454 hardware guarantees that eventually we'll run out of events. Of
455 course, if you're on a slow machine, and packets are arriving
456 faster than you can read them off, you're screwed. Hasta la
458 while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
459 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
460 switch(status & ISQ_EVENT_MASK) {
461 case ISQ_RECEIVER_EVENT:
462 /* Got a packet(s). */
465 case ISQ_TRANSMITTER_EVENT:
466 lp->stats.tx_packets++;
468 mark_bh(NET_BH); /* Inform upper layers. */
469 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
470 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
471 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
472 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
473 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
475 case ISQ_BUFFER_EVENT:
476 if (status & READY_FOR_TX) {
477 /* we tried to transmit a packet earlier,
478 but inexplicably ran out of buffers.
479 That shouldn't happen since we only ever
480 load one packet. Shrug. Do the right
483 mark_bh(NET_BH); /* Inform upper layers. */
485 if (status & TX_UNDERRUN) {
486 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
488 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
489 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
492 case ISQ_RX_MISS_EVENT:
493 lp->stats.rx_missed_errors += (status >>6);
495 case ISQ_TX_COL_EVENT:
496 lp->stats.collisions += (status >>6);
504 /* We have a good packet(s), get it/them out of the buffers. */
506 net_rx(struct net_device *dev)
508 struct net_local *lp = netdev_priv(dev);
512 status = readreg(dev, PP_RxStatus);
513 if ((status & RX_OK) == 0) {
514 lp->stats.rx_errors++;
515 if (status & RX_RUNT) lp->stats.rx_length_errors++;
516 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
517 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
519 lp->stats.rx_crc_errors++;
520 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
524 length = readreg(dev, PP_RxLength);
525 /* Malloc up new buffer. */
526 skb = alloc_skb(length, GFP_ATOMIC);
528 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
529 lp->stats.rx_dropped++;
532 skb_put(skb, length);
535 memcpy_fromio(skb->data, dev->mem_start + PP_RxFrame, length);
537 if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
539 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
540 | skb->data[ETH_ALEN+ETH_ALEN+1]);
542 skb->protocol=eth_type_trans(skb,dev);
544 dev->last_rx = jiffies;
545 lp->stats.rx_packets++;
546 lp->stats.rx_bytes += length;
549 /* The inverse routine to net_open(). */
551 net_close(struct net_device *dev)
554 writereg(dev, PP_RxCFG, 0);
555 writereg(dev, PP_TxCFG, 0);
556 writereg(dev, PP_BufCFG, 0);
557 writereg(dev, PP_BusCTL, 0);
559 netif_stop_queue(dev);
561 free_irq(dev->irq, dev);
563 /* Update the statistics here. */
569 /* Get the current statistics. This may be called with the card open or
571 static struct net_device_stats *
572 net_get_stats(struct net_device *dev)
574 struct net_local *lp = netdev_priv(dev);
577 local_irq_save(flags);
578 /* Update the statistics from the device registers. */
579 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
580 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
581 local_irq_restore(flags);
586 static void set_multicast_list(struct net_device *dev)
588 struct net_local *lp = netdev_priv(dev);
590 if(dev->flags&IFF_PROMISC)
592 lp->rx_mode = RX_ALL_ACCEPT;
594 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
596 /* The multicast-accept list is initialized to accept-all, and we
597 rely on higher-level filtering for now. */
598 lp->rx_mode = RX_MULTCAST_ACCEPT;
603 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
605 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
606 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
607 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
611 static int set_mac_address(struct net_device *dev, void *addr)
616 printk("%s: Setting MAC address to ", dev->name);
617 for (i = 0; i < 6; i++)
618 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
620 /* set the Ethernet address */
621 for (i=0; i < ETH_ALEN/2; i++)
622 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
629 static struct net_device *dev_cs89x0;
632 module_param(debug, int, 0);
633 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
634 MODULE_LICENSE("GPL");
640 dev_cs89x0 = mac89x0_probe(-1);
641 if (IS_ERR(dev_cs89x0)) {
642 printk(KERN_WARNING "mac89x0.c: No card found\n");
643 return PTR_ERR(dev_cs89x0);
651 unregister_netdev(dev_cs89x0);
652 nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
653 free_netdev(dev_cs89x0);
659 * 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 * kept-new-versions: 5