Statistics
| Branch: | Revision:

root / vl.h @ 7d3505c5

History | View | Annotate | Download (13.6 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 <time.h>
34
#include <ctype.h>
35
#include <errno.h>
36
#include <unistd.h>
37
#include <fcntl.h>
38
#include <sys/stat.h>
39

    
40
#ifndef O_LARGEFILE
41
#define O_LARGEFILE 0
42
#endif
43
#ifndef O_BINARY
44
#define O_BINARY 0
45
#endif
46

    
47
#ifdef _WIN32
48
#define lseek64 _lseeki64
49
#endif
50

    
51
#include "cpu.h"
52

    
53
#ifdef _BSD
54
#define lseek64 lseek
55
#define ftruncate64 ftruncate
56
#define mkstemp64 mkstemp
57
#define MAP_ANONYMOUS MAP_ANON
58
#endif
59

    
60
#ifndef glue
61
#define xglue(x, y) x ## y
62
#define glue(x, y) xglue(x, y)
63
#define stringify(s)        tostring(s)
64
#define tostring(s)        #s
65
#endif
66

    
67
#if defined(WORDS_BIGENDIAN)
68
static inline uint32_t be32_to_cpu(uint32_t v)
69
{
70
    return v;
71
}
72

    
73
static inline uint16_t be16_to_cpu(uint16_t v)
74
{
75
    return v;
76
}
77

    
78
static inline uint32_t cpu_to_be32(uint32_t v)
79
{
80
    return v;
81
}
82

    
83
static inline uint16_t cpu_to_be16(uint16_t v)
84
{
85
    return v;
86
}
87

    
88
static inline uint32_t le32_to_cpu(uint32_t v)
89
{
90
    return bswap32(v);
91
}
92

    
93
static inline uint16_t le16_to_cpu(uint16_t v)
94
{
95
    return bswap16(v);
96
}
97

    
98
static inline uint32_t cpu_to_le32(uint32_t v)
99
{
100
    return bswap32(v);
101
}
102

    
103
static inline uint16_t cpu_to_le16(uint16_t v)
104
{
105
    return bswap16(v);
106
}
107

    
108
#else
109

    
110
static inline uint32_t be32_to_cpu(uint32_t v)
111
{
112
    return bswap32(v);
113
}
114

    
115
static inline uint16_t be16_to_cpu(uint16_t v)
116
{
117
    return bswap16(v);
118
}
119

    
120
static inline uint32_t cpu_to_be32(uint32_t v)
121
{
122
    return bswap32(v);
123
}
124

    
125
static inline uint16_t cpu_to_be16(uint16_t v)
126
{
127
    return bswap16(v);
128
}
129

    
130
static inline uint32_t le32_to_cpu(uint32_t v)
131
{
132
    return v;
133
}
134

    
135
static inline uint16_t le16_to_cpu(uint16_t v)
136
{
137
    return v;
138
}
139

    
140
static inline uint32_t cpu_to_le32(uint32_t v)
141
{
142
    return v;
143
}
144

    
145
static inline uint16_t cpu_to_le16(uint16_t v)
146
{
147
    return v;
148
}
149
#endif
150

    
151

    
152
/* vl.c */
153
extern int reset_requested;
154

    
155
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
156

    
157
void hw_error(const char *fmt, ...);
158

    
159
int load_image(const char *filename, uint8_t *addr);
160
extern const char *bios_dir;
161

    
162
void pstrcpy(char *buf, int buf_size, const char *str);
163
char *pstrcat(char *buf, int buf_size, const char *s);
164

    
165
int serial_open_device(void);
166

    
167
extern int vm_running;
168

    
169
typedef void VMStopHandler(void *opaque, int reason);
170

    
171
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
172
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
173

    
174
void vm_start(void);
175
void vm_stop(int reason);
176

    
177
extern int audio_enabled;
178

    
179
/* async I/O support */
180

    
181
typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
182
typedef int IOCanRWHandler(void *opaque);
183

    
184
int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read, 
185
                             IOReadHandler *fd_read, void *opaque);
