Statistics
| Branch: | Revision:

root / vl.h @ 83f64091

History | View | Annotate | Download (38.4 kB)

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
49
#include <windows.h>
50
#define fsync _commit
51
#define lseek _lseeki64
52
#define ENOTSUP 4096
53
extern int qemu_ftruncate64(int, int64_t);
54
#define ftruncate qemu_ftruncate64
55

    
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
}
62

    
63
#define PRId64 "I64d"
64
#define PRIx64 "I64x"
65
#define PRIu64 "I64u"
66
#define PRIo64 "I64o"
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

    
80
#include "audio/audio.h"
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

    
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

    
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

    
113
typedef struct vm_change_state_entry VMChangeStateEntry;
114
typedef void VMChangeStateHandler(void *opaque, int running);
115
typedef void VMStopHandler(void *opaque, int reason);
116

    
117
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
118
                                                     void *opaque);
119
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
120

    
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;
152
extern int usb_enabled;
153
extern int smp_cpus;
154

    
155
/* XXX: make it dynamic */
156
#if defined (TARGET_PPC) || defined (TARGET_SPARC64)
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);
174
void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque, int absolute);
175

    
176
void kbd_put_keycode(int keycode);
177
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
178
int kbd_mouse_is_absolute(void);
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);
209
typedef void IOHandler(void *opaque);
210

    
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);
220

    
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

    
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

    
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

    
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

    
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);
267
    int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
268
    IOEventHandler *chr_event;
269
    void (*chr_send_event)(struct CharDriverState *chr, int event);
270
    void (*chr_close)(struct CharDriverState *chr);
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);
281
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
282

    
283
/* consoles */
284

    
285
typedef struct DisplayState DisplayState;
286
typedef struct TextConsole TextConsole;
287

    
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);
299

    
300
int is_graphic_console(void);
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

    
316
/* VLANs support */
317

    
318
typedef struct VLANClientState VLANClientState;
319

    
320
struct VLANClientState {
321
    IOReadHandler *fd_read;
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;
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,
339
                                      IOReadHandler *fd_read,
340
                                      IOCanRWHandler *fd_can_read,
341
                                      void *opaque);
342
int qemu_can_send_packet(VLANClientState *vc);
343
void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size);
344
void qemu_handler_true(void *opaque);
345

    
346
void do_info_network(void);
347

    
348
/* TAP win32 */
349
int tap_win32_init(VLANState *vlan, const char *ifname);
350
void tap_win32_poll(void);
351

    
352
/* NIC info */
353

    
354
#define MAX_NICS 8
355

    
356
typedef struct NICInfo {
357
    uint8_t macaddr[6];
358
    const char *model;
359
    VLANState *vlan;
360
} NICInfo;
361

    
362
extern int nb_nics;
363
extern NICInfo nd_table[MAX_NICS];
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

    
393
int64_t cpu_get_ticks(void);
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

    
481
void cpu_save(QEMUFile *f, void *opaque);
482
int cpu_load(QEMUFile *f, void *opaque, int version_id);
483

    
484
/* bottom halves */
485
typedef struct QEMUBH QEMUBH;
486
typedef void QEMUBHFunc(void *opaque);
487

    
488
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
489
void qemu_bh_schedule(QEMUBH *bh);
490
void qemu_bh_cancel(QEMUBH *bh);
491
void qemu_bh_delete(QEMUBH *bh);
492
void qemu_bh_poll(void);
493

    
494
/* block.c */
495
typedef struct BlockDriverState BlockDriverState;
496
typedef struct BlockDriver BlockDriver;
497

    
498
extern BlockDriver bdrv_raw;
499
extern BlockDriver bdrv_cow;
500
extern BlockDriver bdrv_qcow;
501
extern BlockDriver bdrv_vmdk;
502
extern BlockDriver bdrv_cloop;
503
extern BlockDriver bdrv_dmg;
504
extern BlockDriver bdrv_bochs;
505
extern BlockDriver bdrv_vpc;
506
extern BlockDriver bdrv_vvfat;
507

    
508
#define BDRV_O_RDONLY      0x0000
509
#define BDRV_O_RDWR        0x0002
510
#define BDRV_O_ACCESS      0x0003
511
#define BDRV_O_CREAT       0x0004 /* create an empty file */
512
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
513
#define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
514
                                     use a disk image format on top of
