net/ice: factorize firmware loading

Both "normal" and "dcf" inits have their copy of some firmware loading
code.

The DSN query is moved in specific parts for the "normal" and "dcf" init.

A common helper ice_load_pkg is then introduced and takes an adapter
pointer as its main input.

This helper takes care of finding the right firmware file and loading
it.
The adapter active_pkg_type field is set by this helper.

The ice_access macro is removed from the osdep.h header: osdep.h should
only hosts wrappers for base driver code.

Signed-off-by: David Marchand <david.marchand@redhat.com>
Acked-by: Haiyue Wang <haiyue.wang@intel.com>

diff --git a/drivers/net/ice/base/ice_osdep.h b/drivers/net/ice/base/ice_osdep.h
index 154fe96..8160eb6 100644 (file)
--- a/drivers/net/ice/base/ice_osdep.h
+++ b/drivers/net/ice/base/ice_osdep.h
@@ -73,12 +73,6 @@ typedef uint64_t        s64;
 #define min(a, b) RTE_MIN(a, b)
 #define max(a, b) RTE_MAX(a, b)
 
-#ifdef RTE_EXEC_ENV_WINDOWS
-#define ice_access _access
-#else
-#define ice_access access
-#endif
-
 #define FIELD_SIZEOF(t, f) RTE_SIZEOF_FIELD(t, f)
 #define ARRAY_SIZE(arr) RTE_DIM(arr)
 

diff --git a/drivers/net/ice/ice_dcf_parent.c b/drivers/net/ice/ice_dcf_parent.c
index c59cd0b..020f764 100644 (file)
--- a/drivers/net/ice/ice_dcf_parent.c
+++ b/drivers/net/ice/ice_dcf_parent.c
@@ -372,13 +372,14 @@ static void ice_dcf_uninit_parent_hw(struct ice_hw *hw)
 }
 
 static int
-ice_dcf_request_pkg_name(struct ice_hw *hw, char *pkg_name)
+ice_dcf_load_pkg(struct ice_adapter *adapter)
 {
        struct ice_dcf_adapter *dcf_adapter =
-                       container_of(hw, struct ice_dcf_adapter, parent.hw);
+                       container_of(&adapter->hw, struct ice_dcf_adapter, parent.hw);
        struct virtchnl_pkg_info pkg_info;
        struct dcf_virtchnl_cmd vc_cmd;
-       uint64_t dsn;
+       bool use_dsn;
+       uint64_t dsn = 0;
 
        vc_cmd.v_op = VIRTCHNL_OP_DCF_GET_PKG_INFO;
        vc_cmd.req_msglen = 0;
@@ -386,90 +387,11 @@ ice_dcf_request_pkg_name(struct ice_hw *hw, char *pkg_name)
        vc_cmd.rsp_buflen = sizeof(pkg_info);
        vc_cmd.rsp_msgbuf = (uint8_t *)&pkg_info;
 
-       if (ice_dcf_execute_virtchnl_cmd(&dcf_adapter->real_hw, &vc_cmd))
-               goto pkg_file_direct;
+       use_dsn = ice_dcf_execute_virtchnl_cmd(&dcf_adapter->real_hw, &vc_cmd) == 0;
+       if (use_dsn)
+               rte_memcpy(&dsn, pkg_info.dsn, sizeof(dsn));
 
-       rte_memcpy(&dsn, pkg_info.dsn, sizeof(dsn));
-
-       snprintf(pkg_name, ICE_MAX_PKG_FILENAME_SIZE,
-                ICE_PKG_FILE_SEARCH_PATH_UPDATES "ice-%016llx.pkg",
-                (unsigned long long)dsn);
-       if (!ice_access(pkg_name, 0))
-               return 0;
-
-       snprintf(pkg_name, ICE_MAX_PKG_FILENAME_SIZE,
-                ICE_PKG_FILE_SEARCH_PATH_DEFAULT "ice-%016llx.pkg",
-                (unsigned long long)dsn);
-       if (!ice_access(pkg_name, 0))
-               return 0;
-
-pkg_file_direct:
-       snprintf(pkg_name,
-                ICE_MAX_PKG_FILENAME_SIZE, "%s", ICE_PKG_FILE_UPDATES);
-       if (!ice_access(pkg_name, 0))
-               return 0;
-
-       snprintf(pkg_name,
-                ICE_MAX_PKG_FILENAME_SIZE, "%s", ICE_PKG_FILE_DEFAULT);
-       if (!ice_access(pkg_name, 0))
-               return 0;
-
-       return -1;
-}
-
-static int
-ice_dcf_load_pkg(struct ice_hw *hw)
-{
-       char pkg_name[ICE_MAX_PKG_FILENAME_SIZE];
-       uint8_t *pkg_buf;
-       uint32_t buf_len;
-       struct stat st;
-       FILE *fp;
-       int err;
-
-       if (ice_dcf_request_pkg_name(hw, pkg_name)) {
-               PMD_INIT_LOG(ERR, "Failed to locate the package file");
-               return -ENOENT;
-       }
-
-       PMD_INIT_LOG(DEBUG, "DDP package name: %s", pkg_name);
-
-       err = stat(pkg_name, &st);
-       if (err) {
-               PMD_INIT_LOG(ERR, "Failed to get file status");
-               return err;
-       }
-
-       buf_len = st.st_size;
-       pkg_buf = rte_malloc(NULL, buf_len, 0);
-       if (!pkg_buf) {
-               PMD_INIT_LOG(ERR, "failed to allocate buffer of size %u for package",
-                            buf_len);
-               return -1;
-       }
-
-       fp = fopen(pkg_name, "rb");
-       if (!fp)  {
-               PMD_INIT_LOG(ERR, "failed to open file: %s", pkg_name);
-               err = -1;
-               goto ret;
-       }
-
-       err = fread(pkg_buf, buf_len, 1, fp);
-       fclose(fp);
-       if (err != 1) {
-               PMD_INIT_LOG(ERR, "failed to read package data");
-               err = -1;
-               goto ret;
-       }
-
-       err = ice_copy_and_init_pkg(hw, pkg_buf, buf_len);
-       if (err)
-               PMD_INIT_LOG(ERR, "ice_copy_and_init_hw failed: %d", err);
-
-ret:
-       rte_free(pkg_buf);
-       return err;
+       return ice_load_pkg(adapter, use_dsn, dsn);
 }
 
 int
