cpufreq: Add SFI based cpufreq driver support

This adds the SFI based cpu freq driver for some of the Intel's Silvermont based Atom architectures like Z34xx and Z35xx.

Signed-off-by Rudramuni, Vishwesh M <[email protected]>

Signed-off-by Srinidhi Kasagar <[email protected]>

Acked-by Viresh Kumar <[email protected]>

---

drivers/cpufreq/sfi-cpufreq.c +60 -0

+{
+       struct sfi_table_simple *sb;
+
+       sb = (struct sfi_table_simple *)table;
+
+       sfi_cpufreq_num = SFI_GET_NUM_ENTRIES(sb, struct sfi_freq_table_entry);
+       f_entry = (struct sfi_freq_table_entry *)sb->pentry;
+
+       return 0;
+}
+
+static int sfi_cpufreq_register_performance(struct sfi_cpufreq_performance *pr)
+{
+       mutex_lock(&performance_mutex);
+
+       /* parse the freq table from SFI */
+       sfi_table_parse(SFI_SIG_FREQ, NULL, NULL, parse_freq);
+
+       pr->state_count = sfi_cpufreq_num;
+       if (pr->state_count <= 1) {
+               pr_err("No p-states discovered\n");
+               return -ENODEV;
+       }
+
+       pr->states = f_entry;
+
+       mutex_unlock(&performance_mutex);
+
+       return 0;
+}
+
+static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
+{
+       u32 lo, hi, sfi_ctrl;
+       struct sfi_cpufreq_performance *perf;
+       struct cpufreq_frequency_table *pos;
+       struct sfi_cpufreq_data *data = per_cpu(drv_data, cpu);
+
+       rdmsr_on_cpu(cpu, MSR_IA32_PERF_CTL, &lo, &hi);
+       lo &= SFI_FREQ_MASK;
+
+       perf = data->sfi_data;
+
+       cpufreq_for_each_entry(pos, data->freq_table) {
+               sfi_ctrl = perf->states[pos->driver_data].ctrl_val
+                       & SFI_FREQ_MASK;
+               if (sfi_ctrl == lo)
+                       return pos->frequency;
+       }
+       return data->freq_table[0].frequency;
+}
+
+static int sfi_cpufreq_target(struct cpufreq_policy *policy,
+                               unsigned int index)
+{
+       struct sfi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+       struct sfi_cpufreq_performance *perf;
+       unsigned int next_perf_state = 0; /* Index into perf table */
+       u32 lo, hi;
+

drivers/cpufreq/sfi-cpufreq.c +6 -0

+
+       return 0;
+}
+
+static int sfi_cpufreq_cpu_init(struct cpufreq_policy *policy)
+{

Your code is dependent on policy->cpu at multiple places and it can change on CPU hotplug.

drivers/cpufreq/sfi-cpufreq.c +42 -0

+       per_cpu(drv_data, cpu) = data;
+
+       result = sfi_cpufreq_register_performance(data->sfi_data);
+       if (result)
+               goto err_free;
+
+       perf = data->sfi_data;
+       policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
+
+       data->freq_table = kzalloc(sizeof(*data->freq_table) *
+                               (perf->state_count+1), GFP_KERNEL);
+       if (!data->freq_table) {
+               result = -ENOMEM;
+               goto err_free;
+       }
+
+       policy->cpuinfo.transition_latency = 0;
+       for (i = 0; i < perf->state_count; i++) {
+               /* detect transition latency */
+               if ((perf->states[i].latency * 1000) >
+                   policy->cpuinfo.transition_latency)
+                       policy->cpuinfo.transition_latency =
+                               perf->states[i].latency * 1000;
+
+               /* initialize the freq table */
+               data->freq_table[valid_states].driver_data = i;
+               data->freq_table[valid_states].frequency =
+                               perf->states[i].freq_mhz * 1000;
+               valid_states++;
+
+               pr_debug("     %cP%d: %d MHz, %d uS\n",
+                       (i == perf->state ? '*' : ' '), i,
+                       (u32) perf->states[i].freq_mhz,
+                       (u32) perf->states[i].latency);
+       }
+
+       data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
+       perf->state = 0;
+
+       result = cpufreq_table_validate_and_show(policy, data->freq_table);
+       if (result)
+               goto err_freqfree;

drivers/cpufreq/sfi-cpufreq.c +19 -0

+
+       return result;
+}
+
+static int sfi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
+{
+       struct sfi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+
+       per_cpu(drv_data, policy->cpu) = NULL;
+       kfree(data->freq_table);
+       kfree(data);
+
+       return 0;
+}
+
+static struct cpufreq_driver sfi_cpufreq_driver = {
+       .flags          = CPUFREQ_CONST_LOOPS,
+       .get            = get_cur_freq_on_cpu,
+       .verify         = cpufreq_generic_frequency_table_verify,

drivers/cpufreq/sfi-cpufreq.c +19 -1

+       if (!sfi_perf_data) {
+               pr_err("Memory allocation error for sfi_perf_data.\n");
+               return -ENOMEM;
+       }
+
+       return cpufreq_register_driver(&sfi_cpufreq_driver);
+}
+late_initcall(sfi_cpufreq_init);
+
+static void __exit sfi_cpufreq_exit(void)
+{
+       cpufreq_unregister_driver(&sfi_cpufreq_driver);
+       free_percpu(sfi_perf_data);
+}
+module_exit(sfi_cpufreq_exit);
+
+MODULE_AUTHOR("Vishwesh M Rudramuni <[email protected]>");
+MODULE_DESCRIPTION("SFI P-States Driver");
+MODULE_LICENSE("GPL");
--

