Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3779cf9667
NetBSD/sys/arch/sun2/dev/if_ec.c
dyoung de87fe677d *** Summary *** 
When a link-layer address changes (e.g., ifconfig ex0 link
02🇩🇪ad:be:ef:02 active), send a gratuitous ARP and/or a Neighbor
Advertisement to update the network-/link-layer address bindings
on our LAN peers.

Refuse a change of ethernet address to the address 00:00:00:00:00:00
or to any multicast/broadcast address.  (Thanks matt@.)

Reorder ifnet ioctl operations so that driver ioctls may inherit
the functions of their "class"---ether_ioctl(), fddi_ioctl(), et
cetera---and the class ioctls may inherit from the generic ioctl,
ifioctl_common(), but both driver- and class-ioctls may override
the generic behavior.  Make network drivers share more code.

Distinguish a "factory" link-layer address from others for the
purposes of both protecting that address from deletion and computing
EUI64.

Return consistent, appropriate error codes from network drivers.

Improve readability.  KNF.

*** Details ***

In if_attach(), always initialize the interface ioctl routine,
ifnet->if_ioctl, if the driver has not already initialized it.
Delete if_ioctl == NULL tests everywhere else, because it cannot
happen.

In the ioctl routines of network interfaces, inherit common ioctl
behaviors by calling either ifioctl_common() or whichever ioctl
routine is appropriate for the class of interface---e.g., ether_ioctl()
for ethernets.

Stop (ab)using SIOCSIFADDR and start to use SIOCINITIFADDR.  In
the user->kernel interface, SIOCSIFADDR's argument was an ifreq,
but on the protocol->ifnet interface, SIOCSIFADDR's argument was
an ifaddr.  That was confusing, and it would work against me as I
make it possible for a network interface to overload most ioctls.
On the protocol->ifnet interface, replace SIOCSIFADDR with
SIOCINITIFADDR.  In ifioctl(), return EPERM if userland tries to
invoke SIOCINITIFADDR.

In ifioctl(), give the interface the first shot at handling most
interface ioctls, and give the protocol the second shot, instead
of the other way around. Finally, let compatibility code (COMPAT_OSOCK)
take a shot.

Pull device initialization out of switch statements under
SIOCINITIFADDR.  For example, pull ..._init() out of any switch
statement that looks like this:

        switch (...->sa_family) {
        case ...:
                ..._init();
                ...
                break;
        ...
        default:
                ..._init();
                ...
                break;
        }

Rewrite many if-else clauses that handle all permutations of IFF_UP
and IFF_RUNNING to use a switch statement,

        switch (x & (IFF_UP|IFF_RUNNING)) {
        case 0:
                ...
                break;
        case IFF_RUNNING:
                ...
                break;
        case IFF_UP:
                ...
                break;
        case IFF_UP|IFF_RUNNING:
                ...
                break;
        }

unifdef lots of code containing #ifdef FreeBSD, #ifdef NetBSD, and
#ifdef SIOCSIFMTU, especially in fwip(4) and in ndis(4).

In ipw(4), remove an if_set_sadl() call that is out of place.

In nfe(4), reuse the jumbo MTU logic in ether_ioctl().

Let ethernets register a callback for setting h/w state such as
promiscuous mode and the multicast filter in accord with a change
in the if_flags: ether_set_ifflags_cb() registers a callback that
returns ENETRESET if the caller should reset the ethernet by calling
if_init(), 0 on success, != 0 on failure.  Pull common code from
ex(4), gem(4), nfe(4), sip(4), tlp(4), vge(4) into ether_ioctl(),
and register if_flags callbacks for those drivers.

Return ENOTTY instead of EINVAL for inappropriate ioctls.  In
zyd(4), use ENXIO instead of ENOTTY to indicate that the device is
not any longer attached.

Add to if_set_sadl() a boolean 'factory' argument that indicates
whether a link-layer address was assigned by the factory or some
other source.  In a comment, recommend using the factory address
for generating an EUI64, and update in6_get_hw_ifid() to prefer a
factory address to any other link-layer address.

