[qemu.git] / ioport.c

/*
 * QEMU System Emulator
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
/*
 * splitted out ioport related stuffs from vl.c.
 */

#include "ioport.h"
#include "trace.h"

/***********************************************************/
/* IO Port */

//#define DEBUG_UNUSED_IOPORT
//#define DEBUG_IOPORT

#ifdef DEBUG_UNUSED_IOPORT
#  define LOG_UNUSED_IOPORT(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
#else
#  define LOG_UNUSED_IOPORT(fmt, ...) do{ } while (0)
#endif

#ifdef DEBUG_IOPORT
#  define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
#else
#  define LOG_IOPORT(...) do { } while (0)
#endif

/* XXX: use a two level table to limit memory usage */

static void *ioport_opaque[MAX_IOPORTS];
static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];

static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;

static uint32_t ioport_read(int index, uint32_t address)
{
    static IOPortReadFunc * const default_func[3] = {
        default_ioport_readb,
        default_ioport_readw,
        default_ioport_readl
    };
    IOPortReadFunc *func = ioport_read_table[index][address];
    if (!func)
        func = default_func[index];
    return func(ioport_opaque[address], address);
}

static void ioport_write(int index, uint32_t address, uint32_t data)
{
    static IOPortWriteFunc * const default_func[3] = {
        default_ioport_writeb,
        default_ioport_writew,
        default_ioport_writel
    };
    IOPortWriteFunc *func = ioport_write_table[index][address];
    if (!func)
        func = default_func[index];
    func(ioport_opaque[address], address, data);
}

static uint32_t default_ioport_readb(void *opaque, uint32_t address)
{
    LOG_UNUSED_IOPORT("unused inb: port=0x%04"PRIx32"\n", address);
    return 0xff;
}

static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
{
    LOG_UNUSED_IOPORT("unused outb: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
                      address, data);
}

/* default is to make two byte accesses */
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
{
    uint32_t data;
    data = ioport_read(0, address);
    address = (address + 1) & IOPORTS_MASK;
    data |= ioport_read(0, address) << 8;
    return data;
}

static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
{
    ioport_write(0, address, data & 0xff);
    address = (address + 1) & IOPORTS_MASK;
    ioport_write(0, address, (data >> 8) & 0xff);
}

static uint32_t default_ioport_readl(void *opaque, uint32_t address)
{
    LOG_UNUSED_IOPORT("unused inl: port=0x%04"PRIx32"\n", address);
    return 0xffffffff;
}

static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
{
    LOG_UNUSED_IOPORT("unused outl: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
                      address, data);
}

static int ioport_bsize(int size, int *bsize)
{
    if (size == 1) {
        *bsize = 0;
    } else if (size == 2) {
        *bsize = 1;
    } else if (size == 4) {
        *bsize = 2;
    } else {
        return -1;
    }
    return 0;
}

/* size is the word size in byte */
int register_ioport_read(pio_addr_t start, int length, int size,
                         IOPortReadFunc *func, void *opaque)
{
    int i, bsize;

    if (ioport_bsize(size, &bsize)) {
        hw_error("register_ioport_read: invalid size");
        return -1;
    }
    for(i = start; i < start + length; i += size) {
        ioport_read_table[bsize][i] = func;
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
            hw_error("register_ioport_read: invalid opaque");
        ioport_opaque[i] = opaque;
    }
    return 0;
}

/* size is the word size in byte */
int register_ioport_write(pio_addr_t start, int length, int size,
                          IOPortWriteFunc *func, void *opaque)
{
    int i, bsize;

    if (ioport_bsize(size, &bsize)) {
        hw_error("register_ioport_write: invalid size");
        return -1;
    }
    for(i = start; i < start + length; i += size) {
        ioport_write_table[bsize][i] = func;
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
            hw_error("register_ioport_write: invalid opaque");
        ioport_opaque[i] = opaque;
    }
    return 0;
}

static uint32_t ioport_readb_thunk(void *opaque, uint32_t addr)
{
    IORange *ioport = opaque;
    uint64_t data;

    ioport->ops->read(ioport, addr - ioport->base, 1, &data);
    return data;
}

static uint32_t ioport_readw_thunk(void *opaque, uint32_t addr)
{
    IORange *ioport = opaque;
    uint64_t data;

    ioport->ops->read(ioport, addr - ioport->base, 2, &data);
    return data;
}

static uint32_t ioport_readl_thunk(void *opaque, uint32_t addr)
{
    IORange *ioport = opaque;
    uint64_t data;

    ioport->ops->read(ioport, addr - ioport->base, 4, &data);
    return data;
}