515
                                     it (default for
516
                                     bdrv_file_open()) */
517

    
518
void bdrv_init(void);
519
BlockDriver *bdrv_find_format(const char *format_name);
520
int bdrv_create(BlockDriver *drv, 
521
                const char *filename, int64_t size_in_sectors,
522
                const char *backing_file, int flags);
523
BlockDriverState *bdrv_new(const char *device_name);
524
void bdrv_delete(BlockDriverState *bs);
525
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
526
int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
527
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
528
               BlockDriver *drv);
529
void bdrv_close(BlockDriverState *bs);
530
int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
531
              uint8_t *buf, int nb_sectors);
532
int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
533
               const uint8_t *buf, int nb_sectors);
534
int bdrv_pread(BlockDriverState *bs, int64_t offset, 
535
               void *buf, int count);
536
int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 
537
                const void *buf, int count);
538
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
539
int64_t bdrv_getlength(BlockDriverState *bs);
540
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
541
int bdrv_commit(BlockDriverState *bs);
542
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
543
/* async block I/O */
544
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
545
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
546

    
547
BlockDriverAIOCB *bdrv_aio_new(BlockDriverState *bs);
548
int bdrv_aio_read(BlockDriverAIOCB *acb, int64_t sector_num,
549
                  uint8_t *buf, int nb_sectors,
550
                  BlockDriverCompletionFunc *cb, void *opaque);
551
int bdrv_aio_write(BlockDriverAIOCB *acb, int64_t sector_num,
552
                   const uint8_t *buf, int nb_sectors,
553
                   BlockDriverCompletionFunc *cb, void *opaque);
554
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
555
void bdrv_aio_delete(BlockDriverAIOCB *acb);
556

    
557
void qemu_aio_init(void);
558
void qemu_aio_poll(void);
559
void qemu_aio_wait_start(void);
560
void qemu_aio_wait(void);
561
void qemu_aio_wait_end(void);
562

    
563
/* Ensure contents are flushed to disk.  */
564
void bdrv_flush(BlockDriverState *bs);
565

    
566
#define BDRV_TYPE_HD     0
567
#define BDRV_TYPE_CDROM  1
568
#define BDRV_TYPE_FLOPPY 2
569
#define BIOS_ATA_TRANSLATION_AUTO 0
570
#define BIOS_ATA_TRANSLATION_NONE 1
571
#define BIOS_ATA_TRANSLATION_LBA  2
572

    
573
void bdrv_set_geometry_hint(BlockDriverState *bs, 
574
                            int cyls, int heads, int secs);
575
void bdrv_set_type_hint(BlockDriverState *bs, int type);
576
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
577
void bdrv_get_geometry_hint(BlockDriverState *bs, 
578
                            int *pcyls, int *pheads, int *psecs);
579
int bdrv_get_type_hint(BlockDriverState *bs);
580
int bdrv_get_translation_hint(BlockDriverState *bs);
581
int bdrv_is_removable(BlockDriverState *bs);
582
int bdrv_is_read_only(BlockDriverState *bs);
583
int bdrv_is_inserted(BlockDriverState *bs);
584
int bdrv_is_locked(BlockDriverState *bs);
585
void bdrv_set_locked(BlockDriverState *bs, int locked);
586
void bdrv_set_change_cb(BlockDriverState *bs, 
587
                        void (*change_cb)(void *opaque), void *opaque);
588
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
589
void bdrv_info(void);
590
BlockDriverState *bdrv_find(const char *name);
591
void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
592
int bdrv_is_encrypted(BlockDriverState *bs);
593
int bdrv_set_key(BlockDriverState *bs, const char *key);
594
void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
595
                         void *opaque);
