[mirror_qemu.git] / vl.h

/*
 * 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
 * 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.
 */
#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>
#include <time.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>

#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
#ifndef O_BINARY
#define O_BINARY 0
#endif

#ifdef _WIN32
#define lseek64 lseek
#endif

#include "cpu.h"

#ifndef glue
#define xglue(x, y) x ## y
#define glue(x, y) xglue(x, y)
#define stringify(s)	tostring(s)
#define tostring(s)	#s
#endif

#if defined(WORDS_BIGENDIAN)
static inline uint32_t be32_to_cpu(uint32_t v)
{
    return v;
}

static inline uint16_t be16_to_cpu(uint16_t v)
{
    return v;
}

static inline uint32_t le32_to_cpu(uint32_t v)
{
    return bswap32(v);
}

static inline uint16_t le16_to_cpu(uint16_t v)
{
    return bswap16(v);
}

#else
static inline uint32_t be32_to_cpu(uint32_t v)
{
    return bswap32(v);
}

static inline uint16_t be16_to_cpu(uint16_t v)
{
    return bswap16(v);
}

static inline uint32_t le32_to_cpu(uint32_t v)
{
    return v;
}

static inline uint16_t le16_to_cpu(uint16_t v)
{
    return v;
}
#endif


/* vl.c */
extern int reset_requested;

typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);

int register_ioport_read(int start, int length, int size, 
                         IOPortReadFunc *func, void *opaque);
int register_ioport_write(int start, int length, int size, 
                          IOPortWriteFunc *func, void *opaque);
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);

void hw_error(const char *fmt, ...);

int load_image(const char *filename, uint8_t *addr);
extern const char *bios_dir;

void pstrcpy(char *buf, int buf_size, const char *str);
char *pstrcat(char *buf, int buf_size, const char *s);

int serial_open_device(void);

extern int vm_running;

typedef void VMStopHandler(void *opaque, int reason);

int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);

void vm_start(void);
void vm_stop(int reason);

/* network redirectors support */

#define MAX_NICS 8

typedef struct NetDriverState {
    int fd;
    uint8_t macaddr[6];
    char ifname[16];
} NetDriverState;

extern int nb_nics;
extern NetDriverState nd_table[MAX_NICS];

void net_send_packet(NetDriverState *nd, const uint8_t *buf, int size);

/* async I/O support */

typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
typedef int IOCanRWHandler(void *opaque);

int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read, 
                             IOReadHandler *fd_read, void *opaque);
void qemu_del_fd_read_handler(int fd);

/* timers */

typedef struct QEMUClock QEMUClock;
typedef struct QEMUTimer QEMUTimer;
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 or 1000
   Hz. */
extern QEMUClock *rt_clock;

/* Rge 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 QEMUClock *vm_clock;

int64_t qemu_get_clock(QEMUClock *clock);

QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
void qemu_free_timer(QEMUTimer *ts);
void qemu_del_timer(QEMUTimer *ts);
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
int qemu_timer_pending(QEMUTimer *ts);

extern int64_t ticks_per_sec;
extern int pit_min_timer_count;

void cpu_enable_ticks(void);
void cpu_disable_ticks(void);

/* VM Load/Save */

typedef FILE QEMUFile;

void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
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);
void qemu_put_be64(QEMUFile *f, uint64_t v);
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
int qemu_get_byte(QEMUFile *f);
unsigned int qemu_get_be16(QEMUFile *f);
unsigned int qemu_get_be32(QEMUFile *f);
uint64_t qemu_get_be64(QEMUFile *f);

static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
{
    qemu_put_be64(f, *pv);
}

static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
{
    qemu_put_be32(f, *pv);
}

static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
{
    qemu_put_be16(f, *pv);
}

static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
{
    qemu_put_byte(f, *pv);
}

static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
{
    *pv = qemu_get_be64(f);
}

static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
{
    *pv = qemu_get_be32(f);
}

static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
{
    *pv = qemu_get_be16(f);
}

