]>
Commit | Line | Data |
---|---|---|
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 "sysbus.h" | |
21 | #include "monitor.h" | |
22 | #include "exec-memory.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 | static void system_bus_class_init(ObjectClass *klass, void *data) | |
28 | { | |
29 | BusClass *k = BUS_CLASS(klass); | |
30 | ||
31 | k->print_dev = sysbus_dev_print; | |
32 | k->get_fw_dev_path = sysbus_get_fw_dev_path; | |
33 | } | |
34 | ||
35 | static const TypeInfo system_bus_info = { | |
36 | .name = TYPE_SYSTEM_BUS, | |
37 | .parent = TYPE_BUS, | |
38 | .instance_size = sizeof(BusState), | |
39 | .class_init = system_bus_class_init, | |
40 | }; | |
41 | ||
42 | void sysbus_connect_irq(SysBusDevice *dev, int n, qemu_irq irq) | |
43 | { | |
44 | assert(n >= 0 && n < dev->num_irq); | |
45 | dev->irqs[n] = NULL; | |
46 | if (dev->irqp[n]) { | |
47 | *dev->irqp[n] = irq; | |
48 | } | |
49 | } | |
50 | ||
51 | void sysbus_mmio_map(SysBusDevice *dev, int n, hwaddr addr) | |
52 | { | |
53 | assert(n >= 0 && n < dev->num_mmio); | |
54 | ||
55 | if (dev->mmio[n].addr == addr) { | |
56 | /* ??? region already mapped here. */ | |
57 | return; | |
58 | } | |
59 | if (dev->mmio[n].addr != (hwaddr)-1) { | |
60 | /* Unregister previous mapping. */ | |
61 | memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory); | |
62 | } | |
63 | dev->mmio[n].addr = addr; | |
64 | memory_region_add_subregion(get_system_memory(), | |
65 | addr, | |
66 | dev->mmio[n].memory); | |
67 | } | |
68 | ||
69 | ||
70 | /* Request an IRQ source. The actual IRQ object may be populated later. */ | |
71 | void sysbus_init_irq(SysBusDevice *dev, qemu_irq *p) | |
72 | { | |
73 | int n; | |
74 | ||
75 | assert(dev->num_irq < QDEV_MAX_IRQ); | |
76 | n = dev->num_irq++; | |
77 | dev->irqp[n] = p; | |
78 | } | |
79 | ||
80 | /* Pass IRQs from a target device. */ | |
81 | void sysbus_pass_irq(SysBusDevice *dev, SysBusDevice *target) | |
82 | { | |
83 | int i; | |
84 | assert(dev->num_irq == 0); | |
85 | dev->num_irq = target->num_irq; | |
86 | for (i = 0; i < dev->num_irq; i++) { | |
87 | dev->irqp[i] = target->irqp[i]; | |
88 | } | |
89 | } | |
90 | ||
91 | void sysbus_init_mmio(SysBusDevice *dev, MemoryRegion *memory) | |
92 | { | |
93 | int n; | |
94 | ||
95 | assert(dev->num_mmio < QDEV_MAX_MMIO); | |
96 | n = dev->num_mmio++; | |
97 | dev->mmio[n].addr = -1; | |
98 | dev->mmio[n].memory = memory; | |
99 | } | |
100 | ||
101 | MemoryRegion *sysbus_mmio_get_region(SysBusDevice *dev, int n) | |
102 | { | |
103 | return dev->mmio[n].memory; | |
104 | } | |
105 | ||
106 | void sysbus_init_ioports(SysBusDevice *dev, pio_addr_t ioport, pio_addr_t size) | |
107 | { | |
108 | pio_addr_t i; | |
109 | ||
110 | for (i = 0; i < size; i++) { | |
111 | assert(dev->num_pio < QDEV_MAX_PIO); | |
112 | dev->pio[dev->num_pio++] = ioport++; | |
113 | } | |
114 | } | |
115 | ||
116 | static int sysbus_device_init(DeviceState *dev) | |
117 | { | |
118 | SysBusDevice *sd = SYS_BUS_DEVICE(dev); | |
119 | SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(sd); | |
120 | ||
121 | return sbc->init(sd); | |
122 | } | |
123 | ||
124 | DeviceState *sysbus_create_varargs(const char *name, | |
125 | hwaddr addr, ...) | |
126 | { | |
127 | DeviceState *dev; | |
128 | SysBusDevice *s; | |
129 | va_list va; | |
130 | qemu_irq irq; | |
131 | int n; | |
132 | ||
133 | dev = qdev_create(NULL, name); | |
134 | s = sysbus_from_qdev(dev); | |
135 | qdev_init_nofail(dev); | |
136 | if (addr != (hwaddr)-1) { | |
137 | sysbus_mmio_map(s, 0, addr); | |
138 | } | |
139 | va_start(va, addr); | |
140 | n = 0; | |
141 | while (1) { | |
142 | irq = va_arg(va, qemu_irq); | |
143 | if (!irq) { | |
144 | break; | |
145 | } | |
146 | sysbus_connect_irq(s, n, irq); | |
147 | n++; | |
148 | } | |
149 | va_end(va); | |
150 | return dev; | |
151 | } | |
152 | ||
153 | DeviceState *sysbus_try_create_varargs(const char *name, | |
154 | hwaddr addr, ...) | |
155 | { | |
156 | DeviceState *dev; | |
157 | SysBusDevice *s; | |
158 | va_list va; | |
159 | qemu_irq irq; | |
160 | int n; | |
161 | ||
162 | dev = qdev_try_create(NULL, name); | |
163 | if (!dev) { | |
164 | return NULL; | |
165 | } | |
166 | s = sysbus_from_qdev(dev); | |
167 | qdev_init_nofail(dev); | |
168 | if (addr != (hwaddr)-1) { | |
169 | sysbus_mmio_map(s, 0, addr); | |
170 | } | |
171 | va_start(va, addr); | |
172 | n = 0; | |
173 | while (1) { | |
174 | irq = va_arg(va, qemu_irq); | |
175 | if (!irq) { | |
176 | break; | |
177 | } | |
178 | sysbus_connect_irq(s, n, irq); | |
179 | n++; | |
180 | } | |
181 | va_end(va); | |
182 | return dev; | |
183 | } | |
184 | ||
185 | static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent) | |
186 | { | |
187 | SysBusDevice *s = sysbus_from_qdev(dev); | |
188 | hwaddr size; | |
189 | int i; | |
190 | ||
191 | monitor_printf(mon, "%*sirq %d\n", indent, "", s->num_irq); | |
192 | for (i = 0; i < s->num_mmio; i++) { | |
193 | size = memory_region_size(s->mmio[i].memory); | |
194 | monitor_printf(mon, "%*smmio " TARGET_FMT_plx "/" TARGET_FMT_plx "\n", | |
195 | indent, "", s->mmio[i].addr, size); | |
196 | } | |
197 | } | |
198 | ||
199 | static char *sysbus_get_fw_dev_path(DeviceState *dev) | |
200 | { | |
201 | SysBusDevice *s = sysbus_from_qdev(dev); | |
202 | char path[40]; | |
203 | int off; | |
204 | ||
205 | off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev)); | |
206 | ||
207 | if (s->num_mmio) { | |
208 | snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx, | |
209 | s->mmio[0].addr); | |
210 | } else if (s->num_pio) { | |
211 | snprintf(path + off, sizeof(path) - off, "@i%04x", s->pio[0]); | |
212 | } | |
213 | ||
214 | return g_strdup(path); | |
215 | } | |
216 | ||
217 | void sysbus_add_memory(SysBusDevice *dev, hwaddr addr, | |
218 | MemoryRegion *mem) | |
219 | { | |
220 | memory_region_add_subregion(get_system_memory(), addr, mem); | |
221 | } | |
222 | ||
223 | void sysbus_add_memory_overlap(SysBusDevice *dev, hwaddr addr, | |
224 | MemoryRegion *mem, unsigned priority) | |
225 | { | |
226 | memory_region_add_subregion_overlap(get_system_memory(), addr, mem, | |
227 | priority); | |
228 | } | |
229 | ||
230 | void sysbus_del_memory(SysBusDevice *dev, MemoryRegion *mem) | |
231 | { | |
232 | memory_region_del_subregion(get_system_memory(), mem); | |
233 | } | |
234 | ||
235 | void sysbus_add_io(SysBusDevice *dev, hwaddr addr, | |
236 | MemoryRegion *mem) | |
237 | { | |
238 | memory_region_add_subregion(get_system_io(), addr, mem); | |
239 | } | |
240 | ||
241 | void sysbus_del_io(SysBusDevice *dev, MemoryRegion *mem) | |
242 | { | |
243 | memory_region_del_subregion(get_system_io(), mem); | |
244 | } | |
245 | ||
246 | MemoryRegion *sysbus_address_space(SysBusDevice *dev) | |
247 | { | |
248 | return get_system_memory(); | |
249 | } | |
250 | ||
251 | static void sysbus_device_class_init(ObjectClass *klass, void *data) | |
252 | { | |
253 | DeviceClass *k = DEVICE_CLASS(klass); | |
254 | k->init = sysbus_device_init; | |
255 | k->bus_type = TYPE_SYSTEM_BUS; | |
256 | } | |
257 | ||
258 | static TypeInfo sysbus_device_type_info = { | |
259 | .name = TYPE_SYS_BUS_DEVICE, | |
260 | .parent = TYPE_DEVICE, | |
261 | .instance_size = sizeof(SysBusDevice), | |
262 | .abstract = true, | |
263 | .class_size = sizeof(SysBusDeviceClass), | |
264 | .class_init = sysbus_device_class_init, | |
265 | }; | |
266 | ||
267 | /* This is a nasty hack to allow passing a NULL bus to qdev_create. */ | |
268 | static BusState *main_system_bus; | |
269 | ||
270 | static void main_system_bus_create(void) | |
271 | { | |
272 | /* assign main_system_bus before qbus_create_inplace() | |
273 | * in order to make "if (bus != sysbus_get_default())" work */ | |
274 | main_system_bus = g_malloc0(system_bus_info.instance_size); | |
275 | qbus_create_inplace(main_system_bus, TYPE_SYSTEM_BUS, NULL, | |
276 | "main-system-bus"); | |
277 | OBJECT(main_system_bus)->free = g_free; | |
278 | object_property_add_child(container_get(qdev_get_machine(), | |
279 | "/unattached"), | |
280 | "sysbus", OBJECT(main_system_bus), NULL); | |
281 | } | |
282 | ||
283 | BusState *sysbus_get_default(void) | |
284 | { | |
285 | if (!main_system_bus) { | |
286 | main_system_bus_create(); | |
287 | } | |
288 | return main_system_bus; | |
289 | } | |
290 | ||
291 | static void sysbus_register_types(void) | |
292 | { | |
293 | type_register_static(&system_bus_info); | |
294 | type_register_static(&sysbus_device_type_info); | |
295 | } | |
296 | ||
297 | type_init(sysbus_register_types) |