596
const char *bdrv_get_device_name(BlockDriverState *bs);
597

    
598
int qcow_get_cluster_size(BlockDriverState *bs);
599
int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
600
                          const uint8_t *buf);
601
void bdrv_get_backing_filename(BlockDriverState *bs, 
602
                               char *filename, int filename_size);
603

    
604
int path_is_absolute(const char *path);
605
void path_combine(char *dest, int dest_size,
606
                  const char *base_path,
607
                  const char *filename);
608

    
609
#ifndef QEMU_TOOL
610

    
611
typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size, 
612
                                 int boot_device,
613
             DisplayState *ds, const char **fd_filename, int snapshot,
614
             const char *kernel_filename, const char *kernel_cmdline,
615
             const char *initrd_filename);
616

    
617
typedef struct QEMUMachine {
618
    const char *name;
619
    const char *desc;
620
    QEMUMachineInitFunc *init;
621
    struct QEMUMachine *next;
622
} QEMUMachine;
623

    
624
int qemu_register_machine(QEMUMachine *m);
625

    
626
typedef void SetIRQFunc(void *opaque, int irq_num, int level);
627
typedef void IRQRequestFunc(void *opaque, int level);
628

    
629
/* ISA bus */
630

    
631
extern target_phys_addr_t isa_mem_base;
632

    
633
typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
634
typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
635

    
636
int register_ioport_read(int start, int length, int size, 
637
                         IOPortReadFunc *func, void *opaque);
638
int register_ioport_write(int start, int length, int size, 
639
                          IOPortWriteFunc *func, void *opaque);
640
void isa_unassign_ioport(int start, int length);
641

    
642
/* PCI bus */
643

    
644
extern target_phys_addr_t pci_mem_base;
645

    
646
typedef struct PCIBus PCIBus;
647
typedef struct PCIDevice PCIDevice;
648

    
649
typedef void PCIConfigWriteFunc(PCIDevice *pci_dev, 
650
                                uint32_t address, uint32_t data, int len);
651
typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev, 
652
                                   uint32_t address, int len);
653
typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num, 
654
                                uint32_t addr, uint32_t size, int type);
655

    
656
#define PCI_ADDRESS_SPACE_MEM                0x00
657
#define PCI_ADDRESS_SPACE_IO                0x01
658
#define PCI_ADDRESS_SPACE_MEM_PREFETCH        0x08
659

    
660
typedef struct PCIIORegion {
661
    uint32_t addr; /* current PCI mapping address. -1 means not mapped */
662
    uint32_t size;
663
    uint8_t type;
664
    PCIMapIORegionFunc *map_func;
665
} PCIIORegion;
666

    
667
#define PCI_ROM_SLOT 6
668
#define PCI_NUM_REGIONS 7
669

    
670
#define PCI_DEVICES_MAX 64
671

    
672
#define PCI_VENDOR_ID                0x00        /* 16 bits */
673
#define PCI_DEVICE_ID                0x02        /* 16 bits */
674
#define PCI_COMMAND                0x04        /* 16 bits */
675
#define  PCI_COMMAND_IO                0x1        /* Enable response in I/O space */
676
#define  PCI_COMMAND_MEMORY        0x2        /* Enable response in Memory space */
677
#define PCI_CLASS_DEVICE        0x0a    /* Device class */
678
#define PCI_INTERRUPT_LINE        0x3c        /* 8 bits */
679
#define PCI_INTERRUPT_PIN        0x3d        /* 8 bits */
680
#define PCI_MIN_GNT                0x3e        /* 8 bits */
681
#define PCI_MAX_LAT                0x3f        /* 8 bits */
682

    
683
struct PCIDevice {
684
    /* PCI config space */
685
    uint8_t config[256];
686

    
687
    /* the following fields are read only */
688
    PCIBus *bus;
689
    int devfn;
690
    char name[64];
691
    PCIIORegion io_regions[PCI_NUM_REGIONS];
692
    
693
    /* do not access the following fields */
694
    PCIConfigReadFunc *config_read;
695
    PCIConfigWriteFunc *config_write;
696
    /* ??? This is a PC-specific hack, and should be removed.  */
697
    int irq_index;
698
};
699

    
700
PCIDevice *pci_register_device(PCIBus *bus, const char *name,
701
                               int instance_size, int devfn,
702
                               PCIConfigReadFunc *config_read, 
703
                               PCIConfigWriteFunc *config_write);
