qemu

1
/*
2
 * HMAT ACPI Implementation
3
 *
4
 * Copyright(C) 2019 Intel Corporation.
5
 *
6
 * Author:
7
 *  Liu jingqi <jingqi.liu@linux.intel.com>
8
 *  Tao Xu <tao3.xu@intel.com>
9
 *
10
 * HMAT is defined in ACPI 6.3: 5.2.27 Heterogeneous Memory Attribute Table
11
 * (HMAT)
12
 *
13
 * This library is free software; you can redistribute it and/or
14
 * modify it under the terms of the GNU Lesser General Public
15
 * License as published by the Free Software Foundation; either
16
 * version 2.1 of the License, or (at your option) any later version.
17
 *
18
 * This library is distributed in the hope that it will be useful,
19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21
 * Lesser General Public License for more details.
22
 *
23
 * You should have received a copy of the GNU Lesser General Public
24
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
25
 */
26

27
#include "qemu/osdep.h"
28
#include "qemu/units.h"
29
#include "sysemu/numa.h"
30
#include "hw/acpi/aml-build.h"
31
#include "hw/acpi/hmat.h"
32

33
/*
34
 * ACPI 6.3:
35
 * 5.2.27.3 Memory Proximity Domain Attributes Structure: Table 5-145
36
 */
37
static void build_hmat_mpda(GArray *table_data, uint16_t flags,
38
                            uint32_t initiator, uint32_t mem_node)
39
{
40

41
    /* Memory Proximity Domain Attributes Structure */
42
    /* Type */
43
    build_append_int_noprefix(table_data, 0, 2);
44
    /* Reserved */
45
    build_append_int_noprefix(table_data, 0, 2);
46
    /* Length */
47
    build_append_int_noprefix(table_data, 40, 4);
48
    /* Flags */
49
    build_append_int_noprefix(table_data, flags, 2);
50
    /* Reserved */
51
    build_append_int_noprefix(table_data, 0, 2);
52
    /* Proximity Domain for the Attached Initiator */
53
    build_append_int_noprefix(table_data, initiator, 4);
54
    /* Proximity Domain for the Memory */
55
    build_append_int_noprefix(table_data, mem_node, 4);
56
    /* Reserved */
57
    build_append_int_noprefix(table_data, 0, 4);
58
    /*
59
     * Reserved:
60
     * Previously defined as the Start Address of the System Physical
61
     * Address Range. Deprecated since ACPI Spec 6.3.
62
     */
63
    build_append_int_noprefix(table_data, 0, 8);
64
    /*
65
     * Reserved:
66
     * Previously defined as the Range Length of the region in bytes.
67
     * Deprecated since ACPI Spec 6.3.
68
     */
69
    build_append_int_noprefix(table_data, 0, 8);
70
}
71

72
/*
73
 * ACPI 6.3: 5.2.27.4 System Locality Latency and Bandwidth Information
74
 * Structure: Table 5-146
75
 */
76
static void build_hmat_lb(GArray *table_data, HMAT_LB_Info *hmat_lb,
77
                          uint32_t num_initiator, uint32_t num_target,
78
                          uint32_t *initiator_list)
