tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'pm+acpi-3.19-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull power management and ACPI material from Rafael J Wysocki:
"These are fixes (operating performance points library, cpufreq-dt
driver, cpufreq core, ACPI backlight, cpupower tool), cleanups
(cpuidle), new processor IDs for the RAPL (Running Average Power
Limit) power capping driver, and a modification of the generic power
domains framework allowing modular drivers to call one of its helper
functions.

Specifics:

- Fix for a potential NULL pointer dereference in the cpufreq core
due to an initialization race condition (Ethan Zhao).

- Fixes for abuse of the OPP (Operating Performance Points) API
related to RCU and other minor issues in the OPP library and the
cpufreq-dt driver (Dmitry Torokhov).

- cpuidle governors cleanup making them measure idle duration in a
better way without using the CPUIDLE_FLAG_TIME_INVALID flag which
allows that flag to be dropped from the ACPI cpuidle driver and
from the core too (Len Brown).

- New ACPI backlight blacklist entries for Samsung machines without a
working native backlight interface that need to use the ACPI
backlight instead (Aaron Lu).

- New CPU IDs of future Intel Xeon CPUs for the Intel RAPL power
capping driver (Jacob Pan).

- Generic power domains framework modification to export the
of_genpd_get_from_provider() function to modular drivers that will
allow future driver modifications to be based on the mainline (Amit
Daniel Kachhap).

- Two fixes for the cpupower tool (Michal Privoznik, Prarit
Bhargava)"

* tag 'pm+acpi-3.19-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
ACPI / video: Add some Samsung models to disable_native_backlight list
tools / cpupower: Fix no idle state information return value
tools / cpupower: Correctly detect if running as root
cpufreq: fix a NULL pointer dereference in __cpufreq_governor()
cpufreq-dt: defer probing if OPP table is not ready
PM / OPP: take RCU lock in dev_pm_opp_get_opp_count
PM / OPP: fix warning in of_free_opp_table()
PM / OPP: add some lockdep annotations
powercap / RAPL: add IDs for future Xeon CPUs
PM / Domains: Export of_genpd_get_from_provider function
cpuidle / ACPI: remove unused CPUIDLE_FLAG_TIME_INVALID
cpuidle: ladder: Better idle duration measurement without using CPUIDLE_FLAG_TIME_INVALID
cpuidle: menu: Better idle duration measurement without using CPUIDLE_FLAG_TIME_INVALID

Linus Torvalds df90dcd1 346eef2f