704

    
705
void pci_register_io_region(PCIDevice *pci_dev, int region_num, 
706
                            uint32_t size, int type, 
707
                            PCIMapIORegionFunc *map_func);
708

    
709
void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
710

    
711
uint32_t pci_default_read_config(PCIDevice *d, 
712
                                 uint32_t address, int len);
713
void pci_default_write_config(PCIDevice *d, 
714
                              uint32_t address, uint32_t val, int len);
715
void generic_pci_save(QEMUFile* f, void *opaque);
716
int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
717

    
718
typedef void (*pci_set_irq_fn)(PCIDevice *pci_dev, void *pic,
719
                               int irq_num, int level);
720
PCIBus *pci_register_bus(pci_set_irq_fn set_irq, void *pic, int devfn_min);
721

    
722
void pci_nic_init(PCIBus *bus, NICInfo *nd);
723
void pci_data_write(void *opaque, uint32_t addr, uint32_t val, int len);
724
uint32_t pci_data_read(void *opaque, uint32_t addr, int len);
725
int pci_bus_num(PCIBus *s);
726
void pci_for_each_device(void (*fn)(PCIDevice *d));
727

    
728
void pci_info(void);
729

    
730
/* prep_pci.c */
731
PCIBus *pci_prep_init(void);
732

    
733
/* grackle_pci.c */
734
PCIBus *pci_grackle_init(uint32_t base, void *pic);
735

    
736
/* unin_pci.c */
737
PCIBus *pci_pmac_init(void *pic);
738

    
739
/* apb_pci.c */
740
PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base,
741
                     void *pic);
742

    
743
PCIBus *pci_vpb_init(void *pic);
744

    
745
/* piix_pci.c */
746
PCIBus *i440fx_init(void);
747
int piix3_init(PCIBus *bus);
748
void pci_bios_init(void);
749

    
750
/* openpic.c */
751
typedef struct openpic_t openpic_t;
752
void openpic_set_irq(void *opaque, int n_IRQ, int level);
753
openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus,
754
                         CPUState **envp);
755

    
756
/* heathrow_pic.c */
757
typedef struct HeathrowPICS HeathrowPICS;
758
void heathrow_pic_set_irq(void *opaque, int num, int level);
759
HeathrowPICS *heathrow_pic_init(int *pmem_index);
760

    
761
#ifdef HAS_AUDIO
762
struct soundhw {
763
    const char *name;
764
    const char *descr;
765
    int enabled;
766
    int isa;
767
    union {
768
        int (*init_isa) (AudioState *s);
769
        int (*init_pci) (PCIBus *bus, AudioState *s);
770
    } init;
771
};
772

    
773
extern struct soundhw soundhw[];
774
#endif
775

    
776
/* vga.c */
777

    
778
#define VGA_RAM_SIZE (8192 * 1024)
779

    
780
struct DisplayState {
781
    uint8_t *data;
782
    int linesize;
783
    int depth;
784
    int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
785
    int width;
786
    int height;
787
    void *opaque;
788

    
789
    void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
790
    void (*dpy_resize)(struct DisplayState *s, int w, int h);
791
    void (*dpy_refresh)(struct DisplayState *s);
792
    void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y, int dst_x, int dst_y, int w, int h);
793
};
794

    
795
static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
796
{
797
    s->dpy_update(s, x, y, w, h);
798
}
799

    
800
static inline void dpy_resize(DisplayState *s, int w, int h)
801
{
802
    s->dpy_resize(s, w, h);
803
}
804

    
805
int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 
806
                   unsigned long vga_ram_offset, int vga_ram_size,
807
                   unsigned long vga_bios_offset, int vga_bios_size);
