X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_core%2Ftf_msg.c;h=0fbb2fe837631c5a73bb499a4157fe95d0d7e796;hb=53a80512644c8a12cb8efc903f77dd7b42263565;hp=be30d4a09f3aff2804212721e25e452111167b5c;hpb=acd38b0a8a84153b373455efa674464990405d89;p=dpdk.git diff --git a/drivers/net/bnxt/tf_core/tf_msg.c b/drivers/net/bnxt/tf_core/tf_msg.c index be30d4a09f..0fbb2fe837 100644 --- a/drivers/net/bnxt/tf_core/tf_msg.c +++ b/drivers/net/bnxt/tf_core/tf_msg.c @@ -9,6 +9,7 @@ #include #include +#include "tf_em_common.h" #include "tf_msg_common.h" #include "tf_device.h" #include "tf_msg.h" @@ -16,7 +17,6 @@ #include "tf_common.h" #include "tf_session.h" #include "tfp.h" -#include "hwrm_tf.h" #include "tf_em.h" /* Specific msg size defines as we cannot use defines in tf.yaml. This @@ -25,6 +25,7 @@ */ #define TF_MSG_SET_GLOBAL_CFG_DATA_SIZE 16 #define TF_MSG_EM_INSERT_KEY_SIZE 64 +#define TF_MSG_EM_INSERT_RECORD_SIZE 80 #define TF_MSG_TBL_TYPE_SET_DATA_SIZE 88 /* Compile check - Catch any msg changes that we depend on, like the @@ -57,6 +58,16 @@ static_assert(sizeof(struct hwrm_tf_tbl_type_set_input) == */ #define TF_PCI_BUF_SIZE_MAX 88 +/** + * This is the length of shared session name "tf_share" + */ +#define TF_SHARED_SESSION_NAME_LEN 8 + +/** + * This is the length of tcam shared session name "tf_shared-wc_tcam" + */ +#define TF_TCAM_SHARED_SESSION_NAME_LEN 17 + /** * If data bigger than TF_PCI_BUF_SIZE_MAX then use DMA method */ @@ -113,19 +124,31 @@ tf_msg_free_dma_buf(struct tf_msg_dma_buf *buf) /* HWRM Direct messages */ int -tf_msg_session_open(struct tf *tfp, +tf_msg_session_open(struct bnxt *bp, char *ctrl_chan_name, uint8_t *fw_session_id, uint8_t *fw_session_client_id, - struct tf_dev_info *dev) + struct tf_dev_info *dev, + bool *shared_session_creator) { int rc; struct hwrm_tf_session_open_input req = { 0 }; struct hwrm_tf_session_open_output resp = { 0 }; struct tfp_send_msg_parms parms = { 0 }; + int name_len; + char *session_name; + char *tcam_session_name; /* Populate the request */ - tfp_memcpy(&req.session_name, ctrl_chan_name, TF_SESSION_NAME_MAX); + name_len = strnlen(ctrl_chan_name, TF_SESSION_NAME_MAX); + session_name = &ctrl_chan_name[name_len - strlen("tf_shared")]; + tcam_session_name = &ctrl_chan_name[name_len - strlen("tf_shared-wc_tcam")]; + if (!strncmp(tcam_session_name, "tf_shared-wc_tcam", strlen("tf_shared-wc_tcam"))) + tfp_memcpy(&req.session_name, tcam_session_name, TF_TCAM_SHARED_SESSION_NAME_LEN); + else if (!strncmp(session_name, "tf_shared", strlen("tf_shared"))) + tfp_memcpy(&req.session_name, session_name, TF_SHARED_SESSION_NAME_LEN); + else + tfp_memcpy(&req.session_name, ctrl_chan_name, TF_SESSION_NAME_MAX); parms.tf_type = HWRM_TF_SESSION_OPEN; parms.req_data = (uint32_t *)&req; @@ -134,7 +157,7 @@ tf_msg_session_open(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(bp, &parms); if (rc) return rc; @@ -142,6 +165,8 @@ tf_msg_session_open(struct tf *tfp, *fw_session_id = (uint8_t)tfp_le_to_cpu_32(resp.fw_session_id); *fw_session_client_id = (uint8_t)tfp_le_to_cpu_32(resp.fw_session_client_id); + *shared_session_creator = (bool)tfp_le_to_cpu_32(resp.flags + & HWRM_TF_SESSION_OPEN_OUTPUT_FLAGS_SHARED_SESSION_CREATOR); return rc; } @@ -166,6 +191,9 @@ tf_msg_session_client_register(struct tf *tfp, struct tfp_send_msg_parms parms = { 0 }; uint8_t fw_session_id; struct tf_dev_info *dev; + int name_len; + char *session_name; + char *tcam_session_name; /* Retrieve the device information */ rc = tf_session_get_device(tfs, &dev); @@ -186,9 +214,24 @@ tf_msg_session_client_register(struct tf *tfp, /* Populate the request */ req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); - tfp_memcpy(&req.session_client_name, - ctrl_channel_name, - TF_SESSION_NAME_MAX); + name_len = strnlen(ctrl_channel_name, TF_SESSION_NAME_MAX); + session_name = &ctrl_channel_name[name_len - strlen("tf_shared")]; + tcam_session_name = &ctrl_channel_name[name_len - + strlen("tf_shared-wc_tcam")]; + if (!strncmp(tcam_session_name, + "tf_shared-wc_tcam", + strlen("tf_shared-wc_tcam"))) + tfp_memcpy(&req.session_client_name, + tcam_session_name, + TF_TCAM_SHARED_SESSION_NAME_LEN); + else if (!strncmp(session_name, "tf_shared", strlen("tf_shared"))) + tfp_memcpy(&req.session_client_name, + session_name, + TF_SHARED_SESSION_NAME_LEN); + else + tfp_memcpy(&req.session_client_name, + ctrl_channel_name, + TF_SESSION_NAME_MAX); parms.tf_type = HWRM_TF_SESSION_REGISTER; parms.req_data = (uint32_t *)&req; @@ -197,7 +240,7 @@ tf_msg_session_client_register(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; @@ -248,7 +291,7 @@ tf_msg_session_client_unregister(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; @@ -256,31 +299,13 @@ tf_msg_session_client_unregister(struct tf *tfp, int tf_msg_session_close(struct tf *tfp, - struct tf_session *tfs) + uint8_t fw_session_id, + int mailbox) { int rc; struct hwrm_tf_session_close_input req = { 0 }; struct hwrm_tf_session_close_output resp = { 0 }; struct tfp_send_msg_parms parms = { 0 }; - uint8_t fw_session_id; - struct tf_dev_info *dev; - - /* Retrieve the device information */ - rc = tf_session_get_device(tfs, &dev); - if (rc) { - TFP_DRV_LOG(ERR, - "Failed to lookup device, rc:%s\n", - strerror(-rc)); - return rc; - } - - rc = tf_session_get_fw_session_id(tfp, &fw_session_id); - if (rc) { - TFP_DRV_LOG(ERR, - "Unable to lookup FW id, rc:%s\n", - strerror(-rc)); - return rc; - } /* Populate the request */ req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); @@ -290,9 +315,9 @@ tf_msg_session_close(struct tf *tfp, parms.req_size = sizeof(req); parms.resp_data = (uint32_t *)&resp; parms.resp_size = sizeof(resp); - parms.mailbox = dev->ops->tf_dev_get_mailbox(); + parms.mailbox = mailbox; - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -344,7 +369,7 @@ tf_msg_session_qcfg(struct tf *tfp) parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -366,6 +391,16 @@ tf_msg_session_resc_qcaps(struct tf *tfp, struct tf_msg_dma_buf qcaps_buf = { 0 }; struct tf_rm_resc_req_entry *data; int dma_size; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } TF_CHECK_PARMS3(tfp, query, resv_strategy); @@ -397,7 +432,7 @@ tf_msg_session_resc_qcaps(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) goto cleanup; @@ -405,17 +440,18 @@ tf_msg_session_resc_qcaps(struct tf *tfp, * Should always get expected number of entries */ if (tfp_le_to_cpu_32(resp.size) != size) { - TFP_DRV_LOG(ERR, - "%s: QCAPS message size error, rc:%s\n", + TFP_DRV_LOG(WARNING, + "%s: QCAPS message size error, rc:%s, request %d vs response %d\n", tf_dir_2_str(dir), - strerror(EINVAL)); - rc = -EINVAL; - goto cleanup; + strerror(EINVAL), + size, + resp.size); } /* Post process the response */ data = (struct tf_rm_resc_req_entry *)qcaps_buf.va_addr; - for (i = 0; i < size; i++) { + + for (i = 0; i < resp.size; i++) { query[i].type = tfp_le_to_cpu_32(data[i].type); query[i].min = tfp_le_to_cpu_16(data[i].min); query[i].max = tfp_le_to_cpu_16(data[i].max); @@ -449,6 +485,16 @@ tf_msg_session_resc_alloc(struct tf *tfp, struct tf_rm_resc_req_entry *req_data; struct tf_rm_resc_entry *resv_data; int dma_size; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } TF_CHECK_PARMS3(tfp, request, resv); @@ -496,7 +542,114 @@ tf_msg_session_resc_alloc(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); + if (rc) + goto cleanup; + + /* Process the response + * Should always get expected number of entries + */ + if (tfp_le_to_cpu_32(resp.size) != size) { + TFP_DRV_LOG(ERR, + "%s: Alloc message size error, rc:%s\n", + tf_dir_2_str(dir), + strerror(EINVAL)); + rc = -EINVAL; + goto cleanup; + } + + /* Post process the response */ + resv_data = (struct tf_rm_resc_entry *)resv_buf.va_addr; + for (i = 0; i < size; i++) { + resv[i].type = tfp_le_to_cpu_32(resv_data[i].type); + resv[i].start = tfp_le_to_cpu_16(resv_data[i].start); + resv[i].stride = tfp_le_to_cpu_16(resv_data[i].stride); + } + +cleanup: + tf_msg_free_dma_buf(&req_buf); + tf_msg_free_dma_buf(&resv_buf); + + return rc; +} + +int +tf_msg_session_resc_info(struct tf *tfp, + struct tf_dev_info *dev, + enum tf_dir dir, + uint16_t size, + struct tf_rm_resc_req_entry *request, + struct tf_rm_resc_entry *resv) +{ + int rc; + int i; + struct tfp_send_msg_parms parms = { 0 }; + struct hwrm_tf_session_resc_info_input req = { 0 }; + struct hwrm_tf_session_resc_info_output resp = { 0 }; + uint8_t fw_session_id; + struct tf_msg_dma_buf req_buf = { 0 }; + struct tf_msg_dma_buf resv_buf = { 0 }; + struct tf_rm_resc_req_entry *req_data; + struct tf_rm_resc_entry *resv_data; + int dma_size; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } + + TF_CHECK_PARMS3(tfp, request, resv); + + rc = tf_session_get_fw_session_id(tfp, &fw_session_id); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Unable to lookup FW id, rc:%s\n", + tf_dir_2_str(dir), + strerror(-rc)); + return rc; + } + + /* Prepare DMA buffers */ + dma_size = size * sizeof(struct tf_rm_resc_req_entry); + rc = tf_msg_alloc_dma_buf(&req_buf, dma_size); + if (rc) + return rc; + + dma_size = size * sizeof(struct tf_rm_resc_entry); + rc = tf_msg_alloc_dma_buf(&resv_buf, dma_size); + if (rc) { + tf_msg_free_dma_buf(&req_buf); + return rc; + } + + /* Populate the request */ + req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); + req.flags = tfp_cpu_to_le_16(dir); + req.req_size = size; + + req_data = (struct tf_rm_resc_req_entry *)req_buf.va_addr; + for (i = 0; i < size; i++) { + req_data[i].type = tfp_cpu_to_le_32(request[i].type); + req_data[i].min = tfp_cpu_to_le_16(request[i].min); + req_data[i].max = tfp_cpu_to_le_16(request[i].max); + } + + req.req_addr = tfp_cpu_to_le_64(req_buf.pa_addr); + req.resc_addr = tfp_cpu_to_le_64(resv_buf.pa_addr); + + parms.tf_type = HWRM_TF_SESSION_RESC_INFO; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) goto cleanup; @@ -603,7 +756,7 @@ tf_msg_session_resc_flush(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); tf_msg_free_dma_buf(&resv_buf); @@ -629,6 +782,9 @@ tf_msg_insert_em_internal_entry(struct tf *tfp, struct tf_dev_info *dev; struct tf_session *tfs; + RTE_BUILD_BUG_ON(sizeof(struct hwrm_tf_em_insert_input) != + TF_MSG_SIZE_HWRM_TF_EM_INSERT); + /* Retrieve the session information */ rc = tf_session_get_session_internal(tfp, &tfs); if (rc) { @@ -694,7 +850,102 @@ tf_msg_insert_em_internal_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), + &parms); + if (rc) + return rc; + + *rptr_entry = resp.rptr_entry; + *rptr_index = resp.rptr_index; + *num_of_entries = resp.num_of_entries; + + return 0; +} + +int +tf_msg_hash_insert_em_internal_entry(struct tf *tfp, + struct tf_insert_em_entry_parms *em_parms, + uint32_t key0_hash, + uint32_t key1_hash, + uint16_t *rptr_index, + uint8_t *rptr_entry, + uint8_t *num_of_entries) +{ + int rc; + struct tfp_send_msg_parms parms = { 0 }; + struct hwrm_tf_em_hash_insert_input req = { 0 }; + struct hwrm_tf_em_hash_insert_output resp = { 0 }; + uint16_t flags; + uint8_t fw_session_id; + uint8_t msg_record_size; + struct tf_dev_info *dev; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup device, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + rc = tf_session_get_fw_session_id(tfp, &fw_session_id); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Unable to lookup FW id, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + /* Populate the request */ + req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); + + /* Check for key size conformity */ + msg_record_size = (em_parms->em_record_sz_in_bits + 7) / 8; + + if (msg_record_size > TF_MSG_EM_INSERT_RECORD_SIZE) { + rc = -EINVAL; + TFP_DRV_LOG(ERR, + "%s: Record size to large, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + tfp_memcpy((char *)req.em_record, + em_parms->em_record, + msg_record_size); + + flags = (em_parms->dir == TF_DIR_TX ? + HWRM_TF_EM_INSERT_INPUT_FLAGS_DIR_TX : + HWRM_TF_EM_INSERT_INPUT_FLAGS_DIR_RX); + req.flags = tfp_cpu_to_le_16(flags); + req.em_record_size_bits = em_parms->em_record_sz_in_bits; + req.em_record_idx = *rptr_index; + req.key0_hash = key0_hash; + req.key1_hash = key1_hash; + + parms.tf_type = HWRM_TF_EM_HASH_INSERT; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; @@ -764,7 +1015,7 @@ tf_msg_delete_em_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; @@ -774,6 +1025,186 @@ tf_msg_delete_em_entry(struct tf *tfp, return 0; } +int +tf_msg_move_em_entry(struct tf *tfp, + struct tf_move_em_entry_parms *em_parms) +{ + int rc; + struct tfp_send_msg_parms parms = { 0 }; + struct hwrm_tf_em_move_input req = { 0 }; + struct hwrm_tf_em_move_output resp = { 0 }; + uint16_t flags; + uint8_t fw_session_id; + struct tf_dev_info *dev; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup device, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + rc = tf_session_get_fw_session_id(tfp, &fw_session_id); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Unable to lookup FW id, rc:%s\n", + tf_dir_2_str(em_parms->dir), + strerror(-rc)); + return rc; + } + + /* Populate the request */ + req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); + + flags = (em_parms->dir == TF_DIR_TX ? + HWRM_TF_EM_DELETE_INPUT_FLAGS_DIR_TX : + HWRM_TF_EM_DELETE_INPUT_FLAGS_DIR_RX); + req.flags = tfp_cpu_to_le_16(flags); + req.flow_handle = tfp_cpu_to_le_64(em_parms->flow_handle); + req.new_index = tfp_cpu_to_le_32(em_parms->new_index); + + parms.tf_type = HWRM_TF_EM_MOVE; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), + &parms); + if (rc) + return rc; + + em_parms->index = tfp_le_to_cpu_16(resp.em_index); + + return 0; +} + +int tf_msg_ext_em_ctxt_mem_alloc(struct tf *tfp, + struct hcapi_cfa_em_table *tbl, + uint64_t *dma_addr, + uint32_t *page_lvl, + uint32_t *page_size) +{ + struct tfp_send_msg_parms parms = { 0 }; + struct hwrm_tf_ctxt_mem_alloc_input req = {0}; + struct hwrm_tf_ctxt_mem_alloc_output resp = {0}; + uint32_t mem_size_k; + int rc = 0; + struct tf_dev_info *dev; + struct tf_session *tfs; + uint32_t fw_se_id; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup device, rc:%s\n", + strerror(-rc)); + return rc; + } + /* Retrieve the session information */ + fw_se_id = tfs->session_id.internal.fw_session_id; + + if (tbl->num_entries && tbl->entry_size) { + /* unit: kbytes */ + mem_size_k = (tbl->num_entries / TF_KILOBYTE) * tbl->entry_size; + req.mem_size = tfp_cpu_to_le_32(mem_size_k); + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); + parms.tf_type = HWRM_TF_CTXT_MEM_ALLOC; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); + if (rc) { + TFP_DRV_LOG(ERR, "Failed ext_em_alloc error rc:%s\n", + strerror(-rc)); + return rc; + } + + *dma_addr = tfp_le_to_cpu_64(resp.page_dir); + *page_lvl = resp.page_level; + *page_size = resp.page_size; + } + + return rc; +} + +int tf_msg_ext_em_ctxt_mem_free(struct tf *tfp, + uint32_t mem_size_k, + uint64_t dma_addr, + uint8_t page_level, + uint8_t page_size) +{ + struct tfp_send_msg_parms parms = { 0 }; + struct hwrm_tf_ctxt_mem_free_input req = {0}; + struct hwrm_tf_ctxt_mem_free_output resp = {0}; + int rc = 0; + struct tf_dev_info *dev; + struct tf_session *tfs; + uint32_t fw_se_id; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup device, rc:%s\n", + strerror(-rc)); + return rc; + } + /* Retrieve the session information */ + fw_se_id = tfs->session_id.internal.fw_session_id; + + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); + req.mem_size = tfp_cpu_to_le_32(mem_size_k); + req.page_dir = tfp_cpu_to_le_64(dma_addr); + req.page_level = page_level; + req.page_size = page_size; + parms.tf_type = HWRM_TF_CTXT_MEM_FREE; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); + + return rc; +} + int tf_msg_em_mem_rgtr(struct tf *tfp, int page_lvl, @@ -787,6 +1218,7 @@ tf_msg_em_mem_rgtr(struct tf *tfp, struct tfp_send_msg_parms parms = { 0 }; struct tf_dev_info *dev; struct tf_session *tfs; + uint32_t fw_se_id; /* Retrieve the session information */ rc = tf_session_get_session_internal(tfp, &tfs); @@ -805,7 +1237,9 @@ tf_msg_em_mem_rgtr(struct tf *tfp, strerror(-rc)); return rc; } + fw_se_id = tfs->session_id.internal.fw_session_id; + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); req.page_level = page_lvl; req.page_size = page_size; req.page_dir = tfp_cpu_to_le_64(dma_addr); @@ -817,7 +1251,7 @@ tf_msg_em_mem_rgtr(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; @@ -837,6 +1271,7 @@ tf_msg_em_mem_unrgtr(struct tf *tfp, struct tfp_send_msg_parms parms = { 0 }; struct tf_dev_info *dev; struct tf_session *tfs; + uint32_t fw_se_id; /* Retrieve the session information */ rc = tf_session_get_session_internal(tfp, &tfs); @@ -856,6 +1291,9 @@ tf_msg_em_mem_unrgtr(struct tf *tfp, return rc; } + fw_se_id = tfs->session_id.internal.fw_session_id; + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); + req.ctx_id = tfp_cpu_to_le_32(*ctx_id); parms.tf_type = HWRM_TF_CTXT_MEM_UNRGTR; @@ -865,7 +1303,7 @@ tf_msg_em_mem_unrgtr(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -882,6 +1320,7 @@ tf_msg_em_qcaps(struct tf *tfp, struct tfp_send_msg_parms parms = { 0 }; struct tf_dev_info *dev; struct tf_session *tfs; + uint32_t fw_se_id; /* Retrieve the session information */ rc = tf_session_get_session_internal(tfp, &tfs); @@ -892,6 +1331,7 @@ tf_msg_em_qcaps(struct tf *tfp, strerror(-rc)); return rc; } + fw_se_id = tfs->session_id.internal.fw_session_id; /* Retrieve the device information */ rc = tf_session_get_device(tfs, &dev); @@ -908,13 +1348,14 @@ tf_msg_em_qcaps(struct tf *tfp, req.flags = tfp_cpu_to_le_32(flags); parms.tf_type = HWRM_TF_EXT_EM_QCAPS; + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); parms.req_data = (uint32_t *)&req; parms.req_size = sizeof(req); parms.resp_data = (uint32_t *)&resp; parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; @@ -989,7 +1430,81 @@ tf_msg_em_cfg(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), + &parms); + return rc; +} + +int +tf_msg_ext_em_cfg(struct tf *tfp, + struct tf_tbl_scope_cb *tbl_scope_cb, + uint32_t st_buckets, + uint8_t flush_interval, + enum tf_dir dir) +{ + struct hcapi_cfa_em_ctx_mem_info *ctxp = &tbl_scope_cb->em_ctx_info[dir]; + struct hcapi_cfa_em_table *lkup_tbl, *act_tbl; + struct hwrm_tf_ext_em_cfg_input req = {0}; + struct hwrm_tf_ext_em_cfg_output resp = {0}; + struct tfp_send_msg_parms parms = { 0 }; + uint32_t flags; + struct tf_dev_info *dev; + struct tf_session *tfs; + uint32_t fw_se_id; + int rc; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(dir), + strerror(-rc)); + return rc; + } + + /* Retrieve the device information */ + rc = tf_session_get_device(tfs, &dev); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup device, rc:%s\n", + tf_dir_2_str(dir), + strerror(-rc)); + return rc; + } + fw_se_id = tfs->session_id.internal.fw_session_id; + + lkup_tbl = &ctxp->em_tables[TF_EM_LKUP_TABLE]; + act_tbl = &ctxp->em_tables[TF_ACTION_TABLE]; + flags = (dir == TF_DIR_TX ? HWRM_TF_EXT_EM_CFG_INPUT_FLAGS_DIR_TX : + HWRM_TF_EXT_EM_CFG_INPUT_FLAGS_DIR_RX); + flags |= HWRM_TF_EXT_EM_QCAPS_INPUT_FLAGS_PREFERRED_OFFLOAD; + + req.flags = tfp_cpu_to_le_32(flags); + req.num_entries = tfp_cpu_to_le_32(act_tbl->num_entries); + req.lkup_static_buckets = tfp_cpu_to_le_32(st_buckets); + req.fw_session_id = tfp_cpu_to_le_32(fw_se_id); + req.flush_interval = flush_interval; + req.action_ctx_id = tfp_cpu_to_le_16(act_tbl->ctx_id); + req.action_tbl_scope = tfp_cpu_to_le_16(tbl_scope_cb->tbl_scope_id); + req.lkup_ctx_id = tfp_cpu_to_le_16(lkup_tbl->ctx_id); + req.lkup_tbl_scope = tfp_cpu_to_le_16(tbl_scope_cb->tbl_scope_id); + + req.enables = (HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_ACTION_CTX_ID | + HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_ACTION_TBL_SCOPE | + HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_LKUP_CTX_ID | + HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_LKUP_TBL_SCOPE | + HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_LKUP_STATIC_BUCKETS | + HWRM_TF_EXT_EM_CFG_INPUT_ENABLES_NUM_ENTRIES); + + parms.tf_type = HWRM_TF_EXT_EM_CFG; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); + + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -1039,7 +1554,7 @@ tf_msg_em_op(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -1057,6 +1572,16 @@ tf_msg_tcam_entry_set(struct tf *tfp, uint8_t *data = NULL; int data_size = 0; uint8_t fw_session_id; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } rc = tf_session_get_fw_session_id(tfp, &fw_session_id); if (rc) { @@ -1107,7 +1632,7 @@ tf_msg_tcam_entry_set(struct tf *tfp, mparms.resp_size = sizeof(resp); mparms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &mparms); cleanup: @@ -1116,6 +1641,76 @@ cleanup: return rc; } +int +tf_msg_tcam_entry_get(struct tf *tfp, + struct tf_dev_info *dev, + struct tf_tcam_get_parms *parms) +{ + int rc; + struct tfp_send_msg_parms mparms = { 0 }; + struct hwrm_tf_tcam_get_input req = { 0 }; + struct hwrm_tf_tcam_get_output resp = { 0 }; + uint8_t fw_session_id; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } + + rc = tf_session_get_fw_session_id(tfp, &fw_session_id); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Unable to lookup FW id, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + /* Populate the request */ + req.fw_session_id = tfp_cpu_to_le_32(fw_session_id); + req.type = parms->hcapi_type; + req.idx = tfp_cpu_to_le_16(parms->idx); + if (parms->dir == TF_DIR_TX) + req.flags |= HWRM_TF_TCAM_GET_INPUT_FLAGS_DIR_TX; + + mparms.tf_type = HWRM_TF_TCAM_GET; + mparms.req_data = (uint32_t *)&req; + mparms.req_size = sizeof(req); + mparms.resp_data = (uint32_t *)&resp; + mparms.resp_size = sizeof(resp); + mparms.mailbox = dev->ops->tf_dev_get_mailbox(); + + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), + &mparms); + + if (rc != 0) + return rc; + + if (parms->key_size < resp.key_size || + parms->result_size < resp.result_size) { + rc = -EINVAL; + TFP_DRV_LOG(ERR, + "%s: Key buffer(%d) is smaller than the key(%d), rc:%s\n", + tf_dir_2_str(parms->dir), + parms->key_size, + resp.key_size, + strerror(-rc)); + return rc; + } + parms->key_size = resp.key_size; + parms->result_size = resp.result_size; + tfp_memcpy(parms->key, resp.dev_data, resp.key_size); + tfp_memcpy(parms->mask, &resp.dev_data[resp.key_size], resp.key_size); + tfp_memcpy(parms->result, &resp.dev_data[resp.result_offset], resp.result_size); + + return 0; +} + int tf_msg_tcam_entry_free(struct tf *tfp, struct tf_dev_info *dev, @@ -1126,6 +1721,16 @@ tf_msg_tcam_entry_free(struct tf *tfp, struct hwrm_tf_tcam_free_output resp = { 0 }; struct tfp_send_msg_parms parms = { 0 }; uint8_t fw_session_id; + struct tf_session *tfs; + + /* Retrieve the session information */ + rc = tf_session_get_session_internal(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "Failed to lookup session, rc:%s\n", + strerror(-rc)); + return rc; + } rc = tf_session_get_fw_session_id(tfp, &fw_session_id); if (rc) { @@ -1151,7 +1756,7 @@ tf_msg_tcam_entry_free(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); return rc; } @@ -1172,6 +1777,9 @@ tf_msg_set_tbl_entry(struct tf *tfp, struct tf_dev_info *dev; struct tf_session *tfs; + RTE_BUILD_BUG_ON(sizeof(struct hwrm_tf_tbl_type_set_input) != + TF_MSG_SIZE_HWRM_TF_TBL_TYPE_SET); + /* Retrieve the session information */ rc = tf_session_get_session_internal(tfp, &tfs); if (rc) { @@ -1229,12 +1837,12 @@ tf_msg_set_tbl_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } int @@ -1295,20 +1903,27 @@ tf_msg_get_tbl_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc) return rc; - /* Verify that we got enough buffer to return the requested data */ - if (tfp_le_to_cpu_32(resp.size) != size) + /* + * The response will be 64 bytes long, the response size will + * be in words (16). All we can test for is that the response + * size is < to the requested size. + */ + if ((tfp_le_to_cpu_32(resp.size) * 4) < size) return -EINVAL; + /* + * Copy the requested number of bytes + */ tfp_memcpy(data, &resp.data, size); - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } /* HWRM Tunneled messages */ @@ -1374,7 +1989,7 @@ tf_msg_get_global_cfg(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc != 0) return rc; @@ -1390,7 +2005,7 @@ tf_msg_get_global_cfg(struct tf *tfp, else return -EFAULT; - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } int @@ -1475,12 +2090,12 @@ tf_msg_set_global_cfg(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc != 0) return rc; - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } int @@ -1494,8 +2109,8 @@ tf_msg_bulk_get_tbl_entry(struct tf *tfp, { int rc; struct tfp_send_msg_parms parms = { 0 }; - struct tf_tbl_type_bulk_get_input req = { 0 }; - struct tf_tbl_type_bulk_get_output resp = { 0 }; + struct hwrm_tf_tbl_type_bulk_get_input req = { 0 }; + struct hwrm_tf_tbl_type_bulk_get_output resp = { 0 }; int data_size = 0; uint8_t fw_session_id; struct tf_dev_info *dev; @@ -1541,14 +2156,15 @@ tf_msg_bulk_get_tbl_entry(struct tf *tfp, req.host_addr = tfp_cpu_to_le_64(physical_mem_addr); - MSG_PREP(parms, - dev->ops->tf_dev_get_mailbox(), - HWRM_TF, - HWRM_TFT_TBL_TYPE_BULK_GET, - req, - resp); + parms.tf_type = HWRM_TF_TBL_TYPE_BULK_GET; + parms.req_data = (uint32_t *)&req; + parms.req_size = sizeof(req); + parms.resp_data = (uint32_t *)&resp; + parms.resp_size = sizeof(resp); + parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_tunneled(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), + &parms); if (rc) return rc; @@ -1556,7 +2172,7 @@ tf_msg_bulk_get_tbl_entry(struct tf *tfp, if (tfp_le_to_cpu_32(resp.size) != data_size) return -EINVAL; - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } int @@ -1610,17 +2226,14 @@ tf_msg_get_if_tbl_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc != 0) return rc; - if (parms.tf_resp_code != 0) - return tfp_le_to_cpu_32(parms.tf_resp_code); + tfp_memcpy(¶ms->data[0], resp.data, req.size); - tfp_memcpy(params->data, resp.data, req.size); - - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; } int @@ -1670,10 +2283,10 @@ tf_msg_set_if_tbl_entry(struct tf *tfp, parms.resp_size = sizeof(resp); parms.mailbox = dev->ops->tf_dev_get_mailbox(); - rc = tfp_send_msg_direct(tfp, &parms); + rc = tfp_send_msg_direct(tf_session_get_bp(tfp), &parms); if (rc != 0) return rc; - return tfp_le_to_cpu_32(parms.tf_resp_code); + return 0; }