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 ram_size;
 130 extern int bios_size;
 131 extern int rtc_utc;
 132 extern int cirrus_vga_enabled;
 133 extern int graphic_width;
 134 extern int graphic_height;
 135 extern int graphic_depth;
 136 extern const char *keyboard_layout;
 137 extern int kqemu_allowed;
 138 extern int win2k_install_hack;
 139 extern int usb_enabled;
 140 extern int smp_cpus;
 141
 142 /* XXX: make it dynamic */
 143 #if defined (TARGET_PPC)
 144 #define BIOS_SIZE ((512 + 32) * 1024)
 145 #elif defined(TARGET_MIPS)
 146 #define BIOS_SIZE (128 * 1024)
 147 #else
 148 #define BIOS_SIZE ((256 + 64) * 1024)
 149 #endif
 150
 151 /* keyboard/mouse support */
 152
 153 #define MOUSE_EVENT_LBUTTON 0x01
 154 #define MOUSE_EVENT_RBUTTON 0x02
 155 #define MOUSE_EVENT_MBUTTON 0x04
 156
 157 typedef void QEMUPutKBDEvent(void *opaque, int keycode);
 158 typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
 159
 160 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
 161 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque, int absolute);
 162
 163 void kbd_put_keycode(int keycode);
 164 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
 165 int kbd_mouse_is_absolute(void);
 166
 167 /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
 168    constants) */
 169 #define QEMU_KEY_ESC1(c) ((c) | 0xe100)
 170 #define QEMU_KEY_BACKSPACE  0x007f
 171 #define QEMU_KEY_UP         QEMU_KEY_ESC1('A')
 172 #define QEMU_KEY_DOWN       QEMU_KEY_ESC1('B')
 173 #define QEMU_KEY_RIGHT      QEMU_KEY_ESC1('C')
 174 #define QEMU_KEY_LEFT       QEMU_KEY_ESC1('D')
 175 #define QEMU_KEY_HOME       QEMU_KEY_ESC1(1)
 176 #define QEMU_KEY_END        QEMU_KEY_ESC1(4)
 177 #define QEMU_KEY_PAGEUP     QEMU_KEY_ESC1(5)
 178 #define QEMU_KEY_PAGEDOWN   QEMU_KEY_ESC1(6)
 179 #define QEMU_KEY_DELETE     QEMU_KEY_ESC1(3)
 180
 181 #define QEMU_KEY_CTRL_UP         0xe400
 182 #define QEMU_KEY_CTRL_DOWN       0xe401
 183 #define QEMU_KEY_CTRL_LEFT       0xe402
 184 #define QEMU_KEY_CTRL_RIGHT      0xe403
 185 #define QEMU_KEY_CTRL_HOME       0xe404
 186 #define QEMU_KEY_CTRL_END        0xe405
 187 #define QEMU_KEY_CTRL_PAGEUP     0xe406
 188 #define QEMU_KEY_CTRL_PAGEDOWN   0xe407
 189
 190 void kbd_put_keysym(int keysym);
 191
 192 /* async I/O support */
 193
 194 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
 195 typedef int IOCanRWHandler(void *opaque);
 196 typedef void IOHandler(void *opaque);
 197
 198 int qemu_set_fd_handler2(int fd,
 199                          IOCanRWHandler *fd_read_poll,
 200                          IOHandler *fd_read,
 201                          IOHandler *fd_write,
 202                          void *opaque);
 203 int qemu_set_fd_handler(int fd,
 204                         IOHandler *fd_read,
 205                         IOHandler *fd_write,
 206                         void *opaque);
 207
 208 /* Polling handling */
 209
 210 /* return TRUE if no sleep should be done afterwards */
 211 typedef int PollingFunc(void *opaque);
 212
 213 int qemu_add_polling_cb(PollingFunc *func, void *opaque);
 214 void qemu_del_polling_cb(PollingFunc *func, void *opaque);
 215
 216 /* character device */
 217
 218 #define CHR_EVENT_BREAK 0 /* serial break char */
 219 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
 220
 221
 222
 223 #define CHR_IOCTL_SERIAL_SET_PARAMS   1
 224 typedef struct {
 225     int speed;
 226     int parity;
 227     int data_bits;
 228     int stop_bits;
 229 } QEMUSerialSetParams;
 230
 231 #define CHR_IOCTL_SERIAL_SET_BREAK    2
 232
 233 #define CHR_IOCTL_PP_READ_DATA        3
 234 #define CHR_IOCTL_PP_WRITE_DATA       4
 235 #define CHR_IOCTL_PP_READ_CONTROL     5
 236 #define CHR_IOCTL_PP_WRITE_CONTROL    6
 237 #define CHR_IOCTL_PP_READ_STATUS      7
 238
 239 typedef void IOEventHandler(void *opaque, int event);
 240
 241 typedef struct CharDriverState {
 242     int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
 243     void (*chr_add_read_handler)(struct CharDriverState *s,
 244                                  IOCanRWHandler *fd_can_read,
 245                                  IOReadHandler *fd_read, void *opaque);
 246     int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
 247     IOEventHandler *chr_event;
 248     void (*chr_send_event)(struct CharDriverState *chr, int event);
 249     void (*chr_close)(struct CharDriverState *chr);
 250     void *opaque;
 251 } CharDriverState;
 252
 253 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
 254 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
 255 void qemu_chr_send_event(CharDriverState *s, int event);
 256 void qemu_chr_add_read_handler(CharDriverState *s,
 257                                IOCanRWHandler *fd_can_read,
 258                                IOReadHandler *fd_read, void *opaque);
 259 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event);
 260 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
 261
 262 /* consoles */
 263
 264 typedef struct DisplayState DisplayState;
 265 typedef struct TextConsole TextConsole;
 266
 267 typedef void (*vga_hw_update_ptr)(void *);
 268 typedef void (*vga_hw_invalidate_ptr)(void *);
 269 typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
 270
 271 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
 272                                   vga_hw_invalidate_ptr invalidate,
 273                                   vga_hw_screen_dump_ptr screen_dump,
 274                                   void *opaque);
 275 void vga_hw_update(void);
 276 void vga_hw_invalidate(void);
 277 void vga_hw_screen_dump(const char *filename);
 278
 279 int is_graphic_console(void);
 280 CharDriverState *text_console_init(DisplayState *ds);
 281 void console_select(unsigned int index);
 282
 283 /* serial ports */
 284
 285 #define MAX_SERIAL_PORTS 4
 286
 287 extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 288
 289 /* parallel ports */
 290
 291 #define MAX_PARALLEL_PORTS 3
 292
 293 extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 294
 295 /* VLANs support */
 296
 297 typedef struct VLANClientState VLANClientState;
 298
 299 struct VLANClientState {
 300     IOReadHandler *fd_read;
 301     /* Packets may still be sent if this returns zero.  It's used to
 302        rate-limit the slirp code.  */
 303     IOCanRWHandler *fd_can_read;
 304     void *opaque;
 305     struct VLANClientState *next;
 306     struct VLANState *vlan;
 307     char info_str[256];
 308 };
 309
 310 typedef struct VLANState {
 311     int id;
 312     VLANClientState *first_client;
 313     struct VLANState *next;
 314 } VLANState;
 315
 316 VLANState *qemu_find_vlan(int id);
 317 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
 318                                       IOReadHandler *fd_read,
 319                                       IOCanRWHandler *fd_can_read,
 320                                       void *opaque);
 321 int qemu_can_send_packet(VLANClientState *vc);
 322 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size);
 323 void qemu_handler_true(void *opaque);
 324
 325 void do_info_network(void);
 326
 327 /* TAP win32 */
 328 int tap_win32_init(VLANState *vlan, const char *ifname);
 329 void tap_win32_poll(void);
 330
 331 /* NIC info */
 332
 333 #define MAX_NICS 8
 334
 335 typedef struct NICInfo {
 336     uint8_t macaddr[6];
 337     const char *model;
 338     VLANState *vlan;
 339 } NICInfo;
 340
 341 extern int nb_nics;
 342 extern NICInfo nd_table[MAX_NICS];
 343
 344 /* timers */
 345
 346 typedef struct QEMUClock QEMUClock;
 347 typedef struct QEMUTimer QEMUTimer;
 348 typedef void QEMUTimerCB(void *opaque);
 349
 350 /* The real time clock should be used only for stuff which does not
 351    change the virtual machine state, as it is run even if the virtual
 352    machine is stopped. The real time clock has a frequency of 1000
 353    Hz. */
 354 extern QEMUClock *rt_clock;
 355
 356 /* The virtual clock is only run during the emulation. It is stopped
 357    when the virtual machine is stopped. Virtual timers use a high
 358    precision clock, usually cpu cycles (use ticks_per_sec). */
 359 extern QEMUClock *vm_clock;
 360
 361 int64_t qemu_get_clock(QEMUClock *clock);
 362
 363 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
 364 void qemu_free_timer(QEMUTimer *ts);
 365 void qemu_del_timer(QEMUTimer *ts);
 366 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
 367 int qemu_timer_pending(QEMUTimer *ts);
 368
 369 extern int64_t ticks_per_sec;
 370 extern int pit_min_timer_count;
 371
 372 void cpu_enable_ticks(void);
 373 void cpu_disable_ticks(void);
 374
 375 /* VM Load/Save */
 376
 377 typedef FILE QEMUFile;
 378
 379 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
 380 void qemu_put_byte(QEMUFile *f, int v);
 381 void qemu_put_be16(QEMUFile *f, unsigned int v);
 382 void qemu_put_be32(QEMUFile *f, unsigned int v);
 383 void qemu_put_be64(QEMUFile *f, uint64_t v);
 384 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
 385 int qemu_get_byte(QEMUFile *f);
 386 unsigned int qemu_get_be16(QEMUFile *f);
 387 unsigned int qemu_get_be32(QEMUFile *f);
 388 uint64_t qemu_get_be64(QEMUFile *f);
 389
 390 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
 391 {
 392     qemu_put_be64(f, *pv);
 393 }
 394
 395 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
 396 {
 397     qemu_put_be32(f, *pv);
 398 }
 399
 400 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
 401 {
 402     qemu_put_be16(f, *pv);
 403 }
 404
 405 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
 406 {
 407     qemu_put_byte(f, *pv);
 408 }
 409
 410 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
 411 {
 412     *pv = qemu_get_be64(f);
 413 }
 414
 415 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
 416 {
 417     *pv = qemu_get_be32(f);
 418 }
 419
 420 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
 421 {
 422     *pv = qemu_get_be16(f);
 423 }
 424
 425 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
 426 {
 427     *pv = qemu_get_byte(f);
 428 }
 429
 430 #if TARGET_LONG_BITS == 64
 431 #define qemu_put_betl qemu_put_be64
 432 #define qemu_get_betl qemu_get_be64
 433 #define qemu_put_betls qemu_put_be64s
 434 #define qemu_get_betls qemu_get_be64s
 435 #else
 436 #define qemu_put_betl qemu_put_be32
 437 #define qemu_get_betl qemu_get_be32
 438 #define qemu_put_betls qemu_put_be32s
 439 #define qemu_get_betls qemu_get_be32s
 440 #endif
 441
 442 int64_t qemu_ftell(QEMUFile *f);
 443 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
 444
 445 typedef void SaveStateHandler(QEMUFile *f, void *opaque);
 446 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
 447
 448 int qemu_loadvm(const char *filename);
 449 int qemu_savevm(const char *filename);
 450 int register_savevm(const char *idstr,
 451                     int instance_id,
 452                     int version_id,
 453                     SaveStateHandler *save_state,
 454                     LoadStateHandler *load_state,
 455                     void *opaque);
 456 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
 457 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
 458
 459 void cpu_save(QEMUFile *f, void *opaque);
 460 int cpu_load(QEMUFile *f, void *opaque, int version_id);
 461
 462 /* block.c */
 463 typedef struct BlockDriverState BlockDriverState;
 464 typedef struct BlockDriver BlockDriver;
 465
 466 extern BlockDriver bdrv_raw;
 467 extern BlockDriver bdrv_cow;
 468 extern BlockDriver bdrv_qcow;
 469 extern BlockDriver bdrv_vmdk;
 470 extern BlockDriver bdrv_cloop;
 471 extern BlockDriver bdrv_dmg;
 472 extern BlockDriver bdrv_bochs;
 473 extern BlockDriver bdrv_vpc;
 474 extern BlockDriver bdrv_vvfat;
 475
 476 void bdrv_init(void);
 477 BlockDriver *bdrv_find_format(const char *format_name);
 478 int bdrv_create(BlockDriver *drv,
 479                 const char *filename, int64_t size_in_sectors,
 480                 const char *backing_file, int flags);
 481 BlockDriverState *bdrv_new(const char *device_name);
 482 void bdrv_delete(BlockDriverState *bs);
 483 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
 484 int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
 485                BlockDriver *drv);
 486 void bdrv_close(BlockDriverState *bs);
 487 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 488               uint8_t *buf, int nb_sectors);
 489 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 490                const uint8_t *buf, int nb_sectors);
 491 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
 492 int bdrv_commit(BlockDriverState *bs);
 493 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
 494
 495 #define BDRV_TYPE_HD     0
 496 #define BDRV_TYPE_CDROM  1
 497 #define BDRV_TYPE_FLOPPY 2
 498 #define BIOS_ATA_TRANSLATION_AUTO 0
 499 #define BIOS_ATA_TRANSLATION_NONE 1
 500 #define BIOS_ATA_TRANSLATION_LBA  2
 501
 502 void bdrv_set_geometry_hint(BlockDriverState *bs,
 503                             int cyls, int heads, int secs);
 504 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 505 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
 506 void bdrv_get_geometry_hint(BlockDriverState *bs,
 507                             int *pcyls, int *pheads, int *psecs);
 508 int bdrv_get_type_hint(BlockDriverState *bs);
 509 int bdrv_get_translation_hint(BlockDriverState *bs);
 510 int bdrv_is_removable(BlockDriverState *bs);
 511 int bdrv_is_read_only(BlockDriverState *bs);
 512 int bdrv_is_inserted(BlockDriverState *bs);
 513 int bdrv_is_locked(BlockDriverState *bs);
 514 void bdrv_set_locked(BlockDriverState *bs, int locked);
 515 void bdrv_set_change_cb(BlockDriverState *bs,
 516                         void (*change_cb)(void *opaque), void *opaque);
 517 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
 518 void bdrv_info(void);
 519 BlockDriverState *bdrv_find(const char *name);
 520 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
 521 int bdrv_is_encrypted(BlockDriverState *bs);
 522 int bdrv_set_key(BlockDriverState *bs, const char *key);
 523 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 524                          void *opaque);
 525 const char *bdrv_get_device_name(BlockDriverState *bs);
 526
 527 int qcow_get_cluster_size(BlockDriverState *bs);
 528 int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
 529                           const uint8_t *buf);
 530
 531 #ifndef QEMU_TOOL
 532
 533 typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
 534                                  int boot_device,
 535              DisplayState *ds, const char **fd_filename, int snapshot,
 536              const char *kernel_filename, const char *kernel_cmdline,
 537              const char *initrd_filename);
 538
 539 typedef struct QEMUMachine {
 540     const char *name;
 541     const char *desc;
 542     QEMUMachineInitFunc *init;
 543     struct QEMUMachine *next;
 544 } QEMUMachine;
 545
 546 int qemu_register_machine(QEMUMachine *m);
 547
 548 typedef void SetIRQFunc(void *opaque, int irq_num, int level);
 549 typedef void IRQRequestFunc(void *opaque, int level);
 550
 551 /* ISA bus */
 552
 553 extern target_phys_addr_t isa_mem_base;
 554
 555 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
 556 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
 557
 558 int register_ioport_read(int start, int length, int size,
 559                          IOPortReadFunc *func, void *opaque);
 560 int register_ioport_write(int start, int length, int size,
 561                           IOPortWriteFunc *func, void *opaque);
 562 void isa_unassign_ioport(int start, int length);
 563
 564 /* PCI bus */
 565
 566 extern target_phys_addr_t pci_mem_base;
 567
 568 typedef struct PCIBus PCIBus;
 569 typedef struct PCIDevice PCIDevice;
 570
 571 typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
 572                                 uint32_t address, uint32_t data, int len);
 573 typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
 574                                    uint32_t address, int len);
 575 typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
 576                                 uint32_t addr, uint32_t size, int type);
 577
 578 #define PCI_ADDRESS_SPACE_MEM           0x00
 579 #define PCI_ADDRESS_SPACE_IO            0x01
 580 #define PCI_ADDRESS_SPACE_MEM_PREFETCH  0x08
 581
 582 typedef struct PCIIORegion {
 583     uint32_t addr; /* current PCI mapping address. -1 means not mapped */
 584     uint32_t size;
 585     uint8_t type;
 586     PCIMapIORegionFunc *map_func;
 587 } PCIIORegion;
 588
 589 #define PCI_ROM_SLOT 6
 590 #define PCI_NUM_REGIONS 7
 591 struct PCIDevice {
 592     /* PCI config space */
 593     uint8_t config[256];
 594
 595     /* the following fields are read only */
 596     PCIBus *bus;
 597     int devfn;
 598     char name[64];
 599     PCIIORegion io_regions[PCI_NUM_REGIONS];
 600
 601     /* do not access the following fields */
 602     PCIConfigReadFunc *config_read;
 603     PCIConfigWriteFunc *config_write;
 604     int irq_index;
 605 };
 606
 607 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
 608                                int instance_size, int devfn,
 609                                PCIConfigReadFunc *config_read,
 610                                PCIConfigWriteFunc *config_write);
 611
 612 void pci_register_io_region(PCIDevice *pci_dev, int region_num,
 613                             uint32_t size, int type,
 614                             PCIMapIORegionFunc *map_func);
 615
 616 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
 617
 618 uint32_t pci_default_read_config(PCIDevice *d,
 619                                  uint32_t address, int len);
 620 void pci_default_write_config(PCIDevice *d,
 621                               uint32_t address, uint32_t val, int len);
 622 void generic_pci_save(QEMUFile* f, void *opaque);
 623 int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
 624
 625 extern struct PIIX3State *piix3_state;
 626
 627 PCIBus *i440fx_init(void);
 628 void piix3_init(PCIBus *bus);
 629 void pci_bios_init(void);
 630 void pci_info(void);
 631
 632 /* temporary: will be moved in platform specific file */
 633 void pci_set_pic(PCIBus *bus, SetIRQFunc *set_irq, void *irq_opaque);
 634 PCIBus *pci_prep_init(void);
 635 PCIBus *pci_grackle_init(uint32_t base);
 636 PCIBus *pci_pmac_init(void);
 637 PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base);
 638
 639 void pci_nic_init(PCIBus *bus, NICInfo *nd);
 640
 641 /* openpic.c */
 642 typedef struct openpic_t openpic_t;
 643 void openpic_set_irq(void *opaque, int n_IRQ, int level);
 644 openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus,
 645                          CPUState **envp);
 646
 647 /* heathrow_pic.c */
 648 typedef struct HeathrowPICS HeathrowPICS;
 649 void heathrow_pic_set_irq(void *opaque, int num, int level);
 650 HeathrowPICS *heathrow_pic_init(int *pmem_index);
 651
 652 #ifdef HAS_AUDIO
 653 struct soundhw {
 654     const char *name;
 655     const char *descr;
 656     int enabled;
 657     int isa;
 658     union {
 659         int (*init_isa) (AudioState *s);
 660         int (*init_pci) (PCIBus *bus, AudioState *s);
 661     } init;
 662 };
 663
 664 extern struct soundhw soundhw[];
 665 #endif
 666
 667 /* vga.c */
 668
 669 #define VGA_RAM_SIZE (4096 * 1024)
 670
 671 struct DisplayState {
 672     uint8_t *data;
 673     int linesize;
 674     int depth;
 675     int width;
 676     int height;
 677     void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
 678     void (*dpy_resize)(struct DisplayState *s, int w, int h);
 679     void (*dpy_refresh)(struct DisplayState *s);
 680 };
 681
 682 static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
 683 {
 684     s->dpy_update(s, x, y, w, h);
 685 }
 686
 687 static inline void dpy_resize(DisplayState *s, int w, int h)
 688 {
 689     s->dpy_resize(s, w, h);
 690 }
 691
 692 int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 693                    unsigned long vga_ram_offset, int vga_ram_size,
 694                    unsigned long vga_bios_offset, int vga_bios_size);
 695
 696 /* cirrus_vga.c */
 697 void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 698                          unsigned long vga_ram_offset, int vga_ram_size);
 699 void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
 700                          unsigned long vga_ram_offset, int vga_ram_size);
 701
 702 /* sdl.c */
 703 void sdl_display_init(DisplayState *ds, int full_screen);
 704
 705 /* cocoa.m */
 706 void cocoa_display_init(DisplayState *ds, int full_screen);
 707
 708 /* ide.c */
 709 #define MAX_DISKS 4
 710
 711 extern BlockDriverState *bs_table[MAX_DISKS];
 712
 713 void isa_ide_init(int iobase, int iobase2, int irq,
 714                   BlockDriverState *hd0, BlockDriverState *hd1);
 715 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
 716                          int secondary_ide_enabled);
 717 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table);
 718 int pmac_ide_init (BlockDriverState **hd_table,
 719                    SetIRQFunc *set_irq, void *irq_opaque, int irq);
 720
 721 /* es1370.c */
 722 int es1370_init (PCIBus *bus, AudioState *s);
 723
 724 /* sb16.c */
 725 int SB16_init (AudioState *s);
 726
 727 /* adlib.c */
 728 int Adlib_init (AudioState *s);
 729
 730 /* gus.c */
 731 int GUS_init (AudioState *s);
 732
 733 /* dma.c */
 734 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
 735 int DMA_get_channel_mode (int nchan);
 736 int DMA_read_memory (int nchan, void *buf, int pos, int size);
 737 int DMA_write_memory (int nchan, void *buf, int pos, int size);
 738 void DMA_hold_DREQ (int nchan);
 739 void DMA_release_DREQ (int nchan);
 740 void DMA_schedule(int nchan);
 741 void DMA_run (void);
 742 void DMA_init (int high_page_enable);
 743 void DMA_register_channel (int nchan,
 744                            DMA_transfer_handler transfer_handler,
 745                            void *opaque);
 746 /* fdc.c */
 747 #define MAX_FD 2
 748 extern BlockDriverState *fd_table[MAX_FD];
 749
 750 typedef struct fdctrl_t fdctrl_t;
 751
 752 fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
 753                        uint32_t io_base,
 754                        BlockDriverState **fds);
 755 int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
 756
 757 /* ne2000.c */
 758
 759 void isa_ne2000_init(int base, int irq, NICInfo *nd);
 760 void pci_ne2000_init(PCIBus *bus, NICInfo *nd);
 761
 762 /* rtl8139.c */
 763
 764 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd);
 765
 766 /* pckbd.c */
 767
 768 void kbd_init(void);
 769
 770 /* mc146818rtc.c */
 771
 772 typedef struct RTCState RTCState;
 773
 774 RTCState *rtc_init(int base, int irq);
 775 void rtc_set_memory(RTCState *s, int addr, int val);
 776 void rtc_set_date(RTCState *s, const struct tm *tm);
 777
 778 /* serial.c */
 779
 780 typedef struct SerialState SerialState;
 781 SerialState *serial_init(SetIRQFunc *set_irq, void *opaque,
 782                          int base, int irq, CharDriverState *chr);
 783 SerialState *serial_mm_init (SetIRQFunc *set_irq, void *opaque,
 784                              target_ulong base, int it_shift,
 785                              int irq, CharDriverState *chr);
 786
 787 /* parallel.c */
 788
 789 typedef struct ParallelState ParallelState;
 790 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
 791
 792 /* i8259.c */
 793
 794 typedef struct PicState2 PicState2;
 795 extern PicState2 *isa_pic;
 796 void pic_set_irq(int irq, int level);
 797 void pic_set_irq_new(void *opaque, int irq, int level);
 798 PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
 799 void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
 800                           void *alt_irq_opaque);
 801 int pic_read_irq(PicState2 *s);
 802 void pic_update_irq(PicState2 *s);
 803 uint32_t pic_intack_read(PicState2 *s);
 804 void pic_info(void);
 805 void irq_info(void);
 806
 807 /* APIC */
 808 typedef struct IOAPICState IOAPICState;
 809
 810 int apic_init(CPUState *env);
 811 int apic_get_interrupt(CPUState *env);
 812 IOAPICState *ioapic_init(void);
 813 void ioapic_set_irq(void *opaque, int vector, int level);
 814
 815 /* i8254.c */
 816
 817 #define PIT_FREQ 1193182
 818
 819 typedef struct PITState PITState;
 820
 821 PITState *pit_init(int base, int irq);
 822 void pit_set_gate(PITState *pit, int channel, int val);
 823 int pit_get_gate(PITState *pit, int channel);
 824 int pit_get_out(PITState *pit, int channel, int64_t current_time);
 825
 826 /* pc.c */
 827 extern QEMUMachine pc_machine;
 828 extern QEMUMachine isapc_machine;
 829
 830 void ioport_set_a20(int enable);
 831 int ioport_get_a20(void);
 832
 833 /* ppc.c */
 834 extern QEMUMachine prep_machine;
 835 extern QEMUMachine core99_machine;
 836 extern QEMUMachine heathrow_machine;
 837
 838 /* mips_r4k.c */
 839 extern QEMUMachine mips_machine;
 840
 841 #ifdef TARGET_PPC
 842 ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
 843 #endif
 844 void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
 845
 846 extern CPUWriteMemoryFunc *PPC_io_write[];
 847 extern CPUReadMemoryFunc *PPC_io_read[];
 848 void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
 849
 850 /* sun4m.c */
 851 extern QEMUMachine sun4m_machine;
 852 uint32_t iommu_translate(uint32_t addr);
 853 void pic_set_irq_cpu(int irq, int level, unsigned int cpu);
 854
 855 /* iommu.c */
 856 void *iommu_init(uint32_t addr);
 857 uint32_t iommu_translate_local(void *opaque, uint32_t addr);
 858
 859 /* lance.c */
 860 void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
 861
 862 /* tcx.c */
 863 void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
 864                unsigned long vram_offset, int vram_size, int width, int height);
 865
 866 /* slavio_intctl.c */
 867 void *slavio_intctl_init();
 868 void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env);
 869 void slavio_pic_info(void *opaque);
 870 void slavio_irq_info(void *opaque);
 871 void slavio_pic_set_irq(void *opaque, int irq, int level);
 872 void slavio_pic_set_irq_cpu(void *opaque, int irq, int level, unsigned int cpu);
 873
 874 /* magic-load.c */
 875 int load_elf(const char *filename, uint8_t *addr);
 876 int load_aout(const char *filename, uint8_t *addr);
 877
 878 /* slavio_timer.c */
 879 void slavio_timer_init(uint32_t addr, int irq, int mode, unsigned int cpu);
 880
 881 /* slavio_serial.c */
 882 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
 883 void slavio_serial_ms_kbd_init(int base, int irq);
 884
 885 /* slavio_misc.c */
 886 void *slavio_misc_init(uint32_t base, int irq);
 887 void slavio_set_power_fail(void *opaque, int power_failing);
 888
 889 /* esp.c */
 890 void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr);
 891
 892 /* sun4u.c */
 893 extern QEMUMachine sun4u_machine;
 894
 895 /* NVRAM helpers */
 896 #include "hw/m48t59.h"
 897
 898 void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
 899 uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
 900 void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
 901 uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
 902 void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
 903 uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
 904 void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
 905                        const unsigned char *str, uint32_t max);
 906 int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
 907 void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
 908                     uint32_t start, uint32_t count);
 909 int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
 910                           const unsigned char *arch,
 911                           uint32_t RAM_size, int boot_device,
 912                           uint32_t kernel_image, uint32_t kernel_size,
 913                           const char *cmdline,
 914                           uint32_t initrd_image, uint32_t initrd_size,
 915                           uint32_t NVRAM_image,
 916                           int width, int height, int depth);
 917
 918 /* adb.c */
 919
 920 #define MAX_ADB_DEVICES 16
 921
 922 #define ADB_MAX_OUT_LEN 16
 923
 924 typedef struct ADBDevice ADBDevice;
 925
 926 /* buf = NULL means polling */
 927 typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
 928                               const uint8_t *buf, int len);
 929 typedef int ADBDeviceReset(ADBDevice *d);
 930
 931 struct ADBDevice {
 932     struct ADBBusState *bus;
 933     int devaddr;
 934     int handler;
 935     ADBDeviceRequest *devreq;
 936     ADBDeviceReset *devreset;
 937     void *opaque;
 938 };
 939
 940 typedef struct ADBBusState {
 941     ADBDevice devices[MAX_ADB_DEVICES];
 942     int nb_devices;
 943     int poll_index;
 944 } ADBBusState;
 945
 946 int adb_request(ADBBusState *s, uint8_t *buf_out,
 947                 const uint8_t *buf, int len);
 948 int adb_poll(ADBBusState *s, uint8_t *buf_out);
 949
 950 ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
 951                                ADBDeviceRequest *devreq,
 952                                ADBDeviceReset *devreset,
 953                                void *opaque);
 954 void adb_kbd_init(ADBBusState *bus);
 955 void adb_mouse_init(ADBBusState *bus);
 956
 957 /* cuda.c */
 958
 959 extern ADBBusState adb_bus;
 960 int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
 961
 962 #include "hw/usb.h"
 963
 964 /* usb ports of the VM */
 965
 966 #define MAX_VM_USB_PORTS 8
 967
 968 extern USBPort *vm_usb_ports[MAX_VM_USB_PORTS];
 969 extern USBDevice *vm_usb_hub;
 970
 971 void do_usb_add(const char *devname);
 972 void do_usb_del(const char *devname);
 973 void usb_info(void);
 974
 975 /* integratorcp.c */
 976 extern QEMUMachine integratorcp926_machine;
 977 extern QEMUMachine integratorcp1026_machine;
 978
 979 /* versatilepb.c */
 980 extern QEMUMachine versatilepb_machine;
 981
 982 /* ps2.c */
 983 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
 984 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
 985 void ps2_write_mouse(void *, int val);
 986 void ps2_write_keyboard(void *, int val);
 987 uint32_t ps2_read_data(void *);
 988 void ps2_queue(void *, int b);
 989 void ps2_keyboard_set_translation(void *opaque, int mode);
 990
 991 /* smc91c111.c */
 992 void smc91c111_init(NICInfo *, uint32_t, void *, int);
 993
 994 /* pl110.c */
 995 void *pl110_init(DisplayState *ds, uint32_t base, void *pic, int irq, int);
 996
 997 /* pl011.c */
 998 void pl011_init(uint32_t base, void *pic, int irq, CharDriverState *chr);
 999
