744 lines
12 KiB
C
744 lines
12 KiB
C
#include <lx_emul.h>
|
|
#include <lx_emul_c.h>
|
|
|
|
#include <drm/drm_device.h>
|
|
#include <drm/drm_gem.h>
|
|
#include <linux/component.h>
|
|
#include <linux/irqdomain.h>
|
|
#include <linux/irqhandler.h>
|
|
#include <linux/ratelimit.h>
|
|
#include <soc/imx8/sc/types.h>
|
|
#include <uapi/linux/i2c.h>
|
|
|
|
|
|
/************************
|
|
** drivers/base/bus.c **
|
|
************************/
|
|
|
|
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
|
|
void *data, int (*fn)(struct device_driver *, void *))
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*************************
|
|
** drivers/base/core.c **
|
|
*************************/
|
|
|
|
int device_for_each_child(struct device *dev, void *data,
|
|
int (*fn)(struct device *dev, void *data))
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int device_register(struct device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/********************************
|
|
** drivers/base/dma-mapping.c **
|
|
********************************/
|
|
|
|
void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
|
|
dma_addr_t dma_handle)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/*****************************
|
|
** drivers/base/platform.c **
|
|
*****************************/
|
|
|
|
int platform_device_put(struct platform_device *pdev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return 0;
|
|
}
|
|
|
|
void platform_device_unregister(struct platform_device *pdev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/*****************************
|
|
** drivers/base/property.c **
|
|
*****************************/
|
|
|
|
int device_add_properties(struct device *dev, const struct property_entry *properties)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void device_remove_properties(struct device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/***********************
|
|
** drivers/clk/clk.c **
|
|
***********************/
|
|
|
|
struct clk *clk_get_parent(struct clk *clk)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
bool clk_is_match(const struct clk *p, const struct clk *q)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return false;
|
|
}
|
|
|
|
int clk_set_parent(struct clk *clk, struct clk *parent)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*******************************
|
|
** drivers/gpu/drm/drm_drv.c **
|
|
*******************************/
|
|
|
|
void drm_dev_unref(struct drm_device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void drm_dev_unregister(struct drm_device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/*****************************************
|
|
** drivers/gpu/drm/drm_fb_cma_helper.c **
|
|
*****************************************/
|
|
|
|
struct drm_framebuffer *drm_fb_cma_create(struct drm_device *dev,
|
|
struct drm_file *file_priv,
|
|
const struct drm_mode_fb_cmd2 *mode_cmd)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
struct drm_fbdev_cma;
|
|
|
|
void drm_fbdev_cma_hotplug_event(struct drm_fbdev_cma *fbdev_cma)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
|
|
/*******************************
|
|
** drivers/i2c/i2c-core-of.c **
|
|
*******************************/
|
|
|
|
struct i2c_adapter;
|
|
|
|
void of_i2c_register_devices(struct i2c_adapter *adap)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/**********************************
|
|
** drivers/i2c/i2c-core-smbus.c **
|
|
**********************************/
|
|
|
|
struct i2c_adapter;
|
|
|
|
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
|
|
char read_write, u8 command, int protocol,
|
|
union i2c_smbus_data *data) {
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/***********************
|
|
** drivers/of/base.c **
|
|
***********************/
|
|
|
|
bool of_device_is_available(const struct device_node *device)
|
|
{
|
|
return device;
|
|
}
|
|
|
|
|
|
/**************************
|
|
** drivers/of/dynamic.c **
|
|
**************************/
|
|
|
|
struct device_node *of_node_get(struct device_node *node)
|
|
{
|
|
TRACE;
|
|
return node;
|
|
}
|
|
|
|
void of_node_put(struct device_node *node)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
|
|
/***********************************
|
|
** drivers/soc/imx/sc/main/ipc.c **
|
|
***********************************/
|
|
|
|
int sc_ipc_getMuID(uint32_t *mu_id)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void sc_ipc_close(sc_ipc_t handle)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
sc_err_t sc_ipc_open(sc_ipc_t *handle, uint32_t id)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/********************************************
|
|
** drivers/soc/imx/sc/svc/misc/rpc_clnt.c **
|
|
********************************************/
|
|
|
|
sc_err_t sc_misc_set_control(sc_ipc_t ipc, sc_rsrc_t resource,
|
|
sc_ctrl_t ctrl, uint32_t val)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/***********************
|
|
** kernel/irq/chip.c **
|
|
***********************/
|
|
|
|
void handle_level_irq(struct irq_desc *desc)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void handle_simple_irq(struct irq_desc *desc)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void irq_chip_eoi_parent(struct irq_data *data)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
struct irq_data *irq_get_irq_data(unsigned int irq)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int irq_set_chip_data(unsigned int irq, void *data)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/****************************
|
|
** kernel/irq/irqdomain.c **
|
|
****************************/
|
|
|
|
unsigned int irq_create_mapping(struct irq_domain *host, irq_hw_number_t hwirq)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
|
|
const u32 *intspec, unsigned int intsize,
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/******************
|
|
** lib/string.c **
|
|
******************/
|
|
|
|
char *strstr(const char * a0, const char * a1)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************
|
|
** linux/clk.h **
|
|
*****************/
|
|
|
|
void clk_disable_unprepare(struct clk *clk)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
int clk_prepare_enable(struct clk *clk)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/******************
|
|
** linux/gpio.h **
|
|
******************/
|
|
|
|
void gpio_free(unsigned gpio)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int gpio_get_value(unsigned int gpio)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
bool gpio_is_valid(int number)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return false;
|
|
}
|
|
|
|
int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void gpio_set_value(unsigned int gpio, int value)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/*****************
|
|
** linux/i2c.h **
|
|
*****************/
|
|
|
|
struct i2c_client;
|
|
|
|
const struct of_device_id *i2c_of_match_device(const struct of_device_id *matches,
|
|
struct i2c_client *client)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************
|
|
** linux/irq.h **
|
|
*****************/
|
|
|
|
void irq_set_status_flags(unsigned int irq, unsigned long set)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void irqd_set_trigger_type(struct irq_data *d, u32 type)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
|
|
/****************
|
|
** linux/of.h **
|
|
****************/
|
|
|
|
bool is_of_node(const struct fwnode_handle *fwnode)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return false;
|
|
}
|
|
|
|
|
|
/************************
|
|
** linux/pm_runtime.h **
|
|
************************/
|
|
|
|
int pm_runtime_get_sync(struct device *dev)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
int pm_runtime_put_sync(struct device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**********************
|
|
** linux/spinlock.h **
|
|
**********************/
|
|
|
|
void assert_spin_locked(spinlock_t *lock)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
|
|
/*************************
|
|
** linux/timekeeping.h **
|
|
*************************/
|
|
|
|
ktime_t ktime_get_real(void)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*************************
|
|
** linux/dma-mapping.h **
|
|
*************************/
|
|
|
|
int
|
|
dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
|
|
dma_addr_t dma_addr, size_t size,
|
|
unsigned long attrs)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int dma_mmap_wc(struct device *dev,
|
|
struct vm_area_struct *vma,
|
|
void *cpu_addr, dma_addr_t dma_addr,
|
|
size_t size)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/************************
|
|
** linux/pm-runtime.h **
|
|
************************/
|
|
|
|
void pm_runtime_enable(struct device *dev)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void pm_runtime_disable(struct device *dev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *ev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
bool acpi_driver_match_device(struct device *dev, const struct device_driver *drv)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
const char *acpi_dev_name(struct acpi_device *adev)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void destroy_workqueue(struct workqueue_struct *wq)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int device_init_wakeup(struct device *dev, bool val)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void down_read(struct rw_semaphore *sem)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
|
|
struct drm_gem_object *obj,
|
|
int flags)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
int drm_gem_prime_fd_to_handle(struct drm_device *dev, struct drm_file *file_priv, int prime_fd, uint32_t *handle)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int drm_gem_prime_handle_to_fd(struct drm_device *dev, struct drm_file *file_priv, uint32_t handle, uint32_t flags, int *prime_fd)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
|
|
struct dma_buf *dma_buf)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return NULL;
|
|
}
|
|
|
|
long drm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int drm_open(struct inode *inode, struct file *filp)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
ssize_t drm_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int drm_release(struct inode *inode, struct file *filp)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void ndelay(unsigned long ns)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
loff_t noop_llseek(struct file *file, loff_t offset, int whence)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int of_alias_get_id(struct device_node *np, const char *stem)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -ENOSYS;
|
|
}
|
|
|
|
int of_irq_get(struct device_node *dev, int index)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int of_irq_get_byname(struct device_node *dev, const char *name)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
pgprot_t pgprot_writecombine(pgprot_t prot)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return prot;
|
|
}
|
|
|
|
void print_hex_dump(const char *level, const char *prefix_str, int prefix_type, int rowsize, int groupsize, const void *buf, size_t len, bool ascii)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
int PTR_ERR_OR_ZERO(__force const void *ptr)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void up_read(struct rw_semaphore *sem)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
pgprot_t vm_get_page_prot(unsigned long vm_flags)
|
|
{
|
|
pgprot_t prot;
|
|
TRACE_AND_STOP;
|
|
return prot;
|
|
}
|
|
|
|
void ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int ww_mutex_lock_slow_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int ww_mutex_trylock(struct ww_mutex *lock)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
int ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return -1;
|
|
}
|
|
|
|
void might_lock(struct mutex *m)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void write_lock(rwlock_t *l)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void write_unlock(rwlock_t *l)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void read_lock(rwlock_t *l)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void read_unlock(rwlock_t *l)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
void write_seqlock(seqlock_t *l)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void write_sequnlock(seqlock_t *l)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
unsigned read_seqbegin(const seqlock_t *s)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
unsigned read_seqretry(const seqlock_t *s, unsigned x)
|
|
{
|
|
TRACE;
|
|
return 0;
|
|
}
|
|
|
|
struct dma_fence * reservation_object_get_excl_rcu(struct reservation_object *obj)
|
|
{
|
|
TRACE;
|
|
return obj->fence_excl;
|
|
}
|
|
|
|
void rwlock_init(rwlock_t *rw)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
unsigned long vma_pages(struct vm_area_struct *p)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return 0;
|
|
}
|
|
|
|
void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *))
|
|
{
|
|
TRACE;
|
|
|
|
func(head);
|
|
}
|
|
|
|
void seqlock_init (seqlock_t *s)
|
|
{
|
|
TRACE;
|
|
}
|
|
|
|
void irq_domain_remove(struct irq_domain *d)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
pgprot_t pgprot_decrypted(pgprot_t prot)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return prot;
|
|
}
|
|
|
|
void dma_buf_put(struct dma_buf *buf)
|
|
{
|
|
TRACE_AND_STOP;
|
|
}
|
|
|
|
int ___ratelimit(struct ratelimit_state *rs, const char *func)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return 0;
|
|
}
|
|
|
|
bool _drm_lease_held(struct drm_file *f, int x)
|
|
{
|
|
TRACE_AND_STOP;
|
|
return false;
|
|
}
|
|
|
|
long long atomic64_add_return(long long i, atomic64_t *p)
|
|
{
|
|
TRACE;
|
|
p->counter += i;
|
|
return p->counter;
|
|
}
|