static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
{
    *pv = qemu_get_byte(f);
}

int64_t qemu_ftell(QEMUFile *f);
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);

typedef void SaveStateHandler(QEMUFile *f, void *opaque);
typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);

int qemu_loadvm(const char *filename);
int qemu_savevm(const char *filename);
int register_savevm(const char *idstr, 
                    int instance_id, 
                    int version_id,
                    SaveStateHandler *save_state,
                    LoadStateHandler *load_state,
                    void *opaque);
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);

/* block.c */
typedef struct BlockDriverState BlockDriverState;

BlockDriverState *bdrv_new(const char *device_name);
void bdrv_delete(BlockDriverState *bs);
int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
void bdrv_close(BlockDriverState *bs);
int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
              uint8_t *buf, int nb_sectors);
int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
               const uint8_t *buf, int nb_sectors);
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
int bdrv_commit(BlockDriverState *bs);
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);

#define BDRV_TYPE_HD     0
#define BDRV_TYPE_CDROM  1
#define BDRV_TYPE_FLOPPY 2

void bdrv_set_geometry_hint(BlockDriverState *bs, 
                            int cyls, int heads, int secs);
void bdrv_set_type_hint(BlockDriverState *bs, int type);
void bdrv_get_geometry_hint(BlockDriverState *bs, 
                            int *pcyls, int *pheads, int *psecs);
int bdrv_get_type_hint(BlockDriverState *bs);
int bdrv_is_removable(BlockDriverState *bs);
int bdrv_is_read_only(BlockDriverState *bs);
int bdrv_is_inserted(BlockDriverState *bs);
int bdrv_is_locked(BlockDriverState *bs);
void bdrv_set_locked(BlockDriverState *bs, int locked);
void bdrv_set_change_cb(BlockDriverState *bs, 
                        void (*change_cb)(void *opaque), void *opaque);

void bdrv_info(void);
BlockDriverState *bdrv_find(const char *name);

/* vga.c */

#define VGA_RAM_SIZE (4096 * 1024)

typedef struct DisplayState {
    uint8_t *data;
    int linesize;
    int depth;
    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);
} DisplayState;

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);
}

int vga_initialize(DisplayState *ds, uint8_t *vga_ram_base, 
                   unsigned long vga_ram_offset, int vga_ram_size);
void vga_update_display(void);
void vga_screen_dump(const char *filename);

/* sdl.c */
void sdl_display_init(DisplayState *ds);

/* ide.c */
#define MAX_DISKS 4

extern BlockDriverState *bs_table[MAX_DISKS];

void ide_init(int iobase, int iobase2, int irq,
              BlockDriverState *hd0, BlockDriverState *hd1);

/* oss.c */
typedef enum {
  AUD_FMT_U8,
  AUD_FMT_S8,
  AUD_FMT_U16,
  AUD_FMT_S16
} audfmt_e;

void AUD_open (int rfreq, int rnchannels, audfmt_e rfmt);
void AUD_reset (int rfreq, int rnchannels, audfmt_e rfmt);
int AUD_write (void *in_buf, int size);
void AUD_run (void);
void AUD_adjust_estimate (int _leftover);
int AUD_get_free (void);
int AUD_get_live (void);
int AUD_get_buffer_size (void);
void AUD_init (void);

/* dma.c */
typedef int (*DMA_transfer_handler) (void *opaque, target_ulong addr, int size);
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 (void);
void DMA_register_channel (int nchan,
                           DMA_transfer_handler transfer_handler, void *opaque);

/* sb16.c */
void SB16_run (void);
void SB16_init (void);
 
/* fdc.c */
#define MAX_FD 2
extern BlockDriverState *fd_table[MAX_FD];

typedef struct fdctrl_t fdctrl_t;

fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped, 
                       uint32_t io_base,
                       BlockDriverState **fds);
int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);

/* ne2000.c */

void ne2000_init(int base, int irq, NetDriverState *nd);

