#include <stdint.h>
#include <Hal/AA64/aa64cpu.h>
#include <Mm/kmalloc.h>
#include <_null.h>
#include <Hal/AA64/aa64lowlevel.h>
#include <linux/build_bug.h>
#include <linux/irqreturn.h>
#include <linux/compiler.h>
#include <linux/log2.h>
#include <linux/math.h>
#include <linux/minmax.h>
#include <linux/string.h>
#include <linux/sprintf.h>
#include <linux/bitmap.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <linux/usb/ch9.h>
#include <linux/usb/otg.h>
#include <linux/virtio.h>
#include <linux/kconfig.h>
#include <linux/kstrtox.h>

Include dependency graph for kernel.h:

Classes
struct	timespec64

Macros
#define	udelay(us) AA64SleepUS(us)

#define	mdelay(ms) AA64SleepMS(ms)

#define	msleep(ms) mdelay(ms)

#define	usleep(us) AA64SleepUS(us)

#define	GFP_KERNEL 0

#define	GFP_ATOMIC 1

#define	GFP_DMA 2

#define	GFP_NOWAIT 1

#define	__GFP_ACCOUNT 0

#define	__GFP_BITS_SHIFT 26

#define	container_of(ptr, type, member) ((type)((char)(ptr)- offsetof(type,member)))

#define	offsetof(type, member) ((size_t)&((type*)0)->member)

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

#define	spin_lock_init(l) do{} while(0)

#define	spin_lock_irqsave(l, f) do{(f) = 0;}while(0)

#define	spin_unlock_irqrestore(l, f) do{}while(0)

#define	mutex_init(m) do{} while(0)

#define	mutex_lock(m) do{}while(0)

#define	mutex_unlock(m) do{} while(0)

#define	__iomem

#define	__user

#define	__kernel

#define	__force

#define	__nocast

#define	__safe

#define	__aligned(x) __attribute__((aligned(x)))

#define	__chk_user_ptr(x) (void)0

#define	__chk_io_ptr(x) (void)0

#define	EPERM 1

#define	ENOENT 2

#define	EIO 5

#define	ENOMEM 12

#define	EBUSY 16

#define	ENXIO 6

#define	E2BIG 7

#define	EPROBE_DEFER 517

#define	EL3HLT 46

#define	ENODEV 19

#define	EINVAL 22

#define	ENOSPC 28

#define	ETIMEDOUT 110

#define	ENOTSUPP 524

#define	ERESTARTSYS 512

#define	MAX_ERRNO 4095

#define	IS_ERR_VALUE(x) ((x) >= (uintptr_t)-MAX_ERRNO)

#define	EDEADLK 35

#define	ENAMETOOLONG 36

#define	ENOLCK 37

#define	ENOSYS 38

#define	ENOTEMPTY 39

#define	ELOOP 40

#define	EAGAIN 11

#define	EWOULDBLOCK EAGAIN

#define	ENOMSG 42

#define	EIDRM 43

#define	ENOSTR 60

#define	ENODATA 61

#define	ETIME 62

#define	ENOSR 63

#define	EREMOTE 66

#define	ENOLINK 67

#define	EPROTO 71

#define	EMULTIHOP 72

#define	EBADMSG 74

#define	EOVERFLOW 75

#define	EILSEQ 84

#define	EUSERS 87

#define	ENOTSOCK 88

#define	EDESTADDRREQ 89

#define	EMSGSIZE 90

#define	ENOPROTOOPT 92

#define	EPROTONOSUPPORT 93

#define	ESOCKTNOSUPPORT 94

#define	EOPNOTSUPP 95

#define	EAFNOSUPPORT 97

#define	EADDRINUSE 98

#define	EADDRNOTAVAIL 99

#define	ENETDOWN 100

#define	ENETUNREACH 101

#define	ENETRESET 102

#define	ECONNABORTED 103

#define	ECONNRESET 104

#define	ENOBUFS 105

#define	EISCONN 106

#define	ENOTCONN 107

#define	ESHUTDOWN 108

#define	ETOOMANYREGS 109

#define	ECONNREFUSED 111

