/* * This API is to be called during init to set the various voltage * domains to the voltage as per the opp table. Typically we boot up * at the nominal voltage. So this function finds out the rate of * the clock associated with the voltage domain, finds out the correct * opp entry and sets the voltage domain to the voltage specified * in the opp entry */ static int __init omap2_set_init_voltage(char *vdd_name, char *clk_name, const char *oh_name) { struct voltagedomain *voltdm; struct clk *clk; struct opp *opp; unsigned long freq, bootup_volt; struct device *dev; if (!vdd_name || !clk_name || !oh_name) { pr_err("%s: invalid parameters\n", __func__); goto exit; } dev = omap_device_get_by_hwmod_name(oh_name); if (IS_ERR(dev)) { pr_err("%s: Unable to get dev pointer for hwmod %s\n", __func__, oh_name); goto exit; } voltdm = voltdm_lookup(vdd_name); if (IS_ERR(voltdm)) { pr_err("%s: unable to get vdd pointer for vdd_%s\n", __func__, vdd_name); goto exit; } clk = clk_get(NULL, clk_name); if (IS_ERR(clk)) { pr_err("%s: unable to get clk %s\n", __func__, clk_name); goto exit; } freq = clk->rate; clk_put(clk); opp = opp_find_freq_ceil(dev, &freq); if (IS_ERR(opp)) { pr_err("%s: unable to find boot up OPP for vdd_%s\n", __func__, vdd_name); goto exit; } bootup_volt = opp_get_voltage(opp); if (!bootup_volt) { pr_err("%s: unable to find voltage corresponding " "to the bootup OPP for vdd_%s\n", __func__, vdd_name); goto exit; } voltdm_scale(voltdm, bootup_volt); return 0; exit: pr_err("%s: unable to set vdd_%s\n", __func__, vdd_name); return -EINVAL; }
/** * sr_class1p5_calib_work() - work which actually does the calibration * @work: pointer to the work * * calibration routine uses the following logic: * on the first trigger, we start the isr to collect sr voltages * wait for stabilization delay (reschdule self instead of sleeping) * after the delay, see if we collected any isr events * if none, we have calibrated voltage. * if there are any, we retry untill we giveup. * on retry timeout, select a voltage to use as safe voltage. */ static void sr_class1p5_calib_work(struct work_struct *work) { struct sr_class1p5_work_data *work_data = container_of(work, struct sr_class1p5_work_data, work.work); unsigned long u_volt_safe = 0, u_volt_current = 0, u_volt_margin = 0; struct omap_volt_data *volt_data; struct voltagedomain *voltdm; int idx = 0; if (!work) { pr_err("%s: ooops.. null work_data?\n", __func__); return; } /* * Handle the case where we might have just been scheduled AND * 1.5 disable was called. */ if (!mutex_trylock(&omap_dvfs_lock)) { schedule_delayed_work(&work_data->work, msecs_to_jiffies(SR1P5_SAMPLING_DELAY_MS * SR1P5_STABLE_SAMPLES)); return; } voltdm = work_data->voltdm; /* * In the unlikely case that we did get through when unplanned, * flag and return. */ if (unlikely(!work_data->work_active)) { pr_err("%s:%s unplanned work invocation!\n", __func__, voltdm->name); mutex_unlock(&omap_dvfs_lock); return; } volt_data = work_data->vdata; work_data->num_calib_triggers++; /* if we are triggered first time, we need to start isr to sample */ if (work_data->num_calib_triggers == 1) { /* We could be interrupted many times, so, only for debug */ pr_debug("%s: %s: Calibration start: Voltage Nominal=%d\n", __func__, voltdm->name, volt_data->volt_nominal); goto start_sampling; } /* Stop isr from interrupting our measurements :) */ sr_notifier_control(voltdm, false); /* * Quit sampling * a) if we have oscillations * b) if we have nominal voltage as the voltage */ if (work_data->num_calib_triggers == SR1P5_MAX_TRIGGERS) goto stop_sampling; /* if there are no samples captured.. SR is silent, aka stability! */ if (!work_data->num_osc_samples) { /* Did we interrupt too early? */ u_volt_current = omap_vp_get_curr_volt(voltdm); if (u_volt_current >= volt_data->volt_nominal) goto start_sampling; u_volt_safe = u_volt_current; goto done_calib; } /* we have potential oscillations/first sample */ start_sampling: work_data->num_osc_samples = 0; /* Clear transdone events so that we can go on. */ do { if (!omap_vp_is_transdone(voltdm)) break; idx++; /* get some constant delay */ udelay(1); omap_vp_clear_transdone(voltdm); } while (idx < MAX_CHECK_VPTRANS_US); if (idx >= MAX_CHECK_VPTRANS_US) pr_warning("%s: timed out waiting for transdone clear!!\n", __func__); /* Clear pending events */ sr_notifier_control(voltdm, false); /* trigger sampling */ sr_notifier_control(voltdm, true); schedule_delayed_work(&work_data->work, msecs_to_jiffies(SR1P5_SAMPLING_DELAY_MS * SR1P5_STABLE_SAMPLES)); mutex_unlock(&omap_dvfs_lock); return; stop_sampling: /* * We are here for Oscillations due to two scenarios: * a) SR is attempting to adjust voltage lower than VLIMITO * which VP will ignore, but SR will re-attempt * b) actual oscillations * NOTE: For debugging, enable debug to see the samples. */ pr_warning("%s: %s Stop sampling: Voltage Nominal=%d samples=%d\n", __func__, work_data->voltdm->name, volt_data->volt_nominal, work_data->num_osc_samples); /* pick up current voltage */ u_volt_current = omap_vp_get_curr_volt(voltdm); /* Just in case we got more interrupts than our tiny buffer */ if (work_data->num_osc_samples > SR1P5_STABLE_SAMPLES) idx = SR1P5_STABLE_SAMPLES; else idx = work_data->num_osc_samples; /* Index at 0 */ idx -= 1; u_volt_safe = u_volt_current; /* Grab the max of the samples as the stable voltage */ for (; idx >= 0; idx--) { pr_debug("%s: osc_v[%d]=%ld, safe_v=%ld\n", __func__, idx, work_data->u_volt_samples[idx], u_volt_safe); if (work_data->u_volt_samples[idx] > u_volt_safe) u_volt_safe = work_data->u_volt_samples[idx]; } /* Fall through to close up common stuff */ done_calib: sr_disable_errgen(voltdm); omap_vp_disable(voltdm); sr_disable(voltdm); /* Add margin if needed */ if (volt_data->volt_margin) { struct omap_voltdm_pmic *pmic = voltdm->pmic; /* Convert to rounded to PMIC step level if available */ if (pmic && pmic->vsel_to_uv && pmic->uv_to_vsel) { /* * To ensure conversion works: * use a proper base voltage - we use the current volt * then convert it with pmic routine to vsel and back * to voltage, and finally remove the base voltage */ u_volt_margin = u_volt_current + volt_data->volt_margin; u_volt_margin = pmic->uv_to_vsel(u_volt_margin); u_volt_margin = pmic->vsel_to_uv(u_volt_margin); u_volt_margin -= u_volt_current; } else { u_volt_margin = volt_data->volt_margin; } u_volt_safe += u_volt_margin; } if (u_volt_safe > volt_data->volt_nominal) { pr_warning("%s: %s Vsafe %ld > Vnom %d. %ld[%d] margin on" "vnom %d curr_v=%ld\n", __func__, voltdm->name, u_volt_safe, volt_data->volt_nominal, u_volt_margin, volt_data->volt_margin, volt_data->volt_nominal, u_volt_current); } volt_data->volt_calibrated = u_volt_safe; /* Setup my dynamic voltage for the next calibration for this opp */ volt_data->volt_dynamic_nominal = omap_get_dyn_nominal(volt_data); /* * if the voltage we decided as safe is not the current voltage, * switch */ if (volt_data->volt_calibrated != u_volt_current) { pr_debug("%s: %s reconfiguring to voltage %d\n", __func__, voltdm->name, volt_data->volt_calibrated); voltdm_scale(voltdm, volt_data); } pr_info("%s: %s: Calibration complete: Voltage:Nominal=%d," "Calib=%d,margin=%d\n", __func__, voltdm->name, volt_data->volt_nominal, volt_data->volt_calibrated, volt_data->volt_margin); /* * TODO: Setup my wakeup voltage to allow immediate going to OFF and * on - Pending twl and voltage layer cleanups. * This is necessary, as this is not done as part of regular * Dvfs flow. * vc_setup_on_voltage(voltdm, volt_data->volt_calibrated); */ work_data->work_active = false; mutex_unlock(&omap_dvfs_lock); }
static int twl_set_voltage(void *data, int target_uV) { struct voltagedomain *voltdm = (struct voltagedomain *)data; return voltdm_scale(voltdm, target_uV); }
/* * This API is to be called during init to set the various voltage * domains to the voltage as per the opp table. Typically we boot up * at the nominal voltage. So this function finds out the rate of * the clock associated with the voltage domain, finds out the correct * opp entry and sets the voltage domain to the voltage specified * in the opp entry */ static int __init omap2_set_init_voltage(char *vdd_name, char *clk_name, const char *oh_name) { struct voltagedomain *voltdm; struct clk *clk; struct opp *opp; struct device *dev; unsigned long freq_cur, freq_valid, bootup_volt; int ret = -EINVAL; dev = omap_device_get_by_hwmod_name(oh_name); if (IS_ERR(dev)) { pr_err("%s: Unable to get dev pointer for hwmod %s\n", __func__, oh_name); goto exit; } voltdm = voltdm_lookup(vdd_name); if (IS_ERR(voltdm)) { pr_err("%s: unable to get vdd pointer for vdd_%s\n", __func__, vdd_name); goto exit; } clk = clk_get(NULL, clk_name); if (IS_ERR(clk)) { pr_err("%s: unable to get clk %s\n", __func__, clk_name); goto exit; } freq_cur = clk->rate; freq_valid = freq_cur; rcu_read_lock(); opp = opp_find_freq_ceil(dev, &freq_valid); if (IS_ERR(opp)) { opp = opp_find_freq_floor(dev, &freq_valid); if (IS_ERR(opp)) { rcu_read_unlock(); pr_err("%s: no boot OPP match for %ld on vdd_%s\n", __func__, freq_cur, vdd_name); ret = -ENOENT; goto exit_ck; } } bootup_volt = opp_get_voltage(opp); rcu_read_unlock(); if (!bootup_volt) { pr_err("%s: unable to find voltage corresponding " "to the bootup OPP for vdd_%s\n", __func__, vdd_name); ret = -ENOENT; goto exit_ck; } /* * Frequency and Voltage have to be sequenced: if we move from * a lower frequency to higher frequency, raise voltage, followed by * frequency, and vice versa. we assume that the voltage at boot * is the required voltage for the frequency it was set for. * NOTE: * we can check the frequency, but there is numerous ways to set * voltage. We play the safe path and just set the voltage. */ if (freq_cur < freq_valid) { ret = voltdm_scale(voltdm, bootup_volt); if (ret) { pr_err("%s: Fail set voltage-%s(f=%ld v=%ld)on vdd%s\n", __func__, vdd_name, freq_valid, bootup_volt, vdd_name); goto exit_ck; } } /* Set freq only if there is a difference in freq */ if (freq_valid != freq_cur) { ret = clk_set_rate(clk, freq_valid); if (ret) { pr_err("%s: Fail set clk-%s(f=%ld v=%ld)on vdd%s\n", __func__, clk_name, freq_valid, bootup_volt, vdd_name); goto exit_ck; } } if (freq_cur >= freq_valid) { ret = voltdm_scale(voltdm, bootup_volt); if (ret) { pr_err("%s: Fail set voltage-%s(f=%ld v=%ld)on vdd%s\n", __func__, clk_name, freq_valid, bootup_volt, vdd_name); goto exit_ck; } } ret = 0; exit_ck: clk_put(clk); if (!ret) return 0; exit: pr_err("%s: unable to set vdd_%s\n", __func__, vdd_name); return -EINVAL; }
/** * sr_classp5_calib_work() - work which actually does the calibration * @work: pointer to the work * * calibration routine uses the following logic: * on the first trigger, we start the isr to collect sr voltages * wait for stabilization delay (reschdule self instead of sleeping) * after the delay, see if we collected any isr events * if none, we have calibrated voltage. * if there are any, we retry untill we giveup. * on retry timeout, select a voltage to use as safe voltage. */ static void sr_classp5_calib_work(struct work_struct *work) { struct sr_classp5_calib_data *work_data = container_of(work, struct sr_classp5_calib_data, work.work); unsigned long u_volt_safe = 0, u_volt_current = 0, u_volt_margin = 0; struct omap_volt_data *volt_data; struct voltagedomain *voltdm; struct omap_sr *sr; struct omap_voltdm_pmic *pmic; int idx = 0; if (!work) { pr_err("%s: ooops.. null work_data?\n", __func__); return; } /* * Handle the case where we might have just been scheduled AND * disable was called. */ if (!mutex_trylock(&omap_dvfs_lock)) { schedule_delayed_work(&work_data->work, msecs_to_jiffies(SRP5_SAMPLING_DELAY_MS * SRP5_STABLE_SAMPLES)); return; } sr = work_data->sr; voltdm = sr->voltdm; /* * In the unlikely case that we did get through when unplanned, * flag and return. */ if (unlikely(!work_data->work_active)) { pr_err("%s:%s unplanned work invocation!\n", __func__, sr->name); /* No expectation of calibration, remove qos req */ pm_qos_update_request(&work_data->qos, PM_QOS_DEFAULT_VALUE); mutex_unlock(&omap_dvfs_lock); return; } volt_data = work_data->vdata; work_data->num_calib_triggers++; /* if we are triggered first time, we need to start isr to sample */ if (work_data->num_calib_triggers == 1) { /* We could be interrupted many times, so, only for debug */ pr_debug("%s: %s: Calibration start: Voltage Nominal=%d\n", __func__, sr->name, volt_data->volt_nominal); goto start_sampling; } /* Stop isr from interrupting our measurements :) */ sr_notifier_control(sr, false); /* * Quit sampling * a) if we have oscillations * b) if we have nominal voltage as the voltage */ if (work_data->num_calib_triggers == SRP5_MAX_TRIGGERS) goto stop_sampling; /* if there are no samples captured.. SR is silent, aka stability! */ if (!work_data->num_osc_samples) { /* Did we interrupt too early? */ u_volt_current = omap_vp_get_curr_volt(voltdm); /* * If we waited enough amount of iterations, then we might be * on a corner case where voltage adjusted = Vnom! */ if (work_data->num_calib_triggers < 2 && u_volt_current >= volt_data->volt_nominal) goto start_sampling; u_volt_safe = u_volt_current; goto done_calib; } /* we have potential oscillations/first sample */ start_sampling: work_data->num_osc_samples = 0; /* Clear transdone events so that we can go on. */ do { if (!omap_vp_is_transdone(voltdm)) break; idx++; /* get some constant delay */ udelay(1); omap_vp_clear_transdone(voltdm); } while (idx < SRP5_MAX_CHECK_VPTRANS_US); if (idx >= SRP5_MAX_CHECK_VPTRANS_US) pr_warning("%s: timed out waiting for transdone clear!!\n", __func__); /* Clear pending events */ sr_notifier_control(sr, false); /* trigger sampling */ sr_notifier_control(sr, true); schedule_delayed_work(&work_data->work, msecs_to_jiffies(SRP5_SAMPLING_DELAY_MS * SRP5_STABLE_SAMPLES)); mutex_unlock(&omap_dvfs_lock); return; stop_sampling: /* * We are here for Oscillations due to two scenarios: * a) SR is attempting to adjust voltage lower than VLIMITO * which VP will ignore, but SR will re-attempt * b) actual oscillations * NOTE: For debugging, enable debug to see the samples. */ pr_warning("%s: %s Stop sampling: Voltage Nominal=%d samples=%d\n", __func__, sr->name, volt_data->volt_nominal, work_data->num_osc_samples); /* pick up current voltage */ u_volt_current = omap_vp_get_curr_volt(voltdm); /* Just in case we got more interrupts than our tiny buffer */ if (work_data->num_osc_samples > SRP5_STABLE_SAMPLES) idx = SRP5_STABLE_SAMPLES; else idx = work_data->num_osc_samples; /* Index at 0 */ idx -= 1; u_volt_safe = u_volt_current; /* Grab the max of the samples as the stable voltage */ for (; idx >= 0; idx--) { pr_debug("%s: osc_v[%d]=%ld, safe_v=%ld\n", __func__, idx, work_data->u_volt_samples[idx], u_volt_safe); if (work_data->u_volt_samples[idx] > u_volt_safe) u_volt_safe = work_data->u_volt_samples[idx]; } /* Fall through to close up common stuff */ done_calib: sr_classp5_stop_hw_loop(sr); pmic = voltdm->pmic; /* Add Per OPP margin if needed */ if (volt_data->volt_margin) u_volt_margin += sr_classp5_adjust_margin(pmic, volt_data->volt_margin, u_volt_current); u_volt_safe += u_volt_margin; /* just warn, dont clamp down on voltage */ if (u_volt_margin && u_volt_safe > volt_data->volt_nominal) { pr_warning("%s: %s Vsafe %ld > Vnom %d. %ld[%d] margin on" "vnom %d curr_v=%ld\n", __func__, sr->name, u_volt_safe, volt_data->volt_nominal, u_volt_margin, volt_data->volt_margin, volt_data->volt_nominal, u_volt_current); } volt_data->volt_calibrated = u_volt_safe; /* Setup my dynamic voltage for the next calibration for this opp */ volt_data->volt_dynamic_nominal = omap_get_dyn_nominal(volt_data); /* * if the voltage we decided as safe is not the current voltage, * switch */ if (volt_data->volt_calibrated != u_volt_current) { pr_debug("%s: %s reconfiguring to voltage %d\n", __func__, sr->name, volt_data->volt_calibrated); voltdm_scale(voltdm, volt_data); } pr_info("%s: %s: Calibration complete: Voltage Nominal=%d " "Calib=%d Dyn=%d OPP_margin=%d total_margin=%ld\n", __func__, sr->name, volt_data->volt_nominal, volt_data->volt_calibrated, volt_data->volt_dynamic_nominal, volt_data->volt_margin, u_volt_margin); work_data->work_active = false; /* Calibration done, Remove qos req */ pm_qos_update_request(&work_data->qos, PM_QOS_DEFAULT_VALUE); mutex_unlock(&omap_dvfs_lock); }