186
void qemu_del_fd_read_handler(int fd);
187

    
188
/* network redirectors support */
189

    
190
#define MAX_NICS 8
191

    
192
typedef struct NetDriverState {
193
    int index; /* index number in QEMU */
194
    uint8_t macaddr[6];
195
    char ifname[16];
196
    void (*send_packet)(struct NetDriverState *nd, 
197
                        const uint8_t *buf, int size);
198
    void (*add_read_packet)(struct NetDriverState *nd, 
199
                            IOCanRWHandler *fd_can_read, 
200
                            IOReadHandler *fd_read, void *opaque);
201
    /* tun specific data */
202
    int fd;
203
    /* slirp specific data */
204
} NetDriverState;
205

    
206
extern int nb_nics;
207
extern NetDriverState nd_table[MAX_NICS];
208

    
209
void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size);
210
void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read, 
211
                          IOReadHandler *fd_read, void *opaque);
212

    
213
/* timers */
214

    
215
typedef struct QEMUClock QEMUClock;
216
typedef struct QEMUTimer QEMUTimer;
217
typedef void QEMUTimerCB(void *opaque);
218

    
219
/* The real time clock should be used only for stuff which does not
220
   change the virtual machine state, as it is run even if the virtual
221
   machine is stopped. The real time clock has a frequency or 1000
222
   Hz. */
223
extern QEMUClock *rt_clock;
224

    
225
/* Rge virtual clock is only run during the emulation. It is stopped
226
   when the virtual machine is stopped. Virtual timers use a high
227
   precision clock, usually cpu cycles (use ticks_per_sec). */
228
extern QEMUClock *vm_clock;
229

    
230
int64_t qemu_get_clock(QEMUClock *clock);
231

    
232
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
233
void qemu_free_timer(QEMUTimer *ts);
234
void qemu_del_timer(QEMUTimer *ts);
235
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
236
int qemu_timer_pending(QEMUTimer *ts);
237

    
238
extern int64_t ticks_per_sec;
239
extern int pit_min_timer_count;
240

    
241
void cpu_enable_ticks(void);
242
void cpu_disable_ticks(void);
243

    
244
/* VM Load/Save */
245

    
246
typedef FILE QEMUFile;
247

    
248
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
249
void qemu_put_byte(QEMUFile *f, int v);
250
void qemu_put_be16(QEMUFile *f, unsigned int v);
251
void qemu_put_be32(QEMUFile *f, unsigned int v);
252
void qemu_put_be64(QEMUFile *f, uint64_t v);
253
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
254
int qemu_get_byte(QEMUFile *f);
255
unsigned int qemu_get_be16(QEMUFile *f);
256
unsigned int qemu_get_be32(QEMUFile *f);
257
uint64_t qemu_get_be64(QEMUFile *f);
258

    
259
static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
260
{
261
    qemu_put_be64(f, *pv);
262
}
263

    
264
static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
265
{
266
    qemu_put_be32(f, *pv);
267
}
268

    
269
static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
270
{
271
    qemu_put_be16(f, *pv);
272
}
273

    
274
static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
275
{
276
    qemu_put_byte(f, *pv);
277
}
278

    
279
static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
280
{
281
    *pv = qemu_get_be64(f);
282
}
283

    
284
static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
285
{
286
    *pv = qemu_get_be32(f);
287
}
288

    
289
static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
290
{
291
    *pv = qemu_get_be16(f);
292
}
293

    
294
static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
295
{
296
    *pv = qemu_get_byte(f);
297
}
298

    
299
int64_t qemu_ftell(QEMUFile *f);
300
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
301

    
302
typedef void SaveStateHandler(QEMUFile *f, void *opaque);
303
typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
304

    
305
int qemu_loadvm(const char *filename);
306
int qemu_savevm(const char *filename);
307
int register_savevm(const char *idstr, 
308
                    int instance_id, 
309
                    int version_id,
310
                    SaveStateHandler *save_state,
311
                    LoadStateHandler *load_state,
312
                    void *opaque);
