xref: /netbsd-src/sys/dev/qbus/if_il.c (revision 4b2769fe52b586c4d7d9e7cc506c2247ed060a04)
1 /*	$NetBSD: if_il.c,v 1.37 2021/08/01 15:29:30 andvar Exp $	*/
2 /*
3  * Copyright (c) 1982, 1986 Regents of the University of California.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. Neither the name of the University nor the names of its contributors
15  *    may be used to endorse or promote products derived from this software
16  *    without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  *	@(#)if_il.c	7.8 (Berkeley) 12/16/90
31  */
32 
33 /*
34  * Interlan Ethernet Communications Controller interface
35  */
36 
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: if_il.c,v 1.37 2021/08/01 15:29:30 andvar Exp $");
39 
40 #include "opt_inet.h"
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/mbuf.h>
45 #include <sys/buf.h>
46 #include <sys/protosw.h>
47 #include <sys/socket.h>
48 #include <sys/ioctl.h>
49 #include <sys/errno.h>
50 #include <sys/syslog.h>
51 #include <sys/device.h>
52 
53 #include <net/if.h>
54 #include <net/if_ether.h>
55 #include <net/if_dl.h>
56 
57 #ifdef INET
58 #include <netinet/in.h>
59 #endif
60 
61 
62 #include <sys/bus.h>
63 
64 #include <dev/qbus/ubareg.h>
65 #include <dev/qbus/ubavar.h>
66 #include <dev/qbus/if_uba.h>
67 
68 #include <dev/qbus/if_il.h>
69 #include <dev/qbus/if_ilreg.h>
70 
71 /*
72  * Ethernet software status per interface.
73  *
74  * Each interface is referenced by a network interface structure,
75  * is_if, which the routing code uses to locate the interface.
76  * This structure contains the output queue for the interface, its address, ...
77  * We also have, for each interface, a UBA interface structure, which
78  * contains information about the UNIBUS resources held by the interface:
79  * map registers, buffered data paths, etc.  Information is cached in this
80  * structure for use by the if_uba.c routines in running the interface
81  * efficiently.
82  */
83 
84 struct	il_softc {
85 	device_t sc_dev;		/* Configuration common part */
86 	struct ethercom sc_ec;		/* Ethernet common part */
87 #define	sc_if	sc_ec.ec_if		/* network-visible interface */
88 	struct evcnt sc_cintrcnt;	/* Command interrupts */
89 	struct evcnt sc_rintrcnt;	/* Receive interrupts */
90 	bus_space_tag_t sc_iot;
91 	bus_addr_t sc_ioh;
92 	bus_dma_tag_t sc_dmat;
93 	struct	ubinfo sc_ui;
94 
95 	struct	ifuba sc_ifuba;		/* UNIBUS resources */
96 	int	sc_flags;
97 #define	ILF_RCVPENDING	0x2		/* start rcv in ilcint */
98 #define	ILF_STATPENDING	0x4		/* stat cmd pending */
99 #define	ILF_RUNNING	0x8		/* board is running */
100 #define	ILF_SETADDR	0x10		/* physical address is changed */
101 	short	sc_lastcmd;		/* can't read csr, so must save it */
102 	short	sc_scaninterval;	/* interval of stat collection */
103 #define	ILWATCHINTERVAL	60		/* once every 60 seconds */
104 	union {
105 	    struct	il_stats isu_stats;	/* holds on-board statistics */
106 	    struct	ether_addr isu_maddrs[63];	/* multicast addrs */
107 	}	sc_isu;
108 #define sc_stats	sc_isu.isu_stats
109 #define sc_maddrs	sc_isu.isu_maddrs
110 	struct	il_stats sc_sum;	/* summation over time */
111 	int	sc_ubaddr;		/* mapping registers of is_stats */
112 };
113 
114 static	int ilmatch(device_t, cfdata_t, void *);
115 static	void ilattach(device_t, device_t, void *);
116 static	void ilcint(void *);
117 static	void ilrint(void *);
118 static	void ilreset(device_t);
119 static	int ilwait(struct il_softc *, const char *);
120 static	int ilinit(struct ifnet *);
121 static	void ilstart(struct ifnet *);
122 static	void ilwatch(struct ifnet *);
123 static	void iltotal(struct il_softc *);
124 static	void ilstop(struct ifnet *, int);
125 
126 CFATTACH_DECL_NEW(il, sizeof(struct il_softc),
127     ilmatch, ilattach, NULL, NULL);
128 
129 #define IL_WCSR(csr, val) \
130 	bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val)
131 #define IL_RCSR(csr) \
132 	bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr)
133 #define LOWORD(x)	((int)(x) & 0xffff)
134 #define HIWORD(x)	(((int)(x) >> 16) & 0x3)
135 
136 int
ilmatch(device_t parent,cfdata_t cf,void * aux)137 ilmatch(device_t parent, cfdata_t cf, void *aux)
138 {
139 	struct uba_attach_args *ua = aux;
140 
141 	bus_space_write_2(ua->ua_iot, ua->ua_ioh, IL_CSR,
142 	    ILC_OFFLINE | IL_CIE);
143 	DELAY(100000);
144 	bus_space_read_2(ua->ua_iot, ua->ua_ioh, IL_CSR); /* clear CDONE */
145 
146 	return 1;
147 }
148 
149 /*
150  * Interface exists: make available by filling in network interface
151  * record.  System will initialize the interface when it is ready
152  * to accept packets.  A STATUS command is done to get the ethernet
153  * address and other interesting data.
154  */
155 void
ilattach(device_t parent,device_t self,void * aux)156 ilattach(device_t parent, device_t self, void *aux)
157 {
158 	struct uba_attach_args *ua = aux;
159 	struct il_softc *sc = device_private(self);
160 	struct ifnet *ifp = &sc->sc_if;
161 	int error;
162 
163 	sc->sc_dev = self;
164 	sc->sc_iot = ua->ua_iot;
165 	sc->sc_ioh = ua->ua_ioh;
166 	sc->sc_dmat = ua->ua_dmat;
167 
168 	/*
169 	 * Map interrupt vectors and reset function.
170 	 */
171 	uba_intr_establish(ua->ua_icookie, ua->ua_cvec, ilcint,
172 	    sc, &sc->sc_cintrcnt);
173 	evcnt_attach_dynamic(&sc->sc_cintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
174 	    device_xname(sc->sc_dev), "intr");
175 	uba_intr_establish(ua->ua_icookie, ua->ua_cvec-4, ilrint,
176 	    sc, &sc->sc_rintrcnt);
177 	evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
178 	    device_xname(sc->sc_dev), "intr");
179 	uba_reset_establish(ilreset, sc->sc_dev);
180 
181 	/*
182 	 * Reset the board and map the statistics
183 	 * buffer onto the Unibus.
184 	 */
185 	IL_WCSR(IL_CSR, ILC_RESET);
186 	(void)ilwait(sc, "reset");
187 	sc->sc_ui.ui_size = sizeof(struct il_stats);
188 	sc->sc_ui.ui_vaddr = (void *)&sc->sc_stats;
189 	if ((error = uballoc(device_private(parent), &sc->sc_ui, 0)))
190 		return printf(": failed uballoc, error = %d\n", error);
191 
192 	IL_WCSR(IL_BAR, LOWORD(sc->sc_ui.ui_baddr));
193 	IL_WCSR(IL_BCR, sizeof(struct il_stats));
194 	IL_WCSR(IL_CSR, ((sc->sc_ui.ui_baddr >> 2) & IL_EUA) | ILC_STAT);
195 	(void)ilwait(sc, "status");
196 	ubfree(device_private(parent), &sc->sc_ui);
197 	printf("%s: module=%s firmware=%s\n", device_xname(sc->sc_dev),
198 		sc->sc_stats.ils_module, sc->sc_stats.ils_firmware);
199 	printf("%s: hardware address %s\n", device_xname(sc->sc_dev),
200 		ether_sprintf(sc->sc_stats.ils_addr));
201 
202 	strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
203 	ifp->if_softc = sc;
204 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
205 	ifp->if_init = ilinit;
206 	ifp->if_stop = ilstop;
207 	ifp->if_ioctl = ether_ioctl;
208 	ifp->if_start = ilstart;
209 	ifp->if_watchdog = ilwatch;
210 	IFQ_SET_READY(&ifp->if_snd);
211 
212 	if_attach(ifp);
213 	ether_ifattach(ifp, sc->sc_stats.ils_addr);
214 }
215 
216 void
ilstop(struct ifnet * ifp,int a)217 ilstop(struct ifnet *ifp, int a)
218 {
219 	struct il_softc *sc = ifp->if_softc;
220 
221 	IL_WCSR(IL_CSR, ILC_RESET);
222 }
223 
224 
225 int
ilwait(struct il_softc * sc,const char * op)226 ilwait(struct il_softc *sc, const char *op)
227 {
228 
229 	while ((IL_RCSR(IL_CSR)&IL_CDONE) == 0)
230 		;
231 	if (IL_RCSR(IL_CSR)&IL_STATUS) {
232 		char bits[64];
233 
234 		snprintb(bits, sizeof(bits), IL_BITS, IL_RCSR(IL_CSR));
235 		aprint_error_dev(sc->sc_dev, "%s failed, csr=%s\n", op, bits);
236 		return -1;
237 	}
238 	return 0;
239 }
240 
241 /*
242  * Reset of interface after UNIBUS reset.
243  * If interface is on specified uba, reset its state.
244  */
245 void
ilreset(device_t dev)246 ilreset(device_t dev)
247 {
248 	struct il_softc *sc = (void *)dev;
249 
250 	printf(" %s", device_xname(sc->sc_dev));
251 	sc->sc_if.if_flags &= ~IFF_RUNNING;
252 	sc->sc_flags &= ~ILF_RUNNING;
253 	ilinit(&sc->sc_if);
254 }
255 
256 /*
257  * Initialization of interface; clear recorded pending
258  * operations, and reinitialize UNIBUS usage.
259  */
260 int
ilinit(struct ifnet * ifp)261 ilinit(struct ifnet *ifp)
262 {
263 	struct il_softc *sc = ifp->if_softc;
264 	int s;
265 
266 	if (sc->sc_flags & ILF_RUNNING)
267 		return 0;
268 
269 	if ((ifp->if_flags & IFF_RUNNING) == 0) {
270 		if (if_ubainit(&sc->sc_ifuba,
271 		    device_private(device_parent(sc->sc_dev)),
272 		    ETHER_MAX_LEN)) {
273 			aprint_error_dev(sc->sc_dev, "can't initialize\n");
274 			sc->sc_if.if_flags &= ~IFF_UP;
275 			return 0;
276 		}
277 		sc->sc_ui.ui_size = sizeof(sc->sc_isu);
278 		sc->sc_ui.ui_vaddr = (void *)&sc->sc_isu;
279 		uballoc(device_private(device_parent(sc->sc_dev)),
280 		    &sc->sc_ui, 0);
281 	}
282 	sc->sc_scaninterval = ILWATCHINTERVAL;
283 	ifp->if_timer = sc->sc_scaninterval;
284 
285 	/*
286 	 * Turn off source address insertion (it's faster this way),
287 	 * and set board online.  Former doesn't work if board is
288 	 * already online (happens on ubareset), so we put it offline
289 	 * first.
290 	 */
291 	s = splnet();
292 	IL_WCSR(IL_CSR, ILC_RESET);
293 	if (ilwait(sc, "hardware diag")) {
294 		sc->sc_if.if_flags &= ~IFF_UP;
295 		goto out;
296 	}
297 	IL_WCSR(IL_CSR, ILC_CISA);
298 	while ((IL_RCSR(IL_CSR) & IL_CDONE) == 0)
299 		;
300 	/*
301 	 * If we must reprogram this board's physical ethernet
302 	 * address (as for secondary XNS interfaces), we do so
303 	 * before putting it on line, and starting receive requests.
304 	 * If you try this on an older 1010 board, it will total
305 	 * wedge the board.
306 	 */
307 	if (sc->sc_flags & ILF_SETADDR) {
308 		memcpy(&sc->sc_isu, CLLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
309 		IL_WCSR(IL_BAR, LOWORD(sc->sc_ui.ui_baddr));
310 		IL_WCSR(IL_BCR, ETHER_ADDR_LEN);
311 		IL_WCSR(IL_CSR,
312 		    ((sc->sc_ui.ui_baddr >> 2) & IL_EUA) | ILC_LDPA);
313 		if (ilwait(sc, "setaddr"))
314 			goto out;
315 		IL_WCSR(IL_BAR, LOWORD(sc->sc_ui.ui_baddr));
316 		IL_WCSR(IL_BCR, sizeof (struct il_stats));
317 		IL_WCSR(IL_CSR,
318 		    ((sc->sc_ui.ui_baddr >> 2) & IL_EUA) | ILC_STAT);
319 		if (ilwait(sc, "verifying setaddr"))
320 			goto out;
321 		if (memcmp(sc->sc_stats.ils_addr,
322 		    CLLADDR(ifp->if_sadl), ETHER_ADDR_LEN) != 0) {
323 			aprint_error_dev(sc->sc_dev, "setaddr didn't work\n");
324 			goto out;
325 		}
326 	}
327 	if (sc->sc_if.if_flags & IFF_PROMISC) {
328 		IL_WCSR(IL_CSR, ILC_PRMSC);
329 		if (ilwait(sc, "all multi"))
330 			goto out;
331 	} else if (sc->sc_if.if_flags & IFF_ALLMULTI) {
332 too_many_multis:
333 		IL_WCSR(IL_CSR, ILC_ALLMC);
334 		if (ilwait(sc, "all multi"))
335 			goto out;
336 	} else {
337 		int i;
338 		struct ethercom *ec = &sc->sc_ec;
339 		register struct ether_addr *ep = sc->sc_maddrs;
340 		struct ether_multi *enm;
341 		struct ether_multistep step;
342 		/*
343 		 * Step through our list of multicast addresses.  If we have
344 		 * too many multicast addresses, or if we have to listen to
345 		 * a range of multicast addresses, turn on reception of all
346 		 * multicasts.
347 		 */
348 		i = 0;
349 		ETHER_LOCK(ec);
350 		ETHER_FIRST_MULTI(step, ec, enm);
351 		while (enm != NULL) {
352 			if (++i > 63 /* && k != 0 */) {
353 				break;
354 			}
355 			*ep++ = *(struct ether_addr *)enm->enm_addrlo;
356 			ETHER_NEXT_MULTI(step, enm);
357 		}
358 		ETHER_UNLOCK(ec);
359 		if (i == 0) {
360 			/* no multicasts! */
361 		} else if (i <= 63) {
362 			IL_WCSR(IL_BAR, sc->sc_ubaddr & 0xffff);
363 			IL_WCSR(IL_BCR, i * sizeof(struct ether_addr));
364 			IL_WCSR(IL_CSR,
365 			    ((sc->sc_ubaddr >> 2) & IL_EUA) | ILC_LDGRPS);
366 			if (ilwait(sc, "load multi"))
367 				goto out;
368 		} else {
369 			sc->sc_if.if_flags |= IFF_ALLMULTI;
370 			goto too_many_multis;
371 		}
372 	}
373 	/*
374 	 * Set board online.
375 	 * Hang receive buffer and start any pending
376 	 * writes by faking a transmit complete.
377 	 * Receive bcr is not a multiple of 8 so buffer
378 	 * chaining can't happen.
379 	 */
380 	IL_WCSR(IL_CSR, ILC_ONLINE);
381 	while ((IL_RCSR(IL_CSR) & IL_CDONE) == 0)
382 		;
383 
384 	IL_WCSR(IL_BAR, LOWORD(sc->sc_ifuba.ifu_r.ifrw_info));
385 	IL_WCSR(IL_BCR, sizeof(struct il_rheader) + ETHERMTU + 6);
386 	IL_WCSR(IL_CSR,
387 	    ((sc->sc_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA) | ILC_RCV | IL_RIE);
388 	while ((IL_RCSR(IL_CSR) & IL_CDONE) == 0)
389 		;
390 	ifp->if_flags |= IFF_RUNNING | IFF_OACTIVE;
391 	sc->sc_flags |= ILF_RUNNING;
392 	sc->sc_lastcmd = 0;
393 	ilcint(sc);
394 out:
395 	splx(s);
396 	return 0;
397 }
398 
399 /*
400  * Start output on interface.
401  * Get another datagram to send off of the interface queue,
402  * and map it to the interface before starting the output.
403  */
404 void
ilstart(struct ifnet * ifp)405 ilstart(struct ifnet *ifp)
406 {
407 	struct il_softc *sc = ifp->if_softc;
408 	int len;
409 	struct mbuf *m;
410 	short csr;
411 
412 	IFQ_DEQUEUE(&ifp->if_snd, m);
413 	if (m == 0) {
414 		if ((sc->sc_flags & ILF_STATPENDING) == 0)
415 			return;
416 		IL_WCSR(IL_BAR, LOWORD(sc->sc_ui.ui_baddr));
417 		IL_WCSR(IL_BCR, sizeof (struct il_stats));
418 		csr = ((sc->sc_ui.ui_baddr >> 2) & IL_EUA)
419 		    | ILC_STAT | IL_RIE | IL_CIE;
420 		sc->sc_flags &= ~ILF_STATPENDING;
421 		goto startcmd;
422 	}
423 	len = if_wubaput(&sc->sc_ifuba, m);
424 #ifdef notdef
425 	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
426 		UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_w.ifrw_bdp);
427 #endif
428 	IL_WCSR(IL_BAR, LOWORD(sc->sc_ifuba.ifu_w.ifrw_info));
429 	IL_WCSR(IL_BCR, len);
430 	csr = ((sc->sc_ifuba.ifu_w.ifrw_info >> 2) & IL_EUA)
431 	    | ILC_XMIT | IL_CIE | IL_RIE;
432 
433 startcmd:
434 	sc->sc_lastcmd = csr & IL_CMD;
435 	IL_WCSR(IL_CSR, csr);
436 	ifp->if_flags |= IFF_OACTIVE;
437 	return;
438 }
439 
440 /*
441  * Command done interrupt.
442  */
443 void
ilcint(void * arg)444 ilcint(void *arg)
445 {
446 	struct il_softc *sc = arg;
447 	short csr;
448 
449 	if ((sc->sc_if.if_flags & IFF_OACTIVE) == 0) {
450 		char bits[64];
451 
452 		snprintb(bits, sizeof(bits), IL_BITS, IL_RCSR(IL_CSR));
453 		aprint_error_dev(sc->sc_dev,
454 				 "stray xmit interrupt, csr=%s\n", bits);
455 		return;
456 	}
457 
458 	csr = IL_RCSR(IL_CSR);
459 	/*
460 	 * Hang receive buffer if it couldn't
461 	 * be done earlier (in ilrint).
462 	 */
463 	if (sc->sc_flags & ILF_RCVPENDING) {
464 		int s;
465 
466 		IL_WCSR(IL_BAR, LOWORD(sc->sc_ifuba.ifu_r.ifrw_info));
467 		IL_WCSR(IL_BCR, sizeof(struct il_rheader) + ETHERMTU + 6);
468 		IL_WCSR(IL_CSR, ((sc->sc_ifuba.ifu_r.ifrw_info>>2) & IL_EUA)
469 		    | ILC_RCV | IL_RIE);
470 		s = splhigh();
471 		while ((IL_RCSR(IL_CSR) & IL_CDONE) == 0)
472 			;
473 		splx(s);
474 		sc->sc_flags &= ~ILF_RCVPENDING;
475 	}
476 	sc->sc_if.if_flags &= ~IFF_OACTIVE;
477 	csr &= IL_STATUS;
478 	switch (sc->sc_lastcmd) {
479 
480 	case ILC_XMIT:
481 		sc->sc_if.if_opackets++;
482 		if (csr > ILERR_RETRIES)
483 			sc->sc_if.if_oerrors++;
484 		break;
485 
486 	case ILC_STAT:
487 		if (csr == ILERR_SUCCESS)
488 			iltotal(sc);
489 		break;
490 	}
491 	if_wubaend(&sc->sc_ifuba);
492 	ilstart(&sc->sc_if);
493 }
494 
495 /*
496  * Ethernet interface receiver interrupt.
497  * If input error just drop packet.
498  * Otherwise purge input buffered data path and examine
499  * packet to determine type.  If can't determine length
500  * from type, then have to drop packet.  Otherwise decapsulate
501  * packet based on type and pass to type specific higher-level
502  * input routine.
503  */
504 void
ilrint(void * arg)505 ilrint(void *arg)
506 {
507 	struct il_softc *sc = arg;
508 	struct il_rheader *il;
509 	struct mbuf *m;
510 	int len, s;
511 
512 #ifdef notyet
513 	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
514 		UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_r.ifrw_bdp);
515 #endif
516 	il = (struct il_rheader *)(sc->sc_ifuba.ifu_r.ifrw_addr);
517 	len = il->ilr_length - sizeof(struct il_rheader);
518 	if ((il->ilr_status&(ILFSTAT_A | ILFSTAT_C)) || len < 46 ||
519 	    len > ETHERMTU) {
520 		sc->sc_if.if_ierrors++;
521 #ifdef notdef
522 		if (sc->sc_if.if_ierrors % 100 == 0)
523 			printf("il%d: += 100 input errors\n", unit);
524 #endif
525 		goto setup;
526 	}
527 
528 	if (len == 0)
529 		goto setup;
530 
531 	/*
532 	 * Pull packet off interface.
533 	 */
534 	m = if_rubaget(&sc->sc_ifuba, &sc->sc_if, len);
535 	if (m == NULL)
536 		goto setup;
537 
538 	/* Shave off status hdr */
539 	m_adj(m, 4);
540 	if_percpuq_enqueue((&sc->sc_if)->if_percpuq, m);
541 setup:
542 	/*
543 	 * Reset for next packet if possible.
544 	 * If waiting for transmit command completion, set flag
545 	 * and wait until command completes.
546 	 */
547 	if (sc->sc_if.if_flags & IFF_OACTIVE) {
548 		sc->sc_flags |= ILF_RCVPENDING;
549 		return;
550 	}
551 	IL_WCSR(IL_BAR, LOWORD(sc->sc_ifuba.ifu_r.ifrw_info));
552 	IL_WCSR(IL_BCR, sizeof(struct il_rheader) + ETHERMTU + 6);
553 	IL_WCSR(IL_CSR,
554 	    ((sc->sc_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA) | ILC_RCV | IL_RIE);
555 	s = splhigh();
556 	while ((IL_RCSR(IL_CSR) & IL_CDONE) == 0)
557 		;
558 	splx(s);
559 }
560 /*
561  * Watchdog routine, request statistics from board.
562  */
563 void
ilwatch(struct ifnet * ifp)564 ilwatch(struct ifnet *ifp)
565 {
566 	struct il_softc *sc = ifp->if_softc;
567 	int s;
568 
569 	if (sc->sc_flags & ILF_STATPENDING) {
570 		ifp->if_timer = sc->sc_scaninterval;
571 		return;
572 	}
573 	s = splnet();
574 	sc->sc_flags |= ILF_STATPENDING;
575 	if ((sc->sc_if.if_flags & IFF_OACTIVE) == 0)
576 		ilstart(ifp);
577 	splx(s);
578 	ifp->if_timer = sc->sc_scaninterval;
579 }
580 
581 /*
582  * Total up the on-board statistics.
583  */
584 void
iltotal(struct il_softc * sc)585 iltotal(struct il_softc *sc)
586 {
587 	struct ifnet *ifp = &sc->sc_if;
588 	u_short *interval, *sum, *end;
589 
590 	interval = &sc->sc_stats.ils_frames;
591 	sum = &sc->sc_sum.ils_frames;
592 	end = sc->sc_sum.ils_fill2;
593 	while (sum < end)
594 		*sum++ += *interval++;
595 	sc->sc_if.if_collisions = sc->sc_sum.ils_collis;
596 	if ((sc->sc_flags & ILF_SETADDR) &&
597 	    (memcmp(sc->sc_stats.ils_addr, CLLADDR(ifp->if_sadl),
598 		    ETHER_ADDR_LEN) != 0)) {
599 		log(LOG_ERR, "%s: physaddr reverted\n",
600 		    device_xname(sc->sc_dev));
601 		sc->sc_flags &= ~ILF_RUNNING;
602 		ilinit(&sc->sc_if);
603 	}
604 }
605 
606 #ifdef notyet
607 /*
608  * set ethernet address for unit
609  */
610 void
il_setaddr(u_char * physaddr,struct il_softc * sc)611 il_setaddr(u_char *physaddr, struct il_softc *sc)
612 {
613 	if (! (sc->sc_flags & ILF_RUNNING))
614 		return;
615 
616 	memcpy((void *)is->is_addr, (void *)physaddr, sizeof is->is_addr);
617 	sc->sc_flags &= ~ILF_RUNNING;
618 	sc->sc_flags |= ILF_SETADDR;
619 	ilinit(&sc->sc_if);
620 }
621 #endif
622