blob: 94266212766848e9aef4bb74a11dc876796d8e30 [file] [log] [blame]
bellardfc01f7e2003-06-30 10:03:06 +00001/*
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
bellard67b915a2004-03-31 23:37:16 +000027/* 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>
bellard85571bc2004-11-07 18:04:02 +000033#include <limits.h>
bellard8a7ddc32004-03-31 19:00:16 +000034#include <time.h>
bellard67b915a2004-03-31 23:37:16 +000035#include <ctype.h>
36#include <errno.h>
37#include <unistd.h>
38#include <fcntl.h>
bellard7d3505c2004-05-12 19:32:15 +000039#include <sys/stat.h>
bellardfb065182004-11-09 23:09:44 +000040#include "audio/audio.h"
bellard67b915a2004-03-31 23:37:16 +000041
42#ifndef O_LARGEFILE
43#define O_LARGEFILE 0
44#endif
bellard40c3bac2004-04-04 12:56:28 +000045#ifndef O_BINARY
46#define O_BINARY 0
47#endif
bellard67b915a2004-03-31 23:37:16 +000048
49#ifdef _WIN32
bellard57d1a2b2004-08-03 21:15:11 +000050#define lseek _lseeki64
51#define ENOTSUP 4096
52/* XXX: find 64 bit version */
53#define ftruncate chsize
54
55static inline char *realpath(const char *path, char *resolved_path)
56{
57 _fullpath(resolved_path, path, _MAX_PATH);
58 return resolved_path;
59}
bellard67b915a2004-03-31 23:37:16 +000060#endif
bellard8a7ddc32004-03-31 19:00:16 +000061
bellardea2384d2004-08-01 21:59:26 +000062#ifdef QEMU_TOOL
63
64/* we use QEMU_TOOL in the command line tools which do not depend on
65 the target CPU type */
66#include "config-host.h"
67#include <setjmp.h>
68#include "osdep.h"
69#include "bswap.h"
70
71#else
72
bellard16f62432004-02-25 23:25:55 +000073#include "cpu.h"
74
bellardea2384d2004-08-01 21:59:26 +000075#endif /* !defined(QEMU_TOOL) */
76
bellard67b915a2004-03-31 23:37:16 +000077#ifndef glue
78#define xglue(x, y) x ## y
79#define glue(x, y) xglue(x, y)
80#define stringify(s) tostring(s)
81#define tostring(s) #s
82#endif
83
bellard33e39632003-07-06 17:15:21 +000084/* vl.c */
bellard80cabfa2004-03-14 12:20:30 +000085uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
bellard313aa562003-08-10 21:52:11 +000086
bellard80cabfa2004-03-14 12:20:30 +000087void hw_error(const char *fmt, ...);
88
bellard7587cf42004-06-20 13:43:27 +000089int get_image_size(const char *filename);
bellard80cabfa2004-03-14 12:20:30 +000090int load_image(const char *filename, uint8_t *addr);
91extern const char *bios_dir;
92
93void pstrcpy(char *buf, int buf_size, const char *str);
94char *pstrcat(char *buf, int buf_size, const char *s);
bellard82c643f2004-07-14 17:28:13 +000095int strstart(const char *str, const char *val, const char **ptr);
bellardc4b1fcc2004-03-14 21:44:30 +000096
bellard8a7ddc32004-03-31 19:00:16 +000097extern int vm_running;
98
99typedef void VMStopHandler(void *opaque, int reason);
100
101int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
102void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
103
104void vm_start(void);
105void vm_stop(int reason);
106
bellardbb0c6722004-06-20 12:37:32 +0000107typedef void QEMUResetHandler(void *opaque);
108
109void qemu_register_reset(QEMUResetHandler *func, void *opaque);
110void qemu_system_reset_request(void);
111void qemu_system_shutdown_request(void);
112
bellardea2384d2004-08-01 21:59:26 +0000113void main_loop_wait(int timeout);
114
bellardaaaa7df2004-04-26 20:56:53 +0000115extern int audio_enabled;
bellardfb065182004-11-09 23:09:44 +0000116extern int sb16_enabled;
117extern int adlib_enabled;
118extern int gus_enabled;
bellard0ced6582004-05-23 21:06:12 +0000119extern int ram_size;
120extern int bios_size;
bellardee22c2f2004-06-03 12:49:50 +0000121extern int rtc_utc;
bellard1f042752004-06-05 13:46:47 +0000122extern int cirrus_vga_enabled;
bellard28b9b5a2004-06-21 16:46:35 +0000123extern int graphic_width;
124extern int graphic_height;
125extern int graphic_depth;
bellard3d11d0e2004-12-12 16:56:30 +0000126extern const char *keyboard_layout;
bellard0ced6582004-05-23 21:06:12 +0000127
128/* XXX: make it dynamic */
129#if defined (TARGET_PPC)
130#define BIOS_SIZE (512 * 1024)
131#else
bellard7587cf42004-06-20 13:43:27 +0000132#define BIOS_SIZE ((256 + 64) * 1024)
bellard0ced6582004-05-23 21:06:12 +0000133#endif
bellardaaaa7df2004-04-26 20:56:53 +0000134
bellard63066f42004-06-03 18:45:02 +0000135/* keyboard/mouse support */
136
137#define MOUSE_EVENT_LBUTTON 0x01
138#define MOUSE_EVENT_RBUTTON 0x02
139#define MOUSE_EVENT_MBUTTON 0x04
140
141typedef void QEMUPutKBDEvent(void *opaque, int keycode);
142typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
143
144void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
145void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque);
146
147void kbd_put_keycode(int keycode);
148void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
149
bellard82c643f2004-07-14 17:28:13 +0000150/* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
151 constants) */
152#define QEMU_KEY_ESC1(c) ((c) | 0xe100)
153#define QEMU_KEY_BACKSPACE 0x007f
154#define QEMU_KEY_UP QEMU_KEY_ESC1('A')
155#define QEMU_KEY_DOWN QEMU_KEY_ESC1('B')
156#define QEMU_KEY_RIGHT QEMU_KEY_ESC1('C')
157#define QEMU_KEY_LEFT QEMU_KEY_ESC1('D')
158#define QEMU_KEY_HOME QEMU_KEY_ESC1(1)
159#define QEMU_KEY_END QEMU_KEY_ESC1(4)
160#define QEMU_KEY_PAGEUP QEMU_KEY_ESC1(5)
161#define QEMU_KEY_PAGEDOWN QEMU_KEY_ESC1(6)
162#define QEMU_KEY_DELETE QEMU_KEY_ESC1(3)
163
164#define QEMU_KEY_CTRL_UP 0xe400
165#define QEMU_KEY_CTRL_DOWN 0xe401
166#define QEMU_KEY_CTRL_LEFT 0xe402
167#define QEMU_KEY_CTRL_RIGHT 0xe403
168#define QEMU_KEY_CTRL_HOME 0xe404
169#define QEMU_KEY_CTRL_END 0xe405
170#define QEMU_KEY_CTRL_PAGEUP 0xe406
171#define QEMU_KEY_CTRL_PAGEDOWN 0xe407
172
173void kbd_put_keysym(int keysym);
174
bellardc4b1fcc2004-03-14 21:44:30 +0000175/* async I/O support */
176
177typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
178typedef int IOCanRWHandler(void *opaque);
179
bellard8a7ddc32004-03-31 19:00:16 +0000180int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read,
181 IOReadHandler *fd_read, void *opaque);
182void qemu_del_fd_read_handler(int fd);
183
bellard82c643f2004-07-14 17:28:13 +0000184/* character device */
185
186#define CHR_EVENT_BREAK 0 /* serial break char */
bellardea2384d2004-08-01 21:59:26 +0000187#define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
bellard82c643f2004-07-14 17:28:13 +0000188
189typedef void IOEventHandler(void *opaque, int event);
190
191typedef struct CharDriverState {
192 int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
193 void (*chr_add_read_handler)(struct CharDriverState *s,
194 IOCanRWHandler *fd_can_read,
195 IOReadHandler *fd_read, void *opaque);
196 IOEventHandler *chr_event;
bellardeb45f5f2004-09-18 19:33:09 +0000197 void (*chr_send_event)(struct CharDriverState *chr, int event);
bellard82c643f2004-07-14 17:28:13 +0000198 void *opaque;
199} CharDriverState;
200
201void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
202int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
bellardea2384d2004-08-01 21:59:26 +0000203void qemu_chr_send_event(CharDriverState *s, int event);
bellard82c643f2004-07-14 17:28:13 +0000204void qemu_chr_add_read_handler(CharDriverState *s,
205 IOCanRWHandler *fd_can_read,
206 IOReadHandler *fd_read, void *opaque);
207void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event);
208
bellard82c643f2004-07-14 17:28:13 +0000209/* consoles */
210
211typedef struct DisplayState DisplayState;
212typedef struct TextConsole TextConsole;
213
214extern TextConsole *vga_console;
215
216TextConsole *graphic_console_init(DisplayState *ds);
217int is_active_console(TextConsole *s);
218CharDriverState *text_console_init(DisplayState *ds);
219void console_select(unsigned int index);
220
bellard8d11df92004-08-24 21:13:40 +0000221/* serial ports */
222
223#define MAX_SERIAL_PORTS 4
224
225extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
226
bellardc20709a2004-04-21 23:27:19 +0000227/* network redirectors support */
228
229#define MAX_NICS 8
230
231typedef struct NetDriverState {
232 int index; /* index number in QEMU */
233 uint8_t macaddr[6];
234 char ifname[16];
235 void (*send_packet)(struct NetDriverState *nd,
236 const uint8_t *buf, int size);
237 void (*add_read_packet)(struct NetDriverState *nd,
238 IOCanRWHandler *fd_can_read,
239 IOReadHandler *fd_read, void *opaque);
240 /* tun specific data */
241 int fd;
242 /* slirp specific data */
243} NetDriverState;
244
245extern int nb_nics;
246extern NetDriverState nd_table[MAX_NICS];
247
248void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size);
249void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read,
250 IOReadHandler *fd_read, void *opaque);
251
bellard8a7ddc32004-03-31 19:00:16 +0000252/* timers */
253
254typedef struct QEMUClock QEMUClock;
255typedef struct QEMUTimer QEMUTimer;
256typedef void QEMUTimerCB(void *opaque);
257
258/* The real time clock should be used only for stuff which does not
259 change the virtual machine state, as it is run even if the virtual
bellard69b91032004-05-18 23:05:28 +0000260 machine is stopped. The real time clock has a frequency of 1000
bellard8a7ddc32004-03-31 19:00:16 +0000261 Hz. */
262extern QEMUClock *rt_clock;
263
bellarde80cfcf2004-12-19 23:18:01 +0000264/* The virtual clock is only run during the emulation. It is stopped
bellard8a7ddc32004-03-31 19:00:16 +0000265 when the virtual machine is stopped. Virtual timers use a high
266 precision clock, usually cpu cycles (use ticks_per_sec). */
267extern QEMUClock *vm_clock;
268
269int64_t qemu_get_clock(QEMUClock *clock);
270
271QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
272void qemu_free_timer(QEMUTimer *ts);
273void qemu_del_timer(QEMUTimer *ts);
274void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
275int qemu_timer_pending(QEMUTimer *ts);
276
277extern int64_t ticks_per_sec;
278extern int pit_min_timer_count;
279
280void cpu_enable_ticks(void);
281void cpu_disable_ticks(void);
282
283/* VM Load/Save */
284
285typedef FILE QEMUFile;
286
287void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
288void qemu_put_byte(QEMUFile *f, int v);
289void qemu_put_be16(QEMUFile *f, unsigned int v);
290void qemu_put_be32(QEMUFile *f, unsigned int v);
291void qemu_put_be64(QEMUFile *f, uint64_t v);
292int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
293int qemu_get_byte(QEMUFile *f);
294unsigned int qemu_get_be16(QEMUFile *f);
295unsigned int qemu_get_be32(QEMUFile *f);
296uint64_t qemu_get_be64(QEMUFile *f);
297
298static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
299{
300 qemu_put_be64(f, *pv);
301}
302
303static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
304{
305 qemu_put_be32(f, *pv);
306}
307
308static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
309{
310 qemu_put_be16(f, *pv);
311}
312
313static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
314{
315 qemu_put_byte(f, *pv);
316}
317
318static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
319{
320 *pv = qemu_get_be64(f);
321}
322
323static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
324{
325 *pv = qemu_get_be32(f);
326}
327
328static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
329{
330 *pv = qemu_get_be16(f);
331}
332
333static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
334{
335 *pv = qemu_get_byte(f);
336}
337
338int64_t qemu_ftell(QEMUFile *f);
339int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
340
341typedef void SaveStateHandler(QEMUFile *f, void *opaque);
342typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
343
344int qemu_loadvm(const char *filename);
345int qemu_savevm(const char *filename);
346int register_savevm(const char *idstr,
347 int instance_id,
348 int version_id,
349 SaveStateHandler *save_state,
350 LoadStateHandler *load_state,
351 void *opaque);
352void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
353void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
bellardc4b1fcc2004-03-14 21:44:30 +0000354
bellardfc01f7e2003-06-30 10:03:06 +0000355/* block.c */
356typedef struct BlockDriverState BlockDriverState;
bellardea2384d2004-08-01 21:59:26 +0000357typedef struct BlockDriver BlockDriver;
bellardfc01f7e2003-06-30 10:03:06 +0000358
bellardea2384d2004-08-01 21:59:26 +0000359extern BlockDriver bdrv_raw;
360extern BlockDriver bdrv_cow;
361extern BlockDriver bdrv_qcow;
362extern BlockDriver bdrv_vmdk;
bellard3c565212004-09-29 21:29:14 +0000363extern BlockDriver bdrv_cloop;
bellard585d0ed2004-12-12 11:24:44 +0000364extern BlockDriver bdrv_dmg;
bellardea2384d2004-08-01 21:59:26 +0000365
366void bdrv_init(void);
367BlockDriver *bdrv_find_format(const char *format_name);
368int bdrv_create(BlockDriver *drv,
369 const char *filename, int64_t size_in_sectors,
370 const char *backing_file, int flags);
bellardc4b1fcc2004-03-14 21:44:30 +0000371BlockDriverState *bdrv_new(const char *device_name);
372void bdrv_delete(BlockDriverState *bs);
373int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
bellardea2384d2004-08-01 21:59:26 +0000374int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
375 BlockDriver *drv);
bellardfc01f7e2003-06-30 10:03:06 +0000376void bdrv_close(BlockDriverState *bs);
377int bdrv_read(BlockDriverState *bs, int64_t sector_num,
378 uint8_t *buf, int nb_sectors);
379int bdrv_write(BlockDriverState *bs, int64_t sector_num,
380 const uint8_t *buf, int nb_sectors);
381void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
bellard33e39632003-07-06 17:15:21 +0000382int bdrv_commit(BlockDriverState *bs);
bellard77fef8c2004-02-16 22:05:46 +0000383void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
bellardfc01f7e2003-06-30 10:03:06 +0000384
bellardc4b1fcc2004-03-14 21:44:30 +0000385#define BDRV_TYPE_HD 0
386#define BDRV_TYPE_CDROM 1
387#define BDRV_TYPE_FLOPPY 2
bellard46d47672004-11-16 01:45:27 +0000388#define BIOS_ATA_TRANSLATION_AUTO 0
389#define BIOS_ATA_TRANSLATION_NONE 1
390#define BIOS_ATA_TRANSLATION_LBA 2
bellardc4b1fcc2004-03-14 21:44:30 +0000391
392void bdrv_set_geometry_hint(BlockDriverState *bs,
393 int cyls, int heads, int secs);
394void bdrv_set_type_hint(BlockDriverState *bs, int type);
bellard46d47672004-11-16 01:45:27 +0000395void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
bellardc4b1fcc2004-03-14 21:44:30 +0000396void bdrv_get_geometry_hint(BlockDriverState *bs,
397 int *pcyls, int *pheads, int *psecs);
398int bdrv_get_type_hint(BlockDriverState *bs);
bellard46d47672004-11-16 01:45:27 +0000399int bdrv_get_translation_hint(BlockDriverState *bs);
bellardc4b1fcc2004-03-14 21:44:30 +0000400int bdrv_is_removable(BlockDriverState *bs);
401int bdrv_is_read_only(BlockDriverState *bs);
402int bdrv_is_inserted(BlockDriverState *bs);
403int bdrv_is_locked(BlockDriverState *bs);
404void bdrv_set_locked(BlockDriverState *bs, int locked);
405void bdrv_set_change_cb(BlockDriverState *bs,
406 void (*change_cb)(void *opaque), void *opaque);
bellardea2384d2004-08-01 21:59:26 +0000407void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
bellardc4b1fcc2004-03-14 21:44:30 +0000408void bdrv_info(void);
409BlockDriverState *bdrv_find(const char *name);
bellard82c643f2004-07-14 17:28:13 +0000410void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
bellardea2384d2004-08-01 21:59:26 +0000411int bdrv_is_encrypted(BlockDriverState *bs);
412int bdrv_set_key(BlockDriverState *bs, const char *key);
413void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
414 void *opaque);
415const char *bdrv_get_device_name(BlockDriverState *bs);
bellardc4b1fcc2004-03-14 21:44:30 +0000416
bellardea2384d2004-08-01 21:59:26 +0000417int qcow_get_cluster_size(BlockDriverState *bs);
418int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
419 const uint8_t *buf);
420
421#ifndef QEMU_TOOL
bellard26aa7d72004-04-28 22:26:05 +0000422/* ISA bus */
423
424extern target_phys_addr_t isa_mem_base;
425
426typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
427typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
428
429int register_ioport_read(int start, int length, int size,
430 IOPortReadFunc *func, void *opaque);
431int register_ioport_write(int start, int length, int size,
432 IOPortWriteFunc *func, void *opaque);
bellard69b91032004-05-18 23:05:28 +0000433void isa_unassign_ioport(int start, int length);
434
435/* PCI bus */
436
437extern int pci_enabled;
438
439extern target_phys_addr_t pci_mem_base;
440
bellard46e50e92004-06-21 19:43:00 +0000441typedef struct PCIBus PCIBus;
bellard69b91032004-05-18 23:05:28 +0000442typedef struct PCIDevice PCIDevice;
443
444typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
445 uint32_t address, uint32_t data, int len);
446typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
447 uint32_t address, int len);
448typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
449 uint32_t addr, uint32_t size, int type);
450
451#define PCI_ADDRESS_SPACE_MEM 0x00
452#define PCI_ADDRESS_SPACE_IO 0x01
453#define PCI_ADDRESS_SPACE_MEM_PREFETCH 0x08
454
455typedef struct PCIIORegion {
bellard5768f5a2004-05-20 12:47:45 +0000456 uint32_t addr; /* current PCI mapping address. -1 means not mapped */
bellard69b91032004-05-18 23:05:28 +0000457 uint32_t size;
458 uint8_t type;
459 PCIMapIORegionFunc *map_func;
460} PCIIORegion;
461
bellard8a8696a2004-06-03 14:06:32 +0000462#define PCI_ROM_SLOT 6
463#define PCI_NUM_REGIONS 7
bellard69b91032004-05-18 23:05:28 +0000464struct PCIDevice {
465 /* PCI config space */
466 uint8_t config[256];
467
468 /* the following fields are read only */
bellard46e50e92004-06-21 19:43:00 +0000469 PCIBus *bus;
bellard69b91032004-05-18 23:05:28 +0000470 int devfn;
471 char name[64];
bellard8a8696a2004-06-03 14:06:32 +0000472 PCIIORegion io_regions[PCI_NUM_REGIONS];
bellard69b91032004-05-18 23:05:28 +0000473
474 /* do not access the following fields */
475 PCIConfigReadFunc *config_read;
476 PCIConfigWriteFunc *config_write;
bellard5768f5a2004-05-20 12:47:45 +0000477 int irq_index;
bellard69b91032004-05-18 23:05:28 +0000478};
479
bellard46e50e92004-06-21 19:43:00 +0000480PCIDevice *pci_register_device(PCIBus *bus, const char *name,
481 int instance_size, int devfn,
bellard69b91032004-05-18 23:05:28 +0000482 PCIConfigReadFunc *config_read,
483 PCIConfigWriteFunc *config_write);
484
485void pci_register_io_region(PCIDevice *pci_dev, int region_num,
486 uint32_t size, int type,
487 PCIMapIORegionFunc *map_func);
488
bellard5768f5a2004-05-20 12:47:45 +0000489void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
490
491uint32_t pci_default_read_config(PCIDevice *d,
492 uint32_t address, int len);
493void pci_default_write_config(PCIDevice *d,
494 uint32_t address, uint32_t val, int len);
bellard30ca2aa2004-10-03 13:56:00 +0000495void generic_pci_save(QEMUFile* f, void *opaque);
496int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
bellard5768f5a2004-05-20 12:47:45 +0000497
bellard9995c512004-05-23 19:09:22 +0000498extern struct PIIX3State *piix3_state;
499
bellard46e50e92004-06-21 19:43:00 +0000500PCIBus *i440fx_init(void);
501void piix3_init(PCIBus *bus);
bellard69b91032004-05-18 23:05:28 +0000502void pci_bios_init(void);
bellard5768f5a2004-05-20 12:47:45 +0000503void pci_info(void);
bellard26aa7d72004-04-28 22:26:05 +0000504
bellard77d4bc32004-05-26 22:13:53 +0000505/* temporary: will be moved in platform specific file */
bellard46e50e92004-06-21 19:43:00 +0000506PCIBus *pci_prep_init(void);
507struct openpic_t;
508void pci_pmac_set_openpic(PCIBus *bus, struct openpic_t *openpic);
509PCIBus *pci_pmac_init(void);
bellard77d4bc32004-05-26 22:13:53 +0000510
bellard28b9b5a2004-06-21 16:46:35 +0000511/* openpic.c */
512typedef struct openpic_t openpic_t;
513void openpic_set_irq (openpic_t *opp, int n_IRQ, int level);
bellarde2733d22004-06-21 22:46:10 +0000514openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus);
bellard28b9b5a2004-06-21 16:46:35 +0000515
bellard313aa562003-08-10 21:52:11 +0000516/* vga.c */
517
bellard4fa0f5d2004-02-06 19:47:52 +0000518#define VGA_RAM_SIZE (4096 * 1024)
bellard313aa562003-08-10 21:52:11 +0000519
bellard82c643f2004-07-14 17:28:13 +0000520struct DisplayState {
bellard313aa562003-08-10 21:52:11 +0000521 uint8_t *data;
522 int linesize;
523 int depth;
bellard82c643f2004-07-14 17:28:13 +0000524 int width;
525 int height;
bellard313aa562003-08-10 21:52:11 +0000526 void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
527 void (*dpy_resize)(struct DisplayState *s, int w, int h);
528 void (*dpy_refresh)(struct DisplayState *s);
bellard82c643f2004-07-14 17:28:13 +0000529};
bellard313aa562003-08-10 21:52:11 +0000530
531static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
532{
533 s->dpy_update(s, x, y, w, h);
534}
535
536static inline void dpy_resize(DisplayState *s, int w, int h)
537{
538 s->dpy_resize(s, w, h);
539}
540
bellard46e50e92004-06-21 19:43:00 +0000541int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
542 unsigned long vga_ram_offset, int vga_ram_size);
bellard313aa562003-08-10 21:52:11 +0000543void vga_update_display(void);
bellardee38b4c2004-06-08 00:56:42 +0000544void vga_invalidate_display(void);
bellard59a983b2004-03-17 23:17:16 +0000545void vga_screen_dump(const char *filename);
bellard313aa562003-08-10 21:52:11 +0000546
bellardd6bfa222004-06-05 10:32:30 +0000547/* cirrus_vga.c */
bellard46e50e92004-06-21 19:43:00 +0000548void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
bellardd6bfa222004-06-05 10:32:30 +0000549 unsigned long vga_ram_offset, int vga_ram_size);
bellardd6bfa222004-06-05 10:32:30 +0000550void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
551 unsigned long vga_ram_offset, int vga_ram_size);
552
bellard313aa562003-08-10 21:52:11 +0000553/* sdl.c */
bellardd63d3072004-10-03 13:29:03 +0000554void sdl_display_init(DisplayState *ds, int full_screen);
bellard313aa562003-08-10 21:52:11 +0000555
bellard5391d802003-11-11 13:48:59 +0000556/* ide.c */
557#define MAX_DISKS 4
558
559extern BlockDriverState *bs_table[MAX_DISKS];
560
bellard69b91032004-05-18 23:05:28 +0000561void isa_ide_init(int iobase, int iobase2, int irq,
562 BlockDriverState *hd0, BlockDriverState *hd1);
bellard46e50e92004-06-21 19:43:00 +0000563void pci_ide_init(PCIBus *bus, BlockDriverState **hd_table);
564void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table);
bellard28b9b5a2004-06-21 16:46:35 +0000565int pmac_ide_init (BlockDriverState **hd_table,
566 openpic_t *openpic, int irq);
bellard5391d802003-11-11 13:48:59 +0000567
bellardfb065182004-11-09 23:09:44 +0000568/* sb16.c */
569void SB16_init (void);
570
571/* adlib.c */
572void Adlib_init (void);
573
574/* gus.c */
575void GUS_init (void);
bellard27503322003-11-13 01:46:15 +0000576
577/* dma.c */
bellard85571bc2004-11-07 18:04:02 +0000578typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
bellard27503322003-11-13 01:46:15 +0000579int DMA_get_channel_mode (int nchan);
bellard85571bc2004-11-07 18:04:02 +0000580int DMA_read_memory (int nchan, void *buf, int pos, int size);
581int DMA_write_memory (int nchan, void *buf, int pos, int size);
bellard27503322003-11-13 01:46:15 +0000582void DMA_hold_DREQ (int nchan);
583void DMA_release_DREQ (int nchan);
bellard16f62432004-02-25 23:25:55 +0000584void DMA_schedule(int nchan);
bellard27503322003-11-13 01:46:15 +0000585void DMA_run (void);
bellard28b9b5a2004-06-21 16:46:35 +0000586void DMA_init (int high_page_enable);
bellard27503322003-11-13 01:46:15 +0000587void DMA_register_channel (int nchan,
bellard85571bc2004-11-07 18:04:02 +0000588 DMA_transfer_handler transfer_handler,
589 void *opaque);
bellard7138fcf2004-01-05 00:02:28 +0000590/* fdc.c */
591#define MAX_FD 2
592extern BlockDriverState *fd_table[MAX_FD];
593
bellardbaca51f2004-03-19 23:05:34 +0000594typedef struct fdctrl_t fdctrl_t;
595
596fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
597 uint32_t io_base,
598 BlockDriverState **fds);
599int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
bellard7138fcf2004-01-05 00:02:28 +0000600
bellard80cabfa2004-03-14 12:20:30 +0000601/* ne2000.c */
602
bellard69b91032004-05-18 23:05:28 +0000603void isa_ne2000_init(int base, int irq, NetDriverState *nd);
bellard46e50e92004-06-21 19:43:00 +0000604void pci_ne2000_init(PCIBus *bus, NetDriverState *nd);
bellard80cabfa2004-03-14 12:20:30 +0000605
606/* pckbd.c */
607
bellard80cabfa2004-03-14 12:20:30 +0000608void kbd_init(void);
609
610/* mc146818rtc.c */
611
bellard8a7ddc32004-03-31 19:00:16 +0000612typedef struct RTCState RTCState;
bellard80cabfa2004-03-14 12:20:30 +0000613
bellard8a7ddc32004-03-31 19:00:16 +0000614RTCState *rtc_init(int base, int irq);
615void rtc_set_memory(RTCState *s, int addr, int val);
616void rtc_set_date(RTCState *s, const struct tm *tm);
bellard80cabfa2004-03-14 12:20:30 +0000617
618/* serial.c */
619
bellardc4b1fcc2004-03-14 21:44:30 +0000620typedef struct SerialState SerialState;
bellard82c643f2004-07-14 17:28:13 +0000621SerialState *serial_init(int base, int irq, CharDriverState *chr);
bellard80cabfa2004-03-14 12:20:30 +0000622
623/* i8259.c */
624
625void pic_set_irq(int irq, int level);
626void pic_init(void);
bellardc5df0182004-04-12 20:54:52 +0000627uint32_t pic_intack_read(CPUState *env);
bellardc20709a2004-04-21 23:27:19 +0000628void pic_info(void);
bellard4a0fb71e2004-05-21 11:39:07 +0000629void irq_info(void);
bellard80cabfa2004-03-14 12:20:30 +0000630
631/* i8254.c */
632
633#define PIT_FREQ 1193182
634
bellardec844b92004-05-03 23:18:25 +0000635typedef struct PITState PITState;
bellard80cabfa2004-03-14 12:20:30 +0000636
bellardec844b92004-05-03 23:18:25 +0000637PITState *pit_init(int base, int irq);
638void pit_set_gate(PITState *pit, int channel, int val);
639int pit_get_gate(PITState *pit, int channel);
640int pit_get_out(PITState *pit, int channel, int64_t current_time);
bellard80cabfa2004-03-14 12:20:30 +0000641
642/* pc.c */
643void pc_init(int ram_size, int vga_ram_size, int boot_device,
644 DisplayState *ds, const char **fd_filename, int snapshot,
645 const char *kernel_filename, const char *kernel_cmdline,
646 const char *initrd_filename);
647
bellard26aa7d72004-04-28 22:26:05 +0000648/* ppc.c */
649void ppc_init (int ram_size, int vga_ram_size, int boot_device,
650 DisplayState *ds, const char **fd_filename, int snapshot,
651 const char *kernel_filename, const char *kernel_cmdline,
652 const char *initrd_filename);
bellard77d4bc32004-05-26 22:13:53 +0000653void ppc_prep_init (int ram_size, int vga_ram_size, int boot_device,
654 DisplayState *ds, const char **fd_filename, int snapshot,
655 const char *kernel_filename, const char *kernel_cmdline,
656 const char *initrd_filename);
657void ppc_chrp_init(int ram_size, int vga_ram_size, int boot_device,
658 DisplayState *ds, const char **fd_filename, int snapshot,
659 const char *kernel_filename, const char *kernel_cmdline,
660 const char *initrd_filename);
bellard8cc43fe2004-05-26 23:29:15 +0000661#ifdef TARGET_PPC
662ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
663#endif
bellard64201202004-05-26 22:55:16 +0000664void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
bellard77d4bc32004-05-26 22:13:53 +0000665
666extern CPUWriteMemoryFunc *PPC_io_write[];
667extern CPUReadMemoryFunc *PPC_io_read[];
668extern int prep_enabled;
bellard26aa7d72004-04-28 22:26:05 +0000669
bellarde95c8d52004-09-30 22:22:08 +0000670/* sun4m.c */
671void sun4m_init(int ram_size, int vga_ram_size, int boot_device,
672 DisplayState *ds, const char **fd_filename, int snapshot,
673 const char *kernel_filename, const char *kernel_cmdline,
674 const char *initrd_filename);
bellarde80cfcf2004-12-19 23:18:01 +0000675uint32_t iommu_translate(uint32_t addr);
bellarde95c8d52004-09-30 22:22:08 +0000676
677/* iommu.c */
bellarde80cfcf2004-12-19 23:18:01 +0000678void *iommu_init(uint32_t addr);
679uint32_t iommu_translate_local(void *opaque, uint32_t addr);
bellarde95c8d52004-09-30 22:22:08 +0000680
681/* lance.c */
bellard8d5f07f2004-10-04 21:23:09 +0000682void lance_init(NetDriverState *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
bellarde95c8d52004-09-30 22:22:08 +0000683
684/* tcx.c */
bellarde80cfcf2004-12-19 23:18:01 +0000685void *tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
686 unsigned long vram_offset, int vram_size);
687void tcx_update_display(void *opaque);
688void tcx_invalidate_display(void *opaque);
689void tcx_screen_dump(void *opaque, const char *filename);
bellarde95c8d52004-09-30 22:22:08 +0000690
bellarde80cfcf2004-12-19 23:18:01 +0000691/* slavio_intctl.c */
692void *slavio_intctl_init();
693void slavio_pic_info(void *opaque);
694void slavio_irq_info(void *opaque);
695void slavio_pic_set_irq(void *opaque, int irq, int level);
bellarde95c8d52004-09-30 22:22:08 +0000696
697/* magic-load.c */
bellarde80cfcf2004-12-19 23:18:01 +0000698int load_elf(const char *filename, uint8_t *addr);
699int load_aout(const char *filename, uint8_t *addr);
bellard8d5f07f2004-10-04 21:23:09 +0000700
bellarde80cfcf2004-12-19 23:18:01 +0000701/* slavio_timer.c */
702void slavio_timer_init(uint32_t addr1, int irq1, uint32_t addr2, int irq2);
703
704/* slavio_serial.c */
705SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
706void slavio_serial_ms_kbd_init(int base, int irq);
bellarde95c8d52004-09-30 22:22:08 +0000707
bellard64201202004-05-26 22:55:16 +0000708/* NVRAM helpers */
709#include "hw/m48t59.h"
710
711void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
712uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
713void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
714uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
715void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
716uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
717void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
718 const unsigned char *str, uint32_t max);
719int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
720void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
721 uint32_t start, uint32_t count);
722int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
723 const unsigned char *arch,
724 uint32_t RAM_size, int boot_device,
725 uint32_t kernel_image, uint32_t kernel_size,
bellard28b9b5a2004-06-21 16:46:35 +0000726 const char *cmdline,
bellard64201202004-05-26 22:55:16 +0000727 uint32_t initrd_image, uint32_t initrd_size,
bellard28b9b5a2004-06-21 16:46:35 +0000728 uint32_t NVRAM_image,
729 int width, int height, int depth);
bellard64201202004-05-26 22:55:16 +0000730
bellard63066f42004-06-03 18:45:02 +0000731/* adb.c */
732
733#define MAX_ADB_DEVICES 16
734
bellarde2733d22004-06-21 22:46:10 +0000735#define ADB_MAX_OUT_LEN 16
736
bellard63066f42004-06-03 18:45:02 +0000737typedef struct ADBDevice ADBDevice;
738
bellarde2733d22004-06-21 22:46:10 +0000739/* buf = NULL means polling */
740typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
741 const uint8_t *buf, int len);
bellard12c28fed2004-07-12 20:26:20 +0000742typedef int ADBDeviceReset(ADBDevice *d);
743
bellard63066f42004-06-03 18:45:02 +0000744struct ADBDevice {
745 struct ADBBusState *bus;
746 int devaddr;
747 int handler;
bellarde2733d22004-06-21 22:46:10 +0000748 ADBDeviceRequest *devreq;
bellard12c28fed2004-07-12 20:26:20 +0000749 ADBDeviceReset *devreset;
bellard63066f42004-06-03 18:45:02 +0000750 void *opaque;
751};
752
753typedef struct ADBBusState {
754 ADBDevice devices[MAX_ADB_DEVICES];
755 int nb_devices;
bellarde2733d22004-06-21 22:46:10 +0000756 int poll_index;
bellard63066f42004-06-03 18:45:02 +0000757} ADBBusState;
758
bellarde2733d22004-06-21 22:46:10 +0000759int adb_request(ADBBusState *s, uint8_t *buf_out,
760 const uint8_t *buf, int len);
761int adb_poll(ADBBusState *s, uint8_t *buf_out);
bellard63066f42004-06-03 18:45:02 +0000762
763ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
bellarde2733d22004-06-21 22:46:10 +0000764 ADBDeviceRequest *devreq,
bellard12c28fed2004-07-12 20:26:20 +0000765 ADBDeviceReset *devreset,
bellard63066f42004-06-03 18:45:02 +0000766 void *opaque);
767void adb_kbd_init(ADBBusState *bus);
768void adb_mouse_init(ADBBusState *bus);
769
770/* cuda.c */
771
772extern ADBBusState adb_bus;
bellard28b9b5a2004-06-21 16:46:35 +0000773int cuda_init(openpic_t *openpic, int irq);
bellard63066f42004-06-03 18:45:02 +0000774
bellardea2384d2004-08-01 21:59:26 +0000775#endif /* defined(QEMU_TOOL) */
776
bellardc4b1fcc2004-03-14 21:44:30 +0000777/* monitor.c */
bellard82c643f2004-07-14 17:28:13 +0000778void monitor_init(CharDriverState *hd, int show_banner);
bellardea2384d2004-08-01 21:59:26 +0000779void term_puts(const char *str);
780void term_vprintf(const char *fmt, va_list ap);
bellard40c3bac2004-04-04 12:56:28 +0000781void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
bellardc4b1fcc2004-03-14 21:44:30 +0000782void term_flush(void);
783void term_print_help(void);
bellardea2384d2004-08-01 21:59:26 +0000784void monitor_readline(const char *prompt, int is_password,
785 char *buf, int buf_size);
786
787/* readline.c */
788typedef void ReadLineFunc(void *opaque, const char *str);
789
790extern int completion_index;
791void add_completion(const char *str);
792void readline_handle_byte(int ch);
793void readline_find_completion(const char *cmdline);
794const char *readline_get_history(unsigned int index);
795void readline_start(const char *prompt, int is_password,
796 ReadLineFunc *readline_func, void *opaque);
bellardc4b1fcc2004-03-14 21:44:30 +0000797
bellard8a7ddc32004-03-31 19:00:16 +0000798/* gdbstub.c */
799
800#define DEFAULT_GDBSTUB_PORT 1234
801
802int gdbserver_start(int port);
803
bellardfc01f7e2003-06-30 10:03:06 +0000804#endif /* VL_H */