File Manager

003 File Manager

Current Path: /usr/src/sys/dev/sfxge/common

usr / src / sys / dev / sfxge / common /

📁 ..
📄 ef10_ev.c(38.47 KB)
📄 ef10_filter.c(48.25 KB)
📄 ef10_image.c(22.76 KB)
📄 ef10_impl.h(28.32 KB)
📄 ef10_intr.c(4.71 KB)
📄 ef10_mac.c(31.92 KB)
📄 ef10_mcdi.c(9.59 KB)
📄 ef10_nic.c(62.96 KB)
📄 ef10_nvram.c(54.36 KB)
📄 ef10_phy.c(20.26 KB)
📄 ef10_rx.c(30.8 KB)
📄 ef10_signed_image_layout.h(3.9 KB)
📄 ef10_tlv_layout.h(33.34 KB)
📄 ef10_tx.c(19.03 KB)
📄 ef10_vpd.c(11.03 KB)
📄 efsys.h(31.95 KB)
📄 efx.h(82.48 KB)
📄 efx_annote.h(4.06 KB)
📄 efx_bootcfg.c(25.55 KB)
📄 efx_check.h(11.67 KB)
📄 efx_crc32.c(5.45 KB)
📄 efx_ev.c(34.49 KB)
📄 efx_filter.c(39.47 KB)
📄 efx_hash.c(8.08 KB)
📄 efx_impl.h(38.52 KB)
📄 efx_intr.c(14.56 KB)
📄 efx_lic.c(37.43 KB)
📄 efx_mac.c(22.27 KB)
📄 efx_mcdi.c(58.17 KB)
📄 efx_mcdi.h(13.28 KB)
📄 efx_mon.c(23.85 KB)
📄 efx_nic.c(28.89 KB)
📄 efx_nvram.c(24.9 KB)
📄 efx_phy.c(13.44 KB)
📄 efx_phy_ids.h(2.04 KB)
📄 efx_port.c(5.99 KB)
📄 efx_regs.h(118.32 KB)
📄 efx_regs_ef10.h(21.93 KB)
📄 efx_regs_mcdi.h(769.41 KB)
📄 efx_regs_mcdi_aoe.h(125.41 KB)
📄 efx_regs_mcdi_strs.h(8.54 KB)
📄 efx_regs_pci.h(55.57 KB)
📄 efx_rx.c(39.55 KB)
📄 efx_sram.c(8.76 KB)
📄 efx_tunnel.c(11.69 KB)
📄 efx_tx.c(27.1 KB)
📄 efx_types.h(57.59 KB)
📄 efx_vpd.c(20.8 KB)
📄 hunt_impl.h(2.36 KB)
📄 hunt_nic.c(7.76 KB)
📄 mcdi_mon.c(16.08 KB)
📄 mcdi_mon.h(2.47 KB)
📄 medford2_impl.h(2.1 KB)
📄 medford2_nic.c(5.53 KB)
📄 medford_impl.h(2.04 KB)
📄 medford_nic.c(5.39 KB)
📄 siena_flash.h(9.02 KB)
📄 siena_impl.h(10.2 KB)
📄 siena_mac.c(15.58 KB)
📄 siena_mcdi.c(6.87 KB)
📄 siena_nic.c(20.68 KB)
📄 siena_nvram.c(17.89 KB)
📄 siena_phy.c(22.34 KB)
📄 siena_sram.c(5.46 KB)
📄 siena_vpd.c(14.54 KB)

Editing: efx_tunnel.c

/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2017-2018 Solarflare Communications Inc.
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of the FreeBSD Project.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "efx.h"
#include "efx_impl.h"

#if EFSYS_OPT_TUNNEL

#if EFSYS_OPT_SIENA || EFSYS_OPT_HUNTINGTON
static const efx_tunnel_ops_t	__efx_tunnel_dummy_ops = {
	NULL,	/* eto_udp_encap_supported */
	NULL,	/* eto_reconfigure */
};
#endif /* EFSYS_OPT_SIENA || EFSYS_OPT_HUNTINGTON */

#if EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
static	__checkReturn	boolean_t
ef10_udp_encap_supported(
	__in		efx_nic_t *enp);

static	__checkReturn	efx_rc_t
ef10_tunnel_reconfigure(
	__in		efx_nic_t *enp);

