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