blob: 6e4ca0dd9115c22fd3abd09980ecdfbef4f38178 [file] [log] [blame]
Isaku Yamahata32993972009-07-02 19:32:06 +09001/*
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 * splitted out ioport related stuffs from vl.c.
26 */
27
28#include "ioport.h"
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +053029#include "trace.h"
Avi Kivity6bf9fd42011-09-26 14:52:26 +030030#include "memory.h"
Isaku Yamahata32993972009-07-02 19:32:06 +090031
32/***********************************************************/
33/* IO Port */
34
35//#define DEBUG_UNUSED_IOPORT
36//#define DEBUG_IOPORT
37
Isaku Yamahatafc7083b2009-07-14 19:10:42 +090038#ifdef DEBUG_UNUSED_IOPORT
39# define LOG_UNUSED_IOPORT(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
40#else
41# define LOG_UNUSED_IOPORT(fmt, ...) do{ } while (0)
42#endif
43
Isaku Yamahata32993972009-07-02 19:32:06 +090044#ifdef DEBUG_IOPORT
45# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
46#else
47# define LOG_IOPORT(...) do { } while (0)
48#endif
49
50/* XXX: use a two level table to limit memory usage */
51
52static void *ioport_opaque[MAX_IOPORTS];
53static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
54static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
Avi Kivityc5b703a2012-03-05 17:36:19 +020055static IOPortDestructor *ioport_destructor_table[MAX_IOPORTS];
Isaku Yamahata32993972009-07-02 19:32:06 +090056
57static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
58static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
59
60static uint32_t ioport_read(int index, uint32_t address)
61{
Blue Swirl1dde6fc2009-09-06 16:32:13 +000062 static IOPortReadFunc * const default_func[3] = {
Isaku Yamahata32993972009-07-02 19:32:06 +090063 default_ioport_readb,
64 default_ioport_readw,
65 default_ioport_readl
66 };
67 IOPortReadFunc *func = ioport_read_table[index][address];
68 if (!func)
69 func = default_func[index];
70 return func(ioport_opaque[address], address);
71}
72
73static void ioport_write(int index, uint32_t address, uint32_t data)
74{
Blue Swirl1dde6fc2009-09-06 16:32:13 +000075 static IOPortWriteFunc * const default_func[3] = {
Isaku Yamahata32993972009-07-02 19:32:06 +090076 default_ioport_writeb,
77 default_ioport_writew,
78 default_ioport_writel
79 };
80 IOPortWriteFunc *func = ioport_write_table[index][address];
81 if (!func)
82 func = default_func[index];
83 func(ioport_opaque[address], address, data);
84}
85
86static uint32_t default_ioport_readb(void *opaque, uint32_t address)
87{
Isaku Yamahatafc7083b2009-07-14 19:10:42 +090088 LOG_UNUSED_IOPORT("unused inb: port=0x%04"PRIx32"\n", address);
Isaku Yamahata32993972009-07-02 19:32:06 +090089 return 0xff;
90}
91
92static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
93{
Isaku Yamahatafc7083b2009-07-14 19:10:42 +090094 LOG_UNUSED_IOPORT("unused outb: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
95 address, data);
Isaku Yamahata32993972009-07-02 19:32:06 +090096}
97
98/* default is to make two byte accesses */
99static uint32_t default_ioport_readw(void *opaque, uint32_t address)
100{
101 uint32_t data;
102 data = ioport_read(0, address);
Isaku Yamahatad56dd6c2009-07-02 19:32:07 +0900103 address = (address + 1) & IOPORTS_MASK;
Isaku Yamahata32993972009-07-02 19:32:06 +0900104 data |= ioport_read(0, address) << 8;
105 return data;
106}
107
108static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
109{
110 ioport_write(0, address, data & 0xff);
Isaku Yamahatad56dd6c2009-07-02 19:32:07 +0900111 address = (address + 1) & IOPORTS_MASK;
Isaku Yamahata32993972009-07-02 19:32:06 +0900112 ioport_write(0, address, (data >> 8) & 0xff);
113}
114
115static uint32_t default_ioport_readl(void *opaque, uint32_t address)
116{
Isaku Yamahatafc7083b2009-07-14 19:10:42 +0900117 LOG_UNUSED_IOPORT("unused inl: port=0x%04"PRIx32"\n", address);
Isaku Yamahata32993972009-07-02 19:32:06 +0900118 return 0xffffffff;
119}
120
121static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
122{
Isaku Yamahatafc7083b2009-07-14 19:10:42 +0900123 LOG_UNUSED_IOPORT("unused outl: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
124 address, data);
Isaku Yamahata32993972009-07-02 19:32:06 +0900125}
126
Isaku Yamahata23e0aff2009-07-02 19:32:08 +0900127static int ioport_bsize(int size, int *bsize)
128{
129 if (size == 1) {
130 *bsize = 0;
131 } else if (size == 2) {
132 *bsize = 1;
133 } else if (size == 4) {
134 *bsize = 2;
135 } else {
136 return -1;
137 }
138 return 0;
139}
140
Isaku Yamahata32993972009-07-02 19:32:06 +0900141/* size is the word size in byte */
Anthony Liguoric227f092009-10-01 16:12:16 -0500142int register_ioport_read(pio_addr_t start, int length, int size,
Isaku Yamahata32993972009-07-02 19:32:06 +0900143 IOPortReadFunc *func, void *opaque)
144{
145 int i, bsize;
146
Isaku Yamahata23e0aff2009-07-02 19:32:08 +0900147 if (ioport_bsize(size, &bsize)) {
Isaku Yamahata32993972009-07-02 19:32:06 +0900148 hw_error("register_ioport_read: invalid size");
149 return -1;
150 }
Avi Kivitybf3fb0e2011-07-26 14:26:15 +0300151 for(i = start; i < start + length; ++i) {
Isaku Yamahata32993972009-07-02 19:32:06 +0900152 ioport_read_table[bsize][i] = func;
153 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
Andreas Färberf66a99d2011-03-06 15:48:13 +0100154 hw_error("register_ioport_read: invalid opaque for address 0x%x",
155 i);
Isaku Yamahata32993972009-07-02 19:32:06 +0900156 ioport_opaque[i] = opaque;
157 }
158 return 0;
159}
160
161/* size is the word size in byte */
Anthony Liguoric227f092009-10-01 16:12:16 -0500162int register_ioport_write(pio_addr_t start, int length, int size,
Isaku Yamahata32993972009-07-02 19:32:06 +0900163 IOPortWriteFunc *func, void *opaque)
164{
165 int i, bsize;
166
Isaku Yamahata23e0aff2009-07-02 19:32:08 +0900167 if (ioport_bsize(size, &bsize)) {
Isaku Yamahata32993972009-07-02 19:32:06 +0900168 hw_error("register_ioport_write: invalid size");
169 return -1;
170 }
Avi Kivitybf3fb0e2011-07-26 14:26:15 +0300171 for(i = start; i < start + length; ++i) {
Isaku Yamahata32993972009-07-02 19:32:06 +0900172 ioport_write_table[bsize][i] = func;
173 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
Andreas Färberf66a99d2011-03-06 15:48:13 +0100174 hw_error("register_ioport_write: invalid opaque for address 0x%x",
175 i);
Isaku Yamahata32993972009-07-02 19:32:06 +0900176 ioport_opaque[i] = opaque;
177 }
178 return 0;
179}
180
Avi Kivityacd1c812010-11-17 11:50:09 +0200181static uint32_t ioport_readb_thunk(void *opaque, uint32_t addr)
182{
183 IORange *ioport = opaque;
184 uint64_t data;
185
186 ioport->ops->read(ioport, addr - ioport->base, 1, &data);
187 return data;
188}
189
190static uint32_t ioport_readw_thunk(void *opaque, uint32_t addr)
191{
192 IORange *ioport = opaque;
193 uint64_t data;
194
195 ioport->ops->read(ioport, addr - ioport->base, 2, &data);
196 return data;
197}
198
199static uint32_t ioport_readl_thunk(void *opaque, uint32_t addr)
200{
201 IORange *ioport = opaque;
202 uint64_t data;
203
204 ioport->ops->read(ioport, addr - ioport->base, 4, &data);
205 return data;
206}
207
208static void ioport_writeb_thunk(void *opaque, uint32_t addr, uint32_t data)
209{
210 IORange *ioport = opaque;
211
212 ioport->ops->write(ioport, addr - ioport->base, 1, data);
213}
214
215static void ioport_writew_thunk(void *opaque, uint32_t addr, uint32_t data)
216{
217 IORange *ioport = opaque;
218
219 ioport->ops->write(ioport, addr - ioport->base, 2, data);
220}
221
222static void ioport_writel_thunk(void *opaque, uint32_t addr, uint32_t data)
223{
224 IORange *ioport = opaque;
225
226 ioport->ops->write(ioport, addr - ioport->base, 4, data);
227}
228
Avi Kivityc5b703a2012-03-05 17:36:19 +0200229static void iorange_destructor_thunk(void *opaque)
230{
231 IORange *iorange = opaque;
232
233 if (iorange->ops->destructor) {
234 iorange->ops->destructor(iorange);
235 }
236}
237
Avi Kivityacd1c812010-11-17 11:50:09 +0200238void ioport_register(IORange *ioport)
239{
240 register_ioport_read(ioport->base, ioport->len, 1,
241 ioport_readb_thunk, ioport);
242 register_ioport_read(ioport->base, ioport->len, 2,
243 ioport_readw_thunk, ioport);
244 register_ioport_read(ioport->base, ioport->len, 4,
245 ioport_readl_thunk, ioport);
246 register_ioport_write(ioport->base, ioport->len, 1,
247 ioport_writeb_thunk, ioport);
248 register_ioport_write(ioport->base, ioport->len, 2,
249 ioport_writew_thunk, ioport);
250 register_ioport_write(ioport->base, ioport->len, 4,
251 ioport_writel_thunk, ioport);
Avi Kivityc5b703a2012-03-05 17:36:19 +0200252 ioport_destructor_table[ioport->base] = iorange_destructor_thunk;
Avi Kivityacd1c812010-11-17 11:50:09 +0200253}
254
Anthony Liguoric227f092009-10-01 16:12:16 -0500255void isa_unassign_ioport(pio_addr_t start, int length)
Isaku Yamahata32993972009-07-02 19:32:06 +0900256{
257 int i;
258
Avi Kivityc5b703a2012-03-05 17:36:19 +0200259 if (ioport_destructor_table[start]) {
260 ioport_destructor_table[start](ioport_opaque[start]);
261 ioport_destructor_table[start] = NULL;
262 }
Isaku Yamahata32993972009-07-02 19:32:06 +0900263 for(i = start; i < start + length; i++) {
Paolo Bonzini6141dbf2011-07-15 17:10:15 +0200264 ioport_read_table[0][i] = NULL;
265 ioport_read_table[1][i] = NULL;
266 ioport_read_table[2][i] = NULL;
Isaku Yamahata32993972009-07-02 19:32:06 +0900267
Paolo Bonzini6141dbf2011-07-15 17:10:15 +0200268 ioport_write_table[0][i] = NULL;
269 ioport_write_table[1][i] = NULL;
270 ioport_write_table[2][i] = NULL;
Isaku Yamahata32993972009-07-02 19:32:06 +0900271
272 ioport_opaque[i] = NULL;
273 }
274}
275
Paolo Bonzini6141dbf2011-07-15 17:10:15 +0200276bool isa_is_ioport_assigned(pio_addr_t start)
277{
278 return (ioport_read_table[0][start] || ioport_write_table[0][start] ||
279 ioport_read_table[1][start] || ioport_write_table[1][start] ||
280 ioport_read_table[2][start] || ioport_write_table[2][start]);
281}
282
Isaku Yamahata32993972009-07-02 19:32:06 +0900283/***********************************************************/
284
Anthony Liguoric227f092009-10-01 16:12:16 -0500285void cpu_outb(pio_addr_t addr, uint8_t val)
Isaku Yamahata32993972009-07-02 19:32:06 +0900286{
Isaku Yamahata07323532009-07-14 19:10:43 +0900287 LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530288 trace_cpu_out(addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900289 ioport_write(0, addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900290}
291
Anthony Liguoric227f092009-10-01 16:12:16 -0500292void cpu_outw(pio_addr_t addr, uint16_t val)
Isaku Yamahata32993972009-07-02 19:32:06 +0900293{
Isaku Yamahata07323532009-07-14 19:10:43 +0900294 LOG_IOPORT("outw: %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530295 trace_cpu_out(addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900296 ioport_write(1, addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900297}
298
Anthony Liguoric227f092009-10-01 16:12:16 -0500299void cpu_outl(pio_addr_t addr, uint32_t val)
Isaku Yamahata32993972009-07-02 19:32:06 +0900300{
Isaku Yamahata07323532009-07-14 19:10:43 +0900301 LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530302 trace_cpu_out(addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900303 ioport_write(2, addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900304}
305
Anthony Liguoric227f092009-10-01 16:12:16 -0500306uint8_t cpu_inb(pio_addr_t addr)
Isaku Yamahata32993972009-07-02 19:32:06 +0900307{
Isaku Yamahata07323532009-07-14 19:10:43 +0900308 uint8_t val;
Isaku Yamahata32993972009-07-02 19:32:06 +0900309 val = ioport_read(0, addr);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530310 trace_cpu_in(addr, val);
Isaku Yamahata07323532009-07-14 19:10:43 +0900311 LOG_IOPORT("inb : %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900312 return val;
313}
314
Anthony Liguoric227f092009-10-01 16:12:16 -0500315uint16_t cpu_inw(pio_addr_t addr)
Isaku Yamahata32993972009-07-02 19:32:06 +0900316{
Isaku Yamahata07323532009-07-14 19:10:43 +0900317 uint16_t val;
Isaku Yamahata32993972009-07-02 19:32:06 +0900318 val = ioport_read(1, addr);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530319 trace_cpu_in(addr, val);
Isaku Yamahata07323532009-07-14 19:10:43 +0900320 LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900321 return val;
322}
323
Anthony Liguoric227f092009-10-01 16:12:16 -0500324uint32_t cpu_inl(pio_addr_t addr)
Isaku Yamahata32993972009-07-02 19:32:06 +0900325{
Isaku Yamahata07323532009-07-14 19:10:43 +0900326 uint32_t val;
Isaku Yamahata32993972009-07-02 19:32:06 +0900327 val = ioport_read(2, addr);
Prerna Saxenabd3c9aa2010-08-11 17:15:11 +0530328 trace_cpu_in(addr, val);
Isaku Yamahata07323532009-07-14 19:10:43 +0900329 LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
Isaku Yamahata32993972009-07-02 19:32:06 +0900330 return val;
331}
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300332
333void portio_list_init(PortioList *piolist,
334 const MemoryRegionPortio *callbacks,
335 void *opaque, const char *name)
336{
337 unsigned n = 0;
338
339 while (callbacks[n].size) {
340 ++n;
341 }
342
343 piolist->ports = callbacks;
344 piolist->nr = 0;
345 piolist->regions = g_new0(MemoryRegion *, n);
Avi Kivityde58ac72012-01-08 19:46:17 +0200346 piolist->aliases = g_new0(MemoryRegion *, n);
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300347 piolist->address_space = NULL;
348 piolist->opaque = opaque;
349 piolist->name = name;
350}
351
352void portio_list_destroy(PortioList *piolist)
353{
354 g_free(piolist->regions);
Avi Kivityde58ac72012-01-08 19:46:17 +0200355 g_free(piolist->aliases);
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300356}
357
358static void portio_list_add_1(PortioList *piolist,
359 const MemoryRegionPortio *pio_init,
360 unsigned count, unsigned start,
361 unsigned off_low, unsigned off_high)
362{
363 MemoryRegionPortio *pio;
364 MemoryRegionOps *ops;
Avi Kivityde58ac72012-01-08 19:46:17 +0200365 MemoryRegion *region, *alias;
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300366 unsigned i;
367
368 /* Copy the sub-list and null-terminate it. */
369 pio = g_new(MemoryRegionPortio, count + 1);
370 memcpy(pio, pio_init, sizeof(MemoryRegionPortio) * count);
371 memset(pio + count, 0, sizeof(MemoryRegionPortio));
372
373 /* Adjust the offsets to all be zero-based for the region. */
374 for (i = 0; i < count; ++i) {
375 pio[i].offset -= off_low;
376 }
377
378 ops = g_new0(MemoryRegionOps, 1);
379 ops->old_portio = pio;
380
381 region = g_new(MemoryRegion, 1);
Avi Kivityde58ac72012-01-08 19:46:17 +0200382 alias = g_new(MemoryRegion, 1);
383 /*
384 * Use an alias so that the callback is called with an absolute address,
385 * rather than an offset relative to to start + off_low.
386 */
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300387 memory_region_init_io(region, ops, piolist->opaque, piolist->name,
Blue Swirl42008722012-03-10 16:57:10 +0000388 INT64_MAX);
Avi Kivityde58ac72012-01-08 19:46:17 +0200389 memory_region_init_alias(alias, piolist->name,
390 region, start + off_low, off_high - off_low);
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300391 memory_region_add_subregion(piolist->address_space,
Avi Kivityde58ac72012-01-08 19:46:17 +0200392 start + off_low, alias);
393 piolist->regions[piolist->nr] = region;
394 piolist->aliases[piolist->nr] = alias;
395 ++piolist->nr;
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300396}
397
398void portio_list_add(PortioList *piolist,
399 MemoryRegion *address_space,
400 uint32_t start)
401{
402 const MemoryRegionPortio *pio, *pio_start = piolist->ports;
403 unsigned int off_low, off_high, off_last, count;
404
405 piolist->address_space = address_space;
406
407 /* Handle the first entry specially. */
408 off_last = off_low = pio_start->offset;
409 off_high = off_low + pio_start->len;
410 count = 1;
411
412 for (pio = pio_start + 1; pio->size != 0; pio++, count++) {
413 /* All entries must be sorted by offset. */
414 assert(pio->offset >= off_last);
415 off_last = pio->offset;
416
417 /* If we see a hole, break the region. */
418 if (off_last > off_high) {
419 portio_list_add_1(piolist, pio_start, count, start, off_low,
420 off_high);
421 /* ... and start collecting anew. */
422 pio_start = pio;
423 off_low = off_last;
424 off_high = off_low + pio->len;
425 count = 0;
426 } else if (off_last + pio->len > off_high) {
427 off_high = off_last + pio->len;
428 }
429 }
430
431 /* There will always be an open sub-list. */
432 portio_list_add_1(piolist, pio_start, count, start, off_low, off_high);
433}
434
435void portio_list_del(PortioList *piolist)
436{
Avi Kivityde58ac72012-01-08 19:46:17 +0200437 MemoryRegion *mr, *alias;
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300438 unsigned i;
439
440 for (i = 0; i < piolist->nr; ++i) {
441 mr = piolist->regions[i];
Avi Kivityde58ac72012-01-08 19:46:17 +0200442 alias = piolist->aliases[i];
443 memory_region_del_subregion(piolist->address_space, alias);
444 memory_region_destroy(alias);
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300445 memory_region_destroy(mr);
446 g_free((MemoryRegionOps *)mr->ops);
447 g_free(mr);
Avi Kivityde58ac72012-01-08 19:46:17 +0200448 g_free(alias);
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300449 piolist->regions[i] = NULL;
Avi Kivityde58ac72012-01-08 19:46:17 +0200450 piolist->aliases[i] = NULL;
Avi Kivity6bf9fd42011-09-26 14:52:26 +0300451 }
452}