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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
|
/* SPDX-License-Identifier: GPL-2.0-only */
#ifndef DEVICE_H
#define DEVICE_H
#include <device/resource.h>
#include <device/path.h>
#include <device/pci_type.h>
#include <smbios.h>
#include <static.h>
#include <types.h>
struct fw_config;
struct device;
struct pci_operations;
struct i2c_bus_operations;
struct smbus_bus_operations;
struct pnp_mode_ops;
struct spi_bus_operations;
struct usb_bus_operations;
struct gpio_operations;
struct mdio_bus_operations;
/* Chip operations */
struct chip_operations {
void (*enable_dev)(struct device *dev);
void (*init)(void *chip_info);
void (*final)(void *chip_info);
unsigned int initialized : 1;
unsigned int finalized : 1;
const char *name;
};
#define CHIP_NAME(X) .name = X,
struct bus;
struct acpi_rsdp;
struct device_operations {
void (*read_resources)(struct device *dev);
void (*set_resources)(struct device *dev);
void (*enable_resources)(struct device *dev);
void (*init)(struct device *dev);
void (*final)(struct device *dev);
void (*scan_bus)(struct device *bus);
void (*enable)(struct device *dev);
void (*vga_disable)(struct device *dev);
void (*reset_bus)(struct bus *bus);
int (*get_smbios_data)(struct device *dev, int *handle,
unsigned long *current);
void (*get_smbios_strings)(struct device *dev, struct smbios_type11 *t);
#if CONFIG(HAVE_ACPI_TABLES)
unsigned long (*write_acpi_tables)(const struct device *dev,
unsigned long start, struct acpi_rsdp *rsdp);
void (*acpi_fill_ssdt)(const struct device *dev);
void (*acpi_inject_dsdt)(const struct device *dev);
const char *(*acpi_name)(const struct device *dev);
/* Returns the optional _HID (Hardware ID) */
const char *(*acpi_hid)(const struct device *dev);
#endif
const struct pci_operations *ops_pci;
const struct i2c_bus_operations *ops_i2c_bus;
const struct spi_bus_operations *ops_spi_bus;
const struct smbus_bus_operations *ops_smbus_bus;
const struct pnp_mode_ops *ops_pnp_mode;
const struct gpio_operations *ops_gpio;
const struct mdio_bus_operations *ops_mdio;
};
/**
* Standard device operations function pointers shims.
*/
static inline void noop_read_resources(struct device *dev) {}
static inline void noop_set_resources(struct device *dev) {}
struct bus {
DEVTREE_CONST struct device *dev; /* This bridge device */
DEVTREE_CONST struct device *children; /* devices behind this bridge */
DEVTREE_CONST struct bus *next; /* The next bridge on this device */
unsigned int bridge_ctrl; /* Bridge control register */
uint16_t bridge_cmd; /* Bridge command register */
unsigned char link_num; /* The index of this link */
uint16_t secondary; /* secondary bus number */
uint16_t subordinate; /* subordinate bus number */
uint16_t max_subordinate; /* max subordinate bus number */
unsigned int reset_needed : 1;
unsigned int no_vga16 : 1; /* No support for 16-bit VGA decoding */
};
/*
* There is one device structure for each slot-number/function-number
* combination:
*/
struct device {
DEVTREE_CONST struct bus *bus; /* bus this device is on, for bridge
* devices, it is the up stream bus */
DEVTREE_CONST struct device *sibling; /* next device on this bus */
DEVTREE_CONST struct device *next; /* chain of all devices */
struct device_path path;
unsigned int vendor;
unsigned int device;
u16 subsystem_vendor;
u16 subsystem_device;
unsigned int class; /* 3 bytes: (base, sub, prog-if) */
unsigned int hdr_type; /* PCI header type */
unsigned int enabled : 1; /* set if we should enable the device */
unsigned int initialized : 1; /* 1 if we have initialized the device */
unsigned int on_mainboard : 1;
unsigned int disable_pcie_aspm : 1;
/* set if we should hide from UI */
unsigned int hidden : 1;
/* set if this device is used even in minimum PCI cases */
unsigned int mandatory : 1;
unsigned int hotplug_port : 1;
u8 command;
uint16_t hotplug_buses; /* Number of hotplug buses to allocate */
/* Base registers for this device. I/O, MEM and Expansion ROM */
DEVTREE_CONST struct resource *resource_list;
/* links are (downstream) buses attached to the device, usually a leaf
* device with no children has 0 buses attached and a bridge has 1 bus
*/
DEVTREE_CONST struct bus *link_list;
#if !DEVTREE_EARLY
struct device_operations *ops;
struct chip_operations *chip_ops;
const char *name;
#if CONFIG(GENERATE_SMBIOS_TABLES)
u8 smbios_slot_type;
u8 smbios_slot_data_width;
u8 smbios_slot_length;
const char *smbios_slot_designation;
#if CONFIG(SMBIOS_TYPE41_PROVIDED_BY_DEVTREE)
/*
* These fields are intentionally guarded so that attempts to use
* the corresponding devicetree syntax without selecting the Kconfig
* option result in build-time errors. Smaller size is a side effect.
*/
bool smbios_instance_id_valid;
u8 smbios_instance_id;
const char *smbios_refdes;
#endif
#endif
#endif
DEVTREE_CONST void *chip_info;
/* Zero-terminated array of fields and options to probe. */
DEVTREE_CONST struct fw_config *probe_list;
};
/**
* This is the root of the device tree. The device tree is defined in the
* static.c file and is generated by the config tool at compile time.
*/
extern DEVTREE_CONST struct device dev_root;
/* list of all devices */
extern DEVTREE_CONST struct device * DEVTREE_CONST all_devices;
extern struct resource *free_resources;
extern struct bus *free_links;
/* Generic device interface functions */
struct device *alloc_dev(struct bus *parent, struct device_path *path);
void dev_initialize_chips(void);
void dev_enumerate(void);
void dev_configure(void);
void dev_enable(void);
void dev_initialize(void);
void dev_finalize(void);
void dev_finalize_chips(void);
/* Function used to override device state */
void devfn_disable(const struct bus *bus, unsigned int devfn);
/* Generic device helper functions */
int reset_bus(struct bus *bus);
void scan_bridges(struct bus *bus);
void assign_resources(struct bus *bus);
const char *dev_name(const struct device *dev);
const char *dev_path(const struct device *dev);
u32 dev_path_encode(const struct device *dev);
const char *bus_path(struct bus *bus);
void dev_set_enabled(struct device *dev, int enable);
void disable_children(struct bus *bus);
bool dev_is_active_bridge(struct device *dev);
void add_more_links(struct device *dev, unsigned int total_links);
bool is_dev_enabled(const struct device *const dev);
bool is_devfn_enabled(unsigned int devfn);
bool is_cpu(const struct device *cpu);
bool is_enabled_cpu(const struct device *cpu);
bool is_pci(const struct device *pci);
bool is_enabled_pci(const struct device *pci);
bool is_pci_dev_on_bus(const struct device *pci, unsigned int bus);
/* Returns whether there is a hotplug port on the path to the given device. */
bool dev_path_hotplug(const struct device *);
/* Option ROM helper functions */
void run_bios(struct device *dev, unsigned long addr);
/* Helper functions */
DEVTREE_CONST struct device *find_dev_path(
const struct bus *parent,
const struct device_path *path);
DEVTREE_CONST struct device *find_dev_nested_path(
const struct bus *parent,
const struct device_path nested_path[],
size_t nested_path_length);
struct device *alloc_find_dev(struct bus *parent, struct device_path *path);
struct device *dev_find_device(u16 vendor, u16 device, struct device *from);
struct device *dev_find_class(unsigned int class, struct device *from);
DEVTREE_CONST struct device *dev_find_path(
DEVTREE_CONST struct device *prev_match,
enum device_path_type path_type);
struct device *dev_find_lapic(unsigned int apic_id);
int dev_count_cpu(void);
struct device *add_cpu_device(struct bus *cpu_bus, unsigned int apic_id,
int enabled);
void mp_init_cpus(DEVTREE_CONST struct bus *cpu_bus);
static inline void mp_cpu_bus_init(struct device *dev)
{
/*
* When no LAPIC device is specified in the devietree inside the CPU cluster device,
* neither a LAPIC device nor the link/bus between the CPU cluster and the LAPIC device
* will be present in the static device tree and the link_list struct element of the
* CPU cluster device will be NULL. In this case add one link, so that the
* alloc_find_dev calls in init_bsp and allocate_cpu_devices will be able to add a
* LAPIC device for the BSP and the APs on this link/bus.
*/
if (!dev->link_list)
add_more_links(dev, 1);
mp_init_cpus(dev->link_list);
}
/* Debug functions */
void print_resource_tree(const struct device *root, int debug_level,
const char *msg);
void show_devs_tree(const struct device *dev, int debug_level, int depth);
void show_devs_subtree(struct device *root, int debug_level, const char *msg);
void show_all_devs(int debug_level, const char *msg);
void show_all_devs_tree(int debug_level, const char *msg);
void show_one_resource(int debug_level, struct device *dev,
struct resource *resource, const char *comment);
void show_all_devs_resources(int debug_level, const char *msg);
/* Debug macros */
#if CONFIG(DEBUG_FUNC)
#include <console/console.h>
#define DEV_FUNC_ENTER(dev) \
printk(BIOS_SPEW, "%s:%s:%d: ENTER (dev: %s)\n", \
__FILE__, __func__, __LINE__, dev_path(dev))
#define DEV_FUNC_EXIT(dev) \
printk(BIOS_SPEW, "%s:%s:%d: EXIT (dev: %s)\n", __FILE__, \
__func__, __LINE__, dev_path(dev))
#else /* DEBUG_FUNC */
#define DEV_FUNC_ENTER(dev)
#define DEV_FUNC_EXIT(dev)
#endif /* DEBUG_FUNC */
extern struct device_operations default_dev_ops_root;
void pci_domain_read_resources(struct device *dev);
void pci_domain_set_resources(struct device *dev);
void pci_host_bridge_scan_bus(struct device *dev);
void mmconf_resource(struct device *dev, unsigned long index);
/* These are temporary resource constructors to get us through the
migration away from open-coding all the IORESOURCE_FLAGS. */
const struct resource *fixed_resource_range_idx(struct device *dev, unsigned long index,
uint64_t base, uint64_t size,
unsigned long flags);
static inline
const struct resource *fixed_mem_range_flags(struct device *dev, unsigned long index,
uint64_t base, uint64_t size,
unsigned long flags)
{
return fixed_resource_range_idx(dev, index, base, size, IORESOURCE_MEM | flags);
}
static inline
const struct resource *fixed_mem_from_to_flags(struct device *dev, unsigned long index,
uint64_t base, uint64_t end, unsigned long flags)
{
if (end <= base)
return NULL;
return fixed_mem_range_flags(dev, index, base, end - base, flags);
}
static inline
const struct resource *ram_range(struct device *dev, unsigned long index, uint64_t base,
uint64_t size)
{
return fixed_mem_range_flags(dev, index, base, size, IORESOURCE_CACHEABLE | IORESOURCE_STORED);
}
static inline
const struct resource *ram_from_to(struct device *dev, unsigned long index, uint64_t base,
uint64_t end)
{
if (end <= base)
return NULL;
return ram_range(dev, index, base, end - base);
}
static inline
const struct resource *reserved_ram_range(struct device *dev, unsigned long index,
uint64_t base, uint64_t size)
{
return fixed_mem_range_flags(dev, index, base, size, IORESOURCE_CACHEABLE |
IORESOURCE_RESERVE | IORESOURCE_STORED);
}
static inline
const struct resource *reserved_ram_from_to(struct device *dev, unsigned long index,
uint64_t base, uint64_t end)
{
if (end <= base)
return NULL;
return reserved_ram_range(dev, index, base, end - base);
}
static inline
const struct resource *mmio_range(struct device *dev, unsigned long index, uint64_t base,
uint64_t size)
{
return fixed_mem_range_flags(dev, index, base, size, IORESOURCE_RESERVE | IORESOURCE_STORED);
}
static inline
const struct resource *mmio_from_to(struct device *dev, unsigned long index, uint64_t base,
uint64_t end)
{
if (end <= base)
return NULL;
return mmio_range(dev, index, base, end - base);
}
const struct resource *lower_ram_end(struct device *dev, unsigned long index, uint64_t end);
const struct resource *upper_ram_end(struct device *dev, unsigned long index, uint64_t end);
#define bad_ram_range(...) reserved_ram_range(__VA_ARGS__)
#define uma_range(...) mmio_range(__VA_ARGS__)
#define uma_from_to(...) mmio_from_to(__VA_ARGS__)
static inline
const struct resource *fixed_io_range_flags(struct device *dev, unsigned long index,
uint16_t base, uint16_t size, unsigned long flags)
{
return fixed_resource_range_idx(dev, index, base, size, IORESOURCE_IO | flags);
}
static inline
const struct resource *fixed_io_from_to_flags(struct device *dev, unsigned long index,
uint16_t base, uint16_t end, unsigned long flags)
{
if (end <= base)
return NULL;
return fixed_io_range_flags(dev, index, base, end - base, flags);
}
static inline
const struct resource *fixed_io_range_reserved(struct device *dev, unsigned long index,
uint16_t base, uint16_t size)
{
return fixed_io_range_flags(dev, index, base, size, IORESOURCE_RESERVE);
}
/* Compatibility code */
static inline void fixed_mem_resource_kb(struct device *dev, unsigned long index,
unsigned long basek, unsigned long sizek,
unsigned long flags)
{
fixed_mem_range_flags(dev, index, ((uint64_t)basek) << 10,
((uint64_t)sizek) << 10, IORESOURCE_STORED | flags);
}
/* It is the caller's responsibility to adjust regions such that ram_resource_kb()
* and mmio_resource_kb() do not overlap.
*/
#define ram_resource_kb(dev, idx, basek, sizek) \
fixed_mem_resource_kb(dev, idx, basek, sizek, IORESOURCE_CACHEABLE)
#define reserved_ram_resource_kb(dev, idx, basek, sizek) \
fixed_mem_resource_kb(dev, idx, basek, sizek, IORESOURCE_CACHEABLE \
| IORESOURCE_RESERVE)
#define soft_reserved_ram_resource(dev, idx, basek, sizek) \
fixed_mem_resource(dev, idx, basek, sizek, IORESOURCE_SOFT_RESERVE)
#define bad_ram_resource_kb(dev, idx, basek, sizek) \
reserved_ram_resource_kb((dev), (idx), (basek), (sizek))
#define uma_resource_kb(dev, idx, basek, sizek) \
fixed_mem_resource_kb(dev, idx, basek, sizek, IORESOURCE_RESERVE)
#define mmio_resource_kb(dev, idx, basek, sizek) \
fixed_mem_resource_kb(dev, idx, basek, sizek, IORESOURCE_RESERVE)
void tolm_test(void *gp, struct device *dev, struct resource *new);
u32 find_pci_tolm(struct bus *bus);
DEVTREE_CONST struct device *dev_find_next_pci_device(
DEVTREE_CONST struct device *previous_dev);
DEVTREE_CONST struct device *dev_find_slot_on_smbus(unsigned int bus,
unsigned int addr);
DEVTREE_CONST struct device *dev_find_slot_pnp(u16 port, u16 device);
DEVTREE_CONST struct device *dev_bus_each_child(const struct bus *parent,
DEVTREE_CONST struct device *prev_child);
DEVTREE_CONST struct device *pcidev_path_behind(const struct bus *parent,
pci_devfn_t devfn);
DEVTREE_CONST struct device *pcidev_path_on_root(pci_devfn_t devfn);
DEVTREE_CONST struct device *pcidev_path_on_bus(unsigned int bus, pci_devfn_t devfn);
DEVTREE_CONST struct device *pcidev_on_root(uint8_t dev, uint8_t fn);
DEVTREE_CONST struct bus *pci_root_bus(void);
/* Find PCI device with given D#:F# sitting behind the given PCI-to-PCI bridge device. */
DEVTREE_CONST struct device *pcidev_path_behind_pci2pci_bridge(
const struct device *bridge,
pci_devfn_t devfn);
/* To be deprecated, avoid using.
*
* Note that this function can return the incorrect device prior
* to PCI enumeration because the secondary field of the bus object
* is 0. The failing scenario is determined by the order of the
* devices in all_devices singly-linked list as well as the time
* when this function is called (secondary reflecting topology).
*/
DEVTREE_CONST struct device *pcidev_path_on_root_debug(pci_devfn_t devfn, const char *func);
/* Robust discovery of chip_info. */
void devtree_bug(const char *func, pci_devfn_t devfn);
void __noreturn devtree_die(void);
/*
* Dies if `dev` or `dev->chip_info` are NULL. Returns `dev->chip_info` otherwise.
*
* Only use if missing `chip_info` is fatal and we can't boot. If it's
* not fatal, please handle the NULL case gracefully.
*/
static inline DEVTREE_CONST void *config_of(const struct device *dev)
{
if (dev && dev->chip_info)
return dev->chip_info;
devtree_die();
}
/*
* Returns pointer to config structure of root device (B:D:F = 0:00:0) defined by
* sconfig in static.{h/c}.
*/
#define config_of_soc() __pci_0_00_0_config
void enable_static_device(struct device *dev);
void enable_static_devices(struct device *bus);
void scan_smbus(struct device *bus);
void scan_generic_bus(struct device *bus);
void scan_static_bus(struct device *bus);
/* Macro to generate `struct device *` name that points to a device with the given alias. */
#define DEV_PTR(_alias) _dev_##_alias##_ptr
/* Macro to generate weak `struct device *` definition that points to a device with the given
alias. */
#define WEAK_DEV_PTR(_alias) \
__weak DEVTREE_CONST struct device *const DEV_PTR(_alias)
#endif /* DEVICE_H */
|