blob: 69fa4ef64dd24d99f6b7981735578d1f7aae65c5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040015 : Changes for Linux 2.0 compatibility.
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 : 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040021 : that the module is in use and wouldn't eject the
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 : 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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
30
31 David Huggins-Daines <dhd@debian.org>
Jeff Garzik6aa20a22006-09-13 13:24:59 -040032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 Split this off into mac89x0.c, and gutted it of all parts which are
34 not relevant to the existing CS8900 cards on the Macintosh
35 (i.e. basically the Daynaport CS and LC cards). To be precise:
36
37 * Removed all the media-detection stuff, because these cards are
38 TP-only.
39
40 * Lobotomized the ISA interrupt bogosity, because these cards use
41 a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
42
43 * Basically eliminated everything not relevant to getting the
44 cards minimally functioning on the Macintosh.
45
46 I might add that these cards are badly designed even from the Mac
47 standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
48 I/O space and NuBus interrupts for these cards, but neglected to
49 provide anything even remotely resembling a NuBus ROM. Therefore we
50 have to probe for them in a brain-damaged ISA-like fashion.
51
52 Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
53 check kmalloc and release the allocated memory on failure in
54 mac89x0_probe and in init_module
55 use local_irq_{save,restore}(flags) in net_get_stat, not just
56 local_irq_{dis,en}able()
57*/
58
59static char *version =
60"cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
61
62/* ======================= configure the driver here ======================= */
63
64/* use 0 for production, 1 for verification, >2 for debug */
65#ifndef NET_DEBUG
66#define NET_DEBUG 0
67#endif
68
69/* ======================= end of configuration ======================= */
70
71
72/* Always include 'config.h' first in case the user wants to turn on
73 or override something. */
74#include <linux/module.h>
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/*
77 Sources:
78
79 Crynwr packet driver epktisa.
80
81 Crystal Semiconductor data sheets.
82
83*/
84
85#include <linux/kernel.h>
86#include <linux/types.h>
87#include <linux/fcntl.h>
88#include <linux/interrupt.h>
89#include <linux/ioport.h>
90#include <linux/in.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070091#include <linux/string.h>
92#include <linux/nubus.h>
93#include <linux/errno.h>
94#include <linux/init.h>
95#include <linux/netdevice.h>
96#include <linux/etherdevice.h>
97#include <linux/skbuff.h>
98#include <linux/delay.h>
Jiri Slaby1977f032007-10-18 23:40:25 -070099#include <linux/bitops.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900100#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103#include <asm/io.h>
104#include <asm/hwtest.h>
105#include <asm/macints.h>
106
107#include "cs89x0.h"
108
109static unsigned int net_debug = NET_DEBUG;
110
111/* Information that need to be kept for each board. */
112struct net_local {
113 struct net_device_stats stats;
114 int chip_type; /* one of: CS8900, CS8920, CS8920M */
115 char chip_revision; /* revision letter of the chip ('A'...) */
116 int send_cmd; /* the propercommand used to send a packet. */
117 int rx_mode;
118 int curr_rx_cfg;
119 int send_underrun; /* keep track of how many underruns in a row we get */
120 struct sk_buff *skb;
121};
122
123/* Index to functions, as function prototypes. */
124
125#if 0
126extern void reset_chip(struct net_device *dev);
127#endif
128static int net_open(struct net_device *dev);
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200129static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100130static irqreturn_t net_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131static void set_multicast_list(struct net_device *dev);
132static void net_rx(struct net_device *dev);
133static int net_close(struct net_device *dev);
134static struct net_device_stats *net_get_stats(struct net_device *dev);
135static int set_mac_address(struct net_device *dev, void *addr);
136
137
138/* Example routines you must write ;->. */
139#define tx_done(dev) 1
140
141/* For reading/writing registers ISA-style */
142static inline int
143readreg_io(struct net_device *dev, int portno)
144{
145 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
146 return swab16(nubus_readw(dev->base_addr + DATA_PORT));
147}
148
149static inline void
150writereg_io(struct net_device *dev, int portno, int value)
151{
152 nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
153 nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
154}
155
156/* These are for reading/writing registers in shared memory */
157static inline int
158readreg(struct net_device *dev, int portno)
159{
160 return swab16(nubus_readw(dev->mem_start + portno));
161}
162
163static inline void
164writereg(struct net_device *dev, int portno, int value)
165{
166 nubus_writew(swab16(value), dev->mem_start + portno);
167}
168
Alexander Beregalovd0174ae2009-04-11 07:43:11 +0000169static const struct net_device_ops mac89x0_netdev_ops = {
170 .ndo_open = net_open,
171 .ndo_stop = net_close,
172 .ndo_start_xmit = net_send_packet,
173 .ndo_get_stats = net_get_stats,
174 .ndo_set_multicast_list = set_multicast_list,
175 .ndo_set_mac_address = set_mac_address,
176 .ndo_validate_addr = eth_validate_addr,
177 .ndo_change_mtu = eth_change_mtu,
178};
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180/* Probe for the CS8900 card in slot E. We won't bother looking
181 anywhere else until we have a really good reason to do so. */
182struct net_device * __init mac89x0_probe(int unit)
183{
184 struct net_device *dev;
185 static int once_is_enough;
186 struct net_local *lp;
187 static unsigned version_printed;
188 int i, slot;
189 unsigned rev_type = 0;
190 unsigned long ioaddr;
191 unsigned short sig;
192 int err = -ENODEV;
193
Geert Uytterhoeven0f734482008-05-18 20:47:16 +0200194 if (!MACH_IS_MAC)
195 return ERR_PTR(-ENODEV);
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 dev = alloc_etherdev(sizeof(struct net_local));
198 if (!dev)
199 return ERR_PTR(-ENOMEM);
200
201 if (unit >= 0) {
202 sprintf(dev->name, "eth%d", unit);
203 netdev_boot_setup_check(dev);
204 }
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (once_is_enough)
207 goto out;
208 once_is_enough = 1;
209
210 /* We might have to parameterize this later */
211 slot = 0xE;
212 /* Get out now if there's a real NuBus card in slot E */
213 if (nubus_find_slot(slot, NULL) != NULL)
214 goto out;
215
216 /* The pseudo-ISA bits always live at offset 0x300 (gee,
217 wonder why...) */
218 ioaddr = (unsigned long)
219 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
220 {
221 unsigned long flags;
222 int card_present;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 local_irq_save(flags);
Joe Perches8e95a202009-12-03 07:58:21 +0000225 card_present = (hwreg_present((void*) ioaddr+4) &&
226 hwreg_present((void*) ioaddr + DATA_PORT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 local_irq_restore(flags);
228
229 if (!card_present)
230 goto out;
231 }
232
233 nubus_writew(0, ioaddr + ADD_PORT);
234 sig = nubus_readw(ioaddr + DATA_PORT);
235 if (sig != swab16(CHIP_EISA_ID_SIG))
236 goto out;
237
238 /* Initialize the net_device structure. */
239 lp = netdev_priv(dev);
240
241 /* Fill in the 'dev' fields. */
242 dev->base_addr = ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400243 dev->mem_start = (unsigned long)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
245 dev->mem_end = dev->mem_start + 0x1000;
246
247 /* Turn on shared memory */
248 writereg_io(dev, PP_BusCTL, MEMORY_ON);
249
250 /* get the chip type */
251 rev_type = readreg(dev, PRODUCT_ID_ADD);
252 lp->chip_type = rev_type &~ REVISON_BITS;
253 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
254
255 /* Check the chip type and revision in order to set the correct send command
256 CS8920 revision C and CS8900 revision F can use the faster send. */
257 lp->send_cmd = TX_AFTER_381;
258 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
259 lp->send_cmd = TX_NOW;
260 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
261 lp->send_cmd = TX_NOW;
262
263 if (net_debug && version_printed++ == 0)
264 printk(version);
265
266 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
267 dev->name,
268 lp->chip_type==CS8900?'0':'2',
269 lp->chip_type==CS8920M?"M":"",
270 lp->chip_revision,
271 dev->base_addr);
272
273 /* Try to read the MAC address */
274 if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
275 printk("\nmac89x0: No EEPROM, giving up now.\n");
276 goto out1;
277 } else {
278 for (i = 0; i < ETH_ALEN; i += 2) {
279 /* Big-endian (why??!) */
280 unsigned short s = readreg(dev, PP_IA + i);
281 dev->dev_addr[i] = s >> 8;
282 dev->dev_addr[i+1] = s & 0xff;
283 }
284 }
285
286 dev->irq = SLOT2IRQ(slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Joe Perches0795af52007-10-03 17:59:30 -0700288 /* print the IRQ and ethernet address. */
289
Johannes Berge1749612008-10-27 15:59:26 -0700290 printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Alexander Beregalovd0174ae2009-04-11 07:43:11 +0000292 dev->netdev_ops = &mac89x0_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 err = register_netdev(dev);
295 if (err)
296 goto out1;
Al Viro79ea13c2008-01-24 02:06:46 -0800297 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298out1:
299 nubus_writew(0, dev->base_addr + ADD_PORT);
300out:
301 free_netdev(dev);
302 return ERR_PTR(err);
303}
304
305#if 0
306/* This is useful for something, but I don't know what yet. */
307void __init reset_chip(struct net_device *dev)
308{
309 int reset_start_time;
310
311 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
312
313 /* wait 30 ms */
314 msleep_interruptible(30);
315
316 /* Wait until the chip is reset */
317 reset_start_time = jiffies;
318 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
319 ;
320}
321#endif
322
323/* Open/initialize the board. This is called (in the current kernel)
324 sometime after booting when the 'ifconfig' program is run.
325
326 This routine should set everything up anew at each open, even
327 registers that "should" only need to be set once at boot, so that
328 there is non-reboot way to recover if something goes wrong.
329 */
330static int
331net_open(struct net_device *dev)
332{
333 struct net_local *lp = netdev_priv(dev);
334 int i;
335
336 /* Disable the interrupt for now */
337 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
338
339 /* Grab the interrupt */
Joe Perchesa0607fd2009-11-18 23:29:17 -0800340 if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return -EAGAIN;
342
343 /* Set up the IRQ - Apparently magic */
344 if (lp->chip_type == CS8900)
345 writereg(dev, PP_CS8900_ISAINT, 0);
346 else
347 writereg(dev, PP_CS8920_ISAINT, 0);
348
349 /* set the Ethernet address */
350 for (i=0; i < ETH_ALEN/2; i++)
351 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
352
353 /* Turn on both receive and transmit operations */
354 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
355
356 /* Receive only error free packets addressed to this card */
357 lp->rx_mode = 0;
358 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
359
360 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
361
362 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
363
364 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
365 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
366
367 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
368 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
369
370 /* now that we've got our act together, enable everything */
371 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
372 netif_start_queue(dev);
373 return 0;
374}
375
376static int
377net_send_packet(struct sk_buff *skb, struct net_device *dev)
378{
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200379 struct net_local *lp = netdev_priv(dev);
380 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200382 if (net_debug > 3)
383 printk("%s: sent %d byte packet of type %x\n",
384 dev->name, skb->len,
385 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
386 | skb->data[ETH_ALEN+ETH_ALEN+1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200388 /* keep the upload from being interrupted, since we
389 ask the chip to start transmitting before the
390 whole packet has been completely uploaded. */
391 local_irq_save(flags);
392 netif_stop_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200394 /* initiate a transmit sequence */
395 writereg(dev, PP_TxCMD, lp->send_cmd);
396 writereg(dev, PP_TxLength, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200398 /* Test to see if the chip has allocated memory for the packet */
399 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
400 /* Gasp! It hasn't. But that shouldn't happen since
401 we're waiting for TxOk, so return 1 and requeue this packet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 local_irq_restore(flags);
Patrick McHardy5b548142009-06-12 06:22:29 +0000403 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200405
406 /* Write the contents of the packet */
407 skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
408 skb->len+1);
409
410 local_irq_restore(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 dev_kfree_skb (skb);
412
Patrick McHardy6ed10652009-06-23 06:03:08 +0000413 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416/* The typical workload of the driver:
417 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100418static irqreturn_t net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419{
420 struct net_device *dev = dev_id;
421 struct net_local *lp;
422 int ioaddr, status;
423
424 if (dev == NULL) {
425 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
426 return IRQ_NONE;
427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429 ioaddr = dev->base_addr;
430 lp = netdev_priv(dev);
431
432 /* we MUST read all the events out of the ISQ, otherwise we'll never
433 get interrupted again. As a consequence, we can't have any limit
434 on the number of times we loop in the interrupt handler. The
435 hardware guarantees that eventually we'll run out of events. Of
436 course, if you're on a slow machine, and packets are arriving
437 faster than you can read them off, you're screwed. Hasta la
438 vista, baby! */
439 while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
440 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
441 switch(status & ISQ_EVENT_MASK) {
442 case ISQ_RECEIVER_EVENT:
443 /* Got a packet(s). */
444 net_rx(dev);
445 break;
446 case ISQ_TRANSMITTER_EVENT:
447 lp->stats.tx_packets++;
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200448 netif_wake_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
450 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
451 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
452 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
453 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
454 break;
455 case ISQ_BUFFER_EVENT:
456 if (status & READY_FOR_TX) {
457 /* we tried to transmit a packet earlier,
458 but inexplicably ran out of buffers.
459 That shouldn't happen since we only ever
460 load one packet. Shrug. Do the right
461 thing anyway. */
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200462 netif_wake_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
464 if (status & TX_UNDERRUN) {
465 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
466 lp->send_underrun++;
467 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
468 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
469 }
470 break;
471 case ISQ_RX_MISS_EVENT:
472 lp->stats.rx_missed_errors += (status >>6);
473 break;
474 case ISQ_TX_COL_EVENT:
475 lp->stats.collisions += (status >>6);
476 break;
477 }
478 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 return IRQ_HANDLED;
480}
481
482/* We have a good packet(s), get it/them out of the buffers. */
483static void
484net_rx(struct net_device *dev)
485{
486 struct net_local *lp = netdev_priv(dev);
487 struct sk_buff *skb;
488 int status, length;
489
490 status = readreg(dev, PP_RxStatus);
491 if ((status & RX_OK) == 0) {
492 lp->stats.rx_errors++;
493 if (status & RX_RUNT) lp->stats.rx_length_errors++;
494 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
495 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
496 /* per str 172 */
497 lp->stats.rx_crc_errors++;
498 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
499 return;
500 }
501
502 length = readreg(dev, PP_RxLength);
503 /* Malloc up new buffer. */
504 skb = alloc_skb(length, GFP_ATOMIC);
505 if (skb == NULL) {
506 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
507 lp->stats.rx_dropped++;
508 return;
509 }
510 skb_put(skb, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
Matthias Urlichs39ad2cb2007-05-01 22:32:41 +0200512 skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
513 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
516 dev->name, length,
517 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
518 | skb->data[ETH_ALEN+ETH_ALEN+1]);
519
520 skb->protocol=eth_type_trans(skb,dev);
521 netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 lp->stats.rx_packets++;
523 lp->stats.rx_bytes += length;
524}
525
526/* The inverse routine to net_open(). */
527static int
528net_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. */
548static struct net_device_stats *
549net_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
563static 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;
Jiri Pirkof9dcbcc2010-02-23 09:19:49 +0000570 } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 /* The multicast-accept list is initialized to accept-all, and we
572 rely on higher-level filtering for now. */
573 lp->rx_mode = RX_MULTCAST_ACCEPT;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400574 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 else
576 lp->rx_mode = 0;
577
578 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
579
580 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
581 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
582 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
583}
584
585
586static int set_mac_address(struct net_device *dev, void *addr)
587{
588 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 printk("%s: Setting MAC address to ", dev->name);
590 for (i = 0; i < 6; i++)
591 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
592 printk(".\n");
593 /* set the Ethernet address */
594 for (i=0; i < ETH_ALEN/2; i++)
595 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
596
597 return 0;
598}
599
600#ifdef MODULE
601
602static struct net_device *dev_cs89x0;
603static int debug;
604
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800605module_param(debug, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
607MODULE_LICENSE("GPL");
608
Al Viro446df4c2007-07-20 04:33:48 +0100609int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610init_module(void)
611{
612 net_debug = debug;
613 dev_cs89x0 = mac89x0_probe(-1);
614 if (IS_ERR(dev_cs89x0)) {
615 printk(KERN_WARNING "mac89x0.c: No card found\n");
616 return PTR_ERR(dev_cs89x0);
617 }
618 return 0;
619}
620
621void
622cleanup_module(void)
623{
624 unregister_netdev(dev_cs89x0);
625 nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
626 free_netdev(dev_cs89x0);
627}
628#endif /* MODULE */