From nobody Thu Apr 2 22:07:16 2026 Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A74F2413229; Thu, 26 Mar 2026 16:33:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=192.198.163.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774542792; cv=none; b=JdpkoDZgdubqh3UpSon80CajpspOTFW14Xd8KMlG1U8mx4gRmh3/DM6wgKNEv9R2LwRLbTm2OOrr/0fCzdOqX7G/dfWr1L3IdCHgntFqJV/LWhFAiug6jiZWuvyt9p2XZyPfGWvdMYpEeW5ZMjtMBgVjKbkvx+NxvuF3KVkXJaA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774542792; c=relaxed/simple; bh=RXeLAwQd/WhX+HnMNBfpNgz9UNtamMV0lERMiFBdSsM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=qAODhYGQGqYBMmQADe1+P+uFtFZ5AclWlixynBHPKVHWEqizVzjAhsWV4dJ5joOxkWEwX0VvsdglTQ9LHSsb+OX32hU18hOILtH14wrt+OSHyQQ1pt9fLM3UlFk1eMM2ArhSwE6UCHT/Agriluct+95Ihnv2cSOlwIx6Q1bw7a8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=intel.com; spf=pass smtp.mailfrom=intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=hAIyITwK; arc=none smtp.client-ip=192.198.163.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="hAIyITwK" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1774542790; x=1806078790; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RXeLAwQd/WhX+HnMNBfpNgz9UNtamMV0lERMiFBdSsM=; b=hAIyITwKp4ACYN/cRXj0w8pn1RS8FflpkBKWQar+eFgrs87SMtkUaQEC EyToFWtf4cZyuZ/St+lpcLaujydD74poUYbaSdTY9N6f7ENLqfvt1c3NN 7waW2XCNusa49cdt6KcxrGD5D/3nCXP32TnY5xMyep6StoWvkF8MkW1eT aWzEaKWdQR6W0kqg/LYI00TJdUjylAqwvfmiNmMmLBNMkXoEPprN5Eqym KDG1RLSSU7hR3ESu8XCEvqL5gg08lXa2mPMbqgxLYJdR4UKleljRZj7Im W2B087m/qEE/S85/pxVcGVWAdID9q/H63KqvExNpvtp66W48eJHGx+Nub w==; X-CSE-ConnectionGUID: THtOdPxFSrSXywdvANJm0w== X-CSE-MsgGUID: FDuJWYPaRo+nuJEGslCTFQ== X-IronPort-AV: E=McAfee;i="6800,10657,11741"; a="74636714" X-IronPort-AV: E=Sophos;i="6.23,142,1770624000"; d="scan'208";a="74636714" Received: from orviesa007.jf.intel.com ([10.64.159.147]) by fmvoesa113.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 26 Mar 2026 09:33:10 -0700 X-CSE-ConnectionGUID: 06dnr0SJRoGxAQ1iFRumMg== X-CSE-MsgGUID: y/jfD1TFR0eN4K+pN3EBqQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.23,142,1770624000"; d="scan'208";a="225311228" Received: from gklab-003-001.igk.intel.com ([10.91.173.48]) by orviesa007.jf.intel.com with ESMTP; 26 Mar 2026 09:33:05 -0700 From: Grzegorz Nitka To: netdev@vger.kernel.org Cc: linux-kernel@vger.kernel.org, intel-wired-lan@lists.osuosl.org, poros@redhat.com, richardcochran@gmail.com, andrew+netdev@lunn.ch, przemyslaw.kitszel@intel.com, anthony.l.nguyen@intel.com, Prathosh.Satish@microchip.com, ivecera@redhat.com, jiri@resnulli.us, arkadiusz.kubalewski@intel.com, vadim.fedorenko@linux.dev, donald.hunter@gmail.com, horms@kernel.org, pabeni@redhat.com, kuba@kernel.org, davem@davemloft.net, edumazet@google.com, Grzegorz Nitka Subject: [PATCH v4 net-next 6/8] ice: implement CPI support for E825C Date: Thu, 26 Mar 2026 17:28:30 +0100 Message-Id: <20260326162832.3135857-7-grzegorz.nitka@intel.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20260326162832.3135857-1-grzegorz.nitka@intel.com> References: <20260326162832.3135857-1-grzegorz.nitka@intel.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add full CPI (Converged PHY Interface) command handling required for E825C devices. The CPI interface allows the driver to interact with PHY-side control logic through the LM/PHY command registers, including enabling/disabling/selection of PHY reference clock. This patch introduces: - a new CPI subsystem (ice_cpi.c / ice_cpi.h) implementing the CPI request/acknowledge state machine, including REQ/ACK protocol, command execution, and response handling - helper functions for reading/writing PHY registers over Sideband Queue - CPI command execution API (ice_cpi_exec) and a helper for enabling or disabling Tx reference clocks (CPI 0xF1 opcode 'Config PHY clocking') - addition of the non-posted write opcode (wr_np) to SBQ - Makefile integration to build CPI support together with the PTP stack This provides the infrastructure necessary to support PHY-side configuration flows on E825C and is required for advanced link control and Tx reference clock management. Reviewed-by: Arkadiusz Kubalewski Signed-off-by: Grzegorz Nitka --- drivers/net/ethernet/intel/ice/Makefile | 2 +- drivers/net/ethernet/intel/ice/ice_cpi.c | 347 +++++++++++++++++++ drivers/net/ethernet/intel/ice/ice_cpi.h | 69 ++++ drivers/net/ethernet/intel/ice/ice_sbq_cmd.h | 5 +- 4 files changed, 420 insertions(+), 3 deletions(-) create mode 100644 drivers/net/ethernet/intel/ice/ice_cpi.c create mode 100644 drivers/net/ethernet/intel/ice/ice_cpi.h diff --git a/drivers/net/ethernet/intel/ice/Makefile b/drivers/net/ethernet= /intel/ice/Makefile index 5b2c666496e7..38db476ab2ec 100644 --- a/drivers/net/ethernet/intel/ice/Makefile +++ b/drivers/net/ethernet/intel/ice/Makefile @@ -54,7 +54,7 @@ ice-$(CONFIG_PCI_IOV) +=3D \ ice_vf_mbx.o \ ice_vf_vsi_vlan_ops.o \ ice_vf_lib.o -ice-$(CONFIG_PTP_1588_CLOCK) +=3D ice_ptp.o ice_ptp_hw.o ice_dpll.o ice_ts= pll.o +ice-$(CONFIG_PTP_1588_CLOCK) +=3D ice_ptp.o ice_ptp_hw.o ice_dpll.o ice_ts= pll.o ice_cpi.o ice-$(CONFIG_DCB) +=3D ice_dcb.o ice_dcb_nl.o ice_dcb_lib.o ice-$(CONFIG_RFS_ACCEL) +=3D ice_arfs.o ice-$(CONFIG_XDP_SOCKETS) +=3D ice_xsk.o diff --git a/drivers/net/ethernet/intel/ice/ice_cpi.c b/drivers/net/etherne= t/intel/ice/ice_cpi.c new file mode 100644 index 000000000000..97fe2ebb99f3 --- /dev/null +++ b/drivers/net/ethernet/intel/ice/ice_cpi.c @@ -0,0 +1,347 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (C) 2018-2026 Intel Corporation */ + +#include "ice_type.h" +#include "ice_common.h" +#include "ice_ptp_hw.h" +#include "ice_cpi.h" + +/** + * ice_cpi_get_dest_dev - get destination PHY for given phy index + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * + * Return: sideband queue destination PHY device. + */ +static enum ice_sbq_dev_id ice_cpi_get_dest_dev(struct ice_hw *hw, u8 phy) +{ + u8 curr_phy =3D hw->lane_num / hw->ptp.ports_per_phy; + + /* In the driver, lanes 4..7 are in fact 0..3 on a second PHY. + * On a single complex E825C, PHY 0 is always destination device phy_0 + * and PHY 1 is phy_0_peer. + * On dual complex E825C, device phy_0 points to PHY on a current + * complex and phy_0_peer to PHY on a different complex. + */ + if ((!ice_is_dual(hw) && phy) || + (ice_is_dual(hw) && phy !=3D curr_phy)) + return ice_sbq_dev_phy_0_peer; + else + return ice_sbq_dev_phy_0; +} + +/** + * ice_cpi_write_phy - Write a CPI port register + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @addr: PHY register address + * @val: Value to write + * + * Return: + * * 0 on success + * * other error codes when failed to write to PHY + */ +static int ice_cpi_write_phy(struct ice_hw *hw, u8 phy, u32 addr, u32 val) +{ + struct ice_sbq_msg_input msg =3D { + .dest_dev =3D ice_cpi_get_dest_dev(hw, phy), + .opcode =3D ice_sbq_msg_wr_np, + .msg_addr_low =3D lower_16_bits(addr), + .msg_addr_high =3D upper_16_bits(addr), + .data =3D val + }; + int err; + + err =3D ice_sbq_rw_reg(hw, &msg, LIBIE_AQ_FLAG_RD); + if (err) + ice_debug(hw, ICE_DBG_PTP, + "Failed to write CPI msg to phy %d, err: %d\n", + phy, err); + + return err; +} + +/** + * ice_cpi_read_phy - Read a CPI port register + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @addr: PHY register address + * @val: storage for register value + * + * Return: + * * 0 on success + * * other error codes when failed to read from PHY + */ +static int ice_cpi_read_phy(struct ice_hw *hw, u8 phy, u32 addr, u32 *val) +{ + struct ice_sbq_msg_input msg =3D { + .dest_dev =3D ice_cpi_get_dest_dev(hw, phy), + .opcode =3D ice_sbq_msg_rd, + .msg_addr_low =3D lower_16_bits(addr), + .msg_addr_high =3D upper_16_bits(addr) + }; + int err; + + err =3D ice_sbq_rw_reg(hw, &msg, LIBIE_AQ_FLAG_RD); + if (err) { + ice_debug(hw, ICE_DBG_PTP, + "Failed to read CPI msg from phy %d, err: %d\n", + phy, err); + return err; + } + + *val =3D msg.data; + + return 0; +} + +/** + * ice_cpi_wait_req0_ack0 - waits for CPI interface to be available + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * + * This function checks if CPI interface is ready to use by CPI client. + * It's done by assuring LM.CMD.REQ and PHY.CMD.ACK bit in CPI + * interface registers to be 0. + * + * Return: 0 on success, negative on error + */ +static int ice_cpi_wait_req0_ack0(struct ice_hw *hw, int phy) +{ + union cpi_reg_phy_cmd_data phy_regs; + union cpi_reg_lm_cmd_data lm_regs; + + for (int i =3D 0; i < CPI_RETRIES_COUNT; i++) { + int err; + + /* check if another CPI Client is also accessing CPI */ + err =3D ice_cpi_read_phy(hw, phy, CPI0_LM1_CMD_DATA, + &lm_regs.val); + if (err) + return err; + if (lm_regs.field.cpi_req) + return -EBUSY; + + /* check if PHY.ACK is deasserted */ + err =3D ice_cpi_read_phy(hw, phy, CPI0_PHY1_CMD_DATA, + &phy_regs.val); + if (err) + return err; + if (phy_regs.field.error) + return -EFAULT; + if (!phy_regs.field.ack) + /* req0 and ack0 at this point - ready to go */ + return 0; + + msleep(CPI_RETRIES_CADENCE_MS); + } + + return -ETIMEDOUT; +} + +/** + * ice_cpi_wait_ack - Waits for the PHY.ACK bit to be asserted/deasserted + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @asserted: desired state of PHY.ACK bit + * @data: pointer to the user data where PHY.data is stored + * + * This function checks if PHY.ACK bit is asserted or deasserted, depending + * on the phase of CPI handshake. If 'asserted' state is required, PHY com= mand + * data is stored in the 'data' storage. + * + * Return: 0 on success, negative on error + */ +static int ice_cpi_wait_ack(struct ice_hw *hw, u8 phy, bool asserted, + u32 *data) +{ + union cpi_reg_phy_cmd_data phy_regs; + + for (int i =3D 0; i < CPI_RETRIES_COUNT; i++) { + int err; + + err =3D ice_cpi_read_phy(hw, phy, CPI0_PHY1_CMD_DATA, + &phy_regs.val); + if (err) + return err; + if (phy_regs.field.error) + return -EFAULT; + if (asserted && phy_regs.field.ack) { + if (data) + *data =3D phy_regs.val; + return 0; + } + if (!asserted && !phy_regs.field.ack) + return 0; + + msleep(CPI_RETRIES_CADENCE_MS); + } + + return -ETIMEDOUT; +} + +#define ice_cpi_wait_ack0(hw, port) \ + ice_cpi_wait_ack(hw, port, false, NULL) + +#define ice_cpi_wait_ack1(hw, port, data) \ + ice_cpi_wait_ack(hw, port, true, data) + +/** + * ice_cpi_req0 - deasserts LM.REQ bit + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @data: the command data + * + * Return: 0 on success, negative on CPI write error + */ +static int ice_cpi_req0(struct ice_hw *hw, u8 phy, u32 data) +{ + union cpi_reg_lm_cmd_data *lm_regs; + int err; + + lm_regs =3D (union cpi_reg_lm_cmd_data *)&data; + lm_regs->field.cpi_req =3D 0; + + err =3D ice_cpi_write_phy(hw, phy, CPI0_LM1_CMD_DATA, lm_regs->val); + + return err; +} + +/** + * ice_cpi_exec_cmd - writes command data to CPI interface + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @data: the command data + * + * Return: 0 on success, otherwise negative on error + */ +static int ice_cpi_exec_cmd(struct ice_hw *hw, int phy, u32 data) +{ + return ice_cpi_write_phy(hw, phy, CPI0_LM1_CMD_DATA, data); +} + +/** + * ice_cpi_exec - executes CPI command + * @hw: pointer to the HW struct + * @phy: phy index of port the CPI action is taken on + * @cmd: pointer to the command struct to execute + * @resp: pointer to user allocated CPI response struct + * + * This function executes CPI request with respect to CPI handshake + * mechanism. + * + * Return: 0 on success, otherwise negative on error + */ +int ice_cpi_exec(struct ice_hw *hw, u8 phy, + const struct ice_cpi_cmd *cmd, + struct ice_cpi_resp *resp) +{ + union cpi_reg_phy_cmd_data phy_cmd_data; + union cpi_reg_lm_cmd_data lm_cmd_data; + int err, err1 =3D 0; + + if (!cmd || !resp) + return -EINVAL; + + memset(&lm_cmd_data, 0, sizeof(lm_cmd_data)); + + lm_cmd_data.field.cpi_req =3D CPI_LM_CMD_REQ; + lm_cmd_data.field.get_set =3D cmd->set; + lm_cmd_data.field.opcode =3D cmd->opcode; + lm_cmd_data.field.portlane =3D cmd->port; + lm_cmd_data.field.data =3D cmd->data; + + /* 1. Try to acquire the bus, PHY ACK should be low before we begin */ + err =3D ice_cpi_wait_req0_ack0(hw, phy); + if (err) + goto cpi_exec_exit; + + /* 2. We start the CPI request */ + err =3D ice_cpi_exec_cmd(hw, phy, lm_cmd_data.val); + if (err) + goto cpi_exec_exit; + + /* + * 3. Wait for CPI confirmation, PHY ACK should be asserted and opcode + * echoed in the response + */ + err =3D ice_cpi_wait_ack1(hw, phy, &phy_cmd_data.val); + if (err) + goto cpi_deassert; + + if (phy_cmd_data.field.ack && + lm_cmd_data.field.opcode !=3D phy_cmd_data.field.opcode) { + err =3D -EFAULT; + goto cpi_deassert; + } + + resp->opcode =3D phy_cmd_data.field.opcode; + resp->data =3D phy_cmd_data.field.data; + resp->port =3D phy_cmd_data.field.portlane; + +cpi_deassert: + /* 4. We deassert REQ */ + err1 =3D ice_cpi_req0(hw, phy, lm_cmd_data.val); + if (err1) + goto cpi_exec_exit; + + /* 5. PHY ACK should be deasserted in response */ + err1 =3D ice_cpi_wait_ack0(hw, phy); + +cpi_exec_exit: + if (!err) + err =3D err1; + + return err; +} + +/** + * ice_cpi_set_cmd - execute CPI SET command + * @hw: pointer to the HW struct + * @opcode: CPI command opcode + * @phy: phy index CPI command is applied for + * @port_lane: ephy index CPI command is applied for + * @data: CPI opcode context specific data + * + * Return: 0 on success. + */ +static int ice_cpi_set_cmd(struct ice_hw *hw, u16 opcode, u8 phy, u8 port_= lane, + u16 data) +{ + struct ice_cpi_resp cpi_resp =3D {0}; + struct ice_cpi_cmd cpi_cmd =3D { + .opcode =3D opcode, + .set =3D true, + .port =3D port_lane, + .data =3D data, + }; + + return ice_cpi_exec(hw, phy, &cpi_cmd, &cpi_resp); +} + +/** + * ice_cpi_ena_dis_clk_ref - enables/disables Tx reference clock on port + * @hw: pointer to the HW struct + * @phy: phy index of port for which Tx reference clock is enabled/disabled + * @clk: Tx reference clock to enable or disable + * @enable: bool value to enable or disable Tx reference clock + * + * This function executes CPI request to enable or disable specific + * Tx reference clock on given PHY. + * + * Return: 0 on success. + */ +int ice_cpi_ena_dis_clk_ref(struct ice_hw *hw, u8 phy, + enum ice_e825c_ref_clk clk, bool enable) +{ + u16 val; + + val =3D FIELD_PREP(CPI_OPCODE_PHY_CLK_PHY_SEL_M, phy) | + FIELD_PREP(CPI_OPCODE_PHY_CLK_REF_CTRL_M, + enable ? CPI_OPCODE_PHY_CLK_ENABLE : + CPI_OPCODE_PHY_CLK_DISABLE) | + FIELD_PREP(CPI_OPCODE_PHY_CLK_REF_SEL_M, clk); + + return ice_cpi_set_cmd(hw, CPI_OPCODE_PHY_CLK, phy, 0, val); +} + diff --git a/drivers/net/ethernet/intel/ice/ice_cpi.h b/drivers/net/etherne= t/intel/ice/ice_cpi.h new file mode 100644 index 000000000000..767107fc18e5 --- /dev/null +++ b/drivers/net/ethernet/intel/ice/ice_cpi.h @@ -0,0 +1,69 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Copyright (C) 2018-2025 Intel Corporation */ + +#ifndef _ICE_CPI_H_ +#define _ICE_CPI_H_ + +#define CPI0_PHY1_CMD_DATA 0x7FD028 +#define CPI0_LM1_CMD_DATA 0x7FD024 +#define CPI_RETRIES_COUNT 10 +#define CPI_RETRIES_CADENCE_MS 100 + +#define CPI_OPCODE_PHY_CLK 0xF1 +#define CPI_OPCODE_PHY_CLK_PHY_SEL_M GENMASK(9, 6) +#define CPI_OPCODE_PHY_CLK_REF_CTRL_M GENMASK(5, 4) +#define CPI_OPCODE_PHY_CLK_PORT_SEL 0 +#define CPI_OPCODE_PHY_CLK_DISABLE 1 +#define CPI_OPCODE_PHY_CLK_ENABLE 2 +#define CPI_OPCODE_PHY_CLK_REF_SEL_M GENMASK(3, 0) + +#define CPI_OPCODE_PHY_PCS_RESET 0xF0 +#define CPI_OPCODE_PHY_PCS_ONPI_RESET_VAL 0x3F + +#define CPI_LM_CMD_REQ 1 +#define CPI_LM_CMD_SET 1 + +union cpi_reg_phy_cmd_data { + struct { + u16 data; + u16 opcode : 8; + u16 portlane : 3; + u16 reserved_13_11: 3; + u16 error : 1; + u16 ack : 1; + } __packed field; + u32 val; +}; + +union cpi_reg_lm_cmd_data { + struct { + u16 data; + u16 opcode : 8; + u16 portlane : 3; + u16 reserved_12_11: 2; + u16 get_set : 1; + u16 cpi_reset : 1; + u16 cpi_req : 1; + } __packed field; + u32 val; +}; + +struct ice_cpi_cmd { + u8 port; + u8 opcode; + u16 data; + bool set; +}; + +struct ice_cpi_resp { + u8 port; + u8 opcode; + u16 data; +}; + +int ice_cpi_exec(struct ice_hw *hw, u8 phy, + const struct ice_cpi_cmd *cmd, + struct ice_cpi_resp *resp); +int ice_cpi_ena_dis_clk_ref(struct ice_hw *hw, u8 port, + enum ice_e825c_ref_clk clk, bool enable); +#endif /* _ICE_CPI_H_ */ diff --git a/drivers/net/ethernet/intel/ice/ice_sbq_cmd.h b/drivers/net/eth= ernet/intel/ice/ice_sbq_cmd.h index 21bb861febbf..226243d32968 100644 --- a/drivers/net/ethernet/intel/ice/ice_sbq_cmd.h +++ b/drivers/net/ethernet/intel/ice/ice_sbq_cmd.h @@ -54,8 +54,9 @@ enum ice_sbq_dev_id { }; =20 enum ice_sbq_msg_opcode { - ice_sbq_msg_rd =3D 0x00, - ice_sbq_msg_wr =3D 0x01 + ice_sbq_msg_rd =3D 0x00, + ice_sbq_msg_wr =3D 0x01, + ice_sbq_msg_wr_np =3D 0x02 }; =20 #define ICE_SBQ_MSG_FLAGS 0x40 --=20 2.39.3