Lines Matching refs:dev
30 #define GENPD_DEV_CALLBACK(genpd, type, callback, dev) \
37 __ret = __routine(dev); \
134 static inline bool irq_safe_dev_in_sleep_domain(struct device *dev,
139 ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd);
150 dev_warn_once(dev, "PM domain %s will not be powered off\n",
156 static int genpd_runtime_suspend(struct device *dev);
164 static struct generic_pm_domain *dev_to_genpd_safe(struct device *dev)
166 if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain))
170 if (dev->pm_domain->ops.runtime_suspend == genpd_runtime_suspend)
171 return pd_to_genpd(dev->pm_domain);
180 static struct generic_pm_domain *dev_to_genpd(struct device *dev)
182 if (IS_ERR_OR_NULL(dev->pm_domain))
185 return pd_to_genpd(dev->pm_domain);
189 struct device *dev)
191 return GENPD_DEV_CALLBACK(genpd, int, stop, dev);
195 struct device *dev)
197 return GENPD_DEV_CALLBACK(genpd, int, start, dev);
384 static int genpd_set_performance_state(struct device *dev, unsigned int state)
386 struct generic_pm_domain *genpd = dev_to_genpd(dev);
387 struct generic_pm_domain_data *gpd_data = dev_gpd_data(dev);
405 static int genpd_drop_performance_state(struct device *dev)
407 unsigned int prev_state = dev_gpd_data(dev)->performance_state;
409 if (!genpd_set_performance_state(dev, 0))
415 static void genpd_restore_performance_state(struct device *dev,
419 genpd_set_performance_state(dev, state);
426 * @dev: Device for which the performance-state needs to be set.
437 int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state)
442 genpd = dev_to_genpd_safe(dev);
446 if (WARN_ON(!dev->power.subsys_data ||
447 !dev->power.subsys_data->domain_data))
451 if (pm_runtime_suspended(dev)) {
452 dev_gpd_data(dev)->rpm_pstate = state;
454 ret = genpd_set_performance_state(dev, state);
456 dev_gpd_data(dev)->rpm_pstate = 0;
467 * @dev: Device to handle
473 * called. Additionally, it's also assumed that @dev isn't runtime suspended
479 void dev_pm_genpd_set_next_wakeup(struct device *dev, ktime_t next)
484 genpd = dev_to_genpd_safe(dev);
488 td = to_gpd_data(dev->power.subsys_data->domain_data)->td;
496 * @dev: A device that is attached to the genpd.
504 ktime_t dev_pm_genpd_get_next_hrtimer(struct device *dev)
508 genpd = dev_to_genpd_safe(dev);
522 * @dev: A device that is attached to the genpd.
530 void dev_pm_genpd_synced_poweroff(struct device *dev)
534 genpd = dev_to_genpd_safe(dev);
712 if (!pm_runtime_suspended(pdd->dev) ||
713 irq_safe_dev_in_sleep_domain(pdd->dev, genpd))
811 static int genpd_dev_pm_start(struct device *dev)
813 struct generic_pm_domain *genpd = dev_to_genpd(dev);
815 return genpd_start_dev(genpd, dev);
822 struct device *dev;
825 dev = gpd_data->base.dev;
832 spin_lock_irq(&dev->power.lock);
834 pdd = dev->power.subsys_data ?
835 dev->power.subsys_data->domain_data : NULL;
840 genpd = dev_to_genpd(dev);
844 spin_unlock_irq(&dev->power.lock);
852 dev = dev->parent;
853 if (!dev || dev->power.ignore_children)
877 * @dev: Device to handle.
879 static int __genpd_runtime_suspend(struct device *dev)
883 if (dev->type && dev->type->pm)
884 cb = dev->type->pm->runtime_suspend;
885 else if (dev->class && dev->class->pm)
886 cb = dev->class->pm->runtime_suspend;
887 else if (dev->bus && dev->bus->pm)
888 cb = dev->bus->pm->runtime_suspend;
892 if (!cb && dev->driver && dev->driver->pm)
893 cb = dev->driver->pm->runtime_suspend;
895 return cb ? cb(dev) : 0;
900 * @dev: Device to handle.
902 static int __genpd_runtime_resume(struct device *dev)
906 if (dev->type && dev->type->pm)
907 cb = dev->type->pm->runtime_resume;
908 else if (dev->class && dev->class->pm)
909 cb = dev->class->pm->runtime_resume;
910 else if (dev->bus && dev->bus->pm)
911 cb = dev->bus->pm->runtime_resume;
915 if (!cb && dev->driver && dev->driver->pm)
916 cb = dev->driver->pm->runtime_resume;
918 return cb ? cb(dev) : 0;
923 * @dev: Device to suspend.
929 static int genpd_runtime_suspend(struct device *dev)
933 struct generic_pm_domain_data *gpd_data = dev_gpd_data(dev);
935 bool runtime_pm = pm_runtime_enabled(dev);
940 dev_dbg(dev, "%s()\n", __func__);
942 genpd = dev_to_genpd(dev);
953 if (runtime_pm && suspend_ok && !suspend_ok(dev))
960 ret = __genpd_runtime_suspend(dev);
964 ret = genpd_stop_dev(genpd, dev);
966 __genpd_runtime_resume(dev);
975 dev_dbg(dev, "suspend latency exceeded, %lld ns\n",
986 if (irq_safe_dev_in_sleep_domain(dev, genpd))
991 gpd_data->rpm_pstate = genpd_drop_performance_state(dev);
999 * @dev: Device to resume.
1005 static int genpd_runtime_resume(struct device *dev)
1008 struct generic_pm_domain_data *gpd_data = dev_gpd_data(dev);
1010 bool timed = td && pm_runtime_enabled(dev);
1015 dev_dbg(dev, "%s()\n", __func__);
1017 genpd = dev_to_genpd(dev);
1025 if (irq_safe_dev_in_sleep_domain(dev, genpd))
1029 genpd_restore_performance_state(dev, gpd_data->rpm_pstate);
1041 ret = genpd_start_dev(genpd, dev);
1045 ret = __genpd_runtime_resume(dev);
1054 dev_dbg(dev, "resume latency exceeded, %lld ns\n",
1064 genpd_stop_dev(genpd, dev);
1066 if (!pm_runtime_is_irq_safe(dev) || genpd_is_irq_safe(genpd)) {
1069 gpd_data->rpm_pstate = genpd_drop_performance_state(dev);
1197 * @dev: Device to start the transition of.
1204 static int genpd_prepare(struct device *dev)
1209 dev_dbg(dev, "%s()\n", __func__);
1211 genpd = dev_to_genpd(dev);
1222 ret = pm_generic_prepare(dev);
1238 * @dev: Device to suspend.
1245 static int genpd_finish_suspend(struct device *dev,
1246 int (*suspend_noirq)(struct device *dev),
1247 int (*resume_noirq)(struct device *dev))
1252 genpd = dev_to_genpd(dev);
1256 ret = suspend_noirq(dev);
1260 if (device_wakeup_path(dev) && genpd_is_active_wakeup(genpd))
1264 !pm_runtime_status_suspended(dev)) {
1265 ret = genpd_stop_dev(genpd, dev);
1267 resume_noirq(dev);
1282 * @dev: Device to suspend.
1287 static int genpd_suspend_noirq(struct device *dev)
1289 dev_dbg(dev, "%s()\n", __func__);
1291 return genpd_finish_suspend(dev,
1298 * @dev: Device to resume.
1303 static int genpd_finish_resume(struct device *dev,
1304 int (*resume_noirq)(struct device *dev))
1309 dev_dbg(dev, "%s()\n", __func__);
1311 genpd = dev_to_genpd(dev);
1315 if (device_wakeup_path(dev) && genpd_is_active_wakeup(genpd))
1316 return resume_noirq(dev);
1324 !pm_runtime_status_suspended(dev)) {
1325 ret = genpd_start_dev(genpd, dev);
1330 return pm_generic_resume_noirq(dev);
1335 * @dev: Device to resume.
1339 static int genpd_resume_noirq(struct device *dev)
1341 dev_dbg(dev, "%s()\n", __func__);
1343 return genpd_finish_resume(dev, pm_generic_resume_noirq);
1348 * @dev: Device to freeze.
1355 static int genpd_freeze_noirq(struct device *dev)
1357 dev_dbg(dev, "%s()\n", __func__);
1359 return genpd_finish_suspend(dev,
1366 * @dev: Device to thaw.
1371 static int genpd_thaw_noirq(struct device *dev)
1373 dev_dbg(dev, "%s()\n", __func__);
1375 return genpd_finish_resume(dev, pm_generic_thaw_noirq);
1381 * @dev: Device to poweroff.
1386 static int genpd_poweroff_noirq(struct device *dev)
1388 dev_dbg(dev, "%s()\n", __func__);
1390 return genpd_finish_suspend(dev,
1397 * @dev: Device to resume.
1402 static int genpd_restore_noirq(struct device *dev)
1404 dev_dbg(dev, "%s()\n", __func__);
1406 return genpd_finish_resume(dev, pm_generic_restore_noirq);
1411 * @dev: Device to complete the transition of.
1418 static void genpd_complete(struct device *dev)
1422 dev_dbg(dev, "%s()\n", __func__);
1424 genpd = dev_to_genpd(dev);
1428 pm_generic_complete(dev);
1439 static void genpd_switch_state(struct device *dev, bool suspend)
1444 genpd = dev_to_genpd_safe(dev);
1466 * dev_pm_genpd_suspend - Synchronously try to suspend the genpd for @dev
1467 * @dev: The device that is attached to the genpd, that can be suspended.
1474 void dev_pm_genpd_suspend(struct device *dev)
1476 genpd_switch_state(dev, true);
1481 * dev_pm_genpd_resume - Synchronously try to resume the genpd for @dev
1482 * @dev: The device that is attached to the genpd, which needs to be resumed.
1488 void dev_pm_genpd_resume(struct device *dev)
1490 genpd_switch_state(dev, false);
1507 static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,
1514 ret = dev_pm_get_subsys_data(dev);
1524 gpd_data->base.dev = dev;
1541 spin_lock_irq(&dev->power.lock);
1543 if (dev->power.subsys_data->domain_data)
1546 dev->power.subsys_data->domain_data = &gpd_data->base;
1548 spin_unlock_irq(&dev->power.lock);
1559 dev_pm_put_subsys_data(dev);
1563 static void genpd_free_dev_data(struct device *dev,
1566 spin_lock_irq(&dev->power.lock);
1568 dev->power.subsys_data->domain_data = NULL;
1570 spin_unlock_irq(&dev->power.lock);
1574 dev_pm_put_subsys_data(dev);
1611 static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev)
1619 if (get_cpu_device(cpu) == dev)
1626 static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
1633 dev_dbg(dev, "%s()\n", __func__);
1635 gpd_data = genpd_alloc_dev_data(dev, gd);
1641 ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0;
1648 dev_pm_domain_set(dev, &genpd->domain);
1659 genpd_free_dev_data(dev, gpd_data);
1661 dev_pm_qos_add_notifier(dev, &gpd_data->nb,
1670 * @dev: Device to be added.
1672 int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
1676 if (!genpd || !dev)
1680 ret = genpd_add_device(genpd, dev, dev);
1688 struct device *dev)
1694 dev_dbg(dev, "%s()\n", __func__);
1696 pdd = dev->power.subsys_data->domain_data;
1698 dev_pm_qos_remove_notifier(dev, &gpd_data->nb,
1713 dev_pm_domain_set(dev, NULL);
1720 genpd->detach_dev(genpd, dev);
1722 genpd_free_dev_data(dev, gpd_data);
1728 dev_pm_qos_add_notifier(dev, &gpd_data->nb, DEV_PM_QOS_RESUME_LATENCY);
1735 * @dev: Device to be removed.
1737 int pm_genpd_remove_device(struct device *dev)
1739 struct generic_pm_domain *genpd = dev_to_genpd_safe(dev);
1744 return genpd_remove_device(genpd, dev);
1749 * dev_pm_genpd_add_notifier - Add a genpd power on/off notifier for @dev
1751 * @dev: Device that should be associated with the notifier
1755 * attached @dev. Only one notifier per device is allowed. The notifier is
1763 int dev_pm_genpd_add_notifier(struct device *dev, struct notifier_block *nb)
1769 genpd = dev_to_genpd_safe(dev);
1773 if (WARN_ON(!dev->power.subsys_data ||
1774 !dev->power.subsys_data->domain_data))
1777 gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
1786 dev_warn(dev, "failed to add notifier for PM domain %s\n",
1797 * dev_pm_genpd_remove_notifier - Remove a genpd power on/off notifier for @dev
1799 * @dev: Device that is associated with the notifier
1802 * attached @dev.
1809 int dev_pm_genpd_remove_notifier(struct device *dev)
1815 genpd = dev_to_genpd_safe(dev);
1819 if (WARN_ON(!dev->power.subsys_data ||
1820 !dev->power.subsys_data->domain_data))
1823 gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
1833 dev_warn(dev, "failed to remove notifier for PM domain %s\n",
2107 device_initialize(&genpd->dev);
2108 dev_set_name(&genpd->dev, "%s", genpd->name);
2328 genpd->dev.of_node = np;
2332 ret = dev_pm_opp_of_add_table(&genpd->dev);
2334 return dev_err_probe(&genpd->dev, ret, "Failed to add OPP table\n");
2340 genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev);
2348 dev_pm_opp_of_remove_table(&genpd->dev);
2387 genpd->dev.of_node = np;
2391 ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i);
2393 dev_err_probe(&genpd->dev, ret,
2402 genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev);
2428 dev_pm_opp_of_remove_table(&genpd->dev);
2462 dev_pm_opp_of_remove_table(&gpd->dev);
2516 * @dev: Device to be added.
2521 int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev)
2526 if (!dev)
2537 ret = genpd_add_device(genpd, dev, dev);
2657 static void genpd_release_dev(struct device *dev)
2659 of_node_put(dev->of_node);
2660 kfree(dev);
2669 * @dev: Device to detach.
2675 static void genpd_dev_pm_detach(struct device *dev, bool power_off)
2681 pd = dev_to_genpd(dev);
2685 dev_dbg(dev, "removing from PM domain %s\n", pd->name);
2688 if (dev_gpd_data(dev)->default_pstate) {
2689 dev_pm_genpd_set_performance_state(dev, 0);
2690 dev_gpd_data(dev)->default_pstate = 0;
2694 ret = genpd_remove_device(pd, dev);
2703 dev_err(dev, "failed to remove from PM domain %s: %d",
2712 if (dev->bus == &genpd_bus_type)
2713 device_unregister(dev);
2716 static void genpd_dev_pm_sync(struct device *dev)
2720 pd = dev_to_genpd(dev);
2727 static int __genpd_dev_pm_attach(struct device *dev, struct device *base_dev,
2735 ret = of_parse_phandle_with_args(dev->of_node, "power-domains",
2745 dev_dbg(dev, "%s() failed to find PM domain: %ld\n",
2750 dev_dbg(dev, "adding to PM domain %s\n", pd->name);
2752 ret = genpd_add_device(pd, dev, base_dev);
2756 return dev_err_probe(dev, ret, "failed to add to PM domain %s\n", pd->name);
2758 dev->pm_domain->detach = genpd_dev_pm_detach;
2759 dev->pm_domain->sync = genpd_dev_pm_sync;
2762 pstate = of_get_required_opp_performance_state(dev->of_node, index);
2767 ret = dev_pm_genpd_set_performance_state(dev, pstate);
2770 dev_gpd_data(dev)->default_pstate = pstate;
2781 if (dev_gpd_data(dev)->default_pstate) {
2782 dev_pm_genpd_set_performance_state(dev, 0);
2783 dev_gpd_data(dev)->default_pstate = 0;
2786 genpd_remove_device(pd, dev);
2793 dev_err(dev, "failed to set required performance state for power-domain %s: %d\n",
2795 genpd_remove_device(pd, dev);
2801 * @dev: Device to attach.
2812 int genpd_dev_pm_attach(struct device *dev)
2814 if (!dev->of_node)
2821 if (of_count_phandle_with_args(dev->of_node, "power-domains",
2825 return __genpd_dev_pm_attach(dev, dev, 0, true);
2831 * @dev: The device used to lookup the PM domain.
2845 struct device *genpd_dev_pm_attach_by_id(struct device *dev,
2852 if (!dev->of_node)
2856 num_domains = of_count_phandle_with_args(dev->of_node, "power-domains",
2866 dev_set_name(virt_dev, "genpd:%u:%s", index, dev_name(dev));
2869 virt_dev->of_node = of_node_get(dev->of_node);
2878 ret = __genpd_dev_pm_attach(virt_dev, dev, index, false);
2893 * @dev: The device used to lookup the PM domain.
2900 struct device *genpd_dev_pm_attach_by_name(struct device *dev, const char *name)
2904 if (!dev->of_node)
2907 index = of_property_match_string(dev->of_node, "power-domain-names",
2912 return genpd_dev_pm_attach_by_id(dev, index);
3054 genpd = container_of(genpd_dev, struct generic_pm_domain, dev);
3083 static void rtpm_status_str(struct seq_file *s, struct device *dev)
3093 if (dev->power.runtime_error)
3095 else if (dev->power.disable_depth)
3097 else if (dev->power.runtime_status < ARRAY_SIZE(status_lookup))
3098 p = status_lookup[dev->power.runtime_status];
3105 static void perf_status_str(struct seq_file *s, struct device *dev)
3109 gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
3154 kobj_path = kobject_get_path(&pm_data->dev->kobj,
3161 rtpm_status_str(s, pm_data->dev);
3162 perf_status_str(s, pm_data->dev);
3340 kobj_path = kobject_get_path(&pm_data->dev->kobj,