/* pckbd.c */

void kbd_put_keycode(int keycode);

#define MOUSE_EVENT_LBUTTON 0x01
#define MOUSE_EVENT_RBUTTON 0x02
#define MOUSE_EVENT_MBUTTON 0x04
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);

void kbd_init(void);

/* mc146818rtc.c */

typedef struct RTCState RTCState;

RTCState *rtc_init(int base, int irq);
void rtc_set_memory(RTCState *s, int addr, int val);
void rtc_set_date(RTCState *s, const struct tm *tm);

/* serial.c */

typedef struct SerialState SerialState;

extern SerialState *serial_console;

SerialState *serial_init(int base, int irq, int fd);
int serial_can_receive(SerialState *s);
void serial_receive_byte(SerialState *s, int ch);
void serial_receive_break(SerialState *s);

/* i8259.c */

void pic_set_irq(int irq, int level);
void pic_init(void);

/* i8254.c */

#define PIT_FREQ 1193182

typedef struct PITChannelState {
    int count; /* can be 65536 */
    uint16_t latched_count;
    uint8_t rw_state;
    uint8_t mode;
    uint8_t bcd; /* not supported */
    uint8_t gate; /* timer start */
    int64_t count_load_time;
    /* irq handling */
    int64_t next_transition_time;
    QEMUTimer *irq_timer;
    int irq;
} PITChannelState;

extern PITChannelState pit_channels[3];

void pit_init(int base, int irq);
void pit_set_gate(PITChannelState *s, int val);
int pit_get_out(PITChannelState *s, int64_t current_time);
int pit_get_out_edges(PITChannelState *s);

/* pc.c */
void pc_init(int ram_size, int vga_ram_size, int boot_device,
             DisplayState *ds, const char **fd_filename, int snapshot,
             const char *kernel_filename, const char *kernel_cmdline,
             const char *initrd_filename);

/* monitor.c */
void monitor_init(void);
void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
void term_flush(void);
void term_print_help(void);

/* gdbstub.c */

#define DEFAULT_GDBSTUB_PORT 1234

int gdbserver_start(int port);

#endif /* VL_H */
Commit	Line	Data
fc01f7e7 FB	1	/*
	2	* QEMU System Emulator header
	3	*
	4	* Copyright (c) 2003 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	#ifndef VL_H
	25	#define VL_H
	26
67b915a5 FB	27	/* we put basic includes here to avoid repeating them in device drivers */
	28	#include <stdlib.h>
	29	#include <stdio.h>
	30	#include <stdarg.h>
	31	#include <string.h>
	32	#include <inttypes.h>
8a7ddc38	33	#include <time.h>
67b915a5 FB	34	#include <ctype.h>
	35	#include <errno.h>
	36	#include <unistd.h>
	37	#include <fcntl.h>
	38
	39	#ifndef O_LARGEFILE
	40	#define O_LARGEFILE 0
	41	#endif
40c3bac3 FB	42	#ifndef O_BINARY
	43	#define O_BINARY 0
	44	#endif
67b915a5 FB	45
	46	#ifdef _WIN32
	47	#define lseek64 lseek
	48	#endif
8a7ddc38	49
16f62432 FB	50	#include "cpu.h"
16f62432 FB	51
67b915a5 FB	52	#ifndef glue
	53	#define xglue(x, y) x ## y
	54	#define glue(x, y) xglue(x, y)
	55	#define stringify(s) tostring(s)
	56	#define tostring(s) #s
	57	#endif
	58
	59	#if defined(WORDS_BIGENDIAN)
	60	static inline uint32_t be32_to_cpu(uint32_t v)
	61	{
	62	return v;
	63	}
	64
	65	static inline uint16_t be16_to_cpu(uint16_t v)
	66	{
	67	return v;
	68	}
	69
	70	static inline uint32_t le32_to_cpu(uint32_t v)
	71	{
	72	return bswap32(v);
	73	}
	74
	75	static inline uint16_t le16_to_cpu(uint16_t v)
	76	{
	77	return bswap16(v);
	78	}
	79
	80	#else
	81	static inline uint32_t be32_to_cpu(uint32_t v)
	82	{
	83	return bswap32(v);
	84	}
	85
	86	static inline uint16_t be16_to_cpu(uint16_t v)
	87	{
	88	return bswap16(v);
	89	}
	90
	91	static inline uint32_t le32_to_cpu(uint32_t v)
	92	{
	93	return v;
	94	}
	95
	96	static inline uint16_t le16_to_cpu(uint16_t v)
	97	{
	98	return v;
	99	}
	100	#endif
	101
	102