#define	EHOSTDOWN 112

#define	readb(addr) ((volatile u8)((uint8_t*)addr))

#define	readw(addr) ((volatile u16)((uint8_t*)addr))

#define	readl(addr) ((volatile u32)((uint8_t*)addr))

#define	writeb(v, addr) ((volatile u8)((uint8_t*)addr) = (v))

#define	writew(v, addr) ((volatile u16)((uint8_t*)addr) = (v))

#define	writel(v, addr) ((volatile u32)((uint8_t*)addr) = (v))

#define	BITS_PER_BYTE 8

#define	BITS_PER_LONG 32

#define	BIT(n) (1UL << (n))

#define	BIT_ULL(n) (1ULL << (n))

#define	GENMASK(h, l) (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG-1-(h))))

#define	GENMASK_ULL(h, l) (((~0ULL) << (l)) & (~0ULL >> (63-(h))))

#define	NSEC_PER_USEC 1000LL

#define	NSEC_PER_MSEC 1000000LL

#define	NSEC_PER_SEC 1000000000LL

#define	USEC_PER_MSEC 1000LL

#define	USEC_PER_SEC 1000000LL

#define	MSEC_PER_SEC 1000LL

#define	KTIME_MAX ((ktime_t)~((uint64_t)1<<63))

#define	KTIME_MIN (~KTIME_MAX - 1)

#define	KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)

#define	TK_OFFS_BOOT 0

#define	ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

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

#define	ALIGN(x, a) __ALIGN_KERNEL((x), (a))

#define	__ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)

#define	__ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask))

#define	MIN(a, b) ((a) < (b) ? (a) : (b))

#define	MAX(a, b) ((a) > (b) ? (a) : (b))

#define	clamp(val, lo, hi) ((val) < (lo) ? (lo) : ((val) > (hi) ? (hi) : (val)))

#define	BUILD_BUG_ON(cond) ((void)sizeof(char[1 - 2 * !!(cond)]))

#define	upper_32_bits(n) ((uint32_t)((n) >> 32))

#define	lower_32_bits(n) ((uint32_t)((n) & 0xFFFFFFFF))

#define	READ_ONCE(x) __atomic_load_n(&(x), __ATOMIC_RELAXED)

#define	WRITE_ONCE(x, val) __atomic_store_n(&(x), (val), __ATOMIC_RELAXED)

#define	smp_load_acquire(p) __atomic_load_n((p), __ATOMIC_ACQUIRE)

#define	smp_store_release(p, v) __atomic_store_n((p), (v), __ATOMIC_RELEASE)

#define	smp_mb() __atomic_thread_fence(__ATOMIC_SEQ_CST)

#define	smp_rmb() __atomic_thread_fence(__ATOMIC_ACQUIRE)

#define	smp_wmb() __atomic_thread_fence(__ATOMIC_RELEASE)

#define	WARN(cond, fmt, ...)

#define	WARN_ON_ONCE(cond)

#define	__randomize_layout

#define	xchg(ptr, v) __atomic_exchange_n((ptr), (v), __ATOMIC_SEQ_CST)

#define	BUG() panic("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__)

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

#define	__strscpy_2(dst, src, ...) sized_strscpy(dst, src, sizeof(dst))

#define	__strscpy_3(dst, src, size) sized_strscpy(dst, src, size)

#define	__strscpy_sel(_1, N, ...) N

#define	__strscpy_args(...) __strscpy_sel(__VA_OPT__(__VA_ARGS__, __strscpy_3) , __strscpy_2)

#define	strscpy(dst, src, ...) __strscpy_args(__VA_ARGS__)(dst, src, __VA_ARGS__)

Typedefs
typedef uint8_t	u8

typedef uint16_t	u16

typedef uint32_t	u32

typedef uint64_t	u64

typedef int8_t	s8

typedef int16_t	s16

typedef int32_t	s32

typedef int64_t	s64

typedef uint8_t	__u8

typedef uint16_t	__u16

typedef uint32_t	__u32

typedef uint64_t	__u64

typedef int8_t	__s8

typedef int16_t	__s16

typedef int32_t	__s32

typedef int64_t	__s64

