Re: [PATCH v5 2/8] cpufreq: Use cpufreq_for_each_* macros for frequency table iteration

Prabhakar Lad
2014-04-26T09:58:21Z

Hi Stratos,

Thanks for the patch,

On Sat, Apr 26, 2014 at 1:45 AM, Stratos Karafotis
<stratosk@semaphore.gr> wrote:
> The cpufreq core now supports the cpufreq_for_each_entry and
> cpufreq_for_each_valid_entry macros helpers for iteration over the
> cpufreq_frequency_table, so use them.
>
> It should have no functional changes.
>
> Signed-off-by: Stratos Karafotis <stratosk@semaphore.gr>

For patches 1 & 2: Acked-by: Lad, Prabhakar <prabhakar.csengg@gmail.com>

and for patch 3: Acked-and-tested-by: Lad, Prabhakar
<prabhakar.csengg@gmail.com>

Thanks,
--Prabhakar lad

> ---
> drivers/cpufreq/acpi-cpufreq.c | 9 +++---
> drivers/cpufreq/arm_big_little.c | 16 +++++------
> drivers/cpufreq/cpufreq_stats.c | 24 ++++++----------
> drivers/cpufreq/dbx500-cpufreq.c | 8 ++----
> drivers/cpufreq/elanfreq.c | 9 +++---
> drivers/cpufreq/exynos-cpufreq.c | 11 ++++---
> drivers/cpufreq/exynos5440-cpufreq.c | 30 +++++++++----------
> drivers/cpufreq/freq_table.c | 56 ++++++++++++++++--------------------
> drivers/cpufreq/longhaul.c | 11 ++++---
> drivers/cpufreq/pasemi-cpufreq.c | 10 +++----
> drivers/cpufreq/powernow-k6.c | 14 ++++-----
> drivers/cpufreq/ppc_cbe_cpufreq.c | 9 +++---
> drivers/cpufreq/s3c2416-cpufreq.c | 40 +++++++++++---------------
> drivers/cpufreq/s3c64xx-cpufreq.c | 15 ++++------
> 14 files changed, 116 insertions(+), 146 deletions(-)
>
> diff --git a/drivers/cpufreq/acpi-cpufreq.c b/drivers/cpufreq/acpi-cpufreq.c
> index 000e4e0..b0c18ed 100644
> --- a/drivers/cpufreq/acpi-cpufreq.c
> +++ b/drivers/cpufreq/acpi-cpufreq.c
> @@ -213,7 +213,7 @@ static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
>
> static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
> {
> - int i;
> + struct cpufreq_frequency_table *pos;
> struct acpi_processor_performance *perf;
>
> if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
> @@ -223,10 +223,9 @@ static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
>
> perf = data->acpi_data;
>
> - for (i = 0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
> - if (msr == perf->states[data->freq_table[i].driver_data].status)
> - return data->freq_table[i].frequency;
> - }
> + cpufreq_for_each_entry(pos, data->freq_table)
> + if (msr == perf->states[pos->driver_data].status)
> + return pos->frequency;
> return data->freq_table[0].frequency;
> }
>
> diff --git a/drivers/cpufreq/arm_big_little.c b/drivers/cpufreq/arm_big_little.c
> index bad2ed3..1f4d4e3 100644
> --- a/drivers/cpufreq/arm_big_little.c
> +++ b/drivers/cpufreq/arm_big_little.c
> @@ -226,22 +226,22 @@ static inline u32 get_table_count(struct cpufreq_frequency_table *table)
> /* get the minimum frequency in the cpufreq_frequency_table */
> static inline u32 get_table_min(struct cpufreq_frequency_table *table)
> {
> - int i;
> + struct cpufreq_frequency_table *pos;
> uint32_t min_freq = ~0;
> - for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++)
> - if (table[i].frequency < min_freq)
> - min_freq = table[i].frequency;
> + cpufreq_for_each_entry(pos, table)
> + if (pos->frequency < min_freq)
> + min_freq = pos->frequency;
> return min_freq;
> }
>
> /* get the maximum frequency in the cpufreq_frequency_table */
> static inline u32 get_table_max(struct cpufreq_frequency_table *table)
> {
> - int i;
> + struct cpufreq_frequency_table *pos;
> uint32_t max_freq = 0;
> - for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++)
> - if (table[i].frequency > max_freq)
> - max_freq = table[i].frequency;
> + cpufreq_for_each_entry(pos, table)
> + if (pos->frequency > max_freq)
> + max_freq = pos->frequency;
> return max_freq;
> }
>
> diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
> index ecaaebf..0cd9b4d 100644
> --- a/drivers/cpufreq/cpufreq_stats.c
> +++ b/drivers/cpufreq/cpufreq_stats.c
> @@ -182,11 +182,11 @@ static void cpufreq_stats_free_table(unsigned int cpu)
>
> static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
> {
> - unsigned int i, j, count = 0, ret = 0;
> + unsigned int i, count = 0, ret = 0;
> struct cpufreq_stats *stat;
> unsigned int alloc_size;
> unsigned int cpu = policy->cpu;
> - struct cpufreq_frequency_table *table;
> + struct cpufreq_frequency_table *pos, *table;
>
> table = cpufreq_frequency_get_table(cpu);
> if (unlikely(!table))
> @@ -205,12 +205,8 @@ static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
> stat->cpu = cpu;
> per_cpu(cpufreq_stats_table, cpu) = stat;
>
> - for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
> - unsigned int freq = table[i].frequency;
> - if (freq == CPUFREQ_ENTRY_INVALID)
> - continue;
> + cpufreq_for_each_valid_entry(pos, table)
> count++;
> - }
>
> alloc_size = count * sizeof(int) + count * sizeof(u64);
>
> @@ -228,15 +224,11 @@ static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
> #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
> stat->trans_table = stat->freq_table + count;
> #endif
> - j = 0;
> - for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
> - unsigned int freq = table[i].frequency;
> - if (freq == CPUFREQ_ENTRY_INVALID)
> - continue;
> - if (freq_table_get_index(stat, freq) == -1)
> - stat->freq_table[j++] = freq;
> - }
> - stat->state_num = j;
> + i = 0;
> + cpufreq_for_each_valid_entry(pos, table)
> + if (freq_table_get_index(stat, pos->frequency) == -1)
> + stat->freq_table[i++] = pos->frequency;
> + stat->state_num = i;
> spin_lock(&cpufreq_stats_lock);
> stat->last_time = get_jiffies_64();
> stat->last_index = freq_table_get_index(stat, policy->cur);
> diff --git a/drivers/cpufreq/dbx500-cpufreq.c b/drivers/cpufreq/dbx500-cpufreq.c
> index 412a78b..4bebc1b 100644
> --- a/drivers/cpufreq/dbx500-cpufreq.c
> +++ b/drivers/cpufreq/dbx500-cpufreq.c
> @@ -45,7 +45,7 @@ static struct cpufreq_driver dbx500_cpufreq_driver = {
>
> static int dbx500_cpufreq_probe(struct platform_device *pdev)
> {
> - int i = 0;
> + struct cpufreq_frequency_table *pos;
>
> freq_table = dev_get_platdata(&pdev->dev);
> if (!freq_table) {
> @@ -60,10 +60,8 @@ static int dbx500_cpufreq_probe(struct platform_device *pdev)
> }
>
> pr_info("dbx500-cpufreq: Available frequencies:\n");
> - while (freq_table[i].frequency != CPUFREQ_TABLE_END) {
> - pr_info(" %d Mhz\n", freq_table[i].frequency/1000);
> - i++;
> - }
> + cpufreq_for_each_entry(pos, freq_table)
> + pr_info(" %d Mhz\n", pos->frequency / 1000);
>
> return cpufreq_register_driver(&dbx500_cpufreq_driver);
> }
> diff --git a/drivers/cpufreq/elanfreq.c b/drivers/cpufreq/elanfreq.c
> index 7f5d2a6..1c06e78 100644
> --- a/drivers/cpufreq/elanfreq.c
> +++ b/drivers/cpufreq/elanfreq.c
> @@ -147,7 +147,7 @@ static int elanfreq_target(struct cpufreq_policy *policy,
> static int elanfreq_cpu_init(struct cpufreq_policy *policy)
> {
> struct cpuinfo_x86 *c = &cpu_data(0);
> - unsigned int i;
> + struct cpufreq_frequency_table *pos;
>
> /* capability check */
> if ((c->x86_vendor != X86_VENDOR_AMD) ||
> @@ -159,10 +159,9 @@ static int elanfreq_cpu_init(struct cpufreq_policy *policy)
> max_freq = elanfreq_get_cpu_frequency(0);
>
> /* table init */
> - for (i = 0; (elanfreq_table[i].frequency != CPUFREQ_TABLE_END); i++) {
> - if (elanfreq_table[i].frequency > max_freq)
> - elanfreq_table[i].frequency = CPUFREQ_ENTRY_INVALID;
> - }
> + cpufreq_for_each_entry(pos, elanfreq_table)
> + if (pos->frequency > max_freq)
> + pos->frequency = CPUFREQ_ENTRY_INVALID;
>
> /* cpuinfo and default policy values */
> policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
> diff --git a/drivers/cpufreq/exynos-cpufreq.c b/drivers/cpufreq/exynos-cpufreq.c
> index f99cfe2..9c13255 100644
> --- a/drivers/cpufreq/exynos-cpufreq.c
> +++ b/drivers/cpufreq/exynos-cpufreq.c
> @@ -29,17 +29,16 @@ static unsigned int locking_frequency;
> static int exynos_cpufreq_get_index(unsigned int freq)
> {
> struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
> - int index;
> + struct cpufreq_frequency_table *pos;
>
> - for (index = 0;
> - freq_table[index].frequency != CPUFREQ_TABLE_END; index++)
> - if (freq_table[index].frequency == freq)
> + cpufreq_for_each_entry(pos, freq_table)
> + if (pos->frequency == freq)
> break;
>
> - if (freq_table[index].frequency == CPUFREQ_TABLE_END)
> + if (pos->frequency == CPUFREQ_TABLE_END)
> return -EINVAL;
>
> - return index;
> + return pos - freq_table;
> }
>
> static int exynos_cpufreq_scale(unsigned int target_freq)
> diff --git a/drivers/cpufreq/exynos5440-cpufreq.c b/drivers/cpufreq/exynos5440-cpufreq.c
> index a6b8214..f33f25b 100644
> --- a/drivers/cpufreq/exynos5440-cpufreq.c
> +++ b/drivers/cpufreq/exynos5440-cpufreq.c
> @@ -114,25 +114,23 @@ static struct cpufreq_freqs freqs;
>
> static int init_div_table(void)
> {
> - struct cpufreq_frequency_table *freq_tbl = dvfs_info->freq_table;
> + struct cpufreq_frequency_table *pos, *freq_tbl = dvfs_info->freq_table;
> unsigned int tmp, clk_div, ema_div, freq, volt_id;
> - int i = 0;
> struct dev_pm_opp *opp;
>
> rcu_read_lock();
> - for (i = 0; freq_tbl[i].frequency != CPUFREQ_TABLE_END; i++) {
> -
> + cpufreq_for_each_entry(pos, freq_tbl) {
> opp = dev_pm_opp_find_freq_exact(dvfs_info->dev,
> - freq_tbl[i].frequency * 1000, true);
> + pos->frequency * 1000, true);
> if (IS_ERR(opp)) {
> rcu_read_unlock();
> dev_err(dvfs_info->dev,
> "failed to find valid OPP for %u KHZ\n",
> - freq_tbl[i].frequency);
> + pos->frequency);
> return PTR_ERR(opp);
> }
>
> - freq = freq_tbl[i].frequency / 1000; /* In MHZ */
> + freq = pos->frequency / 1000; /* In MHZ */
> clk_div = ((freq / CPU_DIV_FREQ_MAX) & P0_7_CPUCLKDEV_MASK)
> << P0_7_CPUCLKDEV_SHIFT;
> clk_div |= ((freq / CPU_ATB_FREQ_MAX) & P0_7_ATBCLKDEV_MASK)
> @@ -157,7 +155,8 @@ static int init_div_table(void)
> tmp = (clk_div | ema_div | (volt_id << P0_7_VDD_SHIFT)
> | ((freq / FREQ_UNIT) << P0_7_FREQ_SHIFT));
>
> - __raw_writel(tmp, dvfs_info->base + XMU_PMU_P0_7 + 4 * i);
> + __raw_writel(tmp, dvfs_info->base + XMU_PMU_P0_7 + 4 *
> + (pos - freq_tbl));
> }
>
> rcu_read_unlock();
> @@ -166,8 +165,9 @@ static int init_div_table(void)
>
> static void exynos_enable_dvfs(unsigned int cur_frequency)
> {
> - unsigned int tmp, i, cpu;
> + unsigned int tmp, cpu;
> struct cpufreq_frequency_table *freq_table = dvfs_info->freq_table;
> + struct cpufreq_frequency_table *pos;
> /* Disable DVFS */
> __raw_writel(0, dvfs_info->base + XMU_DVFS_CTRL);
>
> @@ -182,15 +182,15 @@ static void exynos_enable_dvfs(unsigned int cur_frequency)
> __raw_writel(tmp, dvfs_info->base + XMU_PMUIRQEN);
>
> /* Set initial performance index */
> - for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++)
> - if (freq_table[i].frequency == cur_frequency)
> + cpufreq_for_each_entry(pos, freq_table)
> + if (pos->frequency == cur_frequency)
> break;
>
> - if (freq_table[i].frequency == CPUFREQ_TABLE_END) {
> + if (pos->frequency == CPUFREQ_TABLE_END) {
> dev_crit(dvfs_info->dev, "Boot up frequency not supported\n");
> /* Assign the highest frequency */
> - i = 0;
> - cur_frequency = freq_table[i].frequency;
> + pos = freq_table;
> + cur_frequency = pos->frequency;
> }
>
> dev_info(dvfs_info->dev, "Setting dvfs initial frequency = %uKHZ",
> @@ -199,7 +199,7 @@ static void exynos_enable_dvfs(unsigned int cur_frequency)
> for (cpu = 0; cpu < CONFIG_NR_CPUS; cpu++) {
> tmp = __raw_readl(dvfs_info->base + XMU_C0_3_PSTATE + cpu * 4);
> tmp &= ~(P_VALUE_MASK << C0_3_PSTATE_NEW_SHIFT);
> - tmp |= (i << C0_3_PSTATE_NEW_SHIFT);
> + tmp |= ((pos - freq_table) << C0_3_PSTATE_NEW_SHIFT);
> __raw_writel(tmp, dvfs_info->base + XMU_C0_3_PSTATE + cpu * 4);
> }
>
> diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
> index 08e7bbc..8e518c6 100644
> --- a/drivers/cpufreq/freq_table.c
> +++ b/drivers/cpufreq/freq_table.c
> @@ -21,22 +21,19 @@
> int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
> struct cpufreq_frequency_table *table)
> {
> + struct cpufreq_frequency_table *pos;
> unsigned int min_freq = ~0;
> unsigned int max_freq = 0;
> - unsigned int i;
> + unsigned int freq;
>
> - for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
> - unsigned int freq = table[i].frequency;
> - if (freq == CPUFREQ_ENTRY_INVALID) {
> - pr_debug("table entry %u is invalid, skipping\n", i);
> + cpufreq_for_each_valid_entry(pos, table) {
> + freq = pos->frequency;
>
> - continue;
> - }
> if (!cpufreq_boost_enabled()
> - && (table[i].flags & CPUFREQ_BOOST_FREQ))
> + && (pos->flags & CPUFREQ_BOOST_FREQ))
> continue;
>
> - pr_debug("table entry %u: %u kHz\n", i, freq);
> + pr_debug("table entry %u: %u kHz\n", (int)(pos - table), freq);
> if (freq < min_freq)
> min_freq = freq;
> if (freq > max_freq)
> @@ -57,7 +54,8 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
> int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
> struct cpufreq_frequency_table *table)
> {
> - unsigned int next_larger = ~0, freq, i = 0;
> + struct cpufreq_frequency_table *pos;
> + unsigned int freq, next_larger = ~0;
> bool found = false;
>
> pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
> @@ -65,9 +63,9 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
>
> cpufreq_verify_within_cpu_limits(policy);
>
> - for (; freq = table[i].frequency, freq != CPUFREQ_TABLE_END; i++) {
> - if (freq == CPUFREQ_ENTRY_INVALID)
> - continue;
> + cpufreq_for_each_valid_entry(pos, table) {
> + freq = pos->frequency;
> +
> if ((freq >= policy->min) && (freq <= policy->max)) {
> found = true;
> break;
> @@ -118,7 +116,8 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
> .driver_data = ~0,
> .frequency = 0,
> };
> - unsigned int i;
> + struct cpufreq_frequency_table *pos;
> + unsigned int freq, i = 0;
>
> pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
> target_freq, relation, policy->cpu);
> @@ -132,10 +131,10 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
> break;
> }
>
> - for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
> - unsigned int freq = table[i].frequency;
> - if (freq == CPUFREQ_ENTRY_INVALID)
> - continue;
> + cpufreq_for_each_valid_entry(pos, table) {
> + freq = pos->frequency;
> +
> + i = pos - table;
> if ((freq < policy->min) || (freq > policy->max))
> continue;
> switch (relation) {
> @@ -184,8 +183,7 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
> int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
> unsigned int freq)
> {
> - struct cpufreq_frequency_table *table;
> - int i;
> + struct cpufreq_frequency_table *pos, *table;
>
> table = cpufreq_frequency_get_table(policy->cpu);
> if (unlikely(!table)) {
> @@ -193,10 +191,9 @@ int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
> return -ENOENT;
> }
>
> - for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
> - if (table[i].frequency == freq)
> - return i;
> - }
> + cpufreq_for_each_valid_entry(pos, table)
> + if (pos->frequency == freq)
> + return pos - table;
>
> return -EINVAL;
> }
> @@ -208,16 +205,13 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_index);
> static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf,
> bool show_boost)
> {
> - unsigned int i = 0;
> ssize_t count = 0;
> - struct cpufreq_frequency_table *table = policy->freq_table;
> + struct cpufreq_frequency_table *pos, *table = policy->freq_table;
>
> if (!table)
> return -ENODEV;
>
> - for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
> - if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
> - continue;
> + cpufreq_for_each_valid_entry(pos, table) {
> /*
> * show_boost = true and driver_data = BOOST freq
> * display BOOST freqs
> @@ -229,10 +223,10 @@ static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf,
> * show_boost = false and driver_data != BOOST freq
> * display NON BOOST freqs
> */
> - if (show_boost ^ (table[i].flags & CPUFREQ_BOOST_FREQ))
> + if (show_boost ^ (pos->flags & CPUFREQ_BOOST_FREQ))
> continue;
>
> - count += sprintf(&buf[count], "%d ", table[i].frequency);
> + count += sprintf(&buf[count], "%d ", pos->frequency);
> }
> count += sprintf(&buf[count], "\n");
>
> diff --git a/drivers/cpufreq/longhaul.c b/drivers/cpufreq/longhaul.c
> index d00e5d1..f4024d4 100644
> --- a/drivers/cpufreq/longhaul.c
> +++ b/drivers/cpufreq/longhaul.c
> @@ -528,6 +528,7 @@ static int longhaul_get_ranges(void)
>
> static void longhaul_setup_voltagescaling(void)
> {
> + struct cpufreq_frequency_table *freq_pos;
> union msr_longhaul longhaul;
> struct mV_pos minvid, maxvid, vid;
> unsigned int j, speed, pos, kHz_step, numvscales;
> @@ -606,18 +607,16 @@ static void longhaul_setup_voltagescaling(void)
> /* Calculate kHz for one voltage step */
> kHz_step = (highest_speed - min_vid_speed) / numvscales;
>
> - j = 0;
> - while (longhaul_table[j].frequency != CPUFREQ_TABLE_END) {
> - speed = longhaul_table[j].frequency;
> + cpufreq_for_each_entry(freq_pos, longhaul_table) {
> + speed = freq_pos->frequency;
> if (speed > min_vid_speed)
> pos = (speed - min_vid_speed) / kHz_step + minvid.pos;
> else
> pos = minvid.pos;
> - longhaul_table[j].driver_data |= mV_vrm_table[pos] << 8;
> + freq_pos->driver_data |= mV_vrm_table[pos] << 8;
> vid = vrm_mV_table[mV_vrm_table[pos]];
> printk(KERN_INFO PFX "f: %d kHz, index: %d, vid: %d mV\n",
> - speed, j, vid.mV);
> - j++;
> + speed, (int)(freq_pos - longhaul_table), vid.mV);
> }
>
> can_scale_voltage = 1;
> diff --git a/drivers/cpufreq/pasemi-cpufreq.c b/drivers/cpufreq/pasemi-cpufreq.c
> index 84c84b5..35dd4d7 100644
> --- a/drivers/cpufreq/pasemi-cpufreq.c
> +++ b/drivers/cpufreq/pasemi-cpufreq.c
> @@ -136,9 +136,10 @@ void restore_astate(int cpu)
>
> static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
> {
> + struct cpufreq_frequency_table *pos;
> const u32 *max_freqp;
> u32 max_freq;
> - int i, cur_astate;
> + int cur_astate;
> struct resource res;
> struct device_node *cpu, *dn;
> int err = -ENODEV;
> @@ -197,10 +198,9 @@ static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
> pr_debug("initializing frequency table\n");
>
> /* initialize frequency table */
> - for (i=0; pas_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
> - pas_freqs[i].frequency =
> - get_astate_freq(pas_freqs[i].driver_data) * 100000;
> - pr_debug("%d: %d\n", i, pas_freqs[i].frequency);
> + cpufreq_for_each_entry(pos, pas_freqs) {
> + pos->frequency = get_astate_freq(pos->driver_data) * 100000;
> + pr_debug("%d: %d\n", (int)(pos - pas_freqs), pos->frequency);
> }
>
> cur_astate = get_cur_astate(policy->cpu);
> diff --git a/drivers/cpufreq/powernow-k6.c b/drivers/cpufreq/powernow-k6.c
> index 49f120e..a133236 100644
> --- a/drivers/cpufreq/powernow-k6.c
> +++ b/drivers/cpufreq/powernow-k6.c
> @@ -159,6 +159,7 @@ static int powernow_k6_target(struct cpufreq_policy *policy,
>
> static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
> {
> + struct cpufreq_frequency_table *pos;
> unsigned int i, f;
> unsigned khz;
>
> @@ -176,12 +177,11 @@ static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
> }
> }
> if (param_max_multiplier) {
> - for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
> - if (clock_ratio[i].driver_data == param_max_multiplier) {
> + cpufreq_for_each_entry(pos, clock_ratio)
> + if (pos->driver_data == param_max_multiplier) {
> max_multiplier = param_max_multiplier;
> goto have_max_multiplier;
> }
> - }
> printk(KERN_ERR "powernow-k6: invalid max_multiplier parameter, valid parameters 20, 30, 35, 40, 45, 50, 55, 60\n");
> return -EINVAL;
> }
> @@ -209,12 +209,12 @@ have_busfreq:
> param_busfreq = busfreq * 10;
>
> /* table init */
> - for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
> - f = clock_ratio[i].driver_data;
> + cpufreq_for_each_entry(pos, clock_ratio) {
> + f = pos->driver_data;
> if (f > max_multiplier)
> - clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID;
> + pos->frequency = CPUFREQ_ENTRY_INVALID;
> else
> - clock_ratio[i].frequency = busfreq * f;
> + pos->frequency = busfreq * f;
> }
>
> /* cpuinfo and default policy values */
> diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c
> index 5be8a48..5a4c5a6 100644
> --- a/drivers/cpufreq/ppc_cbe_cpufreq.c
> +++ b/drivers/cpufreq/ppc_cbe_cpufreq.c
> @@ -67,9 +67,10 @@ static int set_pmode(unsigned int cpu, unsigned int slow_mode)
>
> static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
> {
> + struct cpufreq_frequency_table *pos;
> const u32 *max_freqp;
> u32 max_freq;
> - int i, cur_pmode;
> + int cur_pmode;
> struct device_node *cpu;
>
> cpu = of_get_cpu_node(policy->cpu, NULL);
> @@ -102,9 +103,9 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
> pr_debug("initializing frequency table\n");
>
> /* initialize frequency table */
> - for (i=0; cbe_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
> - cbe_freqs[i].frequency = max_freq / cbe_freqs[i].driver_data;
> - pr_debug("%d: %d\n", i, cbe_freqs[i].frequency);
> + cpufreq_for_each_entry(pos, cbe_freqs) {
> + pos->frequency = max_freq / pos->driver_data;
> + pr_debug("%d: %d\n", (int)(pos - cbe_freqs), pos->frequency);
> }
>
> /* if DEBUG is enabled set_pmode() measures the latency
> diff --git a/drivers/cpufreq/s3c2416-cpufreq.c b/drivers/cpufreq/s3c2416-cpufreq.c
> index 4626f90..2fd53ea 100644
> --- a/drivers/cpufreq/s3c2416-cpufreq.c
> +++ b/drivers/cpufreq/s3c2416-cpufreq.c
> @@ -266,7 +266,7 @@ out:
> static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
> {
> int count, v, i, found;
> - struct cpufreq_frequency_table *freq;
> + struct cpufreq_frequency_table *pos;
> struct s3c2416_dvfs *dvfs;
>
> count = regulator_count_voltages(s3c_freq->vddarm);
> @@ -275,12 +275,11 @@ static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
> return;
> }
>
> - freq = s3c_freq->freq_table;
> - while (count > 0 && freq->frequency != CPUFREQ_TABLE_END) {
> - if (freq->frequency == CPUFREQ_ENTRY_INVALID)
> - continue;
> + if (!count)
> + goto out;
>
> - dvfs = &s3c2416_dvfs_table[freq->driver_data];
> + cpufreq_for_each_valid_entry(pos, s3c_freq->freq_table) {
> + dvfs = &s3c2416_dvfs_table[pos->driver_data];
> found = 0;
>
> /* Check only the min-voltage, more is always ok on S3C2416 */
> @@ -292,13 +291,12 @@ static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
>
> if (!found) {
> pr_debug("cpufreq: %dkHz unsupported by regulator\n",
> - freq->frequency);
> - freq->frequency = CPUFREQ_ENTRY_INVALID;
> + pos->frequency);
> + pos->frequency = CPUFREQ_ENTRY_INVALID;
> }
> -
> - freq++;
> }
>
> +out:
> /* Guessed */
> s3c_freq->regulator_latency = 1 * 1000 * 1000;
> }
> @@ -338,7 +336,7 @@ static struct notifier_block s3c2416_cpufreq_reboot_notifier = {
> static int __init s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
> {
> struct s3c2416_data *s3c_freq = &s3c2416_cpufreq;
> - struct cpufreq_frequency_table *freq;
> + struct cpufreq_frequency_table *pos;
> struct clk *msysclk;
> unsigned long rate;
> int ret;
> @@ -427,31 +425,27 @@ static int __init s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
> s3c_freq->regulator_latency = 0;
> #endif
>
> - freq = s3c_freq->freq_table;
> - while (freq->frequency != CPUFREQ_TABLE_END) {
> + cpufreq_for_each_entry(pos, s3c_freq->freq_table) {
> /* special handling for dvs mode */
> - if (freq->driver_data == 0) {
> + if (pos->driver_data == 0) {
> if (!s3c_freq->hclk) {
> pr_debug("cpufreq: %dkHz unsupported as it would need unavailable dvs mode\n",
> - freq->frequency);
> - freq->frequency = CPUFREQ_ENTRY_INVALID;
> + pos->frequency);
> + pos->frequency = CPUFREQ_ENTRY_INVALID;
> } else {
> - freq++;
> continue;
> }
> }
>
> /* Check for frequencies we can generate */
> rate = clk_round_rate(s3c_freq->armdiv,
> - freq->frequency * 1000);
> + pos->frequency * 1000);
> rate /= 1000;
> - if (rate != freq->frequency) {
> + if (rate != pos->frequency) {
> pr_debug("cpufreq: %dkHz unsupported by clock (clk_round_rate return %lu)\n",
> - freq->frequency, rate);
> - freq->frequency = CPUFREQ_ENTRY_INVALID;
> + pos->frequency, rate);
> + pos->frequency = CPUFREQ_ENTRY_INVALID;
> }
> -
> - freq++;
> }
>
> /* Datasheet says PLL stabalisation time must be at least 300us,
> diff --git a/drivers/cpufreq/s3c64xx-cpufreq.c b/drivers/cpufreq/s3c64xx-cpufreq.c
> index ff7d3ec..176e84c 100644
> --- a/drivers/cpufreq/s3c64xx-cpufreq.c
> +++ b/drivers/cpufreq/s3c64xx-cpufreq.c
> @@ -118,11 +118,10 @@ static void __init s3c64xx_cpufreq_config_regulator(void)
> pr_err("Unable to check supported voltages\n");
> }
>
> - freq = s3c64xx_freq_table;
> - while (count > 0 && freq->frequency != CPUFREQ_TABLE_END) {
> - if (freq->frequency == CPUFREQ_ENTRY_INVALID)
> - continue;
> + if (!count)
> + goto out;
>
> + cpufreq_for_each_valid_entry(freq, s3c64xx_freq_table) {
> dvfs = &s3c64xx_dvfs_table[freq->driver_data];
> found = 0;
>
> @@ -137,10 +136,9 @@ static void __init s3c64xx_cpufreq_config_regulator(void)
> freq->frequency);
> freq->frequency = CPUFREQ_ENTRY_INVALID;
> }
> -
> - freq++;
> }
>
> +out:
> /* Guess based on having to do an I2C/SPI write; in future we
> * will be able to query the regulator performance here. */
> regulator_latency = 1 * 1000 * 1000;
> @@ -179,8 +177,7 @@ static int s3c64xx_cpufreq_driver_init(struct cpufreq_policy *policy)
> }
> #endif
>
> - freq = s3c64xx_freq_table;
> - while (freq->frequency != CPUFREQ_TABLE_END) {
> + cpufreq_for_each_entry(freq, s3c64xx_freq_table) {
> unsigned long r;
>
> /* Check for frequencies we can generate */
> @@ -196,8 +193,6 @@ static int s3c64xx_cpufreq_driver_init(struct cpufreq_policy *policy)
> * frequency is the maximum we can support. */
> if (!vddarm && freq->frequency > clk_get_rate(policy->clk) / 1000)
> freq->frequency = CPUFREQ_ENTRY_INVALID;
> -
> - freq++;
> }
>
> /* Datasheet says PLL stabalisation time (if we were to use
> --
> 1.9.0