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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
60 
61 static const char version[] =
62 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
63 
64 #include <linux/module.h>
65 
66 /*
67   Sources:
68 
69 	Crynwr packet driver epktisa.
70 
71 	Crystal Semiconductor data sheets.
72 
73 */
74 
75 #include <linux/kernel.h>
76 #include <linux/types.h>
77 #include <linux/fcntl.h>
78 #include <linux/interrupt.h>
79 #include <linux/ioport.h>
80 #include <linux/in.h>
81 #include <linux/string.h>
82 #include <linux/nubus.h>
83 #include <linux/errno.h>
84 #include <linux/init.h>
85 #include <linux/netdevice.h>
86 #include <linux/platform_device.h>
87 #include <linux/etherdevice.h>
88 #include <linux/skbuff.h>
89 #include <linux/delay.h>
90 #include <linux/bitops.h>
91 #include <linux/gfp.h>
92 
93 #include <asm/io.h>
94 #include <asm/hwtest.h>
95 #include <asm/macints.h>
96 
97 #include "cs89x0.h"
98 
99 static int debug = -1;
100 module_param(debug, int, 0);
101 MODULE_PARM_DESC(debug, "debug message level");
102 
103 /* Information that need to be kept for each board. */
104 struct net_local {
105 	int msg_enable;
106 	int chip_type;		/* one of: CS8900, CS8920, CS8920M */
107 	char chip_revision;	/* revision letter of the chip ('A'...) */
108 	int send_cmd;		/* the propercommand used to send a packet. */
109 	int rx_mode;
110 	int curr_rx_cfg;
111         int send_underrun;      /* keep track of how many underruns in a row we get */
112 };
113 
114 /* Index to functions, as function prototypes. */
115 static int net_open(struct net_device *dev);
116 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev);
117 static irqreturn_t net_interrupt(int irq, void *dev_id);
118 static void set_multicast_list(struct net_device *dev);
119 static void net_rx(struct net_device *dev);
120 static int net_close(struct net_device *dev);
121 static struct net_device_stats *net_get_stats(struct net_device *dev);
122 static int set_mac_address(struct net_device *dev, void *addr);
123 
124 /* For reading/writing registers ISA-style */
125 static inline int
126 readreg_io(struct net_device *dev, int portno)
127 {
128 	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
129 	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
130 }
131 
132 static inline void
133 writereg_io(struct net_device *dev, int portno, int value)
134 {
135 	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
136 	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
137 }
138 
139 /* These are for reading/writing registers in shared memory */
140 static inline int
141 readreg(struct net_device *dev, int portno)
142 {
143 	return swab16(nubus_readw(dev->mem_start + portno));
144 }
145 
146 static inline void
147 writereg(struct net_device *dev, int portno, int value)
148 {
149 	nubus_writew(swab16(value), dev->mem_start + portno);
150 }
151 
152 static const struct net_device_ops mac89x0_netdev_ops = {
153 	.ndo_open		= net_open,
154 	.ndo_stop		= net_close,
155 	.ndo_start_xmit		= net_send_packet,
156 	.ndo_get_stats		= net_get_stats,
157 	.ndo_set_rx_mode	= set_multicast_list,
158 	.ndo_set_mac_address	= set_mac_address,
159 	.ndo_validate_addr	= eth_validate_addr,
160 };
161 
162 /* Probe for the CS8900 card in slot E.  We won't bother looking
163    anywhere else until we have a really good reason to do so. */
164 static int mac89x0_device_probe(struct platform_device *pdev)
165 {
166 	struct net_device *dev;
167 	struct net_local *lp;
168 	int i, slot;
169 	unsigned rev_type = 0;
170 	unsigned long ioaddr;
171 	unsigned short sig;
172 	int err = -ENODEV;
173 	struct nubus_rsrc *fres;
174 
175 	dev = alloc_etherdev(sizeof(struct net_local));
176 	if (!dev)
177 		return -ENOMEM;
178 
179 	/* We might have to parameterize this later */
180 	slot = 0xE;
181 	/* Get out now if there's a real NuBus card in slot E */
182 	for_each_func_rsrc(fres)
183 		if (fres->board->slot == slot)
184 			goto out;
185 
186 	/* The pseudo-ISA bits always live at offset 0x300 (gee,
187            wonder why...) */
188 	ioaddr = (unsigned long)
189 		nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
190 	{
191 		int card_present;
192 
193 		card_present = (hwreg_present((void *)ioaddr + 4) &&
194 				hwreg_present((void *)ioaddr + DATA_PORT));
195 		if (!card_present)
196 			goto out;
197 	}
198 
199 	nubus_writew(0, ioaddr + ADD_PORT);
200 	sig = nubus_readw(ioaddr + DATA_PORT);
201 	if (sig != swab16(CHIP_EISA_ID_SIG))
202 		goto out;
203 
204 	SET_NETDEV_DEV(dev, &pdev->dev);
205 
206 	/* Initialize the net_device structure. */
207 	lp = netdev_priv(dev);
208 
209 	lp->msg_enable = netif_msg_init(debug, 0);
210 
211 	/* Fill in the 'dev' fields. */
212 	dev->base_addr = ioaddr;
213 	dev->mem_start = (unsigned long)
214 		nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
215 	dev->mem_end = dev->mem_start + 0x1000;
216 
217 	/* Turn on shared memory */
218 	writereg_io(dev, PP_BusCTL, MEMORY_ON);
219 
220 	/* get the chip type */
221 	rev_type = readreg(dev, PRODUCT_ID_ADD);
222 	lp->chip_type = rev_type &~ REVISON_BITS;
223 	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
224 
225 	/* Check the chip type and revision in order to set the correct send command
226 	CS8920 revision C and CS8900 revision F can use the faster send. */
227 	lp->send_cmd = TX_AFTER_381;
228 	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
229 		lp->send_cmd = TX_NOW;
230 	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
231 		lp->send_cmd = TX_NOW;
232 
233 	netif_dbg(lp, drv, dev, "%s", version);
234 
235 	pr_info("cs89%c0%s rev %c found at %#8lx\n",
236 		lp->chip_type == CS8900 ? '0' : '2',
237 		lp->chip_type == CS8920M ? "M" : "",
238 		lp->chip_revision, dev->base_addr);
239 
240 	/* Try to read the MAC address */
241 	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
242 		pr_info("No EEPROM, giving up now.\n");
243 		goto out1;
244         } else {
245                 for (i = 0; i < ETH_ALEN; i += 2) {
246 			/* Big-endian (why??!) */
247 			unsigned short s = readreg(dev, PP_IA + i);
248                         dev->dev_addr[i] = s >> 8;
249                         dev->dev_addr[i+1] = s & 0xff;
250                 }
251         }
252 
253 	dev->irq = SLOT2IRQ(slot);
254 
255 	/* print the IRQ and ethernet address. */
256 
257 	pr_info("MAC %pM, IRQ %d\n", dev->dev_addr, dev->irq);
258 
259 	dev->netdev_ops		= &mac89x0_netdev_ops;
260 
261 	err = register_netdev(dev);
262 	if (err)
263 		goto out1;
264 
265 	platform_set_drvdata(pdev, dev);
266 	return 0;
267 out1:
268 	nubus_writew(0, dev->base_addr + ADD_PORT);
269 out:
270 	free_netdev(dev);
271 	return err;
272 }
273 
274 /* Open/initialize the board.  This is called (in the current kernel)
275    sometime after booting when the 'ifconfig' program is run.
276 
277    This routine should set everything up anew at each open, even
278    registers that "should" only need to be set once at boot, so that
279    there is non-reboot way to recover if something goes wrong.
280    */
281 static int
282 net_open(struct net_device *dev)
283 {
284 	struct net_local *lp = netdev_priv(dev);
285 	int i;
286 
287 	/* Disable the interrupt for now */
288 	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
289 
290 	/* Grab the interrupt */
291 	if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
292 		return -EAGAIN;
293 
294 	/* Set up the IRQ - Apparently magic */
295 	if (lp->chip_type == CS8900)
296 		writereg(dev, PP_CS8900_ISAINT, 0);
297 	else
298 		writereg(dev, PP_CS8920_ISAINT, 0);
299 
300 	/* set the Ethernet address */
301 	for (i=0; i < ETH_ALEN/2; i++)
302 		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
303 
304 	/* Turn on both receive and transmit operations */
305 	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
306 
307 	/* Receive only error free packets addressed to this card */
308 	lp->rx_mode = 0;
309 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
310 
311 	lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
312 
313 	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
314 
315 	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
316 	       TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
317 
318 	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
319 		 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
320 
321 	/* now that we've got our act together, enable everything */
322 	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
323 	netif_start_queue(dev);
324 	return 0;
325 }
326 
327 static netdev_tx_t
328 net_send_packet(struct sk_buff *skb, struct net_device *dev)
329 {
330 	struct net_local *lp = netdev_priv(dev);
331 	unsigned long flags;
332 
333 	netif_dbg(lp, tx_queued, dev, "sent %d byte packet of type %x\n",
334 		  skb->len, skb->data[ETH_ALEN + ETH_ALEN] << 8 |
335 		  skb->data[ETH_ALEN + ETH_ALEN + 1]);
336 
337 	/* keep the upload from being interrupted, since we
338 	   ask the chip to start transmitting before the
339 	   whole packet has been completely uploaded. */
340 	local_irq_save(flags);
341 	netif_stop_queue(dev);
342 
343 	/* initiate a transmit sequence */
344 	writereg(dev, PP_TxCMD, lp->send_cmd);
345 	writereg(dev, PP_TxLength, skb->len);
346 
347 	/* Test to see if the chip has allocated memory for the packet */
348 	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
349 		/* Gasp!  It hasn't.  But that shouldn't happen since
350 		   we're waiting for TxOk, so return 1 and requeue this packet. */
351 		local_irq_restore(flags);
352 		return NETDEV_TX_BUSY;
353 	}
354 
355 	/* Write the contents of the packet */
356 	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
357 				  skb->len+1);
358 
359 	local_irq_restore(flags);
360 	dev_kfree_skb (skb);
361 
362 	return NETDEV_TX_OK;
363 }
364 
365 /* The typical workload of the driver:
366    Handle the network interface interrupts. */
367 static irqreturn_t net_interrupt(int irq, void *dev_id)
368 {
369 	struct net_device *dev = dev_id;
370 	struct net_local *lp;
371 	int ioaddr, status;
372 
373 	ioaddr = dev->base_addr;
374 	lp = netdev_priv(dev);
375 
376 	/* we MUST read all the events out of the ISQ, otherwise we'll never
377            get interrupted again.  As a consequence, we can't have any limit
378            on the number of times we loop in the interrupt handler.  The
379            hardware guarantees that eventually we'll run out of events.  Of
380            course, if you're on a slow machine, and packets are arriving
381            faster than you can read them off, you're screwed.  Hasta la
382            vista, baby!  */
383 	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
384 		netif_dbg(lp, intr, dev, "status=%04x\n", status);
385 		switch(status & ISQ_EVENT_MASK) {
386 		case ISQ_RECEIVER_EVENT:
387 			/* Got a packet(s). */
388 			net_rx(dev);
389 			break;
390 		case ISQ_TRANSMITTER_EVENT:
391 			dev->stats.tx_packets++;
392 			netif_wake_queue(dev);
393 			if ((status & TX_OK) == 0)
394 				dev->stats.tx_errors++;
395 			if (status & TX_LOST_CRS)
396 				dev->stats.tx_carrier_errors++;
397 			if (status & TX_SQE_ERROR)
398 				dev->stats.tx_heartbeat_errors++;
399 			if (status & TX_LATE_COL)
400 				dev->stats.tx_window_errors++;
401 			if (status & TX_16_COL)
402 				dev->stats.tx_aborted_errors++;
403 			break;
404 		case ISQ_BUFFER_EVENT:
405 			if (status & READY_FOR_TX) {
406 				/* we tried to transmit a packet earlier,
407                                    but inexplicably ran out of buffers.
408                                    That shouldn't happen since we only ever
409                                    load one packet.  Shrug.  Do the right
410                                    thing anyway. */
411 				netif_wake_queue(dev);
412 			}
413 			if (status & TX_UNDERRUN) {
414 				netif_dbg(lp, tx_err, dev, "transmit underrun\n");
415                                 lp->send_underrun++;
416                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
417                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
418                         }
419 			break;
420 		case ISQ_RX_MISS_EVENT:
421 			dev->stats.rx_missed_errors += (status >> 6);
422 			break;
423 		case ISQ_TX_COL_EVENT:
424 			dev->stats.collisions += (status >> 6);
425 			break;
426 		}
427 	}
428 	return IRQ_HANDLED;
429 }
430 
431 /* We have a good packet(s), get it/them out of the buffers. */
432 static void
433 net_rx(struct net_device *dev)
434 {
435 	struct net_local *lp = netdev_priv(dev);
436 	struct sk_buff *skb;
437 	int status, length;
438 
439 	status = readreg(dev, PP_RxStatus);
440 	if ((status & RX_OK) == 0) {
441 		dev->stats.rx_errors++;
442 		if (status & RX_RUNT)
443 				dev->stats.rx_length_errors++;
444 		if (status & RX_EXTRA_DATA)
445 				dev->stats.rx_length_errors++;
446 		if ((status & RX_CRC_ERROR) &&
447 		    !(status & (RX_EXTRA_DATA|RX_RUNT)))
448 			/* per str 172 */
449 			dev->stats.rx_crc_errors++;
450 		if (status & RX_DRIBBLE)
451 				dev->stats.rx_frame_errors++;
452 		return;
453 	}
454 
455 	length = readreg(dev, PP_RxLength);
456 	/* Malloc up new buffer. */
457 	skb = alloc_skb(length, GFP_ATOMIC);
458 	if (skb == NULL) {
459 		dev->stats.rx_dropped++;
460 		return;
461 	}
462 	skb_put(skb, length);
463 
464 	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
465 				length);
466 
467 	netif_dbg(lp, rx_status, dev, "received %d byte packet of type %x\n",
468 		  length, skb->data[ETH_ALEN + ETH_ALEN] << 8 |
469 		  skb->data[ETH_ALEN + ETH_ALEN + 1]);
470 
471         skb->protocol=eth_type_trans(skb,dev);
472 	netif_rx(skb);
473 	dev->stats.rx_packets++;
474 	dev->stats.rx_bytes += length;
475 }
476 
477 /* The inverse routine to net_open(). */
478 static int
479 net_close(struct net_device *dev)
480 {
481 
482 	writereg(dev, PP_RxCFG, 0);
483 	writereg(dev, PP_TxCFG, 0);
484 	writereg(dev, PP_BufCFG, 0);
485 	writereg(dev, PP_BusCTL, 0);
486 
487 	netif_stop_queue(dev);
488 
489 	free_irq(dev->irq, dev);
490 
491 	/* Update the statistics here. */
492 
493 	return 0;
494 
495 }
496 
497 /* Get the current statistics.	This may be called with the card open or
498    closed. */
499 static struct net_device_stats *
500 net_get_stats(struct net_device *dev)
501 {
502 	unsigned long flags;
503 
504 	local_irq_save(flags);
505 	/* Update the statistics from the device registers. */
506 	dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
507 	dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
508 	local_irq_restore(flags);
509 
510 	return &dev->stats;
511 }
512 
513 static void set_multicast_list(struct net_device *dev)
514 {
515 	struct net_local *lp = netdev_priv(dev);
516 
517 	if(dev->flags&IFF_PROMISC)
518 	{
519 		lp->rx_mode = RX_ALL_ACCEPT;
520 	} else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
521 		/* The multicast-accept list is initialized to accept-all, and we
522 		   rely on higher-level filtering for now. */
523 		lp->rx_mode = RX_MULTCAST_ACCEPT;
524 	}
525 	else
526 		lp->rx_mode = 0;
527 
528 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
529 
530 	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
531 	writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
532 	     (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
533 }
534 
535 
536 static int set_mac_address(struct net_device *dev, void *addr)
537 {
538 	struct sockaddr *saddr = addr;
539 	int i;
540 
541 	if (!is_valid_ether_addr(saddr->sa_data))
542 		return -EADDRNOTAVAIL;
543 
544 	eth_hw_addr_set(dev, saddr->sa_data);
545 	netdev_info(dev, "Setting MAC address to %pM\n", dev->dev_addr);
546 
547 	/* set the Ethernet address */
548 	for (i=0; i < ETH_ALEN/2; i++)
549 		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
550 
551 	return 0;
552 }
553 
554 MODULE_LICENSE("GPL");
555 
556 static int mac89x0_device_remove(struct platform_device *pdev)
557 {
558 	struct net_device *dev = platform_get_drvdata(pdev);
559 
560 	unregister_netdev(dev);
561 	nubus_writew(0, dev->base_addr + ADD_PORT);
562 	free_netdev(dev);
563 	return 0;
564 }
565 
566 static struct platform_driver mac89x0_platform_driver = {
567 	.probe = mac89x0_device_probe,
568 	.remove = mac89x0_device_remove,
569 	.driver = {
570 		.name = "mac89x0",
571 	},
572 };
573 
574 module_platform_driver(mac89x0_platform_driver);
575