xref: /openbmc/qemu/system/ioport.c (revision 05caa062)
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"
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 
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 
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 
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 
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 
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 
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 
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 
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 
143 void portio_list_set_flush_coalesced(PortioList *piolist)
144 {
145     piolist->flush_coalesced_mmio = true;
146 }
147 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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