808

    
809
/* cirrus_vga.c */
810
void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 
811
                         unsigned long vga_ram_offset, int vga_ram_size);
812
void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base, 
813
                         unsigned long vga_ram_offset, int vga_ram_size);
814

    
815
/* sdl.c */
816
void sdl_display_init(DisplayState *ds, int full_screen);
817

    
818
/* cocoa.m */
819
void cocoa_display_init(DisplayState *ds, int full_screen);
820

    
821
/* vnc.c */
822
void vnc_display_init(DisplayState *ds, int display);
823

    
824
/* ide.c */
825
#define MAX_DISKS 4
826

    
827
extern BlockDriverState *bs_table[MAX_DISKS];
828

    
829
void isa_ide_init(int iobase, int iobase2, int irq,
830
                  BlockDriverState *hd0, BlockDriverState *hd1);
831
void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
832
                         int secondary_ide_enabled);
833
void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn);
834
int pmac_ide_init (BlockDriverState **hd_table,
835
                   SetIRQFunc *set_irq, void *irq_opaque, int irq);
836

    
837
/* cdrom.c */
838
int cdrom_read_toc(int nb_sectors, uint8_t *buf, int msf, int start_track);
839
int cdrom_read_toc_raw(int nb_sectors, uint8_t *buf, int msf, int session_num);
840

    
841
/* es1370.c */
842
int es1370_init (PCIBus *bus, AudioState *s);
843

    
844
/* sb16.c */
845
int SB16_init (AudioState *s);
846

    
847
/* adlib.c */
848
int Adlib_init (AudioState *s);
849

    
850
/* gus.c */
851
int GUS_init (AudioState *s);
852

    
853
/* dma.c */
854
typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
855
int DMA_get_channel_mode (int nchan);
856
int DMA_read_memory (int nchan, void *buf, int pos, int size);
857
int DMA_write_memory (int nchan, void *buf, int pos, int size);
858
void DMA_hold_DREQ (int nchan);
859
void DMA_release_DREQ (int nchan);
860
void DMA_schedule(int nchan);
861
void DMA_run (void);
862
void DMA_init (int high_page_enable);
863
void DMA_register_channel (int nchan,
864
                           DMA_transfer_handler transfer_handler,
865
                           void *opaque);
866
/* fdc.c */
867
#define MAX_FD 2
868
extern BlockDriverState *fd_table[MAX_FD];
869

    
870
typedef struct fdctrl_t fdctrl_t;
871

    
872
fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped, 
873
                       uint32_t io_base,
874
                       BlockDriverState **fds);
875
int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
876

    
877
/* ne2000.c */
878

    
879
void isa_ne2000_init(int base, int irq, NICInfo *nd);
880
void pci_ne2000_init(PCIBus *bus, NICInfo *nd);
881

    
882
/* rtl8139.c */
883

    
884
void pci_rtl8139_init(PCIBus *bus, NICInfo *nd);
885

    
886
/* pcnet.c */
887

    
888
void pci_pcnet_init(PCIBus *bus, NICInfo *nd);
889

    
890
/* pckbd.c */
891

    
892
void kbd_init(void);
893

    
894
/* mc146818rtc.c */
895

    
896
typedef struct RTCState RTCState;
897

    
898
RTCState *rtc_init(int base, int irq);
899
void rtc_set_memory(RTCState *s, int addr, int val);
900
void rtc_set_date(RTCState *s, const struct tm *tm);
901

    
902
/* serial.c */
903

    
904
typedef struct SerialState SerialState;
905
SerialState *serial_init(SetIRQFunc *set_irq, void *opaque,
906
                         int base, int irq, CharDriverState *chr);
907
SerialState *serial_mm_init (SetIRQFunc *set_irq, void *opaque,
908
                             target_ulong base, int it_shift,
909
                             int irq, CharDriverState *chr);