typedef uint8_t	__le8

typedef uint16_t	__le16

typedef uint32_t	__le32

typedef uint64_t	__le64

typedef uint16_t	__be16

typedef uint32_t	__be32

typedef uint64_t	__be64

typedef uintptr_t	phys_addr_t

typedef uintptr_t	resource_size_t

typedef uintptr_t	dma_addr_t

typedef uintptr_t	io_addr_t

typedef int	spinlock_t

typedef int	mutex

typedef uint64_t	sector_t

typedef uint64_t	blkcnt_t

typedef uint64_t	loff_t

typedef uint32_t	uid_t

typedef uint32_t	gid_t

typedef uint32_t	dev_t

typedef uint32_t	ino_t

typedef uint32_t	nlink_t

typedef unsigned int	gfp_t

typedef unsigned int	fmode_t

typedef unsigned int	umode_t

typedef unsigned long	irq_hw_number_t

typedef unsigned long	pgoff_t

typedef unsigned long	kernel_ulong_t

typedef int64_t	ktime_t

Functions
void	dump_stack (void)

Variables
int	oops_in_progress

Macro Definition Documentation

◆ __ALIGN_KERNEL

#define __ALIGN_KERNEL	(	x,
		a
	)	__ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)

◆ __ALIGN_KERNEL_MASK

#define __ALIGN_KERNEL_MASK	(	x,
		mask
	)	(((x) + (mask)) & ~(mask))

◆ __aligned

#define __aligned ( x ) __attribute__((aligned(x)))

◆ __chk_io_ptr

#define __chk_io_ptr ( x ) (void)0

◆ __chk_user_ptr

#define __chk_user_ptr ( x ) (void)0

◆ __force

#define __force

◆ __GFP_ACCOUNT

#define __GFP_ACCOUNT 0

◆ __GFP_BITS_SHIFT

#define __GFP_BITS_SHIFT 26

◆ __iomem

#define __iomem

◆ __kernel

#define __kernel

◆ __nocast

#define __nocast

◆ __randomize_layout

#define __randomize_layout

◆ __safe

#define __safe

◆ __strscpy_2

#define __strscpy_2	(	dst,
		src,
		...
	)	sized_strscpy(dst, src, sizeof(dst))

◆ __strscpy_3

#define __strscpy_3	(	dst,
		src,
		size
	)	sized_strscpy(dst, src, size)

◆ __strscpy_args

#define __strscpy_args ( ... ) __strscpy_sel(__VA_OPT__(__VA_ARGS__, __strscpy_3) , __strscpy_2)

◆ __strscpy_sel

#define __strscpy_sel	(	_1,
		N,
		...
	)	N

◆ __user

#define __user

◆ ALIGN

#define ALIGN	(	x,
		a
	)	__ALIGN_KERNEL((x), (a))

◆ ARRAY_SIZE

#define ARRAY_SIZE ( a ) (sizeof(a) / sizeof((a)[0]))

◆ BIT

#define BIT ( n ) (1UL << (n))

◆ BIT_ULL

#define BIT_ULL ( n ) (1ULL << (n))

◆ BITS_PER_BYTE

#define BITS_PER_BYTE 8

◆ BITS_PER_LONG

#define BITS_PER_LONG 32

◆ BUG

#define BUG ( ) panic("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__)

◆ BUG_ON

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

◆ BUILD_BUG_ON

#define BUILD_BUG_ON ( cond ) ((void)sizeof(char[1 - 2 * !!(cond)]))

◆ clamp

#define clamp	(	val,
		lo,
		hi
	)	((val) < (lo) ? (lo) : ((val) > (hi) ? (hi) : (val)))

◆ container_of

#define container_of	(	ptr,
		type,
		member
	)	((type)((char)(ptr)- offsetof(type,member)))

◆ DIV_ROUND_UP

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

◆ E2BIG

#define E2BIG 7

◆ EADDRINUSE

#define EADDRINUSE 98

◆ EADDRNOTAVAIL

#define EADDRNOTAVAIL 99

◆ EAFNOSUPPORT

#define EAFNOSUPPORT 97

◆ EAGAIN

