vl.h revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/*
* QEMU System Emulator header
*
* Copyright (c) 2003 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
* 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.
*/
#ifndef VL_H
#define VL_H
/* we put basic includes here to avoid repeating them in device drivers */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <inttypes.h>
#ifndef VBOX
#include <limits.h>
#include <time.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#endif /* !VBOX */
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
#ifndef O_BINARY
#define O_BINARY 0
#endif
#ifdef _WIN32
#ifndef VBOX
#include <windows.h>
#define ENOTSUP 4096
#define ENOMEDIUM 4097
extern int qemu_ftruncate64(int, int64_t);
#define ftruncate qemu_ftruncate64
{
return resolved_path;
}
#define PRId64 "I64d"
#define PRIx64 "I64x"
#define PRIu64 "I64u"
#define PRIo64 "I64o"
#endif /* !VBOX */
#endif
#ifdef QEMU_TOOL
/* we use QEMU_TOOL in the command line tools which do not depend on
the target CPU type */
#include "config-host.h"
#include <setjmp.h>
#include "osdep.h"
#include "bswap.h"
#else
#ifndef VBOX
#endif /* !VBOX */
#include "cpu.h"
#ifndef VBOX
#include "gdbstub.h"
#endif /* !VBOX */
#endif /* !defined(QEMU_TOOL) */
#ifdef VBOX
# include "REMInternal.h"
#endif /* VBOX */
#ifndef glue
#define xglue(x, y) x ## y
#define tostring(s) #s
#endif
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
/* vl.c */
extern const char *bios_dir;
extern int vm_running;
typedef struct vm_change_state_entry VMChangeStateEntry;
void *opaque);
void vm_start(void);
typedef void QEMUResetHandler(void *opaque);
void qemu_system_reset_request(void);
void qemu_system_shutdown_request(void);
void qemu_system_powerdown_request(void);
#if !defined(TARGET_SPARC)
// Please implement a power failure function to signal the OS
#define qemu_system_powerdown() do{}while(0)
#else
void qemu_system_powerdown(void);
#endif
void main_loop_wait(int timeout);
extern int ram_size;
extern int bios_size;
extern int rtc_utc;
extern int cirrus_vga_enabled;
extern int graphic_width;
extern int graphic_height;
extern int graphic_depth;
extern const char *keyboard_layout;
extern int kqemu_allowed;
extern int win2k_install_hack;
extern int usb_enabled;
extern int smp_cpus;
extern int no_quit;
#ifndef VBOX
/* XXX: make it dynamic */
#if defined (TARGET_PPC) || defined (TARGET_SPARC64)
#elif defined(TARGET_MIPS)
#else
#endif
#define MOUSE_EVENT_LBUTTON 0x01
#define MOUSE_EVENT_RBUTTON 0x02
#define MOUSE_EVENT_MBUTTON 0x04
void kbd_put_keycode(int keycode);
int kbd_mouse_is_absolute(void);
/* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
constants) */
#define QEMU_KEY_ESC1(c) ((c) | 0xe100)
#define QEMU_KEY_BACKSPACE 0x007f
#define QEMU_KEY_CTRL_UP 0xe400
#define QEMU_KEY_CTRL_DOWN 0xe401
#define QEMU_KEY_CTRL_LEFT 0xe402
#define QEMU_KEY_CTRL_RIGHT 0xe403
#define QEMU_KEY_CTRL_HOME 0xe404
#define QEMU_KEY_CTRL_END 0xe405
#define QEMU_KEY_CTRL_PAGEUP 0xe406
#define QEMU_KEY_CTRL_PAGEDOWN 0xe407
void kbd_put_keysym(int keysym);
/* async I/O support */
typedef int IOCanRWHandler(void *opaque);
int qemu_set_fd_handler2(int fd,
void *opaque);
int qemu_set_fd_handler(int fd,
void *opaque);
/* Polling handling */
/* return TRUE if no sleep should be done afterwards */
typedef int PollingFunc(void *opaque);
#ifdef _WIN32
/* Wait objects handling */
typedef void WaitObjectFunc(void *opaque);
#endif
/* character device */
#define CHR_EVENT_BREAK 0 /* serial break char */
#define CHR_IOCTL_SERIAL_SET_PARAMS 1
typedef struct {
int speed;
int parity;
int data_bits;
int stop_bits;
#define CHR_IOCTL_SERIAL_SET_BREAK 2
#define CHR_IOCTL_PP_READ_DATA 3
#define CHR_IOCTL_PP_WRITE_DATA 4
#define CHR_IOCTL_PP_READ_CONTROL 5
#define CHR_IOCTL_PP_WRITE_CONTROL 6
#define CHR_IOCTL_PP_READ_STATUS 7
typedef struct CharDriverState {
void (*chr_add_read_handler)(struct CharDriverState *s,
void *opaque;
void qemu_chr_add_read_handler(CharDriverState *s,
/* consoles */
typedef struct DisplayState DisplayState;
typedef struct TextConsole TextConsole;
typedef void (*vga_hw_update_ptr)(void *);
typedef void (*vga_hw_invalidate_ptr)(void *);
typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
void *opaque);
void vga_hw_update(void);
void vga_hw_invalidate(void);
void vga_hw_screen_dump(const char *filename);
int is_graphic_console(void);
void console_select(unsigned int index);
/* serial ports */
#define MAX_SERIAL_PORTS 4
/* parallel ports */
#define MAX_PARALLEL_PORTS 3
/* VLANs support */
typedef struct VLANClientState VLANClientState;
struct VLANClientState {
/* Packets may still be sent if this returns zero. It's used to
rate-limit the slirp code. */
void *opaque;
struct VLANClientState *next;
char info_str[256];
};
typedef struct VLANState {
int id;
} VLANState;
void *opaque);
void qemu_handler_true(void *opaque);
void do_info_network(void);
/* TAP win32 */
/* NIC info */
#define MAX_NICS 8
typedef struct NICInfo {
const char *model;
} NICInfo;
extern int nb_nics;
/* timers */
typedef void QEMUTimerCB(void *opaque);
/* The real time clock should be used only for stuff which does not
change the virtual machine state, as it is run even if the virtual
machine is stopped. The real time clock has a frequency of 1000
Hz. */
/* The virtual clock is only run during the emulation. It is stopped
when the virtual machine is stopped. Virtual timers use a high
precision clock, usually cpu cycles (use ticks_per_sec). */
extern int64_t ticks_per_sec;
extern int pit_min_timer_count;
int64_t cpu_get_ticks(void);
void cpu_enable_ticks(void);
void cpu_disable_ticks(void);
void qemu_fflush(QEMUFile *f);
void qemu_fclose(QEMUFile *f);
void qemu_put_byte(QEMUFile *f, int v);
void qemu_put_be16(QEMUFile *f, unsigned int v);
void qemu_put_be32(QEMUFile *f, unsigned int v);
int qemu_get_byte(QEMUFile *f);
unsigned int qemu_get_be16(QEMUFile *f);
unsigned int qemu_get_be32(QEMUFile *f);
{
qemu_put_be64(f, *pv);
}
{
qemu_put_be32(f, *pv);
}
{
qemu_put_be16(f, *pv);
}
{
qemu_put_byte(f, *pv);
}
{
*pv = qemu_get_be64(f);
}
{
*pv = qemu_get_be32(f);
}
{
*pv = qemu_get_be16(f);
}
{
*pv = qemu_get_byte(f);
}
#if TARGET_LONG_BITS == 64
#define qemu_put_betl qemu_put_be64
#define qemu_get_betl qemu_get_be64
#define qemu_put_betls qemu_put_be64s
#define qemu_get_betls qemu_get_be64s
#else
#define qemu_put_betl qemu_put_be32
#define qemu_get_betl qemu_get_be32
#define qemu_put_betls qemu_put_be32s
#define qemu_get_betls qemu_get_be32s
#endif
int register_savevm(const char *idstr,
int instance_id,
int version_id,
void *opaque);
void do_info_snapshots(void);
/* bottom halves */
typedef void QEMUBHFunc(void *opaque);
int qemu_bh_poll(void);
/* block.c */
typedef struct BlockDriverState BlockDriverState;
typedef struct BlockDriver BlockDriver;
extern BlockDriver bdrv_raw;
extern BlockDriver bdrv_host_device;
extern BlockDriver bdrv_cow;
extern BlockDriver bdrv_qcow;
extern BlockDriver bdrv_vmdk;
extern BlockDriver bdrv_cloop;
extern BlockDriver bdrv_dmg;
extern BlockDriver bdrv_bochs;
extern BlockDriver bdrv_vpc;
extern BlockDriver bdrv_vvfat;
extern BlockDriver bdrv_qcow2;
typedef struct BlockDriverInfo {
/* in bytes, 0 if irrelevant */
int cluster_size;
/* offset at which the VM state can be saved (0 if not possible) */
typedef struct QEMUSnapshotInfo {
/* the following fields are informative. They are not needed for
the consistency of the snapshot */
#define BDRV_O_RDONLY 0x0000
#define BDRV_O_RDWR 0x0002
#define BDRV_O_ACCESS 0x0003
use a disk image format on top of
it (default for
bdrv_file_open()) */
void bdrv_init(void);
const char *backing_file, int flags);
BlockDriver *drv);
/* async block I/O */
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
void qemu_aio_init(void);
void qemu_aio_poll(void);
void qemu_aio_flush(void);
void qemu_aio_wait_start(void);
void qemu_aio_wait(void);
void qemu_aio_wait_end(void);
/* Ensure contents are flushed to disk. */
#define BDRV_TYPE_HD 0
#define BDRV_TYPE_CDROM 1
#define BDRV_TYPE_FLOPPY 2
#define BIOS_ATA_TRANSLATION_AUTO 0
#define BIOS_ATA_TRANSLATION_NONE 1
#define BIOS_ATA_TRANSLATION_LBA 2
void bdrv_info(void);
void *opaque);
char *filename, int filename_size);
const char *snapshot_id);
int path_is_absolute(const char *path);
const char *base_path,
const char *filename);
#ifndef QEMU_TOOL
int boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename);
typedef struct QEMUMachine {
const char *name;
const char *desc;
struct QEMUMachine *next;
} QEMUMachine;
int qemu_register_machine(QEMUMachine *m);
/* ISA bus */
extern target_phys_addr_t isa_mem_base;
/* PCI bus */
extern target_phys_addr_t pci_mem_base;
#define PCI_ADDRESS_SPACE_MEM 0x00
#define PCI_ADDRESS_SPACE_IO 0x01
#define PCI_ADDRESS_SPACE_MEM_PREFETCH 0x08
typedef struct PCIIORegion {
} PCIIORegion;
#define PCI_ROM_SLOT 6
#define PCI_NUM_REGIONS 7
#define PCI_DEVICES_MAX 64
struct PCIDevice {
/* PCI config space */
/* the following fields are read only */
int devfn;
char name[64];
/* do not access the following fields */
/* ??? This is a PC-specific hack, and should be removed. */
int irq_index;
/* Current IRQ levels. Used internally by the generic PCI code. */
int irq_state[4];
};
int instance_size, int devfn,
void pci_default_write_config(PCIDevice *d,
int pci_bus_num(PCIBus *s);
void pci_info(void);
/* prep_pci.c */
PCIBus *pci_prep_init(void);
/* grackle_pci.c */
/* unin_pci.c */
/* apb_pci.c */
void *pic);
/* piix_pci.c */
void i440fx_init_memory_mappings(PCIDevice *d);
/* openpic.c */
/* heathrow_pic.c */
typedef struct HeathrowPICS HeathrowPICS;
#ifdef HAS_AUDIO
struct soundhw {
const char *name;
const char *descr;
int enabled;
int isa;
union {
int (*init_isa) (AudioState *s);
} init;
};
#endif
/* vga.c */
struct DisplayState {
int linesize;
int depth;
int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
int width;
int height;
void *opaque;
void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
void (*dpy_resize)(struct DisplayState *s, int w, int h);
void (*dpy_refresh)(struct DisplayState *s);
};
static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
{
s->dpy_update(s, x, y, w, h);
}
static inline void dpy_resize(DisplayState *s, int w, int h)
{
s->dpy_resize(s, w, h);
}
unsigned long vga_ram_offset, int vga_ram_size);
unsigned long vga_ram_offset, int vga_ram_size,
unsigned long vga_bios_offset, int vga_bios_size);
/* cirrus_vga.c */
unsigned long vga_ram_offset, int vga_ram_size);
unsigned long vga_ram_offset, int vga_ram_size);
/* sdl.c */
/* cocoa.m */
/* vnc.c */
/* ide.c */
#define MAX_DISKS 4
int secondary_ide_enabled);
/* cdrom.c */
/* es1370.c */
/* sb16.c */
int SB16_init (AudioState *s);
/* adlib.c */
int Adlib_init (AudioState *s);
/* gus.c */
int GUS_init (AudioState *s);
/* dma.c */
int DMA_get_channel_mode (int nchan);
void DMA_hold_DREQ (int nchan);
void DMA_release_DREQ (int nchan);
void DMA_schedule(int nchan);
void DMA_run (void);
void DMA_init (int high_page_enable);
void DMA_register_channel (int nchan,
void *opaque);
/* fdc.c */
#define MAX_FD 2
BlockDriverState **fds);
/* ne2000.c */
/* rtl8139.c */
/* pcnet.c */
void pcnet_h_reset(void *opaque);
/* pckbd.c */
void kbd_init(void);
/* mc146818rtc.c */
/* serial.c */
typedef struct SerialState SerialState;
/* parallel.c */
typedef struct ParallelState ParallelState;
/* i8259.c */
void *alt_irq_opaque);
int pic_read_irq(PicState2 *s);
void pic_update_irq(PicState2 *s);
void pic_info(void);
void irq_info(void);
/* APIC */
typedef struct IOAPICState IOAPICState;
IOAPICState *ioapic_init(void);
/* i8254.c */
#define PIT_FREQ 1193182
/* pcspk.c */
void pcspk_init(PITState *);
int pcspk_audio_init(AudioState *);
/* acpi.c */
extern int acpi_enabled;
void acpi_bios_init(void);
/* pc.c */
extern QEMUMachine pc_machine;
extern QEMUMachine isapc_machine;
extern int fd_bootchk;
void ioport_set_a20(int enable);
int ioport_get_a20(void);
/* ppc.c */
extern QEMUMachine prep_machine;
extern QEMUMachine core99_machine;
extern QEMUMachine heathrow_machine;
/* mips_r4k.c */
extern QEMUMachine mips_machine;
/* mips_timer.c */
extern void cpu_mips_clock_init(CPUState *);
extern void cpu_mips_irqctrl_init (void);
/* shix.c */
extern QEMUMachine shix_machine;
#ifdef TARGET_PPC
#endif
extern CPUWriteMemoryFunc *PPC_io_write[];
extern CPUReadMemoryFunc *PPC_io_read[];
/* sun4m.c */
extern QEMUMachine sun4m_machine;
/* iommu.c */
static inline void sparc_iommu_memory_read(void *opaque,
{
}
static inline void sparc_iommu_memory_write(void *opaque,
{
}
/* tcx.c */
/* slavio_intctl.c */
void *slavio_intctl_init();
void slavio_pic_info(void *opaque);
void slavio_irq_info(void *opaque);
/* loader.c */
int get_image_size(const char *filename);
/* slavio_timer.c */
/* slavio_serial.c */
/* slavio_misc.c */
/* esp.c */
/* sparc32_dma.c */
void *intctl);
void espdma_raise_irq(void *opaque);
void espdma_clear_irq(void *opaque);
void *lance_opaque);
/* cs4231.c */
/* sun4u.c */
extern QEMUMachine sun4u_machine;
/* NVRAM helpers */
const unsigned char *arch,
const char *cmdline,
/* adb.c */
#define MAX_ADB_DEVICES 16
#define ADB_MAX_OUT_LEN 16
/* buf = NULL means polling */
typedef int ADBDeviceReset(ADBDevice *d);
struct ADBDevice {
struct ADBBusState *bus;
int devaddr;
int handler;
void *opaque;
};
typedef struct ADBBusState {
int nb_devices;
int poll_index;
} ADBBusState;
void *opaque);
/* cuda.c */
extern ADBBusState adb_bus;
/* usb ports of the VM */
#define VM_USB_HUB_SIZE 8
void do_usb_add(const char *devname);
void do_usb_del(const char *devname);
void usb_info(void);
/* scsi-disk.c */
enum scsi_reason {
SCSI_REASON_DONE, /* Command complete. */
SCSI_REASON_DATA /* Transfer complete, more data required. */
};
typedef struct SCSIDevice SCSIDevice;
int tcq,
void *opaque);
void scsi_disk_destroy(SCSIDevice *s);
/* SCSI data transfers are asynchrnonous. However, unlike the block IO
layer the completion routine may be called directly by
scsi_{read,write}_data. */
enum scsi_host_adapters {
};
enum scsi_devices {
};
typedef enum scsi_host_adapters scsi_host_adapters;
typedef enum scsi_devices scsi_devices;
typedef struct SCSIDiskInfo {
int id;
} SCSIDiskInfo;
#define MAX_SCSI_DISKS 7
/* lsi53c895a.c */
extern int scsi_hba_lsi; // Count of scsi disks/cdrom using this lsi adapter
/* integratorcp.c */
extern QEMUMachine integratorcp926_machine;
extern QEMUMachine integratorcp1026_machine;
/* versatilepb.c */
extern QEMUMachine versatilepb_machine;
extern QEMUMachine versatileab_machine;
/* realview.c */
extern QEMUMachine realview_machine;
/* ps2.c */
void ps2_write_mouse(void *, int val);
void ps2_write_keyboard(void *, int val);
uint32_t ps2_read_data(void *);
void ps2_queue(void *, int b);
/* smc91c111.c */
/* pl110.c */
/* pl011.c */
/* pl050.c */
/* pl080.c */
/* pl190.c */
/* arm-timer.c */
/* arm_sysctl.c */
/* arm_gic.c */
/* arm_boot.c */
const char *kernel_cmdline, const char *initrd_filename,
int board_id);
/* sh7750.c */
struct SH7750State;
typedef struct {
/* The callback will be triggered if any of the designated lines change */
/* Return 0 if no action was taken */
int sh7750_register_io_device(struct SH7750State *s,
/* tc58128.c */
/* NOR flash devices */
#endif /* defined(QEMU_TOOL) */
/* monitor.c */
void term_print_filename(const char *filename);
void term_flush(void);
void term_print_help(void);
/* readline.c */
extern int completion_index;
void add_completion(const char *str);
void readline_handle_byte(int ch);
void readline_find_completion(const char *cmdline);
const char *readline_get_history(unsigned int index);
void kqemu_record_dump(void);
#endif /* !VBOX */
#endif /* VL_H */