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