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