Annotation of qemu/vl.h, revision 1.1.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