qed: Add support for MFW resource locking.

Orabug: 26783820

The patch adds API for default initialization of the MFW resource
locking.

Signed-off-by: Sudarsana Reddy Kalluru <Sudarsana.Kalluru@cavium.com>
Signed-off-by: Yuval Mintz <Yuval.Mintz@cavium.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
[ Upstream commit f470f22cfa3d42f357ed404a06ec77aa09ddb05b ]
Signed-off-by: Somasundaram Krishnasamy <somasundaram.krishnasamy@oracle.com>

diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev.c b/drivers/net/ethernet/qlogic/qed/qed_dev.c
index 081843958076a5748f3117c2b063a3c06c2f0852..4f72e3924f117c6ef453a45b496acbda58734ecb 100644 (file)
--- a/drivers/net/ethernet/qlogic/qed/qed_dev.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_dev.c
@@ -2322,9 +2322,6 @@ static int qed_hw_set_resc_info(struct qed_hwfn *p_hwfn)
        return 0;
 }
 
-#define QED_RESC_ALLOC_LOCK_RETRY_CNT           10
-#define QED_RESC_ALLOC_LOCK_RETRY_INTVL_US      10000  /* 10 msec */
-
 static int qed_hw_get_resc(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
 {
        struct qed_resc_unlock_params resc_unlock_params;
@@ -2341,13 +2338,8 @@ static int qed_hw_get_resc(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
         * needed, and proceed to the queries. Other failures, including a
         * failure to acquire the lock, will cause this function to fail.
         */
-       memset(&resc_lock_params, 0, sizeof(resc_lock_params));
-       resc_lock_params.resource = QED_RESC_LOCK_RESC_ALLOC;
-       resc_lock_params.retry_num = QED_RESC_ALLOC_LOCK_RETRY_CNT;
-       resc_lock_params.retry_interval = QED_RESC_ALLOC_LOCK_RETRY_INTVL_US;
-       resc_lock_params.sleep_b4_retry = true;
-       memset(&resc_unlock_params, 0, sizeof(resc_unlock_params));
-       resc_unlock_params.resource = QED_RESC_LOCK_RESC_ALLOC;
+       qed_mcp_resc_lock_default_init(&resc_lock_params, &resc_unlock_params,
+                                      QED_RESC_LOCK_RESC_ALLOC, false);
 
        rc = qed_mcp_resc_lock(p_hwfn, p_ptt, &resc_lock_params);
        if (rc && rc != -EINVAL) {

diff --git a/drivers/net/ethernet/qlogic/qed/qed_mcp.c b/drivers/net/ethernet/qlogic/qed/qed_mcp.c
index bfeeed380a970ddf540e370bfb9c4e184a4acd33..3a96f99a84d4f4dc4f519f9677c3091e4b7d4329 100644 (file)
--- a/drivers/net/ethernet/qlogic/qed/qed_mcp.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_mcp.c
@@ -2612,3 +2612,33 @@ qed_mcp_resc_unlock(struct qed_hwfn *p_hwfn,
 
        return 0;
 }
+
+void qed_mcp_resc_lock_default_init(struct qed_resc_lock_params *p_lock,
+                                   struct qed_resc_unlock_params *p_unlock,
+                                   enum qed_resc_lock
+                                   resource, bool b_is_permanent)
+{
+       if (p_lock) {
+               memset(p_lock, 0, 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 = QED_MCP_RESC_LOCK_TO_NONE;
+               } else {
+                       p_lock->retry_num = QED_MCP_RESC_LOCK_RETRY_CNT_DFLT;
+                       p_lock->retry_interval =
+                           QED_MCP_RESC_LOCK_RETRY_VAL_DFLT;
+                       p_lock->sleep_b4_retry = true;
+               }
+
+               p_lock->resource = resource;
+       }
+
+       if (p_unlock) {
+               memset(p_unlock, 0, sizeof(*p_unlock));
+               p_unlock->resource = resource;
+       }
+}

diff --git a/drivers/net/ethernet/qlogic/qed/qed_mcp.h b/drivers/net/ethernet/qlogic/qed/qed_mcp.h
index 76fd3d2ead3bd49c4ec1623040089d70fcfc457b..4a3152b1072c0944cb66fcb99084de855feeeec9 100644 (file)
--- a/drivers/net/ethernet/qlogic/qed/qed_mcp.h
+++ b/drivers/net/ethernet/qlogic/qed/qed_mcp.h
@@ -794,7 +794,8 @@ int qed_mcp_ov_update_eswitch(struct qed_hwfn *p_hwfn,
 
 enum qed_resc_lock {
        QED_RESC_LOCK_DBG_DUMP = QED_MCP_RESC_LOCK_MIN_VAL,
-       QED_RESC_LOCK_RESC_ALLOC = QED_MCP_RESC_LOCK_MAX_VAL
+       QED_RESC_LOCK_RESC_ALLOC = QED_MCP_RESC_LOCK_MAX_VAL,
+       QED_RESC_LOCK_RESC_INVALID
 };
 
 /**
@@ -817,9 +818,11 @@ struct qed_resc_lock_params {
 
        /* Number of times to retry locking */
        u8 retry_num;
+#define QED_MCP_RESC_LOCK_RETRY_CNT_DFLT        10
 
        /* The interval in usec between retries */
        u16 retry_interval;
+#define QED_MCP_RESC_LOCK_RETRY_VAL_DFLT        10000
 
        /* Use sleep or delay between retries */
        bool sleep_b4_retry;
@@ -871,4 +874,17 @@ qed_mcp_resc_unlock(struct qed_hwfn *p_hwfn,
                    struct qed_ptt *p_ptt,
                    struct qed_resc_unlock_params *p_params);
 
+/**
+ * @brief - default initialization for lock/unlock resource structs
+ *
+ * @param p_lock - lock params struct to be initialized; Can be NULL
+ * @param p_unlock - unlock params struct to be initialized; Can be NULL
+ * @param resource - the requested resource
+ * @paral b_is_permanent - disable retries & aging when set
+ */
+void qed_mcp_resc_lock_default_init(struct qed_resc_lock_params *p_lock,
+                                   struct qed_resc_unlock_params *p_unlock,
+                                   enum qed_resc_lock
+                                   resource, bool b_is_permanent);
+
 #endif