1f721889fSRafael J. Wysocki /* 2f721889fSRafael J. Wysocki * drivers/base/power/domain.c - Common code related to device power domains. 3f721889fSRafael J. Wysocki * 4f721889fSRafael J. Wysocki * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. 5f721889fSRafael J. Wysocki * 6f721889fSRafael J. Wysocki * This file is released under the GPLv2. 7f721889fSRafael J. Wysocki */ 8f721889fSRafael J. Wysocki 993af5e93SGeert Uytterhoeven #include <linux/delay.h> 10f721889fSRafael J. Wysocki #include <linux/kernel.h> 11f721889fSRafael J. Wysocki #include <linux/io.h> 12aa42240aSTomasz Figa #include <linux/platform_device.h> 136a0ae73dSViresh Kumar #include <linux/pm_opp.h> 14f721889fSRafael J. Wysocki #include <linux/pm_runtime.h> 15f721889fSRafael J. Wysocki #include <linux/pm_domain.h> 166ff7bb0dSRafael J. Wysocki #include <linux/pm_qos.h> 17c11f6f5bSUlf Hansson #include <linux/pm_clock.h> 18f721889fSRafael J. Wysocki #include <linux/slab.h> 19f721889fSRafael J. Wysocki #include <linux/err.h> 2017b75ecaSRafael J. Wysocki #include <linux/sched.h> 2117b75ecaSRafael J. Wysocki #include <linux/suspend.h> 22d5e4cbfeSRafael J. Wysocki #include <linux/export.h> 23d5e4cbfeSRafael J. Wysocki 24aa8e54b5STomeu Vizoso #include "power.h" 25aa8e54b5STomeu Vizoso 2693af5e93SGeert Uytterhoeven #define GENPD_RETRY_MAX_MS 250 /* Approximate */ 2793af5e93SGeert Uytterhoeven 28d5e4cbfeSRafael J. Wysocki #define GENPD_DEV_CALLBACK(genpd, type, callback, dev) \ 29d5e4cbfeSRafael J. Wysocki ({ \ 30d5e4cbfeSRafael J. Wysocki type (*__routine)(struct device *__d); \ 31d5e4cbfeSRafael J. Wysocki type __ret = (type)0; \ 32d5e4cbfeSRafael J. Wysocki \ 33d5e4cbfeSRafael J. Wysocki __routine = genpd->dev_ops.callback; \ 34d5e4cbfeSRafael J. Wysocki if (__routine) { \ 35d5e4cbfeSRafael J. Wysocki __ret = __routine(dev); \ 36d5e4cbfeSRafael J. Wysocki } \ 37d5e4cbfeSRafael J. Wysocki __ret; \ 38d5e4cbfeSRafael J. Wysocki }) 39f721889fSRafael J. Wysocki 405125bbf3SRafael J. Wysocki static LIST_HEAD(gpd_list); 415125bbf3SRafael J. Wysocki static DEFINE_MUTEX(gpd_list_lock); 425125bbf3SRafael J. Wysocki 4335241d12SLina Iyer struct genpd_lock_ops { 4435241d12SLina Iyer void (*lock)(struct generic_pm_domain *genpd); 4535241d12SLina Iyer void (*lock_nested)(struct generic_pm_domain *genpd, int depth); 4635241d12SLina Iyer int (*lock_interruptible)(struct generic_pm_domain *genpd); 4735241d12SLina Iyer void (*unlock)(struct generic_pm_domain *genpd); 4835241d12SLina Iyer }; 4935241d12SLina Iyer 5035241d12SLina Iyer static void genpd_lock_mtx(struct generic_pm_domain *genpd) 5135241d12SLina Iyer { 5235241d12SLina Iyer mutex_lock(&genpd->mlock); 5335241d12SLina Iyer } 5435241d12SLina Iyer 5535241d12SLina Iyer static void genpd_lock_nested_mtx(struct generic_pm_domain *genpd, 5635241d12SLina Iyer int depth) 5735241d12SLina Iyer { 5835241d12SLina Iyer mutex_lock_nested(&genpd->mlock, depth); 5935241d12SLina Iyer } 6035241d12SLina Iyer 6135241d12SLina Iyer static int genpd_lock_interruptible_mtx(struct generic_pm_domain *genpd) 6235241d12SLina Iyer { 6335241d12SLina Iyer return mutex_lock_interruptible(&genpd->mlock); 6435241d12SLina Iyer } 6535241d12SLina Iyer 6635241d12SLina Iyer static void genpd_unlock_mtx(struct generic_pm_domain *genpd) 6735241d12SLina Iyer { 6835241d12SLina Iyer return mutex_unlock(&genpd->mlock); 6935241d12SLina Iyer } 7035241d12SLina Iyer 7135241d12SLina Iyer static const struct genpd_lock_ops genpd_mtx_ops = { 7235241d12SLina Iyer .lock = genpd_lock_mtx, 7335241d12SLina Iyer .lock_nested = genpd_lock_nested_mtx, 7435241d12SLina Iyer .lock_interruptible = genpd_lock_interruptible_mtx, 7535241d12SLina Iyer .unlock = genpd_unlock_mtx, 7635241d12SLina Iyer }; 7735241d12SLina Iyer 78d716f479SLina Iyer static void genpd_lock_spin(struct generic_pm_domain *genpd) 79d716f479SLina Iyer __acquires(&genpd->slock) 80d716f479SLina Iyer { 81d716f479SLina Iyer unsigned long flags; 82d716f479SLina Iyer 83d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 84d716f479SLina Iyer genpd->lock_flags = flags; 85d716f479SLina Iyer } 86d716f479SLina Iyer 87d716f479SLina Iyer static void genpd_lock_nested_spin(struct generic_pm_domain *genpd, 88d716f479SLina Iyer int depth) 89d716f479SLina Iyer __acquires(&genpd->slock) 90d716f479SLina Iyer { 91d716f479SLina Iyer unsigned long flags; 92d716f479SLina Iyer 93d716f479SLina Iyer spin_lock_irqsave_nested(&genpd->slock, flags, depth); 94d716f479SLina Iyer genpd->lock_flags = flags; 95d716f479SLina Iyer } 96d716f479SLina Iyer 97d716f479SLina Iyer static int genpd_lock_interruptible_spin(struct generic_pm_domain *genpd) 98d716f479SLina Iyer __acquires(&genpd->slock) 99d716f479SLina Iyer { 100d716f479SLina Iyer unsigned long flags; 101d716f479SLina Iyer 102d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 103d716f479SLina Iyer genpd->lock_flags = flags; 104d716f479SLina Iyer return 0; 105d716f479SLina Iyer } 106d716f479SLina Iyer 107d716f479SLina Iyer static void genpd_unlock_spin(struct generic_pm_domain *genpd) 108d716f479SLina Iyer __releases(&genpd->slock) 109d716f479SLina Iyer { 110d716f479SLina Iyer spin_unlock_irqrestore(&genpd->slock, genpd->lock_flags); 111d716f479SLina Iyer } 112d716f479SLina Iyer 113d716f479SLina Iyer static const struct genpd_lock_ops genpd_spin_ops = { 114d716f479SLina Iyer .lock = genpd_lock_spin, 115d716f479SLina Iyer .lock_nested = genpd_lock_nested_spin, 116d716f479SLina Iyer .lock_interruptible = genpd_lock_interruptible_spin, 117d716f479SLina Iyer .unlock = genpd_unlock_spin, 118d716f479SLina Iyer }; 119d716f479SLina Iyer 12035241d12SLina Iyer #define genpd_lock(p) p->lock_ops->lock(p) 12135241d12SLina Iyer #define genpd_lock_nested(p, d) p->lock_ops->lock_nested(p, d) 12235241d12SLina Iyer #define genpd_lock_interruptible(p) p->lock_ops->lock_interruptible(p) 12335241d12SLina Iyer #define genpd_unlock(p) p->lock_ops->unlock(p) 12435241d12SLina Iyer 12541e2c8e0SUlf Hansson #define genpd_status_on(genpd) (genpd->status == GPD_STATE_ACTIVE) 126d716f479SLina Iyer #define genpd_is_irq_safe(genpd) (genpd->flags & GENPD_FLAG_IRQ_SAFE) 127ffaa42e8SUlf Hansson #define genpd_is_always_on(genpd) (genpd->flags & GENPD_FLAG_ALWAYS_ON) 12895a20ef6SGeert Uytterhoeven #define genpd_is_active_wakeup(genpd) (genpd->flags & GENPD_FLAG_ACTIVE_WAKEUP) 129d716f479SLina Iyer 130d716f479SLina Iyer static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev, 131d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 132d716f479SLina Iyer { 133d716f479SLina Iyer bool ret; 134d716f479SLina Iyer 135d716f479SLina Iyer ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd); 136d716f479SLina Iyer 137075c37d5SUlf Hansson /* 138075c37d5SUlf Hansson * Warn once if an IRQ safe device is attached to a no sleep domain, as 139075c37d5SUlf Hansson * to indicate a suboptimal configuration for PM. For an always on 140075c37d5SUlf Hansson * domain this isn't case, thus don't warn. 141075c37d5SUlf Hansson */ 142075c37d5SUlf Hansson if (ret && !genpd_is_always_on(genpd)) 143d716f479SLina Iyer dev_warn_once(dev, "PM domain %s will not be powered off\n", 144d716f479SLina Iyer genpd->name); 145d716f479SLina Iyer 146d716f479SLina Iyer return ret; 147d716f479SLina Iyer } 148d716f479SLina Iyer 149446d999cSRussell King /* 150446d999cSRussell King * Get the generic PM domain for a particular struct device. 151446d999cSRussell King * This validates the struct device pointer, the PM domain pointer, 152446d999cSRussell King * and checks that the PM domain pointer is a real generic PM domain. 153446d999cSRussell King * Any failure results in NULL being returned. 154446d999cSRussell King */ 155f58d4e5aSJon Hunter static struct generic_pm_domain *genpd_lookup_dev(struct device *dev) 156446d999cSRussell King { 157446d999cSRussell King struct generic_pm_domain *genpd = NULL, *gpd; 158446d999cSRussell King 159446d999cSRussell King if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain)) 160446d999cSRussell King return NULL; 161446d999cSRussell King 162446d999cSRussell King mutex_lock(&gpd_list_lock); 163446d999cSRussell King list_for_each_entry(gpd, &gpd_list, gpd_list_node) { 164446d999cSRussell King if (&gpd->domain == dev->pm_domain) { 165446d999cSRussell King genpd = gpd; 166446d999cSRussell King break; 167446d999cSRussell King } 168446d999cSRussell King } 169446d999cSRussell King mutex_unlock(&gpd_list_lock); 170446d999cSRussell King 171446d999cSRussell King return genpd; 172446d999cSRussell King } 173446d999cSRussell King 174446d999cSRussell King /* 175446d999cSRussell King * This should only be used where we are certain that the pm_domain 176446d999cSRussell King * attached to the device is a genpd domain. 177446d999cSRussell King */ 178446d999cSRussell King static struct generic_pm_domain *dev_to_genpd(struct device *dev) 1795248051bSRafael J. Wysocki { 1805248051bSRafael J. Wysocki if (IS_ERR_OR_NULL(dev->pm_domain)) 1815248051bSRafael J. Wysocki return ERR_PTR(-EINVAL); 1825248051bSRafael J. Wysocki 183596ba34bSRafael J. Wysocki return pd_to_genpd(dev->pm_domain); 1845248051bSRafael J. Wysocki } 185f721889fSRafael J. Wysocki 186d8600c8bSKrzysztof Kozlowski static int genpd_stop_dev(const struct generic_pm_domain *genpd, 187d8600c8bSKrzysztof Kozlowski struct device *dev) 188d5e4cbfeSRafael J. Wysocki { 18951cda844SUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, stop, dev); 190d5e4cbfeSRafael J. Wysocki } 191d5e4cbfeSRafael J. Wysocki 192d8600c8bSKrzysztof Kozlowski static int genpd_start_dev(const struct generic_pm_domain *genpd, 193d8600c8bSKrzysztof Kozlowski struct device *dev) 194d5e4cbfeSRafael J. Wysocki { 195ba2bbfbfSUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, start, dev); 196d5e4cbfeSRafael J. Wysocki } 197d5e4cbfeSRafael J. Wysocki 198c4bb3160SRafael J. Wysocki static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd) 199f721889fSRafael J. Wysocki { 200c4bb3160SRafael J. Wysocki bool ret = false; 201c4bb3160SRafael J. Wysocki 202c4bb3160SRafael J. Wysocki if (!WARN_ON(atomic_read(&genpd->sd_count) == 0)) 203c4bb3160SRafael J. Wysocki ret = !!atomic_dec_and_test(&genpd->sd_count); 204c4bb3160SRafael J. Wysocki 205c4bb3160SRafael J. Wysocki return ret; 206c4bb3160SRafael J. Wysocki } 207c4bb3160SRafael J. Wysocki 208c4bb3160SRafael J. Wysocki static void genpd_sd_counter_inc(struct generic_pm_domain *genpd) 209c4bb3160SRafael J. Wysocki { 210c4bb3160SRafael J. Wysocki atomic_inc(&genpd->sd_count); 2114e857c58SPeter Zijlstra smp_mb__after_atomic(); 212f721889fSRafael J. Wysocki } 213f721889fSRafael J. Wysocki 214afece3abSThara Gopinath #ifdef CONFIG_DEBUG_FS 215afece3abSThara Gopinath static void genpd_update_accounting(struct generic_pm_domain *genpd) 216afece3abSThara Gopinath { 217afece3abSThara Gopinath ktime_t delta, now; 218afece3abSThara Gopinath 219afece3abSThara Gopinath now = ktime_get(); 220afece3abSThara Gopinath delta = ktime_sub(now, genpd->accounting_time); 221afece3abSThara Gopinath 222afece3abSThara Gopinath /* 223afece3abSThara Gopinath * If genpd->status is active, it means we are just 224afece3abSThara Gopinath * out of off and so update the idle time and vice 225afece3abSThara Gopinath * versa. 226afece3abSThara Gopinath */ 227afece3abSThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) { 228afece3abSThara Gopinath int state_idx = genpd->state_idx; 229afece3abSThara Gopinath 230afece3abSThara Gopinath genpd->states[state_idx].idle_time = 231afece3abSThara Gopinath ktime_add(genpd->states[state_idx].idle_time, delta); 232afece3abSThara Gopinath } else { 233afece3abSThara Gopinath genpd->on_time = ktime_add(genpd->on_time, delta); 234afece3abSThara Gopinath } 235afece3abSThara Gopinath 236afece3abSThara Gopinath genpd->accounting_time = now; 237afece3abSThara Gopinath } 238afece3abSThara Gopinath #else 239afece3abSThara Gopinath static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {} 240afece3abSThara Gopinath #endif 241afece3abSThara Gopinath 24242f6284aSViresh Kumar /** 24342f6284aSViresh Kumar * dev_pm_genpd_set_performance_state- Set performance state of device's power 24442f6284aSViresh Kumar * domain. 24542f6284aSViresh Kumar * 24642f6284aSViresh Kumar * @dev: Device for which the performance-state needs to be set. 24742f6284aSViresh Kumar * @state: Target performance state of the device. This can be set as 0 when the 24842f6284aSViresh Kumar * device doesn't have any performance state constraints left (And so 24942f6284aSViresh Kumar * the device wouldn't participate anymore to find the target 25042f6284aSViresh Kumar * performance state of the genpd). 25142f6284aSViresh Kumar * 25242f6284aSViresh Kumar * It is assumed that the users guarantee that the genpd wouldn't be detached 25342f6284aSViresh Kumar * while this routine is getting called. 25442f6284aSViresh Kumar * 25542f6284aSViresh Kumar * Returns 0 on success and negative error values on failures. 25642f6284aSViresh Kumar */ 25742f6284aSViresh Kumar int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state) 25842f6284aSViresh Kumar { 25942f6284aSViresh Kumar struct generic_pm_domain *genpd; 26042f6284aSViresh Kumar struct generic_pm_domain_data *gpd_data, *pd_data; 26142f6284aSViresh Kumar struct pm_domain_data *pdd; 26242f6284aSViresh Kumar unsigned int prev; 26342f6284aSViresh Kumar int ret = 0; 26442f6284aSViresh Kumar 26542f6284aSViresh Kumar genpd = dev_to_genpd(dev); 26642f6284aSViresh Kumar if (IS_ERR(genpd)) 26742f6284aSViresh Kumar return -ENODEV; 26842f6284aSViresh Kumar 26942f6284aSViresh Kumar if (unlikely(!genpd->set_performance_state)) 27042f6284aSViresh Kumar return -EINVAL; 27142f6284aSViresh Kumar 27242f6284aSViresh Kumar if (unlikely(!dev->power.subsys_data || 27342f6284aSViresh Kumar !dev->power.subsys_data->domain_data)) { 27442f6284aSViresh Kumar WARN_ON(1); 27542f6284aSViresh Kumar return -EINVAL; 27642f6284aSViresh Kumar } 27742f6284aSViresh Kumar 27842f6284aSViresh Kumar genpd_lock(genpd); 27942f6284aSViresh Kumar 28042f6284aSViresh Kumar gpd_data = to_gpd_data(dev->power.subsys_data->domain_data); 28142f6284aSViresh Kumar prev = gpd_data->performance_state; 28242f6284aSViresh Kumar gpd_data->performance_state = state; 28342f6284aSViresh Kumar 28442f6284aSViresh Kumar /* New requested state is same as Max requested state */ 28542f6284aSViresh Kumar if (state == genpd->performance_state) 28642f6284aSViresh Kumar goto unlock; 28742f6284aSViresh Kumar 28842f6284aSViresh Kumar /* New requested state is higher than Max requested state */ 28942f6284aSViresh Kumar if (state > genpd->performance_state) 29042f6284aSViresh Kumar goto update_state; 29142f6284aSViresh Kumar 29242f6284aSViresh Kumar /* Traverse all devices within the domain */ 29342f6284aSViresh Kumar list_for_each_entry(pdd, &genpd->dev_list, list_node) { 29442f6284aSViresh Kumar pd_data = to_gpd_data(pdd); 29542f6284aSViresh Kumar 29642f6284aSViresh Kumar if (pd_data->performance_state > state) 29742f6284aSViresh Kumar state = pd_data->performance_state; 29842f6284aSViresh Kumar } 29942f6284aSViresh Kumar 30042f6284aSViresh Kumar if (state == genpd->performance_state) 30142f6284aSViresh Kumar goto unlock; 30242f6284aSViresh Kumar 30342f6284aSViresh Kumar /* 30442f6284aSViresh Kumar * We aren't propagating performance state changes of a subdomain to its 30542f6284aSViresh Kumar * masters as we don't have hardware that needs it. Over that, the 30642f6284aSViresh Kumar * performance states of subdomain and its masters may not have 30742f6284aSViresh Kumar * one-to-one mapping and would require additional information. We can 30842f6284aSViresh Kumar * get back to this once we have hardware that needs it. For that 30942f6284aSViresh Kumar * reason, we don't have to consider performance state of the subdomains 31042f6284aSViresh Kumar * of genpd here. 31142f6284aSViresh Kumar */ 31242f6284aSViresh Kumar 31342f6284aSViresh Kumar update_state: 31442f6284aSViresh Kumar if (genpd_status_on(genpd)) { 31542f6284aSViresh Kumar ret = genpd->set_performance_state(genpd, state); 31642f6284aSViresh Kumar if (ret) { 31742f6284aSViresh Kumar gpd_data->performance_state = prev; 31842f6284aSViresh Kumar goto unlock; 31942f6284aSViresh Kumar } 32042f6284aSViresh Kumar } 32142f6284aSViresh Kumar 32242f6284aSViresh Kumar genpd->performance_state = state; 32342f6284aSViresh Kumar 32442f6284aSViresh Kumar unlock: 32542f6284aSViresh Kumar genpd_unlock(genpd); 32642f6284aSViresh Kumar 32742f6284aSViresh Kumar return ret; 32842f6284aSViresh Kumar } 32942f6284aSViresh Kumar EXPORT_SYMBOL_GPL(dev_pm_genpd_set_performance_state); 33042f6284aSViresh Kumar 33186e12eacSUlf Hansson static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) 332c8f0ea45SGeert Uytterhoeven { 333fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 334c8f0ea45SGeert Uytterhoeven ktime_t time_start; 335c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 336c8f0ea45SGeert Uytterhoeven int ret; 337c8f0ea45SGeert Uytterhoeven 338c8f0ea45SGeert Uytterhoeven if (!genpd->power_on) 339c8f0ea45SGeert Uytterhoeven return 0; 340c8f0ea45SGeert Uytterhoeven 341a4630c61SGeert Uytterhoeven if (!timed) 342a4630c61SGeert Uytterhoeven return genpd->power_on(genpd); 343a4630c61SGeert Uytterhoeven 344c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 345c8f0ea45SGeert Uytterhoeven ret = genpd->power_on(genpd); 346c8f0ea45SGeert Uytterhoeven if (ret) 347c8f0ea45SGeert Uytterhoeven return ret; 348c8f0ea45SGeert Uytterhoeven 349c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 35042f6284aSViresh Kumar 35142f6284aSViresh Kumar if (unlikely(genpd->set_performance_state)) { 35242f6284aSViresh Kumar ret = genpd->set_performance_state(genpd, genpd->performance_state); 35342f6284aSViresh Kumar if (ret) { 35442f6284aSViresh Kumar pr_warn("%s: Failed to set performance state %d (%d)\n", 35542f6284aSViresh Kumar genpd->name, genpd->performance_state, ret); 35642f6284aSViresh Kumar } 35742f6284aSViresh Kumar } 35842f6284aSViresh Kumar 359fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_on_latency_ns) 360c8f0ea45SGeert Uytterhoeven return ret; 361c8f0ea45SGeert Uytterhoeven 362fc5cbf0cSAxel Haslam genpd->states[state_idx].power_on_latency_ns = elapsed_ns; 363c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 3646d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 365c8f0ea45SGeert Uytterhoeven genpd->name, "on", elapsed_ns); 366c8f0ea45SGeert Uytterhoeven 367c8f0ea45SGeert Uytterhoeven return ret; 368c8f0ea45SGeert Uytterhoeven } 369c8f0ea45SGeert Uytterhoeven 37086e12eacSUlf Hansson static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed) 371c8f0ea45SGeert Uytterhoeven { 372fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 373c8f0ea45SGeert Uytterhoeven ktime_t time_start; 374c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 375c8f0ea45SGeert Uytterhoeven int ret; 376c8f0ea45SGeert Uytterhoeven 377c8f0ea45SGeert Uytterhoeven if (!genpd->power_off) 378c8f0ea45SGeert Uytterhoeven return 0; 379c8f0ea45SGeert Uytterhoeven 380a4630c61SGeert Uytterhoeven if (!timed) 381a4630c61SGeert Uytterhoeven return genpd->power_off(genpd); 382a4630c61SGeert Uytterhoeven 383c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 384c8f0ea45SGeert Uytterhoeven ret = genpd->power_off(genpd); 385c8f0ea45SGeert Uytterhoeven if (ret == -EBUSY) 386c8f0ea45SGeert Uytterhoeven return ret; 387c8f0ea45SGeert Uytterhoeven 388c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 389fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_off_latency_ns) 390c8f0ea45SGeert Uytterhoeven return ret; 391c8f0ea45SGeert Uytterhoeven 392fc5cbf0cSAxel Haslam genpd->states[state_idx].power_off_latency_ns = elapsed_ns; 393c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 3946d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 395c8f0ea45SGeert Uytterhoeven genpd->name, "off", elapsed_ns); 396c8f0ea45SGeert Uytterhoeven 397c8f0ea45SGeert Uytterhoeven return ret; 398c8f0ea45SGeert Uytterhoeven } 399c8f0ea45SGeert Uytterhoeven 400f721889fSRafael J. Wysocki /** 40186e12eacSUlf Hansson * genpd_queue_power_off_work - Queue up the execution of genpd_power_off(). 402a3d09c73SMoritz Fischer * @genpd: PM domain to power off. 40329e47e21SUlf Hansson * 40486e12eacSUlf Hansson * Queue up the execution of genpd_power_off() unless it's already been done 40529e47e21SUlf Hansson * before. 40629e47e21SUlf Hansson */ 40729e47e21SUlf Hansson static void genpd_queue_power_off_work(struct generic_pm_domain *genpd) 40829e47e21SUlf Hansson { 40929e47e21SUlf Hansson queue_work(pm_wq, &genpd->power_off_work); 41029e47e21SUlf Hansson } 41129e47e21SUlf Hansson 41229e47e21SUlf Hansson /** 4131f8728b7SUlf Hansson * genpd_power_off - Remove power from a given PM domain. 4141f8728b7SUlf Hansson * @genpd: PM domain to power down. 4153c64649dSUlf Hansson * @one_dev_on: If invoked from genpd's ->runtime_suspend|resume() callback, the 4163c64649dSUlf Hansson * RPM status of the releated device is in an intermediate state, not yet turned 4173c64649dSUlf Hansson * into RPM_SUSPENDED. This means genpd_power_off() must allow one device to not 4183c64649dSUlf Hansson * be RPM_SUSPENDED, while it tries to power off the PM domain. 4191f8728b7SUlf Hansson * 4201f8728b7SUlf Hansson * If all of the @genpd's devices have been suspended and all of its subdomains 4211f8728b7SUlf Hansson * have been powered down, remove power from @genpd. 4221f8728b7SUlf Hansson */ 4232da83545SUlf Hansson static int genpd_power_off(struct generic_pm_domain *genpd, bool one_dev_on, 4242da83545SUlf Hansson unsigned int depth) 4251f8728b7SUlf Hansson { 4261f8728b7SUlf Hansson struct pm_domain_data *pdd; 4271f8728b7SUlf Hansson struct gpd_link *link; 4281f8728b7SUlf Hansson unsigned int not_suspended = 0; 4291f8728b7SUlf Hansson 4301f8728b7SUlf Hansson /* 4311f8728b7SUlf Hansson * Do not try to power off the domain in the following situations: 4321f8728b7SUlf Hansson * (1) The domain is already in the "power off" state. 4331f8728b7SUlf Hansson * (2) System suspend is in progress. 4341f8728b7SUlf Hansson */ 43541e2c8e0SUlf Hansson if (!genpd_status_on(genpd) || genpd->prepared_count > 0) 4361f8728b7SUlf Hansson return 0; 4371f8728b7SUlf Hansson 438ffaa42e8SUlf Hansson /* 439ffaa42e8SUlf Hansson * Abort power off for the PM domain in the following situations: 440ffaa42e8SUlf Hansson * (1) The domain is configured as always on. 441ffaa42e8SUlf Hansson * (2) When the domain has a subdomain being powered on. 442ffaa42e8SUlf Hansson */ 443ffaa42e8SUlf Hansson if (genpd_is_always_on(genpd) || atomic_read(&genpd->sd_count) > 0) 4441f8728b7SUlf Hansson return -EBUSY; 4451f8728b7SUlf Hansson 4461f8728b7SUlf Hansson list_for_each_entry(pdd, &genpd->dev_list, list_node) { 4471f8728b7SUlf Hansson enum pm_qos_flags_status stat; 4481f8728b7SUlf Hansson 44920f97cafSRafael J. Wysocki stat = dev_pm_qos_flags(pdd->dev, PM_QOS_FLAG_NO_POWER_OFF); 4501f8728b7SUlf Hansson if (stat > PM_QOS_FLAGS_NONE) 4511f8728b7SUlf Hansson return -EBUSY; 4521f8728b7SUlf Hansson 4531f8728b7SUlf Hansson /* 4541f8728b7SUlf Hansson * Do not allow PM domain to be powered off, when an IRQ safe 4551f8728b7SUlf Hansson * device is part of a non-IRQ safe domain. 4561f8728b7SUlf Hansson */ 4571f8728b7SUlf Hansson if (!pm_runtime_suspended(pdd->dev) || 4581f8728b7SUlf Hansson irq_safe_dev_in_no_sleep_domain(pdd->dev, genpd)) 4591f8728b7SUlf Hansson not_suspended++; 4601f8728b7SUlf Hansson } 4611f8728b7SUlf Hansson 4623c64649dSUlf Hansson if (not_suspended > 1 || (not_suspended == 1 && !one_dev_on)) 4631f8728b7SUlf Hansson return -EBUSY; 4641f8728b7SUlf Hansson 4651f8728b7SUlf Hansson if (genpd->gov && genpd->gov->power_down_ok) { 4661f8728b7SUlf Hansson if (!genpd->gov->power_down_ok(&genpd->domain)) 4671f8728b7SUlf Hansson return -EAGAIN; 4681f8728b7SUlf Hansson } 4691f8728b7SUlf Hansson 4701f8728b7SUlf Hansson if (genpd->power_off) { 4711f8728b7SUlf Hansson int ret; 4721f8728b7SUlf Hansson 4731f8728b7SUlf Hansson if (atomic_read(&genpd->sd_count) > 0) 4741f8728b7SUlf Hansson return -EBUSY; 4751f8728b7SUlf Hansson 4761f8728b7SUlf Hansson /* 4771f8728b7SUlf Hansson * If sd_count > 0 at this point, one of the subdomains hasn't 4781f8728b7SUlf Hansson * managed to call genpd_power_on() for the master yet after 4791f8728b7SUlf Hansson * incrementing it. In that case genpd_power_on() will wait 4801f8728b7SUlf Hansson * for us to drop the lock, so we can call .power_off() and let 4811f8728b7SUlf Hansson * the genpd_power_on() restore power for us (this shouldn't 4821f8728b7SUlf Hansson * happen very often). 4831f8728b7SUlf Hansson */ 4841f8728b7SUlf Hansson ret = _genpd_power_off(genpd, true); 4851f8728b7SUlf Hansson if (ret) 4861f8728b7SUlf Hansson return ret; 4871f8728b7SUlf Hansson } 4881f8728b7SUlf Hansson 4891f8728b7SUlf Hansson genpd->status = GPD_STATE_POWER_OFF; 490afece3abSThara Gopinath genpd_update_accounting(genpd); 4911f8728b7SUlf Hansson 4921f8728b7SUlf Hansson list_for_each_entry(link, &genpd->slave_links, slave_node) { 4931f8728b7SUlf Hansson genpd_sd_counter_dec(link->master); 4942da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 4952da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 4962da83545SUlf Hansson genpd_unlock(link->master); 4971f8728b7SUlf Hansson } 4981f8728b7SUlf Hansson 4991f8728b7SUlf Hansson return 0; 5001f8728b7SUlf Hansson } 5011f8728b7SUlf Hansson 5021f8728b7SUlf Hansson /** 50386e12eacSUlf Hansson * genpd_power_on - Restore power to a given PM domain and its masters. 5045248051bSRafael J. Wysocki * @genpd: PM domain to power up. 5050106ef51SMarek Szyprowski * @depth: nesting count for lockdep. 5065248051bSRafael J. Wysocki * 5075063ce15SRafael J. Wysocki * Restore power to @genpd and all of its masters so that it is possible to 5085248051bSRafael J. Wysocki * resume a device belonging to it. 5095248051bSRafael J. Wysocki */ 51086e12eacSUlf Hansson static int genpd_power_on(struct generic_pm_domain *genpd, unsigned int depth) 5115248051bSRafael J. Wysocki { 5125063ce15SRafael J. Wysocki struct gpd_link *link; 5135248051bSRafael J. Wysocki int ret = 0; 5145248051bSRafael J. Wysocki 51541e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 5163f241775SRafael J. Wysocki return 0; 5175248051bSRafael J. Wysocki 5185063ce15SRafael J. Wysocki /* 5195063ce15SRafael J. Wysocki * The list is guaranteed not to change while the loop below is being 5205063ce15SRafael J. Wysocki * executed, unless one of the masters' .power_on() callbacks fiddles 5215063ce15SRafael J. Wysocki * with it. 5225063ce15SRafael J. Wysocki */ 5235063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 5240106ef51SMarek Szyprowski struct generic_pm_domain *master = link->master; 5255248051bSRafael J. Wysocki 5260106ef51SMarek Szyprowski genpd_sd_counter_inc(master); 5270106ef51SMarek Szyprowski 52835241d12SLina Iyer genpd_lock_nested(master, depth + 1); 52986e12eacSUlf Hansson ret = genpd_power_on(master, depth + 1); 53035241d12SLina Iyer genpd_unlock(master); 5310106ef51SMarek Szyprowski 5325063ce15SRafael J. Wysocki if (ret) { 5330106ef51SMarek Szyprowski genpd_sd_counter_dec(master); 5349e08cf42SRafael J. Wysocki goto err; 5355248051bSRafael J. Wysocki } 5365063ce15SRafael J. Wysocki } 5375248051bSRafael J. Wysocki 53886e12eacSUlf Hansson ret = _genpd_power_on(genpd, true); 5399e08cf42SRafael J. Wysocki if (ret) 5409e08cf42SRafael J. Wysocki goto err; 5410140d8bdSRafael J. Wysocki 542ba2bbfbfSUlf Hansson genpd->status = GPD_STATE_ACTIVE; 543afece3abSThara Gopinath genpd_update_accounting(genpd); 544afece3abSThara Gopinath 5453f241775SRafael J. Wysocki return 0; 5469e08cf42SRafael J. Wysocki 5479e08cf42SRafael J. Wysocki err: 54829e47e21SUlf Hansson list_for_each_entry_continue_reverse(link, 54929e47e21SUlf Hansson &genpd->slave_links, 55029e47e21SUlf Hansson slave_node) { 5515063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 5522da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 5532da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 5542da83545SUlf Hansson genpd_unlock(link->master); 55529e47e21SUlf Hansson } 5569e08cf42SRafael J. Wysocki 5573f241775SRafael J. Wysocki return ret; 5583f241775SRafael J. Wysocki } 5593f241775SRafael J. Wysocki 5606ff7bb0dSRafael J. Wysocki static int genpd_dev_pm_qos_notifier(struct notifier_block *nb, 5616ff7bb0dSRafael J. Wysocki unsigned long val, void *ptr) 5626ff7bb0dSRafael J. Wysocki { 5636ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 5646ff7bb0dSRafael J. Wysocki struct device *dev; 5656ff7bb0dSRafael J. Wysocki 5666ff7bb0dSRafael J. Wysocki gpd_data = container_of(nb, struct generic_pm_domain_data, nb); 5676ff7bb0dSRafael J. Wysocki dev = gpd_data->base.dev; 5686ff7bb0dSRafael J. Wysocki 5696ff7bb0dSRafael J. Wysocki for (;;) { 5706ff7bb0dSRafael J. Wysocki struct generic_pm_domain *genpd; 5716ff7bb0dSRafael J. Wysocki struct pm_domain_data *pdd; 5726ff7bb0dSRafael J. Wysocki 5736ff7bb0dSRafael J. Wysocki spin_lock_irq(&dev->power.lock); 5746ff7bb0dSRafael J. Wysocki 5756ff7bb0dSRafael J. Wysocki pdd = dev->power.subsys_data ? 5766ff7bb0dSRafael J. Wysocki dev->power.subsys_data->domain_data : NULL; 577b4883ca4SViresh Kumar if (pdd) { 5786ff7bb0dSRafael J. Wysocki to_gpd_data(pdd)->td.constraint_changed = true; 5796ff7bb0dSRafael J. Wysocki genpd = dev_to_genpd(dev); 5806ff7bb0dSRafael J. Wysocki } else { 5816ff7bb0dSRafael J. Wysocki genpd = ERR_PTR(-ENODATA); 5826ff7bb0dSRafael J. Wysocki } 5836ff7bb0dSRafael J. Wysocki 5846ff7bb0dSRafael J. Wysocki spin_unlock_irq(&dev->power.lock); 5856ff7bb0dSRafael J. Wysocki 5866ff7bb0dSRafael J. Wysocki if (!IS_ERR(genpd)) { 58735241d12SLina Iyer genpd_lock(genpd); 5886ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 58935241d12SLina Iyer genpd_unlock(genpd); 5906ff7bb0dSRafael J. Wysocki } 5916ff7bb0dSRafael J. Wysocki 5926ff7bb0dSRafael J. Wysocki dev = dev->parent; 5936ff7bb0dSRafael J. Wysocki if (!dev || dev->power.ignore_children) 5946ff7bb0dSRafael J. Wysocki break; 5956ff7bb0dSRafael J. Wysocki } 5966ff7bb0dSRafael J. Wysocki 5976ff7bb0dSRafael J. Wysocki return NOTIFY_DONE; 5986ff7bb0dSRafael J. Wysocki } 5996ff7bb0dSRafael J. Wysocki 6005248051bSRafael J. Wysocki /** 601f721889fSRafael J. Wysocki * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0. 602f721889fSRafael J. Wysocki * @work: Work structure used for scheduling the execution of this function. 603f721889fSRafael J. Wysocki */ 604f721889fSRafael J. Wysocki static void genpd_power_off_work_fn(struct work_struct *work) 605f721889fSRafael J. Wysocki { 606f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 607f721889fSRafael J. Wysocki 608f721889fSRafael J. Wysocki genpd = container_of(work, struct generic_pm_domain, power_off_work); 609f721889fSRafael J. Wysocki 61035241d12SLina Iyer genpd_lock(genpd); 6112da83545SUlf Hansson genpd_power_off(genpd, false, 0); 61235241d12SLina Iyer genpd_unlock(genpd); 613f721889fSRafael J. Wysocki } 614f721889fSRafael J. Wysocki 615f721889fSRafael J. Wysocki /** 61654eeddbfSUlf Hansson * __genpd_runtime_suspend - walk the hierarchy of ->runtime_suspend() callbacks 61754eeddbfSUlf Hansson * @dev: Device to handle. 61854eeddbfSUlf Hansson */ 61954eeddbfSUlf Hansson static int __genpd_runtime_suspend(struct device *dev) 62054eeddbfSUlf Hansson { 62154eeddbfSUlf Hansson int (*cb)(struct device *__dev); 62254eeddbfSUlf Hansson 62354eeddbfSUlf Hansson if (dev->type && dev->type->pm) 62454eeddbfSUlf Hansson cb = dev->type->pm->runtime_suspend; 62554eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 62654eeddbfSUlf Hansson cb = dev->class->pm->runtime_suspend; 62754eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 62854eeddbfSUlf Hansson cb = dev->bus->pm->runtime_suspend; 62954eeddbfSUlf Hansson else 63054eeddbfSUlf Hansson cb = NULL; 63154eeddbfSUlf Hansson 63254eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 63354eeddbfSUlf Hansson cb = dev->driver->pm->runtime_suspend; 63454eeddbfSUlf Hansson 63554eeddbfSUlf Hansson return cb ? cb(dev) : 0; 63654eeddbfSUlf Hansson } 63754eeddbfSUlf Hansson 63854eeddbfSUlf Hansson /** 63954eeddbfSUlf Hansson * __genpd_runtime_resume - walk the hierarchy of ->runtime_resume() callbacks 64054eeddbfSUlf Hansson * @dev: Device to handle. 64154eeddbfSUlf Hansson */ 64254eeddbfSUlf Hansson static int __genpd_runtime_resume(struct device *dev) 64354eeddbfSUlf Hansson { 64454eeddbfSUlf Hansson int (*cb)(struct device *__dev); 64554eeddbfSUlf Hansson 64654eeddbfSUlf Hansson if (dev->type && dev->type->pm) 64754eeddbfSUlf Hansson cb = dev->type->pm->runtime_resume; 64854eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 64954eeddbfSUlf Hansson cb = dev->class->pm->runtime_resume; 65054eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 65154eeddbfSUlf Hansson cb = dev->bus->pm->runtime_resume; 65254eeddbfSUlf Hansson else 65354eeddbfSUlf Hansson cb = NULL; 65454eeddbfSUlf Hansson 65554eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 65654eeddbfSUlf Hansson cb = dev->driver->pm->runtime_resume; 65754eeddbfSUlf Hansson 65854eeddbfSUlf Hansson return cb ? cb(dev) : 0; 65954eeddbfSUlf Hansson } 66054eeddbfSUlf Hansson 66154eeddbfSUlf Hansson /** 662795bd2e7SUlf Hansson * genpd_runtime_suspend - Suspend a device belonging to I/O PM domain. 663f721889fSRafael J. Wysocki * @dev: Device to suspend. 664f721889fSRafael J. Wysocki * 665f721889fSRafael J. Wysocki * Carry out a runtime suspend of a device under the assumption that its 666f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 667f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 668f721889fSRafael J. Wysocki */ 669795bd2e7SUlf Hansson static int genpd_runtime_suspend(struct device *dev) 670f721889fSRafael J. Wysocki { 671f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 6729df3921eSUlf Hansson bool (*suspend_ok)(struct device *__dev); 6732b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 674ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 6752b1d88cdSUlf Hansson ktime_t time_start; 6762b1d88cdSUlf Hansson s64 elapsed_ns; 677d5e4cbfeSRafael J. Wysocki int ret; 678f721889fSRafael J. Wysocki 679f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 680f721889fSRafael J. Wysocki 6815248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 6825248051bSRafael J. Wysocki if (IS_ERR(genpd)) 683f721889fSRafael J. Wysocki return -EINVAL; 684f721889fSRafael J. Wysocki 685ffe12855SUlf Hansson /* 686ffe12855SUlf Hansson * A runtime PM centric subsystem/driver may re-use the runtime PM 687ffe12855SUlf Hansson * callbacks for other purposes than runtime PM. In those scenarios 688ffe12855SUlf Hansson * runtime PM is disabled. Under these circumstances, we shall skip 689ffe12855SUlf Hansson * validating/measuring the PM QoS latency. 690ffe12855SUlf Hansson */ 6919df3921eSUlf Hansson suspend_ok = genpd->gov ? genpd->gov->suspend_ok : NULL; 6929df3921eSUlf Hansson if (runtime_pm && suspend_ok && !suspend_ok(dev)) 693b02c999aSRafael J. Wysocki return -EBUSY; 694b02c999aSRafael J. Wysocki 6952b1d88cdSUlf Hansson /* Measure suspend latency. */ 696d33d5a6cSLinus Torvalds time_start = 0; 697ffe12855SUlf Hansson if (runtime_pm) 6982b1d88cdSUlf Hansson time_start = ktime_get(); 6992b1d88cdSUlf Hansson 70054eeddbfSUlf Hansson ret = __genpd_runtime_suspend(dev); 701f721889fSRafael J. Wysocki if (ret) 70217b75ecaSRafael J. Wysocki return ret; 70317b75ecaSRafael J. Wysocki 7042b1d88cdSUlf Hansson ret = genpd_stop_dev(genpd, dev); 705ba2bbfbfSUlf Hansson if (ret) { 70654eeddbfSUlf Hansson __genpd_runtime_resume(dev); 707ba2bbfbfSUlf Hansson return ret; 708ba2bbfbfSUlf Hansson } 709ba2bbfbfSUlf Hansson 7102b1d88cdSUlf Hansson /* Update suspend latency value if the measured time exceeds it. */ 711ffe12855SUlf Hansson if (runtime_pm) { 7122b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 7132b1d88cdSUlf Hansson if (elapsed_ns > td->suspend_latency_ns) { 7142b1d88cdSUlf Hansson td->suspend_latency_ns = elapsed_ns; 7152b1d88cdSUlf Hansson dev_dbg(dev, "suspend latency exceeded, %lld ns\n", 7162b1d88cdSUlf Hansson elapsed_ns); 7172b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 7182b1d88cdSUlf Hansson td->constraint_changed = true; 7192b1d88cdSUlf Hansson } 720ffe12855SUlf Hansson } 7212b1d88cdSUlf Hansson 7220aa2a221SRafael J. Wysocki /* 723d716f479SLina Iyer * If power.irq_safe is set, this routine may be run with 724d716f479SLina Iyer * IRQs disabled, so suspend only if the PM domain also is irq_safe. 7250aa2a221SRafael J. Wysocki */ 726d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) 7270aa2a221SRafael J. Wysocki return 0; 7280aa2a221SRafael J. Wysocki 72935241d12SLina Iyer genpd_lock(genpd); 7302da83545SUlf Hansson genpd_power_off(genpd, true, 0); 73135241d12SLina Iyer genpd_unlock(genpd); 732f721889fSRafael J. Wysocki 733f721889fSRafael J. Wysocki return 0; 734f721889fSRafael J. Wysocki } 735f721889fSRafael J. Wysocki 736f721889fSRafael J. Wysocki /** 737795bd2e7SUlf Hansson * genpd_runtime_resume - Resume a device belonging to I/O PM domain. 738f721889fSRafael J. Wysocki * @dev: Device to resume. 739f721889fSRafael J. Wysocki * 740f721889fSRafael J. Wysocki * Carry out a runtime resume of a device under the assumption that its 741f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 742f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 743f721889fSRafael J. Wysocki */ 744795bd2e7SUlf Hansson static int genpd_runtime_resume(struct device *dev) 745f721889fSRafael J. Wysocki { 746f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 7472b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 748ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 7492b1d88cdSUlf Hansson ktime_t time_start; 7502b1d88cdSUlf Hansson s64 elapsed_ns; 751f721889fSRafael J. Wysocki int ret; 752ba2bbfbfSUlf Hansson bool timed = true; 753f721889fSRafael J. Wysocki 754f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 755f721889fSRafael J. Wysocki 7565248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 7575248051bSRafael J. Wysocki if (IS_ERR(genpd)) 758f721889fSRafael J. Wysocki return -EINVAL; 759f721889fSRafael J. Wysocki 760d716f479SLina Iyer /* 761d716f479SLina Iyer * As we don't power off a non IRQ safe domain, which holds 762d716f479SLina Iyer * an IRQ safe device, we don't need to restore power to it. 763d716f479SLina Iyer */ 764d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) { 765ba2bbfbfSUlf Hansson timed = false; 766ba2bbfbfSUlf Hansson goto out; 767ba2bbfbfSUlf Hansson } 7680aa2a221SRafael J. Wysocki 76935241d12SLina Iyer genpd_lock(genpd); 77086e12eacSUlf Hansson ret = genpd_power_on(genpd, 0); 77135241d12SLina Iyer genpd_unlock(genpd); 772ba2bbfbfSUlf Hansson 773ba2bbfbfSUlf Hansson if (ret) 7743f241775SRafael J. Wysocki return ret; 775c6d22b37SRafael J. Wysocki 776ba2bbfbfSUlf Hansson out: 7772b1d88cdSUlf Hansson /* Measure resume latency. */ 778ab51e6baSAugusto Mecking Caringi time_start = 0; 779ffe12855SUlf Hansson if (timed && runtime_pm) 7802b1d88cdSUlf Hansson time_start = ktime_get(); 7812b1d88cdSUlf Hansson 782076395caSLaurent Pinchart ret = genpd_start_dev(genpd, dev); 783076395caSLaurent Pinchart if (ret) 784076395caSLaurent Pinchart goto err_poweroff; 785076395caSLaurent Pinchart 78654eeddbfSUlf Hansson ret = __genpd_runtime_resume(dev); 787076395caSLaurent Pinchart if (ret) 788076395caSLaurent Pinchart goto err_stop; 7892b1d88cdSUlf Hansson 7902b1d88cdSUlf Hansson /* Update resume latency value if the measured time exceeds it. */ 791ffe12855SUlf Hansson if (timed && runtime_pm) { 7922b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 7932b1d88cdSUlf Hansson if (elapsed_ns > td->resume_latency_ns) { 7942b1d88cdSUlf Hansson td->resume_latency_ns = elapsed_ns; 7952b1d88cdSUlf Hansson dev_dbg(dev, "resume latency exceeded, %lld ns\n", 7962b1d88cdSUlf Hansson elapsed_ns); 7972b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 7982b1d88cdSUlf Hansson td->constraint_changed = true; 7992b1d88cdSUlf Hansson } 8002b1d88cdSUlf Hansson } 80117b75ecaSRafael J. Wysocki 802f721889fSRafael J. Wysocki return 0; 803076395caSLaurent Pinchart 804076395caSLaurent Pinchart err_stop: 805076395caSLaurent Pinchart genpd_stop_dev(genpd, dev); 806076395caSLaurent Pinchart err_poweroff: 807d716f479SLina Iyer if (!pm_runtime_is_irq_safe(dev) || 808d716f479SLina Iyer (pm_runtime_is_irq_safe(dev) && genpd_is_irq_safe(genpd))) { 80935241d12SLina Iyer genpd_lock(genpd); 8102da83545SUlf Hansson genpd_power_off(genpd, true, 0); 81135241d12SLina Iyer genpd_unlock(genpd); 812076395caSLaurent Pinchart } 813076395caSLaurent Pinchart 814076395caSLaurent Pinchart return ret; 815f721889fSRafael J. Wysocki } 816f721889fSRafael J. Wysocki 81739ac5ba5STushar Behera static bool pd_ignore_unused; 81839ac5ba5STushar Behera static int __init pd_ignore_unused_setup(char *__unused) 81939ac5ba5STushar Behera { 82039ac5ba5STushar Behera pd_ignore_unused = true; 82139ac5ba5STushar Behera return 1; 82239ac5ba5STushar Behera } 82339ac5ba5STushar Behera __setup("pd_ignore_unused", pd_ignore_unused_setup); 82439ac5ba5STushar Behera 82517f2ae7fSRafael J. Wysocki /** 82686e12eacSUlf Hansson * genpd_power_off_unused - Power off all PM domains with no devices in use. 82717f2ae7fSRafael J. Wysocki */ 82886e12eacSUlf Hansson static int __init genpd_power_off_unused(void) 82917f2ae7fSRafael J. Wysocki { 83017f2ae7fSRafael J. Wysocki struct generic_pm_domain *genpd; 83117f2ae7fSRafael J. Wysocki 83239ac5ba5STushar Behera if (pd_ignore_unused) { 83339ac5ba5STushar Behera pr_warn("genpd: Not disabling unused power domains\n"); 834bb4b72fcSUlf Hansson return 0; 83539ac5ba5STushar Behera } 83639ac5ba5STushar Behera 83717f2ae7fSRafael J. Wysocki mutex_lock(&gpd_list_lock); 83817f2ae7fSRafael J. Wysocki 83917f2ae7fSRafael J. Wysocki list_for_each_entry(genpd, &gpd_list, gpd_list_node) 84017f2ae7fSRafael J. Wysocki genpd_queue_power_off_work(genpd); 84117f2ae7fSRafael J. Wysocki 84217f2ae7fSRafael J. Wysocki mutex_unlock(&gpd_list_lock); 84317f2ae7fSRafael J. Wysocki 8442fe71dcdSUlf Hansson return 0; 8452fe71dcdSUlf Hansson } 84686e12eacSUlf Hansson late_initcall(genpd_power_off_unused); 8472fe71dcdSUlf Hansson 8480159ec67SJon Hunter #if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_GENERIC_DOMAINS_OF) 849596ba34bSRafael J. Wysocki 8509e9704eaSUlf Hansson static bool genpd_present(const struct generic_pm_domain *genpd) 85177f827deSRafael J. Wysocki { 852895b31f3SGeert Uytterhoeven const struct generic_pm_domain *gpd; 85377f827deSRafael J. Wysocki 85477f827deSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 85577f827deSRafael J. Wysocki return false; 85677f827deSRafael J. Wysocki 85777f827deSRafael J. Wysocki list_for_each_entry(gpd, &gpd_list, gpd_list_node) 85877f827deSRafael J. Wysocki if (gpd == genpd) 85977f827deSRafael J. Wysocki return true; 86077f827deSRafael J. Wysocki 86177f827deSRafael J. Wysocki return false; 86277f827deSRafael J. Wysocki } 86377f827deSRafael J. Wysocki 8640159ec67SJon Hunter #endif 8650159ec67SJon Hunter 8660159ec67SJon Hunter #ifdef CONFIG_PM_SLEEP 8670159ec67SJon Hunter 868596ba34bSRafael J. Wysocki /** 86986e12eacSUlf Hansson * genpd_sync_power_off - Synchronously power off a PM domain and its masters. 870596ba34bSRafael J. Wysocki * @genpd: PM domain to power off, if possible. 8710883ac03SUlf Hansson * @use_lock: use the lock. 8720883ac03SUlf Hansson * @depth: nesting count for lockdep. 873596ba34bSRafael J. Wysocki * 874596ba34bSRafael J. Wysocki * Check if the given PM domain can be powered off (during system suspend or 8755063ce15SRafael J. Wysocki * hibernation) and do that if so. Also, in that case propagate to its masters. 876596ba34bSRafael J. Wysocki * 87777f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 8780883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 8790883ac03SUlf Hansson * these cases the lock must be held. 880596ba34bSRafael J. Wysocki */ 8810883ac03SUlf Hansson static void genpd_sync_power_off(struct generic_pm_domain *genpd, bool use_lock, 8820883ac03SUlf Hansson unsigned int depth) 883596ba34bSRafael J. Wysocki { 8845063ce15SRafael J. Wysocki struct gpd_link *link; 885596ba34bSRafael J. Wysocki 886ffaa42e8SUlf Hansson if (!genpd_status_on(genpd) || genpd_is_always_on(genpd)) 887596ba34bSRafael J. Wysocki return; 888596ba34bSRafael J. Wysocki 889c4bb3160SRafael J. Wysocki if (genpd->suspended_count != genpd->device_count 890c4bb3160SRafael J. Wysocki || atomic_read(&genpd->sd_count) > 0) 891596ba34bSRafael J. Wysocki return; 892596ba34bSRafael J. Wysocki 893fc5cbf0cSAxel Haslam /* Choose the deepest state when suspending */ 894fc5cbf0cSAxel Haslam genpd->state_idx = genpd->state_count - 1; 8951c14967cSUlf Hansson if (_genpd_power_off(genpd, false)) 8961c14967cSUlf Hansson return; 897596ba34bSRafael J. Wysocki 89817b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 8995063ce15SRafael J. Wysocki 9005063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 9015063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 9020883ac03SUlf Hansson 9030883ac03SUlf Hansson if (use_lock) 9040883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 9050883ac03SUlf Hansson 9060883ac03SUlf Hansson genpd_sync_power_off(link->master, use_lock, depth + 1); 9070883ac03SUlf Hansson 9080883ac03SUlf Hansson if (use_lock) 9090883ac03SUlf Hansson genpd_unlock(link->master); 910596ba34bSRafael J. Wysocki } 911596ba34bSRafael J. Wysocki } 912596ba34bSRafael J. Wysocki 913596ba34bSRafael J. Wysocki /** 91486e12eacSUlf Hansson * genpd_sync_power_on - Synchronously power on a PM domain and its masters. 915802d8b49SRafael J. Wysocki * @genpd: PM domain to power on. 9160883ac03SUlf Hansson * @use_lock: use the lock. 9170883ac03SUlf Hansson * @depth: nesting count for lockdep. 918802d8b49SRafael J. Wysocki * 91977f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 9200883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 9210883ac03SUlf Hansson * these cases the lock must be held. 922802d8b49SRafael J. Wysocki */ 9230883ac03SUlf Hansson static void genpd_sync_power_on(struct generic_pm_domain *genpd, bool use_lock, 9240883ac03SUlf Hansson unsigned int depth) 925802d8b49SRafael J. Wysocki { 926802d8b49SRafael J. Wysocki struct gpd_link *link; 927802d8b49SRafael J. Wysocki 92841e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 929802d8b49SRafael J. Wysocki return; 930802d8b49SRafael J. Wysocki 931802d8b49SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 932802d8b49SRafael J. Wysocki genpd_sd_counter_inc(link->master); 9330883ac03SUlf Hansson 9340883ac03SUlf Hansson if (use_lock) 9350883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 9360883ac03SUlf Hansson 9370883ac03SUlf Hansson genpd_sync_power_on(link->master, use_lock, depth + 1); 9380883ac03SUlf Hansson 9390883ac03SUlf Hansson if (use_lock) 9400883ac03SUlf Hansson genpd_unlock(link->master); 941802d8b49SRafael J. Wysocki } 942802d8b49SRafael J. Wysocki 94386e12eacSUlf Hansson _genpd_power_on(genpd, false); 944802d8b49SRafael J. Wysocki 945802d8b49SRafael J. Wysocki genpd->status = GPD_STATE_ACTIVE; 946802d8b49SRafael J. Wysocki } 947802d8b49SRafael J. Wysocki 948802d8b49SRafael J. Wysocki /** 9494ecd6e65SRafael J. Wysocki * resume_needed - Check whether to resume a device before system suspend. 9504ecd6e65SRafael J. Wysocki * @dev: Device to check. 9514ecd6e65SRafael J. Wysocki * @genpd: PM domain the device belongs to. 9524ecd6e65SRafael J. Wysocki * 9534ecd6e65SRafael J. Wysocki * There are two cases in which a device that can wake up the system from sleep 9549e9704eaSUlf Hansson * states should be resumed by genpd_prepare(): (1) if the device is enabled 9554ecd6e65SRafael J. Wysocki * to wake up the system and it has to remain active for this purpose while the 9564ecd6e65SRafael J. Wysocki * system is in the sleep state and (2) if the device is not enabled to wake up 9574ecd6e65SRafael J. Wysocki * the system from sleep states and it generally doesn't generate wakeup signals 9584ecd6e65SRafael J. Wysocki * by itself (those signals are generated on its behalf by other parts of the 9594ecd6e65SRafael J. Wysocki * system). In the latter case it may be necessary to reconfigure the device's 9604ecd6e65SRafael J. Wysocki * wakeup settings during system suspend, because it may have been set up to 9614ecd6e65SRafael J. Wysocki * signal remote wakeup from the system's working state as needed by runtime PM. 9624ecd6e65SRafael J. Wysocki * Return 'true' in either of the above cases. 9634ecd6e65SRafael J. Wysocki */ 964d8600c8bSKrzysztof Kozlowski static bool resume_needed(struct device *dev, 965d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 9664ecd6e65SRafael J. Wysocki { 9674ecd6e65SRafael J. Wysocki bool active_wakeup; 9684ecd6e65SRafael J. Wysocki 9694ecd6e65SRafael J. Wysocki if (!device_can_wakeup(dev)) 9704ecd6e65SRafael J. Wysocki return false; 9714ecd6e65SRafael J. Wysocki 972d0af45f1SGeert Uytterhoeven active_wakeup = genpd_is_active_wakeup(genpd); 9734ecd6e65SRafael J. Wysocki return device_may_wakeup(dev) ? active_wakeup : !active_wakeup; 9744ecd6e65SRafael J. Wysocki } 9754ecd6e65SRafael J. Wysocki 9764ecd6e65SRafael J. Wysocki /** 9779e9704eaSUlf Hansson * genpd_prepare - Start power transition of a device in a PM domain. 978596ba34bSRafael J. Wysocki * @dev: Device to start the transition of. 979596ba34bSRafael J. Wysocki * 980596ba34bSRafael J. Wysocki * Start a power transition of a device (during a system-wide power transition) 981596ba34bSRafael J. Wysocki * under the assumption that its pm_domain field points to the domain member of 982596ba34bSRafael J. Wysocki * an object of type struct generic_pm_domain representing a PM domain 983596ba34bSRafael J. Wysocki * consisting of I/O devices. 984596ba34bSRafael J. Wysocki */ 9859e9704eaSUlf Hansson static int genpd_prepare(struct device *dev) 986596ba34bSRafael J. Wysocki { 987596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 988b6c10c84SRafael J. Wysocki int ret; 989596ba34bSRafael J. Wysocki 990596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 991596ba34bSRafael J. Wysocki 992596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 993596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 994596ba34bSRafael J. Wysocki return -EINVAL; 995596ba34bSRafael J. Wysocki 99617b75ecaSRafael J. Wysocki /* 99717b75ecaSRafael J. Wysocki * If a wakeup request is pending for the device, it should be woken up 99817b75ecaSRafael J. Wysocki * at this point and a system wakeup event should be reported if it's 99917b75ecaSRafael J. Wysocki * set up to wake up the system from sleep states. 100017b75ecaSRafael J. Wysocki */ 10014ecd6e65SRafael J. Wysocki if (resume_needed(dev, genpd)) 10024ecd6e65SRafael J. Wysocki pm_runtime_resume(dev); 10034ecd6e65SRafael J. Wysocki 100435241d12SLina Iyer genpd_lock(genpd); 1005596ba34bSRafael J. Wysocki 100639dd0f23SUlf Hansson if (genpd->prepared_count++ == 0) 100765533bbfSRafael J. Wysocki genpd->suspended_count = 0; 100817b75ecaSRafael J. Wysocki 100935241d12SLina Iyer genpd_unlock(genpd); 1010596ba34bSRafael J. Wysocki 1011b6c10c84SRafael J. Wysocki ret = pm_generic_prepare(dev); 10125241ab40SUlf Hansson if (ret < 0) { 101335241d12SLina Iyer genpd_lock(genpd); 1014b6c10c84SRafael J. Wysocki 101539dd0f23SUlf Hansson genpd->prepared_count--; 1016b6c10c84SRafael J. Wysocki 101735241d12SLina Iyer genpd_unlock(genpd); 1018b6c10c84SRafael J. Wysocki } 101917b75ecaSRafael J. Wysocki 10205241ab40SUlf Hansson /* Never return 1, as genpd don't cope with the direct_complete path. */ 10215241ab40SUlf Hansson return ret >= 0 ? 0 : ret; 1022596ba34bSRafael J. Wysocki } 1023596ba34bSRafael J. Wysocki 1024596ba34bSRafael J. Wysocki /** 102510da6542SMikko Perttunen * genpd_finish_suspend - Completion of suspend or hibernation of device in an 102610da6542SMikko Perttunen * I/O pm domain. 10270496c8aeSRafael J. Wysocki * @dev: Device to suspend. 102810da6542SMikko Perttunen * @poweroff: Specifies if this is a poweroff_noirq or suspend_noirq callback. 10290496c8aeSRafael J. Wysocki * 10300496c8aeSRafael J. Wysocki * Stop the device and remove power from the domain if all devices in it have 10310496c8aeSRafael J. Wysocki * been stopped. 10320496c8aeSRafael J. Wysocki */ 103310da6542SMikko Perttunen static int genpd_finish_suspend(struct device *dev, bool poweroff) 10340496c8aeSRafael J. Wysocki { 10350496c8aeSRafael J. Wysocki struct generic_pm_domain *genpd; 1036a935424bSUlf Hansson int ret = 0; 1037596ba34bSRafael J. Wysocki 10380496c8aeSRafael J. Wysocki genpd = dev_to_genpd(dev); 10390496c8aeSRafael J. Wysocki if (IS_ERR(genpd)) 10400496c8aeSRafael J. Wysocki return -EINVAL; 10410496c8aeSRafael J. Wysocki 104210da6542SMikko Perttunen if (poweroff) 104310da6542SMikko Perttunen ret = pm_generic_poweroff_noirq(dev); 104410da6542SMikko Perttunen else 104510da6542SMikko Perttunen ret = pm_generic_suspend_noirq(dev); 104610da6542SMikko Perttunen if (ret) 104710da6542SMikko Perttunen return ret; 104810da6542SMikko Perttunen 1049a935424bSUlf Hansson if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1050a935424bSUlf Hansson return 0; 1051a935424bSUlf Hansson 105217218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 105317218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 105417218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1055a935424bSUlf Hansson if (ret) { 1056a935424bSUlf Hansson if (poweroff) 1057a935424bSUlf Hansson pm_generic_restore_noirq(dev); 1058a935424bSUlf Hansson else 1059a935424bSUlf Hansson pm_generic_resume_noirq(dev); 1060122a2237SUlf Hansson return ret; 1061122a2237SUlf Hansson } 1062a935424bSUlf Hansson } 1063122a2237SUlf Hansson 10640883ac03SUlf Hansson genpd_lock(genpd); 1065596ba34bSRafael J. Wysocki genpd->suspended_count++; 10660883ac03SUlf Hansson genpd_sync_power_off(genpd, true, 0); 10670883ac03SUlf Hansson genpd_unlock(genpd); 1068596ba34bSRafael J. Wysocki 1069596ba34bSRafael J. Wysocki return 0; 1070596ba34bSRafael J. Wysocki } 1071596ba34bSRafael J. Wysocki 1072596ba34bSRafael J. Wysocki /** 10739e9704eaSUlf Hansson * genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain. 107410da6542SMikko Perttunen * @dev: Device to suspend. 107510da6542SMikko Perttunen * 107610da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 107710da6542SMikko Perttunen * been stopped. 107810da6542SMikko Perttunen */ 10799e9704eaSUlf Hansson static int genpd_suspend_noirq(struct device *dev) 108010da6542SMikko Perttunen { 108110da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 108210da6542SMikko Perttunen 108310da6542SMikko Perttunen return genpd_finish_suspend(dev, false); 108410da6542SMikko Perttunen } 108510da6542SMikko Perttunen 108610da6542SMikko Perttunen /** 10879e9704eaSUlf Hansson * genpd_resume_noirq - Start of resume of device in an I/O PM domain. 1088596ba34bSRafael J. Wysocki * @dev: Device to resume. 1089596ba34bSRafael J. Wysocki * 10900496c8aeSRafael J. Wysocki * Restore power to the device's PM domain, if necessary, and start the device. 1091596ba34bSRafael J. Wysocki */ 10929e9704eaSUlf Hansson static int genpd_resume_noirq(struct device *dev) 1093596ba34bSRafael J. Wysocki { 1094596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1095a935424bSUlf Hansson int ret; 1096596ba34bSRafael J. Wysocki 1097596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1098596ba34bSRafael J. Wysocki 1099596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1100596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1101596ba34bSRafael J. Wysocki return -EINVAL; 1102596ba34bSRafael J. Wysocki 1103d0af45f1SGeert Uytterhoeven if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1104a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1105596ba34bSRafael J. Wysocki 11060883ac03SUlf Hansson genpd_lock(genpd); 11070883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 1108596ba34bSRafael J. Wysocki genpd->suspended_count--; 11090883ac03SUlf Hansson genpd_unlock(genpd); 1110596ba34bSRafael J. Wysocki 111117218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 111217218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 111317218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 111410da6542SMikko Perttunen if (ret) 111510da6542SMikko Perttunen return ret; 1116a935424bSUlf Hansson } 111710da6542SMikko Perttunen 1118a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1119596ba34bSRafael J. Wysocki } 1120596ba34bSRafael J. Wysocki 1121596ba34bSRafael J. Wysocki /** 11229e9704eaSUlf Hansson * genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain. 1123596ba34bSRafael J. Wysocki * @dev: Device to freeze. 1124596ba34bSRafael J. Wysocki * 1125596ba34bSRafael J. Wysocki * Carry out a late freeze of a device under the assumption that its 1126596ba34bSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 1127596ba34bSRafael J. Wysocki * struct generic_pm_domain representing a power domain consisting of I/O 1128596ba34bSRafael J. Wysocki * devices. 1129596ba34bSRafael J. Wysocki */ 11309e9704eaSUlf Hansson static int genpd_freeze_noirq(struct device *dev) 1131596ba34bSRafael J. Wysocki { 1132d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1133122a2237SUlf Hansson int ret = 0; 1134596ba34bSRafael J. Wysocki 1135596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1136596ba34bSRafael J. Wysocki 1137596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1138596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1139596ba34bSRafael J. Wysocki return -EINVAL; 1140596ba34bSRafael J. Wysocki 114110da6542SMikko Perttunen ret = pm_generic_freeze_noirq(dev); 114210da6542SMikko Perttunen if (ret) 114310da6542SMikko Perttunen return ret; 114410da6542SMikko Perttunen 114517218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 114617218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) 114717218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1148122a2237SUlf Hansson 1149122a2237SUlf Hansson return ret; 1150596ba34bSRafael J. Wysocki } 1151596ba34bSRafael J. Wysocki 1152596ba34bSRafael J. Wysocki /** 11539e9704eaSUlf Hansson * genpd_thaw_noirq - Early thaw of device in an I/O PM domain. 1154596ba34bSRafael J. Wysocki * @dev: Device to thaw. 1155596ba34bSRafael J. Wysocki * 11560496c8aeSRafael J. Wysocki * Start the device, unless power has been removed from the domain already 11570496c8aeSRafael J. Wysocki * before the system transition. 1158596ba34bSRafael J. Wysocki */ 11599e9704eaSUlf Hansson static int genpd_thaw_noirq(struct device *dev) 1160596ba34bSRafael J. Wysocki { 1161d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1162122a2237SUlf Hansson int ret = 0; 1163596ba34bSRafael J. Wysocki 1164596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1165596ba34bSRafael J. Wysocki 1166596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1167596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1168596ba34bSRafael J. Wysocki return -EINVAL; 1169596ba34bSRafael J. Wysocki 117017218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 117117218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 117217218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 117310da6542SMikko Perttunen if (ret) 1174122a2237SUlf Hansson return ret; 11750496c8aeSRafael J. Wysocki } 1176596ba34bSRafael J. Wysocki 117710da6542SMikko Perttunen return pm_generic_thaw_noirq(dev); 117810da6542SMikko Perttunen } 117910da6542SMikko Perttunen 118010da6542SMikko Perttunen /** 11819e9704eaSUlf Hansson * genpd_poweroff_noirq - Completion of hibernation of device in an 118210da6542SMikko Perttunen * I/O PM domain. 118310da6542SMikko Perttunen * @dev: Device to poweroff. 118410da6542SMikko Perttunen * 118510da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 118610da6542SMikko Perttunen * been stopped. 118710da6542SMikko Perttunen */ 11889e9704eaSUlf Hansson static int genpd_poweroff_noirq(struct device *dev) 118910da6542SMikko Perttunen { 119010da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 119110da6542SMikko Perttunen 119210da6542SMikko Perttunen return genpd_finish_suspend(dev, true); 119310da6542SMikko Perttunen } 119410da6542SMikko Perttunen 11950496c8aeSRafael J. Wysocki /** 11969e9704eaSUlf Hansson * genpd_restore_noirq - Start of restore of device in an I/O PM domain. 1197596ba34bSRafael J. Wysocki * @dev: Device to resume. 1198596ba34bSRafael J. Wysocki * 11990496c8aeSRafael J. Wysocki * Make sure the domain will be in the same power state as before the 12000496c8aeSRafael J. Wysocki * hibernation the system is resuming from and start the device if necessary. 1201596ba34bSRafael J. Wysocki */ 12029e9704eaSUlf Hansson static int genpd_restore_noirq(struct device *dev) 1203596ba34bSRafael J. Wysocki { 1204596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1205122a2237SUlf Hansson int ret = 0; 1206596ba34bSRafael J. Wysocki 1207596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1208596ba34bSRafael J. Wysocki 1209596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1210596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1211596ba34bSRafael J. Wysocki return -EINVAL; 1212596ba34bSRafael J. Wysocki 1213596ba34bSRafael J. Wysocki /* 121465533bbfSRafael J. Wysocki * At this point suspended_count == 0 means we are being run for the 121565533bbfSRafael J. Wysocki * first time for the given domain in the present cycle. 121665533bbfSRafael J. Wysocki */ 12170883ac03SUlf Hansson genpd_lock(genpd); 121839dd0f23SUlf Hansson if (genpd->suspended_count++ == 0) 121965533bbfSRafael J. Wysocki /* 122065533bbfSRafael J. Wysocki * The boot kernel might put the domain into arbitrary state, 122186e12eacSUlf Hansson * so make it appear as powered off to genpd_sync_power_on(), 1222802d8b49SRafael J. Wysocki * so that it tries to power it on in case it was really off. 1223596ba34bSRafael J. Wysocki */ 122417b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 122518dd2eceSRafael J. Wysocki 12260883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 12270883ac03SUlf Hansson genpd_unlock(genpd); 1228596ba34bSRafael J. Wysocki 122917218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 123017218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 123117218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 123210da6542SMikko Perttunen if (ret) 1233122a2237SUlf Hansson return ret; 1234596ba34bSRafael J. Wysocki } 1235596ba34bSRafael J. Wysocki 123610da6542SMikko Perttunen return pm_generic_restore_noirq(dev); 123710da6542SMikko Perttunen } 123810da6542SMikko Perttunen 1239596ba34bSRafael J. Wysocki /** 12409e9704eaSUlf Hansson * genpd_complete - Complete power transition of a device in a power domain. 1241596ba34bSRafael J. Wysocki * @dev: Device to complete the transition of. 1242596ba34bSRafael J. Wysocki * 1243596ba34bSRafael J. Wysocki * Complete a power transition of a device (during a system-wide power 1244596ba34bSRafael J. Wysocki * transition) under the assumption that its pm_domain field points to the 1245596ba34bSRafael J. Wysocki * domain member of an object of type struct generic_pm_domain representing 1246596ba34bSRafael J. Wysocki * a power domain consisting of I/O devices. 1247596ba34bSRafael J. Wysocki */ 12489e9704eaSUlf Hansson static void genpd_complete(struct device *dev) 1249596ba34bSRafael J. Wysocki { 1250596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1251596ba34bSRafael J. Wysocki 1252596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1253596ba34bSRafael J. Wysocki 1254596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1255596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1256596ba34bSRafael J. Wysocki return; 1257596ba34bSRafael J. Wysocki 12584d23a5e8SUlf Hansson pm_generic_complete(dev); 12594d23a5e8SUlf Hansson 126035241d12SLina Iyer genpd_lock(genpd); 1261596ba34bSRafael J. Wysocki 126239dd0f23SUlf Hansson genpd->prepared_count--; 12634d23a5e8SUlf Hansson if (!genpd->prepared_count) 12644d23a5e8SUlf Hansson genpd_queue_power_off_work(genpd); 1265596ba34bSRafael J. Wysocki 126635241d12SLina Iyer genpd_unlock(genpd); 1267596ba34bSRafael J. Wysocki } 1268596ba34bSRafael J. Wysocki 126977f827deSRafael J. Wysocki /** 1270d47e6464SUlf Hansson * genpd_syscore_switch - Switch power during system core suspend or resume. 127177f827deSRafael J. Wysocki * @dev: Device that normally is marked as "always on" to switch power for. 127277f827deSRafael J. Wysocki * 127377f827deSRafael J. Wysocki * This routine may only be called during the system core (syscore) suspend or 127477f827deSRafael J. Wysocki * resume phase for devices whose "always on" flags are set. 127577f827deSRafael J. Wysocki */ 1276d47e6464SUlf Hansson static void genpd_syscore_switch(struct device *dev, bool suspend) 127777f827deSRafael J. Wysocki { 127877f827deSRafael J. Wysocki struct generic_pm_domain *genpd; 127977f827deSRafael J. Wysocki 128023c6d2c7SRafael J. Wysocki genpd = dev_to_genpd(dev); 12819e9704eaSUlf Hansson if (!genpd_present(genpd)) 128277f827deSRafael J. Wysocki return; 128377f827deSRafael J. Wysocki 128477f827deSRafael J. Wysocki if (suspend) { 128577f827deSRafael J. Wysocki genpd->suspended_count++; 12860883ac03SUlf Hansson genpd_sync_power_off(genpd, false, 0); 128777f827deSRafael J. Wysocki } else { 12880883ac03SUlf Hansson genpd_sync_power_on(genpd, false, 0); 128977f827deSRafael J. Wysocki genpd->suspended_count--; 129077f827deSRafael J. Wysocki } 129177f827deSRafael J. Wysocki } 1292d47e6464SUlf Hansson 1293d47e6464SUlf Hansson void pm_genpd_syscore_poweroff(struct device *dev) 1294d47e6464SUlf Hansson { 1295d47e6464SUlf Hansson genpd_syscore_switch(dev, true); 1296d47e6464SUlf Hansson } 1297d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff); 1298d47e6464SUlf Hansson 1299d47e6464SUlf Hansson void pm_genpd_syscore_poweron(struct device *dev) 1300d47e6464SUlf Hansson { 1301d47e6464SUlf Hansson genpd_syscore_switch(dev, false); 1302d47e6464SUlf Hansson } 1303d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron); 130477f827deSRafael J. Wysocki 1305d30d819dSRafael J. Wysocki #else /* !CONFIG_PM_SLEEP */ 1306596ba34bSRafael J. Wysocki 13079e9704eaSUlf Hansson #define genpd_prepare NULL 13089e9704eaSUlf Hansson #define genpd_suspend_noirq NULL 13099e9704eaSUlf Hansson #define genpd_resume_noirq NULL 13109e9704eaSUlf Hansson #define genpd_freeze_noirq NULL 13119e9704eaSUlf Hansson #define genpd_thaw_noirq NULL 13129e9704eaSUlf Hansson #define genpd_poweroff_noirq NULL 13139e9704eaSUlf Hansson #define genpd_restore_noirq NULL 13149e9704eaSUlf Hansson #define genpd_complete NULL 1315596ba34bSRafael J. Wysocki 1316596ba34bSRafael J. Wysocki #endif /* CONFIG_PM_SLEEP */ 1317596ba34bSRafael J. Wysocki 1318f104e1e5SUlf Hansson static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev, 1319f104e1e5SUlf Hansson struct gpd_timing_data *td) 13201d5fcfecSRafael J. Wysocki { 13211d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 13223e235685SUlf Hansson int ret; 13233e235685SUlf Hansson 13243e235685SUlf Hansson ret = dev_pm_get_subsys_data(dev); 13253e235685SUlf Hansson if (ret) 13263e235685SUlf Hansson return ERR_PTR(ret); 13271d5fcfecSRafael J. Wysocki 13281d5fcfecSRafael J. Wysocki gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL); 13293e235685SUlf Hansson if (!gpd_data) { 13303e235685SUlf Hansson ret = -ENOMEM; 13313e235685SUlf Hansson goto err_put; 13323e235685SUlf Hansson } 13331d5fcfecSRafael J. Wysocki 1334f104e1e5SUlf Hansson if (td) 1335f104e1e5SUlf Hansson gpd_data->td = *td; 1336f104e1e5SUlf Hansson 1337f104e1e5SUlf Hansson gpd_data->base.dev = dev; 1338f104e1e5SUlf Hansson gpd_data->td.constraint_changed = true; 13390759e80bSRafael J. Wysocki gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS; 1340f104e1e5SUlf Hansson gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier; 1341f104e1e5SUlf Hansson 1342f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1343f104e1e5SUlf Hansson 1344f104e1e5SUlf Hansson if (dev->power.subsys_data->domain_data) { 1345f104e1e5SUlf Hansson ret = -EINVAL; 1346f104e1e5SUlf Hansson goto err_free; 1347f104e1e5SUlf Hansson } 1348f104e1e5SUlf Hansson 1349f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = &gpd_data->base; 1350f104e1e5SUlf Hansson 1351f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1352f104e1e5SUlf Hansson 13531d5fcfecSRafael J. Wysocki return gpd_data; 13543e235685SUlf Hansson 1355f104e1e5SUlf Hansson err_free: 1356f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1357f104e1e5SUlf Hansson kfree(gpd_data); 13583e235685SUlf Hansson err_put: 13593e235685SUlf Hansson dev_pm_put_subsys_data(dev); 13603e235685SUlf Hansson return ERR_PTR(ret); 13611d5fcfecSRafael J. Wysocki } 13621d5fcfecSRafael J. Wysocki 136349d400c7SUlf Hansson static void genpd_free_dev_data(struct device *dev, 13641d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data) 13651d5fcfecSRafael J. Wysocki { 1366f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1367f104e1e5SUlf Hansson 1368f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = NULL; 1369f104e1e5SUlf Hansson 1370f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1371f104e1e5SUlf Hansson 13721d5fcfecSRafael J. Wysocki kfree(gpd_data); 13733e235685SUlf Hansson dev_pm_put_subsys_data(dev); 13741d5fcfecSRafael J. Wysocki } 13751d5fcfecSRafael J. Wysocki 137619efa5ffSJon Hunter static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev, 1377b02c999aSRafael J. Wysocki struct gpd_timing_data *td) 1378f721889fSRafael J. Wysocki { 1379c0356db7SUlf Hansson struct generic_pm_domain_data *gpd_data; 1380b56d9c91SUlf Hansson int ret; 1381f721889fSRafael J. Wysocki 1382f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1383f721889fSRafael J. Wysocki 1384f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) 1385f721889fSRafael J. Wysocki return -EINVAL; 1386f721889fSRafael J. Wysocki 138796c1bf68SUlf Hansson gpd_data = genpd_alloc_dev_data(dev, td); 13883e235685SUlf Hansson if (IS_ERR(gpd_data)) 13893e235685SUlf Hansson return PTR_ERR(gpd_data); 13906ff7bb0dSRafael J. Wysocki 139135241d12SLina Iyer genpd_lock(genpd); 1392f721889fSRafael J. Wysocki 1393b472c2faSUlf Hansson ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0; 1394b472c2faSUlf Hansson if (ret) 1395b472c2faSUlf Hansson goto out; 1396d79b6fe1SGeert Uytterhoeven 1397975e83cfSSudeep Holla dev_pm_domain_set(dev, &genpd->domain); 1398975e83cfSSudeep Holla 139914b53064SUlf Hansson genpd->device_count++; 140014b53064SUlf Hansson genpd->max_off_time_changed = true; 140114b53064SUlf Hansson 14021d5fcfecSRafael J. Wysocki list_add_tail(&gpd_data->base.list_node, &genpd->dev_list); 14036ff7bb0dSRafael J. Wysocki 1404f721889fSRafael J. Wysocki out: 140535241d12SLina Iyer genpd_unlock(genpd); 1406f721889fSRafael J. Wysocki 1407c0356db7SUlf Hansson if (ret) 1408c0356db7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 1409c0356db7SUlf Hansson else 1410c0356db7SUlf Hansson dev_pm_qos_add_notifier(dev, &gpd_data->nb); 14111d5fcfecSRafael J. Wysocki 1412f721889fSRafael J. Wysocki return ret; 1413f721889fSRafael J. Wysocki } 141419efa5ffSJon Hunter 141519efa5ffSJon Hunter /** 14161a7a6707SUlf Hansson * pm_genpd_add_device - Add a device to an I/O PM domain. 141719efa5ffSJon Hunter * @genpd: PM domain to add the device to. 141819efa5ffSJon Hunter * @dev: Device to be added. 141919efa5ffSJon Hunter */ 14201a7a6707SUlf Hansson int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev) 142119efa5ffSJon Hunter { 142219efa5ffSJon Hunter int ret; 142319efa5ffSJon Hunter 142419efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 14251a7a6707SUlf Hansson ret = genpd_add_device(genpd, dev, NULL); 142619efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 142719efa5ffSJon Hunter 142819efa5ffSJon Hunter return ret; 142919efa5ffSJon Hunter } 14301a7a6707SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_add_device); 1431f721889fSRafael J. Wysocki 143285168d56SUlf Hansson static int genpd_remove_device(struct generic_pm_domain *genpd, 1433f721889fSRafael J. Wysocki struct device *dev) 1434f721889fSRafael J. Wysocki { 14356ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 14364605ab65SRafael J. Wysocki struct pm_domain_data *pdd; 1437efa69025SRafael J. Wysocki int ret = 0; 1438f721889fSRafael J. Wysocki 1439f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1440f721889fSRafael J. Wysocki 1441c0356db7SUlf Hansson pdd = dev->power.subsys_data->domain_data; 1442c0356db7SUlf Hansson gpd_data = to_gpd_data(pdd); 1443c0356db7SUlf Hansson dev_pm_qos_remove_notifier(dev, &gpd_data->nb); 1444c0356db7SUlf Hansson 144535241d12SLina Iyer genpd_lock(genpd); 1446f721889fSRafael J. Wysocki 1447596ba34bSRafael J. Wysocki if (genpd->prepared_count > 0) { 1448596ba34bSRafael J. Wysocki ret = -EAGAIN; 1449596ba34bSRafael J. Wysocki goto out; 1450596ba34bSRafael J. Wysocki } 1451596ba34bSRafael J. Wysocki 14526ff7bb0dSRafael J. Wysocki genpd->device_count--; 14536ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 14546ff7bb0dSRafael J. Wysocki 1455d79b6fe1SGeert Uytterhoeven if (genpd->detach_dev) 1456c16561e8SUlf Hansson genpd->detach_dev(genpd, dev); 1457d79b6fe1SGeert Uytterhoeven 1458975e83cfSSudeep Holla dev_pm_domain_set(dev, NULL); 1459975e83cfSSudeep Holla 1460efa69025SRafael J. Wysocki list_del_init(&pdd->list_node); 14616ff7bb0dSRafael J. Wysocki 146235241d12SLina Iyer genpd_unlock(genpd); 14636ff7bb0dSRafael J. Wysocki 146449d400c7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 14651d5fcfecSRafael J. Wysocki 14666ff7bb0dSRafael J. Wysocki return 0; 1467f721889fSRafael J. Wysocki 1468596ba34bSRafael J. Wysocki out: 146935241d12SLina Iyer genpd_unlock(genpd); 1470c0356db7SUlf Hansson dev_pm_qos_add_notifier(dev, &gpd_data->nb); 1471f721889fSRafael J. Wysocki 1472f721889fSRafael J. Wysocki return ret; 1473f721889fSRafael J. Wysocki } 147485168d56SUlf Hansson 147585168d56SUlf Hansson /** 147685168d56SUlf Hansson * pm_genpd_remove_device - Remove a device from an I/O PM domain. 147785168d56SUlf Hansson * @dev: Device to be removed. 147885168d56SUlf Hansson */ 1479924f4486SUlf Hansson int pm_genpd_remove_device(struct device *dev) 148085168d56SUlf Hansson { 1481924f4486SUlf Hansson struct generic_pm_domain *genpd = genpd_lookup_dev(dev); 1482924f4486SUlf Hansson 1483924f4486SUlf Hansson if (!genpd) 148485168d56SUlf Hansson return -EINVAL; 148585168d56SUlf Hansson 148685168d56SUlf Hansson return genpd_remove_device(genpd, dev); 148785168d56SUlf Hansson } 148824c96dc7SMaruthi Bayyavarapu EXPORT_SYMBOL_GPL(pm_genpd_remove_device); 1489f721889fSRafael J. Wysocki 149019efa5ffSJon Hunter static int genpd_add_subdomain(struct generic_pm_domain *genpd, 1491bc0403ffSRafael J. Wysocki struct generic_pm_domain *subdomain) 1492f721889fSRafael J. Wysocki { 14932547923dSLina Iyer struct gpd_link *link, *itr; 1494f721889fSRafael J. Wysocki int ret = 0; 1495f721889fSRafael J. Wysocki 1496fb7268beSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain) 1497fb7268beSRafael J. Wysocki || genpd == subdomain) 1498f721889fSRafael J. Wysocki return -EINVAL; 1499f721889fSRafael J. Wysocki 1500d716f479SLina Iyer /* 1501d716f479SLina Iyer * If the domain can be powered on/off in an IRQ safe 1502d716f479SLina Iyer * context, ensure that the subdomain can also be 1503d716f479SLina Iyer * powered on/off in that context. 1504d716f479SLina Iyer */ 1505d716f479SLina Iyer if (!genpd_is_irq_safe(genpd) && genpd_is_irq_safe(subdomain)) { 150644cae7d5SDan Carpenter WARN(1, "Parent %s of subdomain %s must be IRQ safe\n", 1507d716f479SLina Iyer genpd->name, subdomain->name); 1508d716f479SLina Iyer return -EINVAL; 1509d716f479SLina Iyer } 1510d716f479SLina Iyer 15112547923dSLina Iyer link = kzalloc(sizeof(*link), GFP_KERNEL); 15122547923dSLina Iyer if (!link) 15132547923dSLina Iyer return -ENOMEM; 15142547923dSLina Iyer 151535241d12SLina Iyer genpd_lock(subdomain); 151635241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1517f721889fSRafael J. Wysocki 151841e2c8e0SUlf Hansson if (!genpd_status_on(genpd) && genpd_status_on(subdomain)) { 1519f721889fSRafael J. Wysocki ret = -EINVAL; 1520f721889fSRafael J. Wysocki goto out; 1521f721889fSRafael J. Wysocki } 1522f721889fSRafael J. Wysocki 15232547923dSLina Iyer list_for_each_entry(itr, &genpd->master_links, master_node) { 15242547923dSLina Iyer if (itr->slave == subdomain && itr->master == genpd) { 1525f721889fSRafael J. Wysocki ret = -EINVAL; 1526f721889fSRafael J. Wysocki goto out; 1527f721889fSRafael J. Wysocki } 1528f721889fSRafael J. Wysocki } 1529f721889fSRafael J. Wysocki 15305063ce15SRafael J. Wysocki link->master = genpd; 15315063ce15SRafael J. Wysocki list_add_tail(&link->master_node, &genpd->master_links); 1532bc0403ffSRafael J. Wysocki link->slave = subdomain; 1533bc0403ffSRafael J. Wysocki list_add_tail(&link->slave_node, &subdomain->slave_links); 153441e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1535c4bb3160SRafael J. Wysocki genpd_sd_counter_inc(genpd); 1536f721889fSRafael J. Wysocki 1537f721889fSRafael J. Wysocki out: 153835241d12SLina Iyer genpd_unlock(genpd); 153935241d12SLina Iyer genpd_unlock(subdomain); 15402547923dSLina Iyer if (ret) 15412547923dSLina Iyer kfree(link); 1542f721889fSRafael J. Wysocki return ret; 1543f721889fSRafael J. Wysocki } 154419efa5ffSJon Hunter 154519efa5ffSJon Hunter /** 154619efa5ffSJon Hunter * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 154719efa5ffSJon Hunter * @genpd: Master PM domain to add the subdomain to. 154819efa5ffSJon Hunter * @subdomain: Subdomain to be added. 154919efa5ffSJon Hunter */ 155019efa5ffSJon Hunter int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, 155119efa5ffSJon Hunter struct generic_pm_domain *subdomain) 155219efa5ffSJon Hunter { 155319efa5ffSJon Hunter int ret; 155419efa5ffSJon Hunter 155519efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 155619efa5ffSJon Hunter ret = genpd_add_subdomain(genpd, subdomain); 155719efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 155819efa5ffSJon Hunter 155919efa5ffSJon Hunter return ret; 156019efa5ffSJon Hunter } 1561d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_add_subdomain); 1562f721889fSRafael J. Wysocki 1563f721889fSRafael J. Wysocki /** 1564f721889fSRafael J. Wysocki * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain. 1565f721889fSRafael J. Wysocki * @genpd: Master PM domain to remove the subdomain from. 15665063ce15SRafael J. Wysocki * @subdomain: Subdomain to be removed. 1567f721889fSRafael J. Wysocki */ 1568f721889fSRafael J. Wysocki int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, 15695063ce15SRafael J. Wysocki struct generic_pm_domain *subdomain) 1570f721889fSRafael J. Wysocki { 1571c6e83cacSKrzysztof Kozlowski struct gpd_link *l, *link; 1572f721889fSRafael J. Wysocki int ret = -EINVAL; 1573f721889fSRafael J. Wysocki 15745063ce15SRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)) 1575f721889fSRafael J. Wysocki return -EINVAL; 1576f721889fSRafael J. Wysocki 157735241d12SLina Iyer genpd_lock(subdomain); 157835241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1579f721889fSRafael J. Wysocki 1580beda5fc1SJon Hunter if (!list_empty(&subdomain->master_links) || subdomain->device_count) { 158130e7a65bSJon Hunter pr_warn("%s: unable to remove subdomain %s\n", genpd->name, 158230e7a65bSJon Hunter subdomain->name); 158330e7a65bSJon Hunter ret = -EBUSY; 158430e7a65bSJon Hunter goto out; 158530e7a65bSJon Hunter } 158630e7a65bSJon Hunter 1587c6e83cacSKrzysztof Kozlowski list_for_each_entry_safe(link, l, &genpd->master_links, master_node) { 15885063ce15SRafael J. Wysocki if (link->slave != subdomain) 1589f721889fSRafael J. Wysocki continue; 1590f721889fSRafael J. Wysocki 15915063ce15SRafael J. Wysocki list_del(&link->master_node); 15925063ce15SRafael J. Wysocki list_del(&link->slave_node); 15935063ce15SRafael J. Wysocki kfree(link); 159441e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1595f721889fSRafael J. Wysocki genpd_sd_counter_dec(genpd); 1596f721889fSRafael J. Wysocki 1597f721889fSRafael J. Wysocki ret = 0; 1598f721889fSRafael J. Wysocki break; 1599f721889fSRafael J. Wysocki } 1600f721889fSRafael J. Wysocki 160130e7a65bSJon Hunter out: 160235241d12SLina Iyer genpd_unlock(genpd); 160335241d12SLina Iyer genpd_unlock(subdomain); 1604f721889fSRafael J. Wysocki 1605f721889fSRafael J. Wysocki return ret; 1606f721889fSRafael J. Wysocki } 1607d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_remove_subdomain); 1608f721889fSRafael J. Wysocki 160959d65b73SLina Iyer static int genpd_set_default_power_state(struct generic_pm_domain *genpd) 161059d65b73SLina Iyer { 161159d65b73SLina Iyer struct genpd_power_state *state; 161259d65b73SLina Iyer 161359d65b73SLina Iyer state = kzalloc(sizeof(*state), GFP_KERNEL); 161459d65b73SLina Iyer if (!state) 161559d65b73SLina Iyer return -ENOMEM; 161659d65b73SLina Iyer 161759d65b73SLina Iyer genpd->states = state; 161859d65b73SLina Iyer genpd->state_count = 1; 161959d65b73SLina Iyer genpd->free = state; 162059d65b73SLina Iyer 162159d65b73SLina Iyer return 0; 162259d65b73SLina Iyer } 162359d65b73SLina Iyer 1624d716f479SLina Iyer static void genpd_lock_init(struct generic_pm_domain *genpd) 1625d716f479SLina Iyer { 1626d716f479SLina Iyer if (genpd->flags & GENPD_FLAG_IRQ_SAFE) { 1627d716f479SLina Iyer spin_lock_init(&genpd->slock); 1628d716f479SLina Iyer genpd->lock_ops = &genpd_spin_ops; 1629d716f479SLina Iyer } else { 1630d716f479SLina Iyer mutex_init(&genpd->mlock); 1631d716f479SLina Iyer genpd->lock_ops = &genpd_mtx_ops; 1632d716f479SLina Iyer } 1633d716f479SLina Iyer } 1634d716f479SLina Iyer 1635d23b9b00SRafael J. Wysocki /** 1636f721889fSRafael J. Wysocki * pm_genpd_init - Initialize a generic I/O PM domain object. 1637f721889fSRafael J. Wysocki * @genpd: PM domain object to initialize. 1638f721889fSRafael J. Wysocki * @gov: PM domain governor to associate with the domain (may be NULL). 1639f721889fSRafael J. Wysocki * @is_off: Initial value of the domain's power_is_off field. 16407eb231c3SUlf Hansson * 16417eb231c3SUlf Hansson * Returns 0 on successful initialization, else a negative error code. 1642f721889fSRafael J. Wysocki */ 16437eb231c3SUlf Hansson int pm_genpd_init(struct generic_pm_domain *genpd, 1644f721889fSRafael J. Wysocki struct dev_power_governor *gov, bool is_off) 1645f721889fSRafael J. Wysocki { 164659d65b73SLina Iyer int ret; 164759d65b73SLina Iyer 1648f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 16497eb231c3SUlf Hansson return -EINVAL; 1650f721889fSRafael J. Wysocki 16515063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->master_links); 16525063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->slave_links); 1653f721889fSRafael J. Wysocki INIT_LIST_HEAD(&genpd->dev_list); 1654d716f479SLina Iyer genpd_lock_init(genpd); 1655f721889fSRafael J. Wysocki genpd->gov = gov; 1656f721889fSRafael J. Wysocki INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn); 1657c4bb3160SRafael J. Wysocki atomic_set(&genpd->sd_count, 0); 165817b75ecaSRafael J. Wysocki genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE; 1659596ba34bSRafael J. Wysocki genpd->device_count = 0; 1660221e9b58SRafael J. Wysocki genpd->max_off_time_ns = -1; 16616ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 1662de0aa06dSJon Hunter genpd->provider = NULL; 1663de0aa06dSJon Hunter genpd->has_provider = false; 1664afece3abSThara Gopinath genpd->accounting_time = ktime_get(); 1665795bd2e7SUlf Hansson genpd->domain.ops.runtime_suspend = genpd_runtime_suspend; 1666795bd2e7SUlf Hansson genpd->domain.ops.runtime_resume = genpd_runtime_resume; 16679e9704eaSUlf Hansson genpd->domain.ops.prepare = genpd_prepare; 16689e9704eaSUlf Hansson genpd->domain.ops.suspend_noirq = genpd_suspend_noirq; 16699e9704eaSUlf Hansson genpd->domain.ops.resume_noirq = genpd_resume_noirq; 16709e9704eaSUlf Hansson genpd->domain.ops.freeze_noirq = genpd_freeze_noirq; 16719e9704eaSUlf Hansson genpd->domain.ops.thaw_noirq = genpd_thaw_noirq; 16729e9704eaSUlf Hansson genpd->domain.ops.poweroff_noirq = genpd_poweroff_noirq; 16739e9704eaSUlf Hansson genpd->domain.ops.restore_noirq = genpd_restore_noirq; 16749e9704eaSUlf Hansson genpd->domain.ops.complete = genpd_complete; 1675c11f6f5bSUlf Hansson 1676c11f6f5bSUlf Hansson if (genpd->flags & GENPD_FLAG_PM_CLK) { 1677c11f6f5bSUlf Hansson genpd->dev_ops.stop = pm_clk_suspend; 1678c11f6f5bSUlf Hansson genpd->dev_ops.start = pm_clk_resume; 1679c11f6f5bSUlf Hansson } 1680c11f6f5bSUlf Hansson 1681ffaa42e8SUlf Hansson /* Always-on domains must be powered on at initialization. */ 1682ffaa42e8SUlf Hansson if (genpd_is_always_on(genpd) && !genpd_status_on(genpd)) 1683ffaa42e8SUlf Hansson return -EINVAL; 1684ffaa42e8SUlf Hansson 1685fc5cbf0cSAxel Haslam /* Use only one "off" state if there were no states declared */ 168659d65b73SLina Iyer if (genpd->state_count == 0) { 168759d65b73SLina Iyer ret = genpd_set_default_power_state(genpd); 168859d65b73SLina Iyer if (ret) 168959d65b73SLina Iyer return ret; 169059d65b73SLina Iyer } 1691fc5cbf0cSAxel Haslam 1692401ea157SViresh Kumar device_initialize(&genpd->dev); 1693401ea157SViresh Kumar dev_set_name(&genpd->dev, "%s", genpd->name); 1694401ea157SViresh Kumar 16955125bbf3SRafael J. Wysocki mutex_lock(&gpd_list_lock); 16965125bbf3SRafael J. Wysocki list_add(&genpd->gpd_list_node, &gpd_list); 16975125bbf3SRafael J. Wysocki mutex_unlock(&gpd_list_lock); 16987eb231c3SUlf Hansson 16997eb231c3SUlf Hansson return 0; 17005125bbf3SRafael J. Wysocki } 1701be5ed55dSRajendra Nayak EXPORT_SYMBOL_GPL(pm_genpd_init); 1702aa42240aSTomasz Figa 17033fe57710SJon Hunter static int genpd_remove(struct generic_pm_domain *genpd) 17043fe57710SJon Hunter { 17053fe57710SJon Hunter struct gpd_link *l, *link; 17063fe57710SJon Hunter 17073fe57710SJon Hunter if (IS_ERR_OR_NULL(genpd)) 17083fe57710SJon Hunter return -EINVAL; 17093fe57710SJon Hunter 171035241d12SLina Iyer genpd_lock(genpd); 17113fe57710SJon Hunter 17123fe57710SJon Hunter if (genpd->has_provider) { 171335241d12SLina Iyer genpd_unlock(genpd); 17143fe57710SJon Hunter pr_err("Provider present, unable to remove %s\n", genpd->name); 17153fe57710SJon Hunter return -EBUSY; 17163fe57710SJon Hunter } 17173fe57710SJon Hunter 17183fe57710SJon Hunter if (!list_empty(&genpd->master_links) || genpd->device_count) { 171935241d12SLina Iyer genpd_unlock(genpd); 17203fe57710SJon Hunter pr_err("%s: unable to remove %s\n", __func__, genpd->name); 17213fe57710SJon Hunter return -EBUSY; 17223fe57710SJon Hunter } 17233fe57710SJon Hunter 17243fe57710SJon Hunter list_for_each_entry_safe(link, l, &genpd->slave_links, slave_node) { 17253fe57710SJon Hunter list_del(&link->master_node); 17263fe57710SJon Hunter list_del(&link->slave_node); 17273fe57710SJon Hunter kfree(link); 17283fe57710SJon Hunter } 17293fe57710SJon Hunter 17303fe57710SJon Hunter list_del(&genpd->gpd_list_node); 173135241d12SLina Iyer genpd_unlock(genpd); 17323fe57710SJon Hunter cancel_work_sync(&genpd->power_off_work); 173359d65b73SLina Iyer kfree(genpd->free); 17343fe57710SJon Hunter pr_debug("%s: removed %s\n", __func__, genpd->name); 17353fe57710SJon Hunter 17363fe57710SJon Hunter return 0; 17373fe57710SJon Hunter } 17383fe57710SJon Hunter 17393fe57710SJon Hunter /** 17403fe57710SJon Hunter * pm_genpd_remove - Remove a generic I/O PM domain 17413fe57710SJon Hunter * @genpd: Pointer to PM domain that is to be removed. 17423fe57710SJon Hunter * 17433fe57710SJon Hunter * To remove the PM domain, this function: 17443fe57710SJon Hunter * - Removes the PM domain as a subdomain to any parent domains, 17453fe57710SJon Hunter * if it was added. 17463fe57710SJon Hunter * - Removes the PM domain from the list of registered PM domains. 17473fe57710SJon Hunter * 17483fe57710SJon Hunter * The PM domain will only be removed, if the associated provider has 17493fe57710SJon Hunter * been removed, it is not a parent to any other PM domain and has no 17503fe57710SJon Hunter * devices associated with it. 17513fe57710SJon Hunter */ 17523fe57710SJon Hunter int pm_genpd_remove(struct generic_pm_domain *genpd) 17533fe57710SJon Hunter { 17543fe57710SJon Hunter int ret; 17553fe57710SJon Hunter 17563fe57710SJon Hunter mutex_lock(&gpd_list_lock); 17573fe57710SJon Hunter ret = genpd_remove(genpd); 17583fe57710SJon Hunter mutex_unlock(&gpd_list_lock); 17593fe57710SJon Hunter 17603fe57710SJon Hunter return ret; 17613fe57710SJon Hunter } 17623fe57710SJon Hunter EXPORT_SYMBOL_GPL(pm_genpd_remove); 17633fe57710SJon Hunter 1764aa42240aSTomasz Figa #ifdef CONFIG_PM_GENERIC_DOMAINS_OF 1765892ebdccSJon Hunter 1766aa42240aSTomasz Figa /* 1767aa42240aSTomasz Figa * Device Tree based PM domain providers. 1768aa42240aSTomasz Figa * 1769aa42240aSTomasz Figa * The code below implements generic device tree based PM domain providers that 1770aa42240aSTomasz Figa * bind device tree nodes with generic PM domains registered in the system. 1771aa42240aSTomasz Figa * 1772aa42240aSTomasz Figa * Any driver that registers generic PM domains and needs to support binding of 1773aa42240aSTomasz Figa * devices to these domains is supposed to register a PM domain provider, which 1774aa42240aSTomasz Figa * maps a PM domain specifier retrieved from the device tree to a PM domain. 1775aa42240aSTomasz Figa * 1776aa42240aSTomasz Figa * Two simple mapping functions have been provided for convenience: 1777892ebdccSJon Hunter * - genpd_xlate_simple() for 1:1 device tree node to PM domain mapping. 1778892ebdccSJon Hunter * - genpd_xlate_onecell() for mapping of multiple PM domains per node by 1779aa42240aSTomasz Figa * index. 1780aa42240aSTomasz Figa */ 1781aa42240aSTomasz Figa 1782aa42240aSTomasz Figa /** 1783aa42240aSTomasz Figa * struct of_genpd_provider - PM domain provider registration structure 1784aa42240aSTomasz Figa * @link: Entry in global list of PM domain providers 1785aa42240aSTomasz Figa * @node: Pointer to device tree node of PM domain provider 1786aa42240aSTomasz Figa * @xlate: Provider-specific xlate callback mapping a set of specifier cells 1787aa42240aSTomasz Figa * into a PM domain. 1788aa42240aSTomasz Figa * @data: context pointer to be passed into @xlate callback 1789aa42240aSTomasz Figa */ 1790aa42240aSTomasz Figa struct of_genpd_provider { 1791aa42240aSTomasz Figa struct list_head link; 1792aa42240aSTomasz Figa struct device_node *node; 1793aa42240aSTomasz Figa genpd_xlate_t xlate; 1794aa42240aSTomasz Figa void *data; 1795aa42240aSTomasz Figa }; 1796aa42240aSTomasz Figa 1797aa42240aSTomasz Figa /* List of registered PM domain providers. */ 1798aa42240aSTomasz Figa static LIST_HEAD(of_genpd_providers); 1799aa42240aSTomasz Figa /* Mutex to protect the list above. */ 1800aa42240aSTomasz Figa static DEFINE_MUTEX(of_genpd_mutex); 1801aa42240aSTomasz Figa 1802aa42240aSTomasz Figa /** 1803892ebdccSJon Hunter * genpd_xlate_simple() - Xlate function for direct node-domain mapping 1804aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1805aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct generic_pm_domain 1806aa42240aSTomasz Figa * 1807aa42240aSTomasz Figa * This is a generic xlate function that can be used to model PM domains that 1808aa42240aSTomasz Figa * have their own device tree nodes. The private data of xlate function needs 1809aa42240aSTomasz Figa * to be a valid pointer to struct generic_pm_domain. 1810aa42240aSTomasz Figa */ 1811892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_simple( 1812aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1813aa42240aSTomasz Figa void *data) 1814aa42240aSTomasz Figa { 1815aa42240aSTomasz Figa return data; 1816aa42240aSTomasz Figa } 1817aa42240aSTomasz Figa 1818aa42240aSTomasz Figa /** 1819892ebdccSJon Hunter * genpd_xlate_onecell() - Xlate function using a single index. 1820aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1821aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct genpd_onecell_data 1822aa42240aSTomasz Figa * 1823aa42240aSTomasz Figa * This is a generic xlate function that can be used to model simple PM domain 1824aa42240aSTomasz Figa * controllers that have one device tree node and provide multiple PM domains. 1825aa42240aSTomasz Figa * A single cell is used as an index into an array of PM domains specified in 1826aa42240aSTomasz Figa * the genpd_onecell_data struct when registering the provider. 1827aa42240aSTomasz Figa */ 1828892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_onecell( 1829aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1830aa42240aSTomasz Figa void *data) 1831aa42240aSTomasz Figa { 1832aa42240aSTomasz Figa struct genpd_onecell_data *genpd_data = data; 1833aa42240aSTomasz Figa unsigned int idx = genpdspec->args[0]; 1834aa42240aSTomasz Figa 1835aa42240aSTomasz Figa if (genpdspec->args_count != 1) 1836aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1837aa42240aSTomasz Figa 1838aa42240aSTomasz Figa if (idx >= genpd_data->num_domains) { 1839aa42240aSTomasz Figa pr_err("%s: invalid domain index %u\n", __func__, idx); 1840aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1841aa42240aSTomasz Figa } 1842aa42240aSTomasz Figa 1843aa42240aSTomasz Figa if (!genpd_data->domains[idx]) 1844aa42240aSTomasz Figa return ERR_PTR(-ENOENT); 1845aa42240aSTomasz Figa 1846aa42240aSTomasz Figa return genpd_data->domains[idx]; 1847aa42240aSTomasz Figa } 1848aa42240aSTomasz Figa 1849aa42240aSTomasz Figa /** 1850892ebdccSJon Hunter * genpd_add_provider() - Register a PM domain provider for a node 1851aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider. 1852aa42240aSTomasz Figa * @xlate: Callback for decoding PM domain from phandle arguments. 1853aa42240aSTomasz Figa * @data: Context pointer for @xlate callback. 1854aa42240aSTomasz Figa */ 1855892ebdccSJon Hunter static int genpd_add_provider(struct device_node *np, genpd_xlate_t xlate, 1856aa42240aSTomasz Figa void *data) 1857aa42240aSTomasz Figa { 1858aa42240aSTomasz Figa struct of_genpd_provider *cp; 1859aa42240aSTomasz Figa 1860aa42240aSTomasz Figa cp = kzalloc(sizeof(*cp), GFP_KERNEL); 1861aa42240aSTomasz Figa if (!cp) 1862aa42240aSTomasz Figa return -ENOMEM; 1863aa42240aSTomasz Figa 1864aa42240aSTomasz Figa cp->node = of_node_get(np); 1865aa42240aSTomasz Figa cp->data = data; 1866aa42240aSTomasz Figa cp->xlate = xlate; 1867aa42240aSTomasz Figa 1868aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 1869aa42240aSTomasz Figa list_add(&cp->link, &of_genpd_providers); 1870aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 1871ea11e94bSRob Herring pr_debug("Added domain provider from %pOF\n", np); 1872aa42240aSTomasz Figa 1873aa42240aSTomasz Figa return 0; 1874aa42240aSTomasz Figa } 1875892ebdccSJon Hunter 1876892ebdccSJon Hunter /** 1877892ebdccSJon Hunter * of_genpd_add_provider_simple() - Register a simple PM domain provider 1878892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 1879892ebdccSJon Hunter * @genpd: Pointer to PM domain associated with the PM domain provider. 1880892ebdccSJon Hunter */ 1881892ebdccSJon Hunter int of_genpd_add_provider_simple(struct device_node *np, 1882892ebdccSJon Hunter struct generic_pm_domain *genpd) 1883892ebdccSJon Hunter { 18840159ec67SJon Hunter int ret = -EINVAL; 18850159ec67SJon Hunter 18860159ec67SJon Hunter if (!np || !genpd) 18870159ec67SJon Hunter return -EINVAL; 18880159ec67SJon Hunter 18890159ec67SJon Hunter mutex_lock(&gpd_list_lock); 18900159ec67SJon Hunter 18916a0ae73dSViresh Kumar if (!genpd_present(genpd)) 18926a0ae73dSViresh Kumar goto unlock; 18936a0ae73dSViresh Kumar 18946a0ae73dSViresh Kumar genpd->dev.of_node = np; 18956a0ae73dSViresh Kumar 18966a0ae73dSViresh Kumar /* Parse genpd OPP table */ 18976a0ae73dSViresh Kumar if (genpd->set_performance_state) { 18986a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table(&genpd->dev); 18996a0ae73dSViresh Kumar if (ret) { 19006a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table: %d\n", 19016a0ae73dSViresh Kumar ret); 19026a0ae73dSViresh Kumar goto unlock; 1903de0aa06dSJon Hunter } 19048ce95844SViresh Kumar } 1905de0aa06dSJon Hunter 19066a0ae73dSViresh Kumar ret = genpd_add_provider(np, genpd_xlate_simple, genpd); 19076a0ae73dSViresh Kumar if (ret) { 19086a0ae73dSViresh Kumar if (genpd->set_performance_state) 19096a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 19106a0ae73dSViresh Kumar 19116a0ae73dSViresh Kumar goto unlock; 19126a0ae73dSViresh Kumar } 19136a0ae73dSViresh Kumar 19146a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 19156a0ae73dSViresh Kumar genpd->has_provider = true; 19166a0ae73dSViresh Kumar 19176a0ae73dSViresh Kumar unlock: 19180159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 19190159ec67SJon Hunter 19200159ec67SJon Hunter return ret; 1921892ebdccSJon Hunter } 1922892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_simple); 1923892ebdccSJon Hunter 1924892ebdccSJon Hunter /** 1925892ebdccSJon Hunter * of_genpd_add_provider_onecell() - Register a onecell PM domain provider 1926892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 1927892ebdccSJon Hunter * @data: Pointer to the data associated with the PM domain provider. 1928892ebdccSJon Hunter */ 1929892ebdccSJon Hunter int of_genpd_add_provider_onecell(struct device_node *np, 1930892ebdccSJon Hunter struct genpd_onecell_data *data) 1931892ebdccSJon Hunter { 19326a0ae73dSViresh Kumar struct generic_pm_domain *genpd; 19330159ec67SJon Hunter unsigned int i; 1934de0aa06dSJon Hunter int ret = -EINVAL; 19350159ec67SJon Hunter 19360159ec67SJon Hunter if (!np || !data) 19370159ec67SJon Hunter return -EINVAL; 19380159ec67SJon Hunter 19390159ec67SJon Hunter mutex_lock(&gpd_list_lock); 19400159ec67SJon Hunter 194140845524SThierry Reding if (!data->xlate) 194240845524SThierry Reding data->xlate = genpd_xlate_onecell; 194340845524SThierry Reding 19440159ec67SJon Hunter for (i = 0; i < data->num_domains; i++) { 19456a0ae73dSViresh Kumar genpd = data->domains[i]; 19466a0ae73dSViresh Kumar 19476a0ae73dSViresh Kumar if (!genpd) 1948609bed67STomeu Vizoso continue; 19496a0ae73dSViresh Kumar if (!genpd_present(genpd)) 1950de0aa06dSJon Hunter goto error; 1951de0aa06dSJon Hunter 19526a0ae73dSViresh Kumar genpd->dev.of_node = np; 19536a0ae73dSViresh Kumar 19546a0ae73dSViresh Kumar /* Parse genpd OPP table */ 19556a0ae73dSViresh Kumar if (genpd->set_performance_state) { 19566a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i); 19576a0ae73dSViresh Kumar if (ret) { 19586a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table for index %d: %d\n", 19596a0ae73dSViresh Kumar i, ret); 19606a0ae73dSViresh Kumar goto error; 19616a0ae73dSViresh Kumar } 19626a0ae73dSViresh Kumar } 19636a0ae73dSViresh Kumar 19646a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 19656a0ae73dSViresh Kumar genpd->has_provider = true; 19660159ec67SJon Hunter } 19670159ec67SJon Hunter 196840845524SThierry Reding ret = genpd_add_provider(np, data->xlate, data); 1969de0aa06dSJon Hunter if (ret < 0) 1970de0aa06dSJon Hunter goto error; 1971de0aa06dSJon Hunter 1972de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 1973de0aa06dSJon Hunter 1974de0aa06dSJon Hunter return 0; 1975de0aa06dSJon Hunter 1976de0aa06dSJon Hunter error: 1977de0aa06dSJon Hunter while (i--) { 19786a0ae73dSViresh Kumar genpd = data->domains[i]; 19796a0ae73dSViresh Kumar 19806a0ae73dSViresh Kumar if (!genpd) 1981609bed67STomeu Vizoso continue; 19826a0ae73dSViresh Kumar 19836a0ae73dSViresh Kumar genpd->provider = NULL; 19846a0ae73dSViresh Kumar genpd->has_provider = false; 19856a0ae73dSViresh Kumar 19866a0ae73dSViresh Kumar if (genpd->set_performance_state) 19876a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 1988de0aa06dSJon Hunter } 19890159ec67SJon Hunter 19900159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 19910159ec67SJon Hunter 19920159ec67SJon Hunter return ret; 1993892ebdccSJon Hunter } 1994892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_onecell); 1995aa42240aSTomasz Figa 1996aa42240aSTomasz Figa /** 1997aa42240aSTomasz Figa * of_genpd_del_provider() - Remove a previously registered PM domain provider 1998aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider 1999aa42240aSTomasz Figa */ 2000aa42240aSTomasz Figa void of_genpd_del_provider(struct device_node *np) 2001aa42240aSTomasz Figa { 2002b556b15dSKrzysztof Kozlowski struct of_genpd_provider *cp, *tmp; 2003de0aa06dSJon Hunter struct generic_pm_domain *gpd; 2004aa42240aSTomasz Figa 2005de0aa06dSJon Hunter mutex_lock(&gpd_list_lock); 2006aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2007b556b15dSKrzysztof Kozlowski list_for_each_entry_safe(cp, tmp, &of_genpd_providers, link) { 2008aa42240aSTomasz Figa if (cp->node == np) { 2009de0aa06dSJon Hunter /* 2010de0aa06dSJon Hunter * For each PM domain associated with the 2011de0aa06dSJon Hunter * provider, set the 'has_provider' to false 2012de0aa06dSJon Hunter * so that the PM domain can be safely removed. 2013de0aa06dSJon Hunter */ 20146a0ae73dSViresh Kumar list_for_each_entry(gpd, &gpd_list, gpd_list_node) { 20156a0ae73dSViresh Kumar if (gpd->provider == &np->fwnode) { 2016de0aa06dSJon Hunter gpd->has_provider = false; 2017de0aa06dSJon Hunter 20186a0ae73dSViresh Kumar if (!gpd->set_performance_state) 20196a0ae73dSViresh Kumar continue; 20206a0ae73dSViresh Kumar 20216a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&gpd->dev); 20226a0ae73dSViresh Kumar } 20236a0ae73dSViresh Kumar } 20246a0ae73dSViresh Kumar 2025aa42240aSTomasz Figa list_del(&cp->link); 2026aa42240aSTomasz Figa of_node_put(cp->node); 2027aa42240aSTomasz Figa kfree(cp); 2028aa42240aSTomasz Figa break; 2029aa42240aSTomasz Figa } 2030aa42240aSTomasz Figa } 2031aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2032de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 2033aa42240aSTomasz Figa } 2034aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(of_genpd_del_provider); 2035aa42240aSTomasz Figa 2036aa42240aSTomasz Figa /** 2037f58d4e5aSJon Hunter * genpd_get_from_provider() - Look-up PM domain 2038aa42240aSTomasz Figa * @genpdspec: OF phandle args to use for look-up 2039aa42240aSTomasz Figa * 2040aa42240aSTomasz Figa * Looks for a PM domain provider under the node specified by @genpdspec and if 2041aa42240aSTomasz Figa * found, uses xlate function of the provider to map phandle args to a PM 2042aa42240aSTomasz Figa * domain. 2043aa42240aSTomasz Figa * 2044aa42240aSTomasz Figa * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR() 2045aa42240aSTomasz Figa * on failure. 2046aa42240aSTomasz Figa */ 2047f58d4e5aSJon Hunter static struct generic_pm_domain *genpd_get_from_provider( 2048aa42240aSTomasz Figa struct of_phandle_args *genpdspec) 2049aa42240aSTomasz Figa { 2050aa42240aSTomasz Figa struct generic_pm_domain *genpd = ERR_PTR(-ENOENT); 2051aa42240aSTomasz Figa struct of_genpd_provider *provider; 2052aa42240aSTomasz Figa 205341795a8aSJon Hunter if (!genpdspec) 205441795a8aSJon Hunter return ERR_PTR(-EINVAL); 205541795a8aSJon Hunter 2056aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2057aa42240aSTomasz Figa 2058aa42240aSTomasz Figa /* Check if we have such a provider in our array */ 2059aa42240aSTomasz Figa list_for_each_entry(provider, &of_genpd_providers, link) { 2060aa42240aSTomasz Figa if (provider->node == genpdspec->np) 2061aa42240aSTomasz Figa genpd = provider->xlate(genpdspec, provider->data); 2062aa42240aSTomasz Figa if (!IS_ERR(genpd)) 2063aa42240aSTomasz Figa break; 2064aa42240aSTomasz Figa } 2065aa42240aSTomasz Figa 2066aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2067aa42240aSTomasz Figa 2068aa42240aSTomasz Figa return genpd; 2069aa42240aSTomasz Figa } 2070aa42240aSTomasz Figa 2071aa42240aSTomasz Figa /** 2072ec69572bSJon Hunter * of_genpd_add_device() - Add a device to an I/O PM domain 2073ec69572bSJon Hunter * @genpdspec: OF phandle args to use for look-up PM domain 2074ec69572bSJon Hunter * @dev: Device to be added. 2075ec69572bSJon Hunter * 2076ec69572bSJon Hunter * Looks-up an I/O PM domain based upon phandle args provided and adds 2077ec69572bSJon Hunter * the device to the PM domain. Returns a negative error code on failure. 2078ec69572bSJon Hunter */ 2079ec69572bSJon Hunter int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev) 2080ec69572bSJon Hunter { 2081ec69572bSJon Hunter struct generic_pm_domain *genpd; 208219efa5ffSJon Hunter int ret; 208319efa5ffSJon Hunter 208419efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2085ec69572bSJon Hunter 2086f58d4e5aSJon Hunter genpd = genpd_get_from_provider(genpdspec); 208719efa5ffSJon Hunter if (IS_ERR(genpd)) { 208819efa5ffSJon Hunter ret = PTR_ERR(genpd); 208919efa5ffSJon Hunter goto out; 209019efa5ffSJon Hunter } 2091ec69572bSJon Hunter 209219efa5ffSJon Hunter ret = genpd_add_device(genpd, dev, NULL); 209319efa5ffSJon Hunter 209419efa5ffSJon Hunter out: 209519efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 209619efa5ffSJon Hunter 209719efa5ffSJon Hunter return ret; 2098ec69572bSJon Hunter } 2099ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_device); 2100ec69572bSJon Hunter 2101ec69572bSJon Hunter /** 2102ec69572bSJon Hunter * of_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 2103ec69572bSJon Hunter * @parent_spec: OF phandle args to use for parent PM domain look-up 2104ec69572bSJon Hunter * @subdomain_spec: OF phandle args to use for subdomain look-up 2105ec69572bSJon Hunter * 2106ec69572bSJon Hunter * Looks-up a parent PM domain and subdomain based upon phandle args 2107ec69572bSJon Hunter * provided and adds the subdomain to the parent PM domain. Returns a 2108ec69572bSJon Hunter * negative error code on failure. 2109ec69572bSJon Hunter */ 2110ec69572bSJon Hunter int of_genpd_add_subdomain(struct of_phandle_args *parent_spec, 2111ec69572bSJon Hunter struct of_phandle_args *subdomain_spec) 2112ec69572bSJon Hunter { 2113ec69572bSJon Hunter struct generic_pm_domain *parent, *subdomain; 211419efa5ffSJon Hunter int ret; 211519efa5ffSJon Hunter 211619efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2117ec69572bSJon Hunter 2118f58d4e5aSJon Hunter parent = genpd_get_from_provider(parent_spec); 211919efa5ffSJon Hunter if (IS_ERR(parent)) { 212019efa5ffSJon Hunter ret = PTR_ERR(parent); 212119efa5ffSJon Hunter goto out; 212219efa5ffSJon Hunter } 2123ec69572bSJon Hunter 2124f58d4e5aSJon Hunter subdomain = genpd_get_from_provider(subdomain_spec); 212519efa5ffSJon Hunter if (IS_ERR(subdomain)) { 212619efa5ffSJon Hunter ret = PTR_ERR(subdomain); 212719efa5ffSJon Hunter goto out; 212819efa5ffSJon Hunter } 2129ec69572bSJon Hunter 213019efa5ffSJon Hunter ret = genpd_add_subdomain(parent, subdomain); 213119efa5ffSJon Hunter 213219efa5ffSJon Hunter out: 213319efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 213419efa5ffSJon Hunter 213519efa5ffSJon Hunter return ret; 2136ec69572bSJon Hunter } 2137ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_subdomain); 2138ec69572bSJon Hunter 2139ec69572bSJon Hunter /** 214017926551SJon Hunter * of_genpd_remove_last - Remove the last PM domain registered for a provider 214117926551SJon Hunter * @provider: Pointer to device structure associated with provider 214217926551SJon Hunter * 214317926551SJon Hunter * Find the last PM domain that was added by a particular provider and 214417926551SJon Hunter * remove this PM domain from the list of PM domains. The provider is 214517926551SJon Hunter * identified by the 'provider' device structure that is passed. The PM 214617926551SJon Hunter * domain will only be removed, if the provider associated with domain 214717926551SJon Hunter * has been removed. 214817926551SJon Hunter * 214917926551SJon Hunter * Returns a valid pointer to struct generic_pm_domain on success or 215017926551SJon Hunter * ERR_PTR() on failure. 215117926551SJon Hunter */ 215217926551SJon Hunter struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) 215317926551SJon Hunter { 2154a7e2d1bcSKrzysztof Kozlowski struct generic_pm_domain *gpd, *tmp, *genpd = ERR_PTR(-ENOENT); 215517926551SJon Hunter int ret; 215617926551SJon Hunter 215717926551SJon Hunter if (IS_ERR_OR_NULL(np)) 215817926551SJon Hunter return ERR_PTR(-EINVAL); 215917926551SJon Hunter 216017926551SJon Hunter mutex_lock(&gpd_list_lock); 2161a7e2d1bcSKrzysztof Kozlowski list_for_each_entry_safe(gpd, tmp, &gpd_list, gpd_list_node) { 216217926551SJon Hunter if (gpd->provider == &np->fwnode) { 216317926551SJon Hunter ret = genpd_remove(gpd); 216417926551SJon Hunter genpd = ret ? ERR_PTR(ret) : gpd; 216517926551SJon Hunter break; 216617926551SJon Hunter } 216717926551SJon Hunter } 216817926551SJon Hunter mutex_unlock(&gpd_list_lock); 216917926551SJon Hunter 217017926551SJon Hunter return genpd; 217117926551SJon Hunter } 217217926551SJon Hunter EXPORT_SYMBOL_GPL(of_genpd_remove_last); 217317926551SJon Hunter 217417926551SJon Hunter /** 2175aa42240aSTomasz Figa * genpd_dev_pm_detach - Detach a device from its PM domain. 21768bb6944eSJon Hunter * @dev: Device to detach. 2177aa42240aSTomasz Figa * @power_off: Currently not used 2178aa42240aSTomasz Figa * 2179aa42240aSTomasz Figa * Try to locate a corresponding generic PM domain, which the device was 2180aa42240aSTomasz Figa * attached to previously. If such is found, the device is detached from it. 2181aa42240aSTomasz Figa */ 2182aa42240aSTomasz Figa static void genpd_dev_pm_detach(struct device *dev, bool power_off) 2183aa42240aSTomasz Figa { 2184446d999cSRussell King struct generic_pm_domain *pd; 218593af5e93SGeert Uytterhoeven unsigned int i; 2186aa42240aSTomasz Figa int ret = 0; 2187aa42240aSTomasz Figa 218885168d56SUlf Hansson pd = dev_to_genpd(dev); 218985168d56SUlf Hansson if (IS_ERR(pd)) 2190aa42240aSTomasz Figa return; 2191aa42240aSTomasz Figa 2192aa42240aSTomasz Figa dev_dbg(dev, "removing from PM domain %s\n", pd->name); 2193aa42240aSTomasz Figa 219493af5e93SGeert Uytterhoeven for (i = 1; i < GENPD_RETRY_MAX_MS; i <<= 1) { 219585168d56SUlf Hansson ret = genpd_remove_device(pd, dev); 2196aa42240aSTomasz Figa if (ret != -EAGAIN) 2197aa42240aSTomasz Figa break; 219893af5e93SGeert Uytterhoeven 219993af5e93SGeert Uytterhoeven mdelay(i); 2200aa42240aSTomasz Figa cond_resched(); 2201aa42240aSTomasz Figa } 2202aa42240aSTomasz Figa 2203aa42240aSTomasz Figa if (ret < 0) { 2204aa42240aSTomasz Figa dev_err(dev, "failed to remove from PM domain %s: %d", 2205aa42240aSTomasz Figa pd->name, ret); 2206aa42240aSTomasz Figa return; 2207aa42240aSTomasz Figa } 2208aa42240aSTomasz Figa 2209aa42240aSTomasz Figa /* Check if PM domain can be powered off after removing this device. */ 2210aa42240aSTomasz Figa genpd_queue_power_off_work(pd); 2211aa42240aSTomasz Figa } 2212aa42240aSTomasz Figa 2213632f7ce3SRussell King static void genpd_dev_pm_sync(struct device *dev) 2214632f7ce3SRussell King { 2215632f7ce3SRussell King struct generic_pm_domain *pd; 2216632f7ce3SRussell King 2217632f7ce3SRussell King pd = dev_to_genpd(dev); 2218632f7ce3SRussell King if (IS_ERR(pd)) 2219632f7ce3SRussell King return; 2220632f7ce3SRussell King 2221632f7ce3SRussell King genpd_queue_power_off_work(pd); 2222632f7ce3SRussell King } 2223632f7ce3SRussell King 2224aa42240aSTomasz Figa /** 2225aa42240aSTomasz Figa * genpd_dev_pm_attach - Attach a device to its PM domain using DT. 2226aa42240aSTomasz Figa * @dev: Device to attach. 2227aa42240aSTomasz Figa * 2228aa42240aSTomasz Figa * Parse device's OF node to find a PM domain specifier. If such is found, 2229aa42240aSTomasz Figa * attaches the device to retrieved pm_domain ops. 2230aa42240aSTomasz Figa * 2231919b7308SUlf Hansson * Returns 1 on successfully attached PM domain, 0 when the device don't need a 2232919b7308SUlf Hansson * PM domain or a negative error code in case of failures. Note that if a 2233919b7308SUlf Hansson * power-domain exists for the device, but it cannot be found or turned on, 2234919b7308SUlf Hansson * then return -EPROBE_DEFER to ensure that the device is not probed and to 2235919b7308SUlf Hansson * re-try again later. 2236aa42240aSTomasz Figa */ 2237aa42240aSTomasz Figa int genpd_dev_pm_attach(struct device *dev) 2238aa42240aSTomasz Figa { 2239aa42240aSTomasz Figa struct of_phandle_args pd_args; 2240aa42240aSTomasz Figa struct generic_pm_domain *pd; 2241aa42240aSTomasz Figa int ret; 2242aa42240aSTomasz Figa 2243aa42240aSTomasz Figa if (!dev->of_node) 2244919b7308SUlf Hansson return 0; 2245aa42240aSTomasz Figa 2246aa42240aSTomasz Figa ret = of_parse_phandle_with_args(dev->of_node, "power-domains", 2247aa42240aSTomasz Figa "#power-domain-cells", 0, &pd_args); 2248001d50c9SGeert Uytterhoeven if (ret < 0) 2249919b7308SUlf Hansson return 0; 2250aa42240aSTomasz Figa 225119efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2252f58d4e5aSJon Hunter pd = genpd_get_from_provider(&pd_args); 2253265e2cf6SEric Anholt of_node_put(pd_args.np); 2254aa42240aSTomasz Figa if (IS_ERR(pd)) { 225519efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2256aa42240aSTomasz Figa dev_dbg(dev, "%s() failed to find PM domain: %ld\n", 2257aa42240aSTomasz Figa __func__, PTR_ERR(pd)); 2258311fa6adSJon Hunter return -EPROBE_DEFER; 2259aa42240aSTomasz Figa } 2260aa42240aSTomasz Figa 2261aa42240aSTomasz Figa dev_dbg(dev, "adding to PM domain %s\n", pd->name); 2262aa42240aSTomasz Figa 226319efa5ffSJon Hunter ret = genpd_add_device(pd, dev, NULL); 226419efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2265aa42240aSTomasz Figa 2266aa42240aSTomasz Figa if (ret < 0) { 226734994692SGeert Uytterhoeven if (ret != -EPROBE_DEFER) 2268aa42240aSTomasz Figa dev_err(dev, "failed to add to PM domain %s: %d", 2269aa42240aSTomasz Figa pd->name, ret); 2270919b7308SUlf Hansson return ret; 2271aa42240aSTomasz Figa } 2272aa42240aSTomasz Figa 2273aa42240aSTomasz Figa dev->pm_domain->detach = genpd_dev_pm_detach; 2274632f7ce3SRussell King dev->pm_domain->sync = genpd_dev_pm_sync; 2275aa42240aSTomasz Figa 227635241d12SLina Iyer genpd_lock(pd); 227786e12eacSUlf Hansson ret = genpd_power_on(pd, 0); 227835241d12SLina Iyer genpd_unlock(pd); 227972038df3SUlf Hansson 228072038df3SUlf Hansson if (ret) 228172038df3SUlf Hansson genpd_remove_device(pd, dev); 2282919b7308SUlf Hansson 2283919b7308SUlf Hansson return ret ? -EPROBE_DEFER : 1; 2284aa42240aSTomasz Figa } 2285aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(genpd_dev_pm_attach); 228630f60428SLina Iyer 228730f60428SLina Iyer static const struct of_device_id idle_state_match[] = { 2288598da548SLina Iyer { .compatible = "domain-idle-state", }, 228930f60428SLina Iyer { } 229030f60428SLina Iyer }; 229130f60428SLina Iyer 229230f60428SLina Iyer static int genpd_parse_state(struct genpd_power_state *genpd_state, 229330f60428SLina Iyer struct device_node *state_node) 229430f60428SLina Iyer { 229530f60428SLina Iyer int err; 229630f60428SLina Iyer u32 residency; 229730f60428SLina Iyer u32 entry_latency, exit_latency; 229830f60428SLina Iyer 229930f60428SLina Iyer err = of_property_read_u32(state_node, "entry-latency-us", 230030f60428SLina Iyer &entry_latency); 230130f60428SLina Iyer if (err) { 2302ea11e94bSRob Herring pr_debug(" * %pOF missing entry-latency-us property\n", 2303ea11e94bSRob Herring state_node); 230430f60428SLina Iyer return -EINVAL; 230530f60428SLina Iyer } 230630f60428SLina Iyer 230730f60428SLina Iyer err = of_property_read_u32(state_node, "exit-latency-us", 230830f60428SLina Iyer &exit_latency); 230930f60428SLina Iyer if (err) { 2310ea11e94bSRob Herring pr_debug(" * %pOF missing exit-latency-us property\n", 2311ea11e94bSRob Herring state_node); 231230f60428SLina Iyer return -EINVAL; 231330f60428SLina Iyer } 231430f60428SLina Iyer 231530f60428SLina Iyer err = of_property_read_u32(state_node, "min-residency-us", &residency); 231630f60428SLina Iyer if (!err) 231730f60428SLina Iyer genpd_state->residency_ns = 1000 * residency; 231830f60428SLina Iyer 231930f60428SLina Iyer genpd_state->power_on_latency_ns = 1000 * exit_latency; 232030f60428SLina Iyer genpd_state->power_off_latency_ns = 1000 * entry_latency; 23210c9b694aSLina Iyer genpd_state->fwnode = &state_node->fwnode; 232230f60428SLina Iyer 232330f60428SLina Iyer return 0; 232430f60428SLina Iyer } 232530f60428SLina Iyer 2326a3381e3aSUlf Hansson static int genpd_iterate_idle_states(struct device_node *dn, 2327a3381e3aSUlf Hansson struct genpd_power_state *states) 2328a3381e3aSUlf Hansson { 2329a3381e3aSUlf Hansson int ret; 2330a3381e3aSUlf Hansson struct of_phandle_iterator it; 2331a3381e3aSUlf Hansson struct device_node *np; 2332a3381e3aSUlf Hansson int i = 0; 2333a3381e3aSUlf Hansson 2334a3381e3aSUlf Hansson ret = of_count_phandle_with_args(dn, "domain-idle-states", NULL); 2335a3381e3aSUlf Hansson if (ret <= 0) 2336a3381e3aSUlf Hansson return ret; 2337a3381e3aSUlf Hansson 2338a3381e3aSUlf Hansson /* Loop over the phandles until all the requested entry is found */ 2339a3381e3aSUlf Hansson of_for_each_phandle(&it, ret, dn, "domain-idle-states", NULL, 0) { 2340a3381e3aSUlf Hansson np = it.node; 2341a3381e3aSUlf Hansson if (!of_match_node(idle_state_match, np)) 2342a3381e3aSUlf Hansson continue; 2343a3381e3aSUlf Hansson if (states) { 2344a3381e3aSUlf Hansson ret = genpd_parse_state(&states[i], np); 2345a3381e3aSUlf Hansson if (ret) { 2346a3381e3aSUlf Hansson pr_err("Parsing idle state node %pOF failed with err %d\n", 2347a3381e3aSUlf Hansson np, ret); 2348a3381e3aSUlf Hansson of_node_put(np); 2349a3381e3aSUlf Hansson return ret; 2350a3381e3aSUlf Hansson } 2351a3381e3aSUlf Hansson } 2352a3381e3aSUlf Hansson i++; 2353a3381e3aSUlf Hansson } 2354a3381e3aSUlf Hansson 2355a3381e3aSUlf Hansson return i; 2356a3381e3aSUlf Hansson } 2357a3381e3aSUlf Hansson 235830f60428SLina Iyer /** 235930f60428SLina Iyer * of_genpd_parse_idle_states: Return array of idle states for the genpd. 236030f60428SLina Iyer * 236130f60428SLina Iyer * @dn: The genpd device node 236230f60428SLina Iyer * @states: The pointer to which the state array will be saved. 236330f60428SLina Iyer * @n: The count of elements in the array returned from this function. 236430f60428SLina Iyer * 236530f60428SLina Iyer * Returns the device states parsed from the OF node. The memory for the states 236630f60428SLina Iyer * is allocated by this function and is the responsibility of the caller to 2367a3381e3aSUlf Hansson * free the memory after use. If no domain idle states is found it returns 2368a3381e3aSUlf Hansson * -EINVAL and in case of errors, a negative error code. 236930f60428SLina Iyer */ 237030f60428SLina Iyer int of_genpd_parse_idle_states(struct device_node *dn, 237130f60428SLina Iyer struct genpd_power_state **states, int *n) 237230f60428SLina Iyer { 237330f60428SLina Iyer struct genpd_power_state *st; 2374a3381e3aSUlf Hansson int ret; 237530f60428SLina Iyer 2376a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, NULL); 2377a3381e3aSUlf Hansson if (ret <= 0) 2378a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 237930f60428SLina Iyer 2380a3381e3aSUlf Hansson st = kcalloc(ret, sizeof(*st), GFP_KERNEL); 238130f60428SLina Iyer if (!st) 238230f60428SLina Iyer return -ENOMEM; 238330f60428SLina Iyer 2384a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, st); 2385a3381e3aSUlf Hansson if (ret <= 0) { 238630f60428SLina Iyer kfree(st); 2387a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 238830f60428SLina Iyer } 238930f60428SLina Iyer 239030f60428SLina Iyer *states = st; 2391a3381e3aSUlf Hansson *n = ret; 239230f60428SLina Iyer 239330f60428SLina Iyer return 0; 239430f60428SLina Iyer } 239530f60428SLina Iyer EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states); 239630f60428SLina Iyer 23976e41766aSViresh Kumar /** 23986e41766aSViresh Kumar * of_genpd_opp_to_performance_state- Gets performance state of device's 23996e41766aSViresh Kumar * power domain corresponding to a DT node's "required-opps" property. 24006e41766aSViresh Kumar * 24016e41766aSViresh Kumar * @dev: Device for which the performance-state needs to be found. 24026e41766aSViresh Kumar * @opp_node: DT node where the "required-opps" property is present. This can be 24036e41766aSViresh Kumar * the device node itself (if it doesn't have an OPP table) or a node 24046e41766aSViresh Kumar * within the OPP table of a device (if device has an OPP table). 24056e41766aSViresh Kumar * @state: Pointer to return performance state. 24066e41766aSViresh Kumar * 24076e41766aSViresh Kumar * Returns performance state corresponding to the "required-opps" property of 24086e41766aSViresh Kumar * a DT node. This calls platform specific genpd->opp_to_performance_state() 24096e41766aSViresh Kumar * callback to translate power domain OPP to performance state. 24106e41766aSViresh Kumar * 24116e41766aSViresh Kumar * Returns performance state on success and 0 on failure. 24126e41766aSViresh Kumar */ 24136e41766aSViresh Kumar unsigned int of_genpd_opp_to_performance_state(struct device *dev, 24146e41766aSViresh Kumar struct device_node *opp_node) 24156e41766aSViresh Kumar { 24166e41766aSViresh Kumar struct generic_pm_domain *genpd; 24176e41766aSViresh Kumar struct dev_pm_opp *opp; 24186e41766aSViresh Kumar int state = 0; 24196e41766aSViresh Kumar 24206e41766aSViresh Kumar genpd = dev_to_genpd(dev); 24216e41766aSViresh Kumar if (IS_ERR(genpd)) 24226e41766aSViresh Kumar return 0; 24236e41766aSViresh Kumar 24246e41766aSViresh Kumar if (unlikely(!genpd->set_performance_state)) 24256e41766aSViresh Kumar return 0; 24266e41766aSViresh Kumar 24276e41766aSViresh Kumar genpd_lock(genpd); 24286e41766aSViresh Kumar 24296e41766aSViresh Kumar opp = of_dev_pm_opp_find_required_opp(&genpd->dev, opp_node); 24306e41766aSViresh Kumar if (IS_ERR(opp)) { 24319ad14c00SViresh Kumar dev_err(dev, "Failed to find required OPP: %ld\n", 24329ad14c00SViresh Kumar PTR_ERR(opp)); 24336e41766aSViresh Kumar goto unlock; 24346e41766aSViresh Kumar } 24356e41766aSViresh Kumar 24366e41766aSViresh Kumar state = genpd->opp_to_performance_state(genpd, opp); 24376e41766aSViresh Kumar dev_pm_opp_put(opp); 24386e41766aSViresh Kumar 24396e41766aSViresh Kumar unlock: 24406e41766aSViresh Kumar genpd_unlock(genpd); 24416e41766aSViresh Kumar 24426e41766aSViresh Kumar return state; 24436e41766aSViresh Kumar } 24446e41766aSViresh Kumar EXPORT_SYMBOL_GPL(of_genpd_opp_to_performance_state); 24456e41766aSViresh Kumar 2446d30d819dSRafael J. Wysocki #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */ 24472bd5306aSMaciej Matraszek 24482bd5306aSMaciej Matraszek 24492bd5306aSMaciej Matraszek /*** debugfs support ***/ 24502bd5306aSMaciej Matraszek 24518b0510b5SJon Hunter #ifdef CONFIG_DEBUG_FS 24522bd5306aSMaciej Matraszek #include <linux/pm.h> 24532bd5306aSMaciej Matraszek #include <linux/device.h> 24542bd5306aSMaciej Matraszek #include <linux/debugfs.h> 24552bd5306aSMaciej Matraszek #include <linux/seq_file.h> 24562bd5306aSMaciej Matraszek #include <linux/init.h> 24572bd5306aSMaciej Matraszek #include <linux/kobject.h> 24589e9704eaSUlf Hansson static struct dentry *genpd_debugfs_dir; 24592bd5306aSMaciej Matraszek 24602bd5306aSMaciej Matraszek /* 24612bd5306aSMaciej Matraszek * TODO: This function is a slightly modified version of rtpm_status_show 2462d30d819dSRafael J. Wysocki * from sysfs.c, so generalize it. 24632bd5306aSMaciej Matraszek */ 24642bd5306aSMaciej Matraszek static void rtpm_status_str(struct seq_file *s, struct device *dev) 24652bd5306aSMaciej Matraszek { 24662bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 24672bd5306aSMaciej Matraszek [RPM_ACTIVE] = "active", 24682bd5306aSMaciej Matraszek [RPM_RESUMING] = "resuming", 24692bd5306aSMaciej Matraszek [RPM_SUSPENDED] = "suspended", 24702bd5306aSMaciej Matraszek [RPM_SUSPENDING] = "suspending" 24712bd5306aSMaciej Matraszek }; 24722bd5306aSMaciej Matraszek const char *p = ""; 24732bd5306aSMaciej Matraszek 24742bd5306aSMaciej Matraszek if (dev->power.runtime_error) 24752bd5306aSMaciej Matraszek p = "error"; 24762bd5306aSMaciej Matraszek else if (dev->power.disable_depth) 24772bd5306aSMaciej Matraszek p = "unsupported"; 24782bd5306aSMaciej Matraszek else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup)) 24792bd5306aSMaciej Matraszek p = status_lookup[dev->power.runtime_status]; 24802bd5306aSMaciej Matraszek else 24812bd5306aSMaciej Matraszek WARN_ON(1); 24822bd5306aSMaciej Matraszek 24832bd5306aSMaciej Matraszek seq_puts(s, p); 24842bd5306aSMaciej Matraszek } 24852bd5306aSMaciej Matraszek 24869e9704eaSUlf Hansson static int genpd_summary_one(struct seq_file *s, 248766a5ca4bSKevin Hilman struct generic_pm_domain *genpd) 24882bd5306aSMaciej Matraszek { 24892bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 24902bd5306aSMaciej Matraszek [GPD_STATE_ACTIVE] = "on", 24912bd5306aSMaciej Matraszek [GPD_STATE_POWER_OFF] = "off" 24922bd5306aSMaciej Matraszek }; 24932bd5306aSMaciej Matraszek struct pm_domain_data *pm_data; 24942bd5306aSMaciej Matraszek const char *kobj_path; 24952bd5306aSMaciej Matraszek struct gpd_link *link; 24966954d432SGeert Uytterhoeven char state[16]; 24972bd5306aSMaciej Matraszek int ret; 24982bd5306aSMaciej Matraszek 249935241d12SLina Iyer ret = genpd_lock_interruptible(genpd); 25002bd5306aSMaciej Matraszek if (ret) 25012bd5306aSMaciej Matraszek return -ERESTARTSYS; 25022bd5306aSMaciej Matraszek 250366a5ca4bSKevin Hilman if (WARN_ON(genpd->status >= ARRAY_SIZE(status_lookup))) 25042bd5306aSMaciej Matraszek goto exit; 250541e2c8e0SUlf Hansson if (!genpd_status_on(genpd)) 25060ba554e4SGeert Uytterhoeven snprintf(state, sizeof(state), "%s-%u", 25076954d432SGeert Uytterhoeven status_lookup[genpd->status], genpd->state_idx); 2508fc5cbf0cSAxel Haslam else 25096954d432SGeert Uytterhoeven snprintf(state, sizeof(state), "%s", 25106954d432SGeert Uytterhoeven status_lookup[genpd->status]); 25116954d432SGeert Uytterhoeven seq_printf(s, "%-30s %-15s ", genpd->name, state); 25122bd5306aSMaciej Matraszek 25132bd5306aSMaciej Matraszek /* 25142bd5306aSMaciej Matraszek * Modifications on the list require holding locks on both 25152bd5306aSMaciej Matraszek * master and slave, so we are safe. 251666a5ca4bSKevin Hilman * Also genpd->name is immutable. 25172bd5306aSMaciej Matraszek */ 251866a5ca4bSKevin Hilman list_for_each_entry(link, &genpd->master_links, master_node) { 25192bd5306aSMaciej Matraszek seq_printf(s, "%s", link->slave->name); 252066a5ca4bSKevin Hilman if (!list_is_last(&link->master_node, &genpd->master_links)) 25212bd5306aSMaciej Matraszek seq_puts(s, ", "); 25222bd5306aSMaciej Matraszek } 25232bd5306aSMaciej Matraszek 252466a5ca4bSKevin Hilman list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2525d716f479SLina Iyer kobj_path = kobject_get_path(&pm_data->dev->kobj, 2526d716f479SLina Iyer genpd_is_irq_safe(genpd) ? 2527d716f479SLina Iyer GFP_ATOMIC : GFP_KERNEL); 25282bd5306aSMaciej Matraszek if (kobj_path == NULL) 25292bd5306aSMaciej Matraszek continue; 25302bd5306aSMaciej Matraszek 25312bd5306aSMaciej Matraszek seq_printf(s, "\n %-50s ", kobj_path); 25322bd5306aSMaciej Matraszek rtpm_status_str(s, pm_data->dev); 25332bd5306aSMaciej Matraszek kfree(kobj_path); 25342bd5306aSMaciej Matraszek } 25352bd5306aSMaciej Matraszek 25362bd5306aSMaciej Matraszek seq_puts(s, "\n"); 25372bd5306aSMaciej Matraszek exit: 253835241d12SLina Iyer genpd_unlock(genpd); 25392bd5306aSMaciej Matraszek 25402bd5306aSMaciej Matraszek return 0; 25412bd5306aSMaciej Matraszek } 25422bd5306aSMaciej Matraszek 2543b6a1d093SThara Gopinath static int genpd_summary_show(struct seq_file *s, void *data) 25442bd5306aSMaciej Matraszek { 254566a5ca4bSKevin Hilman struct generic_pm_domain *genpd; 25462bd5306aSMaciej Matraszek int ret = 0; 25472bd5306aSMaciej Matraszek 25482bd5306aSMaciej Matraszek seq_puts(s, "domain status slaves\n"); 25492bd5306aSMaciej Matraszek seq_puts(s, " /device runtime status\n"); 25502bd5306aSMaciej Matraszek seq_puts(s, "----------------------------------------------------------------------\n"); 25512bd5306aSMaciej Matraszek 25522bd5306aSMaciej Matraszek ret = mutex_lock_interruptible(&gpd_list_lock); 25532bd5306aSMaciej Matraszek if (ret) 25542bd5306aSMaciej Matraszek return -ERESTARTSYS; 25552bd5306aSMaciej Matraszek 255666a5ca4bSKevin Hilman list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 25579e9704eaSUlf Hansson ret = genpd_summary_one(s, genpd); 25582bd5306aSMaciej Matraszek if (ret) 25592bd5306aSMaciej Matraszek break; 25602bd5306aSMaciej Matraszek } 25612bd5306aSMaciej Matraszek mutex_unlock(&gpd_list_lock); 25622bd5306aSMaciej Matraszek 25632bd5306aSMaciej Matraszek return ret; 25642bd5306aSMaciej Matraszek } 25652bd5306aSMaciej Matraszek 2566b6a1d093SThara Gopinath static int genpd_status_show(struct seq_file *s, void *data) 25672bd5306aSMaciej Matraszek { 2568b6a1d093SThara Gopinath static const char * const status_lookup[] = { 2569b6a1d093SThara Gopinath [GPD_STATE_ACTIVE] = "on", 2570b6a1d093SThara Gopinath [GPD_STATE_POWER_OFF] = "off" 2571b6a1d093SThara Gopinath }; 2572b6a1d093SThara Gopinath 2573b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2574b6a1d093SThara Gopinath int ret = 0; 2575b6a1d093SThara Gopinath 2576b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2577b6a1d093SThara Gopinath if (ret) 2578b6a1d093SThara Gopinath return -ERESTARTSYS; 2579b6a1d093SThara Gopinath 2580b6a1d093SThara Gopinath if (WARN_ON_ONCE(genpd->status >= ARRAY_SIZE(status_lookup))) 2581b6a1d093SThara Gopinath goto exit; 2582b6a1d093SThara Gopinath 2583b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_POWER_OFF) 2584b6a1d093SThara Gopinath seq_printf(s, "%s-%u\n", status_lookup[genpd->status], 2585b6a1d093SThara Gopinath genpd->state_idx); 2586b6a1d093SThara Gopinath else 2587b6a1d093SThara Gopinath seq_printf(s, "%s\n", status_lookup[genpd->status]); 2588b6a1d093SThara Gopinath exit: 2589b6a1d093SThara Gopinath genpd_unlock(genpd); 2590b6a1d093SThara Gopinath return ret; 25912bd5306aSMaciej Matraszek } 25922bd5306aSMaciej Matraszek 2593b6a1d093SThara Gopinath static int genpd_sub_domains_show(struct seq_file *s, void *data) 2594b6a1d093SThara Gopinath { 2595b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2596b6a1d093SThara Gopinath struct gpd_link *link; 2597b6a1d093SThara Gopinath int ret = 0; 2598b6a1d093SThara Gopinath 2599b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2600b6a1d093SThara Gopinath if (ret) 2601b6a1d093SThara Gopinath return -ERESTARTSYS; 2602b6a1d093SThara Gopinath 2603b6a1d093SThara Gopinath list_for_each_entry(link, &genpd->master_links, master_node) 2604b6a1d093SThara Gopinath seq_printf(s, "%s\n", link->slave->name); 2605b6a1d093SThara Gopinath 2606b6a1d093SThara Gopinath genpd_unlock(genpd); 2607b6a1d093SThara Gopinath return ret; 2608b6a1d093SThara Gopinath } 2609b6a1d093SThara Gopinath 2610b6a1d093SThara Gopinath static int genpd_idle_states_show(struct seq_file *s, void *data) 2611b6a1d093SThara Gopinath { 2612b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2613b6a1d093SThara Gopinath unsigned int i; 2614b6a1d093SThara Gopinath int ret = 0; 2615b6a1d093SThara Gopinath 2616b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2617b6a1d093SThara Gopinath if (ret) 2618b6a1d093SThara Gopinath return -ERESTARTSYS; 2619b6a1d093SThara Gopinath 2620b6a1d093SThara Gopinath seq_puts(s, "State Time Spent(ms)\n"); 2621b6a1d093SThara Gopinath 2622b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2623b6a1d093SThara Gopinath ktime_t delta = 0; 2624b6a1d093SThara Gopinath s64 msecs; 2625b6a1d093SThara Gopinath 2626b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2627b6a1d093SThara Gopinath (genpd->state_idx == i)) 2628b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2629b6a1d093SThara Gopinath 2630b6a1d093SThara Gopinath msecs = ktime_to_ms( 2631b6a1d093SThara Gopinath ktime_add(genpd->states[i].idle_time, delta)); 2632b6a1d093SThara Gopinath seq_printf(s, "S%-13i %lld\n", i, msecs); 2633b6a1d093SThara Gopinath } 2634b6a1d093SThara Gopinath 2635b6a1d093SThara Gopinath genpd_unlock(genpd); 2636b6a1d093SThara Gopinath return ret; 2637b6a1d093SThara Gopinath } 2638b6a1d093SThara Gopinath 2639b6a1d093SThara Gopinath static int genpd_active_time_show(struct seq_file *s, void *data) 2640b6a1d093SThara Gopinath { 2641b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2642b6a1d093SThara Gopinath ktime_t delta = 0; 2643b6a1d093SThara Gopinath int ret = 0; 2644b6a1d093SThara Gopinath 2645b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2646b6a1d093SThara Gopinath if (ret) 2647b6a1d093SThara Gopinath return -ERESTARTSYS; 2648b6a1d093SThara Gopinath 2649b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) 2650b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2651b6a1d093SThara Gopinath 2652b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms( 2653b6a1d093SThara Gopinath ktime_add(genpd->on_time, delta))); 2654b6a1d093SThara Gopinath 2655b6a1d093SThara Gopinath genpd_unlock(genpd); 2656b6a1d093SThara Gopinath return ret; 2657b6a1d093SThara Gopinath } 2658b6a1d093SThara Gopinath 2659b6a1d093SThara Gopinath static int genpd_total_idle_time_show(struct seq_file *s, void *data) 2660b6a1d093SThara Gopinath { 2661b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2662b6a1d093SThara Gopinath ktime_t delta = 0, total = 0; 2663b6a1d093SThara Gopinath unsigned int i; 2664b6a1d093SThara Gopinath int ret = 0; 2665b6a1d093SThara Gopinath 2666b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2667b6a1d093SThara Gopinath if (ret) 2668b6a1d093SThara Gopinath return -ERESTARTSYS; 2669b6a1d093SThara Gopinath 2670b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2671b6a1d093SThara Gopinath 2672b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2673b6a1d093SThara Gopinath (genpd->state_idx == i)) 2674b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2675b6a1d093SThara Gopinath 2676b6a1d093SThara Gopinath total = ktime_add(total, genpd->states[i].idle_time); 2677b6a1d093SThara Gopinath } 2678b6a1d093SThara Gopinath total = ktime_add(total, delta); 2679b6a1d093SThara Gopinath 2680b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms(total)); 2681b6a1d093SThara Gopinath 2682b6a1d093SThara Gopinath genpd_unlock(genpd); 2683b6a1d093SThara Gopinath return ret; 2684b6a1d093SThara Gopinath } 2685b6a1d093SThara Gopinath 2686b6a1d093SThara Gopinath 2687b6a1d093SThara Gopinath static int genpd_devices_show(struct seq_file *s, void *data) 2688b6a1d093SThara Gopinath { 2689b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2690b6a1d093SThara Gopinath struct pm_domain_data *pm_data; 2691b6a1d093SThara Gopinath const char *kobj_path; 2692b6a1d093SThara Gopinath int ret = 0; 2693b6a1d093SThara Gopinath 2694b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2695b6a1d093SThara Gopinath if (ret) 2696b6a1d093SThara Gopinath return -ERESTARTSYS; 2697b6a1d093SThara Gopinath 2698b6a1d093SThara Gopinath list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2699b6a1d093SThara Gopinath kobj_path = kobject_get_path(&pm_data->dev->kobj, 2700b6a1d093SThara Gopinath genpd_is_irq_safe(genpd) ? 2701b6a1d093SThara Gopinath GFP_ATOMIC : GFP_KERNEL); 2702b6a1d093SThara Gopinath if (kobj_path == NULL) 2703b6a1d093SThara Gopinath continue; 2704b6a1d093SThara Gopinath 2705b6a1d093SThara Gopinath seq_printf(s, "%s\n", kobj_path); 2706b6a1d093SThara Gopinath kfree(kobj_path); 2707b6a1d093SThara Gopinath } 2708b6a1d093SThara Gopinath 2709b6a1d093SThara Gopinath genpd_unlock(genpd); 2710b6a1d093SThara Gopinath return ret; 2711b6a1d093SThara Gopinath } 2712b6a1d093SThara Gopinath 2713e8912812SRajendra Nayak static int genpd_perf_state_show(struct seq_file *s, void *data) 2714e8912812SRajendra Nayak { 2715e8912812SRajendra Nayak struct generic_pm_domain *genpd = s->private; 2716e8912812SRajendra Nayak 2717e8912812SRajendra Nayak if (genpd_lock_interruptible(genpd)) 2718e8912812SRajendra Nayak return -ERESTARTSYS; 2719e8912812SRajendra Nayak 2720e8912812SRajendra Nayak seq_printf(s, "%u\n", genpd->performance_state); 2721e8912812SRajendra Nayak 2722e8912812SRajendra Nayak genpd_unlock(genpd); 2723e8912812SRajendra Nayak return 0; 2724e8912812SRajendra Nayak } 2725e8912812SRajendra Nayak 2726b6a1d093SThara Gopinath #define define_genpd_open_function(name) \ 2727b6a1d093SThara Gopinath static int genpd_##name##_open(struct inode *inode, struct file *file) \ 2728b6a1d093SThara Gopinath { \ 2729b6a1d093SThara Gopinath return single_open(file, genpd_##name##_show, inode->i_private); \ 2730b6a1d093SThara Gopinath } 2731b6a1d093SThara Gopinath 2732b6a1d093SThara Gopinath define_genpd_open_function(summary); 2733b6a1d093SThara Gopinath define_genpd_open_function(status); 2734b6a1d093SThara Gopinath define_genpd_open_function(sub_domains); 2735b6a1d093SThara Gopinath define_genpd_open_function(idle_states); 2736b6a1d093SThara Gopinath define_genpd_open_function(active_time); 2737b6a1d093SThara Gopinath define_genpd_open_function(total_idle_time); 2738b6a1d093SThara Gopinath define_genpd_open_function(devices); 2739e8912812SRajendra Nayak define_genpd_open_function(perf_state); 2740b6a1d093SThara Gopinath 2741b6a1d093SThara Gopinath #define define_genpd_debugfs_fops(name) \ 2742b6a1d093SThara Gopinath static const struct file_operations genpd_##name##_fops = { \ 2743b6a1d093SThara Gopinath .open = genpd_##name##_open, \ 2744b6a1d093SThara Gopinath .read = seq_read, \ 2745b6a1d093SThara Gopinath .llseek = seq_lseek, \ 2746b6a1d093SThara Gopinath .release = single_release, \ 2747b6a1d093SThara Gopinath } 2748b6a1d093SThara Gopinath 2749b6a1d093SThara Gopinath define_genpd_debugfs_fops(summary); 2750b6a1d093SThara Gopinath define_genpd_debugfs_fops(status); 2751b6a1d093SThara Gopinath define_genpd_debugfs_fops(sub_domains); 2752b6a1d093SThara Gopinath define_genpd_debugfs_fops(idle_states); 2753b6a1d093SThara Gopinath define_genpd_debugfs_fops(active_time); 2754b6a1d093SThara Gopinath define_genpd_debugfs_fops(total_idle_time); 2755b6a1d093SThara Gopinath define_genpd_debugfs_fops(devices); 2756e8912812SRajendra Nayak define_genpd_debugfs_fops(perf_state); 27572bd5306aSMaciej Matraszek 27589e9704eaSUlf Hansson static int __init genpd_debug_init(void) 27592bd5306aSMaciej Matraszek { 27602bd5306aSMaciej Matraszek struct dentry *d; 2761b6a1d093SThara Gopinath struct generic_pm_domain *genpd; 27622bd5306aSMaciej Matraszek 27639e9704eaSUlf Hansson genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL); 27642bd5306aSMaciej Matraszek 27659e9704eaSUlf Hansson if (!genpd_debugfs_dir) 27662bd5306aSMaciej Matraszek return -ENOMEM; 27672bd5306aSMaciej Matraszek 27682bd5306aSMaciej Matraszek d = debugfs_create_file("pm_genpd_summary", S_IRUGO, 27699e9704eaSUlf Hansson genpd_debugfs_dir, NULL, &genpd_summary_fops); 27702bd5306aSMaciej Matraszek if (!d) 27712bd5306aSMaciej Matraszek return -ENOMEM; 27722bd5306aSMaciej Matraszek 2773b6a1d093SThara Gopinath list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 27749e9704eaSUlf Hansson d = debugfs_create_dir(genpd->name, genpd_debugfs_dir); 2775b6a1d093SThara Gopinath if (!d) 2776b6a1d093SThara Gopinath return -ENOMEM; 2777b6a1d093SThara Gopinath 2778b6a1d093SThara Gopinath debugfs_create_file("current_state", 0444, 2779b6a1d093SThara Gopinath d, genpd, &genpd_status_fops); 2780b6a1d093SThara Gopinath debugfs_create_file("sub_domains", 0444, 2781b6a1d093SThara Gopinath d, genpd, &genpd_sub_domains_fops); 2782b6a1d093SThara Gopinath debugfs_create_file("idle_states", 0444, 2783b6a1d093SThara Gopinath d, genpd, &genpd_idle_states_fops); 2784b6a1d093SThara Gopinath debugfs_create_file("active_time", 0444, 2785b6a1d093SThara Gopinath d, genpd, &genpd_active_time_fops); 2786b6a1d093SThara Gopinath debugfs_create_file("total_idle_time", 0444, 2787b6a1d093SThara Gopinath d, genpd, &genpd_total_idle_time_fops); 2788b6a1d093SThara Gopinath debugfs_create_file("devices", 0444, 2789b6a1d093SThara Gopinath d, genpd, &genpd_devices_fops); 2790e8912812SRajendra Nayak if (genpd->set_performance_state) 2791e8912812SRajendra Nayak debugfs_create_file("perf_state", 0444, 2792e8912812SRajendra Nayak d, genpd, &genpd_perf_state_fops); 2793b6a1d093SThara Gopinath } 2794b6a1d093SThara Gopinath 27952bd5306aSMaciej Matraszek return 0; 27962bd5306aSMaciej Matraszek } 27979e9704eaSUlf Hansson late_initcall(genpd_debug_init); 27982bd5306aSMaciej Matraszek 27999e9704eaSUlf Hansson static void __exit genpd_debug_exit(void) 28002bd5306aSMaciej Matraszek { 28019e9704eaSUlf Hansson debugfs_remove_recursive(genpd_debugfs_dir); 28022bd5306aSMaciej Matraszek } 28039e9704eaSUlf Hansson __exitcall(genpd_debug_exit); 28048b0510b5SJon Hunter #endif /* CONFIG_DEBUG_FS */ 2805