Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fill in the missing pieces and make the NetBSD version of Matt Thomas's 

DEFPA FDDI driver actually compile and link.
This commit is contained in:
thorpej 1996-03-09 03:46:21 +00:00
parent 85288c6a61
commit f350b1aa9d
3 changed files with 402 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
sys/dev/ic/pdq_ifsubr.c Normal file
View File

@ -0,0 +1,380 @@
/* $NetBSD: pdq_ifsubr.c,v 1.1 1996/03/09 03:46:21 thorpej Exp $ */
/*-
* Copyright (c) 1995 Matt Thomas (thomas@lkg.dec.com)
* All rights reserved.
*
* 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. The name of the author may not be used to endorse or promote products
* derived from this software withough specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
/*
* DEC PDQ FDDI Controller; code for BSD derived operating systems
*
* Written by Matt Thomas
*
* Network interface subroutines.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/mbuf.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#ifdef __NetBSD__
#include <sys/device.h>
#endif
#include <net/if.h>
#include <net/if_types.h>
#include <net/if_dl.h>
#include <net/route.h>
#include "bpfilter.h"
#if NBPFILTER > 0
#include <net/bpf.h>
#include <net/bpfdesc.h>
#endif
#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#endif
#ifdef __NetBSD__
#include <net/if_fddi.h>
#else
#include <netinet/if_fddi.h>
#endif /* __NetBSD__ */
#ifdef NS
#include <netns/ns.h>
#include <netns/ns_if.h>
#endif
#include <vm/vm.h>
#include <vm/vm_kern.h>
#include <dev/ic/pdqreg.h>
#include <dev/ic/pdqvar.h>
void
pdq_ifinit(
pdq_softc_t *sc)
{
if (sc->sc_if.if_flags & IFF_UP) {
sc->sc_if.if_flags |= IFF_RUNNING;
if (sc->sc_if.if_flags & IFF_PROMISC) {
sc->sc_pdq->pdq_flags |= PDQ_PROMISC;
} else {
sc->sc_pdq->pdq_flags &= ~PDQ_PROMISC;
}
if (sc->sc_if.if_flags & IFF_ALLMULTI) {
sc->sc_pdq->pdq_flags |= PDQ_ALLMULTI;
} else {
sc->sc_pdq->pdq_flags &= ~PDQ_ALLMULTI;
}
if (sc->sc_if.if_flags & IFF_LINK1) {
sc->sc_pdq->pdq_flags |= PDQ_PASS_SMT;
} else {
sc->sc_pdq->pdq_flags &= ~PDQ_PASS_SMT;
}
sc->sc_pdq->pdq_flags |= PDQ_RUNNING;
pdq_run(sc->sc_pdq);
} else {
sc->sc_if.if_flags &= ~IFF_RUNNING;
sc->sc_pdq->pdq_flags &= ~PDQ_RUNNING;
pdq_stop(sc->sc_pdq);
}
}
void
pdq_ifwatchdog(
pdq_softc_t *sc)
{
struct mbuf *m;
/*
* No progress was made on the transmit queue for PDQ_OS_TX_TRANSMIT
* seconds. Remove all queued packets.
*/
sc->sc_if.if_flags &= ~IFF_OACTIVE;
sc->sc_if.if_timer = 0;
for (;;) {
IF_DEQUEUE(&sc->sc_if.if_snd, m);
if (m == NULL)
return;
m_freem(m);
}
}
ifnet_ret_t
pdq_ifstart(
struct ifnet *ifp)
{
pdq_softc_t *sc = (pdq_softc_t *) ((caddr_t) ifp - offsetof(pdq_softc_t, sc_ac.ac_if));
struct ifqueue *ifq = &ifp->if_snd;
struct mbuf *m;
int tx = 0;
if ((ifp->if_flags & IFF_RUNNING) == 0)
return;
if (sc->sc_if.if_timer == 0)
sc->sc_if.if_timer = PDQ_OS_TX_TIMEOUT;
if ((sc->sc_pdq->pdq_flags & PDQ_TXOK) == 0) {
sc->sc_if.if_flags |= IFF_OACTIVE;
return;
}
for (;; tx = 1) {
IF_DEQUEUE(ifq, m);
if (m == NULL)
break;
if (pdq_queue_transmit_data(sc->sc_pdq, m) == PDQ_FALSE) {
ifp->if_flags |= IFF_OACTIVE;
IF_PREPEND(ifq, m);
break;
}
}
if (tx)
PDQ_DO_TYPE2_PRODUCER(sc->sc_pdq);
}
void
pdq_os_receive_pdu(
pdq_t *pdq,
struct mbuf *m,
size_t pktlen)
{
pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
struct fddi_header *fh = mtod(m, struct fddi_header *);
sc->sc_if.if_ipackets++;
#if NBPFILTER > 0
if (sc->sc_bpf != NULL)
bpf_mtap(sc->sc_bpf, m);
if ((fh->fddi_fc & (FDDIFC_L|FDDIFC_F)) != FDDIFC_LLC_ASYNC) {
m_freem(m);
return;
}
#endif
m->m_data += sizeof(struct fddi_header);
m->m_len -= sizeof(struct fddi_header);
m->m_pkthdr.len = pktlen - sizeof(struct fddi_header);
m->m_pkthdr.rcvif = &sc->sc_if;
fddi_input(&sc->sc_if, fh, m);
}
void
pdq_os_restart_transmitter(
pdq_t *pdq)
{
pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
sc->sc_if.if_flags &= ~IFF_OACTIVE;
if (sc->sc_if.if_snd.ifq_head != NULL) {
sc->sc_if.if_timer = PDQ_OS_TX_TIMEOUT;
pdq_ifstart(&sc->sc_if);
} else {
sc->sc_if.if_timer = 0;
}
}
void
pdq_os_transmit_done(
pdq_t *pdq,
struct mbuf *m)
{
pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
#if NBPFILTER > 0
if (sc->sc_bpf != NULL)
bpf_mtap(sc->sc_bpf, m);
#endif
m_freem(m);
sc->sc_if.if_opackets++;
}
void
pdq_os_addr_fill(
pdq_t *pdq,
pdq_lanaddr_t *addr,
size_t num_addrs)
{
pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
struct ether_multistep step;
struct ether_multi *enm;
ETHER_FIRST_MULTI(step, &sc->sc_ac, enm);
while (enm != NULL && num_addrs > 0) {
((u_short *) addr->lanaddr_bytes)[0] = ((u_short *) enm->enm_addrlo)[0];
((u_short *) addr->lanaddr_bytes)[1] = ((u_short *) enm->enm_addrlo)[1];
((u_short *) addr->lanaddr_bytes)[2] = ((u_short *) enm->enm_addrlo)[2];
ETHER_NEXT_MULTI(step, enm);
addr++;
num_addrs--;
}
}
int
pdq_ifioctl(
#ifdef __NetBSD__
pdq_softc_t *sc,
#else
struct ifnet *ifp,
#endif /* __NetBSD__ */
ioctl_cmd_t cmd,
caddr_t data)
{
#ifdef __NetBSD__
struct ifnet *ifp = &sc->sc_if;
#else
pdq_softc_t *sc = (pdq_softc_t *) ((caddr_t) ifp - offsetof(pdq_softc_t, sc_ac.ac_if));
#endif /* __NetBSD__ */
int s, error = 0;
s = splimp();
switch (cmd) {
case SIOCSIFADDR: {
struct ifaddr *ifa = (struct ifaddr *)data;
ifp->if_flags |= IFF_UP;
switch(ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET: {
#ifdef __NetBSD__
(*sc->if_init)(ifp->if_unit);
arp_ifinit(&sc->sc_ac, ifa);
#else /* ! __NetBSD__ */
((struct arpcom *)ifp)->ac_ipaddr = IA_SIN(ifa)->sin_addr;
(*sc->if_init)(ifp->if_unit);
#ifdef __FreeBSD__
arp_ifinit((struct arpcom *)ifp, ifa);
#else /* ! __FreeBSD__ */
arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
#endif /* __FreeBSD__ */
#endif /* __NetBSD__ */
break;
}
#endif /* INET */
#ifdef NS
/* This magic copied from if_is.c; I don't use XNS,
* so I have no way of telling if this actually
* works or not.
*/
case AF_NS: {
struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
if (ns_nullhost(*ina)) {
ina->x_host = *(union ns_host *)(sc->sc_ac.ac_enaddr);
} else {
ifp->if_flags &= ~IFF_RUNNING;
bcopy((caddr_t)ina->x_host.c_host,
(caddr_t)sc->sc_ac.ac_enaddr,
sizeof sc->sc_ac.ac_enaddr);
}
(*sc->if_init)(ifp->if_unit);
break;
}
#endif /* NS */
default: {
(*sc->if_init)(ifp->if_unit);
break;
}
}
break;
}
case SIOCSIFFLAGS: {
(*sc->if_init)(ifp->if_unit);
break;
}
case SIOCADDMULTI:
case SIOCDELMULTI: {
/*
* Update multicast listeners
*/
if (cmd == SIOCADDMULTI)
error = ether_addmulti((struct ifreq *)data, &sc->sc_ac);
else
error = ether_delmulti((struct ifreq *)data, &sc->sc_ac);
if (error == ENETRESET) {
if (sc->sc_if.if_flags & IFF_RUNNING)
pdq_run(sc->sc_pdq);
error = 0;
}
break;
}
default: {
error = EINVAL;
break;
}
}
splx(s);
return error;
}
void
pdq_ifattach(
pdq_softc_t *sc,
ifnet_ret_t (*ifinit)(int unit),
#ifdef __NetBSD__
ifnet_ret_t (*ifwatchdog)(int unit),
int (*ifioctl)(struct ifnet *ifp, ioctl_cmd_t cmd, caddr_t data))
#else
ifnet_ret_t (*ifwatchdog)(int unit))
#endif /* __NetBSD__ */
{
struct ifnet *ifp = &sc->sc_if;
ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST;
sc->if_init = ifinit;
ifp->if_watchdog = ifwatchdog;
#ifdef __NetBSD__
ifp->if_ioctl = ifioctl;
#else
ifp->if_ioctl = pdq_ifioctl;
#endif /* __NetBSD__ */
ifp->if_output = fddi_output;
ifp->if_start = pdq_ifstart;
if_attach(ifp);
fddi_ifattach(ifp);
#if NBPFILTER > 0
bpfattach(&sc->sc_bpf, ifp, DLT_FDDI, sizeof(struct fddi_header));
#endif
}

