static int setup_rdma_sec(DISP_MODULE_ENUM module, disp_ddp_path_config* pConfig, void *handle)
{
static int rdma_is_sec[2];
CMDQ_ENG_ENUM cmdq_engine;
int rdma_idx = rdma_index(module);
DISP_BUFFER_TYPE security = pConfig->rdma_config.security;
enum RDMA_MODE mode = rdma_config_mode(pConfig->rdma_config.address);
cmdq_engine = rdma_idx==0 ? CMDQ_ENG_DISP_RDMA0 : CMDQ_ENG_DISP_RDMA1;
if(!handle) {
DDPMSG("[SVP] bypass rdma sec setting sec=%d,handle=NULL\n", security);
return 0;
}
/* sec setting make sence only in memory mode ! */
if(mode == RDMA_MODE_MEMORY) {
if(security == DISP_SECURE_BUFFER) {
cmdqRecSetSecure(handle, 1);
/* set engine as sec */
cmdqRecSecureEnablePortSecurity(handle, (1LL << cmdq_engine));
//cmdqRecSecureEnableDAPC(handle, (1LL << cmdq_engine));
if(rdma_is_sec[rdma_idx] == 0)
DDPMSG("[SVP] switch rdma%d to sec\n", rdma_idx);
rdma_is_sec[rdma_idx] = 1;
} else {
if(rdma_is_sec[rdma_idx]) {
/* rdma is in sec stat, we need to switch it to nonsec */
cmdqRecHandle nonsec_switch_handle;
int ret;
ret = cmdqRecCreate(CMDQ_SCENARIO_DISP_PRIMARY_DISABLE_SECURE_PATH, &(nonsec_switch_handle));
if(ret)
DDPAEE("[SVP]fail to create disable handle %s ret=%d\n", __FUNCTION__, ret);
cmdqRecReset(nonsec_switch_handle);
_cmdq_insert_wait_frame_done_token_mira(nonsec_switch_handle);
cmdqRecSetSecure(nonsec_switch_handle, 1);
/*ugly work around by kzhang !!. will remove when cmdq delete disable scenario.
* To avoid translation fault like ovl (see notes in ovl.c)*/
do_rdma_config_l(module, pConfig, nonsec_switch_handle);
/*in fact, dapc/port_sec will be disabled by cmdq*/
cmdqRecSecureEnablePortSecurity(nonsec_switch_handle, (1LL << cmdq_engine));
//cmdqRecSecureEnableDAPC(nonsec_switch_handle, (1LL << cmdq_engine));
cmdqRecFlush(nonsec_switch_handle);
cmdqRecDestroy(nonsec_switch_handle);
DDPMSG("[SVP] switch rdma%d to nonsec done\n", rdma_idx);
}
rdma_is_sec[rdma_idx] = 0;
}
}
return 0;
}
static void _cmdq_flush_config_handle(int blocking, void *callback, unsigned int userdata)
{
if(blocking )
cmdqRecFlush(pgc->cmdq_handle_config); // it will be blocked until mutex done
else
{
if(callback)
cmdqRecFlushAsyncCallback(pgc->cmdq_handle_config, callback, userdata);
else
cmdqRecFlushAsync(pgc->cmdq_handle_config);
}
//dprec_event_op(DPREC_EVENT_CMDQ_FLUSH);
}
unsigned int disp_set_pll_by_cmdq(unsigned int freq, void *cmdq_handle)
{
unsigned long reg_va_con0 = 0;
unsigned long reg_va_con1 = 0;
static unsigned int freq_last = 364;
static unsigned int pll_cnt;
unsigned int i = 0;
if (freq == freq_last)
/* return; */
freq_last = freq;
reg_va_con0 =
(unsigned long)ioremap_nocache(REG_PA_VENC_PLL_CON0,
sizeof(unsigned long));
reg_va_con1 =
(unsigned long)ioremap_nocache(REG_PA_VENC_PLL_CON1,
sizeof(unsigned long));
pr_debug
("disp_set_pll(%d), before set, con0=0x%x, con1=0x%x, 0x%lx, 0x%lx\n",
freq, DISP_REG_GET(reg_va_con0), DISP_REG_GET(reg_va_con1),
reg_va_con0, reg_va_con1);
cmdqRecWaitNoClear(cmdq_handle, CMDQ_EVENT_MUTEX0_STREAM_EOF);
if (freq == 156) {
enable_pll(VENCPLL, DISP_CLOCK_USER_NAME);
DISP_CPU_REG_SET(reg_va_con0, DISP_MMCLK_156MHZ_CON0);
DISP_CPU_REG_SET(reg_va_con1, DISP_MMCLK_156MHZ_CON1);
pll_cnt++;
/* set mux to 3 by CMDQ */
DISP_REG_SET_PA(cmdq_handle, 0x10000048, 0x3000000);
DISP_REG_SET_PA(cmdq_handle, 0x10000044, 0x3000000);
DISP_REG_SET_PA(cmdq_handle, 0x10000004, 8);
} else if (freq == 182) {
/*NOT USE*/
} else if (freq == 364) {
/* set mux to 1 by CMDQ */
DISP_REG_SET_PA(cmdq_handle, 0x10000048, 0x3000000);
DISP_REG_SET_PA(cmdq_handle, 0x10000044, 0x1000000);
DISP_REG_SET_PA(cmdq_handle, 0x10000004, 8);
} else {
pr_debug("disp_set_pll, error, invalid freq=%d\n", freq);
}
/* cmdqRecDumpCommand(cmdq_handle); */
cmdqRecFlush(cmdq_handle);
if (freq == 364) {
if (pll_cnt != 0) {
disable_pll(VENCPLL, DISP_CLOCK_USER_NAME);
pll_cnt--;
}
}
pr_debug("disp_set_pll(%d), after set, con0=0x%x, con1=0x%x\n",
freq, DISP_REG_GET(reg_va_con0), DISP_REG_GET(reg_va_con1));
iounmap((void *)reg_va_con0);
iounmap((void *)reg_va_con1);
return 0; /* cmdqRecEstimateEommandExecTime(cmdq_handle); */
}
static int jpeg_dec_ioctl(unsigned int cmd, unsigned long arg, struct file *file)
{
unsigned int* pStatus;
unsigned int decResult;
long timeout_jiff;
JPEG_DEC_DRV_IN dec_params;
JPEG_DEC_CONFIG_ROW dec_row_params ;
JPEG_DEC_CONFIG_CMDQ cfg_cmdq_params ;
unsigned int irq_st = 0;
unsigned int i = 0;
//unsigned int timeout = 0x1FFFFF;
JPEG_DEC_DRV_OUT outParams;
pStatus = (unsigned int*)file->private_data;
if (NULL == pStatus)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder: Private data is null in flush operation. SOME THING WRONG??\n");
return -EFAULT;
}
switch(cmd)
{
// initial and reset JPEG encoder
case JPEG_DEC_IOCTL_INIT: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Init!!\n");
if(jpeg_drv_dec_init() == 0)
{
*pStatus = JPEG_DEC_PROCESS;
}
break;
case JPEG_DEC_IOCTL_RESET: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Reset!!\n");
jpeg_drv_dec_reset();
break;
case JPEG_DEC_IOCTL_CONFIG:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Configration!!\n");
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_MSG("[JPEGDRV]Permission Denied! This process can not access decoder\n");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder is unlocked!!");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&dec_params, (void *)arg, sizeof(JPEG_DEC_DRV_IN)))
{
JPEG_MSG("[JPEGDRV]JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
//_jpeg_dec_dump_reg_en = dec_params.regDecDumpEn;
if(dec_params.decodeMode == JPEG_DEC_MODE_MCU_ROW)
_jpeg_dec_mode = 1;
else
_jpeg_dec_mode = 0;
if (jpeg_drv_dec_set_config_data(&dec_params) < 0)
return -EFAULT;
break;
case JPEG_DEC_IOCTL_FLUSH_CMDQ :
JPEG_MSG("[JPEGDRV]enter JPEG BUILD CMDQ !!\n");
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_MSG("[JPEGDRV]Permission Denied! This process can not access decoder\n");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder is unlocked!!");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&cfg_cmdq_params, (void *)arg, sizeof(JPEG_DEC_CONFIG_CMDQ)))
{
JPEG_MSG("[JPEGDRV]JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
JPEG_MSG("[JPEGDRV]JPEG CREATE CMDQ !!\n");
cmdqRecCreate(CMDQ_SCENARIO_JPEG_DEC, &jpegCMDQ_handle) ;
cmdqRecWait(jpegCMDQ_handle, CMDQ_EVENT_JPEG_DEC_EOF) ;
for( i = 0 ; i < cfg_cmdq_params.goNum ; i++ ){
JPEG_MSG("[JPEGDRV]JPEG gen CMDQ %x %x %x %x !!\n", cfg_cmdq_params.pauseMCUidx[i],
cfg_cmdq_params.decRowBuf0[i], cfg_cmdq_params.decRowBuf1[i], cfg_cmdq_params.decRowBuf2[i]);
cmdqRecWrite(jpegCMDQ_handle, 0x18004170 /*REG_ADDR_JPGDEC_PAUSE_MCU_NUM*/, cfg_cmdq_params.pauseMCUidx[i]-1 , 0xFFFFFFFF) ;
cmdqRecWrite(jpegCMDQ_handle, 0x18004140 /*REG_ADDR_JPGDEC_DEST_ADDR0_Y */, cfg_cmdq_params.decRowBuf0[i] , 0xFFFFFFFF) ;
cmdqRecWrite(jpegCMDQ_handle, 0x18004144 /*REG_ADDR_JPGDEC_DEST_ADDR0_U */, cfg_cmdq_params.decRowBuf1[i] , 0xFFFFFFFF) ;
cmdqRecWrite(jpegCMDQ_handle, 0x18004148 /*REG_ADDR_JPGDEC_DEST_ADDR0_V */, cfg_cmdq_params.decRowBuf2[i] , 0xFFFFFFFF) ;
JPEG_MSG("[JPEGDRV]JPEG gen CMDQ go!!\n");
//trigger
cmdqRecWrite(jpegCMDQ_handle, 0x18004274 /*REG_ADDR_JPGDEC_INTERRUPT_STATUS*/ , BIT_INQST_MASK_PAUSE , 0xFFFFFFFF) ;
JPEG_MSG("[JPEGDRV]JPEG gen CMDQ wait!!\n");
//wait frame done
cmdqRecWait(jpegCMDQ_handle, CMDQ_EVENT_JPEG_DEC_EOF) ;
//cmdqRecPoll(jpegCMDQ_handle, 0x18004274 /*REG_ADDR_JPGDEC_INTERRUPT_STATUS*/ , BIT_INQST_MASK_PAUSE , 0x0010) ;
}
JPEG_MSG("[JPEGDRV]JPEG flush CMDQ start!!\n");
cmdqRecFlush(jpegCMDQ_handle) ;
JPEG_MSG("[JPEGDRV]JPEG flush CMDQ end!!\n");
cmdqRecDestroy(jpegCMDQ_handle) ;
JPEG_MSG("[JPEGDRV]JPEG destroy CMDQ end!!\n");
break;
case JPEG_DEC_IOCTL_RESUME:
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_MSG("[JPEGDRV]Permission Denied! This process can not access decoder\n");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder is unlocked!!");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&dec_row_params, (void *)arg, sizeof(JPEG_DEC_CONFIG_ROW)))
{
JPEG_MSG("[JPEGDRV]JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Resume, [%d] %x %x %x !!\n", dec_row_params.pauseMCU -1,dec_row_params.decRowBuf[0], dec_row_params.decRowBuf[1], dec_row_params.decRowBuf[2]);
jpeg_drv_dec_set_dst_bank0( dec_row_params.decRowBuf[0], dec_row_params.decRowBuf[1], dec_row_params.decRowBuf[2]);
jpeg_drv_dec_set_pause_mcu_idx(dec_row_params.pauseMCU -1) ;
// lock CPU to ensure irq is enabled after trigger HW
spin_lock(&jpeg_dec_lock);
jpeg_drv_dec_resume(BIT_INQST_MASK_PAUSE);
spin_unlock(&jpeg_dec_lock);
break;
case JPEG_DEC_IOCTL_START: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Start!!\n");
//Debug: printk("0xF0: 0x%08x\n", *(volatile unsigned int*)(JPEG_DEC_BASE + 0xF0));
jpeg_drv_dec_start();
break;
case JPEG_DEC_IOCTL_WAIT:
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access decoder");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_WRN("Decoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&outParams, (void *)arg, sizeof(JPEG_DEC_DRV_OUT)))
{
JPEG_WRN("JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
//set timeout
timeout_jiff = outParams.timeout* HZ / 1000;
//JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Wait Resume Time Jiffies : %ld\n", timeout_jiff);
#ifdef FPGA_VERSION
//#if 1
JPEG_MSG("[JPEGDRV]Polling JPEG Status");
do
{
_jpeg_dec_int_status = REG_JPGDEC_INTERRUPT_STATUS;
} while(_jpeg_dec_int_status == 0);
#else
//if(outParams.timeout >= 5000){
//
// JPEG_MSG("Polling JPEG Status");
// do
// {
// _jpeg_dec_int_status = REG_JPGDEC_INTERRUPT_STATUS;
// timeout--;
// } while(_jpeg_dec_int_status == 0 && timeout != 0);
// if(timeout == 0) JPEG_MSG("Polling JPEG Status TIMEOUT!!\n");
//}else
if(jpeg_isr_dec_lisr()<0){
//JPEG_MSG("wait JPEG irq\n");
wait_event_interruptible_timeout(dec_wait_queue, _jpeg_dec_int_status, timeout_jiff);
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Enter IRQ Wait Done!!\n");
//printk("[JPEGDRV]wait JPEG irq done\n");
}else{
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Enter IRQ Wait Already Done!!\n");
//printk("[JPEGDRV]JPEG decoder already done\n");
}
#endif
decResult = jpeg_drv_dec_get_result();
//jpeg_drv_dec_dump_key_reg();
if(decResult >= 2)
{
JPEG_MSG("[JPEGDRV]Decode Result : %d, status %x!\n", decResult, _jpeg_dec_int_status );
jpeg_drv_dec_dump_key_reg();
//jpeg_drv_dec_dump_reg();
jpeg_drv_dec_reset();
}
irq_st = _jpeg_dec_int_status ;
decResult = decResult | (irq_st<<8) ;
_jpeg_dec_int_status = 0;
if(copy_to_user(outParams.result, &decResult, sizeof(unsigned int)))
{
JPEG_WRN("JPEG Decoder : Copy to user error (result)\n");
return -EFAULT;
}
break;
case JPEG_DEC_IOCTL_BREAK:
if (jpeg_drv_dec_break() < 0)
return -EFAULT;
break;
case JPEG_DEC_IOCTL_DUMP_REG:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder DUMP REGISTER !!\n");
jpeg_drv_dec_dump_reg();
break;
case JPEG_DEC_IOCTL_DEINIT:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Deinit !!\n");
// copy input parameters
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_ERR("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_ERR("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
jpeg_drv_dec_deinit();
*pStatus = 0;
break;
#ifdef FOR_COMPILE
case JPEG_DEC_IOCTL_RW_REG: /* OT:OK */
jpeg_drv_dec_rw_reg();
break;
#endif
default:
JPEG_ERR("JPEG DEC IOCTL NO THIS COMMAND\n");
break;
}
return 0;
}