33e3963e	103	/* vl.c */
313aa567 FB	104	extern int reset_requested;
313aa567 FB	105
c4b1fcc0 FB	106	typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
c4b1fcc0 FB	107	typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
313aa567	108
c4b1fcc0 FB	109	int register_ioport_read(int start, int length, int size,
	110	IOPortReadFunc func, void opaque);
	111	int register_ioport_write(int start, int length, int size,
	112	IOPortWriteFunc func, void opaque);
80cabfad	113	uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
313aa567	114
80cabfad FB	115	void hw_error(const char *fmt, ...);
	116
	117	int load_image(const char filename, uint8_t addr);
	118	extern const char *bios_dir;
	119
	120	void pstrcpy(char buf, int buf_size, const char str);
	121	char pstrcat(char buf, int buf_size, const char *s);
33e3963e	122
c4b1fcc0 FB	123	int serial_open_device(void);
c4b1fcc0 FB	124
8a7ddc38 FB	125	extern int vm_running;
	126
	127	typedef void VMStopHandler(void *opaque, int reason);
	128
	129	int qemu_add_vm_stop_handler(VMStopHandler cb, void opaque);
	130	void qemu_del_vm_stop_handler(VMStopHandler cb, void opaque);
	131
	132	void vm_start(void);
	133	void vm_stop(int reason);
	134
c4b1fcc0 FB	135	/* network redirectors support */
	136
	137	#define MAX_NICS 8
	138
	139	typedef struct NetDriverState {
	140	int fd;
	141	uint8_t macaddr[6];
	142	char ifname[16];
	143	} NetDriverState;
	144
	145	extern int nb_nics;
	146	extern NetDriverState nd_table[MAX_NICS];
	147
	148	void net_send_packet(NetDriverState nd, const uint8_t buf, int size);
	149
	150	/* async I/O support */
	151
	152	typedef void IOReadHandler(void opaque, const uint8_t buf, int size);
	153	typedef int IOCanRWHandler(void *opaque);
	154
