idpf: add mailbox access to read PTP clock time

When the access to read PTP clock is specified as mailbox, the driver
needs to send virtchnl message to perform PTP actions. Message is sent
using idpf_mbq_opc_send_msg_to_peer_drv mailbox opcode, with the parameters
received during PTP capabilities negotiation.

Add functions to recognize PTP messages, move them to dedicated secondary
mailbox, read the PTP clock time and cross timestamp using mailbox
messages.

Reviewed-by: Alexander Lobakin <aleksander.lobakin@intel.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: Jacob Keller <jacob.e.keller@intel.com>
Signed-off-by: Milena Olech <milena.olech@intel.com>
Tested-by: Samuel Salin <Samuel.salin@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

diff --git a/drivers/net/ethernet/intel/idpf/idpf_controlq_api.h b/drivers/net/ethernet/intel/idpf/idpf_controlq_api.h
index e8e046ef2f0d7673f4cc24496fe6592d1de899d4..9642494a67d88ace6c32b068e98b3f4aa0fd2a27 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_controlq_api.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_controlq_api.h
@@ -123,9 +123,12 @@ struct idpf_ctlq_info {
 /**
  * enum idpf_mbx_opc - PF/VF mailbox commands
  * @idpf_mbq_opc_send_msg_to_cp: used by PF or VF to send a message to its CP
+ * @idpf_mbq_opc_send_msg_to_peer_drv: used by PF or VF to send a message to
+ *                                    any peer driver
  */
 enum idpf_mbx_opc {
        idpf_mbq_opc_send_msg_to_cp             = 0x0801,
+       idpf_mbq_opc_send_msg_to_peer_drv       = 0x0804,
 };
 
 /* API supported for control queue management */

diff --git a/drivers/net/ethernet/intel/idpf/idpf_ptp.c b/drivers/net/ethernet/intel/idpf/idpf_ptp.c
index 3322598cf7d5bc3c6489eb93a9cdb143c8295a2b..bda194b56bbe8a543aa27d2e60782eb4c924e6c5 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_ptp.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_ptp.c
@@ -92,6 +92,37 @@ static u64 idpf_ptp_read_src_clk_reg_direct(struct idpf_adapter *adapter,
        return ((u64)hi << 32) | lo;
 }
 
+/**
+ * idpf_ptp_read_src_clk_reg_mailbox - Read the main timer value through mailbox
+ * @adapter: Driver specific private structure
+ * @sts: Optional parameter for holding a pair of system timestamps from
+ *      the system clock. Will be ignored when NULL is given.
+ * @src_clk: Returned main timer value in nanoseconds unit
+ *
+ * Return: 0 on success, -errno otherwise.
+ */
+static int idpf_ptp_read_src_clk_reg_mailbox(struct idpf_adapter *adapter,
+                                            struct ptp_system_timestamp *sts,
+                                            u64 *src_clk)
+{
+       struct idpf_ptp_dev_timers clk_time;
+       int err;
+
+       /* Read the system timestamp pre PHC read */
+       ptp_read_system_prets(sts);
+
+       err = idpf_ptp_get_dev_clk_time(adapter, &clk_time);
+       if (err)
+               return err;
+
+       /* Read the system timestamp post PHC read */
+       ptp_read_system_postts(sts);
+
+       *src_clk = clk_time.dev_clk_time_ns;
+
+       return 0;
+}
+
 /**
  * idpf_ptp_read_src_clk_reg - Read the main timer value
  * @adapter: Driver specific private structure
@@ -107,6 +138,8 @@ static int idpf_ptp_read_src_clk_reg(struct idpf_adapter *adapter, u64 *src_clk,
        switch (adapter->ptp->get_dev_clk_time_access) {
        case IDPF_PTP_NONE:
                return -EOPNOTSUPP;
+       case IDPF_PTP_MAILBOX:
+               return idpf_ptp_read_src_clk_reg_mailbox(adapter, sts, src_clk);
        case IDPF_PTP_DIRECT:
                *src_clk = idpf_ptp_read_src_clk_reg_direct(adapter, sts);
                break;

diff --git a/drivers/net/ethernet/intel/idpf/idpf_ptp.h b/drivers/net/ethernet/intel/idpf/idpf_ptp.h
index 955d697e51abc0a5539f08f39038444e798e7548..b536c1cdbb2e0429007a706da8f91e8e3e12bfdf 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_ptp.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_ptp.h
@@ -52,6 +52,19 @@ enum idpf_ptp_access {
        IDPF_PTP_MAILBOX,
 };
 
+/**
+ * struct idpf_ptp_secondary_mbx - PTP secondary mailbox
+ * @peer_mbx_q_id: PTP mailbox queue ID
+ * @peer_id: Peer ID for PTP Device Control daemon
+ * @valid: indicates whether secondary mailblox is supported by the Control
+ *        Plane
+ */
+struct idpf_ptp_secondary_mbx {
+       u16 peer_mbx_q_id;
+       u16 peer_id;
+       bool valid:1;
+};
+
 /**
  * struct idpf_ptp - PTP parameters
  * @info: structure defining PTP hardware capabilities
@@ -62,6 +75,7 @@ enum idpf_ptp_access {
  * @caps: PTP capabilities negotiated with the Control Plane
  * @get_dev_clk_time_access: access type for getting the device clock time
  * @rsv: reserved bits
+ * @secondary_mbx: parameters for using dedicated PTP mailbox
  * @read_dev_clk_lock: spinlock protecting access to the device clock read
  *                    operation executed by the HW latch
  */
@@ -74,6 +88,7 @@ struct idpf_ptp {
        u32 caps;
        enum idpf_ptp_access get_dev_clk_time_access:2;
        u32 rsv:30;
+       struct idpf_ptp_secondary_mbx secondary_mbx;
        spinlock_t read_dev_clk_lock;
 };
 
@@ -91,11 +106,23 @@ idpf_ptp_info_to_adapter(const struct ptp_clock_info *info)
        return ptp->adapter;
 }
 
