xref: /hardware/intel/common/libmix/mix_vbp/viddec_fw/fw/parser/main.c

#include "fw_pvt.h"
#include "viddec_fw_parser_ipclib_config.h"
#include "viddec_fw_common_defs.h"
#include "viddec_fw_parser.h"
#include "viddec_fw_debug.h"

/* This define makes sure that the structure is stored in Local memory.
   This is shared memory between host and FW.*/
volatile dmem_t _dmem __attribute__ ((section (".exchange")));
/* Debug index should be disbaled for Production FW */
uint32_t dump_ptr=0;
uint32_t timer=0;

/* Auto Api definitions */
ismd_api_group viddec_fw_api_array[2];

extern void viddec_fw_parser_register_callbacks(void);

/*------------------------------------------------------------------------------
 * Function:  initialize firmware SVEN TX Output
 *------------------------------------------------------------------------------
 */
int SMDEXPORT viddec_fw_parser_sven_init(struct SVEN_FW_Globals  *sven_fw_globals )
{
    extern int sven_fw_set_globals(struct SVEN_FW_Globals  *fw_globals );
    return(sven_fw_set_globals(sven_fw_globals));
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_check_watermark_boundary
 * This function figures out if we crossesd watermark boundary on input data.
 * before represents the ES Queue data when we started and current represents ES Queue data
 * when we are ready to swap.Threshold is the amount of data specified by the driver to trigger an
 * interrupt.
 * We return true if threshold is between before and current.
 *------------------------------------------------------------------------------
 */
static inline uint32_t viddec_fw_check_watermark_boundary(uint32_t before, uint32_t current, uint32_t threshold)
{
    return ((before >= threshold) && (current < threshold));
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_get_total_input_Q_data
 * This function figures out how much data is available in input queue of the FW
 *------------------------------------------------------------------------------
 */
static uint32_t viddec_fw_get_total_input_Q_data(uint32_t indx)
{
    FW_IPC_Handle *fwipc = GET_IPC_HANDLE(_dmem);
    uint32_t ret;
    int32_t pos=0;
    FW_IPC_ReceiveQue   *rcv_q;

    rcv_q = &fwipc->rcv_q[indx];
    /* count the cubby buffer which we already read if present */
    ret = (_dmem.stream_info[indx].buffered_data) ? CONFIG_IPC_MESSAGE_MAX_SIZE:0;
    ret += ipc_mq_read_avail(&rcv_q->mq, (int32_t *)&pos);
    return ret;
}

/*------------------------------------------------------------------------------
 * Function:  mfd_round_robin
 * Params:
 *        [in]  pri: Priority of the stream
 *        [in] indx: stream id number of the last stream that was scheduled.
 *        [out] qnum: Stream id of priority(pri) which has data.
 * This function is responsible for figuring out which stream needs to be scheduled next.
 * It starts after the last scheduled stream and walks through all streams until it finds
 * a stream which is of required priority, in start state, has space on output and data in
 * input.
 * If no such stream is found qnum is not updated and return value is 0.
 * If a stream is found then qnum is updated with that id and function returns 1.
 *------------------------------------------------------------------------------
 */

uint32_t mfd_round_robin(uint32_t pri, int32_t *qnum, int32_t indx)
{
    FW_IPC_Handle *fwipc = GET_IPC_HANDLE(_dmem);
    int32_t i = CONFIG_IPC_FW_MAX_RX_QUEUES;
    uint32_t ret = 0;
    /* Go through all queues until we find a valid queue of reqd priority */
    while(i>0)
    {
        indx++;
        if(indx >=  CONFIG_IPC_FW_MAX_RX_QUEUES) indx = 0;

        /* We should look only at queues which match priority and
           in running state */
        if( (_dmem.stream_info[indx].state == 1)
            && (_dmem.stream_info[indx].priority == pri))
        {
            uint32_t inpt_avail=0, output_avail=0, wklds_avail =0 , pos;
            FW_IPC_ReceiveQue   *rcv_q;
            rcv_q = &fwipc->rcv_q[indx];
            inpt_avail = (_dmem.stream_info[indx].buffered_data > 0) || (ipc_mq_read_avail(&rcv_q->mq, (int32_t *)&pos) > 0);
            /* we have to check for two workloads to protect against error cases where we might have to push both current and next workloads */
            output_avail = FwIPC_SpaceAvailForMessage(fwipc, &fwipc->snd_q[indx], CONFIG_IPC_MESSAGE_MAX_SIZE, &pos) >= 2;
            pos = 0;
            /* Need at least current and next to proceed */
            wklds_avail =  (ipc_mq_read_avail(&fwipc->wkld_q[indx].mq, (int32_t *)&pos) >= (CONFIG_IPC_MESSAGE_MAX_SIZE << 1));
            if(inpt_avail && output_avail && wklds_avail)
            {/* Success condition: we have some data on input and enough space on output queue */
                *qnum = indx;
                ret =1;
                break;
            }
        }
        i--;
    }
    return ret;
}
static inline void mfd_setup_emitter(FW_IPC_Handle *fwipc, FW_IPC_ReceiveQue *rcv_q, mfd_pk_strm_cxt *cxt)
{
    int32_t ret1=0,ret=0;
    /* We don't check return values for the peek as round robin guarantee's that we have required free workloads */
    ret = FwIPC_PeekReadMessage(fwipc, rcv_q, (char *)&(cxt->wkld1), sizeof(ipc_msg_data), 0);
    ret1 = FwIPC_PeekReadMessage(fwipc, rcv_q, (char *)&(cxt->wkld2), sizeof(ipc_msg_data), 1);
    viddec_emit_update(&(cxt->pm.emitter), cxt->wkld1.phys, cxt->wkld2.phys, cxt->wkld1.len, cxt->wkld2.len);
}

static inline void mfd_init_swap_memory(viddec_pm_cxt_t *pm, uint32_t codec_type, uint32_t start_addr, uint32_t clean)
{
    uint32_t *persist_mem;
    persist_mem = (uint32_t *)(start_addr | GV_DDR_MEM_MASK);
    viddec_pm_init_context(pm,codec_type, persist_mem, clean);
    pm->sc_prefix_info.first_sc_detect = 1;
    viddec_emit_init(&(pm->emitter));
}

void output_omar_wires( unsigned int value )
{
#ifdef RTL_SIMULATION
    reg_write(CONFIG_IPC_ROFF_HOST_DOORBELL, value );
#endif
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_init_swap_memory
 * This function is responsible for seeting the swap memory to a good state for current stream.
 * The swap parameter tells us whether we need to dma the context to local memory.
 * We call init on emitter and parser manager which inturn calls init of the codec we are opening the stream for.
 *------------------------------------------------------------------------------
 */

void viddec_fw_init_swap_memory(unsigned int stream_id, unsigned int swap, unsigned int clean)
{
    mfd_pk_strm_cxt *cxt;
    mfd_stream_info *cxt_swap;
    cxt = (mfd_pk_strm_cxt *)&(_dmem.srm_cxt);
    cxt_swap = (mfd_stream_info *)&(_dmem.stream_info[stream_id]);

    if(swap)
    {/* Swap context into local memory */
        cp_using_dma(cxt_swap->ddr_cxt, (uint32_t) &(cxt->pm), sizeof(viddec_pm_cxt_t), false, false);
    }

    {
        mfd_init_swap_memory(&(cxt->pm), cxt_swap->strm_type, cxt_swap->ddr_cxt+cxt_swap->cxt_size, clean);
        cxt_swap->wl_time = 0;
        cxt_swap->es_time = 0;
    }
    if(swap)
    {/* Swap context into DDR */
        cp_using_dma(cxt_swap->ddr_cxt, (uint32_t) &(cxt->pm), sizeof(viddec_pm_cxt_t), true, false);
    }
}

/*------------------------------------------------------------------------------
 * Function: viddec_fw_push_current_frame_to_output
 * This is a helper function to read a workload from input queue and push to output queue.
 * This is called when are done with a frame.
 *------------------------------------------------------------------------------
 */
static inline void viddec_fw_push_current_frame_to_output(FW_IPC_Handle *fwipc, uint32_t cur)
{
    ipc_msg_data wkld_to_push;
    FwIPC_ReadMessage(fwipc, &fwipc->wkld_q[cur], (char *)&(wkld_to_push), sizeof(ipc_msg_data));
    FwIPC_SendMessage(fwipc, cur, (char *)&(wkld_to_push),  sizeof(ipc_msg_data));
}

/*------------------------------------------------------------------------------
 * Function: viddec_fw_get_next_stream_to_schedule
 * This is a helper function to figure out which active stream needs to be scheduled next.
 * If none of the streams are active it returns -1.
 *------------------------------------------------------------------------------
 */
static inline int viddec_fw_get_next_stream_to_schedule(void)
{
    int32_t cur = -1;

    if(mfd_round_robin(viddec_stream_priority_REALTIME, &cur, _dmem.g_pk_data.high_id))
    {
        /* On success store the stream id */
        _dmem.g_pk_data.high_id = cur;
    }
    else
    {
        /* Check Low priority Queues, Since we couldn't find a valid realtime stream */
        if(mfd_round_robin(viddec_stream_priority_BACKGROUND, &cur, _dmem.g_pk_data.low_id))
        {
            _dmem.g_pk_data.low_id = cur;
        }
    }

    return cur;
}

/*------------------------------------------------------------------------------
 * Function: viddec_fw_update_pending_interrupt_flag
 * This is a helper function to figure out if we need to mark an interrupt pending for this stream.
 * We update status value here if we find any of the interrupt conditions are true.
 * If this stream has a interrupt pending which we could not send to host, we don't overwrite past status info.
 *------------------------------------------------------------------------------
 */
static inline void viddec_fw_update_pending_interrupt_flag(int32_t cur, mfd_stream_info *cxt_swap, uint8_t pushed_a_workload,
                                                           uint32_t es_Q_data_at_start)
{
    if(_dmem.int_status[cur].mask)
    {
        if(!cxt_swap->pending_interrupt)
        {
            uint32_t es_Q_data_now;
            uint8_t wmark_boundary_reached=false;
            es_Q_data_now = viddec_fw_get_total_input_Q_data((uint32_t)cur);
            wmark_boundary_reached = viddec_fw_check_watermark_boundary(es_Q_data_at_start, es_Q_data_now, cxt_swap->low_watermark);
            _dmem.int_status[cur].status = 0;
            if(pushed_a_workload)
            {
                _dmem.int_status[cur].status |= VIDDEC_FW_WKLD_DATA_AVAIL;
            }
            if(wmark_boundary_reached)
            {
                _dmem.int_status[cur].status |= VIDDEC_FW_INPUT_WATERMARK_REACHED;
            }
            cxt_swap->pending_interrupt = ( _dmem.int_status[cur].status != 0);
        }
    }
    else
    {
        cxt_swap->pending_interrupt = false;
    }
}

static inline void viddec_fw_handle_error_and_inband_messages(int32_t cur, uint32_t pm_ret)
{
    FW_IPC_Handle *fwipc = GET_IPC_HANDLE(_dmem);

    viddec_fw_push_current_frame_to_output(fwipc, cur);
    switch(pm_ret)
    {
        case PM_EOS:
        case PM_OVERFLOW:
        {
            viddec_fw_init_swap_memory(cur, false, true);
        }
        break;
        case PM_DISCONTINUITY:
        {
            viddec_fw_init_swap_memory(cur, false, false);
        }
        break;
        default:
            break;
    }
}

void viddec_fw_debug_scheduled_stream_state(int32_t indx, int32_t start)
{
    FW_IPC_Handle *fwipc = GET_IPC_HANDLE(_dmem);
    uint32_t inpt_avail=0, output_avail=0, wklds_avail =0 , pos;
    FW_IPC_ReceiveQue   *rcv_q;
    uint32_t message;

    message = (start) ? SVEN_MODULE_EVENT_GV_FW_PK_SCHDL_STRM_START: SVEN_MODULE_EVENT_GV_FW_PK_SCHDL_STRM_END;
    rcv_q = &fwipc->rcv_q[indx];
    inpt_avail = ipc_mq_read_avail(&rcv_q->mq, (int32_t *)&pos);
    inpt_avail += ((_dmem.stream_info[indx].buffered_data > 0) ? CONFIG_IPC_MESSAGE_MAX_SIZE: 0);
    inpt_avail = inpt_avail >> 4;
    pos = 0;
    output_avail = ipc_mq_read_avail(&fwipc->snd_q[indx].mq, (int32_t *)&pos);
    output_avail = output_avail >> 4;
    pos = 0;
    wklds_avail =  ipc_mq_read_avail(&fwipc->wkld_q[indx].mq, (int32_t *)&pos);
    wklds_avail = wklds_avail >> 4;
    WRITE_SVEN(message, (int)indx, (int)inpt_avail, (int)output_avail,
               (int)wklds_avail, 0, 0);
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_process_async_queues(A.K.A -> Parser Kernel)
 * This function is responsible for handling the asynchronous queues.
 *
 * The first step is to figure out which stream to run. The current algorithm
 * will go through all high priority queues for a valid stream, if not found we
 * go through lower priority queues.
 *
 * If a valid stream is found we swap the required context from DDR to DMEM and do all necessary
 * things to setup the stream.
 * Once a stream is setup we call the parser manager and wait until a wrkld is created or no more input
 * data left.
 * Once we find a wkld we push it to host and save the current context to DDR.
 *------------------------------------------------------------------------------
 */

static inline int32_t viddec_fw_process_async_queues()
{
    int32_t cur = -1;

    cur = viddec_fw_get_next_stream_to_schedule();

    if(cur != -1)
    {
        FW_IPC_Handle *fwipc = GET_IPC_HANDLE(_dmem);
        FW_IPC_ReceiveQue   *rcv_q;
        /* bits captured by OMAR */
        output_omar_wires( 0x0 );
        rcv_q = &fwipc->rcv_q[cur];
        {
            mfd_pk_strm_cxt *cxt;
            mfd_stream_info *cxt_swap;
            cxt = (mfd_pk_strm_cxt *)&(_dmem.srm_cxt);
            cxt_swap = (mfd_stream_info *)&(_dmem.stream_info[cur]);

            /* Step 1: Swap rodata to local memory. Not doing this currently as all the rodata fits in local memory. */
            {/* Step 2: Swap context into local memory */
                cp_using_dma(cxt_swap->ddr_cxt, (uint32_t) &(cxt->pm), sizeof(viddec_pm_cxt_t), false, false);
            }
            /* Step 3:setup emitter by reading input data and workloads and initialising it */
            mfd_setup_emitter(fwipc, &fwipc->wkld_q[cur], cxt);
            viddec_fw_debug_scheduled_stream_state(cur, true);
            /* Step 4: Call Parser Manager until workload done or No more ES buffers */
            {
                ipc_msg_data *data = 0;
                uint8_t stream_active = true, pushed_a_workload=false;
                uint32_t pm_ret = PM_SUCCESS, es_Q_data_at_start;
                uint32_t start_time, time=0;

                start_time = set_wdog(VIDDEC_WATCHDOG_COUNTER_MAX);
                timer=0;
                es_Q_data_at_start = viddec_fw_get_total_input_Q_data((uint32_t)cur);
                do
                {
                    output_omar_wires( 0x1 );
                    {
                        uint32_t es_t0,es_t1;
                        get_wdog(&es_t0);
                        pm_ret = viddec_pm_parse_es_buffer(&(cxt->pm), cxt_swap->strm_type, data);
                        get_wdog(&es_t1);
                        cxt_swap->es_time += get_total_ticks(es_t0, es_t1);
                    }
                    switch(pm_ret)
                    {
                        case PM_EOS:
                        case PM_WKLD_DONE:
                        case PM_OVERFLOW:
                        case PM_DISCONTINUITY:
                        {/* Finished a frame worth of data or encountered fatal error*/
                            stream_active = false;
                        }
                        break;
                        case PM_NO_DATA:
                        {
                            uint32_t next_ret=0;
                            if ( (NULL != data) && (0 != cxt_swap->es_time) )
                            {
                                /* print performance info for this buffer */
                                WRITE_SVEN(SVEN_MODULE_EVENT_GV_FW_PK_ES_DONE, (int)cur, (int)cxt_swap->es_time, (int)cxt->input.phys,
                                           (int)cxt->input.len, (int)cxt->input.id, (int)cxt->input.flags );
                                cxt_swap->es_time = 0;
                            }

                            next_ret = FwIPC_ReadMessage(fwipc, rcv_q, (char *)&(cxt->input), sizeof(ipc_msg_data));
                            if(next_ret != 0)
                            {
                                data = &(cxt->input);
                                WRITE_SVEN(SVEN_MODULE_EVENT_GV_FW_PK_ES_START, (int)cur, (int)cxt_swap->wl_time,
                                           (int)cxt->input.phys, (int)cxt->input.len, (int)cxt->input.id, (int)cxt->input.flags );
                            }
                            else
                            {/* No data on input queue */
                                cxt_swap->buffered_data = 0;
                                stream_active = false;
                            }
                        }
                        break;
                        default:
                        {/* Not done with current buffer */
                            data = NULL;
                        }
                        break;
                    }
                }while(stream_active);
                get_wdog(&time);
                cxt_swap->wl_time += get_total_ticks(start_time, time);
                /* Step 5: If workload done push workload out */
                switch(pm_ret)
                {
                    case PM_EOS:
                    case PM_WKLD_DONE:
                    case PM_OVERFLOW:
                    case PM_DISCONTINUITY:
                    {/* Push current workload as we are done with the frame */
                        cxt_swap->buffered_data = (PM_WKLD_DONE == pm_ret) ? true: false;
                        viddec_pm_update_time(&(cxt->pm), cxt_swap->wl_time);

                        /* xmit performance info for this workload output */
                        WRITE_SVEN( SVEN_MODULE_EVENT_GV_FW_PK_WL_DONE, (int)cur, (int)cxt_swap->wl_time, (int)cxt->wkld1.phys,
                                    (int)cxt->wkld1.len, (int)cxt->wkld1.id, (int)cxt->wkld1.flags );
                        cxt_swap->wl_time = 0;

                        viddec_fw_push_current_frame_to_output(fwipc, cur);
                        if(pm_ret != PM_WKLD_DONE)
                        {
                            viddec_fw_handle_error_and_inband_messages(cur, pm_ret);
                        }
                        pushed_a_workload = true;
                    }
                    break;
                    default:
                        break;
                }
                /* Update information on whether we have active interrupt for this stream */
                viddec_fw_update_pending_interrupt_flag(cur, cxt_swap, pushed_a_workload, es_Q_data_at_start);
            }
            viddec_fw_debug_scheduled_stream_state(cur, false);
            /* Step 6: swap context into DDR */
            {
                cp_using_dma(cxt_swap->ddr_cxt, (uint32_t) &(cxt->pm), sizeof(viddec_pm_cxt_t), true, false);
            }
        }

    }
    return cur;
}


/*------------------------------------------------------------------------------
 * Function:  process_command
 * This magic function figures out which function to excute based on autoapi.
 *------------------------------------------------------------------------------
 */

static inline void process_command(uint32_t cmd_id, unsigned char *command)
{
    int32_t groupid = ((cmd_id >> 24) - 13) & 0xff;
    int32_t funcid = cmd_id & 0xffffff;
    /* writing func pointer to hsot doorbell */
    output_omar_wires( (int) viddec_fw_api_array[groupid].unmarshal[funcid] );
    WRITE_SVEN( SVEN_MODULE_EVENT_GV_FW_AUTOAPI_CMD,(int) cmd_id, (int) command, ((int *)command)[0],
                ((int *)command)[1], ((int *)command)[2], ((int *)command)[3] );

    viddec_fw_api_array[groupid].unmarshal[funcid](0, command);

}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_process_sync_queues(A.K.A auto api)
 * Params:
 *       [in] msg: common sync structure where all required parameters are present for autoapi.
 *
 * This function is responsible for handling synchronous messages. All synchronous messages
 * are handled through auto api.
 * what are synchronous messages?  Anything releated to teardown or opening a stream Ex: open, close, flush etc.
 *
 * Only once synchronous message at a time. When a synchronous message its id is usually in cp doorbell. Once
 * we are done handling synchronous message through auto api we release doorbell to let the host write next
 * message.
 *------------------------------------------------------------------------------
 */

static inline int32_t viddec_fw_process_sync_queues(unsigned char *msg)
{
    int32_t ret = -1;

    if(0 == reg_read(CONFIG_IPC_ROFF_RISC_DOORBELL_STATUS))
    {
        uint32_t command1=0;
        command1 = reg_read(CONFIG_IPC_ROFF_RISC_RX_DOORBELL);
        process_command(command1, msg);
        reg_write(CONFIG_IPC_ROFF_RISC_DOORBELL_STATUS, 0x2); /* Inform Host we are done with this message */
        ret = 0;
    }
    return ret;
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_check_for_pending_int
 * This function walks through all active streams to see if atleast one stream has a pending interrupt
 * and returns true if it finds one.
 *------------------------------------------------------------------------------
 */
static inline uint32_t viddec_fw_check_for_pending_int(void)
{
    uint32_t i=0, ret=false;
    /* start from 0 to max streams that fw can handle*/
    while(i < FW_SUPPORTED_STREAMS)
    {
        if(_dmem.stream_info[i].state == 1)
        {
            if((_dmem.stream_info[i].pending_interrupt) && _dmem.int_status[i].mask)
            {
                ret = true;
            }
            else
            {/* If this is not in INT state clear the status before sending it to host */
                _dmem.int_status[i].status = 0;
            }
        }
        i++;
    }
    return ret;
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_clear_processed_int
 * This function walks through all active streams to clear pending interrupt state.This is
 * called after a INT was issued.
 *------------------------------------------------------------------------------
 */
static inline void viddec_fw_clear_processed_int(void)
{
    uint32_t i=0;
    /* start from 0 to max streams that fw can handle*/
    while(i < FW_SUPPORTED_STREAMS)
    {
        //if(_dmem.stream_info[i].state == 1)
        _dmem.stream_info[i].pending_interrupt = false;
        i++;
    }
    return;
}

/*------------------------------------------------------------------------------
 * Function:  viddec_fw_int_host
 * This function interrupts host if data is available for host or any other status
 * is valid which the host configures the FW to.
 * There is only one interrupt line so this is a shared Int for all streams, Host should
 * look at status of all streams when it receives a Int.
 * The FW will interrupt the host only if host doorbell is free, in other words the host
 * should always make the doorbell free at the End of its ISR.
 *------------------------------------------------------------------------------
 */

static inline int32_t viddec_fw_int_host()
{
    /* We Interrupt the host only if host is ready to receive an interrupt */
    if((reg_read(CONFIG_IPC_ROFF_HOST_DOORBELL_STATUS) & GV_DOORBELL_STATS) == GV_DOORBELL_STATS)
    {
        if(viddec_fw_check_for_pending_int())
        {
            /* If a pending interrupt is found trigger INT */
            reg_write(CONFIG_IPC_ROFF_HOST_DOORBELL, VIDDEC_FW_PARSER_IPC_HOST_INT);
            /* Clear all stream's pending Interrupt info since we use a global INT for all streams */
            viddec_fw_clear_processed_int();
        }
    }
    return 1;
}
volatile unsigned int stack_corrupted __attribute__ ((section (".stckovrflwchk")));
/*------------------------------------------------------------------------------
 * Function:  main
 * This function is the main firmware function. Its a infinite loop where it polls
 * for messages and processes them if they are available. Currently we ping pong between
 * synchronous and asynchronous messages one at a time. If we have multiple aysnchronous
 * queues we always process only one between synchronous messages.
 *
 * For multiple asynchronous queues we round robin through the high priorities first and pick
 * the first one available. Next time when we come around for asynchronous message we start
 * from the next stream onwards so this guarantees that we give equal time slices for same
 * priority queues. If no high priority queues are active we go to low priority queues and repeat
 * the same process.
 *------------------------------------------------------------------------------
 */

int main(void)
{
    unsigned char *msg = (uint8_t *)&(_dmem.buf.data[0]);

    /* We wait until host reads sync message */
    reg_write(CONFIG_IPC_ROFF_HOST_RX_DOORBELL, GV_FW_IPC_HOST_SYNC);

    while ( GV_DOORBELL_STATS != reg_read(CONFIG_IPC_ROFF_HOST_DOORBELL_STATUS) )
    { /*poll register until done bit is set */
      /* Host re-writes Vsparc DRAM (BSS) in this loop and will hit the DONE bit when complete */
    }
    enable_intr();
    /* Initialize State for queues */
    viddec_fw_parser_register_callbacks();
    FwIPC_Initialize(GET_IPC_HANDLE(_dmem), (volatile char *)msg);
    _dmem.g_pk_data.high_id = _dmem.g_pk_data.low_id = -1;
    viddec_pm_init_ops();
    stack_corrupted = 0xDEADBEEF;
    while(1)
    {
        viddec_fw_process_sync_queues(msg);
        viddec_fw_process_async_queues();
        viddec_fw_int_host();
#if 0
        if(stack_corrupted != 0xDEADBEEF)
        {
            WRITE_SVEN(SVEN_MODULE_EVENT_GV_FW_FATAL_STACK_CORRPON, 0, 0, 0, 0, 0, 0);
            while(1);
        }
#endif
    }
    return 1;
}