1f721889fSRafael J. Wysocki /* 2f721889fSRafael J. Wysocki * drivers/base/power/domain.c - Common code related to device power domains. 3f721889fSRafael J. Wysocki * 4f721889fSRafael J. Wysocki * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. 5f721889fSRafael J. Wysocki * 6f721889fSRafael J. Wysocki * This file is released under the GPLv2. 7f721889fSRafael J. Wysocki */ 8f721889fSRafael J. Wysocki 97a5bd127SJoe Perches #define pr_fmt(fmt) "PM: " fmt 107a5bd127SJoe Perches 1193af5e93SGeert Uytterhoeven #include <linux/delay.h> 12f721889fSRafael J. Wysocki #include <linux/kernel.h> 13f721889fSRafael J. Wysocki #include <linux/io.h> 14aa42240aSTomasz Figa #include <linux/platform_device.h> 156a0ae73dSViresh Kumar #include <linux/pm_opp.h> 16f721889fSRafael J. Wysocki #include <linux/pm_runtime.h> 17f721889fSRafael J. Wysocki #include <linux/pm_domain.h> 186ff7bb0dSRafael J. Wysocki #include <linux/pm_qos.h> 19c11f6f5bSUlf Hansson #include <linux/pm_clock.h> 20f721889fSRafael J. Wysocki #include <linux/slab.h> 21f721889fSRafael J. Wysocki #include <linux/err.h> 2217b75ecaSRafael J. Wysocki #include <linux/sched.h> 2317b75ecaSRafael J. Wysocki #include <linux/suspend.h> 24d5e4cbfeSRafael J. Wysocki #include <linux/export.h> 25eb594b73SUlf Hansson #include <linux/cpu.h> 26d5e4cbfeSRafael J. Wysocki 27aa8e54b5STomeu Vizoso #include "power.h" 28aa8e54b5STomeu Vizoso 2993af5e93SGeert Uytterhoeven #define GENPD_RETRY_MAX_MS 250 /* Approximate */ 3093af5e93SGeert Uytterhoeven 31d5e4cbfeSRafael J. Wysocki #define GENPD_DEV_CALLBACK(genpd, type, callback, dev) \ 32d5e4cbfeSRafael J. Wysocki ({ \ 33d5e4cbfeSRafael J. Wysocki type (*__routine)(struct device *__d); \ 34d5e4cbfeSRafael J. Wysocki type __ret = (type)0; \ 35d5e4cbfeSRafael J. Wysocki \ 36d5e4cbfeSRafael J. Wysocki __routine = genpd->dev_ops.callback; \ 37d5e4cbfeSRafael J. Wysocki if (__routine) { \ 38d5e4cbfeSRafael J. Wysocki __ret = __routine(dev); \ 39d5e4cbfeSRafael J. Wysocki } \ 40d5e4cbfeSRafael J. Wysocki __ret; \ 41d5e4cbfeSRafael J. Wysocki }) 42f721889fSRafael J. Wysocki 435125bbf3SRafael J. Wysocki static LIST_HEAD(gpd_list); 445125bbf3SRafael J. Wysocki static DEFINE_MUTEX(gpd_list_lock); 455125bbf3SRafael J. Wysocki 4635241d12SLina Iyer struct genpd_lock_ops { 4735241d12SLina Iyer void (*lock)(struct generic_pm_domain *genpd); 4835241d12SLina Iyer void (*lock_nested)(struct generic_pm_domain *genpd, int depth); 4935241d12SLina Iyer int (*lock_interruptible)(struct generic_pm_domain *genpd); 5035241d12SLina Iyer void (*unlock)(struct generic_pm_domain *genpd); 5135241d12SLina Iyer }; 5235241d12SLina Iyer 5335241d12SLina Iyer static void genpd_lock_mtx(struct generic_pm_domain *genpd) 5435241d12SLina Iyer { 5535241d12SLina Iyer mutex_lock(&genpd->mlock); 5635241d12SLina Iyer } 5735241d12SLina Iyer 5835241d12SLina Iyer static void genpd_lock_nested_mtx(struct generic_pm_domain *genpd, 5935241d12SLina Iyer int depth) 6035241d12SLina Iyer { 6135241d12SLina Iyer mutex_lock_nested(&genpd->mlock, depth); 6235241d12SLina Iyer } 6335241d12SLina Iyer 6435241d12SLina Iyer static int genpd_lock_interruptible_mtx(struct generic_pm_domain *genpd) 6535241d12SLina Iyer { 6635241d12SLina Iyer return mutex_lock_interruptible(&genpd->mlock); 6735241d12SLina Iyer } 6835241d12SLina Iyer 6935241d12SLina Iyer static void genpd_unlock_mtx(struct generic_pm_domain *genpd) 7035241d12SLina Iyer { 7135241d12SLina Iyer return mutex_unlock(&genpd->mlock); 7235241d12SLina Iyer } 7335241d12SLina Iyer 7435241d12SLina Iyer static const struct genpd_lock_ops genpd_mtx_ops = { 7535241d12SLina Iyer .lock = genpd_lock_mtx, 7635241d12SLina Iyer .lock_nested = genpd_lock_nested_mtx, 7735241d12SLina Iyer .lock_interruptible = genpd_lock_interruptible_mtx, 7835241d12SLina Iyer .unlock = genpd_unlock_mtx, 7935241d12SLina Iyer }; 8035241d12SLina Iyer 81d716f479SLina Iyer static void genpd_lock_spin(struct generic_pm_domain *genpd) 82d716f479SLina Iyer __acquires(&genpd->slock) 83d716f479SLina Iyer { 84d716f479SLina Iyer unsigned long flags; 85d716f479SLina Iyer 86d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 87d716f479SLina Iyer genpd->lock_flags = flags; 88d716f479SLina Iyer } 89d716f479SLina Iyer 90d716f479SLina Iyer static void genpd_lock_nested_spin(struct generic_pm_domain *genpd, 91d716f479SLina Iyer int depth) 92d716f479SLina Iyer __acquires(&genpd->slock) 93d716f479SLina Iyer { 94d716f479SLina Iyer unsigned long flags; 95d716f479SLina Iyer 96d716f479SLina Iyer spin_lock_irqsave_nested(&genpd->slock, flags, depth); 97d716f479SLina Iyer genpd->lock_flags = flags; 98d716f479SLina Iyer } 99d716f479SLina Iyer 100d716f479SLina Iyer static int genpd_lock_interruptible_spin(struct generic_pm_domain *genpd) 101d716f479SLina Iyer __acquires(&genpd->slock) 102d716f479SLina Iyer { 103d716f479SLina Iyer unsigned long flags; 104d716f479SLina Iyer 105d716f479SLina Iyer spin_lock_irqsave(&genpd->slock, flags); 106d716f479SLina Iyer genpd->lock_flags = flags; 107d716f479SLina Iyer return 0; 108d716f479SLina Iyer } 109d716f479SLina Iyer 110d716f479SLina Iyer static void genpd_unlock_spin(struct generic_pm_domain *genpd) 111d716f479SLina Iyer __releases(&genpd->slock) 112d716f479SLina Iyer { 113d716f479SLina Iyer spin_unlock_irqrestore(&genpd->slock, genpd->lock_flags); 114d716f479SLina Iyer } 115d716f479SLina Iyer 116d716f479SLina Iyer static const struct genpd_lock_ops genpd_spin_ops = { 117d716f479SLina Iyer .lock = genpd_lock_spin, 118d716f479SLina Iyer .lock_nested = genpd_lock_nested_spin, 119d716f479SLina Iyer .lock_interruptible = genpd_lock_interruptible_spin, 120d716f479SLina Iyer .unlock = genpd_unlock_spin, 121d716f479SLina Iyer }; 122d716f479SLina Iyer 12335241d12SLina Iyer #define genpd_lock(p) p->lock_ops->lock(p) 12435241d12SLina Iyer #define genpd_lock_nested(p, d) p->lock_ops->lock_nested(p, d) 12535241d12SLina Iyer #define genpd_lock_interruptible(p) p->lock_ops->lock_interruptible(p) 12635241d12SLina Iyer #define genpd_unlock(p) p->lock_ops->unlock(p) 12735241d12SLina Iyer 12841e2c8e0SUlf Hansson #define genpd_status_on(genpd) (genpd->status == GPD_STATE_ACTIVE) 129d716f479SLina Iyer #define genpd_is_irq_safe(genpd) (genpd->flags & GENPD_FLAG_IRQ_SAFE) 130ffaa42e8SUlf Hansson #define genpd_is_always_on(genpd) (genpd->flags & GENPD_FLAG_ALWAYS_ON) 13195a20ef6SGeert Uytterhoeven #define genpd_is_active_wakeup(genpd) (genpd->flags & GENPD_FLAG_ACTIVE_WAKEUP) 132eb594b73SUlf Hansson #define genpd_is_cpu_domain(genpd) (genpd->flags & GENPD_FLAG_CPU_DOMAIN) 133d716f479SLina Iyer 134d716f479SLina Iyer static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev, 135d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 136d716f479SLina Iyer { 137d716f479SLina Iyer bool ret; 138d716f479SLina Iyer 139d716f479SLina Iyer ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd); 140d716f479SLina Iyer 141075c37d5SUlf Hansson /* 142075c37d5SUlf Hansson * Warn once if an IRQ safe device is attached to a no sleep domain, as 143075c37d5SUlf Hansson * to indicate a suboptimal configuration for PM. For an always on 144075c37d5SUlf Hansson * domain this isn't case, thus don't warn. 145075c37d5SUlf Hansson */ 146075c37d5SUlf Hansson if (ret && !genpd_is_always_on(genpd)) 147d716f479SLina Iyer dev_warn_once(dev, "PM domain %s will not be powered off\n", 148d716f479SLina Iyer genpd->name); 149d716f479SLina Iyer 150d716f479SLina Iyer return ret; 151d716f479SLina Iyer } 152d716f479SLina Iyer 153446d999cSRussell King /* 154446d999cSRussell King * Get the generic PM domain for a particular struct device. 155446d999cSRussell King * This validates the struct device pointer, the PM domain pointer, 156446d999cSRussell King * and checks that the PM domain pointer is a real generic PM domain. 157446d999cSRussell King * Any failure results in NULL being returned. 158446d999cSRussell King */ 159f58d4e5aSJon Hunter static struct generic_pm_domain *genpd_lookup_dev(struct device *dev) 160446d999cSRussell King { 161446d999cSRussell King struct generic_pm_domain *genpd = NULL, *gpd; 162446d999cSRussell King 163446d999cSRussell King if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain)) 164446d999cSRussell King return NULL; 165446d999cSRussell King 166446d999cSRussell King mutex_lock(&gpd_list_lock); 167446d999cSRussell King list_for_each_entry(gpd, &gpd_list, gpd_list_node) { 168446d999cSRussell King if (&gpd->domain == dev->pm_domain) { 169446d999cSRussell King genpd = gpd; 170446d999cSRussell King break; 171446d999cSRussell King } 172446d999cSRussell King } 173446d999cSRussell King mutex_unlock(&gpd_list_lock); 174446d999cSRussell King 175446d999cSRussell King return genpd; 176446d999cSRussell King } 177446d999cSRussell King 178446d999cSRussell King /* 179446d999cSRussell King * This should only be used where we are certain that the pm_domain 180446d999cSRussell King * attached to the device is a genpd domain. 181446d999cSRussell King */ 182446d999cSRussell King static struct generic_pm_domain *dev_to_genpd(struct device *dev) 1835248051bSRafael J. Wysocki { 1845248051bSRafael J. Wysocki if (IS_ERR_OR_NULL(dev->pm_domain)) 1855248051bSRafael J. Wysocki return ERR_PTR(-EINVAL); 1865248051bSRafael J. Wysocki 187596ba34bSRafael J. Wysocki return pd_to_genpd(dev->pm_domain); 1885248051bSRafael J. Wysocki } 189f721889fSRafael J. Wysocki 190d8600c8bSKrzysztof Kozlowski static int genpd_stop_dev(const struct generic_pm_domain *genpd, 191d8600c8bSKrzysztof Kozlowski struct device *dev) 192d5e4cbfeSRafael J. Wysocki { 19351cda844SUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, stop, dev); 194d5e4cbfeSRafael J. Wysocki } 195d5e4cbfeSRafael J. Wysocki 196d8600c8bSKrzysztof Kozlowski static int genpd_start_dev(const struct generic_pm_domain *genpd, 197d8600c8bSKrzysztof Kozlowski struct device *dev) 198d5e4cbfeSRafael J. Wysocki { 199ba2bbfbfSUlf Hansson return GENPD_DEV_CALLBACK(genpd, int, start, dev); 200d5e4cbfeSRafael J. Wysocki } 201d5e4cbfeSRafael J. Wysocki 202c4bb3160SRafael J. Wysocki static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd) 203f721889fSRafael J. Wysocki { 204c4bb3160SRafael J. Wysocki bool ret = false; 205c4bb3160SRafael J. Wysocki 206c4bb3160SRafael J. Wysocki if (!WARN_ON(atomic_read(&genpd->sd_count) == 0)) 207c4bb3160SRafael J. Wysocki ret = !!atomic_dec_and_test(&genpd->sd_count); 208c4bb3160SRafael J. Wysocki 209c4bb3160SRafael J. Wysocki return ret; 210c4bb3160SRafael J. Wysocki } 211c4bb3160SRafael J. Wysocki 212c4bb3160SRafael J. Wysocki static void genpd_sd_counter_inc(struct generic_pm_domain *genpd) 213c4bb3160SRafael J. Wysocki { 214c4bb3160SRafael J. Wysocki atomic_inc(&genpd->sd_count); 2154e857c58SPeter Zijlstra smp_mb__after_atomic(); 216f721889fSRafael J. Wysocki } 217f721889fSRafael J. Wysocki 218afece3abSThara Gopinath #ifdef CONFIG_DEBUG_FS 219afece3abSThara Gopinath static void genpd_update_accounting(struct generic_pm_domain *genpd) 220afece3abSThara Gopinath { 221afece3abSThara Gopinath ktime_t delta, now; 222afece3abSThara Gopinath 223afece3abSThara Gopinath now = ktime_get(); 224afece3abSThara Gopinath delta = ktime_sub(now, genpd->accounting_time); 225afece3abSThara Gopinath 226afece3abSThara Gopinath /* 227afece3abSThara Gopinath * If genpd->status is active, it means we are just 228afece3abSThara Gopinath * out of off and so update the idle time and vice 229afece3abSThara Gopinath * versa. 230afece3abSThara Gopinath */ 231afece3abSThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) { 232afece3abSThara Gopinath int state_idx = genpd->state_idx; 233afece3abSThara Gopinath 234afece3abSThara Gopinath genpd->states[state_idx].idle_time = 235afece3abSThara Gopinath ktime_add(genpd->states[state_idx].idle_time, delta); 236afece3abSThara Gopinath } else { 237afece3abSThara Gopinath genpd->on_time = ktime_add(genpd->on_time, delta); 238afece3abSThara Gopinath } 239afece3abSThara Gopinath 240afece3abSThara Gopinath genpd->accounting_time = now; 241afece3abSThara Gopinath } 242afece3abSThara Gopinath #else 243afece3abSThara Gopinath static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {} 244afece3abSThara Gopinath #endif 245afece3abSThara Gopinath 246cd50c6d3SViresh Kumar static int _genpd_reeval_performance_state(struct generic_pm_domain *genpd, 247cd50c6d3SViresh Kumar unsigned int state) 248cd50c6d3SViresh Kumar { 249cd50c6d3SViresh Kumar struct generic_pm_domain_data *pd_data; 250cd50c6d3SViresh Kumar struct pm_domain_data *pdd; 25118edf49cSViresh Kumar struct gpd_link *link; 252cd50c6d3SViresh Kumar 253cd50c6d3SViresh Kumar /* New requested state is same as Max requested state */ 254cd50c6d3SViresh Kumar if (state == genpd->performance_state) 255cd50c6d3SViresh Kumar return state; 256cd50c6d3SViresh Kumar 257cd50c6d3SViresh Kumar /* New requested state is higher than Max requested state */ 258cd50c6d3SViresh Kumar if (state > genpd->performance_state) 259cd50c6d3SViresh Kumar return state; 260cd50c6d3SViresh Kumar 261cd50c6d3SViresh Kumar /* Traverse all devices within the domain */ 262cd50c6d3SViresh Kumar list_for_each_entry(pdd, &genpd->dev_list, list_node) { 263cd50c6d3SViresh Kumar pd_data = to_gpd_data(pdd); 264cd50c6d3SViresh Kumar 265cd50c6d3SViresh Kumar if (pd_data->performance_state > state) 266cd50c6d3SViresh Kumar state = pd_data->performance_state; 267cd50c6d3SViresh Kumar } 268cd50c6d3SViresh Kumar 269cd50c6d3SViresh Kumar /* 27018edf49cSViresh Kumar * Traverse all sub-domains within the domain. This can be 27118edf49cSViresh Kumar * done without any additional locking as the link->performance_state 27218edf49cSViresh Kumar * field is protected by the master genpd->lock, which is already taken. 27318edf49cSViresh Kumar * 27418edf49cSViresh Kumar * Also note that link->performance_state (subdomain's performance state 27518edf49cSViresh Kumar * requirement to master domain) is different from 27618edf49cSViresh Kumar * link->slave->performance_state (current performance state requirement 27718edf49cSViresh Kumar * of the devices/sub-domains of the subdomain) and so can have a 27818edf49cSViresh Kumar * different value. 27918edf49cSViresh Kumar * 28018edf49cSViresh Kumar * Note that we also take vote from powered-off sub-domains into account 28118edf49cSViresh Kumar * as the same is done for devices right now. 282cd50c6d3SViresh Kumar */ 28318edf49cSViresh Kumar list_for_each_entry(link, &genpd->master_links, master_node) { 28418edf49cSViresh Kumar if (link->performance_state > state) 28518edf49cSViresh Kumar state = link->performance_state; 28618edf49cSViresh Kumar } 28718edf49cSViresh Kumar 288cd50c6d3SViresh Kumar return state; 289cd50c6d3SViresh Kumar } 290cd50c6d3SViresh Kumar 291cd50c6d3SViresh Kumar static int _genpd_set_performance_state(struct generic_pm_domain *genpd, 29218edf49cSViresh Kumar unsigned int state, int depth) 293cd50c6d3SViresh Kumar { 29418edf49cSViresh Kumar struct generic_pm_domain *master; 29518edf49cSViresh Kumar struct gpd_link *link; 29618edf49cSViresh Kumar int master_state, ret; 297cd50c6d3SViresh Kumar 298cd50c6d3SViresh Kumar if (state == genpd->performance_state) 299cd50c6d3SViresh Kumar return 0; 300cd50c6d3SViresh Kumar 30118edf49cSViresh Kumar /* Propagate to masters of genpd */ 30218edf49cSViresh Kumar list_for_each_entry(link, &genpd->slave_links, slave_node) { 30318edf49cSViresh Kumar master = link->master; 30418edf49cSViresh Kumar 30518edf49cSViresh Kumar if (!master->set_performance_state) 30618edf49cSViresh Kumar continue; 30718edf49cSViresh Kumar 30818edf49cSViresh Kumar /* Find master's performance state */ 30918edf49cSViresh Kumar ret = dev_pm_opp_xlate_performance_state(genpd->opp_table, 31018edf49cSViresh Kumar master->opp_table, 31118edf49cSViresh Kumar state); 31218edf49cSViresh Kumar if (unlikely(ret < 0)) 31318edf49cSViresh Kumar goto err; 31418edf49cSViresh Kumar 31518edf49cSViresh Kumar master_state = ret; 31618edf49cSViresh Kumar 31718edf49cSViresh Kumar genpd_lock_nested(master, depth + 1); 31818edf49cSViresh Kumar 31918edf49cSViresh Kumar link->prev_performance_state = link->performance_state; 32018edf49cSViresh Kumar link->performance_state = master_state; 32118edf49cSViresh Kumar master_state = _genpd_reeval_performance_state(master, 32218edf49cSViresh Kumar master_state); 32318edf49cSViresh Kumar ret = _genpd_set_performance_state(master, master_state, depth + 1); 32418edf49cSViresh Kumar if (ret) 32518edf49cSViresh Kumar link->performance_state = link->prev_performance_state; 32618edf49cSViresh Kumar 32718edf49cSViresh Kumar genpd_unlock(master); 32818edf49cSViresh Kumar 32918edf49cSViresh Kumar if (ret) 33018edf49cSViresh Kumar goto err; 33118edf49cSViresh Kumar } 33218edf49cSViresh Kumar 333cd50c6d3SViresh Kumar ret = genpd->set_performance_state(genpd, state); 334cd50c6d3SViresh Kumar if (ret) 33518edf49cSViresh Kumar goto err; 336cd50c6d3SViresh Kumar 337cd50c6d3SViresh Kumar genpd->performance_state = state; 338cd50c6d3SViresh Kumar return 0; 33918edf49cSViresh Kumar 34018edf49cSViresh Kumar err: 34118edf49cSViresh Kumar /* Encountered an error, lets rollback */ 34218edf49cSViresh Kumar list_for_each_entry_continue_reverse(link, &genpd->slave_links, 34318edf49cSViresh Kumar slave_node) { 34418edf49cSViresh Kumar master = link->master; 34518edf49cSViresh Kumar 34618edf49cSViresh Kumar if (!master->set_performance_state) 34718edf49cSViresh Kumar continue; 34818edf49cSViresh Kumar 34918edf49cSViresh Kumar genpd_lock_nested(master, depth + 1); 35018edf49cSViresh Kumar 35118edf49cSViresh Kumar master_state = link->prev_performance_state; 35218edf49cSViresh Kumar link->performance_state = master_state; 35318edf49cSViresh Kumar 35418edf49cSViresh Kumar master_state = _genpd_reeval_performance_state(master, 35518edf49cSViresh Kumar master_state); 35618edf49cSViresh Kumar if (_genpd_set_performance_state(master, master_state, depth + 1)) { 35718edf49cSViresh Kumar pr_err("%s: Failed to roll back to %d performance state\n", 35818edf49cSViresh Kumar master->name, master_state); 35918edf49cSViresh Kumar } 36018edf49cSViresh Kumar 36118edf49cSViresh Kumar genpd_unlock(master); 36218edf49cSViresh Kumar } 36318edf49cSViresh Kumar 36418edf49cSViresh Kumar return ret; 365cd50c6d3SViresh Kumar } 366cd50c6d3SViresh Kumar 36742f6284aSViresh Kumar /** 36842f6284aSViresh Kumar * dev_pm_genpd_set_performance_state- Set performance state of device's power 36942f6284aSViresh Kumar * domain. 37042f6284aSViresh Kumar * 37142f6284aSViresh Kumar * @dev: Device for which the performance-state needs to be set. 37242f6284aSViresh Kumar * @state: Target performance state of the device. This can be set as 0 when the 37342f6284aSViresh Kumar * device doesn't have any performance state constraints left (And so 37442f6284aSViresh Kumar * the device wouldn't participate anymore to find the target 37542f6284aSViresh Kumar * performance state of the genpd). 37642f6284aSViresh Kumar * 37742f6284aSViresh Kumar * It is assumed that the users guarantee that the genpd wouldn't be detached 37842f6284aSViresh Kumar * while this routine is getting called. 37942f6284aSViresh Kumar * 38042f6284aSViresh Kumar * Returns 0 on success and negative error values on failures. 38142f6284aSViresh Kumar */ 38242f6284aSViresh Kumar int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state) 38342f6284aSViresh Kumar { 38442f6284aSViresh Kumar struct generic_pm_domain *genpd; 385cd50c6d3SViresh Kumar struct generic_pm_domain_data *gpd_data; 38642f6284aSViresh Kumar unsigned int prev; 387cd50c6d3SViresh Kumar int ret; 38842f6284aSViresh Kumar 38942f6284aSViresh Kumar genpd = dev_to_genpd(dev); 39042f6284aSViresh Kumar if (IS_ERR(genpd)) 39142f6284aSViresh Kumar return -ENODEV; 39242f6284aSViresh Kumar 39342f6284aSViresh Kumar if (unlikely(!genpd->set_performance_state)) 39442f6284aSViresh Kumar return -EINVAL; 39542f6284aSViresh Kumar 396e757e7faSYangtao Li if (WARN_ON(!dev->power.subsys_data || 397e757e7faSYangtao Li !dev->power.subsys_data->domain_data)) 39842f6284aSViresh Kumar return -EINVAL; 39942f6284aSViresh Kumar 40042f6284aSViresh Kumar genpd_lock(genpd); 40142f6284aSViresh Kumar 40242f6284aSViresh Kumar gpd_data = to_gpd_data(dev->power.subsys_data->domain_data); 40342f6284aSViresh Kumar prev = gpd_data->performance_state; 40442f6284aSViresh Kumar gpd_data->performance_state = state; 40542f6284aSViresh Kumar 406cd50c6d3SViresh Kumar state = _genpd_reeval_performance_state(genpd, state); 40718edf49cSViresh Kumar ret = _genpd_set_performance_state(genpd, state, 0); 408cd50c6d3SViresh Kumar if (ret) 40942f6284aSViresh Kumar gpd_data->performance_state = prev; 41042f6284aSViresh Kumar 41142f6284aSViresh Kumar genpd_unlock(genpd); 41242f6284aSViresh Kumar 41342f6284aSViresh Kumar return ret; 41442f6284aSViresh Kumar } 41542f6284aSViresh Kumar EXPORT_SYMBOL_GPL(dev_pm_genpd_set_performance_state); 41642f6284aSViresh Kumar 41786e12eacSUlf Hansson static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) 418c8f0ea45SGeert Uytterhoeven { 419fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 420c8f0ea45SGeert Uytterhoeven ktime_t time_start; 421c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 422c8f0ea45SGeert Uytterhoeven int ret; 423c8f0ea45SGeert Uytterhoeven 424c8f0ea45SGeert Uytterhoeven if (!genpd->power_on) 425c8f0ea45SGeert Uytterhoeven return 0; 426c8f0ea45SGeert Uytterhoeven 427a4630c61SGeert Uytterhoeven if (!timed) 428a4630c61SGeert Uytterhoeven return genpd->power_on(genpd); 429a4630c61SGeert Uytterhoeven 430c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 431c8f0ea45SGeert Uytterhoeven ret = genpd->power_on(genpd); 432c8f0ea45SGeert Uytterhoeven if (ret) 433c8f0ea45SGeert Uytterhoeven return ret; 434c8f0ea45SGeert Uytterhoeven 435c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 436fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_on_latency_ns) 437c8f0ea45SGeert Uytterhoeven return ret; 438c8f0ea45SGeert Uytterhoeven 439fc5cbf0cSAxel Haslam genpd->states[state_idx].power_on_latency_ns = elapsed_ns; 440c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 4416d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 442c8f0ea45SGeert Uytterhoeven genpd->name, "on", elapsed_ns); 443c8f0ea45SGeert Uytterhoeven 444c8f0ea45SGeert Uytterhoeven return ret; 445c8f0ea45SGeert Uytterhoeven } 446c8f0ea45SGeert Uytterhoeven 44786e12eacSUlf Hansson static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed) 448c8f0ea45SGeert Uytterhoeven { 449fc5cbf0cSAxel Haslam unsigned int state_idx = genpd->state_idx; 450c8f0ea45SGeert Uytterhoeven ktime_t time_start; 451c8f0ea45SGeert Uytterhoeven s64 elapsed_ns; 452c8f0ea45SGeert Uytterhoeven int ret; 453c8f0ea45SGeert Uytterhoeven 454c8f0ea45SGeert Uytterhoeven if (!genpd->power_off) 455c8f0ea45SGeert Uytterhoeven return 0; 456c8f0ea45SGeert Uytterhoeven 457a4630c61SGeert Uytterhoeven if (!timed) 458a4630c61SGeert Uytterhoeven return genpd->power_off(genpd); 459a4630c61SGeert Uytterhoeven 460c8f0ea45SGeert Uytterhoeven time_start = ktime_get(); 461c8f0ea45SGeert Uytterhoeven ret = genpd->power_off(genpd); 4620cec68a9SAisheng Dong if (ret) 463c8f0ea45SGeert Uytterhoeven return ret; 464c8f0ea45SGeert Uytterhoeven 465c8f0ea45SGeert Uytterhoeven elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 466fc5cbf0cSAxel Haslam if (elapsed_ns <= genpd->states[state_idx].power_off_latency_ns) 4670cec68a9SAisheng Dong return 0; 468c8f0ea45SGeert Uytterhoeven 469fc5cbf0cSAxel Haslam genpd->states[state_idx].power_off_latency_ns = elapsed_ns; 470c8f0ea45SGeert Uytterhoeven genpd->max_off_time_changed = true; 4716d7d5c32SRussell King pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n", 472c8f0ea45SGeert Uytterhoeven genpd->name, "off", elapsed_ns); 473c8f0ea45SGeert Uytterhoeven 4740cec68a9SAisheng Dong return 0; 475c8f0ea45SGeert Uytterhoeven } 476c8f0ea45SGeert Uytterhoeven 477f721889fSRafael J. Wysocki /** 47886e12eacSUlf Hansson * genpd_queue_power_off_work - Queue up the execution of genpd_power_off(). 479a3d09c73SMoritz Fischer * @genpd: PM domain to power off. 48029e47e21SUlf Hansson * 48186e12eacSUlf Hansson * Queue up the execution of genpd_power_off() unless it's already been done 48229e47e21SUlf Hansson * before. 48329e47e21SUlf Hansson */ 48429e47e21SUlf Hansson static void genpd_queue_power_off_work(struct generic_pm_domain *genpd) 48529e47e21SUlf Hansson { 48629e47e21SUlf Hansson queue_work(pm_wq, &genpd->power_off_work); 48729e47e21SUlf Hansson } 48829e47e21SUlf Hansson 48929e47e21SUlf Hansson /** 4901f8728b7SUlf Hansson * genpd_power_off - Remove power from a given PM domain. 4911f8728b7SUlf Hansson * @genpd: PM domain to power down. 4923c64649dSUlf Hansson * @one_dev_on: If invoked from genpd's ->runtime_suspend|resume() callback, the 4933c64649dSUlf Hansson * RPM status of the releated device is in an intermediate state, not yet turned 4943c64649dSUlf Hansson * into RPM_SUSPENDED. This means genpd_power_off() must allow one device to not 4953c64649dSUlf Hansson * be RPM_SUSPENDED, while it tries to power off the PM domain. 4961f8728b7SUlf Hansson * 4971f8728b7SUlf Hansson * If all of the @genpd's devices have been suspended and all of its subdomains 4981f8728b7SUlf Hansson * have been powered down, remove power from @genpd. 4991f8728b7SUlf Hansson */ 5002da83545SUlf Hansson static int genpd_power_off(struct generic_pm_domain *genpd, bool one_dev_on, 5012da83545SUlf Hansson unsigned int depth) 5021f8728b7SUlf Hansson { 5031f8728b7SUlf Hansson struct pm_domain_data *pdd; 5041f8728b7SUlf Hansson struct gpd_link *link; 5051f8728b7SUlf Hansson unsigned int not_suspended = 0; 5061f8728b7SUlf Hansson 5071f8728b7SUlf Hansson /* 5081f8728b7SUlf Hansson * Do not try to power off the domain in the following situations: 5091f8728b7SUlf Hansson * (1) The domain is already in the "power off" state. 5101f8728b7SUlf Hansson * (2) System suspend is in progress. 5111f8728b7SUlf Hansson */ 51241e2c8e0SUlf Hansson if (!genpd_status_on(genpd) || genpd->prepared_count > 0) 5131f8728b7SUlf Hansson return 0; 5141f8728b7SUlf Hansson 515ffaa42e8SUlf Hansson /* 516ffaa42e8SUlf Hansson * Abort power off for the PM domain in the following situations: 517ffaa42e8SUlf Hansson * (1) The domain is configured as always on. 518ffaa42e8SUlf Hansson * (2) When the domain has a subdomain being powered on. 519ffaa42e8SUlf Hansson */ 520ffaa42e8SUlf Hansson if (genpd_is_always_on(genpd) || atomic_read(&genpd->sd_count) > 0) 5211f8728b7SUlf Hansson return -EBUSY; 5221f8728b7SUlf Hansson 5231f8728b7SUlf Hansson list_for_each_entry(pdd, &genpd->dev_list, list_node) { 5241f8728b7SUlf Hansson enum pm_qos_flags_status stat; 5251f8728b7SUlf Hansson 52620f97cafSRafael J. Wysocki stat = dev_pm_qos_flags(pdd->dev, PM_QOS_FLAG_NO_POWER_OFF); 5271f8728b7SUlf Hansson if (stat > PM_QOS_FLAGS_NONE) 5281f8728b7SUlf Hansson return -EBUSY; 5291f8728b7SUlf Hansson 5301f8728b7SUlf Hansson /* 5311f8728b7SUlf Hansson * Do not allow PM domain to be powered off, when an IRQ safe 5321f8728b7SUlf Hansson * device is part of a non-IRQ safe domain. 5331f8728b7SUlf Hansson */ 5341f8728b7SUlf Hansson if (!pm_runtime_suspended(pdd->dev) || 5351f8728b7SUlf Hansson irq_safe_dev_in_no_sleep_domain(pdd->dev, genpd)) 5361f8728b7SUlf Hansson not_suspended++; 5371f8728b7SUlf Hansson } 5381f8728b7SUlf Hansson 5393c64649dSUlf Hansson if (not_suspended > 1 || (not_suspended == 1 && !one_dev_on)) 5401f8728b7SUlf Hansson return -EBUSY; 5411f8728b7SUlf Hansson 5421f8728b7SUlf Hansson if (genpd->gov && genpd->gov->power_down_ok) { 5431f8728b7SUlf Hansson if (!genpd->gov->power_down_ok(&genpd->domain)) 5441f8728b7SUlf Hansson return -EAGAIN; 5451f8728b7SUlf Hansson } 5461f8728b7SUlf Hansson 5472c9b7f87SUlf Hansson /* Default to shallowest state. */ 5482c9b7f87SUlf Hansson if (!genpd->gov) 5492c9b7f87SUlf Hansson genpd->state_idx = 0; 5502c9b7f87SUlf Hansson 5511f8728b7SUlf Hansson if (genpd->power_off) { 5521f8728b7SUlf Hansson int ret; 5531f8728b7SUlf Hansson 5541f8728b7SUlf Hansson if (atomic_read(&genpd->sd_count) > 0) 5551f8728b7SUlf Hansson return -EBUSY; 5561f8728b7SUlf Hansson 5571f8728b7SUlf Hansson /* 5581f8728b7SUlf Hansson * If sd_count > 0 at this point, one of the subdomains hasn't 5591f8728b7SUlf Hansson * managed to call genpd_power_on() for the master yet after 5601f8728b7SUlf Hansson * incrementing it. In that case genpd_power_on() will wait 5611f8728b7SUlf Hansson * for us to drop the lock, so we can call .power_off() and let 5621f8728b7SUlf Hansson * the genpd_power_on() restore power for us (this shouldn't 5631f8728b7SUlf Hansson * happen very often). 5641f8728b7SUlf Hansson */ 5651f8728b7SUlf Hansson ret = _genpd_power_off(genpd, true); 5661f8728b7SUlf Hansson if (ret) 5671f8728b7SUlf Hansson return ret; 5681f8728b7SUlf Hansson } 5691f8728b7SUlf Hansson 5701f8728b7SUlf Hansson genpd->status = GPD_STATE_POWER_OFF; 571afece3abSThara Gopinath genpd_update_accounting(genpd); 5721f8728b7SUlf Hansson 5731f8728b7SUlf Hansson list_for_each_entry(link, &genpd->slave_links, slave_node) { 5741f8728b7SUlf Hansson genpd_sd_counter_dec(link->master); 5752da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 5762da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 5772da83545SUlf Hansson genpd_unlock(link->master); 5781f8728b7SUlf Hansson } 5791f8728b7SUlf Hansson 5801f8728b7SUlf Hansson return 0; 5811f8728b7SUlf Hansson } 5821f8728b7SUlf Hansson 5831f8728b7SUlf Hansson /** 58486e12eacSUlf Hansson * genpd_power_on - Restore power to a given PM domain and its masters. 5855248051bSRafael J. Wysocki * @genpd: PM domain to power up. 5860106ef51SMarek Szyprowski * @depth: nesting count for lockdep. 5875248051bSRafael J. Wysocki * 5885063ce15SRafael J. Wysocki * Restore power to @genpd and all of its masters so that it is possible to 5895248051bSRafael J. Wysocki * resume a device belonging to it. 5905248051bSRafael J. Wysocki */ 59186e12eacSUlf Hansson static int genpd_power_on(struct generic_pm_domain *genpd, unsigned int depth) 5925248051bSRafael J. Wysocki { 5935063ce15SRafael J. Wysocki struct gpd_link *link; 5945248051bSRafael J. Wysocki int ret = 0; 5955248051bSRafael J. Wysocki 59641e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 5973f241775SRafael J. Wysocki return 0; 5985248051bSRafael J. Wysocki 5995063ce15SRafael J. Wysocki /* 6005063ce15SRafael J. Wysocki * The list is guaranteed not to change while the loop below is being 6015063ce15SRafael J. Wysocki * executed, unless one of the masters' .power_on() callbacks fiddles 6025063ce15SRafael J. Wysocki * with it. 6035063ce15SRafael J. Wysocki */ 6045063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 6050106ef51SMarek Szyprowski struct generic_pm_domain *master = link->master; 6065248051bSRafael J. Wysocki 6070106ef51SMarek Szyprowski genpd_sd_counter_inc(master); 6080106ef51SMarek Szyprowski 60935241d12SLina Iyer genpd_lock_nested(master, depth + 1); 61086e12eacSUlf Hansson ret = genpd_power_on(master, depth + 1); 61135241d12SLina Iyer genpd_unlock(master); 6120106ef51SMarek Szyprowski 6135063ce15SRafael J. Wysocki if (ret) { 6140106ef51SMarek Szyprowski genpd_sd_counter_dec(master); 6159e08cf42SRafael J. Wysocki goto err; 6165248051bSRafael J. Wysocki } 6175063ce15SRafael J. Wysocki } 6185248051bSRafael J. Wysocki 61986e12eacSUlf Hansson ret = _genpd_power_on(genpd, true); 6209e08cf42SRafael J. Wysocki if (ret) 6219e08cf42SRafael J. Wysocki goto err; 6220140d8bdSRafael J. Wysocki 623ba2bbfbfSUlf Hansson genpd->status = GPD_STATE_ACTIVE; 624afece3abSThara Gopinath genpd_update_accounting(genpd); 625afece3abSThara Gopinath 6263f241775SRafael J. Wysocki return 0; 6279e08cf42SRafael J. Wysocki 6289e08cf42SRafael J. Wysocki err: 62929e47e21SUlf Hansson list_for_each_entry_continue_reverse(link, 63029e47e21SUlf Hansson &genpd->slave_links, 63129e47e21SUlf Hansson slave_node) { 6325063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 6332da83545SUlf Hansson genpd_lock_nested(link->master, depth + 1); 6342da83545SUlf Hansson genpd_power_off(link->master, false, depth + 1); 6352da83545SUlf Hansson genpd_unlock(link->master); 63629e47e21SUlf Hansson } 6379e08cf42SRafael J. Wysocki 6383f241775SRafael J. Wysocki return ret; 6393f241775SRafael J. Wysocki } 6403f241775SRafael J. Wysocki 6416ff7bb0dSRafael J. Wysocki static int genpd_dev_pm_qos_notifier(struct notifier_block *nb, 6426ff7bb0dSRafael J. Wysocki unsigned long val, void *ptr) 6436ff7bb0dSRafael J. Wysocki { 6446ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 6456ff7bb0dSRafael J. Wysocki struct device *dev; 6466ff7bb0dSRafael J. Wysocki 6476ff7bb0dSRafael J. Wysocki gpd_data = container_of(nb, struct generic_pm_domain_data, nb); 6486ff7bb0dSRafael J. Wysocki dev = gpd_data->base.dev; 6496ff7bb0dSRafael J. Wysocki 6506ff7bb0dSRafael J. Wysocki for (;;) { 6516ff7bb0dSRafael J. Wysocki struct generic_pm_domain *genpd; 6526ff7bb0dSRafael J. Wysocki struct pm_domain_data *pdd; 6536ff7bb0dSRafael J. Wysocki 6546ff7bb0dSRafael J. Wysocki spin_lock_irq(&dev->power.lock); 6556ff7bb0dSRafael J. Wysocki 6566ff7bb0dSRafael J. Wysocki pdd = dev->power.subsys_data ? 6576ff7bb0dSRafael J. Wysocki dev->power.subsys_data->domain_data : NULL; 658b4883ca4SViresh Kumar if (pdd) { 6596ff7bb0dSRafael J. Wysocki to_gpd_data(pdd)->td.constraint_changed = true; 6606ff7bb0dSRafael J. Wysocki genpd = dev_to_genpd(dev); 6616ff7bb0dSRafael J. Wysocki } else { 6626ff7bb0dSRafael J. Wysocki genpd = ERR_PTR(-ENODATA); 6636ff7bb0dSRafael J. Wysocki } 6646ff7bb0dSRafael J. Wysocki 6656ff7bb0dSRafael J. Wysocki spin_unlock_irq(&dev->power.lock); 6666ff7bb0dSRafael J. Wysocki 6676ff7bb0dSRafael J. Wysocki if (!IS_ERR(genpd)) { 66835241d12SLina Iyer genpd_lock(genpd); 6696ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 67035241d12SLina Iyer genpd_unlock(genpd); 6716ff7bb0dSRafael J. Wysocki } 6726ff7bb0dSRafael J. Wysocki 6736ff7bb0dSRafael J. Wysocki dev = dev->parent; 6746ff7bb0dSRafael J. Wysocki if (!dev || dev->power.ignore_children) 6756ff7bb0dSRafael J. Wysocki break; 6766ff7bb0dSRafael J. Wysocki } 6776ff7bb0dSRafael J. Wysocki 6786ff7bb0dSRafael J. Wysocki return NOTIFY_DONE; 6796ff7bb0dSRafael J. Wysocki } 6806ff7bb0dSRafael J. Wysocki 6815248051bSRafael J. Wysocki /** 682f721889fSRafael J. Wysocki * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0. 683f721889fSRafael J. Wysocki * @work: Work structure used for scheduling the execution of this function. 684f721889fSRafael J. Wysocki */ 685f721889fSRafael J. Wysocki static void genpd_power_off_work_fn(struct work_struct *work) 686f721889fSRafael J. Wysocki { 687f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 688f721889fSRafael J. Wysocki 689f721889fSRafael J. Wysocki genpd = container_of(work, struct generic_pm_domain, power_off_work); 690f721889fSRafael J. Wysocki 69135241d12SLina Iyer genpd_lock(genpd); 6922da83545SUlf Hansson genpd_power_off(genpd, false, 0); 69335241d12SLina Iyer genpd_unlock(genpd); 694f721889fSRafael J. Wysocki } 695f721889fSRafael J. Wysocki 696f721889fSRafael J. Wysocki /** 69754eeddbfSUlf Hansson * __genpd_runtime_suspend - walk the hierarchy of ->runtime_suspend() callbacks 69854eeddbfSUlf Hansson * @dev: Device to handle. 69954eeddbfSUlf Hansson */ 70054eeddbfSUlf Hansson static int __genpd_runtime_suspend(struct device *dev) 70154eeddbfSUlf Hansson { 70254eeddbfSUlf Hansson int (*cb)(struct device *__dev); 70354eeddbfSUlf Hansson 70454eeddbfSUlf Hansson if (dev->type && dev->type->pm) 70554eeddbfSUlf Hansson cb = dev->type->pm->runtime_suspend; 70654eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 70754eeddbfSUlf Hansson cb = dev->class->pm->runtime_suspend; 70854eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 70954eeddbfSUlf Hansson cb = dev->bus->pm->runtime_suspend; 71054eeddbfSUlf Hansson else 71154eeddbfSUlf Hansson cb = NULL; 71254eeddbfSUlf Hansson 71354eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 71454eeddbfSUlf Hansson cb = dev->driver->pm->runtime_suspend; 71554eeddbfSUlf Hansson 71654eeddbfSUlf Hansson return cb ? cb(dev) : 0; 71754eeddbfSUlf Hansson } 71854eeddbfSUlf Hansson 71954eeddbfSUlf Hansson /** 72054eeddbfSUlf Hansson * __genpd_runtime_resume - walk the hierarchy of ->runtime_resume() callbacks 72154eeddbfSUlf Hansson * @dev: Device to handle. 72254eeddbfSUlf Hansson */ 72354eeddbfSUlf Hansson static int __genpd_runtime_resume(struct device *dev) 72454eeddbfSUlf Hansson { 72554eeddbfSUlf Hansson int (*cb)(struct device *__dev); 72654eeddbfSUlf Hansson 72754eeddbfSUlf Hansson if (dev->type && dev->type->pm) 72854eeddbfSUlf Hansson cb = dev->type->pm->runtime_resume; 72954eeddbfSUlf Hansson else if (dev->class && dev->class->pm) 73054eeddbfSUlf Hansson cb = dev->class->pm->runtime_resume; 73154eeddbfSUlf Hansson else if (dev->bus && dev->bus->pm) 73254eeddbfSUlf Hansson cb = dev->bus->pm->runtime_resume; 73354eeddbfSUlf Hansson else 73454eeddbfSUlf Hansson cb = NULL; 73554eeddbfSUlf Hansson 73654eeddbfSUlf Hansson if (!cb && dev->driver && dev->driver->pm) 73754eeddbfSUlf Hansson cb = dev->driver->pm->runtime_resume; 73854eeddbfSUlf Hansson 73954eeddbfSUlf Hansson return cb ? cb(dev) : 0; 74054eeddbfSUlf Hansson } 74154eeddbfSUlf Hansson 74254eeddbfSUlf Hansson /** 743795bd2e7SUlf Hansson * genpd_runtime_suspend - Suspend a device belonging to I/O PM domain. 744f721889fSRafael J. Wysocki * @dev: Device to suspend. 745f721889fSRafael J. Wysocki * 746f721889fSRafael J. Wysocki * Carry out a runtime suspend of a device under the assumption that its 747f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 748f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 749f721889fSRafael J. Wysocki */ 750795bd2e7SUlf Hansson static int genpd_runtime_suspend(struct device *dev) 751f721889fSRafael J. Wysocki { 752f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 7539df3921eSUlf Hansson bool (*suspend_ok)(struct device *__dev); 7542b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 755ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 7562b1d88cdSUlf Hansson ktime_t time_start; 7572b1d88cdSUlf Hansson s64 elapsed_ns; 758d5e4cbfeSRafael J. Wysocki int ret; 759f721889fSRafael J. Wysocki 760f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 761f721889fSRafael J. Wysocki 7625248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 7635248051bSRafael J. Wysocki if (IS_ERR(genpd)) 764f721889fSRafael J. Wysocki return -EINVAL; 765f721889fSRafael J. Wysocki 766ffe12855SUlf Hansson /* 767ffe12855SUlf Hansson * A runtime PM centric subsystem/driver may re-use the runtime PM 768ffe12855SUlf Hansson * callbacks for other purposes than runtime PM. In those scenarios 769ffe12855SUlf Hansson * runtime PM is disabled. Under these circumstances, we shall skip 770ffe12855SUlf Hansson * validating/measuring the PM QoS latency. 771ffe12855SUlf Hansson */ 7729df3921eSUlf Hansson suspend_ok = genpd->gov ? genpd->gov->suspend_ok : NULL; 7739df3921eSUlf Hansson if (runtime_pm && suspend_ok && !suspend_ok(dev)) 774b02c999aSRafael J. Wysocki return -EBUSY; 775b02c999aSRafael J. Wysocki 7762b1d88cdSUlf Hansson /* Measure suspend latency. */ 777d33d5a6cSLinus Torvalds time_start = 0; 778ffe12855SUlf Hansson if (runtime_pm) 7792b1d88cdSUlf Hansson time_start = ktime_get(); 7802b1d88cdSUlf Hansson 78154eeddbfSUlf Hansson ret = __genpd_runtime_suspend(dev); 782f721889fSRafael J. Wysocki if (ret) 78317b75ecaSRafael J. Wysocki return ret; 78417b75ecaSRafael J. Wysocki 7852b1d88cdSUlf Hansson ret = genpd_stop_dev(genpd, dev); 786ba2bbfbfSUlf Hansson if (ret) { 78754eeddbfSUlf Hansson __genpd_runtime_resume(dev); 788ba2bbfbfSUlf Hansson return ret; 789ba2bbfbfSUlf Hansson } 790ba2bbfbfSUlf Hansson 7912b1d88cdSUlf Hansson /* Update suspend latency value if the measured time exceeds it. */ 792ffe12855SUlf Hansson if (runtime_pm) { 7932b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 7942b1d88cdSUlf Hansson if (elapsed_ns > td->suspend_latency_ns) { 7952b1d88cdSUlf Hansson td->suspend_latency_ns = elapsed_ns; 7962b1d88cdSUlf Hansson dev_dbg(dev, "suspend latency exceeded, %lld ns\n", 7972b1d88cdSUlf Hansson elapsed_ns); 7982b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 7992b1d88cdSUlf Hansson td->constraint_changed = true; 8002b1d88cdSUlf Hansson } 801ffe12855SUlf Hansson } 8022b1d88cdSUlf Hansson 8030aa2a221SRafael J. Wysocki /* 804d716f479SLina Iyer * If power.irq_safe is set, this routine may be run with 805d716f479SLina Iyer * IRQs disabled, so suspend only if the PM domain also is irq_safe. 8060aa2a221SRafael J. Wysocki */ 807d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) 8080aa2a221SRafael J. Wysocki return 0; 8090aa2a221SRafael J. Wysocki 81035241d12SLina Iyer genpd_lock(genpd); 8112da83545SUlf Hansson genpd_power_off(genpd, true, 0); 81235241d12SLina Iyer genpd_unlock(genpd); 813f721889fSRafael J. Wysocki 814f721889fSRafael J. Wysocki return 0; 815f721889fSRafael J. Wysocki } 816f721889fSRafael J. Wysocki 817f721889fSRafael J. Wysocki /** 818795bd2e7SUlf Hansson * genpd_runtime_resume - Resume a device belonging to I/O PM domain. 819f721889fSRafael J. Wysocki * @dev: Device to resume. 820f721889fSRafael J. Wysocki * 821f721889fSRafael J. Wysocki * Carry out a runtime resume of a device under the assumption that its 822f721889fSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 823f721889fSRafael J. Wysocki * struct generic_pm_domain representing a PM domain consisting of I/O devices. 824f721889fSRafael J. Wysocki */ 825795bd2e7SUlf Hansson static int genpd_runtime_resume(struct device *dev) 826f721889fSRafael J. Wysocki { 827f721889fSRafael J. Wysocki struct generic_pm_domain *genpd; 8282b1d88cdSUlf Hansson struct gpd_timing_data *td = &dev_gpd_data(dev)->td; 829ffe12855SUlf Hansson bool runtime_pm = pm_runtime_enabled(dev); 8302b1d88cdSUlf Hansson ktime_t time_start; 8312b1d88cdSUlf Hansson s64 elapsed_ns; 832f721889fSRafael J. Wysocki int ret; 833ba2bbfbfSUlf Hansson bool timed = true; 834f721889fSRafael J. Wysocki 835f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 836f721889fSRafael J. Wysocki 8375248051bSRafael J. Wysocki genpd = dev_to_genpd(dev); 8385248051bSRafael J. Wysocki if (IS_ERR(genpd)) 839f721889fSRafael J. Wysocki return -EINVAL; 840f721889fSRafael J. Wysocki 841d716f479SLina Iyer /* 842d716f479SLina Iyer * As we don't power off a non IRQ safe domain, which holds 843d716f479SLina Iyer * an IRQ safe device, we don't need to restore power to it. 844d716f479SLina Iyer */ 845d716f479SLina Iyer if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) { 846ba2bbfbfSUlf Hansson timed = false; 847ba2bbfbfSUlf Hansson goto out; 848ba2bbfbfSUlf Hansson } 8490aa2a221SRafael J. Wysocki 85035241d12SLina Iyer genpd_lock(genpd); 85186e12eacSUlf Hansson ret = genpd_power_on(genpd, 0); 85235241d12SLina Iyer genpd_unlock(genpd); 853ba2bbfbfSUlf Hansson 854ba2bbfbfSUlf Hansson if (ret) 8553f241775SRafael J. Wysocki return ret; 856c6d22b37SRafael J. Wysocki 857ba2bbfbfSUlf Hansson out: 8582b1d88cdSUlf Hansson /* Measure resume latency. */ 859ab51e6baSAugusto Mecking Caringi time_start = 0; 860ffe12855SUlf Hansson if (timed && runtime_pm) 8612b1d88cdSUlf Hansson time_start = ktime_get(); 8622b1d88cdSUlf Hansson 863076395caSLaurent Pinchart ret = genpd_start_dev(genpd, dev); 864076395caSLaurent Pinchart if (ret) 865076395caSLaurent Pinchart goto err_poweroff; 866076395caSLaurent Pinchart 86754eeddbfSUlf Hansson ret = __genpd_runtime_resume(dev); 868076395caSLaurent Pinchart if (ret) 869076395caSLaurent Pinchart goto err_stop; 8702b1d88cdSUlf Hansson 8712b1d88cdSUlf Hansson /* Update resume latency value if the measured time exceeds it. */ 872ffe12855SUlf Hansson if (timed && runtime_pm) { 8732b1d88cdSUlf Hansson elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start)); 8742b1d88cdSUlf Hansson if (elapsed_ns > td->resume_latency_ns) { 8752b1d88cdSUlf Hansson td->resume_latency_ns = elapsed_ns; 8762b1d88cdSUlf Hansson dev_dbg(dev, "resume latency exceeded, %lld ns\n", 8772b1d88cdSUlf Hansson elapsed_ns); 8782b1d88cdSUlf Hansson genpd->max_off_time_changed = true; 8792b1d88cdSUlf Hansson td->constraint_changed = true; 8802b1d88cdSUlf Hansson } 8812b1d88cdSUlf Hansson } 88217b75ecaSRafael J. Wysocki 883f721889fSRafael J. Wysocki return 0; 884076395caSLaurent Pinchart 885076395caSLaurent Pinchart err_stop: 886076395caSLaurent Pinchart genpd_stop_dev(genpd, dev); 887076395caSLaurent Pinchart err_poweroff: 888d716f479SLina Iyer if (!pm_runtime_is_irq_safe(dev) || 889d716f479SLina Iyer (pm_runtime_is_irq_safe(dev) && genpd_is_irq_safe(genpd))) { 89035241d12SLina Iyer genpd_lock(genpd); 8912da83545SUlf Hansson genpd_power_off(genpd, true, 0); 89235241d12SLina Iyer genpd_unlock(genpd); 893076395caSLaurent Pinchart } 894076395caSLaurent Pinchart 895076395caSLaurent Pinchart return ret; 896f721889fSRafael J. Wysocki } 897f721889fSRafael J. Wysocki 89839ac5ba5STushar Behera static bool pd_ignore_unused; 89939ac5ba5STushar Behera static int __init pd_ignore_unused_setup(char *__unused) 90039ac5ba5STushar Behera { 90139ac5ba5STushar Behera pd_ignore_unused = true; 90239ac5ba5STushar Behera return 1; 90339ac5ba5STushar Behera } 90439ac5ba5STushar Behera __setup("pd_ignore_unused", pd_ignore_unused_setup); 90539ac5ba5STushar Behera 90617f2ae7fSRafael J. Wysocki /** 90786e12eacSUlf Hansson * genpd_power_off_unused - Power off all PM domains with no devices in use. 90817f2ae7fSRafael J. Wysocki */ 90986e12eacSUlf Hansson static int __init genpd_power_off_unused(void) 91017f2ae7fSRafael J. Wysocki { 91117f2ae7fSRafael J. Wysocki struct generic_pm_domain *genpd; 91217f2ae7fSRafael J. Wysocki 91339ac5ba5STushar Behera if (pd_ignore_unused) { 91439ac5ba5STushar Behera pr_warn("genpd: Not disabling unused power domains\n"); 915bb4b72fcSUlf Hansson return 0; 91639ac5ba5STushar Behera } 91739ac5ba5STushar Behera 91817f2ae7fSRafael J. Wysocki mutex_lock(&gpd_list_lock); 91917f2ae7fSRafael J. Wysocki 92017f2ae7fSRafael J. Wysocki list_for_each_entry(genpd, &gpd_list, gpd_list_node) 92117f2ae7fSRafael J. Wysocki genpd_queue_power_off_work(genpd); 92217f2ae7fSRafael J. Wysocki 92317f2ae7fSRafael J. Wysocki mutex_unlock(&gpd_list_lock); 92417f2ae7fSRafael J. Wysocki 9252fe71dcdSUlf Hansson return 0; 9262fe71dcdSUlf Hansson } 92786e12eacSUlf Hansson late_initcall(genpd_power_off_unused); 9282fe71dcdSUlf Hansson 9290159ec67SJon Hunter #if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_GENERIC_DOMAINS_OF) 930596ba34bSRafael J. Wysocki 9319e9704eaSUlf Hansson static bool genpd_present(const struct generic_pm_domain *genpd) 93277f827deSRafael J. Wysocki { 933895b31f3SGeert Uytterhoeven const struct generic_pm_domain *gpd; 93477f827deSRafael J. Wysocki 93577f827deSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 93677f827deSRafael J. Wysocki return false; 93777f827deSRafael J. Wysocki 93877f827deSRafael J. Wysocki list_for_each_entry(gpd, &gpd_list, gpd_list_node) 93977f827deSRafael J. Wysocki if (gpd == genpd) 94077f827deSRafael J. Wysocki return true; 94177f827deSRafael J. Wysocki 94277f827deSRafael J. Wysocki return false; 94377f827deSRafael J. Wysocki } 94477f827deSRafael J. Wysocki 9450159ec67SJon Hunter #endif 9460159ec67SJon Hunter 9470159ec67SJon Hunter #ifdef CONFIG_PM_SLEEP 9480159ec67SJon Hunter 949596ba34bSRafael J. Wysocki /** 95086e12eacSUlf Hansson * genpd_sync_power_off - Synchronously power off a PM domain and its masters. 951596ba34bSRafael J. Wysocki * @genpd: PM domain to power off, if possible. 9520883ac03SUlf Hansson * @use_lock: use the lock. 9530883ac03SUlf Hansson * @depth: nesting count for lockdep. 954596ba34bSRafael J. Wysocki * 955596ba34bSRafael J. Wysocki * Check if the given PM domain can be powered off (during system suspend or 9565063ce15SRafael J. Wysocki * hibernation) and do that if so. Also, in that case propagate to its masters. 957596ba34bSRafael J. Wysocki * 95877f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 9590883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 9600883ac03SUlf Hansson * these cases the lock must be held. 961596ba34bSRafael J. Wysocki */ 9620883ac03SUlf Hansson static void genpd_sync_power_off(struct generic_pm_domain *genpd, bool use_lock, 9630883ac03SUlf Hansson unsigned int depth) 964596ba34bSRafael J. Wysocki { 9655063ce15SRafael J. Wysocki struct gpd_link *link; 966596ba34bSRafael J. Wysocki 967ffaa42e8SUlf Hansson if (!genpd_status_on(genpd) || genpd_is_always_on(genpd)) 968596ba34bSRafael J. Wysocki return; 969596ba34bSRafael J. Wysocki 970c4bb3160SRafael J. Wysocki if (genpd->suspended_count != genpd->device_count 971c4bb3160SRafael J. Wysocki || atomic_read(&genpd->sd_count) > 0) 972596ba34bSRafael J. Wysocki return; 973596ba34bSRafael J. Wysocki 974fc5cbf0cSAxel Haslam /* Choose the deepest state when suspending */ 975fc5cbf0cSAxel Haslam genpd->state_idx = genpd->state_count - 1; 9761c14967cSUlf Hansson if (_genpd_power_off(genpd, false)) 9771c14967cSUlf Hansson return; 978596ba34bSRafael J. Wysocki 97917b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 9805063ce15SRafael J. Wysocki 9815063ce15SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 9825063ce15SRafael J. Wysocki genpd_sd_counter_dec(link->master); 9830883ac03SUlf Hansson 9840883ac03SUlf Hansson if (use_lock) 9850883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 9860883ac03SUlf Hansson 9870883ac03SUlf Hansson genpd_sync_power_off(link->master, use_lock, depth + 1); 9880883ac03SUlf Hansson 9890883ac03SUlf Hansson if (use_lock) 9900883ac03SUlf Hansson genpd_unlock(link->master); 991596ba34bSRafael J. Wysocki } 992596ba34bSRafael J. Wysocki } 993596ba34bSRafael J. Wysocki 994596ba34bSRafael J. Wysocki /** 99586e12eacSUlf Hansson * genpd_sync_power_on - Synchronously power on a PM domain and its masters. 996802d8b49SRafael J. Wysocki * @genpd: PM domain to power on. 9970883ac03SUlf Hansson * @use_lock: use the lock. 9980883ac03SUlf Hansson * @depth: nesting count for lockdep. 999802d8b49SRafael J. Wysocki * 100077f827deSRafael J. Wysocki * This function is only called in "noirq" and "syscore" stages of system power 10010883ac03SUlf Hansson * transitions. The "noirq" callbacks may be executed asynchronously, thus in 10020883ac03SUlf Hansson * these cases the lock must be held. 1003802d8b49SRafael J. Wysocki */ 10040883ac03SUlf Hansson static void genpd_sync_power_on(struct generic_pm_domain *genpd, bool use_lock, 10050883ac03SUlf Hansson unsigned int depth) 1006802d8b49SRafael J. Wysocki { 1007802d8b49SRafael J. Wysocki struct gpd_link *link; 1008802d8b49SRafael J. Wysocki 100941e2c8e0SUlf Hansson if (genpd_status_on(genpd)) 1010802d8b49SRafael J. Wysocki return; 1011802d8b49SRafael J. Wysocki 1012802d8b49SRafael J. Wysocki list_for_each_entry(link, &genpd->slave_links, slave_node) { 1013802d8b49SRafael J. Wysocki genpd_sd_counter_inc(link->master); 10140883ac03SUlf Hansson 10150883ac03SUlf Hansson if (use_lock) 10160883ac03SUlf Hansson genpd_lock_nested(link->master, depth + 1); 10170883ac03SUlf Hansson 10180883ac03SUlf Hansson genpd_sync_power_on(link->master, use_lock, depth + 1); 10190883ac03SUlf Hansson 10200883ac03SUlf Hansson if (use_lock) 10210883ac03SUlf Hansson genpd_unlock(link->master); 1022802d8b49SRafael J. Wysocki } 1023802d8b49SRafael J. Wysocki 102486e12eacSUlf Hansson _genpd_power_on(genpd, false); 1025802d8b49SRafael J. Wysocki 1026802d8b49SRafael J. Wysocki genpd->status = GPD_STATE_ACTIVE; 1027802d8b49SRafael J. Wysocki } 1028802d8b49SRafael J. Wysocki 1029802d8b49SRafael J. Wysocki /** 10304ecd6e65SRafael J. Wysocki * resume_needed - Check whether to resume a device before system suspend. 10314ecd6e65SRafael J. Wysocki * @dev: Device to check. 10324ecd6e65SRafael J. Wysocki * @genpd: PM domain the device belongs to. 10334ecd6e65SRafael J. Wysocki * 10344ecd6e65SRafael J. Wysocki * There are two cases in which a device that can wake up the system from sleep 10359e9704eaSUlf Hansson * states should be resumed by genpd_prepare(): (1) if the device is enabled 10364ecd6e65SRafael J. Wysocki * to wake up the system and it has to remain active for this purpose while the 10374ecd6e65SRafael J. Wysocki * system is in the sleep state and (2) if the device is not enabled to wake up 10384ecd6e65SRafael J. Wysocki * the system from sleep states and it generally doesn't generate wakeup signals 10394ecd6e65SRafael J. Wysocki * by itself (those signals are generated on its behalf by other parts of the 10404ecd6e65SRafael J. Wysocki * system). In the latter case it may be necessary to reconfigure the device's 10414ecd6e65SRafael J. Wysocki * wakeup settings during system suspend, because it may have been set up to 10424ecd6e65SRafael J. Wysocki * signal remote wakeup from the system's working state as needed by runtime PM. 10434ecd6e65SRafael J. Wysocki * Return 'true' in either of the above cases. 10444ecd6e65SRafael J. Wysocki */ 1045d8600c8bSKrzysztof Kozlowski static bool resume_needed(struct device *dev, 1046d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd) 10474ecd6e65SRafael J. Wysocki { 10484ecd6e65SRafael J. Wysocki bool active_wakeup; 10494ecd6e65SRafael J. Wysocki 10504ecd6e65SRafael J. Wysocki if (!device_can_wakeup(dev)) 10514ecd6e65SRafael J. Wysocki return false; 10524ecd6e65SRafael J. Wysocki 1053d0af45f1SGeert Uytterhoeven active_wakeup = genpd_is_active_wakeup(genpd); 10544ecd6e65SRafael J. Wysocki return device_may_wakeup(dev) ? active_wakeup : !active_wakeup; 10554ecd6e65SRafael J. Wysocki } 10564ecd6e65SRafael J. Wysocki 10574ecd6e65SRafael J. Wysocki /** 10589e9704eaSUlf Hansson * genpd_prepare - Start power transition of a device in a PM domain. 1059596ba34bSRafael J. Wysocki * @dev: Device to start the transition of. 1060596ba34bSRafael J. Wysocki * 1061596ba34bSRafael J. Wysocki * Start a power transition of a device (during a system-wide power transition) 1062596ba34bSRafael J. Wysocki * under the assumption that its pm_domain field points to the domain member of 1063596ba34bSRafael J. Wysocki * an object of type struct generic_pm_domain representing a PM domain 1064596ba34bSRafael J. Wysocki * consisting of I/O devices. 1065596ba34bSRafael J. Wysocki */ 10669e9704eaSUlf Hansson static int genpd_prepare(struct device *dev) 1067596ba34bSRafael J. Wysocki { 1068596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1069b6c10c84SRafael J. Wysocki int ret; 1070596ba34bSRafael J. Wysocki 1071596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1072596ba34bSRafael J. Wysocki 1073596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1074596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1075596ba34bSRafael J. Wysocki return -EINVAL; 1076596ba34bSRafael J. Wysocki 107717b75ecaSRafael J. Wysocki /* 107817b75ecaSRafael J. Wysocki * If a wakeup request is pending for the device, it should be woken up 107917b75ecaSRafael J. Wysocki * at this point and a system wakeup event should be reported if it's 108017b75ecaSRafael J. Wysocki * set up to wake up the system from sleep states. 108117b75ecaSRafael J. Wysocki */ 10824ecd6e65SRafael J. Wysocki if (resume_needed(dev, genpd)) 10834ecd6e65SRafael J. Wysocki pm_runtime_resume(dev); 10844ecd6e65SRafael J. Wysocki 108535241d12SLina Iyer genpd_lock(genpd); 1086596ba34bSRafael J. Wysocki 108739dd0f23SUlf Hansson if (genpd->prepared_count++ == 0) 108865533bbfSRafael J. Wysocki genpd->suspended_count = 0; 108917b75ecaSRafael J. Wysocki 109035241d12SLina Iyer genpd_unlock(genpd); 1091596ba34bSRafael J. Wysocki 1092b6c10c84SRafael J. Wysocki ret = pm_generic_prepare(dev); 10935241ab40SUlf Hansson if (ret < 0) { 109435241d12SLina Iyer genpd_lock(genpd); 1095b6c10c84SRafael J. Wysocki 109639dd0f23SUlf Hansson genpd->prepared_count--; 1097b6c10c84SRafael J. Wysocki 109835241d12SLina Iyer genpd_unlock(genpd); 1099b6c10c84SRafael J. Wysocki } 110017b75ecaSRafael J. Wysocki 11015241ab40SUlf Hansson /* Never return 1, as genpd don't cope with the direct_complete path. */ 11025241ab40SUlf Hansson return ret >= 0 ? 0 : ret; 1103596ba34bSRafael J. Wysocki } 1104596ba34bSRafael J. Wysocki 1105596ba34bSRafael J. Wysocki /** 110610da6542SMikko Perttunen * genpd_finish_suspend - Completion of suspend or hibernation of device in an 110710da6542SMikko Perttunen * I/O pm domain. 11080496c8aeSRafael J. Wysocki * @dev: Device to suspend. 110910da6542SMikko Perttunen * @poweroff: Specifies if this is a poweroff_noirq or suspend_noirq callback. 11100496c8aeSRafael J. Wysocki * 11110496c8aeSRafael J. Wysocki * Stop the device and remove power from the domain if all devices in it have 11120496c8aeSRafael J. Wysocki * been stopped. 11130496c8aeSRafael J. Wysocki */ 111410da6542SMikko Perttunen static int genpd_finish_suspend(struct device *dev, bool poweroff) 11150496c8aeSRafael J. Wysocki { 11160496c8aeSRafael J. Wysocki struct generic_pm_domain *genpd; 1117a935424bSUlf Hansson int ret = 0; 1118596ba34bSRafael J. Wysocki 11190496c8aeSRafael J. Wysocki genpd = dev_to_genpd(dev); 11200496c8aeSRafael J. Wysocki if (IS_ERR(genpd)) 11210496c8aeSRafael J. Wysocki return -EINVAL; 11220496c8aeSRafael J. Wysocki 112310da6542SMikko Perttunen if (poweroff) 112410da6542SMikko Perttunen ret = pm_generic_poweroff_noirq(dev); 112510da6542SMikko Perttunen else 112610da6542SMikko Perttunen ret = pm_generic_suspend_noirq(dev); 112710da6542SMikko Perttunen if (ret) 112810da6542SMikko Perttunen return ret; 112910da6542SMikko Perttunen 1130a935424bSUlf Hansson if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1131a935424bSUlf Hansson return 0; 1132a935424bSUlf Hansson 113317218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 113417218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 113517218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1136a935424bSUlf Hansson if (ret) { 1137a935424bSUlf Hansson if (poweroff) 1138a935424bSUlf Hansson pm_generic_restore_noirq(dev); 1139a935424bSUlf Hansson else 1140a935424bSUlf Hansson pm_generic_resume_noirq(dev); 1141122a2237SUlf Hansson return ret; 1142122a2237SUlf Hansson } 1143a935424bSUlf Hansson } 1144122a2237SUlf Hansson 11450883ac03SUlf Hansson genpd_lock(genpd); 1146596ba34bSRafael J. Wysocki genpd->suspended_count++; 11470883ac03SUlf Hansson genpd_sync_power_off(genpd, true, 0); 11480883ac03SUlf Hansson genpd_unlock(genpd); 1149596ba34bSRafael J. Wysocki 1150596ba34bSRafael J. Wysocki return 0; 1151596ba34bSRafael J. Wysocki } 1152596ba34bSRafael J. Wysocki 1153596ba34bSRafael J. Wysocki /** 11549e9704eaSUlf Hansson * genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain. 115510da6542SMikko Perttunen * @dev: Device to suspend. 115610da6542SMikko Perttunen * 115710da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 115810da6542SMikko Perttunen * been stopped. 115910da6542SMikko Perttunen */ 11609e9704eaSUlf Hansson static int genpd_suspend_noirq(struct device *dev) 116110da6542SMikko Perttunen { 116210da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 116310da6542SMikko Perttunen 116410da6542SMikko Perttunen return genpd_finish_suspend(dev, false); 116510da6542SMikko Perttunen } 116610da6542SMikko Perttunen 116710da6542SMikko Perttunen /** 11689e9704eaSUlf Hansson * genpd_resume_noirq - Start of resume of device in an I/O PM domain. 1169596ba34bSRafael J. Wysocki * @dev: Device to resume. 1170596ba34bSRafael J. Wysocki * 11710496c8aeSRafael J. Wysocki * Restore power to the device's PM domain, if necessary, and start the device. 1172596ba34bSRafael J. Wysocki */ 11739e9704eaSUlf Hansson static int genpd_resume_noirq(struct device *dev) 1174596ba34bSRafael J. Wysocki { 1175596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1176a935424bSUlf Hansson int ret; 1177596ba34bSRafael J. Wysocki 1178596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1179596ba34bSRafael J. Wysocki 1180596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1181596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1182596ba34bSRafael J. Wysocki return -EINVAL; 1183596ba34bSRafael J. Wysocki 1184d0af45f1SGeert Uytterhoeven if (dev->power.wakeup_path && genpd_is_active_wakeup(genpd)) 1185a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1186596ba34bSRafael J. Wysocki 11870883ac03SUlf Hansson genpd_lock(genpd); 11880883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 1189596ba34bSRafael J. Wysocki genpd->suspended_count--; 11900883ac03SUlf Hansson genpd_unlock(genpd); 1191596ba34bSRafael J. Wysocki 119217218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 119317218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 119417218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 119510da6542SMikko Perttunen if (ret) 119610da6542SMikko Perttunen return ret; 1197a935424bSUlf Hansson } 119810da6542SMikko Perttunen 1199a935424bSUlf Hansson return pm_generic_resume_noirq(dev); 1200596ba34bSRafael J. Wysocki } 1201596ba34bSRafael J. Wysocki 1202596ba34bSRafael J. Wysocki /** 12039e9704eaSUlf Hansson * genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain. 1204596ba34bSRafael J. Wysocki * @dev: Device to freeze. 1205596ba34bSRafael J. Wysocki * 1206596ba34bSRafael J. Wysocki * Carry out a late freeze of a device under the assumption that its 1207596ba34bSRafael J. Wysocki * pm_domain field points to the domain member of an object of type 1208596ba34bSRafael J. Wysocki * struct generic_pm_domain representing a power domain consisting of I/O 1209596ba34bSRafael J. Wysocki * devices. 1210596ba34bSRafael J. Wysocki */ 12119e9704eaSUlf Hansson static int genpd_freeze_noirq(struct device *dev) 1212596ba34bSRafael J. Wysocki { 1213d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1214122a2237SUlf Hansson int ret = 0; 1215596ba34bSRafael J. Wysocki 1216596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1217596ba34bSRafael J. Wysocki 1218596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1219596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1220596ba34bSRafael J. Wysocki return -EINVAL; 1221596ba34bSRafael J. Wysocki 122210da6542SMikko Perttunen ret = pm_generic_freeze_noirq(dev); 122310da6542SMikko Perttunen if (ret) 122410da6542SMikko Perttunen return ret; 122510da6542SMikko Perttunen 122617218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 122717218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) 122817218e00SRafael J. Wysocki ret = genpd_stop_dev(genpd, dev); 1229122a2237SUlf Hansson 1230122a2237SUlf Hansson return ret; 1231596ba34bSRafael J. Wysocki } 1232596ba34bSRafael J. Wysocki 1233596ba34bSRafael J. Wysocki /** 12349e9704eaSUlf Hansson * genpd_thaw_noirq - Early thaw of device in an I/O PM domain. 1235596ba34bSRafael J. Wysocki * @dev: Device to thaw. 1236596ba34bSRafael J. Wysocki * 12370496c8aeSRafael J. Wysocki * Start the device, unless power has been removed from the domain already 12380496c8aeSRafael J. Wysocki * before the system transition. 1239596ba34bSRafael J. Wysocki */ 12409e9704eaSUlf Hansson static int genpd_thaw_noirq(struct device *dev) 1241596ba34bSRafael J. Wysocki { 1242d8600c8bSKrzysztof Kozlowski const struct generic_pm_domain *genpd; 1243122a2237SUlf Hansson int ret = 0; 1244596ba34bSRafael J. Wysocki 1245596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1246596ba34bSRafael J. Wysocki 1247596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1248596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1249596ba34bSRafael J. Wysocki return -EINVAL; 1250596ba34bSRafael J. Wysocki 125117218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 125217218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 125317218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 125410da6542SMikko Perttunen if (ret) 1255122a2237SUlf Hansson return ret; 12560496c8aeSRafael J. Wysocki } 1257596ba34bSRafael J. Wysocki 125810da6542SMikko Perttunen return pm_generic_thaw_noirq(dev); 125910da6542SMikko Perttunen } 126010da6542SMikko Perttunen 126110da6542SMikko Perttunen /** 12629e9704eaSUlf Hansson * genpd_poweroff_noirq - Completion of hibernation of device in an 126310da6542SMikko Perttunen * I/O PM domain. 126410da6542SMikko Perttunen * @dev: Device to poweroff. 126510da6542SMikko Perttunen * 126610da6542SMikko Perttunen * Stop the device and remove power from the domain if all devices in it have 126710da6542SMikko Perttunen * been stopped. 126810da6542SMikko Perttunen */ 12699e9704eaSUlf Hansson static int genpd_poweroff_noirq(struct device *dev) 127010da6542SMikko Perttunen { 127110da6542SMikko Perttunen dev_dbg(dev, "%s()\n", __func__); 127210da6542SMikko Perttunen 127310da6542SMikko Perttunen return genpd_finish_suspend(dev, true); 127410da6542SMikko Perttunen } 127510da6542SMikko Perttunen 12760496c8aeSRafael J. Wysocki /** 12779e9704eaSUlf Hansson * genpd_restore_noirq - Start of restore of device in an I/O PM domain. 1278596ba34bSRafael J. Wysocki * @dev: Device to resume. 1279596ba34bSRafael J. Wysocki * 12800496c8aeSRafael J. Wysocki * Make sure the domain will be in the same power state as before the 12810496c8aeSRafael J. Wysocki * hibernation the system is resuming from and start the device if necessary. 1282596ba34bSRafael J. Wysocki */ 12839e9704eaSUlf Hansson static int genpd_restore_noirq(struct device *dev) 1284596ba34bSRafael J. Wysocki { 1285596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1286122a2237SUlf Hansson int ret = 0; 1287596ba34bSRafael J. Wysocki 1288596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1289596ba34bSRafael J. Wysocki 1290596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1291596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1292596ba34bSRafael J. Wysocki return -EINVAL; 1293596ba34bSRafael J. Wysocki 1294596ba34bSRafael J. Wysocki /* 129565533bbfSRafael J. Wysocki * At this point suspended_count == 0 means we are being run for the 129665533bbfSRafael J. Wysocki * first time for the given domain in the present cycle. 129765533bbfSRafael J. Wysocki */ 12980883ac03SUlf Hansson genpd_lock(genpd); 129939dd0f23SUlf Hansson if (genpd->suspended_count++ == 0) 130065533bbfSRafael J. Wysocki /* 130165533bbfSRafael J. Wysocki * The boot kernel might put the domain into arbitrary state, 130286e12eacSUlf Hansson * so make it appear as powered off to genpd_sync_power_on(), 1303802d8b49SRafael J. Wysocki * so that it tries to power it on in case it was really off. 1304596ba34bSRafael J. Wysocki */ 130517b75ecaSRafael J. Wysocki genpd->status = GPD_STATE_POWER_OFF; 130618dd2eceSRafael J. Wysocki 13070883ac03SUlf Hansson genpd_sync_power_on(genpd, true, 0); 13080883ac03SUlf Hansson genpd_unlock(genpd); 1309596ba34bSRafael J. Wysocki 131017218e00SRafael J. Wysocki if (genpd->dev_ops.stop && genpd->dev_ops.start && 131117218e00SRafael J. Wysocki !pm_runtime_status_suspended(dev)) { 131217218e00SRafael J. Wysocki ret = genpd_start_dev(genpd, dev); 131310da6542SMikko Perttunen if (ret) 1314122a2237SUlf Hansson return ret; 1315596ba34bSRafael J. Wysocki } 1316596ba34bSRafael J. Wysocki 131710da6542SMikko Perttunen return pm_generic_restore_noirq(dev); 131810da6542SMikko Perttunen } 131910da6542SMikko Perttunen 1320596ba34bSRafael J. Wysocki /** 13219e9704eaSUlf Hansson * genpd_complete - Complete power transition of a device in a power domain. 1322596ba34bSRafael J. Wysocki * @dev: Device to complete the transition of. 1323596ba34bSRafael J. Wysocki * 1324596ba34bSRafael J. Wysocki * Complete a power transition of a device (during a system-wide power 1325596ba34bSRafael J. Wysocki * transition) under the assumption that its pm_domain field points to the 1326596ba34bSRafael J. Wysocki * domain member of an object of type struct generic_pm_domain representing 1327596ba34bSRafael J. Wysocki * a power domain consisting of I/O devices. 1328596ba34bSRafael J. Wysocki */ 13299e9704eaSUlf Hansson static void genpd_complete(struct device *dev) 1330596ba34bSRafael J. Wysocki { 1331596ba34bSRafael J. Wysocki struct generic_pm_domain *genpd; 1332596ba34bSRafael J. Wysocki 1333596ba34bSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1334596ba34bSRafael J. Wysocki 1335596ba34bSRafael J. Wysocki genpd = dev_to_genpd(dev); 1336596ba34bSRafael J. Wysocki if (IS_ERR(genpd)) 1337596ba34bSRafael J. Wysocki return; 1338596ba34bSRafael J. Wysocki 13394d23a5e8SUlf Hansson pm_generic_complete(dev); 13404d23a5e8SUlf Hansson 134135241d12SLina Iyer genpd_lock(genpd); 1342596ba34bSRafael J. Wysocki 134339dd0f23SUlf Hansson genpd->prepared_count--; 13444d23a5e8SUlf Hansson if (!genpd->prepared_count) 13454d23a5e8SUlf Hansson genpd_queue_power_off_work(genpd); 1346596ba34bSRafael J. Wysocki 134735241d12SLina Iyer genpd_unlock(genpd); 1348596ba34bSRafael J. Wysocki } 1349596ba34bSRafael J. Wysocki 135077f827deSRafael J. Wysocki /** 1351d47e6464SUlf Hansson * genpd_syscore_switch - Switch power during system core suspend or resume. 135277f827deSRafael J. Wysocki * @dev: Device that normally is marked as "always on" to switch power for. 135377f827deSRafael J. Wysocki * 135477f827deSRafael J. Wysocki * This routine may only be called during the system core (syscore) suspend or 135577f827deSRafael J. Wysocki * resume phase for devices whose "always on" flags are set. 135677f827deSRafael J. Wysocki */ 1357d47e6464SUlf Hansson static void genpd_syscore_switch(struct device *dev, bool suspend) 135877f827deSRafael J. Wysocki { 135977f827deSRafael J. Wysocki struct generic_pm_domain *genpd; 136077f827deSRafael J. Wysocki 136123c6d2c7SRafael J. Wysocki genpd = dev_to_genpd(dev); 13629e9704eaSUlf Hansson if (!genpd_present(genpd)) 136377f827deSRafael J. Wysocki return; 136477f827deSRafael J. Wysocki 136577f827deSRafael J. Wysocki if (suspend) { 136677f827deSRafael J. Wysocki genpd->suspended_count++; 13670883ac03SUlf Hansson genpd_sync_power_off(genpd, false, 0); 136877f827deSRafael J. Wysocki } else { 13690883ac03SUlf Hansson genpd_sync_power_on(genpd, false, 0); 137077f827deSRafael J. Wysocki genpd->suspended_count--; 137177f827deSRafael J. Wysocki } 137277f827deSRafael J. Wysocki } 1373d47e6464SUlf Hansson 1374d47e6464SUlf Hansson void pm_genpd_syscore_poweroff(struct device *dev) 1375d47e6464SUlf Hansson { 1376d47e6464SUlf Hansson genpd_syscore_switch(dev, true); 1377d47e6464SUlf Hansson } 1378d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff); 1379d47e6464SUlf Hansson 1380d47e6464SUlf Hansson void pm_genpd_syscore_poweron(struct device *dev) 1381d47e6464SUlf Hansson { 1382d47e6464SUlf Hansson genpd_syscore_switch(dev, false); 1383d47e6464SUlf Hansson } 1384d47e6464SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron); 138577f827deSRafael J. Wysocki 1386d30d819dSRafael J. Wysocki #else /* !CONFIG_PM_SLEEP */ 1387596ba34bSRafael J. Wysocki 13889e9704eaSUlf Hansson #define genpd_prepare NULL 13899e9704eaSUlf Hansson #define genpd_suspend_noirq NULL 13909e9704eaSUlf Hansson #define genpd_resume_noirq NULL 13919e9704eaSUlf Hansson #define genpd_freeze_noirq NULL 13929e9704eaSUlf Hansson #define genpd_thaw_noirq NULL 13939e9704eaSUlf Hansson #define genpd_poweroff_noirq NULL 13949e9704eaSUlf Hansson #define genpd_restore_noirq NULL 13959e9704eaSUlf Hansson #define genpd_complete NULL 1396596ba34bSRafael J. Wysocki 1397596ba34bSRafael J. Wysocki #endif /* CONFIG_PM_SLEEP */ 1398596ba34bSRafael J. Wysocki 1399a174920dSUlf Hansson static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev) 14001d5fcfecSRafael J. Wysocki { 14011d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 14023e235685SUlf Hansson int ret; 14033e235685SUlf Hansson 14043e235685SUlf Hansson ret = dev_pm_get_subsys_data(dev); 14053e235685SUlf Hansson if (ret) 14063e235685SUlf Hansson return ERR_PTR(ret); 14071d5fcfecSRafael J. Wysocki 14081d5fcfecSRafael J. Wysocki gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL); 14093e235685SUlf Hansson if (!gpd_data) { 14103e235685SUlf Hansson ret = -ENOMEM; 14113e235685SUlf Hansson goto err_put; 14123e235685SUlf Hansson } 14131d5fcfecSRafael J. Wysocki 1414f104e1e5SUlf Hansson gpd_data->base.dev = dev; 1415f104e1e5SUlf Hansson gpd_data->td.constraint_changed = true; 14160759e80bSRafael J. Wysocki gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS; 1417f104e1e5SUlf Hansson gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier; 1418f104e1e5SUlf Hansson 1419f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1420f104e1e5SUlf Hansson 1421f104e1e5SUlf Hansson if (dev->power.subsys_data->domain_data) { 1422f104e1e5SUlf Hansson ret = -EINVAL; 1423f104e1e5SUlf Hansson goto err_free; 1424f104e1e5SUlf Hansson } 1425f104e1e5SUlf Hansson 1426f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = &gpd_data->base; 1427f104e1e5SUlf Hansson 1428f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1429f104e1e5SUlf Hansson 14301d5fcfecSRafael J. Wysocki return gpd_data; 14313e235685SUlf Hansson 1432f104e1e5SUlf Hansson err_free: 1433f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1434f104e1e5SUlf Hansson kfree(gpd_data); 14353e235685SUlf Hansson err_put: 14363e235685SUlf Hansson dev_pm_put_subsys_data(dev); 14373e235685SUlf Hansson return ERR_PTR(ret); 14381d5fcfecSRafael J. Wysocki } 14391d5fcfecSRafael J. Wysocki 144049d400c7SUlf Hansson static void genpd_free_dev_data(struct device *dev, 14411d5fcfecSRafael J. Wysocki struct generic_pm_domain_data *gpd_data) 14421d5fcfecSRafael J. Wysocki { 1443f104e1e5SUlf Hansson spin_lock_irq(&dev->power.lock); 1444f104e1e5SUlf Hansson 1445f104e1e5SUlf Hansson dev->power.subsys_data->domain_data = NULL; 1446f104e1e5SUlf Hansson 1447f104e1e5SUlf Hansson spin_unlock_irq(&dev->power.lock); 1448f104e1e5SUlf Hansson 14491d5fcfecSRafael J. Wysocki kfree(gpd_data); 14503e235685SUlf Hansson dev_pm_put_subsys_data(dev); 14511d5fcfecSRafael J. Wysocki } 14521d5fcfecSRafael J. Wysocki 1453b24e1965SUlf Hansson static void genpd_update_cpumask(struct generic_pm_domain *genpd, 1454eb594b73SUlf Hansson int cpu, bool set, unsigned int depth) 1455eb594b73SUlf Hansson { 1456eb594b73SUlf Hansson struct gpd_link *link; 1457eb594b73SUlf Hansson 1458eb594b73SUlf Hansson if (!genpd_is_cpu_domain(genpd)) 1459eb594b73SUlf Hansson return; 1460eb594b73SUlf Hansson 1461eb594b73SUlf Hansson list_for_each_entry(link, &genpd->slave_links, slave_node) { 1462eb594b73SUlf Hansson struct generic_pm_domain *master = link->master; 1463eb594b73SUlf Hansson 1464eb594b73SUlf Hansson genpd_lock_nested(master, depth + 1); 1465b24e1965SUlf Hansson genpd_update_cpumask(master, cpu, set, depth + 1); 1466eb594b73SUlf Hansson genpd_unlock(master); 1467eb594b73SUlf Hansson } 1468eb594b73SUlf Hansson 1469eb594b73SUlf Hansson if (set) 1470eb594b73SUlf Hansson cpumask_set_cpu(cpu, genpd->cpus); 1471eb594b73SUlf Hansson else 1472eb594b73SUlf Hansson cpumask_clear_cpu(cpu, genpd->cpus); 1473eb594b73SUlf Hansson } 1474eb594b73SUlf Hansson 1475b24e1965SUlf Hansson static void genpd_set_cpumask(struct generic_pm_domain *genpd, int cpu) 1476b24e1965SUlf Hansson { 1477b24e1965SUlf Hansson if (cpu >= 0) 1478b24e1965SUlf Hansson genpd_update_cpumask(genpd, cpu, true, 0); 1479b24e1965SUlf Hansson } 1480b24e1965SUlf Hansson 1481b24e1965SUlf Hansson static void genpd_clear_cpumask(struct generic_pm_domain *genpd, int cpu) 1482b24e1965SUlf Hansson { 1483b24e1965SUlf Hansson if (cpu >= 0) 1484b24e1965SUlf Hansson genpd_update_cpumask(genpd, cpu, false, 0); 1485b24e1965SUlf Hansson } 1486b24e1965SUlf Hansson 1487b24e1965SUlf Hansson static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev) 1488eb594b73SUlf Hansson { 1489eb594b73SUlf Hansson int cpu; 1490eb594b73SUlf Hansson 1491eb594b73SUlf Hansson if (!genpd_is_cpu_domain(genpd)) 1492b24e1965SUlf Hansson return -1; 1493eb594b73SUlf Hansson 1494eb594b73SUlf Hansson for_each_possible_cpu(cpu) { 1495b24e1965SUlf Hansson if (get_cpu_device(cpu) == dev) 1496b24e1965SUlf Hansson return cpu; 1497eb594b73SUlf Hansson } 1498eb594b73SUlf Hansson 1499b24e1965SUlf Hansson return -1; 1500eb594b73SUlf Hansson } 1501eb594b73SUlf Hansson 1502a174920dSUlf Hansson static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev) 1503f721889fSRafael J. Wysocki { 1504c0356db7SUlf Hansson struct generic_pm_domain_data *gpd_data; 1505b24e1965SUlf Hansson int ret, cpu; 1506f721889fSRafael J. Wysocki 1507f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1508f721889fSRafael J. Wysocki 1509f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) 1510f721889fSRafael J. Wysocki return -EINVAL; 1511f721889fSRafael J. Wysocki 1512a174920dSUlf Hansson gpd_data = genpd_alloc_dev_data(dev); 15133e235685SUlf Hansson if (IS_ERR(gpd_data)) 15143e235685SUlf Hansson return PTR_ERR(gpd_data); 15156ff7bb0dSRafael J. Wysocki 1516b24e1965SUlf Hansson cpu = genpd_get_cpu(genpd, dev); 1517b24e1965SUlf Hansson 1518b472c2faSUlf Hansson ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0; 1519b472c2faSUlf Hansson if (ret) 1520b472c2faSUlf Hansson goto out; 1521d79b6fe1SGeert Uytterhoeven 15222071ac98SJiada Wang genpd_lock(genpd); 15232071ac98SJiada Wang 1524b24e1965SUlf Hansson genpd_set_cpumask(genpd, cpu); 1525975e83cfSSudeep Holla dev_pm_domain_set(dev, &genpd->domain); 1526975e83cfSSudeep Holla 152714b53064SUlf Hansson genpd->device_count++; 152814b53064SUlf Hansson genpd->max_off_time_changed = true; 152914b53064SUlf Hansson 15301d5fcfecSRafael J. Wysocki list_add_tail(&gpd_data->base.list_node, &genpd->dev_list); 15316ff7bb0dSRafael J. Wysocki 153235241d12SLina Iyer genpd_unlock(genpd); 15332071ac98SJiada Wang out: 1534c0356db7SUlf Hansson if (ret) 1535c0356db7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 1536c0356db7SUlf Hansson else 1537c0356db7SUlf Hansson dev_pm_qos_add_notifier(dev, &gpd_data->nb); 15381d5fcfecSRafael J. Wysocki 1539f721889fSRafael J. Wysocki return ret; 1540f721889fSRafael J. Wysocki } 154119efa5ffSJon Hunter 154219efa5ffSJon Hunter /** 15431a7a6707SUlf Hansson * pm_genpd_add_device - Add a device to an I/O PM domain. 154419efa5ffSJon Hunter * @genpd: PM domain to add the device to. 154519efa5ffSJon Hunter * @dev: Device to be added. 154619efa5ffSJon Hunter */ 15471a7a6707SUlf Hansson int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev) 154819efa5ffSJon Hunter { 154919efa5ffSJon Hunter int ret; 155019efa5ffSJon Hunter 155119efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 1552a174920dSUlf Hansson ret = genpd_add_device(genpd, dev); 155319efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 155419efa5ffSJon Hunter 155519efa5ffSJon Hunter return ret; 155619efa5ffSJon Hunter } 15571a7a6707SUlf Hansson EXPORT_SYMBOL_GPL(pm_genpd_add_device); 1558f721889fSRafael J. Wysocki 155985168d56SUlf Hansson static int genpd_remove_device(struct generic_pm_domain *genpd, 1560f721889fSRafael J. Wysocki struct device *dev) 1561f721889fSRafael J. Wysocki { 15626ff7bb0dSRafael J. Wysocki struct generic_pm_domain_data *gpd_data; 15634605ab65SRafael J. Wysocki struct pm_domain_data *pdd; 1564b24e1965SUlf Hansson int cpu, ret = 0; 1565f721889fSRafael J. Wysocki 1566f721889fSRafael J. Wysocki dev_dbg(dev, "%s()\n", __func__); 1567f721889fSRafael J. Wysocki 1568c0356db7SUlf Hansson pdd = dev->power.subsys_data->domain_data; 1569c0356db7SUlf Hansson gpd_data = to_gpd_data(pdd); 1570c0356db7SUlf Hansson dev_pm_qos_remove_notifier(dev, &gpd_data->nb); 1571b24e1965SUlf Hansson cpu = genpd_get_cpu(genpd, dev); 1572c0356db7SUlf Hansson 157335241d12SLina Iyer genpd_lock(genpd); 1574f721889fSRafael J. Wysocki 1575596ba34bSRafael J. Wysocki if (genpd->prepared_count > 0) { 1576596ba34bSRafael J. Wysocki ret = -EAGAIN; 1577596ba34bSRafael J. Wysocki goto out; 1578596ba34bSRafael J. Wysocki } 1579596ba34bSRafael J. Wysocki 15806ff7bb0dSRafael J. Wysocki genpd->device_count--; 15816ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 15826ff7bb0dSRafael J. Wysocki 1583b24e1965SUlf Hansson genpd_clear_cpumask(genpd, cpu); 1584975e83cfSSudeep Holla dev_pm_domain_set(dev, NULL); 1585975e83cfSSudeep Holla 1586efa69025SRafael J. Wysocki list_del_init(&pdd->list_node); 15876ff7bb0dSRafael J. Wysocki 158835241d12SLina Iyer genpd_unlock(genpd); 15896ff7bb0dSRafael J. Wysocki 15902071ac98SJiada Wang if (genpd->detach_dev) 15912071ac98SJiada Wang genpd->detach_dev(genpd, dev); 15922071ac98SJiada Wang 159349d400c7SUlf Hansson genpd_free_dev_data(dev, gpd_data); 15941d5fcfecSRafael J. Wysocki 15956ff7bb0dSRafael J. Wysocki return 0; 1596f721889fSRafael J. Wysocki 1597596ba34bSRafael J. Wysocki out: 159835241d12SLina Iyer genpd_unlock(genpd); 1599c0356db7SUlf Hansson dev_pm_qos_add_notifier(dev, &gpd_data->nb); 1600f721889fSRafael J. Wysocki 1601f721889fSRafael J. Wysocki return ret; 1602f721889fSRafael J. Wysocki } 160385168d56SUlf Hansson 160485168d56SUlf Hansson /** 160585168d56SUlf Hansson * pm_genpd_remove_device - Remove a device from an I/O PM domain. 160685168d56SUlf Hansson * @dev: Device to be removed. 160785168d56SUlf Hansson */ 1608924f4486SUlf Hansson int pm_genpd_remove_device(struct device *dev) 160985168d56SUlf Hansson { 1610924f4486SUlf Hansson struct generic_pm_domain *genpd = genpd_lookup_dev(dev); 1611924f4486SUlf Hansson 1612924f4486SUlf Hansson if (!genpd) 161385168d56SUlf Hansson return -EINVAL; 161485168d56SUlf Hansson 161585168d56SUlf Hansson return genpd_remove_device(genpd, dev); 161685168d56SUlf Hansson } 161724c96dc7SMaruthi Bayyavarapu EXPORT_SYMBOL_GPL(pm_genpd_remove_device); 1618f721889fSRafael J. Wysocki 161919efa5ffSJon Hunter static int genpd_add_subdomain(struct generic_pm_domain *genpd, 1620bc0403ffSRafael J. Wysocki struct generic_pm_domain *subdomain) 1621f721889fSRafael J. Wysocki { 16222547923dSLina Iyer struct gpd_link *link, *itr; 1623f721889fSRafael J. Wysocki int ret = 0; 1624f721889fSRafael J. Wysocki 1625fb7268beSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain) 1626fb7268beSRafael J. Wysocki || genpd == subdomain) 1627f721889fSRafael J. Wysocki return -EINVAL; 1628f721889fSRafael J. Wysocki 1629d716f479SLina Iyer /* 1630d716f479SLina Iyer * If the domain can be powered on/off in an IRQ safe 1631d716f479SLina Iyer * context, ensure that the subdomain can also be 1632d716f479SLina Iyer * powered on/off in that context. 1633d716f479SLina Iyer */ 1634d716f479SLina Iyer if (!genpd_is_irq_safe(genpd) && genpd_is_irq_safe(subdomain)) { 163544cae7d5SDan Carpenter WARN(1, "Parent %s of subdomain %s must be IRQ safe\n", 1636d716f479SLina Iyer genpd->name, subdomain->name); 1637d716f479SLina Iyer return -EINVAL; 1638d716f479SLina Iyer } 1639d716f479SLina Iyer 16402547923dSLina Iyer link = kzalloc(sizeof(*link), GFP_KERNEL); 16412547923dSLina Iyer if (!link) 16422547923dSLina Iyer return -ENOMEM; 16432547923dSLina Iyer 164435241d12SLina Iyer genpd_lock(subdomain); 164535241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1646f721889fSRafael J. Wysocki 164741e2c8e0SUlf Hansson if (!genpd_status_on(genpd) && genpd_status_on(subdomain)) { 1648f721889fSRafael J. Wysocki ret = -EINVAL; 1649f721889fSRafael J. Wysocki goto out; 1650f721889fSRafael J. Wysocki } 1651f721889fSRafael J. Wysocki 16522547923dSLina Iyer list_for_each_entry(itr, &genpd->master_links, master_node) { 16532547923dSLina Iyer if (itr->slave == subdomain && itr->master == genpd) { 1654f721889fSRafael J. Wysocki ret = -EINVAL; 1655f721889fSRafael J. Wysocki goto out; 1656f721889fSRafael J. Wysocki } 1657f721889fSRafael J. Wysocki } 1658f721889fSRafael J. Wysocki 16595063ce15SRafael J. Wysocki link->master = genpd; 16605063ce15SRafael J. Wysocki list_add_tail(&link->master_node, &genpd->master_links); 1661bc0403ffSRafael J. Wysocki link->slave = subdomain; 1662bc0403ffSRafael J. Wysocki list_add_tail(&link->slave_node, &subdomain->slave_links); 166341e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1664c4bb3160SRafael J. Wysocki genpd_sd_counter_inc(genpd); 1665f721889fSRafael J. Wysocki 1666f721889fSRafael J. Wysocki out: 166735241d12SLina Iyer genpd_unlock(genpd); 166835241d12SLina Iyer genpd_unlock(subdomain); 16692547923dSLina Iyer if (ret) 16702547923dSLina Iyer kfree(link); 1671f721889fSRafael J. Wysocki return ret; 1672f721889fSRafael J. Wysocki } 167319efa5ffSJon Hunter 167419efa5ffSJon Hunter /** 167519efa5ffSJon Hunter * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 167619efa5ffSJon Hunter * @genpd: Master PM domain to add the subdomain to. 167719efa5ffSJon Hunter * @subdomain: Subdomain to be added. 167819efa5ffSJon Hunter */ 167919efa5ffSJon Hunter int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, 168019efa5ffSJon Hunter struct generic_pm_domain *subdomain) 168119efa5ffSJon Hunter { 168219efa5ffSJon Hunter int ret; 168319efa5ffSJon Hunter 168419efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 168519efa5ffSJon Hunter ret = genpd_add_subdomain(genpd, subdomain); 168619efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 168719efa5ffSJon Hunter 168819efa5ffSJon Hunter return ret; 168919efa5ffSJon Hunter } 1690d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_add_subdomain); 1691f721889fSRafael J. Wysocki 1692f721889fSRafael J. Wysocki /** 1693f721889fSRafael J. Wysocki * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain. 1694f721889fSRafael J. Wysocki * @genpd: Master PM domain to remove the subdomain from. 16955063ce15SRafael J. Wysocki * @subdomain: Subdomain to be removed. 1696f721889fSRafael J. Wysocki */ 1697f721889fSRafael J. Wysocki int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, 16985063ce15SRafael J. Wysocki struct generic_pm_domain *subdomain) 1699f721889fSRafael J. Wysocki { 1700c6e83cacSKrzysztof Kozlowski struct gpd_link *l, *link; 1701f721889fSRafael J. Wysocki int ret = -EINVAL; 1702f721889fSRafael J. Wysocki 17035063ce15SRafael J. Wysocki if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)) 1704f721889fSRafael J. Wysocki return -EINVAL; 1705f721889fSRafael J. Wysocki 170635241d12SLina Iyer genpd_lock(subdomain); 170735241d12SLina Iyer genpd_lock_nested(genpd, SINGLE_DEPTH_NESTING); 1708f721889fSRafael J. Wysocki 1709beda5fc1SJon Hunter if (!list_empty(&subdomain->master_links) || subdomain->device_count) { 17107a5bd127SJoe Perches pr_warn("%s: unable to remove subdomain %s\n", 17117a5bd127SJoe Perches genpd->name, subdomain->name); 171230e7a65bSJon Hunter ret = -EBUSY; 171330e7a65bSJon Hunter goto out; 171430e7a65bSJon Hunter } 171530e7a65bSJon Hunter 1716c6e83cacSKrzysztof Kozlowski list_for_each_entry_safe(link, l, &genpd->master_links, master_node) { 17175063ce15SRafael J. Wysocki if (link->slave != subdomain) 1718f721889fSRafael J. Wysocki continue; 1719f721889fSRafael J. Wysocki 17205063ce15SRafael J. Wysocki list_del(&link->master_node); 17215063ce15SRafael J. Wysocki list_del(&link->slave_node); 17225063ce15SRafael J. Wysocki kfree(link); 172341e2c8e0SUlf Hansson if (genpd_status_on(subdomain)) 1724f721889fSRafael J. Wysocki genpd_sd_counter_dec(genpd); 1725f721889fSRafael J. Wysocki 1726f721889fSRafael J. Wysocki ret = 0; 1727f721889fSRafael J. Wysocki break; 1728f721889fSRafael J. Wysocki } 1729f721889fSRafael J. Wysocki 173030e7a65bSJon Hunter out: 173135241d12SLina Iyer genpd_unlock(genpd); 173235241d12SLina Iyer genpd_unlock(subdomain); 1733f721889fSRafael J. Wysocki 1734f721889fSRafael J. Wysocki return ret; 1735f721889fSRafael J. Wysocki } 1736d60ee966SStephen Boyd EXPORT_SYMBOL_GPL(pm_genpd_remove_subdomain); 1737f721889fSRafael J. Wysocki 173849a27e27SUlf Hansson static void genpd_free_default_power_state(struct genpd_power_state *states, 173949a27e27SUlf Hansson unsigned int state_count) 174049a27e27SUlf Hansson { 174149a27e27SUlf Hansson kfree(states); 174249a27e27SUlf Hansson } 174349a27e27SUlf Hansson 174459d65b73SLina Iyer static int genpd_set_default_power_state(struct generic_pm_domain *genpd) 174559d65b73SLina Iyer { 174659d65b73SLina Iyer struct genpd_power_state *state; 174759d65b73SLina Iyer 174859d65b73SLina Iyer state = kzalloc(sizeof(*state), GFP_KERNEL); 174959d65b73SLina Iyer if (!state) 175059d65b73SLina Iyer return -ENOMEM; 175159d65b73SLina Iyer 175259d65b73SLina Iyer genpd->states = state; 175359d65b73SLina Iyer genpd->state_count = 1; 175449a27e27SUlf Hansson genpd->free_states = genpd_free_default_power_state; 175559d65b73SLina Iyer 175659d65b73SLina Iyer return 0; 175759d65b73SLina Iyer } 175859d65b73SLina Iyer 1759d716f479SLina Iyer static void genpd_lock_init(struct generic_pm_domain *genpd) 1760d716f479SLina Iyer { 1761d716f479SLina Iyer if (genpd->flags & GENPD_FLAG_IRQ_SAFE) { 1762d716f479SLina Iyer spin_lock_init(&genpd->slock); 1763d716f479SLina Iyer genpd->lock_ops = &genpd_spin_ops; 1764d716f479SLina Iyer } else { 1765d716f479SLina Iyer mutex_init(&genpd->mlock); 1766d716f479SLina Iyer genpd->lock_ops = &genpd_mtx_ops; 1767d716f479SLina Iyer } 1768d716f479SLina Iyer } 1769d716f479SLina Iyer 1770d23b9b00SRafael J. Wysocki /** 1771f721889fSRafael J. Wysocki * pm_genpd_init - Initialize a generic I/O PM domain object. 1772f721889fSRafael J. Wysocki * @genpd: PM domain object to initialize. 1773f721889fSRafael J. Wysocki * @gov: PM domain governor to associate with the domain (may be NULL). 1774f721889fSRafael J. Wysocki * @is_off: Initial value of the domain's power_is_off field. 17757eb231c3SUlf Hansson * 17767eb231c3SUlf Hansson * Returns 0 on successful initialization, else a negative error code. 1777f721889fSRafael J. Wysocki */ 17787eb231c3SUlf Hansson int pm_genpd_init(struct generic_pm_domain *genpd, 1779f721889fSRafael J. Wysocki struct dev_power_governor *gov, bool is_off) 1780f721889fSRafael J. Wysocki { 178159d65b73SLina Iyer int ret; 178259d65b73SLina Iyer 1783f721889fSRafael J. Wysocki if (IS_ERR_OR_NULL(genpd)) 17847eb231c3SUlf Hansson return -EINVAL; 1785f721889fSRafael J. Wysocki 17865063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->master_links); 17875063ce15SRafael J. Wysocki INIT_LIST_HEAD(&genpd->slave_links); 1788f721889fSRafael J. Wysocki INIT_LIST_HEAD(&genpd->dev_list); 1789d716f479SLina Iyer genpd_lock_init(genpd); 1790f721889fSRafael J. Wysocki genpd->gov = gov; 1791f721889fSRafael J. Wysocki INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn); 1792c4bb3160SRafael J. Wysocki atomic_set(&genpd->sd_count, 0); 179317b75ecaSRafael J. Wysocki genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE; 1794596ba34bSRafael J. Wysocki genpd->device_count = 0; 1795221e9b58SRafael J. Wysocki genpd->max_off_time_ns = -1; 17966ff7bb0dSRafael J. Wysocki genpd->max_off_time_changed = true; 1797de0aa06dSJon Hunter genpd->provider = NULL; 1798de0aa06dSJon Hunter genpd->has_provider = false; 1799afece3abSThara Gopinath genpd->accounting_time = ktime_get(); 1800795bd2e7SUlf Hansson genpd->domain.ops.runtime_suspend = genpd_runtime_suspend; 1801795bd2e7SUlf Hansson genpd->domain.ops.runtime_resume = genpd_runtime_resume; 18029e9704eaSUlf Hansson genpd->domain.ops.prepare = genpd_prepare; 18039e9704eaSUlf Hansson genpd->domain.ops.suspend_noirq = genpd_suspend_noirq; 18049e9704eaSUlf Hansson genpd->domain.ops.resume_noirq = genpd_resume_noirq; 18059e9704eaSUlf Hansson genpd->domain.ops.freeze_noirq = genpd_freeze_noirq; 18069e9704eaSUlf Hansson genpd->domain.ops.thaw_noirq = genpd_thaw_noirq; 18079e9704eaSUlf Hansson genpd->domain.ops.poweroff_noirq = genpd_poweroff_noirq; 18089e9704eaSUlf Hansson genpd->domain.ops.restore_noirq = genpd_restore_noirq; 18099e9704eaSUlf Hansson genpd->domain.ops.complete = genpd_complete; 1810c11f6f5bSUlf Hansson 1811c11f6f5bSUlf Hansson if (genpd->flags & GENPD_FLAG_PM_CLK) { 1812c11f6f5bSUlf Hansson genpd->dev_ops.stop = pm_clk_suspend; 1813c11f6f5bSUlf Hansson genpd->dev_ops.start = pm_clk_resume; 1814c11f6f5bSUlf Hansson } 1815c11f6f5bSUlf Hansson 1816ffaa42e8SUlf Hansson /* Always-on domains must be powered on at initialization. */ 1817ffaa42e8SUlf Hansson if (genpd_is_always_on(genpd) && !genpd_status_on(genpd)) 1818ffaa42e8SUlf Hansson return -EINVAL; 1819ffaa42e8SUlf Hansson 1820eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd) && 1821eb594b73SUlf Hansson !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL)) 1822eb594b73SUlf Hansson return -ENOMEM; 1823eb594b73SUlf Hansson 1824fc5cbf0cSAxel Haslam /* Use only one "off" state if there were no states declared */ 182559d65b73SLina Iyer if (genpd->state_count == 0) { 182659d65b73SLina Iyer ret = genpd_set_default_power_state(genpd); 1827eb594b73SUlf Hansson if (ret) { 1828eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd)) 1829eb594b73SUlf Hansson free_cpumask_var(genpd->cpus); 183059d65b73SLina Iyer return ret; 1831eb594b73SUlf Hansson } 183246b7fe94SAisheng Dong } else if (!gov && genpd->state_count > 1) { 18332c9b7f87SUlf Hansson pr_warn("%s: no governor for states\n", genpd->name); 183459d65b73SLina Iyer } 1835fc5cbf0cSAxel Haslam 1836401ea157SViresh Kumar device_initialize(&genpd->dev); 1837401ea157SViresh Kumar dev_set_name(&genpd->dev, "%s", genpd->name); 1838401ea157SViresh Kumar 18395125bbf3SRafael J. Wysocki mutex_lock(&gpd_list_lock); 18405125bbf3SRafael J. Wysocki list_add(&genpd->gpd_list_node, &gpd_list); 18415125bbf3SRafael J. Wysocki mutex_unlock(&gpd_list_lock); 18427eb231c3SUlf Hansson 18437eb231c3SUlf Hansson return 0; 18445125bbf3SRafael J. Wysocki } 1845be5ed55dSRajendra Nayak EXPORT_SYMBOL_GPL(pm_genpd_init); 1846aa42240aSTomasz Figa 18473fe57710SJon Hunter static int genpd_remove(struct generic_pm_domain *genpd) 18483fe57710SJon Hunter { 18493fe57710SJon Hunter struct gpd_link *l, *link; 18503fe57710SJon Hunter 18513fe57710SJon Hunter if (IS_ERR_OR_NULL(genpd)) 18523fe57710SJon Hunter return -EINVAL; 18533fe57710SJon Hunter 185435241d12SLina Iyer genpd_lock(genpd); 18553fe57710SJon Hunter 18563fe57710SJon Hunter if (genpd->has_provider) { 185735241d12SLina Iyer genpd_unlock(genpd); 18583fe57710SJon Hunter pr_err("Provider present, unable to remove %s\n", genpd->name); 18593fe57710SJon Hunter return -EBUSY; 18603fe57710SJon Hunter } 18613fe57710SJon Hunter 18623fe57710SJon Hunter if (!list_empty(&genpd->master_links) || genpd->device_count) { 186335241d12SLina Iyer genpd_unlock(genpd); 18643fe57710SJon Hunter pr_err("%s: unable to remove %s\n", __func__, genpd->name); 18653fe57710SJon Hunter return -EBUSY; 18663fe57710SJon Hunter } 18673fe57710SJon Hunter 18683fe57710SJon Hunter list_for_each_entry_safe(link, l, &genpd->slave_links, slave_node) { 18693fe57710SJon Hunter list_del(&link->master_node); 18703fe57710SJon Hunter list_del(&link->slave_node); 18713fe57710SJon Hunter kfree(link); 18723fe57710SJon Hunter } 18733fe57710SJon Hunter 18743fe57710SJon Hunter list_del(&genpd->gpd_list_node); 187535241d12SLina Iyer genpd_unlock(genpd); 18763fe57710SJon Hunter cancel_work_sync(&genpd->power_off_work); 1877eb594b73SUlf Hansson if (genpd_is_cpu_domain(genpd)) 1878eb594b73SUlf Hansson free_cpumask_var(genpd->cpus); 187949a27e27SUlf Hansson if (genpd->free_states) 188049a27e27SUlf Hansson genpd->free_states(genpd->states, genpd->state_count); 188149a27e27SUlf Hansson 18823fe57710SJon Hunter pr_debug("%s: removed %s\n", __func__, genpd->name); 18833fe57710SJon Hunter 18843fe57710SJon Hunter return 0; 18853fe57710SJon Hunter } 18863fe57710SJon Hunter 18873fe57710SJon Hunter /** 18883fe57710SJon Hunter * pm_genpd_remove - Remove a generic I/O PM domain 18893fe57710SJon Hunter * @genpd: Pointer to PM domain that is to be removed. 18903fe57710SJon Hunter * 18913fe57710SJon Hunter * To remove the PM domain, this function: 18923fe57710SJon Hunter * - Removes the PM domain as a subdomain to any parent domains, 18933fe57710SJon Hunter * if it was added. 18943fe57710SJon Hunter * - Removes the PM domain from the list of registered PM domains. 18953fe57710SJon Hunter * 18963fe57710SJon Hunter * The PM domain will only be removed, if the associated provider has 18973fe57710SJon Hunter * been removed, it is not a parent to any other PM domain and has no 18983fe57710SJon Hunter * devices associated with it. 18993fe57710SJon Hunter */ 19003fe57710SJon Hunter int pm_genpd_remove(struct generic_pm_domain *genpd) 19013fe57710SJon Hunter { 19023fe57710SJon Hunter int ret; 19033fe57710SJon Hunter 19043fe57710SJon Hunter mutex_lock(&gpd_list_lock); 19053fe57710SJon Hunter ret = genpd_remove(genpd); 19063fe57710SJon Hunter mutex_unlock(&gpd_list_lock); 19073fe57710SJon Hunter 19083fe57710SJon Hunter return ret; 19093fe57710SJon Hunter } 19103fe57710SJon Hunter EXPORT_SYMBOL_GPL(pm_genpd_remove); 19113fe57710SJon Hunter 1912aa42240aSTomasz Figa #ifdef CONFIG_PM_GENERIC_DOMAINS_OF 1913892ebdccSJon Hunter 1914aa42240aSTomasz Figa /* 1915aa42240aSTomasz Figa * Device Tree based PM domain providers. 1916aa42240aSTomasz Figa * 1917aa42240aSTomasz Figa * The code below implements generic device tree based PM domain providers that 1918aa42240aSTomasz Figa * bind device tree nodes with generic PM domains registered in the system. 1919aa42240aSTomasz Figa * 1920aa42240aSTomasz Figa * Any driver that registers generic PM domains and needs to support binding of 1921aa42240aSTomasz Figa * devices to these domains is supposed to register a PM domain provider, which 1922aa42240aSTomasz Figa * maps a PM domain specifier retrieved from the device tree to a PM domain. 1923aa42240aSTomasz Figa * 1924aa42240aSTomasz Figa * Two simple mapping functions have been provided for convenience: 1925892ebdccSJon Hunter * - genpd_xlate_simple() for 1:1 device tree node to PM domain mapping. 1926892ebdccSJon Hunter * - genpd_xlate_onecell() for mapping of multiple PM domains per node by 1927aa42240aSTomasz Figa * index. 1928aa42240aSTomasz Figa */ 1929aa42240aSTomasz Figa 1930aa42240aSTomasz Figa /** 1931aa42240aSTomasz Figa * struct of_genpd_provider - PM domain provider registration structure 1932aa42240aSTomasz Figa * @link: Entry in global list of PM domain providers 1933aa42240aSTomasz Figa * @node: Pointer to device tree node of PM domain provider 1934aa42240aSTomasz Figa * @xlate: Provider-specific xlate callback mapping a set of specifier cells 1935aa42240aSTomasz Figa * into a PM domain. 1936aa42240aSTomasz Figa * @data: context pointer to be passed into @xlate callback 1937aa42240aSTomasz Figa */ 1938aa42240aSTomasz Figa struct of_genpd_provider { 1939aa42240aSTomasz Figa struct list_head link; 1940aa42240aSTomasz Figa struct device_node *node; 1941aa42240aSTomasz Figa genpd_xlate_t xlate; 1942aa42240aSTomasz Figa void *data; 1943aa42240aSTomasz Figa }; 1944aa42240aSTomasz Figa 1945aa42240aSTomasz Figa /* List of registered PM domain providers. */ 1946aa42240aSTomasz Figa static LIST_HEAD(of_genpd_providers); 1947aa42240aSTomasz Figa /* Mutex to protect the list above. */ 1948aa42240aSTomasz Figa static DEFINE_MUTEX(of_genpd_mutex); 1949aa42240aSTomasz Figa 1950aa42240aSTomasz Figa /** 1951892ebdccSJon Hunter * genpd_xlate_simple() - Xlate function for direct node-domain mapping 1952aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1953aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct generic_pm_domain 1954aa42240aSTomasz Figa * 1955aa42240aSTomasz Figa * This is a generic xlate function that can be used to model PM domains that 1956aa42240aSTomasz Figa * have their own device tree nodes. The private data of xlate function needs 1957aa42240aSTomasz Figa * to be a valid pointer to struct generic_pm_domain. 1958aa42240aSTomasz Figa */ 1959892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_simple( 1960aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1961aa42240aSTomasz Figa void *data) 1962aa42240aSTomasz Figa { 1963aa42240aSTomasz Figa return data; 1964aa42240aSTomasz Figa } 1965aa42240aSTomasz Figa 1966aa42240aSTomasz Figa /** 1967892ebdccSJon Hunter * genpd_xlate_onecell() - Xlate function using a single index. 1968aa42240aSTomasz Figa * @genpdspec: OF phandle args to map into a PM domain 1969aa42240aSTomasz Figa * @data: xlate function private data - pointer to struct genpd_onecell_data 1970aa42240aSTomasz Figa * 1971aa42240aSTomasz Figa * This is a generic xlate function that can be used to model simple PM domain 1972aa42240aSTomasz Figa * controllers that have one device tree node and provide multiple PM domains. 1973aa42240aSTomasz Figa * A single cell is used as an index into an array of PM domains specified in 1974aa42240aSTomasz Figa * the genpd_onecell_data struct when registering the provider. 1975aa42240aSTomasz Figa */ 1976892ebdccSJon Hunter static struct generic_pm_domain *genpd_xlate_onecell( 1977aa42240aSTomasz Figa struct of_phandle_args *genpdspec, 1978aa42240aSTomasz Figa void *data) 1979aa42240aSTomasz Figa { 1980aa42240aSTomasz Figa struct genpd_onecell_data *genpd_data = data; 1981aa42240aSTomasz Figa unsigned int idx = genpdspec->args[0]; 1982aa42240aSTomasz Figa 1983aa42240aSTomasz Figa if (genpdspec->args_count != 1) 1984aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1985aa42240aSTomasz Figa 1986aa42240aSTomasz Figa if (idx >= genpd_data->num_domains) { 1987aa42240aSTomasz Figa pr_err("%s: invalid domain index %u\n", __func__, idx); 1988aa42240aSTomasz Figa return ERR_PTR(-EINVAL); 1989aa42240aSTomasz Figa } 1990aa42240aSTomasz Figa 1991aa42240aSTomasz Figa if (!genpd_data->domains[idx]) 1992aa42240aSTomasz Figa return ERR_PTR(-ENOENT); 1993aa42240aSTomasz Figa 1994aa42240aSTomasz Figa return genpd_data->domains[idx]; 1995aa42240aSTomasz Figa } 1996aa42240aSTomasz Figa 1997aa42240aSTomasz Figa /** 1998892ebdccSJon Hunter * genpd_add_provider() - Register a PM domain provider for a node 1999aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider. 2000aa42240aSTomasz Figa * @xlate: Callback for decoding PM domain from phandle arguments. 2001aa42240aSTomasz Figa * @data: Context pointer for @xlate callback. 2002aa42240aSTomasz Figa */ 2003892ebdccSJon Hunter static int genpd_add_provider(struct device_node *np, genpd_xlate_t xlate, 2004aa42240aSTomasz Figa void *data) 2005aa42240aSTomasz Figa { 2006aa42240aSTomasz Figa struct of_genpd_provider *cp; 2007aa42240aSTomasz Figa 2008aa42240aSTomasz Figa cp = kzalloc(sizeof(*cp), GFP_KERNEL); 2009aa42240aSTomasz Figa if (!cp) 2010aa42240aSTomasz Figa return -ENOMEM; 2011aa42240aSTomasz Figa 2012aa42240aSTomasz Figa cp->node = of_node_get(np); 2013aa42240aSTomasz Figa cp->data = data; 2014aa42240aSTomasz Figa cp->xlate = xlate; 2015aa42240aSTomasz Figa 2016aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2017aa42240aSTomasz Figa list_add(&cp->link, &of_genpd_providers); 2018aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2019ea11e94bSRob Herring pr_debug("Added domain provider from %pOF\n", np); 2020aa42240aSTomasz Figa 2021aa42240aSTomasz Figa return 0; 2022aa42240aSTomasz Figa } 2023892ebdccSJon Hunter 2024892ebdccSJon Hunter /** 2025892ebdccSJon Hunter * of_genpd_add_provider_simple() - Register a simple PM domain provider 2026892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 2027892ebdccSJon Hunter * @genpd: Pointer to PM domain associated with the PM domain provider. 2028892ebdccSJon Hunter */ 2029892ebdccSJon Hunter int of_genpd_add_provider_simple(struct device_node *np, 2030892ebdccSJon Hunter struct generic_pm_domain *genpd) 2031892ebdccSJon Hunter { 20320159ec67SJon Hunter int ret = -EINVAL; 20330159ec67SJon Hunter 20340159ec67SJon Hunter if (!np || !genpd) 20350159ec67SJon Hunter return -EINVAL; 20360159ec67SJon Hunter 20370159ec67SJon Hunter mutex_lock(&gpd_list_lock); 20380159ec67SJon Hunter 20396a0ae73dSViresh Kumar if (!genpd_present(genpd)) 20406a0ae73dSViresh Kumar goto unlock; 20416a0ae73dSViresh Kumar 20426a0ae73dSViresh Kumar genpd->dev.of_node = np; 20436a0ae73dSViresh Kumar 20446a0ae73dSViresh Kumar /* Parse genpd OPP table */ 20456a0ae73dSViresh Kumar if (genpd->set_performance_state) { 20466a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table(&genpd->dev); 20476a0ae73dSViresh Kumar if (ret) { 20486a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table: %d\n", 20496a0ae73dSViresh Kumar ret); 20506a0ae73dSViresh Kumar goto unlock; 2051de0aa06dSJon Hunter } 20521067ae3eSViresh Kumar 20531067ae3eSViresh Kumar /* 20541067ae3eSViresh Kumar * Save table for faster processing while setting performance 20551067ae3eSViresh Kumar * state. 20561067ae3eSViresh Kumar */ 20571067ae3eSViresh Kumar genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev); 20581067ae3eSViresh Kumar WARN_ON(!genpd->opp_table); 20598ce95844SViresh Kumar } 2060de0aa06dSJon Hunter 20616a0ae73dSViresh Kumar ret = genpd_add_provider(np, genpd_xlate_simple, genpd); 20626a0ae73dSViresh Kumar if (ret) { 20631067ae3eSViresh Kumar if (genpd->set_performance_state) { 20641067ae3eSViresh Kumar dev_pm_opp_put_opp_table(genpd->opp_table); 20656a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 20661067ae3eSViresh Kumar } 20676a0ae73dSViresh Kumar 20686a0ae73dSViresh Kumar goto unlock; 20696a0ae73dSViresh Kumar } 20706a0ae73dSViresh Kumar 20716a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 20726a0ae73dSViresh Kumar genpd->has_provider = true; 20736a0ae73dSViresh Kumar 20746a0ae73dSViresh Kumar unlock: 20750159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 20760159ec67SJon Hunter 20770159ec67SJon Hunter return ret; 2078892ebdccSJon Hunter } 2079892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_simple); 2080892ebdccSJon Hunter 2081892ebdccSJon Hunter /** 2082892ebdccSJon Hunter * of_genpd_add_provider_onecell() - Register a onecell PM domain provider 2083892ebdccSJon Hunter * @np: Device node pointer associated with the PM domain provider. 2084892ebdccSJon Hunter * @data: Pointer to the data associated with the PM domain provider. 2085892ebdccSJon Hunter */ 2086892ebdccSJon Hunter int of_genpd_add_provider_onecell(struct device_node *np, 2087892ebdccSJon Hunter struct genpd_onecell_data *data) 2088892ebdccSJon Hunter { 20896a0ae73dSViresh Kumar struct generic_pm_domain *genpd; 20900159ec67SJon Hunter unsigned int i; 2091de0aa06dSJon Hunter int ret = -EINVAL; 20920159ec67SJon Hunter 20930159ec67SJon Hunter if (!np || !data) 20940159ec67SJon Hunter return -EINVAL; 20950159ec67SJon Hunter 20960159ec67SJon Hunter mutex_lock(&gpd_list_lock); 20970159ec67SJon Hunter 209840845524SThierry Reding if (!data->xlate) 209940845524SThierry Reding data->xlate = genpd_xlate_onecell; 210040845524SThierry Reding 21010159ec67SJon Hunter for (i = 0; i < data->num_domains; i++) { 21026a0ae73dSViresh Kumar genpd = data->domains[i]; 21036a0ae73dSViresh Kumar 21046a0ae73dSViresh Kumar if (!genpd) 2105609bed67STomeu Vizoso continue; 21066a0ae73dSViresh Kumar if (!genpd_present(genpd)) 2107de0aa06dSJon Hunter goto error; 2108de0aa06dSJon Hunter 21096a0ae73dSViresh Kumar genpd->dev.of_node = np; 21106a0ae73dSViresh Kumar 21116a0ae73dSViresh Kumar /* Parse genpd OPP table */ 21126a0ae73dSViresh Kumar if (genpd->set_performance_state) { 21136a0ae73dSViresh Kumar ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i); 21146a0ae73dSViresh Kumar if (ret) { 21156a0ae73dSViresh Kumar dev_err(&genpd->dev, "Failed to add OPP table for index %d: %d\n", 21166a0ae73dSViresh Kumar i, ret); 21176a0ae73dSViresh Kumar goto error; 21186a0ae73dSViresh Kumar } 21191067ae3eSViresh Kumar 21201067ae3eSViresh Kumar /* 21211067ae3eSViresh Kumar * Save table for faster processing while setting 21221067ae3eSViresh Kumar * performance state. 21231067ae3eSViresh Kumar */ 21241067ae3eSViresh Kumar genpd->opp_table = dev_pm_opp_get_opp_table_indexed(&genpd->dev, i); 21251067ae3eSViresh Kumar WARN_ON(!genpd->opp_table); 21266a0ae73dSViresh Kumar } 21276a0ae73dSViresh Kumar 21286a0ae73dSViresh Kumar genpd->provider = &np->fwnode; 21296a0ae73dSViresh Kumar genpd->has_provider = true; 21300159ec67SJon Hunter } 21310159ec67SJon Hunter 213240845524SThierry Reding ret = genpd_add_provider(np, data->xlate, data); 2133de0aa06dSJon Hunter if (ret < 0) 2134de0aa06dSJon Hunter goto error; 2135de0aa06dSJon Hunter 2136de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 2137de0aa06dSJon Hunter 2138de0aa06dSJon Hunter return 0; 2139de0aa06dSJon Hunter 2140de0aa06dSJon Hunter error: 2141de0aa06dSJon Hunter while (i--) { 21426a0ae73dSViresh Kumar genpd = data->domains[i]; 21436a0ae73dSViresh Kumar 21446a0ae73dSViresh Kumar if (!genpd) 2145609bed67STomeu Vizoso continue; 21466a0ae73dSViresh Kumar 21476a0ae73dSViresh Kumar genpd->provider = NULL; 21486a0ae73dSViresh Kumar genpd->has_provider = false; 21496a0ae73dSViresh Kumar 21501067ae3eSViresh Kumar if (genpd->set_performance_state) { 21511067ae3eSViresh Kumar dev_pm_opp_put_opp_table(genpd->opp_table); 21526a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&genpd->dev); 2153de0aa06dSJon Hunter } 21541067ae3eSViresh Kumar } 21550159ec67SJon Hunter 21560159ec67SJon Hunter mutex_unlock(&gpd_list_lock); 21570159ec67SJon Hunter 21580159ec67SJon Hunter return ret; 2159892ebdccSJon Hunter } 2160892ebdccSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_provider_onecell); 2161aa42240aSTomasz Figa 2162aa42240aSTomasz Figa /** 2163aa42240aSTomasz Figa * of_genpd_del_provider() - Remove a previously registered PM domain provider 2164aa42240aSTomasz Figa * @np: Device node pointer associated with the PM domain provider 2165aa42240aSTomasz Figa */ 2166aa42240aSTomasz Figa void of_genpd_del_provider(struct device_node *np) 2167aa42240aSTomasz Figa { 2168b556b15dSKrzysztof Kozlowski struct of_genpd_provider *cp, *tmp; 2169de0aa06dSJon Hunter struct generic_pm_domain *gpd; 2170aa42240aSTomasz Figa 2171de0aa06dSJon Hunter mutex_lock(&gpd_list_lock); 2172aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2173b556b15dSKrzysztof Kozlowski list_for_each_entry_safe(cp, tmp, &of_genpd_providers, link) { 2174aa42240aSTomasz Figa if (cp->node == np) { 2175de0aa06dSJon Hunter /* 2176de0aa06dSJon Hunter * For each PM domain associated with the 2177de0aa06dSJon Hunter * provider, set the 'has_provider' to false 2178de0aa06dSJon Hunter * so that the PM domain can be safely removed. 2179de0aa06dSJon Hunter */ 21806a0ae73dSViresh Kumar list_for_each_entry(gpd, &gpd_list, gpd_list_node) { 21816a0ae73dSViresh Kumar if (gpd->provider == &np->fwnode) { 2182de0aa06dSJon Hunter gpd->has_provider = false; 2183de0aa06dSJon Hunter 21846a0ae73dSViresh Kumar if (!gpd->set_performance_state) 21856a0ae73dSViresh Kumar continue; 21866a0ae73dSViresh Kumar 21871067ae3eSViresh Kumar dev_pm_opp_put_opp_table(gpd->opp_table); 21886a0ae73dSViresh Kumar dev_pm_opp_of_remove_table(&gpd->dev); 21896a0ae73dSViresh Kumar } 21906a0ae73dSViresh Kumar } 21916a0ae73dSViresh Kumar 2192aa42240aSTomasz Figa list_del(&cp->link); 2193aa42240aSTomasz Figa of_node_put(cp->node); 2194aa42240aSTomasz Figa kfree(cp); 2195aa42240aSTomasz Figa break; 2196aa42240aSTomasz Figa } 2197aa42240aSTomasz Figa } 2198aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2199de0aa06dSJon Hunter mutex_unlock(&gpd_list_lock); 2200aa42240aSTomasz Figa } 2201aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(of_genpd_del_provider); 2202aa42240aSTomasz Figa 2203aa42240aSTomasz Figa /** 2204f58d4e5aSJon Hunter * genpd_get_from_provider() - Look-up PM domain 2205aa42240aSTomasz Figa * @genpdspec: OF phandle args to use for look-up 2206aa42240aSTomasz Figa * 2207aa42240aSTomasz Figa * Looks for a PM domain provider under the node specified by @genpdspec and if 2208aa42240aSTomasz Figa * found, uses xlate function of the provider to map phandle args to a PM 2209aa42240aSTomasz Figa * domain. 2210aa42240aSTomasz Figa * 2211aa42240aSTomasz Figa * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR() 2212aa42240aSTomasz Figa * on failure. 2213aa42240aSTomasz Figa */ 2214f58d4e5aSJon Hunter static struct generic_pm_domain *genpd_get_from_provider( 2215aa42240aSTomasz Figa struct of_phandle_args *genpdspec) 2216aa42240aSTomasz Figa { 2217aa42240aSTomasz Figa struct generic_pm_domain *genpd = ERR_PTR(-ENOENT); 2218aa42240aSTomasz Figa struct of_genpd_provider *provider; 2219aa42240aSTomasz Figa 222041795a8aSJon Hunter if (!genpdspec) 222141795a8aSJon Hunter return ERR_PTR(-EINVAL); 222241795a8aSJon Hunter 2223aa42240aSTomasz Figa mutex_lock(&of_genpd_mutex); 2224aa42240aSTomasz Figa 2225aa42240aSTomasz Figa /* Check if we have such a provider in our array */ 2226aa42240aSTomasz Figa list_for_each_entry(provider, &of_genpd_providers, link) { 2227aa42240aSTomasz Figa if (provider->node == genpdspec->np) 2228aa42240aSTomasz Figa genpd = provider->xlate(genpdspec, provider->data); 2229aa42240aSTomasz Figa if (!IS_ERR(genpd)) 2230aa42240aSTomasz Figa break; 2231aa42240aSTomasz Figa } 2232aa42240aSTomasz Figa 2233aa42240aSTomasz Figa mutex_unlock(&of_genpd_mutex); 2234aa42240aSTomasz Figa 2235aa42240aSTomasz Figa return genpd; 2236aa42240aSTomasz Figa } 2237aa42240aSTomasz Figa 2238aa42240aSTomasz Figa /** 2239ec69572bSJon Hunter * of_genpd_add_device() - Add a device to an I/O PM domain 2240ec69572bSJon Hunter * @genpdspec: OF phandle args to use for look-up PM domain 2241ec69572bSJon Hunter * @dev: Device to be added. 2242ec69572bSJon Hunter * 2243ec69572bSJon Hunter * Looks-up an I/O PM domain based upon phandle args provided and adds 2244ec69572bSJon Hunter * the device to the PM domain. Returns a negative error code on failure. 2245ec69572bSJon Hunter */ 2246ec69572bSJon Hunter int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev) 2247ec69572bSJon Hunter { 2248ec69572bSJon Hunter struct generic_pm_domain *genpd; 224919efa5ffSJon Hunter int ret; 225019efa5ffSJon Hunter 225119efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2252ec69572bSJon Hunter 2253f58d4e5aSJon Hunter genpd = genpd_get_from_provider(genpdspec); 225419efa5ffSJon Hunter if (IS_ERR(genpd)) { 225519efa5ffSJon Hunter ret = PTR_ERR(genpd); 225619efa5ffSJon Hunter goto out; 225719efa5ffSJon Hunter } 2258ec69572bSJon Hunter 2259a174920dSUlf Hansson ret = genpd_add_device(genpd, dev); 226019efa5ffSJon Hunter 226119efa5ffSJon Hunter out: 226219efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 226319efa5ffSJon Hunter 226419efa5ffSJon Hunter return ret; 2265ec69572bSJon Hunter } 2266ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_device); 2267ec69572bSJon Hunter 2268ec69572bSJon Hunter /** 2269ec69572bSJon Hunter * of_genpd_add_subdomain - Add a subdomain to an I/O PM domain. 2270ec69572bSJon Hunter * @parent_spec: OF phandle args to use for parent PM domain look-up 2271ec69572bSJon Hunter * @subdomain_spec: OF phandle args to use for subdomain look-up 2272ec69572bSJon Hunter * 2273ec69572bSJon Hunter * Looks-up a parent PM domain and subdomain based upon phandle args 2274ec69572bSJon Hunter * provided and adds the subdomain to the parent PM domain. Returns a 2275ec69572bSJon Hunter * negative error code on failure. 2276ec69572bSJon Hunter */ 2277ec69572bSJon Hunter int of_genpd_add_subdomain(struct of_phandle_args *parent_spec, 2278ec69572bSJon Hunter struct of_phandle_args *subdomain_spec) 2279ec69572bSJon Hunter { 2280ec69572bSJon Hunter struct generic_pm_domain *parent, *subdomain; 228119efa5ffSJon Hunter int ret; 228219efa5ffSJon Hunter 228319efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2284ec69572bSJon Hunter 2285f58d4e5aSJon Hunter parent = genpd_get_from_provider(parent_spec); 228619efa5ffSJon Hunter if (IS_ERR(parent)) { 228719efa5ffSJon Hunter ret = PTR_ERR(parent); 228819efa5ffSJon Hunter goto out; 228919efa5ffSJon Hunter } 2290ec69572bSJon Hunter 2291f58d4e5aSJon Hunter subdomain = genpd_get_from_provider(subdomain_spec); 229219efa5ffSJon Hunter if (IS_ERR(subdomain)) { 229319efa5ffSJon Hunter ret = PTR_ERR(subdomain); 229419efa5ffSJon Hunter goto out; 229519efa5ffSJon Hunter } 2296ec69572bSJon Hunter 229719efa5ffSJon Hunter ret = genpd_add_subdomain(parent, subdomain); 229819efa5ffSJon Hunter 229919efa5ffSJon Hunter out: 230019efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 230119efa5ffSJon Hunter 230219efa5ffSJon Hunter return ret; 2303ec69572bSJon Hunter } 2304ec69572bSJon Hunter EXPORT_SYMBOL_GPL(of_genpd_add_subdomain); 2305ec69572bSJon Hunter 2306ec69572bSJon Hunter /** 230717926551SJon Hunter * of_genpd_remove_last - Remove the last PM domain registered for a provider 230817926551SJon Hunter * @provider: Pointer to device structure associated with provider 230917926551SJon Hunter * 231017926551SJon Hunter * Find the last PM domain that was added by a particular provider and 231117926551SJon Hunter * remove this PM domain from the list of PM domains. The provider is 231217926551SJon Hunter * identified by the 'provider' device structure that is passed. The PM 231317926551SJon Hunter * domain will only be removed, if the provider associated with domain 231417926551SJon Hunter * has been removed. 231517926551SJon Hunter * 231617926551SJon Hunter * Returns a valid pointer to struct generic_pm_domain on success or 231717926551SJon Hunter * ERR_PTR() on failure. 231817926551SJon Hunter */ 231917926551SJon Hunter struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) 232017926551SJon Hunter { 2321a7e2d1bcSKrzysztof Kozlowski struct generic_pm_domain *gpd, *tmp, *genpd = ERR_PTR(-ENOENT); 232217926551SJon Hunter int ret; 232317926551SJon Hunter 232417926551SJon Hunter if (IS_ERR_OR_NULL(np)) 232517926551SJon Hunter return ERR_PTR(-EINVAL); 232617926551SJon Hunter 232717926551SJon Hunter mutex_lock(&gpd_list_lock); 2328a7e2d1bcSKrzysztof Kozlowski list_for_each_entry_safe(gpd, tmp, &gpd_list, gpd_list_node) { 232917926551SJon Hunter if (gpd->provider == &np->fwnode) { 233017926551SJon Hunter ret = genpd_remove(gpd); 233117926551SJon Hunter genpd = ret ? ERR_PTR(ret) : gpd; 233217926551SJon Hunter break; 233317926551SJon Hunter } 233417926551SJon Hunter } 233517926551SJon Hunter mutex_unlock(&gpd_list_lock); 233617926551SJon Hunter 233717926551SJon Hunter return genpd; 233817926551SJon Hunter } 233917926551SJon Hunter EXPORT_SYMBOL_GPL(of_genpd_remove_last); 234017926551SJon Hunter 23413c095f32SUlf Hansson static void genpd_release_dev(struct device *dev) 23423c095f32SUlf Hansson { 2343e8b04de9SUlf Hansson of_node_put(dev->of_node); 23443c095f32SUlf Hansson kfree(dev); 23453c095f32SUlf Hansson } 23463c095f32SUlf Hansson 23473c095f32SUlf Hansson static struct bus_type genpd_bus_type = { 23483c095f32SUlf Hansson .name = "genpd", 23493c095f32SUlf Hansson }; 23503c095f32SUlf Hansson 235117926551SJon Hunter /** 2352aa42240aSTomasz Figa * genpd_dev_pm_detach - Detach a device from its PM domain. 23538bb6944eSJon Hunter * @dev: Device to detach. 2354aa42240aSTomasz Figa * @power_off: Currently not used 2355aa42240aSTomasz Figa * 2356aa42240aSTomasz Figa * Try to locate a corresponding generic PM domain, which the device was 2357aa42240aSTomasz Figa * attached to previously. If such is found, the device is detached from it. 2358aa42240aSTomasz Figa */ 2359aa42240aSTomasz Figa static void genpd_dev_pm_detach(struct device *dev, bool power_off) 2360aa42240aSTomasz Figa { 2361446d999cSRussell King struct generic_pm_domain *pd; 236293af5e93SGeert Uytterhoeven unsigned int i; 2363aa42240aSTomasz Figa int ret = 0; 2364aa42240aSTomasz Figa 236585168d56SUlf Hansson pd = dev_to_genpd(dev); 236685168d56SUlf Hansson if (IS_ERR(pd)) 2367aa42240aSTomasz Figa return; 2368aa42240aSTomasz Figa 2369aa42240aSTomasz Figa dev_dbg(dev, "removing from PM domain %s\n", pd->name); 2370aa42240aSTomasz Figa 237193af5e93SGeert Uytterhoeven for (i = 1; i < GENPD_RETRY_MAX_MS; i <<= 1) { 237285168d56SUlf Hansson ret = genpd_remove_device(pd, dev); 2373aa42240aSTomasz Figa if (ret != -EAGAIN) 2374aa42240aSTomasz Figa break; 237593af5e93SGeert Uytterhoeven 237693af5e93SGeert Uytterhoeven mdelay(i); 2377aa42240aSTomasz Figa cond_resched(); 2378aa42240aSTomasz Figa } 2379aa42240aSTomasz Figa 2380aa42240aSTomasz Figa if (ret < 0) { 2381aa42240aSTomasz Figa dev_err(dev, "failed to remove from PM domain %s: %d", 2382aa42240aSTomasz Figa pd->name, ret); 2383aa42240aSTomasz Figa return; 2384aa42240aSTomasz Figa } 2385aa42240aSTomasz Figa 2386aa42240aSTomasz Figa /* Check if PM domain can be powered off after removing this device. */ 2387aa42240aSTomasz Figa genpd_queue_power_off_work(pd); 23883c095f32SUlf Hansson 23893c095f32SUlf Hansson /* Unregister the device if it was created by genpd. */ 23903c095f32SUlf Hansson if (dev->bus == &genpd_bus_type) 23913c095f32SUlf Hansson device_unregister(dev); 2392aa42240aSTomasz Figa } 2393aa42240aSTomasz Figa 2394632f7ce3SRussell King static void genpd_dev_pm_sync(struct device *dev) 2395632f7ce3SRussell King { 2396632f7ce3SRussell King struct generic_pm_domain *pd; 2397632f7ce3SRussell King 2398632f7ce3SRussell King pd = dev_to_genpd(dev); 2399632f7ce3SRussell King if (IS_ERR(pd)) 2400632f7ce3SRussell King return; 2401632f7ce3SRussell King 2402632f7ce3SRussell King genpd_queue_power_off_work(pd); 2403632f7ce3SRussell King } 2404632f7ce3SRussell King 240551dcf748SUlf Hansson static int __genpd_dev_pm_attach(struct device *dev, struct device *base_dev, 240651dcf748SUlf Hansson unsigned int index, bool power_on) 2407aa42240aSTomasz Figa { 2408aa42240aSTomasz Figa struct of_phandle_args pd_args; 2409aa42240aSTomasz Figa struct generic_pm_domain *pd; 2410aa42240aSTomasz Figa int ret; 2411aa42240aSTomasz Figa 2412e8b04de9SUlf Hansson ret = of_parse_phandle_with_args(dev->of_node, "power-domains", 24138cb1cbd6SUlf Hansson "#power-domain-cells", index, &pd_args); 2414001d50c9SGeert Uytterhoeven if (ret < 0) 2415bcd931f2SUlf Hansson return ret; 2416aa42240aSTomasz Figa 241719efa5ffSJon Hunter mutex_lock(&gpd_list_lock); 2418f58d4e5aSJon Hunter pd = genpd_get_from_provider(&pd_args); 2419265e2cf6SEric Anholt of_node_put(pd_args.np); 2420aa42240aSTomasz Figa if (IS_ERR(pd)) { 242119efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2422aa42240aSTomasz Figa dev_dbg(dev, "%s() failed to find PM domain: %ld\n", 2423aa42240aSTomasz Figa __func__, PTR_ERR(pd)); 242451dcf748SUlf Hansson return driver_deferred_probe_check_state(base_dev); 2425aa42240aSTomasz Figa } 2426aa42240aSTomasz Figa 2427aa42240aSTomasz Figa dev_dbg(dev, "adding to PM domain %s\n", pd->name); 2428aa42240aSTomasz Figa 2429a174920dSUlf Hansson ret = genpd_add_device(pd, dev); 243019efa5ffSJon Hunter mutex_unlock(&gpd_list_lock); 2431aa42240aSTomasz Figa 2432aa42240aSTomasz Figa if (ret < 0) { 243334994692SGeert Uytterhoeven if (ret != -EPROBE_DEFER) 2434aa42240aSTomasz Figa dev_err(dev, "failed to add to PM domain %s: %d", 2435aa42240aSTomasz Figa pd->name, ret); 2436919b7308SUlf Hansson return ret; 2437aa42240aSTomasz Figa } 2438aa42240aSTomasz Figa 2439aa42240aSTomasz Figa dev->pm_domain->detach = genpd_dev_pm_detach; 2440632f7ce3SRussell King dev->pm_domain->sync = genpd_dev_pm_sync; 2441aa42240aSTomasz Figa 2442895b6612SUlf Hansson if (power_on) { 244335241d12SLina Iyer genpd_lock(pd); 244486e12eacSUlf Hansson ret = genpd_power_on(pd, 0); 244535241d12SLina Iyer genpd_unlock(pd); 2446895b6612SUlf Hansson } 244772038df3SUlf Hansson 244872038df3SUlf Hansson if (ret) 244972038df3SUlf Hansson genpd_remove_device(pd, dev); 2450919b7308SUlf Hansson 2451919b7308SUlf Hansson return ret ? -EPROBE_DEFER : 1; 2452aa42240aSTomasz Figa } 24538cb1cbd6SUlf Hansson 24548cb1cbd6SUlf Hansson /** 24558cb1cbd6SUlf Hansson * genpd_dev_pm_attach - Attach a device to its PM domain using DT. 24568cb1cbd6SUlf Hansson * @dev: Device to attach. 24578cb1cbd6SUlf Hansson * 24588cb1cbd6SUlf Hansson * Parse device's OF node to find a PM domain specifier. If such is found, 24598cb1cbd6SUlf Hansson * attaches the device to retrieved pm_domain ops. 24608cb1cbd6SUlf Hansson * 24618cb1cbd6SUlf Hansson * Returns 1 on successfully attached PM domain, 0 when the device don't need a 24628cb1cbd6SUlf Hansson * PM domain or when multiple power-domains exists for it, else a negative error 24638cb1cbd6SUlf Hansson * code. Note that if a power-domain exists for the device, but it cannot be 24648cb1cbd6SUlf Hansson * found or turned on, then return -EPROBE_DEFER to ensure that the device is 24658cb1cbd6SUlf Hansson * not probed and to re-try again later. 24668cb1cbd6SUlf Hansson */ 24678cb1cbd6SUlf Hansson int genpd_dev_pm_attach(struct device *dev) 24688cb1cbd6SUlf Hansson { 24698cb1cbd6SUlf Hansson if (!dev->of_node) 24708cb1cbd6SUlf Hansson return 0; 24718cb1cbd6SUlf Hansson 24728cb1cbd6SUlf Hansson /* 24738cb1cbd6SUlf Hansson * Devices with multiple PM domains must be attached separately, as we 24748cb1cbd6SUlf Hansson * can only attach one PM domain per device. 24758cb1cbd6SUlf Hansson */ 24768cb1cbd6SUlf Hansson if (of_count_phandle_with_args(dev->of_node, "power-domains", 24778cb1cbd6SUlf Hansson "#power-domain-cells") != 1) 24788cb1cbd6SUlf Hansson return 0; 24798cb1cbd6SUlf Hansson 248051dcf748SUlf Hansson return __genpd_dev_pm_attach(dev, dev, 0, true); 24818cb1cbd6SUlf Hansson } 2482aa42240aSTomasz Figa EXPORT_SYMBOL_GPL(genpd_dev_pm_attach); 248330f60428SLina Iyer 24843c095f32SUlf Hansson /** 24853c095f32SUlf Hansson * genpd_dev_pm_attach_by_id - Associate a device with one of its PM domains. 24863c095f32SUlf Hansson * @dev: The device used to lookup the PM domain. 24873c095f32SUlf Hansson * @index: The index of the PM domain. 24883c095f32SUlf Hansson * 24893c095f32SUlf Hansson * Parse device's OF node to find a PM domain specifier at the provided @index. 24903c095f32SUlf Hansson * If such is found, creates a virtual device and attaches it to the retrieved 24913c095f32SUlf Hansson * pm_domain ops. To deal with detaching of the virtual device, the ->detach() 24923c095f32SUlf Hansson * callback in the struct dev_pm_domain are assigned to genpd_dev_pm_detach(). 24933c095f32SUlf Hansson * 24943c095f32SUlf Hansson * Returns the created virtual device if successfully attached PM domain, NULL 24953c095f32SUlf Hansson * when the device don't need a PM domain, else an ERR_PTR() in case of 24963c095f32SUlf Hansson * failures. If a power-domain exists for the device, but cannot be found or 24973c095f32SUlf Hansson * turned on, then ERR_PTR(-EPROBE_DEFER) is returned to ensure that the device 24983c095f32SUlf Hansson * is not probed and to re-try again later. 24993c095f32SUlf Hansson */ 25003c095f32SUlf Hansson struct device *genpd_dev_pm_attach_by_id(struct device *dev, 25013c095f32SUlf Hansson unsigned int index) 25023c095f32SUlf Hansson { 2503560928b2SViresh Kumar struct device *virt_dev; 25043c095f32SUlf Hansson int num_domains; 25053c095f32SUlf Hansson int ret; 25063c095f32SUlf Hansson 25073c095f32SUlf Hansson if (!dev->of_node) 25083c095f32SUlf Hansson return NULL; 25093c095f32SUlf Hansson 25103ccf3f0cSUlf Hansson /* Verify that the index is within a valid range. */ 25113c095f32SUlf Hansson num_domains = of_count_phandle_with_args(dev->of_node, "power-domains", 25123c095f32SUlf Hansson "#power-domain-cells"); 25133ccf3f0cSUlf Hansson if (index >= num_domains) 25143c095f32SUlf Hansson return NULL; 25153c095f32SUlf Hansson 25163c095f32SUlf Hansson /* Allocate and register device on the genpd bus. */ 2517560928b2SViresh Kumar virt_dev = kzalloc(sizeof(*virt_dev), GFP_KERNEL); 2518560928b2SViresh Kumar if (!virt_dev) 25193c095f32SUlf Hansson return ERR_PTR(-ENOMEM); 25203c095f32SUlf Hansson 2521560928b2SViresh Kumar dev_set_name(virt_dev, "genpd:%u:%s", index, dev_name(dev)); 2522560928b2SViresh Kumar virt_dev->bus = &genpd_bus_type; 2523560928b2SViresh Kumar virt_dev->release = genpd_release_dev; 2524e8b04de9SUlf Hansson virt_dev->of_node = of_node_get(dev->of_node); 25253c095f32SUlf Hansson 2526560928b2SViresh Kumar ret = device_register(virt_dev); 25273c095f32SUlf Hansson if (ret) { 252871b77697SUlf Hansson put_device(virt_dev); 25293c095f32SUlf Hansson return ERR_PTR(ret); 25303c095f32SUlf Hansson } 25313c095f32SUlf Hansson 25323c095f32SUlf Hansson /* Try to attach the device to the PM domain at the specified index. */ 253351dcf748SUlf Hansson ret = __genpd_dev_pm_attach(virt_dev, dev, index, false); 25343c095f32SUlf Hansson if (ret < 1) { 2535560928b2SViresh Kumar device_unregister(virt_dev); 25363c095f32SUlf Hansson return ret ? ERR_PTR(ret) : NULL; 25373c095f32SUlf Hansson } 25383c095f32SUlf Hansson 2539560928b2SViresh Kumar pm_runtime_enable(virt_dev); 2540560928b2SViresh Kumar genpd_queue_power_off_work(dev_to_genpd(virt_dev)); 25413c095f32SUlf Hansson 2542560928b2SViresh Kumar return virt_dev; 25433c095f32SUlf Hansson } 25443c095f32SUlf Hansson EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id); 25453c095f32SUlf Hansson 25465d6be70aSUlf Hansson /** 25475d6be70aSUlf Hansson * genpd_dev_pm_attach_by_name - Associate a device with one of its PM domains. 25485d6be70aSUlf Hansson * @dev: The device used to lookup the PM domain. 25495d6be70aSUlf Hansson * @name: The name of the PM domain. 25505d6be70aSUlf Hansson * 25515d6be70aSUlf Hansson * Parse device's OF node to find a PM domain specifier using the 25525d6be70aSUlf Hansson * power-domain-names DT property. For further description see 25535d6be70aSUlf Hansson * genpd_dev_pm_attach_by_id(). 25545d6be70aSUlf Hansson */ 25557416f1f2SDouglas Anderson struct device *genpd_dev_pm_attach_by_name(struct device *dev, const char *name) 25565d6be70aSUlf Hansson { 25575d6be70aSUlf Hansson int index; 25585d6be70aSUlf Hansson 25595d6be70aSUlf Hansson if (!dev->of_node) 25605d6be70aSUlf Hansson return NULL; 25615d6be70aSUlf Hansson 25625d6be70aSUlf Hansson index = of_property_match_string(dev->of_node, "power-domain-names", 25635d6be70aSUlf Hansson name); 25645d6be70aSUlf Hansson if (index < 0) 25655d6be70aSUlf Hansson return NULL; 25665d6be70aSUlf Hansson 25675d6be70aSUlf Hansson return genpd_dev_pm_attach_by_id(dev, index); 25685d6be70aSUlf Hansson } 25695d6be70aSUlf Hansson 257030f60428SLina Iyer static const struct of_device_id idle_state_match[] = { 2571598da548SLina Iyer { .compatible = "domain-idle-state", }, 257230f60428SLina Iyer { } 257330f60428SLina Iyer }; 257430f60428SLina Iyer 257530f60428SLina Iyer static int genpd_parse_state(struct genpd_power_state *genpd_state, 257630f60428SLina Iyer struct device_node *state_node) 257730f60428SLina Iyer { 257830f60428SLina Iyer int err; 257930f60428SLina Iyer u32 residency; 258030f60428SLina Iyer u32 entry_latency, exit_latency; 258130f60428SLina Iyer 258230f60428SLina Iyer err = of_property_read_u32(state_node, "entry-latency-us", 258330f60428SLina Iyer &entry_latency); 258430f60428SLina Iyer if (err) { 2585ea11e94bSRob Herring pr_debug(" * %pOF missing entry-latency-us property\n", 2586ea11e94bSRob Herring state_node); 258730f60428SLina Iyer return -EINVAL; 258830f60428SLina Iyer } 258930f60428SLina Iyer 259030f60428SLina Iyer err = of_property_read_u32(state_node, "exit-latency-us", 259130f60428SLina Iyer &exit_latency); 259230f60428SLina Iyer if (err) { 2593ea11e94bSRob Herring pr_debug(" * %pOF missing exit-latency-us property\n", 2594ea11e94bSRob Herring state_node); 259530f60428SLina Iyer return -EINVAL; 259630f60428SLina Iyer } 259730f60428SLina Iyer 259830f60428SLina Iyer err = of_property_read_u32(state_node, "min-residency-us", &residency); 259930f60428SLina Iyer if (!err) 260030f60428SLina Iyer genpd_state->residency_ns = 1000 * residency; 260130f60428SLina Iyer 260230f60428SLina Iyer genpd_state->power_on_latency_ns = 1000 * exit_latency; 260330f60428SLina Iyer genpd_state->power_off_latency_ns = 1000 * entry_latency; 26040c9b694aSLina Iyer genpd_state->fwnode = &state_node->fwnode; 260530f60428SLina Iyer 260630f60428SLina Iyer return 0; 260730f60428SLina Iyer } 260830f60428SLina Iyer 2609a3381e3aSUlf Hansson static int genpd_iterate_idle_states(struct device_node *dn, 2610a3381e3aSUlf Hansson struct genpd_power_state *states) 2611a3381e3aSUlf Hansson { 2612a3381e3aSUlf Hansson int ret; 2613a3381e3aSUlf Hansson struct of_phandle_iterator it; 2614a3381e3aSUlf Hansson struct device_node *np; 2615a3381e3aSUlf Hansson int i = 0; 2616a3381e3aSUlf Hansson 2617a3381e3aSUlf Hansson ret = of_count_phandle_with_args(dn, "domain-idle-states", NULL); 2618a3381e3aSUlf Hansson if (ret <= 0) 2619a3381e3aSUlf Hansson return ret; 2620a3381e3aSUlf Hansson 2621a3381e3aSUlf Hansson /* Loop over the phandles until all the requested entry is found */ 2622a3381e3aSUlf Hansson of_for_each_phandle(&it, ret, dn, "domain-idle-states", NULL, 0) { 2623a3381e3aSUlf Hansson np = it.node; 2624a3381e3aSUlf Hansson if (!of_match_node(idle_state_match, np)) 2625a3381e3aSUlf Hansson continue; 2626a3381e3aSUlf Hansson if (states) { 2627a3381e3aSUlf Hansson ret = genpd_parse_state(&states[i], np); 2628a3381e3aSUlf Hansson if (ret) { 2629a3381e3aSUlf Hansson pr_err("Parsing idle state node %pOF failed with err %d\n", 2630a3381e3aSUlf Hansson np, ret); 2631a3381e3aSUlf Hansson of_node_put(np); 2632a3381e3aSUlf Hansson return ret; 2633a3381e3aSUlf Hansson } 2634a3381e3aSUlf Hansson } 2635a3381e3aSUlf Hansson i++; 2636a3381e3aSUlf Hansson } 2637a3381e3aSUlf Hansson 2638a3381e3aSUlf Hansson return i; 2639a3381e3aSUlf Hansson } 2640a3381e3aSUlf Hansson 264130f60428SLina Iyer /** 264230f60428SLina Iyer * of_genpd_parse_idle_states: Return array of idle states for the genpd. 264330f60428SLina Iyer * 264430f60428SLina Iyer * @dn: The genpd device node 264530f60428SLina Iyer * @states: The pointer to which the state array will be saved. 264630f60428SLina Iyer * @n: The count of elements in the array returned from this function. 264730f60428SLina Iyer * 264830f60428SLina Iyer * Returns the device states parsed from the OF node. The memory for the states 264930f60428SLina Iyer * is allocated by this function and is the responsibility of the caller to 26502c361684SUlf Hansson * free the memory after use. If any or zero compatible domain idle states is 26512c361684SUlf Hansson * found it returns 0 and in case of errors, a negative error code is returned. 265230f60428SLina Iyer */ 265330f60428SLina Iyer int of_genpd_parse_idle_states(struct device_node *dn, 265430f60428SLina Iyer struct genpd_power_state **states, int *n) 265530f60428SLina Iyer { 265630f60428SLina Iyer struct genpd_power_state *st; 2657a3381e3aSUlf Hansson int ret; 265830f60428SLina Iyer 2659a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, NULL); 26602c361684SUlf Hansson if (ret < 0) 26612c361684SUlf Hansson return ret; 26622c361684SUlf Hansson 26632c361684SUlf Hansson if (!ret) { 26642c361684SUlf Hansson *states = NULL; 26652c361684SUlf Hansson *n = 0; 26662c361684SUlf Hansson return 0; 26672c361684SUlf Hansson } 266830f60428SLina Iyer 2669a3381e3aSUlf Hansson st = kcalloc(ret, sizeof(*st), GFP_KERNEL); 267030f60428SLina Iyer if (!st) 267130f60428SLina Iyer return -ENOMEM; 267230f60428SLina Iyer 2673a3381e3aSUlf Hansson ret = genpd_iterate_idle_states(dn, st); 2674a3381e3aSUlf Hansson if (ret <= 0) { 267530f60428SLina Iyer kfree(st); 2676a3381e3aSUlf Hansson return ret < 0 ? ret : -EINVAL; 267730f60428SLina Iyer } 267830f60428SLina Iyer 267930f60428SLina Iyer *states = st; 2680a3381e3aSUlf Hansson *n = ret; 268130f60428SLina Iyer 268230f60428SLina Iyer return 0; 268330f60428SLina Iyer } 268430f60428SLina Iyer EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states); 268530f60428SLina Iyer 26866e41766aSViresh Kumar /** 2687e38f89d3SViresh Kumar * pm_genpd_opp_to_performance_state - Gets performance state of the genpd from its OPP node. 2688e38f89d3SViresh Kumar * 2689e38f89d3SViresh Kumar * @genpd_dev: Genpd's device for which the performance-state needs to be found. 2690e38f89d3SViresh Kumar * @opp: struct dev_pm_opp of the OPP for which we need to find performance 2691e38f89d3SViresh Kumar * state. 2692e38f89d3SViresh Kumar * 2693e38f89d3SViresh Kumar * Returns performance state encoded in the OPP of the genpd. This calls 2694e38f89d3SViresh Kumar * platform specific genpd->opp_to_performance_state() callback to translate 2695e38f89d3SViresh Kumar * power domain OPP to performance state. 2696e38f89d3SViresh Kumar * 2697e38f89d3SViresh Kumar * Returns performance state on success and 0 on failure. 2698e38f89d3SViresh Kumar */ 2699e38f89d3SViresh Kumar unsigned int pm_genpd_opp_to_performance_state(struct device *genpd_dev, 2700e38f89d3SViresh Kumar struct dev_pm_opp *opp) 2701e38f89d3SViresh Kumar { 2702e38f89d3SViresh Kumar struct generic_pm_domain *genpd = NULL; 2703e38f89d3SViresh Kumar int state; 2704e38f89d3SViresh Kumar 2705e38f89d3SViresh Kumar genpd = container_of(genpd_dev, struct generic_pm_domain, dev); 2706e38f89d3SViresh Kumar 2707e38f89d3SViresh Kumar if (unlikely(!genpd->opp_to_performance_state)) 2708e38f89d3SViresh Kumar return 0; 2709e38f89d3SViresh Kumar 2710e38f89d3SViresh Kumar genpd_lock(genpd); 2711e38f89d3SViresh Kumar state = genpd->opp_to_performance_state(genpd, opp); 2712e38f89d3SViresh Kumar genpd_unlock(genpd); 2713e38f89d3SViresh Kumar 2714e38f89d3SViresh Kumar return state; 2715e38f89d3SViresh Kumar } 2716e38f89d3SViresh Kumar EXPORT_SYMBOL_GPL(pm_genpd_opp_to_performance_state); 2717e38f89d3SViresh Kumar 27183c095f32SUlf Hansson static int __init genpd_bus_init(void) 27193c095f32SUlf Hansson { 27203c095f32SUlf Hansson return bus_register(&genpd_bus_type); 27213c095f32SUlf Hansson } 27223c095f32SUlf Hansson core_initcall(genpd_bus_init); 27233c095f32SUlf Hansson 2724d30d819dSRafael J. Wysocki #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */ 27252bd5306aSMaciej Matraszek 27262bd5306aSMaciej Matraszek 27272bd5306aSMaciej Matraszek /*** debugfs support ***/ 27282bd5306aSMaciej Matraszek 27298b0510b5SJon Hunter #ifdef CONFIG_DEBUG_FS 27302bd5306aSMaciej Matraszek #include <linux/pm.h> 27312bd5306aSMaciej Matraszek #include <linux/device.h> 27322bd5306aSMaciej Matraszek #include <linux/debugfs.h> 27332bd5306aSMaciej Matraszek #include <linux/seq_file.h> 27342bd5306aSMaciej Matraszek #include <linux/init.h> 27352bd5306aSMaciej Matraszek #include <linux/kobject.h> 27369e9704eaSUlf Hansson static struct dentry *genpd_debugfs_dir; 27372bd5306aSMaciej Matraszek 27382bd5306aSMaciej Matraszek /* 27392bd5306aSMaciej Matraszek * TODO: This function is a slightly modified version of rtpm_status_show 2740d30d819dSRafael J. Wysocki * from sysfs.c, so generalize it. 27412bd5306aSMaciej Matraszek */ 27422bd5306aSMaciej Matraszek static void rtpm_status_str(struct seq_file *s, struct device *dev) 27432bd5306aSMaciej Matraszek { 27442bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 27452bd5306aSMaciej Matraszek [RPM_ACTIVE] = "active", 27462bd5306aSMaciej Matraszek [RPM_RESUMING] = "resuming", 27472bd5306aSMaciej Matraszek [RPM_SUSPENDED] = "suspended", 27482bd5306aSMaciej Matraszek [RPM_SUSPENDING] = "suspending" 27492bd5306aSMaciej Matraszek }; 27502bd5306aSMaciej Matraszek const char *p = ""; 27512bd5306aSMaciej Matraszek 27522bd5306aSMaciej Matraszek if (dev->power.runtime_error) 27532bd5306aSMaciej Matraszek p = "error"; 27542bd5306aSMaciej Matraszek else if (dev->power.disable_depth) 27552bd5306aSMaciej Matraszek p = "unsupported"; 27562bd5306aSMaciej Matraszek else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup)) 27572bd5306aSMaciej Matraszek p = status_lookup[dev->power.runtime_status]; 27582bd5306aSMaciej Matraszek else 27592bd5306aSMaciej Matraszek WARN_ON(1); 27602bd5306aSMaciej Matraszek 27612bd5306aSMaciej Matraszek seq_puts(s, p); 27622bd5306aSMaciej Matraszek } 27632bd5306aSMaciej Matraszek 27649e9704eaSUlf Hansson static int genpd_summary_one(struct seq_file *s, 276566a5ca4bSKevin Hilman struct generic_pm_domain *genpd) 27662bd5306aSMaciej Matraszek { 27672bd5306aSMaciej Matraszek static const char * const status_lookup[] = { 27682bd5306aSMaciej Matraszek [GPD_STATE_ACTIVE] = "on", 27692bd5306aSMaciej Matraszek [GPD_STATE_POWER_OFF] = "off" 27702bd5306aSMaciej Matraszek }; 27712bd5306aSMaciej Matraszek struct pm_domain_data *pm_data; 27722bd5306aSMaciej Matraszek const char *kobj_path; 27732bd5306aSMaciej Matraszek struct gpd_link *link; 27746954d432SGeert Uytterhoeven char state[16]; 27752bd5306aSMaciej Matraszek int ret; 27762bd5306aSMaciej Matraszek 277735241d12SLina Iyer ret = genpd_lock_interruptible(genpd); 27782bd5306aSMaciej Matraszek if (ret) 27792bd5306aSMaciej Matraszek return -ERESTARTSYS; 27802bd5306aSMaciej Matraszek 278166a5ca4bSKevin Hilman if (WARN_ON(genpd->status >= ARRAY_SIZE(status_lookup))) 27822bd5306aSMaciej Matraszek goto exit; 278341e2c8e0SUlf Hansson if (!genpd_status_on(genpd)) 27840ba554e4SGeert Uytterhoeven snprintf(state, sizeof(state), "%s-%u", 27856954d432SGeert Uytterhoeven status_lookup[genpd->status], genpd->state_idx); 2786fc5cbf0cSAxel Haslam else 27876954d432SGeert Uytterhoeven snprintf(state, sizeof(state), "%s", 27886954d432SGeert Uytterhoeven status_lookup[genpd->status]); 27896954d432SGeert Uytterhoeven seq_printf(s, "%-30s %-15s ", genpd->name, state); 27902bd5306aSMaciej Matraszek 27912bd5306aSMaciej Matraszek /* 27922bd5306aSMaciej Matraszek * Modifications on the list require holding locks on both 27932bd5306aSMaciej Matraszek * master and slave, so we are safe. 279466a5ca4bSKevin Hilman * Also genpd->name is immutable. 27952bd5306aSMaciej Matraszek */ 279666a5ca4bSKevin Hilman list_for_each_entry(link, &genpd->master_links, master_node) { 27972bd5306aSMaciej Matraszek seq_printf(s, "%s", link->slave->name); 279866a5ca4bSKevin Hilman if (!list_is_last(&link->master_node, &genpd->master_links)) 27992bd5306aSMaciej Matraszek seq_puts(s, ", "); 28002bd5306aSMaciej Matraszek } 28012bd5306aSMaciej Matraszek 280266a5ca4bSKevin Hilman list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2803d716f479SLina Iyer kobj_path = kobject_get_path(&pm_data->dev->kobj, 2804d716f479SLina Iyer genpd_is_irq_safe(genpd) ? 2805d716f479SLina Iyer GFP_ATOMIC : GFP_KERNEL); 28062bd5306aSMaciej Matraszek if (kobj_path == NULL) 28072bd5306aSMaciej Matraszek continue; 28082bd5306aSMaciej Matraszek 28092bd5306aSMaciej Matraszek seq_printf(s, "\n %-50s ", kobj_path); 28102bd5306aSMaciej Matraszek rtpm_status_str(s, pm_data->dev); 28112bd5306aSMaciej Matraszek kfree(kobj_path); 28122bd5306aSMaciej Matraszek } 28132bd5306aSMaciej Matraszek 28142bd5306aSMaciej Matraszek seq_puts(s, "\n"); 28152bd5306aSMaciej Matraszek exit: 281635241d12SLina Iyer genpd_unlock(genpd); 28172bd5306aSMaciej Matraszek 28182bd5306aSMaciej Matraszek return 0; 28192bd5306aSMaciej Matraszek } 28202bd5306aSMaciej Matraszek 2821d32dcc6cSYangtao Li static int summary_show(struct seq_file *s, void *data) 28222bd5306aSMaciej Matraszek { 282366a5ca4bSKevin Hilman struct generic_pm_domain *genpd; 28242bd5306aSMaciej Matraszek int ret = 0; 28252bd5306aSMaciej Matraszek 28262bd5306aSMaciej Matraszek seq_puts(s, "domain status slaves\n"); 28272bd5306aSMaciej Matraszek seq_puts(s, " /device runtime status\n"); 28282bd5306aSMaciej Matraszek seq_puts(s, "----------------------------------------------------------------------\n"); 28292bd5306aSMaciej Matraszek 28302bd5306aSMaciej Matraszek ret = mutex_lock_interruptible(&gpd_list_lock); 28312bd5306aSMaciej Matraszek if (ret) 28322bd5306aSMaciej Matraszek return -ERESTARTSYS; 28332bd5306aSMaciej Matraszek 283466a5ca4bSKevin Hilman list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 28359e9704eaSUlf Hansson ret = genpd_summary_one(s, genpd); 28362bd5306aSMaciej Matraszek if (ret) 28372bd5306aSMaciej Matraszek break; 28382bd5306aSMaciej Matraszek } 28392bd5306aSMaciej Matraszek mutex_unlock(&gpd_list_lock); 28402bd5306aSMaciej Matraszek 28412bd5306aSMaciej Matraszek return ret; 28422bd5306aSMaciej Matraszek } 28432bd5306aSMaciej Matraszek 2844d32dcc6cSYangtao Li static int status_show(struct seq_file *s, void *data) 28452bd5306aSMaciej Matraszek { 2846b6a1d093SThara Gopinath static const char * const status_lookup[] = { 2847b6a1d093SThara Gopinath [GPD_STATE_ACTIVE] = "on", 2848b6a1d093SThara Gopinath [GPD_STATE_POWER_OFF] = "off" 2849b6a1d093SThara Gopinath }; 2850b6a1d093SThara Gopinath 2851b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2852b6a1d093SThara Gopinath int ret = 0; 2853b6a1d093SThara Gopinath 2854b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2855b6a1d093SThara Gopinath if (ret) 2856b6a1d093SThara Gopinath return -ERESTARTSYS; 2857b6a1d093SThara Gopinath 2858b6a1d093SThara Gopinath if (WARN_ON_ONCE(genpd->status >= ARRAY_SIZE(status_lookup))) 2859b6a1d093SThara Gopinath goto exit; 2860b6a1d093SThara Gopinath 2861b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_POWER_OFF) 2862b6a1d093SThara Gopinath seq_printf(s, "%s-%u\n", status_lookup[genpd->status], 2863b6a1d093SThara Gopinath genpd->state_idx); 2864b6a1d093SThara Gopinath else 2865b6a1d093SThara Gopinath seq_printf(s, "%s\n", status_lookup[genpd->status]); 2866b6a1d093SThara Gopinath exit: 2867b6a1d093SThara Gopinath genpd_unlock(genpd); 2868b6a1d093SThara Gopinath return ret; 28692bd5306aSMaciej Matraszek } 28702bd5306aSMaciej Matraszek 2871d32dcc6cSYangtao Li static int sub_domains_show(struct seq_file *s, void *data) 2872b6a1d093SThara Gopinath { 2873b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2874b6a1d093SThara Gopinath struct gpd_link *link; 2875b6a1d093SThara Gopinath int ret = 0; 2876b6a1d093SThara Gopinath 2877b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2878b6a1d093SThara Gopinath if (ret) 2879b6a1d093SThara Gopinath return -ERESTARTSYS; 2880b6a1d093SThara Gopinath 2881b6a1d093SThara Gopinath list_for_each_entry(link, &genpd->master_links, master_node) 2882b6a1d093SThara Gopinath seq_printf(s, "%s\n", link->slave->name); 2883b6a1d093SThara Gopinath 2884b6a1d093SThara Gopinath genpd_unlock(genpd); 2885b6a1d093SThara Gopinath return ret; 2886b6a1d093SThara Gopinath } 2887b6a1d093SThara Gopinath 2888d32dcc6cSYangtao Li static int idle_states_show(struct seq_file *s, void *data) 2889b6a1d093SThara Gopinath { 2890b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2891b6a1d093SThara Gopinath unsigned int i; 2892b6a1d093SThara Gopinath int ret = 0; 2893b6a1d093SThara Gopinath 2894b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2895b6a1d093SThara Gopinath if (ret) 2896b6a1d093SThara Gopinath return -ERESTARTSYS; 2897b6a1d093SThara Gopinath 2898b6a1d093SThara Gopinath seq_puts(s, "State Time Spent(ms)\n"); 2899b6a1d093SThara Gopinath 2900b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2901b6a1d093SThara Gopinath ktime_t delta = 0; 2902b6a1d093SThara Gopinath s64 msecs; 2903b6a1d093SThara Gopinath 2904b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2905b6a1d093SThara Gopinath (genpd->state_idx == i)) 2906b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2907b6a1d093SThara Gopinath 2908b6a1d093SThara Gopinath msecs = ktime_to_ms( 2909b6a1d093SThara Gopinath ktime_add(genpd->states[i].idle_time, delta)); 2910b6a1d093SThara Gopinath seq_printf(s, "S%-13i %lld\n", i, msecs); 2911b6a1d093SThara Gopinath } 2912b6a1d093SThara Gopinath 2913b6a1d093SThara Gopinath genpd_unlock(genpd); 2914b6a1d093SThara Gopinath return ret; 2915b6a1d093SThara Gopinath } 2916b6a1d093SThara Gopinath 2917d32dcc6cSYangtao Li static int active_time_show(struct seq_file *s, void *data) 2918b6a1d093SThara Gopinath { 2919b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2920b6a1d093SThara Gopinath ktime_t delta = 0; 2921b6a1d093SThara Gopinath int ret = 0; 2922b6a1d093SThara Gopinath 2923b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2924b6a1d093SThara Gopinath if (ret) 2925b6a1d093SThara Gopinath return -ERESTARTSYS; 2926b6a1d093SThara Gopinath 2927b6a1d093SThara Gopinath if (genpd->status == GPD_STATE_ACTIVE) 2928b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2929b6a1d093SThara Gopinath 2930b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms( 2931b6a1d093SThara Gopinath ktime_add(genpd->on_time, delta))); 2932b6a1d093SThara Gopinath 2933b6a1d093SThara Gopinath genpd_unlock(genpd); 2934b6a1d093SThara Gopinath return ret; 2935b6a1d093SThara Gopinath } 2936b6a1d093SThara Gopinath 2937d32dcc6cSYangtao Li static int total_idle_time_show(struct seq_file *s, void *data) 2938b6a1d093SThara Gopinath { 2939b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2940b6a1d093SThara Gopinath ktime_t delta = 0, total = 0; 2941b6a1d093SThara Gopinath unsigned int i; 2942b6a1d093SThara Gopinath int ret = 0; 2943b6a1d093SThara Gopinath 2944b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2945b6a1d093SThara Gopinath if (ret) 2946b6a1d093SThara Gopinath return -ERESTARTSYS; 2947b6a1d093SThara Gopinath 2948b6a1d093SThara Gopinath for (i = 0; i < genpd->state_count; i++) { 2949b6a1d093SThara Gopinath 2950b6a1d093SThara Gopinath if ((genpd->status == GPD_STATE_POWER_OFF) && 2951b6a1d093SThara Gopinath (genpd->state_idx == i)) 2952b6a1d093SThara Gopinath delta = ktime_sub(ktime_get(), genpd->accounting_time); 2953b6a1d093SThara Gopinath 2954b6a1d093SThara Gopinath total = ktime_add(total, genpd->states[i].idle_time); 2955b6a1d093SThara Gopinath } 2956b6a1d093SThara Gopinath total = ktime_add(total, delta); 2957b6a1d093SThara Gopinath 2958b6a1d093SThara Gopinath seq_printf(s, "%lld ms\n", ktime_to_ms(total)); 2959b6a1d093SThara Gopinath 2960b6a1d093SThara Gopinath genpd_unlock(genpd); 2961b6a1d093SThara Gopinath return ret; 2962b6a1d093SThara Gopinath } 2963b6a1d093SThara Gopinath 2964b6a1d093SThara Gopinath 2965d32dcc6cSYangtao Li static int devices_show(struct seq_file *s, void *data) 2966b6a1d093SThara Gopinath { 2967b6a1d093SThara Gopinath struct generic_pm_domain *genpd = s->private; 2968b6a1d093SThara Gopinath struct pm_domain_data *pm_data; 2969b6a1d093SThara Gopinath const char *kobj_path; 2970b6a1d093SThara Gopinath int ret = 0; 2971b6a1d093SThara Gopinath 2972b6a1d093SThara Gopinath ret = genpd_lock_interruptible(genpd); 2973b6a1d093SThara Gopinath if (ret) 2974b6a1d093SThara Gopinath return -ERESTARTSYS; 2975b6a1d093SThara Gopinath 2976b6a1d093SThara Gopinath list_for_each_entry(pm_data, &genpd->dev_list, list_node) { 2977b6a1d093SThara Gopinath kobj_path = kobject_get_path(&pm_data->dev->kobj, 2978b6a1d093SThara Gopinath genpd_is_irq_safe(genpd) ? 2979b6a1d093SThara Gopinath GFP_ATOMIC : GFP_KERNEL); 2980b6a1d093SThara Gopinath if (kobj_path == NULL) 2981b6a1d093SThara Gopinath continue; 2982b6a1d093SThara Gopinath 2983b6a1d093SThara Gopinath seq_printf(s, "%s\n", kobj_path); 2984b6a1d093SThara Gopinath kfree(kobj_path); 2985b6a1d093SThara Gopinath } 2986b6a1d093SThara Gopinath 2987b6a1d093SThara Gopinath genpd_unlock(genpd); 2988b6a1d093SThara Gopinath return ret; 2989b6a1d093SThara Gopinath } 2990b6a1d093SThara Gopinath 2991d32dcc6cSYangtao Li static int perf_state_show(struct seq_file *s, void *data) 2992e8912812SRajendra Nayak { 2993e8912812SRajendra Nayak struct generic_pm_domain *genpd = s->private; 2994e8912812SRajendra Nayak 2995e8912812SRajendra Nayak if (genpd_lock_interruptible(genpd)) 2996e8912812SRajendra Nayak return -ERESTARTSYS; 2997e8912812SRajendra Nayak 2998e8912812SRajendra Nayak seq_printf(s, "%u\n", genpd->performance_state); 2999e8912812SRajendra Nayak 3000e8912812SRajendra Nayak genpd_unlock(genpd); 3001e8912812SRajendra Nayak return 0; 3002e8912812SRajendra Nayak } 3003e8912812SRajendra Nayak 3004d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(summary); 3005d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(status); 3006d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(sub_domains); 3007d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(idle_states); 3008d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(active_time); 3009d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(total_idle_time); 3010d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(devices); 3011d32dcc6cSYangtao Li DEFINE_SHOW_ATTRIBUTE(perf_state); 30122bd5306aSMaciej Matraszek 30139e9704eaSUlf Hansson static int __init genpd_debug_init(void) 30142bd5306aSMaciej Matraszek { 30152bd5306aSMaciej Matraszek struct dentry *d; 3016b6a1d093SThara Gopinath struct generic_pm_domain *genpd; 30172bd5306aSMaciej Matraszek 30189e9704eaSUlf Hansson genpd_debugfs_dir = debugfs_create_dir("pm_genpd", NULL); 30192bd5306aSMaciej Matraszek 3020e16a42c3SGreg Kroah-Hartman debugfs_create_file("pm_genpd_summary", S_IRUGO, genpd_debugfs_dir, 3021e16a42c3SGreg Kroah-Hartman NULL, &summary_fops); 30222bd5306aSMaciej Matraszek 3023b6a1d093SThara Gopinath list_for_each_entry(genpd, &gpd_list, gpd_list_node) { 30249e9704eaSUlf Hansson d = debugfs_create_dir(genpd->name, genpd_debugfs_dir); 3025b6a1d093SThara Gopinath 3026b6a1d093SThara Gopinath debugfs_create_file("current_state", 0444, 3027d32dcc6cSYangtao Li d, genpd, &status_fops); 3028b6a1d093SThara Gopinath debugfs_create_file("sub_domains", 0444, 3029d32dcc6cSYangtao Li d, genpd, &sub_domains_fops); 3030b6a1d093SThara Gopinath debugfs_create_file("idle_states", 0444, 3031d32dcc6cSYangtao Li d, genpd, &idle_states_fops); 3032b6a1d093SThara Gopinath debugfs_create_file("active_time", 0444, 3033d32dcc6cSYangtao Li d, genpd, &active_time_fops); 3034b6a1d093SThara Gopinath debugfs_create_file("total_idle_time", 0444, 3035d32dcc6cSYangtao Li d, genpd, &total_idle_time_fops); 3036b6a1d093SThara Gopinath debugfs_create_file("devices", 0444, 3037d32dcc6cSYangtao Li d, genpd, &devices_fops); 3038e8912812SRajendra Nayak if (genpd->set_performance_state) 3039e8912812SRajendra Nayak debugfs_create_file("perf_state", 0444, 3040d32dcc6cSYangtao Li d, genpd, &perf_state_fops); 3041b6a1d093SThara Gopinath } 3042b6a1d093SThara Gopinath 30432bd5306aSMaciej Matraszek return 0; 30442bd5306aSMaciej Matraszek } 30459e9704eaSUlf Hansson late_initcall(genpd_debug_init); 30462bd5306aSMaciej Matraszek 30479e9704eaSUlf Hansson static void __exit genpd_debug_exit(void) 30482bd5306aSMaciej Matraszek { 30499e9704eaSUlf Hansson debugfs_remove_recursive(genpd_debugfs_dir); 30502bd5306aSMaciej Matraszek } 30519e9704eaSUlf Hansson __exitcall(genpd_debug_exit); 30528b0510b5SJon Hunter #endif /* CONFIG_DEBUG_FS */ 3053