Archipelago » qemu

/*

 * QEMU System Emulator

 * 

 * Copyright (c) 2003-2004 Fabrice Bellard

 * 

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "vl.h"

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <time.h>

#include <errno.h>

#include <sys/time.h>

#ifndef _WIN32

#include <sys/times.h>

#include <sys/wait.h>

#include <termios.h>

#include <sys/poll.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <dirent.h>

#ifdef _BSD

#include <sys/stat.h>

#ifndef __APPLE__

#include <libutil.h>

#endif

#else

#include <linux/if.h>

#include <linux/if_tun.h>

#include <pty.h>

#include <malloc.h>

#include <linux/rtc.h>

#endif

#endif

#if defined(CONFIG_SLIRP)

#include "libslirp.h"

#endif

#ifdef _WIN32

#include <malloc.h>

#include <sys/timeb.h>

#include <windows.h>

#define getopt_long_only getopt_long

#define memalign(align, size) malloc(size)

#endif

#ifdef CONFIG_SDL

#ifdef __APPLE__

#include <SDL/SDL.h>

#endif

#endif /* CONFIG_SDL */

#include "disas.h"

#include "exec-all.h"

//#define DO_TB_FLUSH

#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"

//#define DEBUG_UNUSED_IOPORT

//#define DEBUG_IOPORT

#if !defined(CONFIG_SOFTMMU)

#define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)

#else

#define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)

#endif

#ifdef TARGET_PPC

#define DEFAULT_RAM_SIZE 144

#else

#define DEFAULT_RAM_SIZE 128

#endif

/* in ms */

#define GUI_REFRESH_INTERVAL 30

/* XXX: use a two level table to limit memory usage */

#define MAX_IOPORTS 65536

const char *bios_dir = CONFIG_QEMU_SHAREDIR;

char phys_ram_file[1024];

CPUState *global_env;

CPUState *cpu_single_env;

void *ioport_opaque[MAX_IOPORTS];

IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];

IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];

BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];

int vga_ram_size;

int bios_size;

static DisplayState display_state;

int nographic;

const char* keyboard_layout = NULL;

int64_t ticks_per_sec;

int boot_device = 'c';

int ram_size;

static char network_script[1024];

int pit_min_timer_count = 0;

int nb_nics;

NetDriverState nd_table[MAX_NICS];

QEMUTimer *gui_timer;

int vm_running;

int audio_enabled = 0;

int sb16_enabled = 1;

int adlib_enabled = 1;

int gus_enabled = 1;

int pci_enabled = 1;

int prep_enabled = 0;

int rtc_utc = 1;

int cirrus_vga_enabled = 1;

int graphic_width = 800;

int graphic_height = 600;

int graphic_depth = 15;

int full_screen = 0;

TextConsole *vga_console;

CharDriverState *serial_hds[MAX_SERIAL_PORTS];

/***********************************************************/

/* x86 ISA bus support */

target_phys_addr_t isa_mem_base = 0;

uint32_t default_ioport_readb(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "inb: port=0x%04x\n", address);

#endif

    return 0xff;

}

void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);

#endif

}

/* default is to make two byte accesses */

uint32_t default_ioport_readw(void *opaque, uint32_t address)

{

    uint32_t data;

    data = ioport_read_table[0][address](ioport_opaque[address], address);

    address = (address + 1) & (MAX_IOPORTS - 1);

    data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;

    return data;

}

void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)

{

    ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);

    address = (address + 1) & (MAX_IOPORTS - 1);

    ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);

}

uint32_t default_ioport_readl(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "inl: port=0x%04x\n", address);

#endif

    return 0xffffffff;

}

void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);

#endif

}

void init_ioports(void)

{

    int i;

    for(i = 0; i < MAX_IOPORTS; i++) {

        ioport_read_table[0][i] = default_ioport_readb;

        ioport_write_table[0][i] = default_ioport_writeb;

        ioport_read_table[1][i] = default_ioport_readw;

        ioport_write_table[1][i] = default_ioport_writew;

        ioport_read_table[2][i] = default_ioport_readl;

        ioport_write_table[2][i] = default_ioport_writel;

    }

}

