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
|
/* SPDX-License-Identifier: GPL-2.0-only */
#include <console/console.h>
#include <device/device.h>
#include <device/pci.h>
#include <reset.h>
void enable_static_device(struct device *dev)
{
if (dev->chip_ops && dev->chip_ops->enable_dev)
dev->chip_ops->enable_dev(dev);
if (dev->ops && dev->ops->enable)
dev->ops->enable(dev);
printk(BIOS_DEBUG, "%s %s\n", dev_path(dev),
dev->enabled ? "enabled" : "disabled");
}
/**
* Enable devices on static buses.
*
* The enumeration of certain buses is purely static. The existence of
* devices on those buses can be completely determined at compile time
* and is specified in the config file. Typical examples are the 'PNP'
* devices on a legacy ISA/LPC bus. There is no need of probing of any kind,
* the only thing we have to do is to walk through the bus and
* enable or disable devices as indicated in the config file.
*
* On the other hand, some devices are virtual and their existence is
* artificial. They can not be probed at run time. One example is the
* debug device. Those virtual devices have to be listed in the config
* file under some static bus in order to be enumerated at run time.
*
* @param bus Pointer to the device to which the static buses are attached to.
*/
void enable_static_devices(struct device *bus)
{
struct device *child;
if (!bus->downstream)
return;
for (child = bus->downstream->children; child; child = child->sibling)
enable_static_device(child);
}
void scan_generic_bus(struct device *bus)
{
struct device *child;
static int bus_max = 0;
printk(BIOS_SPEW, "%s for %s\n", __func__, dev_path(bus));
if (bus->downstream) {
bus->downstream->secondary = ++bus_max;
for (child = bus->downstream->children; child; child = child->sibling) {
enable_static_device(child);
printk(BIOS_DEBUG, "bus: %s->", dev_path(child->upstream->dev));
}
}
printk(BIOS_SPEW, "%s for %s done\n", __func__, dev_path(bus));
}
void scan_smbus(struct device *bus)
{
scan_generic_bus(bus);
}
/*
* Default scan_bus() implementation
*
* This is the default implementation for buses that can't
* be probed at runtime. It simply walks through the topology
* given by the mainboard's `devicetree.cb`.
*
* First, all direct descendants of the given device are
* enabled. Then, downstream buses are scanned.
*/
void scan_static_bus(struct device *bus)
{
printk(BIOS_SPEW, "%s for %s\n", __func__, dev_path(bus));
enable_static_devices(bus);
if (bus->downstream)
scan_bridges(bus->downstream);
printk(BIOS_SPEW, "%s for %s done\n", __func__, dev_path(bus));
}
static void root_dev_reset(struct bus *bus)
{
printk(BIOS_INFO, "Resetting board...\n");
board_reset();
}
#if CONFIG(HAVE_ACPI_TABLES)
static const char *root_dev_acpi_name(const struct device *dev)
{
return "\\_SB";
}
#endif
/**
* Default device operation for root device.
*
* This is the default device operation for root devices. These operations
* should be fully usable as is. However the chip_operations::enable_dev()
* of a motherboard can override this if you want non-default behavior.
*/
struct device_operations default_dev_ops_root = {
.read_resources = noop_read_resources,
.set_resources = noop_set_resources,
.scan_bus = scan_static_bus,
.reset_bus = root_dev_reset,
#if CONFIG(HAVE_ACPI_TABLES)
.acpi_name = root_dev_acpi_name,
#endif
};
|