+/**
+ * struct idpf_ptp_dev_timers - System time and device time values
+ * @sys_time_ns: system time value expressed in nanoseconds
+ * @dev_clk_time_ns: device clock time value expressed in nanoseconds
+ */
+struct idpf_ptp_dev_timers {
+       u64 sys_time_ns;
+       u64 dev_clk_time_ns;
+};
+
 #if IS_ENABLED(CONFIG_PTP_1588_CLOCK)
 int idpf_ptp_init(struct idpf_adapter *adapter);
 void idpf_ptp_release(struct idpf_adapter *adapter);
 int idpf_ptp_get_caps(struct idpf_adapter *adapter);
 void idpf_ptp_get_features_access(const struct idpf_adapter *adapter);
+int idpf_ptp_get_dev_clk_time(struct idpf_adapter *adapter,
+                             struct idpf_ptp_dev_timers *dev_clk_time);
 #else /* CONFIG_PTP_1588_CLOCK */
 static inline int idpf_ptp_init(struct idpf_adapter *adapter)
 {
@@ -112,5 +139,12 @@ static inline int idpf_ptp_get_caps(struct idpf_adapter *adapter)
 static inline void
 idpf_ptp_get_features_access(const struct idpf_adapter *adapter) { }
 
+static inline int
+idpf_ptp_get_dev_clk_time(struct idpf_adapter *adapter,
+                         struct idpf_ptp_dev_timers *dev_clk_time)
+{
+       return -EOPNOTSUPP;
+}
+
 #endif /* CONFIG_PTP_1588_CLOCK */
 #endif /* _IDPF_PTP_H */

diff --git a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
index e27f3f2777a26fbba02e7e4f0aa6fb7133932874..0fc2be15b5395dd145e392b56790da1939e5ec3d 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
@@ -154,6 +154,50 @@ err_kfree:
        return err;
 }
 
