ia64/xen-unstable

view tools/ioemu/vl.h @ 11029:bd04004865ba

[qemu] Add vncunused option.
If the port used for the requested display number is in use, try
additional ports until a free port is found.

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