cpufreq.c (9c0ebcf78fde0ffa348a95a544c6d3f2dac5af65) cpufreq.c (ad7722dab7292dbc1c4586d701ac226b68122d39)
1/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
7 *
8 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>

--- 39 unchanged lines hidden (view full) ---

48#endif
49
50static inline bool has_target(void)
51{
52 return cpufreq_driver->target_index || cpufreq_driver->target;
53}
54
55/*
1/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
7 *
8 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>

--- 39 unchanged lines hidden (view full) ---

48#endif
49
50static inline bool has_target(void)
51{
52 return cpufreq_driver->target_index || cpufreq_driver->target;
53}
54
55/*
56 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
57 * all cpufreq/hotplug/workqueue/etc related lock issues.
58 *
59 * The rules for this semaphore:
60 * - Any routine that wants to read from the policy structure will
61 * do a down_read on this semaphore.
62 * - Any routine that will write to the policy structure and/or may take away
63 * the policy altogether (eg. CPU hotplug), will hold this lock in write
64 * mode before doing so.
65 *
66 * Additional rules:
67 * - Governor routines that can be called in cpufreq hotplug path should not
68 * take this sem as top level hotplug notifier handler takes this.
69 * - Lock should not be held across
70 * __cpufreq_governor(data, CPUFREQ_GOV_STOP);
71 */
72static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
73
74#define lock_policy_rwsem(mode, cpu) \
75static void lock_policy_rwsem_##mode(int cpu) \
76{ \
77 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
78 BUG_ON(!policy); \
79 down_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu)); \
80}
81
82lock_policy_rwsem(read, cpu);
83lock_policy_rwsem(write, cpu);
84
85#define unlock_policy_rwsem(mode, cpu) \
86static void unlock_policy_rwsem_##mode(int cpu) \
87{ \
88 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
89 BUG_ON(!policy); \
90 up_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu)); \
91}
92
93unlock_policy_rwsem(read, cpu);
94unlock_policy_rwsem(write, cpu);
95
96/*
97 * rwsem to guarantee that cpufreq driver module doesn't unload during critical
98 * sections
99 */
100static DECLARE_RWSEM(cpufreq_rwsem);
101
102/* internal prototypes */
103static int __cpufreq_governor(struct cpufreq_policy *policy,
104 unsigned int event);

--- 578 unchanged lines hidden (view full) ---

683{
684 struct cpufreq_policy *policy = to_policy(kobj);
685 struct freq_attr *fattr = to_attr(attr);
686 ssize_t ret;
687
688 if (!down_read_trylock(&cpufreq_rwsem))
689 return -EINVAL;
690
56 * rwsem to guarantee that cpufreq driver module doesn't unload during critical
57 * sections
58 */
59static DECLARE_RWSEM(cpufreq_rwsem);
60
61/* internal prototypes */
62static int __cpufreq_governor(struct cpufreq_policy *policy,
63 unsigned int event);

--- 578 unchanged lines hidden (view full) ---

642{
643 struct cpufreq_policy *policy = to_policy(kobj);
644 struct freq_attr *fattr = to_attr(attr);
645 ssize_t ret;
646
647 if (!down_read_trylock(&cpufreq_rwsem))
648 return -EINVAL;
649
691 lock_policy_rwsem_read(policy->cpu);
650 down_read(&policy->rwsem);
692
693 if (fattr->show)
694 ret = fattr->show(policy, buf);
695 else
696 ret = -EIO;
697
651
652 if (fattr->show)
653 ret = fattr->show(policy, buf);
654 else
655 ret = -EIO;
656
698 unlock_policy_rwsem_read(policy->cpu);
657 up_read(&policy->rwsem);
699 up_read(&cpufreq_rwsem);
700
701 return ret;
702}
703
704static ssize_t store(struct kobject *kobj, struct attribute *attr,
705 const char *buf, size_t count)
706{

--- 4 unchanged lines hidden (view full) ---

711 get_online_cpus();
712
713 if (!cpu_online(policy->cpu))
714 goto unlock;
715
716 if (!down_read_trylock(&cpufreq_rwsem))
717 goto unlock;
718
658 up_read(&cpufreq_rwsem);
659
660 return ret;
661}
662
663static ssize_t store(struct kobject *kobj, struct attribute *attr,
664 const char *buf, size_t count)
665{

--- 4 unchanged lines hidden (view full) ---

670 get_online_cpus();
671
672 if (!cpu_online(policy->cpu))
673 goto unlock;
674
675 if (!down_read_trylock(&cpufreq_rwsem))
676 goto unlock;
677
719 lock_policy_rwsem_write(policy->cpu);
678 down_write(&policy->rwsem);
720
721 if (fattr->store)
722 ret = fattr->store(policy, buf, count);
723 else
724 ret = -EIO;
725
679
680 if (fattr->store)
681 ret = fattr->store(policy, buf, count);
682 else
683 ret = -EIO;
684
726 unlock_policy_rwsem_write(policy->cpu);
685 up_write(&policy->rwsem);
727
728 up_read(&cpufreq_rwsem);
729unlock:
730 put_online_cpus();
731
732 return ret;
733}
734

--- 160 unchanged lines hidden (view full) ---

895 if (has_target()) {
896 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
897 if (ret) {
898 pr_err("%s: Failed to stop governor\n", __func__);
899 return ret;
900 }
901 }
902
686
687 up_read(&cpufreq_rwsem);
688unlock:
689 put_online_cpus();
690
691 return ret;
692}
693

