prcm-debug.c

来自「omap3 linux 2.6 用nocc去除了冗余代码」· C语言 代码 · 共 2,079 行 · 第 1/5 页

		prcm_set_domain_functional_clocks(domain, 0x0);
	}

	if (prcm_set_power_domain_state(domain, state, mode)
							!= PRCM_PASS) {
		DPRINTK1("prcm_set_power_domain_state for "
				"domain %d failed. err:%d\n", domain, ret);
		ret = -1;
		goto revert;
	}
	prcm_get_power_domain_state(domain, &power_state);
	DPRINTK1("Power state for domain %d is %d\n", domain, power_state);

revert:
	/* Restore values in iclken and fclken registers */
	prcm_set_domain_interface_clocks(domain, iclken);
	prcm_set_domain_functional_clocks(domain, fclken);

	if (ret)
		return -1;

	return 0;
}

int powerapi_test(void)
{
	u32 cm_sleepdep_dss, cm_sleepdep_cam, cm_sleepdep_per;
	u32 pm_wkdep_iva2, pm_wkdep_mpu, pm_wkdep_dss, pm_wkdep_cam;
	u32 pm_wkdep_per, pm_wkdep_neon;
	u32 ivaf, core1f, core1i, core2i, wkupf, wkupi;
	u32 dssf, dssi, camf, cami, perf, peri;
	int tries = 0;
	int ret = 0, ret1 = 0;
	u8 state;
	u32 usbi, usbf, sgxi, sgxf, pm_wkdep_usb, pm_wkdep_sgx,
		cm_sleepdep_usb, cm_sleepdep_sgx;

	/* Save clock registers */
	ivaf = CM_FCLKEN_IVA2;
	core1f = CM_FCLKEN1_CORE;
	core1i = CM_ICLKEN1_CORE;
	core2i = CM_ICLKEN2_CORE;
	sgxf = CM_FCLKEN_SGX;
	sgxi = CM_ICLKEN_SGX;
	usbf = CM_FCLKEN_USBHOST;
	usbi = CM_ICLKEN_USBHOST;
	wkupf = CM_FCLKEN_WKUP;
	wkupi = CM_ICLKEN_WKUP;
	dssf = CM_FCLKEN_DSS;
	dssi = CM_ICLKEN_DSS;
	camf = CM_FCLKEN_CAM;
	cami = CM_ICLKEN_CAM;
	perf = CM_FCLKEN_PER;
	peri = CM_ICLKEN_PER;

	/* Clear all sleep/wakeup dependencies */
	cm_sleepdep_sgx = CM_SLEEPDEP_SGX;
	pm_wkdep_sgx = PM_WKDEP_SGX;
	cm_sleepdep_usb	= CM_SLEEPDEP_USBHOST;
	pm_wkdep_usb = PM_WKDEP_USBHOST;
	cm_sleepdep_dss = CM_SLEEPDEP_DSS;
	cm_sleepdep_cam = CM_SLEEPDEP_CAM;
	cm_sleepdep_per = CM_SLEEPDEP_PER;
	pm_wkdep_iva2 = PM_WKDEP_IVA2;
	pm_wkdep_mpu = PM_WKDEP_MPU;
	pm_wkdep_dss = PM_WKDEP_DSS;
	pm_wkdep_cam = PM_WKDEP_CAM;
	pm_wkdep_per = PM_WKDEP_PER;
	pm_wkdep_neon = PM_WKDEP_NEON;


	CM_SLEEPDEP_SGX = 0;
	PM_WKDEP_SGX = 0;
	CM_SLEEPDEP_USBHOST = 0;
	PM_WKDEP_USBHOST = 0;
	CM_SLEEPDEP_DSS = 0;
	CM_SLEEPDEP_CAM = 0;
	CM_SLEEPDEP_PER = 0;
	PM_WKDEP_IVA2 = 0;
	PM_WKDEP_MPU = 0;
	PM_WKDEP_DSS = 0;
	PM_WKDEP_CAM = 0;
	PM_WKDEP_PER = 0;
	PM_WKDEP_NEON = 0;

	DPRINTK1("Testing multiple iterations using force mode\n");

	/* Test Multiple transitions for CAM/DSS/SGX/NEON/USBHOST in
	Force mode */
	for (tries = 0; tries < 3; tries++) {
		/* IVA2 */
		DPRINTK1("IVA2: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_IVA2, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_IVA2, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_IVA2, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_IVA2, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_IVA2, PRCM_FORCE, PRCM_ON);

		/* DSS */
		DPRINTK1("DSS: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_DSS, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_DSS, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_DSS, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_DSS, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_DSS, PRCM_FORCE, PRCM_ON);

		/* CAM */
		DPRINTK1("CAM: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_CAM, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_CAM, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_CAM, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_CAM, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_CAM, PRCM_FORCE, PRCM_ON);

		/* SGX */
		DPRINTK1("SGX: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_SGX, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_SGX, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_SGX, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_SGX, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_SGX, PRCM_FORCE, PRCM_ON);
		/* USBHOST */
		DPRINTK1("USBHOST: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_FORCE, PRCM_ON);
		/* PER */
		DPRINTK1("PER: Trying OFF/ON/RET/ON\n");
		ret |= prcm_set_power_state(DOM_PER, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_PER, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_PER, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_PER, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_PER, PRCM_FORCE, PRCM_ON);

		/* NEON */
		DPRINTK1("NEON: Trying RET/ON\n");
		ret |= prcm_set_power_state(DOM_NEON, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_NEON, PRCM_FORCE, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_NEON, PRCM_FORCE, PRCM_ON);
		ret |= prcm_set_power_state(DOM_NEON, PRCM_FORCE, PRCM_RET);
		ret |= prcm_set_power_state(DOM_NEON, PRCM_FORCE, PRCM_ON);

		if (ret) {
			printk(KERN_ERR"Error in setting the power states \n");
			goto revert;
		}
	}

	DPRINTK1("Testing force power domains API\n");
	/* Test Force API (Level2 API) */
	/* MPU */
	DPRINTK1("Testing MPU\n");
	ret1 = prcm_force_power_domain_state(DOM_MPU, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of MPU power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_pre_power_domain_state(DOM_PER, &state);
	DPRINTK1("Previous mpu state = %x\n", state);

	/* SGX */
	DPRINTK1("Testing SGX\n");
	ret1 = prcm_force_power_domain_state(DOM_SGX, PRCM_OFF);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of SGX power domain failed for state PRCM_OFF"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_SGX, &state);
	DPRINTK1("Current SGX state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_SGX, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of SGX power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_SGX, &state);
	DPRINTK1("Current SGX state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_SGX, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of SGX power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_SGX, &state);
	DPRINTK1("Current SGX state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_SGX, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of SGX power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_SGX, &state);
	DPRINTK1("Current SGX state = %x\n", state);

	/* USBHOST */
	DPRINTK1("Testing USBHOST\n");
	ret1 = prcm_force_power_domain_state(DOM_USBHOST, PRCM_OFF);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of USBHOST power domain failed for state "
				"PRCM_OFF\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_USBHOST, &state);
	DPRINTK1("Current USBHOST state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_USBHOST, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of USBHOST power domain failed for state "
				"PRCM_ON\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_USBHOST, &state);
	DPRINTK1("Current USBHOST state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_USBHOST, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of USBHOST power domain failed for state "
				"PRCM_RET\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_USBHOST, &state);
	DPRINTK1("Current USBHOST state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_USBHOST, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of USBHOST power domain failed for state "
				"PRCM_ON\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_USBHOST, &state);
	DPRINTK1("Current USBHOST state = %x\n", state);

	/* IVA2 */
	DPRINTK1("Testing IVA2\n");
	ret1 = prcm_force_power_domain_state(DOM_IVA2, PRCM_OFF);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of IVA2 power domain failed for state PRCM_OFF"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_IVA2, &state);
	DPRINTK1("Current IVA2 state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_IVA2, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of IVA2 power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_IVA2, &state);
	DPRINTK1("Current IVA2 state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_IVA2, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of IVA2 power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_IVA2, &state);
	DPRINTK1("Current IVA2 state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_IVA2, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of IVA2 power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_IVA2, &state);
	DPRINTK1("Current IVA2 state = %x\n", state);

	/* CAM */
	DPRINTK1("Testing CAM\n");
	ret1 = prcm_force_power_domain_state(DOM_CAM, PRCM_OFF);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of CAM power domain failed for state PRCM_OFF"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_CAM, &state);
	DPRINTK1("Current CAM state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_CAM, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of CAM power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_CAM, &state);
	DPRINTK1("Current CAM state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_CAM, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of CAM power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_CAM, &state);
	DPRINTK1("Current CAM state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_CAM, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of CAM power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_CAM, &state);
	DPRINTK1("Current CAM state = %x\n", state);

	/* PER */
	DPRINTK1("Testing PER\n");
	ret1 = prcm_force_power_domain_state(DOM_PER, PRCM_OFF);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of PER power domain failed for state PRCM_OFF"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_PER, &state);
	DPRINTK1("Current PER state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_PER, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of PER power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_PER, &state);
	DPRINTK1("Current PER state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_PER, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of PER power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_PER, &state);
	DPRINTK1("Current PER state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_PER, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of PER power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_PER, &state);
	DPRINTK1("Current PER state = %x\n", state);

	/* NEON */
	DPRINTK1("Testing NEON\n");
	/* Neon cannot come back from OFF on ES 1.0 becaue of
	 * silicon erratum. So dont test OFF */
	ret1 = prcm_force_power_domain_state(DOM_NEON, PRCM_RET);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of NEON power domain failed for state PRCM_RET"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_NEON, &state);
	DPRINTK1("Current NEON state = %x\n", state);
	ret1 = prcm_force_power_domain_state(DOM_NEON, PRCM_ON);
	if (ret1 != PRCM_PASS) {
		DPRINTK1("Force of NEON power domain failed for state PRCM_ON"
				"\n");
		goto revert;
	}
	prcm_get_power_domain_state(DOM_NEON, &state);
	DPRINTK1("Current NEON state = %x\n", state);

	DPRINTK1("Testing multiple iterations with auto mode\n");
	DPRINTK1("First iteration goes through but for subsequent iterations, "
			"need to use sleep dependency\n");
	DPRINTK1("This is due to limitation 2.6\n");
	/* Test Multiple transitions for CAM/DSS/SGX/NEON in Auto mode */
	for (tries = 0; tries < 3; tries++) {
		DPRINTK1("\n\n");
		DPRINTK1("Iteration: %d\n", (tries + 1));
		/*Making PREPWSTST registers ON*/
		PM_PREPWSTST_CAM = 0xF;
		PM_PREPWSTST_SGX = 0xF;
		PM_PREPWSTST_USBHOST = 0xF;
		PM_PREPWSTST_DSS = 0xF;
		PM_PREPWSTST_PER = 0xF;
		PM_PREPWSTST_NEON = 0xF;

		if (tries > 0) {
			DPRINTK1("Programming sleep dependency with mpu\n");
			DPRINTK1("NEON already has sleep dependency with mpu"
					"\n");
			CM_SLEEPDEP_SGX |= (1 << 1);
			CM_SLEEPDEP_USBHOST |= (1 << 1);
			CM_SLEEPDEP_DSS |= (1 << 1);
			CM_SLEEPDEP_CAM |= (1 << 1);
			CM_SLEEPDEP_PER |= (1 << 1);
			DPRINTK1("Printing previous power states:\n");
			prcm_get_pre_power_domain_state(DOM_CAM, &state);
			DPRINTK1("Previous  CAM state = %x\n", state);
			prcm_get_pre_power_domain_state(DOM_SGX, &state);
			DPRINTK1("Previous  SGX state = %x\n", state);
			prcm_get_pre_power_domain_state(DOM_USBHOST, &state);
			DPRINTK1("Previous  USBHOST state = %x\n", state);
			prcm_get_pre_power_domain_state(DOM_DSS, &state);
			DPRINTK1("Previous  DSS state = %x\n", state);
			prcm_get_pre_power_domain_state(DOM_PER, &state);
			DPRINTK1("Previous  PER state = %x\n", state);
			prcm_get_pre_power_domain_state(DOM_NEON, &state);
			DPRINTK1("Previous  NEON state = %x\n", state);
		}


		/* Put the domains in OFF */
		DPRINTK1("Programming CAM,SGX,DSS,PER in OFF NEON in Ret\n");
		ret |= prcm_set_power_state(DOM_CAM, PRCM_AUTO, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_SGX, PRCM_AUTO, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_USBHOST, PRCM_AUTO, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_DSS, PRCM_AUTO, PRCM_OFF);
		ret |= prcm_set_power_state(DOM_NEON, PRCM_AUTO, PRCM_RET);
		ret |= prcm_set_power_state(DOM_PER, PRCM_AUTO, PRCM_OFF);
		if (ret) {
			printk(KERN_ERR"Error in setting the power states \n");
			goto revert;
		}

		/* Set wakeup dependencies with MPU*/
		PM_WKDEP_CAM |= (1 << 1);
		PM_WKDEP_SGX |= (1 << 1);