From aedd024e0b74fbeb175d38b8ee9e9641fcc0b1dc Mon Sep 17 00:00:00 2001 From: Diljit Singh Date: Sat, 21 Nov 2026 15:16:47 -0500 Subject: [PATCH] PCI: apple: hold T6050 PCIe-C power domain across s2idle On T6050 PCIe-C tunnel hosts, the ps_atcN_pcie power domain is not always-on (power_retained is false) and the sibling DART is bound as cio_dart for native CIO sleep transactions. During suspend-to-idle (PM_SUSPEND_TO_IDLE), the NHI leaves the tunnel running and does not start a CIO sleep transaction, expecting the host to keep its link via apple_pcie_keep_link(). Because t6050_pciec_hw omitted .s2idle_hold_domain = true (unlike t8132_pciec_hw and t6040_pciec_hw), apple_pcie_keep_link() returned false without holding the domain, causing apple_pcie_suspend_noirq() to abort late with -EBUSY after endpoints had already entered D3hot. Set .s2idle_hold_domain = true on t6050_pciec_hw so s2idle vetoes GENPD_NOTIFY_PRE_OFF on ps_atcN_pcie and releases the hold on resume, leaving PM_SUSPEND_MEM (deep sleep) CIO transactions untouched. Factor the pre-suspend link-retention policy out of apple_pcie_keep_link() into apple_pcie_can_keep_link() (checking s2idle_keep_link, pm_suspend_no_platform(), kernel_init || tunnel_cold_init, !bus_stopped && !resume_failed, and power_retained || s2idle_hold_domain) and share it with apple_pcie_prepare() and apple_pcie_suspend_noirq(). That refuses early with -EBUSY before any endpoint suspends whenever a cio_dart host has no NHI sleep transaction and cannot retain its link, leaving only the domain hold and live link-health check to noirq. Extend tools/asahi/pciec-policy-tests.py to cover T6050 s2idle domain holding and release, deep-sleep pass-through, and every pre-suspend refusal term in apple_pcie_can_keep_link() / apple_pcie_prepare(), with negative controls. Signed-off-by: Diljit Singh --- drivers/pci/controller/pcie-apple.c | 30 ++- tools/asahi/pciec-policy-tests.py | 363 ++++++++++++++++++++++++++-- 2 files changed, 366 insertions(+), 27 deletions(-) diff --git a/drivers/pci/controller/pcie-apple.c b/drivers/pci/controller/pcie-apple.c index c74a796d21200..c4734309f231e 100644 --- a/drivers/pci/controller/pcie-apple.c +++ b/drivers/pci/controller/pcie-apple.c @@ -471,6 +471,7 @@ static const struct hw_info t6050_pciec_hw = { .no_port_reset = true, .msimap_by_vector = true, .mps_timers = true, + .s2idle_hold_domain = true, }; static const struct of_device_id apple_pcie_of_match[]; @@ -6634,6 +6635,23 @@ static int apple_pcie_hold_domains(struct apple_pcie *pcie) return ret; } +/* + * Pre-suspend policy shared with apple_pcie_prepare(): everything known before + * endpoints suspend, leaving only the domain hold and live link check to noirq. + */ +static bool apple_pcie_can_keep_link(const struct apple_pcie *pcie) +{ + if (!READ_ONCE(s2idle_keep_link) || !pm_suspend_no_platform()) + return false; + if (!(pcie->kernel_init || pcie->tunnel_cold_init)) + return false; + if (pcie->bus_stopped || pcie->resume_failed) + return false; + if (!pcie->power_retained && !pcie->hw->s2idle_hold_domain) + return false; + return true; +} + /* * In suspend-to-idle ACIO and the router links stay powered, so an up * tunnel can simply be left running. The functions below keep their state @@ -6646,15 +6664,9 @@ static bool apple_pcie_keep_link(struct apple_pcie *pcie) { int ret; - if (!READ_ONCE(s2idle_keep_link) || !pm_suspend_no_platform()) - return false; - if (!(pcie->kernel_init || pcie->tunnel_cold_init)) - return false; - if (pcie->bus_stopped || pcie->resume_failed) + if (!apple_pcie_can_keep_link(pcie)) return false; if (!pcie->power_retained) { - if (!pcie->hw->s2idle_hold_domain) - return false; ret = apple_pcie_hold_domains(pcie); if (ret) { dev_dbg(pcie->dev, "PCIe-C power domain not held (%d): link not kept\n", @@ -6804,7 +6816,7 @@ static int apple_pcie_suspend_noirq(struct device *dev) if (pcie->cio_prepared) return apple_pcie_cio_suspend(pcie); /* The reversed DART link is safe only with retained clocks or native PM. */ - if (pcie->cio_dart && (!pm_suspend_no_platform() || !s2idle_keep_link)) + if (pcie->cio_dart && !apple_pcie_can_keep_link(pcie)) return -EBUSY; if (pcie->neo_sleep_armed) { struct apple_pcie_port *port; @@ -7467,7 +7479,7 @@ static int apple_pcie_prepare(struct device *dev) */ if (pcie && pcie->cio_dart && !pcie->cio_prepared && pm_suspend_target_state != PM_SUSPEND_ON && - (!pm_suspend_no_platform() || !s2idle_keep_link)) { + !apple_pcie_can_keep_link(pcie)) { dev_warn(dev, "no CIO sleep transaction from the NHI; refusing sleep\n"); return -EBUSY; } diff --git a/tools/asahi/pciec-policy-tests.py b/tools/asahi/pciec-policy-tests.py index a5a8fb96e143d..ef1c5d8836c4c 100644 --- a/tools/asahi/pciec-policy-tests.py +++ b/tools/asahi/pciec-policy-tests.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # SPDX-License-Identifier: GPL-2.0-only OR MIT -"""Exercise PCIe-C cold-init admission and ACIO admission using production C.""" +"""Exercise PCIe-C admission and s2idle domain-hold policy using production C.""" import argparse from pathlib import Path import re @@ -11,7 +11,8 @@ def function(source, name): - start = re.search(r'^(?:static\s+)?bool\s+' + name + r'\(', source, re.M).start() + start = re.search(r'^(?:static\s+)?(?:bool|int|void)\s+' + name + r'\(', + source, re.M).start() end = source.index('{', start) + 1 depth = 1 while depth: @@ -137,6 +138,293 @@ def function(source, name): } ''' +S2IDLE_FIXTURE = r''' +#include +#include +#include +#include +#include +#include +#include +typedef uint32_t u32; +#define BIT(n) (1U << (n)) +#define GENMASK(h, l) ((~0U << (l)) & (~0U >> (31 - (h)))) +#define READ_ONCE(x) (x) +#define container_of(ptr, type, member) \ + ((type *)((char *)(ptr) - offsetof(type, member))) +#define NOTIFY_OK 0x0001 +#define NOTIFY_STOP_MASK 0x8000 +#define GENPD_NOTIFY_PRE_OFF 0 +#define GENPD_NOTIFY_ON 1 +#define PM_SUSPEND_ON 0 +#define PM_SUSPEND_TO_IDLE 1 +#define PM_SUSPEND_MEM 3 +static inline int notifier_from_errno(int err) +{ + return err ? (NOTIFY_STOP_MASK | (NOTIFY_OK - err)) : NOTIFY_OK; +} +static inline int notifier_to_errno(int ret) +{ + ret &= ~NOTIFY_STOP_MASK; + return ret > NOTIFY_OK ? NOTIFY_OK - ret : 0; +} +struct of_device_id { const char *compatible; const void *data; }; +struct notifier_block; +typedef int (*notifier_fn_t)(struct notifier_block *nb, + unsigned long action, void *data); +struct notifier_block { notifier_fn_t notifier_call; }; +struct device { + struct apple_pcie *pcie; + struct notifier_block *genpd_nb; + bool genpd_on; + int genpd_add_ret; + unsigned int add_calls, remove_calls; +}; +struct apple_pcie_pd { + struct device *dev; + struct notifier_block nb; + unsigned int vetoed; +}; +struct apple_dart_cio { int dummy; }; +struct hw_info; +struct apple_pcie { + struct device *dev; + const struct hw_info *hw; + bool power_retained, kernel_init, tunnel_cold_init; + bool bus_stopped, resume_failed, link_kept; + struct apple_pcie_pd *pds; + unsigned int num_pds, pd_held; + struct apple_dart_cio *cio_dart; + bool cio_prepared; +}; +static bool s2idle_keep_link = true; +static int pm_suspend_target_state = PM_SUSPEND_TO_IDLE; +static bool link_healthy = true; +static unsigned int radio_prepare_calls, warn_calls; +static bool pm_suspend_no_platform(void) +{ + return pm_suspend_target_state == PM_SUSPEND_TO_IDLE; +} +static struct apple_pcie *apple_pcie_lookup(struct device *dev) +{ + return dev ? dev->pcie : NULL; +} +static bool apple_pcie_tunnel_link_healthy(struct apple_pcie *pcie) +{ + (void)pcie; + return link_healthy; +} +static int apple_radio_prepare(struct device *dev) +{ + (void)dev; + radio_prepare_calls++; + return 0; +} +static int dev_pm_genpd_add_notifier(struct device *dev, + struct notifier_block *nb) +{ + dev->add_calls++; + if (dev->genpd_add_ret) + return dev->genpd_add_ret; + assert(!dev->genpd_nb); + dev->genpd_nb = nb; + return 0; +} +static int dev_pm_genpd_remove_notifier(struct device *dev) +{ + dev->remove_calls++; + assert(dev->genpd_nb != NULL); + dev->genpd_nb = NULL; + return 0; +} +static bool dev_pm_genpd_is_on(struct device *dev) { return dev->genpd_on; } +static inline void dev_dbg(struct device *dev, const char *fmt, ...) +{ + (void)dev; + (void)fmt; +} +static inline void dev_warn(struct device *dev, const char *fmt, ...) +{ + (void)dev; + (void)fmt; + warn_calls++; +} +/* PRODUCTION */ +static const struct hw_info *match_compat(const char *compat) +{ + for (const struct of_device_id *id = apple_pcie_of_match; + id->compatible; id++) + if (!strcmp(id->compatible, compat)) + return id->data; + return NULL; +} +static void reset_host(struct device *dev, struct apple_pcie *pcie, + struct apple_pcie_pd *pd, const struct hw_info *hw, + struct apple_dart_cio *cio_dart) +{ + memset(dev, 0, sizeof(*dev)); + memset(pcie, 0, sizeof(*pcie)); + memset(pd, 0, sizeof(*pd)); + dev->pcie = pcie; + dev->genpd_on = true; + pd->dev = dev; + pcie->dev = dev; + pcie->hw = hw; + pcie->kernel_init = true; + pcie->pds = pd; + pcie->num_pds = 1; + pcie->cio_dart = cio_dart; + s2idle_keep_link = true; + pm_suspend_target_state = PM_SUSPEND_TO_IDLE; + link_healthy = true; + radio_prepare_calls = 0; + warn_calls = 0; +} +int main(void) +{ + struct apple_dart_cio cio_dart = { 1 }; + struct device dev; + struct apple_pcie pcie; + struct apple_pcie_pd pd; + const struct hw_info *t6050 = match_compat("apple,t6050-pciec"); + const struct hw_info *t8132 = match_compat("apple,t8132-pciec"); + const struct hw_info *t6040 = match_compat("apple,t6040-pciec"); + const struct hw_info *t8103 = match_compat("apple,t8103-pciec"); + int nret; + + /* T6050 PCIe-C opts into s2idle_hold_domain like T8132 and T6040. */ + assert(t6050 && t6050->tunneled && t6050->s2idle_hold_domain); + assert(t8132 && t8132->s2idle_hold_domain); + assert(t6040 && t6040->s2idle_hold_domain); + assert(t8103 && t8103->tunneled && !t8103->s2idle_hold_domain); + + /* Non-retained T6050 cio_dart host (tunnel_cold_init) holds domain in s2idle and releases. */ + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.kernel_init = false; + pcie.tunnel_cold_init = true; + assert(apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == 0); + assert(radio_prepare_calls == 1 && warn_calls == 0); + assert(apple_pcie_keep_link(&pcie)); + assert(pcie.pd_held == 1 && dev.genpd_nb == &pd.nb); + assert(dev.add_calls == 1 && dev.remove_calls == 0); + assert(dev.genpd_nb->notifier_call(dev.genpd_nb, GENPD_NOTIFY_ON, NULL) == NOTIFY_OK); + assert(pd.vetoed == 0); + nret = dev.genpd_nb->notifier_call(dev.genpd_nb, GENPD_NOTIFY_PRE_OFF, NULL); + assert(notifier_to_errno(nret) == -EBUSY && pd.vetoed == 1); + apple_pcie_release_domains(&pcie); + assert(pcie.pd_held == 0 && dev.genpd_nb == NULL && dev.remove_calls == 1); + + /* Non-retained T8132 cio_dart host (kernel_init) also passes prepare and holds domain. */ + reset_host(&dev, &pcie, &pd, t8132, &cio_dart); + assert(apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + assert(apple_pcie_keep_link(&pcie) && pcie.pd_held == 1 && dev.add_calls == 1); + apple_pcie_release_domains(&pcie); + assert(pcie.pd_held == 0 && dev.genpd_nb == NULL && dev.remove_calls == 1); + + /* Domain already off or unhealthy link passes prepare and cleans up notifier in keep_link. */ + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.kernel_init = false; + pcie.tunnel_cold_init = true; + dev.genpd_on = false; + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + assert(!apple_pcie_keep_link(&pcie)); + assert(pcie.pd_held == 0 && dev.genpd_nb == NULL && dev.remove_calls == 1); + + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.kernel_init = false; + pcie.tunnel_cold_init = true; + link_healthy = false; + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + assert(!apple_pcie_keep_link(&pcie)); + assert(pcie.pd_held == 0 && dev.genpd_nb == NULL && dev.remove_calls == 1); + + /* Deep sleep is untouched: unprepared refuses early, prepared passes without holding. */ + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pm_suspend_target_state = PM_SUSPEND_MEM; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + pcie.cio_prepared = true; + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.genpd_nb == NULL); + + /* PM_SUSPEND_ON (non-sleep) does not refuse in prepare even without cio_prepared. */ + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pm_suspend_target_state = PM_SUSPEND_ON; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + + /* Every pre-suspend refusal term in apple_pcie_can_keep_link() refuses early in prepare. */ + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + s2idle_keep_link = false; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.kernel_init = false; + pcie.tunnel_cold_init = false; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.bus_stopped = true; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + reset_host(&dev, &pcie, &pd, t6050, &cio_dart); + pcie.resume_failed = true; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + /* Non-retained cio_dart host without s2idle_hold_domain refuses early in prepare. */ + reset_host(&dev, &pcie, &pd, t8103, &cio_dart); + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == -EBUSY && radio_prepare_calls == 0 && warn_calls == 1); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + /* Non-cio_dart host is not refused in prepare (noirq falls back to stop_for_sleep). */ + reset_host(&dev, &pcie, &pd, t8103, NULL); + pcie.bus_stopped = true; + assert(!apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + assert(!apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + /* Retained power domain on a non-holding host passes prepare and keeps link without hold. */ + reset_host(&dev, &pcie, &pd, t8103, &cio_dart); + pcie.power_retained = true; + assert(apple_pcie_can_keep_link(&pcie)); + assert(apple_pcie_prepare(&dev) == 0 && radio_prepare_calls == 1 && warn_calls == 0); + assert(apple_pcie_keep_link(&pcie) && pcie.pd_held == 0 && dev.add_calls == 0); + + puts("PASS: T6050 PCIe-C s2idle domain hold, release, deep sleep and prepare refusal"); + return 0; +} +''' + + +def run_cases(out, cases, extra_flags=()): + for name, body in cases.items(): + source = out / (name + '.c') + source.write_text(body) + binary = out / name + subprocess.run(['cc', '-std=gnu11', '-Wall', '-Werror', + '-Wno-unused-function', *extra_flags, + str(source), '-o', str(binary)], check=True) + run = subprocess.run([str(binary)], capture_output=True, text=True) + (out / (name + '.log')).write_text(run.stdout + run.stderr) + if name.endswith('production'): + assert run.returncode == 0, run.stderr + print(run.stdout, end='') + else: + assert run.returncode < 0 and 'Assertion' in run.stderr, ( + name, run.returncode, run.stderr) + print('PASS negative control:', name) + def main(): parser = argparse.ArgumentParser() @@ -152,25 +440,64 @@ def main(): function(acio, 'apple_cio_pciec_eligible'), function(acio, 'apple_cio_pcie_tunnel_is_preinitialized'))) code = FIXTURE.replace('/* PRODUCTION */', production) + s2idle_prod = '\n'.join((defines, info, matches, + *(function(pci, n) for n in ( + 'apple_pcie_pd_notify', + 'apple_pcie_release_domains', + 'apple_pcie_hold_domains', + 'apple_pcie_can_keep_link', + 'apple_pcie_keep_link', + 'apple_pcie_prepare')))) + s2idle_code = S2IDLE_FIXTURE.replace('/* PRODUCTION */', s2idle_prod) + t6050_old = '\t.mps_timers\t\t= true,\n\t.s2idle_hold_domain\t= true,\n' + s2idle_muts = { + 'drop-t6050-hold': (t6050_old, '\t.mps_timers\t\t= true,\n'), + 'drop-prepare-guard': ( + 'pm_suspend_target_state != PM_SUSPEND_ON &&\n' + '\t !apple_pcie_can_keep_link(pcie)', + 'pm_suspend_target_state != PM_SUSPEND_ON &&\n\t false'), + 'drop-keep-link-param': ( + 'if (!READ_ONCE(s2idle_keep_link) || !pm_suspend_no_platform())', + 'if (!pm_suspend_no_platform())'), + 'drop-no-platform-check': ( + 'if (!READ_ONCE(s2idle_keep_link) || !pm_suspend_no_platform())', + 'if (!READ_ONCE(s2idle_keep_link))'), + 'drop-init-check': ( + 'if (!(pcie->kernel_init || pcie->tunnel_cold_init))', + 'if (false)'), + 'drop-bus-stopped-check': ( + 'if (pcie->bus_stopped || pcie->resume_failed)', + 'if (pcie->resume_failed)'), + 'drop-resume-failed-check': ( + 'if (pcie->bus_stopped || pcie->resume_failed)', + 'if (pcie->bus_stopped)'), + 'drop-domain-policy-check': ( + 'if (!pcie->power_retained && !pcie->hw->s2idle_hold_domain)', + 'if (false)'), + 'skip-domain-release': ( + 'dev_pm_genpd_remove_notifier(pd->dev);', '(void)pd;'), + 'ignore-domain-off': ( + 'if (!dev_pm_genpd_is_on(pd->dev)) {', 'if (false) {'), + } + s2idle_cases = {'s2idle-production': s2idle_code} + for name, (old, new) in s2idle_muts.items(): + assert s2idle_code.count(old) == 1, name + s2idle_cases[name] = s2idle_code.replace(old, new) with tempfile.TemporaryDirectory(prefix='pciec-policy-') as tmp: out = args.out or Path(tmp) out.mkdir(parents=True, exist_ok=True) - cases = {'production': code, - 'm2-fallback': code.replace('{ .compatible = "apple,t8112-pciec",\t.data = &t8112_pciec_hw },', ''), - 'dart-bypass': code.replace('tunables = of_property_present(iommu_spec.np, "apple,tunable");', 'tunables = true;')} - for name, body in cases.items(): - source = out / (name + '.c') - source.write_text(body) - binary = out / name - subprocess.run(['cc', '-std=gnu11', '-Wall', '-Werror', '-Wno-unused-function', str(source), '-o', str(binary)], check=True) - run = subprocess.run([str(binary)], capture_output=True, text=True) - (out / (name + '.log')).write_text(run.stdout + run.stderr) - if name == 'production': - assert run.returncode == 0, run.stderr - print(run.stdout, end='') - else: - assert run.returncode < 0 and 'Assertion' in run.stderr, (name, run.returncode, run.stderr) - print('PASS negative control:', name) + cases = { + 'production': code, + 'm2-fallback': code.replace( + '{ .compatible = "apple,t8112-pciec",\t.data = &t8112_pciec_hw },', ''), + 'dart-bypass': code.replace( + 'tunables = of_property_present(iommu_spec.np, "apple,tunable");', + 'tunables = true;'), + } + run_cases(out, cases) + run_cases(out, s2idle_cases, + extra_flags=('-Wextra', '-Wno-unused-parameter', '-g', + '-fsanitize=address,undefined')) if __name__ == '__main__':