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 <limits.h>
  34 #include <time.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <unistd.h>
  38 #include <fcntl.h>
  39 #include <sys/stat.h>
  40
  41 #ifndef O_LARGEFILE
  42 #define O_LARGEFILE 0
  43 #endif
  44 #ifndef O_BINARY
  45 #define O_BINARY 0
  46 #endif
  47
  48 #ifndef ENOMEDIUM
  49 #define ENOMEDIUM ENODEV
  50 #endif
  51
  52 #ifdef _WIN32
  53 #include <windows.h>
  54 #define fsync _commit
  55 #define lseek _lseeki64
  56 #define ENOTSUP 4096
  57 extern int qemu_ftruncate64(int, int64_t);
  58 #define ftruncate qemu_ftruncate64
  59
  60
  61 static inline char *realpath(const char *path, char *resolved_path)
  62 {
  63     _fullpath(resolved_path, path, _MAX_PATH);
  64     return resolved_path;
  65 }
  66
  67 #define PRId64 "I64d"
  68 #define PRIx64 "I64x"
  69 #define PRIu64 "I64u"
  70 #define PRIo64 "I64o"
  71 #endif
  72
  73 #ifdef QEMU_TOOL
  74
  75 /* we use QEMU_TOOL in the command line tools which do not depend on
  76    the target CPU type */
  77 #include "config-host.h"
  78 #include <setjmp.h>
  79 #include "osdep.h"
  80 #include "bswap.h"
  81
  82 #else
  83
  84 #include "audio/audio.h"
  85 #include "cpu.h"
  86
  87 #endif /* !defined(QEMU_TOOL) */
  88
  89 #ifndef glue
  90 #define xglue(x, y) x ## y
  91 #define glue(x, y) xglue(x, y)
  92 #define stringify(s)    tostring(s)
  93 #define tostring(s)     #s
  94 #endif
  95
  96 #ifndef MIN
  97 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  98 #endif
  99 #ifndef MAX
 100 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 101 #endif
 102
 103 /* cutils.c */
 104 void pstrcpy(char *buf, int buf_size, const char *str);
 105 char *pstrcat(char *buf, int buf_size, const char *s);
 106 int strstart(const char *str, const char *val, const char **ptr);
 107 int stristart(const char *str, const char *val, const char **ptr);
 108 int hex2bin(char ch);
 109 char *urldecode(const char *ptr);
 110
 111 /* vl.c */
 112 void qemu_get_launch_info(int *argc, char ***argv, int *opt_daemonize, const char **opt_incoming);
 113
 114 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
 115
 116 void hw_error(const char *fmt, ...);
 117
 118 extern const char *bios_dir;
 119
 120 extern int vm_running;
 121
 122 typedef struct vm_change_state_entry VMChangeStateEntry;
 123 typedef void VMChangeStateHandler(void *opaque, int running);
 124 typedef void VMStopHandler(void *opaque, int reason);
 125
 126 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 127                                                      void *opaque);
 128 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
 129
 130 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
 131 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
 132
 133 void vm_start(void);
 134 void vm_stop(int reason);
 135
 136 typedef void QEMUResetHandler(void *opaque);
 137
 138 void qemu_register_reset(QEMUResetHandler *func, void *opaque);
 139 void qemu_system_reset_request(void);
 140 void qemu_system_shutdown_request(void);
 141 void qemu_system_powerdown_request(void);
 142 #if !defined(TARGET_SPARC)
 143 // Please implement a power failure function to signal the OS
 144 #define qemu_system_powerdown() do{}while(0)
 145 #else
 146 void qemu_system_powerdown(void);
 147 #endif
 148
 149 void main_loop_wait(int timeout);
 150
 151 extern int ram_size;
 152 extern int bios_size;
 153 extern int rtc_utc;
 154 extern int cirrus_vga_enabled;
 155 extern int graphic_width;
 156 extern int graphic_height;
 157 extern int graphic_depth;
 158 extern const char *keyboard_layout;
 159 extern int kqemu_allowed;
 160 extern int kvm_allowed;
 161 extern int win2k_install_hack;
 162 extern int usb_enabled;
 163 extern int smp_cpus;
 164 extern int no_quit;
 165 extern int semihosting_enabled;
 166 extern int autostart;
 167 extern int time_drift_fix;
 168
 169 #define MAX_OPTION_ROMS 16
 170 extern const char *option_rom[MAX_OPTION_ROMS];
 171 extern int nb_option_roms;
 172
 173 /* XXX: make it dynamic */
 174 #if defined (TARGET_PPC) || defined (TARGET_SPARC64)
 175 #define BIOS_SIZE ((512 + 32) * 1024)
 176 #elif defined(TARGET_MIPS)
 177 #define BIOS_SIZE (4 * 1024 * 1024)
 178 #else
 179 #define BIOS_SIZE ((256 + 64) * 1024)
 180 #endif
 181
 182 #if USE_KVM
 183 #define KVM_EXTRA_PAGES 3
 184 #endif
 185
 186 /* keyboard/mouse support */
 187
 188 #define MOUSE_EVENT_LBUTTON 0x01
 189 #define MOUSE_EVENT_RBUTTON 0x02
 190 #define MOUSE_EVENT_MBUTTON 0x04
 191
 192 typedef void QEMUPutKBDEvent(void *opaque, int keycode);
 193 typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
 194
 195 typedef struct QEMUPutMouseEntry {
 196     QEMUPutMouseEvent *qemu_put_mouse_event;
 197     void *qemu_put_mouse_event_opaque;
 198     int qemu_put_mouse_event_absolute;
 199     char *qemu_put_mouse_event_name;
 200
 201     /* used internally by qemu for handling mice */
 202     struct QEMUPutMouseEntry *next;
 203 } QEMUPutMouseEntry;
 204
 205 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
 206 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
 207                                                 void *opaque, int absolute,
 208                                                 const char *name);
 209 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry);
 210
 211 void kbd_put_keycode(int keycode);
 212 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
 213 int kbd_mouse_is_absolute(void);
 214
 215 void do_info_mice(void);
 216 void do_mouse_set(int index);
 217
 218 /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
 219    constants) */
 220 #define QEMU_KEY_ESC1(c) ((c) | 0xe100)
 221 #define QEMU_KEY_BACKSPACE  0x007f
 222 #define QEMU_KEY_UP         QEMU_KEY_ESC1('A')
 223 #define QEMU_KEY_DOWN       QEMU_KEY_ESC1('B')
 224 #define QEMU_KEY_RIGHT      QEMU_KEY_ESC1('C')
 225 #define QEMU_KEY_LEFT       QEMU_KEY_ESC1('D')
 226 #define QEMU_KEY_HOME       QEMU_KEY_ESC1(1)
 227 #define QEMU_KEY_END        QEMU_KEY_ESC1(4)
 228 #define QEMU_KEY_PAGEUP     QEMU_KEY_ESC1(5)
 229 #define QEMU_KEY_PAGEDOWN   QEMU_KEY_ESC1(6)
 230 #define QEMU_KEY_DELETE     QEMU_KEY_ESC1(3)
 231
 232 #define QEMU_KEY_CTRL_UP         0xe400
 233 #define QEMU_KEY_CTRL_DOWN       0xe401
 234 #define QEMU_KEY_CTRL_LEFT       0xe402
 235 #define QEMU_KEY_CTRL_RIGHT      0xe403
 236 #define QEMU_KEY_CTRL_HOME       0xe404
 237 #define QEMU_KEY_CTRL_END        0xe405
 238 #define QEMU_KEY_CTRL_PAGEUP     0xe406
 239 #define QEMU_KEY_CTRL_PAGEDOWN   0xe407
 240
 241 void kbd_put_keysym(int keysym);
 242
 243 /* async I/O support */
 244
 245 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
 246 typedef int IOCanRWHandler(void *opaque);
 247 typedef void IOHandler(void *opaque);
 248
 249 int qemu_set_fd_handler2(int fd,
 250                          IOCanRWHandler *fd_read_poll,
 251                          IOHandler *fd_read,
 252                          IOHandler *fd_write,
 253                          void *opaque);
 254 int qemu_set_fd_handler(int fd,
 255                         IOHandler *fd_read,
 256                         IOHandler *fd_write,
 257                         void *opaque);
 258
 259 /* Polling handling */
 260
 261 /* return TRUE if no sleep should be done afterwards */
 262 typedef int PollingFunc(void *opaque);
 263
 264 int qemu_add_polling_cb(PollingFunc *func, void *opaque);
 265 void qemu_del_polling_cb(PollingFunc *func, void *opaque);
 266
 267 #ifdef _WIN32
 268 /* Wait objects handling */
 269 typedef void WaitObjectFunc(void *opaque);
 270
 271 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
 272 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
 273 #endif
 274
 275 typedef struct QEMUBH QEMUBH;
 276
 277 /* character device */
 278
 279 #define CHR_EVENT_BREAK 0 /* serial break char */
 280 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
 281 #define CHR_EVENT_RESET 2 /* new connection established */
 282
 283
 284 #define CHR_IOCTL_SERIAL_SET_PARAMS   1
 285 typedef struct {
 286     int speed;
 287     int parity;
 288     int data_bits;
 289     int stop_bits;
 290 } QEMUSerialSetParams;
 291
 292 #define CHR_IOCTL_SERIAL_SET_BREAK    2
 293
 294 #define CHR_IOCTL_PP_READ_DATA        3
 295 #define CHR_IOCTL_PP_WRITE_DATA       4
 296 #define CHR_IOCTL_PP_READ_CONTROL     5
 297 #define CHR_IOCTL_PP_WRITE_CONTROL    6
 298 #define CHR_IOCTL_PP_READ_STATUS      7
 299
 300 typedef void IOEventHandler(void *opaque, int event);
 301
 302 typedef struct CharDriverState {
 303     int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
 304     void (*chr_update_read_handler)(struct CharDriverState *s);
 305     int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
 306     IOEventHandler *chr_event;
 307     IOCanRWHandler *chr_can_read;
 308     IOReadHandler *chr_read;
 309     void *handler_opaque;
 310     void (*chr_send_event)(struct CharDriverState *chr, int event);
 311     void (*chr_close)(struct CharDriverState *chr);
 312     void *opaque;
 313     QEMUBH *bh;
 314 } CharDriverState;
 315
 316 CharDriverState *qemu_chr_open(const char *filename);
 317 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
 318 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
 319 void qemu_chr_send_event(CharDriverState *s, int event);
 320 void qemu_chr_add_handlers(CharDriverState *s,
 321                            IOCanRWHandler *fd_can_read,
 322                            IOReadHandler *fd_read,
 323                            IOEventHandler *fd_event,
 324                            void *opaque);
 325 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
 326 void qemu_chr_reset(CharDriverState *s);
 327 int qemu_chr_can_read(CharDriverState *s);
 328 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len);
 329
 330 /* consoles */
 331
 332 typedef struct DisplayState DisplayState;
 333 typedef struct TextConsole TextConsole;
 334
 335 typedef void (*vga_hw_update_ptr)(void *);
 336 typedef void (*vga_hw_invalidate_ptr)(void *);
 337 typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
 338
 339 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
 340                                   vga_hw_invalidate_ptr invalidate,
 341                                   vga_hw_screen_dump_ptr screen_dump,
 342                                   void *opaque);
 343 void vga_hw_update(void);
 344 void vga_hw_invalidate(void);
 345 void vga_hw_screen_dump(const char *filename);
 346
 347 int is_graphic_console(void);
 348 CharDriverState *text_console_init(DisplayState *ds);
 349 void console_select(unsigned int index);
 350
 351 /* vmchannel devices */
 352
 353 #define MAX_VMCHANNEL_DEVICES 4
 354
 355 /* serial ports */
 356
 357 #define MAX_SERIAL_PORTS 4
 358
 359 extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 360
 361 /* parallel ports */
 362
 363 #define MAX_PARALLEL_PORTS 3
 364
 365 extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 366
 367 /* VLANs support */
 368
 369 typedef struct VLANClientState VLANClientState;
 370
 371 struct VLANClientState {
 372     IOReadHandler *fd_read;
 373     /* Packets may still be sent if this returns zero.  It's used to
 374        rate-limit the slirp code.  */
 375     IOCanRWHandler *fd_can_read;
 376     void *opaque;
 377     struct VLANClientState *next;
 378     struct VLANState *vlan;
 379     char info_str[256];
 380 };
 381
 382 typedef struct VLANState {
 383     int id;
 384     VLANClientState *first_client;
 385     struct VLANState *next;
 386 } VLANState;
 387
 388 VLANState *qemu_find_vlan(int id);
 389 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
 390                                       IOReadHandler *fd_read,
 391                                       IOCanRWHandler *fd_can_read,
 392                                       void *opaque);
 393 int qemu_can_send_packet(VLANClientState *vc);
 394 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size);
 395 void qemu_handler_true(void *opaque);
 396
 397 void do_info_network(void);
 398
 399 /* TAP win32 */
 400 int tap_win32_init(VLANState *vlan, const char *ifname);
 401
 402 /* NIC info */
 403
 404 #define MAX_NICS 8
 405
 406 typedef struct NICInfo {
 407     uint8_t macaddr[6];
 408     const char *model;
 409     VLANState *vlan;
 410 } NICInfo;
 411
 412 extern int nb_nics;
 413 extern NICInfo nd_table[MAX_NICS];
 414
 415 /* timers */
 416
 417 typedef struct QEMUClock QEMUClock;
 418 typedef struct QEMUTimer QEMUTimer;
 419 typedef void QEMUTimerCB(void *opaque);
 420
 421 /* The real time clock should be used only for stuff which does not
 422    change the virtual machine state, as it is run even if the virtual
 423    machine is stopped. The real time clock has a frequency of 1000
 424    Hz. */
 425 extern QEMUClock *rt_clock;
 426
 427 /* The virtual clock is only run during the emulation. It is stopped
 428    when the virtual machine is stopped. Virtual timers use a high
 429    precision clock, usually cpu cycles (use ticks_per_sec). */
 430 extern QEMUClock *vm_clock;
 431
 432 int64_t qemu_get_clock(QEMUClock *clock);
 433
 434 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
 435 void qemu_free_timer(QEMUTimer *ts);
 436 void qemu_del_timer(QEMUTimer *ts);
 437 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
 438 int qemu_timer_pending(QEMUTimer *ts);
 439
 440 extern int64_t ticks_per_sec;
 441 extern int pit_min_timer_count;
 442
 443 int64_t cpu_get_ticks(void);
 444 void cpu_enable_ticks(void);
 445 void cpu_disable_ticks(void);
 446
 447 /* VM Load/Save */
 448
 449 typedef struct QEMUFile QEMUFile;
 450
 451 typedef void (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, int64_t pos, int size);
 452 typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, int64_t pos, int size);
 453 typedef void (QEMUFileCloseFunc)(void *opaque);
 454
 455 QEMUFile *qemu_fopen(void *opaque, QEMUFilePutBufferFunc *put_buffer,
 456                      QEMUFileGetBufferFunc *get_buffer, QEMUFileCloseFunc *close);
 457 QEMUFile *qemu_fopen_file(const char *filename, const char *mode);
 458 QEMUFile *qemu_fopen_fd(int fd);
 459 void qemu_fflush(QEMUFile *f);
 460 void qemu_fclose(QEMUFile *f);
 461 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
 462 void qemu_put_byte(QEMUFile *f, int v);
 463 void qemu_put_be16(QEMUFile *f, unsigned int v);
 464 void qemu_put_be32(QEMUFile *f, unsigned int v);
 465 void qemu_put_be64(QEMUFile *f, uint64_t v);
 466 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
 467 int qemu_get_byte(QEMUFile *f);
 468 unsigned int qemu_get_be16(QEMUFile *f);
 469 unsigned int qemu_get_be32(QEMUFile *f);
 470 uint64_t qemu_get_be64(QEMUFile *f);
 471
 472 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
 473 {
 474     qemu_put_be64(f, *pv);
 475 }
 476
 477 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
 478 {
 479     qemu_put_be32(f, *pv);
 480 }
 481
 482 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
 483 {
 484     qemu_put_be16(f, *pv);
 485 }
 486
 487 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
 488 {
 489     qemu_put_byte(f, *pv);
 490 }
 491
 492 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
 493 {
 494     *pv = qemu_get_be64(f);
 495 }
 496
 497 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
 498 {
 499     *pv = qemu_get_be32(f);
 500 }
 501
 502 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
 503 {
 504     *pv = qemu_get_be16(f);
 505 }
 506
 507 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
 508 {
 509     *pv = qemu_get_byte(f);
 510 }
 511
 512 #if TARGET_LONG_BITS == 64
 513 #define qemu_put_betl qemu_put_be64
 514 #define qemu_get_betl qemu_get_be64
 515 #define qemu_put_betls qemu_put_be64s
 516 #define qemu_get_betls qemu_get_be64s
 517 #else
 518 #define qemu_put_betl qemu_put_be32
 519 #define qemu_get_betl qemu_get_be32
 520 #define qemu_put_betls qemu_put_be32s
 521 #define qemu_get_betls qemu_get_be32s
 522 #endif
 523
 524 int64_t qemu_ftell(QEMUFile *f);
 525 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
 526
 527 typedef void SaveStateHandler(QEMUFile *f, void *opaque);
 528 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
 529
 530 int register_savevm(const char *idstr,
 531                     int instance_id,
 532                     int version_id,
 533                     SaveStateHandler *save_state,
 534                     LoadStateHandler *load_state,
 535                     void *opaque);
 536 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
 537 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
 538
 539 void cpu_save(QEMUFile *f, void *opaque);
 540 int cpu_load(QEMUFile *f, void *opaque, int version_id);
 541
 542 void do_savevm(const char *name);
 543 void do_loadvm(const char *name);
 544 void do_delvm(const char *name);
 545 void do_info_snapshots(void);
 546
 547 int qemu_live_savevm_state(QEMUFile *f);
 548 int qemu_live_loadvm_state(QEMUFile *f);
 549
 550 /* bottom halves */
 551 typedef void QEMUBHFunc(void *opaque);
 552
 553 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
 554 void qemu_bh_schedule(QEMUBH *bh);
 555 void qemu_bh_cancel(QEMUBH *bh);
 556 void qemu_bh_delete(QEMUBH *bh);
 557 int qemu_bh_poll(void);
 558
 559 /* block.c */
 560 typedef struct BlockDriverState BlockDriverState;
 561 typedef struct BlockDriver BlockDriver;
 562
 563 extern BlockDriver bdrv_raw;
 564 extern BlockDriver bdrv_host_device;
 565 extern BlockDriver bdrv_cow;
 566 extern BlockDriver bdrv_qcow;
 567 extern BlockDriver bdrv_vmdk;
 568 extern BlockDriver bdrv_cloop;
 569 extern BlockDriver bdrv_dmg;
 570 extern BlockDriver bdrv_bochs;
 571 extern BlockDriver bdrv_vpc;
 572 extern BlockDriver bdrv_vvfat;
 573 extern BlockDriver bdrv_qcow2;
 574
 575 typedef struct BlockDriverInfo {
 576     /* in bytes, 0 if irrelevant */
 577     int cluster_size;
 578     /* offset at which the VM state can be saved (0 if not possible) */
 579     int64_t vm_state_offset;
 580 } BlockDriverInfo;
 581
 582 typedef struct QEMUSnapshotInfo {
 583     char id_str[128]; /* unique snapshot id */
 584     /* the following fields are informative. They are not needed for
 585        the consistency of the snapshot */
 586     char name[256]; /* user choosen name */
 587     uint32_t vm_state_size; /* VM state info size */
 588     uint32_t date_sec; /* UTC date of the snapshot */
 589     uint32_t date_nsec;
 590     uint64_t vm_clock_nsec; /* VM clock relative to boot */
 591 } QEMUSnapshotInfo;
 592
 593 typedef struct DiskIOStatistics {
 594     uint64_t read_byte_counter;
 595     uint64_t write_byte_counter;
 596 }DiskIOStatistics;
 597
 598 #define BDRV_O_RDONLY      0x0000
 599 #define BDRV_O_RDWR        0x0002
 600 #define BDRV_O_ACCESS      0x0003
 601 #define BDRV_O_CREAT       0x0004 /* create an empty file */
 602 #define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
 603 #define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
 604                                      use a disk image format on top of
 605                                      it (default for
 606                                      bdrv_file_open()) */
 607
 608 void bdrv_init(void);
 609 BlockDriver *bdrv_find_format(const char *format_name);
 610 int bdrv_create(BlockDriver *drv,
 611                 const char *filename, int64_t size_in_sectors,
 612                 const char *backing_file, int flags);
 613 BlockDriverState *bdrv_new(const char *device_name);
 614 void bdrv_delete(BlockDriverState *bs);
 615 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
 616 int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
 617 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
 618                BlockDriver *drv);
 619 void bdrv_close(BlockDriverState *bs);
 620 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 621               uint8_t *buf, int nb_sectors);
 622 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 623                const uint8_t *buf, int nb_sectors);
 624 int bdrv_pread(BlockDriverState *bs, int64_t offset,
 625                void *buf, int count);
 626 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
 627                 const void *buf, int count);
 628 int bdrv_truncate(BlockDriverState *bs, int64_t offset);
 629 int64_t bdrv_getlength(BlockDriverState *bs);
 630 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
 631 int bdrv_commit(BlockDriverState *bs);
 632 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
 633 /* async block I/O */
 634 typedef struct BlockDriverAIOCB BlockDriverAIOCB;
 635 typedef void BlockDriverCompletionFunc(void *opaque, int ret);
 636
 637 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
 638                                 uint8_t *buf, int nb_sectors,
 639                                 BlockDriverCompletionFunc *cb, void *opaque);
 640 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
 641                                  const uint8_t *buf, int nb_sectors,
 642                                  BlockDriverCompletionFunc *cb, void *opaque);
 643 void bdrv_aio_cancel(BlockDriverAIOCB *acb);
 644
 645 void qemu_aio_init(void);
 646 void qemu_aio_poll(void);
 647 void qemu_aio_flush(void);
 648 void qemu_aio_wait_start(void);
 649 void qemu_aio_wait(void);
 650 void qemu_aio_wait_end(void);
 651
 652 /* Ensure contents are flushed to disk.  */
 653 void bdrv_flush(BlockDriverState *bs);
 654
 655 #define BDRV_TYPE_HD     0
 656 #define BDRV_TYPE_CDROM  1
 657 #define BDRV_TYPE_FLOPPY 2
 658 #define BIOS_ATA_TRANSLATION_AUTO   0
 659 #define BIOS_ATA_TRANSLATION_NONE   1
 660 #define BIOS_ATA_TRANSLATION_LBA    2
 661 #define BIOS_ATA_TRANSLATION_LARGE  3
 662 #define BIOS_ATA_TRANSLATION_RECHS  4
 663
 664 void bdrv_set_geometry_hint(BlockDriverState *bs,
 665                             int cyls, int heads, int secs);
 666 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 667 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
 668 void bdrv_get_geometry_hint(BlockDriverState *bs,
 669                             int *pcyls, int *pheads, int *psecs);
 670 int bdrv_get_type_hint(BlockDriverState *bs);
 671 int bdrv_get_translation_hint(BlockDriverState *bs);
 672 int bdrv_is_removable(BlockDriverState *bs);
 673 int bdrv_is_read_only(BlockDriverState *bs);
 674 int bdrv_is_inserted(BlockDriverState *bs);
 675 int bdrv_media_changed(BlockDriverState *bs);
 676 int bdrv_is_locked(BlockDriverState *bs);
 677 void bdrv_set_locked(BlockDriverState *bs, int locked);
 678 void bdrv_eject(BlockDriverState *bs, int eject_flag);
 679 void bdrv_set_change_cb(BlockDriverState *bs,
 680                         void (*change_cb)(void *opaque), void *opaque);
 681 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
 682 void bdrv_info(void);
 683 BlockDriverState *bdrv_find(const char *name);
 684 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
 685 int bdrv_is_encrypted(BlockDriverState *bs);
 686 int bdrv_set_key(BlockDriverState *bs, const char *key);
 687 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 688                          void *opaque);
 689 const char *bdrv_get_device_name(BlockDriverState *bs);
 690 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
 691                           const uint8_t *buf, int nb_sectors);
 692 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
 693
 694 void bdrv_get_backing_filename(BlockDriverState *bs,
 695                                char *filename, int filename_size);
 696 int bdrv_snapshot_create(BlockDriverState *bs,
 697                          QEMUSnapshotInfo *sn_info);
 698 int bdrv_snapshot_goto(BlockDriverState *bs,
 699                        const char *snapshot_id);
 700 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
 701 int bdrv_snapshot_list(BlockDriverState *bs,
 702                        QEMUSnapshotInfo **psn_info);
 703 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
 704
 705 char *get_human_readable_size(char *buf, int buf_size, int64_t size);
 706 int path_is_absolute(const char *path);
 707 void path_combine(char *dest, int dest_size,
 708                   const char *base_path,
 709                   const char *filename);
 710
 711 #ifndef QEMU_TOOL
 712
 713 typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
 714                                  int boot_device,
 715              DisplayState *ds, const char **fd_filename, int snapshot,
 716              const char *kernel_filename, const char *kernel_cmdline,
 717              const char *initrd_filename);
 718
 719 typedef struct QEMUMachine {
 720     const char *name;
 721     const char *desc;
 722     QEMUMachineInitFunc *init;
 723     struct QEMUMachine *next;
 724 } QEMUMachine;
 725
 726 int qemu_register_machine(QEMUMachine *m);
 727
 728 typedef void SetIRQFunc(void *opaque, int irq_num, int level);
 729 typedef void IRQRequestFunc(void *opaque, int level);
 730
 731 /* ISA bus */
 732
 733 extern target_phys_addr_t isa_mem_base;
 734
 735 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
 736 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
 737
 738 int register_ioport_read(int start, int length, int size,
 739                          IOPortReadFunc *func, void *opaque);
 740 int register_ioport_write(int start, int length, int size,
 741                           IOPortWriteFunc *func, void *opaque);
 742 void isa_unassign_ioport(int start, int length);
 743
 744 void isa_mmio_init(target_phys_addr_t base, target_phys_addr_t size);
 745
 746 /* PCI bus */
 747
 748 extern target_phys_addr_t pci_mem_base;
 749
 750 typedef struct PCIBus PCIBus;
 751 typedef struct PCIDevice PCIDevice;
 752
 753 typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
 754                                 uint32_t address, uint32_t data, int len);
 755 typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
 756                                    uint32_t address, int len);
 757 typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
 758                                 uint32_t addr, uint32_t size, int type);
 759
 760 #define PCI_ADDRESS_SPACE_MEM           0x00
 761 #define PCI_ADDRESS_SPACE_IO            0x01
 762 #define PCI_ADDRESS_SPACE_MEM_PREFETCH  0x08
 763
 764 typedef struct PCIIORegion {
 765     uint32_t addr; /* current PCI mapping address. -1 means not mapped */
 766     uint32_t size;
 767     uint8_t type;
 768     PCIMapIORegionFunc *map_func;
 769 } PCIIORegion;
 770
 771 #define PCI_ROM_SLOT 6
 772 #define PCI_NUM_REGIONS 7
 773
 774 #define PCI_DEVICES_MAX 64
 775
 776 #define PCI_VENDOR_ID           0x00    /* 16 bits */
 777 #define PCI_DEVICE_ID           0x02    /* 16 bits */
 778 #define PCI_COMMAND             0x04    /* 16 bits */
 779 #define  PCI_COMMAND_IO         0x1     /* Enable response in I/O space */
 780 #define  PCI_COMMAND_MEMORY     0x2     /* Enable response in Memory space */
 781 #define PCI_CLASS_DEVICE        0x0a    /* Device class */
 782 #define PCI_INTERRUPT_LINE      0x3c    /* 8 bits */
 783 #define PCI_INTERRUPT_PIN       0x3d    /* 8 bits */
 784 #define PCI_MIN_GNT             0x3e    /* 8 bits */
 785 #define PCI_MAX_LAT             0x3f    /* 8 bits */
 786
 787 struct PCIDevice {
 788     /* PCI config space */
 789     uint8_t config[256];
 790
 791     /* the following fields are read only */
 792     PCIBus *bus;
 793     int devfn;
 794     char name[64];
 795     PCIIORegion io_regions[PCI_NUM_REGIONS];
 796
 797     /* do not access the following fields */
 798     PCIConfigReadFunc *config_read;
 799     PCIConfigWriteFunc *config_write;
 800     /* ??? This is a PC-specific hack, and should be removed.  */
 801     int irq_index;
 802
 803     /* Current IRQ levels.  Used internally by the generic PCI code.  */
 804     int irq_state[4];
 805 };
 806
 807 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
 808                                int instance_size, int devfn,
 809                                PCIConfigReadFunc *config_read,
 810                                PCIConfigWriteFunc *config_write);
 811
 812 void pci_register_io_region(PCIDevice *pci_dev, int region_num,
 813                             uint32_t size, int type,
 814                             PCIMapIORegionFunc *map_func);
 815
 816 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
 817
 818 uint32_t pci_default_read_config(PCIDevice *d,
 819                                  uint32_t address, int len);
 820 void pci_default_write_config(PCIDevice *d,
 821                               uint32_t address, uint32_t val, int len);
 822 void pci_device_save(PCIDevice *s, QEMUFile *f);
 823 int pci_device_load(PCIDevice *s, QEMUFile *f);
 824
 825 typedef void (*pci_set_irq_fn)(void *pic, int irq_num, int level);
 826 typedef int (*pci_map_irq_fn)(PCIDevice *pci_dev, int irq_num);
 827 PCIBus *pci_register_bus(pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,
 828                          void *pic, int devfn_min, int nirq);
 829
 830 void pci_nic_init(PCIBus *bus, NICInfo *nd, int devfn);
 831 void pci_data_write(void *opaque, uint32_t addr, uint32_t val, int len);
 832 uint32_t pci_data_read(void *opaque, uint32_t addr, int len);
 833 int pci_bus_num(PCIBus *s);
 834 void pci_for_each_device(int bus_num, void (*fn)(PCIDevice *d));
 835
 836 void pci_info(void);
 837 PCIBus *pci_bridge_init(PCIBus *bus, int devfn, uint32_t id,
 838                         pci_map_irq_fn map_irq, const char *name);
 839
 840 /* prep_pci.c */
 841 PCIBus *pci_prep_init(void);
 842
 843 /* grackle_pci.c */
 844 PCIBus *pci_grackle_init(uint32_t base, void *pic);
 845
 846 /* unin_pci.c */
 847 PCIBus *pci_pmac_init(void *pic);
 848
 849 /* apb_pci.c */
 850 PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base,
 851                      void *pic);
 852
 853 PCIBus *pci_vpb_init(void *pic, int irq, int realview);
 854
 855 /* piix_pci.c */
 856 PCIBus *i440fx_init(PCIDevice **pi440fx_state);
 857 void i440fx_set_smm(PCIDevice *d, int val);
 858 int piix3_init(PCIBus *bus, int devfn);
 859 void i440fx_init_memory_mappings(PCIDevice *d);
 860
 861 int piix4_init(PCIBus *bus, int devfn);
 862
 863 /* openpic.c */
 864 typedef struct openpic_t openpic_t;
 865 void openpic_set_irq(void *opaque, int n_IRQ, int level);
 866 openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus,
 867                          CPUState **envp);
 868
 869 /* heathrow_pic.c */
 870 typedef struct HeathrowPICS HeathrowPICS;
 871 void heathrow_pic_set_irq(void *opaque, int num, int level);
 872 HeathrowPICS *heathrow_pic_init(int *pmem_index);
 873
 874 /* gt64xxx.c */
 875 PCIBus *pci_gt64120_init(void *pic);
 876
 877 #ifdef HAS_AUDIO
 878 struct soundhw {
 879     const char *name;
 880     const char *descr;
 881     int enabled;
 882     int isa;
 883     union {
 884         int (*init_isa) (AudioState *s);
 885         int (*init_pci) (PCIBus *bus, AudioState *s);
 886     } init;
 887 };
 888
 889 extern struct soundhw soundhw[];
 890 #endif
 891
 892 /* vga.c */
 893
 894 #define VGA_RAM_SIZE (8192 * 1024)
 895
 896 struct DisplayState {
 897     uint8_t *data;
 898     int linesize;
 899     int depth;
 900     int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
 901     int width;
 902     int height;
 903     void *opaque;
 904
 905     void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
 906     void (*dpy_resize)(struct DisplayState *s, int w, int h);
 907     void (*dpy_refresh)(struct DisplayState *s);
 908     void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y, int dst_x, int dst_y, int w, int h);
 909 };
 910
 911 static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
 912 {
 913     s->dpy_update(s, x, y, w, h);
 914 }
 915
 916 static inline void dpy_resize(DisplayState *s, int w, int h)
 917 {
 918     s->dpy_resize(s, w, h);
 919 }
 920
 921 int isa_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
 922                  unsigned long vga_ram_offset, int vga_ram_size);
 923 int pci_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 924                  unsigned long vga_ram_offset, int vga_ram_size,
 925                  unsigned long vga_bios_offset, int vga_bios_size);
 926
 927 /* cirrus_vga.c */
 928 void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 929                          unsigned long vga_ram_offset, int vga_ram_size);
 930 void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
 931                          unsigned long vga_ram_offset, int vga_ram_size);
 932
 933 /* sdl.c */
 934 void sdl_display_init(DisplayState *ds, int full_screen);
 935
 936 /* cocoa.m */
 937 void cocoa_display_init(DisplayState *ds, int full_screen);
 938
 939 /* vnc.c */
 940 void vnc_display_init(DisplayState *ds, const char *display);
 941 void do_info_vnc(void);
 942
 943 /* x_keymap.c */
 944 extern uint8_t _translate_keycode(const int key);
 945
 946 /* ide.c */
 947 #define MAX_DISKS 4
 948
 949 extern BlockDriverState *bs_table[MAX_DISKS + 1];
 950
 951 void isa_ide_init(int iobase, int iobase2, int irq,
 952                   BlockDriverState *hd0, BlockDriverState *hd1);
 953 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
 954                          int secondary_ide_enabled);
 955 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn);
 956 int pmac_ide_init (BlockDriverState **hd_table,
 957                    SetIRQFunc *set_irq, void *irq_opaque, int irq);
 958
 959 /* cdrom.c */
 960 int cdrom_read_toc(int nb_sectors, uint8_t *buf, int msf, int start_track);
 961 int cdrom_read_toc_raw(int nb_sectors, uint8_t *buf, int msf, int session_num);
 962
 963 /* es1370.c */
 964 int es1370_init (PCIBus *bus, AudioState *s);
 965
 966 /* sb16.c */
 967 int SB16_init (AudioState *s);
 968
 969 /* adlib.c */
 970 int Adlib_init (AudioState *s);
 971
 972 /* gus.c */
 973 int GUS_init (AudioState *s);
 974
 975 /* dma.c */
 976 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
 977 int DMA_get_channel_mode (int nchan);
 978 int DMA_read_memory (int nchan, void *buf, int pos, int size);
 979 int DMA_write_memory (int nchan, void *buf, int pos, int size);
 980 void DMA_hold_DREQ (int nchan);
 981 void DMA_release_DREQ (int nchan);
 982 void DMA_schedule(int nchan);
 983 void DMA_run (void);
 984 void DMA_init (int high_page_enable);
 985 void DMA_register_channel (int nchan,
 986                            DMA_transfer_handler transfer_handler,
 987                            void *opaque);
 988 /* fdc.c */
 989 #define MAX_FD 2
 990 extern BlockDriverState *fd_table[MAX_FD];
 991
 992 typedef struct fdctrl_t fdctrl_t;
 993
 994 fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
 995                        uint32_t io_base,
 996                        BlockDriverState **fds);
 997 int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
 998
 999 /* ne2000.c */
