From patchwork Thu Aug 4 23:04:59 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lina Iyer X-Patchwork-Id: 73334 Delivered-To: patch@linaro.org Received: by 10.140.29.52 with SMTP id a49csp1636976qga; Thu, 4 Aug 2016 16:06:27 -0700 (PDT) X-Received: by 10.98.201.138 with SMTP id l10mr129607807pfk.77.1470351967129; Thu, 04 Aug 2016 16:06:07 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id y80si16817659pfi.205.2016.08.04.16.06.06; Thu, 04 Aug 2016 16:06:07 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-arm-msm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-arm-msm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-arm-msm-owner@vger.kernel.org; dmarc=fail (p=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1759387AbcHDXGF (ORCPT + 8 others); Thu, 4 Aug 2016 19:06:05 -0400 Received: from mail-pf0-f181.google.com ([209.85.192.181]:35085 "EHLO mail-pf0-f181.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759368AbcHDXGD (ORCPT ); Thu, 4 Aug 2016 19:06:03 -0400 Received: by mail-pf0-f181.google.com with SMTP id x72so90843045pfd.2 for ; Thu, 04 Aug 2016 16:06:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=nnT5qAl5OQ7tS1IAgROWIzUIAR+4qh+/W+Xsq1Oc+Eo=; b=YN0IBrPQNvewHGWBUu+460rCP6dvKGBFvdG+D7LhUzphAf1QmR9BZv4FDn8PLnWUW7 7x/fH46Y/MwjK3ZmbZaoIqvvOQL7o0Acq5kddIC3clyuynGpW7cs9IJQvF8CyP9Vagwd pEyL+Q171eWkS0+ZqHKHBL9rCjFUbGZkqSdFI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=nnT5qAl5OQ7tS1IAgROWIzUIAR+4qh+/W+Xsq1Oc+Eo=; b=FnmX5O2hweeYpJ+VtBYrjYUjke4QUutx+ybWYuD4MtMUFae8AO2JhJY0I5/jKJ9p2U OYXFmEXfoG8RarQeh4E1IvBn+PnMYiG7L1RjDCfSf6h7ccuL/Zi4iFdcJYuQGRww07+e fglisJkJYurq8ALmSCNSO8Gh6evyZ1MGOALb/WZViClRJigLjTCgVSn8LmIl20clCng5 l9Rq2sEjwA2dgWowqa4BzvNjTyZGCkb5JF7AqBqKFVlvF5rqdVUp392VC/WwVztu831H XRG3ALcu3pZ8Egrz+NMuBC9PP9RDNFMH/FnCw0DTCzLdkMY0xPI7wwEteT8mDSrPp/hP DLvw== X-Gm-Message-State: AEkoouu+v+mS7duJyqqIWIWKUZgNzG0XyenbGchxWRmccDA6s+DXljaUXC1WCgB+B8/ZkxCY X-Received: by 10.98.133.10 with SMTP id u10mr112241841pfd.134.1470351962552; Thu, 04 Aug 2016 16:06:02 -0700 (PDT) Received: from ubuntu.localdomain (i-global254.qualcomm.com. [199.106.103.254]) by smtp.gmail.com with ESMTPSA id x66sm22736214pfb.86.2016.08.04.16.06.00 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 04 Aug 2016 16:06:01 -0700 (PDT) From: Lina Iyer To: ulf.hansson@linaro.org, khilman@kernel.org, rjw@rjwysocki.net, linux-pm@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: andy.gross@linaro.org, sboyd@codeaurora.org, linux-arm-msm@vger.kernel.org, Lina Iyer , Lorenzo Pieralisi , Mark Rutland Subject: [PATCH v3 12/15] drivers: firmware: psci: Support cluster idle states for OS-Initiated Date: Thu, 4 Aug 2016 17:04:59 -0600 Message-Id: <1470351902-43103-13-git-send-email-lina.iyer@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1470351902-43103-1-git-send-email-lina.iyer@linaro.org> References: <1470351902-43103-1-git-send-email-lina.iyer@linaro.org> Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org PSCI OS initiated firmware may allow Linux to determine the state of the CPU cluster and the cluster at coherency level to enter idle states when there are no active CPUs. Since Linux has a better idea of the QoS and the wakeup pattern of the CPUs, the cluster idle states may be better determined by the OS instead of the firmware. The last CPU entering idle in a cluster, is responsible for selecting the state of the cluster. Only one CPU in a cluster may provide the cluster idle state to the firmware. Similarly, the last CPU in the system may provide the state of the coherency domain along with the cluster and the CPU state IDs. Utilize the CPU PM domain framework's helper functions to build up the hierarchy of cluster topology using Generic PM domains. We provide callbacks for domain power_on and power_off. By appending the state IDs at each domain level in the -power_off() callbacks, we build up a composite state ID that can be passed onto the firmware to idle the CPU, the cluster and the coherency interface. Cc: Lorenzo Pieralisi Cc: Mark Rutland Signed-off-by: Lina Iyer --- drivers/firmware/psci.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 86 insertions(+), 3 deletions(-) -- 2.7.4 -- To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/drivers/firmware/psci.c b/drivers/firmware/psci.c index 3920aba..3a1e5a7 100644 --- a/drivers/firmware/psci.c +++ b/drivers/firmware/psci.c @@ -15,6 +15,7 @@ #include #include +#include #include #include #include @@ -53,6 +54,17 @@ */ static int resident_cpu = -1; static bool psci_has_osi_pd; +static DEFINE_PER_CPU(u32, cluster_state_id); + +static inline u32 psci_get_composite_state_id(u32 cpu_state) +{ + return cpu_state | this_cpu_read(cluster_state_id); +} + +static inline void psci_reset_composite_state_id(void) +{ + this_cpu_write(cluster_state_id, 0); +} bool psci_tos_resident_on(int cpu) { @@ -179,6 +191,8 @@ static int psci_cpu_on(unsigned long cpuid, unsigned long entry_point) fn = psci_function_id[PSCI_FN_CPU_ON]; err = invoke_psci_fn(fn, cpuid, entry_point, 0); + /* Reset CPU cluster states */ + psci_reset_composite_state_id(); return psci_to_linux_errno(err); } @@ -250,6 +264,52 @@ static int __init psci_features(u32 psci_func_id) #ifdef CONFIG_CPU_IDLE static DEFINE_PER_CPU_READ_MOSTLY(u32 *, psci_power_state); +static bool psci_suspend_mode_is_osi; + +static int psci_set_suspend_mode_osi(bool enable) +{ + int ret; + int mode; + + if (enable && !psci_has_osi_pd) + return -ENODEV; + + if (enable == psci_suspend_mode_is_osi) + return 0; + + mode = enable ? PSCI_1_0_SUSPEND_MODE_OSI : PSCI_1_0_SUSPEND_MODE_PC; + ret = invoke_psci_fn(PSCI_1_0_FN_SET_SUSPEND_MODE, + mode, 0, 0); + if (!ret) + psci_suspend_mode_is_osi = enable; + + return psci_to_linux_errno(ret); +} + +static const struct of_device_id psci_osi_match[] = { + { .compatible = "arm,psci-1.0", }, + {}, +}; + +static int psci_pd_populate_state_data(struct device_node *np, u32 *param) +{ + struct device_node *dn = of_get_next_parent(np); + + /* Check if we are inside in the psci node */ + for (; dn; dn = of_get_next_parent(dn)) + if (of_match_node(psci_osi_match, dn)) + return of_property_read_u32(np, + "arm,psci-suspend-param", param); + + return -EINVAL; +} + +static int psci_pd_power_off(u32 state_idx, u32 param, + const struct cpumask *mask) +{ + __this_cpu_add(cluster_state_id, param); + return 0; +} static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu) { @@ -304,6 +364,21 @@ static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu) } /* Idle states parsed correctly, initialize per-cpu pointer */ per_cpu(psci_power_state, cpu) = psci_states; + + if (psci_has_osi_pd) { + int ret; + const struct cpu_pd_ops psci_pd_ops = { + .populate_state_data = psci_pd_populate_state_data, + .power_off = psci_pd_power_off, + }; + + ret = of_setup_cpu_pd_single(cpu, &psci_pd_ops); + if (!ret) + ret = psci_set_suspend_mode_osi(true); + if (ret) + pr_warn("CPU%d: Error setting PSCI OSI mode\n", cpu); + } + return 0; free_mem: @@ -330,15 +405,17 @@ int psci_cpu_init_idle(unsigned int cpu) static int psci_suspend_finisher(unsigned long index) { u32 *state = __this_cpu_read(psci_power_state); + u32 ext_state = psci_get_composite_state_id(state[index - 1]); - return psci_ops.cpu_suspend(state[index - 1], - virt_to_phys(cpu_resume)); + return psci_ops.cpu_suspend(ext_state, virt_to_phys(cpu_resume)); } int psci_cpu_suspend_enter(unsigned long index) { int ret; u32 *state = __this_cpu_read(psci_power_state); + u32 ext_state = psci_get_composite_state_id(state[index - 1]); + /* * idle state index 0 corresponds to wfi, should never be called * from the cpu_suspend operations @@ -347,10 +424,16 @@ int psci_cpu_suspend_enter(unsigned long index) return -EINVAL; if (!psci_power_state_loses_context(state[index - 1])) - ret = psci_ops.cpu_suspend(state[index - 1], 0); + ret = psci_ops.cpu_suspend(ext_state, 0); else ret = cpu_suspend(index, psci_suspend_finisher); + /* + * Clear the CPU's cluster states, we start afresh after coming + * out of idle. + */ + psci_reset_composite_state_id(); + return ret; }