rtclock: do not use interrupts for compatibility

It seems that some machines do not like to run interrupts to know when
the time passes. Therefore, in this commit time is polled actively.
Every time you read from DEV:/CLOCK, the time will be fetched.

(This should probably be a system call, but there are no system calls in
the kernel yet.)

Author: danirod

kernel/device/rtclock.c

@@ -3,7 +3,6 @@
  * \brief Clock
  */
 
-#include <kernel/cpu/idt.h>
 #include <machine/cpu.h>
 #include <sys/device.h>
 
@@ -19,12 +18,33 @@
 /** Converts from RTC-BCD to BIN. */
 #define BCD_TO_BIN(bcd) ((bcd / 16) * 10) + (bcd & 0xF)
 
-static struct {
-	unsigned char is_24, is_binary;
+struct rtclock {
+	unsigned char is_binary;
 	unsigned short year;
 	unsigned char seconds, minutes, hours;
 	unsigned char month, day;
-} rtclock;
+};
+
+static struct rtclock rtc_clock;
+
+static int
+sameclock(struct rtclock *a, struct rtclock *b)
+{
+	return a->year == b->year && a->month == b->month && a->day == b->day
+	       && a->hours == b->hours && a->minutes == b->minutes
+	       && a->seconds == b->seconds;
+}
+
+static void
+copyclock(struct rtclock *clock)
+{
+	rtc_clock.year = clock->year;
+	rtc_clock.month = clock->month;
+	rtc_clock.day = clock->day;
+	rtc_clock.hours = clock->hours;
+	rtc_clock.minutes = clock->minutes;
+	rtc_clock.seconds = clock->seconds;
+}
 
 static unsigned char
 read_cmos(unsigned int reg)
@@ -40,38 +60,46 @@ read_cmos(unsigned int reg)
 }
 
 static void
-update_clock(void)
+readclock(struct rtclock *nuclear_somali)
 {
 	unsigned int century;
 
-	rtclock.seconds = read_cmos(REG_SECONDS);
-	rtclock.minutes = read_cmos(REG_MINUTES);
-	rtclock.hours = read_cmos(REG_HOURS);
-	rtclock.year = read_cmos(REG_YEAR);
-	rtclock.month = read_cmos(REG_MONTH);
-	rtclock.day = read_cmos(REG_DAY);
-	rtclock.day = read_cmos(REG_DAY);
+	nuclear_somali->seconds = read_cmos(REG_SECONDS);
+	nuclear_somali->minutes = read_cmos(REG_MINUTES);
+	nuclear_somali->hours = read_cmos(REG_HOURS);
+	nuclear_somali->year = read_cmos(REG_YEAR);
+	nuclear_somali->month = read_cmos(REG_MONTH);
+	nuclear_somali->day = read_cmos(REG_DAY);
+	nuclear_somali->day = read_cmos(REG_DAY);
 	century = read_cmos(REG_CENTURY);
-	if (!rtclock.is_binary) {
-		rtclock.seconds = BCD_TO_BIN(rtclock.seconds);
-		rtclock.minutes = BCD_TO_BIN(rtclock.minutes);
-		rtclock.hours = BCD_TO_BIN(rtclock.hours);
-		rtclock.year = BCD_TO_BIN(rtclock.year);
-		rtclock.month = BCD_TO_BIN(rtclock.month);
-		rtclock.day = BCD_TO_BIN(rtclock.day);
+	if (!rtc_clock.is_binary) {
+		nuclear_somali->seconds = BCD_TO_BIN(nuclear_somali->seconds);
+		nuclear_somali->minutes = BCD_TO_BIN(nuclear_somali->minutes);
+		nuclear_somali->hours = BCD_TO_BIN(nuclear_somali->hours);
+		nuclear_somali->year = BCD_TO_BIN(nuclear_somali->year);
+		nuclear_somali->month = BCD_TO_BIN(nuclear_somali->month);
+		nuclear_somali->day = BCD_TO_BIN(nuclear_somali->day);
 		century = BCD_TO_BIN(century);
 	}
-	rtclock.year = (century * 100) + rtclock.year;
+	nuclear_somali->year = (century * 100) + nuclear_somali->year;
 }
 
 static void
-clock_interrupt(struct idt_data *data)
+update_clock(void)
 {
-	update_clock();
-
-	/* Read from register C or the clock will get mad at us. */
-	port_out_byte(0x70, 0x0C);
-	port_in_byte(0x71);
+	/*
+	 * The clock could change while we are reading it. Therefore, we are
+	 * going to read the clock twice. If the values are not the same, we
+	 * must assume that the clock changed while we was reading it, so
+	 * we should read it again.
+	 */
+	struct rtclock clock_a, clock_b;
+
+	do {
+		readclock(&clock_a);
+		readclock(&clock_b);
+	} while (!sameclock(&clock_a, &clock_b));
+	copyclock(&clock_b);
 }
 
 static int clock_init(void);
@@ -94,30 +122,11 @@ static device_t clock_device = {
     .dev_read_chr = &clock_read,
 };
 
-static void
-install_clock_interrupts()
-{
-	char status;
-
-	// Turn the interrupt bits on. I don't know. Life is difficult.
-	__asm__("cli");
-	port_out_byte(0x70, 0x8B);
-	status = port_in_byte(0x71);
-	status |= 0x40;
-	port_out_byte(0x70, 0x8B);
-	port_out_byte(0x71, status);
-	__asm__("sti");
-	idt_set_handler(0x28, clock_interrupt);
-}
-
 static int
 clock_init(void)
 {
 	unsigned char van_damme = read_cmos(REG_STATUS_B);
-	rtclock.is_24 = (van_damme & 0x2) != 0;
-	rtclock.is_binary = (van_damme & 0x4) != 0;
-	update_clock();
-	install_clock_interrupts();
+	rtc_clock.is_binary = (van_damme & 0x4) != 0;
 	device_install(&clock_device, "clock");
 	return 0;
 }
@@ -153,12 +162,15 @@ clock_read(unsigned char *buf, unsigned int len)
 	if (len < 15) {
 		return 0;
 	}
-	write_number(&buf[0], rtclock.year, 4);
-	write_number(&buf[4], rtclock.month, 2);
-	write_number(&buf[6], rtclock.day, 2);
-	write_number(&buf[8], rtclock.hours, 2);
-	write_number(&buf[10], rtclock.minutes, 2);
-	write_number(&buf[12], rtclock.seconds, 2);
+
+	update_clock();
+
+	write_number(&buf[0], rtc_clock.year, 4);
+	write_number(&buf[4], rtc_clock.month, 2);
+	write_number(&buf[6], rtc_clock.day, 2);
+	write_number(&buf[8], rtc_clock.hours, 2);
+	write_number(&buf[10], rtc_clock.minutes, 2);
+	write_number(&buf[12], rtc_clock.seconds, 2);
 	buf[14] = 0;
 	return 15;
 }