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