#define EAGAIN 11

◆ EBADMSG

#define EBADMSG 74

◆ EBUSY

#define EBUSY 16

◆ ECONNABORTED

#define ECONNABORTED 103

◆ ECONNREFUSED

#define ECONNREFUSED 111

◆ ECONNRESET

#define ECONNRESET 104

◆ EDEADLK

#define EDEADLK 35

◆ EDESTADDRREQ

#define EDESTADDRREQ 89

◆ EHOSTDOWN

#define EHOSTDOWN 112

◆ EIDRM

#define EIDRM 43

◆ EILSEQ

#define EILSEQ 84

◆ EINVAL

#define EINVAL 22

◆ EIO

#define EIO 5

◆ EISCONN

#define EISCONN 106

◆ EL3HLT

#define EL3HLT 46

◆ ELOOP

#define ELOOP 40

◆ EMSGSIZE

#define EMSGSIZE 90

◆ EMULTIHOP

#define EMULTIHOP 72

◆ ENAMETOOLONG

#define ENAMETOOLONG 36

◆ ENETDOWN

#define ENETDOWN 100

◆ ENETRESET

#define ENETRESET 102

◆ ENETUNREACH

#define ENETUNREACH 101

◆ ENOBUFS

#define ENOBUFS 105

◆ ENODATA

#define ENODATA 61

◆ ENODEV

#define ENODEV 19

◆ ENOENT

#define ENOENT 2

◆ ENOLCK

#define ENOLCK 37

◆ ENOLINK

#define ENOLINK 67

◆ ENOMEM

#define ENOMEM 12

◆ ENOMSG

#define ENOMSG 42

◆ ENOPROTOOPT

#define ENOPROTOOPT 92

◆ ENOSPC

#define ENOSPC 28

◆ ENOSR

#define ENOSR 63

◆ ENOSTR

#define ENOSTR 60

◆ ENOSYS

#define ENOSYS 38

◆ ENOTCONN

#define ENOTCONN 107

◆ ENOTEMPTY

#define ENOTEMPTY 39

◆ ENOTSOCK

#define ENOTSOCK 88

◆ ENOTSUPP

#define ENOTSUPP 524

◆ ENXIO

#define ENXIO 6

◆ EOPNOTSUPP

#define EOPNOTSUPP 95

◆ EOVERFLOW

#define EOVERFLOW 75

◆ EPERM

#define EPERM 1

◆ EPROBE_DEFER

#define EPROBE_DEFER 517

◆ EPROTO

#define EPROTO 71

◆ EPROTONOSUPPORT

#define EPROTONOSUPPORT 93

◆ EREMOTE

#define EREMOTE 66

◆ ERESTARTSYS

#define ERESTARTSYS 512

◆ ESHUTDOWN

#define ESHUTDOWN 108

◆ ESOCKTNOSUPPORT

#define ESOCKTNOSUPPORT 94

◆ ETIME

#define ETIME 62

◆ ETIMEDOUT

#define ETIMEDOUT 110

◆ ETOOMANYREGS

#define ETOOMANYREGS 109

◆ EUSERS

#define EUSERS 87

◆ EWOULDBLOCK

#define EWOULDBLOCK EAGAIN

◆ GENMASK

#define GENMASK	(	h,
		l
	)	(((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG-1-(h))))

◆ GENMASK_ULL

#define GENMASK_ULL	(	h,
		l
	)	(((~0ULL) << (l)) & (~0ULL >> (63-(h))))

◆ GFP_ATOMIC

#define GFP_ATOMIC 1

◆ GFP_DMA

#define GFP_DMA 2

◆ GFP_KERNEL

#define GFP_KERNEL 0

◆ GFP_NOWAIT

#define GFP_NOWAIT 1

◆ IS_ERR_VALUE

#define IS_ERR_VALUE ( x ) ((x) >= (uintptr_t)-MAX_ERRNO)

◆ KTIME_MAX

#define KTIME_MAX ((ktime_t)~((uint64_t)1<<63))

◆ KTIME_MIN

#define KTIME_MIN (~KTIME_MAX - 1)

