Merge branch 'fix/asoc' into topic/asoc
[linux-2.6] / 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 static const struct net_device_ops mac89x0_netdev_ops = {
172         .ndo_open               = net_open,
173         .ndo_stop               = net_close,
174         .ndo_start_xmit         = net_send_packet,
175         .ndo_get_stats          = net_get_stats,
176         .ndo_set_multicast_list = set_multicast_list,
177         .ndo_set_mac_address    = set_mac_address,
178         .ndo_validate_addr      = eth_validate_addr,
179         .ndo_change_mtu         = eth_change_mtu,
180 };
181
182 /* Probe for the CS8900 card in slot E.  We won't bother looking
183    anywhere else until we have a really good reason to do so. */
184 struct net_device * __init mac89x0_probe(int unit)
185 {
186         struct net_device *dev;
187         static int once_is_enough;
188         struct net_local *lp;
189         static unsigned version_printed;
190         int i, slot;
191         unsigned rev_type = 0;
192         unsigned long ioaddr;
193         unsigned short sig;
194         int err = -ENODEV;
195
196         if (!MACH_IS_MAC)
197                 return ERR_PTR(-ENODEV);
198
199         dev = alloc_etherdev(sizeof(struct net_local));
200         if (!dev)
201                 return ERR_PTR(-ENOMEM);
202
203         if (unit >= 0) {
204                 sprintf(dev->name, "eth%d", unit);
205                 netdev_boot_setup_check(dev);
206         }
207
208         if (once_is_enough)
209                 goto out;
210         once_is_enough = 1;
211
212         /* We might have to parameterize this later */
213         slot = 0xE;
214         /* Get out now if there's a real NuBus card in slot E */
215         if (nubus_find_slot(slot, NULL) != NULL)
216                 goto out;
217
218         /* The pseudo-ISA bits always live at offset 0x300 (gee,
219            wonder why...) */
220         ioaddr = (unsigned long)
221                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
222         {
223                 unsigned long flags;
224                 int card_present;
225
226                 local_irq_save(flags);
227                 card_present = hwreg_present((void*) ioaddr+4)
228                   && hwreg_present((void*) ioaddr + DATA_PORT);
229                 local_irq_restore(flags);
230
231                 if (!card_present)
232                         goto out;
233         }
234
235         nubus_writew(0, ioaddr + ADD_PORT);
236         sig = nubus_readw(ioaddr + DATA_PORT);
237         if (sig != swab16(CHIP_EISA_ID_SIG))
238                 goto out;
239
240         /* Initialize the net_device structure. */
241         lp = netdev_priv(dev);
242
243         /* Fill in the 'dev' fields. */
244         dev->base_addr = ioaddr;
245         dev->mem_start = (unsigned long)
246                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
247         dev->mem_end = dev->mem_start + 0x1000;
248
249         /* Turn on shared memory */
250         writereg_io(dev, PP_BusCTL, MEMORY_ON);
251
252         /* get the chip type */
253         rev_type = readreg(dev, PRODUCT_ID_ADD);
254         lp->chip_type = rev_type &~ REVISON_BITS;
255         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
256
257         /* Check the chip type and revision in order to set the correct send command
258         CS8920 revision C and CS8900 revision F can use the faster send. */
259         lp->send_cmd = TX_AFTER_381;
260         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
261                 lp->send_cmd = TX_NOW;
262         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
263                 lp->send_cmd = TX_NOW;
264
265         if (net_debug && version_printed++ == 0)
266                 printk(version);
267
268         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
269                dev->name,
270                lp->chip_type==CS8900?'0':'2',
271                lp->chip_type==CS8920M?"M":"",
272                lp->chip_revision,
273                dev->base_addr);
274
275         /* Try to read the MAC address */
276         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
277                 printk("\nmac89x0: No EEPROM, giving up now.\n");
278                 goto out1;
279         } else {
280                 for (i = 0; i < ETH_ALEN; i += 2) {
281                         /* Big-endian (why??!) */
282                         unsigned short s = readreg(dev, PP_IA + i);
283                         dev->dev_addr[i] = s >> 8;
284                         dev->dev_addr[i+1] = s & 0xff;
285                 }
286         }
287
288         dev->irq = SLOT2IRQ(slot);
289
290         /* print the IRQ and ethernet address. */
291
292         printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
293
294         dev->netdev_ops         = &mac89x0_netdev_ops;
295
296         err = register_netdev(dev);
297         if (err)
298                 goto out1;
299         return NULL;
300 out1:
301         nubus_writew(0, dev->base_addr + ADD_PORT);
302 out:
303         free_netdev(dev);
304         return ERR_PTR(err);
305 }
306
307 #if 0
308 /* This is useful for something, but I don't know what yet. */
309 void __init reset_chip(struct net_device *dev)
310 {
311         int reset_start_time;
312
313         writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
314
315         /* wait 30 ms */
316         msleep_interruptible(30);
317
318         /* Wait until the chip is reset */
319         reset_start_time = jiffies;
320         while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
321                 ;
322 }
323 #endif
324
325 /* Open/initialize the board.  This is called (in the current kernel)
326    sometime after booting when the 'ifconfig' program is run.
327
328    This routine should set everything up anew at each open, even
329    registers that "should" only need to be set once at boot, so that
330    there is non-reboot way to recover if something goes wrong.
331    */
332 static int
333 net_open(struct net_device *dev)
334 {
335         struct net_local *lp = netdev_priv(dev);
336         int i;
337
338         /* Disable the interrupt for now */
339         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
340
341         /* Grab the interrupt */
342         if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
343                 return -EAGAIN;
344
345         /* Set up the IRQ - Apparently magic */
346         if (lp->chip_type == CS8900)
347                 writereg(dev, PP_CS8900_ISAINT, 0);
348         else
349                 writereg(dev, PP_CS8920_ISAINT, 0);
350
351         /* set the Ethernet address */
352         for (i=0; i < ETH_ALEN/2; i++)
353                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
354
355         /* Turn on both receive and transmit operations */
356         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
357
358         /* Receive only error free packets addressed to this card */
359         lp->rx_mode = 0;
360         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
361
362         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
363
364         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
365
366         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
367                TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
368
369         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
370                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
371
372         /* now that we've got our act together, enable everything */
373         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
374         netif_start_queue(dev);
375         return 0;
376 }
377
378 static int
379 net_send_packet(struct sk_buff *skb, struct net_device *dev)
380 {
381         struct net_local *lp = netdev_priv(dev);
382         unsigned long flags;
383
384         if (net_debug > 3)
385                 printk("%s: sent %d byte packet of type %x\n",
386                        dev->name, skb->len,
387                        (skb->data[ETH_ALEN+ETH_ALEN] << 8)
388                        | skb->data[ETH_ALEN+ETH_ALEN+1]);
389
390         /* keep the upload from being interrupted, since we
391            ask the chip to start transmitting before the
392            whole packet has been completely uploaded. */
393         local_irq_save(flags);
394         netif_stop_queue(dev);
395
396         /* initiate a transmit sequence */
397         writereg(dev, PP_TxCMD, lp->send_cmd);
398         writereg(dev, PP_TxLength, skb->len);
399
400         /* Test to see if the chip has allocated memory for the packet */
401         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
402                 /* Gasp!  It hasn't.  But that shouldn't happen since
403                    we're waiting for TxOk, so return 1 and requeue this packet. */
404                 local_irq_restore(flags);
405                 return 1;
406         }
407
408         /* Write the contents of the packet */
409         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
410                                   skb->len+1);
411
412         local_irq_restore(flags);
413         dev->trans_start = jiffies;
414         dev_kfree_skb (skb);
415
416         return 0;
417 }
418
419 /* The typical workload of the driver:
420    Handle the network interface interrupts. */
421 static irqreturn_t net_interrupt(int irq, void *dev_id)
422 {
423         struct net_device *dev = dev_id;
424         struct net_local *lp;
425         int ioaddr, status;
426
427         if (dev == NULL) {
428                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
429                 return IRQ_NONE;
430         }
431
432         ioaddr = dev->base_addr;
433         lp = netdev_priv(dev);
434
435         /* we MUST read all the events out of the ISQ, otherwise we'll never
436            get interrupted again.  As a consequence, we can't have any limit
437            on the number of times we loop in the interrupt handler.  The
438            hardware guarantees that eventually we'll run out of events.  Of
439            course, if you're on a slow machine, and packets are arriving
440            faster than you can read them off, you're screwed.  Hasta la
441            vista, baby!  */
442         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
443                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
444                 switch(status & ISQ_EVENT_MASK) {
445                 case ISQ_RECEIVER_EVENT:
446                         /* Got a packet(s). */
447                         net_rx(dev);
448                         break;
449                 case ISQ_TRANSMITTER_EVENT:
450                         lp->stats.tx_packets++;
451                         netif_wake_queue(dev);
452                         if ((status & TX_OK) == 0) lp->stats.tx_errors++;
453                         if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
454                         if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
455                         if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
456                         if (status & TX_16_COL) lp->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                         lp->stats.rx_missed_errors += (status >>6);
476                         break;
477                 case ISQ_TX_COL_EVENT:
478                         lp->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. */
486 static void
487 net_rx(struct net_device *dev)
488 {
489         struct net_local *lp = netdev_priv(dev);
490         struct sk_buff *skb;
491         int status, length;
492
493         status = readreg(dev, PP_RxStatus);
494         if ((status & RX_OK) == 0) {
495                 lp->stats.rx_errors++;
496                 if (status & RX_RUNT) lp->stats.rx_length_errors++;
497                 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
498                 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
499                         /* per str 172 */
500                         lp->stats.rx_crc_errors++;
501                 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
502                 return;
503         }
504
505         length = readreg(dev, PP_RxLength);
506         /* Malloc up new buffer. */
507         skb = alloc_skb(length, GFP_ATOMIC);
508         if (skb == NULL) {
509                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
510                 lp->stats.rx_dropped++;
511                 return;
512         }
513         skb_put(skb, length);
514
515         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
516                                 length);
517
518         if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
519                                  dev->name, length,
520                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
521                                  | skb->data[ETH_ALEN+ETH_ALEN+1]);
522
523         skb->protocol=eth_type_trans(skb,dev);
524         netif_rx(skb);
525         lp->stats.rx_packets++;
526         lp->stats.rx_bytes += length;
527 }
528
529 /* The inverse routine to net_open(). */
530 static int
531 net_close(struct net_device *dev)
532 {
533
534         writereg(dev, PP_RxCFG, 0);
535         writereg(dev, PP_TxCFG, 0);
536         writereg(dev, PP_BufCFG, 0);
537         writereg(dev, PP_BusCTL, 0);
538
539         netif_stop_queue(dev);
540
541         free_irq(dev->irq, dev);
542
543         /* Update the statistics here. */
544
545         return 0;
546
547 }
548
549 /* Get the current statistics.  This may be called with the card open or
550    closed. */
551 static struct net_device_stats *
552 net_get_stats(struct net_device *dev)
553 {
554         struct net_local *lp = netdev_priv(dev);
555         unsigned long flags;
556
557         local_irq_save(flags);
558         /* Update the statistics from the device registers. */
559         lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
560         lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
561         local_irq_restore(flags);
562
563         return &lp->stats;
564 }
565
566 static void set_multicast_list(struct net_device *dev)
567 {
568         struct net_local *lp = netdev_priv(dev);
569
570         if(dev->flags&IFF_PROMISC)
571         {
572                 lp->rx_mode = RX_ALL_ACCEPT;
573         }
574         else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
575         {
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
591 static int set_mac_address(struct net_device *dev, void *addr)
592 {
593         int i;
594         printk("%s: Setting MAC address to ", dev->name);
595         for (i = 0; i < 6; i++)
596                 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
597         printk(".\n");
598         /* set the Ethernet address */
599         for (i=0; i < ETH_ALEN/2; i++)
600                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
601
602         return 0;
603 }
604
605 #ifdef MODULE
606
607 static struct net_device *dev_cs89x0;
608 static int debug;
609
610 module_param(debug, int, 0);
611 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
612 MODULE_LICENSE("GPL");
613
614 int __init
615 init_module(void)
616 {
617         net_debug = debug;
618         dev_cs89x0 = mac89x0_probe(-1);
619         if (IS_ERR(dev_cs89x0)) {
620                 printk(KERN_WARNING "mac89x0.c: No card found\n");
621                 return PTR_ERR(dev_cs89x0);
622         }
623         return 0;
624 }
625
626 void
627 cleanup_module(void)
628 {
629         unregister_netdev(dev_cs89x0);
630         nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
631         free_netdev(dev_cs89x0);
632 }
633 #endif /* MODULE */