1/*-
2 * Copyright (c) 1992, 1993, University of Vermont and State
3 *  Agricultural College.
4 * Copyright (c) 1992, 1993, Garrett A. Wollman.
5 *
6 * Portions:
7 * Copyright (c) 1990, 1991, William F. Jolitz
8 * Copyright (c) 1990, The Regents of the University of California
9 *
10 * 3Com 3C507 support:
11 * Copyright (c) 1993, 1994, Charles M. Hannum
12 *
13 * EtherExpress 16 support:
14 * Copyright (c) 1993, 1994, 1995, Rodney W. Grimes
15 * Copyright (c) 1997, Aaron C. Smith
16 *
17 * All rights reserved.
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
21 * are met:
22 * 1. Redistributions of source code must retain the above copyright
23 *    notice, this list of conditions and the following disclaimer.
24 * 2. Redistributions in binary form must reproduce the above copyright
25 *    notice, this list of conditions and the following disclaimer in the
26 *    documentation and/or other materials provided with the distribution.
27 * 3. All advertising materials mentioning features or use of this software
28 *    must display the following acknowledgement:
29 *	This product includes software developed by the University of
30 *	Vermont and State Agricultural College and Garrett A. Wollman, by
31 *	William F. Jolitz, by the University of California, Berkeley,
32 *	Lawrence Berkeley Laboratory, and their contributors, by
33 *	Charles M. Hannum, by Rodney W. Grimes, and by Aaron C. Smith.
34 * 4. Neither the names of the Universities nor the names of the authors
35 *    may be used to endorse or promote products derived from this software
36 *    without specific prior written permission.
37 *
38 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
39 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
41 * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR AUTHORS BE LIABLE
42 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
43 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
44 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
45 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
46 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
47 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48 * SUCH DAMAGE.
49 *
50 * MAINTAINER: Matthew N. Dodd <winter@jurai.net>
51 */
52
53#include <sys/cdefs.h>
54__FBSDID("$FreeBSD$");
55
56/*
57 * Intel 82586 Ethernet chip
58 * Register, bit, and structure definitions.
59 *
60 * Written by GAW with reference to the Clarkson Packet Driver code for this
61 * chip written by Russ Nelson and others.
62 *
63 * Intel EtherExpress 16 support from if_ix.c, written by Rodney W. Grimes.
64 */
65
66/*
67 * The i82586 is a very versatile chip, found in many implementations.
68 * Programming this chip is mostly the same, but certain details differ
69 * from card to card.  This driver is written so that different cards
70 * can be automatically detected at run-time.
71 */
72
73/*
74 * Mode of operation:
75 *
76 * We run the 82586 in a standard Ethernet mode.  We keep NFRAMES
77 * received frame descriptors around for the receiver to use, and
78 * NRXBUFS associated receive buffer descriptors, both in a circular
79 * list.  Whenever a frame is received, we rotate both lists as
80 * necessary.  (The 586 treats both lists as a simple queue.)  We also
81 * keep a transmit command around so that packets can be sent off
82 * quickly.
83 *
84 * We configure the adapter in AL-LOC = 1 mode, which means that the
85 * Ethernet/802.3 MAC header is placed at the beginning of the receive
86 * buffer rather than being split off into various fields in the RFD.
87 * This also means that we must include this header in the transmit
88 * buffer as well.
89 *
90 * By convention, all transmit commands, and only transmit commands,
91 * shall have the I (IE_CMD_INTR) bit set in the command.  This way,
92 * when an interrupt arrives at ieintr(), it is immediately possible
93 * to tell what precisely caused it.  ANY OTHER command-sending routines
94 * should run at splimp(), and should post an acknowledgement to every
95 * interrupt they generate.
96 *
97 * The 82586 has a 24-bit address space internally, and the adaptor's
98 * memory is located at the top of this region.  However, the value
99 * we are given in configuration is normally the *bottom* of the adaptor
100 * RAM.  So, we must go through a few gyrations to come up with a
101 * kernel virtual address which represents the actual beginning of the
102 * 586 address space.  First, we autosize the RAM by running through
103 * several possible sizes and trying to initialize the adapter under
104 * the assumption that the selected size is correct.  Then, knowing
105 * the correct RAM size, we set up our pointers in the softc `iomem'
106 * represents the computed base of the 586 address space.  `iomembot'
107 * represents the actual configured base of adapter RAM.  Finally,
108 * `iosize' represents the calculated size of 586 RAM.  Then, when
109 * laying out commands, we use the interval [iomembot, iomembot +
110 * iosize); to make 24-pointers, we subtract iomem, and to make
111 * 16-pointers, we subtract iomem and and with 0xffff.
112 */
113
114#include <sys/param.h>
115#include <sys/systm.h>
116#include <sys/eventhandler.h>
117#include <sys/kernel.h>
118#include <sys/malloc.h>
119#include <sys/mbuf.h>
120#include <sys/socket.h>
121#include <sys/sockio.h>
122#include <sys/syslog.h>
123
124#include <sys/module.h>
125#include <sys/bus.h>
126
127#include <machine/bus.h>
128#include <machine/resource.h>
129#include <sys/rman.h>
130
131#include <net/ethernet.h>
132#include <net/if.h>
133#include <net/if_types.h>
134#include <net/if_dl.h>
135
136#include <netinet/in.h>
137#include <netinet/if_ether.h>
138
139#include <dev/ic/i82586.h>
140#include <dev/ie/if_ievar.h>
141#include <dev/ie/if_iereg.h>
142#include <dev/ie/if_ie507.h>
143#include <dev/ie/if_iee16.h>
144#include <i386/isa/elink.h>
145
146#include <net/bpf.h>
147
148#ifdef DEBUG
149#define IED_RINT	0x01
150#define IED_TINT	0x02
151#define IED_RNR		0x04
152#define IED_CNA		0x08
153#define IED_READFRAME	0x10
154static int	ie_debug = IED_RNR;
155
156#endif
157
158#define IE_BUF_LEN	ETHER_MAX_LEN	/* length of transmit buffer */
159
160/* XXX this driver uses `volatile' and `caddr_t' to a fault. */
161typedef	volatile char *v_caddr_t;	/* core address, pointer to volatile */
162
163/* Forward declaration */
164struct ie_softc;
165
166static void	ieinit			(void *);
167static void	ieinit_locked		(struct ie_softc *);
168static void	ie_stop			(struct ie_softc *);
169static int	ieioctl			(struct ifnet *, u_long, caddr_t);
170static void	iestart			(struct ifnet *);
171static void	iestart_locked		(struct ifnet *);
172
173static __inline void
174		ee16_interrupt_enable	(struct ie_softc *);
175static void	ee16_eeprom_outbits	(struct ie_softc *, int, int);
176static void	ee16_eeprom_clock	(struct ie_softc *, int);
177static u_short	ee16_read_eeprom	(struct ie_softc *, int);
178static int	ee16_eeprom_inbits	(struct ie_softc *);
179
180static __inline void
181		ie_ack			(struct ie_softc *, u_int);
182static void	iereset			(struct ie_softc *);
183static void	ie_readframe		(struct ie_softc *, int);
184static void	ie_drop_packet_buffer	(struct ie_softc *);
185static void	find_ie_mem_size	(struct ie_softc *);
186static int	command_and_wait	(struct ie_softc *,
187					 int, void volatile *, int);
188static void	run_tdr			(struct ie_softc *,
189					 volatile struct ie_tdr_cmd *);
190static int	ierint			(struct ie_softc *);
191static int	ietint			(struct ie_softc *);
192static int	iernr			(struct ie_softc *);
193static void	start_receiver		(struct ie_softc *);
194static __inline int
195		ieget			(struct ie_softc *, struct mbuf **);
196static v_caddr_t setup_rfa		(struct ie_softc *, v_caddr_t);
197static int	mc_setup		(struct ie_softc *);
198static void	ie_mc_reset		(struct ie_softc *);
199
200#ifdef DEBUG
201static void	print_rbd		(volatile struct ie_recv_buf_desc * rbd);
202static int	in_ierint = 0;
203static int	in_ietint = 0;
204#endif
205
206static const char *ie_hardware_names[] = {
207	"None",
208	"StarLAN 10",
209	"EN100",
210	"StarLAN Fiber",
211	"3C507",
212	"NI5210",
213	"EtherExpress 16",
214	"Unknown"
215};
216
217/*
218 * sizeof(iscp) == 1+1+2+4 == 8
219 * sizeof(scb) == 2+2+2+2+2+2+2+2 == 16
220 * NFRAMES * sizeof(rfd) == NFRAMES*(2+2+2+2+6+6+2+2) == NFRAMES*24 == 384
221 * sizeof(xmit_cmd) == 2+2+2+2+6+2 == 18
222 * sizeof(transmit buffer) == 1512
223 * sizeof(transmit buffer desc) == 8
224 * -----
225 * 1946
226 *
227 * NRXBUFS * sizeof(rbd) == NRXBUFS*(2+2+4+2+2) == NRXBUFS*12
228 * NRXBUFS * IE_RBUF_SIZE == NRXBUFS*256
229 *
230 * NRXBUFS should be (16384 - 1946) / (256 + 12) == 14438 / 268 == 53
231 *
232 * With NRXBUFS == 48, this leaves us 1574 bytes for another command or
233 * more buffers.  Another transmit command would be 18+8+1512 == 1538
234 * ---just barely fits!
235 *
236 * Obviously all these would have to be reduced for smaller memory sizes.
237 * With a larger memory, it would be possible to roughly double the number
238 * of both transmit and receive buffers.
239 */
240
241#define	NFRAMES		4	/* number of receive frames */
242#define	NRXBUFS		24	/* number of buffers to allocate */
243#define	IE_RBUF_SIZE	256	/* size of each buffer, MUST BE POWER OF TWO */
244#define	NTXBUFS		1	/* number of transmit commands */
245#define	IE_TBUF_SIZE	ETHER_MAX_LEN	/* size of transmit buffer */
246
247#define MK_24(base, ptr) ((caddr_t)((uintptr_t)ptr - (uintptr_t)base))
248#define MK_16(base, ptr) ((u_short)(uintptr_t)MK_24(base, ptr))
249
250void
251ee16_shutdown(struct ie_softc *sc)
252{
253
254	ee16_reset_586(sc);
255	outb(PORT(sc) + IEE16_ECTRL, IEE16_RESET_ASIC);
256	outb(PORT(sc) + IEE16_ECTRL, 0);
257}
258
259/*
260 * Taken almost exactly from Bill's if_is.c, then modified beyond recognition.
261 */
262int
263ie_attach(device_t dev)
264{
265	struct ie_softc *       sc;
266	struct ifnet *          ifp;
267	size_t                  allocsize;
268	int                     error, factor;
269
270	sc = device_get_softc(dev);
271	ifp = sc->ifp = if_alloc(IFT_ETHER);
272	if (ifp == NULL) {
273		device_printf(sc->dev, "can not if_alloc()\n");
274		return (ENOSPC);
275	}
276
277	sc->dev = dev;
278	mtx_init(&sc->lock, device_get_nameunit(dev), MTX_NETWORK_LOCK,
279	    MTX_DEF);
280
281	/*
282	 * based on the amount of memory we have, allocate our tx and rx
283	 * resources.
284	 */
285	factor = rman_get_size(sc->mem_res) / 8192;
286	sc->nframes = factor * NFRAMES;
287	sc->nrxbufs = factor * NRXBUFS;
288	sc->ntxbufs = factor * NTXBUFS;
289
290	/*
291	 * Since all of these guys are arrays of pointers, allocate as one
292	 * big chunk and dole out accordingly.
293	 */
294	allocsize = sizeof(void *) * (sc->nframes
295				      + (sc->nrxbufs * 2)
296				      + (sc->ntxbufs * 3));
297	sc->rframes = (volatile struct ie_recv_frame_desc **) malloc(allocsize,
298								     M_DEVBUF,
299								   M_NOWAIT);
300	if (sc->rframes == NULL) {
301		mtx_destroy(&sc->lock);
302		return (ENXIO);
303	}
304	sc->rbuffs =
305	    (volatile struct ie_recv_buf_desc **)&sc->rframes[sc->nframes];
306	sc->cbuffs = (volatile u_char **)&sc->rbuffs[sc->nrxbufs];
307	sc->xmit_cmds =
308	    (volatile struct ie_xmit_cmd **)&sc->cbuffs[sc->nrxbufs];
309	sc->xmit_buffs =
310	    (volatile struct ie_xmit_buf **)&sc->xmit_cmds[sc->ntxbufs];
311	sc->xmit_cbuffs = (volatile u_char **)&sc->xmit_buffs[sc->ntxbufs];
312
313	if (bootverbose)
314		device_printf(sc->dev, "hardware type %s, revision %d\n",
315			ie_hardware_names[sc->hard_type], sc->hard_vers + 1);
316
317	ifp->if_softc = sc;
318	if_initname(ifp, device_get_name(dev), device_get_unit(dev));
319	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
320	ifp->if_start = iestart;
321	ifp->if_ioctl = ieioctl;
322	ifp->if_init = ieinit;
323	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
324
325	ether_ifattach(ifp, sc->enaddr);
326
327	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET | INTR_MPSAFE,
328				NULL, ie_intr, sc, &sc->irq_ih);
329	if (error) {
330		device_printf(dev, "Unable to register interrupt handler\n");
331		mtx_destroy(&sc->lock);
332		return (error);
333	}
334
335	return (0);
336}
337
338static __inline void
339ie_ack(struct ie_softc *sc, u_int mask)
340{
341
342	sc->scb->ie_command = sc->scb->ie_status & mask;
343	(*sc->ie_chan_attn) (sc);
344}
345
346/*
347 * What to do upon receipt of an interrupt.
348 */
349void
350ie_intr(void *xsc)
351{
352	struct ie_softc *sc = (struct ie_softc *)xsc;
353	u_short status;
354
355	IE_LOCK(sc);
356
357	/* Clear the interrupt latch on the 3C507. */
358	if (sc->hard_type == IE_3C507
359	 && (inb(PORT(sc) + IE507_CTRL) & EL_CTRL_INTL))
360		outb(PORT(sc) + IE507_ICTRL, 1);
361
362	/* disable interrupts on the EE16. */
363	if (sc->hard_type == IE_EE16)
364		outb(PORT(sc) + IEE16_IRQ, sc->irq_encoded);
365
366	status = sc->scb->ie_status;
367
368loop:
369
370	/* Don't ack interrupts which we didn't receive */
371	ie_ack(sc, IE_ST_WHENCE & status);
372
373	if (status & (IE_ST_RECV | IE_ST_RNR)) {
374#ifdef DEBUG
375		in_ierint++;
376		if (ie_debug & IED_RINT)
377			if_printf(sc->ifp, "rint\n");
378#endif
379		ierint(sc);
380#ifdef DEBUG
381		in_ierint--;
382#endif
383	}
384	if (status & IE_ST_DONE) {
385#ifdef DEBUG
386		in_ietint++;
387		if (ie_debug & IED_TINT)
388			if_printf(sc->ifp, "tint\n");
389#endif
390		ietint(sc);
391#ifdef DEBUG
392		in_ietint--;
393#endif
394	}
395	if (status & IE_ST_RNR) {
396#ifdef DEBUG
397		if (ie_debug & IED_RNR)
398			if_printf(sc->ifp, "rnr\n");
399#endif
400		iernr(sc);
401	}
402#ifdef DEBUG
403	if ((status & IE_ST_ALLDONE) && (ie_debug & IED_CNA))
404		if_printf(sc->ifp, "cna\n");
405#endif
406
407	if ((status = sc->scb->ie_status) & IE_ST_WHENCE)
408		goto loop;
409
410	/* Clear the interrupt latch on the 3C507. */
411	if (sc->hard_type == IE_3C507)
412		outb(PORT(sc) + IE507_ICTRL, 1);
413
414	/* enable interrupts on the EE16. */
415	if (sc->hard_type == IE_EE16)
416		outb(PORT(sc) + IEE16_IRQ, sc->irq_encoded | IEE16_IRQ_ENABLE);
417	IE_UNLOCK(sc);
418}
419
420/*
421 * Process a received-frame interrupt.
422 */
423static int
424ierint(struct ie_softc *sc)
425{
426	int	i, status;
427	static int timesthru = 1024;
428
429	i = sc->rfhead;
430	while (1) {
431		status = sc->rframes[i]->ie_fd_status;
432
433		if ((status & IE_FD_COMPLETE) && (status & IE_FD_OK)) {
434			sc->ifp->if_ipackets++;
435			if (!--timesthru) {
436				sc->ifp->if_ierrors +=
437				    sc->scb->ie_err_crc +
438				    sc->scb->ie_err_align +
439				    sc->scb->ie_err_resource +
440				    sc->scb->ie_err_overrun;
441				sc->scb->ie_err_crc = 0;
442				sc->scb->ie_err_align = 0;
443				sc->scb->ie_err_resource = 0;
444				sc->scb->ie_err_overrun = 0;
445				timesthru = 1024;
446			}
447			ie_readframe(sc, i);
448		} else {
449			if (status & IE_FD_RNR) {
450				if (!(sc->scb->ie_status & IE_RU_READY)) {
451					sc->rframes[0]->ie_fd_next =
452					    MK_16(MEM(sc), sc->rbuffs[0]);
453					sc->scb->ie_recv_list =
454					    MK_16(MEM(sc), sc->rframes[0]);
455					command_and_wait(sc, IE_RU_START, 0, 0);
456				}
457			}
458			break;
459		}
460		i = (i + 1) % sc->nframes;
461	}
462	return (0);
463}
464
465/*
466 * Process a command-complete interrupt.  These are only generated by
467 * the transmission of frames.	This routine is deceptively simple, since
468 * most of the real work is done by iestart().
469 */
470static int
471ietint(struct ie_softc *sc)
472{
473	struct ifnet *ifp = sc->ifp;
474	int	status;
475	int	i;
476
477	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
478
479	for (i = 0; i < sc->xmit_count; i++) {
480		status = sc->xmit_cmds[i]->ie_xmit_status;
481
482		if (status & IE_XS_LATECOLL) {
483			if_printf(ifp, "late collision\n");
484			ifp->if_collisions++;
485			ifp->if_oerrors++;
486		} else if (status & IE_XS_NOCARRIER) {
487			if_printf(ifp, "no carrier\n");
488			ifp->if_oerrors++;
489		} else if (status & IE_XS_LOSTCTS) {
490			if_printf(ifp, "lost CTS\n");
491			ifp->if_oerrors++;
492		} else if (status & IE_XS_UNDERRUN) {
493			if_printf(ifp, "DMA underrun\n");
494			ifp->if_oerrors++;
495		} else if (status & IE_XS_EXCMAX) {
496			if_printf(ifp, "too many collisions\n");
497			ifp->if_collisions += 16;
498			ifp->if_oerrors++;
499		} else {
500			ifp->if_opackets++;
501			ifp->if_collisions += status & IE_XS_MAXCOLL;
502		}
503	}
504	sc->xmit_count = 0;
505
506	/*
507	 * If multicast addresses were added or deleted while we were
508	 * transmitting, ie_mc_reset() set the want_mcsetup flag indicating
509	 * that we should do it.
510	 */
511	if (sc->want_mcsetup) {
512		mc_setup(sc);
513		sc->want_mcsetup = 0;
514	}
515	/* Wish I knew why this seems to be necessary... */
516	sc->xmit_cmds[0]->ie_xmit_status |= IE_STAT_COMPL;
517
518	iestart_locked(ifp);
519	return (0);		/* shouldn't be necessary */
520}
521
522/*
523 * Process a receiver-not-ready interrupt.  I believe that we get these
524 * when there aren't enough buffers to go around.  For now (FIXME), we
525 * just restart the receiver, and hope everything's ok.
526 */
527static int
528iernr(struct ie_softc *sc)
529{
530#ifdef doesnt_work
531	setup_rfa(sc, (v_caddr_t) sc->rframes[0]);
532
533	sc->scb->ie_recv_list = MK_16(MEM(sc), sc->rframes[0]);
534	command_and_wait(sc, IE_RU_START, 0, 0);
535#else
536	/* This doesn't work either, but it doesn't hang either. */
537	command_and_wait(sc, IE_RU_DISABLE, 0, 0);	/* just in case */
538	setup_rfa(sc, (v_caddr_t) sc->rframes[0]);	/* ignore cast-qual */
539
540	sc->scb->ie_recv_list = MK_16(MEM(sc), sc->rframes[0]);
541	command_and_wait(sc, IE_RU_START, 0, 0);	/* was ENABLE */
542
543#endif
544	ie_ack(sc, IE_ST_WHENCE);
545
546	sc->ifp->if_ierrors++;
547	return (0);
548}
549
550/*
551 * Compare two Ether/802 addresses for equality, inlined and
552 * unrolled for speed.	I'd love to have an inline assembler
553 * version of this...
554 */
555static __inline int
556ether_equal(u_char * one, u_char * two)
557{
558	if (one[0] != two[0])
559		return (0);
560	if (one[1] != two[1])
561		return (0);
562	if (one[2] != two[2])
563		return (0);
564	if (one[3] != two[3])
565		return (0);
566	if (one[4] != two[4])
567		return (0);
568	if (one[5] != two[5])
569		return (0);
570	return 1;
571}
572
573/*
574 * Determine quickly whether we should bother reading in this packet.
575 * This depends on whether BPF and/or bridging is enabled, whether we
576 * are receiving multicast address, and whether promiscuous mode is enabled.
577 * We assume that if IFF_PROMISC is set, then *somebody* wants to see
578 * all incoming packets.
579 */
580static __inline int
581check_eh(struct ie_softc *sc, struct ether_header *eh)
582{
583	/* Optimize the common case: normal operation. We've received
584	   either a unicast with our dest or a multicast packet. */
585	if (sc->promisc == 0) {
586		int i;
587
588		/* If not multicast, it's definitely for us */
589		if ((eh->ether_dhost[0] & 1) == 0)
590			return (1);
591
592		/* Accept broadcasts (loose but fast check) */
593		if (eh->ether_dhost[0] == 0xff)
594			return (1);
595
596		/* Compare against our multicast addresses */
597		for (i = 0; i < sc->mcast_count; i++) {
598			if (ether_equal(eh->ether_dhost,
599			    (u_char *)&sc->mcast_addrs[i]))
600				return (1);
601		}
602		return (0);
603	}
604
605	/* Always accept packets when in promiscuous mode */
606	if ((sc->promisc & IFF_PROMISC) != 0)
607		return (1);
608
609	/* Always accept packets directed at us */
610	if (ether_equal(eh->ether_dhost, IF_LLADDR(sc->ifp)))
611		return (1);
612
613	/* Must have IFF_ALLMULTI but not IFF_PROMISC set. The chip is
614	   actually in promiscuous mode, so discard unicast packets. */
615	return((eh->ether_dhost[0] & 1) != 0);
616}
617
618/*
619 * We want to isolate the bits that have meaning...  This assumes that
620 * IE_RBUF_SIZE is an even power of two.  If somehow the act_len exceeds
621 * the size of the buffer, then we are screwed anyway.
622 */
623static __inline int
624ie_buflen(struct ie_softc *sc, int head)
625{
626	return (sc->rbuffs[head]->ie_rbd_actual
627		& (IE_RBUF_SIZE | (IE_RBUF_SIZE - 1)));
628}
629
630static __inline int
631ie_packet_len(struct ie_softc *sc)
632{
633	int	i;
634	int	head = sc->rbhead;
635	int	acc = 0;
636
637	do {
638		if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
639#ifdef DEBUG
640			print_rbd(sc->rbuffs[sc->rbhead]);
641#endif
642			log(LOG_ERR,
643			    "%s: receive descriptors out of sync at %d\n",
644			    sc->ifp->if_xname, sc->rbhead);
645			iereset(sc);
646			return (-1);
647		}
648		i = sc->rbuffs[head]->ie_rbd_actual & IE_RBD_LAST;
649
650		acc += ie_buflen(sc, head);
651		head = (head + 1) % sc->nrxbufs;
652	} while (!i);
653
654	return (acc);
655}
656
657/*
658 * Read data off the interface, and turn it into an mbuf chain.
659 *
660 * This code is DRAMATICALLY different from the previous version; this
661 * version tries to allocate the entire mbuf chain up front, given the
662 * length of the data available.  This enables us to allocate mbuf
663 * clusters in many situations where before we would have had a long
664 * chain of partially-full mbufs.  This should help to speed up the
665 * operation considerably.  (Provided that it works, of course.)
666 */
667static __inline int
668ieget(struct ie_softc *sc, struct mbuf **mp)
669{
670	struct	ether_header eh;
671	struct	mbuf *m, *top, **mymp;
672	int	offset;
673	int	totlen, resid;
674	int	thismboff;
675	int	head;
676
677	totlen = ie_packet_len(sc);
678	if (totlen <= 0)
679		return (-1);
680
681	/*
682	 * Snarf the Ethernet header.
683	 */
684	bcopy(sc->cbuffs[sc->rbhead], &eh, sizeof(struct ether_header));
685	/* ignore cast-qual warning here */
686
687	/*
688	 * As quickly as possible, check if this packet is for us. If not,
689	 * don't waste a single cycle copying the rest of the packet in.
690	 * This is only a consideration when FILTER is defined; i.e., when
691	 * we are either running BPF or doing multicasting.
692	 */
693	if (!check_eh(sc, &eh)) {
694		ie_drop_packet_buffer(sc);
695		sc->ifp->if_ierrors--;	/* just this case, it's not an
696						 * error
697						 */
698		return (-1);
699	}
700
701	MGETHDR(m, M_NOWAIT, MT_DATA);
702	if (!m) {
703		ie_drop_packet_buffer(sc);
704		/* XXXX if_ierrors++; */
705		return (-1);
706	}
707
708	*mp = m;
709	m->m_pkthdr.rcvif = sc->ifp;
710	m->m_len = MHLEN;
711	resid = m->m_pkthdr.len = totlen;
712	top = 0;
713
714	mymp = &top;
715
716	/*
717	 * This loop goes through and allocates mbufs for all the data we
718	 * will be copying in.	It does not actually do the copying yet.
719	 */
720	do {			/* while(resid > 0) */
721		/*
722		 * Try to allocate an mbuf to hold the data that we have.
723		 * If we already allocated one, just get another one and
724		 * stick it on the end (eventually).  If we don't already
725		 * have one, try to allocate an mbuf cluster big enough to
726		 * hold the whole packet, if we think it's reasonable, or a
727		 * single mbuf which may or may not be big enough. Got that?
728		 */
729		if (top) {
730			MGET(m, M_NOWAIT, MT_DATA);
731			if (!m) {
732				m_freem(top);
733				ie_drop_packet_buffer(sc);
734				return (-1);
735			}
736			m->m_len = MLEN;
737		}
738		if (resid >= MINCLSIZE) {
739			MCLGET(m, M_NOWAIT);
740			if (m->m_flags & M_EXT)
741				m->m_len = min(resid, MCLBYTES);
742		} else {
743			if (resid < m->m_len) {
744				if (!top && resid + max_linkhdr <= m->m_len)
745					m->m_data += max_linkhdr;
746				m->m_len = resid;
747			}
748		}
749		resid -= m->m_len;
750		*mymp = m;
751		mymp = &m->m_next;
752	} while (resid > 0);
753
754	resid = totlen;					/* remaining data */
755	offset = 0;					/* packet offset */
756	thismboff = 0;					/* offset in m */
757
758	m = top;					/* current mbuf */
759	head = sc->rbhead;				/* current rx buffer */
760
761	/*
762	 * Now we take the mbuf chain (hopefully only one mbuf most of the
763	 * time) and stuff the data into it.  There are no possible failures
764	 * at or after this point.
765	 */
766	while (resid > 0) {	/* while there's stuff left */
767		int	thislen = ie_buflen(sc, head) - offset;
768
769		/*
770		 * If too much data for the current mbuf, then fill the
771		 * current one up, go to the next one, and try again.
772		 */
773		if (thislen > m->m_len - thismboff) {
774			int	newlen = m->m_len - thismboff;
775
776			bcopy((v_caddr_t) (sc->cbuffs[head] + offset),
777			      mtod(m, caddr_t) +thismboff, (unsigned) newlen);
778			/* ignore cast-qual warning */
779			m = m->m_next;
780			thismboff = 0;		/* new mbuf, so no offset */
781			offset += newlen;	/* we are now this far into
782						 * the packet */
783			resid -= newlen;	/* so there is this much left
784						 * to get */
785			continue;
786		}
787		/*
788		 * If there is more than enough space in the mbuf to hold
789		 * the contents of this buffer, copy everything in, advance
790		 * pointers, and so on.
791		 */
792		if (thislen < m->m_len - thismboff) {
793			bcopy((v_caddr_t) (sc->cbuffs[head] + offset),
794			    mtod(m, caddr_t) +thismboff, (unsigned) thislen);
795			thismboff += thislen;	/* we are this far into the
796						 * mbuf */
797			resid -= thislen;	/* and this much is left */
798			goto nextbuf;
799		}
800		/*
801		 * Otherwise, there is exactly enough space to put this
802		 * buffer's contents into the current mbuf.  Do the
803		 * combination of the above actions.
804		 */
805		bcopy((v_caddr_t) (sc->cbuffs[head] + offset),
806		      mtod(m, caddr_t) + thismboff, (unsigned) thislen);
807		m = m->m_next;
808		thismboff = 0;		/* new mbuf, start at the beginning */
809		resid -= thislen;	/* and we are this far through */
810
811		/*
812		 * Advance all the pointers.  We can get here from either of
813		 * the last two cases, but never the first.
814		 */
815nextbuf:
816		offset = 0;
817		sc->rbuffs[head]->ie_rbd_actual = 0;
818		sc->rbuffs[head]->ie_rbd_length |= IE_RBD_LAST;
819		sc->rbhead = head = (head + 1) % sc->nrxbufs;
820		sc->rbuffs[sc->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
821		sc->rbtail = (sc->rbtail + 1) % sc->nrxbufs;
822	}
823
824	/*
825	 * Unless something changed strangely while we were doing the copy,
826	 * we have now copied everything in from the shared memory. This
827	 * means that we are done.
828	 */
829	return (0);
830}
831
832/*
833 * Read frame NUM from unit UNIT (pre-cached as IE).
834 *
835 * This routine reads the RFD at NUM, and copies in the buffers from
836 * the list of RBD, then rotates the RBD and RFD lists so that the receiver
837 * doesn't start complaining.  Trailers are DROPPED---there's no point
838 * in wasting time on confusing code to deal with them.	 Hopefully,
839 * this machine will never ARP for trailers anyway.
840 */
841static void
842ie_readframe(struct ie_softc *sc, int	num/* frame number to read */)
843{
844	struct ifnet *ifp = sc->ifp;
845	struct ie_recv_frame_desc rfd;
846	struct mbuf *m = 0;
847#ifdef DEBUG
848	struct ether_header *eh;
849#endif
850
851	bcopy((v_caddr_t) (sc->rframes[num]), &rfd,
852	      sizeof(struct ie_recv_frame_desc));
853
854	/*
855	 * Immediately advance the RFD list, since we we have copied ours
856	 * now.
857	 */
858	sc->rframes[num]->ie_fd_status = 0;
859	sc->rframes[num]->ie_fd_last |= IE_FD_LAST;
860	sc->rframes[sc->rftail]->ie_fd_last &= ~IE_FD_LAST;
861	sc->rftail = (sc->rftail + 1) % sc->nframes;
862	sc->rfhead = (sc->rfhead + 1) % sc->nframes;
863
864	if (rfd.ie_fd_status & IE_FD_OK) {
865		if (ieget(sc, &m)) {
866			sc->ifp->if_ierrors++;	/* this counts as an
867							 * error */
868			return;
869		}
870	}
871#ifdef DEBUG
872	eh = mtod(m, struct ether_header *);
873	if (ie_debug & IED_READFRAME) {
874		if_printf(ifp, "frame from ether %6D type %x\n",
875		       eh->ether_shost, ":", (unsigned) eh->ether_type);
876	}
877	if (ntohs(eh->ether_type) > ETHERTYPE_TRAIL
878	    && ntohs(eh->ether_type) < (ETHERTYPE_TRAIL + ETHERTYPE_NTRAILER))
879		printf("received trailer!\n");
880#endif
881
882	if (!m)
883		return;
884
885	/*
886	 * Finally pass this packet up to higher layers.
887	 */
888	IE_UNLOCK(sc);
889	(*ifp->if_input)(ifp, m);
890	IE_LOCK(sc);
891}
892
893static void
894ie_drop_packet_buffer(struct ie_softc *sc)
895{
896	int	i;
897
898	do {
899		/*
900		 * This means we are somehow out of sync.  So, we reset the
901		 * adapter.
902		 */
903		if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
904#ifdef DEBUG
905			print_rbd(sc->rbuffs[sc->rbhead]);
906#endif
907			log(LOG_ERR, "%s: receive descriptors out of sync at %d\n",
908			    sc->ifp->if_xname, sc->rbhead);
909			iereset(sc);
910			return;
911		}
912		i = sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_LAST;
913
914		sc->rbuffs[sc->rbhead]->ie_rbd_length |= IE_RBD_LAST;
915		sc->rbuffs[sc->rbhead]->ie_rbd_actual = 0;
916		sc->rbhead = (sc->rbhead + 1) % sc->nrxbufs;
917		sc->rbuffs[sc->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
918		sc->rbtail = (sc->rbtail + 1) % sc->nrxbufs;
919	} while (!i);
920}
921
922
923/*
924 * Start transmission on an interface.
925 */
926static void
927iestart(struct ifnet *ifp)
928{
929	struct	 ie_softc *sc = ifp->if_softc;
930
931	IE_LOCK(sc);
932	iestart_locked(ifp);
933	IE_UNLOCK(sc);
934}
935
936static void
937iestart_locked(struct ifnet *ifp)
938{
939	struct	 ie_softc *sc = ifp->if_softc;
940	struct	 mbuf *m0, *m;
941	volatile unsigned char *buffer;
942	u_short	 len;
943
944	/*
945	 * This is not really volatile, in this routine, but it makes gcc
946	 * happy.
947	 */
948	volatile u_short *bptr = &sc->scb->ie_command_list;
949
950	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
951		return;
952	if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
953		return;
954
955	do {
956		IF_DEQUEUE(&sc->ifp->if_snd, m);
957		if (!m)
958			break;
959
960		buffer = sc->xmit_cbuffs[sc->xmit_count];
961		len = 0;
962
963		for (m0 = m; m && len < IE_BUF_LEN; m = m->m_next) {
964			bcopy(mtod(m, caddr_t), buffer, m->m_len);
965			buffer += m->m_len;
966			len += m->m_len;
967		}
968
969		m_freem(m0);
970		len = max(len, ETHER_MIN_LEN);
971
972		/*
973		 * See if bpf is listening on this interface, let it see the
974		 * packet before we commit it to the wire.
975		 */
976		BPF_TAP(sc->ifp,
977			(void *)sc->xmit_cbuffs[sc->xmit_count], len);
978
979		sc->xmit_buffs[sc->xmit_count]->ie_xmit_flags =
980		    IE_XMIT_LAST|len;
981		sc->xmit_buffs[sc->xmit_count]->ie_xmit_next = 0xffff;
982		sc->xmit_buffs[sc->xmit_count]->ie_xmit_buf =
983		    MK_24(sc->iomem, sc->xmit_cbuffs[sc->xmit_count]);
984
985		sc->xmit_cmds[sc->xmit_count]->com.ie_cmd_cmd = IE_CMD_XMIT;
986		sc->xmit_cmds[sc->xmit_count]->ie_xmit_status = 0;
987		sc->xmit_cmds[sc->xmit_count]->ie_xmit_desc =
988		    MK_16(sc->iomem, sc->xmit_buffs[sc->xmit_count]);
989
990		*bptr = MK_16(sc->iomem, sc->xmit_cmds[sc->xmit_count]);
991		bptr = &sc->xmit_cmds[sc->xmit_count]->com.ie_cmd_link;
992		sc->xmit_count++;
993	} while (sc->xmit_count < sc->ntxbufs);
994
995	/*
996	 * If we queued up anything for transmission, send it.
997	 */
998	if (sc->xmit_count) {
999		sc->xmit_cmds[sc->xmit_count - 1]->com.ie_cmd_cmd |=
1000		    IE_CMD_LAST | IE_CMD_INTR;
1001
1002		/*
1003		 * By passing the command pointer as a null, we tell
1004		 * command_and_wait() to pretend that this isn't an action
1005		 * command.  I wish I understood what was happening here.
1006		 */
1007		command_and_wait(sc, IE_CU_START, 0, 0);
1008		ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1009	}
1010	return;
1011}
1012
1013/*
1014 * Check to see if there's an 82586 out there.
1015 */
1016int
1017check_ie_present(struct ie_softc *sc)
1018{
1019	volatile struct ie_sys_conf_ptr *scp;
1020	volatile struct ie_int_sys_conf_ptr *iscp;
1021	volatile struct ie_sys_ctl_block *scb;
1022	u_long	realbase;
1023
1024	realbase = (uintptr_t) sc->iomembot + sc->iosize  - (1 << 24);
1025
1026	scp = (volatile struct ie_sys_conf_ptr *) (uintptr_t)
1027	      (realbase + IE_SCP_ADDR);
1028	bzero((volatile char *) scp, sizeof *scp);
1029
1030	/*
1031	 * First we put the ISCP at the bottom of memory; this tests to make
1032	 * sure that our idea of the size of memory is the same as the
1033	 * controller's. This is NOT where the ISCP will be in normal
1034	 * operation.
1035	 */
1036	iscp = (volatile struct ie_int_sys_conf_ptr *) sc->iomembot;
1037	bzero((volatile char *)iscp, sizeof *iscp);
1038
1039	scb = (volatile struct ie_sys_ctl_block *) sc->iomembot;
1040	bzero((volatile char *)scb, sizeof *scb);
1041
1042	scp->ie_bus_use = sc->bus_use;	/* 8-bit or 16-bit */
1043	scp->ie_iscp_ptr = (caddr_t) (uintptr_t)
1044	    ((volatile char *) iscp - (volatile char *) (uintptr_t) realbase);
1045
1046	iscp->ie_busy = 1;
1047	iscp->ie_scb_offset = MK_16(realbase, scb) + 256;
1048
1049	(*sc->ie_reset_586) (sc);
1050	(*sc->ie_chan_attn) (sc);
1051
1052	DELAY(100);		/* wait a while... */
1053
1054	if (iscp->ie_busy) {
1055		return (0);
1056	}
1057	/*
1058	 * Now relocate the ISCP to its real home, and reset the controller
1059	 * again.
1060	 */
1061	iscp = (void *) Align((caddr_t) (uintptr_t)
1062			      (realbase + IE_SCP_ADDR -
1063			       sizeof(struct ie_int_sys_conf_ptr)));
1064	bzero((volatile char *) iscp, sizeof *iscp);	/* ignore cast-qual */
1065
1066	scp->ie_iscp_ptr = (caddr_t) (uintptr_t)
1067	    ((volatile char *) iscp - (volatile char *) (uintptr_t) realbase);
1068
1069	iscp->ie_busy = 1;
1070	iscp->ie_scb_offset = MK_16(realbase, scb);
1071
1072	(*sc->ie_reset_586) (sc);
1073	(*sc->ie_chan_attn) (sc);
1074
1075	DELAY(100);
1076
1077	if (iscp->ie_busy) {
1078		return (0);
1079	}
1080	sc->iomem = (caddr_t) (uintptr_t) realbase;
1081
1082	sc->iscp = iscp;
1083	sc->scb = scb;
1084
1085	/*
1086	 * Acknowledge any interrupts we may have caused...
1087	 */
1088	ie_ack(sc, IE_ST_WHENCE);
1089
1090	return (1);
1091}
1092
1093/*
1094 * Divine the memory size of ie board UNIT.
1095 * Better hope there's nothing important hiding just below the ie card...
1096 */
1097static void
1098find_ie_mem_size(struct ie_softc *sc)
1099{
1100	unsigned size;
1101
1102	sc->iosize = 0;
1103
1104	for (size = 65536; size >= 8192; size -= 8192) {
1105		if (check_ie_present(sc)) {
1106			return;
1107		}
1108	}
1109
1110	return;
1111}
1112
1113void
1114el_reset_586(struct ie_softc *sc)
1115{
1116	outb(PORT(sc) + IE507_CTRL, EL_CTRL_RESET);
1117	DELAY(100);
1118	outb(PORT(sc) + IE507_CTRL, EL_CTRL_NORMAL);
1119	DELAY(100);
1120}
1121
1122void
1123sl_reset_586(struct ie_softc *sc)
1124{
1125	outb(PORT(sc) + IEATT_RESET, 0);
1126}
1127
1128void
1129ee16_reset_586(struct ie_softc *sc)
1130{
1131	outb(PORT(sc) + IEE16_ECTRL, IEE16_RESET_586);
1132	DELAY(100);
1133	outb(PORT(sc) + IEE16_ECTRL, 0);
1134	DELAY(100);
1135}
1136
1137void
1138el_chan_attn(struct ie_softc *sc)
1139{
1140	outb(PORT(sc) + IE507_ATTN, 1);
1141}
1142
1143void
1144sl_chan_attn(struct ie_softc *sc)
1145{
1146	outb(PORT(sc) + IEATT_ATTN, 0);
1147}
1148
1149void
1150ee16_chan_attn(struct ie_softc *sc)
1151{
1152	outb(PORT(sc) + IEE16_ATTN, 0);
1153}
1154
1155u_short
1156ee16_read_eeprom(struct ie_softc *sc, int location)
1157{
1158	int	ectrl, edata;
1159
1160	ectrl = inb(sc->port + IEE16_ECTRL);
1161	ectrl &= IEE16_ECTRL_MASK;
1162	ectrl |= IEE16_ECTRL_EECS;
1163	outb(sc->port + IEE16_ECTRL, ectrl);
1164
1165	ee16_eeprom_outbits(sc, IEE16_EEPROM_READ, IEE16_EEPROM_OPSIZE1);
1166	ee16_eeprom_outbits(sc, location, IEE16_EEPROM_ADDR_SIZE);
1167	edata = ee16_eeprom_inbits(sc);
1168	ectrl = inb(sc->port + IEE16_ECTRL);
1169	ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EEDI | IEE16_ECTRL_EECS);
1170	outb(sc->port + IEE16_ECTRL, ectrl);
1171	ee16_eeprom_clock(sc, 1);
1172	ee16_eeprom_clock(sc, 0);
1173	return edata;
1174}
1175
1176static void
1177ee16_eeprom_outbits(struct ie_softc *sc, int edata, int count)
1178{
1179	int	ectrl, i;
1180
1181	ectrl = inb(sc->port + IEE16_ECTRL);
1182	ectrl &= ~IEE16_RESET_ASIC;
1183	for (i = count - 1; i >= 0; i--) {
1184		ectrl &= ~IEE16_ECTRL_EEDI;
1185		if (edata & (1 << i)) {
1186			ectrl |= IEE16_ECTRL_EEDI;
1187		}
1188		outb(sc->port + IEE16_ECTRL, ectrl);
1189		DELAY(1);	/* eeprom data must be setup for 0.4 uSec */
1190		ee16_eeprom_clock(sc, 1);
1191		ee16_eeprom_clock(sc, 0);
1192	}
1193	ectrl &= ~IEE16_ECTRL_EEDI;
1194	outb(sc->port + IEE16_ECTRL, ectrl);
1195	DELAY(1);		/* eeprom data must be held for 0.4 uSec */
1196}
1197
1198static int
1199ee16_eeprom_inbits(struct ie_softc *sc)
1200{
1201	int	ectrl, edata, i;
1202
1203	ectrl = inb(sc->port + IEE16_ECTRL);
1204	ectrl &= ~IEE16_RESET_ASIC;
1205	for (edata = 0, i = 0; i < 16; i++) {
1206		edata = edata << 1;
1207		ee16_eeprom_clock(sc, 1);
1208		ectrl = inb(sc->port + IEE16_ECTRL);
1209		if (ectrl & IEE16_ECTRL_EEDO) {
1210			edata |= 1;
1211		}
1212		ee16_eeprom_clock(sc, 0);
1213	}
1214	return (edata);
1215}
1216
1217static void
1218ee16_eeprom_clock(struct ie_softc *sc, int state)
1219{
1220	int	ectrl;
1221
1222	ectrl = inb(sc->port + IEE16_ECTRL);
1223	ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EESK);
1224	if (state) {
1225		ectrl |= IEE16_ECTRL_EESK;
1226	}
1227	outb(sc->port + IEE16_ECTRL, ectrl);
1228	DELAY(9);		/* EESK must be stable for 8.38 uSec */
1229}
1230
1231static __inline void
1232ee16_interrupt_enable(struct ie_softc *sc)
1233{
1234	DELAY(100);
1235	outb(sc->port + IEE16_IRQ, sc->irq_encoded | IEE16_IRQ_ENABLE);
1236	DELAY(100);
1237}
1238
1239void
1240sl_read_ether(struct ie_softc *sc, unsigned char *addr)
1241{
1242	int	i;
1243
1244	for (i = 0; i < 6; i++)
1245		addr[i] = inb(PORT(sc) + i);
1246}
1247
1248static void
1249iereset(struct ie_softc *sc)
1250{
1251	struct ifnet *ifp = sc->ifp;
1252
1253	if_printf(ifp, "reset\n");
1254	ie_stop(sc);
1255
1256	/*
1257	 * Stop i82586 dead in its tracks.
1258	 */
1259	if (command_and_wait(sc, IE_RU_ABORT | IE_CU_ABORT, 0, 0))
1260		if_printf(ifp, "abort commands timed out\n");
1261
1262	if (command_and_wait(sc, IE_RU_DISABLE | IE_CU_STOP, 0, 0))
1263		if_printf(ifp, "disable commands timed out\n");
1264
1265#ifdef notdef
1266	if (!check_ie_present(sc))
1267		panic("ie disappeared!");
1268#endif
1269
1270	if (ifp->if_flags & IFF_UP)
1271		ieinit_locked(sc);
1272
1273	return;
1274}
1275
1276/*
1277 * Send a command to the controller and wait for it to either
1278 * complete or be accepted, depending on the command.  If the
1279 * command pointer is null, then pretend that the command is
1280 * not an action command.  If the command pointer is not null,
1281 * and the command is an action command, wait for
1282 * ((volatile struct ie_cmd_common *)pcmd)->ie_cmd_status & MASK
1283 * to become true.
1284 */
1285static int
1286command_and_wait(struct ie_softc *sc, int cmd, volatile void *pcmd, int mask)
1287{
1288	volatile struct ie_cmd_common *cc = pcmd;
1289	int i;
1290
1291	sc->scb->ie_command = (u_short) cmd;
1292
1293	if (IE_ACTION_COMMAND(cmd) && pcmd) {
1294		(*sc->ie_chan_attn) (sc);
1295
1296		/*
1297		 * Now spin-lock waiting for status.  This is not a very
1298		 * nice thing to do, but I haven't figured out how, or
1299		 * indeed if, we can put the process waiting for action to
1300		 * sleep.  (We may be getting called through some other
1301		 * timeout running in the kernel.)
1302		 *
1303		 * According to the packet driver, the minimum timeout
1304		 * should be .369 seconds, which we round up to .37.
1305		 */
1306		for (i = 0; i < 370; i++) {
1307			if (cc->ie_cmd_status & mask)
1308				return (0);
1309			DELAY(1000);
1310		}
1311
1312		return (1);
1313	} else {
1314
1315		/*
1316		 * Otherwise, just wait for the command to be accepted.
1317		 */
1318		(*sc->ie_chan_attn) (sc);
1319
1320		while (sc->scb->ie_command);	/* spin lock */
1321
1322		return (0);
1323	}
1324}
1325
1326/*
1327 * Run the time-domain reflectometer...
1328 */
1329static void
1330run_tdr(struct ie_softc *sc, volatile struct ie_tdr_cmd *cmd)
1331{
1332	int	result;
1333
1334	cmd->com.ie_cmd_status = 0;
1335	cmd->com.ie_cmd_cmd = IE_CMD_TDR | IE_CMD_LAST;
1336	cmd->com.ie_cmd_link = 0xffff;
1337	cmd->ie_tdr_time = 0;
1338
1339	sc->scb->ie_command_list = MK_16(MEM(sc), cmd);
1340	cmd->ie_tdr_time = 0;
1341
1342	if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL))
1343		result = 0x2000;
1344	else
1345		result = cmd->ie_tdr_time;
1346
1347	ie_ack(sc, IE_ST_WHENCE);
1348
1349	if (result & IE_TDR_SUCCESS)
1350		return;
1351
1352	if (result & IE_TDR_XCVR) {
1353		if_printf(sc->ifp, "transceiver problem\n");
1354	} else if (result & IE_TDR_OPEN) {
1355		if_printf(sc->ifp, "TDR detected an open %d clocks away\n",
1356		       result & IE_TDR_TIME);
1357	} else if (result & IE_TDR_SHORT) {
1358		if_printf(sc->ifp, "TDR detected a short %d clocks away\n",
1359		       result & IE_TDR_TIME);
1360	} else {
1361		if_printf(sc->ifp, "TDR returned unknown status %x\n", result);
1362	}
1363}
1364
1365static void
1366start_receiver(struct ie_softc *sc)
1367{
1368
1369	sc->scb->ie_recv_list = MK_16(MEM(sc), sc->rframes[0]);
1370	command_and_wait(sc, IE_RU_START, 0, 0);
1371
1372	ie_ack(sc, IE_ST_WHENCE);
1373}
1374
1375/*
1376 * Here is a helper routine for iernr() and ieinit().  This sets up
1377 * the RFA.
1378 */
1379static v_caddr_t
1380setup_rfa(struct ie_softc *sc, v_caddr_t ptr)
1381{
1382	volatile struct ie_recv_frame_desc *rfd = (volatile void *)ptr;
1383	volatile struct ie_recv_buf_desc *rbd;
1384	int	i;
1385
1386	/* First lay them out */
1387	for (i = 0; i < sc->nframes; i++) {
1388		sc->rframes[i] = rfd;
1389		bzero((volatile char *) rfd, sizeof *rfd);	/* ignore cast-qual */
1390		rfd++;
1391	}
1392
1393	ptr = Alignvol(rfd);		/* ignore cast-qual */
1394
1395	/* Now link them together */
1396	for (i = 0; i < sc->nframes; i++) {
1397		sc->rframes[i]->ie_fd_next =
1398		    MK_16(MEM(sc), sc->rframes[(i + 1) % sc->nframes]);
1399	}
1400
1401	/* Finally, set the EOL bit on the last one. */
1402	sc->rframes[sc->nframes - 1]->ie_fd_last |= IE_FD_LAST;
1403
1404	/*
1405	 * Now lay out some buffers for the incoming frames.  Note that we
1406	 * set aside a bit of slop in each buffer, to make sure that we have
1407	 * enough space to hold a single frame in every buffer.
1408	 */
1409	rbd = (volatile void *) ptr;
1410
1411	for (i = 0; i < sc->nrxbufs; i++) {
1412		sc->rbuffs[i] = rbd;
1413		bzero((volatile char *)rbd, sizeof *rbd);
1414		ptr = Alignvol(ptr + sizeof *rbd);
1415		rbd->ie_rbd_length = IE_RBUF_SIZE;
1416		rbd->ie_rbd_buffer = MK_24(MEM(sc), ptr);
1417		sc->cbuffs[i] = (volatile void *) ptr;
1418		ptr += IE_RBUF_SIZE;
1419		rbd = (volatile void *) ptr;
1420	}
1421
1422	/* Now link them together */
1423	for (i = 0; i < sc->nrxbufs; i++) {
1424		sc->rbuffs[i]->ie_rbd_next =
1425		    MK_16(MEM(sc), sc->rbuffs[(i + 1) % sc->nrxbufs]);
1426	}
1427
1428	/* Tag EOF on the last one */
1429	sc->rbuffs[sc->nrxbufs - 1]->ie_rbd_length |= IE_RBD_LAST;
1430
1431	/*
1432	 * We use the head and tail pointers on receive to keep track of the
1433	 * order in which RFDs and RBDs are used.
1434	 */
1435	sc->rfhead = 0;
1436	sc->rftail = sc->nframes - 1;
1437	sc->rbhead = 0;
1438	sc->rbtail = sc->nrxbufs - 1;
1439
1440	sc->scb->ie_recv_list = MK_16(MEM(sc), sc->rframes[0]);
1441	sc->rframes[0]->ie_fd_buf_desc = MK_16(MEM(sc), sc->rbuffs[0]);
1442
1443	ptr = Alignvol(ptr);
1444	return (ptr);
1445}
1446
1447/*
1448 * Run the multicast setup command.
1449 */
1450static int
1451mc_setup(struct ie_softc *sc)
1452{
1453	volatile struct ie_mcast_cmd *cmd = (volatile void *)sc->xmit_cbuffs[0];
1454
1455	cmd->com.ie_cmd_status = 0;
1456	cmd->com.ie_cmd_cmd = IE_CMD_MCAST | IE_CMD_LAST;
1457	cmd->com.ie_cmd_link = 0xffff;
1458
1459	/* ignore cast-qual */
1460	bcopy((v_caddr_t) sc->mcast_addrs, (v_caddr_t) cmd->ie_mcast_addrs,
1461	      sc->mcast_count * sizeof *sc->mcast_addrs);
1462
1463	cmd->ie_mcast_bytes = sc->mcast_count * 6;	/* grrr... */
1464
1465	sc->scb->ie_command_list = MK_16(MEM(sc), cmd);
1466	if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL)
1467	    || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
1468		if_printf(sc->ifp, "multicast address setup command failed\n");
1469		return (0);
1470	}
1471	return (1);
1472}
1473
1474/*
1475 * This routine takes the environment generated by check_ie_present()
1476 * and adds to it all the other structures we need to operate the adapter.
1477 * This includes executing the CONFIGURE, IA-SETUP, and MC-SETUP commands,
1478 * starting the receiver unit, and clearing interrupts.
1479 */
1480static void
1481ieinit(xsc)
1482	void *xsc;
1483{
1484	struct ie_softc *sc = xsc;
1485
1486	IE_LOCK(sc);
1487	ieinit_locked(sc);
1488	IE_UNLOCK(sc);
1489}
1490
1491static void
1492ieinit_locked(struct ie_softc *sc)
1493{
1494	struct ifnet *ifp = sc->ifp;
1495	volatile struct ie_sys_ctl_block *scb = sc->scb;
1496	caddr_t ptr;
1497	int	i;
1498
1499	ptr = Alignvol((volatile char *) scb + sizeof *scb);
1500
1501	/*
1502	 * Send the configure command first.
1503	 */
1504	{
1505		volatile struct ie_config_cmd *cmd = (volatile void *) ptr;
1506
1507		ie_setup_config(cmd, sc->promisc,
1508				sc->hard_type == IE_STARLAN10);
1509		cmd->com.ie_cmd_status = 0;
1510		cmd->com.ie_cmd_cmd = IE_CMD_CONFIG | IE_CMD_LAST;
1511		cmd->com.ie_cmd_link = 0xffff;
1512
1513		scb->ie_command_list = MK_16(MEM(sc), cmd);
1514
1515		if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL)
1516		 || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
1517			if_printf(ifp, "configure command failed\n");
1518			return;
1519		}
1520	}
1521	/*
1522	 * Now send the Individual Address Setup command.
1523	 */
1524	{
1525		volatile struct ie_iasetup_cmd *cmd = (volatile void *) ptr;
1526
1527		cmd->com.ie_cmd_status = 0;
1528		cmd->com.ie_cmd_cmd = IE_CMD_IASETUP | IE_CMD_LAST;
1529		cmd->com.ie_cmd_link = 0xffff;
1530
1531		bcopy((volatile char *)IF_LLADDR(ifp),
1532		      (volatile char *)&cmd->ie_address, sizeof cmd->ie_address);
1533		scb->ie_command_list = MK_16(MEM(sc), cmd);
1534		if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL)
1535		    || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
1536			if_printf(ifp, "individual address "
1537			       "setup command failed\n");
1538			return;
1539		}
1540	}
1541
1542	/*
1543	 * Now run the time-domain reflectometer.
1544	 */
1545	run_tdr(sc, (volatile void *) ptr);
1546
1547	/*
1548	 * Acknowledge any interrupts we have generated thus far.
1549	 */
1550	ie_ack(sc, IE_ST_WHENCE);
1551
1552	/*
1553	 * Set up the RFA.
1554	 */
1555	ptr = setup_rfa(sc, ptr);
1556
1557	/*
1558	 * Finally, the transmit command and buffer are the last little bit
1559	 * of work.
1560	 */
1561
1562	/* transmit command buffers */
1563	for (i = 0; i < sc->ntxbufs; i++) {
1564		sc->xmit_cmds[i] = (volatile void *) ptr;
1565		ptr += sizeof *sc->xmit_cmds[i];
1566		ptr = Alignvol(ptr);
1567		sc->xmit_buffs[i] = (volatile void *)ptr;
1568		ptr += sizeof *sc->xmit_buffs[i];
1569		ptr = Alignvol(ptr);
1570	}
1571
1572	/* transmit buffers */
1573	for (i = 0; i < sc->ntxbufs - 1; i++) {
1574		sc->xmit_cbuffs[i] = (volatile void *)ptr;
1575		ptr += IE_BUF_LEN;
1576		ptr = Alignvol(ptr);
1577	}
1578	sc->xmit_cbuffs[sc->ntxbufs - 1] = (volatile void *) ptr;
1579
1580	for (i = 1; i < sc->ntxbufs; i++) {
1581		bzero((v_caddr_t) sc->xmit_cmds[i], sizeof *sc->xmit_cmds[i]);
1582		bzero((v_caddr_t) sc->xmit_buffs[i], sizeof *sc->xmit_buffs[i]);
1583	}
1584
1585	/*
1586	 * This must be coordinated with iestart() and ietint().
1587	 */
1588	sc->xmit_cmds[0]->ie_xmit_status = IE_STAT_COMPL;
1589
1590	/* take the ee16 out of loopback */
1591	if (sc->hard_type == IE_EE16) {
1592		u_int8_t bart_config;
1593
1594		bart_config = inb(PORT(sc) + IEE16_CONFIG);
1595		bart_config &= ~IEE16_BART_LOOPBACK;
1596		/* inb doesn't get bit! */
1597		bart_config |= IEE16_BART_MCS16_TEST;
1598		outb(PORT(sc) + IEE16_CONFIG, bart_config);
1599		ee16_interrupt_enable(sc);
1600		ee16_chan_attn(sc);
1601	}
1602	ifp->if_drv_flags |= IFF_DRV_RUNNING;	/* tell higher levels
1603							 * we're here */
1604	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1605
1606	start_receiver(sc);
1607
1608	return;
1609}
1610
1611static void
1612ie_stop(struct ie_softc *sc)
1613{
1614	struct ifnet *ifp = sc->ifp;
1615
1616	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1617	command_and_wait(sc, IE_RU_DISABLE, 0, 0);
1618}
1619
1620static int
1621ieioctl(struct ifnet *ifp, u_long command, caddr_t data)
1622{
1623	int	error = 0;
1624	struct	 ie_softc *sc = ifp->if_softc;
1625
1626	switch (command) {
1627	case SIOCSIFFLAGS:
1628		/*
1629		 * Note that this device doesn't have an "all multicast"
1630		 * mode, so we must turn on promiscuous mode and do the
1631		 * filtering manually.
1632		 */
1633		IE_LOCK(sc);
1634		if ((ifp->if_flags & IFF_UP) == 0 &&
1635		    (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1636			ie_stop(sc);
1637		} else if ((ifp->if_flags & IFF_UP) &&
1638			   (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1639			sc->promisc =
1640			    ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
1641			ieinit_locked(sc);
1642		} else if (sc->promisc ^
1643			   (ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1644			sc->promisc =
1645			    ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
1646			ieinit_locked(sc);
1647		}
1648		IE_UNLOCK(sc);
1649		break;
1650
1651	case SIOCADDMULTI:
1652	case SIOCDELMULTI:
1653		/*
1654		 * Update multicast listeners
1655		 */
1656		/* reset multicast filtering */
1657		IE_LOCK(sc);
1658		ie_mc_reset(sc);
1659		IE_UNLOCK(sc);
1660		error = 0;
1661		break;
1662
1663	default:
1664		error = ether_ioctl(ifp, command, data);
1665		break;
1666	}
1667
1668	return (error);
1669}
1670
1671static void
1672ie_mc_reset(struct ie_softc *sc)
1673{
1674	struct ifmultiaddr *ifma;
1675
1676	/*
1677	 * Step through the list of addresses.
1678	 */
1679	sc->mcast_count = 0;
1680	if_maddr_rlock(sc->ifp);
1681	TAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
1682		if (ifma->ifma_addr->sa_family != AF_LINK)
1683			continue;
1684
1685		/* XXX - this is broken... */
1686		if (sc->mcast_count >= MAXMCAST) {
1687			sc->ifp->if_flags |= IFF_ALLMULTI;
1688			if (sc->ifp->if_flags & IFF_UP)
1689				ieinit_locked(sc);
1690			goto setflag;
1691		}
1692		bcopy(LLADDR((struct sockaddr_dl *) ifma->ifma_addr),
1693		      &(sc->mcast_addrs[sc->mcast_count]), 6);
1694		sc->mcast_count++;
1695	}
1696	if_maddr_runlock(sc->ifp);
1697
1698setflag:
1699	sc->want_mcsetup = 1;
1700}
1701
1702
1703#ifdef DEBUG
1704static void
1705print_rbd(volatile struct ie_recv_buf_desc * rbd)
1706{
1707	printf("RBD at %p:\n"
1708	       "actual %04x, next %04x, buffer %p\n"
1709	       "length %04x, mbz %04x\n",
1710	       (volatile void *) rbd,
1711	       rbd->ie_rbd_actual, rbd->ie_rbd_next,
1712	       (void *) rbd->ie_rbd_buffer,
1713	       rbd->ie_rbd_length, rbd->mbz);
1714}
1715
1716#endif				/* DEBUG */
1717
1718int
1719ie_alloc_resources (device_t dev)
1720{
1721	struct ie_softc *       sc;
1722	int                     error;
1723
1724	error = 0;
1725	sc = device_get_softc(dev);
1726
1727	sc->io_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &sc->io_rid,
1728					    RF_ACTIVE);
1729	if (!sc->io_res) {
1730		device_printf(dev, "No I/O space?!\n");
1731		error = ENOMEM;
1732		goto bad;
1733	}
1734	sc->io_bt = rman_get_bustag(sc->io_res);
1735	sc->io_bh = rman_get_bushandle(sc->io_res);
1736
1737	sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->mem_rid,
1738					     RF_ACTIVE);
1739	if (!sc->mem_res) {
1740                device_printf(dev, "No Memory!\n");
1741		error = ENOMEM;
1742		goto bad;
1743	}
1744	sc->mem_bt = rman_get_bustag(sc->mem_res);
1745	sc->mem_bh = rman_get_bushandle(sc->mem_res);
1746
1747	sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid,
1748					     RF_ACTIVE);
1749	if (!sc->irq_res) {
1750		device_printf(dev, "No IRQ!\n");
1751		error = ENOMEM;
1752		goto bad;
1753	}
1754
1755	sc->port = rman_get_start(sc->io_res);  /* XXX hack */
1756	sc->iomembot = rman_get_virtual(sc->mem_res);
1757	sc->iosize = rman_get_size(sc->mem_res);
1758
1759	return (0);
1760bad:
1761	return (error);
1762}
1763
1764void
1765ie_release_resources (device_t dev)
1766{
1767	struct ie_softc *       sc;
1768
1769	sc = device_get_softc(dev);
1770
1771	if (sc->irq_ih)
1772		bus_teardown_intr(dev, sc->irq_res, sc->irq_ih);
1773	if (sc->rframes)
1774		free(sc->rframes, M_DEVBUF);
1775	if (sc->io_res)
1776		bus_release_resource(dev, SYS_RES_IOPORT,
1777				     sc->io_rid, sc->io_res);
1778	if (sc->irq_res)
1779		bus_release_resource(dev, SYS_RES_IRQ,
1780				     sc->irq_rid, sc->irq_res);
1781	if (sc->mem_res)
1782		bus_release_resource(dev, SYS_RES_MEMORY,
1783				     sc->mem_rid, sc->mem_res);
1784	if (sc->ifp)
1785		if_free(sc->ifp);
1786
1787	return;
1788}
1789
1790int
1791ie_detach (device_t dev)
1792{
1793	struct ie_softc *	sc;
1794	struct ifnet *		ifp;
1795
1796	sc = device_get_softc(dev);
1797	ifp = sc->ifp;
1798
1799	IE_LOCK(sc);
1800	if (sc->hard_type == IE_EE16)
1801		ee16_shutdown(sc);
1802
1803	ie_stop(sc);
1804	IE_UNLOCK(sc);
1805	ether_ifdetach(ifp);
1806	ie_release_resources(dev);
1807	mtx_destroy(&sc->lock);
1808
1809	return (0);
1810}
1811