910

    
911
/* parallel.c */
912

    
913
typedef struct ParallelState ParallelState;
914
ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
915

    
916
/* i8259.c */
917

    
918
typedef struct PicState2 PicState2;
919
extern PicState2 *isa_pic;
920
void pic_set_irq(int irq, int level);
921
void pic_set_irq_new(void *opaque, int irq, int level);
922
PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
923
void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
924
                          void *alt_irq_opaque);
925
int pic_read_irq(PicState2 *s);
926
void pic_update_irq(PicState2 *s);
927
uint32_t pic_intack_read(PicState2 *s);
928
void pic_info(void);
929
void irq_info(void);
930

    
931
/* APIC */
932
typedef struct IOAPICState IOAPICState;
933

    
934
int apic_init(CPUState *env);
935
int apic_get_interrupt(CPUState *env);
936
IOAPICState *ioapic_init(void);
937
void ioapic_set_irq(void *opaque, int vector, int level);
938

    
939
/* i8254.c */
940

    
941
#define PIT_FREQ 1193182
942

    
943
typedef struct PITState PITState;
944

    
945
PITState *pit_init(int base, int irq);
946
void pit_set_gate(PITState *pit, int channel, int val);
947
int pit_get_gate(PITState *pit, int channel);
948
int pit_get_initial_count(PITState *pit, int channel);
949
int pit_get_mode(PITState *pit, int channel);
950
int pit_get_out(PITState *pit, int channel, int64_t current_time);
951

    
952
/* pcspk.c */
953
void pcspk_init(PITState *);
954
int pcspk_audio_init(AudioState *);
955

    
956
/* acpi.c */
957
extern int acpi_enabled;
958
void piix4_pm_init(PCIBus *bus, int devfn);
959
void acpi_bios_init(void);
960

    
961
/* pc.c */
962
extern QEMUMachine pc_machine;
963
extern QEMUMachine isapc_machine;
964
extern int fd_bootchk;
965

    
966
void ioport_set_a20(int enable);
967
int ioport_get_a20(void);
968

    
969
/* ppc.c */
970
extern QEMUMachine prep_machine;
971
extern QEMUMachine core99_machine;
972
extern QEMUMachine heathrow_machine;
973

    
974
/* mips_r4k.c */
975
extern QEMUMachine mips_machine;
976

    
977
/* shix.c */
978
extern QEMUMachine shix_machine;
979

    
980
#ifdef TARGET_PPC
981
ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
982
#endif
983
void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
984

    
985
extern CPUWriteMemoryFunc *PPC_io_write[];
986
extern CPUReadMemoryFunc *PPC_io_read[];
987
void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
988

    
989
/* sun4m.c */
990
extern QEMUMachine sun4m_machine;
991
uint32_t iommu_translate(uint32_t addr);
992
void pic_set_irq_cpu(int irq, int level, unsigned int cpu);
993

    
994
/* iommu.c */
995
void *iommu_init(uint32_t addr);
996
uint32_t iommu_translate_local(void *opaque, uint32_t addr);
997

    
998
/* lance.c */
999
void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
1000

    
1001
/* tcx.c */
1002
void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
1003
               unsigned long vram_offset, int vram_size, int width, int height);
1004

    
1005
/* slavio_intctl.c */
1006
void *slavio_intctl_init();
1007
void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env);
1008
void slavio_pic_info(void *opaque);
1009
void slavio_irq_info(void *opaque);
1010
void slavio_pic_set_irq(void *opaque, int irq, int level);
1011
void slavio_pic_set_irq_cpu(void *opaque, int irq, int level, unsigned int cpu);
1012

    
1013
/* loader.c */
1014
int get_image_size(const char *filename);
1015
int load_image(const char *filename, uint8_t *addr);
1016
int load_elf(const char *filename, int64_t virt_to_phys_addend, uint64_t *pentry);
1017
int load_aout(const char *filename, uint8_t *addr);
1018

    
1019
/* slavio_timer.c */
1020
void slavio_timer_init(uint32_t addr, int irq, int mode, unsigned int cpu);
1021

    
1022
/* slavio_serial.c */
1023
SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
1024
void slavio_serial_ms_kbd_init(int base, int irq);
1025

    
1026
/* slavio_misc.c */
1027
void *slavio_misc_init(uint32_t base, int irq);
1028
void slavio_set_power_fail(void *opaque, int power_failing);
1029

    
1030
/* esp.c */
1031
void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr);
1032

    
1033
/* sun4u.c */
1034
extern QEMUMachine sun4u_machine;
1035

    
1036
/* NVRAM helpers */
1037
#include "hw/m48t59.h"
1038

    
1039
void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
1040
uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
1041
void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
1042
uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
1043
void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
1044
uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
1045
void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
1046
                       const unsigned char *str, uint32_t max);
