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