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 static void
 219 handle_1ab1(struct bregs *regs)
 220 {
 221     // XXX - pcibios stuff
 222     set_fail(regs);
 223 }
 224
 225 // Unsupported
 226 static void
 227 handle_1aXX(struct bregs *regs)
 228 {
 229     set_fail(regs);
 230 }
 231
 232 // INT 1Ah Time-of-day Service Entry Point
 233 void VISIBLE16
 234 handle_1a(struct bregs *regs)
 235 {
 236     //debug_enter(regs);
 237     switch (regs->ah) {
 238     case 0x00: handle_1a00(regs); break;
 239     case 0x01: handle_1a01(regs); break;
 240     case 0x02: handle_1a02(regs); break;
 241     case 0x03: handle_1a03(regs); break;
 242     case 0x04: handle_1a04(regs); break;
 243     case 0x05: handle_1a05(regs); break;
 244     case 0x06: handle_1a06(regs); break;
 245     case 0x07: handle_1a07(regs); break;
 246     case 0xb1: handle_1ab1(regs); break;
 247     default:   handle_1aXX(regs); break;
 248     }
 249 }
 250
 251 // User Timer Tick
 252 void VISIBLE16
 253 handle_1c(struct bregs *regs)
 254 {
 255     //debug_enter(regs);
 256 }
 257
 258 // INT 08h System Timer ISR Entry Point
 259 void VISIBLE16
 260 handle_08(struct bregs *regs)
 261 {
 262 //    debug_isr(regs);
 263
 264     floppy_tick();
 265
 266     u32 counter = GET_BDA(timer_counter);
 267     counter++;
 268     // compare to one days worth of timer ticks at 18.2 hz
 269     if (counter >= 0x001800B0) {
 270         // there has been a midnight rollover at this point
 271         counter = 0;
 272         SET_BDA(timer_rollover, GET_BDA(timer_rollover) + 1);
 273     }
 274
 275     SET_BDA(timer_counter, counter);
 276
 277     // chain to user timer tick INT #0x1c
 278     struct bregs br;
 279     memset(&br, 0, sizeof(br));
 280     call16_int(0x1c, &br);
 281
 282     eoi_master_pic();
 283 }
 284
 285 // Set Interval requested.
 286 static void
 287 handle_158300(struct bregs *regs)
 288 {
 289     if (GET_BDA(rtc_wait_flag) & RWS_WAIT_PENDING) {
 290         // Interval already set.
 291         DEBUGF("int15: Func 83h, failed, already waiting.\n" );
 292         set_code_fail(regs, RET_EUNSUPPORTED);
 293     }
 294     // Interval not already set.
 295     SET_BDA(rtc_wait_flag, RWS_WAIT_PENDING);  // Set status byte.
 296     u32 v = (regs->es << 16) | regs->bx;
 297     SET_BDA(ptr_user_wait_complete_flag, v);
 298     v = (regs->dx << 16) | regs->cx;
 299     SET_BDA(user_wait_timeout, v);
 300
 301     // Unmask IRQ8 so INT70 will get through.
 302     u8 irqDisable = inb(PORT_PIC2_DATA);
 303     outb(irqDisable & ~PIC2_IRQ8, PORT_PIC2_DATA);
 304     // Turn on the Periodic Interrupt timer
 305     u8 bRegister = inb_cmos(CMOS_STATUS_B);
 306     outb_cmos(CMOS_STATUS_B, bRegister | CSB_EN_ALARM_IRQ);
 307
 308     set_success(regs); // XXX - no set ah?
 309 }
 310
 311 // Clear interval requested
 312 static void
 313 handle_158301(struct bregs *regs)
 314 {
 315     SET_BDA(rtc_wait_flag, 0); // Clear status byte
 316     // Turn off the Periodic Interrupt timer
 317     u8 bRegister = inb_cmos(CMOS_STATUS_B);
 318     outb_cmos(CMOS_STATUS_B, bRegister & ~CSB_EN_ALARM_IRQ);
 319     set_success(regs); // XXX - no set ah?
 320 }
 321
 322 static void
 323 handle_1583XX(struct bregs *regs)
 324 {
 325     set_code_fail(regs, RET_EUNSUPPORTED);
 326     regs->al--;
 327 }
 328
 329 void
 330 handle_1583(struct bregs *regs)
 331 {
 332     switch (regs->al) {
 333     case 0x00: handle_158300(regs); break;
 334     case 0x01: handle_158301(regs); break;
 335     default:   handle_1583XX(regs); break;
 336     }
 337 }
 338
 339 // int70h: IRQ8 - CMOS RTC
 340 void VISIBLE16
 341 handle_70(struct bregs *regs)
 342 {
 343     debug_isr(regs);
 344
 345     // Check which modes are enabled and have occurred.
 346     u8 registerB = inb_cmos(CMOS_STATUS_B);
 347     u8 registerC = inb_cmos(CMOS_STATUS_C);
 348
 349     if (!(registerB & 0x60))
 350         goto done;
 351     if (registerC & 0x20) {
 352         // Handle Alarm Interrupt.
 353         struct bregs br;
 354         memset(&br, 0, sizeof(br));
 355         call16_int(0x4a, &br);
 356     }
 357     if (!(registerC & 0x40))
 358         goto done;
 359
 360     // Handle Periodic Interrupt.
 361
 362     if (!GET_BDA(rtc_wait_flag))
 363         goto done;
 364
 365     // Wait Interval (Int 15, AH=83) active.
 366     u32 time = GET_BDA(user_wait_timeout);  // Time left in microseconds.
 367     if (time < 0x3D1) {
 368         // Done waiting.
 369         u32 segoff = GET_BDA(ptr_user_wait_complete_flag);
 370         u16 segment = segoff >> 16;
 371         u16 offset = segoff & 0xffff;
 372         // Turn off status byte.
 373         SET_BDA(rtc_wait_flag, 0);
 374         // Clear the Periodic Interrupt.
 375         outb_cmos(registerB & 0x37, CMOS_STATUS_B);
 376         // Write to specified flag byte.
 377         u8 oldval = GET_FARVAR(segment, *(u8*)(offset+0));
 378         SET_FARVAR(segment, *(u8*)(offset+0), oldval | 0x80);
 379     } else {
 380         // Continue waiting.
 381         time -= 0x3D1;
 382         SET_BDA(user_wait_timeout, time);
 383     }
 384
 385 done:
 386     eoi_both_pics();
 387 }