GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
Executable
+18
@@ -0,0 +1,18 @@
|
||||
ifneq ($(srctree),)
|
||||
KERNEL_DIR := $(srctree)
|
||||
SDK_DIR := $(shell cd $(KERNEL_DIR)/../../.. && /bin/pwd)
|
||||
else
|
||||
SDK_DIR := $(shell cd $(CURDIR)/../../../.. && /bin/pwd)
|
||||
endif
|
||||
|
||||
include $(SDK_DIR)/build/base.mk
|
||||
|
||||
obj-$(XMEDIA_DRV_BUILDTYPE) += linux/kernel/
|
||||
|
||||
.PHONY: all clean
|
||||
|
||||
all:
|
||||
$(AT)$(MAKE) -C linux/kernel
|
||||
|
||||
clean:
|
||||
$(AT)$(MAKE) -C linux/kernel clean
|
||||
@@ -0,0 +1,608 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __OSAL__
|
||||
#define __OSAL__
|
||||
|
||||
#define OSAL_VERSION "1.0"
|
||||
|
||||
#include "osal_list.h"
|
||||
#include "osal_devfreq.h"
|
||||
|
||||
#define osal_gfp_kernel 0
|
||||
#define osal_gfp_atomic 1
|
||||
extern void *osal_vmalloc(unsigned long size);
|
||||
extern void osal_vfree(const void *addr);
|
||||
extern void *osal_kmalloc(unsigned long size, unsigned int osal_gfp_flag);
|
||||
extern void osal_kfree(const void *addr);
|
||||
|
||||
// atomic api
|
||||
typedef struct {
|
||||
void *atomic;
|
||||
} osal_atomic_t;
|
||||
|
||||
#define OSAL_ATOMIC_INIT(i) { (i) }
|
||||
|
||||
extern int osal_atomic_init(osal_atomic_t *atomic);
|
||||
extern void osal_atomic_destory(osal_atomic_t *atomic);
|
||||
extern void osal_atomic_destroy(osal_atomic_t *atomic);
|
||||
extern int osal_atomic_read(osal_atomic_t *v);
|
||||
extern void osal_atomic_set(osal_atomic_t *v, int i);
|
||||
extern int osal_atomic_inc_return(osal_atomic_t *v);
|
||||
extern int osal_atomic_dec_return(osal_atomic_t *v);
|
||||
|
||||
// semaphore api
|
||||
#define EINTR 4
|
||||
typedef struct osal_semaphore {
|
||||
void *sem;
|
||||
} osal_semaphore_t;
|
||||
extern int osal_sema_init(osal_semaphore_t *sem, int val);
|
||||
extern int osal_down(osal_semaphore_t *sem);
|
||||
extern int osal_down_interruptible(osal_semaphore_t *sem);
|
||||
extern int osal_down_trylock(osal_semaphore_t *sem);
|
||||
extern void osal_up(osal_semaphore_t *sem);
|
||||
// notice:must be called when kmod exit, other wise will lead to memory leak;
|
||||
extern void osal_sema_destory(osal_semaphore_t *sem);
|
||||
extern void osal_sema_destroy(osal_semaphore_t *sem);
|
||||
|
||||
// mutex api
|
||||
typedef struct osal_mutex {
|
||||
void *mutex;
|
||||
} osal_mutex_t;
|
||||
extern int osal_mutex_init(osal_mutex_t *mutex);
|
||||
extern int osal_mutex_lock(osal_mutex_t *mutex);
|
||||
extern int osal_mutex_lock_interruptible(osal_mutex_t *mutex);
|
||||
extern int osal_mutex_trylock(osal_mutex_t *mutex);
|
||||
extern void osal_mutex_unlock(osal_mutex_t *mutex);
|
||||
// notice:must be called when kmod exit, other wise will lead to memory leak;
|
||||
extern void osal_mutex_destroy(osal_mutex_t *mutex);
|
||||
|
||||
// spin lock api
|
||||
typedef struct osal_spinlock {
|
||||
void *lock;
|
||||
} osal_spinlock_t;
|
||||
extern int osal_spin_lock_init(osal_spinlock_t *lock);
|
||||
extern void osal_spin_lock(osal_spinlock_t *lock);
|
||||
extern int osal_spin_trylock(osal_spinlock_t *lock);
|
||||
extern void osal_spin_unlock(osal_spinlock_t *lock);
|
||||
extern void osal_spin_lock_irqsave(osal_spinlock_t *lock, unsigned long *flags);
|
||||
extern void osal_spin_unlock_irqrestore(osal_spinlock_t *lock, unsigned long *flags);
|
||||
// notice:must be called when kmod exit, other wise will lead to memory leak;
|
||||
extern void osal_spin_lock_destory(osal_spinlock_t *lock);
|
||||
extern void osal_spin_lock_destroy(osal_spinlock_t *lock);
|
||||
|
||||
// wait api
|
||||
typedef int (*osal_wait_cond_func_t)(const void *param);
|
||||
|
||||
typedef struct osal_wait {
|
||||
void *wait;
|
||||
} osal_wait_t;
|
||||
#define ERESTARTSYS 512
|
||||
|
||||
extern unsigned long osal_msecs_to_jiffies(const unsigned int m);
|
||||
extern int osal_wait_init(osal_wait_t *wait);
|
||||
extern int osal_wait_interruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param);
|
||||
extern int osal_wait_uninterruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param);
|
||||
extern int osal_wait_timeout_interruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param,
|
||||
unsigned long ms);
|
||||
extern int osal_wait_timeout_uninterruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param,
|
||||
unsigned long ms);
|
||||
|
||||
#define osal_wait_event_interruptible(wait, func, param) \
|
||||
({ \
|
||||
int __ret = 0; \
|
||||
\
|
||||
for (;;) { \
|
||||
if (func(param)) { \
|
||||
__ret = 0; \
|
||||
break; \
|
||||
} \
|
||||
__ret = osal_wait_timeout_interruptible(wait, (func), param, 100); \
|
||||
if (__ret < 0) \
|
||||
break; \
|
||||
} \
|
||||
__ret; \
|
||||
})
|
||||
|
||||
#define osal_wait_event_uninterruptible(wait, func, param) \
|
||||
({ \
|
||||
int __ret = 0; \
|
||||
\
|
||||
for (;;) { \
|
||||
if (func(param)) { \
|
||||
__ret = 0; \
|
||||
break; \
|
||||
} \
|
||||
__ret = osal_wait_uninterruptible(wait, (func), param); \
|
||||
if (__ret < 0) \
|
||||
break; \
|
||||
} \
|
||||
__ret; \
|
||||
})
|
||||
|
||||
#define osal_wait_event_timeout_interruptible(wait, func, param, timeout) \
|
||||
({ \
|
||||
int __ret = timeout; \
|
||||
\
|
||||
if ((func(param)) && !timeout) { \
|
||||
__ret = 1; \
|
||||
} \
|
||||
\
|
||||
for (;;) { \
|
||||
if (func(param)) { \
|
||||
__ret = osal_msecs_to_jiffies(__ret); \
|
||||
break; \
|
||||
} \
|
||||
__ret = osal_wait_timeout_interruptible(wait, (func), param, __ret); \
|
||||
if (!__ret || __ret == -ERESTARTSYS) \
|
||||
break; \
|
||||
} \
|
||||
__ret; \
|
||||
})
|
||||
|
||||
#define osal_wait_event_timeout_uninterruptible(wait, func, param, timeout) \
|
||||
({ \
|
||||
int __ret = timeout; \
|
||||
\
|
||||
if ((func(param)) && !timeout) { \
|
||||
__ret = 1; \
|
||||
} \
|
||||
\
|
||||
for (;;) { \
|
||||
if (func(param)) { \
|
||||
__ret = osal_msecs_to_jiffies(__ret); \
|
||||
break; \
|
||||
} \
|
||||
__ret = osal_wait_timeout_uninterruptible(wait, (func), param, __ret); \
|
||||
if (!__ret || __ret == -ERESTARTSYS) \
|
||||
break; \
|
||||
} \
|
||||
__ret; \
|
||||
})
|
||||
|
||||
extern void osal_wakeup(osal_wait_t *wait); // same as wake_up_all
|
||||
extern void osal_wait_destory(osal_wait_t *wait);
|
||||
extern void osal_wait_destroy(osal_wait_t *wait);
|
||||
|
||||
// workqueue api
|
||||
typedef struct osal_work_struct {
|
||||
void *work;
|
||||
void (*func)(struct osal_work_struct *work);
|
||||
} osal_work_struct_t;
|
||||
typedef void (*osal_work_func_t)(struct osal_work_struct *work);
|
||||
|
||||
extern int osal_init_work(struct osal_work_struct *work, osal_work_func_t func);
|
||||
|
||||
#define OSAL_INIT_WORK(_work, _func) \
|
||||
do { \
|
||||
osal_init_work((_work), (_func)); \
|
||||
} while (0)
|
||||
|
||||
extern int osal_schedule_work(struct osal_work_struct *work);
|
||||
extern void osal_destroy_work(struct osal_work_struct *work);
|
||||
|
||||
// shedule
|
||||
extern void osal_yield(void);
|
||||
|
||||
// interrupt api
|
||||
enum osal_irqreturn {
|
||||
OSAL_IRQ_NONE = (0 << 0),
|
||||
OSAL_IRQ_HANDLED = (1 << 0),
|
||||
OSAL_IRQ_WAKE_THREAD = (1 << 1),
|
||||
};
|
||||
|
||||
typedef int (*osal_irq_handler_t)(int, void *);
|
||||
extern int osal_request_irq(unsigned int irq, osal_irq_handler_t handler, osal_irq_handler_t thread_fn,
|
||||
const char *name, void *dev);
|
||||
extern void osal_free_irq(unsigned int irq, void *dev);
|
||||
extern int osal_in_interrupt(void);
|
||||
|
||||
#define OSAL_DIS_IRQ_CNT 2
|
||||
typedef void (*osal_gic_handle_t)(unsigned int, unsigned int, void *);
|
||||
extern int osal_register_gic_handle(unsigned int index, unsigned int irq, osal_gic_handle_t handle, const char *name,
|
||||
void *dev);
|
||||
extern int osal_unregister_gic_handle(unsigned int index, unsigned int irq, void *dev);
|
||||
|
||||
// task api
|
||||
typedef struct osal_task {
|
||||
void *task_struct;
|
||||
} osal_task_t;
|
||||
typedef int (*threadfn_t)(void *data);
|
||||
extern osal_task_t *osal_kthread_create(threadfn_t thread, void *data, const char *name);
|
||||
extern void osal_kthread_destory(osal_task_t *task, unsigned int stop_flag);
|
||||
extern void osal_kthread_destroy(osal_task_t *task, unsigned int stop_flag);
|
||||
int osal_kthread_should_stop(void);
|
||||
|
||||
// string api
|
||||
extern char *osal_strcpy(char *s1, const char *s2);
|
||||
extern char *osal_strncpy(char *s1, const char *s2, int size);
|
||||
extern int osal_strlcpy(char *s1, const char *s2, int size);
|
||||
extern char *osal_strcat(char *s1, const char *s2);
|
||||
extern char *osal_strncat(char *s1, const char *s2, int size);
|
||||
extern int osal_strlcat(char *s1, const char *s2, int size);
|
||||
extern int osal_strcmp(const char *s1, const char *s2);
|
||||
extern int osal_strncmp(const char *s1, const char *s2, int size);
|
||||
extern int osal_strnicmp(const char *s1, const char *s2, int size);
|
||||
extern int osal_strcasecmp(const char *s1, const char *s2);
|
||||
extern int osal_strncasecmp(const char *s1, const char *s2, int n);
|
||||
extern char *osal_strchr(const char *s, int n);
|
||||
extern char *osal_strnchr(const char *s, int count, int c);
|
||||
extern char *osal_strrchr(const char *s, int c);
|
||||
extern char *osal_strstr(const char *s1, const char *s2);
|
||||
extern char *osal_strnstr(const char *s1, const char *s2, int n);
|
||||
extern int osal_strlen(const char *s);
|
||||
extern int osal_strnlen(const char *s, int size);
|
||||
extern char *osal_strpbrk(const char *s1, const char *s2);
|
||||
extern char *osal_strsep(char **s, const char *ct);
|
||||
extern int osal_strspn(const char *s, const char *accept);
|
||||
extern int osal_strcspn(const char *s, const char *reject);
|
||||
extern void *osal_memset(void *str, int c, int count);
|
||||
extern void *osal_memcpy(void *s1, const void *s2, int count);
|
||||
extern void *osal_memmove(void *s1, const void *s2, int count);
|
||||
extern void *osal_memscan(void *addr, int c, int size);
|
||||
extern int osal_memcmp(const void *cs, const void *ct, int count);
|
||||
extern void *osal_memchr(const void *s, int c, int n);
|
||||
extern void *osal_memchr_inv(const void *s, int c, int n);
|
||||
|
||||
extern unsigned long long osal_strtoull(const char *cp, char **endp, unsigned int base);
|
||||
extern unsigned long osal_strtoul(const char *cp, char **endp, unsigned int base);
|
||||
extern long osal_strtol(const char *cp, char **endp, unsigned int base);
|
||||
extern long long osal_strtoll(const char *cp, char **endp, unsigned int base);
|
||||
extern int osal_snprintf(char *buf, int size, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
|
||||
extern int osal_scnprintf(char *buf, int size, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
|
||||
extern int osal_sprintf(char *buf, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
|
||||
extern int osal_sscanf(const char *buf, const char *fmt, ...);
|
||||
|
||||
// addr translate
|
||||
extern void *osal_ioremap(unsigned long phys_addr, unsigned long size);
|
||||
extern void *osal_ioremap_nocache(unsigned long phys_addr, unsigned long size);
|
||||
extern void *osal_ioremap_cached(unsigned long phys_addr, unsigned long size);
|
||||
extern void *osal_ioremap_wc(unsigned long phys_addr, unsigned long size);
|
||||
extern void osal_iounmap(void *addr);
|
||||
|
||||
#define osal_readl(x) (*((volatile int *)(x)))
|
||||
#define osal_writel(v, x) (*((volatile int *)(x)) = (v))
|
||||
|
||||
extern unsigned long osal_copy_from_user(void *to, const void *from, unsigned long n);
|
||||
extern unsigned long osal_copy_to_user(void *to, const void *from, unsigned long n);
|
||||
|
||||
#define OSAL_VERIFY_READ 0
|
||||
#define OSAL_VERIFY_WRITE 1
|
||||
extern int osal_access_ok(int type, const void *addr, unsigned long size);
|
||||
|
||||
// cache api
|
||||
extern void osal_flush_cache_all(void);
|
||||
extern void osal_cpuc_flush_dcache_area(void *addr, int size);
|
||||
|
||||
extern void osal_flush_dcache_area(void *kvirt, unsigned long phys_addr, unsigned long length);
|
||||
extern int osal_flush_dcache_all(void);
|
||||
|
||||
// math
|
||||
extern int osal_isdigit(int c);
|
||||
extern void osal_kernel_neon_end(void);
|
||||
extern void osal_kernel_neon_begin(void);
|
||||
extern unsigned long long osal_div_u64(unsigned long long dividend, unsigned int divisor);
|
||||
extern long long osal_div_s64(long long dividend, int divisor);
|
||||
extern unsigned long long osal_div64_u64(unsigned long long dividend, unsigned long long divisor);
|
||||
extern long long osal_div64_s64(long long dividend, long long divisor);
|
||||
extern unsigned long long osal_div_u64_rem(unsigned long long dividend, unsigned int divisor);
|
||||
extern long long osal_div_s64_rem(long long dividend, int divisor);
|
||||
extern unsigned long long osal_div64_u64_rem(unsigned long long dividend, unsigned long long divisor);
|
||||
extern unsigned int osal_random(void);
|
||||
|
||||
#define osal_max(x, y) ({ \
|
||||
__typeof__(x) _max1 = (x); \
|
||||
__typeof__(y) _max2 = (y); \
|
||||
(void) (&_max1 == &_max2); \
|
||||
_max1 > _max2 ? _max1 : _max2; })
|
||||
|
||||
#define osal_min(x, y) ({ \
|
||||
__typeof__(x) _min1 = (x); \
|
||||
__typeof__(y) _min2 = (y); \
|
||||
(void) (&_min1 == &_min2); \
|
||||
_min1 < _min2 ? _min1 : _min2; })
|
||||
|
||||
#define osal_abs(x) ({ \
|
||||
long ret; \
|
||||
if (sizeof(x) == sizeof(long)) { \
|
||||
long __x = (x); \
|
||||
ret = (__x < 0) ? -__x : __x; \
|
||||
} else { \
|
||||
int __x = (x); \
|
||||
ret = (__x < 0) ? -__x : __x; \
|
||||
} \
|
||||
ret; \
|
||||
})
|
||||
|
||||
// barrier
|
||||
extern void osal_mb(void);
|
||||
extern void osal_rmb(void);
|
||||
extern void osal_wmb(void);
|
||||
extern void osal_smp_mb(void);
|
||||
extern void osal_smp_rmb(void);
|
||||
extern void osal_smp_wmb(void);
|
||||
extern void osal_isb(void);
|
||||
extern void osal_dsb(void);
|
||||
extern void osal_dmb(void);
|
||||
|
||||
// debug
|
||||
extern int osal_printk(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
|
||||
extern void osal_panic(const char *fmt, const char *fun, int line, const char *);
|
||||
#define OSAL_BUG() \
|
||||
do { \
|
||||
} while (1)
|
||||
|
||||
#define OSAL_ASSERT(expr) \
|
||||
do { \
|
||||
if (!(expr)) { \
|
||||
osal_printk("\nASSERT failed at:\n" \
|
||||
" >Condition: %s\n", \
|
||||
#expr); \
|
||||
OSAL_BUG(); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define OSAL_BUG_ON(expr) \
|
||||
do { \
|
||||
if (expr) { \
|
||||
osal_printk("BUG: failure at %d/%s()!\n", __LINE__, __func__); \
|
||||
OSAL_BUG(); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// proc
|
||||
typedef struct osal_proc_dir_entry {
|
||||
char name[50];
|
||||
void *proc_dir_entry;
|
||||
int (*open)(struct osal_proc_dir_entry *entry);
|
||||
int (*read)(struct osal_proc_dir_entry *entry);
|
||||
int (*write)(struct osal_proc_dir_entry *entry, const char *buf, int count, long long *);
|
||||
void *private;
|
||||
void *seqfile;
|
||||
struct osal_list_head node;
|
||||
} osal_proc_entry_t;
|
||||
extern osal_proc_entry_t *osal_create_proc_entry(const char *name, osal_proc_entry_t *parent);
|
||||
extern osal_proc_entry_t *osal_proc_mkdir(const char *name, osal_proc_entry_t *parent);
|
||||
extern void osal_remove_proc_entry(const char *name, osal_proc_entry_t *parent);
|
||||
extern void osal_seq_printf(osal_proc_entry_t *entry, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
|
||||
|
||||
// device api
|
||||
#ifndef _IOC_TYPECHECK
|
||||
#ifdef __KERNEL__
|
||||
#include "osal_ioctl.h"
|
||||
#endif
|
||||
#endif
|
||||
typedef struct osal_dev {
|
||||
char name[48];
|
||||
void *dev;
|
||||
int minor;
|
||||
struct osal_fileops *fops;
|
||||
struct osal_pmops *osal_pmops;
|
||||
struct osal_devfreq_dev_profile *osal_profile;
|
||||
} osal_dev_t;
|
||||
|
||||
typedef struct osal_devfreq_dev_profile {
|
||||
unsigned long initial_freq;
|
||||
unsigned int polling_ms;
|
||||
|
||||
int (*target)(osal_dev_t *dev, unsigned long *freq, unsigned int flags);
|
||||
int (*get_dev_status)(osal_dev_t *dev, struct osal_devfreq_dev_status *stat);
|
||||
int (*get_cur_freq)(osal_dev_t *dev, unsigned long *freq);
|
||||
void (*exit)(osal_dev_t *dev);
|
||||
|
||||
unsigned long *freq_table;
|
||||
unsigned int max_state;
|
||||
} osal_devfreq_dev_profile_t;
|
||||
|
||||
typedef struct osal_vm {
|
||||
void *vm;
|
||||
} osal_vm_t;
|
||||
|
||||
#define OSAL_POLLIN 0x0001
|
||||
#define OSAL_POLLPRI 0x0002
|
||||
#define OSAL_POLLOUT 0x0004
|
||||
#define OSAL_POLLERR 0x0008
|
||||
#define OSAL_POLLHUP 0x0010
|
||||
#define OSAL_POLLNVAL 0x0020
|
||||
#define OSAL_POLLRDNORM 0x0040
|
||||
#define OSAL_POLLRDBAND 0x0080
|
||||
#define OSAL_POLLWRNORM 0x0100
|
||||
|
||||
typedef struct osal_poll {
|
||||
void *poll_table;
|
||||
void *data;
|
||||
} osal_poll_t;
|
||||
|
||||
typedef struct osal_fileops {
|
||||
int (*open)(void *private_data);
|
||||
int (*read)(char *buf, int size, long *offset, void *private_data);
|
||||
int (*write)(const char *buf, int size, long *offset, void *private_data);
|
||||
long (*llseek)(long offset, int whence, void *private_data);
|
||||
int (*release)(void *private_data);
|
||||
long (*unlocked_ioctl)(unsigned int cmd, unsigned long arg, void *private_data);
|
||||
unsigned int (*poll)(osal_poll_t *osal_poll, void *private_data);
|
||||
int (*mmap)(osal_vm_t *vm, unsigned long start, unsigned long end, unsigned long vm_pgoff, void *private_data);
|
||||
#ifdef CONFIG_COMPAT
|
||||
long (*compat_ioctl)(unsigned int cmd, unsigned long arg, void *private_data);
|
||||
#endif
|
||||
} osal_fileops_t;
|
||||
|
||||
typedef struct osal_pmops {
|
||||
int (*pm_prepare)(osal_dev_t *dev);
|
||||
void (*pm_complete)(osal_dev_t *dev);
|
||||
int (*pm_suspend)(osal_dev_t *dev);
|
||||
int (*pm_resume)(osal_dev_t *dev);
|
||||
int (*pm_freeze)(osal_dev_t *dev);
|
||||
int (*pm_thaw)(osal_dev_t *dev);
|
||||
int (*pm_poweroff)(osal_dev_t *dev);
|
||||
int (*pm_restore)(osal_dev_t *dev);
|
||||
int (*pm_suspend_late)(osal_dev_t *dev);
|
||||
int (*pm_resume_early)(osal_dev_t *dev);
|
||||
int (*pm_freeze_late)(osal_dev_t *dev);
|
||||
int (*pm_thaw_early)(osal_dev_t *dev);
|
||||
int (*pm_poweroff_late)(osal_dev_t *dev);
|
||||
int (*pm_restore_early)(osal_dev_t *dev);
|
||||
int (*pm_suspend_noirq)(osal_dev_t *dev);
|
||||
int (*pm_resume_noirq)(osal_dev_t *dev);
|
||||
int (*pm_freeze_noirq)(osal_dev_t *dev);
|
||||
int (*pm_thaw_noirq)(osal_dev_t *dev);
|
||||
int (*pm_poweroff_noirq)(osal_dev_t *dev);
|
||||
int (*pm_restore_noirq)(osal_dev_t *dev);
|
||||
} osal_pmops_t;
|
||||
|
||||
#define OSAL_SEEK_SET 0
|
||||
#define OSAL_SEEK_CUR 1
|
||||
#define OSAL_SEEK_END 2
|
||||
|
||||
// #define PAGE_SHIFT 12
|
||||
|
||||
extern osal_dev_t *osal_createdev(const char *name);
|
||||
extern int osal_destroydev(osal_dev_t *pdev);
|
||||
extern int osal_registerdevice(osal_dev_t *pdev);
|
||||
extern void osal_deregisterdevice(osal_dev_t *pdev);
|
||||
extern void osal_poll_wait(osal_poll_t *table, osal_wait_t *wait);
|
||||
extern void osal_pgprot_noncached(osal_vm_t *vm);
|
||||
extern void osal_pgprot_cached(osal_vm_t *vm);
|
||||
extern void osal_pgprot_writecombine(osal_vm_t *vm);
|
||||
extern void osal_pgprot_stronglyordered(osal_vm_t *vm);
|
||||
extern int osal_remap_pfn_range(osal_vm_t *vm, unsigned long addr, unsigned long pfn, unsigned long size);
|
||||
extern int osal_io_remap_pfn_range(osal_vm_t *vm, unsigned long addr, unsigned long pfn, unsigned long size);
|
||||
extern int osal_devfreq_register(osal_dev_t *osal_dev, struct osal_devfreq_dev_profile *osal_profile,
|
||||
const char *governor, void *data);
|
||||
extern void osal_devfreq_unregister(osal_dev_t *osal_dev);
|
||||
|
||||
|
||||
// timer
|
||||
typedef struct osal_timer {
|
||||
void *timer;
|
||||
void (*function)(unsigned long);
|
||||
unsigned long data;
|
||||
} osal_timer_t;
|
||||
|
||||
typedef struct osal_timeval {
|
||||
long tv_sec;
|
||||
long tv_usec;
|
||||
} osal_timeval_t;
|
||||
|
||||
typedef struct osal_rtc_time {
|
||||
int tm_sec;
|
||||
int tm_min;
|
||||
int tm_hour;
|
||||
int tm_mday;
|
||||
int tm_mon;
|
||||
int tm_year;
|
||||
int tm_wday;
|
||||
int tm_yday;
|
||||
int tm_isdst;
|
||||
} osal_rtc_time_t;
|
||||
|
||||
/* Return values for the timer callback function */
|
||||
typedef enum OSAL_HRTIMER_RESTART_E {
|
||||
OSAL_HRTIMER_NORESTART, /* < The timer will not be restarted. */
|
||||
OSAL_HRTIMER_RESTART /* < The timer must be restarted. */
|
||||
} OSAL_HRTIMER_RESTART_E;
|
||||
|
||||
/* hrtimer struct */
|
||||
typedef struct osal_hrtimer {
|
||||
void *timer;
|
||||
OSAL_HRTIMER_RESTART_E (*function)(void *timer);
|
||||
unsigned long interval; /* Unit ms */
|
||||
} osal_hrtimer_t;
|
||||
|
||||
extern int osal_hrtimer_create(osal_hrtimer_t *phrtimer);
|
||||
extern int osal_hrtimer_start(osal_hrtimer_t *phrtimer);
|
||||
extern int osal_hrtimer_destroy(osal_hrtimer_t *phrtimer);
|
||||
|
||||
extern int osal_timer_init(osal_timer_t *timer);
|
||||
extern int osal_set_timer(osal_timer_t *timer, unsigned long interval); /* ms */
|
||||
extern unsigned long osal_timer_get_private_data(void *data);
|
||||
extern int osal_del_timer(osal_timer_t *timer);
|
||||
extern int osal_timer_destory(osal_timer_t *timer);
|
||||
extern int osal_timer_destroy(osal_timer_t *timer);
|
||||
|
||||
extern unsigned long osal_msleep(unsigned int msecs);
|
||||
extern void osal_udelay(unsigned int usecs);
|
||||
extern void osal_mdelay(unsigned int msecs);
|
||||
|
||||
extern unsigned int osal_get_tickcount(void);
|
||||
extern unsigned long long osal_sched_clock(void);
|
||||
extern void osal_gettimeofday(osal_timeval_t *tv);
|
||||
|
||||
/* unit is ns */
|
||||
extern unsigned long long osal_get_boottime(void);
|
||||
extern void osal_rtc_time_to_tm(unsigned long time, osal_rtc_time_t *tm);
|
||||
extern void osal_rtc_tm_to_time(osal_rtc_time_t *tm, unsigned long *time);
|
||||
extern int osal_rtc_valid_tm(struct osal_rtc_time *tm);
|
||||
extern void osal_getjiffies(unsigned long long *pjiffies);
|
||||
|
||||
#define OSAL_O_ACCMODE 00000003
|
||||
#define OSAL_O_RDONLY 00000000
|
||||
#define OSAL_O_WRONLY 00000001
|
||||
#define OSAL_O_RDWR 00000002
|
||||
#define OSAL_O_CREAT 00000100
|
||||
|
||||
extern void *osal_klib_fopen(const char *filename, int flags, int mode);
|
||||
extern void osal_klib_fclose(void *filp);
|
||||
extern int osal_klib_fwrite(const char *buf, int len, void *filp);
|
||||
extern int osal_klib_fread(char *buf, unsigned int len, void *filp);
|
||||
|
||||
// reboot
|
||||
struct osal_notifier_block {
|
||||
int (*notifier_call)(struct osal_notifier_block *nb, unsigned long action, void *data);
|
||||
void *notifier_block;
|
||||
};
|
||||
typedef int (*osal_notifier_fn_t)(struct osal_notifier_block *nb, unsigned long action, void *data);
|
||||
|
||||
extern int osal_register_reboot_notifier(struct osal_notifier_block *nb);
|
||||
extern int osal_unregister_reboot_notifier(struct osal_notifier_block *nb);
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#ifndef _OSAL_VA_LIST
|
||||
|
||||
#define _OSAL_VA_LIST
|
||||
#define osal_va_list va_list
|
||||
#define osal_va_arg(ap, T) va_arg(ap, T)
|
||||
#define osal_va_end(ap) va_end(ap)
|
||||
#define osal_va_start(ap, A) va_start(ap, A)
|
||||
|
||||
#endif /* va_arg */
|
||||
|
||||
#define NULL_STRING "NULL"
|
||||
|
||||
extern void osal_vprintk(const char *fmt, osal_va_list args);
|
||||
extern int osal_vsnprintf(char *str, int size, const char *fmt, osal_va_list args);
|
||||
|
||||
#ifdef CONFIG_SNAPSHOT_BOOT
|
||||
|
||||
#ifndef OSAL_UMH_WAIT_PROC
|
||||
#define OSAL_UMH_WAIT_PROC 2 /* wait for the process to complete */
|
||||
#endif
|
||||
|
||||
extern int osal_call_usermodehelper_force(char *path, char **argv, char **envp, int wait);
|
||||
#endif
|
||||
|
||||
int osal_platform_driver_register(void *drv);
|
||||
void osal_platform_driver_unregister(void *drv);
|
||||
void *osal_platform_get_resource_byname(void *dev, unsigned int type, const char *name);
|
||||
void *osal_platform_get_resource(void *dev, unsigned int type, unsigned int num);
|
||||
int osal_platform_get_irq(void *dev, unsigned int num);
|
||||
int osal_platform_get_irq_byname(void *dev, const char *name);
|
||||
|
||||
#define osal_module_driver(osal_driver, osal_register, osal_unregister, ...) \
|
||||
static int __init osal_driver##_init(void) \
|
||||
{ \
|
||||
return osal_register(&(osal_driver)); \
|
||||
} \
|
||||
module_init(osal_driver##_init); \
|
||||
static void __exit osal_driver##_exit(void) \
|
||||
{ \
|
||||
osal_unregister(&(osal_driver)); \
|
||||
} \
|
||||
module_exit(osal_driver##_exit);
|
||||
|
||||
#define osal_module_platform_driver(platform_driver) \
|
||||
osal_module_driver(platform_driver, osal_platform_driver_register, \
|
||||
osal_platform_driver_unregister)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __OSAL_DEVFREQ__H
|
||||
#define __OSAL_DEVFREQ__H
|
||||
|
||||
typedef struct osal_devfreq_dev_status {
|
||||
/* both since the last measure */
|
||||
unsigned long total_time;
|
||||
unsigned long busy_time;
|
||||
unsigned long current_frequency;
|
||||
void *private_data;
|
||||
} osal_devfreq_dev_status_t;
|
||||
|
||||
typedef struct osal_devfreq_para {
|
||||
unsigned long initial_freq;
|
||||
unsigned int polling_ms;
|
||||
unsigned long *freq_table;
|
||||
unsigned int max_state;
|
||||
} osal_devfreq_para_t;
|
||||
|
||||
#endif /* __OSAL_DEVFREQ__H */
|
||||
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef _DRV_IOCTL_H
|
||||
#define _DRV_IOCTL_H
|
||||
|
||||
/* ioctl command encoding: 32 bits total, command in lower 16 bits,
|
||||
* size of the parameter structure in the lower 14 bits of the
|
||||
* upper 16 bits.
|
||||
* Encoding the size of the parameter structure in the ioctl request
|
||||
* is useful for catching programs compiled with old versions
|
||||
* and to avoid overwriting user space outside the user buffer area.
|
||||
* The highest 2 bits are reserved for indicating the ``access mode''.
|
||||
* NOTE: This limits the max parameter size to 16kB -1 !
|
||||
*/
|
||||
|
||||
/*
|
||||
* The following is for compatibility across the various Linux
|
||||
* platforms. The generic ioctl numbering scheme doesn't really enforce
|
||||
* a type field. De facto, however, the top 8 bits of the lower 16
|
||||
* bits are indeed used as a type field, so we might just as well make
|
||||
* this explicit here. Please be sure to use the decoding macros
|
||||
* below from now on.
|
||||
*/
|
||||
#define _IOC_NRBITS 8
|
||||
#define _IOC_TYPEBITS 8
|
||||
|
||||
/*
|
||||
* Let any architecture override either of the following before
|
||||
* including this file.
|
||||
*/
|
||||
|
||||
#ifndef _IOC_SIZEBITS
|
||||
#define _IOC_SIZEBITS 14
|
||||
#endif
|
||||
|
||||
#ifndef _IOC_DIRBITS
|
||||
#define _IOC_DIRBITS 2
|
||||
#endif
|
||||
|
||||
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1)
|
||||
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1)
|
||||
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1)
|
||||
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1)
|
||||
|
||||
#define _IOC_NRSHIFT 0
|
||||
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)
|
||||
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)
|
||||
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)
|
||||
|
||||
/*
|
||||
* Direction bits, which any architecture can choose to override
|
||||
* before including this file.
|
||||
*/
|
||||
|
||||
#ifndef _IOC_NONE
|
||||
#define _IOC_NONE 0U
|
||||
#endif
|
||||
|
||||
#ifndef _IOC_WRITE
|
||||
#define _IOC_WRITE 1U
|
||||
#endif
|
||||
|
||||
#ifndef _IOC_READ
|
||||
#define _IOC_READ 2U
|
||||
#endif
|
||||
|
||||
#define _IOC(dir, type, nr, size) \
|
||||
(((dir) << _IOC_DIRSHIFT) | \
|
||||
((type) << _IOC_TYPESHIFT) | \
|
||||
((nr) << _IOC_NRSHIFT) | \
|
||||
((size) << _IOC_SIZESHIFT))
|
||||
|
||||
// #define _IOC_TYPECHECK(t) (sizeof(t))
|
||||
|
||||
#ifdef __CHECKER__
|
||||
#define _IOC_TYPECHECK(t) (sizeof(t))
|
||||
#else
|
||||
/* provoke compile error for invalid uses of size argument */
|
||||
extern unsigned int __invalid_size_argument_for_IOC;
|
||||
#define _IOC_TYPECHECK(t) \
|
||||
((sizeof(t) == sizeof(t[1]) && \
|
||||
sizeof(t) < (1 << _IOC_SIZEBITS)) \
|
||||
? sizeof(t) \
|
||||
: __invalid_size_argument_for_IOC)
|
||||
#endif
|
||||
|
||||
/* used to create numbers */
|
||||
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
|
||||
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
|
||||
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
|
||||
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
|
||||
#define _IOR_BAD(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
|
||||
#define _IOW_BAD(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
|
||||
#define _IOWR_BAD(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
|
||||
|
||||
/* used to decode ioctl numbers.. */
|
||||
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
|
||||
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
|
||||
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
|
||||
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
|
||||
|
||||
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
|
||||
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
|
||||
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
|
||||
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
|
||||
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
|
||||
|
||||
#endif /* _DRV_IOCTL_H */
|
||||
@@ -0,0 +1,745 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef _OSAL_LIST_H
|
||||
#define _OSAL_LIST_H
|
||||
|
||||
#define OSAL_NULL (0)
|
||||
|
||||
/*
|
||||
* Simple doubly linked list implementation.
|
||||
*
|
||||
* Some of the internal functions ("__xxx") are useful when
|
||||
* manipulating whole lists rather than single entries, as
|
||||
* sometimes we already know the next/prev entries and we can
|
||||
* generate better code by using them directly rather than
|
||||
* using the generic single-entry routines.
|
||||
*/
|
||||
|
||||
struct osal_list_head {
|
||||
struct osal_list_head *next, *prev;
|
||||
};
|
||||
#define OSAL_LIST_HEAD_INIT(name) \
|
||||
{ \
|
||||
&(name), &(name) \
|
||||
}
|
||||
|
||||
#define OSAL_LIST_HEAD(name) \
|
||||
struct osal_list_head name = OSAL_LIST_HEAD_INIT(name)
|
||||
|
||||
static inline void OSAL_INIT_LIST_HEAD(struct osal_list_head *list)
|
||||
{
|
||||
list->next = list;
|
||||
list->prev = list;
|
||||
}
|
||||
|
||||
/*
|
||||
* Insert a new entry between two known consecutive entries.
|
||||
*
|
||||
* This is only for internal list manipulation where we know
|
||||
* the prev/next entries already!
|
||||
*/
|
||||
static inline void osal___list_add(struct osal_list_head *new,
|
||||
struct osal_list_head *prev,
|
||||
struct osal_list_head *next)
|
||||
{
|
||||
next->prev = new;
|
||||
new->next = next;
|
||||
new->prev = prev;
|
||||
prev->next = new;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_add - add a new entry
|
||||
* @new: new entry to be added
|
||||
* @head: list head to add it after
|
||||
*
|
||||
* Insert a new entry after the specified head.
|
||||
* This is good for implementing stacks.
|
||||
*/
|
||||
static inline void osal_list_add(struct osal_list_head *new, struct osal_list_head *head)
|
||||
{
|
||||
osal___list_add(new, head, head->next);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_add_tail - add a new entry
|
||||
* @new: new entry to be added
|
||||
* @head: list head to add it before
|
||||
*
|
||||
* Insert a new entry before the specified head.
|
||||
* This is useful for implementing queues.
|
||||
*/
|
||||
static inline void osal_list_add_tail(struct osal_list_head *new, struct osal_list_head *head)
|
||||
{
|
||||
osal___list_add(new, head->prev, head);
|
||||
}
|
||||
|
||||
/*
|
||||
* Delete a list entry by making the prev/next entries
|
||||
* point to each other.
|
||||
*
|
||||
* This is only for internal list manipulation where we know
|
||||
* the prev/next entries already!
|
||||
*/
|
||||
static inline void osal___list_del(struct osal_list_head *prev, struct osal_list_head *next)
|
||||
{
|
||||
next->prev = prev;
|
||||
prev->next = next;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del - deletes entry from list.
|
||||
* @entry: the element to delete from the list.
|
||||
* Note: list_empty() on entry does not return true after this, the entry is
|
||||
* in an undefined state.
|
||||
*/
|
||||
static inline void osal___list_del_entry(struct osal_list_head *entry)
|
||||
{
|
||||
osal___list_del(entry->prev, entry->next);
|
||||
}
|
||||
|
||||
#define OSAL_LIST_POISON1 ((void *)0x00100100)
|
||||
#define OSAL_LIST_POISON2 ((void *)0x00200200)
|
||||
|
||||
static inline void osal_list_del(struct osal_list_head *entry)
|
||||
{
|
||||
osal___list_del(entry->prev, entry->next);
|
||||
entry->next = OSAL_LIST_POISON1;
|
||||
entry->prev = OSAL_LIST_POISON2;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_replace - replace old entry by new one
|
||||
* @old : the element to be replaced
|
||||
* @new : the new element to insert
|
||||
*
|
||||
* If @old was empty, it will be overwritten.
|
||||
*/
|
||||
static inline void osal_list_replace(struct osal_list_head *old,
|
||||
struct osal_list_head *new)
|
||||
{
|
||||
new->next = old->next;
|
||||
new->next->prev = new;
|
||||
new->prev = old->prev;
|
||||
new->prev->next = new;
|
||||
}
|
||||
|
||||
static inline void osal_list_replace_init(struct osal_list_head *old,
|
||||
struct osal_list_head *new)
|
||||
{
|
||||
osal_list_replace(old, new);
|
||||
OSAL_INIT_LIST_HEAD(old);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del_init - deletes entry from list and reinitialize it.
|
||||
* @entry: the element to delete from the list.
|
||||
*/
|
||||
static inline void osal_list_del_init(struct osal_list_head *entry)
|
||||
{
|
||||
osal___list_del_entry(entry);
|
||||
OSAL_INIT_LIST_HEAD(entry);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_move - delete from one list and add as another's head
|
||||
* @list: the entry to move
|
||||
* @head: the head that will precede our entry
|
||||
*/
|
||||
static inline void osal_list_move(struct osal_list_head *list, struct osal_list_head *head)
|
||||
{
|
||||
osal___list_del_entry(list);
|
||||
osal_list_add(list, head);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_move_tail - delete from one list and add as another's tail
|
||||
* @list: the entry to move
|
||||
* @head: the head that will follow our entry
|
||||
*/
|
||||
static inline void osal_list_move_tail(struct osal_list_head *list,
|
||||
struct osal_list_head *head)
|
||||
{
|
||||
osal___list_del_entry(list);
|
||||
osal_list_add_tail(list, head);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_is_last - tests whether @list is the last entry in list @head
|
||||
* @list: the entry to test
|
||||
* @head: the head of the list
|
||||
*/
|
||||
static inline int osal_list_is_last(const struct osal_list_head *list,
|
||||
const struct osal_list_head *head)
|
||||
{
|
||||
return list->next == head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_empty - tests whether a list is empty
|
||||
* @head: the list to test.
|
||||
*/
|
||||
static inline int osal_list_empty(const struct osal_list_head *head)
|
||||
{
|
||||
return head->next == head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_empty_careful - tests whether a list is empty and not being modified
|
||||
* @head: the list to test
|
||||
*
|
||||
* Description:
|
||||
* tests whether a list is empty _and_ checks that no other CPU might be
|
||||
* in the process of modifying either member (next or prev)
|
||||
*
|
||||
* NOTE: using list_empty_careful() without synchronization
|
||||
* can only be safe if the only activity that can happen
|
||||
* to the list entry is list_del_init(). Eg. it cannot be used
|
||||
* if another CPU could re-list_add() it.
|
||||
*/
|
||||
static inline int osal_list_empty_careful(const struct osal_list_head *head)
|
||||
{
|
||||
struct osal_list_head *next = head->next;
|
||||
return (next == head) && (next == head->prev);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_rotate_left - rotate the list to the left
|
||||
* @head: the head of the list
|
||||
*/
|
||||
static inline void osal_list_rotate_left(struct osal_list_head *head)
|
||||
{
|
||||
struct osal_list_head *first;
|
||||
|
||||
if (!osal_list_empty(head)) {
|
||||
first = head->next;
|
||||
osal_list_move_tail(first, head);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_is_singular - tests whether a list has just one entry.
|
||||
* @head: the list to test.
|
||||
*/
|
||||
static inline int osal_list_is_singular(const struct osal_list_head *head)
|
||||
{
|
||||
return !osal_list_empty(head) && (head->next == head->prev);
|
||||
}
|
||||
|
||||
static inline void osal___list_cut_position(struct osal_list_head *list,
|
||||
struct osal_list_head *head, struct osal_list_head *entry)
|
||||
{
|
||||
struct osal_list_head *new_first = entry->next;
|
||||
list->next = head->next;
|
||||
list->next->prev = list;
|
||||
list->prev = entry;
|
||||
entry->next = list;
|
||||
head->next = new_first;
|
||||
new_first->prev = head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_cut_position - cut a list into two
|
||||
* @list: a new list to add all removed entries
|
||||
* @head: a list with entries
|
||||
* @entry: an entry within head, could be the head itself
|
||||
* and if so we won't cut the list
|
||||
*
|
||||
* This helper moves the initial part of @head, up to and
|
||||
* including @entry, from @head to @list. You should
|
||||
* pass on @entry an element you know is on @head. @list
|
||||
* should be an empty list or a list you do not care about
|
||||
* losing its data.
|
||||
*
|
||||
*/
|
||||
static inline void osal_list_cut_position(struct osal_list_head *list,
|
||||
struct osal_list_head *head, struct osal_list_head *entry)
|
||||
{
|
||||
if (osal_list_empty(head)) {
|
||||
return;
|
||||
}
|
||||
if (osal_list_is_singular(head) &&
|
||||
((head->next != entry) && (head != entry))) {
|
||||
return;
|
||||
}
|
||||
if (entry == head) {
|
||||
OSAL_INIT_LIST_HEAD(list);
|
||||
} else {
|
||||
osal___list_cut_position(list, head, entry);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void osal___list_splice(const struct osal_list_head *list,
|
||||
struct osal_list_head *prev,
|
||||
struct osal_list_head *next)
|
||||
{
|
||||
struct osal_list_head *first = list->next;
|
||||
struct osal_list_head *last = list->prev;
|
||||
|
||||
first->prev = prev;
|
||||
prev->next = first;
|
||||
|
||||
last->next = next;
|
||||
next->prev = last;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice - join two lists, this is designed for stacks
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*/
|
||||
static inline void osal_list_splice(const struct osal_list_head *list,
|
||||
struct osal_list_head *head)
|
||||
{
|
||||
if (!osal_list_empty(list)) {
|
||||
osal___list_splice(list, head, head->next);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_tail - join two lists, each list being a queue
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*/
|
||||
static inline void osal_list_splice_tail(struct osal_list_head *list,
|
||||
struct osal_list_head *head)
|
||||
{
|
||||
if (!osal_list_empty(list)) {
|
||||
osal___list_splice(list, head->prev, head);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_init - join two lists and reinitialise the emptied list.
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*
|
||||
* The list at @list is reinitialised
|
||||
*/
|
||||
static inline void osal_list_splice_init(struct osal_list_head *list,
|
||||
struct osal_list_head *head)
|
||||
{
|
||||
if (!osal_list_empty(list)) {
|
||||
osal___list_splice(list, head, head->next);
|
||||
OSAL_INIT_LIST_HEAD(list);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_tail_init - join two lists and reinitialise the emptied list
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*
|
||||
* Each of the lists is a queue.
|
||||
* The list at @list is reinitialised
|
||||
*/
|
||||
static inline void osal_list_splice_tail_init(struct osal_list_head *list,
|
||||
struct osal_list_head *head)
|
||||
{
|
||||
if (!osal_list_empty(list)) {
|
||||
osal___list_splice(list, head->prev, head);
|
||||
OSAL_INIT_LIST_HEAD(list);
|
||||
}
|
||||
}
|
||||
|
||||
#undef osal_offsetof
|
||||
#ifdef __compiler_offsetof
|
||||
#define osal_offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER)
|
||||
#else
|
||||
#define osal_offsetof(TYPE, MEMBER) ((int)(unsigned long)&((TYPE *)0)->MEMBER)
|
||||
#endif
|
||||
|
||||
#define osal_container_of(ptr, type, member) ({ \
|
||||
const __typeof__( ((type *)0)->member ) *__mptr = (ptr); \
|
||||
(type *)( (char *)__mptr - osal_offsetof(type,member) ); })
|
||||
|
||||
/**
|
||||
* list_entry - get the struct for this entry
|
||||
* @ptr: the &struct list_head pointer.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define osal_list_entry(ptr, type, member) \
|
||||
osal_container_of(ptr, type, member)
|
||||
|
||||
/**
|
||||
* list_first_entry - get the first element from a list
|
||||
* @ptr: the list head to take the element from.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Note, that list is expected to be not empty.
|
||||
*/
|
||||
#define osal_list_first_entry(ptr, type, member) \
|
||||
osal_list_entry((ptr)->next, type, member)
|
||||
|
||||
/**
|
||||
* list_for_each - iterate over a list
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define osal_list_for_each(pos, head) \
|
||||
for (pos = (head)->next; pos != (head); pos = pos->next)
|
||||
|
||||
/**
|
||||
* __list_for_each - iterate over a list
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*
|
||||
* This variant doesn't differ from list_for_each() any more.
|
||||
* We don't do prefetching in either case.
|
||||
*/
|
||||
#define osal___list_for_each(pos, head) \
|
||||
for (pos = (head)->next; pos != (head); pos = pos->next)
|
||||
|
||||
/**
|
||||
* list_for_each_prev - iterate over a list backwards
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define osal_list_for_each_prev(pos, head) \
|
||||
for (pos = (head)->prev; pos != (head); pos = pos->prev)
|
||||
|
||||
/**
|
||||
* list_for_each_safe - iterate over a list safe against removal of list entry
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @n: another &struct list_head to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define osal_list_for_each_safe(pos, n, head) \
|
||||
for (pos = (head)->next, n = pos->next; pos != (head); \
|
||||
pos = n, n = pos->next)
|
||||
|
||||
/**
|
||||
* list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @n: another &struct list_head to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define osal_list_for_each_prev_safe(pos, n, head) \
|
||||
for (pos = (head)->prev, n = pos->prev; \
|
||||
pos != (head); \
|
||||
pos = n, n = pos->prev)
|
||||
|
||||
/**
|
||||
* list_for_each_entry - iterate over list of given type
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define osal_list_for_each_entry(pos, head, member) \
|
||||
for (pos = osal_list_entry((head)->next, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = osal_list_entry(pos->member.next, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_reverse - iterate backwards over list of given type.
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define osal_list_for_each_entry_reverse(pos, head, member) \
|
||||
for (pos = osal_list_entry((head)->prev, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = osal_list_entry(pos->member.prev, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
|
||||
* @pos: the type * to use as a start point
|
||||
* @head: the head of the list
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Prepares a pos entry for use as a start point in list_for_each_entry_continue().
|
||||
*/
|
||||
#define osal_list_prepare_entry(pos, head, member) \
|
||||
((pos) ?: osal_list_entry(head, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_continue - continue iteration over list of given type
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Continue to iterate over list of given type, continuing after
|
||||
* the current position.
|
||||
*/
|
||||
#define osal_list_for_each_entry_continue(pos, head, member) \
|
||||
for (pos = osal_list_entry(pos->member.next, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = osal_list_entry(pos->member.next, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_continue_reverse - iterate backwards from the given point
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Start to iterate over list of given type backwards, continuing after
|
||||
* the current position.
|
||||
*/
|
||||
#define osal_list_for_each_entry_continue_reverse(pos, head, member) \
|
||||
for (pos = osal_list_entry(pos->member.prev, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = osal_list_entry(pos->member.prev, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_from - iterate over list of given type from the current point
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type, continuing from current position.
|
||||
*/
|
||||
#define osal_list_for_each_entry_from(pos, head, member) \
|
||||
for (; &pos->member != (head); \
|
||||
pos = osal_list_entry(pos->member.next, __typeof__(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define osal_list_for_each_entry_safe(pos, n, head, member) \
|
||||
for (pos = osal_list_entry((head)->next, __typeof__(*pos), member), \
|
||||
n = osal_list_entry(pos->member.next, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = osal_list_entry(n->member.next, __typeof__(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_continue - continue list iteration safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type, continuing after current point,
|
||||
* safe against removal of list entry.
|
||||
*/
|
||||
#define osal_list_for_each_entry_safe_continue(pos, n, head, member) \
|
||||
for (pos = osal_list_entry(pos->member.next, __typeof__(*pos), member), \
|
||||
n = osal_list_entry(pos->member.next, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = osal_list_entry(n->member.next, __typeof__(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_from - iterate over list from current point safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type from current point, safe against
|
||||
* removal of list entry.
|
||||
*/
|
||||
#define osal_list_for_each_entry_safe_from(pos, n, head, member) \
|
||||
for (n = osal_list_entry(pos->member.next, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = osal_list_entry(n->member.next, __typeof__(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate backwards over list of given type, safe against removal
|
||||
* of list entry.
|
||||
*/
|
||||
#define osal_list_for_each_entry_safe_reverse(pos, n, head, member) \
|
||||
for (pos = osal_list_entry((head)->prev, __typeof__(*pos), member), \
|
||||
n = osal_list_entry(pos->member.prev, __typeof__(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = osal_list_entry(n->member.prev, __typeof__(*n), member))
|
||||
|
||||
/**
|
||||
* list_safe_reset_next - reset a stale list_for_each_entry_safe loop
|
||||
* @pos: the loop cursor used in the list_for_each_entry_safe loop
|
||||
* @n: temporary storage used in list_for_each_entry_safe
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* list_safe_reset_next is not safe to use in general if the list may be
|
||||
* modified concurrently (eg. the lock is dropped in the loop body). An
|
||||
* exception to this is if the cursor element (pos) is pinned in the list,
|
||||
* and list_safe_reset_next is called after re-taking the lock and before
|
||||
* completing the current iteration of the loop body.
|
||||
*/
|
||||
#define osal_list_safe_reset_next(pos, n, member) \
|
||||
n = osal_list_entry(pos->member.next, __typeof__(*pos), member)
|
||||
|
||||
/*
|
||||
* Double linked lists with a single pointer list head.
|
||||
* Mostly useful for hash tables where the two pointer list head is
|
||||
* too wasteful.
|
||||
* You lose the ability to access the tail in O(1).
|
||||
*/
|
||||
struct osal_hlist_node {
|
||||
struct osal_hlist_node *next, **pprev;
|
||||
};
|
||||
struct osal_hlist_head {
|
||||
struct osal_hlist_node *first;
|
||||
};
|
||||
|
||||
#define OSAL_HLIST_HEAD_INIT \
|
||||
{ \
|
||||
.first = OSAL_NULL \
|
||||
}
|
||||
#define OSAL_HLIST_HEAD(name) struct osal_hlist_head name = { .first = OSAL_NULL }
|
||||
#define INIT_OSAL_HLIST_HEAD(ptr) ((ptr)->first = OSAL_NULL)
|
||||
static inline void INIT_OSAL_HLIST_NODE(struct osal_hlist_node *h)
|
||||
{
|
||||
h->next = OSAL_NULL;
|
||||
h->pprev = OSAL_NULL;
|
||||
}
|
||||
|
||||
static inline int osal_hlist_unhashed(const struct osal_hlist_node *h)
|
||||
{
|
||||
return !h->pprev;
|
||||
}
|
||||
|
||||
static inline int osal_hlist_empty(const struct osal_hlist_head *h)
|
||||
{
|
||||
return !h->first;
|
||||
}
|
||||
|
||||
static inline void osal___hlist_del(struct osal_hlist_node *n)
|
||||
{
|
||||
struct osal_hlist_node *next = n->next;
|
||||
struct osal_hlist_node **pprev = n->pprev;
|
||||
*pprev = next;
|
||||
if (next) {
|
||||
next->pprev = pprev;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void osal_hlist_del(struct osal_hlist_node *n)
|
||||
{
|
||||
osal___hlist_del(n);
|
||||
n->next = OSAL_LIST_POISON1;
|
||||
n->pprev = OSAL_LIST_POISON2;
|
||||
}
|
||||
|
||||
static inline void osal_hlist_del_init(struct osal_hlist_node *n)
|
||||
{
|
||||
if (!osal_hlist_unhashed(n)) {
|
||||
osal___hlist_del(n);
|
||||
INIT_OSAL_HLIST_NODE(n);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void osal_hlist_add_head(struct osal_hlist_node *n, struct osal_hlist_head *h)
|
||||
{
|
||||
struct osal_hlist_node *first = h->first;
|
||||
n->next = first;
|
||||
if (first) {
|
||||
first->pprev = &n->next;
|
||||
}
|
||||
h->first = n;
|
||||
n->pprev = &h->first;
|
||||
}
|
||||
|
||||
/* next must be != NULL */
|
||||
static inline void osal_hlist_add_before(struct osal_hlist_node *n,
|
||||
struct osal_hlist_node *next)
|
||||
{
|
||||
n->pprev = next->pprev;
|
||||
n->next = next;
|
||||
next->pprev = &n->next;
|
||||
*(n->pprev) = n;
|
||||
}
|
||||
|
||||
static inline void osal_hlist_add_after(struct osal_hlist_node *n,
|
||||
struct osal_hlist_node *next)
|
||||
{
|
||||
next->next = n->next;
|
||||
n->next = next;
|
||||
next->pprev = &n->next;
|
||||
|
||||
if (next->next) {
|
||||
next->next->pprev = &next->next;
|
||||
}
|
||||
}
|
||||
|
||||
/* after that we'll appear to be on some hlist and hlist_del will work */
|
||||
static inline void osal_hlist_add_fake(struct osal_hlist_node *n)
|
||||
{
|
||||
n->pprev = &n->next;
|
||||
}
|
||||
|
||||
/*
|
||||
* Move a list from one list head to another. Fixup the pprev
|
||||
* reference of the first entry if it exists.
|
||||
*/
|
||||
static inline void osal_hlist_move_list(struct osal_hlist_head *old,
|
||||
struct osal_hlist_head *new)
|
||||
{
|
||||
new->first = old->first;
|
||||
if (new->first) {
|
||||
new->first->pprev = &new->first;
|
||||
}
|
||||
old->first = OSAL_NULL;
|
||||
}
|
||||
|
||||
#define osal_hlist_entry(ptr, type, member) osal_container_of(ptr, type, member)
|
||||
|
||||
#define osal_hlist_for_each(pos, head) \
|
||||
for (pos = (head)->first; pos; pos = pos->next)
|
||||
|
||||
#define osal_hlist_for_each_safe(pos, n, head) \
|
||||
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
|
||||
pos = n)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry - iterate over list of given type
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define osal_hlist_for_each_entry(tpos, pos, head, member) \
|
||||
for (pos = (head)->first; \
|
||||
pos && \
|
||||
({ tpos = osal_hlist_entry(pos, __typeof__(*tpos), member); 1; }); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_continue - iterate over a hlist continuing after current point
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define osal_hlist_for_each_entry_continue(tpos, pos, member) \
|
||||
for (pos = (pos)->next; \
|
||||
pos && \
|
||||
({ tpos = osal_hlist_entry(pos, __typeof__(*tpos), member); 1; }); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_from - iterate over a hlist continuing from current point
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define osal_hlist_for_each_entry_from(tpos, pos, member) \
|
||||
for (; pos && \
|
||||
({ tpos = osal_hlist_entry(pos, __typeof__(*tpos), member); 1; }); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @n: another &struct hlist_node to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define osal_hlist_for_each_entry_safe(tpos, pos, n, head, member) \
|
||||
for (pos = (head)->first; \
|
||||
pos && ({ n = pos->next; 1; }) && \
|
||||
({ tpos = osal_hlist_entry(pos, __typeof__(*tpos), member); 1; }); \
|
||||
pos = n)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,241 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef _OSAL_MMZ_H
|
||||
#define _OSAL_MMZ_H
|
||||
|
||||
#include "osal.h"
|
||||
|
||||
#define CACHE_LINE_SIZE (0x40)
|
||||
#define MMZ_MMZ_NAME_LEN 32
|
||||
#define MMZ_MMB_NAME_LEN 16
|
||||
|
||||
struct mmz_media_memory_zone {
|
||||
char name[MMZ_MMZ_NAME_LEN];
|
||||
|
||||
unsigned long gfp;
|
||||
|
||||
unsigned long phys_start;
|
||||
unsigned long nbytes;
|
||||
|
||||
struct osal_list_head list;
|
||||
union {
|
||||
struct device *cma_dev;
|
||||
unsigned char *bitmap;
|
||||
};
|
||||
struct osal_list_head mmb_list;
|
||||
|
||||
unsigned int alloc_type;
|
||||
unsigned long block_align;
|
||||
|
||||
void (*destructor)(const void *);
|
||||
};
|
||||
typedef struct mmz_media_memory_zone mmz_mmz_t;
|
||||
|
||||
#define MMZ_MMZ_FMT_S "PHYS(0x%08lX, 0x%08lX), GFP=%lu, nBYTES=%luKB, NAME=\"%s\""
|
||||
#define mmz_mmz_fmt_arg(p) (p)->phys_start, (p)->phys_start + (p)->nbytes - 1, (p)->gfp, (p)->nbytes / SZ_1K, (p)->name
|
||||
|
||||
#define MMZ_MMB_NAME_LEN 16
|
||||
struct mmz_media_memory_block {
|
||||
#ifndef MMZ_V2_SUPPORT
|
||||
unsigned int id;
|
||||
#endif
|
||||
char name[MMZ_MMB_NAME_LEN];
|
||||
struct mmz_media_memory_zone *zone;
|
||||
struct osal_list_head list;
|
||||
|
||||
unsigned long phys_addr;
|
||||
void *kvirt;
|
||||
unsigned long length;
|
||||
|
||||
unsigned long flags;
|
||||
|
||||
unsigned int order;
|
||||
|
||||
int phy_ref;
|
||||
int map_ref;
|
||||
};
|
||||
typedef struct mmz_media_memory_block mmz_mmb_t;
|
||||
|
||||
#define mmz_mmb_kvirt(p) ({mmz_mmb_t *__mmb=(p); OSAL_BUG_ON(__mmb==NULL); __mmb->kvirt; })
|
||||
#define mmz_mmb_phys(p) ({mmz_mmb_t *__mmb=(p); OSAL_BUG_ON(__mmb==NULL); __mmb->phys_addr; })
|
||||
#define mmz_mmb_length(p) ({mmz_mmb_t *__mmb=(p); OSAL_BUG_ON(__mmb==NULL); __mmb->length; })
|
||||
#define mmz_mmb_name(p) ({mmz_mmb_t *__mmb=(p); OSAL_BUG_ON(__mmb==NULL); __mmb->name; })
|
||||
#define mmz_mmb_zone(p) ({mmz_mmb_t *__mmb=(p); OSAL_BUG_ON(__mmb==NULL); __mmb->zone; })
|
||||
|
||||
#define MMZ_MMB_MAP2KERN (1 << 0)
|
||||
#define MMZ_MMB_MAP2KERN_CACHED (1 << 1)
|
||||
#define MMZ_MMB_RELEASED (1 << 2)
|
||||
|
||||
#define MMZ_MMB_FMT_S "phys(0x%08lX, 0x%08lX), kvirt=0x%08lX, flags=0x%08lX, length=%luKB, name=\"%s\""
|
||||
#define mmz_mmb_fmt_arg(p) (p)->phys_addr, mmz_grain_align((p)->phys_addr + (p)->length) - 1, (unsigned long)(uintptr_t)((p)->kvirt), (p)->flags, (p)->length / SZ_1K, (p)->name
|
||||
|
||||
#define DEFAULT_ALLOC 0
|
||||
#define SLAB_ALLOC 1
|
||||
#define EQ_BLOCK_ALLOC 2
|
||||
|
||||
#define LOW_TO_HIGH 0
|
||||
#define HIGH_TO_LOW 1
|
||||
|
||||
#define MMZ_DBG_LEVEL 0x0
|
||||
#define mmz_trace(level, s, params...) \
|
||||
do { \
|
||||
if (level & MMZ_DBG_LEVEL) \
|
||||
printk(KERN_INFO "[%s, %d]: " s "\n", __FUNCTION__, __LINE__, params); \
|
||||
} while (0)
|
||||
|
||||
#define mmz_trace_func() mmz_trace(0x02, "%s", __FUNCTION__)
|
||||
|
||||
#define MMZ_GRAIN PAGE_SIZE
|
||||
#define mmz_bitmap_size(p) (mmz_align2(mmz_length2grain((p)->nbytes), 8) / 8)
|
||||
|
||||
#define mmz_get_bit(p, n) (((p)->bitmap[(n) / 8] >> ((n)&0x7)) & 0x1)
|
||||
#define mmz_set_bit(p, n) (p)->bitmap[(n) / 8] |= 1 << ((n)&0x7)
|
||||
#define mmz_clr_bit(p, n) (p)->bitmap[(n) / 8] &= ~(1 << ((n)&0x7))
|
||||
|
||||
#define mmz_pos2phy_addr(p, n) ((p)->phys_start + (n)*MMZ_GRAIN)
|
||||
#define mmz_phy_addr2pos(p, a) (((a) - (p)->phys_start) / MMZ_GRAIN)
|
||||
|
||||
#define mmz_align2low(x, g) (((x) / (g)) * (g))
|
||||
#define mmz_align2(x, g) ((((x) + (g)-1) / (g)) * (g))
|
||||
#define mmz_grain_align(x) mmz_align2(x, MMZ_GRAIN)
|
||||
#define mmz_length2grain(len) (mmz_grain_align(len) / MMZ_GRAIN)
|
||||
|
||||
#define begin_list_for_each_mmz(p, gfp, mmz_name) \
|
||||
list_for_each_entry(p, &mmz_list, list) \
|
||||
{ \
|
||||
if (gfp == 0 ? 0 : (p)->gfp != (gfp)) \
|
||||
continue; \
|
||||
if ((mmz_name == NULL) || (*mmz_name == '\0')) { \
|
||||
if (strcmp("anonymous", p->name)) \
|
||||
continue; \
|
||||
} else { \
|
||||
if (strcmp(mmz_name, p->name)) \
|
||||
continue; \
|
||||
} \
|
||||
mmz_trace(1, MMZ_MMZ_FMT_S, mmz_mmz_fmt_arg(p));
|
||||
#define end_list_for_each_mmz() }
|
||||
|
||||
#if defined(KERNEL_BIT_64) && defined(USER_BIT_32)
|
||||
#define __phys_addr_type__ unsigned long long
|
||||
#define __phys_len_type__ unsigned long long
|
||||
#define __phys_addr_align__ __attribute__((aligned(8)))
|
||||
#else
|
||||
#define __phys_addr_type__ unsigned long
|
||||
#define __phys_len_type__ unsigned long
|
||||
#define __phys_addr_align__ __attribute__((aligned(sizeof(long))))
|
||||
#endif
|
||||
|
||||
struct mmb_info {
|
||||
__phys_addr_type__ phys_addr; /* phys-memory address */
|
||||
__phys_addr_type__ __phys_addr_align__ align; /* if you need your phys-memory have special align size */
|
||||
__phys_len_type__ __phys_addr_align__ size; /* length of memory you need, in bytes */
|
||||
unsigned int __phys_addr_align__ order;
|
||||
|
||||
void *__phys_addr_align__ mapped; /* userspace mapped ptr */
|
||||
|
||||
union {
|
||||
struct
|
||||
{
|
||||
unsigned long prot : 8; /* PROT_READ or PROT_WRITE */
|
||||
unsigned long flags : 12; /* MAP_SHARED or MAP_PRIVATE */
|
||||
|
||||
#ifdef __KERNEL__
|
||||
unsigned long reserved : 7;/* reserved, do not use */
|
||||
unsigned long kernel_mmb :1;
|
||||
unsigned long delayed_free : 1;
|
||||
unsigned long map_cached : 1;
|
||||
#endif
|
||||
};
|
||||
unsigned long w32_stuf;
|
||||
} __phys_addr_align__;
|
||||
|
||||
char mmb_name[MMZ_MMB_NAME_LEN];
|
||||
char mmz_name[MMZ_MMZ_NAME_LEN];
|
||||
unsigned long __phys_addr_align__ gfp; /* reserved, do set to 0 */
|
||||
|
||||
#ifdef __KERNEL__
|
||||
int map_ref;
|
||||
int mmb_ref;
|
||||
|
||||
struct osal_list_head list;
|
||||
mmz_mmb_t *mmb;
|
||||
#endif
|
||||
} __attribute__((aligned(8)));
|
||||
|
||||
struct dirty_area {
|
||||
__phys_addr_type__ dirty_phys_start; /* dirty physical address */
|
||||
void *__phys_addr_align__ dirty_virt_start; /* dirty virtual address,
|
||||
must be coherent with dirty_phys_addr */
|
||||
__phys_len_type__ __phys_addr_align__ dirty_size;
|
||||
} __phys_addr_align__;
|
||||
|
||||
#define IOC_MMB_ALLOC _IOWR('m', 10, struct mmb_info)
|
||||
#define IOC_MMB_ATTR _IOR('m', 11, struct mmb_info)
|
||||
#define IOC_MMB_FREE _IOW('m', 12, struct mmb_info)
|
||||
|
||||
#define IOC_MMB_USER_REMAP _IOWR('m', 20, struct mmb_info)
|
||||
#define IOC_MMB_USER_REMAP_CACHED _IOWR('m', 21, struct mmb_info)
|
||||
#define IOC_MMB_USER_UNMAP _IOWR('m', 22, struct mmb_info)
|
||||
|
||||
#define IOC_MMB_VIRT_GET_PHYS _IOWR('m', 23, struct mmb_info)
|
||||
|
||||
#define IOC_MMB_ADD_REF _IO('r', 30) /* ioctl(file, cmd, arg), arg is mmb_addr */
|
||||
#define IOC_MMB_DEC_REF _IO('r', 31) /* ioctl(file, cmd, arg), arg is mmb_addr */
|
||||
|
||||
#define IOC_MMB_FLUSH_DCACHE _IO('c', 40)
|
||||
|
||||
#define IOC_MMB_FLUSH_DCACHE_DIRTY _IOW('d', 50, struct dirty_area)
|
||||
#define IOC_MMB_TEST_CACHE _IOW('t', 11, struct mmb_info)
|
||||
|
||||
#define MMZ_SETUP_CMDLINE_LEN 256
|
||||
|
||||
/*
|
||||
* APIs
|
||||
*/
|
||||
extern mmz_mmz_t *mmz_mmz_create(const char *name, unsigned long gfp, unsigned long phys_start,
|
||||
unsigned long nbytes);
|
||||
|
||||
extern int mmz_mmz_destroy(mmz_mmz_t *zone);
|
||||
|
||||
extern int mmz_mmz_register(mmz_mmz_t *zone);
|
||||
extern int mmz_mmz_unregister(mmz_mmz_t *zone);
|
||||
extern mmz_mmz_t *mmz_mmz_find(unsigned long gfp, const char *mmz_name);
|
||||
|
||||
extern mmz_mmb_t *mmz_mmb_alloc(const char *name, unsigned long size, unsigned long align,
|
||||
unsigned long gfp, const char *mmz_name);
|
||||
extern int mmz_mmb_free(mmz_mmb_t *mmb);
|
||||
extern mmz_mmb_t *mmz_mmb_getby_phys(unsigned long addr);
|
||||
extern mmz_mmb_t *mmz_mmb_getby_phys_2(unsigned long addr, unsigned long *Outoffset); // used in cipher
|
||||
extern mmz_mmb_t *mmz_mmb_getby_kvirt(void *virt);
|
||||
extern unsigned long usr_virt_to_phys(unsigned long virt);
|
||||
|
||||
extern int mmz_is_phys_in_mmz(unsigned long addr_start, unsigned long addr_len);
|
||||
|
||||
extern int mmz_vma_check(unsigned long vm_start, unsigned long vm_end);
|
||||
extern int mmz_mmb_flush_dcache_byaddr_safe(void *kvirt, unsigned long phys_addr, unsigned long length);
|
||||
|
||||
extern unsigned long mmz_mmz_get_phys(const char *zone_name);
|
||||
|
||||
#define mmz_mmb_freeby_phys(phys_addr) mmz_mmb_free(mmz_mmb_getby_phys(phys_addr))
|
||||
|
||||
extern void *mmz_mmb_map2kern(mmz_mmb_t *mmb);
|
||||
extern void *mmz_mmb_map2kern_cached(mmz_mmb_t *mmb);
|
||||
|
||||
extern int mmz_mmb_flush_dcache_byaddr(void *kvirt, unsigned long phys_addr, unsigned long length);
|
||||
extern int mmz_mmb_invalid_cache_byaddr(void *kvirt, unsigned long phys_addr, unsigned long length);
|
||||
|
||||
extern int mmz_mmb_unmap(mmz_mmb_t *mmb);
|
||||
extern int mmz_mmb_get(mmz_mmb_t *mmb);
|
||||
extern int mmz_mmb_put(mmz_mmb_t *mmb);
|
||||
|
||||
extern void *mmz_mmf_map2kern_nocache(unsigned long phys, int len);
|
||||
extern void *mmz_mmf_map2kern_cache(unsigned long phys, int len);
|
||||
extern void mmz_mmf_unmap(void *virt);
|
||||
|
||||
/* for mmz userdev */
|
||||
int mmz_userdev_init(void);
|
||||
void mmz_userdev_exit(void);
|
||||
int mmz_flush_dcache_all(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,20 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __OSAL_USER__
|
||||
#define __OSAL_USER__
|
||||
|
||||
#ifndef PROT_READ
|
||||
#define PROT_READ
|
||||
#endif
|
||||
#ifndef PROT_WRITE
|
||||
#define PROT_WRITE
|
||||
#endif
|
||||
#ifndef MAP_SHARED
|
||||
#define MAP_SHARED
|
||||
#endif
|
||||
#ifndef MAP_FAILED
|
||||
#define MAP_FAILED (NULL)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,59 @@
|
||||
ifneq ($(srctree),)
|
||||
KERNEL_DIR := $(srctree)
|
||||
SDK_DIR := $(shell cd $(KERNEL_DIR)/../../.. && /bin/pwd)
|
||||
else
|
||||
SDK_DIR := $(shell cd $(CURDIR)/../../../../../.. && /bin/pwd)
|
||||
endif
|
||||
|
||||
include $(SDK_DIR)/build/base.mk
|
||||
include $(SDK_DIR)/build/version.mk
|
||||
|
||||
OSAL_ROOT := $(GMP_DIR)/drv/osal
|
||||
|
||||
MOD_NAME := xm_osal
|
||||
|
||||
SRCS := osal_fileops.c \
|
||||
osal_vmalloc.c \
|
||||
osal_addr.c \
|
||||
osal_init.c \
|
||||
osal_atomic.c \
|
||||
osal_barrier.c \
|
||||
osal_cache.c \
|
||||
osal_debug.c \
|
||||
osal_device.c \
|
||||
osal_interrupt.c \
|
||||
osal_math.c \
|
||||
osal_mutex.c \
|
||||
osal_proc.c \
|
||||
osal_schedule.c \
|
||||
osal_semaphore.c \
|
||||
osal_spinlock.c \
|
||||
osal_string.c \
|
||||
osal_task.c \
|
||||
osal_timer.c \
|
||||
osal_wait.c \
|
||||
osal_workqueue.c \
|
||||
osal_notifier.c \
|
||||
osal_platform.c
|
||||
|
||||
SRCS += ./media/base.c \
|
||||
./media/media.c \
|
||||
./mmz/media-mem.c \
|
||||
./mmz/mmz-userdev.c \
|
||||
./mmz/drv_mmz.c \
|
||||
./mmz/allocator.c
|
||||
|
||||
ifeq ($(CONFIG_CMA),y)
|
||||
SRCS += ./mmz/cma_allocator.c
|
||||
endif
|
||||
|
||||
SDK_KER_CFLAGS += -D$(CHIPSET) -DRELEASE -DUSER_BIT_32 -DKERNEL_BIT_32 -Wno-date-time -D_GNU_SOURCE
|
||||
|
||||
SDK_KER_CFLAGS += -I$(OSAL_ROOT)/include \
|
||||
-I$(OSAL_ROOT)/linux/kernel \
|
||||
-I$(OSAL_ROOT)/linux/kernel/media \
|
||||
-I$(OSAL_ROOT)/linux/kernel/mmz \
|
||||
-I$(GMP_DIR)/drv/include \
|
||||
-I$(GMP_DIR)/include
|
||||
|
||||
include $(SDK_DIR)/build/sdk_ko_rules.mk
|
||||
+362
@@ -0,0 +1,362 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/version.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/major.h>
|
||||
#include <linux/stat.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/kmod.h>
|
||||
|
||||
#include "base.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
/**** media bus ****/
|
||||
/*****************************************************************************/
|
||||
|
||||
static void media_bus_release(struct device *dev)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
struct device media_bus = {
|
||||
// change media_bus name from "media" to "gmp", because bus "media" is used in kenrel
|
||||
.init_name = "gmp",
|
||||
.release = media_bus_release
|
||||
};
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0)
|
||||
/* sysfs modalias store/show */
|
||||
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
|
||||
char *buf)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
int len = snprintf(buf, PAGE_SIZE, "media:%s\n", pdev->devfs_name);
|
||||
|
||||
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
|
||||
}
|
||||
|
||||
static struct device_attribute media_dev_attrs[] = {
|
||||
__ATTR_RO(modalias),
|
||||
__ATTR_NULL,
|
||||
};
|
||||
#endif
|
||||
|
||||
/* bus match & uevent */
|
||||
static int media_match(struct device *dev, struct device_driver *drv)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
return (strncmp(pdev->devfs_name, drv->name, sizeof(pdev->devfs_name)) == 0);
|
||||
}
|
||||
|
||||
static int media_uevent(struct device *dev, struct kobj_uevent_env *env)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
add_uevent_var(env, "MODALIAS=media:%s", pdev->devfs_name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
// pm methods
|
||||
static int media_pm_prepare(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_prepare == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_prepare(pdev);
|
||||
}
|
||||
|
||||
static void media_pm_complete(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_complete == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
pdrv->ops->pm_complete(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_suspend(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_suspend == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_suspend(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_resume(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_resume == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_resume(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_freeze(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_freeze == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_freeze(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_thaw(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_thaw == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_thaw(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_poweroff(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_poweroff == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_poweroff(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_restore(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_restore == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_restore(pdev);
|
||||
}
|
||||
static int media_pm_suspend_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_suspend_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_suspend_noirq(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_resume_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_resume_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_resume_noirq(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_freeze_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_freeze_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_freeze_noirq(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_thaw_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_thaw_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_thaw_noirq(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_poweroff_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_poweroff_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_poweroff_noirq(pdev);
|
||||
}
|
||||
|
||||
static int media_pm_restore_noirq(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->pm_restore_noirq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->pm_restore_noirq(pdev);
|
||||
}
|
||||
|
||||
static struct dev_pm_ops media_bus_pm_ops = {
|
||||
.prepare = media_pm_prepare,
|
||||
.complete = media_pm_complete,
|
||||
|
||||
// with irq
|
||||
.suspend = media_pm_suspend,
|
||||
.resume = media_pm_resume,
|
||||
|
||||
.freeze = media_pm_freeze,
|
||||
.thaw = media_pm_thaw,
|
||||
.poweroff = media_pm_poweroff,
|
||||
.restore = media_pm_restore,
|
||||
|
||||
// with noirq
|
||||
.suspend_noirq = media_pm_suspend_noirq,
|
||||
.resume_noirq = media_pm_resume_noirq,
|
||||
.freeze_noirq = media_pm_freeze_noirq,
|
||||
.thaw_noirq = media_pm_thaw_noirq,
|
||||
.poweroff_noirq = media_pm_poweroff_noirq,
|
||||
.restore_noirq = media_pm_restore_noirq,
|
||||
};
|
||||
|
||||
struct bus_type media_bus_type = {
|
||||
// change media_bus name from "media" to "gmp", because bus "media" is used in kenrel
|
||||
.name = "gmp",
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0)
|
||||
.dev_attrs = media_dev_attrs,
|
||||
#endif
|
||||
.match = media_match,
|
||||
.uevent = media_uevent,
|
||||
.pm = &media_bus_pm_ops,
|
||||
};
|
||||
|
||||
int media_bus_init(void)
|
||||
{
|
||||
int ret;
|
||||
ret = device_register(&media_bus);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = bus_register(&media_bus_type);
|
||||
if (ret) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
error:
|
||||
|
||||
device_unregister(&media_bus);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void media_bus_exit(void)
|
||||
{
|
||||
bus_unregister(&media_bus_type);
|
||||
device_unregister(&media_bus);
|
||||
}
|
||||
|
||||
static void media_device_release(struct device *dev)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int _media_device_register(struct media_device *pdev)
|
||||
{
|
||||
dev_set_name(&pdev->device, "%s", pdev->devfs_name);
|
||||
|
||||
pdev->device.devt = MKDEV(MEDIA_DEVICE_MAJOR, pdev->minor);
|
||||
pdev->device.release = media_device_release;
|
||||
pdev->device.bus = &media_bus_type;
|
||||
|
||||
return device_register(&pdev->device);
|
||||
}
|
||||
|
||||
void _media_device_unregister(struct media_device *pdev)
|
||||
{
|
||||
device_unregister(&pdev->device);
|
||||
}
|
||||
|
||||
struct media_driver *media_driver_register(const char *name,
|
||||
struct module *owner, struct media_ops *ops)
|
||||
{
|
||||
int ret;
|
||||
struct media_driver *pdrv = NULL;
|
||||
#ifdef MODULE
|
||||
if ((name == NULL) || (owner == NULL)) {
|
||||
#else
|
||||
if (name == NULL){
|
||||
#endif
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
|
||||
pdrv = kzalloc(sizeof(struct media_driver) + strnlen(name, MEDIA_MAX_DEV_NAME_LEN), GFP_KERNEL);
|
||||
if (pdrv == NULL) {
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
/* init driver object */
|
||||
strncpy(pdrv->name, name, strnlen(name, MEDIA_MAX_DEV_NAME_LEN));
|
||||
|
||||
pdrv->ops = ops;
|
||||
|
||||
pdrv->driver.name = pdrv->name;
|
||||
pdrv->driver.owner = owner;
|
||||
pdrv->driver.bus = &media_bus_type;
|
||||
|
||||
ret = driver_register(&pdrv->driver);
|
||||
if (ret) {
|
||||
kfree(pdrv);
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
return pdrv;
|
||||
}
|
||||
|
||||
void media_driver_unregister(struct media_driver *pdrv)
|
||||
{
|
||||
if (pdrv != NULL) {
|
||||
driver_unregister(&pdrv->driver);
|
||||
kfree(pdrv);
|
||||
}
|
||||
}
|
||||
|
||||
// end!
|
||||
/*****************************************************************************/
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef _MEDIA_BASE_H_
|
||||
#define _MEDIA_BASE_H_
|
||||
|
||||
#include "media.h"
|
||||
|
||||
int media_bus_init(void);
|
||||
void media_bus_exit(void);
|
||||
|
||||
#if 0
|
||||
struct device *_media_device_register(struct class *class,
|
||||
dev_t devt, const char *name);
|
||||
|
||||
void _media_device_unregister(struct class *class, dev_t devt);
|
||||
|
||||
#else
|
||||
|
||||
int _media_device_register(struct media_device *pdev);
|
||||
|
||||
void _media_device_unregister(struct media_device *pdev);
|
||||
|
||||
#endif
|
||||
|
||||
struct media_driver *media_driver_register(const char *name,
|
||||
struct module *owner, struct media_ops *ops);
|
||||
|
||||
void media_driver_unregister(struct media_driver *pdrv);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,343 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/major.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/stat.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/kmod.h>
|
||||
#include <linux/devfreq.h>
|
||||
|
||||
#include "base.h"
|
||||
#include "osal_devfreq.h"
|
||||
|
||||
static OSAL_LIST_HEAD(media_list);
|
||||
static DEFINE_MUTEX(media_sem);
|
||||
|
||||
/*
|
||||
* Assigned numbers, used for dynamic minors
|
||||
*/
|
||||
#define DYNAMIC_MINORS 64 /* like dynamic majors */
|
||||
static unsigned char media_minors[DYNAMIC_MINORS / 8];
|
||||
|
||||
int media_devfreq_target(struct device *dev, unsigned long *freq, unsigned int flags)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->devfreq_target == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->devfreq_target(pdev, freq, flags);
|
||||
}
|
||||
|
||||
int media_devfreq_get_dev_status(struct device *dev, struct devfreq_dev_status *stat)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
osal_devfreq_dev_status_t pstat;
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->devfreq_get_dev_status == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
pstat.total_time = stat->total_time;
|
||||
pstat.busy_time = stat->busy_time;
|
||||
pstat.current_frequency = stat->current_frequency;
|
||||
pstat.private_data = stat->private_data;
|
||||
|
||||
return pdrv->ops->devfreq_get_dev_status(pdev, &pstat);
|
||||
}
|
||||
|
||||
int media_devfreq_get_cur_freq(struct device *dev, unsigned long *freq)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->devfreq_get_cur_freq == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return pdrv->ops->devfreq_get_cur_freq(pdev, freq);
|
||||
}
|
||||
|
||||
void media_devfreq_exit(struct device *dev)
|
||||
{
|
||||
struct media_device *pdev = to_media_device(dev);
|
||||
struct media_driver *pdrv = to_media_driver(dev->driver);
|
||||
|
||||
if ((pdrv->ops == NULL) || (pdrv->ops->devfreq_exit == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
return pdrv->ops->devfreq_exit(pdev);
|
||||
}
|
||||
|
||||
int media_devfreq_register(struct media_device *media, osal_devfreq_para_t *devfreq_para)
|
||||
{
|
||||
struct device *dev = (struct device *)&media->device;
|
||||
struct devfreq_dev_profile *profile = &(media->profile);
|
||||
|
||||
profile->initial_freq = devfreq_para->initial_freq;
|
||||
profile->polling_ms = devfreq_para->polling_ms;
|
||||
profile->target = media_devfreq_target;
|
||||
profile->get_dev_status = media_devfreq_get_dev_status;
|
||||
profile->get_cur_freq = media_devfreq_get_cur_freq;
|
||||
profile->exit = media_devfreq_exit;
|
||||
profile->freq_table = devfreq_para->freq_table;
|
||||
profile->max_state = devfreq_para->max_state;
|
||||
|
||||
media->devfreq = devm_devfreq_add_device(dev, profile, "userspace", NULL);
|
||||
if (IS_ERR(media->devfreq)) {
|
||||
printk("failed to add devfreq device\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void media_devfreq_unregister(struct media_device *media)
|
||||
{
|
||||
struct device *dev = (struct device *)&media->device;
|
||||
|
||||
devm_devfreq_remove_device(dev, media->devfreq);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static int media_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
int minor = iminor(inode);
|
||||
struct media_device *c = NULL;
|
||||
int err = -ENODEV;
|
||||
const struct file_operations *old_fops, *new_fops = NULL;
|
||||
|
||||
mutex_lock(&media_sem);
|
||||
|
||||
osal_list_for_each_entry(c, &media_list, list) {
|
||||
if (c->minor == minor) {
|
||||
new_fops = fops_get(c->fops);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_fops == NULL) {
|
||||
mutex_unlock(&media_sem);
|
||||
request_module("char-major-%d-%d", MEDIA_DEVICE_MAJOR, minor);
|
||||
mutex_lock(&media_sem);
|
||||
|
||||
osal_list_for_each_entry(c, &media_list, list) {
|
||||
if (c->minor == minor) {
|
||||
new_fops = fops_get(c->fops);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_fops == NULL) {
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
err = 0;
|
||||
|
||||
old_fops = file->f_op;
|
||||
file->f_op = new_fops;
|
||||
if (file->f_op->open) {
|
||||
file->private_data = c;
|
||||
err = file->f_op->open(inode, file);
|
||||
if (err) {
|
||||
fops_put(file->f_op);
|
||||
file->private_data = NULL;
|
||||
file->f_op = fops_get(old_fops);
|
||||
}
|
||||
}
|
||||
|
||||
fops_put(old_fops);
|
||||
fail:
|
||||
mutex_unlock(&media_sem);
|
||||
return err;
|
||||
}
|
||||
|
||||
static struct file_operations media_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = media_open,
|
||||
};
|
||||
|
||||
/**
|
||||
* media_register - register a media device
|
||||
* @media: device structure
|
||||
*
|
||||
* Register a media device with the kernel. If the minor
|
||||
* number is set to %MEDIA_DYNAMIC_MINOR a minor number is assigned
|
||||
* and placed in the minor field of the structure. For other cases
|
||||
* the minor number requested is used.
|
||||
*
|
||||
* The structure passed is linked into the kernel and may not be
|
||||
* destroyed until it has been unregistered.
|
||||
*
|
||||
* A zero is returned on success and a negative errno code for
|
||||
* failure.
|
||||
*/
|
||||
|
||||
int media_register(struct media_device *media)
|
||||
{
|
||||
struct media_device *ptmp = NULL;
|
||||
struct media_driver *pdrv = NULL;
|
||||
|
||||
int err = 0;
|
||||
|
||||
mutex_lock(&media_sem);
|
||||
|
||||
/* check if registered */
|
||||
osal_list_for_each_entry(ptmp, &media_list, list) {
|
||||
if (ptmp->minor == media->minor) {
|
||||
mutex_unlock(&media_sem);
|
||||
return -EBUSY;
|
||||
}
|
||||
}
|
||||
|
||||
/* check minor */
|
||||
if (media->minor == MEDIA_DYNAMIC_MINOR) {
|
||||
int i = DYNAMIC_MINORS;
|
||||
|
||||
while (--i >= 0)
|
||||
if ((media_minors[(unsigned int)i >> 3] & (1 << ((unsigned int)i & 7))) == 0) {
|
||||
break;
|
||||
}
|
||||
if (i < 0) {
|
||||
mutex_unlock(&media_sem);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
media->minor = i;
|
||||
}
|
||||
|
||||
if (media->minor < DYNAMIC_MINORS) {
|
||||
media_minors[media->minor >> 3] |= 1 << (media->minor & 7);
|
||||
}
|
||||
|
||||
/* device register */
|
||||
err = _media_device_register(media);
|
||||
if (err < 0) {
|
||||
media_minors[media->minor >> 3] &= ~(1 << (media->minor & 7));
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* driver register */
|
||||
pdrv = media_driver_register(media->devfs_name, media->owner, media->drvops);
|
||||
if (IS_ERR(pdrv)) {
|
||||
_media_device_unregister(media);
|
||||
|
||||
media_minors[media->minor >> 3] &= ~(1 << (media->minor & 7));
|
||||
|
||||
err = PTR_ERR(pdrv);
|
||||
goto out;
|
||||
}
|
||||
|
||||
media->driver = pdrv;
|
||||
|
||||
/*
|
||||
* Add it to the front, so that later devices can "override"
|
||||
* earlier defaults
|
||||
*/
|
||||
osal_list_add(&media->list, &media_list);
|
||||
|
||||
out:
|
||||
mutex_unlock(&media_sem);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL(media_register);
|
||||
|
||||
/**
|
||||
* media_unregister - unregister a media device
|
||||
* @media: device to unregister
|
||||
*
|
||||
* Unregister a media device that was previously
|
||||
* successfully registered with media_register(). Success
|
||||
* is indicated by a zero return, a negative errno code
|
||||
* indicates an error.
|
||||
*/
|
||||
|
||||
int media_unregister(struct media_device *media)
|
||||
{
|
||||
struct media_device *ptmp = NULL, *_ptmp = NULL;
|
||||
|
||||
if (osal_list_empty(&media->list)) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
mutex_lock(&media_sem);
|
||||
|
||||
osal_list_for_each_entry_safe(ptmp, _ptmp, &media_list, list) {
|
||||
/* if found, unregister device & driver */
|
||||
if (ptmp->minor == media->minor) {
|
||||
osal_list_del(&media->list);
|
||||
|
||||
media_driver_unregister(media->driver);
|
||||
|
||||
media->driver = NULL;
|
||||
|
||||
_media_device_unregister(media);
|
||||
|
||||
media_minors[media->minor >> 3] &= ~(1 << (media->minor & 7));
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&media_sem);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(media_unregister);
|
||||
|
||||
int media_init(void)
|
||||
{
|
||||
int ret;
|
||||
// 1
|
||||
ret = media_bus_init();
|
||||
if (ret) {
|
||||
goto err0;
|
||||
}
|
||||
|
||||
// 2
|
||||
ret = -EIO;
|
||||
|
||||
if (register_chrdev(MEDIA_DEVICE_MAJOR, "media", &media_fops)) {
|
||||
goto err1;
|
||||
}
|
||||
|
||||
printk("Module media: init ok\n");
|
||||
|
||||
return 0;
|
||||
|
||||
// 3
|
||||
err1:
|
||||
media_bus_exit();
|
||||
err0:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void media_exit(void)
|
||||
{
|
||||
// 0
|
||||
if (!osal_list_empty(&media_list)) {
|
||||
printk("!!! Module media: sub module in list\n");
|
||||
return;
|
||||
}
|
||||
|
||||
unregister_chrdev(MEDIA_DEVICE_MAJOR, "media");
|
||||
|
||||
media_bus_exit();
|
||||
|
||||
printk("!!! Module media: exit ok\n");
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef _LINUX_MEDIA_DEVICE_H_
|
||||
#define _LINUX_MEDIA_DEVICE_H_
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/major.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/devfreq.h>
|
||||
#include "osal_list.h"
|
||||
#include "osal_devfreq.h"
|
||||
|
||||
#define MEDIA_DEVICE_MAJOR 218
|
||||
#define MEDIA_DYNAMIC_MINOR 255
|
||||
|
||||
struct media_device;
|
||||
|
||||
struct media_ops {
|
||||
// pm methos
|
||||
int (*pm_prepare)(struct media_device *);
|
||||
void (*pm_complete)(struct media_device *);
|
||||
|
||||
int (*pm_suspend)(struct media_device *);
|
||||
int (*pm_resume)(struct media_device *);
|
||||
|
||||
int (*pm_freeze)(struct media_device *);
|
||||
int (*pm_thaw)(struct media_device *);
|
||||
int (*pm_poweroff)(struct media_device *);
|
||||
int (*pm_restore)(struct media_device *);
|
||||
|
||||
int (*pm_suspend_late)(struct media_device *);
|
||||
int (*pm_resume_early)(struct media_device *);
|
||||
int (*pm_freeze_late)(struct media_device *);
|
||||
int (*pm_thaw_early)(struct media_device *);
|
||||
int (*pm_poweroff_late)(struct media_device *);
|
||||
int (*pm_restore_early)(struct media_device *);
|
||||
|
||||
int (*pm_suspend_noirq)(struct media_device *);
|
||||
int (*pm_resume_noirq)(struct media_device *);
|
||||
|
||||
int (*pm_freeze_noirq)(struct media_device *);
|
||||
int (*pm_thaw_noirq)(struct media_device *);
|
||||
int (*pm_poweroff_noirq)(struct media_device *);
|
||||
int (*pm_restore_noirq)(struct media_device *);
|
||||
|
||||
/* devfreq */
|
||||
int (*devfreq_target)(struct media_device *, unsigned long *, unsigned int);
|
||||
int (*devfreq_get_dev_status)(struct media_device *, struct osal_devfreq_dev_status *);
|
||||
int (*devfreq_get_cur_freq)(struct media_device *, unsigned long *);
|
||||
void (*devfreq_exit)(struct media_device *);
|
||||
};
|
||||
|
||||
#define MEDIA_MAX_DEV_NAME_LEN 32
|
||||
|
||||
struct media_driver {
|
||||
struct device_driver driver;
|
||||
struct media_ops *ops;
|
||||
char name[1];
|
||||
};
|
||||
|
||||
#define to_media_driver(drv) \
|
||||
container_of((drv), struct media_driver, driver)
|
||||
|
||||
struct media_device {
|
||||
struct osal_list_head list;
|
||||
|
||||
char devfs_name[MEDIA_MAX_DEV_NAME_LEN];
|
||||
|
||||
unsigned int minor;
|
||||
|
||||
struct device device;
|
||||
|
||||
struct module *owner;
|
||||
|
||||
const struct file_operations *fops;
|
||||
|
||||
struct media_ops *drvops;
|
||||
|
||||
/* for internal use */
|
||||
struct media_driver *driver;
|
||||
|
||||
struct devfreq *devfreq;
|
||||
struct devfreq_dev_profile profile;
|
||||
};
|
||||
|
||||
#define to_media_device(dev) \
|
||||
container_of((dev), struct media_device, device)
|
||||
|
||||
int media_devfreq_register(struct media_device *media, osal_devfreq_para_t *devfreq_para);
|
||||
void media_devfreq_unregister(struct media_device *media);
|
||||
|
||||
int media_register(struct media_device *pdev);
|
||||
|
||||
int media_unregister(struct media_device *pdev);
|
||||
|
||||
#define MODULE_ALIAS_MEDIA(minor) \
|
||||
MODULE_ALIAS("media-char-major-" __stringify(MEDIA_DEVICE_MAJOR) "-" __stringify(minor))
|
||||
|
||||
#endif /* _LINUX_MEDIA_DEVICE_H_ */
|
||||
@@ -0,0 +1,419 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <linux/fs.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#include <linux/list.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <linux/version.h>
|
||||
#include "allocator.h"
|
||||
|
||||
#ifndef fallthrough
|
||||
#define fallthrough
|
||||
#endif
|
||||
|
||||
extern struct osal_list_head mmz_list;
|
||||
|
||||
long long max_malloc_size = 0x40000000UL;
|
||||
|
||||
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':
|
||||
fallthrough;
|
||||
case 'M':
|
||||
__value <<= 10;
|
||||
fallthrough;
|
||||
case 'k':
|
||||
fallthrough;
|
||||
case 'K':
|
||||
__value <<= 10;
|
||||
if (ep != NULL) {
|
||||
(*ep) = __end_p + 1;
|
||||
}
|
||||
fallthrough;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return __value;
|
||||
}
|
||||
|
||||
static unsigned long find_fixed_region(unsigned long *region_len,
|
||||
mmz_mmz_t *mmz,
|
||||
unsigned long size,
|
||||
unsigned long align)
|
||||
{
|
||||
unsigned long start;
|
||||
unsigned long fixed_start = 0;
|
||||
unsigned long fixed_len = -1;
|
||||
unsigned long len = 0;
|
||||
unsigned long blank_len = 0;
|
||||
mmz_mmb_t *p = NULL;
|
||||
|
||||
mmz_trace_func();
|
||||
align = mmz_grain_align(align);
|
||||
if (align == 0) {
|
||||
align = MMZ_GRAIN;
|
||||
}
|
||||
start = mmz_align2(mmz->phys_start, align);
|
||||
len = mmz_grain_align(size);
|
||||
|
||||
list_for_each_entry(p, &mmz->mmb_list, list) {
|
||||
mmz_mmb_t *next = NULL;
|
||||
mmz_trace(4, "p->phys_addr=0x%08lX p->length = %luKB \t",
|
||||
p->phys_addr, p->length / SZ_1K);
|
||||
next = list_entry(p->list.next, typeof(*p), list);
|
||||
mmz_trace(4, ",next = 0x%08lX\n\n", next->phys_addr);
|
||||
/*
|
||||
* if p is the first entry or not.
|
||||
*/
|
||||
if (list_first_entry(&mmz->mmb_list, typeof(*p), list) == p) {
|
||||
blank_len = p->phys_addr - start;
|
||||
if ((blank_len < fixed_len) && (blank_len >= len)) {
|
||||
fixed_len = blank_len;
|
||||
fixed_start = start;
|
||||
mmz_trace(4, "%d: fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
__LINE__, fixed_start, fixed_len / SZ_1K);
|
||||
}
|
||||
}
|
||||
start = mmz_align2((p->phys_addr + p->length), align);
|
||||
/*
|
||||
* if aglin is larger than mmz->nbytes, it would trigger the BUG_ON
|
||||
*/
|
||||
// BUG_ON((start < mmz->phys_start) || (start > (mmz->phys_start + mmz->nbytes)));
|
||||
/*
|
||||
* if we have to alloc after the last node.
|
||||
*/
|
||||
if (osal_list_is_last(&p->list, &mmz->mmb_list)) {
|
||||
blank_len = mmz->phys_start + mmz->nbytes - start;
|
||||
if ((blank_len < fixed_len) && (blank_len >= len)) {
|
||||
fixed_len = blank_len;
|
||||
fixed_start = start;
|
||||
mmz_trace(4, "fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
fixed_start, fixed_len / SZ_1K);
|
||||
break;
|
||||
} else {
|
||||
if (fixed_len != -1) {
|
||||
goto out;
|
||||
}
|
||||
fixed_start = 0;
|
||||
mmz_trace(4, "fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
fixed_start, fixed_len / SZ_1K);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
/* blank is too small */
|
||||
if ((start + len) > next->phys_addr) {
|
||||
mmz_trace(4, "start=0x%08lX ,len=%lu,next=0x%08lX\n",
|
||||
start, len, next->phys_addr);
|
||||
continue;
|
||||
}
|
||||
blank_len = next->phys_addr - start;
|
||||
if ((blank_len < fixed_len) && (blank_len >= len)) {
|
||||
fixed_len = blank_len;
|
||||
fixed_start = start;
|
||||
mmz_trace(4, "fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
fixed_start, fixed_len / SZ_1K);
|
||||
}
|
||||
}
|
||||
|
||||
if ((mmz_grain_align(start + len) <= (mmz->phys_start + mmz->nbytes)) &&
|
||||
(start >= mmz->phys_start) &&
|
||||
(start < (mmz->phys_start + mmz->nbytes))) {
|
||||
fixed_len = len;
|
||||
fixed_start = start;
|
||||
mmz_trace(4, "fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
fixed_start, fixed_len / SZ_1K);
|
||||
} else {
|
||||
fixed_start = 0;
|
||||
mmz_trace(4, "fixed_region: start=0x%08lX, len=%luKB\n",
|
||||
fixed_start, len / SZ_1K);
|
||||
}
|
||||
out:
|
||||
*region_len = len;
|
||||
return fixed_start;
|
||||
}
|
||||
|
||||
static int do_mmb_alloc(mmz_mmb_t *mmb)
|
||||
{
|
||||
mmz_mmb_t *p = NULL;
|
||||
mmz_trace_func();
|
||||
|
||||
/* add mmb sorted */
|
||||
osal_list_for_each_entry(p, &mmb->zone->mmb_list, list) {
|
||||
if (mmb->phys_addr < p->phys_addr) {
|
||||
break;
|
||||
}
|
||||
if (mmb->phys_addr == p->phys_addr) {
|
||||
printk(KERN_ERR "ERROR: media-mem allocator bad in %s! (%s, %d)",
|
||||
mmb->zone->name, __FUNCTION__, __LINE__);
|
||||
}
|
||||
}
|
||||
osal_list_add(&mmb->list, p->list.prev);
|
||||
|
||||
mmz_trace(1, MMZ_MMB_FMT_S, mmz_mmb_fmt_arg(mmb));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static mmz_mmb_t *__mmb_alloc(const char *name,
|
||||
unsigned long size,
|
||||
unsigned long align,
|
||||
unsigned long gfp,
|
||||
const char *mmz_name,
|
||||
mmz_mmz_t *_user_mmz)
|
||||
{
|
||||
mmz_mmz_t *mmz = NULL;
|
||||
mmz_mmb_t *mmb = NULL;
|
||||
|
||||
unsigned long start;
|
||||
unsigned long region_len;
|
||||
|
||||
unsigned long fixed_start = 0;
|
||||
unsigned long fixed_len = ~1;
|
||||
mmz_mmz_t *fixed_mmz = NULL;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
if ((size == 0) || (size > max_malloc_size)) {
|
||||
return NULL;
|
||||
}
|
||||
if (align == 0) {
|
||||
align = MMZ_GRAIN;
|
||||
}
|
||||
|
||||
size = mmz_grain_align(size);
|
||||
|
||||
mmz_trace(1, "size=%luKB, align=%lu", size / SZ_1K, align);
|
||||
|
||||
begin_list_for_each_mmz(mmz, gfp, mmz_name)
|
||||
|
||||
if ((_user_mmz != NULL) && (_user_mmz != mmz)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
start = find_fixed_region(®ion_len, mmz, size, align);
|
||||
if ((fixed_len > region_len) && (start != 0)) {
|
||||
fixed_len = region_len;
|
||||
fixed_start = start;
|
||||
fixed_mmz = mmz;
|
||||
}
|
||||
end_list_for_each_mmz()
|
||||
|
||||
if (fixed_mmz == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mmb = kmalloc(sizeof(mmz_mmb_t), GFP_KERNEL);
|
||||
if (mmb == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset(mmb, 0, sizeof(mmz_mmb_t));
|
||||
mmb->zone = fixed_mmz;
|
||||
mmb->phys_addr = fixed_start;
|
||||
mmb->length = size;
|
||||
if (name != NULL) {
|
||||
strlcpy(mmb->name, name, MMZ_MMB_NAME_LEN);
|
||||
} else {
|
||||
strncpy(mmb->name, "<null>", MMZ_MMB_NAME_LEN);
|
||||
}
|
||||
|
||||
if (do_mmb_alloc(mmb)) {
|
||||
kfree(mmb);
|
||||
mmb = NULL;
|
||||
}
|
||||
|
||||
return mmb;
|
||||
}
|
||||
|
||||
static void *__mmb_map2kern(mmz_mmb_t *mmb, int cached)
|
||||
{
|
||||
/*
|
||||
* already mapped? no need to remap again,
|
||||
* just return mmb's kernel virtual address.
|
||||
*/
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN) {
|
||||
if ((!!cached * MMZ_MMB_MAP2KERN_CACHED) != (mmb->flags & MMZ_MMB_MAP2KERN_CACHED)) {
|
||||
printk(KERN_ERR "mmb<%s> has been kernel-mapped as %s, \
|
||||
can not be re-mapped as %s.",
|
||||
mmb->name,
|
||||
(mmb->flags & MMZ_MMB_MAP2KERN_CACHED) ? "cached" : "non-cached",
|
||||
(cached) ? "cached" : "non-cached");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mmb->map_ref++;
|
||||
|
||||
return mmb->kvirt;
|
||||
}
|
||||
|
||||
if (cached) {
|
||||
mmb->flags |= MMZ_MMB_MAP2KERN_CACHED;
|
||||
mmb->kvirt = ioremap_cache(mmb->phys_addr, mmb->length);
|
||||
} else {
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN_CACHED;
|
||||
/* ioremap_wc has better performance */
|
||||
mmb->kvirt = ioremap_wc(mmb->phys_addr, mmb->length);
|
||||
}
|
||||
|
||||
if (mmb->kvirt) {
|
||||
mmb->flags |= MMZ_MMB_MAP2KERN;
|
||||
mmb->map_ref++;
|
||||
} else {
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN_CACHED;
|
||||
}
|
||||
|
||||
return mmb->kvirt;
|
||||
}
|
||||
|
||||
static void __mmb_free(mmz_mmb_t *mmb)
|
||||
{
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN_CACHED) {
|
||||
#ifdef CONFIG_64BIT
|
||||
__flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
#else
|
||||
__cpuc_flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
outer_flush_range(mmb->phys_addr, mmb->phys_addr + mmb->length);
|
||||
#endif
|
||||
}
|
||||
|
||||
osal_list_del(&mmb->list);
|
||||
kfree(mmb);
|
||||
}
|
||||
|
||||
static int __mmb_unmap(mmz_mmb_t *mmb)
|
||||
{
|
||||
int ref;
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN_CACHED) {
|
||||
#ifdef CONFIG_64BIT
|
||||
__flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
#else
|
||||
__cpuc_flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
outer_flush_range(mmb->phys_addr, mmb->phys_addr + mmb->length);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN) {
|
||||
ref = --mmb->map_ref;
|
||||
if (mmb->map_ref != 0) {
|
||||
return ref;
|
||||
}
|
||||
iounmap(mmb->kvirt);
|
||||
}
|
||||
|
||||
mmb->kvirt = NULL;
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN;
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN_CACHED;
|
||||
|
||||
if ((mmb->flags & MMZ_MMB_RELEASED) && (mmb->phy_ref == 0)) {
|
||||
__mmb_free(mmb);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void *__mmf_map(phys_addr_t phys, int len, int cache)
|
||||
{
|
||||
void *virt = NULL;
|
||||
if (cache) {
|
||||
virt = ioremap_cache(phys, len);
|
||||
} else {
|
||||
virt = ioremap_wc(phys, len);
|
||||
}
|
||||
|
||||
return virt;
|
||||
}
|
||||
|
||||
static void __mmf_unmap(void *virt)
|
||||
{
|
||||
if (virt != NULL) {
|
||||
iounmap(virt);
|
||||
}
|
||||
}
|
||||
|
||||
static int __allocator_init(char *s)
|
||||
{
|
||||
mmz_mmz_t *zone = NULL;
|
||||
char *line = NULL;
|
||||
unsigned long phys_end = 0;
|
||||
|
||||
while ((line = strsep(&s, ":")) != NULL) {
|
||||
int i;
|
||||
char *argv[6];
|
||||
|
||||
for (i = 0; (argv[i] = strsep(&line, ",")) != NULL;)
|
||||
if (++i == ARRAY_SIZE(argv)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (i == 4) {
|
||||
zone = mmz_mmz_create("null", 0, 0, 0);
|
||||
if (zone == NULL) {
|
||||
continue;
|
||||
}
|
||||
strlcpy(zone->name, argv[0], MMZ_MMZ_NAME_LEN);
|
||||
zone->gfp = _strtoul_ex(argv[1], NULL, 0);
|
||||
zone->phys_start = _strtoul_ex(argv[2], NULL, 0);
|
||||
zone->nbytes = _strtoul_ex(argv[3], NULL, 0);
|
||||
if (zone->nbytes > max_malloc_size) {
|
||||
max_malloc_size = zone->nbytes;
|
||||
}
|
||||
} else {
|
||||
printk(KERN_ERR "error parameters\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// mmz_info_phys_start = zone->phys_start + zone->nbytes - 0x2000;
|
||||
|
||||
if (mmz_mmz_register(zone)) {
|
||||
printk(KERN_WARNING "Add MMZ failed: " MMZ_MMZ_FMT_S "\n", mmz_mmz_fmt_arg(zone));
|
||||
mmz_mmz_destroy(zone);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// if phys_end is 0xFFFFFFFF (32bit)
|
||||
phys_end = (zone->phys_start + zone->nbytes);
|
||||
|
||||
if ((phys_end == 0) && (zone->nbytes >= PAGE_SIZE)) {
|
||||
// reserve last PAGE_SIZE memory
|
||||
zone->nbytes = zone->nbytes - PAGE_SIZE;
|
||||
}
|
||||
|
||||
// if phys_end exceed 0xFFFFFFFF (32bit), wraping error
|
||||
if ((zone->phys_start > phys_end) && (phys_end != 0)) {
|
||||
printk(KERN_ERR "MMZ: parameter is not correct! Address exceeds 0xFFFFFFFF\n");
|
||||
mmz_mmz_unregister(zone);
|
||||
mmz_mmz_destroy(zone);
|
||||
return -1;
|
||||
}
|
||||
zone = NULL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int allocator_setopt(struct mmz_allocator *allocator)
|
||||
{
|
||||
allocator->init = __allocator_init;
|
||||
allocator->mmb_alloc = __mmb_alloc;
|
||||
allocator->mmb_map2kern = __mmb_map2kern;
|
||||
allocator->mmb_unmap = __mmb_unmap;
|
||||
allocator->mmb_free = __mmb_free;
|
||||
allocator->mmf_map = __mmf_map;
|
||||
allocator->mmf_unmap = __mmf_unmap;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __ALLOCATOR_H__
|
||||
#define __ALLOCATOR_H__
|
||||
|
||||
#include <linux/device.h>
|
||||
#include "osal_mmz.h"
|
||||
|
||||
#define NAME_LEN_MAX 64
|
||||
|
||||
struct mmz_allocator {
|
||||
int (*init)(char *args);
|
||||
mmz_mmb_t *(*mmb_alloc)(const char *name,
|
||||
unsigned long size,
|
||||
unsigned long align,
|
||||
unsigned long gfp,
|
||||
const char *mmz_name,
|
||||
mmz_mmz_t *_user_mmz);
|
||||
void *(*mmb_map2kern)(mmz_mmb_t *mmb, int cached);
|
||||
int (*mmb_unmap)(mmz_mmb_t *mmb);
|
||||
void (*mmb_free)(mmz_mmb_t *mmb);
|
||||
void *(*mmf_map)(phys_addr_t phys, int len, int cache);
|
||||
void (*mmf_unmap)(void *virt);
|
||||
};
|
||||
|
||||
int cma_allocator_setopt(struct mmz_allocator *allocator);
|
||||
int allocator_setopt(struct mmz_allocator *allocator);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,459 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/fs.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#include <linux/list.h>
|
||||
#include <asm/cacheflush.h>
|
||||
|
||||
#include <asm/memory.h>
|
||||
#include <linux/dma-contiguous.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <asm/memory.h>
|
||||
#include <asm/tlbflush.h>
|
||||
#include <asm/pgtable.h>
|
||||
#include <linux/vmalloc.h>
|
||||
|
||||
#include "allocator.h"
|
||||
#include "mmz_arm.h"
|
||||
|
||||
#define __use_vmalloc_space 1
|
||||
|
||||
struct cma_zone {
|
||||
struct device pdev;
|
||||
char name[NAME_LEN_MAX];
|
||||
unsigned long gfp;
|
||||
unsigned long phys_start;
|
||||
unsigned long nbytes;
|
||||
unsigned int alloc_type;
|
||||
unsigned long block_align;
|
||||
};
|
||||
|
||||
extern struct osal_list_head mmz_list;
|
||||
|
||||
long long max_malloc_size = 0x40000000UL;
|
||||
|
||||
static int do_mmb_alloc(mmz_mmb_t *mmb)
|
||||
{
|
||||
mmz_mmb_t *p = NULL;
|
||||
mmz_trace_func();
|
||||
|
||||
/* add mmb into zone, sorted */
|
||||
osal_list_for_each_entry(p, &mmb->zone->mmb_list, list) {
|
||||
if (mmb->phys_addr < p->phys_addr) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (mmb->phys_addr == p->phys_addr) {
|
||||
pr_err("ERROR:cma allocator bad in %s(%s, %d)",
|
||||
mmb->zone->name, __func__, __LINE__);
|
||||
return -EFAULT;
|
||||
}
|
||||
}
|
||||
|
||||
osal_list_add(&mmb->list, p->list.prev);
|
||||
mmz_trace(1, MMZ_MMB_FMT_S, mmz_mmb_fmt_arg(mmb));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static mmz_mmb_t *__mmb_alloc(const char *name,
|
||||
unsigned long size,
|
||||
unsigned long align,
|
||||
unsigned long gfp,
|
||||
const char *mmz_name,
|
||||
mmz_mmz_t *_user_mmz)
|
||||
{
|
||||
mmz_mmz_t *mmz = NULL;
|
||||
mmz_mmb_t *mmb = NULL;
|
||||
unsigned long order = get_order(size);
|
||||
size_t count = size >> PAGE_SHIFT;
|
||||
struct page *page = NULL;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
/*
|
||||
* No zero length memory request, no supper
|
||||
* large memory (4GB and above) request.
|
||||
*/
|
||||
if ((size == 0) || (size > max_malloc_size)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (align == 0) {
|
||||
align = MMZ_GRAIN;
|
||||
}
|
||||
|
||||
size = mmz_grain_align(size);
|
||||
order = get_order(size);
|
||||
count = size >> PAGE_SHIFT;
|
||||
|
||||
mmz_trace(1, "anonymous=%s,size=%luKB,align=%lu", mmz_name, size / SZ_1K, align);
|
||||
|
||||
begin_list_for_each_mmz(mmz, gfp, mmz_name)
|
||||
|
||||
if ((_user_mmz != NULL) && (_user_mmz != mmz)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
page = dma_alloc_from_contiguous(mmz->cma_dev, count, order);
|
||||
if (page == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Get it */
|
||||
break;
|
||||
end_list_for_each_mmz()
|
||||
|
||||
if (page == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* clear the allocated buffer, if needed! */
|
||||
dma_buffer_clear(page, size);
|
||||
|
||||
mmb = kmalloc(sizeof(mmz_mmb_t), GFP_KERNEL);
|
||||
if (mmb == NULL) {
|
||||
pr_err("<%s,%d> mmb struct alloc failed\n", __func__, __LINE__);
|
||||
goto cma_free;
|
||||
}
|
||||
|
||||
memset(mmb, 0, sizeof(mmz_mmb_t));
|
||||
mmb->zone = mmz;
|
||||
mmb->phys_addr = page_to_phys(page);
|
||||
mmb->length = size;
|
||||
|
||||
if (name != NULL) {
|
||||
strlcpy(mmb->name, name, MMZ_MMB_NAME_LEN);
|
||||
} else {
|
||||
strncpy(mmb->name, "<null>", MMZ_MMB_NAME_LEN - 1);
|
||||
}
|
||||
|
||||
if (do_mmb_alloc(mmb)) {
|
||||
goto mmb_free;
|
||||
}
|
||||
|
||||
return mmb;
|
||||
|
||||
mmb_free:
|
||||
kfree(mmb);
|
||||
cma_free:
|
||||
dma_release_from_contiguous(mmz->cma_dev, page, count);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void __mmb_free(mmz_mmb_t *mmb)
|
||||
{
|
||||
size_t count = mmb->length >> PAGE_SHIFT;
|
||||
struct page *page = phys_to_page(mmb->phys_addr);
|
||||
|
||||
mmz_mmz_t *mmz = mmb->zone;
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN_CACHED) {
|
||||
mmb_dcache_flush(mmb);
|
||||
}
|
||||
|
||||
dma_release_from_contiguous(mmz->cma_dev, page, count);
|
||||
|
||||
osal_list_del(&mmb->list);
|
||||
kfree(mmb);
|
||||
}
|
||||
|
||||
static void *__mmb_map2kern(mmz_mmb_t *mmb, int cached)
|
||||
{
|
||||
pgprot_t prot;
|
||||
struct page *page = phys_to_page(mmb->phys_addr);
|
||||
|
||||
mmz_trace(1, "mmb[phys_addr=%lx,kvirt=%pK,length=%lx]",
|
||||
mmb->phys_addr, mmb->kvirt, mmb->length);
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN) {
|
||||
if ((!!cached * MMZ_MMB_MAP2KERN_CACHED) != (mmb->flags & MMZ_MMB_MAP2KERN_CACHED)) {
|
||||
pr_err("mmb<%s> has been kernel-mapped %s, \
|
||||
can not be re-mapped as %s.",
|
||||
mmb->name,
|
||||
(mmb->flags & MMZ_MMB_MAP2KERN_CACHED) ? "cached" : "non-cached",
|
||||
(cached) ? "cached" : "non-cached");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mmz_trace(1, "map[%lx --> %pK]", mmb->phys_addr, mmb->kvirt);
|
||||
|
||||
mmb->map_ref++;
|
||||
return mmb->kvirt;
|
||||
}
|
||||
|
||||
prot = arch_kern_pgprot(cached);
|
||||
|
||||
#if __use_vmalloc_space
|
||||
/*
|
||||
* Map into vmalloc space
|
||||
*/
|
||||
{
|
||||
int i;
|
||||
struct page **pages = NULL;
|
||||
unsigned int pagesnr = mmb->length / PAGE_SIZE;
|
||||
struct page *tmp = page;
|
||||
int array_size = sizeof(struct page *) * pagesnr;
|
||||
|
||||
/*
|
||||
* Noted: mmb->length would be very large in some cases(for example:
|
||||
* more than one Giga Bytes). and array_size would be very large as
|
||||
* well. So, don't use kmalloc here.
|
||||
*/
|
||||
pages = vmalloc(array_size);
|
||||
if (pages == NULL) {
|
||||
pr_err("ptr array(0x%x) vmalloc failed.\n", array_size);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < pagesnr; i++) {
|
||||
*(pages + i) = tmp;
|
||||
tmp++;
|
||||
}
|
||||
|
||||
mmb->kvirt = vmap(pages, pagesnr, VM_MAP, prot);
|
||||
vfree(pages);
|
||||
}
|
||||
#else
|
||||
/*
|
||||
* Map into linear space
|
||||
*/
|
||||
{
|
||||
dma_pages_remap(page, mmb->length, prot);
|
||||
mmb->kvirt = __va(mmb->phys_addr);
|
||||
}
|
||||
#endif
|
||||
if (mmb->kvirt == NULL) {
|
||||
/*
|
||||
* you should never get here.
|
||||
*/
|
||||
printk(KERN_ERR "mmb[0x%lx, 0x%lx] map to kernel failed\n",
|
||||
mmb->phys_addr, mmb->length);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (cached) {
|
||||
mmb->flags |= MMZ_MMB_MAP2KERN_CACHED;
|
||||
} else {
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN_CACHED;
|
||||
}
|
||||
mmb->flags |= MMZ_MMB_MAP2KERN;
|
||||
mmb->map_ref++;
|
||||
|
||||
mmz_trace(1, "map[%lx --> %pK]", mmb->phys_addr, mmb->kvirt);
|
||||
|
||||
return mmb->kvirt;
|
||||
}
|
||||
|
||||
static int __mmb_unmap(mmz_mmb_t *mmb)
|
||||
{
|
||||
int ref;
|
||||
|
||||
mmz_trace(1, "mmb[phys_addr=%lx,kvirt=%pK,length=%lx]",
|
||||
mmb->phys_addr, mmb->kvirt, mmb->length);
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN_CACHED) {
|
||||
mmb_dcache_flush(mmb);
|
||||
}
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN) {
|
||||
ref = --mmb->map_ref;
|
||||
if (mmb->map_ref != 0) {
|
||||
return ref;
|
||||
}
|
||||
}
|
||||
|
||||
#if __use_vmalloc_space
|
||||
/*
|
||||
* unmap from vmalloc space.
|
||||
*/
|
||||
{
|
||||
vunmap(mmb->kvirt);
|
||||
}
|
||||
#endif
|
||||
mmb->kvirt = NULL;
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN;
|
||||
mmb->flags &= ~MMZ_MMB_MAP2KERN_CACHED;
|
||||
|
||||
if ((mmb->flags & MMZ_MMB_RELEASED) && (mmb->phy_ref == 0)) {
|
||||
__mmb_free(mmb);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Map any valid phys address passed by users, to virtual address.
|
||||
* The input phys may not be 4Kbytes aligned.
|
||||
* FIXME
|
||||
*/
|
||||
static void *__mmf_map(phys_addr_t phys, int len, int cache)
|
||||
{
|
||||
struct page **pages = NULL;
|
||||
unsigned int pagesnr = len / PAGE_SIZE;
|
||||
int i;
|
||||
void *virt = NULL;
|
||||
pgprot_t prot;
|
||||
struct page *page = phys_to_page(phys);
|
||||
struct page *tmp = page;
|
||||
int array_size;
|
||||
|
||||
mmz_trace(1, "phys=%lx, len=0x%x, cache=%d", (unsigned long)phys, len, cache);
|
||||
|
||||
/*
|
||||
* if the given phys is not page aligned, we need to
|
||||
* map one more page for the leftover.
|
||||
*/
|
||||
if (((phys & 0xfff) + len) > PAGE_SIZE) {
|
||||
pagesnr += 1;
|
||||
}
|
||||
|
||||
array_size = sizeof(struct page *) * pagesnr;
|
||||
|
||||
prot = arch_kern_pgprot(cache);
|
||||
|
||||
#if __use_vmalloc_space
|
||||
/*
|
||||
* Map into vmalloc space.
|
||||
*/
|
||||
{
|
||||
/*
|
||||
* Noted: length of region may be very large in some cases(for example:
|
||||
* more than one Giga Bytes). and array_size would be very large as
|
||||
* well. So, don't use kmalloc here.
|
||||
*/
|
||||
pages = vmalloc(array_size);
|
||||
if (pages == NULL) {
|
||||
printk(KERN_ERR "ptr vmalloc %d failed.\n", array_size);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < pagesnr; i++) {
|
||||
*(pages + i) = tmp;
|
||||
tmp++;
|
||||
}
|
||||
|
||||
virt = vmap(pages, pagesnr, VM_MAP, prot);
|
||||
vfree(pages);
|
||||
|
||||
if (virt == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
virt += (phys & 0xfff);
|
||||
}
|
||||
#else
|
||||
/*
|
||||
* Map into linear space
|
||||
*/
|
||||
{
|
||||
dma_pages_remap(page, len, prot);
|
||||
virt = __va(phys);
|
||||
}
|
||||
#endif
|
||||
|
||||
mmz_trace(1, "map[%lx --> %pK]", (unsigned long)phys, virt);
|
||||
|
||||
return virt;
|
||||
}
|
||||
|
||||
static void __mmf_unmap(void *virt)
|
||||
{
|
||||
unsigned long vaddr = (unsigned long)(uintptr_t)virt;
|
||||
|
||||
mmz_trace(1, "virt=%pK", virt);
|
||||
|
||||
/*
|
||||
* virtual address to be vunmaped should be page aligned
|
||||
*/
|
||||
vaddr &= 0xfffff000;
|
||||
|
||||
if ((vaddr >= VMALLOC_START) && (vaddr < VMALLOC_END)) {
|
||||
vunmap ((void *)(uintptr_t)vaddr);
|
||||
}
|
||||
}
|
||||
|
||||
static int __allocator_init(char *s)
|
||||
{
|
||||
#ifdef CONFIG_CMA
|
||||
mmz_mmz_t *zone = NULL;
|
||||
char *line = NULL;
|
||||
struct cma_zone *cma_zone = NULL;
|
||||
|
||||
while ((line = strsep(&s, ":")) != NULL) {
|
||||
int i;
|
||||
char *argv[6];
|
||||
extern struct cma_zone *get_cma_zone(const char *name);
|
||||
/*
|
||||
* FIXME: We got 4 args in "line", formated as
|
||||
* "argv[0],argv[1],argv[2],argv[3],argv[4]".
|
||||
* eg: "<mmz_name>,<gfp>,<phys_start>,<size>,<alloc_type>"
|
||||
* For more convenient, "hard code" are used such as "arg[0]", i.e.
|
||||
*/
|
||||
for (i = 0; (argv[i] = strsep(&line, ",")) != NULL;)
|
||||
if (++i == ARRAY_SIZE(argv)) {
|
||||
break;
|
||||
}
|
||||
|
||||
cma_zone = get_cma_zone(argv[0]);
|
||||
if (cma_zone == NULL) {
|
||||
printk(KERN_ERR "can't get cma zone info:%s\n", argv[0]);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i == 4) {
|
||||
zone = mmz_mmz_create("null", 0, 0, 0);
|
||||
if (zone == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
strlcpy(zone->name, argv[0], MMZ_MMZ_NAME_LEN);
|
||||
|
||||
printk("cmz zone gfp 0x%lx, phys 0x%lx, nbytes 0x%lx\n",
|
||||
cma_zone->gfp,
|
||||
cma_zone->phys_start,
|
||||
cma_zone->nbytes);
|
||||
zone->gfp = cma_zone->gfp;
|
||||
zone->phys_start = cma_zone->phys_start;
|
||||
zone->nbytes = cma_zone->nbytes;
|
||||
zone->cma_dev = &cma_zone->pdev;
|
||||
|
||||
if (zone->nbytes > max_malloc_size) {
|
||||
max_malloc_size = zone->nbytes;
|
||||
}
|
||||
} else {
|
||||
printk(KERN_ERR "Input parameter num incorrect!\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
if (mmz_mmz_register(zone)) {
|
||||
printk(KERN_WARNING "Add MMZ failed: " MMZ_MMZ_FMT_S "\n",
|
||||
mmz_mmz_fmt_arg(zone));
|
||||
mmz_mmz_destroy(zone);
|
||||
}
|
||||
|
||||
zone = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cma_allocator_setopt(struct mmz_allocator *allocator)
|
||||
{
|
||||
allocator->init = __allocator_init;
|
||||
allocator->mmb_alloc = __mmb_alloc;
|
||||
allocator->mmb_map2kern = __mmb_map2kern;
|
||||
allocator->mmb_unmap = __mmb_unmap;
|
||||
allocator->mmb_free = __mmb_free;
|
||||
allocator->mmf_map = __mmf_map;
|
||||
allocator->mmf_unmap = __mmf_unmap;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,104 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/semaphore.h>
|
||||
#include <linux/slab.h>
|
||||
#include "osal.h"
|
||||
#include "osal_mmz.h"
|
||||
#define MMZ_NAME "anonymous"
|
||||
|
||||
unsigned long long mmz_alloc(const char *mmz_name, const char *buf_name, unsigned long size)
|
||||
{
|
||||
mmz_mmb_t *pmmb = NULL;
|
||||
|
||||
pmmb = mmz_mmb_alloc(buf_name, size, 0, 0, mmz_name);
|
||||
if (pmmb == NULL) {
|
||||
osal_printk("Mmz malloc failed!\n");
|
||||
return 0UL;
|
||||
}
|
||||
|
||||
return mmz_mmb_phys(pmmb);
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_alloc);
|
||||
|
||||
void mmz_free(unsigned long long phy_addr)
|
||||
{
|
||||
mmz_mmb_freeby_phys(phy_addr);
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_free);
|
||||
|
||||
void *mmz_map(unsigned long long phy_addr, unsigned long size, bool cached)
|
||||
{
|
||||
mmz_mmb_t *pmmb = NULL;
|
||||
void *vir_addr = NULL;
|
||||
unsigned long offset;
|
||||
|
||||
pmmb = mmz_mmb_getby_phys_2(phy_addr, &offset);
|
||||
if ( pmmb == NULL ) {
|
||||
osal_printk("mmz remap cache get mmz_mmb failed\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (size == 0 || size + offset > pmmb->length) {
|
||||
osal_printk("mmz remap size(0x%lx) is zero or bigger than mmb size(0x%lx)", size, pmmb->length);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ( cached == 1 ) {
|
||||
vir_addr = mmz_mmb_map2kern_cached(pmmb);
|
||||
} else {
|
||||
vir_addr = mmz_mmb_map2kern(pmmb);
|
||||
}
|
||||
if (vir_addr == NULL) {
|
||||
osal_printk("mmz remap failed!\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return vir_addr + offset;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_map);
|
||||
|
||||
void mmz_unmap(void *vir_addr)
|
||||
{
|
||||
if (vir_addr != NULL) {
|
||||
mmz_mmb_t *pmmb = mmz_mmb_getby_kvirt(vir_addr);
|
||||
|
||||
if (pmmb != NULL) {
|
||||
mmz_mmb_unmap(pmmb);
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_unmap);
|
||||
|
||||
int mmz_check_phyaddr(unsigned long long phy_addr, unsigned long len)
|
||||
{
|
||||
/* if address in mmz of current system */
|
||||
if (mmz_is_phys_in_mmz(phy_addr, len))
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_check_phyaddr);
|
||||
|
||||
int mmz_flush_cache(unsigned long phy_addr, void *kvirt, unsigned long length)
|
||||
{
|
||||
mmz_mmb_t *pmmb = NULL;
|
||||
unsigned long offset;
|
||||
|
||||
/*err address flush maybe panic so judge input parameter*/
|
||||
pmmb = mmz_mmb_getby_phys_2(phy_addr, &offset);
|
||||
if ( pmmb == NULL ) {
|
||||
osal_printk("mmz flush cache get mmz_mmb failed\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ( mmz_mmb_flush_dcache_byaddr(kvirt, phy_addr, length) != 0 )
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_flush_cache);
|
||||
+956
@@ -0,0 +1,956 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#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 "osal.h"
|
||||
#include "allocator.h"
|
||||
#include "version.h"
|
||||
#include <linux/lotus/kapi.h>
|
||||
|
||||
|
||||
OSAL_LIST_HEAD(mmz_list);
|
||||
|
||||
static DEFINE_SEMAPHORE(mmz_lock);
|
||||
|
||||
#define MMZ_SETUP_CMDLINE_LEN 256
|
||||
#define MMZ_ALLOCATOR_NAME_LEN 32
|
||||
#define MMZ_DEFAULT_ALLOCATOR "xmedia"
|
||||
#ifndef MODULE
|
||||
|
||||
static char setup_zones[MMZ_SETUP_CMDLINE_LEN] = {'\0'};
|
||||
static int __init parse_kern_mmz(char *line)
|
||||
{
|
||||
strlcpy(setup_zones, line, sizeof(setup_zones));
|
||||
|
||||
return 1;
|
||||
}
|
||||
__setup("mmz=", parse_kern_mmz);
|
||||
|
||||
static char setup_allocator[MMZ_ALLOCATOR_NAME_LEN] = MMZ_DEFAULT_ALLOCATOR;
|
||||
static int __init parse_kern_allocator(char *line)
|
||||
{
|
||||
strlcpy(setup_allocator, line, sizeof(setup_allocator));
|
||||
return 1;
|
||||
}
|
||||
__setup("mmz_allocator=", parse_kern_allocator);
|
||||
|
||||
#else
|
||||
static char setup_zones[MMZ_SETUP_CMDLINE_LEN]={'\0'};
|
||||
static char setup_allocator[MMZ_ALLOCATOR_NAME_LEN] = MMZ_DEFAULT_ALLOCATOR; //default setting
|
||||
module_param_string(mmz, setup_zones, MMZ_SETUP_CMDLINE_LEN, 0600);
|
||||
module_param_string(mmz_allocator, 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 the_allocator;
|
||||
|
||||
mmz_mmz_t *mmz_mmz_create(const char *name,
|
||||
unsigned long gfp,
|
||||
unsigned long phys_start,
|
||||
unsigned long nbytes)
|
||||
{
|
||||
mmz_mmz_t *p = NULL;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
if(name == NULL) {
|
||||
printk(KERN_ERR "%s: 'name' should not be NULL!", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
p = kmalloc(sizeof(mmz_mmz_t) + 1, GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
printk(KERN_ERR "%s: System OOM!\n", __func__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset(p, 0, sizeof(mmz_mmz_t)+1);
|
||||
strlcpy(p->name, name, MMZ_MMZ_NAME_LEN);
|
||||
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(mmz_mmz_create);
|
||||
|
||||
int mmz_mmz_destroy(mmz_mmz_t *zone)
|
||||
{
|
||||
if(zone == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(zone->destructor) {
|
||||
zone->destructor(zone);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmz_destroy);
|
||||
|
||||
static int _check_mmz(mmz_mmz_t *zone)
|
||||
{
|
||||
mmz_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)))) {
|
||||
printk(KERN_ERR "ERROR: Conflict MMZ:\n");
|
||||
printk(KERN_ERR MMZ_MMZ_FMT_S "\n", mmz_mmz_fmt_arg(zone));
|
||||
printk(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, &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 {
|
||||
;
|
||||
}
|
||||
|
||||
printk(KERN_ERR "ERROR: Conflict MMZ:\n");
|
||||
printk(KERN_ERR "MMZ new: " MMZ_MMZ_FMT_S "\n", mmz_mmz_fmt_arg(zone));
|
||||
printk(KERN_ERR "MMZ exist: " MMZ_MMZ_FMT_S "\n", mmz_mmz_fmt_arg(p));
|
||||
printk(KERN_ERR "Add new MMZ failed!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mmz_mmz_register(mmz_mmz_t *zone)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
mmz_trace(1, MMZ_MMZ_FMT_S, mmz_mmz_fmt_arg(zone));
|
||||
|
||||
if(zone == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
down(&mmz_lock);
|
||||
|
||||
if (0 == strcmp(setup_allocator, "xmedia")) {
|
||||
ret = _check_mmz(zone);
|
||||
if (ret) {
|
||||
up(&mmz_lock);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
OSAL_INIT_LIST_HEAD(&zone->mmb_list);
|
||||
|
||||
osal_list_add(&zone->list, &mmz_list);
|
||||
|
||||
up(&mmz_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mmz_mmz_unregister(mmz_mmz_t *zone)
|
||||
{
|
||||
int losts = 0;
|
||||
mmz_mmb_t *p = NULL;
|
||||
|
||||
if(zone == NULL)
|
||||
return -1;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
down(&mmz_lock);
|
||||
osal_list_for_each_entry(p, &zone->mmb_list, list) {
|
||||
printk(KERN_WARNING "MB Lost: " MMZ_MMB_FMT_S "\n",
|
||||
mmz_mmb_fmt_arg(p));
|
||||
losts++;
|
||||
}
|
||||
|
||||
if (losts) {
|
||||
printk(KERN_ERR "%d mmbs not free, mmz<%s> can not be unregistered!\n",
|
||||
losts, zone->name);
|
||||
up(&mmz_lock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
osal_list_del(&zone->list);
|
||||
up(&mmz_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
mmz_mmb_t *mmz_mmb_alloc(const char *name,
|
||||
unsigned long size,
|
||||
unsigned long align,
|
||||
unsigned long gfp,
|
||||
const char *mmz_name)
|
||||
{
|
||||
mmz_mmb_t *mmb = NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
mmb = the_allocator.mmb_alloc(name, size, align, gfp, mmz_name, NULL);
|
||||
up(&mmz_lock);
|
||||
|
||||
return mmb;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_alloc);
|
||||
|
||||
void *mmz_mmb_map2kern(mmz_mmb_t *mmb)
|
||||
{
|
||||
void *p = NULL;
|
||||
|
||||
if(mmb == NULL)
|
||||
return NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
p = the_allocator.mmb_map2kern(mmb, 0);
|
||||
up(&mmz_lock);
|
||||
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_map2kern);
|
||||
|
||||
/* mmf: media-memory fragment */
|
||||
void *mmz_mmf_map2kern_nocache(unsigned long phys, int len)
|
||||
{
|
||||
void *virt = the_allocator.mmf_map(phys, len, 0);
|
||||
if (virt != NULL)
|
||||
return virt;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmf_map2kern_nocache);
|
||||
|
||||
void *mmz_mmf_map2kern_cache(unsigned long phys, int len)
|
||||
{
|
||||
void *virt = the_allocator.mmf_map(phys, len, 1);
|
||||
if (virt != NULL)
|
||||
return virt;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmf_map2kern_cache);
|
||||
|
||||
void mmz_mmf_unmap(void *virt)
|
||||
{
|
||||
the_allocator.mmf_unmap(virt);
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmf_unmap);
|
||||
|
||||
void *mmz_mmb_map2kern_cached(mmz_mmb_t *mmb)
|
||||
{
|
||||
void *p = NULL;
|
||||
|
||||
if(mmb == NULL)
|
||||
return NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
p = the_allocator.mmb_map2kern(mmb, 1);
|
||||
up(&mmz_lock);
|
||||
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_map2kern_cached);
|
||||
|
||||
int mmz_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
|
||||
#if defined(CONFIG_CACHE_L2V200) || defined(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(mmz_mmb_flush_dcache_byaddr);
|
||||
|
||||
int mmz_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(mmz_mmb_invalid_cache_byaddr);
|
||||
|
||||
int mmz_mmb_unmap(mmz_mmb_t *mmb)
|
||||
{
|
||||
int ref;
|
||||
|
||||
if(mmb == NULL)
|
||||
return -1;
|
||||
|
||||
down(&mmz_lock);
|
||||
|
||||
ref = the_allocator.mmb_unmap(mmb);
|
||||
|
||||
up(&mmz_lock);
|
||||
|
||||
return ref;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_unmap);
|
||||
|
||||
int mmz_mmb_get(mmz_mmb_t *mmb)
|
||||
{
|
||||
int ref;
|
||||
|
||||
if(mmb == NULL)
|
||||
return -1;
|
||||
|
||||
down(&mmz_lock);
|
||||
|
||||
if(mmb->flags & MMZ_MMB_RELEASED)
|
||||
printk(KERN_WARNING "mmz_mmb_get: amazing, mmb<%s> is released!\n", mmb->name);
|
||||
ref = ++mmb->phy_ref;
|
||||
|
||||
up(&mmz_lock);
|
||||
|
||||
return ref;
|
||||
}
|
||||
|
||||
int mmz_mmb_put(mmz_mmb_t *mmb)
|
||||
{
|
||||
int ref;
|
||||
|
||||
if(mmb == NULL)
|
||||
return -1;
|
||||
|
||||
down(&mmz_lock);
|
||||
|
||||
if(mmb->flags & MMZ_MMB_RELEASED)
|
||||
printk(KERN_WARNING "mmz_mmb_put: amazing, mmb<%s> is released!\n", mmb->name);
|
||||
|
||||
ref = --mmb->phy_ref;
|
||||
|
||||
if ((mmb->flags & MMZ_MMB_RELEASED) && (mmb->phy_ref ==0) && (mmb->map_ref ==0)) {
|
||||
the_allocator.mmb_free(mmb);
|
||||
}
|
||||
|
||||
up(&mmz_lock);
|
||||
|
||||
return ref;
|
||||
}
|
||||
|
||||
int mmz_mmb_free(mmz_mmb_t *mmb)
|
||||
{
|
||||
mmz_trace_func();
|
||||
|
||||
if(mmb == NULL)
|
||||
return -1;
|
||||
|
||||
mmz_trace(1,MMZ_MMB_FMT_S,mmz_mmb_fmt_arg(mmb));
|
||||
down(&mmz_lock);
|
||||
|
||||
if(mmb->flags & MMZ_MMB_RELEASED) {
|
||||
printk(KERN_WARNING "mmz_mmb_free: amazing, mmb<%s> has been released,\
|
||||
but is still in use!\n", mmb->name);
|
||||
up(&mmz_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (mmb->phy_ref > 0) {
|
||||
printk(KERN_WARNING "mmz_mmb_free: free mmb<%s> delayed \
|
||||
for which ref-count is %d!\n",
|
||||
mmb->name, mmb->map_ref);
|
||||
mmb->flags |= MMZ_MMB_RELEASED;
|
||||
up(&mmz_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (mmb->flags & MMZ_MMB_MAP2KERN) {
|
||||
printk(KERN_WARNING "mmz_mmb_free: 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 |= MMZ_MMB_RELEASED;
|
||||
up(&mmz_lock);
|
||||
return 0;
|
||||
}
|
||||
the_allocator.mmb_free(mmb);
|
||||
up(&mmz_lock);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_free);
|
||||
|
||||
#define MACH_MMB(p, val, member) do {\
|
||||
mmz_mmz_t *__mach_mmb_zone__ = NULL; \
|
||||
(p) = NULL;\
|
||||
list_for_each_entry(__mach_mmb_zone__, &mmz_list, list) { \
|
||||
mmz_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)
|
||||
|
||||
mmz_mmb_t *mmz_mmb_getby_phys(unsigned long addr)
|
||||
{
|
||||
mmz_mmb_t *p = NULL;
|
||||
down(&mmz_lock);
|
||||
MACH_MMB(p, addr, phys_addr);
|
||||
up(&mmz_lock);
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_getby_phys);
|
||||
|
||||
unsigned long usr_virt_to_phys(unsigned long virt)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
pgd_t* pgd = NULL;
|
||||
pud_t* pud = NULL;
|
||||
#endif
|
||||
pmd_t* pmd = NULL;
|
||||
pte_t* pte = NULL;
|
||||
unsigned int cacheable = 0;
|
||||
unsigned long page_addr = 0;
|
||||
unsigned long page_offset = 0;
|
||||
unsigned long phys_addr = 0;
|
||||
|
||||
if (virt & 0x3) {
|
||||
printk("invalid virt addr 0x%08lx[not 4 bytes align]\n", virt);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (virt >= PAGE_OFFSET) {
|
||||
printk("invalid user space virt addr 0x%08lx\n", virt);
|
||||
return 0;
|
||||
}
|
||||
// in kernel 5.10 just use pmd_off is ok
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
pgd = pgd_offset(current->mm, virt);
|
||||
|
||||
if (pgd_none(*pgd)) {
|
||||
printk("printk: not mapped in pgd!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
pud = pud_offset(pgd, virt);
|
||||
|
||||
if (pud_none(*pud)) {
|
||||
printk("printk: not mapped in pud!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
pmd = pmd_offset(pud, virt);
|
||||
#else
|
||||
pmd = pmd_off(current->mm, virt);
|
||||
#endif
|
||||
if (pmd_none(*pmd)) {
|
||||
printk("printk: not mapped in pmd!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
pte = pte_offset_map(pmd, virt);
|
||||
|
||||
if (pte_none(*pte)) {
|
||||
printk("printk: not mapped in pte!\n");
|
||||
pte_unmap(pte);
|
||||
return 0;
|
||||
}
|
||||
|
||||
page_addr = (pte_val(*pte) & PHYS_MASK) & PAGE_MASK;
|
||||
page_offset = virt & ~PAGE_MASK;
|
||||
phys_addr = page_addr | page_offset;
|
||||
#ifdef CONFIG_64BIT
|
||||
if (pte_val(*pte) & (1 << 4))
|
||||
#else
|
||||
if (pte_val(*pte) & (1 << 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, Outoffset) do {\
|
||||
mmz_mmz_t *__mach_mmb_zone__ = NULL; \
|
||||
(p) = NULL;\
|
||||
list_for_each_entry(__mach_mmb_zone__, &mmz_list, list) { \
|
||||
mmz_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__; \
|
||||
Outoffset = val - __mach_mmb__->member;\
|
||||
break;\
|
||||
}\
|
||||
} \
|
||||
if (p != NULL)break;\
|
||||
} \
|
||||
}while(0)
|
||||
|
||||
|
||||
mmz_mmb_t *mmz_mmb_getby_kvirt(void *virt)
|
||||
{
|
||||
mmz_mmb_t *p = NULL;
|
||||
unsigned long Outoffset;
|
||||
|
||||
if (virt == NULL)
|
||||
return NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
MACH_MMB_2(p, virt, kvirt, Outoffset);
|
||||
up(&mmz_lock);
|
||||
|
||||
mmz_trace(1, "Outoffset %lu \n", Outoffset);
|
||||
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_getby_kvirt);
|
||||
|
||||
mmz_mmb_t *mmz_mmb_getby_phys_2(unsigned long addr, unsigned long *Outoffset)
|
||||
{
|
||||
mmz_mmb_t *p = NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
MACH_MMB_2(p, addr, phys_addr, *Outoffset);
|
||||
up(&mmz_lock);
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_getby_phys_2);
|
||||
|
||||
mmz_mmz_t *mmz_mmz_find(unsigned long gfp, const char *mmz_name)
|
||||
{
|
||||
mmz_mmz_t *p = NULL;
|
||||
|
||||
down(&mmz_lock);
|
||||
begin_list_for_each_mmz(p, gfp, mmz_name)
|
||||
up(&mmz_lock);
|
||||
return p;
|
||||
end_list_for_each_mmz()
|
||||
up(&mmz_lock);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmz_find);
|
||||
|
||||
unsigned long mmz_mmz_get_phys(const char *zone_name)
|
||||
{
|
||||
mmz_mmz_t *zone = NULL;
|
||||
|
||||
zone = mmz_mmz_find(0, zone_name);
|
||||
if (zone != NULL)
|
||||
return zone->phys_start;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmz_get_phys);
|
||||
|
||||
int mmz_map_mmz_unregister(mmz_mmz_t *zone)
|
||||
{
|
||||
int losts = 0;
|
||||
mmz_mmb_t *p = NULL;
|
||||
|
||||
if (zone == NULL)
|
||||
return -1;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
down(&mmz_lock);
|
||||
osal_list_for_each_entry(p, &zone->mmb_list, list) {
|
||||
printk(KERN_WARNING "MB Lost: " MMZ_MMB_FMT_S "\n",
|
||||
mmz_mmb_fmt_arg(p));
|
||||
losts++;
|
||||
}
|
||||
|
||||
if (losts) {
|
||||
printk(KERN_ERR "%d mmbs not free, mmz<%s> can not be unregistered!\n",
|
||||
losts, zone->name);
|
||||
up(&mmz_lock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
osal_list_del(&zone->list);
|
||||
up(&mmz_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mmz_vma_check(unsigned long vm_start, unsigned long vm_end)
|
||||
{
|
||||
struct vm_area_struct *pvma1;
|
||||
struct vm_area_struct *pvma2;
|
||||
|
||||
pvma1 = find_vma(current->mm, vm_start);
|
||||
if (pvma1 == NULL) {
|
||||
printk(KERN_ERR "ERROR: pvma1 is null\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
pvma2 = find_vma(current->mm, vm_end-1);
|
||||
if (pvma2 == NULL) {
|
||||
printk(KERN_ERR "ERROR: pvma2 is null\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pvma1 != pvma2) {
|
||||
printk(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)) {
|
||||
printk(KERN_ERR "ERROR vma flag:0x%lx\n", pvma1->vm_flags);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pvma1->vm_start > vm_start) {
|
||||
printk("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(mmz_vma_check);
|
||||
|
||||
int mmz_is_phys_in_mmz(unsigned long addr_start, unsigned long addr_len)
|
||||
{
|
||||
mmz_mmz_t *p = NULL;
|
||||
unsigned long addr_end = addr_start + addr_len;
|
||||
unsigned long temp_start, temp_end;
|
||||
|
||||
osal_list_for_each_entry(p, &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(mmz_is_phys_in_mmz);
|
||||
|
||||
|
||||
int mmz_mmb_flush_dcache_byaddr_safe(void *kvirt,
|
||||
unsigned long phys_addr,
|
||||
unsigned long length)
|
||||
{
|
||||
int ret = 0;
|
||||
struct mm_struct *mm = current->mm;
|
||||
|
||||
if (kvirt == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
down_read(&mm->mmap_sem);
|
||||
#else
|
||||
down_read(&mm->mmap_lock);
|
||||
#endif
|
||||
if (mmz_vma_check((unsigned long)(uintptr_t)kvirt, (unsigned long)(uintptr_t)kvirt+length)) {
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
up_read(&mm->mmap_sem);
|
||||
#else
|
||||
up_read(&mm->mmap_lock);
|
||||
#endif
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
ret = mmz_mmb_flush_dcache_byaddr(kvirt, phys_addr, length);
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
up_read(&mm->mmap_sem);
|
||||
#else
|
||||
up_read(&mm->mmap_lock);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(mmz_mmb_flush_dcache_byaddr_safe);
|
||||
|
||||
#define MEDIA_MEM_NAME "media-mem"
|
||||
|
||||
#ifdef CONFIG_PROC_FS
|
||||
static void mmz_proc_version(struct osal_proc_dir_entry *sfile)
|
||||
{
|
||||
unsigned char mmz_version[128] = {0};
|
||||
VERSION_FORMAT(mmz_version, "MMZ", "V1.0", "");
|
||||
osal_seq_printf(sfile, "\n%s\n\n", mmz_version);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int mmz_seq_show(struct osal_proc_dir_entry *sfile)
|
||||
{
|
||||
mmz_mmz_t *p = NULL;
|
||||
int len = 0;
|
||||
unsigned int zone_number = 0;
|
||||
unsigned int block_number = 0;
|
||||
unsigned int used_size = 0;
|
||||
unsigned int free_size = 0;
|
||||
unsigned int mmz_total_size = 0;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
mmz_proc_version(sfile);
|
||||
|
||||
down(&mmz_lock);
|
||||
list_for_each_entry(p, &mmz_list, list) {
|
||||
mmz_mmb_t *mmb = NULL;
|
||||
osal_seq_printf(sfile, "+---ZONE: " MMZ_MMZ_FMT_S "\n", mmz_mmz_fmt_arg(p));
|
||||
mmz_total_size += p->nbytes / 1024;
|
||||
++zone_number;
|
||||
|
||||
list_for_each_entry(mmb, &p->mmb_list, list) {
|
||||
osal_seq_printf(sfile, " |-MMB: " MMZ_MMB_FMT_S "\n", mmz_mmb_fmt_arg(mmb));
|
||||
used_size += mmb->length / 1024;
|
||||
++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),free=%dKB(%dMB + %dKB),"
|
||||
"zone_number=%d,block_number=%d\n",
|
||||
mmz_total_size, mmz_total_size / 1024,
|
||||
used_size, used_size / 1024, used_size % 1024,
|
||||
free_size, free_size / 1024, free_size % 1024,
|
||||
zone_number, block_number);
|
||||
}
|
||||
up(&mmz_lock);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
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) {
|
||||
printk(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);
|
||||
}
|
||||
|
||||
#else
|
||||
static int __init media_mem_proc_init(void) { return 0; }
|
||||
static void __exit media_mem_proc_exit(void) { }
|
||||
|
||||
#endif /* CONFIG_PROC_FS */
|
||||
|
||||
static void mmz_exit_check(void)
|
||||
{
|
||||
mmz_mmz_t* pmmz = NULL;
|
||||
struct osal_list_head* p = NULL, *n = NULL;
|
||||
|
||||
mmz_trace_func();
|
||||
|
||||
list_for_each_safe(p, n, &mmz_list) {
|
||||
pmmz = list_entry(p,mmz_mmz_t,list);
|
||||
printk(KERN_WARNING "MMZ force removed: " MMZ_MMZ_FMT_S "\n",
|
||||
mmz_mmz_fmt_arg(pmmz));
|
||||
mmz_mmz_unregister(pmmz);
|
||||
mmz_mmz_destroy(pmmz);
|
||||
}
|
||||
}
|
||||
|
||||
int __init media_mem_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
printk(KERN_INFO "Media Memory Zone Manager\n");
|
||||
|
||||
if (setup_zones[0] == '\0') {
|
||||
char *boot_mmz_para_start = NULL;
|
||||
char *boot_mmz_para_end = NULL;
|
||||
int mmz_para_len = 0;
|
||||
|
||||
/* get parameter from bootargs*/
|
||||
boot_mmz_para_start = lotus_get_cmd_line();
|
||||
|
||||
if (boot_mmz_para_start != NULL)
|
||||
boot_mmz_para_start = strstr(boot_mmz_para_start, "mmz_allocator=");
|
||||
|
||||
printk("mmz allocator from bootargs:%s\n", boot_mmz_para_start == NULL ? "none" : boot_mmz_para_start);
|
||||
if (boot_mmz_para_start != NULL) {
|
||||
|
||||
boot_mmz_para_start += strlen("mmz_allocator=");
|
||||
|
||||
/*find mmz parameter end*/
|
||||
boot_mmz_para_end = strchr(boot_mmz_para_start, ' ');
|
||||
|
||||
/*if this is the last bootargs, bootargs end is mmz parameter end*/
|
||||
if (boot_mmz_para_end == NULL) {
|
||||
mmz_para_len = strlen(boot_mmz_para_start);
|
||||
} else {
|
||||
mmz_para_len = boot_mmz_para_end - boot_mmz_para_start;
|
||||
}
|
||||
|
||||
mmz_para_len = ((mmz_para_len > MMZ_ALLOCATOR_NAME_LEN) ? MMZ_ALLOCATOR_NAME_LEN : mmz_para_len);
|
||||
memcpy(setup_allocator, boot_mmz_para_start, mmz_para_len);
|
||||
|
||||
boot_mmz_para_start = lotus_get_cmd_line();
|
||||
/*no need judge here*/
|
||||
boot_mmz_para_start = strstr(boot_mmz_para_start, "mmz=") + strlen("mmz=");
|
||||
|
||||
printk("mmz zone setting from bootargs:%s\n", boot_mmz_para_start);
|
||||
if (boot_mmz_para_start != NULL) {
|
||||
|
||||
/*find mmz parameter end*/
|
||||
boot_mmz_para_end = strchr(boot_mmz_para_start, ' ');
|
||||
|
||||
/*if this is the last bootargs, bootargs end is mmz parameter end*/
|
||||
if (boot_mmz_para_end == NULL) {
|
||||
mmz_para_len = strlen(boot_mmz_para_start);
|
||||
} else {
|
||||
mmz_para_len = boot_mmz_para_end - boot_mmz_para_start;
|
||||
}
|
||||
|
||||
mmz_para_len = ((mmz_para_len > MMZ_SETUP_CMDLINE_LEN) ? MMZ_SETUP_CMDLINE_LEN : mmz_para_len);
|
||||
memcpy(setup_zones, boot_mmz_para_start, mmz_para_len);
|
||||
printk("mmz cfg from bootargs allocator:%s zones:%s\n", setup_allocator, setup_zones);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (strcmp(setup_allocator, "cma") == 0) {
|
||||
#ifdef CONFIG_CMA
|
||||
ret = cma_allocator_setopt(&the_allocator);
|
||||
#else
|
||||
pr_err("cma is not enabled in kernel, please check!\n");
|
||||
return -EINVAL;
|
||||
#endif
|
||||
} else if (strcmp(setup_allocator, "xmedia") == 0) {
|
||||
ret = allocator_setopt(&the_allocator);
|
||||
} else {
|
||||
printk("The module param \"setup_allocator\" should be \"cma\" or \"xmedia\", which is \"%s\"\n",
|
||||
setup_allocator);
|
||||
mmz_exit_check();
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = the_allocator.init(setup_zones);
|
||||
if (ret != 0) {
|
||||
mmz_exit_check();
|
||||
return ret;
|
||||
}
|
||||
|
||||
media_mem_proc_init();
|
||||
mmz_userdev_init();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __exit media_mem_exit(void)
|
||||
{
|
||||
mmz_userdev_exit();
|
||||
mmz_exit_check();
|
||||
media_mem_proc_exit();
|
||||
}
|
||||
|
||||
/*
|
||||
module_init(media_mem_init);
|
||||
module_exit(media_mem_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
*/
|
||||
/*
|
||||
#ifndef MODULE
|
||||
subsys_initcall(media_mem_init);
|
||||
#endif
|
||||
*/
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __MMZ_ARCH_OPS_HEADER__
|
||||
#define __MMZ_ARCH_OPS_HEADER__
|
||||
|
||||
#if defined(CONFIG_ARM64)
|
||||
/* this function is used to change memory's property. */
|
||||
static void dma_pages_remap(struct page *page, size_t size, pgprot_t prot) {}
|
||||
|
||||
static void dma_buffer_clear(struct page *page, size_t size)
|
||||
{
|
||||
memset(page_address(page), 0, size);
|
||||
__flush_dcache_area(page_address(page), size);
|
||||
}
|
||||
|
||||
static void mmb_dcache_flush(mmz_mmb_t *mmb)
|
||||
{
|
||||
__flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
}
|
||||
|
||||
static pgprot_t arch_kern_pgprot(int cache)
|
||||
{
|
||||
if (cache) {
|
||||
return PAGE_KERNEL;
|
||||
}
|
||||
|
||||
return __pgprot(PROT_NORMAL_NC);
|
||||
}
|
||||
|
||||
#elif defined(CONFIG_ARM)
|
||||
#include <asm/highmem.h>
|
||||
#include <asm/pgtable.h>
|
||||
|
||||
extern void __dma_clear_buffer(struct page *page, size_t size);
|
||||
|
||||
static void dma_buffer_clear(struct page *page, size_t size)
|
||||
{
|
||||
__dma_clear_buffer(page, size);
|
||||
}
|
||||
|
||||
static void mmb_dcache_flush(mmz_mmb_t *mmb)
|
||||
{
|
||||
__cpuc_flush_dcache_area((void *)mmb->kvirt, (size_t)mmb->length);
|
||||
|
||||
outer_flush_range(mmb->phys_addr, mmb->phys_addr + mmb->length);
|
||||
}
|
||||
|
||||
static pgprot_t arch_kern_pgprot(int cache)
|
||||
{
|
||||
if (cache) {
|
||||
return pgprot_kernel;
|
||||
}
|
||||
|
||||
return pgprot_noncached(pgprot_kernel);
|
||||
}
|
||||
|
||||
#else
|
||||
#error no proper arch selected(CONFIG_ARM64/CONFIG_ARM)!
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
#include <mach/io.h>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
void *osal_ioremap(unsigned long phys_addr, unsigned long size)
|
||||
{
|
||||
return ioremap(phys_addr, size);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_ioremap);
|
||||
|
||||
void *osal_ioremap_nocache(unsigned long phys_addr, unsigned long size)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
return ioremap_nocache(phys_addr, size);
|
||||
#else
|
||||
return ioremap(phys_addr, size);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_ioremap_nocache);
|
||||
|
||||
void *osal_ioremap_cached(unsigned long phys_addr, unsigned long size)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
return ioremap_cached(phys_addr, size);
|
||||
#else
|
||||
return ioremap_cache(phys_addr, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
void *osal_ioremap_wc(unsigned long phys_addr, unsigned long size)
|
||||
{
|
||||
return ioremap_wc(phys_addr, size);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_ioremap_wc);
|
||||
|
||||
|
||||
EXPORT_SYMBOL(osal_ioremap_cached);
|
||||
|
||||
void osal_iounmap(void *addr)
|
||||
{
|
||||
iounmap(addr);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_iounmap);
|
||||
|
||||
unsigned long osal_copy_from_user(void *to, const void *from, unsigned long n)
|
||||
{
|
||||
return copy_from_user(to, from, n);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_copy_from_user);
|
||||
|
||||
unsigned long osal_copy_to_user(void *to, const void *from, unsigned long n)
|
||||
{
|
||||
return copy_to_user(to, from, n);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_copy_to_user);
|
||||
|
||||
int osal_access_ok(int type, const void *addr, unsigned long size)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
return access_ok(type, addr, size);
|
||||
#else
|
||||
return access_ok(addr, size);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_access_ok);
|
||||
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
int osal_atomic_init(osal_atomic_t *atomic)
|
||||
{
|
||||
atomic_t *p = NULL;
|
||||
if (atomic == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (atomic_t *)kmalloc(sizeof(atomic_t), GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
memset(p, 0, sizeof(atomic_t));
|
||||
atomic->atomic = p;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_init);
|
||||
|
||||
void osal_atomic_destory(osal_atomic_t *atomic)
|
||||
{
|
||||
if((atomic != NULL ) && (atomic->atomic != NULL)) {
|
||||
kfree(atomic->atomic);
|
||||
atomic->atomic = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_destory);
|
||||
|
||||
void osal_atomic_destroy(osal_atomic_t *atomic)
|
||||
{
|
||||
if((atomic != NULL ) && (atomic->atomic != NULL)) {
|
||||
kfree(atomic->atomic);
|
||||
atomic->atomic = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_destroy);
|
||||
|
||||
int osal_atomic_read(osal_atomic_t *atomic)
|
||||
{
|
||||
atomic_t *p = NULL;
|
||||
if (atomic == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (atomic_t *)(atomic->atomic);
|
||||
return atomic_read(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_read);
|
||||
|
||||
void osal_atomic_set(osal_atomic_t *atomic, int i)
|
||||
{
|
||||
atomic_t *p = NULL;
|
||||
p = (atomic_t *)(atomic->atomic);
|
||||
atomic_set(p, i);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_set);
|
||||
|
||||
int osal_atomic_inc_return(osal_atomic_t *atomic)
|
||||
{
|
||||
atomic_t *p = NULL;
|
||||
if (atomic == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (atomic_t *)(atomic->atomic);
|
||||
return atomic_inc_return(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_inc_return);
|
||||
|
||||
int osal_atomic_dec_return(osal_atomic_t *atomic)
|
||||
{
|
||||
atomic_t *p = NULL;
|
||||
if (atomic == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (atomic_t *)(atomic->atomic);
|
||||
return atomic_dec_return(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_atomic_dec_return);
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/barrier.h>
|
||||
|
||||
void osal_mb(void)
|
||||
{
|
||||
mb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mb);
|
||||
void osal_rmb(void)
|
||||
{
|
||||
rmb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_rmb);
|
||||
void osal_wmb(void)
|
||||
{
|
||||
wmb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wmb);
|
||||
void osal_smp_mb(void)
|
||||
{
|
||||
smp_mb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_smp_mb);
|
||||
void osal_smp_rmb(void)
|
||||
{
|
||||
smp_rmb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_smp_rmb);
|
||||
void osal_smp_wmb(void)
|
||||
{
|
||||
smp_wmb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_smp_wmb);
|
||||
void osal_isb(void)
|
||||
{
|
||||
isb();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_isb);
|
||||
void osal_dsb(void)
|
||||
{
|
||||
#ifdef CONFIG_64BIT
|
||||
dsb(sy);
|
||||
#else
|
||||
dsb();
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_dsb);
|
||||
void osal_dmb(void)
|
||||
{
|
||||
#ifdef CONFIG_64BIT
|
||||
dmb(sy);
|
||||
#else
|
||||
dmb();
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_dmb);
|
||||
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <linux/dma-direction.h>
|
||||
#include "osal_mmz.h"
|
||||
|
||||
void osal_flush_cache_all(void)
|
||||
{
|
||||
flush_cache_all();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_flush_cache_all);
|
||||
|
||||
void osal_cpuc_flush_dcache_area(void *addr, int size)
|
||||
{
|
||||
#ifdef CONFIG_64BIT
|
||||
__flush_dcache_area(addr, size);
|
||||
#else
|
||||
__cpuc_flush_dcache_area(addr, size);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_cpuc_flush_dcache_area);
|
||||
|
||||
void osal_flush_dcache_area(void *kvirt, unsigned long phys_addr, unsigned long length)
|
||||
{
|
||||
mmz_mmb_flush_dcache_byaddr(kvirt, phys_addr, length);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_flush_dcache_area);
|
||||
|
||||
int osal_flush_dcache_all(void)
|
||||
{
|
||||
#ifdef CONFIG_64BIT
|
||||
|
||||
flush_cache_all();
|
||||
|
||||
#else
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
on_each_cpu((smp_call_func_t)__cpuc_flush_kern_all, NULL, 1);
|
||||
#else
|
||||
__cpuc_flush_kern_all();
|
||||
#endif
|
||||
|
||||
outer_flush_all();
|
||||
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_flush_dcache_all);
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
|
||||
int osal_printk(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int r;
|
||||
|
||||
va_start(args, fmt);
|
||||
r = vprintk(fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return r;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_printk);
|
||||
|
||||
void osal_panic(const char *fmt, const char *fun, int line, const char *cond)
|
||||
{
|
||||
panic(fmt, fun, line, cond);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_panic);
|
||||
@@ -0,0 +1,952 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/poll.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/mm_types.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/kmod.h>
|
||||
#include <linux/devfreq.h>
|
||||
#include "media.h"
|
||||
#include "osal.h"
|
||||
#include "osal_devfreq.h"
|
||||
|
||||
#define DRVAL_DEBUG 0
|
||||
|
||||
#define GET_FILE(file) \
|
||||
do { \
|
||||
if (__get_file(file) < 0) \
|
||||
return -1; \
|
||||
} while (0)
|
||||
|
||||
#define PUT_FILE(file) \
|
||||
do { \
|
||||
if (__put_file(file) < 0) \
|
||||
return -1; \
|
||||
} while (0)
|
||||
|
||||
typedef struct osal_coat_dev {
|
||||
struct osal_dev osal_dev;
|
||||
struct media_device media_dev;
|
||||
} osal_coat_dev_t;
|
||||
|
||||
struct osal_private_data {
|
||||
struct osal_dev *dev;
|
||||
void *data;
|
||||
struct osal_poll table;
|
||||
int f_ref_cnt;
|
||||
};
|
||||
|
||||
spinlock_t f_lock;
|
||||
|
||||
void osal_device_init(void)
|
||||
{
|
||||
spin_lock_init(&f_lock);
|
||||
}
|
||||
|
||||
static int __get_file(struct file *file)
|
||||
{
|
||||
struct osal_private_data *pdata = NULL;
|
||||
|
||||
spin_lock(&f_lock);
|
||||
pdata = file->private_data;
|
||||
if (pdata == NULL) {
|
||||
spin_unlock(&f_lock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
pdata->f_ref_cnt++;
|
||||
spin_unlock(&f_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __put_file(struct file *file)
|
||||
{
|
||||
struct osal_private_data *pdata = NULL;
|
||||
|
||||
spin_lock(&f_lock);
|
||||
pdata = file->private_data;
|
||||
if (pdata == NULL) {
|
||||
spin_unlock(&f_lock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
pdata->f_ref_cnt--;
|
||||
spin_unlock(&f_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct media_device *media = NULL;
|
||||
osal_coat_dev_t *coat_dev = NULL;
|
||||
struct osal_private_data *pdata = NULL;
|
||||
|
||||
if (!capable(CAP_SYS_RAWIO) || !capable(CAP_SYS_ADMIN)) {
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
// media = getmedia(inode);
|
||||
media = (struct media_device *)file->private_data;
|
||||
if (media == NULL) {
|
||||
osal_printk("%s - get media device error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
coat_dev = osal_container_of(media, struct osal_coat_dev, media_dev);
|
||||
pdata = (struct osal_private_data *)kmalloc(sizeof(struct osal_private_data), GFP_KERNEL);
|
||||
if (pdata == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - file->private_data=%pK!\n", __FUNCTION__, pdata);
|
||||
}
|
||||
|
||||
memset(pdata, 0, sizeof(struct osal_private_data));
|
||||
|
||||
file->private_data = pdata;
|
||||
pdata->dev = &(coat_dev->osal_dev);
|
||||
if (coat_dev->osal_dev.fops->open != NULL) {
|
||||
return coat_dev->osal_dev.fops->open((void *)&(pdata->data));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t osal_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
|
||||
{
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
int ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
|
||||
if (pdata->dev->fops->read != NULL) {
|
||||
ret = pdata->dev->fops->read(buf, (int)size, (long *)offset, (void *)&(pdata->data));
|
||||
}
|
||||
|
||||
PUT_FILE(file);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t osal_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
|
||||
{
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
int ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
if (pdata->dev->fops->write != NULL) {
|
||||
ret = pdata->dev->fops->write(buf, (int)size, (long *)offset, (void *)&(pdata->data));
|
||||
}
|
||||
PUT_FILE(file);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static loff_t osal_llseek(struct file *file, loff_t offset, int whence)
|
||||
{
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
int ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - file->private_data=%pK!\n", __FUNCTION__, pdata);
|
||||
}
|
||||
|
||||
if (whence == SEEK_SET) {
|
||||
if (pdata->dev->fops->llseek != NULL) {
|
||||
ret = pdata->dev->fops->llseek((long)offset, OSAL_SEEK_SET, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (whence == SEEK_CUR) {
|
||||
if (pdata->dev->fops->llseek != NULL) {
|
||||
ret = pdata->dev->fops->llseek((long)offset, OSAL_SEEK_CUR, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (whence == SEEK_END) {
|
||||
if (pdata->dev->fops->llseek != NULL) {
|
||||
ret = pdata->dev->fops->llseek((long)offset, OSAL_SEEK_END, (void *)&(pdata->data));
|
||||
}
|
||||
}
|
||||
|
||||
PUT_FILE(file);
|
||||
return (loff_t)ret;
|
||||
}
|
||||
|
||||
static int osal_release(struct inode *inode, struct file *file)
|
||||
{
|
||||
int ret = 0;
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
|
||||
GET_FILE(file);
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - file->private_data=%pK!\n", __FUNCTION__, pdata);
|
||||
}
|
||||
|
||||
if (pdata->dev->fops->release != NULL) {
|
||||
ret = pdata->dev->fops->release((void *)&(pdata->data));
|
||||
}
|
||||
if (ret != 0) {
|
||||
PUT_FILE(file);
|
||||
osal_printk("%s - release failed!\n", __FUNCTION__);
|
||||
return ret;
|
||||
}
|
||||
|
||||
PUT_FILE(file);
|
||||
spin_lock(&f_lock);
|
||||
if (pdata->f_ref_cnt != 0) {
|
||||
osal_printk("%s - release failed!\n", __FUNCTION__);
|
||||
spin_unlock(&f_lock);
|
||||
return -1;
|
||||
}
|
||||
kfree(file->private_data);
|
||||
file->private_data = NULL;
|
||||
spin_unlock(&f_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long __osal_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
int ret = -1;
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
char *kbuf = NULL;
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - file->private_data=%pK!\n", __FUNCTION__, pdata);
|
||||
}
|
||||
|
||||
if (((_IOC_SIZE(cmd) == 0) && (_IOC_DIR(cmd) != _IOC_NONE))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((_IOC_DIR(cmd) != _IOC_NONE) && (((char *)(uintptr_t)arg) == NULL)) {
|
||||
osal_printk("%s - Input param err,it is null!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (_IOC_DIR(cmd) == _IOC_NONE) {
|
||||
if (pdata->dev->fops->unlocked_ioctl == NULL) {
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->unlocked_ioctl(cmd, arg, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == _IOC_WRITE) {
|
||||
kbuf = (char *)vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (copy_from_user(kbuf, (char *)(uintptr_t)arg, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pdata->dev->fops->unlocked_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->unlocked_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == _IOC_READ) {
|
||||
kbuf = vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
if (pdata->dev->fops->unlocked_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->unlocked_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
if (ret == 0) {
|
||||
if (copy_to_user((char *)(uintptr_t)arg, kbuf, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == (_IOC_READ + _IOC_WRITE)) {
|
||||
kbuf = vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (copy_from_user(kbuf, (char *)(uintptr_t)arg, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pdata->dev->fops->unlocked_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->unlocked_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
if (ret == 0) {
|
||||
if (copy_to_user((char *)(uintptr_t)arg, kbuf, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (kbuf != NULL) {
|
||||
vfree(kbuf);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static long osal_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
long ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
|
||||
ret = __osal_unlocked_ioctl(file, cmd, arg);
|
||||
PUT_FILE(file);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long __osal_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
int ret = -1;
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
char *kbuf = NULL;
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - file->private_data=%pK!\n", __FUNCTION__, pdata);
|
||||
}
|
||||
|
||||
if (((_IOC_SIZE(cmd) == 0) && (_IOC_DIR(cmd) != _IOC_NONE))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((_IOC_DIR(cmd) != _IOC_NONE) && (((char *)(uintptr_t)arg) == NULL)) {
|
||||
osal_printk("%s - Input param err,it is null!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (_IOC_DIR(cmd) == _IOC_NONE) {
|
||||
if (pdata->dev->fops->compat_ioctl == NULL) {
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->compat_ioctl(cmd, arg, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == _IOC_WRITE) {
|
||||
kbuf = (char *)vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (copy_from_user(kbuf, (char *)(uintptr_t)arg, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pdata->dev->fops->compat_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->compat_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == _IOC_READ) {
|
||||
kbuf = vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
if (pdata->dev->fops->compat_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->compat_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
if (ret == 0) {
|
||||
if (copy_to_user((char *)(uintptr_t)arg, kbuf, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (_IOC_DIR(cmd) == (_IOC_READ + _IOC_WRITE)) {
|
||||
kbuf = vmalloc(_IOC_SIZE(cmd));
|
||||
if (kbuf == NULL) {
|
||||
osal_printk("%s - vmalloc failed!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (copy_from_user(kbuf, (char *)(uintptr_t)arg, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (pdata->dev->fops->compat_ioctl == NULL) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
} else {
|
||||
ret = pdata->dev->fops->compat_ioctl (cmd, (unsigned long)(uintptr_t)kbuf, (void *)&(pdata->data));
|
||||
if (ret == 0) {
|
||||
if (copy_to_user((char *)(uintptr_t)arg, kbuf, _IOC_SIZE(cmd))) {
|
||||
vfree(kbuf);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (kbuf != NULL) {
|
||||
vfree(kbuf);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static long osal_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
long ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
|
||||
ret = __osal_compat_ioctl(file, cmd, arg);
|
||||
PUT_FILE(file);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static unsigned int osal_poll(struct file *file, struct poll_table_struct *table)
|
||||
{
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
struct osal_poll t;
|
||||
unsigned int ret = 0;
|
||||
|
||||
GET_FILE(file);
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - table=%pK, file=%pK!\n", __FUNCTION__, table, file);
|
||||
}
|
||||
t.poll_table = table;
|
||||
t.data = file;
|
||||
if (pdata->dev->fops->poll != NULL) {
|
||||
ret = pdata->dev->fops->poll(&t, (void *)&(pdata->data));
|
||||
}
|
||||
|
||||
PUT_FILE(file);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __osal_valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
|
||||
{
|
||||
/* check physical addr greater than the max addr supported by the system */
|
||||
if ((pfn + (size >> PAGE_SHIFT)) > (1 + ((~0UL) >> PAGE_SHIFT))) {
|
||||
osal_printk("--%s - %d--!\n", __FUNCTION__, __LINE__);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* CMA need to alloc ram region, so annotate the code as follows */
|
||||
#if 0
|
||||
/* check physical addr is ram region */
|
||||
if (pfn_valid(pfn) || pfn_valid(pfn + (size >> PAGE_SHIFT))) {
|
||||
osal_printk("--%s - %d--!\n", __FUNCTION__, __LINE__);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* It's necessary for the variable "size" to align 4k(page_size). */
|
||||
#define PAGE_SIZE_MASK 0xfffffffffffff000ULL
|
||||
if ((unsigned long)size & (~PAGE_SIZE_MASK)) {
|
||||
osal_printk("--%s - %d--!\n", __FUNCTION__, __LINE__);
|
||||
return 0;
|
||||
}
|
||||
#undef PAGE_SIZE_MASK
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int osal_mmap(struct file *file, struct vm_area_struct *vm)
|
||||
{
|
||||
struct osal_vm osal_vm;
|
||||
struct osal_private_data *pdata = file->private_data;
|
||||
osal_vm.vm = vm;
|
||||
|
||||
if (!__osal_valid_mmap_phys_addr_range(vm->vm_pgoff, vm->vm_end - vm->vm_start)) {
|
||||
osal_printk("\n%s - invalid argument size=%ld!!!\n", __FUNCTION__, vm->vm_end - vm->vm_start);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - start=%lx, end=%lx!, off=%lx\n", __FUNCTION__, vm->vm_start, vm->vm_end, vm->vm_pgoff);
|
||||
}
|
||||
if (pdata->dev->fops->mmap != NULL) {
|
||||
return pdata->dev->fops->mmap(&osal_vm, vm->vm_start, vm->vm_end, vm->vm_pgoff, (void *)&(pdata->data));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct file_operations s_osal_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = osal_open,
|
||||
.read = osal_read,
|
||||
.write = osal_write,
|
||||
.llseek = osal_llseek,
|
||||
.unlocked_ioctl = osal_unlocked_ioctl,
|
||||
.release = osal_release,
|
||||
.poll = osal_poll,
|
||||
.mmap = osal_mmap,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = osal_compat_ioctl,
|
||||
#endif
|
||||
};
|
||||
|
||||
static int osal_pm_prepare(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_prepare) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_prepare(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void osal_pm_complete(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_complete) {
|
||||
coat_dev->osal_dev.osal_pmops->pm_complete(&(coat_dev->osal_dev));
|
||||
}
|
||||
}
|
||||
|
||||
static int osal_pm_suspend(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_suspend) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_suspend(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_resume(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_resume) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_resume(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_freeze(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_freeze) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_freeze(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_thaw(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_thaw) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_thaw(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_poweroff(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_poweroff) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_poweroff(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_restore(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_restore) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_restore(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_suspend_late(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_suspend_late) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_suspend_late(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_resume_early(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_resume_early) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_resume_early(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_freeze_late(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_freeze_late) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_freeze_late(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_thaw_early(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_thaw_early) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_thaw_early(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_poweroff_late(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_poweroff_late) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_poweroff_late(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_restore_early(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_restore_early) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_restore_early(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_suspend_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_suspend_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_suspend_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_resume_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_resume_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_resume_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_freeze_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_freeze_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_freeze_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_thaw_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_thaw_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_thaw_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_poweroff_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_poweroff_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_poweroff_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_pm_restore_noirq(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_pmops && coat_dev->osal_dev.osal_pmops->pm_restore_noirq) {
|
||||
return coat_dev->osal_dev.osal_pmops->pm_restore_noirq(&(coat_dev->osal_dev));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_devfreq_target(struct media_device *media, unsigned long *freq, unsigned int flags)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_profile->target) {
|
||||
return coat_dev->osal_dev.osal_profile->target(&(coat_dev->osal_dev), freq, flags);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_devfreq_get_dev_status(struct media_device *media, struct osal_devfreq_dev_status *stat)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_profile->get_dev_status) {
|
||||
return coat_dev->osal_dev.osal_profile->get_dev_status(&(coat_dev->osal_dev), stat);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int osal_devfreq_get_cur_freq(struct media_device *media, unsigned long *freq)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
if (coat_dev->osal_dev.osal_profile->get_cur_freq) {
|
||||
return coat_dev->osal_dev.osal_profile->get_cur_freq(&(coat_dev->osal_dev), freq);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void osal_devfreq_exit(struct media_device *media)
|
||||
{
|
||||
osal_coat_dev_t *coat_dev = container_of(media, struct osal_coat_dev, media_dev);
|
||||
|
||||
if (coat_dev->osal_dev.osal_profile->exit) {
|
||||
return coat_dev->osal_dev.osal_profile->exit(&(coat_dev->osal_dev));
|
||||
}
|
||||
}
|
||||
|
||||
int osal_devfreq_register(osal_dev_t *osal_dev, struct osal_devfreq_dev_profile *osal_profile,
|
||||
const char *governor, void *data)
|
||||
{
|
||||
struct media_device *media = NULL;
|
||||
osal_devfreq_para_t devfreq_para = { 0 };
|
||||
|
||||
if ((osal_dev == NULL) || (osal_profile == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
media = &(((osal_coat_dev_t *)(osal_dev->dev))->media_dev);
|
||||
if ((governor != NULL) && (osal_strcmp(governor, "userspace") == 0)) {
|
||||
osal_printk("Not supported governor\r\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
osal_dev->osal_profile = osal_profile;
|
||||
|
||||
devfreq_para.initial_freq = osal_dev->osal_profile->initial_freq;
|
||||
devfreq_para.polling_ms = osal_dev->osal_profile->polling_ms;
|
||||
devfreq_para.freq_table = osal_dev->osal_profile->freq_table;
|
||||
devfreq_para.max_state = osal_dev->osal_profile->max_state;
|
||||
|
||||
return media_devfreq_register(media, &devfreq_para);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_devfreq_register);
|
||||
|
||||
void osal_devfreq_unregister(osal_dev_t *osal_dev)
|
||||
{
|
||||
struct media_device *media = NULL;
|
||||
|
||||
if ((osal_dev == NULL) || (osal_dev->osal_profile == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
|
||||
media = &(((osal_coat_dev_t *)(osal_dev->dev))->media_dev);
|
||||
media_devfreq_unregister(media);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_devfreq_unregister);
|
||||
|
||||
static struct media_ops s_osal_pmops = {
|
||||
.pm_prepare = osal_pm_prepare,
|
||||
.pm_complete = osal_pm_complete,
|
||||
.pm_suspend = osal_pm_suspend,
|
||||
.pm_resume = osal_pm_resume,
|
||||
.pm_freeze = osal_pm_freeze,
|
||||
.pm_thaw = osal_pm_thaw,
|
||||
.pm_poweroff = osal_pm_poweroff,
|
||||
.pm_restore = osal_pm_restore,
|
||||
.pm_suspend_late = osal_pm_suspend_late,
|
||||
.pm_resume_early = osal_pm_resume_early,
|
||||
.pm_freeze_late = osal_pm_freeze_late,
|
||||
.pm_thaw_early = osal_pm_thaw_early,
|
||||
.pm_poweroff_late = osal_pm_poweroff_late,
|
||||
.pm_restore_early = osal_pm_restore_early,
|
||||
.pm_suspend_noirq = osal_pm_suspend_noirq,
|
||||
.pm_resume_noirq = osal_pm_resume_noirq,
|
||||
.pm_freeze_noirq = osal_pm_freeze_noirq,
|
||||
.pm_thaw_noirq = osal_pm_thaw_noirq,
|
||||
.pm_poweroff_noirq = osal_pm_poweroff_noirq,
|
||||
.pm_restore_noirq = osal_pm_restore_noirq,
|
||||
|
||||
.devfreq_target = osal_devfreq_target,
|
||||
.devfreq_get_dev_status = osal_devfreq_get_dev_status,
|
||||
.devfreq_get_cur_freq = osal_devfreq_get_cur_freq,
|
||||
.devfreq_exit = osal_devfreq_exit,
|
||||
};
|
||||
|
||||
osal_dev_t *osal_createdev(const char *name)
|
||||
{
|
||||
osal_coat_dev_t *pdev = NULL;
|
||||
if (name == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
pdev = (osal_coat_dev_t *)kmalloc(sizeof(osal_coat_dev_t), GFP_KERNEL);
|
||||
if (pdev == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
memset(pdev, 0, sizeof(osal_coat_dev_t));
|
||||
osal_strncpy(pdev->osal_dev.name, name, sizeof(pdev->osal_dev.name) - 1);
|
||||
pdev->osal_dev.dev = pdev;
|
||||
return &(pdev->osal_dev);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_createdev);
|
||||
|
||||
int osal_destroydev(osal_dev_t *osal_dev)
|
||||
{
|
||||
osal_coat_dev_t *pdev = NULL;
|
||||
if (osal_dev == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
pdev = osal_dev->dev;
|
||||
if (pdev == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
kfree(pdev);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_destroydev);
|
||||
|
||||
int osal_registerdevice(osal_dev_t *osal_dev)
|
||||
{
|
||||
struct media_device *media = NULL;
|
||||
if ((osal_dev == NULL) || (osal_dev->fops == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
media = &(((osal_coat_dev_t *)(osal_dev->dev))->media_dev);
|
||||
if (osal_dev->minor != 0) {
|
||||
media->minor = osal_dev->minor;
|
||||
} else {
|
||||
media->minor = MEDIA_DYNAMIC_MINOR;
|
||||
}
|
||||
media->owner = THIS_MODULE;
|
||||
media->fops = &s_osal_fops;
|
||||
media->drvops = &s_osal_pmops;
|
||||
osal_strncpy(media->devfs_name, osal_dev->name, sizeof(media->devfs_name) - 1);
|
||||
return media_register(media);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_registerdevice);
|
||||
|
||||
void osal_deregisterdevice(osal_dev_t *pdev)
|
||||
{
|
||||
if (pdev == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
media_unregister((struct media_device *)&(((osal_coat_dev_t *)(pdev->dev))->media_dev));
|
||||
}
|
||||
EXPORT_SYMBOL(osal_deregisterdevice);
|
||||
|
||||
void osal_poll_wait(osal_poll_t *table, osal_wait_t *wait)
|
||||
{
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - call poll_wait +!, table=%pK, file=%pK\n", __FUNCTION__, table->poll_table, table->data);
|
||||
}
|
||||
|
||||
poll_wait ((struct file *)table->data, (wait_queue_head_t *)(wait->wait), table->poll_table);
|
||||
|
||||
if (DRVAL_DEBUG) {
|
||||
osal_printk("%s - call poll_wait -!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_poll_wait);
|
||||
|
||||
#if 0
|
||||
void osal_pgprot_noncached(osal_vm_t *vm) {
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
v->vm_page_prot = pgprot_noncached(v->vm_page_prot);
|
||||
}
|
||||
#else
|
||||
void osal_pgprot_noncached(osal_vm_t *vm)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
v->vm_page_prot = pgprot_writecombine(v->vm_page_prot);
|
||||
}
|
||||
|
||||
#endif
|
||||
EXPORT_SYMBOL(osal_pgprot_noncached);
|
||||
|
||||
void osal_pgprot_cached(osal_vm_t *vm)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
v->vm_page_prot = __pgprot(pgprot_val(v->vm_page_prot)
|
||||
| PTE_VALID | PTE_DIRTY | PTE_AF);
|
||||
#else
|
||||
|
||||
v->vm_page_prot = __pgprot(pgprot_val(v->vm_page_prot) | L_PTE_PRESENT
|
||||
| L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_MT_DEV_CACHED);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_pgprot_cached);
|
||||
|
||||
void osal_pgprot_writecombine(osal_vm_t *vm)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
v->vm_page_prot = pgprot_writecombine(v->vm_page_prot);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_pgprot_writecombine);
|
||||
|
||||
void osal_pgprot_stronglyordered(osal_vm_t *vm)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
v->vm_page_prot = pgprot_device(v->vm_page_prot);
|
||||
#else
|
||||
v->vm_page_prot = pgprot_stronglyordered(v->vm_page_prot);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_pgprot_stronglyordered);
|
||||
|
||||
int osal_remap_pfn_range(osal_vm_t *vm, unsigned long addr, unsigned long pfn, unsigned long size)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
if (size == 0) {
|
||||
return -EPERM;
|
||||
}
|
||||
return remap_pfn_range(v, addr, pfn, size, v->vm_page_prot);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_remap_pfn_range);
|
||||
|
||||
int osal_io_remap_pfn_range(osal_vm_t *vm, unsigned long addr, unsigned long pfn, unsigned long size)
|
||||
{
|
||||
struct vm_area_struct *v = (struct vm_area_struct *)(vm->vm);
|
||||
v->vm_flags |= VM_IO;
|
||||
if (size == 0) {
|
||||
return -EPERM;
|
||||
}
|
||||
return io_remap_pfn_range(v, addr, pfn, size, v->vm_page_prot);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_io_remap_pfn_range);
|
||||
|
||||
#ifdef CONFIG_SNAPSHOT_BOOT
|
||||
int osal_call_usermodehelper_force(char *path, char **argv, char **envp, int wait)
|
||||
{
|
||||
return call_usermodehelper_force(path, argv, envp, wait);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_call_usermodehelper_force);
|
||||
#endif
|
||||
@@ -0,0 +1,80 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/version.h>
|
||||
#include <linux/fs.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
struct file *klib_fopen(const char *filename, int flags, int mode)
|
||||
{
|
||||
struct file *filp = filp_open(filename, flags, mode);
|
||||
return (IS_ERR(filp)) ? NULL : filp;
|
||||
}
|
||||
|
||||
void klib_fclose(struct file *filp)
|
||||
{
|
||||
if (filp != NULL) {
|
||||
filp_close(filp, NULL);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
int klib_fwrite(const char *buf, int len, struct file *filp)
|
||||
{
|
||||
int writelen;
|
||||
|
||||
if (filp == NULL) {
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
writelen = __kernel_write(filp, buf, len, &filp->f_pos);
|
||||
return writelen;
|
||||
}
|
||||
|
||||
int klib_fread(char *buf, unsigned int len, struct file *filp)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0)
|
||||
mm_segment_t old_fs;
|
||||
int readlen;
|
||||
#endif
|
||||
if (filp == NULL) {
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0)
|
||||
old_fs = get_fs();
|
||||
set_fs(get_ds());
|
||||
/* The cast to a user pointer is valid due to the set_fs() */
|
||||
readlen = vfs_read(filp, (void __user *)buf, len, &filp->f_pos);
|
||||
set_fs(old_fs);
|
||||
return readlen;
|
||||
#else
|
||||
return kernel_read(filp, (void __user*)buf, len, &filp->f_pos);
|
||||
#endif
|
||||
}
|
||||
|
||||
void *osal_klib_fopen(const char *filename, int flags, int mode)
|
||||
{
|
||||
return (void *)klib_fopen(filename, flags, mode);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_klib_fopen);
|
||||
|
||||
void osal_klib_fclose(void *filp)
|
||||
{
|
||||
klib_fclose((struct file *)filp);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_klib_fclose);
|
||||
|
||||
int osal_klib_fwrite(const char *buf, int len, void *filp)
|
||||
{
|
||||
return klib_fwrite(buf, len, (struct file *)filp);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_klib_fwrite);
|
||||
|
||||
int osal_klib_fread(char *buf, unsigned int len, void *filp)
|
||||
{
|
||||
return klib_fread(buf, len, (struct file *)filp);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_klib_fread);
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include "osal.h"
|
||||
|
||||
extern void osal_proc_init(void);
|
||||
extern void osal_proc_exit(void);
|
||||
extern int media_init(void);
|
||||
extern void media_exit(void);
|
||||
extern int media_mem_init(void);
|
||||
extern void media_mem_exit(void);
|
||||
extern void osal_device_init(void);
|
||||
|
||||
static int __init osal_init(void)
|
||||
{
|
||||
osal_device_init();
|
||||
osal_proc_init();
|
||||
media_init();
|
||||
media_mem_init();
|
||||
osal_printk("osal %s init success!\n", OSAL_VERSION);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit osal_exit(void)
|
||||
{
|
||||
media_exit();
|
||||
media_mem_exit();
|
||||
osal_proc_exit();
|
||||
osal_printk("osal v1.0 exit!\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef MODULE
|
||||
|
||||
module_init(osal_init);
|
||||
module_exit(osal_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
#else
|
||||
|
||||
int __init osal_driver_init(void)
|
||||
{
|
||||
return osal_init();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/interrupt.h>
|
||||
|
||||
int osal_request_irq(unsigned int irq, osal_irq_handler_t handler, osal_irq_handler_t thread_fn, const char *name,
|
||||
void *dev)
|
||||
{
|
||||
unsigned long flags = IRQF_SHARED;
|
||||
|
||||
return request_threaded_irq(irq, (irq_handler_t)handler, (irq_handler_t)thread_fn, flags, name, dev);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_request_irq);
|
||||
void osal_free_irq(unsigned int irq, void *dev)
|
||||
{
|
||||
free_irq(irq, dev);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_free_irq);
|
||||
|
||||
int osal_in_interrupt(void)
|
||||
{
|
||||
return in_interrupt();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_in_interrupt);
|
||||
|
||||
#if 0
|
||||
#ifdef CONFIG_ARM_GIC
|
||||
|
||||
#define DIS_IRQ_CNT 2
|
||||
struct gic_sgi_handle {
|
||||
unsigned int irq;
|
||||
void (*handle)(unsigned int cpu_intrf,
|
||||
unsigned int irq_num,
|
||||
struct pt_regs *regs);
|
||||
};
|
||||
int osal_register_gic_handle(unsigned int index, unsigned int irq,
|
||||
osal_gic_handle_t handle, const char *name, void *dev)
|
||||
{
|
||||
extern struct gic_sgi_handle dis_irq_handle[DIS_IRQ_CNT];
|
||||
|
||||
|
||||
if (index >= DIS_IRQ_CNT) {
|
||||
printk("index(%d) is error.\n", index);
|
||||
return -1;
|
||||
}
|
||||
dis_irq_handle[index].irq = irq;
|
||||
dis_irq_handle[index].handle = (void (*)(unsigned int, unsigned int, struct pt_regs *))(handle);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_register_gic_handle);
|
||||
|
||||
int osal_unregister_gic_handle(unsigned int index, unsigned int irq, void *dev)
|
||||
{
|
||||
extern struct gic_sgi_handle dis_irq_handle[DIS_IRQ_CNT];
|
||||
|
||||
if (index >= DIS_IRQ_CNT) {
|
||||
printk("index(%d) is error.\n", index);
|
||||
return -1;
|
||||
}
|
||||
dis_irq_handle[index].irq = 0xF;
|
||||
dis_irq_handle[index].handle = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_unregister_gic_handle);
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,102 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
// #include <asm/div64.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <asm/neon.h>
|
||||
#include "osal.h"
|
||||
|
||||
int osal_isdigit(int c)
|
||||
{
|
||||
return isdigit(c);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_isdigit);
|
||||
|
||||
#ifdef CONFIG_KERNEL_MODE_NEON
|
||||
void osal_kernel_neon_begin(void)
|
||||
{
|
||||
kernel_neon_begin();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kernel_neon_begin);
|
||||
|
||||
void osal_kernel_neon_end(void)
|
||||
{
|
||||
kernel_neon_end();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kernel_neon_end);
|
||||
#endif
|
||||
|
||||
/* the result of u64/u32. */
|
||||
unsigned long long osal_div_u64(unsigned long long dividend, unsigned int divisor)
|
||||
{
|
||||
return div_u64(dividend, divisor);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div_u64);
|
||||
|
||||
/* the result of s64/s32. */
|
||||
long long osal_div_s64(long long dividend, int divisor)
|
||||
{
|
||||
return div_s64(dividend, divisor);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div_s64);
|
||||
|
||||
/* the result of u64/u64. */
|
||||
unsigned long long osal_div64_u64(unsigned long long dividend, unsigned long long divisor)
|
||||
{
|
||||
return div64_u64(dividend, divisor);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div64_u64);
|
||||
|
||||
/* the result of s64/s64. */
|
||||
long long osal_div64_s64(long long dividend, long long divisor)
|
||||
{
|
||||
return div64_s64(dividend, divisor);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div64_s64);
|
||||
|
||||
/* the remainder of u64/u32. */
|
||||
unsigned long long osal_div_u64_rem(unsigned long long dividend, unsigned int divisor)
|
||||
{
|
||||
unsigned int remainder;
|
||||
|
||||
div_u64_rem(dividend, divisor, &remainder);
|
||||
|
||||
return remainder;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div_u64_rem);
|
||||
|
||||
/* the remainder of s64/s32. */
|
||||
long long osal_div_s64_rem(long long dividend, int divisor)
|
||||
{
|
||||
int remainder;
|
||||
|
||||
div_s64_rem(dividend, divisor, &remainder);
|
||||
|
||||
return remainder;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div_s64_rem);
|
||||
|
||||
/* the remainder of u64/u64. */
|
||||
unsigned long long osal_div64_u64_rem(unsigned long long dividend, unsigned long long divisor)
|
||||
{
|
||||
unsigned long long remainder;
|
||||
|
||||
div64_u64_rem(dividend, divisor, &remainder);
|
||||
|
||||
return remainder;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_div64_u64_rem);
|
||||
|
||||
unsigned int osal_random(void)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
return random32();
|
||||
#else
|
||||
return get_random_int();
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_random);
|
||||
@@ -0,0 +1,86 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
int osal_mutex_init(osal_mutex_t *mutex)
|
||||
{
|
||||
struct mutex *p = NULL;
|
||||
if (mutex == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = kmalloc(sizeof(struct mutex), GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
mutex_init(p);
|
||||
mutex->mutex = p;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_init);
|
||||
|
||||
int osal_mutex_lock(osal_mutex_t *mutex)
|
||||
{
|
||||
struct mutex *p = NULL;
|
||||
if (mutex == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct mutex *)(mutex->mutex);
|
||||
mutex_lock(p);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_lock);
|
||||
|
||||
int osal_mutex_lock_interruptible(osal_mutex_t *mutex)
|
||||
{
|
||||
struct mutex *p = NULL;
|
||||
if (mutex == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct mutex *)(mutex->mutex);
|
||||
return mutex_lock_interruptible(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_lock_interruptible);
|
||||
|
||||
int osal_mutex_trylock(osal_mutex_t *mutex)
|
||||
{
|
||||
struct mutex *p = NULL;
|
||||
if (mutex == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct mutex *)(mutex->mutex);
|
||||
|
||||
return mutex_trylock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_trylock);
|
||||
|
||||
void osal_mutex_unlock(osal_mutex_t *mutex)
|
||||
{
|
||||
struct mutex *p = NULL;
|
||||
p = (struct mutex *)(mutex->mutex);
|
||||
|
||||
mutex_unlock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_unlock);
|
||||
|
||||
void osal_mutex_destroy(osal_mutex_t *mutex)
|
||||
{
|
||||
if((mutex != NULL) && (mutex->mutex != NULL)) {
|
||||
kfree((struct mutex *)(mutex->mutex));
|
||||
mutex->mutex = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mutex_destroy);
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <linux/notifier.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/reboot.h>
|
||||
#include <linux/module.h>
|
||||
#include "osal.h"
|
||||
|
||||
OSAL_LIST_HEAD(nb_list);
|
||||
|
||||
struct nb_node {
|
||||
struct osal_notifier_block *osal_nb;
|
||||
struct notifier_block *nb;
|
||||
struct osal_list_head node;
|
||||
};
|
||||
|
||||
static struct osal_notifier_block *osal_find_ob(struct notifier_block *nb)
|
||||
{
|
||||
struct osal_list_head *this = NULL;
|
||||
if (osal_list_empty(&nb_list)) {
|
||||
osal_printk("find nb failed! nb_list is empty!\n");
|
||||
return NULL;
|
||||
}
|
||||
osal_list_for_each(this, &nb_list) {
|
||||
struct nb_node *ns = osal_list_entry(this, struct nb_node, node);
|
||||
if (ns->nb == nb) {
|
||||
return ns->osal_nb;
|
||||
}
|
||||
}
|
||||
osal_printk("find ob failed!\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int osal_del_nb(struct osal_notifier_block *nb)
|
||||
{
|
||||
struct osal_list_head *this = NULL;
|
||||
struct osal_list_head *next = NULL;
|
||||
if (osal_list_empty(&nb_list)) {
|
||||
osal_printk("find nb failed! nb_list is empty!\n");
|
||||
return -1;
|
||||
}
|
||||
osal_list_for_each_safe(this, next, &nb_list) {
|
||||
struct nb_node *ns = osal_list_entry(this, struct nb_node, node);
|
||||
if (ns->osal_nb == nb) {
|
||||
osal_list_del(this);
|
||||
kfree(ns);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
osal_printk("del nb failed!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int osal_notifier(struct notifier_block *nb, unsigned long action, void *data)
|
||||
{
|
||||
struct osal_notifier_block *ob = osal_find_ob(nb);
|
||||
if ((ob != NULL) && (ob->notifier_call != NULL)) {
|
||||
return ob->notifier_call(ob, action, data);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int osal_register_reboot_notifier(struct osal_notifier_block *ob)
|
||||
{
|
||||
struct notifier_block *nb = NULL;
|
||||
struct nb_node *node = NULL;
|
||||
|
||||
nb = kmalloc(sizeof(struct notifier_block), GFP_KERNEL);
|
||||
if (nb == NULL) {
|
||||
osal_printk("osal_register_reboot_notifier malloc nb failed!\n");
|
||||
return -1;
|
||||
}
|
||||
memset(nb, 0, sizeof(struct notifier_block));
|
||||
|
||||
node = kmalloc(sizeof(struct nb_node), GFP_KERNEL);
|
||||
if (node == NULL) {
|
||||
osal_printk("osal_register_reboot_notifier kmalloc nb_node failed!\n");
|
||||
kfree(nb);
|
||||
return -1;
|
||||
}
|
||||
memset(node, 0, sizeof(struct nb_node));
|
||||
|
||||
nb->notifier_call = osal_notifier;
|
||||
register_reboot_notifier(nb);
|
||||
ob->notifier_block = nb;
|
||||
node->osal_nb = ob;
|
||||
node->nb = nb;
|
||||
osal_list_add(&(node->node), &nb_list);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_register_reboot_notifier);
|
||||
|
||||
int osal_unregister_reboot_notifier(struct osal_notifier_block *nb)
|
||||
{
|
||||
if (nb != NULL) {
|
||||
osal_del_nb(nb);
|
||||
unregister_reboot_notifier((struct notifier_block *)nb->notifier_block);
|
||||
kfree((struct notifier_block *)nb->notifier_block);
|
||||
nb->notifier_block = NULL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_unregister_reboot_notifier);
|
||||
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#if 0
|
||||
int osal_platform_driver_register(struct platform_driver *drv)
|
||||
{
|
||||
return __platform_driver_register(drv, THIS_MODULE);
|
||||
}
|
||||
void osal_platform_driver_unregister(struct platform_driver *drv)
|
||||
{
|
||||
return platform_driver_unregister(drv);
|
||||
}
|
||||
struct resource *osal_platform_get_resource_byname(struct platform_device *dev, unsigned int type, const char *name)
|
||||
{
|
||||
return platform_get_resource_byname(dev, type, name);
|
||||
}
|
||||
|
||||
#else
|
||||
int osal_platform_driver_register(void *drv)
|
||||
{
|
||||
return __platform_driver_register((struct platform_driver *)drv, THIS_MODULE);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_driver_register);
|
||||
|
||||
void osal_platform_driver_unregister(void *drv)
|
||||
{
|
||||
return platform_driver_unregister((struct platform_driver *)drv);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_driver_unregister);
|
||||
|
||||
void *osal_platform_get_resource_byname(void *dev, unsigned int type,
|
||||
const char *name)
|
||||
{
|
||||
return (void *)platform_get_resource_byname((struct platform_device *)dev, type, name);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_get_resource_byname);
|
||||
|
||||
void *osal_platform_get_resource(void *dev, unsigned int type, unsigned int num)
|
||||
{
|
||||
return (void *)platform_get_resource((struct platform_device *)dev, type, num);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_get_resource);
|
||||
|
||||
int osal_platform_get_irq(void *dev, unsigned int num)
|
||||
{
|
||||
return platform_get_irq((struct platform_device *)dev, num);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_get_irq);
|
||||
|
||||
int osal_platform_get_irq_byname(void *dev, const char *name)
|
||||
{
|
||||
return platform_get_irq_byname((struct platform_device *)dev, name);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_platform_get_irq_byname);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/slab.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <linux/version.h>
|
||||
|
||||
#include "osal.h"
|
||||
|
||||
#define OSAL_PROC_DEBUG 0
|
||||
|
||||
static struct osal_list_head list;
|
||||
static osal_proc_entry_t *proc_entry = NULL;
|
||||
|
||||
static int osal_seq_show(struct seq_file *s, void *p)
|
||||
{
|
||||
osal_proc_entry_t *oldsentry = s->private;
|
||||
osal_proc_entry_t sentry;
|
||||
if (oldsentry == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
memset(&sentry, 0, sizeof(osal_proc_entry_t));
|
||||
osal_memcpy(sentry.name, oldsentry->name, sizeof(sentry.name));
|
||||
/* only these two parameters are used */
|
||||
sentry.seqfile = s;
|
||||
sentry.private = oldsentry->private;
|
||||
oldsentry->read(&sentry);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
static ssize_t osal_procwrite(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
|
||||
{
|
||||
osal_proc_entry_t *sentry = ((struct seq_file *)(file->private_data))->private;
|
||||
return sentry->write(sentry, (char *)buf, count, (long long *)ppos);
|
||||
}
|
||||
#else
|
||||
static ssize_t osal_procwrite(struct file *file, const char __user *buf,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
osal_proc_entry_t *item = PDE_DATA(file_inode(file));
|
||||
|
||||
if ((item != NULL) && (item->write != NULL)) {
|
||||
return item->write(item, buf, count, (long long *)ppos);
|
||||
}
|
||||
|
||||
return -ENOSYS;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int osal_procopen(struct inode *inode, struct file *file)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
osal_proc_entry_t *sentry = PDE(inode)->data;
|
||||
#else
|
||||
osal_proc_entry_t *sentry = PDE_DATA(inode);
|
||||
#endif
|
||||
if ((sentry != NULL) && (sentry->open != NULL)) {
|
||||
sentry->open(sentry);
|
||||
}
|
||||
return single_open(file, osal_seq_show, sentry);
|
||||
}
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
static struct file_operations osal_proc_ops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = osal_procopen,
|
||||
.read = seq_read,
|
||||
.write = osal_procwrite,
|
||||
.llseek = seq_lseek,
|
||||
.release = single_release
|
||||
};
|
||||
#else
|
||||
struct proc_ops osal_proc_ops = {
|
||||
.proc_open = osal_procopen,
|
||||
.proc_read = seq_read,
|
||||
.proc_write = osal_procwrite,
|
||||
.proc_lseek = seq_lseek,
|
||||
.proc_release = single_release
|
||||
};
|
||||
#endif
|
||||
|
||||
osal_proc_entry_t *osal_create_proc(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
struct proc_dir_entry *entry = NULL;
|
||||
osal_proc_entry_t *sentry = NULL;
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
if (parent == NULL) {
|
||||
osal_printk("%s - parent is NULL!\n", __FUNCTION__);
|
||||
entry = create_proc_entry(name, 0, NULL);
|
||||
} else {
|
||||
osal_printk("%s - parent is not NULL! parent=%pK\n", __FUNCTION__, parent->proc_dir_entry);
|
||||
entry = create_proc_entry(name, 0, parent->proc_dir_entry);
|
||||
}
|
||||
if (entry == NULL) {
|
||||
osal_printk("%s - create_proc_entry failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
sentry = kmalloc(sizeof(struct osal_proc_dir_entry), GFP_KERNEL);
|
||||
if (sentry == NULL) {
|
||||
if (parent != NULL) {
|
||||
remove_proc_entry(name, parent->proc_dir_entry);
|
||||
} else {
|
||||
remove_proc_entry(name, NULL);
|
||||
}
|
||||
osal_printk("%s - kmalloc failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
osal_memset(sentry, 0, sizeof(struct osal_proc_dir_entry));
|
||||
|
||||
osal_strncpy(sentry->name, name, sizeof(sentry->name) - 1);
|
||||
sentry->proc_dir_entry = entry;
|
||||
sentry->open = NULL;
|
||||
entry->proc_fops = &osal_proc_ops;
|
||||
entry->data = sentry;
|
||||
#else
|
||||
sentry = kmalloc(sizeof(struct osal_proc_dir_entry), GFP_KERNEL);
|
||||
if (sentry == NULL) {
|
||||
osal_printk("%s - kmalloc failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
osal_memset(sentry, 0, sizeof(struct osal_proc_dir_entry));
|
||||
|
||||
osal_strncpy(sentry->name, name, sizeof(sentry->name) - 1);
|
||||
|
||||
if (parent == NULL) {
|
||||
entry = proc_create_data(name, 0, NULL, &osal_proc_ops, sentry);
|
||||
} else {
|
||||
entry = proc_create_data(name, 0, parent->proc_dir_entry, &osal_proc_ops, sentry);
|
||||
}
|
||||
if (entry == NULL) {
|
||||
osal_printk("%s - create_proc_entry failed!\n", __FUNCTION__);
|
||||
kfree(sentry);
|
||||
sentry = NULL;
|
||||
return NULL;
|
||||
}
|
||||
sentry->proc_dir_entry = entry;
|
||||
sentry->open = NULL;
|
||||
#endif
|
||||
osal_list_add_tail(&(sentry->node), &list);
|
||||
return sentry;
|
||||
}
|
||||
|
||||
void osal_remove_proc(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
struct osal_proc_dir_entry *sproc = NULL;
|
||||
|
||||
if (name == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
if (parent != NULL) {
|
||||
remove_proc_entry(name, parent->proc_dir_entry);
|
||||
} else {
|
||||
remove_proc_entry(name, NULL);
|
||||
}
|
||||
osal_list_for_each_entry(sproc, &list, node) {
|
||||
if (osal_strncmp(sproc->name, name, sizeof(sproc->name)) == 0) {
|
||||
osal_list_del(&(sproc->node));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sproc != NULL) {
|
||||
kfree(sproc);
|
||||
}
|
||||
}
|
||||
|
||||
osal_proc_entry_t *osal_create_proc_entry(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
parent = proc_entry;
|
||||
|
||||
return osal_create_proc(name, parent);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_create_proc_entry);
|
||||
|
||||
void osal_remove_proc_entry(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
parent = proc_entry;
|
||||
osal_remove_proc(name, parent);
|
||||
return;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_remove_proc_entry);
|
||||
|
||||
osal_proc_entry_t *osal_proc_mkdir(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
struct proc_dir_entry *proc = NULL;
|
||||
struct osal_proc_dir_entry *sproc = NULL;
|
||||
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
|
||||
if (parent != NULL) {
|
||||
proc = proc_mkdir(name, parent->proc_dir_entry);
|
||||
osal_printk("%s - parent is not NULL!\n", __FUNCTION__);
|
||||
// proc = create_proc_entry(name, S_IFDIR | S_IRUGO | S_IXUGO, parent->proc_dir_entry);
|
||||
} else {
|
||||
proc = proc_mkdir(name, NULL);
|
||||
osal_printk("%s - parent is NULL! proc=%pK \n", __FUNCTION__, proc);
|
||||
// proc = create_proc_entry(name, S_IFDIR | S_IRUGO | S_IXUGO, NULL);
|
||||
}
|
||||
if (proc == NULL) {
|
||||
osal_printk("%s - proc_mkdir failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
// osal_memset(proc, 0x00, sizeof(proc));
|
||||
sproc = kmalloc(sizeof(struct osal_proc_dir_entry), GFP_KERNEL);
|
||||
if (sproc == NULL) {
|
||||
if (parent != NULL) {
|
||||
remove_proc_entry(name, parent->proc_dir_entry);
|
||||
} else {
|
||||
remove_proc_entry(name, NULL);
|
||||
}
|
||||
osal_printk("%s - kmalloc failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
osal_memset(sproc, 0, sizeof(struct osal_proc_dir_entry));
|
||||
|
||||
osal_strncpy(sproc->name, name, sizeof(sproc->name) - 1);
|
||||
sproc->proc_dir_entry = proc;
|
||||
// sproc->read = NULL;
|
||||
// sproc->write = NULL;
|
||||
// proc->proc_fops = NULL;
|
||||
proc->data = sproc;
|
||||
#else
|
||||
sproc = kmalloc(sizeof(struct osal_proc_dir_entry), GFP_KERNEL);
|
||||
if (sproc == NULL) {
|
||||
osal_printk("%s - kmalloc failed!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
osal_memset(sproc, 0, sizeof(struct osal_proc_dir_entry));
|
||||
|
||||
osal_strncpy(sproc->name, name, sizeof(sproc->name) - 1);
|
||||
|
||||
if (parent != NULL) {
|
||||
proc = proc_mkdir_data(name, 0, parent->proc_dir_entry, sproc);
|
||||
} else {
|
||||
proc = proc_mkdir_data(name, 0, NULL, sproc);
|
||||
}
|
||||
if (proc == NULL) {
|
||||
osal_printk("%s - proc_mkdir failed!\n", __FUNCTION__);
|
||||
kfree(sproc);
|
||||
sproc = NULL;
|
||||
return NULL;
|
||||
}
|
||||
sproc->proc_dir_entry = proc;
|
||||
#endif
|
||||
osal_list_add_tail(&(sproc->node), &list);
|
||||
return sproc;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_proc_mkdir);
|
||||
|
||||
void osal_remove_proc_root(const char *name, osal_proc_entry_t *parent)
|
||||
{
|
||||
struct osal_proc_dir_entry *sproc = NULL;
|
||||
if (name == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
if (parent != NULL) {
|
||||
remove_proc_entry(name, parent->proc_dir_entry);
|
||||
} else {
|
||||
remove_proc_entry(name, NULL);
|
||||
}
|
||||
osal_list_for_each_entry(sproc, &list, node) {
|
||||
if (osal_strncmp(sproc->name, name, sizeof(sproc->name)) == 0) {
|
||||
osal_list_del(&(sproc->node));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sproc != NULL) {
|
||||
kfree(sproc);
|
||||
}
|
||||
}
|
||||
|
||||
void osal_seq_printf(osal_proc_entry_t *entry, const char *fmt, ...)
|
||||
{
|
||||
struct seq_file *s = (struct seq_file *)(entry->seqfile);
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0)
|
||||
(void)seq_vprintf(s, fmt, args);
|
||||
#else
|
||||
seq_vprintf(s, fmt, args);
|
||||
#endif
|
||||
va_end(args);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_seq_printf);
|
||||
|
||||
void osal_proc_init(void)
|
||||
{
|
||||
OSAL_INIT_LIST_HEAD(&list);
|
||||
proc_entry = osal_proc_mkdir("umap", OSAL_NULL);
|
||||
if (proc_entry == OSAL_NULL) {
|
||||
osal_printk("test init, proc mkdir error!\n");
|
||||
}
|
||||
}
|
||||
void osal_proc_exit(void)
|
||||
{
|
||||
osal_remove_proc_root("umap", OSAL_NULL);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
|
||||
void osal_yield(void)
|
||||
{
|
||||
// yield();
|
||||
cond_resched();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_yield);
|
||||
@@ -0,0 +1,95 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/semaphore.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
int osal_sema_init(osal_semaphore_t *sem, int val)
|
||||
{
|
||||
struct semaphore *p = NULL;
|
||||
if (sem == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = kmalloc(sizeof(struct semaphore), GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
sema_init(p, val);
|
||||
sem->sem = p;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sema_init);
|
||||
|
||||
int osal_down(osal_semaphore_t *sem)
|
||||
{
|
||||
struct semaphore *p = NULL;
|
||||
if (sem == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct semaphore *)(sem->sem);
|
||||
down(p);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_down);
|
||||
|
||||
int osal_down_interruptible(osal_semaphore_t *sem)
|
||||
{
|
||||
struct semaphore *p = NULL;
|
||||
if (sem == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct semaphore *)(sem->sem);
|
||||
return down_interruptible(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_down_interruptible);
|
||||
|
||||
int osal_down_trylock(osal_semaphore_t *sem)
|
||||
{
|
||||
struct semaphore *p = NULL;
|
||||
if (sem == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (struct semaphore *)(sem->sem);
|
||||
return down_trylock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_down_trylock);
|
||||
|
||||
void osal_up(osal_semaphore_t *sem)
|
||||
{
|
||||
struct semaphore *p = NULL;
|
||||
p = (struct semaphore *)(sem->sem);
|
||||
up(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_up);
|
||||
|
||||
void osal_sema_destory(osal_semaphore_t *sem)
|
||||
{
|
||||
if((sem != NULL) && (sem->sem != NULL)) {
|
||||
kfree((struct semaphore *)(sem->sem));
|
||||
sem->sem = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sema_destory);
|
||||
|
||||
void osal_sema_destroy(osal_semaphore_t *sem)
|
||||
{
|
||||
if((sem != NULL) && (sem->sem != NULL)) {
|
||||
kfree((struct semaphore *)(sem->sem));
|
||||
sem->sem = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sema_destroy);
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
int osal_spin_lock_init(osal_spinlock_t *lock)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
if (lock == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (spinlock_t *)kmalloc(sizeof(spinlock_t), GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
spin_lock_init(p);
|
||||
lock->lock = p;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_lock_init);
|
||||
|
||||
void osal_spin_lock(osal_spinlock_t *lock)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
|
||||
p = (spinlock_t *)(lock->lock);
|
||||
spin_lock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_lock);
|
||||
|
||||
int osal_spin_trylock(osal_spinlock_t *lock)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
if (lock == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
p = (spinlock_t *)(lock->lock);
|
||||
return spin_trylock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_trylock);
|
||||
|
||||
void osal_spin_unlock(osal_spinlock_t *lock)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
|
||||
p = (spinlock_t *)(lock->lock);
|
||||
spin_unlock(p);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_unlock);
|
||||
|
||||
void osal_spin_lock_irqsave(osal_spinlock_t *lock, unsigned long *flags)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
unsigned long f;
|
||||
|
||||
p = (spinlock_t *)(lock->lock);
|
||||
spin_lock_irqsave(p, f);
|
||||
*flags = f;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_lock_irqsave);
|
||||
void osal_spin_unlock_irqrestore(osal_spinlock_t *lock, unsigned long *flags)
|
||||
{
|
||||
spinlock_t *p = NULL;
|
||||
unsigned long f;
|
||||
|
||||
p = (spinlock_t *)(lock->lock);
|
||||
f = *flags;
|
||||
spin_unlock_irqrestore(p, f);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_unlock_irqrestore);
|
||||
|
||||
void osal_spin_lock_destory(osal_spinlock_t *lock)
|
||||
{
|
||||
if((lock != NULL) && (lock->lock != NULL)) {
|
||||
kfree((spinlock_t *)(lock->lock));
|
||||
lock->lock = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_lock_destory);
|
||||
|
||||
void osal_spin_lock_destroy(osal_spinlock_t *lock)
|
||||
{
|
||||
if((lock != NULL) && (lock->lock != NULL)) {
|
||||
kfree((spinlock_t *)(lock->lock));
|
||||
lock->lock = NULL;
|
||||
} else {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_spin_lock_destroy);
|
||||
|
||||
@@ -0,0 +1,235 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/version.h>
|
||||
|
||||
char *osal_strcpy(char *dest, const char *src)
|
||||
{
|
||||
return strcpy(dest, src);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strcpy);
|
||||
char *osal_strncpy(char *dest, const char *src, int count)
|
||||
{
|
||||
return strncpy(dest, src, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strncpy);
|
||||
int osal_strlcpy(char *dest, const char *src, int size)
|
||||
{
|
||||
return strlcpy(dest, src, size);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strlcpy);
|
||||
char *osal_strcat(char *dest, const char *src)
|
||||
{
|
||||
return strcat(dest, src);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strcat);
|
||||
char *osal_strncat(char *dest, const char *src, int count)
|
||||
{
|
||||
return strncat(dest, src, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strncat);
|
||||
int osal_strlcat(char *dest, const char *src, int count)
|
||||
{
|
||||
return strlcat(dest, src, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strlcat);
|
||||
int osal_strcmp(const char *cs, const char *ct)
|
||||
{
|
||||
return strcmp(cs, ct);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strcmp);
|
||||
int osal_strncmp(const char *cs, const char *ct, int count)
|
||||
{
|
||||
return strncmp(cs, ct, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strncmp);
|
||||
int osal_strnicmp(const char *s1, const char *s2, int len)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
|
||||
return strnicmp(s1, s2, len);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strnicmp);
|
||||
int osal_strcasecmp(const char *s1, const char *s2)
|
||||
{
|
||||
return strcasecmp(s1, s2);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strcasecmp);
|
||||
int osal_strncasecmp(const char *s1, const char *s2, int n)
|
||||
{
|
||||
return strncasecmp(s1, s2, n);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strncasecmp);
|
||||
char *osal_strchr(const char *s, int c)
|
||||
{
|
||||
return strchr(s, c);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strchr);
|
||||
char *osal_strnchr(const char *s, int count, int c)
|
||||
{
|
||||
return strnchr(s, count, c);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strnchr);
|
||||
char *osal_strrchr(const char *s, int c)
|
||||
{
|
||||
return strrchr(s, c);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strrchr);
|
||||
char *osal_strstr(const char *s1, const char *s2)
|
||||
{
|
||||
return strstr(s1, s2);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strstr);
|
||||
char *osal_strnstr(const char *s1, const char *s2, int len)
|
||||
{
|
||||
return strnstr(s1, s2, len);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strnstr);
|
||||
int osal_strlen(const char *s)
|
||||
{
|
||||
return strlen(s);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strlen);
|
||||
int osal_strnlen(const char *s, int count)
|
||||
{
|
||||
return strnlen(s, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strnlen);
|
||||
char *osal_strpbrk(const char *cs, const char *ct)
|
||||
{
|
||||
return strpbrk(cs, ct);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strpbrk);
|
||||
char *osal_strsep(char **s, const char *ct)
|
||||
{
|
||||
return strsep(s, ct);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strsep);
|
||||
int osal_strspn(const char *s, const char *accept)
|
||||
{
|
||||
return strspn(s, accept);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strspn);
|
||||
int osal_strcspn(const char *s, const char *reject)
|
||||
{
|
||||
return strcspn(s, reject);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strcspn);
|
||||
void *osal_memset(void *str, int c, int count)
|
||||
{
|
||||
return memset(str, c, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memset);
|
||||
void *osal_memcpy(void *dest, const void *src, int count)
|
||||
{
|
||||
return memcpy(dest, src, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memcpy);
|
||||
void *osal_memmove(void *dest, const void *src, int count)
|
||||
{
|
||||
return memmove(dest, src, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memmove);
|
||||
void *osal_memscan(void *addr, int c, int size)
|
||||
{
|
||||
return memscan(addr, c, size);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memscan);
|
||||
int osal_memcmp(const void *cs, const void *ct, int count)
|
||||
{
|
||||
return memcmp(cs, ct, count);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memcmp);
|
||||
void *osal_memchr(const void *s, int c, int n)
|
||||
{
|
||||
return memchr(s, c, n);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memchr);
|
||||
void *osal_memchr_inv(const void *start, int c, int bytes)
|
||||
{
|
||||
return memchr_inv(start, c, bytes);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_memchr_inv);
|
||||
unsigned long long osal_strtoull(const char *cp, char **endp, unsigned int base)
|
||||
{
|
||||
return simple_strtoull(cp, endp, base);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strtoull);
|
||||
unsigned long osal_strtoul(const char *cp, char **endp, unsigned int base)
|
||||
{
|
||||
return simple_strtoul(cp, endp, base);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strtoul);
|
||||
long osal_strtol(const char *cp, char **endp, unsigned int base)
|
||||
{
|
||||
return simple_strtol(cp, endp, base);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strtol);
|
||||
long long osal_strtoll(const char *cp, char **endp, unsigned int base)
|
||||
{
|
||||
return simple_strtoll(cp, endp, base);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_strtoll);
|
||||
int osal_snprintf(char *buf, int size, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i;
|
||||
|
||||
va_start(args, fmt);
|
||||
i = vsnprintf(buf, size, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return i;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_snprintf);
|
||||
int osal_scnprintf(char *buf, int size, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i;
|
||||
|
||||
va_start(args, fmt);
|
||||
i = vscnprintf(buf, size, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return i;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_scnprintf);
|
||||
int osal_sprintf(char *buf, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i;
|
||||
|
||||
va_start(args, fmt);
|
||||
i = vsnprintf(buf, INT_MAX, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return i;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sprintf);
|
||||
int osal_sscanf(const char *buf, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i;
|
||||
|
||||
va_start(args, fmt);
|
||||
i = vsscanf(buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return i;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sscanf);
|
||||
|
||||
int osal_vsnprintf(char *str, int size, const char *fmt, osal_va_list args)
|
||||
{
|
||||
return vsnprintf(str, size, fmt, args);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_vsnprintf);
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/kthread.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
osal_task_t *osal_kthread_create(threadfn_t thread, void *data, const char *name)
|
||||
{
|
||||
struct task_struct *k = NULL;
|
||||
osal_task_t *p = (osal_task_t *)kmalloc(sizeof(osal_task_t), GFP_KERNEL);
|
||||
if (p == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
memset(p, 0, sizeof(osal_task_t));
|
||||
|
||||
k = kthread_run(thread, data, name);
|
||||
if (IS_ERR(k)) {
|
||||
osal_printk("%s - kthread create error!\n", __FUNCTION__);
|
||||
kfree(p);
|
||||
return NULL;
|
||||
}
|
||||
p->task_struct = k;
|
||||
return p;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kthread_create);
|
||||
|
||||
void osal_kthread_destory(osal_task_t *task, unsigned int stop_flag)
|
||||
{
|
||||
if (task == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
/* note: When you call the Kthread_stop function, the thread function cannot be finished, otherwise it will oops. */
|
||||
if (stop_flag != 0) {
|
||||
kthread_stop ((struct task_struct *)(task->task_struct));
|
||||
}
|
||||
task->task_struct = NULL;
|
||||
kfree(task);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kthread_destory);
|
||||
|
||||
void osal_kthread_destroy(osal_task_t *task, unsigned int stop_flag)
|
||||
{
|
||||
if (task == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
/* note: When you call the Kthread_stop function, the thread function cannot be finished, otherwise it will oops. */
|
||||
if (stop_flag != 0) {
|
||||
kthread_stop ((struct task_struct *)(task->task_struct));
|
||||
}
|
||||
task->task_struct = NULL;
|
||||
kfree(task);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kthread_destroy);
|
||||
|
||||
int osal_kthread_should_stop(void)
|
||||
{
|
||||
return kthread_should_stop();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kthread_should_stop);
|
||||
@@ -0,0 +1,298 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/version.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/rtc.h>
|
||||
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 19, 0)
|
||||
#include <linux/sched/clock.h>
|
||||
#endif
|
||||
#include "osal.h"
|
||||
|
||||
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 19, 0)
|
||||
struct timer_list_info {
|
||||
struct timer_list time_list;
|
||||
unsigned long data;
|
||||
};
|
||||
typedef void (*timer_callback_fun)(struct timer_list * data);
|
||||
#endif
|
||||
|
||||
int osal_hrtimer_create(osal_hrtimer_t *phrtimer)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_hrtimer_create);
|
||||
|
||||
int osal_hrtimer_start(osal_hrtimer_t *phrtimer)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_hrtimer_start);
|
||||
|
||||
int osal_hrtimer_destroy(osal_hrtimer_t *phrtimer)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_hrtimer_destroy);
|
||||
|
||||
unsigned long osal_timer_get_private_data(void *data)
|
||||
{
|
||||
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 19, 0)
|
||||
struct timer_list_info *list_info = osal_container_of(data, struct timer_list_info, time_list);
|
||||
|
||||
return list_info->data;
|
||||
#else
|
||||
return (unsigned long)data;
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_timer_get_private_data);
|
||||
|
||||
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 19, 0)
|
||||
int osal_timer_init(osal_timer_t *timer)
|
||||
{
|
||||
struct timer_list_info *t = NULL;
|
||||
|
||||
if (timer == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
t = (struct timer_list_info *)kmalloc(sizeof(struct timer_list_info), GFP_KERNEL);
|
||||
if (t == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
t->data = timer->data;
|
||||
timer_setup(&t->time_list, (timer_callback_fun)timer->function, 0);
|
||||
timer->timer = t;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_timer_init);
|
||||
|
||||
int osal_set_timer(osal_timer_t *timer, unsigned long interval)
|
||||
{
|
||||
struct timer_list_info *list_info = NULL;
|
||||
if ((timer == NULL) || (timer->timer == NULL) || (timer->function == NULL) || (interval == 0)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
list_info = (struct timer_list_info *)timer->timer;
|
||||
list_info->data = timer->data;
|
||||
list_info->time_list.function = (timer_callback_fun)timer->function;
|
||||
return mod_timer(&list_info->time_list, jiffies + msecs_to_jiffies(interval) - 1);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_set_timer);
|
||||
#else
|
||||
int osal_timer_init(osal_timer_t *timer)
|
||||
{
|
||||
struct timer_list *t = NULL;
|
||||
|
||||
if (timer == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
t = (struct timer_list *)kmalloc(sizeof(struct timer_list), GFP_KERNEL);
|
||||
if (t == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
init_timer(t);
|
||||
timer->timer = t;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_timer_init);
|
||||
|
||||
int osal_set_timer(osal_timer_t *timer, unsigned long interval)
|
||||
{
|
||||
struct timer_list *t = NULL;
|
||||
if ((timer == NULL) || (timer->timer == NULL) || (timer->function == NULL) || (interval == 0)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
t = timer->timer;
|
||||
t->function = timer->function;
|
||||
t->data = timer->data;
|
||||
return mod_timer(t, jiffies + msecs_to_jiffies(interval) - 1);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_set_timer);
|
||||
#endif
|
||||
|
||||
int osal_del_timer(osal_timer_t *timer)
|
||||
{
|
||||
struct timer_list *t = NULL;
|
||||
if ((timer == NULL) || (timer->timer == NULL) || (timer->function == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
t = timer->timer;
|
||||
return del_timer(t);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_del_timer);
|
||||
|
||||
int osal_timer_destory(osal_timer_t *timer)
|
||||
{
|
||||
struct timer_list *t = NULL;
|
||||
if ((timer == NULL) || (timer->timer == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
t = timer->timer;
|
||||
del_timer(t);
|
||||
kfree(t);
|
||||
timer->timer = NULL;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_timer_destory);
|
||||
|
||||
int osal_timer_destroy(osal_timer_t *timer)
|
||||
{
|
||||
struct timer_list *t = NULL;
|
||||
if ((timer == NULL) || (timer->timer == NULL)) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
t = timer->timer;
|
||||
del_timer(t);
|
||||
kfree(t);
|
||||
timer->timer = NULL;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_timer_destroy);
|
||||
|
||||
unsigned long osal_msleep(unsigned int msecs)
|
||||
{
|
||||
return msleep_interruptible(msecs);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_msleep);
|
||||
|
||||
void osal_udelay(unsigned int usecs)
|
||||
{
|
||||
udelay(usecs);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_udelay);
|
||||
|
||||
void osal_mdelay(unsigned int msecs)
|
||||
{
|
||||
mdelay(msecs);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_mdelay);
|
||||
|
||||
unsigned int osal_get_tickcount()
|
||||
{
|
||||
return jiffies_to_msecs(jiffies);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_get_tickcount);
|
||||
|
||||
unsigned long long osal_sched_clock()
|
||||
{
|
||||
return sched_clock();
|
||||
}
|
||||
EXPORT_SYMBOL(osal_sched_clock);
|
||||
|
||||
void osal_gettimeofday(osal_timeval_t *tv)
|
||||
{
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
struct timeval t;
|
||||
if (tv == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
do_gettimeofday(&t);
|
||||
|
||||
tv->tv_sec = t.tv_sec;
|
||||
tv->tv_usec = t.tv_usec;
|
||||
#else
|
||||
struct timespec64 t;
|
||||
if (tv == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
ktime_get_real_ts64(&t);
|
||||
|
||||
tv->tv_sec = (long)(t.tv_sec);
|
||||
tv->tv_usec = t.tv_nsec / 1000;
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_gettimeofday);
|
||||
|
||||
unsigned long long osal_get_boottime(void)
|
||||
{
|
||||
return ktime_to_ns(ktime_get_boottime());
|
||||
}
|
||||
EXPORT_SYMBOL(osal_get_boottime);
|
||||
|
||||
void osal_rtc_time_to_tm(unsigned long time, osal_rtc_time_t *tm)
|
||||
{
|
||||
struct rtc_time _tm = { 0 };
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
rtc_time_to_tm(time, &_tm);
|
||||
#else
|
||||
rtc_time64_to_tm((time64_t)time, &_tm);
|
||||
#endif
|
||||
tm->tm_sec = _tm.tm_sec;
|
||||
tm->tm_min = _tm.tm_min;
|
||||
tm->tm_hour = _tm.tm_hour;
|
||||
tm->tm_mday = _tm.tm_mday;
|
||||
tm->tm_mon = _tm.tm_mon;
|
||||
tm->tm_year = _tm.tm_year;
|
||||
tm->tm_wday = _tm.tm_wday;
|
||||
tm->tm_yday = _tm.tm_yday;
|
||||
tm->tm_isdst = _tm.tm_isdst;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_rtc_time_to_tm);
|
||||
|
||||
void osal_rtc_tm_to_time(osal_rtc_time_t *tm, unsigned long *time)
|
||||
{
|
||||
struct rtc_time _tm;
|
||||
_tm.tm_sec = tm->tm_sec;
|
||||
_tm.tm_min = tm->tm_min;
|
||||
_tm.tm_hour = tm->tm_hour;
|
||||
_tm.tm_mday = tm->tm_mday;
|
||||
_tm.tm_mon = tm->tm_mon;
|
||||
_tm.tm_year = tm->tm_year;
|
||||
_tm.tm_wday = tm->tm_wday;
|
||||
_tm.tm_yday = tm->tm_yday;
|
||||
_tm.tm_isdst = tm->tm_isdst;
|
||||
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0)
|
||||
rtc_tm_to_time(&_tm, time);
|
||||
#else
|
||||
*time = (unsigned long)rtc_tm_to_time64(&_tm);
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(osal_rtc_tm_to_time);
|
||||
|
||||
void osal_getjiffies(unsigned long long *pjiffies)
|
||||
{
|
||||
*pjiffies = jiffies;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_getjiffies);
|
||||
|
||||
int osal_rtc_valid_tm(struct osal_rtc_time *tm)
|
||||
{
|
||||
struct rtc_time _tm;
|
||||
_tm.tm_sec = tm->tm_sec;
|
||||
_tm.tm_min = tm->tm_min;
|
||||
_tm.tm_hour = tm->tm_hour;
|
||||
_tm.tm_mday = tm->tm_mday;
|
||||
_tm.tm_mon = tm->tm_mon;
|
||||
_tm.tm_year = tm->tm_year;
|
||||
_tm.tm_wday = tm->tm_wday;
|
||||
_tm.tm_yday = tm->tm_yday;
|
||||
_tm.tm_isdst = tm->tm_isdst;
|
||||
|
||||
return rtc_valid_tm(&_tm);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_rtc_valid_tm);
|
||||
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/slab.h>
|
||||
#include "osal.h"
|
||||
|
||||
void *osal_vmalloc(unsigned long size)
|
||||
{
|
||||
return vmalloc(size);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_vmalloc);
|
||||
|
||||
void osal_vfree(const void *addr)
|
||||
{
|
||||
vfree(addr);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_vfree);
|
||||
|
||||
void *osal_kmalloc(unsigned long size, unsigned int osal_gfp_flag)
|
||||
{
|
||||
if (osal_gfp_flag == osal_gfp_kernel) {
|
||||
return kmalloc(size, GFP_KERNEL);
|
||||
} else if (osal_gfp_flag == osal_gfp_atomic) {
|
||||
return kmalloc(size, GFP_ATOMIC);
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_kmalloc);
|
||||
|
||||
void osal_kfree(const void *addr)
|
||||
{
|
||||
kfree(addr);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(osal_kfree);
|
||||
|
||||
|
||||
@@ -0,0 +1,217 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include "osal.h"
|
||||
#include <linux/version.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/sched.h>
|
||||
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 19, 0)
|
||||
#include <linux/sched/signal.h>
|
||||
#endif
|
||||
#include <linux/slab.h>
|
||||
|
||||
unsigned long osal_msecs_to_jiffies(const unsigned int m)
|
||||
{
|
||||
return msecs_to_jiffies(m);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_msecs_to_jiffies);
|
||||
|
||||
int osal_wait_init(osal_wait_t *wait)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
if (wait == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
wq = (wait_queue_head_t *)kmalloc(sizeof(wait_queue_head_t), GFP_ATOMIC);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - kmalloc error!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
init_waitqueue_head(wq);
|
||||
wait->wait = wq;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_init);
|
||||
|
||||
int osal_wait_interruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
DEFINE_WAIT(__wait);
|
||||
long ret = 0;
|
||||
int condition = 0;
|
||||
|
||||
if (wait == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
wq = (wait_queue_head_t *)(wait->wait);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
prepare_to_wait(wq, &__wait, TASK_INTERRUPTIBLE);
|
||||
/* if wakeup the queue brefore prepare_to_wait, the func will return true. And will not go to schedule */
|
||||
if (func != NULL) {
|
||||
condition = func(param);
|
||||
}
|
||||
|
||||
if (!condition) {
|
||||
if (!signal_pending(current)) {
|
||||
schedule();
|
||||
}
|
||||
if (signal_pending(current)) {
|
||||
ret = -ERESTARTSYS;
|
||||
}
|
||||
}
|
||||
|
||||
finish_wait(wq, &__wait);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_interruptible);
|
||||
|
||||
int osal_wait_uninterruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
DEFINE_WAIT(__wait);
|
||||
long ret = 0;
|
||||
int condition = 0;
|
||||
|
||||
if (wait == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
wq = (wait_queue_head_t *)(wait->wait);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
prepare_to_wait(wq, &__wait, TASK_UNINTERRUPTIBLE);
|
||||
/* if wakeup the queue brefore prepare_to_wait, the func will return true. And will not go to schedule */
|
||||
if (func != NULL) {
|
||||
condition = func(param);
|
||||
}
|
||||
|
||||
if (!condition) {
|
||||
schedule();
|
||||
}
|
||||
|
||||
finish_wait(wq, &__wait);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_uninterruptible);
|
||||
|
||||
int osal_wait_timeout_interruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param, unsigned long ms)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
DEFINE_WAIT(__wait);
|
||||
long ret = ms;
|
||||
int condition = 0;
|
||||
|
||||
if (wait == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
wq = (wait_queue_head_t *)(wait->wait);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
prepare_to_wait(wq, &__wait, TASK_INTERRUPTIBLE);
|
||||
/* if wakeup the queue brefore prepare_to_wait, the func will return true. And will not go to schedule */
|
||||
if (func != NULL) {
|
||||
condition = func(param);
|
||||
}
|
||||
|
||||
if (!condition) {
|
||||
if (!signal_pending(current)) {
|
||||
ret = schedule_timeout(msecs_to_jiffies(ret));
|
||||
ret = jiffies_to_msecs(ret);
|
||||
}
|
||||
if (signal_pending(current)) {
|
||||
ret = -ERESTARTSYS;
|
||||
}
|
||||
}
|
||||
|
||||
finish_wait(wq, &__wait);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(osal_wait_timeout_interruptible);
|
||||
|
||||
int osal_wait_timeout_uninterruptible(osal_wait_t *wait, osal_wait_cond_func_t func, void *param, unsigned long ms)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
DEFINE_WAIT(__wait);
|
||||
long ret = ms;
|
||||
int condition = 0;
|
||||
|
||||
if (wait == NULL) {
|
||||
osal_printk("%s - parameter invalid!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
wq = (wait_queue_head_t *)(wait->wait);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
return -1;
|
||||
}
|
||||
prepare_to_wait(wq, &__wait, TASK_UNINTERRUPTIBLE);
|
||||
/* if wakeup the queue brefore prepare_to_wait, the func will return true. And will not go to schedule */
|
||||
if (func != NULL) {
|
||||
condition = func(param);
|
||||
}
|
||||
|
||||
if (!condition) {
|
||||
ret = schedule_timeout(msecs_to_jiffies(ret));
|
||||
ret = jiffies_to_msecs(ret);
|
||||
}
|
||||
|
||||
finish_wait(wq, &__wait);
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_timeout_uninterruptible);
|
||||
|
||||
void osal_wakeup(osal_wait_t *wait)
|
||||
{
|
||||
wait_queue_head_t *wq = NULL;
|
||||
|
||||
wq = (wait_queue_head_t *)(wait->wait);
|
||||
if (wq == NULL) {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
return;
|
||||
}
|
||||
wake_up_all(wq);
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wakeup);
|
||||
|
||||
void osal_wait_destory(osal_wait_t *wait)
|
||||
{
|
||||
if ((wait != NULL) && (wait->wait != NULL)) {
|
||||
kfree((wait_queue_head_t *)(wait->wait));
|
||||
wait->wait = NULL;
|
||||
} else {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_destory);
|
||||
|
||||
void osal_wait_destroy(osal_wait_t *wait)
|
||||
{
|
||||
if ((wait != NULL) && (wait->wait != NULL)) {
|
||||
kfree((wait_queue_head_t *)(wait->wait));
|
||||
wait->wait = NULL;
|
||||
} else {
|
||||
osal_printk("%s - wait->wait is NULL!\n", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_wait_destroy);
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include "osal.h"
|
||||
|
||||
OSAL_LIST_HEAD(wq_list);
|
||||
struct wq_node {
|
||||
struct osal_work_struct *osal_work;
|
||||
struct work_struct *work;
|
||||
struct osal_list_head node;
|
||||
};
|
||||
|
||||
static struct osal_work_struct *osal_find_work(struct work_struct *work)
|
||||
{
|
||||
struct osal_list_head *this = NULL;
|
||||
if (osal_list_empty(&wq_list)) {
|
||||
osal_printk("find work failed! wq_list is empty!\n");
|
||||
return NULL;
|
||||
}
|
||||
osal_list_for_each(this, &wq_list) {
|
||||
struct wq_node *ws = osal_list_entry(this, struct wq_node, node);
|
||||
if (ws->work == work) {
|
||||
return ws->osal_work;
|
||||
}
|
||||
}
|
||||
osal_printk("find work failed!\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int osal_del_work(struct work_struct *work)
|
||||
{
|
||||
struct osal_list_head *this = NULL;
|
||||
struct osal_list_head *next = NULL;
|
||||
if (osal_list_empty(&wq_list)) {
|
||||
osal_printk("find work failed! wq_list is empty!\n");
|
||||
return -1;
|
||||
}
|
||||
osal_list_for_each_safe(this, next, &wq_list) {
|
||||
struct wq_node *ws = osal_list_entry(this, struct wq_node, node);
|
||||
if (ws->work == work) {
|
||||
osal_list_del(this);
|
||||
kfree(ws);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
osal_printk("del work failed!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void osal_work_func(struct work_struct *work)
|
||||
{
|
||||
struct osal_work_struct *ow = osal_find_work(work);
|
||||
if ((ow != NULL) && (ow->func != NULL)) {
|
||||
ow->func(ow);
|
||||
}
|
||||
}
|
||||
|
||||
int osal_init_work(struct osal_work_struct *work, osal_work_func_t func)
|
||||
{
|
||||
struct work_struct *w = NULL;
|
||||
struct wq_node *w_node = NULL;
|
||||
w = kmalloc(sizeof(struct work_struct), GFP_ATOMIC);
|
||||
if (w == NULL) {
|
||||
osal_printk("osal_init_work kmalloc failed!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
w_node = kmalloc(sizeof(struct wq_node), GFP_ATOMIC);
|
||||
if (w_node == NULL) {
|
||||
osal_printk("osal_init_work kmalloc failed!\n");
|
||||
kfree(w);
|
||||
return -1;
|
||||
}
|
||||
INIT_WORK(w, osal_work_func);
|
||||
work->work = w;
|
||||
work->func = func;
|
||||
w_node->osal_work = work;
|
||||
w_node->work = w;
|
||||
osal_list_add(&(w_node->node), &wq_list);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(osal_init_work);
|
||||
|
||||
int osal_schedule_work(struct osal_work_struct *work)
|
||||
{
|
||||
if ((work != NULL) && (work->work != NULL)) {
|
||||
return (int)schedule_work(work->work);
|
||||
} else {
|
||||
return (int)false;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_schedule_work);
|
||||
|
||||
void osal_destroy_work(struct osal_work_struct *work)
|
||||
{
|
||||
if ((work != NULL) && (work->work != NULL)) {
|
||||
osal_del_work(work->work);
|
||||
kfree((struct work_struct *)work->work);
|
||||
work->work = NULL;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(osal_destroy_work);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user