HT7315_MonitorSOC/sdk/Driver/UsbBillboard/inc/hv_drv_UsbCompat.h

/*
* @file hv_drv_UsbCompat.h
* @brief This file contains some compatibility definitions. 
*        Because the code is ported from uboot, some adaptations have been made here.
*
* @author HiView SoC Software Team
* @version 1.0.0
* @date 2022-06-15
*/

#ifndef __HV_DRV_USB_COMPAT_H_
#define __HV_DRV_USB_COMPAT_H_

#include "hv_drv_UsbDefaultConfig.h"

#include "hv_drv_UsbDefines.h"
#include "hv_vos_Comm.h"




struct unused {};
typedef struct unused unused_t;

struct p_current{
       int pid;
};


//extern struct p_current *current;

/* avoid conflict with <dm/device.h> */
#ifdef dev_dbg
#undef dev_dbg
#endif
#ifdef dev_vdbg
#undef dev_vdbg
#endif
#ifdef dev_info
#undef dev_info
#endif
#ifdef dev_err
#undef dev_err
#endif
#ifdef dev_warn
#undef dev_warn
#endif


#ifdef USB_DEBUG
#define dev_dbg(dev, fmt, args...)        \
    pr_info(fmt, ##args)
#define dev_vdbg(dev, fmt, args...)        \
    pr_info(fmt, ##args)
#define dev_info(dev, fmt, args...)        \
    pr_info(fmt, ##args)
#define dev_err(dev, fmt, args...)        \
    pr_info(fmt, ##args)
#define dev_warn(dev, fmt, args...)        \
    pr_info(fmt, ##args)

#define debug(fmt, args...)   pr_info(fmt, ##args)
#define ERR(fmt, args...)     pr_info(fmt, ##args)
#else
#define dev_dbg(dev, fmt, args...)        
#define dev_vdbg(dev, fmt, args...)        
#define dev_info(dev, fmt, args...)        
#define dev_err(dev, fmt, args...)        \
    pr_err(fmt, ##args)
#define dev_warn(dev, fmt, args...)        

#define debug(fmt, args...)   
#define ERR(fmt, args...)               \
    pr_err(fmt, ##args)
#endif


#define GFP_ATOMIC ((gfp_t) 0)
#define GFP_KERNEL ((gfp_t) 0)
#define GFP_NOFS ((gfp_t) 0)
#define GFP_USER ((gfp_t) 0)
#define __GFP_NOWARN ((gfp_t) 0)
#define __GFP_ZERO    ((gfp_t)0x8000u)    /* Return zeroed page on success */

#ifndef SIZE_MAX
#define SIZE_MAX    (~(size_t)0)
#endif

static inline void kfree(const void *block)
{
    HV_FREE((void *)block);
}
static inline void vfree(const void *addr)
{
    HV_FREE((void *)addr);
}

struct kmem_cache { int sz; };

struct kmem_cache *get_mem(int element_sz);
#define kmem_cache_create(a, sz, c, d, e)    get_mem(sz)
void *kmem_cache_alloc(struct kmem_cache *obj, int flag);
static inline void kmem_cache_free(struct kmem_cache *cachep, void *obj)
{
    HV_FREE(obj);
}
static inline void kmem_cache_destroy(struct kmem_cache *cachep)
{
    HV_FREE(cachep);
}

#define DECLARE_WAITQUEUE(...)      do { } while (0)
#define add_wait_queue(...)         do { } while (0)
#define remove_wait_queue(...)      do { } while (0)

#define KERNEL_VERSION(a,b,c)    (((a) << 16) + ((b) << 8) + (c))

#define PAGE_SIZE    4096

/* drivers/char/random.c */
#define get_random_bytes(...)

/* include/linux/leds.h */
struct led_trigger {};

#define DEFINE_LED_TRIGGER(x)        static struct led_trigger *x;
enum led_brightness {
    LED_OFF        = 0,
    LED_HALF    = 127,
    LED_FULL    = 255,
};

static inline void led_trigger_register_simple(const char *name,
                    struct led_trigger **trigger) {}
static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
static inline void led_trigger_event(struct led_trigger *trigger,
                    enum led_brightness event) {}

/* uapi/linux/limits.h */
#define XATTR_LIST_MAX 65536    /* size of extended attribute namelist (64k) */

/**
 * The type used for indexing onto a disc or disc partition.
 *
 * Linux always considers sectors to be 512 bytes long independently
 * of the devices real block size.
 *
 * blkcnt_t is the type of the inode's block count.
 */
#ifdef CONFIG_LBDAF
typedef u64 sector_t;
typedef u64 blkcnt_t;
#else
#ifdef sector_t
#undef sector_t
typedef unsigned long sector_t;
#endif

#ifdef blkcnt_t
#undef blkcnt_t
typedef unsigned long blkcnt_t;
#endif
#endif


struct work_struct {};

typedef unused_t spinlock_t;
typedef int    wait_queue_head_t;

#define spin_lock_init(lock) do {} while (0)
#define spin_lock(lock) do {} while (0)
#define spin_unlock(lock) do {} while (0)
#define spin_lock_irqsave(lock, flags) do {} while (0)
#define spin_unlock_irqrestore(lock, flags) do { flags = 0; } while (0)

#define DEFINE_MUTEX(...)
#define mutex_init(...)
#define mutex_lock(...)
#define mutex_unlock(...)

#define init_rwsem(...)            do { } while (0)
#define down_read(...)             do { } while (0)
#define down_write(...)            do { } while (0)
#define down_write_trylock(...)    1
#define up_read(...)               do { } while (0)
#define up_write(...)              do { } while (0)

#define cond_resched()             do { } while (0)
#define yield()                    do { } while (0)

#define __init
#define __exit
#define __devinit
#define __devinitconst

#define kthread_create(...)    __builtin_return_address(0)
#define kthread_stop(...)      do { } while (0)
#define wake_up_process(...)   do { } while (0)

struct rw_semaphore { int i; };
#define down_write(...)            do { } while (0)
#define up_write(...)              do { } while (0)
#define down_read(...)             do { } while (0)
#define up_read(...)               do { } while (0)
struct device {
    struct device        *parent;
    struct class         *class;
    dev_t                devt;    /* dev_t, creates the sysfs "dev" */
    void                 (*release)(struct device *dev);
    /* This is used from drivers/usb/musb-new subsystem only */
    void                 *driver_data;    /* data private to the driver */
    void            *device_data;   /* data private to the device */
};
struct mutex { int i; };
struct kernel_param { int i; };

struct cdev {
    int owner;
    dev_t dev;
};
#define cdev_init(...)        do { } while (0)
#define cdev_add(...)        0
#define cdev_del(...)        do { } while (0)

#define prandom_u32(...)    0

typedef struct {
    uid_t val;
} kuid_t;

typedef struct {
    gid_t val;
} kgid_t;

/* from include/linux/types.h */

/**
 * struct callback_head - callback structure for use with RCU and task_work
 * @next: next update requests in a list
 * @func: actual update function to call after the grace period.
 */
struct callback_head {
    struct callback_head *next;
    void (*func)(struct callback_head *head);
};
#define rcu_head callback_head
enum writeback_sync_modes {
    WB_SYNC_NONE,    /* Don't wait on anything */
    WB_SYNC_ALL,    /* Wait on every mapping */
};

/* from include/linux/writeback.h */
/*
 * A control structure which tells the writeback code what to do.  These are
 * always on the stack, and hence need no locking.  They are always initialised
 * in a manner such that unspecified fields are set to zero.
 */
struct writeback_control {
    long nr_to_write;        /* Write this many pages, and decrement
                       this for each page written */
    long pages_skipped;        /* Pages which were not written */

    /*
     * For a_ops->writepages(): if start or end are non-zero then this is
     * a hint that the filesystem need only write out the pages inside that
     * byterange.  The byte at `end' is included in the writeout request.
     */
    loff_t range_start;
    loff_t range_end;

    enum writeback_sync_modes sync_mode;

    unsigned for_kupdate:1;        /* A kupdate writeback */
    unsigned for_background:1;    /* A background writeback */
    unsigned tagged_writepages:1;    /* tag-and-write to avoid livelock */
    unsigned for_reclaim:1;        /* Invoked from the page allocator */
    unsigned range_cyclic:1;    /* range_start is cyclic */
    unsigned for_sync:1;        /* sync(2) WB_SYNC_ALL writeback */
};


typedef int irqreturn_t;

struct timer_list {};
struct notifier_block {};

typedef unsigned long dmaaddr_t;

#define pm_runtime_get_sync(dev) do {} while (0)
#define pm_runtime_put(dev) do {} while (0)
#define pm_runtime_put_sync(dev) do {} while (0)
#define pm_runtime_use_autosuspend(dev) do {} while (0)
#define pm_runtime_set_autosuspend_delay(dev, delay) do {} while (0)
#define pm_runtime_enable(dev) do {} while (0)

#define IRQ_NONE        0
#define IRQ_HANDLED     1
#define IRQ_WAKE_THREAD 2

#define dev_set_drvdata(dev, data) do {} while (0)

#define disable_irq_wake(irq) do {} while (0)
#define enable_irq_wake(irq) -EINVAL
#define free_irq(irq, data) do {} while (0)
#define request_irq(nr, f, flags, nm, data) 0


#define __constant_cpu_to_le16(x) ((__le16)(__u16)(x))

#define cpu_relax() do {} while (0)

#ifndef unlikely
#define unlikely(cond) (cond)
#endif
#ifndef likely
#define likely(cond) (cond)
#endif




/// mark as unused for prevent compiler warning
#ifndef USB_UNUSED
#define USB_UNUSED(var) (void)(var)
#endif


////linux/bug.h

#define BUG() do { \
    pr_info("BUG at :%d/%s()!\n",  __LINE__, __func__); \
} while (0)

#define BUG_ON(condition) do { if (condition) BUG(); } while (0)

#define WARN_ON(condition) ({                        \
    if (condition == 1)                    \
        pr_info("WARNING at :%d/%s()!\n",  __LINE__, __func__); \
})


/*
 * You can initialize platform's USB host or device
 * ports by passing this enum as an argument to
 * board_usb_init().
 */
enum usb_init_type {
    USB_INIT_HOST,
    USB_INIT_DEVICE
};


int usb_lowlevel_init(int index, enum usb_init_type init, void **controller);
int usb_lowlevel_stop(int index);

/*
 * board-specific hardware initialization, called by
 * usb drivers and u-boot commands
 *
 * @param index USB controller number
 * @param init initializes controller as USB host or device
 */
int board_usb_init(int index, enum usb_init_type init);

/*
 * can be used to clean up after failed USB initialization attempt
 * vide: board_usb_init()
 *
 * @param index USB controller number for selective cleanup
 * @param init usb_init_type passed to board_usb_init()
 */
int board_usb_cleanup(int index, enum usb_init_type init);



////include\linux\unaligned\le_byteshift.h
static inline void __put_unaligned_le16(u16 val, u8 *p)
{
    *p++ = val;
    *p++ = val >> 8;
}

static inline void put_unaligned_le16(u16 val, void *p)
{
    __put_unaligned_le16(val, p);
}

unsigned long simple_strtoul(const char *cp, char **endp,
                unsigned int base);

static inline void *kmemdup(const void *src, size_t len)
{
    void *p;

    p = HV_MALLOC(len);
    if (p)
        HV_MEMCPY(p, src, len);
    return p;
}


#define WARN(condition, fmt, args...) ({    \
    int ret_warn = !!condition;        \
    if (ret_warn)                \
        pr_info(fmt, ##args);        \
    ret_warn; })

#define device_init_wakeup(dev, a) do {} while (0)

#define platform_data device_data

#ifndef wmb
#define wmb()        asm volatile (""   : : : "memory")
#endif

#define msleep(a)    udelay(a * 1000)

/*
 * Map U-Boot config options to Linux ones
 */

#define __set_bit generic_set_bit

#ifndef max_usb
#define max_usb(a, b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min_usb
#define min_usb(a, b) (((a) < (b)) ? (a) : (b))
#endif


#define min_t_usb(type, x, y) ({      \
    type __min1 = (x);            \
    type __min2 = (y);            \
    __min1 < __min2 ? __min1: __min2; })

#define max_t_usb(type, x, y) ({      \
    type __max1 = (x);            \
    type __max2 = (y);            \
    __max1 > __max2 ? __max1: __max2; })

