15de363b6SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2f721889fSRafael J. Wysocki /* 3f721889fSRafael J. Wysocki * drivers/base/power/domain.c - Common code related to device power domains. 4f721889fSRafael J. Wysocki * 5f721889fSRafael J. Wysocki * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. 6f721889fSRafael J. Wysocki */ 77a5bd127SJoe Perches #define pr_fmt(fmt) "PM: " fmt 87a5bd127SJoe Perches 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> 23eb594b73SUlf Hansson #include <linux/cpu.h> 24d5e4cbfeSRafael J. Wysocki 25aa8e54b5STomeu Vizoso #include "power.h" 26aa8e54b5STomeu Vizoso 2793af5e93SGeert Uytterhoeven #define GENPD_RETRY_MAX_MS 250 /* Approximate */ 2893af5e93SGeert Uytterhoeven 29d5e4cbfeSRafael J. Wysocki #define GENPD_DEV_CALLBACK(genpd, type, callback, dev) \ 30d5e4cbfeSRafael J. Wysocki ({ \ 31d5e4cbfeSRafael J. Wysocki type (*__routine)(struct device *__d); \ 32d5e4cbfeSRafael J. Wysocki type __ret = (type)0; \ 33d5e4cbfeSRafael J. Wysocki \ 34d5e4cbfeSRafael J. Wysocki __routine = genpd->dev_ops.callback; \ 35d5e4cbfeSRafael J. Wysocki if (__routine) { \ 36d5e4cbfeSRafael J. Wysocki __ret = __routine(dev); \ 37d5e4cbfeSRafael J. Wysocki } \ 38d5e4cbfeSRafael J. Wysocki __ret; \ 39d5e4cbfeSRafael J. Wysocki }) 40f721889fSRafael J. Wysocki 415125bbf3SRafael J. Wysocki static LIST_HEAD(gpd_list); 425125bbf3SRafael J. Wysocki static DEFINE_MUTEX(gpd_list_lock); 435125bbf3SRafael J. Wysocki 4435241d12SLina Iyer struct genpd_lock_ops { 4535241d12SLina Iyer void (*lock)(struct generic_pm_domain *genpd); 4635241d12SLina Iyer void (*lock_nested)(struct generic_pm_domain *genpd, int depth); 4735241d12SLina Iyer int (*lock_interruptible)(struct generic_pm_domain *genpd); 4835241d12SLina Iyer void (*unlock)(struct generic_pm_domain *genpd); 4935241d12SLina Iyer }; 5035241d12SLina Iyer 5135241d12SLina Iyer static void genpd_lock_mtx(struct generic_pm_domain *genpd) 5235241d12SLina Iyer { 5335241d12SLina Iyer mutex_lock(&genpd->mlock); 5435241d12SLina Iyer } 5535241d12SLina Iyer 5635241d12SLina Iyer static void genpd_lock_nested_mtx(struct generic_pm_domain *genpd, 5735241d12SLina Iyer int depth) 5835241d12SLina Iyer { 5935241d12SLina Iyer mutex_lock_nested(&genpd->mlock, depth); 6035241d12SLina Iyer } 6135241d12SLina Iyer 6235241d12SLina Iyer static int genpd_lock_interruptible_mtx(struct generic_pm_domain *genpd) 6335241d12SLina Iyer { 6435241d12SLina Iyer return mutex_lock_interruptible(&genpd->mlock); 6535241d12SLina Iyer } 6635241d12SLina Iyer 6735241d12SLina Iyer static void genpd_unlock_mtx(struct generic_pm_domain *genpd) 6835241d12SLina Iyer { 6935241d12SLina Iyer return mutex_unlock(&genpd->mlock); 7035241d12SLina Iyer } 7135241d12SLina Iyer 7235241d12SLina Iyer static const struct genpd_lock_ops genpd_mtx_ops = { 7335241d12SLina Iyer .lock = genpd_lock_mtx, 7435241d12SLina Iyer .lock_nested = genpd_lock_nested_mtx, 7535241d12SLina Iyer .lock_interruptible = genpd_lock_interruptible_mtx, 7635241d12SLina Iyer .unlock = genpd_unlock_mtx, 7735241d12SLina Iyer }; 7835241d12SLina Iyer 79d716f479SLina Iyer static void genpd_lock_spin(struct generic_pm_domain *genpd) 80d716f479SLina Iyer __acquires(&genpd->slock) 81d716f479SLina Iyer { 82d716f479SLina Iyer unsigned long flags; 83d716f479SLina Iyer 84d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 85d716f479SLina Iyer genpd->lock_flags = flags; 86d716f479SLina Iyer } 87d716f479SLina Iyer 88d716f479SLina Iyer static void genpd_lock_nested_spin(struct generic_pm_domain *genpd, 89d716f479SLina Iyer int depth) 90d716f479SLina Iyer __acquires(&genpd->slock) 91d716f479SLina Iyer { 92d716f479SLina Iyer unsigned long flags; 93d716f479SLina Iyer 94d716f479SLina Iyer spin_lock_irqsave_nested(&genpd->slock, flags, depth); 95d716f479SLina Iyer genpd->lock_flags = flags; 96d716f479SLina Iyer } 97d716f479SLina Iyer 98d716f479SLina Iyer static int genpd_lock_interruptible_spin(struct generic_pm_domain *genpd) 99d716f479SLina Iyer __acquires(&genpd->slock) 100d716f479SLina Iyer { 101d716f479SLina Iyer unsigned long flags; 102d716f479SLina Iyer 103d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 104d716f479SLina Iyer genpd->lock_flags = flags; 105d716f479SLina Iyer return 0; 106d716f479SLina Iyer } 107d716f479SLina Iyer 108d716f479SLina Iyer static void genpd_unlock_spin(struct generic_pm_domain *genpd) 109d716f479SLina Iyer __releases(&genpd->slock) 110d716f479SLina Iyer { 111d716f479SLina Iyer spin_unlock_irqrestore(&genpd->slock, genpd->lock_flags); 112d716f479SLina Iyer } 113d716f479SLina Iyer 114d716f479SLina Iyer static const struct genpd_lock_ops genpd_spin_ops = { 115d716f479SLina Iyer .lock = genpd_lock_spin, 116d716f479SLina Iyer .lock_nested = genpd_lock_nested_spin, 117d716f479SLina Iyer .lock_interruptible = genpd_lock_interruptible_spin, 118d716f479SLina Iyer .unlock = genpd_unlock_spin, 119d716f479SLina Iyer }; 120d716f479SLina Iyer 12135241d12SLina Iyer #define genpd_lock(p) p->lock_ops->lock(p) 12235241d12SLina Iyer #define genpd_lock_nested(p, d) p->lock_ops->lock_nested(p, d) 12335241d12SLina Iyer #define genpd_lock_interruptible(p) p->lock_ops->lock_interruptible(p) 12435241d12SLina Iyer #define genpd_unlock(p) p->lock_ops->unlock(p) 12535241d12SLina Iyer 12641e2c8e0SUlf Hansson #define genpd_status_on(genpd) (genpd->status == GPD_STATE_ACTIVE) 127d716f479SLina Iyer #define genpd_is_irq_safe(genpd) (genpd->flags & GENPD_FLAG_IRQ_SAFE) 128ffaa42e8SUlf Hansson #define genpd_is_always_on(genpd) (genpd->flags & GENPD_FLAG_ALWAYS_ON) 12995a20ef6SGeert Uytterhoeven #define genpd_is_active_wakeup(genpd) (genpd->flags & GENPD_FLAG_ACTIVE_WAKEUP) 130eb594b73SUlf Hansson #define genpd_is_cpu_domain(genpd) (genpd->flags & GENPD_FLAG_CPU_DOMAIN) 131ed61e18aSLeonard Crestez #define genpd_is_rpm_always_on(genpd) (genpd->flags & GENPD_FLAG_RPM_ALWAYS_ON) 132d716f479SLina Iyer 133d716f479SLina Iyer static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev, 134d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 135d716f479SLina Iyer { 136d716f479SLina Iyer bool ret; 137d716f479SLina Iyer 138d716f479SLina Iyer ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd); 139d716f479SLina Iyer 140075c37d5SUlf Hansson /* 141075c37d5SUlf Hansson * Warn once if an IRQ safe device is attached to a no sleep domain, as 142075c37d5SUlf Hansson * to indicate a suboptimal configuration for PM. For an always on 143075c37d5SUlf Hansson * domain this isn't case, thus don't warn. 144075c37d5SUlf Hansson */ 145075c37d5SUlf Hansson if (ret && !genpd_is_always_on(genpd)) 146d716f479SLina Iyer dev_warn_once(dev, "PM domain %s will not be powered off\n", 147d716f479SLina Iyer genpd->name); 148d716f479SLina Iyer 149d716f479SLina Iyer return ret; 150d716f479SLina Iyer } 151d716f479SLina Iyer 152b3ad17c0SUlf Hansson static int genpd_runtime_suspend(struct device *dev); 153b3ad17c0SUlf Hansson 154446d999cSRussell King /* 155446d999cSRussell King * Get the generic PM domain for a particular struct device. 156446d999cSRussell King * This validates the struct device pointer, the PM domain pointer, 157446d999cSRussell King * and checks that the PM domain pointer is a real generic PM domain. 158446d999cSRussell King * Any failure results in NULL being returned. 159446d999cSRussell King */ 160b3ad17c0SUlf Hansson static struct generic_pm_domain *dev_to_genpd_safe(struct device *dev) 161446d999cSRussell King { 162446d999cSRussell King if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain)) 163446d999cSRussell King return NULL; 164446d999cSRussell King 165b3ad17c0SUlf Hansson /* A genpd's always have its ->runtime_suspend() callback assigned. */ 166b3ad17c0SUlf Hansson if (dev->pm_domain->ops.runtime_suspend == genpd_runtime_suspend) 167b3ad17c0SUlf Hansson return pd_to_genpd(dev->pm_domain); 168446d999cSRussell King 169b3ad17c0SUlf Hansson return NULL; 170446d999cSRussell King } 171446d999cSRussell King 172446d999cSRussell King /* 173446d999cSRussell King * This should only be used where we are certain that the pm_domain 174446d999cSRussell King * attached to the device is a genpd domain. 175446d999cSRussell King */ 176446d999cSRussell King static struct generic_pm_domain *dev_to_genpd(struct device *dev) 1775248051bSRafael J. Wysocki { 1785248051bSRafael J. Wysocki if (IS_ERR_OR_NULL(dev->pm_domain)) 1795248051bSRafael J. Wysocki return ERR_PTR(-EINVAL); 1805248051bSRafael J. Wysocki 181596ba34bSRafael J. Wysocki return pd_to_genpd(dev->pm_domain); 1825248051bSRafael J. Wysocki } 183f721889fSRafael J. Wysocki 184d8600c8bSKrzysztof Kozlowski static int genpd_stop_dev(const struct generic_pm_domain *genpd, 185d8600c8bSKrzysztof Kozlowski struct device *dev) 186d5e4cbfeSRafael J. Wysocki { 18751cda844SUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, stop, dev); 188d5e4cbfeSRafael J. Wysocki } 189d5e4cbfeSRafael J. Wysocki 190d8600c8bSKrzysztof Kozlowski static int genpd_start_dev(const struct generic_pm_domain *genpd, 191d8600c8bSKrzysztof Kozlowski struct device *dev) 192d5e4cbfeSRafael J. Wysocki { 193ba2bbfbfSUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, start, dev); 194d5e4cbfeSRafael J. Wysocki } 195d5e4cbfeSRafael J. Wysocki 196c4bb3160SRafael J. Wysocki static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd) 197f721889fSRafael J. Wysocki { 198c4bb3160SRafael J. Wysocki bool ret = false; 199c4bb3160SRafael J. Wysocki 200c4bb3160SRafael J. Wysocki if (!WARN_ON(atomic_read(&genpd->sd_count) == 0)) 201c4bb3160SRafael J. Wysocki ret = !!atomic_dec_and_test(&genpd->sd_count); 202c4bb3160SRafael J. Wysocki 203c4bb3160SRafael J. Wysocki return ret; 204c4bb3160SRafael J. Wysocki } 205c4bb3160SRafael J. Wysocki 206c4bb3160SRafael J. Wysocki static void genpd_sd_counter_inc(struct generic_pm_domain *genpd) 207c4bb3160SRafael J. Wysocki { 208c4bb3160SRafael J. Wysocki atomic_inc(&genpd->sd_count); 2094e857c58SPeter Zijlstra smp_mb__after_atomic(); 210f721889fSRafael J. Wysocki } 211f721889fSRafael J. Wysocki 212afece3abSThara Gopinath #ifdef CONFIG_DEBUG_FS 213afece3abSThara Gopinath static void genpd_update_accounting(struct generic_pm_domain *genpd) 214afece3abSThara Gopinath { 215afece3abSThara Gopinath ktime_t delta, now; 216afece3abSThara Gopinath 217afece3abSThara Gopinath now = ktime_get(); 218afece3abSThara Gopinath delta = ktime_sub(now, genpd->accounting_time); 219afece3abSThara Gopinath 220afece3abSThara Gopinath /* 221afece3abSThara Gopinath * If genpd->status is active, it means we are just 222afece3abSThara Gopinath * out of off and so update the idle time and vice 223afece3abSThara Gopinath * versa. 224afece3abSThara Gopinath */ 225afece3abSThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) { 226afece3abSThara Gopinath int state_idx = genpd->state_idx; 227afece3abSThara Gopinath 228afece3abSThara Gopinath genpd->states[state_idx].idle_time = 229afece3abSThara Gopinath ktime_add(genpd->states[state_idx].idle_time, delta); 230afece3abSThara Gopinath } else { 231afece3abSThara Gopinath genpd->on_time = ktime_add(genpd->on_time, delta); 232afece3abSThara Gopinath } 233afece3abSThara Gopinath 234afece3abSThara Gopinath genpd->accounting_time = now; 235afece3abSThara Gopinath } 236afece3abSThara Gopinath #else 237afece3abSThara Gopinath static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {} 238afece3abSThara Gopinath #endif 239afece3abSThara Gopinath 240cd50c6d3SViresh Kumar static int _genpd_reeval_performance_state(struct generic_pm_domain *genpd, 241cd50c6d3SViresh Kumar unsigned int state) 242cd50c6d3SViresh Kumar { 243cd50c6d3SViresh Kumar struct generic_pm_domain_data *pd_data; 244cd50c6d3SViresh Kumar struct pm_domain_data *pdd; 24518edf49cSViresh Kumar struct gpd_link *link; 246cd50c6d3SViresh Kumar 247cd50c6d3SViresh Kumar /* New requested state is same as Max requested state */ 248cd50c6d3SViresh Kumar if (state == genpd->performance_state) 249cd50c6d3SViresh Kumar return state; 250cd50c6d3SViresh Kumar 251cd50c6d3SViresh Kumar /* New requested state is higher than Max requested state */ 252cd50c6d3SViresh Kumar if (state > genpd->performance_state) 253cd50c6d3SViresh Kumar return state; 254cd50c6d3SViresh Kumar 255cd50c6d3SViresh Kumar /* Traverse all devices within the domain */ 256cd50c6d3SViresh Kumar list_for_each_entry(pdd, &genpd->dev_list, list_node) { 257cd50c6d3SViresh Kumar pd_data = to_gpd_data(pdd); 258cd50c6d3SViresh Kumar 259cd50c6d3SViresh Kumar if (pd_data->performance_state > state) 260cd50c6d3SViresh Kumar state = pd_data->performance_state; 261cd50c6d3SViresh Kumar } 262cd50c6d3SViresh Kumar 263cd50c6d3SViresh Kumar /* 26418edf49cSViresh Kumar * Traverse all sub-domains within the domain. This can be 26518edf49cSViresh Kumar * done without any additional locking as the link->performance_state 26618edf49cSViresh Kumar * field is protected by the master genpd->lock, which is already taken. 26718edf49cSViresh Kumar * 26818edf49cSViresh Kumar * Also note that link->performance_state (subdomain's performance state 26918edf49cSViresh Kumar * requirement to master domain) is different from 27018edf49cSViresh Kumar * link->slave->performance_state (current performance state requirement 27118edf49cSViresh Kumar * of the devices/sub-domains of the subdomain) and so can have a 27218edf49cSViresh Kumar * different value. 27318edf49cSViresh Kumar * 27418edf49cSViresh Kumar * Note that we also take vote from powered-off sub-domains into account 27518edf49cSViresh Kumar * as the same is done for devices right now. 276cd50c6d3SViresh Kumar */ 27718edf49cSViresh Kumar list_for_each_entry(link, &genpd->master_links, master_node) { 27818edf49cSViresh Kumar if (link->performance_state > state) 27918edf49cSViresh Kumar state = link->performance_state; 28018edf49cSViresh Kumar } 28118edf49cSViresh Kumar 282cd50c6d3SViresh Kumar return state; 283cd50c6d3SViresh Kumar } 284cd50c6d3SViresh Kumar 285cd50c6d3SViresh Kumar static int _genpd_set_performance_state(struct generic_pm_domain *genpd, 28618edf49cSViresh Kumar unsigned int state, int depth) 287cd50c6d3SViresh Kumar { 28818edf49cSViresh Kumar struct generic_pm_domain *master; 28918edf49cSViresh Kumar struct gpd_link *link; 29018edf49cSViresh Kumar int master_state, ret; 291cd50c6d3SViresh Kumar 292cd50c6d3SViresh Kumar if (state == genpd->performance_state) 293cd50c6d3SViresh Kumar return 0; 294cd50c6d3SViresh Kumar 29518edf49cSViresh Kumar /* Propagate to masters of genpd */ 29618edf49cSViresh Kumar list_for_each_entry(link, &genpd->slave_links, slave_node) { 29718edf49cSViresh Kumar master = link->master; 29818edf49cSViresh Kumar 29918edf49cSViresh Kumar if (!master->set_performance_state) 30018edf49cSViresh Kumar continue; 30118edf49cSViresh Kumar 30218edf49cSViresh Kumar /* Find master's performance state */ 30318edf49cSViresh Kumar ret = dev_pm_opp_xlate_performance_state(genpd->opp_table, 30418edf49cSViresh Kumar master->opp_table, 30518edf49cSViresh Kumar state); 30618edf49cSViresh Kumar if (unlikely(ret < 0)) 30718edf49cSViresh Kumar goto err; 30818edf49cSViresh Kumar 30918edf49cSViresh Kumar master_state = ret; 31018edf49cSViresh Kumar 31118edf49cSViresh Kumar genpd_lock_nested(master, depth + 1); 31218edf49cSViresh Kumar 31318edf49cSViresh Kumar link->prev_performance_state = link->performance_state; 31418edf49cSViresh Kumar link->performance_state = master_state; 31518edf49cSViresh Kumar master_state = _genpd_reeval_performance_state(master, 31618edf49cSViresh Kumar master_state); 31718edf49cSViresh Kumar ret = _genpd_set_performance_state(master, master_state, depth + 1); 31818edf49cSViresh Kumar if (ret) 31918edf49cSViresh Kumar link->performance_state = link->prev_performance_state; 32018edf49cSViresh Kumar 32118edf49cSViresh Kumar genpd_unlock(master); 32218edf49cSViresh Kumar 32318edf49cSViresh Kumar if (ret) 32418edf49cSViresh Kumar goto err; 32518edf49cSViresh Kumar } 32618edf49cSViresh Kumar 327cd50c6d3SViresh Kumar ret = genpd->set_performance_state(genpd, state); 328cd50c6d3SViresh Kumar if (ret) 32918edf49cSViresh Kumar goto err; 330cd50c6d3SViresh Kumar 331cd50c6d3SViresh Kumar genpd->performance_state = state; 332cd50c6d3SViresh Kumar return 0; 33318edf49cSViresh Kumar 33418edf49cSViresh Kumar err: 33518edf49cSViresh Kumar /* Encountered an error, lets rollback */ 33618edf49cSViresh Kumar list_for_each_entry_continue_reverse(link, &genpd->slave_links, 33718edf49cSViresh Kumar slave_node) { 33818edf49cSViresh Kumar master = link->master; 33918edf49cSViresh Kumar 34018edf49cSViresh Kumar if (!master->set_performance_state) 34118edf49cSViresh Kumar continue; 34218edf49cSViresh Kumar 34318edf49cSViresh Kumar genpd_lock_nested(master, depth + 1); 34418edf49cSViresh Kumar 34518edf49cSViresh Kumar master_state = link->prev_performance_state; 34618edf49cSViresh Kumar link->performance_state = master_state; 34718edf49cSViresh Kumar 34818edf49cSViresh Kumar master_state = _genpd_reeval_performance_state(master, 34918edf49cSViresh Kumar master_state); 35018edf49cSViresh Kumar if (_genpd_set_performance_state(master, master_state, depth + 1)) { 35118edf49cSViresh Kumar pr_err("%s: Failed to roll back to %d performance state\n", 35218edf49cSViresh Kumar master->name, master_state); 35318edf49cSViresh Kumar } 35418edf49cSViresh Kumar 35518edf49cSViresh Kumar genpd_unlock(master); 35618edf49cSViresh Kumar } 35718edf49cSViresh Kumar 35818edf49cSViresh Kumar return ret; 359cd50c6d3SViresh Kumar } 360cd50c6d3SViresh Kumar 36142f6284aSViresh Kumar /** 36242f6284aSViresh Kumar * dev_pm_genpd_set_performance_state- Set performance state of device's power 36342f6284aSViresh Kumar * domain. 36442f6284aSViresh Kumar * 36542f6284aSViresh Kumar * @dev: Device for which the performance-state needs to be set. 36642f6284aSViresh Kumar * @state: Target performance state of the device. This can be set as 0 when the 36742f6284aSViresh Kumar * device doesn't have any performance state constraints left (And so 36842f6284aSViresh Kumar * the device wouldn't participate anymore to find the target 36942f6284aSViresh Kumar * performance state of the genpd). 37042f6284aSViresh Kumar * 37142f6284aSViresh Kumar * It is assumed that the users guarantee that the genpd wouldn't be detached 37242f6284aSViresh Kumar * while this routine is getting called. 37342f6284aSViresh Kumar * 37442f6284aSViresh Kumar * Returns 0 on success and negative error values on failures. 37542f6284aSViresh Kumar */ 37642f6284aSViresh Kumar int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state) 37742f6284aSViresh Kumar { 37842f6284aSViresh Kumar struct generic_pm_domain *genpd; 379cd50c6d3SViresh Kumar struct generic_pm_domain_data *gpd_data; 38042f6284aSViresh Kumar unsigned int prev; 381cd50c6d3SViresh Kumar int ret; 38242f6284aSViresh Kumar 3833ea4ca92SUlf Hansson genpd = dev_to_genpd_safe(dev); 3843ea4ca92SUlf Hansson if (!genpd) 38542f6284aSViresh Kumar return -ENODEV; 38642f6284aSViresh Kumar 38742f6284aSViresh Kumar if (unlikely(!genpd->set_performance_state)) 38842f6284aSViresh Kumar return -EINVAL; 38942f6284aSViresh Kumar 390e757e7faSYangtao Li if (WARN_ON(!dev->power.subsys_data || 391e757e7faSYangtao Li !dev->power.subsys_data->domain_data)) 39242f6284aSViresh Kumar return -EINVAL; 39342f6284aSViresh Kumar 39442f6284aSViresh Kumar genpd_lock(genpd); 39542f6284aSViresh Kumar 39642f6284aSViresh Kumar gpd_data = to_gpd_data(dev->power.subsys_data->domain_data); 39742f6284aSViresh Kumar prev = gpd_data->performance_state; 39842f6284aSViresh Kumar gpd_data->performance_state = state; 39942f6284aSViresh Kumar 400cd50c6d3SViresh Kumar state = _genpd_reeval_performance_state(genpd, state); 40118edf49cSViresh Kumar ret = _genpd_set_performance_state(genpd, state, 0); 402cd50c6d3SViresh Kumar if (ret) 40342f6284aSViresh Kumar gpd_data->performance_state = prev; 40442f6284aSViresh Kumar 40542f6284aSViresh Kumar genpd_unlock(genpd); 40642f6284aSViresh Kumar 40742f6284aSViresh Kumar return ret; 40842f6284aSViresh Kumar } 40942f6284aSViresh Kumar EXPORT_SYMBOL_GPL(dev_pm_genpd_set_performance_state); 41042f6284aSViresh Kumar 41186e12eacSUlf Hansson static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) 412c8f0ea45SGeert Uytterhoeven { 413fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 414c8f0ea45SGeert Uytterhoeven ktime_t time_start; 415c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 416c8f0ea45SGeert Uytterhoeven int ret; 417c8f0ea45SGeert Uytterhoeven 418c8f0ea45SGeert Uytterhoeven if (!genpd->power_on) 419c8f0ea45SGeert Uytterhoeven return 0; 420c8f0ea45SGeert Uytterhoeven 421a4630c61SGeert Uytterhoeven if (!timed) 422a4630c61SGeert Uytterhoeven return genpd->power_on(genpd); 423a4630c61SGeert Uytterhoeven 424c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 425c8f0ea45SGeert Uytterhoeven ret = genpd->power_on(genpd); 426c8f0ea45SGeert Uytterhoeven if (ret) 427c8f0ea45SGeert Uytterhoeven return ret; 428c8f0ea45SGeert Uytterhoeven 429c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 430fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_on_latency_ns) 431c8f0ea45SGeert Uytterhoeven return ret; 432c8f0ea45SGeert Uytterhoeven 433fc5cbf0cSAxel Haslam genpd->states[state_idx].power_on_latency_ns = elapsed_ns; 434c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 4356d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 436c8f0ea45SGeert Uytterhoeven genpd->name, "on", elapsed_ns); 437c8f0ea45SGeert Uytterhoeven 438c8f0ea45SGeert Uytterhoeven return ret; 439c8f0ea45SGeert Uytterhoeven } 440c8f0ea45SGeert Uytterhoeven 44186e12eacSUlf Hansson static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed) 442c8f0ea45SGeert Uytterhoeven { 443fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 444c8f0ea45SGeert Uytterhoeven ktime_t time_start; 445c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 446c8f0ea45SGeert Uytterhoeven int ret; 447c8f0ea45SGeert Uytterhoeven 448c8f0ea45SGeert Uytterhoeven if (!genpd->power_off) 449c8f0ea45SGeert Uytterhoeven return 0; 450c8f0ea45SGeert Uytterhoeven 451a4630c61SGeert Uytterhoeven if (!timed) 452a4630c61SGeert Uytterhoeven return genpd->power_off(genpd); 453a4630c61SGeert Uytterhoeven 454c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 455c8f0ea45SGeert Uytterhoeven ret = genpd->power_off(genpd); 4560cec68a9SAisheng Dong if (ret) 457c8f0ea45SGeert Uytterhoeven return ret; 458c8f0ea45SGeert Uytterhoeven 459c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 460fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_off_latency_ns) 4610cec68a9SAisheng Dong return 0; 462c8f0ea45SGeert Uytterhoeven 463fc5cbf0cSAxel Haslam genpd->states[state_idx].power_off_latency_ns = elapsed_ns; 464c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 4656d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 466c8f0ea45SGeert Uytterhoeven genpd->name, "off", elapsed_ns); 467c8f0ea45SGeert Uytterhoeven 4680cec68a9SAisheng Dong return 0; 469c8f0ea45SGeert Uytterhoeven } 470c8f0ea45SGeert Uytterhoeven 471f721889fSRafael J. Wysocki /** 47286e12eacSUlf Hansson * genpd_queue_power_off_work - Queue up the execution of genpd_power_off(). 473a3d09c73SMoritz Fischer * @genpd: PM domain to power off. 47429e47e21SUlf Hansson * 47586e12eacSUlf Hansson * Queue up the execution of genpd_power_off() unless it's already been done 47629e47e21SUlf Hansson * before. 47729e47e21SUlf Hansson */ 47829e47e21SUlf Hansson static void genpd_queue_power_off_work(struct generic_pm_domain *genpd) 47929e47e21SUlf Hansson { 48029e47e21SUlf Hansson queue_work(pm_wq, &genpd->power_off_work); 48129e47e21SUlf Hansson } 48229e47e21SUlf Hansson 48329e47e21SUlf Hansson /** 4841f8728b7SUlf Hansson * genpd_power_off - Remove power from a given PM domain. 4851f8728b7SUlf Hansson * @genpd: PM domain to power down. 4863c64649dSUlf Hansson * @one_dev_on: If invoked from genpd's ->runtime_suspend|resume() callback, the 4873c64649dSUlf Hansson * RPM status of the releated device is in an intermediate state, not yet turned 4883c64649dSUlf Hansson * into RPM_SUSPENDED. This means genpd_power_off() must allow one device to not 4893c64649dSUlf Hansson * be RPM_SUSPENDED, while it tries to power off the PM domain. 4901f8728b7SUlf Hansson * 4911f8728b7SUlf Hansson * If all of the @genpd's devices have been suspended and all of its subdomains 4921f8728b7SUlf Hansson * have been powered down, remove power from @genpd. 4931f8728b7SUlf Hansson */ 4942da83545SUlf Hansson static int genpd_power_off(struct generic_pm_domain *genpd, bool one_dev_on, 4952da83545SUlf Hansson unsigned int depth) 4961f8728b7SUlf Hansson { 4971f8728b7SUlf Hansson struct pm_domain_data *pdd; 4981f8728b7SUlf Hansson struct gpd_link *link; 4991f8728b7SUlf Hansson unsigned int not_suspended = 0; 5001f8728b7SUlf Hansson 5011f8728b7SUlf Hansson /* 5021f8728b7SUlf Hansson * Do not try to power off the domain in the following situations: 5031f8728b7SUlf Hansson * (1) The domain is already in the "power off" state. 5041f8728b7SUlf Hansson * (2) System suspend is in progress. 5051f8728b7SUlf Hansson */ 50641e2c8e0SUlf Hansson if (!genpd_status_on(genpd) || genpd->prepared_count > 0) 5071f8728b7SUlf Hansson return 0; 5081f8728b7SUlf Hansson 509ffaa42e8SUlf Hansson /* 510ffaa42e8SUlf Hansson * Abort power off for the PM domain in the following situations: 511ffaa42e8SUlf Hansson * (1) The domain is configured as always on. 512ffaa42e8SUlf Hansson * (2) When the domain has a subdomain being powered on. 513ffaa42e8SUlf Hansson */ 514ed61e18aSLeonard Crestez if (genpd_is_always_on(genpd) || 515ed61e18aSLeonard Crestez genpd_is_rpm_always_on(genpd) || 516ed61e18aSLeonard Crestez atomic_read(&genpd->sd_count) > 0) 5171f8728b7SUlf Hansson return -EBUSY; 5181f8728b7SUlf Hansson 5191f8728b7SUlf Hansson list_for_each_entry(pdd, &genpd->dev_list, list_node) { 5201f8728b7SUlf Hansson enum pm_qos_flags_status stat; 5211f8728b7SUlf Hansson 52220f97cafSRafael J. Wysocki stat = dev_pm_qos_flags(pdd->dev, PM_QOS_FLAG_NO_POWER_OFF); 5231f8728b7SUlf Hansson if (stat > PM_QOS_FLAGS_NONE) 5241f8728b7SUlf Hansson return -EBUSY; 5251f8728b7SUlf Hansson 5261f8728b7SUlf Hansson /* 5271f8728b7SUlf Hansson * Do not allow PM domain to be powered off, when an IRQ safe 5281f8728b7SUlf Hansson * device is part of a non-IRQ safe domain. 5291f8728b7SUlf Hansson */ 5301f8728b7SUlf Hansson if (!pm_runtime_suspended(pdd->dev) || 5311f8728b7SUlf Hansson irq_safe_dev_in_no_sleep_domain(pdd->dev, genpd)) 5321f8728b7SUlf Hansson not_suspended++; 5331f8728b7SUlf Hansson } 5341f8728b7SUlf Hansson 5353c64649dSUlf Hansson if (not_suspended > 1 || (not_suspended == 1 && !one_dev_on)) 5361f8728b7SUlf Hansson return -EBUSY; 5371f8728b7SUlf Hansson 5381f8728b7SUlf Hansson if (genpd->gov && genpd->gov->power_down_ok) { 5391f8728b7SUlf Hansson if (!genpd->gov->power_down_ok(&genpd->domain)) 5401f8728b7SUlf Hansson return -EAGAIN; 5411f8728b7SUlf Hansson } 5421f8728b7SUlf Hansson 5432c9b7f87SUlf Hansson /* Default to shallowest state. */ 5442c9b7f87SUlf Hansson if (!genpd->gov) 5452c9b7f87SUlf Hansson genpd->state_idx = 0; 5462c9b7f87SUlf Hansson 5471f8728b7SUlf Hansson if (genpd->power_off) { 5481f8728b7SUlf Hansson int ret; 5491f8728b7SUlf Hansson 5501f8728b7SUlf Hansson if (atomic_read(&genpd->sd_count) > 0) 5511f8728b7SUlf Hansson return -EBUSY; 5521f8728b7SUlf Hansson 5531f8728b7SUlf Hansson /* 5541f8728b7SUlf Hansson * If sd_count > 0 at this point, one of the subdomains hasn't 5551f8728b7SUlf Hansson * managed to call genpd_power_on() for the master yet after 5561f8728b7SUlf Hansson * incrementing it. In that case genpd_power_on() will wait 5571f8728b7SUlf Hansson * for us to drop the lock, so we can call .power_off() and let 5581f8728b7SUlf Hansson * the genpd_power_on() restore power for us (this shouldn't 5591f8728b7SUlf Hansson * happen very often). 5601f8728b7SUlf Hansson */ 5611f8728b7SUlf Hansson ret = _genpd_power_off(genpd, true); 5621f8728b7SUlf Hansson if (ret) 5631f8728b7SUlf Hansson return ret; 5641f8728b7SUlf Hansson } 5651f8728b7SUlf Hansson 5661f8728b7SUlf Hansson genpd->status = GPD_STATE_POWER_OFF; 567afece3abSThara Gopinath genpd_update_accounting(genpd); 5681f8728b7SUlf Hansson 5691f8728b7SUlf Hansson list_for_each_entry(link, &genpd->slave_links, slave_node) { 5701f8728b7SUlf Hansson genpd_sd_counter_dec(link->master); 5712da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 5722da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 5732da83545SUlf Hansson genpd_unlock(link->master); 5741f8728b7SUlf Hansson } 5751f8728b7SUlf Hansson 5761f8728b7SUlf Hansson return 0; 5771f8728b7SUlf Hansson } 5781f8728b7SUlf Hansson 5791f8728b7SUlf Hansson /** 58086e12eacSUlf Hansson * genpd_power_on - Restore power to a given PM domain and its masters. 5815248051bSRafael J. Wysocki * @genpd: PM domain to power up. 5820106ef51SMarek Szyprowski * @depth: nesting count for lockdep. 5835248051bSRafael J. Wysocki * 5845063ce15SRafael J. Wysocki * Restore power to @genpd and all of its masters so that it is possible to 5855248051bSRafael J. Wysocki * resume a device belonging to it. 5865248051bSRafael J. Wysocki */ 58786e12eacSUlf Hansson static int genpd_power_on(struct generic_pm_domain *genpd, unsigned int depth) 5885248051bSRafael J. Wysocki { 5895063ce15SRafael J. Wysocki struct gpd_link *link; 5905248051bSRafael J. Wysocki int ret = 0; 5915248051bSRafael J. Wysocki 59241e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 5933f241775SRafael J. Wysocki return 0; 5945248051bSRafael J. Wysocki 5955063ce15SRafael J. Wysocki /* 5965063ce15SRafael J. Wysocki * The list is guaranteed not to change while the loop below is being 5975063ce15SRafael J. Wysocki * executed, unless one of the masters' .power_on() callbacks fiddles 5985063ce15SRafael J. Wysocki * with it. 5995063ce15SRafael J. Wysocki */ 6005063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 6010106ef51SMarek Szyprowski struct generic_pm_domain *master = link->master; 6025248051bSRafael J. Wysocki 6030106ef51SMarek Szyprowski genpd_sd_counter_inc(master); 6040106ef51SMarek Szyprowski 60535241d12SLina Iyer genpd_lock_nested(master, depth + 1); 60686e12eacSUlf Hansson ret = genpd_power_on(master, depth + 1); 60735241d12SLina Iyer genpd_unlock(master); 6080106ef51SMarek Szyprowski 6095063ce15SRafael J. Wysocki if (ret) { 6100106ef51SMarek Szyprowski genpd_sd_counter_dec(master); 6119e08cf42SRafael J. Wysocki goto err; 6125248051bSRafael J. Wysocki } 6135063ce15SRafael J. Wysocki } 6145248051bSRafael J. Wysocki 61586e12eacSUlf Hansson ret = _genpd_power_on(genpd, true); 6169e08cf42SRafael J. Wysocki if (ret) 6179e08cf42SRafael J. Wysocki goto err; 6180140d8bdSRafael J. Wysocki 619ba2bbfbfSUlf Hansson genpd->status = GPD_STATE_ACTIVE; 620afece3abSThara Gopinath genpd_update_accounting(genpd); 621afece3abSThara Gopinath 6223f241775SRafael J. Wysocki return 0; 6239e08cf42SRafael J. Wysocki 6249e08cf42SRafael J. Wysocki err: 62529e47e21SUlf Hansson list_for_each_entry_continue_reverse(link, 62629e47e21SUlf Hansson &genpd->slave_links, 62729e47e21SUlf Hansson slave_node) { 6285063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 6292da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 6302da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 6312da83545SUlf Hansson genpd_unlock(link->master); 63229e47e21SUlf Hansson } 6339e08cf42SRafael J. Wysocki 6343f241775SRafael J. Wysocki return ret; 6353f241775SRafael J. Wysocki } 6363f241775SRafael J. Wysocki 6376ff7bb0dSRafael J. Wysocki static int genpd_dev_pm_qos_notifier(struct notifier_block *nb, 6386ff7bb0dSRafael J. Wysocki unsigned long val, void *ptr) 6396ff7bb0dSRafael J. Wysocki { 6406ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 6416ff7bb0dSRafael J. Wysocki struct device *dev; 6426ff7bb0dSRafael J. Wysocki 6436ff7bb0dSRafael J. Wysocki gpd_data = container_of(nb, struct generic_pm_domain_data, nb); 6446ff7bb0dSRafael J. Wysocki dev = gpd_data->base.dev; 6456ff7bb0dSRafael J. Wysocki 6466ff7bb0dSRafael J. Wysocki for (;;) { 6476ff7bb0dSRafael J. Wysocki struct generic_pm_domain *genpd; 6486ff7bb0dSRafael J. Wysocki struct pm_domain_data *pdd; 6496ff7bb0dSRafael J. Wysocki 6506ff7bb0dSRafael J. Wysocki spin_lock_irq(&dev->power.lock); 6516ff7bb0dSRafael J. Wysocki 6526ff7bb0dSRafael J. Wysocki pdd = dev->power.subsys_data ? 6536ff7bb0dSRafael J. Wysocki dev->power.subsys_data->domain_data : NULL; 654b4883ca4SViresh Kumar if (pdd) { 6556ff7bb0dSRafael J. Wysocki to_gpd_data(pdd)->td.constraint_changed = true; 6566ff7bb0dSRafael J. Wysocki genpd = dev_to_genpd(dev); 6576ff7bb0dSRafael J. Wysocki } else { 6586ff7bb0dSRafael J. Wysocki genpd = ERR_PTR(-ENODATA); 6596ff7bb0dSRafael J. Wysocki } 6606ff7bb0dSRafael J. Wysocki 6616ff7bb0dSRafael J. Wysocki spin_unlock_irq(&dev->power.lock); 6626ff7bb0dSRafael J. Wysocki 6636ff7bb0dSRafael J. Wysocki if (!IS_ERR(genpd)) { 66435241d12SLina Iyer genpd_lock(genpd); 6656ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 66635241d12SLina Iyer genpd_unlock(genpd); 6676ff7bb0dSRafael J. Wysocki } 6686ff7bb0dSRafael J. Wysocki 6696ff7bb0dSRafael J. Wysocki dev = dev->parent; 6706ff7bb0dSRafael J. Wysocki if (!dev || dev->power.ignore_children) 6716ff7bb0dSRafael J. Wysocki break; 6726ff7bb0dSRafael J. Wysocki } 6736ff7bb0dSRafael J. Wysocki 6746ff7bb0dSRafael J. Wysocki return NOTIFY_DONE; 6756ff7bb0dSRafael J. Wysocki } 6766ff7bb0dSRafael J. Wysocki 6775248051bSRafael J. Wysocki /** 678f721889fSRafael J. Wysocki * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0. 679f721889fSRafael J. Wysocki * @work: Work structure used for scheduling the execution of this function. 680f721889fSRafael J. Wysocki */ 681f721889fSRafael J. Wysocki static void genpd_power_off_work_fn(struct work_struct *work) 682f721889fSRafael J. Wysocki { 683f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 684f721889fSRafael J. Wysocki 685f721889fSRafael J. Wysocki genpd = container_of(work, struct generic_pm_domain, power_off_work); 686f721889fSRafael J. Wysocki 68735241d12SLina Iyer genpd_lock(genpd); 6882da83545SUlf Hansson genpd_power_off(genpd, false, 0); 68935241d12SLina Iyer genpd_unlock(genpd); 690f721889fSRafael J. Wysocki } 691f721889fSRafael J. Wysocki 692f721889fSRafael J. Wysocki /** 69354eeddbfSUlf Hansson * __genpd_runtime_suspend - walk the hierarchy of ->runtime_suspend() callbacks 69454eeddbfSUlf Hansson * @dev: Device to handle. 69554eeddbfSUlf Hansson */ 69654eeddbfSUlf Hansson static int __genpd_runtime_suspend(struct device *dev) 69754eeddbfSUlf Hansson { 69854eeddbfSUlf Hansson int (*cb)(struct device *__dev); 69954eeddbfSUlf Hansson 70054eeddbfSUlf Hansson if (dev->type && dev->type->pm) 70154eeddbfSUlf Hansson cb = dev->type->pm->runtime_suspend; 70254eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 70354eeddbfSUlf Hansson cb = dev->class->pm->runtime_suspend; 70454eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 70554eeddbfSUlf Hansson cb = dev->bus->pm->runtime_suspend; 70654eeddbfSUlf Hansson else 70754eeddbfSUlf Hansson cb = NULL; 70854eeddbfSUlf Hansson 70954eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 71054eeddbfSUlf Hansson cb = dev->driver->pm->runtime_suspend; 71154eeddbfSUlf Hansson 71254eeddbfSUlf Hansson return cb ? cb(dev) : 0; 71354eeddbfSUlf Hansson } 71454eeddbfSUlf Hansson 71554eeddbfSUlf Hansson /** 71654eeddbfSUlf Hansson * __genpd_runtime_resume - walk the hierarchy of ->runtime_resume() callbacks 71754eeddbfSUlf Hansson * @dev: Device to handle. 71854eeddbfSUlf Hansson */ 71954eeddbfSUlf Hansson static int __genpd_runtime_resume(struct device *dev) 72054eeddbfSUlf Hansson { 72154eeddbfSUlf Hansson int (*cb)(struct device *__dev); 72254eeddbfSUlf Hansson 72354eeddbfSUlf Hansson if (dev->type && dev->type->pm) 72454eeddbfSUlf Hansson cb = dev->type->pm->runtime_resume; 72554eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 72654eeddbfSUlf Hansson cb = dev->class->pm->runtime_resume; 72754eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 72854eeddbfSUlf Hansson cb = dev->bus->pm->runtime_resume; 72954eeddbfSUlf Hansson else 73054eeddbfSUlf Hansson cb = NULL; 73154eeddbfSUlf Hansson 73254eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 73354eeddbfSUlf Hansson cb = dev->driver->pm->runtime_resume; 73454eeddbfSUlf Hansson 73554eeddbfSUlf Hansson return cb ? cb(dev) : 0; 73654eeddbfSUlf Hansson } 73754eeddbfSUlf Hansson 73854eeddbfSUlf Hansson /** 739795bd2e7SUlf Hansson * genpd_runtime_suspend - Suspend a device belonging to I/O PM domain. 740f721889fSRafael J. Wysocki * @dev: Device to suspend. 741f721889fSRafael J. Wysocki * 742f721889fSRafael J. Wysocki * Carry out a runtime suspend of a device under the assumption that its 743f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 744f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 745f721889fSRafael J. Wysocki */ 746795bd2e7SUlf Hansson static int genpd_runtime_suspend(struct device *dev) 747f721889fSRafael J. Wysocki { 748f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 7499df3921eSUlf Hansson bool (*suspend_ok)(struct device *__dev); 7502b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 751ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 7522b1d88cdSUlf Hansson ktime_t time_start; 7532b1d88cdSUlf Hansson s64 elapsed_ns; 754d5e4cbfeSRafael J. Wysocki int ret; 755f721889fSRafael J. Wysocki 756f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 757f721889fSRafael J. Wysocki 7585248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 7595248051bSRafael J. Wysocki if (IS_ERR(genpd)) 760f721889fSRafael J. Wysocki return -EINVAL; 761f721889fSRafael J. Wysocki 762ffe12855SUlf Hansson /* 763ffe12855SUlf Hansson * A runtime PM centric subsystem/driver may re-use the runtime PM 764ffe12855SUlf Hansson * callbacks for other purposes than runtime PM. In those scenarios 765ffe12855SUlf Hansson * runtime PM is disabled. Under these circumstances, we shall skip 766ffe12855SUlf Hansson * validating/measuring the PM QoS latency. 767ffe12855SUlf Hansson */ 7689df3921eSUlf Hansson suspend_ok = genpd->gov ? genpd->gov->suspend_ok : NULL; 7699df3921eSUlf Hansson if (runtime_pm && suspend_ok && !suspend_ok(dev)) 770b02c999aSRafael J. Wysocki return -EBUSY; 771b02c999aSRafael J. Wysocki 7722b1d88cdSUlf Hansson /* Measure suspend latency. */ 773d33d5a6cSLinus Torvalds time_start = 0; 774ffe12855SUlf Hansson if (runtime_pm) 7752b1d88cdSUlf Hansson time_start = ktime_get(); 7762b1d88cdSUlf Hansson 77754eeddbfSUlf Hansson ret = __genpd_runtime_suspend(dev); 778f721889fSRafael J. Wysocki if (ret) 77917b75ecaSRafael J. Wysocki return ret; 78017b75ecaSRafael J. Wysocki 7812b1d88cdSUlf Hansson ret = genpd_stop_dev(genpd, dev); 782ba2bbfbfSUlf Hansson if (ret) { 78354eeddbfSUlf Hansson __genpd_runtime_resume(dev); 784ba2bbfbfSUlf Hansson return ret; 785ba2bbfbfSUlf Hansson } 786ba2bbfbfSUlf Hansson 7872b1d88cdSUlf Hansson /* Update suspend latency value if the measured time exceeds it. */ 788ffe12855SUlf Hansson if (runtime_pm) { 7892b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 7902b1d88cdSUlf Hansson if (elapsed_ns > td->suspend_latency_ns) { 7912b1d88cdSUlf Hansson td->suspend_latency_ns = elapsed_ns; 7922b1d88cdSUlf Hansson dev_dbg(dev, "suspend latency exceeded, %lld ns\n", 7932b1d88cdSUlf Hansson elapsed_ns); 7942b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 7952b1d88cdSUlf Hansson td->constraint_changed = true; 7962b1d88cdSUlf Hansson } 797ffe12855SUlf Hansson } 7982b1d88cdSUlf Hansson 7990aa2a221SRafael J. Wysocki /* 800d716f479SLina Iyer * If power.irq_safe is set, this routine may be run with 801d716f479SLina Iyer * IRQs disabled, so suspend only if the PM domain also is irq_safe. 8020aa2a221SRafael J. Wysocki */ 803d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) 8040aa2a221SRafael J. Wysocki return 0; 8050aa2a221SRafael J. Wysocki 80635241d12SLina Iyer genpd_lock(genpd); 8072da83545SUlf Hansson genpd_power_off(genpd, true, 0); 80835241d12SLina Iyer genpd_unlock(genpd); 809f721889fSRafael J. Wysocki 810f721889fSRafael J. Wysocki return 0; 811f721889fSRafael J. Wysocki } 812f721889fSRafael J. Wysocki 813f721889fSRafael J. Wysocki /** 814795bd2e7SUlf Hansson * genpd_runtime_resume - Resume a device belonging to I/O PM domain. 815f721889fSRafael J. Wysocki * @dev: Device to resume. 816f721889fSRafael J. Wysocki * 817f721889fSRafael J. Wysocki * Carry out a runtime resume of a device under the assumption that its 818f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 819f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 820f721889fSRafael J. Wysocki */ 821795bd2e7SUlf Hansson static int genpd_runtime_resume(struct device *dev) 822f721889fSRafael J. Wysocki { 823f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 8242b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 825ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 8262b1d88cdSUlf Hansson ktime_t time_start; 8272b1d88cdSUlf Hansson s64 elapsed_ns; 828f721889fSRafael J. Wysocki int ret; 829ba2bbfbfSUlf Hansson bool timed = true; 830f721889fSRafael J. Wysocki 831f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 832f721889fSRafael J. Wysocki 8335248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 8345248051bSRafael J. Wysocki if (IS_ERR(genpd)) 835f721889fSRafael J. Wysocki return -EINVAL; 836f721889fSRafael J. Wysocki 837d716f479SLina Iyer /* 838d716f479SLina Iyer * As we don't power off a non IRQ safe domain, which holds 839d716f479SLina Iyer * an IRQ safe device, we don't need to restore power to it. 840d716f479SLina Iyer */ 841d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) { 842ba2bbfbfSUlf Hansson timed = false; 843ba2bbfbfSUlf Hansson goto out; 844ba2bbfbfSUlf Hansson } 8450aa2a221SRafael J. Wysocki 84635241d12SLina Iyer genpd_lock(genpd); 84786e12eacSUlf Hansson ret = genpd_power_on(genpd, 0); 84835241d12SLina Iyer genpd_unlock(genpd); 849ba2bbfbfSUlf Hansson 850ba2bbfbfSUlf Hansson if (ret) 8513f241775SRafael J. Wysocki return ret; 852c6d22b37SRafael J. Wysocki 853ba2bbfbfSUlf Hansson out: 8542b1d88cdSUlf Hansson /* Measure resume latency. */ 855ab51e6baSAugusto Mecking Caringi time_start = 0; 856ffe12855SUlf Hansson if (timed && runtime_pm) 8572b1d88cdSUlf Hansson time_start = ktime_get(); 8582b1d88cdSUlf Hansson 859076395caSLaurent Pinchart ret = genpd_start_dev(genpd, dev); 860076395caSLaurent Pinchart if (ret) 861076395caSLaurent Pinchart goto err_poweroff; 862076395caSLaurent Pinchart 86354eeddbfSUlf Hansson ret = __genpd_runtime_resume(dev); 864076395caSLaurent Pinchart if (ret) 865076395caSLaurent Pinchart goto err_stop; 8662b1d88cdSUlf Hansson 8672b1d88cdSUlf Hansson /* Update resume latency value if the measured time exceeds it. */ 868ffe12855SUlf Hansson if (timed && runtime_pm) { 8692b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 8702b1d88cdSUlf Hansson if (elapsed_ns > td->resume_latency_ns) { 8712b1d88cdSUlf Hansson td->resume_latency_ns = elapsed_ns; 8722b1d88cdSUlf Hansson dev_dbg(dev, "resume latency exceeded, %lld ns\n", 8732b1d88cdSUlf Hansson elapsed_ns); 8742b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 8752b1d88cdSUlf Hansson td->constraint_changed = true; 8762b1d88cdSUlf Hansson } 8772b1d88cdSUlf Hansson } 87817b75ecaSRafael J. Wysocki 879f721889fSRafael J. Wysocki return 0; 880076395caSLaurent Pinchart 881076395caSLaurent Pinchart err_stop: 882076395caSLaurent Pinchart genpd_stop_dev(genpd, dev); 883076395caSLaurent Pinchart err_poweroff: 884d716f479SLina Iyer if (!pm_runtime_is_irq_safe(dev) || 885d716f479SLina Iyer (pm_runtime_is_irq_safe(dev) && genpd_is_irq_safe(genpd))) { 88635241d12SLina Iyer genpd_lock(genpd); 8872da83545SUlf Hansson genpd_power_off(genpd, true, 0); 88835241d12SLina Iyer genpd_unlock(genpd); 889076395caSLaurent Pinchart } 890076395caSLaurent Pinchart 891076395caSLaurent Pinchart return ret; 892f721889fSRafael J. Wysocki } 893f721889fSRafael J. Wysocki 89439ac5ba5STushar Behera static bool pd_ignore_unused; 89539ac5ba5STushar Behera static int __init pd_ignore_unused_setup(char *__unused) 89639ac5ba5STushar Behera { 89739ac5ba5STushar Behera pd_ignore_unused = true; 89839ac5ba5STushar Behera return 1; 89939ac5ba5STushar Behera } 90039ac5ba5STushar Behera __setup("pd_ignore_unused", pd_ignore_unused_setup); 90139ac5ba5STushar Behera 90217f2ae7fSRafael J. Wysocki /** 90386e12eacSUlf Hansson * genpd_power_off_unused - Power off all PM domains with no devices in use. 90417f2ae7fSRafael J. Wysocki */ 90586e12eacSUlf Hansson static int __init genpd_power_off_unused(void) 90617f2ae7fSRafael J. Wysocki { 90717f2ae7fSRafael J. Wysocki struct generic_pm_domain *genpd; 90817f2ae7fSRafael J. Wysocki 90939ac5ba5STushar Behera if (pd_ignore_unused) { 91039ac5ba5STushar Behera pr_warn("genpd: Not disabling unused power domains\n"); 911bb4b72fcSUlf Hansson return 0; 91239ac5ba5STushar Behera } 91339ac5ba5STushar Behera 91417f2ae7fSRafael J. Wysocki mutex_lock(&gpd_list_lock); 91517f2ae7fSRafael J. Wysocki 91617f2ae7fSRafael J. Wysocki list_for_each_entry(genpd, &gpd_list, gpd_list_node) 91717f2ae7fSRafael J. Wysocki genpd_queue_power_off_work(genpd); 91817f2ae7fSRafael J. Wysocki 91917f2ae7fSRafael J. Wysocki mutex_unlock(&gpd_list_lock); 92017f2ae7fSRafael J. Wysocki 9212fe71dcdSUlf Hansson return 0; 9222fe71dcdSUlf Hansson } 92386e12eacSUlf Hansson late_initcall(genpd_power_off_unused); 9242fe71dcdSUlf Hansson 9250159ec67SJon Hunter #if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_GENERIC_DOMAINS_OF) 926596ba34bSRafael J. Wysocki 9279e9704eaSUlf Hansson static bool genpd_present(const struct generic_pm_domain *genpd) 92877f827deSRafael J. Wysocki { 929895b31f3SGeert Uytterhoeven const struct generic_pm_domain *gpd; 93077f827deSRafael J. Wysocki 93177f827deSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 93277f827deSRafael J. Wysocki return false; 93377f827deSRafael J. Wysocki 93477f827deSRafael J. Wysocki list_for_each_entry(gpd, &gpd_list, gpd_list_node) 93577f827deSRafael J. Wysocki if (gpd == genpd) 93677f827deSRafael J. Wysocki return true; 93777f827deSRafael J. Wysocki 93877f827deSRafael J. Wysocki return false; 93977f827deSRafael J. Wysocki } 94077f827deSRafael J. Wysocki 9410159ec67SJon Hunter #endif 9420159ec67SJon Hunter 9430159ec67SJon Hunter #ifdef CONFIG_PM_SLEEP 9440159ec67SJon Hunter 945596ba34bSRafael J. Wysocki /** 94686e12eacSUlf Hansson * genpd_sync_power_off - Synchronously power off a PM domain and its masters. 947596ba34bSRafael J. Wysocki * @genpd: PM domain to power off, if possible. 9480883ac03SUlf Hansson * @use_lock: use the lock. 9490883ac03SUlf Hansson * @depth: nesting count for lockdep. 950596ba34bSRafael J. Wysocki * 951596ba34bSRafael J. Wysocki * Check if the given PM domain can be powered off (during system suspend or 9525063ce15SRafael J. Wysocki * hibernation) and do that if so. Also, in that case propagate to its masters. 953596ba34bSRafael J. Wysocki * 95477f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 9550883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 9560883ac03SUlf Hansson * these cases the lock must be held. 957596ba34bSRafael J. Wysocki */ 9580883ac03SUlf Hansson static void genpd_sync_power_off(struct generic_pm_domain *genpd, bool use_lock, 9590883ac03SUlf Hansson unsigned int depth) 960596ba34bSRafael J. Wysocki { 9615063ce15SRafael J. Wysocki struct gpd_link *link; 962596ba34bSRafael J. Wysocki 963ffaa42e8SUlf Hansson if (!genpd_status_on(genpd) || genpd_is_always_on(genpd)) 964596ba34bSRafael J. Wysocki return; 965596ba34bSRafael J. Wysocki 966c4bb3160SRafael J. Wysocki if (genpd->suspended_count != genpd->device_count 967c4bb3160SRafael J. Wysocki || atomic_read(&genpd->sd_count) > 0) 968596ba34bSRafael J. Wysocki return; 969596ba34bSRafael J. Wysocki 970fc5cbf0cSAxel Haslam /* Choose the deepest state when suspending */ 971fc5cbf0cSAxel Haslam genpd->state_idx = genpd->state_count - 1; 9721c14967cSUlf Hansson if (_genpd_power_off(genpd, false)) 9731c14967cSUlf Hansson return; 974596ba34bSRafael J. Wysocki 97517b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 9765063ce15SRafael J. Wysocki 9775063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 9785063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 9790883ac03SUlf Hansson 9800883ac03SUlf Hansson if (use_lock) 9810883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 9820883ac03SUlf Hansson 9830883ac03SUlf Hansson genpd_sync_power_off(link->master, use_lock, depth + 1); 9840883ac03SUlf Hansson 9850883ac03SUlf Hansson if (use_lock) 9860883ac03SUlf Hansson genpd_unlock(link->master); 987596ba34bSRafael J. Wysocki } 988596ba34bSRafael J. Wysocki } 989596ba34bSRafael J. Wysocki 990596ba34bSRafael J. Wysocki /** 99186e12eacSUlf Hansson * genpd_sync_power_on - Synchronously power on a PM domain and its masters. 992802d8b49SRafael J. Wysocki * @genpd: PM domain to power on. 9930883ac03SUlf Hansson * @use_lock: use the lock. 9940883ac03SUlf Hansson * @depth: nesting count for lockdep. 995802d8b49SRafael J. Wysocki * 99677f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 9970883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 9980883ac03SUlf Hansson * these cases the lock must be held. 999802d8b49SRafael J. Wysocki */ 10000883ac03SUlf Hansson static void genpd_sync_power_on(struct generic_pm_domain *genpd, bool use_lock, 10010883ac03SUlf Hansson unsigned int depth) 1002802d8b49SRafael J. Wysocki { 1003802d8b49SRafael J. Wysocki struct gpd_link *link; 1004802d8b49SRafael J. Wysocki 100541e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 1006802d8b49SRafael J. Wysocki return; 1007802d8b49SRafael J. Wysocki 1008802d8b49SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 1009802d8b49SRafael J. Wysocki genpd_sd_counter_inc(link->master); 10100883ac03SUlf Hansson 10110883ac03SUlf Hansson if (use_lock) 10120883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 10130883ac03SUlf Hansson 10140883ac03SUlf Hansson genpd_sync_power_on(link->master, use_lock, depth + 1); 10150883ac03SUlf Hansson 10160883ac03SUlf Hansson if (use_lock) 10170883ac03SUlf Hansson genpd_unlock(link->master); 1018802d8b49SRafael J. Wysocki } 1019802d8b49SRafael J. Wysocki 102086e12eacSUlf Hansson _genpd_power_on(genpd, false); 1021802d8b49SRafael J. Wysocki 1022802d8b49SRafael J. Wysocki genpd->status = GPD_STATE_ACTIVE; 1023802d8b49SRafael J. Wysocki } 1024802d8b49SRafael J. Wysocki 1025802d8b49SRafael J. Wysocki /** 10264ecd6e65SRafael J. Wysocki * resume_needed - Check whether to resume a device before system suspend. 10274ecd6e65SRafael J. Wysocki * @dev: Device to check. 10284ecd6e65SRafael J. Wysocki * @genpd: PM domain the device belongs to. 10294ecd6e65SRafael J. Wysocki * 10304ecd6e65SRafael J. Wysocki * There are two cases in which a device that can wake up the system from sleep 10319e9704eaSUlf Hansson * states should be resumed by genpd_prepare(): (1) if the device is enabled 10324ecd6e65SRafael J. Wysocki * to wake up the system and it has to remain active for this purpose while the 10334ecd6e65SRafael J. Wysocki * system is in the sleep state and (2) if the device is not enabled to wake up 10344ecd6e65SRafael J. Wysocki * the system from sleep states and it generally doesn't generate wakeup signals 10354ecd6e65SRafael J. Wysocki * by itself (those signals are generated on its behalf by other parts of the 10364ecd6e65SRafael J. Wysocki * system). In the latter case it may be necessary to reconfigure the device's 10374ecd6e65SRafael J. Wysocki * wakeup settings during system suspend, because it may have been set up to 10384ecd6e65SRafael J. Wysocki * signal remote wakeup from the system's working state as needed by runtime PM. 10394ecd6e65SRafael J. Wysocki * Return 'true' in either of the above cases. 10404ecd6e65SRafael J. Wysocki */ 1041d8600c8bSKrzysztof Kozlowski static bool resume_needed(struct device *dev, 1042d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 10434ecd6e65SRafael J. Wysocki { 10444ecd6e65SRafael J. Wysocki bool active_wakeup; 10454ecd6e65SRafael J. Wysocki 10464ecd6e65SRafael J. Wysocki if (!device_can_wakeup(dev)) 10474ecd6e65SRafael J. Wysocki return false; 10484ecd6e65SRafael J. Wysocki 1049d0af45f1SGeert Uytterhoeven active_wakeup = genpd_is_active_wakeup(genpd); 10504ecd6e65SRafael J. Wysocki return device_may_wakeup(dev) ? active_wakeup : !active_wakeup; 10514ecd6e65SRafael J. Wysocki } 10524ecd6e65SRafael J. Wysocki 10534ecd6e65SRafael J. Wysocki /** 10549e9704eaSUlf Hansson * genpd_prepare - Start power transition of a device in a PM domain. 1055596ba34bSRafael J. Wysocki * @dev: Device to start the transition of. 1056596ba34bSRafael J. Wysocki * 1057596ba34bSRafael J. Wysocki * Start a power transition of a device (during a system-wide power transition) 1058596ba34bSRafael J. Wysocki * under the assumption that its pm_domain field points to the domain member of 1059596ba34bSRafael J. Wysocki * an object of type struct generic_pm_domain representing a PM domain 1060596ba34bSRafael J. Wysocki * consisting of I/O devices. 1061596ba34bSRafael J. Wysocki */ 10629e9704eaSUlf Hansson static int genpd_prepare(struct device *dev) 1063596ba34bSRafael J. Wysocki { 1064596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1065b6c10c84SRafael J. Wysocki int ret; 1066596ba34bSRafael J. Wysocki 1067596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1068596ba34bSRafael J. Wysocki 1069596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1070596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1071596ba34bSRafael J. Wysocki return -EINVAL; 1072596ba34bSRafael J. Wysocki 107317b75ecaSRafael J. Wysocki /* 107417b75ecaSRafael J. Wysocki * If a wakeup request is pending for the device, it should be woken up 107517b75ecaSRafael J. Wysocki * at this point and a system wakeup event should be reported if it's 107617b75ecaSRafael J. Wysocki * set up to wake up the system from sleep states. 107717b75ecaSRafael J. Wysocki */ 10784ecd6e65SRafael J. Wysocki if (resume_needed(dev, genpd)) 10794ecd6e65SRafael J. Wysocki pm_runtime_resume(dev); 10804ecd6e65SRafael J. Wysocki 108135241d12SLina Iyer genpd_lock(genpd); 1082596ba34bSRafael J. Wysocki 108339dd0f23SUlf Hansson if (genpd->prepared_count++ == 0) 108465533bbfSRafael J. Wysocki genpd->suspended_count = 0; 108517b75ecaSRafael J. Wysocki 108635241d12SLina Iyer genpd_unlock(genpd); 1087596ba34bSRafael J. Wysocki 1088b6c10c84SRafael J. Wysocki ret = pm_generic_prepare(dev); 10895241ab40SUlf Hansson if (ret < 0) { 109035241d12SLina Iyer genpd_lock(genpd); 1091b6c10c84SRafael J. Wysocki 109239dd0f23SUlf Hansson genpd->prepared_count--; 1093b6c10c84SRafael J. Wysocki 109435241d12SLina Iyer genpd_unlock(genpd); 1095b6c10c84SRafael J. Wysocki } 109617b75ecaSRafael J. Wysocki 10975241ab40SUlf Hansson /* Never return 1, as genpd don't cope with the direct_complete path. */ 10985241ab40SUlf Hansson return ret >= 0 ? 0 : ret; 1099596ba34bSRafael J. Wysocki } 1100596ba34bSRafael J. Wysocki 1101596ba34bSRafael J. Wysocki /** 110210da6542SMikko Perttunen * genpd_finish_suspend - Completion of suspend or hibernation of device in an 110310da6542SMikko Perttunen * I/O pm domain. 11040496c8aeSRafael J. Wysocki * @dev: Device to suspend. 110510da6542SMikko Perttunen * @poweroff: Specifies if this is a poweroff_noirq or suspend_noirq callback. 11060496c8aeSRafael J. Wysocki * 11070496c8aeSRafael J. Wysocki * Stop the device and remove power from the domain if all devices in it have 11080496c8aeSRafael J. Wysocki * been stopped. 11090496c8aeSRafael J. Wysocki */ 111010da6542SMikko Perttunen static int genpd_finish_suspend(struct device *dev, bool poweroff) 11110496c8aeSRafael J. Wysocki { 11120496c8aeSRafael J. Wysocki struct generic_pm_domain *genpd; 1113a935424bSUlf Hansson int ret = 0; 1114596ba34bSRafael J. Wysocki 11150496c8aeSRafael J. Wysocki genpd = dev_to_genpd(dev); 11160496c8aeSRafael J. Wysocki if (IS_ERR(genpd)) 11170496c8aeSRafael J. Wysocki return -EINVAL; 11180496c8aeSRafael J. Wysocki 111910da6542SMikko Perttunen if (poweroff) 112010da6542SMikko Perttunen ret = pm_generic_poweroff_noirq(dev); 112110da6542SMikko Perttunen else 112210da6542SMikko Perttunen ret = pm_generic_suspend_noirq(dev); 112310da6542SMikko Perttunen if (ret) 112410da6542SMikko Perttunen return ret; 112510da6542SMikko Perttunen 1126a935424bSUlf Hansson if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1127a935424bSUlf Hansson return 0; 1128a935424bSUlf Hansson 112917218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 113017218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 113117218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1132a935424bSUlf Hansson if (ret) { 1133a935424bSUlf Hansson if (poweroff) 1134a935424bSUlf Hansson pm_generic_restore_noirq(dev); 1135a935424bSUlf Hansson else 1136a935424bSUlf Hansson pm_generic_resume_noirq(dev); 1137122a2237SUlf Hansson return ret; 1138122a2237SUlf Hansson } 1139a935424bSUlf Hansson } 1140122a2237SUlf Hansson 11410883ac03SUlf Hansson genpd_lock(genpd); 1142596ba34bSRafael J. Wysocki genpd->suspended_count++; 11430883ac03SUlf Hansson genpd_sync_power_off(genpd, true, 0); 11440883ac03SUlf Hansson genpd_unlock(genpd); 1145596ba34bSRafael J. Wysocki 1146596ba34bSRafael J. Wysocki return 0; 1147596ba34bSRafael J. Wysocki } 1148596ba34bSRafael J. Wysocki 1149596ba34bSRafael J. Wysocki /** 11509e9704eaSUlf Hansson * genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain. 115110da6542SMikko Perttunen * @dev: Device to suspend. 115210da6542SMikko Perttunen * 115310da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 115410da6542SMikko Perttunen * been stopped. 115510da6542SMikko Perttunen */ 11569e9704eaSUlf Hansson static int genpd_suspend_noirq(struct device *dev) 115710da6542SMikko Perttunen { 115810da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 115910da6542SMikko Perttunen 116010da6542SMikko Perttunen return genpd_finish_suspend(dev, false); 116110da6542SMikko Perttunen } 116210da6542SMikko Perttunen 116310da6542SMikko Perttunen /** 11649e9704eaSUlf Hansson * genpd_resume_noirq - Start of resume of device in an I/O PM domain. 1165596ba34bSRafael J. Wysocki * @dev: Device to resume. 1166596ba34bSRafael J. Wysocki * 11670496c8aeSRafael J. Wysocki * Restore power to the device's PM domain, if necessary, and start the device. 1168596ba34bSRafael J. Wysocki */ 11699e9704eaSUlf Hansson static int genpd_resume_noirq(struct device *dev) 1170596ba34bSRafael J. Wysocki { 1171596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1172a935424bSUlf Hansson int ret; 1173596ba34bSRafael J. Wysocki 1174596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1175596ba34bSRafael J. Wysocki 1176596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1177596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1178596ba34bSRafael J. Wysocki return -EINVAL; 1179596ba34bSRafael J. Wysocki 1180d0af45f1SGeert Uytterhoeven if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1181a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1182596ba34bSRafael J. Wysocki 11830883ac03SUlf Hansson genpd_lock(genpd); 11840883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 1185596ba34bSRafael J. Wysocki genpd->suspended_count--; 11860883ac03SUlf Hansson genpd_unlock(genpd); 1187596ba34bSRafael J. Wysocki 118817218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 118917218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 119017218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 119110da6542SMikko Perttunen if (ret) 119210da6542SMikko Perttunen return ret; 1193a935424bSUlf Hansson } 119410da6542SMikko Perttunen 1195a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1196596ba34bSRafael J. Wysocki } 1197596ba34bSRafael J. Wysocki 1198596ba34bSRafael J. Wysocki /** 11999e9704eaSUlf Hansson * genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain. 1200596ba34bSRafael J. Wysocki * @dev: Device to freeze. 1201596ba34bSRafael J. Wysocki * 1202596ba34bSRafael J. Wysocki * Carry out a late freeze of a device under the assumption that its 1203596ba34bSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 1204596ba34bSRafael J. Wysocki * struct generic_pm_domain representing a power domain consisting of I/O 1205596ba34bSRafael J. Wysocki * devices. 1206596ba34bSRafael J. Wysocki */ 12079e9704eaSUlf Hansson static int genpd_freeze_noirq(struct device *dev) 1208596ba34bSRafael J. Wysocki { 1209d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1210122a2237SUlf Hansson int ret = 0; 1211596ba34bSRafael J. Wysocki 1212596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1213596ba34bSRafael J. Wysocki 1214596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1215596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1216596ba34bSRafael J. Wysocki return -EINVAL; 1217596ba34bSRafael J. Wysocki 121810da6542SMikko Perttunen ret = pm_generic_freeze_noirq(dev); 121910da6542SMikko Perttunen if (ret) 122010da6542SMikko Perttunen return ret; 122110da6542SMikko Perttunen 122217218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 122317218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) 122417218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1225122a2237SUlf Hansson 1226122a2237SUlf Hansson return ret; 1227596ba34bSRafael J. Wysocki } 1228596ba34bSRafael J. Wysocki 1229596ba34bSRafael J. Wysocki /** 12309e9704eaSUlf Hansson * genpd_thaw_noirq - Early thaw of device in an I/O PM domain. 1231596ba34bSRafael J. Wysocki * @dev: Device to thaw. 1232596ba34bSRafael J. Wysocki * 12330496c8aeSRafael J. Wysocki * Start the device, unless power has been removed from the domain already 12340496c8aeSRafael J. Wysocki * before the system transition. 1235596ba34bSRafael J. Wysocki */ 12369e9704eaSUlf Hansson static int genpd_thaw_noirq(struct device *dev) 1237596ba34bSRafael J. Wysocki { 1238d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1239122a2237SUlf Hansson int ret = 0; 1240596ba34bSRafael J. Wysocki 1241596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1242596ba34bSRafael J. Wysocki 1243596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1244596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1245596ba34bSRafael J. Wysocki return -EINVAL; 1246596ba34bSRafael J. Wysocki 124717218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 124817218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 124917218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 125010da6542SMikko Perttunen if (ret) 1251122a2237SUlf Hansson return ret; 12520496c8aeSRafael J. Wysocki } 1253596ba34bSRafael J. Wysocki 125410da6542SMikko Perttunen return pm_generic_thaw_noirq(dev); 125510da6542SMikko Perttunen } 125610da6542SMikko Perttunen 125710da6542SMikko Perttunen /** 12589e9704eaSUlf Hansson * genpd_poweroff_noirq - Completion of hibernation of device in an 125910da6542SMikko Perttunen * I/O PM domain. 126010da6542SMikko Perttunen * @dev: Device to poweroff. 126110da6542SMikko Perttunen * 126210da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 126310da6542SMikko Perttunen * been stopped. 126410da6542SMikko Perttunen */ 12659e9704eaSUlf Hansson static int genpd_poweroff_noirq(struct device *dev) 126610da6542SMikko Perttunen { 126710da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 126810da6542SMikko Perttunen 126910da6542SMikko Perttunen return genpd_finish_suspend(dev, true); 127010da6542SMikko Perttunen } 127110da6542SMikko Perttunen 12720496c8aeSRafael J. Wysocki /** 12739e9704eaSUlf Hansson * genpd_restore_noirq - Start of restore of device in an I/O PM domain. 1274596ba34bSRafael J. Wysocki * @dev: Device to resume. 1275596ba34bSRafael J. Wysocki * 12760496c8aeSRafael J. Wysocki * Make sure the domain will be in the same power state as before the 12770496c8aeSRafael J. Wysocki * hibernation the system is resuming from and start the device if necessary. 1278596ba34bSRafael J. Wysocki */ 12799e9704eaSUlf Hansson static int genpd_restore_noirq(struct device *dev) 1280596ba34bSRafael J. Wysocki { 1281596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1282122a2237SUlf Hansson int ret = 0; 1283596ba34bSRafael J. Wysocki 1284596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1285596ba34bSRafael J. Wysocki 1286596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1287596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1288596ba34bSRafael J. Wysocki return -EINVAL; 1289596ba34bSRafael J. Wysocki 1290596ba34bSRafael J. Wysocki /* 129165533bbfSRafael J. Wysocki * At this point suspended_count == 0 means we are being run for the 129265533bbfSRafael J. Wysocki * first time for the given domain in the present cycle. 129365533bbfSRafael J. Wysocki */ 12940883ac03SUlf Hansson genpd_lock(genpd); 129539dd0f23SUlf Hansson if (genpd->suspended_count++ == 0) 129665533bbfSRafael J. Wysocki /* 129765533bbfSRafael J. Wysocki * The boot kernel might put the domain into arbitrary state, 129886e12eacSUlf Hansson * so make it appear as powered off to genpd_sync_power_on(), 1299802d8b49SRafael J. Wysocki * so that it tries to power it on in case it was really off. 1300596ba34bSRafael J. Wysocki */ 130117b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 130218dd2eceSRafael J. Wysocki 13030883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 13040883ac03SUlf Hansson genpd_unlock(genpd); 1305596ba34bSRafael J. Wysocki 130617218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 130717218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 130817218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 130910da6542SMikko Perttunen if (ret) 1310122a2237SUlf Hansson return ret; 1311596ba34bSRafael J. Wysocki } 1312596ba34bSRafael J. Wysocki 131310da6542SMikko Perttunen return pm_generic_restore_noirq(dev); 131410da6542SMikko Perttunen } 131510da6542SMikko Perttunen 1316596ba34bSRafael J. Wysocki /** 13179e9704eaSUlf Hansson * genpd_complete - Complete power transition of a device in a power domain. 1318596ba34bSRafael J. Wysocki * @dev: Device to complete the transition of. 1319596ba34bSRafael J. Wysocki * 1320596ba34bSRafael J. Wysocki * Complete a power transition of a device (during a system-wide power 1321596ba34bSRafael J. Wysocki * transition) under the assumption that its pm_domain field points to the 1322596ba34bSRafael J. Wysocki * domain member of an object of type struct generic_pm_domain representing 1323596ba34bSRafael J. Wysocki * a power domain consisting of I/O devices. 1324596ba34bSRafael J. Wysocki */ 13259e9704eaSUlf Hansson static void genpd_complete(struct device *dev) 1326596ba34bSRafael J. Wysocki { 1327596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1328596ba34bSRafael J. Wysocki 1329596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1330596ba34bSRafael J. Wysocki 1331596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1332596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1333596ba34bSRafael J. Wysocki return; 1334596ba34bSRafael J. Wysocki 13354d23a5e8SUlf Hansson pm_generic_complete(dev); 13364d23a5e8SUlf Hansson 133735241d12SLina Iyer genpd_lock(genpd); 1338596ba34bSRafael J. Wysocki 133939dd0f23SUlf Hansson genpd->prepared_count--; 13404d23a5e8SUlf Hansson if (!genpd->prepared_count) 13414d23a5e8SUlf Hansson genpd_queue_power_off_work(genpd); 1342596ba34bSRafael J. Wysocki 134335241d12SLina Iyer genpd_unlock(genpd); 1344596ba34bSRafael J. Wysocki } 1345596ba34bSRafael J. Wysocki 134677f827deSRafael J. Wysocki /** 1347d47e6464SUlf Hansson * genpd_syscore_switch - Switch power during system core suspend or resume. 134877f827deSRafael J. Wysocki * @dev: Device that normally is marked as "always on" to switch power for. 134977f827deSRafael J. Wysocki * 135077f827deSRafael J. Wysocki * This routine may only be called during the system core (syscore) suspend or 135177f827deSRafael J. Wysocki * resume phase for devices whose "always on" flags are set. 135277f827deSRafael J. Wysocki */ 1353d47e6464SUlf Hansson static void genpd_syscore_switch(struct device *dev, bool suspend) 135477f827deSRafael J. Wysocki { 135577f827deSRafael J. Wysocki struct generic_pm_domain *genpd; 135677f827deSRafael J. Wysocki 135723c6d2c7SRafael J. Wysocki genpd = dev_to_genpd(dev); 13589e9704eaSUlf Hansson if (!genpd_present(genpd)) 135977f827deSRafael J. Wysocki return; 136077f827deSRafael J. Wysocki 136177f827deSRafael J. Wysocki if (suspend) { 136277f827deSRafael J. Wysocki genpd->suspended_count++; 13630883ac03SUlf Hansson genpd_sync_power_off(genpd, false, 0); 136477f827deSRafael J. Wysocki } else { 13650883ac03SUlf Hansson genpd_sync_power_on(genpd, false, 0); 136677f827deSRafael J. Wysocki genpd->suspended_count--; 136777f827deSRafael J. Wysocki } 136877f827deSRafael J. Wysocki } 1369d47e6464SUlf Hansson 1370d47e6464SUlf Hansson void pm_genpd_syscore_poweroff(struct device *dev) 1371d47e6464SUlf Hansson { 1372d47e6464SUlf Hansson genpd_syscore_switch(dev, true); 1373d47e6464SUlf Hansson } 1374d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff); 1375d47e6464SUlf Hansson 1376d47e6464SUlf Hansson void pm_genpd_syscore_poweron(struct device *dev) 1377d47e6464SUlf Hansson { 1378d47e6464SUlf Hansson genpd_syscore_switch(dev, false); 1379d47e6464SUlf Hansson } 1380d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron); 138177f827deSRafael J. Wysocki 1382d30d819dSRafael J. Wysocki #else /* !CONFIG_PM_SLEEP */ 1383596ba34bSRafael J. Wysocki 13849e9704eaSUlf Hansson #define genpd_prepare NULL 13859e9704eaSUlf Hansson #define genpd_suspend_noirq NULL 13869e9704eaSUlf Hansson #define genpd_resume_noirq NULL 13879e9704eaSUlf Hansson #define genpd_freeze_noirq NULL 13889e9704eaSUlf Hansson #define genpd_thaw_noirq NULL 13899e9704eaSUlf Hansson #define genpd_poweroff_noirq NULL 13909e9704eaSUlf Hansson #define genpd_restore_noirq NULL 13919e9704eaSUlf Hansson #define genpd_complete NULL 1392596ba34bSRafael J. Wysocki 1393596ba34bSRafael J. Wysocki #endif /* CONFIG_PM_SLEEP */ 1394596ba34bSRafael J. Wysocki 1395a174920dSUlf Hansson static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev) 13961d5fcfecSRafael J. Wysocki { 13971d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 13983e235685SUlf Hansson int ret; 13993e235685SUlf Hansson 14003e235685SUlf Hansson ret = dev_pm_get_subsys_data(dev); 14013e235685SUlf Hansson if (ret) 14023e235685SUlf Hansson return ERR_PTR(ret); 14031d5fcfecSRafael J. Wysocki 14041d5fcfecSRafael J. Wysocki gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL); 14053e235685SUlf Hansson if (!gpd_data) { 14063e235685SUlf Hansson ret = -ENOMEM; 14073e235685SUlf Hansson goto err_put; 14083e235685SUlf Hansson } 14091d5fcfecSRafael J. Wysocki 1410f104e1e5SUlf Hansson gpd_data->base.dev = dev; 1411f104e1e5SUlf Hansson gpd_data->td.constraint_changed = true; 14120759e80bSRafael J. Wysocki gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS; 1413f104e1e5SUlf Hansson gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier; 1414f104e1e5SUlf Hansson 1415f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1416f104e1e5SUlf Hansson 1417f104e1e5SUlf Hansson if (dev->power.subsys_data->domain_data) { 1418f104e1e5SUlf Hansson ret = -EINVAL; 1419f104e1e5SUlf Hansson goto err_free; 1420f104e1e5SUlf Hansson } 1421f104e1e5SUlf Hansson 1422f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = &gpd_data->base; 1423f104e1e5SUlf Hansson 1424f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1425f104e1e5SUlf Hansson 14261d5fcfecSRafael J. Wysocki return gpd_data; 14273e235685SUlf Hansson 1428f104e1e5SUlf Hansson err_free: 1429f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1430f104e1e5SUlf Hansson kfree(gpd_data); 14313e235685SUlf Hansson err_put: 14323e235685SUlf Hansson dev_pm_put_subsys_data(dev); 14333e235685SUlf Hansson return ERR_PTR(ret); 14341d5fcfecSRafael J. Wysocki } 14351d5fcfecSRafael J. Wysocki 143649d400c7SUlf Hansson static void genpd_free_dev_data(struct device *dev, 14371d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data) 14381d5fcfecSRafael J. Wysocki { 1439f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1440f104e1e5SUlf Hansson 1441f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = NULL; 1442f104e1e5SUlf Hansson 1443f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1444f104e1e5SUlf Hansson 14451d5fcfecSRafael J. Wysocki kfree(gpd_data); 14463e235685SUlf Hansson dev_pm_put_subsys_data(dev); 14471d5fcfecSRafael J. Wysocki } 14481d5fcfecSRafael J. Wysocki 1449b24e1965SUlf Hansson static void genpd_update_cpumask(struct generic_pm_domain *genpd, 1450eb594b73SUlf Hansson int cpu, bool set, unsigned int depth) 1451eb594b73SUlf Hansson { 1452eb594b73SUlf Hansson struct gpd_link *link; 1453eb594b73SUlf Hansson 1454eb594b73SUlf Hansson if (!genpd_is_cpu_domain(genpd)) 1455eb594b73SUlf Hansson return; 1456eb594b73SUlf Hansson 1457eb594b73SUlf Hansson list_for_each_entry(link, &genpd->slave_links, slave_node) { 1458eb594b73SUlf Hansson struct generic_pm_domain *master = link->master; 1459eb594b73SUlf Hansson 1460eb594b73SUlf Hansson genpd_lock_nested(master, depth + 1); 1461b24e1965SUlf Hansson genpd_update_cpumask(master, cpu, set, depth + 1); 1462eb594b73SUlf Hansson genpd_unlock(master); 1463eb594b73SUlf Hansson } 1464eb594b73SUlf Hansson 1465eb594b73SUlf Hansson if (set) 1466eb594b73SUlf Hansson cpumask_set_cpu(cpu, genpd->cpus); 1467eb594b73SUlf Hansson else 1468eb594b73SUlf Hansson cpumask_clear_cpu(cpu, genpd->cpus); 1469eb594b73SUlf Hansson } 1470eb594b73SUlf Hansson 1471b24e1965SUlf Hansson static void genpd_set_cpumask(struct generic_pm_domain *genpd, int cpu) 1472b24e1965SUlf Hansson { 1473b24e1965SUlf Hansson if (cpu >= 0) 1474b24e1965SUlf Hansson genpd_update_cpumask(genpd, cpu, true, 0); 1475b24e1965SUlf Hansson } 1476b24e1965SUlf Hansson 1477b24e1965SUlf Hansson static void genpd_clear_cpumask(struct generic_pm_domain *genpd, int cpu) 1478b24e1965SUlf Hansson { 1479b24e1965SUlf Hansson if (cpu >= 0) 1480b24e1965SUlf Hansson genpd_update_cpumask(genpd, cpu, false, 0); 1481b24e1965SUlf Hansson } 1482b24e1965SUlf Hansson 1483b24e1965SUlf Hansson static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev) 1484eb594b73SUlf Hansson { 1485eb594b73SUlf Hansson int cpu; 1486eb594b73SUlf Hansson 1487eb594b73SUlf Hansson if (!genpd_is_cpu_domain(genpd)) 1488b24e1965SUlf Hansson return -1; 1489eb594b73SUlf Hansson 1490eb594b73SUlf Hansson for_each_possible_cpu(cpu) { 1491b24e1965SUlf Hansson if (get_cpu_device(cpu) == dev) 1492b24e1965SUlf Hansson return cpu; 1493eb594b73SUlf Hansson } 1494eb594b73SUlf Hansson 1495b24e1965SUlf Hansson return -1; 1496eb594b73SUlf Hansson } 1497eb594b73SUlf Hansson 1498f9ccd7c3SUlf Hansson static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev, 1499f9ccd7c3SUlf Hansson struct device *base_dev) 1500f721889fSRafael J. Wysocki { 1501c0356db7SUlf Hansson struct generic_pm_domain_data *gpd_data; 1502f9ccd7c3SUlf Hansson int ret; 1503f721889fSRafael J. Wysocki 1504f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1505f721889fSRafael J. Wysocki 1506f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) 1507f721889fSRafael J. Wysocki return -EINVAL; 1508f721889fSRafael J. Wysocki 1509a174920dSUlf Hansson gpd_data = genpd_alloc_dev_data(dev); 15103e235685SUlf Hansson if (IS_ERR(gpd_data)) 15113e235685SUlf Hansson return PTR_ERR(gpd_data); 15126ff7bb0dSRafael J. Wysocki 1513f9ccd7c3SUlf Hansson gpd_data->cpu = genpd_get_cpu(genpd, base_dev); 1514b24e1965SUlf Hansson 1515b472c2faSUlf Hansson ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0; 1516b472c2faSUlf Hansson if (ret) 1517b472c2faSUlf Hansson goto out; 1518d79b6fe1SGeert Uytterhoeven 15192071ac98SJiada Wang genpd_lock(genpd); 15202071ac98SJiada Wang 1521f9ccd7c3SUlf Hansson genpd_set_cpumask(genpd, gpd_data->cpu); 1522975e83cfSSudeep Holla dev_pm_domain_set(dev, &genpd->domain); 1523975e83cfSSudeep Holla 152414b53064SUlf Hansson genpd->device_count++; 152514b53064SUlf Hansson genpd->max_off_time_changed = true; 152614b53064SUlf Hansson 15271d5fcfecSRafael J. Wysocki list_add_tail(&gpd_data->base.list_node, &genpd->dev_list); 15286ff7bb0dSRafael J. Wysocki 152935241d12SLina Iyer genpd_unlock(genpd); 15302071ac98SJiada Wang out: 1531c0356db7SUlf Hansson if (ret) 1532c0356db7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 1533c0356db7SUlf Hansson else 15340b07ee94SViresh Kumar dev_pm_qos_add_notifier(dev, &gpd_data->nb, 15350b07ee94SViresh Kumar DEV_PM_QOS_RESUME_LATENCY); 15361d5fcfecSRafael J. Wysocki 1537f721889fSRafael J. Wysocki return ret; 1538f721889fSRafael J. Wysocki } 153919efa5ffSJon Hunter 154019efa5ffSJon Hunter /** 15411a7a6707SUlf Hansson * pm_genpd_add_device - Add a device to an I/O PM domain. 154219efa5ffSJon Hunter * @genpd: PM domain to add the device to. 154319efa5ffSJon Hunter * @dev: Device to be added. 154419efa5ffSJon Hunter */ 15451a7a6707SUlf Hansson int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev) 154619efa5ffSJon Hunter { 154719efa5ffSJon Hunter int ret; 154819efa5ffSJon Hunter 154919efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 1550f9ccd7c3SUlf Hansson ret = genpd_add_device(genpd, dev, dev); 155119efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 155219efa5ffSJon Hunter 155319efa5ffSJon Hunter return ret; 155419efa5ffSJon Hunter } 15551a7a6707SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_add_device); 1556f721889fSRafael J. Wysocki 155785168d56SUlf Hansson static int genpd_remove_device(struct generic_pm_domain *genpd, 1558f721889fSRafael J. Wysocki struct device *dev) 1559f721889fSRafael J. Wysocki { 15606ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 15614605ab65SRafael J. Wysocki struct pm_domain_data *pdd; 1562f9ccd7c3SUlf Hansson int ret = 0; 1563f721889fSRafael J. Wysocki 1564f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1565f721889fSRafael J. Wysocki 1566c0356db7SUlf Hansson pdd = dev->power.subsys_data->domain_data; 1567c0356db7SUlf Hansson gpd_data = to_gpd_data(pdd); 15680b07ee94SViresh Kumar dev_pm_qos_remove_notifier(dev, &gpd_data->nb, 15690b07ee94SViresh Kumar DEV_PM_QOS_RESUME_LATENCY); 1570c0356db7SUlf Hansson 157135241d12SLina Iyer genpd_lock(genpd); 1572f721889fSRafael J. Wysocki 1573596ba34bSRafael J. Wysocki if (genpd->prepared_count > 0) { 1574596ba34bSRafael J. Wysocki ret = -EAGAIN; 1575596ba34bSRafael J. Wysocki goto out; 1576596ba34bSRafael J. Wysocki } 1577596ba34bSRafael J. Wysocki 15786ff7bb0dSRafael J. Wysocki genpd->device_count--; 15796ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 15806ff7bb0dSRafael J. Wysocki 1581f9ccd7c3SUlf Hansson genpd_clear_cpumask(genpd, gpd_data->cpu); 1582975e83cfSSudeep Holla dev_pm_domain_set(dev, NULL); 1583975e83cfSSudeep Holla 1584efa69025SRafael J. Wysocki list_del_init(&pdd->list_node); 15856ff7bb0dSRafael J. Wysocki 158635241d12SLina Iyer genpd_unlock(genpd); 15876ff7bb0dSRafael J. Wysocki 15882071ac98SJiada Wang if (genpd->detach_dev) 15892071ac98SJiada Wang genpd->detach_dev(genpd, dev); 15902071ac98SJiada Wang 159149d400c7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 15921d5fcfecSRafael J. Wysocki 15936ff7bb0dSRafael J. Wysocki return 0; 1594f721889fSRafael J. Wysocki 1595596ba34bSRafael J. Wysocki out: 159635241d12SLina Iyer genpd_unlock(genpd); 15970b07ee94SViresh Kumar dev_pm_qos_add_notifier(dev, &gpd_data->nb, DEV_PM_QOS_RESUME_LATENCY); 1598f721889fSRafael J. Wysocki 1599f721889fSRafael J. Wysocki return ret; 1600f721889fSRafael J. Wysocki } 160185168d56SUlf Hansson 160285168d56SUlf Hansson /** 160385168d56SUlf Hansson * pm_genpd_remove_device - Remove a device from an I/O PM domain. 160485168d56SUlf Hansson * @dev: Device to be removed. 160585168d56SUlf Hansson */ 1606924f4486SUlf Hansson int pm_genpd_remove_device(struct device *dev) 160785168d56SUlf Hansson { 1608b3ad17c0SUlf Hansson struct generic_pm_domain *genpd = dev_to_genpd_safe(dev); 1609924f4486SUlf Hansson 1610924f4486SUlf Hansson if (!genpd) 161185168d56SUlf Hansson return -EINVAL; 161285168d56SUlf Hansson 161385168d56SUlf Hansson return genpd_remove_device(genpd, dev); 161485168d56SUlf Hansson } 161524c96dc7SMaruthi Bayyavarapu EXPORT_SYMBOL_GPL(pm_genpd_remove_device); 1616f721889fSRafael J. Wysocki 161719efa5ffSJon Hunter static int genpd_add_subdomain(struct generic_pm_domain *genpd, 1618bc0403ffSRafael J. Wysocki struct generic_pm_domain *subdomain) 1619f721889fSRafael J. Wysocki { 16202547923dSLina Iyer struct gpd_link *link, *itr; 1621f721889fSRafael J. Wysocki int ret = 0; 1622f721889fSRafael J. Wysocki 1623fb7268beSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain) 1624fb7268beSRafael J. Wysocki || genpd == subdomain) 1625f721889fSRafael J. Wysocki return -EINVAL; 1626f721889fSRafael J. Wysocki 1627d716f479SLina Iyer /* 1628d716f479SLina Iyer * If the domain can be powered on/off in an IRQ safe 1629d716f479SLina Iyer * context, ensure that the subdomain can also be 1630d716f479SLina Iyer * powered on/off in that context. 1631d716f479SLina Iyer */ 1632d716f479SLina Iyer if (!genpd_is_irq_safe(genpd) && genpd_is_irq_safe(subdomain)) { 163344cae7d5SDan Carpenter WARN(1, "Parent %s of subdomain %s must be IRQ safe\n", 1634d716f479SLina Iyer genpd->name, subdomain->name); 1635d716f479SLina Iyer return -EINVAL; 1636d716f479SLina Iyer } 1637d716f479SLina Iyer 16382547923dSLina Iyer link = kzalloc(sizeof(*link), GFP_KERNEL); 16392547923dSLina Iyer if (!link) 16402547923dSLina Iyer return -ENOMEM; 16412547923dSLina Iyer 164235241d12SLina Iyer genpd_lock(subdomain); 164335241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1644f721889fSRafael J. Wysocki 164541e2c8e0SUlf Hansson if (!genpd_status_on(genpd) && genpd_status_on(subdomain)) { 1646f721889fSRafael J. Wysocki ret = -EINVAL; 1647f721889fSRafael J. Wysocki goto out; 1648f721889fSRafael J. Wysocki } 1649f721889fSRafael J. Wysocki 16502547923dSLina Iyer list_for_each_entry(itr, &genpd->master_links, master_node) { 16512547923dSLina Iyer if (itr->slave == subdomain && itr->master == genpd) { 1652f721889fSRafael J. Wysocki ret = -EINVAL; 1653f721889fSRafael J. Wysocki goto out; 1654f721889fSRafael J. Wysocki } 1655f721889fSRafael J. Wysocki } 1656f721889fSRafael J. Wysocki 16575063ce15SRafael J. Wysocki link->master = genpd; 16585063ce15SRafael J. Wysocki list_add_tail(&link->master_node, &genpd->master_links); 1659bc0403ffSRafael J. Wysocki link->slave = subdomain; 1660bc0403ffSRafael J. Wysocki list_add_tail(&link->slave_node, &subdomain->slave_links); 166141e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1662c4bb3160SRafael J. Wysocki genpd_sd_counter_inc(genpd); 1663f721889fSRafael J. Wysocki 1664f721889fSRafael J. Wysocki out: 166535241d12SLina Iyer genpd_unlock(genpd); 166635241d12SLina Iyer genpd_unlock(subdomain); 16672547923dSLina Iyer if (ret) 16682547923dSLina Iyer kfree(link); 1669f721889fSRafael J. Wysocki return ret; 1670f721889fSRafael J. Wysocki } 167119efa5ffSJon Hunter 167219efa5ffSJon Hunter /** 167319efa5ffSJon Hunter * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 167419efa5ffSJon Hunter * @genpd: Master PM domain to add the subdomain to. 167519efa5ffSJon Hunter * @subdomain: Subdomain to be added. 167619efa5ffSJon Hunter */ 167719efa5ffSJon Hunter int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, 167819efa5ffSJon Hunter struct generic_pm_domain *subdomain) 167919efa5ffSJon Hunter { 168019efa5ffSJon Hunter int ret; 168119efa5ffSJon Hunter 168219efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 168319efa5ffSJon Hunter ret = genpd_add_subdomain(genpd, subdomain); 168419efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 168519efa5ffSJon Hunter 168619efa5ffSJon Hunter return ret; 168719efa5ffSJon Hunter } 1688d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_add_subdomain); 1689f721889fSRafael J. Wysocki 1690f721889fSRafael J. Wysocki /** 1691f721889fSRafael J. Wysocki * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain. 1692f721889fSRafael J. Wysocki * @genpd: Master PM domain to remove the subdomain from. 16935063ce15SRafael J. Wysocki * @subdomain: Subdomain to be removed. 1694f721889fSRafael J. Wysocki */ 1695f721889fSRafael J. Wysocki int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, 16965063ce15SRafael J. Wysocki struct generic_pm_domain *subdomain) 1697f721889fSRafael J. Wysocki { 1698c6e83cacSKrzysztof Kozlowski struct gpd_link *l, *link; 1699f721889fSRafael J. Wysocki int ret = -EINVAL; 1700f721889fSRafael J. Wysocki 17015063ce15SRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)) 1702f721889fSRafael J. Wysocki return -EINVAL; 1703f721889fSRafael J. Wysocki 170435241d12SLina Iyer genpd_lock(subdomain); 170535241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1706f721889fSRafael J. Wysocki 1707beda5fc1SJon Hunter if (!list_empty(&subdomain->master_links) || subdomain->device_count) { 17087a5bd127SJoe Perches pr_warn("%s: unable to remove subdomain %s\n", 17097a5bd127SJoe Perches genpd->name, subdomain->name); 171030e7a65bSJon Hunter ret = -EBUSY; 171130e7a65bSJon Hunter goto out; 171230e7a65bSJon Hunter } 171330e7a65bSJon Hunter 1714c6e83cacSKrzysztof Kozlowski list_for_each_entry_safe(link, l, &genpd->master_links, master_node) { 17155063ce15SRafael J. Wysocki if (link->slave != subdomain) 1716f721889fSRafael J. Wysocki continue; 1717f721889fSRafael J. Wysocki 17185063ce15SRafael J. Wysocki list_del(&link->master_node); 17195063ce15SRafael J. Wysocki list_del(&link->slave_node); 17205063ce15SRafael J. Wysocki kfree(link); 172141e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1722f721889fSRafael J. Wysocki genpd_sd_counter_dec(genpd); 1723f721889fSRafael J. Wysocki 1724f721889fSRafael J. Wysocki ret = 0; 1725f721889fSRafael J. Wysocki break; 1726f721889fSRafael J. Wysocki } 1727f721889fSRafael J. Wysocki 172830e7a65bSJon Hunter out: 172935241d12SLina Iyer genpd_unlock(genpd); 173035241d12SLina Iyer genpd_unlock(subdomain); 1731f721889fSRafael J. Wysocki 1732f721889fSRafael J. Wysocki return ret; 1733f721889fSRafael J. Wysocki } 1734d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_remove_subdomain); 1735f721889fSRafael J. Wysocki 173649a27e27SUlf Hansson static void genpd_free_default_power_state(struct genpd_power_state *states, 173749a27e27SUlf Hansson unsigned int state_count) 173849a27e27SUlf Hansson { 173949a27e27SUlf Hansson kfree(states); 174049a27e27SUlf Hansson } 174149a27e27SUlf Hansson 174259d65b73SLina Iyer static int genpd_set_default_power_state(struct generic_pm_domain *genpd) 174359d65b73SLina Iyer { 174459d65b73SLina Iyer struct genpd_power_state *state; 174559d65b73SLina Iyer 174659d65b73SLina Iyer state = kzalloc(sizeof(*state), GFP_KERNEL); 174759d65b73SLina Iyer if (!state) 174859d65b73SLina Iyer return -ENOMEM; 174959d65b73SLina Iyer 175059d65b73SLina Iyer genpd->states = state; 175159d65b73SLina Iyer genpd->state_count = 1; 175249a27e27SUlf Hansson genpd->free_states = genpd_free_default_power_state; 175359d65b73SLina Iyer 175459d65b73SLina Iyer return 0; 175559d65b73SLina Iyer } 175659d65b73SLina Iyer 1757d716f479SLina Iyer static void genpd_lock_init(struct generic_pm_domain *genpd) 1758d716f479SLina Iyer { 1759d716f479SLina Iyer if (genpd->flags & GENPD_FLAG_IRQ_SAFE) { 1760d716f479SLina Iyer spin_lock_init(&genpd->slock); 1761d716f479SLina Iyer genpd->lock_ops = &genpd_spin_ops; 1762d716f479SLina Iyer } else { 1763d716f479SLina Iyer mutex_init(&genpd->mlock); 1764d716f479SLina Iyer genpd->lock_ops = &genpd_mtx_ops; 1765d716f479SLina Iyer } 1766d716f479SLina Iyer } 1767d716f479SLina Iyer 1768d23b9b00SRafael J. Wysocki /** 1769f721889fSRafael J. Wysocki * pm_genpd_init - Initialize a generic I/O PM domain object. 1770f721889fSRafael J. Wysocki * @genpd: PM domain object to initialize. 1771f721889fSRafael J. Wysocki * @gov: PM domain governor to associate with the domain (may be NULL). 1772f721889fSRafael J. Wysocki * @is_off: Initial value of the domain's power_is_off field. 17737eb231c3SUlf Hansson * 17747eb231c3SUlf Hansson * Returns 0 on successful initialization, else a negative error code. 1775f721889fSRafael J. Wysocki */ 17767eb231c3SUlf Hansson int pm_genpd_init(struct generic_pm_domain *genpd, 1777f721889fSRafael J. Wysocki struct dev_power_governor *gov, bool is_off) 1778f721889fSRafael J. Wysocki { 177959d65b73SLina Iyer int ret; 178059d65b73SLina Iyer 1781f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 17827eb231c3SUlf Hansson return -EINVAL; 1783f721889fSRafael J. Wysocki 17845063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->master_links); 17855063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->slave_links); 1786f721889fSRafael J. Wysocki INIT_LIST_HEAD(&genpd->dev_list); 1787d716f479SLina Iyer genpd_lock_init(genpd); 1788f721889fSRafael J. Wysocki genpd->gov = gov; 1789f721889fSRafael J. Wysocki INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn); 1790c4bb3160SRafael J. Wysocki atomic_set(&genpd->sd_count, 0); 179117b75ecaSRafael J. Wysocki genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE; 1792596ba34bSRafael J. Wysocki genpd->device_count = 0; 1793221e9b58SRafael J. Wysocki genpd->max_off_time_ns = -1; 17946ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 1795de0aa06dSJon Hunter genpd->provider = NULL; 1796de0aa06dSJon Hunter genpd->has_provider = false; 1797afece3abSThara Gopinath genpd->accounting_time = ktime_get(); 1798795bd2e7SUlf Hansson genpd->domain.ops.runtime_suspend = genpd_runtime_suspend; 1799795bd2e7SUlf Hansson genpd->domain.ops.runtime_resume = genpd_runtime_resume; 18009e9704eaSUlf Hansson genpd->domain.ops.prepare = genpd_prepare; 18019e9704eaSUlf Hansson genpd->domain.ops.suspend_noirq = genpd_suspend_noirq; 18029e9704eaSUlf Hansson genpd->domain.ops.resume_noirq = genpd_resume_noirq; 18039e9704eaSUlf Hansson genpd->domain.ops.freeze_noirq = genpd_freeze_noirq; 18049e9704eaSUlf Hansson genpd->domain.ops.thaw_noirq = genpd_thaw_noirq; 18059e9704eaSUlf Hansson genpd->domain.ops.poweroff_noirq = genpd_poweroff_noirq; 18069e9704eaSUlf Hansson genpd->domain.ops.restore_noirq = genpd_restore_noirq; 18079e9704eaSUlf Hansson genpd->domain.ops.complete = genpd_complete; 1808c11f6f5bSUlf Hansson 1809c11f6f5bSUlf Hansson if (genpd->flags & GENPD_FLAG_PM_CLK) { 1810c11f6f5bSUlf Hansson genpd->dev_ops.stop = pm_clk_suspend; 1811c11f6f5bSUlf Hansson genpd->dev_ops.start = pm_clk_resume; 1812c11f6f5bSUlf Hansson } 1813c11f6f5bSUlf Hansson 1814ffaa42e8SUlf Hansson /* Always-on domains must be powered on at initialization. */ 1815ed61e18aSLeonard Crestez if ((genpd_is_always_on(genpd) || genpd_is_rpm_always_on(genpd)) && 1816ed61e18aSLeonard Crestez !genpd_status_on(genpd)) 1817ffaa42e8SUlf Hansson return -EINVAL; 1818ffaa42e8SUlf Hansson 1819eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd) && 1820eb594b73SUlf Hansson !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL)) 1821eb594b73SUlf Hansson return -ENOMEM; 1822eb594b73SUlf Hansson 1823fc5cbf0cSAxel Haslam /* Use only one "off" state if there were no states declared */ 182459d65b73SLina Iyer if (genpd->state_count == 0) { 182559d65b73SLina Iyer ret = genpd_set_default_power_state(genpd); 1826eb594b73SUlf Hansson if (ret) { 1827eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd)) 1828eb594b73SUlf Hansson free_cpumask_var(genpd->cpus); 182959d65b73SLina Iyer return ret; 1830eb594b73SUlf Hansson } 183146b7fe94SAisheng Dong } else if (!gov && genpd->state_count > 1) { 18322c9b7f87SUlf Hansson pr_warn("%s: no governor for states\n", genpd->name); 183359d65b73SLina Iyer } 1834fc5cbf0cSAxel Haslam 1835401ea157SViresh Kumar device_initialize(&genpd->dev); 1836401ea157SViresh Kumar dev_set_name(&genpd->dev, "%s", genpd->name); 1837401ea157SViresh Kumar 18385125bbf3SRafael J. Wysocki mutex_lock(&gpd_list_lock); 18395125bbf3SRafael J. Wysocki list_add(&genpd->gpd_list_node, &gpd_list); 18405125bbf3SRafael J. Wysocki mutex_unlock(&gpd_list_lock); 18417eb231c3SUlf Hansson 18427eb231c3SUlf Hansson return 0; 18435125bbf3SRafael J. Wysocki } 1844be5ed55dSRajendra Nayak EXPORT_SYMBOL_GPL(pm_genpd_init); 1845aa42240aSTomasz Figa 18463fe57710SJon Hunter static int genpd_remove(struct generic_pm_domain *genpd) 18473fe57710SJon Hunter { 18483fe57710SJon Hunter struct gpd_link *l, *link; 18493fe57710SJon Hunter 18503fe57710SJon Hunter if (IS_ERR_OR_NULL(genpd)) 18513fe57710SJon Hunter return -EINVAL; 18523fe57710SJon Hunter 185335241d12SLina Iyer genpd_lock(genpd); 18543fe57710SJon Hunter 18553fe57710SJon Hunter if (genpd->has_provider) { 185635241d12SLina Iyer genpd_unlock(genpd); 18573fe57710SJon Hunter pr_err("Provider present, unable to remove %s\n", genpd->name); 18583fe57710SJon Hunter return -EBUSY; 18593fe57710SJon Hunter } 18603fe57710SJon Hunter 18613fe57710SJon Hunter if (!list_empty(&genpd->master_links) || genpd->device_count) { 186235241d12SLina Iyer genpd_unlock(genpd); 18633fe57710SJon Hunter pr_err("%s: unable to remove %s\n", __func__, genpd->name); 18643fe57710SJon Hunter return -EBUSY; 18653fe57710SJon Hunter } 18663fe57710SJon Hunter 18673fe57710SJon Hunter list_for_each_entry_safe(link, l, &genpd->slave_links, slave_node) { 18683fe57710SJon Hunter list_del(&link->master_node); 18693fe57710SJon Hunter list_del(&link->slave_node); 18703fe57710SJon Hunter kfree(link); 18713fe57710SJon Hunter } 18723fe57710SJon Hunter 18733fe57710SJon Hunter list_del(&genpd->gpd_list_node); 187435241d12SLina Iyer genpd_unlock(genpd); 18753fe57710SJon Hunter cancel_work_sync(&genpd->power_off_work); 1876eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd)) 1877eb594b73SUlf Hansson free_cpumask_var(genpd->cpus); 187849a27e27SUlf Hansson if (genpd->free_states) 187949a27e27SUlf Hansson genpd->free_states(genpd->states, genpd->state_count); 188049a27e27SUlf Hansson 18813fe57710SJon Hunter pr_debug("%s: removed %s\n", __func__, genpd->name); 18823fe57710SJon Hunter 18833fe57710SJon Hunter return 0; 18843fe57710SJon Hunter } 18853fe57710SJon Hunter 18863fe57710SJon Hunter /** 18873fe57710SJon Hunter * pm_genpd_remove - Remove a generic I/O PM domain 18883fe57710SJon Hunter * @genpd: Pointer to PM domain that is to be removed. 18893fe57710SJon Hunter * 18903fe57710SJon Hunter * To remove the PM domain, this function: 18913fe57710SJon Hunter * - Removes the PM domain as a subdomain to any parent domains, 18923fe57710SJon Hunter * if it was added. 18933fe57710SJon Hunter * - Removes the PM domain from the list of registered PM domains. 18943fe57710SJon Hunter * 18953fe57710SJon Hunter * The PM domain will only be removed, if the associated provider has 18963fe57710SJon Hunter * been removed, it is not a parent to any other PM domain and has no 18973fe57710SJon Hunter * devices associated with it. 18983fe57710SJon Hunter */ 18993fe57710SJon Hunter int pm_genpd_remove(struct generic_pm_domain *genpd) 19003fe57710SJon Hunter { 19013fe57710SJon Hunter int ret; 19023fe57710SJon Hunter 19033fe57710SJon Hunter mutex_lock(&gpd_list_lock); 19043fe57710SJon Hunter ret = genpd_remove(genpd); 19053fe57710SJon Hunter mutex_unlock(&gpd_list_lock); 19063fe57710SJon Hunter 19073fe57710SJon Hunter return ret; 19083fe57710SJon Hunter } 19093fe57710SJon Hunter EXPORT_SYMBOL_GPL(pm_genpd_remove); 19103fe57710SJon Hunter 1911aa42240aSTomasz Figa #ifdef CONFIG_PM_GENERIC_DOMAINS_OF 1912892ebdccSJon Hunter 1913aa42240aSTomasz Figa /* 1914aa42240aSTomasz Figa * Device Tree based PM domain providers. 1915aa42240aSTomasz Figa * 1916aa42240aSTomasz Figa * The code below implements generic device tree based PM domain providers that 1917aa42240aSTomasz Figa * bind device tree nodes with generic PM domains registered in the system. 1918aa42240aSTomasz Figa * 1919aa42240aSTomasz Figa * Any driver that registers generic PM domains and needs to support binding of 1920aa42240aSTomasz Figa * devices to these domains is supposed to register a PM domain provider, which 1921aa42240aSTomasz Figa * maps a PM domain specifier retrieved from the device tree to a PM domain. 1922aa42240aSTomasz Figa * 1923aa42240aSTomasz Figa * Two simple mapping functions have been provided for convenience: 1924892ebdccSJon Hunter * - genpd_xlate_simple() for 1:1 device tree node to PM domain mapping. 1925892ebdccSJon Hunter * - genpd_xlate_onecell() for mapping of multiple PM domains per node by 1926aa42240aSTomasz Figa * index. 1927aa42240aSTomasz Figa */ 1928aa42240aSTomasz Figa 1929aa42240aSTomasz Figa /** 1930aa42240aSTomasz Figa * struct of_genpd_provider - PM domain provider registration structure 1931aa42240aSTomasz Figa * @link: Entry in global list of PM domain providers 1932aa42240aSTomasz Figa * @node: Pointer to device tree node of PM domain provider 1933aa42240aSTomasz Figa * @xlate: Provider-specific xlate callback mapping a set of specifier cells 1934aa42240aSTomasz Figa * into a PM domain. 1935aa42240aSTomasz Figa * @data: context pointer to be passed into @xlate callback 1936aa42240aSTomasz Figa */ 1937aa42240aSTomasz Figa struct of_genpd_provider { 1938aa42240aSTomasz Figa struct list_head link; 1939aa42240aSTomasz Figa struct device_node *node; 1940aa42240aSTomasz Figa genpd_xlate_t xlate; 1941aa42240aSTomasz Figa void *data; 1942aa42240aSTomasz Figa }; 1943aa42240aSTomasz Figa 1944aa42240aSTomasz Figa /* List of registered PM domain providers. */ 1945aa42240aSTomasz Figa static LIST_HEAD(of_genpd_providers); 1946aa42240aSTomasz Figa /* Mutex to protect the list above. */ 1947aa42240aSTomasz Figa static DEFINE_MUTEX(of_genpd_mutex); 1948aa42240aSTomasz Figa 1949aa42240aSTomasz Figa /** 1950892ebdccSJon Hunter * genpd_xlate_simple() - Xlate function for direct node-domain mapping 1951aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1952aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct generic_pm_domain 1953aa42240aSTomasz Figa * 1954aa42240aSTomasz Figa * This is a generic xlate function that can be used to model PM domains that 1955aa42240aSTomasz Figa * have their own device tree nodes. The private data of xlate function needs 1956aa42240aSTomasz Figa * to be a valid pointer to struct generic_pm_domain. 1957aa42240aSTomasz Figa */ 1958892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_simple( 1959aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1960aa42240aSTomasz Figa void *data) 1961aa42240aSTomasz Figa { 1962aa42240aSTomasz Figa return data; 1963aa42240aSTomasz Figa } 1964aa42240aSTomasz Figa 1965aa42240aSTomasz Figa /** 1966892ebdccSJon Hunter * genpd_xlate_onecell() - Xlate function using a single index. 1967aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1968aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct genpd_onecell_data 1969aa42240aSTomasz Figa * 1970aa42240aSTomasz Figa * This is a generic xlate function that can be used to model simple PM domain 1971aa42240aSTomasz Figa * controllers that have one device tree node and provide multiple PM domains. 1972aa42240aSTomasz Figa * A single cell is used as an index into an array of PM domains specified in 1973aa42240aSTomasz Figa * the genpd_onecell_data struct when registering the provider. 1974aa42240aSTomasz Figa */ 1975892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_onecell( 1976aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1977aa42240aSTomasz Figa void *data) 1978aa42240aSTomasz Figa { 1979aa42240aSTomasz Figa struct genpd_onecell_data *genpd_data = data; 1980aa42240aSTomasz Figa unsigned int idx = genpdspec->args[0]; 1981aa42240aSTomasz Figa 1982aa42240aSTomasz Figa if (genpdspec->args_count != 1) 1983aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1984aa42240aSTomasz Figa 1985aa42240aSTomasz Figa if (idx >= genpd_data->num_domains) { 1986aa42240aSTomasz Figa pr_err("%s: invalid domain index %u\n", __func__, idx); 1987aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1988aa42240aSTomasz Figa } 1989aa42240aSTomasz Figa 1990aa42240aSTomasz Figa if (!genpd_data->domains[idx]) 1991aa42240aSTomasz Figa return ERR_PTR(-ENOENT); 1992aa42240aSTomasz Figa 1993aa42240aSTomasz Figa return genpd_data->domains[idx]; 1994aa42240aSTomasz Figa } 1995aa42240aSTomasz Figa 1996aa42240aSTomasz Figa /** 1997892ebdccSJon Hunter * genpd_add_provider() - Register a PM domain provider for a node 1998aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider. 1999aa42240aSTomasz Figa * @xlate: Callback for decoding PM domain from phandle arguments. 2000aa42240aSTomasz Figa * @data: Context pointer for @xlate callback. 2001aa42240aSTomasz Figa */ 2002892ebdccSJon Hunter static int genpd_add_provider(struct device_node *np, genpd_xlate_t xlate, 2003aa42240aSTomasz Figa void *data) 2004aa42240aSTomasz Figa { 2005aa42240aSTomasz Figa struct of_genpd_provider *cp; 2006aa42240aSTomasz Figa 2007aa42240aSTomasz Figa cp = kzalloc(sizeof(*cp), GFP_KERNEL); 2008aa42240aSTomasz Figa if (!cp) 2009aa42240aSTomasz Figa return -ENOMEM; 2010aa42240aSTomasz Figa 2011aa42240aSTomasz Figa cp->node = of_node_get(np); 2012aa42240aSTomasz Figa cp->data = data; 2013aa42240aSTomasz Figa cp->xlate = xlate; 2014aa42240aSTomasz Figa 2015aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2016aa42240aSTomasz Figa list_add(&cp->link, &of_genpd_providers); 2017aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2018ea11e94bSRob Herring pr_debug("Added domain provider from %pOF\n", np); 2019aa42240aSTomasz Figa 2020aa42240aSTomasz Figa return 0; 2021aa42240aSTomasz Figa } 2022892ebdccSJon Hunter 2023892ebdccSJon Hunter /** 2024892ebdccSJon Hunter * of_genpd_add_provider_simple() - Register a simple PM domain provider 2025892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 2026892ebdccSJon Hunter * @genpd: Pointer to PM domain associated with the PM domain provider. 2027892ebdccSJon Hunter */ 2028892ebdccSJon Hunter int of_genpd_add_provider_simple(struct device_node *np, 2029892ebdccSJon Hunter struct generic_pm_domain *genpd) 2030892ebdccSJon Hunter { 20310159ec67SJon Hunter int ret = -EINVAL; 20320159ec67SJon Hunter 20330159ec67SJon Hunter if (!np || !genpd) 20340159ec67SJon Hunter return -EINVAL; 20350159ec67SJon Hunter 20360159ec67SJon Hunter mutex_lock(&gpd_list_lock); 20370159ec67SJon Hunter 20386a0ae73dSViresh Kumar if (!genpd_present(genpd)) 20396a0ae73dSViresh Kumar goto unlock; 20406a0ae73dSViresh Kumar 20416a0ae73dSViresh Kumar genpd->dev.of_node = np; 20426a0ae73dSViresh Kumar 20436a0ae73dSViresh Kumar /* Parse genpd OPP table */ 20446a0ae73dSViresh Kumar if (genpd->set_performance_state) { 20456a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table(&genpd->dev); 20466a0ae73dSViresh Kumar if (ret) { 20476a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table: %d\n", 20486a0ae73dSViresh Kumar ret); 20496a0ae73dSViresh Kumar goto unlock; 2050de0aa06dSJon Hunter } 20511067ae3eSViresh Kumar 20521067ae3eSViresh Kumar /* 20531067ae3eSViresh Kumar * Save table for faster processing while setting performance 20541067ae3eSViresh Kumar * state. 20551067ae3eSViresh Kumar */ 20561067ae3eSViresh Kumar genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev); 20571067ae3eSViresh Kumar WARN_ON(!genpd->opp_table); 20588ce95844SViresh Kumar } 2059de0aa06dSJon Hunter 20606a0ae73dSViresh Kumar ret = genpd_add_provider(np, genpd_xlate_simple, genpd); 20616a0ae73dSViresh Kumar if (ret) { 20621067ae3eSViresh Kumar if (genpd->set_performance_state) { 20631067ae3eSViresh Kumar dev_pm_opp_put_opp_table(genpd->opp_table); 20646a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 20651067ae3eSViresh Kumar } 20666a0ae73dSViresh Kumar 20676a0ae73dSViresh Kumar goto unlock; 20686a0ae73dSViresh Kumar } 20696a0ae73dSViresh Kumar 20706a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 20716a0ae73dSViresh Kumar genpd->has_provider = true; 20726a0ae73dSViresh Kumar 20736a0ae73dSViresh Kumar unlock: 20740159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 20750159ec67SJon Hunter 20760159ec67SJon Hunter return ret; 2077892ebdccSJon Hunter } 2078892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_simple); 2079892ebdccSJon Hunter 2080892ebdccSJon Hunter /** 2081892ebdccSJon Hunter * of_genpd_add_provider_onecell() - Register a onecell PM domain provider 2082892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 2083892ebdccSJon Hunter * @data: Pointer to the data associated with the PM domain provider. 2084892ebdccSJon Hunter */ 2085892ebdccSJon Hunter int of_genpd_add_provider_onecell(struct device_node *np, 2086892ebdccSJon Hunter struct genpd_onecell_data *data) 2087892ebdccSJon Hunter { 20886a0ae73dSViresh Kumar struct generic_pm_domain *genpd; 20890159ec67SJon Hunter unsigned int i; 2090de0aa06dSJon Hunter int ret = -EINVAL; 20910159ec67SJon Hunter 20920159ec67SJon Hunter if (!np || !data) 20930159ec67SJon Hunter return -EINVAL; 20940159ec67SJon Hunter 20950159ec67SJon Hunter mutex_lock(&gpd_list_lock); 20960159ec67SJon Hunter 209740845524SThierry Reding if (!data->xlate) 209840845524SThierry Reding data->xlate = genpd_xlate_onecell; 209940845524SThierry Reding 21000159ec67SJon Hunter for (i = 0; i < data->num_domains; i++) { 21016a0ae73dSViresh Kumar genpd = data->domains[i]; 21026a0ae73dSViresh Kumar 21036a0ae73dSViresh Kumar if (!genpd) 2104609bed67STomeu Vizoso continue; 21056a0ae73dSViresh Kumar if (!genpd_present(genpd)) 2106de0aa06dSJon Hunter goto error; 2107de0aa06dSJon Hunter 21086a0ae73dSViresh Kumar genpd->dev.of_node = np; 21096a0ae73dSViresh Kumar 21106a0ae73dSViresh Kumar /* Parse genpd OPP table */ 21116a0ae73dSViresh Kumar if (genpd->set_performance_state) { 21126a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i); 21136a0ae73dSViresh Kumar if (ret) { 21146a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table for index %d: %d\n", 21156a0ae73dSViresh Kumar i, ret); 21166a0ae73dSViresh Kumar goto error; 21176a0ae73dSViresh Kumar } 21181067ae3eSViresh Kumar 21191067ae3eSViresh Kumar /* 21201067ae3eSViresh Kumar * Save table for faster processing while setting 21211067ae3eSViresh Kumar * performance state. 21221067ae3eSViresh Kumar */ 21231067ae3eSViresh Kumar genpd->opp_table = dev_pm_opp_get_opp_table_indexed(&genpd->dev, i); 21241067ae3eSViresh Kumar WARN_ON(!genpd->opp_table); 21256a0ae73dSViresh Kumar } 21266a0ae73dSViresh Kumar 21276a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 21286a0ae73dSViresh Kumar genpd->has_provider = true; 21290159ec67SJon Hunter } 21300159ec67SJon Hunter 213140845524SThierry Reding ret = genpd_add_provider(np, data->xlate, data); 2132de0aa06dSJon Hunter if (ret < 0) 2133de0aa06dSJon Hunter goto error; 2134de0aa06dSJon Hunter 2135de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 2136de0aa06dSJon Hunter 2137de0aa06dSJon Hunter return 0; 2138de0aa06dSJon Hunter 2139de0aa06dSJon Hunter error: 2140de0aa06dSJon Hunter while (i--) { 21416a0ae73dSViresh Kumar genpd = data->domains[i]; 21426a0ae73dSViresh Kumar 21436a0ae73dSViresh Kumar if (!genpd) 2144609bed67STomeu Vizoso continue; 21456a0ae73dSViresh Kumar 21466a0ae73dSViresh Kumar genpd->provider = NULL; 21476a0ae73dSViresh Kumar genpd->has_provider = false; 21486a0ae73dSViresh Kumar 21491067ae3eSViresh Kumar if (genpd->set_performance_state) { 21501067ae3eSViresh Kumar dev_pm_opp_put_opp_table(genpd->opp_table); 21516a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 2152de0aa06dSJon Hunter } 21531067ae3eSViresh Kumar } 21540159ec67SJon Hunter 21550159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 21560159ec67SJon Hunter 21570159ec67SJon Hunter return ret; 2158892ebdccSJon Hunter } 2159892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_onecell); 2160aa42240aSTomasz Figa 2161aa42240aSTomasz Figa /** 2162aa42240aSTomasz Figa * of_genpd_del_provider() - Remove a previously registered PM domain provider 2163aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider 2164aa42240aSTomasz Figa */ 2165aa42240aSTomasz Figa void of_genpd_del_provider(struct device_node *np) 2166aa42240aSTomasz Figa { 2167b556b15dSKrzysztof Kozlowski struct of_genpd_provider *cp, *tmp; 2168de0aa06dSJon Hunter struct generic_pm_domain *gpd; 2169aa42240aSTomasz Figa 2170de0aa06dSJon Hunter mutex_lock(&gpd_list_lock); 2171aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2172b556b15dSKrzysztof Kozlowski list_for_each_entry_safe(cp, tmp, &of_genpd_providers, link) { 2173aa42240aSTomasz Figa if (cp->node == np) { 2174de0aa06dSJon Hunter /* 2175de0aa06dSJon Hunter * For each PM domain associated with the 2176de0aa06dSJon Hunter * provider, set the 'has_provider' to false 2177de0aa06dSJon Hunter * so that the PM domain can be safely removed. 2178de0aa06dSJon Hunter */ 21796a0ae73dSViresh Kumar list_for_each_entry(gpd, &gpd_list, gpd_list_node) { 21806a0ae73dSViresh Kumar if (gpd->provider == &np->fwnode) { 2181de0aa06dSJon Hunter gpd->has_provider = false; 2182de0aa06dSJon Hunter 21836a0ae73dSViresh Kumar if (!gpd->set_performance_state) 21846a0ae73dSViresh Kumar continue; 21856a0ae73dSViresh Kumar 21861067ae3eSViresh Kumar dev_pm_opp_put_opp_table(gpd->opp_table); 21876a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&gpd->dev); 21886a0ae73dSViresh Kumar } 21896a0ae73dSViresh Kumar } 21906a0ae73dSViresh Kumar 2191aa42240aSTomasz Figa list_del(&cp->link); 2192aa42240aSTomasz Figa of_node_put(cp->node); 2193aa42240aSTomasz Figa kfree(cp); 2194aa42240aSTomasz Figa break; 2195aa42240aSTomasz Figa } 2196aa42240aSTomasz Figa } 2197aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2198de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 2199aa42240aSTomasz Figa } 2200aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(of_genpd_del_provider); 2201aa42240aSTomasz Figa 2202aa42240aSTomasz Figa /** 2203f58d4e5aSJon Hunter * genpd_get_from_provider() - Look-up PM domain 2204aa42240aSTomasz Figa * @genpdspec: OF phandle args to use for look-up 2205aa42240aSTomasz Figa * 2206aa42240aSTomasz Figa * Looks for a PM domain provider under the node specified by @genpdspec and if 2207aa42240aSTomasz Figa * found, uses xlate function of the provider to map phandle args to a PM 2208aa42240aSTomasz Figa * domain. 2209aa42240aSTomasz Figa * 2210aa42240aSTomasz Figa * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR() 2211aa42240aSTomasz Figa * on failure. 2212aa42240aSTomasz Figa */ 2213f58d4e5aSJon Hunter static struct generic_pm_domain *genpd_get_from_provider( 2214aa42240aSTomasz Figa struct of_phandle_args *genpdspec) 2215aa42240aSTomasz Figa { 2216aa42240aSTomasz Figa struct generic_pm_domain *genpd = ERR_PTR(-ENOENT); 2217aa42240aSTomasz Figa struct of_genpd_provider *provider; 2218aa42240aSTomasz Figa 221941795a8aSJon Hunter if (!genpdspec) 222041795a8aSJon Hunter return ERR_PTR(-EINVAL); 222141795a8aSJon Hunter 2222aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2223aa42240aSTomasz Figa 2224aa42240aSTomasz Figa /* Check if we have such a provider in our array */ 2225aa42240aSTomasz Figa list_for_each_entry(provider, &of_genpd_providers, link) { 2226aa42240aSTomasz Figa if (provider->node == genpdspec->np) 2227aa42240aSTomasz Figa genpd = provider->xlate(genpdspec, provider->data); 2228aa42240aSTomasz Figa if (!IS_ERR(genpd)) 2229aa42240aSTomasz Figa break; 2230aa42240aSTomasz Figa } 2231aa42240aSTomasz Figa 2232aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2233aa42240aSTomasz Figa 2234aa42240aSTomasz Figa return genpd; 2235aa42240aSTomasz Figa } 2236aa42240aSTomasz Figa 2237aa42240aSTomasz Figa /** 2238ec69572bSJon Hunter * of_genpd_add_device() - Add a device to an I/O PM domain 2239ec69572bSJon Hunter * @genpdspec: OF phandle args to use for look-up PM domain 2240ec69572bSJon Hunter * @dev: Device to be added. 2241ec69572bSJon Hunter * 2242ec69572bSJon Hunter * Looks-up an I/O PM domain based upon phandle args provided and adds 2243ec69572bSJon Hunter * the device to the PM domain. Returns a negative error code on failure. 2244ec69572bSJon Hunter */ 2245ec69572bSJon Hunter int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev) 2246ec69572bSJon Hunter { 2247ec69572bSJon Hunter struct generic_pm_domain *genpd; 224819efa5ffSJon Hunter int ret; 224919efa5ffSJon Hunter 225019efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2251ec69572bSJon Hunter 2252f58d4e5aSJon Hunter genpd = genpd_get_from_provider(genpdspec); 225319efa5ffSJon Hunter if (IS_ERR(genpd)) { 225419efa5ffSJon Hunter ret = PTR_ERR(genpd); 225519efa5ffSJon Hunter goto out; 225619efa5ffSJon Hunter } 2257ec69572bSJon Hunter 2258f9ccd7c3SUlf Hansson ret = genpd_add_device(genpd, dev, dev); 225919efa5ffSJon Hunter 226019efa5ffSJon Hunter out: 226119efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 226219efa5ffSJon Hunter 226319efa5ffSJon Hunter return ret; 2264ec69572bSJon Hunter } 2265ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_device); 2266ec69572bSJon Hunter 2267ec69572bSJon Hunter /** 2268ec69572bSJon Hunter * of_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 2269ec69572bSJon Hunter * @parent_spec: OF phandle args to use for parent PM domain look-up 2270ec69572bSJon Hunter * @subdomain_spec: OF phandle args to use for subdomain look-up 2271ec69572bSJon Hunter * 2272ec69572bSJon Hunter * Looks-up a parent PM domain and subdomain based upon phandle args 2273ec69572bSJon Hunter * provided and adds the subdomain to the parent PM domain. Returns a 2274ec69572bSJon Hunter * negative error code on failure. 2275ec69572bSJon Hunter */ 2276ec69572bSJon Hunter int of_genpd_add_subdomain(struct of_phandle_args *parent_spec, 2277ec69572bSJon Hunter struct of_phandle_args *subdomain_spec) 2278ec69572bSJon Hunter { 2279ec69572bSJon Hunter struct generic_pm_domain *parent, *subdomain; 228019efa5ffSJon Hunter int ret; 228119efa5ffSJon Hunter 228219efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2283ec69572bSJon Hunter 2284f58d4e5aSJon Hunter parent = genpd_get_from_provider(parent_spec); 228519efa5ffSJon Hunter if (IS_ERR(parent)) { 228619efa5ffSJon Hunter ret = PTR_ERR(parent); 228719efa5ffSJon Hunter goto out; 228819efa5ffSJon Hunter } 2289ec69572bSJon Hunter 2290f58d4e5aSJon Hunter subdomain = genpd_get_from_provider(subdomain_spec); 229119efa5ffSJon Hunter if (IS_ERR(subdomain)) { 229219efa5ffSJon Hunter ret = PTR_ERR(subdomain); 229319efa5ffSJon Hunter goto out; 229419efa5ffSJon Hunter } 2295ec69572bSJon Hunter 229619efa5ffSJon Hunter ret = genpd_add_subdomain(parent, subdomain); 229719efa5ffSJon Hunter 229819efa5ffSJon Hunter out: 229919efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 230019efa5ffSJon Hunter 230119efa5ffSJon Hunter return ret; 2302ec69572bSJon Hunter } 2303ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_subdomain); 2304ec69572bSJon Hunter 2305ec69572bSJon Hunter /** 230617926551SJon Hunter * of_genpd_remove_last - Remove the last PM domain registered for a provider 230717926551SJon Hunter * @provider: Pointer to device structure associated with provider 230817926551SJon Hunter * 230917926551SJon Hunter * Find the last PM domain that was added by a particular provider and 231017926551SJon Hunter * remove this PM domain from the list of PM domains. The provider is 231117926551SJon Hunter * identified by the 'provider' device structure that is passed. The PM 231217926551SJon Hunter * domain will only be removed, if the provider associated with domain 231317926551SJon Hunter * has been removed. 231417926551SJon Hunter * 231517926551SJon Hunter * Returns a valid pointer to struct generic_pm_domain on success or 231617926551SJon Hunter * ERR_PTR() on failure. 231717926551SJon Hunter */ 231817926551SJon Hunter struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) 231917926551SJon Hunter { 2320a7e2d1bcSKrzysztof Kozlowski struct generic_pm_domain *gpd, *tmp, *genpd = ERR_PTR(-ENOENT); 232117926551SJon Hunter int ret; 232217926551SJon Hunter 232317926551SJon Hunter if (IS_ERR_OR_NULL(np)) 232417926551SJon Hunter return ERR_PTR(-EINVAL); 232517926551SJon Hunter 232617926551SJon Hunter mutex_lock(&gpd_list_lock); 2327a7e2d1bcSKrzysztof Kozlowski list_for_each_entry_safe(gpd, tmp, &gpd_list, gpd_list_node) { 232817926551SJon Hunter if (gpd->provider == &np->fwnode) { 232917926551SJon Hunter ret = genpd_remove(gpd); 233017926551SJon Hunter genpd = ret ? ERR_PTR(ret) : gpd; 233117926551SJon Hunter break; 233217926551SJon Hunter } 233317926551SJon Hunter } 233417926551SJon Hunter mutex_unlock(&gpd_list_lock); 233517926551SJon Hunter 233617926551SJon Hunter return genpd; 233717926551SJon Hunter } 233817926551SJon Hunter EXPORT_SYMBOL_GPL(of_genpd_remove_last); 233917926551SJon Hunter 23403c095f32SUlf Hansson static void genpd_release_dev(struct device *dev) 23413c095f32SUlf Hansson { 2342e8b04de9SUlf Hansson of_node_put(dev->of_node); 23433c095f32SUlf Hansson kfree(dev); 23443c095f32SUlf Hansson } 23453c095f32SUlf Hansson 23463c095f32SUlf Hansson static struct bus_type genpd_bus_type = { 23473c095f32SUlf Hansson .name = "genpd", 23483c095f32SUlf Hansson }; 23493c095f32SUlf Hansson 235017926551SJon Hunter /** 2351aa42240aSTomasz Figa * genpd_dev_pm_detach - Detach a device from its PM domain. 23528bb6944eSJon Hunter * @dev: Device to detach. 2353aa42240aSTomasz Figa * @power_off: Currently not used 2354aa42240aSTomasz Figa * 2355aa42240aSTomasz Figa * Try to locate a corresponding generic PM domain, which the device was 2356aa42240aSTomasz Figa * attached to previously. If such is found, the device is detached from it. 2357aa42240aSTomasz Figa */ 2358aa42240aSTomasz Figa static void genpd_dev_pm_detach(struct device *dev, bool power_off) 2359aa42240aSTomasz Figa { 2360446d999cSRussell King struct generic_pm_domain *pd; 236193af5e93SGeert Uytterhoeven unsigned int i; 2362aa42240aSTomasz Figa int ret = 0; 2363aa42240aSTomasz Figa 236485168d56SUlf Hansson pd = dev_to_genpd(dev); 236585168d56SUlf Hansson if (IS_ERR(pd)) 2366aa42240aSTomasz Figa return; 2367aa42240aSTomasz Figa 2368aa42240aSTomasz Figa dev_dbg(dev, "removing from PM domain %s\n", pd->name); 2369aa42240aSTomasz Figa 237093af5e93SGeert Uytterhoeven for (i = 1; i < GENPD_RETRY_MAX_MS; i <<= 1) { 237185168d56SUlf Hansson ret = genpd_remove_device(pd, dev); 2372aa42240aSTomasz Figa if (ret != -EAGAIN) 2373aa42240aSTomasz Figa break; 237493af5e93SGeert Uytterhoeven 237593af5e93SGeert Uytterhoeven mdelay(i); 2376aa42240aSTomasz Figa cond_resched(); 2377aa42240aSTomasz Figa } 2378aa42240aSTomasz Figa 2379aa42240aSTomasz Figa if (ret < 0) { 2380aa42240aSTomasz Figa dev_err(dev, "failed to remove from PM domain %s: %d", 2381aa42240aSTomasz Figa pd->name, ret); 2382aa42240aSTomasz Figa return; 2383aa42240aSTomasz Figa } 2384aa42240aSTomasz Figa 2385aa42240aSTomasz Figa /* Check if PM domain can be powered off after removing this device. */ 2386aa42240aSTomasz Figa genpd_queue_power_off_work(pd); 23873c095f32SUlf Hansson 23883c095f32SUlf Hansson /* Unregister the device if it was created by genpd. */ 23893c095f32SUlf Hansson if (dev->bus == &genpd_bus_type) 23903c095f32SUlf Hansson device_unregister(dev); 2391aa42240aSTomasz Figa } 2392aa42240aSTomasz Figa 2393632f7ce3SRussell King static void genpd_dev_pm_sync(struct device *dev) 2394632f7ce3SRussell King { 2395632f7ce3SRussell King struct generic_pm_domain *pd; 2396632f7ce3SRussell King 2397632f7ce3SRussell King pd = dev_to_genpd(dev); 2398632f7ce3SRussell King if (IS_ERR(pd)) 2399632f7ce3SRussell King return; 2400632f7ce3SRussell King 2401632f7ce3SRussell King genpd_queue_power_off_work(pd); 2402632f7ce3SRussell King } 2403632f7ce3SRussell King 240451dcf748SUlf Hansson static int __genpd_dev_pm_attach(struct device *dev, struct device *base_dev, 240551dcf748SUlf Hansson unsigned int index, bool power_on) 2406aa42240aSTomasz Figa { 2407aa42240aSTomasz Figa struct of_phandle_args pd_args; 2408aa42240aSTomasz Figa struct generic_pm_domain *pd; 2409aa42240aSTomasz Figa int ret; 2410aa42240aSTomasz Figa 2411e8b04de9SUlf Hansson ret = of_parse_phandle_with_args(dev->of_node, "power-domains", 24128cb1cbd6SUlf Hansson "#power-domain-cells", index, &pd_args); 2413001d50c9SGeert Uytterhoeven if (ret < 0) 2414bcd931f2SUlf Hansson return ret; 2415aa42240aSTomasz Figa 241619efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2417f58d4e5aSJon Hunter pd = genpd_get_from_provider(&pd_args); 2418265e2cf6SEric Anholt of_node_put(pd_args.np); 2419aa42240aSTomasz Figa if (IS_ERR(pd)) { 242019efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2421aa42240aSTomasz Figa dev_dbg(dev, "%s() failed to find PM domain: %ld\n", 2422aa42240aSTomasz Figa __func__, PTR_ERR(pd)); 242351dcf748SUlf Hansson return driver_deferred_probe_check_state(base_dev); 2424aa42240aSTomasz Figa } 2425aa42240aSTomasz Figa 2426aa42240aSTomasz Figa dev_dbg(dev, "adding to PM domain %s\n", pd->name); 2427aa42240aSTomasz Figa 2428f9ccd7c3SUlf Hansson ret = genpd_add_device(pd, dev, base_dev); 242919efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2430aa42240aSTomasz Figa 2431aa42240aSTomasz Figa if (ret < 0) { 243234994692SGeert Uytterhoeven if (ret != -EPROBE_DEFER) 2433aa42240aSTomasz Figa dev_err(dev, "failed to add to PM domain %s: %d", 2434aa42240aSTomasz Figa pd->name, ret); 2435919b7308SUlf Hansson return ret; 2436aa42240aSTomasz Figa } 2437aa42240aSTomasz Figa 2438aa42240aSTomasz Figa dev->pm_domain->detach = genpd_dev_pm_detach; 2439632f7ce3SRussell King dev->pm_domain->sync = genpd_dev_pm_sync; 2440aa42240aSTomasz Figa 2441895b6612SUlf Hansson if (power_on) { 244235241d12SLina Iyer genpd_lock(pd); 244386e12eacSUlf Hansson ret = genpd_power_on(pd, 0); 244435241d12SLina Iyer genpd_unlock(pd); 2445895b6612SUlf Hansson } 244672038df3SUlf Hansson 244772038df3SUlf Hansson if (ret) 244872038df3SUlf Hansson genpd_remove_device(pd, dev); 2449919b7308SUlf Hansson 2450919b7308SUlf Hansson return ret ? -EPROBE_DEFER : 1; 2451aa42240aSTomasz Figa } 24528cb1cbd6SUlf Hansson 24538cb1cbd6SUlf Hansson /** 24548cb1cbd6SUlf Hansson * genpd_dev_pm_attach - Attach a device to its PM domain using DT. 24558cb1cbd6SUlf Hansson * @dev: Device to attach. 24568cb1cbd6SUlf Hansson * 24578cb1cbd6SUlf Hansson * Parse device's OF node to find a PM domain specifier. If such is found, 24588cb1cbd6SUlf Hansson * attaches the device to retrieved pm_domain ops. 24598cb1cbd6SUlf Hansson * 24608cb1cbd6SUlf Hansson * Returns 1 on successfully attached PM domain, 0 when the device don't need a 24618cb1cbd6SUlf Hansson * PM domain or when multiple power-domains exists for it, else a negative error 24628cb1cbd6SUlf Hansson * code. Note that if a power-domain exists for the device, but it cannot be 24638cb1cbd6SUlf Hansson * found or turned on, then return -EPROBE_DEFER to ensure that the device is 24648cb1cbd6SUlf Hansson * not probed and to re-try again later. 24658cb1cbd6SUlf Hansson */ 24668cb1cbd6SUlf Hansson int genpd_dev_pm_attach(struct device *dev) 24678cb1cbd6SUlf Hansson { 24688cb1cbd6SUlf Hansson if (!dev->of_node) 24698cb1cbd6SUlf Hansson return 0; 24708cb1cbd6SUlf Hansson 24718cb1cbd6SUlf Hansson /* 24728cb1cbd6SUlf Hansson * Devices with multiple PM domains must be attached separately, as we 24738cb1cbd6SUlf Hansson * can only attach one PM domain per device. 24748cb1cbd6SUlf Hansson */ 24758cb1cbd6SUlf Hansson if (of_count_phandle_with_args(dev->of_node, "power-domains", 24768cb1cbd6SUlf Hansson "#power-domain-cells") != 1) 24778cb1cbd6SUlf Hansson return 0; 24788cb1cbd6SUlf Hansson 247951dcf748SUlf Hansson return __genpd_dev_pm_attach(dev, dev, 0, true); 24808cb1cbd6SUlf Hansson } 2481aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(genpd_dev_pm_attach); 248230f60428SLina Iyer 24833c095f32SUlf Hansson /** 24843c095f32SUlf Hansson * genpd_dev_pm_attach_by_id - Associate a device with one of its PM domains. 24853c095f32SUlf Hansson * @dev: The device used to lookup the PM domain. 24863c095f32SUlf Hansson * @index: The index of the PM domain. 24873c095f32SUlf Hansson * 24883c095f32SUlf Hansson * Parse device's OF node to find a PM domain specifier at the provided @index. 24893c095f32SUlf Hansson * If such is found, creates a virtual device and attaches it to the retrieved 24903c095f32SUlf Hansson * pm_domain ops. To deal with detaching of the virtual device, the ->detach() 24913c095f32SUlf Hansson * callback in the struct dev_pm_domain are assigned to genpd_dev_pm_detach(). 24923c095f32SUlf Hansson * 24933c095f32SUlf Hansson * Returns the created virtual device if successfully attached PM domain, NULL 24943c095f32SUlf Hansson * when the device don't need a PM domain, else an ERR_PTR() in case of 24953c095f32SUlf Hansson * failures. If a power-domain exists for the device, but cannot be found or 24963c095f32SUlf Hansson * turned on, then ERR_PTR(-EPROBE_DEFER) is returned to ensure that the device 24973c095f32SUlf Hansson * is not probed and to re-try again later. 24983c095f32SUlf Hansson */ 24993c095f32SUlf Hansson struct device *genpd_dev_pm_attach_by_id(struct device *dev, 25003c095f32SUlf Hansson unsigned int index) 25013c095f32SUlf Hansson { 2502560928b2SViresh Kumar struct device *virt_dev; 25033c095f32SUlf Hansson int num_domains; 25043c095f32SUlf Hansson int ret; 25053c095f32SUlf Hansson 25063c095f32SUlf Hansson if (!dev->of_node) 25073c095f32SUlf Hansson return NULL; 25083c095f32SUlf Hansson 25093ccf3f0cSUlf Hansson /* Verify that the index is within a valid range. */ 25103c095f32SUlf Hansson num_domains = of_count_phandle_with_args(dev->of_node, "power-domains", 25113c095f32SUlf Hansson "#power-domain-cells"); 25123ccf3f0cSUlf Hansson if (index >= num_domains) 25133c095f32SUlf Hansson return NULL; 25143c095f32SUlf Hansson 25153c095f32SUlf Hansson /* Allocate and register device on the genpd bus. */ 2516560928b2SViresh Kumar virt_dev = kzalloc(sizeof(*virt_dev), GFP_KERNEL); 2517560928b2SViresh Kumar if (!virt_dev) 25183c095f32SUlf Hansson return ERR_PTR(-ENOMEM); 25193c095f32SUlf Hansson 2520560928b2SViresh Kumar dev_set_name(virt_dev, "genpd:%u:%s", index, dev_name(dev)); 2521560928b2SViresh Kumar virt_dev->bus = &genpd_bus_type; 2522560928b2SViresh Kumar virt_dev->release = genpd_release_dev; 2523e8b04de9SUlf Hansson virt_dev->of_node = of_node_get(dev->of_node); 25243c095f32SUlf Hansson 2525560928b2SViresh Kumar ret = device_register(virt_dev); 25263c095f32SUlf Hansson if (ret) { 252771b77697SUlf Hansson put_device(virt_dev); 25283c095f32SUlf Hansson return ERR_PTR(ret); 25293c095f32SUlf Hansson } 25303c095f32SUlf Hansson 25313c095f32SUlf Hansson /* Try to attach the device to the PM domain at the specified index. */ 253251dcf748SUlf Hansson ret = __genpd_dev_pm_attach(virt_dev, dev, index, false); 25333c095f32SUlf Hansson if (ret < 1) { 2534560928b2SViresh Kumar device_unregister(virt_dev); 25353c095f32SUlf Hansson return ret ? ERR_PTR(ret) : NULL; 25363c095f32SUlf Hansson } 25373c095f32SUlf Hansson 2538560928b2SViresh Kumar pm_runtime_enable(virt_dev); 2539560928b2SViresh Kumar genpd_queue_power_off_work(dev_to_genpd(virt_dev)); 25403c095f32SUlf Hansson 2541560928b2SViresh Kumar return virt_dev; 25423c095f32SUlf Hansson } 25433c095f32SUlf Hansson EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id); 25443c095f32SUlf Hansson 25455d6be70aSUlf Hansson /** 25465d6be70aSUlf Hansson * genpd_dev_pm_attach_by_name - Associate a device with one of its PM domains. 25475d6be70aSUlf Hansson * @dev: The device used to lookup the PM domain. 25485d6be70aSUlf Hansson * @name: The name of the PM domain. 25495d6be70aSUlf Hansson * 25505d6be70aSUlf Hansson * Parse device's OF node to find a PM domain specifier using the 25515d6be70aSUlf Hansson * power-domain-names DT property. For further description see 25525d6be70aSUlf Hansson * genpd_dev_pm_attach_by_id(). 25535d6be70aSUlf Hansson */ 25547416f1f2SDouglas Anderson struct device *genpd_dev_pm_attach_by_name(struct device *dev, const char *name) 25555d6be70aSUlf Hansson { 25565d6be70aSUlf Hansson int index; 25575d6be70aSUlf Hansson 25585d6be70aSUlf Hansson if (!dev->of_node) 25595d6be70aSUlf Hansson return NULL; 25605d6be70aSUlf Hansson 25615d6be70aSUlf Hansson index = of_property_match_string(dev->of_node, "power-domain-names", 25625d6be70aSUlf Hansson name); 25635d6be70aSUlf Hansson if (index < 0) 25645d6be70aSUlf Hansson return NULL; 25655d6be70aSUlf Hansson 25665d6be70aSUlf Hansson return genpd_dev_pm_attach_by_id(dev, index); 25675d6be70aSUlf Hansson } 25685d6be70aSUlf Hansson 256930f60428SLina Iyer static const struct of_device_id idle_state_match[] = { 2570598da548SLina Iyer { .compatible = "domain-idle-state", }, 257130f60428SLina Iyer { } 257230f60428SLina Iyer }; 257330f60428SLina Iyer 257430f60428SLina Iyer static int genpd_parse_state(struct genpd_power_state *genpd_state, 257530f60428SLina Iyer struct device_node *state_node) 257630f60428SLina Iyer { 257730f60428SLina Iyer int err; 257830f60428SLina Iyer u32 residency; 257930f60428SLina Iyer u32 entry_latency, exit_latency; 258030f60428SLina Iyer 258130f60428SLina Iyer err = of_property_read_u32(state_node, "entry-latency-us", 258230f60428SLina Iyer &entry_latency); 258330f60428SLina Iyer if (err) { 2584ea11e94bSRob Herring pr_debug(" * %pOF missing entry-latency-us property\n", 2585ea11e94bSRob Herring state_node); 258630f60428SLina Iyer return -EINVAL; 258730f60428SLina Iyer } 258830f60428SLina Iyer 258930f60428SLina Iyer err = of_property_read_u32(state_node, "exit-latency-us", 259030f60428SLina Iyer &exit_latency); 259130f60428SLina Iyer if (err) { 2592ea11e94bSRob Herring pr_debug(" * %pOF missing exit-latency-us property\n", 2593ea11e94bSRob Herring state_node); 259430f60428SLina Iyer return -EINVAL; 259530f60428SLina Iyer } 259630f60428SLina Iyer 259730f60428SLina Iyer err = of_property_read_u32(state_node, "min-residency-us", &residency); 259830f60428SLina Iyer if (!err) 259930f60428SLina Iyer genpd_state->residency_ns = 1000 * residency; 260030f60428SLina Iyer 260130f60428SLina Iyer genpd_state->power_on_latency_ns = 1000 * exit_latency; 260230f60428SLina Iyer genpd_state->power_off_latency_ns = 1000 * entry_latency; 26030c9b694aSLina Iyer genpd_state->fwnode = &state_node->fwnode; 260430f60428SLina Iyer 260530f60428SLina Iyer return 0; 260630f60428SLina Iyer } 260730f60428SLina Iyer 2608a3381e3aSUlf Hansson static int genpd_iterate_idle_states(struct device_node *dn, 2609a3381e3aSUlf Hansson struct genpd_power_state *states) 2610a3381e3aSUlf Hansson { 2611a3381e3aSUlf Hansson int ret; 2612a3381e3aSUlf Hansson struct of_phandle_iterator it; 2613a3381e3aSUlf Hansson struct device_node *np; 2614a3381e3aSUlf Hansson int i = 0; 2615a3381e3aSUlf Hansson 2616a3381e3aSUlf Hansson ret = of_count_phandle_with_args(dn, "domain-idle-states", NULL); 2617a3381e3aSUlf Hansson if (ret <= 0) 2618a3381e3aSUlf Hansson return ret; 2619a3381e3aSUlf Hansson 2620a3381e3aSUlf Hansson /* Loop over the phandles until all the requested entry is found */ 2621a3381e3aSUlf Hansson of_for_each_phandle(&it, ret, dn, "domain-idle-states", NULL, 0) { 2622a3381e3aSUlf Hansson np = it.node; 2623a3381e3aSUlf Hansson if (!of_match_node(idle_state_match, np)) 2624a3381e3aSUlf Hansson continue; 2625a3381e3aSUlf Hansson if (states) { 2626a3381e3aSUlf Hansson ret = genpd_parse_state(&states[i], np); 2627a3381e3aSUlf Hansson if (ret) { 2628a3381e3aSUlf Hansson pr_err("Parsing idle state node %pOF failed with err %d\n", 2629a3381e3aSUlf Hansson np, ret); 2630a3381e3aSUlf Hansson of_node_put(np); 2631a3381e3aSUlf Hansson return ret; 2632a3381e3aSUlf Hansson } 2633a3381e3aSUlf Hansson } 2634a3381e3aSUlf Hansson i++; 2635a3381e3aSUlf Hansson } 2636a3381e3aSUlf Hansson 2637a3381e3aSUlf Hansson return i; 2638a3381e3aSUlf Hansson } 2639a3381e3aSUlf Hansson 264030f60428SLina Iyer /** 264130f60428SLina Iyer * of_genpd_parse_idle_states: Return array of idle states for the genpd. 264230f60428SLina Iyer * 264330f60428SLina Iyer * @dn: The genpd device node 264430f60428SLina Iyer * @states: The pointer to which the state array will be saved. 264530f60428SLina Iyer * @n: The count of elements in the array returned from this function. 264630f60428SLina Iyer * 264730f60428SLina Iyer * Returns the device states parsed from the OF node. The memory for the states 264830f60428SLina Iyer * is allocated by this function and is the responsibility of the caller to 26492c361684SUlf Hansson * free the memory after use. If any or zero compatible domain idle states is 26502c361684SUlf Hansson * found it returns 0 and in case of errors, a negative error code is returned. 265130f60428SLina Iyer */ 265230f60428SLina Iyer int of_genpd_parse_idle_states(struct device_node *dn, 265330f60428SLina Iyer struct genpd_power_state **states, int *n) 265430f60428SLina Iyer { 265530f60428SLina Iyer struct genpd_power_state *st; 2656a3381e3aSUlf Hansson int ret; 265730f60428SLina Iyer 2658a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, NULL); 26592c361684SUlf Hansson if (ret < 0) 26602c361684SUlf Hansson return ret; 26612c361684SUlf Hansson 26622c361684SUlf Hansson if (!ret) { 26632c361684SUlf Hansson *states = NULL; 26642c361684SUlf Hansson *n = 0; 26652c361684SUlf Hansson return 0; 26662c361684SUlf Hansson } 266730f60428SLina Iyer 2668a3381e3aSUlf Hansson st = kcalloc(ret, sizeof(*st), GFP_KERNEL); 266930f60428SLina Iyer if (!st) 267030f60428SLina Iyer return -ENOMEM; 267130f60428SLina Iyer 2672a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, st); 2673a3381e3aSUlf Hansson if (ret <= 0) { 267430f60428SLina Iyer kfree(st); 2675a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 267630f60428SLina Iyer } 267730f60428SLina Iyer 267830f60428SLina Iyer *states = st; 2679a3381e3aSUlf Hansson *n = ret; 268030f60428SLina Iyer 268130f60428SLina Iyer return 0; 268230f60428SLina Iyer } 268330f60428SLina Iyer EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states); 268430f60428SLina Iyer 26856e41766aSViresh Kumar /** 2686e38f89d3SViresh Kumar * pm_genpd_opp_to_performance_state - Gets performance state of the genpd from its OPP node. 2687e38f89d3SViresh Kumar * 2688e38f89d3SViresh Kumar * @genpd_dev: Genpd's device for which the performance-state needs to be found. 2689e38f89d3SViresh Kumar * @opp: struct dev_pm_opp of the OPP for which we need to find performance 2690e38f89d3SViresh Kumar * state. 2691e38f89d3SViresh Kumar * 2692e38f89d3SViresh Kumar * Returns performance state encoded in the OPP of the genpd. This calls 2693e38f89d3SViresh Kumar * platform specific genpd->opp_to_performance_state() callback to translate 2694e38f89d3SViresh Kumar * power domain OPP to performance state. 2695e38f89d3SViresh Kumar * 2696e38f89d3SViresh Kumar * Returns performance state on success and 0 on failure. 2697e38f89d3SViresh Kumar */ 2698e38f89d3SViresh Kumar unsigned int pm_genpd_opp_to_performance_state(struct device *genpd_dev, 2699e38f89d3SViresh Kumar struct dev_pm_opp *opp) 2700e38f89d3SViresh Kumar { 2701e38f89d3SViresh Kumar struct generic_pm_domain *genpd = NULL; 2702e38f89d3SViresh Kumar int state; 2703e38f89d3SViresh Kumar 2704e38f89d3SViresh Kumar genpd = container_of(genpd_dev, struct generic_pm_domain, dev); 2705e38f89d3SViresh Kumar 2706e38f89d3SViresh Kumar if (unlikely(!genpd->opp_to_performance_state)) 2707e38f89d3SViresh Kumar return 0; 2708e38f89d3SViresh Kumar 2709e38f89d3SViresh Kumar genpd_lock(genpd); 2710e38f89d3SViresh Kumar state = genpd->opp_to_performance_state(genpd, opp); 2711e38f89d3SViresh Kumar genpd_unlock(genpd); 2712e38f89d3SViresh Kumar 2713e38f89d3SViresh Kumar return state; 2714e38f89d3SViresh Kumar } 2715e38f89d3SViresh Kumar EXPORT_SYMBOL_GPL(pm_genpd_opp_to_performance_state); 2716e38f89d3SViresh Kumar 27173c095f32SUlf Hansson static int __init genpd_bus_init(void) 27183c095f32SUlf Hansson { 27193c095f32SUlf Hansson return bus_register(&genpd_bus_type); 27203c095f32SUlf Hansson } 27213c095f32SUlf Hansson core_initcall(genpd_bus_init); 27223c095f32SUlf Hansson 2723d30d819dSRafael J. Wysocki #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */ 27242bd5306aSMaciej Matraszek 27252bd5306aSMaciej Matraszek 27262bd5306aSMaciej Matraszek /*** debugfs support ***/ 27272bd5306aSMaciej Matraszek 27288b0510b5SJon Hunter #ifdef CONFIG_DEBUG_FS 27292bd5306aSMaciej Matraszek #include <linux/pm.h> 27302bd5306aSMaciej Matraszek #include <linux/device.h> 27312bd5306aSMaciej Matraszek #include <linux/debugfs.h> 27322bd5306aSMaciej Matraszek #include <linux/seq_file.h> 27332bd5306aSMaciej Matraszek #include <linux/init.h> 27342bd5306aSMaciej Matraszek #include <linux/kobject.h> 27359e9704eaSUlf Hansson static struct dentry *genpd_debugfs_dir; 27362bd5306aSMaciej Matraszek 27372bd5306aSMaciej Matraszek /* 27382bd5306aSMaciej Matraszek * TODO: This function is a slightly modified version of rtpm_status_show 2739d30d819dSRafael J. Wysocki * from sysfs.c, so generalize it. 27402bd5306aSMaciej Matraszek */ 27412bd5306aSMaciej Matraszek static void rtpm_status_str(struct seq_file *s, struct device *dev) 27422bd5306aSMaciej Matraszek { 27432bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 27442bd5306aSMaciej Matraszek [RPM_ACTIVE] = "active", 27452bd5306aSMaciej Matraszek [RPM_RESUMING] = "resuming", 27462bd5306aSMaciej Matraszek [RPM_SUSPENDED] = "suspended", 27472bd5306aSMaciej Matraszek [RPM_SUSPENDING] = "suspending" 27482bd5306aSMaciej Matraszek }; 27492bd5306aSMaciej Matraszek const char *p = ""; 27502bd5306aSMaciej Matraszek 27512bd5306aSMaciej Matraszek if (dev->power.runtime_error) 27522bd5306aSMaciej Matraszek p = "error"; 27532bd5306aSMaciej Matraszek else if (dev->power.disable_depth) 27542bd5306aSMaciej Matraszek p = "unsupported"; 27552bd5306aSMaciej Matraszek else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup)) 27562bd5306aSMaciej Matraszek p = status_lookup[dev->power.runtime_status]; 27572bd5306aSMaciej Matraszek else 27582bd5306aSMaciej Matraszek WARN_ON(1); 27592bd5306aSMaciej Matraszek 27602bd5306aSMaciej Matraszek seq_puts(s, p); 27612bd5306aSMaciej Matraszek } 27622bd5306aSMaciej Matraszek 27639e9704eaSUlf Hansson static int genpd_summary_one(struct seq_file *s, 276466a5ca4bSKevin Hilman struct generic_pm_domain *genpd) 27652bd5306aSMaciej Matraszek { 27662bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 27672bd5306aSMaciej Matraszek [GPD_STATE_ACTIVE] = "on", 27682bd5306aSMaciej Matraszek [GPD_STATE_POWER_OFF] = "off" 27692bd5306aSMaciej Matraszek }; 27702bd5306aSMaciej Matraszek struct pm_domain_data *pm_data; 27712bd5306aSMaciej Matraszek const char *kobj_path; 27722bd5306aSMaciej Matraszek struct gpd_link *link; 27736954d432SGeert Uytterhoeven char state[16]; 27742bd5306aSMaciej Matraszek int ret; 27752bd5306aSMaciej Matraszek 277635241d12SLina Iyer ret = genpd_lock_interruptible(genpd); 27772bd5306aSMaciej Matraszek if (ret) 27782bd5306aSMaciej Matraszek return -ERESTARTSYS; 27792bd5306aSMaciej Matraszek 278066a5ca4bSKevin Hilman if (WARN_ON(genpd->status >= ARRAY_SIZE(status_lookup))) 27812bd5306aSMaciej Matraszek goto exit; 278241e2c8e0SUlf Hansson if (!genpd_status_on(genpd)) 27830ba554e4SGeert Uytterhoeven snprintf(state, sizeof(state), "%s-%u", 27846954d432SGeert Uytterhoeven status_lookup[genpd->status], genpd->state_idx); 2785fc5cbf0cSAxel Haslam else 27866954d432SGeert Uytterhoeven snprintf(state, sizeof(state), "%s", 27876954d432SGeert Uytterhoeven status_lookup[genpd->status]); 27886954d432SGeert Uytterhoeven seq_printf(s, "%-30s %-15s ", genpd->name, state); 27892bd5306aSMaciej Matraszek 27902bd5306aSMaciej Matraszek /* 27912bd5306aSMaciej Matraszek * Modifications on the list require holding locks on both 27922bd5306aSMaciej Matraszek * master and slave, so we are safe. 279366a5ca4bSKevin Hilman * Also genpd->name is immutable. 27942bd5306aSMaciej Matraszek */ 279566a5ca4bSKevin Hilman list_for_each_entry(link, &genpd->master_links, master_node) { 27962bd5306aSMaciej Matraszek seq_printf(s, "%s", link->slave->name); 279766a5ca4bSKevin Hilman if (!list_is_last(&link->master_node, &genpd->master_links)) 27982bd5306aSMaciej Matraszek seq_puts(s, ", "); 27992bd5306aSMaciej Matraszek } 28002bd5306aSMaciej Matraszek 280166a5ca4bSKevin Hilman list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2802d716f479SLina Iyer kobj_path = kobject_get_path(&pm_data->dev->kobj, 2803d716f479SLina Iyer genpd_is_irq_safe(genpd) ? 2804d716f479SLina Iyer GFP_ATOMIC : GFP_KERNEL); 28052bd5306aSMaciej Matraszek if (kobj_path == NULL) 28062bd5306aSMaciej Matraszek continue; 28072bd5306aSMaciej Matraszek 28082bd5306aSMaciej Matraszek seq_printf(s, "\n %-50s ", kobj_path); 28092bd5306aSMaciej Matraszek rtpm_status_str(s, pm_data->dev); 28102bd5306aSMaciej Matraszek kfree(kobj_path); 28112bd5306aSMaciej Matraszek } 28122bd5306aSMaciej Matraszek 28132bd5306aSMaciej Matraszek seq_puts(s, "\n"); 28142bd5306aSMaciej Matraszek exit: 281535241d12SLina Iyer genpd_unlock(genpd); 28162bd5306aSMaciej Matraszek 28172bd5306aSMaciej Matraszek return 0; 28182bd5306aSMaciej Matraszek } 28192bd5306aSMaciej Matraszek 2820d32dcc6cSYangtao Li static int summary_show(struct seq_file *s, void *data) 28212bd5306aSMaciej Matraszek { 282266a5ca4bSKevin Hilman struct generic_pm_domain *genpd; 28232bd5306aSMaciej Matraszek int ret = 0; 28242bd5306aSMaciej Matraszek 28252bd5306aSMaciej Matraszek seq_puts(s, "domain status slaves\n"); 28262bd5306aSMaciej Matraszek seq_puts(s, " /device runtime status\n"); 28272bd5306aSMaciej Matraszek seq_puts(s, "----------------------------------------------------------------------\n"); 28282bd5306aSMaciej Matraszek 28292bd5306aSMaciej Matraszek ret = mutex_lock_interruptible(&gpd_list_lock); 28302bd5306aSMaciej Matraszek if (ret) 28312bd5306aSMaciej Matraszek return -ERESTARTSYS; 28322bd5306aSMaciej Matraszek 283366a5ca4bSKevin Hilman list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 28349e9704eaSUlf Hansson ret = genpd_summary_one(s, genpd); 28352bd5306aSMaciej Matraszek if (ret) 28362bd5306aSMaciej Matraszek break; 28372bd5306aSMaciej Matraszek } 28382bd5306aSMaciej Matraszek mutex_unlock(&gpd_list_lock); 28392bd5306aSMaciej Matraszek 28402bd5306aSMaciej Matraszek return ret; 28412bd5306aSMaciej Matraszek } 28422bd5306aSMaciej Matraszek 2843d32dcc6cSYangtao Li static int status_show(struct seq_file *s, void *data) 28442bd5306aSMaciej Matraszek { 2845b6a1d093SThara Gopinath static const char * const status_lookup[] = { 2846b6a1d093SThara Gopinath [GPD_STATE_ACTIVE] = "on", 2847b6a1d093SThara Gopinath [GPD_STATE_POWER_OFF] = "off" 2848b6a1d093SThara Gopinath }; 2849b6a1d093SThara Gopinath 2850b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2851b6a1d093SThara Gopinath int ret = 0; 2852b6a1d093SThara Gopinath 2853b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2854b6a1d093SThara Gopinath if (ret) 2855b6a1d093SThara Gopinath return -ERESTARTSYS; 2856b6a1d093SThara Gopinath 2857b6a1d093SThara Gopinath if (WARN_ON_ONCE(genpd->status >= ARRAY_SIZE(status_lookup))) 2858b6a1d093SThara Gopinath goto exit; 2859b6a1d093SThara Gopinath 2860b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_POWER_OFF) 2861b6a1d093SThara Gopinath seq_printf(s, "%s-%u\n", status_lookup[genpd->status], 2862b6a1d093SThara Gopinath genpd->state_idx); 2863b6a1d093SThara Gopinath else 2864b6a1d093SThara Gopinath seq_printf(s, "%s\n", status_lookup[genpd->status]); 2865b6a1d093SThara Gopinath exit: 2866b6a1d093SThara Gopinath genpd_unlock(genpd); 2867b6a1d093SThara Gopinath return ret; 28682bd5306aSMaciej Matraszek } 28692bd5306aSMaciej Matraszek 2870d32dcc6cSYangtao Li static int sub_domains_show(struct seq_file *s, void *data) 2871b6a1d093SThara Gopinath { 2872b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2873b6a1d093SThara Gopinath struct gpd_link *link; 2874b6a1d093SThara Gopinath int ret = 0; 2875b6a1d093SThara Gopinath 2876b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2877b6a1d093SThara Gopinath if (ret) 2878b6a1d093SThara Gopinath return -ERESTARTSYS; 2879b6a1d093SThara Gopinath 2880b6a1d093SThara Gopinath list_for_each_entry(link, &genpd->master_links, master_node) 2881b6a1d093SThara Gopinath seq_printf(s, "%s\n", link->slave->name); 2882b6a1d093SThara Gopinath 2883b6a1d093SThara Gopinath genpd_unlock(genpd); 2884b6a1d093SThara Gopinath return ret; 2885b6a1d093SThara Gopinath } 2886b6a1d093SThara Gopinath 2887d32dcc6cSYangtao Li static int idle_states_show(struct seq_file *s, void *data) 2888b6a1d093SThara Gopinath { 2889b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2890b6a1d093SThara Gopinath unsigned int i; 2891b6a1d093SThara Gopinath int ret = 0; 2892b6a1d093SThara Gopinath 2893b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2894b6a1d093SThara Gopinath if (ret) 2895b6a1d093SThara Gopinath return -ERESTARTSYS; 2896b6a1d093SThara Gopinath 2897b6a1d093SThara Gopinath seq_puts(s, "State Time Spent(ms)\n"); 2898b6a1d093SThara Gopinath 2899b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2900b6a1d093SThara Gopinath ktime_t delta = 0; 2901b6a1d093SThara Gopinath s64 msecs; 2902b6a1d093SThara Gopinath 2903b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2904b6a1d093SThara Gopinath (genpd->state_idx == i)) 2905b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2906b6a1d093SThara Gopinath 2907b6a1d093SThara Gopinath msecs = ktime_to_ms( 2908b6a1d093SThara Gopinath ktime_add(genpd->states[i].idle_time, delta)); 2909b6a1d093SThara Gopinath seq_printf(s, "S%-13i %lld\n", i, msecs); 2910b6a1d093SThara Gopinath } 2911b6a1d093SThara Gopinath 2912b6a1d093SThara Gopinath genpd_unlock(genpd); 2913b6a1d093SThara Gopinath return ret; 2914b6a1d093SThara Gopinath } 2915b6a1d093SThara Gopinath 2916d32dcc6cSYangtao Li static int active_time_show(struct seq_file *s, void *data) 2917b6a1d093SThara Gopinath { 2918b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2919b6a1d093SThara Gopinath ktime_t delta = 0; 2920b6a1d093SThara Gopinath int ret = 0; 2921b6a1d093SThara Gopinath 2922b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2923b6a1d093SThara Gopinath if (ret) 2924b6a1d093SThara Gopinath return -ERESTARTSYS; 2925b6a1d093SThara Gopinath 2926b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) 2927b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2928b6a1d093SThara Gopinath 2929b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms( 2930b6a1d093SThara Gopinath ktime_add(genpd->on_time, delta))); 2931b6a1d093SThara Gopinath 2932b6a1d093SThara Gopinath genpd_unlock(genpd); 2933b6a1d093SThara Gopinath return ret; 2934b6a1d093SThara Gopinath } 2935b6a1d093SThara Gopinath 2936d32dcc6cSYangtao Li static int total_idle_time_show(struct seq_file *s, void *data) 2937b6a1d093SThara Gopinath { 2938b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2939b6a1d093SThara Gopinath ktime_t delta = 0, total = 0; 2940b6a1d093SThara Gopinath unsigned int i; 2941b6a1d093SThara Gopinath int ret = 0; 2942b6a1d093SThara Gopinath 2943b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2944b6a1d093SThara Gopinath if (ret) 2945b6a1d093SThara Gopinath return -ERESTARTSYS; 2946b6a1d093SThara Gopinath 2947b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2948b6a1d093SThara Gopinath 2949b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2950b6a1d093SThara Gopinath (genpd->state_idx == i)) 2951b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2952b6a1d093SThara Gopinath 2953b6a1d093SThara Gopinath total = ktime_add(total, genpd->states[i].idle_time); 2954b6a1d093SThara Gopinath } 2955b6a1d093SThara Gopinath total = ktime_add(total, delta); 2956b6a1d093SThara Gopinath 2957b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms(total)); 2958b6a1d093SThara Gopinath 2959b6a1d093SThara Gopinath genpd_unlock(genpd); 2960b6a1d093SThara Gopinath return ret; 2961b6a1d093SThara Gopinath } 2962b6a1d093SThara Gopinath 2963b6a1d093SThara Gopinath 2964d32dcc6cSYangtao Li static int devices_show(struct seq_file *s, void *data) 2965b6a1d093SThara Gopinath { 2966b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2967b6a1d093SThara Gopinath struct pm_domain_data *pm_data; 2968b6a1d093SThara Gopinath const char *kobj_path; 2969b6a1d093SThara Gopinath int ret = 0; 2970b6a1d093SThara Gopinath 2971b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2972b6a1d093SThara Gopinath if (ret) 2973b6a1d093SThara Gopinath return -ERESTARTSYS; 2974b6a1d093SThara Gopinath 2975b6a1d093SThara Gopinath list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2976b6a1d093SThara Gopinath kobj_path = kobject_get_path(&pm_data->dev->kobj, 2977b6a1d093SThara Gopinath genpd_is_irq_safe(genpd) ? 2978b6a1d093SThara Gopinath GFP_ATOMIC : GFP_KERNEL); 2979b6a1d093SThara Gopinath if (kobj_path == NULL) 2980b6a1d093SThara Gopinath continue; 2981b6a1d093SThara Gopinath 2982b6a1d093SThara Gopinath seq_printf(s, "%s\n", kobj_path); 2983b6a1d093SThara Gopinath kfree(kobj_path); 2984b6a1d093SThara Gopinath } 2985b6a1d093SThara Gopinath 2986b6a1d093SThara Gopinath genpd_unlock(genpd); 2987b6a1d093SThara Gopinath return ret; 2988b6a1d093SThara Gopinath } 2989b6a1d093SThara Gopinath 2990d32dcc6cSYangtao Li static int perf_state_show(struct seq_file *s, void *data) 2991e8912812SRajendra Nayak { 2992e8912812SRajendra Nayak struct generic_pm_domain *genpd = s->private; 2993e8912812SRajendra Nayak 2994e8912812SRajendra Nayak if (genpd_lock_interruptible(genpd)) 2995e8912812SRajendra Nayak return -ERESTARTSYS; 2996e8912812SRajendra Nayak 2997e8912812SRajendra Nayak seq_printf(s, "%u\n", genpd->performance_state); 2998e8912812SRajendra Nayak 2999e8912812SRajendra Nayak genpd_unlock(genpd); 3000e8912812SRajendra Nayak return 0; 3001e8912812SRajendra Nayak } 3002e8912812SRajendra Nayak 3003d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(summary); 3004d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(status); 3005d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(sub_domains); 3006d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(idle_states); 3007d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(active_time); 3008d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(total_idle_time); 3009d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(devices); 3010d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(perf_state); 30112bd5306aSMaciej Matraszek 30129e9704eaSUlf Hansson static int __init genpd_debug_init(void) 30132bd5306aSMaciej Matraszek { 30142bd5306aSMaciej Matraszek struct dentry *d; 3015b6a1d093SThara Gopinath struct generic_pm_domain *genpd; 30162bd5306aSMaciej Matraszek 30179e9704eaSUlf Hansson genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL); 30182bd5306aSMaciej Matraszek 3019e16a42c3SGreg Kroah-Hartman debugfs_create_file("pm_genpd_summary", S_IRUGO, genpd_debugfs_dir, 3020e16a42c3SGreg Kroah-Hartman NULL, &summary_fops); 30212bd5306aSMaciej Matraszek 3022b6a1d093SThara Gopinath list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 30239e9704eaSUlf Hansson d = debugfs_create_dir(genpd->name, genpd_debugfs_dir); 3024b6a1d093SThara Gopinath 3025b6a1d093SThara Gopinath debugfs_create_file("current_state", 0444, 3026d32dcc6cSYangtao Li d, genpd, &status_fops); 3027b6a1d093SThara Gopinath debugfs_create_file("sub_domains", 0444, 3028d32dcc6cSYangtao Li d, genpd, &sub_domains_fops); 3029b6a1d093SThara Gopinath debugfs_create_file("idle_states", 0444, 3030d32dcc6cSYangtao Li d, genpd, &idle_states_fops); 3031b6a1d093SThara Gopinath debugfs_create_file("active_time", 0444, 3032d32dcc6cSYangtao Li d, genpd, &active_time_fops); 3033b6a1d093SThara Gopinath debugfs_create_file("total_idle_time", 0444, 3034d32dcc6cSYangtao Li d, genpd, &total_idle_time_fops); 3035b6a1d093SThara Gopinath debugfs_create_file("devices", 0444, 3036d32dcc6cSYangtao Li d, genpd, &devices_fops); 3037e8912812SRajendra Nayak if (genpd->set_performance_state) 3038e8912812SRajendra Nayak debugfs_create_file("perf_state", 0444, 3039d32dcc6cSYangtao Li d, genpd, &perf_state_fops); 3040b6a1d093SThara Gopinath } 3041b6a1d093SThara Gopinath 30422bd5306aSMaciej Matraszek return 0; 30432bd5306aSMaciej Matraszek } 30449e9704eaSUlf Hansson late_initcall(genpd_debug_init); 30452bd5306aSMaciej Matraszek 30469e9704eaSUlf Hansson static void __exit genpd_debug_exit(void) 30472bd5306aSMaciej Matraszek { 30489e9704eaSUlf Hansson debugfs_remove_recursive(genpd_debugfs_dir); 30492bd5306aSMaciej Matraszek } 30509e9704eaSUlf Hansson __exitcall(genpd_debug_exit); 30518b0510b5SJon Hunter #endif /* CONFIG_DEBUG_FS */ 3052