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