2 * Copyright (c) 1992, 1993, University of Vermont and State
3 * Agricultural College.
4 * Copyright (c) 1992, 1993, Garrett A. Wollman.
7 * Copyright (c) 1990, 1991, William F. Jolitz
8 * Copyright (c) 1990, The Regents of the University of California
11 * Copyright (c) 1993, 1994, Charles M. Hannum
13 * EtherExpress 16 support:
14 * Copyright (c) 1993, 1994, 1995, Rodney W. Grimes
15 * Copyright (c) 1997, Aaron C. Smith
17 * All rights reserved.
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
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.
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
54 * Intel 82586 Ethernet chip
55 * Register, bit, and structure definitions.
57 * Written by GAW with reference to the Clarkson Packet Driver code for this
58 * chip written by Russ Nelson and others.
60 * Intel EtherExpress 16 support from if_ix.c, written by Rodney W. Grimes.
64 * The i82586 is a very versatile chip, found in many implementations.
65 * Programming this chip is mostly the same, but certain details differ
66 * from card to card. This driver is written so that different cards
67 * can be automatically detected at run-time.
73 We run the 82586 in a standard Ethernet mode. We keep NFRAMES received
74 frame descriptors around for the receiver to use, and NRXBUFS associated
75 receive buffer descriptors, both in a circular list. Whenever a frame is
76 received, we rotate both lists as necessary. (The 586 treats both lists
77 as a simple queue.) We also keep a transmit command around so that packets
78 can be sent off quickly.
80 We configure the adapter in AL-LOC = 1 mode, which means that the
81 Ethernet/802.3 MAC header is placed at the beginning of the receive buffer
82 rather than being split off into various fields in the RFD. This also
83 means that we must include this header in the transmit buffer as well.
85 By convention, all transmit commands, and only transmit commands, shall
86 have the I (IE_CMD_INTR) bit set in the command. This way, when an
87 interrupt arrives at ieintr(), it is immediately possible to tell
88 what precisely caused it. ANY OTHER command-sending routines should
89 run at splimp(), and should post an acknowledgement to every interrupt
92 The 82586 has a 24-bit address space internally, and the adaptor's memory
93 is located at the top of this region. However, the value we are given in
94 configuration is normally the *bottom* of the adaptor RAM. So, we must go
95 through a few gyrations to come up with a kernel virtual address which
96 represents the actual beginning of the 586 address space. First, we
97 autosize the RAM by running through several possible sizes and trying to
98 initialize the adapter under the assumption that the selected size is
99 correct. Then, knowing the correct RAM size, we set up our pointers in
100 ie_softc[unit]. `iomem' represents the computed base of the 586 address
101 space. `iomembot' represents the actual configured base of adapter RAM.
102 Finally, `iosize' represents the calculated size of 586 RAM. Then, when
103 laying out commands, we use the interval [iomembot, iomembot + iosize); to
104 make 24-pointers, we subtract iomem, and to make 16-pointers, we subtract
105 iomem and and with 0xffff.
111 #include "opt_inet.h"
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/conf.h>
120 #include <sys/mbuf.h>
121 #include <sys/socket.h>
122 #include <sys/sockio.h>
123 #include <sys/syslog.h>
125 #include <net/ethernet.h>
127 #include <net/if_types.h>
128 #include <net/if_dl.h>
130 #include <netinet/in.h>
131 #include <netinet/if_ether.h>
133 #include <machine/clock.h>
134 #include <machine/md_var.h>
136 #include <i386/isa/isa_device.h>
137 #include <i386/isa/ic/i82586.h>
138 #include <i386/isa/icu.h>
139 #include <i386/isa/if_iereg.h>
140 #include <i386/isa/if_ie507.h>
141 #include <i386/isa/if_iee16.h>
142 #include <i386/isa/elink.h>
147 #define IED_RINT 0x01
148 #define IED_TINT 0x02
151 #define IED_READFRAME 0x10
152 static int ie_debug = IED_RNR;
156 #define IE_BUF_LEN ETHER_MAX_LEN /* length of transmit buffer */
158 /* Forward declaration */
161 static struct mbuf *last_not_for_us;
163 static int ieprobe(struct isa_device * dvp);
164 static int ieattach(struct isa_device * dvp);
165 static ointhand2_t ieintr;
166 static int sl_probe(struct isa_device * dvp);
167 static int el_probe(struct isa_device * dvp);
168 static int ni_probe(struct isa_device * dvp);
169 static int ee16_probe(struct isa_device * dvp);
171 static int check_ie_present(int unit, caddr_t where, unsigned size);
172 static void ieinit(void *);
173 static void ie_stop(int unit);
174 static int ieioctl(struct ifnet * ifp, u_long command, caddr_t data);
175 static void iestart(struct ifnet * ifp);
177 static void el_reset_586(int unit);
178 static void el_chan_attn(int unit);
180 static void sl_reset_586(int unit);
181 static void sl_chan_attn(int unit);
183 static void ee16_reset_586(int unit);
184 static void ee16_chan_attn(int unit);
185 static __inline void ee16_interrupt_enable(struct ie_softc * ie);
186 static void ee16_eeprom_outbits(struct ie_softc * ie, int edata, int cnt);
187 static void ee16_eeprom_clock(struct ie_softc * ie, int state);
188 static u_short ee16_read_eeprom(struct ie_softc * ie, int location);
189 static int ee16_eeprom_inbits(struct ie_softc * ie);
190 static void ee16_shutdown(void *sc, int howto);
192 static void iereset(int unit);
193 static void ie_readframe(int unit, struct ie_softc * ie, int bufno);
194 static void ie_drop_packet_buffer(int unit, struct ie_softc * ie);
195 static void sl_read_ether(int unit, unsigned char addr[6]);
196 static void find_ie_mem_size(int unit);
197 static void chan_attn_timeout(void *rock);
198 static int command_and_wait(int unit, int command,
199 void volatile * pcmd, int);
200 static void run_tdr(int unit, volatile struct ie_tdr_cmd * cmd);
201 static int ierint(int unit, struct ie_softc * ie);
202 static int ietint(int unit, struct ie_softc * ie);
203 static int iernr(int unit, struct ie_softc * ie);
204 static void start_receiver(int unit);
205 static __inline int ieget(int, struct ie_softc *, struct mbuf **,
206 struct ether_header *, int *);
207 static v_caddr_t setup_rfa(v_caddr_t ptr, struct ie_softc * ie);
208 static int mc_setup(int, v_caddr_t, volatile struct ie_sys_ctl_block *);
209 static void ie_mc_reset(int unit);
212 static void print_rbd(volatile struct ie_recv_buf_desc * rbd);
214 static int in_ierint = 0;
215 static int in_ietint = 0;
220 * This tells the autoconf code how to set us up.
222 struct isa_driver iedriver = {
223 ieprobe, ieattach, "ie",
236 static const char *ie_hardware_names[] = {
247 sizeof(iscp) == 1+1+2+4 == 8
248 sizeof(scb) == 2+2+2+2+2+2+2+2 == 16
249 NFRAMES * sizeof(rfd) == NFRAMES*(2+2+2+2+6+6+2+2) == NFRAMES*24 == 384
250 sizeof(xmit_cmd) == 2+2+2+2+6+2 == 18
251 sizeof(transmit buffer) == 1512
252 sizeof(transmit buffer desc) == 8
256 NRXBUFS * sizeof(rbd) == NRXBUFS*(2+2+4+2+2) == NRXBUFS*12
257 NRXBUFS * IE_RBUF_SIZE == NRXBUFS*256
259 NRXBUFS should be (16384 - 1946) / (256 + 12) == 14438 / 268 == 53
261 With NRXBUFS == 48, this leaves us 1574 bytes for another command or
262 more buffers. Another transmit command would be 18+8+1512 == 1538
265 Obviously all these would have to be reduced for smaller memory sizes.
266 With a larger memory, it would be possible to roughly double the number of
267 both transmit and receive buffers.
270 #define NFRAMES 8 /* number of receive frames */
271 #define NRXBUFS 48 /* number of buffers to allocate */
272 #define IE_RBUF_SIZE 256 /* size of each buffer, MUST BE POWER OF TWO */
273 #define NTXBUFS 2 /* number of transmit commands */
274 #define IE_TBUF_SIZE ETHER_MAX_LEN /* size of transmit buffer */
277 * Ethernet status, per interface.
279 static struct ie_softc {
280 struct arpcom arpcom;
281 void (*ie_reset_586) (int);
282 void (*ie_chan_attn) (int);
283 enum ie_hardware hard_type;
287 u_short port; /* i/o base address for this interface */
288 caddr_t iomem; /* memory size */
289 caddr_t iomembot; /* memory base address */
291 int bus_use; /* 0 means 16bit, 1 means 8 bit adapter */
298 volatile struct ie_int_sys_conf_ptr *iscp;
299 volatile struct ie_sys_ctl_block *scb;
300 volatile struct ie_recv_frame_desc **rframes; /* nframes worth */
301 volatile struct ie_recv_buf_desc **rbuffs; /* nrxbufs worth */
302 volatile u_char **cbuffs; /* nrxbufs worth */
303 int rfhead, rftail, rbhead, rbtail;
305 volatile struct ie_xmit_cmd **xmit_cmds; /* ntxbufs worth */
306 volatile struct ie_xmit_buf **xmit_buffs; /* ntxbufs worth */
307 volatile u_char **xmit_cbuffs; /* ntxbufs worth */
310 struct ie_en_addr mcast_addrs[MAXMCAST + 1];
313 u_short irq_encoded; /* encoded interrupt on IEE16 */
316 #define MK_24(base, ptr) ((caddr_t)((uintptr_t)ptr - (uintptr_t)base))
317 #define MK_16(base, ptr) ((u_short)(uintptr_t)MK_24(base, ptr))
319 #define PORT ie_softc[unit].port
320 #define MEM ie_softc[unit].iomem
323 ieprobe(struct isa_device *dvp)
333 ret = ee16_probe(dvp);
339 sl_probe(struct isa_device *dvp)
341 int unit = dvp->id_unit;
344 ie_softc[unit].port = dvp->id_iobase;
345 ie_softc[unit].iomembot = dvp->id_maddr;
346 ie_softc[unit].iomem = 0;
347 ie_softc[unit].bus_use = 0;
349 c = inb(PORT + IEATT_REVISION);
350 switch (SL_BOARD(c)) {
352 ie_softc[unit].hard_type = IE_STARLAN10;
353 ie_softc[unit].ie_reset_586 = sl_reset_586;
354 ie_softc[unit].ie_chan_attn = sl_chan_attn;
357 ie_softc[unit].hard_type = IE_EN100;
358 ie_softc[unit].ie_reset_586 = sl_reset_586;
359 ie_softc[unit].ie_chan_attn = sl_chan_attn;
362 ie_softc[unit].hard_type = IE_SLFIBER;
363 ie_softc[unit].ie_reset_586 = sl_reset_586;
364 ie_softc[unit].ie_chan_attn = sl_chan_attn;
368 * Anything else is not recognized or cannot be used.
374 ie_softc[unit].hard_vers = SL_REV(c);
377 * Divine memory size on-board the card. Ususally 16k.
379 find_ie_mem_size(unit);
381 if (!ie_softc[unit].iosize) {
384 dvp->id_msize = ie_softc[unit].iosize;
386 switch (ie_softc[unit].hard_type) {
390 sl_read_ether(unit, ie_softc[unit].arpcom.ac_enaddr);
395 printf("ie%d: unknown AT&T board type code %d\n", unit,
396 ie_softc[unit].hard_type);
405 el_probe(struct isa_device *dvp)
407 struct ie_softc *sc = &ie_softc[dvp->id_unit];
410 u_char signature[] = "*3COM*";
411 int unit = dvp->id_unit;
414 sc->port = dvp->id_iobase;
415 sc->iomembot = dvp->id_maddr;
418 /* Need this for part of the probe. */
419 sc->ie_reset_586 = el_reset_586;
420 sc->ie_chan_attn = el_chan_attn;
422 /* Reset and put card in CONFIG state without changing address. */
424 outb(ELINK_ID_PORT, 0x00);
425 elink_idseq(ELINK_507_POLY);
426 elink_idseq(ELINK_507_POLY);
427 outb(ELINK_ID_PORT, 0xff);
429 c = inb(PORT + IE507_MADDR);
432 printf("ie%d: can't map 3C507 RAM in high memory\n", unit);
436 /* go to RUN state */
437 outb(ELINK_ID_PORT, 0x00);
438 elink_idseq(ELINK_507_POLY);
439 outb(ELINK_ID_PORT, 0x00);
441 outb(PORT + IE507_CTRL, EL_CTRL_NRST);
443 for (i = 0; i < 6; i++)
444 if (inb(PORT + i) != signature[i])
447 c = inb(PORT + IE507_IRQ) & 0x0f;
449 if (dvp->id_irq != (1 << c)) {
450 printf("ie%d: kernel configured irq %d "
451 "doesn't match board configured irq %d\n",
452 unit, ffs(dvp->id_irq) - 1, c);
455 c = (inb(PORT + IE507_MADDR) & 0x1c) + 0xc0;
457 if (kvtop(dvp->id_maddr) != ((int) c << 12)) {
458 printf("ie%d: kernel configured maddr %lx "
459 "doesn't match board configured maddr %x\n",
460 unit, kvtop(dvp->id_maddr), (int) c << 12);
463 outb(PORT + IE507_CTRL, EL_CTRL_NORMAL);
465 sc->hard_type = IE_3C507;
466 sc->hard_vers = 0; /* 3C507 has no version number. */
469 * Divine memory size on-board the card.
471 find_ie_mem_size(unit);
474 printf("ie%d: can't find shared memory\n", unit);
475 outb(PORT + IE507_CTRL, EL_CTRL_NRST);
479 dvp->id_msize = sc->iosize;
480 else if (dvp->id_msize != sc->iosize) {
481 printf("ie%d: kernel configured msize %d "
482 "doesn't match board configured msize %d\n",
483 unit, dvp->id_msize, sc->iosize);
484 outb(PORT + IE507_CTRL, EL_CTRL_NRST);
487 sl_read_ether(unit, ie_softc[unit].arpcom.ac_enaddr);
489 /* Clear the interrupt latch just in case. */
490 outb(PORT + IE507_ICTRL, 1);
497 ni_probe(struct isa_device *dvp)
499 int unit = dvp->id_unit;
502 ie_softc[unit].port = dvp->id_iobase;
503 ie_softc[unit].iomembot = dvp->id_maddr;
504 ie_softc[unit].iomem = 0;
505 ie_softc[unit].bus_use = 1;
507 boardtype = inb(PORT + IEATT_REVISION);
508 c = inb(PORT + IEATT_REVISION + 1);
509 boardtype = boardtype + (c << 8);
511 case 0x5500: /* This is the magic cookie for the NI5210 */
512 ie_softc[unit].hard_type = IE_NI5210;
513 ie_softc[unit].ie_reset_586 = sl_reset_586;
514 ie_softc[unit].ie_chan_attn = sl_chan_attn;
518 * Anything else is not recognized or cannot be used.
524 ie_softc[unit].hard_vers = 0;
527 * Divine memory size on-board the card. Either 8 or 16k.
529 find_ie_mem_size(unit);
531 if (!ie_softc[unit].iosize) {
535 dvp->id_msize = ie_softc[unit].iosize;
536 else if (dvp->id_msize != ie_softc[unit].iosize) {
537 printf("ie%d: kernel configured msize %d "
538 "doesn't match board configured msize %d\n",
539 unit, dvp->id_msize, ie_softc[unit].iosize);
542 sl_read_ether(unit, ie_softc[unit].arpcom.ac_enaddr);
550 ee16_shutdown(void *sc, int howto)
552 struct ie_softc *ie = (struct ie_softc *)sc;
553 int unit = ie - &ie_softc[0];
555 ee16_reset_586(unit);
556 outb(PORT + IEE16_ECTRL, IEE16_RESET_ASIC);
557 outb(PORT + IEE16_ECTRL, 0);
561 /* Taken almost exactly from Rod's if_ix.c. */
564 ee16_probe(struct isa_device *dvp)
566 struct ie_softc *sc = &ie_softc[dvp->id_unit];
569 int unit = dvp->id_unit;
570 u_short board_id, id_var1, id_var2, checksum = 0;
571 u_short eaddrtemp, irq;
572 u_short pg, adjust, decode, edecode;
576 short irq_translate[] = {0, IRQ9, IRQ3, IRQ4, IRQ5, IRQ10, IRQ11, 0};
577 char irq_encode[] = {0, 0, 0, 2, 3, 4, 0, 0, 0, 1, 5, 6, 0, 0, 0, 0};
579 /* Need this for part of the probe. */
580 sc->ie_reset_586 = ee16_reset_586;
581 sc->ie_chan_attn = ee16_chan_attn;
583 /* unsure if this is necessary */
586 /* reset any ee16 at the current iobase */
587 outb(dvp->id_iobase + IEE16_ECTRL, IEE16_RESET_ASIC);
588 outb(dvp->id_iobase + IEE16_ECTRL, 0);
591 /* now look for ee16. */
592 board_id = id_var1 = id_var2 = 0;
593 for (i = 0; i < 4; i++) {
594 id_var1 = inb(dvp->id_iobase + IEE16_ID_PORT);
595 id_var2 = ((id_var1 & 0x03) << 2);
596 board_id |= ((id_var1 >> 4) << id_var2);
599 if (board_id != IEE16_ID) {
601 printf("ie%d: unknown board_id: %x\n", unit, board_id);
604 /* need sc->port for ee16_read_eeprom */
605 sc->port = dvp->id_iobase;
606 sc->hard_type = IE_EE16;
609 * The shared RAM location on the EE16 is encoded into bits 3-7 of
610 * EEPROM location 6. We zero the upper byte, and shift the 5 bits
611 * right 3. The resulting number tells us the RAM location.
612 * Because the EE16 supports either 16k or 32k of shared RAM, we
613 * only worry about the 32k locations.
615 * NOTE: if a 64k EE16 exists, it should be added to this switch. then
616 * the ia->ia_msize would need to be set per case statement.
618 * value msize location ===== ===== ======== 0x03 0x8000
619 * 0xCC000 0x06 0x8000 0xD0000 0x0C 0x8000 0xD4000 0x18
625 i = (ee16_read_eeprom(sc, 6) & 0x00ff) >> 3;
643 dvp->id_msize = 0x8000;
644 if (kvtop(dvp->id_maddr) != bd_maddr) {
645 printf("ie%d: kernel configured maddr %lx "
646 "doesn't match board configured maddr %lx\n",
647 unit, kvtop(dvp->id_maddr), bd_maddr);
649 sc->iomembot = dvp->id_maddr;
650 sc->iomem = 0; /* XXX some probes set this and some don't */
651 sc->iosize = dvp->id_msize;
653 /* need to put the 586 in RESET while we access the eeprom. */
654 outb(PORT + IEE16_ECTRL, IEE16_RESET_586);
656 /* read the eeprom and checksum it, should == IEE16_ID */
657 for (i = 0; i < 0x40; i++)
658 checksum += ee16_read_eeprom(sc, i);
660 if (checksum != IEE16_ID) {
661 printf("ie%d: invalid eeprom checksum: %x\n", unit, checksum);
665 * Size and test the memory on the board. The size of the memory
666 * can be one of 16k, 32k, 48k or 64k. It can be located in the
667 * address range 0xC0000 to 0xEFFFF on 16k boundaries.
669 * If the size does not match the passed in memory allocation size
670 * issue a warning, but continue with the minimum of the two sizes.
673 switch (dvp->id_msize) {
675 case 32768: /* XXX Only support 32k and 64k right now */
680 printf("ie%d: mapped memory size %d not supported\n", unit,
683 break; /* NOTREACHED */
686 if ((kvtop(dvp->id_maddr) < 0xC0000) ||
687 (kvtop(dvp->id_maddr) + sc->iosize > 0xF0000)) {
688 printf("ie%d: mapped memory location %p out of range\n", unit,
689 (void *)dvp->id_maddr);
692 pg = (kvtop(dvp->id_maddr) & 0x3C000) >> 14;
693 adjust = IEE16_MCTRL_FMCS16 | (pg & 0x3) << 2;
694 decode = ((1 << (sc->iosize / 16384)) - 1) << pg;
695 edecode = ((~decode >> 4) & 0xF0) | (decode >> 8);
697 /* ZZZ This should be checked against eeprom location 6, low byte */
698 outb(PORT + IEE16_MEMDEC, decode & 0xFF);
699 /* ZZZ This should be checked against eeprom location 1, low byte */
700 outb(PORT + IEE16_MCTRL, adjust);
701 /* ZZZ Now if I could find this one I would have it made */
702 outb(PORT + IEE16_MPCTRL, (~decode & 0xFF));
703 /* ZZZ I think this is location 6, high byte */
704 outb(PORT + IEE16_MECTRL, edecode); /* XXX disable Exxx */
706 (void) kvtop(dvp->id_maddr);
709 * first prime the stupid bart DRAM controller so that it works,
710 * then zero out all of memory.
712 bzero(sc->iomembot, 32);
713 bzero(sc->iomembot, sc->iosize);
716 * Get the encoded interrupt number from the EEPROM, check it
717 * against the passed in IRQ. Issue a warning if they do not match.
718 * Always use the passed in IRQ, not the one in the EEPROM.
720 irq = ee16_read_eeprom(sc, IEE16_EEPROM_CONFIG1);
721 irq = (irq & IEE16_EEPROM_IRQ) >> IEE16_EEPROM_IRQ_SHIFT;
722 irq = irq_translate[irq];
723 if (dvp->id_irq > 0) {
724 if (irq != dvp->id_irq) {
725 printf("ie%d: WARNING: board configured "
726 "at irq %u, using %u\n",
727 dvp->id_unit, dvp->id_irq, irq);
733 sc->irq_encoded = irq_encode[ffs(irq) - 1];
736 * Get the hardware ethernet address from the EEPROM and save it in
737 * the softc for use by the 586 setup code.
739 eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_HIGH);
740 sc->arpcom.ac_enaddr[1] = eaddrtemp & 0xFF;
741 sc->arpcom.ac_enaddr[0] = eaddrtemp >> 8;
742 eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_MID);
743 sc->arpcom.ac_enaddr[3] = eaddrtemp & 0xFF;
744 sc->arpcom.ac_enaddr[2] = eaddrtemp >> 8;
745 eaddrtemp = ee16_read_eeprom(sc, IEE16_EEPROM_ENET_LOW);
746 sc->arpcom.ac_enaddr[5] = eaddrtemp & 0xFF;
747 sc->arpcom.ac_enaddr[4] = eaddrtemp >> 8;
749 /* disable the board interrupts */
750 outb(PORT + IEE16_IRQ, sc->irq_encoded);
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);
760 /* take the board out of reset state */
761 outb(PORT + IEE16_ECTRL, 0);
764 if (!check_ie_present(unit, dvp->id_maddr, sc->iosize))
767 return (16); /* return the number of I/O ports */
771 * Taken almost exactly from Bill's if_is.c, then modified beyond recognition.
774 ieattach(struct isa_device *dvp)
777 int unit = dvp->id_unit;
778 struct ie_softc *ie = &ie_softc[unit];
779 struct ifnet *ifp = &ie->arpcom.ac_if;
782 dvp->id_ointr = ieintr;
785 * based on the amount of memory we have, allocate our tx and rx
788 factor = dvp->id_msize / 16384;
789 ie->nframes = factor * NFRAMES;
790 ie->nrxbufs = factor * NRXBUFS;
791 ie->ntxbufs = factor * NTXBUFS;
794 * Since all of these guys are arrays of pointers, allocate as one
795 * big chunk and dole out accordingly.
797 allocsize = sizeof(void *) * (ie->nframes
799 + (ie->ntxbufs * 3));
800 ie->rframes = (volatile struct ie_recv_frame_desc **) malloc(allocsize,
803 if (ie->rframes == NULL)
806 (volatile struct ie_recv_buf_desc **)&ie->rframes[ie->nframes];
807 ie->cbuffs = (volatile u_char **)&ie->rbuffs[ie->nrxbufs];
809 (volatile struct ie_xmit_cmd **)&ie->cbuffs[ie->nrxbufs];
811 (volatile struct ie_xmit_buf **)&ie->xmit_cmds[ie->ntxbufs];
812 ie->xmit_cbuffs = (volatile u_char **)&ie->xmit_buffs[ie->ntxbufs];
816 ifp->if_name = iedriver.name;
817 ifp->if_mtu = ETHERMTU;
818 printf("ie%d: <%s R%d> address %6D\n", unit,
819 ie_hardware_names[ie->hard_type],
821 ie->arpcom.ac_enaddr, ":");
823 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
824 ifp->if_output = ether_output;
825 ifp->if_start = iestart;
826 ifp->if_ioctl = ieioctl;
827 ifp->if_init = ieinit;
828 ifp->if_type = IFT_ETHER;
832 if (ie->hard_type == IE_EE16)
833 EVENTHANDLER_REGISTER(shutdown_post_sync, ee16_shutdown,
834 ie, SHUTDOWN_PRI_DEFAULT);
836 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
844 * What to do upon receipt of an interrupt.
849 register struct ie_softc *ie = &ie_softc[unit];
850 register u_short status;
852 /* Clear the interrupt latch on the 3C507. */
853 if (ie->hard_type == IE_3C507
854 && (inb(PORT + IE507_CTRL) & EL_CTRL_INTL))
855 outb(PORT + IE507_ICTRL, 1);
857 /* disable interrupts on the EE16. */
858 if (ie->hard_type == IE_EE16)
859 outb(PORT + IEE16_IRQ, ie->irq_encoded);
861 status = ie->scb->ie_status;
865 /* Don't ack interrupts which we didn't receive */
866 ie_ack(ie->scb, IE_ST_WHENCE & status, unit, ie->ie_chan_attn);
868 if (status & (IE_ST_RECV | IE_ST_RNR)) {
871 if (ie_debug & IED_RINT)
872 printf("ie%d: rint\n", unit);
879 if (status & IE_ST_DONE) {
882 if (ie_debug & IED_TINT)
883 printf("ie%d: tint\n", unit);
890 if (status & IE_ST_RNR) {
892 if (ie_debug & IED_RNR)
893 printf("ie%d: rnr\n", unit);
898 if ((status & IE_ST_ALLDONE)
899 && (ie_debug & IED_CNA))
900 printf("ie%d: cna\n", unit);
903 if ((status = ie->scb->ie_status) & IE_ST_WHENCE)
906 /* Clear the interrupt latch on the 3C507. */
907 if (ie->hard_type == IE_3C507)
908 outb(PORT + IE507_ICTRL, 1);
910 /* enable interrupts on the EE16. */
911 if (ie->hard_type == IE_EE16)
912 outb(PORT + IEE16_IRQ, ie->irq_encoded | IEE16_IRQ_ENABLE);
917 * Process a received-frame interrupt.
920 ierint(int unit, struct ie_softc *ie)
923 static int timesthru = 1024;
927 status = ie->rframes[i]->ie_fd_status;
929 if ((status & IE_FD_COMPLETE) && (status & IE_FD_OK)) {
930 ie->arpcom.ac_if.if_ipackets++;
932 ie->arpcom.ac_if.if_ierrors +=
933 ie->scb->ie_err_crc +
934 ie->scb->ie_err_align +
935 ie->scb->ie_err_resource +
936 ie->scb->ie_err_overrun;
937 ie->scb->ie_err_crc = 0;
938 ie->scb->ie_err_align = 0;
939 ie->scb->ie_err_resource = 0;
940 ie->scb->ie_err_overrun = 0;
943 ie_readframe(unit, ie, i);
945 if (status & IE_FD_RNR) {
946 if (!(ie->scb->ie_status & IE_RU_READY)) {
947 ie->rframes[0]->ie_fd_next =
948 MK_16(MEM, ie->rbuffs[0]);
949 ie->scb->ie_recv_list =
950 MK_16(MEM, ie->rframes[0]);
951 command_and_wait(unit, IE_RU_START,
957 i = (i + 1) % ie->nframes;
963 * Process a command-complete interrupt. These are only generated by
964 * the transmission of frames. This routine is deceptively simple, since
965 * most of the real work is done by iestart().
968 ietint(int unit, struct ie_softc *ie)
973 ie->arpcom.ac_if.if_timer = 0;
974 ie->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
976 for (i = 0; i < ie->xmit_count; i++) {
977 status = ie->xmit_cmds[i]->ie_xmit_status;
979 if (status & IE_XS_LATECOLL) {
980 printf("ie%d: late collision\n", unit);
981 ie->arpcom.ac_if.if_collisions++;
982 ie->arpcom.ac_if.if_oerrors++;
983 } else if (status & IE_XS_NOCARRIER) {
984 printf("ie%d: no carrier\n", unit);
985 ie->arpcom.ac_if.if_oerrors++;
986 } else if (status & IE_XS_LOSTCTS) {
987 printf("ie%d: lost CTS\n", unit);
988 ie->arpcom.ac_if.if_oerrors++;
989 } else if (status & IE_XS_UNDERRUN) {
990 printf("ie%d: DMA underrun\n", unit);
991 ie->arpcom.ac_if.if_oerrors++;
992 } else if (status & IE_XS_EXCMAX) {
993 printf("ie%d: too many collisions\n", unit);
994 ie->arpcom.ac_if.if_collisions += 16;
995 ie->arpcom.ac_if.if_oerrors++;
997 ie->arpcom.ac_if.if_opackets++;
998 ie->arpcom.ac_if.if_collisions += status & IE_XS_MAXCOLL;
1004 * If multicast addresses were added or deleted while we were
1005 * transmitting, ie_mc_reset() set the want_mcsetup flag indicating
1006 * that we should do it.
1008 if (ie->want_mcsetup) {
1009 mc_setup(unit, (v_caddr_t) ie->xmit_cbuffs[0], ie->scb);
1010 ie->want_mcsetup = 0;
1012 /* Wish I knew why this seems to be necessary... */
1013 ie->xmit_cmds[0]->ie_xmit_status |= IE_STAT_COMPL;
1015 iestart(&ie->arpcom.ac_if);
1016 return (0); /* shouldn't be necessary */
1020 * Process a receiver-not-ready interrupt. I believe that we get these
1021 * when there aren't enough buffers to go around. For now (FIXME), we
1022 * just restart the receiver, and hope everything's ok.
1025 iernr(int unit, struct ie_softc *ie)
1028 setup_rfa((v_caddr_t) ie->rframes[0], ie);
1030 ie->scb->ie_recv_list = MK_16(MEM, ie_softc[unit].rframes[0]);
1031 command_and_wait(unit, IE_RU_START, 0, 0);
1033 /* This doesn't work either, but it doesn't hang either. */
1034 command_and_wait(unit, IE_RU_DISABLE, 0, 0); /* just in case */
1035 setup_rfa((v_caddr_t) ie->rframes[0], ie); /* ignore cast-qual */
1037 ie->scb->ie_recv_list = MK_16(MEM, ie_softc[unit].rframes[0]);
1038 command_and_wait(unit, IE_RU_START, 0, 0); /* was ENABLE */
1041 ie_ack(ie->scb, IE_ST_WHENCE, unit, ie->ie_chan_attn);
1043 ie->arpcom.ac_if.if_ierrors++;
1048 * Compare two Ether/802 addresses for equality, inlined and
1049 * unrolled for speed. I'd love to have an inline assembler
1050 * version of this...
1053 ether_equal(u_char * one, u_char * two)
1055 if (one[0] != two[0])
1057 if (one[1] != two[1])
1059 if (one[2] != two[2])
1061 if (one[3] != two[3])
1063 if (one[4] != two[4])
1065 if (one[5] != two[5])
1071 * Check for a valid address. to_bpf is filled in with one of the following:
1072 * 0 -> BPF doesn't get this packet
1073 * 1 -> BPF does get this packet
1074 * 2 -> BPF does get this packet, but we don't
1075 * Return value is true if the packet is for us, and false otherwise.
1077 * This routine is a mess, but it's also critical that it be as fast
1078 * as possible. It could be made cleaner if we can assume that the
1079 * only client which will fiddle with IFF_PROMISC is BPF. This is
1080 * probably a good assumption, but we do not make it here. (Yet.)
1083 check_eh(struct ie_softc * ie, struct ether_header * eh, int *to_bpf)
1087 switch (ie->promisc) {
1090 * Receiving all multicasts, but no unicasts except those
1093 /* BPF gets this packet if anybody cares */
1094 *to_bpf = (ie->arpcom.ac_if.if_bpf != 0);
1095 if (eh->ether_dhost[0] & 1) {
1098 if (ether_equal(eh->ether_dhost, ie->arpcom.ac_enaddr))
1104 * Receiving all packets. These need to be passed on to
1107 *to_bpf = (ie->arpcom.ac_if.if_bpf != 0);
1108 /* If for us, accept and hand up to BPF */
1109 if (ether_equal(eh->ether_dhost, ie->arpcom.ac_enaddr))
1113 *to_bpf = 2; /* we don't need to see it */
1116 * Not a multicast, so BPF wants to see it but we don't.
1118 if (!(eh->ether_dhost[0] & 1))
1122 * If it's one of our multicast groups, accept it and pass
1125 for (i = 0; i < ie->mcast_count; i++) {
1126 if (ether_equal(eh->ether_dhost,
1127 (u_char *)&ie->mcast_addrs[i])) {
1135 case IFF_ALLMULTI | IFF_PROMISC:
1137 * Acting as a multicast router, and BPF running at the same
1138 * time. Whew! (Hope this is a fast machine...)
1140 *to_bpf = (ie->arpcom.ac_if.if_bpf != 0);
1141 /* We want to see multicasts. */
1142 if (eh->ether_dhost[0] & 1)
1145 /* We want to see our own packets */
1146 if (ether_equal(eh->ether_dhost, ie->arpcom.ac_enaddr))
1149 /* Anything else goes to BPF but nothing else. */
1156 * Only accept unicast packets destined for us, or
1157 * multicasts for groups that we belong to. For now, we
1158 * assume that the '586 will only return packets that we
1159 * asked it for. This isn't strictly true (it uses hashing
1160 * for the multicast filter), but it will do in this case,
1161 * and we want to get out of here as quickly as possible.
1163 *to_bpf = (ie->arpcom.ac_if.if_bpf != 0);
1170 * We want to isolate the bits that have meaning... This assumes that
1171 * IE_RBUF_SIZE is an even power of two. If somehow the act_len exceeds
1172 * the size of the buffer, then we are screwed anyway.
1175 ie_buflen(struct ie_softc * ie, int head)
1177 return (ie->rbuffs[head]->ie_rbd_actual
1178 & (IE_RBUF_SIZE | (IE_RBUF_SIZE - 1)));
1182 ie_packet_len(int unit, struct ie_softc * ie)
1185 int head = ie->rbhead;
1189 if (!(ie->rbuffs[ie->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
1191 print_rbd(ie->rbuffs[ie->rbhead]);
1194 "ie%d: receive descriptors out of sync at %d\n",
1199 i = ie->rbuffs[head]->ie_rbd_actual & IE_RBD_LAST;
1201 acc += ie_buflen(ie, head);
1202 head = (head + 1) % ie->nrxbufs;
1209 * Read data off the interface, and turn it into an mbuf chain.
1211 * This code is DRAMATICALLY different from the previous version; this
1212 * version tries to allocate the entire mbuf chain up front, given the
1213 * length of the data available. This enables us to allocate mbuf
1214 * clusters in many situations where before we would have had a long
1215 * chain of partially-full mbufs. This should help to speed up the
1216 * operation considerably. (Provided that it works, of course.)
1219 ieget(int unit, struct ie_softc *ie, struct mbuf **mp,
1220 struct ether_header *ehp, int *to_bpf)
1222 struct mbuf *m, *top, **mymp;
1229 totlen = ie_packet_len(unit, ie);
1236 * Snarf the Ethernet header.
1238 bcopy((v_caddr_t) ie->cbuffs[i], (caddr_t) ehp, sizeof *ehp);
1239 /* ignore cast-qual warning here */
1242 * As quickly as possible, check if this packet is for us. If not,
1243 * don't waste a single cycle copying the rest of the packet in.
1244 * This is only a consideration when FILTER is defined; i.e., when
1245 * we are either running BPF or doing multicasting.
1247 if (!check_eh(ie, ehp, to_bpf)) {
1248 ie_drop_packet_buffer(unit, ie);
1249 ie->arpcom.ac_if.if_ierrors--; /* just this case, it's not an
1254 totlen -= (offset = sizeof *ehp);
1256 MGETHDR(*mp, M_DONTWAIT, MT_DATA);
1258 ie_drop_packet_buffer(unit, ie);
1262 m->m_pkthdr.rcvif = &ie->arpcom.ac_if;
1264 resid = m->m_pkthdr.len = totlen;
1269 * This loop goes through and allocates mbufs for all the data we
1270 * will be copying in. It does not actually do the copying yet.
1272 do { /* while(resid > 0) */
1274 * Try to allocate an mbuf to hold the data that we have.
1275 * If we already allocated one, just get another one and
1276 * stick it on the end (eventually). If we don't already
1277 * have one, try to allocate an mbuf cluster big enough to
1278 * hold the whole packet, if we think it's reasonable, or a
1279 * single mbuf which may or may not be big enough. Got that?
1282 MGET(m, M_DONTWAIT, MT_DATA);
1285 ie_drop_packet_buffer(unit, ie);
1290 if (resid >= MINCLSIZE) {
1291 MCLGET(m, M_DONTWAIT);
1292 if (m->m_flags & M_EXT)
1293 m->m_len = min(resid, MCLBYTES);
1295 if (resid < m->m_len) {
1296 if (!top && resid + max_linkhdr <= m->m_len)
1297 m->m_data += max_linkhdr;
1304 } while (resid > 0);
1312 * Now we take the mbuf chain (hopefully only one mbuf most of the
1313 * time) and stuff the data into it. There are no possible failures
1314 * at or after this point.
1316 while (resid > 0) { /* while there's stuff left */
1317 int thislen = ie_buflen(ie, head) - offset;
1320 * If too much data for the current mbuf, then fill the
1321 * current one up, go to the next one, and try again.
1323 if (thislen > m->m_len - thismboff) {
1324 int newlen = m->m_len - thismboff;
1326 bcopy((v_caddr_t) (ie->cbuffs[head] + offset),
1327 mtod(m, v_caddr_t) +thismboff, (unsigned) newlen);
1328 /* ignore cast-qual warning */
1330 thismboff = 0; /* new mbuf, so no offset */
1331 offset += newlen; /* we are now this far into
1333 resid -= newlen; /* so there is this much left
1338 * If there is more than enough space in the mbuf to hold
1339 * the contents of this buffer, copy everything in, advance
1340 * pointers, and so on.
1342 if (thislen < m->m_len - thismboff) {
1343 bcopy((v_caddr_t) (ie->cbuffs[head] + offset),
1344 mtod(m, caddr_t) +thismboff, (unsigned) thislen);
1345 thismboff += thislen; /* we are this far into the
1347 resid -= thislen; /* and this much is left */
1351 * Otherwise, there is exactly enough space to put this
1352 * buffer's contents into the current mbuf. Do the
1353 * combination of the above actions.
1355 bcopy((v_caddr_t) (ie->cbuffs[head] + offset),
1356 mtod(m, caddr_t) + thismboff, (unsigned) thislen);
1358 thismboff = 0; /* new mbuf, start at the beginning */
1359 resid -= thislen; /* and we are this far through */
1362 * Advance all the pointers. We can get here from either of
1363 * the last two cases, but never the first.
1367 ie->rbuffs[head]->ie_rbd_actual = 0;
1368 ie->rbuffs[head]->ie_rbd_length |= IE_RBD_LAST;
1369 ie->rbhead = head = (head + 1) % ie->nrxbufs;
1370 ie->rbuffs[ie->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
1371 ie->rbtail = (ie->rbtail + 1) % ie->nrxbufs;
1375 * Unless something changed strangely while we were doing the copy,
1376 * we have now copied everything in from the shared memory. This
1377 * means that we are done.
1383 * Read frame NUM from unit UNIT (pre-cached as IE).
1385 * This routine reads the RFD at NUM, and copies in the buffers from
1386 * the list of RBD, then rotates the RBD and RFD lists so that the receiver
1387 * doesn't start complaining. Trailers are DROPPED---there's no point
1388 * in wasting time on confusing code to deal with them. Hopefully,
1389 * this machine will never ARP for trailers anyway.
1392 ie_readframe(int unit, struct ie_softc *ie, int num/* frame number to read */)
1394 struct ie_recv_frame_desc rfd;
1396 struct ether_header eh;
1398 int bpf_gets_it = 0;
1400 bcopy((v_caddr_t) (ie->rframes[num]), &rfd,
1401 sizeof(struct ie_recv_frame_desc));
1404 * Immediately advance the RFD list, since we we have copied ours
1407 ie->rframes[num]->ie_fd_status = 0;
1408 ie->rframes[num]->ie_fd_last |= IE_FD_LAST;
1409 ie->rframes[ie->rftail]->ie_fd_last &= ~IE_FD_LAST;
1410 ie->rftail = (ie->rftail + 1) % ie->nframes;
1411 ie->rfhead = (ie->rfhead + 1) % ie->nframes;
1413 if (rfd.ie_fd_status & IE_FD_OK) {
1414 if (ieget(unit, ie, &m, &eh, &bpf_gets_it)) {
1415 ie->arpcom.ac_if.if_ierrors++; /* this counts as an
1421 if (ie_debug & IED_READFRAME) {
1422 printf("ie%d: frame from ether %6D type %x\n", unit,
1423 eh.ether_shost, ":", (unsigned) eh.ether_type);
1425 if (ntohs(eh.ether_type) > ETHERTYPE_TRAIL
1426 && ntohs(eh.ether_type) < (ETHERTYPE_TRAIL + ETHERTYPE_NTRAILER))
1427 printf("received trailer!\n");
1433 if (last_not_for_us) {
1434 m_freem(last_not_for_us);
1435 last_not_for_us = 0;
1438 * Check for a BPF filter; if so, hand it up. Note that we have to
1439 * stick an extra mbuf up front, because bpf_mtap expects to have
1440 * the ether header at the front. It doesn't matter that this
1441 * results in an ill-formatted mbuf chain, since BPF just looks at
1442 * the data. (It doesn't try to free the mbuf, tho' it will make a
1443 * copy for tcpdump.)
1448 m0.m_len = sizeof eh;
1449 m0.m_data = (caddr_t)&eh;
1453 bpf_mtap(&ie->arpcom.ac_if, &m0);
1456 * A signal passed up from the filtering code indicating that the
1457 * packet is intended for BPF but not for the protocol machinery. We
1458 * can save a few cycles by not handing it off to them.
1460 if (bpf_gets_it == 2) {
1461 last_not_for_us = m;
1465 * In here there used to be code to check destination addresses upon
1466 * receipt of a packet. We have deleted that code, and replaced it
1467 * with code to check the address much earlier in the cycle, before
1468 * copying the data in; this saves us valuable cycles when operating
1469 * as a multicast router or when using BPF.
1473 * Finally pass this packet up to higher layers.
1475 ether_input(&ie->arpcom.ac_if, &eh, m);
1479 ie_drop_packet_buffer(int unit, struct ie_softc * ie)
1485 * This means we are somehow out of sync. So, we reset the
1488 if (!(ie->rbuffs[ie->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
1490 print_rbd(ie->rbuffs[ie->rbhead]);
1492 log(LOG_ERR, "ie%d: receive descriptors out of sync at %d\n",
1497 i = ie->rbuffs[ie->rbhead]->ie_rbd_actual & IE_RBD_LAST;
1499 ie->rbuffs[ie->rbhead]->ie_rbd_length |= IE_RBD_LAST;
1500 ie->rbuffs[ie->rbhead]->ie_rbd_actual = 0;
1501 ie->rbhead = (ie->rbhead + 1) % ie->nrxbufs;
1502 ie->rbuffs[ie->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
1503 ie->rbtail = (ie->rbtail + 1) % ie->nrxbufs;
1509 * Start transmission on an interface.
1512 iestart(struct ifnet *ifp)
1514 struct ie_softc *ie = ifp->if_softc;
1515 struct mbuf *m0, *m;
1516 volatile unsigned char *buffer;
1520 * This is not really volatile, in this routine, but it makes gcc
1523 volatile u_short *bptr = &ie->scb->ie_command_list;
1525 if (!(ifp->if_flags & IFF_RUNNING))
1527 if (ifp->if_flags & IFF_OACTIVE)
1531 IF_DEQUEUE(&ie->arpcom.ac_if.if_snd, m);
1535 buffer = ie->xmit_cbuffs[ie->xmit_count];
1538 for (m0 = m; m && len < IE_BUF_LEN; m = m->m_next) {
1539 bcopy(mtod(m, caddr_t), buffer, m->m_len);
1545 len = max(len, ETHER_MIN_LEN);
1548 * See if bpf is listening on this interface, let it see the
1549 * packet before we commit it to the wire.
1551 if (ie->arpcom.ac_if.if_bpf)
1552 bpf_tap(&ie->arpcom.ac_if,
1553 (void *)ie->xmit_cbuffs[ie->xmit_count], len);
1555 ie->xmit_buffs[ie->xmit_count]->ie_xmit_flags =
1557 ie->xmit_buffs[ie->xmit_count]->ie_xmit_next = 0xffff;
1558 ie->xmit_buffs[ie->xmit_count]->ie_xmit_buf =
1559 MK_24(ie->iomem, ie->xmit_cbuffs[ie->xmit_count]);
1561 ie->xmit_cmds[ie->xmit_count]->com.ie_cmd_cmd = IE_CMD_XMIT;
1562 ie->xmit_cmds[ie->xmit_count]->ie_xmit_status = 0;
1563 ie->xmit_cmds[ie->xmit_count]->ie_xmit_desc =
1564 MK_16(ie->iomem, ie->xmit_buffs[ie->xmit_count]);
1566 *bptr = MK_16(ie->iomem, ie->xmit_cmds[ie->xmit_count]);
1567 bptr = &ie->xmit_cmds[ie->xmit_count]->com.ie_cmd_link;
1569 } while (ie->xmit_count < ie->ntxbufs);
1572 * If we queued up anything for transmission, send it.
1574 if (ie->xmit_count) {
1575 ie->xmit_cmds[ie->xmit_count - 1]->com.ie_cmd_cmd |=
1576 IE_CMD_LAST | IE_CMD_INTR;
1579 * By passing the command pointer as a null, we tell
1580 * command_and_wait() to pretend that this isn't an action
1581 * command. I wish I understood what was happening here.
1583 command_and_wait(ifp->if_unit, IE_CU_START, 0, 0);
1584 ifp->if_flags |= IFF_OACTIVE;
1590 * Check to see if there's an 82586 out there.
1593 check_ie_present(int unit, caddr_t where, unsigned size)
1595 volatile struct ie_sys_conf_ptr *scp;
1596 volatile struct ie_int_sys_conf_ptr *iscp;
1597 volatile struct ie_sys_ctl_block *scb;
1603 realbase = (uintptr_t) where + size - (1 << 24);
1605 scp = (volatile struct ie_sys_conf_ptr *) (uintptr_t)
1606 (realbase + IE_SCP_ADDR);
1607 bzero((volatile char *) scp, sizeof *scp);
1610 * First we put the ISCP at the bottom of memory; this tests to make
1611 * sure that our idea of the size of memory is the same as the
1612 * controller's. This is NOT where the ISCP will be in normal
1615 iscp = (volatile struct ie_int_sys_conf_ptr *) where;
1616 bzero((volatile char *)iscp, sizeof *iscp);
1618 scb = (volatile struct ie_sys_ctl_block *) where;
1619 bzero((volatile char *)scb, sizeof *scb);
1621 scp->ie_bus_use = ie_softc[unit].bus_use; /* 8-bit or 16-bit */
1622 scp->ie_iscp_ptr = (caddr_t) (uintptr_t)
1623 ((volatile char *) iscp - (volatile char *) (uintptr_t) realbase);
1626 iscp->ie_scb_offset = MK_16(realbase, scb) + 256;
1628 (*ie_softc[unit].ie_reset_586) (unit);
1629 (*ie_softc[unit].ie_chan_attn) (unit);
1631 DELAY(100); /* wait a while... */
1633 if (iscp->ie_busy) {
1638 * Now relocate the ISCP to its real home, and reset the controller
1641 iscp = (void *) Align((caddr_t) (uintptr_t)
1642 (realbase + IE_SCP_ADDR -
1643 sizeof(struct ie_int_sys_conf_ptr)));
1644 bzero((volatile char *) iscp, sizeof *iscp); /* ignore cast-qual */
1646 scp->ie_iscp_ptr = (caddr_t) (uintptr_t)
1647 ((volatile char *) iscp - (volatile char *) (uintptr_t) realbase);
1650 iscp->ie_scb_offset = MK_16(realbase, scb);
1652 (*ie_softc[unit].ie_reset_586) (unit);
1653 (*ie_softc[unit].ie_chan_attn) (unit);
1657 if (iscp->ie_busy) {
1661 ie_softc[unit].iosize = size;
1662 ie_softc[unit].iomem = (caddr_t) (uintptr_t) realbase;
1664 ie_softc[unit].iscp = iscp;
1665 ie_softc[unit].scb = scb;
1668 * Acknowledge any interrupts we may have caused...
1670 ie_ack(scb, IE_ST_WHENCE, unit, ie_softc[unit].ie_chan_attn);
1677 * Divine the memory size of ie board UNIT.
1678 * Better hope there's nothing important hiding just below the ie card...
1681 find_ie_mem_size(int unit)
1685 ie_softc[unit].iosize = 0;
1687 for (size = 65536; size >= 8192; size -= 8192) {
1688 if (check_ie_present(unit, ie_softc[unit].iomembot, size)) {
1697 el_reset_586(int unit)
1699 outb(PORT + IE507_CTRL, EL_CTRL_RESET);
1701 outb(PORT + IE507_CTRL, EL_CTRL_NORMAL);
1706 sl_reset_586(int unit)
1708 outb(PORT + IEATT_RESET, 0);
1712 ee16_reset_586(int unit)
1714 outb(PORT + IEE16_ECTRL, IEE16_RESET_586);
1716 outb(PORT + IEE16_ECTRL, 0);
1721 el_chan_attn(int unit)
1723 outb(PORT + IE507_ATTN, 1);
1727 sl_chan_attn(int unit)
1729 outb(PORT + IEATT_ATTN, 0);
1733 ee16_chan_attn(int unit)
1735 outb(PORT + IEE16_ATTN, 0);
1739 ee16_read_eeprom(struct ie_softc *sc, int location)
1743 ectrl = inb(sc->port + IEE16_ECTRL);
1744 ectrl &= IEE16_ECTRL_MASK;
1745 ectrl |= IEE16_ECTRL_EECS;
1746 outb(sc->port + IEE16_ECTRL, ectrl);
1748 ee16_eeprom_outbits(sc, IEE16_EEPROM_READ, IEE16_EEPROM_OPSIZE1);
1749 ee16_eeprom_outbits(sc, location, IEE16_EEPROM_ADDR_SIZE);
1750 edata = ee16_eeprom_inbits(sc);
1751 ectrl = inb(sc->port + IEE16_ECTRL);
1752 ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EEDI | IEE16_ECTRL_EECS);
1753 outb(sc->port + IEE16_ECTRL, ectrl);
1754 ee16_eeprom_clock(sc, 1);
1755 ee16_eeprom_clock(sc, 0);
1760 ee16_eeprom_outbits(struct ie_softc *sc, int edata, int count)
1764 ectrl = inb(sc->port + IEE16_ECTRL);
1765 ectrl &= ~IEE16_RESET_ASIC;
1766 for (i = count - 1; i >= 0; i--) {
1767 ectrl &= ~IEE16_ECTRL_EEDI;
1768 if (edata & (1 << i)) {
1769 ectrl |= IEE16_ECTRL_EEDI;
1771 outb(sc->port + IEE16_ECTRL, ectrl);
1772 DELAY(1); /* eeprom data must be setup for 0.4 uSec */
1773 ee16_eeprom_clock(sc, 1);
1774 ee16_eeprom_clock(sc, 0);
1776 ectrl &= ~IEE16_ECTRL_EEDI;
1777 outb(sc->port + IEE16_ECTRL, ectrl);
1778 DELAY(1); /* eeprom data must be held for 0.4 uSec */
1782 ee16_eeprom_inbits(struct ie_softc *sc)
1784 int ectrl, edata, i;
1786 ectrl = inb(sc->port + IEE16_ECTRL);
1787 ectrl &= ~IEE16_RESET_ASIC;
1788 for (edata = 0, i = 0; i < 16; i++) {
1790 ee16_eeprom_clock(sc, 1);
1791 ectrl = inb(sc->port + IEE16_ECTRL);
1792 if (ectrl & IEE16_ECTRL_EEDO) {
1795 ee16_eeprom_clock(sc, 0);
1801 ee16_eeprom_clock(struct ie_softc *sc, int state)
1805 ectrl = inb(sc->port + IEE16_ECTRL);
1806 ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EESK);
1808 ectrl |= IEE16_ECTRL_EESK;
1810 outb(sc->port + IEE16_ECTRL, ectrl);
1811 DELAY(9); /* EESK must be stable for 8.38 uSec */
1814 static __inline void
1815 ee16_interrupt_enable(struct ie_softc *sc)
1818 outb(sc->port + IEE16_IRQ, sc->irq_encoded | IEE16_IRQ_ENABLE);
1823 sl_read_ether(int unit, unsigned char addr[6])
1827 for (i = 0; i < 6; i++)
1828 addr[i] = inb(PORT + i);
1841 printf("ie%d: reset\n", unit);
1842 ie_softc[unit].arpcom.ac_if.if_flags &= ~IFF_UP;
1843 ieioctl(&ie_softc[unit].arpcom.ac_if, SIOCSIFFLAGS, 0);
1846 * Stop i82586 dead in its tracks.
1848 if (command_and_wait(unit, IE_RU_ABORT | IE_CU_ABORT, 0, 0))
1849 printf("ie%d: abort commands timed out\n", unit);
1851 if (command_and_wait(unit, IE_RU_DISABLE | IE_CU_STOP, 0, 0))
1852 printf("ie%d: disable commands timed out\n", unit);
1855 if (!check_ie_present(unit, ie_softc[unit].iomembot,
1856 e_softc[unit].iosize))
1857 panic("ie disappeared!");
1860 ie_softc[unit].arpcom.ac_if.if_flags |= IFF_UP;
1861 ieioctl(&ie_softc[unit].arpcom.ac_if, SIOCSIFFLAGS, 0);
1868 * This is called if we time out.
1871 chan_attn_timeout(void *rock)
1877 * Send a command to the controller and wait for it to either
1878 * complete or be accepted, depending on the command. If the
1879 * command pointer is null, then pretend that the command is
1880 * not an action command. If the command pointer is not null,
1881 * and the command is an action command, wait for
1882 * ((volatile struct ie_cmd_common *)pcmd)->ie_cmd_status & MASK
1886 command_and_wait(int unit, int cmd, volatile void *pcmd, int mask)
1888 volatile struct ie_cmd_common *cc = pcmd;
1889 volatile int timedout = 0;
1890 struct callout_handle ch;
1892 ie_softc[unit].scb->ie_command = (u_short) cmd;
1894 if (IE_ACTION_COMMAND(cmd) && pcmd) {
1895 (*ie_softc[unit].ie_chan_attn) (unit);
1898 * According to the packet driver, the minimum timeout
1899 * should be .369 seconds, which we round up to .37.
1901 ch = timeout(chan_attn_timeout, (caddr_t)&timedout,
1903 /* ignore cast-qual */
1906 * Now spin-lock waiting for status. This is not a very
1907 * nice thing to do, but I haven't figured out how, or
1908 * indeed if, we can put the process waiting for action to
1909 * sleep. (We may be getting called through some other
1910 * timeout running in the kernel.)
1913 if ((cc->ie_cmd_status & mask) || timedout)
1917 untimeout(chan_attn_timeout, (caddr_t)&timedout, ch);
1918 /* ignore cast-qual */
1924 * Otherwise, just wait for the command to be accepted.
1926 (*ie_softc[unit].ie_chan_attn) (unit);
1928 while (ie_softc[unit].scb->ie_command); /* spin lock */
1935 * Run the time-domain reflectometer...
1938 run_tdr(int unit, volatile struct ie_tdr_cmd *cmd)
1942 cmd->com.ie_cmd_status = 0;
1943 cmd->com.ie_cmd_cmd = IE_CMD_TDR | IE_CMD_LAST;
1944 cmd->com.ie_cmd_link = 0xffff;
1945 cmd->ie_tdr_time = 0;
1947 ie_softc[unit].scb->ie_command_list = MK_16(MEM, cmd);
1948 cmd->ie_tdr_time = 0;
1950 if (command_and_wait(unit, IE_CU_START, cmd, IE_STAT_COMPL))
1953 result = cmd->ie_tdr_time;
1955 ie_ack(ie_softc[unit].scb, IE_ST_WHENCE, unit,
1956 ie_softc[unit].ie_chan_attn);
1958 if (result & IE_TDR_SUCCESS)
1961 if (result & IE_TDR_XCVR) {
1962 printf("ie%d: transceiver problem\n", unit);
1963 } else if (result & IE_TDR_OPEN) {
1964 printf("ie%d: TDR detected an open %d clocks away\n", unit,
1965 result & IE_TDR_TIME);
1966 } else if (result & IE_TDR_SHORT) {
1967 printf("ie%d: TDR detected a short %d clocks away\n", unit,
1968 result & IE_TDR_TIME);
1970 printf("ie%d: TDR returned unknown status %x\n", unit, result);
1975 start_receiver(int unit)
1979 ie_softc[unit].scb->ie_recv_list = MK_16(MEM, ie_softc[unit].rframes[0]);
1980 command_and_wait(unit, IE_RU_START, 0, 0);
1982 ie_ack(ie_softc[unit].scb, IE_ST_WHENCE, unit, ie_softc[unit].ie_chan_attn);
1988 * Here is a helper routine for iernr() and ieinit(). This sets up
1992 setup_rfa(v_caddr_t ptr, struct ie_softc * ie)
1994 volatile struct ie_recv_frame_desc *rfd = (volatile void *)ptr;
1995 volatile struct ie_recv_buf_desc *rbd;
1997 int unit = ie - &ie_softc[0];
1999 /* First lay them out */
2000 for (i = 0; i < ie->nframes; i++) {
2001 ie->rframes[i] = rfd;
2002 bzero((volatile char *) rfd, sizeof *rfd); /* ignore cast-qual */
2006 ptr = Alignvol(rfd); /* ignore cast-qual */
2008 /* Now link them together */
2009 for (i = 0; i < ie->nframes; i++) {
2010 ie->rframes[i]->ie_fd_next =
2011 MK_16(MEM, ie->rframes[(i + 1) % ie->nframes]);
2014 /* Finally, set the EOL bit on the last one. */
2015 ie->rframes[ie->nframes - 1]->ie_fd_last |= IE_FD_LAST;
2018 * Now lay out some buffers for the incoming frames. Note that we
2019 * set aside a bit of slop in each buffer, to make sure that we have
2020 * enough space to hold a single frame in every buffer.
2022 rbd = (volatile void *) ptr;
2024 for (i = 0; i < ie->nrxbufs; i++) {
2025 ie->rbuffs[i] = rbd;
2026 bzero((volatile char *)rbd, sizeof *rbd);
2027 ptr = Alignvol(ptr + sizeof *rbd);
2028 rbd->ie_rbd_length = IE_RBUF_SIZE;
2029 rbd->ie_rbd_buffer = MK_24(MEM, ptr);
2030 ie->cbuffs[i] = (volatile void *) ptr;
2031 ptr += IE_RBUF_SIZE;
2032 rbd = (volatile void *) ptr;
2035 /* Now link them together */
2036 for (i = 0; i < ie->nrxbufs; i++) {
2037 ie->rbuffs[i]->ie_rbd_next =
2038 MK_16(MEM, ie->rbuffs[(i + 1) % ie->nrxbufs]);
2041 /* Tag EOF on the last one */
2042 ie->rbuffs[ie->nrxbufs - 1]->ie_rbd_length |= IE_RBD_LAST;
2045 * We use the head and tail pointers on receive to keep track of the
2046 * order in which RFDs and RBDs are used.
2049 ie->rftail = ie->nframes - 1;
2051 ie->rbtail = ie->nrxbufs - 1;
2053 ie->scb->ie_recv_list = MK_16(MEM, ie->rframes[0]);
2054 ie->rframes[0]->ie_fd_buf_desc = MK_16(MEM, ie->rbuffs[0]);
2056 ptr = Alignvol(ptr);
2061 * Run the multicast setup command.
2065 mc_setup(int unit, v_caddr_t ptr,
2066 volatile struct ie_sys_ctl_block * scb)
2068 struct ie_softc *ie = &ie_softc[unit];
2069 volatile struct ie_mcast_cmd *cmd = (volatile void *) ptr;
2071 cmd->com.ie_cmd_status = 0;
2072 cmd->com.ie_cmd_cmd = IE_CMD_MCAST | IE_CMD_LAST;
2073 cmd->com.ie_cmd_link = 0xffff;
2075 /* ignore cast-qual */
2076 bcopy((v_caddr_t) ie->mcast_addrs, (v_caddr_t) cmd->ie_mcast_addrs,
2077 ie->mcast_count * sizeof *ie->mcast_addrs);
2079 cmd->ie_mcast_bytes = ie->mcast_count * 6; /* grrr... */
2081 scb->ie_command_list = MK_16(MEM, cmd);
2082 if (command_and_wait(unit, IE_CU_START, cmd, IE_STAT_COMPL)
2083 || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2084 printf("ie%d: multicast address setup command failed\n", unit);
2091 * This routine takes the environment generated by check_ie_present()
2092 * and adds to it all the other structures we need to operate the adapter.
2093 * This includes executing the CONFIGURE, IA-SETUP, and MC-SETUP commands,
2094 * starting the receiver unit, and clearing interrupts.
2096 * THIS ROUTINE MUST BE CALLED AT splimp() OR HIGHER.
2102 struct ie_softc *ie = xsc;
2103 volatile struct ie_sys_ctl_block *scb = ie->scb;
2106 int unit = ie->unit;
2108 ptr = Alignvol((volatile char *) scb + sizeof *scb);
2111 * Send the configure command first.
2114 volatile struct ie_config_cmd *cmd = (volatile void *) ptr;
2116 ie_setup_config(cmd, ie->promisc,
2117 ie->hard_type == IE_STARLAN10);
2118 cmd->com.ie_cmd_status = 0;
2119 cmd->com.ie_cmd_cmd = IE_CMD_CONFIG | IE_CMD_LAST;
2120 cmd->com.ie_cmd_link = 0xffff;
2122 scb->ie_command_list = MK_16(MEM, cmd);
2124 if (command_and_wait(unit, IE_CU_START, cmd, IE_STAT_COMPL)
2125 || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2126 printf("ie%d: configure command failed\n", unit);
2131 * Now send the Individual Address Setup command.
2134 volatile struct ie_iasetup_cmd *cmd = (volatile void *) ptr;
2136 cmd->com.ie_cmd_status = 0;
2137 cmd->com.ie_cmd_cmd = IE_CMD_IASETUP | IE_CMD_LAST;
2138 cmd->com.ie_cmd_link = 0xffff;
2140 bcopy((volatile char *)ie_softc[unit].arpcom.ac_enaddr,
2141 (volatile char *)&cmd->ie_address, sizeof cmd->ie_address);
2142 scb->ie_command_list = MK_16(MEM, cmd);
2143 if (command_and_wait(unit, IE_CU_START, cmd, IE_STAT_COMPL)
2144 || !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
2145 printf("ie%d: individual address "
2146 "setup command failed\n", unit);
2152 * Now run the time-domain reflectometer.
2154 run_tdr(unit, (volatile void *) ptr);
2157 * Acknowledge any interrupts we have generated thus far.
2159 ie_ack(ie->scb, IE_ST_WHENCE, unit, ie->ie_chan_attn);
2164 ptr = setup_rfa(ptr, ie);
2167 * Finally, the transmit command and buffer are the last little bit
2171 /* transmit command buffers */
2172 for (i = 0; i < ie->ntxbufs; i++) {
2173 ie->xmit_cmds[i] = (volatile void *) ptr;
2174 ptr += sizeof *ie->xmit_cmds[i];
2175 ptr = Alignvol(ptr);
2176 ie->xmit_buffs[i] = (volatile void *)ptr;
2177 ptr += sizeof *ie->xmit_buffs[i];
2178 ptr = Alignvol(ptr);
2181 /* transmit buffers */
2182 for (i = 0; i < ie->ntxbufs - 1; i++) {
2183 ie->xmit_cbuffs[i] = (volatile void *)ptr;
2185 ptr = Alignvol(ptr);
2187 ie->xmit_cbuffs[ie->ntxbufs - 1] = (volatile void *) ptr;
2189 for (i = 1; i < ie->ntxbufs; i++) {
2190 bzero((v_caddr_t) ie->xmit_cmds[i], sizeof *ie->xmit_cmds[i]);
2191 bzero((v_caddr_t) ie->xmit_buffs[i], sizeof *ie->xmit_buffs[i]);
2195 * This must be coordinated with iestart() and ietint().
2197 ie->xmit_cmds[0]->ie_xmit_status = IE_STAT_COMPL;
2199 /* take the ee16 out of loopback */
2200 if (ie->hard_type == IE_EE16) {
2201 u_int8_t bart_config;
2203 bart_config = inb(PORT + IEE16_CONFIG);
2204 bart_config &= ~IEE16_BART_LOOPBACK;
2205 /* inb doesn't get bit! */
2206 bart_config |= IEE16_BART_MCS16_TEST;
2207 outb(PORT + IEE16_CONFIG, bart_config);
2208 ee16_interrupt_enable(ie);
2209 ee16_chan_attn(unit);
2211 ie->arpcom.ac_if.if_flags |= IFF_RUNNING; /* tell higher levels
2213 start_receiver(unit);
2221 command_and_wait(unit, IE_RU_DISABLE, 0, 0);
2225 ieioctl(struct ifnet *ifp, u_long command, caddr_t data)
2235 error = ether_ioctl(ifp, command, data);
2240 * Note that this device doesn't have an "all multicast"
2241 * mode, so we must turn on promiscuous mode and do the
2242 * filtering manually.
2244 if ((ifp->if_flags & IFF_UP) == 0 &&
2245 (ifp->if_flags & IFF_RUNNING)) {
2246 ifp->if_flags &= ~IFF_RUNNING;
2247 ie_stop(ifp->if_unit);
2248 } else if ((ifp->if_flags & IFF_UP) &&
2249 (ifp->if_flags & IFF_RUNNING) == 0) {
2250 ie_softc[ifp->if_unit].promisc =
2251 ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
2252 ieinit(ifp->if_softc);
2253 } else if (ie_softc[ifp->if_unit].promisc ^
2254 (ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI))) {
2255 ie_softc[ifp->if_unit].promisc =
2256 ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
2257 ieinit(ifp->if_softc);
2264 * Update multicast listeners
2266 /* reset multicast filtering */
2267 ie_mc_reset(ifp->if_unit);
2280 ie_mc_reset(int unit)
2282 struct ie_softc *ie = &ie_softc[unit];
2283 struct ifmultiaddr *ifma;
2286 * Step through the list of addresses.
2288 ie->mcast_count = 0;
2289 for (ifma = ie->arpcom.ac_if.if_multiaddrs.lh_first; ifma;
2290 ifma = ifma->ifma_link.le_next) {
2291 if (ifma->ifma_addr->sa_family != AF_LINK)
2294 /* XXX - this is broken... */
2295 if (ie->mcast_count >= MAXMCAST) {
2296 ie->arpcom.ac_if.if_flags |= IFF_ALLMULTI;
2297 ieioctl(&ie->arpcom.ac_if, SIOCSIFFLAGS, (void *) 0);
2300 bcopy(LLADDR((struct sockaddr_dl *) ifma->ifma_addr),
2301 &(ie->mcast_addrs[ie->mcast_count]), 6);
2306 ie->want_mcsetup = 1;
2312 print_rbd(volatile struct ie_recv_buf_desc * rbd)
2314 printf("RBD at %p:\n"
2315 "actual %04x, next %04x, buffer %p\n"
2316 "length %04x, mbz %04x\n",
2317 (volatile void *) rbd,
2318 rbd->ie_rbd_actual, rbd->ie_rbd_next,
2319 (void *) rbd->ie_rbd_buffer,
2320 rbd->ie_rbd_length, rbd->mbz);
2324 #endif /* NIE > 0 */