35#include <sys/eventhandler.h>
36#include <sys/fnv_hash.h>
38#include <sys/kernel.h>
39#include <sys/module.h>
43#include <sys/rwlock.h>
44#include <sys/socket.h>
46#include <netinet/in.h>
93 hash = fnv_32_buf(&ft->
sip[0], 16, FNV1_32_INIT);
94 hash = fnv_32_buf(&ft->
dip[0], 16, hash);
96 hash = fnv_32_buf(&ft->
sip[0], 4, FNV1_32_INIT);
97 hash = fnv_32_buf(&ft->
dip[0], 4, hash);
99 hash = fnv_32_buf(&ft->
sport,
sizeof(ft->
sport), hash);
100 hash = fnv_32_buf(&ft->
dport,
sizeof(ft->
dport), hash);
105static inline uint32_t
109 return (fnv_32_buf(&tid,
sizeof(tid), FNV1_32_INIT));
121 n = max(t->
ntids / 1024, 16);
133 mtx_init(&t->hftid_lock,
"T4 hashfilters", 0, MTX_DEF);
153 LIST_FOREACH_SAFE(f, &head[i], link_tid, ftmp) {
154 LIST_REMOVE(f, link_tid);
161 LIST_FOREACH_SAFE(f, &head[i], link_4t, ftmp) {
163 n += f->fs.type ? 2 : 1;
165 LIST_REMOVE(f, link_4t);
181 if (mtx_initialized(&t->hftid_lock)) {
182 mtx_destroy(&t->hftid_lock);
196 LIST_INSERT_HEAD(&head[hash & t->
hftid_4t_mask], f, link_4t);
197 atomic_add_int(&t->
tids_in_use, f->fs.type ? 2 : 1);
209 mtx_assert(&t->hftid_lock, MA_OWNED);
226 n = fs1->
type ? 16 : 4;
270 mtx_assert(&t->hftid_lock, MA_OWNED);
292 mtx_assert(&t->hftid_lock, MA_OWNED);
309 mtx_assert(&t->hftid_lock, MA_OWNED);
311 LIST_REMOVE(f, link_4t);
312 atomic_subtract_int(&t->
tids_in_use, f->fs.type ? 2 : 1);
321 mtx_assert(&t->hftid_lock, MA_OWNED);
324 LIST_REMOVE(f, link_tid);
428 if (fs->
val.encap_vld || fs->
mask.encap_vld) {
569 if (iconf != -1 && iconf != tp->
vnic_mode)
598static inline uint64_t
609 else if (
is_t4(sc)) {
640 u_int vnic_vld, vnic_vld_mask;
642 int i, rc, busy, locked;
644 const int ntids = t->
fs.
type ? 4 : 1;
660 rc = busy = locked = 0;
661 mtx_lock(&sc->
tids.ftid_lock);
662 for (i = 0; i < ntids; i++) {
663 busy += f[i].pending + f[i].valid;
664 locked += f[i].locked;
678 if (__predict_false(fwr == NULL))
688 mtx_unlock(&sc->
tids.ftid_lock);
710 bzero(fwr,
sizeof(*fwr));
738 fwr->
ethtype = htobe16(f->fs.val.ethtype);
739 fwr->
ethtypem = htobe16(f->fs.mask.ethtype);
759 fwr->
ptcl = f->fs.val.proto;
760 fwr->
ptclm = f->fs.mask.proto;
761 fwr->
ttyp = f->fs.val.tos;
762 fwr->
ttypm = f->fs.mask.tos;
763 fwr->
ivlan = htobe16(f->fs.val.vlan);
764 fwr->
ivlanm = htobe16(f->fs.mask.vlan);
765 fwr->
ovlan = htobe16(f->fs.val.vnic);
766 fwr->
ovlanm = htobe16(f->fs.mask.vnic);
767 bcopy(f->fs.val.dip, fwr->
lip, sizeof (fwr->
lip));
768 bcopy(f->fs.mask.dip, fwr->
lipm, sizeof (fwr->
lipm));
769 bcopy(f->fs.val.sip, fwr->
fip, sizeof (fwr->
fip));
770 bcopy(f->fs.mask.sip, fwr->
fipm, sizeof (fwr->
fipm));
771 fwr->
lp = htobe16(f->fs.val.dport);
772 fwr->
lpm = htobe16(f->fs.mask.dport);
773 fwr->
fp = htobe16(f->fs.val.sport);
774 fwr->
fpm = htobe16(f->fs.mask.sport);
776 bzero(fwr->
sma, sizeof (fwr->
sma));
785 memcpy(fwr->
newlip, f->fs.nat_dip,
sizeof(fwr->
newlip));
786 memcpy(fwr->
newfip, f->fs.nat_sip,
sizeof(fwr->
newfip));
787 fwr->
newlport = htobe16(f->fs.nat_dport);
788 fwr->
newfport = htobe16(f->fs.nat_sport);
794 mtx_lock(&sc->
tids.ftid_lock);
796 if (f->pending == 0) {
797 rc = f->valid ? 0 : EIO;
805 mtx_unlock(&sc->
tids.ftid_lock);
851 MPASS(fs->
mask.encap_vld);
893 const int n = fs->
type ? 16 : 4;
898 for (i = 0; i < n; i++) {
925 if (t->
idx != (uint32_t)-1)
999 (
"%s: no memory allocated but hpftids_in_use is %u",
1002 ti->
nhpftids, M_CXGBE, M_NOWAIT | M_ZERO);
1007 if (!mtx_initialized(&sc->
tids.ftid_lock)) {
1008 mtx_init(&ti->ftid_lock,
"T4 filters", 0, MTX_DEF);
1009 cv_init(&ti->
ftid_cv,
"t4fcv");
1011 }
else if (__predict_false(ti->
ftid_tab == NULL)) {
1014 (
"%s: no memory allocated but ftids_in_use is %u",
1017 M_CXGBE, M_NOWAIT | M_ZERO);
1022 if (!mtx_initialized(&sc->
tids.ftid_lock)) {
1023 mtx_init(&ti->ftid_lock,
"T4 filters", 0, MTX_DEF);
1024 cv_init(&ti->
ftid_cv,
"t4fcv");
1040 if (__predict_false(l2te == NULL)) {
1049 if (__predict_false(smt == NULL)) {
1063 if (rc != 0 && rc != EINPROGRESS) {
1084 mtx_lock(&sc->
tids.ftid_lock);
1099 if (t->
idx >= nfilters) {
1113 if (f->valid == 0) {
1117 MPASS(f->tid == tid_base + t->
idx);
1124 bzero(fwr,
sizeof (*fwr));
1131 if (f->pending == 0) {
1132 rc = f->valid ? EIO : 0;
1141 mtx_unlock(&sc->
tids.ftid_lock);
1190 uint64_t val,
int no_reply)
1198 bzero(req,
sizeof(*req));
1200 if (no_reply == 0) {
1220 (uint64_t)
val << bit_pos, no_reply));
1232 KASSERT(m == NULL, (
"%s: payload with opcode %02x", __func__,
1239 }
else if (
is_ftid(sc, tid)) {
1243 panic(
"%s: FW reply for invalid TID %d.", __func__, tid);
1245 MPASS(f->tid == tid);
1248 mtx_lock(&sc->
tids.ftid_lock);
1249 KASSERT(f->pending, (
"%s: reply %d for filter[%u] that isn't pending.",
1250 __func__, rc, tid));
1255 if (f->fs.newsmac) {
1256 MPASS(f->smt != NULL);
1266 MPASS(f->valid == 1);
1271 MPASS(f->valid == 0);
1281 panic(
"%s: unexpected reply %d for filter[%d].", __func__, rc,
1286 mtx_unlock(&sc->
tids.ftid_lock);
1305 KASSERT(m == NULL, (
"%s: wasn't expecting payload", __func__));
1307 mtx_lock(&sc->
tids.hftid_lock);
1308 KASSERT(f->pending, (
"%s: hashfilter[%p] isn't pending.", __func__, f));
1309 KASSERT(f->tid == -1, (
"%s: hashfilter[%p] has tid %d already.",
1310 __func__, f, f->tid));
1338 mtx_unlock(&sc->
tids.hftid_lock);
1353 mtx_lock(&sc->
tids.hftid_lock);
1355 KASSERT(f->tid == tid, (
"%s: filter tid mismatch", __func__));
1356 KASSERT(f->pending, (
"%s: hashfilter %p [%u] isn't pending.", __func__,
1358 KASSERT(f->valid == 0, (
"%s: hashfilter %p [%u] is valid already.",
1374 mtx_unlock(&sc->
tids.hftid_lock);
1385 unsigned int tid =
GET_TID(cpl);
1388 mtx_lock(&sc->
tids.hftid_lock);
1390 KASSERT(f->tid == tid, (
"%s: filter tid mismatch", __func__));
1391 KASSERT(f->pending, (
"%s: hashfilter %p [%u] isn't pending.", __func__,
1393 KASSERT(f->valid, (
"%s: hashfilter %p [%u] isn't valid.", __func__, f,
1406 mtx_unlock(&sc->
tids.hftid_lock);
1439 if (in_use == 0 || f == NULL || t->
idx >= nfilters) {
1440 t->
idx = 0xffffffff;
1445 mtx_lock(&sc->
tids.ftid_lock);
1446 for (i = t->
idx; i < nfilters; i++, f++) {
1448 MPASS(f->tid == tid_base + i);
1450 t->
l2tidx = f->l2te ? f->l2te->idx : 0;
1451 t->
smtidx = f->smt ? f->smt->idx : 0;
1455 t->
hits = UINT64_MAX;
1461 t->
idx = 0xffffffff;
1463 mtx_unlock(&sc->
tids.ftid_lock);
1478 t->
idx >= inv_tid) {
1479 t->
idx = 0xffffffff;
1485 mtx_lock(&ti->hftid_lock);
1486 for (tid = t->
idx; tid < inv_tid; tid++) {
1488 if (f != NULL && f->valid) {
1490 t->
l2tidx = f->l2te ? f->l2te->idx : 0;
1491 t->
smtidx = f->smt ? f->smt->idx : 0;
1495 t->
hits = UINT64_MAX;
1501 t->
idx = 0xffffffff;
1503 mtx_unlock(&ti->hftid_lock);
1530 cpl->
peer_port = htobe16(f->fs.val.sport);
1532 cpl->
local_ip_lo = *(((uint64_t *)&f->fs.val.dip) + 1);
1533 cpl->
peer_ip_hi = *(uint64_t *)(&f->fs.val.sip);
1534 cpl->
peer_ip_lo = *(((uint64_t *)&f->fs.val.sip) + 1);
1548 V_PACE(f->fs.maskhash | (f->fs.dirsteerhash << 1)));
1574 cpl->
peer_port = htobe16(f->fs.val.sport);
1575 cpl->
local_ip = f->fs.val.dip[0] | f->fs.val.dip[1] << 8 |
1576 f->fs.val.dip[2] << 16 | f->fs.val.dip[3] << 24;
1577 cpl->
peer_ip = f->fs.val.sip[0] | f->fs.val.sip[1] << 8 |
1578 f->fs.val.sip[2] << 16 | f->fs.val.sip[3] << 24;
1592 V_PACE(f->fs.maskhash | (f->fs.dirsteerhash << 1)));
1599 static const int sz_table[3][2] = {
1617 return (sz_table[idx][!!isipv6]);
1637 mtx_lock(&sc->
tids.hftid_lock);
1643 f = malloc(
sizeof(*f), M_CXGBE, M_ZERO | M_NOWAIT);
1644 if (__predict_false(f == NULL)) {
1653 if (__predict_false(atid) == -1) {
1681 if (f->pending == 0) {
1699 mtx_unlock(&sc->
tids.hftid_lock);
1704#define LEN__SET_TCB_FIELD_ULP (sizeof(struct ulp_txpkt) + \
1705 sizeof(struct ulptx_idata) + sizeof(struct cpl_set_tcb_field_core))
1709 uint64_t val, uint32_t tid, uint32_t qid)
1719 ulpsc->
len = htobe32(
sizeof(*req));
1731 ulpsc->
len = htobe32(0);
1738#define LEN__ABORT_REQ_ULP (sizeof(struct ulp_txpkt) + \
1739 sizeof(struct ulptx_idata) + sizeof(struct cpl_abort_req_core))
1752 ulpsc->
len = htobe32(
sizeof(*req));
1756 req->
rsvd0 = htonl(0);
1763 ulpsc->
len = htobe32(0);
1770#define LEN__ABORT_RPL_ULP (sizeof(struct ulp_txpkt) + \
1771 sizeof(struct ulptx_idata) + sizeof(struct cpl_abort_rpl_core))
1784 ulpsc->
len = htobe32(
sizeof(*rpl));
1788 rpl->
rsvd0 = htonl(0);
1795 ulpsc->
len = htobe32(0);
1841 mtx_lock(&ti->hftid_lock);
1843 if (f == NULL || f->valid == 0) {
1847 MPASS(f->tid == t->
idx);
1870 if (f->pending == 0) {
1880 if (cv_wait_sig(&ti->
hftid_cv, &ti->hftid_lock) != 0) {
1887 mtx_unlock(&ti->hftid_lock);
1891#define WORD_MASK 0xffffffff
1894 const bool sip,
const bool dp,
const bool sp)
1900 f->fs.nat_dip[15] | f->fs.nat_dip[14] << 8 |
1901 f->fs.nat_dip[13] << 16 | f->fs.nat_dip[12] << 24, 1);
1905 f->fs.nat_dip[11] | f->fs.nat_dip[10] << 8 |
1906 f->fs.nat_dip[9] << 16 | f->fs.nat_dip[8] << 24, 1);
1910 f->fs.nat_dip[7] | f->fs.nat_dip[6] << 8 |
1911 f->fs.nat_dip[5] << 16 | f->fs.nat_dip[4] << 24, 1);
1915 f->fs.nat_dip[3] | f->fs.nat_dip[2] << 8 |
1916 f->fs.nat_dip[1] << 16 | f->fs.nat_dip[0] << 24, 1);
1920 f->fs.nat_dip[3] | f->fs.nat_dip[2] << 8 |
1921 f->fs.nat_dip[1] << 16 | f->fs.nat_dip[0] << 24, 1);
1929 f->fs.nat_sip[15] | f->fs.nat_sip[14] << 8 |
1930 f->fs.nat_sip[13] << 16 | f->fs.nat_sip[12] << 24, 1);
1934 f->fs.nat_sip[11] | f->fs.nat_sip[10] << 8 |
1935 f->fs.nat_sip[9] << 16 | f->fs.nat_sip[8] << 24, 1);
1939 f->fs.nat_sip[7] | f->fs.nat_sip[6] << 8 |
1940 f->fs.nat_sip[5] << 16 | f->fs.nat_sip[4] << 24, 1);
1944 f->fs.nat_sip[3] | f->fs.nat_sip[2] << 8 |
1945 f->fs.nat_sip[1] << 16 | f->fs.nat_sip[0] << 24, 1);
1950 f->fs.nat_sip[3] | f->fs.nat_sip[2] << 8 |
1951 f->fs.nat_sip[1] << 16 | f->fs.nat_sip[0] << 24, 1);
1956 (dp ? f->fs.nat_dport : 0) | (sp ? f->fs.nat_sport << 16 : 0), 1);
1972 MPASS(f->valid == 0);
1974 if (f->fs.newdmac) {
1984 if (f->fs.newsmac) {
1985 MPASS(f->smt != NULL);
1993 switch(f->fs.nat_mode) {
2030 if (f->fs.nat_seq_chk) {
2056 if (f->fs.hitcnts || updated > 0) {
2061 return (EINPROGRESS);
int begin_synchronized_op(struct adapter *, struct vi_info *, int, char *)
static uint32_t t4_read_reg(struct adapter *sc, uint32_t reg)
void free_atid(struct adapter *, int)
void * lookup_atid(struct adapter *, int)
int alloc_atid(struct adapter *, void *)
static int read_via_memwin(struct adapter *sc, int idx, uint32_t addr, uint32_t *val, int len)
void commit_wrq_wr(struct sge_wrq *, void *, struct wrq_cookie *)
static bool hw_off_limits(struct adapter *sc)
void release_tid(struct adapter *, int, struct sge_wrq *)
void end_synchronized_op(struct adapter *, int)
int adapter_init(struct adapter *)
void * start_wrq_wr(struct sge_wrq *, int, struct wrq_cookie *)
static int is_ftid(const struct adapter *sc, u_int tid)
int t4_set_filter_cfg(struct adapter *adap, int mode, int mask, int vnic_mode)
static int is_hashfilter(const struct adapter *adap)
static int chip_id(struct adapter *adap)
static int is_t4(struct adapter *adap)
static int is_hpftid(const struct adapter *sc, u_int tid)
static int is_t5(struct adapter *adap)
void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
LIST_HEAD(cxgbei_cmp_head, cxgbei_cmp)
#define INIT_TP_WR(w, tid)
#define INIT_ULPTX_WRH(w, wrlen, atomic, tid)
#define INIT_TP_WR_MIT_CPL(w, cpl, tid)
unsigned int filter2_wr_support
struct adapter_params params
__be32 maci_to_matchtypem
__be32 del_filter_to_l2tix
struct t4_filter_tuple val
struct t4_filter_tuple mask
uint8_t dmac[ETHER_ADDR_LEN]
uint8_t smac[ETHER_ADDR_LEN]
struct t4_filter_specification fs
struct filter_entry * ftid_tab
struct filter_entry * hpftid_tab
static int del_hashfilter_wrlen(void)
static bool is_4tuple_specified(struct t4_filter_specification *fs)
static int del_hashfilter(struct adapter *, struct t4_filter *)
int set_filter_mask(struct adapter *sc, uint32_t mode)
static int set_tcb_field(struct adapter *sc, u_int tid, uint16_t word, uint64_t mask, uint64_t val, int no_reply)
#define LEN__SET_TCB_FIELD_ULP
static void insert_hf(struct adapter *sc, struct filter_entry *f, uint32_t hash)
static uint16_t mode_to_fconf(uint32_t mode)
static struct filter_entry * lookup_hftid(struct adapter *sc, int tid)
int t4_del_hashfilter_rpl(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
static int set_hashfilter(struct adapter *, struct t4_filter *, uint64_t, struct l2t_entry *, struct smt_entry *)
int set_filter(struct adapter *sc, struct t4_filter *t)
int get_filter_mode(struct adapter *sc, uint32_t *mode)
static int set_tcamfilter(struct adapter *sc, struct t4_filter *t, struct l2t_entry *l2te, struct smt_entry *smt)
static bool filter_eq(struct t4_filter_specification *fs1, struct t4_filter_specification *fs2)
static int mode_to_iconf(uint32_t mode)
int t4_hashfilter_tcb_rpl(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
static int configure_hashfilter_tcb(struct adapter *, struct filter_entry *)
static void mk_act_open_req(struct adapter *sc, struct filter_entry *f, int atid, uint64_t ftuple, struct cpl_act_open_req *cpl)
static void mk_act_open_req6(struct adapter *sc, struct filter_entry *f, int atid, uint64_t ftuple, struct cpl_act_open_req6 *cpl)
int t4_filter_rpl(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
static int act_open_cpl_len16(struct adapter *sc, int isipv6)
int t4_hashfilter_ao_rpl(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
static int get_tcamfilter(struct adapter *, struct t4_filter *)
static void free_filter_resources(struct filter_entry *)
static int hashfilter_ntuple(struct adapter *sc, const struct t4_filter_specification *fs, uint64_t *ftuple)
int set_filter_mode(struct adapter *sc, uint32_t mode)
static int check_fspec_against_fconf_iconf(struct adapter *sc, struct t4_filter_specification *fs)
static struct filter_entry * lookup_hf(struct adapter *sc, struct t4_filter_specification *fs, uint32_t hash)
static void * mk_abort_req_ulp(struct ulp_txpkt *ulpmc, uint32_t tid)
static bool separate_hpfilter_region(struct adapter *sc)
static int get_hashfilter(struct adapter *, struct t4_filter *)
void free_hftid_hash(struct tid_info *t)
static int set_tcb_tflag(struct adapter *sc, int tid, u_int bit_pos, u_int val, u_int no_reply)
static void insert_hftid(struct adapter *sc, struct filter_entry *f)
static void * mk_set_tcb_field_ulp(struct ulp_txpkt *ulpmc, uint64_t word, uint64_t mask, uint64_t val, uint32_t tid, uint32_t qid)
int get_filter(struct adapter *sc, struct t4_filter *t)
static void * mk_abort_rpl_ulp(struct ulp_txpkt *ulpmc, uint32_t tid)
static void mk_del_hashfilter_wr(int tid, struct work_request_hdr *wrh, int wrlen, int qid)
static void set_nat_params(struct adapter *sc, struct filter_entry *f, const bool dip, const bool sip, const bool dp, const bool sp)
#define LEN__ABORT_REQ_ULP
static int alloc_hftid_hash(struct tid_info *t, int flags)
static uint32_t hf_hashfn_tid(int tid)
#define LEN__ABORT_RPL_ULP
static uint64_t get_filter_hits(struct adapter *sc, uint32_t tid)
static uint32_t fconf_to_mode(uint16_t hwmode, int vnic_mode)
static uint32_t hf_hashfn_4t(struct t4_filter_specification *fs)
int del_filter(struct adapter *sc, struct t4_filter *t)
static void remove_hftid(struct adapter *sc, struct filter_entry *f)
static void remove_hf(struct adapter *sc, struct filter_entry *f)
static int del_tcamfilter(struct adapter *sc, struct t4_filter *t)
#define T4_FILTER_IC_ENCAP
#define T4_FILTER_MAC_IDX
#define T4_FILTER_IP_FRAGMENT
#define T4_FILTER_IP_DPORT
#define T4_FILTER_IP_DADDR
#define T4_FILTER_ETH_TYPE
#define T4_FILTER_IP_SPORT
#define T4_FILTER_IP_PROTO
#define T4_FILTER_IP_SADDR
#define T4_FILTER_MPS_HIT_TYPE
#define T4_FILTER_IC_VNIC
struct l2t_entry * t4_l2t_alloc_switching(struct adapter *sc, uint16_t vlan, uint8_t port, uint8_t *eth_addr)
static void t4_l2t_release(struct l2t_entry *e)
#define V_WND_SCALE_EN(x)
#define F_RSS_QUEUE_VALID
#define V_ULP_TXPKT_DEST(x)
#define V_FILTER_TUPLE(x)
#define G_AOPEN_STATUS(x)
static int act_open_has_tid(int status)
#define V_RX_FC_DISABLE(x)
#define MK_OPCODE_TID(opcode, tid)
static int act_open_rpl_status_to_errno(int status)
#define A_TP_CMM_TCB_BASE
int t4_smt_set_switching(struct adapter *sc, struct smt_entry *e, uint16_t pfvf, uint8_t *smac)
struct smt_entry * t4_smt_alloc_switching(struct smt_data *s, uint8_t *smac)
static void t4_smt_release(struct smt_entry *e)
#define M_TCB_T_RTT_TS_RECENT_AGE
#define W_TCB_RX_FRAG2_PTR_RAW
#define V_TCB_TIMESTAMP(x)
#define V_TCB_RSS_INFO(x)
#define W_TCB_RX_FRAG3_LEN_RAW
#define W_TCB_SND_UNA_RAW
#define W_TCB_PDU_HDR_LEN
#define V_TF_MIGRATING(x)
#define V_TCB_T_RTT_TS_RECENT_AGE(x)
#define W_TCB_RX_FRAG3_START_IDX_OFFSET_RAW
#define V_TCB_SMAC_SEL(x)
#define V_TF_NON_OFFLOAD(x)
#define V_FW_FILTER_WR_IQ(x)
@ FW_FILTER_WR_SMT_TBL_FULL
@ FW_FILTER_WR_FLT_DELETED
#define V_FW_FILTER_WR_FRAG(x)
#define V_FW_FILTER_WR_OVLAN_VLD(x)
#define V_FW_FILTER_WR_FCOE(x)
#define V_FW_FILTER_WR_IVLAN_VLD(x)
#define V_FW_FILTER_WR_RMVLAN(x)
#define V_FW_FILTER_WR_NOREPLY(x)
@ FW_VNIC_MODE_OUTER_VLAN
#define V_FW_FILTER_WR_DMAC(x)
#define V_FW_FILTER_WR_HITCNTS(x)
#define V_FW_FILTER_WR_MASKHASH(x)
#define V_FW_FILTER_WR_OVLAN_VLDM(x)
#define V_FW_FILTER_WR_FCOEM(x)
#define V_FW_FILTER_WR_RQTYPE(x)
#define V_FW_FILTER_WR_TID(x)
#define V_FW_FILTER2_WR_NATMODE(x)
#define V_FW_FILTER_WR_IVLAN_VLDM(x)
#define V_FW_FILTER2_WR_SWAPMAC(x)
#define V_FW_FILTER2_WR_ULP_TYPE(x)
#define V_FW_FILTER_WR_MACI(x)
#define V_FW_FILTER_WR_RX_CHAN(x)
#define V_FW_FILTER_WR_RX_RPL_IQ(x)
#define V_FW_FILTER_WR_TXCHAN(x)
#define V_FW_FILTER_WR_DIRSTEER(x)
#define V_FW_FILTER_WR_MACIM(x)
#define V_FW_FILTER_WR_DIRSTEERHASH(x)
#define V_FW_FILTER_WR_PRIO(x)
#define V_FW_FILTER_WR_MATCHTYPE(x)
#define V_FW_FILTER_WR_SMAC(x)
#define V_FW_FILTER_WR_RPTTID(x)
#define V_FW_FILTER_WR_FRAGM(x)
#define V_FW_FILTER_WR_MATCHTYPEM(x)
#define V_FW_FILTER_WR_L2TIX(x)
#define V_FW_FILTER_WR_PORTM(x)
#define V_FW_FILTER_WR_INSVLAN(x)
#define V_FW_FILTER_WR_PORT(x)
#define V_FW_FILTER_WR_DROP(x)
#define V_FW_FILTER_WR_LPBK(x)
#define V_FW_FILTER2_WR_NATFLAGCHECK(x)
#define FW_LEN16(fw_struct)