313
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
314
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
315

    
316
/* block.c */
317
typedef struct BlockDriverState BlockDriverState;
318

    
319
BlockDriverState *bdrv_new(const char *device_name);
320
void bdrv_delete(BlockDriverState *bs);
321
int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
322
void bdrv_close(BlockDriverState *bs);
323
int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
324
              uint8_t *buf, int nb_sectors);
325
int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
326
               const uint8_t *buf, int nb_sectors);
327
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
328
int bdrv_commit(BlockDriverState *bs);
329
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
330

    
331
#define BDRV_TYPE_HD     0
332
#define BDRV_TYPE_CDROM  1
333
#define BDRV_TYPE_FLOPPY 2
334

    
335
void bdrv_set_geometry_hint(BlockDriverState *bs, 
336
                            int cyls, int heads, int secs);
337
void bdrv_set_type_hint(BlockDriverState *bs, int type);
338
void bdrv_get_geometry_hint(BlockDriverState *bs, 
339
                            int *pcyls, int *pheads, int *psecs);
340
int bdrv_get_type_hint(BlockDriverState *bs);
341
int bdrv_is_removable(BlockDriverState *bs);
342
int bdrv_is_read_only(BlockDriverState *bs);
343
int bdrv_is_inserted(BlockDriverState *bs);
344
int bdrv_is_locked(BlockDriverState *bs);
345
void bdrv_set_locked(BlockDriverState *bs, int locked);
346
void bdrv_set_change_cb(BlockDriverState *bs, 
347
                        void (*change_cb)(void *opaque), void *opaque);
348

    
349
void bdrv_info(void);
350
BlockDriverState *bdrv_find(const char *name);
351

    
352
/* ISA bus */
353

    
354
extern target_phys_addr_t isa_mem_base;
355

    
356
typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
357
typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
358

    
359
int register_ioport_read(int start, int length, int size, 
360
                         IOPortReadFunc *func, void *opaque);
361
int register_ioport_write(int start, int length, int size, 
362
                          IOPortWriteFunc *func, void *opaque);
363

    
364
/* vga.c */
365

    
366
#define VGA_RAM_SIZE (4096 * 1024)
367

    
368
typedef struct DisplayState {
369
    uint8_t *data;
370
    int linesize;
371
    int depth;
372
    void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
373
    void (*dpy_resize)(struct DisplayState *s, int w, int h);
374
    void (*dpy_refresh)(struct DisplayState *s);
375
} DisplayState;
376

    
377
static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
378
{
379
    s->dpy_update(s, x, y, w, h);
380
}
381

    
382
static inline void dpy_resize(DisplayState *s, int w, int h)
383
{
384
    s->dpy_resize(s, w, h);
385
}
386

    
387
int vga_initialize(DisplayState *ds, uint8_t *vga_ram_base, 
388
                   unsigned long vga_ram_offset, int vga_ram_size);
389
void vga_update_display(void);
390
void vga_screen_dump(const char *filename);
391

    
392
/* sdl.c */
393
void sdl_display_init(DisplayState *ds);
394

    
395
/* ide.c */
396
#define MAX_DISKS 4
397

    
398
extern BlockDriverState *bs_table[MAX_DISKS];
399

    
400
void ide_init(int iobase, int iobase2, int irq,
401
              BlockDriverState *hd0, BlockDriverState *hd1);