10
sys/dev/ic/pdqvar.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: pdqvar.h,v 1.2 1995/08/19 04:35:22 cgd Exp $ */
/* $NetBSD: pdqvar.h,v 1.3 1996/03/09 03:46:24 thorpej Exp $ */
/*-
* Copyright (c) 1995 Matt Thomas (thomas@lkg.dec.com)
@ -95,6 +95,7 @@ typedef struct {
void *sc_ats; /* shutdown hook */
#endif
struct arpcom sc_ac;
void (*if_init) __P((int unit));
pdq_t *sc_pdq;
unsigned sc_iobase;
} pdq_softc_t;
@ -106,9 +107,16 @@ extern void pdq_ifreset(pdq_softc_t *sc);
extern void pdq_ifinit(pdq_softc_t *sc);
extern void pdq_ifwatchdog(pdq_softc_t *sc);
extern ifnet_ret_t pdq_ifstart(struct ifnet *ifp);
#ifdef __NetBSD__
extern int pdq_ifioctl(pdq_softc_t *sc, ioctl_cmd_t cmd, caddr_t data);
extern void pdq_ifattach(pdq_softc_t *sc, ifnet_ret_t (*ifinit)(int unit),
ifnet_ret_t (*ifwatchdog)(int unit),
int (*ifioctl)(struct ifnet *, ioctl_cmd_t, caddr_t));
#else /* ! __NetBSD__ */
extern int pdq_ifioctl(struct ifnet *ifp, ioctl_cmd_t cmd, caddr_t data);
extern void pdq_ifattach(pdq_softc_t *sc, ifnet_ret_t (*ifinit)(int unit),
ifnet_ret_t (*ifwatchdog)(int unit));
#endif /* __NetBSD__ */
#endif /* PDQ_HWSUPPORT */
#elif defined(DLPI_PDQ)
#include <sys/param.h>

