vcs.maemo.org Git - qemu/blob - vl.h

   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 /* block.c */
 485 typedef struct BlockDriverState BlockDriverState;
 486 typedef struct BlockDriver BlockDriver;
 487
 488 extern BlockDriver bdrv_raw;
 489 extern BlockDriver bdrv_cow;
 490 extern BlockDriver bdrv_qcow;
 491 extern BlockDriver bdrv_vmdk;
 492 extern BlockDriver bdrv_cloop;
 493 extern BlockDriver bdrv_dmg;
 494 extern BlockDriver bdrv_bochs;
 495 extern BlockDriver bdrv_vpc;
 496 extern BlockDriver bdrv_vvfat;
 497
 498 void bdrv_init(void);
 499 BlockDriver *bdrv_find_format(const char *format_name);
 500 int bdrv_create(BlockDriver *drv,
 501                 const char *filename, int64_t size_in_sectors,
 502                 const char *backing_file, int flags);
 503 BlockDriverState *bdrv_new(const char *device_name);
 504 void bdrv_delete(BlockDriverState *bs);
 505 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
 506 int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
 507                BlockDriver *drv);
 508 void bdrv_close(BlockDriverState *bs);
 509 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
 510               uint8_t *buf, int nb_sectors);
 511 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
 512                const uint8_t *buf, int nb_sectors);
 513 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
 514 int bdrv_commit(BlockDriverState *bs);
 515 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
 516 /* Ensure contents are flushed to disk.  */
 517 void bdrv_flush(BlockDriverState *bs);
 518
 519 #define BDRV_TYPE_HD     0
 520 #define BDRV_TYPE_CDROM  1
 521 #define BDRV_TYPE_FLOPPY 2
 522 #define BIOS_ATA_TRANSLATION_AUTO 0
 523 #define BIOS_ATA_TRANSLATION_NONE 1
 524 #define BIOS_ATA_TRANSLATION_LBA  2
 525
 526 void bdrv_set_geometry_hint(BlockDriverState *bs,
 527                             int cyls, int heads, int secs);
 528 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 529 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
 530 void bdrv_get_geometry_hint(BlockDriverState *bs,
 531                             int *pcyls, int *pheads, int *psecs);
 532 int bdrv_get_type_hint(BlockDriverState *bs);
 533 int bdrv_get_translation_hint(BlockDriverState *bs);
 534 int bdrv_is_removable(BlockDriverState *bs);
 535 int bdrv_is_read_only(BlockDriverState *bs);
 536 int bdrv_is_inserted(BlockDriverState *bs);
 537 int bdrv_is_locked(BlockDriverState *bs);
 538 void bdrv_set_locked(BlockDriverState *bs, int locked);
 539 void bdrv_set_change_cb(BlockDriverState *bs,
 540                         void (*change_cb)(void *opaque), void *opaque);
 541 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
 542 void bdrv_info(void);
 543 BlockDriverState *bdrv_find(const char *name);
 544 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
 545 int bdrv_is_encrypted(BlockDriverState *bs);
 546 int bdrv_set_key(BlockDriverState *bs, const char *key);
 547 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
 548                          void *opaque);
 549 const char *bdrv_get_device_name(BlockDriverState *bs);
 550
 551 int qcow_get_cluster_size(BlockDriverState *bs);
 552 int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
 553                           const uint8_t *buf);
 554
 555 #ifndef QEMU_TOOL
 556
 557 typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
 558                                  int boot_device,
 559              DisplayState *ds, const char **fd_filename, int snapshot,
 560              const char *kernel_filename, const char *kernel_cmdline,
 561              const char *initrd_filename);
 562
 563 typedef struct QEMUMachine {
 564     const char *name;
 565     const char *desc;
 566     QEMUMachineInitFunc *init;
 567     struct QEMUMachine *next;
 568 } QEMUMachine;
 569
 570 int qemu_register_machine(QEMUMachine *m);
 571
 572 typedef void SetIRQFunc(void *opaque, int irq_num, int level);
 573 typedef void IRQRequestFunc(void *opaque, int level);
 574
 575 /* ISA bus */
 576
 577 extern target_phys_addr_t isa_mem_base;
 578
 579 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
 580 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
 581
 582 int register_ioport_read(int start, int length, int size,
 583                          IOPortReadFunc *func, void *opaque);
 584 int register_ioport_write(int start, int length, int size,
 585                           IOPortWriteFunc *func, void *opaque);
 586 void isa_unassign_ioport(int start, int length);
 587
 588 /* PCI bus */
 589
 590 extern target_phys_addr_t pci_mem_base;
 591
 592 typedef struct PCIBus PCIBus;
 593 typedef struct PCIDevice PCIDevice;
 594
 595 typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
 596                                 uint32_t address, uint32_t data, int len);
 597 typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
 598                                    uint32_t address, int len);
 599 typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
 600                                 uint32_t addr, uint32_t size, int type);
 601
 602 #define PCI_ADDRESS_SPACE_MEM           0x00
 603 #define PCI_ADDRESS_SPACE_IO            0x01
 604 #define PCI_ADDRESS_SPACE_MEM_PREFETCH  0x08
 605
 606 typedef struct PCIIORegion {
 607     uint32_t addr; /* current PCI mapping address. -1 means not mapped */
 608     uint32_t size;
 609     uint8_t type;
 610     PCIMapIORegionFunc *map_func;
 611 } PCIIORegion;
 612
 613 #define PCI_ROM_SLOT 6
 614 #define PCI_NUM_REGIONS 7
 615
 616 #define PCI_DEVICES_MAX 64
 617
 618 #define PCI_VENDOR_ID           0x00    /* 16 bits */
 619 #define PCI_DEVICE_ID           0x02    /* 16 bits */
 620 #define PCI_COMMAND             0x04    /* 16 bits */
 621 #define  PCI_COMMAND_IO         0x1     /* Enable response in I/O space */
 622 #define  PCI_COMMAND_MEMORY     0x2     /* Enable response in Memory space */
 623 #define PCI_CLASS_DEVICE        0x0a    /* Device class */
 624 #define PCI_INTERRUPT_LINE      0x3c    /* 8 bits */
 625 #define PCI_INTERRUPT_PIN       0x3d    /* 8 bits */
 626 #define PCI_MIN_GNT             0x3e    /* 8 bits */
 627 #define PCI_MAX_LAT             0x3f    /* 8 bits */
 628
 629 struct PCIDevice {
 630     /* PCI config space */
 631     uint8_t config[256];
 632
 633     /* the following fields are read only */
 634     PCIBus *bus;
 635     int devfn;
 636     char name[64];
 637     PCIIORegion io_regions[PCI_NUM_REGIONS];
 638
 639     /* do not access the following fields */
 640     PCIConfigReadFunc *config_read;
 641     PCIConfigWriteFunc *config_write;
 642     /* ??? This is a PC-specific hack, and should be removed.  */
 643     int irq_index;
 644 };
 645
 646 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
 647                                int instance_size, int devfn,
 648                                PCIConfigReadFunc *config_read,
 649                                PCIConfigWriteFunc *config_write);
 650
 651 void pci_register_io_region(PCIDevice *pci_dev, int region_num,
 652                             uint32_t size, int type,
 653                             PCIMapIORegionFunc *map_func);
 654
 655 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
 656
 657 uint32_t pci_default_read_config(PCIDevice *d,
 658                                  uint32_t address, int len);
 659 void pci_default_write_config(PCIDevice *d,
 660                               uint32_t address, uint32_t val, int len);
 661 void generic_pci_save(QEMUFile* f, void *opaque);
 662 int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
 663
 664 typedef void (*pci_set_irq_fn)(PCIDevice *pci_dev, void *pic,
 665                                int irq_num, int level);
 666 PCIBus *pci_register_bus(pci_set_irq_fn set_irq, void *pic, int devfn_min);
 667
 668 void pci_nic_init(PCIBus *bus, NICInfo *nd);
 669 void pci_data_write(void *opaque, uint32_t addr, uint32_t val, int len);
 670 uint32_t pci_data_read(void *opaque, uint32_t addr, int len);
 671 int pci_bus_num(PCIBus *s);
 672 void pci_for_each_device(void (*fn)(PCIDevice *d));
 673
 674 void pci_info(void);
 675
 676 /* prep_pci.c */
 677 PCIBus *pci_prep_init(void);
 678
 679 /* grackle_pci.c */
 680 PCIBus *pci_grackle_init(uint32_t base, void *pic);
 681
 682 /* unin_pci.c */
 683 PCIBus *pci_pmac_init(void *pic);
 684
 685 /* apb_pci.c */
 686 PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base,
 687                      void *pic);
 688
 689 PCIBus *pci_vpb_init(void *pic);
 690
 691 /* piix_pci.c */
 692 PCIBus *i440fx_init(void);
 693 int piix3_init(PCIBus *bus);
 694 void pci_bios_init(void);
 695
 696 /* openpic.c */
 697 typedef struct openpic_t openpic_t;
 698 void openpic_set_irq(void *opaque, int n_IRQ, int level);
 699 openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus,
 700                          CPUState **envp);
 701
 702 /* heathrow_pic.c */
 703 typedef struct HeathrowPICS HeathrowPICS;
 704 void heathrow_pic_set_irq(void *opaque, int num, int level);
 705 HeathrowPICS *heathrow_pic_init(int *pmem_index);
 706
 707 #ifdef HAS_AUDIO
 708 struct soundhw {
 709     const char *name;
 710     const char *descr;
 711     int enabled;
 712     int isa;
 713     union {
 714         int (*init_isa) (AudioState *s);
 715         int (*init_pci) (PCIBus *bus, AudioState *s);
 716     } init;
 717 };
 718
 719 extern struct soundhw soundhw[];
 720 #endif
 721
 722 /* vga.c */
 723
 724 #define VGA_RAM_SIZE (8192 * 1024)
 725
 726 struct DisplayState {
 727     uint8_t *data;
 728     int linesize;
 729     int depth;
 730     int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
 731     int width;
 732     int height;
 733     void *opaque;
 734
 735     void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
 736     void (*dpy_resize)(struct DisplayState *s, int w, int h);
 737     void (*dpy_refresh)(struct DisplayState *s);
 738     void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y, int dst_x, int dst_y, int w, int h);
 739 };
 740
 741 static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
 742 {
 743     s->dpy_update(s, x, y, w, h);
 744 }
 745
 746 static inline void dpy_resize(DisplayState *s, int w, int h)
 747 {
 748     s->dpy_resize(s, w, h);
 749 }
 750
 751 int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 752                    unsigned long vga_ram_offset, int vga_ram_size,
 753                    unsigned long vga_bios_offset, int vga_bios_size);
 754
 755 /* cirrus_vga.c */
 756 void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
 757                          unsigned long vga_ram_offset, int vga_ram_size);
 758 void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
 759                          unsigned long vga_ram_offset, int vga_ram_size);
 760
 761 /* sdl.c */
 762 void sdl_display_init(DisplayState *ds, int full_screen);
 763
 764 /* cocoa.m */
 765 void cocoa_display_init(DisplayState *ds, int full_screen);
 766
 767 /* vnc.c */
 768 void vnc_display_init(DisplayState *ds, int display);
 769
 770 /* ide.c */
 771 #define MAX_DISKS 4
 772
 773 extern BlockDriverState *bs_table[MAX_DISKS];
 774
 775 void isa_ide_init(int iobase, int iobase2, int irq,
 776                   BlockDriverState *hd0, BlockDriverState *hd1);
 777 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
 778                          int secondary_ide_enabled);
 779 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn);
 780 int pmac_ide_init (BlockDriverState **hd_table,
 781                    SetIRQFunc *set_irq, void *irq_opaque, int irq);
 782
 783 /* cdrom.c */
 784 int cdrom_read_toc(int nb_sectors, uint8_t *buf, int msf, int start_track);
 785 int cdrom_read_toc_raw(int nb_sectors, uint8_t *buf, int msf, int session_num);
 786
 787 /* es1370.c */
 788 int es1370_init (PCIBus *bus, AudioState *s);
 789
 790 /* sb16.c */
 791 int SB16_init (AudioState *s);
 792
 793 /* adlib.c */
 794 int Adlib_init (AudioState *s);
 795
 796 /* gus.c */
 797 int GUS_init (AudioState *s);
 798
 799 /* dma.c */
 800 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
 801 int DMA_get_channel_mode (int nchan);
 802 int DMA_read_memory (int nchan, void *buf, int pos, int size);
 803 int DMA_write_memory (int nchan, void *buf, int pos, int size);
 804 void DMA_hold_DREQ (int nchan);
 805 void DMA_release_DREQ (int nchan);
 806 void DMA_schedule(int nchan);
 807 void DMA_run (void);
 808 void DMA_init (int high_page_enable);
 809 void DMA_register_channel (int nchan,
 810                            DMA_transfer_handler transfer_handler,
 811                            void *opaque);
 812 /* fdc.c */
 813 #define MAX_FD 2
 814 extern BlockDriverState *fd_table[MAX_FD];
 815
 816 typedef struct fdctrl_t fdctrl_t;
 817
 818 fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
 819                        uint32_t io_base,
 820                        BlockDriverState **fds);
 821 int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
 822
 823 /* ne2000.c */
 824
 825 void isa_ne2000_init(int base, int irq, NICInfo *nd);
 826 void pci_ne2000_init(PCIBus *bus, NICInfo *nd);
 827
 828 /* rtl8139.c */
 829
 830 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd);
 831
 832 /* pcnet.c */
 833
 834 void pci_pcnet_init(PCIBus *bus, NICInfo *nd);
 835
 836 /* pckbd.c */
 837
 838 void kbd_init(void);
 839
 840 /* mc146818rtc.c */
 841
 842 typedef struct RTCState RTCState;
 843
 844 RTCState *rtc_init(int base, int irq);
 845 void rtc_set_memory(RTCState *s, int addr, int val);
 846 void rtc_set_date(RTCState *s, const struct tm *tm);
 847
 848 /* serial.c */
 849
 850 typedef struct SerialState SerialState;
 851 SerialState *serial_init(SetIRQFunc *set_irq, void *opaque,
 852                          int base, int irq, CharDriverState *chr);
 853 SerialState *serial_mm_init (SetIRQFunc *set_irq, void *opaque,
 854                              target_ulong base, int it_shift,
 855                              int irq, CharDriverState *chr);
 856
 857 /* parallel.c */
 858
 859 typedef struct ParallelState ParallelState;
 860 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
 861
 862 /* i8259.c */
 863
 864 typedef struct PicState2 PicState2;
 865 extern PicState2 *isa_pic;
 866 void pic_set_irq(int irq, int level);
 867 void pic_set_irq_new(void *opaque, int irq, int level);
 868 PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
 869 void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
 870                           void *alt_irq_opaque);
 871 int pic_read_irq(PicState2 *s);
 872 void pic_update_irq(PicState2 *s);
 873 uint32_t pic_intack_read(PicState2 *s);
 874 void pic_info(void);
 875 void irq_info(void);
 876
 877 /* APIC */
 878 typedef struct IOAPICState IOAPICState;
 879
 880 int apic_init(CPUState *env);
 881 int apic_get_interrupt(CPUState *env);
 882 IOAPICState *ioapic_init(void);
 883 void ioapic_set_irq(void *opaque, int vector, int level);
 884
 885 /* i8254.c */
 886
 887 #define PIT_FREQ 1193182
 888
 889 typedef struct PITState PITState;
 890
 891 PITState *pit_init(int base, int irq);
 892 void pit_set_gate(PITState *pit, int channel, int val);
 893 int pit_get_gate(PITState *pit, int channel);
 894 int pit_get_initial_count(PITState *pit, int channel);
 895 int pit_get_mode(PITState *pit, int channel);
 896 int pit_get_out(PITState *pit, int channel, int64_t current_time);
 897
 898 /* pcspk.c */
 899 void pcspk_init(PITState *);
 900 int pcspk_audio_init(AudioState *);
 901
 902 /* acpi.c */
 903 extern int acpi_enabled;
 904 void piix4_pm_init(PCIBus *bus, int devfn);
 905 void acpi_bios_init(void);
 906
 907 /* pc.c */
 908 extern QEMUMachine pc_machine;
 909 extern QEMUMachine isapc_machine;
 910 extern int fd_bootchk;
 911
 912 void ioport_set_a20(int enable);
 913 int ioport_get_a20(void);
 914
 915 /* ppc.c */
 916 extern QEMUMachine prep_machine;
 917 extern QEMUMachine core99_machine;
 918 extern QEMUMachine heathrow_machine;
 919
 920 /* mips_r4k.c */
 921 extern QEMUMachine mips_machine;
 922
 923 /* shix.c */
 924 extern QEMUMachine shix_machine;
 925
 926 #ifdef TARGET_PPC
 927 ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
 928 #endif
 929 void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
 930
 931 extern CPUWriteMemoryFunc *PPC_io_write[];
 932 extern CPUReadMemoryFunc *PPC_io_read[];
 933 void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
 934
 935 /* sun4m.c */
 936 extern QEMUMachine sun4m_machine;
 937 uint32_t iommu_translate(uint32_t addr);
 938 void pic_set_irq_cpu(int irq, int level, unsigned int cpu);
 939
 940 /* iommu.c */
 941 void *iommu_init(uint32_t addr);
 942 uint32_t iommu_translate_local(void *opaque, uint32_t addr);
 943
 944 /* lance.c */
 945 void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
 946
 947 /* tcx.c */
 948 void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
 949                unsigned long vram_offset, int vram_size, int width, int height);
 950
 951 /* slavio_intctl.c */
 952 void *slavio_intctl_init();
 953 void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env);
 954 void slavio_pic_info(void *opaque);
 955 void slavio_irq_info(void *opaque);
 956 void slavio_pic_set_irq(void *opaque, int irq, int level);
 957 void slavio_pic_set_irq_cpu(void *opaque, int irq, int level, unsigned int cpu);
 958
 959 /* loader.c */
 960 int get_image_size(const char *filename);
 961 int load_image(const char *filename, uint8_t *addr);
 962 int load_elf(const char *filename, int64_t virt_to_phys_addend, uint64_t *pentry);
 963 int load_aout(const char *filename, uint8_t *addr);
 964
 965 /* slavio_timer.c */
 966 void slavio_timer_init(uint32_t addr, int irq, int mode, unsigned int cpu);
 967
 968 /* slavio_serial.c */
 969 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
 970 void slavio_serial_ms_kbd_init(int base, int irq);
 971
 972 /* slavio_misc.c */
 973 void *slavio_misc_init(uint32_t base, int irq);
 974 void slavio_set_power_fail(void *opaque, int power_failing);
 975
 976 /* esp.c */
 977 void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr);
 978
 979 /* sun4u.c */
 980 extern QEMUMachine sun4u_machine;
 981
 982 /* NVRAM helpers */
 983 #include "hw/m48t59.h"
 984
 985 void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
 986 uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
 987 void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
 988 uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
 989 void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
 990 uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
 991 void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
 992                        const unsigned char *str, uint32_t max);
 993 int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
 994 void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
 995                     uint32_t start, uint32_t count);
 996 int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
 997                           const unsigned char *arch,
 998                           uint32_t RAM_size, int boot_device,
 999                           uint32_t kernel_image, uint32_t kernel_size,