static inline int ffs_me(int x)
{
    int r = 1;

    if (!x)
        return 0;
    if (!(x & 0xffff)) {
        x >>= 16;
        r += 16;
    }
    if (!(x & 0xff)) {
        x >>= 8;
        r += 8;
    }
    if (!(x & 0xf)) {
        x >>= 4;
        r += 4;
    }
    if (!(x & 3)) {
        x >>= 2;
        r += 2;
    }
    if (!(x & 1)) {
        x >>= 1;
        r += 1;
    }
    return r;
}



#define BITS_PER_LONG       32
#define BIT_MASK(nr)        (1UL << ((nr) % BITS_PER_LONG))
#define BIT_WORD(nr)        ((nr) / BITS_PER_LONG)


#define DIV_ROUND_UP(n,d)   (((n) + (d) - 1) / (d))

#define BITS_PER_BYTE        8
#define BITS_TO_LONGS(nr)    DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))


/**
 * __set_bit - Set a bit in memory
 * @nr: the bit to set
 * @addr: the address to start counting from
 *
 * Unlike set_bit(), this function is non-atomic and may be reordered.
 * If it's called on the same region of memory simultaneously, the effect
 * may be that only one operation succeeds.
 */
static inline void generic_set_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);

    *p  |= mask;
}

static inline void generic_clear_bit(int nr, volatile unsigned long *addr)
{
    unsigned long mask = BIT_MASK(nr);
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);

    *p &= ~mask;
}

static inline int test_bit(int nr, const void *addr)
{
    return ((unsigned char *)addr)[nr >> 3] & (1u << (nr & 7));
}


/* common */
#define DECLARE_BITMAP(name, bits) \
    unsigned long name[BITS_TO_LONGS(bits)]

#define small_const_nbits(nbits) \
    (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)

static inline void bitmap_zero(unsigned long *dst, int nbits)
{
    if (small_const_nbits(nbits))
        *dst = 0UL;
    else {
        int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
        HV_MEMSET(dst, 0, len);
    }
}

#define dma_cache_maint(addr, size, mode) cache_flush()
void cache_flush(void);


#endif