| /*************************************************** |
| Copyright (c) 2015 Amphion Semiconductor Ltd |
| All rights reserved. |
| *************************************************** |
| * The code contained herein is licensed under the GNU General Public |
| * License. You may obtain a copy of the GNU General Public License |
| * Version 2 or later at the following locations: |
| * |
| * http://www.opensource.org/licenses/gpl-license.html |
| * http://www.gnu.org/copyleft/gpl.html |
| **************************************************** |
| |
| Author : Media IP FW team ( Belfast and Shanghai ) |
| File name : DecLibHWControl.c |
| Notes : Processes commands from decoder lib scheduler |
| Establishes context for and makes calls to |
| the base decoders |
| This file provides the hardware facing aspect to |
| the interface. It is part of a group with |
| DecLibStreamControl.c which provides the |
| HW funtionality |
| |
| ******************************************************/ |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Header Files |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| #include "basetype.h" |
| #include "mediaip_fw_types.h" |
| #include "pal.h" |
| |
| #include "mvd_types.h" |
| #include "mvd_reg_map.h" |
| #include "mvd_sif_control.h" |
| |
| #include "DecKernelLibPrivate.h" |
| #include "DecKernelLibHWControl.h" |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Extern Function Prototypes |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| extern MEDIAIP_IRQ_RETCODE mvd_kernel_hw_primary_isr ( u_int32 irq_val ); |
| extern MEDIAIP_IRQ_RETCODE mvd_kernel_hw_secondary_isr ( u_int32 irq_val ); |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Private Function Prototypes |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Global Variables |
| /////////////////////////////////////////////////////////////////////////////////; |
| |
| extern DEC_KERNEL_LIB gDecKernelLib; |
| MALONE_KERNEL_HW_SESSION gMvdKernelHw[(DECODERLIB_MAX_MALONES + 1)]; |
| pMALONE_KERNEL_HW_SESSION pgMVDKernelHw; |
| |
| u_int32 gMaloneList[(DECODERLIB_MAX_MALONES + 1)] = { MALONE_HW_1, |
| #if DECODERLIB_MAX_MALONES > 1 |
| MALONE_HW_2, |
| #endif |
| MALONE_SW }; |
| |
| static u_int32 uSWMaloneRegSpace[2048]; /* Until we are sure we have eliminated register access */ |
| /* for functions using the 'SW Malone', point them here */ |
| |
| extern u_int32 uDecLibIrqPin[DECODERLIB_MAX_MALONES][0x2]; |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Code |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // FUNCTION: mvd_kernel_hw_control_init // |
| // // |
| // DESCRIPTION: Perform all HW initialisation and shared structure setup // |
| // // |
| // INPUTS: uMaloneID - The ID of the Malone for which the info is to // |
| // be restored // |
| // pCtxArea - Pointer to area of memory from which data is to be // |
| // read // |
| // // |
| // OUTPUTS: None. // |
| // // |
| // RETURNS: None. // |
| // // |
| // NOTES: None. // |
| // // |
| // CONTEXT: This function must be called from non-interrupt context // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| void mvd_kernel_hw_control_init ( DECODERLIB_KERNEL_CFG * pCfg ) |
| { |
| /* Init the handles */ |
| /* This sets up the reg pointers so do it first */ |
| mvd_kernel_hw_init_handles ( pCfg, |
| TRUE ); |
| |
| /* Default global pointers to a 1st Malone focus */ |
| mvd_kernel_hw_set_focus ( MALONE_HW_1, &pgMVDKernelHw ); |
| |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // FUNCTION: mvd_kernel_hw_set_malone_instance // |
| // // |
| // DESCRIPTION: Look for the most appropriate Malone instance to service // |
| // the command for a specified stream // |
| // // |
| // INPUTS: uStrId - The Stream ID // |
| // bSWCmd - is the command to be carried out for this stream // |
| // capable of being handled without using the HW engine? // |
| // uHWIndex - HW Index suggested by scheduler // |
| // bUseSch - Set to guarantee scheduler suggested unit is used // |
| // // |
| // OUTPUTS: None. // |
| // // |
| // RETURNS: The most suitable Malone ID to be used // |
| // // |
| // NOTES: This function must return a value. // |
| // // |
| // CONTEXT: This function must be called from non-interrupt context // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| u_int32 mvd_kernel_hw_set_malone_instance ( u_int32 uStrId, |
| bool bSWCmd, |
| u_int32 uHWIndex, |
| bool bUseSch |
| ) |
| { |
| u_int32 uIdx = 0; |
| |
| if ( bUseSch ) |
| { |
| return uHWIndex; |
| } |
| |
| for ( uIdx = 0; uIdx < gDecKernelLib.uNumMalones; uIdx++ ) |
| { |
| /* Even if there is no command active, this is a valid check as */ |
| /* it avoids need for a context change if it matches */ |
| if ( gMvdKernelHw[uIdx].uStrID == uStrId ) |
| { |
| return uIdx; |
| } |
| } |
| |
| if ( bSWCmd ) return MALONE_SW; |
| |
| /* Look for free Malone - this function should not be called */ |
| /* unless this is a SW command or there is a free Malone */ |
| |
| for ( uIdx = 0; uIdx < gDecKernelLib.uNumMalones; uIdx++ ) |
| { |
| /* Even if there is no command active, this is a valid check as */ |
| /* it avoids need for a context change if it matches */ |
| if ( gMvdKernelHw[uIdx].eState == MALONE_INACTIVE ) |
| { |
| break; |
| } |
| } |
| |
| /* Do not assign this stream and do NOT make it active yet */ |
| /* Only make this malone active when the command is issued */ |
| /* This is necessary so we we can trigger context switches */ |
| |
| /* We should set the global pointer though so calls to sif */ |
| /* etc can get correct functions!! */ |
| |
| mvd_kernel_hw_set_focus ( uIdx, &pgMVDKernelHw ); |
| |
| return uIdx; |
| |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // FUNCTION: mvd_kernel_hw_set_focus // |
| // // |
| // DESCRIPTION: Changes focus to the selected Malone HW unit // |
| // // |
| // INPUTS: uMaloneID - The ID of the Malone // |
| // // |
| // OUTPUTS: ppMVDHw - Pointer to a HW session structure for the specified // |
| // Malone // |
| // // |
| // RETURNS: None. // |
| // // |
| // NOTES: Only makes sense in multi-malone configs // |
| // // |
| // CONTEXT: This function may be called from any context // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| void mvd_kernel_hw_set_focus ( u_int32 uMaloneID, pMALONE_KERNEL_HW_SESSION * ppMVDHw ) |
| { |
| *ppMVDHw = ( MALONE_KERNEL_HW_SESSION * )&gMvdKernelHw[uMaloneID]; |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // FUNCTION: mvd_kernel_hw_init_handles // |
| // // |
| // DESCRIPTION: Initialise the HW session handles // |
| // // |
| // INPUTS: pCfg - A pointer to the DecLib Config structure // |
| // bSoftInit - If set, the FW pointers get established - leave // |
| // FALSE when restarting from a snapshot // |
| // // |
| // OUTPUTS: None. // |
| // // |
| // RETURNS: None. // |
| // // |
| // NOTES: None. // |
| // // |
| // CONTEXT: This function must be called from non-interrupt context // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| void mvd_kernel_hw_init_handles ( DECODERLIB_KERNEL_CFG * pCfg, |
| bool bSoftInit |
| ) |
| { |
| u_int32 uIdx; |
| pMALONE_KERNEL_HW_SESSION pMVDHw; |
| MvdHwRegMap *pMvdReg; |
| |
| for ( uIdx = 0; uIdx < (gDecKernelLib.uNumMalones + 1); uIdx++ ) |
| { |
| /* If we have set up all the HW handles then move to the SW */ |
| /* handle and set it up */ |
| if ( uIdx == gDecKernelLib.uNumMalones ) uIdx = DECODERLIB_MAX_MALONES; |
| |
| pMVDHw = &gMvdKernelHw[uIdx]; |
| |
| if ( bSoftInit ) |
| { |
| pMVDHw->eState = MALONE_INACTIVE; |
| pMVDHw->uStrID = 0; |
| pMVDHw->uForceFIQ = 0; |
| pMVDHw->uForceDFEFIQ = 0; |
| |
| /* Malone ID that the instance uses, normally fixed... */ |
| pMVDHw->uMaloneID = gMaloneList[uIdx]; |
| } |
| |
| if ( pMVDHw->uMaloneID == DECODERLIB_MAX_MALONES ) |
| { |
| pMvdReg = ( MvdHwRegMap * )uSWMaloneRegSpace; |
| } |
| else if ( pMVDHw->uMaloneID == MALONE_HW_2 ) |
| { |
| pMvdReg = ( MvdHwRegMap * ) ( pCfg->uMaloneBaseAddr[0x1] + pCfg->uMaloneHifOffset[0x1] ); |
| } |
| else |
| { |
| pMvdReg = ( MvdHwRegMap * ) ( pCfg->uMaloneBaseAddr[0x0] + pCfg->uMaloneHifOffset[0x0] ); |
| } |
| |
| if ( pMVDHw->uMaloneID == MALONE_SW ) |
| { |
| pMVDHw->msd_regp = ( MvdHwRegMap * )pMvdReg; |
| pMVDHw->hif_regp = ( MvdHwRegHifMap * )pMvdReg; |
| pMVDHw->sif_regp = ( MvdHwRegSifMap * )pMvdReg; |
| pMVDHw->ctx_regp = ( MvdHwRegCtxMap * )pMvdReg; |
| pMVDHw->rsb_regp = ( MvdHwReg * )pMvdReg; |
| pMVDHw->rpr_regp = ( MvdHwRegRprMap * )pMvdReg; |
| pMVDHw->spp_regp = ( MvdHwRegSppMap * )pMvdReg; |
| pMVDHw->avc_regp = ( MvdHwRegH264Map * )pMvdReg; |
| pMVDHw->mp2d_regp = ( MvdHwRegMp2dMap * )pMvdReg; |
| pMVDHw->avsd_regp = ( MvdHwRegAvsdMap * )pMvdReg; |
| pMVDHw->aspd_regp = ( MvdHwRegAspdMap * )pMvdReg; |
| pMVDHw->vc1d_regp = ( MvdHwRegVc1dMap * )pMvdReg; |
| pMVDHw->jpgd_regp = ( MvdHwRegAspdMap * )pMvdReg; |
| pMVDHw->rvid_regp = ( MvdHwRegRvidMap * )pMvdReg; |
| pMVDHw->hevc_regp = ( MvdHwRegHevcMap * )pMvdReg; |
| pMVDHw->on2d_regp = ( MvdHwRegOn2dMap * )pMvdReg; |
| pMVDHw->cq_regp = ( MvdHwRegCqMap * )pMvdReg; |
| pMVDHw->rc4_regp = ( MvdHwRegRC4Map * )pMvdReg; |
| pMVDHw->dfe_regp = ( MvdHwRegDfeMap * )pMvdReg; |
| pMVDHw->dbe_regp[0x0] = ( MvdHwRegDbeMap * )pMvdReg; |
| pMVDHw->dbe_regp[0x1] = ( MvdHwRegDbeMap * )pMvdReg; |
| |
| } |
| else |
| { |
| pMVDHw->msd_regp = pMvdReg; |
| pMVDHw->hif_regp = &( pMvdReg->HifMap.hif_map ); |
| pMVDHw->sif_regp = &( pMvdReg->SifMap.sif_map ); |
| pMVDHw->ctx_regp = &( pMvdReg->CtxMap.ctx_map ); |
| pMVDHw->rpr_regp = &( pMvdReg->RprMap.rpr_map ); |
| pMVDHw->spp_regp = &( pMvdReg->SppMap.spp_map ); |
| pMVDHw->avc_regp = &( pMvdReg->DecMap.h264_map ); |
| pMVDHw->mp2d_regp = &( pMvdReg->DecMap.mp2d_map ); |
| pMVDHw->aspd_regp = &( pMvdReg->DecMap.aspd_map ); |
| pMVDHw->avsd_regp = &( pMvdReg->DecMap.avsd_map ); |
| pMVDHw->vc1d_regp = &( pMvdReg->DecMap.vc1d_map ); |
| pMVDHw->jpgd_regp = &( pMvdReg->DecMap.aspd_map ); |
| pMVDHw->on2d_regp = &( pMvdReg->DecMap.on2d_map ); |
| pMVDHw->rvid_regp = &( pMvdReg->DecMap.rvid_map ); |
| pMVDHw->hevc_regp = &( pMvdReg->DecMap.hevc_map ); |
| pMVDHw->bbd_regp = &( pMvdReg->BbdMap.bbd_map ); |
| pMVDHw->cq_regp = &( pMvdReg->CqMap.cq_map ); |
| pMVDHw->rc4_regp = &( pMvdReg->RC4Map.RC4_map ); |
| pMVDHw->dfe_regp = &( pMvdReg->DcpMap.dfe_map ); |
| pMVDHw->dbe_regp[0x0] = &( pMvdReg->DcpMap.dbe_map[0x0] ); |
| pMVDHw->dbe_regp[0x1] = &( pMvdReg->DcpMap.dbe_map[0x1] ); |
| |
| if ( pMVDHw->uMaloneID == MALONE_HW_2 ) |
| { |
| pMVDHw->rsb_regp = ( MvdHwReg * ) pCfg->uMaloneBaseAddr[0x1] ; |
| } |
| else |
| { |
| pMVDHw->rsb_regp = ( MvdHwReg * ) pCfg->uMaloneBaseAddr[0x0] ; |
| } |
| } |
| } |
| } |
| |
| /* End of File */ |
