GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
@@ -0,0 +1,262 @@
|
||||
#ifndef _ASM_GENERIC_ATOMIC_LONG_H
|
||||
#define _ASM_GENERIC_ATOMIC_LONG_H
|
||||
/*
|
||||
* Copyright (C) 2005 Silicon Graphics, Inc.
|
||||
* Christoph Lameter
|
||||
*
|
||||
* Allows to provide arch independent atomic definitions without the need to
|
||||
* edit all arch specific atomic.h files.
|
||||
*/
|
||||
|
||||
#include <asm/types.h>
|
||||
|
||||
/*
|
||||
* Suppport for atomic_long_t
|
||||
*
|
||||
* Casts for parameters are avoided for existing atomic functions in order to
|
||||
* avoid issues with cast-as-lval under gcc 4.x and other limitations that the
|
||||
* macros of a platform may have.
|
||||
*/
|
||||
|
||||
#if BITS_PER_LONG == 64
|
||||
|
||||
typedef atomic64_t atomic_long_t;
|
||||
|
||||
#define ATOMIC_LONG_INIT(i) ATOMIC64_INIT(i)
|
||||
|
||||
static inline long atomic_long_read(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_read(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_set(atomic_long_t *l, long i)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
atomic64_set(v, i);
|
||||
}
|
||||
|
||||
static inline void atomic_long_inc(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
atomic64_inc(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_dec(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
atomic64_dec(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_add(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
atomic64_add(i, v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_sub(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
atomic64_sub(i, v);
|
||||
}
|
||||
|
||||
#ifndef __UBOOT__
|
||||
static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return atomic64_sub_and_test(i, v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_dec_and_test(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return atomic64_dec_and_test(v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_inc_and_test(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return atomic64_inc_and_test(v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_add_negative(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return atomic64_add_negative(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_add_return(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_add_return(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_sub_return(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_sub_return(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_inc_return(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_inc_return(v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_dec_return(atomic_long_t *l)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_dec_return(v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
|
||||
{
|
||||
atomic64_t *v = (atomic64_t *)l;
|
||||
|
||||
return (long)atomic64_add_unless(v, a, u);
|
||||
}
|
||||
|
||||
#define atomic_long_inc_not_zero(l) atomic64_inc_not_zero((atomic64_t *)(l))
|
||||
|
||||
#define atomic_long_cmpxchg(l, old, new) \
|
||||
(atomic64_cmpxchg((atomic64_t *)(l), (old), (new)))
|
||||
#define atomic_long_xchg(v, new) \
|
||||
(atomic64_xchg((atomic64_t *)(v), (new)))
|
||||
#endif /* __UBOOT__ */
|
||||
|
||||
#else /* BITS_PER_LONG == 64 */
|
||||
|
||||
typedef atomic_t atomic_long_t;
|
||||
|
||||
#define ATOMIC_LONG_INIT(i) ATOMIC_INIT(i)
|
||||
static inline long atomic_long_read(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_read(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_set(atomic_long_t *l, long i)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
atomic_set(v, i);
|
||||
}
|
||||
|
||||
static inline void atomic_long_inc(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
atomic_inc(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_dec(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
atomic_dec(v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_add(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
atomic_add(i, v);
|
||||
}
|
||||
|
||||
static inline void atomic_long_sub(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
atomic_sub(i, v);
|
||||
}
|
||||
|
||||
#ifndef __UBOOT__
|
||||
static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return atomic_sub_and_test(i, v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_dec_and_test(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return atomic_dec_and_test(v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_inc_and_test(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return atomic_inc_and_test(v);
|
||||
}
|
||||
|
||||
static inline int atomic_long_add_negative(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return atomic_add_negative(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_add_return(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_add_return(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_sub_return(long i, atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_sub_return(i, v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_inc_return(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_inc_return(v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_dec_return(atomic_long_t *l)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_dec_return(v);
|
||||
}
|
||||
|
||||
static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
|
||||
{
|
||||
atomic_t *v = (atomic_t *)l;
|
||||
|
||||
return (long)atomic_add_unless(v, a, u);
|
||||
}
|
||||
|
||||
#define atomic_long_inc_not_zero(l) atomic_inc_not_zero((atomic_t *)(l))
|
||||
|
||||
#define atomic_long_cmpxchg(l, old, new) \
|
||||
(atomic_cmpxchg((atomic_t *)(l), (old), (new)))
|
||||
#define atomic_long_xchg(v, new) \
|
||||
(atomic_xchg((atomic_t *)(v), (new)))
|
||||
#endif /* __UBOOT__ */
|
||||
|
||||
#endif /* BITS_PER_LONG == 64 */
|
||||
|
||||
#endif /* _ASM_GENERIC_ATOMIC_LONG_H */
|
||||
@@ -0,0 +1,150 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
|
||||
#ifndef _ASM_GENERIC_ATOMIC_H
|
||||
#define _ASM_GENERIC_ATOMIC_H
|
||||
|
||||
typedef struct { volatile int counter; } atomic_t;
|
||||
#if BITS_PER_LONG == 32
|
||||
typedef struct { volatile long long counter; } atomic64_t;
|
||||
#else /* BIT_PER_LONG == 32 */
|
||||
typedef struct { volatile long counter; } atomic64_t;
|
||||
#endif
|
||||
|
||||
#define ATOMIC_INIT(i) { (i) }
|
||||
|
||||
#define atomic_read(v) ((v)->counter)
|
||||
#define atomic_set(v, i) ((v)->counter = (i))
|
||||
#define atomic64_read(v) atomic_read(v)
|
||||
#define atomic64_set(v, i) atomic_set(v, i)
|
||||
|
||||
static inline void atomic_add(int i, atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter += i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic_sub(int i, atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter -= i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic_inc(atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
++v->counter;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic_dec(atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
--v->counter;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline int atomic_dec_and_test(volatile atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
int val;
|
||||
|
||||
local_irq_save(flags);
|
||||
val = v->counter;
|
||||
v->counter = val -= 1;
|
||||
local_irq_restore(flags);
|
||||
|
||||
return val == 0;
|
||||
}
|
||||
|
||||
static inline int atomic_add_negative(int i, volatile atomic_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
int val;
|
||||
|
||||
local_irq_save(flags);
|
||||
val = v->counter;
|
||||
v->counter = val += i;
|
||||
local_irq_restore(flags);
|
||||
|
||||
return val < 0;
|
||||
}
|
||||
|
||||
static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
*addr &= ~mask;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
#if BITS_PER_LONG == 32
|
||||
|
||||
static inline void atomic64_add(long long i, volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter += i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic64_sub(long long i, volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter -= i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
#else /* BIT_PER_LONG == 32 */
|
||||
|
||||
static inline void atomic64_add(long i, volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter += i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic64_sub(long i, volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter -= i;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline void atomic64_inc(volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter += 1;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static inline void atomic64_dec(volatile atomic64_t *v)
|
||||
{
|
||||
unsigned long flags = 0;
|
||||
|
||||
local_irq_save(flags);
|
||||
v->counter -= 1;
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
#ifndef _ASM_GENERIC_BITOPS___FFS_H_
|
||||
#define _ASM_GENERIC_BITOPS___FFS_H_
|
||||
|
||||
#include <asm/types.h>
|
||||
|
||||
/**
|
||||
* __ffs - find first bit in word.
|
||||
* @word: The word to search
|
||||
*
|
||||
* Undefined if no bit exists, so code should check against 0 first.
|
||||
*/
|
||||
static __always_inline unsigned long __ffs(unsigned long word)
|
||||
{
|
||||
int num = 0;
|
||||
|
||||
#if BITS_PER_LONG == 64
|
||||
if ((word & 0xffffffff) == 0) {
|
||||
num += 32;
|
||||
word >>= 32;
|
||||
}
|
||||
#endif
|
||||
if ((word & 0xffff) == 0) {
|
||||
num += 16;
|
||||
word >>= 16;
|
||||
}
|
||||
if ((word & 0xff) == 0) {
|
||||
num += 8;
|
||||
word >>= 8;
|
||||
}
|
||||
if ((word & 0xf) == 0) {
|
||||
num += 4;
|
||||
word >>= 4;
|
||||
}
|
||||
if ((word & 0x3) == 0) {
|
||||
num += 2;
|
||||
word >>= 2;
|
||||
}
|
||||
if ((word & 0x1) == 0)
|
||||
num += 1;
|
||||
return num;
|
||||
}
|
||||
|
||||
#endif /* _ASM_GENERIC_BITOPS___FFS_H_ */
|
||||
@@ -0,0 +1,43 @@
|
||||
#ifndef _ASM_GENERIC_BITOPS___FLS_H_
|
||||
#define _ASM_GENERIC_BITOPS___FLS_H_
|
||||
|
||||
#include <asm/types.h>
|
||||
|
||||
/**
|
||||
* __fls - find last (most-significant) set bit in a long word
|
||||
* @word: the word to search
|
||||
*
|
||||
* Undefined if no set bit exists, so code should check against 0 first.
|
||||
*/
|
||||
static __always_inline unsigned long __fls(unsigned long word)
|
||||
{
|
||||
int num = BITS_PER_LONG - 1;
|
||||
|
||||
#if BITS_PER_LONG == 64
|
||||
if (!(word & (~0ul << 32))) {
|
||||
num -= 32;
|
||||
word <<= 32;
|
||||
}
|
||||
#endif
|
||||
if (!(word & (~0ul << (BITS_PER_LONG-16)))) {
|
||||
num -= 16;
|
||||
word <<= 16;
|
||||
}
|
||||
if (!(word & (~0ul << (BITS_PER_LONG-8)))) {
|
||||
num -= 8;
|
||||
word <<= 8;
|
||||
}
|
||||
if (!(word & (~0ul << (BITS_PER_LONG-4)))) {
|
||||
num -= 4;
|
||||
word <<= 4;
|
||||
}
|
||||
if (!(word & (~0ul << (BITS_PER_LONG-2)))) {
|
||||
num -= 2;
|
||||
word <<= 2;
|
||||
}
|
||||
if (!(word & (~0ul << (BITS_PER_LONG-1))))
|
||||
num -= 1;
|
||||
return num;
|
||||
}
|
||||
|
||||
#endif /* _ASM_GENERIC_BITOPS___FLS_H_ */
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef _ASM_GENERIC_BITOPS_FLS_H_
|
||||
#define _ASM_GENERIC_BITOPS_FLS_H_
|
||||
|
||||
/**
|
||||
* fls - find last (most-significant) bit set
|
||||
* @x: the word to search
|
||||
*
|
||||
* This is defined the same way as ffs.
|
||||
* Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
|
||||
*/
|
||||
|
||||
static __always_inline int fls(int x)
|
||||
{
|
||||
int r = 32;
|
||||
|
||||
if (!x)
|
||||
return 0;
|
||||
if (!(x & 0xffff0000u)) {
|
||||
x <<= 16;
|
||||
r -= 16;
|
||||
}
|
||||
if (!(x & 0xff000000u)) {
|
||||
x <<= 8;
|
||||
r -= 8;
|
||||
}
|
||||
if (!(x & 0xf0000000u)) {
|
||||
x <<= 4;
|
||||
r -= 4;
|
||||
}
|
||||
if (!(x & 0xc0000000u)) {
|
||||
x <<= 2;
|
||||
r -= 2;
|
||||
}
|
||||
if (!(x & 0x80000000u)) {
|
||||
x <<= 1;
|
||||
r -= 1;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* _ASM_GENERIC_BITOPS_FLS_H_ */
|
||||
@@ -0,0 +1,36 @@
|
||||
#ifndef _ASM_GENERIC_BITOPS_FLS64_H_
|
||||
#define _ASM_GENERIC_BITOPS_FLS64_H_
|
||||
|
||||
#include <asm/types.h>
|
||||
|
||||
/**
|
||||
* fls64 - find last set bit in a 64-bit word
|
||||
* @x: the word to search
|
||||
*
|
||||
* This is defined in a similar way as the libc and compiler builtin
|
||||
* ffsll, but returns the position of the most significant set bit.
|
||||
*
|
||||
* fls64(value) returns 0 if value is 0 or the position of the last
|
||||
* set bit if value is nonzero. The last (most significant) bit is
|
||||
* at position 64.
|
||||
*/
|
||||
#if BITS_PER_LONG == 32
|
||||
static __always_inline int fls64(__u64 x)
|
||||
{
|
||||
__u32 h = x >> 32;
|
||||
if (h)
|
||||
return fls(h) + 32;
|
||||
return fls(x);
|
||||
}
|
||||
#elif BITS_PER_LONG == 64
|
||||
static __always_inline int fls64(__u64 x)
|
||||
{
|
||||
if (x == 0)
|
||||
return 0;
|
||||
return __fls(x) + 1;
|
||||
}
|
||||
#else
|
||||
#error BITS_PER_LONG not 32 or 64
|
||||
#endif
|
||||
|
||||
#endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */
|
||||
@@ -0,0 +1,8 @@
|
||||
#ifndef __ASM_GENERIC_BITS_PER_LONG
|
||||
#define __ASM_GENERIC_BITS_PER_LONG
|
||||
|
||||
#ifndef BITS_PER_LONG_LONG
|
||||
#define BITS_PER_LONG_LONG 64
|
||||
#endif
|
||||
|
||||
#endif /* __ASM_GENERIC_BITS_PER_LONG */
|
||||
@@ -0,0 +1,173 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Copyright (c) 2012 The Chromium OS Authors.
|
||||
* (C) Copyright 2002-2010
|
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
*/
|
||||
|
||||
#ifndef __ASM_GENERIC_GBL_DATA_H
|
||||
#define __ASM_GENERIC_GBL_DATA_H
|
||||
/*
|
||||
* The following data structure is placed in some memory which is
|
||||
* available very early after boot (like DPRAM on MPC8xx/MPC82xx, or
|
||||
* some locked parts of the data cache) to allow for a minimum set of
|
||||
* global variables during system initialization (until we have set
|
||||
* up the memory controller so that we can use RAM).
|
||||
*
|
||||
* Keep it *SMALL* and remember to set GENERATED_GBL_DATA_SIZE > sizeof(gd_t)
|
||||
*
|
||||
* Each architecture has its own private fields. For now all are private
|
||||
*/
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
#include <fdtdec.h>
|
||||
#include <membuff.h>
|
||||
#include <linux/list.h>
|
||||
|
||||
typedef struct global_data {
|
||||
bd_t *bd;
|
||||
unsigned long flags;
|
||||
unsigned int baudrate;
|
||||
unsigned long cpu_clk; /* CPU clock in Hz! */
|
||||
unsigned long bus_clk;
|
||||
/* We cannot bracket this with CONFIG_PCI due to mpc5xxx */
|
||||
unsigned long pci_clk;
|
||||
unsigned long mem_clk;
|
||||
#if defined(CONFIG_LCD) || defined(CONFIG_VIDEO) || defined(CONFIG_DM_VIDEO)
|
||||
unsigned long fb_base; /* Base address of framebuffer mem */
|
||||
#endif
|
||||
#if defined(CONFIG_POST)
|
||||
unsigned long post_log_word; /* Record POST activities */
|
||||
unsigned long post_log_res; /* success of POST test */
|
||||
unsigned long post_init_f_time; /* When post_init_f started */
|
||||
#endif
|
||||
#ifdef CONFIG_BOARD_TYPES
|
||||
unsigned long board_type;
|
||||
#endif
|
||||
unsigned long have_console; /* serial_init() was called */
|
||||
#if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
|
||||
unsigned long precon_buf_idx; /* Pre-Console buffer index */
|
||||
#endif
|
||||
unsigned long env_addr; /* Address of Environment struct */
|
||||
unsigned long env_valid; /* Environment valid? enum env_valid */
|
||||
unsigned long env_has_init; /* Bitmask of boolean of struct env_location offsets */
|
||||
int env_load_prio; /* Priority of the loaded environment */
|
||||
|
||||
unsigned long ram_base; /* Base address of RAM used by U-Boot */
|
||||
unsigned long ram_top; /* Top address of RAM used by U-Boot */
|
||||
unsigned long relocaddr; /* Start address of U-Boot in RAM */
|
||||
phys_size_t ram_size; /* RAM size */
|
||||
unsigned long mon_len; /* monitor len */
|
||||
unsigned long irq_sp; /* irq stack pointer */
|
||||
unsigned long start_addr_sp; /* start_addr_stackpointer */
|
||||
unsigned long reloc_off;
|
||||
struct global_data *new_gd; /* relocated global data */
|
||||
|
||||
#ifdef CONFIG_DM
|
||||
struct udevice *dm_root; /* Root instance for Driver Model */
|
||||
struct udevice *dm_root_f; /* Pre-relocation root instance */
|
||||
struct list_head uclass_root; /* Head of core tree */
|
||||
#endif
|
||||
#ifdef CONFIG_TIMER
|
||||
struct udevice *timer; /* Timer instance for Driver Model */
|
||||
#endif
|
||||
|
||||
const void *fdt_blob; /* Our device tree, NULL if none */
|
||||
void *new_fdt; /* Relocated FDT */
|
||||
unsigned long fdt_size; /* Space reserved for relocated FDT */
|
||||
#ifdef CONFIG_OF_LIVE
|
||||
struct device_node *of_root;
|
||||
#endif
|
||||
|
||||
#if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
|
||||
const void *multi_dtb_fit; /* uncompressed multi-dtb FIT image */
|
||||
#endif
|
||||
struct jt_funcs *jt; /* jump table */
|
||||
char env_buf[32]; /* buffer for env_get() before reloc. */
|
||||
#ifdef CONFIG_TRACE
|
||||
void *trace_buff; /* The trace buffer */
|
||||
#endif
|
||||
#if defined(CONFIG_SYS_I2C)
|
||||
int cur_i2c_bus; /* current used i2c bus */
|
||||
#endif
|
||||
#ifdef CONFIG_SYS_I2C_MXC
|
||||
void *srdata[10];
|
||||
#endif
|
||||
unsigned int timebase_h;
|
||||
unsigned int timebase_l;
|
||||
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
|
||||
unsigned long malloc_base; /* base address of early malloc() */
|
||||
unsigned long malloc_limit; /* limit address */
|
||||
unsigned long malloc_ptr; /* current address */
|
||||
#endif
|
||||
#ifdef CONFIG_PCI
|
||||
struct pci_controller *hose; /* PCI hose for early use */
|
||||
phys_addr_t pci_ram_top; /* top of region accessible to PCI */
|
||||
#endif
|
||||
#ifdef CONFIG_PCI_BOOTDELAY
|
||||
int pcidelay_done;
|
||||
#endif
|
||||
struct udevice *cur_serial_dev; /* current serial device */
|
||||
struct arch_global_data arch; /* architecture-specific data */
|
||||
#ifdef CONFIG_CONSOLE_RECORD
|
||||
struct membuff console_out; /* console output */
|
||||
struct membuff console_in; /* console input */
|
||||
#endif
|
||||
#ifdef CONFIG_DM_VIDEO
|
||||
ulong video_top; /* Top of video frame buffer area */
|
||||
ulong video_bottom; /* Bottom of video frame buffer area */
|
||||
#endif
|
||||
#ifdef CONFIG_BOOTSTAGE
|
||||
struct bootstage_data *bootstage; /* Bootstage information */
|
||||
struct bootstage_data *new_bootstage; /* Relocated bootstage info */
|
||||
#endif
|
||||
#ifdef CONFIG_LOG
|
||||
int log_drop_count; /* Number of dropped log messages */
|
||||
int default_log_level; /* For devices with no filters */
|
||||
struct list_head log_head; /* List of struct log_device */
|
||||
int log_fmt; /* Mask containing log format info */
|
||||
#endif
|
||||
#if CONFIG_IS_ENABLED(BLOBLIST)
|
||||
struct bloblist_hdr *bloblist; /* Bloblist information */
|
||||
struct bloblist_hdr *new_bloblist; /* Relocated blolist info */
|
||||
# ifdef CONFIG_SPL
|
||||
struct spl_handoff *spl_handoff;
|
||||
# endif
|
||||
#endif
|
||||
#if defined(CONFIG_TRANSLATION_OFFSET)
|
||||
fdt_addr_t translation_offset; /* optional translation offset */
|
||||
#endif
|
||||
#if CONFIG_IS_ENABLED(WDT)
|
||||
struct udevice *watchdog_dev;
|
||||
#endif
|
||||
} gd_t;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_BOARD_TYPES
|
||||
#define gd_board_type() gd->board_type
|
||||
#else
|
||||
#define gd_board_type() 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Global Data Flags
|
||||
*/
|
||||
#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
|
||||
#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
|
||||
#define GD_FLG_SILENT 0x00004 /* Silent mode */
|
||||
#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
|
||||
#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
|
||||
#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
|
||||
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
|
||||
#define GD_FLG_ENV_READY 0x00080 /* Env. imported into hash table */
|
||||
#define GD_FLG_SERIAL_READY 0x00100 /* Pre-reloc serial console ready */
|
||||
#define GD_FLG_FULL_MALLOC_INIT 0x00200 /* Full malloc() is ready */
|
||||
#define GD_FLG_SPL_INIT 0x00400 /* spl_init() has been called */
|
||||
#define GD_FLG_SKIP_RELOC 0x00800 /* Don't relocate */
|
||||
#define GD_FLG_RECORD 0x01000 /* Record console */
|
||||
#define GD_FLG_ENV_DEFAULT 0x02000 /* Default variable flag */
|
||||
#define GD_FLG_SPL_EARLY_INIT 0x04000 /* Early SPL init is done */
|
||||
#define GD_FLG_LOG_READY 0x08000 /* Log system is ready for use */
|
||||
#define GD_FLG_WDT_READY 0x10000 /* Watchdog is ready for use */
|
||||
|
||||
#endif /* __ASM_GENERIC_GBL_DATA_H */
|
||||
@@ -0,0 +1,660 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Copyright (c) 2011 The Chromium OS Authors.
|
||||
* Copyright (c) 2011, NVIDIA Corp. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef _ASM_GENERIC_GPIO_H_
|
||||
#define _ASM_GENERIC_GPIO_H_
|
||||
|
||||
#include <dm/ofnode.h>
|
||||
|
||||
struct ofnode_phandle_args;
|
||||
|
||||
/*
|
||||
* Generic GPIO API for U-Boot
|
||||
*
|
||||
* --
|
||||
* NB: This is deprecated. Please use the driver model functions instead:
|
||||
*
|
||||
* - gpio_request_by_name()
|
||||
* - dm_gpio_get_value() etc.
|
||||
*
|
||||
* For now we need a dm_ prefix on some functions to avoid name collision.
|
||||
* --
|
||||
*
|
||||
* GPIOs are numbered from 0 to GPIO_COUNT-1 which value is defined
|
||||
* by the SOC/architecture.
|
||||
*
|
||||
* Each GPIO can be an input or output. If an input then its value can
|
||||
* be read as 0 or 1. If an output then its value can be set to 0 or 1.
|
||||
* If you try to write an input then the value is undefined. If you try
|
||||
* to read an output, barring something very unusual, you will get
|
||||
* back the value of the output that you previously set.
|
||||
*
|
||||
* In some cases the operation may fail, for example if the GPIO number
|
||||
* is out of range, or the GPIO is not available because its pin is
|
||||
* being used by another function. In that case, functions may return
|
||||
* an error value of -1.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Request a GPIO. This should be called before any of the other functions
|
||||
* are used on this GPIO.
|
||||
*
|
||||
* Note: With driver model, the label is allocated so there is no need for
|
||||
* the caller to preserve it.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @param label User label for this GPIO
|
||||
* @return 0 if ok, -1 on error
|
||||
*/
|
||||
int gpio_request(unsigned gpio, const char *label);
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Stop using the GPIO. This function should not alter pin configuration.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @return 0 if ok, -1 on error
|
||||
*/
|
||||
int gpio_free(unsigned gpio);
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Make a GPIO an input.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @return 0 if ok, -1 on error
|
||||
*/
|
||||
int gpio_direction_input(unsigned gpio);
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Make a GPIO an output, and set its value.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @param value GPIO value (0 for low or 1 for high)
|
||||
* @return 0 if ok, -1 on error
|
||||
*/
|
||||
int gpio_direction_output(unsigned gpio, int value);
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Get a GPIO's value. This will work whether the GPIO is an input
|
||||
* or an output.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @return 0 if low, 1 if high, -1 on error
|
||||
*/
|
||||
int gpio_get_value(unsigned gpio);
|
||||
|
||||
/**
|
||||
* @deprecated Please use driver model instead
|
||||
* Set an output GPIO's value. The GPIO must already be an output or
|
||||
* this function may have no effect.
|
||||
*
|
||||
* @param gpio GPIO number
|
||||
* @param value GPIO value (0 for low or 1 for high)
|
||||
* @return 0 if ok, -1 on error
|
||||
*/
|
||||
int gpio_set_value(unsigned gpio, int value);
|
||||
|
||||
/* State of a GPIO, as reported by get_function() */
|
||||
enum gpio_func_t {
|
||||
GPIOF_INPUT = 0,
|
||||
GPIOF_OUTPUT,
|
||||
GPIOF_UNUSED, /* Not claimed */
|
||||
GPIOF_UNKNOWN, /* Not known */
|
||||
GPIOF_FUNC, /* Not used as a GPIO */
|
||||
|
||||
GPIOF_COUNT,
|
||||
};
|
||||
|
||||
struct udevice;
|
||||
|
||||
struct gpio_desc {
|
||||
struct udevice *dev; /* Device, NULL for invalid GPIO */
|
||||
unsigned long flags;
|
||||
#define GPIOD_REQUESTED (1 << 0) /* Requested/claimed */
|
||||
#define GPIOD_IS_OUT (1 << 1) /* GPIO is an output */
|
||||
#define GPIOD_IS_IN (1 << 2) /* GPIO is an input */
|
||||
#define GPIOD_ACTIVE_LOW (1 << 3) /* value has active low */
|
||||
#define GPIOD_IS_OUT_ACTIVE (1 << 4) /* set output active */
|
||||
|
||||
uint offset; /* GPIO offset within the device */
|
||||
/*
|
||||
* We could consider adding the GPIO label in here. Possibly we could
|
||||
* use this structure for internal GPIO information.
|
||||
*/
|
||||
};
|
||||
|
||||
/**
|
||||
* dm_gpio_is_valid() - Check if a GPIO is valid
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return true if valid, false if not
|
||||
*/
|
||||
static inline bool dm_gpio_is_valid(const struct gpio_desc *desc)
|
||||
{
|
||||
return desc->dev != NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* gpio_get_status() - get the current GPIO status as a string
|
||||
*
|
||||
* Obtain the current GPIO status as a string which can be presented to the
|
||||
* user. A typical string is:
|
||||
*
|
||||
* "b4: in: 1 [x] sdmmc_cd"
|
||||
*
|
||||
* which means this is GPIO bank b, offset 4, currently set to input, current
|
||||
* value 1, [x] means that it is requested and the owner is 'sdmmc_cd'
|
||||
*
|
||||
* TODO(sjg@chromium.org): This should use struct gpio_desc
|
||||
*
|
||||
* @dev: Device to check
|
||||
* @offset: Offset of device GPIO to check
|
||||
* @buf: Place to put string
|
||||
* @buffsize: Size of string including \0
|
||||
*/
|
||||
int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize);
|
||||
|
||||
/**
|
||||
* gpio_get_function() - get the current function for a GPIO pin
|
||||
*
|
||||
* Note this returns GPIOF_UNUSED if the GPIO is not requested.
|
||||
*
|
||||
* TODO(sjg@chromium.org): This should use struct gpio_desc
|
||||
*
|
||||
* @dev: Device to check
|
||||
* @offset: Offset of device GPIO to check
|
||||
* @namep: If non-NULL, this is set to the name given when the GPIO
|
||||
* was requested, or -1 if it has not been requested
|
||||
* @return -ENODATA if the driver returned an unknown function,
|
||||
* -ENODEV if the device is not active, -EINVAL if the offset is invalid.
|
||||
* GPIOF_UNUSED if the GPIO has not been requested. Otherwise returns the
|
||||
* function from enum gpio_func_t.
|
||||
*/
|
||||
int gpio_get_function(struct udevice *dev, int offset, const char **namep);
|
||||
|
||||
/**
|
||||
* gpio_get_raw_function() - get the current raw function for a GPIO pin
|
||||
*
|
||||
* Note this does not return GPIOF_UNUSED - it will always return the GPIO
|
||||
* driver's view of a pin function, even if it is not correctly set up.
|
||||
*
|
||||
* TODO(sjg@chromium.org): This should use struct gpio_desc
|
||||
*
|
||||
* @dev: Device to check
|
||||
* @offset: Offset of device GPIO to check
|
||||
* @namep: If non-NULL, this is set to the name given when the GPIO
|
||||
* was requested, or -1 if it has not been requested
|
||||
* @return -ENODATA if the driver returned an unknown function,
|
||||
* -ENODEV if the device is not active, -EINVAL if the offset is invalid.
|
||||
* Otherwise returns the function from enum gpio_func_t.
|
||||
*/
|
||||
int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep);
|
||||
|
||||
/**
|
||||
* gpio_requestf() - request a GPIO using a format string for the owner
|
||||
*
|
||||
* This is a helper function for gpio_request(). It allows you to provide
|
||||
* a printf()-format string for the GPIO owner. It calls gpio_request() with
|
||||
* the string that is created
|
||||
*/
|
||||
int gpio_requestf(unsigned gpio, const char *fmt, ...)
|
||||
__attribute__ ((format (__printf__, 2, 3)));
|
||||
|
||||
struct fdtdec_phandle_args;
|
||||
|
||||
/**
|
||||
* gpio_xlate_offs_flags() - implementation for common use of dm_gpio_ops.xlate
|
||||
*
|
||||
* This routine sets the offset field to args[0] and the flags field to
|
||||
* GPIOD_ACTIVE_LOW if the GPIO_ACTIVE_LOW flag is present in args[1].
|
||||
*/
|
||||
int gpio_xlate_offs_flags(struct udevice *dev, struct gpio_desc *desc,
|
||||
struct ofnode_phandle_args *args);
|
||||
|
||||
/**
|
||||
* struct struct dm_gpio_ops - Driver model GPIO operations
|
||||
*
|
||||
* Refer to functions above for description. These function largely copy
|
||||
* the old API.
|
||||
*
|
||||
* This is trying to be close to Linux GPIO API. Once the U-Boot uses the
|
||||
* new DM GPIO API, this should be really easy to flip over to the Linux
|
||||
* GPIO API-alike interface.
|
||||
*
|
||||
* Also it would be useful to standardise additional functions like
|
||||
* pullup, slew rate and drive strength.
|
||||
*
|
||||
* gpio_request() and gpio_free() are optional - if NULL then they will
|
||||
* not be called.
|
||||
*
|
||||
* Note that @offset is the offset from the base GPIO of the device. So
|
||||
* offset 0 is the device's first GPIO and offset o-1 is the last GPIO,
|
||||
* where o is the number of GPIO lines controlled by the device. A device
|
||||
* is typically used to control a single bank of GPIOs. Within complex
|
||||
* SoCs there may be many banks and therefore many devices all referring
|
||||
* to the different IO addresses within the SoC.
|
||||
*
|
||||
* The uclass combines all GPIO devices together to provide a consistent
|
||||
* numbering from 0 to n-1, where n is the number of GPIOs in total across
|
||||
* all devices. Be careful not to confuse offset with gpio in the parameters.
|
||||
*/
|
||||
struct dm_gpio_ops {
|
||||
int (*request)(struct udevice *dev, unsigned offset, const char *label);
|
||||
int (*free)(struct udevice *dev, unsigned offset);
|
||||
int (*direction_input)(struct udevice *dev, unsigned offset);
|
||||
int (*direction_output)(struct udevice *dev, unsigned offset,
|
||||
int value);
|
||||
int (*get_value)(struct udevice *dev, unsigned offset);
|
||||
int (*set_value)(struct udevice *dev, unsigned offset, int value);
|
||||
int (*get_open_drain)(struct udevice *dev, unsigned offset);
|
||||
int (*set_open_drain)(struct udevice *dev, unsigned offset, int value);
|
||||
/**
|
||||
* get_function() Get the GPIO function
|
||||
*
|
||||
* @dev: Device to check
|
||||
* @offset: GPIO offset within that device
|
||||
* @return current function - GPIOF_...
|
||||
*/
|
||||
int (*get_function)(struct udevice *dev, unsigned offset);
|
||||
|
||||
/**
|
||||
* xlate() - Translate phandle arguments into a GPIO description
|
||||
*
|
||||
* This function should set up the fields in desc according to the
|
||||
* information in the arguments. The uclass will have set up:
|
||||
*
|
||||
* @desc->dev to @dev
|
||||
* @desc->flags to 0
|
||||
* @desc->offset to 0
|
||||
*
|
||||
* This method is optional and defaults to gpio_xlate_offs_flags,
|
||||
* which will parse offset and the GPIO_ACTIVE_LOW flag in the first
|
||||
* two arguments.
|
||||
*
|
||||
* Note that @dev is passed in as a parameter to follow driver model
|
||||
* uclass conventions, even though it is already available as
|
||||
* desc->dev.
|
||||
*
|
||||
* @dev: GPIO device
|
||||
* @desc: Place to put GPIO description
|
||||
* @args: Arguments provided in description
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int (*xlate)(struct udevice *dev, struct gpio_desc *desc,
|
||||
struct ofnode_phandle_args *args);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct gpio_dev_priv - information about a device used by the uclass
|
||||
*
|
||||
* The uclass combines all active GPIO devices into a unified numbering
|
||||
* scheme. To do this it maintains some private information about each
|
||||
* device.
|
||||
*
|
||||
* To implement driver model support in your GPIO driver, add a probe
|
||||
* handler, and set @gpio_count and @bank_name correctly in that handler.
|
||||
* This tells the uclass the name of the GPIO bank and the number of GPIOs
|
||||
* it contains.
|
||||
*
|
||||
* @bank_name: Name of the GPIO device (e.g 'a' means GPIOs will be called
|
||||
* 'A0', 'A1', etc.
|
||||
* @gpio_count: Number of GPIOs in this device
|
||||
* @gpio_base: Base GPIO number for this device. For the first active device
|
||||
* this will be 0; the numbering for others will follow sequentially so that
|
||||
* @gpio_base for device 1 will equal the number of GPIOs in device 0.
|
||||
* @name: Array of pointers to the name for each GPIO in this bank. The
|
||||
* value of the pointer will be NULL if the GPIO has not been claimed.
|
||||
*/
|
||||
struct gpio_dev_priv {
|
||||
const char *bank_name;
|
||||
unsigned gpio_count;
|
||||
unsigned gpio_base;
|
||||
char **name;
|
||||
};
|
||||
|
||||
/* Access the GPIO operations for a device */
|
||||
#define gpio_get_ops(dev) ((struct dm_gpio_ops *)(dev)->driver->ops)
|
||||
|
||||
/**
|
||||
* gpio_get_bank_info - Return information about a GPIO bank/device
|
||||
*
|
||||
* This looks up a device and returns both its GPIO base name and the number
|
||||
* of GPIOs it controls.
|
||||
*
|
||||
* @dev: Device to look up
|
||||
* @offset_count: Returns number of GPIOs within this bank
|
||||
* @return bank name of this device
|
||||
*/
|
||||
const char *gpio_get_bank_info(struct udevice *dev, int *offset_count);
|
||||
|
||||
/**
|
||||
* dm_gpio_lookup_name() - Look up a named GPIO and return its description
|
||||
*
|
||||
* The name of a GPIO is typically its bank name followed by a number from 0.
|
||||
* For example A0 is the first GPIO in bank A. Each bank is a separate driver
|
||||
* model device.
|
||||
*
|
||||
* @name: Name to look up
|
||||
* @desc: Returns description, on success
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* gpio_hog_lookup_name() - Look up a named GPIO and return the gpio descr.
|
||||
*
|
||||
* @name: Name to look up
|
||||
* @desc: Returns GPIO description, on success, else NULL
|
||||
* @return: Returns 0 if OK, else -ENODEV
|
||||
*/
|
||||
int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc);
|
||||
|
||||
/**
|
||||
* gpio_hog_probe_all() - probe all gpio devices with
|
||||
* gpio-hog subnodes.
|
||||
*
|
||||
* @return: Returns return value from device_probe()
|
||||
*/
|
||||
int gpio_hog_probe_all(void);
|
||||
|
||||
/**
|
||||
* gpio_lookup_name - Look up a GPIO name and return its details
|
||||
*
|
||||
* This is used to convert a named GPIO into a device, offset and GPIO
|
||||
* number.
|
||||
*
|
||||
* @name: GPIO name to look up
|
||||
* @devp: Returns pointer to device which contains this GPIO
|
||||
* @offsetp: Returns the offset number within this device
|
||||
* @gpiop: Returns the absolute GPIO number, numbered from 0
|
||||
*/
|
||||
int gpio_lookup_name(const char *name, struct udevice **devp,
|
||||
unsigned int *offsetp, unsigned int *gpiop);
|
||||
|
||||
/**
|
||||
* gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int
|
||||
*
|
||||
* This puts the value of the first GPIO into bit 0, the second into bit 1,
|
||||
* etc. then returns the resulting integer.
|
||||
*
|
||||
* @gpio_list: List of GPIOs to collect
|
||||
* @return resulting integer value, or -ve on error
|
||||
*/
|
||||
int gpio_get_values_as_int(const int *gpio_list);
|
||||
|
||||
/**
|
||||
* dm_gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int
|
||||
*
|
||||
* This puts the value of the first GPIO into bit 0, the second into bit 1,
|
||||
* etc. then returns the resulting integer.
|
||||
*
|
||||
* @desc_list: List of GPIOs to collect
|
||||
* @count: Number of GPIOs
|
||||
* @return resulting integer value, or -ve on error
|
||||
*/
|
||||
int dm_gpio_get_values_as_int(const struct gpio_desc *desc_list, int count);
|
||||
|
||||
/**
|
||||
* gpio_claim_vector() - claim a number of GPIOs for input
|
||||
*
|
||||
* @gpio_num_array: array of gpios to claim, terminated by -1
|
||||
* @fmt: format string for GPIO names, e.g. "board_id%d"
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int gpio_claim_vector(const int *gpio_num_array, const char *fmt);
|
||||
|
||||
/**
|
||||
* gpio_request_by_name() - Locate and request a GPIO by name
|
||||
*
|
||||
* This operates by looking up the given list name in the device (device
|
||||
* tree property) and requesting the GPIO for use. The property must exist
|
||||
* in @dev's node.
|
||||
*
|
||||
* Use @flags to specify whether the GPIO should be an input or output. In
|
||||
* principle this can also come from the device tree binding but most
|
||||
* bindings don't provide this information. Specifically, when the GPIO uclass
|
||||
* calls the xlate() method, it can return default flags, which are then
|
||||
* ORed with this @flags.
|
||||
*
|
||||
* If we find that requesting the GPIO is not always needed we could add a
|
||||
* new function or a new GPIOD_NO_REQUEST flag.
|
||||
*
|
||||
* At present driver model has no reference counting so if one device
|
||||
* requests a GPIO which subsequently is unbound, the @desc->dev pointer
|
||||
* will be invalid. However this will only happen if the GPIO device is
|
||||
* unbound, not if it is removed, so this seems like a reasonable limitation
|
||||
* for now. There is no real use case for unbinding drivers in normal
|
||||
* operation.
|
||||
*
|
||||
* The device tree binding is doc/device-tree-bindings/gpio/gpio.txt in
|
||||
* generate terms and each specific device may add additional details in
|
||||
* a binding file in the same directory.
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @index: Index number of the GPIO in that list use request (0=first)
|
||||
* @desc: Returns GPIO description information. If there is no such
|
||||
* GPIO, dev->dev will be NULL.
|
||||
* @flags: Indicates the GPIO input/output settings (GPIOD_...)
|
||||
* @return 0 if OK, -ENOENT if the GPIO does not exist, -EINVAL if there is
|
||||
* something wrong with the list, or other -ve for another error (e.g.
|
||||
* -EBUSY if a GPIO was already requested)
|
||||
*/
|
||||
int gpio_request_by_name(struct udevice *dev, const char *list_name,
|
||||
int index, struct gpio_desc *desc, int flags);
|
||||
|
||||
/**
|
||||
* gpio_request_list_by_name() - Request a list of GPIOs
|
||||
*
|
||||
* Reads all the GPIOs from a list and requests them. See
|
||||
* gpio_request_by_name() for additional details. Lists should not be
|
||||
* misused to hold unrelated or optional GPIOs. They should only be used
|
||||
* for things like parallel data lines. A zero phandle terminates the list
|
||||
* the list.
|
||||
*
|
||||
* This function will either succeed, and request all GPIOs in the list, or
|
||||
* fail and request none (it will free already-requested GPIOs in case of
|
||||
* an error part-way through).
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @desc_list: Returns a list of GPIO description information
|
||||
* @max_count: Maximum number of GPIOs to return (@desc_list must be at least
|
||||
* this big)
|
||||
* @flags: Indicates the GPIO input/output settings (GPIOD_...)
|
||||
* @return number of GPIOs requested, or -ve on error
|
||||
*/
|
||||
int gpio_request_list_by_name(struct udevice *dev, const char *list_name,
|
||||
struct gpio_desc *desc_list, int max_count,
|
||||
int flags);
|
||||
|
||||
/**
|
||||
* dm_gpio_request() - manually request a GPIO
|
||||
*
|
||||
* Note: This function should only be used for testing / debugging. Instead.
|
||||
* use gpio_request_by_name() to pull GPIOs from the device tree.
|
||||
*
|
||||
* @desc: GPIO description of GPIO to request (see dm_gpio_lookup_name())
|
||||
* @label: Label to attach to the GPIO while claimed
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_request(struct gpio_desc *desc, const char *label);
|
||||
|
||||
/**
|
||||
* gpio_get_list_count() - Returns the number of GPIOs in a list
|
||||
*
|
||||
* Counts the GPIOs in a list. See gpio_request_by_name() for additional
|
||||
* details.
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @return number of GPIOs (0 for an empty property) or -ENOENT if the list
|
||||
* does not exist
|
||||
*/
|
||||
int gpio_get_list_count(struct udevice *dev, const char *list_name);
|
||||
|
||||
/**
|
||||
* gpio_request_by_name_nodev() - request GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_request_list_by_name() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_request_by_name_nodev(ofnode node, const char *list_name, int index,
|
||||
struct gpio_desc *desc, int flags);
|
||||
|
||||
/**
|
||||
* gpio_request_list_by_name_nodev() - request GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_request_list_by_name() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_request_list_by_name_nodev(ofnode node, const char *list_name,
|
||||
struct gpio_desc *desc_list, int max_count,
|
||||
int flags);
|
||||
|
||||
/**
|
||||
* gpio_dev_request_index() - request single GPIO from gpio device
|
||||
*
|
||||
* @dev: GPIO device
|
||||
* @nodename: Name of node for which gpio gets requested, used
|
||||
* for the gpio label name
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @index: Index number of the GPIO in that list use request (0=first)
|
||||
* @flags: GPIOD_* flags
|
||||
* @dtflags: GPIO flags read from DT defined see GPIOD_*
|
||||
* @desc: returns GPIO descriptor filled from this function
|
||||
* @return: return value from gpio_request_tail()
|
||||
*/
|
||||
int gpio_dev_request_index(struct udevice *dev, const char *nodename,
|
||||
char *list_name, int index, int flags,
|
||||
int dtflags, struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* dm_gpio_free() - Free a single GPIO
|
||||
*
|
||||
* This frees a single GPIOs previously returned from gpio_request_by_name().
|
||||
*
|
||||
* @dev: Device which requested the GPIO
|
||||
* @desc: GPIO to free
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* gpio_free_list() - Free a list of GPIOs
|
||||
*
|
||||
* This frees a list of GPIOs previously returned from
|
||||
* gpio_request_list_by_name().
|
||||
*
|
||||
* @dev: Device which requested the GPIOs
|
||||
* @desc: List of GPIOs to free
|
||||
* @count: Number of GPIOs in the list
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count);
|
||||
|
||||
/**
|
||||
* gpio_free_list_nodev() - free GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_free_list() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_free_list_nodev(struct gpio_desc *desc, int count);
|
||||
|
||||
/**
|
||||
* dm_gpio_get_value() - Get the value of a GPIO
|
||||
*
|
||||
* This is the driver model version of the existing gpio_get_value() function
|
||||
* and should be used instead of that.
|
||||
*
|
||||
* For now, these functions have a dm_ prefix since they conflict with
|
||||
* existing names.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return GPIO value (0 for inactive, 1 for active) or -ve on error
|
||||
*/
|
||||
int dm_gpio_get_value(const struct gpio_desc *desc);
|
||||
|
||||
int dm_gpio_set_value(const struct gpio_desc *desc, int value);
|
||||
|
||||
/**
|
||||
* dm_gpio_get_open_drain() - Check if open-drain-mode of a GPIO is active
|
||||
*
|
||||
* This checks if open-drain-mode for a GPIO is enabled or not. This method is
|
||||
* optional.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return Value of open drain mode for GPIO (0 for inactive, 1 for active) or
|
||||
* -ve on error
|
||||
*/
|
||||
int dm_gpio_get_open_drain(struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* dm_gpio_set_open_drain() - Switch open-drain-mode of a GPIO on or off
|
||||
*
|
||||
* This enables or disables open-drain mode for a GPIO. This method is
|
||||
* optional; if the driver does not support it, nothing happens when the method
|
||||
* is called.
|
||||
*
|
||||
* In open-drain mode, instead of actively driving the output (Push-pull
|
||||
* output), the GPIO's pin is connected to the collector (for a NPN transistor)
|
||||
* or the drain (for a MOSFET) of a transistor, respectively. The pin then
|
||||
* either forms an open circuit or a connection to ground, depending on the
|
||||
* state of the transistor.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_set_open_drain(struct gpio_desc *desc, int value);
|
||||
|
||||
/**
|
||||
* dm_gpio_set_dir() - Set the direction for a GPIO
|
||||
*
|
||||
* This sets up the direction according tot the provided flags. It will do
|
||||
* nothing unless the direction is actually specified.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_set_dir(struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* dm_gpio_set_dir_flags() - Set direction using specific flags
|
||||
*
|
||||
* This is like dm_gpio_set_dir() except that the flags value is provided
|
||||
* instead of being used from desc->flags. This is needed because in many
|
||||
* cases the GPIO description does not include direction information.
|
||||
* Note that desc->flags is updated by this function.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @flags: New flags to use
|
||||
* @return 0 if OK, -ve on error, in which case desc->flags is not updated
|
||||
*/
|
||||
int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags);
|
||||
|
||||
/**
|
||||
* gpio_get_number() - Get the global GPIO number of a GPIO
|
||||
*
|
||||
* This should only be used for debugging or interest. It returns the number
|
||||
* that should be used for gpio_get_value() etc. to access this GPIO.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return GPIO number, or -ve if not found
|
||||
*/
|
||||
int gpio_get_number(const struct gpio_desc *desc);
|
||||
|
||||
#endif /* _ASM_GENERIC_GPIO_H_ */
|
||||
@@ -0,0 +1,47 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/*
|
||||
* asm-generic/int-ll64.h
|
||||
*
|
||||
* Integer declarations for architectures which use "long long"
|
||||
* for 64-bit types.
|
||||
*/
|
||||
|
||||
#ifndef _ASM_GENERIC_INT_LL64_H
|
||||
#define _ASM_GENERIC_INT_LL64_H
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
/*
|
||||
* __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
|
||||
* header files exported to user space
|
||||
*/
|
||||
|
||||
typedef __signed__ char __s8;
|
||||
typedef unsigned char __u8;
|
||||
|
||||
typedef __signed__ short __s16;
|
||||
typedef unsigned short __u16;
|
||||
|
||||
typedef __signed__ int __s32;
|
||||
typedef unsigned int __u32;
|
||||
|
||||
#ifdef __GNUC__
|
||||
__extension__ typedef __signed__ long long __s64;
|
||||
__extension__ typedef unsigned long long __u64;
|
||||
#else
|
||||
typedef __signed__ long long __s64;
|
||||
typedef unsigned long long __u64;
|
||||
#endif
|
||||
|
||||
typedef __s8 s8;
|
||||
typedef __u8 u8;
|
||||
typedef __s16 s16;
|
||||
typedef __u16 u16;
|
||||
typedef __s32 s32;
|
||||
typedef __u32 u32;
|
||||
typedef __s64 s64;
|
||||
typedef __u64 u64;
|
||||
|
||||
#endif /* __ASSEMBLY__ */
|
||||
|
||||
|
||||
#endif /* _ASM_GENERIC_INT_LL64_H */
|
||||
@@ -0,0 +1,109 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Generic I/O functions.
|
||||
*
|
||||
* Copyright (c) 2016 Imagination Technologies Ltd.
|
||||
*/
|
||||
|
||||
#ifndef __ASM_GENERIC_IO_H__
|
||||
#define __ASM_GENERIC_IO_H__
|
||||
|
||||
/*
|
||||
* This file should be included at the end of each architecture-specific
|
||||
* asm/io.h such that we may provide generic implementations without
|
||||
* conflicting with architecture-specific code.
|
||||
*/
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
||||
/**
|
||||
* phys_to_virt() - Return a virtual address mapped to a given physical address
|
||||
* @paddr: the physical address
|
||||
*
|
||||
* Returns a virtual address which the CPU can access that maps to the physical
|
||||
* address @paddr. This should only be used where it is known that no dynamic
|
||||
* mapping is required. In general, map_physmem should be used instead.
|
||||
*
|
||||
* Returns: a virtual address which maps to @paddr
|
||||
*/
|
||||
#ifndef phys_to_virt
|
||||
static inline void *phys_to_virt(phys_addr_t paddr)
|
||||
{
|
||||
return (void *)(unsigned long)paddr;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* virt_to_phys() - Return the physical address that a virtual address maps to
|
||||
* @vaddr: the virtual address
|
||||
*
|
||||
* Returns the physical address which the CPU-accessible virtual address @vaddr
|
||||
* maps to.
|
||||
*
|
||||
* Returns: the physical address which @vaddr maps to
|
||||
*/
|
||||
#ifndef virt_to_phys
|
||||
static inline phys_addr_t virt_to_phys(void *vaddr)
|
||||
{
|
||||
return (phys_addr_t)((unsigned long)vaddr);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Flags for use with map_physmem() & unmap_physmem(). Architectures need not
|
||||
* support all of these, in which case they will be defined as zero here &
|
||||
* ignored. Callers that may run on multiple architectures should therefore
|
||||
* treat them as hints rather than requirements.
|
||||
*/
|
||||
#ifndef MAP_NOCACHE
|
||||
# define MAP_NOCACHE 0 /* Produce an uncached mapping */
|
||||
#endif
|
||||
#ifndef MAP_WRCOMBINE
|
||||
# define MAP_WRCOMBINE 0 /* Allow write-combining on the mapping */
|
||||
#endif
|
||||
#ifndef MAP_WRBACK
|
||||
# define MAP_WRBACK 0 /* Map using write-back caching */
|
||||
#endif
|
||||
#ifndef MAP_WRTHROUGH
|
||||
# define MAP_WRTHROUGH 0 /* Map using write-through caching */
|
||||
#endif
|
||||
|
||||
/**
|
||||
* map_physmem() - Return a virtual address mapped to a given physical address
|
||||
* @paddr: the physical address
|
||||
* @len: the length of the required mapping
|
||||
* @flags: flags affecting the type of mapping
|
||||
*
|
||||
* Return a virtual address through which the CPU may access the memory at
|
||||
* physical address @paddr. The mapping will be valid for at least @len bytes,
|
||||
* and may be affected by flags passed to the @flags argument. This function
|
||||
* may create new mappings, so should generally be paired with a matching call
|
||||
* to unmap_physmem once the caller is finished with the memory in question.
|
||||
*
|
||||
* Returns: a virtual address suitably mapped to @paddr
|
||||
*/
|
||||
#ifndef map_physmem
|
||||
static inline void *map_physmem(phys_addr_t paddr, unsigned long len,
|
||||
unsigned long flags)
|
||||
{
|
||||
return phys_to_virt(paddr);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* unmap_physmem() - Remove mappings created by a prior call to map_physmem()
|
||||
* @vaddr: the virtual address which map_physmem() previously returned
|
||||
* @flags: flags matching those originally passed to map_physmem()
|
||||
*
|
||||
* Unmap memory which was previously mapped by a call to map_physmem(). If
|
||||
* map_physmem() dynamically created a mapping for the memory in question then
|
||||
* unmap_physmem() will remove that mapping.
|
||||
*/
|
||||
#ifndef unmap_physmem
|
||||
static inline void unmap_physmem(void *vaddr, unsigned long flags)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !__ASSEMBLY__ */
|
||||
#endif /* __ASM_GENERIC_IO_H__ */
|
||||
@@ -0,0 +1,105 @@
|
||||
#ifndef _ASM_GENERIC_IOCTL_H
|
||||
#define _ASM_GENERIC_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))
|
||||
|
||||
#ifdef __KERNEL__
|
||||
/* 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)
|
||||
#else
|
||||
#define _IOC_TYPECHECK(t) (sizeof(t))
|
||||
#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)
|
||||
|
||||
/* ...and for the drivers/sound files... */
|
||||
|
||||
#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 /* _ASM_GENERIC_IOCTL_H */
|
||||
@@ -0,0 +1,54 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Portable Executable and Common Object Constants
|
||||
*
|
||||
* Copyright (c) 2018 Heinrich Schuchardt
|
||||
*
|
||||
* based on the "Microsoft Portable Executable and Common Object File Format
|
||||
* Specification", revision 11, 2017-01-23
|
||||
*/
|
||||
|
||||
#ifndef _ASM_PE_H
|
||||
#define _ASM_PE_H
|
||||
|
||||
/* Characteristics */
|
||||
#define IMAGE_FILE_RELOCS_STRIPPED 0x0001
|
||||
#define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002
|
||||
#define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004
|
||||
#define IMAGE_FILE_LOCAL_SYMS_STRIPPED 0x0008
|
||||
#define IMAGE_FILE_AGGRESSIVE_WS_TRIM 0x0010
|
||||
#define IMAGE_FILE_LARGE_ADDRESS_AWARE 0x0020
|
||||
/* Reserved 0x0040 */
|
||||
#define IMAGE_FILE_BYTES_REVERSED_LO 0x0080
|
||||
#define IMAGE_FILE_32BIT_MACHINE 0x0100
|
||||
#define IMAGE_FILE_DEBUG_STRIPPED 0x0200
|
||||
#define IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP 0x0400
|
||||
#define IMAGE_FILE_NET_RUN_FROM_SWAP 0x0800
|
||||
#define IMAGE_FILE_SYSTEM 0x1000
|
||||
#define IMAGE_FILE_DLL 0x2000
|
||||
#define IMAGE_FILE_UP_SYSTEM_ONLY 0x4000
|
||||
#define IMAGE_FILE_BYTES_REVERSED_HI 0x8000
|
||||
|
||||
/* Machine types */
|
||||
#define IMAGE_FILE_MACHINE_I386 0x014c
|
||||
#define IMAGE_FILE_MACHINE_ARM 0x01c0
|
||||
#define IMAGE_FILE_MACHINE_THUMB 0x01c2
|
||||
#define IMAGE_FILE_MACHINE_ARMNT 0x01c4
|
||||
#define IMAGE_FILE_MACHINE_AMD64 0x8664
|
||||
#define IMAGE_FILE_MACHINE_ARM64 0xaa64
|
||||
#define IMAGE_FILE_MACHINE_RISCV32 0x5032
|
||||
#define IMAGE_FILE_MACHINE_RISCV64 0x5064
|
||||
|
||||
/* Header magic constants */
|
||||
#define IMAGE_NT_OPTIONAL_HDR32_MAGIC 0x010b
|
||||
#define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x020b
|
||||
#define IMAGE_DOS_SIGNATURE 0x5a4d /* MZ */
|
||||
#define IMAGE_NT_SIGNATURE 0x00004550 /* PE00 */
|
||||
|
||||
/* Subsystem type */
|
||||
#define IMAGE_SUBSYSTEM_EFI_APPLICATION 10
|
||||
#define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11
|
||||
#define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER 12
|
||||
#define IMAGE_SUBSYSTEM_EFI_ROM 13
|
||||
|
||||
#endif /* _ASM_PE_H */
|
||||
@@ -0,0 +1,92 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Copyright (c) 2011 The Chromium OS Authors.
|
||||
*/
|
||||
|
||||
/* Taken from Linux kernel, commit f56c3196 */
|
||||
|
||||
#ifndef _ASM_GENERIC_SECTIONS_H_
|
||||
#define _ASM_GENERIC_SECTIONS_H_
|
||||
|
||||
/* References to section boundaries */
|
||||
|
||||
extern char _text[], _stext[], _etext[];
|
||||
extern char _data[], _sdata[], _edata[];
|
||||
extern char __bss_start[], __bss_stop[];
|
||||
extern char __init_begin[], __init_end[];
|
||||
extern char _sinittext[], _einittext[];
|
||||
extern char _end[], _init[];
|
||||
extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[];
|
||||
extern char __kprobes_text_start[], __kprobes_text_end[];
|
||||
extern char __entry_text_start[], __entry_text_end[];
|
||||
extern char __initdata_begin[], __initdata_end[];
|
||||
extern char __start_rodata[], __end_rodata[];
|
||||
extern char __efi_helloworld_begin[];
|
||||
extern char __efi_helloworld_end[];
|
||||
|
||||
/* Start and end of .ctors section - used for constructor calls. */
|
||||
extern char __ctors_start[], __ctors_end[];
|
||||
|
||||
/* function descriptor handling (if any). Override
|
||||
* in asm/sections.h */
|
||||
#ifndef dereference_function_descriptor
|
||||
#define dereference_function_descriptor(p) (p)
|
||||
#endif
|
||||
|
||||
/* random extra sections (if any). Override
|
||||
* in asm/sections.h */
|
||||
#ifndef arch_is_kernel_text
|
||||
static inline int arch_is_kernel_text(unsigned long addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef arch_is_kernel_data
|
||||
static inline int arch_is_kernel_data(unsigned long addr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* U-Boot-specific things begin here */
|
||||
|
||||
/* Start of U-Boot text region */
|
||||
extern char __text_start[];
|
||||
|
||||
/* This marks the end of the text region which must be relocated */
|
||||
extern char __image_copy_end[];
|
||||
|
||||
/*
|
||||
* This is the U-Boot entry point - prior to relocation it should be same
|
||||
* as __text_start
|
||||
*/
|
||||
extern void _start(void);
|
||||
|
||||
/*
|
||||
* ARM defines its symbols as char[]. Other arches define them as ulongs.
|
||||
*/
|
||||
#ifdef CONFIG_ARM
|
||||
|
||||
extern char __bss_start[];
|
||||
extern char __bss_end[];
|
||||
extern char __image_copy_start[];
|
||||
extern char __image_copy_end[];
|
||||
extern char _image_binary_end[];
|
||||
extern char __rel_dyn_start[];
|
||||
extern char __rel_dyn_end[];
|
||||
|
||||
#else /* don't use offsets: */
|
||||
|
||||
/* Exports from the Linker Script */
|
||||
extern ulong __data_end;
|
||||
extern ulong __rel_dyn_start;
|
||||
extern ulong __rel_dyn_end;
|
||||
extern ulong __bss_end;
|
||||
extern ulong _image_binary_end;
|
||||
|
||||
extern ulong _TEXT_BASE; /* code start */
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _ASM_GENERIC_SECTIONS_H_ */
|
||||
@@ -0,0 +1,101 @@
|
||||
#ifndef __ASM_GENERIC_SIGNAL_H
|
||||
#define __ASM_GENERIC_SIGNAL_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#define _NSIG 64
|
||||
#define _NSIG_BPW BITS_PER_LONG
|
||||
#define _NSIG_WORDS (_NSIG / _NSIG_BPW)
|
||||
|
||||
#define SIGHUP 1
|
||||
#define SIGINT 2
|
||||
#define SIGQUIT 3
|
||||
#define SIGILL 4
|
||||
#define SIGTRAP 5
|
||||
#define SIGABRT 6
|
||||
#define SIGIOT 6
|
||||
#define SIGBUS 7
|
||||
#define SIGFPE 8
|
||||
#define SIGKILL 9
|
||||
#define SIGUSR1 10
|
||||
#define SIGSEGV 11
|
||||
#define SIGUSR2 12
|
||||
#define SIGPIPE 13
|
||||
#define SIGALRM 14
|
||||
#define SIGTERM 15
|
||||
#define SIGSTKFLT 16
|
||||
#define SIGCHLD 17
|
||||
#define SIGCONT 18
|
||||
#define SIGSTOP 19
|
||||
#define SIGTSTP 20
|
||||
#define SIGTTIN 21
|
||||
#define SIGTTOU 22
|
||||
#define SIGURG 23
|
||||
#define SIGXCPU 24
|
||||
#define SIGXFSZ 25
|
||||
#define SIGVTALRM 26
|
||||
#define SIGPROF 27
|
||||
#define SIGWINCH 28
|
||||
#define SIGIO 29
|
||||
#define SIGPOLL SIGIO
|
||||
/*
|
||||
#define SIGLOST 29
|
||||
*/
|
||||
#define SIGPWR 30
|
||||
#define SIGSYS 31
|
||||
#define SIGUNUSED 31
|
||||
|
||||
/* These should not be considered constants from userland. */
|
||||
#define SIGRTMIN 32
|
||||
#ifndef SIGRTMAX
|
||||
#define SIGRTMAX _NSIG
|
||||
#endif
|
||||
|
||||
/*
|
||||
* SA_FLAGS values:
|
||||
*
|
||||
* SA_ONSTACK indicates that a registered stack_t will be used.
|
||||
* SA_RESTART flag to get restarting signals (which were the default long ago)
|
||||
* SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
|
||||
* SA_RESETHAND clears the handler when the signal is delivered.
|
||||
* SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
|
||||
* SA_NODEFER prevents the current signal from being masked in the handler.
|
||||
*
|
||||
* SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
|
||||
* Unix names RESETHAND and NODEFER respectively.
|
||||
*/
|
||||
#define SA_NOCLDSTOP 0x00000001
|
||||
#define SA_NOCLDWAIT 0x00000002
|
||||
#define SA_SIGINFO 0x00000004
|
||||
#define SA_ONSTACK 0x08000000
|
||||
#define SA_RESTART 0x10000000
|
||||
#define SA_NODEFER 0x40000000
|
||||
#define SA_RESETHAND 0x80000000
|
||||
|
||||
#define SA_NOMASK SA_NODEFER
|
||||
#define SA_ONESHOT SA_RESETHAND
|
||||
|
||||
/*
|
||||
* New architectures should not define the obsolete
|
||||
* SA_RESTORER 0x04000000
|
||||
*/
|
||||
|
||||
/*
|
||||
* sigaltstack controls
|
||||
*/
|
||||
#define SS_ONSTACK 1
|
||||
#define SS_DISABLE 2
|
||||
|
||||
#define MINSIGSTKSZ 2048
|
||||
#define SIGSTKSZ 8192
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
typedef struct {
|
||||
unsigned long sig[_NSIG_WORDS];
|
||||
} sigset_t;
|
||||
|
||||
/* not actually used, but required for linux/syscalls.h */
|
||||
|
||||
#endif /* __ASSEMBLY__ */
|
||||
|
||||
#endif /* _ASM_GENERIC_SIGNAL_H */
|
||||
@@ -0,0 +1,9 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
#ifndef _ASM_GENERIC_TYPES_H
|
||||
#define _ASM_GENERIC_TYPES_H
|
||||
/*
|
||||
* int-ll64 is used everywhere now.
|
||||
*/
|
||||
#include <asm-generic/int-ll64.h>
|
||||
|
||||
#endif /* _ASM_GENERIC_TYPES_H */
|
||||
@@ -0,0 +1,98 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* Copyright (c) 2011 The Chromium OS Authors.
|
||||
*
|
||||
* (C) Copyright 2000 - 2002
|
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
********************************************************************
|
||||
* NOTE: This header file defines an interface to U-Boot. Including
|
||||
* this (unmodified) header file in another file is considered normal
|
||||
* use of U-Boot, and does *not* fall under the heading of "derived
|
||||
* work".
|
||||
********************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __ASM_GENERIC_U_BOOT_H__
|
||||
#define __ASM_GENERIC_U_BOOT_H__
|
||||
|
||||
/*
|
||||
* Board information passed to Linux kernel from U-Boot
|
||||
*
|
||||
* include/asm-ppc/u-boot.h
|
||||
*/
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
||||
typedef struct bd_info {
|
||||
unsigned long bi_memstart; /* start of DRAM memory */
|
||||
phys_size_t bi_memsize; /* size of DRAM memory in bytes */
|
||||
unsigned long bi_flashstart; /* start of FLASH memory */
|
||||
unsigned long bi_flashsize; /* size of FLASH memory */
|
||||
unsigned long bi_flashoffset; /* reserved area for startup monitor */
|
||||
unsigned long bi_sramstart; /* start of SRAM memory */
|
||||
unsigned long bi_sramsize; /* size of SRAM memory */
|
||||
#ifdef CONFIG_ARM
|
||||
unsigned long bi_arm_freq; /* arm frequency */
|
||||
unsigned long bi_dsp_freq; /* dsp core frequency */
|
||||
unsigned long bi_ddr_freq; /* ddr frequency */
|
||||
#endif
|
||||
#if defined(CONFIG_MPC8xx) || defined(CONFIG_E500) || defined(CONFIG_MPC86xx)
|
||||
unsigned long bi_immr_base; /* base of IMMR register */
|
||||
#endif
|
||||
#if defined(CONFIG_M68K)
|
||||
unsigned long bi_mbar_base; /* base of internal registers */
|
||||
#endif
|
||||
#if defined(CONFIG_MPC83xx)
|
||||
unsigned long bi_immrbar;
|
||||
#endif
|
||||
unsigned long bi_bootflags; /* boot / reboot flag (Unused) */
|
||||
unsigned long bi_ip_addr; /* IP Address */
|
||||
unsigned char bi_enetaddr[6]; /* OLD: see README.enetaddr */
|
||||
unsigned short bi_ethspeed; /* Ethernet speed in Mbps */
|
||||
unsigned long bi_intfreq; /* Internal Freq, in MHz */
|
||||
unsigned long bi_busfreq; /* Bus Freq, in MHz */
|
||||
#if defined(CONFIG_CPM2)
|
||||
unsigned long bi_cpmfreq; /* CPM_CLK Freq, in MHz */
|
||||
unsigned long bi_brgfreq; /* BRG_CLK Freq, in MHz */
|
||||
unsigned long bi_sccfreq; /* SCC_CLK Freq, in MHz */
|
||||
unsigned long bi_vco; /* VCO Out from PLL, in MHz */
|
||||
#endif
|
||||
#if defined(CONFIG_M68K)
|
||||
unsigned long bi_ipbfreq; /* IPB Bus Freq, in MHz */
|
||||
unsigned long bi_pcifreq; /* PCI Bus Freq, in MHz */
|
||||
#endif
|
||||
#if defined(CONFIG_EXTRA_CLOCK)
|
||||
unsigned long bi_inpfreq; /* input Freq in MHz */
|
||||
unsigned long bi_vcofreq; /* vco Freq in MHz */
|
||||
unsigned long bi_flbfreq; /* Flexbus Freq in MHz */
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_HAS_ETH1
|
||||
unsigned char bi_enet1addr[6]; /* OLD: see README.enetaddr */
|
||||
#endif
|
||||
#ifdef CONFIG_HAS_ETH2
|
||||
unsigned char bi_enet2addr[6]; /* OLD: see README.enetaddr */
|
||||
#endif
|
||||
#ifdef CONFIG_HAS_ETH3
|
||||
unsigned char bi_enet3addr[6]; /* OLD: see README.enetaddr */
|
||||
#endif
|
||||
#ifdef CONFIG_HAS_ETH4
|
||||
unsigned char bi_enet4addr[6]; /* OLD: see README.enetaddr */
|
||||
#endif
|
||||
#ifdef CONFIG_HAS_ETH5
|
||||
unsigned char bi_enet5addr[6]; /* OLD: see README.enetaddr */
|
||||
#endif
|
||||
|
||||
ulong bi_arch_number; /* unique id for this board */
|
||||
ulong bi_boot_params; /* where this board expects params */
|
||||
#ifdef CONFIG_NR_DRAM_BANKS
|
||||
struct { /* RAM configuration */
|
||||
phys_addr_t start;
|
||||
phys_size_t size;
|
||||
} bi_dram[CONFIG_NR_DRAM_BANKS];
|
||||
#endif /* CONFIG_NR_DRAM_BANKS */
|
||||
} bd_t;
|
||||
|
||||
#endif /* __ASSEMBLY__ */
|
||||
|
||||
#endif /* __ASM_GENERIC_U_BOOT_H__ */
|
||||
@@ -0,0 +1,26 @@
|
||||
#ifndef _GENERIC_UNALIGNED_H
|
||||
#define _GENERIC_UNALIGNED_H
|
||||
|
||||
#include <asm/byteorder.h>
|
||||
|
||||
#include <linux/unaligned/le_byteshift.h>
|
||||
#include <linux/unaligned/be_byteshift.h>
|
||||
#include <linux/unaligned/generic.h>
|
||||
|
||||
/*
|
||||
* Select endianness
|
||||
*/
|
||||
#if defined(__LITTLE_ENDIAN)
|
||||
#define get_unaligned __get_unaligned_le
|
||||
#define put_unaligned __put_unaligned_le
|
||||
#elif defined(__BIG_ENDIAN)
|
||||
#define get_unaligned __get_unaligned_be
|
||||
#define put_unaligned __put_unaligned_be
|
||||
#else
|
||||
#error invalid endian
|
||||
#endif
|
||||
|
||||
/* Allow unaligned memory access */
|
||||
void allow_unaligned(void);
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user