Esempio n. 1
0
// -------------------------------------------------------------
static mcResult_t executeCmd(uint32_t *num1, uint32_t *num2, uint32_t *result, tciCommandId_t cmd)
{
	mcResult_t  ret;    

	if(NULL == tci) 
	{
	    LOG_E("TCI has not been set up properly - exiting");
	    return MC_DRV_ERR_NO_FREE_MEMORY;
	}

	tci->cmdfoo.header.commandId = cmd;
	tci->cmdfoo.len = 0;
	tci->cmdfoo.respLen = 0;
	tci->Num1 = *num1;
	tci->Num2 = *num2;    

	LOG_I("Preparing command message in TCI");

	LOG_I("Notifying the trustlet");
	ret = mcNotify(&sessionHandle);

	if (MC_DRV_OK != ret)
	{
	    LOG_E("Notify failed: %d", ret);
	    goto exit;
	}

	LOG_I("Waiting for the Trustlet response");
	ret = mcWaitNotification(&sessionHandle, -1);

	if (MC_DRV_OK != ret) 
	{
	    LOG_E("Wait for response notification failed: 0x%x", ret);
	    goto exit;
	}

	*result = tci->ResultData;

	LOG_I("Verifying that the Trustlet sent a response.");
	if (RSP_ID(cmd) != tci->rspfoo.header.responseId) 
	{
	    LOG_E("Trustlet did not send a response: %d",
	        tci->rspfoo.header.responseId);
	    ret = MC_DRV_ERR_INVALID_RESPONSE;
	    goto exit;
	}

	if (RET_OK != tci->rspfoo.header.returnCode) 
	{
	    LOG_E("Trustlet did not send a valid return code: %d",
	        tci->rspfoo.header.returnCode);
	    ret = tci->rspfoo.header.returnCode;
	}

	exit:
	return ret;
}
Esempio n. 2
0
// -------------------------------------------------------------
static mcResult_t executeCmd(uint32_t *index, uint32_t *result, tciCommandId_t cmd)
{
	mcResult_t  ret;    

	if(NULL == tci) 
	{
	    printf("TCI has not been set up properly - exiting\n");
	    return MC_DRV_ERR_NO_FREE_MEMORY;
	}

	tci->cmd.header.commandId = cmd;
	tci->cmd.len = 0;
	tci->cmd.respLen = 0;
	tci->index= *index; 

	printf("Preparing command message in TCI\n");

	printf("Notifying the trustlet\n");
	ret = mcNotify(&sessionHandle);

	if (MC_DRV_OK != ret)
	{
	    printf("Notify failed: %d\n", ret);
	    goto exit;
	}

	printf("Waiting for the Trustlet response\n");
	ret = mcWaitNotification(&sessionHandle, -1);

	if (MC_DRV_OK != ret) 
	{
	    printf("Wait for response notification failed: 0x%x\n", ret);
	    goto exit;
	}

	*result = tci->result;

	printf("Verifying that the Trustlet sent a response.\n");
	if (RSP_ID(cmd) != tci->rsp.header.responseId) 
	{
	    printf("Trustlet did not send a response: %d\n",
	        tci->rsp.header.responseId);
	    ret = MC_DRV_ERR_INVALID_RESPONSE;
	    goto exit;
	}

	if (RET_OK != tci->rsp.header.returnCode) 
	{
	    printf("Trustlet did not send a valid return code: %d\n",
	        tci->rsp.header.returnCode);
	    ret = tci->rsp.header.returnCode;
	}

	exit:
	return ret;
}
Esempio n. 3
0
/**
 * DCI handler loop. this is the function where notifications from Nwd are handled
 */
