/* $NetBSD: if_le.c,v 1.32 1999/01/10 12:56:25 tron Exp $ */ /*- * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace * Simulation Facility, NASA Ames Research Center. * * 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. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * 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. */ /*- * Copyright (c) 1997 Bernd Ernesti. All rights reserved. * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Ralph Campbell and Rick Macklem. * * 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. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed for the NetBSD Project * by Bernd Ernesti. * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. * * @(#)if_le.c 8.2 (Berkeley) 11/16/93 */ #include "opt_inet.h" #include "bpfilter.h" #include #include #include #include #include #include #include #include #include #ifdef INET #include #include #endif #include #include #include #include #include #include #include #include #include #include int le_zbus_match __P((struct device *, struct cfdata *, void *)); void le_zbus_attach __P((struct device *, struct device *, void *)); struct cfattach le_zbus_ca = { sizeof(struct le_softc), le_zbus_match, le_zbus_attach }; #if defined(_KERNEL) && !defined(_LKM) #include "opt_ddb.h" #endif #ifdef DDB #define integrate #define hide #else #define integrate static __inline #define hide static #endif hide void lepcnet_reset __P((struct lance_softc *)); hide void lewrcsr __P((struct lance_softc *, u_int16_t, u_int16_t)); hide u_int16_t lerdcsr __P((struct lance_softc *, u_int16_t)); hide u_int16_t ariadne_swapreg __P((u_int16_t)); hide void ariadne_wrcsr __P((struct lance_softc *, u_int16_t, u_int16_t)); hide u_int16_t ariadne_rdcsr __P((struct lance_softc *, u_int16_t)); hide void ariadne_wribcr __P((struct lance_softc *, u_int16_t, u_int16_t)); integrate void ariadne_copytodesc_word __P((struct lance_softc *, void *, int, int)); integrate void ariadne_copyfromdesc_word __P((struct lance_softc *, void *, int, int)); integrate void ariadne_copytobuf_word __P((struct lance_softc *, void *, int, int)); integrate void ariadne_copyfrombuf_word __P((struct lance_softc *, void *, int, int)); integrate void ariadne_zerobuf_word __P((struct lance_softc *, int, int)); void ariadne_autoselect __P((struct lance_softc *, int)); int ariadne_mediachange __P((struct lance_softc *)); void ariadne_hwinit __P((struct lance_softc *)); /* * Media types supported by the Ariadne. */ int lemedia_ariadne[] = { IFM_ETHER | IFM_10_T, IFM_ETHER | IFM_10_2, IFM_ETHER | IFM_AUTO, }; #define NLEMEDIA_ARIADNE (sizeof(lemedia_ariadne) / sizeof(lemedia_ariadne[0])) hide u_int16_t ariadne_swapreg(val) u_int16_t val; { return (((val & 0xff) << 8 ) | (( val >> 8) & 0xff)); } hide void ariadne_wrcsr(sc, port, val) struct lance_softc *sc; u_int16_t port, val; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; ler1->ler1_rap = ariadne_swapreg(port); ler1->ler1_rdp = ariadne_swapreg(val); } hide u_int16_t ariadne_rdcsr(sc, port) struct lance_softc *sc; u_int16_t port; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; u_int16_t val; ler1->ler1_rap = ariadne_swapreg(port); val = ariadne_swapreg(ler1->ler1_rdp); return (val); } hide void ariadne_wribcr(sc, port, val) struct lance_softc *sc; u_int16_t port, val; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; ler1->ler1_rap = ariadne_swapreg(port); ler1->ler1_idp = ariadne_swapreg(val); } hide void lewrcsr(sc, port, val) struct lance_softc *sc; u_int16_t port, val; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; ler1->ler1_rap = port; ler1->ler1_rdp = val; } hide u_int16_t lerdcsr(sc, port) struct lance_softc *sc; u_int16_t port; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; u_int16_t val; ler1->ler1_rap = port; val = ler1->ler1_rdp; return (val); } hide void lepcnet_reset(sc) struct lance_softc *sc; { struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1; volatile int dummy; dummy = ler1->ler1_reset; /* Reset PCNet-ISA */ } void ariadne_autoselect(sc, on) struct lance_softc *sc; int on; { /* * on = 0: autoselect disabled * on = 1: autoselect enabled */ if (on == 0) ariadne_wribcr(sc, LE_BCR_MC, 0x0000); else ariadne_wribcr(sc, LE_BCR_MC, LE_MC_ASEL); } int ariadne_mediachange(sc) struct lance_softc *sc; { struct ifmedia *ifm = &sc->sc_media; if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) return (EINVAL); /* * Switch to the selected media. If autoselect is * set, switch it on otherwise disable it. We'll * switch to the other media when we detect loss of * carrier. */ switch (IFM_SUBTYPE(ifm->ifm_media)) { case IFM_10_T: sc->sc_initmodemedia = 1; lance_init(sc); break; case IFM_10_2: sc->sc_initmodemedia = 0; lance_init(sc); break; case IFM_AUTO: sc->sc_initmodemedia = 2; ariadne_hwinit(sc); break; default: return (EINVAL); } return (0); } void ariadne_hwinit(sc) struct lance_softc *sc; { /* * Re-program LEDs to match meaning used on the Ariadne board. */ ariadne_wribcr(sc, LE_BCR_LED1, 0x0090); ariadne_wribcr(sc, LE_BCR_LED2, 0x0081); ariadne_wribcr(sc, LE_BCR_LED3, 0x0084); /* * Enabel/Disable auto selection */ if (sc->sc_initmodemedia == 2) ariadne_autoselect(sc, 1); else ariadne_autoselect(sc, 0); } int le_zbus_match(parent, cfp, aux) struct device *parent; struct cfdata *cfp; void *aux; { struct zbus_args *zap = aux; /* Commodore ethernet card */ if (zap->manid == 514 && zap->prodid == 112) return (1); /* Ameristar ethernet card */ if (zap->manid == 1053 && zap->prodid == 1) return (1); /* Ariadne ethernet card */ if (zap->manid == 2167 && zap->prodid == 201) return (1); return (0); } void le_zbus_attach(parent, self, aux) struct device *parent, *self; void *aux; { struct le_softc *lesc = (struct le_softc *)self; struct lance_softc *sc = &lesc->sc_am7990.lsc; struct zbus_args *zap = aux; u_long ser; /* This has no effect on PCnet-ISA LANCE chips */ sc->sc_conf3 = LE_C3_BSWP; /* * Manufacturer decides the 3 first bytes, i.e. ethernet vendor ID. */ switch (zap->manid) { case 514: /* Commodore */ sc->sc_memsize = 32768; sc->sc_enaddr[0] = 0x00; sc->sc_enaddr[1] = 0x80; sc->sc_enaddr[2] = 0x10; lesc->sc_r1 = (struct lereg1 *)(0x4000 + (int)zap->va); sc->sc_mem = (void *)(0x8000 + (int)zap->va); sc->sc_addr = 0x8000; sc->sc_copytodesc = lance_copytobuf_contig; sc->sc_copyfromdesc = lance_copyfrombuf_contig; sc->sc_copytobuf = lance_copytobuf_contig; sc->sc_copyfrombuf = lance_copyfrombuf_contig; sc->sc_zerobuf = lance_zerobuf_contig; sc->sc_rdcsr = lerdcsr; sc->sc_wrcsr = lewrcsr; sc->sc_hwreset = NULL; sc->sc_hwinit = NULL; break; case 1053: /* Ameristar */ sc->sc_memsize = 32768; sc->sc_enaddr[0] = 0x00; sc->sc_enaddr[1] = 0x00; sc->sc_enaddr[2] = 0x9f; lesc->sc_r1 = (struct lereg1 *)(0x4000 + (int)zap->va); sc->sc_mem = (void *)(0x8000 + (int)zap->va); sc->sc_addr = 0x8000; sc->sc_copytodesc = lance_copytobuf_contig; sc->sc_copyfromdesc = lance_copyfrombuf_contig; sc->sc_copytobuf = lance_copytobuf_contig; sc->sc_copyfrombuf = lance_copyfrombuf_contig; sc->sc_zerobuf = lance_zerobuf_contig; sc->sc_rdcsr = lerdcsr; sc->sc_wrcsr = lewrcsr; sc->sc_hwreset = NULL; sc->sc_hwinit = NULL; break; case 2167: /* Village Tronic */ sc->sc_memsize = 32768; sc->sc_enaddr[0] = 0x00; sc->sc_enaddr[1] = 0x60; sc->sc_enaddr[2] = 0x30; lesc->sc_r1 = (struct lereg1 *)(0x0370 + (int)zap->va); sc->sc_mem = (void *)(0x8000 + (int)zap->va); sc->sc_addr = 0x8000; sc->sc_copytodesc = ariadne_copytodesc_word; sc->sc_copyfromdesc = ariadne_copyfromdesc_word; sc->sc_copytobuf = ariadne_copytobuf_word; sc->sc_copyfrombuf = ariadne_copyfrombuf_word; sc->sc_zerobuf = ariadne_zerobuf_word; sc->sc_rdcsr = ariadne_rdcsr; sc->sc_wrcsr = ariadne_wrcsr; sc->sc_hwreset = lepcnet_reset; sc->sc_hwinit = ariadne_hwinit; sc->sc_mediachange = ariadne_mediachange; sc->sc_supmedia = lemedia_ariadne; sc->sc_nsupmedia = NLEMEDIA_ARIADNE; sc->sc_defaultmedia = IFM_ETHER | IFM_AUTO; sc->sc_initmodemedia = 2; break; default: panic("le_zbus_attach: bad manid"); } /* * Serial number for board is used as host ID. */ ser = (u_long)zap->serno; sc->sc_enaddr[3] = (ser >> 16) & 0xff; sc->sc_enaddr[4] = (ser >> 8) & 0xff; sc->sc_enaddr[5] = (ser ) & 0xff; am7990_config(&lesc->sc_am7990); lesc->sc_isr.isr_intr = am7990_intr; lesc->sc_isr.isr_arg = sc; lesc->sc_isr.isr_ipl = 2; add_isr(&lesc->sc_isr); } integrate void ariadne_copytodesc_word(sc, from, boff, len) struct lance_softc *sc; void *from; int boff, len; { u_short *b1 = from; volatile u_short *b2 = (u_short *)((u_char *)sc->sc_mem + boff); for (len >>= 1; len > 0; len--) *b2++ = ariadne_swapreg(*b1++); } integrate void ariadne_copyfromdesc_word(sc, to, boff, len) struct lance_softc *sc; void *to; int boff, len; { volatile u_short *b1 = (u_short *)((u_char *)sc->sc_mem + boff); u_short *b2 = to; for (len >>= 1; len > 0; len--) *b2++ = ariadne_swapreg(*b1++); } #define isodd(n) ((n) & 1) integrate void ariadne_copytobuf_word(sc, from, boff, len) struct lance_softc *sc; void *from; int boff, len; { u_char *a1 = from; volatile u_char *a2 = (u_char *)sc->sc_mem + boff; u_short *b1; volatile u_short *b2; int i; if (len > 0 && isodd(boff)) { /* adjust source pointer */ b1 = (u_short *)(a1 + 1); /* compute aligned destination pointer */ b2 = (u_short *)(a2 + 1); /* copy first unaligned byte to buf */ b2[-1] = (b2[-1] & 0xff00) | *a1; --len; } else { /* destination is aligned or length is zero */ b1 = (u_short *)a1; b2 = (u_short *)a2; } /* copy full words with aligned destination */ for (i = len >> 1; i > 0; i--) *b2++ = *b1++; /* copy remaining byte */ if (isodd(len)) *b2 = (*b2 & 0x00ff) | (*(u_char *)b1) << 8; } integrate void ariadne_copyfrombuf_word(sc, to, boff, len) struct lance_softc *sc; void *to; int boff, len; { volatile u_char *a1 = (u_char *)sc->sc_mem + boff; u_char *a2 = to; volatile u_short *b1; u_short *b2; int i; if (len > 0 && isodd(boff)) { /* compute aligned source pointer */ b1 = (u_short *)(a1 + 1); /* adjust destination pointer (possibly unaligned) */ b2 = (u_short *)(a2 + 1); /* copy first unaligned byte from buf */ *a2 = b1[-1]; --len; } else { /* source is aligned or length is zero */ b1 = (u_short *)a1; b2 = (u_short *)a2; } /* copy full words with aligned source */ for (i = len >> 1; i > 0; i--) *b2++ = *b1++; /* copy remaining byte */ if (isodd(len)) *(u_char *)b2 = *b1 >> 8; } integrate void ariadne_zerobuf_word(sc, boff, len) struct lance_softc *sc; int boff, len; { volatile u_char *a1 = (u_char *)sc->sc_mem + boff; volatile u_short *b1; int i; if (len > 0 && isodd(boff)) { b1 = (u_short *)(a1 + 1); b1[-1] &= 0xff00; --len; } else { b1 = (u_short *)a1; } for (i = len >> 1; i > 0; i--) *b1++ = 0; if (isodd(len)) *b1 &= 0x00ff; }