/* size is the word size in byte */

int register_ioport_read(int start, int length, int size, 

                         IOPortReadFunc *func, void *opaque)

{

    int i, bsize;

    if (size == 1) {

        bsize = 0;

    } else if (size == 2) {

        bsize = 1;

    } else if (size == 4) {

        bsize = 2;

    } else {

        hw_error("register_ioport_read: invalid size");

        return -1;

    }

    for(i = start; i < start + length; i += size) {

        ioport_read_table[bsize][i] = func;

        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)

            hw_error("register_ioport_read: invalid opaque");

        ioport_opaque[i] = opaque;

    }

    return 0;

}

/* size is the word size in byte */

int register_ioport_write(int start, int length, int size, 

                          IOPortWriteFunc *func, void *opaque)

{

    int i, bsize;

    if (size == 1) {

        bsize = 0;

    } else if (size == 2) {

        bsize = 1;

    } else if (size == 4) {

        bsize = 2;

    } else {

        hw_error("register_ioport_write: invalid size");

        return -1;

    }

    for(i = start; i < start + length; i += size) {

        ioport_write_table[bsize][i] = func;

        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)

            hw_error("register_ioport_read: invalid opaque");

        ioport_opaque[i] = opaque;

    }

    return 0;

}

void isa_unassign_ioport(int start, int length)

{

    int i;

    for(i = start; i < start + length; i++) {

        ioport_read_table[0][i] = default_ioport_readb;

        ioport_read_table[1][i] = default_ioport_readw;

        ioport_read_table[2][i] = default_ioport_readl;

        ioport_write_table[0][i] = default_ioport_writeb;

        ioport_write_table[1][i] = default_ioport_writew;

        ioport_write_table[2][i] = default_ioport_writel;

    }

}

void pstrcpy(char *buf, int buf_size, const char *str)

{

    int c;

    char *q = buf;

    if (buf_size <= 0)

        return;

    for(;;) {

        c = *str++;

        if (c == 0 || q >= buf + buf_size - 1)

            break;

        *q++ = c;

    }

    *q = '\0';

}

/* strcat and truncate. */

char *pstrcat(char *buf, int buf_size, const char *s)

{

    int len;

    len = strlen(buf);

    if (len < buf_size) 

        pstrcpy(buf + len, buf_size - len, s);

    return buf;

}

int strstart(const char *str, const char *val, const char **ptr)

{

    const char *p, *q;

    p = str;

    q = val;

    while (*q != '\0') {

        if (*p != *q)

            return 0;

        p++;

        q++;

    }

    if (ptr)

        *ptr = p;

    return 1;

}

/* return the size or -1 if error */

int get_image_size(const char *filename)

{

    int fd, size;

    fd = open(filename, O_RDONLY | O_BINARY);

    if (fd < 0)

        return -1;

    size = lseek(fd, 0, SEEK_END);

    close(fd);

    return size;

}

/* return the size or -1 if error */

int load_image(const char *filename, uint8_t *addr)

{

    int fd, size;

    fd = open(filename, O_RDONLY | O_BINARY);

    if (fd < 0)

        return -1;

    size = lseek(fd, 0, SEEK_END);

    lseek(fd, 0, SEEK_SET);

    if (read(fd, addr, size) != size) {

        close(fd);

        return -1;

    }

    close(fd);

    return size;

}

void cpu_outb(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outb: %04x %02x\n", addr, val);

#endif    

    ioport_write_table[0][addr](ioport_opaque[addr], addr, val);

}

void cpu_outw(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outw: %04x %04x\n", addr, val);

#endif    

    ioport_write_table[1][addr](ioport_opaque[addr], addr, val);

}

