if_mx.c

来自「基于组件方式开发操作系统的OSKIT源代码」· C语言 代码 · 共 2,495 行 · 第 1/4 页

	return;
}

static void mx_intr(arg)
	void			*arg;
{
	struct mx_softc		*sc;
	struct ifnet		*ifp;
	u_int32_t		status;

	sc = arg;
	ifp = &sc->arpcom.ac_if;

	/* Supress unwanted interrupts */
	if (!(ifp->if_flags & IFF_UP)) {
		mx_stop(sc);
		return;
	}

	/* Disable interrupts. */
	CSR_WRITE_4(sc, MX_IMR, 0x00000000);

	for (;;) {
		status = CSR_READ_4(sc, MX_ISR);
		if (status)
			CSR_WRITE_4(sc, MX_ISR, status);

		if ((status & MX_INTRS) == 0)
			break;

		if (status & MX_ISR_TX_OK)
			mx_txeof(sc);

		if (status & MX_ISR_TX_NOBUF)
			mx_txeoc(sc);

		if (status & MX_ISR_TX_IDLE) {
			mx_txeof(sc);
			if (sc->mx_cdata.mx_tx_head != NULL) {
				MX_SETBIT(sc, MX_NETCFG, MX_NETCFG_TX_ON);
				CSR_WRITE_4(sc, MX_TXSTART, 0xFFFFFFFF);
			}
		}

		if (status & MX_ISR_TX_UNDERRUN) {
			u_int32_t		cfg;
			cfg = CSR_READ_4(sc, MX_NETCFG);
			if ((cfg & MX_NETCFG_TX_THRESH) == MX_TXTHRESH_160BYTES)
				MX_SETBIT(sc, MX_NETCFG, MX_NETCFG_STORENFWD);
			else
				CSR_WRITE_4(sc, MX_NETCFG, cfg + 0x4000);
		}

		if (status & MX_ISR_RX_OK)
			mx_rxeof(sc);

		if ((status & MX_ISR_RX_WATDOGTIMEO)
					|| (status & MX_ISR_RX_NOBUF))
			mx_rxeoc(sc);

		if (status & MX_ISR_BUS_ERR) {
			mx_reset(sc);
			mx_init(sc);
		}
	}

	/* Re-enable interrupts. */
	CSR_WRITE_4(sc, MX_IMR, MX_INTRS);

	if (ifp->if_snd.ifq_head != NULL) {
		mx_start(ifp);
	}

	return;
}

/*
 * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
 * pointers to the fragment pointers.
 */
static int mx_encap(sc, c, m_head)
	struct mx_softc		*sc;
	struct mx_chain		*c;
	struct mbuf		*m_head;
{
	int			frag = 0;
	struct mx_desc		*f = NULL;
	int			total_len;
	struct mbuf		*m;

	/*
 	 * Start packing the mbufs in this chain into
	 * the fragment pointers. Stop when we run out
 	 * of fragments or hit the end of the mbuf chain.
	 */
	m = m_head;
	total_len = 0;

	for (m = m_head, frag = 0; m != NULL; m = m->m_next) {
		if (m->m_len != 0) {
			if (frag == MX_MAXFRAGS)
				break;
			total_len += m->m_len;
			f = &c->mx_ptr->mx_frag[frag];
			f->mx_ctl = MX_TXCTL_TLINK | m->m_len;
			if (frag == 0) {
				f->mx_status = 0;
				f->mx_ctl |= MX_TXCTL_FIRSTFRAG;
			} else
				f->mx_status = MX_TXSTAT_OWN;
			f->mx_next = vtophys(&c->mx_ptr->mx_frag[frag + 1]);
			f->mx_data = vtophys(mtod(m, vm_offset_t));
			frag++;
		}
	}

