/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_dra7xx_set
* @BRIEF change OPP of a given voltage domain.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] vdd_id: voltage domain ID
* @param[in] opp_id: ID of the OPP to be set
* @DESCRIPTION change OPP of a given voltage domain.
*//*------------------------------------------------------------------------ */
int opp_dra7xx_set(voltdm_dra7xx_id vdd_id, opp_dra7xx_id opp_id)
{
CHECK_ARG_LESS_THAN(vdd_id, VDD_DRA7XX_ID_MAX, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(opp_id, OPP_DRA7XX_ID_MAX, OMAPCONF_ERR_ARG);
opp_dra7xx_init();
printf("Sorry, not yet implemented...\n");
return OMAPCONF_ERR_NOT_AVAILABLE;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp54xx_set
* @BRIEF change OPP of a given voltage domain.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] vdd_id: voltage domain ID
* @param[in] opp_id: ID of the OPP to be set
* @DESCRIPTION change OPP of a given voltage domain.
*//*------------------------------------------------------------------------ */
int opp54xx_set(voltdm54xx_id vdd_id, opp54xx_id opp_id)
{
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(opp_id, OPP54XX_ID_MAX, OMAPCONF_ERR_ARG);
opp54xx_init();
printf("Sorry, not yet implemented...\n");
return OMAPCONF_ERR_NOT_AVAILABLE;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION sr44xx_golden_settings_get
* @BRIEF return SR module golden settings.
* @RETURNS SR module name on success
* "FIXME" string in case of error
* @param[in] sr_id: SR module ID
* opp_id: OPP ID
* @DESCRIPTION return SR module golden settings, for a given chip,
* module and OPP.
*//*------------------------------------------------------------------------ */
const sr_audit_settings *sr44xx_golden_settings_get(omap4_sr_module_id sr_id,
opp44xx_id opp_id)
{
omap_chip chip_id;
CHECK_ARG_LESS_THAN(sr_id, OMAP4_SR_ID_MAX, NULL);
CHECK_ARG_LESS_THAN(opp_id, OPP44XX_ID_MAX, NULL);
chip_id = cpu_get();
dprintf("%s(): sr_id=%d opp_id=%d chip_id=%d\n", __func__,
sr_id, opp_id, chip_id);
return sr44xx_golden_settings[chip_id][sr_id][opp_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION sr54xx_export
* @BRIEF export module register content to file, in XML format.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_REG_ACCESS
* @param[in,out] fp: output file stream (opened for write operations)
* @param[in] id: SR module ID
* @DESCRIPTION export module register content to file, in XML format.
*//*------------------------------------------------------------------------ */
int sr54xx_export(FILE *fp, sr54xx_mod_id id)
{
reg **mod;
unsigned int i;
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_NULL_ARG(fp, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(id, SR54XX_MODS_COUNT, OMAPCONF_ERR_ARG);
if (!sr54xx_is_enabled(id)) {
printf("%s export: module not running, skipping "
"registers export.\n", sr54xx_mod_name_get(id));
return 0;
}
mod = sr54xx_mods[id];
fprintf(fp, " <submodule id=\"%u\" name=\"%s\">\n",
id, sr54xx_mod_name_get(id));
for (i = 0; i < OMAP5430_SMARTREFLEX_CORE_MOD_REGCOUNT; i++)
fprintf(fp, " <register id=\"%u\" name=\"%s\" "
"addr=\"0x%08X\" data=\"0x%08X\" />\n", i,
(mod[i])->name, (mod[i])->addr, reg_read(mod[i]));
fprintf(fp, " </submodule>\n");
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION smps_step_get
* @BRIEF return SMPS regulator voltage step (in microvolts)
* @RETURNS > 0 voltage step in microvolts
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] smps_id: valid SMPS ID
* @DESCRIPTION return SMPS regulator voltage step (in microvolts)
*//*------------------------------------------------------------------------ */
long smps_step_get(pmic_smps_id smps_id)
{
long step;
CHECK_ARG_LESS_THAN(smps_id, PMIC_SMPS_ID_MAX, (long) OMAPCONF_ERR_ARG);
if (!pmic_detection_done())
pmic_detect();
switch (pmic_chip[smps_id]) {
case PMIC_TWL6030:
case PMIC_TWL6032:
case PMIC_TWL6034:
case PMIC_TWL6035:
step = twl603x_smps_step_get();
break;
case PMIC_TPS62361:
step = tps62361_smps_step_get();
break;
case PMIC_TPS659038:
step = tps659038_smps_step_get();
break;
case PMIC_TPS65217A:
case PMIC_TPS65217B:
case PMIC_TPS65217C:
case PMIC_TPS65217D:
step = tps65217x_smps_step_get();
default:
step = (long) OMAPCONF_ERR_NOT_AVAILABLE;
}
dprintf("%s(%s): step=%lduV\n", __func__, smps_name_get(smps_id), step);
return step;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_voltage_set
* @BRIEF set voltage of given voltage domain
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_INTERNAL
* @param[in] id: valid voltage domain ID
* @DESCRIPTION set voltage of given voltage domain
*//*------------------------------------------------------------------------ */
int voltdm54xx_voltage_set(voltdm54xx_id id, unsigned long uv)
{
CHECK_CPU(54xx, (double) OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, (double) OMAPCONF_ERR_ARG);
/* Retrieve domain state */
switch (id) {
case VDD54XX_WKUP:
return OMAPCONF_ERR_NOT_AVAILABLE;
case VDD54XX_MPU:
return smps_voltage_set(PMIC_SMPS_MPU, uv);
break;
case VDD54XX_MM:
return smps_voltage_set(PMIC_SMPS_MM, uv);
break;
case VDD54XX_CORE:
return smps_voltage_set(PMIC_SMPS_CORE, uv);
break;
default:
return OMAPCONF_ERR_ARG;
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION smps_name_get
* @BRIEF return PMIC SMPS name as a string
* @RETURNS PMIC SMPS name as a string in case of success
* NULL in case of error
* @param[in] smps_id: valid SMPS ID
* @DESCRIPTION return PMIC SMPS name as a string
*//*------------------------------------------------------------------------ */
const char *smps_name_get(pmic_smps_id smps_id)
{
CHECK_ARG_LESS_THAN(smps_id, PMIC_SMPS_ID_MAX, NULL);
switch (cpu_get()) {
case OMAP_4430:
case OMAP_4460:
case OMAP_4470:
return smps44xx_names[smps_id];
break;
case OMAP_5430:
case OMAP_5432:
return smps54xx_names[smps_id];
break;
case DRA_75X:
return smps_dra7xx_names[smps_id];
break;
case AM_3352:
case AM_3354:
case AM_3356:
case AM_3357:
case AM_3358:
case AM_3359:
return smps_am335x_names[smps_id];
break;
default:
return smps44xx_names[smps_id];
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_por_nominal_voltage_get
* @BRIEF return the Plan of Record (POR) nominal voltage
* of a given voltage domain for a given OPP.
* @RETURNS supply voltage in case of success (>= 0.0)
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* @param[in] id: valid voltage domain ID
* @DESCRIPTION return the Plan of Record (POR) nominal voltage
* of a given voltage domain for a given OPP.
*//*------------------------------------------------------------------------ */
double voltdm54xx_por_nominal_voltage_get(voltdm54xx_id id, opp54xx_id opp_id)
{
double volt;
CHECK_CPU(54xx, (double) OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, (double) OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, (double) OMAPCONF_ERR_ARG);
volt = voltdm54xx_por_nominal_voltages_table_es1[id][opp_id];
dprintf("%s(%s): %s POR nominal volt=%lfV\n", __func__,
opp54xx_name_get(opp_id),
voltdm54xx_name_get(id), volt);
return volt;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm_am335x_voltage_get
* @BRIEF find the current supply voltage of a domain
* @RETURNS supply voltage in case of success (>= 0.0)
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] id: valid voltage domain ID
* @DESCRIPTION find the current supply voltage of a domain,
* taking care of the voltage domain state
* (ON/ON_LP/RET/OFF)
* NB: use PRCM VP VOLTAGE register to retrieve ON voltage.
* Hence SR/VP/VC have to be at least initialized
* (SR could be disabled)
*//*------------------------------------------------------------------------ */
double voltdm_am335x_voltage_get(voltdm_am335x_id id)
{
double volt;
CHECK_ARG_LESS_THAN(id, VDD_AM335X_ID_MAX, (double) OMAPCONF_ERR_ARG);
switch (id) {
case VDD_AM335X_CORE:
volt = smps_voltage_get(PMIC_SMPS_CORE);
break;
case VDD_AM335X_MPU:
volt = smps_voltage_get(PMIC_SMPS_MPU);
break;
case VDD_AM335X_RTC:
volt = smps_voltage_get(PMIC_SMPS_ID_MAX);
break;
default:
return (double) OMAPCONF_ERR_ARG;
}
dprintf("%s(%s): volt=%lfV\n", __func__, voltdm_am335x_name_get(id), volt);
return volt;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_nominal_voltage_get
* @BRIEF return the nominal voltage of a given voltage domain
* @RETURNS supply voltage in case of success (>= 0.0)
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] id: valid voltage domain ID
* @DESCRIPTION return the nominal voltage of a given voltage domain.
*//*------------------------------------------------------------------------ */
double voltdm54xx_nominal_voltage_get(voltdm54xx_id id)
{
int ret;
double volt;
vc54xx_registers vc_regs;
unsigned char cmd_on, cmd_onlp, cmd_ret, cmd_off;
CHECK_CPU(54xx, (double) OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, (double) OMAPCONF_ERR_ARG);
ret = vc54xx_registers_get(&vc_regs);
if (ret != 0)
return (double) ret;
ret = vc54xx_cmd_values_get(id, &vc_regs,
&cmd_on, &cmd_onlp, &cmd_ret, &cmd_off);
if (ret != 0)
return (double) ret;
volt = smps_vsel2volt(vdd_id2smps_id(id), cmd_on);
dprintf("%s(%s): nominal volt=%lfV\n", __func__,
voltdm54xx_name_get(id), volt);
return volt;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_id2s
* @BRIEF convert voltage domain ID into voltage domain name, as
* defined in voltdm.h.
* @RETURNS Voltage Domain name, as defined in voltdm.h.
* NULL in case of invalid voltage domain ID
* @param[in] id: voltage domain ID
* @DESCRIPTION convert voltage domain ID to voltage domain name.
*//*------------------------------------------------------------------------ */
const char *voltdm54xx_id2s(voltdm54xx_id id)
{
const char *s;
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, NULL);
switch (id) {
case VDD54XX_WKUP:
s = VDD_WKUP;
break;
case VDD54XX_MPU:
s = VDD_MPU;
break;
case VDD54XX_MM:
s = VDD_MM;
break;
case VDD54XX_CORE:
s = VDD_CORE;
break;
default:
s = NULL;
}
dprintf("%s(%d) = %s\n", __func__, id, s);
return s;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_voltage_get
* @BRIEF find the current supply voltage of a domain
* @RETURNS supply voltage in case of success (>= 0.0)
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] id: valid voltage domain ID
* @DESCRIPTION find the current supply voltage of a domain,
* taking care of the voltage domain state
* (ON/ON_LP/RET/OFF)
* NB: use PRCM VP VOLTAGE register to retrieve ON voltage.
* Hence SR/VP/VC have to be at least initialized
* (SR could be disabled)
*//*------------------------------------------------------------------------ */
double voltdm54xx_voltage_get(voltdm54xx_id id)
{
double volt;
CHECK_CPU(54xx, (double) OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, (double) OMAPCONF_ERR_ARG);
switch (id) {
case VDD54XX_WKUP:
return (double) OMAPCONF_ERR_NOT_AVAILABLE;
case VDD54XX_MPU:
volt = smps_voltage_get(PMIC_SMPS_MPU);
break;
case VDD54XX_MM:
volt = smps_voltage_get(PMIC_SMPS_MM);
break;
case VDD54XX_CORE:
volt = smps_voltage_get(PMIC_SMPS_CORE);
break;
default:
return (double) OMAPCONF_ERR_ARG;
}
dprintf("%s(%s): volt=%lfV\n", __func__, voltdm54xx_name_get(id), volt);
return volt;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION prm54xx_import
* @BRIEF import OMAP PRM registers from XML file
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_UNEXPECTED
* @param[in,out] fp: XML import file descriptor
* @param[in] id: CM module ID
* @DESCRIPTION import OMAP PRM registers from XML file,
* generated with lib54xx_export().
*//*------------------------------------------------------------------------ */
int prm54xx_import(FILE *fp, prm54xx_mod_id id)
{
reg **mod;
char line[256], sline[256];
char *xml_entry;
int ret, i, n;
CHECK_NULL_ARG(fp, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(id, PRM54XX_MODS_COUNT, OMAPCONF_ERR_ARG);
if (cpu_revision_get() == REV_ES1_0)
mod = prm54xxes1_mods[id];
else
mod = prm54xx_mods[id];
rewind(fp);
/* Search for the PRM module tag */
sprintf(sline, "<submodule id=\"%u\" name=\"%s\">",
id, prm54xx_mod_name_get(id));
while (fgets(line, sizeof(line), fp) != NULL) {
if (strstr(line, sline) == NULL)
continue;
/* Import register content */
for (i = 0; mod[i] != NULL; i++) {
if (fgets(line, sizeof(line), fp) == NULL)
return OMAPCONF_ERR_UNEXPECTED;
line[strlen(line) - 1] = '\0'; /* remove ending '\n' */
xml_entry = strstr(line, "<"); /* remove spaces */
dprintf("%s(%u (%s)): xml_entry=%s\n", __func__, id,
prm54xx_mod_name_get(id), xml_entry);
/* Check register id is correct */
ret = sscanf(xml_entry, "<register id=\"%u\" %s",
&n, sline);
if (ret != 2) {
dprintf("%s(%u (%s)): could not get id\n",
__func__, id, prm54xx_mod_name_get(id));
return OMAPCONF_ERR_UNEXPECTED;
}
if (n != i) {
dprintf(
"%s(%u (%s)): register id does not match! (n=%u, i=%u)\n",
__func__, id,
prm54xx_mod_name_get(id), n, i);
return OMAPCONF_ERR_UNEXPECTED;
}
ret = reg_xml_import(mod[i], xml_entry);
if (ret != 0)
return ret;
}
dprintf("%s(%u (%s)): all registers imported.\n", __func__, id,
prm54xx_mod_name_get(id));
break;
}
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION lib54xx_voltage_set
* @BRIEF change voltage of a given voltage domain, switching
* CPUFreq governor to "userspace" & disabling smart-reflex
* @RETURNS 0 on success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_INTERNAL
* @param[in] vdd_id: voltage domain ID
* @param[in] volt: new supply voltage (in volt)
* @DESCRIPTION change voltage of a given voltage domain, switching
* CPUFreq governor to "userspace" & disabling smart-reflex
*//*------------------------------------------------------------------------ */
int lib54xx_voltage_set(voltdm54xx_id vdd_id, double volt)
{
int ret, ret_cpufreq;
char prev_gov[CPUFREQ_GOV_MAX_NAME_LENGTH];
sr54xx_mod_id sr_id;
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, OMAPCONF_ERR_ARG);
/*
* Switch governor to 'userspace' otherwise voltage change will be
* overriden in case of OPP change.
*/
printf("Warning: switching CPUFreq governor to 'userspace', otherwise "
"voltage change will be overriden...\n");
ret_cpufreq = cpufreq_scaling_governor_set("userspace", prev_gov);
if (ret_cpufreq < 0)
printf("Warning: failed to switch governor. Voltage will be "
"overriden in case of OPP change.\n");
else
printf("CPUFreq governor switched to 'userspace'.\n");
/*
* Disable Smart-Reflex (if running) otherwise voltage change will be
* overriden.
*/
sr_id = sr54xx_vddid2srid(vdd_id);
if (sr54xx_avs_is_enabled(sr_id)) {
printf("Warning: %s Smart-Reflex AVS is enabled. "
"Disabling it...\n", voltdm54xx_name_get(vdd_id));
ret = sr54xx_avs_enable(sr_id, 0);
if (ret == 0)
printf("Smartreflex disabled.\n\n");
else
printf("Warning: Could not disable Smart-Reflex AVS. "
"Voltage may be overriden.\n\n");
} else {
printf("Smartreflex disabled.\n\n");
}
ret = voltdm54xx_voltage_set(vdd_id,
(unsigned long) (volt * 1000000));
if (ret != 0) {
fprintf(stderr, "Oups, could not change %s voltage to "
"%.3lfV ... (%d)\n\n",
voltdm54xx_name_get(vdd_id), volt, ret);
} else {
printf("%s supply voltage set to %1.3lfV (vsel = 0x%02X).\n\n",
voltdm54xx_name_get(vdd_id), volt,
smps_uvolt2vsel(vdd_id2smps_id(vdd_id),
(unsigned long) (volt * 1000000)));
printf("Warning:\n"
" - Do not re-enable %s smartreflex or new voltage "
"will be overriden.\n"
" - Do not change OPP (or use CPUFREQ) or new voltage"
" will be overriden.\n\n", voltdm54xx_name_get(vdd_id));
}
return ret;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION pwrdm54xx_has_pwrstst_reg
* @BRIEF return 1 if power domain features PM_xyz_PWRSTST,
* 0 otherwise.
* @RETURNS 1 if power domain features PM_xyz_PWRSTST register
* 0 otherwise
* @param[in] id: valid power domain ID
* @DESCRIPTION return 1 if power domain features PM_xyz_PWRSTST,
* 0 otherwise.
*//*------------------------------------------------------------------------ */
unsigned int pwrdm54xx_has_pwrstst_reg(pwrdm54xx_id id)
{
if (!cpu_is_omap54xx())
return 0;
CHECK_ARG_LESS_THAN(id, PWRDM54XX_ID_MAX, 0);
return (pwrdm54xx_pwrstst_table[id] != NULL);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_dra7xx_get
* @BRIEF return the current voltage domain OPP name.
* @RETURNS current voltage domain OPP name (as defined in opp.h)
* NULL pointer in case of error or not found
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION return the current voltage domain OPP name. Search it by
* voltage first, then if failed search it by rates.
*//*------------------------------------------------------------------------ */
const char *opp_dra7xx_get(voltdm_dra7xx_id vdd_id)
{
CHECK_ARG_LESS_THAN(vdd_id, VDD_DRA7XX_ID_MAX, NULL);
opp_dra7xx_init();
return opp_get(voltdm_dra7xx_id2s(vdd_id), 1);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_dra7xx_list_get
* @BRIEF return the list of OPP of a given voltage domain
* @RETURNS list of OPP of a given voltage domain in case of success
* NULL in case of error
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION return the list of OPP of a given voltage domain
*//*------------------------------------------------------------------------ */
const genlist *opp_dra7xx_list_get(voltdm_dra7xx_id vdd_id)
{
CHECK_ARG_LESS_THAN(vdd_id, VDD_DRA7XX_ID_MAX, NULL);
opp_dra7xx_init();
return opp_dra7xx_list_table[vdd_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION pwrdm54xx_pwrstst_reg_get
* @BRIEF return pointer to power domain PM_xyz_PWRSTST register.
* @RETURNS pointer to power domain PM_xyz_PWRSTST register
* NULL in case of error
* @param[in] id: valid power domain ID
* @DESCRIPTION return pointer to power domain PM_xyz_PWRSTST register.
*//*------------------------------------------------------------------------ */
reg *pwrdm54xx_pwrstst_reg_get(pwrdm54xx_id id)
{
if (!cpu_is_omap54xx())
return NULL;
CHECK_ARG_LESS_THAN(id, PWRDM54XX_ID_MAX, NULL);
return pwrdm54xx_pwrstst_table[id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION cm54xx_export
* @BRIEF export module register content to file, in XML format.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_INTERNAL
* @param[in,out] fp: output file stream (opened for write operations)
* @param[in] id: CM module ID
* @DESCRIPTION export module register content to file, in XML format.
*//*------------------------------------------------------------------------ */
int cm54xx_export(FILE *fp, cm54xx_mod_id id)
{
reg **mod;
unsigned int i;
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_NULL_ARG(fp, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(id, CM54XX_MODS_COUNT, OMAPCONF_ERR_ARG);
if ((cpu_revision_get() != REV_ES1_0) &&
(id == CM54XX_L4PER_CM_CORE)) {
fprintf(stderr, "omapconf: %s(): L4_PER does not exist!!!\n",
__func__);
return OMAPCONF_ERR_ARG;
}
dprintf("%s(): exporting CM %s (%u) module ...\n", __func__,
cm54xx_mod_name_get(id), id);
if (cpu_revision_get() == REV_ES1_0)
mod = cm54xxes1_mods[id];
else
mod = cm54xx_mods[id];
if (mod == NULL) {
fprintf(stderr, "omapconf: %s(): mod == NULL!!!\n", __func__);
return OMAPCONF_ERR_INTERNAL;
}
if ((id == CM54XX_INSTR_CM_CORE) &&
!cm54xx_is_profiling_running(CM54XX_INSTR_CM_CORE)) {
dprintf(
"%s(%s): CM module is not accessible, don't export registers\n",
__func__, cm54xx_mod_name_get(id));
return 0;
} else if ((id == CM54XX_INSTR_CM_CORE_AON) &&
!cm54xx_is_profiling_running(CM54XX_INSTR_CM_CORE_AON)) {
dprintf(
"%s(%s): CM module is not accessible, don't export registers\n",
__func__, cm54xx_mod_name_get(id));
return 0;
}
fprintf(fp, " <submodule id=\"%u\" name=\"%s\">\n",
id, cm54xx_mod_name_get(id));
for (i = 0; mod[i] != NULL; i++)
fprintf(fp,
" <register id=\"%u\" name=\"%s\" addr=\"0x%08X\" data=\"0x%08X\" />\n",
i, reg_name_get(mod[i]), reg_addr_get(mod[i]),
reg_read(mod[i]));
fprintf(fp, " </submodule>\n");
fflush(fp);
dprintf("%s(): CM %s (%u) module exported.\n", __func__,
cm54xx_mod_name_get(id), id);
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp54xx_list_get
* @BRIEF return the list of OPP of a given voltage domain
* @RETURNS list of OPP of a given voltage domain in case of success
* NULL in case of error
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION return the list of OPP of a given voltage domain
*//*------------------------------------------------------------------------ */
const genlist *opp54xx_list_get(voltdm54xx_id vdd_id)
{
CHECK_CPU(54xx, NULL);
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, NULL);
opp54xx_init();
return opp54xx_list_table_es1[vdd_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION mod44xx_get_por_clk_speed
* @BRIEF retrieve omap module's functional POR clock speed
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* @param[in] module_id: omap module ID
* @param[in] opp: the OPP ID
* @param[in,out] por_clk_speed: returned omap functional clock speed
* (in MHz)
* @DESCRIPTION retrieve omap module's functional POR clock speed
*//*------------------------------------------------------------------------ */
int mod44xx_get_por_clk_speed(mod44xx_id module_id,
unsigned short opp, double *por_clk_speed)
{
*por_clk_speed = 0.0;
#ifdef MODULE44XX_DEBUG
char name[MOD44XX_MAX_NAME_LENGTH];
#endif
CHECK_CPU(44xx, OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(module_id, OMAP4_MODULE_ID_MAX, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(opp, OPP44XX_ID_MAX, OMAPCONF_ERR_ARG);
*por_clk_speed = (double) mod44xx_info_table[module_id].por_speed[opp];
dprintf("%s(): module %s POR speed is %lf\n", __func__,
mod44xx_get_name(module_id, name),
*por_clk_speed);
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION pmic_is_tps659038
* @BRIEF return 1 if PMIC chip of a given rail is TPS659038
* @RETURNS 1 if PMIC chip is TPS659038
* 0 otherwise
* @param[in] smps_id: valid SMPS ID
* @DESCRIPTION return 1 if PMIC chip of a given rail is TPS659038
*//*------------------------------------------------------------------------ */
unsigned short pmic_is_tps659038(pmic_smps_id smps_id)
{
CHECK_ARG_LESS_THAN(smps_id, PMIC_SMPS_ID_MAX, 0);
if (!pmic_detection_done())
pmic_detect();
return pmic_chip[smps_id] == PMIC_TPS659038;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION pmic_chip_get
* @BRIEF return the PMIC chip ID of a given power rail.
* @RETURNS PMIC chip ID of a given power rail.
* PMIC_ID_MAX in case of error.
* @param[in] smps_id: valid SMPS ID
* @DESCRIPTION return the PMIC chip ID of a given power rail.
*//*------------------------------------------------------------------------ */
pmic_id pmic_chip_get(pmic_smps_id smps_id)
{
CHECK_ARG_LESS_THAN(smps_id, PMIC_SMPS_ID_MAX, PMIC_ID_MAX);
if (!pmic_detection_done())
pmic_detect();
return pmic_chip[smps_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp54xx_get
* @BRIEF return the current voltage domain OPP name.
* @RETURNS current voltage domain OPP name (as defined in opp.h)
* NULL pointer in case of error or not found
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION return the current voltage domain OPP name. Search it by
* voltage first, then if failed search it by rates.
*//*------------------------------------------------------------------------ */
const char *opp54xx_get(voltdm54xx_id vdd_id)
{
CHECK_CPU(54xx, NULL);
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, NULL);
opp54xx_init();
return opp_get(voltdm54xx_id2s(vdd_id), 1);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION pmic_eprom_revision_get
* @BRIEF return the PMIC EPROM revision of a given power rail.
* @RETURNS > 0.0 PMIC EPROM revision of a given power rail.
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] smps_id: valid SMPS ID
* @DESCRIPTION return the PMIC EPROM revision of a given power rail.
*//*------------------------------------------------------------------------ */
double pmic_eprom_revision_get(pmic_smps_id smps_id)
{
CHECK_ARG_LESS_THAN(smps_id, PMIC_SMPS_ID_MAX,
(double) OMAPCONF_ERR_ARG);
if (!pmic_detection_done())
pmic_detect();
return pmic_eprom_revision[smps_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm2sensor_id
* @BRIEF convert voltage domain ID to sensor domain ID
* @RETURNS valid sensor ID in case of success
* TEMP54XX_ID_MAX in case of voltage domain ID
* @param[in] vdd_id: valid voltage domain ID
* @DESCRIPTION convert voltage domain ID to sensor domain ID.
*//*------------------------------------------------------------------------ */
temp54xx_sensor_id voltdm2sensor_id(voltdm54xx_id vdd_id)
{
static const temp54xx_sensor_id voltdm2sensor_map[VDD54XX_ID_MAX] = {
TEMP54XX_ID_MAX,
TEMP54XX_MPU,
TEMP54XX_GPU,
TEMP54XX_CORE};
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, TEMP54XX_ID_MAX);
return voltdm2sensor_map[vdd_id];
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION sr54xx_avs_enable
* @BRIEF control SR AVS via sysfs entry.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_UNEXPECTED
* @param[in] id: SR ID
* @param[in] enable: =1 to enable, =0 to disable SR AVS
* @DESCRIPTION control SR AVS via sysfs entry.
*//*------------------------------------------------------------------------ */
int sr54xx_avs_enable(sr54xx_mod_id id, unsigned short enable)
{
int ret;
FILE *fp;
static const char filename[SR54XX_MODS_COUNT][72] = {
"/sys/kernel/debug/smartreflex/smartreflex_mpu/autocomp",
"/sys/kernel/debug/smartreflex/smartreflex_mm/autocomp",
"/sys/kernel/debug/smartreflex/smartreflex_core/autocomp"};
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_ARG_LESS_THAN(id, SR54XX_MODS_COUNT, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(enable, 2, OMAPCONF_ERR_ARG);
/* Open file */
fp = fopen(filename[id], "w");
if (fp == NULL) {
fprintf(stderr,
"omapconf (%s()): could not open %s! Is debugfs mounted???\n\n",
__func__, filename[id]);
return OMAPCONF_ERR_NOT_AVAILABLE;
}
if (enable)
ret = fwrite("1", sizeof(char), 1, fp);
else
ret = fwrite("0", sizeof(char), 1, fp);
if (ret != 1) {
fprintf(stderr, "omapconf (%s()): could not write into %s!\n\n",
__func__, filename[id]);
ret = OMAPCONF_ERR_UNEXPECTED;
} else {
ret = 0;
}
/* Close file */
if (fp != NULL)
fclose(fp);
return ret;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm54xx_opp_get
* @BRIEF find the current voltage domain OPP
* @RETURNS valid OPP ID in case of success
* OPP54XX_ID_MAX in case of error
* @param[in] id: voltage domain ID
* @DESCRIPTION find the current voltage domain OPP
*//*------------------------------------------------------------------------ */
opp54xx_id voltdm54xx_opp_get(voltdm54xx_id id)
{
opp54xx_id opp_id;
double volt = 0.0, volt_por = 0.0;
CHECK_CPU(54xx, OPP54XX_ID_MAX);
CHECK_ARG_LESS_THAN(id, VDD54XX_ID_MAX, OPP54XX_ID_MAX);
if (id == VDD54XX_WKUP) {
/* Only 1 OPP for WKUP voltage domain */
opp_id = OPP54XX_NOM;
} else {
/*
* In VDD_MM there are 3 independent modules (GPU, IVA, DSP)
* that may be running at different clock rates.
* Furthermore, these modules may or may not be running, so
* module's clock rate may not be relevant.
* Use nominal voltage instead.
*/
volt = voltdm54xx_nominal_voltage_get(id);
if (volt < 0.0)
return OPP54XX_ID_MAX;
dprintf("%s(%s): nominal voltage is %lfV\n", __func__,
voltdm54xx_name_get(id), volt);
for (opp_id = OPP54XX_DPLL_CASC; opp_id < OPP54XX_ID_MAX;
opp_id++) {
volt_por = voltdm54xx_por_nominal_voltage_get(
id, opp_id);
if (volt_por < 0.0)
return OPP54XX_ID_MAX;
dprintf("%s(%s): POR nominal voltage for %s is %lfV\n",
__func__, voltdm54xx_name_get(id),
opp54xx_name_get(opp_id), volt_por);
if (volt == volt_por)
break;
}
}
#ifdef VOLTDM54XX_DEBUG
if (opp_id != OPP54XX_ID_MAX) {
dprintf("%s(%s): OPP found: %s\n", __func__,
voltdm54xx_name_get(id), opp54xx_name_get(opp_id));
} else {
dprintf("%s(%s): OPP not found!\n", __func__,
voltdm54xx_name_get(id));
}
#endif
return opp_id;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_dra7xx_count_get
* @BRIEF return the number of OPP(s) of a given voltage domain
* @RETURNS number of OPP(s) (> 0) in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION return the number of OPP(s) of a given voltage domain
*//*------------------------------------------------------------------------ */
int opp_dra7xx_count_get(voltdm_dra7xx_id vdd_id)
{
int count;
CHECK_ARG_LESS_THAN(vdd_id, VDD_DRA7XX_ID_MAX, OMAPCONF_ERR_ARG);
opp_dra7xx_init();
count = genlist_getcount(opp_dra7xx_list_table[vdd_id]);
dprintf("%s(%d) = %d\n", __func__, vdd_id, count);
return count;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION sr54xx_vddid2srid
* @BRIEF convert a VDD ID into corresponding SR ID.
* @RETURNS corresponding SR ID
* SR54XX_MODS_COUNT in case of error.
* @param[in] vdd_id: voltage domain ID
* @DESCRIPTION convert a VDD ID into corresponding SR ID.
*//*------------------------------------------------------------------------ */
sr54xx_mod_id sr54xx_vddid2srid(voltdm54xx_id vdd_id)
{
CHECK_ARG_LESS_THAN(vdd_id, VDD54XX_ID_MAX, SR54XX_MODS_COUNT);
static const sr54xx_mod_id vddid2srid_table[VDD54XX_ID_MAX] = {
SR54XX_MODS_COUNT,
SR54XX_SMARTREFLEX_MPU,
SR54XX_SMARTREFLEX_MM,
SR54XX_SMARTREFLEX_CORE};
return vddid2srid_table[vdd_id];
}
