2 * NVDIMM ACPI Implementation
4 * Copyright(C) 2015 Intel Corporation.
7 * Xiao Guangrong <guangrong.xiao@linux.intel.com>
9 * NFIT is defined in ACPI 6.0: 5.2.25 NVDIMM Firmware Interface Table (NFIT)
10 * and the DSM specification can be found at:
11 * http://pmem.io/documents/NVDIMM_DSM_Interface_Example.pdf
13 * Currently, it only supports PMEM Virtualization.
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, see <http://www.gnu.org/licenses/>
29 #include "qemu/osdep.h"
30 #include "hw/acpi/acpi.h"
31 #include "hw/acpi/aml-build.h"
32 #include "hw/acpi/bios-linker-loader.h"
33 #include "hw/nvram/fw_cfg.h"
34 #include "hw/mem/nvdimm.h"
36 static int nvdimm_plugged_device_list(Object
*obj
, void *opaque
)
38 GSList
**list
= opaque
;
40 if (object_dynamic_cast(obj
, TYPE_NVDIMM
)) {
41 DeviceState
*dev
= DEVICE(obj
);
43 if (dev
->realized
) { /* only realized NVDIMMs matter */
44 *list
= g_slist_append(*list
, DEVICE(obj
));
48 object_child_foreach(obj
, nvdimm_plugged_device_list
, opaque
);
53 * inquire plugged NVDIMM devices and link them into the list which is
54 * returned to the caller.
56 * Note: it is the caller's responsibility to free the list to avoid
59 static GSList
*nvdimm_get_plugged_device_list(void)
63 object_child_foreach(qdev_get_machine(), nvdimm_plugged_device_list
,
68 #define NVDIMM_UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
69 { (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
70 (b) & 0xff, ((b) >> 8) & 0xff, (c) & 0xff, ((c) >> 8) & 0xff, \
71 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }
74 * define Byte Addressable Persistent Memory (PM) Region according to
75 * ACPI 6.0: 5.2.25.1 System Physical Address Range Structure.
77 static const uint8_t nvdimm_nfit_spa_uuid
[] =
78 NVDIMM_UUID_LE(0x66f0d379, 0xb4f3, 0x4074, 0xac, 0x43, 0x0d, 0x33,
79 0x18, 0xb7, 0x8c, 0xdb);
82 * NVDIMM Firmware Interface Table
85 * It provides information that allows OSPM to enumerate NVDIMM present in
86 * the platform and associate system physical address ranges created by the
89 * It is defined in ACPI 6.0: 5.2.25 NVDIMM Firmware Interface Table (NFIT)
91 struct NvdimmNfitHeader
{
95 typedef struct NvdimmNfitHeader NvdimmNfitHeader
;
98 * define NFIT structures according to ACPI 6.0: 5.2.25 NVDIMM Firmware
99 * Interface Table (NFIT).
103 * System Physical Address Range Structure
105 * It describes the system physical address ranges occupied by NVDIMMs and
106 * the types of the regions.
108 struct NvdimmNfitSpa
{
114 uint32_t proximity_domain
;
115 uint8_t type_guid
[16];
120 typedef struct NvdimmNfitSpa NvdimmNfitSpa
;
123 * Memory Device to System Physical Address Range Mapping Structure
125 * It enables identifying each NVDIMM region and the corresponding SPA
126 * describing the memory interleave
128 struct NvdimmNfitMemDev
{
131 uint32_t nfit_handle
;
137 uint64_t region_offset
;
139 uint16_t interleave_index
;
140 uint16_t interleave_ways
;
144 typedef struct NvdimmNfitMemDev NvdimmNfitMemDev
;
147 * NVDIMM Control Region Structure
149 * It describes the NVDIMM and if applicable, Block Control Window.
151 struct NvdimmNfitControlRegion
{
157 uint16_t revision_id
;
158 uint16_t sub_vendor_id
;
159 uint16_t sub_device_id
;
160 uint16_t sub_revision_id
;
162 uint32_t serial_number
;
168 uint64_t status_offset
;
169 uint64_t status_size
;
171 uint8_t reserved2
[6];
173 typedef struct NvdimmNfitControlRegion NvdimmNfitControlRegion
;
176 * Module serial number is a unique number for each device. We use the
177 * slot id of NVDIMM device to generate this number so that each device
178 * associates with a different number.
180 * 0x123456 is a magic number we arbitrarily chose.
182 static uint32_t nvdimm_slot_to_sn(int slot
)
184 return 0x123456 + slot
;
188 * handle is used to uniquely associate nfit_memdev structure with NVDIMM
189 * ACPI device - nfit_memdev.nfit_handle matches with the value returned
190 * by ACPI device _ADR method.
192 * We generate the handle with the slot id of NVDIMM device and reserve
193 * 0 for NVDIMM root device.
195 static uint32_t nvdimm_slot_to_handle(int slot
)
201 * index uniquely identifies the structure, 0 is reserved which indicates
202 * that the structure is not valid or the associated structure is not
205 * Each NVDIMM device needs two indexes, one for nfit_spa and another for
206 * nfit_dc which are generated by the slot id of NVDIMM device.
208 static uint16_t nvdimm_slot_to_spa_index(int slot
)
210 return (slot
+ 1) << 1;
213 /* See the comments of nvdimm_slot_to_spa_index(). */
214 static uint32_t nvdimm_slot_to_dcr_index(int slot
)
216 return nvdimm_slot_to_spa_index(slot
) + 1;
219 static NVDIMMDevice
*nvdimm_get_device_by_handle(uint32_t handle
)
221 NVDIMMDevice
*nvdimm
= NULL
;
222 GSList
*list
, *device_list
= nvdimm_get_plugged_device_list();
224 for (list
= device_list
; list
; list
= list
->next
) {
225 NVDIMMDevice
*nvd
= list
->data
;
226 int slot
= object_property_get_int(OBJECT(nvd
), PC_DIMM_SLOT_PROP
,
229 if (nvdimm_slot_to_handle(slot
) == handle
) {
235 g_slist_free(device_list
);
239 /* ACPI 6.0: 5.2.25.1 System Physical Address Range Structure */
241 nvdimm_build_structure_spa(GArray
*structures
, DeviceState
*dev
)
243 NvdimmNfitSpa
*nfit_spa
;
244 uint64_t addr
= object_property_get_int(OBJECT(dev
), PC_DIMM_ADDR_PROP
,
246 uint64_t size
= object_property_get_int(OBJECT(dev
), PC_DIMM_SIZE_PROP
,
248 uint32_t node
= object_property_get_int(OBJECT(dev
), PC_DIMM_NODE_PROP
,
250 int slot
= object_property_get_int(OBJECT(dev
), PC_DIMM_SLOT_PROP
,
253 nfit_spa
= acpi_data_push(structures
, sizeof(*nfit_spa
));
255 nfit_spa
->type
= cpu_to_le16(0 /* System Physical Address Range
257 nfit_spa
->length
= cpu_to_le16(sizeof(*nfit_spa
));
258 nfit_spa
->spa_index
= cpu_to_le16(nvdimm_slot_to_spa_index(slot
));
261 * Control region is strict as all the device info, such as SN, index,
262 * is associated with slot id.
264 nfit_spa
->flags
= cpu_to_le16(1 /* Control region is strictly for
265 management during hot add/online
267 2 /* Data in Proximity Domain field is
271 nfit_spa
->proximity_domain
= cpu_to_le32(node
);
272 /* the region reported as PMEM. */
273 memcpy(nfit_spa
->type_guid
, nvdimm_nfit_spa_uuid
,
274 sizeof(nvdimm_nfit_spa_uuid
));
276 nfit_spa
->spa_base
= cpu_to_le64(addr
);
277 nfit_spa
->spa_length
= cpu_to_le64(size
);
279 /* It is the PMEM and can be cached as writeback. */
280 nfit_spa
->mem_attr
= cpu_to_le64(0x8ULL
/* EFI_MEMORY_WB */ |
281 0x8000ULL
/* EFI_MEMORY_NV */);
285 * ACPI 6.0: 5.2.25.2 Memory Device to System Physical Address Range Mapping
289 nvdimm_build_structure_memdev(GArray
*structures
, DeviceState
*dev
)
291 NvdimmNfitMemDev
*nfit_memdev
;
292 uint64_t size
= object_property_get_int(OBJECT(dev
), PC_DIMM_SIZE_PROP
,
294 int slot
= object_property_get_int(OBJECT(dev
), PC_DIMM_SLOT_PROP
,
296 uint32_t handle
= nvdimm_slot_to_handle(slot
);
298 nfit_memdev
= acpi_data_push(structures
, sizeof(*nfit_memdev
));
300 nfit_memdev
->type
= cpu_to_le16(1 /* Memory Device to System Address
301 Range Map Structure*/);
302 nfit_memdev
->length
= cpu_to_le16(sizeof(*nfit_memdev
));
303 nfit_memdev
->nfit_handle
= cpu_to_le32(handle
);
306 * associate memory device with System Physical Address Range
309 nfit_memdev
->spa_index
= cpu_to_le16(nvdimm_slot_to_spa_index(slot
));
310 /* associate memory device with Control Region Structure. */
311 nfit_memdev
->dcr_index
= cpu_to_le16(nvdimm_slot_to_dcr_index(slot
));
313 /* The memory region on the device. */
314 nfit_memdev
->region_len
= cpu_to_le64(size
);
315 /* The device address starts from 0. */
316 nfit_memdev
->region_dpa
= cpu_to_le64(0);
318 /* Only one interleave for PMEM. */
319 nfit_memdev
->interleave_ways
= cpu_to_le16(1);
323 * ACPI 6.0: 5.2.25.5 NVDIMM Control Region Structure.
325 static void nvdimm_build_structure_dcr(GArray
*structures
, DeviceState
*dev
)
327 NvdimmNfitControlRegion
*nfit_dcr
;
328 int slot
= object_property_get_int(OBJECT(dev
), PC_DIMM_SLOT_PROP
,
330 uint32_t sn
= nvdimm_slot_to_sn(slot
);
332 nfit_dcr
= acpi_data_push(structures
, sizeof(*nfit_dcr
));
334 nfit_dcr
->type
= cpu_to_le16(4 /* NVDIMM Control Region Structure */);
335 nfit_dcr
->length
= cpu_to_le16(sizeof(*nfit_dcr
));
336 nfit_dcr
->dcr_index
= cpu_to_le16(nvdimm_slot_to_dcr_index(slot
));
339 nfit_dcr
->vendor_id
= cpu_to_le16(0x8086);
340 nfit_dcr
->device_id
= cpu_to_le16(1);
342 /* The _DSM method is following Intel's DSM specification. */
343 nfit_dcr
->revision_id
= cpu_to_le16(1 /* Current Revision supported
344 in ACPI 6.0 is 1. */);
345 nfit_dcr
->serial_number
= cpu_to_le32(sn
);
346 nfit_dcr
->fic
= cpu_to_le16(0x201 /* Format Interface Code. See Chapter
347 2: NVDIMM Device Specific Method
348 (DSM) in DSM Spec Rev1.*/);
351 static GArray
*nvdimm_build_device_structure(void)
353 GSList
*device_list
= nvdimm_get_plugged_device_list();
354 GArray
*structures
= g_array_new(false, true /* clear */, 1);
356 for (; device_list
; device_list
= device_list
->next
) {
357 DeviceState
*dev
= device_list
->data
;
359 /* build System Physical Address Range Structure. */
360 nvdimm_build_structure_spa(structures
, dev
);
363 * build Memory Device to System Physical Address Range Mapping
366 nvdimm_build_structure_memdev(structures
, dev
);
368 /* build NVDIMM Control Region Structure. */
369 nvdimm_build_structure_dcr(structures
, dev
);
371 g_slist_free(device_list
);
376 static void nvdimm_init_fit_buffer(NvdimmFitBuffer
*fit_buf
)
378 qemu_mutex_init(&fit_buf
->lock
);
379 fit_buf
->fit
= g_array_new(false, true /* clear */, 1);
382 static void nvdimm_build_fit_buffer(NvdimmFitBuffer
*fit_buf
)
384 qemu_mutex_lock(&fit_buf
->lock
);
385 g_array_free(fit_buf
->fit
, true);
386 fit_buf
->fit
= nvdimm_build_device_structure();
387 fit_buf
->dirty
= true;
388 qemu_mutex_unlock(&fit_buf
->lock
);
391 void nvdimm_acpi_hotplug(AcpiNVDIMMState
*state
)
393 nvdimm_build_fit_buffer(&state
->fit_buf
);
396 static void nvdimm_build_nfit(AcpiNVDIMMState
*state
, GArray
*table_offsets
,
397 GArray
*table_data
, BIOSLinker
*linker
)
399 NvdimmFitBuffer
*fit_buf
= &state
->fit_buf
;
402 qemu_mutex_lock(&fit_buf
->lock
);
404 /* NVDIMM device is not plugged? */
405 if (!fit_buf
->fit
->len
) {
409 acpi_add_table(table_offsets
, table_data
);
412 header
= table_data
->len
;
413 acpi_data_push(table_data
, sizeof(NvdimmNfitHeader
));
414 /* NVDIMM device structures. */
415 g_array_append_vals(table_data
, fit_buf
->fit
->data
, fit_buf
->fit
->len
);
417 build_header(linker
, table_data
,
418 (void *)(table_data
->data
+ header
), "NFIT",
419 sizeof(NvdimmNfitHeader
) + fit_buf
->fit
->len
, 1, NULL
, NULL
);
422 qemu_mutex_unlock(&fit_buf
->lock
);
429 /* the remaining size in the page is used by arg3. */
434 typedef struct NvdimmDsmIn NvdimmDsmIn
;
435 QEMU_BUILD_BUG_ON(sizeof(NvdimmDsmIn
) != 4096);
437 struct NvdimmDsmOut
{
438 /* the size of buffer filled by QEMU. */
442 typedef struct NvdimmDsmOut NvdimmDsmOut
;
443 QEMU_BUILD_BUG_ON(sizeof(NvdimmDsmOut
) != 4096);
445 struct NvdimmDsmFunc0Out
{
446 /* the size of buffer filled by QEMU. */
448 uint32_t supported_func
;
450 typedef struct NvdimmDsmFunc0Out NvdimmDsmFunc0Out
;
452 struct NvdimmDsmFuncNoPayloadOut
{
453 /* the size of buffer filled by QEMU. */
455 uint32_t func_ret_status
;
457 typedef struct NvdimmDsmFuncNoPayloadOut NvdimmDsmFuncNoPayloadOut
;
459 struct NvdimmFuncGetLabelSizeOut
{
460 /* the size of buffer filled by QEMU. */
462 uint32_t func_ret_status
; /* return status code. */
463 uint32_t label_size
; /* the size of label data area. */
465 * Maximum size of the namespace label data length supported by
466 * the platform in Get/Set Namespace Label Data functions.
470 typedef struct NvdimmFuncGetLabelSizeOut NvdimmFuncGetLabelSizeOut
;
471 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncGetLabelSizeOut
) > 4096);
473 struct NvdimmFuncGetLabelDataIn
{
474 uint32_t offset
; /* the offset in the namespace label data area. */
475 uint32_t length
; /* the size of data is to be read via the function. */
477 typedef struct NvdimmFuncGetLabelDataIn NvdimmFuncGetLabelDataIn
;
478 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncGetLabelDataIn
) +
479 offsetof(NvdimmDsmIn
, arg3
) > 4096);
481 struct NvdimmFuncGetLabelDataOut
{
482 /* the size of buffer filled by QEMU. */
484 uint32_t func_ret_status
; /* return status code. */
485 uint8_t out_buf
[0]; /* the data got via Get Namesapce Label function. */
487 typedef struct NvdimmFuncGetLabelDataOut NvdimmFuncGetLabelDataOut
;
488 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncGetLabelDataOut
) > 4096);
490 struct NvdimmFuncSetLabelDataIn
{
491 uint32_t offset
; /* the offset in the namespace label data area. */
492 uint32_t length
; /* the size of data is to be written via the function. */
493 uint8_t in_buf
[0]; /* the data written to label data area. */
495 typedef struct NvdimmFuncSetLabelDataIn NvdimmFuncSetLabelDataIn
;
496 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncSetLabelDataIn
) +
497 offsetof(NvdimmDsmIn
, arg3
) > 4096);
499 struct NvdimmFuncReadFITIn
{
500 uint32_t offset
; /* the offset of FIT buffer. */
502 typedef struct NvdimmFuncReadFITIn NvdimmFuncReadFITIn
;
503 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncReadFITIn
) +
504 offsetof(NvdimmDsmIn
, arg3
) > 4096);
506 struct NvdimmFuncReadFITOut
{
507 /* the size of buffer filled by QEMU. */
509 uint32_t func_ret_status
; /* return status code. */
510 uint8_t fit
[0]; /* the FIT data. */
512 typedef struct NvdimmFuncReadFITOut NvdimmFuncReadFITOut
;
513 QEMU_BUILD_BUG_ON(sizeof(NvdimmFuncReadFITOut
) > 4096);
516 nvdimm_dsm_function0(uint32_t supported_func
, hwaddr dsm_mem_addr
)
518 NvdimmDsmFunc0Out func0
= {
519 .len
= cpu_to_le32(sizeof(func0
)),
520 .supported_func
= cpu_to_le32(supported_func
),
522 cpu_physical_memory_write(dsm_mem_addr
, &func0
, sizeof(func0
));
526 nvdimm_dsm_no_payload(uint32_t func_ret_status
, hwaddr dsm_mem_addr
)
528 NvdimmDsmFuncNoPayloadOut out
= {
529 .len
= cpu_to_le32(sizeof(out
)),
530 .func_ret_status
= cpu_to_le32(func_ret_status
),
532 cpu_physical_memory_write(dsm_mem_addr
, &out
, sizeof(out
));
535 #define NVDIMM_QEMU_RSVD_HANDLE_ROOT 0x10000
537 /* Read FIT data, defined in docs/specs/acpi_nvdimm.txt. */
538 static void nvdimm_dsm_func_read_fit(AcpiNVDIMMState
*state
, NvdimmDsmIn
*in
,
541 NvdimmFitBuffer
*fit_buf
= &state
->fit_buf
;
542 NvdimmFuncReadFITIn
*read_fit
;
543 NvdimmFuncReadFITOut
*read_fit_out
;
545 uint32_t read_len
= 0, func_ret_status
;
548 read_fit
= (NvdimmFuncReadFITIn
*)in
->arg3
;
549 le32_to_cpus(&read_fit
->offset
);
551 qemu_mutex_lock(&fit_buf
->lock
);
554 nvdimm_debug("Read FIT: offset %#x FIT size %#x Dirty %s.\n",
555 read_fit
->offset
, fit
->len
, fit_buf
->dirty
? "Yes" : "No");
557 if (read_fit
->offset
> fit
->len
) {
558 func_ret_status
= 3 /* Invalid Input Parameters */;
562 /* It is the first time to read FIT. */
563 if (!read_fit
->offset
) {
564 fit_buf
->dirty
= false;
565 } else if (fit_buf
->dirty
) { /* FIT has been changed during RFIT. */
566 func_ret_status
= 0x100 /* fit changed */;
570 func_ret_status
= 0 /* Success */;
571 read_len
= MIN(fit
->len
- read_fit
->offset
,
572 4096 - sizeof(NvdimmFuncReadFITOut
));
575 size
= sizeof(NvdimmFuncReadFITOut
) + read_len
;
576 read_fit_out
= g_malloc(size
);
578 read_fit_out
->len
= cpu_to_le32(size
);
579 read_fit_out
->func_ret_status
= cpu_to_le32(func_ret_status
);
580 memcpy(read_fit_out
->fit
, fit
->data
+ read_fit
->offset
, read_len
);
582 cpu_physical_memory_write(dsm_mem_addr
, read_fit_out
, size
);
584 g_free(read_fit_out
);
585 qemu_mutex_unlock(&fit_buf
->lock
);
588 static void nvdimm_dsm_reserved_root(AcpiNVDIMMState
*state
, NvdimmDsmIn
*in
,
591 switch (in
->function
) {
593 nvdimm_dsm_function0(0x1 | 1 << 1 /* Read FIT */, dsm_mem_addr
);
595 case 0x1 /*Read FIT */:
596 nvdimm_dsm_func_read_fit(state
, in
, dsm_mem_addr
);
600 nvdimm_dsm_no_payload(1 /* Not Supported */, dsm_mem_addr
);
603 static void nvdimm_dsm_root(NvdimmDsmIn
*in
, hwaddr dsm_mem_addr
)
606 * function 0 is called to inquire which functions are supported by
610 nvdimm_dsm_function0(0 /* No function supported other than
611 function 0 */, dsm_mem_addr
);
615 /* No function except function 0 is supported yet. */
616 nvdimm_dsm_no_payload(1 /* Not Supported */, dsm_mem_addr
);
620 * the max transfer size is the max size transferred by both a
621 * 'Get Namespace Label Data' function and a 'Set Namespace Label Data'
624 static uint32_t nvdimm_get_max_xfer_label_size(void)
626 uint32_t max_get_size
, max_set_size
, dsm_memory_size
= 4096;
629 * the max data ACPI can read one time which is transferred by
630 * the response of 'Get Namespace Label Data' function.
632 max_get_size
= dsm_memory_size
- sizeof(NvdimmFuncGetLabelDataOut
);
635 * the max data ACPI can write one time which is transferred by
636 * 'Set Namespace Label Data' function.
638 max_set_size
= dsm_memory_size
- offsetof(NvdimmDsmIn
, arg3
) -
639 sizeof(NvdimmFuncSetLabelDataIn
);
641 return MIN(max_get_size
, max_set_size
);
645 * DSM Spec Rev1 4.4 Get Namespace Label Size (Function Index 4).
647 * It gets the size of Namespace Label data area and the max data size
648 * that Get/Set Namespace Label Data functions can transfer.
650 static void nvdimm_dsm_label_size(NVDIMMDevice
*nvdimm
, hwaddr dsm_mem_addr
)
652 NvdimmFuncGetLabelSizeOut label_size_out
= {
653 .len
= cpu_to_le32(sizeof(label_size_out
)),
655 uint32_t label_size
, mxfer
;
657 label_size
= nvdimm
->label_size
;
658 mxfer
= nvdimm_get_max_xfer_label_size();
660 nvdimm_debug("label_size %#x, max_xfer %#x.\n", label_size
, mxfer
);
662 label_size_out
.func_ret_status
= cpu_to_le32(0 /* Success */);
663 label_size_out
.label_size
= cpu_to_le32(label_size
);
664 label_size_out
.max_xfer
= cpu_to_le32(mxfer
);
666 cpu_physical_memory_write(dsm_mem_addr
, &label_size_out
,
667 sizeof(label_size_out
));
670 static uint32_t nvdimm_rw_label_data_check(NVDIMMDevice
*nvdimm
,
671 uint32_t offset
, uint32_t length
)
673 uint32_t ret
= 3 /* Invalid Input Parameters */;
675 if (offset
+ length
< offset
) {
676 nvdimm_debug("offset %#x + length %#x is overflow.\n", offset
,
681 if (nvdimm
->label_size
< offset
+ length
) {
682 nvdimm_debug("position %#x is beyond label data (len = %" PRIx64
").\n",
683 offset
+ length
, nvdimm
->label_size
);
687 if (length
> nvdimm_get_max_xfer_label_size()) {
688 nvdimm_debug("length (%#x) is larger than max_xfer (%#x).\n",
689 length
, nvdimm_get_max_xfer_label_size());
693 return 0 /* Success */;
697 * DSM Spec Rev1 4.5 Get Namespace Label Data (Function Index 5).
699 static void nvdimm_dsm_get_label_data(NVDIMMDevice
*nvdimm
, NvdimmDsmIn
*in
,
702 NVDIMMClass
*nvc
= NVDIMM_GET_CLASS(nvdimm
);
703 NvdimmFuncGetLabelDataIn
*get_label_data
;
704 NvdimmFuncGetLabelDataOut
*get_label_data_out
;
708 get_label_data
= (NvdimmFuncGetLabelDataIn
*)in
->arg3
;
709 le32_to_cpus(&get_label_data
->offset
);
710 le32_to_cpus(&get_label_data
->length
);
712 nvdimm_debug("Read Label Data: offset %#x length %#x.\n",
713 get_label_data
->offset
, get_label_data
->length
);
715 status
= nvdimm_rw_label_data_check(nvdimm
, get_label_data
->offset
,
716 get_label_data
->length
);
717 if (status
!= 0 /* Success */) {
718 nvdimm_dsm_no_payload(status
, dsm_mem_addr
);
722 size
= sizeof(*get_label_data_out
) + get_label_data
->length
;
723 assert(size
<= 4096);
724 get_label_data_out
= g_malloc(size
);
726 get_label_data_out
->len
= cpu_to_le32(size
);
727 get_label_data_out
->func_ret_status
= cpu_to_le32(0 /* Success */);
728 nvc
->read_label_data(nvdimm
, get_label_data_out
->out_buf
,
729 get_label_data
->length
, get_label_data
->offset
);
731 cpu_physical_memory_write(dsm_mem_addr
, get_label_data_out
, size
);
732 g_free(get_label_data_out
);
736 * DSM Spec Rev1 4.6 Set Namespace Label Data (Function Index 6).
738 static void nvdimm_dsm_set_label_data(NVDIMMDevice
*nvdimm
, NvdimmDsmIn
*in
,
741 NVDIMMClass
*nvc
= NVDIMM_GET_CLASS(nvdimm
);
742 NvdimmFuncSetLabelDataIn
*set_label_data
;
745 set_label_data
= (NvdimmFuncSetLabelDataIn
*)in
->arg3
;
747 le32_to_cpus(&set_label_data
->offset
);
748 le32_to_cpus(&set_label_data
->length
);
750 nvdimm_debug("Write Label Data: offset %#x length %#x.\n",
751 set_label_data
->offset
, set_label_data
->length
);
753 status
= nvdimm_rw_label_data_check(nvdimm
, set_label_data
->offset
,
754 set_label_data
->length
);
755 if (status
!= 0 /* Success */) {
756 nvdimm_dsm_no_payload(status
, dsm_mem_addr
);
760 assert(sizeof(*in
) + sizeof(*set_label_data
) + set_label_data
->length
<=
763 nvc
->write_label_data(nvdimm
, set_label_data
->in_buf
,
764 set_label_data
->length
, set_label_data
->offset
);
765 nvdimm_dsm_no_payload(0 /* Success */, dsm_mem_addr
);
768 static void nvdimm_dsm_device(NvdimmDsmIn
*in
, hwaddr dsm_mem_addr
)
770 NVDIMMDevice
*nvdimm
= nvdimm_get_device_by_handle(in
->handle
);
772 /* See the comments in nvdimm_dsm_root(). */
774 uint32_t supported_func
= 0;
776 if (nvdimm
&& nvdimm
->label_size
) {
777 supported_func
|= 0x1 /* Bit 0 indicates whether there is
778 support for any functions other
779 than function 0. */ |
780 1 << 4 /* Get Namespace Label Size */ |
781 1 << 5 /* Get Namespace Label Data */ |
782 1 << 6 /* Set Namespace Label Data */;
784 nvdimm_dsm_function0(supported_func
, dsm_mem_addr
);
789 nvdimm_dsm_no_payload(2 /* Non-Existing Memory Device */,
794 /* Encode DSM function according to DSM Spec Rev1. */
795 switch (in
->function
) {
796 case 4 /* Get Namespace Label Size */:
797 if (nvdimm
->label_size
) {
798 nvdimm_dsm_label_size(nvdimm
, dsm_mem_addr
);
802 case 5 /* Get Namespace Label Data */:
803 if (nvdimm
->label_size
) {
804 nvdimm_dsm_get_label_data(nvdimm
, in
, dsm_mem_addr
);
808 case 0x6 /* Set Namespace Label Data */:
809 if (nvdimm
->label_size
) {
810 nvdimm_dsm_set_label_data(nvdimm
, in
, dsm_mem_addr
);
816 nvdimm_dsm_no_payload(1 /* Not Supported */, dsm_mem_addr
);
820 nvdimm_dsm_read(void *opaque
, hwaddr addr
, unsigned size
)
822 nvdimm_debug("BUG: we never read _DSM IO Port.\n");
827 nvdimm_dsm_write(void *opaque
, hwaddr addr
, uint64_t val
, unsigned size
)
829 AcpiNVDIMMState
*state
= opaque
;
831 hwaddr dsm_mem_addr
= val
;
833 nvdimm_debug("dsm memory address %#" HWADDR_PRIx
".\n", dsm_mem_addr
);
836 * The DSM memory is mapped to guest address space so an evil guest
837 * can change its content while we are doing DSM emulation. Avoid
838 * this by copying DSM memory to QEMU local memory.
840 in
= g_new(NvdimmDsmIn
, 1);
841 cpu_physical_memory_read(dsm_mem_addr
, in
, sizeof(*in
));
843 le32_to_cpus(&in
->revision
);
844 le32_to_cpus(&in
->function
);
845 le32_to_cpus(&in
->handle
);
847 nvdimm_debug("Revision %#x Handler %#x Function %#x.\n", in
->revision
,
848 in
->handle
, in
->function
);
850 if (in
->revision
!= 0x1 /* Currently we only support DSM Spec Rev1. */) {
851 nvdimm_debug("Revision %#x is not supported, expect %#x.\n",
853 nvdimm_dsm_no_payload(1 /* Not Supported */, dsm_mem_addr
);
857 if (in
->handle
== NVDIMM_QEMU_RSVD_HANDLE_ROOT
) {
858 nvdimm_dsm_reserved_root(state
, in
, dsm_mem_addr
);
862 /* Handle 0 is reserved for NVDIMM Root Device. */
864 nvdimm_dsm_root(in
, dsm_mem_addr
);
868 nvdimm_dsm_device(in
, dsm_mem_addr
);
874 static const MemoryRegionOps nvdimm_dsm_ops
= {
875 .read
= nvdimm_dsm_read
,
876 .write
= nvdimm_dsm_write
,
877 .endianness
= DEVICE_LITTLE_ENDIAN
,
879 .min_access_size
= 4,
880 .max_access_size
= 4,
884 void nvdimm_init_acpi_state(AcpiNVDIMMState
*state
, MemoryRegion
*io
,
885 FWCfgState
*fw_cfg
, Object
*owner
)
887 memory_region_init_io(&state
->io_mr
, owner
, &nvdimm_dsm_ops
, state
,
888 "nvdimm-acpi-io", NVDIMM_ACPI_IO_LEN
);
889 memory_region_add_subregion(io
, NVDIMM_ACPI_IO_BASE
, &state
->io_mr
);
891 state
->dsm_mem
= g_array_new(false, true /* clear */, 1);
892 acpi_data_push(state
->dsm_mem
, sizeof(NvdimmDsmIn
));
893 fw_cfg_add_file(fw_cfg
, NVDIMM_DSM_MEM_FILE
, state
->dsm_mem
->data
,
894 state
->dsm_mem
->len
);
896 nvdimm_init_fit_buffer(&state
->fit_buf
);
899 #define NVDIMM_COMMON_DSM "NCAL"
900 #define NVDIMM_ACPI_MEM_ADDR "MEMA"
902 #define NVDIMM_DSM_MEMORY "NRAM"
903 #define NVDIMM_DSM_IOPORT "NPIO"
905 #define NVDIMM_DSM_NOTIFY "NTFI"
906 #define NVDIMM_DSM_HANDLE "HDLE"
907 #define NVDIMM_DSM_REVISION "REVS"
908 #define NVDIMM_DSM_FUNCTION "FUNC"
909 #define NVDIMM_DSM_ARG3 "FARG"
911 #define NVDIMM_DSM_OUT_BUF_SIZE "RLEN"
912 #define NVDIMM_DSM_OUT_BUF "ODAT"
914 #define NVDIMM_DSM_RFIT_STATUS "RSTA"
916 #define NVDIMM_QEMU_RSVD_UUID "648B9CF2-CDA1-4312-8AD9-49C4AF32BD62"
918 static void nvdimm_build_common_dsm(Aml
*dev
)
920 Aml
*method
, *ifctx
, *function
, *handle
, *uuid
, *dsm_mem
, *elsectx2
;
921 Aml
*elsectx
, *unsupport
, *unpatched
, *expected_uuid
, *uuid_invalid
;
922 Aml
*pckg
, *pckg_index
, *pckg_buf
, *field
, *dsm_out_buf
, *dsm_out_buf_size
;
923 uint8_t byte_list
[1];
925 method
= aml_method(NVDIMM_COMMON_DSM
, 5, AML_SERIALIZED
);
927 function
= aml_arg(2);
929 dsm_mem
= aml_local(6);
930 dsm_out_buf
= aml_local(7);
932 aml_append(method
, aml_store(aml_name(NVDIMM_ACPI_MEM_ADDR
), dsm_mem
));
934 /* map DSM memory and IO into ACPI namespace. */
935 aml_append(method
, aml_operation_region(NVDIMM_DSM_IOPORT
, AML_SYSTEM_IO
,
936 aml_int(NVDIMM_ACPI_IO_BASE
), NVDIMM_ACPI_IO_LEN
));
937 aml_append(method
, aml_operation_region(NVDIMM_DSM_MEMORY
,
938 AML_SYSTEM_MEMORY
, dsm_mem
, sizeof(NvdimmDsmIn
)));
942 * NVDIMM_DSM_NOTIFY: write the address of DSM memory and notify QEMU to
943 * emulate the access.
945 * It is the IO port so that accessing them will cause VM-exit, the
946 * control will be transferred to QEMU.
948 field
= aml_field(NVDIMM_DSM_IOPORT
, AML_DWORD_ACC
, AML_NOLOCK
,
950 aml_append(field
, aml_named_field(NVDIMM_DSM_NOTIFY
,
951 sizeof(uint32_t) * BITS_PER_BYTE
));
952 aml_append(method
, field
);
956 * NVDIMM_DSM_HANDLE: store device's handle, it's zero if the _DSM call
957 * happens on NVDIMM Root Device.
958 * NVDIMM_DSM_REVISION: store the Arg1 of _DSM call.
959 * NVDIMM_DSM_FUNCTION: store the Arg2 of _DSM call.
960 * NVDIMM_DSM_ARG3: store the Arg3 of _DSM call which is a Package
961 * containing function-specific arguments.
963 * They are RAM mapping on host so that these accesses never cause
966 field
= aml_field(NVDIMM_DSM_MEMORY
, AML_DWORD_ACC
, AML_NOLOCK
,
968 aml_append(field
, aml_named_field(NVDIMM_DSM_HANDLE
,
969 sizeof(typeof_field(NvdimmDsmIn
, handle
)) * BITS_PER_BYTE
));
970 aml_append(field
, aml_named_field(NVDIMM_DSM_REVISION
,
971 sizeof(typeof_field(NvdimmDsmIn
, revision
)) * BITS_PER_BYTE
));
972 aml_append(field
, aml_named_field(NVDIMM_DSM_FUNCTION
,
973 sizeof(typeof_field(NvdimmDsmIn
, function
)) * BITS_PER_BYTE
));
974 aml_append(field
, aml_named_field(NVDIMM_DSM_ARG3
,
975 (sizeof(NvdimmDsmIn
) - offsetof(NvdimmDsmIn
, arg3
)) * BITS_PER_BYTE
));
976 aml_append(method
, field
);
980 * NVDIMM_DSM_OUT_BUF_SIZE: the size of the buffer filled by QEMU.
981 * NVDIMM_DSM_OUT_BUF: the buffer QEMU uses to store the result.
983 * Since the page is reused by both input and out, the input data
984 * will be lost after storing new result into ODAT so we should fetch
985 * all the input data before writing the result.
987 field
= aml_field(NVDIMM_DSM_MEMORY
, AML_DWORD_ACC
, AML_NOLOCK
,
989 aml_append(field
, aml_named_field(NVDIMM_DSM_OUT_BUF_SIZE
,
990 sizeof(typeof_field(NvdimmDsmOut
, len
)) * BITS_PER_BYTE
));
991 aml_append(field
, aml_named_field(NVDIMM_DSM_OUT_BUF
,
992 (sizeof(NvdimmDsmOut
) - offsetof(NvdimmDsmOut
, data
)) * BITS_PER_BYTE
));
993 aml_append(method
, field
);
996 * do not support any method if DSM memory address has not been
999 unpatched
= aml_equal(dsm_mem
, aml_int(0x0));
1001 expected_uuid
= aml_local(0);
1003 ifctx
= aml_if(aml_equal(handle
, aml_int(0x0)));
1004 aml_append(ifctx
, aml_store(
1005 aml_touuid("2F10E7A4-9E91-11E4-89D3-123B93F75CBA")
1006 /* UUID for NVDIMM Root Device */, expected_uuid
));
1007 aml_append(method
, ifctx
);
1008 elsectx
= aml_else();
1009 ifctx
= aml_if(aml_equal(handle
, aml_int(NVDIMM_QEMU_RSVD_HANDLE_ROOT
)));
1010 aml_append(ifctx
, aml_store(aml_touuid(NVDIMM_QEMU_RSVD_UUID
1011 /* UUID for QEMU internal use */), expected_uuid
));
1012 aml_append(elsectx
, ifctx
);
1013 elsectx2
= aml_else();
1014 aml_append(elsectx2
, aml_store(
1015 aml_touuid("4309AC30-0D11-11E4-9191-0800200C9A66")
1016 /* UUID for NVDIMM Devices */, expected_uuid
));
1017 aml_append(elsectx
, elsectx2
);
1018 aml_append(method
, elsectx
);
1020 uuid_invalid
= aml_lnot(aml_equal(uuid
, expected_uuid
));
1022 unsupport
= aml_if(aml_or(unpatched
, uuid_invalid
, NULL
));
1025 * function 0 is called to inquire what functions are supported by
1028 ifctx
= aml_if(aml_equal(function
, aml_int(0)));
1029 byte_list
[0] = 0 /* No function Supported */;
1030 aml_append(ifctx
, aml_return(aml_buffer(1, byte_list
)));
1031 aml_append(unsupport
, ifctx
);
1033 /* No function is supported yet. */
1034 byte_list
[0] = 1 /* Not Supported */;
1035 aml_append(unsupport
, aml_return(aml_buffer(1, byte_list
)));
1036 aml_append(method
, unsupport
);
1039 * The HDLE indicates the DSM function is issued from which device,
1040 * it reserves 0 for root device and is the handle for NVDIMM devices.
1041 * See the comments in nvdimm_slot_to_handle().
1043 aml_append(method
, aml_store(handle
, aml_name(NVDIMM_DSM_HANDLE
)));
1044 aml_append(method
, aml_store(aml_arg(1), aml_name(NVDIMM_DSM_REVISION
)));
1045 aml_append(method
, aml_store(aml_arg(2), aml_name(NVDIMM_DSM_FUNCTION
)));
1048 * The fourth parameter (Arg3) of _DSM is a package which contains
1049 * a buffer, the layout of the buffer is specified by UUID (Arg0),
1050 * Revision ID (Arg1) and Function Index (Arg2) which are documented
1054 ifctx
= aml_if(aml_and(aml_equal(aml_object_type(pckg
),
1055 aml_int(4 /* Package */)) /* It is a Package? */,
1056 aml_equal(aml_sizeof(pckg
), aml_int(1)) /* 1 element? */,
1059 pckg_index
= aml_local(2);
1060 pckg_buf
= aml_local(3);
1061 aml_append(ifctx
, aml_store(aml_index(pckg
, aml_int(0)), pckg_index
));
1062 aml_append(ifctx
, aml_store(aml_derefof(pckg_index
), pckg_buf
));
1063 aml_append(ifctx
, aml_store(pckg_buf
, aml_name(NVDIMM_DSM_ARG3
)));
1064 aml_append(method
, ifctx
);
1067 * tell QEMU about the real address of DSM memory, then QEMU
1068 * gets the control and fills the result in DSM memory.
1070 aml_append(method
, aml_store(dsm_mem
, aml_name(NVDIMM_DSM_NOTIFY
)));
1072 dsm_out_buf_size
= aml_local(1);
1073 /* RLEN is not included in the payload returned to guest. */
1074 aml_append(method
, aml_subtract(aml_name(NVDIMM_DSM_OUT_BUF_SIZE
),
1075 aml_int(4), dsm_out_buf_size
));
1076 aml_append(method
, aml_store(aml_shiftleft(dsm_out_buf_size
, aml_int(3)),
1078 aml_append(method
, aml_create_field(aml_name(NVDIMM_DSM_OUT_BUF
),
1079 aml_int(0), dsm_out_buf_size
, "OBUF"));
1080 aml_append(method
, aml_concatenate(aml_buffer(0, NULL
), aml_name("OBUF"),
1082 aml_append(method
, aml_return(dsm_out_buf
));
1083 aml_append(dev
, method
);
1086 static void nvdimm_build_device_dsm(Aml
*dev
, uint32_t handle
)
1090 method
= aml_method("_DSM", 4, AML_NOTSERIALIZED
);
1091 aml_append(method
, aml_return(aml_call5(NVDIMM_COMMON_DSM
, aml_arg(0),
1092 aml_arg(1), aml_arg(2), aml_arg(3),
1094 aml_append(dev
, method
);
1097 static void nvdimm_build_fit(Aml
*dev
)
1099 Aml
*method
, *pkg
, *buf
, *buf_size
, *offset
, *call_result
;
1100 Aml
*whilectx
, *ifcond
, *ifctx
, *elsectx
, *fit
;
1103 buf_size
= aml_local(1);
1106 aml_append(dev
, aml_create_dword_field(aml_buffer(4, NULL
),
1107 aml_int(0), NVDIMM_DSM_RFIT_STATUS
));
1109 /* build helper function, RFIT. */
1110 method
= aml_method("RFIT", 1, AML_SERIALIZED
);
1111 aml_append(method
, aml_create_dword_field(aml_buffer(4, NULL
),
1112 aml_int(0), "OFST"));
1114 /* prepare input package. */
1115 pkg
= aml_package(1);
1116 aml_append(method
, aml_store(aml_arg(0), aml_name("OFST")));
1117 aml_append(pkg
, aml_name("OFST"));
1119 /* call Read_FIT function. */
1120 call_result
= aml_call5(NVDIMM_COMMON_DSM
,
1121 aml_touuid(NVDIMM_QEMU_RSVD_UUID
),
1122 aml_int(1) /* Revision 1 */,
1123 aml_int(0x1) /* Read FIT */,
1124 pkg
, aml_int(NVDIMM_QEMU_RSVD_HANDLE_ROOT
));
1125 aml_append(method
, aml_store(call_result
, buf
));
1127 /* handle _DSM result. */
1128 aml_append(method
, aml_create_dword_field(buf
,
1129 aml_int(0) /* offset at byte 0 */, "STAU"));
1131 aml_append(method
, aml_store(aml_name("STAU"),
1132 aml_name(NVDIMM_DSM_RFIT_STATUS
)));
1134 /* if something is wrong during _DSM. */
1135 ifcond
= aml_equal(aml_int(0 /* Success */), aml_name("STAU"));
1136 ifctx
= aml_if(aml_lnot(ifcond
));
1137 aml_append(ifctx
, aml_return(aml_buffer(0, NULL
)));
1138 aml_append(method
, ifctx
);
1140 aml_append(method
, aml_store(aml_sizeof(buf
), buf_size
));
1141 aml_append(method
, aml_subtract(buf_size
,
1142 aml_int(4) /* the size of "STAU" */,
1145 /* if we read the end of fit. */
1146 ifctx
= aml_if(aml_equal(buf_size
, aml_int(0)));
1147 aml_append(ifctx
, aml_return(aml_buffer(0, NULL
)));
1148 aml_append(method
, ifctx
);
1150 aml_append(method
, aml_store(aml_shiftleft(buf_size
, aml_int(3)),
1152 aml_append(method
, aml_create_field(buf
,
1153 aml_int(4 * BITS_PER_BYTE
), /* offset at byte 4.*/
1155 aml_append(method
, aml_return(aml_name("BUFF")));
1156 aml_append(dev
, method
);
1159 method
= aml_method("_FIT", 0, AML_SERIALIZED
);
1160 offset
= aml_local(3);
1162 aml_append(method
, aml_store(aml_buffer(0, NULL
), fit
));
1163 aml_append(method
, aml_store(aml_int(0), offset
));
1165 whilectx
= aml_while(aml_int(1));
1166 aml_append(whilectx
, aml_store(aml_call1("RFIT", offset
), buf
));
1167 aml_append(whilectx
, aml_store(aml_sizeof(buf
), buf_size
));
1170 * if fit buffer was changed during RFIT, read from the beginning
1173 ifctx
= aml_if(aml_equal(aml_name(NVDIMM_DSM_RFIT_STATUS
),
1174 aml_int(0x100 /* fit changed */)));
1175 aml_append(ifctx
, aml_store(aml_buffer(0, NULL
), fit
));
1176 aml_append(ifctx
, aml_store(aml_int(0), offset
));
1177 aml_append(whilectx
, ifctx
);
1179 elsectx
= aml_else();
1181 /* finish fit read if no data is read out. */
1182 ifctx
= aml_if(aml_equal(buf_size
, aml_int(0)));
1183 aml_append(ifctx
, aml_return(fit
));
1184 aml_append(elsectx
, ifctx
);
1186 /* update the offset. */
1187 aml_append(elsectx
, aml_add(offset
, buf_size
, offset
));
1188 /* append the data we read out to the fit buffer. */
1189 aml_append(elsectx
, aml_concatenate(fit
, buf
, fit
));
1190 aml_append(whilectx
, elsectx
);
1191 aml_append(method
, whilectx
);
1193 aml_append(dev
, method
);
1196 static void nvdimm_build_nvdimm_devices(Aml
*root_dev
, uint32_t ram_slots
)
1200 for (slot
= 0; slot
< ram_slots
; slot
++) {
1201 uint32_t handle
= nvdimm_slot_to_handle(slot
);
1204 nvdimm_dev
= aml_device("NV%02X", slot
);
1207 * ACPI 6.0: 9.20 NVDIMM Devices:
1209 * _ADR object that is used to supply OSPM with unique address
1210 * of the NVDIMM device. This is done by returning the NFIT Device
1211 * handle that is used to identify the associated entries in ACPI
1212 * table NFIT or _FIT.
1214 aml_append(nvdimm_dev
, aml_name_decl("_ADR", aml_int(handle
)));
1216 nvdimm_build_device_dsm(nvdimm_dev
, handle
);
1217 aml_append(root_dev
, nvdimm_dev
);
1221 static void nvdimm_build_ssdt(GArray
*table_offsets
, GArray
*table_data
,
1222 BIOSLinker
*linker
, GArray
*dsm_dma_arrea
,
1225 Aml
*ssdt
, *sb_scope
, *dev
;
1226 int mem_addr_offset
, nvdimm_ssdt
;
1228 acpi_add_table(table_offsets
, table_data
);
1230 ssdt
= init_aml_allocator();
1231 acpi_data_push(ssdt
->buf
, sizeof(AcpiTableHeader
));
1233 sb_scope
= aml_scope("\\_SB");
1235 dev
= aml_device("NVDR");
1238 * ACPI 6.0: 9.20 NVDIMM Devices:
1240 * The ACPI Name Space device uses _HID of ACPI0012 to identify the root
1241 * NVDIMM interface device. Platform firmware is required to contain one
1242 * such device in _SB scope if NVDIMMs support is exposed by platform to
1244 * For each NVDIMM present or intended to be supported by platform,
1245 * platform firmware also exposes an ACPI Namespace Device under the
1248 aml_append(dev
, aml_name_decl("_HID", aml_string("ACPI0012")));
1250 nvdimm_build_common_dsm(dev
);
1252 /* 0 is reserved for root device. */
1253 nvdimm_build_device_dsm(dev
, 0);
1254 nvdimm_build_fit(dev
);
1256 nvdimm_build_nvdimm_devices(dev
, ram_slots
);
1258 aml_append(sb_scope
, dev
);
1259 aml_append(ssdt
, sb_scope
);
1261 nvdimm_ssdt
= table_data
->len
;
1263 /* copy AML table into ACPI tables blob and patch header there */
1264 g_array_append_vals(table_data
, ssdt
->buf
->data
, ssdt
->buf
->len
);
1265 mem_addr_offset
= build_append_named_dword(table_data
,
1266 NVDIMM_ACPI_MEM_ADDR
);
1268 bios_linker_loader_alloc(linker
,
1269 NVDIMM_DSM_MEM_FILE
, dsm_dma_arrea
,
1270 sizeof(NvdimmDsmIn
), false /* high memory */);
1271 bios_linker_loader_add_pointer(linker
,
1272 ACPI_BUILD_TABLE_FILE
, mem_addr_offset
, sizeof(uint32_t),
1273 NVDIMM_DSM_MEM_FILE
, 0);
1274 build_header(linker
, table_data
,
1275 (void *)(table_data
->data
+ nvdimm_ssdt
),
1276 "SSDT", table_data
->len
- nvdimm_ssdt
, 1, NULL
, "NVDIMM");
1277 free_aml_allocator();
1280 void nvdimm_build_acpi(GArray
*table_offsets
, GArray
*table_data
,
1281 BIOSLinker
*linker
, AcpiNVDIMMState
*state
,
1284 nvdimm_build_nfit(state
, table_offsets
, table_data
, linker
);
1287 * NVDIMM device is allowed to be plugged only if there is available
1291 nvdimm_build_ssdt(table_offsets
, table_data
, linker
, state
->dsm_mem
,