--- 160 unchanged lines hidden (view full) ---

854 if (has_target()) {
855 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
856 if (ret) {
857 pr_err("%s: Failed to stop governor\n", __func__);
858 return ret;
859 }
860 }
861
903 lock_policy_rwsem_write(policy->cpu);
862 down_write(&policy->rwsem);
904
905 write_lock_irqsave(&cpufreq_driver_lock, flags);
906
907 cpumask_set_cpu(cpu, policy->cpus);
908 per_cpu(cpufreq_cpu_data, cpu) = policy;
909 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
910
863
864 write_lock_irqsave(&cpufreq_driver_lock, flags);
865
866 cpumask_set_cpu(cpu, policy->cpus);
867 per_cpu(cpufreq_cpu_data, cpu) = policy;
868 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
869
911 unlock_policy_rwsem_write(policy->cpu);
870 up_write(&policy->rwsem);
912
913 if (has_target()) {
914 if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
915 (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
916 pr_err("%s: Failed to start governor\n", __func__);
917 return ret;
918 }
919 }

--- 30 unchanged lines hidden (view full) ---

950
951 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
952 goto err_free_policy;
953
954 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
955 goto err_free_cpumask;
956
957 INIT_LIST_HEAD(&policy->policy_list);
871
872 if (has_target()) {
873 if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
874 (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
875 pr_err("%s: Failed to start governor\n", __func__);
876 return ret;
877 }
878 }

--- 30 unchanged lines hidden (view full) ---

909
910 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
911 goto err_free_policy;
912
913 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
914 goto err_free_cpumask;
915
916 INIT_LIST_HEAD(&policy->policy_list);
917 init_rwsem(&policy->rwsem);
918
958 return policy;
959
960err_free_cpumask:
961 free_cpumask_var(policy->cpus);
962err_free_policy:
963 kfree(policy);
964
965 return NULL;

--- 6 unchanged lines hidden (view full) ---

