Skip to content

Commit

Permalink
ioport: Remove unused old dispatching services
Browse files Browse the repository at this point in the history 
Remove unused ioport_register and isa_unassign_ioport along with
everything that only those services used.

Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
  • Loading branch information
@jan-kiszka @bonzini
jan-kiszka authored and bonzini committed Jul 4, 2013
1 parent b40acf9 commit 0659097
Show file tree
Hide file tree
Showing 4 changed files with 0 additions and 283 deletions.
5 changes: 0 additions & 5 deletions include/exec/ioport.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,6 @@
#define IOPORT_H

#include "qemu-common.h"
#include "exec/iorange.h"

typedef uint32_t pio_addr_t;
#define FMT_pioaddr PRIx32
Expand All @@ -36,10 +35,6 @@ typedef uint32_t pio_addr_t;
/* These should really be in isa.h, but are here to make pc.h happy. */
typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
typedef void (IOPortDestructor)(void *opaque);

void ioport_register(IORange *iorange);
void isa_unassign_ioport(pio_addr_t start, int length);

void cpu_outb(pio_addr_t addr, uint8_t val);
void cpu_outw(pio_addr_t addr, uint16_t val);
Expand Down
31 changes: 0 additions & 31 deletions include/exec/iorange.h
View file

This file was deleted.

9 changes: 0 additions & 9 deletions include/exec/memory.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,6 @@
#include "exec/hwaddr.h"
#endif
#include "qemu/queue.h"
#include "exec/iorange.h"
#include "exec/ioport.h"
#include "qemu/int128.h"
#include "qemu/notify.h"
Expand All @@ -48,14 +47,6 @@ struct MemoryRegionMmio {
CPUWriteMemoryFunc *write[3];
};

/* Internal use; thunks between old-style IORange and MemoryRegions. */
typedef struct MemoryRegionIORange MemoryRegionIORange;
struct MemoryRegionIORange {
IORange iorange;
MemoryRegion *mr;
hwaddr offset;
};

typedef struct IOMMUTLBEntry IOMMUTLBEntry;

/* See address_space_translate: bit 0 is read, bit 1 is write. */
Expand Down
238 changes: 0 additions & 238 deletions ioport.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,18 +30,8 @@
#include "exec/memory.h"
#include "exec/address-spaces.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
Expand All @@ -54,234 +44,6 @@ typedef struct MemoryRegionPortioList {
MemoryRegionPortio ports[];
} MemoryRegionPortioList;

/* 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 IOPortDestructor *ioport_destructor_table[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 */
static 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) {
ioport_read_table[bsize][i] = func;
if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
hw_error("register_ioport_read: invalid opaque for address 0x%x",
i);
ioport_opaque[i] = opaque;
}
return 0;
}

/* size is the word size in byte */
static 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) {
ioport_write_table[bsize][i] = func;
if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
hw_error("register_ioport_write: invalid opaque for address 0x%x",
i);
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);
}

static void iorange_destructor_thunk(void *opaque)
{
IORange *iorange = opaque;

if (iorange->ops->destructor) {
iorange->ops->destructor(iorange);
}
}

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);
ioport_destructor_table[ioport->base] = iorange_destructor_thunk;
}

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

if (ioport_destructor_table[start]) {
ioport_destructor_table[start](ioport_opaque[start]);
ioport_destructor_table[start] = NULL;
}
for(i = start; i < start + length; i++) {
ioport_read_table[0][i] = NULL;
ioport_read_table[1][i] = NULL;
ioport_read_table[2][i] = NULL;

ioport_write_table[0][i] = NULL;
ioport_write_table[1][i] = NULL;
ioport_write_table[2][i] = NULL;

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);
Expand Down

0 comments on commit 0659097

Please sign in to comment.