vl.h

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