static const efx_tunnel_ops_t	__efx_tunnel_ef10_ops = {
	ef10_udp_encap_supported,	/* eto_udp_encap_supported */
	ef10_tunnel_reconfigure,	/* eto_reconfigure */
};
#endif /* EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */

static	__checkReturn		efx_rc_t
efx_mcdi_set_tunnel_encap_udp_ports(
	__in			efx_nic_t *enp,
	__in			efx_tunnel_cfg_t *etcp,
	__in			boolean_t unloading,
	__out			boolean_t *resetting)
{
	efx_mcdi_req_t req;
	EFX_MCDI_DECLARE_BUF(payload,
		MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LENMAX,
		MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN);
	efx_word_t flags;
	efx_rc_t rc;
	unsigned int i;
	unsigned int entries_num;

if (etcp == NULL)
		entries_num = 0;
	else
		entries_num = etcp->etc_udp_entries_num;

req.emr_cmd = MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS;
	req.emr_in_buf = payload;
	req.emr_in_length =
	    MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LEN(entries_num);
	req.emr_out_buf = payload;
	req.emr_out_length = MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN;

EFX_POPULATE_WORD_1(flags,
	    MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_UNLOADING,
	    (unloading == B_TRUE) ? 1 : 0);
	MCDI_IN_SET_WORD(req, SET_TUNNEL_ENCAP_UDP_PORTS_IN_FLAGS,
	    EFX_WORD_FIELD(flags, EFX_WORD_0));

MCDI_IN_SET_WORD(req, SET_TUNNEL_ENCAP_UDP_PORTS_IN_NUM_ENTRIES,
	    entries_num);

for (i = 0; i < entries_num; ++i) {
		uint16_t mcdi_udp_protocol;

switch (etcp->etc_udp_entries[i].etue_protocol) {
		case EFX_TUNNEL_PROTOCOL_VXLAN:
			mcdi_udp_protocol = TUNNEL_ENCAP_UDP_PORT_ENTRY_VXLAN;
			break;
		case EFX_TUNNEL_PROTOCOL_GENEVE:
			mcdi_udp_protocol = TUNNEL_ENCAP_UDP_PORT_ENTRY_GENEVE;
			break;
		default:
			rc = EINVAL;
			goto fail1;
		}

/*
		 * UDP port is MCDI native little-endian in the request
		 * and EFX_POPULATE_DWORD cares about conversion from
		 * host/CPU byte order to little-endian.
		 */
		EFX_STATIC_ASSERT(sizeof (efx_dword_t) ==
		    TUNNEL_ENCAP_UDP_PORT_ENTRY_LEN);
		EFX_POPULATE_DWORD_2(
		    MCDI_IN2(req, efx_dword_t,
			SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES)[i],
		    TUNNEL_ENCAP_UDP_PORT_ENTRY_UDP_PORT,
		    etcp->etc_udp_entries[i].etue_port,
		    TUNNEL_ENCAP_UDP_PORT_ENTRY_PROTOCOL,
		    mcdi_udp_protocol);
	}

efx_mcdi_execute(enp, &req);

if (req.emr_rc != 0) {
		rc = req.emr_rc;
		goto fail2;
	}

if (req.emr_out_length_used !=
	    MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN) {
		rc = EMSGSIZE;
		goto fail3;
	}

*resetting = MCDI_OUT_WORD_FIELD(req,
	    SET_TUNNEL_ENCAP_UDP_PORTS_OUT_FLAGS,
	    SET_TUNNEL_ENCAP_UDP_PORTS_OUT_RESETTING);

return (0);

fail3:
	EFSYS_PROBE(fail3);

fail2:
	EFSYS_PROBE(fail2);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);

return (rc);
}

__checkReturn	efx_rc_t
efx_tunnel_init(
	__in		efx_nic_t *enp)
{
	efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
	const efx_tunnel_ops_t *etop;
	efx_rc_t rc;

EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
	EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_TUNNEL));

EFX_STATIC_ASSERT(EFX_TUNNEL_MAXNENTRIES ==
	    MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES_MAXNUM);

