Commit | Line | Data |
---|---|---|
9b6b563c PM |
1 | #ifndef _POWERPC_PROM_H |
2 | #define _POWERPC_PROM_H | |
3 | #ifdef __KERNEL__ | |
4 | ||
5 | /* | |
6 | * Definitions for talking to the Open Firmware PROM on | |
7 | * Power Macintosh computers. | |
8 | * | |
9 | * Copyright (C) 1996-2005 Paul Mackerras. | |
10 | * | |
11 | * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp. | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or | |
14 | * modify it under the terms of the GNU General Public License | |
15 | * as published by the Free Software Foundation; either version | |
16 | * 2 of the License, or (at your option) any later version. | |
17 | */ | |
18 | #include <linux/types.h> | |
19 | #include <linux/proc_fs.h> | |
a9b14973 | 20 | #include <linux/platform_device.h> |
99ddef9b | 21 | #include <asm/irq.h> |
9b6b563c PM |
22 | #include <asm/atomic.h> |
23 | ||
97e873e5 SR |
24 | #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1 |
25 | #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 | |
26 | ||
9b6b563c PM |
27 | /* Definitions used by the flattened device tree */ |
28 | #define OF_DT_HEADER 0xd00dfeed /* marker */ | |
29 | #define OF_DT_BEGIN_NODE 0x1 /* Start of node, full name */ | |
30 | #define OF_DT_END_NODE 0x2 /* End node */ | |
31 | #define OF_DT_PROP 0x3 /* Property: name off, size, | |
32 | * content */ | |
33 | #define OF_DT_NOP 0x4 /* nop */ | |
34 | #define OF_DT_END 0x9 | |
35 | ||
36 | #define OF_DT_VERSION 0x10 | |
37 | ||
38 | /* | |
39 | * This is what gets passed to the kernel by prom_init or kexec | |
40 | * | |
41 | * The dt struct contains the device tree structure, full pathes and | |
42 | * property contents. The dt strings contain a separate block with just | |
43 | * the strings for the property names, and is fully page aligned and | |
44 | * self contained in a page, so that it can be kept around by the kernel, | |
45 | * each property name appears only once in this page (cheap compression) | |
46 | * | |
47 | * the mem_rsvmap contains a map of reserved ranges of physical memory, | |
48 | * passing it here instead of in the device-tree itself greatly simplifies | |
49 | * the job of everybody. It's just a list of u64 pairs (base/size) that | |
50 | * ends when size is 0 | |
51 | */ | |
52 | struct boot_param_header | |
53 | { | |
54 | u32 magic; /* magic word OF_DT_HEADER */ | |
55 | u32 totalsize; /* total size of DT block */ | |
56 | u32 off_dt_struct; /* offset to structure */ | |
57 | u32 off_dt_strings; /* offset to strings */ | |
58 | u32 off_mem_rsvmap; /* offset to memory reserve map */ | |
59 | u32 version; /* format version */ | |
60 | u32 last_comp_version; /* last compatible version */ | |
61 | /* version 2 fields below */ | |
62 | u32 boot_cpuid_phys; /* Physical CPU id we're booting on */ | |
63 | /* version 3 fields below */ | |
64 | u32 dt_strings_size; /* size of the DT strings block */ | |
0e0293c8 DG |
65 | /* version 17 fields below */ |
66 | u32 dt_struct_size; /* size of the DT structure block */ | |
9b6b563c PM |
67 | }; |
68 | ||
69 | ||
70 | ||
71 | typedef u32 phandle; | |
72 | typedef u32 ihandle; | |
73 | ||
9b6b563c PM |
74 | struct property { |
75 | char *name; | |
76 | int length; | |
1a38147e | 77 | void *value; |
9b6b563c PM |
78 | struct property *next; |
79 | }; | |
80 | ||
81 | struct device_node { | |
a7f67bdf JK |
82 | const char *name; |
83 | const char *type; | |
9b6b563c PM |
84 | phandle node; |
85 | phandle linux_phandle; | |
9b6b563c PM |
86 | char *full_name; |
87 | ||
88 | struct property *properties; | |
088186de | 89 | struct property *deadprops; /* removed properties */ |
9b6b563c PM |
90 | struct device_node *parent; |
91 | struct device_node *child; | |
92 | struct device_node *sibling; | |
93 | struct device_node *next; /* next device of same type */ | |
94 | struct device_node *allnext; /* next in list of all nodes */ | |
95 | struct proc_dir_entry *pde; /* this node's proc directory */ | |
96 | struct kref kref; | |
97 | unsigned long _flags; | |
98 | void *data; | |
99 | }; | |
100 | ||
101 | extern struct device_node *of_chosen; | |
102 | ||
d3b814bb ME |
103 | static inline int of_node_check_flag(struct device_node *n, unsigned long flag) |
104 | { | |
105 | return test_bit(flag, &n->_flags); | |
106 | } | |
107 | ||
108 | static inline void of_node_set_flag(struct device_node *n, unsigned long flag) | |
109 | { | |
110 | set_bit(flag, &n->_flags); | |
111 | } | |
9b6b563c | 112 | |
9b6b563c PM |
113 | |
114 | #define HAVE_ARCH_DEVTREE_FIXUPS | |
115 | ||
116 | static inline void set_node_proc_entry(struct device_node *dn, struct proc_dir_entry *de) | |
117 | { | |
118 | dn->pde = de; | |
119 | } | |
120 | ||
121 | ||
9b6b563c | 122 | extern struct device_node *of_find_all_nodes(struct device_node *prev); |
9b6b563c PM |
123 | extern struct device_node *of_node_get(struct device_node *node); |
124 | extern void of_node_put(struct device_node *node); | |
125 | ||
3c726f8d | 126 | /* For scanning the flat device-tree at boot time */ |
e8222502 BH |
127 | extern int __init of_scan_flat_dt(int (*it)(unsigned long node, |
128 | const char *uname, int depth, | |
129 | void *data), | |
130 | void *data); | |
131 | extern void* __init of_get_flat_dt_prop(unsigned long node, const char *name, | |
132 | unsigned long *size); | |
133 | extern int __init of_flat_dt_is_compatible(unsigned long node, const char *name); | |
134 | extern unsigned long __init of_get_flat_dt_root(void); | |
3c726f8d | 135 | |
9b6b563c PM |
136 | /* For updating the device tree at runtime */ |
137 | extern void of_attach_node(struct device_node *); | |
138 | extern void of_detach_node(const struct device_node *); | |
139 | ||
140 | /* Other Prototypes */ | |
141 | extern void finish_device_tree(void); | |
142 | extern void unflatten_device_tree(void); | |
143 | extern void early_init_devtree(void *); | |
7a92f74f | 144 | #define device_is_compatible(d, c) of_device_is_compatible((d), (c)) |
9b6b563c | 145 | extern int machine_is_compatible(const char *compat); |
9b6b563c | 146 | extern void print_properties(struct device_node *node); |
9b6b563c PM |
147 | extern int prom_n_intr_cells(struct device_node* np); |
148 | extern void prom_get_irq_senses(unsigned char *senses, int off, int max); | |
183d0202 | 149 | extern int prom_add_property(struct device_node* np, struct property* prop); |
088186de DB |
150 | extern int prom_remove_property(struct device_node *np, struct property *prop); |
151 | extern int prom_update_property(struct device_node *np, | |
152 | struct property *newprop, | |
153 | struct property *oldprop); | |
9b6b563c | 154 | |
40ef8cbc | 155 | #ifdef CONFIG_PPC32 |
9b6b563c PM |
156 | /* |
157 | * PCI <-> OF matching functions | |
158 | * (XXX should these be here?) | |
159 | */ | |
160 | struct pci_bus; | |
161 | struct pci_dev; | |
162 | extern int pci_device_from_OF_node(struct device_node *node, | |
163 | u8* bus, u8* devfn); | |
164 | extern struct device_node* pci_busdev_to_OF_node(struct pci_bus *, int); | |
165 | extern struct device_node* pci_device_to_OF_node(struct pci_dev *); | |
166 | extern void pci_create_OF_bus_map(void); | |
40ef8cbc PM |
167 | #endif |
168 | ||
9b6b563c PM |
169 | extern struct resource *request_OF_resource(struct device_node* node, |
170 | int index, const char* name_postfix); | |
171 | extern int release_OF_resource(struct device_node* node, int index); | |
172 | ||
d2dd482b | 173 | |
d1405b86 | 174 | /* |
d2dd482b BH |
175 | * OF address retreival & translation |
176 | */ | |
177 | ||
178 | ||
a4dc7ff0 | 179 | /* Helper to read a big number; size is in cells (not bytes) */ |
b5a1a9ab | 180 | static inline u64 of_read_number(const u32 *cell, int size) |
cc9fd71c BH |
181 | { |
182 | u64 r = 0; | |
183 | while (size--) | |
184 | r = (r << 32) | *(cell++); | |
185 | return r; | |
186 | } | |
187 | ||
a4dc7ff0 PM |
188 | /* Like of_read_number, but we want an unsigned long result */ |
189 | #ifdef CONFIG_PPC32 | |
190 | static inline unsigned long of_read_ulong(const u32 *cell, int size) | |
191 | { | |
192 | return cell[size-1]; | |
193 | } | |
194 | #else | |
195 | #define of_read_ulong(cell, size) of_read_number(cell, size) | |
196 | #endif | |
197 | ||
d2dd482b | 198 | /* Translate an OF address block into a CPU physical address |
d1405b86 | 199 | */ |
a7f67bdf | 200 | extern u64 of_translate_address(struct device_node *np, const u32 *addr); |
d1405b86 | 201 | |
d2dd482b BH |
202 | /* Extract an address from a device, returns the region size and |
203 | * the address space flags too. The PCI version uses a BAR number | |
204 | * instead of an absolute index | |
205 | */ | |
a7f67bdf | 206 | extern const u32 *of_get_address(struct device_node *dev, int index, |
d2dd482b | 207 | u64 *size, unsigned int *flags); |
a7f67bdf | 208 | extern const u32 *of_get_pci_address(struct device_node *dev, int bar_no, |
d2dd482b BH |
209 | u64 *size, unsigned int *flags); |
210 | ||
211 | /* Get an address as a resource. Note that if your address is | |
212 | * a PIO address, the conversion will fail if the physical address | |
213 | * can't be internally converted to an IO token with | |
214 | * pci_address_to_pio(), that is because it's either called to early | |
215 | * or it can't be matched to any host bridge IO space | |
216 | */ | |
217 | extern int of_address_to_resource(struct device_node *dev, int index, | |
218 | struct resource *r); | |
219 | extern int of_pci_address_to_resource(struct device_node *dev, int bar, | |
220 | struct resource *r); | |
d1405b86 | 221 | |
d4ad66fa JK |
222 | /* Parse the ibm,dma-window property of an OF node into the busno, phys and |
223 | * size parameters. | |
224 | */ | |
a7f67bdf | 225 | void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop, |
d4ad66fa JK |
226 | unsigned long *busno, unsigned long *phys, unsigned long *size); |
227 | ||
b68239ee ME |
228 | extern void kdump_move_device_tree(void); |
229 | ||
acf7d768 BH |
230 | /* CPU OF node matching */ |
231 | struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); | |
232 | ||
29cfe6f4 TT |
233 | /* Get the MAC address */ |
234 | extern const void *of_get_mac_address(struct device_node *np); | |
cc9fd71c BH |
235 | |
236 | /* | |
237 | * OF interrupt mapping | |
238 | */ | |
239 | ||
240 | /* This structure is returned when an interrupt is mapped. The controller | |
241 | * field needs to be put() after use | |
242 | */ | |
243 | ||
244 | #define OF_MAX_IRQ_SPEC 4 /* We handle specifiers of at most 4 cells */ | |
245 | ||
246 | struct of_irq { | |
247 | struct device_node *controller; /* Interrupt controller node */ | |
248 | u32 size; /* Specifier size */ | |
249 | u32 specifier[OF_MAX_IRQ_SPEC]; /* Specifier copy */ | |
250 | }; | |
251 | ||
40681b95 | 252 | /** |
cc9fd71c BH |
253 | * of_irq_map_init - Initialize the irq remapper |
254 | * @flags: flags defining workarounds to enable | |
255 | * | |
256 | * Some machines have bugs in the device-tree which require certain workarounds | |
257 | * to be applied. Call this before any interrupt mapping attempts to enable | |
258 | * those workarounds. | |
259 | */ | |
260 | #define OF_IMAP_OLDWORLD_MAC 0x00000001 | |
261 | #define OF_IMAP_NO_PHANDLE 0x00000002 | |
262 | ||
263 | extern void of_irq_map_init(unsigned int flags); | |
264 | ||
40681b95 | 265 | /** |
cc9fd71c BH |
266 | * of_irq_map_raw - Low level interrupt tree parsing |
267 | * @parent: the device interrupt parent | |
268 | * @intspec: interrupt specifier ("interrupts" property of the device) | |
006b64de | 269 | * @ointsize: size of the passed in interrupt specifier |
cc9fd71c BH |
270 | * @addr: address specifier (start of "reg" property of the device) |
271 | * @out_irq: structure of_irq filled by this function | |
272 | * | |
273 | * Returns 0 on success and a negative number on error | |
274 | * | |
275 | * This function is a low-level interrupt tree walking function. It | |
276 | * can be used to do a partial walk with synthetized reg and interrupts | |
277 | * properties, for example when resolving PCI interrupts when no device | |
278 | * node exist for the parent. | |
279 | * | |
280 | */ | |
281 | ||
a7f67bdf | 282 | extern int of_irq_map_raw(struct device_node *parent, const u32 *intspec, |
aa43f779 | 283 | u32 ointsize, const u32 *addr, |
cc9fd71c BH |
284 | struct of_irq *out_irq); |
285 | ||
286 | ||
40681b95 | 287 | /** |
cc9fd71c BH |
288 | * of_irq_map_one - Resolve an interrupt for a device |
289 | * @device: the device whose interrupt is to be resolved | |
290 | * @index: index of the interrupt to resolve | |
291 | * @out_irq: structure of_irq filled by this function | |
292 | * | |
293 | * This function resolves an interrupt, walking the tree, for a given | |
294 | * device-tree node. It's the high level pendant to of_irq_map_raw(). | |
295 | * It also implements the workarounds for OldWolrd Macs. | |
296 | */ | |
297 | extern int of_irq_map_one(struct device_node *device, int index, | |
298 | struct of_irq *out_irq); | |
299 | ||
40681b95 | 300 | /** |
cc9fd71c BH |
301 | * of_irq_map_pci - Resolve the interrupt for a PCI device |
302 | * @pdev: the device whose interrupt is to be resolved | |
303 | * @out_irq: structure of_irq filled by this function | |
304 | * | |
305 | * This function resolves the PCI interrupt for a given PCI device. If a | |
306 | * device-node exists for a given pci_dev, it will use normal OF tree | |
307 | * walking. If not, it will implement standard swizzling and walk up the | |
308 | * PCI tree until an device-node is found, at which point it will finish | |
309 | * resolving using the OF tree walking. | |
310 | */ | |
311 | struct pci_dev; | |
312 | extern int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq); | |
313 | ||
c0b3ae14 MD |
314 | extern int of_irq_to_resource(struct device_node *dev, int index, |
315 | struct resource *r); | |
a9b14973 | 316 | |
c3e8011a CK |
317 | /** |
318 | * of_iomap - Maps the memory mapped IO for a given device_node | |
319 | * @device: the device whose io range will be mapped | |
320 | * @index: index of the io range | |
321 | * | |
322 | * Returns a pointer to the mapped memory | |
323 | */ | |
324 | extern void __iomem *of_iomap(struct device_node *device, int index); | |
cc9fd71c | 325 | |
76c1ce78 SR |
326 | /* |
327 | * NB: This is here while we transition from using asm/prom.h | |
328 | * to linux/of.h | |
329 | */ | |
330 | #include <linux/of.h> | |
331 | ||
9b6b563c PM |
332 | #endif /* __KERNEL__ */ |
333 | #endif /* _POWERPC_PROM_H */ |