_NORETURN void drDcihLoop( void )
{
    dciCommandId_t  commandId;
    dciReturnCode_t ret;

    drDbgPrintLnf("[Driver DrTemplate] drDcihLoop(): DCI handler thread is running");

    for(;;)
    {
        /* Initialize return value */
        ret = RET_OK;

        /* Wait for IPC signal */
        if (DRAPI_OK != drApiIpcSigWait())
        {
            drDbgPrintLnf("[Driver DrTemplate] drDcihLoop(): drApiIpcSigWait failed");
            continue;
        }

        /* Get commandid */
        commandId = message->command.header.commandId;

        /* Get & process DCI command */
        switch( commandId )
        {
            /**
             * TODO: Add new command ids and and update existing ones when needed
             *
             */

            //--------------------------------------
            case CMD_ID_01:
                break;
            //--------------------------------------
            case CMD_ID_02:
                break;
            //--------------------------------------
            default:
                break;
        }

        message->response.header.responseId = RSP_ID(commandId);
        message->response.header.returnCode = ret;

        /* Notify Nwd */
        if (DRAPI_OK != drApiNotify())
        {
            drDbgPrintLnf("[Driver DrTemplate] drDcihLoop(): drApiNotify failed");
        }
    }
}
static uint32_t send_cmd_to_user(uint32_t command_id)
{
    uint32_t ret = TUI_DCI_ERR_NO_RESPONSE;

    /* Init shared variables */
    g_cmd_id = command_id;
    g_user_rsp.id = TLC_TUI_CMD_NONE;
    g_user_rsp.return_code = TLC_TUI_ERR_UNKNOWN_CMD;


    /* S.LSI : Clean up previous response. */
    complete_all(&io_comp);
    INIT_COMPLETION(io_comp);

    /* Give way to ioctl thread */
    complete(&dci_comp);
    pr_debug("send_cmd_to_user: give way to ioctl thread\n");

    /* Wait for ioctl thread to complete */
    wait_for_completion_interruptible(&io_comp);
    pr_debug("send_cmd_to_user: Got an answer from ioctl thread.\n");
    INIT_COMPLETION(io_comp);

    /* Check id of the cmd processed by ioctl thread (paranoia) */
    if (g_user_rsp.id != command_id) {
        pr_debug("ERROR %s: Wrong response id 0x%08x iso 0x%08x\n",
                 __func__, dci->nwd_rsp.id, RSP_ID(command_id));
        ret = TUI_DCI_ERR_INTERNAL_ERROR;
    } else {
        /* retrieve return code */
        switch (g_user_rsp.return_code) {
        case TLC_TUI_OK:
            ret = TUI_DCI_OK;
            break;
        case TLC_TUI_ERROR:
            ret = TUI_DCI_ERR_INTERNAL_ERROR;
            break;
        case TLC_TUI_ERR_UNKNOWN_CMD:
            ret = TUI_DCI_ERR_UNKNOWN_CMD;
            break;
        }
    }

    return ret;
}
static uint32_t sendCmdToUser(uint32_t commandId)
{
	dciReturnCode_t ret = TUI_DCI_ERR_NO_RESPONSE;

	/* Init shared variables */
	gCmdId = commandId;
	gUserRsp.id = TLC_TUI_CMD_NONE;
	gUserRsp.returnCode = TLC_TUI_ERR_UNKNOWN_CMD;
	
	/* Give way to ioctl thread */
	complete(&dciComp);
	pr_debug("sendCmdToUser: give way to ioctl thread\n");

	/* Wait for ioctl thread to complete */
	wait_for_completion_interruptible(&ioComp);
	pr_debug("sendCmdToUser: Got an answer from ioctl thread.\n");
	INIT_COMPLETION(ioComp);

	/* Check id of the cmd processed by ioctl thread (paranoïa) */
	if (gUserRsp.id != commandId) {
		pr_debug("sendCmdToUser ERROR: Wrong response id 0x%08x iso 0x%08x\n",
				pDci->nwdRsp.id, RSP_ID(commandId));
		ret = TUI_DCI_ERR_INTERNAL_ERROR;
	} else {
		/* retrieve return code */
		switch (gUserRsp.returnCode) {
		case TLC_TUI_OK:
			ret = TUI_DCI_OK;
			break;
		case TLC_TUI_ERROR:
			ret = TUI_DCI_ERR_INTERNAL_ERROR;
			break;
		case TLC_TUI_ERR_UNKNOWN_CMD:
			ret = TUI_DCI_ERR_UNKNOWN_CMD;
			break;
		}
	}

	return ret;
}
extern "C" g2ddrmResult_t G2DDRM_Terminate(void)
{
	mcResult_t mcRet;
	g2ddrmResult_t ret = G2DDRM_SUCCESS;
	struct tciMessage_t *tci = NULL;

	LOG_I("G2DDRM_Terminate(): secure G2D driver termination");
	do {
		LOG_I("Check TCI buffer");

		tci = ctx.tci_msg;
		if (NULL == tci) {
			LOG_E("TCI has not been set up properly - exiting");
			ret = G2DDRM_ERROR_EXIT_FAILED;
			close(g_fd_secmem);
			break;
		}
		LOG_I("Prepare command message in TCI");
		tci->cmd.id = CMD_G2DDRM_TERMINATE;

		mcRet = tlc_communicate(&ctx);
		if (MC_DRV_OK != mcRet) {
			LOG_E("tlc_communicate Error!");
			ret = G2DDRM_ERROR_EXIT_FAILED;
			break;
		}

		if ((RSP_ID(CMD_G2DDRM_TERMINATE) != tci->resp.id)) {
			LOG_E("Trustlet did not send a response : %d", tci->resp.id);
			ret = G2DDRM_ERROR_EXIT_FAILED;
			break;
		}
		LOG_I("Trustlet response is completed");

		if (tci->resp.return_code != RET_TL_G2DDRM_OK) {
			LOG_E("Trustlet did not send a valid return code : %d", tci->resp.return_code);
			ret = G2DDRM_ERROR_EXIT_FAILED;
			break;
		}

		mcRet = tlc_terminate();
		if (MC_DRV_OK != mcRet) {
			LOG_E("Tlc Close Error");
			ret = G2DDRM_ERROR_EXIT_FAILED;
			break;
		}

		LOG_I("Check the Trustlet return code is completed");

		close(g_fd_secmem);
		if (sec_g2d_activate(DRV_ACT) != 0) {
			ret = G2DDRM_ERROR_EXIT_FAILED;
			break;
		}

		ret = G2DDRM_SUCCESS;
	} while (false);

	LOG_I("G2DDRM_Terminate(): secure G2D driver is terminated. ret(%d)", ret);
	return ret;
}
extern "C" g2ddrmResult_t G2DDRM_Blit(struct fimg2d_blit_raw *cmd)
{
	mcResult_t mcRet;
	g2ddrmResult_t ret = G2DDRM_SUCCESS;
	mcBulkMap_t mapInfo;
	struct tciMessage_t *tci = NULL;
	struct secfd_info secfd;

	mapInfo.sVirtualAddr = NULL;

	do {
		secfd.fd = cmd->src.addr.start;
		if (get_fd_phyaddr_from_kernel(&secfd) < 0) {
			LOG_E("fail to get src phyaddr from fd(%d)", secfd.fd);
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}
		cmd->src.addr.start = secfd.phys;

		secfd.fd = cmd->dst.addr.start;
		if (get_fd_phyaddr_from_kernel(&secfd) < 0) {
			LOG_E("fail to get dst phyaddr from fd(%d)", secfd.fd);
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}
		cmd->dst.addr.start = secfd.phys;

		secfd.fd = cmd->dst.plane2.start;
		if (get_fd_phyaddr_from_kernel(&secfd) < 0) {
			LOG_E("fail to get plane2 phyaddr from fd(%d)", secfd.fd);
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}
		cmd->dst.plane2.start = secfd.phys;

		LOG_I("Check TCI buffer");
		tci = ctx.tci_msg;
		if (NULL == tci) {
			LOG_E("TCI has not been set up properly - exiting");
			ret = G2DDRM_ERROR_BLIT_FAILED;
			close(g_fd_secmem);
			break;
		}
		LOG_I("Prepare command message in TCI");

		tci->cmd.id = CMD_G2DDRM_BLIT;
		tci->blit.op = cmd->op;
		tci->blit.param = cmd->param;
		tci->blit.src = cmd->src;
		tci->blit.dst = cmd->dst;
		tci->blit.msk = cmd->msk;
		tci->blit.tmp = cmd->tmp;
		tci->blit.sync = cmd->sync;
		tci->blit.seq_no = cmd->seq_no;

		mcRet = tlc_communicate(&ctx);
		if (MC_DRV_OK != mcRet) {
			LOG_E("tlc_communicate Error!");
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}

		if ((RSP_ID(CMD_G2DDRM_BLIT) != tci->resp.id)) {
			LOG_E("Trustlet did not send a response : %d", tci->resp.id);
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}
		LOG_I("Trustlet response is completed");

		if (tci->resp.return_code != RET_TL_G2DDRM_OK) {
			LOG_E("Trustlet did not send a valid return code : %d", tci->resp.return_code);
			ret = G2DDRM_ERROR_BLIT_FAILED;
			break;
		}
		LOG_I("Check the Trustlet return code is completed");

		ret = G2DDRM_SUCCESS;
	} while (false);

	LOG_I("G2DDRM_Blit(): secure G2D driver blit is done. ret(%d)", ret);
	return ret;
}
extern "C" g2ddrmResult_t G2DDRM_Initialize(void)
{
	mcResult_t mcRet;
	g2ddrmResult_t ret = G2DDRM_SUCCESS;
	struct tciMessage_t *tci = NULL;

	LOG_I("G2DDRM_Initialize(): secure G2D driver initialization");
	do {
		if (sec_g2d_activate(DRV_DEACT) != 0) {
			ret = G2DDRM_ERROR_INIT_FAILED;
			break;
		}

		LOG_I("Open the Trustlet");

		g_fd_secmem = open(SMEM_PATH, O_RDWR);
		if (g_fd_secmem < 0) {
			LOG_E("open S5P-MEM device error");
			ret = G2DDRM_ERROR_INIT_FAILED;
			break;
		}

		mcRet = tlc_initialize();
		if (MC_DRV_OK != mcRet) {
			LOG_E("Tlc Open Error");
			ret = G2DDRM_ERROR_INIT_FAILED;
			close(g_fd_secmem);
			break;
		}

		LOG_I("Check TCI buffer");
		tci = ctx.tci_msg;
		if (NULL == tci) {
			LOG_E("TCI has not been set up properly - exiting");
			ret = G2DDRM_ERROR_INIT_FAILED;
			close(g_fd_secmem);
			break;
		}

		LOG_I("Prepare command message in TCI");
		tci->cmd.id = CMD_G2DDRM_INITIALIZE;
		mcRet = tlc_communicate(&ctx);
		if (MC_DRV_OK != mcRet) {
			LOG_E("tlc_communicate Error!");
			ret = G2DDRM_ERROR_INIT_FAILED;
			close(g_fd_secmem);
			break;
		}

		if ((RSP_ID(CMD_G2DDRM_INITIALIZE) != tci->resp.id)) {
			LOG_E("Trustlet did not send a response : %d", tci->resp.id);
			ret = G2DDRM_ERROR_INIT_FAILED;
			close(g_fd_secmem);
			break;
		}
		LOG_I("Trustlet response is completed");

		if (tci->resp.return_code != RET_TL_G2DDRM_OK) {
			LOG_E("Trustlet did not send a valid return code : %d", tci->resp.return_code);
			ret = G2DDRM_ERROR_INIT_FAILED;
			close(g_fd_secmem);
			break;
		}
		LOG_I("Check the Trustlet return code is completed");

		ret = G2DDRM_SUCCESS;
	} while (false);

	LOG_I("G2DDRM_Initialize(): secure G2D driver is initialized. ret(%d)", ret);
	return ret;
}
/* ------------------------------------------------------------- */
static void tlcProcessCmd(void)
{
	uint32_t ret = TUI_DCI_ERR_INTERNAL_ERROR;
	uint32_t commandId = CMD_TUI_SW_NONE;

	if (NULL == pDci) {
		pr_debug("ERROR tlcProcessCmd: DCI has not been set up properly - exiting\n");
		return;
	} else {
		commandId = pDci->cmdNwd.id;
	}

	/* Warn if previous response was not acknowledged */
	if (CMD_TUI_SW_NONE == commandId) {
		pr_debug("ERROR tlcProcessCmd: Notified without command\n");
		return;
	} else {
		if (pDci->nwdRsp.id != CMD_TUI_SW_NONE)
			pr_debug("tlcProcessCmd: Warning, previous response not ack\n");
	}

	/* Handle command */
	switch (commandId) {
	case CMD_TUI_SW_OPEN_SESSION:
		pr_debug("tlcProcessCmd: CMD_TUI_SW_OPEN_SESSION.\n");

		/* Start android TUI activity */
		ret = sendCmdToUser(TLC_TUI_CMD_START_ACTIVITY);
		if (TUI_DCI_OK == ret) {

			/* allocate TUI frame buffer */
			if (!allocateTuiBuffer(pDci))
				ret = TUI_DCI_ERR_INTERNAL_ERROR;
		}

		break;

	case CMD_TUI_SW_STOP_DISPLAY:
		pr_debug("tlcProcessCmd: CMD_TUI_SW_STOP_DISPLAY.\n");

#ifndef CONFIG_SOC_EXYNOS5420
		/* Set linux TUI flag */
		trustedui_set_mask(TRUSTEDUI_MODE_TUI_SESSION);
#endif
		trustedui_blank_set_counter(0);
#ifdef CONFIG_TRUSTONIC_TRUSTED_UI_FB_BLANK
		blank_framebuffer(1);
		disable_irq(gpio_to_irq(190));
#endif

		trustedui_set_mask(TRUSTEDUI_MODE_VIDEO_SECURED|TRUSTEDUI_MODE_INPUT_SECURED);

		ret = TUI_DCI_OK;
		break;
		
	case CMD_TUI_SW_CLOSE_SESSION:
		pr_debug("tlcProcessCmd: CMD_TUI_SW_CLOSE_SESSION.\n");

		freeTuiBuffer();
		// Protect NWd
		trustedui_clear_mask(TRUSTEDUI_MODE_VIDEO_SECURED|TRUSTEDUI_MODE_INPUT_SECURED);

#ifdef CONFIG_TRUSTONIC_TRUSTED_UI_FB_BLANK
		pr_info("Unblanking");
		enable_irq(gpio_to_irq(190));
		unblank_framebuffer(1);
#endif

		/* Clear linux TUI flag */
		trustedui_set_mode(TRUSTEDUI_MODE_OFF);

#ifdef CONFIG_TRUSTONIC_TRUSTED_UI_FB_BLANK
		pr_info("Unsetting TUI flag (blank counter=%d)", trustedui_blank_get_counter());
		if (0 < trustedui_blank_get_counter()) {
			blank_framebuffer(0);		
		}
#endif

		/* Stop android TUI activity */
		ret = sendCmdToUser(TLC_TUI_CMD_STOP_ACTIVITY);
		break;

	default:
		pr_debug("ERROR tlcProcessCmd: Unknown command %d\n",
				commandId);
		break;
	}

	/* Fill in response to SWd, fill ID LAST */
	pr_debug("tlcProcessCmd: return 0x%08x to cmd 0x%08x\n",
			ret, commandId);
	pDci->nwdRsp.returnCode = ret;
	pDci->nwdRsp.id = RSP_ID(commandId);

	/* Acknowledge command */
	pDci->cmdNwd.id = CMD_TUI_SW_NONE;

	/* Notify SWd */
	pr_debug("DCI RSP NOTIFY CORE\n");
	ret = mc_notify(&drSessionHandle);
	if (MC_DRV_OK != ret)
		pr_debug("ERROR tlcProcessCmd: Notify failed: %d\n", ret);
}
/* ------------------------------------------------------------- */
static void tlc_process_cmd(void)
{
    uint32_t ret = TUI_DCI_ERR_INTERNAL_ERROR;
    uint32_t command_id = CMD_TUI_SW_NONE;
#if defined(CONFIG_SECURE_OS_BOOSTER_API)
    int ret_val = 0;
    u8 retry_cnt = 0;
#endif

    if (NULL == dci) {
        pr_debug("ERROR %s: DCI has not been set up properly - exiting"\
                 "\n", __func__);
        return;
    } else {
        command_id = dci->cmd_nwd.id;
    }

    /* Warn if previous response was not acknowledged */
    if (CMD_TUI_SW_NONE == command_id) {
        pr_debug("ERROR %s: Notified without command\n", __func__);
        return;
    } else {
        if (dci->nwd_rsp.id != CMD_TUI_SW_NONE)
            pr_debug("%s: Warning, previous response not ack\n",
                     __func__);
    }

    /* Handle command */
    switch (command_id) {
    case CMD_TUI_SW_OPEN_SESSION:
        pr_debug("%s: CMD_TUI_SW_OPEN_SESSION.\n", __func__);
#if defined(CONFIG_SECURE_OS_BOOSTER_API)
        pr_info("%s TUI_CPU_SPEEDUP ON retry: %d\n",
                __func__, retry_cnt);
        do {
            ret_val = secos_booster_start(MAX_PERFORMANCE);
            retry_cnt++;
            if (ret_val) {
                pr_err("%s: booster start failed. (%d) retry: %d\n"
                       , __func__, ret_val, retry_cnt);
                if (retry_cnt < 7)
                    usleep_range(500, 510);
            }
        } while (ret_val && retry_cnt < 7);
#endif

        /* Start android TUI activity */
        ret = send_cmd_to_user(TLC_TUI_CMD_START_ACTIVITY);
        if (TUI_DCI_OK != ret)
            break;

        /* allocate TUI frame buffer */
        ret = hal_tui_alloc(dci->nwd_rsp.alloc_buffer,
                            dci->cmd_nwd.payload.alloc_data.alloc_size,
                            dci->cmd_nwd.payload.alloc_data.num_of_buff);

        if (TUI_DCI_OK != ret) {
            pr_err("%s: hal_tui_alloc error : %d\n", __func__ ,ret);
            /* no need to call tui_i2c_reset, because there will be no TUI
             * session */
            //tui_i2c_reset();
            send_cmd_to_user(TLC_TUI_CMD_STOP_ACTIVITY);
            break;
        }

        /* Deactivate linux UI drivers */
        ret = hal_tui_deactivate();

        if (TUI_DCI_OK != ret) {
            pr_err("%s: hal_tui_deactivate error : %d\n", __func__ ,ret);
            hal_tui_free();
            send_cmd_to_user(TLC_TUI_CMD_STOP_ACTIVITY);
            break;
        }
        break;

    case CMD_TUI_SW_CLOSE_SESSION:
        pr_debug("%s: CMD_TUI_SW_CLOSE_SESSION.\n", __func__);

        /* Activate linux UI drivers */
        ret = hal_tui_activate();

        hal_tui_free();

#if defined(CONFIG_SECURE_OS_BOOSTER_API)
        ret_val = secos_booster_stop();
        if (ret_val)
            pr_err("%s: booster stop failed. (%d)\n"
                   , __func__, ret_val);
#endif
        /* Stop android TUI activity */
        ret = send_cmd_to_user(TLC_TUI_CMD_STOP_ACTIVITY);
        break;

    default:
        pr_debug("ERROR %s: Unknown command %d\n",
                 __func__, command_id);
        break;
    }

    /* Fill in response to SWd, fill ID LAST */
    pr_debug("%s: return 0x%08x to cmd 0x%08x\n",
             __func__, ret, command_id);
    dci->nwd_rsp.return_code = ret;
    dci->nwd_rsp.id = RSP_ID(command_id);

    /* Acknowledge command */
    dci->cmd_nwd.id = CMD_TUI_SW_NONE;

    /* Notify SWd */
    pr_debug("DCI RSP NOTIFY CORE\n");
    ret = mc_notify(&dr_session_handle);
    if (MC_DRV_OK != ret)
        pr_debug("ERROR %s: Notify failed: %d\n", __func__, ret);
}
/* ------------------------------------------------------------- */
static void tlcProcessCmd(void)
{
	uint32_t ret = TUI_DCI_ERR_INTERNAL_ERROR;
	uint32_t commandId = CMD_TUI_SW_NONE;

	pDci->cmdNwd.payload.allocData.numOfBuff = TUI_BUFFER_NUM;

	if (NULL == pDci) {
		pr_debug("ERROR tlcProcessCmd: DCI has not been set up properly - exiting\n");
		return;
	} else {
		commandId = pDci->cmdNwd.id;
	}

	/* Warn if previous response was not acknowledged */
	if (CMD_TUI_SW_NONE == commandId) {
		pr_debug("ERROR tlcProcessCmd: Notified without command\n");
		return;
	} else {
		if (pDci->nwdRsp.id != CMD_TUI_SW_NONE)
			pr_debug("tlcProcessCmd: Warning, previous response not ack\n");
	}

	/* Handle command */
	switch (commandId) {
	case CMD_TUI_SW_OPEN_SESSION:
		printk(KERN_ERR "tlcProcessCmd: CMD_TUI_SW_OPEN_SESSION.\n");

		/* Start android TUI activity */
		ret = sendCmdToUser(TLC_TUI_CMD_START_ACTIVITY);
		if (TUI_DCI_OK == ret) {

			/* allocate TUI frame buffer */
			ret = hal_tui_alloc(&pDci->nwdRsp.allocBuffer[MAX_DCI_BUFFER_NUMBER],
					pDci->cmdNwd.payload.allocData.allocSize,
					pDci->cmdNwd.payload.allocData.numOfBuff);

			printk(KERN_ERR "tlcProcessCmd: CMD_TUI_SW_OPEN_SESSION & disable_irq(%d);.\n",tsp_irq_num);
			disable_irq(tsp_irq_num);
			msleep(100); // temp code
		}
		hal_tui_video_space_alloc();

		pDci->nwdRsp.allocBuffer[0].pa = g_sec_tuiMemPool.pa;
		pDci->nwdRsp.allocBuffer[1].pa = (g_sec_tuiMemPool.pa + g_sec_tuiMemPool.size/2);

		pDci->cmdNwd.payload.allocData.allocSize = g_sec_tuiMemPool.size;

		break;

	case CMD_TUI_SW_STOP_DISPLAY:
		printk(KERN_ERR "tlcProcessCmd: CMD_TUI_SW_STOP_DISPLAY.\n");

		/* Deactivate linux UI drivers */
		ret = hal_tui_deactivate();

		break;

	case CMD_TUI_SW_CLOSE_SESSION:
		printk(KERN_ERR "tlcProcessCmd: CMD_TUI_SW_CLOSE_SESSION & enable_irq(%d).\n", tsp_irq_num);

		disable_irq(pwr_irq_num);
		/* Activate linux UI drivers */
		ret = hal_tui_activate();
		tui_i2c_reset();
		enable_irq(tsp_irq_num);
		hal_tui_free();
		enable_irq(pwr_irq_num);

		/* Stop android TUI activity */
		ret = sendCmdToUser(TLC_TUI_CMD_STOP_ACTIVITY);
		break;

	default:
		pr_debug("ERROR tlcProcessCmd: Unknown command %d\n",
				commandId);
		break;
	}

	/* Fill in response to SWd, fill ID LAST */
	pr_debug("tlcProcessCmd: return 0x%08x to cmd 0x%08x\n",
			ret, commandId);
	pDci->nwdRsp.returnCode = ret;
	pDci->nwdRsp.id = RSP_ID(commandId);

	/* Acknowledge command */
	pDci->cmdNwd.id = CMD_TUI_SW_NONE;

	/* Notify SWd */
	pr_debug("DCI RSP NOTIFY CORE\n");
	ret = mc_notify(&drSessionHandle);
	if (MC_DRV_OK != ret)
		pr_debug("ERROR tlcProcessCmd: Notify failed: %d\n", ret);
}