switch (enp->en_family) {
#if EFSYS_OPT_SIENA
	case EFX_FAMILY_SIENA:
		etop = &__efx_tunnel_dummy_ops;
		break;
#endif /* EFSYS_OPT_SIENA */

#if EFSYS_OPT_HUNTINGTON
	case EFX_FAMILY_HUNTINGTON:
		etop = &__efx_tunnel_dummy_ops;
		break;
#endif /* EFSYS_OPT_HUNTINGTON */

#if EFSYS_OPT_MEDFORD
	case EFX_FAMILY_MEDFORD:
		etop = &__efx_tunnel_ef10_ops;
		break;
#endif /* EFSYS_OPT_MEDFORD */

#if EFSYS_OPT_MEDFORD2
	case EFX_FAMILY_MEDFORD2:
		etop = &__efx_tunnel_ef10_ops;
		break;
#endif /* EFSYS_OPT_MEDFORD2 */

default:
		EFSYS_ASSERT(0);
		rc = ENOTSUP;
		goto fail1;
	}

memset(etcp->etc_udp_entries, 0, sizeof (etcp->etc_udp_entries));
	etcp->etc_udp_entries_num = 0;

enp->en_etop = etop;
	enp->en_mod_flags |= EFX_MOD_TUNNEL;

return (0);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);

enp->en_etop = NULL;
	enp->en_mod_flags &= ~EFX_MOD_TUNNEL;

return (rc);
}

void
efx_tunnel_fini(
	__in		efx_nic_t *enp)
{
	boolean_t resetting;

EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
	EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);

if ((enp->en_etop->eto_udp_encap_supported != NULL) &&
	    enp->en_etop->eto_udp_encap_supported(enp)) {
		/*
		 * The UNLOADING flag allows the MC to suppress the datapath
		 * reset if it was set on the last call to
		 * MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS by all functions
		 */
		(void) efx_mcdi_set_tunnel_encap_udp_ports(enp, NULL, B_TRUE,
		    &resetting);
	}

enp->en_etop = NULL;
	enp->en_mod_flags &= ~EFX_MOD_TUNNEL;
}

static	__checkReturn	efx_rc_t
efx_tunnel_config_find_udp_tunnel_entry(
	__in		efx_tunnel_cfg_t *etcp,
	__in		uint16_t port,
	__out		unsigned int *entryp)
{
	unsigned int i;

for (i = 0; i < etcp->etc_udp_entries_num; ++i) {
		efx_tunnel_udp_entry_t *p = &etcp->etc_udp_entries[i];

if (p->etue_port == port) {
			*entryp = i;
			return (0);
		}
	}

return (ENOENT);
}

__checkReturn	efx_rc_t
efx_tunnel_config_udp_add(
	__in		efx_nic_t *enp,
	__in		uint16_t port /* host/cpu-endian */,
	__in		efx_tunnel_protocol_t protocol)
{
	const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
	efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
	efsys_lock_state_t state;
	efx_rc_t rc;
	unsigned int entry;

EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);

if (protocol >= EFX_TUNNEL_NPROTOS) {
		rc = EINVAL;
		goto fail1;
	}

if ((encp->enc_tunnel_encapsulations_supported &
	    (1u << protocol)) == 0) {
		rc = ENOTSUP;
		goto fail2;
	}

EFSYS_LOCK(enp->en_eslp, state);

rc = efx_tunnel_config_find_udp_tunnel_entry(etcp, port, &entry);
	if (rc == 0) {
		rc = EEXIST;
		goto fail3;
	}

if (etcp->etc_udp_entries_num ==
	    encp->enc_tunnel_config_udp_entries_max) {
		rc = ENOSPC;
		goto fail4;
	}

etcp->etc_udp_entries[etcp->etc_udp_entries_num].etue_port = port;
	etcp->etc_udp_entries[etcp->etc_udp_entries_num].etue_protocol =
	    protocol;

etcp->etc_udp_entries_num++;

EFSYS_UNLOCK(enp->en_eslp, state);

return (0);

fail4:
	EFSYS_PROBE(fail4);

fail3:
	EFSYS_PROBE(fail3);
	EFSYS_UNLOCK(enp->en_eslp, state);

fail2:
	EFSYS_PROBE(fail2);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);

return (rc);
}

__checkReturn	efx_rc_t
efx_tunnel_config_udp_remove(
	__in		efx_nic_t *enp,
	__in		uint16_t port /* host/cpu-endian */,
	__in		efx_tunnel_protocol_t protocol)
{
	efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
	efsys_lock_state_t state;
	unsigned int entry;
	efx_rc_t rc;

EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);

