Annotation of qemu/vl.h, revision 1.1

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

unix.superglobalmegacorp.com