net/ntnic: add nthw function name prefix

Add nthw prefix to functions with abstract names
to avoid exposing global symbols

Signed-off-by: Serhii Iliushyk <[email protected]>

Author: sil-plv

drivers/net/ntnic/adapter/nt4ga_adapter.c

@@ -168,7 +168,7 @@ static int nt4ga_adapter_init(struct adapter_info_s *p_adapter_info)
 	nt4ga_filter_t *p_filter = &p_adapter_info->nt4ga_filter;
 
 	if (flow_filter_ops != NULL) {
-		res = flow_filter_ops->flow_filter_init(p_fpga, &p_filter->mp_flow_device,
+		res = flow_filter_ops->nthw_flow_filter_init(p_fpga, &p_filter->mp_flow_device,
 				p_adapter_info->adapter_no);
 
 		if (res != 0) {
@@ -266,7 +266,7 @@ static int nt4ga_adapter_deinit(struct adapter_info_s *p_adapter_info)
 	nt4ga_filter_t *p_filter = &p_adapter_info->nt4ga_filter;
 
 	if (flow_filter_ops != NULL) {
-		res = flow_filter_ops->flow_filter_done(p_filter->mp_flow_device);
+		res = flow_filter_ops->nthw_flow_filter_done(p_filter->mp_flow_device);
 
 		if (res != 0) {
 			NT_LOG(ERR, NTNIC, "Cannot deinitialize filter");
@@ -309,7 +309,7 @@ static const struct adapter_ops ops = {
 	.show_info = nt4ga_adapter_show_info,
 };
 
-void adapter_init(void)
+void nthw_adapter_init(void)
 {
 	register_adapter_ops(&ops);
 }

drivers/net/ntnic/adapter/nt4ga_stat/nt4ga_stat.c

@@ -558,11 +558,13 @@ static int nt4ga_stat_collect_cap_v1_stats(struct adapter_info_s *p_adapter_info
 	}
 
 	/* Update and get FLM stats */
-	flow_filter_ops->flow_get_flm_stats(ndev, (uint64_t *)p_nt4ga_stat->mp_stat_structs_flm,
+	flow_filter_ops->nthw_flow_get_flm_stats(ndev,
+		(uint64_t *)p_nt4ga_stat->mp_stat_structs_flm,
 		sizeof(struct flm_counters_v1) / sizeof(uint64_t));
 
 	/* Update and get IFR stats */
-	flow_filter_ops->flow_get_ifr_stats(ndev, (uint64_t *)p_nt4ga_stat->mp_stat_structs_ifr,
+	flow_filter_ops->nthw_flow_get_ifr_stats(ndev,
+		(uint64_t *)p_nt4ga_stat->mp_stat_structs_ifr,
 		p_nt4ga_stat->mn_ifr_counters - 1);
 
 	/*

drivers/net/ntnic/dbsconfig/ntnic_dbsconfig.c

@@ -177,13 +177,13 @@ static void dbs_init_rx_queue(nthw_dbs_t *p_nthw_dbs, uint32_t queue, uint32_t s
 	uint32_t dummy;
 
 	do {
-		get_rx_init(p_nthw_dbs, &init, &dummy, &busy);
+		nthw_get_rx_init(p_nthw_dbs, &init, &dummy, &busy);
 	} while (busy != 0);
 
-	set_rx_init(p_nthw_dbs, start_idx, start_ptr, INIT_QUEUE, queue);
+	nthw_set_rx_init(p_nthw_dbs, start_idx, start_ptr, INIT_QUEUE, queue);
 
 	do {
-		get_rx_init(p_nthw_dbs, &init, &dummy, &busy);
+		nthw_get_rx_init(p_nthw_dbs, &init, &dummy, &busy);
 	} while (busy != 0);
 }
 
@@ -195,13 +195,13 @@ static void dbs_init_tx_queue(nthw_dbs_t *p_nthw_dbs, uint32_t queue, uint32_t s
 	uint32_t dummy;
 
 	do {
-		get_tx_init(p_nthw_dbs, &init, &dummy, &busy);
+		nthw_get_tx_init(p_nthw_dbs, &init, &dummy, &busy);
 	} while (busy != 0);
 
 	set_tx_init(p_nthw_dbs, start_idx, start_ptr, INIT_QUEUE, queue);
 
 	do {
-		get_tx_init(p_nthw_dbs, &init, &dummy, &busy);
+		nthw_get_tx_init(p_nthw_dbs, &init, &dummy, &busy);
 	} while (busy != 0);
 }
 
@@ -250,18 +250,18 @@ static int nthw_virt_queue_init(struct fpga_info_s *p_fpga_info)
 	for (i = 0; i < NT_DBS_TX_QUEUES_MAX; ++i)
 		dbs_init_tx_queue(p_nthw_dbs, i, 0, 0);
 
-	set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_DISABLE, RX_AM_POLL_SPEED, RX_UW_DISABLE,
+	nthw_set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_DISABLE, RX_AM_POLL_SPEED, RX_UW_DISABLE,
 		RX_UW_POLL_SPEED, RX_Q_DISABLE);
-	set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_ENABLE, RX_AM_POLL_SPEED, RX_UW_ENABLE,
+	nthw_set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_ENABLE, RX_AM_POLL_SPEED, RX_UW_ENABLE,
 		RX_UW_POLL_SPEED, RX_Q_DISABLE);
-	set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_ENABLE, RX_AM_POLL_SPEED, RX_UW_ENABLE,
+	nthw_set_rx_control(p_nthw_dbs, LAST_QUEUE, RX_AM_ENABLE, RX_AM_POLL_SPEED, RX_UW_ENABLE,
 		RX_UW_POLL_SPEED, RX_Q_ENABLE);
 
-	set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_DISABLE, TX_AM_POLL_SPEED, TX_UW_DISABLE,
+	nthw_set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_DISABLE, TX_AM_POLL_SPEED, TX_UW_DISABLE,
 		TX_UW_POLL_SPEED, TX_Q_DISABLE);
-	set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_ENABLE, TX_AM_POLL_SPEED, TX_UW_ENABLE,
+	nthw_set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_ENABLE, TX_AM_POLL_SPEED, TX_UW_ENABLE,
 		TX_UW_POLL_SPEED, TX_Q_DISABLE);
-	set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_ENABLE, TX_AM_POLL_SPEED, TX_UW_ENABLE,
+	nthw_set_tx_control(p_nthw_dbs, LAST_QUEUE, TX_AM_ENABLE, TX_AM_POLL_SPEED, TX_UW_ENABLE,
 		TX_UW_POLL_SPEED, TX_Q_ENABLE);
 
 	return 0;
@@ -464,10 +464,10 @@ static int dbs_wait_on_busy(struct nthw_virt_queue *vq, uint32_t *idle, int rx)
 
 	do {
 		if (rx)
-			err = get_rx_idle(p_nthw_dbs, idle, &queue, &busy);
+			err = nthw_get_rx_idle(p_nthw_dbs, idle, &queue, &busy);
 
 		else
-			err = get_tx_idle(p_nthw_dbs, idle, &queue, &busy);
+			err = nthw_get_tx_idle(p_nthw_dbs, idle, &queue, &busy);
 	} while (!err && busy);
 
 	return err;
@@ -492,10 +492,10 @@ static int dbs_wait_hw_queue_shutdown(struct nthw_virt_queue *vq, int rx)
 
 	do {
 		if (rx)
-			err = set_rx_idle(p_nthw_dbs, 1, vq->index);
+			err = nthw_set_rx_idle(p_nthw_dbs, 1, vq->index);
 
 		else
-			err = set_tx_idle(p_nthw_dbs, 1, vq->index);
+			err = nthw_set_tx_idle(p_nthw_dbs, 1, vq->index);
 
 		if (err)
 			return -1;
@@ -1424,7 +1424,7 @@ static struct sg_ops_s sg_ops = {
 	.nthw_virt_queue_init = nthw_virt_queue_init
 };
 
-void sg_init(void)
+void nthw_sg_init(void)
 {
 	NT_LOG(INF, NTNIC, "SG ops initialized");
 	register_sg_ops(&sg_ops);

drivers/net/ntnic/include/create_elements.h

@@ -60,11 +60,11 @@ enum nt_rte_flow_item_type {
 
 extern rte_spinlock_t flow_lock;
 
-int interpret_raw_data(uint8_t *data, uint8_t *preserve, int size, struct rte_flow_item *out);
-int create_attr(struct cnv_attr_s *attribute, const struct rte_flow_attr *attr);
-int create_match_elements(struct cnv_match_s *match, const struct rte_flow_item items[],
+int nthw_interpret_raw_data(uint8_t *data, uint8_t *preserve, int size, struct rte_flow_item *out);
+int nthw_create_attr(struct cnv_attr_s *attribute, const struct rte_flow_attr *attr);
+int nthw_create_match_elements(struct cnv_match_s *match, const struct rte_flow_item items[],
 	int max_elem);
-int create_action_elements_inline(struct cnv_action_s *action,
+int nthw_create_action_elements_inline(struct cnv_action_s *action,
 	const struct rte_flow_action actions[],
 	int max_elem,
 	uint32_t queue_offset);

drivers/net/ntnic/include/flow_api.h

@@ -27,7 +27,7 @@ struct hw_mod_resource_s {
 /*
  * Device Management API
  */
-int flow_delete_eth_dev(struct flow_eth_dev *eth_dev);
+int nthw_flow_delete_eth_dev(struct flow_eth_dev *eth_dev);
 
 /**
  * A structure used to configure the Receive Side Scaling (RSS) feature
@@ -167,7 +167,7 @@ enum flow_nic_err_msg_e {
 	ERR_MSG_END
 };
 
-void flow_nic_set_error(enum flow_nic_err_msg_e msg, struct rte_flow_error *error);
+void nthw_flow_nic_set_error(enum flow_nic_err_msg_e msg, struct rte_flow_error *error);
 
 /*
  * Resources
@@ -219,17 +219,17 @@ extern const char *dbg_res_descr[];
 #define flow_nic_is_resource_used(_ndev, res_type, index)                                         \
 	(!!flow_nic_is_bit_set((_ndev)->res[res_type].alloc_bm, index))
 
-int flow_nic_alloc_resource(struct flow_nic_dev *ndev, enum res_type_e res_type,
+int nthw_flow_nic_alloc_resource(struct flow_nic_dev *ndev, enum res_type_e res_type,
 	uint32_t alignment);
 
-int flow_nic_alloc_resource_config(struct flow_nic_dev *ndev, enum res_type_e res_type,
+int nthw_flow_nic_alloc_resource_config(struct flow_nic_dev *ndev, enum res_type_e res_type,
 	unsigned int num, uint32_t alignment);
-void flow_nic_free_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int idx);
+void nthw_flow_nic_free_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int idx);
 
-int flow_nic_ref_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int index);
-int flow_nic_deref_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int index);
+int nthw_flow_nic_ref_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int index);
+int nthw_flow_nic_deref_resource(struct flow_nic_dev *ndev, enum res_type_e res_type, int index);
 
-int flow_get_flm_stats(struct flow_nic_dev *ndev, uint64_t *data, uint64_t size);
-int flow_get_ifr_stats(struct flow_nic_dev *ndev, uint64_t *data, uint8_t port_count);
+int nthw_flow_get_flm_stats(struct flow_nic_dev *ndev, uint64_t *data, uint64_t size);
+int nthw_flow_get_ifr_stats(struct flow_nic_dev *ndev, uint64_t *data, uint8_t port_count);
 
 #endif

drivers/net/ntnic/include/flow_api_engine.h

@@ -420,12 +420,12 @@ void kcc_free_ndev_resource_management(void **handle);
 /*
  * Group management
  */
-int flow_group_handle_create(void **handle, uint32_t group_count);
-int flow_group_handle_destroy(void **handle);
+int nthw_flow_group_handle_create(void **handle, uint32_t group_count);
+int nthw_flow_group_handle_destroy(void **handle);
 
-int flow_group_translate_get(void *handle, uint8_t owner_id, uint8_t port_id, uint32_t group_in,
-	uint32_t *group_out);
-int flow_group_translate_get_orig_group(void *handle, uint32_t translated_group,
+int nthw_flow_group_translate_get(void *handle, uint8_t owner_id, uint8_t port_id,
+	uint32_t group_in, uint32_t *group_out);
+int nthw_flow_group_translate_get_orig_group(void *handle, uint32_t translated_group,
 	uint32_t *group_orig);
 
 #endif  /* _FLOW_API_ENGINE_H_ */

drivers/net/ntnic/include/flow_filter.h

@@ -9,8 +9,8 @@
 #include "flow_api.h"
 #include "nthw_fpga_model.h"
 
-int flow_filter_init(nthw_fpga_t *p_fpga, struct flow_nic_dev **p_flow_device, int adapter_no);
-int flow_filter_done(struct flow_nic_dev *dev);
-int flow_get_flm_stats(struct flow_nic_dev *ndev, uint64_t *data, uint64_t size);
+int nthw_flow_filter_init(nthw_fpga_t *p_fpga, struct flow_nic_dev **p_flow_device, int adapter_no);
+int nthw_flow_filter_done(struct flow_nic_dev *dev);
+int nthw_flow_get_flm_stats(struct flow_nic_dev *ndev, uint64_t *data, uint64_t size);
 
 #endif  /* __FLOW_FILTER_HPP__ */

drivers/net/ntnic/include/hw_mod_backend.h

@@ -29,8 +29,8 @@
 struct flow_api_backend_s;
 struct common_func_s;
 
-void *callocate_mod(struct common_func_s *mod, int sets, ...);
-void zero_module_cache(struct common_func_s *mod);
+void *nthw_callocate_mod(struct common_func_s *mod, int sets, ...);
+void nthw_zero_module_cache(struct common_func_s *mod);
 
 #define ALL_ENTRIES -1000
 #define ALL_BANK_ENTRIES -1001
@@ -1164,8 +1164,8 @@ struct flow_api_backend_s {
 	unsigned int max_queues;
 };
 
-int flow_api_backend_init(struct flow_api_backend_s *dev, const struct flow_api_backend_ops *iface,
-	void *be_dev);
-int flow_api_backend_done(struct flow_api_backend_s *dev);
+int nthw_flow_api_backend_init(struct flow_api_backend_s *dev,
+	const struct flow_api_backend_ops *iface, void *be_dev);
+int nthw_flow_api_backend_done(struct flow_api_backend_s *dev);
 
 #endif  /* _HW_MOD_BACKEND_H_ */

drivers/net/ntnic/include/ntnic_dbs.h

@@ -236,30 +236,30 @@ nthw_dbs_t *nthw_dbs_new(void);
 int dbs_init(nthw_dbs_t *p, nthw_fpga_t *p_fpga, int n_instance);
 void dbs_reset(nthw_dbs_t *p);
 
-int set_rx_control(nthw_dbs_t *p,
+int nthw_set_rx_control(nthw_dbs_t *p,
 	uint32_t last_queue,
 	uint32_t avail_monitor_enable,
 	uint32_t avail_monitor_speed,
 	uint32_t used_write_enable,
 	uint32_t used_write_speed,
 	uint32_t rx_queue_enable);
-int set_tx_control(nthw_dbs_t *p,
+int nthw_set_tx_control(nthw_dbs_t *p,
 	uint32_t last_queue,
 	uint32_t avail_monitor_enable,
 	uint32_t avail_monitor_speed,
 	uint32_t used_write_enable,
 	uint32_t used_write_speed,
 	uint32_t tx_queue_enable);
-int set_rx_init(nthw_dbs_t *p, uint32_t start_idx, uint32_t start_ptr, uint32_t init,
+int nthw_set_rx_init(nthw_dbs_t *p, uint32_t start_idx, uint32_t start_ptr, uint32_t init,
 	uint32_t queue);
-int get_rx_init(nthw_dbs_t *p, uint32_t *init, uint32_t *queue, uint32_t *busy);
+int nthw_get_rx_init(nthw_dbs_t *p, uint32_t *init, uint32_t *queue, uint32_t *busy);
 int set_tx_init(nthw_dbs_t *p, uint32_t start_idx, uint32_t start_ptr, uint32_t init,
 	uint32_t queue);
-int get_tx_init(nthw_dbs_t *p, uint32_t *init, uint32_t *queue, uint32_t *busy);
-int set_rx_idle(nthw_dbs_t *p, uint32_t idle, uint32_t queue);
-int get_rx_idle(nthw_dbs_t *p, uint32_t *idle, uint32_t *queue, uint32_t *busy);
-int set_tx_idle(nthw_dbs_t *p, uint32_t idle, uint32_t queue);
-int get_tx_idle(nthw_dbs_t *p, uint32_t *idle, uint32_t *queue, uint32_t *busy);
+int nthw_get_tx_init(nthw_dbs_t *p, uint32_t *init, uint32_t *queue, uint32_t *busy);
+int nthw_set_rx_idle(nthw_dbs_t *p, uint32_t idle, uint32_t queue);
+int nthw_get_rx_idle(nthw_dbs_t *p, uint32_t *idle, uint32_t *queue, uint32_t *busy);
+int nthw_set_tx_idle(nthw_dbs_t *p, uint32_t idle, uint32_t queue);
+int nthw_get_tx_idle(nthw_dbs_t *p, uint32_t *idle, uint32_t *queue, uint32_t *busy);
 int set_rx_am_data(nthw_dbs_t *p,
 	uint32_t index,
 	uint64_t guest_physical_address,

drivers/net/ntnic/link_mgmt/link_100g/nt4ga_link_100g.c

@@ -304,28 +304,28 @@ static int _create_nim(adapter_info_t *drv, int port, bool enable)
 		return -1;
 	}
 
-	res = construct_and_preinit_nim(nim_ctx, NULL);
+	res = nthw_construct_and_preinit_nim(nim_ctx, NULL);
 
 	if (res)
 		return res;
 
-	res = nim_state_build(nim_ctx, &nim);
+	res = nthw_nim_state_build(nim_ctx, &nim);
 
 	if (res)
 		return res;
 
 	NT_LOG(DBG, NTHW, "%s: NIM id = %u (%s), br = %u, vendor = '%s', pn = '%s', sn='%s'",
-		drv->mp_port_id_str[port], nim_ctx->nim_id, nim_id_to_text(nim_ctx->nim_id), nim.br,
-		nim_ctx->vendor_name, nim_ctx->prod_no, nim_ctx->serial_no);
+		drv->mp_port_id_str[port], nim_ctx->nim_id, nthw_nim_id_to_text(nim_ctx->nim_id),
+		nim.br, nim_ctx->vendor_name, nim_ctx->prod_no, nim_ctx->serial_no);
 
 	/*
 	 * Does the driver support the NIM module type?
 	 */
 	if (nim_ctx->nim_id != valid_nim_id) {
 		NT_LOG(ERR, NTHW, "%s: The driver does not support the NIM module type %s",
-			drv->mp_port_id_str[port], nim_id_to_text(nim_ctx->nim_id));
+			drv->mp_port_id_str[port], nthw_nim_id_to_text(nim_ctx->nim_id));
 		NT_LOG(DBG, NTHW, "%s: The driver supports the NIM module type %s",
-			drv->mp_port_id_str[port], nim_id_to_text(valid_nim_id));
+			drv->mp_port_id_str[port], nthw_nim_id_to_text(valid_nim_id));
 		return -1;
 	}
 
@@ -371,7 +371,7 @@ static int _port_init(adapter_info_t *drv, nthw_fpga_t *fpga, int port)
 
 	/*
 	 * Phase 1. Pre-state machine (`port init` functions)
-	 * 1.1) nt4ga_adapter::port_init()
+	 * 1.1) nt4ga_adapter::nthw_port_init()
 	 */
 
 	/* No adapter set-up here, only state variables */
@@ -597,7 +597,7 @@ static int _common_ptp_nim_state_machine(void *data)
 					continue;
 				}
 
-				if (nim_state_build(&nim_ctx[i], &new_state)) {
+				if (nthw_nim_state_build(&nim_ctx[i], &new_state)) {
 					NT_LOG(ERR, NTNIC, "%s: Cannot read basic NIM data",
 						drv->mp_port_id_str[i]);
 					continue;
@@ -607,8 +607,9 @@ static int _common_ptp_nim_state_machine(void *data)
 				NT_LOG(DBG, NTNIC,
 					"%s: NIM id = %u (%s), br = %u, vendor = '%s', pn = '%s', sn='%s'",
 					drv->mp_port_id_str[i], nim_ctx->nim_id,
-					nim_id_to_text(nim_ctx->nim_id), (unsigned int)new_state.br,
-					nim_ctx->vendor_name, nim_ctx->prod_no, nim_ctx->serial_no);
+					nthw_nim_id_to_text(nim_ctx->nim_id),
+					(unsigned int)new_state.br, nim_ctx->vendor_name,
+					nim_ctx->prod_no, nim_ctx->serial_no);
 
 				(void)_link_state_build(drv, &mac_pcs[i], &gpio_phy[i], i,
 					&link_state[i], is_port_disabled);
@@ -725,7 +726,7 @@ static struct link_ops_s link_100g_ops = {
 	.link_init = nt4ga_link_100g_ports_init,
 };
 
-void link_100g_init(void)
+void nthw_link_100g_init(void)
 {
 	register_100g_link_ops(&link_100g_ops);
 }