drivers/net: Kill now superfluous ->last_rx stores.
[linux-2.6.git] / drivers / net / mac89x0.c
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
185         if (!MACH_IS_MAC)
186                 return ERR_PTR(-ENODEV);
187
188         dev = alloc_etherdev(sizeof(struct net_local));
189         if (!dev)
190                 return ERR_PTR(-ENOMEM);
191
192         if (unit >= 0) {
193                 sprintf(dev->name, "eth%d", unit);
194                 netdev_boot_setup_check(dev);
195         }
196
197         if (once_is_enough)
198                 goto out;
199         once_is_enough = 1;
200
201         /* We might have to parameterize this later */
202         slot = 0xE;
203         /* Get out now if there's a real NuBus card in slot E */
204         if (nubus_find_slot(slot, NULL) != NULL)
205                 goto out;
206
207         /* The pseudo-ISA bits always live at offset 0x300 (gee,
208            wonder why...) */
209         ioaddr = (unsigned long)
210                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
211         {
212                 unsigned long flags;
213                 int card_present;
214
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);
219
220                 if (!card_present)
221                         goto out;
222         }
223
224         nubus_writew(0, ioaddr + ADD_PORT);
225         sig = nubus_readw(ioaddr + DATA_PORT);
226         if (sig != swab16(CHIP_EISA_ID_SIG))
227                 goto out;
228
229         /* Initialize the net_device structure. */
230         lp = netdev_priv(dev);
231
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;
237
238         /* Turn on shared memory */
239         writereg_io(dev, PP_BusCTL, MEMORY_ON);
240
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';
245
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;
253
254         if (net_debug && version_printed++ == 0)
255                 printk(version);
256
257         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
258                dev->name,
259                lp->chip_type==CS8900?'0':'2',
260                lp->chip_type==CS8920M?"M":"",
261                lp->chip_revision,
262                dev->base_addr);
263
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");
267                 goto out1;
268         } else {
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;
274                 }
275         }
276
277         dev->irq = SLOT2IRQ(slot);
278
279         /* print the IRQ and ethernet address. */
280
281         printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
282
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;
289
290         err = register_netdev(dev);
291         if (err)
292                 goto out1;
293         return NULL;
294 out1:
295         nubus_writew(0, dev->base_addr + ADD_PORT);
296 out:
297         free_netdev(dev);
298         return ERR_PTR(err);
299 }
300
301 #if 0
302 /* This is useful for something, but I don't know what yet. */
303 void __init reset_chip(struct net_device *dev)
304 {
305         int reset_start_time;
306
307         writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
308
309         /* wait 30 ms */
310         msleep_interruptible(30);
311
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)
315                 ;
316 }
317 #endif
318
319 /* Open/initialize the board.  This is called (in the current kernel)
320    sometime after booting when the 'ifconfig' program is run.
321
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.
325    */
326 static int
327 net_open(struct net_device *dev)
328 {
329         struct net_local *lp = netdev_priv(dev);
330         int i;
331
332         /* Disable the interrupt for now */
333         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
334
335         /* Grab the interrupt */
336         if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
337                 return -EAGAIN;
338
339         /* Set up the IRQ - Apparently magic */
340         if (lp->chip_type == CS8900)
341                 writereg(dev, PP_CS8900_ISAINT, 0);
342         else
343                 writereg(dev, PP_CS8920_ISAINT, 0);
344
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));
348
349         /* Turn on both receive and transmit operations */
350         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
351
352         /* Receive only error free packets addressed to this card */
353         lp->rx_mode = 0;
354         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
355
356         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
357
358         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
359
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);
362
363         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
364                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
365
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);
369         return 0;
370 }
371
372 static int
373 net_send_packet(struct sk_buff *skb, struct net_device *dev)
374 {
375         struct net_local *lp = netdev_priv(dev);
376         unsigned long flags;
377
378         if (net_debug > 3)
379                 printk("%s: sent %d byte packet of type %x\n",
380                        dev->name, skb->len,
381                        (skb->data[ETH_ALEN+ETH_ALEN] << 8)
382                        | skb->data[ETH_ALEN+ETH_ALEN+1]);
383
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);
389
390         /* initiate a transmit sequence */
391         writereg(dev, PP_TxCMD, lp->send_cmd);
392         writereg(dev, PP_TxLength, skb->len);
393
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);
399                 return 1;
400         }
401
402         /* Write the contents of the packet */
403         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
404                                   skb->len+1);
405
406         local_irq_restore(flags);
407         dev->trans_start = jiffies;
408         dev_kfree_skb (skb);
409
410         return 0;
411 }
412
413 /* The typical workload of the driver:
414    Handle the network interface interrupts. */
415 static irqreturn_t net_interrupt(int irq, void *dev_id)
416 {
417         struct net_device *dev = dev_id;
418         struct net_local *lp;
419         int ioaddr, status;
420
421         if (dev == NULL) {
422                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
423                 return IRQ_NONE;
424         }
425
426         ioaddr = dev->base_addr;
427         lp = netdev_priv(dev);
428
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
435            vista, baby!  */
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). */
441                         net_rx(dev);
442                         break;
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++;
451                         break;
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
458                                    thing anyway. */
459                                 netif_wake_queue(dev);
460                         }
461                         if (status & TX_UNDERRUN) {
462                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
463                                 lp->send_underrun++;
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;
466                         }
467                         break;
468                 case ISQ_RX_MISS_EVENT:
469                         lp->stats.rx_missed_errors += (status >>6);
470                         break;
471                 case ISQ_TX_COL_EVENT:
472                         lp->stats.collisions += (status >>6);
473                         break;
474                 }
475         }
476         return IRQ_HANDLED;
477 }
478
479 /* We have a good packet(s), get it/them out of the buffers. */
480 static void
481 net_rx(struct net_device *dev)
482 {
483         struct net_local *lp = netdev_priv(dev);
484         struct sk_buff *skb;
485         int status, length;
486
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)))
493                         /* per str 172 */
494                         lp->stats.rx_crc_errors++;
495                 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
496                 return;
497         }
498
499         length = readreg(dev, PP_RxLength);
500         /* Malloc up new buffer. */
501         skb = alloc_skb(length, GFP_ATOMIC);
502         if (skb == NULL) {
503                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
504                 lp->stats.rx_dropped++;
505                 return;
506         }
507         skb_put(skb, length);
508
509         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
510                                 length);
511
512         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
513                                  dev->name, length,
514                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
515                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
516
517         skb->protocol=eth_type_trans(skb,dev);
518         netif_rx(skb);
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  */