Add a routing message, RTM_LLINFO_UPD, that tells protocols to
update the binding of network-layer addresses to link-layer addresses.
Implement this message in IPv4 and IPv6 by sending a gratuitous
ARP or a neighbor advertisement, respectively.  Generate RTM_LLINFO_UPD
messages on a change of an interface's link-layer address.

In ether_ioctl(), do not let SIOCALIFADDR set a link-layer address
that is broadcast/multicast or equal to 00:00:00:00:00:00.

Make ether_ioctl() call ifioctl_common() to handle ioctls that it
does not understand.

In gif(4), initialize if_softc and use it, instead of assuming that
the gif_softc and ifp overlap.

Let ifioctl_common() handle SIOCGIFADDR.

Sprinkle rtcache_invariants(), which checks on DIAGNOSTIC kernels
that certain invariants on a struct route are satisfied.

In agr(4), rewrite agr_ioctl_filter() to be a bit more explicit
about the ioctls that we do not allow on an agr(4) member interface.

bzero -> memset.  Delete unnecessary casts to void *.  Use
sockaddr_in_init() and sockaddr_in6_init().  Compare pointers with
NULL instead of "testing truth".  Replace some instances of (type
*)0 with NULL.  Change some K&R prototypes to ANSI C, and join
lines.
2008-11-07 00:20:01 +00:00

708 lines
16 KiB
C
Raw Blame History