972 kfree(policy);
973}
974
975static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
976{
977 if (WARN_ON(cpu == policy->cpu))
978 return;
979
919 return policy;
920
921err_free_cpumask:
922 free_cpumask_var(policy->cpus);
923err_free_policy:
924 kfree(policy);
925
926 return NULL;

--- 6 unchanged lines hidden (view full) ---

933 kfree(policy);
934}
935
936static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
937{
938 if (WARN_ON(cpu == policy->cpu))
939 return;
940
980 /*
981 * Take direct locks as lock_policy_rwsem_write wouldn't work here.
982 * Also lock for last cpu is enough here as contention will happen only
983 * after policy->cpu is changed and after it is changed, other threads
984 * will try to acquire lock for new cpu. And policy is already updated
985 * by then.
986 */
987 down_write(&per_cpu(cpu_policy_rwsem, policy->cpu));
941 down_write(&policy->rwsem);
988
989 policy->last_cpu = policy->cpu;
990 policy->cpu = cpu;
991
942
943 policy->last_cpu = policy->cpu;
944 policy->cpu = cpu;
945
992 up_write(&per_cpu(cpu_policy_rwsem, policy->last_cpu));
946 up_write(&policy->rwsem);
993
994 cpufreq_frequency_table_update_policy_cpu(policy);
995 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
996 CPUFREQ_UPDATE_POLICY_CPU, policy);
997}
998
999static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
1000 bool frozen)

--- 175 unchanged lines hidden (view full) ---

1176 if (frozen)
1177 return cpu_dev->id;
1178
1179 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1180 ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
1181 if (ret) {
1182 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1183
947
948 cpufreq_frequency_table_update_policy_cpu(policy);
949 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
950 CPUFREQ_UPDATE_POLICY_CPU, policy);
951}
952
953static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
954 bool frozen)

--- 175 unchanged lines hidden (view full) ---

1130 if (frozen)
1131 return cpu_dev->id;
1132
1133 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1134 ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
1135 if (ret) {
1136 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1137
1184 lock_policy_rwsem_write(old_cpu);
1138 down_write(&policy->rwsem);
1185 cpumask_set_cpu(old_cpu, policy->cpus);
1139 cpumask_set_cpu(old_cpu, policy->cpus);
1186 unlock_policy_rwsem_write(old_cpu);
1140 up_write(&policy->rwsem);
1187
1188 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
1189 "cpufreq");
1190
1191 return -EINVAL;
1192 }
1193
1194 return cpu_dev->id;

--- 34 unchanged lines hidden (view full) ---

1229 }
1230
1231#ifdef CONFIG_HOTPLUG_CPU
1232 if (!cpufreq_driver->setpolicy)
1233 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1234 policy->governor->name, CPUFREQ_NAME_LEN);
1235#endif
1236
1141
1142 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
1143 "cpufreq");
1144
1145 return -EINVAL;
1146 }
1147
1148 return cpu_dev->id;

--- 34 unchanged lines hidden (view full) ---