1047
int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
1048
void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
1049
                    uint32_t start, uint32_t count);
1050
int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
1051
                          const unsigned char *arch,
1052
                          uint32_t RAM_size, int boot_device,
1053
                          uint32_t kernel_image, uint32_t kernel_size,
1054
                          const char *cmdline,
1055
                          uint32_t initrd_image, uint32_t initrd_size,
1056
                          uint32_t NVRAM_image,
1057
                          int width, int height, int depth);
1058

    
1059
/* adb.c */
1060

    
1061
#define MAX_ADB_DEVICES 16
1062

    
1063
#define ADB_MAX_OUT_LEN 16
1064

    
1065
typedef struct ADBDevice ADBDevice;
1066

    
1067
/* buf = NULL means polling */
1068
typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
1069
                              const uint8_t *buf, int len);
1070
typedef int ADBDeviceReset(ADBDevice *d);
1071

    
1072
struct ADBDevice {
1073
    struct ADBBusState *bus;
1074
    int devaddr;
1075
    int handler;
1076
    ADBDeviceRequest *devreq;
1077
    ADBDeviceReset *devreset;
1078
    void *opaque;
1079
};
1080

    
1081
typedef struct ADBBusState {
1082
    ADBDevice devices[MAX_ADB_DEVICES];
1083
    int nb_devices;
1084
    int poll_index;
1085
} ADBBusState;
1086

    
1087
int adb_request(ADBBusState *s, uint8_t *buf_out,
1088
                const uint8_t *buf, int len);
1089
int adb_poll(ADBBusState *s, uint8_t *buf_out);
1090

    
1091
ADBDevice *adb_register_device(ADBBusState *s, int devaddr, 
1092
                               ADBDeviceRequest *devreq, 
1093
                               ADBDeviceReset *devreset, 
1094
                               void *opaque);
1095
void adb_kbd_init(ADBBusState *bus);
1096
void adb_mouse_init(ADBBusState *bus);
1097

    
1098
/* cuda.c */
1099

    
1100
extern ADBBusState adb_bus;
1101
int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
1102

    
1103
#include "hw/usb.h"
1104

    
1105
/* usb ports of the VM */
1106

    
1107
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
1108
                            usb_attachfn attach);
1109

    
1110
#define VM_USB_HUB_SIZE 8
1111

    
1112
void do_usb_add(const char *devname);
1113
void do_usb_del(const char *devname);
1114
void usb_info(void);
1115

    
1116
/* scsi-disk.c */
1117
typedef struct SCSIDevice SCSIDevice;
1118
typedef void (*scsi_completionfn)(void *, uint32_t, int);
1119

    
1120
SCSIDevice *scsi_disk_init(BlockDriverState *bdrv,
1121
                           scsi_completionfn completion,
1122
                           void *opaque);