	/*
	 * Handle special case: we ran out of fragments,
	 * but we have more mbufs left in the chain. Copy the
	 * data into an mbuf cluster. Note that we don't
	 * bother clearing the values in the other fragment
	 * pointers/counters; it wouldn't gain us anything,
	 * and would waste cycles.
	 */
	if (m != NULL) {
		struct mbuf		*m_new = NULL;

		MGETHDR(m_new, M_DONTWAIT, MT_DATA);
		if (m_new == NULL) {
			printf("mx%d: no memory for tx list", sc->mx_unit);
			return(1);
		}
		if (m_head->m_pkthdr.len > MHLEN) {
			MCLGET(m_new, M_DONTWAIT);
			if (!(m_new->m_flags & M_EXT)) {
				m_freem(m_new);
				printf("mx%d: no memory for tx list",
						sc->mx_unit);
				return(1);
			}
		}
		m_copydata(m_head, 0, m_head->m_pkthdr.len,	
					mtod(m_new, caddr_t));
		m_new->m_pkthdr.len = m_new->m_len = m_head->m_pkthdr.len;
		m_freem(m_head);
		m_head = m_new;
		f = &c->mx_ptr->mx_frag[0];
		f->mx_status = 0;
		f->mx_data = vtophys(mtod(m_new, caddr_t));
		f->mx_ctl = total_len = m_new->m_len;
		f->mx_ctl |= MX_TXCTL_TLINK|MX_TXCTL_FIRSTFRAG;
		frag = 1;
	}


	if (total_len < MX_MIN_FRAMELEN) {
		f = &c->mx_ptr->mx_frag[frag];
		f->mx_ctl = MX_MIN_FRAMELEN - total_len;
		f->mx_data = vtophys(&sc->mx_cdata.mx_pad);
		f->mx_ctl |= MX_TXCTL_TLINK;
		f->mx_status = MX_TXSTAT_OWN;
		frag++;
	}

	c->mx_mbuf = m_head;
	c->mx_lastdesc = frag - 1;
	MX_TXCTL(c) |= MX_TXCTL_LASTFRAG|MX_TXCTL_FINT;
	MX_TXNEXT(c) = vtophys(&c->mx_nextdesc->mx_ptr->mx_frag[0]);
	return(0);
}

/*
 * Main transmit routine. To avoid having to do mbuf copies, we put pointers
 * to the mbuf data regions directly in the transmit lists. We also save a
 * copy of the pointers since the transmit list fragment pointers are
 * physical addresses.
 */

static void mx_start(ifp)
	struct ifnet		*ifp;
{
	struct mx_softc		*sc;
	struct mbuf		*m_head = NULL;
	struct mx_chain		*cur_tx = NULL, *start_tx;

	sc = ifp->if_softc;

	if (sc->mx_autoneg) {
		sc->mx_tx_pend = 1;
		return;
	}

	if (ifp->if_flags & IFF_OACTIVE)
		return;

	/*
	 * Check for an available queue slot. If there are none,
	 * punt.
	 */
	if (sc->mx_cdata.mx_tx_free->mx_mbuf != NULL) {
		ifp->if_flags |= IFF_OACTIVE;
		return;
	}

	start_tx = sc->mx_cdata.mx_tx_free;

	while(sc->mx_cdata.mx_tx_free->mx_mbuf == NULL) {
		IF_DEQUEUE(&ifp->if_snd, m_head);
		if (m_head == NULL)
			break;

		/* Pick a descriptor off the free list. */
		cur_tx = sc->mx_cdata.mx_tx_free;
		sc->mx_cdata.mx_tx_free = cur_tx->mx_nextdesc;

		/* Pack the data into the descriptor. */
		mx_encap(sc, cur_tx, m_head);
		if (cur_tx != start_tx)
			MX_TXOWN(cur_tx) = MX_TXSTAT_OWN;

#if NBPFILTER > 0
		/*
		 * If there's a BPF listener, bounce a copy of this frame
		 * to him.
		 */
		if (ifp->if_bpf)
			bpf_mtap(ifp, cur_tx->mx_mbuf);
#endif
		MX_TXOWN(cur_tx) = MX_TXSTAT_OWN;
		CSR_WRITE_4(sc, MX_TXSTART, 0xFFFFFFFF);

	}

	/*
	 * If there are no frames queued, bail.
	 */
	if (cur_tx == NULL)
		return;

	sc->mx_cdata.mx_tx_tail = cur_tx;

	if (sc->mx_cdata.mx_tx_head == NULL)
		sc->mx_cdata.mx_tx_head = start_tx;

	/*
	 * Set a timeout in case the chip goes out to lunch.
	 */
	ifp->if_timer = 5;

	return;
}