1.7.9.5

--

Quoted 2 lines · Srinidhi Kasagar

drivers/cpufreq/sfi-cpufreq.c +1 -0

+static int parse_freq(struct sfi_table_header *table)

drivers/cpufreq/sfi-cpufreq.c line 138

Quoted 13 lines

drivers/cpufreq/sfi-cpufreq.c +13 -0

+
+static int sfi_cpufreq_cpu_init(struct cpufreq_policy *policy)
+{
+       unsigned int i, result = 0, valid_states = 0;
+       unsigned int cpu = policy->cpu;
+       struct sfi_cpufreq_data *data;
+       struct sfi_cpufreq_performance *perf;
+
+       data = kzalloc(sizeof(*data), GFP_KERNEL);
+       if (!data)
+               return -ENOMEM;
+
+       data->sfi_data = per_cpu_ptr(sfi_perf_data, cpu);

I told you this before and this is still broken:

Quoted 2 lines

Your code is dependent on policy->cpu at multiple places and it can change on CPU hotplug.

To explain again, in your case a single policy will have two CPUs. Groups are: 0-1 and 2-3.
policy->cpu for both policies are 0 and 2.

If we hotplug out cpu 0 or cpu 2, policy->cpu will be updated to 1 and 3.

And then the above per-cpu variable access will return NULL, as you have initialized
them just for 0 and 2, not 1 and 3.

Not anymore now..I have fixed it in my earlier version.

$ cat /sys/devices/system/cpu/cpu*/cpufreq/affected_cpus
0
1
2
3

$  cat /sys/devices/system/cpu/cpu*/cpufreq/related_cpus
0
1
2
3

Quoted 8 lines · Srinidhi

Not anymore now..I have fixed it in my earlier version.

$ cat /sys/devices/system/cpu/cpu*/cpufreq/affected_cpus
0
1
2
3

Quoted 5 lines

$  cat /sys/devices/system/cpu/cpu*/cpufreq/related_cpus
0
1
2
3

What do you mean by you have fixed it? Weren't the CPUs sharing clock lines? I hope cpu 0 and 1 should be sharing their clock lines, i.e. they change freq together.
Also same for cpu 2 and 3.

The architecture supports both, and the current code allows me to change the freq independently and that's why the above output lines.

Quoted 3 lines · Srinidhi

The architecture supports both, and the current code allows me to change the freq independently and that's why the above output lines.

Which part of the code exactly controls this ?