From nobody Mon May 25 02:57:57 2026 Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) (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 3967F352037 for ; Tue, 19 May 2026 10:50:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.168.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187823; cv=none; b=YuYA+QRICmIMRDOhwvxtIXMTu1cemLSSOwNt9SJrIoEzQDeTyjt2ADc1gXOfkOEPFc734PCnZgexWuQNSRLNNATImJcVlFkZ9tUAhZOgwQEvf7QaAvmDpuI7TbCqpN+rk5mcjXtNIHrEU+BjLDAsWu/9k1t6IWfStULEslqmC+c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187823; c=relaxed/simple; bh=ez6BI+iFIWBZJ4OKYJs5blAxXM0YWETGmKLMOIskNuM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Avy1y95A0U8iSwpSFjpOC9KIh+QMthSfX5viy6nRrqQ3ojmQhDx1qtgd34a+Nt/nr9nEfI9XJapJq8uHPY0hWzAxMjRCuwSez+5lcHOAVbhkrc629xGLVb0cWwQYhprG0LdWzIBLcE0CinJ9rTDg1zXr/VTlDNdAEY9w97c++3A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=QRcfLm5m; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=C6ybGc8a; arc=none smtp.client-ip=205.220.168.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="QRcfLm5m"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="C6ybGc8a" Received: from pps.filterd (m0279862.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 64J6glvO1737101 for ; Tue, 19 May 2026 10:50:21 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=qcppdkim1; bh= yMu3pwwfQeds9RjA4hYk8iB+KBRpIN6EKL+u9mQS2mo=; b=QRcfLm5mmSr/ulxn bVyrHujCPYH4W47x5WLyl+CGwvoXpze1FP6R/kIbWfwQJYAE9PRp4xgYD74YiTdq xfI2ddDB0EYtNjQHojnjolO8bNy/U0GK17vReG0hGXW6FVeenSiSSgfQO8dvVaDW 1/P3coiT1WySPd3P+d/XxFy0jO8whThz2Wf7lYl+b4bXlYe2da/ya09GPyCorlmu lGPlLqHTn9oLFU8II4YJjiS2EJcGDH0FSwanUOWEJ1rZs5om8GDT1yDLVVtT9p69 t+cBswWv908YxXGlrI/BZ4gGgAJkF7L15WX4VLwLtvYdraifYD9UMVQV+csaEaFj /Dx8BQ== Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4e8ju911h2-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Tue, 19 May 2026 10:50:21 +0000 (GMT) Received: by mail-pf1-f200.google.com with SMTP id d2e1a72fcca58-82f85179263so5145852b3a.3 for ; Tue, 19 May 2026 03:50:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1779187821; x=1779792621; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=yMu3pwwfQeds9RjA4hYk8iB+KBRpIN6EKL+u9mQS2mo=; b=C6ybGc8adLJsJOBUPW/O6fZB9JWxkiKmSihJfNKnCrp18o6mwJk7NmbaeiYqNh0x4X siLaX7x7DGguCGTmIZ1FBV0h2kgx++XGygP7oeJxeCQ7QNGYczRrUAiwaW7qvDl7rG04 zLne3giPUYl5zNsRmRytCqbSeCuIGpERPkW6dQkiJCuVMC0oynnP+UwMK12r3M0VtN2S K+wK18inNyajGVKy4eDtK7ehUN0Sxtjzo5ZgTaCq2Bh3XjMpBBXGNPuYmC73y6/byajc hQQ0wFl46geeBh2Z3nY0Ss1bd9HKuIEeioRRoZ45F2luxzgPz9fZIE3HVP86SvAu9wU3 tkew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779187821; x=1779792621; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=yMu3pwwfQeds9RjA4hYk8iB+KBRpIN6EKL+u9mQS2mo=; b=CZ4BQlBMixLQ2SbYM/zU2LByIPakuz5xU42iTkfnH163C16zT4epO8pv06uNSFcQzw dv35IvRzGD+rniJU77OLXjPBosgshOYi8JFdUhNV62bbNovL+23z/417hwBzhia8L4jA eUfwbYETKThv1SQ9kRAuCoCFB6j4WwXFTMS3LM17jTxpWovYtbVV8dALSxkdUeVtzjsM 63ceFK/3GQYGiUsGrYsxy84uP07JBIUiVF+syr6g3MxYzWiBUxHfgLfY+ph4psSSNvSn pq4KPrDQ6YhGTXVsTnLrb7ldfmzm0mAQR0ChqLUKHLaj770StdlW6KnV5BHehnb7gYNK +Qpw== X-Forwarded-Encrypted: i=1; AFNElJ/cCUASzipM5zMEg/Fo524bUE6+hThKJvZ4wecXGTjpnVGUQCV7jcK35ANcLoa8u2e14Rf7FTviCwLjbwI=@vger.kernel.org X-Gm-Message-State: AOJu0Ywtq/MuOrp9NdInBQBOw+7+uHwISasDqSRsKUk6yR9q5Ybb+7+d UCFcB/eG1zXJuirIfU6LJdc+g1uFEzlFirlITe1U7Fm3A6Pm7RtZfW+f8jPoRcgrvLkMsq+AzIH Fme+gYRSD3Eu/IB6tdVSc2oGdqzncGsO8KKrT4v1D6PCzc7bI4eEGhYoexu1aDunRYsg= X-Gm-Gg: Acq92OFmy+SxAtE1QDlfJQGJZkIZdtj+Itck1MFIYj0HU9Xpp1tSfUIfiH5wU1fC2n4 Ok11XLuVHBwd1/RrOGpoRI3xYivul1YHguUCPxsfQtPjEYwi4nAFZiD8c+twVkBB5xkLbZ59l9l HlV6HBnzCvHiGNJGJiLDE+9M7KGmdTE19igIH3X4mVi6A83nAkovyDrsM40C2VxZha7obrUxoJQ 8eBJE5qjUkMeH2NVvSBJnjhPxoxC6CyfZPO7UMw5JVbIvmAjGFR48/JwLlHpSG6nTTnPTGt8qDl bKJbBpacblxBZbCg8pbcEUanCL/dtPrslRwxNFxvvCnz0LI7pqE78grh+mln6DQi/kDBtNEHUjo fUkEfhmccI91qNEXfERZlKRVSanwyO2qmUokNdOAMT79NFKqeFBEOyqUi X-Received: by 2002:a05:6a00:4b53:b0:82c:247b:ffdc with SMTP id d2e1a72fcca58-83f33c359b3mr18235919b3a.29.1779187820886; Tue, 19 May 2026 03:50:20 -0700 (PDT) X-Received: by 2002:a05:6a00:4b53:b0:82c:247b:ffdc with SMTP id d2e1a72fcca58-83f33c359b3mr18235880b3a.29.1779187820298; Tue, 19 May 2026 03:50:20 -0700 (PDT) Received: from hu-manafm-hyd.qualcomm.com ([202.46.23.25]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-83f19fa869esm20877879b3a.61.2026.05.19.03.50.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 19 May 2026 03:50:19 -0700 (PDT) From: Manaf Meethalavalappu Pallikunhi Date: Tue, 19 May 2026 16:19:49 +0530 Subject: [PATCH 1/3] dt-bindings: power: limits: Describe Qualcomm SPEL hardware Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260519-qcom_spel_driver_upstream-v1-1-75356d1b7f94@oss.qualcomm.com> References: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> In-Reply-To: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , "Rafael J. Wysocki" , Bjorn Andersson , Konrad Dybcio , Daniel Lezcano Cc: linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, Gaurav Kohli , Manaf Meethalavalappu Pallikunhi X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1779187810; l=2537; i=manaf.pallikunhi@oss.qualcomm.com; s=20260206; h=from:subject:message-id; bh=ez6BI+iFIWBZJ4OKYJs5blAxXM0YWETGmKLMOIskNuM=; b=+d7gNedQsIlsHf9gc6Uv0waPlUJuobTPnNYs0y84owz2NwRH3/+Xhpd43TiRCGNwDLp4vPJAt CVdutJ8/8qnAkWS6mCmHA7QjndpPgrf+elpfD71Va3b0tnoZbGEEaAX X-Developer-Key: i=manaf.pallikunhi@oss.qualcomm.com; a=ed25519; pk=oZ3x9jh+FDyPwxHmCbyzEMQHMzKqrH6hUbbL7dEBe2g= X-Proofpoint-GUID: nA6ZoXOBcz-i8feimDXHvmxHjZbV_mOJ X-Authority-Analysis: v=2.4 cv=eeUNubEH c=1 sm=1 tr=0 ts=6a0c406d cx=c_pps a=mDZGXZTwRPZaeRUbqKGCBw==:117 a=ZePRamnt/+rB5gQjfz0u9A==:17 a=IkcTkHD0fZMA:10 a=NGcC8JguVDcA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_K5XuSEh1TEqbUxoQ0s3:22 a=gEfo2CItAAAA:8 a=EUspDBNiAAAA:8 a=VwQbUJbxAAAA:8 a=COk6AnOGAAAA:8 a=MtUMKvMtarDq8PFyUT8A:9 a=QEXdDO2ut3YA:10 a=zc0IvFSfCIW2DFIPzwfm:22 a=sptkURWiP4Gy88Gu7hUp:22 a=TjNXssC_j7lpFel5tvFf:22 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwNTE5MDEwNiBTYWx0ZWRfX6az9DgMa9fYo CBawDJOHaU8QUXF+iIgEW+OJ7KZ6caJNQpqIj/lsVYfOdcdpYWjooxsvddhwyjUcIxGUiusQl4i eAmNTFkMXhfuP7+4tf7uQXE9b4tbYbWFJ21DWJ43Vt0XwC+4Lv9ZsyJq4jR7kWCWZ87CXlReNcz E+gMYg9asEStfEtQmaGTsP9jYEjHMV5KxL7dUECWTm6wMg5FGhR/pwgO/zaeLGFoM4be2wjOy6R 1aS6wyhj3MDx917gXqllwE6uIk03hGy+v4W2NLc/4pucpFwbPCSetOMvI/kynVMTuUW/NVw5nEu ALNh7d6CyS4Ql3yW0ASdJMLvVV32fZGxCp/bF7n1bnEBBptn1KUh6QnRetozC5+BxmdmKHPoYJz Lvh4Oh0N2TPrV2JtR0kRYM2voqq5n/27T8z3sVGyw5MzIXJs/wd6sgzZEKZbTL0qFLeVNfFyhj3 l5opOOyv3xX7RT/BVww== X-Proofpoint-ORIG-GUID: nA6ZoXOBcz-i8feimDXHvmxHjZbV_mOJ X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1143,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-05-19_03,2026-05-18_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 malwarescore=0 adultscore=0 priorityscore=1501 clxscore=1015 impostorscore=0 phishscore=0 suspectscore=0 bulkscore=0 lowpriorityscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2605130000 definitions=main-2605190106 The Qualcomm SoC Power and Electrical Limits (SPEL) provides hardware based power monitoring and limiting capabilities for various domains. Add a DeviceTree binding to describe the SPEL block on Qualcomm's SoC. Signed-off-by: Manaf Meethalavalappu Pallikunhi --- .../bindings/power/limits/qcom,spel.yaml | 47 ++++++++++++++++++= ++++ MAINTAINERS | 6 +++ 2 files changed, 53 insertions(+) diff --git a/Documentation/devicetree/bindings/power/limits/qcom,spel.yaml = b/Documentation/devicetree/bindings/power/limits/qcom,spel.yaml new file mode 100644 index 000000000000..e9bb70c3a3aa --- /dev/null +++ b/Documentation/devicetree/bindings/power/limits/qcom,spel.yaml @@ -0,0 +1,47 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/power/limits/qcom,spel.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Qualcomm SoC Power and Electrical Limits (SPEL) + +maintainers: + - Manaf Meethalavalappu Pallikunhi + +description: + The Qualcomm SPEL (SoC Power and Electrical Limits) provides hardware-ba= sed + power monitoring and limiting capabilities for various power domains in + Qualcomm SoCs. + +properties: + compatible: + const: qcom,spel + + reg: + maxItems: 3 + + reg-names: + items: + - const: nodes + - const: constraints + - const: config + +required: + - compatible + - reg + - reg-names + +additionalProperties: false + +examples: + - | + power-controller@ef3b000 { + compatible =3D "qcom,spel"; + reg =3D <0x0ef3e000 0x1000>, + <0x0ef3d000 0x1000>, + <0x0ef3b000 0x1000>; + reg-names =3D "nodes", + "constraints", + "config"; + }; diff --git a/MAINTAINERS b/MAINTAINERS index 3dd58a16f06a..c63f147e8c54 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22233,6 +22233,12 @@ S: Maintained F: Documentation/devicetree/bindings/power/supply/qcom,pmi8998-charger.yaml F: drivers/power/supply/qcom_smbx.c =20 +QUALCOMM SPEL POWERCAP DRIVER +M: Manaf Meethalavalappu Pallikunhi +L: linux-arm-msm@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/power/limits/qcom,spel.yaml + QUALCOMM PPE DRIVER M: Luo Jie L: netdev@vger.kernel.org --=20 2.43.0 From nobody Mon May 25 02:57:57 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (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 5CDC6352037 for ; Tue, 19 May 2026 10:50:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187830; cv=none; b=IzmIo1wyUgON18DpvKUOG1fbNM/RG5aqdQ9ZXnVBnwcHNG/0+bJFYwC4iVPXYlE7aI2r9vtR68dh9CdR+ukbpzrYmTV7fCvdMx3gThaJ+rOJFbePpPltmQ+tG2GKLMllmKq4reCQEksmlj3SW1lRwV8kCaiT2NIfDVBW6y1Qz1k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187830; c=relaxed/simple; bh=xhw0n2H0Ogr+XnpwObolDrQSmi6BKJK6KkfSM4an7WY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=lirDrW69VLWQ/qS/ObQdrwQkYlImu/sz+HtGC61/Ll3AugWu7pFwuzRMKngHYwl3tLhiV2aN8KT74AV0rWrN5iA5gbznQhvQuWscMEaDw9mymt+oZgtT6WNIEY4XMsv62nQNXXwrg+YDDobTpukll4jr72pkQTNeSQm/vByUtrs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=TYM8hqY2; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=GvW8Qv81; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="TYM8hqY2"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="GvW8Qv81" Received: from pps.filterd (m0279871.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 64JA38ld1393051 for ; Tue, 19 May 2026 10:50:27 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=qcppdkim1; bh= V7T5CBk0nxF6/mjhsou1VVPhQADaS6NTxrViWTKFrq0=; b=TYM8hqY2yZXiMZee nLDqz1tEExBtPkJqqcUHMC0afRCg6LuPralfc4xxJdU4uwP6UhDNKu+F7AYJ8BNY AYaQZiEXsSYfaiI8DfiU7oa81r67VXaZCetP9C9/IT2NcAGsmRKmt6zwe4rmI1UP SNgcFypneqWocdi9AqBw+CfJ9VN5ji1lTc18Uo21NOsHnG5FenuROewTESydtlK8 3SgPtZxHmOUvx33+8rDraad6gS/CDxZNQGeI0My/kaZzmoMwZXxh7sO0igpouObY 6i1A9XMREPxHY2/ZYPCwRAwywbjV/1C5WcAvcSKrey+BxpwLV/YUkd0A7huDWuNQ SqhGvQ== Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4e8ns48619-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Tue, 19 May 2026 10:50:27 +0000 (GMT) Received: by mail-pf1-f200.google.com with SMTP id d2e1a72fcca58-82fd55bf6cdso2152309b3a.3 for ; Tue, 19 May 2026 03:50:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1779187826; x=1779792626; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=V7T5CBk0nxF6/mjhsou1VVPhQADaS6NTxrViWTKFrq0=; b=GvW8Qv818zKnCP4JuJUhApyMG8Ay0qJrjdZ0E1ssfG/XtnB2cV0Tqknq1FLXso1N2A P/NbpOdybRdcNUb700rPCSxxYWZaU2TT92659e5TJT9F1EhvNfl2O+OGatIolypj29qz 2Rg4GTRAapAtv4z2I70dWllsrX/044kTS5gREejWaNuyuICbHPeUOb2hu7+1Ynfo7V5c 7xo/8M2PNaldjgWyP1ZvAQvlpT5lbUdi/9qZ3cCb1M8Xlb12IcAUXU2mryeyEJnpri9g wjgEhVwyYkY+Pz7AapG0FwzqDDsGD2XCKIjM4aHOGpodPuVWoag/bBOiQkOdKbZuLbzl XAjQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779187826; x=1779792626; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=V7T5CBk0nxF6/mjhsou1VVPhQADaS6NTxrViWTKFrq0=; b=TjVJBTkte5yvPVPi3Un5qYxWh57O8bPSR089i+fxwN+h5BW6NJCblZ3QFW5RCoKxXi ZN/P7gF15+Rh/EkCXTHlA4NuJR65V8X4b2P0OysCZNYl/lCPdXvK9WoD0ZLQ3rY3LBAt r4F3e2geRVaPnDlhLT9Bhw/MRuvJ5DkxARWNOmlG3bkhVWQ9U3mQ0PkDR5zzfQnTChha BKlPSdl4YUFTDpOxjiydT+fjdO4MGsZgKIcnFTG4mpZByhxzzGE1uUVTaLyahe0rZpUH iY36tAHXjW4hJIuPQ1YKBt0jS8zgg2UJXonm6dtVl5K2fM2GnZNi4DREM7ITYQhYWGVi OrkQ== X-Forwarded-Encrypted: i=1; AFNElJ/BnCA0OQ7N3iY9eDLkq8GEhNWP5pFV561+d/QN+qrk/cpYyA8aCrEvOwia5hY2yW6jFq687YFfS1xvmes=@vger.kernel.org X-Gm-Message-State: AOJu0YypAbCMPK7+Xk8aB9cOHydaFq0N5S+5ZySKZpeSWWwWnVgoAPGC QqJlSJSqdi3CrNs34zZutpu1F+CEoeBVZLniNCOCpIPJs8YkvscwYikTuSlZlQb+GA98wsq5c2U OfFxAtT+c/RVVqS/C/LeeZB6GDPHXHpWRQzYMsulA4nxDJAW9/saOZo3qjYVTu7y0F9g= X-Gm-Gg: Acq92OEbt84RJB77Kt9elBkFjVvCaCZpyL2li4LtoC6ZImSTUM+pkglHzDdcmPAawG/ uLLWYa3BIDHEYl4Dd99oO5KPl+jQEae2d2gGC74d65w9oS0n98nzFFaCciuKhjV/B7ykVvoVj2Q WBnBnajGgmKAzlL3pidOscUP5VBbOR3L8ArlelC/14EA+hK122XDylAovvLlgDbMsHNLBPLqozR OafQc5f/eHRJ/bCX5Yaqr80ssOQ8x2vzDVxVO9yZKXpVjZaqv0pZ451+LjVRiB7H5znfrUrh1yy GmAJxf9GHu7fFIAb8Qqvek6VlibkpkqsASp3uoeFOvCGXRgybBCshmYuNdMuZPYo67ZSif48WX8 2k0ItYfF9PKVy7xi6m1y2xKLM4DeKy8phij+m6ImMYJ4sBykRA4jNje6R X-Received: by 2002:a05:6a00:a203:b0:834:df57:9d36 with SMTP id d2e1a72fcca58-83f33d9de2dmr18978500b3a.25.1779187826059; Tue, 19 May 2026 03:50:26 -0700 (PDT) X-Received: by 2002:a05:6a00:a203:b0:834:df57:9d36 with SMTP id d2e1a72fcca58-83f33d9de2dmr18978463b3a.25.1779187825263; Tue, 19 May 2026 03:50:25 -0700 (PDT) Received: from hu-manafm-hyd.qualcomm.com ([202.46.23.25]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-83f19fa869esm20877879b3a.61.2026.05.19.03.50.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 19 May 2026 03:50:24 -0700 (PDT) From: Manaf Meethalavalappu Pallikunhi Date: Tue, 19 May 2026 16:19:50 +0530 Subject: [PATCH 2/3] powercap: qcom: Add SPEL powercap driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260519-qcom_spel_driver_upstream-v1-2-75356d1b7f94@oss.qualcomm.com> References: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> In-Reply-To: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , "Rafael J. Wysocki" , Bjorn Andersson , Konrad Dybcio , Daniel Lezcano Cc: linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, Gaurav Kohli , Manaf Meethalavalappu Pallikunhi X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1779187810; l=23185; i=manaf.pallikunhi@oss.qualcomm.com; s=20260206; h=from:subject:message-id; bh=xhw0n2H0Ogr+XnpwObolDrQSmi6BKJK6KkfSM4an7WY=; b=upVBkGmk6KILkog95QPtcpBtHGHbFbY68UikQvYkLhz9wJGFxPH5+ymnK70MlqzZSk0qwj6oW W2EgM7hVQ4iAyxGkkAVduLczyUpq/NIb8SIInXpQ+vvghbVJkXOdeyK X-Developer-Key: i=manaf.pallikunhi@oss.qualcomm.com; a=ed25519; pk=oZ3x9jh+FDyPwxHmCbyzEMQHMzKqrH6hUbbL7dEBe2g= X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwNTE5MDEwNSBTYWx0ZWRfX98+FedewwZo3 qDxlPDpJmpe2xlUMjP0YzvzOhMsfESPqdpgP+nkQC5kmBvzG4RWlHIWOSVDMV0oX4jnhdEdih6/ 5qEpfwhiV60sLMxtG+wIidE59dmlJIvH3NWlBi6ibC3woRFmZXq+W3tBRyPeT4B2wnzm8d+smxf RIu6Ez53BnqRwpTYSnayebhzJq6F6lZzu11MB3uAE4T8Y5p8xtOdQhdrCpD3+8tGqb1a1MagLHs IHfXUOJkGuKkGizp9L21Q3+cLav8+Bf+vX5SP1O6bFvISeogkrAr8Py8MFmELc11PrbelFWs8So WeGI/rb/fFrGb/y7keQjfgZFBgkfU9JU8hmGYBWF1Q+9ySevxCMXHs0RBJcc9TmSB7r4mT1unoI Ej7g6BJspUsp4LHq0mnh1jJMa1mnl2oD2PAQVhOry2ePsoLfrZ9ufIyzcn6zLeJw652z/74zZF7 F700RghJ4YjuEXrqFZg== X-Authority-Analysis: v=2.4 cv=F6dnsKhN c=1 sm=1 tr=0 ts=6a0c4073 cx=c_pps a=mDZGXZTwRPZaeRUbqKGCBw==:117 a=ZePRamnt/+rB5gQjfz0u9A==:17 a=IkcTkHD0fZMA:10 a=NGcC8JguVDcA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=3WHJM1ZQz_JShphwDgj5:22 a=EUspDBNiAAAA:8 a=VwQbUJbxAAAA:8 a=COk6AnOGAAAA:8 a=KhCOZ2j7RViXKUWDOLQA:9 a=QEXdDO2ut3YA:10 a=zc0IvFSfCIW2DFIPzwfm:22 a=TjNXssC_j7lpFel5tvFf:22 X-Proofpoint-GUID: oEw2VRPDox_Iao2wijEG8G8YKZzwbgoK X-Proofpoint-ORIG-GUID: oEw2VRPDox_Iao2wijEG8G8YKZzwbgoK X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1143,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-05-19_03,2026-05-18_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 adultscore=0 bulkscore=0 malwarescore=0 lowpriorityscore=0 priorityscore=1501 phishscore=0 clxscore=1015 impostorscore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2605130000 definitions=main-2605190105 The Qualcomm SoC Power and Electrical Limits (SPEL) provides hardware based power monitoring and limiting capabilities for various power domains including System, SoC, CPU clusters, GPU, and various other subsystems. The driver integrates with the Linux powercap framework, exposing SPEL capabilities through powercap sysfs interfaces. Signed-off-by: Manaf Meethalavalappu Pallikunhi --- MAINTAINERS | 1 + drivers/powercap/Kconfig | 13 + drivers/powercap/Makefile | 1 + drivers/powercap/qcom_spel.c | 787 +++++++++++++++++++++++++++++++++++++++= ++++ 4 files changed, 802 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index c63f147e8c54..5c7542754ab6 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22238,6 +22238,7 @@ M: Manaf Meethalavalappu Pallikunhi L: linux-arm-msm@vger.kernel.org S: Maintained F: Documentation/devicetree/bindings/power/limits/qcom,spel.yaml +F: drivers/powercap/qcom_spel.c =20 QUALCOMM PPE DRIVER M: Luo Jie diff --git a/drivers/powercap/Kconfig b/drivers/powercap/Kconfig index 03c4c796d993..e3a47c653499 100644 --- a/drivers/powercap/Kconfig +++ b/drivers/powercap/Kconfig @@ -93,4 +93,17 @@ config DTPM_DEVFREQ help This enables support for device power limitation based on energy model. + +config QCOM_SPEL + tristate "Qualcomm SPEL Powercap driver" + depends on ARM64 || COMPILE_TEST + help + This enables support for the Qualcomm SoC Power and Electrical + Limits (SPEL) hardware, which allows power limits to be + enforced and monitored on Qualcomm SoCs. + + SPEL provides energy monitoring and power capping for multiple + domains including system, SoC, CPU clusters, GPU, and various + other subsystems. + endif diff --git a/drivers/powercap/Makefile b/drivers/powercap/Makefile index 5ab0dce565b9..8235fb9d3df6 100644 --- a/drivers/powercap/Makefile +++ b/drivers/powercap/Makefile @@ -8,3 +8,4 @@ obj-$(CONFIG_INTEL_RAPL) +=3D intel_rapl_msr.o obj-$(CONFIG_INTEL_RAPL_TPMI) +=3D intel_rapl_tpmi.o obj-$(CONFIG_IDLE_INJECT) +=3D idle_inject.o obj-$(CONFIG_ARM_SCMI_POWERCAP) +=3D arm_scmi_powercap.o +obj-$(CONFIG_QCOM_SPEL) +=3D qcom_spel.o diff --git a/drivers/powercap/qcom_spel.c b/drivers/powercap/qcom_spel.c new file mode 100644 index 000000000000..fed5647959a5 --- /dev/null +++ b/drivers/powercap/qcom_spel.c @@ -0,0 +1,787 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Qualcomm SPEL (SoC Power and Electrical Limits) Driver + * + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* SPEL register bitmasks */ +#define ENERGY_STATUS_MASK 0xFFFFFFFF + +#define POWER_LIMIT_MASK 0x00007FFF +#define POWER_LIMIT_ENABLE BIT(31) + +#define TIME_WINDOW_MASK_L 0x00007FFF /* bits [14:0] */ +#define TIME_WINDOW_MASK_H 0x007F0000 /* bits [22:16] */ + +#define ENERGY_UNIT_OFFSET 16 +#define ENERGY_UNIT_MASK 0xF0000 + +#define TIME_UNIT_OFFSET 8 +#define TIME_UNIT_MASK 0xF00 + +#define POWER_UNIT_OFFSET 0 +#define POWER_UNIT_MASK 0x7 + +#define LIMITS_CAPABILITY_OFFSET 0x20 +#define ENERGY_RPT_UNIT_OFFSET 0x04 + +#define ENERGY_UNIT_SCALE 1000 + +#define SPEL_DOMAIN_NAME_LENGTH 16 + +/* Domain types */ +enum spel_domain_type { + SPEL_DOMAIN_SYS, + SPEL_DOMAIN_SOC, + SPEL_DOMAIN_CL0, + SPEL_DOMAIN_CL1, + SPEL_DOMAIN_CL2, + SPEL_DOMAIN_IGPU, + SPEL_DOMAIN_DGPU, + SPEL_DOMAIN_NSP, + SPEL_DOMAIN_MMCX, + SPEL_DOMAIN_INFRA, + SPEL_DOMAIN_DRAM, + SPEL_DOMAIN_MDM, + SPEL_DOMAIN_WLAN, + SPEL_DOMAIN_USB1, + SPEL_DOMAIN_USB2, + SPEL_DOMAIN_USB3, + SPEL_DOMAIN_MAX, +}; + +/* Power limit IDs */ +enum spel_power_limit_id { + POWER_LIMIT1, + POWER_LIMIT2, + POWER_LIMIT3, + POWER_LIMIT4, + NR_POWER_LIMITS, +}; + +/* Unit types for conversion */ +enum unit_type { + POWER_UNIT, + ENERGY_UNIT, + TIME_UNIT, +}; + +/* Power limit operation types */ +enum pl_ops_type { + PL_LIMIT, + PL_TIME_WINDOW, +}; + +static const char *pl_names[NR_POWER_LIMITS] =3D { + [POWER_LIMIT1] =3D "pl1", + [POWER_LIMIT2] =3D "pl2", + [POWER_LIMIT3] =3D "pl3", + [POWER_LIMIT4] =3D "pl4", +}; + +static const char *const spel_domain_names[] =3D { + "sys", "soc", "cl0", "cl1", "cl2", "igpu", "dgpu", "nsp", + "mmcx", "infra", "dram", "mdm", "wlan", "usb1", "usb2", "usb3", +}; + +/* Domain register offsets in node base */ +static const u32 domain_offsets[SPEL_DOMAIN_MAX] =3D { + [SPEL_DOMAIN_SYS] =3D 0x40, + [SPEL_DOMAIN_SOC] =3D 0x00, + [SPEL_DOMAIN_CL0] =3D 0x5C, + [SPEL_DOMAIN_CL1] =3D 0x60, + [SPEL_DOMAIN_CL2] =3D 0x64, + [SPEL_DOMAIN_IGPU] =3D 0x08, + [SPEL_DOMAIN_DGPU] =3D 0x44, + [SPEL_DOMAIN_NSP] =3D 0x0C, + [SPEL_DOMAIN_MMCX] =3D 0x10, + [SPEL_DOMAIN_INFRA] =3D 0x18, + [SPEL_DOMAIN_DRAM] =3D 0x1C, + [SPEL_DOMAIN_MDM] =3D 0x48, + [SPEL_DOMAIN_WLAN] =3D 0x4C, + [SPEL_DOMAIN_USB1] =3D 0x50, + [SPEL_DOMAIN_USB2] =3D 0x54, + [SPEL_DOMAIN_USB3] =3D 0x58, +}; + +/** + * struct spel_constraint_info - Power limit constraint information + * @limit_offset: Register offset for power limit value + * @time_window_offset: Register offset for time window + * @supported_mask: Bit mask in capability register + * @domain_id: Domain this constraint applies to + * @pl_id: Power limit ID (PL1, PL2, etc.) + */ +struct spel_constraint_info { + u32 limit_offset; + u32 time_window_offset; + u32 supported_mask; + enum spel_domain_type domain_id; + int pl_id; +}; + +/* Constraint configuration */ +static struct spel_constraint_info constraints[] =3D { + /* SYS domain constraints */ + { 0x10, 0x70, BIT(0), SPEL_DOMAIN_SYS, POWER_LIMIT1 }, + { 0x14, 0x74, BIT(1), SPEL_DOMAIN_SYS, POWER_LIMIT2 }, + { 0x18, 0x78, BIT(2), SPEL_DOMAIN_SYS, POWER_LIMIT3 }, + { 0x1C, 0x7C, BIT(3), SPEL_DOMAIN_SYS, POWER_LIMIT4 }, + /* SOC domain constraints */ + { 0x00, 0x60, BIT(4), SPEL_DOMAIN_SOC, POWER_LIMIT1 }, + { 0x04, 0x64, BIT(5), SPEL_DOMAIN_SOC, POWER_LIMIT2 }, + { 0x08, 0x68, BIT(6), SPEL_DOMAIN_SOC, POWER_LIMIT3 }, + { 0x0C, 0x6C, BIT(7), SPEL_DOMAIN_SOC, POWER_LIMIT4 }, +}; + +struct spel_system; + +/** + * struct spel_domain - SPEL power domain + * @power_zone: Powercap zone + * @lock: Mutex protecting register access + * @sp: Parent system + * @status_reg: Energy counter register + * @pl_name: Power limit names + * @name: Domain name + * @id: Domain type ID + */ +struct spel_domain { + struct powercap_zone power_zone; + struct mutex lock; /* Protects register read/write operations */ + struct spel_system *sp; + void __iomem *status_reg; + const char *pl_name[NR_POWER_LIMITS]; + char name[SPEL_DOMAIN_NAME_LENGTH]; + enum spel_domain_type id; +}; + +/** + * struct spel_system - SPEL system + * @domains: Array of domains + * @power_zone: Parent powercap zone + * @node_base: Base address for node registers + * @constraint_base: Base address for constraint registers + * @config_base: Base address for config registers + * @control_type: Powercap control type + * @dev: Device pointer for logging + * @limits: Supported power limits per domain + * @power_unit: Power unit in microWatts (common for all domains) + * @energy_unit: Energy unit in nanoJoules (common for all domains) + * @time_unit: Time unit in microseconds (common for all domains) + */ +struct spel_system { + struct spel_domain *domains; + struct powercap_zone *power_zone; + void __iomem *node_base; + void __iomem *constraint_base; + void __iomem *config_base; + struct powercap_control_type *control_type; + struct device *dev; + int limits[SPEL_DOMAIN_MAX]; + unsigned int power_unit; + unsigned int energy_unit; + unsigned int time_unit; +}; + +#define power_zone_to_spel_domain(_zone) \ + container_of(_zone, struct spel_domain, power_zone) + +/* Helper functions */ +static bool is_pl_valid(struct spel_domain *sd, int pl) +{ + if (pl < POWER_LIMIT1 || pl >=3D NR_POWER_LIMITS) + return false; + return sd->pl_name[pl] ? true : false; +} + +static int get_pl_ops_offset(struct spel_domain *sd, int pl, enum pl_ops_t= ype pl_op) +{ + int i; + + for (i =3D 0; i < ARRAY_SIZE(constraints); i++) { + struct spel_constraint_info *ci =3D &constraints[i]; + + if (ci->domain_id =3D=3D sd->id && ci->pl_id =3D=3D pl) { + switch (pl_op) { + case PL_LIMIT: + return ci->limit_offset; + case PL_TIME_WINDOW: + return ci->time_window_offset; + default: + return -EOPNOTSUPP; + } + } + } + + return -EOPNOTSUPP; +} + +static u64 spel_unit_xlate(struct spel_domain *sd, enum unit_type type, + u64 value, int to_raw) +{ + struct spel_system *sp =3D sd->sp; + u64 units =3D 1; + u64 scale =3D 1; + + switch (type) { + case POWER_UNIT: + units =3D sp->power_unit; + break; + case ENERGY_UNIT: + scale =3D ENERGY_UNIT_SCALE; + units =3D sp->energy_unit; + break; + case TIME_UNIT: + units =3D sp->time_unit; + break; + default: + return value; + } + + if (to_raw) + return div64_u64(value * scale, units); + + value *=3D units; + return div64_u64(value, scale); +} + +/* Power limit data access */ +static int spel_read_pl_data(struct spel_domain *sd, int pl, + enum pl_ops_type pl_op, bool xlate, u64 *data) +{ + struct spel_system *sp =3D sd->sp; + void __iomem *reg_addr; + u64 value; + int offset; + + if (!is_pl_valid(sd, pl)) + return -EINVAL; + + offset =3D get_pl_ops_offset(sd, pl, pl_op); + if (offset < 0) + return offset; + + guard(mutex)(&sd->lock); + + reg_addr =3D sp->constraint_base + offset; + value =3D readl(reg_addr); + + switch (pl_op) { + case PL_LIMIT: + value &=3D POWER_LIMIT_MASK; + if (xlate) + *data =3D spel_unit_xlate(sd, POWER_UNIT, value, 0); + else + *data =3D value; + break; + case PL_TIME_WINDOW: + /* Decode time window: bits [22:16] are upper 7 bits, [14:0] are lower 1= 5 bits */ + value =3D ((value & TIME_WINDOW_MASK_H) >> 16 << 15) | + (value & TIME_WINDOW_MASK_L); + if (xlate) + *data =3D spel_unit_xlate(sd, TIME_UNIT, value, 0); + else + *data =3D value; + break; + default: + return -EINVAL; + } + + return 0; +} + +static int spel_write_pl_data(struct spel_domain *sd, int pl, + enum pl_ops_type pl_op, unsigned long long value) +{ + struct spel_system *sp =3D sd->sp; + void __iomem *reg_addr; + u64 reg_val, new_val; + int offset; + + if (!is_pl_valid(sd, pl)) + return -EINVAL; + + offset =3D get_pl_ops_offset(sd, pl, pl_op); + if (offset < 0) + return offset; + + guard(mutex)(&sd->lock); + + reg_addr =3D sp->constraint_base + offset; + reg_val =3D readl(reg_addr); + + switch (pl_op) { + case PL_LIMIT: + new_val =3D spel_unit_xlate(sd, POWER_UNIT, value, 1); + if (new_val > POWER_LIMIT_MASK) + return -EINVAL; + reg_val =3D (reg_val & ~POWER_LIMIT_MASK) | new_val; + + /* + * Enable/Disable PL based on the value: + * - If value is 0, disable the PL (clear enable bit) + * - If value is non-zero, enable the PL (set enable bit) + */ + if (new_val =3D=3D 0) + reg_val &=3D ~POWER_LIMIT_ENABLE; + else + reg_val |=3D POWER_LIMIT_ENABLE; + break; + case PL_TIME_WINDOW: + /* + * Encode time window: upper 7 bits to [22:16], lower 15 bits to [14:0] + * Time window register is separate from limit register (different offse= t), + * so we write only the time window bits without preserving any enable b= it. + */ + new_val =3D spel_unit_xlate(sd, TIME_UNIT, value, 1); + reg_val =3D (((new_val >> 15) & 0x7F) << 16) | + (new_val & 0x7FFF); + break; + default: + return -EINVAL; + } + + writel(reg_val, reg_addr); + return 0; +} + +/* Powercap zone operations */ +static int spel_get_energy_counter(struct powercap_zone *power_zone, u64 *= energy_raw) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + u64 value; + + value =3D readl(sd->status_reg); + *energy_raw =3D spel_unit_xlate(sd, ENERGY_UNIT, value, 0); + + return 0; +} + +static int spel_get_max_energy_counter(struct powercap_zone *pcd_dev, u64 = *energy) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(pcd_dev); + + *energy =3D spel_unit_xlate(sd, ENERGY_UNIT, ENERGY_STATUS_MASK, 0); + return 0; +} + +static int spel_release_zone(struct powercap_zone *power_zone) +{ + return 0; +} + +static int spel_find_nr_power_limit(struct spel_domain *sd) +{ + int i, nr_pl =3D 0; + + for (i =3D 0; i < NR_POWER_LIMITS; i++) { + if (is_pl_valid(sd, i)) + nr_pl++; + } + + return nr_pl; +} + +static const struct powercap_zone_ops zone_ops =3D { + .get_energy_uj =3D spel_get_energy_counter, + .get_max_energy_range_uj =3D spel_get_max_energy_counter, + .release =3D spel_release_zone, +}; + +/* Constraint operations */ +static int spel_constraint_to_pl(struct spel_domain *sd, int cid) +{ + int i, j; + + for (i =3D POWER_LIMIT1, j =3D 0; i < NR_POWER_LIMITS; i++) { + if (is_pl_valid(sd, i) && j++ =3D=3D cid) + return i; + } + + return -EINVAL; +} + +static int spel_set_power_limit(struct powercap_zone *power_zone, int cid, + u64 power_limit) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + int id; + + id =3D spel_constraint_to_pl(sd, cid); + if (id < 0) + return id; + + return spel_write_pl_data(sd, id, PL_LIMIT, power_limit); +} + +static int spel_get_power_limit(struct powercap_zone *power_zone, int cid, + u64 *data) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + u64 val; + int ret, id; + + id =3D spel_constraint_to_pl(sd, cid); + if (id < 0) + return id; + + ret =3D spel_read_pl_data(sd, id, PL_LIMIT, true, &val); + if (!ret) + *data =3D val; + + return ret; +} + +static int spel_set_time_window(struct powercap_zone *power_zone, int cid, + u64 window) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + int id; + + id =3D spel_constraint_to_pl(sd, cid); + if (id < 0) + return id; + + return spel_write_pl_data(sd, id, PL_TIME_WINDOW, window); +} + +static int spel_get_time_window(struct powercap_zone *power_zone, int cid, + u64 *data) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + u64 val; + int ret, id; + + id =3D spel_constraint_to_pl(sd, cid); + if (id < 0) + return id; + + ret =3D spel_read_pl_data(sd, id, PL_TIME_WINDOW, true, &val); + if (!ret) + *data =3D val; + + return ret; +} + +static const char *spel_get_constraint_name(struct powercap_zone *power_zo= ne, + int cid) +{ + struct spel_domain *sd =3D power_zone_to_spel_domain(power_zone); + int id; + + id =3D spel_constraint_to_pl(sd, cid); + if (id >=3D 0) + return sd->pl_name[id]; + + return NULL; +} + +static const struct powercap_zone_constraint_ops constraint_ops =3D { + .set_power_limit_uw =3D spel_set_power_limit, + .get_power_limit_uw =3D spel_get_power_limit, + .set_time_window_us =3D spel_set_time_window, + .get_time_window_us =3D spel_get_time_window, + .get_name =3D spel_get_constraint_name, +}; + +static void spel_init_domains(struct spel_system *sp) +{ + unsigned int i; + + for (i =3D 0; i < SPEL_DOMAIN_MAX; i++) { + struct spel_domain *sd =3D &sp->domains[i]; + + sd->sp =3D sp; + snprintf(sd->name, SPEL_DOMAIN_NAME_LENGTH, "%s", + spel_domain_names[i]); + sd->id =3D i; + sd->status_reg =3D sp->node_base + domain_offsets[i]; + + /* PL1 is always supported (required for powercap registration) */ + sp->limits[i] =3D BIT(POWER_LIMIT1); + sd->pl_name[POWER_LIMIT1] =3D pl_names[POWER_LIMIT1]; + } +} + +static int spel_check_unit(struct spel_system *sp) +{ + u32 value, shift; + + /* Read power_unit and time_unit from offset 0x0 */ + value =3D readl(sp->config_base); + + /* + * Unit calculation: 1 / (2^shift) + * Masks limit: TIME_UNIT (4 bits, max 15), POWER_UNIT (3 bits, max 7). + */ + shift =3D (value & POWER_UNIT_MASK) >> POWER_UNIT_OFFSET; + sp->power_unit =3D 1000000 / (1 << shift); + + shift =3D (value & TIME_UNIT_MASK) >> TIME_UNIT_OFFSET; + sp->time_unit =3D 1000000 / (1 << shift); + + /* Read energy_unit from ENERGY_RPT_UNIT_OFFSET */ + value =3D readl(sp->config_base + ENERGY_RPT_UNIT_OFFSET); + + /* + * Unit calculation: 1 / (2^shift) + * Masks limit: ENERGY_UNIT (4 bits, max 15). + */ + shift =3D (value & ENERGY_UNIT_MASK) >> ENERGY_UNIT_OFFSET; + sp->energy_unit =3D ENERGY_UNIT_SCALE * 1000000 / (1 << shift); + + dev_dbg(sp->dev, "Units: energy=3D%dnJ, time=3D%dus, power=3D%duW\n", + sp->energy_unit, sp->time_unit, sp->power_unit); + + return 0; +} + +static void spel_detect_powerlimit(struct spel_domain *sd) +{ + struct spel_system *sp =3D sd->sp; + u32 capabilities; + int i, j; + + capabilities =3D readl(sp->config_base + LIMITS_CAPABILITY_OFFSET); + + /* Detect power limits from hardware capabilities */ + for (i =3D POWER_LIMIT2; i < NR_POWER_LIMITS; i++) { + for (j =3D 0; j < ARRAY_SIZE(constraints); j++) { + struct spel_constraint_info *ci =3D &constraints[j]; + + if (ci->domain_id =3D=3D sd->id && ci->pl_id =3D=3D i) { + if (capabilities & ci->supported_mask) { + sp->limits[sd->id] |=3D BIT(i); + sd->pl_name[i] =3D pl_names[i]; + } + break; + } + } + } +} + +static int spel_init_system(struct spel_system *sp, struct device *dev) +{ + int i, ret; + + /* Read unit configuration (common for all domains) */ + ret =3D spel_check_unit(sp); + if (ret) { + dev_err(dev, "Failed to read unit config\n"); + return ret; + } + + sp->domains =3D devm_kcalloc(dev, SPEL_DOMAIN_MAX, + sizeof(struct spel_domain), GFP_KERNEL); + if (!sp->domains) + return -ENOMEM; + + spel_init_domains(sp); + + for (i =3D 0; i < SPEL_DOMAIN_MAX; i++) { + struct spel_domain *sd =3D &sp->domains[i]; + + ret =3D devm_mutex_init(dev, &sd->lock); + if (ret) { + dev_err(dev, "Failed to initialize mutex for domain %s\n", sd->name); + return ret; + } + + spel_detect_powerlimit(sd); + } + + return 0; +} + +static int spel_register_powercap(struct spel_system *sp) +{ + struct spel_domain *sd; + struct powercap_zone *power_zone =3D NULL; + int nr_pl, ret, i; + + /* Register SYS domain as parent zone */ + for (sd =3D sp->domains; sd < sp->domains + SPEL_DOMAIN_MAX; sd++) { + if (sd->id =3D=3D SPEL_DOMAIN_SYS) { + nr_pl =3D spel_find_nr_power_limit(sd); + + power_zone =3D powercap_register_zone(&sd->power_zone, + sp->control_type, sd->name, + NULL, &zone_ops, nr_pl, + &constraint_ops); + if (IS_ERR(power_zone)) { + dev_err(sp->dev, "Failed to register power zone %s\n", + sd->name); + return PTR_ERR(power_zone); + } + sp->power_zone =3D power_zone; + break; + } + } + + if (!power_zone) { + dev_err(sp->dev, "No SYS domain found\n"); + return -ENODEV; + } + + /* Register other domains as children */ + for (sd =3D sp->domains; sd < sp->domains + SPEL_DOMAIN_MAX; sd++) { + struct powercap_zone *parent =3D sp->power_zone; + + if (sd->id =3D=3D SPEL_DOMAIN_SYS) + continue; + + /* SOC is child of SYS, others are children of SOC */ + if (sd->id !=3D SPEL_DOMAIN_SOC) { + for (i =3D 0; i < SPEL_DOMAIN_MAX; i++) { + if (sp->domains[i].id =3D=3D SPEL_DOMAIN_SOC) { + parent =3D &sp->domains[i].power_zone; + break; + } + } + } + + nr_pl =3D spel_find_nr_power_limit(sd); + power_zone =3D powercap_register_zone(&sd->power_zone, + sp->control_type, + sd->name, parent, + &zone_ops, nr_pl, + &constraint_ops); + + if (IS_ERR(power_zone)) { + dev_err(sp->dev, "Failed to register power_zone %s\n", + sd->name); + ret =3D PTR_ERR(power_zone); + goto err_cleanup; + } + } + + return 0; + +err_cleanup: + /* Unregister in reverse order: children first, then SOC, then SYS */ + for (i =3D (int)(sd - sp->domains) - 1; i >=3D 0; i--) + powercap_unregister_zone(sp->control_type, &sp->domains[i].power_zone); + + return ret; +} + +static int spel_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct spel_system *sp; + struct resource *res; + int ret; + + sp =3D devm_kzalloc(dev, sizeof(*sp), GFP_KERNEL); + if (!sp) + return -ENOMEM; + + sp->dev =3D dev; + + /* Map spel domain registers (energy counters) */ + res =3D platform_get_resource_byname(pdev, IORESOURCE_MEM, "nodes"); + if (!res) { + dev_err(dev, "Failed to get nodes resource\n"); + return -EINVAL; + } + sp->node_base =3D devm_ioremap_resource(dev, res); + if (IS_ERR(sp->node_base)) + return PTR_ERR(sp->node_base); + + /* Map constraint registers (power limits) */ + res =3D platform_get_resource_byname(pdev, IORESOURCE_MEM, "constraints"); + if (!res) { + dev_err(dev, "Failed to get constraints resource\n"); + return -EINVAL; + } + sp->constraint_base =3D devm_ioremap_resource(dev, res); + if (IS_ERR(sp->constraint_base)) + return PTR_ERR(sp->constraint_base); + + /* Map config registers (units, capabilities) */ + res =3D platform_get_resource_byname(pdev, IORESOURCE_MEM, "config"); + if (!res) { + dev_err(dev, "Failed to get config resource\n"); + return -EINVAL; + } + sp->config_base =3D devm_ioremap_resource(dev, res); + if (IS_ERR(sp->config_base)) + return PTR_ERR(sp->config_base); + + sp->control_type =3D powercap_register_control_type(NULL, "qcom-spel", + NULL); + if (IS_ERR(sp->control_type)) { + dev_err(dev, "Failed to register control type\n"); + return PTR_ERR(sp->control_type); + } + + /* Initialize system and domains */ + ret =3D spel_init_system(sp, dev); + if (ret) { + dev_err(dev, "Failed to initialize system\n"); + goto err_unregister_control; + } + + ret =3D spel_register_powercap(sp); + if (ret) { + dev_err(dev, "Failed to register powercap zones\n"); + goto err_unregister_control; + } + + platform_set_drvdata(pdev, sp); + + return 0; + +err_unregister_control: + powercap_unregister_control_type(sp->control_type); + return ret; +} + +static void spel_remove(struct platform_device *pdev) +{ + struct spel_system *sp =3D platform_get_drvdata(pdev); + int i; + + if (!sp) + return; + + /* Unregister in reverse order: children first, then SOC, then SYS */ + for (i =3D SPEL_DOMAIN_MAX - 1; i >=3D 0; i--) + powercap_unregister_zone(sp->control_type, &sp->domains[i].power_zone); + + powercap_unregister_control_type(sp->control_type); +} + +static const struct of_device_id spel_of_match[] =3D { + { .compatible =3D "qcom,spel" }, + { } +}; +MODULE_DEVICE_TABLE(of, spel_of_match); + +static struct platform_driver spel_driver =3D { + .probe =3D spel_probe, + .remove =3D spel_remove, + .driver =3D { + .name =3D "qcom_spel", + .of_match_table =3D spel_of_match, + }, +}; + +module_platform_driver(spel_driver); + +MODULE_DESCRIPTION("Qualcomm SPEL Powercap Driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Mon May 25 02:57:57 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (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 21BD23F4DDC for ; Tue, 19 May 2026 10:50:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187834; cv=none; b=HfViYEkKSQWvKJo0rN4/g0G5J9vRYkKnnw+jMcp04c+Lmtp40IIHZfXJla6GvWCB20/xwG/tkvDirdvpWxH45ud1iNPMOqG/a8DU61HRwtJLQ1OoWpRBbDakMg0eW71St6SVsgWtxSZlZztx598Nv+EKyr8RDBse3Xuw9tDmK2E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779187834; c=relaxed/simple; bh=QkBvjzgzUPS7j6rbYYt0+plzzSIJ+yEdKR2h5bans+I=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ODZZIOA21Irwoqz4BqqcdXRLhc0MiQZzrKJyv6E+ckdPX6JKvZFZQTL5VWeuzH4qwdrqg1+IGoB6GGiq0k07ZO55dL0ecKzTbyltpKyUCR6H4qHV7Qa5dka5YbSJGtG+NGD4walb/7GAEFumYKpoTCCE+Jiz4xM7N5fQoWxiNfs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=WZe77LZc; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=MCm1EZo9; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="WZe77LZc"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="MCm1EZo9" Received: from pps.filterd (m0279871.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 64JA34Ht1392941 for ; Tue, 19 May 2026 10:50:32 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=qcppdkim1; bh= jD4A3DvHqusxb6pJNGa2ldrzXIBVdy3bObx9T0M3r9k=; b=WZe77LZctWPVbHmC vPpddlNZhWFfM9Ue2oc1UBvOf6pMrLYI3iJs9GYi7NuCqTtfXYt3mBhBoQX7ZVV3 W1dWTqHETPMPBtHHPMrgq7Ulgquh+EqEIoTJwr/9hgQ+8/5GHyGnqSSZbvxWbtL2 tiAOzL8AqIxAOcZ/d4gx5msq4HxeXLOTXTdiTrnKj3FUuT5zpUq4RDyqRJN5pk2O ufGhaq8giaj/nvs8wazW5NCli83ZjFDmu6wISfB1pbDnkrb6cP1e4Lr5iqhtVbNw Dw9+ZhV3V+km0ZZp4qXbpLU2UKqXMAai36mmQ7SQV0vl12x47NbSF1Q8mDvtPXFY sqKm6g== Received: from mail-pg1-f199.google.com (mail-pg1-f199.google.com [209.85.215.199]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4e8ns4861t-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Tue, 19 May 2026 10:50:32 +0000 (GMT) Received: by mail-pg1-f199.google.com with SMTP id 41be03b00d2f7-c8281d4cef8so1561073a12.2 for ; Tue, 19 May 2026 03:50:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1779187831; x=1779792631; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=jD4A3DvHqusxb6pJNGa2ldrzXIBVdy3bObx9T0M3r9k=; b=MCm1EZo9NZAdAp1loIb1RNLVY7iTL6Am5H9z/UGDVjlvh3nGzTTSVhcK4xXQvzVgU1 HtkL63l7PQfDBUoHfdy2iGZeN6B+3PPnYH6+ANHK+oC60MW1iBwA8jG55ci3YUQ+xKLV 7fphrFQFzlMeEWnSN6WWJf8wwJ3q5eKHUMkj3ZOK56Qs7XYt/7ZePr4fxCAm1Q6f6xUX bMA49qY9dUYK6wfJTDAfTS1LRx5gvkw708bUa9H3YYtqENUUYYipIk2iV0e5BHh+z8+2 tm8Ao6YglCVJdAwF/uyp31we9HF/1VTQ/WUbbiDT5Nws0Hts/WeDGgoltGfADhj+xbCc 8O9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779187831; x=1779792631; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=jD4A3DvHqusxb6pJNGa2ldrzXIBVdy3bObx9T0M3r9k=; b=Z86Gr0EQCvSdumaqjF1WrV0uA6lMpFEFeMBrOjAaSffr9Kbh2HSgNrDiFJOkg9WBnM 3wnCEsxdg6FhSMYjqaqqnwFf51ECrscluRpSgHwEQwyaNt07uPzcnplW2ARC1le53P7A XZWRXEO8FXfF+g7T2lesIjaNomXqtntn4giHbiOAwZrUZ0VAgCfyXUzw3/ULSzLo+qzg xpKcecXWXerNkckZ+NH5Gr/1eFldX75lY7zegpw24LYhRnrQ2BbYQn+BlNL8te96gVyh Fx/Ky9R0WRIxTcmCQImqZETPvYNJTKgxFFWGE373TeHwFART7pZ5J/s0nFmHh8O7TckC gpQA== X-Forwarded-Encrypted: i=1; AFNElJ/tjG23kOS+LlR2GAeAlqXAM8Sp3wshsEQRxXRswoaVbSQiBDWKJOuVfzh9fhG+4fKz0laBFy0xbZ0KVWk=@vger.kernel.org X-Gm-Message-State: AOJu0YzRK/mc0XlOjNwH84Mw4C4xITD4WlpdrKzLS7/HxuaU4F2hOGMK 0y1LpacIPf4usQCOOa+a1xuz6W97XIkS2I1bm55FDqQuHFLBgouhvjSBlW73Nx/mhg2isXRfFxe c0TcomxAKS+5LZb1D5egfC3//BrKezryVJRUNqgfVrDBIdlBLVyibcE2Jg4q4MuRJT5w= X-Gm-Gg: Acq92OEmUbEhkXTk/7lUn8SK8Ce8gS/KJVFvlmw90s0ntEG2QAv3eKArpcM/SLdye5t +oaSG43sDczFGaGtqfHWNrff/VYcFXIHNlzKmqnLpejScSDwOXBlOy0/OZvjwVX4P5EL4MgoJj/ WPQhI3OEZZZ2D8Kq3yHeuMgnHge95Ur6yp+3lUXahzjzvrv8u1ZNWfVm8wwKnf6iBpoc0m3p335 d/td7N1CaVzbXqzQcMcQhC4NzTstA0Mg58HV4FUKC0co6lfyy+UtO8cdQa5FuqtEZJ518ZQnYJC tFl+/AJxplp2xyCjnQ8X1JdtW4NkctwiAia1exS3332WCC7GJ7k9kFmfepr2Imv7OhYgKAgcOSs iYOu5crPR5PWslhYXrQMf/Tu/cM0sM3AiXlarN+1RJbVzYH2I38ju4AJj X-Received: by 2002:a05:6300:218e:b0:3a2:bd1d:d68c with SMTP id adf61e73a8af0-3b22ecb3630mr22180401637.50.1779187831061; Tue, 19 May 2026 03:50:31 -0700 (PDT) X-Received: by 2002:a05:6300:218e:b0:3a2:bd1d:d68c with SMTP id adf61e73a8af0-3b22ecb3630mr22180368637.50.1779187830541; Tue, 19 May 2026 03:50:30 -0700 (PDT) Received: from hu-manafm-hyd.qualcomm.com ([202.46.23.25]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-83f19fa869esm20877879b3a.61.2026.05.19.03.50.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 19 May 2026 03:50:29 -0700 (PDT) From: Manaf Meethalavalappu Pallikunhi Date: Tue, 19 May 2026 16:19:51 +0530 Subject: [PATCH 3/3] arm64: dts: qcom: glymur: Enable SPEL powercap driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260519-qcom_spel_driver_upstream-v1-3-75356d1b7f94@oss.qualcomm.com> References: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> In-Reply-To: <20260519-qcom_spel_driver_upstream-v1-0-75356d1b7f94@oss.qualcomm.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , "Rafael J. Wysocki" , Bjorn Andersson , Konrad Dybcio , Daniel Lezcano Cc: linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, Gaurav Kohli , Manaf Meethalavalappu Pallikunhi X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1779187810; l=1088; i=manaf.pallikunhi@oss.qualcomm.com; s=20260206; h=from:subject:message-id; bh=QkBvjzgzUPS7j6rbYYt0+plzzSIJ+yEdKR2h5bans+I=; b=kdvWLzdOynXwDBoB2O6Sije04VhkPQ32HFwYGtVfrdeV/M/jABz/cCEHZAaxKeeyGpWxv3tMz mbI5Yxlk7YkAjF9/AxW3B2mTSCZFacwYRr24sphwJ08M2pMuYIbXEr7 X-Developer-Key: i=manaf.pallikunhi@oss.qualcomm.com; a=ed25519; pk=oZ3x9jh+FDyPwxHmCbyzEMQHMzKqrH6hUbbL7dEBe2g= X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwNTE5MDEwNSBTYWx0ZWRfX+LhYaBlWkw7E gtNiiyQTdLJcV27fz5KvQhqsh2ii4shB02MseL0xmwZMlIRIofygcai6ZSU/9gonqwG6DOZd7c1 GZ8Adp6MGk9vvUix8itu9QQxO0AAz9e0JrOkz+POK79D6uVNCf8tESI3YxvQLftZGiqW9SK8N9q RB5dlQ12eSkUlXyHYTihmNNn63ZwE4xPNAV1GoMuLR6YnjJrNyjrr54/WtwO753GzQrUr/TB9jb KVQsupkDHXiS+m6geGp3OqmI5IF+5ifmtg00Dn+mBTaFuXQxJcwQcdfG+OU9+YlphmaT9NbSR0p nN0/k7O4vpMLTqHByPVWe8gLFbxANRCUo3wjINzOoHrdXkTtJF+ARixJhcufE7nrVNQSakRJIr1 wtLnzMjl0Xuse8Q+xRkjsufyj0Ogkjsu+a6H9fqw8EHCxRnH3xvaGU2zx8GS2u6/zG/bOeEpVrF nToS6K+OV1cimsMRkiA== X-Authority-Analysis: v=2.4 cv=F6dnsKhN c=1 sm=1 tr=0 ts=6a0c4078 cx=c_pps a=Oh5Dbbf/trHjhBongsHeRQ==:117 a=ZePRamnt/+rB5gQjfz0u9A==:17 a=IkcTkHD0fZMA:10 a=NGcC8JguVDcA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=3WHJM1ZQz_JShphwDgj5:22 a=EUspDBNiAAAA:8 a=0DiunMzU2dUnP_sjRnAA:9 a=QEXdDO2ut3YA:10 a=_Vgx9l1VpLgwpw_dHYaR:22 X-Proofpoint-GUID: IhGK-cG_5OHfpZXyZwmTJ95HKyv_O1YU X-Proofpoint-ORIG-GUID: IhGK-cG_5OHfpZXyZwmTJ95HKyv_O1YU X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1143,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-05-19_03,2026-05-18_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 adultscore=0 bulkscore=0 malwarescore=0 lowpriorityscore=0 priorityscore=1501 phishscore=0 clxscore=1015 impostorscore=0 suspectscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2605130000 definitions=main-2605190105 The Qualcomm SoC Power and Electrical Limits (SPEL) provides hardware based power monitoring and limiting capabilities for various power domains including System, SoC, CPU clusters, GPU, and various other subsystems for glymur. Signed-off-by: Manaf Meethalavalappu Pallikunhi --- arch/arm64/boot/dts/qcom/glymur.dtsi | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/arch/arm64/boot/dts/qcom/glymur.dtsi b/arch/arm64/boot/dts/qco= m/glymur.dtsi index 72c7dc6e4f09..c0ba8740ae41 100644 --- a/arch/arm64/boot/dts/qcom/glymur.dtsi +++ b/arch/arm64/boot/dts/qcom/glymur.dtsi @@ -5033,6 +5033,16 @@ spmi_bus2: spmi@c48000 { }; }; =20 + power-controller@ef3b000 { + compatible =3D "qcom,spel"; + reg =3D <0x0 0x0ef3e000 0x0 0x1000>, + <0x0 0x0ef3d000 0x0 0x1000>, + <0x0 0x0ef3b000 0x0 0x1000>; + reg-names =3D "nodes", + "constraints", + "config"; + }; + tlmm: pinctrl@f100000 { compatible =3D "qcom,glymur-tlmm"; reg =3D <0x0 0x0f100000 0x0 0xf00000>; --=20 2.43.0