static int close_tplay_driver_connection(void)
{
enum mc_result mcRet = MC_DRV_OK;
DDPDBG("=============== close tplay TDriver session ===============\n");
/* Close session*/
if (tplaySessionHandle.session_id != 0) // we have an valid session
{
mcRet = mc_close_session(&tplaySessionHandle);
if (MC_DRV_OK != mcRet)
{
DDPERR("mc_close_session failed: %d @%s line %d\n", mcRet, __func__, __LINE__);
memset(&tplaySessionHandle, 0, sizeof(tplaySessionHandle)); // clear handle value anyway
return -1;
}
}
memset(&tplaySessionHandle, 0, sizeof(tplaySessionHandle));
mcRet = mc_free_wsm(mc_deviceId, (uint8_t *)pTplayTci);
if (MC_DRV_OK != mcRet)
{
DDPERR("mc_free_wsm failed: %d @%s line %d\n", mcRet, __func__, __LINE__);
return -1;
}
return 0;
}
//Close trustlet and driver
static int secwidevinemdw_session_close(void)
{
enum mc_result mc_ret = MC_DRV_OK;
mutex_lock(&secwidevinemdw_lock);
do {
/* session is already closed ? */
if (secwidevinemdw_session_ref == 0)
{
MSG(WRN, "secwidevinemdw_session already closed\n");
break;
}
if (secwidevinemdw_session_ref > 1)
{
secwidevinemdw_session_ref--;
break;
}
/* close session */
mc_ret = mc_close_session(&secwidevinemdwdr_session);
/* free WSM for DCI */
mc_ret = mc_free_wsm(secwidevinemdw_devid, (uint8_t*) secwidevinemdw_dci);
secwidevinemdw_dci = NULL;
secwidevinemdw_session_ref = 0;
/* close device */
mc_ret = mc_close_device(secwidevinemdw_devid);
if (MC_DRV_OK != mc_ret)
{
MSG(ERR, "mc_close_device failed: %d\n", mc_ret);
}
} while(0);
MSG(INFO, "secwidevinemdw_session_close: ret=%d, ref=%d\n", mc_ret, secwidevinemdw_session_ref);
mutex_unlock(&secwidevinemdw_lock);
if (MC_DRV_OK != mc_ret)
{
return -ENXIO;
}
return 0;
}
int32_t cmdq_sec_free_wsm_impl(uint32_t deviceId, uint8_t **ppWsm)
{
int32_t status = 0;
enum mc_result mcRet = mc_free_wsm(deviceId, (*ppWsm));
(*ppWsm) = (MC_DRV_OK == mcRet) ? (NULL) : (*ppWsm);
CMDQ_VERBOSE("_WSM_FREE: ret[0x%x], *ppWsm[0x%p]\n", mcRet, (*ppWsm));
if (MC_DRV_OK != mcRet) {
CMDQ_ERR("_WSM_FREE: err[0x%x]", mcRet);
status = -1;
}
return status;
}
/* DO NOT invoke this function unless you get HACC lock */
int close_sdriver_connection(void)
{
enum mc_result mcRet = 0;
do
{
/* Close session*/
mcRet = mc_close_session(&drSessionHandle);
if (MC_DRV_OK != mcRet)
{
printk("NWD HACC: mc_close_session failed: %d\n", mcRet);
break;
}
printk("NWD HACC: mc_close_session success: %d\n", mcRet);
memset(&drSessionHandle, 0, sizeof(drSessionHandle));
/* Free WSM for DCI */
mcRet = mc_free_wsm(deviceId, (uint8_t *)pTci);
if (MC_DRV_OK != mcRet)
{
printk("NWD HACC: mc_free_wsm failed: %d\n", mcRet);
break;
}
pTci = NULL;
/* Close MobiCore device */
mcRet = mc_close_device(deviceId);
if (MC_DRV_OK != mcRet)
{
printk("NWD HACC: mc_close_device failed: %d\n", mcRet);
break;
}
printk("NWD HACC: mc_close_device success: %d\n", mcRet);
}while(false);
if (MC_DRV_OK != mcRet)
{
return -1;
}
return 0;
}
//Open driver in open
static int secwidevine_session_open(void)
{
enum mc_result mc_ret = MC_DRV_OK;
mutex_lock(&secwidevine_lock);
do {
/* sessions reach max numbers ? */
if (secwidevine_session_ref > MAX_OPEN_SESSIONS)
{
MSG(WRN, "secwidevine_session > 0x%x\n", MAX_OPEN_SESSIONS);
break;
}
if (secwidevine_session_ref > 0)
{
secwidevine_session_ref++;
break;
}
/* open device */
mc_ret = mc_open_device(secwidevine_devid);
if (MC_DRV_OK != mc_ret)
{
MSG(ERR, "mc_open_device failed: %d\n", mc_ret);
break;
}
/* allocating WSM for DCI */
/*//open trustlet
mc_ret = mc_malloc_wsm(secwidevine_devid, 0, sizeof(tci_t),
(uint8_t **)&secwidevine_tci, 0);
if (MC_DRV_OK != mc_ret) {
mc_close_device(secwidevine_devid);
MSG(ERR, "mc_malloc_wsm failed: %d\n", mc_ret);
break;
}
// open session
secwidevine_session.device_id = secwidevine_devid;
mc_ret = mc_open_session(&secwidevine_session, &secwidevine_uuid,
(uint8_t *)secwidevine_tci, sizeof(tci_t));
if (MC_DRV_OK != mc_ret)
{
mc_free_wsm(secwidevine_devid, (uint8_t *)secwidevine_tci);
secwidevine_tci = NULL;
mc_close_device(secwidevine_devid);
MSG(ERR, "mc_open_session failed: %d\n", mc_ret);
break;
}*/
//open driver
mc_ret = mc_malloc_wsm(secwidevine_devid, 0, sizeof(tci_t), (uint8_t **) &secwidevinedr_tci,
0);
if (MC_DRV_OK != mc_ret)
{
/*mc_free_wsm(secwidevine_devid, (uint8_t *) secwidevine_tci);
secwidevine_tci = NULL;*/
mc_close_device(secwidevine_devid);
MSG(ERR, "2.mc_malloc_wsm failed: %d\n", mc_ret);
break;
}
/* open session */
secwidevinedr_session.device_id = secwidevine_devid;
mc_ret = mc_open_session(&secwidevinedr_session, &secwidevinedr_uuid,
(uint8_t *) secwidevinedr_tci, sizeof(tci_t));
if (MC_DRV_OK != mc_ret)
{
/* mc_free_wsm(secwidevine_devid, (uint8_t *) secwidevine_tci);
secwidevine_tci = NULL;*/
mc_free_wsm(secwidevine_devid, (uint8_t *) secwidevinedr_tci);
secwidevinedr_tci = NULL;
mc_close_device(secwidevine_devid);
MSG(ERR, "2.mc_open_session failed: %d\n", mc_ret);
break;
}
secwidevine_session_ref = 1;
} while(0);
MSG(INFO, "secwidevine_session_open: ret=%d, ref=%d\n", mc_ret, secwidevine_session_ref);
MSG(INFO, "driver sessionId = %d, deviceId = %d\n",
secwidevinedr_session.session_id, secwidevinedr_session.device_id);
mutex_unlock(&secwidevine_lock);
if (MC_DRV_OK != mc_ret)
{
MSG(ERR, "secwidevine_session_open fail");
return -ENXIO;
}
return 0;
}
//Open driver in open
static int secwidevinemdw_session_open(void)
{
enum mc_result mc_ret = MC_DRV_OK;
mutex_lock(&secwidevinemdw_lock);
do {
/* sessions reach max numbers ? */
if (secwidevinemdw_session_ref > MAX_OPEN_SESSIONS)
{
MSG(WRN, "secwidevinemdw_session > 0x%x\n", MAX_OPEN_SESSIONS);
break;
}
if (secwidevinemdw_session_ref > 0)
{
MSG(WRN, "secwidevinemdw_session already open");
secwidevinemdw_session_ref++;
break;
}
/* open device */
mc_ret = mc_open_device(secwidevinemdw_devid);
if (MC_DRV_OK != mc_ret)
{
MSG(ERR, "mc_open_device failed: %d\n", mc_ret);
break;
}
/* allocating WSM for DCI */
mc_ret = mc_malloc_wsm(secwidevinemdw_devid, 0, sizeof(dciMessage_t),
(uint8_t **)&secwidevinemdw_dci, 0);
if (MC_DRV_OK != mc_ret) {
mc_close_device(secwidevinemdw_devid);
MSG(ERR, "mc_malloc_wsm failed: %d\n", mc_ret);
break;
}
// open session
secwidevinemdwdr_session.device_id = secwidevinemdw_devid;
mc_ret = mc_open_session(&secwidevinemdwdr_session, &secwidevinemdw_uuid,
(uint8_t *)secwidevinemdw_dci, sizeof(dciMessage_t));
if (MC_DRV_OK != mc_ret)
{
mc_free_wsm(secwidevinemdw_devid, (uint8_t *)secwidevinemdw_dci);
secwidevinemdw_dci = NULL;
mc_close_device(secwidevinemdw_devid);
MSG(ERR, "mc_open_session failed: %d\n", mc_ret);
break;
}
/* create a thread for listening DCI signals */
secwidevinemdwDci_th = kthread_run(secwidevinemdw_listenDci, NULL, "secwidevinemdw_Dci");
if (IS_ERR(secwidevinemdwDci_th))
{
mc_close_session(&secwidevinemdwdr_session);
mc_free_wsm(secwidevinemdw_devid, (uint8_t *) secwidevinemdw_dci);
secwidevinemdw_dci = NULL;
mc_close_device(secwidevinemdw_devid);
MSG(ERR, "%s, init kthread_run failed!\n", __func__);
break;
}
secwidevinemdw_session_ref = 1;
} while(0);
MSG(INFO, "secwidevinemdw_session_open: ret=%d, ref=%d\n", mc_ret, secwidevinemdw_session_ref);
MSG(INFO, "driver sessionId = %d, deviceId = %d\n",
secwidevinemdwdr_session.session_id, secwidevinemdwdr_session.device_id);
mutex_unlock(&secwidevinemdw_lock);
if (MC_DRV_OK != mc_ret)
{
MSG(ERR, "secwidevinemdw_session_open fail");
return -ENXIO;
}
return 0;
}