static void mx_init(xsc)
	void			*xsc;
{
	struct mx_softc		*sc = xsc;
	struct ifnet		*ifp = &sc->arpcom.ac_if;
	u_int16_t		phy_bmcr = 0;
	int			s;

	if (sc->mx_autoneg)
		return;

	s = splimp();

	if (sc->mx_pinfo != NULL)
		phy_bmcr = mx_phy_readreg(sc, PHY_BMCR);

	/*
	 * Cancel pending I/O and free all RX/TX buffers.
	 */
	mx_stop(sc);
	mx_reset(sc);

	/*
	 * Set cache alignment and burst length.
	 */
	CSR_WRITE_4(sc, MX_BUSCTL, MX_BUSCTL_MUSTBEONE|MX_BUSCTL_ARBITRATION);
	MX_SETBIT(sc, MX_BUSCTL, MX_BURSTLEN_16LONG);
	switch(sc->mx_cachesize) {
	case 32:
		MX_SETBIT(sc, MX_BUSCTL, MX_CACHEALIGN_32LONG);
		break;
	case 16:
		MX_SETBIT(sc, MX_BUSCTL, MX_CACHEALIGN_16LONG);
		break; 
	case 8:
		MX_SETBIT(sc, MX_BUSCTL, MX_CACHEALIGN_8LONG);
		break;  
	case 0:
	default:
		MX_SETBIT(sc, MX_BUSCTL, MX_CACHEALIGN_NONE);
		break;
	}

	MX_SETBIT(sc, MX_NETCFG, MX_NETCFG_NO_RXCRC);
	MX_CLRBIT(sc, MX_NETCFG, MX_NETCFG_HEARTBEAT);
	MX_SETBIT(sc, MX_NETCFG, MX_NETCFG_STORENFWD);
	MX_CLRBIT(sc, MX_NETCFG, MX_NETCFG_TX_BACKOFF);

	/*
	 * The app notes for the 98713 and 98715A say that
	 * in order to have the chips operate properly, a magic
	 * number must be written to CSR16. Macronix does not
	 * document the meaning of these bits so there's no way
	 * to know exactly what they mean. The 98713 has a magic
	 * number all its own; the rest all use a different one.
	 */
	MX_CLRBIT(sc, MX_MAGICPACKET, 0xFFFF0000);
	if (sc->mx_type == MX_TYPE_98713)
		MX_SETBIT(sc, MX_MAGICPACKET, MX_MAGIC_98713);
	else
		MX_SETBIT(sc, MX_MAGICPACKET, MX_MAGIC_98715);

	if (sc->mx_pinfo != NULL) {
		MX_SETBIT(sc, MX_WATCHDOG, MX_WDOG_JABBERDIS);
		mx_setcfg(sc, mx_phy_readreg(sc, PHY_BMCR));
	} else
		mx_setmode(sc, sc->ifmedia.ifm_media, 0);

	MX_CLRBIT(sc, MX_NETCFG, MX_NETCFG_TX_THRESH);
	/*MX_CLRBIT(sc, MX_NETCFG, MX_NETCFG_SPEEDSEL);*/

	if (IFM_SUBTYPE(sc->ifmedia.ifm_media) == IFM_10_T)
		MX_SETBIT(sc, MX_NETCFG, MX_TXTHRESH_160BYTES);
	else
		MX_SETBIT(sc, MX_NETCFG, MX_TXTHRESH_72BYTES);

	/* Init circular RX list. */
	if (mx_list_rx_init(sc) == ENOBUFS) {
		printf("mx%d: initialization failed: no "
			"memory for rx buffers\n", sc->mx_unit);
		mx_stop(sc);
		(void)splx(s);
		return;
	}

	/*
	 * Init tx descriptors.
	 */
	mx_list_tx_init(sc);

	/*
	 * Load the address of the RX list.
	 */
	CSR_WRITE_4(sc, MX_RXADDR, vtophys(sc->mx_cdata.mx_rx_head->mx_ptr));

	/*
	 * Load the RX/multicast filter.
	 */
	mx_setfilt(sc);

	/*
	 * Enable interrupts.
	 */
	CSR_WRITE_4(sc, MX_IMR, MX_INTRS);
	CSR_WRITE_4(sc, MX_ISR, 0xFFFFFFFF);

	/* Enable receiver and transmitter. */
	MX_SETBIT(sc, MX_NETCFG, MX_NETCFG_TX_ON|MX_NETCFG_RX_ON);
	CSR_WRITE_4(sc, MX_RXSTART, 0xFFFFFFFF);

	/* Restore state of BMCR */
	if (sc->mx_pinfo != NULL)
		mx_phy_writereg(sc, PHY_BMCR, phy_bmcr);

	ifp->if_flags |= IFF_RUNNING;
	ifp->if_flags &= ~IFF_OACTIVE;

	(void)splx(s);

	return;
}