8a7ddc38 FB	155	int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read,
	156	IOReadHandler fd_read, void opaque);
	157	void qemu_del_fd_read_handler(int fd);
	158
	159	/* timers */
	160
	161	typedef struct QEMUClock QEMUClock;
	162	typedef struct QEMUTimer QEMUTimer;
	163	typedef void QEMUTimerCB(void *opaque);
	164
	165	/* The real time clock should be used only for stuff which does not
	166	change the virtual machine state, as it is run even if the virtual
	167	machine is stopped. The real time clock has a frequency or 1000
	168	Hz. */
	169	extern QEMUClock *rt_clock;
	170
	171	/* Rge virtual clock is only run during the emulation. It is stopped
	172	when the virtual machine is stopped. Virtual timers use a high
	173	precision clock, usually cpu cycles (use ticks_per_sec). */
	174	extern QEMUClock *vm_clock;
	175
	176	int64_t qemu_get_clock(QEMUClock *clock);
	177
	178	QEMUTimer qemu_new_timer(QEMUClock clock, QEMUTimerCB cb, void opaque);
	179	void qemu_free_timer(QEMUTimer *ts);
	180	void qemu_del_timer(QEMUTimer *ts);
	181	void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
	182	int qemu_timer_pending(QEMUTimer *ts);
	183
	184	extern int64_t ticks_per_sec;
	185	extern int pit_min_timer_count;
	186
	187	void cpu_enable_ticks(void);
	188	void cpu_disable_ticks(void);
	189
	190	/* VM Load/Save */
	191
	192	typedef FILE QEMUFile;
	193
	194	void qemu_put_buffer(QEMUFile f, const uint8_t buf, int size);
	195	void qemu_put_byte(QEMUFile *f, int v);
	196	void qemu_put_be16(QEMUFile *f, unsigned int v);
	197	void qemu_put_be32(QEMUFile *f, unsigned int v);
	198	void qemu_put_be64(QEMUFile *f, uint64_t v);
	199	int qemu_get_buffer(QEMUFile f, uint8_t buf, int size);
	200	int qemu_get_byte(QEMUFile *f);
	201	unsigned int qemu_get_be16(QEMUFile *f);
	202	unsigned int qemu_get_be32(QEMUFile *f);
	203	uint64_t qemu_get_be64(QEMUFile *f);
	204
	205	static inline void qemu_put_be64s(QEMUFile f, const uint64_t pv)
	206	{
	207	qemu_put_be64(f, *pv);
	208	}
	209
	210	static inline void qemu_put_be32s(QEMUFile f, const uint32_t pv)
	211	{
	212	qemu_put_be32(f, *pv);
	213	}
	214
	215	static inline void qemu_put_be16s(QEMUFile f, const uint16_t pv)
	216	{
	217	qemu_put_be16(f, *pv);
	218	}
219
220	static inline void qemu_put_8s(QEMUFile f, const uint8_t pv)
221	{
222	qemu_put_byte(f, *pv);
223	}
224
225	static inline void qemu_get_be64s(QEMUFile f, uint64_t pv)
226	{
227	*pv = qemu_get_be64(f);
228	}
229
230	static inline void qemu_get_be32s(QEMUFile f, uint32_t pv)
231	{
232	*pv = qemu_get_be32(f);
233	}
234
235	static inline void qemu_get_be16s(QEMUFile f, uint16_t pv)
236	{
237	*pv = qemu_get_be16(f);
238	}
239
240	static inline void qemu_get_8s(QEMUFile f, uint8_t pv)
241	{
242	*pv = qemu_get_byte(f);
243	}
244
245	int64_t qemu_ftell(QEMUFile *f);
246	int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
247
248	typedef void SaveStateHandler(QEMUFile f, void opaque);
249	typedef int LoadStateHandler(QEMUFile f, void opaque, int version_id);
250
251	int qemu_loadvm(const char *filename);
252	int qemu_savevm(const char *filename);
253	int register_savevm(const char *idstr,
254	int instance_id,
255	int version_id,
256	SaveStateHandler *save_state,
257	LoadStateHandler *load_state,
258	void *opaque);
259	void qemu_get_timer(QEMUFile f, QEMUTimer ts);
260	void qemu_put_timer(QEMUFile f, QEMUTimer ts);
c4b1fcc0	261
fc01f7e7 FB	262	/* block.c */
	263	typedef struct BlockDriverState BlockDriverState;
	264
c4b1fcc0 FB	265	BlockDriverState bdrv_new(const char device_name);
	266	void bdrv_delete(BlockDriverState *bs);
	267	int bdrv_open(BlockDriverState bs, const char filename, int snapshot);
fc01f7e7 FB	268	void bdrv_close(BlockDriverState *bs);
	269	int bdrv_read(BlockDriverState *bs, int64_t sector_num,
	270	uint8_t *buf, int nb_sectors);
	271	int bdrv_write(BlockDriverState *bs, int64_t sector_num,
	272	const uint8_t *buf, int nb_sectors);
	273	void bdrv_get_geometry(BlockDriverState bs, int64_t nb_sectors_ptr);
