1
2
3#include <linux/kernel.h>
4#include <linux/string.h>
5#include <linux/errno.h>
6#include <linux/ioport.h>
7#include <linux/slab.h>
8#include <linux/interrupt.h>
9#include <linux/delay.h>
10#include <linux/time.h>
11#include <linux/mca-legacy.h>
12#include <linux/module.h>
13#include <linux/netdevice.h>
14#include <linux/etherdevice.h>
15#include <linux/skbuff.h>
16#include <linux/bitops.h>
17
18#include <asm/processor.h>
19#include <asm/io.h>
20
21#define _IBM_LANA_DRIVER_
22#include "ibmlana.h"
23
24#undef DEBUG
25
26#define DRV_NAME "ibmlana"
27
28/* ------------------------------------------------------------------------
29 * global static data - not more since we can handle multiple boards and
30 * have to pack all state info into the device struct!
31 * ------------------------------------------------------------------------ */
32
33static char *MediaNames[Media_Count] = {
34	"10BaseT", "10Base5", "Unknown", "10Base2"
35};
36
37/* ------------------------------------------------------------------------
38 * private subfunctions
39 * ------------------------------------------------------------------------ */
40
41#ifdef DEBUG
42  /* dump all registers */
43
44static void dumpregs(struct net_device *dev)
45{
46	int z;
47
48	for (z = 0; z < 160; z += 2) {
49		if (!(z & 15))
50			printk("REGS: %04x:", z);
51		printk(" %04x", inw(dev->base_addr + z));
52		if ((z & 15) == 14)
53			printk("\n");
54	}
55}
56
57/* dump parts of shared memory - only needed during debugging */
58
59static void dumpmem(struct net_device *dev, u32 start, u32 len)
60{
61	ibmlana_priv *priv = netdev_priv(dev);
62	int z;
63
64	printk("Address %04x:\n", start);
65	for (z = 0; z < len; z++) {
66		if ((z & 15) == 0)
67			printk("%04x:", z);
68		printk(" %02x", readb(priv->base + start + z));
69		if ((z & 15) == 15)
70			printk("\n");
71	}
72	if ((z & 15) != 0)
73		printk("\n");
74}
75
76/* print exact time - ditto */
77
78static void PrTime(void)
79{
80	struct timeval tv;
81
82	do_gettimeofday(&tv);
83	printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
84}
85#endif				/* DEBUG */
86
87/* deduce resources out of POS registers */
88
89static void getaddrs(int slot, int *base, int *memlen, int *iobase,
90		     int *irq, ibmlana_medium * medium)
91{
92	u_char pos0, pos1;
93
94	pos0 = mca_read_stored_pos(slot, 2);
95	pos1 = mca_read_stored_pos(slot, 3);
96
97	*base = 0xc0000 + ((pos1 & 0xf0) << 9);
98	*memlen = (pos1 & 0x01) ? 0x8000 : 0x4000;
99	*iobase = (pos0 & 0xe0) << 7;
100	switch (pos0 & 0x06) {
101	case 0:
102		*irq = 5;
103		break;
104	case 2:
105		*irq = 15;
106		break;
107	case 4:
108		*irq = 10;
109		break;
110	case 6:
111		*irq = 11;
112		break;
113	}
114	*medium = (pos0 & 0x18) >> 3;
115}
116
117/* wait on register value with mask and timeout */
118
119static int wait_timeout(struct net_device *dev, int regoffs, u16 mask,
120			u16 value, int timeout)
121{
122	unsigned long fin = jiffies + timeout;
123
124	while (time_before(jiffies,fin))
125		if ((inw(dev->base_addr + regoffs) & mask) == value)
126			return 1;
127
128	return 0;
129}
130
131
132/* reset the whole board */
133
134static void ResetBoard(struct net_device *dev)
135{
136	unsigned char bcmval;
137
138	/* read original board control value */
139
140	bcmval = inb(dev->base_addr + BCMREG);
141
142	/* set reset bit for a while */
143
144	bcmval |= BCMREG_RESET;
145	outb(bcmval, dev->base_addr + BCMREG);
146	udelay(10);
147	bcmval &= ~BCMREG_RESET;
148	outb(bcmval, dev->base_addr + BCMREG);
149
150	/* switch over to RAM again */
151
152	bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
153	outb(bcmval, dev->base_addr + BCMREG);
154}
155
156/* calculate RAM layout & set up descriptors in RAM */
157
158static void InitDscrs(struct net_device *dev)
159{
160	ibmlana_priv *priv = netdev_priv(dev);
161	u32 addr, baddr, raddr;
162	int z;
163	tda_t tda;
164	rda_t rda;
165	rra_t rra;
166
167	/* initialize RAM */
168
169	memset_io(priv->base, 0xaa,
170		      dev->mem_start - dev->mem_start);
171
172	/* setup n TX descriptors - independent of RAM size */
173
174	priv->tdastart = addr = 0;
175	priv->txbufstart = baddr = sizeof(tda_t) * TXBUFCNT;
176	for (z = 0; z < TXBUFCNT; z++) {
177		tda.status = 0;
178		tda.config = 0;
179		tda.length = 0;
180		tda.fragcount = 1;
181		tda.startlo = baddr;
182		tda.starthi = 0;
183		tda.fraglength = 0;
184		if (z == TXBUFCNT - 1)
185			tda.link = priv->tdastart;
186		else
187			tda.link = addr + sizeof(tda_t);
188		tda.link |= 1;
189		memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
190		addr += sizeof(tda_t);
191		baddr += PKTSIZE;
192	}
193
194	/* calculate how many receive buffers fit into remaining memory */
195
196	priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) / (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
197
198	/* calculate receive addresses */
199
200	priv->rrastart = raddr = priv->txbufstart + (TXBUFCNT * PKTSIZE);
201	priv->rdastart = addr = priv->rrastart + (priv->rxbufcnt * sizeof(rra_t));
202	priv->rxbufstart = baddr = priv->rdastart + (priv->rxbufcnt * sizeof(rda_t));
203
204	for (z = 0; z < priv->rxbufcnt; z++) {
205		rra.startlo = baddr;
206		rra.starthi = 0;
207		rra.cntlo = PKTSIZE >> 1;
208		rra.cnthi = 0;
209		memcpy_toio(priv->base + raddr, &rra, sizeof(rra_t));
210
211		rda.status = 0;
212		rda.length = 0;
213		rda.startlo = 0;
214		rda.starthi = 0;
215		rda.seqno = 0;
216		if (z < priv->rxbufcnt - 1)
217			rda.link = addr + sizeof(rda_t);
218		else
219			rda.link = 1;
220		rda.inuse = 1;
221		memcpy_toio(priv->base + addr, &rda, sizeof(rda_t));
222
223		baddr += PKTSIZE;
224		raddr += sizeof(rra_t);
225		addr += sizeof(rda_t);
226	}
227
228	/* initialize current pointers */
229
230	priv->nextrxdescr = 0;
231	priv->lastrxdescr = priv->rxbufcnt - 1;
232	priv->nexttxdescr = 0;
233	priv->currtxdescr = 0;
234	priv->txusedcnt = 0;
235	memset(priv->txused, 0, sizeof(priv->txused));
236}
237
238/* set up Rx + Tx descriptors in SONIC */
239
240static int InitSONIC(struct net_device *dev)
241{
242	ibmlana_priv *priv = netdev_priv(dev);
243
244	/* set up start & end of resource area */
245
246	outw(0, SONIC_URRA);
247	outw(priv->rrastart, dev->base_addr + SONIC_RSA);
248	outw(priv->rrastart + (priv->rxbufcnt * sizeof(rra_t)), dev->base_addr + SONIC_REA);
249	outw(priv->rrastart, dev->base_addr + SONIC_RRP);
250	outw(priv->rrastart, dev->base_addr + SONIC_RWP);
251
252	/* set EOBC so that only one packet goes into one buffer */
253
254	outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
255
256	/* let SONIC read the first RRA descriptor */
257
258	outw(CMDREG_RRRA, dev->base_addr + SONIC_CMDREG);
259	if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_RRRA, 0, 2)) {
260		printk(KERN_ERR "%s: SONIC did not respond on RRRA command - giving up.", dev->name);
261		return 0;
262	}
263
264	/* point SONIC to the first RDA */
265
266	outw(0, dev->base_addr + SONIC_URDA);
267	outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
268
269	/* set upper half of TDA address */
270
271	outw(0, dev->base_addr + SONIC_UTDA);
272
273	return 1;
274}
275
276/* stop SONIC so we can reinitialize it */
277
278static void StopSONIC(struct net_device *dev)
279{
280	/* disable interrupts */
281
282	outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN), dev->base_addr + BCMREG);
283	outb(0, dev->base_addr + SONIC_IMREG);
284
285	/* reset the SONIC */
286
287	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
288	udelay(10);
289	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
290}
291
292/* initialize card and SONIC for proper operation */
293
294static void putcam(camentry_t * cams, int *camcnt, char *addr)
295{
296	camentry_t *pcam = cams + (*camcnt);
297	u8 *uaddr = (u8 *) addr;
298
299	pcam->index = *camcnt;
300	pcam->addr0 = (((u16) uaddr[1]) << 8) | uaddr[0];
301	pcam->addr1 = (((u16) uaddr[3]) << 8) | uaddr[2];
302	pcam->addr2 = (((u16) uaddr[5]) << 8) | uaddr[4];
303	(*camcnt)++;
304}
305
306static void InitBoard(struct net_device *dev)
307{
308	ibmlana_priv *priv = netdev_priv(dev);
309	int camcnt;
310	camentry_t cams[16];
311	u32 cammask;
312	struct dev_mc_list *mcptr;
313	u16 rcrval;
314
315	/* reset the SONIC */
316
317	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
318	udelay(10);
319
320	/* clear all spurious interrupts */
321
322	outw(inw(dev->base_addr + SONIC_ISREG), dev->base_addr + SONIC_ISREG);
323
324	/* set up the SONIC's bus interface - constant for this adapter -
325	   must be done while the SONIC is in reset */
326
327	outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32, dev->base_addr + SONIC_DCREG);
328	outw(0, dev->base_addr + SONIC_DCREG2);
329
330	/* remove reset form the SONIC */
331
332	outw(0, dev->base_addr + SONIC_CMDREG);
333	udelay(10);
334
335	/* data sheet requires URRA to be programmed before setting up the CAM contents */
336
337	outw(0, dev->base_addr + SONIC_URRA);
338
339	/* program the CAM entry 0 to the device address */
340
341	camcnt = 0;
342	putcam(cams, &camcnt, dev->dev_addr);
343
344	/* start putting the multicast addresses into the CAM list.  Stop if
345	   it is full. */
346
347	for (mcptr = dev->mc_list; mcptr != NULL; mcptr = mcptr->next) {
348		putcam(cams, &camcnt, mcptr->dmi_addr);
349		if (camcnt == 16)
350			break;
351	}
352
353	/* calculate CAM mask */
354
355	cammask = (1 << camcnt) - 1;
356
357	/* feed CDA into SONIC, initialize RCR value (always get broadcasts) */
358
359	memcpy_toio(priv->base, cams, sizeof(camentry_t) * camcnt);
360	memcpy_toio(priv->base + (sizeof(camentry_t) * camcnt), &cammask, sizeof(cammask));
361
362#ifdef DEBUG
363	printk("CAM setup:\n");
364	dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
365#endif
366
367	outw(0, dev->base_addr + SONIC_CAMPTR);
368	outw(camcnt, dev->base_addr + SONIC_CAMCNT);
369	outw(CMDREG_LCAM, dev->base_addr + SONIC_CMDREG);
370	if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_LCAM, 0, 2)) {
371		printk(KERN_ERR "%s:SONIC did not respond on LCAM command - giving up.", dev->name);
372		return;
373	} else {
374		/* clear interrupt condition */
375
376		outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
377
378#ifdef DEBUG
379		printk("Loading CAM done, address pointers %04x:%04x\n",
380		       inw(dev->base_addr + SONIC_URRA),
381		       inw(dev->base_addr + SONIC_CAMPTR));
382		{
383			int z;
384
385			printk("\n-->CAM: PTR %04x CNT %04x\n",
386			       inw(dev->base_addr + SONIC_CAMPTR),
387			       inw(dev->base_addr + SONIC_CAMCNT));
388			outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
389			for (z = 0; z < camcnt; z++) {
390				outw(z, dev->base_addr + SONIC_CAMEPTR);
391				printk("Entry %d: %04x %04x %04x\n", z,
392				       inw(dev->base_addr + SONIC_CAMADDR0),
393				       inw(dev->base_addr + SONIC_CAMADDR1),
394				       inw(dev->base_addr + SONIC_CAMADDR2));
395			}
396			outw(0, dev->base_addr + SONIC_CMDREG);
397		}
398#endif
399	}
400
401	rcrval = RCREG_BRD | RCREG_LB_NONE;
402
403	/* if still multicast addresses left or ALLMULTI is set, set the multicast
404	   enable bit */
405
406	if ((dev->flags & IFF_ALLMULTI) || (mcptr != NULL))
407		rcrval |= RCREG_AMC;
408
409	/* promiscous mode ? */
410
411	if (dev->flags & IFF_PROMISC)
412		rcrval |= RCREG_PRO;
413
414	/* program receive mode */
415
416	outw(rcrval, dev->base_addr + SONIC_RCREG);
417#ifdef DEBUG
418	printk("\nRCRVAL: %04x\n", rcrval);
419#endif
420
421	/* set up descriptors in shared memory + feed them into SONIC registers */
422
423	InitDscrs(dev);
424	if (!InitSONIC(dev))
425		return;
426
427	/* reset all pending interrupts */
428
429	outw(0xffff, dev->base_addr + SONIC_ISREG);
430
431	/* enable transmitter + receiver interrupts */
432
433	outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
434	outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN, dev->base_addr + SONIC_IMREG);
435
436	/* turn on card interrupts */
437
438	outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN, dev->base_addr + BCMREG);
439
440#ifdef DEBUG
441	printk("Register dump after initialization:\n");
442	dumpregs(dev);
443#endif
444}
445
446/* start transmission of a descriptor */
447
448static void StartTx(struct net_device *dev, int descr)
449{
450	ibmlana_priv *priv = netdev_priv(dev);
451	int addr;
452
453	addr = priv->tdastart + (descr * sizeof(tda_t));
454
455	/* put descriptor address into SONIC */
456
457	outw(addr, dev->base_addr + SONIC_CTDA);
458
459	/* trigger transmitter */
460
461	priv->currtxdescr = descr;
462	outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
463}
464
465/* ------------------------------------------------------------------------
466 * interrupt handler(s)
467 * ------------------------------------------------------------------------ */
468
469/* receive buffer area exhausted */
470
471static void irqrbe_handler(struct net_device *dev)
472{
473	ibmlana_priv *priv = netdev_priv(dev);
474
475	/* point the SONIC back to the RRA start */
476
477	outw(priv->rrastart, dev->base_addr + SONIC_RRP);
478	outw(priv->rrastart, dev->base_addr + SONIC_RWP);
479}
480
481/* receive interrupt */
482
483static void irqrx_handler(struct net_device *dev)
484{
485	ibmlana_priv *priv = netdev_priv(dev);
486	rda_t rda;
487	u32 rdaaddr, lrdaaddr;
488
489	/* loop until ... */
490
491	while (1) {
492		/* read descriptor that was next to be filled by SONIC */
493
494		rdaaddr = priv->rdastart + (priv->nextrxdescr * sizeof(rda_t));
495		lrdaaddr = priv->rdastart + (priv->lastrxdescr * sizeof(rda_t));
496		memcpy_fromio(&rda, priv->base + rdaaddr, sizeof(rda_t));
497
498		/* iron out upper word halves of fields we use - SONIC will duplicate
499		   bits 0..15 to 16..31 */
500
501		rda.status &= 0xffff;
502		rda.length &= 0xffff;
503		rda.startlo &= 0xffff;
504
505		/* stop if the SONIC still owns it, i.e. there is no data for us */
506
507		if (rda.inuse)
508			break;
509
510		/* good packet? */
511
512		else if (rda.status & RCREG_PRX) {
513			struct sk_buff *skb;
514
515			/* fetch buffer */
516
517			skb = dev_alloc_skb(rda.length + 2);
518			if (skb == NULL)
519				priv->stat.rx_dropped++;
520			else {
521				/* copy out data */
522
523				memcpy_fromio(skb_put(skb, rda.length),
524					       priv->base +
525					       rda.startlo, rda.length);
526
527				/* set up skb fields */
528
529				skb->protocol = eth_type_trans(skb, dev);
530				skb->ip_summed = CHECKSUM_NONE;
531
532				/* bookkeeping */
533				dev->last_rx = jiffies;
534				priv->stat.rx_packets++;
535				priv->stat.rx_bytes += rda.length;
536
537				/* pass to the upper layers */
538				netif_rx(skb);
539			}
540		}
541
542		/* otherwise check error status bits and increase statistics */
543
544		else {
545			priv->stat.rx_errors++;
546			if (rda.status & RCREG_FAER)
547				priv->stat.rx_frame_errors++;
548			if (rda.status & RCREG_CRCR)
549				priv->stat.rx_crc_errors++;
550		}
551
552		/* descriptor processed, will become new last descriptor in queue */
553
554		rda.link = 1;
555		rda.inuse = 1;
556		memcpy_toio(priv->base + rdaaddr, &rda,
557			     sizeof(rda_t));
558
559		/* set up link and EOL = 0 in currently last descriptor. Only write
560		   the link field since the SONIC may currently already access the
561		   other fields. */
562
563		memcpy_toio(priv->base + lrdaaddr + 20, &rdaaddr, 4);
564
565		/* advance indices */
566
567		priv->lastrxdescr = priv->nextrxdescr;
568		if ((++priv->nextrxdescr) >= priv->rxbufcnt)
569			priv->nextrxdescr = 0;
570	}
571}
572
573/* transmit interrupt */
574
575static void irqtx_handler(struct net_device *dev)
576{
577	ibmlana_priv *priv = netdev_priv(dev);
578	tda_t tda;
579
580	/* fetch descriptor (we forgot the size ;-) */
581	memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
582
583	/* update statistics */
584	priv->stat.tx_packets++;
585	priv->stat.tx_bytes += tda.length;
586
587	/* update our pointers */
588	priv->txused[priv->currtxdescr] = 0;
589	priv->txusedcnt--;
590
591	/* if there are more descriptors present in RAM, start them */
592	if (priv->txusedcnt > 0)
593		StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
594
595	/* tell the upper layer we can go on transmitting */
596	netif_wake_queue(dev);
597}
598
599static void irqtxerr_handler(struct net_device *dev)
600{
601	ibmlana_priv *priv = netdev_priv(dev);
602	tda_t tda;
603
604	/* fetch descriptor to check status */
605	memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
606
607	/* update statistics */
608	priv->stat.tx_errors++;
609	if (tda.status & (TCREG_NCRS | TCREG_CRSL))
610		priv->stat.tx_carrier_errors++;
611	if (tda.status & TCREG_EXC)
612		priv->stat.tx_aborted_errors++;
613	if (tda.status & TCREG_OWC)
614		priv->stat.tx_window_errors++;
615	if (tda.status & TCREG_FU)
616		priv->stat.tx_fifo_errors++;
617
618	/* update our pointers */
619	priv->txused[priv->currtxdescr] = 0;
620	priv->txusedcnt--;
621
622	/* if there are more descriptors present in RAM, start them */
623	if (priv->txusedcnt > 0)
624		StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
625
626	/* tell the upper layer we can go on transmitting */
627	netif_wake_queue(dev);
628}
629
630/* general interrupt entry */
631
632static irqreturn_t irq_handler(int irq, void *device)
633{
634	struct net_device *dev = (struct net_device *) device;
635	u16 ival;
636
637	/* in case we're not meant... */
638	if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
639		return IRQ_NONE;
640
641	/* loop through the interrupt bits until everything is clear */
642	while (1) {
643		ival = inw(dev->base_addr + SONIC_ISREG);
644
645		if (ival & ISREG_RBE) {
646			irqrbe_handler(dev);
647			outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
648		}
649		if (ival & ISREG_PKTRX) {
650			irqrx_handler(dev);
651			outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
652		}
653		if (ival & ISREG_TXDN) {
654			irqtx_handler(dev);
655			outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
656		}
657		if (ival & ISREG_TXER) {
658			irqtxerr_handler(dev);
659			outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
660		}
661		break;
662	}
663	return IRQ_HANDLED;
664}
665
666/* ------------------------------------------------------------------------
667 * driver methods
668 * ------------------------------------------------------------------------ */
669
670/* MCA info */
671
672static int ibmlana_getinfo(char *buf, int slot, void *d)
673{
674	int len = 0, i;
675	struct net_device *dev = (struct net_device *) d;
676	ibmlana_priv *priv;
677
678	/* can't say anything about an uninitialized device... */
679
680	if (dev == NULL)
681		return len;
682	priv = netdev_priv(dev);
683
684	/* print info */
685
686	len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
687	len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
688	len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start, dev->mem_end - 1);
689	len += sprintf(buf + len, "Transceiver: %s\n", MediaNames[priv->medium]);
690	len += sprintf(buf + len, "Device: %s\n", dev->name);
691	len += sprintf(buf + len, "MAC address:");
692	for (i = 0; i < 6; i++)
693		len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
694	buf[len++] = '\n';
695	buf[len] = 0;
696
697	return len;
698}
699
700/* open driver.  Means also initialization and start of LANCE */
701
702static int ibmlana_open(struct net_device *dev)
703{
704	int result;
705	ibmlana_priv *priv = netdev_priv(dev);
706
707	/* register resources - only necessary for IRQ */
708
709	result = request_irq(priv->realirq, irq_handler, IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, dev);
710	if (result != 0) {
711		printk(KERN_ERR "%s: failed to register irq %d\n", dev->name, dev->irq);
712		return result;
713	}
714	dev->irq = priv->realirq;
715
716	/* set up the card and SONIC */
717	InitBoard(dev);
718
719	/* initialize operational flags */
720	netif_start_queue(dev);
721	return 0;
722}
723
724/* close driver.  Shut down board and free allocated resources */
725
726static int ibmlana_close(struct net_device *dev)
727{
728	/* turn off board */
729
730	/* release resources */
731	if (dev->irq != 0)
732		free_irq(dev->irq, dev);
733	dev->irq = 0;
734	return 0;
735}
736
737/* transmit a block. */
738
739static int ibmlana_tx(struct sk_buff *skb, struct net_device *dev)
740{
741	ibmlana_priv *priv = netdev_priv(dev);
742	int retval = 0, tmplen, addr;
743	unsigned long flags;
744	tda_t tda;
745	int baddr;
746
747	/* find out if there are free slots for a frame to transmit. If not,
748	   the upper layer is in deep desperation and we simply ignore the frame. */
749
750	if (priv->txusedcnt >= TXBUFCNT) {
751		retval = -EIO;
752		priv->stat.tx_dropped++;
753		goto tx_done;
754	}
755
756	/* copy the frame data into the next free transmit buffer - fillup missing */
757	tmplen = skb->len;
758	if (tmplen < 60)
759		tmplen = 60;
760	baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
761	memcpy_toio(priv->base + baddr, skb->data, skb->len);
762
763	/* copy filler into RAM - in case we're filling up...
764	   we're filling a bit more than necessary, but that doesn't harm
765	   since the buffer is far larger...
766	   Sorry Linus for the filler string but I couldn't resist ;-) */
767
768	if (tmplen > skb->len) {
769		char *fill = "NetBSD is a nice OS too! ";
770		unsigned int destoffs = skb->len, l = strlen(fill);
771
772		while (destoffs < tmplen) {
773			memcpy_toio(priv->base + baddr + destoffs, fill, l);
774			destoffs += l;
775		}
776	}
777
778	/* set up the new frame descriptor */
779	addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
780	memcpy_fromio(&tda, priv->base + addr, sizeof(tda_t));
781	tda.length = tda.fraglength = tmplen;
782	memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
783
784	/* if there were no active descriptors, trigger the SONIC */
785	spin_lock_irqsave(&priv->lock, flags);
786
787	priv->txusedcnt++;
788	priv->txused[priv->nexttxdescr] = 1;
789
790	/* are all transmission slots used up ? */
791	if (priv->txusedcnt >= TXBUFCNT)
792		netif_stop_queue(dev);
793
794	if (priv->txusedcnt == 1)
795		StartTx(dev, priv->nexttxdescr);
796	priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
797
798	spin_unlock_irqrestore(&priv->lock, flags);
799tx_done:
800	dev_kfree_skb(skb);
801	return retval;
802}
803
804/* return pointer to Ethernet statistics */
805
806static struct net_device_stats *ibmlana_stats(struct net_device *dev)
807{
808	ibmlana_priv *priv = netdev_priv(dev);
809	return &priv->stat;
810}
811
812/* switch receiver mode. */
813
814static void ibmlana_set_multicast_list(struct net_device *dev)
815{
816	/* first stop the SONIC... */
817	StopSONIC(dev);
818	/* ...then reinit it with the new flags */
819	InitBoard(dev);
820}
821
822/* ------------------------------------------------------------------------
823 * hardware check
824 * ------------------------------------------------------------------------ */
825
826static int startslot;		/* counts through slots when probing multiple devices */
827
828static int ibmlana_probe(struct net_device *dev)
829{
830	int slot, z;
831	int base = 0, irq = 0, iobase = 0, memlen = 0;
832	ibmlana_priv *priv;
833	ibmlana_medium medium;
834
835	SET_MODULE_OWNER(dev);
836
837	/* can't work without an MCA bus ;-) */
838	if (MCA_bus == 0)
839		return -ENODEV;
840
841	base = dev->mem_start;
842	irq = dev->irq;
843
844	for (slot = startslot; (slot = mca_find_adapter(IBM_LANA_ID, slot)) != -1; slot++) {
845		/* deduce card addresses */
846		getaddrs(slot, &base, &memlen, &iobase, &irq, &medium);
847
848		/* slot already in use ? */
849		if (mca_is_adapter_used(slot))
850			continue;
851		/* were we looking for something different ? */
852		if (dev->irq && dev->irq != irq)
853			continue;
854		if (dev->mem_start && dev->mem_start != base)
855			continue;
856		/* found something that matches */
857		break;
858	}
859
860	/* nothing found ? */
861	if (slot == -1)
862		return (base != 0 || irq != 0) ? -ENXIO : -ENODEV;
863
864	/* announce success */
865	printk(KERN_INFO "%s: IBM LAN Adapter/A found in slot %d\n", dev->name, slot + 1);
866
867	/* try to obtain I/O range */
868	if (!request_region(iobase, IBM_LANA_IORANGE, DRV_NAME)) {
869		printk(KERN_ERR "%s: cannot allocate I/O range at %#x!\n", DRV_NAME, iobase);
870		startslot = slot + 1;
871		return -EBUSY;
872	}
873
874	priv = netdev_priv(dev);
875	priv->slot = slot;
876	priv->realirq = irq;
877	priv->medium = medium;
878	spin_lock_init(&priv->lock);
879
880
881	/* set base + irq for this device (irq not allocated so far) */
882
883	dev->irq = 0;
884	dev->mem_start = base;
885	dev->mem_end = base + memlen;
886	dev->base_addr = iobase;
887
888	priv->base = ioremap(base, memlen);
889	if (!priv->base) {
890		printk(KERN_ERR "%s: cannot remap memory!\n", DRV_NAME);
891		startslot = slot + 1;
892		release_region(iobase, IBM_LANA_IORANGE);
893		return -EBUSY;
894	}
895
896	/* make procfs entries */
897	mca_set_adapter_name(slot, "IBM LAN Adapter/A");
898	mca_set_adapter_procfn(slot, (MCA_ProcFn) ibmlana_getinfo, dev);
899
900	mca_mark_as_used(slot);
901
902	/* set methods */
903
904	dev->open = ibmlana_open;
905	dev->stop = ibmlana_close;
906	dev->hard_start_xmit = ibmlana_tx;
907	dev->do_ioctl = NULL;
908	dev->get_stats = ibmlana_stats;
909	dev->set_multicast_list = ibmlana_set_multicast_list;
910	dev->flags |= IFF_MULTICAST;
911
912	/* copy out MAC address */
913
914	for (z = 0; z < sizeof(dev->dev_addr); z++)
915		dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
916
917	/* print config */
918
919	printk(KERN_INFO "%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
920	       "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
921	       dev->name, priv->realirq, dev->base_addr,
922	       dev->mem_start, dev->mem_end - 1,
923	       dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
924	       dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
925	printk(KERN_INFO "%s: %s medium\n", dev->name, MediaNames[priv->medium]);
926
927	/* reset board */
928
929	ResetBoard(dev);
930
931	/* next probe will start at next slot */
932
933	startslot = slot + 1;
934
935	return 0;
936}
937
938/* ------------------------------------------------------------------------
939 * modularization support
940 * ------------------------------------------------------------------------ */
941
942#ifdef MODULE
943
944#define DEVMAX 5
945
946static struct net_device *moddevs[DEVMAX];
947static int irq;
948static int io;
949
950module_param(irq, int, 0);
951module_param(io, int, 0);
952MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
953MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
954MODULE_LICENSE("GPL");
955
956int init_module(void)
957{
958	int z;
959
960	startslot = 0;
961	for (z = 0; z < DEVMAX; z++) {
962		struct net_device *dev = alloc_etherdev(sizeof(ibmlana_priv));
963		if (!dev)
964			break;
965		dev->irq = irq;
966		dev->base_addr = io;
967		if (ibmlana_probe(dev)) {
968			free_netdev(dev);
969			break;
970		}
971		if (register_netdev(dev)) {
972			ibmlana_priv *priv = netdev_priv(dev);
973			release_region(dev->base_addr, IBM_LANA_IORANGE);
974			mca_mark_as_unused(priv->slot);
975			mca_set_adapter_name(priv->slot, "");
976			mca_set_adapter_procfn(priv->slot, NULL, NULL);
977			iounmap(priv->base);
978			free_netdev(dev);
979			break;
980		}
981		moddevs[z] = dev;
982	}
983	return (z > 0) ? 0 : -EIO;
984}
985
986void cleanup_module(void)
987{
988	int z;
989	for (z = 0; z < DEVMAX; z++) {
990		struct net_device *dev = moddevs[z];
991		if (dev) {
992			ibmlana_priv *priv = netdev_priv(dev);
993			unregister_netdev(dev);
994			/*DeinitBoard(dev); */
995			release_region(dev->base_addr, IBM_LANA_IORANGE);
996			mca_mark_as_unused(priv->slot);
997			mca_set_adapter_name(priv->slot, "");
998			mca_set_adapter_procfn(priv->slot, NULL, NULL);
999			iounmap(priv->base);
1000			free_netdev(dev);
1001		}
1002	}
1003}
1004#endif				/* MODULE */
1005