@@ -518,13 +440,12 @@ ice_dcf_init_parent_adapter(struct rte_eth_dev *eth_dev)
                }
        }
 
-       err = ice_dcf_load_pkg(parent_hw);
+       err = ice_dcf_load_pkg(parent_adapter);
        if (err) {
                PMD_INIT_LOG(ERR, "failed to load package with error %d",
                             err);
                goto uninit_hw;
        }
-       parent_adapter->active_pkg_type = ice_load_pkg_type(parent_hw);
 
        parent_adapter->pf.main_vsi->idx = hw->num_vfs;
        ice_dcf_update_pf_vsi_map(parent_hw,

diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c
index 63f735d..6c3d2d9 100644 (file)
--- a/drivers/net/ice/ice_ethdev.c
+++ b/drivers/net/ice/ice_ethdev.c
@@ -1651,57 +1651,7 @@ ice_pf_setup(struct ice_pf *pf)
        return 0;
 }
 
-/*
- * Extract device serial number from PCIe Configuration Space and
- * determine the pkg file path according to the DSN.
- */
-#ifndef RTE_EXEC_ENV_WINDOWS
-static int
-ice_pkg_file_search_path(struct rte_pci_device *pci_dev, char *pkg_file)
-{
-       off_t pos;
-       char opt_ddp_filename[ICE_MAX_PKG_FILENAME_SIZE];
-       uint32_t dsn_low, dsn_high;
-       memset(opt_ddp_filename, 0, ICE_MAX_PKG_FILENAME_SIZE);
-
-       pos = rte_pci_find_ext_capability(pci_dev, RTE_PCI_EXT_CAP_ID_DSN);
-
-       if (pos) {
-               if (rte_pci_read_config(pci_dev, &dsn_low, 4, pos + 4) < 0) {
-                       PMD_INIT_LOG(ERR, "Failed to read pci config space\n");
-                       return -1;
-               }
-               if (rte_pci_read_config(pci_dev, &dsn_high, 4, pos + 8) < 0) {
-                       PMD_INIT_LOG(ERR, "Failed to read pci config space\n");
-                       return -1;
-               }
-               snprintf(opt_ddp_filename, ICE_MAX_PKG_FILENAME_SIZE,
-                        "ice-%08x%08x.pkg", dsn_high, dsn_low);
-       } else {
-               PMD_INIT_LOG(ERR, "Failed to read device serial number\n");
-               goto fail_dsn;
-       }
-
-       strncpy(pkg_file, ICE_PKG_FILE_SEARCH_PATH_UPDATES,
-               ICE_MAX_PKG_FILENAME_SIZE);
-       if (!ice_access(strcat(pkg_file, opt_ddp_filename), 0))
-               return 0;
-
-       strncpy(pkg_file, ICE_PKG_FILE_SEARCH_PATH_DEFAULT,
-               ICE_MAX_PKG_FILENAME_SIZE);
-       if (!ice_access(strcat(pkg_file, opt_ddp_filename), 0))
-               return 0;
-
-fail_dsn:
-       strncpy(pkg_file, ICE_PKG_FILE_UPDATES, ICE_MAX_PKG_FILENAME_SIZE);
-       if (!ice_access(pkg_file, 0))
-               return 0;
-       strncpy(pkg_file, ICE_PKG_FILE_DEFAULT, ICE_MAX_PKG_FILENAME_SIZE);
-       return 0;
-}
-#endif
-
-enum ice_pkg_type
+static enum ice_pkg_type
 ice_load_pkg_type(struct ice_hw *hw)
 {
        enum ice_pkg_type package_type;
@@ -1725,37 +1675,62 @@ ice_load_pkg_type(struct ice_hw *hw)
        return package_type;
 }
 
