Author: arybchik
Date: Thu Jan 14 16:07:29 2016
New Revision: 293996
URL: https://svnweb.freebsd.org/changeset/base/293996
Log:
MFC r293764
sfxge: rename hunt filter methods, types etc. to ef10 and use for Medford
New filters types may be added, but the same machinery should be able to
handle them.
Submitted by: Mark Spender <mspender at solarflare.com>
Reviewed by: gnn
Sponsored by: Solarflare Communications, Inc.
Modified:
stable/10/sys/dev/sfxge/common/efx_filter.c
stable/10/sys/dev/sfxge/common/efx_impl.h
stable/10/sys/dev/sfxge/common/hunt_filter.c
stable/10/sys/dev/sfxge/common/hunt_impl.h
stable/10/sys/dev/sfxge/common/hunt_mac.c
Directory Properties:
stable/10/ (props changed)
Modified: stable/10/sys/dev/sfxge/common/efx_filter.c
==============================================================================
--- stable/10/sys/dev/sfxge/common/efx_filter.c Thu Jan 14 16:06:51 2016
(r293995)
+++ stable/10/sys/dev/sfxge/common/efx_filter.c Thu Jan 14 16:07:29 2016
(r293996)
@@ -97,17 +97,17 @@ static efx_filter_ops_t __efx_filter_sie
};
#endif /* EFSYS_OPT_SIENA */
-#if EFSYS_OPT_HUNTINGTON
-static efx_filter_ops_t __efx_filter_hunt_ops = {
- hunt_filter_init, /* efo_init */
- hunt_filter_fini, /* efo_fini */
- hunt_filter_restore, /* efo_restore */
- hunt_filter_add, /* efo_add */
- hunt_filter_delete, /* efo_delete */
- hunt_filter_supported_filters, /* efo_supported_filters */
- hunt_filter_reconfigure, /* efo_reconfigure */
+#if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
+static efx_filter_ops_t __efx_filter_ef10_ops = {
+ ef10_filter_init, /* efo_init */
+ ef10_filter_fini, /* efo_fini */
+ ef10_filter_restore, /* efo_restore */
+ ef10_filter_add, /* efo_add */
+ ef10_filter_delete, /* efo_delete */
+ ef10_filter_supported_filters, /* efo_supported_filters */
+ ef10_filter_reconfigure, /* efo_reconfigure */
};
-#endif /* EFSYS_OPT_HUNTINGTON */
+#endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */
__checkReturn efx_rc_t
efx_filter_insert(
@@ -189,10 +189,16 @@ efx_filter_init(
#if EFSYS_OPT_HUNTINGTON
case EFX_FAMILY_HUNTINGTON:
- efop = (efx_filter_ops_t *)&__efx_filter_hunt_ops;
+ efop = (efx_filter_ops_t *)&__efx_filter_ef10_ops;
break;
#endif /* EFSYS_OPT_HUNTINGTON */
+#if EFSYS_OPT_MEDFORD
+ case EFX_FAMILY_MEDFORD:
+ efop = (efx_filter_ops_t *)&__efx_filter_ef10_ops;
+ break;
+#endif /* EFSYS_OPT_MEDFORD */
+
default:
EFSYS_ASSERT(0);
rc = ENOTSUP;
Modified: stable/10/sys/dev/sfxge/common/efx_impl.h
==============================================================================
--- stable/10/sys/dev/sfxge/common/efx_impl.h Thu Jan 14 16:06:51 2016
(r293995)
+++ stable/10/sys/dev/sfxge/common/efx_impl.h Thu Jan 14 16:07:29 2016
(r293996)
@@ -436,9 +436,9 @@ typedef struct efx_filter_s {
#if EFSYS_OPT_FALCON || EFSYS_OPT_SIENA
falconsiena_filter_t *ef_falconsiena_filter;
#endif /* EFSYS_OPT_FALCON || EFSYS_OPT_SIENA */
-#if EFSYS_OPT_HUNTINGTON
- hunt_filter_table_t *ef_hunt_filter_table;
-#endif /* EFSYS_OPT_HUNTINGTON */
+#if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
+ ef10_filter_table_t *ef_ef10_filter_table;
+#endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */
} efx_filter_t;
extern void
Modified: stable/10/sys/dev/sfxge/common/hunt_filter.c
==============================================================================
--- stable/10/sys/dev/sfxge/common/hunt_filter.c Thu Jan 14 16:06:51
2016 (r293995)
+++ stable/10/sys/dev/sfxge/common/hunt_filter.c Thu Jan 14 16:07:29
2016 (r293996)
@@ -41,90 +41,91 @@ __FBSDID("$FreeBSD$");
#if EFSYS_OPT_FILTER
-#define HFE_SPEC(hftp, index) ((hftp)->hft_entry[(index)].hfe_spec)
+#define EFE_SPEC(eftp, index) ((eftp)->eft_entry[(index)].efe_spec)
static efx_filter_spec_t *
-hunt_filter_entry_spec(
- __in const hunt_filter_table_t *hftp,
+ef10_filter_entry_spec(
+ __in const ef10_filter_table_t *eftp,
__in unsigned int index)
{
- return ((efx_filter_spec_t *)(HFE_SPEC(hftp, index) &
- ~(uintptr_t)EFX_HUNT_FILTER_FLAGS));
+ return ((efx_filter_spec_t *)(EFE_SPEC(eftp, index) &
+ ~(uintptr_t)EFX_EF10_FILTER_FLAGS));
}
static boolean_t
-hunt_filter_entry_is_busy(
- __in const hunt_filter_table_t *hftp,
+ef10_filter_entry_is_busy(
+ __in const ef10_filter_table_t *eftp,
__in unsigned int index)
{
- if (HFE_SPEC(hftp, index) & EFX_HUNT_FILTER_FLAG_BUSY)
+ if (EFE_SPEC(eftp, index) & EFX_EF10_FILTER_FLAG_BUSY)
return (B_TRUE);
else
return (B_FALSE);
}
static boolean_t
-hunt_filter_entry_is_auto_old(
- __in const hunt_filter_table_t *hftp,
+ef10_filter_entry_is_auto_old(
+ __in const ef10_filter_table_t *eftp,
__in unsigned int index)
{
- if (HFE_SPEC(hftp, index) & EFX_HUNT_FILTER_FLAG_AUTO_OLD)
+ if (EFE_SPEC(eftp, index) & EFX_EF10_FILTER_FLAG_AUTO_OLD)
return (B_TRUE);
else
return (B_FALSE);
}
static void
-hunt_filter_set_entry(
- __inout hunt_filter_table_t *hftp,
+ef10_filter_set_entry(
+ __inout ef10_filter_table_t *eftp,
__in unsigned int index,
__in_opt const efx_filter_spec_t *efsp)
{
- HFE_SPEC(hftp, index) = (uintptr_t)efsp;
+ EFE_SPEC(eftp, index) = (uintptr_t)efsp;
}
static void
-hunt_filter_set_entry_busy(
- __inout hunt_filter_table_t *hftp,
+ef10_filter_set_entry_busy(
+ __inout ef10_filter_table_t *eftp,
__in unsigned int index)
{
- HFE_SPEC(hftp, index) |= (uintptr_t)EFX_HUNT_FILTER_FLAG_BUSY;
+ EFE_SPEC(eftp, index) |= (uintptr_t)EFX_EF10_FILTER_FLAG_BUSY;
}
static void
-hunt_filter_set_entry_not_busy(
- __inout hunt_filter_table_t *hftp,
+ef10_filter_set_entry_not_busy(
+ __inout ef10_filter_table_t *eftp,
__in unsigned int index)
{
- HFE_SPEC(hftp, index) &= ~(uintptr_t)EFX_HUNT_FILTER_FLAG_BUSY;
+ EFE_SPEC(eftp, index) &= ~(uintptr_t)EFX_EF10_FILTER_FLAG_BUSY;
}
static void
-hunt_filter_set_entry_auto_old(
- __inout hunt_filter_table_t *hftp,
+ef10_filter_set_entry_auto_old(
+ __inout ef10_filter_table_t *eftp,
__in unsigned int index)
{
- EFSYS_ASSERT(hunt_filter_entry_spec(hftp, index) != NULL);
- HFE_SPEC(hftp, index) |= (uintptr_t)EFX_HUNT_FILTER_FLAG_AUTO_OLD;
+ EFSYS_ASSERT(ef10_filter_entry_spec(eftp, index) != NULL);
+ EFE_SPEC(eftp, index) |= (uintptr_t)EFX_EF10_FILTER_FLAG_AUTO_OLD;
}
static void
-hunt_filter_set_entry_not_auto_old(
- __inout hunt_filter_table_t *hftp,
+ef10_filter_set_entry_not_auto_old(
+ __inout ef10_filter_table_t *eftp,
__in unsigned int index)
{
- HFE_SPEC(hftp, index) &= ~(uintptr_t)EFX_HUNT_FILTER_FLAG_AUTO_OLD;
- EFSYS_ASSERT(hunt_filter_entry_spec(hftp, index) != NULL);
+ EFE_SPEC(eftp, index) &= ~(uintptr_t)EFX_EF10_FILTER_FLAG_AUTO_OLD;
+ EFSYS_ASSERT(ef10_filter_entry_spec(eftp, index) != NULL);
}
__checkReturn efx_rc_t
-hunt_filter_init(
+ef10_filter_init(
__in efx_nic_t *enp)
{
efx_rc_t rc;
- hunt_filter_table_t *hftp;
+ ef10_filter_table_t *eftp;
- EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
+ EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
+ enp->en_family == EFX_FAMILY_MEDFORD);
#define MATCH_MASK(match) (EFX_MASK32(match) << EFX_LOW_BIT(match))
EFX_STATIC_ASSERT(EFX_FILTER_MATCH_REM_HOST ==
@@ -149,14 +150,14 @@ hunt_filter_init(
MATCH_MASK(MC_CMD_FILTER_OP_IN_MATCH_IP_PROTO));
#undef MATCH_MASK
- EFSYS_KMEM_ALLOC(enp->en_esip, sizeof (hunt_filter_table_t), hftp);
+ EFSYS_KMEM_ALLOC(enp->en_esip, sizeof (ef10_filter_table_t), eftp);
- if (!hftp) {
+ if (!eftp) {
rc = ENOMEM;
goto fail1;
}
- enp->en_filter.ef_hunt_filter_table = hftp;
+ enp->en_filter.ef_ef10_filter_table = eftp;
return (0);
@@ -167,14 +168,15 @@ fail1:
}
void
-hunt_filter_fini(
+ef10_filter_fini(
__in efx_nic_t *enp)
{
- EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
+ EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
+ enp->en_family == EFX_FAMILY_MEDFORD);
- if (enp->en_filter.ef_hunt_filter_table != NULL) {
- EFSYS_KMEM_FREE(enp->en_esip, sizeof (hunt_filter_table_t),
- enp->en_filter.ef_hunt_filter_table);
+ if (enp->en_filter.ef_ef10_filter_table != NULL) {
+ EFSYS_KMEM_FREE(enp->en_esip, sizeof (ef10_filter_table_t),
+ enp->en_filter.ef_ef10_filter_table);
}
}
@@ -183,7 +185,7 @@ efx_mcdi_filter_op_add(
__in efx_nic_t *enp,
__in efx_filter_spec_t *spec,
__in unsigned int filter_op,
- __inout hunt_filter_handle_t *handle)
+ __inout ef10_filter_handle_t *handle)
{
efx_mcdi_req_t req;
uint8_t payload[MAX(MC_CMD_FILTER_OP_IN_LEN,
@@ -201,9 +203,9 @@ efx_mcdi_filter_op_add(
switch (filter_op) {
case MC_CMD_FILTER_OP_IN_OP_REPLACE:
MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_LO,
- handle->hfh_lo);
+ handle->efh_lo);
MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_HI,
- handle->hfh_hi);
+ handle->efh_hi);
/* Fall through */
case MC_CMD_FILTER_OP_IN_OP_INSERT:
case MC_CMD_FILTER_OP_IN_OP_SUBSCRIBE:
@@ -302,8 +304,8 @@ efx_mcdi_filter_op_add(
goto fail3;
}
- handle->hfh_lo = MCDI_OUT_DWORD(req, FILTER_OP_OUT_HANDLE_LO);
- handle->hfh_hi = MCDI_OUT_DWORD(req, FILTER_OP_OUT_HANDLE_HI);
+ handle->efh_lo = MCDI_OUT_DWORD(req, FILTER_OP_OUT_HANDLE_LO);
+ handle->efh_hi = MCDI_OUT_DWORD(req, FILTER_OP_OUT_HANDLE_HI);
return (0);
@@ -322,7 +324,7 @@ static __checkReturn efx_rc_t
efx_mcdi_filter_op_delete(
__in efx_nic_t *enp,
__in unsigned int filter_op,
- __inout hunt_filter_handle_t *handle)
+ __inout ef10_filter_handle_t *handle)
{
efx_mcdi_req_t req;
uint8_t payload[MAX(MC_CMD_FILTER_OP_IN_LEN,
@@ -351,8 +353,8 @@ efx_mcdi_filter_op_delete(
goto fail1;
}
- MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_LO, handle->hfh_lo);
- MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_HI, handle->hfh_hi);
+ MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_LO, handle->efh_lo);
+ MCDI_IN_SET_DWORD(req, FILTER_OP_IN_HANDLE_HI, handle->efh_hi);
efx_mcdi_execute(enp, &req);
@@ -380,7 +382,7 @@ fail1:
}
static __checkReturn boolean_t
-hunt_filter_equal(
+ef10_filter_equal(
__in const efx_filter_spec_t *left,
__in const efx_filter_spec_t *right)
{
@@ -413,7 +415,7 @@ hunt_filter_equal(
}
static __checkReturn boolean_t
-hunt_filter_same_dest(
+ef10_filter_same_dest(
__in const efx_filter_spec_t *left,
__in const efx_filter_spec_t *right)
{
@@ -430,7 +432,7 @@ hunt_filter_same_dest(
}
static __checkReturn uint32_t
-hunt_filter_hash(
+ef10_filter_hash(
__in efx_filter_spec_t *spec)
{
EFX_STATIC_ASSERT((sizeof (efx_filter_spec_t) % sizeof (uint32_t))
@@ -456,7 +458,7 @@ hunt_filter_hash(
* exclusive.
*/
static __checkReturn boolean_t
-hunt_filter_is_exclusive(
+ef10_filter_is_exclusive(
__in efx_filter_spec_t *spec)
{
if ((spec->efs_match_flags & EFX_FILTER_MATCH_LOC_MAC) &&
@@ -478,30 +480,31 @@ hunt_filter_is_exclusive(
}
__checkReturn efx_rc_t
-hunt_filter_restore(
+ef10_filter_restore(
__in efx_nic_t *enp)
{
int tbl_id;
efx_filter_spec_t *spec;
- hunt_filter_table_t *hftp = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *eftp = enp->en_filter.ef_ef10_filter_table;
boolean_t restoring;
int state;
efx_rc_t rc;
- EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
+ EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
+ enp->en_family == EFX_FAMILY_MEDFORD);
- for (tbl_id = 0; tbl_id < EFX_HUNT_FILTER_TBL_ROWS; tbl_id++) {
+ for (tbl_id = 0; tbl_id < EFX_EF10_FILTER_TBL_ROWS; tbl_id++) {
EFSYS_LOCK(enp->en_eslp, state);
- spec = hunt_filter_entry_spec(hftp, tbl_id);
+ spec = ef10_filter_entry_spec(eftp, tbl_id);
if (spec == NULL) {
restoring = B_FALSE;
- } else if (hunt_filter_entry_is_busy(hftp, tbl_id)) {
+ } else if (ef10_filter_entry_is_busy(eftp, tbl_id)) {
/* Ignore busy entries. */
restoring = B_FALSE;
} else {
- hunt_filter_set_entry_busy(hftp, tbl_id);
+ ef10_filter_set_entry_busy(eftp, tbl_id);
restoring = B_TRUE;
}
@@ -510,14 +513,14 @@ hunt_filter_restore(
if (restoring == B_FALSE)
continue;
- if (hunt_filter_is_exclusive(spec)) {
+ if (ef10_filter_is_exclusive(spec)) {
rc = efx_mcdi_filter_op_add(enp, spec,
MC_CMD_FILTER_OP_IN_OP_INSERT,
- &hftp->hft_entry[tbl_id].hfe_handle);
+ &eftp->eft_entry[tbl_id].efe_handle);
} else {
rc = efx_mcdi_filter_op_add(enp, spec,
MC_CMD_FILTER_OP_IN_OP_SUBSCRIBE,
- &hftp->hft_entry[tbl_id].hfe_handle);
+ &eftp->eft_entry[tbl_id].efe_handle);
}
if (rc != 0)
@@ -525,7 +528,7 @@ hunt_filter_restore(
EFSYS_LOCK(enp->en_eslp, state);
- hunt_filter_set_entry_not_busy(hftp, tbl_id);
+ ef10_filter_set_entry_not_busy(eftp, tbl_id);
EFSYS_UNLOCK(enp->en_eslp, state);
}
@@ -542,17 +545,17 @@ fail1:
* An arbitrary search limit for the software hash table. As per the linux net
* driver.
*/
-#define EFX_HUNT_FILTER_SEARCH_LIMIT 200
+#define EF10_FILTER_SEARCH_LIMIT 200
static __checkReturn efx_rc_t
-hunt_filter_add_internal(
+ef10_filter_add_internal(
__in efx_nic_t *enp,
__inout efx_filter_spec_t *spec,
__in boolean_t may_replace,
__out_opt uint32_t *filter_id)
{
efx_rc_t rc;
- hunt_filter_table_t *hftp = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *eftp = enp->en_filter.ef_ef10_filter_table;
efx_filter_spec_t *saved_spec;
uint32_t hash;
unsigned int depth;
@@ -562,13 +565,14 @@ hunt_filter_add_internal(
int state;
boolean_t locked = B_FALSE;
- EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
+ EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
+ enp->en_family == EFX_FAMILY_MEDFORD);
#if EFSYS_OPT_RX_SCALE
spec->efs_rss_context = enp->en_rss_context;
#endif
- hash = hunt_filter_hash(spec);
+ hash = ef10_filter_hash(spec);
/*
* FIXME: Add support for inserting filters of different priorities
@@ -587,21 +591,21 @@ hunt_filter_add_internal(
locked = B_TRUE;
for (;;) {
- i = (hash + depth) & (EFX_HUNT_FILTER_TBL_ROWS - 1);
- saved_spec = hunt_filter_entry_spec(hftp, i);
+ i = (hash + depth) & (EFX_EF10_FILTER_TBL_ROWS - 1);
+ saved_spec = ef10_filter_entry_spec(eftp, i);
if (!saved_spec) {
if (ins_index < 0) {
ins_index = i;
}
- } else if (hunt_filter_equal(spec, saved_spec)) {
- if (hunt_filter_entry_is_busy(hftp, i))
+ } else if (ef10_filter_equal(spec, saved_spec)) {
+ if (ef10_filter_entry_is_busy(eftp, i))
break;
if (saved_spec->efs_priority
== EFX_FILTER_PRI_AUTO) {
ins_index = i;
goto found;
- } else if (hunt_filter_is_exclusive(spec)) {
+ } else if (ef10_filter_is_exclusive(spec)) {
if (may_replace) {
ins_index = i;
goto found;
@@ -619,7 +623,7 @@ hunt_filter_add_internal(
* the first suitable slot or return EBUSY if
* there was none.
*/
- if (depth == EFX_HUNT_FILTER_SEARCH_LIMIT) {
+ if (depth == EF10_FILTER_SEARCH_LIMIT) {
if (ins_index < 0) {
rc = EBUSY;
goto fail2;
@@ -639,11 +643,11 @@ found:
* insert a conflicting filter while we're waiting for the
* firmware must find the busy entry.
*/
- saved_spec = hunt_filter_entry_spec(hftp, ins_index);
+ saved_spec = ef10_filter_entry_spec(eftp, ins_index);
if (saved_spec) {
if (saved_spec->efs_priority == EFX_FILTER_PRI_AUTO) {
/* This is a filter we are refreshing */
- hunt_filter_set_entry_not_auto_old(hftp, ins_index);
+ ef10_filter_set_entry_not_auto_old(eftp, ins_index);
goto out_unlock;
}
@@ -655,9 +659,9 @@ found:
goto fail3;
}
*saved_spec = *spec;
- hunt_filter_set_entry(hftp, ins_index, saved_spec);
+ ef10_filter_set_entry(eftp, ins_index, saved_spec);
}
- hunt_filter_set_entry_busy(hftp, ins_index);
+ ef10_filter_set_entry_busy(eftp, ins_index);
EFSYS_UNLOCK(enp->en_eslp, state);
locked = B_FALSE;
@@ -669,15 +673,15 @@ found:
if (replacing) {
rc = efx_mcdi_filter_op_add(enp, spec,
MC_CMD_FILTER_OP_IN_OP_REPLACE,
- &hftp->hft_entry[ins_index].hfe_handle);
- } else if (hunt_filter_is_exclusive(spec)) {
+ &eftp->eft_entry[ins_index].efe_handle);
+ } else if (ef10_filter_is_exclusive(spec)) {
rc = efx_mcdi_filter_op_add(enp, spec,
MC_CMD_FILTER_OP_IN_OP_INSERT,
- &hftp->hft_entry[ins_index].hfe_handle);
+ &eftp->eft_entry[ins_index].efe_handle);
} else {
rc = efx_mcdi_filter_op_add(enp, spec,
MC_CMD_FILTER_OP_IN_OP_SUBSCRIBE,
- &hftp->hft_entry[ins_index].hfe_handle);
+ &eftp->eft_entry[ins_index].efe_handle);
}
if (rc != 0)
@@ -694,7 +698,7 @@ found:
saved_spec->efs_dmaq_id = spec->efs_dmaq_id;
}
- hunt_filter_set_entry_not_busy(hftp, ins_index);
+ ef10_filter_set_entry_not_busy(eftp, ins_index);
out_unlock:
@@ -713,8 +717,8 @@ fail4:
EFSYS_KMEM_FREE(enp->en_esip, sizeof (*spec), saved_spec);
saved_spec = NULL;
}
- hunt_filter_set_entry_not_busy(hftp, ins_index);
- hunt_filter_set_entry(hftp, ins_index, NULL);
+ ef10_filter_set_entry_not_busy(eftp, ins_index);
+ ef10_filter_set_entry(eftp, ins_index, NULL);
fail3:
EFSYS_PROBE(fail3);
@@ -732,14 +736,14 @@ fail1:
}
__checkReturn efx_rc_t
-hunt_filter_add(
+ef10_filter_add(
__in efx_nic_t *enp,
__inout efx_filter_spec_t *spec,
__in boolean_t may_replace)
{
efx_rc_t rc;
- rc = hunt_filter_add_internal(enp, spec, may_replace, NULL);
+ rc = ef10_filter_add_internal(enp, spec, may_replace, NULL);
if (rc != 0)
goto fail1;
@@ -753,15 +757,15 @@ fail1:
static __checkReturn efx_rc_t
-hunt_filter_delete_internal(
+ef10_filter_delete_internal(
__in efx_nic_t *enp,
__in uint32_t filter_id)
{
efx_rc_t rc;
- hunt_filter_table_t *table = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *table = enp->en_filter.ef_ef10_filter_table;
efx_filter_spec_t *spec;
int state;
- uint32_t filter_idx = filter_id % EFX_HUNT_FILTER_TBL_ROWS;
+ uint32_t filter_idx = filter_id % EFX_EF10_FILTER_TBL_ROWS;
/*
* Find the software table entry and mark it busy. Don't
@@ -771,13 +775,13 @@ hunt_filter_delete_internal(
* FIXME: What if the busy flag is never cleared?
*/
EFSYS_LOCK(enp->en_eslp, state);
- while (hunt_filter_entry_is_busy(table, filter_idx)) {
+ while (ef10_filter_entry_is_busy(table, filter_idx)) {
EFSYS_UNLOCK(enp->en_eslp, state);
EFSYS_SPIN(1);
EFSYS_LOCK(enp->en_eslp, state);
}
- if ((spec = hunt_filter_entry_spec(table, filter_idx)) != NULL) {
- hunt_filter_set_entry_busy(table, filter_idx);
+ if ((spec = ef10_filter_entry_spec(table, filter_idx)) != NULL) {
+ ef10_filter_set_entry_busy(table, filter_idx);
}
EFSYS_UNLOCK(enp->en_eslp, state);
@@ -790,20 +794,20 @@ hunt_filter_delete_internal(
* Try to remove the hardware filter. This may fail if the MC has
* rebooted (which frees all hardware filter resources).
*/
- if (hunt_filter_is_exclusive(spec)) {
+ if (ef10_filter_is_exclusive(spec)) {
rc = efx_mcdi_filter_op_delete(enp,
MC_CMD_FILTER_OP_IN_OP_REMOVE,
- &table->hft_entry[filter_idx].hfe_handle);
+ &table->eft_entry[filter_idx].efe_handle);
} else {
rc = efx_mcdi_filter_op_delete(enp,
MC_CMD_FILTER_OP_IN_OP_UNSUBSCRIBE,
- &table->hft_entry[filter_idx].hfe_handle);
+ &table->eft_entry[filter_idx].efe_handle);
}
/* Free the software table entry */
EFSYS_LOCK(enp->en_eslp, state);
- hunt_filter_set_entry_not_busy(table, filter_idx);
- hunt_filter_set_entry(table, filter_idx, NULL);
+ ef10_filter_set_entry_not_busy(table, filter_idx);
+ ef10_filter_set_entry(table, filter_idx, NULL);
EFSYS_UNLOCK(enp->en_eslp, state);
EFSYS_KMEM_FREE(enp->en_esip, sizeof (*spec), spec);
@@ -824,12 +828,12 @@ fail1:
}
__checkReturn efx_rc_t
-hunt_filter_delete(
+ef10_filter_delete(
__in efx_nic_t *enp,
__inout efx_filter_spec_t *spec)
{
efx_rc_t rc;
- hunt_filter_table_t *table = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *table = enp->en_filter.ef_ef10_filter_table;
efx_filter_spec_t *saved_spec;
unsigned int hash;
unsigned int depth;
@@ -837,22 +841,23 @@ hunt_filter_delete(
int state;
boolean_t locked = B_FALSE;
- EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON);
+ EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON ||
+ enp->en_family == EFX_FAMILY_MEDFORD);
- hash = hunt_filter_hash(spec);
+ hash = ef10_filter_hash(spec);
EFSYS_LOCK(enp->en_eslp, state);
locked = B_TRUE;
depth = 1;
for (;;) {
- i = (hash + depth) & (EFX_HUNT_FILTER_TBL_ROWS - 1);
- saved_spec = hunt_filter_entry_spec(table, i);
- if (saved_spec && hunt_filter_equal(spec, saved_spec) &&
- hunt_filter_same_dest(spec, saved_spec)) {
+ i = (hash + depth) & (EFX_EF10_FILTER_TBL_ROWS - 1);
+ saved_spec = ef10_filter_entry_spec(table, i);
+ if (saved_spec && ef10_filter_equal(spec, saved_spec) &&
+ ef10_filter_same_dest(spec, saved_spec)) {
break;
}
- if (depth == EFX_HUNT_FILTER_SEARCH_LIMIT) {
+ if (depth == EF10_FILTER_SEARCH_LIMIT) {
rc = ENOENT;
goto fail1;
}
@@ -862,7 +867,7 @@ hunt_filter_delete(
EFSYS_UNLOCK(enp->en_eslp, state);
locked = B_FALSE;
- rc = hunt_filter_delete_internal(enp, i);
+ rc = ef10_filter_delete_internal(enp, i);
if (rc != 0)
goto fail2;
@@ -961,7 +966,7 @@ fail1:
}
__checkReturn efx_rc_t
-hunt_filter_supported_filters(
+ef10_filter_supported_filters(
__in efx_nic_t *enp,
__out uint32_t *list,
__out size_t *length)
@@ -980,13 +985,13 @@ fail1:
}
static __checkReturn efx_rc_t
-hunt_filter_unicast_refresh(
+ef10_filter_unicast_refresh(
__in efx_nic_t *enp,
__in_ecount(6) uint8_t const *addr,
__in boolean_t all_unicst,
__in efx_filter_flag_t filter_flags)
{
- hunt_filter_table_t *hftp = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *eftp = enp->en_filter.ef_ef10_filter_table;
efx_filter_spec_t spec;
efx_rc_t rc;
@@ -996,11 +1001,11 @@ hunt_filter_unicast_refresh(
/* Insert the filter for the local station address */
efx_filter_spec_init_rx(&spec, EFX_FILTER_PRI_AUTO,
filter_flags,
- hftp->hft_default_rxq);
+ eftp->eft_default_rxq);
efx_filter_spec_set_eth_local(&spec, EFX_FILTER_SPEC_VID_UNSPEC, addr);
- rc = hunt_filter_add_internal(enp, &spec, B_TRUE,
- &hftp->hft_unicst_filter_index);
+ rc = ef10_filter_add_internal(enp, &spec, B_TRUE,
+ &eftp->eft_unicst_filter_index);
if (rc != 0) {
/*
* Fall back to an unknown filter. We may be able to subscribe
@@ -1008,7 +1013,7 @@ hunt_filter_unicast_refresh(
*/
goto use_uc_def;
}
- hftp->hft_unicst_filter_set = B_TRUE;
+ eftp->eft_unicst_filter_set = B_TRUE;
return (0);
@@ -1016,32 +1021,32 @@ use_uc_def:
/* Insert the unknown unicast filter */
efx_filter_spec_init_rx(&spec, EFX_FILTER_PRI_AUTO,
filter_flags,
- hftp->hft_default_rxq);
+ eftp->eft_default_rxq);
efx_filter_spec_set_uc_def(&spec);
- rc = hunt_filter_add_internal(enp, &spec, B_TRUE,
- &hftp->hft_unicst_filter_index);
+ rc = ef10_filter_add_internal(enp, &spec, B_TRUE,
+ &eftp->eft_unicst_filter_index);
if (rc != 0)
goto fail1;
- hftp->hft_unicst_filter_set = B_TRUE;
+ eftp->eft_unicst_filter_set = B_TRUE;
return (0);
fail1:
EFSYS_PROBE1(fail1, efx_rc_t, rc);
- if (hftp->hft_unicst_filter_set != B_FALSE) {
- (void) hunt_filter_delete_internal(enp,
- hftp->hft_unicst_filter_index);
+ if (eftp->eft_unicst_filter_set != B_FALSE) {
+ (void) ef10_filter_delete_internal(enp,
+ eftp->eft_unicst_filter_index);
- hftp->hft_unicst_filter_set = B_FALSE;
+ eftp->eft_unicst_filter_set = B_FALSE;
}
return (rc);
}
static __checkReturn efx_rc_t
-hunt_filter_multicast_refresh(
+ef10_filter_multicast_refresh(
__in efx_nic_t *enp,
__in boolean_t mulcst,
__in boolean_t all_mulcst,
@@ -1050,7 +1055,7 @@ hunt_filter_multicast_refresh(
__in int count,
__in efx_filter_flag_t filter_flags)
{
- hunt_filter_table_t *hftp = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *eftp = enp->en_filter.ef_ef10_filter_table;
efx_filter_spec_t spec;
uint8_t addr[6];
unsigned i;
@@ -1063,25 +1068,25 @@ hunt_filter_multicast_refresh(
count = 0;
if (count + (brdcst ? 1 : 0) >
- EFX_ARRAY_SIZE(hftp->hft_mulcst_filter_indexes)) {
+ EFX_ARRAY_SIZE(eftp->eft_mulcst_filter_indexes)) {
/* Too many MAC addresses; use unknown multicast filter */
goto use_mc_def;
}
/* Insert/renew multicast address list filters */
- hftp->hft_mulcst_filter_count = count;
- for (i = 0; i < hftp->hft_mulcst_filter_count; i++) {
+ eftp->eft_mulcst_filter_count = count;
+ for (i = 0; i < eftp->eft_mulcst_filter_count; i++) {
efx_filter_spec_init_rx(&spec,
EFX_FILTER_PRI_AUTO,
filter_flags,
- hftp->hft_default_rxq);
+ eftp->eft_default_rxq);
efx_filter_spec_set_eth_local(&spec,
EFX_FILTER_SPEC_VID_UNSPEC,
&addrs[i * EFX_MAC_ADDR_LEN]);
- rc = hunt_filter_add_internal(enp, &spec, B_TRUE,
- &hftp->hft_mulcst_filter_indexes[i]);
+ rc = ef10_filter_add_internal(enp, &spec, B_TRUE,
+ &eftp->eft_mulcst_filter_indexes[i]);
if (rc != 0) {
/* Rollback, then use unknown multicast filter */
goto rollback;
@@ -1090,18 +1095,18 @@ hunt_filter_multicast_refresh(
if (brdcst == B_TRUE) {
/* Insert/renew broadcast address filter */
- hftp->hft_mulcst_filter_count++;
+ eftp->eft_mulcst_filter_count++;
efx_filter_spec_init_rx(&spec, EFX_FILTER_PRI_AUTO,
filter_flags,
- hftp->hft_default_rxq);
+ eftp->eft_default_rxq);
EFX_MAC_BROADCAST_ADDR_SET(addr);
efx_filter_spec_set_eth_local(&spec, EFX_FILTER_SPEC_VID_UNSPEC,
addr);
- rc = hunt_filter_add_internal(enp, &spec, B_TRUE,
- &hftp->hft_mulcst_filter_indexes[
- hftp->hft_mulcst_filter_count - 1]);
+ rc = ef10_filter_add_internal(enp, &spec, B_TRUE,
+ &eftp->eft_mulcst_filter_indexes[
+ eftp->eft_mulcst_filter_count - 1]);
if (rc != 0) {
/* Rollback, then use unknown multicast filter */
goto rollback;
@@ -1116,24 +1121,24 @@ rollback:
* before inserting the unknown multicast filter.
*/
while (i--) {
- (void) hunt_filter_delete_internal(enp,
- hftp->hft_mulcst_filter_indexes[i]);
+ (void) ef10_filter_delete_internal(enp,
+ eftp->eft_mulcst_filter_indexes[i]);
}
- hftp->hft_mulcst_filter_count = 0;
+ eftp->eft_mulcst_filter_count = 0;
use_mc_def:
/* Insert the unknown multicast filter */
efx_filter_spec_init_rx(&spec, EFX_FILTER_PRI_AUTO,
filter_flags,
- hftp->hft_default_rxq);
+ eftp->eft_default_rxq);
efx_filter_spec_set_mc_def(&spec);
- rc = hunt_filter_add_internal(enp, &spec, B_TRUE,
- &hftp->hft_mulcst_filter_indexes[0]);
+ rc = ef10_filter_add_internal(enp, &spec, B_TRUE,
+ &eftp->eft_mulcst_filter_indexes[0]);
if (rc != 0)
goto fail1;
- hftp->hft_mulcst_filter_count = 1;
+ eftp->eft_mulcst_filter_count = 1;
/*
* FIXME: If brdcst == B_FALSE, add a filter to drop broadcast traffic.
@@ -1192,7 +1197,7 @@ fail1:
* still applied in this case).
*/
__checkReturn efx_rc_t
-hunt_filter_reconfigure(
+ef10_filter_reconfigure(
__in efx_nic_t *enp,
__in_ecount(6) uint8_t const *mac_addr,
__in boolean_t all_unicst,
@@ -1202,58 +1207,58 @@ hunt_filter_reconfigure(
__in_ecount(6*count) uint8_t const *addrs,
__in int count)
{
- hunt_filter_table_t *table = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *table = enp->en_filter.ef_ef10_filter_table;
efx_filter_flag_t filter_flags;
unsigned i;
int all_unicst_rc;
int all_mulcst_rc;
efx_rc_t rc;
- if (table->hft_default_rxq == NULL) {
+ if (table->eft_default_rxq == NULL) {
/*
* Filters direct traffic to the default RXQ, and so cannot be
* inserted until it is available. Any currently configured
* filters must be removed (ignore errors in case the MC
* has rebooted, which removes hardware filters).
*/
- if (table->hft_unicst_filter_set != B_FALSE) {
- (void) hunt_filter_delete_internal(enp,
- table->hft_unicst_filter_index);
- table->hft_unicst_filter_set = B_FALSE;
+ if (table->eft_unicst_filter_set != B_FALSE) {
+ (void) ef10_filter_delete_internal(enp,
+ table->eft_unicst_filter_index);
+ table->eft_unicst_filter_set = B_FALSE;
}
- for (i = 0; i < table->hft_mulcst_filter_count; i++) {
- (void) hunt_filter_delete_internal(enp,
- table->hft_mulcst_filter_indexes[i]);
+ for (i = 0; i < table->eft_mulcst_filter_count; i++) {
+ (void) ef10_filter_delete_internal(enp,
+ table->eft_mulcst_filter_indexes[i]);
}
- table->hft_mulcst_filter_count = 0;
+ table->eft_mulcst_filter_count = 0;
return (0);
}
- if (table->hft_using_rss)
+ if (table->eft_using_rss)
filter_flags = EFX_FILTER_FLAG_RX_RSS;
else
filter_flags = 0;
/* Mark old filters which may need to be removed */
- if (table->hft_unicst_filter_set != B_FALSE) {
- hunt_filter_set_entry_auto_old(table,
- table->hft_unicst_filter_index);
- }
- for (i = 0; i < table->hft_mulcst_filter_count; i++) {
- hunt_filter_set_entry_auto_old(table,
- table->hft_mulcst_filter_indexes[i]);
+ if (table->eft_unicst_filter_set != B_FALSE) {
+ ef10_filter_set_entry_auto_old(table,
+ table->eft_unicst_filter_index);
+ }
+ for (i = 0; i < table->eft_mulcst_filter_count; i++) {
+ ef10_filter_set_entry_auto_old(table,
+ table->eft_mulcst_filter_indexes[i]);
}
/* Insert or renew unicast filters */
- if ((all_unicst_rc = hunt_filter_unicast_refresh(enp, mac_addr,
+ if ((all_unicst_rc = ef10_filter_unicast_refresh(enp, mac_addr,
all_unicst, filter_flags)) != 0) {
if (all_unicst == B_FALSE) {
rc = all_unicst_rc;
goto fail1;
}
/* Retry without all_unicast flag */
- rc = hunt_filter_unicast_refresh(enp, mac_addr,
+ rc = ef10_filter_unicast_refresh(enp, mac_addr,
B_FALSE, filter_flags);
if (rc != 0)
goto fail2;
@@ -1272,12 +1277,14 @@ hunt_filter_reconfigure(
* filters. This ensures that encp->enc_workaround_bug26807 matches the
* firmware state, and that later changes to enable/disable the
* workaround will result in this function seeing a reset (FLR).
+ *
+ * FIXME: On Medford mulicast chaining should always be on.
*/
if ((rc = hunt_filter_get_workarounds(enp)) != 0)
goto fail3;
/* Insert or renew multicast filters */
- if ((all_mulcst_rc = hunt_filter_multicast_refresh(enp, mulcst,
+ if ((all_mulcst_rc = ef10_filter_multicast_refresh(enp, mulcst,
all_mulcst, brdcst,
addrs, count, filter_flags)) != 0) {
if (all_mulcst == B_FALSE) {
@@ -1285,7 +1292,7 @@ hunt_filter_reconfigure(
goto fail4;
}
/* Retry without all_mulcast flag */
- rc = hunt_filter_multicast_refresh(enp, mulcst,
+ rc = ef10_filter_multicast_refresh(enp, mulcst,
B_FALSE, brdcst,
addrs, count, filter_flags);
if (rc != 0)
@@ -1293,9 +1300,9 @@ hunt_filter_reconfigure(
}
/* Remove old filters which were not renewed */
- for (i = 0; i < EFX_ARRAY_SIZE(table->hft_entry); i++) {
- if (hunt_filter_entry_is_auto_old(table, i)) {
- (void) hunt_filter_delete_internal(enp, i);
+ for (i = 0; i < EFX_ARRAY_SIZE(table->eft_entry); i++) {
+ if (ef10_filter_entry_is_auto_old(table, i)) {
+ (void) ef10_filter_delete_internal(enp, i);
}
}
@@ -1319,9 +1326,9 @@ fail1:
EFSYS_PROBE1(fail1, efx_rc_t, rc);
/* Clear auto old flags */
- for (i = 0; i < EFX_ARRAY_SIZE(table->hft_entry); i++) {
- if (hunt_filter_entry_is_auto_old(table, i)) {
- hunt_filter_set_entry_not_auto_old(table, i);
+ for (i = 0; i < EFX_ARRAY_SIZE(table->eft_entry); i++) {
+ if (ef10_filter_entry_is_auto_old(table, i)) {
+ ef10_filter_set_entry_not_auto_old(table, i);
}
}
@@ -1329,45 +1336,45 @@ fail1:
}
void
-hunt_filter_get_default_rxq(
+ef10_filter_get_default_rxq(
__in efx_nic_t *enp,
__out efx_rxq_t **erpp,
__out boolean_t *using_rss)
{
- hunt_filter_table_t *table = enp->en_filter.ef_hunt_filter_table;
+ ef10_filter_table_t *table = enp->en_filter.ef_ef10_filter_table;
- *erpp = table->hft_default_rxq;
- *using_rss = table->hft_using_rss;
+ *erpp = table->eft_default_rxq;
+ *using_rss = table->eft_using_rss;
}
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-stable-10@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-stable-10
To unsubscribe, send any mail to "svn-src-stable-10-unsubscr...@freebsd.org"