/* $NetBSD: if_ec.c,v 1.16 2008/11/07 00:20:02 dyoung Exp $ */
/*
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Matthew Fredette.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* 3Com 3C400 device driver
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_ec.c,v 1.16 2008/11/07 00:20:02 dyoung Exp $");
#include "opt_inet.h"
#include "opt_ns.h"
#include "bpfilter.h"
#include "rnd.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <sys/endian.h>
#if NRND > 0
#include <sys/rnd.h>
#endif
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/if_ether.h>
#include <net/if_media.h>
#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_inarp.h>
#endif
#ifdef NS
#include <netns/ns.h>
#include <netns/ns_if.h>
#endif
#if NBPFILTER > 0
#include <net/bpf.h>
#include <net/bpfdesc.h>
#endif
#include <machine/cpu.h>
#include <machine/autoconf.h>
#include <machine/idprom.h>
#include <machine/bus.h>
#include <machine/intr.h>
#include <sun2/dev/if_ecreg.h>
/*
* Interface softc.
*/
struct ec_softc {
device_t sc_dev;
void *sc_ih;
struct ethercom sc_ethercom; /* ethernet common */
struct ifmedia sc_media; /* our supported media */
bus_space_tag_t sc_iot; /* bus space tag */
bus_space_handle_t sc_ioh; /* bus space handle */
u_char sc_jammed; /* nonzero if the net is jammed */
u_char sc_colliding; /* nonzero if the net is colliding */
uint32_t sc_backoff_seed; /* seed for the backoff PRNG */
#if NRND > 0
rndsource_element_t rnd_source;
#endif
};
/* Macros to read and write the CSR. */
#define ECREG_CSR_RD bus_space_read_2(sc->sc_iot, sc->sc_ioh, ECREG_CSR)
#define ECREG_CSR_WR(val) bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_CSR, val)
/* After this many collisions, the packet is dropped. */
#define EC_COLLISIONS_JAMMED 16
/*
* Various constants used in the backoff pseudorandom
* number generator.
*/
#define EC_BACKOFF_PRNG_COLL_MAX 10
#define EC_BACKOFF_PRNG_MUL 1103515245
#define EC_BACKOFF_PRNG_ADD 12345
#define EC_BACKOFF_PRNG_MASK 0x7fffffff
/*
* Prototypes
*/
int ec_intr(void *);
void ec_reset(struct ifnet *);
int ec_init(struct ifnet *);
int ec_ioctl(struct ifnet *, u_long, void *);
void ec_watchdog(struct ifnet *);
void ec_start(struct ifnet *);
void ec_recv(struct ec_softc *, int);
void ec_coll(struct ec_softc *);
void ec_copyin(struct ec_softc *, void *, int, size_t);
void ec_copyout(struct ec_softc *, const void *, int, size_t);
int ec_mediachange(struct ifnet *);
void ec_mediastatus(struct ifnet *, struct ifmediareq *);
int ec_match(device_t, cfdata_t, void *);
void ec_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(ec, sizeof(struct ec_softc),
ec_match, ec_attach, NULL, NULL);
/*
* Copy board memory to kernel.
*/
void
ec_copyin(struct ec_softc *sc, void *p, int offset, size_t size)
{
bus_space_copyin(sc->sc_iot, sc->sc_ioh, offset, p, size);
}
/*
* Copy from kernel space to board memory.
*/
void
ec_copyout(struct ec_softc *sc, const void *p, int offset, size_t size)
{
bus_space_copyout(sc->sc_iot, sc->sc_ioh, offset, p, size);
}
int
ec_match(device_t parent, cfdata_t cf, void *aux)
{
struct mbmem_attach_args *mbma = aux;
bus_space_handle_t bh;
bool matched;
/* No default Multibus address. */
if (mbma->mbma_paddr == -1)
return 0;
/* Make sure there is something there... */
if (bus_space_map(mbma->mbma_bustag, mbma->mbma_paddr, ECREG_BANK_SZ,
0, &bh))
return 0;
matched = (bus_space_peek_2(mbma->mbma_bustag, bh, 0, NULL) == 0);
bus_space_unmap(mbma->mbma_bustag, bh, ECREG_BANK_SZ);
if (!matched)
return 0;
/* Default interrupt priority. */
if (mbma->mbma_pri == -1)
mbma->mbma_pri = 3;
return 1;
}
void
ec_attach(device_t parent, device_t self, void *aux)
{
struct ec_softc *sc = device_private(self);
struct mbmem_attach_args *mbma = aux;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
uint8_t myaddr[ETHER_ADDR_LEN];
sc->sc_dev = self;
aprint_normal("\n");
/* Map in the board control regs. */
sc->sc_iot = mbma->mbma_bustag;
if (bus_space_map(mbma->mbma_bustag, mbma->mbma_paddr, ECREG_BANK_SZ,
0, &sc->sc_ioh))
panic("%s: can't map regs", __func__);
/* Reset the board. */
ECREG_CSR_WR(EC_CSR_RESET);
delay(160);
/*
* Copy out the board ROM Ethernet address,
* and use the non-vendor-ID part to seed
* our backoff pseudorandom number generator.
*/
bus_space_read_region_1(sc->sc_iot, sc->sc_ioh,
ECREG_AROM, myaddr, ETHER_ADDR_LEN);
sc->sc_backoff_seed =
(myaddr[3] << 16) | (myaddr[4] << 8) | (myaddr[5]) | 1;
/* Initialize ifnet structure. */
strcpy(ifp->if_xname, device_xname(self));
ifp->if_softc = sc;
ifp->if_start = ec_start;
ifp->if_ioctl = ec_ioctl;
ifp->if_init = ec_init;
ifp->if_watchdog = ec_watchdog;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
IFQ_SET_READY(&ifp->if_snd);
/* Initialize ifmedia structures. */
ifmedia_init(&sc->sc_media, 0, ec_mediachange, ec_mediastatus);
ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_MANUAL, 0, NULL);
ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_MANUAL);
/* Now we can attach the interface. */
if_attach(ifp);
idprom_etheraddr(myaddr);
ether_ifattach(ifp, myaddr);
aprint_normal_dev(self, "address %s\n", ether_sprintf(myaddr));
bus_intr_establish(mbma->mbma_bustag, mbma->mbma_pri, IPL_NET, 0,
ec_intr, sc);
#if NRND > 0
rnd_attach_source(&sc->rnd_source, device_xname(self),
RND_TYPE_NET, 0);
#endif
}
/*
* Reset interface.
*/
void
ec_reset(struct ifnet *ifp)
{
int s;
s = splnet();
ec_init(ifp);
splx(s);
}
/*
* Initialize interface.
*/
int
ec_init(struct ifnet *ifp)
{
struct ec_softc *sc = ifp->if_softc;
/* Reset the board. */
ECREG_CSR_WR(EC_CSR_RESET);
delay(160);
/* Set the Ethernet address. */
bus_space_write_region_1(sc->sc_iot, sc->sc_ioh,
ECREG_ARAM, CLLADDR(sc->sc_ethercom.ec_if.if_sadl), ETHER_ADDR_LEN);
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) | EC_CSR_AMSW);
ECREG_CSR_WR(ECREG_CSR_RD & 0);
/* Enable interrupts. */
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_BINT | EC_CSR_AINT |
(ifp->if_flags & IFF_PROMISC ? EC_CSR_PROMISC : EC_CSR_PA));
/* Set flags appropriately. */
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
/* Start output. */
ec_start(ifp);
return 0;
}
/*
* Start output on interface.
*/
void
ec_start(struct ifnet *ifp)
{
struct ec_softc *sc = ifp->if_softc;
struct mbuf *m, *m0;
int s;
u_int count, realcount;
bus_size_t off;
static uint8_t padding[ETHER_MIN_LEN - ETHER_CRC_LEN] = {0};
s = splnet();
/* Don't do anything if output is active. */
if ((ifp->if_flags & IFF_OACTIVE) != 0) {
splx(s);
return;
}
/* Don't do anything if the output queue is empty. */
IFQ_DEQUEUE(&ifp->if_snd, m0);
if (m0 == NULL) {
splx(s);
return;
}
#if NBPFILTER > 0
/* The BPF tap. */
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0);
#endif
/* Size the packet. */
count = EC_BUF_SZ - m0->m_pkthdr.len;
/* Copy the packet into the xmit buffer. */
realcount = MIN(count, EC_PKT_MAXTDOFF);
bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_TBUF, realcount);
for (off = realcount, m = m0; m != 0; off += m->m_len, m = m->m_next)
ec_copyout(sc, mtod(m, uint8_t *), ECREG_TBUF + off, m->m_len);
m_freem(m0);
if (count - realcount)
ec_copyout(sc, padding, ECREG_TBUF + off, count - realcount);
/* Enable the transmitter. */
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_PA) |
EC_CSR_TBSW | EC_CSR_TINT | EC_CSR_JINT);
ifp->if_flags |= IFF_OACTIVE;
/* Done. */
splx(s);
}
/*
* Controller interrupt.
*/
int
ec_intr(void *arg)
{
struct ec_softc *sc = arg;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
int recv_first;
int recv_second;
int retval;
struct mbuf *m0;
retval = 0;
/* Check for received packet(s). */
recv_first = recv_second = 0;
switch (ECREG_CSR_RD & (EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_RBBA)) {
case (EC_CSR_BBSW | EC_CSR_ABSW):
case (EC_CSR_BBSW | EC_CSR_ABSW | EC_CSR_RBBA):
/* Neither buffer is full. Is this a transmit interrupt?
* Acknowledge the interrupt ourselves. */
ECREG_CSR_WR(ECREG_CSR_RD &
(EC_CSR_TINT | EC_CSR_JINT | EC_CSR_PAMASK));
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
EC_CSR_BINT | EC_CSR_AINT);
break;
case EC_CSR_BBSW:
case (EC_CSR_BBSW | EC_CSR_RBBA):
/* Only the A buffer is full. */
recv_first = EC_CSR_AINT;
break;
case EC_CSR_ABSW:
case (EC_CSR_ABSW | EC_CSR_RBBA):
/* Only the B buffer is full. */
recv_first = EC_CSR_BINT;
break;
case 0:
/* Both the A buffer and the B buffer are full, and the A
* buffer is older than the B buffer. */
recv_first = EC_CSR_AINT;
recv_second = EC_CSR_BINT;
break;
case EC_CSR_RBBA:
/* Both the A buffer and the B buffer are full, and the B
* buffer is older than the A buffer. */
recv_first = EC_CSR_BINT;
recv_second = EC_CSR_AINT;
break;
}
/* Receive packets. */
if (recv_first) {
/* Acknowledge the interrupt. */
ECREG_CSR_WR(ECREG_CSR_RD &
((EC_CSR_BINT | EC_CSR_AINT | EC_CSR_TINT | EC_CSR_JINT |
EC_CSR_PAMASK) ^ (recv_first | recv_second)));
/* Receive a packet. */
ec_recv(sc, recv_first);
/* Receive a packet. */
if (recv_second)
ec_recv(sc, recv_second);
retval++;
}
/* Check for a transmitted packet. */
if (ifp->if_flags & IFF_OACTIVE) {
/* If we got a collision. */
if (ECREG_CSR_RD & EC_CSR_JAM) {
ECREG_CSR_WR(ECREG_CSR_RD &
(EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
sc->sc_ethercom.ec_if.if_collisions++;
retval++;
ec_coll(sc);
}
/* If we transmitted a packet. */
else if ((ECREG_CSR_RD & EC_CSR_TBSW) == 0) {
ECREG_CSR_WR(ECREG_CSR_RD &
(EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
retval++;
sc->sc_ethercom.ec_if.if_opackets++;
sc->sc_jammed = 0;
ifp->if_flags &= ~IFF_OACTIVE;
IFQ_POLL(&ifp->if_snd, m0);
if (m0 != NULL)
ec_start(ifp);
}
} else {
/* Make sure we disable transmitter interrupts. */
ECREG_CSR_WR(ECREG_CSR_RD &
(EC_CSR_BINT | EC_CSR_AINT | EC_CSR_PAMASK));
}
return retval;
}
/*
* Read in a packet from the board.
*/
void
ec_recv(struct ec_softc *sc, int intbit)
{
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
struct mbuf *m0, *m, *newm;
bus_size_t buf;
uint16_t status;
uint16_t doff;
int length, total_length;
buf = EC_CSR_INT_BUF(intbit);
/* Read in the packet status. */
status = bus_space_read_2(sc->sc_iot, sc->sc_ioh, buf);
doff = status & EC_PKT_DOFF;
for (total_length = -1, m0 = NULL;;) {
/* Check for an error. */
if (status & (EC_PKT_FCSERR | EC_PKT_RGERR | EC_PKT_FRERR) ||
doff < EC_PKT_MINRDOFF ||
doff > EC_PKT_MAXRDOFF) {
printf("%s: garbled packet, status 0x%04x; dropping\n",
device_xname(sc->sc_dev), (unsigned int)status);
break;
}
/* Adjust for the header. */
total_length = doff - EC_PKT_RDOFF;
buf += EC_PKT_RDOFF;
/* XXX - sometimes the card reports a large data offset. */
if (total_length > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
#ifdef DEBUG
printf("%s: fixing too-large length of %d\n",
device_xname(sc->sc_dev), total_length);
#endif
total_length = (ETHER_MAX_LEN - ETHER_CRC_LEN);
}
MGETHDR(m0, M_DONTWAIT, MT_DATA);
if (m0 == NULL)
break;
m0->m_pkthdr.rcvif = ifp;
m0->m_pkthdr.len = total_length;
length = MHLEN;
m = m0;
while (total_length > 0) {
if (total_length >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0)
break;
length = MCLBYTES;
}
m->m_len = length = min(total_length, length);
ec_copyin(sc, mtod(m, uint8_t *), buf, length);
total_length -= length;
buf += length;
if (total_length > 0) {
MGET(newm, M_DONTWAIT, MT_DATA);
if (newm == NULL)
break;
length = MLEN;
m = m->m_next = newm;
}
}
break;
}
if (total_length == 0) {
ifp->if_ipackets++;
#if NBPFILTER > 0
/*
* Check if there's a BPF listener on this interface.
* If so, hand off the raw packet to BPF.
*/
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0);
#endif
/* Pass the packet up. */
(*ifp->if_input)(ifp, m0);
} else {
/* Something went wrong. */
if (m0 != NULL)
m_freem(m0);
ifp->if_ierrors++;
}
/* Give the receive buffer back to the card. */
buf = EC_CSR_INT_BUF(intbit);
bus_space_write_2(sc->sc_iot, sc->sc_ioh, buf, 0);
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
EC_CSR_INT_BSW(intbit) | intbit);
}
int
ec_mediachange(struct ifnet *ifp)
{
return 0;
}
void
ec_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
{
if ((ifp->if_flags & IFF_UP) == 0)
return;
ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
}
/*
* Process an ioctl request. This code needs some work - it looks pretty ugly.
*/
int
ec_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
struct ifaddr *ifa = (struct ifaddr *)data;
struct ifreq *ifr = (struct ifreq *)data;
struct ec_softc *sc = ifp->if_softc;
int s, error = 0;
s = splnet();
switch (cmd) {
case SIOCINITIFADDR:
ifp->if_flags |= IFF_UP;
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
ec_init(ifp);
arp_ifinit(ifp, ifa);
break;
#endif
default:
ec_init(ifp);
break;
}
break;
case SIOCSIFFLAGS:
if ((error = ifioctl_common(ifp, cmd, data)) != 0)
break;
switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
case IFF_RUNNING:
/*
* If interface is marked down and it is running, then
* stop it.
*/
ifp->if_flags &= ~IFF_RUNNING;
break;
case IFF_UP:
/*
* If interface is marked up and it is stopped, then
* start it.
*/
ec_init(ifp);
break;
default:
/*
* Some other important flag might have changed, so
* reset.
*/
ec_reset(ifp);
break;
}
break;
case SIOCGIFMEDIA:
case SIOCSIFMEDIA:
error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
break;
default:
error = ether_ioctl(ifp, cmd, data);
break;
}
splx(s);
return error;
}
/*
* Collision routine.
*/
void
ec_coll(struct ec_softc *sc)
{
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
u_short jams;
struct mbuf *m0;
if ((++sc->sc_colliding) >= EC_COLLISIONS_JAMMED) {
sc->sc_ethercom.ec_if.if_oerrors++;
if (!sc->sc_jammed)
printf("%s: ethernet jammed\n",
device_xname(sc->sc_dev));
sc->sc_jammed = 1;
sc->sc_colliding = 0;
ifp->if_flags &= ~IFF_OACTIVE;
IFQ_POLL(&ifp->if_snd, m0);
if (m0 != NULL)
ec_start(ifp);
} else {
jams = MAX(sc->sc_colliding, EC_BACKOFF_PRNG_COLL_MAX);
sc->sc_backoff_seed =
((sc->sc_backoff_seed * EC_BACKOFF_PRNG_MUL) +
EC_BACKOFF_PRNG_ADD) & EC_BACKOFF_PRNG_MASK;
bus_space_write_2(sc->sc_iot, sc->sc_ioh, ECREG_BACKOFF,
-(((sc->sc_backoff_seed >> 8) & ~(-1 << jams)) + 1));
ECREG_CSR_WR((ECREG_CSR_RD & EC_CSR_INTPA) |
EC_CSR_JAM | EC_CSR_TINT | EC_CSR_JINT);
}
}
/*
* Device timeout routine.
*/
void
ec_watchdog(struct ifnet *ifp)
{
struct ec_softc *sc = ifp->if_softc;
log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev));
sc->sc_ethercom.ec_if.if_oerrors++;
ec_reset(ifp);
}
Reference in New Issue View Git Blame Copy Permalink