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
|
/* SPDX-License-Identifier: GPL-2.0-only */
#include <stdbool.h>
#include <console/console.h>
#include <device/device.h>
#include <device/resource.h>
#include <defs_iio.h>
#include <hob_iiouds.h>
#include <intelblocks/acpi.h>
#include <soc/acpi.h>
#include <IioPcieConfigUpd.h>
#include <soc/chip_common.h>
/*
* Used for IIO stacks for accelerators and other functionality (IOAT).
* Those have only integrated PCI endpoints (no bridges) behind the host bridge.
*/
static struct device_operations ioat_domain_ops = {
.read_resources = noop_read_resources,
.set_resources = pci_domain_set_resources,
.scan_bus = pci_host_bridge_scan_bus,
#if CONFIG(HAVE_ACPI_TABLES)
.acpi_name = soc_acpi_name,
#endif
};
static void create_ioat_domain(const union xeon_domain_path dp, struct bus *const upstream,
const unsigned int bus_base, const unsigned int bus_limit,
const resource_t mem32_base, const resource_t mem32_limit,
const resource_t mem64_base, const resource_t mem64_limit,
const char *prefix)
{
union xeon_domain_path new_path = {
.domain_path = dp.domain_path
};
new_path.bus = bus_base;
struct device_path path = {
.type = DEVICE_PATH_DOMAIN,
.domain = {
.domain = new_path.domain_path,
},
};
struct device *const domain = alloc_dev(upstream, &path);
if (!domain)
die("%s: out of memory.\n", __func__);
domain->ops = &ioat_domain_ops;
iio_domain_set_acpi_name(domain, prefix);
struct bus *const bus = alloc_bus(domain);
bus->secondary = bus_base;
bus->subordinate = bus->secondary;
bus->max_subordinate = bus_limit;
unsigned int index = 0;
if (mem32_base <= mem32_limit) {
struct resource *const res = new_resource(domain, index++);
res->base = mem32_base;
res->limit = mem32_limit;
res->size = res->limit - res->base + 1;
res->flags = IORESOURCE_MEM | IORESOURCE_ASSIGNED;
}
if (mem64_base <= mem64_limit) {
struct resource *const res = new_resource(domain, index++);
res->base = mem64_base;
res->limit = mem64_limit;
res->size = res->limit - res->base + 1;
res->flags = IORESOURCE_MEM | IORESOURCE_ASSIGNED;
}
}
void soc_create_ioat_domains(const union xeon_domain_path path, struct bus *const bus, const STACK_RES *const sr)
{
if (sr->BusLimit < sr->BusBase + HQM_BUS_OFFSET + HQM_RESERVED_BUS) {
printk(BIOS_WARNING,
"Ignoring IOAT domain with limited bus range.\n");
return;
}
if (sr->PciResourceMem64Limit - sr->PciResourceMem64Base + 1
< 2 * CPM_MMIO_SIZE + 2 * HQM_MMIO_SIZE) {
printk(BIOS_WARNING,
"Ignoring IOAT domain with limited 64-bit MMIO window.\n");
return;
}
/* The FSP HOB doesn't provide accurate information about the
resource allocation. Hence use pre-defined offsets. Based
on ACPI code in create_dsdt_ioat_resource(), soc_acpi.c: */
resource_t mem64_base, mem64_limit, bus_base, bus_limit;
/* CPM0 */
mem64_base = sr->PciResourceMem64Base;
mem64_limit = mem64_base + CPM_MMIO_SIZE - 1;
bus_base = sr->BusBase + CPM_BUS_OFFSET;
bus_limit = bus_base + CPM_RESERVED_BUS;
create_ioat_domain(path, bus, bus_base, bus_limit, 0, -1, mem64_base, mem64_limit,
DOMAIN_TYPE_CPM0);
/* HQM0 */
mem64_base = mem64_limit + 1;
mem64_limit = mem64_base + HQM_MMIO_SIZE - 1;
bus_base = sr->BusBase + HQM_BUS_OFFSET;
bus_limit = bus_base + HQM_RESERVED_BUS;
create_ioat_domain(path, bus, bus_base, bus_limit, 0, -1, mem64_base, mem64_limit,
DOMAIN_TYPE_HQM0);
/* CPM1 (optional) */
mem64_base = mem64_limit + 1;
mem64_limit = mem64_base + CPM_MMIO_SIZE - 1;
bus_base = sr->BusBase + CPM1_BUS_OFFSET;
bus_limit = bus_base + CPM_RESERVED_BUS;
if (bus_limit <= sr->BusLimit)
create_ioat_domain(path, bus, bus_base, bus_limit, 0, -1, mem64_base, mem64_limit,
DOMAIN_TYPE_CPM1);
/* HQM1 (optional) */
mem64_base = mem64_limit + 1;
mem64_limit = mem64_base + HQM_MMIO_SIZE - 1;
bus_base = sr->BusBase + HQM1_BUS_OFFSET;
bus_limit = bus_base + HQM_RESERVED_BUS;
if (bus_limit <= sr->BusLimit)
create_ioat_domain(path, bus, bus_base, bus_limit, 0, -1, mem64_base, mem64_limit,
DOMAIN_TYPE_HQM1);
/* DINO */
mem64_base = mem64_limit + 1;
mem64_limit = sr->PciResourceMem64Limit;
bus_base = sr->BusBase;
bus_limit = bus_base;
create_ioat_domain(path, bus, bus_base, bus_limit, sr->PciResourceMem32Base, sr->PciResourceMem32Limit,
mem64_base, mem64_limit, DOMAIN_TYPE_DINO);
}
|
