sys/dev/netif/ie/if_ie.c

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