1000                           const char *cmdline,
1001                           uint32_t initrd_image, uint32_t initrd_size,
1002                           uint32_t NVRAM_image,
1003                           int width, int height, int depth);
1004
1005 /* adb.c */
1006
1007 #define MAX_ADB_DEVICES 16
1008
1009 #define ADB_MAX_OUT_LEN 16
1010
1011 typedef struct ADBDevice ADBDevice;
1012
1013 /* buf = NULL means polling */
1014 typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
1015                               const uint8_t *buf, int len);
1016 typedef int ADBDeviceReset(ADBDevice *d);
1017
1018 struct ADBDevice {
1019     struct ADBBusState *bus;
1020     int devaddr;
1021     int handler;
1022     ADBDeviceRequest *devreq;
1023     ADBDeviceReset *devreset;
1024     void *opaque;
1025 };
1026
1027 typedef struct ADBBusState {
1028     ADBDevice devices[MAX_ADB_DEVICES];
1029     int nb_devices;
1030     int poll_index;
1031 } ADBBusState;
1032
1033 int adb_request(ADBBusState *s, uint8_t *buf_out,
1034                 const uint8_t *buf, int len);
1035 int adb_poll(ADBBusState *s, uint8_t *buf_out);
1036
1037 ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
1038                                ADBDeviceRequest *devreq,
1039                                ADBDeviceReset *devreset,
1040                                void *opaque);
1041 void adb_kbd_init(ADBBusState *bus);
1042 void adb_mouse_init(ADBBusState *bus);
1043
1044 /* cuda.c */
1045
1046 extern ADBBusState adb_bus;
1047 int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
1048
1049 #include "hw/usb.h"
1050
1051 /* usb ports of the VM */
1052
1053 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
1054                             usb_attachfn attach);
1055
1056 #define VM_USB_HUB_SIZE 8
1057
1058 void do_usb_add(const char *devname);
1059 void do_usb_del(const char *devname);
1060 void usb_info(void);
1061
1062 /* scsi-disk.c */
1063 typedef struct SCSIDevice SCSIDevice;
1064 typedef void (*scsi_completionfn)(void *, uint32_t, int);
1065
1066 SCSIDevice *scsi_disk_init(BlockDriverState *bdrv,
1067                            scsi_completionfn completion,
1068                            void *opaque);
1069 void scsi_disk_destroy(SCSIDevice *s);
1070
1071 int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun);
1072 int scsi_read_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1073 int scsi_write_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1074
1075 /* lsi53c895a.c */
1076 void lsi_scsi_attach(void *opaque, BlockDriverState *bd, int id);
1077 void *lsi_scsi_init(PCIBus *bus, int devfn);
1078
1079 /* integratorcp.c */
1080 extern QEMUMachine integratorcp926_machine;
1081 extern QEMUMachine integratorcp1026_machine;
1082
1083 /* versatilepb.c */
1084 extern QEMUMachine versatilepb_machine;
1085 extern QEMUMachine versatileab_machine;
1086
1087 /* ps2.c */
1088 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
1089 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
1090 void ps2_write_mouse(void *, int val);
1091 void ps2_write_keyboard(void *, int val);
1092 uint32_t ps2_read_data(void *);
1093 void ps2_queue(void *, int b);
1094 void ps2_keyboard_set_translation(void *opaque, int mode);
1095
1096 /* smc91c111.c */
1097 void smc91c111_init(NICInfo *, uint32_t, void *, int);
1098
1099 /* pl110.c */
1100 void *pl110_init(DisplayState *ds, uint32_t base, void *pic, int irq, int);
1101
1102 /* pl011.c */
1103 void pl011_init(uint32_t base, void *pic, int irq, CharDriverState *chr);
1104
1105 /* pl050.c */
1106 void pl050_init(uint32_t base, void *pic, int irq, int is_mouse);
1107
1108 /* pl080.c */
1109 void *pl080_init(uint32_t base, void *pic, int irq);
1110
1111 /* pl190.c */
1112 void *pl190_init(uint32_t base, void *parent, int irq, int fiq);
1113
1114 /* arm-timer.c */
1115 void sp804_init(uint32_t base, void *pic, int irq);
1116 void icp_pit_init(uint32_t base, void *pic, int irq);
1117
1118 /* arm_boot.c */
1119
1120 void arm_load_kernel(int ram_size, const char *kernel_filename,
1121                      const char *kernel_cmdline, const char *initrd_filename,
1122                      int board_id);
1123
1124 /* sh7750.c */
1125 struct SH7750State;
1126
1127 struct SH7750State *sh7750_init(CPUState * cpu);
1128
1129 typedef struct {
1130     /* The callback will be triggered if any of the designated lines change */
1131     uint16_t portamask_trigger;
1132     uint16_t portbmask_trigger;
1133     /* Return 0 if no action was taken */
1134     int (*port_change_cb) (uint16_t porta, uint16_t portb,
1135                            uint16_t * periph_pdtra,
1136                            uint16_t * periph_portdira,
1137                            uint16_t * periph_pdtrb,
1138                            uint16_t * periph_portdirb);
1139 } sh7750_io_device;
1140
1141 int sh7750_register_io_device(struct SH7750State *s,
1142                               sh7750_io_device * device);
1143 /* tc58128.c */
1144 int tc58128_init(struct SH7750State *s, char *zone1, char *zone2);
1145
1146 /* NOR flash devices */
1147 typedef struct pflash_t pflash_t;
1148
1149 pflash_t *pflash_register (target_ulong base, ram_addr_t off,
1150                            BlockDriverState *bs,
1151                            target_ulong sector_len, int nb_blocs, int width,
1152                            uint16_t id0, uint16_t id1,
1153                            uint16_t id2, uint16_t id3);
1154
1155 #endif /* defined(QEMU_TOOL) */
1156
1157 /* monitor.c */
1158 void monitor_init(CharDriverState *hd, int show_banner);
1159 void term_puts(const char *str);
1160 void term_vprintf(const char *fmt, va_list ap);
1161 void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
1162 void term_flush(void);
1163 void term_print_help(void);
1164 void monitor_readline(const char *prompt, int is_password,
1165                       char *buf, int buf_size);
1166
1167 /* readline.c */
1168 typedef void ReadLineFunc(void *opaque, const char *str);
1169
1170 extern int completion_index;
1171 void add_completion(const char *str);
1172 void readline_handle_byte(int ch);
1173 void readline_find_completion(const char *cmdline);
1174 const char *readline_get_history(unsigned int index);
1175 void readline_start(const char *prompt, int is_password,
1176                     ReadLineFunc *readline_func, void *opaque);
1177
1178 void kqemu_record_dump(void);
1179
1180 #endif /* VL_H */