src/clock.c

   1 // 16bit code to handle system clocks.
   2 //
   3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2002  MandrakeSoft S.A.
   5 //
   6 // This file may be distributed under the terms of the GNU GPLv3 license.
   7
   8 #include "biosvar.h" // struct bregs
   9 #include "util.h" // debug_enter
  10 #include "disk.h" // floppy_tick
  11 #include "cmos.h" // inb_cmos
  12
  13 #define DEBUGF1(fmt, args...) bprintf(0, fmt , ##args)
  14 #define DEBUGF(fmt, args...)
  15
  16 static void
  17 init_rtc()
  18 {
  19     outb_cmos(0x26, CMOS_STATUS_A);
  20     outb_cmos(0x02, CMOS_STATUS_B);
  21     inb_cmos(CMOS_STATUS_C);
  22     inb_cmos(CMOS_STATUS_D);
  23 }
  24
  25 static u8
  26 rtc_updating()
  27 {
  28     // This function checks to see if the update-in-progress bit
  29     // is set in CMOS Status Register A.  If not, it returns 0.
  30     // If it is set, it tries to wait until there is a transition
  31     // to 0, and will return 0 if such a transition occurs.  A 1
  32     // is returned only after timing out.  The maximum period
  33     // that this bit should be set is constrained to 244useconds.
  34     // The count I use below guarantees coverage or more than
  35     // this time, with any reasonable IPS setting.
  36
  37     u16 count = 25000;
  38     while (--count != 0) {
  39         if ( (inb_cmos(CMOS_STATUS_A) & 0x80) == 0 )
  40             return 0;
  41     }
  42     return 1; // update-in-progress never transitioned to 0
  43 }
  44
  45 // get current clock count
  46 static void
  47 handle_1a00(struct bregs *regs)
  48 {
  49     u32 ticks = GET_BDA(timer_counter);
  50     regs->cx = ticks >> 16;
  51     regs->dx = ticks;
  52     regs->al = GET_BDA(timer_rollover);
  53     SET_BDA(timer_rollover, 0); // reset flag
  54     set_success(regs);
  55 }
  56
  57 // Set Current Clock Count
  58 static void
  59 handle_1a01(struct bregs *regs)
  60 {
  61     u32 ticks = (regs->cx << 16) | regs->dx;
  62     SET_BDA(timer_counter, ticks);
  63     SET_BDA(timer_rollover, 0); // reset flag
  64     regs->ah = 0;
  65     set_success(regs);
  66 }
  67
  68 // Read CMOS Time
  69 static void
  70 handle_1a02(struct bregs *regs)
  71 {
  72     if (rtc_updating()) {
  73         set_fail(regs);
  74         return;
  75     }
  76
  77     regs->dh = inb_cmos(CMOS_RTC_SECONDS);
  78     regs->cl = inb_cmos(CMOS_RTC_MINUTES);
  79     regs->ch = inb_cmos(CMOS_RTC_HOURS);
  80     regs->dl = inb_cmos(CMOS_STATUS_B) & 0x01;
  81     regs->ah = 0;
  82     regs->al = regs->ch;
  83     set_success(regs);
  84 }
  85
  86 // Set CMOS Time
  87 static void
  88 handle_1a03(struct bregs *regs)
  89 {
  90     // Using a debugger, I notice the following masking/setting
  91     // of bits in Status Register B, by setting Reg B to
  92     // a few values and getting its value after INT 1A was called.
  93     //
  94     //        try#1       try#2       try#3
  95     // before 1111 1101   0111 1101   0000 0000
  96     // after  0110 0010   0110 0010   0000 0010
  97     //
  98     // Bit4 in try#1 flipped in hardware (forced low) due to bit7=1
  99     // My assumption: RegB = ((RegB & 01100000b) | 00000010b)
 100     if (rtc_updating()) {
 101         init_rtc();
 102         // fall through as if an update were not in progress
 103     }
 104     outb_cmos(regs->dh, CMOS_RTC_SECONDS);
 105     outb_cmos(regs->cl, CMOS_RTC_MINUTES);
 106     outb_cmos(regs->ch, CMOS_RTC_HOURS);
 107     // Set Daylight Savings time enabled bit to requested value
 108     u8 val8 = (inb_cmos(CMOS_STATUS_B) & 0x60) | 0x02 | (regs->dl & 0x01);
 109     outb_cmos(val8, CMOS_STATUS_B);
 110     regs->ah = 0;
 111     regs->al = val8; // val last written to Reg B
 112     set_success(regs);
 113 }
 114
 115 // Read CMOS Date
 116 static void
 117 handle_1a04(struct bregs *regs)
 118 {
 119     regs->ah = 0;
 120     if (rtc_updating()) {
 121         set_fail(regs);
 122         return;
 123     }
 124     regs->cl = inb_cmos(CMOS_RTC_YEAR);
 125     regs->dh = inb_cmos(CMOS_RTC_MONTH);
 126     regs->dl = inb_cmos(CMOS_RTC_DAY_MONTH);
 127     regs->ch = inb_cmos(CMOS_CENTURY);
 128     regs->al = regs->ch;
 129     set_success(regs);
 130 }
 131
 132 // Set CMOS Date
 133 static void
 134 handle_1a05(struct bregs *regs)
 135 {
 136     // Using a debugger, I notice the following masking/setting
 137     // of bits in Status Register B, by setting Reg B to
 138     // a few values and getting its value after INT 1A was called.
 139     //
 140     //        try#1       try#2       try#3       try#4
 141     // before 1111 1101   0111 1101   0000 0010   0000 0000
 142     // after  0110 1101   0111 1101   0000 0010   0000 0000
 143     //
 144     // Bit4 in try#1 flipped in hardware (forced low) due to bit7=1
 145     // My assumption: RegB = (RegB & 01111111b)
 146     if (rtc_updating()) {
 147         init_rtc();
 148         set_fail(regs);
 149         return;
 150     }
 151     outb_cmos(regs->cl, CMOS_RTC_YEAR);
 152     outb_cmos(regs->dh, CMOS_RTC_MONTH);
 153     outb_cmos(regs->dl, CMOS_RTC_DAY_MONTH);
 154     outb_cmos(regs->ch, CMOS_CENTURY);
 155     u8 val8 = inb_cmos(CMOS_STATUS_B) & 0x7f; // clear halt-clock bit
 156     outb_cmos(val8, CMOS_STATUS_B);
 157     regs->ah = 0;
 158     regs->al = val8; // AL = val last written to Reg B
 159     set_success(regs);
 160 }
 161
 162 // Set Alarm Time in CMOS
 163 static void
 164 handle_1a06(struct bregs *regs)
 165 {
 166     // Using a debugger, I notice the following masking/setting
 167     // of bits in Status Register B, by setting Reg B to
 168     // a few values and getting its value after INT 1A was called.
 169     //
 170     //        try#1       try#2       try#3
 171     // before 1101 1111   0101 1111   0000 0000
 172     // after  0110 1111   0111 1111   0010 0000
 173     //
 174     // Bit4 in try#1 flipped in hardware (forced low) due to bit7=1
 175     // My assumption: RegB = ((RegB & 01111111b) | 00100000b)
 176     u8 val8 = inb_cmos(CMOS_STATUS_B); // Get Status Reg B
 177     regs->ax = 0;
 178     if (val8 & 0x20) {
 179         // Alarm interrupt enabled already
 180         set_fail(regs);
 181         return;
 182     }
 183     if (rtc_updating()) {
 184         init_rtc();
 185         // fall through as if an update were not in progress
 186     }
 187     outb_cmos(regs->dh, CMOS_RTC_SECONDS_ALARM);
 188     outb_cmos(regs->cl, CMOS_RTC_MINUTES_ALARM);
 189     outb_cmos(regs->ch, CMOS_RTC_HOURS_ALARM);
 190     outb(inb(PORT_PIC2_DATA) & ~PIC2_IRQ8, PORT_PIC2_DATA); // enable IRQ 8
 191     // enable Status Reg B alarm bit, clear halt clock bit
 192     outb_cmos((val8 & 0x7f) | 0x20, CMOS_STATUS_B);
 193     set_success(regs);
 194 }
 195
 196 // Turn off Alarm
 197 static void
 198 handle_1a07(struct bregs *regs)
 199 {
 200     // Using a debugger, I notice the following masking/setting
 201     // of bits in Status Register B, by setting Reg B to
 202     // a few values and getting its value after INT 1A was called.
 203     //
 204     //        try#1       try#2       try#3       try#4
 205     // before 1111 1101   0111 1101   0010 0000   0010 0010
 206     // after  0100 0101   0101 0101   0000 0000   0000 0010
 207     //
 208     // Bit4 in try#1 flipped in hardware (forced low) due to bit7=1
 209     // My assumption: RegB = (RegB & 01010111b)
 210     u8 val8 = inb_cmos(CMOS_STATUS_B); // Get Status Reg B
 211     // clear clock-halt bit, disable alarm bit
 212     outb_cmos(val8 & 0x57, CMOS_STATUS_B); // disable alarm bit
 213     regs->ah = 0;
 214     regs->al = val8; // val last written to Reg B
 215     set_success(regs);
 216 }
 217
 218 // Unsupported
 219 static void
 220 handle_1aXX(struct bregs *regs)
 221 {
 222     set_fail(regs);
 223 }
 224
 225 // INT 1Ah Time-of-day Service Entry Point
 226 void VISIBLE16
 227 handle_1a(struct bregs *regs)
 228 {
 229     //debug_enter(regs);
 230     switch (regs->ah) {
 231     case 0x00: handle_1a00(regs); break;
 232     case 0x01: handle_1a01(regs); break;
 233     case 0x02: handle_1a02(regs); break;
 234     case 0x03: handle_1a03(regs); break;
 235     case 0x04: handle_1a04(regs); break;
 236     case 0x05: handle_1a05(regs); break;
 237     case 0x06: handle_1a06(regs); break;
 238     case 0x07: handle_1a07(regs); break;
 239     case 0xb1: handle_1ab1(regs); break;
 240     default:   handle_1aXX(regs); break;
 241     }
 242 }
 243
 244 // User Timer Tick
 245 void VISIBLE16
 246 handle_1c()
 247 {
 248     //debug_enter(regs);
 249 }
 250
 251 // INT 08h System Timer ISR Entry Point
 252 void VISIBLE16
 253 handle_08()
 254 {
 255     //debug_isr();
 256     irq_enable();
 257
 258     floppy_tick();
 259
 260     u32 counter = GET_BDA(timer_counter);
 261     counter++;
 262     // compare to one days worth of timer ticks at 18.2 hz
 263     if (counter >= 0x001800B0) {
 264         // there has been a midnight rollover at this point
 265         counter = 0;
 266         SET_BDA(timer_rollover, GET_BDA(timer_rollover) + 1);
 267     }
 268
 269     SET_BDA(timer_counter, counter);
 270
 271     // chain to user timer tick INT #0x1c
 272     struct bregs br;
 273     memset(&br, 0, sizeof(br));
 274     call16_int(0x1c, &br);
 275
 276     irq_disable();
 277
 278     eoi_master_pic();
 279 }
 280
 281 // Set Interval requested.
 282 static void
 283 handle_158300(struct bregs *regs)
 284 {
 285     if (GET_BDA(rtc_wait_flag) & RWS_WAIT_PENDING) {
 286         // Interval already set.
 287         DEBUGF("int15: Func 83h, failed, already waiting.\n" );
 288         set_code_fail(regs, RET_EUNSUPPORTED);
 289     }
 290     // Interval not already set.
 291     SET_BDA(rtc_wait_flag, RWS_WAIT_PENDING);  // Set status byte.
 292     u32 v = (regs->es << 16) | regs->bx;
 293     SET_BDA(ptr_user_wait_complete_flag, v);
 294     v = (regs->dx << 16) | regs->cx;
 295     SET_BDA(user_wait_timeout, v);
 296
 297     // Unmask IRQ8 so INT70 will get through.
 298     u8 irqDisable = inb(PORT_PIC2_DATA);
 299     outb(irqDisable & ~PIC2_IRQ8, PORT_PIC2_DATA);
 300     // Turn on the Periodic Interrupt timer
 301     u8 bRegister = inb_cmos(CMOS_STATUS_B);
 302     outb_cmos(CMOS_STATUS_B, bRegister | CSB_EN_ALARM_IRQ);
 303
 304     set_success(regs); // XXX - no set ah?
 305 }
 306
 307 // Clear interval requested
 308 static void
 309 handle_158301(struct bregs *regs)
 310 {
 311     SET_BDA(rtc_wait_flag, 0); // Clear status byte
 312     // Turn off the Periodic Interrupt timer
 313     u8 bRegister = inb_cmos(CMOS_STATUS_B);
 314     outb_cmos(CMOS_STATUS_B, bRegister & ~CSB_EN_ALARM_IRQ);
 315     set_success(regs); // XXX - no set ah?
 316 }
 317
 318 static void
 319 handle_1583XX(struct bregs *regs)
 320 {
 321     set_code_fail(regs, RET_EUNSUPPORTED);
 322     regs->al--;
 323 }
 324
 325 void
 326 handle_1583(struct bregs *regs)
 327 {
 328     switch (regs->al) {
 329     case 0x00: handle_158300(regs); break;
 330     case 0x01: handle_158301(regs); break;
 331     default:   handle_1583XX(regs); break;
 332     }
 333 }
 334
 335 // int70h: IRQ8 - CMOS RTC
 336 void VISIBLE16
 337 handle_70()
 338 {
 339     debug_isr();
 340
 341     // Check which modes are enabled and have occurred.
 342     u8 registerB = inb_cmos(CMOS_STATUS_B);
 343     u8 registerC = inb_cmos(CMOS_STATUS_C);
 344
 345     if (!(registerB & 0x60))
 346         goto done;
 347     if (registerC & 0x20) {
 348         // Handle Alarm Interrupt.
 349         struct bregs br;
 350         memset(&br, 0, sizeof(br));
 351         call16_int(0x4a, &br);
 352         irq_disable();
 353     }
 354     if (!(registerC & 0x40))
 355         goto done;
 356
 357     // Handle Periodic Interrupt.
 358
 359     if (!GET_BDA(rtc_wait_flag))
 360         goto done;
 361
 362     // Wait Interval (Int 15, AH=83) active.
 363     u32 time = GET_BDA(user_wait_timeout);  // Time left in microseconds.
 364     if (time < 0x3D1) {
 365         // Done waiting.
 366         u32 segoff = GET_BDA(ptr_user_wait_complete_flag);
 367         u16 segment = segoff >> 16;
 368         u16 offset = segoff & 0xffff;
 369         // Turn off status byte.
 370         SET_BDA(rtc_wait_flag, 0);
 371         // Clear the Periodic Interrupt.
 372         outb_cmos(registerB & 0x37, CMOS_STATUS_B);
 373         // Write to specified flag byte.
 374         u8 oldval = GET_FARVAR(segment, *(u8*)(offset+0));
 375         SET_FARVAR(segment, *(u8*)(offset+0), oldval | 0x80);
 376     } else {
 377         // Continue waiting.
 378         time -= 0x3D1;
 379         SET_BDA(user_wait_timeout, time);
 380     }
 381
 382 done:
 383     eoi_both_pics();
 384 }