/* ------------------------------------------------------------- */
static bool tlcOpen(void)
{
bool ret = false;
enum mc_result mcRet;
/* Open the tbase device */
pr_debug("tlcOpen: Opening tbase device\n");
mcRet = mc_open_device(DEVICE_ID);
/* In case the device is already open, mc_open_device will return an
* error (MC_DRV_ERR_INVALID_OPERATION). But in this case, we can
* continue, even though mc_open_device returned an error. Stop in all
* other case of error
*/
if (MC_DRV_OK != mcRet && MC_DRV_ERR_INVALID_OPERATION != mcRet) {
pr_debug("ERROR tlcOpen: Error %d opening device\n", mcRet);
return false;
}
pr_debug("tlcOpen: Opening driver session\n");
ret = tlcOpenDriver();
return ret;
}
//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;
}