33e3963e	274	int bdrv_commit(BlockDriverState *bs);
77fef8c1	275	void bdrv_set_boot_sector(BlockDriverState bs, const uint8_t data, int size);
33e3963e	276
c4b1fcc0 FB	277	#define BDRV_TYPE_HD 0
	278	#define BDRV_TYPE_CDROM 1
	279	#define BDRV_TYPE_FLOPPY 2
	280
	281	void bdrv_set_geometry_hint(BlockDriverState *bs,
	282	int cyls, int heads, int secs);
	283	void bdrv_set_type_hint(BlockDriverState *bs, int type);
	284	void bdrv_get_geometry_hint(BlockDriverState *bs,
	285	int pcyls, int pheads, int *psecs);
	286	int bdrv_get_type_hint(BlockDriverState *bs);
	287	int bdrv_is_removable(BlockDriverState *bs);
	288	int bdrv_is_read_only(BlockDriverState *bs);
	289	int bdrv_is_inserted(BlockDriverState *bs);
	290	int bdrv_is_locked(BlockDriverState *bs);
	291	void bdrv_set_locked(BlockDriverState *bs, int locked);
	292	void bdrv_set_change_cb(BlockDriverState *bs,
	293	void (change_cb)(void opaque), void *opaque);
	294
	295	void bdrv_info(void);
	296	BlockDriverState bdrv_find(const char name);
	297
313aa567 FB	298	/* vga.c */
313aa567 FB	299
4fa0f5d2	300	#define VGA_RAM_SIZE (4096 * 1024)
313aa567 FB	301
	302	typedef struct DisplayState {
	303	uint8_t *data;
	304	int linesize;
	305	int depth;
	306	void (dpy_update)(struct DisplayState s, int x, int y, int w, int h);
	307	void (dpy_resize)(struct DisplayState s, int w, int h);
	308	void (dpy_refresh)(struct DisplayState s);
	309	} DisplayState;
	310
	311	static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
	312	{
	313	s->dpy_update(s, x, y, w, h);
	314	}
	315
	316	static inline void dpy_resize(DisplayState *s, int w, int h)
	317	{
	318	s->dpy_resize(s, w, h);
	319	}
	320
7138fcfb FB	321	int vga_initialize(DisplayState ds, uint8_t vga_ram_base,
7138fcfb FB	322	unsigned long vga_ram_offset, int vga_ram_size);
313aa567	323	void vga_update_display(void);
59a983b9	324	void vga_screen_dump(const char *filename);
313aa567 FB	325
	326	/* sdl.c */
	327	void sdl_display_init(DisplayState *ds);
	328
5391d806 FB	329	/* ide.c */
	330	#define MAX_DISKS 4
	331
	332	extern BlockDriverState *bs_table[MAX_DISKS];
	333
c4b1fcc0 FB	334	void ide_init(int iobase, int iobase2, int irq,
c4b1fcc0 FB	335	BlockDriverState hd0, BlockDriverState hd1);
5391d806	336
27503323 FB	337	/* oss.c */
	338	typedef enum {
	339	AUD_FMT_U8,
	340	AUD_FMT_S8,
	341	AUD_FMT_U16,
	342	AUD_FMT_S16
	343	} audfmt_e;
	344
	345	void AUD_open (int rfreq, int rnchannels, audfmt_e rfmt);
	346	void AUD_reset (int rfreq, int rnchannels, audfmt_e rfmt);
	347	int AUD_write (void *in_buf, int size);
	348	void AUD_run (void);
	349	void AUD_adjust_estimate (int _leftover);
	350	int AUD_get_free (void);
	351	int AUD_get_live (void);
	352	int AUD_get_buffer_size (void);
	353	void AUD_init (void);
	354
	355	/* dma.c */
16f62432	356	typedef int (DMA_transfer_handler) (void opaque, target_ulong addr, int size);
27503323 FB	357	int DMA_get_channel_mode (int nchan);
	358	void DMA_hold_DREQ (int nchan);
	359	void DMA_release_DREQ (int nchan);
