1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 /*
25 * split out ioport related stuffs from vl.c.
26 */
27
28 #include "qemu/osdep.h"
29 #include "cpu.h"
30 #include "exec/ioport.h"
31 #include "exec/memory.h"
32 #include "exec/address-spaces.h"
33 #include "trace.h"
34
35 struct MemoryRegionPortioList {
36 Object obj;
37
38 MemoryRegion mr;
39 void *portio_opaque;
40 MemoryRegionPortio *ports;
41 };
42
43 #define TYPE_MEMORY_REGION_PORTIO_LIST "memory-region-portio-list"
OBJECT_DECLARE_SIMPLE_TYPE(MemoryRegionPortioList,MEMORY_REGION_PORTIO_LIST)44 OBJECT_DECLARE_SIMPLE_TYPE(MemoryRegionPortioList, MEMORY_REGION_PORTIO_LIST)
45
46 static uint64_t unassigned_io_read(void *opaque, hwaddr addr, unsigned size)
47 {
48 return -1ULL;
49 }
50
unassigned_io_write(void * opaque,hwaddr addr,uint64_t val,unsigned size)51 static void unassigned_io_write(void *opaque, hwaddr addr, uint64_t val,
52 unsigned size)
53 {
54 }
55
56 const MemoryRegionOps unassigned_io_ops = {
57 .read = unassigned_io_read,
58 .write = unassigned_io_write,
59 .endianness = DEVICE_NATIVE_ENDIAN,
60 };
61
cpu_outb(uint32_t addr,uint8_t val)62 void cpu_outb(uint32_t addr, uint8_t val)
63 {
64 trace_cpu_out(addr, 'b', val);
65 address_space_write(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED,
66 &val, 1);
67 }
68
cpu_outw(uint32_t addr,uint16_t val)69 void cpu_outw(uint32_t addr, uint16_t val)
70 {
71 uint8_t buf[2];
72
73 trace_cpu_out(addr, 'w', val);
74 stw_p(buf, val);
75 address_space_write(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED,
76 buf, 2);
77 }
78
cpu_outl(uint32_t addr,uint32_t val)79 void cpu_outl(uint32_t addr, uint32_t val)
80 {
81 uint8_t buf[4];
82
83 trace_cpu_out(addr, 'l', val);
84 stl_p(buf, val);
85 address_space_write(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED,
86 buf, 4);
87 }
88
cpu_inb(uint32_t addr)89 uint8_t cpu_inb(uint32_t addr)
90 {
91 uint8_t val;
92
93 address_space_read(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED,
94 &val, 1);
95 trace_cpu_in(addr, 'b', val);
96 return val;
97 }
98
cpu_inw(uint32_t addr)99 uint16_t cpu_inw(uint32_t addr)
100 {
101 uint8_t buf[2];
102 uint16_t val;
103
104 address_space_read(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED, buf, 2);
105 val = lduw_p(buf);
106 trace_cpu_in(addr, 'w', val);
107 return val;
108 }
109
cpu_inl(uint32_t addr)110 uint32_t cpu_inl(uint32_t addr)
111 {
112 uint8_t buf[4];
113 uint32_t val;
114
115 address_space_read(&address_space_io, addr, MEMTXATTRS_UNSPECIFIED, buf, 4);
116 val = ldl_p(buf);
117 trace_cpu_in(addr, 'l', val);
118 return val;
119 }
120
portio_list_init(PortioList * piolist,Object * owner,const MemoryRegionPortio * callbacks,void * opaque,const char * name)121 void portio_list_init(PortioList *piolist,
122 Object *owner,
123 const MemoryRegionPortio *callbacks,
124 void *opaque, const char *name)
125 {
126 unsigned n = 0;
127
128 while (callbacks[n].size) {
129 ++n;
130 }
131
132 piolist->ports = callbacks;
133 piolist->nr = 0;
134 piolist->regions = g_new0(MemoryRegion *, n);
135 piolist->address_space = NULL;
136 piolist->addr = 0;
137 piolist->opaque = opaque;
138 piolist->owner = owner;
139 piolist->name = name;
140 piolist->flush_coalesced_mmio = false;
141 }
142
portio_list_set_flush_coalesced(PortioList * piolist)143 void portio_list_set_flush_coalesced(PortioList *piolist)
144 {
145 piolist->flush_coalesced_mmio = true;
146 }
147
portio_list_destroy(PortioList * piolist)148 void portio_list_destroy(PortioList *piolist)
149 {
150 MemoryRegionPortioList *mrpio;
151 unsigned i;
152
153 for (i = 0; i < piolist->nr; ++i) {
154 mrpio = container_of(piolist->regions[i], MemoryRegionPortioList, mr);
155 object_unparent(OBJECT(&mrpio->mr));
156 object_unref(mrpio);
157 }
158 g_free(piolist->regions);
159 }
160
find_portio(MemoryRegionPortioList * mrpio,uint64_t offset,unsigned size,bool write)161 static const MemoryRegionPortio *find_portio(MemoryRegionPortioList *mrpio,
162 uint64_t offset, unsigned size,
163 bool write)
164 {
165 const MemoryRegionPortio *mrp;
166
167 for (mrp = mrpio->ports; mrp->size; ++mrp) {
168 if (offset >= mrp->offset && offset < mrp->offset + mrp->len &&
169 size == mrp->size &&
170 (write ? (bool)mrp->write : (bool)mrp->read)) {
171 return mrp;
172 }
173 }
174 return NULL;
175 }
176
portio_read(void * opaque,hwaddr addr,unsigned size)177 static uint64_t portio_read(void *opaque, hwaddr addr, unsigned size)
178 {
179 MemoryRegionPortioList *mrpio = opaque;
180 const MemoryRegionPortio *mrp = find_portio(mrpio, addr, size, false);
181 uint64_t data;
182
183 data = ((uint64_t)1 << (size * 8)) - 1;
184 if (mrp) {
185 data = mrp->read(mrpio->portio_opaque, mrpio->mr.addr + addr);
186 } else if (size == 2) {
187 mrp = find_portio(mrpio, addr, 1, false);
188 if (mrp) {
189 data = mrp->read(mrpio->portio_opaque, mrpio->mr.addr + addr);
190 if (addr + 1 < mrp->offset + mrp->len) {
191 data |= mrp->read(mrpio->portio_opaque, mrpio->mr.addr + addr + 1) << 8;
192 } else {
193 data |= 0xff00;
194 }
195 }
196 }
197 return data;
198 }
199
portio_write(void * opaque,hwaddr addr,uint64_t data,unsigned size)200 static void portio_write(void *opaque, hwaddr addr, uint64_t data,
201 unsigned size)
202 {
203 MemoryRegionPortioList *mrpio = opaque;
204 const MemoryRegionPortio *mrp = find_portio(mrpio, addr, size, true);
205
206 if (mrp) {
207 mrp->write(mrpio->portio_opaque, mrpio->mr.addr + addr, data);
208 } else if (size == 2) {
209 mrp = find_portio(mrpio, addr, 1, true);
210 if (mrp) {
211 mrp->write(mrpio->portio_opaque, mrpio->mr.addr + addr, data & 0xff);
212 if (addr + 1 < mrp->offset + mrp->len) {
213 mrp->write(mrpio->portio_opaque, mrpio->mr.addr + addr + 1, data >> 8);
214 }
215 }
216 }
217 }
218
219 static const MemoryRegionOps portio_ops = {
220 .read = portio_read,
221 .write = portio_write,
222 .endianness = DEVICE_LITTLE_ENDIAN,
223 .valid.unaligned = true,
224 .impl.unaligned = true,
225 };
226
portio_list_add_1(PortioList * piolist,const MemoryRegionPortio * pio_init,unsigned count,unsigned start,unsigned off_low,unsigned off_high)227 static void portio_list_add_1(PortioList *piolist,
228 const MemoryRegionPortio *pio_init,
229 unsigned count, unsigned start,
230 unsigned off_low, unsigned off_high)
231 {
232 MemoryRegionPortioList *mrpio;
233 Object *owner;
234 char *name;
235 unsigned i;
236
237 /* Copy the sub-list and null-terminate it. */
238 mrpio = MEMORY_REGION_PORTIO_LIST(
239 object_new(TYPE_MEMORY_REGION_PORTIO_LIST));
240 mrpio->portio_opaque = piolist->opaque;
241 mrpio->ports = g_malloc0(sizeof(MemoryRegionPortio) * (count + 1));
242 memcpy(mrpio->ports, pio_init, sizeof(MemoryRegionPortio) * count);
243 memset(mrpio->ports + count, 0, sizeof(MemoryRegionPortio));
244
245 /* Adjust the offsets to all be zero-based for the region. */
246 for (i = 0; i < count; ++i) {
247 mrpio->ports[i].offset -= off_low;
248 }
249
250 /*
251 * The MemoryRegion owner is the MemoryRegionPortioList since that manages
252 * the lifecycle via the refcount
253 */
254 memory_region_init_io(&mrpio->mr, OBJECT(mrpio), &portio_ops, mrpio,
255 piolist->name, off_high - off_low);
256
257 /* Reparent the MemoryRegion to the piolist owner */
258 object_ref(&mrpio->mr);
259 object_unparent(OBJECT(&mrpio->mr));
260 if (!piolist->owner) {
261 owner = container_get(qdev_get_machine(), "/unattached");
262 } else {
263 owner = piolist->owner;
264 }
265 name = g_strdup_printf("%s[*]", piolist->name);
266 object_property_add_child(owner, name, OBJECT(&mrpio->mr));
267 g_free(name);
268
269 if (piolist->flush_coalesced_mmio) {
270 memory_region_set_flush_coalesced(&mrpio->mr);
271 }
272 memory_region_add_subregion(piolist->address_space,
273 start + off_low, &mrpio->mr);
274 piolist->regions[piolist->nr] = &mrpio->mr;
275 ++piolist->nr;
276 }
277
portio_list_add(PortioList * piolist,MemoryRegion * address_space,uint32_t start)278 void portio_list_add(PortioList *piolist,
279 MemoryRegion *address_space,
280 uint32_t start)
281 {
282 const MemoryRegionPortio *pio, *pio_start = piolist->ports;
283 unsigned int off_low, off_high, off_last, count;
284
285 piolist->address_space = address_space;
286 piolist->addr = start;
287
288 /* Handle the first entry specially. */
289 off_last = off_low = pio_start->offset;
290 off_high = off_low + pio_start->len + pio_start->size - 1;
291 count = 1;
292
293 for (pio = pio_start + 1; pio->size != 0; pio++, count++) {
294 /* All entries must be sorted by offset. */
295 assert(pio->offset >= off_last);
296 off_last = pio->offset;
297
298 /* If we see a hole, break the region. */
299 if (off_last > off_high) {
300 portio_list_add_1(piolist, pio_start, count, start, off_low,
301 off_high);
302 /* ... and start collecting anew. */
303 pio_start = pio;
304 off_low = off_last;
305 off_high = off_low + pio->len + pio_start->size - 1;
306 count = 0;
307 } else if (off_last + pio->len > off_high) {
308 off_high = off_last + pio->len + pio_start->size - 1;
309 }
310 }
311
312 /* There will always be an open sub-list. */
313 portio_list_add_1(piolist, pio_start, count, start, off_low, off_high);
314 }
315
portio_list_del(PortioList * piolist)316 void portio_list_del(PortioList *piolist)
317 {
318 MemoryRegionPortioList *mrpio;
319 unsigned i;
320
321 for (i = 0; i < piolist->nr; ++i) {
322 mrpio = container_of(piolist->regions[i], MemoryRegionPortioList, mr);
323 memory_region_del_subregion(piolist->address_space, &mrpio->mr);
324 }
325 }
326
portio_list_set_enabled(PortioList * piolist,bool enabled)327 void portio_list_set_enabled(PortioList *piolist, bool enabled)
328 {
329 unsigned i;
330
331 for (i = 0; i < piolist->nr; ++i) {
332 memory_region_set_enabled(piolist->regions[i], enabled);
333 }
334 }
335
portio_list_set_address(PortioList * piolist,uint32_t addr)336 void portio_list_set_address(PortioList *piolist, uint32_t addr)
337 {
338 MemoryRegionPortioList *mrpio;
339 unsigned i, j;
340
341 for (i = 0; i < piolist->nr; ++i) {
342 mrpio = container_of(piolist->regions[i], MemoryRegionPortioList, mr);
343 memory_region_set_address(&mrpio->mr,
344 mrpio->mr.addr - piolist->addr + addr);
345 for (j = 0; mrpio->ports[j].size; ++j) {
346 mrpio->ports[j].offset += addr - piolist->addr;
347 }
348 }
349
350 piolist->addr = addr;
351 }
352
memory_region_portio_list_finalize(Object * obj)353 static void memory_region_portio_list_finalize(Object *obj)
354 {
355 MemoryRegionPortioList *mrpio = MEMORY_REGION_PORTIO_LIST(obj);
356
357 object_unref(&mrpio->mr);
358 g_free(mrpio->ports);
359 }
360
361 static const TypeInfo memory_region_portio_list_info = {
362 .parent = TYPE_OBJECT,
363 .name = TYPE_MEMORY_REGION_PORTIO_LIST,
364 .instance_size = sizeof(MemoryRegionPortioList),
365 .instance_finalize = memory_region_portio_list_finalize,
366 };
367
ioport_register_types(void)368 static void ioport_register_types(void)
369 {
370 type_register_static(&memory_region_portio_list_info);
371 }
372
373 type_init(ioport_register_types)
374