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; }