Annotation of sys/dev/isa/if_ie.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_ie.c,v 1.33 2006/04/16 00:46:32 pascoe Exp $ */
2: /* $NetBSD: if_ie.c,v 1.51 1996/05/12 23:52:48 mycroft Exp $ */
3:
4: /*-
5: * Copyright (c) 1993, 1994, 1995 Charles Hannum.
6: * Copyright (c) 1992, 1993, University of Vermont and State
7: * Agricultural College.
8: * Copyright (c) 1992, 1993, Garrett A. Wollman.
9: *
10: * Portions:
11: * Copyright (c) 1993, 1994, 1995, Rodney W. Grimes
12: * Copyright (c) 1994, 1995, Rafal K. Boni
13: * Copyright (c) 1990, 1991, William F. Jolitz
14: * Copyright (c) 1990, The Regents of the University of California
15: *
16: * All rights reserved.
17: *
18: * Redistribution and use in source and binary forms, with or without
19: * modification, are permitted provided that the following conditions
20: * are met:
21: * 1. Redistributions of source code must retain the above copyright
22: * notice, this list of conditions and the following disclaimer.
23: * 2. Redistributions in binary form must reproduce the above copyright
24: * notice, this list of conditions and the following disclaimer in the
25: * documentation and/or other materials provided with the distribution.
26: * 3. All advertising materials mentioning features or use of this software
27: * must display the following acknowledgement:
28: * This product includes software developed by Charles Hannum, by the
29: * University of Vermont and State Agricultural College and Garrett A.
30: * Wollman, by William F. Jolitz, and by the University of California,
31: * Berkeley, Lawrence Berkeley Laboratory, and its contributors.
32: * 4. Neither the names of the Universities nor the names of the authors
33: * may be used to endorse or promote products derived from this software
34: * without specific prior written permission.
35: *
36: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
37: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39: * ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR AUTHORS BE LIABLE
40: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
42: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
44: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
45: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46: * SUCH DAMAGE.
47: */
48:
49: /*
50: * Intel 82586 Ethernet chip
51: * Register, bit, and structure definitions.
52: *
53: * Original StarLAN driver written by Garrett Wollman with reference to the
54: * Clarkson Packet Driver code for this chip written by Russ Nelson and others.
55: *
56: * BPF support code taken from hpdev/if_le.c, supplied with tcpdump.
57: *
58: * 3C507 support is loosely based on code donated to NetBSD by Rafal Boni.
59: *
60: * Intel EtherExpress 16 support taken from FreeBSD's if_ix.c, written
61: * by Rodney W. Grimes.
62: *
63: * Majorly cleaned up and 3C507 code merged by Charles Hannum.
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 received frame
77: descriptors around for the receiver to use, and NRXBUF associated receive
78: buffer descriptors, both in a circular list. Whenever a frame is received, we
79: rotate both lists as necessary. (The 586 treats both lists as a simple
80: queue.) We also keep a transmit command around so that packets can be sent
81: off quickly.
82:
83: We configure the adapter in AL-LOC = 1 mode, which means that the
84: Ethernet/802.3 MAC header is placed at the beginning of the receive buffer
85: rather than being split off into various fields in the RFD. This also means
86: that we must include this header in the transmit buffer as well.
87:
88: By convention, all transmit commands, and only transmit commands, shall have
89: the I (IE_CMD_INTR) bit set in the command. This way, when an interrupt
90: arrives at ieintr(), it is immediately possible to tell what precisely caused
91: it. ANY OTHER command-sending routines should run at splnet(), and should
92: post an acknowledgement to every interrupt they generate.
93:
94: The 82586 has a 24-bit address space internally, and the adaptor's memory is
95: located at the top of this region. However, the value we are given in
96: configuration is the CPU's idea of where the adaptor RAM is. So, we must go
97: through a few gyrations to come up with a kernel virtual address which
98: represents the actual beginning of the 586 address space. First, we autosize
99: the RAM by running through several possible sizes and trying to initialize the
100: adapter under the assumption that the selected size is correct. Then, knowing
101: the correct RAM size, we set up our pointers in the softc. `sc_maddr'
102: represents the computed base of the 586 address space. `iomembot' represents
103: the actual configured base of adapter RAM. Finally, `sc_msize' represents the
104: calculated size of 586 RAM. Then, when laying out commands, we use the
105: interval [sc_maddr, sc_maddr + sc_msize); to make 24-pointers, we subtract
106: iomem, and to make 16-pointers, we subtract sc_maddr and and with 0xffff.
107: */
108:
109: #include "bpfilter.h"
110:
111: #include <sys/param.h>
112: #include <sys/systm.h>
113: #include <sys/mbuf.h>
114: #include <sys/buf.h>
115: #include <sys/protosw.h>
116: #include <sys/socket.h>
117: #include <sys/ioctl.h>
118: #include <sys/errno.h>
119: #include <sys/syslog.h>
120: #include <sys/device.h>
121: #include <sys/timeout.h>
122:
123: #include <net/if.h>
124: #include <net/if_types.h>
125: #include <net/if_dl.h>
126: #include <net/netisr.h>
127: #include <net/route.h>
128:
129: #if NBPFILTER > 0
130: #include <net/bpf.h>
131: #endif
132:
133: #ifdef INET
134: #include <netinet/in.h>
135: #include <netinet/in_systm.h>
136: #include <netinet/in_var.h>
137: #include <netinet/ip.h>
138: #include <netinet/if_ether.h>
139: #endif
140:
141: #include <machine/cpu.h>
142: #include <machine/bus.h>
143: #include <machine/intr.h>
144:
145: #include <dev/isa/isareg.h>
146: #include <dev/isa/isavar.h>
147: #include <i386/isa/isa_machdep.h> /* XXX USES ISA HOLE DIRECTLY */
148: #include <dev/ic/i82586reg.h>
149: #include <dev/isa/if_ieatt.h>
150: #include <dev/isa/if_ie507.h>
151: #include <dev/isa/if_iee16.h>
152: #include <dev/isa/elink.h>
153:
154: #define IED_RINT 0x01
155: #define IED_TINT 0x02
156: #define IED_RNR 0x04
157: #define IED_CNA 0x08
158: #define IED_READFRAME 0x10
159: #define IED_ENQ 0x20
160: #define IED_XMIT 0x40
161: #define IED_ALL 0x7f
162:
163: /*
164: sizeof(iscp) == 1+1+2+4 == 8
165: sizeof(scb) == 2+2+2+2+2+2+2+2 == 16
166: NFRAMES * sizeof(rfd) == NFRAMES*(2+2+2+2+6+6+2+2) == NFRAMES*24 == 384
167: sizeof(xmit_cmd) == 2+2+2+2+6+2 == 18
168: sizeof(transmit buffer) == ETHER_MAX_LEN == 1518
169: sizeof(transmit buffer desc) == 8
170: -----
171: 1952
172:
173: NRXBUF * sizeof(rbd) == NRXBUF*(2+2+4+2+2) == NRXBUF*12
174: NRXBUF * IE_RBUF_SIZE == NRXBUF*256
175:
176: NRXBUF should be (16384 - 1952) / (256 + 12) == 14432 / 268 == 53
177:
178: With NRXBUF == 48, this leaves us 1568 bytes for another command or
179: more buffers. Another transmit command would be 18+8+1518 == 1544
180: ---just barely fits!
181:
182: Obviously all these would have to be reduced for smaller memory sizes.
183: With a larger memory, it would be possible to roughly double the number of
184: both transmit and receive buffers.
185: */
186:
187: #define NFRAMES 16 /* number of receive frames */
188: #define NRXBUF 48 /* number of buffers to allocate */
189: #define IE_RBUF_SIZE 256 /* size of each receive buffer;
190: MUST BE POWER OF TWO */
191: #define NTXBUF 2 /* number of transmit commands */
192: #define IE_TBUF_SIZE ETHER_MAX_LEN /* length of transmit buffer */
193:
194:
195: enum ie_hardware {
196: IE_STARLAN10,
197: IE_EN100,
198: IE_SLFIBER,
199: IE_3C507,
200: IE_EE16,
201: IE_UNKNOWN
202: };
203:
204: const char *ie_hardware_names[] = {
205: "StarLAN 10",
206: "EN100",
207: "StarLAN Fiber",
208: "3C507",
209: "EtherExpress 16",
210: "Unknown"
211: };
212:
213: /*
214: * Ethernet status, per interface.
215: */
216: struct ie_softc {
217: struct device sc_dev;
218: void *sc_ih;
219:
220: int sc_iobase;
221: caddr_t sc_maddr;
222: u_int sc_msize;
223:
224: struct arpcom sc_arpcom;
225:
226: void (*reset_586)(struct ie_softc *);
227: void (*chan_attn)(struct ie_softc *);
228:
229: enum ie_hardware hard_type;
230: int hard_vers;
231:
232: int want_mcsetup;
233: int promisc;
234: volatile struct ie_int_sys_conf_ptr *iscp;
235: volatile struct ie_sys_ctl_block *scb;
236:
237: int rfhead, rftail, rbhead, rbtail;
238: volatile struct ie_recv_frame_desc *rframes[NFRAMES];
239: volatile struct ie_recv_buf_desc *rbuffs[NRXBUF];
240: volatile char *cbuffs[NRXBUF];
241:
242: int xmit_busy;
243: int xchead, xctail;
244: volatile struct ie_xmit_cmd *xmit_cmds[NTXBUF];
245: volatile struct ie_xmit_buf *xmit_buffs[NTXBUF];
246: u_char *xmit_cbuffs[NTXBUF];
247:
248: struct ie_en_addr mcast_addrs[MAXMCAST + 1];
249: int mcast_count;
250:
251: u_short irq_encoded; /* encoded interrupt on IEE16 */
252:
253: #ifdef IEDEBUG
254: int sc_debug;
255: #endif
256: };
257:
258: void iewatchdog(struct ifnet *);
259: int ieintr(void *);
260: void iestop(struct ie_softc *);
261: int ieinit(struct ie_softc *);
262: int ieioctl(struct ifnet *, u_long, caddr_t);
263: void iestart(struct ifnet *);
264: static void el_reset_586(struct ie_softc *);
265: static void sl_reset_586(struct ie_softc *);
266: static void el_chan_attn(struct ie_softc *);
267: static void sl_chan_attn(struct ie_softc *);
268: static void slel_get_address(struct ie_softc *);
269:
270: static void ee16_reset_586(struct ie_softc *);
271: static void ee16_chan_attn(struct ie_softc *);
272: static void ee16_interrupt_enable(struct ie_softc *);
273: void ee16_eeprom_outbits(struct ie_softc *, int, int);
274: void ee16_eeprom_clock(struct ie_softc *, int);
275: u_short ee16_read_eeprom(struct ie_softc *, int);
276: int ee16_eeprom_inbits(struct ie_softc *);
277:
278: void iereset(struct ie_softc *);
279: void ie_readframe(struct ie_softc *, int);
280: void ie_drop_packet_buffer(struct ie_softc *);
281: void ie_find_mem_size(struct ie_softc *);
282: static int command_and_wait(struct ie_softc *, int,
283: void volatile *, int);
284: void ierint(struct ie_softc *);
285: void ietint(struct ie_softc *);
286: void iexmit(struct ie_softc *);
287: struct mbuf *ieget(struct ie_softc *,
288: struct ether_header *, int *);
289: void iememinit(void *, struct ie_softc *);
290: static int mc_setup(struct ie_softc *, void *);
291: static void mc_reset(struct ie_softc *);
292:
293: #ifdef IEDEBUG
294: void print_rbd(volatile struct ie_recv_buf_desc *);
295:
296: int in_ierint = 0;
297: int in_ietint = 0;
298: #endif
299:
300: int ieprobe(struct device *, void *, void *);
301: void ieattach(struct device *, struct device *, void *);
302: int sl_probe(struct ie_softc *, struct isa_attach_args *);
303: int el_probe(struct ie_softc *, struct isa_attach_args *);
304: int ee16_probe(struct ie_softc *, struct isa_attach_args *);
305: int check_ie_present(struct ie_softc *, caddr_t, u_int);
306:
307: static __inline void ie_setup_config(volatile struct ie_config_cmd *,
308: int, int);
309: static __inline void ie_ack(struct ie_softc *, u_int);
310: static __inline int ether_equal(u_char *, u_char *);
311: static __inline int check_eh(struct ie_softc *, struct ether_header *,
312: int *);
313: static __inline int ie_buflen(struct ie_softc *, int);
314: static __inline int ie_packet_len(struct ie_softc *);
315:
316: static void run_tdr(struct ie_softc *, struct ie_tdr_cmd *);
317:
318: struct cfattach ie_isa_ca = {
319: sizeof(struct ie_softc), ieprobe, ieattach
320: };
321:
322: struct cfdriver ie_cd = {
323: NULL, "ie", DV_IFNET
324: };
325:
326: #define MK_24(base, ptr) ((caddr_t)((u_long)ptr - (u_long)base))
327: #define MK_16(base, ptr) ((u_short)(u_long)MK_24(base, ptr))
328:
329: #define PORT sc->sc_iobase
330: #define MEM sc->sc_maddr
331:
332: /*
333: * Here are a few useful functions. We could have done these as macros, but
334: * since we have the inline facility, it makes sense to use that instead.
335: */
336: static __inline void
337: ie_setup_config(cmd, promiscuous, manchester)
338: volatile struct ie_config_cmd *cmd;
339: int promiscuous, manchester;
340: {
341:
342: cmd->ie_config_count = 0x0c;
343: cmd->ie_fifo = 8;
344: cmd->ie_save_bad = 0x40;
345: cmd->ie_addr_len = 0x2e;
346: cmd->ie_priority = 0;
347: cmd->ie_ifs = 0x60;
348: cmd->ie_slot_low = 0;
349: cmd->ie_slot_high = 0xf2;
350: cmd->ie_promisc = promiscuous | manchester << 2;
351: cmd->ie_crs_cdt = 0;
352: cmd->ie_min_len = 64;
353: cmd->ie_junk = 0xff;
354: }
355:
356: static __inline void
357: ie_ack(sc, mask)
358: struct ie_softc *sc;
359: u_int mask;
360: {
361: volatile struct ie_sys_ctl_block *scb = sc->scb;
362:
363: scb->ie_command = scb->ie_status & mask;
364: (sc->chan_attn)(sc);
365:
366: while (scb->ie_command)
367: ; /* Spin Lock */
368: }
369:
370: int
371: ieprobe(parent, match, aux)
372: struct device *parent;
373: void *match, *aux;
374: {
375: struct ie_softc *sc = match;
376: struct isa_attach_args *ia = aux;
377:
378: if (sl_probe(sc, ia))
379: return 1;
380: if (el_probe(sc, ia))
381: return 1;
382: if (ee16_probe(sc, ia))
383: return 1;
384: return 0;
385: }
386:
387: int
388: sl_probe(sc, ia)
389: struct ie_softc *sc;
390: struct isa_attach_args *ia;
391: {
392: u_char c;
393:
394: sc->sc_iobase = ia->ia_iobase;
395:
396: /* Need this for part of the probe. */
397: sc->reset_586 = sl_reset_586;
398: sc->chan_attn = sl_chan_attn;
399:
400: c = inb(PORT + IEATT_REVISION);
401: switch (SL_BOARD(c)) {
402: case SL10_BOARD:
403: sc->hard_type = IE_STARLAN10;
404: break;
405: case EN100_BOARD:
406: sc->hard_type = IE_EN100;
407: break;
408: case SLFIBER_BOARD:
409: sc->hard_type = IE_SLFIBER;
410: break;
411:
412: default:
413: /* Anything else is not recognized or cannot be used. */
414: #if 0
415: printf("%s: unknown AT&T board type code %d\n",
416: sc->sc_dev.dv_xname, SL_BOARD(c));
417: #endif
418: return 0;
419: }
420:
421: sc->hard_vers = SL_REV(c);
422:
423: if (ia->ia_irq == IRQUNK || ia->ia_maddr == MADDRUNK) {
424: printf("%s: %s does not have soft configuration\n",
425: sc->sc_dev.dv_xname, ie_hardware_names[sc->hard_type]);
426: return 0;
427: }
428:
429: /*
430: * Divine memory size on-board the card. Ususally 16k.
431: */
432: sc->sc_maddr = ISA_HOLE_VADDR(ia->ia_maddr);
433: ie_find_mem_size(sc);
434:
435: if (!sc->sc_msize) {
436: printf("%s: can't find shared memory\n", sc->sc_dev.dv_xname);
437: return 0;
438: }
439:
440: if (!ia->ia_msize)
441: ia->ia_msize = sc->sc_msize;
442: else if (ia->ia_msize != sc->sc_msize) {
443: printf("%s: msize mismatch; kernel configured %d != board configured %d\n",
444: sc->sc_dev.dv_xname, ia->ia_msize, sc->sc_msize);
445: return 0;
446: }
447:
448: slel_get_address(sc);
449:
450: ia->ia_iosize = 16;
451: return 1;
452: }
453:
454: int
455: el_probe(sc, ia)
456: struct ie_softc *sc;
457: struct isa_attach_args *ia;
458: {
459: bus_space_tag_t iot = ia->ia_iot;
460: bus_space_handle_t ioh;
461: u_char c;
462: int i, rval = 0;
463: u_char signature[] = "*3COM*";
464:
465: sc->sc_iobase = ia->ia_iobase;
466:
467: /* Need this for part of the probe. */
468: sc->reset_586 = el_reset_586;
469: sc->chan_attn = el_chan_attn;
470:
471: /*
472: * Map the Etherlink ID port for the probe sequence.
473: */
474: if (bus_space_map(iot, ELINK_ID_PORT, 1, 0, &ioh)) {
475: printf("3c507 probe: can't map Etherlink ID port\n");
476: return 0;
477: }
478:
479: /*
480: * Reset and put card in CONFIG state without changing address.
481: * XXX Indirect brokenness here!
482: */
483: elink_reset(iot, ioh, sc->sc_dev.dv_parent->dv_unit);
484: elink_idseq(iot, ioh, ELINK_507_POLY);
485: elink_idseq(iot, ioh, ELINK_507_POLY);
486: outb(ELINK_ID_PORT, 0xff);
487:
488: /* Check for 3COM signature before proceeding. */
489: outb(PORT + IE507_CTRL, inb(PORT + IE507_CTRL) & 0xfc); /* XXX */
490: for (i = 0; i < 6; i++)
491: if (inb(PORT + i) != signature[i])
492: goto out;
493:
494: c = inb(PORT + IE507_MADDR);
495: if (c & 0x20) {
496: printf("%s: can't map 3C507 RAM in high memory\n",
497: sc->sc_dev.dv_xname);
498: goto out;
499: }
500:
501: /* Go to RUN state. */
502: outb(ELINK_ID_PORT, 0x00);
503: elink_idseq(iot, ioh, ELINK_507_POLY);
504: outb(ELINK_ID_PORT, 0x00);
505:
506: /* Set bank 2 for version info and read BCD version byte. */
507: outb(PORT + IE507_CTRL, EL_CTRL_NRST | EL_CTRL_BNK2);
508: i = inb(PORT + 3);
509:
510: sc->hard_type = IE_3C507;
511: sc->hard_vers = 10*(i / 16) + (i % 16) - 1;
512:
513: i = inb(PORT + IE507_IRQ) & 0x0f;
514:
515: if (ia->ia_irq != IRQUNK) {
516: if (ia->ia_irq != i) {
517: printf("%s: irq mismatch; kernel configured %d != board configured %d\n",
518: sc->sc_dev.dv_xname, ia->ia_irq, i);
519: goto out;
520: }
521: } else
522: ia->ia_irq = i;
523:
524: i = ((inb(PORT + IE507_MADDR) & 0x1c) << 12) + 0xc0000;
525:
526: if (ia->ia_maddr != MADDRUNK) {
527: if (ia->ia_maddr != i) {
528: printf("%s: maddr mismatch; kernel configured %x != board configured %x\n",
529: sc->sc_dev.dv_xname, ia->ia_maddr, i);
530: goto out;
531: }
532: } else
533: ia->ia_maddr = i;
534:
535: outb(PORT + IE507_CTRL, EL_CTRL_NORMAL);
536:
537: /*
538: * Divine memory size on-board the card.
539: */
540: sc->sc_maddr = ISA_HOLE_VADDR(ia->ia_maddr);
541: ie_find_mem_size(sc);
542:
543: if (!sc->sc_msize) {
544: printf("%s: can't find shared memory\n", sc->sc_dev.dv_xname);
545: outb(PORT + IE507_CTRL, EL_CTRL_NRST);
546: goto out;
547: }
548:
549: if (!ia->ia_msize)
550: ia->ia_msize = sc->sc_msize;
551: else if (ia->ia_msize != sc->sc_msize) {
552: printf("%s: msize mismatch; kernel configured %d != board configured %d\n",
553: sc->sc_dev.dv_xname, ia->ia_msize, sc->sc_msize);
554: outb(PORT + IE507_CTRL, EL_CTRL_NRST);
555: goto out;
556: }
557:
558: slel_get_address(sc);
559:
560: /* Clear the interrupt latch just in case. */
561: outb(PORT + IE507_ICTRL, 1);
562:
563: ia->ia_iosize = 16;
564: rval = 1;
565:
566: out:
567: bus_space_unmap(iot, ioh, 1);
568: return rval;
569: }
570:
571: /* Taken almost exactly from Rod's if_ix.c. */
572:
573: int
574: ee16_probe(sc, ia)
575: struct ie_softc *sc;
576: struct isa_attach_args *ia;
577: {
578: int i;
579: u_short board_id, id_var1, id_var2, checksum = 0;
580: u_short eaddrtemp, irq;
581: u_short pg, adjust, decode, edecode;
582: u_char bart_config;
583:
584: short irq_translate[] = {0, 0x09, 0x03, 0x04, 0x05, 0x0a, 0x0b, 0};
585:
586: /* Need this for part of the probe. */
587: sc->reset_586 = ee16_reset_586;
588: sc->chan_attn = ee16_chan_attn;
589:
590: /* reset any ee16 at the current iobase */
591: outb(ia->ia_iobase + IEE16_ECTRL, IEE16_RESET_ASIC);
592: outb(ia->ia_iobase + IEE16_ECTRL, 0);
593: delay(240);
594:
595: /* now look for ee16. */
596: board_id = id_var1 = id_var2 = 0;
597: for (i=0; i<4 ; i++) {
598: id_var1 = inb(ia->ia_iobase + IEE16_ID_PORT);
599: id_var2 = ((id_var1 & 0x03) << 2);
600: board_id |= (( id_var1 >> 4) << id_var2);
601: }
602:
603: if (board_id != IEE16_ID)
604: return 0;
605:
606: /* need sc->sc_iobase for ee16_read_eeprom */
607: sc->sc_iobase = ia->ia_iobase;
608: sc->hard_type = IE_EE16;
609:
610: /*
611: * If ia->maddr == MADDRUNK, use value in eeprom location 6.
612: *
613: * The shared RAM location on the EE16 is encoded into bits
614: * 3-7 of EEPROM location 6. We zero the upper byte, and
615: * shift the 5 bits right 3. The resulting number tells us
616: * the RAM location. Because the EE16 supports either 16k or 32k
617: * of shared RAM, we only worry about the 32k locations.
618: *
619: * NOTE: if a 64k EE16 exists, it should be added to this switch.
620: * then the ia->ia_msize would need to be set per case statement.
621: *
622: * value msize location
623: * ===== ===== ========
624: * 0x03 0x8000 0xCC000
625: * 0x06 0x8000 0xD0000
626: * 0x0C 0x8000 0xD4000
627: * 0x18 0x8000 0xD8000
628: *
629: */
630:
631: if ((ia->ia_maddr == MADDRUNK) || (ia->ia_msize == 0)) {
632: i = (ee16_read_eeprom(sc, 6) & 0x00ff ) >> 3;
633: switch(i) {
634: case 0x03:
635: ia->ia_maddr = 0xCC000;
636: break;
637: case 0x06:
638: ia->ia_maddr = 0xD0000;
639: break;
640: case 0x0c:
641: ia->ia_maddr = 0xD4000;
642: break;
643: case 0x18:
644: ia->ia_maddr = 0xD8000;
645: break;
646: default:
647: return 0 ;
648: break; /* NOTREACHED */
649: }
650: ia->ia_msize = 0x8000;
651: }
652:
653: /* need to set these after checking for MADDRUNK */
654: sc->sc_maddr = ISA_HOLE_VADDR(ia->ia_maddr);
655: sc->sc_msize = ia->ia_msize;
656:
657: /* need to put the 586 in RESET, and leave it */
658: outb( PORT + IEE16_ECTRL, IEE16_RESET_586);
659:
660: /* read the eeprom and checksum it, should == IEE16_ID */
661: for(i=0 ; i< 0x40 ; i++)
662: checksum += ee16_read_eeprom(sc, i);
663:
664: if (checksum != IEE16_ID)
665: return 0;
666:
667: /*
668: * Size and test the memory on the board. The size of the memory
669: * can be one of 16k, 32k, 48k or 64k. It can be located in the
670: * address range 0xC0000 to 0xEFFFF on 16k boundaries.
671: *
672: * If the size does not match the passed in memory allocation size
673: * issue a warning, but continue with the minimum of the two sizes.
674: */
675:
676: switch (ia->ia_msize) {
677: case 65536:
678: case 32768: /* XXX Only support 32k and 64k right now */
679: break;
680: case 16384:
681: case 49512:
682: default:
683: printf("ieprobe mapped memory size out of range\n");
684: return 0;
685: break; /* NOTREACHED */
686: }
687:
688: if ((kvtop(sc->sc_maddr) < 0xC0000) ||
689: (kvtop(sc->sc_maddr) + sc->sc_msize > 0xF0000)) {
690: printf("ieprobe mapped memory address out of range\n");
691: return 0;
692: }
693:
694: pg = (kvtop(sc->sc_maddr) & 0x3C000) >> 14;
695: adjust = IEE16_MCTRL_FMCS16 | (pg & 0x3) << 2;
696: decode = ((1 << (sc->sc_msize / 16384)) - 1) << pg;
697: edecode = ((~decode >> 4) & 0xF0) | (decode >> 8);
698:
699: /* ZZZ This should be checked against eeprom location 6, low byte */
700: outb(PORT + IEE16_MEMDEC, decode & 0xFF);
701: /* ZZZ This should be checked against eeprom location 1, low byte */
702: outb(PORT + IEE16_MCTRL, adjust);
703: /* ZZZ Now if I could find this one I would have it made */
704: outb(PORT + IEE16_MPCTRL, (~decode & 0xFF));
705: /* ZZZ I think this is location 6, high byte */
706: outb(PORT + IEE16_MECTRL, edecode); /*XXX disable Exxx */
707:
708: /*
709: * first prime the stupid bart DRAM controller so that it
710: * works, then zero out all of memory.
711: */
712: bzero(sc->sc_maddr, 32);
713: bzero(sc->sc_maddr, sc->sc_msize);
714:
715: /*
716: * Get the encoded interrupt number from the EEPROM, check it
717: * against the passed in IRQ. Issue a warning if they do not
718: * match, and fail the probe. If irq is 'IRQUNK' then we
719: * use the EEPROM irq, and continue.
720: */
721: irq = ee16_read_eeprom(sc, IEE16_EEPROM_CONFIG1);
722: irq = (irq & IEE16_EEPROM_IRQ) >> IEE16_EEPROM_IRQ_SHIFT;
723: sc->irq_encoded = irq;
724: irq = irq_translate[irq];
725: if (ia->ia_irq != IRQUNK) {
726: if (irq != ia->ia_irq) {
727: #ifdef DIAGNOSTIC
728: printf("\nie%d: fatal: board IRQ %d does not match kernel\n", sc->sc_dev.dv_unit, irq);
729: #endif /* DIAGNOSTIC */
730: return 0; /* _must_ match or probe fails */
731: }
732: } else
733: ia->ia_irq = irq;
734:
735: /*
736: * Get the hardware ethernet address from the EEPROM and
737: * save it in the softc for use by the 586 setup code.
738: */
739: eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_HIGH);
740: sc->sc_arpcom.ac_enaddr[1] = eaddrtemp & 0xFF;
741: sc->sc_arpcom.ac_enaddr[0] = eaddrtemp >> 8;
742: eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_MID);
743: sc->sc_arpcom.ac_enaddr[3] = eaddrtemp & 0xFF;
744: sc->sc_arpcom.ac_enaddr[2] = eaddrtemp >> 8;
745: eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_LOW);
746: sc->sc_arpcom.ac_enaddr[5] = eaddrtemp & 0xFF;
747: sc->sc_arpcom.ac_enaddr[4] = eaddrtemp >> 8;
748:
749: /* disable the board interrupts */
750: outb(PORT + IEE16_IRQ, sc->irq_encoded);
751:
752: /* enable loopback to keep bad packets off the wire */
753: if(sc->hard_type == IE_EE16) {
754: bart_config = inb(PORT + IEE16_CONFIG);
755: bart_config |= IEE16_BART_LOOPBACK;
756: bart_config |= IEE16_BART_MCS16_TEST; /* inb doesn't get bit! */
757: outb(PORT + IEE16_CONFIG, bart_config);
758: bart_config = inb(PORT + IEE16_CONFIG);
759: }
760:
761: outb(PORT + IEE16_ECTRL, 0);
762: delay(100);
763: if (!check_ie_present(sc, sc->sc_maddr, sc->sc_msize))
764: return 0;
765:
766: ia->ia_iosize = 16; /* the number of I/O ports */
767: return 1; /* found */
768: }
769:
770: /*
771: * Taken almost exactly from Bill's if_is.c, then modified beyond recognition.
772: */
773: void
774: ieattach(parent, self, aux)
775: struct device *parent, *self;
776: void *aux;
777: {
778: struct ie_softc *sc = (void *)self;
779: struct isa_attach_args *ia = aux;
780: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
781:
782: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
783: ifp->if_softc = sc;
784: ifp->if_start = iestart;
785: ifp->if_ioctl = ieioctl;
786: ifp->if_watchdog = iewatchdog;
787: ifp->if_flags =
788: IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
789: IFQ_SET_READY(&ifp->if_snd);
790:
791: /* Attach the interface. */
792: if_attach(ifp);
793: ether_ifattach(ifp);
794:
795: printf(": address %s, type %s R%d\n",
796: ether_sprintf(sc->sc_arpcom.ac_enaddr),
797: ie_hardware_names[sc->hard_type], sc->hard_vers + 1);
798:
799: sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
800: IPL_NET, ieintr, sc, sc->sc_dev.dv_xname);
801: }
802:
803: /*
804: * Device timeout/watchdog routine. Entered if the device neglects to generate
805: * an interrupt after a transmit has been started on it.
806: */
807: void
808: iewatchdog(ifp)
809: struct ifnet *ifp;
810: {
811: struct ie_softc *sc = ifp->if_softc;
812:
813: log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
814: ++sc->sc_arpcom.ac_if.if_oerrors;
815: iereset(sc);
816: }
817:
818: /*
819: * What to do upon receipt of an interrupt.
820: */
821: int
822: ieintr(arg)
823: void *arg;
824: {
825: struct ie_softc *sc = arg;
826: register u_short status;
827:
828: /* Clear the interrupt latch on the 3C507. */
829: if (sc->hard_type == IE_3C507)
830: outb(PORT + IE507_ICTRL, 1);
831:
832: /* disable interrupts on the EE16. */
833: if (sc->hard_type == IE_EE16)
834: outb(PORT + IEE16_IRQ, sc->irq_encoded);
835:
836: status = sc->scb->ie_status & IE_ST_WHENCE;
837: if (status == 0)
838: return 0;
839:
840: loop:
841: /* Ack interrupts FIRST in case we receive more during the ISR. */
842: ie_ack(sc, status);
843:
844: if (status & (IE_ST_FR | IE_ST_RNR)) {
845: #ifdef IEDEBUG
846: in_ierint++;
847: if (sc->sc_debug & IED_RINT)
848: printf("%s: rint\n", sc->sc_dev.dv_xname);
849: #endif
850: ierint(sc);
851: #ifdef IEDEBUG
852: in_ierint--;
853: #endif
854: }
855:
856: if (status & IE_ST_CX) {
857: #ifdef IEDEBUG
858: in_ietint++;
859: if (sc->sc_debug & IED_TINT)
860: printf("%s: tint\n", sc->sc_dev.dv_xname);
861: #endif
862: ietint(sc);
863: #ifdef IEDEBUG
864: in_ietint--;
865: #endif
866: }
867:
868: if (status & IE_ST_RNR) {
869: printf("%s: receiver not ready\n", sc->sc_dev.dv_xname);
870: sc->sc_arpcom.ac_if.if_ierrors++;
871: iereset(sc);
872: }
873:
874: #ifdef IEDEBUG
875: if ((status & IE_ST_CNA) && (sc->sc_debug & IED_CNA))
876: printf("%s: cna\n", sc->sc_dev.dv_xname);
877: #endif
878:
879: /* Clear the interrupt latch on the 3C507. */
880: if (sc->hard_type == IE_3C507)
881: outb(PORT + IE507_ICTRL, 1);
882:
883: status = sc->scb->ie_status & IE_ST_WHENCE;
884: if (status == 0) {
885: /* enable interrupts on the EE16. */
886: if (sc->hard_type == IE_EE16)
887: outb(PORT + IEE16_IRQ, sc->irq_encoded | IEE16_IRQ_ENABLE);
888: return 1;
889: }
890:
891: goto loop;
892: }
893:
894: /*
895: * Process a received-frame interrupt.
896: */
897: void
898: ierint(sc)
899: struct ie_softc *sc;
900: {
901: volatile struct ie_sys_ctl_block *scb = sc->scb;
902: int i, status;
903: static int timesthru = 1024;
904:
905: i = sc->rfhead;
906: for (;;) {
907: status = sc->rframes[i]->ie_fd_status;
908:
909: if ((status & IE_FD_COMPLETE) && (status & IE_FD_OK)) {
910: if (!--timesthru) {
911: sc->sc_arpcom.ac_if.if_ierrors +=
912: scb->ie_err_crc + scb->ie_err_align +
913: scb->ie_err_resource + scb->ie_err_overrun;
914: scb->ie_err_crc = scb->ie_err_align =
915: scb->ie_err_resource = scb->ie_err_overrun =
916: 0;
917: timesthru = 1024;
918: }
919: ie_readframe(sc, i);
920: } else {
921: if ((status & IE_FD_RNR) != 0 &&
922: (scb->ie_status & IE_RU_READY) == 0) {
923: sc->rframes[0]->ie_fd_buf_desc =
924: MK_16(MEM, sc->rbuffs[0]);
925: scb->ie_recv_list = MK_16(MEM, sc->rframes[0]);
926: command_and_wait(sc, IE_RU_START, 0, 0);
927: }
928: break;
929: }
930: i = (i + 1) % NFRAMES;
931: }
932: }
933:
934: /*
935: * Process a command-complete interrupt. These are only generated by the
936: * transmission of frames. This routine is deceptively simple, since most of
937: * the real work is done by iestart().
938: */
939: void
940: ietint(sc)
941: struct ie_softc *sc;
942: {
943: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
944: int status;
945:
946: ifp->if_timer = 0;
947: ifp->if_flags &= ~IFF_OACTIVE;
948:
949: status = sc->xmit_cmds[sc->xctail]->ie_xmit_status;
950:
951: if (!(status & IE_STAT_COMPL) || (status & IE_STAT_BUSY))
952: printf("ietint: command still busy!\n");
953:
954: if (status & IE_STAT_OK) {
955: ifp->if_opackets++;
956: ifp->if_collisions += status & IE_XS_MAXCOLL;
957: } else {
958: ifp->if_oerrors++;
959: /*
960: * XXX
961: * Check SQE and DEFERRED?
962: * What if more than one bit is set?
963: */
964: if (status & IE_STAT_ABORT)
965: printf("%s: send aborted\n", sc->sc_dev.dv_xname);
966: else if (status & IE_XS_LATECOLL)
967: printf("%s: late collision\n", sc->sc_dev.dv_xname);
968: else if (status & IE_XS_NOCARRIER)
969: printf("%s: no carrier\n", sc->sc_dev.dv_xname);
970: else if (status & IE_XS_LOSTCTS)
971: printf("%s: lost CTS\n", sc->sc_dev.dv_xname);
972: else if (status & IE_XS_UNDERRUN)
973: printf("%s: DMA underrun\n", sc->sc_dev.dv_xname);
974: else if (status & IE_XS_EXCMAX) {
975: printf("%s: too many collisions\n", sc->sc_dev.dv_xname);
976: ifp->if_collisions += 16;
977: }
978: }
979:
980: /*
981: * If multicast addresses were added or deleted while transmitting,
982: * mc_reset() set the want_mcsetup flag indicating that we should do
983: * it.
984: */
985: if (sc->want_mcsetup) {
986: mc_setup(sc, (caddr_t)sc->xmit_cbuffs[sc->xctail]);
987: sc->want_mcsetup = 0;
988: }
989:
990: /* Done with the buffer. */
991: sc->xmit_busy--;
992: sc->xctail = (sc->xctail + 1) % NTXBUF;
993:
994: /* Start the next packet, if any, transmitting. */
995: if (sc->xmit_busy > 0)
996: iexmit(sc);
997:
998: iestart(ifp);
999: }
1000:
1001: /*
1002: * Compare two Ether/802 addresses for equality, inlined and unrolled for
1003: * speed. I'd love to have an inline assembler version of this...
1004: */
1005: static __inline int
1006: ether_equal(one, two)
1007: u_char *one, *two;
1008: {
1009:
1010: if (one[0] != two[0] || one[1] != two[1] || one[2] != two[2] ||
1011: one[3] != two[3] || one[4] != two[4] || one[5] != two[5])
1012: return 0;
1013: return 1;
1014: }
1015:
1016: /*
1017: * Check for a valid address. to_bpf is filled in with one of the following:
1018: * 0 -> BPF doesn't get this packet
1019: * 1 -> BPF does get this packet
1020: * 2 -> BPF does get this packet, but we don't
1021: * Return value is true if the packet is for us, and false otherwise.
1022: *
1023: * This routine is a mess, but it's also critical that it be as fast
1024: * as possible. It could be made cleaner if we can assume that the
1025: * only client which will fiddle with IFF_PROMISC is BPF. This is
1026: * probably a good assumption, but we do not make it here. (Yet.)
1027: */
1028: static __inline int
1029: check_eh(sc, eh, to_bpf)
1030: struct ie_softc *sc;
1031: struct ether_header *eh;
1032: int *to_bpf;
1033: {
1034: int i;
1035:
1036: switch (sc->promisc) {
1037: case IFF_ALLMULTI:
1038: /*
1039: * Receiving all multicasts, but no unicasts except those
1040: * destined for us.
1041: */
1042: #if NBPFILTER > 0
1043: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0); /* BPF gets this packet if anybody cares */
1044: #endif
1045: if (eh->ether_dhost[0] & 1)
1046: return 1;
1047: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr))
1048: return 1;
1049: return 0;
1050:
1051: case IFF_PROMISC:
1052: /*
1053: * Receiving all packets. These need to be passed on to BPF.
1054: */
1055: #if NBPFILTER > 0
1056: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0) ||
1057: (sc->sc_arpcom.ac_if.if_bridge != NULL);
1058: #else
1059: *to_bpf = (sc->sc_arpcom.ac_if.if_bridge != NULL);
1060: #endif
1061: /* If for us, accept and hand up to BPF */
1062: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr))
1063: return 1;
1064:
1065: #if NBPFILTER > 0
1066: if (*to_bpf && sc->sc_arpcom.ac_if.if_bridge == NULL)
1067: *to_bpf = 2; /* we don't need to see it */
1068: #endif
1069:
1070: /*
1071: * Not a multicast, so BPF wants to see it but we don't.
1072: */
1073: if (!(eh->ether_dhost[0] & 1))
1074: return 1;
1075:
1076: /*
1077: * If it's one of our multicast groups, accept it and pass it
1078: * up.
1079: */
1080: for (i = 0; i < sc->mcast_count; i++) {
1081: if (ether_equal(eh->ether_dhost, (u_char *)&sc->mcast_addrs[i])) {
1082: #if NBPFILTER > 0
1083: if (*to_bpf)
1084: *to_bpf = 1;
1085: #endif
1086: return 1;
1087: }
1088: }
1089: return 1;
1090:
1091: case IFF_ALLMULTI | IFF_PROMISC:
1092: /*
1093: * Acting as a multicast router, and BPF running at the same
1094: * time. Whew! (Hope this is a fast machine...)
1095: */
1096: #if NBPFILTER > 0
1097: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0) ||
1098: (sc->sc_arpcom.ac_if.if_bridge != NULL);
1099: #else
1100: *to_bpf = (sc->sc_arpcom.ac_if.if_bridge != NULL);
1101: #endif
1102: /* We want to see multicasts. */
1103: if (eh->ether_dhost[0] & 1)
1104: return 1;
1105:
1106: /* We want to see our own packets */
1107: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr))
1108: return 1;
1109:
1110: /* Anything else goes to BPF but nothing else. */
1111: #if NBPFILTER > 0
1112: if (*to_bpf && sc->sc_arpcom.ac_if.if_bridge == NULL)
1113: *to_bpf = 2;
1114: #endif
1115: return 1;
1116:
1117: case 0:
1118: /*
1119: * Only accept unicast packets destined for us, or multicasts
1120: * for groups that we belong to. For now, we assume that the
1121: * '586 will only return packets that we asked it for. This
1122: * isn't strictly true (it uses hashing for the multicast
1123: * filter), but it will do in this case, and we want to get out
1124: * of here as quickly as possible.
1125: */
1126: #if NBPFILTER > 0
1127: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0);
1128: #endif
1129: return 1;
1130: }
1131:
1132: #ifdef DIAGNOSTIC
1133: panic("check_eh: impossible");
1134: #endif
1135: return 0;
1136: }
1137:
1138: /*
1139: * We want to isolate the bits that have meaning... This assumes that
1140: * IE_RBUF_SIZE is an even power of two. If somehow the act_len exceeds
1141: * the size of the buffer, then we are screwed anyway.
1142: */
1143: static __inline int
1144: ie_buflen(sc, head)
1145: struct ie_softc *sc;
1146: int head;
1147: {
1148:
1149: return (sc->rbuffs[head]->ie_rbd_actual
1150: & (IE_RBUF_SIZE | (IE_RBUF_SIZE - 1)));
1151: }
1152:
1153: static __inline int
1154: ie_packet_len(sc)
1155: struct ie_softc *sc;
1156: {
1157: int i;
1158: int head = sc->rbhead;
1159: int acc = 0;
1160:
1161: do {
1162: if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED))
1163: return -1;
1164:
1165: i = sc->rbuffs[head]->ie_rbd_actual & IE_RBD_LAST;
1166:
1167: acc += ie_buflen(sc, head);
1168: head = (head + 1) % NRXBUF;
1169: } while (!i);
1170:
1171: return acc;
1172: }
1173:
1174: /*
1175: * Setup all necessary artifacts for an XMIT command, and then pass the XMIT
1176: * command to the chip to be executed. On the way, if we have a BPF listener
1177: * also give him a copy.
1178: */
1179: void
1180: iexmit(sc)
1181: struct ie_softc *sc;
1182: {
1183:
1184: #ifdef IEDEBUG
1185: if (sc->sc_debug & IED_XMIT)
1186: printf("%s: xmit buffer %d\n", sc->sc_dev.dv_xname,
1187: sc->xctail);
1188: #endif
1189:
1190: #if NBPFILTER > 0
1191: /*
1192: * If BPF is listening on this interface, let it see the packet before
1193: * we push it on the wire.
1194: */
1195: if (sc->sc_arpcom.ac_if.if_bpf)
1196: bpf_tap(sc->sc_arpcom.ac_if.if_bpf,
1197: sc->xmit_cbuffs[sc->xctail],
1198: sc->xmit_buffs[sc->xctail]->ie_xmit_flags,
1199: BPF_DIRECTION_OUT);
1200: #endif
1201:
1202: sc->xmit_buffs[sc->xctail]->ie_xmit_flags |= IE_XMIT_LAST;
1203: sc->xmit_buffs[sc->xctail]->ie_xmit_next = 0xffff;
1204: sc->xmit_buffs[sc->xctail]->ie_xmit_buf =
1205: MK_24(MEM, sc->xmit_cbuffs[sc->xctail]);
1206:
1207: sc->xmit_cmds[sc->xctail]->com.ie_cmd_link = 0xffff;
1208: sc->xmit_cmds[sc->xctail]->com.ie_cmd_cmd =
1209: IE_CMD_XMIT | IE_CMD_INTR | IE_CMD_LAST;
1210:
1211: sc->xmit_cmds[sc->xctail]->ie_xmit_status = 0;
1212: sc->xmit_cmds[sc->xctail]->ie_xmit_desc =
1213: MK_16(MEM, sc->xmit_buffs[sc->xctail]);
1214:
1215: sc->scb->ie_command_list = MK_16(MEM, sc->xmit_cmds[sc->xctail]);
1216: command_and_wait(sc, IE_CU_START, 0, 0);
1217:
1218: sc->sc_arpcom.ac_if.if_timer = 5;
1219: }
1220:
1221: /*
1222: * Read data off the interface, and turn it into an mbuf chain.
1223: *
1224: * This code is DRAMATICALLY different from the previous version; this version
1225: * tries to allocate the entire mbuf chain up front, given the length of the
1226: * data available. This enables us to allocate mbuf clusters in many
1227: * situations where before we would have had a long chain of partially-full
1228: * mbufs. This should help to speed up the operation considerably. (Provided
1229: * that it works, of course.)
1230: */
1231: struct mbuf *
1232: ieget(sc, ehp, to_bpf)
1233: struct ie_softc *sc;
1234: struct ether_header *ehp;
1235: int *to_bpf;
1236: {
1237: struct mbuf *top, **mp, *m;
1238: int len, totlen, resid;
1239: int thisrboff, thismboff;
1240: int head;
1241:
1242: resid = totlen = ie_packet_len(sc);
1243: if (totlen <= 0)
1244: return 0;
1245:
1246: head = sc->rbhead;
1247:
1248: /*
1249: * Snarf the Ethernet header.
1250: */
1251: bcopy((caddr_t)sc->cbuffs[head], (caddr_t)ehp, sizeof *ehp);
1252:
1253: /*
1254: * As quickly as possible, check if this packet is for us.
1255: * If not, don't waste a single cycle copying the rest of the
1256: * packet in.
1257: * This is only a consideration when FILTER is defined; i.e., when
1258: * we are either running BPF or doing multicasting.
1259: */
1260: if (!check_eh(sc, ehp, to_bpf)) {
1261: sc->sc_arpcom.ac_if.if_ierrors--; /* just this case, it's not an error */
1262: return 0;
1263: }
1264:
1265: MGETHDR(m, M_DONTWAIT, MT_DATA);
1266: if (m == 0)
1267: return 0;
1268: m->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if;
1269: m->m_pkthdr.len = totlen;
1270: len = MHLEN;
1271: top = 0;
1272: mp = ⊤
1273:
1274: /*
1275: * This loop goes through and allocates mbufs for all the data we will
1276: * be copying in. It does not actually do the copying yet.
1277: */
1278: while (totlen > 0) {
1279: if (top) {
1280: MGET(m, M_DONTWAIT, MT_DATA);
1281: if (m == 0) {
1282: m_freem(top);
1283: return 0;
1284: }
1285: len = MLEN;
1286: }
1287: if (totlen >= MINCLSIZE) {
1288: MCLGET(m, M_DONTWAIT);
1289: if (m->m_flags & M_EXT)
1290: len = MCLBYTES;
1291: }
1292: m->m_len = len = min(totlen, len);
1293: totlen -= len;
1294: *mp = m;
1295: mp = &m->m_next;
1296: }
1297:
1298: m = top;
1299: thisrboff = 0;
1300: thismboff = 0;
1301:
1302: /*
1303: * Now we take the mbuf chain (hopefully only one mbuf most of the
1304: * time) and stuff the data into it. There are no possible failures at
1305: * or after this point.
1306: */
1307: while (resid > 0) {
1308: int thisrblen = ie_buflen(sc, head) - thisrboff,
1309: thismblen = m->m_len - thismboff;
1310: len = min(thisrblen, thismblen);
1311:
1312: bcopy((caddr_t)(sc->cbuffs[head] + thisrboff),
1313: mtod(m, caddr_t) + thismboff, (u_int)len);
1314: resid -= len;
1315:
1316: if (len == thismblen) {
1317: m = m->m_next;
1318: thismboff = 0;
1319: } else
1320: thismboff += len;
1321:
1322: if (len == thisrblen) {
1323: head = (head + 1) % NRXBUF;
1324: thisrboff = 0;
1325: } else
1326: thisrboff += len;
1327: }
1328:
1329: /*
1330: * Unless something changed strangely while we were doing the copy, we
1331: * have now copied everything in from the shared memory.
1332: * This means that we are done.
1333: */
1334: return top;
1335: }
1336:
1337: /*
1338: * Read frame NUM from unit UNIT (pre-cached as IE).
1339: *
1340: * This routine reads the RFD at NUM, and copies in the buffers from the list
1341: * of RBD, then rotates the RBD and RFD lists so that the receiver doesn't
1342: * start complaining. Trailers are DROPPED---there's no point in wasting time
1343: * on confusing code to deal with them. Hopefully, this machine will never ARP
1344: * for trailers anyway.
1345: */
1346: void
1347: ie_readframe(sc, num)
1348: struct ie_softc *sc;
1349: int num; /* frame number to read */
1350: {
1351: int status;
1352: struct mbuf *m = 0;
1353: struct ether_header eh;
1354: #if NBPFILTER > 0
1355: int bpf_gets_it = 0;
1356: #endif
1357:
1358: status = sc->rframes[num]->ie_fd_status;
1359:
1360: /* Advance the RFD list, since we're done with this descriptor. */
1361: sc->rframes[num]->ie_fd_status = 0;
1362: sc->rframes[num]->ie_fd_last |= IE_FD_LAST;
1363: sc->rframes[sc->rftail]->ie_fd_last &= ~IE_FD_LAST;
1364: sc->rftail = (sc->rftail + 1) % NFRAMES;
1365: sc->rfhead = (sc->rfhead + 1) % NFRAMES;
1366:
1367: if (status & IE_FD_OK) {
1368: #if NBPFILTER > 0
1369: m = ieget(sc, &eh, &bpf_gets_it);
1370: #else
1371: m = ieget(sc, &eh, 0);
1372: #endif
1373: ie_drop_packet_buffer(sc);
1374: }
1375: if (m == 0) {
1376: sc->sc_arpcom.ac_if.if_ierrors++;
1377: return;
1378: }
1379:
1380: #ifdef IEDEBUG
1381: if (sc->sc_debug & IED_READFRAME)
1382: printf("%s: frame from ether %s type %x\n", sc->sc_dev.dv_xname,
1383: ether_sprintf(eh.ether_shost), (u_int)eh.ether_type);
1384: #endif
1385:
1386: #if NBPFILTER > 0
1387: /* Check for a BPF filter; if so, hand it up. */
1388: if (bpf_gets_it) {
1389: /* Pass it up. */
1390: bpf_mtap(sc->sc_arpcom.ac_if.if_bpf, m, BPF_DIRECTION_IN);
1391:
1392: /*
1393: * A signal passed up from the filtering code indicating that
1394: * the packet is intended for BPF but not for the protocol
1395: * machinery. We can save a few cycles by not handing it off
1396: * to them.
1397: */
1398: if (bpf_gets_it == 2) {
1399: m_freem(m);
1400: return;
1401: }
1402: }
1403: #endif /* NBPFILTER > 0 */
1404:
1405: /*
1406: * In here there used to be code to check destination addresses upon
1407: * receipt of a packet. We have deleted that code, and replaced it
1408: * with code to check the address much earlier in the cycle, before
1409: * copying the data in; this saves us valuable cycles when operating
1410: * as a multicast router or when using BPF.
1411: */
1412:
1413: /*
1414: * Finally pass this packet up to higher layers.
1415: */
1416: ether_input_mbuf(&sc->sc_arpcom.ac_if, m);
1417: sc->sc_arpcom.ac_if.if_ipackets++;
1418: }
1419:
1420: void
1421: ie_drop_packet_buffer(sc)
1422: struct ie_softc *sc;
1423: {
1424: int i;
1425:
1426: do {
1427: /*
1428: * This means we are somehow out of sync. So, we reset the
1429: * adapter.
1430: */
1431: if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
1432: #ifdef IEDEBUG
1433: print_rbd(sc->rbuffs[sc->rbhead]);
1434: #endif
1435: log(LOG_ERR, "%s: receive descriptors out of sync at %d\n",
1436: sc->sc_dev.dv_xname, sc->rbhead);
1437: iereset(sc);
1438: return;
1439: }
1440:
1441: i = sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_LAST;
1442:
1443: sc->rbuffs[sc->rbhead]->ie_rbd_length |= IE_RBD_LAST;
1444: sc->rbuffs[sc->rbhead]->ie_rbd_actual = 0;
1445: sc->rbhead = (sc->rbhead + 1) % NRXBUF;
1446: sc->rbuffs[sc->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
1447: sc->rbtail = (sc->rbtail + 1) % NRXBUF;
1448: } while (!i);
1449: }
1450:
1451: /*
1452: * Start transmission on an interface.
1453: */
1454: void
1455: iestart(ifp)
1456: struct ifnet *ifp;
1457: {
1458: struct ie_softc *sc = ifp->if_softc;
1459: struct mbuf *m0, *m;
1460: u_char *buffer;
1461: u_short len;
1462:
1463: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
1464: return;
1465:
1466: for (;;) {
1467: if (sc->xmit_busy == NTXBUF) {
1468: ifp->if_flags |= IFF_OACTIVE;
1469: break;
1470: }
1471:
1472: IFQ_DEQUEUE(&ifp->if_snd, m0);
1473: if (m0 == 0)
1474: break;
1475:
1476: /* We need to use m->m_pkthdr.len, so require the header */
1477: if ((m0->m_flags & M_PKTHDR) == 0)
1478: panic("iestart: no header mbuf");
1479:
1480: #if NBPFILTER > 0
1481: /* Tap off here if there is a BPF listener. */
1482: if (ifp->if_bpf)
1483: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
1484: #endif
1485:
1486: #ifdef IEDEBUG
1487: if (sc->sc_debug & IED_ENQ)
1488: printf("%s: fill buffer %d\n", sc->sc_dev.dv_xname,
1489: sc->xchead);
1490: #endif
1491:
1492: len = 0;
1493: buffer = sc->xmit_cbuffs[sc->xchead];
1494:
1495: for (m = m0; m != NULL && (len + m->m_len) < IE_TBUF_SIZE;
1496: m = m->m_next) {
1497: bcopy(mtod(m, caddr_t), buffer, m->m_len);
1498: buffer += m->m_len;
1499: len += m->m_len;
1500: }
1501: if (m != NULL)
1502: printf("%s: tbuf overflow\n", sc->sc_dev.dv_xname);
1503:
1504: m_freem(m0);
1505:
1506: if (len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
1507: bzero(buffer, ETHER_MIN_LEN - ETHER_CRC_LEN - len);
1508: len = ETHER_MIN_LEN - ETHER_CRC_LEN;
1509: buffer += ETHER_MIN_LEN - ETHER_CRC_LEN;
1510: }
1511:
1512: sc->xmit_buffs[sc->xchead]->ie_xmit_flags = len;
1513:
1514: /* Start the first packet transmitting. */
1515: if (sc->xmit_busy == 0)
1516: iexmit(sc);
1517:
1518: sc->xchead = (sc->xchead + 1) % NTXBUF;
1519: sc->xmit_busy++;
1520: }
1521: }
1522:
1523: /*
1524: * Check to see if there's an 82586 out there.
1525: */
1526: int
1527: check_ie_present(sc, where, size)
1528: struct ie_softc *sc;
1529: caddr_t where;
1530: u_int size;
1531: {
1532: volatile struct ie_sys_conf_ptr *scp;
1533: volatile struct ie_int_sys_conf_ptr *iscp;
1534: volatile struct ie_sys_ctl_block *scb;
1535: u_long realbase;
1536: int s;
1537:
1538: s = splnet();
1539:
1540: realbase = (u_long)where + size - (1 << 24);
1541:
1542: scp = (volatile struct ie_sys_conf_ptr *)(realbase + IE_SCP_ADDR);
1543: bzero((char *)scp, sizeof *scp);
1544:
1545: /*
1546: * First we put the ISCP at the bottom of memory; this tests to make
1547: * sure that our idea of the size of memory is the same as the
1548: * controller's. This is NOT where the ISCP will be in normal
1549: * operation.
1550: */
1551: iscp = (volatile struct ie_int_sys_conf_ptr *)where;
1552: bzero((char *)iscp, sizeof *iscp);
1553:
1554: scb = (volatile struct ie_sys_ctl_block *)where;
1555: bzero((char *)scb, sizeof *scb);
1556:
1557: scp->ie_bus_use = 0; /* 16-bit */
1558: scp->ie_iscp_ptr = (caddr_t)((volatile caddr_t)iscp -
1559: (volatile caddr_t)realbase);
1560:
1561: iscp->ie_busy = 1;
1562: iscp->ie_scb_offset = MK_16(realbase, scb) + 256;
1563:
1564: (sc->reset_586)(sc);
1565: (sc->chan_attn)(sc);
1566:
1567: delay(100); /* wait a while... */
1568:
1569: if (iscp->ie_busy) {
1570: splx(s);
1571: return 0;
1572: }
1573:
1574: /*
1575: * Now relocate the ISCP to its real home, and reset the controller
1576: * again.
1577: */
1578: iscp = (void *)ALIGN(realbase + IE_SCP_ADDR - sizeof(*iscp));
1579: bzero((char *)iscp, sizeof *iscp);
1580:
1581: scp->ie_iscp_ptr = (caddr_t)((caddr_t)iscp - (caddr_t)realbase);
1582:
1583: iscp->ie_busy = 1;
1584: iscp->ie_scb_offset = MK_16(realbase, scb);
1585:
1586: (sc->reset_586)(sc);
1587: (sc->chan_attn)(sc);
1588:
1589: delay(100);
1590:
1591: if (iscp->ie_busy) {
1592: splx(s);
1593: return 0;
1594: }
1595:
1596: sc->sc_msize = size;
1597: sc->sc_maddr = (caddr_t)realbase;
1598:
1599: sc->iscp = iscp;
1600: sc->scb = scb;
1601:
1602: /*
1603: * Acknowledge any interrupts we may have caused...
1604: */
1605: ie_ack(sc, IE_ST_WHENCE);
1606: splx(s);
1607:
1608: return 1;
1609: }
1610:
1611: /*
1612: * Divine the memory size of ie board UNIT.
1613: * Better hope there's nothing important hiding just below the ie card...
1614: */
1615: void
1616: ie_find_mem_size(sc)
1617: struct ie_softc *sc;
1618: {
1619: u_int size;
1620:
1621: sc->sc_msize = 0;
1622:
1623: for (size = 65536; size >= 16384; size -= 16384)
1624: if (check_ie_present(sc, sc->sc_maddr, size))
1625: return;
1626:
1627: return;
1628: }
1629:
1630: void
1631: el_reset_586(sc)
1632: struct ie_softc *sc;
1633: {
1634:
1635: outb(PORT + IE507_CTRL, EL_CTRL_RESET);
1636: delay(100);
1637: outb(PORT + IE507_CTRL, EL_CTRL_NORMAL);
1638: delay(100);
1639: }
1640:
1641: void
1642: sl_reset_586(sc)
1643: struct ie_softc *sc;
1644: {
1645:
1646: outb(PORT + IEATT_RESET, 0);
1647: }
1648:
1649: void
1650: ee16_reset_586(sc)
1651: struct ie_softc *sc;
1652: {
1653:
1654: outb(PORT + IEE16_ECTRL, IEE16_RESET_586);
1655: delay(100);
1656: outb(PORT + IEE16_ECTRL, 0);
1657: delay(100);
1658: }
1659:
1660: void
1661: el_chan_attn(sc)
1662: struct ie_softc *sc;
1663: {
1664:
1665: outb(PORT + IE507_ATTN, 1);
1666: }
1667:
1668: void
1669: sl_chan_attn(sc)
1670: struct ie_softc *sc;
1671: {
1672:
1673: outb(PORT + IEATT_ATTN, 0);
1674: }
1675:
1676: void
1677: ee16_chan_attn(sc)
1678: struct ie_softc *sc;
1679: {
1680: outb(PORT + IEE16_ATTN, 0);
1681: }
1682:
1683: u_short
1684: ee16_read_eeprom(sc, location)
1685: struct ie_softc *sc;
1686: int location;
1687: {
1688: int ectrl, edata;
1689:
1690: ectrl = inb(PORT + IEE16_ECTRL);
1691: ectrl &= IEE16_ECTRL_MASK;
1692: ectrl |= IEE16_ECTRL_EECS;
1693: outb(PORT + IEE16_ECTRL, ectrl);
1694:
1695: ee16_eeprom_outbits(sc, IEE16_EEPROM_READ, IEE16_EEPROM_OPSIZE1);
1696: ee16_eeprom_outbits(sc, location, IEE16_EEPROM_ADDR_SIZE);
1697: edata = ee16_eeprom_inbits(sc);
1698: ectrl = inb(PORT + IEE16_ECTRL);
1699: ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EEDI | IEE16_ECTRL_EECS);
1700: outb(PORT + IEE16_ECTRL, ectrl);
1701: ee16_eeprom_clock(sc, 1);
1702: ee16_eeprom_clock(sc, 0);
1703: return edata;
1704: }
1705:
1706: void
1707: ee16_eeprom_outbits(sc, edata, count)
1708: struct ie_softc *sc;
1709: int edata, count;
1710: {
1711: int ectrl, i;
1712:
1713: ectrl = inb(PORT + IEE16_ECTRL);
1714: ectrl &= ~IEE16_RESET_ASIC;
1715: for (i = count - 1; i >= 0; i--) {
1716: ectrl &= ~IEE16_ECTRL_EEDI;
1717: if (edata & (1 << i)) {
1718: ectrl |= IEE16_ECTRL_EEDI;
1719: }
1720: outb(PORT + IEE16_ECTRL, ectrl);
1721: delay(1); /* eeprom data must be setup for 0.4 uSec */
1722: ee16_eeprom_clock(sc, 1);
1723: ee16_eeprom_clock(sc, 0);
1724: }
1725: ectrl &= ~IEE16_ECTRL_EEDI;
1726: outb(PORT + IEE16_ECTRL, ectrl);
1727: delay(1); /* eeprom data must be held for 0.4 uSec */
1728: }
1729:
1730: int
1731: ee16_eeprom_inbits(sc)
1732: struct ie_softc *sc;
1733: {
1734: int ectrl, edata, i;
1735:
1736: ectrl = inb(PORT + IEE16_ECTRL);
1737: ectrl &= ~IEE16_RESET_ASIC;
1738: for (edata = 0, i = 0; i < 16; i++) {
1739: edata = edata << 1;
1740: ee16_eeprom_clock(sc, 1);
1741: ectrl = inb(PORT + IEE16_ECTRL);
1742: if (ectrl & IEE16_ECTRL_EEDO) {
1743: edata |= 1;
1744: }
1745: ee16_eeprom_clock(sc, 0);
1746: }
1747: return (edata);
1748: }
1749:
1750: void
1751: ee16_eeprom_clock(sc, state)
1752: struct ie_softc *sc;
1753: int state;
1754: {
1755: int ectrl;
1756:
1757: ectrl = inb(PORT + IEE16_ECTRL);
1758: ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EESK);
1759: if (state) {
1760: ectrl |= IEE16_ECTRL_EESK;
1761: }
1762: outb(PORT + IEE16_ECTRL, ectrl);
1763: delay(9); /* EESK must be stable for 8.38 uSec */
1764: }
1765:
1766: static inline void
1767: ee16_interrupt_enable(sc)
1768: struct ie_softc *sc;
1769: {
1770: delay(100);
1771: outb(PORT + IEE16_IRQ, sc->irq_encoded | IEE16_IRQ_ENABLE);
1772: delay(100);
1773: }
1774: void
1775: slel_get_address(sc)
1776: struct ie_softc *sc;
1777: {
1778: u_char *addr = sc->sc_arpcom.ac_enaddr;
1779: int i;
1780:
1781: for (i = 0; i < ETHER_ADDR_LEN; i++)
1782: addr[i] = inb(PORT + i);
1783: }
1784:
1785: void
1786: iereset(sc)
1787: struct ie_softc *sc;
1788: {
1789: int s = splnet();
1790:
1791: iestop(sc);
1792:
1793: /*
1794: * Stop i82586 dead in its tracks.
1795: */
1796: if (command_and_wait(sc, IE_RU_ABORT | IE_CU_ABORT, 0, 0))
1797: printf("%s: abort commands timed out\n", sc->sc_dev.dv_xname);
1798:
1799: if (command_and_wait(sc, IE_RU_DISABLE | IE_CU_STOP, 0, 0))
1800: printf("%s: disable commands timed out\n", sc->sc_dev.dv_xname);
1801:
1802: ieinit(sc);
1803:
1804: splx(s);
1805: }
1806:
1807: /*
1808: * Send a command to the controller and wait for it to either complete or be
1809: * accepted, depending on the command. If the command pointer is null, then
1810: * pretend that the command is not an action command. If the command pointer
1811: * is not null, and the command is an action command, wait for
1812: * ((volatile struct ie_cmd_common *)pcmd)->ie_cmd_status & MASK
1813: * to become true.
1814: */
1815: static int
1816: command_and_wait(sc, cmd, pcmd, mask)
1817: struct ie_softc *sc;
1818: int cmd;
1819: volatile void *pcmd;
1820: int mask;
1821: {
1822: volatile struct ie_cmd_common *cc = pcmd;
1823: volatile struct ie_sys_ctl_block *scb = sc->scb;
1824: int i;
1825:
1826: scb->ie_command = (u_short)cmd;
1827:
1828: if (IE_ACTION_COMMAND(cmd) && pcmd) {
1829: (sc->chan_attn)(sc);
1830:
1831: /*
1832: * According to the packet driver, the minimum timeout should
1833: * be .369 seconds, which we round up to .4.
1834: *
1835: * Now spin-lock waiting for status. This is not a very nice
1836: * thing to do, but I haven't figured out how, or indeed if, we
1837: * can put the process waiting for action to sleep. (We may
1838: * be getting called through some other timeout running in the
1839: * kernel.)
1840: */
1841: for (i = 36900; i--; DELAY(10))
1842: if ((cc->ie_cmd_status & mask))
1843: break;
1844:
1845: return i < 0;
1846: } else {
1847: /*
1848: * Otherwise, just wait for the command to be accepted.
1849: */
1850: (sc->chan_attn)(sc);
1851:
1852: while (scb->ie_command)
1853: ; /* spin lock */
1854:
1855: return 0;
1856: }
1857: }
1858:
1859: /*
1860: * Run the time-domain reflectometer.
1861: */
1862: static void
1863: run_tdr(sc, cmd)
1864: struct ie_softc *sc;
1865: struct ie_tdr_cmd *cmd;
1866: {
1867: int result;
1868:
1869: cmd->com.ie_cmd_status = 0;
1870: cmd->com.ie_cmd_cmd = IE_CMD_TDR | IE_CMD_LAST;
1871: cmd->com.ie_cmd_link = 0xffff;
1872:
1873: sc->scb->ie_command_list = MK_16(MEM, cmd);
1874: cmd->ie_tdr_time = 0;
1875:
1876: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
1877: !(cmd->com.ie_cmd_status & IE_STAT_OK))
1878: result = 0x10000;
1879: else
1880: result = cmd->ie_tdr_time;
1881:
1882: ie_ack(sc, IE_ST_WHENCE);
1883:
1884: if (result & IE_TDR_SUCCESS)
1885: return;
1886:
1887: if (result & 0x10000)
1888: printf("%s: TDR command failed\n", sc->sc_dev.dv_xname);
1889: else if (result & IE_TDR_XCVR)
1890: printf("%s: transceiver problem\n", sc->sc_dev.dv_xname);
1891: else if (result & IE_TDR_OPEN)
1892: printf("%s: TDR detected an open %d clocks away\n",
1893: sc->sc_dev.dv_xname, result & IE_TDR_TIME);
1894: else if (result & IE_TDR_SHORT)
1895: printf("%s: TDR detected a short %d clocks away\n",
1896: sc->sc_dev.dv_xname, result & IE_TDR_TIME);
1897: else
1898: printf("%s: TDR returned unknown status %x\n",
1899: sc->sc_dev.dv_xname, result);
1900: }
1901:
1902: #define _ALLOC(p, n) (bzero(p, n), p += n, p - n)
1903: #define ALLOC(p, n) _ALLOC(p, ALIGN(n))
1904:
1905: /*
1906: * Here is a helper routine for ieinit(). This sets up the buffers.
1907: */
1908: void
1909: iememinit(ptr, sc)
1910: void *ptr;
1911: struct ie_softc *sc;
1912: {
1913: int i;
1914:
1915: /* First lay them out. */
1916: for (i = 0; i < NFRAMES; i++)
1917: sc->rframes[i] = ALLOC(ptr, sizeof(*sc->rframes[i]));
1918:
1919: /* Now link them together. */
1920: for (i = 0; i < NFRAMES; i++)
1921: sc->rframes[i]->ie_fd_next =
1922: MK_16(MEM, sc->rframes[(i + 1) % NFRAMES]);
1923:
1924: /* Finally, set the EOL bit on the last one. */
1925: sc->rframes[NFRAMES - 1]->ie_fd_last |= IE_FD_LAST;
1926:
1927: /*
1928: * Now lay out some buffers for the incoming frames. Note that we set
1929: * aside a bit of slop in each buffer, to make sure that we have enough
1930: * space to hold a single frame in every buffer.
1931: */
1932: for (i = 0; i < NRXBUF; i++) {
1933: sc->rbuffs[i] = ALLOC(ptr, sizeof(*sc->rbuffs[i]));
1934: sc->rbuffs[i]->ie_rbd_length = IE_RBUF_SIZE;
1935: sc->rbuffs[i]->ie_rbd_buffer = MK_24(MEM, ptr);
1936: sc->cbuffs[i] = ALLOC(ptr, IE_RBUF_SIZE);
1937: }
1938:
1939: /* Now link them together. */
1940: for (i = 0; i < NRXBUF; i++)
1941: sc->rbuffs[i]->ie_rbd_next =
1942: MK_16(MEM, sc->rbuffs[(i + 1) % NRXBUF]);
1943:
1944: /* Tag EOF on the last one. */
1945: sc->rbuffs[NRXBUF - 1]->ie_rbd_length |= IE_RBD_LAST;
1946:
1947: /*
1948: * We use the head and tail pointers on receive to keep track of the
1949: * order in which RFDs and RBDs are used.
1950: */
1951: sc->rfhead = 0;
1952: sc->rftail = NFRAMES - 1;
1953: sc->rbhead = 0;
1954: sc->rbtail = NRXBUF - 1;
1955:
1956: sc->scb->ie_recv_list = MK_16(MEM, sc->rframes[0]);
1957: sc->rframes[0]->ie_fd_buf_desc = MK_16(MEM, sc->rbuffs[0]);
1958:
1959: /*
1960: * Finally, the transmit command and buffer are the last little bit of
1961: * work.
1962: */
1963: for (i = 0; i < NTXBUF; i++) {
1964: sc->xmit_cmds[i] = ALLOC(ptr, sizeof(*sc->xmit_cmds[i]));
1965: sc->xmit_buffs[i] = ALLOC(ptr, sizeof(*sc->xmit_buffs[i]));
1966: }
1967:
1968: for (i = 0; i < NTXBUF; i++)
1969: sc->xmit_cbuffs[i] = ALLOC(ptr, IE_TBUF_SIZE);
1970:
1971: /* Pointers to last packet sent and next available transmit buffer. */
1972: sc->xchead = sc->xctail = 0;
1973:
1974: /* Clear transmit-busy flag and set number of free transmit buffers. */
1975: sc->xmit_busy = 0;
1976: }
1977:
1978: /*
1979: * Run the multicast setup command.
1980: * Called at splnet().
1981: */
1982: static int
1983: mc_setup(sc, ptr)
1984: struct ie_softc *sc;
1985: void *ptr;
1986: {
1987: volatile struct ie_mcast_cmd *cmd = ptr;
1988:
1989: cmd->com.ie_cmd_status = 0;
1990: cmd->com.ie_cmd_cmd = IE_CMD_MCAST | IE_CMD_LAST;
1991: cmd->com.ie_cmd_link = 0xffff;
1992:
1993: bcopy((caddr_t)sc->mcast_addrs, (caddr_t)cmd->ie_mcast_addrs,
1994: sc->mcast_count * sizeof *sc->mcast_addrs);
1995:
1996: cmd->ie_mcast_bytes = sc->mcast_count * ETHER_ADDR_LEN; /* grrr... */
1997:
1998: sc->scb->ie_command_list = MK_16(MEM, cmd);
1999: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
2000: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2001: printf("%s: multicast address setup command failed\n",
2002: sc->sc_dev.dv_xname);
2003: return 0;
2004: }
2005: return 1;
2006: }
2007:
2008: /*
2009: * This routine takes the environment generated by check_ie_present() and adds
2010: * to it all the other structures we need to operate the adapter. This
2011: * includes executing the CONFIGURE, IA-SETUP, and MC-SETUP commands, starting
2012: * the receiver unit, and clearing interrupts.
2013: *
2014: * THIS ROUTINE MUST BE CALLED AT splnet() OR HIGHER.
2015: */
2016: int
2017: ieinit(sc)
2018: struct ie_softc *sc;
2019: {
2020: volatile struct ie_sys_ctl_block *scb = sc->scb;
2021: void *ptr;
2022:
2023: ptr = (void *)ALIGN(scb + 1);
2024:
2025: /*
2026: * Send the configure command first.
2027: */
2028: {
2029: volatile struct ie_config_cmd *cmd = ptr;
2030:
2031: scb->ie_command_list = MK_16(MEM, cmd);
2032: cmd->com.ie_cmd_status = 0;
2033: cmd->com.ie_cmd_cmd = IE_CMD_CONFIG | IE_CMD_LAST;
2034: cmd->com.ie_cmd_link = 0xffff;
2035:
2036: ie_setup_config(cmd, sc->promisc != 0,
2037: sc->hard_type == IE_STARLAN10);
2038:
2039: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
2040: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2041: printf("%s: configure command failed\n",
2042: sc->sc_dev.dv_xname);
2043: return 0;
2044: }
2045: }
2046:
2047: /*
2048: * Now send the Individual Address Setup command.
2049: */
2050: {
2051: volatile struct ie_iasetup_cmd *cmd = ptr;
2052:
2053: scb->ie_command_list = MK_16(MEM, cmd);
2054: cmd->com.ie_cmd_status = 0;
2055: cmd->com.ie_cmd_cmd = IE_CMD_IASETUP | IE_CMD_LAST;
2056: cmd->com.ie_cmd_link = 0xffff;
2057:
2058: bcopy(sc->sc_arpcom.ac_enaddr, (caddr_t)&cmd->ie_address,
2059: sizeof cmd->ie_address);
2060:
2061: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
2062: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2063: printf("%s: individual address setup command failed\n",
2064: sc->sc_dev.dv_xname);
2065: return 0;
2066: }
2067: }
2068:
2069: /*
2070: * Now run the time-domain reflectometer.
2071: */
2072: run_tdr(sc, ptr);
2073:
2074: /*
2075: * Acknowledge any interrupts we have generated thus far.
2076: */
2077: ie_ack(sc, IE_ST_WHENCE);
2078:
2079: /*
2080: * Set up the RFA.
2081: */
2082: iememinit(ptr, sc);
2083:
2084: sc->sc_arpcom.ac_if.if_flags |= IFF_RUNNING;
2085: sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
2086:
2087: sc->scb->ie_recv_list = MK_16(MEM, sc->rframes[0]);
2088: command_and_wait(sc, IE_RU_START, 0, 0);
2089:
2090: ie_ack(sc, IE_ST_WHENCE);
2091:
2092: /* take the ee16 out of loopback */
2093: {
2094: u_char bart_config;
2095:
2096: if(sc->hard_type == IE_EE16) {
2097: bart_config = inb(PORT + IEE16_CONFIG);
2098: bart_config &= ~IEE16_BART_LOOPBACK;
2099: bart_config |= IEE16_BART_MCS16_TEST; /* inb doesn't get bit! */
2100: outb(PORT + IEE16_CONFIG, bart_config);
2101: ee16_interrupt_enable(sc);
2102: ee16_chan_attn(sc);
2103: }
2104: }
2105: return 0;
2106: }
2107:
2108: void
2109: iestop(sc)
2110: struct ie_softc *sc;
2111: {
2112:
2113: command_and_wait(sc, IE_RU_DISABLE, 0, 0);
2114: }
2115:
2116: int
2117: ieioctl(ifp, cmd, data)
2118: register struct ifnet *ifp;
2119: u_long cmd;
2120: caddr_t data;
2121: {
2122: struct ie_softc *sc = ifp->if_softc;
2123: struct ifaddr *ifa = (struct ifaddr *)data;
2124: struct ifreq *ifr = (struct ifreq *)data;
2125: int s, error = 0;
2126:
2127: s = splnet();
2128:
2129: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
2130: splx(s);
2131: return error;
2132: }
2133:
2134: switch (cmd) {
2135:
2136: case SIOCSIFADDR:
2137: ifp->if_flags |= IFF_UP;
2138:
2139: switch (ifa->ifa_addr->sa_family) {
2140: #ifdef INET
2141: case AF_INET:
2142: ieinit(sc);
2143: arp_ifinit(&sc->sc_arpcom, ifa);
2144: break;
2145: #endif
2146: default:
2147: ieinit(sc);
2148: break;
2149: }
2150: break;
2151:
2152: case SIOCSIFFLAGS:
2153: sc->promisc = ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
2154: if ((ifp->if_flags & IFF_UP) == 0 &&
2155: (ifp->if_flags & IFF_RUNNING) != 0) {
2156: /*
2157: * If interface is marked down and it is running, then
2158: * stop it.
2159: */
2160: iestop(sc);
2161: ifp->if_flags &= ~IFF_RUNNING;
2162: } else if ((ifp->if_flags & IFF_UP) != 0 &&
2163: (ifp->if_flags & IFF_RUNNING) == 0) {
2164: /*
2165: * If interface is marked up and it is stopped, then
2166: * start it.
2167: */
2168: ieinit(sc);
2169: } else {
2170: /*
2171: * Reset the interface to pick up changes in any other
2172: * flags that affect hardware registers.
2173: */
2174: iestop(sc);
2175: ieinit(sc);
2176: }
2177: #ifdef IEDEBUG
2178: if (ifp->if_flags & IFF_DEBUG)
2179: sc->sc_debug = IED_ALL;
2180: else
2181: sc->sc_debug = 0;
2182: #endif
2183: break;
2184:
2185: case SIOCADDMULTI:
2186: case SIOCDELMULTI:
2187: error = (cmd == SIOCADDMULTI) ?
2188: ether_addmulti(ifr, &sc->sc_arpcom):
2189: ether_delmulti(ifr, &sc->sc_arpcom);
2190:
2191: if (error == ENETRESET) {
2192: /*
2193: * Multicast list has changed; set the hardware filter
2194: * accordingly.
2195: */
2196: if (ifp->if_flags & IFF_RUNNING)
2197: mc_reset(sc);
2198: error = 0;
2199: }
2200: break;
2201:
2202: default:
2203: error = EINVAL;
2204: }
2205: splx(s);
2206: return error;
2207: }
2208:
2209: static void
2210: mc_reset(sc)
2211: struct ie_softc *sc;
2212: {
2213: struct ether_multi *enm;
2214: struct ether_multistep step;
2215:
2216: /*
2217: * Step through the list of addresses.
2218: */
2219: sc->mcast_count = 0;
2220: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
2221: while (enm) {
2222: if (sc->mcast_count >= MAXMCAST ||
2223: bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
2224: sc->sc_arpcom.ac_if.if_flags |= IFF_ALLMULTI;
2225: ieioctl(&sc->sc_arpcom.ac_if, SIOCSIFFLAGS, (void *)0);
2226: goto setflag;
2227: }
2228:
2229: bcopy(enm->enm_addrlo, &sc->mcast_addrs[sc->mcast_count], 6);
2230: sc->mcast_count++;
2231: ETHER_NEXT_MULTI(step, enm);
2232: }
2233: setflag:
2234: sc->want_mcsetup = 1;
2235: }
2236:
2237: #ifdef IEDEBUG
2238: void
2239: print_rbd(rbd)
2240: volatile struct ie_recv_buf_desc *rbd;
2241: {
2242:
2243: printf("RBD at %08lx:\nactual %04x, next %04x, buffer %08x\n"
2244: "length %04x, mbz %04x\n", (u_long)rbd, rbd->ie_rbd_actual,
2245: rbd->ie_rbd_next, rbd->ie_rbd_buffer, rbd->ie_rbd_length,
2246: rbd->mbz);
2247: }
2248: #endif
2249:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_ie.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa