sys/arch/sun2/dev/if_ec.c

   1 /*      $NetBSD: if_ec.c,v 1.15 2008/07/06 13:29:50 tsutsui Exp $       */
   2
   3 /*
   4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Matthew Fredette.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * 3Com 3C400 device driver
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __KERNEL_RCSID(0, "$NetBSD: if_ec.c,v 1.15 2008/07/06 13:29:50 tsutsui Exp $");
  38
  39 #include "opt_inet.h"
  40 #include "opt_ns.h"
  41 #include "bpfilter.h"
  42 #include "rnd.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/errno.h>
  47 #include <sys/ioctl.h>
  48 #include <sys/mbuf.h>
  49 #include <sys/socket.h>
  50 #include <sys/syslog.h>
  51 #include <sys/device.h>
  52 #include <sys/endian.h>
  53 #if NRND > 0
  54 #include <sys/rnd.h>
  55 #endif
  56
  57 #include <net/if.h>
  58 #include <net/if_dl.h>
  59 #include <net/if_types.h>
  60
  61 #include <net/if_ether.h>
  62 #include <net/if_media.h>
  63
  64 #ifdef INET
  65 #include <netinet/in.h>
  66 #include <netinet/in_systm.h>
  67 #include <netinet/in_var.h>
  68 #include <netinet/ip.h>
  69 #include <netinet/if_inarp.h>
  70 #endif
  71
  72 #ifdef NS
  73 #include <netns/ns.h>
  74 #include <netns/ns_if.h>
  75 #endif
  76
  77 #if NBPFILTER > 0
  78 #include <net/bpf.h>
  79 #include <net/bpfdesc.h>
  80 #endif
  81
  82 #include <machine/cpu.h>
  83 #include <machine/autoconf.h>
  84 #include <machine/idprom.h>
  85 #include <machine/bus.h>
  86 #include <machine/intr.h>
  87
  88 #include <sun2/dev/if_ecreg.h>
  89
  90 /*
  91  * Interface softc.
  92  */
  93 struct ec_softc {
  94         device_t sc_dev;
  95         void *sc_ih;
  96
  97         struct ethercom sc_ethercom;    /* ethernet common */
  98         struct ifmedia sc_media;        /* our supported media */
  99
 100         bus_space_tag_t sc_iot; /* bus space tag */
 101         bus_space_handle_t sc_ioh;      /* bus space handle */
 102
 103         u_char sc_jammed;       /* nonzero if the net is jammed */
 104         u_char sc_colliding;    /* nonzero if the net is colliding */
 105         uint32_t sc_backoff_seed;       /* seed for the backoff PRNG */
 106
 107 #if NRND > 0
 108         rndsource_element_t rnd_source;
 109 #endif
 110 };
 111
 112 /* Macros to read and write the CSR. */
 113 #define ECREG_CSR_RD bus_space_read_2(sc->sc_iot, sc->sc_ioh, ECREG_CSR)
 114 #define ECREG_CSR_WR(val) bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_CSR, val)
 115
 116 /* After this many collisions, the packet is dropped. */
 117 #define EC_COLLISIONS_JAMMED            16
 118
 119 /*
 120  * Various constants used in the backoff pseudorandom
 121  * number generator.
 122  */
 123 #define EC_BACKOFF_PRNG_COLL_MAX        10
 124 #define EC_BACKOFF_PRNG_MUL             1103515245
 125 #define EC_BACKOFF_PRNG_ADD             12345
 126 #define EC_BACKOFF_PRNG_MASK            0x7fffffff
 127
 128 /*
 129  * Prototypes
 130  */
 131 int ec_intr(void *);
 132 void ec_reset(struct ifnet *);
 133 int ec_init(struct ifnet *);
 134 int ec_ioctl(struct ifnet *, u_long, void *);
 135 void ec_watchdog(struct ifnet *);
 136 void ec_start(struct ifnet *);
 137
 138 void ec_recv(struct ec_softc *, int);
 139 void ec_coll(struct ec_softc *);
 140 void ec_copyin(struct ec_softc *, void *, int, size_t);
 141 void ec_copyout(struct ec_softc *, const void *, int, size_t);
 142
 143 int ec_mediachange(struct ifnet *);
 144 void ec_mediastatus(struct ifnet *, struct ifmediareq *);
 145
 146 int ec_match(device_t, cfdata_t, void *);
 147 void ec_attach(device_t, device_t, void *);
 148
 149 CFATTACH_DECL_NEW(ec, sizeof(struct ec_softc),
 150     ec_match, ec_attach, NULL, NULL);
 151
 152 /*
 153  * Copy board memory to kernel.
 154  */
 155 void
 156 ec_copyin(struct ec_softc *sc, void *p, int offset, size_t size)
 157 {
 158
 159         bus_space_copyin(sc->sc_iot, sc->sc_ioh, offset, p, size);
 160 }
 161
 162 /*
 163  * Copy from kernel space to board memory.
 164  */
 165 void
 166 ec_copyout(struct ec_softc *sc, const void *p, int offset, size_t size)
 167 {
 168
 169         bus_space_copyout(sc->sc_iot, sc->sc_ioh, offset, p, size);
 170 }
 171
 172 int
 173 ec_match(device_t parent, cfdata_t cf, void *aux)
 174 {
 175         struct mbmem_attach_args *mbma = aux;
 176         bus_space_handle_t bh;
 177         bool matched;
 178
 179         /* No default Multibus address. */
 180         if (mbma->mbma_paddr == -1)
 181                 return 0;
 182
 183         /* Make sure there is something there... */
 184         if (bus_space_map(mbma->mbma_bustag, mbma->mbma_paddr, ECREG_BANK_SZ,
 185             0, &bh))
 186                 return 0;
 187         matched = (bus_space_peek_2(mbma->mbma_bustag, bh, 0, NULL) == 0);
 188         bus_space_unmap(mbma->mbma_bustag, bh, ECREG_BANK_SZ);
 189         if (!matched)
 190                 return 0;
 191
 192         /* Default interrupt priority. */
 193         if (mbma->mbma_pri == -1)
 194                 mbma->mbma_pri = 3;
 195
 196         return 1;
 197 }
 198
 199 void
 200 ec_attach(device_t parent, device_t self, void *aux)
 201 {
 202         struct ec_softc *sc = device_private(self);
 203         struct mbmem_attach_args *mbma = aux;
 204         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 205         uint8_t myaddr[ETHER_ADDR_LEN];
 206
 207         sc->sc_dev = self;
 208
 209         aprint_normal("\n");
 210
 211         /* Map in the board control regs. */
 212         sc->sc_iot = mbma->mbma_bustag;
 213         if (bus_space_map(mbma->mbma_bustag, mbma->mbma_paddr, ECREG_BANK_SZ,
 214             0, &sc->sc_ioh))
 215                 panic("%s: can't map regs", __func__);
 216
 217         /* Reset the board. */
 218         ECREG_CSR_WR(EC_CSR_RESET);
 219         delay(160);
 220
 221         /*
 222          * Copy out the board ROM Ethernet address,
 223          * and use the non-vendor-ID part to seed
 224          * our backoff pseudorandom number generator.
 225          */
 226         bus_space_read_region_1(sc->sc_iot, sc->sc_ioh,
 227             ECREG_AROM, myaddr, ETHER_ADDR_LEN);
 228         sc->sc_backoff_seed =
 229             (myaddr[3] << 16) | (myaddr[4] << 8) | (myaddr[5]) | 1;
 230
 231         /* Initialize ifnet structure. */
 232         strcpy(ifp->if_xname, device_xname(self));
 233         ifp->if_softc = sc;
 234         ifp->if_start = ec_start;
 235         ifp->if_ioctl = ec_ioctl;
 236         ifp->if_init = ec_init;
 237         ifp->if_watchdog = ec_watchdog;
 238         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
 239         IFQ_SET_READY(&ifp->if_snd);
 240
 241         /* Initialize ifmedia structures. */
 242         ifmedia_init(&sc->sc_media, 0, ec_mediachange, ec_mediastatus);
 243         ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_MANUAL, 0, NULL);
 244         ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_MANUAL);
 245
 246         /* Now we can attach the interface. */
 247         if_attach(ifp);
 248         idprom_etheraddr(myaddr);
 249         ether_ifattach(ifp, myaddr);
 250         aprint_normal_dev(self, "address %s\n", ether_sprintf(myaddr));
 251
 252         bus_intr_establish(mbma->mbma_bustag, mbma->mbma_pri, IPL_NET, 0,
 253             ec_intr, sc);
 254
 255 #if NRND > 0
 256         rnd_attach_source(&sc->rnd_source, device_xname(self),
 257             RND_TYPE_NET, 0);
 258 #endif
 259 }
 260
 261 /*
 262  * Reset interface.
 263  */
 264 void
 265 ec_reset(struct ifnet *ifp)
 266 {
 267         int s;
 268
 269         s = splnet();
 270         ec_init(ifp);
 271         splx(s);
 272 }
 273
 274
 275 /*
 276  * Initialize interface.
 277  */
 278 int
 279 ec_init(struct ifnet *ifp)
 280 {
 281         struct ec_softc *sc = ifp->if_softc;
 282
 283         /* Reset the board. */
 284         ECREG_CSR_WR(EC_CSR_RESET);
 285         delay(160);
 286
 287         /* Set the Ethernet address. */
 288         bus_space_write_region_1(sc->sc_iot, sc->sc_ioh,
 289             ECREG_ARAM, CLLADDR(sc->sc_ethercom.ec_if.if_sadl), ETHER_ADDR_LEN);
 290         ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) | EC_CSR_AMSW);
 291         ECREG_CSR_WR(ECREG_CSR_RD & 0);
 292
 293         /* Enable interrupts. */
 294         ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
 295             EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_BINT | EC_CSR_AINT |
 296             (ifp->if_flags & IFF_PROMISC ? EC_CSR_PROMISC : EC_CSR_PA));
 297
 298         /* Set flags appropriately. */
 299         ifp->if_flags |= IFF_RUNNING;
 300         ifp->if_flags &= ~IFF_OACTIVE;
 301
 302         /* Start output. */
 303         ec_start(ifp);
 304
 305         return 0;
 306 }
 307
 308 /*
 309  * Start output on interface.
 310  */
 311 void
 312 ec_start(struct ifnet *ifp)
 313 {
 314         struct ec_softc *sc = ifp->if_softc;
 315         struct mbuf *m, *m0;
 316         int s;
 317         u_int count, realcount;
 318         bus_size_t off;
 319         static uint8_t padding[ETHER_MIN_LEN - ETHER_CRC_LEN] = {0};
 320
 321         s = splnet();
 322
 323         /* Don't do anything if output is active. */
 324         if ((ifp->if_flags & IFF_OACTIVE) != 0) {
 325                 splx(s);
 326                 return;
 327         }
 328         /* Don't do anything if the output queue is empty. */
 329         IFQ_DEQUEUE(&ifp->if_snd, m0);
 330         if (m0 == NULL) {
 331                 splx(s);
 332                 return;
 333         }
 334
 335 #if NBPFILTER > 0
 336         /* The BPF tap. */
 337         if (ifp->if_bpf)
 338                 bpf_mtap(ifp->if_bpf, m0);
 339 #endif
 340
 341         /* Size the packet. */
 342         count = EC_BUF_SZ - m0->m_pkthdr.len;
 343
 344         /* Copy the packet into the xmit buffer. */
 345         realcount = MIN(count, EC_PKT_MAXTDOFF);
 346         bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_TBUF, realcount);
 347         for (off = realcount, m = m0; m != 0; off += m->m_len, m = m->m_next)
 348                 ec_copyout(sc, mtod(m, uint8_t *), ECREG_TBUF + off, m->m_len);
 349         m_freem(m0);
 350         if (count - realcount)
 351                 ec_copyout(sc, padding, ECREG_TBUF + off, count - realcount);
 352
 353         /* Enable the transmitter. */
 354         ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_PA) |
 355             EC_CSR_TBSW | EC_CSR_TINT | EC_CSR_JINT);
 356         ifp->if_flags |= IFF_OACTIVE;
 357
 358         /* Done. */
 359         splx(s);
 360 }
 361
 362 /*
 363  * Controller interrupt.
 364  */
 365 int
 366 ec_intr(void *arg)
 367 {
 368         struct ec_softc *sc = arg;
 369         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 370         int recv_first;
 371         int recv_second;
 372         int retval;
 373         struct mbuf *m0;
 374
 375         retval = 0;
 376
 377         /* Check for received packet(s). */
 378         recv_first = recv_second = 0;
 379         switch (ECREG_CSR_RD & (EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_RBBA)) {
 380
 381         case (EC_CSR_BBSW | EC_CSR_ABSW):
 382         case (EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_RBBA):
 383                 /* Neither buffer is full.  Is this a transmit interrupt?
 384                  * Acknowledge the interrupt ourselves. */
 385                 ECREG_CSR_WR(ECREG_CSR_RD &
 386                     (EC_CSR_TINT | EC_CSR_JINT | EC_CSR_PAMASK));
 387                 ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
 388                     EC_CSR_BINT | EC_CSR_AINT);
 389                 break;
 390
 391         case EC_CSR_BBSW:
 392         case (EC_CSR_BBSW | EC_CSR_RBBA):
 393                 /* Only the A buffer is full. */
 394                 recv_first = EC_CSR_AINT;
 395                 break;
 396
 397         case EC_CSR_ABSW:
 398         case (EC_CSR_ABSW | EC_CSR_RBBA):
 399                 /* Only the B buffer is full. */
 400                 recv_first = EC_CSR_BINT;
 401                 break;
 402
 403         case 0:
 404                 /* Both the A buffer and the B buffer are full, and the A
 405                  * buffer is older than the B buffer. */
 406                 recv_first = EC_CSR_AINT;
 407                 recv_second = EC_CSR_BINT;
 408                 break;
 409
 410         case EC_CSR_RBBA:
 411                 /* Both the A buffer and the B buffer are full, and the B
 412                  * buffer is older than the A buffer. */
 413                 recv_first = EC_CSR_BINT;
 414                 recv_second = EC_CSR_AINT;
 415                 break;
 416         }
 417
 418         /* Receive packets. */
 419         if (recv_first) {
 420
 421                 /* Acknowledge the interrupt. */
 422                 ECREG_CSR_WR(ECREG_CSR_RD &
 423                     ((EC_CSR_BINT | EC_CSR_AINT | EC_CSR_TINT | EC_CSR_JINT |
 424                       EC_CSR_PAMASK) ^ (recv_first | recv_second)));
 425
 426                 /* Receive a packet. */
 427                 ec_recv(sc, recv_first);
 428
 429                 /* Receive a packet. */
 430                 if (recv_second)
 431                         ec_recv(sc, recv_second);
 432
 433                 retval++;
 434         }
 435         /* Check for a transmitted packet. */
 436         if (ifp->if_flags & IFF_OACTIVE) {
 437
 438                 /* If we got a collision. */
 439                 if (ECREG_CSR_RD & EC_CSR_JAM) {
 440                         ECREG_CSR_WR(ECREG_CSR_RD &
 441                             (EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
 442                         sc->sc_ethercom.ec_if.if_collisions++;
 443                         retval++;
 444                         ec_coll(sc);
 445
 446                 }
 447                 /* If we transmitted a packet. */
 448                 else if ((ECREG_CSR_RD & EC_CSR_TBSW) == 0) {
 449                         ECREG_CSR_WR(ECREG_CSR_RD &
 450                             (EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
 451                         retval++;
 452                         sc->sc_ethercom.ec_if.if_opackets++;
 453                         sc->sc_jammed = 0;
 454                         ifp->if_flags &= ~IFF_OACTIVE;
 455                         IFQ_POLL(&ifp->if_snd, m0);
 456                         if (m0 != NULL)
 457                                 ec_start(ifp);
 458                 }
 459         } else {
 460
 461                 /* Make sure we disable transmitter interrupts. */
 462                 ECREG_CSR_WR(ECREG_CSR_RD &
 463                     (EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
 464         }
 465
 466         return retval;
 467 }
 468
 469 /*
 470  * Read in a packet from the board.
 471  */
 472 void
 473 ec_recv(struct ec_softc *sc, int intbit)
 474 {
 475         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 476         struct mbuf *m0, *m, *newm;
 477         bus_size_t buf;
 478         uint16_t status;
 479         uint16_t doff;
 480         int length, total_length;
 481
 482         buf = EC_CSR_INT_BUF(intbit);
 483
 484         /* Read in the packet status. */
 485         status = bus_space_read_2(sc->sc_iot, sc->sc_ioh, buf);
 486         doff = status & EC_PKT_DOFF;
 487
 488         for (total_length = -1, m0 = NULL;;) {
 489
 490                 /* Check for an error. */
 491                 if (status & (EC_PKT_FCSERR | EC_PKT_RGERR | EC_PKT_FRERR) ||
 492                     doff < EC_PKT_MINRDOFF ||
 493                     doff > EC_PKT_MAXRDOFF) {
 494                         printf("%s: garbled packet, status 0x%04x; dropping\n",
 495                             device_xname(sc->sc_dev), (unsigned int)status);
 496                         break;
 497                 }
 498
 499                 /* Adjust for the header. */
 500                 total_length = doff - EC_PKT_RDOFF;
 501                 buf += EC_PKT_RDOFF;
 502
 503                 /* XXX - sometimes the card reports a large data offset. */
 504                 if (total_length > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
 505 #ifdef DEBUG
 506                         printf("%s: fixing too-large length of %d\n",
 507                             device_xname(sc->sc_dev), total_length);
 508 #endif
 509                         total_length = (ETHER_MAX_LEN - ETHER_CRC_LEN);
 510                 }
 511
 512                 MGETHDR(m0, M_DONTWAIT, MT_DATA);
 513                 if (m0 == NULL)
 514                         break;
 515                 m0->m_pkthdr.rcvif = ifp;
 516                 m0->m_pkthdr.len = total_length;
 517                 length = MHLEN;
 518                 m = m0;
 519
 520                 while (total_length > 0) {
 521                         if (total_length >= MINCLSIZE) {
 522                                 MCLGET(m, M_DONTWAIT);
 523                                 if ((m->m_flags & M_EXT) == 0)
 524                                         break;
 525                                 length = MCLBYTES;
 526                         }
 527                         m->m_len = length = min(total_length, length);
 528                         ec_copyin(sc, mtod(m, uint8_t *), buf, length);
 529                         total_length -= length;
 530                         buf += length;
 531
 532                         if (total_length > 0) {
 533                                 MGET(newm, M_DONTWAIT, MT_DATA);
 534                                 if (newm == NULL)
 535                                         break;
 536                                 length = MLEN;
 537                                 m = m->m_next = newm;
 538                         }
 539                 }
 540                 break;
 541         }
 542
 543         if (total_length == 0) {
 544                 ifp->if_ipackets++;
 545
 546 #if NBPFILTER > 0
 547                 /*
 548                 * Check if there's a BPF listener on this interface.
 549                 * If so, hand off the raw packet to BPF.
 550                 */
 551                 if (ifp->if_bpf)
 552                         bpf_mtap(ifp->if_bpf, m0);
 553 #endif
 554
 555                 /* Pass the packet up. */
 556                 (*ifp->if_input)(ifp, m0);
 557
 558         } else {
 559                 /* Something went wrong. */
 560                 if (m0 != NULL)
 561                         m_freem(m0);
 562                 ifp->if_ierrors++;
 563         }
 564
 565         /* Give the receive buffer back to the card. */
 566         buf = EC_CSR_INT_BUF(intbit);
 567         bus_space_write_2(sc->sc_iot, sc->sc_ioh, buf, 0);
 568         ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
 569             EC_CSR_INT_BSW(intbit) | intbit);
 570 }
 571
 572 int
 573 ec_mediachange(struct ifnet *ifp)
 574 {
 575
 576         return 0;
 577 }
 578
 579 void
 580 ec_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
 581 {
 582
 583         if ((ifp->if_flags & IFF_UP) == 0)
 584                 return;
 585
 586         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
 587 }
 588
 589 /*
 590  * Process an ioctl request. This code needs some work - it looks pretty ugly.
 591  */
 592 int
 593 ec_ioctl(struct ifnet *ifp, u_long cmd, void *data)
 594 {
 595         struct ifaddr *ifa = (struct ifaddr *)data;
 596         struct ifreq *ifr = (struct ifreq *)data;
 597         struct ec_softc *sc = ifp->if_softc;
 598         int s, error = 0;
 599
 600         s = splnet();
 601
 602         switch (cmd) {
 603
 604         case SIOCINITIFADDR:
 605                 ifp->if_flags |= IFF_UP;
 606
 607                 switch (ifa->ifa_addr->sa_family) {
 608 #ifdef INET
 609                 case AF_INET:
 610                         ec_init(ifp);
 611                         arp_ifinit(ifp, ifa);
 612                         break;
 613 #endif
 614                 default:
 615                         ec_init(ifp);
 616                         break;
 617                 }
 618                 break;
 619
 620         case SIOCSIFFLAGS:
 621                 if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 622                         break;
 623                 switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
 624                 case IFF_RUNNING:
 625                         /*
 626                          * If interface is marked down and it is running, then
 627                          * stop it.
 628                          */
 629                         ifp->if_flags &= ~IFF_RUNNING;
 630                         break;
 631                 case IFF_UP:
 632                         /*
 633                          * If interface is marked up and it is stopped, then
 634                          * start it.
 635                          */
 636                         ec_init(ifp);
 637                         break;
 638                 default:
 639                         /*
 640                          * Some other important flag might have changed, so
 641                          * reset.
 642                          */
 643                         ec_reset(ifp);
 644                         break;
 645                 }
 646                 break;
 647
 648         case SIOCGIFMEDIA:
 649         case SIOCSIFMEDIA:
 650                 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
 651                 break;
 652
 653         default:
 654                 error = ether_ioctl(ifp, cmd, data);
 655                 break;
 656         }
 657
 658         splx(s);
 659         return error;
 660 }
 661
 662 /*
 663  * Collision routine.
 664  */
 665 void
 666 ec_coll(struct ec_softc *sc)
 667 {
 668         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 669         u_short jams;
 670         struct mbuf *m0;
 671
 672         if ((++sc->sc_colliding) >= EC_COLLISIONS_JAMMED) {
 673                 sc->sc_ethercom.ec_if.if_oerrors++;
 674                 if (!sc->sc_jammed)
 675                         printf("%s: ethernet jammed\n",
 676                             device_xname(sc->sc_dev));
 677                 sc->sc_jammed = 1;
 678                 sc->sc_colliding = 0;
 679                 ifp->if_flags &= ~IFF_OACTIVE;
 680                 IFQ_POLL(&ifp->if_snd, m0);
 681                 if (m0 != NULL)
 682                         ec_start(ifp);
 683         } else {
 684                 jams = MAX(sc->sc_colliding, EC_BACKOFF_PRNG_COLL_MAX);
 685                 sc->sc_backoff_seed =
 686                     ((sc->sc_backoff_seed * EC_BACKOFF_PRNG_MUL) +
 687                     EC_BACKOFF_PRNG_ADD) & EC_BACKOFF_PRNG_MASK;
 688                 bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_BACKOFF,
 689                     -(((sc->sc_backoff_seed >> 8) & ~(-1 << jams)) + 1));
 690                 ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
 691                     EC_CSR_JAM | EC_CSR_TINT | EC_CSR_JINT);
 692         }
 693 }
 694
 695 /*
 696  * Device timeout routine.
 697  */
 698 void
 699 ec_watchdog(struct ifnet *ifp)
 700 {
 701         struct ec_softc *sc = ifp->if_softc;
 702
 703         log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev));
 704         sc->sc_ethercom.ec_if.if_oerrors++;
 705
 706         ec_reset(ifp);
 707 }