79
{
80
    int i, index;
81
    uint32_t initiator_to_index[MAX_NODES] = {};
82
    HMAT_LB_Data *lb_data;
83
    uint16_t *entry_list;
84
    uint32_t base;
85
    /* Length in bytes for entire structure */
86
    uint32_t lb_length
87
        = 32 /* Table length up to and including Entry Base Unit */
88
        + 4 * num_initiator /* Initiator Proximity Domain List */
89
        + 4 * num_target /* Target Proximity Domain List */
90
        + 2 * num_initiator * num_target; /* Latency or Bandwidth Entries */
91

92
    /* Type */
93
    build_append_int_noprefix(table_data, 1, 2);
94
    /* Reserved */
95
    build_append_int_noprefix(table_data, 0, 2);
96
    /* Length */
97
    build_append_int_noprefix(table_data, lb_length, 4);
98
    /* Flags: Bits [3:0] Memory Hierarchy, Bits[7:4] Reserved */
99
    assert(!(hmat_lb->hierarchy >> 4));
100
    build_append_int_noprefix(table_data, hmat_lb->hierarchy, 1);
101
    /* Data Type */
102
    build_append_int_noprefix(table_data, hmat_lb->data_type, 1);
103
    /* Reserved */
104
    build_append_int_noprefix(table_data, 0, 2);
105
    /* Number of Initiator Proximity Domains (s) */
106
    build_append_int_noprefix(table_data, num_initiator, 4);
107
    /* Number of Target Proximity Domains (t) */
108
    build_append_int_noprefix(table_data, num_target, 4);
109
    /* Reserved */
110
    build_append_int_noprefix(table_data, 0, 4);
111

112
    /* Entry Base Unit */
113
    if (hmat_lb->data_type <= HMAT_LB_DATA_WRITE_LATENCY) {
114
        /* Convert latency base from nanoseconds to picosecond */
115
        base = hmat_lb->base * 1000;
116
    } else {
117
        /* Convert bandwidth base from Byte to Megabyte */
118
        base = hmat_lb->base / MiB;
119
    }
120
    build_append_int_noprefix(table_data, base, 8);
121

122
    /* Initiator Proximity Domain List */
123
    for (i = 0; i < num_initiator; i++) {
124
        build_append_int_noprefix(table_data, initiator_list[i], 4);
125
        /* Reverse mapping for array possitions */
126
        initiator_to_index[initiator_list[i]] = i;
127
    }
128

129
    /* Target Proximity Domain List */
130
    for (i = 0; i < num_target; i++) {
131
        build_append_int_noprefix(table_data, i, 4);
132
    }
133

134
    /* Latency or Bandwidth Entries */
135
    entry_list = g_new0(uint16_t, num_initiator * num_target);
136
    for (i = 0; i < hmat_lb->list->len; i++) {
137
        lb_data = &g_array_index(hmat_lb->list, HMAT_LB_Data, i);
138
        index = initiator_to_index[lb_data->initiator] * num_target +
139
            lb_data->target;
140

141
        entry_list[index] = (uint16_t)(lb_data->data / hmat_lb->base);
142
    }
143

144
    for (i = 0; i < num_initiator * num_target; i++) {
145
        build_append_int_noprefix(table_data, entry_list[i], 2);
146
    }
147

148
    g_free(entry_list);
149
}
150

151
/* ACPI 6.3: 5.2.27.5 Memory Side Cache Information Structure: Table 5-147 */
152
static void build_hmat_cache(GArray *table_data, uint8_t total_levels,
153
                             NumaHmatCacheOptions *hmat_cache)
154
{
155
    /*
156
     * Cache Attributes: Bits [3:0] – Total Cache Levels
157
     * for this Memory Proximity Domain
158
     */
159
    uint32_t cache_attr = total_levels;
160

161
    /* Bits [7:4] : Cache Level described in this structure */
162
    cache_attr |= (uint32_t) hmat_cache->level << 4;
163

164
    /* Bits [11:8] - Cache Associativity */
165
    cache_attr |= (uint32_t) hmat_cache->associativity << 8;
166

167
    /* Bits [15:12] - Write Policy */
168
    cache_attr |= (uint32_t) hmat_cache->policy << 12;
169

170
    /* Bits [31:16] - Cache Line size in bytes */
171
    cache_attr |= (uint32_t) hmat_cache->line << 16;
172

173
    /* Type */
174
    build_append_int_noprefix(table_data, 2, 2);
175
    /* Reserved */
176
    build_append_int_noprefix(table_data, 0, 2);
177
    /* Length */
178
    build_append_int_noprefix(table_data, 32, 4);
179
    /* Proximity Domain for the Memory */
180
    build_append_int_noprefix(table_data, hmat_cache->node_id, 4);
181
    /* Reserved */
182
    build_append_int_noprefix(table_data, 0, 4);
183
    /* Memory Side Cache Size */
184
    build_append_int_noprefix(table_data, hmat_cache->size, 8);
185
    /* Cache Attributes */
186
    build_append_int_noprefix(table_data, cache_attr, 4);
187
    /* Reserved */
188
    build_append_int_noprefix(table_data, 0, 2);
189
    /*
190
     * Number of SMBIOS handles (n)
191
     * Linux kernel uses Memory Side Cache Information Structure
192
     * without SMBIOS entries for now, so set Number of SMBIOS handles
193
     * as 0.
194
     */
195
    build_append_int_noprefix(table_data, 0, 2);
196
}
197