402

    
403
/* oss.c */
404
typedef enum {
405
  AUD_FMT_U8,
406
  AUD_FMT_S8,
407
  AUD_FMT_U16,
408
  AUD_FMT_S16
409
} audfmt_e;
410

    
411
void AUD_open (int rfreq, int rnchannels, audfmt_e rfmt);
412
void AUD_reset (int rfreq, int rnchannels, audfmt_e rfmt);
413
int AUD_write (void *in_buf, int size);
414
void AUD_run (void);
415
void AUD_adjust_estimate (int _leftover);
416
int AUD_get_free (void);
417
int AUD_get_live (void);
418
int AUD_get_buffer_size (void);
419
void AUD_init (void);
420

    
421
/* dma.c */
422
typedef int (*DMA_transfer_handler) (void *opaque, target_ulong addr, int size);
423
int DMA_get_channel_mode (int nchan);
424
void DMA_hold_DREQ (int nchan);
425
void DMA_release_DREQ (int nchan);
426
void DMA_schedule(int nchan);
427
void DMA_run (void);
428
void DMA_init (void);
429
void DMA_register_channel (int nchan,
430
                           DMA_transfer_handler transfer_handler, void *opaque);
431

    
432
/* sb16.c */
433
void SB16_run (void);
434
void SB16_init (void);
435
 
436
/* fdc.c */
437
#define MAX_FD 2
438
extern BlockDriverState *fd_table[MAX_FD];
439

    
440
typedef struct fdctrl_t fdctrl_t;
441

    
442
fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped, 
443
                       uint32_t io_base,
444
                       BlockDriverState **fds);
445
int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
446

    
447
/* ne2000.c */
448

    
449
void ne2000_init(int base, int irq, NetDriverState *nd);
450

    
451
/* pckbd.c */
452

    
453
void kbd_put_keycode(int keycode);
454

    
455
#define MOUSE_EVENT_LBUTTON 0x01
456
#define MOUSE_EVENT_RBUTTON 0x02
457
#define MOUSE_EVENT_MBUTTON 0x04
458
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
459

    
460
void kbd_init(void);
461

    
462
/* mc146818rtc.c */
463

    
464
typedef struct RTCState RTCState;
465

    
466
RTCState *rtc_init(int base, int irq);
467
void rtc_set_memory(RTCState *s, int addr, int val);
468
void rtc_set_date(RTCState *s, const struct tm *tm);
469

    
470
/* serial.c */
471

    
472
typedef struct SerialState SerialState;
473

    
474
extern SerialState *serial_console;
475

    
476
SerialState *serial_init(int base, int irq, int fd);
477
int serial_can_receive(SerialState *s);
478
void serial_receive_byte(SerialState *s, int ch);
479
void serial_receive_break(SerialState *s);
480

    
481
/* i8259.c */
482

    
483
void pic_set_irq(int irq, int level);
484
void pic_init(void);
485
uint32_t pic_intack_read(CPUState *env);
486
void pic_info(void);
487

    
488
/* i8254.c */
489

    
490
#define PIT_FREQ 1193182
491

    
492
typedef struct PITState PITState;
493

    
494
PITState *pit_init(int base, int irq);
495
void pit_set_gate(PITState *pit, int channel, int val);
496
int pit_get_gate(PITState *pit, int channel);
497
int pit_get_out(PITState *pit, int channel, int64_t current_time);
498

    
499
/* pc.c */
500
void pc_init(int ram_size, int vga_ram_size, int boot_device,
501
             DisplayState *ds, const char **fd_filename, int snapshot,
502
             const char *kernel_filename, const char *kernel_cmdline,
503
             const char *initrd_filename);
504

    
505
/* ppc.c */
506
void ppc_init (int ram_size, int vga_ram_size, int boot_device,
507
               DisplayState *ds, const char **fd_filename, int snapshot,
508
               const char *kernel_filename, const char *kernel_cmdline,
509
               const char *initrd_filename);
510

    
511
/* monitor.c */
512
void monitor_init(void);
513
void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
514
void term_flush(void);
515
void term_print_help(void);
516

    
517
/* gdbstub.c */
518

    
519
#define DEFAULT_GDBSTUB_PORT 1234
520

    
521
int gdbserver_start(int port);
522

    
523
#endif /* VL_H */