void cpu_outl(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outl: %04x %08x\n", addr, val);

#endif

    ioport_write_table[2][addr](ioport_opaque[addr], addr, val);

}

int cpu_inb(CPUState *env, int addr)

{

    int val;

    val = ioport_read_table[0][addr](ioport_opaque[addr], addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inb : %04x %02x\n", addr, val);

#endif

    return val;

}

int cpu_inw(CPUState *env, int addr)

{

    int val;

    val = ioport_read_table[1][addr](ioport_opaque[addr], addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inw : %04x %04x\n", addr, val);

#endif

    return val;

}

int cpu_inl(CPUState *env, int addr)

{

    int val;

    val = ioport_read_table[2][addr](ioport_opaque[addr], addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inl : %04x %08x\n", addr, val);

#endif

    return val;

}

/***********************************************************/

void hw_error(const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    fprintf(stderr, "qemu: hardware error: ");

    vfprintf(stderr, fmt, ap);

    fprintf(stderr, "\n");

#ifdef TARGET_I386

    cpu_dump_state(global_env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);

#else

    cpu_dump_state(global_env, stderr, fprintf, 0);

#endif

    va_end(ap);

    abort();

}

/***********************************************************/

/* keyboard/mouse */

static QEMUPutKBDEvent *qemu_put_kbd_event;

static void *qemu_put_kbd_event_opaque;

static QEMUPutMouseEvent *qemu_put_mouse_event;

static void *qemu_put_mouse_event_opaque;

void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)

{

    qemu_put_kbd_event_opaque = opaque;

    qemu_put_kbd_event = func;

}

void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque)

{

    qemu_put_mouse_event_opaque = opaque;

    qemu_put_mouse_event = func;

}

void kbd_put_keycode(int keycode)

{

    if (qemu_put_kbd_event) {

        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);

    }

}

void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)

{

    if (qemu_put_mouse_event) {

        qemu_put_mouse_event(qemu_put_mouse_event_opaque, 

                             dx, dy, dz, buttons_state);

    }

}

/***********************************************************/

/* timers */

#if defined(__powerpc__)

static inline uint32_t get_tbl(void) 

{

    uint32_t tbl;

    asm volatile("mftb %0" : "=r" (tbl));

    return tbl;

}

static inline uint32_t get_tbu(void) 

{

        uint32_t tbl;

        asm volatile("mftbu %0" : "=r" (tbl));

        return tbl;

}

int64_t cpu_get_real_ticks(void)

{

    uint32_t l, h, h1;

    /* NOTE: we test if wrapping has occurred */

    do {

        h = get_tbu();

        l = get_tbl();

        h1 = get_tbu();

    } while (h != h1);

    return ((int64_t)h << 32) | l;

}

#elif defined(__i386__)

int64_t cpu_get_real_ticks(void)

{

    int64_t val;

    asm volatile ("rdtsc" : "=A" (val));

    return val;

}

#elif defined(__x86_64__)

int64_t cpu_get_real_ticks(void)

{

    uint32_t low,high;

    int64_t val;

    asm volatile("rdtsc" : "=a" (low), "=d" (high));

    val = high;

    val <<= 32;

    val |= low;

    return val;

}

#else

#error unsupported CPU

#endif

static int64_t cpu_ticks_offset;

static int cpu_ticks_enabled;

static inline int64_t cpu_get_ticks(void)

{

    if (!cpu_ticks_enabled) {

        return cpu_ticks_offset;

    } else {

        return cpu_get_real_ticks() + cpu_ticks_offset;

    }

}

/* enable cpu_get_ticks() */

void cpu_enable_ticks(void)

{

    if (!cpu_ticks_enabled) {

        cpu_ticks_offset -= cpu_get_real_ticks();

        cpu_ticks_enabled = 1;

    }

}

/* disable cpu_get_ticks() : the clock is stopped. You must not call

   cpu_get_ticks() after that.  */

void cpu_disable_ticks(void)

