124 lines
2.7 KiB
C
Executable file
124 lines
2.7 KiB
C
Executable file
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2019 MediaTek Inc.
|
|
*/
|
|
|
|
#include "mdla_debug.h"
|
|
#include "gsm.h"
|
|
#include "mdla.h"
|
|
|
|
#include <linux/bitmap.h>
|
|
#include <asm/page.h>
|
|
#include <linux/io.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
|
|
#define GSM_BITMAP_SIZE (GSM_SIZE/PAGE_SIZE)
|
|
DECLARE_BITMAP(gsm_bitmap, GSM_BITMAP_SIZE);
|
|
DEFINE_SPINLOCK(gsm_lock);
|
|
|
|
void *gsm_alloc(size_t size)
|
|
{
|
|
unsigned long flags;
|
|
int pageno;
|
|
int order = get_order(size);
|
|
|
|
spin_lock_irqsave(&gsm_lock, flags);
|
|
pageno = bitmap_find_free_region(
|
|
gsm_bitmap, GSM_BITMAP_SIZE, order);
|
|
spin_unlock_irqrestore(&gsm_lock, flags);
|
|
if (unlikely(pageno < 0))
|
|
return NULL;
|
|
return apu_mdla_gsm_top + (pageno << PAGE_SHIFT);
|
|
}
|
|
|
|
void *gsm_mva_to_virt(u32 mva)
|
|
{
|
|
return (void *)(mva - GSM_MVA_BASE + apu_mdla_gsm_top);
|
|
}
|
|
|
|
#define is_gsm_virt(a) \
|
|
(likely(((a) >= apu_mdla_gsm_top) && \
|
|
((a) < (apu_mdla_gsm_top + SZ_1M))))
|
|
|
|
#define gsm_virt_offset(a) \
|
|
((a) - apu_mdla_gsm_top)
|
|
|
|
static u32 gsm_virt_to_mva(void *vaddr)
|
|
{
|
|
if (is_gsm_virt(vaddr))
|
|
return (u32)(gsm_virt_offset(vaddr) + GSM_MVA_BASE);
|
|
|
|
return GSM_MVA_INVALID;
|
|
}
|
|
|
|
static void *gsm_virt_to_pa(void *vaddr)
|
|
{
|
|
if (is_gsm_virt(vaddr))
|
|
return (apu_mdla_gsm_base + gsm_virt_offset(vaddr));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int gsm_release(void *vaddr, size_t size)
|
|
{
|
|
unsigned long flags;
|
|
int order = get_order(size);
|
|
int page = (vaddr - apu_mdla_gsm_top) >> PAGE_SHIFT;
|
|
|
|
if ((page >= GSM_BITMAP_SIZE) || (page < 0))
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&gsm_lock, flags);
|
|
bitmap_release_region(gsm_bitmap, page, order);
|
|
spin_unlock_irqrestore(&gsm_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int mdla_gsm_alloc(struct ioctl_malloc *malloc_data)
|
|
{
|
|
int ret = 0;
|
|
int ex = 0;
|
|
void *ptr;
|
|
u32 size = malloc_data->size;
|
|
|
|
if (size == GSM_MVA_INVALID) {
|
|
size = GSM_SIZE;
|
|
mdla_mem_debug("%s: <exclusive mode>\n", __func__);
|
|
ex = 1;
|
|
}
|
|
ptr = gsm_alloc(size);
|
|
|
|
if (ptr == NULL)
|
|
ret = -ENOMEM;
|
|
|
|
malloc_data->size = size;
|
|
malloc_data->kva = (ex) ? apu_mdla_gsm_top : ptr;
|
|
malloc_data->mva = gsm_virt_to_mva(malloc_data->kva);
|
|
malloc_data->pa = gsm_virt_to_pa(malloc_data->kva);
|
|
#ifdef CONFIG_FPGA_EARLY_PORTING
|
|
/* avoid bus hang in fpga stage */
|
|
malloc_data->pa = (void *)((long) malloc_data->mva);
|
|
#endif
|
|
mdla_mem_debug("%s: ret: %d, kva:%p, mva:%x, pa:%p, size:%x\n",
|
|
__func__, ret,
|
|
malloc_data->kva, malloc_data->mva,
|
|
malloc_data->pa, malloc_data->size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void mdla_gsm_free(struct ioctl_malloc *malloc_data)
|
|
{
|
|
if (malloc_data->size > GSM_SIZE)
|
|
return;
|
|
if (malloc_data->kva)
|
|
gsm_release(malloc_data->kva, malloc_data->size);
|
|
mdla_mem_debug("%s: kva:%p, mva:%x, pa:%p, size:%x\n", __func__,
|
|
malloc_data->kva, malloc_data->mva,
|
|
malloc_data->pa, malloc_data->size);
|
|
}
|
|
|