From nobody Tue Oct 7 16:36:36 2025 Received: from mailout3.samsung.com (mailout3.samsung.com [203.254.224.33]) (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 5AC342D8391 for ; Tue, 8 Jul 2025 10:40:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.33 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971253; cv=none; b=h2Brl5HxFYJcNhN/Btiv8IZrOTlfn38a1GPenQemsnVRtzmTERC7NXB6I3P2vl1NFYMWndoAMR4uUd/cWWUbA/cB0x62DfdXvzLhajtQ6HEIeU6gJQKpODLkTxzedhQeAE5P/WADOEXuI0NjBJzv+URGCmsMyg5fbWhWyUxyiyM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971253; c=relaxed/simple; bh=MDIEaPr8HDVKtLmDaM9Mbp62hb9gBqko7nOef0uAuIU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=OY1GBpO0OSlZ88cAjUSIfH9RJkoa90FH0S3r4zjhu7z+sRh65Zol/c4X7y4pvtIpd1DBDI9H3cSll4XOZA1QLr7+a04VebdZNRQWwqa5GrinpJEntnk5XSuaov0UZ9PJ6tsJTLx1jYdFQdmXYjhFBsIrds/6nog+L/IQdeDJKQ0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=AFZE5An8; arc=none smtp.client-ip=203.254.224.33 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="AFZE5An8" Received: from epcas5p1.samsung.com (unknown [182.195.41.39]) by mailout3.samsung.com (KnoxPortal) with ESMTP id 20250708104049epoutp036f4884f44ae998714a470810c17ec75f~QQJGxCry12777027770epoutp03X for ; Tue, 8 Jul 2025 10:40:49 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout3.samsung.com 20250708104049epoutp036f4884f44ae998714a470810c17ec75f~QQJGxCry12777027770epoutp03X DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971249; bh=jH87uithjfzP9Ykpoxmhz9d98lNSkdIORLDu4bcOrWg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=AFZE5An8I4UPKDhyNrWZ1uIaoLRQWo68NYtgqYhHHThIXR2SZeyqwIsyrT8stp3x4 qMFLlUMv/KA1I8CeO2caI76ypjuswT4VrNDXGK2nZzwmia71I4VHIh7hefVBeGk7cw FK2q2XSKZWntlFs8qjTO0zkbmTi3qWAlLI5BX7IQ= Received: from epsnrtp02.localdomain (unknown [182.195.42.154]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPS id 20250708104048epcas5p45aedc6a241e37ee683d7b1880dc8903e~QQJGIyyTk1622616226epcas5p4l; Tue, 8 Jul 2025 10:40:48 +0000 (GMT) Received: from epcas5p2.samsung.com (unknown [182.195.38.175]) by epsnrtp02.localdomain (Postfix) with ESMTP id 4bbyLl00Mhz2SSKZ; Tue, 8 Jul 2025 10:40:47 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p1.samsung.com (KnoxPortal) with ESMTPA id 20250708103231epcas5p1b9fe52dd6ea3cdd65a5df163ba05e139~QQB2zDMtv0987209872epcas5p11; Tue, 8 Jul 2025 10:32:31 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103228epsmtip11c2127deecf9c06a4da8aa251fc8feba~QQB0CXqJN2120421204epsmtip1W; Tue, 8 Jul 2025 10:32:28 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 1/6] dt-bindings: clock: Add PPMU clock definitions for FSD platform Date: Tue, 8 Jul 2025 16:02:03 +0530 Message-ID: <20250708103208.79444-2-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103231epcas5p1b9fe52dd6ea3cdd65a5df163ba05e139 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103231epcas5p1b9fe52dd6ea3cdd65a5df163ba05e139 References: <20250708103208.79444-1-vivek.2311@samsung.com> Add clock IDs for PPMU (Platform Performance Monitoring Unit) associated with the MFC block. Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- include/dt-bindings/clock/fsd-clk.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/dt-bindings/clock/fsd-clk.h b/include/dt-bindings/cloc= k/fsd-clk.h index 3f7b64d93558..552e8bad98e0 100644 --- a/include/dt-bindings/clock/fsd-clk.h +++ b/include/dt-bindings/clock/fsd-clk.h @@ -125,6 +125,10 @@ =20 /* MFC */ #define MFC_MFC_IPCLKPORT_ACLK 1 +#define MFC_PPMU_MFCD0_IPCLKPORT_ACLK 2 +#define MFC_PPMU_MFCD0_IPCLKPORT_PCLK 3 +#define MFC_PPMU_MFCD1_IPCLKPORT_ACLK 4 +#define MFC_PPMU_MFCD1_IPCLKPORT_PCLK 5 =20 /* CAM_CSI */ #define CAM_CSI0_0_IPCLKPORT_I_ACLK 1 --=20 2.49.0 From nobody Tue Oct 7 16:36:36 2025 Received: from mailout1.samsung.com (mailout1.samsung.com [203.254.224.24]) (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 D6D072D9489 for ; Tue, 8 Jul 2025 10:41:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.24 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971264; cv=none; b=YYfBp9MSX4YBr+pWu5G5CFE08L8+OTjXELygFnnRMPXippI/mGKw7JrdTdcHF7dlQ7kCVFtlP0N8ovenX6qvW1GTMWh6+rZUnE6NW4MuSE8wfVxxoXdVj4KTrQ218rPkNBIv6c5E1cHfhzK/6iaiRF5i8dFdqx/PA3qy3gyGOZ8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971264; c=relaxed/simple; bh=/RQNQ/dtfaKGETOGG3j7ev7DvdiaASUa4WOAtBdY7i8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=IOPH/M71DI/MQAsR0k1ONN2cQiDqCtNqHKyV1b7XU+h4F1V8sMKbItiaCLxiGszNtjmfavtbmUI9KhNMvqGI64UJTe6Nn1Ox6NFINI07apcopLa2/ISBx5eBnZbYt3k4gJ1XS+aomvI3EDKU1b26PugMKJYYwj53CI8VP+3fle8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=EFHzxLOu; arc=none smtp.client-ip=203.254.224.24 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="EFHzxLOu" Received: from epcas5p4.samsung.com (unknown [182.195.41.42]) by mailout1.samsung.com (KnoxPortal) with ESMTP id 20250708104054epoutp01ad3cca3ecf747ad7b496c54e66b61e8b~QQJLpnHWS2791827918epoutp013 for ; Tue, 8 Jul 2025 10:40:54 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout1.samsung.com 20250708104054epoutp01ad3cca3ecf747ad7b496c54e66b61e8b~QQJLpnHWS2791827918epoutp013 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971254; bh=NfJkRbmOTcr65lxFjeLJlMql9NikTl7suSZwH4Lbtaw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EFHzxLOuBTdSuIov5DF5cUvKsT78IEQnI65z5yArW0VpOHTa8/RJcDiNpIKNq7HzG QCDb1F0r/gCssG8Ql8Q4TIF0y8IucFXPn8h480iMNvhAGbH4VOiDpNvfSbVBkQ7BR5 uAKEbArChXFb6HcIbTK0Zm9rOuemFBOCkah+GZ7I= Received: from epsnrtp02.localdomain (unknown [182.195.42.154]) by epcas5p1.samsung.com (KnoxPortal) with ESMTPS id 20250708104053epcas5p1dc5ef8f325ace2a1f6519b582ca1572f~QQJKvz5310327403274epcas5p1w; Tue, 8 Jul 2025 10:40:53 +0000 (GMT) Received: from epcas5p2.samsung.com (unknown [182.195.38.174]) by epsnrtp02.localdomain (Postfix) with ESMTP id 4bbyLq4gfxz2SSKn; Tue, 8 Jul 2025 10:40:51 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p1.samsung.com (KnoxPortal) with ESMTPA id 20250708103234epcas5p1a92b0b57315f6e81c906fedcc232c279~QQB5qA9nc0987209872epcas5p1H; Tue, 8 Jul 2025 10:32:34 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103231epsmtip1869c3d7d71f4a9e263c08b8ccd9b4dd6~QQB3BuOct2131121311epsmtip1l; Tue, 8 Jul 2025 10:32:31 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 2/6] clk: samsung: fsd: Use clock IDs for PPMU MFC block Date: Tue, 8 Jul 2025 16:02:04 +0530 Message-ID: <20250708103208.79444-3-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103234epcas5p1a92b0b57315f6e81c906fedcc232c279 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103234epcas5p1a92b0b57315f6e81c906fedcc232c279 References: <20250708103208.79444-1-vivek.2311@samsung.com> Use PPMU clock ID macros for PPMU MFC gate clocks. Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- drivers/clk/samsung/clk-fsd.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/drivers/clk/samsung/clk-fsd.c b/drivers/clk/samsung/clk-fsd.c index 9a6006c298c2..f80d35feb3f7 100644 --- a/drivers/clk/samsung/clk-fsd.c +++ b/drivers/clk/samsung/clk-fsd.c @@ -88,7 +88,7 @@ #define CLKS_NR_FSYS0 (FSYS0_DOUT_FSYS0_PERIBUS_GRP + 1) #define CLKS_NR_FSYS1 (PCIE_LINK1_IPCLKPORT_SLV_ACLK + 1) #define CLKS_NR_IMEM (IMEM_TMU_GT_IPCLKPORT_I_CLK_TS + 1) -#define CLKS_NR_MFC (MFC_MFC_IPCLKPORT_ACLK + 1) +#define CLKS_NR_MFC (MFC_PPMU_MFCD1_IPCLKPORT_PCLK + 1) #define CLKS_NR_CAM_CSI (CAM_CSI2_3_IPCLKPORT_I_ACLK + 1) =20 static const unsigned long cmu_clk_regs[] __initconst =3D { @@ -1519,13 +1519,13 @@ static const struct samsung_gate_clock mfc_gate_clk= s[] __initconst =3D { GAT_MFC_NS_BRDG_MFC_IPCLKPORT_CLK__PMFC__CLK_MFC_D, 21, CLK_IGNORE_U= NUSED, 0), GATE(0, "mfc_ns_brdg_mfc_ipclkport_clk__pmfc__clk_mfc_p", "mout_mfc_busp", GAT_MFC_NS_BRDG_MFC_IPCLKPORT_CLK__PMFC__CLK_MFC_P, 21, CLK_IGNORE_U= NUSED, 0), - GATE(0, "mfc_ppmu_mfcd0_ipclkport_aclk", "mout_mfc_busd", + GATE(MFC_PPMU_MFCD0_IPCLKPORT_ACLK, "mfc_ppmu_mfcd0_ipclkport_aclk", "mou= t_mfc_busd", GAT_MFC_PPMU_MFCD0_IPCLKPORT_ACLK, 21, CLK_IGNORE_UNUSED, 0), - GATE(0, "mfc_ppmu_mfcd0_ipclkport_pclk", "mout_mfc_busp", + GATE(MFC_PPMU_MFCD0_IPCLKPORT_PCLK, "mfc_ppmu_mfcd0_ipclkport_pclk", "mou= t_mfc_busp", GAT_MFC_PPMU_MFCD0_IPCLKPORT_PCLK, 21, CLK_IGNORE_UNUSED, 0), - GATE(0, "mfc_ppmu_mfcd1_ipclkport_aclk", "mout_mfc_busd", + GATE(MFC_PPMU_MFCD1_IPCLKPORT_ACLK, "mfc_ppmu_mfcd1_ipclkport_aclk", "mou= t_mfc_busd", GAT_MFC_PPMU_MFCD1_IPCLKPORT_ACLK, 21, CLK_IGNORE_UNUSED, 0), - GATE(0, "mfc_ppmu_mfcd1_ipclkport_pclk", "mout_mfc_busp", + GATE(MFC_PPMU_MFCD1_IPCLKPORT_PCLK, "mfc_ppmu_mfcd1_ipclkport_pclk", "mou= t_mfc_busp", GAT_MFC_PPMU_MFCD1_IPCLKPORT_PCLK, 21, CLK_IGNORE_UNUSED, 0), GATE(0, "mfc_sysreg_mfc_ipclkport_pclk", "mout_mfc_busp", GAT_MFC_SYSREG_MFC_IPCLKPORT_PCLK, 21, CLK_IGNORE_UNUSED, 0), --=20 2.49.0 From nobody Tue Oct 7 16:36:36 2025 Received: from mailout4.samsung.com (mailout4.samsung.com [203.254.224.34]) (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 D90772D8771 for ; Tue, 8 Jul 2025 10:41:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.34 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971263; cv=none; b=A/ACnlPuKgofD7qqmvC63lMvzzATD/mLih0Dpqg63HbJJhHIIwU+20hM5sZLYh6dQeWkzyWd7gJ2V+pfwG9en0dw6vf7eAXh7d5BXCDUcD//Got/7PPWu4+O0jJYV7AHWl3+jhudsSfpkq58u+8a2r/kHIBe0jhbhoXmeGJa+QM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971263; c=relaxed/simple; bh=1dTkMR7ivxCKPAG8IwLvcS5tHG1yew3jddWr45nGSSo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=t/5PIYXKWha0wk5MiTbmPQArMQrUQeWMbxgK1PmxRPM3LC4tKgbrx+P2VcJFEMYZfARC+7/yWodwdVU4NOgqcnnBQ/Rbf4qzljSgFlUoOcIqTEZNOY75bZz9s2q7PzHNi3i+uQEwZLfiVc8o9dK7MSdsU72gLlQSsDnPjosKITc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=Jsfx/fal; arc=none smtp.client-ip=203.254.224.34 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="Jsfx/fal" Received: from epcas5p2.samsung.com (unknown [182.195.41.40]) by mailout4.samsung.com (KnoxPortal) with ESMTP id 20250708104059epoutp04c8fa4fb8addc3e64d0cf33c630968918~QQJQZh__70897808978epoutp04F for ; Tue, 8 Jul 2025 10:40:59 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout4.samsung.com 20250708104059epoutp04c8fa4fb8addc3e64d0cf33c630968918~QQJQZh__70897808978epoutp04F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971259; bh=NYCyVQSEhyiNgRSZQjKeP4GdTZI8s/pFA0yDOkhv5d0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Jsfx/fallHOJRoEFYjX7BDKTtuakH/46HvCl6HlgiDIwz+1w3HH12cxX8zRYvkZZf jxzVeqHx2MVBGGA4DxcZO1+8Otttm9mgxHPCd0izdGqo1UKUJT+2os47wNwmoB/+d6 pyNQt2yKpEm+osBqcnXQ5ZkVvPE0Qul2hiHLQ+ls= Received: from epsnrtp04.localdomain (unknown [182.195.42.156]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPS id 20250708104059epcas5p41d1793c5aeb434f28b17499ea46e9013~QQJP0qpLH1625116251epcas5p4r; Tue, 8 Jul 2025 10:40:59 +0000 (GMT) Received: from epcas5p1.samsung.com (unknown [182.195.38.175]) by epsnrtp04.localdomain (Postfix) with ESMTP id 4bbyLx19t7z6B9m6; Tue, 8 Jul 2025 10:40:57 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p1.samsung.com (KnoxPortal) with ESMTPA id 20250708103237epcas5p1c4c5d7a5f43c0c88317e74d2f2458a1b~QQB8hGhe-2145121451epcas5p1G; Tue, 8 Jul 2025 10:32:37 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103234epsmtip1fd36b1a6f6019b1ba42e343ae39083bc~QQB54pvRQ1977519775epsmtip16; Tue, 8 Jul 2025 10:32:34 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 3/6] dt-bindings: perf: Add devicetree binding for custom PPMU Date: Tue, 8 Jul 2025 16:02:05 +0530 Message-ID: <20250708103208.79444-4-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103237epcas5p1c4c5d7a5f43c0c88317e74d2f2458a1b X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103237epcas5p1c4c5d7a5f43c0c88317e74d2f2458a1b References: <20250708103208.79444-1-vivek.2311@samsung.com> Add the dt-binding documentation for the Samsung specific Platform Performance Monitoring Unit (PPMU) driver which provides performance statistics for AXI bus masters such as MFC. Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- .../bindings/perf/samsung,ppmu-v2.yaml | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Documentation/devicetree/bindings/perf/samsung,ppmu-v2.= yaml diff --git a/Documentation/devicetree/bindings/perf/samsung,ppmu-v2.yaml b/= Documentation/devicetree/bindings/perf/samsung,ppmu-v2.yaml new file mode 100644 index 000000000000..d137d06b7034 --- /dev/null +++ b/Documentation/devicetree/bindings/perf/samsung,ppmu-v2.yaml @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/perf/samsung,ppmu-v2.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Samsung PPMU (Platform Performance Monitoring Unit) + +maintainers: + - Vivek Yadav + - Ravi Patel + +description: + PPMU (Platform Performance Monitoring Unit) provides performance statist= ics + such as bandwidth, read and write request, transactions count for AXI ma= sters + like MFC. + +properties: + compatible: + const: samsung,ppmu-v2 + + reg: + maxItems: 1 + description: Memory-mapped register address + + clocks: + items: + - description: AXI bus clock + - description: Peripheral clock + + clock-names: + items: + - const: aclk + - const: pclk + + interrupts: + items: + - description: Overflow interrupt for Counters + - description: Conditional Interrupt Generation (CIG) + +required: + - compatible + - reg + - clocks + - clock-names + - interrupts + +additionalProperties: false + +examples: + - | + #include + #include + ppmu@12840000 { + compatible =3D "samsung,ppmu-v2"; + reg =3D <0x12840000 0x1000>; + interrupts =3D , + ; + clocks =3D <&clock_mfc MFC_PPMU_MFCD0_IPCLKPORT_ACLK>, + <&clock_mfc MFC_PPMU_MFCD0_IPCLKPORT_PCLK>; + clock-names =3D "aclk", "pclk"; + }; --=20 2.49.0 From nobody Tue Oct 7 16:36:36 2025 Received: from mailout2.samsung.com (mailout2.samsung.com [203.254.224.25]) (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 CB4E22D94BA for ; Tue, 8 Jul 2025 10:41:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.25 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971267; cv=none; b=CGiUSUq4NOl4XxXL+vi6dkD7h3DyPAgexdEXq798NgaFdSNRyOX0/WRFkadjG3sEcmUA00KdlWmqOyhkSzceidvyzd5pbMfvc4GfkkOEOZYYKHWD8PNRmEFNFrQPuzYpyuquQ/0r6xfZIOxXnXkgxpalXWgY2nwpl9slSPCEswE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971267; c=relaxed/simple; bh=hN2KM2LroQvebBOfXHVOMTXH6tYWJl+jeYKPSC9RtLg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=jsAW3tAEWZ70YA87ZyMu/7AGF/BbIdWbyAmzLfhHHcGGpH0w4Q+uKAdIcIVK+1b/BA0A0KsWOJ2ZkxZeTlURM8rtFekMCw+uYnQzcMeKRrcWBr2z7kQq3eKjXuwNYSi7NmJMqvXYF5dcBaWUzEZIdU63MVzzhmvfVtKC5M0dvc4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=apuQPWmW; arc=none smtp.client-ip=203.254.224.25 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="apuQPWmW" Received: from epcas5p2.samsung.com (unknown [182.195.41.40]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20250708104102epoutp02154362dc5c49ef4cb2d29ace2f5c9785~QQJTSawad0104501045epoutp02l for ; Tue, 8 Jul 2025 10:41:02 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20250708104102epoutp02154362dc5c49ef4cb2d29ace2f5c9785~QQJTSawad0104501045epoutp02l DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971263; bh=wcn3ekiEBh3bQUPBYv93o0+HsETSNyswVRcekmOQry4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=apuQPWmW0bOj5O8TtWxlUeoYOmxX7AXD7AkcW1EccApUAWC0r8TU8mFJ+I3AEJF9r W1HkFsa3IBUM7goY73bmWYeUmO+6ohxhu7v4oPrT0E/fz2i7HBBEyE6z0sOGwrrDq1 vFyEBtz3LPSlYwCupjs9wVbqdQ1Sa11/PHwn6kw4= Received: from epsnrtp01.localdomain (unknown [182.195.42.153]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPS id 20250708104102epcas5p4c664b37db1e8127b70f8bc5cf5da7b4a~QQJScy5qv1624516245epcas5p4N; Tue, 8 Jul 2025 10:41:02 +0000 (GMT) Received: from epcas5p1.samsung.com (unknown [182.195.38.175]) by epsnrtp01.localdomain (Postfix) with ESMTP id 4bbyM04V5Fz6B9m6; Tue, 8 Jul 2025 10:41:00 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p3.samsung.com (KnoxPortal) with ESMTPA id 20250708103240epcas5p336539d4c3a1fb489708c61f9aae6bfa8~QQB-XgtaL1991119911epcas5p3B; Tue, 8 Jul 2025 10:32:40 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103237epsmtip1b822d2d396b2fc397bf990c9e1ae1d20~QQB8wDtVG2131121311epsmtip1n; Tue, 8 Jul 2025 10:32:37 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 4/6] drivers: perf: samsung: Add PPMU driver support Date: Tue, 8 Jul 2025 16:02:06 +0530 Message-ID: <20250708103208.79444-5-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103240epcas5p336539d4c3a1fb489708c61f9aae6bfa8 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103240epcas5p336539d4c3a1fb489708c61f9aae6bfa8 References: <20250708103208.79444-1-vivek.2311@samsung.com> Add Samsung PPMU driver support in the Linux perf subsystem. PPMU24 driver configures the PPMU24 hardware which is found in the Samsung SoCs like Tesla FSD. Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- drivers/perf/Kconfig | 2 + drivers/perf/Makefile | 1 + drivers/perf/samsung/Kconfig | 13 + drivers/perf/samsung/Makefile | 2 + drivers/perf/samsung/ppmu.c | 494 +++++++++++++++++++++++++++ drivers/perf/samsung/ppmu_platform.c | 338 ++++++++++++++++++ drivers/perf/samsung/samsung_ppmu.h | 128 +++++++ 7 files changed, 978 insertions(+) create mode 100644 drivers/perf/samsung/Kconfig create mode 100644 drivers/perf/samsung/Makefile create mode 100644 drivers/perf/samsung/ppmu.c create mode 100644 drivers/perf/samsung/ppmu_platform.c create mode 100644 drivers/perf/samsung/samsung_ppmu.h diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig index 4e268de351c4..0852bcae6cd2 100644 --- a/drivers/perf/Kconfig +++ b/drivers/perf/Kconfig @@ -271,6 +271,8 @@ source "drivers/perf/arm_cspmu/Kconfig" =20 source "drivers/perf/amlogic/Kconfig" =20 +source "drivers/perf/samsung/Kconfig" + config CXL_PMU tristate "CXL Performance Monitoring Unit" depends on CXL_BUS diff --git a/drivers/perf/Makefile b/drivers/perf/Makefile index de71d2574857..5f764d9fc601 100644 --- a/drivers/perf/Makefile +++ b/drivers/perf/Makefile @@ -33,3 +33,4 @@ obj-$(CONFIG_DWC_PCIE_PMU) +=3D dwc_pcie_pmu.o obj-$(CONFIG_ARM_CORESIGHT_PMU_ARCH_SYSTEM_PMU) +=3D arm_cspmu/ obj-$(CONFIG_MESON_DDR_PMU) +=3D amlogic/ obj-$(CONFIG_CXL_PMU) +=3D cxl_pmu.o +obj-$(CONFIG_SAMSUNG_PPMU24) +=3D samsung/ diff --git a/drivers/perf/samsung/Kconfig b/drivers/perf/samsung/Kconfig new file mode 100644 index 000000000000..2088e2b7299d --- /dev/null +++ b/drivers/perf/samsung/Kconfig @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# Programmable Performance Monitoring Unit (PPMU) driver +# + +config SAMSUNG_PPMU24 + tristate "Samsung PPMU24 drivers" + depends on ARM64 && ARCH_EXYNOS + help + The Platform Performance Measuring Unit (PPMU) is an AMBA-compliant + performance measurement tool designed to provide observability into + system-level operations. It provides performance statistics such as + as bandwidth, read and write request, transactions count for AXI masters. diff --git a/drivers/perf/samsung/Makefile b/drivers/perf/samsung/Makefile new file mode 100644 index 000000000000..c9ed1e1a986e --- /dev/null +++ b/drivers/perf/samsung/Makefile @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_SAMSUNG_PPMU24) +=3D ppmu_platform.o ppmu.o diff --git a/drivers/perf/samsung/ppmu.c b/drivers/perf/samsung/ppmu.c new file mode 100644 index 000000000000..cacb9cdec79f --- /dev/null +++ b/drivers/perf/samsung/ppmu.c @@ -0,0 +1,494 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Samsung Platform Performance Measuring Unit (PPMU) driver + * + * Copyright (c) 2024-25 Samsung Electronics Co., Ltd. + * + * Authors: Vivek Yadav + * Ravi Patel + */ + +#include +#include +#include +#include +#include "samsung_ppmu.h" + +#define PPMU_CLEAR_FLAG (GENMASK(3, 0) | BIT(31)) + +#define PPMU_PMCNT3_HIGH_VAL (3) +#define PPMU_PMCNT2_HIGH_VAL (2) +#define PPMU_RESET_CCNT BIT(2) +#define PPMU_RESET_PMCNT BIT(1) + +#define PPMU_PMNC_OP_MODE_MASK (GENMASK(21, 20)) +#define PPMU_PMNC_OP_MODE_OFF (20) +#define PPMU_MANUAL_MODE_VAL (0x0) +#define PPMU_PMNC_GLB_CNT_EN_VAL (BIT(0)) +#define PPMU_PMNC_RESET_PMCNT_VAL (BIT(1)) +#define PPMU_PMNC_RESET_CCNT_VAL (BIT(2)) + +#define PPMU_V24_IDENTIFIER (0x45) + +#define PPMU_CCNT_IDX (4) +#define PPMU_CCNT_POS_OFF (31) +#define PPMU_VERSION_CHECK (GENMASK(19, 12)) + +#define PPMU_SM_ENABLE_ALL_CNT (0xf) +#define PPMU_ENABLE_CCNT BIT(31) +#define PPMU_FILTER_MASK (0x7) + +/* ID of event type */ +enum { + PPMU_EVENT_READ_CHANNEL_ACTIVE =3D (0x00), + PPMU_EVENT_WRITE_CHANNEL_ACTIVE =3D (0x01), + PPMU_EVENT_READ_REQUEST =3D (0x02), + PPMU_EVENT_WRITE_REQUEST =3D (0x03), + PPMU_EVENT_READ_DATA =3D (0x04), + PPMU_EVENT_WRITE_DATA =3D (0x05), + PPMU_EVENT_WRITE_RESPONSE =3D (0x06), + PPMU_EVENT_LAST_READ_DATA =3D (0x07), + PPMU_EVENT_LAST_WRITE_DATA =3D (0x08), + PPMU_EVENT_READ_REQUEST_BOLCKING =3D (0x10), + PPMU_EVENT_WRITE_REQUEST_BOLCKING =3D (0x11), + PPMU_EVENT_READ_DATA_BLOCKING =3D (0x12), + PPMU_EVENT_WRITE_DATA_BLOCKING =3D (0x13), + PPMU_EVENT_WRITE_RESPONSE_BLOCKING =3D (0x14), + PPMU_EVENT_READ_BURST_LENGTH =3D (0x2a), + PPMU_EVENT_WRITE_BURST_LENGTH =3D (0x2b), + PPMU_EVENT_CCNT =3D (0xfe), + PPMU_EVENT_MAX =3D (0xff), +}; + +/* Register offsets */ +enum ppmu_reg { + PPMU_VERSION =3D (0x0000), + PPMU_PMNC =3D (0x0004), + PPMU_CNTENS =3D (0x0008), + PPMU_CNTENC =3D (0x000c), + PPMU_INTENS =3D (0x0010), + PPMU_INTENC =3D (0x0014), + PPMU_FLAG =3D (0x0018), + PPMU_CIG_CFG0 =3D (0x001c), + PPMU_CIG_CFG1 =3D (0x0020), + PPMU_CIG_CFG2 =3D (0x0024), + PPMU_CIG_RESULT =3D (0x0028), + PPMU_CNT_RESET =3D (0x002c), + PPMU_CNT_AUTO =3D (0x0030), + PPMU_PMCNT0 =3D (0x0034), + PPMU_PMCNT1 =3D (0x0038), + PPMU_PMCNT2 =3D (0x003c), + PPMU_PMCNT3_LOW =3D (0x0040), + PPMU_PMCNT3_HIGH =3D (0x0044), + PPMU_CCNT =3D (0x0048), + PPMU_PMCNT2_HIGH =3D (0x0054), + PPMU_CONFIG_INFO =3D (0X005c), + PPMU_INTERRUPT_TEST =3D (0x0060), + PPMU_EVENT_EV0_TYPE =3D (0x0200), + PPMU_EVENT_EV1_TYPE =3D (0x0204), + PPMU_EVENT_EV2_TYPE =3D (0x0208), + PPMU_EVENT_EV3_TYPE =3D (0x020c), + PPMU_EVENT_SM_ID_MASK =3D (0x0220), + PPMU_EVENT_SM_ID_VALUE =3D (0x0224), + PPMU_EVENT_SM_ID_A =3D (0x0228), + PPMU_EVENT_SM_OTHERS_V =3D (0x022c), + PPMU_EVENT_SM_OTHERS_A =3D (0x0230), + PPMU_EVENT_SAMPLE_RD_ID_MASK =3D (0x0234), + PPMU_EVENT_SAMPLE_RD_ID_VALUE =3D (0x0238), + PPMU_EVENT_SAMPLE_WR_ID_MASK =3D (0x023c), + PPMU_EVENT_SAMPLE_WD_ID_VALUE =3D (0x0240), + PPMU_EVENT_AXI_CH_TYPE =3D (0x0244), + PPMU_EVENT_MO_INFO =3D (0x0250), + PPMU_EVENT_MO_INFO_SM_ID =3D (0x0254), + PPMU_EVENT_MO_INFO_SAMPLE =3D (0x0258), + PPMU_EVENT_IMPRECISE_ERR =3D (0x0260), +}; + +static const u32 ppmu_pmcnt_offset[PPMU_MAX_COUNTERS][2] =3D { + { PPMU_PMCNT0, PPMU_EVENT_EV0_TYPE }, + { PPMU_PMCNT1, PPMU_EVENT_EV1_TYPE }, + { PPMU_PMCNT2, PPMU_EVENT_EV2_TYPE }, + { PPMU_PMCNT3_LOW, PPMU_EVENT_EV3_TYPE }, + { PPMU_CCNT, 0 }, +}; + +static DEFINE_IDR(my_idr); + +static void samsung_ppmu_write_evtype(struct samsung_ppmu *s_ppmu, + int idx, u32 type) +{ + /* Configure event */ + if (idx !=3D PPMU_CCNT_IDX) + writel(type, s_ppmu->base + ppmu_pmcnt_offset[idx][1]); +} + +static int samsung_ppmu_get_event_idx(struct perf_event *event) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + unsigned long *used_mask =3D samsung_ppmu->pmu_events.used_mask; + u32 num_counters =3D samsung_ppmu->num_counters; + DECLARE_BITMAP(buf, PPMU_MAX_COUNTERS); + int idx; + + if (event->attr.config =3D=3D PPMU_EVENT_CCNT) + *buf =3D *used_mask | (~BIT(PPMU_CCNT_IDX)); + else + *buf =3D *used_mask; + + idx =3D find_first_zero_bit(buf, num_counters); + if (idx =3D=3D num_counters) + return -EAGAIN; + + set_bit(idx, used_mask); + + return idx; +} + +static u64 samsung_ppmu_get_read_counter(struct samsung_ppmu *s_ppmu, + struct hw_perf_event *hwc) +{ + u64 counter_val, prev_overflow_val; + u64 high_val =3D 0; + + counter_val =3D (u64)readl(s_ppmu->base + ppmu_pmcnt_offset[hwc->idx][0]); + prev_overflow_val =3D (u64)s_ppmu->counter_overflow[hwc->idx] << 32; + + /* + * PMCNT2 and PMCNT3 are 40-bit counters + * its value are divided in two 32-bit registers + */ + if (hwc->idx =3D=3D PPMU_PMCNT3_HIGH_VAL || hwc->idx =3D=3D PPMU_PMCNT2_H= IGH_VAL) { + prev_overflow_val =3D prev_overflow_val << 8; + + if (hwc->idx =3D=3D PPMU_PMCNT3_HIGH_VAL) + high_val =3D (u64)(readl(s_ppmu->base + PPMU_PMCNT3_HIGH) & 0xFF); + else + high_val =3D (u64)(readl(s_ppmu->base + PPMU_PMCNT2_HIGH) & 0xFF); + } + + counter_val =3D counter_val + (high_val << 32); + + /* Clear overflow status */ + s_ppmu->counter_overflow[hwc->idx] =3D 0; + + /* Read previous counter */ + s_ppmu->prev_counter[hwc->idx] =3D counter_val; + + return (counter_val | prev_overflow_val); +} + +static void samsung_ppmu_get_enable_counter(struct samsung_ppmu *s_ppmu, + struct hw_perf_event *hwc) +{ + u32 val; + int idx =3D hwc->idx; + + if (idx =3D=3D PPMU_CCNT_IDX) + idx =3D PPMU_CCNT_POS_OFF; + + /* Enabling counters */ + writel(BIT(idx), s_ppmu->base + PPMU_CNTENS); + + /* Enabling interrupt */ + writel(BIT(idx), s_ppmu->base + PPMU_INTENS); + + /* Manual mode enabled */ + val =3D readl(s_ppmu->base + PPMU_PMNC); + val &=3D (~PPMU_PMNC_OP_MODE_MASK); + val |=3D (PPMU_MANUAL_MODE_VAL << PPMU_PMNC_OP_MODE_OFF); + writel(val, s_ppmu->base + PPMU_PMNC); +} + +static void samsung_ppmu_get_disable_counter(struct samsung_ppmu *s_ppmu, + struct hw_perf_event *hwc) +{ + int idx =3D hwc->idx; + + if (idx =3D=3D PPMU_CCNT_IDX) + idx =3D PPMU_CCNT_POS_OFF; + + /* Disabling interrupt */ + writel(BIT(idx), s_ppmu->base + PPMU_INTENC); + + /* Disabling counter */ + writel(BIT(idx), s_ppmu->base + PPMU_CNTENC); + + /* Reset counter */ + writel(BIT(idx), s_ppmu->base + PPMU_CNT_RESET); +} + +static void samsung_ppmu_get_start_counters(struct samsung_ppmu *s_ppmu) +{ + u32 val; + + /* Clearing all overflow status */ + writel(PPMU_CLEAR_FLAG, s_ppmu->base + PPMU_FLAG); + + /* Resetting all counters */ + val =3D readl(s_ppmu->base + PPMU_PMNC); + val |=3D (PPMU_PMNC_RESET_PMCNT_VAL | PPMU_PMNC_RESET_CCNT_VAL); + writel(val, s_ppmu->base + PPMU_PMNC); + + /* Start counters */ + val =3D readl(s_ppmu->base + PPMU_PMNC); + val |=3D PPMU_PMNC_GLB_CNT_EN_VAL; + writel(val, s_ppmu->base + PPMU_PMNC); + + s_ppmu->status =3D PPMU_START; +} + +static void samsung_ppmu_get_stop_counters(struct samsung_ppmu *s_ppmu) +{ + u32 val; + + /* Stop counters */ + val =3D readl(s_ppmu->base + PPMU_PMNC); + val &=3D (~PPMU_PMNC_GLB_CNT_EN_VAL); + writel(val, s_ppmu->base + PPMU_PMNC); + + s_ppmu->status =3D PPMU_STOP; +} + +static u32 samsung_ppmu_get_int_status(struct samsung_ppmu *s_ppmu) +{ + u32 regvalue, i; + + /* Read status register */ + regvalue =3D readl(s_ppmu->base + PPMU_FLAG); + + for (i =3D 0; i < PPMU_MAX_COUNTERS; i++) { + if (regvalue & BIT(i)) + s_ppmu->counter_overflow[i] +=3D 1; + } + + if (regvalue & BIT(PPMU_CCNT_POS_OFF)) { + s_ppmu->counter_overflow[PPMU_CCNT_IDX] +=3D 1; + regvalue &=3D (~BIT(PPMU_CCNT_POS_OFF)); + regvalue |=3D BIT(PPMU_CCNT_IDX); + } + + return regvalue; +} + +static void samsung_ppmu_clear_int_status(struct samsung_ppmu *s_ppmu, int= idx) +{ + if (idx =3D=3D PPMU_CCNT_IDX) + idx =3D PPMU_CCNT_POS_OFF; + + /* Clear the interrupt status */ + writel(BIT(idx), s_ppmu->base + PPMU_FLAG); +} + +static struct attribute *samsung_ppmu_format_attr[] =3D { + SAMSUNG_PPMU_FORMAT_ATTR(event, "config:0-7"), + NULL +}; + +static const struct attribute_group samsung_ppmu_format_group =3D { + .name =3D "format", + .attrs =3D samsung_ppmu_format_attr, +}; + +static struct attribute *samsung_ppmu_events_attr[] =3D { + SAMSUNG_PPMU_EVENT_ATTR(rd_channel_active, PPMU_EVENT_READ_CHANNEL_ACTIVE= ), + SAMSUNG_PPMU_EVENT_ATTR(wr_channel_active, PPMU_EVENT_WRITE_CHANNEL_ACTIV= E), + SAMSUNG_PPMU_EVENT_ATTR(read_request, PPMU_EVENT_READ_REQUEST), + SAMSUNG_PPMU_EVENT_ATTR(write_request, PPMU_EVENT_WRITE_REQUEST), + SAMSUNG_PPMU_EVENT_ATTR(read_data, PPMU_EVENT_READ_DATA), + SAMSUNG_PPMU_EVENT_ATTR(write_data, PPMU_EVENT_WRITE_DATA), + SAMSUNG_PPMU_EVENT_ATTR(wr_response, PPMU_EVENT_WRITE_RESPONSE), + SAMSUNG_PPMU_EVENT_ATTR(last_rd_data, PPMU_EVENT_LAST_READ_DATA), + SAMSUNG_PPMU_EVENT_ATTR(last_wr_data, PPMU_EVENT_LAST_WRITE_DATA), + SAMSUNG_PPMU_EVENT_ATTR(rd_request_blk, PPMU_EVENT_READ_REQUEST_BOLCKING= ), + SAMSUNG_PPMU_EVENT_ATTR(wr_request_blk, PPMU_EVENT_WRITE_REQUEST_BOLCKIN= G), + SAMSUNG_PPMU_EVENT_ATTR(rd_data_blk, PPMU_EVENT_READ_DATA_BLOCKING), + SAMSUNG_PPMU_EVENT_ATTR(wr_data_blk, PPMU_EVENT_WRITE_DATA_BLOCKING), + SAMSUNG_PPMU_EVENT_ATTR(wr_response_blk, PPMU_EVENT_WRITE_RESPONSE_BLOCKI= NG), + SAMSUNG_PPMU_EVENT_ATTR(rd_burst_length, PPMU_EVENT_READ_BURST_LENGTH), + SAMSUNG_PPMU_EVENT_ATTR(wr_burst_length, PPMU_EVENT_WRITE_BURST_LENGTH), + SAMSUNG_PPMU_EVENT_ATTR(ccnt, PPMU_EVENT_CCNT), + NULL +}; + +static const struct attribute_group samsung_ppmu_events_group =3D { + .name =3D "events", + .attrs =3D samsung_ppmu_events_attr, +}; + +struct device_attribute dev_attr_cpumask =3D + __ATTR(cpumask, 0444, samsung_ppmu_cpumask_sysfs_show, NULL); + +static struct attribute *samsung_ppmu_cpumask_attrs[] =3D { + &dev_attr_cpumask.attr, + NULL, +}; + +static const struct attribute_group samsung_ppmu_cpumask_attr_group =3D { + .attrs =3D samsung_ppmu_cpumask_attrs, +}; + +static struct device_attribute samsung_ppmu_identifier_attr =3D + __ATTR(identifier, 0444, samsung_ppmu_identifier_attr_show, NULL); + +static struct attribute *samsung_ppmu_identifier_attrs[] =3D { + &samsung_ppmu_identifier_attr.attr, + NULL +}; + +static const struct attribute_group samsung_ppmu_identifier_group =3D { + .attrs =3D samsung_ppmu_identifier_attrs, +}; + +static const struct attribute_group *samsung_ppmu_v24_attr_groups[] =3D { + &samsung_ppmu_format_group, + &samsung_ppmu_events_group, + &samsung_ppmu_cpumask_attr_group, + &samsung_ppmu_identifier_group, + NULL +}; + +static struct samsung_ppmu_drv_data samsung_ppmu_v24_data =3D { + .ppmu_attr_group =3D samsung_ppmu_v24_attr_groups +}; + +static const struct samsung_ppmu_ops samsung_ppmu_plat_ops =3D { + .write_evtype =3D samsung_ppmu_write_evtype, + .get_event_idx =3D samsung_ppmu_get_event_idx, + .read_counter =3D samsung_ppmu_get_read_counter, + .enable_counter =3D samsung_ppmu_get_enable_counter, + .disable_counter =3D samsung_ppmu_get_disable_counter, + .start_counters =3D samsung_ppmu_get_start_counters, + .stop_counters =3D samsung_ppmu_get_stop_counters, + .get_int_status =3D samsung_ppmu_get_int_status, + .clear_int_status =3D samsung_ppmu_clear_int_status, +}; + +static int ppmu_clock_init(struct samsung_ppmu *s_ppmu) +{ + int ret =3D 0; + struct device *dev =3D s_ppmu->dev; + + s_ppmu->clks[PPMU_ACLK].id =3D "aclk"; + s_ppmu->clks[PPMU_PCLK].id =3D "pclk"; + + ret =3D devm_clk_bulk_get(dev, PPMU_CLK_COUNT, s_ppmu->clks); + if (ret) { + dev_err(dev, "Failed to get clocks. Err %d\n", ret); + return ret; + } + + ret =3D clk_bulk_prepare_enable(PPMU_CLK_COUNT, s_ppmu->clks); + if (ret) + dev_err(dev, "Clock enable failed. Err %d\n", ret); + + return ret; +} + +static int samsung_ppmu_probe(struct platform_device *pdev) +{ + struct samsung_ppmu *s_ppmu; + struct device *dev =3D &pdev->dev; + u32 version; + char *name; + int ret; + + s_ppmu =3D devm_kzalloc(dev, sizeof(*s_ppmu), GFP_KERNEL); + if (!s_ppmu) + return -ENOMEM; + + s_ppmu->dev =3D &pdev->dev; + + s_ppmu->id =3D idr_alloc(&my_idr, dev, 0, 2, GFP_KERNEL); + if (s_ppmu->id < 0) { + dev_err(dev, "Failed to allocate ID dynamically\n"); + return s_ppmu->id; + } + + /* Register base address */ + s_ppmu->base =3D devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(s_ppmu->base)) { + dev_err(dev, "IO remap failed\n"); + return PTR_ERR(s_ppmu->base); + } + + /* Register IRQ */ + ret =3D samsung_ppmu_init_irq(s_ppmu, pdev); + if (ret) + return ret; + + s_ppmu->check_event =3D PPMU_EVENT_MAX; + s_ppmu->num_counters =3D PPMU_MAX_COUNTERS; + s_ppmu->on_cpu =3D 0; + s_ppmu->identifier =3D PPMU_V24_IDENTIFIER; + + s_ppmu->ppmu_data =3D device_get_match_data(&pdev->dev); + if (!s_ppmu->ppmu_data) { + dev_err(&pdev->dev, "No matching device data found\n"); + return -ENODEV; + } + + /* Register PPMU driver ops */ + s_ppmu->pmu_events.attr_groups =3D s_ppmu->ppmu_data->ppmu_attr_group; + s_ppmu->ops =3D &samsung_ppmu_plat_ops; + + /* Set private data to platform_device structure */ + platform_set_drvdata(pdev, s_ppmu); + + /* Initialize the PPMU */ + samsung_ppmu_init(s_ppmu, THIS_MODULE); + + ret =3D ppmu_clock_init(s_ppmu); + if (ret) + return ret; + + version =3D readl(s_ppmu->base + PPMU_VERSION); + version &=3D PPMU_VERSION_CHECK; + version >>=3D 12; + s_ppmu->samsung_ppmu_version =3D version; + + name =3D devm_kasprintf(&pdev->dev, GFP_KERNEL, "ppmu_v_%x_%d", version, = s_ppmu->id); + if (!name) + return -ENOMEM; + + ret =3D perf_pmu_register(&s_ppmu->pmu, name, -1); + if (ret) { + clk_bulk_disable_unprepare(PPMU_CLK_COUNT, s_ppmu->clks); + dev_err(dev, "Failed to register PPMU in perf. Err %d\n", ret); + } + + return ret; +} + +static void samsung_ppmu_remove(struct platform_device *pdev) +{ + struct samsung_ppmu *s_ppmu =3D platform_get_drvdata(pdev); + + clk_bulk_disable_unprepare(PPMU_CLK_COUNT, s_ppmu->clks); + + perf_pmu_unregister(&s_ppmu->pmu); + + idr_remove(&my_idr, s_ppmu->id); +} + +static const struct of_device_id ppmu_of_match[] =3D { + { .compatible =3D "samsung,ppmu-v2", .data =3D &samsung_ppmu_v24_data }, + {} +}; +MODULE_DEVICE_TABLE(of, ppmu_of_match); + +static struct platform_driver samsung_ppmu_driver =3D { + .probe =3D samsung_ppmu_probe, + .remove =3D samsung_ppmu_remove, + .driver =3D { + .name =3D "samsung-ppmu", + .of_match_table =3D ppmu_of_match, + }, +}; + +module_platform_driver(samsung_ppmu_driver); + +MODULE_ALIAS("perf:samsung-ppmu"); +MODULE_DESCRIPTION("Samsung Platform Performance Measuring Unit (PPMU) dri= ver"); +MODULE_AUTHOR("Vivek Yadav "); +MODULE_AUTHOR("Ravi Patel "); +MODULE_LICENSE("GPL"); diff --git a/drivers/perf/samsung/ppmu_platform.c b/drivers/perf/samsung/pp= mu_platform.c new file mode 100644 index 000000000000..ee11311d5a61 --- /dev/null +++ b/drivers/perf/samsung/ppmu_platform.c @@ -0,0 +1,338 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Samsung Platform Performance Measuring Unit (PPMU) core file + * + * Copyright (c) 2024-25 Samsung Electronics Co., Ltd. + * + * Authors: Vivek Yadav + * Ravi Patel + */ + +#include +#include +#include +#include "samsung_ppmu.h" + +/* + * PMU format attributes + */ +ssize_t samsung_ppmu_format_sysfs_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct dev_ext_attribute *eattr; + + eattr =3D container_of(attr, struct dev_ext_attribute, attr); + + return sysfs_emit(buf, "%s\n", (char *)eattr->var); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_format_sysfs_show); + +/* + * PMU event attributes + */ +ssize_t samsung_ppmu_event_sysfs_show(struct device *dev, + struct device_attribute *attr, char *page) +{ + struct dev_ext_attribute *eattr; + + eattr =3D container_of(attr, struct dev_ext_attribute, attr); + + return sysfs_emit(page, "config=3D0x%lx\n", (unsigned long)eattr->var); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_event_sysfs_show); + +/* + * sysfs cpumask attributes. For PPMU, we only have a single CPU to show + */ +ssize_t samsung_ppmu_cpumask_sysfs_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(dev_get_drvdata(dev= )); + + return sysfs_emit(buf, "%d\n", samsung_ppmu->on_cpu); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_cpumask_sysfs_show); + +ssize_t samsung_ppmu_identifier_attr_show(struct device *dev, + struct device_attribute *attr, + char *page) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(dev_get_drvdata(dev= )); + + return sysfs_emit(page, "0x%08x\n", samsung_ppmu->identifier); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_identifier_attr_show); + +static irqreturn_t samsung_ppmu_isr(int irq, void *data) +{ + struct samsung_ppmu *samsung_ppmu =3D data; + unsigned long overflown; + int idx; + + overflown =3D samsung_ppmu->ops->get_int_status(samsung_ppmu); + if (!overflown) + return IRQ_NONE; + + /* + * Find the counter index which overflowed if the bit was set + * and handle it. + */ + for_each_set_bit(idx, &overflown, samsung_ppmu->num_counters) + samsung_ppmu->ops->clear_int_status(samsung_ppmu, idx); + + return IRQ_HANDLED; +} + +int samsung_ppmu_init_irq(struct samsung_ppmu *samsung_ppmu, + struct platform_device *pdev) +{ + int irq0, irq1, ret, irq_count; + + irq0 =3D platform_get_irq(pdev, 0); + if (irq0 < 0) { + dev_err(&pdev->dev, "Failed to get IRQ 0\n"); + return irq0; + } + + ret =3D devm_request_irq(&pdev->dev, irq0, samsung_ppmu_isr, + IRQF_NOBALANCING | IRQF_NO_THREAD | IRQF_SHARED, + dev_name(&pdev->dev), samsung_ppmu); + if (ret) { + dev_err(&pdev->dev, + "Fail to request IRQ: %d ret: %d.\n", irq0, ret); + return ret; + } + + samsung_ppmu->irq0 =3D irq0; + + irq_count =3D of_property_count_elems_of_size(pdev->dev.of_node, "interru= pts", sizeof(u32)); + if (irq_count > 1) { + irq1 =3D platform_get_irq(pdev, 1); + if (irq1 < 0) { + dev_err(&pdev->dev, "Failed to get IRQ 0\n"); + return irq1; + } + + ret =3D devm_request_irq(&pdev->dev, irq1, samsung_ppmu_isr, + IRQF_NOBALANCING | IRQF_NO_THREAD | IRQF_SHARED, + dev_name(&pdev->dev), samsung_ppmu); + if (ret) { + dev_err(&pdev->dev, + "Fail to request IRQ: %d ret: %d.\n", irq1, ret); + return ret; + } + samsung_ppmu->irq1 =3D irq1; + } + + return ret; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_init_irq); + +int samsung_ppmu_event_init(struct perf_event *event) +{ + struct hw_perf_event *hwc =3D &event->hw; + struct samsung_ppmu *samsung_ppmu; + + if (event->attr.type !=3D event->pmu->type) + return -ENOENT; + + /* + * We do not support sampling as the counters are all + * shared by all CPU cores in a CPU die. Also we + * do not support attach to a task(per-process mode) + */ + if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK) + return -EOPNOTSUPP; + + /* PPMU counters not specific to any CPU, so cannot support per-task */ + if (event->cpu < 0) + return -EINVAL; + + /* Check if events in group does not exceed the available counters */ + samsung_ppmu =3D to_samsung_ppmu(event->pmu); + if (event->attr.config > samsung_ppmu->check_event) + return -EINVAL; + + /* + * We don't assign an index until we actually place the event onto + * hardware. Use -1 to signify that we haven't decided where to put it + * yet. + */ + hwc->idx =3D -1; + hwc->config_base =3D event->attr.config; + + /* Enforce to use the same CPU for all events in this PMU */ + event->cpu =3D samsung_ppmu->on_cpu; + + return 0; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_event_init); + +/* + * Set the counter to count the event that we're interested in, + * and enable interrupt and counter. + */ +static void samsung_ppmu_enable_event(struct perf_event *event) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + struct hw_perf_event *hwc =3D &event->hw; + + samsung_ppmu->ops->write_evtype(samsung_ppmu, hwc->idx, + SAMSUNG_PPMU_GET_EVENTID(event)); + + samsung_ppmu->ops->enable_counter(samsung_ppmu, hwc); +} + +/* + * Disable counter and interrupt. + */ +static void samsung_ppmu_disable_event(struct perf_event *event) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + struct hw_perf_event *hwc =3D &event->hw; + + samsung_ppmu->ops->disable_counter(samsung_ppmu, hwc); +} + +void samsung_ppmu_event_update(struct perf_event *event) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + struct hw_perf_event *hwc =3D &event->hw; + u64 delta, prev_raw_count, new_raw_count; + + /* read previous counter value */ + prev_raw_count =3D samsung_ppmu->prev_counter[hwc->idx]; + + /* Read the count from the counter register */ + new_raw_count =3D samsung_ppmu->ops->read_counter(samsung_ppmu, hwc); + + /* compute the delta */ + delta =3D new_raw_count - prev_raw_count; + + local64_add(delta, &event->count); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_event_update); + +void samsung_ppmu_start(struct perf_event *event, int flags) +{ + struct hw_perf_event *hwc =3D &event->hw; + + if (WARN_ON_ONCE(!(hwc->state & PERF_HES_STOPPED))) + return; + + WARN_ON_ONCE(!(hwc->state & PERF_HES_UPTODATE)); + hwc->state =3D 0; + + samsung_ppmu_enable_event(event); + perf_event_update_userpage(event); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_start); + +void samsung_ppmu_stop(struct perf_event *event, int flags) +{ + struct hw_perf_event *hwc =3D &event->hw; + + samsung_ppmu_disable_event(event); + WARN_ON_ONCE(hwc->state & PERF_HES_STOPPED); + hwc->state |=3D PERF_HES_STOPPED; + + if (hwc->state & PERF_HES_UPTODATE) + return; + + /* Read hardware counter and update the perf counter statistics */ + samsung_ppmu_event_update(event); + hwc->state |=3D PERF_HES_UPTODATE; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_stop); + +int samsung_ppmu_add(struct perf_event *event, int flags) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + struct hw_perf_event *hwc =3D &event->hw; + int idx; + + hwc->state =3D PERF_HES_STOPPED | PERF_HES_UPTODATE; + + /* Get an available counter index for counting */ + idx =3D samsung_ppmu->ops->get_event_idx(event); + if (idx < 0) + return idx; + + event->hw.idx =3D idx; + samsung_ppmu->pmu_events.hw_events[idx] =3D event; + + if (flags & PERF_EF_START) + samsung_ppmu_start(event, PERF_EF_RELOAD); + + return 0; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_add); + +void samsung_ppmu_del(struct perf_event *event, int flags) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(event->pmu); + struct hw_perf_event *hwc =3D &event->hw; + + samsung_ppmu_stop(event, PERF_EF_UPDATE); + + samsung_ppmu->prev_counter[hwc->idx] =3D 0; + + /* Clear the event bit */ + clear_bit(hwc->idx, samsung_ppmu->pmu_events.used_mask); + perf_event_update_userpage(event); + samsung_ppmu->pmu_events.hw_events[hwc->idx] =3D NULL; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_del); + +void samsung_ppmu_read(struct perf_event *event) +{ + /* Read hardware counter and update the perf counter statistics */ + samsung_ppmu_event_update(event); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_read); + +void samsung_ppmu_enable(struct pmu *pmu) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(pmu); + bool enabled =3D !bitmap_empty(samsung_ppmu->pmu_events.used_mask, + samsung_ppmu->num_counters); + + if (!enabled) + return; + + samsung_ppmu->ops->start_counters(samsung_ppmu); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_enable); + +void samsung_ppmu_disable(struct pmu *pmu) +{ + struct samsung_ppmu *samsung_ppmu =3D to_samsung_ppmu(pmu); + + samsung_ppmu->ops->stop_counters(samsung_ppmu); +} +EXPORT_SYMBOL_GPL(samsung_ppmu_disable); + +void samsung_ppmu_init(struct samsung_ppmu *s_ppmu, struct module *module) +{ + struct pmu *pmu =3D &s_ppmu->pmu; + + pmu->module =3D module; + pmu->task_ctx_nr =3D perf_invalid_context; + pmu->event_init =3D samsung_ppmu_event_init; + pmu->pmu_enable =3D samsung_ppmu_enable; + pmu->pmu_disable =3D samsung_ppmu_disable; + pmu->add =3D samsung_ppmu_add; + pmu->del =3D samsung_ppmu_del; + pmu->start =3D samsung_ppmu_start; + pmu->stop =3D samsung_ppmu_stop; + pmu->read =3D samsung_ppmu_read; + pmu->attr_groups =3D s_ppmu->pmu_events.attr_groups; + pmu->capabilities =3D PERF_PMU_CAP_NO_EXCLUDE; +} +EXPORT_SYMBOL_GPL(samsung_ppmu_init); + +MODULE_ALIAS("perf:samsung-ppmu-core"); +MODULE_DESCRIPTION("Samsung Platform Performance Measuring Unit (PPMU) dri= ver"); +MODULE_AUTHOR("Vivek Yadav "); +MODULE_AUTHOR("Ravi Patel "); +MODULE_LICENSE("GPL"); diff --git a/drivers/perf/samsung/samsung_ppmu.h b/drivers/perf/samsung/sam= sung_ppmu.h new file mode 100644 index 000000000000..2cad75cfa97b --- /dev/null +++ b/drivers/perf/samsung/samsung_ppmu.h @@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Samsung Platform Performance Measuring Unit (PPMU) headers + * + * Copyright (c) 2024-25 Samsung Electronics Co., Ltd. + * + * Authors: Vivek Yadav + * Ravi Patel + */ + +#ifndef __SAMSUNG_PPMU_H__ +#define __SAMSUNG_PPMU_H__ + +#include + +#define PPMU_MAX_COUNTERS (5) + +#define to_samsung_ppmu(p) (container_of(p, struct samsung_ppmu, pmu)) + +#define SAMSUNG_PPMU_ATTR(_name, _func, _config) \ + (&((struct dev_ext_attribute[]) { \ + { __ATTR(_name, 0444, _func, NULL), (void *)_config } \ + })[0].attr.attr) + +#define SAMSUNG_PPMU_FORMAT_ATTR(_name, _config) \ + SAMSUNG_PPMU_ATTR(_name, samsung_ppmu_format_sysfs_show, (void *)_config) +#define SAMSUNG_PPMU_EVENT_ATTR(_name, _config) \ + SAMSUNG_PPMU_ATTR(_name, samsung_ppmu_event_sysfs_show, (unsigned long)_c= onfig) + +#define SAMSUNG_PPMU_GET_EVENTID(ev) ((ev)->hw.config_base & 0xff) + +enum ppmu_clock_type { + PPMU_ACLK, + PPMU_PCLK, + PPMU_CLK_COUNT, +}; + +enum ppmu_status { + PPMU_STOP, + PPMU_START, +}; + +struct samsung_ppmu; + +struct samsung_ppmu_ops { + void (*write_evtype)(struct samsung_ppmu *s_ppmu, int idx, u32 type); + int (*get_event_idx)(struct perf_event *event); + u64 (*read_counter)(struct samsung_ppmu *s_ppmu, struct hw_perf_event *ev= ent); + void (*enable_counter)(struct samsung_ppmu *s_ppmu, struct hw_perf_event = *event); + void (*disable_counter)(struct samsung_ppmu *s_ppmu, struct hw_perf_event= *event); + void (*start_counters)(struct samsung_ppmu *s_ppmu); + void (*stop_counters)(struct samsung_ppmu *s_ppmu); + u32 (*get_int_status)(struct samsung_ppmu *s_ppmu); + void (*clear_int_status)(struct samsung_ppmu *s_ppmu, int idx); +}; + +/* Describes the Samsung PPMU features information */ +struct samsung_ppmu_dev_info { + const char *name; + const struct attribute_group **attr_groups; + void *private; +}; + +struct samsung_ppmu_hwevents { + struct perf_event *hw_events[PPMU_MAX_COUNTERS]; + DECLARE_BITMAP(used_mask, PPMU_MAX_COUNTERS); + const struct attribute_group **attr_groups; +}; + +struct samsung_ppmu_drv_data { + const struct attribute_group **ppmu_attr_group; +}; + +/* Generic pmu struct for different pmu types */ +struct samsung_ppmu { + struct pmu pmu; + const struct samsung_ppmu_ops *ops; + const struct samsung_ppmu_dev_info *dev_info; + struct samsung_ppmu_hwevents pmu_events; + const struct samsung_ppmu_drv_data *ppmu_data; + u32 samsung_ppmu_version; + u32 samsung_ppmu_master_id_val; + u8 status; + u8 id; + /* CPU used for counting */ + int on_cpu; + int irq0; + int irq1; + struct device *dev; + struct hlist_node node; + void __iomem *base; + int num_counters; + u32 counter_overflow[PPMU_MAX_COUNTERS]; + u64 prev_counter[PPMU_MAX_COUNTERS]; + /* check event code range */ + int check_event; + u32 identifier; + struct clk_bulk_data clks[PPMU_CLK_COUNT]; +}; + +void samsung_ppmu_read(struct perf_event *event); +int samsung_ppmu_add(struct perf_event *event, int flags); +void samsung_ppmu_del(struct perf_event *event, int flags); +void samsung_ppmu_start(struct perf_event *event, int flags); +void samsung_ppmu_stop(struct perf_event *event, int flags); +void samsung_ppmu_set_event_period(struct perf_event *event); +void samsung_ppmu_event_update(struct perf_event *event); +int samsung_ppmu_event_init(struct perf_event *event); +void samsung_ppmu_enable(struct pmu *pmu); +void samsung_ppmu_disable(struct pmu *pmu); +ssize_t samsung_ppmu_event_sysfs_show(struct device *dev, + struct device_attribute *attr, char *buf); +ssize_t samsung_ppmu_format_sysfs_show(struct device *dev, + struct device_attribute *attr, char *buf); +ssize_t samsung_ppmu_cpumask_sysfs_show(struct device *dev, + struct device_attribute *attr, char *buf); +int samsung_ppmu_online_cpu(unsigned int cpu, struct hlist_node *node); +int samsung_ppmu_offline_cpu(unsigned int cpu, struct hlist_node *node); + +ssize_t samsung_ppmu_identifier_attr_show(struct device *dev, + struct device_attribute *attr, + char *page); +int samsung_ppmu_init_irq(struct samsung_ppmu *samsung_ppmu, + struct platform_device *pdev); + +void samsung_ppmu_init(struct samsung_ppmu *samsung_ppmu, struct module *m= odule); + +#endif /* __SAMSUNG_PPMU_H__ */ --=20 2.49.0 From nobody Tue Oct 7 16:36:36 2025 Received: from mailout2.samsung.com (mailout2.samsung.com [203.254.224.25]) (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 47A4A2D9489 for ; Tue, 8 Jul 2025 10:41:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.25 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971271; cv=none; b=kCvivQbnflGoSPyxJo2BiuGr53Hzj13o4H1lE7zUorbZp7eVjapo/glYgbS8vrGfOKvDLKFO3Kfs/+GG+U5tMZHJlRF9/TlNNJuMQG2WdT9TETUFeZ93ymjJ8+Mfjn/kl9PmfOMxDl/4PatKFAKCZClA+QksaHFFiKO2yrcsYBo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971271; c=relaxed/simple; bh=RFe77r1HbG6Q+MYMncVBBXCUapplAX1Lv3aK87B4hcM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=q6WW8D/43brz3F3FBXZ/gqCQ9u96FH7iuQ9a2Z1aPC4nsQiMvfc41mWV4U+k8lbgfuNzQdmrM2Wm1BvyWBpd25qEhpJtvEJAeCl+HZDVqoiPoRloPCcT0XNZFQxcaH94wASe13yIRoGDNtVEp40yQmfNrhhFotXHkZL++lvMVU8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=GLUU/57I; arc=none smtp.client-ip=203.254.224.25 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="GLUU/57I" Received: from epcas5p3.samsung.com (unknown [182.195.41.41]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20250708104107epoutp023a0d4751b81a79833919c0b6ebd44eed~QQJXptdcl0092700927epoutp02q for ; Tue, 8 Jul 2025 10:41:07 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20250708104107epoutp023a0d4751b81a79833919c0b6ebd44eed~QQJXptdcl0092700927epoutp02q DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971267; bh=yQQif8BnhaNVq6Q/a8Q3DYVnyJXRWSFrD2QEhPIZrBw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GLUU/57INvp0UdSWXgD8QlTtEdLD0TjLUPu8JbI9rizCHBq1n9I+dMkDfYpEgs/6F ed7kAc/QMOUaYKYpQfuDDq+Ht+fiERdfqceW3FsLmrTP2Im6g19MirmSEm6S6fhGKO y2gHSmvP0weVl2q9SCHbqnSJW8ua2TUTPxNTTHM4= Received: from epsnrtp01.localdomain (unknown [182.195.42.153]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPS id 20250708104106epcas5p4f80114851e1609d1f2f7ceb0c1fa7212~QQJWK9yyp3037230372epcas5p4b; Tue, 8 Jul 2025 10:41:06 +0000 (GMT) Received: from epcas5p4.samsung.com (unknown [182.195.38.182]) by epsnrtp01.localdomain (Postfix) with ESMTP id 4bbyM41ZZqz6B9m4; Tue, 8 Jul 2025 10:41:04 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPA id 20250708103243epcas5p2d8fd5bf02e64e104eca3def802813230~QQCCNA-B31542215422epcas5p2D; Tue, 8 Jul 2025 10:32:43 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103240epsmtip125db38a216aac73a68a1e95d29162d5e~QQB-mXXWQ2131121311epsmtip1o; Tue, 8 Jul 2025 10:32:40 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 5/6] arm64: dts: fsd: Add PPMU support for MFC block of FSD SoC Date: Tue, 8 Jul 2025 16:02:07 +0530 Message-ID: <20250708103208.79444-6-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103243epcas5p2d8fd5bf02e64e104eca3def802813230 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103243epcas5p2d8fd5bf02e64e104eca3def802813230 References: <20250708103208.79444-1-vivek.2311@samsung.com> Add device tree node for PPMU instances in MFC block and enable the same for Tesla FSD platform. Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- arch/arm64/boot/dts/tesla/fsd-evb.dts | 8 ++++++++ arch/arm64/boot/dts/tesla/fsd.dtsi | 20 ++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/arch/arm64/boot/dts/tesla/fsd-evb.dts b/arch/arm64/boot/dts/te= sla/fsd-evb.dts index 8d7794642900..f543c7dad7cc 100644 --- a/arch/arm64/boot/dts/tesla/fsd-evb.dts +++ b/arch/arm64/boot/dts/tesla/fsd-evb.dts @@ -110,3 +110,11 @@ &serial_0 { &ufs { status =3D "okay"; }; + +&ppmu0_mfc { + status =3D "okay"; +}; + +&ppmu1_mfc { + status =3D "okay"; +}; diff --git a/arch/arm64/boot/dts/tesla/fsd.dtsi b/arch/arm64/boot/dts/tesla= /fsd.dtsi index 690b4ed9c29b..7b6e7d81be10 100644 --- a/arch/arm64/boot/dts/tesla/fsd.dtsi +++ b/arch/arm64/boot/dts/tesla/fsd.dtsi @@ -970,6 +970,26 @@ timer@10040000 { clock-names =3D "fin_pll", "mct"; }; =20 + ppmu0_mfc: ppmu@12840000 { + compatible =3D "samsung,ppmu-v2"; + reg =3D <0x0 0x12840000 0x0 0x1000>; + interrupts =3D , + ; + clocks =3D <&clock_mfc MFC_PPMU_MFCD0_IPCLKPORT_ACLK>, + <&clock_mfc MFC_PPMU_MFCD0_IPCLKPORT_PCLK>; + clock-names =3D "aclk", "pclk"; + }; + + ppmu1_mfc: ppmu@12850000 { + compatible =3D "samsung,ppmu-v2"; + reg =3D <0x0 0x12850000 0x0 0x1000>; + interrupts =3D , + ; + clocks =3D <&clock_mfc MFC_PPMU_MFCD1_IPCLKPORT_ACLK>, + <&clock_mfc MFC_PPMU_MFCD1_IPCLKPORT_PCLK>; + clock-names =3D "aclk", "pclk"; + }; + mfc: mfc@12880000 { compatible =3D "tesla,fsd-mfc"; reg =3D <0x0 0x12880000 0x0 0x10000>; --=20 2.49.0 From nobody Tue Oct 7 16:36:36 2025 Received: from mailout2.samsung.com (mailout2.samsung.com [203.254.224.25]) (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 15FCC2D879D for ; Tue, 8 Jul 2025 10:41:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=203.254.224.25 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971273; cv=none; b=s5Iu+3H8pnRzj32UVuW2KxKLnDLU+WnIyk0Kg9t/f8u8t/wxA1eEx0Ct/x3YGZ2VLRJ2Jgycp2kIQCY6fMdG6887NNUwMD/y4ccLm7GRkSBaEKgin14TSUc4xwU0Tqsec7HsNivH6tSFk5bNc15VEG7u2zI+ke2oaWnL9Rc1NuQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751971273; c=relaxed/simple; bh=h8WzAtP1deJY97IsehBiHpJJmky6zH0Upj7s8EmaukQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:MIME-Version: Content-Type:References; b=iDDuFJuBrSCs4zUyFHEr9u4YNfV4qfZ5kZnP4AEWAnEV3lziA6c3oCYZe4mvdJoF9KWQ5dYPR1mrmC/mQoJFr/RV6f0xHmVST0g7Nir79cLrI2BeaAP2TJuyxXlN6PP55vYbgfJlOUscClzqHICMcdgFbtB8c+gokgwdZoOxoAM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com; spf=pass smtp.mailfrom=samsung.com; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b=nQI0UJp/; arc=none smtp.client-ip=203.254.224.25 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=samsung.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=samsung.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="nQI0UJp/" Received: from epcas5p4.samsung.com (unknown [182.195.41.42]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20250708104110epoutp02c5570dda59575faef4d675654e2db5b4~QQJaKwswj3128831288epoutp02T for ; Tue, 8 Jul 2025 10:41:10 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20250708104110epoutp02c5570dda59575faef4d675654e2db5b4~QQJaKwswj3128831288epoutp02T DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1751971270; bh=wKNM/MVkW5+UIAF/DDkf6NK4GoimrDLpjI5p5ZBJ8t8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=nQI0UJp/aEZHp3uJivzKfYJIBb1cTXi1bbF656pyNNMPJFAI01ZCufSdUCSzORIGm xqLuOsMxWqtNfW5kUp6D1b4OnPNijKNgbTDNi67vS9OxTX5LFdAyFwzOgkWGkRsv6y I7RAHtnOJaB9jOmYh6jdnkKw01XE+7Zbze3bWtto= Received: from epsnrtp02.localdomain (unknown [182.195.42.154]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPS id 20250708104109epcas5p2c53a6a032b6f49f6e749fceb3bf3b87d~QQJZeMmWX3102631026epcas5p2O; Tue, 8 Jul 2025 10:41:09 +0000 (GMT) Received: from epcas5p1.samsung.com (unknown [182.195.38.181]) by epsnrtp02.localdomain (Postfix) with ESMTP id 4bbyM82djqz2SSKs; Tue, 8 Jul 2025 10:41:08 +0000 (GMT) Received: from epsmtip1.samsung.com (unknown [182.195.34.30]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPA id 20250708103246epcas5p47b446ec342f9d49361c0a9a3929bcdd2~QQCFFnJsk0186101861epcas5p4N; Tue, 8 Jul 2025 10:32:46 +0000 (GMT) Received: from cheetah.samsungds.net (unknown [107.109.115.53]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20250708103243epsmtip152f34feb66a77e0fa50f13329b23b7ca~QQCCbn-4T1977519775epsmtip1_; Tue, 8 Jul 2025 10:32:43 +0000 (GMT) From: Vivek Yadav To: pankaj.dubey@samsung.com, ravi.patel@samsung.com, shradha.t@samsung.com, mturquette@baylibre.com, sboyd@kernel.org, robh@kernel.org, krzk@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, will@kernel.org, mark.rutland@arm.com, s.nawrocki@samsung.com, cw00.choi@samsung.com, alim.akhtar@samsung.com, linux-fsd@tesla.com Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-samsung-soc@vger.kernel.org, Vivek Yadav Subject: [PATCH 6/6] MAINTAINERS: Add maintainers for Samsung PPMU driver Date: Tue, 8 Jul 2025 16:02:08 +0530 Message-ID: <20250708103208.79444-7-vivek.2311@samsung.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250708103208.79444-1-vivek.2311@samsung.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 X-CMS-MailID: 20250708103246epcas5p47b446ec342f9d49361c0a9a3929bcdd2 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-Sendblock-Type: REQ_APPROVE CMS-TYPE: 105P cpgsPolicy: CPGSC10-541,Y X-CFilter-Loop: Reflected X-CMS-RootMailID: 20250708103246epcas5p47b446ec342f9d49361c0a9a3929bcdd2 References: <20250708103208.79444-1-vivek.2311@samsung.com> Add maintainers entry for Samsung PPMU driver Signed-off-by: Ravi Patel Signed-off-by: Vivek Yadav --- MAINTAINERS | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index ca11a553d412..5895b4e70c9e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21023,6 +21023,13 @@ F: drivers/regulator/s5m*.c F: drivers/rtc/rtc-s5m.c F: include/linux/mfd/samsung/ =20 +SAMSUNG PPMU DRIVER +M: Vivek Yadav +M: Ravi Patel +S: Supported +F: Documentation/devicetree/bindings/perf/samsung,ppmu-v2.yaml +F: drivers/perf/samsung/ + SAMSUNG S3C24XX/S3C64XX SOC SERIES CAMIF DRIVER M: Sylwester Nawrocki L: linux-media@vger.kernel.org --=20 2.49.0