hc
2023-11-22 f743a7adbd6e230d66a6206fa115b59fec2d88eb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Definitions for working with the Flattened Device Tree data format
 *
 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
 * benh@kernel.crashing.org
 */
 
#ifndef _LINUX_OF_FDT_H
#define _LINUX_OF_FDT_H
 
#include <linux/types.h>
#include <linux/init.h>
#include <linux/errno.h>
 
/* Definitions used by the flattened device tree */
#define OF_DT_HEADER        0xd00dfeed    /* marker */
 
#ifndef __ASSEMBLY__
 
#if defined(CONFIG_OF_FLATTREE)
 
struct device_node;
 
/* For scanning an arbitrary device-tree at any time */
extern char *of_fdt_get_string(const void *blob, u32 offset);
extern void *of_fdt_get_property(const void *blob,
                unsigned long node,
                const char *name,
                int *size);
extern bool of_fdt_is_big_endian(const void *blob,
                unsigned long node);
extern int of_fdt_match(const void *blob, unsigned long node,
           const char *const *compat);
extern void *of_fdt_unflatten_tree(const unsigned long *blob,
                  struct device_node *dad,
                  struct device_node **mynodes);
 
/* TBD: Temporary export of fdt globals - remove when code fully merged */
extern int __initdata dt_root_addr_cells;
extern int __initdata dt_root_size_cells;
extern void *initial_boot_params;
 
extern char __dtb_start[];
extern char __dtb_end[];
 
/* Other Prototypes */
extern u64 of_flat_dt_translate_address(unsigned long node);
extern void of_fdt_limit_memory(int limit);
extern int of_fdt_get_ddrtype(void);
extern int of_fdt_get_ddrrank(int channel);
extern int of_fdt_get_ddrhbb(int channel, int rank);
#endif /* CONFIG_OF_FLATTREE */
 
#ifdef CONFIG_OF_EARLY_FLATTREE
/* For scanning the flat device-tree at boot time */
extern int of_scan_flat_dt(int (*it)(unsigned long node, const char *uname,
                    int depth, void *data),
              void *data);
extern int of_scan_flat_dt_subnodes(unsigned long node,
                   int (*it)(unsigned long node,
                         const char *uname,
                         void *data),
                   void *data);
extern int of_get_flat_dt_subnode_by_name(unsigned long node,
                     const char *uname);
extern const void *of_get_flat_dt_prop(unsigned long node, const char *name,
                      int *size);
extern int of_flat_dt_is_compatible(unsigned long node, const char *name);
extern int of_flat_dt_match(unsigned long node, const char *const *matches);
extern unsigned long of_get_flat_dt_root(void);
extern int of_get_flat_dt_size(void);
extern uint32_t of_get_flat_dt_phandle(unsigned long node);
 
/*
 * early_init_dt_scan_chosen - scan the device tree for ramdisk and bootargs
 *
 * The boot arguments will be placed into the memory pointed to by @data.
 * That memory should be COMMAND_LINE_SIZE big and initialized to be a valid
 * (possibly empty) string.  Logic for what will be in @data after this
 * function finishes:
 *
 * - CONFIG_CMDLINE_FORCE=true
 *     CONFIG_CMDLINE
 * - CONFIG_CMDLINE_EXTEND=true, @data is non-empty string
 *     @data + dt bootargs (even if dt bootargs are empty)
 * - CONFIG_CMDLINE_EXTEND=true, @data is empty string
 *     CONFIG_CMDLINE + dt bootargs (even if dt bootargs are empty)
 * - CMDLINE_FROM_BOOTLOADER=true, dt bootargs=non-empty:
 *     dt bootargs
 * - CMDLINE_FROM_BOOTLOADER=true, dt bootargs=empty, @data is non-empty string
 *     @data is left unchanged
 * - CMDLINE_FROM_BOOTLOADER=true, dt bootargs=empty, @data is empty string
 *     CONFIG_CMDLINE (or "" if that's not defined)
 */
extern int early_init_dt_scan_chosen(unsigned long node, const char *uname,
                    int depth, void *data);
extern int early_init_dt_scan_memory(unsigned long node, const char *uname,
                    int depth, void *data);
extern int early_init_dt_scan_chosen_stdout(void);
extern void early_init_fdt_scan_reserved_mem(void);
extern void early_init_fdt_reserve_self(void);
extern void early_init_dt_add_memory_arch(u64 base, u64 size);
extern int early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size);
extern int early_init_dt_reserve_memory_arch(phys_addr_t base, phys_addr_t size,
                        bool no_map);
extern u64 dt_mem_next_cell(int s, const __be32 **cellp);
 
/* Early flat tree scan hooks */
extern int early_init_dt_scan_root(unsigned long node, const char *uname,
                  int depth, void *data);
 
extern bool early_init_dt_scan(void *params);
extern bool early_init_dt_verify(void *params);
extern void early_init_dt_scan_nodes(void);
 
extern const char *of_flat_dt_get_machine_name(void);
extern const void *of_flat_dt_match_machine(const void *default_match,
       const void * (*get_next_compat)(const char * const**));
 
/* Other Prototypes */
extern void unflatten_device_tree(void);
extern void unflatten_and_copy_device_tree(void);
extern void early_init_devtree(void *);
extern void early_get_first_memblock_info(void *, phys_addr_t *);
#else /* CONFIG_OF_EARLY_FLATTREE */
static inline int early_init_dt_scan_chosen_stdout(void) { return -ENODEV; }
static inline void early_init_fdt_scan_reserved_mem(void) {}
static inline void early_init_fdt_reserve_self(void) {}
static inline const char *of_flat_dt_get_machine_name(void) { return NULL; }
static inline void unflatten_device_tree(void) {}
static inline void unflatten_and_copy_device_tree(void) {}
#endif /* CONFIG_OF_EARLY_FLATTREE */
 
#endif /* __ASSEMBLY__ */
#endif /* _LINUX_OF_FDT_H */