Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20190426' into staging

[qemu.git] / tests / m48t59-test.c

diff --git a/tests/m48t59-test.c b/tests/m48t59-test.c
index 6abc4c8bf0e4607accc58c23ec6d2c35ea19e477..b94a1230f7fdf742102597f402e2ea894689320b 100644 (file)
--- a/tests/m48t59-test.c
+++ b/tests/m48t59-test.c
@@ -11,13 +11,10 @@
  * See the COPYING file in the top-level directory.
  *
  */
  * 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
 
 #define RTC_SECONDS             0x9
 #define RTC_MINUTES             0xa


@@ -31,47 +28,48 @@
 static uint32_t base;
 static uint16_t reg_base = 0x1ff0; /* 0x7f0 for m48t02 */
 static int base_year;
 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 bool use_mmio;
 

-static uint8_t cmos_read_mmio(uint8_t reg)
+static uint8_t cmos_read_mmio(QTestState *s, uint8_t reg)

 {
 {

-    return readb(base + (uint32_t)reg_base + (uint32_t)reg);
+    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;
 
 {
     uint8_t data = val;
 

-    writeb(base + (uint32_t)reg_base + (uint32_t)reg, data);
+    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) {
 {
     if (use_mmio) {

-        return cmos_read_mmio(reg);
+        return cmos_read_mmio(s, reg);

     } else {
     } 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) {
 {
     if (use_mmio) {

-        cmos_write_mmio(reg, val);
+        cmos_write_mmio(s, reg, val);

     } else {
     } else {

-        cmos_write_ioio(reg, val);
+        cmos_write_ioio(s, reg, val);

     }
 }
 
     }
 }
 


@@ -109,18 +107,18 @@ static void print_tm(struct tm *tm)
 }
 #endif
 
 }
 #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;
 
 {
     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);
 
     sec = bcd2dec(sec);
     min = bcd2dec(min);


@@ -146,11 +144,18 @@ static void cmos_get_date_time(struct tm *date)
     ts = mktime(date);
 }
 
     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;
 {
     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
 
     /*
      * This check assumes a few things.  First, we cannot guarantee that we get


@@ -168,10 +173,10 @@ static void check_time(int wiggle)
     ts = time(NULL);
     gmtime_r(&ts, &start);
 
     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);
 
     ts = time(NULL);
     gmtime_r(&ts, &end);


@@ -194,37 +199,22 @@ static void check_time(int wiggle)
         t = (long)mktime(datep);
         s = (long)mktime(&start);
         if (t < s) {
         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 {
         } 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);
     }
         }
 
         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;
 }
 
 /* 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;
 
     for (i = 0; i < 1000; i++) {
         uint8_t reg, val;


@@ -237,27 +227,43 @@ static void fuzz_registers(void)
             continue;
         }
 
             continue;
         }
 

-        cmos_write(reg, val);
-        cmos_read(reg);
+        cmos_write(s, reg, val);
+        cmos_read(s, reg);
+    }
+
+    qtest_quit(s);
+}
+
+static void base_setup(void)
+{
+    const char *arch = qtest_get_arch();
+
+    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();

     }
 }
 
 int main(int argc, char **argv)
 {
     }
 }
 
 int main(int argc, char **argv)
 {

-    QTestState *s = NULL;
-    int ret;
+    base_setup();

 
     g_test_init(&argc, &argv, NULL);
 
 
     g_test_init(&argc, &argv, NULL);
 

-    s = qtest_start("-rtc clock=vm");
-
-    qtest_add_func("/rtc/bcd/check-time", bcd_check_time);
-    qtest_add_func("/rtc/fuzz-registers", fuzz_registers);
-    ret = g_test_run();
-
-    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();

 }
 }