--- initial
+++ final
@@ -1,161 +1,160 @@
 static int eps_cpu_init(struct cpufreq_policy *policy) {
   unsigned int i;
   u32 lo, hi;
   u64 val;
   u8 current_multiplier, current_voltage;
   u8 max_multiplier, max_voltage;
   u8 min_multiplier, min_voltage;
   u8 brand = 0;
   u32 fsb;
   struct eps_cpu_data *centaur;
   struct cpuinfo_x86 *c = &cpu_data(0);
   struct cpufreq_frequency_table *f_table;
   int k, step, voltage;
   int ret;
   int states;
 #if defined CONFIG_ACPI_PROCESSOR || defined CONFIG_ACPI_PROCESSOR_MODULE
   unsigned int limit;
 #endif
   if (policy->cpu != 0) return -ENODEV;
   /* Check brand */
   printk(KERN_INFO "eps: Detected VIA ");
   switch (c->x86_model) {
   case 10:
     rdmsr(0x1153, lo, hi);
     brand = (((lo >> 2) ^ lo) >> 18) & 3;
     printk(KERN_CONT "Model A ");
     break;
   case 13:
     rdmsr(0x1154, lo, hi);
     brand = (((lo >> 4) ^ (lo >> 2))) & 0x000000ff;
     printk(KERN_CONT "Model D ");
     break;
   }
   switch (brand) {
   case EPS_BRAND_C7M: printk(KERN_CONT "C7-M\n"); break;
   case EPS_BRAND_C7: printk(KERN_CONT "C7\n"); break;
   case EPS_BRAND_EDEN: printk(KERN_CONT "Eden\n"); break;
   case EPS_BRAND_C7D: printk(KERN_CONT "C7-D\n"); break;
   case EPS_BRAND_C3:
     printk(KERN_CONT "C3\n");
     return -ENODEV;
     break;
   }
   /* Enable Enhanced PowerSaver */
   rdmsrl(MSR_IA32_MISC_ENABLE, val);
   if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
     val |= MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP;
     wrmsrl(MSR_IA32_MISC_ENABLE, val);
     /* Can be locked at 0 */
     rdmsrl(MSR_IA32_MISC_ENABLE, val);
     if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
       printk(KERN_INFO "eps: Can't enable Enhanced PowerSaver\n");
       return -ENODEV;
     }
   }
   /* Print voltage and multiplier */
   rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
   current_voltage = lo & 0xff;
   printk(KERN_INFO "eps: Current voltage = %dmV\n", current_voltage * 16 + 700);
   current_multiplier = (lo >> 8) & 0xff;
   printk(KERN_INFO "eps: Current multiplier = %d\n", current_multiplier);
   /* Print limits */
   max_voltage = hi & 0xff;
   printk(KERN_INFO "eps: Highest voltage = %dmV\n", max_voltage * 16 + 700);
   max_multiplier = (hi >> 8) & 0xff;
   printk(KERN_INFO "eps: Highest multiplier = %d\n", max_multiplier);
   min_voltage = (hi >> 16) & 0xff;
   printk(KERN_INFO "eps: Lowest voltage = %dmV\n", min_voltage * 16 + 700);
   min_multiplier = (hi >> 24) & 0xff;
   printk(KERN_INFO "eps: Lowest multiplier = %d\n", min_multiplier);
   /* Sanity checks */
   if (current_multiplier == 0 || max_multiplier == 0 || min_multiplier == 0) return -EINVAL;
   if (current_multiplier > max_multiplier || max_multiplier <= min_multiplier) return -EINVAL;
   if (current_voltage > 0x1f || max_voltage > 0x1f) return -EINVAL;
   if (max_voltage < min_voltage || current_voltage < min_voltage || current_voltage > max_voltage) return -EINVAL;
   /* Check for systems using underclocked CPU */
   if (!freq_failsafe_off && max_multiplier != current_multiplier) {
     printk(KERN_INFO "eps: Your processor is running at different "
                      "frequency then its maximum. Aborting.\n");
     printk(KERN_INFO "eps: You can use freq_failsafe_off option "
                      "to disable this check.\n");
     return -EINVAL;
   }
   if (!voltage_failsafe_off && max_voltage != current_voltage) {
     printk(KERN_INFO "eps: Your processor is running at different "
                      "voltage then its maximum. Aborting.\n");
     printk(KERN_INFO "eps: You can use voltage_failsafe_off "
                      "option to disable this check.\n");
     return -EINVAL;
   }
   /* Calc FSB speed */
   fsb = cpu_khz / current_multiplier;
 #if defined CONFIG_ACPI_PROCESSOR || defined CONFIG_ACPI_PROCESSOR_MODULE
   /* Check for ACPI processor speed limit */
   if (!ignore_acpi_limit && !eps_acpi_init()) {
     if (!acpi_processor_get_bios_limit(policy->cpu, &limit)) {
       printk(KERN_INFO "eps: ACPI limit %u.%uGHz\n", limit / 1000000, (limit % 1000000) / 10000);
       eps_acpi_exit(policy);
       /* Check if max_multiplier is in BIOS limits */
       if (limit && max_multiplier * fsb > limit) {
         printk(KERN_INFO "eps: Aborting.\n");
         return -EINVAL;
       }
     }
   }
 #endif
   /* Allow user to set lower maximum voltage then that reported
    * by processor */
   if (brand == EPS_BRAND_C7M && set_max_voltage) {
     u32 v;
     /* Change mV to something hardware can use */
     v = (set_max_voltage - 700) / 16;
     /* Check if voltage is within limits */
     if (v >= min_voltage && v <= max_voltage) {
       printk(KERN_INFO "eps: Setting %dmV as maximum.\n", v * 16 + 700);
       max_voltage = v;
     }
   }
   /* Calc number of p-states supported */
   if (brand == EPS_BRAND_C7M)
     states = max_multiplier - min_multiplier + 1;
   else
     states = 2;
   /* Allocate private data and frequency table for current cpu */
   centaur = kzalloc(sizeof(*centaur) + (states + 1) * sizeof(struct cpufreq_frequency_table), GFP_KERNEL);
   if (!centaur) return -ENOMEM;
   eps_cpu[0] = centaur;
   /* Copy basic values */
   centaur->fsb = fsb;
 #if defined CONFIG_ACPI_PROCESSOR || defined CONFIG_ACPI_PROCESSOR_MODULE
   centaur->bios_limit = limit;
 #endif
   /* Fill frequency and MSR value table */
   f_table = &centaur->freq_table[0];
   if (brand != EPS_BRAND_C7M) {
     f_table[0].frequency = fsb * min_multiplier;
     f_table[0].driver_data = (min_multiplier << 8) | min_voltage;
     f_table[1].frequency = fsb * max_multiplier;
     f_table[1].driver_data = (max_multiplier << 8) | max_voltage;
     f_table[2].frequency = CPUFREQ_TABLE_END;
   } else {
     k = 0;
     step = ((max_voltage - min_voltage) * 256) / (max_multiplier - min_multiplier);
     for (i = min_multiplier; i <= max_multiplier; i++) {
       voltage = (k * step) / 256 + min_voltage;
       f_table[k].frequency = fsb * i;
       f_table[k].driver_data = (i << 8) | voltage;
       k++;
     }
     f_table[k].frequency = CPUFREQ_TABLE_END;
   }
   policy->cpuinfo.transition_latency = 140000; /* 844mV -> 700mV in ns */
   policy->cur = fsb * current_multiplier;
-  ret = cpufreq_frequency_table_cpuinfo(policy, &centaur->freq_table[0]);
+  ret = cpufreq_table_validate_and_show(policy, &centaur->freq_table[0]);
   if (ret) {
     kfree(centaur);
     return ret;
   }
-  cpufreq_frequency_table_get_attr(&centaur->freq_table[0], policy->cpu);
   return 0;
 }<sep>@@
expression policy,table;
@@

-       cpufreq_frequency_table_cpuinfo
+       cpufreq_table_validate_and_show
		(policy, table)
...
-       cpufreq_frequency_table_get_attr(table, policy->cpu);