{

    if (cpu_ticks_enabled) {

        cpu_ticks_offset = cpu_get_ticks();

        cpu_ticks_enabled = 0;

    }

}

static int64_t get_clock(void)

{

#ifdef _WIN32

    struct _timeb tb;

    _ftime(&tb);

    return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;

#else

    struct timeval tv;

    gettimeofday(&tv, NULL);

    return tv.tv_sec * 1000000LL + tv.tv_usec;

#endif

}

void cpu_calibrate_ticks(void)

{

    int64_t usec, ticks;

    usec = get_clock();

    ticks = cpu_get_real_ticks();

#ifdef _WIN32

    Sleep(50);

#else

    usleep(50 * 1000);

#endif

    usec = get_clock() - usec;

    ticks = cpu_get_real_ticks() - ticks;

    ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;

}

/* compute with 96 bit intermediate result: (a*b)/c */

uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)

{

    union {

        uint64_t ll;

        struct {

#ifdef WORDS_BIGENDIAN

            uint32_t high, low;

#else

            uint32_t low, high;

#endif            

        } l;

    } u, res;

    uint64_t rl, rh;

    u.ll = a;

    rl = (uint64_t)u.l.low * (uint64_t)b;

    rh = (uint64_t)u.l.high * (uint64_t)b;

    rh += (rl >> 32);

    res.l.high = rh / c;

    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;

    return res.ll;

}

#define QEMU_TIMER_REALTIME 0

#define QEMU_TIMER_VIRTUAL  1

struct QEMUClock {

    int type;

    /* XXX: add frequency */

};

struct QEMUTimer {

    QEMUClock *clock;

    int64_t expire_time;

    QEMUTimerCB *cb;

    void *opaque;

    struct QEMUTimer *next;

};

QEMUClock *rt_clock;

QEMUClock *vm_clock;

static QEMUTimer *active_timers[2];

#ifdef _WIN32

static MMRESULT timerID;

#else

/* frequency of the times() clock tick */

static int timer_freq;

#endif

QEMUClock *qemu_new_clock(int type)

{

    QEMUClock *clock;

    clock = qemu_mallocz(sizeof(QEMUClock));

    if (!clock)

        return NULL;

    clock->type = type;

    return clock;

}

QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)

{

    QEMUTimer *ts;

    ts = qemu_mallocz(sizeof(QEMUTimer));

    ts->clock = clock;

    ts->cb = cb;

    ts->opaque = opaque;

    return ts;

}

void qemu_free_timer(QEMUTimer *ts)

{

    qemu_free(ts);

}

/* stop a timer, but do not dealloc it */

void qemu_del_timer(QEMUTimer *ts)

{

    QEMUTimer **pt, *t;

    /* NOTE: this code must be signal safe because

       qemu_timer_expired() can be called from a signal. */

    pt = &active_timers[ts->clock->type];

    for(;;) {

        t = *pt;

        if (!t)

            break;

        if (t == ts) {

            *pt = t->next;

            break;

        }

        pt = &t->next;

    }

}

/* modify the current timer so that it will be fired when current_time

   >= expire_time. The corresponding callback will be called. */

void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)

{

    QEMUTimer **pt, *t;

    qemu_del_timer(ts);

    /* add the timer in the sorted list */

    /* NOTE: this code must be signal safe because

       qemu_timer_expired() can be called from a signal. */

    pt = &active_timers[ts->clock->type];

    for(;;) {

        t = *pt;

        if (!t)

            break;

        if (t->expire_time > expire_time) 

            break;

        pt = &t->next;

    }

    ts->expire_time = expire_time;

    ts->next = *pt;

    *pt = ts;

}

int qemu_timer_pending(QEMUTimer *ts)

{

    QEMUTimer *t;

    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {

        if (t == ts)

            return 1;

    }

    return 0;

}

static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)

{

    if (!timer_head)

        return 0;

    return (timer_head->expire_time <= current_time);

}

static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)

