Revision 2091ba23
| b/hw/fdc.c | ||
|---|---|---|
| 1871 | 1871 |
} |
| 1872 | 1872 |
} |
| 1873 | 1873 |
|
| 1874 |
fdctrl_t *fdctrl_init (qemu_irq irq, int dma_chann, int mem_mapped,
|
|
| 1875 |
target_phys_addr_t io_base,
|
|
| 1876 |
BlockDriverState **fds) |
|
| 1874 |
fdctrl_t *fdctrl_init_isa(int isairq, int dma_chann,
|
|
| 1875 |
uint32_t io_base,
|
|
| 1876 |
BlockDriverState **fds)
|
|
| 1877 | 1877 |
{
|
| 1878 | 1878 |
fdctrl_t *fdctrl; |
| 1879 |
ISADevice *dev; |
|
| 1879 | 1880 |
|
| 1880 |
if (mem_mapped) {
|
|
| 1881 |
DeviceState *dev;
|
|
| 1882 |
fdctrl_sysbus_t *sys;
|
|
| 1881 |
dev = isa_create_simple("isa-fdc", io_base, 0);
|
|
| 1882 |
fdctrl = &(DO_UPCAST(fdctrl_isabus_t, busdev, dev)->state);
|
|
| 1883 |
isa_connect_irq(dev, 0, isairq);
|
|
| 1883 | 1884 |
|
| 1884 |
dev = qdev_create(NULL, "sysbus-fdc"); |
|
| 1885 |
qdev_init(dev); |
|
| 1886 |
sys = DO_UPCAST(fdctrl_sysbus_t, busdev.qdev, dev); |
|
| 1887 |
fdctrl = &sys->state; |
|
| 1888 |
sysbus_connect_irq(&sys->busdev, 0, irq); |
|
| 1889 |
sysbus_mmio_map(&sys->busdev, 0, io_base); |
|
| 1890 |
} else {
|
|
| 1891 |
ISADevice *dev; |
|
| 1885 |
fdctrl->dma_chann = dma_chann; |
|
| 1886 |
DMA_register_channel(dma_chann, &fdctrl_transfer_handler, fdctrl); |
|
| 1892 | 1887 |
|
| 1893 |
dev = isa_create_simple("isa-fdc", io_base, 0);
|
|
| 1894 |
fdctrl = &(DO_UPCAST(fdctrl_isabus_t, busdev, dev)->state); |
|
| 1895 |
isa_connect_irq(dev, 0, irq); |
|
| 1896 |
} |
|
| 1888 |
fdctrl_connect_drives(fdctrl, fds); |
|
| 1889 |
|
|
| 1890 |
return fdctrl; |
|
| 1891 |
} |
|
| 1892 |
|
|
| 1893 |
fdctrl_t *fdctrl_init_sysbus(qemu_irq irq, int dma_chann, |
|
| 1894 |
target_phys_addr_t mmio_base, |
|
| 1895 |
BlockDriverState **fds) |
|
| 1896 |
{
|
|
| 1897 |
fdctrl_t *fdctrl; |
|
| 1898 |
DeviceState *dev; |
|
| 1899 |
fdctrl_sysbus_t *sys; |
|
| 1900 |
|
|
| 1901 |
dev = qdev_create(NULL, "sysbus-fdc"); |
|
| 1902 |
qdev_init(dev); |
|
| 1903 |
sys = DO_UPCAST(fdctrl_sysbus_t, busdev.qdev, dev); |
|
| 1904 |
fdctrl = &sys->state; |
|
| 1905 |
sysbus_connect_irq(&sys->busdev, 0, irq); |
|
| 1906 |
sysbus_mmio_map(&sys->busdev, 0, mmio_base); |
|
| 1897 | 1907 |
|
| 1898 | 1908 |
fdctrl->dma_chann = dma_chann; |
| 1899 | 1909 |
DMA_register_channel(dma_chann, &fdctrl_transfer_handler, fdctrl); |
| 1900 |
|
|
| 1901 | 1910 |
fdctrl_connect_drives(fdctrl, fds); |
| 1902 | 1911 |
|
| 1903 | 1912 |
return fdctrl; |
| b/hw/fdc.h | ||
|---|---|---|
| 3 | 3 |
|
| 4 | 4 |
typedef struct fdctrl_t fdctrl_t; |
| 5 | 5 |
|
| 6 |
fdctrl_t *fdctrl_init (qemu_irq irq, int dma_chann, int mem_mapped, |
|
| 7 |
target_phys_addr_t io_base, |
|
| 8 |
BlockDriverState **fds); |
|
| 6 |
fdctrl_t *fdctrl_init_isa(int isairq, int dma_chann, |
|
| 7 |
uint32_t io_base, |
|
| 8 |
BlockDriverState **fds); |
|
| 9 |
fdctrl_t *fdctrl_init_sysbus(qemu_irq irq, int dma_chann, |
|
| 10 |
target_phys_addr_t mmio_base, |
|
| 11 |
BlockDriverState **fds); |
|
| 9 | 12 |
fdctrl_t *sun4m_fdctrl_init (qemu_irq irq, target_phys_addr_t io_base, |
| 10 | 13 |
BlockDriverState **fds, qemu_irq *fdc_tc); |
| 11 | 14 |
int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num); |
| b/hw/isa-bus.c | ||
|---|---|---|
| 18 | 18 |
*/ |
| 19 | 19 |
#include "hw.h" |
| 20 | 20 |
#include "sysemu.h" |
| 21 |
#include "monitor.h" |
|
| 22 |
#include "sysbus.h" |
|
| 21 | 23 |
#include "isa.h" |
| 22 | 24 |
|
| 23 | 25 |
struct ISABus {
|
| 24 | 26 |
BusState qbus; |
| 27 |
qemu_irq *irqs; |
|
| 28 |
uint32_t assigned; |
|
| 25 | 29 |
}; |
| 26 | 30 |
static ISABus *isabus; |
| 27 | 31 |
|
| 32 |
static void isabus_dev_print(Monitor *mon, DeviceState *dev, int indent); |
|
| 33 |
|
|
| 28 | 34 |
static struct BusInfo isa_bus_info = {
|
| 29 |
.name = "ISA", |
|
| 30 |
.size = sizeof(ISABus), |
|
| 31 |
.props = (Property[]) {
|
|
| 35 |
.name = "ISA", |
|
| 36 |
.size = sizeof(ISABus), |
|
| 37 |
.print_dev = isabus_dev_print, |
|
| 38 |
.props = (Property[]) {
|
|
| 32 | 39 |
DEFINE_PROP_HEX32("iobase", ISADevice, iobase[0], -1),
|
| 33 | 40 |
DEFINE_PROP_HEX32("iobase2", ISADevice, iobase[1], -1),
|
| 34 | 41 |
DEFINE_PROP_END_OF_LIST(), |
| ... | ... | |
| 41 | 48 |
fprintf(stderr, "Can't create a second ISA bus\n"); |
| 42 | 49 |
return NULL; |
| 43 | 50 |
} |
| 51 |
if (NULL == dev) {
|
|
| 52 |
dev = qdev_create(NULL, "isabus-bridge"); |
|
| 53 |
qdev_init(dev); |
|
| 54 |
} |
|
| 44 | 55 |
|
| 45 | 56 |
isabus = FROM_QBUS(ISABus, qbus_create(&isa_bus_info, dev, NULL)); |
| 46 | 57 |
return isabus; |
| 47 | 58 |
} |
| 48 | 59 |
|
| 49 |
void isa_connect_irq(ISADevice *dev, int n, qemu_irq irq)
|
|
| 60 |
void isa_bus_irqs(qemu_irq *irqs)
|
|
| 50 | 61 |
{
|
| 51 |
assert(n >= 0 && n < dev->nirqs); |
|
| 52 |
if (dev->irqs[n]) |
|
| 53 |
*dev->irqs[n] = irq; |
|
| 62 |
isabus->irqs = irqs; |
|
| 63 |
} |
|
| 64 |
|
|
| 65 |
void isa_connect_irq(ISADevice *dev, int devnr, int isairq) |
|
| 66 |
{
|
|
| 67 |
assert(devnr >= 0 && devnr < dev->nirqs); |
|
| 68 |
if (isabus->assigned & (1 << isairq)) {
|
|
| 69 |
fprintf(stderr, "isa irq %d already assigned\n", isairq); |
|
| 70 |
exit(1); |
|
| 71 |
} |
|
| 72 |
if (dev->irqs[devnr]) {
|
|
| 73 |
isabus->assigned |= (1 << isairq); |
|
| 74 |
dev->isairq[devnr] = isairq; |
|
| 75 |
*dev->irqs[devnr] = isabus->irqs[isairq]; |
|
| 76 |
} |
|
| 54 | 77 |
} |
| 55 | 78 |
|
| 56 | 79 |
void isa_init_irq(ISADevice *dev, qemu_irq *p) |
| ... | ... | |
| 65 | 88 |
ISADevice *dev = DO_UPCAST(ISADevice, qdev, qdev); |
| 66 | 89 |
ISADeviceInfo *info = DO_UPCAST(ISADeviceInfo, qdev, base); |
| 67 | 90 |
|
| 91 |
dev->isairq[0] = -1; |
|
| 92 |
dev->isairq[1] = -1; |
|
| 68 | 93 |
info->init(dev); |
| 69 | 94 |
} |
| 70 | 95 |
|
| ... | ... | |
| 91 | 116 |
qdev_init(dev); |
| 92 | 117 |
return isa; |
| 93 | 118 |
} |
| 119 |
|
|
| 120 |
static void isabus_dev_print(Monitor *mon, DeviceState *dev, int indent) |
|
| 121 |
{
|
|
| 122 |
ISADevice *d = DO_UPCAST(ISADevice, qdev, dev); |
|
| 123 |
|
|
| 124 |
if (d->isairq[1] != -1) {
|
|
| 125 |
monitor_printf(mon, "%*sisa irqs %d,%d\n", indent, "", |
|
| 126 |
d->isairq[0], d->isairq[1]); |
|
| 127 |
} else if (d->isairq[0] != -1) {
|
|
| 128 |
monitor_printf(mon, "%*sisa irq %d\n", indent, "", |
|
| 129 |
d->isairq[0]); |
|
| 130 |
} |
|
| 131 |
} |
|
| 132 |
|
|
| 133 |
static void isabus_bridge_init(SysBusDevice *dev) |
|
| 134 |
{
|
|
| 135 |
/* nothing */ |
|
| 136 |
} |
|
| 137 |
|
|
| 138 |
static SysBusDeviceInfo isabus_bridge_info = {
|
|
| 139 |
.init = isabus_bridge_init, |
|
| 140 |
.qdev.name = "isabus-bridge", |
|
| 141 |
.qdev.size = sizeof(SysBusDevice), |
|
| 142 |
}; |
|
| 143 |
|
|
| 144 |
static void isabus_register_devices(void) |
|
| 145 |
{
|
|
| 146 |
sysbus_register_withprop(&isabus_bridge_info); |
|
| 147 |
} |
|
| 148 |
|
|
| 149 |
device_init(isabus_register_devices) |
|
| b/hw/isa.h | ||
|---|---|---|
| 13 | 13 |
struct ISADevice {
|
| 14 | 14 |
DeviceState qdev; |
| 15 | 15 |
uint32_t iobase[2]; |
| 16 |
uint32_t isairq[2]; |
|
| 16 | 17 |
qemu_irq *irqs[2]; |
| 17 | 18 |
int nirqs; |
| 18 | 19 |
}; |
| ... | ... | |
| 24 | 25 |
}; |
| 25 | 26 |
|
| 26 | 27 |
ISABus *isa_bus_new(DeviceState *dev); |
| 27 |
void isa_connect_irq(ISADevice *dev, int n, qemu_irq irq); |
|
| 28 |
void isa_bus_irqs(qemu_irq *irqs); |
|
| 29 |
void isa_connect_irq(ISADevice *dev, int devirq, int isairq); |
|
| 28 | 30 |
void isa_init_irq(ISADevice *dev, qemu_irq *p); |
| 29 | 31 |
void isa_qdev_register(ISADeviceInfo *info); |
| 30 | 32 |
ISADevice *isa_create_simple(const char *name, uint32_t iobase, uint32_t iobase2); |
| b/hw/mips_jazz.c | ||
|---|---|---|
| 238 | 238 |
DriveInfo *dinfo = drive_get(IF_FLOPPY, 0, n); |
| 239 | 239 |
fds[n] = dinfo ? dinfo->bdrv : NULL; |
| 240 | 240 |
} |
| 241 |
fdctrl_init(rc4030[1], 0, 1, 0x80003000, fds);
|
|
| 241 |
fdctrl_init_sysbus(rc4030[1], 0, 0x80003000, fds);
|
|
| 242 | 242 |
|
| 243 | 243 |
/* Real time clock */ |
| 244 | 244 |
rtc_init(0x70, i8259[8], 1980); |
| b/hw/mips_malta.c | ||
|---|---|---|
| 929 | 929 |
dinfo = drive_get(IF_FLOPPY, 0, i); |
| 930 | 930 |
fd[i] = dinfo ? dinfo->bdrv : NULL; |
| 931 | 931 |
} |
| 932 |
floppy_controller = fdctrl_init(i8259[6], 2, 0, 0x3f0, fd);
|
|
| 932 |
floppy_controller = fdctrl_init_isa(6, 2, 0x3f0, fd);
|
|
| 933 | 933 |
|
| 934 | 934 |
/* Sound card */ |
| 935 | 935 |
#ifdef HAS_AUDIO |
| b/hw/pc.c | ||
|---|---|---|
| 1283 | 1283 |
piix3_devfn = piix3_init(pci_bus, -1); |
| 1284 | 1284 |
} else {
|
| 1285 | 1285 |
pci_bus = NULL; |
| 1286 |
isa_bus_new(NULL); |
|
| 1286 | 1287 |
} |
| 1288 |
isa_bus_irqs(isa_irq); |
|
| 1287 | 1289 |
|
| 1288 | 1290 |
/* init basic PC hardware */ |
| 1289 | 1291 |
register_ioport_write(0x80, 1, 1, ioport80_write, NULL); |
| ... | ... | |
| 1372 | 1374 |
} |
| 1373 | 1375 |
|
| 1374 | 1376 |
isa_dev = isa_create_simple("i8042", 0x60, 0x64);
|
| 1375 |
isa_connect_irq(isa_dev, 0, isa_irq[1]);
|
|
| 1376 |
isa_connect_irq(isa_dev, 1, isa_irq[12]);
|
|
| 1377 |
isa_connect_irq(isa_dev, 0, 1);
|
|
| 1378 |
isa_connect_irq(isa_dev, 1, 12);
|
|
| 1377 | 1379 |
DMA_init(0); |
| 1378 | 1380 |
#ifdef HAS_AUDIO |
| 1379 | 1381 |
audio_init(pci_enabled ? pci_bus : NULL, isa_irq); |
| ... | ... | |
| 1383 | 1385 |
dinfo = drive_get(IF_FLOPPY, 0, i); |
| 1384 | 1386 |
fd[i] = dinfo ? dinfo->bdrv : NULL; |
| 1385 | 1387 |
} |
| 1386 |
floppy_controller = fdctrl_init(isa_irq[6], 2, 0, 0x3f0, fd);
|
|
| 1388 |
floppy_controller = fdctrl_init_isa(6, 2, 0x3f0, fd);
|
|
| 1387 | 1389 |
|
| 1388 | 1390 |
cmos_init(below_4g_mem_size, above_4g_mem_size, boot_device, hd); |
| 1389 | 1391 |
|
| b/hw/ppc_prep.c | ||
|---|---|---|
| 719 | 719 |
dinfo = drive_get(IF_FLOPPY, 0, i); |
| 720 | 720 |
fd[i] = dinfo ? dinfo->bdrv : NULL; |
| 721 | 721 |
} |
| 722 |
fdctrl_init(i8259[6], 2, 0, 0x3f0, fd);
|
|
| 722 |
fdctrl_init_isa(6, 2, 0x3f0, fd);
|
|
| 723 | 723 |
|
| 724 | 724 |
/* Register speaker port */ |
| 725 | 725 |
register_ioport_read(0x61, 1, 1, speaker_ioport_read, NULL); |
| b/hw/sun4u.c | ||
|---|---|---|
| 618 | 618 |
dinfo = drive_get(IF_FLOPPY, 0, i); |
| 619 | 619 |
fd[i] = dinfo ? dinfo->bdrv : NULL; |
| 620 | 620 |
} |
| 621 |
floppy_controller = fdctrl_init(NULL/*6*/, 2, 0, 0x3f0, fd);
|
|
| 621 |
floppy_controller = fdctrl_init_isa(6, 2, 0x3f0, fd);
|
|
| 622 | 622 |
nvram = m48t59_init(NULL/*8*/, 0, 0x0074, NVRAM_SIZE, 59); |
| 623 | 623 |
|
| 624 | 624 |
initrd_size = 0; |
Also available in: Unified diff