16f62432	360	void DMA_schedule(int nchan);
27503323 FB	361	void DMA_run (void);
	362	void DMA_init (void);
	363	void DMA_register_channel (int nchan,
16f62432	364	DMA_transfer_handler transfer_handler, void *opaque);
27503323 FB	365
	366	/* sb16.c */
	367	void SB16_run (void);
	368	void SB16_init (void);
	369
7138fcfb FB	370	/* fdc.c */
	371	#define MAX_FD 2
	372	extern BlockDriverState *fd_table[MAX_FD];
	373
baca51fa FB	374	typedef struct fdctrl_t fdctrl_t;
	375
	376	fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
	377	uint32_t io_base,
	378	BlockDriverState **fds);
	379	int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
7138fcfb	380
80cabfad FB	381	/* ne2000.c */
80cabfad FB	382
c4b1fcc0	383	void ne2000_init(int base, int irq, NetDriverState *nd);
80cabfad FB	384
	385	/* pckbd.c */
	386
	387	void kbd_put_keycode(int keycode);
	388
	389	#define MOUSE_EVENT_LBUTTON 0x01
	390	#define MOUSE_EVENT_RBUTTON 0x02
	391	#define MOUSE_EVENT_MBUTTON 0x04
	392	void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
	393
	394	void kbd_init(void);
	395
	396	/* mc146818rtc.c */
	397
8a7ddc38	398	typedef struct RTCState RTCState;
80cabfad	399
8a7ddc38 FB	400	RTCState *rtc_init(int base, int irq);
	401	void rtc_set_memory(RTCState *s, int addr, int val);
	402	void rtc_set_date(RTCState s, const struct tm tm);
80cabfad FB	403
	404	/* serial.c */
	405
c4b1fcc0 FB	406	typedef struct SerialState SerialState;
	407
	408	extern SerialState *serial_console;
	409
	410	SerialState *serial_init(int base, int irq, int fd);
	411	int serial_can_receive(SerialState *s);
	412	void serial_receive_byte(SerialState *s, int ch);
	413	void serial_receive_break(SerialState *s);
80cabfad FB	414
	415	/* i8259.c */
	416
	417	void pic_set_irq(int irq, int level);
	418	void pic_init(void);
	419
	420	/* i8254.c */
	421
	422	#define PIT_FREQ 1193182
	423
	424	typedef struct PITChannelState {
	425	int count; /* can be 65536 */
	426	uint16_t latched_count;
	427	uint8_t rw_state;
	428	uint8_t mode;
	429	uint8_t bcd; /* not supported */
	430	uint8_t gate; /* timer start */
	431	int64_t count_load_time;
8a7ddc38 FB	432	/* irq handling */
	433	int64_t next_transition_time;
	434	QEMUTimer *irq_timer;
	435	int irq;
80cabfad FB	436	} PITChannelState;
	437
	438	extern PITChannelState pit_channels[3];
	439
8a7ddc38	440	void pit_init(int base, int irq);
80cabfad	441	void pit_set_gate(PITChannelState *s, int val);
8a7ddc38	442	int pit_get_out(PITChannelState *s, int64_t current_time);
80cabfad FB	443	int pit_get_out_edges(PITChannelState *s);
	444
	445	/* pc.c */
	446	void pc_init(int ram_size, int vga_ram_size, int boot_device,
	447	DisplayState ds, const char *fd_filename, int snapshot,
	448	const char kernel_filename, const char kernel_cmdline,
	449	const char *initrd_filename);
	450
c4b1fcc0 FB	451	/* monitor.c */
c4b1fcc0 FB	452	void monitor_init(void);
40c3bac3	453	void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
c4b1fcc0 FB	454	void term_flush(void);
	455	void term_print_help(void);
	456
8a7ddc38 FB	457	/* gdbstub.c */
	458
	459	#define DEFAULT_GDBSTUB_PORT 1234
	460
	461	int gdbserver_start(int port);
	462
fc01f7e7	463	#endif /* VL_H */