/*
 * Copyright (C) 2020 Intel Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __CPU_MEM_SUPPORT_H
#define __CPU_MEM_SUPPORT_H

#include "storage_class.h"
#include "assert_support.h"
#include "type_support.h"

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_copy(void *dst, const void *src, unsigned int size)
{
    /* memcpy cannot be used in in Windows (function is not allowed),
     * and the safer function memcpy_s is not available on other platforms.
     * Because usage of ia_css_cpu_mem_copy is minimal, we implement it here in an easy,
     * but sub-optimal way.
     */
    unsigned int i;

    assert(dst != NULL && src != NULL);

    if (!(dst != NULL && src != NULL)) {
        return NULL;
    }
    for (i = 0; i < size; i++) {
        ((char *)dst)[i] = ((char *)src)[i];
    }
    return dst;
}

#if defined(__KERNEL__)

#include <linux/slab.h>
#include <linux/string.h>
#include <linux/types.h>
#include <asm/cacheflush.h>

/* TODO: remove, workaround for issue in hrt file ibuf_ctrl_2600_config.c
 * error checking code added to SDK that uses calls to exit function
 */
#define exit(a) return

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc(unsigned int size)
{
    return kmalloc(size, GFP_KERNEL);
}

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc_page_aligned(unsigned int size)
{
    return ia_css_cpu_mem_alloc(size); /* todo: align to page size */
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_protect(void *ptr, unsigned int size, int prot)
{
    /* nothing here yet */
}

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_set_zero(void *dst, unsigned int size)
{
    return memset(dst, 0, size); /* available in kernel in linux/string.h */
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_free(void *ptr)
{
    kfree(ptr);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_flush(void *ptr, unsigned int size)
{
    /* parameter check here */
    if (ptr == NULL)
        return;

    clflush_cache_range(ptr, size);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_invalidate(void *ptr, unsigned int size)
{
    /* for now same as flush */
    ia_css_cpu_mem_cache_flush(ptr, size);
}

#elif defined(_MSC_VER)

#include <stdlib.h>
#include <string.h>
#include <stddef.h>

extern void *hrt_malloc(size_t bytes, int zero_mem);
extern void *hrt_free(void *ptr);
extern void hrt_mem_cache_flush(void *ptr, unsigned int size);
extern void hrt_mem_cache_invalidate(void *ptr, unsigned int size);

#define malloc(a)    hrt_malloc(a, 1)
#define free(a)        hrt_free(a)

#define CSS_PAGE_SIZE    (1<<12)

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc(unsigned int size)
{
    return malloc(size);
}

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc_page_aligned(unsigned int size)
{
    unsigned int buffer_size = size;

    /* Currently hrt_malloc calls Windows ExAllocatePoolWithTag() routine
     * to request system memory. If the number of bytes is equal or bigger
     * than the page size, then the returned address is page aligned,
     * but if it's smaller it's not necessarily page-aligned We agreed
     * with Windows team that we allocate a full page
     * if it's less than page size
    */
    if (buffer_size < CSS_PAGE_SIZE)
        buffer_size = CSS_PAGE_SIZE;

    return ia_css_cpu_mem_alloc(buffer_size);
}

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_set_zero(void *dst, unsigned int size)
{
    return memset(dst, 0, size);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_free(void *ptr)
{
    free(ptr);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_flush(void *ptr, unsigned int size)
{
#ifdef _KERNEL_MODE
    hrt_mem_cache_flush(ptr, size);
#else
    (void)ptr;
    (void)size;
#endif
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_invalidate(void *ptr, unsigned int size)
{
#ifdef _KERNEL_MODE
    hrt_mem_cache_invalidate(ptr, size);
#else
    (void)ptr;
    (void)size;
#endif
}

#else

#include <stdlib.h>
#include <string.h>
#include <stddef.h>
/* Needed for the MPROTECT */
#include <unistd.h>
#include <sys/types.h>

/* For host only, not fw */
#ifndef __XTENSA_FW__
#include <sys/mman.h>
#include <malloc.h>
#endif

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc(unsigned int size)
{
    return malloc(size);
}

#ifdef _SC_PAGE_SIZE
STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_alloc_page_aligned(unsigned int size)
{
    int pagesize;

    pagesize = sysconf(_SC_PAGE_SIZE);
    return memalign(pagesize, size);
}
#endif /*_SC_PAGE_SIZE*/

STORAGE_CLASS_INLINE void*
ia_css_cpu_mem_set_zero(void *dst, unsigned int size)
{
    return memset(dst, 0, size);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_free(void *ptr)
{
    free(ptr);
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_flush(void *ptr, unsigned int size)
{
    /* not needed in simulation */
    (void)ptr;
    (void)size;
}

STORAGE_CLASS_INLINE void
ia_css_cpu_mem_cache_invalidate(void *ptr, unsigned int size)
{
    /* not needed in simulation */
    (void)ptr;
    (void)size;
}

#endif

#endif /* __CPU_MEM_SUPPORT_H */