◆ KTIME_SEC_MAX

#define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)

◆ lower_32_bits

#define lower_32_bits ( n ) ((uint32_t)((n) & 0xFFFFFFFF))

◆ MAX

#define MAX	(	a,
		b
	)	((a) > (b) ? (a) : (b))

◆ MAX_ERRNO

#define MAX_ERRNO 4095

◆ mdelay

#define mdelay ( ms ) AA64SleepMS(ms)

◆ might_sleep

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

◆ MIN

#define MIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

◆ MSEC_PER_SEC

#define MSEC_PER_SEC 1000LL

◆ msleep

#define msleep ( ms ) mdelay(ms)

◆ mutex_init

#define mutex_init ( m ) do{} while(0)

◆ mutex_lock

#define mutex_lock ( m ) do{}while(0)

◆ mutex_unlock

#define mutex_unlock ( m ) do{} while(0)

◆ NSEC_PER_MSEC

#define NSEC_PER_MSEC 1000000LL

◆ NSEC_PER_SEC

#define NSEC_PER_SEC 1000000000LL

◆ NSEC_PER_USEC

#define NSEC_PER_USEC 1000LL

◆ offsetof

#define offsetof	(	type,
		member
	)	((size_t)&((type*)0)->member)

◆ READ_ONCE

#define READ_ONCE ( x ) __atomic_load_n(&(x), __ATOMIC_RELAXED)

◆ readb

#define readb ( addr ) (*(volatile u8*)((uint8_t*)addr))

◆ readl

#define readl ( addr ) (*(volatile u32*)((uint8_t*)addr))

◆ readw

#define readw ( addr ) (*(volatile u16*)((uint8_t*)addr))

◆ smp_load_acquire

#define smp_load_acquire ( p ) __atomic_load_n((p), __ATOMIC_ACQUIRE)

◆ smp_mb

#define smp_mb ( ) __atomic_thread_fence(__ATOMIC_SEQ_CST)

◆ smp_rmb

#define smp_rmb ( ) __atomic_thread_fence(__ATOMIC_ACQUIRE)

◆ smp_store_release

#define smp_store_release	(	p,
		v
	)	__atomic_store_n((p), (v), __ATOMIC_RELEASE)

◆ smp_wmb

#define smp_wmb ( ) __atomic_thread_fence(__ATOMIC_RELEASE)

◆ spin_lock_init

#define spin_lock_init ( l ) do{} while(0)

◆ spin_lock_irqsave

#define spin_lock_irqsave	(	l,
		f
	)	do{(f) = 0;}while(0)

◆ spin_unlock_irqrestore

#define spin_unlock_irqrestore	(	l,
		f
	)	do{}while(0)

◆ strscpy

#define strscpy	(	dst,
		src,
		...
	)	__strscpy_args(__VA_ARGS__)(dst, src, __VA_ARGS__)

◆ TK_OFFS_BOOT

#define TK_OFFS_BOOT 0

◆ udelay

#define udelay ( us ) AA64SleepUS(us)

◆ upper_32_bits

#define upper_32_bits ( n ) ((uint32_t)((n) >> 32))

◆ USEC_PER_MSEC

#define USEC_PER_MSEC 1000LL

◆ USEC_PER_SEC

#define USEC_PER_SEC 1000000LL

◆ usleep

#define usleep ( us ) AA64SleepUS(us)

◆ WARN

#define WARN	(	cond,
		fmt,
		...
	)

Value:

    ({                              \
        int __wret = !!(cond);                  \
        if (__wret)                     \
            UARTDebugOut("[WARN] " fmt " (%s:%d)\r\n",  \
                ##__VA_ARGS__, __FILE__, __LINE__); \
        __wret;                         \
    })

◆ WARN_ON_ONCE

#define WARN_ON_ONCE ( cond )

Value:

    ({                              \
        static int __warned_once;               \
        int __wret = !!(cond);                  \
        if (__wret && !__warned_once) {             \
            __warned_once = 1;              \
            UARTDebugOut("[WARN] %s:%d\r\n",        \
                __FILE__, __LINE__);            \
        }                           \
        __wret;                         \
    })