Lines Matching refs:policy
55 * - Any routine that wants to read from the policy structure will
57 * - Any routine that will write to the policy structure and/or may take away
58 * the policy altogether (eg. CPU hotplug), will hold this lock in write
107 static int __cpufreq_governor(struct cpufreq_policy *policy,
113 * Two notifier lists: the "policy" list is involved in the
114 * validation process for a new CPU frequency policy; the
196 * loading of a cpufreq driver, temporarily disabled when a new policy
323 struct cpufreq_policy *policy;
331 policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
340 if ((policy) && (policy->cpu == freqs->cpu) &&
341 (policy->cur) && (policy->cur != freqs->old)) {
344 freqs->old, policy->cur);
345 freqs->old = policy->cur;
360 if (likely(policy) && likely(policy->cpu == freqs->cpu))
361 policy->cur = freqs->new;
387 static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
397 *policy = CPUFREQ_POLICY_PERFORMANCE;
401 *policy = CPUFREQ_POLICY_POWERSAVE;
445 * Write out information from cpufreq_driver->policy[cpu]; object must be
451 (struct cpufreq_policy *policy, char *buf) \
453 return sprintf(buf, "%u\n", policy->object); \
464 struct cpufreq_policy *policy);
471 (struct cpufreq_policy *policy, const char *buf, size_t count) \
476 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
484 ret = __cpufreq_set_policy(policy, &new_policy); \
485 policy->user_policy.object = policy->object; \
496 static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
499 unsigned int cur_freq = __cpufreq_get(policy->cpu);
507 * show_scaling_governor - show the current policy for the specified CPU
509 static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
511 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
513 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
515 else if (policy->governor)
517 policy->governor->name);
523 * store_scaling_governor - store policy for the specified CPU
525 static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
532 ret = cpufreq_get_policy(&new_policy, policy->cpu);
540 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
546 ret = __cpufreq_set_policy(policy, &new_policy);
548 policy->user_policy.policy = policy->policy;
549 policy->user_policy.governor = policy->governor;
560 static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
568 static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
610 static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
612 if (cpumask_empty(policy->related_cpus))
613 return show_cpus(policy->cpus, buf);
614 return show_cpus(policy->related_cpus, buf);
620 static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
622 return show_cpus(policy->cpus, buf);
625 static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
631 if (!policy->governor || !policy->governor->store_setspeed)
638 policy->governor->store_setspeed(policy, freq);
643 static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
645 if (!policy->governor || !policy->governor->show_setspeed)
648 return policy->governor->show_setspeed(policy, buf);
654 static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
659 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
663 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
704 struct cpufreq_policy *policy = to_policy(kobj);
707 policy = cpufreq_cpu_get(policy->cpu);
708 if (!policy)
711 if (lock_policy_rwsem_read(policy->cpu) < 0)
715 ret = fattr->show(policy, buf);
719 unlock_policy_rwsem_read(policy->cpu);
721 cpufreq_cpu_put(policy);
729 struct cpufreq_policy *policy = to_policy(kobj);
732 policy = cpufreq_cpu_get(policy->cpu);
733 if (!policy)
736 if (lock_policy_rwsem_write(policy->cpu) < 0)
740 ret = fattr->store(policy, buf, count);
744 unlock_policy_rwsem_write(policy->cpu);
746 cpufreq_cpu_put(policy);
753 struct cpufreq_policy *policy = to_policy(kobj);
755 complete(&policy->kobj_unregister);
776 struct cpufreq_policy *policy,
788 policy->governor = gov;
790 policy->governor->name, cpu);
794 for_each_cpu(j, policy->cpus) {
813 /* Should not go through policy unlock path */
815 cpufreq_driver->exit(policy);
821 cpumask_copy(managed_policy->cpus, policy->cpus);
837 cpufreq_driver->exit(policy);
852 struct cpufreq_policy *policy)
857 for_each_cpu(j, policy->cpus) {
869 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
880 struct cpufreq_policy *policy,
890 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
898 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
904 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
909 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
914 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
920 for_each_cpu(j, policy->cpus) {
923 per_cpu(cpufreq_cpu_data, j) = policy;
924 per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
928 ret = cpufreq_add_dev_symlink(cpu, policy);
932 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
934 policy->governor = NULL;
936 /* set default policy */
937 ret = __cpufreq_set_policy(policy, &new_policy);
938 policy->user_policy.policy = policy->policy;
939 policy->user_policy.governor = policy->governor;
942 dprintk("setting policy failed\n");
944 cpufreq_driver->exit(policy);
949 kobject_put(&policy->kobj);
950 wait_for_completion(&policy->kobj_unregister);
968 struct cpufreq_policy *policy;
984 policy = cpufreq_cpu_get(cpu);
985 if (unlikely(policy)) {
986 cpufreq_cpu_put(policy);
998 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
999 if (!policy)
1002 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1005 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1008 policy->cpu = cpu;
1009 cpumask_copy(policy->cpus, cpumask_of(cpu));
1016 init_completion(&policy->kobj_unregister);
1017 INIT_WORK(&policy->update, handle_update);
1025 policy->governor = cp->governor;
1032 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
1036 ret = cpufreq_driver->init(policy);
1041 policy->user_policy.min = policy->min;
1042 policy->user_policy.max = policy->max;
1045 CPUFREQ_START, policy);
1047 ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
1056 ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
1062 kobject_uevent(&policy->kobj, KOBJ_ADD);
1072 for_each_cpu(j, policy->cpus)
1076 kobject_put(&policy->kobj);
1077 wait_for_completion(&policy->kobj_unregister);
1081 free_cpumask_var(policy->related_cpus);
1083 free_cpumask_var(policy->cpus);
1085 kfree(policy);
1237 struct cpufreq_policy *policy =
1239 unsigned int cpu = policy->cpu;
1270 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1278 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1281 if (policy) {
1282 ret_freq = policy->cur;
1283 cpufreq_cpu_put(policy);
1293 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1301 if (ret_freq && policy->cur &&
1305 if (unlikely(ret_freq != policy->cur)) {
1306 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1307 schedule_work(&policy->update);
1323 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1325 if (!policy)
1336 cpufreq_cpu_put(policy);
1360 * we need to grab the correct cpu policy, as to check
1407 * we need to grab the correct cpu policy, as to check
1455 * changes in cpufreq policy.
1521 int __cpufreq_driver_target(struct cpufreq_policy *policy,
1527 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1529 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1530 retval = cpufreq_driver->target(policy, target_freq, relation);
1536 int cpufreq_driver_target(struct cpufreq_policy *policy,
1542 policy = cpufreq_cpu_get(policy->cpu);
1543 if (!policy)
1546 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1549 ret = __cpufreq_driver_target(policy, target_freq, relation);
1551 unlock_policy_rwsem_write(policy->cpu);
1554 cpufreq_cpu_put(policy);
1560 int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
1564 policy = cpufreq_cpu_get(policy->cpu);
1565 if (!policy)
1569 ret = cpufreq_driver->getavg(policy, cpu);
1571 cpufreq_cpu_put(policy);
1580 static int __cpufreq_governor(struct cpufreq_policy *policy,
1595 if (policy->governor->max_transition_latency &&
1596 policy->cpuinfo.transition_latency >
1597 policy->governor->max_transition_latency) {
1604 policy->governor->name,
1606 policy->governor = gov;
1610 if (!try_module_get(policy->governor->owner))
1614 policy->cpu, event);
1615 ret = policy->governor->governor(policy, event);
1620 module_put(policy->governor->owner);
1622 module_put(policy->governor->owner);
1682 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1685 * Reads the current cpufreq policy.
1687 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1690 if (!policy)
1697 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1706 * data : current policy.
1707 * policy : policy to be set.
1710 struct cpufreq_policy *policy)
1715 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1716 policy->min, policy->max);
1718 memcpy(&policy->cpuinfo, &data->cpuinfo,
1721 if (policy->min > data->max || policy->max < data->min) {
1727 ret = cpufreq_driver->verify(policy);
1733 CPUFREQ_ADJUST, policy);
1737 CPUFREQ_INCOMPATIBLE, policy);
1741 ret = cpufreq_driver->verify(policy);
1745 /* notification of the new policy */
1747 CPUFREQ_NOTIFY, policy);
1749 data->min = policy->min;
1750 data->max = policy->max;
1756 data->policy = policy->policy;
1758 ret = cpufreq_driver->setpolicy(policy);
1760 if (policy->governor != data->governor) {
1771 data->governor = policy->governor;
1784 /* might be a policy change, too, so fall through */
1796 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1799 * Usefull for policy notifiers which have different necessities
1805 struct cpufreq_policy policy;
1818 dprintk("updating policy for CPU %u\n", cpu);
1819 memcpy(&policy, data, sizeof(struct cpufreq_policy));
1820 policy.min = data->user_policy.min;
1821 policy.max = data->user_policy.max;
1822 policy.policy = data->user_policy.policy;
1823 policy.governor = data->user_policy.governor;
1828 policy.cur = cpufreq_driver->get(cpu);
1831 data->cur = policy.cur;
1833 if (data->cur != policy.cur)
1835 policy.cur);
1839 ret = __cpufreq_set_policy(data, &policy);