{

    QEMUTimer *ts;

    for(;;) {

        ts = *ptimer_head;

        if (!ts || ts->expire_time > current_time)

            break;

        /* remove timer from the list before calling the callback */

        *ptimer_head = ts->next;

        ts->next = NULL;

        /* run the callback (the timer list can be modified) */

        ts->cb(ts->opaque);

    }

}

int64_t qemu_get_clock(QEMUClock *clock)

{

    switch(clock->type) {

    case QEMU_TIMER_REALTIME:

#ifdef _WIN32

        return GetTickCount();

#else

        {

            struct tms tp;

            /* Note that using gettimeofday() is not a good solution

               for timers because its value change when the date is

               modified. */

            if (timer_freq == 100) {

                return times(&tp) * 10;

            } else {

                return ((int64_t)times(&tp) * 1000) / timer_freq;

            }

        }

#endif

    default:

    case QEMU_TIMER_VIRTUAL:

        return cpu_get_ticks();

    }

}

/* save a timer */

void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)

{

    uint64_t expire_time;

    if (qemu_timer_pending(ts)) {

        expire_time = ts->expire_time;

    } else {

        expire_time = -1;

    }

    qemu_put_be64(f, expire_time);

}

void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)

{

    uint64_t expire_time;

    expire_time = qemu_get_be64(f);

    if (expire_time != -1) {

        qemu_mod_timer(ts, expire_time);

    } else {

        qemu_del_timer(ts);

    }

}

static void timer_save(QEMUFile *f, void *opaque)

{

    if (cpu_ticks_enabled) {

        hw_error("cannot save state if virtual timers are running");

    }

    qemu_put_be64s(f, &cpu_ticks_offset);

    qemu_put_be64s(f, &ticks_per_sec);

}

static int timer_load(QEMUFile *f, void *opaque, int version_id)

{

    if (version_id != 1)

        return -EINVAL;

    if (cpu_ticks_enabled) {

        return -EINVAL;

    }

    qemu_get_be64s(f, &cpu_ticks_offset);

    qemu_get_be64s(f, &ticks_per_sec);

    return 0;

}

#ifdef _WIN32

void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg, 

                                 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)

#else

static void host_alarm_handler(int host_signum)

#endif

{

#if 0

#define DISP_FREQ 1000

    {

        static int64_t delta_min = INT64_MAX;

        static int64_t delta_max, delta_cum, last_clock, delta, ti;

        static int count;

        ti = qemu_get_clock(vm_clock);

        if (last_clock != 0) {

            delta = ti - last_clock;

            if (delta < delta_min)

                delta_min = delta;

            if (delta > delta_max)

                delta_max = delta;

            delta_cum += delta;

            if (++count == DISP_FREQ) {

                printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",

                       muldiv64(delta_min, 1000000, ticks_per_sec),

                       muldiv64(delta_max, 1000000, ticks_per_sec),

                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),

                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));

                count = 0;

                delta_min = INT64_MAX;

                delta_max = 0;

                delta_cum = 0;

            }

        }

        last_clock = ti;

    }

#endif

    if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],

                           qemu_get_clock(vm_clock)) ||

        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],

                           qemu_get_clock(rt_clock))) {

        /* stop the cpu because a timer occured */

        cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);

    }

}

#ifndef _WIN32

#if defined(__linux__)

#define RTC_FREQ 1024

static int rtc_fd;

static int start_rtc_timer(void)

{

    rtc_fd = open("/dev/rtc", O_RDONLY);

    if (rtc_fd < 0)

        return -1;

    if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {

        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"

                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"

                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");

        goto fail;

    }

    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {

    fail:

        close(rtc_fd);

        return -1;

    }

    pit_min_timer_count = PIT_FREQ / RTC_FREQ;

    return 0;

}

#else

static int start_rtc_timer(void)

{

    return -1;

}

#endif /* !defined(__linux__) */

#endif /* !defined(_WIN32) */

static void init_timers(void)