* See the COPYING file in the top-level directory.
*
*/
-#include "libqtest.h"
-#include <glib.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include "qemu/osdep.h"
+
+#include "libqtest.h"
#define RTC_SECONDS 0x9
#define RTC_MINUTES 0xa
static uint32_t base;
static uint16_t reg_base = 0x1ff0; /* 0x7f0 for m48t02 */
static int base_year;
+static const char *base_machine;
static bool use_mmio;
-static uint8_t cmos_read_mmio(uint8_t reg)
+static uint8_t cmos_read_mmio(QTestState *s, uint8_t reg)
{
- uint8_t data;
-
- memread(base + (uint32_t)reg_base + (uint32_t)reg, &data, 1);
- return data;
+ return qtest_readb(s, base + (uint32_t)reg_base + (uint32_t)reg);
}
-static void cmos_write_mmio(uint8_t reg, uint8_t val)
+static void cmos_write_mmio(QTestState *s, uint8_t reg, uint8_t val)
{
uint8_t data = val;
- memwrite(base + (uint32_t)reg_base + (uint32_t)reg, &data, 1);
+ qtest_writeb(s, base + (uint32_t)reg_base + (uint32_t)reg, data);
}
-static uint8_t cmos_read_ioio(uint8_t reg)
+static uint8_t cmos_read_ioio(QTestState *s, uint8_t reg)
{
- outw(base + 0, reg_base + (uint16_t)reg);
- return inb(base + 3);
+ qtest_outw(s, base + 0, reg_base + (uint16_t)reg);
+ return qtest_inb(s, base + 3);
}
-static void cmos_write_ioio(uint8_t reg, uint8_t val)
+static void cmos_write_ioio(QTestState *s, uint8_t reg, uint8_t val)
{
- outw(base + 0, reg_base + (uint16_t)reg);
- outb(base + 3, val);
+ qtest_outw(s, base + 0, reg_base + (uint16_t)reg);
+ qtest_outb(s, base + 3, val);
}
-static uint8_t cmos_read(uint8_t reg)
+static uint8_t cmos_read(QTestState *s, uint8_t reg)
{
if (use_mmio) {
- return cmos_read_mmio(reg);
+ return cmos_read_mmio(s, reg);
} else {
- return cmos_read_ioio(reg);
+ return cmos_read_ioio(s, reg);
}
}
-static void cmos_write(uint8_t reg, uint8_t val)
+static void cmos_write(QTestState *s, uint8_t reg, uint8_t val)
{
if (use_mmio) {
- cmos_write_mmio(reg, val);
+ cmos_write_mmio(s, reg, val);
} else {
- cmos_write_ioio(reg, val);
+ cmos_write_ioio(s, reg, val);
}
}
}
#endif
-static void cmos_get_date_time(struct tm *date)
+static void cmos_get_date_time(QTestState *s, struct tm *date)
{
int sec, min, hour, mday, mon, year;
time_t ts;
struct tm dummy;
- sec = cmos_read(RTC_SECONDS);
- min = cmos_read(RTC_MINUTES);
- hour = cmos_read(RTC_HOURS);
- mday = cmos_read(RTC_DAY_OF_MONTH);
- mon = cmos_read(RTC_MONTH);
- year = cmos_read(RTC_YEAR);
+ sec = cmos_read(s, RTC_SECONDS);
+ min = cmos_read(s, RTC_MINUTES);
+ hour = cmos_read(s, RTC_HOURS);
+ mday = cmos_read(s, RTC_DAY_OF_MONTH);
+ mon = cmos_read(s, RTC_MONTH);
+ year = cmos_read(s, RTC_YEAR);
sec = bcd2dec(sec);
min = bcd2dec(min);
date->tm_mday = mday;
date->tm_mon = mon - 1;
date->tm_year = base_year + year - 1900;
+#ifndef __sun__
date->tm_gmtoff = 0;
+#endif
ts = mktime(date);
}
-static void check_time(int wiggle)
+static QTestState *m48t59_qtest_start(void)
+{
+ return qtest_initf("-M %s -rtc clock=vm", base_machine);
+}
+
+static void bcd_check_time(void)
{
struct tm start, date[4], end;
struct tm *datep;
time_t ts;
+ const int wiggle = 2;
+ QTestState *s = m48t59_qtest_start();
/*
* This check assumes a few things. First, we cannot guarantee that we get
ts = time(NULL);
gmtime_r(&ts, &start);
- cmos_get_date_time(&date[0]);
- cmos_get_date_time(&date[1]);
- cmos_get_date_time(&date[2]);
- cmos_get_date_time(&date[3]);
+ cmos_get_date_time(s, &date[0]);
+ cmos_get_date_time(s, &date[1]);
+ cmos_get_date_time(s, &date[2]);
+ cmos_get_date_time(s, &date[3]);
ts = time(NULL);
gmtime_r(&ts, &end);
t = (long)mktime(datep);
s = (long)mktime(&start);
if (t < s) {
- g_test_message("RTC is %ld second(s) behind wall-clock\n", (s - t));
+ g_test_message("RTC is %ld second(s) behind wall-clock", (s - t));
} else {
- g_test_message("RTC is %ld second(s) ahead of wall-clock\n", (t - s));
+ g_test_message("RTC is %ld second(s) ahead of wall-clock", (t - s));
}
g_assert_cmpint(ABS(t - s), <=, wiggle);
}
-}
-
-static int wiggle = 2;
-static void bcd_check_time(void)
-{
- if (strcmp(qtest_get_arch(), "sparc64") == 0) {
- base = 0x74;
- base_year = 1900;
- use_mmio = false;
- } else if (strcmp(qtest_get_arch(), "sparc") == 0) {
- base = 0x71200000;
- base_year = 1968;
- use_mmio = true;
- } else { /* PPC: need to map macio in PCI */
- g_assert_not_reached();
- }
- check_time(wiggle);
+ qtest_quit(s);
}
/* success if no crash or abort */
static void fuzz_registers(void)
{
unsigned int i;
+ QTestState *s = m48t59_qtest_start();
for (i = 0; i < 1000; i++) {
uint8_t reg, val;
continue;
}
- cmos_write(reg, val);
- cmos_read(reg);
+ cmos_write(s, reg, val);
+ cmos_read(s, reg);
}
+
+ qtest_quit(s);
}
-int main(int argc, char **argv)
+static void base_setup(void)
{
- QTestState *s = NULL;
- int ret;
+ const char *arch = qtest_get_arch();
- g_test_init(&argc, &argv, NULL);
+ if (g_str_equal(arch, "sparc")) {
+ /* Note: For sparc64, we'd need to map-in the PCI bridge memory first */
+ base = 0x71200000;
+ base_year = 1968;
+ base_machine = "SS-5";
+ use_mmio = true;
+ } else if (g_str_equal(arch, "ppc") || g_str_equal(arch, "ppc64")) {
+ base = 0xF0000000;
+ base_year = 1968;
+ base_machine = "ref405ep";
+ use_mmio = true;
+ } else {
+ g_assert_not_reached();
+ }
+}
- s = qtest_start("-display none -rtc clock=vm");
+int main(int argc, char **argv)
+{
+ base_setup();
- qtest_add_func("/rtc/bcd/check-time", bcd_check_time);
- qtest_add_func("/rtc/fuzz-registers", fuzz_registers);
- ret = g_test_run();
+ g_test_init(&argc, &argv, NULL);
- if (s) {
- qtest_quit(s);
+ if (g_test_slow()) {
+ /* Do not run this in timing-sensitive environments */
+ qtest_add_func("/rtc/bcd-check-time", bcd_check_time);
}
-
- return ret;
+ qtest_add_func("/rtc/fuzz-registers", fuzz_registers);
+ return g_test_run();
}
projects / mirror_qemu.git / blobdiff