1183 }
1184
1185#ifdef CONFIG_HOTPLUG_CPU
1186 if (!cpufreq_driver->setpolicy)
1187 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1188 policy->governor->name, CPUFREQ_NAME_LEN);
1189#endif
1190
1237 lock_policy_rwsem_read(cpu);
1191 down_read(&policy->rwsem);
1238 cpus = cpumask_weight(policy->cpus);
1192 cpus = cpumask_weight(policy->cpus);
1239 unlock_policy_rwsem_read(cpu);
1193 up_read(&policy->rwsem);
1240
1241 if (cpu != policy->cpu) {
1242 if (!frozen)
1243 sysfs_remove_link(&dev->kobj, "cpufreq");
1244 } else if (cpus > 1) {
1245 new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
1246 if (new_cpu >= 0) {
1247 update_policy_cpu(policy, new_cpu);

--- 23 unchanged lines hidden (view full) ---

1271 policy = per_cpu(cpufreq_cpu_data, cpu);
1272 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1273
1274 if (!policy) {
1275 pr_debug("%s: No cpu_data found\n", __func__);
1276 return -EINVAL;
1277 }
1278
1194
1195 if (cpu != policy->cpu) {
1196 if (!frozen)
1197 sysfs_remove_link(&dev->kobj, "cpufreq");
1198 } else if (cpus > 1) {
1199 new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
1200 if (new_cpu >= 0) {
1201 update_policy_cpu(policy, new_cpu);

--- 23 unchanged lines hidden (view full) ---

1225 policy = per_cpu(cpufreq_cpu_data, cpu);
1226 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1227
1228 if (!policy) {
1229 pr_debug("%s: No cpu_data found\n", __func__);
1230 return -EINVAL;
1231 }
1232
1279 lock_policy_rwsem_write(cpu);
1233 down_write(&policy->rwsem);
1280 cpus = cpumask_weight(policy->cpus);
1281
1282 if (cpus > 1)
1283 cpumask_clear_cpu(cpu, policy->cpus);
1234 cpus = cpumask_weight(policy->cpus);
1235
1236 if (cpus > 1)
1237 cpumask_clear_cpu(cpu, policy->cpus);
1284 unlock_policy_rwsem_write(cpu);
1238 up_write(&policy->rwsem);
1285
1286 /* If cpu is last user of policy, free policy */
1287 if (cpus == 1) {
1288 if (has_target()) {
1289 ret = __cpufreq_governor(policy,
1290 CPUFREQ_GOV_POLICY_EXIT);
1291 if (ret) {
1292 pr_err("%s: Failed to exit governor\n",
1293 __func__);
1294 return ret;
1295 }
1296 }
1297
1298 if (!frozen) {
1239
1240 /* If cpu is last user of policy, free policy */
1241 if (cpus == 1) {
1242 if (has_target()) {
1243 ret = __cpufreq_governor(policy,
1244 CPUFREQ_GOV_POLICY_EXIT);
1245 if (ret) {
1246 pr_err("%s: Failed to exit governor\n",
1247 __func__);
1248 return ret;
1249 }
1250 }
1251
1252 if (!frozen) {
1299 lock_policy_rwsem_read(cpu);
1253 down_read(&policy->rwsem);
1300 kobj = &policy->kobj;
1301 cmp = &policy->kobj_unregister;
1254 kobj = &policy->kobj;
1255 cmp = &policy->kobj_unregister;
1302 unlock_policy_rwsem_read(cpu);
1256 up_read(&policy->rwsem);
1303 kobject_put(kobj);
1304
1305 /*
1306 * We need to make sure that the underlying kobj is
1307 * actually not referenced anymore by anybody before we
1308 * proceed with unloading.
1309 */
1310 pr_debug("waiting for dropping of refcount\n");

--- 163 unchanged lines hidden (view full) ---

1474/**
1475 * cpufreq_get - get the current CPU frequency (in kHz)
1476 * @cpu: CPU number
1477 *
1478 * Get the CPU current (static) CPU frequency
1479 */
1480unsigned int cpufreq_get(unsigned int cpu)
1481{
1257 kobject_put(kobj);
1258
1259 /*
1260 * We need to make sure that the underlying kobj is
1261 * actually not referenced anymore by anybody before we
1262 * proceed with unloading.
1263 */
1264 pr_debug("waiting for dropping of refcount\n");

--- 163 unchanged lines hidden (view full) ---

1428/**
1429 * cpufreq_get - get the current CPU frequency (in kHz)
1430 * @cpu: CPU number
1431 *
1432 * Get the CPU current (static) CPU frequency
1433 */
1434unsigned int cpufreq_get(unsigned int cpu)
1435{
1436 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1482 unsigned int ret_freq = 0;
1483
1484 if (cpufreq_disabled() || !cpufreq_driver)
1485 return -ENOENT;
1486
1437 unsigned int ret_freq = 0;
1438
1439 if (cpufreq_disabled() || !cpufreq_driver)
1440 return -ENOENT;
1441
1442 BUG_ON(!policy);
1443
1487 if (!down_read_trylock(&cpufreq_rwsem))
1488 return 0;
1489
1444 if (!down_read_trylock(&cpufreq_rwsem))
1445 return 0;
1446
1490 lock_policy_rwsem_read(cpu);
1447 down_read(&policy->rwsem);
1491
1492 ret_freq = __cpufreq_get(cpu);
1493
1448
1449 ret_freq = __cpufreq_get(cpu);
1450
1494 unlock_policy_rwsem_read(cpu);
1451 up_read(&policy->rwsem);
1495 up_read(&cpufreq_rwsem);
1496
1497 return ret_freq;
1498}
1499EXPORT_SYMBOL(cpufreq_get);
1500
1501static struct subsys_interface cpufreq_interface = {
1502 .name = "cpufreq",

--- 236 unchanged lines hidden (view full) ---

1739EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1740
1741int cpufreq_driver_target(struct cpufreq_policy *policy,
1742 unsigned int target_freq,
1743 unsigned int relation)
1744{
1745 int ret = -EINVAL;
1746
1452 up_read(&cpufreq_rwsem);
1453
1454 return ret_freq;
1455}
1456EXPORT_SYMBOL(cpufreq_get);
1457
1458static struct subsys_interface cpufreq_interface = {
1459 .name = "cpufreq",

--- 236 unchanged lines hidden (view full) ---

1696EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1697
1698int cpufreq_driver_target(struct cpufreq_policy *policy,
1699 unsigned int target_freq,
1700 unsigned int relation)
1701{
1702 int ret = -EINVAL;
1703
1747 lock_policy_rwsem_write(policy->cpu);
1704 down_write(&policy->rwsem);
1748
1749 ret = __cpufreq_driver_target(policy, target_freq, relation);
1750
1705
1706 ret = __cpufreq_driver_target(policy, target_freq, relation);
1707
1751 unlock_policy_rwsem_write(policy->cpu);
1708 up_write(&policy->rwsem);
1752
1753 return ret;
1754}
1755EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1756
1757/*
1758 * when "event" is CPUFREQ_GOV_LIMITS
1759 */

--- 214 unchanged lines hidden (view full) ---

1974 /* save old, working values */
1975 struct cpufreq_governor *old_gov = policy->governor;
1976
1977 pr_debug("governor switch\n");
1978
1979 /* end old governor */
1980 if (policy->governor) {
1981 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1709
1710 return ret;
1711}
1712EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1713
1714/*
1715 * when "event" is CPUFREQ_GOV_LIMITS
1716 */

--- 214 unchanged lines hidden (view full) ---

1931 /* save old, working values */
1932 struct cpufreq_governor *old_gov = policy->governor;
1933
1934 pr_debug("governor switch\n");
1935
1936 /* end old governor */
1937 if (policy->governor) {
1938 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1982 unlock_policy_rwsem_write(new_policy->cpu);
1939 up_write(&policy->rwsem);
1983 __cpufreq_governor(policy,
1984 CPUFREQ_GOV_POLICY_EXIT);
1940 __cpufreq_governor(policy,
1941 CPUFREQ_GOV_POLICY_EXIT);
1985 lock_policy_rwsem_write(new_policy->cpu);
1942 down_write(&policy->rwsem);
1986 }
1987
1988 /* start new governor */
1989 policy->governor = new_policy->governor;
1990 if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
1991 if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
1992 failed = 0;
1993 } else {
1943 }
1944
1945 /* start new governor */
1946 policy->governor = new_policy->governor;
1947 if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
1948 if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
1949 failed = 0;
1950 } else {
1994 unlock_policy_rwsem_write(new_policy->cpu);
1951 up_write(&policy->rwsem);
1995 __cpufreq_governor(policy,
1996 CPUFREQ_GOV_POLICY_EXIT);
1952 __cpufreq_governor(policy,
1953 CPUFREQ_GOV_POLICY_EXIT);
1997 lock_policy_rwsem_write(new_policy->cpu);
1954 down_write(&policy->rwsem);
1998 }
1999 }
2000
2001 if (failed) {
2002 /* new governor failed, so re-start old one */
2003 pr_debug("starting governor %s failed\n",
2004 policy->governor->name);
2005 if (old_gov) {

--- 29 unchanged lines hidden (view full) ---

2035 struct cpufreq_policy new_policy;
2036 int ret;
2037
2038 if (!policy) {
2039 ret = -ENODEV;
2040 goto no_policy;
2041 }
2042
1955 }
1956 }
1957
1958 if (failed) {
1959 /* new governor failed, so re-start old one */
1960 pr_debug("starting governor %s failed\n",
1961 policy->governor->name);
1962 if (old_gov) {

--- 29 unchanged lines hidden (view full) ---

1992 struct cpufreq_policy new_policy;
1993 int ret;
1994
1995 if (!policy) {
1996 ret = -ENODEV;
1997 goto no_policy;
1998 }
1999
2043 lock_policy_rwsem_write(cpu);
2000 down_write(&policy->rwsem);
2044
2045 pr_debug("updating policy for CPU %u\n", cpu);
2046 memcpy(&new_policy, policy, sizeof(*policy));
2047 new_policy.min = policy->user_policy.min;
2048 new_policy.max = policy->user_policy.max;
2049 new_policy.policy = policy->user_policy.policy;
2050 new_policy.governor = policy->user_policy.governor;
2051

--- 10 unchanged lines hidden (view full) ---

2062 if (policy->cur != new_policy.cur && has_target())
2063 cpufreq_out_of_sync(cpu, policy->cur,
2064 new_policy.cur);
2065 }
2066 }
2067
2068 ret = cpufreq_set_policy(policy, &new_policy);
2069
2001
2002 pr_debug("updating policy for CPU %u\n", cpu);
2003 memcpy(&new_policy, policy, sizeof(*policy));
2004 new_policy.min = policy->user_policy.min;
2005 new_policy.max = policy->user_policy.max;
2006 new_policy.policy = policy->user_policy.policy;
2007 new_policy.governor = policy->user_policy.governor;
2008

--- 10 unchanged lines hidden (view full) ---

2019 if (policy->cur != new_policy.cur && has_target())
2020 cpufreq_out_of_sync(cpu, policy->cur,
2021 new_policy.cur);
2022 }
2023 }
2024
2025 ret = cpufreq_set_policy(policy, &new_policy);
2026
2070 unlock_policy_rwsem_write(cpu);
2027 up_write(&policy->rwsem);
2071
2072 cpufreq_cpu_put(policy);
2073no_policy:
2074 return ret;
2075}
2076EXPORT_SYMBOL(cpufreq_update_policy);
2077
2078static int cpufreq_cpu_callback(struct notifier_block *nfb,

--- 141 unchanged lines hidden (view full) ---

2220 up_write(&cpufreq_rwsem);
2221
2222 return 0;
2223}
2224EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2225
2226static int __init cpufreq_core_init(void)
2227{
2028
2029 cpufreq_cpu_put(policy);
2030no_policy:
2031 return ret;
2032}
2033EXPORT_SYMBOL(cpufreq_update_policy);
2034
2035static int cpufreq_cpu_callback(struct notifier_block *nfb,

--- 141 unchanged lines hidden (view full) ---

2177 up_write(&cpufreq_rwsem);
2178
2179 return 0;
2180}
2181EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2182
2183static int __init cpufreq_core_init(void)
2184{
2228 int cpu;
2229
2230 if (cpufreq_disabled())
2231 return -ENODEV;
2232
2185 if (cpufreq_disabled())
2186 return -ENODEV;
2187
2233 for_each_possible_cpu(cpu)
2234 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
2235
2236 cpufreq_global_kobject = kobject_create();
2237 BUG_ON(!cpufreq_global_kobject);
2238 register_syscore_ops(&cpufreq_syscore_ops);
2239
2240 return 0;
2241}
2242core_initcall(cpufreq_core_init);
2188 cpufreq_global_kobject = kobject_create();
2189 BUG_ON(!cpufreq_global_kobject);
2190 register_syscore_ops(&cpufreq_syscore_ops);
2191
2192 return 0;
2193}
2194core_initcall(cpufreq_core_init);