xref: /openbmc/qemu/hw/core/sysbus.c (revision 81b07353c5e7ae9ae9360c357b7b4732b1cb03b4) 
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 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 "hw/sysbus.h"
21 #include "monitor/monitor.h"
22 #include "exec/address-spaces.h"
23 
24 static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent);
25 static char *sysbus_get_fw_dev_path(DeviceState *dev);
26 
27 typedef struct SysBusFind {
28     void *opaque;
29     FindSysbusDeviceFunc *func;
30 } SysBusFind;
31 
32 /* Run func() for every sysbus device, traverse the tree for everything else */
33 static int find_sysbus_device(Object *obj, void *opaque)
34 {
35     SysBusFind *find = opaque;
36     Object *dev;
37     SysBusDevice *sbdev;
38 
39     dev = object_dynamic_cast(obj, TYPE_SYS_BUS_DEVICE);
40     sbdev = (SysBusDevice *)dev;
41 
42     if (!sbdev) {
43         /* Container, traverse it for children */
44         return object_child_foreach(obj, find_sysbus_device, opaque);
45     }
46 
47     find->func(sbdev, find->opaque);
48 
49     return 0;
50 }
51 
52 /*
53  * Loop through all dynamically created sysbus devices and call
54  * func() for each instance.
55  */
56 void foreach_dynamic_sysbus_device(FindSysbusDeviceFunc *func, void *opaque)
57 {
58     Object *container;
59     SysBusFind find = {
60         .func = func,
61         .opaque = opaque,
62     };
63 
64     /* Loop through all sysbus devices that were spawened outside the machine */
65     container = container_get(qdev_get_machine(), "/peripheral");
66     find_sysbus_device(container, &find);
67     container = container_get(qdev_get_machine(), "/peripheral-anon");
68     find_sysbus_device(container, &find);
69 }
70 
71 
72 static void system_bus_class_init(ObjectClass *klass, void *data)
73 {
74     BusClass *k = BUS_CLASS(klass);
75 
76     k->print_dev = sysbus_dev_print;
77     k->get_fw_dev_path = sysbus_get_fw_dev_path;
78 }
79 
80 static const TypeInfo system_bus_info = {
81     .name = TYPE_SYSTEM_BUS,
82     .parent = TYPE_BUS,
83     .instance_size = sizeof(BusState),
84     .class_init = system_bus_class_init,
85 };
86 
87 /* Check whether an IRQ source exists */
88 bool sysbus_has_irq(SysBusDevice *dev, int n)
89 {
90     char *prop = g_strdup_printf("%s[%d]", SYSBUS_DEVICE_GPIO_IRQ, n);
91     ObjectProperty *r;
92 
93     r = object_property_find(OBJECT(dev), prop, NULL);
94     return (r != NULL);
95 }
96 
97 bool sysbus_is_irq_connected(SysBusDevice *dev, int n)
98 {
99     return !!sysbus_get_connected_irq(dev, n);
100 }
101 
102 qemu_irq sysbus_get_connected_irq(SysBusDevice *dev, int n)
103 {
104     DeviceState *d = DEVICE(dev);
105     return qdev_get_gpio_out_connector(d, SYSBUS_DEVICE_GPIO_IRQ, n);
106 }
107 
108 void sysbus_connect_irq(SysBusDevice *dev, int n, qemu_irq irq)
109 {
110     qdev_connect_gpio_out_named(DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ, n, irq);
111 }
112 
113 /* Check whether an MMIO region exists */
114 bool sysbus_has_mmio(SysBusDevice *dev, unsigned int n)
115 {
116     return (n < dev->num_mmio);
117 }
118 
119 static void sysbus_mmio_map_common(SysBusDevice *dev, int n, hwaddr addr,
120                                    bool may_overlap, int priority)
121 {
122     assert(n >= 0 && n < dev->num_mmio);
123 
124     if (dev->mmio[n].addr == addr) {
125         /* ??? region already mapped here.  */
126         return;
127     }
128     if (dev->mmio[n].addr != (hwaddr)-1) {
129         /* Unregister previous mapping.  */
130         memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
131     }
132     dev->mmio[n].addr = addr;
133     if (may_overlap) {
134         memory_region_add_subregion_overlap(get_system_memory(),
135                                             addr,
136                                             dev->mmio[n].memory,
137                                             priority);
138     }
139     else {
140         memory_region_add_subregion(get_system_memory(),
141                                     addr,
142                                     dev->mmio[n].memory);
143     }
144 }
145 
146 void sysbus_mmio_map(SysBusDevice *dev, int n, hwaddr addr)
147 {
148     sysbus_mmio_map_common(dev, n, addr, false, 0);
149 }
150 
151 void sysbus_mmio_map_overlap(SysBusDevice *dev, int n, hwaddr addr,
152                              int priority)
153 {
154     sysbus_mmio_map_common(dev, n, addr, true, priority);
155 }
156 
157 /* Request an IRQ source.  The actual IRQ object may be populated later.  */
158 void sysbus_init_irq(SysBusDevice *dev, qemu_irq *p)
159 {
160     qdev_init_gpio_out_named(DEVICE(dev), p, SYSBUS_DEVICE_GPIO_IRQ, 1);
161 }
162 
163 /* Pass IRQs from a target device.  */
164 void sysbus_pass_irq(SysBusDevice *dev, SysBusDevice *target)
165 {
166     qdev_pass_gpios(DEVICE(target), DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ);
167 }
168 
169 void sysbus_init_mmio(SysBusDevice *dev, MemoryRegion *memory)
170 {
171     int n;
172 
173     assert(dev->num_mmio < QDEV_MAX_MMIO);
174     n = dev->num_mmio++;
175     dev->mmio[n].addr = -1;
176     dev->mmio[n].memory = memory;
177 }
178 
179 MemoryRegion *sysbus_mmio_get_region(SysBusDevice *dev, int n)
180 {
181     return dev->mmio[n].memory;
182 }
183 
184 void sysbus_init_ioports(SysBusDevice *dev, pio_addr_t ioport, pio_addr_t size)
185 {
186     pio_addr_t i;
187 
188     for (i = 0; i < size; i++) {
189         assert(dev->num_pio < QDEV_MAX_PIO);
190         dev->pio[dev->num_pio++] = ioport++;
191     }
192 }
193 
194 static int sysbus_device_init(DeviceState *dev)
195 {
196     SysBusDevice *sd = SYS_BUS_DEVICE(dev);
197     SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(sd);
198 
199     if (!sbc->init) {
200         return 0;
201     }
202     return sbc->init(sd);
203 }
204 
205 DeviceState *sysbus_create_varargs(const char *name,
206                                    hwaddr addr, ...)
207 {
208     DeviceState *dev;
209     SysBusDevice *s;
210     va_list va;
211     qemu_irq irq;
212     int n;
213 
214     dev = qdev_create(NULL, name);
215     s = SYS_BUS_DEVICE(dev);
216     qdev_init_nofail(dev);
217     if (addr != (hwaddr)-1) {
218         sysbus_mmio_map(s, 0, addr);
219     }
220     va_start(va, addr);
221     n = 0;
222     while (1) {
223         irq = va_arg(va, qemu_irq);
224         if (!irq) {
225             break;
226         }
227         sysbus_connect_irq(s, n, irq);
228         n++;
229     }
230     va_end(va);
231     return dev;
232 }
233 
234 DeviceState *sysbus_try_create_varargs(const char *name,
235                                        hwaddr addr, ...)
236 {
237     DeviceState *dev;
238     SysBusDevice *s;
239     va_list va;
240     qemu_irq irq;
241     int n;
242 
243     dev = qdev_try_create(NULL, name);
244     if (!dev) {
245         return NULL;
246     }
247     s = SYS_BUS_DEVICE(dev);
248     qdev_init_nofail(dev);
249     if (addr != (hwaddr)-1) {
250         sysbus_mmio_map(s, 0, addr);
251     }
252     va_start(va, addr);
253     n = 0;
254     while (1) {
255         irq = va_arg(va, qemu_irq);
256         if (!irq) {
257             break;
258         }
259         sysbus_connect_irq(s, n, irq);
260         n++;
261     }
262     va_end(va);
263     return dev;
264 }
265 
266 static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent)
267 {
268     SysBusDevice *s = SYS_BUS_DEVICE(dev);
269     hwaddr size;
270     int i;
271 
272     for (i = 0; i < s->num_mmio; i++) {
273         size = memory_region_size(s->mmio[i].memory);
274         monitor_printf(mon, "%*smmio " TARGET_FMT_plx "/" TARGET_FMT_plx "\n",
275                        indent, "", s->mmio[i].addr, size);
276     }
277 }
278 
279 static char *sysbus_get_fw_dev_path(DeviceState *dev)
280 {
281     SysBusDevice *s = SYS_BUS_DEVICE(dev);
282     char path[40];
283     int off;
284 
285     off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev));
286 
287     if (s->num_mmio) {
288         snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx,
289                  s->mmio[0].addr);
290     } else if (s->num_pio) {
291         snprintf(path + off, sizeof(path) - off, "@i%04x", s->pio[0]);
292     }
293 
294     return g_strdup(path);
295 }
296 
297 void sysbus_add_io(SysBusDevice *dev, hwaddr addr,
298                        MemoryRegion *mem)
299 {
300     memory_region_add_subregion(get_system_io(), addr, mem);
301 }
302 
303 MemoryRegion *sysbus_address_space(SysBusDevice *dev)
304 {
305     return get_system_memory();
306 }
307 
308 static void sysbus_device_class_init(ObjectClass *klass, void *data)
309 {
310     DeviceClass *k = DEVICE_CLASS(klass);
311     k->init = sysbus_device_init;
312     k->bus_type = TYPE_SYSTEM_BUS;
313 }
314 
315 static const TypeInfo sysbus_device_type_info = {
316     .name = TYPE_SYS_BUS_DEVICE,
317     .parent = TYPE_DEVICE,
318     .instance_size = sizeof(SysBusDevice),
319     .abstract = true,
320     .class_size = sizeof(SysBusDeviceClass),
321     .class_init = sysbus_device_class_init,
322 };
323 
324 /* This is a nasty hack to allow passing a NULL bus to qdev_create.  */
325 static BusState *main_system_bus;
326 
327 static void main_system_bus_create(void)
328 {
329     /* assign main_system_bus before qbus_create_inplace()
330      * in order to make "if (bus != sysbus_get_default())" work */
331     main_system_bus = g_malloc0(system_bus_info.instance_size);
332     qbus_create_inplace(main_system_bus, system_bus_info.instance_size,
333                         TYPE_SYSTEM_BUS, NULL, "main-system-bus");
334     OBJECT(main_system_bus)->free = g_free;
335     object_property_add_child(container_get(qdev_get_machine(),
336                                             "/unattached"),
337                               "sysbus", OBJECT(main_system_bus), NULL);
338 }
339 
340 BusState *sysbus_get_default(void)
341 {
342     if (!main_system_bus) {
343         main_system_bus_create();
344     }
345     return main_system_bus;
346 }
347 
348 static void sysbus_register_types(void)
349 {
350     type_register_static(&system_bus_info);
351     type_register_static(&sysbus_device_type_info);
352 }
353 
354 type_init(sysbus_register_types)
355