/*
 * Set media options.
 */
static int mx_ifmedia_upd(ifp)
	struct ifnet		*ifp;
{
	struct mx_softc		*sc;
	struct ifmedia		*ifm;

	sc = ifp->if_softc;
	ifm = &sc->ifmedia;

	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
		return(EINVAL);

	if (sc->mx_type == MX_TYPE_98713 && sc->mx_pinfo != NULL) {
		if (IFM_SUBTYPE(ifm->ifm_media) == IFM_AUTO)
			mx_autoneg_mii(sc, MX_FLAG_SCHEDDELAY, 1);
		else
			mx_setmode_mii(sc, ifm->ifm_media);
	} else {
		if (IFM_SUBTYPE(ifm->ifm_media) == IFM_AUTO)
			mx_autoneg(sc, MX_FLAG_SCHEDDELAY, 1);
		else
			mx_setmode(sc, ifm->ifm_media, 1);
	}

	return(0);
}

/*
 * Report current media status.
 */
static void mx_ifmedia_sts(ifp, ifmr)
	struct ifnet		*ifp;
	struct ifmediareq	*ifmr;
{
	struct mx_softc		*sc;
	u_int16_t		advert = 0, ability = 0;
	u_int32_t		media = 0;

	sc = ifp->if_softc;

	ifmr->ifm_active = IFM_ETHER;

	if (sc->mx_type != MX_TYPE_98713 || sc->mx_pinfo == NULL) {
		media = CSR_READ_4(sc, MX_NETCFG);
		if (media & MX_NETCFG_PORTSEL)
			ifmr->ifm_active = IFM_ETHER|IFM_100_TX;
		else
			ifmr->ifm_active = IFM_ETHER|IFM_10_T;
		if (media & MX_NETCFG_FULLDUPLEX)
			ifmr->ifm_active |= IFM_FDX;
		else
			ifmr->ifm_active |= IFM_HDX;
		return;
	}

	if (!(mx_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_AUTONEGENBL)) {
		if (mx_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_SPEEDSEL)
			ifmr->ifm_active = IFM_ETHER|IFM_100_TX;
		else
			ifmr->ifm_active = IFM_ETHER|IFM_10_T;
		if (mx_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_DUPLEX)
			ifmr->ifm_active |= IFM_FDX;
		else
			ifmr->ifm_active |= IFM_HDX;
		return;
	}

	ability = mx_phy_readreg(sc, PHY_LPAR);
	advert = mx_phy_readreg(sc, PHY_ANAR);
	if (advert & PHY_ANAR_100BT4 &&
		ability & PHY_ANAR_100BT4) {
		ifmr->ifm_active = IFM_ETHER|IFM_100_T4;
	} else if (advert & PHY_ANAR_100BTXFULL &&
		ability & PHY_ANAR_100BTXFULL) {
		ifmr->ifm_active = IFM_ETHER|IFM_100_TX|IFM_FDX;
	} else if (advert & PHY_ANAR_100BTXHALF &&
		ability & PHY_ANAR_100BTXHALF) {
		ifmr->ifm_active = IFM_ETHER|IFM_100_TX|IFM_HDX;
	} else if (advert & PHY_ANAR_10BTFULL &&
		ability & PHY_ANAR_10BTFULL) {
		ifmr->ifm_active = IFM_ETHER|IFM_10_T|IFM_FDX;
	} else if (advert & PHY_ANAR_10BTHALF &&
		ability & PHY_ANAR_10BTHALF) {
		ifmr->ifm_active = IFM_ETHER|IFM_10_T|IFM_HDX;
	}

	return;
}

static int mx_ioctl(ifp, command, data)
	struct ifnet		*ifp;
	u_long			command;
	caddr_t			data;
{
	struct mx_softc		*sc = ifp->if_softc;
	struct ifreq		*ifr = (struct ifreq *) data;
	int			s, error = 0;

	s = splimp();

	switch(command) {
	case SIOCSIFADDR:
	case SIOCGIFADDR:
	case SIOCSIFMTU:
		error = ether_ioctl(ifp, command, data);
		break;
	case SIOCSIFFLAGS:
		if (ifp->if_flags & IFF_UP) {
			mx_init(sc);
		} else {
			if (ifp->if_flags & IFF_RUNNING)
				mx_stop(sc);
		}
		error = 0;
		break;
	case SIOCADDMULTI:
	case SIOCDELMULTI:
		mx_init(sc);
		error = 0;
		break;
	case SIOCGIFMEDIA:
	case SIOCSIFMEDIA:
		error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
		break;
	default:
		error = EINVAL;
		break;
	}

	(void)splx(s);

	return(error);
}

static void mx_watchdog(ifp)
	struct ifnet		*ifp;
{
	struct mx_softc		*sc;

	sc = ifp->if_softc;

	if (sc->mx_autoneg) {
		if (sc->mx_type == MX_TYPE_98713 && sc->mx_pinfo != NULL)
			mx_autoneg_mii(sc, MX_FLAG_DELAYTIMEO, 1);
		else
			mx_autoneg(sc, MX_FLAG_DELAYTIMEO, 1);
		return;
	}

	ifp->if_oerrors++;
	printf("mx%d: watchdog timeout\n", sc->mx_unit);

	if (sc->mx_pinfo == NULL) {
		if (!(CSR_READ_4(sc, MX_10BTSTAT) & MX_TSTAT_LS10) ||
			!(CSR_READ_4(sc, MX_10BTSTAT) & MX_TSTAT_LS100))
			printf("mx%d: no carrier - transceiver "
				"cable problem?\n", sc->mx_unit);
	} else {
		if (!(mx_phy_readreg(sc, PHY_BMSR) & PHY_BMSR_LINKSTAT))
			printf("mx%d: no carrier - transceiver "
				"cable problem?\n", sc->mx_unit);
	}

	mx_stop(sc);
	mx_reset(sc);
	mx_init(sc);

	if (ifp->if_snd.ifq_head != NULL)
		mx_start(ifp);

	return;
}

/*
 * Stop the adapter and free any mbufs allocated to the
 * RX and TX lists.
 */
static void mx_stop(sc)
	struct mx_softc		*sc;
{
	register int		i;
	struct ifnet		*ifp;

	ifp = &sc->arpcom.ac_if;
	ifp->if_timer = 0;

	MX_CLRBIT(sc, MX_NETCFG, (MX_NETCFG_RX_ON|MX_NETCFG_TX_ON));
	CSR_WRITE_4(sc, MX_IMR, 0x00000000);
	CSR_WRITE_4(sc, MX_TXADDR, 0x00000000);
	CSR_WRITE_4(sc, MX_RXADDR, 0x00000000);

	/*
	 * Free data in the RX lists.
	 */
	for (i = 0; i < MX_RX_LIST_CNT; i++) {
		if (sc->mx_cdata.mx_rx_chain[i].mx_mbuf != NULL) {
			m_freem(sc->mx_cdata.mx_rx_chain[i].mx_mbuf);
			sc->mx_cdata.mx_rx_chain[i].mx_mbuf = NULL;
		}
	}
	bzero((char *)&sc->mx_ldata->mx_rx_list,
		sizeof(sc->mx_ldata->mx_rx_list));

	/*
	 * Free the TX list buffers.
	 */
	for (i = 0; i < MX_TX_LIST_CNT; i++) {
		if (sc->mx_cdata.mx_tx_chain[i].mx_mbuf != NULL) {
			m_freem(sc->mx_cdata.mx_tx_chain[i].mx_mbuf);
			sc->mx_cdata.mx_tx_chain[i].mx_mbuf = NULL;
		}
	}

	bzero((char *)&sc->mx_ldata->mx_tx_list,
		sizeof(sc->mx_ldata->mx_tx_list));

	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);

	return;
}

/*
 * Stop all chip I/O so that the kernel's probe routines don't
 * get confused by errant DMAs when rebooting.
 */
static void mx_shutdown(howto, arg)
	int			howto;
	void			*arg;
{
	struct mx_softc		*sc = (struct mx_softc *)arg;

	mx_stop(sc);

	return;
}

static struct pci_device mx_device = {
	"mx",
	mx_probe,
	mx_attach,
	&mx_count,
	NULL
};
DATA_SET(pcidevice_set, mx_device);