vcs.maemo.org Git - qemu/blob - 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 #include "audio/audio.h"
  41
  42 #ifndef O_LARGEFILE
  43 #define O_LARGEFILE 0
  44 #endif
  45 #ifndef O_BINARY
  46 #define O_BINARY 0
  47 #endif
  48
  49 #ifdef _WIN32
  50 #define lseek _lseeki64
  51 #define ENOTSUP 4096
  52 /* XXX: find 64 bit version */
  53 #define ftruncate chsize
  54
  55 static inline char *realpath(const char *path, char *resolved_path)
  56 {
  57     _fullpath(resolved_path, path, _MAX_PATH);
  58     return resolved_path;
  59 }
  60 #endif
  61
  62 #ifdef QEMU_TOOL
  63
  64 /* we use QEMU_TOOL in the command line tools which do not depend on
  65    the target CPU type */
  66 #include "config-host.h"
  67 #include <setjmp.h>
  68 #include "osdep.h"
  69 #include "bswap.h"
  70
  71 #else
  72
  73 #include "cpu.h"
  74 #include "gdbstub.h"
  75
  76 #endif /* !defined(QEMU_TOOL) */
  77
  78 #ifndef glue
  79 #define xglue(x, y) x ## y
  80 #define glue(x, y) xglue(x, y)
  81 #define stringify(s)    tostring(s)
  82 #define tostring(s)     #s
  83 #endif
  84
  85 /* vl.c */
  86 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
  87
  88 void hw_error(const char *fmt, ...);
  89
  90 int get_image_size(const char *filename);
  91 int load_image(const char *filename, uint8_t *addr);
  92 extern const char *bios_dir;
  93
  94 void pstrcpy(char *buf, int buf_size, const char *str);
  95 char *pstrcat(char *buf, int buf_size, const char *s);
  96 int strstart(const char *str, const char *val, const char **ptr);
  97
  98 extern int vm_running;
  99
 100 typedef struct vm_change_state_entry VMChangeStateEntry;
 101 typedef void VMChangeStateHandler(void *opaque, int running);
 102 typedef void VMStopHandler(void *opaque, int reason);
 103
 104 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 105                                                      void *opaque);
 106 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
 107
 108 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
 109 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
 110
 111 void vm_start(void);
 112 void vm_stop(int reason);
 113
 114 typedef void QEMUResetHandler(void *opaque);
 115
 116 void qemu_register_reset(QEMUResetHandler *func, void *opaque);
 117 void qemu_system_reset_request(void);
 118 void qemu_system_shutdown_request(void);
 119 void qemu_system_powerdown_request(void);
 120 #if !defined(TARGET_SPARC)
 121 // Please implement a power failure function to signal the OS
 122 #define qemu_system_powerdown() do{}while(0)
 123 #else
 124 void qemu_system_powerdown(void);
 125 #endif
 126
 127 void main_loop_wait(int timeout);
 128
 129 extern int audio_enabled;
 130 extern int sb16_enabled;
 131 extern int adlib_enabled;
 132 extern int gus_enabled;
 133 extern int es1370_enabled;
 134 extern int ram_size;
 135 extern int bios_size;
 136 extern int rtc_utc;
 137 extern int cirrus_vga_enabled;
 138 extern int graphic_width;
 139 extern int graphic_height;
 140 extern int graphic_depth;
 141 extern const char *keyboard_layout;
 142 extern int kqemu_allowed;
 143 extern int win2k_install_hack;
 144 extern int usb_enabled;
 145
 146 /* XXX: make it dynamic */
 147 #if defined (TARGET_PPC)
 148 #define BIOS_SIZE ((512 + 32) * 1024)
 149 #elif defined(TARGET_MIPS)
 150 #define BIOS_SIZE (128 * 1024)
 151 #else
 152 #define BIOS_SIZE ((256 + 64) * 1024)
 153 #endif
 154
 155 /* keyboard/mouse support */
 156
 157 #define MOUSE_EVENT_LBUTTON 0x01
 158 #define MOUSE_EVENT_RBUTTON 0x02
 159 #define MOUSE_EVENT_MBUTTON 0x04
 160
 161 typedef void QEMUPutKBDEvent(void *opaque, int keycode);
 162 typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
 163
 164 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
 165 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque);
 166
 167 void kbd_put_keycode(int keycode);
 168 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
 169
 170 /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
 171    constants) */
 172 #define QEMU_KEY_ESC1(c) ((c) | 0xe100)
 173 #define QEMU_KEY_BACKSPACE  0x007f
 174 #define QEMU_KEY_UP         QEMU_KEY_ESC1('A')
 175 #define QEMU_KEY_DOWN       QEMU_KEY_ESC1('B')
 176 #define QEMU_KEY_RIGHT      QEMU_KEY_ESC1('C')
 177 #define QEMU_KEY_LEFT       QEMU_KEY_ESC1('D')
 178 #define QEMU_KEY_HOME       QEMU_KEY_ESC1(1)
 179 #define QEMU_KEY_END        QEMU_KEY_ESC1(4)
 180 #define QEMU_KEY_PAGEUP     QEMU_KEY_ESC1(5)
 181 #define QEMU_KEY_PAGEDOWN   QEMU_KEY_ESC1(6)
 182 #define QEMU_KEY_DELETE     QEMU_KEY_ESC1(3)
 183
 184 #define QEMU_KEY_CTRL_UP         0xe400
 185 #define QEMU_KEY_CTRL_DOWN       0xe401
 186 #define QEMU_KEY_CTRL_LEFT       0xe402
 187 #define QEMU_KEY_CTRL_RIGHT      0xe403
 188 #define QEMU_KEY_CTRL_HOME       0xe404
 189 #define QEMU_KEY_CTRL_END        0xe405
 190 #define QEMU_KEY_CTRL_PAGEUP     0xe406
 191 #define QEMU_KEY_CTRL_PAGEDOWN   0xe407
 192
 193 void kbd_put_keysym(int keysym);
 194
 195 /* async I/O support */
 196
 197 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
 198 typedef int IOCanRWHandler(void *opaque);
 199
 200 int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read,
 201                              IOReadHandler *fd_read, void *opaque);
 202 void qemu_del_fd_read_handler(int fd);
 203
 204 /* character device */
 205
 206 #define CHR_EVENT_BREAK 0 /* serial break char */
 207 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
 208
 209
 210
 211 #define CHR_IOCTL_SERIAL_SET_PARAMS   1
 212 typedef struct {
 213     int speed;
 214     int parity;
 215     int data_bits;
 216     int stop_bits;
 217 } QEMUSerialSetParams;
 218
 219 #define CHR_IOCTL_SERIAL_SET_BREAK    2
 220
 221 #define CHR_IOCTL_PP_READ_DATA        3
 222 #define CHR_IOCTL_PP_WRITE_DATA       4
 223 #define CHR_IOCTL_PP_READ_CONTROL     5
 224 #define CHR_IOCTL_PP_WRITE_CONTROL    6
 225 #define CHR_IOCTL_PP_READ_STATUS      7
 226
 227 typedef void IOEventHandler(void *opaque, int event);
 228
 229 typedef struct CharDriverState {
 230     int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
 231     void (*chr_add_read_handler)(struct CharDriverState *s,
 232                                  IOCanRWHandler *fd_can_read,
 233                                  IOReadHandler *fd_read, void *opaque);
 234     int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
 235     IOEventHandler *chr_event;
 236     void (*chr_send_event)(struct CharDriverState *chr, int event);
 237     void *opaque;
 238 } CharDriverState;
 239
 240 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
 241 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
 242 void qemu_chr_send_event(CharDriverState *s, int event);
 243 void qemu_chr_add_read_handler(CharDriverState *s,
 244                                IOCanRWHandler *fd_can_read,
 245                                IOReadHandler *fd_read, void *opaque);
 246 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event);
 247 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
 248
 249 /* consoles */
 250
 251 typedef struct DisplayState DisplayState;
 252 typedef struct TextConsole TextConsole;
 253
 254 extern TextConsole *vga_console;
 255
 256 TextConsole *graphic_console_init(DisplayState *ds);
 257 int is_active_console(TextConsole *s);
 258 CharDriverState *text_console_init(DisplayState *ds);
 259 void console_select(unsigned int index);
 260
 261 /* serial ports */
 262
 263 #define MAX_SERIAL_PORTS 4
 264
 265 extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 266
 267 /* parallel ports */
 268
 269 #define MAX_PARALLEL_PORTS 3
 270
 271 extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 272
 273 /* network redirectors support */
 274
 275 #define MAX_NICS 8
 276
 277 typedef struct NetDriverState {
 278     int index; /* index number in QEMU */
 279     uint8_t macaddr[6];
 280     char ifname[16];
 281     void (*send_packet)(struct NetDriverState *nd,
 282                         const uint8_t *buf, int size);
 283     void (*add_read_packet)(struct NetDriverState *nd,
 284                             IOCanRWHandler *fd_can_read,
 285                             IOReadHandler *fd_read, void *opaque);
 286     /* tun specific data */
 287     int fd;
 288     /* slirp specific data */
 289 } NetDriverState;
 290
 291 extern int nb_nics;
 292 extern NetDriverState nd_table[MAX_NICS];
 293
 294 void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size);
 295 void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read,
 296                           IOReadHandler *fd_read, void *opaque);
 297
 298 /* timers */
 299
 300 typedef struct QEMUClock QEMUClock;
 301 typedef struct QEMUTimer QEMUTimer;
 302 typedef void QEMUTimerCB(void *opaque);
 303
 304 /* The real time clock should be used only for stuff which does not
 305    change the virtual machine state, as it is run even if the virtual
 306    machine is stopped. The real time clock has a frequency of 1000
 307    Hz. */
 308 extern QEMUClock *rt_clock;
 309
 310 /* The virtual clock is only run during the emulation. It is stopped
 311    when the virtual machine is stopped. Virtual timers use a high
 312    precision clock, usually cpu cycles (use ticks_per_sec). */
 313 extern QEMUClock *vm_clock;
 314
 315 int64_t qemu_get_clock(QEMUClock *clock);
 316
 317 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
 318 void qemu_free_timer(QEMUTimer *ts);
 319 void qemu_del_timer(QEMUTimer *ts);
 320 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
 321 int qemu_timer_pending(QEMUTimer *ts);
 322
 323 extern int64_t ticks_per_sec;
 324 extern int pit_min_timer_count;
 325
 326 void cpu_enable_ticks(void);
 327 void cpu_disable_ticks(void);
 328
 329 /* VM Load/Save */
 330
 331 typedef FILE QEMUFile;
 332
 333 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
 334 void qemu_put_byte(QEMUFile *f, int v);
 335 void qemu_put_be16(QEMUFile *f, unsigned int v);
 336 void qemu_put_be32(QEMUFile *f, unsigned int v);
 337 void qemu_put_be64(QEMUFile *f, uint64_t v);
 338 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
 339 int qemu_get_byte(QEMUFile *f);
 340 unsigned int qemu_get_be16(QEMUFile *f);
 341 unsigned int qemu_get_be32(QEMUFile *f);
 342 uint64_t qemu_get_be64(QEMUFile *f);
 343
 344 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
 345 {
 346     qemu_put_be64(f, *pv);
 347 }
 348
 349 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
 350 {
 351     qemu_put_be32(f, *pv);
 352 }
 353
 354 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
 355 {
 356     qemu_put_be16(f, *pv);
 357 }
 358
 359 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
 360 {
 361     qemu_put_byte(f, *pv);
 362 }
 363
 364 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
 365 {
 366     *pv = qemu_get_be64(f);
 367 }
 368
 369 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
 370 {
 371     *pv = qemu_get_be32(f);
 372 }
 373
 374 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
 375 {
 376     *pv = qemu_get_be16(f);
 377 }
 378
 379 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
 380 {
 381     *pv = qemu_get_byte(f);
 382 }
 383
 384 #if TARGET_LONG_BITS == 64
 385 #define qemu_put_betl qemu_put_be64
 386 #define qemu_get_betl qemu_get_be64
 387 #define qemu_put_betls qemu_put_be64s
 388 #define qemu_get_betls qemu_get_be64s
 389 #else
 390 #define qemu_put_betl qemu_put_be32
 391 #define qemu_get_betl qemu_get_be32
 392 #define qemu_put_betls qemu_put_be32s
 393 #define qemu_get_betls qemu_get_be32s
 394 #endif
 395
 396 int64_t qemu_ftell(QEMUFile *f);
 397 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
 398
 399 typedef void SaveStateHandler(QEMUFile *f, void *opaque);
 400 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
 401
 402 int qemu_loadvm(const char *filename);
 403 int qemu_savevm(const char *filename);
 404 int register_savevm(const char *idstr,
 405                     int instance_id,
 406                     int version_id,
 407                     SaveStateHandler *save_state,
 408                     LoadStateHandler *load_state,
 409                     void *opaque);
 410 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
 411 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
 412
 413 /* block.c */
 414 typedef struct BlockDriverState BlockDriverState;
 415 typedef struct BlockDriver BlockDriver;
 416
 417 extern BlockDriver bdrv_raw;
 418 extern BlockDriver bdrv_cow;
 419 extern BlockDriver bdrv_qcow;
 420 extern BlockDriver bdrv_vmdk;
 421 extern BlockDriver bdrv_cloop;
 422 extern BlockDriver bdrv_dmg;
 423 extern BlockDriver bdrv_bochs;
 424 extern BlockDriver bdrv_vpc;
 425 extern BlockDriver bdrv_vvfat;
 426
 427 void bdrv_init(void);
 428 BlockDriver *bdrv_find_format(const char *format_name);
 429 int bdrv_create(BlockDriver *drv,
 430                 const char *filename, int64_t size_in_sectors,
 431                 const char *backing_file, int flags);
 432 BlockDriverState *bdrv_new(const char *device_name);
 433 void bdrv_delete(BlockDriverState *bs);
 434 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
 435 int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
 436                BlockDriver *drv);
 437 void bdrv_close(BlockDriverState *bs);
 438 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 439               uint8_t *buf, int nb_sectors);
 440 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 441                const uint8_t *buf, int nb_sectors);
 442 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
 443 int bdrv_commit(BlockDriverState *bs);
 444 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
 445
 446 #define BDRV_TYPE_HD     0
 447 #define BDRV_TYPE_CDROM  1
 448 #define BDRV_TYPE_FLOPPY 2
 449 #define BIOS_ATA_TRANSLATION_AUTO 0
 450 #define BIOS_ATA_TRANSLATION_NONE 1
 451 #define BIOS_ATA_TRANSLATION_LBA  2
 452
 453 void bdrv_set_geometry_hint(BlockDriverState *bs,
 454                             int cyls, int heads, int secs);
 455 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 456 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
 457 void bdrv_get_geometry_hint(BlockDriverState *bs,
 458                             int *pcyls, int *pheads, int *psecs);
 459 int bdrv_get_type_hint(BlockDriverState *bs);
 460 int bdrv_get_translation_hint(BlockDriverState *bs);
 461 int bdrv_is_removable(BlockDriverState *bs);
 462 int bdrv_is_read_only(BlockDriverState *bs);
 463 int bdrv_is_inserted(BlockDriverState *bs);
 464 int bdrv_is_locked(BlockDriverState *bs);
 465 void bdrv_set_locked(BlockDriverState *bs, int locked);
 466 void bdrv_set_change_cb(BlockDriverState *bs,
 467                         void (*change_cb)(void *opaque), void *opaque);
 468 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
 469 void bdrv_info(void);
 470 BlockDriverState *bdrv_find(const char *name);
 471 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
 472 int bdrv_is_encrypted(BlockDriverState *bs);
 473 int bdrv_set_key(BlockDriverState *bs, const char *key);
 474 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 475                          void *opaque);
 476 const char *bdrv_get_device_name(BlockDriverState *bs);
 477
 478 int qcow_get_cluster_size(BlockDriverState *bs);
 479 int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
 480                           const uint8_t *buf);
 481
 482 #ifndef QEMU_TOOL
 483
 484 typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
 485                                  int boot_device,
 486              DisplayState *ds, const char **fd_filename, int snapshot,
 487              const char *kernel_filename, const char *kernel_cmdline,
 488              const char *initrd_filename);
 489
 490 typedef struct QEMUMachine {
 491     const char *name;
 492     const char *desc;
 493     QEMUMachineInitFunc *init;
 494     struct QEMUMachine *next;
 495 } QEMUMachine;
 496
 497 int qemu_register_machine(QEMUMachine *m);
 498
 499 typedef void SetIRQFunc(void *opaque, int irq_num, int level);
 500 typedef void IRQRequestFunc(void *opaque, int level);
 501
 502 /* ISA bus */
 503
 504 extern target_phys_addr_t isa_mem_base;
 505
 506 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
 507 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
 508
 509 int register_ioport_read(int start, int length, int size,
 510                          IOPortReadFunc *func, void *opaque);
 511 int register_ioport_write(int start, int length, int size,
 512                           IOPortWriteFunc *func, void *opaque);
 513 void isa_unassign_ioport(int start, int length);
 514
 515 /* PCI bus */
 516
 517 extern target_phys_addr_t pci_mem_base;
 518
 519 typedef struct PCIBus PCIBus;
 520 typedef struct PCIDevice PCIDevice;
 521
 522 typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
 523                                 uint32_t address, uint32_t data, int len);
 524 typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
 525                                    uint32_t address, int len);
 526 typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
 527                                 uint32_t addr, uint32_t size, int type);
 528
 529 #define PCI_ADDRESS_SPACE_MEM           0x00
 530 #define PCI_ADDRESS_SPACE_IO            0x01
 531 #define PCI_ADDRESS_SPACE_MEM_PREFETCH  0x08
 532
 533 typedef struct PCIIORegion {
 534     uint32_t addr; /* current PCI mapping address. -1 means not mapped */
 535     uint32_t size;
 536     uint8_t type;
 537     PCIMapIORegionFunc *map_func;
 538 } PCIIORegion;
 539
 540 #define PCI_ROM_SLOT 6
 541 #define PCI_NUM_REGIONS 7
 542 struct PCIDevice {
 543     /* PCI config space */
 544     uint8_t config[256];
 545
 546     /* the following fields are read only */
 547     PCIBus *bus;
 548     int devfn;
 549     char name[64];
 550     PCIIORegion io_regions[PCI_NUM_REGIONS];
 551
 552     /* do not access the following fields */
 553     PCIConfigReadFunc *config_read;
 554     PCIConfigWriteFunc *config_write;
 555     int irq_index;
 556 };
 557
 558 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
 559                                int instance_size, int devfn,
 560                                PCIConfigReadFunc *config_read,
 561                                PCIConfigWriteFunc *config_write);
 562
 563 void pci_register_io_region(PCIDevice *pci_dev, int region_num,
 564                             uint32_t size, int type,
 565                             PCIMapIORegionFunc *map_func);
 566
 567 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
 568
 569 uint32_t pci_default_read_config(PCIDevice *d,
 570                                  uint32_t address, int len);
 571 void pci_default_write_config(PCIDevice *d,
 572                               uint32_t address, uint32_t val, int len);
 573 void generic_pci_save(QEMUFile* f, void *opaque);
 574 int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
 575
 576 extern struct PIIX3State *piix3_state;
 577
 578 PCIBus *i440fx_init(void);
 579 void piix3_init(PCIBus *bus);
 580 void pci_bios_init(void);
 581 void pci_info(void);
 582
 583 /* temporary: will be moved in platform specific file */
 584 void pci_set_pic(PCIBus *bus, SetIRQFunc *set_irq, void *irq_opaque);
 585 PCIBus *pci_prep_init(void);
 586 PCIBus *pci_grackle_init(uint32_t base);
 587 PCIBus *pci_pmac_init(void);
 588 PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base);
 589
 590 /* openpic.c */
 591 typedef struct openpic_t openpic_t;
 592 void openpic_set_irq(void *opaque, int n_IRQ, int level);
 593 openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus);
 594
 595 /* heathrow_pic.c */
 596 typedef struct HeathrowPICS HeathrowPICS;
 597 void heathrow_pic_set_irq(void *opaque, int num, int level);
 598 HeathrowPICS *heathrow_pic_init(int *pmem_index);
 599
 600 /* vga.c */
 601
 602 #define VGA_RAM_SIZE (4096 * 1024)
 603
 604 struct DisplayState {
 605     uint8_t *data;
 606     int linesize;
 607     int depth;
 608     int width;
 609     int height;
 610     void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
 611     void (*dpy_resize)(struct DisplayState *s, int w, int h);
 612     void (*dpy_refresh)(struct DisplayState *s);
 613 };
 614
 615 static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
 616 {
 617     s->dpy_update(s, x, y, w, h);
 618 }
 619
 620 static inline void dpy_resize(DisplayState *s, int w, int h)
 621 {
 622     s->dpy_resize(s, w, h);
 623 }
 624
 625 int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 626                    unsigned long vga_ram_offset, int vga_ram_size,
 627                    unsigned long vga_bios_offset, int vga_bios_size);
 628 void vga_update_display(void);
 629 void vga_invalidate_display(void);
 630 void vga_screen_dump(const char *filename);
 631
 632 /* cirrus_vga.c */
 633 void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 634                          unsigned long vga_ram_offset, int vga_ram_size);
 635 void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
 636                          unsigned long vga_ram_offset, int vga_ram_size);
 637
 638 /* sdl.c */
 639 void sdl_display_init(DisplayState *ds, int full_screen);
 640
 641 /* cocoa.m */
 642 void cocoa_display_init(DisplayState *ds, int full_screen);
 643
 644 /* ide.c */
 645 #define MAX_DISKS 4
 646
 647 extern BlockDriverState *bs_table[MAX_DISKS];
 648
 649 void isa_ide_init(int iobase, int iobase2, int irq,
 650                   BlockDriverState *hd0, BlockDriverState *hd1);
 651 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
 652                          int secondary_ide_enabled);
 653 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table);
 654 int pmac_ide_init (BlockDriverState **hd_table,
 655                    SetIRQFunc *set_irq, void *irq_opaque, int irq);
 656
 657 /* es1370.c */
 658 int es1370_init (PCIBus *bus, AudioState *s);
 659
 660 /* sb16.c */
 661 int SB16_init (AudioState *s);
 662
 663 /* adlib.c */
 664 int Adlib_init (AudioState *s);
 665
 666 /* gus.c */
 667 int GUS_init (AudioState *s);
 668
 669 /* dma.c */
 670 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
 671 int DMA_get_channel_mode (int nchan);
 672 int DMA_read_memory (int nchan, void *buf, int pos, int size);
 673 int DMA_write_memory (int nchan, void *buf, int pos, int size);
 674 void DMA_hold_DREQ (int nchan);
 675 void DMA_release_DREQ (int nchan);
 676 void DMA_schedule(int nchan);
 677 void DMA_run (void);
 678 void DMA_init (int high_page_enable);
 679 void DMA_register_channel (int nchan,
 680                            DMA_transfer_handler transfer_handler,
 681                            void *opaque);
 682 /* fdc.c */
 683 #define MAX_FD 2
 684 extern BlockDriverState *fd_table[MAX_FD];
 685
 686 typedef struct fdctrl_t fdctrl_t;
 687
 688 fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
 689                        uint32_t io_base,
 690                        BlockDriverState **fds);
 691 int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
 692
 693 /* ne2000.c */
 694
 695 void isa_ne2000_init(int base, int irq, NetDriverState *nd);
 696 void pci_ne2000_init(PCIBus *bus, NetDriverState *nd);
 697
 698 /* pckbd.c */
 699
 700 void kbd_init(void);
 701
 702 /* mc146818rtc.c */
 703
 704 typedef struct RTCState RTCState;
 705
 706 RTCState *rtc_init(int base, int irq);
 707 void rtc_set_memory(RTCState *s, int addr, int val);
 708 void rtc_set_date(RTCState *s, const struct tm *tm);
 709
 710 /* serial.c */
 711
 712 typedef struct SerialState SerialState;
 713 SerialState *serial_init(int base, int irq, CharDriverState *chr);
 714
 715 /* parallel.c */
 716
 717 typedef struct ParallelState ParallelState;
 718 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
 719
 720 /* i8259.c */
 721
 722 typedef struct PicState2 PicState2;
 723 extern PicState2 *isa_pic;
 724 void pic_set_irq(int irq, int level);
 725 void pic_set_irq_new(void *opaque, int irq, int level);
 726 PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
 727 void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
 728                           void *alt_irq_opaque);
 729 int pic_read_irq(PicState2 *s);
 730 void pic_update_irq(PicState2 *s);
 731 uint32_t pic_intack_read(PicState2 *s);
 732 void pic_info(void);
 733 void irq_info(void);
 734
 735 /* APIC */
 736 typedef struct IOAPICState IOAPICState;
 737
 738 int apic_init(CPUState *env);
 739 int apic_get_interrupt(CPUState *env);
 740 IOAPICState *ioapic_init(void);
 741 void ioapic_set_irq(void *opaque, int vector, int level);
 742
 743 /* i8254.c */
 744
 745 #define PIT_FREQ 1193182
 746
 747 typedef struct PITState PITState;
 748
 749 PITState *pit_init(int base, int irq);
 750 void pit_set_gate(PITState *pit, int channel, int val);
 751 int pit_get_gate(PITState *pit, int channel);
 752 int pit_get_out(PITState *pit, int channel, int64_t current_time);
 753
 754 /* pc.c */
 755 extern QEMUMachine pc_machine;
 756 extern QEMUMachine isapc_machine;
 757
 758 /* ppc.c */
 759 extern QEMUMachine prep_machine;
 760 extern QEMUMachine core99_machine;
 761 extern QEMUMachine heathrow_machine;
 762
 763 /* mips_r4k.c */
 764 extern QEMUMachine mips_machine;
 765
 766 #ifdef TARGET_PPC
 767 ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
 768 #endif
 769 void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
 770
 771 extern CPUWriteMemoryFunc *PPC_io_write[];
 772 extern CPUReadMemoryFunc *PPC_io_read[];
 773 void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
 774
 775 /* sun4m.c */
 776 extern QEMUMachine sun4m_machine;
 777 uint32_t iommu_translate(uint32_t addr);
 778
 779 /* iommu.c */
 780 void *iommu_init(uint32_t addr);
 781 uint32_t iommu_translate_local(void *opaque, uint32_t addr);
 782
 783 /* lance.c */
 784 void lance_init(NetDriverState *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
 785
 786 /* tcx.c */
 787 void *tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
 788                unsigned long vram_offset, int vram_size, int width, int height);
 789 void tcx_update_display(void *opaque);
 790 void tcx_invalidate_display(void *opaque);
 791 void tcx_screen_dump(void *opaque, const char *filename);
 792
 793 /* slavio_intctl.c */
 794 void *slavio_intctl_init();
 795 void slavio_pic_info(void *opaque);
 796 void slavio_irq_info(void *opaque);
 797 void slavio_pic_set_irq(void *opaque, int irq, int level);
 798
 799 /* magic-load.c */
 800 int load_elf(const char *filename, uint8_t *addr);
 801 int load_aout(const char *filename, uint8_t *addr);
 802
 803 /* slavio_timer.c */
 804 void slavio_timer_init(uint32_t addr1, int irq1, uint32_t addr2, int irq2);
 805
 806 /* slavio_serial.c */
 807 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
 808 void slavio_serial_ms_kbd_init(int base, int irq);
 809
 810 /* slavio_misc.c */
 811 void *slavio_misc_init(uint32_t base, int irq);
 812 void slavio_set_power_fail(void *opaque, int power_failing);
 813
 814 /* esp.c */
 815 void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr);
 816
 817 /* sun4u.c */
 818 extern QEMUMachine sun4u_machine;
 819
 820 /* NVRAM helpers */
 821 #include "hw/m48t59.h"
 822
 823 void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
 824 uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
 825 void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
 826 uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
 827 void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
 828 uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
 829 void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
 830                        const unsigned char *str, uint32_t max);
 831 int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
 832 void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
 833                     uint32_t start, uint32_t count);
 834 int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
 835                           const unsigned char *arch,
 836                           uint32_t RAM_size, int boot_device,
 837                           uint32_t kernel_image, uint32_t kernel_size,
 838                           const char *cmdline,
 839                           uint32_t initrd_image, uint32_t initrd_size,
 840                           uint32_t NVRAM_image,
 841                           int width, int height, int depth);
 842
 843 /* adb.c */
 844
 845 #define MAX_ADB_DEVICES 16
 846
 847 #define ADB_MAX_OUT_LEN 16
 848
 849 typedef struct ADBDevice ADBDevice;
 850
 851 /* buf = NULL means polling */
 852 typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
 853                               const uint8_t *buf, int len);
 854 typedef int ADBDeviceReset(ADBDevice *d);
 855
 856 struct ADBDevice {
 857     struct ADBBusState *bus;
 858     int devaddr;
 859     int handler;
 860     ADBDeviceRequest *devreq;
 861     ADBDeviceReset *devreset;
 862     void *opaque;
 863 };
 864
 865 typedef struct ADBBusState {
 866     ADBDevice devices[MAX_ADB_DEVICES];
 867     int nb_devices;
 868     int poll_index;
 869 } ADBBusState;
 870
 871 int adb_request(ADBBusState *s, uint8_t *buf_out,
 872                 const uint8_t *buf, int len);
 873 int adb_poll(ADBBusState *s, uint8_t *buf_out);
 874
 875 ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
 876                                ADBDeviceRequest *devreq,
 877                                ADBDeviceReset *devreset,
 878                                void *opaque);
 879 void adb_kbd_init(ADBBusState *bus);
 880 void adb_mouse_init(ADBBusState *bus);
 881
 882 /* cuda.c */
 883
 884 extern ADBBusState adb_bus;
 885 int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
 886
 887 #include "hw/usb.h"
 888
 889 /* usb ports of the VM */
 890
 891 #define MAX_VM_USB_PORTS 8
 892
 893 extern USBPort *vm_usb_ports[MAX_VM_USB_PORTS];
 894 extern USBDevice *vm_usb_hub;
 895
 896 void do_usb_add(const char *devname);
 897 void do_usb_del(const char *devname);
 898 void usb_info(void);
 899
 900 #endif /* defined(QEMU_TOOL) */
 901
 902 /* monitor.c */
 903 void monitor_init(CharDriverState *hd, int show_banner);
 904 void term_puts(const char *str);
 905 void term_vprintf(const char *fmt, va_list ap);
 906 void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
 907 void term_flush(void);
 908 void term_print_help(void);
 909 void monitor_readline(const char *prompt, int is_password,
 910                       char *buf, int buf_size);
 911
 912 /* readline.c */
 913 typedef void ReadLineFunc(void *opaque, const char *str);
 914
 915 extern int completion_index;
 916 void add_completion(const char *str);
 917 void readline_handle_byte(int ch);
 918 void readline_find_completion(const char *cmdline);
 919 const char *readline_get_history(unsigned int index);
 920 void readline_start(const char *prompt, int is_password,
 921                     ReadLineFunc *readline_func, void *opaque);
 922
 923 void kqemu_record_dump(void);
 924
 925 #endif /* VL_H */