xref: /openbmc/qemu/hw/core/sysbus.c (revision 491da0af)
1 /*
2  *  System (CPU) Bus device support code
3  *
4  *  Copyright (c) 2009 CodeSourcery
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include "qemu/osdep.h"
21 #include "qapi/error.h"
22 #include "qemu/module.h"
23 #include "hw/sysbus.h"
24 #include "monitor/monitor.h"
25 #include "exec/address-spaces.h"
26 
27 static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent);
28 static char *sysbus_get_fw_dev_path(DeviceState *dev);
29 
30 typedef struct SysBusFind {
31     void *opaque;
32     FindSysbusDeviceFunc *func;
33 } SysBusFind;
34 
35 /* Run func() for every sysbus device, traverse the tree for everything else */
find_sysbus_device(Object * obj,void * opaque)36 static int find_sysbus_device(Object *obj, void *opaque)
37 {
38     SysBusFind *find = opaque;
39     Object *dev;
40     SysBusDevice *sbdev;
41 
42     dev = object_dynamic_cast(obj, TYPE_SYS_BUS_DEVICE);
43     sbdev = (SysBusDevice *)dev;
44 
45     if (!sbdev) {
46         /* Container, traverse it for children */
47         return object_child_foreach(obj, find_sysbus_device, opaque);
48     }
49 
50     find->func(sbdev, find->opaque);
51 
52     return 0;
53 }
54 
55 /*
56  * Loop through all dynamically created sysbus devices and call
57  * func() for each instance.
58  */
foreach_dynamic_sysbus_device(FindSysbusDeviceFunc * func,void * opaque)59 void foreach_dynamic_sysbus_device(FindSysbusDeviceFunc *func, void *opaque)
60 {
61     Object *container;
62     SysBusFind find = {
63         .func = func,
64         .opaque = opaque,
65     };
66 
67     /* Loop through all sysbus devices that were spawned outside the machine */
68     container = container_get(qdev_get_machine(), "/peripheral");
69     find_sysbus_device(container, &find);
70     container = container_get(qdev_get_machine(), "/peripheral-anon");
71     find_sysbus_device(container, &find);
72 }
73 
74 
system_bus_class_init(ObjectClass * klass,void * data)75 static void system_bus_class_init(ObjectClass *klass, void *data)
76 {
77     BusClass *k = BUS_CLASS(klass);
78 
79     k->print_dev = sysbus_dev_print;
80     k->get_fw_dev_path = sysbus_get_fw_dev_path;
81 }
82 
83 static const TypeInfo system_bus_info = {
84     .name = TYPE_SYSTEM_BUS,
85     .parent = TYPE_BUS,
86     .instance_size = sizeof(BusState),
87     .class_init = system_bus_class_init,
88 };
89 
90 /* Check whether an IRQ source exists */
sysbus_has_irq(SysBusDevice * dev,int n)91 bool sysbus_has_irq(SysBusDevice *dev, int n)
92 {
93     char *prop = g_strdup_printf("%s[%d]", SYSBUS_DEVICE_GPIO_IRQ, n);
94     ObjectProperty *r;
95 
96     r = object_property_find(OBJECT(dev), prop);
97     g_free(prop);
98 
99     return (r != NULL);
100 }
101 
sysbus_is_irq_connected(SysBusDevice * dev,int n)102 bool sysbus_is_irq_connected(SysBusDevice *dev, int n)
103 {
104     return !!sysbus_get_connected_irq(dev, n);
105 }
106 
sysbus_get_connected_irq(SysBusDevice * dev,int n)107 qemu_irq sysbus_get_connected_irq(SysBusDevice *dev, int n)
108 {
109     DeviceState *d = DEVICE(dev);
110     return qdev_get_gpio_out_connector(d, SYSBUS_DEVICE_GPIO_IRQ, n);
111 }
112 
sysbus_connect_irq(SysBusDevice * dev,int n,qemu_irq irq)113 void sysbus_connect_irq(SysBusDevice *dev, int n, qemu_irq irq)
114 {
115     SysBusDeviceClass *sbd = SYS_BUS_DEVICE_GET_CLASS(dev);
116 
117     qdev_connect_gpio_out_named(DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ, n, irq);
118 
119     if (sbd->connect_irq_notifier) {
120         sbd->connect_irq_notifier(dev, irq);
121     }
122 }
123 
124 /* Check whether an MMIO region exists */
sysbus_has_mmio(SysBusDevice * dev,unsigned int n)125 bool sysbus_has_mmio(SysBusDevice *dev, unsigned int n)
126 {
127     return (n < dev->num_mmio);
128 }
129 
sysbus_mmio_map_common(SysBusDevice * dev,int n,hwaddr addr,bool may_overlap,int priority)130 static void sysbus_mmio_map_common(SysBusDevice *dev, int n, hwaddr addr,
131                                    bool may_overlap, int priority)
132 {
133     assert(n >= 0 && n < dev->num_mmio);
134 
135     if (dev->mmio[n].addr == addr) {
136         /* ??? region already mapped here.  */
137         return;
138     }
139     if (dev->mmio[n].addr != (hwaddr)-1) {
140         /* Unregister previous mapping.  */
141         memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
142     }
143     dev->mmio[n].addr = addr;
144     if (may_overlap) {
145         memory_region_add_subregion_overlap(get_system_memory(),
146                                             addr,
147                                             dev->mmio[n].memory,
148                                             priority);
149     }
150     else {
151         memory_region_add_subregion(get_system_memory(),
152                                     addr,
153                                     dev->mmio[n].memory);
154     }
155 }
156 
sysbus_mmio_unmap(SysBusDevice * dev,int n)157 void sysbus_mmio_unmap(SysBusDevice *dev, int n)
158 {
159     assert(n >= 0 && n < dev->num_mmio);
160 
161     if (dev->mmio[n].addr != (hwaddr)-1) {
162         memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
163         dev->mmio[n].addr = (hwaddr)-1;
164     }
165 }
166 
sysbus_mmio_map(SysBusDevice * dev,int n,hwaddr addr)167 void sysbus_mmio_map(SysBusDevice *dev, int n, hwaddr addr)
168 {
169     sysbus_mmio_map_common(dev, n, addr, false, 0);
170 }
171 
sysbus_mmio_map_overlap(SysBusDevice * dev,int n,hwaddr addr,int priority)172 void sysbus_mmio_map_overlap(SysBusDevice *dev, int n, hwaddr addr,
173                              int priority)
174 {
175     sysbus_mmio_map_common(dev, n, addr, true, priority);
176 }
177 
178 /* Request an IRQ source.  The actual IRQ object may be populated later.  */
sysbus_init_irq(SysBusDevice * dev,qemu_irq * p)179 void sysbus_init_irq(SysBusDevice *dev, qemu_irq *p)
180 {
181     qdev_init_gpio_out_named(DEVICE(dev), p, SYSBUS_DEVICE_GPIO_IRQ, 1);
182 }
183 
184 /* Pass IRQs from a target device.  */
sysbus_pass_irq(SysBusDevice * dev,SysBusDevice * target)185 void sysbus_pass_irq(SysBusDevice *dev, SysBusDevice *target)
186 {
187     qdev_pass_gpios(DEVICE(target), DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ);
188 }
189 
sysbus_init_mmio(SysBusDevice * dev,MemoryRegion * memory)190 void sysbus_init_mmio(SysBusDevice *dev, MemoryRegion *memory)
191 {
192     int n;
193 
194     assert(dev->num_mmio < QDEV_MAX_MMIO);
195     n = dev->num_mmio++;
196     dev->mmio[n].addr = -1;
197     dev->mmio[n].memory = memory;
198 }
199 
sysbus_mmio_get_region(SysBusDevice * dev,int n)200 MemoryRegion *sysbus_mmio_get_region(SysBusDevice *dev, int n)
201 {
202     assert(n >= 0 && n < QDEV_MAX_MMIO);
203     return dev->mmio[n].memory;
204 }
205 
sysbus_init_ioports(SysBusDevice * dev,uint32_t ioport,uint32_t size)206 void sysbus_init_ioports(SysBusDevice *dev, uint32_t ioport, uint32_t size)
207 {
208     uint32_t i;
209 
210     for (i = 0; i < size; i++) {
211         assert(dev->num_pio < QDEV_MAX_PIO);
212         dev->pio[dev->num_pio++] = ioport++;
213     }
214 }
215 
216 /* The purpose of preserving this empty realize function
217  * is to prevent the parent_realize field of some subclasses
218  * from being set to NULL to break the normal init/realize
219  * of some devices.
220  */
sysbus_device_realize(DeviceState * dev,Error ** errp)221 static void sysbus_device_realize(DeviceState *dev, Error **errp)
222 {
223 }
224 
sysbus_create_varargs(const char * name,hwaddr addr,...)225 DeviceState *sysbus_create_varargs(const char *name,
226                                    hwaddr addr, ...)
227 {
228     DeviceState *dev;
229     SysBusDevice *s;
230     va_list va;
231     qemu_irq irq;
232     int n;
233 
234     dev = qdev_new(name);
235     s = SYS_BUS_DEVICE(dev);
236     sysbus_realize_and_unref(s, &error_fatal);
237     if (addr != (hwaddr)-1) {
238         sysbus_mmio_map(s, 0, addr);
239     }
240     va_start(va, addr);
241     n = 0;
242     while (1) {
243         irq = va_arg(va, qemu_irq);
244         if (!irq) {
245             break;
246         }
247         sysbus_connect_irq(s, n, irq);
248         n++;
249     }
250     va_end(va);
251     return dev;
252 }
253 
sysbus_realize(SysBusDevice * dev,Error ** errp)254 bool sysbus_realize(SysBusDevice *dev, Error **errp)
255 {
256     return qdev_realize(DEVICE(dev), sysbus_get_default(), errp);
257 }
258 
sysbus_realize_and_unref(SysBusDevice * dev,Error ** errp)259 bool sysbus_realize_and_unref(SysBusDevice *dev, Error **errp)
260 {
261     return qdev_realize_and_unref(DEVICE(dev), sysbus_get_default(), errp);
262 }
263 
sysbus_dev_print(Monitor * mon,DeviceState * dev,int indent)264 static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent)
265 {
266     SysBusDevice *s = SYS_BUS_DEVICE(dev);
267     hwaddr size;
268     int i;
269 
270     for (i = 0; i < s->num_mmio; i++) {
271         size = memory_region_size(s->mmio[i].memory);
272         monitor_printf(mon, "%*smmio " HWADDR_FMT_plx "/" HWADDR_FMT_plx "\n",
273                        indent, "", s->mmio[i].addr, size);
274     }
275 }
276 
sysbus_get_fw_dev_path(DeviceState * dev)277 static char *sysbus_get_fw_dev_path(DeviceState *dev)
278 {
279     SysBusDevice *s = SYS_BUS_DEVICE(dev);
280     SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(s);
281     char *addr, *fw_dev_path;
282 
283     if (sbc->explicit_ofw_unit_address) {
284         addr = sbc->explicit_ofw_unit_address(s);
285         if (addr) {
286             fw_dev_path = g_strdup_printf("%s@%s", qdev_fw_name(dev), addr);
287             g_free(addr);
288             return fw_dev_path;
289         }
290     }
291     if (s->num_mmio) {
292         return g_strdup_printf("%s@" HWADDR_FMT_plx, qdev_fw_name(dev),
293                                s->mmio[0].addr);
294     }
295     if (s->num_pio) {
296         return g_strdup_printf("%s@i%04x", qdev_fw_name(dev), s->pio[0]);
297     }
298     return g_strdup(qdev_fw_name(dev));
299 }
300 
sysbus_device_class_init(ObjectClass * klass,void * data)301 static void sysbus_device_class_init(ObjectClass *klass, void *data)
302 {
303     DeviceClass *k = DEVICE_CLASS(klass);
304     k->realize = sysbus_device_realize;
305     k->bus_type = TYPE_SYSTEM_BUS;
306     /*
307      * device_add plugs devices into a suitable bus.  For "real" buses,
308      * that actually connects the device.  For sysbus, the connections
309      * need to be made separately, and device_add can't do that.  The
310      * device would be left unconnected, and will probably not work
311      *
312      * However, a few machines can handle device_add/-device with
313      * a few specific sysbus devices. In those cases, the device
314      * subclass needs to override it and set user_creatable=true.
315      */
316     k->user_creatable = false;
317 }
318 
319 static const TypeInfo sysbus_device_type_info = {
320     .name = TYPE_SYS_BUS_DEVICE,
321     .parent = TYPE_DEVICE,
322     .instance_size = sizeof(SysBusDevice),
323     .abstract = true,
324     .class_size = sizeof(SysBusDeviceClass),
325     .class_init = sysbus_device_class_init,
326 };
327 
328 static BusState *main_system_bus;
329 
main_system_bus_create(void)330 static void main_system_bus_create(void)
331 {
332     /*
333      * assign main_system_bus before qbus_init()
334      * in order to make "if (bus != sysbus_get_default())" work
335      */
336     main_system_bus = g_malloc0(system_bus_info.instance_size);
337     qbus_init(main_system_bus, system_bus_info.instance_size,
338               TYPE_SYSTEM_BUS, NULL, "main-system-bus");
339     OBJECT(main_system_bus)->free = g_free;
340 }
341 
sysbus_get_default(void)342 BusState *sysbus_get_default(void)
343 {
344     if (!main_system_bus) {
345         main_system_bus_create();
346     }
347     return main_system_bus;
348 }
349 
sysbus_register_types(void)350 static void sysbus_register_types(void)
351 {
352     type_register_static(&system_bus_info);
353     type_register_static(&sysbus_device_type_info);
354 }
355 
356 type_init(sysbus_register_types)
357