Coverage Report

Created: 2026-10-31 08:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/mem/sp-mem.c
Line
Count
Source
1
/*
2
 * Specific Purpose Memory (SPM) device
3
 *
4
 * Copyright (c) 2026 Advanced Micro Devices, Inc.
5
 *
6
 * Authors:
7
 *  FangSheng Huang <FangSheng.Huang@amd.com>
8
 *
9
 * SPDX-License-Identifier: GPL-2.0-or-later
10
 */
11
12
#include "qemu/osdep.h"
13
#include "qemu/module.h"
14
#include "qapi/error.h"
15
#include "hw/core/qdev-properties.h"
16
#include "hw/core/qdev.h"
17
#include "hw/mem/sp-mem.h"
18
#include "hw/mem/memory-device.h"
19
#include "system/hostmem.h"
20
21
0
#define SP_MEM_MEMDEV_PROP    "memdev"
22
#define SP_MEM_NODE_PROP      "node"
23
0
#define SP_MEM_ADDR_PROP      "addr"
24
25
static const Property sp_mem_properties[] = {
26
    DEFINE_PROP_LINK(SP_MEM_MEMDEV_PROP, SpMemDevice, hostmem,
27
                     TYPE_MEMORY_BACKEND, HostMemoryBackend *),
28
    DEFINE_PROP_UINT32(SP_MEM_NODE_PROP, SpMemDevice, node, 0),
29
    DEFINE_PROP_UINT64(SP_MEM_ADDR_PROP, SpMemDevice, addr, 0),
30
};
31
32
static uint64_t sp_mem_get_addr(const MemoryDeviceState *md)
33
0
{
34
0
    return object_property_get_uint(OBJECT(md), SP_MEM_ADDR_PROP,
35
0
                                    &error_abort);
36
0
}
37
38
static void sp_mem_set_addr(MemoryDeviceState *md, uint64_t addr,
39
                            Error **errp)
40
0
{
41
0
    object_property_set_uint(OBJECT(md), SP_MEM_ADDR_PROP, addr, errp);
42
0
}
43
44
static MemoryRegion *sp_mem_get_memory_region(MemoryDeviceState *md,
45
                                              Error **errp)
46
0
{
47
0
    SpMemDevice *spm = SP_MEM(md);
48
49
0
    if (!spm->hostmem) {
50
0
        error_setg(errp, "'%s' property must be set", SP_MEM_MEMDEV_PROP);
51
0
        return NULL;
52
0
    }
53
0
    return host_memory_backend_get_memory(spm->hostmem);
54
0
}
55
56
static void sp_mem_fill_device_info(const MemoryDeviceState *md,
57
                                    MemoryDeviceInfo *info)
58
0
{
59
0
    SpMemDeviceInfo *di = g_new0(SpMemDeviceInfo, 1);
60
0
    SpMemDevice *spm = SP_MEM(md);
61
0
    DeviceState *dev = DEVICE(md);
62
63
0
    di->id = dev->id ? g_strdup(dev->id) : NULL;
64
0
    di->addr = spm->addr;
65
0
    di->size = memory_region_size(
66
0
                   host_memory_backend_get_memory(spm->hostmem));
67
0
    di->node = spm->node;
68
0
    di->memdev = object_get_canonical_path(OBJECT(spm->hostmem));
69
70
0
    info->u.sp_mem.data = di;
71
0
    info->type = MEMORY_DEVICE_INFO_KIND_SP_MEM;
72
0
}
73
74
static void sp_mem_realize(DeviceState *dev, Error **errp)
75
0
{
76
0
    SpMemDevice *spm = SP_MEM(dev);
77
78
0
    if (!spm->hostmem) {
79
0
        error_setg(errp, "'%s' property is required", SP_MEM_MEMDEV_PROP);
80
0
        return;
81
0
    }
82
0
    if (host_memory_backend_is_mapped(spm->hostmem)) {
83
0
        error_setg(errp, "memory backend '%s' is already in use",
84
0
                   object_get_canonical_path_component(OBJECT(spm->hostmem)));
85
0
        return;
86
0
    }
87
0
    host_memory_backend_set_mapped(spm->hostmem, true);
88
0
}
89
90
static void sp_mem_unrealize(DeviceState *dev)
91
0
{
92
0
    SpMemDevice *spm = SP_MEM(dev);
93
94
0
    host_memory_backend_set_mapped(spm->hostmem, false);
95
0
}
96
97
static void sp_mem_class_init(ObjectClass *oc, const void *data)
98
61
{
99
61
    DeviceClass *dc = DEVICE_CLASS(oc);
100
61
    MemoryDeviceClass *mdc = MEMORY_DEVICE_CLASS(oc);
101
102
61
    dc->desc = "SPM (Specific Purpose Memory) device";
103
61
    dc->hotpluggable = false;
104
61
    dc->realize = sp_mem_realize;
105
61
    dc->unrealize = sp_mem_unrealize;
106
61
    device_class_set_props(dc, sp_mem_properties);
107
108
61
    mdc->get_addr            = sp_mem_get_addr;
109
61
    mdc->set_addr            = sp_mem_set_addr;
110
61
    mdc->get_memory_region   = sp_mem_get_memory_region;
111
61
    mdc->get_plugged_size    = memory_device_get_region_size;
112
61
    mdc->fill_device_info    = sp_mem_fill_device_info;
113
61
}
114
115
static const TypeInfo sp_mem_types[] = {
116
    {
117
        .name          = TYPE_SP_MEM,
118
        .parent        = TYPE_DEVICE,
119
        .class_init    = sp_mem_class_init,
120
        .instance_size = sizeof(SpMemDevice),
121
        .interfaces    = (InterfaceInfo[]) {
122
            { TYPE_MEMORY_DEVICE },
123
            { }
124
        },
125
    },
126
};
127
128
DEFINE_TYPES(sp_mem_types)