Merge branch 'pm-cpufreq' (c3a74f8e) · Commits · 戴 / test

Documentation/ABI/testing/sysfs-devices-system-cpu

+2 −1

Original line number	Diff line number	Diff line
		@@ -264,7 +264,8 @@ Description: Discover CPUs in the same CPU frequency coordination domain
		attribute is useful for user space DVFS controllers to get better
		power/performance results for platforms using acpi-cpufreq.

		This file is only present if the acpi-cpufreq driver is in use.
		This file is only present if the acpi-cpufreq or the cppc-cpufreq
		drivers are in use.


		What: /sys/devices/system/cpu/cpu*/cache/index3/cache_disable_{0,1}

drivers/acpi/cppc_acpi.c

+60 −81

Original line number	Diff line number	Diff line
		@@ -414,109 +414,88 @@ end:
		return result;
		}

		bool acpi_cpc_valid(void)
		{
		struct cpc_desc *cpc_ptr;
		int cpu;

		for_each_possible_cpu(cpu) {
		cpc_ptr = per_cpu(cpc_desc_ptr, cpu);
		if (!cpc_ptr)
		return false;
		}

		return true;
		}
		EXPORT_SYMBOL_GPL(acpi_cpc_valid);

		/**
		* acpi_get_psd_map - Map the CPUs in a common freq domain.
		* @all_cpu_data: Ptrs to CPU specific CPPC data including PSD info.
		* acpi_get_psd_map - Map the CPUs in the freq domain of a given cpu
		* @cpu: Find all CPUs that share a domain with cpu.
		* @cpu_data: Pointer to CPU specific CPPC data including PSD info.
		*
		* Return: 0 for success or negative value for err.
		*/
		int acpi_get_psd_map(struct cppc_cpudata **all_cpu_data)
		int acpi_get_psd_map(unsigned int cpu, struct cppc_cpudata *cpu_data)
		{
		int count_target;
		int retval = 0;
		unsigned int i, j;
		cpumask_var_t covered_cpus;
		struct cppc_cpudata pr, match_pr;
		struct acpi_psd_package *pdomain;
		struct acpi_psd_package *match_pdomain;
		struct cpc_desc cpc_ptr, match_cpc_ptr;

		if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
		return -ENOMEM;
		struct acpi_psd_package *match_pdomain;
		struct acpi_psd_package *pdomain;
		int count_target, i;

		/*
		* Now that we have _PSD data from all CPUs, let's setup P-state
		* domain info.
		*/
		for_each_possible_cpu(i) {
		if (cpumask_test_cpu(i, covered_cpus))
		continue;

		pr = all_cpu_data[i];
		cpc_ptr = per_cpu(cpc_desc_ptr, i);
		if (!cpc_ptr) {
		retval = -EFAULT;
		goto err_ret;
		}
		cpc_ptr = per_cpu(cpc_desc_ptr, cpu);
		if (!cpc_ptr)
		return -EFAULT;

		pdomain = &(cpc_ptr->domain_info);
		cpumask_set_cpu(i, pr->shared_cpu_map);
		cpumask_set_cpu(i, covered_cpus);
		cpumask_set_cpu(cpu, cpu_data->shared_cpu_map);
		if (pdomain->num_processors <= 1)
		continue;
		return 0;

		/* Validate the Domain info */
		count_target = pdomain->num_processors;
		if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
		pr->shared_type = CPUFREQ_SHARED_TYPE_ALL;
		cpu_data->shared_type = CPUFREQ_SHARED_TYPE_ALL;
		else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
		pr->shared_type = CPUFREQ_SHARED_TYPE_HW;
		cpu_data->shared_type = CPUFREQ_SHARED_TYPE_HW;
		else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
		pr->shared_type = CPUFREQ_SHARED_TYPE_ANY;
		cpu_data->shared_type = CPUFREQ_SHARED_TYPE_ANY;

		for_each_possible_cpu(j) {
		if (i == j)
		for_each_possible_cpu(i) {
		if (i == cpu)
		continue;

		match_cpc_ptr = per_cpu(cpc_desc_ptr, j);
		if (!match_cpc_ptr) {
		retval = -EFAULT;
		goto err_ret;
		}
		match_cpc_ptr = per_cpu(cpc_desc_ptr, i);
		if (!match_cpc_ptr)
		goto err_fault;

		match_pdomain = &(match_cpc_ptr->domain_info);
		if (match_pdomain->domain != pdomain->domain)
		continue;

		/* Here i and j are in the same domain */
		if (match_pdomain->num_processors != count_target) {
		retval = -EFAULT;
		goto err_ret;
		}

		if (pdomain->coord_type != match_pdomain->coord_type) {
		retval = -EFAULT;
		goto err_ret;
		}
		/* Here i and cpu are in the same domain */
		if (match_pdomain->num_processors != count_target)
		goto err_fault;

		cpumask_set_cpu(j, covered_cpus);
		cpumask_set_cpu(j, pr->shared_cpu_map);
		}
		if (pdomain->coord_type != match_pdomain->coord_type)
		goto err_fault;

		for_each_cpu(j, pr->shared_cpu_map) {
		if (i == j)
		continue;

		match_pr = all_cpu_data[j];
		match_pr->shared_type = pr->shared_type;
		cpumask_copy(match_pr->shared_cpu_map,
		pr->shared_cpu_map);
		}
		cpumask_set_cpu(i, cpu_data->shared_cpu_map);
		}
		goto out;

		err_ret:
		for_each_possible_cpu(i) {
		pr = all_cpu_data[i];
		return 0;

		err_fault:
		/* Assume no coordination on any error parsing domain info */
		cpumask_clear(pr->shared_cpu_map);
		cpumask_set_cpu(i, pr->shared_cpu_map);
		pr->shared_type = CPUFREQ_SHARED_TYPE_ALL;
		}
		out:
		free_cpumask_var(covered_cpus);
		return retval;
		cpumask_clear(cpu_data->shared_cpu_map);
		cpumask_set_cpu(cpu, cpu_data->shared_cpu_map);
		cpu_data->shared_type = CPUFREQ_SHARED_TYPE_NONE;

		return -EFAULT;
		}
		EXPORT_SYMBOL_GPL(acpi_get_psd_map);

drivers/acpi/processor_perflib.c

+1 −2

Original line number	Diff line number	Diff line
		@@ -616,7 +616,6 @@ int acpi_processor_preregister_performance(
		continue;

		pr->performance = per_cpu_ptr(performance, i);
		cpumask_set_cpu(i, pr->performance->shared_cpu_map);
		pdomain = &(pr->performance->domain_info);
		if (acpi_processor_get_psd(pr->handle, pdomain)) {
		retval = -EINVAL;
		@@ -710,7 +709,7 @@ err_ret:
		if (retval) {
		cpumask_clear(pr->performance->shared_cpu_map);
		cpumask_set_cpu(i, pr->performance->shared_cpu_map);
		pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
		pr->performance->shared_type = CPUFREQ_SHARED_TYPE_NONE;
		}
		pr->performance = NULL; /* Will be set for real in register */
		}

drivers/cpufreq/cppc_cpufreq.c

+116 −88

Original line number	Diff line number	Diff line
		@@ -30,13 +30,13 @@
		#define DMI_PROCESSOR_MAX_SPEED 0x14

		/*
		* These structs contain information parsed from per CPU
		* ACPI _CPC structures.
		* e.g. For each CPU the highest, lowest supported
		* performance capabilities, desired performance level
		* requested etc.
		* This list contains information parsed from per CPU ACPI _CPC and _PSD
		* structures: e.g. the highest and lowest supported performance, capabilities,
		* desired performance, level requested etc. Depending on the share_type, not
		* all CPUs will have an entry in the list.
		*/
		static struct cppc_cpudata **all_cpu_data;
		static LIST_HEAD(cpu_data_list);

		static bool boost_supported;

		struct cppc_workaround_oem_info {
		@@ -148,8 +148,10 @@ static unsigned int cppc_cpufreq_khz_to_perf(struct cppc_cpudata *cpu_data,
		static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,
		unsigned int target_freq,
		unsigned int relation)

		{
		struct cppc_cpudata *cpu_data = all_cpu_data[policy->cpu];
		struct cppc_cpudata *cpu_data = policy->driver_data;
		unsigned int cpu = policy->cpu;
		struct cpufreq_freqs freqs;
		u32 desired_perf;
		int ret = 0;
		@@ -164,12 +166,12 @@ static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,
		freqs.new = target_freq;

		cpufreq_freq_transition_begin(policy, &freqs);
		ret = cppc_set_perf(cpu_data->cpu, &cpu_data->perf_ctrls);
		ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
		cpufreq_freq_transition_end(policy, &freqs, ret != 0);

		if (ret)
		pr_debug("Failed to set target on CPU:%d. ret:%d\n",
		cpu_data->cpu, ret);
		cpu, ret);

		return ret;
		}
		@@ -182,7 +184,7 @@ static int cppc_verify_policy(struct cpufreq_policy_data *policy)

		static void cppc_cpufreq_stop_cpu(struct cpufreq_policy *policy)
		{
		struct cppc_cpudata *cpu_data = all_cpu_data[policy->cpu];
		struct cppc_cpudata *cpu_data = policy->driver_data;
		struct cppc_perf_caps *caps = &cpu_data->perf_caps;
		unsigned int cpu = policy->cpu;
		int ret;
		@@ -193,6 +195,12 @@ static void cppc_cpufreq_stop_cpu(struct cpufreq_policy *policy)
		if (ret)
		pr_debug("Err setting perf value:%d on CPU:%d. ret:%d\n",
		caps->lowest_perf, cpu, ret);

		/* Remove CPU node from list and free driver data for policy */
		free_cpumask_var(cpu_data->shared_cpu_map);
		list_del(&cpu_data->node);
		kfree(policy->driver_data);
		policy->driver_data = NULL;
		}

		/*
		@@ -238,25 +246,61 @@ static unsigned int cppc_cpufreq_get_transition_delay_us(unsigned int cpu)
		}
		#endif

		static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)

		static struct cppc_cpudata *cppc_cpufreq_get_cpu_data(unsigned int cpu)
		{
		struct cppc_cpudata *cpu_data = all_cpu_data[policy->cpu];
		struct cppc_perf_caps *caps = &cpu_data->perf_caps;
		unsigned int cpu = policy->cpu;
		int ret = 0;
		struct cppc_cpudata *cpu_data;
		int ret;

		cpu_data->cpu = cpu;
		ret = cppc_get_perf_caps(cpu, caps);
		cpu_data = kzalloc(sizeof(struct cppc_cpudata), GFP_KERNEL);
		if (!cpu_data)
		goto out;

		if (!zalloc_cpumask_var(&cpu_data->shared_cpu_map, GFP_KERNEL))
		goto free_cpu;

		ret = acpi_get_psd_map(cpu, cpu_data);
		if (ret) {
		pr_debug("Err reading CPU%d perf capabilities. ret:%d\n",
		cpu, ret);
		return ret;
		pr_debug("Err parsing CPU%d PSD data: ret:%d\n", cpu, ret);
		goto free_mask;
		}

		ret = cppc_get_perf_caps(cpu, &cpu_data->perf_caps);
		if (ret) {
		pr_debug("Err reading CPU%d perf caps: ret:%d\n", cpu, ret);
		goto free_mask;
		}

		/* Convert the lowest and nominal freq from MHz to KHz */
		caps->lowest_freq *= 1000;
		caps->nominal_freq *= 1000;
		cpu_data->perf_caps.lowest_freq *= 1000;
		cpu_data->perf_caps.nominal_freq *= 1000;

		list_add(&cpu_data->node, &cpu_data_list);

		return cpu_data;

		free_mask:
		free_cpumask_var(cpu_data->shared_cpu_map);
		free_cpu:
		kfree(cpu_data);
		out:
		return NULL;
		}

		static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)
		{
		unsigned int cpu = policy->cpu;
		struct cppc_cpudata *cpu_data;
		struct cppc_perf_caps *caps;
		int ret;

		cpu_data = cppc_cpufreq_get_cpu_data(cpu);
		if (!cpu_data) {
		pr_err("Error in acquiring _CPC/_PSD data for CPU%d.\n", cpu);
		return -ENODEV;
		}
		caps = &cpu_data->perf_caps;
		policy->driver_data = cpu_data;

		/*
		* Set min to lowest nonlinear perf to avoid any efficiency penalty (see
		@@ -280,26 +324,25 @@ static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)
		policy->transition_delay_us = cppc_cpufreq_get_transition_delay_us(cpu);
		policy->shared_type = cpu_data->shared_type;

		if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
		int i;

		switch (policy->shared_type) {
		case CPUFREQ_SHARED_TYPE_HW:
		case CPUFREQ_SHARED_TYPE_NONE:
		/* Nothing to be done - we'll have a policy for each CPU */
		break;
		case CPUFREQ_SHARED_TYPE_ANY:
		/*
		* All CPUs in the domain will share a policy and all cpufreq
		* operations will use a single cppc_cpudata structure stored
		* in policy->driver_data.
		*/
		cpumask_copy(policy->cpus, cpu_data->shared_cpu_map);

		for_each_cpu(i, policy->cpus) {
		if (unlikely(i == cpu))
		continue;

		memcpy(&all_cpu_data[i]->perf_caps, caps,
		sizeof(cpu_data->perf_caps));
		}
		} else if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL) {
		/* Support only SW_ANY for now. */
		pr_debug("Unsupported CPU co-ord type\n");
		break;
		default:
		pr_debug("Unsupported CPU co-ord type: %d\n",
		policy->shared_type);
		return -EFAULT;
		}

		cpu_data->cur_policy = policy;

		/*
		* If 'highest_perf' is greater than 'nominal_perf', we assume CPU Boost
		* is supported.
		@@ -354,9 +397,12 @@ static int cppc_get_rate_from_fbctrs(struct cppc_cpudata *cpu_data,
		static unsigned int cppc_cpufreq_get_rate(unsigned int cpu)
		{
		struct cppc_perf_fb_ctrs fb_ctrs_t0 = {0}, fb_ctrs_t1 = {0};
		struct cppc_cpudata *cpu_data = all_cpu_data[cpu];
		struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
		struct cppc_cpudata *cpu_data = policy->driver_data;
		int ret;

		cpufreq_cpu_put(policy);

		ret = cppc_get_perf_ctrs(cpu, &fb_ctrs_t0);
		if (ret)
		return ret;
		@@ -372,7 +418,7 @@ static unsigned int cppc_cpufreq_get_rate(unsigned int cpu)

		static int cppc_cpufreq_set_boost(struct cpufreq_policy *policy, int state)
		{
		struct cppc_cpudata *cpu_data = all_cpu_data[policy->cpu];
		struct cppc_cpudata *cpu_data = policy->driver_data;
		struct cppc_perf_caps *caps = &cpu_data->perf_caps;
		int ret;

		@@ -396,6 +442,19 @@ static int cppc_cpufreq_set_boost(struct cpufreq_policy *policy, int state)
		return 0;
		}

		static ssize_t show_freqdomain_cpus(struct cpufreq_policy policy, char buf)
		{
		struct cppc_cpudata *cpu_data = policy->driver_data;

		return cpufreq_show_cpus(cpu_data->shared_cpu_map, buf);
		}
		cpufreq_freq_attr_ro(freqdomain_cpus);

		static struct freq_attr *cppc_cpufreq_attr[] = {
		&freqdomain_cpus,
		NULL,
		};

		static struct cpufreq_driver cppc_cpufreq_driver = {
		.flags = CPUFREQ_CONST_LOOPS,
		.verify = cppc_verify_policy,
		@@ -404,6 +463,7 @@ static struct cpufreq_driver cppc_cpufreq_driver = {
		.init = cppc_cpufreq_cpu_init,
		.stop_cpu = cppc_cpufreq_stop_cpu,
		.set_boost = cppc_cpufreq_set_boost,
		.attr = cppc_cpufreq_attr,
		.name = "cppc_cpufreq",
		};

		@@ -415,10 +475,13 @@ static struct cpufreq_driver cppc_cpufreq_driver = {
		*/
		static unsigned int hisi_cppc_cpufreq_get_rate(unsigned int cpu)
		{
		struct cppc_cpudata *cpu_data = all_cpu_data[cpu];
		struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
		struct cppc_cpudata *cpu_data = policy->driver_data;
		u64 desired_perf;
		int ret;

		cpufreq_cpu_put(policy);

		ret = cppc_get_desired_perf(cpu, &desired_perf);
		if (ret < 0)
		return -EIO;
		@@ -451,68 +514,33 @@ static void cppc_check_hisi_workaround(void)

		static int __init cppc_cpufreq_init(void)
		{
		struct cppc_cpudata *cpu_data;
		int i, ret = 0;

		if (acpi_disabled)
		if ((acpi_disabled) \|\| !acpi_cpc_valid())
		return -ENODEV;

		all_cpu_data = kcalloc(num_possible_cpus(), sizeof(void *),
		GFP_KERNEL);
		if (!all_cpu_data)
		return -ENOMEM;

		for_each_possible_cpu(i) {
		all_cpu_data[i] = kzalloc(sizeof(struct cppc_cpudata), GFP_KERNEL);
		if (!all_cpu_data[i])
		goto out;

		cpu_data = all_cpu_data[i];
		if (!zalloc_cpumask_var(&cpu_data->shared_cpu_map, GFP_KERNEL))
		goto out;
		}

		ret = acpi_get_psd_map(all_cpu_data);
		if (ret) {
		pr_debug("Error parsing PSD data. Aborting cpufreq registration.\n");
		goto out;
		}
		INIT_LIST_HEAD(&cpu_data_list);

		cppc_check_hisi_workaround();

		ret = cpufreq_register_driver(&cppc_cpufreq_driver);
		if (ret)
		goto out;
		return cpufreq_register_driver(&cppc_cpufreq_driver);
		}

		return ret;
		static inline void free_cpu_data(void)
		{
		struct cppc_cpudata iter, tmp;

		out:
		for_each_possible_cpu(i) {
		cpu_data = all_cpu_data[i];
		if (!cpu_data)
		break;
		free_cpumask_var(cpu_data->shared_cpu_map);
		kfree(cpu_data);
		list_for_each_entry_safe(iter, tmp, &cpu_data_list, node) {
		free_cpumask_var(iter->shared_cpu_map);
		list_del(&iter->node);
		kfree(iter);
		}

		kfree(all_cpu_data);
		return -ENODEV;
		}

		static void __exit cppc_cpufreq_exit(void)
		{
		struct cppc_cpudata *cpu_data;
		int i;

		cpufreq_unregister_driver(&cppc_cpufreq_driver);

		for_each_possible_cpu(i) {
		cpu_data = all_cpu_data[i];
		free_cpumask_var(cpu_data->shared_cpu_map);
		kfree(cpu_data);
		}

		kfree(all_cpu_data);
		free_cpu_data();
		}

		module_exit(cppc_cpufreq_exit);

drivers/cpufreq/cpufreq.c

+40 −0

Original line number	Diff line number	Diff line
		@@ -2097,6 +2097,46 @@ unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
		}
		EXPORT_SYMBOL_GPL(cpufreq_driver_fast_switch);

		/**
		* cpufreq_driver_adjust_perf - Adjust CPU performance level in one go.
		* @cpu: Target CPU.
		* @min_perf: Minimum (required) performance level (units of @capacity).
		* @target_perf: Terget (desired) performance level (units of @capacity).
		* @capacity: Capacity of the target CPU.
		*
		* Carry out a fast performance level switch of @cpu without sleeping.
		*
		* The driver's ->adjust_perf() callback invoked by this function must be
		* suitable for being called from within RCU-sched read-side critical sections
		* and it is expected to select a suitable performance level equal to or above
		* @min_perf and preferably equal to or below @target_perf.
		*
		* This function must not be called if policy->fast_switch_enabled is unset.
		*
		* Governors calling this function must guarantee that it will never be invoked
		* twice in parallel for the same CPU and that it will never be called in
		* parallel with either ->target() or ->target_index() or ->fast_switch() for
		* the same CPU.
		*/
		void cpufreq_driver_adjust_perf(unsigned int cpu,
		unsigned long min_perf,
		unsigned long target_perf,
		unsigned long capacity)
		{
		cpufreq_driver->adjust_perf(cpu, min_perf, target_perf, capacity);
		}

		/**
		* cpufreq_driver_has_adjust_perf - Check "direct fast switch" callback.
		*
		* Return 'true' if the ->adjust_perf callback is present for the
		* current driver or 'false' otherwise.
		*/
		bool cpufreq_driver_has_adjust_perf(void)
		{
		return !!cpufreq_driver->adjust_perf;
		}

		/* Must set freqs->new to intermediate frequency */
		static int __target_intermediate(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs, int index)

Admin message