Annotation of qemu/vl.h, revision 1.1.1.5

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

unix.superglobalmegacorp.com