/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_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] voltdm: voltage domain name (as defined in voltdm.h)
* @param[in] opp: name of OPP to be set (as defined in opp.h)
* @DESCRIPTION change OPP of a given voltage domain.
*//*------------------------------------------------------------------------ */
int opp_set(const char *voltdm, const char *opp)
{
int vdd_id, opp_id;
CHECK_NULL_ARG(voltdm, OMAPCONF_ERR_ARG);
CHECK_NULL_ARG(opp, OMAPCONF_ERR_ARG);
opp_init();
vdd_id = voltdm_s2id(voltdm);
if (vdd_id < 0)
return OMAPCONF_ERR_ARG;
opp_id = opp_s2id(opp);
if (opp_id < 0)
return OMAPCONF_ERR_ARG;
if (cpu_is_omap44xx()) {
return opp44xx_set((voltdm44xx_id) vdd_id, (opp44xx_id) opp_id);
} else if (cpu_is_omap54xx()) {
return opp54xx_set((voltdm54xx_id) vdd_id, (opp54xx_id) opp_id);
} else {
fprintf(stderr,
"omapconf: %s(): cpu not supported!!!\n", __func__);
return OMAPCONF_ERR_CPU;
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION main_i2c_read
* @BRIEF read given data from given address of given device of
* given I2C bus
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_REG_ACCESS
* @param[in] argc: shell input argument number
* argc must be 5
* @param[in] argv: shell input argument(s)
* argv[2] = i2cbus: I2C bus number
* argv[3] = address: I2C device address
* argv[4] = daddress: I2C device register address
* @DESCRIPTION read given data from given address of given device of
* given I2C bus
*//*------------------------------------------------------------------------ */
static int main_i2c_read(int argc, char *argv[])
{
unsigned int i2cbus, chip_address, data_address;
unsigned int data;
int ret;
CHECK_NULL_ARG(argv, OMAPCONF_ERR_ARG);
/* Retrieve arguments */
if (argc != 5)
goto main_i2c_read_err;
ret = sscanf(argv[2], "%u", &i2cbus);
if (ret != 1)
goto main_i2c_read_err;
ret = sscanf(argv[3], "0x%x", &chip_address);
if (ret != 1)
goto main_i2c_read_err;
ret = sscanf(argv[4], "0x%x", &data_address);
if (ret != 1)
goto main_i2c_read_err;
ret = i2cget(i2cbus, chip_address, data_address, &data);
if (ret == 0)
printf("0x%02x\n", data);
return ret;
main_i2c_read_err:
printf(
"Usage: omapconf i2c read 'i2cbus' 0x'chip-address' 0x'data-address'\n");
printf(" 'i2cbus' is decimal value.\n");
printf(" 'chip-address' & 'data-address' are hexadecimal values.\n");
printf(" Warning: prefix '0x' is mandatory.\n");
return OMAPCONF_ERR_ARG;
}
/**
* @brief Reads complete content of a file referenced by the descriptor 'fd' into the memory.
* Caller is responsible for deallocation of the memory block returned through the output argument 'out'.
* Returns SR_ERR_OK in case of success, error code otherwise.
*/
static int
srcfg_read_file_content(int fd, char **out)
{
int rc = SR_ERR_OK;
size_t size = EXPECTED_MAX_INPUT_FILE_SIZE;
unsigned cur = 0;
ssize_t n = 0;
char *buffer = NULL;
CHECK_NULL_ARG(out);
buffer = malloc(size);
CHECK_NULL_NOMEM_GOTO(buffer, rc, fail);
do {
if (size == cur + 1) {
size <<= 1;
char *new_buffer = realloc(buffer, size);
CHECK_NULL_NOMEM_GOTO(new_buffer, rc, fail);
buffer = new_buffer;
}
n = read(fd, buffer + cur, size - cur - 1);
CHECK_NOT_MINUS1_LOG_GOTO(n, rc, SR_ERR_INTERNAL, fail,
"Read operation failed: %s.", sr_strerror_safe(errno));
cur += n;
} while (0 < n);
buffer[cur] = '\0';
*out = buffer;
return rc;
fail:
free(buffer);
return rc;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm_s2id
* @BRIEF convert voltage domain provided as a string
* (as defined in voltdm.h) into a plaftorm-specific
* voltage domain ID (integer).
* @RETURNS plaftorm-specific voltage domain ID (> 0) if success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* @param[in] voltdm: voltage domain name (as defined in voltdm.h)
* @DESCRIPTION convert voltage domain provided as a string
* (as defined in voltdm.h) into a plaftorm-specific
* voltage domain ID (integer).
*//*------------------------------------------------------------------------ */
int voltdm_s2id(const char *voltdm)
{
CHECK_NULL_ARG(voltdm, OMAPCONF_ERR_ARG);
if (cpu_is_omap44xx()) {
if (strcmp(voltdm, VDD_WKUP) == 0)
return (int) OMAP4_LDO_WKUP;
else if (strcmp(voltdm, VDD_MPU) == 0)
return (int) OMAP4_VDD_MPU;
else if (strcmp(voltdm, VDD_IVA) == 0)
return (int) OMAP4_VDD_IVA;
else if (strcmp(voltdm, VDD_CORE) == 0)
return (int) OMAP4_VDD_CORE;
else
return OMAPCONF_ERR_ARG;
} else if (cpu_is_omap54xx()) {
if (strcmp(voltdm, VDD_WKUP) == 0)
return (int) VDD54XX_WKUP;
else if (strcmp(voltdm, VDD_MPU) == 0)
return (int) VDD54XX_MPU;
else if (strcmp(voltdm, VDD_MM) == 0)
return (int) VDD54XX_MM;
else if (strcmp(voltdm, VDD_CORE) == 0)
return (int) VDD54XX_CORE;
else
return OMAPCONF_ERR_ARG;
} else {
fprintf(stderr,
"omapconf: %s(): cpu not supported!!!\n", __func__);
return OMAPCONF_ERR_CPU;
}
}
/**
* @brief Measure the current consumption of a given spring.
* @return current consumption of a given spring (in microamps)
* warning 'spring' index starts at 1, not 0.
* @param[in] spring: selected spring ([1..SPRING_COUNT])
* @param[out] uA: selected spring current measurement, in microamps)
*/
int spwrm_get_current(uint8_t spring, int32_t *uA)
{
int ret;
uint8_t adc, chan;
uint32_t spin, uV;
CHECK_SPRING(spring);
CHECK_NULL_ARG(uA);
adc = spwrm_get_adc_device(spring);
chan = spwrm_get_adc_channel(spring);
spin = spwrm_get_sign_pin(spring);
*uA = 0;
ret = adc_get_data(adc, chan, &uV);
if (ret) {
dbg_error("%s(): failed to get %s data! (%d)\n", __func__,
spwrm_get_name(spring), ret);
return ret;
}
/* Convert to uV */
uV = adc_get_uV(uV);
/* Get data sign */
if (stm32_gpioread(spin) == 0) {
dbg_verbose("%s(): pin=0 => sign=-\n", __func__);
*uA = -((int32_t) max9929f_get_Iload(uV));
} else {
dbg_verbose("%s(): pin=1 => sign=+\n", __func__);
*uA = (int32_t) max9929f_get_Iload(uV);
}
dbg_verbose("%s(): measured voltage=%uuV => current=%duA\n",
__func__, uV, *uA);
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm_nominal_voltage_get
* @BRIEF return the nominal voltage supplied to a voltage domain.
* @RETURNS nominal voltage in micro-volt (> 0) in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* @param[in] voltdm: voltage domain name (as defined in voltdm.h)
* @DESCRIPTION return the nominal voltage supplied to a voltage domain.
* In case SmartReflex AVS Class3 is enabled,
* it may differ from the current supplied voltage.
*//*------------------------------------------------------------------------ */
int voltdm_nominal_voltage_get(const char *voltdm)
{
int id;
int uvolt;
CHECK_NULL_ARG(voltdm, OMAPCONF_ERR_ARG);
voltdm_init();
id = voltdm_s2id(voltdm);
if (id < 0) {
uvolt = OMAPCONF_ERR_ARG;
} else if (cpu_is_omap44xx()) {
uvolt = v2uv(voltdm44xx_nominal_voltage_get(
(voltdm44xx_id) id));
} else if (cpu_is_omap54xx()) {
uvolt = v2uv(voltdm54xx_nominal_voltage_get(
(voltdm54xx_id) id));
} else {
fprintf(stderr,
"omapconf: %s(): cpu not supported!!!\n", __func__);
uvolt = OMAPCONF_ERR_CPU;
}
dprintf("%s(%s) = %duV\n", __func__, voltdm, uvolt);
return uvolt;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION dpll_lock_freq_calc
* @BRIEF compute DPLL lock frequency (in MHz)
* @RETURNS lock frequency in case of success (in MHz)
* 0.0 in case of error.
* @param[in] settings: DPLL settings with fields
* regm4xen, fref, MN.M, MN.N INITIALIZED
* @DESCRIPTION compute DPLL lock frequency (in MHz)
*//*------------------------------------------------------------------------ */
double dpll_lock_freq_calc(dpll_settings *settings)
{
CHECK_NULL_ARG(settings, 0.0);
if (settings->type == DPLL_TYPE_A) {
if (settings->regm4xen == 0)
settings->fdpll =
(settings->fref * 2.0 * (double) (settings->MN).M) /
((double) (settings->MN).N + 1.0);
else
settings->fdpll =
(settings->fref * 8.0 * (double) (settings->MN).M) /
((double) (settings->MN).N + 1.0);
dprintf("%s(%u): type=A regm4xen=%u fref=%lfMHz M=%u N=%u => "
"fdpll=%lfMHz\n", __func__, settings->id,
settings->regm4xen, settings->fref, (settings->MN).M,
(settings->MN).N, settings->fdpll);
} else {
settings->fdpll =
(settings->fref * (double) (settings->MN).M) /
((double) (settings->MN).N + 1.0);
dprintf("%s(%u): type=B fref=%lfMHz M=%u N=%u => "
"fdpll=%lfMHz\n", __func__, settings->id,
settings->fref, (settings->MN).M,
(settings->MN).N, settings->fdpll);
}
return settings->fdpll;
}
/* ------------------------------------------------------------------------*//**
* @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 powerdm_has_last_power_state
* @BRIEF return 1 if power domain has LASTPOWERSTATEENTERED
* @RETURNS 1 if power domain has a LASTPOWERSTATEENTERED bitfield.
* 0 if not available or in case of error.
* @param[in] powerdm: power domain name
* @DESCRIPTION return 1 if power domain has LASTPOWERSTATEENTERED
* in PM_xyz_PWRSTST register (not all power domains
* feature it).
* Return 0 if not available or in case of error.
* Does not make any access to any register.
*//*------------------------------------------------------------------------ */
unsigned int powerdm_has_last_power_state(const char *powerdm)
{
int ret;
powerdm_info data;
CHECK_NULL_ARG(powerdm, 0);
ret = _powerdm_info_get(powerdm, &data);
if (ret != 0) {
dprintf("%s(%s): could not retrieve powerdm_info struct!\n",
__func__, powerdm);
return 0;
}
if ((data.properties & PWRDM_HAS_LAST_STATE) != 0) {
dprintf("%s(%s): HAS LASTPOWERSTATEENTERED bitfield\n",
__func__, powerdm);
return 1;
} else {
dprintf(
"%s(%s): does NOT have LASTPOWERSTATEENTERED bitfield\n",
__func__, powerdm);
return 0;
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION voltdm_voltage_get
* @BRIEF return the current voltage supplied to a voltage domain.
* @RETURNS supplied voltage in micro-volt (> 0) in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_NOT_AVAILABLE
* OMAPCONF_ERR_INTERNAL
* @param[in] voltdm: voltage domain name (as defined in voltdm.h)
* @DESCRIPTION return the current voltage supplied to a voltage domain.
*//*------------------------------------------------------------------------ */
int voltdm_voltage_get(const char *voltdm)
{
int id, ret;
double volt;
CHECK_NULL_ARG(voltdm, OMAPCONF_ERR_ARG);
voltdm_init();
id = voltdm_s2id(voltdm);
if (id < 0)
return (double) OMAPCONF_ERR_ARG;
if (cpu_is_omap44xx()) {
ret = voltdm44xx_get_voltage((voltdm44xx_id) id, &volt);
if (ret < 0)
return (double) ret;
else
return v2uv(volt);
} else if (cpu_is_omap54xx()) {
return v2uv(voltdm54xx_voltage_get((voltdm54xx_id) id));
} else {
fprintf(stderr,
"omapconf: %s(): cpu not supported!!!\n", __func__);
return (double) OMAPCONF_ERR_CPU;
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION powerdm_in_transition
* @BRIEF return 1 if a power transition is ongoing
* on a given power domain
* @RETURNS 1 if a power transition is ongoing
* 0 if NO power transition is ongoing (or error)
* @param[in] powerdm: power domain name
* @DESCRIPTION return 1 if a power transition is ongoing
* on a given power domain
*//*------------------------------------------------------------------------ */
unsigned int powerdm_in_transition(const char *powerdm)
{
int in_transition;
reg *pm_pwrstst;
CHECK_NULL_ARG(powerdm, 0);
pm_pwrstst = powerdm_pwrstst_reg_get(powerdm);
if (pm_pwrstst == NULL) {
dprintf("%s(%s): PM_PWRSTST==NULL!\n", __func__, powerdm);
return 0;
}
in_transition = pwrdm_in_transition(pm_pwrstst);
#ifdef PWRDM_DEBUG
if (in_transition)
printf("%s(%s): power transition ONGOING.\n",
__func__, powerdm);
else
printf("%s(%s): NO power transition ongoing.\n",
__func__, powerdm);
#endif
return in_transition;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION cpu_die_id_get
* @BRIEF return OMAP DIE ID (4x 32-bit integers, string).
* @RETURNS OMAP DIE ID string (as "DIEID3-DIEID2-DIEID1-DIEID0")
* NULL in case of error
* @param[in,out] die_id_3: DIE ID (part 3, MSB)
* @param[in,out] die_id_2: DIE ID (part 2)
* @param[in,out] die_id_1: DIE ID (part 1)
* @param[in,out] die_id_0: DIE ID (part 0, LSB)
* @param[in,out] die_id: DIE ID string ("DIEID3-DIEID2-DIEID1-DIEID0")
* @DESCRIPTION return OMAP DIE ID (4x 32-bit integers, string).
*//*------------------------------------------------------------------------ */
char *cpu_die_id_get(unsigned int *die_id_3, unsigned int *die_id_2,
unsigned int *die_id_1, unsigned int *die_id_0,
char die_id[CPU_DIE_ID_LENGTH])
{
CHECK_NULL_ARG(die_id, NULL);
if (mem_read(CONTROL_STD_FUSE_DIE_ID_3, die_id_3) != 0)
return NULL;
dprintf("%s(): die_id_3 = 0x%08X\n", __func__, *die_id_3);
if (mem_read(CONTROL_STD_FUSE_DIE_ID_2, die_id_2) != 0)
return NULL;
dprintf("%s(): die_id_2 = 0x%08X\n", __func__, *die_id_2);
if (mem_read(CONTROL_STD_FUSE_DIE_ID_1, die_id_1) != 0)
return NULL;
dprintf("%s(): die_id_1 = 0x%08X\n", __func__, *die_id_1);
if (mem_read(CONTROL_STD_FUSE_DIE_ID_0, die_id_0) != 0)
return NULL;
dprintf("%s(): die_id_0 = 0x%08X\n", __func__, *die_id_0);
sprintf(die_id, "%08X-%08X-%08X-%08X",
*die_id_3, *die_id_2, *die_id_1, *die_id_0);
dprintf("%s(): die_id = %s\n", __func__, die_id);
return die_id;
}
/* ------------------------------------------------------------------------*//**
* @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 main_dra7xx_show
* @BRIEF show some DRA7 information,
* which category is found in argv
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG in case of incorrect format
* @param[in] argc: shell input argument number
* @param[in] argv: shell input argument(s)
* @DESCRIPTION show some DRA7 information,
* which category is found in argv
*//*------------------------------------------------------------------------ */
int main_dra7xx_show(int argc, char *argv[])
{
CHECK_NULL_ARG(argv, OMAPCONF_ERR_ARG);
if (argc < 1) {
help(HELP_USAGE);
return OMAPCONF_ERR_ARG;
} else if (strcmp(argv[0], "hwtemp") == 0) {
if (argc == 1) {
return hwtemp_sensor_show(stdout, "all");
} else if (argc == 2) {
if (strcmp(argv[1], "all") == 0)
return hwtemp_sensor_show(stdout, argv[1]);
else if (hwtemp_sensor_is_available(argv[1]) != 0)
return hwtemp_sensor_show(stdout, argv[1]);
else
return err_arg_msg_show(HELP_HWTEMPERATURE);
} else {
return err_arg_too_many_msg_show(HELP_HWTEMPERATURE);
}
} else if (strcmp(argv[0], "temp") == 0) {
if (argc == 1) {
return temp_sensor_show(stdout, "all");
} else if (argc == 2) {
if (strcmp(argv[1], "all") == 0)
return temp_sensor_show(stdout, argv[1]);
else if (hwtemp_sensor_is_available(argv[1]) != 0)
return temp_sensor_show(stdout, argv[1]);
else
return err_arg_msg_show(HELP_TEMPERATURE);
} else {
return err_arg_too_many_msg_show(HELP_TEMPERATURE);
}
} else if (strcmp(argv[0], "dpll") == 0) {
if (argc == 1) {
return dpll_dra7xx_show(stdout);
} else if (argc == 2) {
if (strcmp(argv[1], "cfg") == 0)
return dpll_dra7xx_show(stdout);
else
return err_arg_msg_show(HELP_DPLL);
} else {
return err_arg_too_many_msg_show(HELP_DPLL);
}
} else if (strcmp(argv[0], "opp") == 0) {
if (argc == 1)
return opp_show(stdout);
else
return err_arg_too_many_msg_show(HELP_SOC_OPP);
} else if (strncmp(argv[0], "mcasp", 5) == 0) {
if (argc == 1) {
return dra7xx_mcasp_show(stdout, argc, argv);
} else {
return err_arg_too_many_msg_show(HELP_MCASP);
}
} else {
return err_unknown_argument_msg_show(argv[0]);
}
}
/* ------------------------------------------------------------------------*//**
* @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;
}
/**
* @brief Convert data tree difference of type LYD_DIFF_MOVEDAFTER1 or LYD_DIFF_MOVEDAFTER2 to corresponding
* set of Sysrepo public API calls.
*/
static int
srcfg_convert_lydiff_movedafter(const char *target_xpath, const char *after_xpath)
{
CHECK_NULL_ARG(target_xpath);
int rc = sr_move_item(srcfg_session, target_xpath, after_xpath ? SR_MOVE_AFTER : SR_MOVE_FIRST, after_xpath);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error returned from sr_move_item: %s.", sr_strerror(rc));
}
return rc;
}
/**
* @brief Convert data tree difference of type LYD_DIFF_DELETED to corresponding set of Sysrepo public API calls.
*/
static int
srcfg_convert_lydiff_deleted(const char *xpath)
{
CHECK_NULL_ARG(xpath);
int rc = sr_delete_item(srcfg_session, xpath, SR_EDIT_STRICT);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error returned from sr_delete_item: %s.", sr_strerror(rc));
}
return rc;
}
int
cl_session_clear_errors(sr_session_ctx_t *session)
{
CHECK_NULL_ARG(session);
pthread_mutex_lock(&session->lock);
session->error_cnt = 0;
pthread_mutex_unlock(&session->lock);
return SR_ERR_OK;
}
sr_error_t
cl_session_return(sr_session_ctx_t *session, sr_error_t error_code)
{
CHECK_NULL_ARG(session);
pthread_mutex_lock(&session->lock);
session->last_error = error_code;
pthread_mutex_unlock(&session->lock);
return error_code;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_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
* @param[in] voltdm: voltage domain name (as defined in voltdm.h)
* @param[in] quiet: if == 0, print warning message when OPP
* could not be found
* @DESCRIPTION return the current voltage domain OPP name. Search it by
* voltage first, then if failed search it by rates.
*//*------------------------------------------------------------------------ */
const char *opp_get(const char *voltdm, unsigned int quiet)
{
const char *opp = NULL;
CHECK_NULL_ARG(voltdm, NULL);
opp_init();
/*
*
* Due to Smart-Reflex AVS Class1.5 which dynamically updates nominal
* voltages, it is not possible to search OPP using nominal voltages.
* Even if SR AVS Class1.5 could be disabled before and
* during the search, it is considered too constraining,
* as it would reset the voltage and force a new calibration to happen.
* Also if it was ever needed to print the current voltage, it would
* have to be done before the search, otherwise it may not always show
* the converged voltage.
*
* Another reason to skip it is that we want to be really strict,
* then OPP is a strict combination of voltage and frequency.
* which means we would have to search by voltage AND by frequency,
* and only consider it OK if both are found and are matching.
*
*/
#if 0
dprintf("%s(%s): searching OPP by voltage first:\n", __func__, voltdm);
opp = opp_by_voltage_get(voltdm, quiet);
if (opp != NULL) {
dprintf("%s(%s): OPP search by voltage succeeded.\n",
__func__, voltdm);
goto opp_get_end;
}
/*
* Could not detect OPP using voltage, try again
* using frequencies instead.
*/
dprintf("%s(): OPP search by voltage failed, try using rate instead.\n",
__func__);
#endif
opp = opp_by_rate_get(voltdm, quiet);
#if 0
opp_get_end:
#endif
#ifdef OPP_DEBUG
if (opp != NULL)
printf("%s(%s): found %s OPP\n", __func__, voltdm, opp);
else
printf("%s(%s): OPP not found!\n", __func__, voltdm);
#endif
return opp;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION _powerdm_info_get
* @BRIEF return the saved informations of a given power domain.
* @RETURNS 0 in case of success
* -1 in case of error
* @param[in] powerdm: power domain name
* @param[in,out] data: power domain details
* @DESCRIPTION return the saved informations of a given power domain.
*//*------------------------------------------------------------------------ */
static int _powerdm_info_get(const char *powerdm, powerdm_info *data)
{
const genlist *pwrdm_list;
int i, count;
CHECK_NULL_ARG(powerdm, -1);
CHECK_NULL_ARG(data, -1);
pwrdm_list = powerdm_list_get();
count = genlist_getcount((genlist *) pwrdm_list);
for (i = 0; i < count; i++) {
genlist_get((genlist *) pwrdm_list, i, (void *) data);
if (strcmp(data->name, powerdm) == 0) {
dprintf("%s(%s): found.\n", __func__, powerdm);
return 0;
}
}
dprintf("%s(%s): not found!\n", __func__, powerdm);
return -1;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION ctt44xx_rd1_export
* @BRIEF export PRCM registers in CTT RD1 format
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_NOT_AVAILABLE
* @param[in] filename: output file name
* @DESCRIPTION export PRCM registers in CTT RD1 format
*//*------------------------------------------------------------------------ */
int ctt44xx_rd1_export(char *filename)
{
unsigned int i = 0;
unsigned int ret, val = 0;
int err = 0;
FILE *fd = NULL;
CHECK_CPU(44xx, OMAPCONF_ERR_ARG);
CHECK_NULL_ARG(filename, OMAPCONF_ERR_ARG);
fd = fopen(filename, "w");
if (fd == NULL) {
printf("error: could not create %s file!\n", filename);
return OMAPCONF_ERR_NOT_AVAILABLE;
}
if (cpu_is_omap4430()) {
fprintf(fd, "DeviceName OMAP4430_ES2.x\n");
} else if (cpu_is_omap4460()) {
fprintf(fd, "DeviceName OMAP4460_ES1.x\n");
} else if (cpu_is_omap4470()) {
fprintf(fd, "DeviceName OMAP4470_ES1.0\n");
} else {
err = OMAPCONF_ERR_CPU;
goto ctt44xx_rd1_export_end;
}
ctt44xx_regtable_init();
while (prcm_ctt_reg_table[i].addr != 0) {
/* display register addr & content (hex) */
ret = mem_read(prcm_ctt_reg_table[i].addr, &val);
if (ret == 0)
fprintf(fd, "0x%08X 0x%08X\n",
prcm_ctt_reg_table[i].addr, val);
else {
fprintf(stderr,
"omapconf: read error! (addr=0x%08X, err=%d)\n",
prcm_ctt_reg_table[i].addr, ret);
err = OMAPCONF_ERR_REG_ACCESS;
}
i++;
}
printf("Output written to file '%s'.\n", filename);
err = 0;
ctt44xx_rd1_export_end:
if (fd != NULL)
fclose(fd);
return err;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION vc44xx_raw_cmd_values_get
* @BRIEF return ON/ONLP/RET/OFF command values
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* @param[in] id: voltage domain ID
* @param[in,out] vc_regs: Voltage Controller registers content
* @param[in,out] cmd_on: ON command value (RETURNED)
* @param[in,out] cmd_onlp: ONLP command value (RETURNED)
* @param[in,out] cmd_ret: RET command value (RETURNED)
* @param[in,out] cmd_off: OFF command value (RETURNED)
* @DESCRIPTION return ON/ONLP/RET/OFF command values
* WARNING: DO NOT CONSIDER PMIC-SPECIFIC SIZE OF COMMAND.
*//*------------------------------------------------------------------------ */
short int vc44xx_raw_cmd_values_get(voltdm44xx_id id, vc44xx_registers *vc_regs,
unsigned char *cmd_on, unsigned char *cmd_onlp,
unsigned char *cmd_ret, unsigned char *cmd_off)
{
unsigned int vc_val_cmd;
CHECK_NULL_ARG(cmd_on, OMAPCONF_ERR_ARG);
CHECK_NULL_ARG(cmd_onlp, OMAPCONF_ERR_ARG);
CHECK_NULL_ARG(cmd_ret, OMAPCONF_ERR_ARG);
CHECK_NULL_ARG(cmd_off, OMAPCONF_ERR_ARG);
/* Command Values Set Selection */
switch (id) {
case OMAP4_VDD_MPU:
vc_val_cmd = vc_regs->prm_vc_val_cmd_vdd_mpu_l;
break;
case OMAP4_VDD_IVA:
if (extract_bit(vc_regs->prm_vc_cfg_channel,
VC_CFG_CHANNEL_CMD_VDD_IVA_L_POS) == 1)
vc_val_cmd = vc_regs->prm_vc_val_cmd_vdd_iva_l;
else
vc_val_cmd = vc_regs->prm_vc_val_cmd_vdd_core_l;
break;
case OMAP4_VDD_CORE:
vc_val_cmd = vc_regs->prm_vc_val_cmd_vdd_core_l;
break;
default:
return OMAPCONF_ERR_ARG;
}
/* Retrieve commands from registers */
vc_cmd_values_get(vc_val_cmd,
cmd_on, cmd_onlp, cmd_ret, cmd_off);
return 0;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION opp_dra7xx_id_get
* @BRIEF convert OPP provided as a string (as defined in opp.h)
* into a plaftorm-specific OPP ID (integer).
* @RETURNS plaftorm-specific OPP ID (> 0) in case of success
* OMAPCONF_ERR_CPU
* @param[in] opp: OPP provided as a string (as defined in opp.h)
* @DESCRIPTION convert OPP provided as a string (as defined in opp.h)
* into a plaftorm-specific OPP ID (integer).
*//*------------------------------------------------------------------------ */
int opp_dra7xx_id_get(const char *opp)
{
CHECK_NULL_ARG(opp, OMAPCONF_ERR_ARG);
if (strcasecmp(opp, OPP_NOM) == 0)
return (int) OPP_DRA7XX_NOM;
else if (strcasecmp(opp, OPP_OD) == 0)
return (int) OPP_DRA7XX_OD;
else if (strcasecmp(opp, OPP_HIGH) == 0)
return (int) OPP_DRA7XX_HIGH;
else
return OMAPCONF_ERR_ARG;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION temp_sensor_s2id
* @BRIEF convert generic temperature sensor name (string)
* into platform-specific ID (integer).
* @RETURNS >= 0 platform-specific ID
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* @param[in] sensor: generic temperature sensor name
* @DESCRIPTION convert generic temperature sensor name (string)
* into platform-specific ID (integer).
* To be used when calling architecture-specific functions.
*//*------------------------------------------------------------------------ */
int temp_sensor_s2id(const char *sensor)
{
int id;
CHECK_NULL_ARG(sensor, OMAPCONF_ERR_ARG);
if (cpu_is_omap44xx()) {
if (strcasecmp(sensor, TEMP_SENSOR_BANDGAP) == 0)
id = (int) TEMP44XX_BANDGAP;
else if (strcasecmp(sensor, TEMP_SENSOR_HOTSPOT_MPU) == 0)
id = (int) TEMP44XX_HOTSPOT;
else if (strcasecmp(sensor, TEMP_SENSOR_MEM1) == 0)
id = (int) TEMP44XX_DDR1_CS1;
else if (strcasecmp(sensor, TEMP_SENSOR_MEM2) == 0)
id = (int) TEMP44XX_DDR2_CS1;
else if (strcasecmp(sensor, TEMP_SENSOR_PCB) == 0)
id = (int) TEMP44XX_PCB;
else
id = OMAPCONF_ERR_ARG;
} else if (cpu_is_omap54xx()) {
if (strcasecmp(sensor, TEMP_SENSOR_MPU) == 0)
id = (int) TEMP54XX_MPU;
else if (strcasecmp(sensor, TEMP_SENSOR_HOTSPOT_MPU) == 0)
id = (int) TEMP54XX_HOTSPOT_MPU;
else if (strcasecmp(sensor, TEMP_SENSOR_GPU) == 0)
id = (int) TEMP54XX_GPU;
else if (strcasecmp(sensor, TEMP_SENSOR_HOTSPOT_GPU) == 0)
id = (int) TEMP54XX_HOTSPOT_GPU;
else if (strcasecmp(sensor, TEMP_SENSOR_MEM1) == 0)
id = (int) TEMP54XX_EMIF1;
else if (strcasecmp(sensor, TEMP_SENSOR_MEM2) == 0)
id = (int) TEMP54XX_EMIF2;
else if (strcasecmp(sensor, TEMP_SENSOR_CORE) == 0)
id = (int) TEMP54XX_CORE;
else if (strcasecmp(sensor, TEMP_SENSOR_PCB) == 0)
id = (int) TEMP54XX_PCB;
else if (strcasecmp(sensor, TEMP_SENSOR_CASE) == 0)
id = (int) TEMP54XX_CASE;
else if (strcasecmp(sensor, TEMP_SENSOR_CHARGER) == 0)
id = (int) TEMP54XX_CHARGER;
else
id = OMAPCONF_ERR_ARG;
} else {
fprintf(stderr,
"omapconf: %s(): cpu not supported!!!\n", __func__);
id = OMAPCONF_ERR_CPU;
}
dprintf("%s(%s) = %d\n", __func__, sensor, id);
return id;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION main_dra7xx_dump
* @BRIEF dump some DRA7 registers, which category is found in
* argv
* @RETURNS 0 in case of success
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_ARG
* @param[in] argc: number of arguments
* @param[in] argv: argument(s)
* @DESCRIPTION dump some DRA7 registers, which category is found in
* argv
*//*------------------------------------------------------------------------ */
int main_dra7xx_dump(int argc, char *argv[])
{
dpll_dra7xx_id dpll_id;
CHECK_NULL_ARG(argv, OMAPCONF_ERR_ARG);
if (argc < 1) {
help(HELP_USAGE);
return OMAPCONF_ERR_ARG;
} else if (strcmp(argv[0], "prcm") == 0) {
if (argc == 1)
return prcm_dra7xx_dump(NULL);
else if (argc == 2)
return prcm_dra7xx_dump(argv[1]);
else
return err_arg_too_many_msg_show(HELP_PRCM);
} else if (strcmp(argv[0], "dpll") == 0) {
if (argc == 1)
return dpll_dra7xx_dump(stdout, DPLL_DRA7XX_ID_MAX);
else if (argc == 2) {
if (strcmp(argv[1], "all") == 0)
dpll_id = DPLL_DRA7XX_ID_MAX;
else {
dpll_id = dpll_dra7xx_s2id(argv[1]);
if (dpll_id == DPLL_DRA7XX_ID_MAX)
return err_arg_msg_show(HELP_DPLL);
}
return dpll_dra7xx_dump(stdout, dpll_id);
}
else
return err_arg_too_many_msg_show(HELP_PRCM);
} else if (strncmp(argv[0], "mcasp", 5) == 0) {
if (argc == 1) {
return dra7xx_mcasp_dumpregs(stdout, argc, argv);
} else {
return err_arg_too_many_msg_show(HELP_MCASP);
}
} else if (strcmp(argv[0], "audioic") == 0) {
if (argc == 1 || argc == 3)
return tlv320aic3x_dumpregs(argc, argv);
else
return err_arg_too_many_msg_show(HELP_AUDIOIC);
} else if (!strcmp(argv[0], "crossbar")) {
if (argc == 1 || argc == 2 || argc == 3) {
return dra7_crossbar_dump_main(argc - 1, argv + 1);
} else {
return err_arg_too_many_msg_show(HELP_CROSSBAR);
}
} else {
return err_unknown_argument_msg_show(argv[0]);
}
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION emif54xx_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
* OMAPCONF_ERR_INTERNAL
* @param[in,out] fp: output file stream (opened for write operations)
* @param[in] id: EMIF module ID
* @DESCRIPTION export module register content to file, in XML format.
*//*------------------------------------------------------------------------ */
int emif54xx_export(FILE *fp, emif54xx_mod_id id)
{
reg **mod;
unsigned int i, accessible;
CHECK_CPU(54xx, OMAPCONF_ERR_CPU);
CHECK_NULL_ARG(fp, OMAPCONF_ERR_ARG);
CHECK_ARG_LESS_THAN(id, EMIF54XX_MODS_COUNT, OMAPCONF_ERR_ARG);
switch (id) {
case EMIF54XX_EMIF1:
accessible = module_is_accessible(MOD_EMIF1);
break;
case EMIF54XX_EMIF2:
accessible = module_is_accessible(MOD_EMIF2);
break;
default: /* should not happen as already checked just before ... */
return OMAPCONF_ERR_INTERNAL;
}
if (!accessible) {
printf("%s export: module not running, skipping "
"registers export.\n", emif54xx_mod_name_get(id));
return 0;
}
if (cpu_revision_get() == REV_ES1_0)
mod = emif54xxes1_mods[id];
else
mod = emif54xx_mods[id];
fprintf(fp, " <submodule id=\"%u\" name=\"%s\">\n",
id, emif54xx_mod_name_get(id));
if (cpu_revision_get() == REV_ES1_0) {
for (i = 0; i < OMAP5430ES1_EMIF1_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]));
} else {
for (i = 0; i < OMAP5430_EMIF1_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 powerdm_id_get
* @BRIEF return the unique ID of a given power domain.
* @RETURNS >= 0 power domain ID
* -1 in case of error
* @param[in] powerdm: power domain name
* @DESCRIPTION return the unique ID of a given power domain.
*//*------------------------------------------------------------------------ */
int powerdm_id_get(const char *powerdm)
{
int id;
powerdm_info data;
CHECK_NULL_ARG(powerdm, -1);
id = _powerdm_info_get(powerdm, &data);
if (id == 0)
id = data.id;
dprintf("%s(%s) = %d\n", __func__, powerdm, id);
return id;
}
int
cl_session_set_error(sr_session_ctx_t *session, const char *error_message, const char *error_path)
{
CHECK_NULL_ARG(session);
pthread_mutex_lock(&session->lock);
if (0 == session->error_info_size) {
/* need to allocate the space for the error */
session->error_info = calloc(1, sizeof(*session->error_info));
if (NULL == session->error_info) {
SR_LOG_ERR_MSG("Unable to allocate error information.");
pthread_mutex_unlock(&session->lock);
return SR_ERR_NOMEM;
}
session->error_info_size = 1;
} else {
/* space for the error already allocated, release old error data */
if (NULL != session->error_info[0].message) {
free((void*)session->error_info[0].message);
session->error_info[0].message = NULL;
}
if (NULL != session->error_info[0].xpath) {
free((void*)session->error_info[0].xpath);
session->error_info[0].xpath = NULL;
}
}
if (NULL != error_message) {
session->error_info[0].message = strdup(error_message);
if (NULL == session->error_info[0].message) {
SR_LOG_ERR_MSG("Unable to allocate error message.");
pthread_mutex_unlock(&session->lock);
return SR_ERR_NOMEM;
}
}
if (NULL != error_path) {
session->error_info[0].xpath = strdup(error_path);
if (NULL == session->error_info[0].xpath) {
SR_LOG_ERR_MSG("Unable to allocate error xpath.");
pthread_mutex_unlock(&session->lock);
return SR_ERR_NOMEM;
}
}
session->error_cnt = 1;
pthread_mutex_unlock(&session->lock);
return SR_ERR_OK;
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION temp_sensor_is_available
* @BRIEF check if temperature sensor is available.
* @RETURNS 1 if temperature sensor is available
* 0 if temperature sensor is NOT available
* @param[in] sensor: generic temperature sensor name
* @DESCRIPTION check if temperature sensor is available
* (platform-dependent).
*//*------------------------------------------------------------------------ */
int temp_sensor_is_available(const char *sensor)
{
int id;
CHECK_NULL_ARG(sensor, 0);
id = temp_sensor_s2id(sensor);
if (id >= 0) {
dprintf("%s(): %s is available.\n", __func__, sensor);
return 1;
} else {
dprintf("%s(): %s is NOT available.\n", __func__, sensor);
return 0;
}
}