15
sys/dev/pci/if_fpa.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: if_fpa.c,v 1.3 1995/12/24 02:32:17 mycroft Exp $ */
/* $NetBSD: if_fpa.c,v 1.4 1996/03/09 03:46:33 thorpej Exp $ */
/*-
* Copyright (c) 1995 Matt Thomas (thomas@lkg.dec.com)
@ -145,6 +145,17 @@ pdq_pci_ifwatchdog(
pdq_ifwatchdog(PDQ_PCI_UNIT_TO_SOFTC(unit));
}
#ifdef __NetBSD__
static int
pdq_pci_ifioctl(
struct ifnet *ifp,
ioctl_cmd_t cmd,
caddr_t data)
{
return (pdq_ifioctl(PDQ_PCI_UNIT_TO_SOFTC(ifp->if_unit), cmd, data));
}
#endif /* __NetBSD__ */
static int
pdq_pci_ifintr(
void *arg)
@ -387,7 +398,7 @@ pdq_pci_attach(
if (sc->sc_pdq == NULL)
return;
bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
pdq_ifattach(sc, pdq_pci_ifinit, pdq_pci_ifwatchdog);
pdq_ifattach(sc, pdq_pci_ifinit, pdq_pci_ifwatchdog, pdq_pci_ifioctl);
sc->sc_ih = pci_map_int(pa->pa_tag, IPL_NET, pdq_pci_ifintr, sc);
if (sc->sc_ih == NULL) {