1000 /* pl050.c */
1001 void pl050_init(uint32_t base, void *pic, int irq, int is_mouse);
1002
1003 /* pl080.c */
1004 void *pl080_init(uint32_t base, void *pic, int irq);
1005
1006 /* pl190.c */
1007 void *pl190_init(uint32_t base, void *parent, int irq, int fiq);
1008
1009 /* arm-timer.c */
1010 void sp804_init(uint32_t base, void *pic, int irq);
1011 void icp_pit_init(uint32_t base, void *pic, int irq);
1012
1013 #endif /* defined(QEMU_TOOL) */
1014
1015 /* monitor.c */
1016 void monitor_init(CharDriverState *hd, int show_banner);
1017 void term_puts(const char *str);
1018 void term_vprintf(const char *fmt, va_list ap);
1019 void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
1020 void term_flush(void);
1021 void term_print_help(void);
1022 void monitor_readline(const char *prompt, int is_password,
1023                       char *buf, int buf_size);
1024
1025 /* readline.c */
1026 typedef void ReadLineFunc(void *opaque, const char *str);
1027
1028 extern int completion_index;
1029 void add_completion(const char *str);
1030 void readline_handle_byte(int ch);
1031 void readline_find_completion(const char *cmdline);
1032 const char *readline_get_history(unsigned int index);
1033 void readline_start(const char *prompt, int is_password,
1034                     ReadLineFunc *readline_func, void *opaque);
1035
1036 void kqemu_record_dump(void);
1037
1038 #endif /* VL_H */