m68k: Some network drivers do not check the platform
[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         DECLARE_MAC_BUF(mac);
185
186         if (!MACH_IS_MAC)
187                 return ERR_PTR(-ENODEV);
188
189         dev = alloc_etherdev(sizeof(struct net_local));
190         if (!dev)
191                 return ERR_PTR(-ENOMEM);
192
193         if (unit >= 0) {
194                 sprintf(dev->name, "eth%d", unit);
195                 netdev_boot_setup_check(dev);
196         }
197
198         if (once_is_enough)
199                 goto out;
200         once_is_enough = 1;
201
202         /* We might have to parameterize this later */
203         slot = 0xE;
204         /* Get out now if there's a real NuBus card in slot E */
205         if (nubus_find_slot(slot, NULL) != NULL)
206                 goto out;
207
208         /* The pseudo-ISA bits always live at offset 0x300 (gee,
209            wonder why...) */
210         ioaddr = (unsigned long)
211                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
212         {
213                 unsigned long flags;
214                 int card_present;
215
216                 local_irq_save(flags);
217                 card_present = hwreg_present((void*) ioaddr+4)
218                   && hwreg_present((void*) ioaddr + DATA_PORT);
219                 local_irq_restore(flags);
220
221                 if (!card_present)
222                         goto out;
223         }
224
225         nubus_writew(0, ioaddr + ADD_PORT);
226         sig = nubus_readw(ioaddr + DATA_PORT);
227         if (sig != swab16(CHIP_EISA_ID_SIG))
228                 goto out;
229
230         /* Initialize the net_device structure. */
231         lp = netdev_priv(dev);
232
233         /* Fill in the 'dev' fields. */
234         dev->base_addr = ioaddr;
235         dev->mem_start = (unsigned long)
236                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
237         dev->mem_end = dev->mem_start + 0x1000;
238
239         /* Turn on shared memory */
240         writereg_io(dev, PP_BusCTL, MEMORY_ON);
241
242         /* get the chip type */
243         rev_type = readreg(dev, PRODUCT_ID_ADD);
244         lp->chip_type = rev_type &~ REVISON_BITS;
245         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
246
247         /* Check the chip type and revision in order to set the correct send command
248         CS8920 revision C and CS8900 revision F can use the faster send. */
249         lp->send_cmd = TX_AFTER_381;
250         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
251                 lp->send_cmd = TX_NOW;
252         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
253                 lp->send_cmd = TX_NOW;
254
255         if (net_debug && version_printed++ == 0)
256                 printk(version);
257
258         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
259                dev->name,
260                lp->chip_type==CS8900?'0':'2',
261                lp->chip_type==CS8920M?"M":"",
262                lp->chip_revision,
263                dev->base_addr);
264
265         /* Try to read the MAC address */
266         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
267                 printk("\nmac89x0: No EEPROM, giving up now.\n");
268                 goto out1;
269         } else {
270                 for (i = 0; i < ETH_ALEN; i += 2) {
271                         /* Big-endian (why??!) */
272                         unsigned short s = readreg(dev, PP_IA + i);
273                         dev->dev_addr[i] = s >> 8;
274                         dev->dev_addr[i+1] = s & 0xff;
275                 }
276         }
277
278         dev->irq = SLOT2IRQ(slot);
279
280         /* print the IRQ and ethernet address. */
281
282         printk(" IRQ %d ADDR %s\n",
283                dev->irq, print_mac(mac, dev->dev_addr));
284
285         dev->open               = net_open;
286         dev->stop               = net_close;
287         dev->hard_start_xmit = net_send_packet;
288         dev->get_stats  = net_get_stats;
289         dev->set_multicast_list = &set_multicast_list;
290         dev->set_mac_address = &set_mac_address;
291
292         err = register_netdev(dev);
293         if (err)
294                 goto out1;
295         return NULL;
296 out1:
297         nubus_writew(0, dev->base_addr + ADD_PORT);
298 out:
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. */
305 void __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    */
328 static int
329 net_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
374 static int
375 net_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 1;
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->trans_start = jiffies;
410         dev_kfree_skb (skb);
411
412         return 0;
413 }
414
415 /* The typical workload of the driver:
416    Handle the network interface interrupts. */
417 static irqreturn_t net_interrupt(int irq, void *dev_id)
418 {
419         struct net_device *dev = dev_id;
420         struct net_local *lp;
421         int ioaddr, status;
422
423         if (dev == NULL) {
424                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
425                 return IRQ_NONE;
426         }
427
428         ioaddr = dev->base_addr;
429         lp = netdev_priv(dev);
430
431         /* we MUST read all the events out of the ISQ, otherwise we'll never
432            get interrupted again.  As a consequence, we can't have any limit
433            on the number of times we loop in the interrupt handler.  The
434            hardware guarantees that eventually we'll run out of events.  Of
435            course, if you're on a slow machine, and packets are arriving
436            faster than you can read them off, you're screwed.  Hasta la
437            vista, baby!  */
438         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
439                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
440                 switch(status & ISQ_EVENT_MASK) {
441                 case ISQ_RECEIVER_EVENT:
442                         /* Got a packet(s). */
443                         net_rx(dev);
444                         break;
445                 case ISQ_TRANSMITTER_EVENT:
446                         lp->stats.tx_packets++;
447                         netif_wake_queue(dev);
448                         if ((status & TX_OK) == 0) lp->stats.tx_errors++;
449                         if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
450                         if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
451                         if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
452                         if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
453                         break;
454                 case ISQ_BUFFER_EVENT:
455                         if (status & READY_FOR_TX) {
456                                 /* we tried to transmit a packet earlier,
457                                    but inexplicably ran out of buffers.
458                                    That shouldn't happen since we only ever
459                                    load one packet.  Shrug.  Do the right
460                                    thing anyway. */
461                                 netif_wake_queue(dev);
462                         }
463                         if (status & TX_UNDERRUN) {
464                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
465                                 lp->send_underrun++;
466                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
467                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
468                         }
469                         break;
470                 case ISQ_RX_MISS_EVENT:
471                         lp->stats.rx_missed_errors += (status >>6);
472                         break;
473                 case ISQ_TX_COL_EVENT:
474                         lp->stats.collisions += (status >>6);
475                         break;
476                 }
477         }
478         return IRQ_HANDLED;
479 }
480
481 /* We have a good packet(s), get it/them out of the buffers. */
482 static void
483 net_rx(struct net_device *dev)
484 {
485         struct net_local *lp = netdev_priv(dev);
486         struct sk_buff *skb;
487         int status, length;
488
489         status = readreg(dev, PP_RxStatus);
490         if ((status & RX_OK) == 0) {
491                 lp->stats.rx_errors++;
492                 if (status & RX_RUNT) lp->stats.rx_length_errors++;
493                 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
494                 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
495                         /* per str 172 */
496                         lp->stats.rx_crc_errors++;
497                 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
498                 return;
499         }
500
501         length = readreg(dev, PP_RxLength);
502         /* Malloc up new buffer. */
503         skb = alloc_skb(length, GFP_ATOMIC);
504         if (skb == NULL) {
505                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
506                 lp->stats.rx_dropped++;
507                 return;
508         }
509         skb_put(skb, length);
510
511         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
512                                 length);
513
514         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
515                                  dev->name, length,
516                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
517                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
518
519         skb->protocol=eth_type_trans(skb,dev);
520         netif_rx(skb);
521         dev->last_rx = jiffies;
522         lp->stats.rx_packets++;
523         lp->stats.rx_bytes += length;
524 }
525
526 /* The inverse routine to net_open(). */
527 static int
528 net_close(struct net_device *dev)
529 {
530
531         writereg(dev, PP_RxCFG, 0);
532         writereg(dev, PP_TxCFG, 0);
533         writereg(dev, PP_BufCFG, 0);
534         writereg(dev, PP_BusCTL, 0);
535
536         netif_stop_queue(dev);
537
538         free_irq(dev->irq, dev);
539
540         /* Update the statistics here. */
541
542         return 0;
543
544 }
545
546 /* Get the current statistics.  This may be called with the card open or
547    closed. */
548 static struct net_device_stats *
549 net_get_stats(struct net_device *dev)
550 {
551         struct net_local *lp = netdev_priv(dev);
552         unsigned long flags;
553
554         local_irq_save(flags);
555         /* Update the statistics from the device registers. */
556         lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
557         lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
558         local_irq_restore(flags);
559
560         return &lp->stats;
561 }
562
563 static void set_multicast_list(struct net_device *dev)
564 {
565         struct net_local *lp = netdev_priv(dev);
566
567         if(dev->flags&IFF_PROMISC)
568         {
569                 lp->rx_mode = RX_ALL_ACCEPT;
570         }
571         else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
572         {
573                 /* The multicast-accept list is initialized to accept-all, and we
574                    rely on higher-level filtering for now. */
575                 lp->rx_mode = RX_MULTCAST_ACCEPT;
576         }
577         else
578                 lp->rx_mode = 0;
579
580         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
581
582         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
583         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
584              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
585 }
586
587
588 static int set_mac_address(struct net_device *dev, void *addr)
589 {
590         int i;
591         printk("%s: Setting MAC address to ", dev->name);
592         for (i = 0; i < 6; i++)
593                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
594         printk(".\n");
595         /* set the Ethernet address */
596         for (i=0; i < ETH_ALEN/2; i++)
597                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
598
599         return 0;
600 }
601
602 #ifdef MODULE
603
604 static struct net_device *dev_cs89x0;
605 static int debug;
606
607 module_param(debug, int, 0);
608 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
609 MODULE_LICENSE("GPL");
610
611 int __init
612 init_module(void)
613 {
614         net_debug = debug;
615         dev_cs89x0 = mac89x0_probe(-1);
616         if (IS_ERR(dev_cs89x0)) {
617                 printk(KERN_WARNING "mac89x0.c: No card found\n");
618                 return PTR_ERR(dev_cs89x0);
619         }
620         return 0;
621 }
622
623 void
624 cleanup_module(void)
625 {
626         unregister_netdev(dev_cs89x0);
627         nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
628         free_netdev(dev_cs89x0);
629 }
630 #endif /* MODULE */
631
632 /*
633  * Local variables:
634  *  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"
635  *  version-control: t
636  *  kept-new-versions: 5
637  *  c-indent-level: 8
638  *  tab-width: 8
639  * End:
640  *
641  */