1123
void scsi_disk_destroy(SCSIDevice *s);
1124

    
1125
int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun);
1126
int scsi_read_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1127
int scsi_write_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1128

    
1129
/* lsi53c895a.c */
1130
void lsi_scsi_attach(void *opaque, BlockDriverState *bd, int id);
1131
void *lsi_scsi_init(PCIBus *bus, int devfn);
1132

    
1133
/* integratorcp.c */
1134
extern QEMUMachine integratorcp926_machine;
1135
extern QEMUMachine integratorcp1026_machine;
1136

    
1137
/* versatilepb.c */
1138
extern QEMUMachine versatilepb_machine;
1139
extern QEMUMachine versatileab_machine;
1140

    
1141
/* ps2.c */
1142
void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
1143
void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
1144
void ps2_write_mouse(void *, int val);
1145
void ps2_write_keyboard(void *, int val);
1146
uint32_t ps2_read_data(void *);
1147
void ps2_queue(void *, int b);
1148
void ps2_keyboard_set_translation(void *opaque, int mode);
1149

    
1150
/* smc91c111.c */
1151
void smc91c111_init(NICInfo *, uint32_t, void *, int);
1152

    
1153
/* pl110.c */
1154
void *pl110_init(DisplayState *ds, uint32_t base, void *pic, int irq, int);
1155

    
1156
/* pl011.c */
1157
void pl011_init(uint32_t base, void *pic, int irq, CharDriverState *chr);
1158

    
1159
/* pl050.c */
1160
void pl050_init(uint32_t base, void *pic, int irq, int is_mouse);
1161

    
1162
/* pl080.c */
1163
void *pl080_init(uint32_t base, void *pic, int irq);
1164

    
1165
/* pl190.c */
1166
void *pl190_init(uint32_t base, void *parent, int irq, int fiq);
1167

    
1168
/* arm-timer.c */
1169
void sp804_init(uint32_t base, void *pic, int irq);
1170
void icp_pit_init(uint32_t base, void *pic, int irq);
1171

    
1172
/* arm_boot.c */
1173

    
1174
void arm_load_kernel(int ram_size, const char *kernel_filename,
1175
                     const char *kernel_cmdline, const char *initrd_filename,
1176
                     int board_id);
1177

    
1178
/* sh7750.c */
1179
struct SH7750State;
1180

    
1181
struct SH7750State *sh7750_init(CPUState * cpu);
1182

    
1183
typedef struct {
1184
    /* The callback will be triggered if any of the designated lines change */
1185
    uint16_t portamask_trigger;
1186
    uint16_t portbmask_trigger;
1187
    /* Return 0 if no action was taken */
1188
    int (*port_change_cb) (uint16_t porta, uint16_t portb,
1189
                           uint16_t * periph_pdtra,
1190
                           uint16_t * periph_portdira,
1191
                           uint16_t * periph_pdtrb,
1192
                           uint16_t * periph_portdirb);
1193
} sh7750_io_device;
1194

    
1195
int sh7750_register_io_device(struct SH7750State *s,
1196
                              sh7750_io_device * device);
1197
/* tc58128.c */
1198
int tc58128_init(struct SH7750State *s, char *zone1, char *zone2);
1199

    
1200
/* NOR flash devices */
1201
typedef struct pflash_t pflash_t;
1202

    
1203
pflash_t *pflash_register (target_ulong base, ram_addr_t off,
1204
                           BlockDriverState *bs,
1205
                           target_ulong sector_len, int nb_blocs, int width,
1206
                           uint16_t id0, uint16_t id1, 
1207
                           uint16_t id2, uint16_t id3);
1208

    
1209
#endif /* defined(QEMU_TOOL) */
1210

    
1211
/* monitor.c */
1212
void monitor_init(CharDriverState *hd, int show_banner);
1213
void term_puts(const char *str);
1214
void term_vprintf(const char *fmt, va_list ap);
1215
void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
1216
void term_flush(void);
1217
void term_print_help(void);
1218
void monitor_readline(const char *prompt, int is_password,
1219
                      char *buf, int buf_size);
1220

    
1221
/* readline.c */
1222
typedef void ReadLineFunc(void *opaque, const char *str);
1223

    
1224
extern int completion_index;
1225
void add_completion(const char *str);
1226
void readline_handle_byte(int ch);
1227
void readline_find_completion(const char *cmdline);
1228
const char *readline_get_history(unsigned int index);
1229
void readline_start(const char *prompt, int is_password,
1230
                    ReadLineFunc *readline_func, void *opaque);
1231

    
1232
void kqemu_record_dump(void);
1233

    
1234
#endif /* VL_H */