2005-01-06 01:43:34 +00:00
|
|
|
/*-
|
2001-09-27 23:55:28 +00:00
|
|
|
* Copyright (c) 2001 Wind River Systems
|
|
|
|
* Copyright (c) 1997, 1998, 1999, 2001
|
|
|
|
* Bill Paul <wpaul@windriver.com>. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. 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-08-24 17:55:58 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Broadcom BCM570x family gigabit ethernet driver for FreeBSD.
|
2003-04-03 21:36:33 +00:00
|
|
|
*
|
2001-09-27 23:55:28 +00:00
|
|
|
* The Broadcom BCM5700 is based on technology originally developed by
|
|
|
|
* Alteon Networks as part of the Tigon I and Tigon II gigabit ethernet
|
|
|
|
* MAC chips. The BCM5700, sometimes refered to as the Tigon III, has
|
|
|
|
* two on-board MIPS R4000 CPUs and can have as much as 16MB of external
|
|
|
|
* SSRAM. The BCM5700 supports TCP, UDP and IP checksum offload, jumbo
|
|
|
|
* frames, highly configurable RX filtering, and 16 RX and TX queues
|
|
|
|
* (which, along with RX filter rules, can be used for QOS applications).
|
|
|
|
* Other features, such as TCP segmentation, may be available as part
|
|
|
|
* of value-added firmware updates. Unlike the Tigon I and Tigon II,
|
|
|
|
* firmware images can be stored in hardware and need not be compiled
|
|
|
|
* into the driver.
|
|
|
|
*
|
|
|
|
* The BCM5700 supports the PCI v2.2 and PCI-X v1.0 standards, and will
|
|
|
|
* function in a 32-bit/64-bit 33/66Mhz bus, or a 64-bit/133Mhz bus.
|
2004-10-30 14:54:51 +00:00
|
|
|
*
|
2001-09-27 23:55:28 +00:00
|
|
|
* The BCM5701 is a single-chip solution incorporating both the BCM5700
|
2002-03-22 06:45:40 +00:00
|
|
|
* MAC and a BCM5401 10/100/1000 PHY. Unlike the BCM5700, the BCM5701
|
2001-09-27 23:55:28 +00:00
|
|
|
* does not support external SSRAM.
|
|
|
|
*
|
|
|
|
* Broadcom also produces a variation of the BCM5700 under the "Altima"
|
|
|
|
* brand name, which is functionally similar but lacks PCI-X support.
|
|
|
|
*
|
|
|
|
* Without external SSRAM, you can only have at most 4 TX rings,
|
|
|
|
* and the use of the mini RX ring is disabled. This seems to imply
|
|
|
|
* that these features are simply not available on the BCM5701. As a
|
|
|
|
* result, this driver does not implement any support for the mini RX
|
|
|
|
* ring.
|
|
|
|
*/
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef HAVE_KERNEL_OPTION_HEADERS
|
|
|
|
#include "opt_device_polling.h"
|
|
|
|
#endif
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
#include <sys/param.h>
|
2003-07-25 19:42:44 +00:00
|
|
|
#include <sys/endian.h>
|
2001-09-27 23:55:28 +00:00
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/kernel.h>
|
2004-05-30 20:08:47 +00:00
|
|
|
#include <sys/module.h>
|
2001-09-27 23:55:28 +00:00
|
|
|
#include <sys/socket.h>
|
2006-09-23 18:55:49 +00:00
|
|
|
#include <sys/sysctl.h>
|
2009-11-22 20:31:40 +00:00
|
|
|
#include <sys/taskqueue.h>
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_arp.h>
|
|
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_media.h>
|
|
|
|
|
|
|
|
#include <net/bpf.h>
|
|
|
|
|
|
|
|
#include <net/if_types.h>
|
|
|
|
#include <net/if_vlan_var.h>
|
|
|
|
|
|
|
|
#include <netinet/in_systm.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/ip.h>
|
2009-11-22 21:16:30 +00:00
|
|
|
#include <netinet/tcp.h>
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <machine/resource.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/rman.h>
|
|
|
|
|
|
|
|
#include <dev/mii/mii.h>
|
|
|
|
#include <dev/mii/miivar.h>
|
2003-01-19 02:59:34 +00:00
|
|
|
#include "miidevs.h"
|
2001-09-27 23:55:28 +00:00
|
|
|
#include <dev/mii/brgphyreg.h>
|
|
|
|
|
2007-04-30 21:55:27 +00:00
|
|
|
#ifdef __sparc64__
|
|
|
|
#include <dev/ofw/ofw_bus.h>
|
|
|
|
#include <dev/ofw/openfirm.h>
|
|
|
|
#include <machine/ofw_machdep.h>
|
|
|
|
#include <machine/ver.h>
|
|
|
|
#endif
|
|
|
|
|
2003-08-22 05:54:52 +00:00
|
|
|
#include <dev/pci/pcireg.h>
|
|
|
|
#include <dev/pci/pcivar.h>
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
#include <dev/bge/if_bgereg.h>
|
|
|
|
|
2010-08-22 01:39:09 +00:00
|
|
|
#define BGE_CSUM_FEATURES (CSUM_IP | CSUM_TCP)
|
2007-02-12 23:33:05 +00:00
|
|
|
#define ETHER_MIN_NOPAD (ETHER_MIN_LEN - ETHER_CRC_LEN) /* i.e., 60 */
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-04-15 06:37:30 +00:00
|
|
|
MODULE_DEPEND(bge, pci, 1, 1, 1);
|
|
|
|
MODULE_DEPEND(bge, ether, 1, 1, 1);
|
2001-09-27 23:55:28 +00:00
|
|
|
MODULE_DEPEND(bge, miibus, 1, 1, 1);
|
|
|
|
|
2005-10-22 05:06:55 +00:00
|
|
|
/* "device miibus" required. See GENERIC if you get errors here. */
|
2001-09-27 23:55:28 +00:00
|
|
|
#include "miibus_if.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Various supported device vendors/types and their names. Note: the
|
|
|
|
* spec seems to indicate that the hardware still has Alteon's vendor
|
|
|
|
* ID burned into it, though it will always be overriden by the vendor
|
|
|
|
* ID in the EEPROM. Just to be safe, we cover all possibilities.
|
|
|
|
*/
|
2008-09-22 20:55:19 +00:00
|
|
|
static const struct bge_type {
|
2006-06-15 14:31:49 +00:00
|
|
|
uint16_t bge_vid;
|
|
|
|
uint16_t bge_did;
|
|
|
|
} bge_devs[] = {
|
|
|
|
{ ALTEON_VENDORID, ALTEON_DEVICEID_BCM5700 },
|
|
|
|
{ ALTEON_VENDORID, ALTEON_DEVICEID_BCM5701 },
|
|
|
|
|
|
|
|
{ ALTIMA_VENDORID, ALTIMA_DEVICE_AC1000 },
|
|
|
|
{ ALTIMA_VENDORID, ALTIMA_DEVICE_AC1002 },
|
|
|
|
{ ALTIMA_VENDORID, ALTIMA_DEVICE_AC9100 },
|
|
|
|
|
|
|
|
{ APPLE_VENDORID, APPLE_DEVICE_BCM5701 },
|
|
|
|
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5700 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5701 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5702 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5702_ALT },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5702X },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5703 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5703_ALT },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5703X },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5704C },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5704S },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5704S_ALT },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5705 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5705F },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5705K },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5705M },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5705M_ALT },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5714C },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5714S },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5715 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5715S },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5720 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5721 },
|
2007-12-25 19:51:18 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5722 },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5723 },
|
2006-06-15 14:31:49 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5750 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5750M },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5751 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5751F },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5751M },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5752 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5752M },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5753 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5753F },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5753M },
|
2006-06-28 09:12:29 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5754 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5754M },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5755 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5755M },
|
2010-01-13 22:39:39 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5756 },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5761 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5761E },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5761S },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5761SE },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5764 },
|
2006-06-15 14:31:49 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5780 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5780S },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5781 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5782 },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5784 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5785F },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5785G },
|
2006-06-28 09:12:29 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5786 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5787 },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5787F },
|
2006-06-28 09:12:29 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5787M },
|
2006-06-15 14:31:49 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5788 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5789 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5901 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5901A2 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5903M },
|
2008-04-29 19:47:13 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5906 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM5906M },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM57760 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM57780 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM57788 },
|
|
|
|
{ BCOM_VENDORID, BCOM_DEVICEID_BCM57790 },
|
2006-06-15 14:31:49 +00:00
|
|
|
|
|
|
|
{ SK_VENDORID, SK_DEVICEID_ALTIMA },
|
|
|
|
|
|
|
|
{ TC_VENDORID, TC_DEVICEID_3C996 },
|
|
|
|
|
2009-10-07 13:12:43 +00:00
|
|
|
{ FJTSU_VENDORID, FJTSU_DEVICEID_PW008GE4 },
|
|
|
|
{ FJTSU_VENDORID, FJTSU_DEVICEID_PW008GE5 },
|
|
|
|
{ FJTSU_VENDORID, FJTSU_DEVICEID_PP250450 },
|
|
|
|
|
2006-06-15 14:31:49 +00:00
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct bge_vendor {
|
|
|
|
uint16_t v_id;
|
|
|
|
const char *v_name;
|
|
|
|
} bge_vendors[] = {
|
|
|
|
{ ALTEON_VENDORID, "Alteon" },
|
|
|
|
{ ALTIMA_VENDORID, "Altima" },
|
|
|
|
{ APPLE_VENDORID, "Apple" },
|
|
|
|
{ BCOM_VENDORID, "Broadcom" },
|
|
|
|
{ SK_VENDORID, "SysKonnect" },
|
|
|
|
{ TC_VENDORID, "3Com" },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ FJTSU_VENDORID, "Fujitsu" },
|
2006-06-15 14:31:49 +00:00
|
|
|
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2009-11-22 18:30:19 +00:00
|
|
|
|
2006-06-15 14:31:49 +00:00
|
|
|
static const struct bge_revision {
|
|
|
|
uint32_t br_chipid;
|
|
|
|
const char *br_name;
|
|
|
|
} bge_revisions[] = {
|
|
|
|
{ BGE_CHIPID_BCM5700_A0, "BCM5700 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5700_A1, "BCM5700 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5700_B0, "BCM5700 B0" },
|
|
|
|
{ BGE_CHIPID_BCM5700_B1, "BCM5700 B1" },
|
|
|
|
{ BGE_CHIPID_BCM5700_B2, "BCM5700 B2" },
|
|
|
|
{ BGE_CHIPID_BCM5700_B3, "BCM5700 B3" },
|
|
|
|
{ BGE_CHIPID_BCM5700_ALTIMA, "BCM5700 Altima" },
|
|
|
|
{ BGE_CHIPID_BCM5700_C0, "BCM5700 C0" },
|
|
|
|
{ BGE_CHIPID_BCM5701_A0, "BCM5701 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5701_B0, "BCM5701 B0" },
|
|
|
|
{ BGE_CHIPID_BCM5701_B2, "BCM5701 B2" },
|
|
|
|
{ BGE_CHIPID_BCM5701_B5, "BCM5701 B5" },
|
|
|
|
{ BGE_CHIPID_BCM5703_A0, "BCM5703 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5703_A1, "BCM5703 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5703_A2, "BCM5703 A2" },
|
|
|
|
{ BGE_CHIPID_BCM5703_A3, "BCM5703 A3" },
|
2006-06-28 09:12:29 +00:00
|
|
|
{ BGE_CHIPID_BCM5703_B0, "BCM5703 B0" },
|
2006-06-15 14:31:49 +00:00
|
|
|
{ BGE_CHIPID_BCM5704_A0, "BCM5704 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5704_A1, "BCM5704 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5704_A2, "BCM5704 A2" },
|
|
|
|
{ BGE_CHIPID_BCM5704_A3, "BCM5704 A3" },
|
|
|
|
{ BGE_CHIPID_BCM5704_B0, "BCM5704 B0" },
|
|
|
|
{ BGE_CHIPID_BCM5705_A0, "BCM5705 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5705_A1, "BCM5705 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5705_A2, "BCM5705 A2" },
|
|
|
|
{ BGE_CHIPID_BCM5705_A3, "BCM5705 A3" },
|
|
|
|
{ BGE_CHIPID_BCM5750_A0, "BCM5750 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5750_A1, "BCM5750 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5750_A3, "BCM5750 A3" },
|
|
|
|
{ BGE_CHIPID_BCM5750_B0, "BCM5750 B0" },
|
|
|
|
{ BGE_CHIPID_BCM5750_B1, "BCM5750 B1" },
|
|
|
|
{ BGE_CHIPID_BCM5750_C0, "BCM5750 C0" },
|
|
|
|
{ BGE_CHIPID_BCM5750_C1, "BCM5750 C1" },
|
2006-08-07 12:51:50 +00:00
|
|
|
{ BGE_CHIPID_BCM5750_C2, "BCM5750 C2" },
|
2006-06-15 14:31:49 +00:00
|
|
|
{ BGE_CHIPID_BCM5714_A0, "BCM5714 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5752_A0, "BCM5752 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5752_A1, "BCM5752 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5752_A2, "BCM5752 A2" },
|
|
|
|
{ BGE_CHIPID_BCM5714_B0, "BCM5714 B0" },
|
|
|
|
{ BGE_CHIPID_BCM5714_B3, "BCM5714 B3" },
|
|
|
|
{ BGE_CHIPID_BCM5715_A0, "BCM5715 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5715_A1, "BCM5715 A1" },
|
2007-03-09 01:30:23 +00:00
|
|
|
{ BGE_CHIPID_BCM5715_A3, "BCM5715 A3" },
|
|
|
|
{ BGE_CHIPID_BCM5755_A0, "BCM5755 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5755_A1, "BCM5755 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5755_A2, "BCM5755 A2" },
|
2008-03-06 21:42:48 +00:00
|
|
|
{ BGE_CHIPID_BCM5722_A0, "BCM5722 A0" },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BGE_CHIPID_BCM5761_A0, "BCM5761 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5761_A1, "BCM5761 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5784_A0, "BCM5784 A0" },
|
|
|
|
{ BGE_CHIPID_BCM5784_A1, "BCM5784 A1" },
|
2007-02-14 19:01:33 +00:00
|
|
|
/* 5754 and 5787 share the same ASIC ID */
|
2009-11-22 18:30:19 +00:00
|
|
|
{ BGE_CHIPID_BCM5787_A0, "BCM5754/5787 A0" },
|
2006-12-12 05:11:12 +00:00
|
|
|
{ BGE_CHIPID_BCM5787_A1, "BCM5754/5787 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5787_A2, "BCM5754/5787 A2" },
|
2008-04-29 19:47:13 +00:00
|
|
|
{ BGE_CHIPID_BCM5906_A1, "BCM5906 A1" },
|
|
|
|
{ BGE_CHIPID_BCM5906_A2, "BCM5906 A2" },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BGE_CHIPID_BCM57780_A0, "BCM57780 A0" },
|
|
|
|
{ BGE_CHIPID_BCM57780_A1, "BCM57780 A1" },
|
2006-06-15 14:31:49 +00:00
|
|
|
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some defaults for major revisions, so that newer steppings
|
|
|
|
* that we don't know about have a shot at working.
|
|
|
|
*/
|
|
|
|
static const struct bge_revision bge_majorrevs[] = {
|
2006-06-28 09:12:29 +00:00
|
|
|
{ BGE_ASICREV_BCM5700, "unknown BCM5700" },
|
|
|
|
{ BGE_ASICREV_BCM5701, "unknown BCM5701" },
|
|
|
|
{ BGE_ASICREV_BCM5703, "unknown BCM5703" },
|
|
|
|
{ BGE_ASICREV_BCM5704, "unknown BCM5704" },
|
|
|
|
{ BGE_ASICREV_BCM5705, "unknown BCM5705" },
|
|
|
|
{ BGE_ASICREV_BCM5750, "unknown BCM5750" },
|
|
|
|
{ BGE_ASICREV_BCM5714_A0, "unknown BCM5714" },
|
|
|
|
{ BGE_ASICREV_BCM5752, "unknown BCM5752" },
|
|
|
|
{ BGE_ASICREV_BCM5780, "unknown BCM5780" },
|
|
|
|
{ BGE_ASICREV_BCM5714, "unknown BCM5714" },
|
|
|
|
{ BGE_ASICREV_BCM5755, "unknown BCM5755" },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BGE_ASICREV_BCM5761, "unknown BCM5761" },
|
|
|
|
{ BGE_ASICREV_BCM5784, "unknown BCM5784" },
|
|
|
|
{ BGE_ASICREV_BCM5785, "unknown BCM5785" },
|
2007-02-14 19:01:33 +00:00
|
|
|
/* 5754 and 5787 share the same ASIC ID */
|
2006-12-12 05:11:12 +00:00
|
|
|
{ BGE_ASICREV_BCM5787, "unknown BCM5754/5787" },
|
2008-04-29 19:47:13 +00:00
|
|
|
{ BGE_ASICREV_BCM5906, "unknown BCM5906" },
|
2009-10-07 13:12:43 +00:00
|
|
|
{ BGE_ASICREV_BCM57780, "unknown BCM57780" },
|
2006-06-15 14:31:49 +00:00
|
|
|
|
|
|
|
{ 0, NULL }
|
2001-09-27 23:55:28 +00:00
|
|
|
};
|
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
#define BGE_IS_JUMBO_CAPABLE(sc) ((sc)->bge_flags & BGE_FLAG_JUMBO)
|
|
|
|
#define BGE_IS_5700_FAMILY(sc) ((sc)->bge_flags & BGE_FLAG_5700_FAMILY)
|
|
|
|
#define BGE_IS_5705_PLUS(sc) ((sc)->bge_flags & BGE_FLAG_5705_PLUS)
|
|
|
|
#define BGE_IS_5714_FAMILY(sc) ((sc)->bge_flags & BGE_FLAG_5714_FAMILY)
|
|
|
|
#define BGE_IS_575X_PLUS(sc) ((sc)->bge_flags & BGE_FLAG_575X_PLUS)
|
2009-10-07 13:12:43 +00:00
|
|
|
#define BGE_IS_5755_PLUS(sc) ((sc)->bge_flags & BGE_FLAG_5755_PLUS)
|
2006-06-15 14:31:49 +00:00
|
|
|
|
|
|
|
const struct bge_revision * bge_lookup_rev(uint32_t);
|
|
|
|
const struct bge_vendor * bge_lookup_vendor(uint16_t);
|
2008-04-29 19:47:13 +00:00
|
|
|
|
|
|
|
typedef int (*bge_eaddr_fcn_t)(struct bge_softc *, uint8_t[]);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
static int bge_probe(device_t);
|
|
|
|
static int bge_attach(device_t);
|
|
|
|
static int bge_detach(device_t);
|
|
|
|
static int bge_suspend(device_t);
|
|
|
|
static int bge_resume(device_t);
|
|
|
|
static void bge_release_resources(struct bge_softc *);
|
|
|
|
static void bge_dma_map_addr(void *, bus_dma_segment_t *, int, int);
|
2010-08-31 17:33:48 +00:00
|
|
|
static int bge_dma_alloc(struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_dma_free(struct bge_softc *);
|
2010-08-31 17:33:48 +00:00
|
|
|
static int bge_dma_ring_alloc(struct bge_softc *, bus_size_t, bus_size_t,
|
|
|
|
bus_dma_tag_t *, uint8_t **, bus_dmamap_t *, bus_addr_t *, const char *);
|
2006-06-07 21:03:20 +00:00
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
static int bge_get_eaddr_fw(struct bge_softc *sc, uint8_t ether_addr[]);
|
2008-04-29 19:47:13 +00:00
|
|
|
static int bge_get_eaddr_mem(struct bge_softc *, uint8_t[]);
|
|
|
|
static int bge_get_eaddr_nvram(struct bge_softc *, uint8_t[]);
|
|
|
|
static int bge_get_eaddr_eeprom(struct bge_softc *, uint8_t[]);
|
|
|
|
static int bge_get_eaddr(struct bge_softc *, uint8_t[]);
|
|
|
|
|
2009-11-22 20:02:13 +00:00
|
|
|
static void bge_txeof(struct bge_softc *, uint16_t);
|
2009-11-22 20:31:40 +00:00
|
|
|
static int bge_rxeof(struct bge_softc *, uint16_t, int);
|
2006-06-07 21:03:20 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
static void bge_asf_driver_up (struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_tick(void *);
|
|
|
|
static void bge_stats_update(struct bge_softc *);
|
|
|
|
static void bge_stats_update_regs(struct bge_softc *);
|
2009-11-22 21:20:26 +00:00
|
|
|
static struct mbuf *bge_setup_tso(struct bge_softc *, struct mbuf *,
|
|
|
|
uint16_t *);
|
2006-08-17 09:53:04 +00:00
|
|
|
static int bge_encap(struct bge_softc *, struct mbuf **, uint32_t *);
|
2006-06-07 21:03:20 +00:00
|
|
|
|
|
|
|
static void bge_intr(void *);
|
2009-11-22 20:31:40 +00:00
|
|
|
static int bge_msi_intr(void *);
|
|
|
|
static void bge_intr_task(void *, int);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_start_locked(struct ifnet *);
|
|
|
|
static void bge_start(struct ifnet *);
|
|
|
|
static int bge_ioctl(struct ifnet *, u_long, caddr_t);
|
|
|
|
static void bge_init_locked(struct bge_softc *);
|
|
|
|
static void bge_init(void *);
|
|
|
|
static void bge_stop(struct bge_softc *);
|
2006-11-30 13:40:39 +00:00
|
|
|
static void bge_watchdog(struct bge_softc *);
|
2009-02-05 18:43:13 +00:00
|
|
|
static int bge_shutdown(device_t);
|
2006-08-24 14:41:16 +00:00
|
|
|
static int bge_ifmedia_upd_locked(struct ifnet *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static int bge_ifmedia_upd(struct ifnet *);
|
|
|
|
static void bge_ifmedia_sts(struct ifnet *, struct ifmediareq *);
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
static uint8_t bge_nvram_getbyte(struct bge_softc *, int, uint8_t *);
|
|
|
|
static int bge_read_nvram(struct bge_softc *, caddr_t, int, int);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint8_t bge_eeprom_getbyte(struct bge_softc *, int, uint8_t *);
|
|
|
|
static int bge_read_eeprom(struct bge_softc *, caddr_t, int, int);
|
|
|
|
|
2006-09-18 22:18:21 +00:00
|
|
|
static void bge_setpromisc(struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_setmulti(struct bge_softc *);
|
2007-06-01 02:02:39 +00:00
|
|
|
static void bge_setvlan(struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
|
2010-06-05 23:29:24 +00:00
|
|
|
static __inline void bge_rxreuse_std(struct bge_softc *, int);
|
|
|
|
static __inline void bge_rxreuse_jumbo(struct bge_softc *, int);
|
2009-11-07 01:01:33 +00:00
|
|
|
static int bge_newbuf_std(struct bge_softc *, int);
|
|
|
|
static int bge_newbuf_jumbo(struct bge_softc *, int);
|
2006-06-07 21:03:20 +00:00
|
|
|
static int bge_init_rx_ring_std(struct bge_softc *);
|
|
|
|
static void bge_free_rx_ring_std(struct bge_softc *);
|
|
|
|
static int bge_init_rx_ring_jumbo(struct bge_softc *);
|
|
|
|
static void bge_free_rx_ring_jumbo(struct bge_softc *);
|
|
|
|
static void bge_free_tx_ring(struct bge_softc *);
|
|
|
|
static int bge_init_tx_ring(struct bge_softc *);
|
|
|
|
|
|
|
|
static int bge_chipinit(struct bge_softc *);
|
|
|
|
static int bge_blockinit(struct bge_softc *);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
static int bge_has_eaddr(struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint32_t bge_readmem_ind(struct bge_softc *, int);
|
|
|
|
static void bge_writemem_ind(struct bge_softc *, int, int);
|
2008-04-29 19:47:13 +00:00
|
|
|
static void bge_writembx(struct bge_softc *, int, int);
|
2001-09-27 23:55:28 +00:00
|
|
|
#ifdef notdef
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint32_t bge_readreg_ind(struct bge_softc *, int);
|
2001-09-27 23:55:28 +00:00
|
|
|
#endif
|
2006-12-13 21:13:09 +00:00
|
|
|
static void bge_writemem_direct(struct bge_softc *, int, int);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_writereg_ind(struct bge_softc *, int, int);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
static int bge_miibus_readreg(device_t, int, int);
|
|
|
|
static int bge_miibus_writereg(device_t, int, int, int);
|
|
|
|
static void bge_miibus_statchg(device_t);
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2009-05-30 15:14:44 +00:00
|
|
|
static int bge_poll(struct ifnet *ifp, enum poll_cmd cmd, int count);
|
2005-10-22 14:31:01 +00:00
|
|
|
#endif
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-02-12 23:33:05 +00:00
|
|
|
#define BGE_RESET_START 1
|
|
|
|
#define BGE_RESET_STOP 2
|
2006-09-09 03:36:57 +00:00
|
|
|
static void bge_sig_post_reset(struct bge_softc *, int);
|
|
|
|
static void bge_sig_legacy(struct bge_softc *, int);
|
|
|
|
static void bge_sig_pre_reset(struct bge_softc *, int);
|
2010-07-13 19:33:46 +00:00
|
|
|
static void bge_stop_fw(struct bge_softc *);
|
2006-09-09 03:36:57 +00:00
|
|
|
static int bge_reset(struct bge_softc *);
|
2006-06-07 21:03:20 +00:00
|
|
|
static void bge_link_upd(struct bge_softc *);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-12-12 05:11:12 +00:00
|
|
|
/*
|
|
|
|
* The BGE_REGISTER_DEBUG option is only for low-level debugging. It may
|
|
|
|
* leak information to untrusted users. It is also known to cause alignment
|
|
|
|
* traps on certain architectures.
|
|
|
|
*/
|
|
|
|
#ifdef BGE_REGISTER_DEBUG
|
|
|
|
static int bge_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
|
|
|
|
static int bge_sysctl_reg_read(SYSCTL_HANDLER_ARGS);
|
|
|
|
static int bge_sysctl_mem_read(SYSCTL_HANDLER_ARGS);
|
|
|
|
#endif
|
|
|
|
static void bge_add_sysctls(struct bge_softc *);
|
2007-03-12 09:25:57 +00:00
|
|
|
static int bge_sysctl_stats(SYSCTL_HANDLER_ARGS);
|
2006-12-12 05:11:12 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static device_method_t bge_methods[] = {
|
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, bge_probe),
|
|
|
|
DEVMETHOD(device_attach, bge_attach),
|
|
|
|
DEVMETHOD(device_detach, bge_detach),
|
|
|
|
DEVMETHOD(device_shutdown, bge_shutdown),
|
2005-09-28 19:20:49 +00:00
|
|
|
DEVMETHOD(device_suspend, bge_suspend),
|
|
|
|
DEVMETHOD(device_resume, bge_resume),
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* bus interface */
|
|
|
|
DEVMETHOD(bus_print_child, bus_generic_print_child),
|
|
|
|
DEVMETHOD(bus_driver_added, bus_generic_driver_added),
|
|
|
|
|
|
|
|
/* MII interface */
|
|
|
|
DEVMETHOD(miibus_readreg, bge_miibus_readreg),
|
|
|
|
DEVMETHOD(miibus_writereg, bge_miibus_writereg),
|
|
|
|
DEVMETHOD(miibus_statchg, bge_miibus_statchg),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t bge_driver = {
|
|
|
|
"bge",
|
|
|
|
bge_methods,
|
|
|
|
sizeof(struct bge_softc)
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t bge_devclass;
|
|
|
|
|
2003-04-15 06:37:30 +00:00
|
|
|
DRIVER_MODULE(bge, pci, bge_driver, bge_devclass, 0, 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
DRIVER_MODULE(miibus, bge, miibus_driver, miibus_devclass, 0, 0);
|
|
|
|
|
2006-09-23 18:55:49 +00:00
|
|
|
static int bge_allow_asf = 1;
|
|
|
|
|
|
|
|
TUNABLE_INT("hw.bge.allow_asf", &bge_allow_asf);
|
|
|
|
|
|
|
|
SYSCTL_NODE(_hw, OID_AUTO, bge, CTLFLAG_RD, 0, "BGE driver parameters");
|
|
|
|
SYSCTL_INT(_hw_bge, OID_AUTO, allow_asf, CTLFLAG_RD, &bge_allow_asf, 0,
|
|
|
|
"Allow ASF mode if available");
|
2006-04-25 15:56:52 +00:00
|
|
|
|
2007-04-30 21:55:27 +00:00
|
|
|
#define SPARC64_BLADE_1500_MODEL "SUNW,Sun-Blade-1500"
|
|
|
|
#define SPARC64_BLADE_1500_PATH_BGE "/pci@1f,700000/network@2"
|
|
|
|
#define SPARC64_BLADE_2500_MODEL "SUNW,Sun-Blade-2500"
|
|
|
|
#define SPARC64_BLADE_2500_PATH_BGE "/pci@1c,600000/network@3"
|
|
|
|
#define SPARC64_OFW_SUBVENDOR "subsystem-vendor-id"
|
|
|
|
|
|
|
|
static int
|
2008-05-14 21:00:27 +00:00
|
|
|
bge_has_eaddr(struct bge_softc *sc)
|
2007-04-30 21:55:27 +00:00
|
|
|
{
|
|
|
|
#ifdef __sparc64__
|
|
|
|
char buf[sizeof(SPARC64_BLADE_1500_PATH_BGE)];
|
|
|
|
device_t dev;
|
|
|
|
uint32_t subvendor;
|
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The on-board BGEs found in sun4u machines aren't fitted with
|
|
|
|
* an EEPROM which means that we have to obtain the MAC address
|
2008-05-14 21:00:27 +00:00
|
|
|
* via OFW and that some tests will always fail. We distinguish
|
2007-04-30 21:55:27 +00:00
|
|
|
* such BGEs by the subvendor ID, which also has to be obtained
|
|
|
|
* from OFW instead of the PCI configuration space as the latter
|
|
|
|
* indicates Broadcom as the subvendor of the netboot interface.
|
|
|
|
* For early Blade 1500 and 2500 we even have to check the OFW
|
|
|
|
* device path as the subvendor ID always defaults to Broadcom
|
|
|
|
* there.
|
|
|
|
*/
|
|
|
|
if (OF_getprop(ofw_bus_get_node(dev), SPARC64_OFW_SUBVENDOR,
|
|
|
|
&subvendor, sizeof(subvendor)) == sizeof(subvendor) &&
|
2010-04-26 18:56:06 +00:00
|
|
|
(subvendor == FJTSU_VENDORID || subvendor == SUN_VENDORID))
|
2007-04-30 21:55:27 +00:00
|
|
|
return (0);
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
if (OF_package_to_path(ofw_bus_get_node(dev), buf, sizeof(buf)) > 0) {
|
|
|
|
if (strcmp(sparc64_model, SPARC64_BLADE_1500_MODEL) == 0 &&
|
|
|
|
strcmp(buf, SPARC64_BLADE_1500_PATH_BGE) == 0)
|
|
|
|
return (0);
|
|
|
|
if (strcmp(sparc64_model, SPARC64_BLADE_2500_MODEL) == 0 &&
|
|
|
|
strcmp(buf, SPARC64_BLADE_2500_PATH_BGE) == 0)
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint32_t
|
|
|
|
bge_readmem_ind(struct bge_softc *sc, int off)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
device_t dev;
|
2006-12-12 05:11:12 +00:00
|
|
|
uint32_t val;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
|
|
|
pci_write_config(dev, BGE_PCI_MEMWIN_BASEADDR, off, 4);
|
2006-12-12 05:11:12 +00:00
|
|
|
val = pci_read_config(dev, BGE_PCI_MEMWIN_DATA, 4);
|
|
|
|
pci_write_config(dev, BGE_PCI_MEMWIN_BASEADDR, 0, 4);
|
|
|
|
return (val);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_writemem_ind(struct bge_softc *sc, int off, int val)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
device_t dev;
|
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
|
|
|
pci_write_config(dev, BGE_PCI_MEMWIN_BASEADDR, off, 4);
|
|
|
|
pci_write_config(dev, BGE_PCI_MEMWIN_DATA, val, 4);
|
2006-12-12 05:11:12 +00:00
|
|
|
pci_write_config(dev, BGE_PCI_MEMWIN_BASEADDR, 0, 4);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef notdef
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint32_t
|
|
|
|
bge_readreg_ind(struct bge_softc *sc, int off)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
device_t dev;
|
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
|
|
|
pci_write_config(dev, BGE_PCI_REG_BASEADDR, off, 4);
|
2006-06-07 21:03:20 +00:00
|
|
|
return (pci_read_config(dev, BGE_PCI_REG_DATA, 4));
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_writereg_ind(struct bge_softc *sc, int off, int val)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
device_t dev;
|
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
|
|
|
pci_write_config(dev, BGE_PCI_REG_BASEADDR, off, 4);
|
|
|
|
pci_write_config(dev, BGE_PCI_REG_DATA, val, 4);
|
|
|
|
}
|
|
|
|
|
2006-12-12 05:11:12 +00:00
|
|
|
static void
|
|
|
|
bge_writemem_direct(struct bge_softc *sc, int off, int val)
|
|
|
|
{
|
|
|
|
CSR_WRITE_4(sc, off, val);
|
|
|
|
}
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
static void
|
|
|
|
bge_writembx(struct bge_softc *sc, int off, int val)
|
|
|
|
{
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906)
|
|
|
|
off += BGE_LPMBX_IRQ0_HI - BGE_MBX_IRQ0_HI;
|
|
|
|
|
|
|
|
CSR_WRITE_4(sc, off, val);
|
|
|
|
}
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
/*
|
|
|
|
* Map a single buffer address.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
|
2003-07-25 19:42:44 +00:00
|
|
|
{
|
|
|
|
struct bge_dmamap_arg *ctx;
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return;
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
KASSERT(nseg == 1, ("%s: %d segments returned!", __func__, nseg));
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
ctx = arg;
|
2003-07-25 19:42:44 +00:00
|
|
|
ctx->bge_busaddr = segs->ds_addr;
|
|
|
|
}
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
static uint8_t
|
|
|
|
bge_nvram_getbyte(struct bge_softc *sc, int addr, uint8_t *dest)
|
|
|
|
{
|
|
|
|
uint32_t access, byte = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Lock. */
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_SWARB, BGE_NVRAMSWARB_SET1);
|
|
|
|
for (i = 0; i < 8000; i++) {
|
|
|
|
if (CSR_READ_4(sc, BGE_NVRAM_SWARB) & BGE_NVRAMSWARB_GNT1)
|
|
|
|
break;
|
|
|
|
DELAY(20);
|
|
|
|
}
|
|
|
|
if (i == 8000)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
/* Enable access. */
|
|
|
|
access = CSR_READ_4(sc, BGE_NVRAM_ACCESS);
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_ACCESS, access | BGE_NVRAMACC_ENABLE);
|
|
|
|
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_ADDR, addr & 0xfffffffc);
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_CMD, BGE_NVRAM_READCMD);
|
|
|
|
for (i = 0; i < BGE_TIMEOUT * 10; i++) {
|
|
|
|
DELAY(10);
|
|
|
|
if (CSR_READ_4(sc, BGE_NVRAM_CMD) & BGE_NVRAMCMD_DONE) {
|
|
|
|
DELAY(10);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == BGE_TIMEOUT * 10) {
|
|
|
|
if_printf(sc->bge_ifp, "nvram read timed out\n");
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get result. */
|
|
|
|
byte = CSR_READ_4(sc, BGE_NVRAM_RDDATA);
|
|
|
|
|
|
|
|
*dest = (bswap32(byte) >> ((addr % 4) * 8)) & 0xFF;
|
|
|
|
|
|
|
|
/* Disable access. */
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_ACCESS, access);
|
|
|
|
|
|
|
|
/* Unlock. */
|
|
|
|
CSR_WRITE_4(sc, BGE_NVRAM_SWARB, BGE_NVRAMSWARB_CLR1);
|
|
|
|
CSR_READ_4(sc, BGE_NVRAM_SWARB);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a sequence of bytes from NVRAM.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
bge_read_nvram(struct bge_softc *sc, caddr_t dest, int off, int cnt)
|
|
|
|
{
|
|
|
|
int err = 0, i;
|
|
|
|
uint8_t byte = 0;
|
|
|
|
|
|
|
|
if (sc->bge_asicrev != BGE_ASICREV_BCM5906)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
err = bge_nvram_getbyte(sc, off + i, &byte);
|
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
*(dest + i) = byte;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (err ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Read a byte of data stored in the EEPROM at address 'addr.' The
|
|
|
|
* BCM570x supports both the traditional bitbang interface and an
|
|
|
|
* auto access interface for reading the EEPROM. We use the auto
|
|
|
|
* access method.
|
|
|
|
*/
|
2006-06-07 21:03:20 +00:00
|
|
|
static uint8_t
|
|
|
|
bge_eeprom_getbyte(struct bge_softc *sc, int addr, uint8_t *dest)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
int i;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t byte = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable use of auto EEPROM access so we can avoid
|
|
|
|
* having to use the bitbang method.
|
|
|
|
*/
|
|
|
|
BGE_SETBIT(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_AUTO_EEPROM);
|
|
|
|
|
|
|
|
/* Reset the EEPROM, load the clock period. */
|
|
|
|
CSR_WRITE_4(sc, BGE_EE_ADDR,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_EEADDR_RESET | BGE_EEHALFCLK(BGE_HALFCLK_384SCL));
|
2001-09-27 23:55:28 +00:00
|
|
|
DELAY(20);
|
|
|
|
|
|
|
|
/* Issue the read EEPROM command. */
|
|
|
|
CSR_WRITE_4(sc, BGE_EE_ADDR, BGE_EE_READCMD | addr);
|
|
|
|
|
|
|
|
/* Wait for completion */
|
|
|
|
for(i = 0; i < BGE_TIMEOUT * 10; i++) {
|
|
|
|
DELAY(10);
|
|
|
|
if (CSR_READ_4(sc, BGE_EE_ADDR) & BGE_EEADDR_DONE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-05-22 18:51:05 +00:00
|
|
|
if (i == BGE_TIMEOUT * 10) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "EEPROM read timed out\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (1);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get result. */
|
|
|
|
byte = CSR_READ_4(sc, BGE_EE_DATA);
|
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
*dest = (byte >> ((addr % 4) * 8)) & 0xFF;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a sequence of bytes from the EEPROM.
|
|
|
|
*/
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_read_eeprom(struct bge_softc *sc, caddr_t dest, int off, int cnt)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2006-06-07 21:03:20 +00:00
|
|
|
int i, error = 0;
|
|
|
|
uint8_t byte = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
2006-06-07 21:03:20 +00:00
|
|
|
error = bge_eeprom_getbyte(sc, off + i, &byte);
|
|
|
|
if (error)
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
*(dest + i) = byte;
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (error ? 1 : 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_miibus_readreg(device_t dev, int phy, int reg)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t val, autopoll;
|
2001-09-27 23:55:28 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
/*
|
|
|
|
* Broadcom's own driver always assumes the internal
|
|
|
|
* PHY is at GMII address 1. On some chips, the PHY responds
|
|
|
|
* to accesses at all addresses, which could cause us to
|
|
|
|
* bogusly attach the PHY 32 times at probe type. Always
|
|
|
|
* restricting the lookup to address 1 is simpler than
|
|
|
|
* trying to figure out which chips revisions should be
|
|
|
|
* special-cased.
|
|
|
|
*/
|
2002-09-08 19:12:02 +00:00
|
|
|
if (phy != 1)
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2002-03-22 06:45:40 +00:00
|
|
|
|
2003-05-03 19:06:50 +00:00
|
|
|
/* Reading with autopolling on may trigger PCI errors */
|
|
|
|
autopoll = CSR_READ_4(sc, BGE_MI_MODE);
|
|
|
|
if (autopoll & BGE_MIMODE_AUTOPOLL) {
|
|
|
|
BGE_CLRBIT(sc, BGE_MI_MODE, BGE_MIMODE_AUTOPOLL);
|
|
|
|
DELAY(40);
|
|
|
|
}
|
|
|
|
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MI_COMM, BGE_MICMD_READ | BGE_MICOMM_BUSY |
|
|
|
|
BGE_MIPHY(phy) | BGE_MIREG(reg));
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
2007-05-22 18:51:05 +00:00
|
|
|
DELAY(10);
|
2001-09-27 23:55:28 +00:00
|
|
|
val = CSR_READ_4(sc, BGE_MI_COMM);
|
|
|
|
if (!(val & BGE_MICOMM_BUSY))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == BGE_TIMEOUT) {
|
2008-05-14 21:00:27 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"PHY read timed out (phy %d, reg %d, val 0x%08x)\n",
|
|
|
|
phy, reg, val);
|
2003-05-03 19:06:50 +00:00
|
|
|
val = 0;
|
|
|
|
goto done;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
DELAY(5);
|
2001-09-27 23:55:28 +00:00
|
|
|
val = CSR_READ_4(sc, BGE_MI_COMM);
|
|
|
|
|
2003-05-03 19:06:50 +00:00
|
|
|
done:
|
|
|
|
if (autopoll & BGE_MIMODE_AUTOPOLL) {
|
|
|
|
BGE_SETBIT(sc, BGE_MI_MODE, BGE_MIMODE_AUTOPOLL);
|
|
|
|
DELAY(40);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
if (val & BGE_MICOMM_READFAIL)
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
return (val & 0xFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_miibus_writereg(device_t dev, int phy, int reg, int val)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t autopoll;
|
2001-09-27 23:55:28 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906 &&
|
|
|
|
(reg == BRGPHY_MII_1000CTL || reg == BRGPHY_MII_AUXCTL))
|
2010-07-13 19:39:51 +00:00
|
|
|
return (0);
|
2008-04-29 19:47:13 +00:00
|
|
|
|
2003-05-03 19:06:50 +00:00
|
|
|
/* Reading with autopolling on may trigger PCI errors */
|
|
|
|
autopoll = CSR_READ_4(sc, BGE_MI_MODE);
|
|
|
|
if (autopoll & BGE_MIMODE_AUTOPOLL) {
|
|
|
|
BGE_CLRBIT(sc, BGE_MI_MODE, BGE_MIMODE_AUTOPOLL);
|
|
|
|
DELAY(40);
|
|
|
|
}
|
|
|
|
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MI_COMM, BGE_MICMD_WRITE | BGE_MICOMM_BUSY |
|
|
|
|
BGE_MIPHY(phy) | BGE_MIREG(reg) | val);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
2007-05-22 18:51:05 +00:00
|
|
|
DELAY(10);
|
2008-04-29 19:47:13 +00:00
|
|
|
if (!(CSR_READ_4(sc, BGE_MI_COMM) & BGE_MICOMM_BUSY)) {
|
|
|
|
DELAY(5);
|
|
|
|
CSR_READ_4(sc, BGE_MI_COMM); /* dummy read */
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
2007-05-22 18:51:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (i == BGE_TIMEOUT) {
|
2008-04-29 19:47:13 +00:00
|
|
|
device_printf(sc->bge_dev,
|
2008-05-14 21:00:27 +00:00
|
|
|
"PHY write timed out (phy %d, reg %d, val %d)\n",
|
|
|
|
phy, reg, val);
|
2007-05-22 18:51:05 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2003-05-03 19:06:50 +00:00
|
|
|
if (autopoll & BGE_MIMODE_AUTOPOLL) {
|
|
|
|
BGE_SETBIT(sc, BGE_MI_MODE, BGE_MIMODE_AUTOPOLL);
|
|
|
|
DELAY(40);
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_miibus_statchg(device_t dev)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
struct mii_data *mii;
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
|
|
|
|
|
|
|
BGE_CLRBIT(sc, BGE_MAC_MODE, BGE_MACMODE_PORTMODE);
|
2010-01-14 19:08:43 +00:00
|
|
|
if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T ||
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX)
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_MAC_MODE, BGE_PORTMODE_GMII);
|
2006-06-07 21:03:20 +00:00
|
|
|
else
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_MAC_MODE, BGE_PORTMODE_MII);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_MAC_MODE, BGE_MACMODE_HALF_DUPLEX);
|
2006-06-07 21:03:20 +00:00
|
|
|
else
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_MAC_MODE, BGE_MACMODE_HALF_DUPLEX);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Intialize a standard receive ring descriptor.
|
|
|
|
*/
|
|
|
|
static int
|
2009-11-07 01:01:33 +00:00
|
|
|
bge_newbuf_std(struct bge_softc *sc, int i)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2009-11-07 01:01:33 +00:00
|
|
|
struct mbuf *m;
|
2006-06-07 21:03:20 +00:00
|
|
|
struct bge_rx_bd *r;
|
2009-11-04 20:40:38 +00:00
|
|
|
bus_dma_segment_t segs[1];
|
2009-11-07 01:01:33 +00:00
|
|
|
bus_dmamap_t map;
|
2009-11-04 20:40:38 +00:00
|
|
|
int error, nsegs;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-07 01:01:33 +00:00
|
|
|
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
|
|
|
|
if (m == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
m->m_len = m->m_pkthdr.len = MCLBYTES;
|
2006-08-23 11:32:54 +00:00
|
|
|
if ((sc->bge_flags & BGE_FLAG_RX_ALIGNBUG) == 0)
|
2009-11-07 01:01:33 +00:00
|
|
|
m_adj(m, ETHER_ALIGN);
|
|
|
|
|
2009-11-04 20:57:52 +00:00
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->bge_cdata.bge_rx_mtag,
|
2009-11-07 01:01:33 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_sparemap, m, segs, &nsegs, 0);
|
2009-11-04 20:40:38 +00:00
|
|
|
if (error != 0) {
|
2009-11-07 01:01:33 +00:00
|
|
|
m_freem(m);
|
2009-11-04 20:40:38 +00:00
|
|
|
return (error);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
2009-11-07 01:01:33 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_std_chain[i] != NULL) {
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_mtag,
|
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i], BUS_DMASYNC_POSTREAD);
|
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_rx_mtag,
|
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i]);
|
|
|
|
}
|
|
|
|
map = sc->bge_cdata.bge_rx_std_dmamap[i];
|
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i] = sc->bge_cdata.bge_rx_std_sparemap;
|
|
|
|
sc->bge_cdata.bge_rx_std_sparemap = map;
|
|
|
|
sc->bge_cdata.bge_rx_std_chain[i] = m;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_seglen[i] = segs[0].ds_len;
|
2009-11-07 01:01:33 +00:00
|
|
|
r = &sc->bge_ldata.bge_rx_std_ring[sc->bge_std];
|
2009-11-04 20:40:38 +00:00
|
|
|
r->bge_addr.bge_addr_lo = BGE_ADDR_LO(segs[0].ds_addr);
|
|
|
|
r->bge_addr.bge_addr_hi = BGE_ADDR_HI(segs[0].ds_addr);
|
2005-12-15 05:48:49 +00:00
|
|
|
r->bge_flags = BGE_RXBDFLAG_END;
|
2009-11-04 20:40:38 +00:00
|
|
|
r->bge_len = segs[0].ds_len;
|
2005-12-15 05:48:49 +00:00
|
|
|
r->bge_idx = i;
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_mtag,
|
2009-11-07 01:01:33 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i], BUS_DMASYNC_PREREAD);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize a jumbo receive ring descriptor. This allocates
|
|
|
|
* a jumbo buffer from the pool managed internally by the driver.
|
|
|
|
*/
|
|
|
|
static int
|
2009-11-07 01:01:33 +00:00
|
|
|
bge_newbuf_jumbo(struct bge_softc *sc, int i)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
bus_dma_segment_t segs[BGE_NSEG_JUMBO];
|
2009-11-07 01:01:33 +00:00
|
|
|
bus_dmamap_t map;
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
struct bge_extrx_bd *r;
|
2009-11-07 01:01:33 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
int error, nsegs;
|
|
|
|
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
|
|
if (m == NULL)
|
|
|
|
return (ENOBUFS);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-07 01:01:33 +00:00
|
|
|
m_cljget(m, M_DONTWAIT, MJUM9BYTES);
|
|
|
|
if (!(m->m_flags & M_EXT)) {
|
|
|
|
m_freem(m);
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
|
|
|
m->m_len = m->m_pkthdr.len = MJUM9BYTES;
|
2006-08-23 11:32:54 +00:00
|
|
|
if ((sc->bge_flags & BGE_FLAG_RX_ALIGNBUG) == 0)
|
2009-11-07 01:01:33 +00:00
|
|
|
m_adj(m, ETHER_ALIGN);
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
|
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->bge_cdata.bge_mtag_jumbo,
|
2009-11-07 01:01:33 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_sparemap, m, segs, &nsegs, 0);
|
|
|
|
if (error != 0) {
|
|
|
|
m_freem(m);
|
2006-06-07 21:03:20 +00:00
|
|
|
return (error);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
|
2009-11-07 01:01:33 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_chain[i] == NULL) {
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i], BUS_DMASYNC_POSTREAD);
|
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i]);
|
|
|
|
}
|
|
|
|
map = sc->bge_cdata.bge_rx_jumbo_dmamap[i];
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i] =
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_sparemap;
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_sparemap = map;
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_chain[i] = m;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][0] = 0;
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][1] = 0;
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][2] = 0;
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][3] = 0;
|
|
|
|
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
/*
|
|
|
|
* Fill in the extended RX buffer descriptor.
|
|
|
|
*/
|
2009-11-07 01:01:33 +00:00
|
|
|
r = &sc->bge_ldata.bge_rx_jumbo_ring[sc->bge_jumbo];
|
2007-03-06 20:14:48 +00:00
|
|
|
r->bge_flags = BGE_RXBDFLAG_JUMBO_RING | BGE_RXBDFLAG_END;
|
2005-12-15 05:48:49 +00:00
|
|
|
r->bge_idx = i;
|
2006-01-18 14:31:21 +00:00
|
|
|
r->bge_len3 = r->bge_len2 = r->bge_len1 = 0;
|
|
|
|
switch (nsegs) {
|
|
|
|
case 4:
|
|
|
|
r->bge_addr3.bge_addr_lo = BGE_ADDR_LO(segs[3].ds_addr);
|
|
|
|
r->bge_addr3.bge_addr_hi = BGE_ADDR_HI(segs[3].ds_addr);
|
|
|
|
r->bge_len3 = segs[3].ds_len;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][3] = segs[3].ds_len;
|
2006-01-18 14:31:21 +00:00
|
|
|
case 3:
|
|
|
|
r->bge_addr2.bge_addr_lo = BGE_ADDR_LO(segs[2].ds_addr);
|
|
|
|
r->bge_addr2.bge_addr_hi = BGE_ADDR_HI(segs[2].ds_addr);
|
|
|
|
r->bge_len2 = segs[2].ds_len;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][2] = segs[2].ds_len;
|
2006-01-18 14:31:21 +00:00
|
|
|
case 2:
|
|
|
|
r->bge_addr1.bge_addr_lo = BGE_ADDR_LO(segs[1].ds_addr);
|
|
|
|
r->bge_addr1.bge_addr_hi = BGE_ADDR_HI(segs[1].ds_addr);
|
|
|
|
r->bge_len1 = segs[1].ds_len;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][1] = segs[1].ds_len;
|
2006-01-18 14:31:21 +00:00
|
|
|
case 1:
|
|
|
|
r->bge_addr0.bge_addr_lo = BGE_ADDR_LO(segs[0].ds_addr);
|
|
|
|
r->bge_addr0.bge_addr_hi = BGE_ADDR_HI(segs[0].ds_addr);
|
|
|
|
r->bge_len0 = segs[0].ds_len;
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_seglen[i][0] = segs[0].ds_len;
|
2006-01-18 14:31:21 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("%s: %d segments\n", __func__, nsegs);
|
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2009-11-04 20:19:21 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_mtag_jumbo,
|
2009-11-07 01:01:33 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i], BUS_DMASYNC_PREREAD);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_init_rx_ring_std(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2009-11-04 21:06:54 +00:00
|
|
|
int error, i;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-09 23:09:18 +00:00
|
|
|
bzero(sc->bge_ldata.bge_rx_std_ring, BGE_STD_RX_RING_SZ);
|
2009-11-07 02:10:59 +00:00
|
|
|
sc->bge_std = 0;
|
2010-06-05 23:29:24 +00:00
|
|
|
for (i = 0; i < BGE_STD_RX_RING_CNT; i++) {
|
2009-11-07 01:01:33 +00:00
|
|
|
if ((error = bge_newbuf_std(sc, i)) != 0)
|
2009-11-04 21:06:54 +00:00
|
|
|
return (error);
|
2009-11-07 02:10:59 +00:00
|
|
|
BGE_INC(sc->bge_std, BGE_STD_RX_RING_CNT);
|
2001-09-27 23:55:28 +00:00
|
|
|
};
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_std_ring_tag,
|
2009-11-22 19:17:32 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_ring_map, BUS_DMASYNC_PREWRITE);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_std = 0;
|
|
|
|
bge_writembx(sc, BGE_MBX_RX_STD_PROD_LO, BGE_STD_RX_RING_CNT - 1);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_free_rx_ring_std(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BGE_STD_RX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_rx_std_chain[i] != NULL) {
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_mtag,
|
2005-12-22 01:44:27 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i],
|
|
|
|
BUS_DMASYNC_POSTREAD);
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_rx_mtag,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i]);
|
2005-12-22 01:44:27 +00:00
|
|
|
m_freem(sc->bge_cdata.bge_rx_std_chain[i]);
|
|
|
|
sc->bge_cdata.bge_rx_std_chain[i] = NULL;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
bzero((char *)&sc->bge_ldata.bge_rx_std_ring[i],
|
2001-09-27 23:55:28 +00:00
|
|
|
sizeof(struct bge_rx_bd));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_init_rx_ring_jumbo(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_rcb *rcb;
|
2009-11-04 21:06:54 +00:00
|
|
|
int error, i;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-09 23:09:18 +00:00
|
|
|
bzero(sc->bge_ldata.bge_rx_jumbo_ring, BGE_JUMBO_RX_RING_SZ);
|
2009-11-07 02:10:59 +00:00
|
|
|
sc->bge_jumbo = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
for (i = 0; i < BGE_JUMBO_RX_RING_CNT; i++) {
|
2009-11-07 01:01:33 +00:00
|
|
|
if ((error = bge_newbuf_jumbo(sc, i)) != 0)
|
2009-11-04 21:06:54 +00:00
|
|
|
return (error);
|
2009-11-07 02:10:59 +00:00
|
|
|
BGE_INC(sc->bge_jumbo, BGE_JUMBO_RX_RING_CNT);
|
2001-09-27 23:55:28 +00:00
|
|
|
};
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
2009-11-22 19:17:32 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map, BUS_DMASYNC_PREWRITE);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2010-06-05 23:29:24 +00:00
|
|
|
sc->bge_jumbo = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
rcb = &sc->bge_ldata.bge_info.bge_jumbo_rx_rcb;
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
rcb->bge_maxlen_flags = BGE_RCB_MAXLEN_FLAGS(0,
|
|
|
|
BGE_RCB_FLAG_USE_EXT_RX_BD);
|
2003-01-06 23:46:47 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RX_JUMBO_RCB_MAXLEN_FLAGS, rcb->bge_maxlen_flags);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2010-06-05 23:29:24 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_JUMBO_PROD_LO, BGE_JUMBO_RX_RING_CNT - 1);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_free_rx_ring_jumbo(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BGE_JUMBO_RX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_chain[i] != NULL) {
|
2005-12-22 01:44:27 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i],
|
|
|
|
BUS_DMASYNC_POSTREAD);
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i]);
|
2005-12-22 01:44:27 +00:00
|
|
|
m_freem(sc->bge_cdata.bge_rx_jumbo_chain[i]);
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_chain[i] = NULL;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
bzero((char *)&sc->bge_ldata.bge_rx_jumbo_ring[i],
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
sizeof(struct bge_extrx_bd));
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_free_tx_ring(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
if (sc->bge_ldata.bge_tx_ring == NULL)
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < BGE_TX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_tx_chain[i] != NULL) {
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_mtag,
|
2005-12-22 01:44:27 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[i],
|
|
|
|
BUS_DMASYNC_POSTWRITE);
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_tx_mtag,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[i]);
|
2005-12-22 01:44:27 +00:00
|
|
|
m_freem(sc->bge_cdata.bge_tx_chain[i]);
|
|
|
|
sc->bge_cdata.bge_tx_chain[i] = NULL;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
bzero((char *)&sc->bge_ldata.bge_tx_ring[i],
|
2001-09-27 23:55:28 +00:00
|
|
|
sizeof(struct bge_tx_bd));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_init_tx_ring(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
sc->bge_txcnt = 0;
|
|
|
|
sc->bge_tx_saved_considx = 0;
|
2003-05-04 00:07:21 +00:00
|
|
|
|
2009-11-09 23:09:18 +00:00
|
|
|
bzero(sc->bge_ldata.bge_tx_ring, BGE_TX_RING_SZ);
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_ring_tag,
|
2009-11-10 20:29:20 +00:00
|
|
|
sc->bge_cdata.bge_tx_ring_map, BUS_DMASYNC_PREWRITE);
|
2009-11-09 23:09:18 +00:00
|
|
|
|
2005-12-18 20:26:12 +00:00
|
|
|
/* Initialize transmit producer index for host-memory send ring. */
|
|
|
|
sc->bge_tx_prodidx = 0;
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_TX_HOST_PROD0_LO, sc->bge_tx_prodidx);
|
2005-12-18 20:26:12 +00:00
|
|
|
|
2003-05-04 00:07:21 +00:00
|
|
|
/* 5700 b2 errata */
|
2003-05-07 21:51:13 +00:00
|
|
|
if (sc->bge_chiprev == BGE_CHIPREV_5700_BX)
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_TX_HOST_PROD0_LO, sc->bge_tx_prodidx);
|
2003-05-04 00:07:21 +00:00
|
|
|
|
2005-12-18 20:26:12 +00:00
|
|
|
/* NIC-memory send ring not used; initialize to zero. */
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_TX_NIC_PROD0_LO, 0);
|
2003-05-04 00:07:21 +00:00
|
|
|
/* 5700 b2 errata */
|
2003-05-07 21:51:13 +00:00
|
|
|
if (sc->bge_chiprev == BGE_CHIPREV_5700_BX)
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_TX_NIC_PROD0_LO, 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-09-18 22:18:21 +00:00
|
|
|
static void
|
|
|
|
bge_setpromisc(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
|
|
|
ifp = sc->bge_ifp;
|
|
|
|
|
2006-12-20 01:12:07 +00:00
|
|
|
/* Enable or disable promiscuous mode as needed. */
|
2006-09-18 22:18:21 +00:00
|
|
|
if (ifp->if_flags & IFF_PROMISC)
|
2006-12-20 01:12:07 +00:00
|
|
|
BGE_SETBIT(sc, BGE_RX_MODE, BGE_RXMODE_RX_PROMISC);
|
2006-09-18 22:18:21 +00:00
|
|
|
else
|
2006-12-20 01:12:07 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_RX_MODE, BGE_RXMODE_RX_PROMISC);
|
2006-09-18 22:18:21 +00:00
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_setmulti(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ifmultiaddr *ifma;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t hashes[4] = { 0, 0, 0, 0 };
|
2001-09-27 23:55:28 +00:00
|
|
|
int h, i;
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
|
|
|
|
for (i = 0; i < 4; i++)
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAR0 + (i * 4), 0xFFFFFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* First, zot all the existing filters. */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
CSR_WRITE_4(sc, BGE_MAR0 + (i * 4), 0);
|
|
|
|
|
|
|
|
/* Now program new ones. */
|
2009-06-26 11:45:06 +00:00
|
|
|
if_maddr_rlock(ifp);
|
2001-09-27 23:55:28 +00:00
|
|
|
TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
|
|
|
|
if (ifma->ifma_addr->sa_family != AF_LINK)
|
|
|
|
continue;
|
2004-06-09 14:34:04 +00:00
|
|
|
h = ether_crc32_le(LLADDR((struct sockaddr_dl *)
|
2007-03-08 00:29:18 +00:00
|
|
|
ifma->ifma_addr), ETHER_ADDR_LEN) & 0x7F;
|
|
|
|
hashes[(h & 0x60) >> 5] |= 1 << (h & 0x1F);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2009-06-26 11:45:06 +00:00
|
|
|
if_maddr_runlock(ifp);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
CSR_WRITE_4(sc, BGE_MAR0 + (i * 4), hashes[i]);
|
|
|
|
}
|
|
|
|
|
2007-06-01 02:02:39 +00:00
|
|
|
static void
|
|
|
|
bge_setvlan(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
|
|
|
ifp = sc->bge_ifp;
|
|
|
|
|
|
|
|
/* Enable or disable VLAN tag stripping as needed. */
|
|
|
|
if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
|
|
|
|
BGE_CLRBIT(sc, BGE_RX_MODE, BGE_RXMODE_RX_KEEP_VLAN_DIAG);
|
|
|
|
else
|
|
|
|
BGE_SETBIT(sc, BGE_RX_MODE, BGE_RXMODE_RX_KEEP_VLAN_DIAG);
|
|
|
|
}
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
static void
|
2010-07-13 19:33:46 +00:00
|
|
|
bge_sig_pre_reset(struct bge_softc *sc, int type)
|
2006-09-09 03:36:57 +00:00
|
|
|
{
|
2010-07-13 19:33:46 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
/*
|
|
|
|
* Some chips don't like this so only do this if ASF is enabled
|
|
|
|
*/
|
|
|
|
if (sc->bge_asf_mode)
|
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENCOMM, BGE_MAGIC_NUMBER);
|
|
|
|
|
|
|
|
if (sc->bge_asf_mode & ASF_NEW_HANDSHAKE) {
|
|
|
|
switch (type) {
|
|
|
|
case BGE_RESET_START:
|
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x1); /* START */
|
|
|
|
break;
|
|
|
|
case BGE_RESET_STOP:
|
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x2); /* UNLOAD */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-13 19:33:46 +00:00
|
|
|
bge_sig_post_reset(struct bge_softc *sc, int type)
|
2006-09-09 03:36:57 +00:00
|
|
|
{
|
2010-07-13 19:33:46 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
if (sc->bge_asf_mode & ASF_NEW_HANDSHAKE) {
|
|
|
|
switch (type) {
|
|
|
|
case BGE_RESET_START:
|
2009-11-22 18:30:19 +00:00
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x80000001);
|
2006-09-09 03:36:57 +00:00
|
|
|
/* START DONE */
|
|
|
|
break;
|
|
|
|
case BGE_RESET_STOP:
|
2009-11-22 18:30:19 +00:00
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x80000002);
|
2006-09-09 03:36:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-13 19:33:46 +00:00
|
|
|
bge_sig_legacy(struct bge_softc *sc, int type)
|
2006-09-09 03:36:57 +00:00
|
|
|
{
|
2010-07-13 19:33:46 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
if (sc->bge_asf_mode) {
|
|
|
|
switch (type) {
|
|
|
|
case BGE_RESET_START:
|
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x1); /* START */
|
|
|
|
break;
|
|
|
|
case BGE_RESET_STOP:
|
|
|
|
bge_writemem_ind(sc, BGE_SDI_STATUS, 0x2); /* UNLOAD */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-13 19:33:46 +00:00
|
|
|
static void
|
|
|
|
bge_stop_fw(struct bge_softc *sc)
|
2006-09-09 03:36:57 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (sc->bge_asf_mode) {
|
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENCOMM_FW, BGE_FW_PAUSE);
|
|
|
|
CSR_WRITE_4(sc, BGE_CPU_EVENT,
|
2007-03-08 00:49:26 +00:00
|
|
|
CSR_READ_4(sc, BGE_CPU_EVENT) | (1 << 14));
|
2006-09-09 03:36:57 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 100; i++ ) {
|
|
|
|
if (!(CSR_READ_4(sc, BGE_CPU_EVENT) & (1 << 14)))
|
|
|
|
break;
|
|
|
|
DELAY(10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
2009-03-23 14:36:50 +00:00
|
|
|
* Do endian, PCI and DMA initialization.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_chipinit(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t dma_rw_ctl;
|
2010-03-10 20:22:57 +00:00
|
|
|
uint16_t val;
|
2006-06-07 21:03:20 +00:00
|
|
|
int i;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
/* Set endianness before we access any non-PCI registers. */
|
2005-12-15 05:48:49 +00:00
|
|
|
pci_write_config(sc->bge_dev, BGE_PCI_MISC_CTL, BGE_INIT, 4);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Clear the MAC control register */
|
|
|
|
CSR_WRITE_4(sc, BGE_MAC_MODE, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the MAC statistics block in the NIC's
|
|
|
|
* internal memory.
|
|
|
|
*/
|
|
|
|
for (i = BGE_STATS_BLOCK;
|
2006-06-07 21:03:20 +00:00
|
|
|
i < BGE_STATS_BLOCK_END + 1; i += sizeof(uint32_t))
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_MEMWIN_WRITE(sc, i, 0);
|
|
|
|
|
|
|
|
for (i = BGE_STATUS_BLOCK;
|
2006-06-07 21:03:20 +00:00
|
|
|
i < BGE_STATUS_BLOCK_END + 1; i += sizeof(uint32_t))
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_MEMWIN_WRITE(sc, i, 0);
|
|
|
|
|
2010-03-10 20:22:57 +00:00
|
|
|
if (sc->bge_chiprev == BGE_CHIPREV_5704_BX) {
|
|
|
|
/*
|
2010-03-10 20:55:55 +00:00
|
|
|
* Fix data corruption caused by non-qword write with WB.
|
2010-03-10 20:22:57 +00:00
|
|
|
* Fix master abort in PCI mode.
|
|
|
|
* Fix PCI latency timer.
|
|
|
|
*/
|
|
|
|
val = pci_read_config(sc->bge_dev, BGE_PCI_MSI_DATA + 2, 2);
|
|
|
|
val |= (1 << 10) | (1 << 12) | (1 << 13);
|
|
|
|
pci_write_config(sc->bge_dev, BGE_PCI_MSI_DATA + 2, val, 2);
|
|
|
|
}
|
|
|
|
|
2007-05-22 19:22:58 +00:00
|
|
|
/*
|
|
|
|
* Set up the PCI DMA control register.
|
|
|
|
*/
|
|
|
|
dma_rw_ctl = BGE_PCIDMARWCTL_RD_CMD_SHIFT(6) |
|
|
|
|
BGE_PCIDMARWCTL_WR_CMD_SHIFT(7);
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE) {
|
2007-05-22 19:22:58 +00:00
|
|
|
/* Read watermark not used, 128 bytes for write. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_WR_WAT_SHIFT(3);
|
2006-08-23 11:32:54 +00:00
|
|
|
} else if (sc->bge_flags & BGE_FLAG_PCIX) {
|
2006-06-15 14:31:49 +00:00
|
|
|
if (BGE_IS_5714_FAMILY(sc)) {
|
2007-05-22 19:22:58 +00:00
|
|
|
/* 256 bytes for read and write. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_RD_WAT_SHIFT(2) |
|
|
|
|
BGE_PCIDMARWCTL_WR_WAT_SHIFT(2);
|
|
|
|
dma_rw_ctl |= (sc->bge_asicrev == BGE_ASICREV_BCM5780) ?
|
|
|
|
BGE_PCIDMARWCTL_ONEDMA_ATONCE_GLOBAL :
|
|
|
|
BGE_PCIDMARWCTL_ONEDMA_ATONCE_LOCAL;
|
2010-03-10 20:54:08 +00:00
|
|
|
} else if (sc->bge_asicrev == BGE_ASICREV_BCM5703) {
|
|
|
|
/*
|
|
|
|
* In the BCM5703, the DMA read watermark should
|
|
|
|
* be set to less than or equal to the maximum
|
|
|
|
* memory read byte count of the PCI-X command
|
|
|
|
* register.
|
|
|
|
*/
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_RD_WAT_SHIFT(4) |
|
|
|
|
BGE_PCIDMARWCTL_WR_WAT_SHIFT(3);
|
2007-05-22 19:22:58 +00:00
|
|
|
} else if (sc->bge_asicrev == BGE_ASICREV_BCM5704) {
|
|
|
|
/* 1536 bytes for read, 384 bytes for write. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_RD_WAT_SHIFT(7) |
|
|
|
|
BGE_PCIDMARWCTL_WR_WAT_SHIFT(3);
|
|
|
|
} else {
|
|
|
|
/* 384 bytes for read and write. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_RD_WAT_SHIFT(3) |
|
|
|
|
BGE_PCIDMARWCTL_WR_WAT_SHIFT(3) |
|
2007-03-08 00:29:18 +00:00
|
|
|
0x0F;
|
2007-05-22 19:22:58 +00:00
|
|
|
}
|
2003-05-07 21:51:13 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5703 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5704) {
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t tmp;
|
2003-05-03 22:58:45 +00:00
|
|
|
|
2007-05-22 19:22:58 +00:00
|
|
|
/* Set ONE_DMA_AT_ONCE for hardware workaround. */
|
2007-03-08 00:29:18 +00:00
|
|
|
tmp = CSR_READ_4(sc, BGE_PCI_CLKCTL) & 0x1F;
|
2007-05-22 19:22:58 +00:00
|
|
|
if (tmp == 6 || tmp == 7)
|
|
|
|
dma_rw_ctl |=
|
|
|
|
BGE_PCIDMARWCTL_ONEDMA_ATONCE_GLOBAL;
|
|
|
|
|
|
|
|
/* Set PCI-X DMA write workaround. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_ASRT_ALL_BE;
|
2003-05-03 22:58:45 +00:00
|
|
|
}
|
2007-05-22 19:22:58 +00:00
|
|
|
} else {
|
|
|
|
/* Conventional PCI bus: 256 bytes for read and write. */
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_RD_WAT_SHIFT(7) |
|
|
|
|
BGE_PCIDMARWCTL_WR_WAT_SHIFT(7);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-05-22 19:22:58 +00:00
|
|
|
if (sc->bge_asicrev != BGE_ASICREV_BCM5705 &&
|
|
|
|
sc->bge_asicrev != BGE_ASICREV_BCM5750)
|
|
|
|
dma_rw_ctl |= 0x0F;
|
|
|
|
}
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5701)
|
|
|
|
dma_rw_ctl |= BGE_PCIDMARWCTL_USE_MRM |
|
|
|
|
BGE_PCIDMARWCTL_ASRT_ALL_BE;
|
2003-05-07 21:51:13 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5703 ||
|
2007-05-22 19:22:58 +00:00
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5704)
|
2003-05-03 22:58:45 +00:00
|
|
|
dma_rw_ctl &= ~BGE_PCIDMARWCTL_MINDMA;
|
|
|
|
pci_write_config(sc->bge_dev, BGE_PCI_DMA_RW_CTL, dma_rw_ctl, 4);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Set up general mode register.
|
|
|
|
*/
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MODE_CTL, BGE_DMA_SWAP_OPTIONS |
|
|
|
|
BGE_MODECTL_MAC_ATTN_INTR | BGE_MODECTL_HOST_SEND_BDS |
|
2006-02-02 09:58:31 +00:00
|
|
|
BGE_MODECTL_TX_NO_PHDR_CSUM);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2008-12-09 21:34:22 +00:00
|
|
|
/*
|
|
|
|
* BCM5701 B5 have a bug causing data corruption when using
|
|
|
|
* 64-bit DMA reads, which can be terminated early and then
|
|
|
|
* completed later as 32-bit accesses, in combination with
|
|
|
|
* certain bridges.
|
|
|
|
*/
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5701 &&
|
|
|
|
sc->bge_chipid == BGE_CHIPID_BCM5701_B5)
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_FORCE_PCI32);
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
/*
|
|
|
|
* Tell the firmware the driver is running
|
|
|
|
*/
|
|
|
|
if (sc->bge_asf_mode & ASF_STACKUP)
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
2002-09-22 18:58:58 +00:00
|
|
|
* Disable memory write invalidate. Apparently it is not supported
|
2009-03-23 14:36:50 +00:00
|
|
|
* properly by these devices. Also ensure that INTx isn't disabled,
|
|
|
|
* as these chips need it even when using MSI.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
2009-03-23 14:36:50 +00:00
|
|
|
PCI_CLRBIT(sc->bge_dev, BGE_PCI_CMD,
|
|
|
|
PCIM_CMD_INTxDIS | PCIM_CMD_MWIEN, 4);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Set the timer prescaler (always 66Mhz) */
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MISC_CFG, BGE_32BITTIME_66MHZ);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
/* XXX: The Linux tg3 driver does this at the start of brgphy_reset. */
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906) {
|
|
|
|
DELAY(40); /* XXX */
|
|
|
|
|
|
|
|
/* Put PHY into ready state */
|
|
|
|
BGE_CLRBIT(sc, BGE_MISC_CFG, BGE_MISCCFG_EPHY_IDDQ);
|
|
|
|
CSR_READ_4(sc, BGE_MISC_CFG); /* Flush */
|
|
|
|
DELAY(40);
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_blockinit(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_rcb *rcb;
|
2005-12-15 05:48:49 +00:00
|
|
|
bus_size_t vrcb;
|
|
|
|
bge_hostaddr taddr;
|
2006-12-12 05:11:12 +00:00
|
|
|
uint32_t val;
|
2001-09-27 23:55:28 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the memory window pointer register so that
|
|
|
|
* we can access the first 32K of internal NIC RAM. This will
|
|
|
|
* allow us to set up the TX send ring RCBs and the RX return
|
|
|
|
* ring RCBs, plus other things which live in NIC memory.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, BGE_PCI_MEMWIN_BASEADDR, 0);
|
|
|
|
|
2003-08-10 18:04:35 +00:00
|
|
|
/* Note: the BCM5704 has a smaller mbuf space than other chips. */
|
|
|
|
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc))) {
|
2003-07-16 00:09:56 +00:00
|
|
|
/* Configure mbuf memory pool */
|
2006-12-04 19:50:49 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_BASEADDR, BGE_BUFFPOOL_1);
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5704)
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_LEN, 0x10000);
|
|
|
|
else
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_LEN, 0x18000);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
/* Configure DMA resource pool */
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_DMA_DESCPOOL_BASEADDR,
|
|
|
|
BGE_DMA_DESCRIPTORS);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_DMA_DESCPOOL_LEN, 0x2000);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Configure mbuf pool watermarks */
|
2008-04-29 19:47:13 +00:00
|
|
|
if (!BGE_IS_5705_PLUS(sc)) {
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_READDMA_LOWAT, 0x50);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_MACRX_LOWAT, 0x20);
|
2008-04-29 19:47:13 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_HIWAT, 0x60);
|
|
|
|
} else if (sc->bge_asicrev == BGE_ASICREV_BCM5906) {
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_READDMA_LOWAT, 0x0);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_MACRX_LOWAT, 0x04);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_HIWAT, 0x10);
|
|
|
|
} else {
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_READDMA_LOWAT, 0x0);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_MACRX_LOWAT, 0x10);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MBUFPOOL_HIWAT, 0x60);
|
2003-07-16 00:09:56 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Configure DMA resource watermarks */
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_DMA_DESCPOOL_LOWAT, 5);
|
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_DMA_DESCPOOL_HIWAT, 10);
|
|
|
|
|
|
|
|
/* Enable buffer manager */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc))) {
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_BMAN_MODE,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_BMANMODE_ENABLE | BGE_BMANMODE_LOMBUF_ATTN);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
/* Poll for buffer manager start indication */
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
2007-05-22 18:51:05 +00:00
|
|
|
DELAY(10);
|
2007-03-08 00:29:18 +00:00
|
|
|
if (CSR_READ_4(sc, BGE_BMAN_MODE) & BGE_BMANMODE_ENABLE)
|
2003-07-16 00:09:56 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
if (i == BGE_TIMEOUT) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"buffer manager failed to start\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENXIO);
|
2003-07-16 00:09:56 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable flow-through queues */
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_FTQ_RESET, 0xFFFFFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_FTQ_RESET, 0);
|
|
|
|
|
|
|
|
/* Wait until queue initialization is complete */
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
2007-05-22 18:51:05 +00:00
|
|
|
DELAY(10);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (CSR_READ_4(sc, BGE_FTQ_RESET) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == BGE_TIMEOUT) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "flow-through queue init failed\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENXIO);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the standard RX ring control block */
|
2003-07-25 19:42:44 +00:00
|
|
|
rcb = &sc->bge_ldata.bge_info.bge_std_rx_rcb;
|
|
|
|
rcb->bge_hostaddr.bge_addr_lo =
|
|
|
|
BGE_ADDR_LO(sc->bge_ldata.bge_rx_std_ring_paddr);
|
|
|
|
rcb->bge_hostaddr.bge_addr_hi =
|
|
|
|
BGE_ADDR_HI(sc->bge_ldata.bge_rx_std_ring_paddr);
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_std_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_std_ring_map, BUS_DMASYNC_PREREAD);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2003-07-16 00:09:56 +00:00
|
|
|
rcb->bge_maxlen_flags = BGE_RCB_MAXLEN_FLAGS(512, 0);
|
|
|
|
else
|
|
|
|
rcb->bge_maxlen_flags =
|
|
|
|
BGE_RCB_MAXLEN_FLAGS(BGE_MAX_FRAMELEN, 0);
|
2006-12-04 19:50:49 +00:00
|
|
|
rcb->bge_nicaddr = BGE_STD_RX_RINGS;
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RX_STD_RCB_HADDR_HI, rcb->bge_hostaddr.bge_addr_hi);
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_STD_RCB_HADDR_LO, rcb->bge_hostaddr.bge_addr_lo);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2003-01-06 23:46:47 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RX_STD_RCB_MAXLEN_FLAGS, rcb->bge_maxlen_flags);
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_STD_RCB_NICADDR, rcb->bge_nicaddr);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the jumbo RX ring control block
|
|
|
|
* We set the 'ring disabled' bit in the flags
|
|
|
|
* field until we're actually ready to start
|
|
|
|
* using this ring (i.e. once we set the MTU
|
|
|
|
* high enough to require it).
|
|
|
|
*/
|
2006-06-15 14:31:49 +00:00
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc)) {
|
2003-07-25 19:42:44 +00:00
|
|
|
rcb = &sc->bge_ldata.bge_info.bge_jumbo_rx_rcb;
|
|
|
|
|
|
|
|
rcb->bge_hostaddr.bge_addr_lo =
|
|
|
|
BGE_ADDR_LO(sc->bge_ldata.bge_rx_jumbo_ring_paddr);
|
|
|
|
rcb->bge_hostaddr.bge_addr_hi =
|
|
|
|
BGE_ADDR_HI(sc->bge_ldata.bge_rx_jumbo_ring_paddr);
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map,
|
|
|
|
BUS_DMASYNC_PREREAD);
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
rcb->bge_maxlen_flags = BGE_RCB_MAXLEN_FLAGS(0,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_RCB_FLAG_USE_EXT_RX_BD | BGE_RCB_FLAG_RING_DISABLED);
|
2006-12-04 19:50:49 +00:00
|
|
|
rcb->bge_nicaddr = BGE_JUMBO_RX_RINGS;
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RX_JUMBO_RCB_HADDR_HI,
|
|
|
|
rcb->bge_hostaddr.bge_addr_hi);
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_JUMBO_RCB_HADDR_LO,
|
|
|
|
rcb->bge_hostaddr.bge_addr_lo);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RX_JUMBO_RCB_MAXLEN_FLAGS,
|
|
|
|
rcb->bge_maxlen_flags);
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_JUMBO_RCB_NICADDR, rcb->bge_nicaddr);
|
|
|
|
|
|
|
|
/* Set up dummy disabled mini ring RCB */
|
2009-12-08 03:24:29 +00:00
|
|
|
rcb = &sc->bge_ldata.bge_info.bge_mini_rx_rcb;
|
|
|
|
rcb->bge_maxlen_flags =
|
|
|
|
BGE_RCB_MAXLEN_FLAGS(0, BGE_RCB_FLAG_RING_DISABLED);
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_MINI_RCB_MAXLEN_FLAGS,
|
|
|
|
rcb->bge_maxlen_flags);
|
2003-07-16 00:09:56 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the BD ring replentish thresholds. The recommended
|
|
|
|
* values are 1/8th the number of descriptors allocated to
|
|
|
|
* each ring.
|
2006-12-13 21:13:09 +00:00
|
|
|
* XXX The 5754 requires a lower threshold, so it might be a
|
|
|
|
* requirement of all 575x family chips. The Linux driver sets
|
|
|
|
* the lower threshold for all 5705 family chips as well, but there
|
|
|
|
* are reports that it might not need to be so strict.
|
2008-04-29 19:47:13 +00:00
|
|
|
*
|
|
|
|
* XXX Linux does some extra fiddling here for the 5906 parts as
|
|
|
|
* well.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
2006-12-13 21:03:55 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2006-12-12 05:11:12 +00:00
|
|
|
val = 8;
|
|
|
|
else
|
|
|
|
val = BGE_STD_RX_RING_CNT / 8;
|
|
|
|
CSR_WRITE_4(sc, BGE_RBDI_STD_REPL_THRESH, val);
|
2009-12-07 19:26:54 +00:00
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc))
|
|
|
|
CSR_WRITE_4(sc, BGE_RBDI_JUMBO_REPL_THRESH,
|
|
|
|
BGE_JUMBO_RX_RING_CNT/8);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable all unused send rings by setting the 'ring disabled'
|
|
|
|
* bit in the flags field of all the TX send ring control blocks.
|
|
|
|
* These are located in NIC memory.
|
|
|
|
*/
|
2005-12-15 05:48:49 +00:00
|
|
|
vrcb = BGE_MEMWIN_START + BGE_SEND_RING_RCB;
|
2001-09-27 23:55:28 +00:00
|
|
|
for (i = 0; i < BGE_TX_RINGS_EXTSSRAM_MAX; i++) {
|
2005-12-15 05:48:49 +00:00
|
|
|
RCB_WRITE_4(sc, vrcb, bge_maxlen_flags,
|
|
|
|
BGE_RCB_MAXLEN_FLAGS(0, BGE_RCB_FLAG_RING_DISABLED));
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_nicaddr, 0);
|
|
|
|
vrcb += sizeof(struct bge_rcb);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Configure TX RCB 0 (we use only the first ring) */
|
2005-12-15 05:48:49 +00:00
|
|
|
vrcb = BGE_MEMWIN_START + BGE_SEND_RING_RCB;
|
|
|
|
BGE_HOSTADDR(taddr, sc->bge_ldata.bge_tx_ring_paddr);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_hi, taddr.bge_addr_hi);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_lo, taddr.bge_addr_lo);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_nicaddr,
|
|
|
|
BGE_NIC_TXRING_ADDR(0, BGE_TX_RING_CNT));
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2005-12-15 05:48:49 +00:00
|
|
|
RCB_WRITE_4(sc, vrcb, bge_maxlen_flags,
|
|
|
|
BGE_RCB_MAXLEN_FLAGS(BGE_TX_RING_CNT, 0));
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Disable all unused RX return rings */
|
2005-12-15 05:48:49 +00:00
|
|
|
vrcb = BGE_MEMWIN_START + BGE_RX_RETURN_RING_RCB;
|
2001-09-27 23:55:28 +00:00
|
|
|
for (i = 0; i < BGE_RX_RINGS_MAX; i++) {
|
2005-12-15 05:48:49 +00:00
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_hi, 0);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_lo, 0);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_maxlen_flags,
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_RCB_MAXLEN_FLAGS(sc->bge_return_ring_cnt,
|
2005-12-15 05:48:49 +00:00
|
|
|
BGE_RCB_FLAG_RING_DISABLED));
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_nicaddr, 0);
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_CONS0_LO +
|
2006-06-07 21:03:20 +00:00
|
|
|
(i * (sizeof(uint64_t))), 0);
|
2005-12-15 05:48:49 +00:00
|
|
|
vrcb += sizeof(struct bge_rcb);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize RX ring indexes */
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_STD_PROD_LO, 0);
|
2009-12-07 19:26:54 +00:00
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc))
|
|
|
|
bge_writembx(sc, BGE_MBX_RX_JUMBO_PROD_LO, 0);
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700)
|
|
|
|
bge_writembx(sc, BGE_MBX_RX_MINI_PROD_LO, 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up RX return ring 0
|
|
|
|
* Note that the NIC address for RX return rings is 0x00000000.
|
|
|
|
* The return rings live entirely within the host, so the
|
|
|
|
* nicaddr field in the RCB isn't used.
|
|
|
|
*/
|
2005-12-15 05:48:49 +00:00
|
|
|
vrcb = BGE_MEMWIN_START + BGE_RX_RETURN_RING_RCB;
|
|
|
|
BGE_HOSTADDR(taddr, sc->bge_ldata.bge_rx_return_ring_paddr);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_hi, taddr.bge_addr_hi);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_hostaddr.bge_addr_lo, taddr.bge_addr_lo);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_nicaddr, 0x00000000);
|
|
|
|
RCB_WRITE_4(sc, vrcb, bge_maxlen_flags,
|
2009-11-22 18:30:19 +00:00
|
|
|
BGE_RCB_MAXLEN_FLAGS(sc->bge_return_ring_cnt, 0));
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Set random backoff seed for TX */
|
|
|
|
CSR_WRITE_4(sc, BGE_TX_RANDOM_BACKOFF,
|
2005-11-11 16:04:59 +00:00
|
|
|
IF_LLADDR(sc->bge_ifp)[0] + IF_LLADDR(sc->bge_ifp)[1] +
|
|
|
|
IF_LLADDR(sc->bge_ifp)[2] + IF_LLADDR(sc->bge_ifp)[3] +
|
|
|
|
IF_LLADDR(sc->bge_ifp)[4] + IF_LLADDR(sc->bge_ifp)[5] +
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_TX_BACKOFF_SEED_MASK);
|
|
|
|
|
|
|
|
/* Set inter-packet gap */
|
|
|
|
CSR_WRITE_4(sc, BGE_TX_LENGTHS, 0x2620);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Specify which ring to use for packets that don't match
|
|
|
|
* any RX rules.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_RULES_CFG, 0x08);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure number of RX lists. One interrupt distribution
|
|
|
|
* list, sixteen active lists, one bad frames class.
|
|
|
|
*/
|
|
|
|
CSR_WRITE_4(sc, BGE_RXLP_CFG, 0x181);
|
|
|
|
|
|
|
|
/* Inialize RX list placement stats mask. */
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RXLP_STATS_ENABLE_MASK, 0x007FFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RXLP_STATS_CTL, 0x1);
|
|
|
|
|
|
|
|
/* Disable host coalescing until we get it set up */
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_MODE, 0x00000000);
|
|
|
|
|
|
|
|
/* Poll to make sure it's shut down. */
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
2007-05-22 18:51:05 +00:00
|
|
|
DELAY(10);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (!(CSR_READ_4(sc, BGE_HCC_MODE) & BGE_HCCMODE_ENABLE))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == BGE_TIMEOUT) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"host coalescing engine failed to idle\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENXIO);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up host coalescing defaults */
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_RX_COAL_TICKS, sc->bge_rx_coal_ticks);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_TX_COAL_TICKS, sc->bge_tx_coal_ticks);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_RX_MAX_COAL_BDS, sc->bge_rx_max_coal_bds);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_TX_MAX_COAL_BDS, sc->bge_tx_max_coal_bds);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc))) {
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_RX_COAL_TICKS_INT, 0);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_TX_COAL_TICKS_INT, 0);
|
|
|
|
}
|
2006-12-26 18:33:55 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_RX_MAX_COAL_BDS_INT, 1);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_TX_MAX_COAL_BDS_INT, 1);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Set up address of statistics block */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc))) {
|
2003-07-25 19:42:44 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATS_ADDR_HI,
|
|
|
|
BGE_ADDR_HI(sc->bge_ldata.bge_stats_paddr));
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATS_ADDR_LO,
|
2003-07-25 19:42:44 +00:00
|
|
|
BGE_ADDR_LO(sc->bge_ldata.bge_stats_paddr));
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATS_BASEADDR, BGE_STATS_BLOCK);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATUSBLK_BASEADDR, BGE_STATUS_BLOCK);
|
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATS_TICKS, sc->bge_stat_ticks);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Set up address of status block */
|
2003-07-25 19:42:44 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATUSBLK_ADDR_HI,
|
|
|
|
BGE_ADDR_HI(sc->bge_ldata.bge_status_block_paddr));
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_STATUSBLK_ADDR_LO,
|
2003-07-25 19:42:44 +00:00
|
|
|
BGE_ADDR_LO(sc->bge_ldata.bge_status_block_paddr));
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 21:45:55 +00:00
|
|
|
/* Set up status block size. */
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
2010-07-06 18:17:31 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_C0) {
|
2009-11-22 21:45:55 +00:00
|
|
|
val = BGE_STATBLKSZ_FULL;
|
2010-07-06 18:17:31 +00:00
|
|
|
bzero(sc->bge_ldata.bge_status_block, BGE_STATUS_BLK_SZ);
|
|
|
|
} else {
|
2009-11-22 21:45:55 +00:00
|
|
|
val = BGE_STATBLKSZ_32BYTE;
|
2010-07-06 18:17:31 +00:00
|
|
|
bzero(sc->bge_ldata.bge_status_block, 32);
|
|
|
|
}
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
2009-11-22 21:45:55 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Turn on host coalescing state machine */
|
2009-11-22 21:45:55 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_HCC_MODE, val | BGE_HCCMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on RX BD completion state machine and enable attentions */
|
|
|
|
CSR_WRITE_4(sc, BGE_RBDC_MODE,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_RBDCMODE_ENABLE | BGE_RBDCMODE_ATTN);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on RX list placement state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_RXLP_MODE, BGE_RXLPMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on RX list selector state machine. */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RXLS_MODE, BGE_RXLSMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2010-01-14 19:08:43 +00:00
|
|
|
val = BGE_MACMODE_TXDMA_ENB | BGE_MACMODE_RXDMA_ENB |
|
|
|
|
BGE_MACMODE_RX_STATS_CLEAR | BGE_MACMODE_TX_STATS_CLEAR |
|
|
|
|
BGE_MACMODE_RX_STATS_ENB | BGE_MACMODE_TX_STATS_ENB |
|
|
|
|
BGE_MACMODE_FRMHDR_DMA_ENB;
|
|
|
|
|
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI)
|
|
|
|
val |= BGE_PORTMODE_TBI;
|
|
|
|
else if (sc->bge_flags & BGE_FLAG_MII_SERDES)
|
|
|
|
val |= BGE_PORTMODE_GMII;
|
|
|
|
else
|
|
|
|
val |= BGE_PORTMODE_MII;
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Turn on DMA, clear stats */
|
2010-01-14 19:08:43 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_MODE, val);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Set misc. local control, enable interrupts on attentions */
|
|
|
|
CSR_WRITE_4(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_INTR_ONATTN);
|
|
|
|
|
|
|
|
#ifdef notdef
|
|
|
|
/* Assert GPIO pins for PHY reset */
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_SETBIT(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_MISCIO_OUT0 |
|
|
|
|
BGE_MLC_MISCIO_OUT1 | BGE_MLC_MISCIO_OUT2);
|
|
|
|
BGE_SETBIT(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_MISCIO_OUTEN0 |
|
|
|
|
BGE_MLC_MISCIO_OUTEN1 | BGE_MLC_MISCIO_OUTEN2);
|
2001-09-27 23:55:28 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Turn on DMA completion state machine */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_DMAC_MODE, BGE_DMACMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-03-06 20:14:48 +00:00
|
|
|
val = BGE_WDMAMODE_ENABLE | BGE_WDMAMODE_ALL_ATTNS;
|
2006-12-12 05:11:12 +00:00
|
|
|
|
|
|
|
/* Enable host coalescing bug fix. */
|
2009-10-07 13:12:43 +00:00
|
|
|
if (BGE_IS_5755_PLUS(sc))
|
2009-10-07 14:29:48 +00:00
|
|
|
val |= BGE_WDMAMODE_STATUS_TAG_FIX;
|
2006-12-12 05:11:12 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Turn on write DMA state machine */
|
2006-12-12 05:11:12 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_WDMA_MODE, val);
|
2009-03-21 00:23:07 +00:00
|
|
|
DELAY(40);
|
2004-10-30 14:54:51 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Turn on read DMA state machine */
|
2009-03-21 00:23:07 +00:00
|
|
|
val = BGE_RDMAMODE_ENABLE | BGE_RDMAMODE_ALL_ATTNS;
|
2009-10-07 13:12:43 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5784 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5785 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM57780)
|
|
|
|
val |= BGE_RDMAMODE_BD_SBD_CRPT_ATTN |
|
|
|
|
BGE_RDMAMODE_MBUF_RBD_CRPT_ATTN |
|
|
|
|
BGE_RDMAMODE_MBUF_SBD_CRPT_ATTN;
|
2009-03-21 00:23:07 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE)
|
|
|
|
val |= BGE_RDMAMODE_FIFO_LONG_BURST;
|
2010-07-06 02:07:59 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TSO) {
|
2009-11-22 21:16:30 +00:00
|
|
|
val |= BGE_RDMAMODE_TSO4_ENABLE;
|
2010-07-06 02:07:59 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5785 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM57780)
|
|
|
|
val |= BGE_RDMAMODE_TSO6_ENABLE;
|
|
|
|
}
|
2009-03-21 00:23:07 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_RDMA_MODE, val);
|
|
|
|
DELAY(40);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on RX data completion state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_RDC_MODE, BGE_RDCMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on RX BD initiator state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_RBDI_MODE, BGE_RBDIMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on RX data and RX BD initiator state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_RDBDI_MODE, BGE_RDBDIMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on Mbuf cluster free state machine */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MBCF_MODE, BGE_MBCFMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on send BD completion state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_SBDC_MODE, BGE_SBDCMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on send data completion state machine */
|
2009-10-07 13:12:43 +00:00
|
|
|
val = BGE_SDCMODE_ENABLE;
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5761)
|
|
|
|
val |= BGE_SDCMODE_CDELAY;
|
|
|
|
CSR_WRITE_4(sc, BGE_SDC_MODE, val);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on send data initiator state machine */
|
2009-11-22 21:16:30 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TSO)
|
|
|
|
CSR_WRITE_4(sc, BGE_SDI_MODE, BGE_SDIMODE_ENABLE | 0x08);
|
|
|
|
else
|
|
|
|
CSR_WRITE_4(sc, BGE_SDI_MODE, BGE_SDIMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Turn on send BD initiator state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_SBDI_MODE, BGE_SBDIMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Turn on send BD selector state machine */
|
|
|
|
CSR_WRITE_4(sc, BGE_SRS_MODE, BGE_SRSMODE_ENABLE);
|
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_SDI_STATS_ENABLE_MASK, 0x007FFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_SDI_STATS_CTL,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_SDISTATSCTL_ENABLE | BGE_SDISTATSCTL_FASTER);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* ack/clear link change events */
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_STS, BGE_MACSTAT_SYNC_CHANGED |
|
|
|
|
BGE_MACSTAT_CFG_CHANGED | BGE_MACSTAT_MI_COMPLETE |
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_MACSTAT_LINK_CHANGED);
|
2003-07-25 19:42:44 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MI_STS, 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Enable PHY auto polling (for MII/GMII only) */
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MI_STS, BGE_MISTS_LINK);
|
2004-10-30 14:54:51 +00:00
|
|
|
} else {
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_SETBIT(sc, BGE_MI_MODE, BGE_MIMODE_AUTOPOLL | (10 << 16));
|
2006-01-13 08:59:40 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
2006-06-15 14:31:49 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_B2)
|
Try to sort out the correct way to generate async link state change
interrupts. This is a bit harder than it needs to be because there's
more than one way to generate link attentions, at least one of which
does not work on the BCM5700, but does on the 5701.
For the 5701, we can safely use the 'link changed' bit in the status
block, and we enable link change attentions in the mac event register.
For the 5700, we have to use MII interrupts, which require checking
the MAC status register rather than the status block. This requires
doing an extra register access on each interrupt which I'd prefer to
avoid, but them's the breaks. Testing with both a 3c996-T and 3c996B-T
shows that we do in fact detect the link going up and down properly
on cable insertions/disconnections.
Also, avoid twiddling the autopoll enable bit in the MI mode register
when doing a PHY read. I think this coupled with the other changes
will stop the interrupt storms Paul Saab has been harassing me about.
Manually setting the link to 100baseTX full duplex seems to work ok
for me. (I'm typing over the 3c996B-T right now.)
Lastly, teach the driver how to recognize a 3c996B-SX by checking
the hardware config word in the EEPROM in order to detect the media.
We attach 5701 fiber cards correctly now, but I haven't verified that
they send/receive packets yet since I don't have a second fiber
interface at home. (I know that fiber 5700 cards work, so I'm
keeping my fingers crossed.)
2002-04-04 06:01:31 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_EVT_ENB,
|
|
|
|
BGE_EVTENB_MI_INTERRUPT);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-01-13 08:59:40 +00:00
|
|
|
/*
|
|
|
|
* Clear any pending link state attention.
|
|
|
|
* Otherwise some link state change events may be lost until attention
|
|
|
|
* is cleared by bge_intr() -> bge_link_upd() sequence.
|
|
|
|
* It's not necessary on newer BCM chips - perhaps enabling link
|
|
|
|
* state change attentions implies clearing pending attention.
|
|
|
|
*/
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_STS, BGE_MACSTAT_SYNC_CHANGED |
|
|
|
|
BGE_MACSTAT_CFG_CHANGED | BGE_MACSTAT_MI_COMPLETE |
|
2006-01-13 08:59:40 +00:00
|
|
|
BGE_MACSTAT_LINK_CHANGED);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Enable link state change attentions. */
|
|
|
|
BGE_SETBIT(sc, BGE_MAC_EVT_ENB, BGE_EVTENB_LINK_CHANGED);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-06-15 14:31:49 +00:00
|
|
|
const struct bge_revision *
|
|
|
|
bge_lookup_rev(uint32_t chipid)
|
|
|
|
{
|
|
|
|
const struct bge_revision *br;
|
|
|
|
|
|
|
|
for (br = bge_revisions; br->br_name != NULL; br++) {
|
|
|
|
if (br->br_chipid == chipid)
|
|
|
|
return (br);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (br = bge_majorrevs; br->br_name != NULL; br++) {
|
|
|
|
if (br->br_chipid == BGE_ASICREV(chipid))
|
|
|
|
return (br);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct bge_vendor *
|
|
|
|
bge_lookup_vendor(uint16_t vid)
|
|
|
|
{
|
|
|
|
const struct bge_vendor *v;
|
|
|
|
|
|
|
|
for (v = bge_vendors; v->v_name != NULL; v++)
|
|
|
|
if (v->v_id == vid)
|
|
|
|
return (v);
|
2009-11-22 18:30:19 +00:00
|
|
|
|
2006-06-15 14:31:49 +00:00
|
|
|
panic("%s: unknown vendor %d", __func__, vid);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Probe for a Broadcom chip. Check the PCI vendor and device IDs
|
2006-06-15 14:31:49 +00:00
|
|
|
* against our list and return its name if we find a match.
|
|
|
|
*
|
|
|
|
* Note that since the Broadcom controller contains VPD support, we
|
2006-12-18 16:40:04 +00:00
|
|
|
* try to get the device name string from the controller itself instead
|
|
|
|
* of the compiled-in string. It guarantees we'll always announce the
|
|
|
|
* right product name. We fall back to the compiled-in string when
|
|
|
|
* VPD is unavailable or corrupt.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_probe(device_t dev)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2008-09-22 20:55:19 +00:00
|
|
|
const struct bge_type *t = bge_devs;
|
2006-06-15 14:31:49 +00:00
|
|
|
struct bge_softc *sc = device_get_softc(dev);
|
2006-12-18 16:40:04 +00:00
|
|
|
uint16_t vid, did;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
sc->bge_dev = dev;
|
2006-12-18 16:40:04 +00:00
|
|
|
vid = pci_get_vendor(dev);
|
|
|
|
did = pci_get_device(dev);
|
2006-06-15 14:31:49 +00:00
|
|
|
while(t->bge_vid != 0) {
|
2006-12-18 16:40:04 +00:00
|
|
|
if ((vid == t->bge_vid) && (did == t->bge_did)) {
|
|
|
|
char model[64], buf[96];
|
2006-06-15 14:31:49 +00:00
|
|
|
const struct bge_revision *br;
|
|
|
|
const struct bge_vendor *v;
|
|
|
|
uint32_t id;
|
|
|
|
|
2009-10-07 13:12:43 +00:00
|
|
|
id = pci_read_config(dev, BGE_PCI_MISC_CTL, 4) >>
|
|
|
|
BGE_PCIMISCCTL_ASICREV_SHIFT;
|
|
|
|
if (BGE_ASICREV(id) == BGE_ASICREV_USE_PRODID_REG)
|
|
|
|
id = pci_read_config(dev,
|
|
|
|
BGE_PCI_PRODID_ASICREV, 4);
|
2006-06-15 14:31:49 +00:00
|
|
|
br = bge_lookup_rev(id);
|
2006-12-18 16:40:04 +00:00
|
|
|
v = bge_lookup_vendor(vid);
|
2007-03-06 19:15:16 +00:00
|
|
|
{
|
|
|
|
#if __FreeBSD_version > 700024
|
|
|
|
const char *pname;
|
|
|
|
|
2008-09-22 20:55:19 +00:00
|
|
|
if (bge_has_eaddr(sc) &&
|
|
|
|
pci_get_vpd_ident(dev, &pname) == 0)
|
2007-03-06 19:15:16 +00:00
|
|
|
snprintf(model, 64, "%s", pname);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
snprintf(model, 64, "%s %s",
|
|
|
|
v->v_name,
|
|
|
|
br != NULL ? br->br_name :
|
|
|
|
"NetXtreme Ethernet Controller");
|
|
|
|
}
|
2009-10-07 13:12:43 +00:00
|
|
|
snprintf(buf, 96, "%s, %sASIC rev. %#08x", model,
|
|
|
|
br != NULL ? "" : "unknown ", id);
|
2006-06-15 14:31:49 +00:00
|
|
|
device_set_desc_copy(dev, buf);
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENXIO);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_dma_free(struct bge_softc *sc)
|
2003-07-25 19:42:44 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy DMA maps for RX buffers. */
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_STD_RX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_rx_std_dmamap[i])
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_destroy(sc->bge_cdata.bge_rx_mtag,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_dmamap[i]);
|
|
|
|
}
|
2009-11-07 01:01:33 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_std_sparemap)
|
|
|
|
bus_dmamap_destroy(sc->bge_cdata.bge_rx_mtag,
|
|
|
|
sc->bge_cdata.bge_rx_std_sparemap);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy DMA maps for jumbo RX buffers. */
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_JUMBO_RX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_dmamap[i])
|
|
|
|
bus_dmamap_destroy(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_dmamap[i]);
|
|
|
|
}
|
2009-11-07 01:01:33 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_sparemap)
|
|
|
|
bus_dmamap_destroy(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_sparemap);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy DMA maps for TX buffers. */
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_TX_RING_CNT; i++) {
|
|
|
|
if (sc->bge_cdata.bge_tx_dmamap[i])
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_destroy(sc->bge_cdata.bge_tx_mtag,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[i]);
|
|
|
|
}
|
|
|
|
|
2009-11-04 20:57:52 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_mtag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_rx_mtag);
|
|
|
|
if (sc->bge_cdata.bge_tx_mtag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_tx_mtag);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy standard RX ring. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_std_ring_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_rx_std_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_std_ring_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_std_ring_map && sc->bge_ldata.bge_rx_std_ring)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_rx_std_ring_tag,
|
|
|
|
sc->bge_ldata.bge_rx_std_ring,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_ring_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_rx_std_ring_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_rx_std_ring_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy jumbo RX ring. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_ring_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_ring_map &&
|
|
|
|
sc->bge_ldata.bge_rx_jumbo_ring)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
|
|
|
sc->bge_ldata.bge_rx_jumbo_ring,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_rx_jumbo_ring_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_rx_jumbo_ring_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy RX return ring. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_rx_return_ring_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_rx_return_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_return_ring_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_rx_return_ring_map &&
|
|
|
|
sc->bge_ldata.bge_rx_return_ring)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_rx_return_ring_tag,
|
|
|
|
sc->bge_ldata.bge_rx_return_ring,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_rx_return_ring_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_rx_return_ring_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_rx_return_ring_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy TX ring. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_tx_ring_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_tx_ring_tag,
|
|
|
|
sc->bge_cdata.bge_tx_ring_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_tx_ring_map && sc->bge_ldata.bge_tx_ring)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_tx_ring_tag,
|
|
|
|
sc->bge_ldata.bge_tx_ring,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_tx_ring_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_tx_ring_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_tx_ring_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy status block. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_status_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_status_map && sc->bge_ldata.bge_status_block)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_ldata.bge_status_block,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_status_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_status_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_status_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy statistics block. */
|
2005-12-22 01:44:27 +00:00
|
|
|
if (sc->bge_cdata.bge_stats_map)
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_stats_tag,
|
|
|
|
sc->bge_cdata.bge_stats_map);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_stats_map && sc->bge_ldata.bge_stats)
|
|
|
|
bus_dmamem_free(sc->bge_cdata.bge_stats_tag,
|
|
|
|
sc->bge_ldata.bge_stats,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_stats_map);
|
|
|
|
|
|
|
|
if (sc->bge_cdata.bge_stats_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_stats_tag);
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
if (sc->bge_cdata.bge_buffer_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_buffer_tag);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Destroy the parent tag. */
|
2003-07-25 19:42:44 +00:00
|
|
|
if (sc->bge_cdata.bge_parent_tag)
|
|
|
|
bus_dma_tag_destroy(sc->bge_cdata.bge_parent_tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2010-08-31 17:33:48 +00:00
|
|
|
bge_dma_ring_alloc(struct bge_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)
|
2003-07-25 19:42:44 +00:00
|
|
|
{
|
2006-06-07 21:03:20 +00:00
|
|
|
struct bge_dmamap_arg ctx;
|
2009-11-22 20:50:27 +00:00
|
|
|
bus_addr_t lowaddr;
|
2010-08-31 17:33:48 +00:00
|
|
|
bus_size_t ring_end;
|
|
|
|
int error;
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
lowaddr = BUS_SPACE_MAXADDR;
|
|
|
|
again:
|
|
|
|
error = bus_dma_tag_create(sc->bge_cdata.bge_parent_tag,
|
|
|
|
alignment, 0, lowaddr, BUS_SPACE_MAXADDR, NULL,
|
|
|
|
NULL, maxsize, 1, maxsize, 0, NULL, NULL, tag);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"could not create %s dma tag\n", msg);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
/* 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->bge_dev,
|
|
|
|
"could not allocate DMA'able memory for %s\n", msg);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
/* Load the address of the ring. */
|
|
|
|
ctx.bge_busaddr = 0;
|
|
|
|
error = bus_dmamap_load(*tag, *map, *ring, maxsize, bge_dma_map_addr,
|
|
|
|
&ctx, BUS_DMA_NOWAIT);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"could not load DMA'able memory for %s\n", msg);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
*paddr = ctx.bge_busaddr;
|
|
|
|
ring_end = *paddr + maxsize;
|
|
|
|
if ((sc->bge_flags & BGE_FLAG_4G_BNDRY_BUG) != 0 &&
|
|
|
|
BGE_ADDR_HI(*paddr) != BGE_ADDR_HI(ring_end)) {
|
|
|
|
/*
|
|
|
|
* 4GB boundary crossed. Limit maximum allowable DMA
|
|
|
|
* address space to 32bit and try again.
|
|
|
|
*/
|
|
|
|
bus_dmamap_unload(*tag, *map);
|
|
|
|
bus_dmamem_free(*tag, *ring, *map);
|
|
|
|
bus_dma_tag_destroy(*tag);
|
|
|
|
if (bootverbose)
|
|
|
|
device_printf(sc->bge_dev, "4GB boundary crossed, "
|
|
|
|
"limit DMA address space to 32bit for %s\n", msg);
|
|
|
|
*ring = NULL;
|
|
|
|
*tag = NULL;
|
|
|
|
*map = NULL;
|
|
|
|
lowaddr = BUS_SPACE_MAXADDR_32BIT;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_dma_alloc(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
bus_addr_t lowaddr;
|
|
|
|
bus_size_t boundary, sbsz, txsegsz, txmaxsegsz;
|
|
|
|
int i, error;
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2009-11-22 20:50:27 +00:00
|
|
|
lowaddr = BUS_SPACE_MAXADDR;
|
|
|
|
if ((sc->bge_flags & BGE_FLAG_40BIT_BUG) != 0)
|
|
|
|
lowaddr = BGE_DMA_MAXADDR;
|
2003-07-25 19:42:44 +00:00
|
|
|
/*
|
|
|
|
* Allocate the parent bus DMA tag appropriate for PCI.
|
|
|
|
*/
|
2008-04-26 10:54:17 +00:00
|
|
|
error = bus_dma_tag_create(bus_get_dma_tag(sc->bge_dev),
|
2009-11-22 20:50:27 +00:00
|
|
|
1, 0, lowaddr, BUS_SPACE_MAXADDR, NULL,
|
2008-04-26 10:54:17 +00:00
|
|
|
NULL, BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
0, NULL, NULL, &sc->bge_cdata.bge_parent_tag);
|
2005-12-22 01:44:27 +00:00
|
|
|
if (error != 0) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"could not allocate parent dma tag\n");
|
2005-12-22 01:44:27 +00:00
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
/* Create tag for standard RX ring. */
|
|
|
|
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_STD_RX_RING_SZ,
|
|
|
|
&sc->bge_cdata.bge_rx_std_ring_tag,
|
|
|
|
(uint8_t **)&sc->bge_ldata.bge_rx_std_ring,
|
|
|
|
&sc->bge_cdata.bge_rx_std_ring_map,
|
|
|
|
&sc->bge_ldata.bge_rx_std_ring_paddr, "RX ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* Create tag for RX return ring. */
|
|
|
|
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_RX_RTN_RING_SZ(sc),
|
|
|
|
&sc->bge_cdata.bge_rx_return_ring_tag,
|
|
|
|
(uint8_t **)&sc->bge_ldata.bge_rx_return_ring,
|
|
|
|
&sc->bge_cdata.bge_rx_return_ring_map,
|
|
|
|
&sc->bge_ldata.bge_rx_return_ring_paddr, "RX return ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* Create tag for TX ring. */
|
|
|
|
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_TX_RING_SZ,
|
|
|
|
&sc->bge_cdata.bge_tx_ring_tag,
|
|
|
|
(uint8_t **)&sc->bge_ldata.bge_tx_ring,
|
|
|
|
&sc->bge_cdata.bge_tx_ring_map,
|
|
|
|
&sc->bge_ldata.bge_tx_ring_paddr, "TX ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
/*
|
2010-08-31 17:33:48 +00:00
|
|
|
* Create tag for status block.
|
|
|
|
* Because we only use single Tx/Rx/Rx return ring, use
|
|
|
|
* minimum status block size except BCM5700 AX/BX which
|
|
|
|
* seems to want to see full status block size regardless
|
|
|
|
* of configured number of ring.
|
2003-07-25 19:42:44 +00:00
|
|
|
*/
|
2010-08-31 17:33:48 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_C0)
|
|
|
|
sbsz = BGE_STATUS_BLK_SZ;
|
|
|
|
else
|
|
|
|
sbsz = 32;
|
|
|
|
error = bge_dma_ring_alloc(sc, PAGE_SIZE, sbsz,
|
|
|
|
&sc->bge_cdata.bge_status_tag,
|
|
|
|
(uint8_t **)&sc->bge_ldata.bge_status_block,
|
|
|
|
&sc->bge_cdata.bge_status_map,
|
|
|
|
&sc->bge_ldata.bge_status_block_paddr, "status block");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* Create tag for jumbo RX ring. */
|
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc)) {
|
|
|
|
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_JUMBO_RX_RING_SZ,
|
|
|
|
&sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
|
|
|
(uint8_t **)&sc->bge_ldata.bge_rx_jumbo_ring,
|
|
|
|
&sc->bge_cdata.bge_rx_jumbo_ring_map,
|
|
|
|
&sc->bge_ldata.bge_rx_jumbo_ring_paddr, "jumbo RX ring");
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create parent tag for buffers. */
|
|
|
|
boundary = 0;
|
|
|
|
if ((sc->bge_flags & BGE_FLAG_4G_BNDRY_BUG) != 0)
|
2010-08-31 18:48:09 +00:00
|
|
|
boundary = BGE_DMA_BNDRY;
|
2010-08-31 17:33:48 +00:00
|
|
|
error = bus_dma_tag_create(bus_get_dma_tag(sc->bge_dev),
|
|
|
|
1, boundary, lowaddr, BUS_SPACE_MAXADDR, NULL,
|
|
|
|
NULL, BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
0, NULL, NULL, &sc->bge_cdata.bge_buffer_tag);
|
|
|
|
if (error != 0) {
|
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"could not allocate buffer dma tag\n");
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
/* Create tag for Tx mbufs. */
|
2009-11-22 21:16:30 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TSO) {
|
|
|
|
txsegsz = BGE_TSOSEG_SZ;
|
|
|
|
txmaxsegsz = 65535 + sizeof(struct ether_vlan_header);
|
|
|
|
} else {
|
|
|
|
txsegsz = MCLBYTES;
|
|
|
|
txmaxsegsz = MCLBYTES * BGE_NSEG_NEW;
|
|
|
|
}
|
2010-08-31 17:33:48 +00:00
|
|
|
error = bus_dma_tag_create(sc->bge_cdata.bge_buffer_tag, 1,
|
2009-11-22 21:16:30 +00:00
|
|
|
0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
txmaxsegsz, BGE_NSEG_NEW, txsegsz, 0, NULL, NULL,
|
|
|
|
&sc->bge_cdata.bge_tx_mtag);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
|
|
|
if (error) {
|
2009-11-04 20:57:52 +00:00
|
|
|
device_printf(sc->bge_dev, "could not allocate TX dma tag\n");
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
/* Create tag for Rx mbufs. */
|
|
|
|
error = bus_dma_tag_create(sc->bge_cdata.bge_buffer_tag, 1, 0,
|
2009-11-04 20:57:52 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1,
|
2009-11-22 21:16:30 +00:00
|
|
|
MCLBYTES, 0, NULL, NULL, &sc->bge_cdata.bge_rx_mtag);
|
2009-11-04 20:57:52 +00:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->bge_dev, "could not allocate RX dma tag\n");
|
2003-07-25 19:42:44 +00:00
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Create DMA maps for RX buffers. */
|
2009-11-07 01:01:33 +00:00
|
|
|
error = bus_dmamap_create(sc->bge_cdata.bge_rx_mtag, 0,
|
|
|
|
&sc->bge_cdata.bge_rx_std_sparemap);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"can't create spare DMA map for RX\n");
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_STD_RX_RING_CNT; i++) {
|
2009-11-04 20:57:52 +00:00
|
|
|
error = bus_dmamap_create(sc->bge_cdata.bge_rx_mtag, 0,
|
2003-07-25 19:42:44 +00:00
|
|
|
&sc->bge_cdata.bge_rx_std_dmamap[i]);
|
|
|
|
if (error) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"can't create DMA map for RX\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENOMEM);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Create DMA maps for TX buffers. */
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_TX_RING_CNT; i++) {
|
2009-11-04 20:57:52 +00:00
|
|
|
error = bus_dmamap_create(sc->bge_cdata.bge_tx_mtag, 0,
|
2003-07-25 19:42:44 +00:00
|
|
|
&sc->bge_cdata.bge_tx_dmamap[i]);
|
|
|
|
if (error) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
2009-11-04 20:57:52 +00:00
|
|
|
"can't create DMA map for TX\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
return (ENOMEM);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
/* Create tags for jumbo RX buffers. */
|
2006-06-15 14:31:49 +00:00
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc)) {
|
2010-08-31 17:33:48 +00:00
|
|
|
error = bus_dma_tag_create(sc->bge_cdata.bge_buffer_tag,
|
2004-10-19 02:42:49 +00:00
|
|
|
1, 0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
NULL, MJUM9BYTES, BGE_NSEG_JUMBO, PAGE_SIZE,
|
|
|
|
0, NULL, NULL, &sc->bge_cdata.bge_mtag_jumbo);
|
2003-07-25 19:42:44 +00:00
|
|
|
if (error) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
2006-06-07 21:03:20 +00:00
|
|
|
"could not allocate jumbo dma tag\n");
|
2003-07-25 19:42:44 +00:00
|
|
|
return (ENOMEM);
|
|
|
|
}
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Create DMA maps for jumbo RX buffers. */
|
2009-11-07 01:01:33 +00:00
|
|
|
error = bus_dmamap_create(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
0, &sc->bge_cdata.bge_rx_jumbo_sparemap);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->bge_dev,
|
2009-11-22 18:34:15 +00:00
|
|
|
"can't create spare DMA map for jumbo RX\n");
|
2009-11-07 01:01:33 +00:00
|
|
|
return (ENOMEM);
|
|
|
|
}
|
2003-07-25 19:42:44 +00:00
|
|
|
for (i = 0; i < BGE_JUMBO_RX_RING_CNT; i++) {
|
|
|
|
error = bus_dmamap_create(sc->bge_cdata.bge_mtag_jumbo,
|
|
|
|
0, &sc->bge_cdata.bge_rx_jumbo_dmamap[i]);
|
|
|
|
if (error) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
2006-06-07 21:03:20 +00:00
|
|
|
"can't create DMA map for jumbo RX\n");
|
|
|
|
return (ENOMEM);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2003-07-25 19:42:44 +00:00
|
|
|
}
|
|
|
|
|
2006-12-22 02:59:58 +00:00
|
|
|
/*
|
|
|
|
* Return true if this device has more than one port.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
bge_has_multiple_ports(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
device_t dev = sc->bge_dev;
|
2007-09-30 11:05:18 +00:00
|
|
|
u_int b, d, f, fscan, s;
|
2006-12-22 02:59:58 +00:00
|
|
|
|
2007-09-30 11:05:18 +00:00
|
|
|
d = pci_get_domain(dev);
|
2006-12-22 02:59:58 +00:00
|
|
|
b = pci_get_bus(dev);
|
|
|
|
s = pci_get_slot(dev);
|
|
|
|
f = pci_get_function(dev);
|
|
|
|
for (fscan = 0; fscan <= PCI_FUNCMAX; fscan++)
|
2007-09-30 11:05:18 +00:00
|
|
|
if (fscan != f && pci_find_dbsf(d, b, s, fscan) != NULL)
|
2006-12-22 02:59:58 +00:00
|
|
|
return (1);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return true if MSI can be used with this device.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
bge_can_use_msi(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
int can_use_msi = 0;
|
|
|
|
|
|
|
|
switch (sc->bge_asicrev) {
|
2008-10-27 22:10:01 +00:00
|
|
|
case BGE_ASICREV_BCM5714_A0:
|
2006-12-22 02:59:58 +00:00
|
|
|
case BGE_ASICREV_BCM5714:
|
|
|
|
/*
|
2008-10-27 22:10:01 +00:00
|
|
|
* Apparently, MSI doesn't work when these chips are
|
|
|
|
* configured in single-port mode.
|
2006-12-22 02:59:58 +00:00
|
|
|
*/
|
|
|
|
if (bge_has_multiple_ports(sc))
|
|
|
|
can_use_msi = 1;
|
|
|
|
break;
|
|
|
|
case BGE_ASICREV_BCM5750:
|
|
|
|
if (sc->bge_chiprev != BGE_CHIPREV_5750_AX &&
|
|
|
|
sc->bge_chiprev != BGE_CHIPREV_5750_BX)
|
|
|
|
can_use_msi = 1;
|
|
|
|
break;
|
2008-10-27 22:10:01 +00:00
|
|
|
default:
|
|
|
|
if (BGE_IS_575X_PLUS(sc))
|
|
|
|
can_use_msi = 1;
|
2006-12-22 02:59:58 +00:00
|
|
|
}
|
|
|
|
return (can_use_msi);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_attach(device_t dev)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct bge_softc *sc;
|
2008-05-05 18:42:17 +00:00
|
|
|
uint32_t hwcfg = 0, misccfg;
|
2007-04-30 21:55:27 +00:00
|
|
|
u_char eaddr[ETHER_ADDR_LEN];
|
2009-11-22 18:47:56 +00:00
|
|
|
int error, msicount, reg, rid, trys;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
sc->bge_dev = dev;
|
|
|
|
|
2009-11-22 20:31:40 +00:00
|
|
|
TASK_INIT(&sc->bge_intr_task, 0, bge_intr_task, sc);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Map control/status registers.
|
|
|
|
*/
|
|
|
|
pci_enable_busmaster(dev);
|
|
|
|
|
2010-07-13 19:45:40 +00:00
|
|
|
rid = PCIR_BAR(0);
|
2004-03-17 17:50:55 +00:00
|
|
|
sc->bge_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
|
2008-04-26 14:13:48 +00:00
|
|
|
RF_ACTIVE);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
if (sc->bge_res == NULL) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf (sc->bge_dev, "couldn't map memory\n");
|
2001-09-27 23:55:28 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-03-21 00:23:07 +00:00
|
|
|
/* Save various chip information. */
|
2004-09-24 22:24:33 +00:00
|
|
|
sc->bge_chipid =
|
2009-10-07 13:12:43 +00:00
|
|
|
pci_read_config(dev, BGE_PCI_MISC_CTL, 4) >>
|
|
|
|
BGE_PCIMISCCTL_ASICREV_SHIFT;
|
|
|
|
if (BGE_ASICREV(sc->bge_chipid) == BGE_ASICREV_USE_PRODID_REG)
|
|
|
|
sc->bge_chipid = pci_read_config(dev, BGE_PCI_PRODID_ASICREV,
|
|
|
|
4);
|
2004-09-24 22:24:33 +00:00
|
|
|
sc->bge_asicrev = BGE_ASICREV(sc->bge_chipid);
|
|
|
|
sc->bge_chiprev = BGE_CHIPREV(sc->bge_chipid);
|
|
|
|
|
2008-01-18 22:09:50 +00:00
|
|
|
/*
|
2008-04-29 19:47:13 +00:00
|
|
|
* Don't enable Ethernet@WireSpeed for the 5700, 5906, or the
|
2008-01-18 22:09:50 +00:00
|
|
|
* 5705 A0 and A1 chips.
|
|
|
|
*/
|
|
|
|
if (sc->bge_asicrev != BGE_ASICREV_BCM5700 &&
|
2008-04-29 19:47:13 +00:00
|
|
|
sc->bge_asicrev != BGE_ASICREV_BCM5906 &&
|
2008-01-18 22:09:50 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5705_A0 &&
|
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5705_A1)
|
|
|
|
sc->bge_flags |= BGE_FLAG_WIRESPEED;
|
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
if (bge_has_eaddr(sc))
|
|
|
|
sc->bge_flags |= BGE_FLAG_EADDR;
|
2007-04-30 21:55:27 +00:00
|
|
|
|
2006-12-04 19:50:49 +00:00
|
|
|
/* Save chipset family. */
|
|
|
|
switch (sc->bge_asicrev) {
|
2009-10-07 13:12:43 +00:00
|
|
|
case BGE_ASICREV_BCM5755:
|
|
|
|
case BGE_ASICREV_BCM5761:
|
|
|
|
case BGE_ASICREV_BCM5784:
|
|
|
|
case BGE_ASICREV_BCM5785:
|
|
|
|
case BGE_ASICREV_BCM5787:
|
|
|
|
case BGE_ASICREV_BCM57780:
|
|
|
|
sc->bge_flags |= BGE_FLAG_5755_PLUS | BGE_FLAG_575X_PLUS |
|
|
|
|
BGE_FLAG_5705_PLUS;
|
|
|
|
break;
|
2006-12-04 19:50:49 +00:00
|
|
|
case BGE_ASICREV_BCM5700:
|
|
|
|
case BGE_ASICREV_BCM5701:
|
|
|
|
case BGE_ASICREV_BCM5703:
|
|
|
|
case BGE_ASICREV_BCM5704:
|
2006-12-04 22:12:21 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_5700_FAMILY | BGE_FLAG_JUMBO;
|
2006-12-04 19:50:49 +00:00
|
|
|
break;
|
|
|
|
case BGE_ASICREV_BCM5714_A0:
|
|
|
|
case BGE_ASICREV_BCM5780:
|
|
|
|
case BGE_ASICREV_BCM5714:
|
2006-12-04 22:12:21 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_5714_FAMILY /* | BGE_FLAG_JUMBO */;
|
2009-05-14 22:36:56 +00:00
|
|
|
/* FALLTHROUGH */
|
2006-12-04 19:50:49 +00:00
|
|
|
case BGE_ASICREV_BCM5750:
|
|
|
|
case BGE_ASICREV_BCM5752:
|
2008-04-29 19:47:13 +00:00
|
|
|
case BGE_ASICREV_BCM5906:
|
2006-12-04 19:50:49 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_575X_PLUS;
|
2009-05-14 22:36:56 +00:00
|
|
|
/* FALLTHROUGH */
|
2006-12-04 19:50:49 +00:00
|
|
|
case BGE_ASICREV_BCM5705:
|
|
|
|
sc->bge_flags |= BGE_FLAG_5705_PLUS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-01-15 21:43:43 +00:00
|
|
|
/* Set various bug flags. */
|
2007-02-12 23:58:52 +00:00
|
|
|
if (sc->bge_chipid == BGE_CHIPID_BCM5701_A0 ||
|
|
|
|
sc->bge_chipid == BGE_CHIPID_BCM5701_B0)
|
|
|
|
sc->bge_flags |= BGE_FLAG_CRC_BUG;
|
2007-01-15 21:43:43 +00:00
|
|
|
if (sc->bge_chiprev == BGE_CHIPREV_5703_AX ||
|
|
|
|
sc->bge_chiprev == BGE_CHIPREV_5704_AX)
|
|
|
|
sc->bge_flags |= BGE_FLAG_ADC_BUG;
|
|
|
|
if (sc->bge_chipid == BGE_CHIPID_BCM5704_A0)
|
|
|
|
sc->bge_flags |= BGE_FLAG_5704_A0_BUG;
|
2010-02-09 19:12:06 +00:00
|
|
|
if (pci_get_subvendor(dev) == DELL_VENDORID)
|
|
|
|
sc->bge_flags |= BGE_FLAG_NO_3LED;
|
|
|
|
if (pci_get_device(dev) == BCOM_DEVICEID_BCM5755M)
|
|
|
|
sc->bge_flags |= BGE_FLAG_ADJUST_TRIM;
|
2007-02-12 22:51:25 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc) &&
|
|
|
|
!(sc->bge_flags & BGE_FLAG_ADJUST_TRIM)) {
|
2007-01-15 21:43:43 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5755 ||
|
2009-10-07 13:12:43 +00:00
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5761 ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5784 ||
|
2008-03-11 15:05:54 +00:00
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5787) {
|
2010-01-13 22:39:39 +00:00
|
|
|
if (pci_get_device(dev) != BCOM_DEVICEID_BCM5722 &&
|
|
|
|
pci_get_device(dev) != BCOM_DEVICEID_BCM5756)
|
2008-03-11 15:05:54 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_JITTER_BUG;
|
2008-04-29 19:47:13 +00:00
|
|
|
} else if (sc->bge_asicrev != BGE_ASICREV_BCM5906)
|
2007-01-15 21:43:43 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_BER_BUG;
|
|
|
|
}
|
|
|
|
|
2009-11-22 20:50:27 +00:00
|
|
|
/*
|
|
|
|
* All controllers that are not 5755 or higher have 4GB
|
|
|
|
* boundary DMA bug.
|
|
|
|
* Whenever an address crosses a multiple of the 4GB boundary
|
|
|
|
* (including 4GB, 8Gb, 12Gb, etc.) and makes the transition
|
|
|
|
* from 0xX_FFFF_FFFF to 0x(X+1)_0000_0000 an internal DMA
|
|
|
|
* state machine will lockup and cause the device to hang.
|
|
|
|
*/
|
|
|
|
if (BGE_IS_5755_PLUS(sc) == 0)
|
|
|
|
sc->bge_flags |= BGE_FLAG_4G_BNDRY_BUG;
|
2008-05-05 18:42:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We could possibly check for BCOM_DEVICEID_BCM5788 in bge_probe()
|
|
|
|
* but I do not know the DEVICEID for the 5788M.
|
|
|
|
*/
|
|
|
|
misccfg = CSR_READ_4(sc, BGE_MISC_CFG) & BGE_MISCCFG_BOARD_ID;
|
|
|
|
if (misccfg == BGE_MISCCFG_BOARD_ID_5788 ||
|
|
|
|
misccfg == BGE_MISCCFG_BOARD_ID_5788M)
|
|
|
|
sc->bge_flags |= BGE_FLAG_5788;
|
|
|
|
|
2009-11-22 21:16:30 +00:00
|
|
|
/*
|
|
|
|
* Some controllers seem to require a special firmware to use
|
|
|
|
* TSO. But the firmware is not available to FreeBSD and Linux
|
|
|
|
* claims that the TSO performed by the firmware is slower than
|
|
|
|
* hardware based TSO. Moreover the firmware based TSO has one
|
|
|
|
* known bug which can't handle TSO if ethernet header + IP/TCP
|
|
|
|
* header is greater than 80 bytes. The workaround for the TSO
|
|
|
|
* bug exist but it seems it's too expensive than not using
|
|
|
|
* TSO at all. Some hardwares also have the TSO bug so limit
|
|
|
|
* the TSO to the controllers that are not affected TSO issues
|
|
|
|
* (e.g. 5755 or higher).
|
|
|
|
*/
|
2010-01-03 21:49:24 +00:00
|
|
|
if (BGE_IS_5755_PLUS(sc)) {
|
|
|
|
/*
|
|
|
|
* BCM5754 and BCM5787 shares the same ASIC id so
|
|
|
|
* explicit device id check is required.
|
2010-02-26 22:29:42 +00:00
|
|
|
* Due to unknown reason TSO does not work on BCM5755M.
|
2010-01-03 21:49:24 +00:00
|
|
|
*/
|
|
|
|
if (pci_get_device(dev) != BCOM_DEVICEID_BCM5754 &&
|
2010-02-26 22:29:42 +00:00
|
|
|
pci_get_device(dev) != BCOM_DEVICEID_BCM5754M &&
|
|
|
|
pci_get_device(dev) != BCOM_DEVICEID_BCM5755M)
|
2010-01-03 21:49:24 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_TSO;
|
|
|
|
}
|
2009-11-22 21:16:30 +00:00
|
|
|
|
2006-12-12 05:11:12 +00:00
|
|
|
/*
|
|
|
|
* Check if this is a PCI-X or PCI Express device.
|
|
|
|
*/
|
|
|
|
if (pci_find_extcap(dev, PCIY_EXPRESS, ®) == 0) {
|
|
|
|
/*
|
|
|
|
* Found a PCI Express capabilities register, this
|
|
|
|
* must be a PCI Express device.
|
|
|
|
*/
|
2009-11-22 19:11:34 +00:00
|
|
|
sc->bge_flags |= BGE_FLAG_PCIE;
|
|
|
|
sc->bge_expcap = reg;
|
2010-03-25 17:17:35 +00:00
|
|
|
if (pci_get_max_read_req(dev) != 4096)
|
|
|
|
pci_set_max_read_req(dev, 4096);
|
2006-12-12 05:11:12 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Check if the device is in PCI-X Mode.
|
|
|
|
* (This bit is not valid on PCI Express controllers.)
|
|
|
|
*/
|
2009-11-22 19:11:34 +00:00
|
|
|
if (pci_find_extcap(dev, PCIY_PCIX, ®) == 0)
|
|
|
|
sc->bge_pcixcap = reg;
|
2008-12-09 21:34:22 +00:00
|
|
|
if ((pci_read_config(dev, BGE_PCI_PCISTATE, 4) &
|
2006-12-12 05:11:12 +00:00
|
|
|
BGE_PCISTATE_PCI_BUSMODE) == 0)
|
|
|
|
sc->bge_flags |= BGE_FLAG_PCIX;
|
|
|
|
}
|
2006-06-15 14:31:49 +00:00
|
|
|
|
2009-11-24 17:46:58 +00:00
|
|
|
/*
|
|
|
|
* The 40bit DMA bug applies to the 5714/5715 controllers and is
|
|
|
|
* not actually a MAC controller bug but an issue with the embedded
|
|
|
|
* PCIe to PCI-X bridge in the device. Use 40bit DMA workaround.
|
|
|
|
*/
|
|
|
|
if (BGE_IS_5714_FAMILY(sc) && (sc->bge_flags & BGE_FLAG_PCIX))
|
|
|
|
sc->bge_flags |= BGE_FLAG_40BIT_BUG;
|
2009-11-22 18:47:56 +00:00
|
|
|
/*
|
|
|
|
* Allocate the interrupt, using MSI if possible. These devices
|
|
|
|
* support 8 MSI messages, but only the first one is used in
|
|
|
|
* normal operation.
|
|
|
|
*/
|
2009-11-22 19:11:34 +00:00
|
|
|
rid = 0;
|
2009-11-25 17:51:14 +00:00
|
|
|
if (pci_find_extcap(sc->bge_dev, PCIY_MSI, ®) == 0) {
|
2009-11-22 19:11:34 +00:00
|
|
|
sc->bge_msicap = reg;
|
|
|
|
if (bge_can_use_msi(sc)) {
|
|
|
|
msicount = pci_msi_count(dev);
|
|
|
|
if (msicount > 1)
|
|
|
|
msicount = 1;
|
|
|
|
} else
|
|
|
|
msicount = 0;
|
|
|
|
if (msicount == 1 && pci_alloc_msi(dev, &msicount) == 0) {
|
|
|
|
rid = 1;
|
|
|
|
sc->bge_flags |= BGE_FLAG_MSI;
|
|
|
|
}
|
|
|
|
}
|
2006-12-22 02:59:58 +00:00
|
|
|
|
|
|
|
sc->bge_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
|
|
|
|
RF_SHAREABLE | RF_ACTIVE);
|
|
|
|
|
|
|
|
if (sc->bge_irq == NULL) {
|
|
|
|
device_printf(sc->bge_dev, "couldn't map interrupt\n");
|
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-03-21 00:23:07 +00:00
|
|
|
if (bootverbose)
|
|
|
|
device_printf(dev,
|
|
|
|
"CHIP ID 0x%08x; ASIC REV 0x%02x; CHIP REV 0x%02x; %s\n",
|
|
|
|
sc->bge_chipid, sc->bge_asicrev, sc->bge_chiprev,
|
|
|
|
(sc->bge_flags & BGE_FLAG_PCIX) ? "PCI-X" :
|
|
|
|
((sc->bge_flags & BGE_FLAG_PCIE) ? "PCI-E" : "PCI"));
|
|
|
|
|
2006-12-22 02:59:58 +00:00
|
|
|
BGE_LOCK_INIT(sc, device_get_nameunit(dev));
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Try to reset the chip. */
|
2006-09-09 03:36:57 +00:00
|
|
|
if (bge_reset(sc)) {
|
|
|
|
device_printf(sc->bge_dev, "chip reset failed\n");
|
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->bge_asf_mode = 0;
|
2006-09-23 18:55:49 +00:00
|
|
|
if (bge_allow_asf && (bge_readmem_ind(sc, BGE_SOFTWARE_GENCOMM_SIG)
|
|
|
|
== BGE_MAGIC_NUMBER)) {
|
2006-09-09 03:36:57 +00:00
|
|
|
if (bge_readmem_ind(sc, BGE_SOFTWARE_GENCOMM_NICCFG)
|
|
|
|
& BGE_HWCFG_ASF) {
|
|
|
|
sc->bge_asf_mode |= ASF_ENABLE;
|
|
|
|
sc->bge_asf_mode |= ASF_STACKUP;
|
2010-01-22 18:46:37 +00:00
|
|
|
if (BGE_IS_575X_PLUS(sc))
|
2006-09-09 03:36:57 +00:00
|
|
|
sc->bge_asf_mode |= ASF_NEW_HANDSHAKE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to reset the chip again the nice way. */
|
|
|
|
bge_stop_fw(sc);
|
|
|
|
bge_sig_pre_reset(sc, BGE_RESET_STOP);
|
|
|
|
if (bge_reset(sc)) {
|
|
|
|
device_printf(sc->bge_dev, "chip reset failed\n");
|
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
bge_sig_legacy(sc, BGE_RESET_STOP);
|
|
|
|
bge_sig_post_reset(sc, BGE_RESET_STOP);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
if (bge_chipinit(sc)) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "chip initialization failed\n");
|
2001-09-27 23:55:28 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
error = bge_get_eaddr(sc, eaddr);
|
|
|
|
if (error) {
|
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"failed to read station address\n");
|
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
/* 5705 limits RX return ring to 512 entries. */
|
2006-12-04 22:12:21 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_return_ring_cnt = BGE_RETURN_RING_CNT_5705;
|
|
|
|
else
|
|
|
|
sc->bge_return_ring_cnt = BGE_RETURN_RING_CNT;
|
|
|
|
|
2010-08-31 17:33:48 +00:00
|
|
|
if (bge_dma_alloc(sc)) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev,
|
|
|
|
"failed to allocate DMA resources\n");
|
2003-07-25 19:42:44 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2010-08-22 01:39:09 +00:00
|
|
|
bge_add_sysctls(sc);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Set default tuneable values. */
|
|
|
|
sc->bge_stat_ticks = BGE_TICKS_PER_SEC;
|
|
|
|
sc->bge_rx_coal_ticks = 150;
|
|
|
|
sc->bge_tx_coal_ticks = 150;
|
2006-12-12 05:11:12 +00:00
|
|
|
sc->bge_rx_max_coal_bds = 10;
|
|
|
|
sc->bge_tx_max_coal_bds = 10;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2010-08-22 01:39:09 +00:00
|
|
|
/* Initialize checksum features to use. */
|
|
|
|
sc->bge_csum_features = BGE_CSUM_FEATURES;
|
|
|
|
if (sc->bge_forced_udpcsum != 0)
|
|
|
|
sc->bge_csum_features |= CSUM_UDP;
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Set up ifnet structure */
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp = if_alloc(IFT_ETHER);
|
|
|
|
if (ifp == NULL) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "failed to if_alloc()\n");
|
2005-06-10 16:49:24 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
ifp->if_softc = sc;
|
2003-10-31 18:32:15 +00:00
|
|
|
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
|
2001-09-27 23:55:28 +00:00
|
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
|
|
|
|
ifp->if_ioctl = bge_ioctl;
|
|
|
|
ifp->if_start = bge_start;
|
|
|
|
ifp->if_init = bge_init;
|
2004-10-30 21:21:10 +00:00
|
|
|
ifp->if_snd.ifq_drv_maxlen = BGE_TX_RING_CNT - 1;
|
|
|
|
IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen);
|
|
|
|
IFQ_SET_READY(&ifp->if_snd);
|
2010-08-22 01:39:09 +00:00
|
|
|
ifp->if_hwassist = sc->bge_csum_features;
|
2005-12-22 15:14:42 +00:00
|
|
|
ifp->if_capabilities = IFCAP_HWCSUM | IFCAP_VLAN_HWTAGGING |
|
2007-03-06 19:15:16 +00:00
|
|
|
IFCAP_VLAN_MTU;
|
2009-11-22 21:16:30 +00:00
|
|
|
if ((sc->bge_flags & BGE_FLAG_TSO) != 0) {
|
|
|
|
ifp->if_hwassist |= CSUM_TSO;
|
2010-02-20 23:21:06 +00:00
|
|
|
ifp->if_capabilities |= IFCAP_TSO4 | IFCAP_VLAN_HWTSO;
|
2009-11-22 21:16:30 +00:00
|
|
|
}
|
2007-03-06 19:15:16 +00:00
|
|
|
#ifdef IFCAP_VLAN_HWCSUM
|
|
|
|
ifp->if_capabilities |= IFCAP_VLAN_HWCSUM;
|
|
|
|
#endif
|
2001-09-27 23:55:28 +00:00
|
|
|
ifp->if_capenable = ifp->if_capabilities;
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
ifp->if_capabilities |= IFCAP_POLLING;
|
|
|
|
#endif
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-08 10:19:16 +00:00
|
|
|
/*
|
2005-12-22 15:14:42 +00:00
|
|
|
* 5700 B0 chips do not support checksumming correctly due
|
|
|
|
* to hardware bugs.
|
|
|
|
*/
|
|
|
|
if (sc->bge_chipid == BGE_CHIPID_BCM5700_B0) {
|
|
|
|
ifp->if_capabilities &= ~IFCAP_HWCSUM;
|
2009-11-09 00:16:50 +00:00
|
|
|
ifp->if_capenable &= ~IFCAP_HWCSUM;
|
2005-12-22 15:14:42 +00:00
|
|
|
ifp->if_hwassist = 0;
|
|
|
|
}
|
|
|
|
|
Try to sort out the correct way to generate async link state change
interrupts. This is a bit harder than it needs to be because there's
more than one way to generate link attentions, at least one of which
does not work on the BCM5700, but does on the 5701.
For the 5701, we can safely use the 'link changed' bit in the status
block, and we enable link change attentions in the mac event register.
For the 5700, we have to use MII interrupts, which require checking
the MAC status register rather than the status block. This requires
doing an extra register access on each interrupt which I'd prefer to
avoid, but them's the breaks. Testing with both a 3c996-T and 3c996B-T
shows that we do in fact detect the link going up and down properly
on cable insertions/disconnections.
Also, avoid twiddling the autopoll enable bit in the MI mode register
when doing a PHY read. I think this coupled with the other changes
will stop the interrupt storms Paul Saab has been harassing me about.
Manually setting the link to 100baseTX full duplex seems to work ok
for me. (I'm typing over the 3c996B-T right now.)
Lastly, teach the driver how to recognize a 3c996B-SX by checking
the hardware config word in the EEPROM in order to detect the media.
We attach 5701 fiber cards correctly now, but I haven't verified that
they send/receive packets yet since I don't have a second fiber
interface at home. (I know that fiber 5700 cards work, so I'm
keeping my fingers crossed.)
2002-04-04 06:01:31 +00:00
|
|
|
/*
|
|
|
|
* Figure out what sort of media we have by checking the
|
2003-02-05 08:54:36 +00:00
|
|
|
* hardware config word in the first 32k of NIC internal memory,
|
|
|
|
* or fall back to examining the EEPROM if necessary.
|
|
|
|
* Note: on some BCM5700 cards, this value appears to be unset.
|
|
|
|
* If that's the case, we have to rely on identifying the NIC
|
|
|
|
* by its PCI subsystem ID, as we do below for the SysKonnect
|
|
|
|
* SK-9D41.
|
Try to sort out the correct way to generate async link state change
interrupts. This is a bit harder than it needs to be because there's
more than one way to generate link attentions, at least one of which
does not work on the BCM5700, but does on the 5701.
For the 5701, we can safely use the 'link changed' bit in the status
block, and we enable link change attentions in the mac event register.
For the 5700, we have to use MII interrupts, which require checking
the MAC status register rather than the status block. This requires
doing an extra register access on each interrupt which I'd prefer to
avoid, but them's the breaks. Testing with both a 3c996-T and 3c996B-T
shows that we do in fact detect the link going up and down properly
on cable insertions/disconnections.
Also, avoid twiddling the autopoll enable bit in the MI mode register
when doing a PHY read. I think this coupled with the other changes
will stop the interrupt storms Paul Saab has been harassing me about.
Manually setting the link to 100baseTX full duplex seems to work ok
for me. (I'm typing over the 3c996B-T right now.)
Lastly, teach the driver how to recognize a 3c996B-SX by checking
the hardware config word in the EEPROM in order to detect the media.
We attach 5701 fiber cards correctly now, but I haven't verified that
they send/receive packets yet since I don't have a second fiber
interface at home. (I know that fiber 5700 cards work, so I'm
keeping my fingers crossed.)
2002-04-04 06:01:31 +00:00
|
|
|
*/
|
2003-02-05 08:54:36 +00:00
|
|
|
if (bge_readmem_ind(sc, BGE_SOFTWARE_GENCOMM_SIG) == BGE_MAGIC_NUMBER)
|
|
|
|
hwcfg = bge_readmem_ind(sc, BGE_SOFTWARE_GENCOMM_NICCFG);
|
2008-05-14 21:00:27 +00:00
|
|
|
else if ((sc->bge_flags & BGE_FLAG_EADDR) &&
|
|
|
|
(sc->bge_asicrev != BGE_ASICREV_BCM5906)) {
|
2005-12-22 02:03:57 +00:00
|
|
|
if (bge_read_eeprom(sc, (caddr_t)&hwcfg, BGE_EE_HWCFG_OFFSET,
|
|
|
|
sizeof(hwcfg))) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "failed to read EEPROM\n");
|
2005-12-22 02:03:57 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
2003-02-05 08:54:36 +00:00
|
|
|
hwcfg = ntohl(hwcfg);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* The SysKonnect SK-9D41 is a 1000baseSX card. */
|
2010-01-14 19:08:43 +00:00
|
|
|
if ((pci_read_config(dev, BGE_PCI_SUBSYS, 4) >> 16) ==
|
|
|
|
SK_SUBSYSID_9D41 || (hwcfg & BGE_HWCFG_MEDIA) == BGE_MEDIA_FIBER) {
|
|
|
|
if (BGE_IS_5714_FAMILY(sc))
|
|
|
|
sc->bge_flags |= BGE_FLAG_MII_SERDES;
|
|
|
|
else
|
|
|
|
sc->bge_flags |= BGE_FLAG_TBI;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2007-03-08 00:29:18 +00:00
|
|
|
ifmedia_init(&sc->bge_ifmedia, IFM_IMASK, bge_ifmedia_upd,
|
|
|
|
bge_ifmedia_sts);
|
|
|
|
ifmedia_add(&sc->bge_ifmedia, IFM_ETHER | IFM_1000_SX, 0, NULL);
|
|
|
|
ifmedia_add(&sc->bge_ifmedia, IFM_ETHER | IFM_1000_SX | IFM_FDX,
|
2007-03-06 20:14:48 +00:00
|
|
|
0, NULL);
|
|
|
|
ifmedia_add(&sc->bge_ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL);
|
|
|
|
ifmedia_set(&sc->bge_ifmedia, IFM_ETHER | IFM_AUTO);
|
2004-06-09 16:01:59 +00:00
|
|
|
sc->bge_ifmedia.ifm_media = sc->bge_ifmedia.ifm_cur->ifm_media;
|
2001-09-27 23:55:28 +00:00
|
|
|
} else {
|
|
|
|
/*
|
2006-09-09 03:36:57 +00:00
|
|
|
* Do transceiver setup and tell the firmware the
|
|
|
|
* driver is down so we can try to get access the
|
|
|
|
* probe if ASF is running. Retry a couple of times
|
|
|
|
* if we get a conflict with the ASF firmware accessing
|
|
|
|
* the PHY.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
2009-02-10 21:54:23 +00:00
|
|
|
trys = 0;
|
2006-09-09 03:36:57 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
|
|
|
again:
|
|
|
|
bge_asf_driver_up(sc);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
if (mii_phy_probe(dev, &sc->bge_miibus,
|
|
|
|
bge_ifmedia_upd, bge_ifmedia_sts)) {
|
2006-09-09 03:36:57 +00:00
|
|
|
if (trys++ < 4) {
|
|
|
|
device_printf(sc->bge_dev, "Try again\n");
|
2007-03-06 19:15:16 +00:00
|
|
|
bge_miibus_writereg(sc->bge_dev, 1, MII_BMCR,
|
|
|
|
BMCR_RESET);
|
2006-09-09 03:36:57 +00:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "MII without any PHY!\n");
|
2001-09-27 23:55:28 +00:00
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
2006-09-09 03:36:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now tell the firmware we are going up after probing the PHY
|
|
|
|
*/
|
|
|
|
if (sc->bge_asf_mode & ASF_STACKUP)
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2002-06-24 22:04:15 +00:00
|
|
|
/*
|
|
|
|
* When using the BCM5701 in PCI-X mode, data corruption has
|
|
|
|
* been observed in the first few bytes of some received packets.
|
|
|
|
* Aligning the packet buffer in memory eliminates the corruption.
|
|
|
|
* Unfortunately, this misaligns the packet payloads. On platforms
|
|
|
|
* which do not support unaligned accesses, we will realign the
|
|
|
|
* payloads by copying the received packets.
|
|
|
|
*/
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5701 &&
|
|
|
|
sc->bge_flags & BGE_FLAG_PCIX)
|
|
|
|
sc->bge_flags |= BGE_FLAG_RX_ALIGNBUG;
|
2002-06-24 22:04:15 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Call MI attach routine.
|
|
|
|
*/
|
2005-06-10 16:49:24 +00:00
|
|
|
ether_ifattach(ifp, eaddr);
|
2006-11-30 13:40:39 +00:00
|
|
|
callout_init_mtx(&sc->bge_stat_ch, &sc->bge_mtx, 0);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-07 20:37:38 +00:00
|
|
|
/* Tell upper layer we support long frames. */
|
|
|
|
ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
/*
|
|
|
|
* Hookup IRQ last.
|
|
|
|
*/
|
2007-03-06 19:15:16 +00:00
|
|
|
#if __FreeBSD_version > 700030
|
2009-11-22 20:31:40 +00:00
|
|
|
if (BGE_IS_5755_PLUS(sc) && sc->bge_flags & BGE_FLAG_MSI) {
|
|
|
|
/* Take advantage of single-shot MSI. */
|
2009-11-25 17:30:38 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MSI_MODE, CSR_READ_4(sc, BGE_MSI_MODE) &
|
|
|
|
~BGE_MSIMODE_ONE_SHOT_DISABLE);
|
2009-11-22 20:31:40 +00:00
|
|
|
sc->bge_tq = taskqueue_create_fast("bge_taskq", M_WAITOK,
|
|
|
|
taskqueue_thread_enqueue, &sc->bge_tq);
|
|
|
|
if (sc->bge_tq == NULL) {
|
|
|
|
device_printf(dev, "could not create taskqueue.\n");
|
|
|
|
ether_ifdetach(ifp);
|
|
|
|
error = ENXIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
taskqueue_start_threads(&sc->bge_tq, 1, PI_NET, "%s taskq",
|
|
|
|
device_get_nameunit(sc->bge_dev));
|
|
|
|
error = bus_setup_intr(dev, sc->bge_irq,
|
|
|
|
INTR_TYPE_NET | INTR_MPSAFE, bge_msi_intr, NULL, sc,
|
|
|
|
&sc->bge_intrhand);
|
|
|
|
if (error)
|
|
|
|
ether_ifdetach(ifp);
|
|
|
|
} else
|
|
|
|
error = bus_setup_intr(dev, sc->bge_irq,
|
|
|
|
INTR_TYPE_NET | INTR_MPSAFE, NULL, bge_intr, sc,
|
|
|
|
&sc->bge_intrhand);
|
2007-03-06 19:15:16 +00:00
|
|
|
#else
|
|
|
|
error = bus_setup_intr(dev, sc->bge_irq, INTR_TYPE_NET | INTR_MPSAFE,
|
|
|
|
bge_intr, sc, &sc->bge_intrhand);
|
|
|
|
#endif
|
2003-11-11 17:57:03 +00:00
|
|
|
|
|
|
|
if (error) {
|
2005-06-10 16:49:24 +00:00
|
|
|
bge_detach(dev);
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "couldn't set up irq\n");
|
2003-11-11 17:57:03 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-04-30 21:55:27 +00:00
|
|
|
return (0);
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
fail:
|
2007-04-30 21:55:27 +00:00
|
|
|
bge_release_resources(sc);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (error);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_detach(device_t dev)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
if (ifp->if_capenable & IFCAP_POLLING)
|
|
|
|
ether_poll_deregister(ifp);
|
|
|
|
#endif
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_stop(sc);
|
|
|
|
bge_reset(sc);
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
|
2006-12-19 08:57:46 +00:00
|
|
|
callout_drain(&sc->bge_stat_ch);
|
|
|
|
|
2009-11-22 20:31:40 +00:00
|
|
|
if (sc->bge_tq)
|
|
|
|
taskqueue_drain(sc->bge_tq, &sc->bge_intr_task);
|
2003-11-11 17:57:03 +00:00
|
|
|
ether_ifdetach(ifp);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2001-09-27 23:55:28 +00:00
|
|
|
ifmedia_removeall(&sc->bge_ifmedia);
|
|
|
|
} else {
|
|
|
|
bus_generic_detach(dev);
|
|
|
|
device_delete_child(dev, sc->bge_miibus);
|
|
|
|
}
|
|
|
|
|
|
|
|
bge_release_resources(sc);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_release_resources(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2004-10-30 14:54:51 +00:00
|
|
|
device_t dev;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2004-10-30 14:54:51 +00:00
|
|
|
dev = sc->bge_dev;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 20:31:40 +00:00
|
|
|
if (sc->bge_tq != NULL)
|
|
|
|
taskqueue_free(sc->bge_tq);
|
|
|
|
|
2004-10-30 14:54:51 +00:00
|
|
|
if (sc->bge_intrhand != NULL)
|
|
|
|
bus_teardown_intr(dev, sc->bge_irq, sc->bge_intrhand);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2004-10-30 14:54:51 +00:00
|
|
|
if (sc->bge_irq != NULL)
|
2006-12-14 23:10:12 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IRQ,
|
|
|
|
sc->bge_flags & BGE_FLAG_MSI ? 1 : 0, sc->bge_irq);
|
|
|
|
|
|
|
|
if (sc->bge_flags & BGE_FLAG_MSI)
|
|
|
|
pci_release_msi(dev);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2004-10-30 14:54:51 +00:00
|
|
|
if (sc->bge_res != NULL)
|
2001-09-27 23:55:28 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_MEMORY,
|
2010-07-13 19:45:40 +00:00
|
|
|
PCIR_BAR(0), sc->bge_res);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-09-16 11:25:19 +00:00
|
|
|
if (sc->bge_ifp != NULL)
|
|
|
|
if_free(sc->bge_ifp);
|
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
bge_dma_free(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
if (mtx_initialized(&sc->bge_mtx)) /* XXX */
|
|
|
|
BGE_LOCK_DESTROY(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_reset(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
device_t dev;
|
2008-05-14 21:00:27 +00:00
|
|
|
uint32_t cachesize, command, pcistate, reset, val;
|
2006-12-12 05:11:12 +00:00
|
|
|
void (*write_op)(struct bge_softc *, int, int);
|
2009-11-22 19:11:34 +00:00
|
|
|
uint16_t devctl;
|
2008-05-14 21:00:27 +00:00
|
|
|
int i;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
dev = sc->bge_dev;
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
if (BGE_IS_575X_PLUS(sc) && !BGE_IS_5714_FAMILY(sc) &&
|
|
|
|
(sc->bge_asicrev != BGE_ASICREV_BCM5906)) {
|
2006-12-12 05:11:12 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE)
|
|
|
|
write_op = bge_writemem_direct;
|
|
|
|
else
|
|
|
|
write_op = bge_writemem_ind;
|
2006-12-13 21:13:09 +00:00
|
|
|
} else
|
2006-12-12 05:11:12 +00:00
|
|
|
write_op = bge_writereg_ind;
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Save some important PCI state. */
|
|
|
|
cachesize = pci_read_config(dev, BGE_PCI_CACHESZ, 4);
|
|
|
|
command = pci_read_config(dev, BGE_PCI_CMD, 4);
|
|
|
|
pcistate = pci_read_config(dev, BGE_PCI_PCISTATE, 4);
|
|
|
|
|
|
|
|
pci_write_config(dev, BGE_PCI_MISC_CTL,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_PCIMISCCTL_INDIRECT_ACCESS | BGE_PCIMISCCTL_MASK_PCI_INTR |
|
|
|
|
BGE_HIF_SWAP_OPTIONS | BGE_PCIMISCCTL_PCISTATE_RW, 4);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-12-12 05:11:12 +00:00
|
|
|
/* Disable fastboot on controllers that support it. */
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5752 ||
|
2009-10-07 13:12:43 +00:00
|
|
|
BGE_IS_5755_PLUS(sc)) {
|
2006-12-12 05:11:12 +00:00
|
|
|
if (bootverbose)
|
2010-07-13 19:39:51 +00:00
|
|
|
device_printf(dev, "Disabling fastboot\n");
|
2006-12-12 05:11:12 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_FASTBOOT_PC, 0x0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write the magic number to SRAM at offset 0xB50.
|
|
|
|
* When firmware finishes its initialization it will
|
|
|
|
* write ~BGE_MAGIC_NUMBER to the same location.
|
|
|
|
*/
|
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENCOMM, BGE_MAGIC_NUMBER);
|
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
reset = BGE_MISCCFG_RESET_CORE_CLOCKS | BGE_32BITTIME_66MHZ;
|
2004-09-24 22:24:33 +00:00
|
|
|
|
|
|
|
/* XXX: Broadcom Linux driver. */
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE) {
|
2007-03-08 00:29:18 +00:00
|
|
|
if (CSR_READ_4(sc, 0x7E2C) == 0x60) /* PCIE 1.0 */
|
|
|
|
CSR_WRITE_4(sc, 0x7E2C, 0x20);
|
2004-09-24 22:24:33 +00:00
|
|
|
if (sc->bge_chipid != BGE_CHIPID_BCM5750_A0) {
|
|
|
|
/* Prevent PCIE link training during global reset */
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MISC_CFG, 1 << 29);
|
|
|
|
reset |= 1 << 29;
|
2004-09-24 22:24:33 +00:00
|
|
|
}
|
|
|
|
}
|
2004-10-30 14:54:51 +00:00
|
|
|
|
2009-11-22 18:30:19 +00:00
|
|
|
/*
|
2006-12-12 05:11:12 +00:00
|
|
|
* Set GPHY Power Down Override to leave GPHY
|
|
|
|
* powered up in D0 uninitialized.
|
|
|
|
*/
|
2006-12-13 21:03:55 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2010-07-15 23:34:58 +00:00
|
|
|
reset |= BGE_MISCCFG_GPHY_PD_OVERRIDE;
|
2006-12-12 05:11:12 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Issue global reset */
|
2006-12-12 05:11:12 +00:00
|
|
|
write_op(sc, BGE_MISC_CFG, reset);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906) {
|
2008-05-14 21:00:27 +00:00
|
|
|
val = CSR_READ_4(sc, BGE_VCPU_STATUS);
|
2008-04-29 19:47:13 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_VCPU_STATUS,
|
2008-05-14 21:00:27 +00:00
|
|
|
val | BGE_VCPU_STATUS_DRV_RESET);
|
|
|
|
val = CSR_READ_4(sc, BGE_VCPU_EXT_CTRL);
|
2008-04-29 19:47:13 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_VCPU_EXT_CTRL,
|
2008-05-14 21:00:27 +00:00
|
|
|
val & ~BGE_VCPU_EXT_CTRL_HALT_CPU);
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
DELAY(1000);
|
|
|
|
|
2004-09-24 22:24:33 +00:00
|
|
|
/* XXX: Broadcom Linux driver. */
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE) {
|
2004-09-24 22:24:33 +00:00
|
|
|
if (sc->bge_chipid == BGE_CHIPID_BCM5750_A0) {
|
|
|
|
DELAY(500000); /* wait for link training to complete */
|
2008-05-14 21:00:27 +00:00
|
|
|
val = pci_read_config(dev, 0xC4, 4);
|
|
|
|
pci_write_config(dev, 0xC4, val | (1 << 15), 4);
|
2004-09-24 22:24:33 +00:00
|
|
|
}
|
2009-11-22 19:11:34 +00:00
|
|
|
devctl = pci_read_config(dev,
|
|
|
|
sc->bge_expcap + PCIR_EXPRESS_DEVICE_CTL, 2);
|
|
|
|
/* Clear enable no snoop and disable relaxed ordering. */
|
2010-02-01 20:58:45 +00:00
|
|
|
devctl &= ~(PCIM_EXP_CTL_RELAXED_ORD_ENABLE |
|
|
|
|
PCIM_EXP_CTL_NOSNOOP_ENABLE);
|
2009-11-22 19:11:34 +00:00
|
|
|
/* Set PCIE max payload size to 128. */
|
|
|
|
devctl &= ~PCIM_EXP_CTL_MAX_PAYLOAD;
|
|
|
|
pci_write_config(dev, sc->bge_expcap + PCIR_EXPRESS_DEVICE_CTL,
|
|
|
|
devctl, 2);
|
|
|
|
/* Clear error status. */
|
|
|
|
pci_write_config(dev, sc->bge_expcap + PCIR_EXPRESS_DEVICE_STA,
|
2010-02-01 20:58:45 +00:00
|
|
|
PCIM_EXP_STA_CORRECTABLE_ERROR |
|
|
|
|
PCIM_EXP_STA_NON_FATAL_ERROR | PCIM_EXP_STA_FATAL_ERROR |
|
|
|
|
PCIM_EXP_STA_UNSUPPORTED_REQ, 2);
|
2004-09-24 22:24:33 +00:00
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Reset some of the PCI state that got zapped by reset. */
|
2001-09-27 23:55:28 +00:00
|
|
|
pci_write_config(dev, BGE_PCI_MISC_CTL,
|
2007-03-06 20:14:48 +00:00
|
|
|
BGE_PCIMISCCTL_INDIRECT_ACCESS | BGE_PCIMISCCTL_MASK_PCI_INTR |
|
|
|
|
BGE_HIF_SWAP_OPTIONS | BGE_PCIMISCCTL_PCISTATE_RW, 4);
|
2001-09-27 23:55:28 +00:00
|
|
|
pci_write_config(dev, BGE_PCI_CACHESZ, cachesize, 4);
|
|
|
|
pci_write_config(dev, BGE_PCI_CMD, command, 4);
|
2007-03-08 00:29:18 +00:00
|
|
|
write_op(sc, BGE_MISC_CFG, BGE_32BITTIME_66MHZ);
|
2010-03-10 20:54:08 +00:00
|
|
|
/*
|
|
|
|
* Disable PCI-X relaxed ordering to ensure status block update
|
2010-03-10 21:37:19 +00:00
|
|
|
* comes first then packet buffer DMA. Otherwise driver may
|
2010-03-10 20:54:08 +00:00
|
|
|
* read stale status block.
|
|
|
|
*/
|
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIX) {
|
|
|
|
devctl = pci_read_config(dev,
|
|
|
|
sc->bge_pcixcap + PCIXR_COMMAND, 2);
|
|
|
|
devctl &= ~PCIXM_COMMAND_ERO;
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5703) {
|
|
|
|
devctl &= ~PCIXM_COMMAND_MAX_READ;
|
|
|
|
devctl |= PCIXM_COMMAND_MAX_READ_2048;
|
|
|
|
} else if (sc->bge_asicrev == BGE_ASICREV_BCM5704) {
|
|
|
|
devctl &= ~(PCIXM_COMMAND_MAX_SPLITS |
|
|
|
|
PCIXM_COMMAND_MAX_READ);
|
|
|
|
devctl |= PCIXM_COMMAND_MAX_READ_2048;
|
|
|
|
}
|
|
|
|
pci_write_config(dev, sc->bge_pcixcap + PCIXR_COMMAND,
|
|
|
|
devctl, 2);
|
|
|
|
}
|
2006-12-22 02:59:58 +00:00
|
|
|
/* Re-enable MSI, if neccesary, and enable the memory arbiter. */
|
2006-06-15 14:31:49 +00:00
|
|
|
if (BGE_IS_5714_FAMILY(sc)) {
|
2006-12-22 02:59:58 +00:00
|
|
|
/* This chip disables MSI on reset. */
|
|
|
|
if (sc->bge_flags & BGE_FLAG_MSI) {
|
2009-11-22 19:11:34 +00:00
|
|
|
val = pci_read_config(dev,
|
|
|
|
sc->bge_msicap + PCIR_MSI_CTRL, 2);
|
|
|
|
pci_write_config(dev,
|
|
|
|
sc->bge_msicap + PCIR_MSI_CTRL,
|
2006-12-22 02:59:58 +00:00
|
|
|
val | PCIM_MSICTRL_MSI_ENABLE, 2);
|
|
|
|
val = CSR_READ_4(sc, BGE_MSI_MODE);
|
|
|
|
CSR_WRITE_4(sc, BGE_MSI_MODE,
|
|
|
|
val | BGE_MSIMODE_ENABLE);
|
|
|
|
}
|
2006-06-15 14:31:49 +00:00
|
|
|
val = CSR_READ_4(sc, BGE_MARB_MODE);
|
|
|
|
CSR_WRITE_4(sc, BGE_MARB_MODE, BGE_MARBMODE_ENABLE | val);
|
|
|
|
} else
|
2004-04-06 18:28:15 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MARB_MODE, BGE_MARBMODE_ENABLE);
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906) {
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
|
|
|
val = CSR_READ_4(sc, BGE_VCPU_STATUS);
|
|
|
|
if (val & BGE_VCPU_STATUS_INIT_DONE)
|
|
|
|
break;
|
|
|
|
DELAY(100);
|
|
|
|
}
|
|
|
|
if (i == BGE_TIMEOUT) {
|
2010-07-13 19:39:51 +00:00
|
|
|
device_printf(dev, "reset timed out\n");
|
2008-04-29 19:47:13 +00:00
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Poll until we see the 1's complement of the magic number.
|
|
|
|
* This indicates that the firmware initialization is complete.
|
2008-05-14 21:00:27 +00:00
|
|
|
* We expect this to fail if no chip containing the Ethernet
|
|
|
|
* address is fitted though.
|
2008-04-29 19:47:13 +00:00
|
|
|
*/
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
|
|
|
DELAY(10);
|
|
|
|
val = bge_readmem_ind(sc, BGE_SOFTWARE_GENCOMM);
|
|
|
|
if (val == ~BGE_MAGIC_NUMBER)
|
|
|
|
break;
|
|
|
|
}
|
2004-10-30 14:54:51 +00:00
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
if ((sc->bge_flags & BGE_FLAG_EADDR) && i == BGE_TIMEOUT)
|
2010-07-13 19:39:51 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"firmware handshake timed out, found 0x%08x\n",
|
|
|
|
val);
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Wait for the value of the PCISTATE register to
|
|
|
|
* return to its original pre-reset state. This is a
|
|
|
|
* fairly good indicator of reset completion. If we don't
|
|
|
|
* wait for the reset to fully complete, trying to read
|
|
|
|
* from the device's non-PCI registers may yield garbage
|
|
|
|
* results.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < BGE_TIMEOUT; i++) {
|
|
|
|
if (pci_read_config(dev, BGE_PCI_PCISTATE, 4) == pcistate)
|
|
|
|
break;
|
|
|
|
DELAY(10);
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Fix up byte swapping. */
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MODE_CTL, BGE_DMA_SWAP_OPTIONS |
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_MODECTL_BYTESWAP_DATA);
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
/* Tell the ASF firmware we are up */
|
|
|
|
if (sc->bge_asf_mode & ASF_STACKUP)
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_MODE, 0);
|
|
|
|
|
2004-06-09 16:01:59 +00:00
|
|
|
/*
|
|
|
|
* The 5704 in TBI mode apparently needs some special
|
|
|
|
* adjustment to insure the SERDES drive level is set
|
|
|
|
* to 1.2V.
|
|
|
|
*/
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5704 &&
|
|
|
|
sc->bge_flags & BGE_FLAG_TBI) {
|
2008-05-14 21:00:27 +00:00
|
|
|
val = CSR_READ_4(sc, BGE_SERDES_CFG);
|
|
|
|
val = (val & ~0xFFF) | 0x880;
|
|
|
|
CSR_WRITE_4(sc, BGE_SERDES_CFG, val);
|
2004-06-09 16:01:59 +00:00
|
|
|
}
|
|
|
|
|
2004-09-24 22:24:33 +00:00
|
|
|
/* XXX: Broadcom Linux driver. */
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE &&
|
2010-07-14 21:47:49 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5750_A0 &&
|
|
|
|
sc->bge_asicrev != BGE_ASICREV_BCM5785) {
|
|
|
|
/* Enable Data FIFO protection. */
|
2008-05-14 21:00:27 +00:00
|
|
|
val = CSR_READ_4(sc, 0x7C00);
|
|
|
|
CSR_WRITE_4(sc, 0x7C00, val | (1 << 25));
|
2004-09-24 22:24:33 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
DELAY(10000);
|
2006-09-09 03:36:57 +00:00
|
|
|
|
2010-07-13 19:39:51 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2010-06-05 23:29:24 +00:00
|
|
|
static __inline void
|
|
|
|
bge_rxreuse_std(struct bge_softc *sc, int i)
|
|
|
|
{
|
|
|
|
struct bge_rx_bd *r;
|
|
|
|
|
|
|
|
r = &sc->bge_ldata.bge_rx_std_ring[sc->bge_std];
|
|
|
|
r->bge_flags = BGE_RXBDFLAG_END;
|
|
|
|
r->bge_len = sc->bge_cdata.bge_rx_std_seglen[i];
|
|
|
|
r->bge_idx = i;
|
|
|
|
BGE_INC(sc->bge_std, BGE_STD_RX_RING_CNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
bge_rxreuse_jumbo(struct bge_softc *sc, int i)
|
|
|
|
{
|
|
|
|
struct bge_extrx_bd *r;
|
|
|
|
|
|
|
|
r = &sc->bge_ldata.bge_rx_jumbo_ring[sc->bge_jumbo];
|
|
|
|
r->bge_flags = BGE_RXBDFLAG_JUMBO_RING | BGE_RXBDFLAG_END;
|
|
|
|
r->bge_len0 = sc->bge_cdata.bge_rx_jumbo_seglen[i][0];
|
|
|
|
r->bge_len1 = sc->bge_cdata.bge_rx_jumbo_seglen[i][1];
|
|
|
|
r->bge_len2 = sc->bge_cdata.bge_rx_jumbo_seglen[i][2];
|
|
|
|
r->bge_len3 = sc->bge_cdata.bge_rx_jumbo_seglen[i][3];
|
|
|
|
r->bge_idx = i;
|
|
|
|
BGE_INC(sc->bge_jumbo, BGE_JUMBO_RX_RING_CNT);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Frame reception handling. This is called if there's a frame
|
|
|
|
* on the receive return list.
|
|
|
|
*
|
|
|
|
* Note: we have to be able to handle two possibilities here:
|
A big rewrite of receive Jumbo frame handling. Remove the local Jumbo
cluster allocator, that wasn't MPSAFE. Instead, utilize our new generic
UMA jumbo cluster allocator. Since UMA gives us a 9k piece that is contigous
in virtual memory, but isn't contigous in physical memory we need to handle
a few segments. To deal with this we utilize Tigon chip feature - extended
RX descriptors, that can handle up to four DMA segments for one frame.
Details:
o Remove bge_alloc_jumbo_mem(), bge_free_jumbo_mem(),
bge_jalloc(), bge_jfree() functions.
o Remove SLIST heads, bge_jumbo_tag, bge_jumbo_map from softc.
o Use extended RX BDs for Jumbo receive producer ring, and
initialize it appropriately.
o New bge_newbuf_jumbo():
- Allocate an mbuf with Jumbo cluster with help of m_cljget().
- Load the cluster for DMA with help of bus_dmamap_load_mbuf_sg().
- Assert that we got 3 segments in the DMA mapping.
- Fill in these 3 segments into the extended RX descriptor.
2005-12-08 16:11:45 +00:00
|
|
|
* 1) the frame is from the jumbo receive ring
|
2001-09-27 23:55:28 +00:00
|
|
|
* 2) the frame is from the standard receive ring
|
|
|
|
*/
|
|
|
|
|
2009-05-30 15:14:44 +00:00
|
|
|
static int
|
2009-11-22 20:31:40 +00:00
|
|
|
bge_rxeof(struct bge_softc *sc, uint16_t rx_prod, int holdlck)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
2009-05-30 15:14:44 +00:00
|
|
|
int rx_npkts = 0, stdcnt = 0, jumbocnt = 0;
|
2009-11-22 20:02:13 +00:00
|
|
|
uint16_t rx_cons;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-08-18 21:07:39 +00:00
|
|
|
rx_cons = sc->bge_rx_saved_considx;
|
2003-11-11 17:57:03 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Nothing to do. */
|
2009-08-18 21:07:39 +00:00
|
|
|
if (rx_cons == rx_prod)
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
2006-02-01 15:16:03 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_return_ring_tag,
|
2005-12-22 01:44:27 +00:00
|
|
|
sc->bge_cdata.bge_rx_return_ring_map, BUS_DMASYNC_POSTREAD);
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_std_ring_tag,
|
2009-10-21 11:50:18 +00:00
|
|
|
sc->bge_cdata.bge_rx_std_ring_map, BUS_DMASYNC_POSTWRITE);
|
2009-11-06 23:49:20 +00:00
|
|
|
if (ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN >
|
|
|
|
(MCLBYTES - ETHER_ALIGN))
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
2009-10-21 11:50:18 +00:00
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map, BUS_DMASYNC_POSTWRITE);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2009-08-18 21:07:39 +00:00
|
|
|
while (rx_cons != rx_prod) {
|
2001-09-27 23:55:28 +00:00
|
|
|
struct bge_rx_bd *cur_rx;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t rxidx;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct mbuf *m = NULL;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint16_t vlan_tag = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
int have_tag = 0;
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
if (ifp->if_capenable & IFCAP_POLLING) {
|
|
|
|
if (sc->rxcycles <= 0)
|
|
|
|
break;
|
|
|
|
sc->rxcycles--;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-08-18 21:07:39 +00:00
|
|
|
cur_rx = &sc->bge_ldata.bge_rx_return_ring[rx_cons];
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
rxidx = cur_rx->bge_idx;
|
2009-08-18 21:07:39 +00:00
|
|
|
BGE_INC(rx_cons, sc->bge_return_ring_cnt);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-06-01 02:02:39 +00:00
|
|
|
if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING &&
|
|
|
|
cur_rx->bge_flags & BGE_RXBDFLAG_VLAN_TAG) {
|
2001-09-27 23:55:28 +00:00
|
|
|
have_tag = 1;
|
|
|
|
vlan_tag = cur_rx->bge_vlan_tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_rx->bge_flags & BGE_RXBDFLAG_JUMBO_RING) {
|
|
|
|
jumbocnt++;
|
2009-11-07 01:01:33 +00:00
|
|
|
m = sc->bge_cdata.bge_rx_jumbo_chain[rxidx];
|
2001-09-27 23:55:28 +00:00
|
|
|
if (cur_rx->bge_flags & BGE_RXBDFLAG_ERROR) {
|
2010-06-05 23:29:24 +00:00
|
|
|
bge_rxreuse_jumbo(sc, rxidx);
|
2001-09-27 23:55:28 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-07 01:01:33 +00:00
|
|
|
if (bge_newbuf_jumbo(sc, rxidx) != 0) {
|
2010-06-05 23:29:24 +00:00
|
|
|
bge_rxreuse_jumbo(sc, rxidx);
|
2009-11-07 01:01:33 +00:00
|
|
|
ifp->if_iqdrops++;
|
2001-09-27 23:55:28 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-07 02:10:59 +00:00
|
|
|
BGE_INC(sc->bge_jumbo, BGE_JUMBO_RX_RING_CNT);
|
2001-09-27 23:55:28 +00:00
|
|
|
} else {
|
|
|
|
stdcnt++;
|
2010-06-05 23:29:24 +00:00
|
|
|
m = sc->bge_cdata.bge_rx_std_chain[rxidx];
|
2001-09-27 23:55:28 +00:00
|
|
|
if (cur_rx->bge_flags & BGE_RXBDFLAG_ERROR) {
|
2010-06-05 23:29:24 +00:00
|
|
|
bge_rxreuse_std(sc, rxidx);
|
2001-09-27 23:55:28 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-07 01:01:33 +00:00
|
|
|
if (bge_newbuf_std(sc, rxidx) != 0) {
|
2010-06-05 23:29:24 +00:00
|
|
|
bge_rxreuse_std(sc, rxidx);
|
2009-11-07 01:01:33 +00:00
|
|
|
ifp->if_iqdrops++;
|
2001-09-27 23:55:28 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-07 02:10:59 +00:00
|
|
|
BGE_INC(sc->bge_std, BGE_STD_RX_RING_CNT);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_ipackets++;
|
2005-12-22 01:44:27 +00:00
|
|
|
#ifndef __NO_STRICT_ALIGNMENT
|
2002-06-24 22:04:15 +00:00
|
|
|
/*
|
2005-12-22 01:44:27 +00:00
|
|
|
* For architectures with strict alignment we must make sure
|
|
|
|
* the payload is aligned.
|
2002-06-24 22:04:15 +00:00
|
|
|
*/
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_RX_ALIGNBUG) {
|
2002-06-24 22:04:15 +00:00
|
|
|
bcopy(m->m_data, m->m_data + ETHER_ALIGN,
|
|
|
|
cur_rx->bge_len);
|
|
|
|
m->m_data += ETHER_ALIGN;
|
|
|
|
}
|
|
|
|
#endif
|
2003-09-23 19:54:32 +00:00
|
|
|
m->m_pkthdr.len = m->m_len = cur_rx->bge_len - ETHER_CRC_LEN;
|
2001-09-27 23:55:28 +00:00
|
|
|
m->m_pkthdr.rcvif = ifp;
|
|
|
|
|
2004-07-24 13:45:38 +00:00
|
|
|
if (ifp->if_capenable & IFCAP_RXCSUM) {
|
2006-01-21 09:54:32 +00:00
|
|
|
if (cur_rx->bge_flags & BGE_RXBDFLAG_IP_CSUM) {
|
|
|
|
m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
|
2007-03-08 00:29:18 +00:00
|
|
|
if ((cur_rx->bge_ip_csum ^ 0xFFFF) == 0)
|
|
|
|
m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
|
2006-01-21 09:54:32 +00:00
|
|
|
}
|
2005-12-22 15:14:42 +00:00
|
|
|
if (cur_rx->bge_flags & BGE_RXBDFLAG_TCP_UDP_CSUM &&
|
|
|
|
m->m_pkthdr.len >= ETHER_MIN_NOPAD) {
|
2001-09-27 23:55:28 +00:00
|
|
|
m->m_pkthdr.csum_data =
|
|
|
|
cur_rx->bge_tcp_udp_csum;
|
2006-02-02 09:58:31 +00:00
|
|
|
m->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-11-14 23:54:55 +00:00
|
|
|
* If we received a packet with a vlan tag,
|
|
|
|
* attach that information to the packet.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
2005-12-18 18:24:27 +00:00
|
|
|
if (have_tag) {
|
2007-03-06 19:15:16 +00:00
|
|
|
#if __FreeBSD_version > 700022
|
2006-09-17 13:33:30 +00:00
|
|
|
m->m_pkthdr.ether_vtag = vlan_tag;
|
|
|
|
m->m_flags |= M_VLANTAG;
|
2007-03-06 19:15:16 +00:00
|
|
|
#else
|
|
|
|
VLAN_INPUT_TAG_NEW(ifp, m, vlan_tag);
|
|
|
|
if (m == NULL)
|
|
|
|
continue;
|
|
|
|
#endif
|
2005-12-18 18:24:27 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 20:31:40 +00:00
|
|
|
if (holdlck != 0) {
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
(*ifp->if_input)(ifp, m);
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
} else
|
|
|
|
(*ifp->if_input)(ifp, m);
|
2009-05-30 17:25:14 +00:00
|
|
|
rx_npkts++;
|
2009-05-14 22:33:37 +00:00
|
|
|
|
|
|
|
if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
|
2009-05-30 17:56:19 +00:00
|
|
|
return (rx_npkts);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2009-10-21 11:50:18 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_return_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_return_ring_map, BUS_DMASYNC_PREREAD);
|
2005-12-22 01:44:27 +00:00
|
|
|
if (stdcnt > 0)
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_std_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_std_ring_map, BUS_DMASYNC_PREWRITE);
|
2006-06-15 14:31:49 +00:00
|
|
|
|
2009-11-06 23:49:20 +00:00
|
|
|
if (jumbocnt > 0)
|
2006-06-15 14:31:49 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_rx_jumbo_ring_tag,
|
|
|
|
sc->bge_cdata.bge_rx_jumbo_ring_map, BUS_DMASYNC_PREWRITE);
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2009-08-18 21:07:39 +00:00
|
|
|
sc->bge_rx_saved_considx = rx_cons;
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_CONS0_LO, sc->bge_rx_saved_considx);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (stdcnt)
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_STD_PROD_LO, sc->bge_std);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (jumbocnt)
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_RX_JUMBO_PROD_LO, sc->bge_jumbo);
|
2009-11-08 19:59:54 +00:00
|
|
|
#ifdef notyet
|
|
|
|
/*
|
|
|
|
* This register wraps very quickly under heavy packet drops.
|
|
|
|
* If you need correct statistics, you can enable this check.
|
|
|
|
*/
|
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
|
|
|
ifp->if_ierrors += CSR_READ_4(sc, BGE_RXLP_LOCSTAT_IFIN_DROPS);
|
|
|
|
#endif
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-11-22 20:02:13 +00:00
|
|
|
bge_txeof(struct bge_softc *sc, uint16_t tx_cons)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2010-08-31 19:59:18 +00:00
|
|
|
struct bge_tx_bd *cur_tx;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Nothing to do. */
|
2009-11-22 20:02:13 +00:00
|
|
|
if (sc->bge_tx_saved_considx == tx_cons)
|
2006-02-01 15:16:03 +00:00
|
|
|
return;
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-22 01:44:27 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_ring_tag,
|
2009-11-10 20:29:20 +00:00
|
|
|
sc->bge_cdata.bge_tx_ring_map, BUS_DMASYNC_POSTWRITE);
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Go through our tx ring and free mbufs for those
|
|
|
|
* frames that have been sent.
|
|
|
|
*/
|
2009-11-22 20:02:13 +00:00
|
|
|
while (sc->bge_tx_saved_considx != tx_cons) {
|
2010-08-31 19:59:18 +00:00
|
|
|
uint32_t idx;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
idx = sc->bge_tx_saved_considx;
|
2003-07-25 19:42:44 +00:00
|
|
|
cur_tx = &sc->bge_ldata.bge_tx_ring[idx];
|
2001-09-27 23:55:28 +00:00
|
|
|
if (cur_tx->bge_flags & BGE_TXBDFLAG_END)
|
|
|
|
ifp->if_opackets++;
|
|
|
|
if (sc->bge_cdata.bge_tx_chain[idx] != NULL) {
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_mtag,
|
2005-12-22 01:44:27 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[idx],
|
|
|
|
BUS_DMASYNC_POSTWRITE);
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_tx_mtag,
|
2003-07-25 19:42:44 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[idx]);
|
2005-12-22 01:44:27 +00:00
|
|
|
m_freem(sc->bge_cdata.bge_tx_chain[idx]);
|
|
|
|
sc->bge_cdata.bge_tx_chain[idx] = NULL;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
sc->bge_txcnt--;
|
|
|
|
BGE_INC(sc->bge_tx_saved_considx, BGE_TX_RING_CNT);
|
|
|
|
}
|
|
|
|
|
2010-08-31 19:59:18 +00:00
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
|
2006-12-20 12:03:21 +00:00
|
|
|
if (sc->bge_txcnt == 0)
|
|
|
|
sc->bge_timer = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
2009-05-30 15:14:44 +00:00
|
|
|
static int
|
2005-10-22 14:31:01 +00:00
|
|
|
bge_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc = ifp->if_softc;
|
2009-11-22 20:02:13 +00:00
|
|
|
uint16_t rx_prod, tx_cons;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t statusword;
|
2009-05-30 15:14:44 +00:00
|
|
|
int rx_npkts = 0;
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
BGE_LOCK(sc);
|
2006-06-07 21:03:20 +00:00
|
|
|
if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
|
|
|
|
BGE_UNLOCK(sc);
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
2006-06-07 21:03:20 +00:00
|
|
|
}
|
2005-10-22 14:31:01 +00:00
|
|
|
|
2006-02-01 14:41:08 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
2009-11-22 20:02:13 +00:00
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
|
|
|
rx_prod = sc->bge_ldata.bge_status_block->bge_idx[0].bge_rx_prod_idx;
|
|
|
|
tx_cons = sc->bge_ldata.bge_status_block->bge_idx[0].bge_tx_cons_idx;
|
2005-10-22 14:31:01 +00:00
|
|
|
|
2010-08-31 20:56:18 +00:00
|
|
|
statusword = sc->bge_ldata.bge_status_block->bge_status;
|
|
|
|
sc->bge_ldata.bge_status_block->bge_status = 0;
|
2005-10-22 14:31:01 +00:00
|
|
|
|
2006-02-01 14:41:08 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
2009-11-22 20:02:13 +00:00
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
2005-12-08 13:31:52 +00:00
|
|
|
|
2007-03-08 00:29:18 +00:00
|
|
|
/* Note link event. It will be processed by POLL_AND_CHECK_STATUS. */
|
2006-02-01 14:41:08 +00:00
|
|
|
if (statusword & BGE_STATFLAG_LINKSTATE_CHANGED)
|
|
|
|
sc->bge_link_evt++;
|
2005-12-08 13:31:52 +00:00
|
|
|
|
2006-02-01 14:41:08 +00:00
|
|
|
if (cmd == POLL_AND_CHECK_STATUS)
|
2006-01-13 08:59:40 +00:00
|
|
|
if ((sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
2006-06-15 14:31:49 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_B2) ||
|
2006-08-23 11:32:54 +00:00
|
|
|
sc->bge_link_evt || (sc->bge_flags & BGE_FLAG_TBI))
|
2005-12-08 13:31:52 +00:00
|
|
|
bge_link_upd(sc);
|
|
|
|
|
2006-02-01 14:41:08 +00:00
|
|
|
sc->rxcycles = count;
|
2009-11-22 20:31:40 +00:00
|
|
|
rx_npkts = bge_rxeof(sc, rx_prod, 1);
|
2009-05-14 22:33:37 +00:00
|
|
|
if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
|
|
|
|
BGE_UNLOCK(sc);
|
2009-05-30 17:56:19 +00:00
|
|
|
return (rx_npkts);
|
2009-05-14 22:33:37 +00:00
|
|
|
}
|
2009-11-22 20:02:13 +00:00
|
|
|
bge_txeof(sc, tx_cons);
|
2006-02-01 14:41:08 +00:00
|
|
|
if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
|
|
|
|
bge_start_locked(ifp);
|
2006-06-07 21:03:20 +00:00
|
|
|
|
|
|
|
BGE_UNLOCK(sc);
|
2009-05-30 15:14:44 +00:00
|
|
|
return (rx_npkts);
|
2005-10-22 14:31:01 +00:00
|
|
|
}
|
|
|
|
#endif /* DEVICE_POLLING */
|
|
|
|
|
2009-11-22 20:31:40 +00:00
|
|
|
static int
|
|
|
|
bge_msi_intr(void *arg)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
|
|
|
|
sc = (struct bge_softc *)arg;
|
|
|
|
/*
|
|
|
|
* This interrupt is not shared and controller already
|
|
|
|
* disabled further interrupt.
|
|
|
|
*/
|
|
|
|
taskqueue_enqueue(sc->bge_tq, &sc->bge_intr_task);
|
|
|
|
return (FILTER_HANDLED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
bge_intr_task(void *arg, int pending)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
uint32_t status;
|
|
|
|
uint16_t rx_prod, tx_cons;
|
|
|
|
|
|
|
|
sc = (struct bge_softc *)arg;
|
|
|
|
ifp = sc->bge_ifp;
|
|
|
|
|
|
|
|
if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Get updated status block. */
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
|
|
|
|
|
|
|
/* Save producer/consumer indexess. */
|
|
|
|
rx_prod = sc->bge_ldata.bge_status_block->bge_idx[0].bge_rx_prod_idx;
|
|
|
|
tx_cons = sc->bge_ldata.bge_status_block->bge_idx[0].bge_tx_cons_idx;
|
|
|
|
status = sc->bge_ldata.bge_status_block->bge_status;
|
|
|
|
sc->bge_ldata.bge_status_block->bge_status = 0;
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
|
|
|
/* Let controller work. */
|
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 0);
|
|
|
|
|
|
|
|
if ((status & BGE_STATFLAG_LINKSTATE_CHANGED) != 0) {
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
bge_link_upd(sc);
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
|
|
|
/* Check RX return ring producer/consumer. */
|
|
|
|
bge_rxeof(sc, rx_prod, 0);
|
|
|
|
}
|
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
/* Check TX ring producer/consumer. */
|
|
|
|
bge_txeof(sc, tx_cons);
|
|
|
|
if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
|
|
|
|
bge_start_locked(ifp);
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_intr(void *xsc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
2005-12-08 13:31:52 +00:00
|
|
|
uint32_t statusword;
|
2009-11-22 20:02:13 +00:00
|
|
|
uint16_t rx_prod, tx_cons;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
sc = xsc;
|
2003-07-25 19:42:44 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
|
|
|
|
2005-12-08 13:31:52 +00:00
|
|
|
ifp = sc->bge_ifp;
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
if (ifp->if_capenable & IFCAP_POLLING) {
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-12-20 11:14:45 +00:00
|
|
|
/*
|
|
|
|
* Ack the interrupt by writing something to BGE_MBX_IRQ0_LO. Don't
|
|
|
|
* disable interrupts by writing nonzero like we used to, since with
|
|
|
|
* our current organization this just gives complications and
|
|
|
|
* pessimizations for re-enabling interrupts. We used to have races
|
|
|
|
* instead of the necessary complications. Disabling interrupts
|
|
|
|
* would just reduce the chance of a status update while we are
|
|
|
|
* running (by switching to the interrupt-mode coalescence
|
|
|
|
* parameters), but this chance is already very low so it is more
|
|
|
|
* efficient to get another interrupt than prevent it.
|
|
|
|
*
|
|
|
|
* We do the ack first to ensure another interrupt if there is a
|
|
|
|
* status update after the ack. We don't check for the status
|
|
|
|
* changing later because it is more efficient to get another
|
|
|
|
* interrupt than prevent it, not quite as above (not checking is
|
|
|
|
* a smaller optimization than not toggling the interrupt enable,
|
|
|
|
* since checking doesn't involve PCI accesses and toggling require
|
|
|
|
* the status check). So toggling would probably be a pessimization
|
|
|
|
* even with MSI. It would only be needed for using a task queue.
|
|
|
|
*/
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 0);
|
2006-12-20 11:14:45 +00:00
|
|
|
|
2010-03-16 17:45:16 +00:00
|
|
|
/*
|
|
|
|
* Do the mandatory PCI flush as well as get the link status.
|
|
|
|
*/
|
|
|
|
statusword = CSR_READ_4(sc, BGE_MAC_STS) & BGE_MACSTAT_LINK_CHANGED;
|
|
|
|
|
|
|
|
/* Make sure the descriptor ring indexes are coherent. */
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
|
|
|
rx_prod = sc->bge_ldata.bge_status_block->bge_idx[0].bge_rx_prod_idx;
|
|
|
|
tx_cons = sc->bge_ldata.bge_status_block->bge_idx[0].bge_tx_cons_idx;
|
|
|
|
sc->bge_ldata.bge_status_block->bge_status = 0;
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_status_tag,
|
|
|
|
sc->bge_cdata.bge_status_map,
|
|
|
|
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
|
|
|
|
|
2006-01-13 08:59:40 +00:00
|
|
|
if ((sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
2006-06-15 14:31:49 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_B2) ||
|
2006-04-15 08:13:06 +00:00
|
|
|
statusword || sc->bge_link_evt)
|
2005-12-08 13:31:52 +00:00
|
|
|
bge_link_upd(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Check RX return ring producer/consumer. */
|
2009-11-22 20:31:40 +00:00
|
|
|
bge_rxeof(sc, rx_prod, 1);
|
2009-05-14 22:33:37 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-05-14 22:33:37 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Check TX ring producer/consumer. */
|
2009-11-22 20:02:13 +00:00
|
|
|
bge_txeof(sc, tx_cons);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
|
|
|
|
!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
|
2003-11-11 17:57:03 +00:00
|
|
|
bge_start_locked(ifp);
|
|
|
|
|
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
static void
|
|
|
|
bge_asf_driver_up(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
if (sc->bge_asf_mode & ASF_STACKUP) {
|
|
|
|
/* Send ASF heartbeat aprox. every 2s */
|
|
|
|
if (sc->bge_asf_count)
|
|
|
|
sc->bge_asf_count --;
|
|
|
|
else {
|
2010-01-22 18:35:50 +00:00
|
|
|
sc->bge_asf_count = 2;
|
2006-09-09 03:36:57 +00:00
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENCOMM_FW,
|
|
|
|
BGE_FW_DRV_ALIVE);
|
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENNCOMM_FW_LEN, 4);
|
|
|
|
bge_writemem_ind(sc, BGE_SOFTWARE_GENNCOMM_FW_DATA, 3);
|
|
|
|
CSR_WRITE_4(sc, BGE_CPU_EVENT,
|
2007-03-08 00:49:26 +00:00
|
|
|
CSR_READ_4(sc, BGE_CPU_EVENT) | (1 << 14));
|
2006-09-09 03:36:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static void
|
2006-11-30 13:40:39 +00:00
|
|
|
bge_tick(void *xsc)
|
2003-11-11 17:57:03 +00:00
|
|
|
{
|
2006-11-30 13:40:39 +00:00
|
|
|
struct bge_softc *sc = xsc;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct mii_data *mii = NULL;
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-12-19 08:57:46 +00:00
|
|
|
/* Synchronize with possible callout reset/stop. */
|
|
|
|
if (callout_pending(&sc->bge_stat_ch) ||
|
|
|
|
!callout_active(&sc->bge_stat_ch))
|
|
|
|
return;
|
|
|
|
|
2006-12-04 22:12:21 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2003-07-16 00:09:56 +00:00
|
|
|
bge_stats_update_regs(sc);
|
|
|
|
else
|
|
|
|
bge_stats_update(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-08-23 11:32:54 +00:00
|
|
|
if ((sc->bge_flags & BGE_FLAG_TBI) == 0) {
|
2005-12-08 13:31:52 +00:00
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
2008-09-08 18:10:15 +00:00
|
|
|
/*
|
|
|
|
* Do not touch PHY if we have link up. This could break
|
|
|
|
* IPMI/ASF mode or produce extra input errors
|
|
|
|
* (extra errors was reported for bcm5701 & bcm5704).
|
|
|
|
*/
|
|
|
|
if (!sc->bge_link)
|
2006-09-09 03:36:57 +00:00
|
|
|
mii_tick(mii);
|
2006-02-01 14:26:35 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Since in TBI mode auto-polling can't be used we should poll
|
|
|
|
* link status manually. Here we register pending link event
|
|
|
|
* and trigger interrupt.
|
|
|
|
*/
|
|
|
|
#ifdef DEVICE_POLLING
|
2006-06-07 21:03:20 +00:00
|
|
|
/* In polling mode we poll link state in bge_poll(). */
|
2006-02-01 14:26:35 +00:00
|
|
|
if (!(sc->bge_ifp->if_capenable & IFCAP_POLLING))
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
sc->bge_link_evt++;
|
2008-05-05 18:42:17 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 ||
|
|
|
|
sc->bge_flags & BGE_FLAG_5788)
|
|
|
|
BGE_SETBIT(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_INTR_SET);
|
|
|
|
else
|
|
|
|
BGE_SETBIT(sc, BGE_HCC_MODE, BGE_HCCMODE_COAL_NOW);
|
2006-02-01 14:26:35 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
bge_asf_driver_up(sc);
|
2006-11-30 13:40:39 +00:00
|
|
|
bge_watchdog(sc);
|
2006-09-09 03:36:57 +00:00
|
|
|
|
2005-12-08 13:31:52 +00:00
|
|
|
callout_reset(&sc->bge_stat_ch, hz, bge_tick, sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_stats_update_regs(struct bge_softc *sc)
|
2003-07-16 00:09:56 +00:00
|
|
|
{
|
2006-06-07 21:03:20 +00:00
|
|
|
struct ifnet *ifp;
|
2003-07-16 00:09:56 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2003-07-16 00:09:56 +00:00
|
|
|
|
2006-12-11 18:00:34 +00:00
|
|
|
ifp->if_collisions += CSR_READ_4(sc, BGE_MAC_STATS +
|
2006-12-01 01:08:52 +00:00
|
|
|
offsetof(struct bge_mac_stats_regs, etherStatsCollisions));
|
|
|
|
|
2009-11-08 01:30:35 +00:00
|
|
|
ifp->if_ierrors += CSR_READ_4(sc, BGE_RXLP_LOCSTAT_OUT_OF_BDS);
|
2006-12-11 18:00:34 +00:00
|
|
|
ifp->if_ierrors += CSR_READ_4(sc, BGE_RXLP_LOCSTAT_IFIN_DROPS);
|
2009-11-08 01:30:35 +00:00
|
|
|
ifp->if_ierrors += CSR_READ_4(sc, BGE_RXLP_LOCSTAT_IFIN_ERRORS);
|
2003-07-16 00:09:56 +00:00
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_stats_update(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
2005-12-15 05:48:49 +00:00
|
|
|
bus_size_t stats;
|
2006-12-01 01:08:52 +00:00
|
|
|
uint32_t cnt; /* current register value */
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-15 05:48:49 +00:00
|
|
|
stats = BGE_MEMWIN_START + BGE_STATS_BLOCK;
|
|
|
|
|
2007-02-12 23:33:05 +00:00
|
|
|
#define READ_STAT(sc, stats, stat) \
|
2005-12-15 05:48:49 +00:00
|
|
|
CSR_READ_4(sc, stats + offsetof(struct bge_stats, stat))
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-12-13 17:28:51 +00:00
|
|
|
cnt = READ_STAT(sc, stats, txstats.etherStatsCollisions.bge_addr_lo);
|
2006-12-11 18:00:34 +00:00
|
|
|
ifp->if_collisions += (uint32_t)(cnt - sc->bge_tx_collisions);
|
2006-01-17 23:01:58 +00:00
|
|
|
sc->bge_tx_collisions = cnt;
|
|
|
|
|
|
|
|
cnt = READ_STAT(sc, stats, ifInDiscards.bge_addr_lo);
|
2006-12-11 18:00:34 +00:00
|
|
|
ifp->if_ierrors += (uint32_t)(cnt - sc->bge_rx_discards);
|
2006-01-17 23:01:58 +00:00
|
|
|
sc->bge_rx_discards = cnt;
|
|
|
|
|
|
|
|
cnt = READ_STAT(sc, stats, txstats.ifOutDiscards.bge_addr_lo);
|
2006-12-11 18:00:34 +00:00
|
|
|
ifp->if_oerrors += (uint32_t)(cnt - sc->bge_tx_discards);
|
2006-01-17 23:01:58 +00:00
|
|
|
sc->bge_tx_discards = cnt;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2007-02-12 23:33:05 +00:00
|
|
|
#undef READ_STAT
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2005-12-22 15:14:42 +00:00
|
|
|
/*
|
|
|
|
* Pad outbound frame to ETHER_MIN_NOPAD for an unusual reason.
|
|
|
|
* The bge hardware will pad out Tx runts to ETHER_MIN_NOPAD,
|
|
|
|
* but when such padded frames employ the bge IP/TCP checksum offload,
|
|
|
|
* the hardware checksum assist gives incorrect results (possibly
|
|
|
|
* from incorporating its own padding into the UDP/TCP checksum; who knows).
|
|
|
|
* If we pad such runts with zeros, the onboard checksum comes out correct.
|
|
|
|
*/
|
|
|
|
static __inline int
|
|
|
|
bge_cksum_pad(struct mbuf *m)
|
|
|
|
{
|
|
|
|
int padlen = ETHER_MIN_NOPAD - m->m_pkthdr.len;
|
|
|
|
struct mbuf *last;
|
|
|
|
|
|
|
|
/* If there's only the packet-header and we can pad there, use it. */
|
|
|
|
if (m->m_pkthdr.len == m->m_len && M_WRITABLE(m) &&
|
|
|
|
M_TRAILINGSPACE(m) >= padlen) {
|
|
|
|
last = m;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Walk packet chain to find last mbuf. We will either
|
|
|
|
* pad there, or append a new mbuf and pad it.
|
|
|
|
*/
|
|
|
|
for (last = m; last->m_next != NULL; last = last->m_next);
|
|
|
|
if (!(M_WRITABLE(last) && M_TRAILINGSPACE(last) >= padlen)) {
|
|
|
|
/* Allocate new empty mbuf, pad it. Compact later. */
|
|
|
|
struct mbuf *n;
|
|
|
|
|
|
|
|
MGET(n, M_DONTWAIT, MT_DATA);
|
|
|
|
if (n == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
n->m_len = 0;
|
|
|
|
last->m_next = n;
|
|
|
|
last = n;
|
|
|
|
}
|
|
|
|
}
|
2009-11-22 18:30:19 +00:00
|
|
|
|
2005-12-22 15:14:42 +00:00
|
|
|
/* Now zero the pad area, to avoid the bge cksum-assist bug. */
|
|
|
|
memset(mtod(last, caddr_t) + last->m_len, 0, padlen);
|
|
|
|
last->m_len += padlen;
|
|
|
|
m->m_pkthdr.len += padlen;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2009-11-22 21:16:30 +00:00
|
|
|
static struct mbuf *
|
|
|
|
bge_setup_tso(struct bge_softc *sc, struct mbuf *m, uint16_t *mss)
|
|
|
|
{
|
|
|
|
struct ip *ip;
|
|
|
|
struct tcphdr *tcp;
|
|
|
|
struct mbuf *n;
|
|
|
|
uint16_t hlen;
|
2010-02-22 21:03:15 +00:00
|
|
|
uint32_t poff;
|
2009-11-22 21:16:30 +00:00
|
|
|
|
|
|
|
if (M_WRITABLE(m) == 0) {
|
|
|
|
/* Get a writable copy. */
|
|
|
|
n = m_dup(m, M_DONTWAIT);
|
|
|
|
m_freem(m);
|
|
|
|
if (n == NULL)
|
|
|
|
return (NULL);
|
|
|
|
m = n;
|
|
|
|
}
|
2010-02-22 21:03:15 +00:00
|
|
|
m = m_pullup(m, sizeof(struct ether_header) + sizeof(struct ip));
|
2009-11-22 21:16:30 +00:00
|
|
|
if (m == NULL)
|
|
|
|
return (NULL);
|
2010-02-22 21:03:15 +00:00
|
|
|
ip = (struct ip *)(mtod(m, char *) + sizeof(struct ether_header));
|
|
|
|
poff = sizeof(struct ether_header) + (ip->ip_hl << 2);
|
2009-11-22 21:16:30 +00:00
|
|
|
m = m_pullup(m, poff + sizeof(struct tcphdr));
|
|
|
|
if (m == NULL)
|
|
|
|
return (NULL);
|
|
|
|
tcp = (struct tcphdr *)(mtod(m, char *) + poff);
|
2010-02-22 21:03:15 +00:00
|
|
|
m = m_pullup(m, poff + (tcp->th_off << 2));
|
2009-11-22 21:16:30 +00:00
|
|
|
if (m == NULL)
|
|
|
|
return (NULL);
|
|
|
|
/*
|
|
|
|
* It seems controller doesn't modify IP length and TCP pseudo
|
|
|
|
* checksum. These checksum computed by upper stack should be 0.
|
|
|
|
*/
|
|
|
|
*mss = m->m_pkthdr.tso_segsz;
|
|
|
|
ip->ip_sum = 0;
|
|
|
|
ip->ip_len = htons(*mss + (ip->ip_hl << 2) + (tcp->th_off << 2));
|
|
|
|
/* Clear pseudo checksum computed by TCP stack. */
|
|
|
|
tcp->th_sum = 0;
|
|
|
|
/*
|
|
|
|
* Broadcom controllers uses different descriptor format for
|
|
|
|
* TSO depending on ASIC revision. Due to TSO-capable firmware
|
|
|
|
* license issue and lower performance of firmware based TSO
|
|
|
|
* we only support hardware based TSO which is applicable for
|
|
|
|
* BCM5755 or newer controllers. Hardware based TSO uses 11
|
|
|
|
* bits to store MSS and upper 5 bits are used to store IP/TCP
|
|
|
|
* header length(including IP/TCP options). The header length
|
|
|
|
* is expressed as 32 bits unit.
|
|
|
|
*/
|
|
|
|
hlen = ((ip->ip_hl << 2) + (tcp->th_off << 2)) >> 2;
|
|
|
|
*mss |= (hlen << 11);
|
|
|
|
return (m);
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
|
|
|
* Encapsulate an mbuf chain in the tx ring by coupling the mbuf data
|
|
|
|
* pointers to descriptors.
|
|
|
|
*/
|
|
|
|
static int
|
2006-08-17 09:53:04 +00:00
|
|
|
bge_encap(struct bge_softc *sc, struct mbuf **m_head, uint32_t *txidx)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2005-12-15 09:45:53 +00:00
|
|
|
bus_dma_segment_t segs[BGE_NSEG_NEW];
|
2003-07-25 19:42:44 +00:00
|
|
|
bus_dmamap_t map;
|
2006-08-17 09:53:04 +00:00
|
|
|
struct bge_tx_bd *d;
|
|
|
|
struct mbuf *m = *m_head;
|
2005-12-15 09:45:53 +00:00
|
|
|
uint32_t idx = *txidx;
|
2009-11-22 21:16:30 +00:00
|
|
|
uint16_t csum_flags, mss, vlan_tag;
|
2005-12-15 09:45:53 +00:00
|
|
|
int nsegs, i, error;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-08-18 13:53:53 +00:00
|
|
|
csum_flags = 0;
|
2009-11-22 21:16:30 +00:00
|
|
|
mss = 0;
|
|
|
|
vlan_tag = 0;
|
|
|
|
if ((m->m_pkthdr.csum_flags & CSUM_TSO) != 0) {
|
|
|
|
*m_head = m = bge_setup_tso(sc, m, &mss);
|
|
|
|
if (*m_head == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
csum_flags |= BGE_TXBDFLAG_CPU_PRE_DMA |
|
|
|
|
BGE_TXBDFLAG_CPU_POST_DMA;
|
2010-08-22 01:39:09 +00:00
|
|
|
} else if ((m->m_pkthdr.csum_flags & sc->bge_csum_features) != 0) {
|
2006-08-18 13:53:53 +00:00
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_IP)
|
|
|
|
csum_flags |= BGE_TXBDFLAG_IP_CSUM;
|
|
|
|
if (m->m_pkthdr.csum_flags & (CSUM_TCP | CSUM_UDP)) {
|
|
|
|
csum_flags |= BGE_TXBDFLAG_TCP_UDP_CSUM;
|
|
|
|
if (m->m_pkthdr.len < ETHER_MIN_NOPAD &&
|
|
|
|
(error = bge_cksum_pad(m)) != 0) {
|
|
|
|
m_freem(m);
|
|
|
|
*m_head = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (m->m_flags & M_LASTFRAG)
|
|
|
|
csum_flags |= BGE_TXBDFLAG_IP_FRAG_END;
|
|
|
|
else if (m->m_flags & M_FRAG)
|
|
|
|
csum_flags |= BGE_TXBDFLAG_IP_FRAG;
|
|
|
|
}
|
|
|
|
|
2009-12-03 23:57:06 +00:00
|
|
|
if ((m->m_pkthdr.csum_flags & CSUM_TSO) == 0 &&
|
2009-12-08 17:54:23 +00:00
|
|
|
sc->bge_forced_collapse > 0 &&
|
|
|
|
(sc->bge_flags & BGE_FLAG_PCIE) != 0 && m->m_next != NULL) {
|
2009-12-03 23:57:06 +00:00
|
|
|
/*
|
|
|
|
* Forcedly collapse mbuf chains to overcome hardware
|
|
|
|
* limitation which only support a single outstanding
|
|
|
|
* DMA read operation.
|
|
|
|
*/
|
2009-12-08 17:54:23 +00:00
|
|
|
if (sc->bge_forced_collapse == 1)
|
2009-12-03 23:57:06 +00:00
|
|
|
m = m_defrag(m, M_DONTWAIT);
|
|
|
|
else
|
2009-12-08 17:54:23 +00:00
|
|
|
m = m_collapse(m, M_DONTWAIT, sc->bge_forced_collapse);
|
2010-01-15 17:55:18 +00:00
|
|
|
if (m == NULL)
|
|
|
|
m = *m_head;
|
2009-12-03 23:57:06 +00:00
|
|
|
*m_head = m;
|
|
|
|
}
|
|
|
|
|
2005-12-15 09:45:53 +00:00
|
|
|
map = sc->bge_cdata.bge_tx_dmamap[idx];
|
2009-11-04 20:57:52 +00:00
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->bge_cdata.bge_tx_mtag, map, m, segs,
|
2006-08-17 09:53:04 +00:00
|
|
|
&nsegs, BUS_DMA_NOWAIT);
|
|
|
|
if (error == EFBIG) {
|
2008-04-26 10:54:17 +00:00
|
|
|
m = m_collapse(m, M_DONTWAIT, BGE_NSEG_NEW);
|
2006-08-17 09:53:04 +00:00
|
|
|
if (m == NULL) {
|
|
|
|
m_freem(*m_head);
|
|
|
|
*m_head = NULL;
|
|
|
|
return (ENOBUFS);
|
2005-12-15 09:45:53 +00:00
|
|
|
}
|
2006-08-17 09:53:04 +00:00
|
|
|
*m_head = m;
|
2009-11-04 20:57:52 +00:00
|
|
|
error = bus_dmamap_load_mbuf_sg(sc->bge_cdata.bge_tx_mtag, map,
|
|
|
|
m, segs, &nsegs, BUS_DMA_NOWAIT);
|
2006-08-17 09:53:04 +00:00
|
|
|
if (error) {
|
|
|
|
m_freem(m);
|
|
|
|
*m_head = NULL;
|
2006-06-08 10:19:16 +00:00
|
|
|
return (error);
|
2006-08-17 09:53:04 +00:00
|
|
|
}
|
|
|
|
} else if (error != 0)
|
|
|
|
return (error);
|
2005-12-15 09:45:53 +00:00
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
/* Check if we have enough free send BDs. */
|
|
|
|
if (sc->bge_txcnt + nsegs >= BGE_TX_RING_CNT) {
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_unload(sc->bge_cdata.bge_tx_mtag, map);
|
2005-12-15 09:45:53 +00:00
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-04 20:57:52 +00:00
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_mtag, map, BUS_DMASYNC_PREWRITE);
|
2005-12-22 01:44:27 +00:00
|
|
|
|
2009-11-22 21:16:30 +00:00
|
|
|
#if __FreeBSD_version > 700022
|
|
|
|
if (m->m_flags & M_VLANTAG) {
|
|
|
|
csum_flags |= BGE_TXBDFLAG_VLAN_TAG;
|
|
|
|
vlan_tag = m->m_pkthdr.ether_vtag;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
{
|
|
|
|
struct m_tag *mtag;
|
|
|
|
|
|
|
|
if ((mtag = VLAN_OUTPUT_TAG(sc->bge_ifp, m)) != NULL) {
|
|
|
|
csum_flags |= BGE_TXBDFLAG_VLAN_TAG;
|
|
|
|
vlan_tag = VLAN_TAG_VALUE(mtag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2005-12-15 09:45:53 +00:00
|
|
|
for (i = 0; ; i++) {
|
|
|
|
d = &sc->bge_ldata.bge_tx_ring[idx];
|
|
|
|
d->bge_addr.bge_addr_lo = BGE_ADDR_LO(segs[i].ds_addr);
|
|
|
|
d->bge_addr.bge_addr_hi = BGE_ADDR_HI(segs[i].ds_addr);
|
|
|
|
d->bge_len = segs[i].ds_len;
|
|
|
|
d->bge_flags = csum_flags;
|
2009-11-22 21:16:30 +00:00
|
|
|
d->bge_vlan_tag = vlan_tag;
|
|
|
|
d->bge_mss = mss;
|
2005-12-15 09:45:53 +00:00
|
|
|
if (i == nsegs - 1)
|
|
|
|
break;
|
|
|
|
BGE_INC(idx, BGE_TX_RING_CNT);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-15 09:45:53 +00:00
|
|
|
/* Mark the last segment as end of packet... */
|
|
|
|
d->bge_flags |= BGE_TXBDFLAG_END;
|
2006-08-17 09:53:04 +00:00
|
|
|
|
2003-07-25 19:42:44 +00:00
|
|
|
/*
|
|
|
|
* Insure that the map for this transmission
|
|
|
|
* is placed at the array index of the last descriptor
|
|
|
|
* in this chain.
|
|
|
|
*/
|
2005-12-15 09:45:53 +00:00
|
|
|
sc->bge_cdata.bge_tx_dmamap[*txidx] = sc->bge_cdata.bge_tx_dmamap[idx];
|
|
|
|
sc->bge_cdata.bge_tx_dmamap[idx] = map;
|
2006-08-17 09:53:04 +00:00
|
|
|
sc->bge_cdata.bge_tx_chain[idx] = m;
|
2005-12-15 09:45:53 +00:00
|
|
|
sc->bge_txcnt += nsegs;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-15 09:45:53 +00:00
|
|
|
BGE_INC(idx, BGE_TX_RING_CNT);
|
|
|
|
*txidx = idx;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-15 09:45:53 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Main transmit routine. To avoid having to do mbuf copies, we put pointers
|
|
|
|
* to the mbuf data regions directly in the transmit descriptors.
|
|
|
|
*/
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_start_locked(struct ifnet *ifp)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
2009-11-22 19:44:11 +00:00
|
|
|
struct mbuf *m_head;
|
2005-12-18 20:26:12 +00:00
|
|
|
uint32_t prodidx;
|
2009-11-22 19:44:11 +00:00
|
|
|
int count;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
2009-11-22 19:44:11 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
if (!sc->bge_link ||
|
|
|
|
(ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
|
|
|
|
IFF_DRV_RUNNING)
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
|
2005-12-18 20:26:12 +00:00
|
|
|
prodidx = sc->bge_tx_prodidx;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
for (count = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd);) {
|
|
|
|
if (sc->bge_txcnt > BGE_TX_RING_CNT - 16) {
|
|
|
|
ifp->if_drv_flags |= IFF_DRV_OACTIVE;
|
|
|
|
break;
|
|
|
|
}
|
2004-10-30 21:21:10 +00:00
|
|
|
IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (m_head == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
2004-07-24 13:45:38 +00:00
|
|
|
* XXX
|
|
|
|
* The code inside the if() block is never reached since we
|
|
|
|
* must mark CSUM_IP_FRAGS in our if_hwassist to start getting
|
|
|
|
* requests to checksum TCP/UDP in a fragmented packet.
|
2004-10-30 14:54:51 +00:00
|
|
|
*
|
2001-09-27 23:55:28 +00:00
|
|
|
* XXX
|
|
|
|
* safety overkill. If this is a fragmented packet chain
|
|
|
|
* with delayed TCP/UDP checksums, then only encapsulate
|
|
|
|
* it if we have enough descriptors to handle the entire
|
|
|
|
* chain at once.
|
|
|
|
* (paranoia -- may not actually be needed)
|
|
|
|
*/
|
|
|
|
if (m_head->m_flags & M_FIRSTFRAG &&
|
|
|
|
m_head->m_pkthdr.csum_flags & (CSUM_DELAY_DATA)) {
|
|
|
|
if ((BGE_TX_RING_CNT - sc->bge_txcnt) <
|
|
|
|
m_head->m_pkthdr.csum_data + 16) {
|
2004-10-30 21:21:10 +00:00
|
|
|
IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_drv_flags |= IFF_DRV_OACTIVE;
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pack the data into the transmit ring. If we
|
|
|
|
* don't have room, set the OACTIVE flag and wait
|
|
|
|
* for the NIC to drain the ring.
|
|
|
|
*/
|
2006-08-17 09:53:04 +00:00
|
|
|
if (bge_encap(sc, &m_head, &prodidx)) {
|
|
|
|
if (m_head == NULL)
|
|
|
|
break;
|
2004-10-30 21:21:10 +00:00
|
|
|
IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_drv_flags |= IFF_DRV_OACTIVE;
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-10-30 22:59:30 +00:00
|
|
|
++count;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's a BPF listener, bounce a copy of this frame
|
|
|
|
* to him.
|
|
|
|
*/
|
2007-03-06 19:15:16 +00:00
|
|
|
#ifdef ETHER_BPF_MTAP
|
2006-12-20 01:12:07 +00:00
|
|
|
ETHER_BPF_MTAP(ifp, m_head);
|
2007-03-06 19:15:16 +00:00
|
|
|
#else
|
|
|
|
BPF_MTAP(ifp, m_head);
|
|
|
|
#endif
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
if (count > 0) {
|
|
|
|
bus_dmamap_sync(sc->bge_cdata.bge_tx_ring_tag,
|
|
|
|
sc->bge_cdata.bge_tx_ring_map, BUS_DMASYNC_PREWRITE);
|
|
|
|
/* Transmit. */
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_TX_HOST_PROD0_LO, prodidx);
|
2009-11-22 19:44:11 +00:00
|
|
|
/* 5700 b2 errata */
|
|
|
|
if (sc->bge_chiprev == BGE_CHIPREV_5700_BX)
|
|
|
|
bge_writembx(sc, BGE_MBX_TX_HOST_PROD0_LO, prodidx);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
sc->bge_tx_prodidx = prodidx;
|
2005-12-18 20:26:12 +00:00
|
|
|
|
2009-11-22 19:44:11 +00:00
|
|
|
/*
|
|
|
|
* Set a timeout in case the chip goes out to lunch.
|
|
|
|
*/
|
|
|
|
sc->bge_timer = 5;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
/*
|
|
|
|
* Main transmit routine. To avoid having to do mbuf copies, we put pointers
|
|
|
|
* to the mbuf data regions directly in the transmit descriptors.
|
|
|
|
*/
|
2001-09-27 23:55:28 +00:00
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_start(struct ifnet *ifp)
|
2003-11-11 17:57:03 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
bge_start_locked(ifp);
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_init_locked(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
2006-06-07 21:03:20 +00:00
|
|
|
uint16_t *m;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING)
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Cancel pending I/O and flush buffers. */
|
|
|
|
bge_stop(sc);
|
2006-09-09 03:36:57 +00:00
|
|
|
|
|
|
|
bge_stop_fw(sc);
|
|
|
|
bge_sig_pre_reset(sc, BGE_RESET_START);
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_reset(sc);
|
2006-09-09 03:36:57 +00:00
|
|
|
bge_sig_legacy(sc, BGE_RESET_START);
|
|
|
|
bge_sig_post_reset(sc, BGE_RESET_START);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_chipinit(sc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Init the various state machines, ring
|
|
|
|
* control blocks and firmware.
|
|
|
|
*/
|
|
|
|
if (bge_blockinit(sc)) {
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf(sc->bge_dev, "initialization failure\n");
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Specify MTU. */
|
|
|
|
CSR_WRITE_4(sc, BGE_RX_MTU, ifp->if_mtu +
|
2007-06-01 02:02:39 +00:00
|
|
|
ETHER_HDR_LEN + ETHER_CRC_LEN +
|
|
|
|
(ifp->if_capenable & IFCAP_VLAN_MTU ? ETHER_VLAN_ENCAP_LEN : 0));
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Load our MAC address. */
|
2006-06-07 21:03:20 +00:00
|
|
|
m = (uint16_t *)IF_LLADDR(sc->bge_ifp);
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_ADDR1_LO, htons(m[0]));
|
|
|
|
CSR_WRITE_4(sc, BGE_MAC_ADDR1_HI, (htons(m[1]) << 16) | htons(m[2]));
|
|
|
|
|
2006-09-18 22:18:21 +00:00
|
|
|
/* Program promiscuous mode. */
|
|
|
|
bge_setpromisc(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Program multicast filter. */
|
|
|
|
bge_setmulti(sc);
|
|
|
|
|
2007-06-01 02:02:39 +00:00
|
|
|
/* Program VLAN tag stripping. */
|
|
|
|
bge_setvlan(sc);
|
|
|
|
|
2010-08-22 01:39:09 +00:00
|
|
|
/* Override UDP checksum offloading. */
|
|
|
|
if (sc->bge_forced_udpcsum == 0)
|
|
|
|
sc->bge_csum_features &= ~CSUM_UDP;
|
|
|
|
else
|
|
|
|
sc->bge_csum_features |= CSUM_UDP;
|
|
|
|
if (ifp->if_capabilities & IFCAP_TXCSUM &&
|
|
|
|
ifp->if_capenable & IFCAP_TXCSUM) {
|
|
|
|
ifp->if_hwassist &= ~(BGE_CSUM_FEATURES | CSUM_UDP);
|
|
|
|
ifp->if_hwassist |= sc->bge_csum_features;
|
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Init RX ring. */
|
2009-11-04 21:06:54 +00:00
|
|
|
if (bge_init_rx_ring_std(sc) != 0) {
|
|
|
|
device_printf(sc->bge_dev, "no memory for std Rx buffers.\n");
|
|
|
|
bge_stop(sc);
|
|
|
|
return;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-07-16 00:09:56 +00:00
|
|
|
/*
|
|
|
|
* Workaround for a bug in 5705 ASIC rev A0. Poll the NIC's
|
|
|
|
* memory to insure that the chip has in fact read the first
|
|
|
|
* entry of the ring.
|
|
|
|
*/
|
|
|
|
if (sc->bge_chipid == BGE_CHIPID_BCM5705_A0) {
|
2006-06-07 21:03:20 +00:00
|
|
|
uint32_t v, i;
|
2003-07-16 00:09:56 +00:00
|
|
|
for (i = 0; i < 10; i++) {
|
|
|
|
DELAY(20);
|
|
|
|
v = bge_readmem_ind(sc, BGE_STD_RX_RINGS + 8);
|
|
|
|
if (v == (MCLBYTES - ETHER_ALIGN))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == 10)
|
2005-12-23 02:04:41 +00:00
|
|
|
device_printf (sc->bge_dev,
|
|
|
|
"5705 A0 chip failed to load RX ring\n");
|
2003-07-16 00:09:56 +00:00
|
|
|
}
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Init jumbo RX ring. */
|
2009-11-06 23:49:20 +00:00
|
|
|
if (ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN >
|
|
|
|
(MCLBYTES - ETHER_ALIGN)) {
|
2009-11-04 21:06:54 +00:00
|
|
|
if (bge_init_rx_ring_jumbo(sc) != 0) {
|
2010-07-13 19:39:51 +00:00
|
|
|
device_printf(sc->bge_dev,
|
2010-07-13 19:42:55 +00:00
|
|
|
"no memory for jumbo Rx buffers.\n");
|
2009-11-04 21:06:54 +00:00
|
|
|
bge_stop(sc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Init our RX return ring index. */
|
2001-09-27 23:55:28 +00:00
|
|
|
sc->bge_rx_saved_considx = 0;
|
|
|
|
|
2006-12-01 01:08:52 +00:00
|
|
|
/* Init our RX/TX stat counters. */
|
|
|
|
sc->bge_rx_discards = sc->bge_tx_discards = sc->bge_tx_collisions = 0;
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Init TX ring. */
|
|
|
|
bge_init_tx_ring(sc);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Turn on transmitter. */
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_TX_MODE, BGE_TXMODE_ENABLE);
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Turn on receiver. */
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_RX_MODE, BGE_RXMODE_ENABLE);
|
|
|
|
|
|
|
|
/* Tell firmware we're alive. */
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
|
|
|
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
/* Disable interrupts if we are polling. */
|
|
|
|
if (ifp->if_capenable & IFCAP_POLLING) {
|
|
|
|
BGE_SETBIT(sc, BGE_PCI_MISC_CTL,
|
|
|
|
BGE_PCIMISCCTL_MASK_PCI_INTR);
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 1);
|
2005-10-22 14:31:01 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2006-09-09 03:36:57 +00:00
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/* Enable host interrupts. */
|
2005-10-22 14:31:01 +00:00
|
|
|
{
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_SETBIT(sc, BGE_PCI_MISC_CTL, BGE_PCIMISCCTL_CLEAR_INTA);
|
|
|
|
BGE_CLRBIT(sc, BGE_PCI_MISC_CTL, BGE_PCIMISCCTL_MASK_PCI_INTR);
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 0);
|
2005-10-22 14:31:01 +00:00
|
|
|
}
|
2009-11-22 18:30:19 +00:00
|
|
|
|
2006-08-24 14:41:16 +00:00
|
|
|
bge_ifmedia_upd_locked(ifp);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_drv_flags |= IFF_DRV_RUNNING;
|
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
callout_reset(&sc->bge_stat_ch, hz, bge_tick, sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_init(void *xsc)
|
2003-11-11 17:57:03 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc = xsc;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
|
|
|
bge_init_locked(sc);
|
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set media options.
|
|
|
|
*/
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_ifmedia_upd(struct ifnet *ifp)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2006-08-24 14:41:16 +00:00
|
|
|
struct bge_softc *sc = ifp->if_softc;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
res = bge_ifmedia_upd_locked(ifp);
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_ifmedia_upd_locked(struct ifnet *ifp)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc = ifp->if_softc;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct mii_data *mii;
|
2009-03-21 00:23:07 +00:00
|
|
|
struct mii_softc *miisc;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct ifmedia *ifm;
|
|
|
|
|
2006-08-24 14:41:16 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
ifm = &sc->bge_ifmedia;
|
|
|
|
|
|
|
|
/* If this is a 1000baseX NIC, enable the TBI port. */
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2001-09-27 23:55:28 +00:00
|
|
|
if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
|
2006-06-07 21:03:20 +00:00
|
|
|
return (EINVAL);
|
2001-09-27 23:55:28 +00:00
|
|
|
switch(IFM_SUBTYPE(ifm->ifm_media)) {
|
|
|
|
case IFM_AUTO:
|
2005-06-24 21:43:47 +00:00
|
|
|
/*
|
|
|
|
* The BCM5704 ASIC appears to have a special
|
|
|
|
* mechanism for programming the autoneg
|
|
|
|
* advertisement registers in TBI mode.
|
|
|
|
*/
|
2007-05-22 19:35:34 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5704) {
|
2005-06-24 21:43:47 +00:00
|
|
|
uint32_t sgdig;
|
2007-05-22 19:35:34 +00:00
|
|
|
sgdig = CSR_READ_4(sc, BGE_SGDIG_STS);
|
|
|
|
if (sgdig & BGE_SGDIGSTS_DONE) {
|
|
|
|
CSR_WRITE_4(sc, BGE_TX_TBI_AUTONEG, 0);
|
|
|
|
sgdig = CSR_READ_4(sc, BGE_SGDIG_CFG);
|
|
|
|
sgdig |= BGE_SGDIGCFG_AUTO |
|
|
|
|
BGE_SGDIGCFG_PAUSE_CAP |
|
|
|
|
BGE_SGDIGCFG_ASYM_PAUSE;
|
|
|
|
CSR_WRITE_4(sc, BGE_SGDIG_CFG,
|
|
|
|
sgdig | BGE_SGDIGCFG_SEND);
|
|
|
|
DELAY(5);
|
|
|
|
CSR_WRITE_4(sc, BGE_SGDIG_CFG, sgdig);
|
|
|
|
}
|
2005-06-24 21:43:47 +00:00
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
case IFM_1000_SX:
|
|
|
|
if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
|
|
|
|
BGE_CLRBIT(sc, BGE_MAC_MODE,
|
|
|
|
BGE_MACMODE_HALF_DUPLEX);
|
|
|
|
} else {
|
|
|
|
BGE_SETBIT(sc, BGE_MAC_MODE,
|
|
|
|
BGE_MACMODE_HALF_DUPLEX);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2006-06-07 21:03:20 +00:00
|
|
|
return (EINVAL);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
2006-02-17 14:33:35 +00:00
|
|
|
sc->bge_link_evt++;
|
2001-09-27 23:55:28 +00:00
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
2009-03-21 00:23:07 +00:00
|
|
|
if (mii->mii_instance)
|
|
|
|
LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
|
2001-09-27 23:55:28 +00:00
|
|
|
mii_phy_reset(miisc);
|
|
|
|
mii_mediachg(mii);
|
|
|
|
|
2008-04-08 11:51:17 +00:00
|
|
|
/*
|
|
|
|
* Force an interrupt so that we will call bge_link_upd
|
|
|
|
* if needed and clear any pending link state attention.
|
|
|
|
* Without this we are not getting any further interrupts
|
|
|
|
* for link state changes and thus will not UP the link and
|
|
|
|
* not be able to send in bge_start_locked. The only
|
|
|
|
* way to get things working was to receive a packet and
|
|
|
|
* get an RX intr.
|
|
|
|
* bge_tick should help for fiber cards and we might not
|
|
|
|
* need to do this here if BGE_FLAG_TBI is set but as
|
|
|
|
* we poll for fiber anyway it should not harm.
|
|
|
|
*/
|
2008-05-05 18:42:17 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 ||
|
|
|
|
sc->bge_flags & BGE_FLAG_5788)
|
|
|
|
BGE_SETBIT(sc, BGE_MISC_LOCAL_CTL, BGE_MLC_INTR_SET);
|
|
|
|
else
|
|
|
|
BGE_SETBIT(sc, BGE_HCC_MODE, BGE_HCCMODE_COAL_NOW);
|
2008-04-08 11:51:17 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Report current media status.
|
|
|
|
*/
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2006-08-24 14:41:16 +00:00
|
|
|
struct bge_softc *sc = ifp->if_softc;
|
2001-09-27 23:55:28 +00:00
|
|
|
struct mii_data *mii;
|
|
|
|
|
2006-08-24 14:41:16 +00:00
|
|
|
BGE_LOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2001-09-27 23:55:28 +00:00
|
|
|
ifmr->ifm_status = IFM_AVALID;
|
|
|
|
ifmr->ifm_active = IFM_ETHER;
|
|
|
|
if (CSR_READ_4(sc, BGE_MAC_STS) &
|
|
|
|
BGE_MACSTAT_TBI_PCS_SYNCHED)
|
|
|
|
ifmr->ifm_status |= IFM_ACTIVE;
|
2006-06-15 14:31:49 +00:00
|
|
|
else {
|
|
|
|
ifmr->ifm_active |= IFM_NONE;
|
2006-08-24 14:41:16 +00:00
|
|
|
BGE_UNLOCK(sc);
|
2006-06-15 14:31:49 +00:00
|
|
|
return;
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
ifmr->ifm_active |= IFM_1000_SX;
|
|
|
|
if (CSR_READ_4(sc, BGE_MAC_MODE) & BGE_MACMODE_HALF_DUPLEX)
|
2004-10-30 14:54:51 +00:00
|
|
|
ifmr->ifm_active |= IFM_HDX;
|
2001-09-27 23:55:28 +00:00
|
|
|
else
|
|
|
|
ifmr->ifm_active |= IFM_FDX;
|
2006-08-24 14:41:16 +00:00
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
|
|
|
mii_pollstat(mii);
|
|
|
|
ifmr->ifm_active = mii->mii_media_active;
|
|
|
|
ifmr->ifm_status = mii->mii_media_status;
|
2006-08-24 14:41:16 +00:00
|
|
|
|
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc = ifp->if_softc;
|
|
|
|
struct ifreq *ifr = (struct ifreq *) data;
|
|
|
|
struct mii_data *mii;
|
2006-09-18 20:54:40 +00:00
|
|
|
int flags, mask, error = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
switch (command) {
|
2001-09-27 23:55:28 +00:00
|
|
|
case SIOCSIFMTU:
|
2006-06-15 14:31:49 +00:00
|
|
|
if (ifr->ifr_mtu < ETHERMIN ||
|
|
|
|
((BGE_IS_JUMBO_CAPABLE(sc)) &&
|
|
|
|
ifr->ifr_mtu > BGE_JUMBO_MTU) ||
|
|
|
|
((!BGE_IS_JUMBO_CAPABLE(sc)) &&
|
|
|
|
ifr->ifr_mtu > ETHERMTU))
|
2001-09-27 23:55:28 +00:00
|
|
|
error = EINVAL;
|
2006-06-15 14:31:49 +00:00
|
|
|
else if (ifp->if_mtu != ifr->ifr_mtu) {
|
2001-09-27 23:55:28 +00:00
|
|
|
ifp->if_mtu = ifr->ifr_mtu;
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_init(sc);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SIOCSIFFLAGS:
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
if (ifp->if_flags & IFF_UP) {
|
|
|
|
/*
|
|
|
|
* If only the state of the PROMISC flag changed,
|
|
|
|
* then just use the 'set promisc mode' command
|
|
|
|
* instead of reinitializing the entire NIC. Doing
|
|
|
|
* a full re-init means reloading the firmware and
|
|
|
|
* waiting for it to start up, which may take a
|
2006-02-01 10:11:24 +00:00
|
|
|
* second or two. Similarly for ALLMULTI.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
2006-09-18 20:54:40 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
|
|
|
flags = ifp->if_flags ^ sc->bge_if_flags;
|
2006-09-18 22:18:21 +00:00
|
|
|
if (flags & IFF_PROMISC)
|
|
|
|
bge_setpromisc(sc);
|
2006-09-18 20:54:40 +00:00
|
|
|
if (flags & IFF_ALLMULTI)
|
|
|
|
bge_setmulti(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
} else
|
2003-11-11 17:57:03 +00:00
|
|
|
bge_init_locked(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
} else {
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_stop(sc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sc->bge_if_flags = ifp->if_flags;
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
2005-08-09 10:20:02 +00:00
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_setmulti(sc);
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_UNLOCK(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
error = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SIOCSIFMEDIA:
|
|
|
|
case SIOCGIFMEDIA:
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2001-09-27 23:55:28 +00:00
|
|
|
error = ifmedia_ioctl(ifp, ifr,
|
|
|
|
&sc->bge_ifmedia, command);
|
|
|
|
} else {
|
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
|
|
|
error = ifmedia_ioctl(ifp, ifr,
|
|
|
|
&mii->mii_media, command);
|
|
|
|
}
|
|
|
|
break;
|
2004-10-30 14:54:51 +00:00
|
|
|
case SIOCSIFCAP:
|
2001-09-27 23:55:28 +00:00
|
|
|
mask = ifr->ifr_reqcap ^ ifp->if_capenable;
|
2005-10-22 14:31:01 +00:00
|
|
|
#ifdef DEVICE_POLLING
|
|
|
|
if (mask & IFCAP_POLLING) {
|
|
|
|
if (ifr->ifr_reqcap & IFCAP_POLLING) {
|
|
|
|
error = ether_poll_register(bge_poll, ifp);
|
|
|
|
if (error)
|
2006-06-07 21:03:20 +00:00
|
|
|
return (error);
|
2005-10-22 14:31:01 +00:00
|
|
|
BGE_LOCK(sc);
|
|
|
|
BGE_SETBIT(sc, BGE_PCI_MISC_CTL,
|
|
|
|
BGE_PCIMISCCTL_MASK_PCI_INTR);
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 1);
|
2006-06-08 10:19:16 +00:00
|
|
|
ifp->if_capenable |= IFCAP_POLLING;
|
2005-10-22 14:31:01 +00:00
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
} else {
|
|
|
|
error = ether_poll_deregister(ifp);
|
|
|
|
/* Enable interrupt even in error case */
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
BGE_CLRBIT(sc, BGE_PCI_MISC_CTL,
|
|
|
|
BGE_PCIMISCCTL_MASK_PCI_INTR);
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 0);
|
2005-10-22 14:31:01 +00:00
|
|
|
ifp->if_capenable &= ~IFCAP_POLLING;
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2005-12-22 15:14:42 +00:00
|
|
|
if (mask & IFCAP_HWCSUM) {
|
|
|
|
ifp->if_capenable ^= IFCAP_HWCSUM;
|
|
|
|
if (IFCAP_HWCSUM & ifp->if_capenable &&
|
|
|
|
IFCAP_HWCSUM & ifp->if_capabilities)
|
2010-08-22 01:39:09 +00:00
|
|
|
ifp->if_hwassist |= sc->bge_csum_features;
|
2001-09-27 23:55:28 +00:00
|
|
|
else
|
2010-08-22 01:39:09 +00:00
|
|
|
ifp->if_hwassist &= ~sc->bge_csum_features;
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2007-06-01 02:02:39 +00:00
|
|
|
|
2009-11-22 21:16:30 +00:00
|
|
|
if ((mask & IFCAP_TSO4) != 0 &&
|
|
|
|
(ifp->if_capabilities & IFCAP_TSO4) != 0) {
|
|
|
|
ifp->if_capenable ^= IFCAP_TSO4;
|
|
|
|
if ((ifp->if_capenable & IFCAP_TSO4) != 0)
|
|
|
|
ifp->if_hwassist |= CSUM_TSO;
|
|
|
|
else
|
|
|
|
ifp->if_hwassist &= ~CSUM_TSO;
|
|
|
|
}
|
|
|
|
|
2007-06-01 02:02:39 +00:00
|
|
|
if (mask & IFCAP_VLAN_MTU) {
|
|
|
|
ifp->if_capenable ^= IFCAP_VLAN_MTU;
|
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
|
|
|
|
bge_init(sc);
|
|
|
|
}
|
|
|
|
|
2010-02-20 23:21:06 +00:00
|
|
|
if ((mask & IFCAP_VLAN_HWTSO) != 0 &&
|
|
|
|
(ifp->if_capabilities & IFCAP_VLAN_HWTSO) != 0)
|
|
|
|
ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
|
|
|
|
if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
|
|
|
|
(ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) {
|
2007-06-01 02:02:39 +00:00
|
|
|
ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
|
2010-02-20 23:21:06 +00:00
|
|
|
if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0)
|
|
|
|
ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
|
2007-06-01 02:02:39 +00:00
|
|
|
BGE_LOCK(sc);
|
|
|
|
bge_setvlan(sc);
|
|
|
|
BGE_UNLOCK(sc);
|
2010-02-20 23:21:06 +00:00
|
|
|
}
|
2007-06-01 02:02:39 +00:00
|
|
|
#ifdef VLAN_CAPABILITIES
|
2010-02-20 23:21:06 +00:00
|
|
|
VLAN_CAPABILITIES(ifp);
|
2007-06-01 02:02:39 +00:00
|
|
|
#endif
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
default:
|
2002-11-14 23:54:55 +00:00
|
|
|
error = ether_ioctl(ifp, command, data);
|
2001-09-27 23:55:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
return (error);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-11-30 13:40:39 +00:00
|
|
|
bge_watchdog(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
2006-11-30 13:40:39 +00:00
|
|
|
struct ifnet *ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-11-30 13:40:39 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
|
|
|
if (sc->bge_timer == 0 || --sc->bge_timer)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-12-23 02:04:41 +00:00
|
|
|
if_printf(ifp, "watchdog timeout -- resetting\n");
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2005-08-09 10:20:02 +00:00
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
|
2006-12-04 14:35:17 +00:00
|
|
|
bge_init_locked(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the adapter and free any mbufs allocated to the
|
|
|
|
* RX and TX lists.
|
|
|
|
*/
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_stop(struct bge_softc *sc)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK_ASSERT(sc);
|
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = sc->bge_ifp;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2003-11-11 17:57:03 +00:00
|
|
|
callout_stop(&sc->bge_stat_ch);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2009-10-13 20:22:12 +00:00
|
|
|
/* Disable host interrupts. */
|
|
|
|
BGE_SETBIT(sc, BGE_PCI_MISC_CTL, BGE_PCIMISCCTL_MASK_PCI_INTR);
|
|
|
|
bge_writembx(sc, BGE_MBX_IRQ0_LO, 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell firmware we're shutting down.
|
|
|
|
*/
|
|
|
|
bge_stop_fw(sc);
|
|
|
|
bge_sig_pre_reset(sc, BGE_RESET_STOP);
|
|
|
|
|
2001-09-27 23:55:28 +00:00
|
|
|
/*
|
2006-06-07 21:03:20 +00:00
|
|
|
* Disable all of the receiver blocks.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
|
|
|
BGE_CLRBIT(sc, BGE_RX_MODE, BGE_RXMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_RBDI_MODE, BGE_RBDIMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_RXLP_MODE, BGE_RXLPMODE_ENABLE);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_RXLS_MODE, BGE_RXLSMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_RDBDI_MODE, BGE_RBDIMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_RDC_MODE, BGE_RDCMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_RBDC_MODE, BGE_RBDCMODE_ENABLE);
|
|
|
|
|
|
|
|
/*
|
2006-06-07 21:03:20 +00:00
|
|
|
* Disable all of the transmit blocks.
|
2001-09-27 23:55:28 +00:00
|
|
|
*/
|
|
|
|
BGE_CLRBIT(sc, BGE_SRS_MODE, BGE_SRSMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_SBDI_MODE, BGE_SBDIMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_SDI_MODE, BGE_SDIMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_RDMA_MODE, BGE_RDMAMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_SDC_MODE, BGE_SDCMODE_ENABLE);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_DMAC_MODE, BGE_DMACMODE_ENABLE);
|
2001-09-27 23:55:28 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_SBDC_MODE, BGE_SBDCMODE_ENABLE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shut down all of the memory managers and related
|
|
|
|
* state machines.
|
|
|
|
*/
|
|
|
|
BGE_CLRBIT(sc, BGE_HCC_MODE, BGE_HCCMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_WDMA_MODE, BGE_WDMAMODE_ENABLE);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc)))
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_MBCF_MODE, BGE_MBCFMODE_ENABLE);
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_FTQ_RESET, 0xFFFFFFFF);
|
2001-09-27 23:55:28 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_FTQ_RESET, 0);
|
2006-12-04 22:12:21 +00:00
|
|
|
if (!(BGE_IS_5705_PLUS(sc))) {
|
2003-07-16 00:09:56 +00:00
|
|
|
BGE_CLRBIT(sc, BGE_BMAN_MODE, BGE_BMANMODE_ENABLE);
|
|
|
|
BGE_CLRBIT(sc, BGE_MARB_MODE, BGE_MARBMODE_ENABLE);
|
|
|
|
}
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-09-09 03:36:57 +00:00
|
|
|
bge_reset(sc);
|
|
|
|
bge_sig_legacy(sc, BGE_RESET_STOP);
|
|
|
|
bge_sig_post_reset(sc, BGE_RESET_STOP);
|
|
|
|
|
2009-11-22 18:30:19 +00:00
|
|
|
/*
|
2006-09-09 03:36:57 +00:00
|
|
|
* Keep the ASF firmware running if up.
|
|
|
|
*/
|
|
|
|
if (sc->bge_asf_mode & ASF_STACKUP)
|
|
|
|
BGE_SETBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
|
|
|
else
|
|
|
|
BGE_CLRBIT(sc, BGE_MODE_CTL, BGE_MODECTL_STACKUP);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Free the RX lists. */
|
|
|
|
bge_free_rx_ring_std(sc);
|
|
|
|
|
|
|
|
/* Free jumbo RX list. */
|
2006-06-15 14:31:49 +00:00
|
|
|
if (BGE_IS_JUMBO_CAPABLE(sc))
|
2003-07-16 00:09:56 +00:00
|
|
|
bge_free_rx_ring_jumbo(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
|
|
|
|
/* Free TX buffers. */
|
|
|
|
bge_free_tx_ring(sc);
|
|
|
|
|
|
|
|
sc->bge_tx_saved_considx = BGE_TXCONS_UNSET;
|
|
|
|
|
2006-12-19 08:57:46 +00:00
|
|
|
/* Clear MAC's link state (PHY may still have link UP). */
|
2006-02-17 14:33:35 +00:00
|
|
|
if (bootverbose && sc->bge_link)
|
|
|
|
if_printf(sc->bge_ifp, "link DOWN\n");
|
|
|
|
sc->bge_link = 0;
|
2001-09-27 23:55:28 +00:00
|
|
|
|
2006-02-17 14:33:35 +00:00
|
|
|
ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
|
2001-09-27 23:55:28 +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-05 18:43:13 +00:00
|
|
|
static int
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_shutdown(device_t dev)
|
2001-09-27 23:55:28 +00:00
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_LOCK(sc);
|
2004-10-30 14:54:51 +00:00
|
|
|
bge_stop(sc);
|
2001-09-27 23:55:28 +00:00
|
|
|
bge_reset(sc);
|
2003-11-11 17:57:03 +00:00
|
|
|
BGE_UNLOCK(sc);
|
2009-02-05 18:43:13 +00:00
|
|
|
|
|
|
|
return (0);
|
2001-09-27 23:55:28 +00:00
|
|
|
}
|
2005-09-28 19:20:49 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
bge_suspend(device_t dev)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
bge_stop(sc);
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_resume(device_t dev)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
BGE_LOCK(sc);
|
|
|
|
ifp = sc->bge_ifp;
|
|
|
|
if (ifp->if_flags & IFF_UP) {
|
|
|
|
bge_init_locked(sc);
|
|
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING)
|
|
|
|
bge_start_locked(ifp);
|
|
|
|
}
|
|
|
|
BGE_UNLOCK(sc);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
2005-12-08 13:31:52 +00:00
|
|
|
|
|
|
|
static void
|
2006-06-07 21:03:20 +00:00
|
|
|
bge_link_upd(struct bge_softc *sc)
|
2005-12-08 13:31:52 +00:00
|
|
|
{
|
2006-01-13 08:59:40 +00:00
|
|
|
struct mii_data *mii;
|
|
|
|
uint32_t link, status;
|
2005-12-08 13:31:52 +00:00
|
|
|
|
|
|
|
BGE_LOCK_ASSERT(sc);
|
2006-01-13 08:59:40 +00:00
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Clear 'pending link event' flag. */
|
2006-02-01 14:26:35 +00:00
|
|
|
sc->bge_link_evt = 0;
|
|
|
|
|
2005-12-08 13:31:52 +00:00
|
|
|
/*
|
|
|
|
* Process link state changes.
|
|
|
|
* Grrr. The link status word in the status block does
|
|
|
|
* not work correctly on the BCM5700 rev AX and BX chips,
|
|
|
|
* according to all available information. Hence, we have
|
|
|
|
* to enable MII interrupts in order to properly obtain
|
|
|
|
* async link changes. Unfortunately, this also means that
|
|
|
|
* we have to read the MAC status register to detect link
|
|
|
|
* changes, thereby adding an additional register access to
|
|
|
|
* the interrupt handler.
|
2006-01-13 08:59:40 +00:00
|
|
|
*
|
|
|
|
* XXX: perhaps link state detection procedure used for
|
2006-06-15 14:31:49 +00:00
|
|
|
* BGE_CHIPID_BCM5700_B2 can be used for others BCM5700 revisions.
|
2005-12-08 13:31:52 +00:00
|
|
|
*/
|
|
|
|
|
2006-01-13 08:59:40 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5700 &&
|
2006-06-15 14:31:49 +00:00
|
|
|
sc->bge_chipid != BGE_CHIPID_BCM5700_B2) {
|
2005-12-08 13:31:52 +00:00
|
|
|
status = CSR_READ_4(sc, BGE_MAC_STS);
|
|
|
|
if (status & BGE_MACSTAT_MI_INTERRUPT) {
|
2006-01-13 08:59:40 +00:00
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
2006-12-19 08:57:46 +00:00
|
|
|
mii_pollstat(mii);
|
2006-01-13 08:59:40 +00:00
|
|
|
if (!sc->bge_link &&
|
|
|
|
mii->mii_media_status & IFM_ACTIVE &&
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
|
|
|
|
sc->bge_link++;
|
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link UP\n");
|
|
|
|
} else if (sc->bge_link &&
|
|
|
|
(!(mii->mii_media_status & IFM_ACTIVE) ||
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) == IFM_NONE)) {
|
|
|
|
sc->bge_link = 0;
|
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link DOWN\n");
|
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Clear the interrupt. */
|
2005-12-08 13:31:52 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_EVT_ENB,
|
|
|
|
BGE_EVTENB_MI_INTERRUPT);
|
|
|
|
bge_miibus_readreg(sc->bge_dev, 1, BRGPHY_MII_ISR);
|
|
|
|
bge_miibus_writereg(sc->bge_dev, 1, BRGPHY_MII_IMR,
|
|
|
|
BRGPHY_INTRS);
|
|
|
|
}
|
|
|
|
return;
|
2006-06-08 10:19:16 +00:00
|
|
|
}
|
2005-12-08 13:31:52 +00:00
|
|
|
|
2006-08-23 11:32:54 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_TBI) {
|
2006-01-13 08:59:40 +00:00
|
|
|
status = CSR_READ_4(sc, BGE_MAC_STS);
|
2006-02-01 14:26:35 +00:00
|
|
|
if (status & BGE_MACSTAT_TBI_PCS_SYNCHED) {
|
|
|
|
if (!sc->bge_link) {
|
2006-01-13 08:59:40 +00:00
|
|
|
sc->bge_link++;
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5704)
|
|
|
|
BGE_CLRBIT(sc, BGE_MAC_MODE,
|
|
|
|
BGE_MACMODE_TBI_SEND_CFGS);
|
2007-03-08 00:29:18 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_STS, 0xFFFFFFFF);
|
2006-01-13 08:59:40 +00:00
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link UP\n");
|
2006-06-07 21:03:20 +00:00
|
|
|
if_link_state_change(sc->bge_ifp,
|
|
|
|
LINK_STATE_UP);
|
2006-01-13 08:59:40 +00:00
|
|
|
}
|
2006-02-01 14:26:35 +00:00
|
|
|
} else if (sc->bge_link) {
|
|
|
|
sc->bge_link = 0;
|
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link DOWN\n");
|
|
|
|
if_link_state_change(sc->bge_ifp, LINK_STATE_DOWN);
|
2006-01-13 08:59:40 +00:00
|
|
|
}
|
2006-02-17 14:33:35 +00:00
|
|
|
} else if (CSR_READ_4(sc, BGE_MI_MODE) & BGE_MIMODE_AUTOPOLL) {
|
2006-06-08 10:19:16 +00:00
|
|
|
/*
|
2007-03-08 00:29:18 +00:00
|
|
|
* Some broken BCM chips have BGE_STATFLAG_LINKSTATE_CHANGED bit
|
|
|
|
* in status word always set. Workaround this bug by reading
|
|
|
|
* PHY link status directly.
|
2006-01-13 08:59:40 +00:00
|
|
|
*/
|
|
|
|
link = (CSR_READ_4(sc, BGE_MI_STS) & BGE_MISTS_LINK) ? 1 : 0;
|
|
|
|
|
|
|
|
if (link != sc->bge_link ||
|
|
|
|
sc->bge_asicrev == BGE_ASICREV_BCM5700) {
|
|
|
|
mii = device_get_softc(sc->bge_miibus);
|
2006-12-19 08:57:46 +00:00
|
|
|
mii_pollstat(mii);
|
2006-01-13 08:59:40 +00:00
|
|
|
if (!sc->bge_link &&
|
|
|
|
mii->mii_media_status & IFM_ACTIVE &&
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
|
|
|
|
sc->bge_link++;
|
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link UP\n");
|
|
|
|
} else if (sc->bge_link &&
|
|
|
|
(!(mii->mii_media_status & IFM_ACTIVE) ||
|
|
|
|
IFM_SUBTYPE(mii->mii_media_active) == IFM_NONE)) {
|
|
|
|
sc->bge_link = 0;
|
|
|
|
if (bootverbose)
|
|
|
|
if_printf(sc->bge_ifp, "link DOWN\n");
|
|
|
|
}
|
|
|
|
}
|
2007-03-08 00:29:18 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Discard link events for MII/GMII controllers
|
|
|
|
* if MI auto-polling is disabled.
|
|
|
|
*/
|
2005-12-08 13:31:52 +00:00
|
|
|
}
|
|
|
|
|
2006-06-07 21:03:20 +00:00
|
|
|
/* Clear the attention. */
|
2007-03-06 20:14:48 +00:00
|
|
|
CSR_WRITE_4(sc, BGE_MAC_STS, BGE_MACSTAT_SYNC_CHANGED |
|
|
|
|
BGE_MACSTAT_CFG_CHANGED | BGE_MACSTAT_MI_COMPLETE |
|
2005-12-08 13:31:52 +00:00
|
|
|
BGE_MACSTAT_LINK_CHANGED);
|
|
|
|
}
|
2006-12-12 05:11:12 +00:00
|
|
|
|
2007-03-12 09:25:57 +00:00
|
|
|
#define BGE_SYSCTL_STAT(sc, ctx, desc, parent, node, oid) \
|
2007-03-13 00:41:55 +00:00
|
|
|
SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, oid, CTLTYPE_UINT|CTLFLAG_RD, \
|
2007-03-12 09:25:57 +00:00
|
|
|
sc, offsetof(struct bge_stats, node), bge_sysctl_stats, "IU", \
|
|
|
|
desc)
|
|
|
|
|
2006-12-12 05:11:12 +00:00
|
|
|
static void
|
|
|
|
bge_add_sysctls(struct bge_softc *sc)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_list *ctx;
|
2007-03-12 09:25:57 +00:00
|
|
|
struct sysctl_oid_list *children, *schildren;
|
|
|
|
struct sysctl_oid *tree;
|
2010-08-21 23:13:16 +00:00
|
|
|
char tn[32];
|
|
|
|
int unit;
|
2006-12-12 05:11:12 +00:00
|
|
|
|
|
|
|
ctx = device_get_sysctl_ctx(sc->bge_dev);
|
|
|
|
children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->bge_dev));
|
|
|
|
|
|
|
|
#ifdef BGE_REGISTER_DEBUG
|
|
|
|
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "debug_info",
|
|
|
|
CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_debug_info, "I",
|
|
|
|
"Debug Information");
|
|
|
|
|
|
|
|
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "reg_read",
|
|
|
|
CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_reg_read, "I",
|
|
|
|
"Register Read");
|
|
|
|
|
|
|
|
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mem_read",
|
|
|
|
CTLTYPE_INT | CTLFLAG_RW, sc, 0, bge_sysctl_mem_read, "I",
|
|
|
|
"Memory Read");
|
|
|
|
|
|
|
|
#endif
|
2007-03-12 09:25:57 +00:00
|
|
|
|
2010-08-21 23:13:16 +00:00
|
|
|
unit = device_get_unit(sc->bge_dev);
|
2009-12-08 17:54:23 +00:00
|
|
|
/*
|
|
|
|
* A common design characteristic for many Broadcom client controllers
|
|
|
|
* is that they only support a single outstanding DMA read operation
|
|
|
|
* on the PCIe bus. This means that it will take twice as long to fetch
|
|
|
|
* a TX frame that is split into header and payload buffers as it does
|
|
|
|
* to fetch a single, contiguous TX frame (2 reads vs. 1 read). For
|
|
|
|
* these controllers, coalescing buffers to reduce the number of memory
|
|
|
|
* reads is effective way to get maximum performance(about 940Mbps).
|
|
|
|
* Without collapsing TX buffers the maximum TCP bulk transfer
|
|
|
|
* performance is about 850Mbps. However forcing coalescing mbufs
|
|
|
|
* consumes a lot of CPU cycles, so leave it off by default.
|
|
|
|
*/
|
2010-08-21 23:13:16 +00:00
|
|
|
sc->bge_forced_collapse = 0;
|
|
|
|
snprintf(tn, sizeof(tn), "dev.bge.%d.forced_collapse", unit);
|
|
|
|
TUNABLE_INT_FETCH(tn, &sc->bge_forced_collapse);
|
2009-12-08 17:54:23 +00:00
|
|
|
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "forced_collapse",
|
|
|
|
CTLFLAG_RW, &sc->bge_forced_collapse, 0,
|
|
|
|
"Number of fragmented TX buffers of a frame allowed before "
|
|
|
|
"forced collapsing");
|
|
|
|
|
2010-08-22 01:39:09 +00:00
|
|
|
/*
|
|
|
|
* It seems all Broadcom controllers have a bug that can generate UDP
|
|
|
|
* datagrams with checksum value 0 when TX UDP checksum offloading is
|
|
|
|
* enabled. Generating UDP checksum value 0 is RFC 768 violation.
|
|
|
|
* Even though the probability of generating such UDP datagrams is
|
|
|
|
* low, I don't want to see FreeBSD boxes to inject such datagrams
|
|
|
|
* into network so disable UDP checksum offloading by default. Users
|
|
|
|
* still override this behavior by setting a sysctl variable,
|
|
|
|
* dev.bge.0.forced_udpcsum.
|
|
|
|
*/
|
|
|
|
sc->bge_forced_udpcsum = 0;
|
|
|
|
snprintf(tn, sizeof(tn), "dev.bge.%d.bge_forced_udpcsum", unit);
|
|
|
|
TUNABLE_INT_FETCH(tn, &sc->bge_forced_udpcsum);
|
|
|
|
SYSCTL_ADD_INT(ctx, children, OID_AUTO, "forced_udpcsum",
|
|
|
|
CTLFLAG_RW, &sc->bge_forced_udpcsum, 0,
|
|
|
|
"Enable UDP checksum offloading even if controller can "
|
|
|
|
"generate UDP checksum value 0");
|
|
|
|
|
2007-11-16 16:39:27 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
|
|
|
return;
|
|
|
|
|
2007-03-12 09:25:57 +00:00
|
|
|
tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD,
|
|
|
|
NULL, "BGE Statistics");
|
|
|
|
schildren = children = SYSCTL_CHILDREN(tree);
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Frames Dropped Due To Filters",
|
|
|
|
children, COSFramesDroppedDueToFilters,
|
|
|
|
"FramesDroppedDueToFilters");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC DMA Write Queue Full",
|
|
|
|
children, nicDmaWriteQueueFull, "DmaWriteQueueFull");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC DMA Write High Priority Queue Full",
|
|
|
|
children, nicDmaWriteHighPriQueueFull, "DmaWriteHighPriQueueFull");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC No More RX Buffer Descriptors",
|
|
|
|
children, nicNoMoreRxBDs, "NoMoreRxBDs");
|
2007-03-13 00:41:55 +00:00
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Discarded Input Frames",
|
|
|
|
children, ifInDiscards, "InputDiscards");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Input Errors",
|
|
|
|
children, ifInErrors, "InputErrors");
|
2007-03-12 09:25:57 +00:00
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Recv Threshold Hit",
|
|
|
|
children, nicRecvThresholdHit, "RecvThresholdHit");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC DMA Read Queue Full",
|
|
|
|
children, nicDmaReadQueueFull, "DmaReadQueueFull");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC DMA Read High Priority Queue Full",
|
|
|
|
children, nicDmaReadHighPriQueueFull, "DmaReadHighPriQueueFull");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Send Data Complete Queue Full",
|
|
|
|
children, nicSendDataCompQueueFull, "SendDataCompQueueFull");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Ring Set Send Producer Index",
|
|
|
|
children, nicRingSetSendProdIndex, "RingSetSendProdIndex");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Ring Status Update",
|
|
|
|
children, nicRingStatusUpdate, "RingStatusUpdate");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Interrupts",
|
|
|
|
children, nicInterrupts, "Interrupts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Avoided Interrupts",
|
|
|
|
children, nicAvoidedInterrupts, "AvoidedInterrupts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "NIC Send Threshold Hit",
|
|
|
|
children, nicSendThresholdHit, "SendThresholdHit");
|
|
|
|
|
|
|
|
tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "rx", CTLFLAG_RD,
|
|
|
|
NULL, "BGE RX Statistics");
|
|
|
|
children = SYSCTL_CHILDREN(tree);
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Inbound Octets",
|
|
|
|
children, rxstats.ifHCInOctets, "Octets");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Fragments",
|
|
|
|
children, rxstats.etherStatsFragments, "Fragments");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Inbound Unicast Packets",
|
|
|
|
children, rxstats.ifHCInUcastPkts, "UcastPkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Inbound Multicast Packets",
|
|
|
|
children, rxstats.ifHCInMulticastPkts, "MulticastPkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "FCS Errors",
|
|
|
|
children, rxstats.dot3StatsFCSErrors, "FCSErrors");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Alignment Errors",
|
|
|
|
children, rxstats.dot3StatsAlignmentErrors, "AlignmentErrors");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "XON Pause Frames Received",
|
|
|
|
children, rxstats.xonPauseFramesReceived, "xonPauseFramesReceived");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "XOFF Pause Frames Received",
|
|
|
|
children, rxstats.xoffPauseFramesReceived,
|
|
|
|
"xoffPauseFramesReceived");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "MAC Control Frames Received",
|
|
|
|
children, rxstats.macControlFramesReceived,
|
|
|
|
"ControlFramesReceived");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "XOFF State Entered",
|
|
|
|
children, rxstats.xoffStateEntered, "xoffStateEntered");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Frames Too Long",
|
|
|
|
children, rxstats.dot3StatsFramesTooLong, "FramesTooLong");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Jabbers",
|
|
|
|
children, rxstats.etherStatsJabbers, "Jabbers");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Undersized Packets",
|
|
|
|
children, rxstats.etherStatsUndersizePkts, "UndersizePkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Inbound Range Length Errors",
|
2007-03-13 00:41:55 +00:00
|
|
|
children, rxstats.inRangeLengthError, "inRangeLengthError");
|
2007-03-12 09:25:57 +00:00
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Range Length Errors",
|
2007-03-13 00:41:55 +00:00
|
|
|
children, rxstats.outRangeLengthError, "outRangeLengthError");
|
2007-03-12 09:25:57 +00:00
|
|
|
|
|
|
|
tree = SYSCTL_ADD_NODE(ctx, schildren, OID_AUTO, "tx", CTLFLAG_RD,
|
|
|
|
NULL, "BGE TX Statistics");
|
|
|
|
children = SYSCTL_CHILDREN(tree);
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Octets",
|
|
|
|
children, txstats.ifHCOutOctets, "Octets");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "TX Collisions",
|
|
|
|
children, txstats.etherStatsCollisions, "Collisions");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "XON Sent",
|
|
|
|
children, txstats.outXonSent, "XonSent");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "XOFF Sent",
|
|
|
|
children, txstats.outXoffSent, "XoffSent");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Flow Control Done",
|
|
|
|
children, txstats.flowControlDone, "flowControlDone");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Internal MAC TX errors",
|
|
|
|
children, txstats.dot3StatsInternalMacTransmitErrors,
|
|
|
|
"InternalMacTransmitErrors");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Single Collision Frames",
|
|
|
|
children, txstats.dot3StatsSingleCollisionFrames,
|
|
|
|
"SingleCollisionFrames");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Multiple Collision Frames",
|
|
|
|
children, txstats.dot3StatsMultipleCollisionFrames,
|
|
|
|
"MultipleCollisionFrames");
|
2009-11-22 18:30:19 +00:00
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Deferred Transmissions",
|
2007-03-12 09:25:57 +00:00
|
|
|
children, txstats.dot3StatsDeferredTransmissions,
|
|
|
|
"DeferredTransmissions");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Excessive Collisions",
|
|
|
|
children, txstats.dot3StatsExcessiveCollisions,
|
|
|
|
"ExcessiveCollisions");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Late Collisions",
|
2007-03-13 00:41:55 +00:00
|
|
|
children, txstats.dot3StatsLateCollisions,
|
|
|
|
"LateCollisions");
|
2009-11-22 18:30:19 +00:00
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Unicast Packets",
|
2007-03-12 09:25:57 +00:00
|
|
|
children, txstats.ifHCOutUcastPkts, "UcastPkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Multicast Packets",
|
|
|
|
children, txstats.ifHCOutMulticastPkts, "MulticastPkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Broadcast Packets",
|
|
|
|
children, txstats.ifHCOutBroadcastPkts, "BroadcastPkts");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Carrier Sense Errors",
|
|
|
|
children, txstats.dot3StatsCarrierSenseErrors,
|
|
|
|
"CarrierSenseErrors");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Discards",
|
|
|
|
children, txstats.ifOutDiscards, "Discards");
|
|
|
|
BGE_SYSCTL_STAT(sc, ctx, "Outbound Errors",
|
|
|
|
children, txstats.ifOutErrors, "Errors");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_sysctl_stats(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
2007-03-13 00:41:55 +00:00
|
|
|
uint32_t result;
|
2007-11-16 16:39:27 +00:00
|
|
|
int offset;
|
2007-03-12 09:25:57 +00:00
|
|
|
|
|
|
|
sc = (struct bge_softc *)arg1;
|
|
|
|
offset = arg2;
|
2007-11-16 16:39:27 +00:00
|
|
|
result = CSR_READ_4(sc, BGE_MEMWIN_START + BGE_STATS_BLOCK + offset +
|
|
|
|
offsetof(bge_hostaddr, bge_addr_lo));
|
2007-06-04 18:25:08 +00:00
|
|
|
return (sysctl_handle_int(oidp, &result, 0, req));
|
2006-12-12 05:11:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef BGE_REGISTER_DEBUG
|
|
|
|
static int
|
|
|
|
bge_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
uint16_t *sbdata;
|
|
|
|
int error;
|
|
|
|
int result;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
result = -1;
|
|
|
|
error = sysctl_handle_int(oidp, &result, 0, req);
|
|
|
|
if (error || (req->newptr == NULL))
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (result == 1) {
|
|
|
|
sc = (struct bge_softc *)arg1;
|
|
|
|
|
|
|
|
sbdata = (uint16_t *)sc->bge_ldata.bge_status_block;
|
|
|
|
printf("Status Block:\n");
|
|
|
|
for (i = 0x0; i < (BGE_STATUS_BLK_SZ / 4); ) {
|
|
|
|
printf("%06x:", i);
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
|
|
printf(" %04x", sbdata[i]);
|
|
|
|
i += 4;
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Registers:\n");
|
2007-03-08 00:29:18 +00:00
|
|
|
for (i = 0x800; i < 0xA00; ) {
|
2006-12-12 05:11:12 +00:00
|
|
|
printf("%06x:", i);
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
|
|
printf(" %08x", CSR_READ_4(sc, i));
|
|
|
|
i += 4;
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Hardware Flags:\n");
|
2009-10-07 13:12:43 +00:00
|
|
|
if (BGE_IS_5755_PLUS(sc))
|
|
|
|
printf(" - 5755 Plus\n");
|
2006-12-13 21:03:55 +00:00
|
|
|
if (BGE_IS_575X_PLUS(sc))
|
2006-12-12 05:11:12 +00:00
|
|
|
printf(" - 575X Plus\n");
|
2006-12-13 21:03:55 +00:00
|
|
|
if (BGE_IS_5705_PLUS(sc))
|
2006-12-12 05:11:12 +00:00
|
|
|
printf(" - 5705 Plus\n");
|
2006-12-13 21:03:55 +00:00
|
|
|
if (BGE_IS_5714_FAMILY(sc))
|
|
|
|
printf(" - 5714 Family\n");
|
|
|
|
if (BGE_IS_5700_FAMILY(sc))
|
|
|
|
printf(" - 5700 Family\n");
|
2006-12-12 05:11:12 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_JUMBO)
|
|
|
|
printf(" - Supports Jumbo Frames\n");
|
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIX)
|
|
|
|
printf(" - PCI-X Bus\n");
|
|
|
|
if (sc->bge_flags & BGE_FLAG_PCIE)
|
|
|
|
printf(" - PCI Express Bus\n");
|
2007-01-15 21:43:43 +00:00
|
|
|
if (sc->bge_flags & BGE_FLAG_NO_3LED)
|
2006-12-12 05:11:12 +00:00
|
|
|
printf(" - No 3 LEDs\n");
|
|
|
|
if (sc->bge_flags & BGE_FLAG_RX_ALIGNBUG)
|
|
|
|
printf(" - RX Alignment Bug\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_sysctl_reg_read(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
int error;
|
|
|
|
uint16_t result;
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
result = -1;
|
|
|
|
error = sysctl_handle_int(oidp, &result, 0, req);
|
|
|
|
if (error || (req->newptr == NULL))
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (result < 0x8000) {
|
|
|
|
sc = (struct bge_softc *)arg1;
|
|
|
|
val = CSR_READ_4(sc, result);
|
|
|
|
printf("reg 0x%06X = 0x%08X\n", result, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_sysctl_mem_read(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct bge_softc *sc;
|
|
|
|
int error;
|
|
|
|
uint16_t result;
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
result = -1;
|
|
|
|
error = sysctl_handle_int(oidp, &result, 0, req);
|
|
|
|
if (error || (req->newptr == NULL))
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (result < 0x8000) {
|
|
|
|
sc = (struct bge_softc *)arg1;
|
|
|
|
val = bge_readmem_ind(sc, result);
|
|
|
|
printf("mem 0x%06X = 0x%08X\n", result, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
2008-04-29 19:47:13 +00:00
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
static int
|
|
|
|
bge_get_eaddr_fw(struct bge_softc *sc, uint8_t ether_addr[])
|
|
|
|
{
|
|
|
|
|
|
|
|
if (sc->bge_flags & BGE_FLAG_EADDR)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
#ifdef __sparc64__
|
|
|
|
OF_getetheraddr(sc->bge_dev, ether_addr);
|
|
|
|
return (0);
|
|
|
|
#endif
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2008-04-29 19:47:13 +00:00
|
|
|
static int
|
|
|
|
bge_get_eaddr_mem(struct bge_softc *sc, uint8_t ether_addr[])
|
|
|
|
{
|
|
|
|
uint32_t mac_addr;
|
|
|
|
|
|
|
|
mac_addr = bge_readmem_ind(sc, 0x0c14);
|
|
|
|
if ((mac_addr >> 16) == 0x484b) {
|
|
|
|
ether_addr[0] = (uint8_t)(mac_addr >> 8);
|
|
|
|
ether_addr[1] = (uint8_t)mac_addr;
|
|
|
|
mac_addr = bge_readmem_ind(sc, 0x0c18);
|
|
|
|
ether_addr[2] = (uint8_t)(mac_addr >> 24);
|
|
|
|
ether_addr[3] = (uint8_t)(mac_addr >> 16);
|
|
|
|
ether_addr[4] = (uint8_t)(mac_addr >> 8);
|
|
|
|
ether_addr[5] = (uint8_t)mac_addr;
|
2008-05-14 21:00:27 +00:00
|
|
|
return (0);
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
2008-05-14 21:00:27 +00:00
|
|
|
return (1);
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_get_eaddr_nvram(struct bge_softc *sc, uint8_t ether_addr[])
|
|
|
|
{
|
|
|
|
int mac_offset = BGE_EE_MAC_OFFSET;
|
|
|
|
|
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906)
|
|
|
|
mac_offset = BGE_EE_MAC_OFFSET_5906;
|
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
return (bge_read_nvram(sc, ether_addr, mac_offset + 2,
|
|
|
|
ETHER_ADDR_LEN));
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_get_eaddr_eeprom(struct bge_softc *sc, uint8_t ether_addr[])
|
|
|
|
{
|
|
|
|
|
2008-05-14 21:00:27 +00:00
|
|
|
if (sc->bge_asicrev == BGE_ASICREV_BCM5906)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
return (bge_read_eeprom(sc, ether_addr, BGE_EE_MAC_OFFSET + 2,
|
|
|
|
ETHER_ADDR_LEN));
|
2008-04-29 19:47:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
bge_get_eaddr(struct bge_softc *sc, uint8_t eaddr[])
|
|
|
|
{
|
|
|
|
static const bge_eaddr_fcn_t bge_eaddr_funcs[] = {
|
|
|
|
/* NOTE: Order is critical */
|
2008-05-14 21:00:27 +00:00
|
|
|
bge_get_eaddr_fw,
|
2008-04-29 19:47:13 +00:00
|
|
|
bge_get_eaddr_mem,
|
|
|
|
bge_get_eaddr_nvram,
|
|
|
|
bge_get_eaddr_eeprom,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
const bge_eaddr_fcn_t *func;
|
|
|
|
|
|
|
|
for (func = bge_eaddr_funcs; *func != NULL; ++func) {
|
|
|
|
if ((*func)(sc, eaddr) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (*func == NULL ? ENXIO : 0);
|
|
|
|
}
|