-#ifndef RTE_EXEC_ENV_WINDOWS
-static int ice_load_pkg(struct rte_eth_dev *dev)
+#ifdef RTE_EXEC_ENV_WINDOWS
+#define ice_access _access
+#else
+#define ice_access access
+#endif
+
+int ice_load_pkg(struct ice_adapter *adapter, bool use_dsn, uint64_t dsn)
 {
-       struct ice_hw *hw = ICE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+       struct ice_hw *hw = &adapter->hw;
        char pkg_file[ICE_MAX_PKG_FILENAME_SIZE];
+       char opt_ddp_filename[ICE_MAX_PKG_FILENAME_SIZE];
        int err;
-       uint8_t *buf;
+       uint8_t *buf = NULL;
        int buf_len;
        FILE *file;
        struct stat fstat;
-       struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(dev->device);
-       struct ice_adapter *ad =
-               ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
 
-       err = ice_pkg_file_search_path(pci_dev, pkg_file);
-       if (err) {
+       if (!use_dsn)
+               goto no_dsn;
+
+       memset(opt_ddp_filename, 0, ICE_MAX_PKG_FILENAME_SIZE);
+       snprintf(opt_ddp_filename, ICE_MAX_PKG_FILENAME_SIZE,
+               "ice-%016" PRIx64 ".pkg", dsn);
+       strncpy(pkg_file, ICE_PKG_FILE_SEARCH_PATH_UPDATES,
+               ICE_MAX_PKG_FILENAME_SIZE);
+       if (!ice_access(strcat(pkg_file, opt_ddp_filename), 0))
+               goto load_fw;
+
+       strncpy(pkg_file, ICE_PKG_FILE_SEARCH_PATH_DEFAULT,
+               ICE_MAX_PKG_FILENAME_SIZE);
+       if (!ice_access(strcat(pkg_file, opt_ddp_filename), 0))
+               goto load_fw;
+
+no_dsn:
+       strncpy(pkg_file, ICE_PKG_FILE_UPDATES, ICE_MAX_PKG_FILENAME_SIZE);
+       if (!ice_access(pkg_file, 0))
+               goto load_fw;
+       strncpy(pkg_file, ICE_PKG_FILE_DEFAULT, ICE_MAX_PKG_FILENAME_SIZE);
+       if (ice_access(pkg_file, 0)) {
                PMD_INIT_LOG(ERR, "failed to search file path\n");
-               return err;
+               return -1;
        }
 
+load_fw:
        file = fopen(pkg_file, "rb");
        if (!file)  {
                PMD_INIT_LOG(ERR, "failed to open file: %s\n", pkg_file);
                return -1;
        }
 
+       PMD_INIT_LOG(DEBUG, "DDP package name: %s", pkg_file);
+
        err = stat(pkg_file, &fstat);
        if (err) {
                PMD_INIT_LOG(ERR, "failed to get file stats\n");
-               fclose(file);
-               return err;
+               goto out;
        }
 
        buf_len = fstat.st_size;
@@ -1764,44 +1739,33 @@ static int ice_load_pkg(struct rte_eth_dev *dev)
        if (!buf) {
                PMD_INIT_LOG(ERR, "failed to allocate buf of size %d for package\n",
                                buf_len);
-               fclose(file);
-               return -1;
+               err = -1;
+               goto out;
        }
 
        err = fread(buf, buf_len, 1, file);
        if (err != 1) {
                PMD_INIT_LOG(ERR, "failed to read package data\n");
-               fclose(file);
                err = -1;
-               goto fail_exit;
+               goto out;
        }
 
-       fclose(file);
-
        err = ice_copy_and_init_pkg(hw, buf, buf_len);
        if (err) {
                PMD_INIT_LOG(ERR, "ice_copy_and_init_hw failed: %d\n", err);
-               goto fail_exit;
+               goto out;
        }
 
        /* store the loaded pkg type info */
-       ad->active_pkg_type = ice_load_pkg_type(hw);
+       adapter->active_pkg_type = ice_load_pkg_type(hw);
 
-       err = ice_init_hw_tbls(hw);
-       if (err) {
-               PMD_INIT_LOG(ERR, "ice_init_hw_tbls failed: %d\n", err);
-               goto fail_init_tbls;
-       }
-
-       return 0;
-
-fail_init_tbls:
-       rte_free(hw->pkg_copy);
-fail_exit:
+out:
+       fclose(file);
        rte_free(buf);
        return err;
 }
-#endif
+
+#undef ice_access
 
 static void
 ice_base_queue_get(struct ice_pf *pf)
@@ -2056,6 +2020,12 @@ ice_dev_init(struct rte_eth_dev *dev)
                ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
        struct ice_vsi *vsi;
        int ret;
+#ifndef RTE_EXEC_ENV_WINDOWS
+       off_t pos;
+       uint32_t dsn_low, dsn_high;
+       uint64_t dsn;
+       bool use_dsn;
+#endif
 
        dev->dev_ops = &ice_eth_dev_ops;
        dev->rx_queue_count = ice_rx_queue_count;
@@ -2106,7 +2076,30 @@ ice_dev_init(struct rte_eth_dev *dev)
        }
 
 #ifndef RTE_EXEC_ENV_WINDOWS
