Annotation of sys/dev/pci/if_de.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_de.c,v 1.97 2007/02/14 00:53:48 jsg Exp $ */
! 2: /* $NetBSD: if_de.c,v 1.58 1998/01/12 09:39:58 thorpej Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1994-1997 Matt Thomas (matt@3am-software.com)
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. The name of the author may not be used to endorse or promote products
! 14: * derived from this software without specific prior written permission
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 19: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 26: *
! 27: * Id: if_de.c,v 1.89 1997/06/03 19:19:55 thomas Exp
! 28: *
! 29: */
! 30:
! 31: /*
! 32: * DEC 21040 PCI Ethernet Controller
! 33: *
! 34: * Written by Matt Thomas
! 35: * BPF support code stolen directly from if_ec.c
! 36: *
! 37: * This driver supports the DEC DE435 or any other PCI
! 38: * board which support 21040, 21041, or 21140 (mostly).
! 39: */
! 40:
! 41: #include <sys/param.h>
! 42: #include <sys/systm.h>
! 43: #include <sys/mbuf.h>
! 44: #include <sys/protosw.h>
! 45: #include <sys/socket.h>
! 46: #include <sys/ioctl.h>
! 47: #include <sys/errno.h>
! 48: #include <sys/malloc.h>
! 49: #include <sys/kernel.h>
! 50: #include <sys/proc.h> /* only for declaration of wakeup() used by vm.h */
! 51: #include <sys/device.h>
! 52: #include <sys/timeout.h>
! 53:
! 54: #include <net/if.h>
! 55: #include <net/if_media.h>
! 56: #include <net/if_types.h>
! 57: #include <net/if_dl.h>
! 58: #include <net/route.h>
! 59: #include <net/netisr.h>
! 60:
! 61: #include "bpfilter.h"
! 62: #if NBPFILTER > 0
! 63: #include <net/bpf.h>
! 64: #endif
! 65:
! 66: #ifdef INET
! 67: #include <netinet/in.h>
! 68: #include <netinet/in_systm.h>
! 69: #include <netinet/in_var.h>
! 70: #include <netinet/ip.h>
! 71: #endif
! 72:
! 73: #include <netinet/if_ether.h>
! 74:
! 75: #include <machine/bus.h>
! 76: #include <machine/intr.h>
! 77: #include <dev/pci/pcireg.h>
! 78: #include <dev/pci/pcivar.h>
! 79: #include <dev/pci/pcidevs.h>
! 80: #include <dev/ic/dc21040reg.h>
! 81:
! 82: /*
! 83: * Intel CPUs should use I/O mapped access.
! 84: */
! 85: #if defined(__i386__)
! 86: #define TULIP_IOMAPPED
! 87: #endif
! 88:
! 89: #define TULIP_HZ 10
! 90:
! 91: #define TULIP_SIAGEN_WATCHDOG 0
! 92:
! 93: #define TULIP_GPR_CMDBITS (TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION|TULIP_CMD_SCRAMBLER|TULIP_CMD_TXTHRSHLDCTL)
! 94:
! 95: #define EMIT do { TULIP_CSR_WRITE(sc, csr_srom_mii, csr); tulip_delay_300ns(sc); } while (0)
! 96: #define MII_EMIT do { TULIP_CSR_WRITE(sc, csr_srom_mii, csr); tulip_delay_300ns(sc); } while (0)
! 97:
! 98: #define tulip_mchash(mca) (ether_crc32_le(mca, 6) & 0x1FF)
! 99: #define tulip_srom_crcok(databuf) ( \
! 100: ((ether_crc32_le(databuf, 126) & 0xFFFFU) ^ 0xFFFFU) == \
! 101: ((databuf)[126] | ((databuf)[127] << 8)))
! 102:
! 103: /*
! 104: * This is the PCI configuration support. Since the 21040 is available
! 105: * on both EISA and PCI boards, one must be careful in how defines the
! 106: * 21040 in the config file.
! 107: */
! 108:
! 109: #define PCI_CFID 0x00 /* Configuration ID */
! 110: #define PCI_CFCS 0x04 /* Configurtion Command/Status */
! 111: #define PCI_CFRV 0x08 /* Configuration Revision */
! 112: #define PCI_CFLT 0x0c /* Configuration Latency Timer */
! 113: #define PCI_CBIO 0x10 /* Configuration Base IO Address */
! 114: #define PCI_CBMA 0x14 /* Configuration Base Memory Address */
! 115: #define PCI_CFIT 0x3c /* Configuration Interrupt */
! 116: #define PCI_CFDA 0x40 /* Configuration Driver Area */
! 117:
! 118: #define PCI_CONF_WRITE(r, v) pci_conf_write(pa->pa_pc, pa->pa_tag, (r), (v))
! 119: #define PCI_CONF_READ(r) pci_conf_read(pa->pa_pc, pa->pa_tag, (r))
! 120: #define PCI_GETBUSDEVINFO(sc) do { \
! 121: (sc)->tulip_pci_busno = parent; \
! 122: (sc)->tulip_pci_devno = pa->pa_device; \
! 123: } while (0)
! 124:
! 125: #include <dev/pci/if_devar.h>
! 126: /*
! 127: * This module supports
! 128: * the DEC 21040 PCI Ethernet Controller.
! 129: * the DEC 21041 PCI Ethernet Controller.
! 130: * the DEC 21140 PCI Fast Ethernet Controller.
! 131: */
! 132: int tulip_probe(struct device *parent, void *match, void *aux);
! 133: void tulip_attach(struct device * const parent, struct device * const self, void * const aux);
! 134:
! 135: struct cfattach de_ca = {
! 136: sizeof(tulip_softc_t), tulip_probe, tulip_attach
! 137: };
! 138:
! 139: struct cfdriver de_cd = {
! 140: 0, "de", DV_IFNET
! 141: };
! 142:
! 143: void tulip_timeout_callback(void *arg);
! 144: void tulip_timeout(tulip_softc_t * const sc);
! 145: int tulip_txprobe(tulip_softc_t * const sc);
! 146: void tulip_media_set(tulip_softc_t * const sc, tulip_media_t media);
! 147: void tulip_linkup(tulip_softc_t * const sc, tulip_media_t media);
! 148: void tulip_media_print(tulip_softc_t * const sc);
! 149: tulip_link_status_t tulip_media_link_monitor(tulip_softc_t * const sc);
! 150: void tulip_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event);
! 151: void tulip_media_select(tulip_softc_t * const sc);
! 152:
! 153: void tulip_21040_mediainfo_init(tulip_softc_t * const sc, tulip_media_t media);
! 154: void tulip_21040_media_probe(tulip_softc_t * const sc);
! 155: void tulip_21040_10baset_only_media_probe(tulip_softc_t * const sc);
! 156: void tulip_21040_10baset_only_media_select(tulip_softc_t * const sc);
! 157: void tulip_21040_auibnc_only_media_probe(tulip_softc_t * const sc);
! 158: void tulip_21040_auibnc_only_media_select(tulip_softc_t * const sc);
! 159:
! 160: void tulip_21041_mediainfo_init(tulip_softc_t * const sc);
! 161: void tulip_21041_media_noprobe(tulip_softc_t * const sc);
! 162: void tulip_21041_media_probe(tulip_softc_t * const sc);
! 163: void tulip_21041_media_poll(tulip_softc_t * const sc, const tulip_mediapoll_event_t event);
! 164:
! 165: tulip_media_t tulip_mii_phy_readspecific(tulip_softc_t * const sc);
! 166: unsigned tulip_mii_get_phyaddr(tulip_softc_t * const sc, unsigned offset);
! 167: int tulip_mii_map_abilities(tulip_softc_t * const sc, unsigned abilities);
! 168: void tulip_mii_autonegotiate(tulip_softc_t * const sc, const unsigned phyaddr);
! 169:
! 170: void tulip_2114x_media_preset(tulip_softc_t * const sc);
! 171:
! 172: void tulip_null_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event);
! 173:
! 174: void tulip_21140_mediainit(tulip_softc_t * const sc, tulip_media_info_t * const mip,
! 175: tulip_media_t const media, unsigned gpdata, unsigned cmdmode);
! 176: void tulip_21140_evalboard_media_probe(tulip_softc_t * const sc);
! 177: void tulip_21140_accton_media_probe(tulip_softc_t * const sc);
! 178: void tulip_21140_smc9332_media_probe(tulip_softc_t * const sc);
! 179: void tulip_21140_cogent_em100_media_probe(tulip_softc_t * const sc);
! 180: void tulip_21140_znyx_zx34x_media_probe(tulip_softc_t * const sc);
! 181:
! 182: void tulip_2114x_media_probe(tulip_softc_t * const sc);
! 183:
! 184: void tulip_delay_300ns(tulip_softc_t * const sc);
! 185: void tulip_srom_idle(tulip_softc_t * const sc);
! 186: void tulip_srom_read(tulip_softc_t * const sc);
! 187: void tulip_mii_writebits(tulip_softc_t * const sc, unsigned data, unsigned bits);
! 188: void tulip_mii_turnaround(tulip_softc_t * const sc, unsigned cmd);
! 189: unsigned tulip_mii_readbits(tulip_softc_t * const sc);
! 190: unsigned tulip_mii_readreg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno);
! 191: void tulip_mii_writereg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno,
! 192: unsigned data);
! 193:
! 194: void tulip_identify_dec_nic(tulip_softc_t * const sc);
! 195: void tulip_identify_znyx_nic(tulip_softc_t * const sc);
! 196: void tulip_identify_smc_nic(tulip_softc_t * const sc);
! 197: void tulip_identify_cogent_nic(tulip_softc_t * const sc);
! 198: void tulip_identify_accton_nic(tulip_softc_t * const sc);
! 199: void tulip_identify_asante_nic(tulip_softc_t * const sc);
! 200: void tulip_identify_compex_nic(tulip_softc_t * const sc);
! 201:
! 202: int tulip_srom_decode(tulip_softc_t * const sc);
! 203: int tulip_read_macaddr(tulip_softc_t * const sc);
! 204: void tulip_ifmedia_add(tulip_softc_t * const sc);
! 205: int tulip_ifmedia_change(struct ifnet * const ifp);
! 206: void tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req);
! 207: void tulip_addr_filter(tulip_softc_t * const sc);
! 208: void tulip_reset(tulip_softc_t * const sc);
! 209: void tulip_init(tulip_softc_t * const sc);
! 210: void tulip_rx_intr(tulip_softc_t * const sc);
! 211: int tulip_tx_intr(tulip_softc_t * const sc);
! 212: void tulip_print_abnormal_interrupt(tulip_softc_t * const sc, u_int32_t csr);
! 213: void tulip_intr_handler(tulip_softc_t * const sc, int *progress_p);
! 214: int tulip_intr_shared(void *arg);
! 215: int tulip_intr_normal(void *arg);
! 216: struct mbuf *tulip_mbuf_compress(struct mbuf *m);
! 217: struct mbuf *tulip_txput(tulip_softc_t * const sc, struct mbuf *m);
! 218: void tulip_txput_setup(tulip_softc_t * const sc);
! 219: int tulip_ifioctl(struct ifnet * ifp, u_long cmd, caddr_t data);
! 220: void tulip_ifstart(struct ifnet *ifp);
! 221: void tulip_ifstart_one(struct ifnet *ifp);
! 222: void tulip_ifwatchdog(struct ifnet *ifp);
! 223: int tulip_busdma_allocmem(tulip_softc_t * const sc, size_t size,
! 224: bus_dmamap_t *map_p, tulip_desc_t **desc_p);
! 225: int tulip_busdma_init(tulip_softc_t * const sc);
! 226: void tulip_initcsrs(tulip_softc_t * const sc, bus_addr_t csr_base, size_t csr_size);
! 227: void tulip_initring(tulip_softc_t * const sc, tulip_ringinfo_t * const ri,
! 228: tulip_desc_t *descs, int ndescs);
! 229: void tulip_shutdown(void *arg);
! 230:
! 231:
! 232: void
! 233: tulip_timeout_callback(void *arg)
! 234: {
! 235: tulip_softc_t * const sc = arg;
! 236: int s;
! 237:
! 238: s = splnet();
! 239:
! 240: TULIP_PERFSTART(timeout)
! 241:
! 242: sc->tulip_flags &= ~TULIP_TIMEOUTPENDING;
! 243: sc->tulip_probe_timeout -= 1000 / TULIP_HZ;
! 244: (sc->tulip_boardsw->bd_media_poll)(sc, TULIP_MEDIAPOLL_TIMER);
! 245:
! 246: TULIP_PERFEND(timeout);
! 247: splx(s);
! 248: }
! 249:
! 250: void
! 251: tulip_timeout(tulip_softc_t * const sc)
! 252: {
! 253: if (sc->tulip_flags & TULIP_TIMEOUTPENDING)
! 254: return;
! 255: sc->tulip_flags |= TULIP_TIMEOUTPENDING;
! 256: timeout_add(&sc->tulip_stmo, (hz + TULIP_HZ / 2) / TULIP_HZ);
! 257: }
! 258:
! 259: int
! 260: tulip_txprobe(tulip_softc_t * const sc)
! 261: {
! 262: struct mbuf *m;
! 263:
! 264: /*
! 265: * Before we are sure this is the right media we need
! 266: * to send a small packet to make sure there's carrier.
! 267: * Strangely, BNC and AUI will "see" receive data if
! 268: * either is connected so the transmit is the only way
! 269: * to verify the connectivity.
! 270: */
! 271: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 272: if (m == NULL)
! 273: return (0);
! 274: /*
! 275: * Construct a LLC TEST message which will point to ourselves.
! 276: */
! 277: bcopy(sc->tulip_enaddr, mtod(m, struct ether_header *)->ether_dhost,
! 278: ETHER_ADDR_LEN);
! 279: bcopy(sc->tulip_enaddr, mtod(m, struct ether_header *)->ether_shost,
! 280: ETHER_ADDR_LEN);
! 281: mtod(m, struct ether_header *)->ether_type = htons(3);
! 282: mtod(m, unsigned char *)[14] = 0;
! 283: mtod(m, unsigned char *)[15] = 0;
! 284: mtod(m, unsigned char *)[16] = 0xE3; /* LLC Class1 TEST (no poll) */
! 285: m->m_len = m->m_pkthdr.len = sizeof(struct ether_header) + 3;
! 286: /*
! 287: * send it!
! 288: */
! 289: sc->tulip_cmdmode |= TULIP_CMD_TXRUN;
! 290: sc->tulip_intrmask |= TULIP_STS_TXINTR;
! 291: sc->tulip_flags |= TULIP_TXPROBE_ACTIVE;
! 292: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 293: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 294: if ((m = tulip_txput(sc, m)) != NULL)
! 295: m_freem(m);
! 296: sc->tulip_probe.probe_txprobes++;
! 297: return (1);
! 298: }
! 299:
! 300: void
! 301: tulip_media_set(tulip_softc_t * const sc, tulip_media_t media)
! 302: {
! 303: const tulip_media_info_t *mi = sc->tulip_mediums[media];
! 304:
! 305: if (mi == NULL)
! 306: return;
! 307:
! 308: /* Reset the SIA first
! 309: */
! 310: if (mi->mi_type == TULIP_MEDIAINFO_SIA || (sc->tulip_features & TULIP_HAVE_SIANWAY))
! 311: TULIP_CSR_WRITE(sc, csr_sia_connectivity, TULIP_SIACONN_RESET);
! 312:
! 313: /* Next, set full duplex if needed.
! 314: */
! 315: if (sc->tulip_flags & TULIP_FULLDUPLEX) {
! 316: #ifdef TULIP_DEBUG
! 317: if (TULIP_CSR_READ(sc, csr_command) & (TULIP_CMD_RXRUN|TULIP_CMD_TXRUN))
! 318: printf(TULIP_PRINTF_FMT ": warning: board is running (FD).\n", TULIP_PRINTF_ARGS);
! 319: if ((TULIP_CSR_READ(sc, csr_command) & TULIP_CMD_FULLDUPLEX) == 0)
! 320: printf(TULIP_PRINTF_FMT ": setting full duplex.\n", TULIP_PRINTF_ARGS);
! 321: TULIP_PRINTF_ARGS);
! 322: #endif
! 323: sc->tulip_cmdmode |= TULIP_CMD_FULLDUPLEX;
! 324: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode & ~(TULIP_CMD_RXRUN|TULIP_CMD_TXRUN));
! 325: }
! 326:
! 327: /* Now setup the media.
! 328: *
! 329: * If we are switching media, make sure we don't think there's
! 330: * any stale RX activity
! 331: */
! 332: sc->tulip_flags &= ~TULIP_RXACT;
! 333: if (mi->mi_type == TULIP_MEDIAINFO_SIA) {
! 334: TULIP_CSR_WRITE(sc, csr_sia_tx_rx, mi->mi_sia_tx_rx);
! 335: if (sc->tulip_features & TULIP_HAVE_SIAGP) {
! 336: TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_gp_control|mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
! 337: DELAY(50);
! 338: TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_gp_data|mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
! 339: } else
! 340: TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
! 341: TULIP_CSR_WRITE(sc, csr_sia_connectivity, mi->mi_sia_connectivity);
! 342: } else if (mi->mi_type == TULIP_MEDIAINFO_GPR) {
! 343: /*
! 344: * If the cmdmode bits don't match the currently operating mode,
! 345: * set the cmdmode appropriately and reset the chip.
! 346: */
! 347: if (((mi->mi_cmdmode ^ TULIP_CSR_READ(sc, csr_command)) & TULIP_GPR_CMDBITS) != 0) {
! 348: sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
! 349: sc->tulip_cmdmode |= mi->mi_cmdmode;
! 350: tulip_reset(sc);
! 351: }
! 352: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET|sc->tulip_gpinit);
! 353: DELAY(10);
! 354: TULIP_CSR_WRITE(sc, csr_gp, (u_int8_t) mi->mi_gpdata);
! 355: } else if (mi->mi_type == TULIP_MEDIAINFO_SYM) {
! 356: /*
! 357: * If the cmdmode bits don't match the currently operating mode,
! 358: * set the cmdmode appropriately and reset the chip.
! 359: */
! 360: if (((mi->mi_cmdmode ^ TULIP_CSR_READ(sc, csr_command)) & TULIP_GPR_CMDBITS) != 0) {
! 361: sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
! 362: sc->tulip_cmdmode |= mi->mi_cmdmode;
! 363: tulip_reset(sc);
! 364: }
! 365: TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_gpcontrol);
! 366: TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_gpdata);
! 367: } else if (mi->mi_type == TULIP_MEDIAINFO_MII
! 368: && sc->tulip_probe_state != TULIP_PROBE_INACTIVE) {
! 369: int idx;
! 370: if (sc->tulip_features & TULIP_HAVE_SIAGP) {
! 371: const u_int8_t *dp;
! 372: dp = &sc->tulip_rombuf[mi->mi_reset_offset];
! 373: for (idx = 0; idx < mi->mi_reset_length; idx++, dp += 2) {
! 374: DELAY(10);
! 375: TULIP_CSR_WRITE(sc, csr_sia_general, (dp[0] + 256 * dp[1]) << 16);
! 376: }
! 377: sc->tulip_phyaddr = mi->mi_phyaddr;
! 378: dp = &sc->tulip_rombuf[mi->mi_gpr_offset];
! 379: for (idx = 0; idx < mi->mi_gpr_length; idx++, dp += 2) {
! 380: DELAY(10);
! 381: TULIP_CSR_WRITE(sc, csr_sia_general, (dp[0] + 256 * dp[1]) << 16);
! 382: }
! 383: } else {
! 384: for (idx = 0; idx < mi->mi_reset_length; idx++) {
! 385: DELAY(10);
! 386: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_reset_offset + idx]);
! 387: }
! 388: sc->tulip_phyaddr = mi->mi_phyaddr;
! 389: for (idx = 0; idx < mi->mi_gpr_length; idx++) {
! 390: DELAY(10);
! 391: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_gpr_offset + idx]);
! 392: }
! 393: }
! 394:
! 395: if (sc->tulip_features & TULIP_HAVE_SIANWAY) {
! 396: /* Set the SIA port into MII mode */
! 397: TULIP_CSR_WRITE(sc, csr_sia_general, 1);
! 398: TULIP_CSR_WRITE(sc, csr_sia_tx_rx, 0);
! 399: TULIP_CSR_WRITE(sc, csr_sia_status, 0);
! 400: }
! 401:
! 402: if (sc->tulip_flags & TULIP_TRYNWAY)
! 403: tulip_mii_autonegotiate(sc, sc->tulip_phyaddr);
! 404: else if ((sc->tulip_flags & TULIP_DIDNWAY) == 0) {
! 405: u_int32_t data = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_CONTROL);
! 406: data &= ~(PHYCTL_SELECT_100MB|PHYCTL_FULL_DUPLEX|PHYCTL_AUTONEG_ENABLE);
! 407: sc->tulip_flags &= ~TULIP_DIDNWAY;
! 408: if (TULIP_IS_MEDIA_FD(media))
! 409: data |= PHYCTL_FULL_DUPLEX;
! 410: if (TULIP_IS_MEDIA_100MB(media))
! 411: data |= PHYCTL_SELECT_100MB;
! 412: tulip_mii_writereg(sc, sc->tulip_phyaddr, PHYREG_CONTROL, data);
! 413: }
! 414: }
! 415: }
! 416:
! 417: void
! 418: tulip_linkup(tulip_softc_t * const sc, tulip_media_t media)
! 419: {
! 420: if ((sc->tulip_flags & TULIP_LINKUP) == 0)
! 421: sc->tulip_flags |= TULIP_PRINTLINKUP;
! 422: sc->tulip_flags |= TULIP_LINKUP;
! 423: sc->tulip_if.if_flags &= ~IFF_OACTIVE;
! 424: if (sc->tulip_media != media) {
! 425: #ifdef TULIP_DEBUG
! 426: sc->tulip_dbg.dbg_last_media = sc->tulip_media;
! 427: #endif
! 428: sc->tulip_media = media;
! 429: sc->tulip_flags |= TULIP_PRINTMEDIA;
! 430: if (TULIP_IS_MEDIA_FD(sc->tulip_media))
! 431: sc->tulip_flags |= TULIP_FULLDUPLEX;
! 432: else if (sc->tulip_chipid != TULIP_21041 || (sc->tulip_flags & TULIP_DIDNWAY) == 0)
! 433: sc->tulip_flags &= ~TULIP_FULLDUPLEX;
! 434: }
! 435: /*
! 436: * We could set probe_timeout to 0 but setting to 3000 puts this
! 437: * in one central place and the only matters is tulip_link is
! 438: * followed by a tulip_timeout. Therefore setting it should not
! 439: * result in aberrant behavour.
! 440: */
! 441: sc->tulip_probe_timeout = 3000;
! 442: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 443: sc->tulip_flags &= ~(TULIP_TXPROBE_ACTIVE|TULIP_TRYNWAY);
! 444: if (sc->tulip_flags & TULIP_INRESET)
! 445: tulip_media_set(sc, sc->tulip_media);
! 446: else if (sc->tulip_probe_media != sc->tulip_media) {
! 447: /*
! 448: * No reason to change media if we have the right media.
! 449: */
! 450: tulip_reset(sc);
! 451: }
! 452: tulip_init(sc);
! 453: }
! 454:
! 455: void
! 456: tulip_media_print(tulip_softc_t * const sc)
! 457: {
! 458: if ((sc->tulip_flags & TULIP_LINKUP) == 0)
! 459: return;
! 460: if (sc->tulip_flags & TULIP_PRINTMEDIA) {
! 461: #ifdef TULIP_DEBUG
! 462: printf(TULIP_PRINTF_FMT ": enabling %s port\n",
! 463: TULIP_PRINTF_ARGS,
! 464: tulip_mediums[sc->tulip_media]);
! 465: #endif
! 466: sc->tulip_flags &= ~(TULIP_PRINTMEDIA|TULIP_PRINTLINKUP);
! 467: } else if (sc->tulip_flags & TULIP_PRINTLINKUP) {
! 468: #ifdef TULIP_DEBUG
! 469: printf(TULIP_PRINTF_FMT ": link up\n", TULIP_PRINTF_ARGS);
! 470: #endif
! 471: sc->tulip_flags &= ~TULIP_PRINTLINKUP;
! 472: }
! 473: }
! 474:
! 475: tulip_link_status_t
! 476: tulip_media_link_monitor(tulip_softc_t * const sc)
! 477: {
! 478: const tulip_media_info_t * const mi = sc->tulip_mediums[sc->tulip_media];
! 479: tulip_link_status_t linkup = TULIP_LINK_DOWN;
! 480:
! 481: if (mi == NULL) {
! 482: #if defined(TULIP_DEBUG)
! 483: printf("tulip_media_link_monitor: %s: botch at line %d\n",
! 484: tulip_mediums[sc->tulip_media],__LINE__);
! 485: #endif
! 486: return (TULIP_LINK_UNKNOWN);
! 487: }
! 488:
! 489:
! 490: /*
! 491: * Have we seen some packets? If so, the link must be good.
! 492: */
! 493: if ((sc->tulip_flags & (TULIP_RXACT|TULIP_LINKUP)) == (TULIP_RXACT|TULIP_LINKUP)) {
! 494: sc->tulip_flags &= ~TULIP_RXACT;
! 495: sc->tulip_probe_timeout = 3000;
! 496: return (TULIP_LINK_UP);
! 497: }
! 498:
! 499: sc->tulip_flags &= ~TULIP_RXACT;
! 500: if (mi->mi_type == TULIP_MEDIAINFO_MII) {
! 501: u_int32_t status;
! 502: /*
! 503: * Read the PHY status register.
! 504: */
! 505: status = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS)
! 506: | tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS);
! 507: if (status & PHYSTS_AUTONEG_DONE) {
! 508: /*
! 509: * If the PHY has completed autonegotiation, see the if the
! 510: * remote systems abilities have changed. If so, upgrade or
! 511: * downgrade as appropriate.
! 512: */
! 513: u_int32_t abilities = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_AUTONEG_ABILITIES);
! 514: abilities = (abilities << 6) & status;
! 515: if (abilities != sc->tulip_abilities) {
! 516: #if defined(TULIP_DEBUG)
! 517: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation changed: 0x%04x -> 0x%04x\n",
! 518: TULIP_PRINTF_ARGS, sc->tulip_phyaddr,
! 519: sc->tulip_abilities, abilities);
! 520: #endif
! 521: if (tulip_mii_map_abilities(sc, abilities)) {
! 522: tulip_linkup(sc, sc->tulip_probe_media);
! 523: return (TULIP_LINK_UP);
! 524: }
! 525: /*
! 526: * if we had selected media because of autonegotiation,
! 527: * we need to probe for the new media.
! 528: */
! 529: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 530: if (sc->tulip_flags & TULIP_DIDNWAY)
! 531: return (TULIP_LINK_DOWN);
! 532: }
! 533: }
! 534: /*
! 535: * The link is now up. If was down, say its back up.
! 536: */
! 537: if ((status & (PHYSTS_LINK_UP|PHYSTS_REMOTE_FAULT)) == PHYSTS_LINK_UP)
! 538: linkup = TULIP_LINK_UP;
! 539: } else if (mi->mi_type == TULIP_MEDIAINFO_GPR) {
! 540: /*
! 541: * No activity sensor? Assume all's well.
! 542: */
! 543: if (mi->mi_actmask == 0)
! 544: return (TULIP_LINK_UNKNOWN);
! 545: /*
! 546: * Does the activity data match?
! 547: */
! 548: if ((TULIP_CSR_READ(sc, csr_gp) & mi->mi_actmask) == mi->mi_actdata)
! 549: linkup = TULIP_LINK_UP;
! 550: } else if (mi->mi_type == TULIP_MEDIAINFO_SIA) {
! 551: /*
! 552: * Assume non TP ok for now.
! 553: */
! 554: if (!TULIP_IS_MEDIA_TP(sc->tulip_media))
! 555: return (TULIP_LINK_UNKNOWN);
! 556: if ((TULIP_CSR_READ(sc, csr_sia_status) & TULIP_SIASTS_LINKFAIL) == 0)
! 557: linkup = TULIP_LINK_UP;
! 558: #if defined(TULIP_DEBUG)
! 559: if (sc->tulip_probe_timeout <= 0)
! 560: printf(TULIP_PRINTF_FMT ": sia status = 0x%08x\n", TULIP_PRINTF_ARGS, TULIP_CSR_READ(sc, csr_sia_status));
! 561: #endif
! 562: } else if (mi->mi_type == TULIP_MEDIAINFO_SYM)
! 563: return (TULIP_LINK_UNKNOWN);
! 564: /*
! 565: * We will wait for 3 seconds until the link goes into suspect mode.
! 566: */
! 567: if (sc->tulip_flags & TULIP_LINKUP) {
! 568: if (linkup == TULIP_LINK_UP)
! 569: sc->tulip_probe_timeout = 3000;
! 570: if (sc->tulip_probe_timeout > 0)
! 571: return (TULIP_LINK_UP);
! 572:
! 573: sc->tulip_flags &= ~TULIP_LINKUP;
! 574: }
! 575: #if defined(TULIP_DEBUG)
! 576: sc->tulip_dbg.dbg_link_downed++;
! 577: #endif
! 578: return (TULIP_LINK_DOWN);
! 579: }
! 580:
! 581: void
! 582: tulip_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event)
! 583: {
! 584: #if defined(TULIP_DEBUG)
! 585: sc->tulip_dbg.dbg_events[event]++;
! 586: #endif
! 587: if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE
! 588: && event == TULIP_MEDIAPOLL_TIMER) {
! 589: switch (tulip_media_link_monitor(sc)) {
! 590: case TULIP_LINK_DOWN: {
! 591: /*
! 592: * Link Monitor failed. Probe for new media.
! 593: */
! 594: event = TULIP_MEDIAPOLL_LINKFAIL;
! 595: break;
! 596: }
! 597: case TULIP_LINK_UP: {
! 598: /*
! 599: * Check again soon.
! 600: */
! 601: tulip_timeout(sc);
! 602: return;
! 603: }
! 604: case TULIP_LINK_UNKNOWN: {
! 605: /*
! 606: * We can't tell so don't bother.
! 607: */
! 608: return;
! 609: }
! 610: }
! 611: }
! 612:
! 613: if (event == TULIP_MEDIAPOLL_LINKFAIL) {
! 614: if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE) {
! 615: if (TULIP_DO_AUTOSENSE(sc)) {
! 616: #if defined(TULIP_DEBUG)
! 617: sc->tulip_dbg.dbg_link_failures++;
! 618: #endif
! 619: sc->tulip_media = TULIP_MEDIA_UNKNOWN;
! 620: if (sc->tulip_if.if_flags & IFF_UP)
! 621: tulip_reset(sc); /* restart probe */
! 622: }
! 623: return;
! 624: }
! 625: #if defined(TULIP_DEBUG)
! 626: sc->tulip_dbg.dbg_link_pollintrs++;
! 627: #endif
! 628: }
! 629:
! 630: if (event == TULIP_MEDIAPOLL_START) {
! 631: sc->tulip_if.if_flags |= IFF_OACTIVE;
! 632: if (sc->tulip_probe_state != TULIP_PROBE_INACTIVE)
! 633: return;
! 634: sc->tulip_probe_mediamask = 0;
! 635: sc->tulip_probe_passes = 0;
! 636: #if defined(TULIP_DEBUG)
! 637: sc->tulip_dbg.dbg_media_probes++;
! 638: #endif
! 639: /*
! 640: * If the SROM contained an explicit media to use, use it.
! 641: */
! 642: sc->tulip_cmdmode &= ~(TULIP_CMD_RXRUN|TULIP_CMD_FULLDUPLEX);
! 643: sc->tulip_flags |= TULIP_TRYNWAY|TULIP_PROBE1STPASS;
! 644: sc->tulip_flags &= ~(TULIP_DIDNWAY|TULIP_PRINTMEDIA|TULIP_PRINTLINKUP);
! 645: /*
! 646: * connidx is defaulted to a media_unknown type.
! 647: */
! 648: sc->tulip_probe_media = tulip_srom_conninfo[sc->tulip_connidx].sc_media;
! 649: if (sc->tulip_probe_media != TULIP_MEDIA_UNKNOWN) {
! 650: tulip_linkup(sc, sc->tulip_probe_media);
! 651: tulip_timeout(sc);
! 652: return;
! 653: }
! 654:
! 655: if (sc->tulip_features & TULIP_HAVE_GPR) {
! 656: sc->tulip_probe_state = TULIP_PROBE_GPRTEST;
! 657: sc->tulip_probe_timeout = 2000;
! 658: } else {
! 659: sc->tulip_probe_media = TULIP_MEDIA_MAX;
! 660: sc->tulip_probe_timeout = 0;
! 661: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 662: }
! 663: }
! 664:
! 665: /*
! 666: * Ignore txprobe failures or spurious callbacks.
! 667: */
! 668: if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED
! 669: && sc->tulip_probe_state != TULIP_PROBE_MEDIATEST) {
! 670: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 671: return;
! 672: }
! 673:
! 674: /*
! 675: * If we really transmitted a packet, then that's the media we'll use.
! 676: */
! 677: if (event == TULIP_MEDIAPOLL_TXPROBE_OK || event == TULIP_MEDIAPOLL_LINKPASS) {
! 678: if (event == TULIP_MEDIAPOLL_LINKPASS) {
! 679: /* XXX Check media status just to be sure */
! 680: sc->tulip_probe_media = TULIP_MEDIA_10BASET;
! 681: #if defined(TULIP_DEBUG)
! 682: } else {
! 683: sc->tulip_dbg.dbg_txprobes_ok[sc->tulip_probe_media]++;
! 684: #endif
! 685: }
! 686: tulip_linkup(sc, sc->tulip_probe_media);
! 687: tulip_timeout(sc);
! 688: return;
! 689: }
! 690:
! 691: if (sc->tulip_probe_state == TULIP_PROBE_GPRTEST) {
! 692: /*
! 693: * Brute force. We cycle through each of the media types
! 694: * and try to transmit a packet.
! 695: */
! 696: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 697: sc->tulip_probe_media = TULIP_MEDIA_MAX;
! 698: sc->tulip_probe_timeout = 0;
! 699: tulip_timeout(sc);
! 700: return;
! 701: }
! 702:
! 703: if (sc->tulip_probe_state != TULIP_PROBE_MEDIATEST
! 704: && (sc->tulip_features & TULIP_HAVE_MII)) {
! 705: tulip_media_t old_media = sc->tulip_probe_media;
! 706: tulip_mii_autonegotiate(sc, sc->tulip_phyaddr);
! 707: switch (sc->tulip_probe_state) {
! 708: case TULIP_PROBE_FAILED:
! 709: case TULIP_PROBE_MEDIATEST: {
! 710: /*
! 711: * Try the next media.
! 712: */
! 713: sc->tulip_probe_mediamask |= sc->tulip_mediums[sc->tulip_probe_media]->mi_mediamask;
! 714: sc->tulip_probe_timeout = 0;
! 715: break;
! 716: }
! 717: case TULIP_PROBE_PHYAUTONEG: {
! 718: return;
! 719: }
! 720: case TULIP_PROBE_INACTIVE: {
! 721: /*
! 722: * Only probe if we autonegotiated a media that hasn't failed.
! 723: */
! 724: sc->tulip_probe_timeout = 0;
! 725: if (sc->tulip_probe_mediamask & TULIP_BIT(sc->tulip_probe_media)) {
! 726: sc->tulip_probe_media = old_media;
! 727: break;
! 728: }
! 729: tulip_linkup(sc, sc->tulip_probe_media);
! 730: tulip_timeout(sc);
! 731: return;
! 732: }
! 733: default: {
! 734: #if defined(DIAGNOSTIC) || defined(TULIP_DEBUG)
! 735: printf("tulip_media_poll: botch at line %d\n", __LINE__);
! 736: #endif
! 737: break;
! 738: }
! 739: }
! 740: }
! 741:
! 742: if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED) {
! 743: #if defined(TULIP_DEBUG)
! 744: sc->tulip_dbg.dbg_txprobes_failed[sc->tulip_probe_media]++;
! 745: #endif
! 746: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 747: return;
! 748: }
! 749:
! 750: /*
! 751: * Switch to another media if we tried this one enough.
! 752: */
! 753: if (/* event == TULIP_MEDIAPOLL_TXPROBE_FAILED || */ sc->tulip_probe_timeout <= 0) {
! 754: #if defined(TULIP_DEBUG)
! 755: if (sc->tulip_probe_media == TULIP_MEDIA_UNKNOWN) {
! 756: printf(TULIP_PRINTF_FMT ": poll media unknown!\n",
! 757: TULIP_PRINTF_ARGS);
! 758: sc->tulip_probe_media = TULIP_MEDIA_MAX;
! 759: }
! 760: #endif
! 761: /*
! 762: * Find the next media type to check for. Full Duplex
! 763: * types are not allowed.
! 764: */
! 765: do {
! 766: sc->tulip_probe_media -= 1;
! 767: if (sc->tulip_probe_media == TULIP_MEDIA_UNKNOWN) {
! 768: if (++sc->tulip_probe_passes == 3) {
! 769: if ((sc->tulip_if.if_flags & IFF_UP) == 0) {
! 770: sc->tulip_if.if_flags &= ~IFF_RUNNING;
! 771: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 772: return;
! 773: }
! 774: }
! 775: sc->tulip_flags ^= TULIP_TRYNWAY; /* XXX */
! 776: sc->tulip_probe_mediamask = 0;
! 777: sc->tulip_probe_media = TULIP_MEDIA_MAX - 1;
! 778: }
! 779: } while (sc->tulip_mediums[sc->tulip_probe_media] == NULL
! 780: || (sc->tulip_probe_mediamask & TULIP_BIT(sc->tulip_probe_media))
! 781: || TULIP_IS_MEDIA_FD(sc->tulip_probe_media));
! 782:
! 783: #if defined(TULIP_DEBUG)
! 784: printf(TULIP_PRINTF_FMT ": %s: probing %s\n", TULIP_PRINTF_ARGS,
! 785: event == TULIP_MEDIAPOLL_TXPROBE_FAILED ? "txprobe failed" : "timeout",
! 786: tulip_mediums[sc->tulip_probe_media]);
! 787: #endif
! 788: sc->tulip_probe_timeout = TULIP_IS_MEDIA_TP(sc->tulip_probe_media) ? 2500 : 1000;
! 789: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 790: sc->tulip_probe.probe_txprobes = 0;
! 791: tulip_reset(sc);
! 792: tulip_media_set(sc, sc->tulip_probe_media);
! 793: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 794: }
! 795: tulip_timeout(sc);
! 796:
! 797: /*
! 798: * If this is hanging off a phy, we know are doing NWAY and we have
! 799: * forced the phy to a specific speed. Wait for link up before
! 800: * before sending a packet.
! 801: */
! 802: switch (sc->tulip_mediums[sc->tulip_probe_media]->mi_type) {
! 803: case TULIP_MEDIAINFO_MII: {
! 804: if (sc->tulip_probe_media != tulip_mii_phy_readspecific(sc))
! 805: return;
! 806: break;
! 807: }
! 808: case TULIP_MEDIAINFO_SIA: {
! 809: if (TULIP_IS_MEDIA_TP(sc->tulip_probe_media)) {
! 810: if (TULIP_CSR_READ(sc, csr_sia_status) & TULIP_SIASTS_LINKFAIL)
! 811: return;
! 812: tulip_linkup(sc, sc->tulip_probe_media);
! 813: return;
! 814: }
! 815: break;
! 816: }
! 817: case TULIP_MEDIAINFO_RESET:
! 818: case TULIP_MEDIAINFO_SYM:
! 819: case TULIP_MEDIAINFO_NONE:
! 820: case TULIP_MEDIAINFO_GPR: {
! 821: break;
! 822: }
! 823: }
! 824: /*
! 825: * Try to send a packet.
! 826: */
! 827: tulip_txprobe(sc);
! 828: }
! 829:
! 830: void
! 831: tulip_media_select(tulip_softc_t * const sc)
! 832: {
! 833: if (sc->tulip_features & TULIP_HAVE_GPR) {
! 834: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET|sc->tulip_gpinit);
! 835: DELAY(10);
! 836: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_gpdata);
! 837: }
! 838: /*
! 839: * If this board has no media, just return
! 840: */
! 841: if (sc->tulip_features & TULIP_HAVE_NOMEDIA)
! 842: return;
! 843:
! 844: if (sc->tulip_media == TULIP_MEDIA_UNKNOWN) {
! 845: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 846: (*sc->tulip_boardsw->bd_media_poll)(sc, TULIP_MEDIAPOLL_START);
! 847: } else
! 848: tulip_media_set(sc, sc->tulip_media);
! 849: }
! 850:
! 851: void
! 852: tulip_21040_mediainfo_init(tulip_softc_t * const sc, tulip_media_t media)
! 853: {
! 854: sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_THRSHLD160
! 855: |TULIP_CMD_BACKOFFCTR;
! 856: sc->tulip_if.if_baudrate = 10000000;
! 857:
! 858: if (media == TULIP_MEDIA_10BASET || media == TULIP_MEDIA_UNKNOWN) {
! 859: TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[0], 21040, 10BASET);
! 860: TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[1], 21040, 10BASET_FD);
! 861: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 862: }
! 863:
! 864: if (media == TULIP_MEDIA_AUIBNC || media == TULIP_MEDIA_UNKNOWN)
! 865: TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[2], 21040, AUIBNC);
! 866:
! 867: if (media == TULIP_MEDIA_UNKNOWN)
! 868: TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[3], 21040, EXTSIA);
! 869: }
! 870:
! 871: void
! 872: tulip_21040_media_probe(tulip_softc_t * const sc)
! 873: {
! 874: tulip_21040_mediainfo_init(sc, TULIP_MEDIA_UNKNOWN);
! 875: }
! 876:
! 877: void
! 878: tulip_21040_10baset_only_media_probe(tulip_softc_t * const sc)
! 879: {
! 880: tulip_21040_mediainfo_init(sc, TULIP_MEDIA_10BASET);
! 881: tulip_media_set(sc, TULIP_MEDIA_10BASET);
! 882: sc->tulip_media = TULIP_MEDIA_10BASET;
! 883: }
! 884:
! 885: void
! 886: tulip_21040_10baset_only_media_select(tulip_softc_t * const sc)
! 887: {
! 888: sc->tulip_flags |= TULIP_LINKUP;
! 889: if (sc->tulip_media == TULIP_MEDIA_10BASET_FD) {
! 890: sc->tulip_cmdmode |= TULIP_CMD_FULLDUPLEX;
! 891: sc->tulip_flags &= ~TULIP_SQETEST;
! 892: } else {
! 893: sc->tulip_cmdmode &= ~TULIP_CMD_FULLDUPLEX;
! 894: sc->tulip_flags |= TULIP_SQETEST;
! 895: }
! 896: tulip_media_set(sc, sc->tulip_media);
! 897: }
! 898:
! 899: void
! 900: tulip_21040_auibnc_only_media_probe(tulip_softc_t * const sc)
! 901: {
! 902: tulip_21040_mediainfo_init(sc, TULIP_MEDIA_AUIBNC);
! 903: sc->tulip_flags |= TULIP_SQETEST|TULIP_LINKUP;
! 904: tulip_media_set(sc, TULIP_MEDIA_AUIBNC);
! 905: sc->tulip_media = TULIP_MEDIA_AUIBNC;
! 906: }
! 907:
! 908: void
! 909: tulip_21040_auibnc_only_media_select(tulip_softc_t * const sc)
! 910: {
! 911: tulip_media_set(sc, TULIP_MEDIA_AUIBNC);
! 912: sc->tulip_cmdmode &= ~TULIP_CMD_FULLDUPLEX;
! 913: }
! 914:
! 915: static const tulip_boardsw_t tulip_21040_boardsw = {
! 916: TULIP_21040_GENERIC,
! 917: tulip_21040_media_probe,
! 918: tulip_media_select,
! 919: tulip_media_poll,
! 920: };
! 921:
! 922: static const tulip_boardsw_t tulip_21040_10baset_only_boardsw = {
! 923: TULIP_21040_GENERIC,
! 924: tulip_21040_10baset_only_media_probe,
! 925: tulip_21040_10baset_only_media_select,
! 926: NULL,
! 927: };
! 928:
! 929: static const tulip_boardsw_t tulip_21040_auibnc_only_boardsw = {
! 930: TULIP_21040_GENERIC,
! 931: tulip_21040_auibnc_only_media_probe,
! 932: tulip_21040_auibnc_only_media_select,
! 933: NULL,
! 934: };
! 935:
! 936: void
! 937: tulip_21041_mediainfo_init(tulip_softc_t * const sc)
! 938: {
! 939: tulip_media_info_t * const mi = sc->tulip_mediainfo;
! 940:
! 941: TULIP_MEDIAINFO_SIA_INIT(sc, &mi[0], 21041, 10BASET);
! 942: TULIP_MEDIAINFO_SIA_INIT(sc, &mi[1], 21041, 10BASET_FD);
! 943: TULIP_MEDIAINFO_SIA_INIT(sc, &mi[2], 21041, AUI);
! 944: TULIP_MEDIAINFO_SIA_INIT(sc, &mi[3], 21041, BNC);
! 945: }
! 946:
! 947: void
! 948: tulip_21041_media_noprobe(tulip_softc_t * const sc)
! 949: {
! 950: sc->tulip_if.if_baudrate = 10000000;
! 951: sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_ENHCAPTEFFCT
! 952: |TULIP_CMD_THRSHLD160|TULIP_CMD_BACKOFFCTR;
! 953: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 954: }
! 955:
! 956: void
! 957: tulip_21041_media_probe(tulip_softc_t * const sc)
! 958: {
! 959: sc->tulip_if.if_baudrate = 10000000;
! 960: sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_ENHCAPTEFFCT
! 961: |TULIP_CMD_THRSHLD160|TULIP_CMD_BACKOFFCTR;
! 962: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 963: tulip_21041_mediainfo_init(sc);
! 964: }
! 965:
! 966: void
! 967: tulip_21041_media_poll(tulip_softc_t * const sc, const tulip_mediapoll_event_t event)
! 968: {
! 969: u_int32_t sia_status;
! 970:
! 971: #if defined(TULIP_DEBUG)
! 972: sc->tulip_dbg.dbg_events[event]++;
! 973: #endif
! 974:
! 975: if (event == TULIP_MEDIAPOLL_LINKFAIL) {
! 976: if (sc->tulip_probe_state != TULIP_PROBE_INACTIVE
! 977: || !TULIP_DO_AUTOSENSE(sc))
! 978: return;
! 979: sc->tulip_media = TULIP_MEDIA_UNKNOWN;
! 980: tulip_reset(sc); /* start probe */
! 981: return;
! 982: }
! 983:
! 984: /*
! 985: * If we've been been asked to start a poll or link change interrupt
! 986: * restart the probe (and reset the tulip to a known state).
! 987: */
! 988: if (event == TULIP_MEDIAPOLL_START) {
! 989: sc->tulip_if.if_flags |= IFF_OACTIVE;
! 990: sc->tulip_cmdmode &= ~(TULIP_CMD_FULLDUPLEX|TULIP_CMD_RXRUN);
! 991: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 992: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 993: sc->tulip_probe_media = TULIP_MEDIA_10BASET;
! 994: sc->tulip_probe_timeout = TULIP_21041_PROBE_10BASET_TIMEOUT;
! 995: tulip_media_set(sc, TULIP_MEDIA_10BASET);
! 996: tulip_timeout(sc);
! 997: return;
! 998: }
! 999:
! 1000: if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE)
! 1001: return;
! 1002:
! 1003: if (event == TULIP_MEDIAPOLL_TXPROBE_OK) {
! 1004: #if defined(TULIP_DEBUG)
! 1005: sc->tulip_dbg.dbg_txprobes_ok[sc->tulip_probe_media]++;
! 1006: #endif
! 1007: tulip_linkup(sc, sc->tulip_probe_media);
! 1008: return;
! 1009: }
! 1010:
! 1011: sia_status = TULIP_CSR_READ(sc, csr_sia_status);
! 1012: TULIP_CSR_WRITE(sc, csr_sia_status, sia_status);
! 1013: if ((sia_status & TULIP_SIASTS_LINKFAIL) == 0) {
! 1014: if (sc->tulip_revinfo >= 0x20) {
! 1015: if (sia_status & (PHYSTS_10BASET_FD << (16 - 6)))
! 1016: sc->tulip_probe_media = TULIP_MEDIA_10BASET_FD;
! 1017: }
! 1018: /*
! 1019: * If the link has passed LinkPass, 10baseT is the
! 1020: * proper media to use.
! 1021: */
! 1022: tulip_linkup(sc, sc->tulip_probe_media);
! 1023: return;
! 1024: }
! 1025:
! 1026: /*
! 1027: * wait for up to 2.4 seconds for the link to reach pass state.
! 1028: * Only then start scanning the other media for activity.
! 1029: * choose media with receive activity over those without.
! 1030: */
! 1031: if (sc->tulip_probe_media == TULIP_MEDIA_10BASET) {
! 1032: if (event != TULIP_MEDIAPOLL_TIMER)
! 1033: return;
! 1034: if (sc->tulip_probe_timeout > 0
! 1035: && (sia_status & TULIP_SIASTS_OTHERRXACTIVITY) == 0) {
! 1036: tulip_timeout(sc);
! 1037: return;
! 1038: }
! 1039: sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
! 1040: sc->tulip_flags |= TULIP_WANTRXACT;
! 1041: if (sia_status & TULIP_SIASTS_OTHERRXACTIVITY)
! 1042: sc->tulip_probe_media = TULIP_MEDIA_BNC;
! 1043: else
! 1044: sc->tulip_probe_media = TULIP_MEDIA_AUI;
! 1045: tulip_media_set(sc, sc->tulip_probe_media);
! 1046: tulip_timeout(sc);
! 1047: return;
! 1048: }
! 1049:
! 1050: /*
! 1051: * If we failed, clear the txprobe active flag.
! 1052: */
! 1053: if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED)
! 1054: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 1055:
! 1056:
! 1057: if (event == TULIP_MEDIAPOLL_TIMER) {
! 1058: /*
! 1059: * If we've received something, then that's our link!
! 1060: */
! 1061: if (sc->tulip_flags & TULIP_RXACT) {
! 1062: tulip_linkup(sc, sc->tulip_probe_media);
! 1063: return;
! 1064: }
! 1065: /*
! 1066: * if no txprobe active
! 1067: */
! 1068: if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0
! 1069: && ((sc->tulip_flags & TULIP_WANTRXACT) == 0
! 1070: || (sia_status & TULIP_SIASTS_RXACTIVITY))) {
! 1071: sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
! 1072: tulip_txprobe(sc);
! 1073: tulip_timeout(sc);
! 1074: return;
! 1075: }
! 1076: /*
! 1077: * Take 2 passes through before deciding to not
! 1078: * wait for receive activity. Then take another
! 1079: * two passes before spitting out a warning.
! 1080: */
! 1081: if (sc->tulip_probe_timeout <= 0) {
! 1082: if (sc->tulip_flags & TULIP_WANTRXACT) {
! 1083: sc->tulip_flags &= ~TULIP_WANTRXACT;
! 1084: sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
! 1085: } else {
! 1086: if ((sc->tulip_if.if_flags & IFF_UP) == 0) {
! 1087: sc->tulip_if.if_flags &= ~IFF_RUNNING;
! 1088: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 1089: return;
! 1090: }
! 1091: }
! 1092: }
! 1093: }
! 1094:
! 1095: /*
! 1096: * Since this media failed to probe, try the other one.
! 1097: */
! 1098: sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
! 1099: if (sc->tulip_probe_media == TULIP_MEDIA_AUI)
! 1100: sc->tulip_probe_media = TULIP_MEDIA_BNC;
! 1101: else
! 1102: sc->tulip_probe_media = TULIP_MEDIA_AUI;
! 1103: tulip_media_set(sc, sc->tulip_probe_media);
! 1104: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 1105: tulip_timeout(sc);
! 1106: }
! 1107:
! 1108: static const tulip_boardsw_t tulip_21041_boardsw = {
! 1109: TULIP_21041_GENERIC,
! 1110: tulip_21041_media_probe,
! 1111: tulip_media_select,
! 1112: tulip_21041_media_poll
! 1113: };
! 1114:
! 1115: static const tulip_boardsw_t tulip_21041np_boardsw = {
! 1116: TULIP_21041_GENERIC,
! 1117: tulip_21041_media_noprobe,
! 1118: tulip_media_select,
! 1119: tulip_21041_media_poll
! 1120: };
! 1121:
! 1122: static const tulip_phy_attr_t tulip_mii_phy_attrlist[] = {
! 1123: { 0x20005c00, 0, /* 08-00-17 */
! 1124: {
! 1125: { 0x19, 0x0040, 0x0040 }, /* 10TX */
! 1126: { 0x19, 0x0040, 0x0000 }, /* 100TX */
! 1127: },
! 1128: #if defined(TULIP_DEBUG)
! 1129: "NS DP83840",
! 1130: #endif
! 1131: },
! 1132: { 0x0281F400, 0, /* 00-A0-7D */
! 1133: {
! 1134: { 0x12, 0x0010, 0x0000 }, /* 10T */
! 1135: { 0 }, /* 100TX */
! 1136: { 0x12, 0x0010, 0x0010 }, /* 100T4 */
! 1137: { 0x12, 0x0008, 0x0008 }, /* FULL_DUPLEX */
! 1138: },
! 1139: #if defined(TULIP_DEBUG)
! 1140: "Seeq 80C240"
! 1141: #endif
! 1142: },
! 1143: { 0x0281F400, 3, /* 00-A0-7D */
! 1144: {
! 1145: { 0x12, 0x0080, 0x0000 }, /* 10T */
! 1146: { 0x12, 0x0080, 0x0080 }, /* 100TX */
! 1147: { 0 }, /* 100T4 */
! 1148: { 0x12, 0x0040, 0x0040 }, /* FULL_DUPLEX */
! 1149: },
! 1150: #if defined(TULIP_DEBUG)
! 1151: "Seeq 80225"
! 1152: #endif
! 1153: },
! 1154: { 0x0281F400, 0, /* 00-A0-BE */
! 1155: {
! 1156: { 0x11, 0x8000, 0x0000 }, /* 10T */
! 1157: { 0x11, 0x8000, 0x8000 }, /* 100TX */
! 1158: { 0 }, /* 100T4 */
! 1159: { 0x11, 0x4000, 0x4000 }, /* FULL_DUPLEX */
! 1160: },
! 1161: #if defined(TULIP_DEBUG)
! 1162: "ICS 1890"
! 1163: #endif
! 1164: },
! 1165: { 0x78100000, 0, /* 00-A0-CC */
! 1166: {
! 1167: { 0x14, 0x0800, 0x0000 }, /* 10TX */
! 1168: { 0x14, 0x0800, 0x0800 }, /* 100TX */
! 1169: { 0 }, /* 100T4 */
! 1170: { 0x14, 0x1000, 0x1000 }, /* FULL_DUPLEX */
! 1171: },
! 1172: #if defined(TULIP_DEBUG)
! 1173: "LEVEL1 LXT970"
! 1174: #endif
! 1175: },
! 1176: { 0 }
! 1177: };
! 1178:
! 1179: tulip_media_t
! 1180: tulip_mii_phy_readspecific(tulip_softc_t * const sc)
! 1181: {
! 1182: const tulip_phy_attr_t *attr;
! 1183: u_int16_t data;
! 1184: u_int32_t id;
! 1185: unsigned idx = 0;
! 1186: static const tulip_media_t table[] = {
! 1187: TULIP_MEDIA_UNKNOWN,
! 1188: TULIP_MEDIA_10BASET,
! 1189: TULIP_MEDIA_100BASETX,
! 1190: TULIP_MEDIA_100BASET4,
! 1191: TULIP_MEDIA_UNKNOWN,
! 1192: TULIP_MEDIA_10BASET_FD,
! 1193: TULIP_MEDIA_100BASETX_FD,
! 1194: TULIP_MEDIA_UNKNOWN
! 1195: };
! 1196:
! 1197: /*
! 1198: * Don't read phy specific registers if link is not up.
! 1199: */
! 1200: data = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS)
! 1201: | tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS);
! 1202: if ((data & (PHYSTS_LINK_UP|PHYSTS_EXTENDED_REGS)) != (PHYSTS_LINK_UP|PHYSTS_EXTENDED_REGS))
! 1203: return (TULIP_MEDIA_UNKNOWN);
! 1204:
! 1205: id = (tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_IDLOW) << 16) |
! 1206: tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_IDHIGH);
! 1207: for (attr = tulip_mii_phy_attrlist;; attr++) {
! 1208: if (attr->attr_id == 0)
! 1209: return (TULIP_MEDIA_UNKNOWN);
! 1210: if ((id & ~0x0F) == attr->attr_id)
! 1211: break;
! 1212: }
! 1213:
! 1214: if (attr->attr_modes[PHY_MODE_100TX].pm_regno) {
! 1215: const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_100TX];
! 1216: data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
! 1217: if ((data & pm->pm_mask) == pm->pm_value)
! 1218: idx = 2;
! 1219: }
! 1220: if (idx == 0 && attr->attr_modes[PHY_MODE_100T4].pm_regno) {
! 1221: const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_100T4];
! 1222: data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
! 1223: if ((data & pm->pm_mask) == pm->pm_value)
! 1224: idx = 3;
! 1225: }
! 1226: if (idx == 0 && attr->attr_modes[PHY_MODE_10T].pm_regno) {
! 1227: const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_10T];
! 1228: data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
! 1229: if ((data & pm->pm_mask) == pm->pm_value)
! 1230: idx = 1;
! 1231: }
! 1232: if (idx != 0 && attr->attr_modes[PHY_MODE_FULLDUPLEX].pm_regno) {
! 1233: const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_FULLDUPLEX];
! 1234: data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
! 1235: idx += ((data & pm->pm_mask) == pm->pm_value ? 4 : 0);
! 1236: }
! 1237: return (table[idx]);
! 1238: }
! 1239:
! 1240: unsigned
! 1241: tulip_mii_get_phyaddr(tulip_softc_t * const sc, unsigned offset)
! 1242: {
! 1243: unsigned phyaddr;
! 1244:
! 1245: for (phyaddr = 1; phyaddr < 32; phyaddr++) {
! 1246: unsigned status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
! 1247: if (status == 0 || status == 0xFFFF || status < PHYSTS_10BASET)
! 1248: continue;
! 1249: if (offset == 0)
! 1250: return (phyaddr);
! 1251: offset--;
! 1252: }
! 1253: if (offset == 0) {
! 1254: unsigned status = tulip_mii_readreg(sc, 0, PHYREG_STATUS);
! 1255: if (status == 0 || status == 0xFFFF || status < PHYSTS_10BASET)
! 1256: return (TULIP_MII_NOPHY);
! 1257: return (0);
! 1258: }
! 1259: return (TULIP_MII_NOPHY);
! 1260: }
! 1261:
! 1262: int
! 1263: tulip_mii_map_abilities(tulip_softc_t * const sc, unsigned abilities)
! 1264: {
! 1265: sc->tulip_abilities = abilities;
! 1266: if (abilities & PHYSTS_100BASETX_FD)
! 1267: sc->tulip_probe_media = TULIP_MEDIA_100BASETX_FD;
! 1268: else if (abilities & PHYSTS_100BASET4)
! 1269: sc->tulip_probe_media = TULIP_MEDIA_100BASET4;
! 1270: else if (abilities & PHYSTS_100BASETX)
! 1271: sc->tulip_probe_media = TULIP_MEDIA_100BASETX;
! 1272: else if (abilities & PHYSTS_10BASET_FD)
! 1273: sc->tulip_probe_media = TULIP_MEDIA_10BASET_FD;
! 1274: else if (abilities & PHYSTS_10BASET)
! 1275: sc->tulip_probe_media = TULIP_MEDIA_10BASET;
! 1276: else {
! 1277: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 1278: return (0);
! 1279: }
! 1280: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 1281: return (1);
! 1282: }
! 1283:
! 1284: void
! 1285: tulip_mii_autonegotiate(tulip_softc_t * const sc, const unsigned phyaddr)
! 1286: {
! 1287: switch (sc->tulip_probe_state) {
! 1288: case TULIP_PROBE_MEDIATEST:
! 1289: case TULIP_PROBE_INACTIVE: {
! 1290: sc->tulip_flags |= TULIP_DIDNWAY;
! 1291: tulip_mii_writereg(sc, phyaddr, PHYREG_CONTROL, PHYCTL_RESET);
! 1292: sc->tulip_probe_timeout = 3000;
! 1293: sc->tulip_intrmask |= TULIP_STS_ABNRMLINTR|TULIP_STS_NORMALINTR;
! 1294: sc->tulip_probe_state = TULIP_PROBE_PHYRESET;
! 1295: /* FALLTHROUGH */
! 1296: }
! 1297: case TULIP_PROBE_PHYRESET: {
! 1298: u_int32_t status;
! 1299: u_int32_t data = tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL);
! 1300: if (data & PHYCTL_RESET) {
! 1301: if (sc->tulip_probe_timeout > 0) {
! 1302: tulip_timeout(sc);
! 1303: return;
! 1304: }
! 1305: #ifdef TULIP_DEBUG
! 1306: printf(TULIP_PRINTF_FMT "(phy%d): error: reset of PHY never completed!\n",
! 1307: TULIP_PRINTF_ARGS, phyaddr);
! 1308: #endif
! 1309: sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
! 1310: sc->tulip_probe_state = TULIP_PROBE_FAILED;
! 1311: sc->tulip_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
! 1312: return;
! 1313: }
! 1314: status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS)
! 1315: | tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
! 1316: if ((status & PHYSTS_CAN_AUTONEG) == 0) {
! 1317: #if defined(TULIP_DEBUG)
! 1318: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation disabled\n",
! 1319: TULIP_PRINTF_ARGS, phyaddr);
! 1320: #endif
! 1321: sc->tulip_flags &= ~TULIP_DIDNWAY;
! 1322: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 1323: return;
! 1324: }
! 1325: if (tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT) != ((status >> 6) | 0x01))
! 1326: tulip_mii_writereg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT, (status >> 6) | 0x01);
! 1327: tulip_mii_writereg(sc, phyaddr, PHYREG_CONTROL, data|PHYCTL_AUTONEG_RESTART|PHYCTL_AUTONEG_ENABLE);
! 1328: data = tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL);
! 1329: #if defined(TULIP_DEBUG)
! 1330: if ((data & PHYCTL_AUTONEG_ENABLE) == 0)
! 1331: printf(TULIP_PRINTF_FMT "(phy%d): oops: enable autonegotiation failed: 0x%04x\n",
! 1332: TULIP_PRINTF_ARGS, phyaddr, data);
! 1333: else
! 1334: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation restarted: 0x%04x (ad=0x%04x)\n",
! 1335: TULIP_PRINTF_ARGS, phyaddr, data,
! 1336: tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT));
! 1337: sc->tulip_dbg.dbg_nway_starts++;
! 1338: #endif
! 1339: sc->tulip_probe_state = TULIP_PROBE_PHYAUTONEG;
! 1340: sc->tulip_probe_timeout = 3000;
! 1341: /* FALLTHROUGH */
! 1342: }
! 1343: case TULIP_PROBE_PHYAUTONEG: {
! 1344: u_int32_t status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS)
! 1345: | tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
! 1346: u_int32_t data;
! 1347: if ((status & PHYSTS_AUTONEG_DONE) == 0) {
! 1348: if (sc->tulip_probe_timeout > 0) {
! 1349: tulip_timeout(sc);
! 1350: return;
! 1351: }
! 1352: #if defined(TULIP_DEBUG)
! 1353: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation timeout: sts=0x%04x, ctl=0x%04x\n",
! 1354: TULIP_PRINTF_ARGS, phyaddr, status,
! 1355: tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL));
! 1356: #endif
! 1357: sc->tulip_flags &= ~TULIP_DIDNWAY;
! 1358: sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
! 1359: return;
! 1360: }
! 1361: data = tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ABILITIES)
! 1362: | tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ABILITIES);
! 1363: #if defined(TULIP_DEBUG)
! 1364: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation complete: 0x%04x (sts=0x%04x)\n",
! 1365: TULIP_PRINTF_ARGS, phyaddr, data, status);
! 1366: #endif
! 1367: data = (data << 6) & status;
! 1368: if (!tulip_mii_map_abilities(sc, data))
! 1369: sc->tulip_flags &= ~TULIP_DIDNWAY;
! 1370: return;
! 1371: }
! 1372: default: {
! 1373: #if defined(DIAGNOSTIC)
! 1374: printf("tulip_media_poll: botch at line %d\n", __LINE__);
! 1375: #endif
! 1376: break;
! 1377: }
! 1378: }
! 1379: #if defined(TULIP_DEBUG)
! 1380: printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation failure: state = %d\n",
! 1381: TULIP_PRINTF_ARGS, phyaddr, sc->tulip_probe_state);
! 1382: sc->tulip_dbg.dbg_nway_failures++;
! 1383: #endif
! 1384: }
! 1385:
! 1386: void
! 1387: tulip_2114x_media_preset(tulip_softc_t * const sc)
! 1388: {
! 1389: const tulip_media_info_t *mi = NULL;
! 1390: tulip_media_t media = sc->tulip_media;
! 1391:
! 1392: if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE)
! 1393: media = sc->tulip_media;
! 1394: else
! 1395: media = sc->tulip_probe_media;
! 1396:
! 1397: sc->tulip_cmdmode &= ~(TULIP_CMD_PORTSELECT|TULIP_CMD_NOHEARTBEAT
! 1398: |TULIP_CMD_FULLDUPLEX|TULIP_CMD_TXTHRSHLDCTL);
! 1399: sc->tulip_flags &= ~(TULIP_SQETEST|TULIP_FULLDUPLEX);
! 1400: if (media != TULIP_MEDIA_UNKNOWN && media != TULIP_MEDIA_MAX) {
! 1401: #if defined(TULIP_DEBUG)
! 1402: if (media < TULIP_MEDIA_MAX && sc->tulip_mediums[media] != NULL) {
! 1403: #endif
! 1404: mi = sc->tulip_mediums[media];
! 1405: if (mi->mi_type == TULIP_MEDIAINFO_MII)
! 1406: sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT;
! 1407: else if (mi->mi_type == TULIP_MEDIAINFO_GPR
! 1408: || mi->mi_type == TULIP_MEDIAINFO_SYM) {
! 1409: sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
! 1410: sc->tulip_cmdmode |= mi->mi_cmdmode;
! 1411: } else if (mi->mi_type == TULIP_MEDIAINFO_SIA)
! 1412: TULIP_CSR_WRITE(sc, csr_sia_connectivity, TULIP_SIACONN_RESET);
! 1413: #if defined(TULIP_DEBUG)
! 1414: } else {
! 1415: printf(TULIP_PRINTF_FMT ": preset: bad media %d!\n",
! 1416: TULIP_PRINTF_ARGS, media);
! 1417: }
! 1418: #endif
! 1419: }
! 1420: switch (media) {
! 1421: case TULIP_MEDIA_BNC:
! 1422: case TULIP_MEDIA_AUI:
! 1423: case TULIP_MEDIA_10BASET: {
! 1424: sc->tulip_cmdmode |= TULIP_CMD_TXTHRSHLDCTL;
! 1425: sc->tulip_if.if_baudrate = 10000000;
! 1426: sc->tulip_flags |= TULIP_SQETEST;
! 1427: break;
! 1428: }
! 1429: case TULIP_MEDIA_10BASET_FD: {
! 1430: sc->tulip_flags |= TULIP_FULLDUPLEX;
! 1431: sc->tulip_cmdmode |= TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX;
! 1432: sc->tulip_if.if_baudrate = 10000000;
! 1433: break;
! 1434: }
! 1435: case TULIP_MEDIA_100BASEFX:
! 1436: case TULIP_MEDIA_100BASET4:
! 1437: case TULIP_MEDIA_100BASETX: {
! 1438: sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT;
! 1439: sc->tulip_if.if_baudrate = 100000000;
! 1440: if (mi->mi_type == TULIP_MEDIAINFO_SYM
! 1441: || mi->mi_type == TULIP_MEDIAINFO_MII) {
! 1442: sc->tulip_cmdmode |= TULIP_CMD_NOHEARTBEAT;
! 1443: }
! 1444: break;
! 1445: }
! 1446: case TULIP_MEDIA_100BASEFX_FD:
! 1447: case TULIP_MEDIA_100BASETX_FD: {
! 1448: sc->tulip_flags |= TULIP_FULLDUPLEX;
! 1449: sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT|TULIP_CMD_FULLDUPLEX;
! 1450: sc->tulip_if.if_baudrate = 100000000;
! 1451: if (mi->mi_type == TULIP_MEDIAINFO_SYM
! 1452: || mi->mi_type == TULIP_MEDIAINFO_MII) {
! 1453: sc->tulip_cmdmode |= TULIP_CMD_NOHEARTBEAT;
! 1454: }
! 1455: break;
! 1456: }
! 1457: default: {
! 1458: break;
! 1459: }
! 1460: }
! 1461: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 1462: }
! 1463:
! 1464: /*
! 1465: ********************************************************************
! 1466: * Start of 21140/21140A support which does not use the MII interface
! 1467: */
! 1468:
! 1469: void
! 1470: tulip_null_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event)
! 1471: {
! 1472: #if defined(TULIP_DEBUG)
! 1473: sc->tulip_dbg.dbg_events[event]++;
! 1474: #endif
! 1475: #if defined(DIAGNOSTIC)
! 1476: printf(TULIP_PRINTF_FMT ": botch(media_poll) at line %d\n",
! 1477: TULIP_PRINTF_ARGS, __LINE__);
! 1478: #endif
! 1479: }
! 1480:
! 1481: void
! 1482: tulip_21140_mediainit(tulip_softc_t * const sc, tulip_media_info_t * const mip,
! 1483: tulip_media_t const media, unsigned gpdata, unsigned cmdmode)
! 1484: {
! 1485: sc->tulip_mediums[media] = mip;
! 1486: mip->mi_type = TULIP_MEDIAINFO_GPR;
! 1487: mip->mi_cmdmode = cmdmode;
! 1488: mip->mi_gpdata = gpdata;
! 1489: }
! 1490:
! 1491: void
! 1492: tulip_21140_evalboard_media_probe(tulip_softc_t * const sc)
! 1493: {
! 1494: tulip_media_info_t *mip = sc->tulip_mediainfo;
! 1495:
! 1496: sc->tulip_gpinit = TULIP_GP_EB_PINS;
! 1497: sc->tulip_gpdata = TULIP_GP_EB_INIT;
! 1498: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_PINS);
! 1499: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_INIT);
! 1500: TULIP_CSR_WRITE(sc, csr_command,
! 1501: TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
! 1502: TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
! 1503: TULIP_CSR_WRITE(sc, csr_command,
! 1504: TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
! 1505: DELAY(1000000);
! 1506: if ((TULIP_CSR_READ(sc, csr_gp) & TULIP_GP_EB_OK100) != 0)
! 1507: sc->tulip_media = TULIP_MEDIA_10BASET;
! 1508: else
! 1509: sc->tulip_media = TULIP_MEDIA_100BASETX;
! 1510: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
! 1511: TULIP_GP_EB_INIT,
! 1512: TULIP_CMD_TXTHRSHLDCTL);
! 1513: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
! 1514: TULIP_GP_EB_INIT,
! 1515: TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
! 1516: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
! 1517: TULIP_GP_EB_INIT,
! 1518: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1519: |TULIP_CMD_SCRAMBLER);
! 1520: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
! 1521: TULIP_GP_EB_INIT,
! 1522: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1523: |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
! 1524: }
! 1525:
! 1526: static const tulip_boardsw_t tulip_21140_eb_boardsw = {
! 1527: TULIP_21140_DEC_EB,
! 1528: tulip_21140_evalboard_media_probe,
! 1529: tulip_media_select,
! 1530: tulip_null_media_poll,
! 1531: tulip_2114x_media_preset,
! 1532: };
! 1533:
! 1534: void
! 1535: tulip_21140_accton_media_probe(tulip_softc_t * const sc)
! 1536: {
! 1537: tulip_media_info_t *mip = sc->tulip_mediainfo;
! 1538: unsigned gpdata;
! 1539:
! 1540: sc->tulip_gpinit = TULIP_GP_EB_PINS;
! 1541: sc->tulip_gpdata = TULIP_GP_EB_INIT;
! 1542: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_PINS);
! 1543: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_INIT);
! 1544: TULIP_CSR_WRITE(sc, csr_command,
! 1545: TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
! 1546: TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
! 1547: TULIP_CSR_WRITE(sc, csr_command,
! 1548: TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
! 1549: DELAY(1000000);
! 1550: gpdata = TULIP_CSR_READ(sc, csr_gp);
! 1551: if ((gpdata & TULIP_GP_EN1207_UTP_INIT) == 0)
! 1552: sc->tulip_media = TULIP_MEDIA_10BASET;
! 1553: else {
! 1554: if ((gpdata & TULIP_GP_EN1207_BNC_INIT) == 0)
! 1555: sc->tulip_media = TULIP_MEDIA_BNC;
! 1556: else
! 1557: sc->tulip_media = TULIP_MEDIA_100BASETX;
! 1558: }
! 1559: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_BNC,
! 1560: TULIP_GP_EN1207_BNC_INIT,
! 1561: TULIP_CMD_TXTHRSHLDCTL);
! 1562: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
! 1563: TULIP_GP_EN1207_UTP_INIT,
! 1564: TULIP_CMD_TXTHRSHLDCTL);
! 1565: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
! 1566: TULIP_GP_EN1207_UTP_INIT,
! 1567: TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
! 1568: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
! 1569: TULIP_GP_EN1207_100_INIT,
! 1570: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1571: |TULIP_CMD_SCRAMBLER);
! 1572: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
! 1573: TULIP_GP_EN1207_100_INIT,
! 1574: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1575: |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
! 1576: }
! 1577:
! 1578: static const tulip_boardsw_t tulip_21140_accton_boardsw = {
! 1579: TULIP_21140_EN1207,
! 1580: tulip_21140_accton_media_probe,
! 1581: tulip_media_select,
! 1582: tulip_null_media_poll,
! 1583: tulip_2114x_media_preset,
! 1584: };
! 1585:
! 1586: void
! 1587: tulip_21140_smc9332_media_probe(tulip_softc_t * const sc)
! 1588: {
! 1589: tulip_media_info_t *mip = sc->tulip_mediainfo;
! 1590: int idx, cnt = 0;
! 1591:
! 1592: TULIP_CSR_WRITE(sc, csr_command, TULIP_CMD_PORTSELECT|TULIP_CMD_MUSTBEONE);
! 1593: TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
! 1594: DELAY(10); /* Wait 10 microseconds (actually 50 PCI cycles but at
! 1595: 33MHz that comes to two microseconds but wait a
! 1596: bit longer anyways) */
! 1597: TULIP_CSR_WRITE(sc, csr_command, TULIP_CMD_PORTSELECT |
! 1598: TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
! 1599: sc->tulip_gpinit = TULIP_GP_SMC_9332_PINS;
! 1600: sc->tulip_gpdata = TULIP_GP_SMC_9332_INIT;
! 1601: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_SMC_9332_PINS|TULIP_GP_PINSET);
! 1602: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_SMC_9332_INIT);
! 1603: DELAY(200000);
! 1604: for (idx = 1000; idx > 0; idx--) {
! 1605: u_int32_t csr = TULIP_CSR_READ(sc, csr_gp);
! 1606: if ((csr & (TULIP_GP_SMC_9332_OK10|TULIP_GP_SMC_9332_OK100)) == (TULIP_GP_SMC_9332_OK10|TULIP_GP_SMC_9332_OK100)) {
! 1607: if (++cnt > 100)
! 1608: break;
! 1609: } else if ((csr & TULIP_GP_SMC_9332_OK10) == 0)
! 1610: break;
! 1611: else
! 1612: cnt = 0;
! 1613: DELAY(1000);
! 1614: }
! 1615: sc->tulip_media = cnt > 100 ? TULIP_MEDIA_100BASETX : TULIP_MEDIA_10BASET;
! 1616: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
! 1617: TULIP_GP_SMC_9332_INIT,
! 1618: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1619: |TULIP_CMD_SCRAMBLER);
! 1620: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
! 1621: TULIP_GP_SMC_9332_INIT,
! 1622: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1623: |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
! 1624: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
! 1625: TULIP_GP_SMC_9332_INIT,
! 1626: TULIP_CMD_TXTHRSHLDCTL);
! 1627: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
! 1628: TULIP_GP_SMC_9332_INIT,
! 1629: TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
! 1630: }
! 1631:
! 1632: static const tulip_boardsw_t tulip_21140_smc9332_boardsw = {
! 1633: TULIP_21140_SMC_9332,
! 1634: tulip_21140_smc9332_media_probe,
! 1635: tulip_media_select,
! 1636: tulip_null_media_poll,
! 1637: tulip_2114x_media_preset,
! 1638: };
! 1639:
! 1640: void
! 1641: tulip_21140_cogent_em100_media_probe(tulip_softc_t * const sc)
! 1642: {
! 1643: tulip_media_info_t *mip = sc->tulip_mediainfo;
! 1644: u_int32_t cmdmode = TULIP_CSR_READ(sc, csr_command);
! 1645:
! 1646: sc->tulip_gpinit = TULIP_GP_EM100_PINS;
! 1647: sc->tulip_gpdata = TULIP_GP_EM100_INIT;
! 1648: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EM100_PINS);
! 1649: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EM100_INIT);
! 1650:
! 1651: cmdmode = TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION|TULIP_CMD_MUSTBEONE;
! 1652: cmdmode &= ~(TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_SCRAMBLER);
! 1653: if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100FX_ID) {
! 1654: TULIP_CSR_WRITE(sc, csr_command, cmdmode);
! 1655: sc->tulip_media = TULIP_MEDIA_100BASEFX;
! 1656:
! 1657: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASEFX,
! 1658: TULIP_GP_EM100_INIT,
! 1659: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION);
! 1660: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASEFX_FD,
! 1661: TULIP_GP_EM100_INIT,
! 1662: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1663: |TULIP_CMD_FULLDUPLEX);
! 1664: } else {
! 1665: TULIP_CSR_WRITE(sc, csr_command, cmdmode|TULIP_CMD_SCRAMBLER);
! 1666: sc->tulip_media = TULIP_MEDIA_100BASETX;
! 1667: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
! 1668: TULIP_GP_EM100_INIT,
! 1669: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1670: |TULIP_CMD_SCRAMBLER);
! 1671: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
! 1672: TULIP_GP_EM100_INIT,
! 1673: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1674: |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
! 1675: }
! 1676: }
! 1677:
! 1678: static const tulip_boardsw_t tulip_21140_cogent_em100_boardsw = {
! 1679: TULIP_21140_COGENT_EM100,
! 1680: tulip_21140_cogent_em100_media_probe,
! 1681: tulip_media_select,
! 1682: tulip_null_media_poll,
! 1683: tulip_2114x_media_preset
! 1684: };
! 1685:
! 1686: void
! 1687: tulip_21140_znyx_zx34x_media_probe(tulip_softc_t * const sc)
! 1688: {
! 1689: tulip_media_info_t *mip = sc->tulip_mediainfo;
! 1690: int cnt10 = 0, cnt100 = 0, idx;
! 1691:
! 1692: sc->tulip_gpinit = TULIP_GP_ZX34X_PINS;
! 1693: sc->tulip_gpdata = TULIP_GP_ZX34X_INIT;
! 1694: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ZX34X_PINS);
! 1695: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ZX34X_INIT);
! 1696: TULIP_CSR_WRITE(sc, csr_command,
! 1697: TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
! 1698: TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
! 1699: TULIP_CSR_WRITE(sc, csr_command,
! 1700: TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
! 1701:
! 1702: DELAY(200000);
! 1703: for (idx = 1000; idx > 0; idx--) {
! 1704: u_int32_t csr = TULIP_CSR_READ(sc, csr_gp);
! 1705: if ((csr & (TULIP_GP_ZX34X_LNKFAIL|TULIP_GP_ZX34X_SYMDET|TULIP_GP_ZX34X_SIGDET)) == (TULIP_GP_ZX34X_LNKFAIL|TULIP_GP_ZX34X_SYMDET|TULIP_GP_ZX34X_SIGDET)) {
! 1706: if (++cnt100 > 100)
! 1707: break;
! 1708: } else if ((csr & TULIP_GP_ZX34X_LNKFAIL) == 0) {
! 1709: if (++cnt10 > 100)
! 1710: break;
! 1711: } else {
! 1712: cnt10 = 0;
! 1713: cnt100 = 0;
! 1714: }
! 1715: DELAY(1000);
! 1716: }
! 1717: sc->tulip_media = cnt100 > 100 ? TULIP_MEDIA_100BASETX : TULIP_MEDIA_10BASET;
! 1718: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
! 1719: TULIP_GP_ZX34X_INIT,
! 1720: TULIP_CMD_TXTHRSHLDCTL);
! 1721: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
! 1722: TULIP_GP_ZX34X_INIT,
! 1723: TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
! 1724: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
! 1725: TULIP_GP_ZX34X_INIT,
! 1726: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1727: |TULIP_CMD_SCRAMBLER);
! 1728: tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
! 1729: TULIP_GP_ZX34X_INIT,
! 1730: TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
! 1731: |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
! 1732: }
! 1733:
! 1734: static const tulip_boardsw_t tulip_21140_znyx_zx34x_boardsw = {
! 1735: TULIP_21140_ZNYX_ZX34X,
! 1736: tulip_21140_znyx_zx34x_media_probe,
! 1737: tulip_media_select,
! 1738: tulip_null_media_poll,
! 1739: tulip_2114x_media_preset,
! 1740: };
! 1741:
! 1742: void
! 1743: tulip_2114x_media_probe(tulip_softc_t * const sc)
! 1744: {
! 1745: sc->tulip_cmdmode |= TULIP_CMD_MUSTBEONE
! 1746: |TULIP_CMD_BACKOFFCTR|TULIP_CMD_THRSHLD72;
! 1747: }
! 1748:
! 1749: static const tulip_boardsw_t tulip_2114x_isv_boardsw = {
! 1750: TULIP_21140_ISV,
! 1751: tulip_2114x_media_probe,
! 1752: tulip_media_select,
! 1753: tulip_media_poll,
! 1754: tulip_2114x_media_preset,
! 1755: };
! 1756:
! 1757: /*
! 1758: * ******** END of chip-specific handlers. ***********
! 1759: */
! 1760:
! 1761: /*
! 1762: * Code the read the SROM and MII bit streams (I2C)
! 1763: */
! 1764: void
! 1765: tulip_delay_300ns(tulip_softc_t * const sc)
! 1766: {
! 1767: int idx;
! 1768: for (idx = (300 / 33) + 1; idx > 0; idx--)
! 1769: (void) TULIP_CSR_READ(sc, csr_busmode);
! 1770: }
! 1771:
! 1772: void
! 1773: tulip_srom_idle(tulip_softc_t * const sc)
! 1774: {
! 1775: unsigned bit, csr;
! 1776:
! 1777: csr = SROMSEL ; EMIT;
! 1778: csr = SROMSEL | SROMRD; EMIT;
! 1779: csr ^= SROMCS; EMIT;
! 1780: csr ^= SROMCLKON; EMIT;
! 1781:
! 1782: /*
! 1783: * Write 25 cycles of 0 which will force the SROM to be idle.
! 1784: */
! 1785: for (bit = 3 + SROM_BITWIDTH + 16; bit > 0; bit--) {
! 1786: csr ^= SROMCLKOFF; EMIT; /* clock low; data not valid */
! 1787: csr ^= SROMCLKON; EMIT; /* clock high; data valid */
! 1788: }
! 1789: csr ^= SROMCLKOFF; EMIT;
! 1790: csr ^= SROMCS; EMIT;
! 1791: csr = 0; EMIT;
! 1792: }
! 1793:
! 1794: void
! 1795: tulip_srom_read(tulip_softc_t * const sc)
! 1796: {
! 1797: unsigned idx;
! 1798: const unsigned bitwidth = SROM_BITWIDTH;
! 1799: const unsigned cmdmask = (SROMCMD_RD << bitwidth);
! 1800: const unsigned msb = 1 << (bitwidth + 3 - 1);
! 1801: unsigned lastidx = (1 << bitwidth) - 1;
! 1802:
! 1803: tulip_srom_idle(sc);
! 1804:
! 1805: for (idx = 0; idx <= lastidx; idx++) {
! 1806: unsigned lastbit, data, bits, bit, csr;
! 1807: csr = SROMSEL ; EMIT;
! 1808: csr = SROMSEL | SROMRD; EMIT;
! 1809: csr ^= SROMCSON; EMIT;
! 1810: csr ^= SROMCLKON; EMIT;
! 1811:
! 1812: lastbit = 0;
! 1813: for (bits = idx|cmdmask, bit = bitwidth + 3; bit > 0; bit--, bits <<= 1) {
! 1814: const unsigned thisbit = bits & msb;
! 1815: csr ^= SROMCLKOFF; EMIT; /* clock low; data not valid */
! 1816: if (thisbit != lastbit) {
! 1817: csr ^= SROMDOUT; EMIT; /* clock low; invert data */
! 1818: } else {
! 1819: EMIT;
! 1820: }
! 1821: csr ^= SROMCLKON; EMIT; /* clock high; data valid */
! 1822: lastbit = thisbit;
! 1823: }
! 1824: csr ^= SROMCLKOFF; EMIT;
! 1825:
! 1826: for (data = 0, bits = 0; bits < 16; bits++) {
! 1827: data <<= 1;
! 1828: csr ^= SROMCLKON; EMIT; /* clock high; data valid */
! 1829: data |= TULIP_CSR_READ(sc, csr_srom_mii) & SROMDIN ? 1 : 0;
! 1830: csr ^= SROMCLKOFF; EMIT; /* clock low; data not valid */
! 1831: }
! 1832: sc->tulip_rombuf[idx*2] = data & 0xFF;
! 1833: sc->tulip_rombuf[idx*2+1] = data >> 8;
! 1834: csr = SROMSEL | SROMRD; EMIT;
! 1835: csr = 0; EMIT;
! 1836: }
! 1837: tulip_srom_idle(sc);
! 1838: }
! 1839:
! 1840: void
! 1841: tulip_mii_writebits(tulip_softc_t * const sc, unsigned data, unsigned bits)
! 1842: {
! 1843: unsigned msb = 1 << (bits - 1);
! 1844: unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
! 1845: unsigned lastbit = (csr & MII_DOUT) ? msb : 0;
! 1846:
! 1847: csr |= MII_WR; MII_EMIT; /* clock low; assert write */
! 1848:
! 1849: for (; bits > 0; bits--, data <<= 1) {
! 1850: const unsigned thisbit = data & msb;
! 1851: if (thisbit != lastbit)
! 1852: csr ^= MII_DOUT; MII_EMIT; /* clock low; invert data */
! 1853: csr ^= MII_CLKON; MII_EMIT; /* clock high; data valid */
! 1854: lastbit = thisbit;
! 1855: csr ^= MII_CLKOFF; MII_EMIT; /* clock low; data not valid */
! 1856: }
! 1857: }
! 1858:
! 1859: void
! 1860: tulip_mii_turnaround(tulip_softc_t * const sc, unsigned cmd)
! 1861: {
! 1862: unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
! 1863:
! 1864: if (cmd == MII_WRCMD) {
! 1865: csr |= MII_DOUT; MII_EMIT; /* clock low; change data */
! 1866: csr ^= MII_CLKON; MII_EMIT; /* clock high; data valid */
! 1867: csr ^= MII_CLKOFF; MII_EMIT; /* clock low; data not valid */
! 1868: csr ^= MII_DOUT; MII_EMIT; /* clock low; change data */
! 1869: } else
! 1870: csr |= MII_RD; MII_EMIT; /* clock low; switch to read */
! 1871: csr ^= MII_CLKON; MII_EMIT; /* clock high; data valid */
! 1872: csr ^= MII_CLKOFF; MII_EMIT; /* clock low; data not valid */
! 1873: }
! 1874:
! 1875: unsigned
! 1876: tulip_mii_readbits(tulip_softc_t * const sc)
! 1877: {
! 1878: unsigned data;
! 1879: unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
! 1880: int idx;
! 1881:
! 1882: for (idx = 0, data = 0; idx < 16; idx++) {
! 1883: data <<= 1; /* this is NOOP on the first pass through */
! 1884: csr ^= MII_CLKON; MII_EMIT; /* clock high; data valid */
! 1885: if (TULIP_CSR_READ(sc, csr_srom_mii) & MII_DIN)
! 1886: data |= 1;
! 1887: csr ^= MII_CLKOFF; MII_EMIT; /* clock low; data not valid */
! 1888: }
! 1889: csr ^= MII_RD; MII_EMIT; /* clock low; turn off read */
! 1890:
! 1891: return (data);
! 1892: }
! 1893:
! 1894: unsigned
! 1895: tulip_mii_readreg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno)
! 1896: {
! 1897: unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
! 1898: unsigned data;
! 1899:
! 1900: csr &= ~(MII_RD|MII_CLK); MII_EMIT;
! 1901: tulip_mii_writebits(sc, MII_PREAMBLE, 32);
! 1902: tulip_mii_writebits(sc, MII_RDCMD, 8);
! 1903: tulip_mii_writebits(sc, devaddr, 5);
! 1904: tulip_mii_writebits(sc, regno, 5);
! 1905: tulip_mii_turnaround(sc, MII_RDCMD);
! 1906:
! 1907: data = tulip_mii_readbits(sc);
! 1908: #if defined(TULIP_DEBUG)
! 1909: sc->tulip_dbg.dbg_phyregs[regno][0] = data;
! 1910: sc->tulip_dbg.dbg_phyregs[regno][1]++;
! 1911: #endif
! 1912: return (data);
! 1913: }
! 1914:
! 1915: void
! 1916: tulip_mii_writereg(tulip_softc_t * const sc, unsigned devaddr,
! 1917: unsigned regno, unsigned data)
! 1918: {
! 1919: unsigned csr;
! 1920:
! 1921: csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
! 1922: csr &= ~(MII_RD|MII_CLK); MII_EMIT;
! 1923: tulip_mii_writebits(sc, MII_PREAMBLE, 32);
! 1924: tulip_mii_writebits(sc, MII_WRCMD, 8);
! 1925: tulip_mii_writebits(sc, devaddr, 5);
! 1926: tulip_mii_writebits(sc, regno, 5);
! 1927: tulip_mii_turnaround(sc, MII_WRCMD);
! 1928: tulip_mii_writebits(sc, data, 16);
! 1929: #if defined(TULIP_DEBUG)
! 1930: sc->tulip_dbg.dbg_phyregs[regno][2] = data;
! 1931: sc->tulip_dbg.dbg_phyregs[regno][3]++;
! 1932: #endif
! 1933: }
! 1934:
! 1935: void
! 1936: tulip_identify_dec_nic(tulip_softc_t * const sc)
! 1937: {
! 1938: strlcpy(sc->tulip_boardid, "DEC ", sizeof(sc->tulip_boardid));
! 1939: #define D0 4
! 1940: if (sc->tulip_chipid <= TULIP_DE425)
! 1941: return;
! 1942: if (bcmp(sc->tulip_rombuf + 29, "DE500", 5) == 0
! 1943: || bcmp(sc->tulip_rombuf + 29, "DE450", 5) == 0) {
! 1944: bcopy(sc->tulip_rombuf + 29, &sc->tulip_boardid[D0], 8);
! 1945: sc->tulip_boardid[D0+8] = ' ';
! 1946: }
! 1947: #undef D0
! 1948: }
! 1949:
! 1950: void
! 1951: tulip_identify_znyx_nic(tulip_softc_t * const sc)
! 1952: {
! 1953: unsigned id = 0;
! 1954: strlcpy(sc->tulip_boardid, "ZNYX ZX3XX ", sizeof(sc->tulip_boardid));
! 1955: if (sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A) {
! 1956: unsigned znyx_ptr;
! 1957: sc->tulip_boardid[8] = '4';
! 1958: znyx_ptr = sc->tulip_rombuf[124] + 256 * sc->tulip_rombuf[125];
! 1959: if (znyx_ptr < 26 || znyx_ptr > 116) {
! 1960: sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
! 1961: return;
! 1962: }
! 1963: /* ZX344 = 0010 .. 0013FF
! 1964: */
! 1965: if (sc->tulip_rombuf[znyx_ptr] == 0x4A
! 1966: && sc->tulip_rombuf[znyx_ptr + 1] == 0x52
! 1967: && sc->tulip_rombuf[znyx_ptr + 2] == 0x01) {
! 1968: id = sc->tulip_rombuf[znyx_ptr + 5] + 256 * sc->tulip_rombuf[znyx_ptr + 4];
! 1969: if ((id >> 8) == (TULIP_ZNYX_ID_ZX342 >> 8)) {
! 1970: sc->tulip_boardid[9] = '2';
! 1971: if (id == TULIP_ZNYX_ID_ZX342B) {
! 1972: sc->tulip_boardid[10] = 'B';
! 1973: sc->tulip_boardid[11] = ' ';
! 1974: }
! 1975: sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
! 1976: } else if (id == TULIP_ZNYX_ID_ZX344) {
! 1977: sc->tulip_boardid[10] = '4';
! 1978: sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
! 1979: } else if (id == TULIP_ZNYX_ID_ZX345) {
! 1980: sc->tulip_boardid[9] = (sc->tulip_rombuf[19] > 1) ? '8' : '5';
! 1981: } else if (id == TULIP_ZNYX_ID_ZX346) {
! 1982: sc->tulip_boardid[9] = '6';
! 1983: } else if (id == TULIP_ZNYX_ID_ZX351) {
! 1984: sc->tulip_boardid[8] = '5';
! 1985: sc->tulip_boardid[9] = '1';
! 1986: }
! 1987: }
! 1988: if (id == 0) {
! 1989: /*
! 1990: * Assume it's a ZX342...
! 1991: */
! 1992: sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
! 1993: }
! 1994: return;
! 1995: }
! 1996: sc->tulip_boardid[8] = '1';
! 1997: if (sc->tulip_chipid == TULIP_21041) {
! 1998: sc->tulip_boardid[10] = '1';
! 1999: return;
! 2000: }
! 2001: if (sc->tulip_rombuf[32] == 0x4A && sc->tulip_rombuf[33] == 0x52) {
! 2002: id = sc->tulip_rombuf[37] + 256 * sc->tulip_rombuf[36];
! 2003: if (id == TULIP_ZNYX_ID_ZX312T) {
! 2004: sc->tulip_boardid[9] = '2';
! 2005: sc->tulip_boardid[10] = 'T';
! 2006: sc->tulip_boardid[11] = ' ';
! 2007: sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
! 2008: } else if (id == TULIP_ZNYX_ID_ZX314_INTA) {
! 2009: sc->tulip_boardid[9] = '4';
! 2010: sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
! 2011: sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
! 2012: } else if (id == TULIP_ZNYX_ID_ZX314) {
! 2013: sc->tulip_boardid[9] = '4';
! 2014: sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
! 2015: sc->tulip_features |= TULIP_HAVE_BASEROM;
! 2016: } else if (id == TULIP_ZNYX_ID_ZX315_INTA) {
! 2017: sc->tulip_boardid[9] = '5';
! 2018: sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
! 2019: } else if (id == TULIP_ZNYX_ID_ZX315) {
! 2020: sc->tulip_boardid[9] = '5';
! 2021: sc->tulip_features |= TULIP_HAVE_BASEROM;
! 2022: } else
! 2023: id = 0;
! 2024: }
! 2025: if (id == 0) {
! 2026: if ((sc->tulip_enaddr[3] & ~3) == 0xF0 && (sc->tulip_enaddr[5] & 3) == 0) {
! 2027: sc->tulip_boardid[9] = '4';
! 2028: sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
! 2029: sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
! 2030: } else if ((sc->tulip_enaddr[3] & ~3) == 0xF4 && (sc->tulip_enaddr[5] & 1) == 0) {
! 2031: sc->tulip_boardid[9] = '5';
! 2032: sc->tulip_boardsw = &tulip_21040_boardsw;
! 2033: sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
! 2034: } else if ((sc->tulip_enaddr[3] & ~3) == 0xEC) {
! 2035: sc->tulip_boardid[9] = '2';
! 2036: sc->tulip_boardsw = &tulip_21040_boardsw;
! 2037: }
! 2038: }
! 2039: }
! 2040:
! 2041: void
! 2042: tulip_identify_smc_nic(tulip_softc_t * const sc)
! 2043: {
! 2044: u_int32_t id1, id2, ei;
! 2045: int auibnc = 0, utp = 0;
! 2046: char *cp;
! 2047:
! 2048: strlcpy(sc->tulip_boardid, "SMC ", sizeof(sc->tulip_boardid));
! 2049: if (sc->tulip_chipid == TULIP_21041)
! 2050: return;
! 2051: if (sc->tulip_chipid != TULIP_21040) {
! 2052: if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw) {
! 2053: strlcat(sc->tulip_boardid, "9332DST ", sizeof(sc->tulip_boardid));
! 2054: sc->tulip_boardsw = &tulip_21140_smc9332_boardsw;
! 2055: } else if (sc->tulip_features & (TULIP_HAVE_BASEROM|TULIP_HAVE_SLAVEDROM))
! 2056: strlcat(sc->tulip_boardid, "9334BDT ", sizeof(sc->tulip_boardid));
! 2057: else
! 2058: strlcat(sc->tulip_boardid, "9332BDT ", sizeof(sc->tulip_boardid));
! 2059: return;
! 2060: }
! 2061: id1 = sc->tulip_rombuf[0x60] | (sc->tulip_rombuf[0x61] << 8);
! 2062: id2 = sc->tulip_rombuf[0x62] | (sc->tulip_rombuf[0x63] << 8);
! 2063: ei = sc->tulip_rombuf[0x66] | (sc->tulip_rombuf[0x67] << 8);
! 2064:
! 2065: strlcat(sc->tulip_boardid, "8432", sizeof(sc->tulip_boardid));
! 2066: cp = &sc->tulip_boardid[8];
! 2067: if ((id1 & 1) == 0)
! 2068: *cp++ = 'B', auibnc = 1;
! 2069: if ((id1 & 0xFF) > 0x32)
! 2070: *cp++ = 'T', utp = 1;
! 2071: if ((id1 & 0x4000) == 0)
! 2072: *cp++ = 'A', auibnc = 1;
! 2073: if (id2 == 0x15) {
! 2074: sc->tulip_boardid[7] = '4';
! 2075: *cp++ = '-';
! 2076: *cp++ = 'C';
! 2077: *cp++ = 'H';
! 2078: *cp++ = (ei ? '2' : '1');
! 2079: }
! 2080: *cp++ = ' ';
! 2081: *cp = '\0';
! 2082: if (utp && !auibnc)
! 2083: sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
! 2084: else if (!utp && auibnc)
! 2085: sc->tulip_boardsw = &tulip_21040_auibnc_only_boardsw;
! 2086: }
! 2087:
! 2088: void
! 2089: tulip_identify_cogent_nic(tulip_softc_t * const sc)
! 2090: {
! 2091: strlcpy(sc->tulip_boardid, "Cogent ", sizeof(sc->tulip_boardid));
! 2092: if (sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A) {
! 2093: if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100TX_ID) {
! 2094: strlcat(sc->tulip_boardid, "EM100TX ", sizeof(sc->tulip_boardid));
! 2095: sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
! 2096: #if defined(TULIP_COGENT_EM110TX_ID)
! 2097: } else if (sc->tulip_rombuf[32] == TULIP_COGENT_EM110TX_ID) {
! 2098: strlcat(sc->tulip_boardid, "EM110TX ", sizeof(sc->tulip_boardid));
! 2099: sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
! 2100: #endif
! 2101: } else if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100FX_ID) {
! 2102: strlcat(sc->tulip_boardid, "EM100FX ", sizeof(sc->tulip_boardid));
! 2103: sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
! 2104: }
! 2105: /*
! 2106: * Magic number (0x24001109U) is the SubVendor (0x2400) and
! 2107: * SubDevId (0x1109) for the ANA6944TX (EM440TX).
! 2108: */
! 2109: if (*(u_int32_t *) sc->tulip_rombuf == 0x24001109U
! 2110: && (sc->tulip_features & TULIP_HAVE_BASEROM)) {
! 2111: /*
! 2112: * Cogent (Adaptec) is still mapping all INTs to INTA of
! 2113: * first 21140. Dumb! Dumb!
! 2114: */
! 2115: strlcat(sc->tulip_boardid, "EM440TX ", sizeof(sc->tulip_boardid));
! 2116: sc->tulip_features |= TULIP_HAVE_SHAREDINTR;
! 2117: }
! 2118: } else if (sc->tulip_chipid == TULIP_21040)
! 2119: sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
! 2120: }
! 2121:
! 2122: void
! 2123: tulip_identify_accton_nic(tulip_softc_t * const sc)
! 2124: {
! 2125: strlcpy(sc->tulip_boardid, "ACCTON ", sizeof(sc->tulip_boardid));
! 2126: switch (sc->tulip_chipid) {
! 2127: case TULIP_21140A:
! 2128: strlcat(sc->tulip_boardid, "EN1207 ", sizeof(sc->tulip_boardid));
! 2129: if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw)
! 2130: sc->tulip_boardsw = &tulip_21140_accton_boardsw;
! 2131: break;
! 2132: case TULIP_21140:
! 2133: strlcat(sc->tulip_boardid, "EN1207TX ", sizeof(sc->tulip_boardid));
! 2134: if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw)
! 2135: sc->tulip_boardsw = &tulip_21140_eb_boardsw;
! 2136: break;
! 2137: case TULIP_21040:
! 2138: strlcat(sc->tulip_boardid, "EN1203 ", sizeof(sc->tulip_boardid));
! 2139: sc->tulip_boardsw = &tulip_21040_boardsw;
! 2140: break;
! 2141: case TULIP_21041:
! 2142: strlcat(sc->tulip_boardid, "EN1203 ", sizeof(sc->tulip_boardid));
! 2143: sc->tulip_boardsw = &tulip_21041_boardsw;
! 2144: break;
! 2145: default:
! 2146: sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
! 2147: break;
! 2148: }
! 2149: }
! 2150:
! 2151: void
! 2152: tulip_identify_asante_nic(tulip_softc_t * const sc)
! 2153: {
! 2154: strlcpy(sc->tulip_boardid, "Asante ", sizeof(sc->tulip_boardid));
! 2155: if ((sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A)
! 2156: && sc->tulip_boardsw != &tulip_2114x_isv_boardsw) {
! 2157: tulip_media_info_t *mi = sc->tulip_mediainfo;
! 2158: int idx;
! 2159: /*
! 2160: * The Asante Fast Ethernet doesn't always ship with a valid
! 2161: * new format SROM. So if isn't in the new format, we cheat
! 2162: * set it up as if we had.
! 2163: */
! 2164:
! 2165: sc->tulip_gpinit = TULIP_GP_ASANTE_PINS;
! 2166: sc->tulip_gpdata = 0;
! 2167:
! 2168: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ASANTE_PINS|TULIP_GP_PINSET);
! 2169: TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ASANTE_PHYRESET);
! 2170: DELAY(100);
! 2171: TULIP_CSR_WRITE(sc, csr_gp, 0);
! 2172:
! 2173: mi->mi_type = TULIP_MEDIAINFO_MII;
! 2174: mi->mi_gpr_length = 0;
! 2175: mi->mi_gpr_offset = 0;
! 2176: mi->mi_reset_length = 0;
! 2177: mi->mi_reset_offset = 0;
! 2178:
! 2179: mi->mi_phyaddr = TULIP_MII_NOPHY;
! 2180: for (idx = 20; idx > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx--) {
! 2181: DELAY(10000);
! 2182: mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, 0);
! 2183: }
! 2184: if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
! 2185: #ifdef TULIP_DEBUG
! 2186: printf(TULIP_PRINTF_FMT ": can't find phy 0\n", TULIP_PRINTF_ARGS);
! 2187: #endif
! 2188: return;
! 2189: }
! 2190:
! 2191: sc->tulip_features |= TULIP_HAVE_MII;
! 2192: mi->mi_capabilities = PHYSTS_10BASET|PHYSTS_10BASET_FD|PHYSTS_100BASETX|PHYSTS_100BASETX_FD;
! 2193: mi->mi_advertisement = PHYSTS_10BASET|PHYSTS_10BASET_FD|PHYSTS_100BASETX|PHYSTS_100BASETX_FD;
! 2194: mi->mi_full_duplex = PHYSTS_10BASET_FD|PHYSTS_100BASETX_FD;
! 2195: mi->mi_tx_threshold = PHYSTS_10BASET|PHYSTS_10BASET_FD;
! 2196: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
! 2197: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
! 2198: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
! 2199: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
! 2200: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
! 2201: mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
! 2202: tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
! 2203:
! 2204: sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
! 2205: }
! 2206: }
! 2207:
! 2208: void
! 2209: tulip_identify_compex_nic(tulip_softc_t * const sc)
! 2210: {
! 2211: strlcpy(sc->tulip_boardid, "COMPEX ", sizeof(sc->tulip_boardid));
! 2212: if (sc->tulip_chipid == TULIP_21140A) {
! 2213: int root_unit;
! 2214: tulip_softc_t *root_sc = NULL;
! 2215:
! 2216: strlcat(sc->tulip_boardid, "400TX/PCI ", sizeof(sc->tulip_boardid));
! 2217: /*
! 2218: * All 4 chips on these boards share an interrupt. This code
! 2219: * copied from tulip_read_macaddr.
! 2220: */
! 2221: sc->tulip_features |= TULIP_HAVE_SHAREDINTR;
! 2222: for (root_unit = sc->tulip_unit - 1; root_unit >= 0; root_unit--) {
! 2223: root_sc = TULIP_UNIT_TO_SOFTC(root_unit);
! 2224: if (root_sc == NULL
! 2225: || !(root_sc->tulip_features & TULIP_HAVE_SLAVEDINTR))
! 2226: break;
! 2227: root_sc = NULL;
! 2228: }
! 2229: if (root_sc != NULL
! 2230: && root_sc->tulip_chipid == sc->tulip_chipid
! 2231: && root_sc->tulip_pci_busno == sc->tulip_pci_busno) {
! 2232: sc->tulip_features |= TULIP_HAVE_SLAVEDINTR;
! 2233: sc->tulip_slaves = root_sc->tulip_slaves;
! 2234: root_sc->tulip_slaves = sc;
! 2235: } else if(sc->tulip_features & TULIP_HAVE_SLAVEDINTR)
! 2236: printf("\nCannot find master device for de%d interrupts", sc->tulip_unit);
! 2237: } else
! 2238: strlcat(sc->tulip_boardid, "unknown ", sizeof(sc->tulip_boardid));
! 2239:
! 2240: /* sc->tulip_boardsw = &tulip_21140_eb_boardsw; */
! 2241: }
! 2242:
! 2243: int
! 2244: tulip_srom_decode(tulip_softc_t * const sc)
! 2245: {
! 2246: unsigned idx1, idx2, idx3;
! 2247:
! 2248: const tulip_srom_header_t *shp = (tulip_srom_header_t *) &sc->tulip_rombuf[0];
! 2249: const tulip_srom_adapter_info_t *saip = (tulip_srom_adapter_info_t *) (shp + 1);
! 2250: tulip_srom_media_t srom_media;
! 2251: tulip_media_info_t *mi = sc->tulip_mediainfo;
! 2252: const u_int8_t *dp;
! 2253: u_int32_t leaf_offset, blocks, data;
! 2254:
! 2255: for (idx1 = 0; idx1 < shp->sh_adapter_count; idx1++, saip++) {
! 2256: if (shp->sh_adapter_count == 1)
! 2257: break;
! 2258: if (saip->sai_device == sc->tulip_pci_devno)
! 2259: break;
! 2260: }
! 2261: /*
! 2262: * Didn't find the right media block for this card.
! 2263: */
! 2264: if (idx1 == shp->sh_adapter_count)
! 2265: return (0);
! 2266:
! 2267: /*
! 2268: * Save the hardware address.
! 2269: */
! 2270: bcopy((caddr_t) shp->sh_ieee802_address, (caddr_t) sc->tulip_enaddr,
! 2271: ETHER_ADDR_LEN);
! 2272: /*
! 2273: * If this is a multiple port card, add the adapter index to the last
! 2274: * byte of the hardware address. (if it isn't multiport, adding 0
! 2275: * won't hurt.
! 2276: */
! 2277: sc->tulip_enaddr[5] += idx1;
! 2278:
! 2279: leaf_offset = saip->sai_leaf_offset_lowbyte
! 2280: + saip->sai_leaf_offset_highbyte * 256;
! 2281: dp = sc->tulip_rombuf + leaf_offset;
! 2282:
! 2283: sc->tulip_conntype = (tulip_srom_connection_t) (dp[0] + dp[1] * 256); dp += 2;
! 2284:
! 2285: for (idx2 = 0;; idx2++) {
! 2286: if (tulip_srom_conninfo[idx2].sc_type == sc->tulip_conntype
! 2287: || tulip_srom_conninfo[idx2].sc_type == TULIP_SROM_CONNTYPE_NOT_USED)
! 2288: break;
! 2289: }
! 2290: sc->tulip_connidx = idx2;
! 2291:
! 2292: if (sc->tulip_chipid == TULIP_21041) {
! 2293: blocks = *dp++;
! 2294: for (idx2 = 0; idx2 < blocks; idx2++) {
! 2295: tulip_media_t media;
! 2296: data = *dp++;
! 2297: srom_media = (tulip_srom_media_t) (data & 0x3F);
! 2298: for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
! 2299: if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
! 2300: break;
! 2301: }
! 2302: media = tulip_srom_mediums[idx3].sm_type;
! 2303: if (media != TULIP_MEDIA_UNKNOWN) {
! 2304: if (data & TULIP_SROM_21041_EXTENDED) {
! 2305: mi->mi_type = TULIP_MEDIAINFO_SIA;
! 2306: sc->tulip_mediums[media] = mi;
! 2307: mi->mi_sia_connectivity = dp[0] + dp[1] * 256;
! 2308: mi->mi_sia_tx_rx = dp[2] + dp[3] * 256;
! 2309: mi->mi_sia_general = dp[4] + dp[5] * 256;
! 2310: mi++;
! 2311: } else {
! 2312: switch (media) {
! 2313: case TULIP_MEDIA_BNC: {
! 2314: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, BNC);
! 2315: mi++;
! 2316: break;
! 2317: }
! 2318: case TULIP_MEDIA_AUI: {
! 2319: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, AUI);
! 2320: mi++;
! 2321: break;
! 2322: }
! 2323: case TULIP_MEDIA_10BASET: {
! 2324: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, 10BASET);
! 2325: mi++;
! 2326: break;
! 2327: }
! 2328: case TULIP_MEDIA_10BASET_FD: {
! 2329: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, 10BASET_FD);
! 2330: mi++;
! 2331: break;
! 2332: }
! 2333: default: {
! 2334: break;
! 2335: }
! 2336: }
! 2337: }
! 2338: }
! 2339: if (data & TULIP_SROM_21041_EXTENDED)
! 2340: dp += 6;
! 2341: }
! 2342: } else {
! 2343: unsigned length, type;
! 2344: tulip_media_t gp_media = TULIP_MEDIA_UNKNOWN;
! 2345: if (sc->tulip_features & TULIP_HAVE_GPR)
! 2346: sc->tulip_gpinit = *dp++;
! 2347: blocks = *dp++;
! 2348: for (idx2 = 0; idx2 < blocks; idx2++) {
! 2349: const u_int8_t *ep;
! 2350: if ((*dp & 0x80) == 0) {
! 2351: length = 4;
! 2352: type = 0;
! 2353: } else {
! 2354: length = (*dp++ & 0x7f) - 1;
! 2355: type = *dp++ & 0x3f;
! 2356: }
! 2357: ep = dp + length;
! 2358: switch (type & 0x3f) {
! 2359: case 0: { /* 21140[A] GPR block */
! 2360: tulip_media_t media;
! 2361: srom_media = (tulip_srom_media_t)(dp[0] & 0x3f);
! 2362: for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
! 2363: if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
! 2364: break;
! 2365: }
! 2366: media = tulip_srom_mediums[idx3].sm_type;
! 2367: if (media == TULIP_MEDIA_UNKNOWN)
! 2368: break;
! 2369: mi->mi_type = TULIP_MEDIAINFO_GPR;
! 2370: sc->tulip_mediums[media] = mi;
! 2371: mi->mi_gpdata = dp[1];
! 2372: if (media > gp_media && !TULIP_IS_MEDIA_FD(media)) {
! 2373: sc->tulip_gpdata = mi->mi_gpdata;
! 2374: gp_media = media;
! 2375: }
! 2376: data = dp[2] + dp[3] * 256;
! 2377: mi->mi_cmdmode = TULIP_SROM_2114X_CMDBITS(data);
! 2378: if (data & TULIP_SROM_2114X_NOINDICATOR)
! 2379: mi->mi_actmask = 0;
! 2380: else {
! 2381: mi->mi_actmask = TULIP_SROM_2114X_BITPOS(data);
! 2382: mi->mi_actdata = (data & TULIP_SROM_2114X_POLARITY) ? 0 : mi->mi_actmask;
! 2383: }
! 2384: mi++;
! 2385: break;
! 2386: }
! 2387: case 1: { /* 21140[A] MII block */
! 2388: const unsigned phyno = *dp++;
! 2389: mi->mi_type = TULIP_MEDIAINFO_MII;
! 2390: mi->mi_gpr_length = *dp++;
! 2391: mi->mi_gpr_offset = dp - sc->tulip_rombuf;
! 2392: dp += mi->mi_gpr_length;
! 2393: mi->mi_reset_length = *dp++;
! 2394: mi->mi_reset_offset = dp - sc->tulip_rombuf;
! 2395: dp += mi->mi_reset_length;
! 2396:
! 2397: /*
! 2398: * Before we probe for a PHY, use the GPR information
! 2399: * to select it. If we don't, it may be inaccessible.
! 2400: */
! 2401: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_gpinit|TULIP_GP_PINSET);
! 2402: for (idx3 = 0; idx3 < mi->mi_reset_length; idx3++) {
! 2403: DELAY(10);
! 2404: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_reset_offset + idx3]);
! 2405: }
! 2406: sc->tulip_phyaddr = mi->mi_phyaddr;
! 2407: for (idx3 = 0; idx3 < mi->mi_gpr_length; idx3++) {
! 2408: DELAY(10);
! 2409: TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_gpr_offset + idx3]);
! 2410: }
! 2411:
! 2412: /*
! 2413: * At least write something!
! 2414: */
! 2415: if (mi->mi_reset_length == 0 && mi->mi_gpr_length == 0)
! 2416: TULIP_CSR_WRITE(sc, csr_gp, 0);
! 2417:
! 2418: mi->mi_phyaddr = TULIP_MII_NOPHY;
! 2419: for (idx3 = 20; idx3 > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx3--) {
! 2420: DELAY(10000);
! 2421: mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, phyno);
! 2422: }
! 2423: if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
! 2424: #if defined(TULIP_DEBUG)
! 2425: printf(TULIP_PRINTF_FMT ": can't find phy %d\n",
! 2426: TULIP_PRINTF_ARGS, phyno);
! 2427: #endif
! 2428: break;
! 2429: }
! 2430: sc->tulip_features |= TULIP_HAVE_MII;
! 2431: mi->mi_capabilities = dp[0] + dp[1] * 256; dp += 2;
! 2432: mi->mi_advertisement = dp[0] + dp[1] * 256; dp += 2;
! 2433: mi->mi_full_duplex = dp[0] + dp[1] * 256; dp += 2;
! 2434: mi->mi_tx_threshold = dp[0] + dp[1] * 256; dp += 2;
! 2435: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
! 2436: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
! 2437: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
! 2438: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
! 2439: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
! 2440: mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
! 2441: tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
! 2442: mi++;
! 2443: break;
! 2444: }
! 2445: case 2: { /* 2114[23] SIA block */
! 2446: tulip_media_t media;
! 2447: srom_media = (tulip_srom_media_t)(dp[0] & 0x3f);
! 2448: for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
! 2449: if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
! 2450: break;
! 2451: }
! 2452: media = tulip_srom_mediums[idx3].sm_type;
! 2453: if (media == TULIP_MEDIA_UNKNOWN)
! 2454: break;
! 2455: mi->mi_type = TULIP_MEDIAINFO_SIA;
! 2456: sc->tulip_mediums[media] = mi;
! 2457: if (dp[0] & 0x40) {
! 2458: mi->mi_sia_connectivity = dp[1] + dp[2] * 256;
! 2459: mi->mi_sia_tx_rx = dp[3] + dp[4] * 256;
! 2460: mi->mi_sia_general = dp[5] + dp[6] * 256;
! 2461: dp += 6;
! 2462: } else {
! 2463: switch (media) {
! 2464: case TULIP_MEDIA_BNC: {
! 2465: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, BNC);
! 2466: break;
! 2467: }
! 2468: case TULIP_MEDIA_AUI: {
! 2469: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, AUI);
! 2470: break;
! 2471: }
! 2472: case TULIP_MEDIA_10BASET: {
! 2473: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, 10BASET);
! 2474: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 2475: break;
! 2476: }
! 2477: case TULIP_MEDIA_10BASET_FD: {
! 2478: TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, 10BASET_FD);
! 2479: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 2480: break;
! 2481: }
! 2482: default: {
! 2483: goto bad_media;
! 2484: }
! 2485: }
! 2486: }
! 2487: mi->mi_sia_gp_control = (dp[1] + dp[2] * 256) << 16;
! 2488: mi->mi_sia_gp_data = (dp[3] + dp[4] * 256) << 16;
! 2489: mi++;
! 2490: bad_media:
! 2491: break;
! 2492: }
! 2493: case 3: { /* 2114[23] MII PHY block */
! 2494: const unsigned phyno = *dp++;
! 2495: const u_int8_t *dp0;
! 2496: mi->mi_type = TULIP_MEDIAINFO_MII;
! 2497: mi->mi_gpr_length = *dp++;
! 2498: mi->mi_gpr_offset = dp - sc->tulip_rombuf;
! 2499: dp += 2 * mi->mi_gpr_length;
! 2500: mi->mi_reset_length = *dp++;
! 2501: mi->mi_reset_offset = dp - sc->tulip_rombuf;
! 2502: dp += 2 * mi->mi_reset_length;
! 2503:
! 2504: dp0 = &sc->tulip_rombuf[mi->mi_reset_offset];
! 2505: for (idx3 = 0; idx3 < mi->mi_reset_length; idx3++, dp0 += 2) {
! 2506: DELAY(10);
! 2507: TULIP_CSR_WRITE(sc, csr_sia_general, (dp0[0] + 256 * dp0[1]) << 16);
! 2508: }
! 2509: sc->tulip_phyaddr = mi->mi_phyaddr;
! 2510: dp0 = &sc->tulip_rombuf[mi->mi_gpr_offset];
! 2511: for (idx3 = 0; idx3 < mi->mi_gpr_length; idx3++, dp0 += 2) {
! 2512: DELAY(10);
! 2513: TULIP_CSR_WRITE(sc, csr_sia_general, (dp0[0] + 256 * dp0[1]) << 16);
! 2514: }
! 2515:
! 2516: if (mi->mi_reset_length == 0 && mi->mi_gpr_length == 0)
! 2517: TULIP_CSR_WRITE(sc, csr_sia_general, 0);
! 2518:
! 2519: mi->mi_phyaddr = TULIP_MII_NOPHY;
! 2520: for (idx3 = 20; idx3 > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx3--) {
! 2521: DELAY(10000);
! 2522: mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, phyno);
! 2523: }
! 2524: if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
! 2525: #if defined(TULIP_DEBUG)
! 2526: printf(TULIP_PRINTF_FMT ": can't find phy %d\n",
! 2527: TULIP_PRINTF_ARGS, phyno);
! 2528: #endif
! 2529: break;
! 2530: }
! 2531: sc->tulip_features |= TULIP_HAVE_MII;
! 2532: mi->mi_capabilities = dp[0] + dp[1] * 256; dp += 2;
! 2533: mi->mi_advertisement = dp[0] + dp[1] * 256; dp += 2;
! 2534: mi->mi_full_duplex = dp[0] + dp[1] * 256; dp += 2;
! 2535: mi->mi_tx_threshold = dp[0] + dp[1] * 256; dp += 2;
! 2536: mi->mi_mii_interrupt = dp[0] + dp[1] * 256; dp += 2;
! 2537: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
! 2538: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
! 2539: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
! 2540: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
! 2541: TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
! 2542: mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
! 2543: tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
! 2544: mi++;
! 2545: break;
! 2546: }
! 2547: case 4: { /* 21143 SYM block */
! 2548: tulip_media_t media;
! 2549: srom_media = (tulip_srom_media_t) dp[0];
! 2550: for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
! 2551: if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
! 2552: break;
! 2553: }
! 2554: media = tulip_srom_mediums[idx3].sm_type;
! 2555: if (media == TULIP_MEDIA_UNKNOWN)
! 2556: break;
! 2557: mi->mi_type = TULIP_MEDIAINFO_SYM;
! 2558: sc->tulip_mediums[media] = mi;
! 2559: mi->mi_gpcontrol = (dp[1] + dp[2] * 256) << 16;
! 2560: mi->mi_gpdata = (dp[3] + dp[4] * 256) << 16;
! 2561: data = dp[5] + dp[6] * 256;
! 2562: mi->mi_cmdmode = TULIP_SROM_2114X_CMDBITS(data);
! 2563: if (data & TULIP_SROM_2114X_NOINDICATOR)
! 2564: mi->mi_actmask = 0;
! 2565: else {
! 2566: mi->mi_default = (data & TULIP_SROM_2114X_DEFAULT) != 0;
! 2567: mi->mi_actmask = TULIP_SROM_2114X_BITPOS(data);
! 2568: mi->mi_actdata = (data & TULIP_SROM_2114X_POLARITY) ? 0 : mi->mi_actmask;
! 2569: }
! 2570: if (TULIP_IS_MEDIA_TP(media))
! 2571: sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
! 2572: mi++;
! 2573: break;
! 2574: }
! 2575: default: {
! 2576: }
! 2577: }
! 2578: dp = ep;
! 2579: }
! 2580: }
! 2581: return (mi - sc->tulip_mediainfo);
! 2582: }
! 2583:
! 2584: static const struct {
! 2585: void (*vendor_identify_nic)(tulip_softc_t * const sc);
! 2586: unsigned char vendor_oui[3];
! 2587: } tulip_vendors[] = {
! 2588: { tulip_identify_dec_nic, { 0x08, 0x00, 0x2B } },
! 2589: { tulip_identify_dec_nic, { 0x00, 0x00, 0xF8 } },
! 2590: { tulip_identify_smc_nic, { 0x00, 0x00, 0xC0 } },
! 2591: { tulip_identify_smc_nic, { 0x00, 0xE0, 0x29 } },
! 2592: { tulip_identify_znyx_nic, { 0x00, 0xC0, 0x95 } },
! 2593: { tulip_identify_cogent_nic, { 0x00, 0x00, 0x92 } },
! 2594: { tulip_identify_cogent_nic, { 0x00, 0x00, 0xD1 } },
! 2595: { tulip_identify_asante_nic, { 0x00, 0x00, 0x94 } },
! 2596: { tulip_identify_accton_nic, { 0x00, 0x00, 0xE8 } },
! 2597: { tulip_identify_compex_nic, { 0x00, 0x80, 0x48 } },
! 2598: { NULL }
! 2599: };
! 2600:
! 2601: /*
! 2602: * This deals with the vagaries of the address roms and the
! 2603: * brain-deadness that various vendors commit in using them.
! 2604: */
! 2605: int
! 2606: tulip_read_macaddr(tulip_softc_t * const sc)
! 2607: {
! 2608: unsigned cksum, rom_cksum, idx;
! 2609: u_int32_t csr;
! 2610: unsigned char tmpbuf[8];
! 2611: static const u_char testpat[] = { 0xFF, 0, 0x55, 0xAA, 0xFF, 0, 0x55, 0xAA };
! 2612:
! 2613: sc->tulip_connidx = TULIP_SROM_LASTCONNIDX;
! 2614:
! 2615: if (sc->tulip_chipid == TULIP_21040) {
! 2616: TULIP_CSR_WRITE(sc, csr_enetrom, 1);
! 2617: for (idx = 0; idx < sizeof(sc->tulip_rombuf); idx++) {
! 2618: int cnt = 0;
! 2619: while (((csr = TULIP_CSR_READ(sc, csr_enetrom)) & 0x80000000L) && cnt < 10000)
! 2620: cnt++;
! 2621: sc->tulip_rombuf[idx] = csr & 0xFF;
! 2622: }
! 2623: sc->tulip_boardsw = &tulip_21040_boardsw;
! 2624: } else {
! 2625: if (sc->tulip_chipid == TULIP_21041) {
! 2626: /*
! 2627: * Thankfully all 21041's act the same.
! 2628: */
! 2629: sc->tulip_boardsw = &tulip_21041_boardsw;
! 2630: } else {
! 2631: /*
! 2632: * Assume all 21140 board are compatible with the
! 2633: * DEC 10/100 evaluation board. Not really valid but
! 2634: * it's the best we can do until every one switches to
! 2635: * the new SROM format.
! 2636: */
! 2637:
! 2638: sc->tulip_boardsw = &tulip_21140_eb_boardsw;
! 2639: }
! 2640: tulip_srom_read(sc);
! 2641: if (tulip_srom_crcok(sc->tulip_rombuf)) {
! 2642: /*
! 2643: * SROM CRC is valid therefore it must be in the
! 2644: * new format.
! 2645: */
! 2646: sc->tulip_features |= TULIP_HAVE_ISVSROM|TULIP_HAVE_OKSROM;
! 2647: } else if (sc->tulip_rombuf[126] == 0xff && sc->tulip_rombuf[127] == 0xFF) {
! 2648: /*
! 2649: * No checksum is present. See if the SROM id checks out;
! 2650: * the first 18 bytes should be 0 followed by a 1 followed
! 2651: * by the number of adapters (which we don't deal with yet).
! 2652: */
! 2653: for (idx = 0; idx < 18; idx++) {
! 2654: if (sc->tulip_rombuf[idx] != 0)
! 2655: break;
! 2656: }
! 2657: if (idx == 18 && sc->tulip_rombuf[18] == 1 && sc->tulip_rombuf[19] != 0)
! 2658: sc->tulip_features |= TULIP_HAVE_ISVSROM;
! 2659: } else if (sc->tulip_chipid >= TULIP_21142) {
! 2660: sc->tulip_features |= TULIP_HAVE_ISVSROM;
! 2661: sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
! 2662: }
! 2663: if ((sc->tulip_features & TULIP_HAVE_ISVSROM) && tulip_srom_decode(sc)) {
! 2664: if (sc->tulip_chipid != TULIP_21041)
! 2665: sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
! 2666:
! 2667: /*
! 2668: * If the SROM specifies more than one adapter, tag this as a
! 2669: * BASE rom.
! 2670: */
! 2671: if (sc->tulip_rombuf[19] > 1)
! 2672: sc->tulip_features |= TULIP_HAVE_BASEROM;
! 2673: if (sc->tulip_boardsw == NULL)
! 2674: return (-6);
! 2675: goto check_oui;
! 2676: }
! 2677: }
! 2678:
! 2679: if (bcmp(&sc->tulip_rombuf[0], &sc->tulip_rombuf[16], 8) != 0) {
! 2680: /*
! 2681: * Some folks don't use the standard ethernet rom format
! 2682: * but instead just put the address in the first 6 bytes
! 2683: * of the rom and let the rest be all 0xffs. (Can we say
! 2684: * ZNYX???) (well sometimes they put in a checksum so we'll
! 2685: * start at 8).
! 2686: */
! 2687: for (idx = 8; idx < 32; idx++) {
! 2688: if (sc->tulip_rombuf[idx] != 0xFF)
! 2689: return (-4);
! 2690: }
! 2691: /*
! 2692: * Make sure the address is not multicast or locally assigned
! 2693: * that the OUI is not 00-00-00.
! 2694: */
! 2695: if ((sc->tulip_rombuf[0] & 3) != 0)
! 2696: return (-4);
! 2697: if (sc->tulip_rombuf[0] == 0 && sc->tulip_rombuf[1] == 0
! 2698: && sc->tulip_rombuf[2] == 0)
! 2699: return (-4);
! 2700: bcopy(sc->tulip_rombuf, sc->tulip_enaddr, ETHER_ADDR_LEN);
! 2701: sc->tulip_features |= TULIP_HAVE_OKROM;
! 2702: goto check_oui;
! 2703: } else {
! 2704: /*
! 2705: * A number of makers of multiport boards (ZNYX and Cogent)
! 2706: * only put on one address ROM on their 21040 boards. So
! 2707: * if the ROM is all zeros (or all 0xFFs), look at the
! 2708: * previous configured boards (as long as they are on the same
! 2709: * PCI bus and the bus number is non-zero) until we find the
! 2710: * master board with address ROM. We then use its address ROM
! 2711: * as the base for this board. (we add our relative board
! 2712: * to the last byte of its address).
! 2713: */
! 2714: for (idx = 0; idx < sizeof(sc->tulip_rombuf); idx++) {
! 2715: if (sc->tulip_rombuf[idx] != 0 && sc->tulip_rombuf[idx] != 0xFF)
! 2716: break;
! 2717: }
! 2718: if (idx == sizeof(sc->tulip_rombuf)) {
! 2719: int root_unit;
! 2720: tulip_softc_t *root_sc = NULL;
! 2721: for (root_unit = sc->tulip_unit - 1; root_unit >= 0; root_unit--) {
! 2722: root_sc = TULIP_UNIT_TO_SOFTC(root_unit);
! 2723: if (root_sc == NULL || (root_sc->tulip_features & (TULIP_HAVE_OKROM|TULIP_HAVE_SLAVEDROM)) == TULIP_HAVE_OKROM)
! 2724: break;
! 2725: root_sc = NULL;
! 2726: }
! 2727: if (root_sc != NULL && (root_sc->tulip_features & TULIP_HAVE_BASEROM)
! 2728: && root_sc->tulip_chipid == sc->tulip_chipid
! 2729: && root_sc->tulip_pci_busno == sc->tulip_pci_busno) {
! 2730: sc->tulip_features |= TULIP_HAVE_SLAVEDROM;
! 2731: sc->tulip_boardsw = root_sc->tulip_boardsw;
! 2732: strlcpy(sc->tulip_boardid, root_sc->tulip_boardid,
! 2733: sizeof(sc->tulip_boardid));
! 2734: if (sc->tulip_boardsw->bd_type == TULIP_21140_ISV) {
! 2735: bcopy(root_sc->tulip_rombuf, sc->tulip_rombuf,
! 2736: sizeof(sc->tulip_rombuf));
! 2737: if (!tulip_srom_decode(sc))
! 2738: return (-5);
! 2739: } else {
! 2740: bcopy(root_sc->tulip_enaddr, sc->tulip_enaddr,
! 2741: ETHER_ADDR_LEN);
! 2742: sc->tulip_enaddr[5] += sc->tulip_unit - root_sc->tulip_unit;
! 2743: }
! 2744: /*
! 2745: * Now for a truly disgusting kludge: all 4 21040s on
! 2746: * the ZX314 share the same INTA line so the mapping
! 2747: * setup by the BIOS on the PCI bridge is worthless.
! 2748: * Rather than reprogramming the value in the config
! 2749: * register, we will handle this internally.
! 2750: */
! 2751: if (root_sc->tulip_features & TULIP_HAVE_SHAREDINTR) {
! 2752: sc->tulip_slaves = root_sc->tulip_slaves;
! 2753: root_sc->tulip_slaves = sc;
! 2754: sc->tulip_features |= TULIP_HAVE_SLAVEDINTR;
! 2755: }
! 2756: return (0);
! 2757: }
! 2758: }
! 2759: }
! 2760:
! 2761: /*
! 2762: * This is the standard DEC address ROM test.
! 2763: */
! 2764:
! 2765: if (bcmp(&sc->tulip_rombuf[24], testpat, 8) != 0)
! 2766: return (-3);
! 2767:
! 2768: tmpbuf[0] = sc->tulip_rombuf[15]; tmpbuf[1] = sc->tulip_rombuf[14];
! 2769: tmpbuf[2] = sc->tulip_rombuf[13]; tmpbuf[3] = sc->tulip_rombuf[12];
! 2770: tmpbuf[4] = sc->tulip_rombuf[11]; tmpbuf[5] = sc->tulip_rombuf[10];
! 2771: tmpbuf[6] = sc->tulip_rombuf[9]; tmpbuf[7] = sc->tulip_rombuf[8];
! 2772: if (bcmp(&sc->tulip_rombuf[0], tmpbuf, 8) != 0)
! 2773: return (-2);
! 2774:
! 2775: bcopy(sc->tulip_rombuf, sc->tulip_enaddr, ETHER_ADDR_LEN);
! 2776:
! 2777: cksum = *(u_int16_t *) &sc->tulip_enaddr[0];
! 2778: cksum *= 2;
! 2779: if (cksum > 65535) cksum -= 65535;
! 2780: cksum += *(u_int16_t *) &sc->tulip_enaddr[2];
! 2781: if (cksum > 65535) cksum -= 65535;
! 2782: cksum *= 2;
! 2783: if (cksum > 65535) cksum -= 65535;
! 2784: cksum += *(u_int16_t *) &sc->tulip_enaddr[4];
! 2785: if (cksum >= 65535) cksum -= 65535;
! 2786:
! 2787: rom_cksum = *(u_int16_t *) &sc->tulip_rombuf[6];
! 2788:
! 2789: if (cksum != rom_cksum)
! 2790: return (-1);
! 2791:
! 2792: check_oui:
! 2793: /*
! 2794: * Check for various boards based on OUI. Did I say braindead?
! 2795: */
! 2796: for (idx = 0; tulip_vendors[idx].vendor_identify_nic != NULL; idx++) {
! 2797: if (bcmp((caddr_t) sc->tulip_enaddr,
! 2798: (caddr_t) tulip_vendors[idx].vendor_oui, 3) == 0) {
! 2799: (*tulip_vendors[idx].vendor_identify_nic)(sc);
! 2800: break;
! 2801: }
! 2802: }
! 2803:
! 2804: sc->tulip_features |= TULIP_HAVE_OKROM;
! 2805: return (0);
! 2806: }
! 2807:
! 2808: void
! 2809: tulip_ifmedia_add(tulip_softc_t * const sc)
! 2810: {
! 2811: tulip_media_t media;
! 2812: int medias = 0;
! 2813:
! 2814: for (media = TULIP_MEDIA_UNKNOWN; media < TULIP_MEDIA_MAX; media++) {
! 2815: if (sc->tulip_mediums[media] != NULL) {
! 2816: ifmedia_add(&sc->tulip_ifmedia, tulip_media_to_ifmedia[media],
! 2817: 0, 0);
! 2818: medias++;
! 2819: }
! 2820: }
! 2821: if (medias == 0) {
! 2822: sc->tulip_features |= TULIP_HAVE_NOMEDIA;
! 2823: ifmedia_add(&sc->tulip_ifmedia, IFM_ETHER | IFM_NONE, 0, 0);
! 2824: ifmedia_set(&sc->tulip_ifmedia, IFM_ETHER | IFM_NONE);
! 2825: } else if (sc->tulip_media == TULIP_MEDIA_UNKNOWN) {
! 2826: ifmedia_add(&sc->tulip_ifmedia, IFM_ETHER | IFM_AUTO, 0, 0);
! 2827: ifmedia_set(&sc->tulip_ifmedia, IFM_ETHER | IFM_AUTO);
! 2828: } else {
! 2829: ifmedia_set(&sc->tulip_ifmedia, tulip_media_to_ifmedia[sc->tulip_media]);
! 2830: sc->tulip_flags |= TULIP_PRINTMEDIA;
! 2831: tulip_linkup(sc, sc->tulip_media);
! 2832: }
! 2833: }
! 2834:
! 2835: int
! 2836: tulip_ifmedia_change(struct ifnet * const ifp)
! 2837: {
! 2838: tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
! 2839:
! 2840: sc->tulip_flags |= TULIP_NEEDRESET;
! 2841: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 2842: sc->tulip_media = TULIP_MEDIA_UNKNOWN;
! 2843: if (IFM_SUBTYPE(sc->tulip_ifmedia.ifm_media) != IFM_AUTO) {
! 2844: tulip_media_t media;
! 2845: for (media = TULIP_MEDIA_UNKNOWN; media < TULIP_MEDIA_MAX; media++) {
! 2846: if (sc->tulip_mediums[media] != NULL
! 2847: && sc->tulip_ifmedia.ifm_media == tulip_media_to_ifmedia[media]) {
! 2848: sc->tulip_flags |= TULIP_PRINTMEDIA;
! 2849: sc->tulip_flags &= ~TULIP_DIDNWAY;
! 2850: tulip_linkup(sc, media);
! 2851: return (0);
! 2852: }
! 2853: }
! 2854: }
! 2855: sc->tulip_flags &= ~(TULIP_TXPROBE_ACTIVE|TULIP_WANTRXACT);
! 2856: tulip_reset(sc);
! 2857: tulip_init(sc);
! 2858: return (0);
! 2859: }
! 2860:
! 2861: /*
! 2862: * Media status callback
! 2863: */
! 2864: void
! 2865: tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req)
! 2866: {
! 2867: tulip_softc_t *sc = TULIP_IFP_TO_SOFTC(ifp);
! 2868:
! 2869: if (sc->tulip_media == TULIP_MEDIA_UNKNOWN)
! 2870: return;
! 2871:
! 2872: req->ifm_status = IFM_AVALID;
! 2873: if (sc->tulip_flags & TULIP_LINKUP)
! 2874: req->ifm_status |= IFM_ACTIVE;
! 2875:
! 2876: req->ifm_active = tulip_media_to_ifmedia[sc->tulip_media];
! 2877: }
! 2878:
! 2879: void
! 2880: tulip_addr_filter(tulip_softc_t * const sc)
! 2881: {
! 2882: struct ether_multistep step;
! 2883: struct ether_multi *enm;
! 2884:
! 2885: sc->tulip_flags &= ~(TULIP_WANTHASHPERFECT|TULIP_WANTHASHONLY|TULIP_ALLMULTI);
! 2886: sc->tulip_flags |= TULIP_WANTSETUP|TULIP_WANTTXSTART;
! 2887: sc->tulip_cmdmode &= ~TULIP_CMD_RXRUN;
! 2888: sc->tulip_intrmask &= ~TULIP_STS_RXSTOPPED;
! 2889: sc->tulip_if.if_flags &= ~IFF_ALLMULTI;
! 2890: sc->tulip_if.if_start = tulip_ifstart; /* so the setup packet gets queued */
! 2891: if (sc->tulip_multicnt > 14) {
! 2892: u_int32_t *sp = sc->tulip_setupdata;
! 2893: unsigned hash;
! 2894: /*
! 2895: * Some early passes of the 21140 have broken implementations of
! 2896: * hash-perfect mode. When we get too many multicasts for perfect
! 2897: * filtering with these chips, we need to switch into hash-only
! 2898: * mode (this is better than all-multicast on network with lots
! 2899: * of multicast traffic).
! 2900: */
! 2901: if (sc->tulip_features & TULIP_HAVE_BROKEN_HASH)
! 2902: sc->tulip_flags |= TULIP_WANTHASHONLY;
! 2903: else
! 2904: sc->tulip_flags |= TULIP_WANTHASHPERFECT;
! 2905: /*
! 2906: * If we have more than 14 multicasts, we have
! 2907: * go into hash perfect mode (512 bit multicast
! 2908: * hash and one perfect hardware).
! 2909: */
! 2910: bzero(sc->tulip_setupdata, sizeof(sc->tulip_setupdata));
! 2911: ETHER_FIRST_MULTI(step, &sc->tulip_ac, enm);
! 2912: while (enm != NULL) {
! 2913: if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) == 0) {
! 2914: hash = tulip_mchash(enm->enm_addrlo);
! 2915: #if BYTE_ORDER == BIG_ENDIAN
! 2916: sp[hash >> 4] |= swap32(1 << (hash & 0xF));
! 2917: #else
! 2918: sp[hash >> 4] |= 1 << (hash & 0xF);
! 2919: #endif
! 2920: } else {
! 2921: sc->tulip_flags |= TULIP_ALLMULTI;
! 2922: sc->tulip_flags &= ~(TULIP_WANTHASHONLY|TULIP_WANTHASHPERFECT);
! 2923: break;
! 2924: }
! 2925: ETHER_NEXT_MULTI(step, enm);
! 2926: }
! 2927: /*
! 2928: * No reason to use a hash if we are going to be
! 2929: * receiving every multicast.
! 2930: */
! 2931: if ((sc->tulip_flags & TULIP_ALLMULTI) == 0) {
! 2932: hash = tulip_mchash(etherbroadcastaddr);
! 2933: #if BYTE_ORDER == BIG_ENDIAN
! 2934: sp[hash >> 4] |= swap32(1 << (hash & 0xF));
! 2935: #else
! 2936: sp[hash >> 4] |= 1 << (hash & 0xF);
! 2937: #endif
! 2938: if (sc->tulip_flags & TULIP_WANTHASHONLY) {
! 2939: hash = tulip_mchash(sc->tulip_enaddr);
! 2940: #if BYTE_ORDER == BIG_ENDIAN
! 2941: sp[hash >> 4] |= swap32(1 << (hash & 0xF));
! 2942: #else
! 2943: sp[hash >> 4] |= 1 << (hash & 0xF);
! 2944: #endif
! 2945: } else {
! 2946: #if BYTE_ORDER == BIG_ENDIAN
! 2947: sp[39] = ((u_int16_t *) sc->tulip_enaddr)[0] << 16;
! 2948: sp[40] = ((u_int16_t *) sc->tulip_enaddr)[1] << 16;
! 2949: sp[41] = ((u_int16_t *) sc->tulip_enaddr)[2] << 16;
! 2950: #else
! 2951: sp[39] = ((u_int16_t *) sc->tulip_enaddr)[0];
! 2952: sp[40] = ((u_int16_t *) sc->tulip_enaddr)[1];
! 2953: sp[41] = ((u_int16_t *) sc->tulip_enaddr)[2];
! 2954: #endif
! 2955: }
! 2956: }
! 2957: }
! 2958: if ((sc->tulip_flags & (TULIP_WANTHASHPERFECT|TULIP_WANTHASHONLY)) == 0) {
! 2959: u_int32_t *sp = sc->tulip_setupdata;
! 2960: int idx = 0;
! 2961: if ((sc->tulip_flags & TULIP_ALLMULTI) == 0) {
! 2962: /*
! 2963: * Else can get perfect filtering for 16 addresses.
! 2964: */
! 2965: ETHER_FIRST_MULTI(step, &sc->tulip_ac, enm);
! 2966: for (; enm != NULL; idx++) {
! 2967: if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) == 0) {
! 2968: #if BYTE_ORDER == BIG_ENDIAN
! 2969: *sp++ = ((u_int16_t *) enm->enm_addrlo)[0] << 16;
! 2970: *sp++ = ((u_int16_t *) enm->enm_addrlo)[1] << 16;
! 2971: *sp++ = ((u_int16_t *) enm->enm_addrlo)[2] << 16;
! 2972: #else
! 2973: *sp++ = ((u_int16_t *) enm->enm_addrlo)[0];
! 2974: *sp++ = ((u_int16_t *) enm->enm_addrlo)[1];
! 2975: *sp++ = ((u_int16_t *) enm->enm_addrlo)[2];
! 2976: #endif
! 2977: } else {
! 2978: sc->tulip_flags |= TULIP_ALLMULTI;
! 2979: break;
! 2980: }
! 2981: ETHER_NEXT_MULTI(step, enm);
! 2982: }
! 2983: /*
! 2984: * Add the broadcast address.
! 2985: */
! 2986: idx++;
! 2987: #if BYTE_ORDER == BIG_ENDIAN
! 2988: *sp++ = 0xFFFF << 16;
! 2989: *sp++ = 0xFFFF << 16;
! 2990: *sp++ = 0xFFFF << 16;
! 2991: #else
! 2992: *sp++ = 0xFFFF;
! 2993: *sp++ = 0xFFFF;
! 2994: *sp++ = 0xFFFF;
! 2995: #endif
! 2996: }
! 2997: /*
! 2998: * Pad the rest with our hardware address
! 2999: */
! 3000: for (; idx < 16; idx++) {
! 3001: #if BYTE_ORDER == BIG_ENDIAN
! 3002: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[0] << 16;
! 3003: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[1] << 16;
! 3004: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[2] << 16;
! 3005: #else
! 3006: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[0];
! 3007: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[1];
! 3008: *sp++ = ((u_int16_t *) sc->tulip_enaddr)[2];
! 3009: #endif
! 3010: }
! 3011: }
! 3012: if (sc->tulip_flags & TULIP_ALLMULTI)
! 3013: sc->tulip_if.if_flags |= IFF_ALLMULTI;
! 3014: }
! 3015:
! 3016: void
! 3017: tulip_reset(tulip_softc_t * const sc)
! 3018: {
! 3019: tulip_ringinfo_t *ri;
! 3020: tulip_desc_t *di;
! 3021: u_int32_t inreset = (sc->tulip_flags & TULIP_INRESET);
! 3022:
! 3023: /*
! 3024: * Brilliant. Simply brilliant. When switching modes/speeds
! 3025: * on a 2114*, you need to set the appriopriate MII/PCS/SCL/PS
! 3026: * bits in CSR6 and then do a software reset to get the 21140
! 3027: * to properly reset its internal pathways to the right places.
! 3028: * Grrrr.
! 3029: */
! 3030: if ((sc->tulip_flags & TULIP_DEVICEPROBE) == 0
! 3031: && sc->tulip_boardsw->bd_media_preset != NULL)
! 3032: (*sc->tulip_boardsw->bd_media_preset)(sc);
! 3033:
! 3034: TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
! 3035: DELAY(10); /* Wait 10 microseconds (actually 50 PCI cycles but at
! 3036: 33MHz that comes to two microseconds but wait a
! 3037: bit longer anyways) */
! 3038:
! 3039: if (!inreset) {
! 3040: sc->tulip_flags |= TULIP_INRESET;
! 3041: sc->tulip_flags &= ~(TULIP_NEEDRESET|TULIP_RXBUFSLOW);
! 3042: sc->tulip_if.if_flags &= ~IFF_OACTIVE;
! 3043: sc->tulip_if.if_start = tulip_ifstart;
! 3044: }
! 3045:
! 3046: TULIP_CSR_WRITE(sc, csr_txlist, sc->tulip_txdescmap->dm_segs[0].ds_addr);
! 3047: TULIP_CSR_WRITE(sc, csr_rxlist, sc->tulip_rxdescmap->dm_segs[0].ds_addr);
! 3048: TULIP_CSR_WRITE(sc, csr_busmode,
! 3049: (1 << (TULIP_BURSTSIZE(sc->tulip_unit) + 8))
! 3050: |TULIP_BUSMODE_CACHE_ALIGN8
! 3051: |TULIP_BUSMODE_READMULTIPLE
! 3052: |(BYTE_ORDER != LITTLE_ENDIAN ?
! 3053: TULIP_BUSMODE_DESC_BIGENDIAN : 0));
! 3054:
! 3055: sc->tulip_txtimer = 0;
! 3056: sc->tulip_txq.ifq_maxlen = TULIP_TXDESCS;
! 3057: /*
! 3058: * Free all the mbufs that were on the transmit ring.
! 3059: */
! 3060: for (;;) {
! 3061: bus_dmamap_t map;
! 3062: struct mbuf *m;
! 3063: IF_DEQUEUE(&sc->tulip_txq, m);
! 3064: if (m == NULL)
! 3065: break;
! 3066: map = TULIP_GETCTX(m, bus_dmamap_t);
! 3067: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3068: sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
! 3069: m_freem(m);
! 3070: }
! 3071:
! 3072: ri = &sc->tulip_txinfo;
! 3073: ri->ri_nextin = ri->ri_nextout = ri->ri_first;
! 3074: ri->ri_free = ri->ri_max;
! 3075: for (di = ri->ri_first; di < ri->ri_last; di++)
! 3076: di->d_status = 0;
! 3077: bus_dmamap_sync(sc->tulip_dmatag, sc->tulip_txdescmap,
! 3078: 0, sc->tulip_txdescmap->dm_mapsize,
! 3079: BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
! 3080:
! 3081: /*
! 3082: * We need to collect all the mbufs were on the
! 3083: * receive ring before we reinit it either to put
! 3084: * them back on or to know if we have to allocate
! 3085: * more.
! 3086: */
! 3087: ri = &sc->tulip_rxinfo;
! 3088: ri->ri_nextin = ri->ri_nextout = ri->ri_first;
! 3089: ri->ri_free = ri->ri_max;
! 3090: for (di = ri->ri_first; di < ri->ri_last; di++) {
! 3091: di->d_status = 0;
! 3092: di->d_length1 = 0; di->d_addr1 = 0;
! 3093: di->d_length2 = 0; di->d_addr2 = 0;
! 3094: }
! 3095: bus_dmamap_sync(sc->tulip_dmatag, sc->tulip_rxdescmap,
! 3096: 0, sc->tulip_rxdescmap->dm_mapsize,
! 3097: BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
! 3098: for (;;) {
! 3099: bus_dmamap_t map;
! 3100: struct mbuf *m;
! 3101: IF_DEQUEUE(&sc->tulip_rxq, m);
! 3102: if (m == NULL)
! 3103: break;
! 3104: map = TULIP_GETCTX(m, bus_dmamap_t);
! 3105: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3106: sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
! 3107: m_freem(m);
! 3108: }
! 3109:
! 3110: /*
! 3111: * If tulip_reset is being called recurisvely, exit quickly knowing
! 3112: * that when the outer tulip_reset returns all the right stuff will
! 3113: * have happened.
! 3114: */
! 3115: if (inreset)
! 3116: return;
! 3117:
! 3118: sc->tulip_intrmask |= TULIP_STS_NORMALINTR|TULIP_STS_RXINTR|TULIP_STS_TXINTR
! 3119: |TULIP_STS_ABNRMLINTR|TULIP_STS_SYSERROR|TULIP_STS_TXSTOPPED
! 3120: |TULIP_STS_TXUNDERFLOW|TULIP_STS_TXBABBLE
! 3121: |TULIP_STS_RXSTOPPED;
! 3122:
! 3123: if ((sc->tulip_flags & TULIP_DEVICEPROBE) == 0)
! 3124: (*sc->tulip_boardsw->bd_media_select)(sc);
! 3125: #if defined(TULIP_DEBUG)
! 3126: if ((sc->tulip_flags & TULIP_NEEDRESET) == TULIP_NEEDRESET)
! 3127: printf(TULIP_PRINTF_FMT ": tulip_reset: additional reset needed?!?\n",
! 3128: TULIP_PRINTF_ARGS);
! 3129: #endif
! 3130: tulip_media_print(sc);
! 3131: if (sc->tulip_features & TULIP_HAVE_DUALSENSE)
! 3132: TULIP_CSR_WRITE(sc, csr_sia_status, TULIP_CSR_READ(sc, csr_sia_status));
! 3133:
! 3134: sc->tulip_flags &= ~(TULIP_DOINGSETUP|TULIP_WANTSETUP|TULIP_INRESET
! 3135: |TULIP_RXACT);
! 3136: tulip_addr_filter(sc);
! 3137: }
! 3138:
! 3139: void
! 3140: tulip_init(tulip_softc_t * const sc)
! 3141: {
! 3142: if (sc->tulip_if.if_flags & IFF_UP) {
! 3143: if ((sc->tulip_if.if_flags & IFF_RUNNING) == 0) {
! 3144: /* initialize the media */
! 3145: tulip_reset(sc);
! 3146: }
! 3147: sc->tulip_if.if_flags |= IFF_RUNNING;
! 3148: if (sc->tulip_if.if_flags & IFF_PROMISC) {
! 3149: sc->tulip_flags |= TULIP_PROMISC;
! 3150: sc->tulip_cmdmode |= TULIP_CMD_PROMISCUOUS;
! 3151: sc->tulip_intrmask |= TULIP_STS_TXINTR;
! 3152: } else {
! 3153: sc->tulip_flags &= ~TULIP_PROMISC;
! 3154: sc->tulip_cmdmode &= ~TULIP_CMD_PROMISCUOUS;
! 3155: if (sc->tulip_flags & TULIP_ALLMULTI)
! 3156: sc->tulip_cmdmode |= TULIP_CMD_ALLMULTI;
! 3157: else
! 3158: sc->tulip_cmdmode &= ~TULIP_CMD_ALLMULTI;
! 3159: }
! 3160: sc->tulip_cmdmode |= TULIP_CMD_TXRUN;
! 3161: if ((sc->tulip_flags & (TULIP_TXPROBE_ACTIVE|TULIP_WANTSETUP)) == 0) {
! 3162: tulip_rx_intr(sc);
! 3163: sc->tulip_cmdmode |= TULIP_CMD_RXRUN;
! 3164: sc->tulip_intrmask |= TULIP_STS_RXSTOPPED;
! 3165: } else {
! 3166: sc->tulip_if.if_flags |= IFF_OACTIVE;
! 3167: sc->tulip_cmdmode &= ~TULIP_CMD_RXRUN;
! 3168: sc->tulip_intrmask &= ~TULIP_STS_RXSTOPPED;
! 3169: }
! 3170: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 3171: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 3172: if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == TULIP_WANTSETUP)
! 3173: tulip_txput_setup(sc);
! 3174: } else {
! 3175: sc->tulip_if.if_flags &= ~IFF_RUNNING;
! 3176: tulip_reset(sc);
! 3177: }
! 3178: }
! 3179:
! 3180: void
! 3181: tulip_rx_intr(tulip_softc_t * const sc)
! 3182: {
! 3183: TULIP_PERFSTART(rxintr)
! 3184: tulip_ringinfo_t * const ri = &sc->tulip_rxinfo;
! 3185: struct ifnet * const ifp = &sc->tulip_if;
! 3186: int fillok = 1;
! 3187: #if defined(TULIP_DEBUG)
! 3188: int cnt = 0;
! 3189: #endif
! 3190:
! 3191: for (;;) {
! 3192: TULIP_PERFSTART(rxget)
! 3193: tulip_desc_t *eop = ri->ri_nextin;
! 3194: int total_len = 0, last_offset = 0;
! 3195: struct mbuf *ms = NULL, *me = NULL;
! 3196: int accept = 0;
! 3197: bus_dmamap_t map;
! 3198: int error;
! 3199:
! 3200: if (fillok && sc->tulip_rxq.ifq_len < TULIP_RXQ_TARGET)
! 3201: goto queue_mbuf;
! 3202:
! 3203: #if defined(TULIP_DEBUG)
! 3204: if (cnt == ri->ri_max)
! 3205: break;
! 3206: #endif
! 3207: /*
! 3208: * If the TULIP has no descriptors, there can't be any receive
! 3209: * descriptors to process.
! 3210: */
! 3211: if (eop == ri->ri_nextout)
! 3212: break;
! 3213:
! 3214: /*
! 3215: * 90% of the packets will fit in one descriptor. So we optimize
! 3216: * for that case.
! 3217: */
! 3218: TULIP_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
! 3219: if ((((volatile tulip_desc_t *) eop)->d_status & (TULIP_DSTS_OWNER|TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) == (TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) {
! 3220: IF_DEQUEUE(&sc->tulip_rxq, ms);
! 3221: me = ms;
! 3222: } else {
! 3223: /*
! 3224: * If still owned by the TULIP, don't touch it.
! 3225: */
! 3226: if (((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_OWNER)
! 3227: break;
! 3228:
! 3229: /*
! 3230: * It is possible (though improbable unless MCLBYTES < 1518) for
! 3231: * a received packet to cross more than one receive descriptor.
! 3232: */
! 3233: while ((((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_RxLASTDESC) == 0) {
! 3234: if (++eop == ri->ri_last)
! 3235: eop = ri->ri_first;
! 3236: TULIP_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
! 3237: if (eop == ri->ri_nextout || ((((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_OWNER))) {
! 3238: #if defined(TULIP_DEBUG)
! 3239: sc->tulip_dbg.dbg_rxintrs++;
! 3240: sc->tulip_dbg.dbg_rxpktsperintr[cnt]++;
! 3241: #endif
! 3242: TULIP_PERFEND(rxget);
! 3243: TULIP_PERFEND(rxintr);
! 3244: return;
! 3245: }
! 3246: total_len++;
! 3247: }
! 3248:
! 3249: /*
! 3250: * Dequeue the first buffer for the start of the packet. Hopefully
! 3251: * this will be the only one we need to dequeue. However, if the
! 3252: * packet consumed multiple descriptors, then we need to dequeue
! 3253: * those buffers and chain to the starting mbuf. All buffers but
! 3254: * the last buffer have the same length so we can set that now.
! 3255: * (we add to last_offset instead of multiplying since we normally
! 3256: * won't go into the loop and thereby saving a ourselves from
! 3257: * doing a multiplication by 0 in the normal case).
! 3258: */
! 3259: IF_DEQUEUE(&sc->tulip_rxq, ms);
! 3260: for (me = ms; total_len > 0; total_len--) {
! 3261: map = TULIP_GETCTX(me, bus_dmamap_t);
! 3262: TULIP_RXMAP_POSTSYNC(sc, map);
! 3263: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3264: sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
! 3265: #if defined(DIAGNOSTIC)
! 3266: TULIP_SETCTX(me, NULL);
! 3267: #endif
! 3268: me->m_len = TULIP_RX_BUFLEN;
! 3269: last_offset += TULIP_RX_BUFLEN;
! 3270: IF_DEQUEUE(&sc->tulip_rxq, me->m_next);
! 3271: me = me->m_next;
! 3272: }
! 3273: }
! 3274:
! 3275: /*
! 3276: * Now get the size of received packet (minus the CRC).
! 3277: */
! 3278: total_len = ((eop->d_status >> 16) & 0x7FFF) - 4;
! 3279: if ((sc->tulip_flags & TULIP_RXIGNORE) == 0
! 3280: && ((eop->d_status & TULIP_DSTS_ERRSUM) == 0)) {
! 3281: me->m_len = total_len - last_offset;
! 3282:
! 3283: map = TULIP_GETCTX(me, bus_dmamap_t);
! 3284: bus_dmamap_sync(sc->tulip_dmatag, map, 0, me->m_len,
! 3285: BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
! 3286: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3287: sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
! 3288: #if defined(DIAGNOSTIC)
! 3289: TULIP_SETCTX(me, NULL);
! 3290: #endif
! 3291:
! 3292: #if NBPFILTER > 0
! 3293: if (sc->tulip_bpf != NULL) {
! 3294: if (me == ms) {
! 3295: bpf_tap(sc->tulip_if.if_bpf, mtod(ms, caddr_t),
! 3296: total_len, BPF_DIRECTION_IN);
! 3297: } else
! 3298: bpf_mtap(sc->tulip_if.if_bpf, ms, BPF_DIRECTION_IN);
! 3299: }
! 3300: #endif
! 3301: sc->tulip_flags |= TULIP_RXACT;
! 3302: accept = 1;
! 3303: } else {
! 3304: ifp->if_ierrors++;
! 3305: if (eop->d_status & (TULIP_DSTS_RxBADLENGTH|TULIP_DSTS_RxOVERFLOW|TULIP_DSTS_RxWATCHDOG))
! 3306: sc->tulip_dot3stats.dot3StatsInternalMacReceiveErrors++;
! 3307: else {
! 3308: #ifdef TULIP_DEBUG
! 3309: const char *error = NULL;
! 3310: if (eop->d_status & TULIP_DSTS_RxTOOLONG) {
! 3311: sc->tulip_dot3stats.dot3StatsFrameTooLongs++;
! 3312: error = "frame too long";
! 3313: }
! 3314: if (eop->d_status & TULIP_DSTS_RxBADCRC) {
! 3315: if (eop->d_status & TULIP_DSTS_RxDRBBLBIT) {
! 3316: sc->tulip_dot3stats.dot3StatsAlignmentErrors++;
! 3317: error = "alignment error";
! 3318: } else {
! 3319: sc->tulip_dot3stats.dot3StatsFCSErrors++;
! 3320: error = "bad crc";
! 3321: }
! 3322: }
! 3323: if (error != NULL && (sc->tulip_flags & TULIP_NOMESSAGES) == 0) {
! 3324: printf(TULIP_PRINTF_FMT ": receive: %s: %s\n",
! 3325: TULIP_PRINTF_ARGS,
! 3326: ether_sprintf(mtod(ms, u_char *) + 6),
! 3327: error);
! 3328: sc->tulip_flags |= TULIP_NOMESSAGES;
! 3329: }
! 3330: #endif
! 3331: }
! 3332:
! 3333: map = TULIP_GETCTX(me, bus_dmamap_t);
! 3334: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3335: sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
! 3336: #if defined(DIAGNOSTIC)
! 3337: TULIP_SETCTX(me, NULL);
! 3338: #endif
! 3339: }
! 3340: #if defined(TULIP_DEBUG)
! 3341: cnt++;
! 3342: #endif
! 3343: ifp->if_ipackets++;
! 3344: if (++eop == ri->ri_last)
! 3345: eop = ri->ri_first;
! 3346: ri->ri_nextin = eop;
! 3347: queue_mbuf:
! 3348: /*
! 3349: * Either we are priming the TULIP with mbufs (m == NULL)
! 3350: * or we are about to accept an mbuf for the upper layers
! 3351: * so we need to allocate an mbuf to replace it. If we
! 3352: * can't replace it, send up it anyways. This may cause
! 3353: * us to drop packets in the future but that's better than
! 3354: * being caught in livelock.
! 3355: *
! 3356: * Note that if this packet crossed multiple descriptors
! 3357: * we don't even try to reallocate all the mbufs here.
! 3358: * Instead we rely on the test of the beginning of
! 3359: * the loop to refill for the extra consumed mbufs.
! 3360: */
! 3361: if (accept || ms == NULL) {
! 3362: struct mbuf *m0;
! 3363: MGETHDR(m0, M_DONTWAIT, MT_DATA);
! 3364: if (m0 != NULL) {
! 3365: #if defined(TULIP_COPY_RXDATA)
! 3366: if (!accept || total_len >= (MHLEN - 2)) {
! 3367: #endif
! 3368: MCLGET(m0, M_DONTWAIT);
! 3369: if ((m0->m_flags & M_EXT) == 0) {
! 3370: m_freem(m0);
! 3371: m0 = NULL;
! 3372: }
! 3373: #if defined(TULIP_COPY_RXDATA)
! 3374: }
! 3375: #endif
! 3376: }
! 3377: if (accept
! 3378: #if defined(TULIP_COPY_RXDATA)
! 3379: && m0 != NULL
! 3380: #endif
! 3381: ) {
! 3382: #if !defined(TULIP_COPY_RXDATA)
! 3383: ms->m_pkthdr.len = total_len;
! 3384: ms->m_pkthdr.rcvif = ifp;
! 3385: ether_input_mbuf(ifp, ms);
! 3386: #else
! 3387: m0->m_data += 2; /* align data after header */
! 3388: m_copydata(ms, 0, total_len, mtod(m0, caddr_t));
! 3389: m0->m_len = m0->m_pkthdr.len = total_len;
! 3390: m0->m_pkthdr.rcvif = ifp;
! 3391: ether_input_mbuf(ifp, m0);
! 3392: m0 = ms;
! 3393: #endif
! 3394: }
! 3395: ms = m0;
! 3396: }
! 3397: if (ms == NULL) {
! 3398: /*
! 3399: * Couldn't allocate a new buffer. Don't bother
! 3400: * trying to replenish the receive queue.
! 3401: */
! 3402: fillok = 0;
! 3403: sc->tulip_flags |= TULIP_RXBUFSLOW;
! 3404: #if defined(TULIP_DEBUG)
! 3405: sc->tulip_dbg.dbg_rxlowbufs++;
! 3406: #endif
! 3407: TULIP_PERFEND(rxget);
! 3408: continue;
! 3409: }
! 3410: /*
! 3411: * Now give the buffer(s) to the TULIP and save in our
! 3412: * receive queue.
! 3413: */
! 3414: do {
! 3415: tulip_desc_t * const nextout = ri->ri_nextout;
! 3416: if (sc->tulip_rxmaps_free > 0)
! 3417: map = sc->tulip_rxmaps[--sc->tulip_rxmaps_free];
! 3418: else {
! 3419: m_freem(ms);
! 3420: sc->tulip_flags |= TULIP_RXBUFSLOW;
! 3421: #if defined(TULIP_DEBUG)
! 3422: sc->tulip_dbg.dbg_rxlowbufs++;
! 3423: #endif
! 3424: break;
! 3425: }
! 3426: TULIP_SETCTX(ms, map);
! 3427: error = bus_dmamap_load(sc->tulip_dmatag, map, mtod(ms, void *),
! 3428: TULIP_RX_BUFLEN, NULL, BUS_DMA_NOWAIT);
! 3429: if (error) {
! 3430: printf(TULIP_PRINTF_FMT ": unable to load rx map, "
! 3431: "error = %d\n", TULIP_PRINTF_ARGS, error);
! 3432: panic("tulip_rx_intr"); /* XXX */
! 3433: }
! 3434: nextout->d_addr1 = map->dm_segs[0].ds_addr;
! 3435: nextout->d_length1 = map->dm_segs[0].ds_len;
! 3436: if (map->dm_nsegs == 2) {
! 3437: nextout->d_addr2 = map->dm_segs[1].ds_addr;
! 3438: nextout->d_length2 = map->dm_segs[1].ds_len;
! 3439: } else {
! 3440: nextout->d_addr2 = 0;
! 3441: nextout->d_length2 = 0;
! 3442: }
! 3443: TULIP_RXDESC_POSTSYNC(sc, nextout, sizeof(*nextout));
! 3444: nextout->d_status = TULIP_DSTS_OWNER;
! 3445: TULIP_RXDESC_POSTSYNC(sc, nextout, sizeof(u_int32_t));
! 3446: if (++ri->ri_nextout == ri->ri_last)
! 3447: ri->ri_nextout = ri->ri_first;
! 3448: me = ms->m_next;
! 3449: ms->m_next = NULL;
! 3450: IF_ENQUEUE(&sc->tulip_rxq, ms);
! 3451: } while ((ms = me) != NULL);
! 3452:
! 3453: if (sc->tulip_rxq.ifq_len >= TULIP_RXQ_TARGET)
! 3454: sc->tulip_flags &= ~TULIP_RXBUFSLOW;
! 3455: TULIP_PERFEND(rxget);
! 3456: }
! 3457:
! 3458: #if defined(TULIP_DEBUG)
! 3459: sc->tulip_dbg.dbg_rxintrs++;
! 3460: sc->tulip_dbg.dbg_rxpktsperintr[cnt]++;
! 3461: #endif
! 3462: TULIP_PERFEND(rxintr);
! 3463: }
! 3464:
! 3465: int
! 3466: tulip_tx_intr(tulip_softc_t * const sc)
! 3467: {
! 3468: TULIP_PERFSTART(txintr)
! 3469: tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
! 3470: struct mbuf *m;
! 3471: int xmits = 0;
! 3472: int descs = 0;
! 3473:
! 3474: while (ri->ri_free < ri->ri_max) {
! 3475: u_int32_t d_flag;
! 3476:
! 3477: TULIP_TXDESC_POSTSYNC(sc, ri->ri_nextin, sizeof(*ri->ri_nextin));
! 3478: if (((volatile tulip_desc_t *) ri->ri_nextin)->d_status & TULIP_DSTS_OWNER)
! 3479: break;
! 3480:
! 3481: ri->ri_free++;
! 3482: descs++;
! 3483: d_flag = ri->ri_nextin->d_flag;
! 3484: if (d_flag & TULIP_DFLAG_TxLASTSEG) {
! 3485: if (d_flag & TULIP_DFLAG_TxSETUPPKT) {
! 3486: /*
! 3487: * We've just finished processing a setup packet.
! 3488: * Mark that we finished it. If there's not
! 3489: * another pending, startup the TULIP receiver.
! 3490: * Make sure we ack the RXSTOPPED so we won't get
! 3491: * an abormal interrupt indication.
! 3492: */
! 3493: TULIP_TXMAP_POSTSYNC(sc, sc->tulip_setupmap);
! 3494: sc->tulip_flags &= ~(TULIP_DOINGSETUP|TULIP_HASHONLY);
! 3495: if (ri->ri_nextin->d_flag & TULIP_DFLAG_TxINVRSFILT)
! 3496: sc->tulip_flags |= TULIP_HASHONLY;
! 3497: if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == 0) {
! 3498: tulip_rx_intr(sc);
! 3499: sc->tulip_cmdmode |= TULIP_CMD_RXRUN;
! 3500: sc->tulip_intrmask |= TULIP_STS_RXSTOPPED;
! 3501: TULIP_CSR_WRITE(sc, csr_status, TULIP_STS_RXSTOPPED);
! 3502: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 3503: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 3504: }
! 3505: } else {
! 3506: const u_int32_t d_status = ri->ri_nextin->d_status;
! 3507: IF_DEQUEUE(&sc->tulip_txq, m);
! 3508: if (m != NULL) {
! 3509: bus_dmamap_t map = TULIP_GETCTX(m, bus_dmamap_t);
! 3510: TULIP_TXMAP_POSTSYNC(sc, map);
! 3511: sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
! 3512: #if NBPFILTER > 0
! 3513: if (sc->tulip_bpf != NULL)
! 3514: bpf_mtap(sc->tulip_if.if_bpf, m, BPF_DIRECTION_OUT);
! 3515: #endif
! 3516: m_freem(m);
! 3517: }
! 3518: if (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) {
! 3519: tulip_mediapoll_event_t event = TULIP_MEDIAPOLL_TXPROBE_OK;
! 3520: if (d_status & (TULIP_DSTS_TxNOCARR|TULIP_DSTS_TxEXCCOLL)) {
! 3521: #if defined(TULIP_DEBUG)
! 3522: if (d_status & TULIP_DSTS_TxNOCARR)
! 3523: sc->tulip_dbg.dbg_txprobe_nocarr++;
! 3524: if (d_status & TULIP_DSTS_TxEXCCOLL)
! 3525: sc->tulip_dbg.dbg_txprobe_exccoll++;
! 3526: #endif
! 3527: event = TULIP_MEDIAPOLL_TXPROBE_FAILED;
! 3528: }
! 3529: (*sc->tulip_boardsw->bd_media_poll)(sc, event);
! 3530: /*
! 3531: * Escape from the loop before media poll has reset the TULIP!
! 3532: */
! 3533: break;
! 3534: } else {
! 3535: xmits++;
! 3536: if (d_status & TULIP_DSTS_ERRSUM) {
! 3537: sc->tulip_if.if_oerrors++;
! 3538: if (d_status & TULIP_DSTS_TxEXCCOLL)
! 3539: sc->tulip_dot3stats.dot3StatsExcessiveCollisions++;
! 3540: if (d_status & TULIP_DSTS_TxLATECOLL)
! 3541: sc->tulip_dot3stats.dot3StatsLateCollisions++;
! 3542: if (d_status & (TULIP_DSTS_TxNOCARR|TULIP_DSTS_TxCARRLOSS))
! 3543: sc->tulip_dot3stats.dot3StatsCarrierSenseErrors++;
! 3544: if (d_status & (TULIP_DSTS_TxUNDERFLOW|TULIP_DSTS_TxBABBLE))
! 3545: sc->tulip_dot3stats.dot3StatsInternalMacTransmitErrors++;
! 3546: if (d_status & TULIP_DSTS_TxUNDERFLOW)
! 3547: sc->tulip_dot3stats.dot3StatsInternalTransmitUnderflows++;
! 3548: if (d_status & TULIP_DSTS_TxBABBLE)
! 3549: sc->tulip_dot3stats.dot3StatsInternalTransmitBabbles++;
! 3550: } else {
! 3551: u_int32_t collisions =
! 3552: (d_status & TULIP_DSTS_TxCOLLMASK)
! 3553: >> TULIP_DSTS_V_TxCOLLCNT;
! 3554: sc->tulip_if.if_collisions += collisions;
! 3555: if (collisions == 1)
! 3556: sc->tulip_dot3stats.dot3StatsSingleCollisionFrames++;
! 3557: else if (collisions > 1)
! 3558: sc->tulip_dot3stats.dot3StatsMultipleCollisionFrames++;
! 3559: else if (d_status & TULIP_DSTS_TxDEFERRED)
! 3560: sc->tulip_dot3stats.dot3StatsDeferredTransmissions++;
! 3561: /*
! 3562: * SQE is only valid for 10baseT/BNC/AUI when not
! 3563: * running in full-duplex. In order to speed up the
! 3564: * test, the corresponding bit in tulip_flags needs to
! 3565: * set as well to get us to count SQE Test Errors.
! 3566: */
! 3567: if (d_status & TULIP_DSTS_TxNOHRTBT & sc->tulip_flags)
! 3568: sc->tulip_dot3stats.dot3StatsSQETestErrors++;
! 3569: }
! 3570: }
! 3571: }
! 3572: }
! 3573:
! 3574: if (++ri->ri_nextin == ri->ri_last)
! 3575: ri->ri_nextin = ri->ri_first;
! 3576:
! 3577: if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0)
! 3578: sc->tulip_if.if_flags &= ~IFF_OACTIVE;
! 3579: }
! 3580: /*
! 3581: * If nothing left to transmit, disable the timer.
! 3582: * Else if progress, reset the timer back to 2 ticks.
! 3583: */
! 3584: if (ri->ri_free == ri->ri_max || (sc->tulip_flags & TULIP_TXPROBE_ACTIVE))
! 3585: sc->tulip_txtimer = 0;
! 3586: else if (xmits > 0)
! 3587: sc->tulip_txtimer = TULIP_TXTIMER;
! 3588: sc->tulip_if.if_opackets += xmits;
! 3589: TULIP_PERFEND(txintr);
! 3590: return (descs);
! 3591: }
! 3592:
! 3593: void
! 3594: tulip_print_abnormal_interrupt(tulip_softc_t * const sc, u_int32_t csr)
! 3595: {
! 3596: #ifdef TULIP_DEBUG
! 3597: const char * const *msgp = tulip_status_bits;
! 3598: const char *sep;
! 3599: u_int32_t mask;
! 3600: const char thrsh[] = "72|128\0\0\0" "96|256\0\0\0" "128|512\0\0" "160|1024\0";
! 3601:
! 3602: csr &= (1 << (sizeof(tulip_status_bits)/sizeof(tulip_status_bits[0]))) - 1;
! 3603: printf(TULIP_PRINTF_FMT ": abnormal interrupt:", TULIP_PRINTF_ARGS);
! 3604: for (sep = " ", mask = 1; mask <= csr; mask <<= 1, msgp++) {
! 3605: if ((csr & mask) && *msgp != NULL) {
! 3606: printf("%s%s", sep, *msgp);
! 3607: if (mask == TULIP_STS_TXUNDERFLOW && (sc->tulip_flags & TULIP_NEWTXTHRESH)) {
! 3608: sc->tulip_flags &= ~TULIP_NEWTXTHRESH;
! 3609: if (sc->tulip_cmdmode & TULIP_CMD_STOREFWD)
! 3610: printf(" (switching to store-and-forward mode)");
! 3611: else {
! 3612: printf(" (raising TX threshold to %s)",
! 3613: &thrsh[9 * ((sc->tulip_cmdmode & TULIP_CMD_THRESHOLDCTL) >> 14)]);
! 3614: }
! 3615: }
! 3616: sep = ", ";
! 3617: }
! 3618: }
! 3619: printf("\n");
! 3620: #endif
! 3621: }
! 3622:
! 3623: void
! 3624: tulip_intr_handler(tulip_softc_t * const sc, int *progress_p)
! 3625: {
! 3626: TULIP_PERFSTART(intr)
! 3627: u_int32_t csr;
! 3628:
! 3629: while ((csr = TULIP_CSR_READ(sc, csr_status)) & sc->tulip_intrmask) {
! 3630: *progress_p = 1;
! 3631: TULIP_CSR_WRITE(sc, csr_status, csr);
! 3632:
! 3633: if (csr & TULIP_STS_SYSERROR) {
! 3634: sc->tulip_last_system_error = (csr & TULIP_STS_ERRORMASK) >> TULIP_STS_ERR_SHIFT;
! 3635: if (sc->tulip_flags & TULIP_NOMESSAGES)
! 3636: sc->tulip_flags |= TULIP_SYSTEMERROR;
! 3637: else {
! 3638: #if defined(TULIP_DEBUG)
! 3639: printf(TULIP_PRINTF_FMT ": system error: %s\n",
! 3640: TULIP_PRINTF_ARGS,
! 3641: tulip_system_errors[sc->tulip_last_system_error]);
! 3642: #endif
! 3643: }
! 3644: sc->tulip_flags |= TULIP_NEEDRESET;
! 3645: sc->tulip_system_errors++;
! 3646: break;
! 3647: }
! 3648: if (csr & (TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL) & sc->tulip_intrmask) {
! 3649: #if defined(TULIP_DEBUG)
! 3650: sc->tulip_dbg.dbg_link_intrs++;
! 3651: #endif
! 3652: if (sc->tulip_boardsw->bd_media_poll != NULL) {
! 3653: (*sc->tulip_boardsw->bd_media_poll)(sc, csr & TULIP_STS_LINKFAIL
! 3654: ? TULIP_MEDIAPOLL_LINKFAIL
! 3655: : TULIP_MEDIAPOLL_LINKPASS);
! 3656: csr &= ~TULIP_STS_ABNRMLINTR;
! 3657: }
! 3658: tulip_media_print(sc);
! 3659: }
! 3660: if (csr & (TULIP_STS_RXINTR|TULIP_STS_RXNOBUF)) {
! 3661: u_int32_t misses = TULIP_CSR_READ(sc, csr_missed_frames);
! 3662: if (csr & TULIP_STS_RXNOBUF)
! 3663: sc->tulip_dot3stats.dot3StatsMissedFrames += misses & 0xFFFF;
! 3664: /*
! 3665: * Pass 2.[012] of the 21140A-A[CDE] may hang and/or corrupt data
! 3666: * on receive overflows.
! 3667: */
! 3668: if ((misses & 0x0FFE0000) && (sc->tulip_features & TULIP_HAVE_RXBADOVRFLW)) {
! 3669: sc->tulip_dot3stats.dot3StatsInternalMacReceiveErrors++;
! 3670: /*
! 3671: * Stop the receiver process and spin until it's stopped.
! 3672: * Tell rx_intr to drop the packets it dequeues.
! 3673: */
! 3674: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode & ~TULIP_CMD_RXRUN);
! 3675: while ((TULIP_CSR_READ(sc, csr_status) & TULIP_STS_RXSTOPPED) == 0)
! 3676: ;
! 3677: TULIP_CSR_WRITE(sc, csr_status, TULIP_STS_RXSTOPPED);
! 3678: sc->tulip_flags |= TULIP_RXIGNORE;
! 3679: }
! 3680: tulip_rx_intr(sc);
! 3681: if (sc->tulip_flags & TULIP_RXIGNORE) {
! 3682: /*
! 3683: * Restart the receiver.
! 3684: */
! 3685: sc->tulip_flags &= ~TULIP_RXIGNORE;
! 3686: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 3687: }
! 3688: }
! 3689: if (csr & TULIP_STS_ABNRMLINTR) {
! 3690: u_int32_t tmp = csr & sc->tulip_intrmask
! 3691: & ~(TULIP_STS_NORMALINTR|TULIP_STS_ABNRMLINTR);
! 3692: if (csr & TULIP_STS_TXUNDERFLOW) {
! 3693: #if defined(TULIP_DEBUG)
! 3694: printf ("Underflow interrupt\n");
! 3695: #endif
! 3696: if ((sc->tulip_cmdmode & TULIP_CMD_THRESHOLDCTL) != TULIP_CMD_THRSHLD160) {
! 3697: sc->tulip_cmdmode += TULIP_CMD_THRSHLD96;
! 3698: sc->tulip_flags |= TULIP_NEWTXTHRESH;
! 3699: } else if (sc->tulip_features & TULIP_HAVE_STOREFWD) {
! 3700: sc->tulip_cmdmode |= TULIP_CMD_STOREFWD;
! 3701: sc->tulip_flags |= TULIP_NEWTXTHRESH;
! 3702: }
! 3703: }
! 3704: if (sc->tulip_flags & TULIP_NOMESSAGES)
! 3705: sc->tulip_statusbits |= tmp;
! 3706: else {
! 3707: tulip_print_abnormal_interrupt(sc, tmp);
! 3708: sc->tulip_flags |= TULIP_NOMESSAGES;
! 3709: }
! 3710: TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
! 3711: }
! 3712: if (sc->tulip_flags & (TULIP_WANTTXSTART|TULIP_TXPROBE_ACTIVE|TULIP_DOINGSETUP|TULIP_PROMISC)) {
! 3713: tulip_tx_intr(sc);
! 3714: if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0)
! 3715: tulip_ifstart(&sc->tulip_if);
! 3716: }
! 3717: }
! 3718: if (sc->tulip_flags & TULIP_NEEDRESET) {
! 3719: tulip_reset(sc);
! 3720: tulip_init(sc);
! 3721: }
! 3722: TULIP_PERFEND(intr);
! 3723: }
! 3724:
! 3725: int
! 3726: tulip_intr_shared(void *arg)
! 3727: {
! 3728: tulip_softc_t * sc = arg;
! 3729: int progress = 0;
! 3730:
! 3731: for (; sc != NULL; sc = sc->tulip_slaves) {
! 3732: #if defined(TULIP_DEBUG)
! 3733: sc->tulip_dbg.dbg_intrs++;
! 3734: #endif
! 3735: tulip_intr_handler(sc, &progress);
! 3736: }
! 3737: return (progress);
! 3738: }
! 3739:
! 3740: int
! 3741: tulip_intr_normal(void *arg)
! 3742: {
! 3743: tulip_softc_t * sc = (tulip_softc_t *) arg;
! 3744: int progress = 0;
! 3745:
! 3746: #if defined(TULIP_DEBUG)
! 3747: sc->tulip_dbg.dbg_intrs++;
! 3748: #endif
! 3749: tulip_intr_handler(sc, &progress);
! 3750:
! 3751: return (progress);
! 3752: }
! 3753:
! 3754: struct mbuf *
! 3755: tulip_mbuf_compress(struct mbuf *m)
! 3756: {
! 3757: struct mbuf *m0;
! 3758: #if MCLBYTES >= ETHERMTU + 18
! 3759: MGETHDR(m0, M_DONTWAIT, MT_DATA);
! 3760: if (m0 != NULL) {
! 3761: if (m->m_pkthdr.len > MHLEN) {
! 3762: MCLGET(m0, M_DONTWAIT);
! 3763: if ((m0->m_flags & M_EXT) == 0) {
! 3764: m_freem(m);
! 3765: m_freem(m0);
! 3766: return (NULL);
! 3767: }
! 3768: }
! 3769: m_copydata(m, 0, m->m_pkthdr.len, mtod(m0, caddr_t));
! 3770: m0->m_pkthdr.len = m0->m_len = m->m_pkthdr.len;
! 3771: }
! 3772: #else
! 3773: int mlen = MHLEN;
! 3774: int len = m->m_pkthdr.len;
! 3775: struct mbuf **mp = &m0;
! 3776:
! 3777: while (len > 0) {
! 3778: if (mlen == MHLEN)
! 3779: MGETHDR(*mp, M_DONTWAIT, MT_DATA);
! 3780: else
! 3781: MGET(*mp, M_DONTWAIT, MT_DATA);
! 3782: if (*mp == NULL) {
! 3783: m_freem(m0);
! 3784: m0 = NULL;
! 3785: break;
! 3786: }
! 3787: if (len > MLEN) {
! 3788: MCLGET(*mp, M_DONTWAIT);
! 3789: if (((*mp)->m_flags & M_EXT) == 0) {
! 3790: m_freem(m0);
! 3791: m0 = NULL;
! 3792: break;
! 3793: }
! 3794: (*mp)->m_len = len <= MCLBYTES ? len : MCLBYTES;
! 3795: else
! 3796: (*mp)->m_len = len <= mlen ? len : mlen;
! 3797: m_copydata(m, m->m_pkthdr.len - len,
! 3798: (*mp)->m_len, mtod((*mp), caddr_t));
! 3799: len -= (*mp)->m_len;
! 3800: mp = &(*mp)->m_next;
! 3801: mlen = MLEN;
! 3802: }
! 3803: #endif
! 3804: m_freem(m);
! 3805: return (m0);
! 3806: }
! 3807:
! 3808: struct mbuf *
! 3809: tulip_txput(tulip_softc_t * const sc, struct mbuf *m)
! 3810: {
! 3811: TULIP_PERFSTART(txput)
! 3812: tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
! 3813: tulip_desc_t *eop, *nextout;
! 3814: int segcnt, freedescs;
! 3815: u_int32_t d_status;
! 3816: bus_dmamap_t map;
! 3817: int error;
! 3818: struct ifnet *ifp = &sc->tulip_if;
! 3819: struct mbuf *ombuf = m;
! 3820: int compressed = 0;
! 3821:
! 3822: #if defined(TULIP_DEBUG)
! 3823: if ((sc->tulip_cmdmode & TULIP_CMD_TXRUN) == 0) {
! 3824: printf(TULIP_PRINTF_FMT ": txput%s: tx not running\n",
! 3825: TULIP_PRINTF_ARGS,
! 3826: (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) ? "(probe)" : "");
! 3827: sc->tulip_flags |= TULIP_WANTTXSTART;
! 3828: sc->tulip_dbg.dbg_txput_finishes[0]++;
! 3829: goto finish;
! 3830: }
! 3831: #endif
! 3832:
! 3833: /*
! 3834: * Now we try to fill in our transmit descriptors. This is
! 3835: * a bit reminiscent of going on the Ark two by two
! 3836: * since each descriptor for the TULIP can describe
! 3837: * two buffers. So we advance through packet filling
! 3838: * each of the two entries at a time to to fill each
! 3839: * descriptor. Clear the first and last segment bits
! 3840: * in each descriptor (actually just clear everything
! 3841: * but the end-of-ring or chain bits) to make sure
! 3842: * we don't get messed up by previously sent packets.
! 3843: *
! 3844: * We may fail to put the entire packet on the ring if
! 3845: * there is either not enough ring entries free or if the
! 3846: * packet has more than MAX_TXSEG segments. In the former
! 3847: * case we will just wait for the ring to empty. In the
! 3848: * latter case we have to recopy.
! 3849: */
! 3850: d_status = 0;
! 3851: eop = nextout = ri->ri_nextout;
! 3852: segcnt = 0;
! 3853: freedescs = ri->ri_free;
! 3854:
! 3855: /*
! 3856: * Reclaim some DMA maps from if we are out.
! 3857: */
! 3858: if (sc->tulip_txmaps_free == 0) {
! 3859: #if defined(TULIP_DEBUG)
! 3860: sc->tulip_dbg.dbg_no_txmaps++;
! 3861: #endif
! 3862: freedescs += tulip_tx_intr(sc);
! 3863: }
! 3864: if (sc->tulip_txmaps_free > 0)
! 3865: map = sc->tulip_txmaps[sc->tulip_txmaps_free-1];
! 3866: else {
! 3867: sc->tulip_flags |= TULIP_WANTTXSTART;
! 3868: #if defined(TULIP_DEBUG)
! 3869: sc->tulip_dbg.dbg_txput_finishes[1]++;
! 3870: #endif
! 3871: goto finish;
! 3872: }
! 3873: error = bus_dmamap_load_mbuf(sc->tulip_dmatag, map, m, BUS_DMA_NOWAIT);
! 3874: if (error != 0) {
! 3875: if (error == EFBIG) {
! 3876: /*
! 3877: * The packet exceeds the number of transmit buffer
! 3878: * entries that we can use for one packet, so we have
! 3879: * to recopy it into one mbuf and then try again.
! 3880: */
! 3881: struct mbuf *tmp;
! 3882: /*
! 3883: * tulip_mbuf_compress() frees the original mbuf.
! 3884: * thus, we have to remove the mbuf from the queue
! 3885: * before calling it.
! 3886: * we don't have to worry about space shortage
! 3887: * after compressing the mbuf since the compressed
! 3888: * mbuf will take only two segs.
! 3889: */
! 3890: if (compressed) {
! 3891: /* should not happen */
! 3892: #ifdef TULIP_DEBUG
! 3893: printf("tulip_txput: compress called twice!\n");
! 3894: #endif
! 3895: goto finish;
! 3896: }
! 3897: IFQ_DEQUEUE(&ifp->if_snd, tmp);
! 3898: if (tmp != ombuf)
! 3899: panic("tulip_txput: different mbuf dequeued!");
! 3900: compressed = 1;
! 3901: m = tulip_mbuf_compress(m);
! 3902: if (m == NULL) {
! 3903: #if defined(TULIP_DEBUG)
! 3904: sc->tulip_dbg.dbg_txput_finishes[2]++;
! 3905: #endif
! 3906: goto finish;
! 3907: }
! 3908: error = bus_dmamap_load_mbuf(sc->tulip_dmatag, map, m, BUS_DMA_NOWAIT);
! 3909: }
! 3910: if (error != 0) {
! 3911: printf(TULIP_PRINTF_FMT ": unable to load tx map, "
! 3912: "error = %d\n", TULIP_PRINTF_ARGS, error);
! 3913: #if defined(TULIP_DEBUG)
! 3914: sc->tulip_dbg.dbg_txput_finishes[3]++;
! 3915: #endif
! 3916: goto finish;
! 3917: }
! 3918: }
! 3919: if ((freedescs -= (map->dm_nsegs + 1) / 2) <= 0
! 3920: /*
! 3921: * See if there's any unclaimed space in the transmit ring.
! 3922: */
! 3923: && (freedescs += tulip_tx_intr(sc)) <= 0) {
! 3924: /*
! 3925: * There's no more room but since nothing
! 3926: * has been committed at this point, just
! 3927: * show output is active, put back the
! 3928: * mbuf and return.
! 3929: */
! 3930: sc->tulip_flags |= TULIP_WANTTXSTART;
! 3931: #if defined(TULIP_DEBUG)
! 3932: sc->tulip_dbg.dbg_txput_finishes[4]++;
! 3933: #endif
! 3934: bus_dmamap_unload(sc->tulip_dmatag, map);
! 3935: goto finish;
! 3936: }
! 3937: for (; map->dm_nsegs - segcnt > 1; segcnt += 2) {
! 3938: eop = nextout;
! 3939: eop->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
! 3940: eop->d_status = d_status;
! 3941: eop->d_addr1 = map->dm_segs[segcnt].ds_addr;
! 3942: eop->d_length1 = map->dm_segs[segcnt].ds_len;
! 3943: eop->d_addr2 = map->dm_segs[segcnt+1].ds_addr;
! 3944: eop->d_length2 = map->dm_segs[segcnt+1].ds_len;
! 3945: d_status = TULIP_DSTS_OWNER;
! 3946: if (++nextout == ri->ri_last)
! 3947: nextout = ri->ri_first;
! 3948: }
! 3949: if (segcnt < map->dm_nsegs) {
! 3950: eop = nextout;
! 3951: eop->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
! 3952: eop->d_status = d_status;
! 3953: eop->d_addr1 = map->dm_segs[segcnt].ds_addr;
! 3954: eop->d_length1 = map->dm_segs[segcnt].ds_len;
! 3955: eop->d_addr2 = 0;
! 3956: eop->d_length2 = 0;
! 3957: if (++nextout == ri->ri_last)
! 3958: nextout = ri->ri_first;
! 3959: }
! 3960: TULIP_TXMAP_PRESYNC(sc, map);
! 3961: TULIP_SETCTX(m, map);
! 3962: map = NULL;
! 3963: --sc->tulip_txmaps_free; /* commit to using the dmamap */
! 3964:
! 3965: /*
! 3966: * The descriptors have been filled in. Now get ready
! 3967: * to transmit.
! 3968: */
! 3969: if (!compressed && (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0) {
! 3970: /* remove the mbuf from the queue */
! 3971: struct mbuf *tmp;
! 3972: IFQ_DEQUEUE(&ifp->if_snd, tmp);
! 3973: if (tmp != ombuf)
! 3974: panic("tulip_txput: different mbuf dequeued!");
! 3975: }
! 3976:
! 3977: IF_ENQUEUE(&sc->tulip_txq, m);
! 3978: m = NULL;
! 3979:
! 3980: /*
! 3981: * Make sure the next descriptor after this packet is owned
! 3982: * by us since it may have been set up above if we ran out
! 3983: * of room in the ring.
! 3984: */
! 3985: nextout->d_status = 0;
! 3986: TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(u_int32_t));
! 3987:
! 3988: /*
! 3989: * Mark the last and first segments, indicate we want a transmit
! 3990: * complete interrupt, and tell it to transmit!
! 3991: */
! 3992: eop->d_flag |= TULIP_DFLAG_TxLASTSEG|TULIP_DFLAG_TxWANTINTR;
! 3993:
! 3994: /*
! 3995: * Note that ri->ri_nextout is still the start of the packet
! 3996: * and until we set the OWNER bit, we can still back out of
! 3997: * everything we have done.
! 3998: */
! 3999: ri->ri_nextout->d_flag |= TULIP_DFLAG_TxFIRSTSEG;
! 4000: if (eop < ri->ri_nextout) {
! 4001: TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout,
! 4002: (caddr_t) ri->ri_last - (caddr_t) ri->ri_nextout);
! 4003: TULIP_TXDESC_PRESYNC(sc, ri->ri_first,
! 4004: (caddr_t) (eop + 1) - (caddr_t) ri->ri_first);
! 4005: } else {
! 4006: TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout,
! 4007: (caddr_t) (eop + 1) - (caddr_t) ri->ri_nextout);
! 4008: }
! 4009: ri->ri_nextout->d_status = TULIP_DSTS_OWNER;
! 4010: TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout, sizeof(u_int32_t));
! 4011:
! 4012: /*
! 4013: * This advances the ring for us.
! 4014: */
! 4015: ri->ri_nextout = nextout;
! 4016: ri->ri_free = freedescs;
! 4017:
! 4018: TULIP_PERFEND(txput);
! 4019:
! 4020: if (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) {
! 4021: TULIP_CSR_WRITE(sc, csr_txpoll, 1);
! 4022: sc->tulip_if.if_flags |= IFF_OACTIVE;
! 4023: sc->tulip_if.if_start = tulip_ifstart;
! 4024: TULIP_PERFEND(txput);
! 4025: return (NULL);
! 4026: }
! 4027:
! 4028: /*
! 4029: * switch back to the single queueing ifstart.
! 4030: */
! 4031: sc->tulip_flags &= ~TULIP_WANTTXSTART;
! 4032: if (sc->tulip_txtimer == 0)
! 4033: sc->tulip_txtimer = TULIP_TXTIMER;
! 4034: #if defined(TULIP_DEBUG)
! 4035: sc->tulip_dbg.dbg_txput_finishes[5]++;
! 4036: #endif
! 4037:
! 4038: /*
! 4039: * If we want a txstart, there must be not enough space in the
! 4040: * transmit ring. So we want to enable transmit done interrupts
! 4041: * so we can immediately reclaim some space. When the transmit
! 4042: * interrupt is posted, the interrupt handler will call tx_intr
! 4043: * to reclaim space and then txstart (since WANTTXSTART is set).
! 4044: * txstart will move the packet into the transmit ring and clear
! 4045: * WANTTXSTART thereby causing TXINTR to be cleared.
! 4046: */
! 4047: finish:
! 4048: #if defined(TULIP_DEBUG)
! 4049: sc->tulip_dbg.dbg_txput_finishes[6]++;
! 4050: #endif
! 4051: if (sc->tulip_flags & (TULIP_WANTTXSTART|TULIP_DOINGSETUP)) {
! 4052: sc->tulip_if.if_flags |= IFF_OACTIVE;
! 4053: sc->tulip_if.if_start = tulip_ifstart;
! 4054: if ((sc->tulip_intrmask & TULIP_STS_TXINTR) == 0) {
! 4055: sc->tulip_intrmask |= TULIP_STS_TXINTR;
! 4056: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 4057: }
! 4058: } else if ((sc->tulip_flags & TULIP_PROMISC) == 0) {
! 4059: if (sc->tulip_intrmask & TULIP_STS_TXINTR) {
! 4060: sc->tulip_intrmask &= ~TULIP_STS_TXINTR;
! 4061: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 4062: }
! 4063: }
! 4064: TULIP_CSR_WRITE(sc, csr_txpoll, 1);
! 4065: TULIP_PERFEND(txput);
! 4066: return (m);
! 4067: }
! 4068:
! 4069: void
! 4070: tulip_txput_setup(tulip_softc_t * const sc)
! 4071: {
! 4072: tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
! 4073: tulip_desc_t *nextout;
! 4074:
! 4075: /*
! 4076: * We will transmit, at most, one setup packet per call to ifstart.
! 4077: */
! 4078:
! 4079: #if defined(TULIP_DEBUG)
! 4080: if ((sc->tulip_cmdmode & TULIP_CMD_TXRUN) == 0) {
! 4081: printf(TULIP_PRINTF_FMT ": txput_setup: tx not running\n",
! 4082: TULIP_PRINTF_ARGS);
! 4083: sc->tulip_flags |= TULIP_WANTTXSTART;
! 4084: sc->tulip_if.if_start = tulip_ifstart;
! 4085: return;
! 4086: }
! 4087: #endif
! 4088: /*
! 4089: * Try to reclaim some free descriptors..
! 4090: */
! 4091: if (ri->ri_free < 2)
! 4092: tulip_tx_intr(sc);
! 4093: if ((sc->tulip_flags & TULIP_DOINGSETUP) || ri->ri_free == 1) {
! 4094: sc->tulip_flags |= TULIP_WANTTXSTART;
! 4095: sc->tulip_if.if_start = tulip_ifstart;
! 4096: return;
! 4097: }
! 4098: bcopy(sc->tulip_setupdata, sc->tulip_setupbuf,
! 4099: sizeof(sc->tulip_setupbuf));
! 4100: /*
! 4101: * Clear WANTSETUP and set DOINGSETUP. Set know that WANTSETUP is
! 4102: * set and DOINGSETUP is clear doing an XOR of the two will DTRT.
! 4103: */
! 4104: sc->tulip_flags ^= TULIP_WANTSETUP|TULIP_DOINGSETUP;
! 4105: ri->ri_free--;
! 4106: nextout = ri->ri_nextout;
! 4107: nextout->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
! 4108: nextout->d_flag |= TULIP_DFLAG_TxFIRSTSEG|TULIP_DFLAG_TxLASTSEG
! 4109: |TULIP_DFLAG_TxSETUPPKT|TULIP_DFLAG_TxWANTINTR;
! 4110: if (sc->tulip_flags & TULIP_WANTHASHPERFECT)
! 4111: nextout->d_flag |= TULIP_DFLAG_TxHASHFILT;
! 4112: else if (sc->tulip_flags & TULIP_WANTHASHONLY)
! 4113: nextout->d_flag |= TULIP_DFLAG_TxHASHFILT|TULIP_DFLAG_TxINVRSFILT;
! 4114:
! 4115: nextout->d_length2 = 0;
! 4116: nextout->d_addr2 = 0;
! 4117: nextout->d_length1 = sc->tulip_setupmap->dm_segs[0].ds_len;
! 4118: nextout->d_addr1 = sc->tulip_setupmap->dm_segs[0].ds_addr;
! 4119: if (sc->tulip_setupmap->dm_nsegs == 2) {
! 4120: nextout->d_length2 = sc->tulip_setupmap->dm_segs[1].ds_len;
! 4121: nextout->d_addr2 = sc->tulip_setupmap->dm_segs[1].ds_addr;
! 4122: }
! 4123: TULIP_TXMAP_PRESYNC(sc, sc->tulip_setupmap);
! 4124: TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(*nextout));
! 4125:
! 4126: /*
! 4127: * Advance the ring for the next transmit packet.
! 4128: */
! 4129: if (++ri->ri_nextout == ri->ri_last)
! 4130: ri->ri_nextout = ri->ri_first;
! 4131:
! 4132: /*
! 4133: * Make sure the next descriptor is owned by us since it
! 4134: * may have been set up above if we ran out of room in the
! 4135: * ring.
! 4136: */
! 4137: ri->ri_nextout->d_status = 0;
! 4138: TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout, sizeof(u_int32_t));
! 4139: nextout->d_status = TULIP_DSTS_OWNER;
! 4140: /*
! 4141: * Flush the ownwership of the current descriptor
! 4142: */
! 4143: TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(u_int32_t));
! 4144: TULIP_CSR_WRITE(sc, csr_txpoll, 1);
! 4145: if ((sc->tulip_intrmask & TULIP_STS_TXINTR) == 0) {
! 4146: sc->tulip_intrmask |= TULIP_STS_TXINTR;
! 4147: TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
! 4148: }
! 4149: }
! 4150:
! 4151: /*
! 4152: * This routine is entered at splnet().
! 4153: */
! 4154: int
! 4155: tulip_ifioctl(struct ifnet * ifp, u_long cmd, caddr_t data)
! 4156: {
! 4157: TULIP_PERFSTART(ifioctl)
! 4158: tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
! 4159: struct ifaddr *ifa = (struct ifaddr *)data;
! 4160: struct ifreq *ifr = (struct ifreq *) data;
! 4161: int s;
! 4162: int error = 0;
! 4163:
! 4164: s = splnet();
! 4165:
! 4166: if ((error = ether_ioctl(ifp, &sc->tulip_ac, cmd, data)) > 0) {
! 4167: splx(s);
! 4168: return (error);
! 4169: }
! 4170:
! 4171: switch (cmd) {
! 4172: case SIOCSIFADDR: {
! 4173: ifp->if_flags |= IFF_UP;
! 4174: tulip_init(sc);
! 4175: switch(ifa->ifa_addr->sa_family) {
! 4176: #ifdef INET
! 4177: case AF_INET: {
! 4178: arp_ifinit(&sc->tulip_ac, ifa);
! 4179: break;
! 4180: }
! 4181: #endif /* INET */
! 4182:
! 4183: default: {
! 4184: break;
! 4185: }
! 4186: }
! 4187: break;
! 4188: }
! 4189:
! 4190: case SIOCSIFFLAGS: {
! 4191: tulip_init(sc);
! 4192: break;
! 4193: }
! 4194:
! 4195: case SIOCSIFMEDIA:
! 4196: case SIOCGIFMEDIA: {
! 4197: error = ifmedia_ioctl(ifp, ifr, &sc->tulip_ifmedia, cmd);
! 4198: break;
! 4199: }
! 4200:
! 4201: case SIOCADDMULTI:
! 4202: case SIOCDELMULTI: {
! 4203: /*
! 4204: * Update multicast listeners
! 4205: */
! 4206: if (cmd == SIOCADDMULTI)
! 4207: error = ether_addmulti(ifr, &sc->tulip_ac);
! 4208: else
! 4209: error = ether_delmulti(ifr, &sc->tulip_ac);
! 4210:
! 4211: if (error == ENETRESET) {
! 4212: if (ifp->if_flags & IFF_RUNNING) {
! 4213: tulip_addr_filter(sc); /* reset multicast filtering */
! 4214: tulip_init(sc);
! 4215: }
! 4216: error = 0;
! 4217: }
! 4218: break;
! 4219: }
! 4220:
! 4221: case SIOCSIFMTU:
! 4222: /*
! 4223: * Set the interface MTU.
! 4224: */
! 4225: if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ETHERMTU)
! 4226: error = EINVAL;
! 4227: else if (ifp->if_mtu != ifr->ifr_mtu)
! 4228: ifp->if_mtu = ifr->ifr_mtu;
! 4229: break;
! 4230:
! 4231: default:
! 4232: error = ENOTTY;
! 4233: break;
! 4234: }
! 4235:
! 4236: splx(s);
! 4237: TULIP_PERFEND(ifioctl);
! 4238: return (error);
! 4239: }
! 4240:
! 4241: /*
! 4242: * the original dequeueing policy is dequeue-and-prepend if something
! 4243: * goes wrong. when altq is used, it is changed to peek-and-dequeue.
! 4244: * the modification becomes a bit complicated since tulip_txput() might
! 4245: * copy and modify the mbuf passed.
! 4246: */
! 4247: /*
! 4248: * These routines gets called at device spl (from ether_output).
! 4249: */
! 4250:
! 4251: void
! 4252: tulip_ifstart(struct ifnet * const ifp)
! 4253: {
! 4254: TULIP_PERFSTART(ifstart)
! 4255: tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
! 4256:
! 4257: if (sc->tulip_if.if_flags & IFF_RUNNING) {
! 4258:
! 4259: if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == TULIP_WANTSETUP)
! 4260: tulip_txput_setup(sc);
! 4261:
! 4262: while (!IFQ_IS_EMPTY(&sc->tulip_if.if_snd)) {
! 4263: struct mbuf *m, *m0;
! 4264: IFQ_POLL(&sc->tulip_if.if_snd, m);
! 4265: if (m == NULL)
! 4266: break;
! 4267: if ((m0 = tulip_txput(sc, m)) != NULL) {
! 4268: if (m0 != m)
! 4269: /* should not happen */
! 4270: printf("tulip_if_start: txput failed!\n");
! 4271: break;
! 4272: }
! 4273: }
! 4274: #ifdef ALTQ
! 4275: if (0) /* don't switch to the one packet mode */
! 4276: #else
! 4277: if (IFQ_IS_EMPTY(&sc->tulip_if.if_snd))
! 4278: #endif
! 4279: sc->tulip_if.if_start = tulip_ifstart_one;
! 4280: }
! 4281:
! 4282: TULIP_PERFEND(ifstart);
! 4283: }
! 4284:
! 4285: void
! 4286: tulip_ifstart_one(struct ifnet * const ifp)
! 4287: {
! 4288: TULIP_PERFSTART(ifstart_one)
! 4289: tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
! 4290:
! 4291: if ((sc->tulip_if.if_flags & IFF_RUNNING)
! 4292: && !IFQ_IS_EMPTY(&sc->tulip_if.if_snd)) {
! 4293: struct mbuf *m, *m0;
! 4294: IFQ_POLL(&sc->tulip_if.if_snd, m);
! 4295: if (m != NULL && (m0 = tulip_txput(sc, m)) != NULL)
! 4296: if (m0 != m)
! 4297: /* should not happen */
! 4298: printf("tulip_if_start_one: txput failed!\n");
! 4299: }
! 4300: TULIP_PERFEND(ifstart_one);
! 4301: }
! 4302:
! 4303: void
! 4304: tulip_ifwatchdog(struct ifnet *ifp)
! 4305: {
! 4306: TULIP_PERFSTART(ifwatchdog)
! 4307: tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
! 4308:
! 4309: #if defined(TULIP_DEBUG)
! 4310: u_int32_t rxintrs = sc->tulip_dbg.dbg_rxintrs - sc->tulip_dbg.dbg_last_rxintrs;
! 4311: if (rxintrs > sc->tulip_dbg.dbg_high_rxintrs_hz)
! 4312: sc->tulip_dbg.dbg_high_rxintrs_hz = rxintrs;
! 4313: sc->tulip_dbg.dbg_last_rxintrs = sc->tulip_dbg.dbg_rxintrs;
! 4314: #endif /* TULIP_DEBUG */
! 4315:
! 4316: sc->tulip_if.if_timer = 1;
! 4317: /*
! 4318: * These should be rare so do a bulk test up front so we can just skip
! 4319: * them if needed.
! 4320: */
! 4321: if (sc->tulip_flags & (TULIP_SYSTEMERROR|TULIP_RXBUFSLOW|TULIP_NOMESSAGES)) {
! 4322: /*
! 4323: * If the number of receive buffer is low, try to refill
! 4324: */
! 4325: if (sc->tulip_flags & TULIP_RXBUFSLOW)
! 4326: tulip_rx_intr(sc);
! 4327:
! 4328: #if defined(TULIP_DEBUG)
! 4329: if (sc->tulip_flags & TULIP_SYSTEMERROR) {
! 4330: printf(TULIP_PRINTF_FMT ": %d system errors: last was %s\n",
! 4331: TULIP_PRINTF_ARGS, sc->tulip_system_errors,
! 4332: tulip_system_errors[sc->tulip_last_system_error]);
! 4333: }
! 4334: #endif
! 4335: if (sc->tulip_statusbits) {
! 4336: tulip_print_abnormal_interrupt(sc, sc->tulip_statusbits);
! 4337: sc->tulip_statusbits = 0;
! 4338: }
! 4339:
! 4340: sc->tulip_flags &= ~(TULIP_NOMESSAGES|TULIP_SYSTEMERROR);
! 4341: }
! 4342:
! 4343: if (sc->tulip_txtimer)
! 4344: tulip_tx_intr(sc);
! 4345: if (sc->tulip_txtimer && --sc->tulip_txtimer == 0) {
! 4346: printf(TULIP_PRINTF_FMT ": transmission timeout\n", TULIP_PRINTF_ARGS);
! 4347: if (TULIP_DO_AUTOSENSE(sc)) {
! 4348: sc->tulip_media = TULIP_MEDIA_UNKNOWN;
! 4349: sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
! 4350: sc->tulip_flags &= ~(TULIP_WANTRXACT|TULIP_LINKUP);
! 4351: }
! 4352: tulip_reset(sc);
! 4353: tulip_init(sc);
! 4354: }
! 4355:
! 4356: TULIP_PERFEND(ifwatchdog);
! 4357: TULIP_PERFMERGE(sc, perf_intr_cycles);
! 4358: TULIP_PERFMERGE(sc, perf_ifstart_cycles);
! 4359: TULIP_PERFMERGE(sc, perf_ifioctl_cycles);
! 4360: TULIP_PERFMERGE(sc, perf_ifwatchdog_cycles);
! 4361: TULIP_PERFMERGE(sc, perf_timeout_cycles);
! 4362: TULIP_PERFMERGE(sc, perf_ifstart_one_cycles);
! 4363: TULIP_PERFMERGE(sc, perf_txput_cycles);
! 4364: TULIP_PERFMERGE(sc, perf_txintr_cycles);
! 4365: TULIP_PERFMERGE(sc, perf_rxintr_cycles);
! 4366: TULIP_PERFMERGE(sc, perf_rxget_cycles);
! 4367: TULIP_PERFMERGE(sc, perf_intr);
! 4368: TULIP_PERFMERGE(sc, perf_ifstart);
! 4369: TULIP_PERFMERGE(sc, perf_ifioctl);
! 4370: TULIP_PERFMERGE(sc, perf_ifwatchdog);
! 4371: TULIP_PERFMERGE(sc, perf_timeout);
! 4372: TULIP_PERFMERGE(sc, perf_ifstart_one);
! 4373: TULIP_PERFMERGE(sc, perf_txput);
! 4374: TULIP_PERFMERGE(sc, perf_txintr);
! 4375: TULIP_PERFMERGE(sc, perf_rxintr);
! 4376: TULIP_PERFMERGE(sc, perf_rxget);
! 4377: }
! 4378:
! 4379: /*
! 4380: * All printf's are real as of now!
! 4381: */
! 4382: #ifdef printf
! 4383: #undef printf
! 4384: #endif
! 4385:
! 4386: int
! 4387: tulip_busdma_allocmem(tulip_softc_t * const sc, size_t size,
! 4388: bus_dmamap_t *map_p, tulip_desc_t **desc_p)
! 4389: {
! 4390: bus_dma_segment_t segs[1];
! 4391: int nsegs, error;
! 4392: error = bus_dmamem_alloc(sc->tulip_dmatag, size, 1, PAGE_SIZE,
! 4393: segs, sizeof(segs)/sizeof(segs[0]),
! 4394: &nsegs, BUS_DMA_NOWAIT);
! 4395: if (error == 0) {
! 4396: void *desc;
! 4397: error = bus_dmamem_map(sc->tulip_dmatag, segs, nsegs, size,
! 4398: (void *) &desc, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
! 4399: if (error == 0) {
! 4400: bus_dmamap_t map;
! 4401: error = bus_dmamap_create(sc->tulip_dmatag, size, 1, size, 0,
! 4402: BUS_DMA_NOWAIT, &map);
! 4403: if (error == 0) {
! 4404: error = bus_dmamap_load(sc->tulip_dmatag, map, desc,
! 4405: size, NULL, BUS_DMA_NOWAIT);
! 4406: if (error)
! 4407: bus_dmamap_destroy(sc->tulip_dmatag, map);
! 4408: else
! 4409: *map_p = map;
! 4410: }
! 4411: if (error)
! 4412: bus_dmamem_unmap(sc->tulip_dmatag, desc, size);
! 4413: }
! 4414: if (error)
! 4415: bus_dmamem_free(sc->tulip_dmatag, segs, nsegs);
! 4416: else
! 4417: *desc_p = desc;
! 4418: }
! 4419: return (error);
! 4420: }
! 4421:
! 4422: int
! 4423: tulip_busdma_init(tulip_softc_t * const sc)
! 4424: {
! 4425: int error = 0;
! 4426:
! 4427: /*
! 4428: * Allocate dmamap for setup descriptor
! 4429: */
! 4430: error = bus_dmamap_create(sc->tulip_dmatag, sizeof(sc->tulip_setupbuf), 2,
! 4431: sizeof(sc->tulip_setupbuf), 0, BUS_DMA_NOWAIT,
! 4432: &sc->tulip_setupmap);
! 4433: if (error == 0) {
! 4434: error = bus_dmamap_load(sc->tulip_dmatag, sc->tulip_setupmap,
! 4435: sc->tulip_setupbuf, sizeof(sc->tulip_setupbuf),
! 4436: NULL, BUS_DMA_NOWAIT);
! 4437: if (error)
! 4438: bus_dmamap_destroy(sc->tulip_dmatag, sc->tulip_setupmap);
! 4439: }
! 4440: /*
! 4441: * Allocate space and dmamap for transmit ring
! 4442: */
! 4443: if (error == 0) {
! 4444: error = tulip_busdma_allocmem(sc, sizeof(tulip_desc_t) * TULIP_TXDESCS,
! 4445: &sc->tulip_txdescmap,
! 4446: &sc->tulip_txdescs);
! 4447: }
! 4448:
! 4449: /*
! 4450: * Allocate dmamaps for each transmit descriptors
! 4451: */
! 4452: if (error == 0) {
! 4453: while (error == 0 && sc->tulip_txmaps_free < TULIP_TXDESCS) {
! 4454: bus_dmamap_t map;
! 4455: if ((error = TULIP_TXMAP_CREATE(sc, &map)) == 0)
! 4456: sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
! 4457: }
! 4458: if (error) {
! 4459: while (sc->tulip_txmaps_free > 0)
! 4460: bus_dmamap_destroy(sc->tulip_dmatag,
! 4461: sc->tulip_txmaps[--sc->tulip_txmaps_free]);
! 4462: }
! 4463: }
! 4464:
! 4465: /*
! 4466: * Allocate space and dmamap for receive ring
! 4467: */
! 4468: if (error == 0) {
! 4469: error = tulip_busdma_allocmem(sc, sizeof(tulip_desc_t) * TULIP_RXDESCS,
! 4470: &sc->tulip_rxdescmap,
! 4471: &sc->tulip_rxdescs);
! 4472: }
! 4473:
! 4474: /*
! 4475: * Allocate dmamaps for each receive descriptors
! 4476: */
! 4477: if (error == 0) {
! 4478: while (error == 0 && sc->tulip_rxmaps_free < TULIP_RXDESCS) {
! 4479: bus_dmamap_t map;
! 4480: if ((error = TULIP_RXMAP_CREATE(sc, &map)) == 0)
! 4481: sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
! 4482: }
! 4483: if (error) {
! 4484: while (sc->tulip_rxmaps_free > 0)
! 4485: bus_dmamap_destroy(sc->tulip_dmatag,
! 4486: sc->tulip_rxmaps[--sc->tulip_rxmaps_free]);
! 4487: }
! 4488: }
! 4489: return (error);
! 4490: }
! 4491:
! 4492: void
! 4493: tulip_initcsrs(tulip_softc_t * const sc, bus_addr_t csr_base, size_t csr_size)
! 4494: {
! 4495: sc->tulip_csrs.csr_busmode = csr_base + 0 * csr_size;
! 4496: sc->tulip_csrs.csr_txpoll = csr_base + 1 * csr_size;
! 4497: sc->tulip_csrs.csr_rxpoll = csr_base + 2 * csr_size;
! 4498: sc->tulip_csrs.csr_rxlist = csr_base + 3 * csr_size;
! 4499: sc->tulip_csrs.csr_txlist = csr_base + 4 * csr_size;
! 4500: sc->tulip_csrs.csr_status = csr_base + 5 * csr_size;
! 4501: sc->tulip_csrs.csr_command = csr_base + 6 * csr_size;
! 4502: sc->tulip_csrs.csr_intr = csr_base + 7 * csr_size;
! 4503: sc->tulip_csrs.csr_missed_frames = csr_base + 8 * csr_size;
! 4504: sc->tulip_csrs.csr_9 = csr_base + 9 * csr_size;
! 4505: sc->tulip_csrs.csr_10 = csr_base + 10 * csr_size;
! 4506: sc->tulip_csrs.csr_11 = csr_base + 11 * csr_size;
! 4507: sc->tulip_csrs.csr_12 = csr_base + 12 * csr_size;
! 4508: sc->tulip_csrs.csr_13 = csr_base + 13 * csr_size;
! 4509: sc->tulip_csrs.csr_14 = csr_base + 14 * csr_size;
! 4510: sc->tulip_csrs.csr_15 = csr_base + 15 * csr_size;
! 4511: }
! 4512:
! 4513: void
! 4514: tulip_initring(tulip_softc_t * const sc, tulip_ringinfo_t * const ri,
! 4515: tulip_desc_t *descs, int ndescs)
! 4516: {
! 4517: ri->ri_max = ndescs;
! 4518: ri->ri_first = descs;
! 4519: ri->ri_last = ri->ri_first + ri->ri_max;
! 4520: bzero((caddr_t) ri->ri_first, sizeof(ri->ri_first[0]) * ri->ri_max);
! 4521: ri->ri_last[-1].d_flag = TULIP_DFLAG_ENDRING;
! 4522: }
! 4523:
! 4524: int
! 4525: tulip_probe(struct device *parent, void *match, void *aux)
! 4526: {
! 4527: struct pci_attach_args *pa = (struct pci_attach_args *) aux;
! 4528:
! 4529: if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
! 4530: return (0);
! 4531: if (PCI_CHIPID(pa->pa_id) == CHIPID_21040
! 4532: || PCI_CHIPID(pa->pa_id) == CHIPID_21041
! 4533: || PCI_CHIPID(pa->pa_id) == CHIPID_21140
! 4534: || PCI_CHIPID(pa->pa_id) == CHIPID_21142)
! 4535: return (2);
! 4536:
! 4537: return (0);
! 4538: }
! 4539:
! 4540: void
! 4541: tulip_shutdown(void *arg)
! 4542: {
! 4543: tulip_softc_t * const sc = arg;
! 4544: TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
! 4545: DELAY(10); /* Wait 10 microseconds (actually 50 PCI cycles but at
! 4546: 33MHz that comes to two microseconds but wait a
! 4547: bit longer anyways) */
! 4548: }
! 4549:
! 4550: void
! 4551: tulip_attach(struct device * const parent, struct device * const self, void * const aux)
! 4552: {
! 4553: tulip_softc_t * const sc = (tulip_softc_t *) self;
! 4554: struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
! 4555: struct ifnet * const ifp = &sc->tulip_if;
! 4556: const int unit = sc->tulip_dev.dv_unit;
! 4557: int retval, idx;
! 4558: u_int32_t revinfo, cfdainfo, id;
! 4559: unsigned csroffset = TULIP_PCI_CSROFFSET;
! 4560: unsigned csrsize = TULIP_PCI_CSRSIZE;
! 4561: bus_addr_t csr_base;
! 4562: tulip_chipid_t chipid = TULIP_CHIPID_UNKNOWN;
! 4563:
! 4564: if (unit >= TULIP_MAX_DEVICES) {
! 4565: printf(": not configured; limit of %d reached or exceeded\n",
! 4566: TULIP_MAX_DEVICES);
! 4567: return;
! 4568: }
! 4569:
! 4570: revinfo = PCI_CONF_READ(PCI_CFRV) & 0xFF;
! 4571: id = PCI_CONF_READ(PCI_CFID);
! 4572: cfdainfo = PCI_CONF_READ(PCI_CFDA);
! 4573:
! 4574: if (PCI_VENDORID(id) == DEC_VENDORID) {
! 4575: if (PCI_CHIPID(id) == CHIPID_21040)
! 4576: chipid = TULIP_21040;
! 4577: else if (PCI_CHIPID(id) == CHIPID_21041)
! 4578: chipid = TULIP_21041;
! 4579: else if (PCI_CHIPID(id) == CHIPID_21140)
! 4580: chipid = (revinfo >= 0x20) ? TULIP_21140A : TULIP_21140;
! 4581: else if (PCI_CHIPID(id) == CHIPID_21142)
! 4582: chipid = (revinfo >= 0x20) ? TULIP_21143 : TULIP_21142;
! 4583: }
! 4584:
! 4585: if (chipid == TULIP_CHIPID_UNKNOWN)
! 4586: return;
! 4587:
! 4588: if ((chipid == TULIP_21040 || chipid == TULIP_DE425) && revinfo < 0x20) {
! 4589: printf(": not configured; 21040 pass 2.0 required (%d.%d found)\n",
! 4590: revinfo >> 4, revinfo & 0x0f);
! 4591: return;
! 4592: } else if (chipid == TULIP_21140 && revinfo < 0x11) {
! 4593: printf(": not configured; 21140 pass 1.1 required (%d.%d found)\n",
! 4594: revinfo >> 4, revinfo & 0x0f);
! 4595: return;
! 4596: }
! 4597:
! 4598: PCI_GETBUSDEVINFO(sc);
! 4599: sc->tulip_chipid = chipid;
! 4600: sc->tulip_flags |= TULIP_DEVICEPROBE;
! 4601: if (chipid == TULIP_21140 || chipid == TULIP_21140A)
! 4602: sc->tulip_features |= TULIP_HAVE_GPR|TULIP_HAVE_STOREFWD;
! 4603: if (chipid == TULIP_21140A && revinfo <= 0x22)
! 4604: sc->tulip_features |= TULIP_HAVE_RXBADOVRFLW;
! 4605: if (chipid == TULIP_21140)
! 4606: sc->tulip_features |= TULIP_HAVE_BROKEN_HASH;
! 4607: if (chipid != TULIP_21040 && chipid != TULIP_DE425 && chipid != TULIP_21140)
! 4608: sc->tulip_features |= TULIP_HAVE_POWERMGMT;
! 4609: if (chipid == TULIP_21041 || chipid == TULIP_21142 || chipid == TULIP_21143) {
! 4610: sc->tulip_features |= TULIP_HAVE_DUALSENSE;
! 4611: if (chipid != TULIP_21041 || revinfo >= 0x20)
! 4612: sc->tulip_features |= TULIP_HAVE_SIANWAY;
! 4613: if (chipid != TULIP_21041)
! 4614: sc->tulip_features |= TULIP_HAVE_SIAGP|TULIP_HAVE_RXBADOVRFLW|TULIP_HAVE_STOREFWD;
! 4615: if (chipid != TULIP_21041 && revinfo >= 0x20)
! 4616: sc->tulip_features |= TULIP_HAVE_SIA100;
! 4617: }
! 4618:
! 4619: if (sc->tulip_features & TULIP_HAVE_POWERMGMT
! 4620: && (cfdainfo & (TULIP_CFDA_SLEEP|TULIP_CFDA_SNOOZE))) {
! 4621: cfdainfo &= ~(TULIP_CFDA_SLEEP|TULIP_CFDA_SNOOZE);
! 4622: PCI_CONF_WRITE(PCI_CFDA, cfdainfo);
! 4623: DELAY(11*1000);
! 4624: }
! 4625:
! 4626: if (sc->tulip_features & TULIP_HAVE_STOREFWD)
! 4627: sc->tulip_cmdmode |= TULIP_CMD_STOREFWD;
! 4628:
! 4629: bcopy(self->dv_xname, sc->tulip_if.if_xname, IFNAMSIZ);
! 4630: sc->tulip_if.if_softc = sc;
! 4631: sc->tulip_pc = pa->pa_pc;
! 4632: sc->tulip_dmatag = pa->pa_dmat;
! 4633: sc->tulip_revinfo = revinfo;
! 4634:
! 4635: timeout_set(&sc->tulip_stmo, tulip_timeout_callback, sc);
! 4636:
! 4637: csr_base = 0;
! 4638: {
! 4639: bus_space_tag_t iot, memt;
! 4640: bus_space_handle_t ioh, memh;
! 4641: int ioh_valid, memh_valid;
! 4642:
! 4643: ioh_valid = (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
! 4644: &iot, &ioh, NULL, NULL, 0) == 0);
! 4645: memh_valid = (pci_mapreg_map(pa, PCI_CBMA,
! 4646: PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT, 0,
! 4647: &memt, &memh, NULL, NULL, 0) == 0);
! 4648:
! 4649: if (memh_valid) {
! 4650: sc->tulip_bustag = memt;
! 4651: sc->tulip_bushandle = memh;
! 4652: } else if (ioh_valid) {
! 4653: sc->tulip_bustag = iot;
! 4654: sc->tulip_bushandle = ioh;
! 4655: } else {
! 4656: printf(": unable to map device registers\n");
! 4657: return;
! 4658: }
! 4659: }
! 4660:
! 4661: tulip_initcsrs(sc, csr_base + csroffset, csrsize);
! 4662:
! 4663: if ((retval = tulip_busdma_init(sc)) != 0) {
! 4664: printf(": error initing bus_dma: %d\n", retval);
! 4665: return;
! 4666: }
! 4667:
! 4668: tulip_initring(sc, &sc->tulip_rxinfo, sc->tulip_rxdescs, TULIP_RXDESCS);
! 4669: tulip_initring(sc, &sc->tulip_txinfo, sc->tulip_txdescs, TULIP_TXDESCS);
! 4670:
! 4671: /*
! 4672: * Make sure there won't be any interrupts or such...
! 4673: */
! 4674: TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
! 4675: DELAY(100); /* Wait 10 microseconds (actually 50 PCI cycles but at
! 4676: 33MHz that comes to two microseconds but wait a
! 4677: bit longer anyways) */
! 4678:
! 4679: if ((retval = tulip_read_macaddr(sc)) < 0) {
! 4680: printf(", %s%s pass %d.%d", sc->tulip_boardid,
! 4681: tulip_chipdescs[sc->tulip_chipid],
! 4682: (sc->tulip_revinfo & 0xF0) >> 4, sc->tulip_revinfo & 0x0F);
! 4683: printf(": can't read ENET ROM (why=%d) (", retval);
! 4684: for (idx = 0; idx < 32; idx++)
! 4685: printf("%02x", sc->tulip_rombuf[idx]);
! 4686: printf(", address unknown\n");
! 4687: } else {
! 4688: int (*intr_rtn)(void *) = tulip_intr_normal;
! 4689:
! 4690: if (sc->tulip_features & TULIP_HAVE_SHAREDINTR)
! 4691: intr_rtn = tulip_intr_shared;
! 4692:
! 4693: if ((sc->tulip_features & TULIP_HAVE_SLAVEDINTR) == 0) {
! 4694: pci_intr_handle_t intrhandle;
! 4695: const char *intrstr;
! 4696:
! 4697: if (pci_intr_map(pa, &intrhandle)) {
! 4698: printf(": couldn't map interrupt\n");
! 4699: return;
! 4700: }
! 4701:
! 4702: intrstr = pci_intr_string(pa->pa_pc, intrhandle);
! 4703: sc->tulip_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET,
! 4704: intr_rtn, sc, self->dv_xname);
! 4705: if (sc->tulip_ih == NULL) {
! 4706: printf(": couldn't establish interrupt");
! 4707: if (intrstr != NULL)
! 4708: printf(" at %s", intrstr);
! 4709: printf("\n");
! 4710: return;
! 4711: }
! 4712:
! 4713: printf(", %s%s pass %d.%d%s: %s, address %s\n",
! 4714: sc->tulip_boardid,
! 4715: tulip_chipdescs[sc->tulip_chipid],
! 4716: (sc->tulip_revinfo & 0xF0) >> 4,
! 4717: sc->tulip_revinfo & 0x0F,
! 4718: (sc->tulip_features & (TULIP_HAVE_ISVSROM|TULIP_HAVE_OKSROM))
! 4719: == TULIP_HAVE_ISVSROM ? " (invalid EESPROM checksum)" : "",
! 4720: intrstr, ether_sprintf(sc->tulip_enaddr));
! 4721: }
! 4722:
! 4723: sc->tulip_ats = shutdownhook_establish(tulip_shutdown, sc);
! 4724: if (sc->tulip_ats == NULL)
! 4725: printf("%s: warning: couldn't establish shutdown hook\n",
! 4726: sc->tulip_xname);
! 4727:
! 4728: ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_NOTRAILERS|IFF_MULTICAST;
! 4729: ifp->if_ioctl = tulip_ifioctl;
! 4730: ifp->if_start = tulip_ifstart;
! 4731: ifp->if_watchdog = tulip_ifwatchdog;
! 4732: ifp->if_timer = 1;
! 4733:
! 4734: (*sc->tulip_boardsw->bd_media_probe)(sc);
! 4735: ifmedia_init(&sc->tulip_ifmedia, 0,
! 4736: tulip_ifmedia_change, tulip_ifmedia_status);
! 4737: sc->tulip_flags &= ~TULIP_DEVICEPROBE;
! 4738: tulip_ifmedia_add(sc);
! 4739:
! 4740: tulip_reset(sc);
! 4741:
! 4742: IFQ_SET_READY(&ifp->if_snd);
! 4743: if_attach(ifp);
! 4744: ether_ifattach(ifp);
! 4745: }
! 4746: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_de.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci