2005-01-07 02:29:27 +00:00
|
|
|
/*-
|
2017-11-18 14:26:50 +00:00
|
|
|
* SPDX-License-Identifier: BSD-4-Clause
|
|
|
|
*
|
2005-01-05 22:23:03 +00:00
|
|
|
* Copyright (c) 2005 Poul-Henning Kamp <phk@FreeBSD.org>
|
1999-09-05 21:01:03 +00:00
|
|
|
* Copyright (c) 1997, 1998, 1999
|
|
|
|
* Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by Bill Paul.
|
|
|
|
* 4. Neither the name of the author nor the names of any co-contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
|
|
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2003-11-14 17:16:58 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* SiS 900/SiS 7016 fast ethernet PCI NIC driver. Datasheets are
|
|
|
|
* available from http://www.sis.com.tw.
|
|
|
|
*
|
2000-08-22 23:26:51 +00:00
|
|
|
* This driver also supports the NatSemi DP83815. Datasheets are
|
|
|
|
* available from http://www.national.com.
|
|
|
|
*
|
1999-09-05 21:01:03 +00:00
|
|
|
* Written by Bill Paul <wpaul@ee.columbia.edu>
|
|
|
|
* Electrical Engineering Department
|
|
|
|
* Columbia University, New York City
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The SiS 900 is a fairly simple chip. It uses bus master DMA with
|
|
|
|
* simple TX and RX descriptors of 3 longwords in size. The receiver
|
|
|
|
* has a single perfect filter entry for the station address and a
|
|
|
|
* 128-bit multicast hash table. The SiS 900 has a built-in MII-based
|
|
|
|
* transceiver while the 7016 requires an external transceiver chip.
|
|
|
|
* Both chips offer the standard bit-bang MII interface as well as
|
|
|
|
* an enchanced PHY interface which simplifies accessing MII registers.
|
|
|
|
*
|
|
|
|
* The only downside to this chipset is that RX descriptors must be
|
|
|
|
* longword aligned.
|
|
|
|
*/
|
|
|
|
|
2005-10-05 10:09:17 +00:00
|
|
|
#ifdef HAVE_KERNEL_OPTION_HEADERS
|
|
|
|
#include "opt_device_polling.h"
|
|
|
|
#endif
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2010-09-01 19:33:40 +00:00
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/endian.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
#include <sys/kernel.h>
|
2010-09-01 19:33:40 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
2004-05-30 17:57:46 +00:00
|
|
|
#include <sys/module.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
#include <sys/socket.h>
|
2010-09-01 19:33:40 +00:00
|
|
|
#include <sys/sockio.h>
|
2010-09-02 18:10:11 +00:00
|
|
|
#include <sys/sysctl.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
2013-10-26 17:58:36 +00:00
|
|
|
#include <net/if_var.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
#include <net/if_arp.h>
|
|
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_media.h>
|
2001-12-05 09:34:28 +00:00
|
|
|
#include <net/if_types.h>
|
|
|
|
#include <net/if_vlan_var.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
#include <net/bpf.h>
|
|
|
|
|
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <machine/resource.h>
|
|
|
|
#include <sys/rman.h>
|
|
|
|
|
|
|
|
#include <dev/mii/mii.h>
|
2011-11-01 16:13:59 +00:00
|
|
|
#include <dev/mii/mii_bitbang.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
#include <dev/mii/miivar.h>
|
|
|
|
|
2003-08-22 07:20:27 +00:00
|
|
|
#include <dev/pci/pcireg.h>
|
|
|
|
#include <dev/pci/pcivar.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
#define SIS_USEIOSPACE
|
|
|
|
|
2008-08-10 10:00:14 +00:00
|
|
|
#include <dev/sis/if_sisreg.h>
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-04-15 06:37:30 +00:00
|
|
|
MODULE_DEPEND(sis, pci, 1, 1, 1);
|
|
|
|
MODULE_DEPEND(sis, ether, 1, 1, 1);
|
2000-04-29 13:41:57 +00:00
|
|
|
MODULE_DEPEND(sis, miibus, 1, 1, 1);
|
|
|
|
|
2005-10-22 05:06:55 +00:00
|
|
|
/* "device miibus" required. See GENERIC if you get errors here. */
|
1999-09-05 21:01:03 +00:00
|
|
|
#include "miibus_if.h"
|
|
|
|
|
2005-09-20 09:52:53 +00:00
|
|
|
#define SIS_LOCK(_sc) mtx_lock(&(_sc)->sis_mtx)
|
|
|
|
#define SIS_UNLOCK(_sc) mtx_unlock(&(_sc)->sis_mtx)
|
|
|
|
#define SIS_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->sis_mtx, MA_OWNED)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* register space access macros
|
|
|
|
*/
|
2005-09-24 20:46:02 +00:00
|
|
|
#define CSR_WRITE_4(sc, reg, val) bus_write_4(sc->sis_res[0], reg, val)
|
2005-09-20 09:52:53 +00:00
|
|
|
|
2005-09-24 20:46:02 +00:00
|
|
|
#define CSR_READ_4(sc, reg) bus_read_4(sc->sis_res[0], reg)
|
2005-09-20 09:52:53 +00:00
|
|
|
|
2005-09-24 20:46:02 +00:00
|
|
|
#define CSR_READ_2(sc, reg) bus_read_2(sc->sis_res[0], reg)
|
2005-09-20 09:52:53 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
#define CSR_BARRIER(sc, reg, length, flags) \
|
|
|
|
bus_barrier(sc->sis_res[0], reg, length, flags)
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Various supported device vendors/types and their names.
|
|
|
|
*/
|
2012-11-05 19:16:27 +00:00
|
|
|
static const struct sis_type sis_devs[] = {
|
1999-09-05 21:01:03 +00:00
|
|
|
{ SIS_VENDORID, SIS_DEVICEID_900, "SiS 900 10/100BaseTX" },
|
|
|
|
{ SIS_VENDORID, SIS_DEVICEID_7016, "SiS 7016 10/100BaseTX" },
|
2003-09-03 07:40:04 +00:00
|
|
|
{ NS_VENDORID, NS_DEVICEID_DP83815, "NatSemi DP8381[56] 10/100BaseTX" },
|
1999-09-05 21:01:03 +00:00
|
|
|
{ 0, 0, NULL }
|
|
|
|
};
|
|
|
|
|
2005-01-06 23:26:13 +00:00
|
|
|
static int sis_detach(device_t);
|
2010-09-01 19:33:40 +00:00
|
|
|
static __inline void sis_discard_rxbuf(struct sis_rxdesc *);
|
|
|
|
static int sis_dma_alloc(struct sis_softc *);
|
|
|
|
static void sis_dma_free(struct sis_softc *);
|
|
|
|
static int sis_dma_ring_alloc(struct sis_softc *, bus_size_t, bus_size_t,
|
|
|
|
bus_dma_tag_t *, uint8_t **, bus_dmamap_t *, bus_addr_t *, const char *);
|
|
|
|
static void sis_dmamap_cb(void *, bus_dma_segment_t *, int, int);
|
|
|
|
#ifndef __NO_STRICT_ALIGNMENT
|
|
|
|
static __inline void sis_fixup_rx(struct mbuf *);
|
|
|
|
#endif
|
2022-08-17 20:41:35 +00:00
|
|
|
static void sis_ifmedia_sts(if_t, struct ifmediareq *);
|
|
|
|
static int sis_ifmedia_upd(if_t);
|
2005-01-06 23:26:13 +00:00
|
|
|
static void sis_init(void *);
|
|
|
|
static void sis_initl(struct sis_softc *);
|
|
|
|
static void sis_intr(void *);
|
2022-08-17 20:41:35 +00:00
|
|
|
static int sis_ioctl(if_t, u_long, caddr_t);
|
2011-11-01 16:13:59 +00:00
|
|
|
static uint32_t sis_mii_bitbang_read(device_t);
|
|
|
|
static void sis_mii_bitbang_write(device_t, uint32_t);
|
2010-09-01 19:33:40 +00:00
|
|
|
static int sis_newbuf(struct sis_softc *, struct sis_rxdesc *);
|
2010-09-03 00:34:45 +00:00
|
|
|
static int sis_resume(device_t);
|
2010-09-01 19:33:40 +00:00
|
|
|
static int sis_rxeof(struct sis_softc *);
|
2011-01-18 17:50:14 +00:00
|
|
|
static void sis_rxfilter(struct sis_softc *);
|
|
|
|
static void sis_rxfilter_ns(struct sis_softc *);
|
|
|
|
static void sis_rxfilter_sis(struct sis_softc *);
|
2022-08-17 20:41:35 +00:00
|
|
|
static void sis_start(if_t);
|
|
|
|
static void sis_startl(if_t);
|
2005-01-06 23:26:13 +00:00
|
|
|
static void sis_stop(struct sis_softc *);
|
2010-09-03 00:34:45 +00:00
|
|
|
static int sis_suspend(device_t);
|
2010-09-02 18:10:11 +00:00
|
|
|
static void sis_add_sysctls(struct sis_softc *);
|
2007-02-24 14:27:36 +00:00
|
|
|
static void sis_watchdog(struct sis_softc *);
|
2010-09-03 00:34:45 +00:00
|
|
|
static void sis_wol(struct sis_softc *);
|
2001-02-09 00:45:29 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
/*
|
|
|
|
* MII bit-bang glue
|
|
|
|
*/
|
|
|
|
static const struct mii_bitbang_ops sis_mii_bitbang_ops = {
|
|
|
|
sis_mii_bitbang_read,
|
|
|
|
sis_mii_bitbang_write,
|
|
|
|
{
|
|
|
|
SIS_MII_DATA, /* MII_BIT_MDO */
|
|
|
|
SIS_MII_DATA, /* MII_BIT_MDI */
|
|
|
|
SIS_MII_CLK, /* MII_BIT_MDC */
|
|
|
|
SIS_MII_DIR, /* MII_BIT_DIR_HOST_PHY */
|
|
|
|
0, /* MII_BIT_DIR_PHY_HOST */
|
|
|
|
}
|
|
|
|
};
|
2005-09-24 20:46:02 +00:00
|
|
|
|
|
|
|
static struct resource_spec sis_res_spec[] = {
|
1999-09-05 21:01:03 +00:00
|
|
|
#ifdef SIS_USEIOSPACE
|
2005-09-24 20:46:02 +00:00
|
|
|
{ SYS_RES_IOPORT, SIS_PCI_LOIO, RF_ACTIVE},
|
1999-09-05 21:01:03 +00:00
|
|
|
#else
|
2005-09-24 20:46:02 +00:00
|
|
|
{ SYS_RES_MEMORY, SIS_PCI_LOMEM, RF_ACTIVE},
|
1999-09-05 21:01:03 +00:00
|
|
|
#endif
|
2005-09-24 20:46:02 +00:00
|
|
|
{ SYS_RES_IRQ, 0, RF_ACTIVE | RF_SHAREABLE},
|
|
|
|
{ -1, 0 }
|
|
|
|
};
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
#define SIS_SETBIT(sc, reg, x) \
|
|
|
|
CSR_WRITE_4(sc, reg, \
|
|
|
|
CSR_READ_4(sc, reg) | (x))
|
|
|
|
|
|
|
|
#define SIS_CLRBIT(sc, reg, x) \
|
|
|
|
CSR_WRITE_4(sc, reg, \
|
|
|
|
CSR_READ_4(sc, reg) & ~(x))
|
|
|
|
|
|
|
|
#define SIO_SET(x) \
|
|
|
|
CSR_WRITE_4(sc, SIS_EECTL, CSR_READ_4(sc, SIS_EECTL) | x)
|
|
|
|
|
|
|
|
#define SIO_CLR(x) \
|
|
|
|
CSR_WRITE_4(sc, SIS_EECTL, CSR_READ_4(sc, SIS_EECTL) & ~x)
|
|
|
|
|
2000-07-06 06:02:04 +00:00
|
|
|
/*
|
|
|
|
* Routine to reverse the bits in a word. Stolen almost
|
|
|
|
* verbatim from /usr/games/fortune.
|
|
|
|
*/
|
2005-01-05 22:23:03 +00:00
|
|
|
static uint16_t
|
|
|
|
sis_reverse(uint16_t n)
|
2000-07-06 06:02:04 +00:00
|
|
|
{
|
|
|
|
n = ((n >> 1) & 0x5555) | ((n << 1) & 0xaaaa);
|
|
|
|
n = ((n >> 2) & 0x3333) | ((n << 2) & 0xcccc);
|
|
|
|
n = ((n >> 4) & 0x0f0f) | ((n << 4) & 0xf0f0);
|
|
|
|
n = ((n >> 8) & 0x00ff) | ((n << 8) & 0xff00);
|
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (n);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_delay(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
for (idx = (300 / 33) + 1; idx > 0; idx--)
|
|
|
|
CSR_READ_4(sc, SIS_CSR);
|
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_eeprom_idle(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2005-01-05 09:02:05 +00:00
|
|
|
int i;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
SIO_SET(SIS_EECTL_CSEL);
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_SET(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
|
|
|
|
for (i = 0; i < 25; i++) {
|
|
|
|
SIO_CLR(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_SET(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
SIO_CLR(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_CLR(SIS_EECTL_CSEL);
|
|
|
|
sis_delay(sc);
|
|
|
|
CSR_WRITE_4(sc, SIS_EECTL, 0x00000000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send a read command and address to the EEPROM, check for ACK.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_eeprom_putbyte(struct sis_softc *sc, int addr)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2005-01-05 09:02:05 +00:00
|
|
|
int d, i;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
d = addr | SIS_EECMD_READ;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Feed in each bit and stobe the clock.
|
|
|
|
*/
|
|
|
|
for (i = 0x400; i; i >>= 1) {
|
|
|
|
if (d & i) {
|
|
|
|
SIO_SET(SIS_EECTL_DIN);
|
|
|
|
} else {
|
|
|
|
SIO_CLR(SIS_EECTL_DIN);
|
|
|
|
}
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_SET(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_CLR(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a word of data stored in the EEPROM at address 'addr.'
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_eeprom_getword(struct sis_softc *sc, int addr, uint16_t *dest)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2005-01-05 09:02:05 +00:00
|
|
|
int i;
|
2010-09-01 19:53:15 +00:00
|
|
|
uint16_t word = 0;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/* Force EEPROM to idle state. */
|
|
|
|
sis_eeprom_idle(sc);
|
|
|
|
|
|
|
|
/* Enter EEPROM access mode. */
|
|
|
|
sis_delay(sc);
|
2000-07-06 06:02:04 +00:00
|
|
|
SIO_CLR(SIS_EECTL_CLK);
|
1999-09-05 21:01:03 +00:00
|
|
|
sis_delay(sc);
|
2000-07-06 06:02:04 +00:00
|
|
|
SIO_SET(SIS_EECTL_CSEL);
|
1999-09-05 21:01:03 +00:00
|
|
|
sis_delay(sc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send address of word we want to read.
|
|
|
|
*/
|
|
|
|
sis_eeprom_putbyte(sc, addr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start reading bits from EEPROM.
|
|
|
|
*/
|
|
|
|
for (i = 0x8000; i; i >>= 1) {
|
|
|
|
SIO_SET(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
if (CSR_READ_4(sc, SIS_EECTL) & SIS_EECTL_DOUT)
|
|
|
|
word |= i;
|
|
|
|
sis_delay(sc);
|
|
|
|
SIO_CLR(SIS_EECTL_CLK);
|
|
|
|
sis_delay(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Turn off EEPROM access mode. */
|
|
|
|
sis_eeprom_idle(sc);
|
|
|
|
|
|
|
|
*dest = word;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a sequence of words from the EEPROM.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_read_eeprom(struct sis_softc *sc, caddr_t dest, int off, int cnt, int swap)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
int i;
|
2010-09-01 19:53:15 +00:00
|
|
|
uint16_t word = 0, *ptr;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
sis_eeprom_getword(sc, off + i, &word);
|
2010-09-01 19:53:15 +00:00
|
|
|
ptr = (uint16_t *)(dest + (i * 2));
|
1999-09-05 21:01:03 +00:00
|
|
|
if (swap)
|
|
|
|
*ptr = ntohs(word);
|
|
|
|
else
|
|
|
|
*ptr = word;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-03-28 18:06:44 +00:00
|
|
|
#if defined(__i386__) || defined(__amd64__)
|
2002-08-23 23:19:25 +00:00
|
|
|
static device_t
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_find_bridge(device_t dev)
|
2001-02-09 00:45:29 +00:00
|
|
|
{
|
|
|
|
devclass_t pci_devclass;
|
|
|
|
device_t *pci_devices;
|
|
|
|
int pci_count = 0;
|
|
|
|
device_t *pci_children;
|
|
|
|
int pci_childcount = 0;
|
|
|
|
device_t *busp, *childp;
|
2001-12-15 19:59:28 +00:00
|
|
|
device_t child = NULL;
|
2001-02-09 00:45:29 +00:00
|
|
|
int i, j;
|
|
|
|
|
|
|
|
if ((pci_devclass = devclass_find("pci")) == NULL)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (NULL);
|
2001-02-09 00:45:29 +00:00
|
|
|
|
|
|
|
devclass_get_devices(pci_devclass, &pci_devices, &pci_count);
|
|
|
|
|
|
|
|
for (i = 0, busp = pci_devices; i < pci_count; i++, busp++) {
|
2008-08-23 15:34:31 +00:00
|
|
|
if (device_get_children(*busp, &pci_children, &pci_childcount))
|
|
|
|
continue;
|
2001-02-09 00:45:29 +00:00
|
|
|
for (j = 0, childp = pci_children;
|
|
|
|
j < pci_childcount; j++, childp++) {
|
|
|
|
if (pci_get_vendor(*childp) == SIS_VENDORID &&
|
|
|
|
pci_get_device(*childp) == 0x0008) {
|
2001-12-15 19:59:28 +00:00
|
|
|
child = *childp;
|
2008-08-23 15:34:31 +00:00
|
|
|
free(pci_children, M_TEMP);
|
2001-12-15 19:59:28 +00:00
|
|
|
goto done;
|
2001-02-09 00:45:29 +00:00
|
|
|
}
|
|
|
|
}
|
2008-08-23 15:34:31 +00:00
|
|
|
free(pci_children, M_TEMP);
|
2001-02-09 00:45:29 +00:00
|
|
|
}
|
|
|
|
|
2001-12-15 19:59:28 +00:00
|
|
|
done:
|
2001-02-09 00:45:29 +00:00
|
|
|
free(pci_devices, M_TEMP);
|
2010-09-01 18:39:35 +00:00
|
|
|
return (child);
|
2001-02-09 00:45:29 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_read_cmos(struct sis_softc *sc, device_t dev, caddr_t dest, int off, int cnt)
|
2001-02-09 00:45:29 +00:00
|
|
|
{
|
|
|
|
device_t bridge;
|
2010-09-01 19:53:15 +00:00
|
|
|
uint8_t reg;
|
2001-02-09 00:45:29 +00:00
|
|
|
int i;
|
|
|
|
bus_space_tag_t btag;
|
|
|
|
|
|
|
|
bridge = sis_find_bridge(dev);
|
|
|
|
if (bridge == NULL)
|
|
|
|
return;
|
|
|
|
reg = pci_read_config(bridge, 0x48, 1);
|
|
|
|
pci_write_config(bridge, 0x48, reg|0x40, 1);
|
|
|
|
|
|
|
|
/* XXX */
|
2010-12-20 16:39:43 +00:00
|
|
|
#if defined(__amd64__) || defined(__i386__)
|
|
|
|
btag = X86_BUS_SPACE_IO;
|
2005-03-28 18:06:44 +00:00
|
|
|
#endif
|
2001-02-09 00:45:29 +00:00
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
bus_space_write_1(btag, 0x0, 0x70, i + off);
|
|
|
|
*(dest + i) = bus_space_read_1(btag, 0x0, 0x71);
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_write_config(bridge, 0x48, reg & ~0x40, 1);
|
|
|
|
}
|
2002-01-12 21:12:17 +00:00
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_read_mac(struct sis_softc *sc, device_t dev, caddr_t dest)
|
2002-01-12 21:12:17 +00:00
|
|
|
{
|
2010-09-01 19:53:15 +00:00
|
|
|
uint32_t filtsave, csrsave;
|
2002-01-12 21:12:17 +00:00
|
|
|
|
|
|
|
filtsave = CSR_READ_4(sc, SIS_RXFILT_CTL);
|
|
|
|
csrsave = CSR_READ_4(sc, SIS_CSR);
|
|
|
|
|
|
|
|
CSR_WRITE_4(sc, SIS_CSR, SIS_CSR_RELOAD | filtsave);
|
|
|
|
CSR_WRITE_4(sc, SIS_CSR, 0);
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2002-01-12 21:12:17 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave & ~SIS_RXFILTCTL_ENABLE);
|
|
|
|
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR0);
|
2010-09-01 19:53:15 +00:00
|
|
|
((uint16_t *)dest)[0] = CSR_READ_2(sc, SIS_RXFILT_DATA);
|
2002-01-12 21:12:17 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL,SIS_FILTADDR_PAR1);
|
2010-09-01 19:53:15 +00:00
|
|
|
((uint16_t *)dest)[1] = CSR_READ_2(sc, SIS_RXFILT_DATA);
|
2002-01-12 21:12:17 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR2);
|
2010-09-01 19:53:15 +00:00
|
|
|
((uint16_t *)dest)[2] = CSR_READ_2(sc, SIS_RXFILT_DATA);
|
2002-01-12 21:12:17 +00:00
|
|
|
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave);
|
|
|
|
CSR_WRITE_4(sc, SIS_CSR, csrsave);
|
|
|
|
}
|
2001-02-09 00:45:29 +00:00
|
|
|
#endif
|
|
|
|
|
2003-01-10 08:14:07 +00:00
|
|
|
/*
|
2011-11-01 16:13:59 +00:00
|
|
|
* Read the MII serial port for the MII bit-bang module.
|
2003-01-10 08:14:07 +00:00
|
|
|
*/
|
2011-11-01 16:13:59 +00:00
|
|
|
static uint32_t
|
|
|
|
sis_mii_bitbang_read(device_t dev)
|
2003-01-10 08:14:07 +00:00
|
|
|
{
|
2011-11-01 16:13:59 +00:00
|
|
|
struct sis_softc *sc;
|
|
|
|
uint32_t val;
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
sc = device_get_softc(dev);
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
val = CSR_READ_4(sc, SIS_EECTL);
|
|
|
|
CSR_BARRIER(sc, SIS_EECTL, 4,
|
|
|
|
BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
|
|
|
|
return (val);
|
2003-01-10 08:14:07 +00:00
|
|
|
}
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2003-01-10 08:14:07 +00:00
|
|
|
/*
|
2011-11-01 16:13:59 +00:00
|
|
|
* Write the MII serial port for the MII bit-bang module.
|
2003-01-10 08:14:07 +00:00
|
|
|
*/
|
2005-01-05 22:23:03 +00:00
|
|
|
static void
|
2011-11-01 16:13:59 +00:00
|
|
|
sis_mii_bitbang_write(device_t dev, uint32_t val)
|
2003-01-10 08:14:07 +00:00
|
|
|
{
|
2011-11-01 16:13:59 +00:00
|
|
|
struct sis_softc *sc;
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
sc = device_get_softc(dev);
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2011-11-01 16:13:59 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_EECTL, val);
|
|
|
|
CSR_BARRIER(sc, SIS_EECTL, 4,
|
|
|
|
BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
|
2003-01-10 08:14:07 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_miibus_readreg(device_t dev, int phy, int reg)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2000-07-06 06:02:04 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
|
|
|
if (phy != 0)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2000-07-06 06:02:04 +00:00
|
|
|
/*
|
|
|
|
* The NatSemi chip can take a while after
|
|
|
|
* a reset to come ready, during which the BMSR
|
|
|
|
* returns a value of 0. This is *never* supposed
|
|
|
|
* to happen: some of the BMSR bits are meant to
|
|
|
|
* be hardwired in the on position, and this can
|
|
|
|
* confuse the miibus code a bit during the probe
|
|
|
|
* and attach phase. So we make an effort to check
|
|
|
|
* for this condition and wait for it to clear.
|
|
|
|
*/
|
|
|
|
if (!CSR_READ_4(sc, NS_BMSR))
|
|
|
|
DELAY(1000);
|
2003-01-10 08:14:07 +00:00
|
|
|
return CSR_READ_4(sc, NS_BMCR + (reg * 4));
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
/*
|
|
|
|
* Chipsets < SIS_635 seem not to be able to read/write
|
|
|
|
* through mdio. Use the enhanced PHY access register
|
|
|
|
* again for them.
|
|
|
|
*/
|
2002-01-12 21:12:17 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_900 &&
|
2003-01-28 10:55:38 +00:00
|
|
|
sc->sis_rev < SIS_REV_635) {
|
|
|
|
int i, val = 0;
|
|
|
|
|
|
|
|
if (phy != 0)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2003-01-28 10:55:38 +00:00
|
|
|
|
|
|
|
CSR_WRITE_4(sc, SIS_PHYCTL,
|
|
|
|
(phy << 11) | (reg << 6) | SIS_PHYOP_READ);
|
|
|
|
SIS_SETBIT(sc, SIS_PHYCTL, SIS_PHYCTL_ACCESS);
|
|
|
|
|
|
|
|
for (i = 0; i < SIS_TIMEOUT; i++) {
|
|
|
|
if (!(CSR_READ_4(sc, SIS_PHYCTL) & SIS_PHYCTL_ACCESS))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == SIS_TIMEOUT) {
|
2011-11-01 16:13:59 +00:00
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"PHY failed to come ready\n");
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2003-01-28 10:55:38 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
val = (CSR_READ_4(sc, SIS_PHYCTL) >> 16) & 0xFFFF;
|
|
|
|
|
|
|
|
if (val == 0xFFFF)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2003-01-28 10:55:38 +00:00
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (val);
|
2011-11-01 16:13:59 +00:00
|
|
|
} else
|
|
|
|
return (mii_bitbang_readreg(dev, &sis_mii_bitbang_ops, phy,
|
|
|
|
reg));
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_miibus_writereg(device_t dev, int phy, int reg, int data)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2000-07-06 06:02:04 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
|
|
|
if (phy != 0)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2000-07-06 06:02:04 +00:00
|
|
|
CSR_WRITE_4(sc, NS_BMCR + (reg * 4), data);
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
/*
|
|
|
|
* Chipsets < SIS_635 seem not to be able to read/write
|
|
|
|
* through mdio. Use the enhanced PHY access register
|
|
|
|
* again for them.
|
|
|
|
*/
|
|
|
|
if (sc->sis_type == SIS_TYPE_900 &&
|
|
|
|
sc->sis_rev < SIS_REV_635) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (phy != 0)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_PHYCTL, (data << 16) | (phy << 11) |
|
|
|
|
(reg << 6) | SIS_PHYOP_WRITE);
|
|
|
|
SIS_SETBIT(sc, SIS_PHYCTL, SIS_PHYCTL_ACCESS);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
for (i = 0; i < SIS_TIMEOUT; i++) {
|
|
|
|
if (!(CSR_READ_4(sc, SIS_PHYCTL) & SIS_PHYCTL_ACCESS))
|
|
|
|
break;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
if (i == SIS_TIMEOUT)
|
2011-11-01 16:13:59 +00:00
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"PHY failed to come ready\n");
|
|
|
|
} else
|
|
|
|
mii_bitbang_writereg(dev, &sis_mii_bitbang_ops, phy, reg,
|
|
|
|
data);
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 10:26:12 +00:00
|
|
|
sis_miibus_statchg(device_t dev)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2010-09-01 21:42:19 +00:00
|
|
|
struct mii_data *mii;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-01 21:42:19 +00:00
|
|
|
uint32_t reg;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2005-01-05 10:26:12 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
2010-09-01 21:42:19 +00:00
|
|
|
|
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
|
|
|
ifp = sc->sis_ifp;
|
|
|
|
if (mii == NULL || ifp == NULL ||
|
2022-08-17 20:41:35 +00:00
|
|
|
(if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0)
|
2010-09-01 21:42:19 +00:00
|
|
|
return;
|
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
sc->sis_flags &= ~SIS_FLAG_LINK;
|
2010-09-01 21:42:19 +00:00
|
|
|
if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
|
|
|
|
(IFM_ACTIVE | IFM_AVALID)) {
|
|
|
|
switch (IFM_SUBTYPE(mii->mii_media_active)) {
|
|
|
|
case IFM_10_T:
|
|
|
|
CSR_WRITE_4(sc, SIS_TX_CFG, SIS_TXCFG_10);
|
2010-09-02 18:10:11 +00:00
|
|
|
sc->sis_flags |= SIS_FLAG_LINK;
|
2010-09-01 21:42:19 +00:00
|
|
|
break;
|
|
|
|
case IFM_100_TX:
|
|
|
|
CSR_WRITE_4(sc, SIS_TX_CFG, SIS_TXCFG_100);
|
2010-09-02 18:10:11 +00:00
|
|
|
sc->sis_flags |= SIS_FLAG_LINK;
|
2010-09-01 21:42:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
if ((sc->sis_flags & SIS_FLAG_LINK) == 0) {
|
2010-09-01 21:42:19 +00:00
|
|
|
/*
|
|
|
|
* Stopping MACs seem to reset SIS_TX_LISTPTR and
|
|
|
|
* SIS_RX_LISTPTR which in turn requires resetting
|
|
|
|
* TX/RX buffers. So just don't do anything for
|
|
|
|
* lost link.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set full/half duplex mode. */
|
|
|
|
if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
|
|
|
|
SIS_SETBIT(sc, SIS_TX_CFG,
|
|
|
|
(SIS_TXCFG_IGN_HBEAT | SIS_TXCFG_IGN_CARR));
|
|
|
|
SIS_SETBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_TXPKTS);
|
|
|
|
} else {
|
|
|
|
SIS_CLRBIT(sc, SIS_TX_CFG,
|
|
|
|
(SIS_TXCFG_IGN_HBEAT | SIS_TXCFG_IGN_CARR));
|
|
|
|
SIS_CLRBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_TXPKTS);
|
|
|
|
}
|
|
|
|
|
2013-03-18 04:46:17 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr >= NS_SRR_16A) {
|
2010-09-01 21:42:19 +00:00
|
|
|
/*
|
|
|
|
* MPII03.D: Half Duplex Excessive Collisions.
|
|
|
|
* Also page 49 in 83816 manual
|
|
|
|
*/
|
|
|
|
SIS_SETBIT(sc, SIS_TX_CFG, SIS_TXCFG_MPII03D);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr < NS_SRR_16A &&
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) {
|
|
|
|
/*
|
|
|
|
* Short Cable Receive Errors (MP21.E)
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_PAGE, 0x0001);
|
|
|
|
reg = CSR_READ_4(sc, NS_PHY_DSPCFG) & 0xfff;
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_DSPCFG, reg | 0x1000);
|
|
|
|
DELAY(100);
|
|
|
|
reg = CSR_READ_4(sc, NS_PHY_TDATA) & 0xff;
|
|
|
|
if ((reg & 0x0080) == 0 || (reg > 0xd8 && reg <= 0xff)) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"Applying short cable fix (reg=%x)\n", reg);
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_TDATA, 0x00e8);
|
|
|
|
SIS_SETBIT(sc, NS_PHY_DSPCFG, 0x20);
|
|
|
|
}
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_PAGE, 0);
|
|
|
|
}
|
|
|
|
/* Enable TX/RX MACs. */
|
|
|
|
SIS_CLRBIT(sc, SIS_CSR, SIS_CSR_TX_DISABLE | SIS_CSR_RX_DISABLE);
|
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_TX_ENABLE | SIS_CSR_RX_ENABLE);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2005-01-05 22:23:03 +00:00
|
|
|
static uint32_t
|
|
|
|
sis_mchash(struct sis_softc *sc, const uint8_t *addr)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2004-06-09 14:34:04 +00:00
|
|
|
uint32_t crc;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/* Compute CRC for the address value. */
|
2004-06-09 14:34:04 +00:00
|
|
|
crc = ether_crc32_be(addr, ETHER_ADDR_LEN);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2000-07-06 06:02:04 +00:00
|
|
|
/*
|
|
|
|
* return the filter bit position
|
|
|
|
*
|
|
|
|
* The NatSemi chip has a 512-bit filter, which is
|
|
|
|
* different than the SiS, so we special-case it.
|
|
|
|
*/
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815)
|
2003-01-10 08:14:07 +00:00
|
|
|
return (crc >> 23);
|
2003-01-28 10:55:38 +00:00
|
|
|
else if (sc->sis_rev >= SIS_REV_635 ||
|
|
|
|
sc->sis_rev == SIS_REV_900B)
|
2003-01-10 08:14:07 +00:00
|
|
|
return (crc >> 24);
|
2003-01-28 10:55:38 +00:00
|
|
|
else
|
|
|
|
return (crc >> 25);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2011-01-18 17:50:14 +00:00
|
|
|
sis_rxfilter(struct sis_softc *sc)
|
|
|
|
{
|
|
|
|
|
|
|
|
SIS_LOCK_ASSERT(sc);
|
|
|
|
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815)
|
|
|
|
sis_rxfilter_ns(sc);
|
|
|
|
else
|
|
|
|
sis_rxfilter_sis(sc);
|
|
|
|
}
|
|
|
|
|
2019-10-21 18:07:44 +00:00
|
|
|
static u_int
|
|
|
|
sis_write_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
|
|
|
|
{
|
|
|
|
struct sis_softc *sc = arg;
|
|
|
|
uint32_t h;
|
|
|
|
int bit, index;
|
|
|
|
|
|
|
|
h = sis_mchash(sc, LLADDR(sdl));
|
|
|
|
index = h >> 3;
|
|
|
|
bit = h & 0x1F;
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_FMEM_LO + index);
|
|
|
|
if (bit > 0xF)
|
|
|
|
bit -= 0x10;
|
|
|
|
SIS_SETBIT(sc, SIS_RXFILT_DATA, (1 << bit));
|
|
|
|
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2011-01-18 17:50:14 +00:00
|
|
|
static void
|
|
|
|
sis_rxfilter_ns(struct sis_softc *sc)
|
2000-07-06 06:02:04 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2019-10-21 18:07:44 +00:00
|
|
|
uint32_t i, filter;
|
2000-07-06 06:02:04 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
2011-01-18 17:50:14 +00:00
|
|
|
filter = CSR_READ_4(sc, SIS_RXFILT_CTL);
|
|
|
|
if (filter & SIS_RXFILTCTL_ENABLE) {
|
|
|
|
/*
|
|
|
|
* Filter should be disabled to program other bits.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter & ~SIS_RXFILTCTL_ENABLE);
|
|
|
|
CSR_READ_4(sc, SIS_RXFILT_CTL);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
2011-01-18 17:50:14 +00:00
|
|
|
filter &= ~(NS_RXFILTCTL_ARP | NS_RXFILTCTL_PERFECT |
|
|
|
|
NS_RXFILTCTL_MCHASH | SIS_RXFILTCTL_ALLPHYS | SIS_RXFILTCTL_BROAD |
|
|
|
|
SIS_RXFILTCTL_ALLMULTI);
|
2000-07-06 06:02:04 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & IFF_BROADCAST)
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_BROAD;
|
2000-07-06 06:02:04 +00:00
|
|
|
/*
|
2011-01-18 17:50:14 +00:00
|
|
|
* For the NatSemi chip, we have to explicitly enable the
|
|
|
|
* reception of ARP frames, as well as turn on the 'perfect
|
|
|
|
* match' filter where we store the station address, otherwise
|
|
|
|
* we won't receive unicasts meant for this host.
|
2000-07-06 06:02:04 +00:00
|
|
|
*/
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= NS_RXFILTCTL_ARP | NS_RXFILTCTL_PERFECT;
|
2000-07-06 06:02:04 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & (IFF_ALLMULTI | IFF_PROMISC)) {
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_ALLMULTI;
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & IFF_PROMISC)
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_ALLPHYS;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We have to explicitly enable the multicast hash table
|
|
|
|
* on the NatSemi chip if we want to use it, which we do.
|
|
|
|
*/
|
|
|
|
filter |= NS_RXFILTCTL_MCHASH;
|
2000-07-06 06:02:04 +00:00
|
|
|
|
2011-01-18 17:50:14 +00:00
|
|
|
/* first, zot all the existing hash bits */
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_FMEM_LO +
|
|
|
|
(i * 2));
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, 0);
|
|
|
|
}
|
2000-07-06 06:02:04 +00:00
|
|
|
|
2019-10-21 18:07:44 +00:00
|
|
|
if_foreach_llmaddr(ifp, sis_write_maddr, sc);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
|
2015-01-12 07:37:06 +00:00
|
|
|
/* Turn the receive filter on */
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter | SIS_RXFILTCTL_ENABLE);
|
2011-01-18 17:50:14 +00:00
|
|
|
CSR_READ_4(sc, SIS_RXFILT_CTL);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
|
2019-10-21 18:07:44 +00:00
|
|
|
struct sis_hash_maddr_ctx {
|
|
|
|
struct sis_softc *sc;
|
|
|
|
uint16_t hashes[16];
|
|
|
|
};
|
|
|
|
|
|
|
|
static u_int
|
|
|
|
sis_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
|
|
|
|
{
|
|
|
|
struct sis_hash_maddr_ctx *ctx = arg;
|
|
|
|
uint32_t h;
|
|
|
|
|
|
|
|
h = sis_mchash(ctx->sc, LLADDR(sdl));
|
|
|
|
ctx->hashes[h >> 4] |= 1 << (h & 0xf);
|
|
|
|
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2011-01-18 17:50:14 +00:00
|
|
|
sis_rxfilter_sis(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2019-10-21 18:07:44 +00:00
|
|
|
struct sis_hash_maddr_ctx ctx;
|
|
|
|
uint32_t filter, i, n;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-10 08:14:07 +00:00
|
|
|
/* hash table size */
|
2011-01-18 17:50:14 +00:00
|
|
|
if (sc->sis_rev >= SIS_REV_635 || sc->sis_rev == SIS_REV_900B)
|
2003-01-28 10:55:38 +00:00
|
|
|
n = 16;
|
|
|
|
else
|
|
|
|
n = 8;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2011-01-18 17:50:14 +00:00
|
|
|
filter = CSR_READ_4(sc, SIS_RXFILT_CTL);
|
|
|
|
if (filter & SIS_RXFILTCTL_ENABLE) {
|
2014-12-16 06:13:30 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter & ~SIS_RXFILTCTL_ENABLE);
|
2011-01-18 17:50:14 +00:00
|
|
|
CSR_READ_4(sc, SIS_RXFILT_CTL);
|
|
|
|
}
|
|
|
|
filter &= ~(SIS_RXFILTCTL_ALLPHYS | SIS_RXFILTCTL_BROAD |
|
|
|
|
SIS_RXFILTCTL_ALLMULTI);
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & IFF_BROADCAST)
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_BROAD;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & (IFF_ALLMULTI | IFF_PROMISC)) {
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_ALLMULTI;
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & IFF_PROMISC)
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_ALLPHYS;
|
2003-01-10 08:14:07 +00:00
|
|
|
for (i = 0; i < n; i++)
|
2019-10-21 18:07:44 +00:00
|
|
|
ctx.hashes[i] = ~0;
|
2003-01-10 08:14:07 +00:00
|
|
|
} else {
|
|
|
|
for (i = 0; i < n; i++)
|
2019-10-21 18:07:44 +00:00
|
|
|
ctx.hashes[i] = 0;
|
|
|
|
ctx.sc = sc;
|
|
|
|
if (if_foreach_llmaddr(ifp, sis_hash_maddr, &ctx) > n) {
|
2011-01-18 17:50:14 +00:00
|
|
|
filter |= SIS_RXFILTCTL_ALLMULTI;
|
2003-01-10 08:14:07 +00:00
|
|
|
for (i = 0; i < n; i++)
|
2019-10-21 18:07:44 +00:00
|
|
|
ctx.hashes[i] = ~0;
|
2003-01-10 08:14:07 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2003-01-10 08:14:07 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, (4 + i) << 16);
|
2019-10-21 18:07:44 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, ctx.hashes[i]);
|
2003-01-10 08:14:07 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2015-01-12 07:37:06 +00:00
|
|
|
/* Turn the receive filter on */
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, filter | SIS_RXFILTCTL_ENABLE);
|
2011-01-18 17:50:14 +00:00
|
|
|
CSR_READ_4(sc, SIS_RXFILT_CTL);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 10:26:12 +00:00
|
|
|
sis_reset(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2005-01-05 09:02:05 +00:00
|
|
|
int i;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RESET);
|
|
|
|
|
|
|
|
for (i = 0; i < SIS_TIMEOUT; i++) {
|
|
|
|
if (!(CSR_READ_4(sc, SIS_CSR) & SIS_CSR_RESET))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == SIS_TIMEOUT)
|
2006-09-15 10:40:54 +00:00
|
|
|
device_printf(sc->sis_dev, "reset never completed\n");
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/* Wait a little while for the chip to get its brains in order. */
|
|
|
|
DELAY(1000);
|
2001-02-21 20:54:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a NetSemi chip, make sure to clear
|
|
|
|
* PME mode.
|
|
|
|
*/
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
|
|
|
CSR_WRITE_4(sc, NS_CLKRUN, NS_CLKRUN_PMESTS);
|
|
|
|
CSR_WRITE_4(sc, NS_CLKRUN, 0);
|
2010-09-03 00:34:45 +00:00
|
|
|
} else {
|
|
|
|
/* Disable WOL functions. */
|
|
|
|
CSR_WRITE_4(sc, SIS_PWRMAN_CTL, 0);
|
2001-02-21 20:54:22 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe for an SiS chip. Check the PCI vendor and device
|
|
|
|
* IDs against our list and return a device name if we find a match.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_probe(device_t dev)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2011-11-01 16:13:59 +00:00
|
|
|
const struct sis_type *t;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
t = sis_devs;
|
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
while (t->sis_name != NULL) {
|
1999-09-05 21:01:03 +00:00
|
|
|
if ((pci_get_vendor(dev) == t->sis_vid) &&
|
|
|
|
(pci_get_device(dev) == t->sis_did)) {
|
|
|
|
device_set_desc(dev, t->sis_name);
|
2005-02-24 21:32:56 +00:00
|
|
|
return (BUS_PROBE_DEFAULT);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (ENXIO);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the interface. Allocate softc structures, do ifmedia
|
|
|
|
* setup and ethernet/BPF attach.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_attach(device_t dev)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
u_char eaddr[ETHER_ADDR_LEN];
|
|
|
|
struct sis_softc *sc;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2022-04-05 02:13:32 +00:00
|
|
|
int error = 0, pmc;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2006-09-15 10:40:54 +00:00
|
|
|
sc->sis_dev = dev;
|
2003-09-03 07:40:04 +00:00
|
|
|
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&sc->sis_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
|
2005-01-07 00:02:11 +00:00
|
|
|
MTX_DEF);
|
2005-09-26 18:42:27 +00:00
|
|
|
callout_init_mtx(&sc->sis_stat_ch, &sc->sis_mtx, 0);
|
2000-12-04 22:46:50 +00:00
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
if (pci_get_device(dev) == SIS_DEVICEID_900)
|
|
|
|
sc->sis_type = SIS_TYPE_900;
|
|
|
|
if (pci_get_device(dev) == SIS_DEVICEID_7016)
|
|
|
|
sc->sis_type = SIS_TYPE_7016;
|
2000-07-06 06:02:04 +00:00
|
|
|
if (pci_get_vendor(dev) == NS_VENDORID)
|
|
|
|
sc->sis_type = SIS_TYPE_83815;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2002-01-12 21:12:17 +00:00
|
|
|
sc->sis_rev = pci_read_config(dev, PCIR_REVID, 1);
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Map control/status registers.
|
|
|
|
*/
|
2001-02-21 20:54:22 +00:00
|
|
|
pci_enable_busmaster(dev);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-09-24 20:46:02 +00:00
|
|
|
error = bus_alloc_resources(dev, sis_res_spec, sc->sis_res);
|
2005-09-26 18:42:27 +00:00
|
|
|
if (error) {
|
|
|
|
device_printf(dev, "couldn't allocate resources\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/* Reset the adapter. */
|
|
|
|
sis_reset(sc);
|
|
|
|
|
2003-01-28 10:55:38 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_900 &&
|
2010-09-01 18:28:08 +00:00
|
|
|
(sc->sis_rev == SIS_REV_635 ||
|
|
|
|
sc->sis_rev == SIS_REV_900B)) {
|
2003-01-28 10:55:38 +00:00
|
|
|
SIO_SET(SIS_CFG_RND_CNT);
|
|
|
|
SIO_SET(SIS_CFG_PERR_DETECT);
|
|
|
|
}
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Get station address from the EEPROM.
|
|
|
|
*/
|
2000-07-06 06:02:04 +00:00
|
|
|
switch (pci_get_vendor(dev)) {
|
|
|
|
case NS_VENDORID:
|
2003-09-03 07:40:04 +00:00
|
|
|
sc->sis_srr = CSR_READ_4(sc, NS_SRR);
|
|
|
|
|
|
|
|
/* We can't update the device description, so spew */
|
|
|
|
if (sc->sis_srr == NS_SRR_15C)
|
|
|
|
device_printf(dev, "Silicon Revision: DP83815C\n");
|
|
|
|
else if (sc->sis_srr == NS_SRR_15D)
|
|
|
|
device_printf(dev, "Silicon Revision: DP83815D\n");
|
|
|
|
else if (sc->sis_srr == NS_SRR_16A)
|
|
|
|
device_printf(dev, "Silicon Revision: DP83816A\n");
|
|
|
|
else
|
|
|
|
device_printf(dev, "Silicon Revision %x\n", sc->sis_srr);
|
|
|
|
|
2000-07-06 06:02:04 +00:00
|
|
|
/*
|
|
|
|
* Reading the MAC address out of the EEPROM on
|
|
|
|
* the NatSemi chip takes a bit more work than
|
|
|
|
* you'd expect. The address spans 4 16-bit words,
|
|
|
|
* with the first word containing only a single bit.
|
|
|
|
* You have to shift everything over one bit to
|
|
|
|
* get it aligned properly. Also, the bits are
|
|
|
|
* stored backwards (the LSB is really the MSB,
|
|
|
|
* and so on) so you have to reverse them in order
|
|
|
|
* to get the MAC address into the form we want.
|
|
|
|
* Why? Who the hell knows.
|
|
|
|
*/
|
|
|
|
{
|
2010-09-01 19:53:15 +00:00
|
|
|
uint16_t tmp[4];
|
2000-07-06 06:02:04 +00:00
|
|
|
|
|
|
|
sis_read_eeprom(sc, (caddr_t)&tmp,
|
|
|
|
NS_EE_NODEADDR, 4, 0);
|
|
|
|
|
|
|
|
/* Shift everything over one bit. */
|
|
|
|
tmp[3] = tmp[3] >> 1;
|
2000-07-06 19:21:07 +00:00
|
|
|
tmp[3] |= tmp[2] << 15;
|
2000-07-06 06:02:04 +00:00
|
|
|
tmp[2] = tmp[2] >> 1;
|
2000-07-06 19:21:07 +00:00
|
|
|
tmp[2] |= tmp[1] << 15;
|
2000-07-06 06:02:04 +00:00
|
|
|
tmp[1] = tmp[1] >> 1;
|
2000-07-06 19:21:07 +00:00
|
|
|
tmp[1] |= tmp[0] << 15;
|
2000-07-06 06:02:04 +00:00
|
|
|
|
|
|
|
/* Now reverse all the bits. */
|
|
|
|
tmp[3] = sis_reverse(tmp[3]);
|
|
|
|
tmp[2] = sis_reverse(tmp[2]);
|
|
|
|
tmp[1] = sis_reverse(tmp[1]);
|
|
|
|
|
2010-09-02 17:51:41 +00:00
|
|
|
eaddr[0] = (tmp[1] >> 0) & 0xFF;
|
|
|
|
eaddr[1] = (tmp[1] >> 8) & 0xFF;
|
|
|
|
eaddr[2] = (tmp[2] >> 0) & 0xFF;
|
|
|
|
eaddr[3] = (tmp[2] >> 8) & 0xFF;
|
|
|
|
eaddr[4] = (tmp[3] >> 0) & 0xFF;
|
|
|
|
eaddr[5] = (tmp[3] >> 8) & 0xFF;
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SIS_VENDORID:
|
|
|
|
default:
|
2005-03-28 18:06:44 +00:00
|
|
|
#if defined(__i386__) || defined(__amd64__)
|
2001-02-09 00:45:29 +00:00
|
|
|
/*
|
|
|
|
* If this is a SiS 630E chipset with an embedded
|
|
|
|
* SiS 900 controller, we have to read the MAC address
|
|
|
|
* from the APC CMOS RAM. Our method for doing this
|
|
|
|
* is very ugly since we have to reach out and grab
|
|
|
|
* ahold of hardware for which we cannot properly
|
|
|
|
* allocate resources. This code is only compiled on
|
|
|
|
* the i386 architecture since the SiS 630E chipset
|
|
|
|
* is for x86 motherboards only. Note that there are
|
|
|
|
* a lot of magic numbers in this hack. These are
|
|
|
|
* taken from SiS's Linux driver. I'd like to replace
|
|
|
|
* them with proper symbolic definitions, but that
|
|
|
|
* requires some datasheets that I don't have access
|
|
|
|
* to at the moment.
|
|
|
|
*/
|
2002-01-12 21:12:17 +00:00
|
|
|
if (sc->sis_rev == SIS_REV_630S ||
|
|
|
|
sc->sis_rev == SIS_REV_630E ||
|
2002-02-06 22:06:47 +00:00
|
|
|
sc->sis_rev == SIS_REV_630EA1)
|
2001-02-09 00:45:29 +00:00
|
|
|
sis_read_cmos(sc, dev, (caddr_t)&eaddr, 0x9, 6);
|
2002-01-12 21:12:17 +00:00
|
|
|
|
2002-02-06 22:06:47 +00:00
|
|
|
else if (sc->sis_rev == SIS_REV_635 ||
|
|
|
|
sc->sis_rev == SIS_REV_630ET)
|
2002-01-12 21:12:17 +00:00
|
|
|
sis_read_mac(sc, dev, (caddr_t)&eaddr);
|
2003-01-10 08:16:03 +00:00
|
|
|
else if (sc->sis_rev == SIS_REV_96x) {
|
|
|
|
/* Allow to read EEPROM from LAN. It is shared
|
|
|
|
* between a 1394 controller and the NIC and each
|
|
|
|
* time we access it, we need to set SIS_EECMD_REQ.
|
|
|
|
*/
|
|
|
|
SIO_SET(SIS_EECMD_REQ);
|
2022-04-05 02:13:32 +00:00
|
|
|
for (int waittime = 0; waittime < SIS_TIMEOUT;
|
2003-01-10 08:16:03 +00:00
|
|
|
waittime++) {
|
|
|
|
/* Force EEPROM to idle state. */
|
|
|
|
sis_eeprom_idle(sc);
|
|
|
|
if (CSR_READ_4(sc, SIS_EECTL) & SIS_EECMD_GNT) {
|
|
|
|
sis_read_eeprom(sc, (caddr_t)&eaddr,
|
|
|
|
SIS_EE_NODEADDR, 3, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DELAY(1);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Set SIS_EECTL_CLK to high, so a other master
|
|
|
|
* can operate on the i2c bus.
|
|
|
|
*/
|
|
|
|
SIO_SET(SIS_EECTL_CLK);
|
|
|
|
/* Refuse EEPROM access by LAN */
|
|
|
|
SIO_SET(SIS_EECMD_DONE);
|
|
|
|
} else
|
2001-02-09 00:45:29 +00:00
|
|
|
#endif
|
|
|
|
sis_read_eeprom(sc, (caddr_t)&eaddr,
|
|
|
|
SIS_EE_NODEADDR, 3, 0);
|
2000-07-06 06:02:04 +00:00
|
|
|
break;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
sis_add_sysctls(sc);
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Allocate DMA'able memory. */
|
|
|
|
if ((error = sis_dma_alloc(sc)) != 0)
|
2003-03-31 17:29:43 +00:00
|
|
|
goto fail;
|
2001-08-15 17:38:43 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp = if_alloc(IFT_ETHER);
|
|
|
|
if (ifp == NULL) {
|
2005-09-26 18:42:27 +00:00
|
|
|
device_printf(dev, "can not if_alloc()\n");
|
2005-06-10 16:49:24 +00:00
|
|
|
error = ENOSPC;
|
|
|
|
goto fail;
|
|
|
|
}
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setsoftc(ifp, sc);
|
2003-10-31 18:32:15 +00:00
|
|
|
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
|
|
|
|
if_setioctlfn(ifp, sis_ioctl);
|
|
|
|
if_setstartfn(ifp, sis_start);
|
|
|
|
if_setinitfn(ifp, sis_init);
|
|
|
|
if_setsendqlen(ifp, SIS_TX_LIST_CNT - 1);
|
|
|
|
if_setsendqready(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2011-03-23 13:10:15 +00:00
|
|
|
if (pci_find_cap(sc->sis_dev, PCIY_PMG, &pmc) == 0) {
|
2010-09-03 00:34:45 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815)
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setcapabilitiesbit(ifp, IFCAP_WOL, 0);
|
2010-09-03 00:34:45 +00:00
|
|
|
else
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setcapabilitiesbit(ifp, IFCAP_WOL_MAGIC, 0);
|
|
|
|
if_setcapenable(ifp, if_getcapabilities(ifp));
|
2010-09-03 00:34:45 +00:00
|
|
|
}
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Do MII setup.
|
|
|
|
*/
|
2010-10-15 15:00:30 +00:00
|
|
|
error = mii_attach(dev, &sc->sis_miibus, ifp, sis_ifmedia_upd,
|
|
|
|
sis_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(dev, "attaching PHYs failed\n");
|
1999-09-05 21:01:03 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-07-13 22:54:34 +00:00
|
|
|
* Call MI attach routine.
|
1999-09-05 21:01:03 +00:00
|
|
|
*/
|
2002-11-14 23:49:09 +00:00
|
|
|
ether_ifattach(ifp, eaddr);
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2001-12-05 09:34:28 +00:00
|
|
|
/*
|
|
|
|
* Tell the upper layer(s) we support long frames.
|
|
|
|
*/
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
|
|
|
|
if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
|
|
|
|
if_setcapenable(ifp, if_getcapabilities(ifp));
|
2004-04-11 20:34:08 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setcapabilitiesbit(ifp, IFCAP_POLLING, 0);
|
2004-04-11 20:34:08 +00:00
|
|
|
#endif
|
|
|
|
|
2003-04-17 20:32:06 +00:00
|
|
|
/* Hook interrupt last to avoid having to lock softc */
|
2005-09-24 20:46:02 +00:00
|
|
|
error = bus_setup_intr(dev, sc->sis_res[1], INTR_TYPE_NET | INTR_MPSAFE,
|
2007-02-23 12:19:07 +00:00
|
|
|
NULL, sis_intr, sc, &sc->sis_intrhand);
|
2003-03-31 17:29:43 +00:00
|
|
|
|
|
|
|
if (error) {
|
2005-09-26 18:42:27 +00:00
|
|
|
device_printf(dev, "couldn't set up irq\n");
|
2003-04-17 20:32:06 +00:00
|
|
|
ether_ifdetach(ifp);
|
2003-03-31 17:29:43 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
fail:
|
2003-03-31 17:29:43 +00:00
|
|
|
if (error)
|
|
|
|
sis_detach(dev);
|
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (error);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2003-04-17 20:32:06 +00:00
|
|
|
/*
|
|
|
|
* Shutdown hardware and free up resources. This can be called any
|
|
|
|
* time after the mutex has been initialized. It is called in both
|
|
|
|
* the error case in attach and the normal detach case so it needs
|
|
|
|
* to be careful about only freeing resources that have actually been
|
|
|
|
* allocated.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_detach(device_t dev)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2003-03-31 20:22:00 +00:00
|
|
|
KASSERT(mtx_initialized(&sc->sis_mtx), ("sis mutex not initialized"));
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getcapenable(ifp) & IFCAP_POLLING)
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
ether_poll_deregister(ifp);
|
|
|
|
#endif
|
|
|
|
|
2003-07-27 14:38:54 +00:00
|
|
|
/* These should only be active if attach succeeded. */
|
2003-04-21 18:34:04 +00:00
|
|
|
if (device_is_attached(dev)) {
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_LOCK(sc);
|
2003-04-17 20:32:06 +00:00
|
|
|
sis_stop(sc);
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
callout_drain(&sc->sis_stat_ch);
|
2003-03-31 17:29:43 +00:00
|
|
|
ether_ifdetach(ifp);
|
|
|
|
}
|
2003-04-17 20:32:06 +00:00
|
|
|
if (sc->sis_miibus)
|
|
|
|
device_delete_child(dev, sc->sis_miibus);
|
|
|
|
bus_generic_detach(dev);
|
2003-03-31 17:29:43 +00:00
|
|
|
|
|
|
|
if (sc->sis_intrhand)
|
2005-09-24 20:46:02 +00:00
|
|
|
bus_teardown_intr(dev, sc->sis_res[1], sc->sis_intrhand);
|
|
|
|
bus_release_resources(dev, sis_res_spec, sc->sis_res);
|
2003-03-31 17:29:43 +00:00
|
|
|
|
2005-10-13 21:11:20 +00:00
|
|
|
if (ifp)
|
|
|
|
if_free(ifp);
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_dma_free(sc);
|
|
|
|
|
|
|
|
mtx_destroy(&sc->sis_mtx);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct sis_dmamap_arg {
|
|
|
|
bus_addr_t sis_busaddr;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
sis_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
|
|
|
|
{
|
|
|
|
struct sis_dmamap_arg *ctx;
|
|
|
|
|
|
|
|
if (error != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
|
|
|
|
|
|
|
|
ctx = (struct sis_dmamap_arg *)arg;
|
|
|
|
ctx->sis_busaddr = segs[0].ds_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sis_dma_ring_alloc(struct sis_softc *sc, bus_size_t alignment,
|
|
|
|
bus_size_t maxsize, bus_dma_tag_t *tag, uint8_t **ring, bus_dmamap_t *map,
|
|
|
|
bus_addr_t *paddr, const char *msg)
|
|
|
|
{
|
|
|
|
struct sis_dmamap_arg ctx;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = bus_dma_tag_create(sc->sis_parent_tag, alignment, 0,
|
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, maxsize, 1,
|
|
|
|
maxsize, 0, NULL, NULL, tag);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"could not create %s dma tag\n", msg);
|
|
|
|
return (ENOMEM);
|
2003-03-31 17:29:43 +00:00
|
|
|
}
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Allocate DMA'able memory for ring. */
|
|
|
|
error = bus_dmamem_alloc(*tag, (void **)ring,
|
|
|
|
BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, map);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"could not allocate DMA'able memory for %s\n", msg);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
/* Load the address of the ring. */
|
|
|
|
ctx.sis_busaddr = 0;
|
|
|
|
error = bus_dmamap_load(*tag, *map, *ring, maxsize, sis_dmamap_cb,
|
|
|
|
&ctx, BUS_DMA_NOWAIT);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"could not load DMA'able memory for %s\n", msg);
|
|
|
|
return (ENOMEM);
|
2003-03-31 17:29:43 +00:00
|
|
|
}
|
2010-09-01 19:33:40 +00:00
|
|
|
*paddr = ctx.sis_busaddr;
|
|
|
|
return (0);
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
static int
|
|
|
|
sis_dma_alloc(struct sis_softc *sc)
|
|
|
|
{
|
|
|
|
struct sis_rxdesc *rxd;
|
|
|
|
struct sis_txdesc *txd;
|
|
|
|
int error, i;
|
|
|
|
|
|
|
|
/* Allocate the parent bus DMA tag appropriate for PCI. */
|
|
|
|
error = bus_dma_tag_create(bus_get_dma_tag(sc->sis_dev),
|
|
|
|
1, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
|
|
|
|
NULL, BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
0, NULL, NULL, &sc->sis_parent_tag);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"could not allocate parent dma tag\n");
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create RX ring. */
|
|
|
|
error = sis_dma_ring_alloc(sc, SIS_DESC_ALIGN, SIS_RX_LIST_SZ,
|
|
|
|
&sc->sis_rx_list_tag, (uint8_t **)&sc->sis_rx_list,
|
|
|
|
&sc->sis_rx_list_map, &sc->sis_rx_paddr, "RX ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* Create TX ring. */
|
|
|
|
error = sis_dma_ring_alloc(sc, SIS_DESC_ALIGN, SIS_TX_LIST_SZ,
|
|
|
|
&sc->sis_tx_list_tag, (uint8_t **)&sc->sis_tx_list,
|
|
|
|
&sc->sis_tx_list_map, &sc->sis_tx_paddr, "TX ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* Create tag for RX mbufs. */
|
|
|
|
error = bus_dma_tag_create(sc->sis_parent_tag, SIS_RX_BUF_ALIGN, 0,
|
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1,
|
|
|
|
MCLBYTES, 0, NULL, NULL, &sc->sis_rx_tag);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->sis_dev, "could not allocate RX dma tag\n");
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create tag for TX mbufs. */
|
|
|
|
error = bus_dma_tag_create(sc->sis_parent_tag, 1, 0,
|
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
MCLBYTES * SIS_MAXTXSEGS, SIS_MAXTXSEGS, MCLBYTES, 0, NULL, NULL,
|
|
|
|
&sc->sis_tx_tag);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->sis_dev, "could not allocate TX dma tag\n");
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create DMA maps for RX buffers. */
|
|
|
|
error = bus_dmamap_create(sc->sis_rx_tag, 0, &sc->sis_rx_sparemap);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"can't create spare DMA map for RX\n");
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
for (i = 0; i < SIS_RX_LIST_CNT; i++) {
|
|
|
|
rxd = &sc->sis_rxdesc[i];
|
|
|
|
rxd->rx_m = NULL;
|
|
|
|
error = bus_dmamap_create(sc->sis_rx_tag, 0, &rxd->rx_dmamap);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"can't create DMA map for RX\n");
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create DMA maps for TX buffers. */
|
|
|
|
for (i = 0; i < SIS_TX_LIST_CNT; i++) {
|
|
|
|
txd = &sc->sis_txdesc[i];
|
|
|
|
txd->tx_m = NULL;
|
|
|
|
error = bus_dmamap_create(sc->sis_tx_tag, 0, &txd->tx_dmamap);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->sis_dev,
|
|
|
|
"can't create DMA map for TX\n");
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
static void
|
|
|
|
sis_dma_free(struct sis_softc *sc)
|
|
|
|
{
|
|
|
|
struct sis_rxdesc *rxd;
|
|
|
|
struct sis_txdesc *txd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Destroy DMA maps for RX buffers. */
|
|
|
|
for (i = 0; i < SIS_RX_LIST_CNT; i++) {
|
|
|
|
rxd = &sc->sis_rxdesc[i];
|
|
|
|
if (rxd->rx_dmamap)
|
|
|
|
bus_dmamap_destroy(sc->sis_rx_tag, rxd->rx_dmamap);
|
|
|
|
}
|
|
|
|
if (sc->sis_rx_sparemap)
|
|
|
|
bus_dmamap_destroy(sc->sis_rx_tag, sc->sis_rx_sparemap);
|
|
|
|
|
|
|
|
/* Destroy DMA maps for TX buffers. */
|
|
|
|
for (i = 0; i < SIS_TX_LIST_CNT; i++) {
|
|
|
|
txd = &sc->sis_txdesc[i];
|
|
|
|
if (txd->tx_dmamap)
|
|
|
|
bus_dmamap_destroy(sc->sis_tx_tag, txd->tx_dmamap);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->sis_rx_tag)
|
|
|
|
bus_dma_tag_destroy(sc->sis_rx_tag);
|
|
|
|
if (sc->sis_tx_tag)
|
|
|
|
bus_dma_tag_destroy(sc->sis_tx_tag);
|
|
|
|
|
|
|
|
/* Destroy RX ring. */
|
2014-06-11 14:53:58 +00:00
|
|
|
if (sc->sis_rx_paddr)
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_unload(sc->sis_rx_list_tag, sc->sis_rx_list_map);
|
2014-06-11 14:53:58 +00:00
|
|
|
if (sc->sis_rx_list)
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamem_free(sc->sis_rx_list_tag, sc->sis_rx_list,
|
|
|
|
sc->sis_rx_list_map);
|
|
|
|
|
|
|
|
if (sc->sis_rx_list_tag)
|
|
|
|
bus_dma_tag_destroy(sc->sis_rx_list_tag);
|
|
|
|
|
|
|
|
/* Destroy TX ring. */
|
2014-06-11 14:53:58 +00:00
|
|
|
if (sc->sis_tx_paddr)
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_unload(sc->sis_tx_list_tag, sc->sis_tx_list_map);
|
|
|
|
|
2014-06-11 14:53:58 +00:00
|
|
|
if (sc->sis_tx_list)
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamem_free(sc->sis_tx_list_tag, sc->sis_tx_list,
|
|
|
|
sc->sis_tx_list_map);
|
|
|
|
|
|
|
|
if (sc->sis_tx_list_tag)
|
|
|
|
bus_dma_tag_destroy(sc->sis_tx_list_tag);
|
|
|
|
|
|
|
|
/* Destroy the parent tag. */
|
|
|
|
if (sc->sis_parent_tag)
|
|
|
|
bus_dma_tag_destroy(sc->sis_parent_tag);
|
|
|
|
}
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
2005-01-06 23:31:41 +00:00
|
|
|
* Initialize the TX and RX descriptors and allocate mbufs for them. Note that
|
|
|
|
* we arrange the descriptors in a closed ring, so that the last descriptor
|
|
|
|
* points back to the first.
|
1999-09-05 21:01:03 +00:00
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2005-01-06 23:31:41 +00:00
|
|
|
sis_ring_init(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2010-09-01 19:33:40 +00:00
|
|
|
struct sis_rxdesc *rxd;
|
|
|
|
struct sis_txdesc *txd;
|
|
|
|
bus_addr_t next;
|
|
|
|
int error, i;
|
|
|
|
|
|
|
|
bzero(&sc->sis_tx_list[0], SIS_TX_LIST_SZ);
|
|
|
|
for (i = 0; i < SIS_TX_LIST_CNT; i++) {
|
|
|
|
txd = &sc->sis_txdesc[i];
|
|
|
|
txd->tx_m = NULL;
|
|
|
|
if (i == SIS_TX_LIST_CNT - 1)
|
|
|
|
next = SIS_TX_RING_ADDR(sc, 0);
|
2005-01-06 23:31:41 +00:00
|
|
|
else
|
2010-09-01 19:33:40 +00:00
|
|
|
next = SIS_TX_RING_ADDR(sc, i + 1);
|
|
|
|
sc->sis_tx_list[i].sis_next = htole32(SIS_ADDR_LO(next));
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
2005-01-04 22:25:58 +00:00
|
|
|
sc->sis_tx_prod = sc->sis_tx_cons = sc->sis_tx_cnt = 0;
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_sync(sc->sis_tx_list_tag, sc->sis_tx_list_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
|
|
|
|
|
|
|
sc->sis_rx_cons = 0;
|
|
|
|
bzero(&sc->sis_rx_list[0], SIS_RX_LIST_SZ);
|
|
|
|
for (i = 0; i < SIS_RX_LIST_CNT; i++) {
|
|
|
|
rxd = &sc->sis_rxdesc[i];
|
|
|
|
rxd->rx_desc = &sc->sis_rx_list[i];
|
|
|
|
if (i == SIS_RX_LIST_CNT - 1)
|
|
|
|
next = SIS_RX_RING_ADDR(sc, 0);
|
|
|
|
else
|
|
|
|
next = SIS_RX_RING_ADDR(sc, i + 1);
|
|
|
|
rxd->rx_desc->sis_next = htole32(SIS_ADDR_LO(next));
|
|
|
|
error = sis_newbuf(sc, rxd);
|
2005-01-06 23:31:41 +00:00
|
|
|
if (error)
|
2010-09-01 18:39:35 +00:00
|
|
|
return (error);
|
2010-09-01 19:33:40 +00:00
|
|
|
}
|
|
|
|
bus_dmamap_sync(sc->sis_rx_list_tag, sc->sis_rx_list_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize an RX descriptor and attach an MBUF cluster.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_newbuf(struct sis_softc *sc, struct sis_rxdesc *rxd)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2010-09-01 19:33:40 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
bus_dma_segment_t segs[1];
|
|
|
|
bus_dmamap_t map;
|
|
|
|
int nsegs;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2012-12-04 09:32:43 +00:00
|
|
|
m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
|
2010-09-01 19:33:40 +00:00
|
|
|
if (m == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
m->m_len = m->m_pkthdr.len = SIS_RXLEN;
|
|
|
|
#ifndef __NO_STRICT_ALIGNMENT
|
|
|
|
m_adj(m, SIS_RX_BUF_ALIGN);
|
|
|
|
#endif
|
2001-08-15 17:38:43 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
if (bus_dmamap_load_mbuf_sg(sc->sis_rx_tag, sc->sis_rx_sparemap, m,
|
|
|
|
segs, &nsegs, 0) != 0) {
|
|
|
|
m_freem(m);
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
|
|
|
KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
if (rxd->rx_m != NULL) {
|
|
|
|
bus_dmamap_sync(sc->sis_rx_tag, rxd->rx_dmamap,
|
|
|
|
BUS_DMASYNC_POSTREAD);
|
|
|
|
bus_dmamap_unload(sc->sis_rx_tag, rxd->rx_dmamap);
|
|
|
|
}
|
|
|
|
map = rxd->rx_dmamap;
|
|
|
|
rxd->rx_dmamap = sc->sis_rx_sparemap;
|
|
|
|
sc->sis_rx_sparemap = map;
|
|
|
|
bus_dmamap_sync(sc->sis_rx_tag, rxd->rx_dmamap, BUS_DMASYNC_PREREAD);
|
|
|
|
rxd->rx_m = m;
|
|
|
|
rxd->rx_desc->sis_ptr = htole32(SIS_ADDR_LO(segs[0].ds_addr));
|
2011-02-28 20:37:48 +00:00
|
|
|
rxd->rx_desc->sis_cmdsts = htole32(SIS_RXLEN);
|
2010-09-01 19:33:40 +00:00
|
|
|
return (0);
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
static __inline void
|
|
|
|
sis_discard_rxbuf(struct sis_rxdesc *rxd)
|
|
|
|
{
|
2001-08-15 17:38:43 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
rxd->rx_desc->sis_cmdsts = htole32(SIS_RXLEN);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
#ifndef __NO_STRICT_ALIGNMENT
|
|
|
|
static __inline void
|
|
|
|
sis_fixup_rx(struct mbuf *m)
|
|
|
|
{
|
|
|
|
uint16_t *src, *dst;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
src = mtod(m, uint16_t *);
|
|
|
|
dst = src - (SIS_RX_BUF_ALIGN - ETHER_ALIGN) / sizeof(*src);
|
|
|
|
|
|
|
|
for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
|
|
|
|
*dst++ = *src++;
|
|
|
|
|
|
|
|
m->m_data -= SIS_RX_BUF_ALIGN - ETHER_ALIGN;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* A frame has been uploaded: pass the resulting mbuf chain up to
|
|
|
|
* the higher level protocols.
|
|
|
|
*/
|
2009-05-30 15:14:44 +00:00
|
|
|
static int
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_rxeof(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2010-09-01 19:33:40 +00:00
|
|
|
struct mbuf *m;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-01 19:33:40 +00:00
|
|
|
struct sis_rxdesc *rxd;
|
1999-09-05 21:01:03 +00:00
|
|
|
struct sis_desc *cur_rx;
|
2010-09-01 19:33:40 +00:00
|
|
|
int prog, rx_cons, rx_npkts = 0, total_len;
|
|
|
|
uint32_t rxstat;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-11-14 19:00:32 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_sync(sc->sis_rx_list_tag, sc->sis_rx_list_map,
|
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
rx_cons = sc->sis_rx_cons;
|
|
|
|
ifp = sc->sis_ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
for (prog = 0; (if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0;
|
2010-09-01 19:33:40 +00:00
|
|
|
SIS_INC(rx_cons, SIS_RX_LIST_CNT), prog++) {
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getcapenable(ifp) & IFCAP_POLLING) {
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
if (sc->rxcycles <= 0)
|
|
|
|
break;
|
|
|
|
sc->rxcycles--;
|
|
|
|
}
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
#endif
|
2010-09-01 19:33:40 +00:00
|
|
|
cur_rx = &sc->sis_rx_list[rx_cons];
|
|
|
|
rxstat = le32toh(cur_rx->sis_cmdsts);
|
|
|
|
if ((rxstat & SIS_CMDSTS_OWN) == 0)
|
|
|
|
break;
|
|
|
|
rxd = &sc->sis_rxdesc[rx_cons];
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
total_len = (rxstat & SIS_CMDSTS_BUFLEN) - ETHER_CRC_LEN;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_VLAN_MTU) != 0 &&
|
2008-12-09 04:30:47 +00:00
|
|
|
total_len <= (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN -
|
|
|
|
ETHER_CRC_LEN))
|
|
|
|
rxstat &= ~SIS_RXSTAT_GIANT;
|
|
|
|
if (SIS_RXSTAT_ERROR(rxstat) != 0) {
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
|
1999-09-05 21:01:03 +00:00
|
|
|
if (rxstat & SIS_RXSTAT_COLL)
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_discard_rxbuf(rxd);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a new receive buffer to the ring. */
|
|
|
|
m = rxd->rx_m;
|
|
|
|
if (sis_newbuf(sc, rxd) != 0) {
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_discard_rxbuf(rxd);
|
1999-09-05 21:01:03 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-09-01 18:28:08 +00:00
|
|
|
/* No errors; receive the packet. */
|
2010-09-01 19:33:40 +00:00
|
|
|
m->m_pkthdr.len = m->m_len = total_len;
|
|
|
|
#ifndef __NO_STRICT_ALIGNMENT
|
2001-11-28 16:10:37 +00:00
|
|
|
/*
|
2006-10-29 20:19:41 +00:00
|
|
|
* On architectures without alignment problems we try to
|
2001-11-28 16:10:37 +00:00
|
|
|
* allocate a new buffer for the receive ring, and pass up
|
|
|
|
* the one where the packet is already, saving the expensive
|
2010-09-01 19:33:40 +00:00
|
|
|
* copy operation.
|
2001-11-28 16:10:37 +00:00
|
|
|
*/
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_fixup_rx(m);
|
2001-11-28 16:10:37 +00:00
|
|
|
#endif
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
|
2002-11-14 23:49:09 +00:00
|
|
|
m->m_pkthdr.rcvif = ifp;
|
|
|
|
|
2003-11-14 19:00:32 +00:00
|
|
|
SIS_UNLOCK(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
if_input(ifp, m);
|
2003-11-14 19:00:32 +00:00
|
|
|
SIS_LOCK(sc);
|
2009-05-30 15:14:44 +00:00
|
|
|
rx_npkts++;
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
if (prog > 0) {
|
|
|
|
sc->sis_rx_cons = rx_cons;
|
|
|
|
bus_dmamap_sync(sc->sis_rx_list_tag, sc->sis_rx_list_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
|
|
|
}
|
|
|
|
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A frame was downloaded to the chip. It's safe for us to clean up
|
|
|
|
* the list buffers.
|
|
|
|
*/
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_txeof(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-01 19:33:40 +00:00
|
|
|
struct sis_desc *cur_tx;
|
|
|
|
struct sis_txdesc *txd;
|
|
|
|
uint32_t cons, txstat;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-01-05 10:11:37 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
2010-09-01 19:33:40 +00:00
|
|
|
|
|
|
|
cons = sc->sis_tx_cons;
|
|
|
|
if (cons == sc->sis_tx_prod)
|
|
|
|
return;
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_sync(sc->sis_tx_list_tag, sc->sis_tx_list_map,
|
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Go through our tx list and free mbufs for those
|
|
|
|
* frames that have been transmitted.
|
|
|
|
*/
|
2010-09-01 19:33:40 +00:00
|
|
|
for (; cons != sc->sis_tx_prod; SIS_INC(cons, SIS_TX_LIST_CNT)) {
|
|
|
|
cur_tx = &sc->sis_tx_list[cons];
|
|
|
|
txstat = le32toh(cur_tx->sis_cmdsts);
|
|
|
|
if ((txstat & SIS_CMDSTS_OWN) != 0)
|
1999-09-05 21:01:03 +00:00
|
|
|
break;
|
2010-09-01 19:33:40 +00:00
|
|
|
txd = &sc->sis_txdesc[cons];
|
|
|
|
if (txd->tx_m != NULL) {
|
|
|
|
bus_dmamap_sync(sc->sis_tx_tag, txd->tx_dmamap,
|
|
|
|
BUS_DMASYNC_POSTWRITE);
|
|
|
|
bus_dmamap_unload(sc->sis_tx_tag, txd->tx_dmamap);
|
|
|
|
m_freem(txd->tx_m);
|
|
|
|
txd->tx_m = NULL;
|
|
|
|
if ((txstat & SIS_CMDSTS_PKT_OK) != 0) {
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
|
|
|
|
if_inc_counter(ifp, IFCOUNTER_COLLISIONS,
|
|
|
|
(txstat & SIS_TXSTAT_COLLCNT) >> 16);
|
2010-09-01 19:33:40 +00:00
|
|
|
} else {
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
|
2010-09-01 19:33:40 +00:00
|
|
|
if (txstat & SIS_TXSTAT_EXCESSCOLLS)
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
|
2010-09-01 19:33:40 +00:00
|
|
|
if (txstat & SIS_TXSTAT_OUTOFWINCOLL)
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 1);
|
2010-09-01 19:33:40 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
2010-09-01 19:33:40 +00:00
|
|
|
sc->sis_tx_cnt--;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
|
2002-06-30 21:59:08 +00:00
|
|
|
}
|
2010-09-01 19:33:40 +00:00
|
|
|
sc->sis_tx_cons = cons;
|
|
|
|
if (sc->sis_tx_cnt == 0)
|
|
|
|
sc->sis_watchdog_timer = 0;
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_tick(void *xsc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
struct mii_data *mii;
|
|
|
|
|
|
|
|
sc = xsc;
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
2000-08-22 23:26:51 +00:00
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
|
|
|
mii_tick(mii);
|
2007-02-24 14:27:36 +00:00
|
|
|
sis_watchdog(sc);
|
2010-09-02 18:10:11 +00:00
|
|
|
if ((sc->sis_flags & SIS_FLAG_LINK) == 0)
|
2010-09-01 21:42:19 +00:00
|
|
|
sis_miibus_statchg(sc->sis_dev);
|
2003-09-05 22:33:44 +00:00
|
|
|
callout_reset(&sc->sis_stat_ch, hz, sis_tick, sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
static poll_handler_t sis_poll;
|
|
|
|
|
2009-05-30 15:14:44 +00:00
|
|
|
static int
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_poll(if_t ifp, enum poll_cmd cmd, int count)
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
struct sis_softc *sc = if_getsoftc(ifp);
|
2009-05-30 15:14:44 +00:00
|
|
|
int rx_npkts = 0;
|
2001-12-15 02:51:21 +00:00
|
|
|
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
SIS_LOCK(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING)) {
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
SIS_UNLOCK(sc);
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On the sis, reading the status register also clears it.
|
|
|
|
* So before returning to intr mode we must make sure that all
|
|
|
|
* possible pending sources of interrupts have been served.
|
|
|
|
* In practice this means run to completion the *eof routines,
|
|
|
|
* and then call the interrupt routine
|
|
|
|
*/
|
|
|
|
sc->rxcycles = count;
|
2009-05-30 15:14:44 +00:00
|
|
|
rx_npkts = sis_rxeof(sc);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
sis_txeof(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
if (!if_sendq_empty(ifp))
|
2005-01-05 10:04:45 +00:00
|
|
|
sis_startl(ifp);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
|
|
|
|
if (sc->rxcycles > 0 || cmd == POLL_AND_CHECK_STATUS) {
|
2010-09-01 19:53:15 +00:00
|
|
|
uint32_t status;
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
|
|
|
|
/* Reading the ISR register clears all interrupts. */
|
|
|
|
status = CSR_READ_4(sc, SIS_ISR);
|
|
|
|
|
|
|
|
if (status & (SIS_ISR_RX_ERR|SIS_ISR_RX_OFLOW))
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
|
|
|
|
if (status & (SIS_ISR_RX_IDLE))
|
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
|
|
|
|
|
|
|
|
if (status & SIS_ISR_SYSERR) {
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
|
2005-01-05 10:11:37 +00:00
|
|
|
sis_initl(sc);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
}
|
|
|
|
}
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
SIS_UNLOCK(sc);
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
}
|
|
|
|
#endif /* DEVICE_POLLING */
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_intr(void *arg)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-01 19:53:15 +00:00
|
|
|
uint32_t status;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
sc = arg;
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2001-11-27 16:29:11 +00:00
|
|
|
SIS_LOCK(sc);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getcapenable(ifp) & IFCAP_POLLING) {
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
return;
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
}
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
#endif
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
|
2010-09-01 21:42:19 +00:00
|
|
|
/* Reading the ISR register clears all interrupts. */
|
|
|
|
status = CSR_READ_4(sc, SIS_ISR);
|
|
|
|
if ((status & SIS_INTRS) == 0) {
|
|
|
|
/* Not ours. */
|
|
|
|
SIS_UNLOCK(sc);
|
2010-10-20 00:19:25 +00:00
|
|
|
return;
|
2010-09-01 21:42:19 +00:00
|
|
|
}
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/* Disable interrupts. */
|
|
|
|
CSR_WRITE_4(sc, SIS_IER, 0);
|
|
|
|
|
2010-09-01 21:42:19 +00:00
|
|
|
for (;(status & SIS_INTRS) != 0;) {
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0)
|
2010-10-20 00:19:25 +00:00
|
|
|
break;
|
2001-11-27 16:29:11 +00:00
|
|
|
if (status &
|
|
|
|
(SIS_ISR_TX_DESC_OK | SIS_ISR_TX_ERR |
|
2010-09-01 18:28:08 +00:00
|
|
|
SIS_ISR_TX_OK | SIS_ISR_TX_IDLE) )
|
1999-09-05 21:01:03 +00:00
|
|
|
sis_txeof(sc);
|
|
|
|
|
2009-02-13 02:08:20 +00:00
|
|
|
if (status & (SIS_ISR_RX_DESC_OK | SIS_ISR_RX_OK |
|
|
|
|
SIS_ISR_RX_ERR | SIS_ISR_RX_IDLE))
|
1999-09-05 21:01:03 +00:00
|
|
|
sis_rxeof(sc);
|
|
|
|
|
2009-02-13 02:08:20 +00:00
|
|
|
if (status & SIS_ISR_RX_OFLOW)
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
|
2001-11-27 16:29:11 +00:00
|
|
|
|
|
|
|
if (status & (SIS_ISR_RX_IDLE))
|
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
if (status & SIS_ISR_SYSERR) {
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
|
2005-01-05 10:11:37 +00:00
|
|
|
sis_initl(sc);
|
2010-09-01 21:42:19 +00:00
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
return;
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
2010-09-01 21:42:19 +00:00
|
|
|
status = CSR_READ_4(sc, SIS_ISR);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
|
2010-10-20 00:19:25 +00:00
|
|
|
/* Re-enable interrupts. */
|
|
|
|
CSR_WRITE_4(sc, SIS_IER, 1);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (!if_sendq_empty(ifp))
|
2010-10-20 00:19:25 +00:00
|
|
|
sis_startl(ifp);
|
|
|
|
}
|
2000-10-13 17:54:19 +00:00
|
|
|
|
2005-01-07 00:01:43 +00:00
|
|
|
SIS_UNLOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
|
|
|
|
* pointers to the fragment pointers.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2010-09-01 19:33:40 +00:00
|
|
|
sis_encap(struct sis_softc *sc, struct mbuf **m_head)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m;
|
2010-09-01 19:33:40 +00:00
|
|
|
struct sis_txdesc *txd;
|
|
|
|
struct sis_desc *f;
|
|
|
|
bus_dma_segment_t segs[SIS_MAXTXSEGS];
|
|
|
|
bus_dmamap_t map;
|
|
|
|
int error, i, frag, nsegs, prod;
|
2010-09-02 18:10:11 +00:00
|
|
|
int padlen;
|
2010-09-01 19:33:40 +00:00
|
|
|
|
|
|
|
prod = sc->sis_tx_prod;
|
|
|
|
txd = &sc->sis_txdesc[prod];
|
2010-09-02 18:10:11 +00:00
|
|
|
if ((sc->sis_flags & SIS_FLAG_MANUAL_PAD) != 0 &&
|
|
|
|
(*m_head)->m_pkthdr.len < SIS_MIN_FRAMELEN) {
|
|
|
|
m = *m_head;
|
|
|
|
padlen = SIS_MIN_FRAMELEN - m->m_pkthdr.len;
|
|
|
|
if (M_WRITABLE(m) == 0) {
|
|
|
|
/* Get a writable copy. */
|
2012-12-04 09:32:43 +00:00
|
|
|
m = m_dup(*m_head, M_NOWAIT);
|
2010-09-02 18:10:11 +00:00
|
|
|
m_freem(*m_head);
|
|
|
|
if (m == NULL) {
|
|
|
|
*m_head = NULL;
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
|
|
|
*m_head = m;
|
|
|
|
}
|
|
|
|
if (m->m_next != NULL || M_TRAILINGSPACE(m) < padlen) {
|
2012-12-04 09:32:43 +00:00
|
|
|
m = m_defrag(m, M_NOWAIT);
|
2010-09-02 18:10:11 +00:00
|
|
|
if (m == NULL) {
|
|
|
|
m_freem(*m_head);
|
|
|
|
*m_head = NULL;
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Manually pad short frames, and zero the pad space
|
|
|
|
* to avoid leaking data.
|
|
|
|
*/
|
|
|
|
bzero(mtod(m, char *) + m->m_pkthdr.len, padlen);
|
|
|
|
m->m_pkthdr.len += padlen;
|
|
|
|
m->m_len = m->m_pkthdr.len;
|
|
|
|
*m_head = m;
|
|
|
|
}
|
2010-09-01 19:33:40 +00:00
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->sis_tx_tag, txd->tx_dmamap,
|
|
|
|
*m_head, segs, &nsegs, 0);
|
|
|
|
if (error == EFBIG) {
|
2012-12-04 09:32:43 +00:00
|
|
|
m = m_collapse(*m_head, M_NOWAIT, SIS_MAXTXSEGS);
|
2010-09-01 19:33:40 +00:00
|
|
|
if (m == NULL) {
|
|
|
|
m_freem(*m_head);
|
|
|
|
*m_head = NULL;
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
|
|
|
*m_head = m;
|
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->sis_tx_tag, txd->tx_dmamap,
|
|
|
|
*m_head, segs, &nsegs, 0);
|
|
|
|
if (error != 0) {
|
|
|
|
m_freem(*m_head);
|
|
|
|
*m_head = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
} else if (error != 0)
|
|
|
|
return (error);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Check for descriptor overruns. */
|
|
|
|
if (sc->sis_tx_cnt + nsegs > SIS_TX_LIST_CNT - 1) {
|
|
|
|
bus_dmamap_unload(sc->sis_tx_tag, txd->tx_dmamap);
|
2003-03-29 17:50:37 +00:00
|
|
|
return (ENOBUFS);
|
2010-09-01 19:33:40 +00:00
|
|
|
}
|
2003-03-29 17:50:37 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_sync(sc->sis_tx_tag, txd->tx_dmamap, BUS_DMASYNC_PREWRITE);
|
2003-03-29 17:50:37 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
frag = prod;
|
|
|
|
for (i = 0; i < nsegs; i++) {
|
|
|
|
f = &sc->sis_tx_list[prod];
|
|
|
|
if (i == 0)
|
|
|
|
f->sis_cmdsts = htole32(segs[i].ds_len |
|
|
|
|
SIS_CMDSTS_MORE);
|
|
|
|
else
|
|
|
|
f->sis_cmdsts = htole32(segs[i].ds_len |
|
|
|
|
SIS_CMDSTS_OWN | SIS_CMDSTS_MORE);
|
|
|
|
f->sis_ptr = htole32(SIS_ADDR_LO(segs[i].ds_addr));
|
|
|
|
SIS_INC(prod, SIS_TX_LIST_CNT);
|
|
|
|
sc->sis_tx_cnt++;
|
2003-03-29 17:50:37 +00:00
|
|
|
}
|
2010-09-01 18:28:08 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Update producer index. */
|
|
|
|
sc->sis_tx_prod = prod;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Remove MORE flag on the last descriptor. */
|
|
|
|
prod = (prod - 1) & (SIS_TX_LIST_CNT - 1);
|
|
|
|
f = &sc->sis_tx_list[prod];
|
|
|
|
f->sis_cmdsts &= ~htole32(SIS_CMDSTS_MORE);
|
|
|
|
|
|
|
|
/* Lastly transfer ownership of packet to the controller. */
|
|
|
|
f = &sc->sis_tx_list[frag];
|
|
|
|
f->sis_cmdsts |= htole32(SIS_CMDSTS_OWN);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
/* Swap the last and the first dmamaps. */
|
|
|
|
map = txd->tx_dmamap;
|
2010-09-02 00:44:05 +00:00
|
|
|
txd->tx_dmamap = sc->sis_txdesc[prod].tx_dmamap;
|
|
|
|
sc->sis_txdesc[prod].tx_dmamap = map;
|
2010-09-03 18:00:17 +00:00
|
|
|
sc->sis_txdesc[prod].tx_m = *m_head;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (0);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_start(if_t ifp)
|
2005-01-05 10:04:45 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
sc = if_getsoftc(ifp);
|
2005-01-05 10:04:45 +00:00
|
|
|
SIS_LOCK(sc);
|
|
|
|
sis_startl(ifp);
|
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_startl(if_t ifp)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2010-09-01 19:33:40 +00:00
|
|
|
struct mbuf *m_head;
|
|
|
|
int queued;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
sc = if_getsoftc(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-01-05 10:04:45 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getdrvflags(ifp) & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
|
2010-09-02 18:10:11 +00:00
|
|
|
IFF_DRV_RUNNING || (sc->sis_flags & SIS_FLAG_LINK) == 0)
|
2000-08-22 23:26:51 +00:00
|
|
|
return;
|
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
for (queued = 0; !if_sendq_empty(ifp) &&
|
2010-09-01 19:33:40 +00:00
|
|
|
sc->sis_tx_cnt < SIS_TX_LIST_CNT - 4;) {
|
2022-08-17 20:41:35 +00:00
|
|
|
m_head = if_dequeue(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
if (m_head == NULL)
|
|
|
|
break;
|
|
|
|
|
2010-09-01 19:33:40 +00:00
|
|
|
if (sis_encap(sc, &m_head) != 0) {
|
|
|
|
if (m_head == NULL)
|
|
|
|
break;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_sendq_prepend(ifp, m_head);
|
|
|
|
if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
|
1999-09-05 21:01:03 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-10-08 16:14:42 +00:00
|
|
|
queued++;
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* If there's a BPF listener, bounce a copy of this frame
|
|
|
|
* to him.
|
|
|
|
*/
|
2002-11-14 23:49:09 +00:00
|
|
|
BPF_MTAP(ifp, m_head);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2004-10-08 16:14:42 +00:00
|
|
|
if (queued) {
|
|
|
|
/* Transmit */
|
2010-09-01 19:33:40 +00:00
|
|
|
bus_dmamap_sync(sc->sis_tx_list_tag, sc->sis_tx_list_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
2004-10-08 16:14:42 +00:00
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_TX_ENABLE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2004-10-08 16:14:42 +00:00
|
|
|
/*
|
|
|
|
* Set a timeout in case the chip goes out to lunch.
|
|
|
|
*/
|
2007-02-24 14:27:36 +00:00
|
|
|
sc->sis_watchdog_timer = 5;
|
2004-10-08 16:14:42 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 10:11:37 +00:00
|
|
|
sis_init(void *xsc)
|
|
|
|
{
|
|
|
|
struct sis_softc *sc = xsc;
|
|
|
|
|
|
|
|
SIS_LOCK(sc);
|
2005-01-05 10:26:12 +00:00
|
|
|
sis_initl(sc);
|
2005-01-05 10:11:37 +00:00
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-01-05 10:26:12 +00:00
|
|
|
sis_initl(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp = sc->sis_ifp;
|
1999-09-05 21:01:03 +00:00
|
|
|
struct mii_data *mii;
|
2010-09-02 17:51:41 +00:00
|
|
|
uint8_t *eaddr;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-01-05 10:11:37 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0)
|
2010-09-01 22:16:25 +00:00
|
|
|
return;
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Cancel pending I/O and free all RX/TX buffers.
|
|
|
|
*/
|
|
|
|
sis_stop(sc);
|
2010-09-01 22:50:11 +00:00
|
|
|
/*
|
|
|
|
* Reset the chip to a known state.
|
|
|
|
*/
|
|
|
|
sis_reset(sc);
|
2003-09-03 07:40:04 +00:00
|
|
|
#ifdef notyet
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr >= NS_SRR_16A) {
|
|
|
|
/*
|
|
|
|
* Configure 400usec of interrupt holdoff. This is based
|
2022-06-04 14:56:18 +00:00
|
|
|
* on empirical tests on a Soekris 4801.
|
2003-09-03 07:40:04 +00:00
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, NS_IHR, 0x100 | 4);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
|
|
|
|
|
|
|
/* Set MAC address */
|
2022-08-17 20:41:35 +00:00
|
|
|
eaddr = if_getlladdr(sc->sis_ifp);
|
2000-07-06 06:02:04 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR0);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[0] | eaddr[1] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR1);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[2] | eaddr[3] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR2);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[4] | eaddr[5] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
} else {
|
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR0);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[0] | eaddr[1] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR1);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[2] | eaddr[3] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR2);
|
2010-09-02 17:51:41 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RXFILT_DATA, eaddr[4] | eaddr[5] << 8);
|
2000-07-06 06:02:04 +00:00
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-01-06 23:31:41 +00:00
|
|
|
/* Init circular TX/RX lists. */
|
|
|
|
if (sis_ring_init(sc) != 0) {
|
2006-09-15 10:40:54 +00:00
|
|
|
device_printf(sc->sis_dev,
|
2005-09-26 18:42:27 +00:00
|
|
|
"initialization failed: no memory for rx buffers\n");
|
1999-09-05 21:01:03 +00:00
|
|
|
sis_stop(sc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-03-18 04:46:17 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
2010-09-02 18:10:11 +00:00
|
|
|
if (sc->sis_manual_pad != 0)
|
|
|
|
sc->sis_flags |= SIS_FLAG_MANUAL_PAD;
|
|
|
|
else
|
|
|
|
sc->sis_flags &= ~SIS_FLAG_MANUAL_PAD;
|
|
|
|
}
|
|
|
|
|
2003-12-12 10:15:39 +00:00
|
|
|
/*
|
2005-01-06 23:49:26 +00:00
|
|
|
* Short Cable Receive Errors (MP21.E)
|
|
|
|
* also: Page 78 of the DP83815 data sheet (september 2002 version)
|
2003-12-12 10:15:39 +00:00
|
|
|
* recommends the following register settings "for optimum
|
2008-07-30 17:28:49 +00:00
|
|
|
* performance." for rev 15C. Set this also for 15D parts as
|
|
|
|
* they require it in practice.
|
2003-12-12 10:15:39 +00:00
|
|
|
*/
|
2005-01-06 23:49:26 +00:00
|
|
|
if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr <= NS_SRR_15D) {
|
2003-12-12 10:15:39 +00:00
|
|
|
CSR_WRITE_4(sc, NS_PHY_PAGE, 0x0001);
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_CR, 0x189C);
|
2008-07-30 17:28:49 +00:00
|
|
|
/* set val for c2 */
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_TDATA, 0x0000);
|
|
|
|
/* load/kill c2 */
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_DSPCFG, 0x5040);
|
|
|
|
/* rais SD off, from 4 to c */
|
|
|
|
CSR_WRITE_4(sc, NS_PHY_SDCFG, 0x008C);
|
2003-12-12 10:15:39 +00:00
|
|
|
CSR_WRITE_4(sc, NS_PHY_PAGE, 0);
|
|
|
|
}
|
|
|
|
|
2011-01-18 17:50:14 +00:00
|
|
|
sis_rxfilter(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Load the address of the RX and TX lists.
|
|
|
|
*/
|
2010-09-01 19:33:40 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_RX_LISTPTR, SIS_ADDR_LO(sc->sis_rx_paddr));
|
|
|
|
CSR_WRITE_4(sc, SIS_TX_LISTPTR, SIS_ADDR_LO(sc->sis_tx_paddr));
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-01-10 08:12:20 +00:00
|
|
|
/* SIS_CFG_EDB_MASTER_EN indicates the EDB bus is used instead of
|
|
|
|
* the PCI bus. When this bit is set, the Max DMA Burst Size
|
|
|
|
* for TX/RX DMA should be no larger than 16 double words.
|
|
|
|
*/
|
|
|
|
if (CSR_READ_4(sc, SIS_CFG) & SIS_CFG_EDB_MASTER_EN) {
|
|
|
|
CSR_WRITE_4(sc, SIS_RX_CFG, SIS_RXCFG64);
|
|
|
|
} else {
|
|
|
|
CSR_WRITE_4(sc, SIS_RX_CFG, SIS_RXCFG256);
|
|
|
|
}
|
|
|
|
|
2001-12-05 09:34:28 +00:00
|
|
|
/* Accept Long Packets for VLAN support */
|
|
|
|
SIS_SETBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_JABBER);
|
|
|
|
|
2010-09-01 21:42:19 +00:00
|
|
|
/*
|
|
|
|
* Assume 100Mbps link, actual MAC configuration is done
|
|
|
|
* after getting a valid link.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, SIS_TX_CFG, SIS_TXCFG_100);
|
2003-08-19 16:57:00 +00:00
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Enable interrupts.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, SIS_IMR, SIS_INTRS);
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
/*
|
|
|
|
* ... only enable interrupts if we are not polling, make sure
|
|
|
|
* they are off otherwise.
|
|
|
|
*/
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getcapenable(ifp) & IFCAP_POLLING)
|
Device Polling code for -current.
Non-SMP, i386-only, no polling in the idle loop at the moment.
To use this code you must compile a kernel with
options DEVICE_POLLING
and at runtime enable polling with
sysctl kern.polling.enable=1
The percentage of CPU reserved to userland can be set with
sysctl kern.polling.user_frac=NN (default is 50)
while the remainder is used by polling device drivers and netisr's.
These are the only two variables that you should need to touch. There
are a few more parameters in kern.polling but the default values
are adequate for all purposes. See the code in kern_poll.c for
more details on them.
Polling in the idle loop will be implemented shortly by introducing
a kernel thread which does the job. Until then, the amount of CPU
dedicated to polling will never exceed (100-user_frac).
The equivalent (actually, better) code for -stable is at
http://info.iet.unipi.it/~luigi/polling/
and also supports polling in the idle loop.
NOTE to Alpha developers:
There is really nothing in this code that is i386-specific.
If you move the 2 lines supporting the new option from
sys/conf/{files,options}.i386 to sys/conf/{files,options} I am
pretty sure that this should work on the Alpha as well, just that
I do not have a suitable test box to try it. If someone feels like
trying it, I would appreciate it.
NOTE to other developers:
sure some things could be done better, and as always I am open to
constructive criticism, which a few of you have already given and
I greatly appreciated.
However, before proposing radical architectural changes, please
take some time to possibly try out this code, or at the very least
read the comments in kern_poll.c, especially re. the reason why I
am using a soft netisr and cannot (I believe) replace it with a
simple timeout.
Quick description of files touched by this commit:
sys/conf/files.i386
new file kern/kern_poll.c
sys/conf/options.i386
new option
sys/i386/i386/trap.c
poll in trap (disabled by default)
sys/kern/kern_clock.c
initialization and hardclock hooks.
sys/kern/kern_intr.c
minor swi_net changes
sys/kern/kern_poll.c
the bulk of the code.
sys/net/if.h
new flag
sys/net/if_var.h
declaration for functions used in device drivers.
sys/net/netisr.h
NETISR_POLL
sys/dev/fxp/if_fxp.c
sys/dev/fxp/if_fxpvar.h
sys/pci/if_dc.c
sys/pci/if_dcreg.h
sys/pci/if_sis.c
sys/pci/if_sisreg.h
device driver modifications
2001-12-14 17:56:12 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_IER, 0);
|
|
|
|
else
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
#endif
|
1999-09-05 21:01:03 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_IER, 1);
|
|
|
|
|
2010-09-01 21:42:19 +00:00
|
|
|
/* Clear MAC disable. */
|
|
|
|
SIS_CLRBIT(sc, SIS_CSR, SIS_CSR_TX_DISABLE | SIS_CSR_RX_DISABLE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
sc->sis_flags &= ~SIS_FLAG_LINK;
|
1999-09-05 21:01:03 +00:00
|
|
|
mii_mediachg(mii);
|
2000-08-22 23:26:51 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
|
|
|
|
if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 21:42:19 +00:00
|
|
|
callout_reset(&sc->sis_stat_ch, hz, sis_tick, sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set media options.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_ifmedia_upd(if_t ifp)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2000-08-22 23:26:51 +00:00
|
|
|
struct mii_data *mii;
|
- Remove attempts to implement setting of BMCR_LOOP/MIIF_NOLOOP
(reporting IFM_LOOP based on BMCR_LOOP is left in place though as
it might provide useful for debugging). For most mii(4) drivers it
was unclear whether the PHYs driven by them actually support
loopback or not. Moreover, typically loopback mode also needs to
be activated on the MAC, which none of the Ethernet drivers using
mii(4) implements. Given that loopback media has no real use (and
obviously hardly had a chance to actually work) besides for driver
development (which just loopback mode should be sufficient for
though, i.e one doesn't necessary need support for loopback media)
support for it is just dropped as both NetBSD and OpenBSD already
did quite some time ago.
- Let mii_phy_add_media() also announce the support of IFM_NONE.
- Restructure the PHY entry points to use a structure of entry points
instead of discrete function pointers, and extend this to include
a "reset" entry point. Make sure any PHY-specific reset routine is
always used, and provide one for lxtphy(4) which disables MII
interrupts (as is done for a few other PHYs we have drivers for).
This includes changing NIC drivers which previously just called the
generic mii_phy_reset() to now actually call the PHY-specific reset
routine, which might be crucial in some cases. While at it, the
redundant checks in these NIC drivers for mii->mii_instance not being
zero before calling the reset routines were removed because as soon
as one PHY driver attaches mii->mii_instance is incremented and we
hardly can end up in their media change callbacks etc if no PHY driver
has attached as mii_attach() would have failed in that case and not
attach a miibus(4) instance.
Consequently, NIC drivers now no longer should call mii_phy_reset()
directly, so it was removed from EXPORT_SYMS.
- Add a mii_phy_dev_attach() as a companion helper to mii_phy_dev_probe().
The purpose of that function is to perform the common steps to attach
a PHY driver instance and to hook it up to the miibus(4) instance and to
optionally also handle the probing, addition and initialization of the
supported media. So all a PHY driver without any special requirements
has to do in its bus attach method is to call mii_phy_dev_attach()
along with PHY-specific MIIF_* flags, a pointer to its PHY functions
and the add_media set to one. All PHY drivers were updated to take
advantage of mii_phy_dev_attach() as appropriate. Along with these
changes the capability mask was added to the mii_softc structure so
PHY drivers taking advantage of mii_phy_dev_attach() but still
handling media on their own do not need to fiddle with the MII attach
arguments anyway.
- Keep track of the PHY offset in the mii_softc structure. This is done
for compatibility with NetBSD/OpenBSD.
- Keep track of the PHY's OUI, model and revision in the mii_softc
structure. Several PHY drivers require this information also after
attaching and previously had to wrap their own softc around mii_softc.
NetBSD/OpenBSD also keep track of the model and revision on their
mii_softc structure. All PHY drivers were updated to take advantage
as appropriate.
- Convert the mebers of the MII data structure to unsigned where
appropriate. This is partly inspired by NetBSD/OpenBSD.
- According to IEEE 802.3-2002 the bits actually have to be reversed
when mapping an OUI to the MII ID registers. All PHY drivers and
miidevs where changed as necessary. Actually this now again allows to
largely share miidevs with NetBSD, which fixed this problem already
9 years ago. Consequently miidevs was synced as far as possible.
- Add MIIF_NOMANPAUSE and mii_phy_flowstatus() calls to drivers that
weren't explicitly converted to support flow control before. It's
unclear whether flow control actually works with these but typically
it should and their net behavior should be more correct with these
changes in place than without if the MAC driver sets MIIF_DOPAUSE.
Obtained from: NetBSD (partially)
Reviewed by: yongari (earlier version), silence on arch@ and net@
2011-05-03 19:51:29 +00:00
|
|
|
struct mii_softc *miisc;
|
2010-09-01 21:44:36 +00:00
|
|
|
int error;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
sc = if_getsoftc(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_LOCK(sc);
|
2000-08-22 23:26:51 +00:00
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
- Remove attempts to implement setting of BMCR_LOOP/MIIF_NOLOOP
(reporting IFM_LOOP based on BMCR_LOOP is left in place though as
it might provide useful for debugging). For most mii(4) drivers it
was unclear whether the PHYs driven by them actually support
loopback or not. Moreover, typically loopback mode also needs to
be activated on the MAC, which none of the Ethernet drivers using
mii(4) implements. Given that loopback media has no real use (and
obviously hardly had a chance to actually work) besides for driver
development (which just loopback mode should be sufficient for
though, i.e one doesn't necessary need support for loopback media)
support for it is just dropped as both NetBSD and OpenBSD already
did quite some time ago.
- Let mii_phy_add_media() also announce the support of IFM_NONE.
- Restructure the PHY entry points to use a structure of entry points
instead of discrete function pointers, and extend this to include
a "reset" entry point. Make sure any PHY-specific reset routine is
always used, and provide one for lxtphy(4) which disables MII
interrupts (as is done for a few other PHYs we have drivers for).
This includes changing NIC drivers which previously just called the
generic mii_phy_reset() to now actually call the PHY-specific reset
routine, which might be crucial in some cases. While at it, the
redundant checks in these NIC drivers for mii->mii_instance not being
zero before calling the reset routines were removed because as soon
as one PHY driver attaches mii->mii_instance is incremented and we
hardly can end up in their media change callbacks etc if no PHY driver
has attached as mii_attach() would have failed in that case and not
attach a miibus(4) instance.
Consequently, NIC drivers now no longer should call mii_phy_reset()
directly, so it was removed from EXPORT_SYMS.
- Add a mii_phy_dev_attach() as a companion helper to mii_phy_dev_probe().
The purpose of that function is to perform the common steps to attach
a PHY driver instance and to hook it up to the miibus(4) instance and to
optionally also handle the probing, addition and initialization of the
supported media. So all a PHY driver without any special requirements
has to do in its bus attach method is to call mii_phy_dev_attach()
along with PHY-specific MIIF_* flags, a pointer to its PHY functions
and the add_media set to one. All PHY drivers were updated to take
advantage of mii_phy_dev_attach() as appropriate. Along with these
changes the capability mask was added to the mii_softc structure so
PHY drivers taking advantage of mii_phy_dev_attach() but still
handling media on their own do not need to fiddle with the MII attach
arguments anyway.
- Keep track of the PHY offset in the mii_softc structure. This is done
for compatibility with NetBSD/OpenBSD.
- Keep track of the PHY's OUI, model and revision in the mii_softc
structure. Several PHY drivers require this information also after
attaching and previously had to wrap their own softc around mii_softc.
NetBSD/OpenBSD also keep track of the model and revision on their
mii_softc structure. All PHY drivers were updated to take advantage
as appropriate.
- Convert the mebers of the MII data structure to unsigned where
appropriate. This is partly inspired by NetBSD/OpenBSD.
- According to IEEE 802.3-2002 the bits actually have to be reversed
when mapping an OUI to the MII ID registers. All PHY drivers and
miidevs where changed as necessary. Actually this now again allows to
largely share miidevs with NetBSD, which fixed this problem already
9 years ago. Consequently miidevs was synced as far as possible.
- Add MIIF_NOMANPAUSE and mii_phy_flowstatus() calls to drivers that
weren't explicitly converted to support flow control before. It's
unclear whether flow control actually works with these but typically
it should and their net behavior should be more correct with these
changes in place than without if the MAC driver sets MIIF_DOPAUSE.
Obtained from: NetBSD (partially)
Reviewed by: yongari (earlier version), silence on arch@ and net@
2011-05-03 19:51:29 +00:00
|
|
|
LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
|
|
|
|
PHY_RESET(miisc);
|
2010-09-01 21:44:36 +00:00
|
|
|
error = mii_mediachg(mii);
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_UNLOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 21:44:36 +00:00
|
|
|
return (error);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Report current media status.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
struct mii_data *mii;
|
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
sc = if_getsoftc(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_LOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
|
|
|
mii_pollstat(mii);
|
|
|
|
ifmr->ifm_active = mii->mii_media_active;
|
|
|
|
ifmr->ifm_status = mii->mii_media_status;
|
2011-10-17 19:49:00 +00:00
|
|
|
SIS_UNLOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static int
|
2022-08-17 20:41:35 +00:00
|
|
|
sis_ioctl(if_t ifp, u_long command, caddr_t data)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
struct sis_softc *sc = if_getsoftc(ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
struct ifreq *ifr = (struct ifreq *) data;
|
|
|
|
struct mii_data *mii;
|
2010-09-03 00:34:45 +00:00
|
|
|
int error = 0, mask;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
switch (command) {
|
1999-09-05 21:01:03 +00:00
|
|
|
case SIOCSIFFLAGS:
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_LOCK(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
if (if_getflags(ifp) & IFF_UP) {
|
|
|
|
if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0 &&
|
|
|
|
((if_getflags(ifp) ^ sc->sis_if_flags) &
|
2011-01-18 17:50:14 +00:00
|
|
|
(IFF_PROMISC | IFF_ALLMULTI)) != 0)
|
|
|
|
sis_rxfilter(sc);
|
|
|
|
else
|
2010-09-01 22:08:23 +00:00
|
|
|
sis_initl(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
} else if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
|
2005-01-05 22:28:24 +00:00
|
|
|
sis_stop(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
sc->sis_if_flags = if_getflags(ifp);
|
2005-09-26 18:42:27 +00:00
|
|
|
SIS_UNLOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
2001-08-15 17:38:43 +00:00
|
|
|
SIS_LOCK(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0)
|
2015-01-12 07:37:06 +00:00
|
|
|
sis_rxfilter(sc);
|
2001-08-15 17:38:43 +00:00
|
|
|
SIS_UNLOCK(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
break;
|
|
|
|
case SIOCGIFMEDIA:
|
|
|
|
case SIOCSIFMEDIA:
|
|
|
|
mii = device_get_softc(sc->sis_miibus);
|
|
|
|
error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
|
|
|
|
break;
|
2004-04-11 20:34:08 +00:00
|
|
|
case SIOCSIFCAP:
|
2010-09-03 00:34:45 +00:00
|
|
|
SIS_LOCK(sc);
|
2022-08-17 20:41:35 +00:00
|
|
|
mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2010-09-03 00:34:45 +00:00
|
|
|
if ((mask & IFCAP_POLLING) != 0 &&
|
2022-08-17 20:41:35 +00:00
|
|
|
(IFCAP_POLLING & if_getcapabilities(ifp)) != 0) {
|
|
|
|
if_togglecapenable(ifp, IFCAP_POLLING);
|
|
|
|
if ((IFCAP_POLLING & if_getcapenable(ifp)) != 0) {
|
2010-09-03 00:34:45 +00:00
|
|
|
error = ether_poll_register(sis_poll, ifp);
|
|
|
|
if (error != 0) {
|
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Disable interrupts. */
|
|
|
|
CSR_WRITE_4(sc, SIS_IER, 0);
|
|
|
|
} else {
|
|
|
|
error = ether_poll_deregister(ifp);
|
|
|
|
/* Enable interrupts. */
|
|
|
|
CSR_WRITE_4(sc, SIS_IER, 1);
|
|
|
|
}
|
Big polling(4) cleanup.
o Axe poll in trap.
o Axe IFF_POLLING flag from if_flags.
o Rework revision 1.21 (Giant removal), in such a way that
poll_mtx is not dropped during call to polling handler.
This fixes problem with idle polling.
o Make registration and deregistration from polling in a
functional way, insted of next tick/interrupt.
o Obsolete kern.polling.enable. Polling is turned on/off
with ifconfig.
Detailed kern_poll.c changes:
- Remove polling handler flags, introduced in 1.21. The are not
needed now.
- Forget and do not check if_flags, if_capenable and if_drv_flags.
- Call all registered polling handlers unconditionally.
- Do not drop poll_mtx, when entering polling handlers.
- In ether_poll() NET_LOCK_GIANT prior to locking poll_mtx.
- In netisr_poll() axe the block, where polling code asks drivers
to unregister.
- In netisr_poll() and ether_poll() do polling always, if any
handlers are present.
- In ether_poll_[de]register() remove a lot of error hiding code. Assert
that arguments are correct, instead.
- In ether_poll_[de]register() use standard return values in case of
error or success.
- Introduce poll_switch() that is a sysctl handler for kern.polling.enable.
poll_switch() goes through interface list and enabled/disables polling.
A message that kern.polling.enable is deprecated is printed.
Detailed driver changes:
- On attach driver announces IFCAP_POLLING in if_capabilities, but
not in if_capenable.
- On detach driver calls ether_poll_deregister() if polling is enabled.
- In polling handler driver obtains its lock and checks IFF_DRV_RUNNING
flag. If there is no, then unlocks and returns.
- In ioctl handler driver checks for IFCAP_POLLING flag requested to
be set or cleared. Driver first calls ether_poll_[de]register(), then
obtains driver lock and [dis/en]ables interrupts.
- In interrupt handler driver checks IFCAP_POLLING flag in if_capenable.
If present, then returns.This is important to protect from spurious
interrupts.
Reviewed by: ru, sam, jhb
2005-10-01 18:56:19 +00:00
|
|
|
}
|
|
|
|
#endif /* DEVICE_POLLING */
|
2010-09-03 00:34:45 +00:00
|
|
|
if ((mask & IFCAP_WOL) != 0 &&
|
2022-08-17 20:41:35 +00:00
|
|
|
(if_getcapabilities(ifp) & IFCAP_WOL) != 0) {
|
2010-09-03 00:34:45 +00:00
|
|
|
if ((mask & IFCAP_WOL_UCAST) != 0)
|
2022-08-17 20:41:35 +00:00
|
|
|
if_togglecapenable(ifp, IFCAP_WOL_UCAST);
|
2010-09-03 00:34:45 +00:00
|
|
|
if ((mask & IFCAP_WOL_MCAST) != 0)
|
2022-08-17 20:41:35 +00:00
|
|
|
if_togglecapenable(ifp, IFCAP_WOL_MCAST);
|
2010-09-03 00:34:45 +00:00
|
|
|
if ((mask & IFCAP_WOL_MAGIC) != 0)
|
2022-08-17 20:41:35 +00:00
|
|
|
if_togglecapenable(ifp, IFCAP_WOL_MAGIC);
|
2010-09-03 00:34:45 +00:00
|
|
|
}
|
|
|
|
SIS_UNLOCK(sc);
|
2004-04-11 20:34:08 +00:00
|
|
|
break;
|
1999-09-05 21:01:03 +00:00
|
|
|
default:
|
2002-11-14 23:49:09 +00:00
|
|
|
error = ether_ioctl(ifp, command, data);
|
1999-09-05 21:01:03 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-09-01 18:39:35 +00:00
|
|
|
return (error);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2007-02-24 14:27:36 +00:00
|
|
|
sis_watchdog(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
|
2007-02-24 14:27:36 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
2000-10-13 17:54:19 +00:00
|
|
|
|
2007-02-24 14:27:36 +00:00
|
|
|
if (sc->sis_watchdog_timer == 0 || --sc->sis_watchdog_timer >0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
device_printf(sc->sis_dev, "watchdog timeout\n");
|
2014-09-18 20:09:35 +00:00
|
|
|
if_inc_counter(sc->sis_ifp, IFCOUNTER_OERRORS, 1);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(sc->sis_ifp, 0, IFF_DRV_RUNNING);
|
2005-01-05 10:11:37 +00:00
|
|
|
sis_initl(sc);
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if (!if_sendq_empty(sc->sis_ifp))
|
2007-02-24 14:27:36 +00:00
|
|
|
sis_startl(sc->sis_ifp);
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the adapter and free any mbufs allocated to the
|
|
|
|
* RX and TX lists.
|
|
|
|
*/
|
2002-08-23 23:19:25 +00:00
|
|
|
static void
|
2005-01-05 22:23:03 +00:00
|
|
|
sis_stop(struct sis_softc *sc)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-01 19:33:40 +00:00
|
|
|
struct sis_rxdesc *rxd;
|
|
|
|
struct sis_txdesc *txd;
|
|
|
|
int i;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2005-01-05 10:26:12 +00:00
|
|
|
SIS_LOCK_ASSERT(sc);
|
2010-09-01 21:42:19 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->sis_ifp;
|
2007-02-24 14:27:36 +00:00
|
|
|
sc->sis_watchdog_timer = 0;
|
1999-09-05 21:01:03 +00:00
|
|
|
|
2003-09-05 22:33:44 +00:00
|
|
|
callout_stop(&sc->sis_stat_ch);
|
2001-12-07 00:58:37 +00:00
|
|
|
|
2022-08-17 20:41:35 +00:00
|
|
|
if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
|
1999-09-05 21:01:03 +00:00
|
|
|
CSR_WRITE_4(sc, SIS_IER, 0);
|
|
|
|
CSR_WRITE_4(sc, SIS_IMR, 0);
|
2005-01-06 23:18:44 +00:00
|
|
|
CSR_READ_4(sc, SIS_ISR); /* clear any interrupts already pending */
|
1999-09-05 21:01:03 +00:00
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_TX_DISABLE|SIS_CSR_RX_DISABLE);
|
|
|
|
DELAY(1000);
|
|
|
|
CSR_WRITE_4(sc, SIS_TX_LISTPTR, 0);
|
|
|
|
CSR_WRITE_4(sc, SIS_RX_LISTPTR, 0);
|
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
sc->sis_flags &= ~SIS_FLAG_LINK;
|
2000-08-22 23:26:51 +00:00
|
|
|
|
1999-09-05 21:01:03 +00:00
|
|
|
/*
|
|
|
|
* Free data in the RX lists.
|
|
|
|
*/
|
2010-09-01 19:33:40 +00:00
|
|
|
for (i = 0; i < SIS_RX_LIST_CNT; i++) {
|
|
|
|
rxd = &sc->sis_rxdesc[i];
|
|
|
|
if (rxd->rx_m != NULL) {
|
|
|
|
bus_dmamap_sync(sc->sis_rx_tag, rxd->rx_dmamap,
|
|
|
|
BUS_DMASYNC_POSTREAD);
|
|
|
|
bus_dmamap_unload(sc->sis_rx_tag, rxd->rx_dmamap);
|
|
|
|
m_freem(rxd->rx_m);
|
|
|
|
rxd->rx_m = NULL;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the TX list buffers.
|
|
|
|
*/
|
2010-09-01 19:33:40 +00:00
|
|
|
for (i = 0; i < SIS_TX_LIST_CNT; i++) {
|
|
|
|
txd = &sc->sis_txdesc[i];
|
|
|
|
if (txd->tx_m != NULL) {
|
|
|
|
bus_dmamap_sync(sc->sis_tx_tag, txd->tx_dmamap,
|
|
|
|
BUS_DMASYNC_POSTWRITE);
|
|
|
|
bus_dmamap_unload(sc->sis_tx_tag, txd->tx_dmamap);
|
|
|
|
m_freem(txd->tx_m);
|
|
|
|
txd->tx_m = NULL;
|
|
|
|
}
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop all chip I/O so that the kernel's probe routines don't
|
|
|
|
* get confused by errant DMAs when rebooting.
|
|
|
|
*/
|
2009-02-10 23:17:20 +00:00
|
|
|
static int
|
2005-01-05 10:26:12 +00:00
|
|
|
sis_shutdown(device_t dev)
|
1999-09-05 21:01:03 +00:00
|
|
|
{
|
|
|
|
|
2010-09-03 00:34:45 +00:00
|
|
|
return (sis_suspend(dev));
|
1999-09-05 21:01:03 +00:00
|
|
|
}
|
2005-01-06 23:22:38 +00:00
|
|
|
|
2010-09-02 22:37:13 +00:00
|
|
|
static int
|
|
|
|
sis_suspend(device_t dev)
|
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
SIS_LOCK(sc);
|
|
|
|
sis_stop(sc);
|
2010-09-03 00:34:45 +00:00
|
|
|
sis_wol(sc);
|
2010-09-02 22:37:13 +00:00
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sis_resume(device_t dev)
|
|
|
|
{
|
|
|
|
struct sis_softc *sc;
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-02 22:37:13 +00:00
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
SIS_LOCK(sc);
|
|
|
|
ifp = sc->sis_ifp;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getflags(ifp) & IFF_UP) != 0) {
|
|
|
|
if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
|
2010-09-02 22:37:13 +00:00
|
|
|
sis_initl(sc);
|
|
|
|
}
|
|
|
|
SIS_UNLOCK(sc);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2010-09-03 00:34:45 +00:00
|
|
|
static void
|
|
|
|
sis_wol(struct sis_softc *sc)
|
|
|
|
{
|
2022-08-17 20:41:35 +00:00
|
|
|
if_t ifp;
|
2010-09-03 00:34:45 +00:00
|
|
|
uint32_t val;
|
|
|
|
uint16_t pmstat;
|
|
|
|
int pmc;
|
|
|
|
|
|
|
|
ifp = sc->sis_ifp;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL) == 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (sc->sis_type == SIS_TYPE_83815) {
|
|
|
|
/* Reset RXDP. */
|
|
|
|
CSR_WRITE_4(sc, SIS_RX_LISTPTR, 0);
|
|
|
|
|
|
|
|
/* Configure WOL events. */
|
|
|
|
CSR_READ_4(sc, NS_WCSR);
|
|
|
|
val = 0;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL_UCAST) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
val |= NS_WCSR_WAKE_UCAST;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL_MCAST) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
val |= NS_WCSR_WAKE_MCAST;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL_MAGIC) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
val |= NS_WCSR_WAKE_MAGIC;
|
|
|
|
CSR_WRITE_4(sc, NS_WCSR, val);
|
|
|
|
/* Enable PME and clear PMESTS. */
|
|
|
|
val = CSR_READ_4(sc, NS_CLKRUN);
|
|
|
|
val |= NS_CLKRUN_PMEENB | NS_CLKRUN_PMESTS;
|
|
|
|
CSR_WRITE_4(sc, NS_CLKRUN, val);
|
|
|
|
/* Enable silent RX mode. */
|
|
|
|
SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
|
|
|
|
} else {
|
2011-03-23 13:10:15 +00:00
|
|
|
if (pci_find_cap(sc->sis_dev, PCIY_PMG, &pmc) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
return;
|
|
|
|
val = 0;
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL_MAGIC) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
val |= SIS_PWRMAN_WOL_MAGIC;
|
|
|
|
CSR_WRITE_4(sc, SIS_PWRMAN_CTL, val);
|
|
|
|
/* Request PME. */
|
|
|
|
pmstat = pci_read_config(sc->sis_dev,
|
|
|
|
pmc + PCIR_POWER_STATUS, 2);
|
|
|
|
pmstat &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
|
2022-08-17 20:41:35 +00:00
|
|
|
if ((if_getcapenable(ifp) & IFCAP_WOL_MAGIC) != 0)
|
2010-09-03 00:34:45 +00:00
|
|
|
pmstat |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
|
|
|
|
pci_write_config(sc->sis_dev,
|
|
|
|
pmc + PCIR_POWER_STATUS, pmstat, 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-02 18:10:11 +00:00
|
|
|
static void
|
|
|
|
sis_add_sysctls(struct sis_softc *sc)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_list *ctx;
|
|
|
|
struct sysctl_oid_list *children;
|
|
|
|
|
|
|
|
ctx = device_get_sysctl_ctx(sc->sis_dev);
|
|
|
|
children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sis_dev));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlike most other controllers, NS DP83815/DP83816 controllers
|
|
|
|
* seem to pad with 0xFF when it encounter short frames. According
|
|
|
|
* to RFC 1042 the pad bytes should be 0x00. Turning this tunable
|
|
|
|
* on will have driver pad manully but it's disabled by default
|
|
|
|
* because it will consume extra CPU cycles for short frames.
|
|
|
|
*/
|
|
|
|
sc->sis_manual_pad = 0;
|
|
|
|
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "manual_pad",
|
2014-06-28 03:56:17 +00:00
|
|
|
CTLFLAG_RWTUN, &sc->sis_manual_pad, 0, "Manually pad short frames");
|
2010-09-02 18:10:11 +00:00
|
|
|
}
|
|
|
|
|
2005-01-06 23:22:38 +00:00
|
|
|
static device_method_t sis_methods[] = {
|
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, sis_probe),
|
|
|
|
DEVMETHOD(device_attach, sis_attach),
|
|
|
|
DEVMETHOD(device_detach, sis_detach),
|
|
|
|
DEVMETHOD(device_shutdown, sis_shutdown),
|
2010-09-02 22:37:13 +00:00
|
|
|
DEVMETHOD(device_suspend, sis_suspend),
|
|
|
|
DEVMETHOD(device_resume, sis_resume),
|
2005-01-06 23:22:38 +00:00
|
|
|
|
|
|
|
/* MII interface */
|
|
|
|
DEVMETHOD(miibus_readreg, sis_miibus_readreg),
|
|
|
|
DEVMETHOD(miibus_writereg, sis_miibus_writereg),
|
|
|
|
DEVMETHOD(miibus_statchg, sis_miibus_statchg),
|
|
|
|
|
2011-11-22 21:28:20 +00:00
|
|
|
DEVMETHOD_END
|
2005-01-06 23:22:38 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t sis_driver = {
|
|
|
|
"sis",
|
|
|
|
sis_methods,
|
|
|
|
sizeof(struct sis_softc)
|
|
|
|
};
|
|
|
|
|
2022-05-06 22:46:56 +00:00
|
|
|
DRIVER_MODULE(sis, pci, sis_driver, 0, 0);
|
2022-04-19 19:18:43 +00:00
|
|
|
DRIVER_MODULE(miibus, sis, miibus_driver, 0, 0);
|