#include "dwl.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* wrapper information */
typedef struct hRK70dwl {
    RK_U32 clientType;
    int fd;                  /* decoder device file */
    int fd_mem;              /* /dev/mem for mapping */
    int fd_memalloc;         /* linear memory allocator */
    volatile RK_U32 *pRegBase;  /* IO mem base */
    RK_U32 regSize;             /* IO mem size */
    RK_U32 freeLinMem;          /* Start address of free linear memory */
    RK_U32 freeRefFrmMem;       /* Start address of free reference frame memory */
    int semid;
    int sigio_needed;
#ifdef INTERNAL_TEST
    FILE *regDump;
#endif
} hRK70dwl_t;

/* HW ID retriving, static implementation */
RK_U32 DWLReadAsicID(void)
{
    return 0;
}

/* HW configuration retrieving, static implementation */
void DWLReadAsicConfig(DWLHwConfig_t * pHwCfg)
{

    pHwCfg->jpegSupport = JPEG_BASELINE;
    pHwCfg->jpegESupport = JPEG_EXT_SUPPORTED;

}

/* HW fuse retrieving, static implementation */
void DWLReadAsicFuseStatus(DWLHwFuseStatus_t * pHwFuseSts)
{
}

/* DWL initilaization and release */
const void *DWLInit(DWLInitParam_t * param)
{

    hRK70dwl_t *dec_dwl;

    dec_dwl = (hRK70dwl_t *) malloc(sizeof(hRK70dwl_t));

    return dec_dwl;
}

RK_S32 DWLRelease(const void *instance)
{
    hRK70dwl_t *dec_dwl = (hRK70dwl_t *) instance;
    free(dec_dwl);

    return (DWL_OK);
}

/* HW sharing */
RK_S32 DWLReserveHw(const void *instance)
{
    return DWL_OK;
}
void DWLReleaseHw(const void *instance)
{
    return;
}

/* Frame buffers memory */
RK_S32 DWLMallocRefFrm(const void *instance, RK_U32 size, DWLLinearMem_t * info)
{

    return DWLMallocLinear(instance, size, info);
}
void DWLFreeRefFrm(const void *instance, DWLLinearMem_t * info)
{

    DWLFreeLinear(instance, info);
}

/* SW/HW shared memory */
RK_S32 DWLMallocLinear(const void *instance, RK_U32 size, DWLLinearMem_t * info)
{

    info->size = size;
    info->virtualAddress = (RK_U32 *)malloc(size);
    info->busAddress = 0x00010000;

    return DWL_OK;
}

void DWLFreeLinear(const void *instance, DWLLinearMem_t * info)
{

    free(info->virtualAddress);
    return;
}

/* D-Cache coherence */
void DWLDCacheRangeFlush(const void *instance, DWLLinearMem_t * info)
{
    return;
}  /* NOT in use */

void DWLDCacheRangeRefresh(const void *instance, DWLLinearMem_t * info)
{
    return;
}    /* NOT in use */



/* Register access */
void DWLWriteReg(const void *instance, RK_U32 offset, RK_U32 value)
{
    return;
}


RK_U32 DWLReadReg(const void *instance, RK_U32 offset)
{
    return 0;
}

void DWLWriteRegAll(const void *instance, const RK_U32 * table, RK_U32 size)
{
    return;
} /* NOT in use */


void DWLReadRegAll(const void *instance, RK_U32 * table, RK_U32 size)
{
    return;
}    /* NOT in use */

/* HW starting/stopping */
void DWLEnableHW(const void *instance, RK_U32 offset, RK_U32 value)
{
    return;
}


void DWLDisableHW(const void *instance, RK_U32 offset, RK_U32 value)
{
    return;
}

/* HW synchronization */
RK_S32 DWLWaitHwReady(const void *instance, RK_U32 timeout)
{

    return DWL_OK;
}

/* SW/SW shared memory */
void *DWLmalloc(RK_U32 n)
{
    return malloc(n);
}


void DWLfree(void *p)
{
    free(p);
}


void *DWLcalloc(RK_U32 n, RK_U32 s)
{
    return calloc(n, s);
}

void *DWLmemcpy(void *d, const void *s, RK_U32 n)
{
    return memcpy(d, s, n);
}


void *DWLmemset(void *d, RK_S32 c, RK_U32 n)
{
    return memset(d, c, n);
}