Annotation of qemu/vl.h, revision 1.1.1.4

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

unix.superglobalmegacorp.com