自学教程：C++ CHECK_ARG_LESS_THAN函数代码示例

/* ------------------------------------------------------------------------*//** * @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		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		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];}