static void ioport_writeb_thunk(void *opaque, uint32_t addr, uint32_t data)
{
    IORange *ioport = opaque;

    ioport->ops->write(ioport, addr - ioport->base, 1, data);
}

static void ioport_writew_thunk(void *opaque, uint32_t addr, uint32_t data)
{
    IORange *ioport = opaque;

    ioport->ops->write(ioport, addr - ioport->base, 2, data);
}

static void ioport_writel_thunk(void *opaque, uint32_t addr, uint32_t data)
{
    IORange *ioport = opaque;

    ioport->ops->write(ioport, addr - ioport->base, 4, data);
}

void ioport_register(IORange *ioport)
{
    register_ioport_read(ioport->base, ioport->len, 1,
                         ioport_readb_thunk, ioport);
    register_ioport_read(ioport->base, ioport->len, 2,
                         ioport_readw_thunk, ioport);
    register_ioport_read(ioport->base, ioport->len, 4,
                         ioport_readl_thunk, ioport);
    register_ioport_write(ioport->base, ioport->len, 1,
                          ioport_writeb_thunk, ioport);
    register_ioport_write(ioport->base, ioport->len, 2,
                          ioport_writew_thunk, ioport);
    register_ioport_write(ioport->base, ioport->len, 4,
                          ioport_writel_thunk, ioport);
}

void isa_unassign_ioport(pio_addr_t start, int length)
{
    int i;

    for(i = start; i < start + length; i++) {
        ioport_read_table[0][i] = default_ioport_readb;
        ioport_read_table[1][i] = default_ioport_readw;
        ioport_read_table[2][i] = default_ioport_readl;

        ioport_write_table[0][i] = default_ioport_writeb;
        ioport_write_table[1][i] = default_ioport_writew;
        ioport_write_table[2][i] = default_ioport_writel;

        ioport_opaque[i] = NULL;
    }
}

/***********************************************************/

void cpu_outb(pio_addr_t addr, uint8_t val)
{
    LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
    trace_cpu_out(addr, val);
    ioport_write(0, addr, val);
}

