net/qede/base: initialize resc lock/unlock params

Add a function that provides default initialization to resc lock/unlock
parameters. Change acquire flow that use resources into using this
function.

Signed-off-by: Rasesh Mody <rasesh.mody@cavium.com>

diff --git a/drivers/net/qede/base/ecore_dev.c b/drivers/net/qede/base/ecore_dev.c
index 1608b19..40959e7 100644 (file)
--- a/drivers/net/qede/base/ecore_dev.c
+++ b/drivers/net/qede/base/ecore_dev.c
@@ -2836,9 +2836,6 @@ static enum _ecore_status_t ecore_hw_set_resc_info(struct ecore_hwfn *p_hwfn,
        return ECORE_SUCCESS;
 }
 
-#define ECORE_RESC_ALLOC_LOCK_RETRY_CNT                10
-#define ECORE_RESC_ALLOC_LOCK_RETRY_INTVL_US   10000 /* 10 msec */
-
 static enum _ecore_status_t ecore_hw_get_resc(struct ecore_hwfn *p_hwfn,
                                              struct ecore_ptt *p_ptt,
                                              bool drv_resc_alloc)
@@ -2870,13 +2867,9 @@ static enum _ecore_status_t ecore_hw_get_resc(struct ecore_hwfn *p_hwfn,
         * Old drivers that don't acquire the lock can run in parallel, and
         * their allocation values won't be affected by the updated max values.
         */
-       OSAL_MEM_ZERO(&resc_lock_params, sizeof(resc_lock_params));
-       resc_lock_params.resource = ECORE_RESC_LOCK_RESC_ALLOC;
-       resc_lock_params.retry_num = ECORE_RESC_ALLOC_LOCK_RETRY_CNT;
-       resc_lock_params.retry_interval = ECORE_RESC_ALLOC_LOCK_RETRY_INTVL_US;
-       resc_lock_params.sleep_b4_retry = true;
-       OSAL_MEM_ZERO(&resc_unlock_params, sizeof(resc_unlock_params));
-       resc_unlock_params.resource = ECORE_RESC_LOCK_RESC_ALLOC;
+       ecore_mcp_resc_lock_default_init(p_hwfn, &resc_lock_params,
+                                        &resc_unlock_params,
+                                        ECORE_RESC_LOCK_RESC_ALLOC, false);
 
        rc = ecore_mcp_resc_lock(p_hwfn, p_ptt, &resc_lock_params);
        if (rc != ECORE_SUCCESS && rc != ECORE_NOTIMPL) {

diff --git a/drivers/net/qede/base/ecore_mcp.c b/drivers/net/qede/base/ecore_mcp.c
index 24f65cf..7169b55 100644 (file)
--- a/drivers/net/qede/base/ecore_mcp.c
+++ b/drivers/net/qede/base/ecore_mcp.c
@@ -3401,6 +3401,38 @@ ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
        return ECORE_SUCCESS;
 }
 
+void
+ecore_mcp_resc_lock_default_init(struct ecore_hwfn *p_hwfn,
+                                struct ecore_resc_lock_params *p_lock,
+                                struct ecore_resc_unlock_params *p_unlock,
+                                enum ecore_resc_lock resource,
+                                bool b_is_permanent)
+{
+       if (p_lock != OSAL_NULL) {
+               OSAL_MEM_ZERO(p_lock, sizeof(*p_lock));
+
+               /* Permanent resources don't require aging, and there's no
+                * point in trying to acquire them more than once since it's
+                * unexpected another entity would release them.
+                */
+               if (b_is_permanent) {
+                       p_lock->timeout = ECORE_MCP_RESC_LOCK_TO_NONE;
+               } else {
+                       p_lock->retry_num = ECORE_MCP_RESC_LOCK_RETRY_CNT_DFLT;
+                       p_lock->retry_interval =
+                                       ECORE_MCP_RESC_LOCK_RETRY_VAL_DFLT;
+                       p_lock->sleep_b4_retry = true;
+               }
+
+               p_lock->resource = resource;
+       }
+
+       if (p_unlock != OSAL_NULL) {
+               OSAL_MEM_ZERO(p_unlock, sizeof(*p_unlock));
+               p_unlock->resource = resource;
+       }
+}
+
 enum _ecore_status_t
 ecore_mcp_resc_unlock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
                      struct ecore_resc_unlock_params *p_params)

diff --git a/drivers/net/qede/base/ecore_mcp.h b/drivers/net/qede/base/ecore_mcp.h
index dae0720..df80e11 100644 (file)
--- a/drivers/net/qede/base/ecore_mcp.h
+++ b/drivers/net/qede/base/ecore_mcp.h
@@ -413,7 +413,12 @@ enum ecore_resc_lock {
        /* Locks that the MFW is aware of should be added here downwards */
 
        /* Ecore only locks should be added here upwards */
-       ECORE_RESC_LOCK_RESC_ALLOC = ECORE_MCP_RESC_LOCK_MAX_VAL
+       ECORE_RESC_LOCK_RESC_ALLOC = ECORE_MCP_RESC_LOCK_MAX_VAL,
+
+       /* A dummy value to be used for auxiliary functions in need of
+        * returning an 'error' value.
+        */
+       ECORE_RESC_LOCK_RESC_INVALID,
 };
 
 struct ecore_resc_lock_params {
@@ -427,9 +432,11 @@ struct ecore_resc_lock_params {
 
        /* Number of times to retry locking */
        u8 retry_num;
+#define ECORE_MCP_RESC_LOCK_RETRY_CNT_DFLT     10
 
        /* The interval in usec between retries */
        u16 retry_interval;
+#define ECORE_MCP_RESC_LOCK_RETRY_VAL_DFLT     10000
 
        /* Use sleep or delay between retries */
        bool sleep_b4_retry;
@@ -480,6 +487,22 @@ enum _ecore_status_t
 ecore_mcp_resc_unlock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt,
                      struct ecore_resc_unlock_params *p_params);
 
+/**
+ * @brief - default initialization for lock/unlock resource structs
+ *
+ * @param p_hwfn
+ * @param p_lock - lock params struct to be initialized; Can be OSAL_NULL
+ * @param p_unlock - unlock params struct to be initialized; Can be OSAL_NULL
+ * @param resource - the requested resource
+ * @paral b_is_permanent - disable retries & aging when set
+ */
+void
+ecore_mcp_resc_lock_default_init(struct ecore_hwfn *p_hwfn,
+                                struct ecore_resc_lock_params *p_lock,
+                                struct ecore_resc_unlock_params *p_unlock,
+                                enum ecore_resc_lock resource,
+                                bool b_is_permanent);
+
 /**
  * @brief Learn of supported MFW features; To be done during early init
  *