+#if IS_ENABLED(CONFIG_PTP_1588_CLOCK)
+/**
+ * idpf_ptp_is_mb_msg - Check if the message is PTP-related
+ * @op: virtchnl opcode
+ *
+ * Return: true if msg is PTP-related, false otherwise.
+ */
+static bool idpf_ptp_is_mb_msg(u32 op)
+{
+       switch (op) {
+       case VIRTCHNL2_OP_PTP_GET_DEV_CLK_TIME:
+       case VIRTCHNL2_OP_PTP_GET_CROSS_TIME:
+               return true;
+       default:
+               return false;
+       }
+}
+
+/**
+ * idpf_prepare_ptp_mb_msg - Prepare PTP related message
+ *
+ * @adapter: Driver specific private structure
+ * @op: virtchnl opcode
+ * @ctlq_msg: Corresponding control queue message
+ */
+static void idpf_prepare_ptp_mb_msg(struct idpf_adapter *adapter, u32 op,
+                                   struct idpf_ctlq_msg *ctlq_msg)
+{
+       /* If the message is PTP-related and the secondary mailbox is available,
+        * send the message through the secondary mailbox.
+        */
+       if (!idpf_ptp_is_mb_msg(op) || !adapter->ptp->secondary_mbx.valid)
+               return;
+
+       ctlq_msg->opcode = idpf_mbq_opc_send_msg_to_peer_drv;
+       ctlq_msg->func_id = adapter->ptp->secondary_mbx.peer_mbx_q_id;
+       ctlq_msg->host_id = adapter->ptp->secondary_mbx.peer_id;
+}
+#else /* !CONFIG_PTP_1588_CLOCK */
+static void idpf_prepare_ptp_mb_msg(struct idpf_adapter *adapter, u32 op,
+                                   struct idpf_ctlq_msg *ctlq_msg)
+{ }
+#endif /* CONFIG_PTP_1588_CLOCK */
+
 /**
  * idpf_send_mb_msg - Send message over mailbox
  * @adapter: Driver specific private structure
@@ -197,6 +241,9 @@ int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op,
 
        ctlq_msg->opcode = idpf_mbq_opc_send_msg_to_cp;
        ctlq_msg->func_id = 0;
+
+       idpf_prepare_ptp_mb_msg(adapter, op, ctlq_msg);
+
        ctlq_msg->data_len = msg_size;
        ctlq_msg->cookie.mbx.chnl_opcode = op;
        ctlq_msg->cookie.mbx.chnl_retval = 0;

diff --git a/drivers/net/ethernet/intel/idpf/idpf_virtchnl_ptp.c b/drivers/net/ethernet/intel/idpf/idpf_virtchnl_ptp.c
index c3c6b920f2778a948e999461c2e6b289f14bf9d7..79bd2585703b9bad081ff460c61d8ab8cd06b83f 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_virtchnl_ptp.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_virtchnl_ptp.c
@@ -29,6 +29,7 @@ int idpf_ptp_get_caps(struct idpf_adapter *adapter)
                .timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC,
        };
        struct virtchnl2_ptp_clk_reg_offsets clock_offsets;
+       struct idpf_ptp_secondary_mbx *scnd_mbx;
        struct idpf_ptp *ptp = adapter->ptp;
        enum idpf_ptp_access access_type;
        u32 temp_offset;
@@ -50,6 +51,16 @@ int idpf_ptp_get_caps(struct idpf_adapter *adapter)
 
        ptp->caps = le32_to_cpu(recv_ptp_caps_msg->caps);
 
+       scnd_mbx = &ptp->secondary_mbx;
+       scnd_mbx->peer_mbx_q_id = le16_to_cpu(recv_ptp_caps_msg->peer_mbx_q_id);
+
+       /* if the ptp_mb_q_id holds invalid value (0xffff), the secondary
+        * mailbox is not supported.
+        */
+       scnd_mbx->valid = scnd_mbx->peer_mbx_q_id != 0xffff;
+       if (scnd_mbx->valid)
+               scnd_mbx->peer_id = recv_ptp_caps_msg->peer_id;
+
        /* Determine the access type for the PTP features */
        idpf_ptp_get_features_access(adapter);
 
@@ -76,3 +87,39 @@ int idpf_ptp_get_caps(struct idpf_adapter *adapter)
 
        return 0;
 }
+
+/**
+ * idpf_ptp_get_dev_clk_time - Send virtchnl get device clk time message
+ * @adapter: Driver specific private structure
+ * @dev_clk_time: Pointer to the device clock structure where the value is set
+ *
+ * Send virtchnl get time message to get the time of the clock.
+ *
+ * Return: 0 on success, -errno otherwise.
+ */
+int idpf_ptp_get_dev_clk_time(struct idpf_adapter *adapter,
+                             struct idpf_ptp_dev_timers *dev_clk_time)
+{
+       struct virtchnl2_ptp_get_dev_clk_time get_dev_clk_time_msg;
+       struct idpf_vc_xn_params xn_params = {
+               .vc_op = VIRTCHNL2_OP_PTP_GET_DEV_CLK_TIME,
+               .send_buf.iov_base = &get_dev_clk_time_msg,
+               .send_buf.iov_len = sizeof(get_dev_clk_time_msg),
+               .recv_buf.iov_base = &get_dev_clk_time_msg,
+               .recv_buf.iov_len = sizeof(get_dev_clk_time_msg),
+               .timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC,
+       };
+       int reply_sz;
+       u64 dev_time;
+
+       reply_sz = idpf_vc_xn_exec(adapter, &xn_params);
+       if (reply_sz < 0)
+               return reply_sz;
+       if (reply_sz != sizeof(get_dev_clk_time_msg))
+               return -EIO;
+
+       dev_time = le64_to_cpu(get_dev_clk_time_msg.dev_time_ns);
+       dev_clk_time->dev_clk_time_ns = dev_time;
+
+       return 0;
+}