/* * Get the current cursor position. * Params: * state->ebx - pointer to user int where row value should be stored * state->ecx - pointer to user int where column value should be stored * Returns: 0 if successful, -1 otherwise */ static int Sys_GetCursor(struct Interrupt_State *state) { int row, col; Get_Cursor(&row, &col); if (!Copy_To_User(state->ebx, &row, sizeof(int)) || !Copy_To_User(state->ecx, &col, sizeof(int))) return -1; return 0; }
/* * Get the current cursor position. * Params: * state->ebx - pointer to user int where row value should be stored * state->ecx - pointer to user int where column value should be stored * Returns: 0 if successful, -1 otherwise */ static int Sys_GetCursor(struct Interrupt_State* state) { int row, col; Get_Cursor(&row, &col); Copy_To_User(state->ebx, &row, sizeof(int)); Copy_To_User(state->ecx, &col, sizeof(int)); return 0; //TODO("GetCursor system call"); }
/* * Get the current cursor position. * Params: * state->ebx - pointer to user int where row value should be stored * state->ecx - pointer to user int where column value should be stored * Returns: 0 if successful, -1 otherwise */ static int Sys_GetCursor(struct Interrupt_State* state) { int r=0, c=0; Get_Cursor(&r, &c); if (!Copy_To_User(state->ebx, &r, sizeof(int))) { return -1; } if (!Copy_To_User(state->ecx, &c, sizeof(int))) { return -1; } return 0; }
/* * Read a directory entry from an open directory handle. * Params: * state->ebx - file descriptor of the directory * state->ecx - user address of struct VFS_Dir_Entry to copy entry into * Returns: 0 if successful, error code (< 0) if unsuccessful */ static int Sys_ReadEntry(struct Interrupt_State *state) { int bytes_written = 0; /* where is the file table? */ if(state->ebx > USER_MAX_FILES) { return EINVALID; } if( g_currentThread->userContext->file_descriptor_table[state->ebx] ) { void *data_buffer = Malloc(sizeof(struct VFS_Dir_Entry)); if(!data_buffer) { return ENOMEM; } Enable_Interrupts(); bytes_written = Read_Entry(g_currentThread->userContext->file_descriptor_table[state->ebx], data_buffer); Disable_Interrupts(); if(bytes_written < 0) { Free(data_buffer); return bytes_written; } if (!Copy_To_User(state->ecx, data_buffer, sizeof(struct VFS_Dir_Entry))) { Free(data_buffer); return EINVALID; } Free(data_buffer); return bytes_written; } else { return ENOTFOUND; } }
/* * Get information about the running processes * Params: * state->ebx - pointer to user memory containing an array of * Process_Info structs * state->ecx - length of the passed in array in memory * Returns: -1 on failure * 0 if size of user memory too small * N the number of entries in the table, on success */ static int Sys_PS(struct Interrupt_State* state) { struct Process_Info procInfo[50] = {'\0', }; Dump_All_Thread_List(procInfo); Copy_To_User(state->ebx, procInfo, state->ecx*sizeof(struct Process_Info)); return 0; //TODO("Sys_PS system call"); }
/* * Reap a child process that has died * Params: * state->ebx - pointer to status of process reaped * Returns: pid of reaped process on success, -1 on error. */ static int Sys_WaitNoPID(struct Interrupt_State* state) { int status = 0; Print("Sys_WaitNoPID : %x\n", state->ebx); status = 0x7; Copy_To_User(state->ebx, &status, sizeof(int)); return -1; //WaitNoPID(&status); //TODO("Sys_WaitNoPID system call"); }
static int Sys_GetCwd(struct Interrupt_State *state) { char spath[VFS_MAX_PATH_LEN] = {'\0', }; int rc; Enable_Interrupts(); rc = Get_Path(Get_Cwd(), spath); Disable_Interrupts(); Copy_To_User(state->ebx, spath, state->ecx); return rc; }
/* * Get file metadata. * Params: * state->ebx - address of user string containing path of file * state->ecx - length of path * state->edx - user address of struct VFS_File_Stat object to store metadata in * * Returns: 0 if successful, error code (< 0) if unsuccessful */ static int Sys_Stat(struct Interrupt_State *state) { char *path; int rc = get_path_from_registers(state->ebx, state->ecx, &path); struct VFS_File_Stat vfs; Enable_Interrupts(); rc = Stat(path, &vfs); Free(path); Disable_Interrupts(); if(rc == 0) { if (!Copy_To_User(state->edx, &vfs, sizeof(struct VFS_File_Stat))) { return EINVALID; } } return rc; }
/* * Reap a child process that has died * Params: * state->ebx - pointer to status of process reaped * Returns: pid of reaped process on success, -1 on error. */ static int Sys_WaitNoPID(struct Interrupt_State *state) { struct Kernel_Thread *zombieThread = Get_Zombie_Child(); int zombiepid; if (zombieThread == NULL) return ENOZOMBIES; zombiepid = zombieThread->pid; // Save zombie pid // Copy exit code to user variable if(!Copy_To_User(state->ebx, &zombieThread->exitCode, sizeof(int))) return EUNSPECIFIED; // Detach zombie thread, which sends to reaper Pub_Detach_Thread(zombieThread); return zombiepid; }
/* * Get metadata of an open file. * Params: * state->ebx - file descriptor to get metadata for * state->ecx - user address of struct VFS_File_Stat object to store metadata in * * Returns: 0 if successful, error code (< 0) if unsuccessful */ static int Sys_FStat(struct Interrupt_State *state) { int rc; if(state->ebx > USER_MAX_FILES) { return EINVALID; } if( g_currentThread->userContext->file_descriptor_table[state->ebx] ) { struct VFS_File_Stat vfs; Enable_Interrupts(); rc = FStat( g_currentThread->userContext->file_descriptor_table[state->ebx], &vfs); Disable_Interrupts(); if(rc == 0) { if (!Copy_To_User(state->ecx, &vfs, sizeof(struct VFS_File_Stat))) { return EINVALID; } } } else { return ENOTFOUND; } return rc; }
static int s3c_mfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; MFCInstCtx *pMfcInst; MFC_HANDLE *handle; unsigned char *OutBuf = NULL; MFC_CODECMODE codec_mode = 0; int buf_size; unsigned int tmp; MFC_ARGS args; enc_info_t enc_info; // modified by RainAde for header type of mpeg4 (+ VOS/VO) #if 1 // Hdr0 : SPS or VOL // Hdr1 : PPS or VOS // Hdr2 : VO (VIS) int nStrmLen, nHdrLen, nHdr0Len, nHdr1Len, nHdr2Len; #else // modified by RainAde for composer interface int nStrmLen, nHdrLen, nSps, nPps; #endif void *temp; unsigned int vir_mv_addr; unsigned int vir_mb_type_addr; ////////////////////// // Parameter Check // ////////////////////// handle = (MFC_HANDLE *)file->private_data; if (handle->mfc_inst == NULL) { return -EFAULT; } pMfcInst = handle->mfc_inst; switch(cmd) { case IOCTL_MFC_MPEG4_ENC_INIT: case IOCTL_MFC_H264_ENC_INIT: case IOCTL_MFC_H263_ENC_INIT: MFC_Mutex_Lock(); LOG_MSG(LOG_TRACE, "mfc_ioctl", "cmd = %d\r\n", cmd); Copy_From_User(&args.enc_init, (MFC_ENC_INIT_ARG *)arg, sizeof(MFC_ENC_INIT_ARG)); if ( cmd == IOCTL_MFC_MPEG4_ENC_INIT ) codec_mode = MP4_ENC; else if ( cmd == IOCTL_MFC_H264_ENC_INIT ) codec_mode = AVC_ENC; else if ( cmd == IOCTL_MFC_H263_ENC_INIT ) codec_mode = H263_ENC; ////////////////////////////// // Initialize MFC Instance // ////////////////////////////// enc_info.width = args.enc_init.in_width; enc_info.height = args.enc_init.in_height; enc_info.bitrate = args.enc_init.in_bitrate; enc_info.gopNum = args.enc_init.in_gopNum; enc_info.frameRateRes = args.enc_init.in_frameRateRes; enc_info.frameRateDiv = args.enc_init.in_frameRateDiv; ret = MFCInst_Enc_Init(pMfcInst, codec_mode, &enc_info); args.enc_init.ret_code = ret; Copy_To_User((MFC_ENC_INIT_ARG *)arg, &args.enc_init, sizeof(MFC_ENC_INIT_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_MPEG4_ENC_EXE: case IOCTL_MFC_H264_ENC_EXE: case IOCTL_MFC_H263_ENC_EXE: MFC_Mutex_Lock(); Copy_From_User(&args.enc_exe, (MFC_ENC_EXE_ARG *)arg, sizeof(MFC_ENC_EXE_ARG)); tmp = (pMfcInst->width * pMfcInst->height * 3) >> 1; // from 2.8.5 //dmac_clean_range(pMfcInst->pFramBuf, pMfcInst->pFramBuf + tmp); //outer_clean_range(__pa(pMfcInst->pFramBuf), __pa(pMfcInst->pFramBuf + tmp)); // from 2.8.5 : cache flush cpu_cache.flush_kern_all(); ////////////////////////// // Decode MFC Instance // ////////////////////////// // modified by RainAde for composer interface //ret = MFCInst_Encode(pMfcInst, &nStrmLen, &nHdrLen, &nHdr0Len, &nHdr1Len); // modified by RainAde for header type of mpeg4 (+ VOS/VO) ret = MFCInst_Encode(pMfcInst, &nStrmLen, &nHdrLen, &nHdr0Len, &nHdr1Len, &nHdr2Len); // from 2.8.5 //dmac_clean_range(pMfcInst->pStrmBuf, pMfcInst->pStrmBuf + MFC_LINE_BUF_SIZE_PER_INSTANCE); //outer_clean_range(__pa(pMfcInst->pStrmBuf), __pa(pMfcInst->pStrmBuf + MFC_LINE_BUF_SIZE_PER_INSTANCE)); args.enc_exe.ret_code = ret; if (ret == MFCINST_RET_OK) { args.enc_exe.out_encoded_size = nStrmLen; args.enc_exe.out_header_size = nHdrLen; // modified by RainAde for composer interface args.enc_exe.out_header0_size = nHdr0Len; args.enc_exe.out_header1_size = nHdr1Len; // modified by RainAde for header type of mpeg4 (+ VOS/VO) args.enc_exe.out_header2_size = nHdr2Len; } Copy_To_User((MFC_ENC_EXE_ARG *)arg, &args.enc_exe, sizeof(MFC_ENC_EXE_ARG)); // added by RainAde for cache coherency cpu_cache.dma_inv_range(pMfcInst->pStrmBuf, pMfcInst->pStrmBuf + MFC_LINE_BUF_SIZE_PER_INSTANCE); MFC_Mutex_Release(); break; case IOCTL_MFC_MPEG4_DEC_INIT: case IOCTL_MFC_H264_DEC_INIT: case IOCTL_MFC_H263_DEC_INIT: case IOCTL_MFC_VC1_DEC_INIT: MFC_Mutex_Lock(); #ifdef CONFIG_MACH_SATURN lcd_gamma_change(LCD_VIDEO); // when decoder init to start playing video, AMOLED gamma set to video mode #endif Copy_From_User(&args.dec_init, (MFC_DEC_INIT_ARG *)arg, sizeof(MFC_DEC_INIT_ARG)); // yj: fix the PiP problem cpu_cache.flush_kern_all(); if ( cmd == IOCTL_MFC_MPEG4_DEC_INIT ) codec_mode = MP4_DEC; else if ( cmd == IOCTL_MFC_H264_DEC_INIT ) codec_mode = AVC_DEC; else if ( cmd == IOCTL_MFC_H263_DEC_INIT) codec_mode = H263_DEC; else { codec_mode = VC1_DEC; } ////////////////////////////// // Initialize MFC Instance // ////////////////////////////// ret = MFCInst_Init(pMfcInst, codec_mode, args.dec_init.in_strmSize); args.dec_init.ret_code = ret; if (ret == MFCINST_RET_OK) { args.dec_init.out_width = pMfcInst->width; args.dec_init.out_height = pMfcInst->height; args.dec_init.out_buf_width = pMfcInst->buf_width; args.dec_init.out_buf_height = pMfcInst->buf_height; } Copy_To_User((MFC_DEC_INIT_ARG *)arg, &args.dec_init, sizeof(MFC_DEC_INIT_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_MPEG4_DEC_EXE: case IOCTL_MFC_H264_DEC_EXE: case IOCTL_MFC_H263_DEC_EXE: case IOCTL_MFC_VC1_DEC_EXE: MFC_Mutex_Lock(); Copy_From_User(&args.dec_exe, (MFC_DEC_EXE_ARG *)arg, sizeof(MFC_DEC_EXE_ARG)); // from 2.8.5 //dmac_clean_range(pMfcInst->pStrmBuf, pMfcInst->pStrmBuf + MFC_LINE_BUF_SIZE_PER_INSTANCE); //outer_clean_range(__pa(pMfcInst->pStrmBuf), __pa(pMfcInst->pStrmBuf + MFC_LINE_BUF_SIZE_PER_INSTANCE)); // from 2.8.5 : cache flush cpu_cache.flush_kern_all(); if (pMfcInst->inbuf_type == DEC_INBUF_LINE_BUF) { ret = MFCInst_Decode(pMfcInst, args.dec_exe.in_strmSize); } else if (pMfcInst->inbuf_type == DEC_INBUF_RING_BUF) { ret = MFCInst_Decode_Stream(pMfcInst, args.dec_exe.in_strmSize); } else { LOG_MSG(LOG_ERROR, "s3c_mfc_ioctl", "Buffer type is not defined.\n"); MFC_Mutex_Release(); args.dec_exe.ret_code = -1; return -EINVAL; } args.dec_exe.ret_code = ret; Copy_To_User((MFC_DEC_EXE_ARG *)arg, &args.dec_exe, sizeof(MFC_DEC_EXE_ARG)); // added by RainAde for cache coherency tmp = (pMfcInst->width * pMfcInst->height * 3) >> 1; cpu_cache.dma_inv_range(pMfcInst->pFramBuf, pMfcInst->pFramBuf + tmp); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_RING_BUF_ADDR: MFC_Mutex_Lock(); Copy_From_User(&args.get_buf_addr, (MFC_GET_BUF_ADDR_ARG *)arg, sizeof(MFC_GET_BUF_ADDR_ARG)); ret = MFCInst_GetRingBuf(pMfcInst, &OutBuf, &buf_size); args.get_buf_addr.out_buf_size = buf_size; args.get_buf_addr.out_buf_addr = args.get_buf_addr.in_usr_data + ((int)(OutBuf - GetDataBufVirAddr())); args.get_buf_addr.ret_code = ret; Copy_To_User((MFC_GET_BUF_ADDR_ARG *)arg, &args.get_buf_addr, sizeof(MFC_GET_BUF_ADDR_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_LINE_BUF_ADDR: MFC_Mutex_Lock(); Copy_From_User(&args.get_buf_addr, (MFC_GET_BUF_ADDR_ARG *)arg, sizeof(MFC_GET_BUF_ADDR_ARG)); ret = MFCInst_GetLineBuf(pMfcInst, &OutBuf, &buf_size); args.get_buf_addr.out_buf_size = buf_size; args.get_buf_addr.out_buf_addr = args.get_buf_addr.in_usr_data + (OutBuf - GetDataBufVirAddr()); args.get_buf_addr.ret_code = ret; Copy_To_User((MFC_GET_BUF_ADDR_ARG *)arg, &args.get_buf_addr, sizeof(MFC_GET_BUF_ADDR_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_DBK_BUF_ADDR: // newly added by yj: returns to DBK_BUF' virtual address and its size. MFC_Mutex_Lock(); Copy_From_User(&args.get_dbkbuf_addr, (MFC_GET_DBK_BUF_ARG *)arg, sizeof(MFC_GET_DBK_BUF_ARG)); if (pMfcInst->isMp4DbkOn != 1) { LOG_MSG(LOG_ERROR, "s3c_mfc_ioctl", "MFC DBK_BUF is not internally allocated yet.\n"); MFC_Mutex_Release(); return -EFAULT; } args.get_dbkbuf_addr.out_buf_size = (pMfcInst->buf_width * pMfcInst->buf_height * 3) >> 1; args.get_dbkbuf_addr.out_buf_addr = args.get_dbkbuf_addr.in_usr_mapped_addr + ((unsigned int)GetDbkBufVirAddr() - (unsigned int)GetDataBufVirAddr()); args.get_dbkbuf_addr.ret_code = MFCINST_RET_OK; Copy_To_User((MFC_GET_DBK_BUF_ARG *)arg, &args.get_dbkbuf_addr, sizeof(MFC_GET_DBK_BUF_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_FRAM_BUF_ADDR: MFC_Mutex_Lock(); Copy_From_User(&args.get_buf_addr, (MFC_GET_BUF_ADDR_ARG *)arg, sizeof(MFC_GET_BUF_ADDR_ARG)); if (pMfcInst->pFramBuf == NULL) { LOG_MSG(LOG_ERROR, "s3c_mfc_ioctl", "MFC Frame buffer is not internally allocated yet.\n"); MFC_Mutex_Release(); return -EFAULT; } // FRAM_BUF address is calculated differently for Encoder and Decoder. switch (pMfcInst->codec_mode) { case MP4_DEC: case AVC_DEC: case VC1_DEC: case H263_DEC: // Decoder case args.get_buf_addr.out_buf_size = (pMfcInst->buf_width * pMfcInst->buf_height * 3) >> 1; tmp = (unsigned int)args.get_buf_addr.in_usr_data + ( ((unsigned int) pMfcInst->pFramBuf) \ + (pMfcInst->idx) * (args.get_buf_addr.out_buf_size + ZERO_COPY_HDR_SIZE) - (unsigned int)GetDataBufVirAddr() ); #if (MFC_ROTATE_ENABLE == 1) if ( (pMfcInst->codec_mode != VC1_DEC) && (pMfcInst->PostRotMode & 0x0010) ) { tmp = (unsigned int)args.get_buf_addr.in_usr_data + ( ((unsigned int) pMfcInst->pFramBuf) \ + (pMfcInst->frambufCnt) * (args.get_buf_addr.out_buf_size + ZERO_COPY_HDR_SIZE) - (unsigned int)GetDataBufVirAddr() ); } #endif args.get_buf_addr.out_buf_addr = tmp; break; case MP4_ENC: case AVC_ENC: case H263_ENC: // Encoder case tmp = (pMfcInst->width * pMfcInst->height * 3) >> 1; args.get_buf_addr.out_buf_addr = args.get_buf_addr.in_usr_data + (pMfcInst->idx * tmp) + (int)(pMfcInst->pFramBuf - GetDataBufVirAddr()); break; } args.get_buf_addr.ret_code = MFCINST_RET_OK; Copy_To_User((MFC_GET_BUF_ADDR_ARG *)arg, &args.get_buf_addr, sizeof(MFC_GET_BUF_ADDR_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_PHY_FRAM_BUF_ADDR: MFC_Mutex_Lock(); Copy_From_User(&args.get_buf_addr, (MFC_GET_BUF_ADDR_ARG *)arg, sizeof(MFC_GET_BUF_ADDR_ARG)); args.get_buf_addr.out_buf_size = (pMfcInst->buf_width * pMfcInst->buf_height * 3) >> 1; // args.get_buf_addr.out_buf_size = ((pMfcInst->width+2*DIVX_PADDING) * (pMfcInst->height+2*DIVX_PADDING) * 3) >> 1; tmp = (unsigned int)S3C6400_BASEADDR_MFC_DATA_BUF + ( ((unsigned int) pMfcInst->pFramBuf) \ + (pMfcInst->idx) * (args.get_buf_addr.out_buf_size + ZERO_COPY_HDR_SIZE) - (unsigned int)GetDataBufVirAddr() ); //.[ i: sichoi 081103 (ROTATE) #if (MFC_ROTATE_ENABLE == 1) if ( (pMfcInst->codec_mode != VC1_DEC) && (pMfcInst->PostRotMode & 0x0010) ) { tmp = (unsigned int)S3C6400_BASEADDR_MFC_DATA_BUF + ( ((unsigned int) pMfcInst->pFramBuf) \ + (pMfcInst->frambufCnt) * (args.get_buf_addr.out_buf_size + ZERO_COPY_HDR_SIZE) - (unsigned int)GetDataBufVirAddr() ); } #endif //.] sichoi 081103 args.get_buf_addr.out_buf_addr = tmp; args.get_buf_addr.ret_code = MFCINST_RET_OK; Copy_To_User((MFC_GET_BUF_ADDR_ARG *)arg, &args.get_buf_addr, sizeof(MFC_GET_BUF_ADDR_ARG)); MFC_Mutex_Release(); break; case IOCTL_MFC_GET_MPEG4_ASP_PARAM: #if (defined(DIVX_ENABLE) && (DIVX_ENABLE == 1)) Copy_From_User(&args.mpeg4_asp_param, (MFC_GET_MPEG4ASP_ARG *)arg, sizeof(MFC_GET_MPEG4ASP_ARG)); ret = MFCINST_RET_OK; args.mpeg4_asp_param.ret_code = MFCINST_RET_OK; args.mpeg4_asp_param.mp4asp_vop_time_res = pMfcInst->RET_DEC_SEQ_INIT_BAK_MP4ASP_VOP_TIME_RES; args.mpeg4_asp_param.byte_consumed = pMfcInst->RET_DEC_PIC_RUN_BAK_BYTE_CONSUMED; args.mpeg4_asp_param.mp4asp_fcode = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_FCODE; args.mpeg4_asp_param.mp4asp_time_base_last = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_TIME_BASE_LAST; args.mpeg4_asp_param.mp4asp_nonb_time_last = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_NONB_TIME_LAST; args.mpeg4_asp_param.mp4asp_trd = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_MP4ASP_TRD; args.mpeg4_asp_param.mv_addr = (args.mpeg4_asp_param.in_usr_mapped_addr + MFC_STRM_BUF_SIZE) + (pMfcInst->mv_mbyte_addr - pMfcInst->phyadrFramBuf); args.mpeg4_asp_param.mb_type_addr = args.mpeg4_asp_param.mv_addr + 25920; args.mpeg4_asp_param.mv_size = 25920; args.mpeg4_asp_param.mb_type_size = 1620; vir_mv_addr = (unsigned int)((pMfcInst->pStrmBuf + MFC_STRM_BUF_SIZE) + (pMfcInst->mv_mbyte_addr - pMfcInst->phyadrFramBuf)); vir_mb_type_addr = vir_mv_addr + 25920; Copy_To_User((MFC_GET_MPEG4ASP_ARG *)arg, &args.mpeg4_asp_param, sizeof(MFC_GET_MPEG4ASP_ARG)); // from 2.8.5 //dmac_clean_range(vir_mv_addr, vir_mv_addr + args.mpeg4_asp_param.mv_size); //outer_clean_range(__pa(vir_mv_addr), __pa(vir_mv_addr + args.mpeg4_asp_param.mv_size)); //dmac_clean_range(vir_mb_type_addr, vir_mb_type_addr + args.mpeg4_asp_param.mb_type_size); //outer_clean_range(__pa(vir_mb_type_addr), __pa(vir_mb_type_addr + args.mpeg4_asp_param.mb_type_size)); #endif break; case IOCTL_MFC_GET_CONFIG: MFC_Mutex_Lock(); Copy_From_User(&args, (MFC_ARGS *)arg, sizeof(MFC_ARGS)); ret = MFC_GetConfigParams(pMfcInst, &args); Copy_To_User((MFC_ARGS *)arg, &args, sizeof(MFC_ARGS)); MFC_Mutex_Release(); break; case IOCTL_MFC_SET_CONFIG: MFC_Mutex_Lock(); Copy_From_User(&args, (MFC_ARGS *)arg, sizeof(MFC_ARGS)); ret = MFC_SetConfigParams(pMfcInst, &args); Copy_To_User((MFC_ARGS *)arg, &args, sizeof(MFC_ARGS)); MFC_Mutex_Release(); break; case IOCTL_MFC_SET_H263_MULTIPLE_SLICE: MFC_Mutex_Lock(); pMfcInst->multiple_slice = 1; MFC_Mutex_Release(); break; case IOCTL_VIRT_TO_PHYS: //MFC_Mutex_Lock(); temp = __virt_to_phys((void *)arg); return (int)temp; //MFC_Mutex_Release(); break; default: MFC_Mutex_Lock(); LOG_MSG(LOG_TRACE, "s3c_mfc_ioctl", "Requested ioctl command is not defined. (ioctl cmd=0x%X)\n", cmd); MFC_Mutex_Release(); return -EINVAL; } switch(ret) { case MFCINST_RET_OK: return TRUE; default: return -1; } return -1; }