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>
102 #include <linux/bitops.h>
104 #include <asm/system.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);
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 static const struct net_device_ops mac89x0_netdev_ops = {
172 .ndo_open = net_open,
173 .ndo_stop = net_close,
174 .ndo_start_xmit = net_send_packet,
175 .ndo_get_stats = net_get_stats,
176 .ndo_set_multicast_list = set_multicast_list,
177 .ndo_set_mac_address = set_mac_address,
178 .ndo_validate_addr = eth_validate_addr,
179 .ndo_change_mtu = eth_change_mtu,
182 /* Probe for the CS8900 card in slot E. We won't bother looking
183 anywhere else until we have a really good reason to do so. */
184 struct net_device * __init mac89x0_probe(int unit)
186 struct net_device *dev;
187 static int once_is_enough;
188 struct net_local *lp;
189 static unsigned version_printed;
191 unsigned rev_type = 0;
192 unsigned long ioaddr;
197 return ERR_PTR(-ENODEV);
199 dev = alloc_etherdev(sizeof(struct net_local));
201 return ERR_PTR(-ENOMEM);
204 sprintf(dev->name, "eth%d", unit);
205 netdev_boot_setup_check(dev);
212 /* We might have to parameterize this later */
214 /* Get out now if there's a real NuBus card in slot E */
215 if (nubus_find_slot(slot, NULL) != NULL)
218 /* The pseudo-ISA bits always live at offset 0x300 (gee,
220 ioaddr = (unsigned long)
221 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
226 local_irq_save(flags);
227 card_present = hwreg_present((void*) ioaddr+4)
228 && hwreg_present((void*) ioaddr + DATA_PORT);
229 local_irq_restore(flags);
235 nubus_writew(0, ioaddr + ADD_PORT);
236 sig = nubus_readw(ioaddr + DATA_PORT);
237 if (sig != swab16(CHIP_EISA_ID_SIG))
240 /* Initialize the net_device structure. */
241 lp = netdev_priv(dev);
243 /* Fill in the 'dev' fields. */
244 dev->base_addr = ioaddr;
245 dev->mem_start = (unsigned long)
246 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
247 dev->mem_end = dev->mem_start + 0x1000;
249 /* Turn on shared memory */
250 writereg_io(dev, PP_BusCTL, MEMORY_ON);
252 /* get the chip type */
253 rev_type = readreg(dev, PRODUCT_ID_ADD);
254 lp->chip_type = rev_type &~ REVISON_BITS;
255 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
257 /* Check the chip type and revision in order to set the correct send command
258 CS8920 revision C and CS8900 revision F can use the faster send. */
259 lp->send_cmd = TX_AFTER_381;
260 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
261 lp->send_cmd = TX_NOW;
262 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
263 lp->send_cmd = TX_NOW;
265 if (net_debug && version_printed++ == 0)
268 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
270 lp->chip_type==CS8900?'0':'2',
271 lp->chip_type==CS8920M?"M":"",
275 /* Try to read the MAC address */
276 if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
277 printk("\nmac89x0: No EEPROM, giving up now.\n");
280 for (i = 0; i < ETH_ALEN; i += 2) {
281 /* Big-endian (why??!) */
282 unsigned short s = readreg(dev, PP_IA + i);
283 dev->dev_addr[i] = s >> 8;
284 dev->dev_addr[i+1] = s & 0xff;
288 dev->irq = SLOT2IRQ(slot);
290 /* print the IRQ and ethernet address. */
292 printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
294 dev->netdev_ops = &mac89x0_netdev_ops;
296 err = register_netdev(dev);
301 nubus_writew(0, dev->base_addr + ADD_PORT);
308 /* This is useful for something, but I don't know what yet. */
309 void __init reset_chip(struct net_device *dev)
311 int reset_start_time;
313 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
316 msleep_interruptible(30);
318 /* Wait until the chip is reset */
319 reset_start_time = jiffies;
320 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
325 /* Open/initialize the board. This is called (in the current kernel)
326 sometime after booting when the 'ifconfig' program is run.
328 This routine should set everything up anew at each open, even
329 registers that "should" only need to be set once at boot, so that
330 there is non-reboot way to recover if something goes wrong.
333 net_open(struct net_device *dev)
335 struct net_local *lp = netdev_priv(dev);
338 /* Disable the interrupt for now */
339 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
341 /* Grab the interrupt */
342 if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
345 /* Set up the IRQ - Apparently magic */
346 if (lp->chip_type == CS8900)
347 writereg(dev, PP_CS8900_ISAINT, 0);
349 writereg(dev, PP_CS8920_ISAINT, 0);
351 /* set the Ethernet address */
352 for (i=0; i < ETH_ALEN/2; i++)
353 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
355 /* Turn on both receive and transmit operations */
356 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
358 /* Receive only error free packets addressed to this card */
360 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
362 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
364 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
366 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
367 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
369 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
370 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
372 /* now that we've got our act together, enable everything */
373 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
374 netif_start_queue(dev);
379 net_send_packet(struct sk_buff *skb, struct net_device *dev)
381 struct net_local *lp = netdev_priv(dev);
385 printk("%s: sent %d byte packet of type %x\n",
387 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
388 | skb->data[ETH_ALEN+ETH_ALEN+1]);
390 /* keep the upload from being interrupted, since we
391 ask the chip to start transmitting before the
392 whole packet has been completely uploaded. */
393 local_irq_save(flags);
394 netif_stop_queue(dev);
396 /* initiate a transmit sequence */
397 writereg(dev, PP_TxCMD, lp->send_cmd);
398 writereg(dev, PP_TxLength, skb->len);
400 /* Test to see if the chip has allocated memory for the packet */
401 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
402 /* Gasp! It hasn't. But that shouldn't happen since
403 we're waiting for TxOk, so return 1 and requeue this packet. */
404 local_irq_restore(flags);
408 /* Write the contents of the packet */
409 skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
412 local_irq_restore(flags);
413 dev->trans_start = jiffies;
419 /* The typical workload of the driver:
420 Handle the network interface interrupts. */
421 static irqreturn_t net_interrupt(int irq, void *dev_id)
423 struct net_device *dev = dev_id;
424 struct net_local *lp;
428 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
432 ioaddr = dev->base_addr;
433 lp = netdev_priv(dev);
435 /* we MUST read all the events out of the ISQ, otherwise we'll never
436 get interrupted again. As a consequence, we can't have any limit
437 on the number of times we loop in the interrupt handler. The
438 hardware guarantees that eventually we'll run out of events. Of
439 course, if you're on a slow machine, and packets are arriving
440 faster than you can read them off, you're screwed. Hasta la
442 while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
443 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
444 switch(status & ISQ_EVENT_MASK) {
445 case ISQ_RECEIVER_EVENT:
446 /* Got a packet(s). */
449 case ISQ_TRANSMITTER_EVENT:
450 lp->stats.tx_packets++;
451 netif_wake_queue(dev);
452 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
453 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
454 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
455 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
456 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
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
465 netif_wake_queue(dev);
467 if (status & TX_UNDERRUN) {
468 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
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;
474 case ISQ_RX_MISS_EVENT:
475 lp->stats.rx_missed_errors += (status >>6);
477 case ISQ_TX_COL_EVENT:
478 lp->stats.collisions += (status >>6);
485 /* We have a good packet(s), get it/them out of the buffers. */
487 net_rx(struct net_device *dev)
489 struct net_local *lp = netdev_priv(dev);
493 status = readreg(dev, PP_RxStatus);
494 if ((status & RX_OK) == 0) {
495 lp->stats.rx_errors++;
496 if (status & RX_RUNT) lp->stats.rx_length_errors++;
497 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
498 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
500 lp->stats.rx_crc_errors++;
501 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
505 length = readreg(dev, PP_RxLength);
506 /* Malloc up new buffer. */
507 skb = alloc_skb(length, GFP_ATOMIC);
509 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
510 lp->stats.rx_dropped++;
513 skb_put(skb, length);
515 skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
518 if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
520 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
521 | skb->data[ETH_ALEN+ETH_ALEN+1]);
523 skb->protocol=eth_type_trans(skb,dev);
525 lp->stats.rx_packets++;
526 lp->stats.rx_bytes += length;
529 /* The inverse routine to net_open(). */
531 net_close(struct net_device *dev)
534 writereg(dev, PP_RxCFG, 0);
535 writereg(dev, PP_TxCFG, 0);
536 writereg(dev, PP_BufCFG, 0);
537 writereg(dev, PP_BusCTL, 0);
539 netif_stop_queue(dev);
541 free_irq(dev->irq, dev);
543 /* Update the statistics here. */
549 /* Get the current statistics. This may be called with the card open or
551 static struct net_device_stats *
552 net_get_stats(struct net_device *dev)
554 struct net_local *lp = netdev_priv(dev);
557 local_irq_save(flags);
558 /* Update the statistics from the device registers. */
559 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
560 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
561 local_irq_restore(flags);
566 static void set_multicast_list(struct net_device *dev)
568 struct net_local *lp = netdev_priv(dev);
570 if(dev->flags&IFF_PROMISC)
572 lp->rx_mode = RX_ALL_ACCEPT;
574 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
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;
583 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
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));
591 static int set_mac_address(struct net_device *dev, void *addr)
594 printk("%s: Setting MAC address to ", dev->name);
595 for (i = 0; i < 6; i++)
596 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
598 /* set the Ethernet address */
599 for (i=0; i < ETH_ALEN/2; i++)
600 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
607 static struct net_device *dev_cs89x0;
610 module_param(debug, int, 0);
611 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
612 MODULE_LICENSE("GPL");
618 dev_cs89x0 = mac89x0_probe(-1);
619 if (IS_ERR(dev_cs89x0)) {
620 printk(KERN_WARNING "mac89x0.c: No card found\n");
621 return PTR_ERR(dev_cs89x0);
629 unregister_netdev(dev_cs89x0);
630 nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
631 free_netdev(dev_cs89x0);