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 /* 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
;
186 return ERR_PTR(-ENODEV
);
188 dev
= alloc_etherdev(sizeof(struct net_local
));
190 return ERR_PTR(-ENOMEM
);
193 sprintf(dev
->name
, "eth%d", unit
);
194 netdev_boot_setup_check(dev
);
201 /* We might have to parameterize this later */
203 /* Get out now if there's a real NuBus card in slot E */
204 if (nubus_find_slot(slot
, NULL
) != NULL
)
207 /* The pseudo-ISA bits always live at offset 0x300 (gee,
209 ioaddr
= (unsigned long)
210 nubus_slot_addr(slot
) | (((slot
&0xf) << 20) + DEFAULTIOBASE
);
215 local_irq_save(flags
);
216 card_present
= hwreg_present((void*) ioaddr
+4)
217 && hwreg_present((void*) ioaddr
+ DATA_PORT
);
218 local_irq_restore(flags
);
224 nubus_writew(0, ioaddr
+ ADD_PORT
);
225 sig
= nubus_readw(ioaddr
+ DATA_PORT
);
226 if (sig
!= swab16(CHIP_EISA_ID_SIG
))
229 /* Initialize the net_device structure. */
230 lp
= netdev_priv(dev
);
232 /* Fill in the 'dev' fields. */
233 dev
->base_addr
= ioaddr
;
234 dev
->mem_start
= (unsigned long)
235 nubus_slot_addr(slot
) | (((slot
&0xf) << 20) + MMIOBASE
);
236 dev
->mem_end
= dev
->mem_start
+ 0x1000;
238 /* Turn on shared memory */
239 writereg_io(dev
, PP_BusCTL
, MEMORY_ON
);
241 /* get the chip type */
242 rev_type
= readreg(dev
, PRODUCT_ID_ADD
);
243 lp
->chip_type
= rev_type
&~ REVISON_BITS
;
244 lp
->chip_revision
= ((rev_type
& REVISON_BITS
) >> 8) + 'A';
246 /* Check the chip type and revision in order to set the correct send command
247 CS8920 revision C and CS8900 revision F can use the faster send. */
248 lp
->send_cmd
= TX_AFTER_381
;
249 if (lp
->chip_type
== CS8900
&& lp
->chip_revision
>= 'F')
250 lp
->send_cmd
= TX_NOW
;
251 if (lp
->chip_type
!= CS8900
&& lp
->chip_revision
>= 'C')
252 lp
->send_cmd
= TX_NOW
;
254 if (net_debug
&& version_printed
++ == 0)
257 printk(KERN_INFO
"%s: cs89%c0%s rev %c found at %#8lx",
259 lp
->chip_type
==CS8900
?'0':'2',
260 lp
->chip_type
==CS8920M
?"M":"",
264 /* Try to read the MAC address */
265 if ((readreg(dev
, PP_SelfST
) & (EEPROM_PRESENT
| EEPROM_OK
)) == 0) {
266 printk("\nmac89x0: No EEPROM, giving up now.\n");
269 for (i
= 0; i
< ETH_ALEN
; i
+= 2) {
270 /* Big-endian (why??!) */
271 unsigned short s
= readreg(dev
, PP_IA
+ i
);
272 dev
->dev_addr
[i
] = s
>> 8;
273 dev
->dev_addr
[i
+1] = s
& 0xff;
277 dev
->irq
= SLOT2IRQ(slot
);
279 /* print the IRQ and ethernet address. */
281 printk(" IRQ %d ADDR %pM\n", dev
->irq
, dev
->dev_addr
);
283 dev
->open
= net_open
;
284 dev
->stop
= net_close
;
285 dev
->hard_start_xmit
= net_send_packet
;
286 dev
->get_stats
= net_get_stats
;
287 dev
->set_multicast_list
= &set_multicast_list
;
288 dev
->set_mac_address
= &set_mac_address
;
290 err
= register_netdev(dev
);
295 nubus_writew(0, dev
->base_addr
+ ADD_PORT
);
302 /* This is useful for something, but I don't know what yet. */
303 void __init
reset_chip(struct net_device
*dev
)
305 int reset_start_time
;
307 writereg(dev
, PP_SelfCTL
, readreg(dev
, PP_SelfCTL
) | POWER_ON_RESET
);
310 msleep_interruptible(30);
312 /* Wait until the chip is reset */
313 reset_start_time
= jiffies
;
314 while( (readreg(dev
, PP_SelfST
) & INIT_DONE
) == 0 && jiffies
- reset_start_time
< 2)
319 /* Open/initialize the board. This is called (in the current kernel)
320 sometime after booting when the 'ifconfig' program is run.
322 This routine should set everything up anew at each open, even
323 registers that "should" only need to be set once at boot, so that
324 there is non-reboot way to recover if something goes wrong.
327 net_open(struct net_device
*dev
)
329 struct net_local
*lp
= netdev_priv(dev
);
332 /* Disable the interrupt for now */
333 writereg(dev
, PP_BusCTL
, readreg(dev
, PP_BusCTL
) & ~ENABLE_IRQ
);
335 /* Grab the interrupt */
336 if (request_irq(dev
->irq
, &net_interrupt
, 0, "cs89x0", dev
))
339 /* Set up the IRQ - Apparently magic */
340 if (lp
->chip_type
== CS8900
)
341 writereg(dev
, PP_CS8900_ISAINT
, 0);
343 writereg(dev
, PP_CS8920_ISAINT
, 0);
345 /* set the Ethernet address */
346 for (i
=0; i
< ETH_ALEN
/2; i
++)
347 writereg(dev
, PP_IA
+i
*2, dev
->dev_addr
[i
*2] | (dev
->dev_addr
[i
*2+1] << 8));
349 /* Turn on both receive and transmit operations */
350 writereg(dev
, PP_LineCTL
, readreg(dev
, PP_LineCTL
) | SERIAL_RX_ON
| SERIAL_TX_ON
);
352 /* Receive only error free packets addressed to this card */
354 writereg(dev
, PP_RxCTL
, DEF_RX_ACCEPT
);
356 lp
->curr_rx_cfg
= RX_OK_ENBL
| RX_CRC_ERROR_ENBL
;
358 writereg(dev
, PP_RxCFG
, lp
->curr_rx_cfg
);
360 writereg(dev
, PP_TxCFG
, TX_LOST_CRS_ENBL
| TX_SQE_ERROR_ENBL
| TX_OK_ENBL
|
361 TX_LATE_COL_ENBL
| TX_JBR_ENBL
| TX_ANY_COL_ENBL
| TX_16_COL_ENBL
);
363 writereg(dev
, PP_BufCFG
, READY_FOR_TX_ENBL
| RX_MISS_COUNT_OVRFLOW_ENBL
|
364 TX_COL_COUNT_OVRFLOW_ENBL
| TX_UNDERRUN_ENBL
);
366 /* now that we've got our act together, enable everything */
367 writereg(dev
, PP_BusCTL
, readreg(dev
, PP_BusCTL
) | ENABLE_IRQ
);
368 netif_start_queue(dev
);
373 net_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
375 struct net_local
*lp
= netdev_priv(dev
);
379 printk("%s: sent %d byte packet of type %x\n",
381 (skb
->data
[ETH_ALEN
+ETH_ALEN
] << 8)
382 | skb
->data
[ETH_ALEN
+ETH_ALEN
+1]);
384 /* keep the upload from being interrupted, since we
385 ask the chip to start transmitting before the
386 whole packet has been completely uploaded. */
387 local_irq_save(flags
);
388 netif_stop_queue(dev
);
390 /* initiate a transmit sequence */
391 writereg(dev
, PP_TxCMD
, lp
->send_cmd
);
392 writereg(dev
, PP_TxLength
, skb
->len
);
394 /* Test to see if the chip has allocated memory for the packet */
395 if ((readreg(dev
, PP_BusST
) & READY_FOR_TX_NOW
) == 0) {
396 /* Gasp! It hasn't. But that shouldn't happen since
397 we're waiting for TxOk, so return 1 and requeue this packet. */
398 local_irq_restore(flags
);
402 /* Write the contents of the packet */
403 skb_copy_from_linear_data(skb
, (void *)(dev
->mem_start
+ PP_TxFrame
),
406 local_irq_restore(flags
);
407 dev
->trans_start
= jiffies
;
413 /* The typical workload of the driver:
414 Handle the network interface interrupts. */
415 static irqreturn_t
net_interrupt(int irq
, void *dev_id
)
417 struct net_device
*dev
= dev_id
;
418 struct net_local
*lp
;
422 printk ("net_interrupt(): irq %d for unknown device.\n", irq
);
426 ioaddr
= dev
->base_addr
;
427 lp
= netdev_priv(dev
);
429 /* we MUST read all the events out of the ISQ, otherwise we'll never
430 get interrupted again. As a consequence, we can't have any limit
431 on the number of times we loop in the interrupt handler. The
432 hardware guarantees that eventually we'll run out of events. Of
433 course, if you're on a slow machine, and packets are arriving
434 faster than you can read them off, you're screwed. Hasta la
436 while ((status
= swab16(nubus_readw(dev
->base_addr
+ ISQ_PORT
)))) {
437 if (net_debug
> 4)printk("%s: event=%04x\n", dev
->name
, status
);
438 switch(status
& ISQ_EVENT_MASK
) {
439 case ISQ_RECEIVER_EVENT
:
440 /* Got a packet(s). */
443 case ISQ_TRANSMITTER_EVENT
:
444 lp
->stats
.tx_packets
++;
445 netif_wake_queue(dev
);
446 if ((status
& TX_OK
) == 0) lp
->stats
.tx_errors
++;
447 if (status
& TX_LOST_CRS
) lp
->stats
.tx_carrier_errors
++;
448 if (status
& TX_SQE_ERROR
) lp
->stats
.tx_heartbeat_errors
++;
449 if (status
& TX_LATE_COL
) lp
->stats
.tx_window_errors
++;
450 if (status
& TX_16_COL
) lp
->stats
.tx_aborted_errors
++;
452 case ISQ_BUFFER_EVENT
:
453 if (status
& READY_FOR_TX
) {
454 /* we tried to transmit a packet earlier,
455 but inexplicably ran out of buffers.
456 That shouldn't happen since we only ever
457 load one packet. Shrug. Do the right
459 netif_wake_queue(dev
);
461 if (status
& TX_UNDERRUN
) {
462 if (net_debug
> 0) printk("%s: transmit underrun\n", dev
->name
);
464 if (lp
->send_underrun
== 3) lp
->send_cmd
= TX_AFTER_381
;
465 else if (lp
->send_underrun
== 6) lp
->send_cmd
= TX_AFTER_ALL
;
468 case ISQ_RX_MISS_EVENT
:
469 lp
->stats
.rx_missed_errors
+= (status
>>6);
471 case ISQ_TX_COL_EVENT
:
472 lp
->stats
.collisions
+= (status
>>6);
479 /* We have a good packet(s), get it/them out of the buffers. */
481 net_rx(struct net_device
*dev
)
483 struct net_local
*lp
= netdev_priv(dev
);
487 status
= readreg(dev
, PP_RxStatus
);
488 if ((status
& RX_OK
) == 0) {
489 lp
->stats
.rx_errors
++;
490 if (status
& RX_RUNT
) lp
->stats
.rx_length_errors
++;
491 if (status
& RX_EXTRA_DATA
) lp
->stats
.rx_length_errors
++;
492 if (status
& RX_CRC_ERROR
) if (!(status
& (RX_EXTRA_DATA
|RX_RUNT
)))
494 lp
->stats
.rx_crc_errors
++;
495 if (status
& RX_DRIBBLE
) lp
->stats
.rx_frame_errors
++;
499 length
= readreg(dev
, PP_RxLength
);
500 /* Malloc up new buffer. */
501 skb
= alloc_skb(length
, GFP_ATOMIC
);
503 printk("%s: Memory squeeze, dropping packet.\n", dev
->name
);
504 lp
->stats
.rx_dropped
++;
507 skb_put(skb
, length
);
509 skb_copy_to_linear_data(skb
, (void *)(dev
->mem_start
+ PP_RxFrame
),
512 if (net_debug
> 3)printk("%s: received %d byte packet of type %x\n",
514 (skb
->data
[ETH_ALEN
+ETH_ALEN
] << 8)
515 | skb
->data
[ETH_ALEN
+ETH_ALEN
+1]);
517 skb
->protocol
=eth_type_trans(skb
,dev
);
519 lp
->stats
.rx_packets
++;
520 lp
->stats
.rx_bytes
+= length
;
523 /* The inverse routine to net_open(). */
525 net_close(struct net_device
*dev
)
528 writereg(dev
, PP_RxCFG
, 0);
529 writereg(dev
, PP_TxCFG
, 0);
530 writereg(dev
, PP_BufCFG
, 0);
531 writereg(dev
, PP_BusCTL
, 0);
533 netif_stop_queue(dev
);
535 free_irq(dev
->irq
, dev
);
537 /* Update the statistics here. */
543 /* Get the current statistics. This may be called with the card open or
545 static struct net_device_stats
*
546 net_get_stats(struct net_device
*dev
)
548 struct net_local
*lp
= netdev_priv(dev
);
551 local_irq_save(flags
);
552 /* Update the statistics from the device registers. */
553 lp
->stats
.rx_missed_errors
+= (readreg(dev
, PP_RxMiss
) >> 6);
554 lp
->stats
.collisions
+= (readreg(dev
, PP_TxCol
) >> 6);
555 local_irq_restore(flags
);
560 static void set_multicast_list(struct net_device
*dev
)
562 struct net_local
*lp
= netdev_priv(dev
);
564 if(dev
->flags
&IFF_PROMISC
)
566 lp
->rx_mode
= RX_ALL_ACCEPT
;
568 else if((dev
->flags
&IFF_ALLMULTI
)||dev
->mc_list
)
570 /* The multicast-accept list is initialized to accept-all, and we
571 rely on higher-level filtering for now. */
572 lp
->rx_mode
= RX_MULTCAST_ACCEPT
;
577 writereg(dev
, PP_RxCTL
, DEF_RX_ACCEPT
| lp
->rx_mode
);
579 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
580 writereg(dev
, PP_RxCFG
, lp
->curr_rx_cfg
|
581 (lp
->rx_mode
== RX_ALL_ACCEPT
? (RX_CRC_ERROR_ENBL
|RX_RUNT_ENBL
|RX_EXTRA_DATA_ENBL
) : 0));
585 static int set_mac_address(struct net_device
*dev
, void *addr
)
588 printk("%s: Setting MAC address to ", dev
->name
);
589 for (i
= 0; i
< 6; i
++)
590 printk(" %2.2x", dev
->dev_addr
[i
] = ((unsigned char *)addr
)[i
]);
592 /* set the Ethernet address */
593 for (i
=0; i
< ETH_ALEN
/2; i
++)
594 writereg(dev
, PP_IA
+i
*2, dev
->dev_addr
[i
*2] | (dev
->dev_addr
[i
*2+1] << 8));
601 static struct net_device
*dev_cs89x0
;
604 module_param(debug
, int, 0);
605 MODULE_PARM_DESC(debug
, "CS89[02]0 debug level (0-5)");
606 MODULE_LICENSE("GPL");
612 dev_cs89x0
= mac89x0_probe(-1);
613 if (IS_ERR(dev_cs89x0
)) {
614 printk(KERN_WARNING
"mac89x0.c: No card found\n");
615 return PTR_ERR(dev_cs89x0
);
623 unregister_netdev(dev_cs89x0
);
624 nubus_writew(0, dev_cs89x0
->base_addr
+ ADD_PORT
);
625 free_netdev(dev_cs89x0
);
631 * 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"
633 * kept-new-versions: 5