void cpu_outw(pio_addr_t addr, uint16_t val)
{
    LOG_IOPORT("outw: %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
    trace_cpu_out(addr, val);
    ioport_write(1, addr, val);
}

void cpu_outl(pio_addr_t addr, uint32_t val)
{
    LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
    trace_cpu_out(addr, val);
    ioport_write(2, addr, val);
}

uint8_t cpu_inb(pio_addr_t addr)
{
    uint8_t val;
    val = ioport_read(0, addr);
    trace_cpu_in(addr, val);
    LOG_IOPORT("inb : %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
    return val;
}

uint16_t cpu_inw(pio_addr_t addr)
{
    uint16_t val;
    val = ioport_read(1, addr);
    trace_cpu_in(addr, val);
    LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
    return val;
}

uint32_t cpu_inl(pio_addr_t addr)
{
    uint32_t val;
    val = ioport_read(2, addr);
    trace_cpu_in(addr, val);
    LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
    return val;
}
Commit	Line	Data
32993977 IY	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	* splitted out ioport related stuffs from vl.c.
	26	*/
	27
	28	#include "ioport.h"
bd3c9aa5	29	#include "trace.h"
32993977 IY	30
	31	/***********************************************************/
	32	/* IO Port */
	33
	34	//#define DEBUG_UNUSED_IOPORT
	35	//#define DEBUG_IOPORT
	36
fc7083b5 IY	37	#ifdef DEBUG_UNUSED_IOPORT
	38	# define LOG_UNUSED_IOPORT(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
	39	#else
	40	# define LOG_UNUSED_IOPORT(fmt, ...) do{ } while (0)
	41	#endif
	42
32993977 IY	43	#ifdef DEBUG_IOPORT
	44	# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
	45	#else
	46	# define LOG_IOPORT(...) do { } while (0)
	47	#endif
	48
	49	/* XXX: use a two level table to limit memory usage */
	50
	51	static void *ioport_opaque[MAX_IOPORTS];
	52	static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
	53	static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
	54
	55	static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
	56	static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
	57
	58	static uint32_t ioport_read(int index, uint32_t address)
	59	{
1dde6fcc	60	static IOPortReadFunc * const default_func[3] = {
32993977 IY	61	default_ioport_readb,
	62	default_ioport_readw,
	63	default_ioport_readl
	64	};
	65	IOPortReadFunc *func = ioport_read_table[index][address];
	66	if (!func)
	67	func = default_func[index];
	68	return func(ioport_opaque[address], address);
	69	}
	70
	71	static void ioport_write(int index, uint32_t address, uint32_t data)
	72	{
1dde6fcc	73	static IOPortWriteFunc * const default_func[3] = {
32993977 IY	74	default_ioport_writeb,
	75	default_ioport_writew,
	76	default_ioport_writel
	77	};
	78	IOPortWriteFunc *func = ioport_write_table[index][address];
	79	if (!func)
	80	func = default_func[index];
	81	func(ioport_opaque[address], address, data);
	82	}
	83
	84	static uint32_t default_ioport_readb(void *opaque, uint32_t address)
	85	{
fc7083b5	86	LOG_UNUSED_IOPORT("unused inb: port=0x%04"PRIx32"\n", address);
32993977 IY	87	return 0xff;
	88	}
	89
	90	static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
	91	{
fc7083b5 IY	92	LOG_UNUSED_IOPORT("unused outb: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
fc7083b5 IY	93	address, data);
32993977 IY	94	}
	95
	96	/* default is to make two byte accesses */
	97	static uint32_t default_ioport_readw(void *opaque, uint32_t address)
	98	{
	99	uint32_t data;
	100	data = ioport_read(0, address);
d56dd6cf	101	address = (address + 1) & IOPORTS_MASK;
32993977 IY	102	data \|= ioport_read(0, address) << 8;
	103	return data;
	104	}
	105
	106	static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
	107	{
	108	ioport_write(0, address, data & 0xff);
d56dd6cf	109	address = (address + 1) & IOPORTS_MASK;
32993977 IY	110	ioport_write(0, address, (data >> 8) & 0xff);
	111	}
	112
	113	static uint32_t default_ioport_readl(void *opaque, uint32_t address)
	114	{
fc7083b5	115	LOG_UNUSED_IOPORT("unused inl: port=0x%04"PRIx32"\n", address);
32993977 IY	116	return 0xffffffff;
	117	}
	118
	119	static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
	120	{
fc7083b5 IY	121	LOG_UNUSED_IOPORT("unused outl: port=0x%04"PRIx32" data=0x%02"PRIx32"\n",
fc7083b5 IY	122	address, data);
32993977 IY	123	}
32993977 IY	124
23e0affd IY	125	static int ioport_bsize(int size, int *bsize)
	126	{
	127	if (size == 1) {
	128	*bsize = 0;
	129	} else if (size == 2) {
	130	*bsize = 1;
	131	} else if (size == 4) {
	132	*bsize = 2;
	133	} else {
	134	return -1;
	135	}
	136	return 0;
	137	}
	138
32993977	139	/* size is the word size in byte */
c227f099	140	int register_ioport_read(pio_addr_t start, int length, int size,
32993977 IY	141	IOPortReadFunc func, void opaque)
	142	{
	143	int i, bsize;
	144
23e0affd	145	if (ioport_bsize(size, &bsize)) {
32993977 IY	146	hw_error("register_ioport_read: invalid size");
	147	return -1;
	148	}
	149	for(i = start; i < start + length; i += size) {
	150	ioport_read_table[bsize][i] = func;
	151	if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
	152	hw_error("register_ioport_read: invalid opaque");
	153	ioport_opaque[i] = opaque;
	154	}
	155	return 0;
	156	}
	157
	158	/* size is the word size in byte */
c227f099	159	int register_ioport_write(pio_addr_t start, int length, int size,
32993977 IY	160	IOPortWriteFunc func, void opaque)
	161	{
	162	int i, bsize;
	163
23e0affd	164	if (ioport_bsize(size, &bsize)) {
32993977 IY	165	hw_error("register_ioport_write: invalid size");
	166	return -1;
	167	}
	168	for(i = start; i < start + length; i += size) {
	169	ioport_write_table[bsize][i] = func;
	170	if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
	171	hw_error("register_ioport_write: invalid opaque");
	172	ioport_opaque[i] = opaque;
	173	}
	174	return 0;
	175	}
	176
acd1c812 AK	177	static uint32_t ioport_readb_thunk(void *opaque, uint32_t addr)
	178	{
	179	IORange *ioport = opaque;
	180	uint64_t data;
	181
	182	ioport->ops->read(ioport, addr - ioport->base, 1, &data);
	183	return data;
	184	}
	185
	186	static uint32_t ioport_readw_thunk(void *opaque, uint32_t addr)
	187	{
	188	IORange *ioport = opaque;
	189	uint64_t data;
	190
	191	ioport->ops->read(ioport, addr - ioport->base, 2, &data);
	192	return data;
	193	}
	194
	195	static uint32_t ioport_readl_thunk(void *opaque, uint32_t addr)
	196	{
	197	IORange *ioport = opaque;
	198	uint64_t data;
	199
	200	ioport->ops->read(ioport, addr - ioport->base, 4, &data);
	201	return data;
	202	}
	203
	204	static void ioport_writeb_thunk(void *opaque, uint32_t addr, uint32_t data)
	205	{
	206	IORange *ioport = opaque;
	207
	208	ioport->ops->write(ioport, addr - ioport->base, 1, data);
	209	}
	210
	211	static void ioport_writew_thunk(void *opaque, uint32_t addr, uint32_t data)
	212	{
	213	IORange *ioport = opaque;
	214
	215	ioport->ops->write(ioport, addr - ioport->base, 2, data);
	216	}
	217
	218	static void ioport_writel_thunk(void *opaque, uint32_t addr, uint32_t data)
	219	{
	220	IORange *ioport = opaque;
	221
	222	ioport->ops->write(ioport, addr - ioport->base, 4, data);
	223	}
	224
	225	void ioport_register(IORange *ioport)
	226	{
	227	register_ioport_read(ioport->base, ioport->len, 1,
	228	ioport_readb_thunk, ioport);
	229	register_ioport_read(ioport->base, ioport->len, 2,
	230	ioport_readw_thunk, ioport);
	231	register_ioport_read(ioport->base, ioport->len, 4,
	232	ioport_readl_thunk, ioport);
	233	register_ioport_write(ioport->base, ioport->len, 1,
	234	ioport_writeb_thunk, ioport);
	235	register_ioport_write(ioport->base, ioport->len, 2,
	236	ioport_writew_thunk, ioport);
	237	register_ioport_write(ioport->base, ioport->len, 4,
	238	ioport_writel_thunk, ioport);
	239	}
	240
c227f099	241	void isa_unassign_ioport(pio_addr_t start, int length)
32993977 IY	242	{
	243	int i;
	244
	245	for(i = start; i < start + length; i++) {
	246	ioport_read_table[0][i] = default_ioport_readb;
	247	ioport_read_table[1][i] = default_ioport_readw;
	248	ioport_read_table[2][i] = default_ioport_readl;
	249
	250	ioport_write_table[0][i] = default_ioport_writeb;
	251	ioport_write_table[1][i] = default_ioport_writew;
	252	ioport_write_table[2][i] = default_ioport_writel;
	253
	254	ioport_opaque[i] = NULL;
	255	}
	256	}
	257
	258	/***********************************************************/
	259
c227f099	260	void cpu_outb(pio_addr_t addr, uint8_t val)
32993977	261	{
07323531	262	LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
bd3c9aa5	263	trace_cpu_out(addr, val);
32993977	264	ioport_write(0, addr, val);
32993977 IY	265	}
32993977 IY	266
c227f099	267	void cpu_outw(pio_addr_t addr, uint16_t val)
32993977	268	{
07323531	269	LOG_IOPORT("outw: %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
bd3c9aa5	270	trace_cpu_out(addr, val);
32993977	271	ioport_write(1, addr, val);
32993977 IY	272	}
32993977 IY	273
c227f099	274	void cpu_outl(pio_addr_t addr, uint32_t val)
32993977	275	{
07323531	276	LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
bd3c9aa5	277	trace_cpu_out(addr, val);
32993977	278	ioport_write(2, addr, val);
32993977 IY	279	}
32993977 IY	280
c227f099	281	uint8_t cpu_inb(pio_addr_t addr)
32993977	282	{
07323531	283	uint8_t val;
32993977	284	val = ioport_read(0, addr);
bd3c9aa5	285	trace_cpu_in(addr, val);
07323531	286	LOG_IOPORT("inb : %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
32993977 IY	287	return val;
	288	}
	289
c227f099	290	uint16_t cpu_inw(pio_addr_t addr)
32993977	291	{
07323531	292	uint16_t val;
32993977	293	val = ioport_read(1, addr);
bd3c9aa5	294	trace_cpu_in(addr, val);
07323531	295	LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
32993977 IY	296	return val;
	297	}
	298
c227f099	299	uint32_t cpu_inl(pio_addr_t addr)
32993977	300	{
07323531	301	uint32_t val;
32993977	302	val = ioport_read(2, addr);
bd3c9aa5	303	trace_cpu_in(addr, val);
07323531	304	LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
32993977 IY	305	return val;
32993977 IY	306	}