vl.h 13.6 KB
Newer Older
bellard's avatar
bellard committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * 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

bellard's avatar
bellard committed
27 28 29 30 31 32
/* 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>
33
#include <time.h>
bellard's avatar
bellard committed
34 35 36 37
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
bellard's avatar
bellard committed
38
#include <sys/stat.h>
bellard's avatar
bellard committed
39 40 41 42

#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
bellard's avatar
bellard committed
43 44 45
#ifndef O_BINARY
#define O_BINARY 0
#endif
bellard's avatar
bellard committed
46 47

#ifdef _WIN32
bellard's avatar
bellard committed
48
#define lseek64 _lseeki64
bellard's avatar
bellard committed
49
#endif
50

bellard's avatar
bellard committed
51 52
#include "cpu.h"

bellard's avatar
bellard committed
53 54 55 56 57 58 59
#ifdef _BSD
#define lseek64 lseek
#define ftruncate64 ftruncate
#define mkstemp64 mkstemp
#define MAP_ANONYMOUS MAP_ANON
#endif

bellard's avatar
bellard committed
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
#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;
}

bellard's avatar
bellard committed
78 79 80 81 82 83 84 85 86 87
static inline uint32_t cpu_to_be32(uint32_t v)
{
    return v;
}

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

bellard's avatar
bellard committed
88 89 90 91 92 93 94 95 96 97
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);
}

bellard's avatar
bellard committed
98 99 100 101 102 103 104 105 106 107
static inline uint32_t cpu_to_le32(uint32_t v)
{
    return bswap32(v);
}

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

bellard's avatar
bellard committed
108
#else
bellard's avatar
bellard committed
109

bellard's avatar
bellard committed
110 111 112 113 114 115 116 117 118 119
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);
}

bellard's avatar
bellard committed
120 121 122 123 124 125 126 127 128 129
static inline uint32_t cpu_to_be32(uint32_t v)
{
    return bswap32(v);
}

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

bellard's avatar
bellard committed
130 131 132 133 134 135 136 137 138
static inline uint32_t le32_to_cpu(uint32_t v)
{
    return v;
}

static inline uint16_t le16_to_cpu(uint16_t v)
{
    return v;
}
bellard's avatar
bellard committed
139 140 141 142 143 144 145 146 147 148

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

static inline uint16_t cpu_to_le16(uint16_t v)
{
    return v;
}
bellard's avatar
bellard committed
149 150 151
#endif


152
/* vl.c */
153 154
extern int reset_requested;

bellard's avatar
bellard committed
155
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
156

bellard's avatar
bellard committed
157 158 159 160 161 162 163
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);
164

165 166
int serial_open_device(void);

167 168 169 170 171 172 173 174 175 176
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);

bellard's avatar
bellard committed
177 178
extern int audio_enabled;

bellard's avatar
bellard committed
179 180 181 182 183 184 185 186 187
/* 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);

188 189 190 191 192
/* network redirectors support */

#define MAX_NICS 8

typedef struct NetDriverState {
bellard's avatar
bellard committed
193
    int index; /* index number in QEMU */
194 195
    uint8_t macaddr[6];
    char ifname[16];
bellard's avatar
bellard committed
196 197 198 199 200 201 202 203
    void (*send_packet)(struct NetDriverState *nd, 
                        const uint8_t *buf, int size);
    void (*add_read_packet)(struct NetDriverState *nd, 
                            IOCanRWHandler *fd_can_read, 
                            IOReadHandler *fd_read, void *opaque);
    /* tun specific data */
    int fd;
    /* slirp specific data */
204 205 206 207 208
} NetDriverState;

extern int nb_nics;
extern NetDriverState nd_table[MAX_NICS];

bellard's avatar
bellard committed
209 210 211
void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size);
void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read, 
                          IOReadHandler *fd_read, void *opaque);
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314

/* 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);
315

bellard's avatar
bellard committed
316 317 318
/* block.c */
typedef struct BlockDriverState BlockDriverState;

319 320 321
BlockDriverState *bdrv_new(const char *device_name);
void bdrv_delete(BlockDriverState *bs);
int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
bellard's avatar
bellard committed
322 323 324 325 326 327
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);
328
int bdrv_commit(BlockDriverState *bs);
329
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
330

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
#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);

352 353 354 355 356 357 358 359 360 361 362 363
/* ISA bus */

extern target_phys_addr_t isa_mem_base;

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

364 365
/* vga.c */

bellard's avatar
bellard committed
366
#define VGA_RAM_SIZE (4096 * 1024)
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386

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

bellard's avatar
bellard committed
387 388
int vga_initialize(DisplayState *ds, uint8_t *vga_ram_base, 
                   unsigned long vga_ram_offset, int vga_ram_size);
389
void vga_update_display(void);
bellard's avatar
bellard committed
390
void vga_screen_dump(const char *filename);
391 392 393 394

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

bellard's avatar
bellard committed
395 396 397 398 399
/* ide.c */
#define MAX_DISKS 4

extern BlockDriverState *bs_table[MAX_DISKS];

400 401
void ide_init(int iobase, int iobase2, int irq,
              BlockDriverState *hd0, BlockDriverState *hd1);
bellard's avatar
bellard committed
402

bellard's avatar
bellard committed
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
/* 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 */
bellard's avatar
bellard committed
422
typedef int (*DMA_transfer_handler) (void *opaque, target_ulong addr, int size);
bellard's avatar
bellard committed
423 424 425
int DMA_get_channel_mode (int nchan);
void DMA_hold_DREQ (int nchan);
void DMA_release_DREQ (int nchan);
bellard's avatar
bellard committed
426
void DMA_schedule(int nchan);
bellard's avatar
bellard committed
427 428 429
void DMA_run (void);
void DMA_init (void);
void DMA_register_channel (int nchan,
bellard's avatar
bellard committed
430
                           DMA_transfer_handler transfer_handler, void *opaque);
bellard's avatar
bellard committed
431 432 433 434 435

/* sb16.c */
void SB16_run (void);
void SB16_init (void);
 
bellard's avatar
bellard committed
436 437 438 439
/* fdc.c */
#define MAX_FD 2
extern BlockDriverState *fd_table[MAX_FD];

440 441 442 443 444 445
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);
bellard's avatar
bellard committed
446

bellard's avatar
bellard committed
447 448
/* ne2000.c */

449
void ne2000_init(int base, int irq, NetDriverState *nd);
bellard's avatar
bellard committed
450 451 452 453 454 455 456 457 458 459 460 461 462 463

/* 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 */

464
typedef struct RTCState RTCState;
bellard's avatar
bellard committed
465

466 467 468
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);
bellard's avatar
bellard committed
469 470 471

/* serial.c */

472 473 474 475 476 477 478 479
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);
bellard's avatar
bellard committed
480 481 482 483 484

/* i8259.c */

void pic_set_irq(int irq, int level);
void pic_init(void);
485
uint32_t pic_intack_read(CPUState *env);
bellard's avatar
bellard committed
486
void pic_info(void);
bellard's avatar
bellard committed
487 488 489 490 491

/* i8254.c */

#define PIT_FREQ 1193182

bellard's avatar
bellard committed
492 493 494 495 496 497
typedef struct PITState PITState;

PITState *pit_init(int base, int irq);
void pit_set_gate(PITState *pit, int channel, int val);
int pit_get_gate(PITState *pit, int channel);
int pit_get_out(PITState *pit, int channel, int64_t current_time);
bellard's avatar
bellard committed
498 499 500 501 502 503 504

/* 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);

505 506 507 508 509 510
/* ppc.c */
void ppc_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);

511 512
/* monitor.c */
void monitor_init(void);
bellard's avatar
bellard committed
513
void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
514 515 516
void term_flush(void);
void term_print_help(void);

517 518 519 520 521 522
/* gdbstub.c */

#define DEFAULT_GDBSTUB_PORT 1234

int gdbserver_start(int port);

bellard's avatar
bellard committed
523
#endif /* VL_H */