1000
1001 void isa_ne2000_init(int base, int irq, NICInfo *nd);
1002 void pci_ne2000_init(PCIBus *bus, NICInfo *nd, int devfn);
1003
1004 /* rtl8139.c */
1005
1006 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd, int devfn);
1007
1008 /* pcnet.c */
1009
1010 void pci_pcnet_init(PCIBus *bus, NICInfo *nd, int devfn);
1011 void pcnet_h_reset(void *opaque);
1012 void *lance_init(NICInfo *nd, uint32_t leaddr, void *dma_opaque);
1013
1014
1015 /* pckbd.c */
1016
1017 void kbd_init(void);
1018
1019 /* mc146818rtc.c */
1020
1021 typedef struct RTCState RTCState;
1022
1023 RTCState *rtc_init(int base, int irq);
1024 void rtc_set_memory(RTCState *s, int addr, int val);
1025 void rtc_set_date(RTCState *s, const struct tm *tm);
1026
1027 /* serial.c */
1028
1029 typedef struct SerialState SerialState;
1030 SerialState *serial_init(SetIRQFunc *set_irq, void *opaque,
1031                          int base, int irq, CharDriverState *chr);
1032 SerialState *serial_mm_init (SetIRQFunc *set_irq, void *opaque,
1033                              target_ulong base, int it_shift,
1034                              int irq, CharDriverState *chr);
1035
1036 /* parallel.c */
1037
1038 typedef struct ParallelState ParallelState;
1039 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
1040
1041 /* i8259.c */
1042
1043 typedef struct PicState2 PicState2;
1044 extern PicState2 *isa_pic;
1045 void pic_set_irq(int irq, int level);
1046 void pic_set_irq_new(void *opaque, int irq, int level);
1047 PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
1048 void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
1049                           void *alt_irq_opaque);
1050 int pic_read_irq(PicState2 *s);
1051 void pic_update_irq(PicState2 *s);
1052 uint32_t pic_intack_read(PicState2 *s);
1053 void pic_info(void);
1054 void irq_info(void);
1055
1056 /* APIC */
1057 typedef struct IOAPICState IOAPICState;
1058
1059 int apic_init(CPUState *env);
1060 int apic_get_interrupt(CPUState *env);
1061 IOAPICState *ioapic_init(void);
1062 void ioapic_set_irq(void *opaque, int vector, int level);
1063
1064 /* i8254.c */
1065
1066 #define PIT_FREQ 1193182
1067
1068 typedef struct PITState PITState;
1069
1070 PITState *pit_init(int base, int irq);
1071 void pit_set_gate(PITState *pit, int channel, int val);
1072 int pit_get_gate(PITState *pit, int channel);
1073 int pit_get_initial_count(PITState *pit, int channel);
1074 int pit_get_mode(PITState *pit, int channel);
1075 int pit_get_out(PITState *pit, int channel, int64_t current_time);
1076
1077 /* pcspk.c */
1078 void pcspk_init(PITState *);
1079 int pcspk_audio_init(AudioState *);
1080
1081 #include "hw/smbus.h"
1082
1083 /* acpi.c */
1084 extern int acpi_enabled;
1085 void piix4_pm_init(PCIBus *bus, int devfn);
1086 void piix4_smbus_register_device(SMBusDevice *dev, uint8_t addr);
1087 void acpi_bios_init(void);
1088
1089 /* smbus_eeprom.c */
1090 SMBusDevice *smbus_eeprom_device_init(uint8_t addr, uint8_t *buf);
1091
1092 /* pc.c */
1093 extern QEMUMachine pc_machine;
1094 extern QEMUMachine isapc_machine;
1095 extern int fd_bootchk;
1096
1097 void ioport_set_a20(int enable);
1098 int ioport_get_a20(void);
1099
1100 /* ppc.c */
1101 extern QEMUMachine prep_machine;
1102 extern QEMUMachine core99_machine;
1103 extern QEMUMachine heathrow_machine;
1104
1105 /* mips_r4k.c */
1106 extern QEMUMachine mips_machine;
1107
1108 /* mips_malta.c */
1109 extern QEMUMachine mips_malta_machine;
1110
1111 /* mips_int */
1112 extern void cpu_mips_irq_request(void *opaque, int irq, int level);
1113
1114 /* mips_timer.c */
1115 extern void cpu_mips_clock_init(CPUState *);
1116 extern void cpu_mips_irqctrl_init (void);
1117
1118 /* shix.c */
1119 extern QEMUMachine shix_machine;
1120
1121 #ifdef TARGET_PPC
1122 ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
1123 #endif
1124 void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
1125
1126 extern CPUWriteMemoryFunc *PPC_io_write[];
1127 extern CPUReadMemoryFunc *PPC_io_read[];
1128 void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
1129
1130 /* sun4m.c */
1131 extern QEMUMachine sun4m_machine;
1132 void pic_set_irq_cpu(int irq, int level, unsigned int cpu);
1133
1134 /* iommu.c */
1135 void *iommu_init(uint32_t addr);
1136 void sparc_iommu_memory_rw(void *opaque, target_phys_addr_t addr,
1137                                  uint8_t *buf, int len, int is_write);
1138 static inline void sparc_iommu_memory_read(void *opaque,
1139                                            target_phys_addr_t addr,
1140                                            uint8_t *buf, int len)
1141 {
1142     sparc_iommu_memory_rw(opaque, addr, buf, len, 0);
1143 }
1144
1145 static inline void sparc_iommu_memory_write(void *opaque,
1146                                             target_phys_addr_t addr,
1147                                             uint8_t *buf, int len)
1148 {
1149     sparc_iommu_memory_rw(opaque, addr, buf, len, 1);
1150 }
1151
1152 /* tcx.c */
1153 void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
1154                unsigned long vram_offset, int vram_size, int width, int height);
1155
1156 /* slavio_intctl.c */
1157 void *slavio_intctl_init();
1158 void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env);
1159 void slavio_pic_info(void *opaque);
1160 void slavio_irq_info(void *opaque);
1161 void slavio_pic_set_irq(void *opaque, int irq, int level);
1162 void slavio_pic_set_irq_cpu(void *opaque, int irq, int level, unsigned int cpu);
1163
1164 /* loader.c */
1165 int get_image_size(const char *filename);
1166 int load_image(const char *filename, uint8_t *addr);
1167 int load_elf(const char *filename, int64_t virt_to_phys_addend, uint64_t *pentry);
1168 int load_aout(const char *filename, uint8_t *addr);
1169
1170 /* slavio_timer.c */
1171 void slavio_timer_init(uint32_t addr, int irq, int mode, unsigned int cpu);
1172
1173 /* slavio_serial.c */
1174 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
1175 void slavio_serial_ms_kbd_init(int base, int irq);
1176
1177 /* slavio_misc.c */
1178 void *slavio_misc_init(uint32_t base, int irq);
1179 void slavio_set_power_fail(void *opaque, int power_failing);
1180
1181 /* esp.c */
1182 void esp_scsi_attach(void *opaque, BlockDriverState *bd, int id);
1183 void *esp_init(BlockDriverState **bd, uint32_t espaddr, void *dma_opaque);
1184 void esp_reset(void *opaque);
1185
1186 /* sparc32_dma.c */
1187 void *sparc32_dma_init(uint32_t daddr, int espirq, int leirq, void *iommu,
1188                        void *intctl);
1189 void ledma_set_irq(void *opaque, int isr);
1190 void ledma_memory_read(void *opaque, target_phys_addr_t addr,
1191                        uint8_t *buf, int len, int do_bswap);
1192 void ledma_memory_write(void *opaque, target_phys_addr_t addr,
1193                         uint8_t *buf, int len, int do_bswap);
1194 void espdma_raise_irq(void *opaque);
1195 void espdma_clear_irq(void *opaque);
1196 void espdma_memory_read(void *opaque, uint8_t *buf, int len);
1197 void espdma_memory_write(void *opaque, uint8_t *buf, int len);
1198 void sparc32_dma_set_reset_data(void *opaque, void *esp_opaque,
1199                                 void *lance_opaque);
1200
1201 /* cs4231.c */
1202 void cs_init(target_phys_addr_t base, int irq, void *intctl);
1203
1204 /* sun4u.c */
1205 extern QEMUMachine sun4u_machine;
1206
1207 /* NVRAM helpers */
1208 #include "hw/m48t59.h"
1209
1210 void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
1211 uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
1212 void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
1213 uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
1214 void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
1215 uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
1216 void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
1217                        const unsigned char *str, uint32_t max);
1218 int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
1219 void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
1220                     uint32_t start, uint32_t count);
1221 int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
1222                           const unsigned char *arch,
1223                           uint32_t RAM_size, int boot_device,
1224                           uint32_t kernel_image, uint32_t kernel_size,
1225                           const char *cmdline,
1226                           uint32_t initrd_image, uint32_t initrd_size,
1227                           uint32_t NVRAM_image,
1228                           int width, int height, int depth);
1229
1230 /* adb.c */
1231
1232 #define MAX_ADB_DEVICES 16
1233
1234 #define ADB_MAX_OUT_LEN 16
1235
1236 typedef struct ADBDevice ADBDevice;
1237
1238 /* hypercall.c */
1239
1240 void pci_hypercall_init(PCIBus *bus);
1241 void vmchannel_init(CharDriverState *hd, uint32_t deviceid, uint32_t index);
1242
1243 /* buf = NULL means polling */
1244 typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
1245                               const uint8_t *buf, int len);
1246 typedef int ADBDeviceReset(ADBDevice *d);
1247
1248 struct ADBDevice {
1249     struct ADBBusState *bus;
1250     int devaddr;
1251     int handler;
1252     ADBDeviceRequest *devreq;
1253     ADBDeviceReset *devreset;
1254     void *opaque;
1255 };
1256
1257 typedef struct ADBBusState {
1258     ADBDevice devices[MAX_ADB_DEVICES];
1259     int nb_devices;
1260     int poll_index;
1261 } ADBBusState;
1262
1263 int adb_request(ADBBusState *s, uint8_t *buf_out,
1264                 const uint8_t *buf, int len);
1265 int adb_poll(ADBBusState *s, uint8_t *buf_out);
1266
1267 ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
1268                                ADBDeviceRequest *devreq,
1269                                ADBDeviceReset *devreset,
1270                                void *opaque);
1271 void adb_kbd_init(ADBBusState *bus);
1272 void adb_mouse_init(ADBBusState *bus);
1273
1274 /* cuda.c */
1275
1276 extern ADBBusState adb_bus;
1277 int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
1278
1279 #include "hw/usb.h"
1280
1281 /* usb ports of the VM */
1282
1283 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
1284                             usb_attachfn attach);
1285
1286 #define VM_USB_HUB_SIZE 8
1287
1288 void do_usb_add(const char *devname);
1289 void do_usb_del(const char *devname);
1290 void usb_info(void);
1291
1292 /* scsi-disk.c */
1293 enum scsi_reason {
1294     SCSI_REASON_DONE, /* Command complete.  */
1295     SCSI_REASON_DATA  /* Transfer complete, more data required.  */
1296 };
1297
1298 typedef struct SCSIDevice SCSIDevice;
1299 typedef void (*scsi_completionfn)(void *opaque, int reason, uint32_t tag,
1300                                   uint32_t arg);
1301
1302 SCSIDevice *scsi_disk_init(BlockDriverState *bdrv,
1303                            int tcq,
1304                            scsi_completionfn completion,
1305                            void *opaque);
1306 void scsi_disk_destroy(SCSIDevice *s);
1307
1308 int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun);
1309 /* SCSI data transfers are asynchrnonous.  However, unlike the block IO
1310    layer the completion routine may be called directly by
1311    scsi_{read,write}_data.  */
1312 void scsi_read_data(SCSIDevice *s, uint32_t tag);
1313 int scsi_write_data(SCSIDevice *s, uint32_t tag);
1314 void scsi_cancel_io(SCSIDevice *s, uint32_t tag);
1315 uint8_t *scsi_get_buf(SCSIDevice *s, uint32_t tag);
1316
1317 /* lsi53c895a.c */
1318 void lsi_scsi_attach(void *opaque, BlockDriverState *bd, int id);
1319 void *lsi_scsi_init(PCIBus *bus, int devfn);
1320
1321 /* integratorcp.c */
1322 extern QEMUMachine integratorcp926_machine;
1323 extern QEMUMachine integratorcp1026_machine;
1324
1325 /* versatilepb.c */
1326 extern QEMUMachine versatilepb_machine;
1327 extern QEMUMachine versatileab_machine;
1328
1329 /* realview.c */
1330 extern QEMUMachine realview_machine;
1331
1332 /* ps2.c */
1333 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
1334 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
1335 void ps2_write_mouse(void *, int val);
1336 void ps2_write_keyboard(void *, int val);
1337 uint32_t ps2_read_data(void *);
1338 void ps2_queue(void *, int b);
1339 void ps2_keyboard_set_translation(void *opaque, int mode);
1340
1341 /* smc91c111.c */
1342 void smc91c111_init(NICInfo *, uint32_t, void *, int);
1343
1344 /* pl110.c */
1345 void *pl110_init(DisplayState *ds, uint32_t base, void *pic, int irq, int);
1346
1347 /* pl011.c */
1348 void pl011_init(uint32_t base, void *pic, int irq, CharDriverState *chr);
1349
1350 /* pl050.c */
1351 void pl050_init(uint32_t base, void *pic, int irq, int is_mouse);
1352
1353 /* pl080.c */
1354 void *pl080_init(uint32_t base, void *pic, int irq, int nchannels);
1355
1356 /* pl190.c */
1357 void *pl190_init(uint32_t base, void *parent, int irq, int fiq);
1358
1359 /* arm-timer.c */
1360 void sp804_init(uint32_t base, void *pic, int irq);
1361 void icp_pit_init(uint32_t base, void *pic, int irq);
1362
1363 /* arm_sysctl.c */
1364 void arm_sysctl_init(uint32_t base, uint32_t sys_id);
1365
1366 /* arm_gic.c */
1367 void *arm_gic_init(uint32_t base, void *parent, int parent_irq);
1368
1369 /* arm_boot.c */
1370
1371 void arm_load_kernel(CPUState *env, int ram_size, const char *kernel_filename,
1372                      const char *kernel_cmdline, const char *initrd_filename,
1373                      int board_id);
1374
1375 /* sh7750.c */
1376 struct SH7750State;
1377
1378 struct SH7750State *sh7750_init(CPUState * cpu);
1379
1380 typedef struct {
1381     /* The callback will be triggered if any of the designated lines change */
1382     uint16_t portamask_trigger;
1383     uint16_t portbmask_trigger;
1384     /* Return 0 if no action was taken */
1385     int (*port_change_cb) (uint16_t porta, uint16_t portb,
1386                            uint16_t * periph_pdtra,
1387                            uint16_t * periph_portdira,
1388                            uint16_t * periph_pdtrb,
1389                            uint16_t * periph_portdirb);
1390 } sh7750_io_device;
1391
1392 int sh7750_register_io_device(struct SH7750State *s,
1393                               sh7750_io_device * device);
1394 /* tc58128.c */
1395 int tc58128_init(struct SH7750State *s, char *zone1, char *zone2);
1396
1397 /* NOR flash devices */
1398 typedef struct pflash_t pflash_t;
1399
1400 pflash_t *pflash_register (target_ulong base, ram_addr_t off,
1401                            BlockDriverState *bs,
1402                            target_ulong sector_len, int nb_blocs, int width,
1403                            uint16_t id0, uint16_t id1,
1404                            uint16_t id2, uint16_t id3);
1405
1406 #include "gdbstub.h"
1407
1408 #endif /* defined(QEMU_TOOL) */
1409
1410 /* migration.c */
1411 void do_info_migration(void);
1412 void do_migrate(int detach, const char *uri);
1413 void do_migrate_cancel(void);
1414 void do_migrate_set_speed(const char *value);
1415 int migrate_incoming(const char *device);
1416
1417 /* monitor.c */
1418 void monitor_init(CharDriverState *hd, int show_banner);
1419 void term_puts(const char *str);
1420 void term_vprintf(const char *fmt, va_list ap);
1421 void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
1422 void term_print_filename(const char *filename);
1423 void term_flush(void);
1424 void term_print_help(void);
1425 void monitor_readline(const char *prompt, int is_password,
1426                       char *buf, int buf_size);
1427 void monitor_suspend(void);
1428 void monitor_resume(void);
1429
1430 /* readline.c */
1431 typedef void ReadLineFunc(void *opaque, const char *str);
1432
1433 extern int completion_index;
1434 void add_completion(const char *str);
1435 void readline_handle_byte(int ch);
1436 void readline_find_completion(const char *cmdline);
1437 const char *readline_get_history(unsigned int index);
1438 void readline_start(const char *prompt, int is_password,
1439                     ReadLineFunc *readline_func, void *opaque);
1440
1441 void kqemu_record_dump(void);
1442
1443 #endif /* VL_H */