EFSYS_LOCK(enp->en_eslp, state);

rc = efx_tunnel_config_find_udp_tunnel_entry(etcp, port, &entry);
	if (rc != 0)
		goto fail1;

if (etcp->etc_udp_entries[entry].etue_protocol != protocol) {
		rc = EINVAL;
		goto fail2;
	}

EFSYS_ASSERT3U(etcp->etc_udp_entries_num, >, 0);
	etcp->etc_udp_entries_num--;

if (entry < etcp->etc_udp_entries_num) {
		memmove(&etcp->etc_udp_entries[entry],
		    &etcp->etc_udp_entries[entry + 1],
		    (etcp->etc_udp_entries_num - entry) *
		    sizeof (etcp->etc_udp_entries[0]));
	}

memset(&etcp->etc_udp_entries[etcp->etc_udp_entries_num], 0,
	    sizeof (etcp->etc_udp_entries[0]));

EFSYS_UNLOCK(enp->en_eslp, state);

return (0);

fail2:
	EFSYS_PROBE(fail2);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);
	EFSYS_UNLOCK(enp->en_eslp, state);

return (rc);
}

void
efx_tunnel_config_clear(
	__in			efx_nic_t *enp)
{
	efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
	efsys_lock_state_t state;

EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);

EFSYS_LOCK(enp->en_eslp, state);

etcp->etc_udp_entries_num = 0;
	memset(etcp->etc_udp_entries, 0, sizeof (etcp->etc_udp_entries));

EFSYS_UNLOCK(enp->en_eslp, state);
}

__checkReturn	efx_rc_t
efx_tunnel_reconfigure(
	__in		efx_nic_t *enp)
{
	const efx_tunnel_ops_t *etop = enp->en_etop;
	efx_rc_t rc;

EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);

if (etop->eto_reconfigure == NULL) {
		rc = ENOTSUP;
		goto fail1;
	}

if ((rc = enp->en_etop->eto_reconfigure(enp)) != 0)
		goto fail2;

return (0);

fail2:
	EFSYS_PROBE(fail2);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);

return (rc);
}

#if EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
static	__checkReturn		boolean_t
ef10_udp_encap_supported(
	__in		efx_nic_t *enp)
{
	const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
	uint32_t udp_tunnels_mask = 0;

udp_tunnels_mask |= (1u << EFX_TUNNEL_PROTOCOL_VXLAN);
	udp_tunnels_mask |= (1u << EFX_TUNNEL_PROTOCOL_GENEVE);

return ((encp->enc_tunnel_encapsulations_supported &
	    udp_tunnels_mask) == 0 ? B_FALSE : B_TRUE);
}

static	__checkReturn	efx_rc_t
ef10_tunnel_reconfigure(
	__in		efx_nic_t *enp)
{
	efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
	efx_rc_t rc;
	boolean_t resetting;
	efsys_lock_state_t state;
	efx_tunnel_cfg_t etc;

EFSYS_LOCK(enp->en_eslp, state);
	memcpy(&etc, etcp, sizeof (etc));
	EFSYS_UNLOCK(enp->en_eslp, state);

if (ef10_udp_encap_supported(enp) == B_FALSE) {
		/*
		 * It is OK to apply empty UDP tunnel ports when UDP
		 * tunnel encapsulations are not supported - just nothing
		 * should be done.
		 */
		if (etc.etc_udp_entries_num == 0)
			return (0);
		rc = ENOTSUP;
		goto fail1;
	} else {
		/*
		 * All PCI functions can see a reset upon the
		 * MCDI request completion
		 */
		rc = efx_mcdi_set_tunnel_encap_udp_ports(enp, &etc, B_FALSE,
		    &resetting);
		if (rc != 0)
			goto fail2;

/*
		 * Although the caller should be able to handle MC reboot,
		 * it might come in handy to report the impending reboot
		 * by returning EAGAIN
		 */
		return ((resetting) ? EAGAIN : 0);
	}
fail2:
	EFSYS_PROBE(fail2);

fail1:
	EFSYS_PROBE1(fail1, efx_rc_t, rc);

return (rc);
}
#endif /* EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */

#endif /* EFSYS_OPT_TUNNEL */

003 File Manager

Editing: efx_tunnel.c

Upload File

Create Folder