Lines Matching refs:data
24 * power and thermal data sheets, (e.g. 30417.pdf, 30430.pdf, 43375.pdf)
99 static int query_current_values_with_pending_wait(struct powernow_k8_data *data)
112 data->currvid = hi & MSR_S_HI_CURRENT_VID;
113 data->currfid = lo & MSR_S_LO_CURRENT_FID;
119 static void count_off_irt(struct powernow_k8_data *data)
121 udelay((1 << data->irt) * 10);
125 static void count_off_vst(struct powernow_k8_data *data)
127 udelay(data->vstable * VST_UNITS_20US);
146 static int write_new_fid(struct powernow_k8_data *data, u32 fid)
149 u32 savevid = data->currvid;
152 if ((fid & INVALID_FID_MASK) || (data->currvid & INVALID_VID_MASK)) {
158 lo |= (data->currvid << MSR_C_LO_VID_SHIFT);
162 fid, lo, data->plllock * PLL_LOCK_CONVERSION);
165 wrmsr(MSR_FIDVID_CTL, lo, data->plllock * PLL_LOCK_CONVERSION);
170 } while (query_current_values_with_pending_wait(data));
172 count_off_irt(data);
174 if (savevid != data->currvid) {
176 savevid, data->currvid);
180 if (fid != data->currfid) {
182 data->currfid);
190 static int write_new_vid(struct powernow_k8_data *data, u32 vid)
193 u32 savefid = data->currfid;
196 if ((data->currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
201 lo = data->currfid;
214 } while (query_current_values_with_pending_wait(data));
216 if (savefid != data->currfid) {
218 savefid, data->currfid);
222 if (vid != data->currvid) {
224 vid, data->currvid);
236 static int decrease_vid_code_by_step(struct powernow_k8_data *data,
239 if ((data->currvid - reqvid) > step)
240 reqvid = data->currvid - step;
242 if (write_new_vid(data, reqvid))
245 count_off_vst(data);
251 static int transition_fid_vid(struct powernow_k8_data *data,
254 if (core_voltage_pre_transition(data, reqvid, reqfid))
257 if (core_frequency_transition(data, reqfid))
260 if (core_voltage_post_transition(data, reqvid))
263 if (query_current_values_with_pending_wait(data))
266 if ((reqfid != data->currfid) || (reqvid != data->currvid)) {
269 reqfid, reqvid, data->currfid, data->currvid);
274 smp_processor_id(), data->currfid, data->currvid);
280 static int core_voltage_pre_transition(struct powernow_k8_data *data,
283 u32 rvosteps = data->rvo;
284 u32 savefid = data->currfid;
289 data->currfid, data->currvid, reqvid, data->rvo);
300 while (data->currvid > reqvid) {
302 data->currvid, reqvid);
303 if (decrease_vid_code_by_step(data, reqvid, data->vidmvs))
308 ((rvomult * data->rvo + data->currvid) > reqvid)) {
309 if (data->currvid == maxvid) {
313 data->currvid - 1);
314 if (decrease_vid_code_by_step(data, data->currvid-1, 1))
320 if (query_current_values_with_pending_wait(data))
323 if (savefid != data->currfid) {
324 pr_err("ph1 err, currfid changed 0x%x\n", data->currfid);
329 data->currfid, data->currvid);
335 static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
338 u32 fid_interval, savevid = data->currvid;
340 if (data->currfid == reqfid) {
341 pr_err("ph2 null fid transition 0x%x\n", data->currfid);
347 data->currfid, data->currvid, reqfid);
350 vcocurrfid = convert_fid_to_vco_fid(data->currfid);
354 if ((reqfid <= LO_FID_TABLE_TOP) && (data->currfid <= LO_FID_TABLE_TOP))
358 (data->currfid & 1) ? (fid_interval = 1) : (fid_interval = 2);
360 if (reqfid > data->currfid) {
361 if (data->currfid > LO_FID_TABLE_TOP) {
362 if (write_new_fid(data,
363 data->currfid + fid_interval))
367 (data,
368 2 + convert_fid_to_vco_fid(data->currfid)))
372 if (write_new_fid(data, data->currfid - fid_interval))
376 vcocurrfid = convert_fid_to_vco_fid(data->currfid);
381 if (write_new_fid(data, reqfid))
384 if (query_current_values_with_pending_wait(data))
387 if (data->currfid != reqfid) {
389 data->currfid, reqfid);
393 if (savevid != data->currvid) {
395 savevid, data->currvid);
400 data->currfid, data->currvid);
406 static int core_voltage_post_transition(struct powernow_k8_data *data,
409 u32 savefid = data->currfid;
414 data->currfid, data->currvid);
416 if (reqvid != data->currvid) {
417 if (write_new_vid(data, reqvid))
420 if (savefid != data->currfid) {
422 savefid, data->currfid);
426 if (data->currvid != reqvid) {
428 reqvid, data->currvid);
433 if (query_current_values_with_pending_wait(data))
436 if (savereqvid != data->currvid) {
437 pr_debug("ph3 failed, currvid 0x%x\n", data->currvid);
441 if (savefid != data->currfid) {
443 data->currfid);
448 data->currfid, data->currvid);
492 static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst,
498 for (j = 0; j < data->numps; j++) {
504 if (pst[j].vid < data->rvo) {
509 if (pst[j].vid < maxvid + data->rvo) {
543 static void print_basics(struct powernow_k8_data *data)
546 for (j = 0; j < data->numps; j++) {
547 if (data->powernow_table[j].frequency !=
550 data->powernow_table[j].driver_data & 0xff,
551 data->powernow_table[j].frequency/1000,
552 data->powernow_table[j].driver_data >> 8);
555 if (data->batps)
556 pr_info("Only %d pstates on battery\n", data->batps);
559 static int fill_powernow_table(struct powernow_k8_data *data,
565 if (data->batps) {
568 data->batps);
569 data->numps = data->batps;
572 for (j = 1; j < data->numps; j++) {
579 if (data->numps < 2) {
584 if (check_pst_table(data, pst, maxvid))
588 * (data->numps + 1)), GFP_KERNEL);
592 for (j = 0; j < data->numps; j++) {
599 powernow_table[data->numps].frequency = CPUFREQ_TABLE_END;
600 powernow_table[data->numps].driver_data = 0;
602 if (query_current_values_with_pending_wait(data)) {
607 pr_debug("cfid 0x%x, cvid 0x%x\n", data->currfid, data->currvid);
608 data->powernow_table = powernow_table;
609 if (cpumask_first(topology_core_cpumask(data->cpu)) == data->cpu)
610 print_basics(data);
612 for (j = 0; j < data->numps; j++)
613 if ((pst[j].fid == data->currfid) &&
614 (pst[j].vid == data->currvid))
622 static int find_psb_table(struct powernow_k8_data *data)
653 data->vstable = psb->vstable;
655 data->vstable);
658 data->rvo = psb->flags2 & 3;
659 data->irt = ((psb->flags2) >> 2) & 3;
661 data->vidmvs = 1 << mvs;
662 data->batps = ((psb->flags2) >> 6) & 3;
664 pr_debug("ramp voltage offset: %d\n", data->rvo);
665 pr_debug("isochronous relief time: %d\n", data->irt);
666 pr_debug("maximum voltage step: %d - 0x%x\n", mvs, data->vidmvs);
682 data->plllock = psb->plllocktime;
688 data->numps = psb->numps;
689 pr_debug("numpstates: 0x%x\n", data->numps);
690 return fill_powernow_table(data,
709 static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data,
714 if (!data->acpi_data.state_count)
717 control = data->acpi_data.states[index].control;
718 data->irt = (control >> IRT_SHIFT) & IRT_MASK;
719 data->rvo = (control >> RVO_SHIFT) & RVO_MASK;
720 data->exttype = (control >> EXT_TYPE_SHIFT) & EXT_TYPE_MASK;
721 data->plllock = (control >> PLL_L_SHIFT) & PLL_L_MASK;
722 data->vidmvs = 1 << ((control >> MVS_SHIFT) & MVS_MASK);
723 data->vstable = (control >> VST_SHIFT) & VST_MASK;
726 static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
732 if (acpi_processor_register_performance(&data->acpi_data, data->cpu)) {
733 pr_debug("register performance failed: bad ACPI data\n");
737 /* verify the data contained in the ACPI structures */
738 if (data->acpi_data.state_count <= 1) {
743 control = data->acpi_data.control_register.space_id;
744 status = data->acpi_data.status_register.space_id;
753 /* fill in data->powernow_table */
755 * (data->acpi_data.state_count + 1)), GFP_KERNEL);
759 /* fill in data */
760 data->numps = data->acpi_data.state_count;
761 powernow_k8_acpi_pst_values(data, 0);
763 ret_val = fill_powernow_table_fidvid(data, powernow_table);
767 powernow_table[data->acpi_data.state_count].frequency =
769 data->powernow_table = powernow_table;
771 if (cpumask_first(topology_core_cpumask(data->cpu)) == data->cpu)
772 print_basics(data);
777 if (!zalloc_cpumask_var(&data->acpi_data.shared_cpu_map, GFP_KERNEL)) {
789 acpi_processor_unregister_performance(data->cpu);
791 /* data->acpi_data.state_count informs us at ->exit()
793 data->acpi_data.state_count = 0;
798 static int fill_powernow_table_fidvid(struct powernow_k8_data *data,
803 for (i = 0; i < data->acpi_data.state_count; i++) {
809 if (data->exttype) {
810 status = data->acpi_data.states[i].status;
814 control = data->acpi_data.states[i].control;
842 if (freq != (data->acpi_data.states[i].core_frequency * 1000)) {
845 (data->acpi_data.states[i].core_frequency
854 static void powernow_k8_cpu_exit_acpi(struct powernow_k8_data *data)
856 if (data->acpi_data.state_count)
857 acpi_processor_unregister_performance(data->cpu);
858 free_cpumask_var(data->acpi_data.shared_cpu_map);
861 static int get_transition_latency(struct powernow_k8_data *data)
865 for (i = 0; i < data->acpi_data.state_count; i++) {
866 int cur_latency = data->acpi_data.states[i].transition_latency
867 + data->acpi_data.states[i].bus_master_latency;
880 static int transition_frequency_fidvid(struct powernow_k8_data *data,
896 fid = data->powernow_table[index].driver_data & 0xFF;
897 vid = (data->powernow_table[index].driver_data & 0xFF00) >> 8;
901 if (query_current_values_with_pending_wait(data))
904 if ((data->currvid == vid) && (data->currfid == fid)) {
912 freqs.old = find_khz_freq_from_fid(data->currfid);
916 res = transition_fid_vid(data, fid, vid);
932 struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
937 if (!data)
940 checkfid = data->currfid;
941 checkvid = data->currvid;
949 pol->cpu, data->powernow_table[newstate].frequency, pol->min,
952 if (query_current_values_with_pending_wait(data))
956 data->currfid, data->currvid);
958 if ((checkvid != data->currvid) ||
959 (checkfid != data->currfid)) {
961 checkfid, data->currfid,
962 checkvid, data->currvid);
967 powernow_k8_acpi_pst_values(data, newstate);
969 ret = transition_frequency_fidvid(data, newstate, pol);
978 pol->cur = find_khz_freq_from_fid(data->currfid);
992 struct powernow_k8_data *data;
1006 if (query_current_values_with_pending_wait(init_on_cpu->data)) {
1024 struct powernow_k8_data *data;
1032 data = kzalloc(sizeof(*data), GFP_KERNEL);
1033 if (!data)
1036 data->cpu = pol->cpu;
1038 if (powernow_k8_cpu_init_acpi(data)) {
1051 rc = find_psb_table(data);
1058 ((data->rvo + 8) * data->vstable * VST_UNITS_20US) +
1059 ((1 << data->irt) * 30)) * 1000;
1061 pol->cpuinfo.transition_latency = get_transition_latency(data);
1064 init_on_cpu.data = data;
1065 smp_call_function_single(data->cpu, powernowk8_cpu_init_on_cpu,
1072 data->available_cores = pol->cpus;
1073 pol->freq_table = data->powernow_table;
1076 data->currfid, data->currvid);
1078 /* Point all the CPUs in this policy to the same data */
1080 per_cpu(powernow_data, cpu) = data;
1085 powernow_k8_cpu_exit_acpi(data);
1088 kfree(data);
1094 struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
1097 if (!data)
1100 powernow_k8_cpu_exit_acpi(data);
1102 kfree(data->powernow_table);
1103 kfree(data);
1114 struct powernow_k8_data *data = __this_cpu_read(powernow_data);
1116 *err = query_current_values_with_pending_wait(data);
1121 struct powernow_k8_data *data = per_cpu(powernow_data, cpu);
1125 if (!data)
1132 khz = find_khz_freq_from_fid(data->currfid);