+91 -39
-2
drivers/acpi/processor_idle.c
··· 985 985 state->flags = 0; 986 986 switch (cx->type) { 987 987 case ACPI_STATE_C1: 988 - if (cx->entry_method != ACPI_CSTATE_FFH) 989 - state->flags |= CPUIDLE_FLAG_TIME_INVALID; 990 988 991 989 state->enter = acpi_idle_enter_c1; 992 990 state->enter_dead = acpi_idle_play_dead;
+17
drivers/acpi/video.c
··· 505 505 DMI_MATCH(DMI_PRODUCT_NAME, "HP ENVY 15 Notebook PC"), 506 506 }, 507 507 }, 508 + 509 + { 510 + .callback = video_disable_native_backlight, 511 + .ident = "SAMSUNG 870Z5E/880Z5E/680Z5E", 512 + .matches = { 513 + DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 514 + DMI_MATCH(DMI_PRODUCT_NAME, "870Z5E/880Z5E/680Z5E"), 515 + }, 516 + }, 517 + { 518 + .callback = video_disable_native_backlight, 519 + .ident = "SAMSUNG 370R4E/370R4V/370R5E/3570RE/370R5V", 520 + .matches = { 521 + DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 522 + DMI_MATCH(DMI_PRODUCT_NAME, "370R4E/370R4V/370R5E/3570RE/370R5V"), 523 + }, 524 + }, 508 525 {} 509 526 }; 510 527
+2 -1
drivers/base/power/domain.c
··· 2088 2088 * Returns a valid pointer to struct generic_pm_domain on success or ERR_PTR() 2089 2089 * on failure. 2090 2090 */ 2091 - static struct generic_pm_domain *of_genpd_get_from_provider( 2091 + struct generic_pm_domain *of_genpd_get_from_provider( 2092 2092 struct of_phandle_args *genpdspec) 2093 2093 { 2094 2094 struct generic_pm_domain *genpd = ERR_PTR(-ENOENT); ··· 2108 2108 2109 2109 return genpd; 2110 2110 } 2111 + EXPORT_SYMBOL_GPL(of_genpd_get_from_provider); 2111 2112 2112 2113 /** 2113 2114 * genpd_dev_pm_detach - Detach a device from its PM domain.
+31 -8
drivers/base/power/opp.c
··· 108 108 /* Lock to allow exclusive modification to the device and opp lists */ 109 109 static DEFINE_MUTEX(dev_opp_list_lock); 110 110 111 + #define opp_rcu_lockdep_assert() \ 112 + do { \ 113 + rcu_lockdep_assert(rcu_read_lock_held() || \ 114 + lockdep_is_held(&dev_opp_list_lock), \ 115 + "Missing rcu_read_lock() or " \ 116 + "dev_opp_list_lock protection"); \ 117 + } while (0) 118 + 111 119 /** 112 120 * find_device_opp() - find device_opp struct using device pointer 113 121 * @dev: device pointer used to lookup device OPPs ··· 216 208 * This function returns the number of available opps if there are any, 217 209 * else returns 0 if none or the corresponding error value. 218 210 * 219 - * Locking: This function must be called under rcu_read_lock(). This function 220 - * internally references two RCU protected structures: device_opp and opp which 221 - * are safe as long as we are under a common RCU locked section. 211 + * Locking: This function takes rcu_read_lock(). 222 212 */ 223 213 int dev_pm_opp_get_opp_count(struct device *dev) 224 214 { ··· 224 218 struct dev_pm_opp *temp_opp; 225 219 int count = 0; 226 220 221 + rcu_read_lock(); 222 + 227 223 dev_opp = find_device_opp(dev); 228 224 if (IS_ERR(dev_opp)) { 229 - int r = PTR_ERR(dev_opp); 230 - dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r); 231 - return r; 225 + count = PTR_ERR(dev_opp); 226 + dev_err(dev, "%s: device OPP not found (%d)\n", 227 + __func__, count); 228 + goto out_unlock; 232 229 } 233 230 234 231 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) { ··· 239 230 count++; 240 231 } 241 232 233 + out_unlock: 234 + rcu_read_unlock(); 242 235 return count; 243 236 } 244 237 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count); ··· 277 266 { 278 267 struct device_opp *dev_opp; 279 268 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE); 269 + 270 + opp_rcu_lockdep_assert(); 280 271 281 272 dev_opp = find_device_opp(dev); 282 273 if (IS_ERR(dev_opp)) { ··· 325 312 { 326 313 struct device_opp *dev_opp; 327 314 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE); 315 + 316 + opp_rcu_lockdep_assert(); 328 317 329 318 if (!dev || !freq) { 330 319 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq); ··· 375 360 { 376 361 struct device_opp *dev_opp; 377 362 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE); 363 + 364 + opp_rcu_lockdep_assert(); 378 365 379 366 if (!dev || !freq) { 380 367 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq); ··· 800 783 801 784 /* Check for existing list for 'dev' */ 802 785 dev_opp = find_device_opp(dev); 803 - if (WARN(IS_ERR(dev_opp), "%s: dev_opp: %ld\n", dev_name(dev), 804 - PTR_ERR(dev_opp))) 786 + if (IS_ERR(dev_opp)) { 787 + int error = PTR_ERR(dev_opp); 788 + if (error != -ENODEV) 789 + WARN(1, "%s: dev_opp: %d\n", 790 + IS_ERR_OR_NULL(dev) ? 791 + "Invalid device" : dev_name(dev), 792 + error); 805 793 return; 794 + } 806 795 807 796 /* Hold our list modification lock here */ 808 797 mutex_lock(&dev_opp_list_lock);
+11
drivers/cpufreq/cpufreq-dt.c
··· 211 211 /* OPPs might be populated at runtime, don't check for error here */ 212 212 of_init_opp_table(cpu_dev); 213 213 214 + /* 215 + * But we need OPP table to function so if it is not there let's 216 + * give platform code chance to provide it for us. 217 + */ 218 + ret = dev_pm_opp_get_opp_count(cpu_dev); 219 + if (ret <= 0) { 220 + pr_debug("OPP table is not ready, deferring probe\n"); 221 + ret = -EPROBE_DEFER; 222 + goto out_free_opp; 223 + } 224 + 214 225 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 215 226 if (!priv) { 216 227 ret = -ENOMEM;
+6
drivers/cpufreq/cpufreq.c
··· 2028 2028 /* Don't start any governor operations if we are entering suspend */ 2029 2029 if (cpufreq_suspended) 2030 2030 return 0; 2031 + /* 2032 + * Governor might not be initiated here if ACPI _PPC changed 2033 + * notification happened, so check it. 2034 + */ 2035 + if (!policy->governor) 2036 + return -EINVAL; 2031 2037 2032 2038 if (policy->governor->max_transition_latency && 2033 2039 policy->cpuinfo.transition_latency >
+1 -6
drivers/cpuidle/governors/ladder.c
··· 79 79 80 80 last_state = &ldev->states[last_idx]; 81 81 82 - if (!(drv->states[last_idx].flags & CPUIDLE_FLAG_TIME_INVALID)) { 83 - last_residency = cpuidle_get_last_residency(dev) - \ 84 - drv->states[last_idx].exit_latency; 85 - } 86 - else 87 - last_residency = last_state->threshold.promotion_time + 1; 82 + last_residency = cpuidle_get_last_residency(dev) - drv->states[last_idx].exit_latency; 88 83 89 84 /* consider promotion */ 90 85 if (last_idx < drv->state_count - 1 &&
+12 -17
drivers/cpuidle/governors/menu.c
··· 396 396 * power state and occurrence of the wakeup event. 397 397 * 398 398 * If the entered idle state didn't support residency measurements, 399 - * we are basically lost in the dark how much time passed. 400 - * As a compromise, assume we slept for the whole expected time. 399 + * we use them anyway if they are short, and if long, 400 + * truncate to the whole expected time. 401 401 * 402 402 * Any measured amount of time will include the exit latency. 403 403 * Since we are interested in when the wakeup begun, not when it ··· 405 405 * the measured amount of time is less than the exit latency, 406 406 * assume the state was never reached and the exit latency is 0. 407 407 */ 408 - if (unlikely(target->flags & CPUIDLE_FLAG_TIME_INVALID)) { 409 - /* Use timer value as is */ 408 + 409 + /* measured value */ 410 + measured_us = cpuidle_get_last_residency(dev); 411 + 412 + /* Deduct exit latency */ 413 + if (measured_us > target->exit_latency) 414 + measured_us -= target->exit_latency; 415 + 416 + /* Make sure our coefficients do not exceed unity */ 417 + if (measured_us > data->next_timer_us) 410 418 measured_us = data->next_timer_us; 411 - 412 - } else { 413 - /* Use measured value */ 414 - measured_us = cpuidle_get_last_residency(dev); 415 - 416 - /* Deduct exit latency */ 417 - if (measured_us > target->exit_latency) 418 - measured_us -= target->exit_latency; 419 - 420 - /* Make sure our coefficients do not exceed unity */ 421 - if (measured_us > data->next_timer_us) 422 - measured_us = data->next_timer_us; 423 - } 424 419 425 420 /* Update our correction ratio */ 426 421 new_factor = data->correction_factor[data->bucket];
+1
drivers/powercap/intel_rapl.c
··· 1041 1041 RAPL_CPU(0x45, rapl_defaults_core),/* Haswell ULT */ 1042 1042 RAPL_CPU(0x4C, rapl_defaults_atom),/* Braswell */ 1043 1043 RAPL_CPU(0x4A, rapl_defaults_atom),/* Tangier */ 1044 + RAPL_CPU(0x56, rapl_defaults_core),/* Future Xeon */ 1044 1045 RAPL_CPU(0x5A, rapl_defaults_atom),/* Annidale */ 1045 1046 {} 1046 1047 };
-3
include/linux/cpuidle.h
··· 53 53 }; 54 54 55 55 /* Idle State Flags */ 56 - #define CPUIDLE_FLAG_TIME_INVALID (0x01) /* is residency time measurable? */ 57 56 #define CPUIDLE_FLAG_COUPLED (0x02) /* state applies to multiple cpus */ 58 57 #define CPUIDLE_FLAG_TIMER_STOP (0x04) /* timer is stopped on this state */ 59 58 ··· 88 89 /** 89 90 * cpuidle_get_last_residency - retrieves the last state's residency time 90 91 * @dev: the target CPU 91 - * 92 - * NOTE: this value is invalid if CPUIDLE_FLAG_TIME_INVALID is set 93 92 */ 94 93 static inline int cpuidle_get_last_residency(struct cpuidle_device *dev) 95 94 {
+8
include/linux/pm_domain.h
··· 271 271 int __of_genpd_add_provider(struct device_node *np, genpd_xlate_t xlate, 272 272 void *data); 273 273 void of_genpd_del_provider(struct device_node *np); 274 + struct generic_pm_domain *of_genpd_get_from_provider( 275 + struct of_phandle_args *genpdspec); 274 276 275 277 struct generic_pm_domain *__of_genpd_xlate_simple( 276 278 struct of_phandle_args *genpdspec, ··· 289 287 return 0; 290 288 } 291 289 static inline void of_genpd_del_provider(struct device_node *np) {} 290 + 291 + static inline struct generic_pm_domain *of_genpd_get_from_provider( 292 + struct of_phandle_args *genpdspec) 293 + { 294 + return NULL; 295 + } 292 296 293 297 #define __of_genpd_xlate_simple NULL 294 298 #define __of_genpd_xlate_onecell NULL
+1 -1
tools/power/cpupower/utils/cpupower.c
··· 199 199 } 200 200 201 201 get_cpu_info(0, &cpupower_cpu_info); 202 - run_as_root = !getuid(); 202 + run_as_root = !geteuid(); 203 203 if (run_as_root) { 204 204 ret = uname(&uts); 205 205 if (!ret && !strcmp(uts.machine, "x86_64") &&
+1 -1
tools/power/cpupower/utils/helpers/sysfs.c
··· 361 361 362 362 snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpuidle"); 363 363 if (stat(file, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode)) 364 - return -ENODEV; 364 + return 0; 365 365 366 366 snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpu%u/cpuidle/state0", cpu); 367 367 if (stat(file, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode))