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 21743c095f32SUlf Hansson static void genpd_release_dev(struct device *dev) 21753c095f32SUlf Hansson { 21763c095f32SUlf Hansson kfree(dev); 21773c095f32SUlf Hansson } 21783c095f32SUlf Hansson 21793c095f32SUlf Hansson static struct bus_type genpd_bus_type = { 21803c095f32SUlf Hansson .name = "genpd", 21813c095f32SUlf Hansson }; 21823c095f32SUlf Hansson 218317926551SJon Hunter /** 2184aa42240aSTomasz Figa * genpd_dev_pm_detach - Detach a device from its PM domain. 21858bb6944eSJon Hunter * @dev: Device to detach. 2186aa42240aSTomasz Figa * @power_off: Currently not used 2187aa42240aSTomasz Figa * 2188aa42240aSTomasz Figa * Try to locate a corresponding generic PM domain, which the device was 2189aa42240aSTomasz Figa * attached to previously. If such is found, the device is detached from it. 2190aa42240aSTomasz Figa */ 2191aa42240aSTomasz Figa static void genpd_dev_pm_detach(struct device *dev, bool power_off) 2192aa42240aSTomasz Figa { 2193446d999cSRussell King struct generic_pm_domain *pd; 219493af5e93SGeert Uytterhoeven unsigned int i; 2195aa42240aSTomasz Figa int ret = 0; 2196aa42240aSTomasz Figa 219785168d56SUlf Hansson pd = dev_to_genpd(dev); 219885168d56SUlf Hansson if (IS_ERR(pd)) 2199aa42240aSTomasz Figa return; 2200aa42240aSTomasz Figa 2201aa42240aSTomasz Figa dev_dbg(dev, "removing from PM domain %s\n", pd->name); 2202aa42240aSTomasz Figa 220393af5e93SGeert Uytterhoeven for (i = 1; i < GENPD_RETRY_MAX_MS; i <<= 1) { 220485168d56SUlf Hansson ret = genpd_remove_device(pd, dev); 2205aa42240aSTomasz Figa if (ret != -EAGAIN) 2206aa42240aSTomasz Figa break; 220793af5e93SGeert Uytterhoeven 220893af5e93SGeert Uytterhoeven mdelay(i); 2209aa42240aSTomasz Figa cond_resched(); 2210aa42240aSTomasz Figa } 2211aa42240aSTomasz Figa 2212aa42240aSTomasz Figa if (ret < 0) { 2213aa42240aSTomasz Figa dev_err(dev, "failed to remove from PM domain %s: %d", 2214aa42240aSTomasz Figa pd->name, ret); 2215aa42240aSTomasz Figa return; 2216aa42240aSTomasz Figa } 2217aa42240aSTomasz Figa 2218aa42240aSTomasz Figa /* Check if PM domain can be powered off after removing this device. */ 2219aa42240aSTomasz Figa genpd_queue_power_off_work(pd); 22203c095f32SUlf Hansson 22213c095f32SUlf Hansson /* Unregister the device if it was created by genpd. */ 22223c095f32SUlf Hansson if (dev->bus == &genpd_bus_type) 22233c095f32SUlf Hansson device_unregister(dev); 2224aa42240aSTomasz Figa } 2225aa42240aSTomasz Figa 2226632f7ce3SRussell King static void genpd_dev_pm_sync(struct device *dev) 2227632f7ce3SRussell King { 2228632f7ce3SRussell King struct generic_pm_domain *pd; 2229632f7ce3SRussell King 2230632f7ce3SRussell King pd = dev_to_genpd(dev); 2231632f7ce3SRussell King if (IS_ERR(pd)) 2232632f7ce3SRussell King return; 2233632f7ce3SRussell King 2234632f7ce3SRussell King genpd_queue_power_off_work(pd); 2235632f7ce3SRussell King } 2236632f7ce3SRussell King 22378cb1cbd6SUlf Hansson static int __genpd_dev_pm_attach(struct device *dev, struct device_node *np, 22388cb1cbd6SUlf Hansson unsigned int index) 2239aa42240aSTomasz Figa { 2240aa42240aSTomasz Figa struct of_phandle_args pd_args; 2241aa42240aSTomasz Figa struct generic_pm_domain *pd; 2242aa42240aSTomasz Figa int ret; 2243aa42240aSTomasz Figa 22448cb1cbd6SUlf Hansson ret = of_parse_phandle_with_args(np, "power-domains", 22458cb1cbd6SUlf Hansson "#power-domain-cells", index, &pd_args); 2246001d50c9SGeert Uytterhoeven if (ret < 0) 2247bcd931f2SUlf Hansson return ret; 2248aa42240aSTomasz Figa 224919efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2250f58d4e5aSJon Hunter pd = genpd_get_from_provider(&pd_args); 2251265e2cf6SEric Anholt of_node_put(pd_args.np); 2252aa42240aSTomasz Figa if (IS_ERR(pd)) { 225319efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2254aa42240aSTomasz Figa dev_dbg(dev, "%s() failed to find PM domain: %ld\n", 2255aa42240aSTomasz Figa __func__, PTR_ERR(pd)); 2256e01afc32SRob Herring return driver_deferred_probe_check_state(dev); 2257aa42240aSTomasz Figa } 2258aa42240aSTomasz Figa 2259aa42240aSTomasz Figa dev_dbg(dev, "adding to PM domain %s\n", pd->name); 2260aa42240aSTomasz Figa 226119efa5ffSJon Hunter ret = genpd_add_device(pd, dev, NULL); 226219efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2263aa42240aSTomasz Figa 2264aa42240aSTomasz Figa if (ret < 0) { 226534994692SGeert Uytterhoeven if (ret != -EPROBE_DEFER) 2266aa42240aSTomasz Figa dev_err(dev, "failed to add to PM domain %s: %d", 2267aa42240aSTomasz Figa pd->name, ret); 2268919b7308SUlf Hansson return ret; 2269aa42240aSTomasz Figa } 2270aa42240aSTomasz Figa 2271aa42240aSTomasz Figa dev->pm_domain->detach = genpd_dev_pm_detach; 2272632f7ce3SRussell King dev->pm_domain->sync = genpd_dev_pm_sync; 2273aa42240aSTomasz Figa 227435241d12SLina Iyer genpd_lock(pd); 227586e12eacSUlf Hansson ret = genpd_power_on(pd, 0); 227635241d12SLina Iyer genpd_unlock(pd); 227772038df3SUlf Hansson 227872038df3SUlf Hansson if (ret) 227972038df3SUlf Hansson genpd_remove_device(pd, dev); 2280919b7308SUlf Hansson 2281919b7308SUlf Hansson return ret ? -EPROBE_DEFER : 1; 2282aa42240aSTomasz Figa } 22838cb1cbd6SUlf Hansson 22848cb1cbd6SUlf Hansson /** 22858cb1cbd6SUlf Hansson * genpd_dev_pm_attach - Attach a device to its PM domain using DT. 22868cb1cbd6SUlf Hansson * @dev: Device to attach. 22878cb1cbd6SUlf Hansson * 22888cb1cbd6SUlf Hansson * Parse device's OF node to find a PM domain specifier. If such is found, 22898cb1cbd6SUlf Hansson * attaches the device to retrieved pm_domain ops. 22908cb1cbd6SUlf Hansson * 22918cb1cbd6SUlf Hansson * Returns 1 on successfully attached PM domain, 0 when the device don't need a 22928cb1cbd6SUlf Hansson * PM domain or when multiple power-domains exists for it, else a negative error 22938cb1cbd6SUlf Hansson * code. Note that if a power-domain exists for the device, but it cannot be 22948cb1cbd6SUlf Hansson * found or turned on, then return -EPROBE_DEFER to ensure that the device is 22958cb1cbd6SUlf Hansson * not probed and to re-try again later. 22968cb1cbd6SUlf Hansson */ 22978cb1cbd6SUlf Hansson int genpd_dev_pm_attach(struct device *dev) 22988cb1cbd6SUlf Hansson { 22998cb1cbd6SUlf Hansson if (!dev->of_node) 23008cb1cbd6SUlf Hansson return 0; 23018cb1cbd6SUlf Hansson 23028cb1cbd6SUlf Hansson /* 23038cb1cbd6SUlf Hansson * Devices with multiple PM domains must be attached separately, as we 23048cb1cbd6SUlf Hansson * can only attach one PM domain per device. 23058cb1cbd6SUlf Hansson */ 23068cb1cbd6SUlf Hansson if (of_count_phandle_with_args(dev->of_node, "power-domains", 23078cb1cbd6SUlf Hansson "#power-domain-cells") != 1) 23088cb1cbd6SUlf Hansson return 0; 23098cb1cbd6SUlf Hansson 23108cb1cbd6SUlf Hansson return __genpd_dev_pm_attach(dev, dev->of_node, 0); 23118cb1cbd6SUlf Hansson } 2312aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(genpd_dev_pm_attach); 231330f60428SLina Iyer 23143c095f32SUlf Hansson /** 23153c095f32SUlf Hansson * genpd_dev_pm_attach_by_id - Associate a device with one of its PM domains. 23163c095f32SUlf Hansson * @dev: The device used to lookup the PM domain. 23173c095f32SUlf Hansson * @index: The index of the PM domain. 23183c095f32SUlf Hansson * 23193c095f32SUlf Hansson * Parse device's OF node to find a PM domain specifier at the provided @index. 23203c095f32SUlf Hansson * If such is found, creates a virtual device and attaches it to the retrieved 23213c095f32SUlf Hansson * pm_domain ops. To deal with detaching of the virtual device, the ->detach() 23223c095f32SUlf Hansson * callback in the struct dev_pm_domain are assigned to genpd_dev_pm_detach(). 23233c095f32SUlf Hansson * 23243c095f32SUlf Hansson * Returns the created virtual device if successfully attached PM domain, NULL 23253c095f32SUlf Hansson * when the device don't need a PM domain, else an ERR_PTR() in case of 23263c095f32SUlf Hansson * failures. If a power-domain exists for the device, but cannot be found or 23273c095f32SUlf Hansson * turned on, then ERR_PTR(-EPROBE_DEFER) is returned to ensure that the device 23283c095f32SUlf Hansson * is not probed and to re-try again later. 23293c095f32SUlf Hansson */ 23303c095f32SUlf Hansson struct device *genpd_dev_pm_attach_by_id(struct device *dev, 23313c095f32SUlf Hansson unsigned int index) 23323c095f32SUlf Hansson { 23333c095f32SUlf Hansson struct device *genpd_dev; 23343c095f32SUlf Hansson int num_domains; 23353c095f32SUlf Hansson int ret; 23363c095f32SUlf Hansson 23373c095f32SUlf Hansson if (!dev->of_node) 23383c095f32SUlf Hansson return NULL; 23393c095f32SUlf Hansson 23403c095f32SUlf Hansson /* Deal only with devices using multiple PM domains. */ 23413c095f32SUlf Hansson num_domains = of_count_phandle_with_args(dev->of_node, "power-domains", 23423c095f32SUlf Hansson "#power-domain-cells"); 23433c095f32SUlf Hansson if (num_domains < 2 || index >= num_domains) 23443c095f32SUlf Hansson return NULL; 23453c095f32SUlf Hansson 23463c095f32SUlf Hansson /* Allocate and register device on the genpd bus. */ 23473c095f32SUlf Hansson genpd_dev = kzalloc(sizeof(*genpd_dev), GFP_KERNEL); 23483c095f32SUlf Hansson if (!genpd_dev) 23493c095f32SUlf Hansson return ERR_PTR(-ENOMEM); 23503c095f32SUlf Hansson 23513c095f32SUlf Hansson dev_set_name(genpd_dev, "genpd:%u:%s", index, dev_name(dev)); 23523c095f32SUlf Hansson genpd_dev->bus = &genpd_bus_type; 23533c095f32SUlf Hansson genpd_dev->release = genpd_release_dev; 23543c095f32SUlf Hansson 23553c095f32SUlf Hansson ret = device_register(genpd_dev); 23563c095f32SUlf Hansson if (ret) { 23573c095f32SUlf Hansson kfree(genpd_dev); 23583c095f32SUlf Hansson return ERR_PTR(ret); 23593c095f32SUlf Hansson } 23603c095f32SUlf Hansson 23613c095f32SUlf Hansson /* Try to attach the device to the PM domain at the specified index. */ 23623c095f32SUlf Hansson ret = __genpd_dev_pm_attach(genpd_dev, dev->of_node, index); 23633c095f32SUlf Hansson if (ret < 1) { 23643c095f32SUlf Hansson device_unregister(genpd_dev); 23653c095f32SUlf Hansson return ret ? ERR_PTR(ret) : NULL; 23663c095f32SUlf Hansson } 23673c095f32SUlf Hansson 23683c095f32SUlf Hansson pm_runtime_set_active(genpd_dev); 23693c095f32SUlf Hansson pm_runtime_enable(genpd_dev); 23703c095f32SUlf Hansson 23713c095f32SUlf Hansson return genpd_dev; 23723c095f32SUlf Hansson } 23733c095f32SUlf Hansson EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id); 23743c095f32SUlf Hansson 237530f60428SLina Iyer static const struct of_device_id idle_state_match[] = { 2376598da548SLina Iyer { .compatible = "domain-idle-state", }, 237730f60428SLina Iyer { } 237830f60428SLina Iyer }; 237930f60428SLina Iyer 238030f60428SLina Iyer static int genpd_parse_state(struct genpd_power_state *genpd_state, 238130f60428SLina Iyer struct device_node *state_node) 238230f60428SLina Iyer { 238330f60428SLina Iyer int err; 238430f60428SLina Iyer u32 residency; 238530f60428SLina Iyer u32 entry_latency, exit_latency; 238630f60428SLina Iyer 238730f60428SLina Iyer err = of_property_read_u32(state_node, "entry-latency-us", 238830f60428SLina Iyer &entry_latency); 238930f60428SLina Iyer if (err) { 2390ea11e94bSRob Herring pr_debug(" * %pOF missing entry-latency-us property\n", 2391ea11e94bSRob Herring state_node); 239230f60428SLina Iyer return -EINVAL; 239330f60428SLina Iyer } 239430f60428SLina Iyer 239530f60428SLina Iyer err = of_property_read_u32(state_node, "exit-latency-us", 239630f60428SLina Iyer &exit_latency); 239730f60428SLina Iyer if (err) { 2398ea11e94bSRob Herring pr_debug(" * %pOF missing exit-latency-us property\n", 2399ea11e94bSRob Herring state_node); 240030f60428SLina Iyer return -EINVAL; 240130f60428SLina Iyer } 240230f60428SLina Iyer 240330f60428SLina Iyer err = of_property_read_u32(state_node, "min-residency-us", &residency); 240430f60428SLina Iyer if (!err) 240530f60428SLina Iyer genpd_state->residency_ns = 1000 * residency; 240630f60428SLina Iyer 240730f60428SLina Iyer genpd_state->power_on_latency_ns = 1000 * exit_latency; 240830f60428SLina Iyer genpd_state->power_off_latency_ns = 1000 * entry_latency; 24090c9b694aSLina Iyer genpd_state->fwnode = &state_node->fwnode; 241030f60428SLina Iyer 241130f60428SLina Iyer return 0; 241230f60428SLina Iyer } 241330f60428SLina Iyer 2414a3381e3aSUlf Hansson static int genpd_iterate_idle_states(struct device_node *dn, 2415a3381e3aSUlf Hansson struct genpd_power_state *states) 2416a3381e3aSUlf Hansson { 2417a3381e3aSUlf Hansson int ret; 2418a3381e3aSUlf Hansson struct of_phandle_iterator it; 2419a3381e3aSUlf Hansson struct device_node *np; 2420a3381e3aSUlf Hansson int i = 0; 2421a3381e3aSUlf Hansson 2422a3381e3aSUlf Hansson ret = of_count_phandle_with_args(dn, "domain-idle-states", NULL); 2423a3381e3aSUlf Hansson if (ret <= 0) 2424a3381e3aSUlf Hansson return ret; 2425a3381e3aSUlf Hansson 2426a3381e3aSUlf Hansson /* Loop over the phandles until all the requested entry is found */ 2427a3381e3aSUlf Hansson of_for_each_phandle(&it, ret, dn, "domain-idle-states", NULL, 0) { 2428a3381e3aSUlf Hansson np = it.node; 2429a3381e3aSUlf Hansson if (!of_match_node(idle_state_match, np)) 2430a3381e3aSUlf Hansson continue; 2431a3381e3aSUlf Hansson if (states) { 2432a3381e3aSUlf Hansson ret = genpd_parse_state(&states[i], np); 2433a3381e3aSUlf Hansson if (ret) { 2434a3381e3aSUlf Hansson pr_err("Parsing idle state node %pOF failed with err %d\n", 2435a3381e3aSUlf Hansson np, ret); 2436a3381e3aSUlf Hansson of_node_put(np); 2437a3381e3aSUlf Hansson return ret; 2438a3381e3aSUlf Hansson } 2439a3381e3aSUlf Hansson } 2440a3381e3aSUlf Hansson i++; 2441a3381e3aSUlf Hansson } 2442a3381e3aSUlf Hansson 2443a3381e3aSUlf Hansson return i; 2444a3381e3aSUlf Hansson } 2445a3381e3aSUlf Hansson 244630f60428SLina Iyer /** 244730f60428SLina Iyer * of_genpd_parse_idle_states: Return array of idle states for the genpd. 244830f60428SLina Iyer * 244930f60428SLina Iyer * @dn: The genpd device node 245030f60428SLina Iyer * @states: The pointer to which the state array will be saved. 245130f60428SLina Iyer * @n: The count of elements in the array returned from this function. 245230f60428SLina Iyer * 245330f60428SLina Iyer * Returns the device states parsed from the OF node. The memory for the states 245430f60428SLina Iyer * is allocated by this function and is the responsibility of the caller to 2455a3381e3aSUlf Hansson * free the memory after use. If no domain idle states is found it returns 2456a3381e3aSUlf Hansson * -EINVAL and in case of errors, a negative error code. 245730f60428SLina Iyer */ 245830f60428SLina Iyer int of_genpd_parse_idle_states(struct device_node *dn, 245930f60428SLina Iyer struct genpd_power_state **states, int *n) 246030f60428SLina Iyer { 246130f60428SLina Iyer struct genpd_power_state *st; 2462a3381e3aSUlf Hansson int ret; 246330f60428SLina Iyer 2464a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, NULL); 2465a3381e3aSUlf Hansson if (ret <= 0) 2466a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 246730f60428SLina Iyer 2468a3381e3aSUlf Hansson st = kcalloc(ret, sizeof(*st), GFP_KERNEL); 246930f60428SLina Iyer if (!st) 247030f60428SLina Iyer return -ENOMEM; 247130f60428SLina Iyer 2472a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, st); 2473a3381e3aSUlf Hansson if (ret <= 0) { 247430f60428SLina Iyer kfree(st); 2475a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 247630f60428SLina Iyer } 247730f60428SLina Iyer 247830f60428SLina Iyer *states = st; 2479a3381e3aSUlf Hansson *n = ret; 248030f60428SLina Iyer 248130f60428SLina Iyer return 0; 248230f60428SLina Iyer } 248330f60428SLina Iyer EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states); 248430f60428SLina Iyer 24856e41766aSViresh Kumar /** 24866e41766aSViresh Kumar * of_genpd_opp_to_performance_state- Gets performance state of device's 24876e41766aSViresh Kumar * power domain corresponding to a DT node's "required-opps" property. 24886e41766aSViresh Kumar * 24896e41766aSViresh Kumar * @dev: Device for which the performance-state needs to be found. 24906e41766aSViresh Kumar * @opp_node: DT node where the "required-opps" property is present. This can be 24916e41766aSViresh Kumar * the device node itself (if it doesn't have an OPP table) or a node 24926e41766aSViresh Kumar * within the OPP table of a device (if device has an OPP table). 24936e41766aSViresh Kumar * @state: Pointer to return performance state. 24946e41766aSViresh Kumar * 24956e41766aSViresh Kumar * Returns performance state corresponding to the "required-opps" property of 24966e41766aSViresh Kumar * a DT node. This calls platform specific genpd->opp_to_performance_state() 24976e41766aSViresh Kumar * callback to translate power domain OPP to performance state. 24986e41766aSViresh Kumar * 24996e41766aSViresh Kumar * Returns performance state on success and 0 on failure. 25006e41766aSViresh Kumar */ 25016e41766aSViresh Kumar unsigned int of_genpd_opp_to_performance_state(struct device *dev, 25026e41766aSViresh Kumar struct device_node *opp_node) 25036e41766aSViresh Kumar { 25046e41766aSViresh Kumar struct generic_pm_domain *genpd; 25056e41766aSViresh Kumar struct dev_pm_opp *opp; 25066e41766aSViresh Kumar int state = 0; 25076e41766aSViresh Kumar 25086e41766aSViresh Kumar genpd = dev_to_genpd(dev); 25096e41766aSViresh Kumar if (IS_ERR(genpd)) 25106e41766aSViresh Kumar return 0; 25116e41766aSViresh Kumar 25126e41766aSViresh Kumar if (unlikely(!genpd->set_performance_state)) 25136e41766aSViresh Kumar return 0; 25146e41766aSViresh Kumar 25156e41766aSViresh Kumar genpd_lock(genpd); 25166e41766aSViresh Kumar 25176e41766aSViresh Kumar opp = of_dev_pm_opp_find_required_opp(&genpd->dev, opp_node); 25186e41766aSViresh Kumar if (IS_ERR(opp)) { 25199ad14c00SViresh Kumar dev_err(dev, "Failed to find required OPP: %ld\n", 25209ad14c00SViresh Kumar PTR_ERR(opp)); 25216e41766aSViresh Kumar goto unlock; 25226e41766aSViresh Kumar } 25236e41766aSViresh Kumar 25246e41766aSViresh Kumar state = genpd->opp_to_performance_state(genpd, opp); 25256e41766aSViresh Kumar dev_pm_opp_put(opp); 25266e41766aSViresh Kumar 25276e41766aSViresh Kumar unlock: 25286e41766aSViresh Kumar genpd_unlock(genpd); 25296e41766aSViresh Kumar 25306e41766aSViresh Kumar return state; 25316e41766aSViresh Kumar } 25326e41766aSViresh Kumar EXPORT_SYMBOL_GPL(of_genpd_opp_to_performance_state); 25336e41766aSViresh Kumar 25343c095f32SUlf Hansson static int __init genpd_bus_init(void) 25353c095f32SUlf Hansson { 25363c095f32SUlf Hansson return bus_register(&genpd_bus_type); 25373c095f32SUlf Hansson } 25383c095f32SUlf Hansson core_initcall(genpd_bus_init); 25393c095f32SUlf Hansson 2540d30d819dSRafael J. Wysocki #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */ 25412bd5306aSMaciej Matraszek 25422bd5306aSMaciej Matraszek 25432bd5306aSMaciej Matraszek /*** debugfs support ***/ 25442bd5306aSMaciej Matraszek 25458b0510b5SJon Hunter #ifdef CONFIG_DEBUG_FS 25462bd5306aSMaciej Matraszek #include <linux/pm.h> 25472bd5306aSMaciej Matraszek #include <linux/device.h> 25482bd5306aSMaciej Matraszek #include <linux/debugfs.h> 25492bd5306aSMaciej Matraszek #include <linux/seq_file.h> 25502bd5306aSMaciej Matraszek #include <linux/init.h> 25512bd5306aSMaciej Matraszek #include <linux/kobject.h> 25529e9704eaSUlf Hansson static struct dentry *genpd_debugfs_dir; 25532bd5306aSMaciej Matraszek 25542bd5306aSMaciej Matraszek /* 25552bd5306aSMaciej Matraszek * TODO: This function is a slightly modified version of rtpm_status_show 2556d30d819dSRafael J. Wysocki * from sysfs.c, so generalize it. 25572bd5306aSMaciej Matraszek */ 25582bd5306aSMaciej Matraszek static void rtpm_status_str(struct seq_file *s, struct device *dev) 25592bd5306aSMaciej Matraszek { 25602bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 25612bd5306aSMaciej Matraszek [RPM_ACTIVE] = "active", 25622bd5306aSMaciej Matraszek [RPM_RESUMING] = "resuming", 25632bd5306aSMaciej Matraszek [RPM_SUSPENDED] = "suspended", 25642bd5306aSMaciej Matraszek [RPM_SUSPENDING] = "suspending" 25652bd5306aSMaciej Matraszek }; 25662bd5306aSMaciej Matraszek const char *p = ""; 25672bd5306aSMaciej Matraszek 25682bd5306aSMaciej Matraszek if (dev->power.runtime_error) 25692bd5306aSMaciej Matraszek p = "error"; 25702bd5306aSMaciej Matraszek else if (dev->power.disable_depth) 25712bd5306aSMaciej Matraszek p = "unsupported"; 25722bd5306aSMaciej Matraszek else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup)) 25732bd5306aSMaciej Matraszek p = status_lookup[dev->power.runtime_status]; 25742bd5306aSMaciej Matraszek else 25752bd5306aSMaciej Matraszek WARN_ON(1); 25762bd5306aSMaciej Matraszek 25772bd5306aSMaciej Matraszek seq_puts(s, p); 25782bd5306aSMaciej Matraszek } 25792bd5306aSMaciej Matraszek 25809e9704eaSUlf Hansson static int genpd_summary_one(struct seq_file *s, 258166a5ca4bSKevin Hilman struct generic_pm_domain *genpd) 25822bd5306aSMaciej Matraszek { 25832bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 25842bd5306aSMaciej Matraszek [GPD_STATE_ACTIVE] = "on", 25852bd5306aSMaciej Matraszek [GPD_STATE_POWER_OFF] = "off" 25862bd5306aSMaciej Matraszek }; 25872bd5306aSMaciej Matraszek struct pm_domain_data *pm_data; 25882bd5306aSMaciej Matraszek const char *kobj_path; 25892bd5306aSMaciej Matraszek struct gpd_link *link; 25906954d432SGeert Uytterhoeven char state[16]; 25912bd5306aSMaciej Matraszek int ret; 25922bd5306aSMaciej Matraszek 259335241d12SLina Iyer ret = genpd_lock_interruptible(genpd); 25942bd5306aSMaciej Matraszek if (ret) 25952bd5306aSMaciej Matraszek return -ERESTARTSYS; 25962bd5306aSMaciej Matraszek 259766a5ca4bSKevin Hilman if (WARN_ON(genpd->status >= ARRAY_SIZE(status_lookup))) 25982bd5306aSMaciej Matraszek goto exit; 259941e2c8e0SUlf Hansson if (!genpd_status_on(genpd)) 26000ba554e4SGeert Uytterhoeven snprintf(state, sizeof(state), "%s-%u", 26016954d432SGeert Uytterhoeven status_lookup[genpd->status], genpd->state_idx); 2602fc5cbf0cSAxel Haslam else 26036954d432SGeert Uytterhoeven snprintf(state, sizeof(state), "%s", 26046954d432SGeert Uytterhoeven status_lookup[genpd->status]); 26056954d432SGeert Uytterhoeven seq_printf(s, "%-30s %-15s ", genpd->name, state); 26062bd5306aSMaciej Matraszek 26072bd5306aSMaciej Matraszek /* 26082bd5306aSMaciej Matraszek * Modifications on the list require holding locks on both 26092bd5306aSMaciej Matraszek * master and slave, so we are safe. 261066a5ca4bSKevin Hilman * Also genpd->name is immutable. 26112bd5306aSMaciej Matraszek */ 261266a5ca4bSKevin Hilman list_for_each_entry(link, &genpd->master_links, master_node) { 26132bd5306aSMaciej Matraszek seq_printf(s, "%s", link->slave->name); 261466a5ca4bSKevin Hilman if (!list_is_last(&link->master_node, &genpd->master_links)) 26152bd5306aSMaciej Matraszek seq_puts(s, ", "); 26162bd5306aSMaciej Matraszek } 26172bd5306aSMaciej Matraszek 261866a5ca4bSKevin Hilman list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2619d716f479SLina Iyer kobj_path = kobject_get_path(&pm_data->dev->kobj, 2620d716f479SLina Iyer genpd_is_irq_safe(genpd) ? 2621d716f479SLina Iyer GFP_ATOMIC : GFP_KERNEL); 26222bd5306aSMaciej Matraszek if (kobj_path == NULL) 26232bd5306aSMaciej Matraszek continue; 26242bd5306aSMaciej Matraszek 26252bd5306aSMaciej Matraszek seq_printf(s, "\n %-50s ", kobj_path); 26262bd5306aSMaciej Matraszek rtpm_status_str(s, pm_data->dev); 26272bd5306aSMaciej Matraszek kfree(kobj_path); 26282bd5306aSMaciej Matraszek } 26292bd5306aSMaciej Matraszek 26302bd5306aSMaciej Matraszek seq_puts(s, "\n"); 26312bd5306aSMaciej Matraszek exit: 263235241d12SLina Iyer genpd_unlock(genpd); 26332bd5306aSMaciej Matraszek 26342bd5306aSMaciej Matraszek return 0; 26352bd5306aSMaciej Matraszek } 26362bd5306aSMaciej Matraszek 2637b6a1d093SThara Gopinath static int genpd_summary_show(struct seq_file *s, void *data) 26382bd5306aSMaciej Matraszek { 263966a5ca4bSKevin Hilman struct generic_pm_domain *genpd; 26402bd5306aSMaciej Matraszek int ret = 0; 26412bd5306aSMaciej Matraszek 26422bd5306aSMaciej Matraszek seq_puts(s, "domain status slaves\n"); 26432bd5306aSMaciej Matraszek seq_puts(s, " /device runtime status\n"); 26442bd5306aSMaciej Matraszek seq_puts(s, "----------------------------------------------------------------------\n"); 26452bd5306aSMaciej Matraszek 26462bd5306aSMaciej Matraszek ret = mutex_lock_interruptible(&gpd_list_lock); 26472bd5306aSMaciej Matraszek if (ret) 26482bd5306aSMaciej Matraszek return -ERESTARTSYS; 26492bd5306aSMaciej Matraszek 265066a5ca4bSKevin Hilman list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 26519e9704eaSUlf Hansson ret = genpd_summary_one(s, genpd); 26522bd5306aSMaciej Matraszek if (ret) 26532bd5306aSMaciej Matraszek break; 26542bd5306aSMaciej Matraszek } 26552bd5306aSMaciej Matraszek mutex_unlock(&gpd_list_lock); 26562bd5306aSMaciej Matraszek 26572bd5306aSMaciej Matraszek return ret; 26582bd5306aSMaciej Matraszek } 26592bd5306aSMaciej Matraszek 2660b6a1d093SThara Gopinath static int genpd_status_show(struct seq_file *s, void *data) 26612bd5306aSMaciej Matraszek { 2662b6a1d093SThara Gopinath static const char * const status_lookup[] = { 2663b6a1d093SThara Gopinath [GPD_STATE_ACTIVE] = "on", 2664b6a1d093SThara Gopinath [GPD_STATE_POWER_OFF] = "off" 2665b6a1d093SThara Gopinath }; 2666b6a1d093SThara Gopinath 2667b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2668b6a1d093SThara Gopinath int ret = 0; 2669b6a1d093SThara Gopinath 2670b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2671b6a1d093SThara Gopinath if (ret) 2672b6a1d093SThara Gopinath return -ERESTARTSYS; 2673b6a1d093SThara Gopinath 2674b6a1d093SThara Gopinath if (WARN_ON_ONCE(genpd->status >= ARRAY_SIZE(status_lookup))) 2675b6a1d093SThara Gopinath goto exit; 2676b6a1d093SThara Gopinath 2677b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_POWER_OFF) 2678b6a1d093SThara Gopinath seq_printf(s, "%s-%u\n", status_lookup[genpd->status], 2679b6a1d093SThara Gopinath genpd->state_idx); 2680b6a1d093SThara Gopinath else 2681b6a1d093SThara Gopinath seq_printf(s, "%s\n", status_lookup[genpd->status]); 2682b6a1d093SThara Gopinath exit: 2683b6a1d093SThara Gopinath genpd_unlock(genpd); 2684b6a1d093SThara Gopinath return ret; 26852bd5306aSMaciej Matraszek } 26862bd5306aSMaciej Matraszek 2687b6a1d093SThara Gopinath static int genpd_sub_domains_show(struct seq_file *s, void *data) 2688b6a1d093SThara Gopinath { 2689b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2690b6a1d093SThara Gopinath struct gpd_link *link; 2691b6a1d093SThara Gopinath int ret = 0; 2692b6a1d093SThara Gopinath 2693b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2694b6a1d093SThara Gopinath if (ret) 2695b6a1d093SThara Gopinath return -ERESTARTSYS; 2696b6a1d093SThara Gopinath 2697b6a1d093SThara Gopinath list_for_each_entry(link, &genpd->master_links, master_node) 2698b6a1d093SThara Gopinath seq_printf(s, "%s\n", link->slave->name); 2699b6a1d093SThara Gopinath 2700b6a1d093SThara Gopinath genpd_unlock(genpd); 2701b6a1d093SThara Gopinath return ret; 2702b6a1d093SThara Gopinath } 2703b6a1d093SThara Gopinath 2704b6a1d093SThara Gopinath static int genpd_idle_states_show(struct seq_file *s, void *data) 2705b6a1d093SThara Gopinath { 2706b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2707b6a1d093SThara Gopinath unsigned int i; 2708b6a1d093SThara Gopinath int ret = 0; 2709b6a1d093SThara Gopinath 2710b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2711b6a1d093SThara Gopinath if (ret) 2712b6a1d093SThara Gopinath return -ERESTARTSYS; 2713b6a1d093SThara Gopinath 2714b6a1d093SThara Gopinath seq_puts(s, "State Time Spent(ms)\n"); 2715b6a1d093SThara Gopinath 2716b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2717b6a1d093SThara Gopinath ktime_t delta = 0; 2718b6a1d093SThara Gopinath s64 msecs; 2719b6a1d093SThara Gopinath 2720b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2721b6a1d093SThara Gopinath (genpd->state_idx == i)) 2722b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2723b6a1d093SThara Gopinath 2724b6a1d093SThara Gopinath msecs = ktime_to_ms( 2725b6a1d093SThara Gopinath ktime_add(genpd->states[i].idle_time, delta)); 2726b6a1d093SThara Gopinath seq_printf(s, "S%-13i %lld\n", i, msecs); 2727b6a1d093SThara Gopinath } 2728b6a1d093SThara Gopinath 2729b6a1d093SThara Gopinath genpd_unlock(genpd); 2730b6a1d093SThara Gopinath return ret; 2731b6a1d093SThara Gopinath } 2732b6a1d093SThara Gopinath 2733b6a1d093SThara Gopinath static int genpd_active_time_show(struct seq_file *s, void *data) 2734b6a1d093SThara Gopinath { 2735b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2736b6a1d093SThara Gopinath ktime_t delta = 0; 2737b6a1d093SThara Gopinath int ret = 0; 2738b6a1d093SThara Gopinath 2739b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2740b6a1d093SThara Gopinath if (ret) 2741b6a1d093SThara Gopinath return -ERESTARTSYS; 2742b6a1d093SThara Gopinath 2743b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) 2744b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2745b6a1d093SThara Gopinath 2746b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms( 2747b6a1d093SThara Gopinath ktime_add(genpd->on_time, delta))); 2748b6a1d093SThara Gopinath 2749b6a1d093SThara Gopinath genpd_unlock(genpd); 2750b6a1d093SThara Gopinath return ret; 2751b6a1d093SThara Gopinath } 2752b6a1d093SThara Gopinath 2753b6a1d093SThara Gopinath static int genpd_total_idle_time_show(struct seq_file *s, void *data) 2754b6a1d093SThara Gopinath { 2755b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2756b6a1d093SThara Gopinath ktime_t delta = 0, total = 0; 2757b6a1d093SThara Gopinath unsigned int i; 2758b6a1d093SThara Gopinath int ret = 0; 2759b6a1d093SThara Gopinath 2760b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2761b6a1d093SThara Gopinath if (ret) 2762b6a1d093SThara Gopinath return -ERESTARTSYS; 2763b6a1d093SThara Gopinath 2764b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2765b6a1d093SThara Gopinath 2766b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2767b6a1d093SThara Gopinath (genpd->state_idx == i)) 2768b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2769b6a1d093SThara Gopinath 2770b6a1d093SThara Gopinath total = ktime_add(total, genpd->states[i].idle_time); 2771b6a1d093SThara Gopinath } 2772b6a1d093SThara Gopinath total = ktime_add(total, delta); 2773b6a1d093SThara Gopinath 2774b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms(total)); 2775b6a1d093SThara Gopinath 2776b6a1d093SThara Gopinath genpd_unlock(genpd); 2777b6a1d093SThara Gopinath return ret; 2778b6a1d093SThara Gopinath } 2779b6a1d093SThara Gopinath 2780b6a1d093SThara Gopinath 2781b6a1d093SThara Gopinath static int genpd_devices_show(struct seq_file *s, void *data) 2782b6a1d093SThara Gopinath { 2783b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2784b6a1d093SThara Gopinath struct pm_domain_data *pm_data; 2785b6a1d093SThara Gopinath const char *kobj_path; 2786b6a1d093SThara Gopinath int ret = 0; 2787b6a1d093SThara Gopinath 2788b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2789b6a1d093SThara Gopinath if (ret) 2790b6a1d093SThara Gopinath return -ERESTARTSYS; 2791b6a1d093SThara Gopinath 2792b6a1d093SThara Gopinath list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2793b6a1d093SThara Gopinath kobj_path = kobject_get_path(&pm_data->dev->kobj, 2794b6a1d093SThara Gopinath genpd_is_irq_safe(genpd) ? 2795b6a1d093SThara Gopinath GFP_ATOMIC : GFP_KERNEL); 2796b6a1d093SThara Gopinath if (kobj_path == NULL) 2797b6a1d093SThara Gopinath continue; 2798b6a1d093SThara Gopinath 2799b6a1d093SThara Gopinath seq_printf(s, "%s\n", kobj_path); 2800b6a1d093SThara Gopinath kfree(kobj_path); 2801b6a1d093SThara Gopinath } 2802b6a1d093SThara Gopinath 2803b6a1d093SThara Gopinath genpd_unlock(genpd); 2804b6a1d093SThara Gopinath return ret; 2805b6a1d093SThara Gopinath } 2806b6a1d093SThara Gopinath 2807e8912812SRajendra Nayak static int genpd_perf_state_show(struct seq_file *s, void *data) 2808e8912812SRajendra Nayak { 2809e8912812SRajendra Nayak struct generic_pm_domain *genpd = s->private; 2810e8912812SRajendra Nayak 2811e8912812SRajendra Nayak if (genpd_lock_interruptible(genpd)) 2812e8912812SRajendra Nayak return -ERESTARTSYS; 2813e8912812SRajendra Nayak 2814e8912812SRajendra Nayak seq_printf(s, "%u\n", genpd->performance_state); 2815e8912812SRajendra Nayak 2816e8912812SRajendra Nayak genpd_unlock(genpd); 2817e8912812SRajendra Nayak return 0; 2818e8912812SRajendra Nayak } 2819e8912812SRajendra Nayak 2820b6a1d093SThara Gopinath #define define_genpd_open_function(name) \ 2821b6a1d093SThara Gopinath static int genpd_##name##_open(struct inode *inode, struct file *file) \ 2822b6a1d093SThara Gopinath { \ 2823b6a1d093SThara Gopinath return single_open(file, genpd_##name##_show, inode->i_private); \ 2824b6a1d093SThara Gopinath } 2825b6a1d093SThara Gopinath 2826b6a1d093SThara Gopinath define_genpd_open_function(summary); 2827b6a1d093SThara Gopinath define_genpd_open_function(status); 2828b6a1d093SThara Gopinath define_genpd_open_function(sub_domains); 2829b6a1d093SThara Gopinath define_genpd_open_function(idle_states); 2830b6a1d093SThara Gopinath define_genpd_open_function(active_time); 2831b6a1d093SThara Gopinath define_genpd_open_function(total_idle_time); 2832b6a1d093SThara Gopinath define_genpd_open_function(devices); 2833e8912812SRajendra Nayak define_genpd_open_function(perf_state); 2834b6a1d093SThara Gopinath 2835b6a1d093SThara Gopinath #define define_genpd_debugfs_fops(name) \ 2836b6a1d093SThara Gopinath static const struct file_operations genpd_##name##_fops = { \ 2837b6a1d093SThara Gopinath .open = genpd_##name##_open, \ 2838b6a1d093SThara Gopinath .read = seq_read, \ 2839b6a1d093SThara Gopinath .llseek = seq_lseek, \ 2840b6a1d093SThara Gopinath .release = single_release, \ 2841b6a1d093SThara Gopinath } 2842b6a1d093SThara Gopinath 2843b6a1d093SThara Gopinath define_genpd_debugfs_fops(summary); 2844b6a1d093SThara Gopinath define_genpd_debugfs_fops(status); 2845b6a1d093SThara Gopinath define_genpd_debugfs_fops(sub_domains); 2846b6a1d093SThara Gopinath define_genpd_debugfs_fops(idle_states); 2847b6a1d093SThara Gopinath define_genpd_debugfs_fops(active_time); 2848b6a1d093SThara Gopinath define_genpd_debugfs_fops(total_idle_time); 2849b6a1d093SThara Gopinath define_genpd_debugfs_fops(devices); 2850e8912812SRajendra Nayak define_genpd_debugfs_fops(perf_state); 28512bd5306aSMaciej Matraszek 28529e9704eaSUlf Hansson static int __init genpd_debug_init(void) 28532bd5306aSMaciej Matraszek { 28542bd5306aSMaciej Matraszek struct dentry *d; 2855b6a1d093SThara Gopinath struct generic_pm_domain *genpd; 28562bd5306aSMaciej Matraszek 28579e9704eaSUlf Hansson genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL); 28582bd5306aSMaciej Matraszek 28599e9704eaSUlf Hansson if (!genpd_debugfs_dir) 28602bd5306aSMaciej Matraszek return -ENOMEM; 28612bd5306aSMaciej Matraszek 28622bd5306aSMaciej Matraszek d = debugfs_create_file("pm_genpd_summary", S_IRUGO, 28639e9704eaSUlf Hansson genpd_debugfs_dir, NULL, &genpd_summary_fops); 28642bd5306aSMaciej Matraszek if (!d) 28652bd5306aSMaciej Matraszek return -ENOMEM; 28662bd5306aSMaciej Matraszek 2867b6a1d093SThara Gopinath list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 28689e9704eaSUlf Hansson d = debugfs_create_dir(genpd->name, genpd_debugfs_dir); 2869b6a1d093SThara Gopinath if (!d) 2870b6a1d093SThara Gopinath return -ENOMEM; 2871b6a1d093SThara Gopinath 2872b6a1d093SThara Gopinath debugfs_create_file("current_state", 0444, 2873b6a1d093SThara Gopinath d, genpd, &genpd_status_fops); 2874b6a1d093SThara Gopinath debugfs_create_file("sub_domains", 0444, 2875b6a1d093SThara Gopinath d, genpd, &genpd_sub_domains_fops); 2876b6a1d093SThara Gopinath debugfs_create_file("idle_states", 0444, 2877b6a1d093SThara Gopinath d, genpd, &genpd_idle_states_fops); 2878b6a1d093SThara Gopinath debugfs_create_file("active_time", 0444, 2879b6a1d093SThara Gopinath d, genpd, &genpd_active_time_fops); 2880b6a1d093SThara Gopinath debugfs_create_file("total_idle_time", 0444, 2881b6a1d093SThara Gopinath d, genpd, &genpd_total_idle_time_fops); 2882b6a1d093SThara Gopinath debugfs_create_file("devices", 0444, 2883b6a1d093SThara Gopinath d, genpd, &genpd_devices_fops); 2884e8912812SRajendra Nayak if (genpd->set_performance_state) 2885e8912812SRajendra Nayak debugfs_create_file("perf_state", 0444, 2886e8912812SRajendra Nayak d, genpd, &genpd_perf_state_fops); 2887b6a1d093SThara Gopinath } 2888b6a1d093SThara Gopinath 28892bd5306aSMaciej Matraszek return 0; 28902bd5306aSMaciej Matraszek } 28919e9704eaSUlf Hansson late_initcall(genpd_debug_init); 28922bd5306aSMaciej Matraszek 28939e9704eaSUlf Hansson static void __exit genpd_debug_exit(void) 28942bd5306aSMaciej Matraszek { 28959e9704eaSUlf Hansson debugfs_remove_recursive(genpd_debugfs_dir); 28962bd5306aSMaciej Matraszek } 28979e9704eaSUlf Hansson __exitcall(genpd_debug_exit); 28988b0510b5SJon Hunter #endif /* CONFIG_DEBUG_FS */ 2899