From nobody Wed Dec 17 16:09:30 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (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 7F7791C5CBD; Mon, 9 Dec 2024 15:18:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757524; cv=none; b=iuzIvwQ0SmISX6Gr865KBJIqUK+zAvvdhnUVRvYD3l0Q0I98270wBYHejXWitklLMJJdUfoBYrxpPhXnVCMZ1v700q6kxI+lOTz/J+HREztAStxwaV7/yfBKYd/5840TeSkALgk+F5rKgyUHkcTI9YMSdq0BWBk5tIRUoZ6us9k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757524; c=relaxed/simple; bh=5F2nw2jMwc4D6o7lX7JFabG4RgAbTUZVW7moThkshGQ=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=fHMFVbaeeSJZNRUENALUjVA5X2xhMnjWitePYEaPR5qVijgn3nhz2wsbSAoyjV6ibQOJOrXaM9taD92JnbY3E125uMYMUCic5JcLQA9h4kRVoD8qmDSQgrh/mcGiKYKxEEEt1akVYXN/P7glh0HAlGrp1qnT49SPTmpvPDOjUcM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=URx0NsF0; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="URx0NsF0" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1733757522; x=1765293522; h=from:to:subject:date:message-id:in-reply-to:references: mime-version; bh=5F2nw2jMwc4D6o7lX7JFabG4RgAbTUZVW7moThkshGQ=; b=URx0NsF0yI2mvDkpOu8eY00O5QsHjUFehI1DaTmqCsuzYD56Zj9CaIrG rXodqW6vxIV3o3lRXzlRue0EF/1p0HGU7VqAF7Ptpd48qGjcY6swdus3l ckzDkuWy1gwQm2hEnUbWXAXGBol85GDmPomA5nVN1TI6hi/XUs4o8YKIg q9BWYkzQtDYYYaG8wpB4G1TA1eEgp4O7rTy70Mcrnx3EZb3w8cr1fU4t5 4Z9o6LZb0mckSgy9yqLK72QR1KZHwpUjA8/X5TiiAdMd3x8Teh/6J/3wU hzfWuAUMWGbGx4XiClhX3oKRWiDi0XRXv9O5QER+E5VXiJ1fRwdsqf6Im A==; X-CSE-ConnectionGUID: css/sw7iS6y778PqU3NZ3A== X-CSE-MsgGUID: OsHCldszQOi/lBO/T40s6A== X-IronPort-AV: E=Sophos;i="6.12,219,1728975600"; d="scan'208";a="34995265" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa4.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 09 Dec 2024 08:18:41 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex04.mchp-main.com (10.10.85.152) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.35; Mon, 9 Dec 2024 08:17:39 -0700 Received: from training-HP-280-G1-MT-PC.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.35 via Frontend Transport; Mon, 9 Dec 2024 08:17:35 -0700 From: Divya Koppera To: , , , , , , , , , , , , Subject: [PATCH net-next v6 1/5] net: phy: microchip_rds_ptp: Add header file for Microchip rds ptp library Date: Mon, 9 Dec 2024 20:47:38 +0530 Message-ID: <20241209151742.9128-2-divya.koppera@microchip.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20241209151742.9128-1-divya.koppera@microchip.com> References: <20241209151742.9128-1-divya.koppera@microchip.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" This rds ptp header file will cover ptp macros for future phys in Microchip where addresses will be same but base offset and mmd address may changes. Reviewed-by: Vadim Fedorenko Signed-off-by: Divya Koppera --- v5 -> v6 - Renamed header file name, macros and function names to reflect ptp hardware code name. v4 -> v5 - Reduced scope of config PTP Macro check to APIs v3 -> v4 - Re-ordered mchp_ptp_clock structure. v2 -> v3 - No changes v1 -> v2 - Fixed sparse warnings and compilation errors/warnings reported by kernel test robot --- drivers/net/phy/microchip_rds_ptp.h | 218 ++++++++++++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 drivers/net/phy/microchip_rds_ptp.h diff --git a/drivers/net/phy/microchip_rds_ptp.h b/drivers/net/phy/microchi= p_rds_ptp.h new file mode 100644 index 000000000000..15e36d6bc975 --- /dev/null +++ b/drivers/net/phy/microchip_rds_ptp.h @@ -0,0 +1,218 @@ +/* SPDX-License-Identifier: GPL-2.0 + * Copyright (C) 2024 Microchip Technology + */ + +#ifndef _MICROCHIP_RDS_PTP_H +#define _MICROCHIP_RDS_PTP_H + +#include +#include +#include +#include +#include +#include + +#define MCHP_RDS_PTP_CMD_CTL(b) ((b) + 0x0) +#define MCHP_RDS_PTP_CMD_CTL_LTC_STEP_NSEC BIT(6) +#define MCHP_RDS_PTP_CMD_CTL_LTC_STEP_SEC BIT(5) +#define MCHP_RDS_PTP_CMD_CTL_CLOCK_LOAD BIT(4) +#define MCHP_RDS_PTP_CMD_CTL_CLOCK_READ BIT(3) +#define MCHP_RDS_PTP_CMD_CTL_EN BIT(1) +#define MCHP_RDS_PTP_CMD_CTL_DIS BIT(0) + +#define MCHP_RDS_PTP_REF_CLK_CFG(b) ((b) + 0x2) +#define MCHP_RDS_PTP_REF_CLK_SRC_250MHZ 0x0 +#define MCHP_RDS_PTP_REF_CLK_PERIOD_OVERRIDE BIT(9) +#define MCHP_RDS_PTP_REF_CLK_PERIOD 4 +#define MCHP_RDS_PTP_REF_CLK_CFG_SET (MCHP_RDS_PTP_REF_CLK_SRC_250MHZ |\ + MCHP_RDS_PTP_REF_CLK_PERIOD_OVERRIDE |\ + MCHP_RDS_PTP_REF_CLK_PERIOD) + +#define MCHP_RDS_PTP_LTC_SEC_HI(b) ((b) + 0x5) +#define MCHP_RDS_PTP_LTC_SEC_MID(b) ((b) + 0x6) +#define MCHP_RDS_PTP_LTC_SEC_LO(b) ((b) + 0x7) +#define MCHP_RDS_PTP_LTC_NS_HI(b) ((b) + 0x8) +#define MCHP_RDS_PTP_LTC_NS_LO(b) ((b) + 0x9) +#define MCHP_RDS_PTP_LTC_RATE_ADJ_HI(b) ((b) + 0xc) +#define MCHP_RDS_PTP_LTC_RATE_ADJ_HI_DIR BIT(15) +#define MCHP_RDS_PTP_LTC_RATE_ADJ_LO(b) ((b) + 0xd) +#define MCHP_RDS_PTP_STEP_ADJ_HI(b) ((b) + 0x12) +#define MCHP_RDS_PTP_STEP_ADJ_HI_DIR BIT(15) +#define MCHP_RDS_PTP_STEP_ADJ_LO(b) ((b) + 0x13) +#define MCHP_RDS_PTP_LTC_READ_SEC_HI(b) ((b) + 0x29) +#define MCHP_RDS_PTP_LTC_READ_SEC_MID(b) ((b) + 0x2a) +#define MCHP_RDS_PTP_LTC_READ_SEC_LO(b) ((b) + 0x2b) +#define MCHP_RDS_PTP_LTC_READ_NS_HI(b) ((b) + 0x2c) +#define MCHP_RDS_PTP_LTC_READ_NS_LO(b) ((b) + 0x2d) +#define MCHP_RDS_PTP_OP_MODE(b) ((b) + 0x41) +#define MCHP_RDS_PTP_OP_MODE_DIS 0 +#define MCHP_RDS_PTP_OP_MODE_STANDALONE 1 +#define MCHP_RDS_PTP_LATENCY_CORRECTION_CTL(b) ((b) + 0x44) +#define MCHP_RDS_PTP_PREDICTOR_EN BIT(6) +#define MCHP_RDS_PTP_TX_PRED_DIS BIT(1) +#define MCHP_RDS_PTP_RX_PRED_DIS BIT(0) +#define MCHP_RDS_PTP_LATENCY_SETTING (MCHP_RDS_PTP_PREDICTOR_EN | \ + MCHP_RDS_PTP_TX_PRED_DIS | \ + MCHP_RDS_PTP_RX_PRED_DIS) + +#define MCHP_RDS_PTP_INT_EN(b) ((b) + 0x0) +#define MCHP_RDS_PTP_INT_STS(b) ((b) + 0x01) +#define MCHP_RDS_PTP_INT_TX_TS_OVRFL_EN BIT(3) +#define MCHP_RDS_PTP_INT_TX_TS_EN BIT(2) +#define MCHP_RDS_PTP_INT_RX_TS_OVRFL_EN BIT(1) +#define MCHP_RDS_PTP_INT_RX_TS_EN BIT(0) +#define MCHP_RDS_PTP_INT_ALL_MSK (MCHP_RDS_PTP_INT_TX_TS_OVRFL_EN | \ + MCHP_RDS_PTP_INT_TX_TS_EN | \ + MCHP_RDS_PTP_INT_RX_TS_OVRFL_EN |\ + MCHP_RDS_PTP_INT_RX_TS_EN) + +#define MCHP_RDS_PTP_CAP_INFO(b) ((b) + 0x2e) +#define MCHP_RDS_PTP_TX_TS_CNT(v) (((v) & GENMASK(11, 8)) >> 8) +#define MCHP_RDS_PTP_RX_TS_CNT(v) ((v) & GENMASK(3, 0)) + +#define MCHP_RDS_PTP_RX_PARSE_CONFIG(b) ((b) + 0x42) +#define MCHP_RDS_PTP_RX_PARSE_L2_ADDR_EN(b) ((b) + 0x44) +#define MCHP_RDS_PTP_RX_PARSE_IPV4_ADDR_EN(b) ((b) + 0x45) + +#define MCHP_RDS_PTP_RX_TIMESTAMP_CONFIG(b) ((b) + 0x4e) +#define MCHP_RDS_PTP_RX_TIMESTAMP_CONFIG_PTP_FCS_DIS BIT(0) + +#define MCHP_RDS_PTP_RX_VERSION(b) ((b) + 0x48) +#define MCHP_RDS_PTP_RX_TIMESTAMP_EN(b) ((b) + 0x4d) + +#define MCHP_RDS_PTP_RX_INGRESS_NS_HI(b) ((b) + 0x54) +#define MCHP_RDS_PTP_RX_INGRESS_NS_HI_TS_VALID BIT(15) + +#define MCHP_RDS_PTP_RX_INGRESS_NS_LO(b) ((b) + 0x55) +#define MCHP_RDS_PTP_RX_INGRESS_SEC_HI(b) ((b) + 0x56) +#define MCHP_RDS_PTP_RX_INGRESS_SEC_LO(b) ((b) + 0x57) +#define MCHP_RDS_PTP_RX_MSG_HDR2(b) ((b) + 0x59) + +#define MCHP_RDS_PTP_TX_PARSE_CONFIG(b) ((b) + 0x82) +#define MCHP_RDS_PTP_PARSE_CONFIG_LAYER2_EN BIT(0) +#define MCHP_RDS_PTP_PARSE_CONFIG_IPV4_EN BIT(1) +#define MCHP_RDS_PTP_PARSE_CONFIG_IPV6_EN BIT(2) + +#define MCHP_RDS_PTP_TX_PARSE_L2_ADDR_EN(b) ((b) + 0x84) +#define MCHP_RDS_PTP_TX_PARSE_IPV4_ADDR_EN(b) ((b) + 0x85) + +#define MCHP_RDS_PTP_TX_VERSION(b) ((b) + 0x88) +#define MCHP_RDS_PTP_MAX_VERSION(x) (((x) & GENMASK(7, 0)) << 8) +#define MCHP_RDS_PTP_MIN_VERSION(x) ((x) & GENMASK(7, 0)) + +#define MCHP_RDS_PTP_TX_TIMESTAMP_EN(b) ((b) + 0x8d) +#define MCHP_RDS_PTP_TIMESTAMP_EN_SYNC BIT(0) +#define MCHP_RDS_PTP_TIMESTAMP_EN_DREQ BIT(1) +#define MCHP_RDS_PTP_TIMESTAMP_EN_PDREQ BIT(2) +#define MCHP_RDS_PTP_TIMESTAMP_EN_PDRES BIT(3) +#define MCHP_RDS_PTP_TIMESTAMP_EN_ALL (MCHP_RDS_PTP_TIMESTAMP_EN_SYNC |\ + MCHP_RDS_PTP_TIMESTAMP_EN_DREQ |\ + MCHP_RDS_PTP_TIMESTAMP_EN_PDREQ |\ + MCHP_RDS_PTP_TIMESTAMP_EN_PDRES) + +#define MCHP_RDS_PTP_TX_TIMESTAMP_CONFIG(b) ((b) + 0x8e) +#define MCHP_RDS_PTP_TX_TIMESTAMP_CONFIG_PTP_FCS_DIS BIT(0) + +#define MCHP_RDS_PTP_TX_MOD(b) ((b) + 0x8f) +#define MCHP_RDS_PTP_TX_MOD_PTP_SYNC_TS_INSERT BIT(12) +#define MCHP_RDS_PTP_TX_MOD_PTP_FU_TS_INSERT BIT(11) + +#define MCHP_RDS_PTP_TX_EGRESS_NS_HI(b) ((b) + 0x94) +#define MCHP_RDS_PTP_TX_EGRESS_NS_HI_TS_VALID BIT(15) + +#define MCHP_RDS_PTP_TX_EGRESS_NS_LO(b) ((b) + 0x95) +#define MCHP_RDS_PTP_TX_EGRESS_SEC_HI(b) ((b) + 0x96) +#define MCHP_RDS_PTP_TX_EGRESS_SEC_LO(b) ((b) + 0x97) +#define MCHP_RDS_PTP_TX_MSG_HDR2(b) ((b) + 0x99) + +#define MCHP_RDS_PTP_TSU_GEN_CONFIG(b) ((b) + 0xc0) +#define MCHP_RDS_PTP_TSU_GEN_CFG_TSU_EN BIT(0) + +#define MCHP_RDS_PTP_TSU_HARD_RESET(b) ((b) + 0xc1) +#define MCHP_RDS_PTP_TSU_HARDRESET BIT(0) + +/* Represents 1ppm adjustment in 2^32 format with + * each nsec contains 4 clock cycles in 250MHz. + * The value is calculated as following: (1/1000000)/((2^-32)/4) + */ +#define MCHP_RDS_PTP_1PPM_FORMAT 17179 +#define MCHP_RDS_PTP_FIFO_SIZE 8 +#define MCHP_RDS_PTP_MAX_ADJ 31249999 + +#define BASE_CLK(p) ((p)->clk_base_addr) +#define BASE_PORT(p) ((p)->port_base_addr) +#define PTP_MMD(p) ((p)->mmd) + +enum mchp_rds_ptp_fifo_dir { + MCHP_RDS_PTP_INGRESS_FIFO, + MCHP_RDS_PTP_EGRESS_FIFO +}; + +struct mchp_rds_ptp_clock { + struct mii_timestamper mii_ts; + struct phy_device *phydev; + struct ptp_clock *ptp_clock; + + struct sk_buff_head tx_queue; + struct sk_buff_head rx_queue; + struct list_head rx_ts_list; + + struct ptp_clock_info caps; + + /* Lock for Rx ts fifo */ + spinlock_t rx_ts_lock; + int hwts_tx_type; + + enum hwtstamp_rx_filters rx_filter; + int layer; + int version; + u16 port_base_addr; + u16 clk_base_addr; + + /* Lock for phc */ + struct mutex ptp_lock; + u8 mmd; +}; + +struct mchp_rds_ptp_rx_ts { + struct list_head list; + u32 seconds; + u32 nsec; + u16 seq_id; +}; + +#if IS_ENABLED(CONFIG_MICROCHIP_PHY_RDS_PTP) + +struct mchp_rds_ptp_clock *mchp_rds_ptp_probe(struct phy_device *phydev, u= 8 mmd, + u16 clk_base, u16 port_base); + +int mchp_rds_ptp_top_config_intr(struct mchp_rds_ptp_clock *clock, + u16 reg, u16 val, bool enable); + +irqreturn_t mchp_rds_ptp_handle_interrupt(struct mchp_rds_ptp_clock *clock= ); + +#else + +static inline struct mchp_rds_ptp_clock *mchp_rds_ptp_probe(struct phy_dev= ice + *phydev, u8 mmd, + u16 clk_base, + u16 port_base) +{ + return NULL; +} + +static inline int mchp_rds_ptp_top_config_intr(struct mchp_rds_ptp_clock *= clock, + u16 reg, u16 val, bool enable) +{ + return 0; +} + +static inline irqreturn_t mchp_rds_ptp_handle_interrupt(struct + mchp_rds_ptp_clock * clock) +{ + return IRQ_NONE; +} + +#endif //CONFIG_MICROCHIP_PHY_RDS_PTP + +#endif //_MICROCHIP_RDS_PTP_H --=20 2.17.1 From nobody Wed Dec 17 16:09:30 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (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 AF75B1C5CBD; Mon, 9 Dec 2024 15:18:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757504; cv=none; b=hDdcVy7biYkSUDb1AUGAPDY/XnR10C/KWSdjlEUlIvyNg2tKdi6uEDu43XczZRtGBR1sUjPk8ss3JOgmjzGAMrFPB2wlDSOgDz8WtHn8lpxM1Rn5JeJZ00dt4UV+0vSnuG0iPu1Z1r4NyM3PPRmesukVhEJAJg4Sq8f9WpgVgpA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757504; c=relaxed/simple; bh=3Qskowc5ETaCvhorfTUB8DuLeKvlcyhYS79nxUY7yfg=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=HrA6n/YGeOWsaRTIPYYh76Kyp2k+nYSDGRvf6nRkLu5aE9OQBWW/tRY0eQvMMTZq5RQgMZZ73zgl1eS3SrbPzjwdL8fNvUgYVRWCB48lg1pfVosp1JBC2wybyAw0gwnRc3rp5lvGfIQEUPTfeZgoJ9KvPbiXeUUjHOpIfNygjuo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=Cn7xLGtO; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="Cn7xLGtO" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1733757501; x=1765293501; h=from:to:subject:date:message-id:in-reply-to:references: mime-version; bh=3Qskowc5ETaCvhorfTUB8DuLeKvlcyhYS79nxUY7yfg=; b=Cn7xLGtOOVg77A1TLYQnb8MfEQBjxC6LE3JYaniNQ0UUvSFaU4QyMDRd /vv2BpKsD8yC7Vo3BrU7F2fw2oz/xocs/WPRj8P4DO76K+VwdLcJLh/yF A6ytEpaWyt/Se36rhGPbSkfVvNJFCG3Iv51uAH3HMpNE2HYrvD1OWnrmg XFLGzXimPl3e9kkds7zUwNtY+rmnPmiuZGovKpNstpb1LF5fKd0hpIUJA fGqig/hyPGspWfu4ZDJlGGraHwqYfwBnkKSVKv9klghKYWEOMtkdWiQ2K j/2fi3zeXzxB+uCtZh7r7J5In6dbQtRHB/WxVbZG/i2PJa6U5T0qst97R w==; X-CSE-ConnectionGUID: fVcj29IcQ9C5yarZFzKSjw== X-CSE-MsgGUID: eZfF3k1GT/6Mc/cJCYGFKA== X-IronPort-AV: E=Sophos;i="6.12,219,1728975600"; d="scan'208";a="35775872" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 09 Dec 2024 08:18:15 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex04.mchp-main.com (10.10.85.152) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.35; Mon, 9 Dec 2024 08:17:44 -0700 Received: from training-HP-280-G1-MT-PC.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.35 via Frontend Transport; Mon, 9 Dec 2024 08:17:40 -0700 From: Divya Koppera To: , , , , , , , , , , , , Subject: [PATCH net-next v6 2/5] net: phy: microchip_rds_ptp : Add rds ptp library for Microchip phys Date: Mon, 9 Dec 2024 20:47:39 +0530 Message-ID: <20241209151742.9128-3-divya.koppera@microchip.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20241209151742.9128-1-divya.koppera@microchip.com> References: <20241209151742.9128-1-divya.koppera@microchip.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 rds ptp library for Microchip phys 1-step and 2-step modes are supported, over Ethernet and UDP(ipv4, ipv6) Reviewed-by: Vadim Fedorenko Signed-off-by: Divya Koppera --- v5 -> v6 - Renamed file name, macros, function names. - Moved initialization of ptp_lock to avoid race condition. v4 -> v5 - No changes v3 -> v4 - Fixed coccicheck errors v2 -> v3 - Moved to kmalloc from kzalloc - Fixed sparse errors related to cast from restricted __be16 v1 -> v2 - Removed redundant memsets - Moved to standard comparision than memcmp for u16 - Fixed sparse/smatch warnings reported by kernel test robot - Added spinlock to shared code - Moved redundant part of code out of spinlock protected area --- drivers/net/phy/microchip_rds_ptp.c | 1009 +++++++++++++++++++++++++++ 1 file changed, 1009 insertions(+) create mode 100644 drivers/net/phy/microchip_rds_ptp.c diff --git a/drivers/net/phy/microchip_rds_ptp.c b/drivers/net/phy/microchi= p_rds_ptp.c new file mode 100644 index 000000000000..d1c91c0f5e03 --- /dev/null +++ b/drivers/net/phy/microchip_rds_ptp.c @@ -0,0 +1,1009 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2024 Microchip Technology + +#include "microchip_rds_ptp.h" + +static int mchp_rds_ptp_flush_fifo(struct mchp_rds_ptp_clock *clock, + enum mchp_rds_ptp_fifo_dir dir) +{ + struct phy_device *phydev =3D clock->phydev; + int rc; + + for (int i =3D 0; i < MCHP_RDS_PTP_FIFO_SIZE; ++i) { + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + dir =3D=3D MCHP_RDS_PTP_EGRESS_FIFO ? + MCHP_RDS_PTP_TX_MSG_HDR2(BASE_PORT(clock)) : + MCHP_RDS_PTP_RX_MSG_HDR2(BASE_PORT(clock))); + if (rc < 0) + return rc; + } + return phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_INT_STS(BASE_PORT(clock))); +} + +static int mchp_rds_ptp_config_intr(struct mchp_rds_ptp_clock *clock, + bool enable) +{ + struct phy_device *phydev =3D clock->phydev; + + /* Enable or disable ptp interrupts */ + return phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_INT_EN(BASE_PORT(clock)), + enable ? MCHP_RDS_PTP_INT_ALL_MSK : 0); +} + +static void mchp_rds_ptp_txtstamp(struct mii_timestamper *mii_ts, + struct sk_buff *skb, int type) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(mii_ts, + struct mchp_rds_ptp_clock, + mii_ts); + + switch (clock->hwts_tx_type) { + case HWTSTAMP_TX_ONESTEP_SYNC: + if (ptp_msg_is_sync(skb, type)) { + kfree_skb(skb); + return; + } + fallthrough; + case HWTSTAMP_TX_ON: + skb_shinfo(skb)->tx_flags |=3D SKBTX_IN_PROGRESS; + skb_queue_tail(&clock->tx_queue, skb); + break; + case HWTSTAMP_TX_OFF: + default: + kfree_skb(skb); + break; + } +} + +static bool mchp_rds_ptp_get_sig_rx(struct sk_buff *skb, u16 *sig) +{ + struct ptp_header *ptp_header; + int type; + + skb_push(skb, ETH_HLEN); + type =3D ptp_classify_raw(skb); + if (type =3D=3D PTP_CLASS_NONE) + return false; + + ptp_header =3D ptp_parse_header(skb, type); + if (!ptp_header) + return false; + + skb_pull_inline(skb, ETH_HLEN); + + *sig =3D (__force u16)(ntohs(ptp_header->sequence_id)); + + return true; +} + +static bool mchp_rds_ptp_match_skb(struct mchp_rds_ptp_clock *clock, + struct mchp_rds_ptp_rx_ts *rx_ts) +{ + struct skb_shared_hwtstamps *shhwtstamps; + struct sk_buff *skb, *skb_tmp; + unsigned long flags; + bool rc =3D false; + u16 skb_sig; + + spin_lock_irqsave(&clock->rx_queue.lock, flags); + skb_queue_walk_safe(&clock->rx_queue, skb, skb_tmp) { + if (!mchp_rds_ptp_get_sig_rx(skb, &skb_sig)) + continue; + + if (skb_sig !=3D rx_ts->seq_id) + continue; + + __skb_unlink(skb, &clock->rx_queue); + + rc =3D true; + break; + } + spin_unlock_irqrestore(&clock->rx_queue.lock, flags); + + if (rc) { + shhwtstamps =3D skb_hwtstamps(skb); + shhwtstamps->hwtstamp =3D ktime_set(rx_ts->seconds, rx_ts->nsec); + netif_rx(skb); + } + + return rc; +} + +static void mchp_rds_ptp_match_rx_ts(struct mchp_rds_ptp_clock *clock, + struct mchp_rds_ptp_rx_ts *rx_ts) +{ + unsigned long flags; + + /* If we failed to match the skb add it to the queue for when + * the frame will come + */ + if (!mchp_rds_ptp_match_skb(clock, rx_ts)) { + spin_lock_irqsave(&clock->rx_ts_lock, flags); + list_add(&rx_ts->list, &clock->rx_ts_list); + spin_unlock_irqrestore(&clock->rx_ts_lock, flags); + } else { + kfree(rx_ts); + } +} + +static void mchp_rds_ptp_match_rx_skb(struct mchp_rds_ptp_clock *clock, + struct sk_buff *skb) +{ + struct mchp_rds_ptp_rx_ts *rx_ts, *tmp, *rx_ts_var =3D NULL; + struct skb_shared_hwtstamps *shhwtstamps; + unsigned long flags; + u16 skb_sig; + + if (!mchp_rds_ptp_get_sig_rx(skb, &skb_sig)) + return; + + /* Iterate over all RX timestamps and match it with the received skbs */ + spin_lock_irqsave(&clock->rx_ts_lock, flags); + list_for_each_entry_safe(rx_ts, tmp, &clock->rx_ts_list, list) { + /* Check if we found the signature we were looking for. */ + if (skb_sig !=3D rx_ts->seq_id) + continue; + + shhwtstamps =3D skb_hwtstamps(skb); + shhwtstamps->hwtstamp =3D ktime_set(rx_ts->seconds, rx_ts->nsec); + netif_rx(skb); + + rx_ts_var =3D rx_ts; + + break; + } + spin_unlock_irqrestore(&clock->rx_ts_lock, flags); + + if (rx_ts_var) { + list_del(&rx_ts_var->list); + kfree(rx_ts_var); + } else { + skb_queue_tail(&clock->rx_queue, skb); + } +} + +static bool mchp_rds_ptp_rxtstamp(struct mii_timestamper *mii_ts, + struct sk_buff *skb, int type) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(mii_ts, + struct mchp_rds_ptp_clock, + mii_ts); + + if (clock->rx_filter =3D=3D HWTSTAMP_FILTER_NONE || + type =3D=3D PTP_CLASS_NONE) + return false; + + if ((type & clock->version) =3D=3D 0 || (type & clock->layer) =3D=3D 0) + return false; + + /* Here if match occurs skb is sent to application, If not skb is added + * to queue and sending skb to application will get handled when + * interrupt occurs i.e., it get handles in interrupt handler. By + * any means skb will reach the application so we should not return + * false here if skb doesn't matches. + */ + mchp_rds_ptp_match_rx_skb(clock, skb); + + return true; +} + +static int mchp_rds_ptp_hwtstamp(struct mii_timestamper *mii_ts, + struct kernel_hwtstamp_config *config, + struct netlink_ext_ack *extack) +{ + struct mchp_rds_ptp_clock *clock =3D + container_of(mii_ts, struct mchp_rds_ptp_clock, + mii_ts); + struct phy_device *phydev =3D clock->phydev; + struct mchp_rds_ptp_rx_ts *rx_ts, *tmp; + int txcfg =3D 0, rxcfg =3D 0; + unsigned long flags; + int rc; + + clock->hwts_tx_type =3D config->tx_type; + clock->rx_filter =3D config->rx_filter; + + switch (config->rx_filter) { + case HWTSTAMP_FILTER_NONE: + clock->layer =3D 0; + clock->version =3D 0; + break; + case HWTSTAMP_FILTER_PTP_V2_L4_EVENT: + case HWTSTAMP_FILTER_PTP_V2_L4_SYNC: + case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ: + clock->layer =3D PTP_CLASS_L4; + clock->version =3D PTP_CLASS_V2; + break; + case HWTSTAMP_FILTER_PTP_V2_L2_EVENT: + case HWTSTAMP_FILTER_PTP_V2_L2_SYNC: + case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ: + clock->layer =3D PTP_CLASS_L2; + clock->version =3D PTP_CLASS_V2; + break; + case HWTSTAMP_FILTER_PTP_V2_EVENT: + case HWTSTAMP_FILTER_PTP_V2_SYNC: + case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ: + clock->layer =3D PTP_CLASS_L4 | PTP_CLASS_L2; + clock->version =3D PTP_CLASS_V2; + break; + default: + return -ERANGE; + } + + /* Setup parsing of the frames and enable the timestamping for ptp + * frames + */ + if (clock->layer & PTP_CLASS_L2) { + rxcfg =3D MCHP_RDS_PTP_PARSE_CONFIG_LAYER2_EN; + txcfg =3D MCHP_RDS_PTP_PARSE_CONFIG_LAYER2_EN; + } + if (clock->layer & PTP_CLASS_L4) { + rxcfg |=3D MCHP_RDS_PTP_PARSE_CONFIG_IPV4_EN | + MCHP_RDS_PTP_PARSE_CONFIG_IPV6_EN; + txcfg |=3D MCHP_RDS_PTP_PARSE_CONFIG_IPV4_EN | + MCHP_RDS_PTP_PARSE_CONFIG_IPV6_EN; + } + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_PARSE_CONFIG(BASE_PORT(clock)), + rxcfg); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_PARSE_CONFIG(BASE_PORT(clock)), + txcfg); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_TIMESTAMP_EN(BASE_PORT(clock)), + MCHP_RDS_PTP_TIMESTAMP_EN_ALL); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_TIMESTAMP_EN(BASE_PORT(clock)), + MCHP_RDS_PTP_TIMESTAMP_EN_ALL); + if (rc < 0) + return rc; + + if (clock->hwts_tx_type =3D=3D HWTSTAMP_TX_ONESTEP_SYNC) + /* Enable / disable of the TX timestamp in the SYNC frames */ + rc =3D phy_modify_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_MOD(BASE_PORT(clock)), + MCHP_RDS_PTP_TX_MOD_PTP_SYNC_TS_INSERT, + MCHP_RDS_PTP_TX_MOD_PTP_SYNC_TS_INSERT); + else + rc =3D phy_modify_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_MOD(BASE_PORT(clock)), + MCHP_RDS_PTP_TX_MOD_PTP_SYNC_TS_INSERT, + (u16)~MCHP_RDS_PTP_TX_MOD_PTP_SYNC_TS_INSERT); + + if (rc < 0) + return rc; + + /* Now enable the timestamping interrupts */ + rc =3D mchp_rds_ptp_config_intr(clock, + config->rx_filter !=3D + HWTSTAMP_FILTER_NONE); + if (rc < 0) + return rc; + + /* In case of multiple starts and stops, these needs to be cleared */ + spin_lock_irqsave(&clock->rx_ts_lock, flags); + list_for_each_entry_safe(rx_ts, tmp, &clock->rx_ts_list, list) { + list_del(&rx_ts->list); + kfree(rx_ts); + } + spin_unlock_irqrestore(&clock->rx_ts_lock, flags); + skb_queue_purge(&clock->rx_queue); + skb_queue_purge(&clock->tx_queue); + + rc =3D mchp_rds_ptp_flush_fifo(clock, MCHP_RDS_PTP_INGRESS_FIFO); + if (rc < 0) + return rc; + + rc =3D mchp_rds_ptp_flush_fifo(clock, MCHP_RDS_PTP_EGRESS_FIFO); + + return rc < 0 ? rc : 0; +} + +static int mchp_rds_ptp_ts_info(struct mii_timestamper *mii_ts, + struct kernel_ethtool_ts_info *info) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(mii_ts, + struct mchp_rds_ptp_clock, + mii_ts); + + info->phc_index =3D + clock->ptp_clock ? ptp_clock_index(clock->ptp_clock) : -1; + if (info->phc_index =3D=3D -1) + return 0; + + info->so_timestamping =3D SOF_TIMESTAMPING_TX_HARDWARE | + SOF_TIMESTAMPING_RX_HARDWARE | + SOF_TIMESTAMPING_RAW_HARDWARE; + + info->tx_types =3D BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON) | + BIT(HWTSTAMP_TX_ONESTEP_SYNC); + + info->rx_filters =3D BIT(HWTSTAMP_FILTER_NONE) | + BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) | + BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) | + BIT(HWTSTAMP_FILTER_PTP_V2_EVENT); + + return 0; +} + +static int mchp_rds_ptp_ltc_adjtime(struct ptp_clock_info *info, s64 delta) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(info, + struct mchp_rds_ptp_clock, + caps); + struct phy_device *phydev =3D clock->phydev; + struct timespec64 ts; + bool add =3D true; + int rc =3D 0; + u32 nsec; + s32 sec; + + /* The HW allows up to 15 sec to adjust the time, but here we limit to + * 10 sec the adjustment. The reason is, in case the adjustment is 14 + * sec and 999999999 nsec, then we add 8ns to compensate the actual + * increment so the value can be bigger than 15 sec. Therefore limit the + * possible adjustments so we will not have these corner cases + */ + if (delta > 10000000000LL || delta < -10000000000LL) { + /* The timeadjustment is too big, so fall back using set time */ + u64 now; + + info->gettime64(info, &ts); + + now =3D ktime_to_ns(timespec64_to_ktime(ts)); + ts =3D ns_to_timespec64(now + delta); + + info->settime64(info, &ts); + return 0; + } + sec =3D div_u64_rem(abs(delta), NSEC_PER_SEC, &nsec); + if (delta < 0 && nsec !=3D 0) { + /* It is not allowed to adjust low the nsec part, therefore + * subtract more from second part and add to nanosecond such + * that would roll over, so the second part will increase + */ + sec--; + nsec =3D NSEC_PER_SEC - nsec; + } + + /* Calculate the adjustments and the direction */ + if (delta < 0) + add =3D false; + + if (nsec > 0) { + /* add 8 ns to cover the likely normal increment */ + nsec +=3D 8; + + if (nsec >=3D NSEC_PER_SEC) { + /* carry into seconds */ + sec++; + nsec -=3D NSEC_PER_SEC; + } + } + + mutex_lock(&clock->ptp_lock); + if (sec) { + sec =3D abs(sec); + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_STEP_ADJ_LO(BASE_CLK(clock)), + sec); + if (rc < 0) + goto out_unlock; + + rc =3D phy_set_bits_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_STEP_ADJ_HI(BASE_CLK(clock)), + ((add ? MCHP_RDS_PTP_STEP_ADJ_HI_DIR : + 0) | ((sec >> 16) & GENMASK(13, 0)))); + if (rc < 0) + goto out_unlock; + + rc =3D phy_set_bits_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_LTC_STEP_SEC); + if (rc < 0) + goto out_unlock; + } + + if (nsec) { + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_STEP_ADJ_LO(BASE_CLK(clock)), + nsec & GENMASK(15, 0)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_STEP_ADJ_HI(BASE_CLK(clock)), + (nsec >> 16) & GENMASK(13, 0)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_set_bits_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_LTC_STEP_NSEC); + } + +out_unlock: + mutex_unlock(&clock->ptp_lock); + + return rc; +} + +static int mchp_rds_ptp_ltc_adjfine(struct ptp_clock_info *info, + long scaled_ppm) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(info, + struct mchp_rds_ptp_clock, + caps); + struct phy_device *phydev =3D clock->phydev; + u16 rate_lo, rate_hi; + bool faster =3D true; + u32 rate; + int rc; + + if (!scaled_ppm) + return 0; + + if (scaled_ppm < 0) { + scaled_ppm =3D -scaled_ppm; + faster =3D false; + } + + rate =3D MCHP_RDS_PTP_1PPM_FORMAT * (upper_16_bits(scaled_ppm)); + rate +=3D (MCHP_RDS_PTP_1PPM_FORMAT * (lower_16_bits(scaled_ppm))) >> 16; + + rate_lo =3D rate & GENMASK(15, 0); + rate_hi =3D (rate >> 16) & GENMASK(13, 0); + + if (faster) + rate_hi |=3D MCHP_RDS_PTP_LTC_RATE_ADJ_HI_DIR; + + mutex_lock(&clock->ptp_lock); + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_RATE_ADJ_HI(BASE_CLK(clock)), + rate_hi); + if (rc < 0) + goto error; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_RATE_ADJ_LO(BASE_CLK(clock)), + rate_lo); + if (rc > 0) + rc =3D 0; +error: + mutex_unlock(&clock->ptp_lock); + + return rc; +} + +static int mchp_rds_ptp_ltc_gettime64(struct ptp_clock_info *info, + struct timespec64 *ts) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(info, + struct mchp_rds_ptp_clock, + caps); + struct phy_device *phydev =3D clock->phydev; + time64_t secs; + int rc =3D 0; + s64 nsecs; + + mutex_lock(&clock->ptp_lock); + /* Set read bit to 1 to save current values of 1588 local time counter + * into PTP LTC seconds and nanoseconds registers. + */ + rc =3D phy_set_bits_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_CLOCK_READ); + if (rc < 0) + goto out_unlock; + + /* Get LTC clock values */ + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_READ_SEC_HI(BASE_CLK(clock))); + if (rc < 0) + goto out_unlock; + secs =3D rc << 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_READ_SEC_MID(BASE_CLK(clock))); + if (rc < 0) + goto out_unlock; + secs |=3D rc; + secs <<=3D 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_READ_SEC_LO(BASE_CLK(clock))); + if (rc < 0) + goto out_unlock; + secs |=3D rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_READ_NS_HI(BASE_CLK(clock))); + if (rc < 0) + goto out_unlock; + nsecs =3D (rc & GENMASK(13, 0)); + nsecs <<=3D 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_READ_NS_LO(BASE_CLK(clock))); + if (rc < 0) + goto out_unlock; + nsecs |=3D rc; + + set_normalized_timespec64(ts, secs, nsecs); + + if (rc > 0) + rc =3D 0; +out_unlock: + mutex_unlock(&clock->ptp_lock); + + return rc; +} + +static int mchp_rds_ptp_ltc_settime64(struct ptp_clock_info *info, + const struct timespec64 *ts) +{ + struct mchp_rds_ptp_clock *clock =3D container_of(info, + struct mchp_rds_ptp_clock, + caps); + struct phy_device *phydev =3D clock->phydev; + int rc; + + mutex_lock(&clock->ptp_lock); + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_SEC_LO(BASE_CLK(clock)), + lower_16_bits(ts->tv_sec)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_SEC_MID(BASE_CLK(clock)), + upper_16_bits(ts->tv_sec)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_SEC_HI(BASE_CLK(clock)), + upper_32_bits(ts->tv_sec) & GENMASK(15, 0)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_NS_LO(BASE_CLK(clock)), + lower_16_bits(ts->tv_nsec)); + if (rc < 0) + goto out_unlock; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LTC_NS_HI(BASE_CLK(clock)), + upper_16_bits(ts->tv_nsec) & GENMASK(13, 0)); + if (rc < 0) + goto out_unlock; + + /* Set load bit to 1 to write PTP LTC seconds and nanoseconds + * registers to 1588 local time counter. + */ + rc =3D phy_set_bits_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_CLOCK_LOAD); + if (rc > 0) + rc =3D 0; +out_unlock: + mutex_unlock(&clock->ptp_lock); + + return rc; +} + +static bool mchp_rds_ptp_get_sig_tx(struct sk_buff *skb, u16 *sig) +{ + struct ptp_header *ptp_header; + int type; + + type =3D ptp_classify_raw(skb); + if (type =3D=3D PTP_CLASS_NONE) + return false; + + ptp_header =3D ptp_parse_header(skb, type); + if (!ptp_header) + return false; + + *sig =3D (__force u16)(ntohs(ptp_header->sequence_id)); + + return true; +} + +static void mchp_rds_ptp_match_tx_skb(struct mchp_rds_ptp_clock *clock, + u32 seconds, u32 nsec, u16 seq_id) +{ + struct skb_shared_hwtstamps shhwtstamps; + struct sk_buff *skb, *skb_tmp; + unsigned long flags; + bool rc =3D false; + u16 skb_sig; + + spin_lock_irqsave(&clock->tx_queue.lock, flags); + skb_queue_walk_safe(&clock->tx_queue, skb, skb_tmp) { + if (!mchp_rds_ptp_get_sig_tx(skb, &skb_sig)) + continue; + + if (skb_sig !=3D seq_id) + continue; + + __skb_unlink(skb, &clock->tx_queue); + rc =3D true; + break; + } + spin_unlock_irqrestore(&clock->tx_queue.lock, flags); + + if (rc) { + shhwtstamps.hwtstamp =3D ktime_set(seconds, nsec); + skb_complete_tx_timestamp(skb, &shhwtstamps); + } +} + +static struct mchp_rds_ptp_rx_ts + *mchp_rds_ptp_get_rx_ts(struct mchp_rds_ptp_clock *clock) +{ + struct phy_device *phydev =3D clock->phydev; + struct mchp_rds_ptp_rx_ts *rx_ts =3D NULL; + u32 sec, nsec; + int rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_INGRESS_NS_HI(BASE_PORT(clock))); + if (rc < 0) + goto error; + if (!(rc & MCHP_RDS_PTP_RX_INGRESS_NS_HI_TS_VALID)) { + phydev_err(phydev, "RX Timestamp is not valid!\n"); + goto error; + } + nsec =3D (rc & GENMASK(13, 0)) << 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_INGRESS_NS_LO(BASE_PORT(clock))); + if (rc < 0) + goto error; + nsec |=3D rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_INGRESS_SEC_HI(BASE_PORT(clock))); + if (rc < 0) + goto error; + sec =3D rc << 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_INGRESS_SEC_LO(BASE_PORT(clock))); + if (rc < 0) + goto error; + sec |=3D rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_MSG_HDR2(BASE_PORT(clock))); + if (rc < 0) + goto error; + + rx_ts =3D kmalloc(sizeof(*rx_ts), GFP_KERNEL); + if (!rx_ts) + return NULL; + + rx_ts->seconds =3D sec; + rx_ts->nsec =3D nsec; + rx_ts->seq_id =3D rc; + +error: + return rx_ts; +} + +static void mchp_rds_ptp_process_rx_ts(struct mchp_rds_ptp_clock *clock) +{ + struct phy_device *phydev =3D clock->phydev; + int caps; + + do { + struct mchp_rds_ptp_rx_ts *rx_ts; + + rx_ts =3D mchp_rds_ptp_get_rx_ts(clock); + if (rx_ts) + mchp_rds_ptp_match_rx_ts(clock, rx_ts); + + caps =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CAP_INFO(BASE_PORT(clock))); + if (caps < 0) + return; + } while (MCHP_RDS_PTP_RX_TS_CNT(caps) > 0); +} + +static bool mchp_rds_ptp_get_tx_ts(struct mchp_rds_ptp_clock *clock, + u32 *sec, u32 *nsec, u16 *seq) +{ + struct phy_device *phydev =3D clock->phydev; + int rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_EGRESS_NS_HI(BASE_PORT(clock))); + if (rc < 0) + return false; + if (!(rc & MCHP_RDS_PTP_TX_EGRESS_NS_HI_TS_VALID)) + return false; + *nsec =3D (rc & GENMASK(13, 0)) << 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_EGRESS_NS_LO(BASE_PORT(clock))); + if (rc < 0) + return false; + *nsec =3D *nsec | rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_EGRESS_SEC_HI(BASE_PORT(clock))); + if (rc < 0) + return false; + *sec =3D rc << 16; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_EGRESS_SEC_LO(BASE_PORT(clock))); + if (rc < 0) + return false; + *sec =3D *sec | rc; + + rc =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_MSG_HDR2(BASE_PORT(clock))); + if (rc < 0) + return false; + + *seq =3D rc; + + return true; +} + +static void mchp_rds_ptp_process_tx_ts(struct mchp_rds_ptp_clock *clock) +{ + struct phy_device *phydev =3D clock->phydev; + int caps; + + do { + u32 sec, nsec; + u16 seq; + + if (mchp_rds_ptp_get_tx_ts(clock, &sec, &nsec, &seq)) + mchp_rds_ptp_match_tx_skb(clock, sec, nsec, seq); + + caps =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CAP_INFO(BASE_PORT(clock))); + if (caps < 0) + return; + } while (MCHP_RDS_PTP_TX_TS_CNT(caps) > 0); +} + +int mchp_rds_ptp_top_config_intr(struct mchp_rds_ptp_clock *clock, + u16 reg, u16 val, bool clear) +{ + struct phy_device *phydev =3D clock->phydev; + + if (clear) + return phy_clear_bits_mmd(phydev, PTP_MMD(clock), reg, val); + else + return phy_set_bits_mmd(phydev, PTP_MMD(clock), reg, val); +} +EXPORT_SYMBOL_GPL(mchp_rds_ptp_top_config_intr); + +irqreturn_t mchp_rds_ptp_handle_interrupt(struct mchp_rds_ptp_clock *clock) +{ + struct phy_device *phydev; + int irq_sts; + + /* To handle rogue interrupt scenarios */ + if (!clock) + return IRQ_NONE; + + phydev =3D clock->phydev; + do { + irq_sts =3D phy_read_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_INT_STS(BASE_PORT(clock))); + if (irq_sts < 0) + return IRQ_NONE; + + if (irq_sts & MCHP_RDS_PTP_INT_RX_TS_EN) + mchp_rds_ptp_process_rx_ts(clock); + + if (irq_sts & MCHP_RDS_PTP_INT_TX_TS_EN) + mchp_rds_ptp_process_tx_ts(clock); + + if (irq_sts & MCHP_RDS_PTP_INT_TX_TS_OVRFL_EN) { + mchp_rds_ptp_flush_fifo(clock, + MCHP_RDS_PTP_EGRESS_FIFO); + skb_queue_purge(&clock->tx_queue); + } + + if (irq_sts & MCHP_RDS_PTP_INT_RX_TS_OVRFL_EN) { + mchp_rds_ptp_flush_fifo(clock, + MCHP_RDS_PTP_INGRESS_FIFO); + skb_queue_purge(&clock->rx_queue); + } + } while (irq_sts & (MCHP_RDS_PTP_INT_RX_TS_EN | + MCHP_RDS_PTP_INT_TX_TS_EN | + MCHP_RDS_PTP_INT_TX_TS_OVRFL_EN | + MCHP_RDS_PTP_INT_RX_TS_OVRFL_EN)); + + return IRQ_HANDLED; +} +EXPORT_SYMBOL_GPL(mchp_rds_ptp_handle_interrupt); + +static int mchp_rds_ptp_init(struct mchp_rds_ptp_clock *clock) +{ + struct phy_device *phydev =3D clock->phydev; + int rc; + + /* Disable PTP */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_DIS); + if (rc < 0) + return rc; + + /* Disable TSU */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TSU_GEN_CONFIG(BASE_PORT(clock)), 0); + if (rc < 0) + return rc; + + /* Clear PTP interrupt status registers */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TSU_HARD_RESET(BASE_PORT(clock)), + MCHP_RDS_PTP_TSU_HARDRESET); + if (rc < 0) + return rc; + + /* Predictor enable */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_LATENCY_CORRECTION_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_LATENCY_SETTING); + if (rc < 0) + return rc; + + /* Configure PTP operational mode */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_OP_MODE(BASE_CLK(clock)), + MCHP_RDS_PTP_OP_MODE_STANDALONE); + if (rc < 0) + return rc; + + /* Reference clock configuration */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_REF_CLK_CFG(BASE_CLK(clock)), + MCHP_RDS_PTP_REF_CLK_CFG_SET); + if (rc < 0) + return rc; + + /* Classifier configurations */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_PARSE_CONFIG(BASE_PORT(clock)), 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_PARSE_CONFIG(BASE_PORT(clock)), 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_PARSE_L2_ADDR_EN(BASE_PORT(clock)), + 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_PARSE_L2_ADDR_EN(BASE_PORT(clock)), + 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_PARSE_IPV4_ADDR_EN(BASE_PORT(clock)), + 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_PARSE_IPV4_ADDR_EN(BASE_PORT(clock)), + 0); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_RX_VERSION(BASE_PORT(clock)), + MCHP_RDS_PTP_MAX_VERSION(0xff) | + MCHP_RDS_PTP_MIN_VERSION(0x0)); + if (rc < 0) + return rc; + + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TX_VERSION(BASE_PORT(clock)), + MCHP_RDS_PTP_MAX_VERSION(0xff) | + MCHP_RDS_PTP_MIN_VERSION(0x0)); + if (rc < 0) + return rc; + + /* Enable TSU */ + rc =3D phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_TSU_GEN_CONFIG(BASE_PORT(clock)), + MCHP_RDS_PTP_TSU_GEN_CFG_TSU_EN); + if (rc < 0) + return rc; + + /* Enable PTP */ + return phy_write_mmd(phydev, PTP_MMD(clock), + MCHP_RDS_PTP_CMD_CTL(BASE_CLK(clock)), + MCHP_RDS_PTP_CMD_CTL_EN); +} + +struct mchp_rds_ptp_clock *mchp_rds_ptp_probe(struct phy_device *phydev, u= 8 mmd, + u16 clk_base_addr, + u16 port_base_addr) +{ + struct mchp_rds_ptp_clock *clock; + int rc; + + clock =3D devm_kzalloc(&phydev->mdio.dev, sizeof(*clock), GFP_KERNEL); + if (!clock) + return ERR_PTR(-ENOMEM); + + clock->port_base_addr =3D port_base_addr; + clock->clk_base_addr =3D clk_base_addr; + clock->mmd =3D mmd; + + mutex_init(&clock->ptp_lock); + /* Register PTP clock */ + clock->caps.owner =3D THIS_MODULE; + snprintf(clock->caps.name, 30, "%s", phydev->drv->name); + clock->caps.max_adj =3D MCHP_RDS_PTP_MAX_ADJ; + clock->caps.n_ext_ts =3D 0; + clock->caps.pps =3D 0; + clock->caps.adjfine =3D mchp_rds_ptp_ltc_adjfine; + clock->caps.adjtime =3D mchp_rds_ptp_ltc_adjtime; + clock->caps.gettime64 =3D mchp_rds_ptp_ltc_gettime64; + clock->caps.settime64 =3D mchp_rds_ptp_ltc_settime64; + clock->ptp_clock =3D ptp_clock_register(&clock->caps, + &phydev->mdio.dev); + if (IS_ERR(clock->ptp_clock)) + return ERR_PTR(-EINVAL); + + /* Initialize the SW */ + skb_queue_head_init(&clock->tx_queue); + skb_queue_head_init(&clock->rx_queue); + INIT_LIST_HEAD(&clock->rx_ts_list); + spin_lock_init(&clock->rx_ts_lock); + + clock->mii_ts.rxtstamp =3D mchp_rds_ptp_rxtstamp; + clock->mii_ts.txtstamp =3D mchp_rds_ptp_txtstamp; + clock->mii_ts.hwtstamp =3D mchp_rds_ptp_hwtstamp; + clock->mii_ts.ts_info =3D mchp_rds_ptp_ts_info; + + phydev->mii_ts =3D &clock->mii_ts; + + /* Timestamp selected by default to keep legacy API */ + phydev->default_timestamp =3D true; + + clock->phydev =3D phydev; + + rc =3D mchp_rds_ptp_init(clock); + if (rc < 0) + return ERR_PTR(rc); + + return clock; +} +EXPORT_SYMBOL_GPL(mchp_rds_ptp_probe); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("MICROCHIP PHY RDS PTP driver"); +MODULE_AUTHOR("Divya Koppera"); --=20 2.17.1 From nobody Wed Dec 17 16:09:30 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (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 0BC761B423B; Mon, 9 Dec 2024 15:18:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757501; cv=none; b=mmOa1/UG4E94cnCcaIQwyDx68wG6ct+BwL/v6oxwdhGHLw6zkLVHMLa68ha+imozJ9EICGVfkbP/DZ3vpm07EVFFSg3oU5q2/jn/bsSIfGAbSSoCTruFcnLTNh+H2GBULy7EZ19lF0dbHW5sLEHgfM4dU7I2fOusMnlxvwa9srw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757501; c=relaxed/simple; bh=34Kvhd9rXAxxfCnK//kvZ21jMyc9BazOQaCB2lv9p6k=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=jApVaYgt2DnkfNLyl0y5fBqnp3fO7rUeJM+1DrEwJfqO6o8uqevm1CzbkDQEyr0/xG6tmJ+h3Dk3SyPg6CopJ+MwdFePyoD6pJJIZ899RMafKzqLAPYM+Ibqq/wBeoe9W5vKEOU/UM13OzuqIT5IivZ5RV4JujZ+BMqG4dfbEKo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=aNEt/IsR; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="aNEt/IsR" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1733757500; x=1765293500; h=from:to:subject:date:message-id:in-reply-to:references: mime-version; bh=34Kvhd9rXAxxfCnK//kvZ21jMyc9BazOQaCB2lv9p6k=; b=aNEt/IsRVkALWae/ACyVnVVYT4k1F+G/LgSalm638YQqZLgOqPE2Egbp Igi49RqvmJCkf5ej82oTxYthWJGbqQ/c7ZpgkiBp95WUD9Izl+F9taHqr ZA2rdRxMJ8hul6R07X4Pk9EpZsdx3NzyG/Uw5Xy+uDz2efQkGUY0NcU9j 58Mog9v+3B6ibzQG306aa2jIWIFOubYcTXEzS9i6Wjf8jAok5piWY51T9 T/cPiFO4DfRBPgKyZIlpYB0AL43R46P2x21v16/CePZsl7cHZOZNgJQiz EL98nkjh90ij0L+Q/sTX8kvtf9Ymn8d5TvIyWGdxcv7lj+JOyP5JhQEu1 g==; X-CSE-ConnectionGUID: yJIa2BtxQkuJT04wZ40P6A== X-CSE-MsgGUID: tWARgQsjTA2f1+q38CqAwA== X-IronPort-AV: E=Sophos;i="6.12,219,1728975600"; d="scan'208";a="35775868" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 09 Dec 2024 08:18:15 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex01.mchp-main.com (10.10.85.143) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.35; Mon, 9 Dec 2024 08:17:49 -0700 Received: from training-HP-280-G1-MT-PC.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.35 via Frontend Transport; Mon, 9 Dec 2024 08:17:45 -0700 From: Divya Koppera To: , , , , , , , , , , , , Subject: [PATCH net-next v6 3/5] net: phy: Kconfig: Add rds ptp library support and 1588 optional flag in Microchip phys Date: Mon, 9 Dec 2024 20:47:40 +0530 Message-ID: <20241209151742.9128-4-divya.koppera@microchip.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20241209151742.9128-1-divya.koppera@microchip.com> References: <20241209151742.9128-1-divya.koppera@microchip.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 ptp library support in Kconfig As some of Microchip T1 phys support ptp, add dependency of 1588 optional flag in Kconfig Reviewed-by: Vadim Fedorenko Signed-off-by: Divya Koppera --- v5 -> v6 - Renamed the config name to reflect ptp hardware used. v4 -> v5 Addressed below review comments. - Indentation fix - Changed dependency check to if check for PTP_1588_CLOCK_OPTIONAL v1 -> v2 -> v3 -> v4 - No changes --- drivers/net/phy/Kconfig | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig index 15828f4710a9..4ff6f5474397 100644 --- a/drivers/net/phy/Kconfig +++ b/drivers/net/phy/Kconfig @@ -287,8 +287,15 @@ config MICROCHIP_PHY =20 config MICROCHIP_T1_PHY tristate "Microchip T1 PHYs" + select MICROCHIP_PHY_RDS_PTP if NETWORK_PHY_TIMESTAMPING && \ + PTP_1588_CLOCK_OPTIONAL help - Supports the LAN87XX PHYs. + Supports the LAN8XXX PHYs. + +config MICROCHIP_PHY_RDS_PTP + tristate "Microchip PHY RDS PTP" + help + Currently supports LAN887X T1 PHY =20 config MICROSEMI_PHY tristate "Microsemi PHYs" --=20 2.17.1 From nobody Wed Dec 17 16:09:30 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (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 9E2E71BEF9F; Mon, 9 Dec 2024 15:18:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757502; cv=none; b=K6oZSFdJjj7BoOUQBuhcvaUm/lW37CRiog+l/uk9tAPA5HaoiMt2hovkA/JTtDyFeZVTPD+5bUlkUw4k0ISjTTzCn74EMeb80f1grZBT9R+2jNZz2PBkVuNW/KUAj13uQzlmDzs/hkcZ+9ujtnIruBKkcnJ4dffHWNyCiDfoqO0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757502; c=relaxed/simple; bh=TaaoUJlwFZIyPi3oJlLOERwTajsuwKUCCV07uM4pMJg=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=qpHFe28WOPXWq10qMXHjbnlm6Mz1e8qzrCpokZZp6SDb9+zyvxbp62ShNUrmY+g1VoUtLfLs2vHA5EkSm05Xl9tgi2wkFASmcAOJuMGdtmveRaNE7tgi+RNlOWJT4JH4LNK2RPNwq2W+Z/fURTc74Ht+XgMvUFRLPPkpE96xznM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=EY3zq0/f; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="EY3zq0/f" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1733757500; x=1765293500; h=from:to:subject:date:message-id:in-reply-to:references: mime-version; bh=TaaoUJlwFZIyPi3oJlLOERwTajsuwKUCCV07uM4pMJg=; b=EY3zq0/f1B1zBGa3d0cVdceaaCu5ZqdUCiS9ToD3VWFWOUBNtOmhWzRb 7jLiyq20hrdGuLSqQlxEuoaGsaR5ExvWfC9+OT2RI98uQuSd8a51IVUxk ZJyt/AroFHZUJ/HYkNXNdeniLxglw1rEJWG8ZbZ9MJCcT0JX+SaLEMirU hrlftzKpdI9wBbApys4UI2dv4x3wvKAgtrDdSG2KpzmYy3txUTLUJzh+C vuRSyrj4ND6eVcVrFCL16oqjFW0wjXSMyPhPhnyr7v31+VHwbCzx7SYqx XMlusjcw4jJ+3nmDgkM7Xb97bVcosHGRuHgsATy+O3o9OkBR1rq5GgCBo w==; X-CSE-ConnectionGUID: yJIa2BtxQkuJT04wZ40P6A== X-CSE-MsgGUID: zpgMCeI+SAuE1pqvxKQsyQ== X-IronPort-AV: E=Sophos;i="6.12,219,1728975600"; d="scan'208";a="35775870" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 09 Dec 2024 08:18:15 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex01.mchp-main.com (10.10.85.143) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.35; Mon, 9 Dec 2024 08:17:53 -0700 Received: from training-HP-280-G1-MT-PC.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.35 via Frontend Transport; Mon, 9 Dec 2024 08:17:49 -0700 From: Divya Koppera To: , , , , , , , , , , , , Subject: [PATCH net-next v6 4/5] net: phy: Makefile: Add makefile support for rds ptp in Microchip phys Date: Mon, 9 Dec 2024 20:47:41 +0530 Message-ID: <20241209151742.9128-5-divya.koppera@microchip.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20241209151742.9128-1-divya.koppera@microchip.com> References: <20241209151742.9128-1-divya.koppera@microchip.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 makefile support for rds ptp library. Reviewed-by: Vadim Fedorenko Signed-off-by: Divya Koppera --- v5 -> v6 - Renamed config name and object file name to reflect ptp hardware code nam= e. v1 -> v5 - No changes --- drivers/net/phy/Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/net/phy/Makefile b/drivers/net/phy/Makefile index e6145153e837..e32600f3e4f1 100644 --- a/drivers/net/phy/Makefile +++ b/drivers/net/phy/Makefile @@ -80,6 +80,7 @@ obj-$(CONFIG_MICREL_KS8995MA) +=3D spi_ks8995.o obj-$(CONFIG_MICREL_PHY) +=3D micrel.o obj-$(CONFIG_MICROCHIP_PHY) +=3D microchip.o obj-$(CONFIG_MICROCHIP_T1_PHY) +=3D microchip_t1.o +obj-$(CONFIG_MICROCHIP_PHY_RDS_PTP) +=3D microchip_rds_ptp.o obj-$(CONFIG_MICROCHIP_T1S_PHY) +=3D microchip_t1s.o obj-$(CONFIG_MICROSEMI_PHY) +=3D mscc/ obj-$(CONFIG_MOTORCOMM_PHY) +=3D motorcomm.o --=20 2.17.1 From nobody Wed Dec 17 16:09:30 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (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 3EA3D1C5CD6; Mon, 9 Dec 2024 15:18:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757503; cv=none; b=W0c79hd/oE7D+h3/DhZEeNoZN/yrrQXohpUZoPHBQ52xV4P/QzPD41VcIvXHHniVSbewyyjBqxy1VZ/8kawxu/5lDFH7KmmZPxvnXaBicSAwZlnj0rVstSu8tWC0XdC6yho+lKVNUqmR23yFTfOrEmG0IUw8YdBBbvX7UobsvZ0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1733757503; c=relaxed/simple; bh=PRlmrlfVkKdHL5h3fcsDewPyc+WWxgXH7RFjGKU4QHY=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=QumULOPRatY28IPC3EPle8zSYFaX8jZ3DlRtoRM968NAypCcei114cskAbGMAACM/BSinx45oYJxS5SrFOFmUSYp6NpOSZoW5kaiHek7nmHo2BILzhPsa3flKKfwq/QmtIyYUMoaNmYS6dXu5E+VaU/NcdgJBreU2V7bYjvRP0c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=n00KrHCP; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="n00KrHCP" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1733757502; x=1765293502; h=from:to:subject:date:message-id:in-reply-to:references: mime-version; bh=PRlmrlfVkKdHL5h3fcsDewPyc+WWxgXH7RFjGKU4QHY=; b=n00KrHCPMm5c8VV4IoB2rtHAbOl6A5c1Gz1oVkuPWnNdYJAEB3TrFWjW hXRBLANmxT1EmYa77EJk28suKtLsY/Cfj+k7gNFzsfUNPAmsyHT9yLEK5 KQd/U4cr4ZQ/M5ThJhevFZUsdoQbfinY1BLrDYgbSKrW8TjHwjRptrLqg p1Dr2OOF3wtsWm8T1nGOqz0ohxbF5Scr0GXNZXPNp2BCPm4Mqj3zPfpQp T18F1SKkGxgTzUTXLE7BKUHgJIQqUhGDuIwvkbd9GAUVGDXxel3zsvVHh FTEslI8NEfE3eLxps3luarKY83f/VoG0ROv7aB+36rjYdfCAhMp2ZNsA2 A==; X-CSE-ConnectionGUID: yJIa2BtxQkuJT04wZ40P6A== X-CSE-MsgGUID: 7fc63HofQoWQAb2X16tGBg== X-IronPort-AV: E=Sophos;i="6.12,219,1728975600"; d="scan'208";a="35775873" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 09 Dec 2024 08:18:15 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex01.mchp-main.com (10.10.85.143) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.35; Mon, 9 Dec 2024 08:17:58 -0700 Received: from training-HP-280-G1-MT-PC.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.35 via Frontend Transport; Mon, 9 Dec 2024 08:17:54 -0700 From: Divya Koppera To: , , , , , , , , , , , , Subject: [PATCH net-next v6 5/5] net: phy: microchip_t1 : Add initialization of ptp for lan887x Date: Mon, 9 Dec 2024 20:47:42 +0530 Message-ID: <20241209151742.9128-6-divya.koppera@microchip.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20241209151742.9128-1-divya.koppera@microchip.com> References: <20241209151742.9128-1-divya.koppera@microchip.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 initialization of ptp for lan887x. Signed-off-by: Divya Koppera --- v5 -> v6 - Renamed ptp functions and macros. v2 -> v5 - No changes v1 -> v2 Fixed below review comment Added ptp support only if interrupts are supported as interrupts are mand= atory for ptp. --- drivers/net/phy/microchip_t1.c | 41 +++++++++++++++++++++++++++++++--- 1 file changed, 38 insertions(+), 3 deletions(-) diff --git a/drivers/net/phy/microchip_t1.c b/drivers/net/phy/microchip_t1.c index b17bf6708003..73f28463bc35 100644 --- a/drivers/net/phy/microchip_t1.c +++ b/drivers/net/phy/microchip_t1.c @@ -10,11 +10,15 @@ #include #include #include +#include "microchip_rds_ptp.h" =20 #define PHY_ID_LAN87XX 0x0007c150 #define PHY_ID_LAN937X 0x0007c180 #define PHY_ID_LAN887X 0x0007c1f0 =20 +#define MCHP_RDS_PTP_LTC_BASE_ADDR 0xe000 +#define MCHP_RDS_PTP_PORT_BASE_ADDR (MCHP_RDS_PTP_LTC_BASE_ADDR + 0x80= 0) + /* External Register Control Register */ #define LAN87XX_EXT_REG_CTL (0x14) #define LAN87XX_EXT_REG_CTL_RD_CTL (0x1000) @@ -229,6 +233,7 @@ =20 #define LAN887X_INT_STS 0xf000 #define LAN887X_INT_MSK 0xf001 +#define LAN887X_INT_MSK_P1588_MOD_INT_MSK BIT(3) #define LAN887X_INT_MSK_T1_PHY_INT_MSK BIT(2) #define LAN887X_INT_MSK_LINK_UP_MSK BIT(1) #define LAN887X_INT_MSK_LINK_DOWN_MSK BIT(0) @@ -319,6 +324,8 @@ struct lan887x_regwr_map { =20 struct lan887x_priv { u64 stats[ARRAY_SIZE(lan887x_hw_stats)]; + struct mchp_rds_ptp_clock *clock; + bool init_done; }; =20 static int lan937x_dsp_workaround(struct phy_device *phydev, u16 ereg, u8 = bank) @@ -1269,8 +1276,19 @@ static int lan887x_get_features(struct phy_device *p= hydev) =20 static int lan887x_phy_init(struct phy_device *phydev) { + struct lan887x_priv *priv =3D phydev->priv; int ret; =20 + if (!priv->init_done && phy_interrupt_is_valid(phydev)) { + priv->clock =3D mchp_rds_ptp_probe(phydev, MDIO_MMD_VEND1, + MCHP_RDS_PTP_LTC_BASE_ADDR, + MCHP_RDS_PTP_PORT_BASE_ADDR); + if (IS_ERR(priv->clock)) + return PTR_ERR(priv->clock); + + priv->init_done =3D true; + } + /* Clear loopback */ ret =3D phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, LAN887X_MIS_CFG_REG2, @@ -1470,6 +1488,7 @@ static int lan887x_probe(struct phy_device *phydev) if (!priv) return -ENOMEM; =20 + priv->init_done =3D false; phydev->priv =3D priv; =20 return lan887x_phy_setup(phydev); @@ -1518,6 +1537,7 @@ static void lan887x_get_strings(struct phy_device *ph= ydev, u8 *data) =20 static int lan887x_config_intr(struct phy_device *phydev) { + struct lan887x_priv *priv =3D phydev->priv; int rc; =20 if (phydev->interrupts =3D=3D PHY_INTERRUPT_ENABLED) { @@ -1537,12 +1557,24 @@ static int lan887x_config_intr(struct phy_device *p= hydev) =20 rc =3D phy_read_mmd(phydev, MDIO_MMD_VEND1, LAN887X_INT_STS); } + if (rc < 0) + return rc; =20 - return rc < 0 ? rc : 0; + if (phy_is_default_hwtstamp(phydev)) { + return mchp_rds_ptp_top_config_intr(priv->clock, + LAN887X_INT_MSK, + LAN887X_INT_MSK_P1588_MOD_INT_MSK, + (phydev->interrupts =3D=3D + PHY_INTERRUPT_ENABLED)); + } + + return 0; } =20 static irqreturn_t lan887x_handle_interrupt(struct phy_device *phydev) { + struct lan887x_priv *priv =3D phydev->priv; + int rc =3D IRQ_NONE; int irq_status; =20 irq_status =3D phy_read_mmd(phydev, MDIO_MMD_VEND1, LAN887X_INT_STS); @@ -1553,10 +1585,13 @@ static irqreturn_t lan887x_handle_interrupt(struct = phy_device *phydev) =20 if (irq_status & LAN887X_MX_CHIP_TOP_LINK_MSK) { phy_trigger_machine(phydev); - return IRQ_HANDLED; + rc =3D IRQ_HANDLED; } =20 - return IRQ_NONE; + if (irq_status & LAN887X_INT_MSK_P1588_MOD_INT_MSK) + rc =3D mchp_rds_ptp_handle_interrupt(priv->clock); + + return rc; } =20 static int lan887x_cd_reset(struct phy_device *phydev, --=20 2.17.1