lai/hisi_SS524V100_SDK
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
48fc4058d8adc0189830ca139c81a1d0ea059d2e
hisi_SS524V100_SDK/osal/linux/mmz/media_mem.c
T

1243 lines
30 KiB
C
Raw Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include <generated/autoconf.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/miscdevice.h>
#include <linux/proc_fs.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/version.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/spinlock.h>
#include <linux/vmalloc.h>
#include <asm/cacheflush.h>
#ifndef CONFIG_64BIT
#include <linux/highmem.h>
#include <asm/pgtable.h>
#endif
#include <linux/seq_file.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/time.h>
#include <linux/dma-mapping.h>
#include "securec.h"
#include "ot_osal.h"
#include "allocator.h"
#include "mmz.h"
OSAL_LIST_HEAD(g_mmz_list);
OSAL_LIST_HEAD(g_map_mmz_list);
int anony = 0;
static DEFINE_SEMAPHORE(g_mmz_lock);
module_param(anony, int, S_IRUGO);
#define MMZ_SETUP_CMDLINE_LEN 256
#define MMZ_ALLOCATOR_NAME_LEN 32
#ifndef MODULE
static char __initdata g_setup_zones[MMZ_SETUP_CMDLINE_LEN] = {'\0'};
static int __init parse_kern_cmdline(char *line)
{
if (strncpy_s(g_setup_zones, sizeof(g_setup_zones), line, sizeof(g_setup_zones) - 1) != EOK) {
osal_trace("%s - strncpy_s failed!\n", __FUNCTION__);
return -1;
}
return 1;
}
__setup("mmz=", parse_kern_cmdline);
static char __initdata g_setup_allocator[MMZ_ALLOCATOR_NAME_LEN];
static int __init parse_kern_allocator(char *line)
{
if (strncpy_s(g_setup_allocator, sizeof(g_setup_allocator), line, sizeof(g_setup_allocator) - 1) != EOK) {
osal_trace("%s - strncpy_s failed!\n", __FUNCTION__);
return -1;
}
return 1;
}
__setup("mmz_allocator=", parse_kern_allocator);
static char __initdata g_mmap_zones[MMZ_SETUP_CMDLINE_LEN] = {'\0'};
__setup("map_mmz=", parse_kern_cmdline);
#else
static char g_setup_zones[MMZ_SETUP_CMDLINE_LEN] = {'\0'};
static char g_mmap_zones[MMZ_SETUP_CMDLINE_LEN] = {'\0'};
static char g_setup_allocator[MMZ_ALLOCATOR_NAME_LEN] = "ot"; /* default setting */
module_param_string(mmz, g_setup_zones, MMZ_SETUP_CMDLINE_LEN, 0600);
module_param_string(map_mmz, g_mmap_zones, MMZ_SETUP_CMDLINE_LEN, 0600);
module_param_string(mmz_allocator, g_setup_allocator, MMZ_ALLOCATOR_NAME_LEN, 0600);
MODULE_PARM_DESC(mmz, "mmz_allocator=allocator mmz=name,0,start,size,type,eqsize:[others] map_mmz=start,size:[others]");
#endif
static struct mmz_allocator g_the_allocator;
int ot_mmz_get_anony(void)
{
return anony;
}
struct osal_list_head *ot_mmz_get_mmz_list(void)
{
return &g_mmz_list;
}
ot_mmz_t *ot_mmz_create(const char *name,
unsigned long gfp,
unsigned long phys_start,
unsigned long nbytes)
{
ot_mmz_t *p = NULL;
if (name == NULL) {
osal_trace(KERN_ERR "%s: 'name' should not be NULL!", __FUNCTION__);
return NULL;
}
p = kmalloc(sizeof(ot_mmz_t) + 1, GFP_KERNEL);
if (p == NULL) {
osal_trace(KERN_ERR "%s: System OOM!\n", __func__);
return NULL;
}
(void)memset_s(p, sizeof(ot_mmz_t) + 1, 0, sizeof(ot_mmz_t) + 1);
if (strncpy_s(p->name, OT_MMZ_NAME_LEN, name, OT_MMZ_NAME_LEN - 1) != EOK) {
osal_trace("%s - strncpy_s failed!\n", __FUNCTION__);
kfree(p);
return NULL;
}
p->gfp = gfp;
p->phys_start = phys_start;
p->nbytes = nbytes;
OSAL_INIT_LIST_HEAD(&p->list);
OSAL_INIT_LIST_HEAD(&p->mmb_list);
p->destructor = kfree;
return p;
}
EXPORT_SYMBOL(ot_mmz_create);
ot_mmz_t *ot_mmz_create_v2(const char *name, const ot_mmz_create_attr *mmz_create_attr)
{
ot_mmz_t *p = NULL;
if ((name == NULL) || (mmz_create_attr == NULL)) {
osal_trace(KERN_ERR "%s: 'name' or mmz_attr can not be zero!", __FUNCTION__);
return NULL;
}
p = kmalloc(sizeof(ot_mmz_t), GFP_KERNEL);
if (p == NULL) {
return NULL;
}
(void)memset_s(p, sizeof(ot_mmz_t), 0, sizeof(ot_mmz_t));
if (strncpy_s(p->name, OT_MMZ_NAME_LEN, name, OT_MMZ_NAME_LEN - 1) != EOK) {
osal_trace("%s - strncpy_s failed!\n", __FUNCTION__);
kfree(p);
return NULL;
}
p->gfp = mmz_create_attr->gfp;
p->phys_start = mmz_create_attr->phys_start;
p->nbytes = mmz_create_attr->nbytes;
p->alloc_type = mmz_create_attr->alloc_type;
p->block_align = mmz_create_attr->block_align;
OSAL_INIT_LIST_HEAD(&p->list);
OSAL_INIT_LIST_HEAD(&p->mmb_list);
p->destructor = kfree;
return p;
}
int ot_mmz_destroy(const ot_mmz_t *zone)
{
if (zone == NULL) {
return -1;
}
if (zone->destructor) {
zone->destructor(zone);
}
return 0;
}
EXPORT_SYMBOL(ot_mmz_destroy);
static int _check_mmz(const ot_mmz_t *zone)
{
ot_mmz_t *p = NULL;
unsigned long new_start = zone->phys_start;
unsigned long new_end = zone->phys_start + zone->nbytes;
if (zone->nbytes == 0) {
return -1;
}
if (!((new_start >= __pa((uintptr_t)high_memory)) ||
((new_start < PHYS_OFFSET) && (new_end <= PHYS_OFFSET)))) {
osal_trace(KERN_ERR "ERROR: Conflict MMZ:\n");
osal_trace(KERN_ERR OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(zone));
osal_trace(KERN_ERR "MMZ conflict to kernel memory (0x%08lX, 0x%08lX)\n",
(long unsigned int)PHYS_OFFSET,
(long unsigned int)(__pa((uintptr_t)high_memory) - 1));
return -1;
}
osal_list_for_each_entry(p, &g_mmz_list, list) {
unsigned long start, end;
start = p->phys_start;
end = p->phys_start + p->nbytes;
if (new_start >= end) {
continue;
} else if (new_start < start && new_end <= start) {
continue;
} else {
}
osal_trace(KERN_ERR "ERROR: Conflict MMZ:\n");
osal_trace(KERN_ERR "MMZ new: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(zone));
osal_trace(KERN_ERR "MMZ exist: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(p));
osal_trace(KERN_ERR "Add new MMZ failed!\n");
return -1;
}
return 0;
}
int ot_mmz_register(ot_mmz_t *zone)
{
int ret;
mmz_trace(1, OT_MMZ_FMT_S, ot_mmz_fmt_arg(zone));
if (zone == NULL) {
return -1;
}
down(&g_mmz_lock);
if (strcmp(g_setup_allocator, "ot") == 0) {
ret = _check_mmz(zone);
if (ret) {
up(&g_mmz_lock);
return ret;
}
}
OSAL_INIT_LIST_HEAD(&zone->mmb_list);
osal_list_add(&zone->list, &g_mmz_list);
up(&g_mmz_lock);
return 0;
}
int ot_mmz_unregister(ot_mmz_t *zone)
{
int losts = 0;
ot_mmb_t *p = NULL;
if (zone == NULL) {
return -1;
}
down(&g_mmz_lock);
osal_list_for_each_entry(p, &zone->mmb_list, list) {
osal_trace(KERN_WARNING "MB Lost: " OT_MMB_FMT_S "\n",
ot_mmb_fmt_arg(p));
losts++;
}
if (losts) {
osal_trace(KERN_ERR "%d mmbs not free, mmz<%s> can not be unregistered!\n",
losts, zone->name);
up(&g_mmz_lock);
return -1;
}
osal_list_del(&zone->list);
up(&g_mmz_lock);
return 0;
}
ot_mmb_t *ot_mmb_alloc(const char *name,
unsigned long size,
unsigned long align,
unsigned long gfp,
const char *mmz_name)
{
ot_mmb_t *mmb = NULL;
down(&g_mmz_lock);
if (g_the_allocator.mmb_alloc != NULL) {
mmb = g_the_allocator.mmb_alloc(name, size, align, gfp, mmz_name, NULL);
}
up(&g_mmz_lock);
return mmb;
}
EXPORT_SYMBOL(ot_mmb_alloc);
ot_mmb_t *ot_mmb_alloc_v2(const char *name,
unsigned long size,
unsigned long align,
unsigned long gfp,
const char *mmz_name,
unsigned int order)
{
ot_mmb_t *mmb = NULL;
down(&g_mmz_lock);
if (g_the_allocator.mmb_alloc_v2 != NULL) {
mmb = g_the_allocator.mmb_alloc_v2(name, size, align,
gfp, mmz_name, NULL, order);
}
up(&g_mmz_lock);
return mmb;
}
EXPORT_SYMBOL(ot_mmb_alloc_v2);
ot_mmb_t *ot_mmb_alloc_v3(const ot_mmz_alloc_para_in *para_in, ot_mmz_alloc_para_out *para_out)
{
ot_mmb_t *mmb = NULL;
if (para_in == NULL || para_out == NULL) {
return NULL;
}
down(&g_mmz_lock);
if (g_the_allocator.mmb_alloc != NULL) {
mmb = g_the_allocator.mmb_alloc_v3(para_in, para_out);
}
up(&g_mmz_lock);
return mmb;
}
EXPORT_SYMBOL(ot_mmb_alloc_v3);
ot_mmb_t *ot_mmb_alloc_in(const char *name,
unsigned long size,
unsigned long align,
const ot_mmz_t *_user_mmz)
{
ot_mmb_t *mmb = NULL;
if (_user_mmz == NULL) {
return NULL;
}
down(&g_mmz_lock);
if (g_the_allocator.mmb_alloc != NULL) {
mmb = g_the_allocator.mmb_alloc(name, size, align,
_user_mmz->gfp, _user_mmz->name, _user_mmz);
}
up(&g_mmz_lock);
return mmb;
}
ot_mmb_t *ot_mmb_alloc_in_v2(const char *name,
unsigned long size,
unsigned long align,
const ot_mmz_t *_user_mmz,
unsigned int order)
{
ot_mmb_t *mmb = NULL;
if (_user_mmz == NULL) {
return NULL;
}
down(&g_mmz_lock);
if (g_the_allocator.mmb_alloc_v2 != NULL) {
mmb = g_the_allocator.mmb_alloc_v2(name, size, align, _user_mmz->gfp,
_user_mmz->name, _user_mmz, order);
}
up(&g_mmz_lock);
return mmb;
}
void *ot_mmb_map2kern(ot_mmb_t *mmb)
{
void *p = NULL;
if (mmb == NULL) {
return NULL;
}
down(&g_mmz_lock);
if (g_the_allocator.mmb_map2kern != NULL) {
p = g_the_allocator.mmb_map2kern(mmb, 0);
}
up(&g_mmz_lock);
return p;
}
EXPORT_SYMBOL(ot_mmb_map2kern);
/* mmf: media-memory fragment */
void *ot_mmf_map2kern_nocache(unsigned long phys, int len)
{
void *virt = g_the_allocator.mmf_map(phys, len, 0);
if (virt != NULL) {
return virt;
}
return NULL;
}
EXPORT_SYMBOL(ot_mmf_map2kern_nocache);
void *ot_mmf_map2kern_cache(unsigned long phys, int len)
{
void *virt = g_the_allocator.mmf_map(phys, len, 1);
if (virt != NULL) {
return virt;
}
return NULL;
}
EXPORT_SYMBOL(ot_mmf_map2kern_cache);
void ot_mmf_unmap(void *virt)
{
if (g_the_allocator.mmf_unmap != NULL) {
g_the_allocator.mmf_unmap(virt);
}
}
EXPORT_SYMBOL(ot_mmf_unmap);
void *ot_mmb_map2kern_cached(ot_mmb_t *mmb)
{
void *p = NULL;
if (mmb == NULL) {
return NULL;
}
down(&g_mmz_lock);
if (g_the_allocator.mmb_map2kern != NULL) {
p = g_the_allocator.mmb_map2kern(mmb, 1);
}
up(&g_mmz_lock);
return p;
}
EXPORT_SYMBOL(ot_mmb_map2kern_cached);
int ot_mmb_flush_dcache_byaddr(void *kvirt,
unsigned long phys_addr,
unsigned long length)
{
if (kvirt == NULL) {
return -EINVAL;
}
/*
* Use flush range to instead flush_cache_all,
* because flush_cache_all only flush local cpu.
* And on_each_cpu macro cannot used to flush
* all cpus with irq disabled.
*/
#ifdef CONFIG_64BIT
__flush_dcache_area(kvirt, length);
#else
/*
* dmac_map_area is invalid in kernel,
* arm9 is not supported yet
*/
__cpuc_flush_dcache_area(kvirt, length);
#endif
#ifdef CONFIG_CACHE_L2X0
/* flush l2 cache, use paddr */
/*
* if length > L2 cache size, then this interface
* will call <outer_flush_all>
*/
outer_flush_range(phys_addr, phys_addr + length);
#endif
return 0;
}
EXPORT_SYMBOL(ot_mmb_flush_dcache_byaddr);
int ot_mmb_invalid_cache_byaddr(void *kvirt,
unsigned long phys_addr,
unsigned long length)
{
if (kvirt == NULL) {
return -EINVAL;
}
#ifdef CONFIG_64BIT
__flush_dcache_area(kvirt, length);
#else
/*
* dmac_map_area is invalid in kernel,
* arm9 is not supported yet
*/
__cpuc_flush_dcache_area(kvirt, length);
#endif
return 0;
}
EXPORT_SYMBOL(ot_mmb_invalid_cache_byaddr);
int ot_mmb_unmap(ot_mmb_t *mmb)
{
int ref;
if ((mmb == NULL) || (g_the_allocator.mmb_unmap == NULL)) {
return -1;
}
down(&g_mmz_lock);
ref = g_the_allocator.mmb_unmap(mmb);
up(&g_mmz_lock);
return ref;
}
EXPORT_SYMBOL(ot_mmb_unmap);
int ot_mmb_get(ot_mmb_t *mmb)
{
int ref;
if (mmb == NULL) {
return -1;
}
down(&g_mmz_lock);
if (mmb->flags & OT_MMB_RELEASED)
osal_trace(KERN_WARNING "ot_mmb_get: amazing, mmb<%s> is released!\n", mmb->name);
ref = ++mmb->phy_ref;
up(&g_mmz_lock);
return ref;
}
int ot_mmb_put(ot_mmb_t *mmb)
{
int ref;
if (mmb == NULL) {
return -1;
}
down(&g_mmz_lock);
if (mmb->flags & OT_MMB_RELEASED) {
osal_trace(KERN_WARNING "ot_mmb_put: amazing, mmb<%s> is released!\n", mmb->name);
}
ref = --mmb->phy_ref;
if ((mmb->flags & OT_MMB_RELEASED) && (mmb->phy_ref == 0) && (mmb->map_ref == 0)) {
if (g_the_allocator.mmb_free != NULL) {
g_the_allocator.mmb_free(mmb);
}
}
up(&g_mmz_lock);
return ref;
}
int ot_mmb_free(ot_mmb_t *mmb)
{
if (mmb == NULL) {
return -1;
}
mmz_trace(1, OT_MMB_FMT_S, ot_mmb_fmt_arg(mmb));
down(&g_mmz_lock);
if (mmb->flags & OT_MMB_RELEASED) {
osal_trace(KERN_WARNING "ot_mmb_free: amazing, mmb<%s> has been released, but is still in use!\n", mmb->name);
up(&g_mmz_lock);
return 0;
}
if (mmb->phy_ref > 0) {
osal_trace(KERN_WARNING "ot_mmb_free: free mmb<%s> delayed for which ref-count is %d!\n",
mmb->name, mmb->map_ref);
mmb->flags |= OT_MMB_RELEASED;
up(&g_mmz_lock);
return 0;
}
if (mmb->flags & OT_MMB_MAP2KERN) {
osal_trace(KERN_WARNING "free mmb<%s> delayed for which is kernel-mapped to 0x%pK with map_ref %d!\n",
mmb->name, mmb->kvirt, mmb->map_ref);
mmb->flags |= OT_MMB_RELEASED;
up(&g_mmz_lock);
return 0;
}
if (g_the_allocator.mmb_free != NULL) {
g_the_allocator.mmb_free(mmb);
}
up(&g_mmz_lock);
return 0;
}
EXPORT_SYMBOL(ot_mmb_free);
#define mach_mmb(p, val, member) do { \
ot_mmz_t *__mach_mmb_zone__ = NULL; \
(p) = NULL; \
list_for_each_entry(__mach_mmb_zone__, &g_mmz_list, list) { \
ot_mmb_t *__mach_mmb__ = NULL; \
list_for_each_entry(__mach_mmb__, &__mach_mmb_zone__->mmb_list, list) { \
if (__mach_mmb__->member == (val)) { \
(p) = __mach_mmb__; \
break; \
} \
} \
if ((p) != NULL) { \
break; \
} \
} \
} while (0)
ot_mmb_t *ot_mmb_getby_phys(unsigned long addr)
{
ot_mmb_t *p = NULL;
down(&g_mmz_lock);
mach_mmb(p, addr, phys_addr);
up(&g_mmz_lock);
return p;
}
EXPORT_SYMBOL(ot_mmb_getby_phys);
unsigned long usr_virt_to_phys(unsigned long virt)
{
pgd_t *pgd = NULL;
pud_t *pud = NULL;
pmd_t *pmd = NULL;
pte_t *pte = NULL;
p4d_t *p4d = NULL;
unsigned int cacheable = 0;
unsigned long page_addr;
unsigned long page_offset;
unsigned long phys_addr;
if (virt & 0x3) {
osal_trace("invalid virt addr 0x%08lx[not 4 bytes align]\n", virt);
return 0;
}
if (virt >= PAGE_OFFSET) {
osal_trace("invalid user space virt addr 0x%08lx\n", virt);
return 0;
}
pgd = pgd_offset(current->mm, virt);
if (pgd_none(*pgd)) {
osal_trace("osal_trace: not mapped in pgd!\n");
return 0;
}
p4d = p4d_offset(pgd, virt);
if (p4d_none(*p4d)) {
osal_trace("osal_trace: not mapped in p4d!\n");
return 0;
}
pud = pud_offset(p4d, virt);
if (pud_none(*pud)) {
osal_trace("osal_trace: not mapped in pud!\n");
return 0;
}
pmd = pmd_offset(pud, virt);
if (pmd_none(*pmd)) {
osal_trace("osal_trace: not mapped in pmd!\n");
return 0;
}
pte = pte_offset_map(pmd, virt);
if (pte_none(*pte)) {
osal_trace("osal_trace: not mapped in pte!\n");
pte_unmap(pte);
return 0;
}
page_addr = (unsigned long)((pte_val(*pte) & PHYS_MASK) & PAGE_MASK);
page_offset = virt & ~PAGE_MASK;
phys_addr = page_addr | page_offset;
#ifdef CONFIG_64BIT
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0)
if (((pte_val(*pte) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL)) ||
((pte_val(*pte) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL_TAGGED))) {
#else
if (pte_val(*pte) & (1 << 4)) { /* 4: cacheable flag of 64-bit linux is bit 4 */
#endif
#else
if (pte_val(*pte) & (1 << 3)) { /* 3: cacheable flag of 32-bit linux is bit 3 */
#endif
cacheable = 1;
}
/*
* phys_addr: the lowest bit indicates its cache attribute
* 1: cacheable
* 0: uncacheable
*/
phys_addr |= cacheable;
pte_unmap(pte);
return phys_addr;
}
EXPORT_SYMBOL(usr_virt_to_phys);
#define mach_mmb_2(p, val, member, out_offset) do { \
ot_mmz_t *__mach_mmb_zone__ = NULL; \
(p) = NULL; \
list_for_each_entry(__mach_mmb_zone__, &g_mmz_list, list) { \
ot_mmb_t *__mach_mmb__ = NULL; \
list_for_each_entry(__mach_mmb__, &__mach_mmb_zone__->mmb_list, list) { \
if ((__mach_mmb__->member <= (val)) && ((__mach_mmb__->length + __mach_mmb__->member) > (val))) { \
(p) = __mach_mmb__; \
(out_offset) = (val) - __mach_mmb__->member; \
break; \
} \
} \
if ((p) != NULL) { \
break; \
} \
} \
} while (0)
ot_mmb_t *ot_mmb_getby_kvirt(const void *virt)
{
ot_mmb_t *p = NULL;
unsigned long out_offset;
if (virt == NULL) {
return NULL;
}
down(&g_mmz_lock);
mach_mmb_2(p, virt, kvirt, out_offset);
up(&g_mmz_lock);
mmz_trace(1, "Outoffset %lu \n", out_offset);
return p;
}
EXPORT_SYMBOL(ot_mmb_getby_kvirt);
ot_mmb_t *ot_mmb_getby_phys_2(unsigned long addr, unsigned long *out_offset)
{
ot_mmb_t *p = NULL;
down(&g_mmz_lock);
mach_mmb_2(p, addr, phys_addr, *out_offset);
up(&g_mmz_lock);
return p;
}
EXPORT_SYMBOL(ot_mmb_getby_phys_2);
ot_mmz_t *ot_mmz_find(unsigned long gfp, const char *mmz_name)
{
ot_mmz_t *p = NULL;
down(&g_mmz_lock);
begin_list_for_each_mmz(p, gfp, mmz_name)
up(&g_mmz_lock);
return p;
end_list_for_each_mmz()
up(&g_mmz_lock);
return NULL;
}
EXPORT_SYMBOL(ot_mmz_find);
unsigned long ot_mmz_get_phys(const char *zone_name)
{
ot_mmz_t *zone = NULL;
zone = ot_mmz_find(0, zone_name);
if (zone != NULL) {
return zone->phys_start;
}
return 0;
}
EXPORT_SYMBOL(ot_mmz_get_phys);
static unsigned long _strtoul_ex(const char *s, char **ep, unsigned int base)
{
char *__end_p = NULL;
unsigned long __value;
__value = simple_strtoul(s, &__end_p, base);
switch (*__end_p) {
case 'm':
case 'M':
__value <<= 10; /* 10: 1M=1024k, left shift 10bit */
/* fall-through */
case 'k':
case 'K':
__value <<= 10; /* 10: 1K=1024Byte, left shift 10bit */
if (ep != NULL) {
(*ep) = __end_p + 1;
}
/* fall-through */
default:
break;
}
return __value;
}
static int _check_map_mmz(const ot_mmz_t *zone)
{
ot_mmz_t *p = NULL;
unsigned long new_start = zone->phys_start;
unsigned long new_end = zone->phys_start + zone->nbytes;
if (zone->nbytes == 0) {
return -1;
}
osal_list_for_each_entry(p, &g_map_mmz_list, list) {
unsigned long start, end;
start = p->phys_start;
end = p->phys_start + p->nbytes;
if (new_start >= end) {
continue;
} else if ((new_start < start) && (new_end <= start)) {
continue;
} else {
}
osal_trace(KERN_ERR "ERROR: Conflict MMZ:\n");
osal_trace(KERN_ERR "MMZ new: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(zone));
osal_trace(KERN_ERR "MMZ exist: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(p));
osal_trace(KERN_ERR "Add new MMZ failed!\n");
return -1;
}
return 0;
}
int ot_map_mmz_register(ot_mmz_t *zone)
{
int ret;
mmz_trace(1, OT_MMZ_FMT_S, ot_mmz_fmt_arg(zone));
if (zone == NULL) {
return -1;
}
down(&g_mmz_lock);
if (strcmp(g_setup_allocator, "ot") == 0) {
ret = _check_mmz(zone);
if (ret != 0) {
up(&g_mmz_lock);
return ret;
}
}
ret = _check_map_mmz(zone);
if (ret) {
up(&g_mmz_lock);
return ret;
}
OSAL_INIT_LIST_HEAD(&zone->mmb_list);
osal_list_add(&zone->list, &g_map_mmz_list);
up(&g_mmz_lock);
return 0;
}
int ot_map_mmz_unregister(ot_mmz_t *zone)
{
int losts = 0;
ot_mmb_t *p = NULL;
if (zone == NULL) {
return -1;
}
down(&g_mmz_lock);
osal_list_for_each_entry(p, &zone->mmb_list, list) {
osal_trace(KERN_WARNING "MB Lost: " OT_MMB_FMT_S "\n",
ot_mmb_fmt_arg(p));
losts++;
}
if (losts) {
osal_trace(KERN_ERR "%d mmbs not free, mmz<%s> can not be unregistered!\n",
losts, zone->name);
up(&g_mmz_lock);
return -1;
}
osal_list_del(&zone->list);
up(&g_mmz_lock);
return 0;
}
static int map_mmz_init(char *s)
{
ot_mmz_t *zone = NULL;
char *line = NULL;
if (s[0] == '\0') {
return 0;
}
while ((line = strsep(&s, ":")) != NULL) {
int i;
char *argv[2]; /* 2: map mmz has two arguments */
for (i = 0; (argv[i] = strsep(&line, ",")) != NULL;) {
if (++i == ARRAY_SIZE(argv)) {
break;
}
}
if (i == 2) { /* 2: had parse two args */
zone = ot_mmz_create("null", 0, 0, 0);
if (zone == NULL) {
continue;
}
zone->phys_start = _strtoul_ex(argv[0], NULL, 0);
zone->nbytes = _strtoul_ex(argv[1], NULL, 0);
} else {
osal_trace(KERN_ERR "error parameters\n");
return -EINVAL;
}
if (ot_map_mmz_register(zone)) {
osal_trace(KERN_WARNING "Add MMZ failed: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(zone));
ot_mmz_destroy(zone);
}
zone = NULL;
}
return 0;
}
static void map_mmz_exit(void)
{
ot_mmz_t *pmmz = NULL;
struct osal_list_head *p = NULL;
struct osal_list_head *n = NULL;
list_for_each_safe(p, n, &g_map_mmz_list) {
pmmz = list_entry(p, ot_mmz_t, list);
osal_trace(KERN_WARNING "MMZ force removed: " OT_MMZ_FMT_S "\n",
ot_mmz_fmt_arg(pmmz));
ot_map_mmz_unregister(pmmz);
ot_mmz_destroy(pmmz);
}
}
int ot_map_mmz_check_phys(unsigned long addr_start, unsigned long addr_len)
{
ot_mmz_t *p = NULL;
unsigned long addr_end = addr_start + addr_len;
unsigned long temp_start, temp_end;
if ((addr_len > 0) && (addr_end > addr_start)) {
osal_list_for_each_entry(p, &g_map_mmz_list, list) {
temp_start = p->phys_start;
temp_end = p->phys_start + p->nbytes;
if ((addr_start >= temp_start) && (addr_end <= temp_end)) {
return 0;
}
}
}
osal_trace(KERN_ERR "ERROR: MMAP ADDR: 0x%lx-0x%lx\n", addr_start, addr_end);
return -1;
}
EXPORT_SYMBOL(ot_map_mmz_check_phys);
int ot_vma_check(unsigned long vm_start, unsigned long vm_end)
{
struct vm_area_struct *pvma1 = NULL;
struct vm_area_struct *pvma2 = NULL;
pvma1 = find_vma(current->mm, vm_start);
if (pvma1 == NULL) {
osal_trace(KERN_ERR "ERROR: pvma1 is null\n");
return -1;
}
pvma2 = find_vma(current->mm, vm_end - 1);
if (pvma2 == NULL) {
osal_trace(KERN_ERR "ERROR: pvma2 is null\n");
return -1;
}
if (pvma1 != pvma2) {
osal_trace(KERN_ERR "ERROR: pvma1:[0x%lx,0x%lx) and pvma2:[0x%lx,0x%lx) are not equal\n",
pvma1->vm_start, pvma1->vm_end, pvma2->vm_start, pvma2->vm_end);
return -1;
}
if (!(pvma1->vm_flags & VM_WRITE)) {
osal_trace(KERN_ERR "ERROR vma flag:0x%lx\n", pvma1->vm_flags);
return -1;
}
if (pvma1->vm_start > vm_start) {
osal_trace("cannot find corresponding vma, vm[%lx, %lx], user range[%lx,%lx]\n",
pvma1->vm_start, pvma1->vm_end, vm_start, vm_end);
return -1;
}
return 0;
}
EXPORT_SYMBOL(ot_vma_check);
int ot_is_phys_in_mmz(unsigned long addr_start, unsigned long addr_len)
{
ot_mmz_t *p = NULL;
unsigned long addr_end = addr_start + addr_len;
unsigned long temp_start, temp_end;
if ((addr_len > 0) && (addr_end > addr_start)) {
osal_list_for_each_entry(p, &g_mmz_list, list) {
temp_start = p->phys_start;
temp_end = p->phys_start + p->nbytes;
if ((addr_start >= temp_start) && (addr_end <= temp_end)) {
return 0;
}
}
}
return -1;
}
EXPORT_SYMBOL(ot_is_phys_in_mmz);
int ot_mmb_flush_dcache_byaddr_safe(void *kvirt,
unsigned long phys_addr,
unsigned long length)
{
int ret;
struct mm_struct *mm = current->mm;
if (kvirt == NULL) {
return -EINVAL;
}
mmz_map_down(mm);
if (ot_vma_check((unsigned long)(uintptr_t)kvirt, (unsigned long)(uintptr_t)kvirt + length)) {
mmz_map_up(mm);
return -EPERM;
}
ret = ot_mmb_flush_dcache_byaddr(kvirt, phys_addr, length);
mmz_map_up(mm);
return ret;
}
EXPORT_SYMBOL(ot_mmb_flush_dcache_byaddr_safe);
#define MEDIA_MEM_NAME "media-mem"
#ifdef CONFIG_OT_PROC_SHOW_SUPPORT
int mmz_seq_show(struct osal_proc_dir_entry *sfile)
{
ot_mmz_t *p = NULL;
unsigned int zone_number = 0;
unsigned int block_number = 0;
unsigned int used_size = 0;
unsigned int free_size;
unsigned int mmz_total_size = 0;
down(&g_mmz_lock);
list_for_each_entry(p, &g_mmz_list, list) {
ot_mmb_t *mmb = NULL;
ot_mmb_t *temp_mmb = NULL;
osal_seq_printf(sfile, "+---ZONE: " OT_MMZ_FMT_S "\n", ot_mmz_fmt_arg(p));
mmz_total_size += p->nbytes / 1024; /* 1024: 1KByte = 1024Byte */
++zone_number;
list_for_each_entry(mmb, &p->mmb_list, list) {
if (temp_mmb != NULL && ((mmb)->phys_addr > mmz_grain_align((temp_mmb)->phys_addr + (temp_mmb)->length))) {
osal_seq_printf(sfile, " *-MMB: " OT_MMB_FMT_S "\n", ot_mmb_fmt_arg(mmb));
} else {
osal_seq_printf(sfile, " |-MMB: " OT_MMB_FMT_S "\n", ot_mmb_fmt_arg(mmb));
}
temp_mmb = mmb;
used_size += mmb->length / 1024; /* 1024: 1KByte = 1024Byte */
++block_number;
}
}
if (mmz_total_size != 0) {
free_size = mmz_total_size - used_size;
osal_seq_printf(sfile, "\n---MMZ_USE_INFO:\n total size=%dKB(%dMB),"
"used=%dKB(%dMB + %dKB),remain=%dKB(%dMB + %dKB),"
"zone_number=%d,block_number=%d\n",
mmz_total_size, mmz_total_size / 1024, /* 1024: 1MByte = 1024KByte */
used_size, used_size / 1024, used_size % 1024, /* 1024: 1MByte = 1024KByte */
free_size, free_size / 1024, free_size % 1024, /* 1024: 1MByte = 1024KByte */
zone_number, block_number);
mmz_total_size = 0;
zone_number = 0;
block_number = 0;
}
up(&g_mmz_lock);
return 0;
}
static int __init media_mem_proc_init(void)
{
osal_proc_entry_t *proc = NULL;
proc = osal_create_proc_entry(MEDIA_MEM_NAME, NULL);
if (proc == NULL) {
osal_trace(KERN_ERR "Create mmz proc fail!\n");
return -1;
}
proc->read = mmz_seq_show;
return 0;
}
static void __exit media_mem_proc_exit(void)
{
osal_remove_proc_entry(MEDIA_MEM_NAME, NULL);
}
#endif /* CONFIG_OT_PROC_SHOW_SUPPORT */
/* this function is used by osal_init.c */
int mem_check_module_param(void)
{
if (anony != 1) {
osal_trace("The module param \"anony\" should only be 1 which is %d\n", anony);
return -1;
}
return 0;
}
static void mmz_exit_check(void)
{
ot_mmz_t *pmmz = NULL;
struct osal_list_head *p = NULL;
struct osal_list_head *n = NULL;
list_for_each_safe(p, n, &g_mmz_list) {
pmmz = list_entry(p, ot_mmz_t, list);
osal_trace(KERN_WARNING "MMZ force removed: " OT_MMZ_FMT_S "\n",
ot_mmz_fmt_arg(pmmz));
ot_mmz_unregister(pmmz);
ot_mmz_destroy(pmmz);
}
}
int __init media_mem_init(void)
{
int ret = 0;
osal_trace(KERN_INFO "Media Memory Zone Manager\n");
if (anony != 1) {
osal_trace("The module param \"anony\" should only be 1 which is %d\n", anony);
return -EINVAL;
}
if (strcmp(g_setup_allocator, "cma") == 0) {
#ifdef CONFIG_CMA
ret = cma_allocator_setopt(&g_the_allocator);
#else
pr_err("cma is not enabled in kernel, please check!\n");
return -EINVAL;
#endif
} else if (strcmp(g_setup_allocator, "ot") == 0) {
ret = ot_allocator_setopt(&g_the_allocator);
} else {
osal_trace("The module param \"g_setup_allocator\" should be \"cma\" or \"ot\", which is \"%s\"\n",
g_setup_allocator);
mmz_exit_check();
return -EINVAL;
}
ret = g_the_allocator.init(g_setup_zones);
if (ret != 0) {
mmz_exit_check();
return ret;
}
#ifdef CONFIG_OT_PROC_SHOW_SUPPORT
media_mem_proc_init();
#endif
mmz_userdev_init();
map_mmz_init(g_mmap_zones);
return 0;
}
#ifdef MODULE
void __exit media_mem_exit(void)
{
map_mmz_exit();
mmz_userdev_exit();
#ifdef CONFIG_OT_PROC_SHOW_SUPPORT
media_mem_proc_exit();
#endif
mmz_exit_check();
}
#else
subsys_initcall(media_mem_init);
#endif
Reference in New Issue View Git Blame Copy Permalink