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=a980a20569b3ef9d515a5b598bbdf962ccdae9c3;hpb=f3502f5cd2818b96c47a9ec80510b2c186821298;p=dpdk.git diff --git a/drivers/net/bnxt/tf_core/tf_core.c b/drivers/net/bnxt/tf_core/tf_core.c index a980a20569..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; } @@ -281,6 +290,142 @@ int tf_delete_em_entry(struct tf *tfp, return rc; } +/** 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 = 0; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_dev_global_cfg_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 (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", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + 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: Global Cfg get failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return rc; +} + +/** 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 = 0; + struct tf_session *tfs; + struct tf_dev_info *dev; + struct tf_dev_global_cfg_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 (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", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return -EOPNOTSUPP; + } + + 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: Global Cfg set failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return rc; +} + int tf_alloc_identifier(struct tf *tfp, struct tf_alloc_identifier_parms *parms) @@ -388,6 +533,7 @@ tf_free_identifier(struct tf *tfp, 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, @@ -400,6 +546,139 @@ tf_free_identifier(struct tf *tfp, return 0; } +int +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_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) { + 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_search_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; + } + + 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: Identifier search failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + return 0; +} + +int +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_tcam_alloc_search_parms sparms; + + TF_CHECK_PARMS2(tfp, parms); + + memset(&sparms, 0, sizeof(struct tf_tcam_alloc_search_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_tcam == 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->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: TCAM allocation failed, rc:%s\n", + tf_dir_2_str(parms->dir), + strerror(-rc)); + return rc; + } + + /* 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_alloc_tcam_entry(struct tf *tfp, struct tf_alloc_tcam_entry_parms *parms) @@ -407,10 +686,12 @@ tf_alloc_tcam_entry(struct tf *tfp, int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_alloc_parms aparms = { 0 }; + struct tf_tcam_alloc_parms aparms; TF_CHECK_PARMS2(tfp, parms); + memset(&aparms, 0, sizeof(struct tf_tcam_alloc_parms)); + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -465,10 +746,13 @@ tf_set_tcam_entry(struct tf *tfp, int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_set_parms sparms = { 0 }; + struct tf_tcam_set_parms sparms; TF_CHECK_PARMS2(tfp, parms); + memset(&sparms, 0, sizeof(struct tf_tcam_set_parms)); + + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -534,10 +818,12 @@ tf_free_tcam_entry(struct tf *tfp, int rc; struct tf_session *tfs; struct tf_dev_info *dev; - struct tf_tcam_free_parms fparms = { 0 }; + struct tf_tcam_free_parms fparms; TF_CHECK_PARMS2(tfp, parms); + memset(&fparms, 0, sizeof(struct tf_tcam_free_parms)); + /* Retrieve the session information */ rc = tf_session_get_session(tfp, &tfs); if (rc) { @@ -666,6 +952,71 @@ tf_alloc_tbl_entry(struct tf *tfp, 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)