198
/* Build HMAT sub table structures */
199
static void hmat_build_table_structs(GArray *table_data, NumaState *numa_state)
200
{
201
    uint16_t flags;
202
    uint32_t num_initiator = 0;
203
    uint32_t initiator_list[MAX_NODES];
204
    int i, hierarchy, type, cache_level, total_levels;
205
    HMAT_LB_Info *hmat_lb;
206
    NumaHmatCacheOptions *hmat_cache;
207

208
    build_append_int_noprefix(table_data, 0, 4); /* Reserved */
209

210
    for (i = 0; i < numa_state->num_nodes; i++) {
211
        /*
212
         * Linux rejects whole HMAT table if a node with no memory
213
         * has one of these structures listing it as a target.
214
         */
215
        if (!numa_state->nodes[i].node_mem) {
216
            continue;
217
        }
218
        flags = 0;
219

220
        if (numa_state->nodes[i].initiator < MAX_NODES) {
221
            flags |= HMAT_PROXIMITY_INITIATOR_VALID;
222
        }
223

224
        build_hmat_mpda(table_data, flags, numa_state->nodes[i].initiator, i);
225
    }
226

227
    for (i = 0; i < numa_state->num_nodes; i++) {
228
        if (numa_state->nodes[i].has_cpu || numa_state->nodes[i].has_gi) {
229
            initiator_list[num_initiator++] = i;
230
        }
231
    }
232

233
    /*
234
     * ACPI 6.3: 5.2.27.4 System Locality Latency and Bandwidth Information
235
     * Structure: Table 5-146
236
     */
237
    for (hierarchy = HMAT_LB_MEM_MEMORY;
238
         hierarchy <= HMAT_LB_MEM_CACHE_3RD_LEVEL; hierarchy++) {
239
        for (type = HMAT_LB_DATA_ACCESS_LATENCY;
240
             type <= HMAT_LB_DATA_WRITE_BANDWIDTH; type++) {
241
            hmat_lb = numa_state->hmat_lb[hierarchy][type];
242

243
            if (hmat_lb && hmat_lb->list->len) {
244
                build_hmat_lb(table_data, hmat_lb, num_initiator,
245
                              numa_state->num_nodes, initiator_list);
246
            }
247
        }
248
    }
249

250
    /*
251
     * ACPI 6.3: 5.2.27.5 Memory Side Cache Information Structure:
252
     * Table 5-147
253
     */
254
    for (i = 0; i < numa_state->num_nodes; i++) {
255
        total_levels = 0;
256
        for (cache_level = 1; cache_level < HMAT_LB_LEVELS; cache_level++) {
257
            if (numa_state->hmat_cache[i][cache_level]) {
258
                total_levels++;
259
            }
260
        }
261
        for (cache_level = 0; cache_level <= total_levels; cache_level++) {
262
            hmat_cache = numa_state->hmat_cache[i][cache_level];
263
            if (hmat_cache) {
264
                build_hmat_cache(table_data, total_levels, hmat_cache);
265
            }
266
        }
267
    }
268
}
269

270
void build_hmat(GArray *table_data, BIOSLinker *linker, NumaState *numa_state,
271
                const char *oem_id, const char *oem_table_id)
272
{
273
    AcpiTable table = { .sig = "HMAT", .rev = 2,
274
                        .oem_id = oem_id, .oem_table_id = oem_table_id };
275

276
    acpi_table_begin(&table, table_data);
277
    hmat_build_table_structs(table_data, numa_state);
278
    acpi_table_end(linker, &table);
279
}
280