31#include "opt_kern_tls.h"
40#include <sys/sglist.h>
41#include <sys/socket.h>
42#include <sys/socketvar.h>
44#include <netinet/in.h>
45#include <netinet/in_pcb.h>
46#include <netinet/tcp_var.h>
47#include <netinet/toecore.h>
48#include <opencrypto/cryptodev.h>
49#include <opencrypto/xform.h>
62#define tls_tcp_seq PH_loc.thirtytwo[0]
65t4_set_tls_tcb_field(
struct toepcb *toep, uint16_t word, uint64_t mask,
91t4_set_tls_keyid(
struct toepcb *toep,
unsigned int key_id)
101t4_clear_rx_quiesce(
struct toepcb *toep)
108tls_clr_ofld_mode(
struct toepcb *toep)
114 (
"%s: tid %d has RX key", __func__, toep->
tid));
122 t4_clear_rx_quiesce(toep);
129static inline unsigned char
130tls_content_type(
unsigned char content_type)
137 switch (content_type) {
152clear_tls_keyid(
struct toepcb *toep)
168get_tp_plen_max(
struct ktls_session *tls)
170 int plen = ((min(3*4096,
TP_TX_PG_SZ))/1448) * 1448;
172 return (tls->params.max_frame_len <= 8192 ? plen :
FC_TP_PLEN_MAX);
177tls_program_key_id(
struct toepcb *toep,
struct ktls_session *tls,
189 int kwrlen, kctxlen, len;
191 kwrlen =
sizeof(*kwr);
192 kctxlen = roundup2(
sizeof(*kctx), 32);
193 len = roundup2(kwrlen + kctxlen, 16);
199 if ((keyid = t4_alloc_tls_keyid(sc)) < 0) {
205 t4_free_tls_keyid(sc, keyid);
214 if (direction == KTLS_TX)
218 t4_tls_key_ctx(tls, direction, kctx);
239tls_send_handshake_ack(
void *arg)
241 struct toepcb *toep = arg;
261 CTR2(
KTR_CXGBE,
"%s: tid %d clr_ofld_mode", __func__,
263 tls_clr_ofld_mode(toep);
274 CTR2(
KTR_CXGBE,
"%s: tid %d sending RX_DATA_ACK", __func__, toep->
tid);
279tls_start_handshake_timer(
struct toepcb *toep)
283 INP_WLOCK_ASSERT(toep->
inp);
285 tls_send_handshake_ack, toep);
293 INP_WLOCK_ASSERT(toep->
inp);
301 int error, explicit_iv_size, key_offset, mac_first;
310 if (direction != KTLS_TX)
317 switch (tls->params.cipher_algorithm) {
320 switch (tls->params.cipher_key_len) {
329 switch (tls->params.auth_algorithm) {
330 case CRYPTO_SHA1_HMAC:
331 case CRYPTO_SHA2_256_HMAC:
332 case CRYPTO_SHA2_384_HMAC:
335 error = EPROTONOSUPPORT;
338 explicit_iv_size = AES_BLOCK_LEN;
341 case CRYPTO_AES_NIST_GCM_16:
346 switch (tls->params.cipher_key_len) {
355 explicit_iv_size = 8;
359 error = EPROTONOSUPPORT;
364 if (tls->params.tls_vmajor != TLS_MAJOR_VER_ONE ||
365 tls->params.tls_vminor < TLS_MINOR_VER_ONE ||
366 tls->params.tls_vminor > TLS_MINOR_VER_TWO) {
367 error = EPROTONOSUPPORT;
372 if (direction == KTLS_TX) {
380 error = tls_program_key_id(toep, tls, direction);
382 if (direction == KTLS_RX)
387 if (direction == KTLS_TX) {
403 if (tls->params.cipher_algorithm == CRYPTO_AES_NIST_GCM_16)
411 tls->params.tls_tlen;
414 tls->params.max_frame_len;
420 toep->
flags &= ~TPF_FORCE_CREDITS;
423 tls->params.tls_vminor;
431 t4_set_tls_keyid(toep, key_offset / 64);
441 t4_clear_rx_quiesce(toep);
448 CTR2(
KTR_CXGBE,
"%s: tid %d clr_ofld_mode", __func__,
450 tls_clr_ofld_mode(toep);
475 CTR2(
KTR_CXGBE,
"%s: tid %d setting TLS_ENABLE", __func__, toep->
tid);
482 tls_start_handshake_timer(toep);
491 toep->
flags &= ~TPF_TLS_ESTABLISHED;
500 clear_tls_keyid(toep);
503#define MAX_OFLD_TX_CREDITS (SGE_MAX_WR_LEN / 16)
504#define MIN_OFLD_TLSTX_CREDITS(toep) \
505 (howmany(sizeof(struct fw_tlstx_data_wr) + \
506 sizeof(struct cpl_tx_tls_sfo) + sizeof(struct ulptx_idata) + \
507 sizeof(struct ulptx_sc_memrd) + \
508 AES_BLOCK_LEN + 1, 16))
512 unsigned int immdlen,
unsigned int plen,
unsigned int expn,
513 unsigned int pdus, uint8_t credits,
int shove,
int imm_ivs)
516 unsigned int len = plen + expn;
523 txwr->
plen = htobe32(len);
545 int data_type, seglen;
567count_ext_pgs_segs(
struct mbuf *m)
572 MPASS(m->m_epg_npgs > 0);
574 nextpa = m->m_epg_pa[0] + PAGE_SIZE;
575 for (i = 1; i < m->m_epg_npgs; i++) {
576 if (nextpa != m->m_epg_pa[i])
578 nextpa = m->m_epg_pa[i] + PAGE_SIZE;
584write_ktlstx_sgl(
void *dst,
struct mbuf *m,
int nsegs)
591 KASSERT(nsegs > 0, (
"%s: nsegs 0", __func__));
597 pa = m->m_epg_pa[0] + m->m_epg_1st_off;
598 usgl->
addr0 = htobe64(pa);
599 len = m_epg_pagelen(m, 0, m->m_epg_1st_off);
601 for (i = 1; i < m->m_epg_npgs; i++) {
602 if (m->m_epg_pa[i] != pa)
604 len += m_epg_pagelen(m, i, 0);
605 pa += m_epg_pagelen(m, i, 0);
607 usgl->
len0 = htobe32(len);
613 for (; i < m->m_epg_npgs; i++) {
614 if (j == -1 || m->m_epg_pa[i] != pa) {
616 usgl->
sge[j / 2].
len[j & 1] = htobe32(len);
622 usgl->
sge[j / 2].
addr[j & 1] = htobe64(pa);
623 len = m_epg_pagelen(m, i, 0);
626 len += m_epg_pagelen(m, i, 0);
627 pa += m_epg_pagelen(m, i, 0);
631 usgl->
sge[j / 2].
len[j & 1] = htobe32(len);
634 usgl->
sge[j / 2].
len[1] = htobe32(0);
636 KASSERT(nsegs == 0, (
"%s: nsegs %d, m %p", __func__, nsegs, m));
653 u_int nsegs, credits, wr_len;
655 struct inpcb *inp = toep->
inp;
656 struct tcpcb *tp = intotcpcb(inp);
657 struct socket *so = inp->inp_socket;
658 struct sockbuf *sb = &so->so_snd;
659 int tls_size, tx_credits, shove, sowwakeup;
663 INP_WLOCK_ASSERT(inp);
665 (
"%s: flowc_wr not sent for tid %u.", __func__, toep->
tid));
669 (
"%s: ulp_mode %u for toep %p", __func__,
ulp_mode(toep), toep));
671 (
"%s: TX key not set for toep %p", __func__, toep));
674 CTR4(
KTR_CXGBE,
"%s: tid %d toep flags %#x tp flags %#x drop %d",
675 __func__, toep->
tid, toep->
flags, tp->t_flags);
681 if (__predict_false(inp->inp_flags2 & INP_RATE_LIMIT_CHANGED) &&
682 (update_tx_rate_limit(sc, toep, so->so_max_pacing_rate) == 0)) {
683 inp->inp_flags2 &= ~INP_RATE_LIMIT_CHANGED;
693 (
"%s: drop (%d) != 0 but tx is suspended", __func__, drop));
704 sbdrop_locked(sb, drop);
708 m = sb->sb_sndptr != NULL ? sb->sb_sndptr->m_next : sb->sb_mb;
716 sowwakeup_locked(so);
719 SOCKBUF_UNLOCK_ASSERT(sb);
728 if (m == NULL || (m->m_flags & M_NOTAVAIL) != 0) {
730 sowwakeup_locked(so);
733 SOCKBUF_UNLOCK_ASSERT(sb);
735 CTR2(
KTR_CXGBE,
"%s: tid %d no ready data to send",
736 __func__, toep->
tid);
741 KASSERT(m->m_flags & M_EXTPG, (
"%s: mbuf %p is not NOMAP",
743 KASSERT(m->m_epg_tls != NULL,
744 (
"%s: mbuf %p doesn't have TLS session", __func__, m));
752 MPASS(toep->
tls.
iv_len <= AES_BLOCK_LEN);
753 wr_len += AES_BLOCK_LEN;
756 nsegs = count_ext_pgs_segs(m);
758 ((3 * (nsegs - 1)) / 2 + ((nsegs - 1) & 1)) * 8;
761 if (howmany(wr_len, 16) > tx_credits) {
763 sowwakeup_locked(so);
766 SOCKBUF_UNLOCK_ASSERT(sb);
769 "%s: tid %d mbuf %p requires %d credits, but only %d available",
770 __func__, toep->
tid, m, howmany(wr_len, 16),
778 shove = ((m->m_next == NULL ||
779 (m->m_next->m_flags & M_NOTAVAIL) != 0)) &&
780 (tp->t_flags & TF_MORETOCOME) == 0;
782 if (sb->sb_flags & SB_AUTOSIZE &&
783 V_tcp_do_autosndbuf &&
784 sb->sb_hiwat < V_tcp_autosndbuf_max &&
785 sbused(sb) >= sb->sb_hiwat * 7 / 8) {
786 int newsize = min(sb->sb_hiwat + V_tcp_autosndbuf_inc,
787 V_tcp_autosndbuf_max);
789 if (!sbreserve_locked(sb, newsize, so, NULL))
790 sb->sb_flags &= ~SB_AUTOSIZE;
795 sowwakeup_locked(so);
798 SOCKBUF_UNLOCK_ASSERT(sb);
801 panic(
"%s: excess tx.", __func__);
810 thdr = (
struct tls_hdr *)&m->m_epg_hdr;
812 CTR5(
KTR_CXGBE,
"%s: tid %d TLS record %ju type %d len %#x",
813 __func__, toep->
tid, m->m_epg_seqno, thdr->
type,
818 memset(txwr, 0, roundup2(wr_len, 16));
819 credits = howmany(wr_len, 16);
820 expn_size = m->m_epg_hdrlen +
822 tls_size = m->m_len - expn_size;
823 write_tlstx_wr(txwr, toep, 0,
824 tls_size, expn_size, 1, credits, shove, 1);
826 write_tlstx_cpl(cpl, toep, thdr, tls_size, 1);
830 idata->
len = htobe32(0);
838 buf = (
char *)(memrd + 1);
840 buf += AES_BLOCK_LEN;
842 write_ktlstx_sgl(buf, m, nsegs);
845 (
"%s: not enough credits", __func__));
849 tp->snd_nxt += m->m_len;
850 tp->snd_max += m->m_len;
857 if (toep->
tx_credits < MIN_OFLD_TLSTX_CREDITS(toep))
860 KASSERT(toep->
txsd_avail > 0, (
"%s: no txsd", __func__));
861 txsd->
plen = m->m_len;
866 txsd = &toep->
txsd[0];
890 unsigned int tid =
GET_TID(cpl);
892 struct inpcb *inp = toep->
inp;
898 (
"%s: toep %p claims to be a synq entry", __func__, toep));
900 KASSERT(toep->
tid == tid, (
"%s: toep tid/atid mismatch", __func__));
903 m_adj(m,
sizeof(*cpl));
904 len = m->m_pkthdr.len;
909 (
"%s: payload length mismatch", __func__));
912 if (inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT)) {
913 CTR4(
KTR_CXGBE,
"%s: tid %u, rx (%d bytes), inp_flags 0x%x",
914 __func__, tid, len, inp->inp_flags);
921 m->m_pkthdr.tls_tcp_seq = be32toh(cpl->
seq);
925 panic(
"Failed to queue TLS data packet");
927 printf(
"%s: Failed to queue TLS data packet\n", __func__);
935 tp->t_rcvtime = ticks;
938 CTR4(
KTR_CXGBE,
"%s: tid %u len %d seq %u", __func__, tid, len,
952 unsigned int tid =
GET_TID(cpl);
954 struct inpcb *inp = toep->
inp;
958 struct mbuf *tls_data;
959 struct tls_get_record *tgr;
960 struct mbuf *control;
961 int pdu_length, rx_credits;
962#if defined(KTR) || defined(INVARIANTS)
966 KASSERT(toep->
tid == tid, (
"%s: toep tid/atid mismatch", __func__));
968 (
"%s: toep %p claims to be a synq entry", __func__, toep));
971 m_adj(m,
sizeof(*cpl));
972#if defined(KTR) || defined(INVARIANTS)
973 len = m->m_pkthdr.len;
979 (
"%s: payload length mismatch", __func__));
982 if (inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT)) {
983 CTR4(
KTR_CXGBE,
"%s: tid %u, rx (%d bytes), inp_flags 0x%x",
984 __func__, tid, len, inp->inp_flags);
992 so = inp_inpcbtosocket(inp);
996 CTR6(
KTR_CXGBE,
"%s: tid %u PDU len %d len %d seq %u, rcv_nxt %u",
997 __func__, tid, pdu_length, len, be32toh(cpl->
seq), tp->rcv_nxt);
1000 tp->rcv_nxt += pdu_length;
1001 KASSERT(tp->rcv_wnd >= pdu_length,
1002 (
"%s: negative window size", __func__));
1003 tp->rcv_wnd -= pdu_length;
1011 KASSERT(m->m_len >=
sizeof(*tls_hdr_pkt),
1012 (
"%s: payload too small", __func__));
1013 tls_hdr_pkt = mtod(m,
void *);
1016 if (tls_data != NULL) {
1017 KASSERT(be32toh(cpl->
seq) == tls_data->m_pkthdr.tls_tcp_seq,
1018 (
"%s: sequence mismatch", __func__));
1026 CURVNET_SET(toep->
vnet);
1027 so->so_error = EBADMSG;
1037 control = sbcreatecontrol(NULL,
sizeof(*tgr), TLS_GET_RECORD,
1039 if (control == NULL) {
1043 CURVNET_SET(toep->
vnet);
1044 so->so_error = ENOBUFS;
1053 tgr = (
struct tls_get_record *)
1054 CMSG_DATA(mtod(control,
struct cmsghdr *));
1055 memset(tgr, 0,
sizeof(*tgr));
1056 tgr->tls_type = tls_hdr_pkt->
type;
1057 tgr->tls_vmajor = be16toh(tls_hdr_pkt->
version) >> 8;
1058 tgr->tls_vminor = be16toh(tls_hdr_pkt->
version) & 0xff;
1062 if (tls_data != NULL) {
1063 m_last(tls_data)->m_flags |= M_EOR;
1064 tgr->tls_length = htobe16(tls_data->m_pkthdr.len);
1066 tgr->tls_length = 0;
1072 if (__predict_false(sb->sb_state & SBS_CANTRCVMORE)) {
1073 struct epoch_tracker et;
1075 CTR3(
KTR_CXGBE,
"%s: tid %u, excess rx (%d bytes)",
1076 __func__, tid, pdu_length);
1082 CURVNET_SET(toep->
vnet);
1083 NET_EPOCH_ENTER(et);
1085 tp = tcp_drop(tp, ECONNRESET);
1101 MPASS(toep->
vnet == so->so_vnet);
1102 CURVNET_SET(toep->
vnet);
1103 if (sb->sb_flags & SB_AUTOSIZE &&
1104 V_tcp_do_autorcvbuf &&
1105 sb->sb_hiwat < V_tcp_autorcvbuf_max &&
1106 m->m_pkthdr.len > (sbspace(sb) / 8 * 7)) {
1107 unsigned int hiwat = sb->sb_hiwat;
1109 V_tcp_autorcvbuf_max);
1111 if (!sbreserve_locked(sb, newsize, so, NULL))
1112 sb->sb_flags &= ~SB_AUTOSIZE;
1115 sbappendcontrol_locked(sb, m, control, 0);
1116 rx_credits = sbspace(sb) > tp->rcv_wnd ? sbspace(sb) - tp->rcv_wnd : 0;
1117#ifdef VERBOSE_TRACES
1118 CTR4(
KTR_CXGBE,
"%s: tid %u rx_credits %u rcv_wnd %u",
1119 __func__, tid, rx_credits, tp->rcv_wnd);
1121 if (rx_credits > 0 && sbused(sb) + tp->rcv_wnd < sb->sb_lowat) {
1123 tp->rcv_wnd += rx_credits;
1124 tp->rcv_adv += rx_credits;
1127 sorwakeup_locked(so);
1128 SOCKBUF_UNLOCK_ASSERT(sb);
1139 struct inpcb *inp = toep->
inp;
1145 int len, rx_credits;
1147 len = m->m_pkthdr.len;
1149 INP_WLOCK_ASSERT(inp);
1151 so = inp_inpcbtosocket(inp);
1152 tp = intotcpcb(inp);
1155 CURVNET_SET(toep->
vnet);
1158 KASSERT(tp->rcv_wnd >= len, (
"%s: negative window size", __func__));
1162 if (len <
sizeof(*hdr)) {
1163 CTR3(
KTR_CXGBE,
"%s: tid %u len %d: too short for a TLS header",
1164 __func__, toep->
tid, len);
1165 so->so_error = EMSGSIZE;
1168 hdr = mtod(m,
struct tls_hdr *);
1172 CTR3(
KTR_CXGBE,
"%s: tid %u invalid version %04x",
1174 so->so_error = EINVAL;
1177 if (be16toh(hdr->
length) <
sizeof(*hdr)) {
1178 CTR3(
KTR_CXGBE,
"%s: tid %u invalid length %u",
1179 __func__, toep->
tid, be16toh(hdr->
length));
1180 so->so_error = EBADMSG;
1185 if (len < be16toh(hdr->
length)) {
1186 CTR4(
KTR_CXGBE,
"%s: tid %u truncated TLS record (%d vs %u)",
1187 __func__, toep->
tid, len, be16toh(hdr->
length));
1189 so->so_error = EMSGSIZE;
1194 switch (hdr->
type) {
1201 CTR3(
KTR_CXGBE,
"%s: tid %u invalid TLS record type %u",
1202 __func__, toep->
tid, hdr->
type);
1203 so->so_error = EBADMSG;
1211 CTR4(
KTR_CXGBE,
"%s: tid %u dropping TLS record type %u, length %u",
1213 so->so_error = EBADMSG;
1220 rx_credits = sbspace(sb) > tp->rcv_wnd ? sbspace(sb) - tp->rcv_wnd : 0;
1221#ifdef VERBOSE_TRACES
1222 CTR4(
KTR_CXGBE,
"%s: tid %u rx_credits %u rcv_wnd %u",
1223 __func__, toep->
tid, rx_credits, tp->rcv_wnd);
1225 if (rx_credits > 0 && sbused(sb) + tp->rcv_wnd < sb->sb_lowat) {
1228 tp->rcv_wnd += rx_credits;
1229 tp->rcv_adv += rx_credits;
1232 sorwakeup_locked(so);
1233 SOCKBUF_UNLOCK_ASSERT(sb);
static struct wrqe * alloc_wrqe(int wr_len, struct sge_wrq *wrq)
void t4_register_cpl_handler(int, cpl_handler_t)
static void * wrtod(struct wrqe *wr)
static void t4_wrq_tx(struct adapter *sc, struct wrqe *wr)
#define DIV_ROUND_UP(x, y)
__be32 lsodisable_to_flags
u_long rx_toe_tls_records
counter_u64_t tx_toe_tls_octets
counter_u64_t tx_toe_tls_records
struct callout handshake_timer
unsigned int tx_key_info_size
unsigned short pdus_per_ulp
unsigned short adjusted_plen
unsigned short expn_per_ulp
struct conn_params params
struct sge_ofld_rxq * ofld_rxq
struct mbufq ulp_pdu_reclaimq
struct sge_ofld_txq * ofld_txq
struct ofld_tx_sdesc txsd[]
struct ulptx_sge_pair sge[]
#define SCMD_ENCDECCTRL_ENCRYPT
#define V_CPL_TX_TLS_SFO_TYPE(x)
#define V_SCMD_ENC_DEC_CTRL(x)
#define G_CPL_RX_TLS_CMP_PDULENGTH(x)
#define V_SCMD_CIPH_AUTH_SEQ_CTRL(x)
#define V_CPL_TX_TLS_SFO_DATA_TYPE(x)
#define G_CPL_TLS_DATA_LENGTH(x)
#define V_SCMD_IV_GEN_CTRL(x)
#define V_SCMD_HMAC_CTRL(x)
#define V_SCMD_CIPH_MODE(x)
#define V_SCMD_KEY_CTX_INLINE(x)
#define V_SCMD_NUM_IVS(x)
#define V_SCMD_AUTH_MODE(x)
#define V_SCMD_PROTO_VERSION(x)
#define V_CPL_TX_TLS_SFO_OPCODE(x)
#define V_CPL_TX_TLS_SFO_SEG_LEN(x)
#define V_ULP_TX_SC_MORE(x)
#define V_SCMD_SEQ_NO_CTRL(x)
#define G_CPL_RX_TLS_CMP_LENGTH(x)
#define V_SCMD_TLS_FRAG_ENABLE(x)
#define V_CPL_TX_TLS_SFO_CPL_LEN(x)
#define V_SCMD_IV_SIZE(x)
#define V_TF_TLS_CONTROL(x)
#define V_TF_TLS_ACTIVE(x)
#define V_TCB_ULP_TYPE(x)
#define V_TF_RX_QUIESCE(x)
#define M_TCB_RX_TLS_BUF_TAG
#define V_TF_TLS_KEY_SIZE(x)
#define V_TF_TLS_ENABLE(x)
#define V_TCB_RX_TLS_KEY_TAG(x)
#define W_TCB_RX_TLS_KEY_TAG
@ TLS_SFO_WR_CONTEXTLOC_DDR
#define TLS_SRV_HELLO_RD_TM
@ CPL_TX_TLS_SFO_TYPE_ALERT
@ CPL_TX_TLS_SFO_TYPE_HEARTBEAT
@ CPL_TX_TLS_SFO_TYPE_HANDSHAKE
@ CPL_TX_TLS_SFO_TYPE_DATA
@ CPL_TX_TLS_SFO_TYPE_CCS
#define CONTENT_TYPE_HEARTBEAT
#define CONTENT_TYPE_HANDSHAKE
#define TLS_SRV_HELLO_BKOFF_TM
#define CONTENT_TYPE_APP_DATA
#define CONTENT_TYPE_ALERT
#define M_TLSRX_HDR_PKT_ERROR
void tls_detach(struct toepcb *)
void * lookup_tid(struct adapter *, int)
static int ulp_mode(struct toepcb *toep)
void tls_uninit_toep(struct toepcb *)
int tls_alloc_ktls(struct toepcb *, struct ktls_session *, int)
void tls_stop_handshake_timer(struct toepcb *)
void t4_set_tcb_field(struct adapter *, struct sge_wrq *, struct toepcb *, uint16_t, uint64_t, uint64_t, int, int)
int tls_tx_key(struct toepcb *)
void t4_tls_mod_load(void)
void t4_push_ktls(struct adapter *, struct toepcb *, int)
int send_rx_credits(struct adapter *, struct toepcb *, int)
void t4_tls_mod_unload(void)
void send_rx_modulate(struct adapter *, struct toepcb *)
void do_rx_data_tls(const struct cpl_rx_data *, struct toepcb *, struct mbuf *)
void tls_establish(struct toepcb *)
int t4_close_conn(struct adapter *, struct toepcb *)
bool can_tls_offload(struct adapter *)
static struct adapter * td_adapter(struct tom_data *td)
void tls_init_toep(struct toepcb *)
static int t4_l2t_send(struct adapter *sc, struct wrqe *wr, struct l2t_entry *e)
#define V_FW_TLSTX_DATA_WR_EXP(x)
#define V_FW_TLSTX_DATA_WR_ADJUSTEDPLEN(x)
#define V_FW_TLSTX_DATA_WR_FLOWID(x)
#define V_FW_TLSTX_DATA_WR_IVDSGL(x)
#define V_FW_TLSTX_DATA_WR_EXPINPLENMAX(x)
#define V_FW_TLSTX_DATA_WR_CTXLOC(x)
#define V_FW_TLSTX_DATA_WR_IMMDLEN(x)
#define V_FW_TLSTX_DATA_WR_LEN16(x)
#define V_FW_TLSTX_DATA_WR_COMPL(x)
#define V_FW_TLSTX_DATA_WR_NUMIVS(x)
#define V_FW_TLSTX_DATA_WR_KEYSIZE(x)
#define V_FW_TLSTX_DATA_WR_PDUSINPLENMAX(x)