X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_core%2Ftf_core.c;h=0dbde1de2d0c3d4ae756fd69e46997eae6ee5141;hb=7ecfe8521fbb6a845f08a6b178676d1d6c5a7802;hp=3e23d0513ba51420c64fd7c54b68daa422a25b2b;hpb=48d3dff2b98680c6315593e8b6495b64e678b004;p=dpdk.git diff --git a/drivers/net/bnxt/tf_core/tf_core.c b/drivers/net/bnxt/tf_core/tf_core.c index 3e23d0513b..0dbde1de2d 100644 --- a/drivers/net/bnxt/tf_core/tf_core.c +++ b/drivers/net/bnxt/tf_core/tf_core.c @@ -11,6 +11,7 @@ #include "tf_tbl.h" #include "tf_em.h" #include "tf_rm.h" +#include "tf_global_cfg.h" #include "tf_msg.h" #include "tfp.h" #include "bitalloc.h" @@ -48,9 +49,22 @@ tf_open_session(struct tf *tfp, &slot, &device); if (rc != 4) { - TFP_DRV_LOG(ERR, + /* PCI Domain not provided (optional in DPDK), thus we + * force domain to 0 and recheck. + */ + domain = 0; + + /* Check parsing of bus/slot/device */ + rc = sscanf(parms->ctrl_chan_name, + "%x:%x.%d", + &bus, + &slot, + &device); + if (rc != 3) { + TFP_DRV_LOG(ERR, "Failed to scan device ctrl_chan_name\n"); - return -EINVAL; + return -EINVAL; + } } parms->session_id.internal.domain = domain; @@ -58,21 +72,19 @@ tf_open_session(struct tf *tfp, parms->session_id.internal.device = device; oparms.open_cfg = parms; + /* Session vs session client is decided in + * tf_session_open_session() + */ rc = tf_session_open_session(tfp, &oparms); /* Logging handled by tf_session_open_session */ if (rc) return rc; TFP_DRV_LOG(INFO, - "Session created, session_id:%d\n", - parms->session_id.id); - - TFP_DRV_LOG(INFO, - "domain:%d, bus:%d, device:%d, fw_session_id:%d\n", + "domain:%d, bus:%d, device:%d\n", parms->session_id.internal.domain, parms->session_id.internal.bus, - parms->session_id.internal.device, - parms->session_id.internal.fw_session_id); + parms->session_id.internal.device); return 0; } @@ -152,6 +164,9 @@ tf_close_session(struct tf *tfp) cparms.ref_count = &ref_count; cparms.session_id = &session_id; + /* Session vs session client is decided in + * tf_session_close_session() + */ rc = tf_session_close_session(tfp, &cparms); /* Logging handled by tf_session_close_session */ @@ -159,16 +174,10 @@ tf_close_session(struct tf *tfp) return rc; TFP_DRV_LOG(INFO, - "Closed session, session_id:%d, ref_count:%d\n", - cparms.session_id->id, - *cparms.ref_count); - - TFP_DRV_LOG(INFO, - "domain:%d, bus:%d, device:%d, fw_session_id:%d\n", + "domain:%d, bus:%d, device:%d\n", cparms.session_id->internal.domain, cparms.session_id->internal.bus, - cparms.session_id->internal.device, - cparms.session_id->internal.fw_session_id); + cparms.session_id->internal.device); return rc; } @@ -186,7 +195,7 @@ int tf_insert_em_entry(struct tf *tfp, struct tf_dev_info *dev; int rc; - TF_CHECK_PARMS_SESSION(tfp, parms); + TF_CHECK_PARMS2(tfp, parms); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -208,7 +217,15 @@ int tf_insert_em_entry(struct tf *tfp, return rc; } - rc = dev->ops->tf_dev_insert_em_entry(tfp, parms); + if (parms->mem == TF_MEM_EXTERNAL && + dev->ops->tf_dev_insert_ext_em_entry != NULL) + rc = dev->ops->tf_dev_insert_ext_em_entry(tfp, parms); + else if (parms->mem == TF_MEM_INTERNAL && + dev->ops->tf_dev_insert_int_em_entry != NULL) + rc = dev->ops->tf_dev_insert_int_em_entry(tfp, parms); + else + return -EINVAL; + if (rc) { TFP_DRV_LOG(ERR, "%s: EM insert failed, rc:%s\n", @@ -217,7 +234,7 @@ int tf_insert_em_entry(struct tf *tfp, return rc; } - return -EINVAL; + return 0; } /** Delete EM hash entry API @@ -233,7 +250,7 @@ int tf_delete_em_entry(struct tf *tfp, struct tf_dev_info *dev; int rc; - TF_CHECK_PARMS_SESSION(tfp, parms); + TF_CHECK_PARMS2(tfp, parms); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -255,7 +272,13 @@ int tf_delete_em_entry(struct tf *tfp, return rc; } - rc = dev->ops->tf_dev_delete_em_entry(tfp, parms); + if (parms->mem == TF_MEM_EXTERNAL) + rc = dev->ops->tf_dev_delete_ext_em_entry(tfp, parms); + else if (parms->mem == TF_MEM_INTERNAL) + rc = dev->ops->tf_dev_delete_int_em_entry(tfp, parms); + else + return -EINVAL; + if (rc) { TFP_DRV_LOG(ERR, "%s: EM delete failed, rc:%s\n", @@ -267,21 +290,22 @@ int tf_delete_em_entry(struct tf *tfp, return rc; } -int -tf_alloc_identifier(struct tf *tfp, - struct tf_alloc_identifier_parms *parms) +/** Get global configuration API + * + * returns: + * 0 - Success + * -EINVAL - Error + */ +int tf_get_global_cfg(struct tf *tfp, + struct tf_global_cfg_parms *parms) { - int rc; + int rc = 0; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_ident_alloc_parms aparms; - uint16_t id; + struct tf_dev_global_cfg_parms gparms = { 0 }; TF_CHECK_PARMS2(tfp, parms); - /* Can't do static initialization due to UT enum check */ - memset(&aparms, 0, sizeof(struct tf_ident_alloc_parms)); - /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -302,7 +326,13 @@ tf_alloc_identifier(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_alloc_ident == NULL) { + if (parms->config == NULL || + parms->config_sz_in_bytes == 0) { + TFP_DRV_LOG(ERR, "Invalid Argument(s)\n"); + return -EINVAL; + } + + if (dev->ops->tf_dev_get_global_cfg == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", @@ -311,37 +341,39 @@ tf_alloc_identifier(struct tf *tfp, return -EOPNOTSUPP; } - aparms.dir = parms->dir; - aparms.type = parms->ident_type; - aparms.id = &id; - rc = dev->ops->tf_dev_alloc_ident(tfp, &aparms); + gparms.dir = parms->dir; + gparms.type = parms->type; + gparms.offset = parms->offset; + gparms.config = parms->config; + gparms.config_sz_in_bytes = parms->config_sz_in_bytes; + rc = dev->ops->tf_dev_get_global_cfg(tfp, &gparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Identifier allocation failed, rc:%s\n", + "%s: Global Cfg get failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - parms->id = id; - - return 0; + return rc; } -int -tf_free_identifier(struct tf *tfp, - struct tf_free_identifier_parms *parms) +/** Set global configuration API + * + * returns: + * 0 - Success + * -EINVAL - Error + */ +int tf_set_global_cfg(struct tf *tfp, + struct tf_global_cfg_parms *parms) { - int rc; + int rc = 0; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_ident_free_parms fparms; + struct tf_dev_global_cfg_parms gparms = { 0 }; TF_CHECK_PARMS2(tfp, parms); - /* Can't do static initialization due to UT enum check */ - memset(&fparms, 0, sizeof(struct tf_ident_free_parms)); - /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -362,7 +394,13 @@ tf_free_identifier(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_free_ident == NULL) { + if (parms->config == NULL || + parms->config_sz_in_bytes == 0) { + TFP_DRV_LOG(ERR, "Invalid Argument(s)\n"); + return -EINVAL; + } + + if (dev->ops->tf_dev_set_global_cfg == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", @@ -371,32 +409,38 @@ tf_free_identifier(struct tf *tfp, return -EOPNOTSUPP; } - fparms.dir = parms->dir; - fparms.type = parms->ident_type; - fparms.id = parms->id; - rc = dev->ops->tf_dev_free_ident(tfp, &fparms); + gparms.dir = parms->dir; + gparms.type = parms->type; + gparms.offset = parms->offset; + gparms.config = parms->config; + gparms.config_sz_in_bytes = parms->config_sz_in_bytes; + rc = dev->ops->tf_dev_set_global_cfg(tfp, &gparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Identifier free failed, rc:%s\n", + "%s: Global Cfg set failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - return 0; + return rc; } int -tf_alloc_tcam_entry(struct tf *tfp, - struct tf_alloc_tcam_entry_parms *parms) +tf_alloc_identifier(struct tf *tfp, + struct tf_alloc_identifier_parms *parms) { int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_alloc_parms aparms = { 0 }; + struct tf_ident_alloc_parms aparms; + uint16_t id; TF_CHECK_PARMS2(tfp, parms); + /* Can't do static initialization due to UT enum check */ + memset(&aparms, 0, sizeof(struct tf_ident_alloc_parms)); + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -417,44 +461,46 @@ tf_alloc_tcam_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_alloc_tcam == NULL) { + if (dev->ops->tf_dev_alloc_ident == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return rc; + return -EOPNOTSUPP; } aparms.dir = parms->dir; - aparms.type = parms->tcam_tbl_type; - aparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits); - aparms.priority = parms->priority; - rc = dev->ops->tf_dev_alloc_tcam(tfp, &aparms); + aparms.type = parms->ident_type; + aparms.id = &id; + rc = dev->ops->tf_dev_alloc_ident(tfp, &aparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: TCAM allocation failed, rc:%s\n", + "%s: Identifier allocation failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - parms->idx = aparms.idx; + parms->id = id; return 0; } int -tf_set_tcam_entry(struct tf *tfp, - struct tf_set_tcam_entry_parms *parms) +tf_free_identifier(struct tf *tfp, + struct tf_free_identifier_parms *parms) { int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_set_parms sparms = { 0 }; + struct tf_ident_free_parms fparms; TF_CHECK_PARMS2(tfp, parms); + /* Can't do static initialization due to UT enum check */ + memset(&fparms, 0, sizeof(struct tf_ident_free_parms)); + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -475,28 +521,23 @@ tf_set_tcam_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_set_tcam == NULL) { + if (dev->ops->tf_dev_free_ident == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return rc; + return -EOPNOTSUPP; } - sparms.dir = parms->dir; - sparms.type = parms->tcam_tbl_type; - sparms.idx = parms->idx; - sparms.key = parms->key; - sparms.mask = parms->mask; - sparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits); - sparms.result = parms->result; - sparms.result_size = TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits); - - rc = dev->ops->tf_dev_set_tcam(tfp, &sparms); + fparms.dir = parms->dir; + fparms.type = parms->ident_type; + fparms.id = parms->id; + fparms.ref_cnt = &parms->ref_cnt; + rc = dev->ops->tf_dev_free_ident(tfp, &fparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: TCAM set failed, rc:%s\n", + "%s: Identifier free failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; @@ -506,24 +547,19 @@ tf_set_tcam_entry(struct tf *tfp, } int -tf_get_tcam_entry(struct tf *tfp __rte_unused, - struct tf_get_tcam_entry_parms *parms __rte_unused) -{ - TF_CHECK_PARMS_SESSION(tfp, parms); - return -EOPNOTSUPP; -} - -int -tf_free_tcam_entry(struct tf *tfp, - struct tf_free_tcam_entry_parms *parms) +tf_search_identifier(struct tf *tfp, + struct tf_search_identifier_parms *parms) { int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_free_parms fparms = { 0 }; + struct tf_ident_search_parms sparms; TF_CHECK_PARMS2(tfp, parms); + /* Can't do static initialization due to UT enum check */ + memset(&sparms, 0, sizeof(struct tf_ident_search_parms)); + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -544,7 +580,7 @@ tf_free_tcam_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_free_tcam == NULL) { + if (dev->ops->tf_dev_search_ident == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", @@ -553,13 +589,15 @@ tf_free_tcam_entry(struct tf *tfp, return rc; } - fparms.dir = parms->dir; - fparms.type = parms->tcam_tbl_type; - fparms.idx = parms->idx; - rc = dev->ops->tf_dev_free_tcam(tfp, &fparms); + sparms.dir = parms->dir; + sparms.type = parms->ident_type; + sparms.search_id = parms->search_id; + sparms.hit = &parms->hit; + sparms.ref_cnt = &parms->ref_cnt; + rc = dev->ops->tf_dev_search_ident(tfp, &sparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: TCAM allocation failed, rc:%s\n", + "%s: Identifier search failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; @@ -569,19 +607,17 @@ tf_free_tcam_entry(struct tf *tfp, } int -tf_alloc_tbl_entry(struct tf *tfp, - struct tf_alloc_tbl_entry_parms *parms) +tf_search_tcam_entry(struct tf *tfp, + struct tf_search_tcam_entry_parms *parms) { int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tbl_alloc_parms aparms; - uint32_t idx; + struct tf_tcam_alloc_search_parms sparms; TF_CHECK_PARMS2(tfp, parms); - /* Can't do static initialization due to UT enum check */ - memset(&aparms, 0, sizeof(struct tf_tbl_alloc_parms)); + memset(&sparms, 0, sizeof(struct tf_tcam_alloc_search_parms)); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -603,45 +639,58 @@ tf_alloc_tbl_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_alloc_tbl == NULL) { + if (dev->ops->tf_dev_alloc_search_tcam == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return -EOPNOTSUPP; + return rc; } - aparms.dir = parms->dir; - aparms.type = parms->type; - aparms.idx = &idx; - rc = dev->ops->tf_dev_alloc_tbl(tfp, &aparms); + sparms.dir = parms->dir; + sparms.type = parms->tcam_tbl_type; + sparms.key = parms->key; + sparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits); + sparms.mask = parms->mask; + sparms.priority = parms->priority; + sparms.alloc = parms->alloc; + + /* Result is an in/out and so no need to copy during outputs */ + sparms.result = parms->result; + sparms.result_size = + TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits); + + rc = dev->ops->tf_dev_alloc_search_tcam(tfp, &sparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Table allocation failed, rc:%s\n", + "%s: TCAM allocation failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - parms->idx = idx; + /* Copy the outputs */ + parms->hit = sparms.hit; + parms->search_status = sparms.search_status; + parms->ref_cnt = sparms.ref_cnt; + parms->idx = sparms.idx; return 0; } int -tf_free_tbl_entry(struct tf *tfp, - struct tf_free_tbl_entry_parms *parms) +tf_alloc_tcam_entry(struct tf *tfp, + struct tf_alloc_tcam_entry_parms *parms) { int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tbl_free_parms fparms; + struct tf_tcam_alloc_parms aparms; TF_CHECK_PARMS2(tfp, parms); - /* Can't do static initialization due to UT enum check */ - memset(&fparms, 0, sizeof(struct tf_tbl_free_parms)); + memset(&aparms, 0, sizeof(struct tf_tcam_alloc_parms)); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -663,43 +712,46 @@ tf_free_tbl_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_free_tbl == NULL) { + if (dev->ops->tf_dev_alloc_tcam == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return -EOPNOTSUPP; + return rc; } - fparms.dir = parms->dir; - fparms.type = parms->type; - fparms.idx = parms->idx; - rc = dev->ops->tf_dev_free_tbl(tfp, &fparms); + aparms.dir = parms->dir; + aparms.type = parms->tcam_tbl_type; + aparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits); + aparms.priority = parms->priority; + rc = dev->ops->tf_dev_alloc_tcam(tfp, &aparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Table free failed, rc:%s\n", + "%s: TCAM allocation failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } + parms->idx = aparms.idx; + return 0; } int -tf_set_tbl_entry(struct tf *tfp, - struct tf_set_tbl_entry_parms *parms) +tf_set_tcam_entry(struct tf *tfp, + struct tf_set_tcam_entry_parms *parms) { - int rc = 0; + int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tbl_set_parms sparms; + struct tf_tcam_set_parms sparms; - TF_CHECK_PARMS3(tfp, parms, parms->data); + TF_CHECK_PARMS2(tfp, parms); + + memset(&sparms, 0, sizeof(struct tf_tcam_set_parms)); - /* Can't do static initialization due to UT enum check */ - memset(&sparms, 0, sizeof(struct tf_tbl_set_parms)); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -721,45 +773,56 @@ tf_set_tbl_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_set_tbl == NULL) { + if (dev->ops->tf_dev_set_tcam == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return -EOPNOTSUPP; + return rc; } sparms.dir = parms->dir; - sparms.type = parms->type; - sparms.data = parms->data; - sparms.data_sz_in_bytes = parms->data_sz_in_bytes; + sparms.type = parms->tcam_tbl_type; sparms.idx = parms->idx; - rc = dev->ops->tf_dev_set_tbl(tfp, &sparms); + sparms.key = parms->key; + sparms.mask = parms->mask; + sparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits); + sparms.result = parms->result; + sparms.result_size = TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits); + + rc = dev->ops->tf_dev_set_tcam(tfp, &sparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Table set failed, rc:%s\n", + "%s: TCAM set failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - return rc; + return 0; } int -tf_get_tbl_entry(struct tf *tfp, - struct tf_get_tbl_entry_parms *parms) +tf_get_tcam_entry(struct tf *tfp __rte_unused, + struct tf_get_tcam_entry_parms *parms __rte_unused) { - int rc = 0; + TF_CHECK_PARMS2(tfp, parms); + return -EOPNOTSUPP; +} + +int +tf_free_tcam_entry(struct tf *tfp, + struct tf_free_tcam_entry_parms *parms) +{ + int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tbl_get_parms gparms; + struct tf_tcam_free_parms fparms; - TF_CHECK_PARMS3(tfp, parms, parms->data); + TF_CHECK_PARMS2(tfp, parms); - /* Can't do static initialization due to UT enum check */ - memset(&gparms, 0, sizeof(struct tf_tbl_get_parms)); + memset(&fparms, 0, sizeof(struct tf_tcam_free_parms)); /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); @@ -781,28 +844,665 @@ tf_get_tbl_entry(struct tf *tfp, return rc; } - if (dev->ops->tf_dev_get_tbl == NULL) { + if (dev->ops->tf_dev_free_tcam == NULL) { rc = -EOPNOTSUPP; TFP_DRV_LOG(ERR, "%s: Operation not supported, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); - return -EOPNOTSUPP; + return rc; } - gparms.dir = parms->dir; - gparms.type = parms->type; - gparms.data = parms->data; - gparms.data_sz_in_bytes = parms->data_sz_in_bytes; - gparms.idx = parms->idx; - rc = dev->ops->tf_dev_get_tbl(tfp, &gparms); + fparms.dir = parms->dir; + fparms.type = parms->tcam_tbl_type; + fparms.idx = parms->idx; + rc = dev->ops->tf_dev_free_tcam(tfp, &fparms); if (rc) { TFP_DRV_LOG(ERR, - "%s: Table get failed, rc:%s\n", + "%s: TCAM free failed, rc:%s\n", tf_dir_2_str(parms->dir), strerror(-rc)); return rc; } - return rc; + return 0; +} + +int +tf_alloc_tbl_entry(struct tf *tfp, + struct tf_alloc_tbl_entry_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_alloc_parms aparms; + uint32_t idx; + + TF_CHECK_PARMS2(tfp, parms); + + /* Can't do static initialization due to UT enum check */ + memset(&aparms, 0, sizeof(struct tf_tbl_alloc_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + aparms.dir = parms->dir; + aparms.type = parms->type; + aparms.idx = &idx; + aparms.tbl_scope_id = parms->tbl_scope_id; + + if (parms->type == TF_TBL_TYPE_EXT) { + if (dev->ops->tf_dev_alloc_ext_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_alloc_ext_tbl(tfp, &aparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: External table allocation failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + } else { + if (dev->ops->tf_dev_alloc_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_alloc_tbl(tfp, &aparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table allocation failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + } + + parms->idx = idx; + + return 0; +} + +int +tf_search_tbl_entry(struct tf *tfp, + struct tf_search_tbl_entry_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_alloc_search_parms sparms; + + TF_CHECK_PARMS2(tfp, parms); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + if (dev->ops->tf_dev_alloc_search_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + memset(&sparms, 0, sizeof(struct tf_tbl_alloc_search_parms)); + sparms.dir = parms->dir; + sparms.type = parms->type; + sparms.result = parms->result; + sparms.result_sz_in_bytes = parms->result_sz_in_bytes; + sparms.alloc = parms->alloc; + sparms.tbl_scope_id = parms->tbl_scope_id; + rc = dev->ops->tf_dev_alloc_search_tbl(tfp, &sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: TBL allocation failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + /* Return the outputs from the search */ + parms->hit = sparms.hit; + parms->search_status = sparms.search_status; + parms->ref_cnt = sparms.ref_cnt; + parms->idx = sparms.idx; + + return 0; +} + +int +tf_free_tbl_entry(struct tf *tfp, + struct tf_free_tbl_entry_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_free_parms fparms; + + TF_CHECK_PARMS2(tfp, parms); + + /* Can't do static initialization due to UT enum check */ + memset(&fparms, 0, sizeof(struct tf_tbl_free_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + fparms.dir = parms->dir; + fparms.type = parms->type; + fparms.idx = parms->idx; + fparms.tbl_scope_id = parms->tbl_scope_id; + + if (parms->type == TF_TBL_TYPE_EXT) { + if (dev->ops->tf_dev_free_ext_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_free_ext_tbl(tfp, &fparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table free failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + } else { + if (dev->ops->tf_dev_free_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_free_tbl(tfp, &fparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table free failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + } + + return 0; +} + +int +tf_set_tbl_entry(struct tf *tfp, + struct tf_set_tbl_entry_parms *parms) +{ + int rc = 0; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_set_parms sparms; + + TF_CHECK_PARMS3(tfp, parms, parms->data); + + /* Can't do static initialization due to UT enum check */ + memset(&sparms, 0, sizeof(struct tf_tbl_set_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + sparms.dir = parms->dir; + sparms.type = parms->type; + sparms.data = parms->data; + sparms.data_sz_in_bytes = parms->data_sz_in_bytes; + sparms.idx = parms->idx; + sparms.tbl_scope_id = parms->tbl_scope_id; + + if (parms->type == TF_TBL_TYPE_EXT) { + if (dev->ops->tf_dev_set_ext_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_set_ext_tbl(tfp, &sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table set failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + } else { + if (dev->ops->tf_dev_set_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + rc = dev->ops->tf_dev_set_tbl(tfp, &sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table set failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + } + + return rc; +} + +int +tf_get_tbl_entry(struct tf *tfp, + struct tf_get_tbl_entry_parms *parms) +{ + int rc = 0; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_get_parms gparms; + + TF_CHECK_PARMS3(tfp, parms, parms->data); + + /* Can't do static initialization due to UT enum check */ + memset(&gparms, 0, sizeof(struct tf_tbl_get_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + if (dev->ops->tf_dev_get_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + gparms.dir = parms->dir; + gparms.type = parms->type; + gparms.data = parms->data; + gparms.data_sz_in_bytes = parms->data_sz_in_bytes; + gparms.idx = parms->idx; + rc = dev->ops->tf_dev_get_tbl(tfp, &gparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table get failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return rc; +} + +int +tf_bulk_get_tbl_entry(struct tf *tfp, + struct tf_bulk_get_tbl_entry_parms *parms) +{ + int rc = 0; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_tbl_get_bulk_parms bparms; + + TF_CHECK_PARMS2(tfp, parms); + + /* Can't do static initialization due to UT enum check */ + memset(&bparms, 0, sizeof(struct tf_tbl_get_bulk_parms)); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + if (parms->type == TF_TBL_TYPE_EXT) { + /* Not supported, yet */ + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s, External table type not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + + return rc; + } + + /* Internal table type processing */ + + if (dev->ops->tf_dev_get_bulk_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + bparms.dir = parms->dir; + bparms.type = parms->type; + bparms.starting_idx = parms->starting_idx; + bparms.num_entries = parms->num_entries; + bparms.entry_sz_in_bytes = parms->entry_sz_in_bytes; + bparms.physical_mem_addr = parms->physical_mem_addr; + rc = dev->ops->tf_dev_get_bulk_tbl(tfp, &bparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Table get bulk failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return rc; +} + +int +tf_alloc_tbl_scope(struct tf *tfp, + struct tf_alloc_tbl_scope_parms *parms) +{ + struct tf_session *tfs; + struct tf_dev_info *dev; + int rc; + + TF_CHECK_PARMS2(tfp, parms); + + /* Retrieve the session information */ + rc = tf_session_get_session(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; + } + + if (dev->ops->tf_dev_alloc_tbl_scope != NULL) { + rc = dev->ops->tf_dev_alloc_tbl_scope(tfp, parms); + } else { + TFP_DRV_LOG(ERR, + "Alloc table scope not supported by device\n"); + return -EINVAL; + } + + return rc; +} + +int +tf_free_tbl_scope(struct tf *tfp, + struct tf_free_tbl_scope_parms *parms) +{ + struct tf_session *tfs; + struct tf_dev_info *dev; + int rc; + + TF_CHECK_PARMS2(tfp, parms); + + /* Retrieve the session information */ + rc = tf_session_get_session(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; + } + + if (dev->ops->tf_dev_free_tbl_scope) { + rc = dev->ops->tf_dev_free_tbl_scope(tfp, parms); + } else { + TFP_DRV_LOG(ERR, + "Free table scope not supported by device\n"); + return -EINVAL; + } + + return rc; +} + +int +tf_set_if_tbl_entry(struct tf *tfp, + struct tf_set_if_tbl_entry_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_if_tbl_set_parms sparms = { 0 }; + + TF_CHECK_PARMS2(tfp, parms); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + if (dev->ops->tf_dev_set_if_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + sparms.dir = parms->dir; + sparms.type = parms->type; + sparms.idx = parms->idx; + sparms.data_sz_in_bytes = parms->data_sz_in_bytes; + sparms.data = parms->data; + + rc = dev->ops->tf_dev_set_if_tbl(tfp, &sparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: If_tbl set failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return 0; +} + +int +tf_get_if_tbl_entry(struct tf *tfp, + struct tf_get_if_tbl_entry_parms *parms) +{ + int rc; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_if_tbl_get_parms gparms = { 0 }; + + TF_CHECK_PARMS2(tfp, parms); + + /* Retrieve the session information */ + rc = tf_session_get_session(tfp, &tfs); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: Failed to lookup session, rc:%s\n", + tf_dir_2_str(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(parms->dir), + strerror(-rc)); + return rc; + } + + if (dev->ops->tf_dev_get_if_tbl == NULL) { + rc = -EOPNOTSUPP; + TFP_DRV_LOG(ERR, + "%s: Operation not supported, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + gparms.dir = parms->dir; + gparms.type = parms->type; + gparms.idx = parms->idx; + gparms.data_sz_in_bytes = parms->data_sz_in_bytes; + gparms.data = parms->data; + + rc = dev->ops->tf_dev_get_if_tbl(tfp, &gparms); + if (rc) { + TFP_DRV_LOG(ERR, + "%s: If_tbl get failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return 0; }