-       ret = ice_load_pkg(dev);
+       use_dsn = false;
+       dsn = 0;
+       pos = rte_pci_find_ext_capability(pci_dev, RTE_PCI_EXT_CAP_ID_DSN);
+       if (pos) {
+               if (rte_pci_read_config(pci_dev, &dsn_low, 4, pos + 4) < 0 ||
+                               rte_pci_read_config(pci_dev, &dsn_high, 4, pos + 8) < 0) {
+                       PMD_INIT_LOG(ERR, "Failed to read pci config space\n");
+               } else {
+                       use_dsn = true;
+                       dsn = (uint64_t)dsn_high << 32 | dsn_low;
+               }
+       } else {
+               PMD_INIT_LOG(ERR, "Failed to read device serial number\n");
+       }
+
+       ret = ice_load_pkg(pf->adapter, use_dsn, dsn);
+       if (ret == 0) {
+               ret = ice_init_hw_tbls(hw);
+               if (ret) {
+                       PMD_INIT_LOG(ERR, "ice_init_hw_tbls failed: %d\n", ret);
+                       rte_free(hw->pkg_copy);
+               }
+       }
+
        if (ret) {
                if (ad->devargs.safe_mode_support == 0) {
                        PMD_INIT_LOG(ERR, "Failed to load the DDP package,"

diff --git a/drivers/net/ice/ice_ethdev.h b/drivers/net/ice/ice_ethdev.h
index 7f3c26f..edafdf1 100644 (file)
--- a/drivers/net/ice/ice_ethdev.h
+++ b/drivers/net/ice/ice_ethdev.h
@@ -534,7 +534,8 @@ struct ice_vsi_vlan_pvid_info {
 #define ICE_PF_TO_ETH_DEV(pf) \
        (((struct ice_pf *)pf)->adapter->eth_dev)
 
-enum ice_pkg_type ice_load_pkg_type(struct ice_hw *hw);
+int
+ice_load_pkg(struct ice_adapter *adapter, bool use_dsn, uint64_t dsn);
 struct ice_vsi *
 ice_setup_vsi(struct ice_pf *pf, enum ice_vsi_type type);
 int