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>
79 Crynwr packet driver epktisa.
81 Crystal Semiconductor data sheets.
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>
91 #include <linux/slab.h>
92 #include <linux/string.h>
93 #include <linux/nubus.h>
94 #include <linux/errno.h>
95 #include <linux/init.h>
96 #include <linux/netdevice.h>
97 #include <linux/etherdevice.h>
98 #include <linux/skbuff.h>
99 #include <linux/delay.h>
100 #include <linux/bitops.h>
102 #include <asm/system.h>
104 #include <asm/hwtest.h>
105 #include <asm/macints.h>
109 static unsigned int net_debug = NET_DEBUG;
111 /* Information that need to be kept for each board. */
113 struct net_device_stats stats;
114 int chip_type; /* one of: CS8900, CS8920, CS8920M */
115 char chip_revision; /* revision letter of the chip ('A'...) */
116 int send_cmd; /* the propercommand used to send a packet. */
119 int send_underrun; /* keep track of how many underruns in a row we get */
123 /* Index to functions, as function prototypes. */
126 extern void reset_chip(struct net_device *dev);
128 static int net_open(struct net_device *dev);
129 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
130 static irqreturn_t net_interrupt(int irq, void *dev_id);
131 static void set_multicast_list(struct net_device *dev);
132 static void net_rx(struct net_device *dev);
133 static int net_close(struct net_device *dev);
134 static struct net_device_stats *net_get_stats(struct net_device *dev);
135 static int set_mac_address(struct net_device *dev, void *addr);
138 /* Example routines you must write ;->. */
139 #define tx_done(dev) 1
141 /* For reading/writing registers ISA-style */
143 readreg_io(struct net_device *dev, int portno)
145 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
146 return swab16(nubus_readw(dev->base_addr + DATA_PORT));
150 writereg_io(struct net_device *dev, int portno, int value)
152 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
153 nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
156 /* These are for reading/writing registers in shared memory */
158 readreg(struct net_device *dev, int portno)
160 return swab16(nubus_readw(dev->mem_start + portno));
164 writereg(struct net_device *dev, int portno, int value)
166 nubus_writew(swab16(value), dev->mem_start + portno);
169 static const struct net_device_ops mac89x0_netdev_ops = {
170 .ndo_open = net_open,
171 .ndo_stop = net_close,
172 .ndo_start_xmit = net_send_packet,
173 .ndo_get_stats = net_get_stats,
174 .ndo_set_multicast_list = set_multicast_list,
175 .ndo_set_mac_address = set_mac_address,
176 .ndo_validate_addr = eth_validate_addr,
177 .ndo_change_mtu = eth_change_mtu,
180 /* Probe for the CS8900 card in slot E. We won't bother looking
181 anywhere else until we have a really good reason to do so. */
182 struct net_device * __init mac89x0_probe(int unit)
184 struct net_device *dev;
185 static int once_is_enough;
186 struct net_local *lp;
187 static unsigned version_printed;
189 unsigned rev_type = 0;
190 unsigned long ioaddr;
195 return ERR_PTR(-ENODEV);
197 dev = alloc_etherdev(sizeof(struct net_local));
199 return ERR_PTR(-ENOMEM);
202 sprintf(dev->name, "eth%d", unit);
203 netdev_boot_setup_check(dev);
210 /* We might have to parameterize this later */
212 /* Get out now if there's a real NuBus card in slot E */
213 if (nubus_find_slot(slot, NULL) != NULL)
216 /* The pseudo-ISA bits always live at offset 0x300 (gee,
218 ioaddr = (unsigned long)
219 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
224 local_irq_save(flags);
225 card_present = hwreg_present((void*) ioaddr+4)
226 && hwreg_present((void*) ioaddr + DATA_PORT);
227 local_irq_restore(flags);
233 nubus_writew(0, ioaddr + ADD_PORT);
234 sig = nubus_readw(ioaddr + DATA_PORT);
235 if (sig != swab16(CHIP_EISA_ID_SIG))
238 /* Initialize the net_device structure. */
239 lp = netdev_priv(dev);
241 /* Fill in the 'dev' fields. */
242 dev->base_addr = ioaddr;
243 dev->mem_start = (unsigned long)
244 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
245 dev->mem_end = dev->mem_start + 0x1000;
247 /* Turn on shared memory */
248 writereg_io(dev, PP_BusCTL, MEMORY_ON);
250 /* get the chip type */
251 rev_type = readreg(dev, PRODUCT_ID_ADD);
252 lp->chip_type = rev_type &~ REVISON_BITS;
253 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
255 /* Check the chip type and revision in order to set the correct send command
256 CS8920 revision C and CS8900 revision F can use the faster send. */
257 lp->send_cmd = TX_AFTER_381;
258 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
259 lp->send_cmd = TX_NOW;
260 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
261 lp->send_cmd = TX_NOW;
263 if (net_debug && version_printed++ == 0)
266 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
268 lp->chip_type==CS8900?'0':'2',
269 lp->chip_type==CS8920M?"M":"",
273 /* Try to read the MAC address */
274 if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
275 printk("\nmac89x0: No EEPROM, giving up now.\n");
278 for (i = 0; i < ETH_ALEN; i += 2) {
279 /* Big-endian (why??!) */
280 unsigned short s = readreg(dev, PP_IA + i);
281 dev->dev_addr[i] = s >> 8;
282 dev->dev_addr[i+1] = s & 0xff;
286 dev->irq = SLOT2IRQ(slot);
288 /* print the IRQ and ethernet address. */
290 printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
292 dev->netdev_ops = &mac89x0_netdev_ops;
294 err = register_netdev(dev);
299 nubus_writew(0, dev->base_addr + ADD_PORT);
306 /* This is useful for something, but I don't know what yet. */
307 void __init reset_chip(struct net_device *dev)
309 int reset_start_time;
311 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
314 msleep_interruptible(30);
316 /* Wait until the chip is reset */
317 reset_start_time = jiffies;
318 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
323 /* Open/initialize the board. This is called (in the current kernel)
324 sometime after booting when the 'ifconfig' program is run.
326 This routine should set everything up anew at each open, even
327 registers that "should" only need to be set once at boot, so that
328 there is non-reboot way to recover if something goes wrong.
331 net_open(struct net_device *dev)
333 struct net_local *lp = netdev_priv(dev);
336 /* Disable the interrupt for now */
337 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
339 /* Grab the interrupt */
340 if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
343 /* Set up the IRQ - Apparently magic */
344 if (lp->chip_type == CS8900)
345 writereg(dev, PP_CS8900_ISAINT, 0);
347 writereg(dev, PP_CS8920_ISAINT, 0);
349 /* set the Ethernet address */
350 for (i=0; i < ETH_ALEN/2; i++)
351 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
353 /* Turn on both receive and transmit operations */
354 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
356 /* Receive only error free packets addressed to this card */
358 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
360 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
362 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
364 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
365 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
367 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
368 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
370 /* now that we've got our act together, enable everything */
371 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
372 netif_start_queue(dev);
377 net_send_packet(struct sk_buff *skb, struct net_device *dev)
379 struct net_local *lp = netdev_priv(dev);
383 printk("%s: sent %d byte packet of type %x\n",
385 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
386 | skb->data[ETH_ALEN+ETH_ALEN+1]);
388 /* keep the upload from being interrupted, since we
389 ask the chip to start transmitting before the
390 whole packet has been completely uploaded. */
391 local_irq_save(flags);
392 netif_stop_queue(dev);
394 /* initiate a transmit sequence */
395 writereg(dev, PP_TxCMD, lp->send_cmd);
396 writereg(dev, PP_TxLength, skb->len);
398 /* Test to see if the chip has allocated memory for the packet */
399 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
400 /* Gasp! It hasn't. But that shouldn't happen since
401 we're waiting for TxOk, so return 1 and requeue this packet. */
402 local_irq_restore(flags);
403 return NETDEV_TX_BUSY;
406 /* Write the contents of the packet */
407 skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
410 local_irq_restore(flags);
411 dev->trans_start = jiffies;
417 /* The typical workload of the driver:
418 Handle the network interface interrupts. */
419 static irqreturn_t net_interrupt(int irq, void *dev_id)
421 struct net_device *dev = dev_id;
422 struct net_local *lp;
426 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
430 ioaddr = dev->base_addr;
431 lp = netdev_priv(dev);
433 /* we MUST read all the events out of the ISQ, otherwise we'll never
434 get interrupted again. As a consequence, we can't have any limit
435 on the number of times we loop in the interrupt handler. The
436 hardware guarantees that eventually we'll run out of events. Of
437 course, if you're on a slow machine, and packets are arriving
438 faster than you can read them off, you're screwed. Hasta la
440 while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
441 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
442 switch(status & ISQ_EVENT_MASK) {
443 case ISQ_RECEIVER_EVENT:
444 /* Got a packet(s). */
447 case ISQ_TRANSMITTER_EVENT:
448 lp->stats.tx_packets++;
449 netif_wake_queue(dev);
450 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
451 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
452 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
453 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
454 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
456 case ISQ_BUFFER_EVENT:
457 if (status & READY_FOR_TX) {
458 /* we tried to transmit a packet earlier,
459 but inexplicably ran out of buffers.
460 That shouldn't happen since we only ever
461 load one packet. Shrug. Do the right
463 netif_wake_queue(dev);
465 if (status & TX_UNDERRUN) {
466 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
468 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
469 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
472 case ISQ_RX_MISS_EVENT:
473 lp->stats.rx_missed_errors += (status >>6);
475 case ISQ_TX_COL_EVENT:
476 lp->stats.collisions += (status >>6);
483 /* We have a good packet(s), get it/them out of the buffers. */
485 net_rx(struct net_device *dev)
487 struct net_local *lp = netdev_priv(dev);
491 status = readreg(dev, PP_RxStatus);
492 if ((status & RX_OK) == 0) {
493 lp->stats.rx_errors++;
494 if (status & RX_RUNT) lp->stats.rx_length_errors++;
495 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
496 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
498 lp->stats.rx_crc_errors++;
499 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
503 length = readreg(dev, PP_RxLength);
504 /* Malloc up new buffer. */
505 skb = alloc_skb(length, GFP_ATOMIC);
507 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
508 lp->stats.rx_dropped++;
511 skb_put(skb, length);
513 skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
516 if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
518 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
519 | skb->data[ETH_ALEN+ETH_ALEN+1]);
521 skb->protocol=eth_type_trans(skb,dev);
523 lp->stats.rx_packets++;
524 lp->stats.rx_bytes += length;
527 /* The inverse routine to net_open(). */
529 net_close(struct net_device *dev)
532 writereg(dev, PP_RxCFG, 0);
533 writereg(dev, PP_TxCFG, 0);
534 writereg(dev, PP_BufCFG, 0);
535 writereg(dev, PP_BusCTL, 0);
537 netif_stop_queue(dev);
539 free_irq(dev->irq, dev);
541 /* Update the statistics here. */
547 /* Get the current statistics. This may be called with the card open or
549 static struct net_device_stats *
550 net_get_stats(struct net_device *dev)
552 struct net_local *lp = netdev_priv(dev);
555 local_irq_save(flags);
556 /* Update the statistics from the device registers. */
557 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
558 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
559 local_irq_restore(flags);
564 static void set_multicast_list(struct net_device *dev)
566 struct net_local *lp = netdev_priv(dev);
568 if(dev->flags&IFF_PROMISC)
570 lp->rx_mode = RX_ALL_ACCEPT;
572 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
574 /* The multicast-accept list is initialized to accept-all, and we
575 rely on higher-level filtering for now. */
576 lp->rx_mode = RX_MULTCAST_ACCEPT;
581 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
583 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
584 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
585 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
589 static int set_mac_address(struct net_device *dev, void *addr)
592 printk("%s: Setting MAC address to ", dev->name);
593 for (i = 0; i < 6; i++)
594 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
596 /* set the Ethernet address */
597 for (i=0; i < ETH_ALEN/2; i++)
598 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
605 static struct net_device *dev_cs89x0;
608 module_param(debug, int, 0);
609 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
610 MODULE_LICENSE("GPL");
616 dev_cs89x0 = mac89x0_probe(-1);
617 if (IS_ERR(dev_cs89x0)) {
618 printk(KERN_WARNING "mac89x0.c: No card found\n");
619 return PTR_ERR(dev_cs89x0);
627 unregister_netdev(dev_cs89x0);
628 nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
629 free_netdev(dev_cs89x0);