PageRenderTime 46ms CodeModel.GetById 20ms app.highlight 22ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/net/mac89x0.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 634 lines | 392 code | 100 blank | 142 comment | 67 complexity | 3d5b786056134d4dbd0ed2875a51548c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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
 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
 76/*
 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>
 91#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>
 99#include <linux/bitops.h>
100#include <linux/gfp.h>
101
102#include <asm/system.h>
103#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	int chip_type;		/* one of: CS8900, CS8920, CS8920M */
114	char chip_revision;	/* revision letter of the chip ('A'...) */
115	int send_cmd;		/* the propercommand used to send a packet. */
116	int rx_mode;
117	int curr_rx_cfg;
118        int send_underrun;      /* keep track of how many underruns in a row we get */
119	struct sk_buff *skb;
120};
121
122/* Index to functions, as function prototypes. */
123
124#if 0
125extern void reset_chip(struct net_device *dev);
126#endif
127static int net_open(struct net_device *dev);
128static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
129static irqreturn_t net_interrupt(int irq, void *dev_id);
130static void set_multicast_list(struct net_device *dev);
131static void net_rx(struct net_device *dev);
132static int net_close(struct net_device *dev);
133static struct net_device_stats *net_get_stats(struct net_device *dev);
134static int set_mac_address(struct net_device *dev, void *addr);
135
136
137/* Example routines you must write ;->. */
138#define tx_done(dev) 1
139
140/* For reading/writing registers ISA-style */
141static inline int
142readreg_io(struct net_device *dev, int portno)
143{
144	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
145	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
146}
147
148static inline void
149writereg_io(struct net_device *dev, int portno, int value)
150{
151	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
152	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
153}
154
155/* These are for reading/writing registers in shared memory */
156static inline int
157readreg(struct net_device *dev, int portno)
158{
159	return swab16(nubus_readw(dev->mem_start + portno));
160}
161
162static inline void
163writereg(struct net_device *dev, int portno, int value)
164{
165	nubus_writew(swab16(value), dev->mem_start + portno);
166}
167
168static const struct net_device_ops mac89x0_netdev_ops = {
169	.ndo_open		= net_open,
170	.ndo_stop		= net_close,
171	.ndo_start_xmit		= net_send_packet,
172	.ndo_get_stats		= net_get_stats,
173	.ndo_set_multicast_list	= set_multicast_list,
174	.ndo_set_mac_address	= set_mac_address,
175	.ndo_validate_addr	= eth_validate_addr,
176	.ndo_change_mtu		= eth_change_mtu,
177};
178
179/* Probe for the CS8900 card in slot E.  We won't bother looking
180   anywhere else until we have a really good reason to do so. */
181struct net_device * __init mac89x0_probe(int unit)
182{
183	struct net_device *dev;
184	static int once_is_enough;
185	struct net_local *lp;
186	static unsigned version_printed;
187	int i, slot;
188	unsigned rev_type = 0;
189	unsigned long ioaddr;
190	unsigned short sig;
191	int err = -ENODEV;
192
193	if (!MACH_IS_MAC)
194		return ERR_PTR(-ENODEV);
195
196	dev = alloc_etherdev(sizeof(struct net_local));
197	if (!dev)
198		return ERR_PTR(-ENOMEM);
199
200	if (unit >= 0) {
201		sprintf(dev->name, "eth%d", unit);
202		netdev_boot_setup_check(dev);
203	}
204
205	if (once_is_enough)
206		goto out;
207	once_is_enough = 1;
208
209	/* We might have to parameterize this later */
210	slot = 0xE;
211	/* Get out now if there's a real NuBus card in slot E */
212	if (nubus_find_slot(slot, NULL) != NULL)
213		goto out;
214
215	/* The pseudo-ISA bits always live at offset 0x300 (gee,
216           wonder why...) */
217	ioaddr = (unsigned long)
218		nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
219	{
220		unsigned long flags;
221		int card_present;
222
223		local_irq_save(flags);
224		card_present = (hwreg_present((void*) ioaddr+4) &&
225				hwreg_present((void*) ioaddr + DATA_PORT));
226		local_irq_restore(flags);
227
228		if (!card_present)
229			goto out;
230	}
231
232	nubus_writew(0, ioaddr + ADD_PORT);
233	sig = nubus_readw(ioaddr + DATA_PORT);
234	if (sig != swab16(CHIP_EISA_ID_SIG))
235		goto out;
236
237	/* Initialize the net_device structure. */
238	lp = netdev_priv(dev);
239
240	/* Fill in the 'dev' fields. */
241	dev->base_addr = ioaddr;
242	dev->mem_start = (unsigned long)
243		nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
244	dev->mem_end = dev->mem_start + 0x1000;
245
246	/* Turn on shared memory */
247	writereg_io(dev, PP_BusCTL, MEMORY_ON);
248
249	/* get the chip type */
250	rev_type = readreg(dev, PRODUCT_ID_ADD);
251	lp->chip_type = rev_type &~ REVISON_BITS;
252	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
253
254	/* Check the chip type and revision in order to set the correct send command
255	CS8920 revision C and CS8900 revision F can use the faster send. */
256	lp->send_cmd = TX_AFTER_381;
257	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
258		lp->send_cmd = TX_NOW;
259	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
260		lp->send_cmd = TX_NOW;
261
262	if (net_debug && version_printed++ == 0)
263		printk(version);
264
265	printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
266	       dev->name,
267	       lp->chip_type==CS8900?'0':'2',
268	       lp->chip_type==CS8920M?"M":"",
269	       lp->chip_revision,
270	       dev->base_addr);
271
272	/* Try to read the MAC address */
273	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
274		printk("\nmac89x0: No EEPROM, giving up now.\n");
275		goto out1;
276        } else {
277                for (i = 0; i < ETH_ALEN; i += 2) {
278			/* Big-endian (why??!) */
279			unsigned short s = readreg(dev, PP_IA + i);
280                        dev->dev_addr[i] = s >> 8;
281                        dev->dev_addr[i+1] = s & 0xff;
282                }
283        }
284
285	dev->irq = SLOT2IRQ(slot);
286
287	/* print the IRQ and ethernet address. */
288
289	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
290
291	dev->netdev_ops		= &mac89x0_netdev_ops;
292
293	err = register_netdev(dev);
294	if (err)
295		goto out1;
296	return NULL;
297out1:
298	nubus_writew(0, dev->base_addr + ADD_PORT);
299out:
300	free_netdev(dev);
301	return ERR_PTR(err);
302}
303
304#if 0
305/* This is useful for something, but I don't know what yet. */
306void __init reset_chip(struct net_device *dev)
307{
308	int reset_start_time;
309
310	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
311
312	/* wait 30 ms */
313	msleep_interruptible(30);
314
315	/* Wait until the chip is reset */
316	reset_start_time = jiffies;
317	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
318		;
319}
320#endif
321
322/* Open/initialize the board.  This is called (in the current kernel)
323   sometime after booting when the 'ifconfig' program is run.
324
325   This routine should set everything up anew at each open, even
326   registers that "should" only need to be set once at boot, so that
327   there is non-reboot way to recover if something goes wrong.
328   */
329static int
330net_open(struct net_device *dev)
331{
332	struct net_local *lp = netdev_priv(dev);
333	int i;
334
335	/* Disable the interrupt for now */
336	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
337
338	/* Grab the interrupt */
339	if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
340		return -EAGAIN;
341
342	/* Set up the IRQ - Apparently magic */
343	if (lp->chip_type == CS8900)
344		writereg(dev, PP_CS8900_ISAINT, 0);
345	else
346		writereg(dev, PP_CS8920_ISAINT, 0);
347
348	/* set the Ethernet address */
349	for (i=0; i < ETH_ALEN/2; i++)
350		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
351
352	/* Turn on both receive and transmit operations */
353	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
354
355	/* Receive only error free packets addressed to this card */
356	lp->rx_mode = 0;
357	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
358
359	lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
360
361	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
362
363	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
364	       TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
365
366	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
367		 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
368
369	/* now that we've got our act together, enable everything */
370	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
371	netif_start_queue(dev);
372	return 0;
373}
374
375static int
376net_send_packet(struct sk_buff *skb, struct net_device *dev)
377{
378	struct net_local *lp = netdev_priv(dev);
379	unsigned long flags;
380
381	if (net_debug > 3)
382		printk("%s: sent %d byte packet of type %x\n",
383		       dev->name, skb->len,
384		       (skb->data[ETH_ALEN+ETH_ALEN] << 8)
385		       | skb->data[ETH_ALEN+ETH_ALEN+1]);
386
387	/* keep the upload from being interrupted, since we
388	   ask the chip to start transmitting before the
389	   whole packet has been completely uploaded. */
390	local_irq_save(flags);
391	netif_stop_queue(dev);
392
393	/* initiate a transmit sequence */
394	writereg(dev, PP_TxCMD, lp->send_cmd);
395	writereg(dev, PP_TxLength, skb->len);
396
397	/* Test to see if the chip has allocated memory for the packet */
398	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
399		/* Gasp!  It hasn't.  But that shouldn't happen since
400		   we're waiting for TxOk, so return 1 and requeue this packet. */
401		local_irq_restore(flags);
402		return NETDEV_TX_BUSY;
403	}
404
405	/* Write the contents of the packet */
406	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
407				  skb->len+1);
408
409	local_irq_restore(flags);
410	dev_kfree_skb (skb);
411
412	return NETDEV_TX_OK;
413}
414
415/* The typical workload of the driver:
416   Handle the network interface interrupts. */
417static 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			dev->stats.tx_packets++;
447			netif_wake_queue(dev);
448			if ((status & TX_OK) == 0)
449				dev->stats.tx_errors++;
450			if (status & TX_LOST_CRS)
451				dev->stats.tx_carrier_errors++;
452			if (status & TX_SQE_ERROR)
453				dev->stats.tx_heartbeat_errors++;
454			if (status & TX_LATE_COL)
455				dev->stats.tx_window_errors++;
456			if (status & TX_16_COL)
457				dev->stats.tx_aborted_errors++;
458			break;
459		case ISQ_BUFFER_EVENT:
460			if (status & READY_FOR_TX) {
461				/* we tried to transmit a packet earlier,
462                                   but inexplicably ran out of buffers.
463                                   That shouldn't happen since we only ever
464                                   load one packet.  Shrug.  Do the right
465                                   thing anyway. */
466				netif_wake_queue(dev);
467			}
468			if (status & TX_UNDERRUN) {
469				if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
470                                lp->send_underrun++;
471                                if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
472                                else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
473                        }
474			break;
475		case ISQ_RX_MISS_EVENT:
476			dev->stats.rx_missed_errors += (status >> 6);
477			break;
478		case ISQ_TX_COL_EVENT:
479			dev->stats.collisions += (status >> 6);
480			break;
481		}
482	}
483	return IRQ_HANDLED;
484}
485
486/* We have a good packet(s), get it/them out of the buffers. */
487static void
488net_rx(struct net_device *dev)
489{
490	struct sk_buff *skb;
491	int status, length;
492
493	status = readreg(dev, PP_RxStatus);
494	if ((status & RX_OK) == 0) {
495		dev->stats.rx_errors++;
496		if (status & RX_RUNT)
497				dev->stats.rx_length_errors++;
498		if (status & RX_EXTRA_DATA)
499				dev->stats.rx_length_errors++;
500		if ((status & RX_CRC_ERROR) &&
501		    !(status & (RX_EXTRA_DATA|RX_RUNT)))
502			/* per str 172 */
503			dev->stats.rx_crc_errors++;
504		if (status & RX_DRIBBLE)
505				dev->stats.rx_frame_errors++;
506		return;
507	}
508
509	length = readreg(dev, PP_RxLength);
510	/* Malloc up new buffer. */
511	skb = alloc_skb(length, GFP_ATOMIC);
512	if (skb == NULL) {
513		printk("%s: Memory squeeze, dropping packet.\n", dev->name);
514		dev->stats.rx_dropped++;
515		return;
516	}
517	skb_put(skb, length);
518
519	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
520				length);
521
522	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
523                                 dev->name, length,
524                                 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
525				 | skb->data[ETH_ALEN+ETH_ALEN+1]);
526
527        skb->protocol=eth_type_trans(skb,dev);
528	netif_rx(skb);
529	dev->stats.rx_packets++;
530	dev->stats.rx_bytes += length;
531}
532
533/* The inverse routine to net_open(). */
534static int
535net_close(struct net_device *dev)
536{
537
538	writereg(dev, PP_RxCFG, 0);
539	writereg(dev, PP_TxCFG, 0);
540	writereg(dev, PP_BufCFG, 0);
541	writereg(dev, PP_BusCTL, 0);
542
543	netif_stop_queue(dev);
544
545	free_irq(dev->irq, dev);
546
547	/* Update the statistics here. */
548
549	return 0;
550
551}
552
553/* Get the current statistics.	This may be called with the card open or
554   closed. */
555static struct net_device_stats *
556net_get_stats(struct net_device *dev)
557{
558	unsigned long flags;
559
560	local_irq_save(flags);
561	/* Update the statistics from the device registers. */
562	dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
563	dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
564	local_irq_restore(flags);
565
566	return &dev->stats;
567}
568
569static void set_multicast_list(struct net_device *dev)
570{
571	struct net_local *lp = netdev_priv(dev);
572
573	if(dev->flags&IFF_PROMISC)
574	{
575		lp->rx_mode = RX_ALL_ACCEPT;
576	} else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
577		/* The multicast-accept list is initialized to accept-all, and we
578		   rely on higher-level filtering for now. */
579		lp->rx_mode = RX_MULTCAST_ACCEPT;
580	}
581	else
582		lp->rx_mode = 0;
583
584	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
585
586	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
587	writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
588	     (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
589}
590
591
592static int set_mac_address(struct net_device *dev, void *addr)
593{
594	int i;
595	printk("%s: Setting MAC address to ", dev->name);
596	for (i = 0; i < 6; i++)
597		printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
598	printk(".\n");
599	/* set the Ethernet address */
600	for (i=0; i < ETH_ALEN/2; i++)
601		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
602
603	return 0;
604}
605
606#ifdef MODULE
607
608static struct net_device *dev_cs89x0;
609static int debug;
610
611module_param(debug, int, 0);
612MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
613MODULE_LICENSE("GPL");
614
615int __init
616init_module(void)
617{
618	net_debug = debug;
619        dev_cs89x0 = mac89x0_probe(-1);
620	if (IS_ERR(dev_cs89x0)) {
621                printk(KERN_WARNING "mac89x0.c: No card found\n");
622		return PTR_ERR(dev_cs89x0);
623	}
624	return 0;
625}
626
627void
628cleanup_module(void)
629{
630	unregister_netdev(dev_cs89x0);
631	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
632	free_netdev(dev_cs89x0);
633}
634#endif /* MODULE */