![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rtclock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ppc|
Return to rtclock.c CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * @APPLE_FREE_COPYRIGHT@ ! 27: */ ! 28: /* ! 29: * File: rtclock.c ! 30: * Purpose: Routines for handling the machine dependent ! 31: * real-time clock. ! 32: */ ! 33: ! 34: #include <platforms.h> ! 35: ! 36: #include <kern/cpu_number.h> ! 37: #include <kern/clock.h> ! 38: #include <kern/macro_help.h> ! 39: #include <kern/misc_protos.h> ! 40: #include <kern/spl.h> ! 41: #include <machine/mach_param.h> /* HZ */ ! 42: #include <mach/vm_prot.h> ! 43: #include <vm/pmap.h> ! 44: #include <vm/vm_kern.h> /* for kernel_map */ ! 45: #include <ppc/misc_protos.h> ! 46: #include <ppc/proc_reg.h> ! 47: #include <ppc/spl.h> ! 48: ! 49: #include <IOKit/IOPlatformExpert.h> ! 50: ! 51: #include <sys/kdebug.h> ! 52: ! 53: int sysclk_config(void); ! 54: ! 55: int sysclk_init(void); ! 56: ! 57: kern_return_t sysclk_gettime( ! 58: mach_timespec_t *cur_time); ! 59: ! 60: kern_return_t sysclk_getattr( ! 61: clock_flavor_t flavor, ! 62: clock_attr_t attr, ! 63: mach_msg_type_number_t *count); ! 64: ! 65: void sysclk_setalarm( ! 66: mach_timespec_t *deadline); ! 67: ! 68: struct clock_ops sysclk_ops = { ! 69: sysclk_config, sysclk_init, ! 70: sysclk_gettime, 0, ! 71: sysclk_getattr, 0, ! 72: sysclk_setalarm, ! 73: }; ! 74: ! 75: int calend_config(void); ! 76: ! 77: int calend_init(void); ! 78: ! 79: kern_return_t calend_gettime( ! 80: mach_timespec_t *cur_time); ! 81: ! 82: kern_return_t calend_settime( ! 83: mach_timespec_t *cur_time); ! 84: ! 85: kern_return_t calend_getattr( ! 86: clock_flavor_t flavor, ! 87: clock_attr_t attr, ! 88: mach_msg_type_number_t *count); ! 89: ! 90: struct clock_ops calend_ops = { ! 91: calend_config, calend_init, ! 92: calend_gettime, calend_settime, ! 93: calend_getattr, 0, ! 94: 0, ! 95: }; ! 96: ! 97: /* local data declarations */ ! 98: ! 99: static struct rtclock { ! 100: AbsoluteTime alarm_deadline; ! 101: boolean_t alarm_is_set; ! 102: ! 103: mach_timespec_t calend_offset; ! 104: boolean_t calend_is_set; ! 105: ! 106: struct { ! 107: natural_t numer, denom; ! 108: } timebase_const; ! 109: ! 110: AbsoluteTime timer_deadline; ! 111: boolean_t timer_is_set; ! 112: clock_timer_func_t timer_expire; ! 113: ! 114: /* debugging */ ! 115: AbsoluteTime last_abstime[NCPUS]; ! 116: int last_decr[NCPUS]; ! 117: natural_t intr_entry; ! 118: natural_t intr_exit; ! 119: ! 120: decl_simple_lock_data(,lock) /* real-time clock device lock */ ! 121: } rtclock; ! 122: ! 123: static boolean_t rtclock_initialized; ! 124: ! 125: static AbsoluteTime rtclock_tick_deadline[NCPUS]; ! 126: static AbsoluteTime rtclock_tick_interval; ! 127: ! 128: static void absolutetime_to_timespec_internal( ! 129: AbsoluteTime abstime, ! 130: mach_timespec_t *result); ! 131: ! 132: static void timespec_to_absolutetime_internal( ! 133: mach_timespec_t timespec, ! 134: AbsoluteTime *result); ! 135: ! 136: static int deadline_to_decrementer( ! 137: AbsoluteTime deadline, ! 138: AbsoluteTime now); ! 139: ! 140: /* global data declarations */ ! 141: ! 142: #define RTC_TICKPERIOD (NSEC_PER_SEC / HZ) ! 143: ! 144: #define DECREMENTER_MAX 0x7FFFFFFFUL ! 145: #define DECREMENTER_MIN 0xAUL ! 146: ! 147: natural_t rtclock_decrementer_min; ! 148: ! 149: /* ! 150: * Macros to lock/unlock real-time clock device. ! 151: */ ! 152: #define LOCK_RTC(s) \ ! 153: MACRO_BEGIN \ ! 154: (s) = splclock(); \ ! 155: simple_lock(&rtclock.lock); \ ! 156: MACRO_END ! 157: ! 158: #define UNLOCK_RTC(s) \ ! 159: MACRO_BEGIN \ ! 160: simple_unlock(&rtclock.lock); \ ! 161: splx(s); \ ! 162: MACRO_END ! 163: ! 164: static void ! 165: timebase_callback( ! 166: struct timebase_freq_t *freq) ! 167: { ! 168: natural_t numer, denom; ! 169: int n; ! 170: spl_t s; ! 171: ! 172: denom = freq->timebase_num; ! 173: n = 9; ! 174: while (!(denom % 10)) { ! 175: if (n < 1) ! 176: break; ! 177: denom /= 10; ! 178: n--; ! 179: } ! 180: ! 181: numer = freq->timebase_den; ! 182: while (n-- > 0) { ! 183: numer *= 10; ! 184: } ! 185: ! 186: LOCK_RTC(s); ! 187: rtclock.timebase_const.numer = numer; ! 188: rtclock.timebase_const.denom = denom; ! 189: UNLOCK_RTC(s); ! 190: } ! 191: ! 192: /* ! 193: * Configure the real-time clock device. ! 194: */ ! 195: int ! 196: sysclk_config(void) ! 197: { ! 198: if (cpu_number() != master_cpu) ! 199: return(1); ! 200: ! 201: simple_lock_init(&rtclock.lock, ETAP_MISC_RT_CLOCK); ! 202: ! 203: PE_register_timebase_callback(timebase_callback); ! 204: ! 205: return (1); ! 206: } ! 207: ! 208: /* ! 209: * Initialize the system clock device. ! 210: */ ! 211: int ! 212: sysclk_init(void) ! 213: { ! 214: AbsoluteTime abstime; ! 215: int decr, mycpu = cpu_number(); ! 216: ! 217: if (mycpu != master_cpu) { ! 218: if (rtclock_initialized == FALSE) { ! 219: panic("sysclk_init on cpu %d, rtc not initialized\n", mycpu); ! 220: } ! 221: /* Set decrementer and hence our next tick due */ ! 222: clock_get_uptime(&abstime); ! 223: rtclock_tick_deadline[mycpu] = abstime; ! 224: ADD_ABSOLUTETIME(&rtclock_tick_deadline[mycpu], ! 225: &rtclock_tick_interval); ! 226: decr = deadline_to_decrementer(rtclock_tick_deadline[mycpu], abstime); ! 227: mtdec(decr); ! 228: rtclock.last_decr[mycpu] = decr; ! 229: ! 230: return(1); ! 231: } ! 232: ! 233: /* ! 234: * Initialize non-zero clock structure values. ! 235: */ ! 236: clock_interval_to_absolutetime_interval(RTC_TICKPERIOD, 1, ! 237: &rtclock_tick_interval); ! 238: /* Set decrementer and our next tick due */ ! 239: clock_get_uptime(&abstime); ! 240: rtclock_tick_deadline[mycpu] = abstime; ! 241: ADD_ABSOLUTETIME(&rtclock_tick_deadline[mycpu], &rtclock_tick_interval); ! 242: decr = deadline_to_decrementer(rtclock_tick_deadline[mycpu], abstime); ! 243: mtdec(decr); ! 244: rtclock.last_decr[mycpu] = decr; ! 245: ! 246: rtclock_initialized = TRUE; ! 247: ! 248: return (1); ! 249: } ! 250: ! 251: /* ! 252: * Perform a full 64 bit by 32 bit unsigned multiply, ! 253: * yielding a 96 bit product. The most significant ! 254: * portion of the product is returned as a 64 bit ! 255: * quantity, with the lower portion as a 32 bit word. ! 256: */ ! 257: static void ! 258: umul_64by32( ! 259: AbsoluteTime now64, ! 260: natural_t mult32, ! 261: AbsoluteTime *result64, ! 262: natural_t *result32) ! 263: { ! 264: natural_t mid, mid2; ! 265: ! 266: asm volatile(" mullw %0,%1,%2" : ! 267: "=r" (*result32) : ! 268: "r" (now64.lo), "r" (mult32)); ! 269: ! 270: asm volatile(" mullw %0,%1,%2" : ! 271: "=r" (mid2) : ! 272: "r" (now64.hi), "r" (mult32)); ! 273: asm volatile(" mulhwu %0,%1,%2" : ! 274: "=r" (mid) : ! 275: "r" (now64.lo), "r" (mult32)); ! 276: ! 277: asm volatile(" mulhwu %0,%1,%2" : ! 278: "=r" (result64->hi) : ! 279: "r" (now64.hi), "r" (mult32)); ! 280: ! 281: asm volatile(" addc %0,%2,%3; ! 282: addze %1,%4" : ! 283: "=r" (result64->lo), "=r" (result64->hi) : ! 284: "r" (mid), "r" (mid2), "1" (result64->hi)); ! 285: } ! 286: ! 287: /* ! 288: * Perform a partial 64 bit by 32 bit unsigned multiply, ! 289: * yielding a 64 bit product. Only the least significant ! 290: * 64 bits of the product are calculated and returned. ! 291: */ ! 292: static void ! 293: umul_64by32to64( ! 294: AbsoluteTime now64, ! 295: natural_t mult32, ! 296: AbsoluteTime *result64) ! 297: { ! 298: natural_t mid, mid2; ! 299: ! 300: asm volatile(" mullw %0,%1,%2" : ! 301: "=r" (result64->lo) : ! 302: "r" (now64.lo), "r" (mult32)); ! 303: ! 304: asm volatile(" mullw %0,%1,%2" : ! 305: "=r" (mid2) : ! 306: "r" (now64.hi), "r" (mult32)); ! 307: asm volatile(" mulhwu %0,%1,%2" : ! 308: "=r" (mid) : ! 309: "r" (now64.lo), "r" (mult32)); ! 310: ! 311: asm volatile(" add %0,%1,%2" : ! 312: "=r" (result64->hi) : ! 313: "r" (mid), "r" (mid2)); ! 314: } ! 315: ! 316: /* ! 317: * Perform an unsigned division of a 96 bit value ! 318: * by a 32 bit value, yielding a 96 bit quotient. ! 319: * The most significant portion of the product is ! 320: * returned as a 64 bit quantity, with the lower ! 321: * portion as a 32 bit word. ! 322: */ ! 323: static __inline__ ! 324: void ! 325: udiv_96by32( ! 326: AbsoluteTime now64, ! 327: natural_t now32, ! 328: natural_t div32, ! 329: AbsoluteTime *result64, ! 330: natural_t *result32) ! 331: { ! 332: AbsoluteTime t64; ! 333: ! 334: if (now64.hi > 0 || now64.lo >= div32) { ! 335: AbsoluteTime_to_scalar(result64) = ! 336: AbsoluteTime_to_scalar(&now64) / div32; ! 337: ! 338: umul_64by32to64(*result64, div32, &t64); ! 339: ! 340: AbsoluteTime_to_scalar(&t64) = ! 341: AbsoluteTime_to_scalar(&now64) - AbsoluteTime_to_scalar(&t64); ! 342: ! 343: *result32 = (((unsigned long long)t64.lo << 32) | now32) / div32; ! 344: } ! 345: else { ! 346: AbsoluteTime_to_scalar(result64) = ! 347: (((unsigned long long)now64.lo << 32) | now32) / div32; ! 348: ! 349: *result32 = result64->lo; ! 350: result64->lo = result64->hi; ! 351: result64->hi = 0; ! 352: } ! 353: } ! 354: ! 355: /* ! 356: * Perform an unsigned division of a 96 bit value ! 357: * by a 32 bit value, yielding a 64 bit quotient. ! 358: * Any higher order bits of the quotient are simply ! 359: * discarded. ! 360: */ ! 361: static __inline__ ! 362: void ! 363: udiv_96by32to64( ! 364: AbsoluteTime now64, ! 365: natural_t now32, ! 366: natural_t div32, ! 367: AbsoluteTime *result64) ! 368: { ! 369: AbsoluteTime t64; ! 370: ! 371: if (now64.hi > 0 || now64.lo >= div32) { ! 372: AbsoluteTime_to_scalar(result64) = ! 373: AbsoluteTime_to_scalar(&now64) / div32; ! 374: ! 375: umul_64by32to64(*result64, div32, &t64); ! 376: ! 377: AbsoluteTime_to_scalar(&t64) = ! 378: AbsoluteTime_to_scalar(&now64) - AbsoluteTime_to_scalar(&t64); ! 379: ! 380: result64->hi = result64->lo; ! 381: result64->lo = (((unsigned long long)t64.lo << 32) | now32) / div32; ! 382: } ! 383: else { ! 384: AbsoluteTime_to_scalar(result64) = ! 385: (((unsigned long long)now64.lo << 32) | now32) / div32; ! 386: } ! 387: } ! 388: ! 389: /* ! 390: * Perform an unsigned division of a 96 bit value ! 391: * by a 32 bit value, yielding a 32 bit quotient, ! 392: * and a 32 bit remainder. Any higher order bits ! 393: * of the quotient are simply discarded. ! 394: */ ! 395: static __inline__ ! 396: void ! 397: udiv_96by32to32and32( ! 398: AbsoluteTime now64, ! 399: natural_t now32, ! 400: natural_t div32, ! 401: natural_t *result32, ! 402: natural_t *remain32) ! 403: { ! 404: AbsoluteTime t64, u64; ! 405: ! 406: if (now64.hi > 0 || now64.lo >= div32) { ! 407: AbsoluteTime_to_scalar(&t64) = ! 408: AbsoluteTime_to_scalar(&now64) / div32; ! 409: ! 410: umul_64by32to64(t64, div32, &t64); ! 411: ! 412: AbsoluteTime_to_scalar(&t64) = ! 413: AbsoluteTime_to_scalar(&now64) - AbsoluteTime_to_scalar(&t64); ! 414: ! 415: AbsoluteTime_to_scalar(&t64) = ! 416: ((unsigned long long)t64.lo << 32) | now32; ! 417: ! 418: AbsoluteTime_to_scalar(&u64) = ! 419: AbsoluteTime_to_scalar(&t64) / div32; ! 420: ! 421: *result32 = u64.lo; ! 422: ! 423: umul_64by32to64(u64, div32, &u64); ! 424: ! 425: *remain32 = AbsoluteTime_to_scalar(&t64) - ! 426: AbsoluteTime_to_scalar(&u64); ! 427: } ! 428: else { ! 429: AbsoluteTime_to_scalar(&t64) = ! 430: ((unsigned long long)now64.lo << 32) | now32; ! 431: ! 432: AbsoluteTime_to_scalar(&u64) = ! 433: AbsoluteTime_to_scalar(&t64) / div32; ! 434: ! 435: *result32 = u64.lo; ! 436: ! 437: umul_64by32to64(u64, div32, &u64); ! 438: ! 439: *remain32 = AbsoluteTime_to_scalar(&t64) - ! 440: AbsoluteTime_to_scalar(&u64); ! 441: } ! 442: } ! 443: ! 444: /* ! 445: * Get the clock device time. This routine is responsible ! 446: * for converting the device's machine dependent time value ! 447: * into a canonical mach_timespec_t value. ! 448: * ! 449: * SMP configurations - *this currently assumes that the processor ! 450: * clocks will be synchronised* ! 451: */ ! 452: kern_return_t ! 453: sysclk_gettime_internal( ! 454: mach_timespec_t *time) /* OUT */ ! 455: { ! 456: AbsoluteTime now; ! 457: AbsoluteTime t64; ! 458: natural_t t32; ! 459: natural_t numer, denom; ! 460: ! 461: numer = rtclock.timebase_const.numer; ! 462: denom = rtclock.timebase_const.denom; ! 463: ! 464: clock_get_uptime(&now); ! 465: ! 466: umul_64by32(now, numer, &t64, &t32); ! 467: ! 468: udiv_96by32(t64, t32, denom, &t64, &t32); ! 469: ! 470: udiv_96by32to32and32(t64, t32, NSEC_PER_SEC, ! 471: &time->tv_sec, &time->tv_nsec); ! 472: ! 473: return (KERN_SUCCESS); ! 474: } ! 475: ! 476: kern_return_t ! 477: sysclk_gettime( ! 478: mach_timespec_t *time) /* OUT */ ! 479: { ! 480: AbsoluteTime now; ! 481: AbsoluteTime t64; ! 482: natural_t t32; ! 483: natural_t numer, denom; ! 484: spl_t s; ! 485: ! 486: LOCK_RTC(s); ! 487: numer = rtclock.timebase_const.numer; ! 488: denom = rtclock.timebase_const.denom; ! 489: UNLOCK_RTC(s); ! 490: ! 491: clock_get_uptime(&now); ! 492: ! 493: umul_64by32(now, numer, &t64, &t32); ! 494: ! 495: udiv_96by32(t64, t32, denom, &t64, &t32); ! 496: ! 497: udiv_96by32to32and32(t64, t32, NSEC_PER_SEC, ! 498: &time->tv_sec, &time->tv_nsec); ! 499: ! 500: return (KERN_SUCCESS); ! 501: } ! 502: ! 503: /* ! 504: * Get clock device attributes. ! 505: */ ! 506: kern_return_t ! 507: sysclk_getattr( ! 508: clock_flavor_t flavor, ! 509: clock_attr_t attr, /* OUT */ ! 510: mach_msg_type_number_t *count) /* IN/OUT */ ! 511: { ! 512: spl_t s; ! 513: ! 514: if (*count != 1) ! 515: return (KERN_FAILURE); ! 516: switch (flavor) { ! 517: ! 518: case CLOCK_GET_TIME_RES: /* >0 res */ ! 519: case CLOCK_ALARM_CURRES: /* =0 no alarm */ ! 520: case CLOCK_ALARM_MINRES: ! 521: case CLOCK_ALARM_MAXRES: ! 522: LOCK_RTC(s); ! 523: *(clock_res_t *) attr = RTC_TICKPERIOD; ! 524: UNLOCK_RTC(s); ! 525: break; ! 526: ! 527: default: ! 528: return (KERN_INVALID_VALUE); ! 529: } ! 530: return (KERN_SUCCESS); ! 531: } ! 532: ! 533: /* ! 534: * Set deadline for the next alarm on the clock device. This call ! 535: * always resets the time to deliver an alarm for the clock. ! 536: */ ! 537: void ! 538: sysclk_setalarm( ! 539: mach_timespec_t *deadline) ! 540: { ! 541: AbsoluteTime abstime; ! 542: int decr, mycpu; ! 543: spl_t s; ! 544: ! 545: LOCK_RTC(s); ! 546: mycpu = cpu_number(); ! 547: clock_get_uptime(&abstime); ! 548: rtclock.last_abstime[mycpu] = abstime; ! 549: timespec_to_absolutetime_internal(*deadline, &rtclock.alarm_deadline); ! 550: rtclock.alarm_is_set = TRUE; ! 551: if ( (!rtclock.timer_is_set || ! 552: CMP_ABSOLUTETIME(&rtclock.alarm_deadline, ! 553: &rtclock.timer_deadline) < 0) && ! 554: CMP_ABSOLUTETIME(&rtclock.alarm_deadline, ! 555: &rtclock_tick_deadline[mycpu]) < 0) { ! 556: decr = deadline_to_decrementer(rtclock.alarm_deadline, abstime); ! 557: if ( rtclock_decrementer_min != 0 && ! 558: rtclock_decrementer_min < (natural_t)decr ) ! 559: decr = rtclock_decrementer_min; ! 560: ! 561: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_DECI, 1) ! 562: | DBG_FUNC_NONE, decr, 1, 0, 0, 0); ! 563: ! 564: mtdec(decr); ! 565: rtclock.last_decr[mycpu] = decr; ! 566: } ! 567: UNLOCK_RTC(s); ! 568: } ! 569: ! 570: /* ! 571: * Configure the calendar clock. ! 572: */ ! 573: int ! 574: calend_config(void) ! 575: { ! 576: return (1); ! 577: } ! 578: ! 579: /* ! 580: * Initialize the calendar clock. ! 581: */ ! 582: int ! 583: calend_init(void) ! 584: { ! 585: if (cpu_number() != master_cpu) ! 586: return(1); ! 587: ! 588: return (1); ! 589: } ! 590: ! 591: /* ! 592: * Get the current clock time. ! 593: */ ! 594: kern_return_t ! 595: calend_gettime( ! 596: mach_timespec_t *curr_time) /* OUT */ ! 597: { ! 598: spl_t s; ! 599: ! 600: LOCK_RTC(s); ! 601: if (!rtclock.calend_is_set) { ! 602: UNLOCK_RTC(s); ! 603: return (KERN_FAILURE); ! 604: } ! 605: ! 606: (void) sysclk_gettime_internal(curr_time); ! 607: ADD_MACH_TIMESPEC(curr_time, &rtclock.calend_offset); ! 608: UNLOCK_RTC(s); ! 609: ! 610: return (KERN_SUCCESS); ! 611: } ! 612: ! 613: /* ! 614: * Set the current clock time. ! 615: */ ! 616: kern_return_t ! 617: calend_settime( ! 618: mach_timespec_t *new_time) ! 619: { ! 620: mach_timespec_t curr_time; ! 621: spl_t s; ! 622: ! 623: LOCK_RTC(s); ! 624: (void) sysclk_gettime_internal(&curr_time); ! 625: rtclock.calend_offset = *new_time; ! 626: SUB_MACH_TIMESPEC(&rtclock.calend_offset, &curr_time); ! 627: rtclock.calend_is_set = TRUE; ! 628: UNLOCK_RTC(s); ! 629: ! 630: PESetGMTTimeOfDay(new_time->tv_sec); ! 631: ! 632: return (KERN_SUCCESS); ! 633: } ! 634: ! 635: /* ! 636: * Get clock device attributes. ! 637: */ ! 638: kern_return_t ! 639: calend_getattr( ! 640: clock_flavor_t flavor, ! 641: clock_attr_t attr, /* OUT */ ! 642: mach_msg_type_number_t *count) /* IN/OUT */ ! 643: { ! 644: spl_t s; ! 645: ! 646: if (*count != 1) ! 647: return (KERN_FAILURE); ! 648: switch (flavor) { ! 649: ! 650: case CLOCK_GET_TIME_RES: /* >0 res */ ! 651: LOCK_RTC(s); ! 652: *(clock_res_t *) attr = RTC_TICKPERIOD; ! 653: UNLOCK_RTC(s); ! 654: break; ! 655: ! 656: case CLOCK_ALARM_CURRES: /* =0 no alarm */ ! 657: case CLOCK_ALARM_MINRES: ! 658: case CLOCK_ALARM_MAXRES: ! 659: *(clock_res_t *) attr = 0; ! 660: break; ! 661: ! 662: default: ! 663: return (KERN_INVALID_VALUE); ! 664: } ! 665: return (KERN_SUCCESS); ! 666: } ! 667: ! 668: void ! 669: clock_adjust_calendar( ! 670: clock_res_t nsec) ! 671: { ! 672: spl_t s; ! 673: ! 674: LOCK_RTC(s); ! 675: if (rtclock.calend_is_set) ! 676: ADD_MACH_TIMESPEC_NSEC(&rtclock.calend_offset, nsec); ! 677: UNLOCK_RTC(s); ! 678: } ! 679: ! 680: void ! 681: clock_initialize_calendar(void) ! 682: { ! 683: mach_timespec_t curr_time; ! 684: long seconds = PEGetGMTTimeOfDay(); ! 685: spl_t s; ! 686: ! 687: LOCK_RTC(s); ! 688: if (!rtclock.calend_is_set) { ! 689: (void) sysclk_gettime_internal(&curr_time); ! 690: rtclock.calend_offset.tv_sec = seconds; ! 691: rtclock.calend_offset.tv_nsec = 0; ! 692: SUB_MACH_TIMESPEC(&rtclock.calend_offset, &curr_time); ! 693: rtclock.calend_is_set = TRUE; ! 694: } ! 695: UNLOCK_RTC(s); ! 696: } ! 697: ! 698: mach_timespec_t ! 699: clock_get_calendar_offset(void) ! 700: { ! 701: mach_timespec_t result = MACH_TIMESPEC_ZERO; ! 702: spl_t s; ! 703: ! 704: LOCK_RTC(s); ! 705: if (rtclock.calend_is_set) ! 706: result = rtclock.calend_offset; ! 707: UNLOCK_RTC(s); ! 708: ! 709: return (result); ! 710: } ! 711: ! 712: void ! 713: clock_get_timebase_info( ! 714: natural_t *delta, ! 715: natural_t *abs_to_ns_num, ! 716: natural_t *abs_to_ns_denom, ! 717: natural_t *proc_to_abs_num, ! 718: natural_t *proc_to_abs_denom) ! 719: { ! 720: spl_t s; ! 721: ! 722: LOCK_RTC(s); ! 723: *abs_to_ns_num = rtclock.timebase_const.numer; ! 724: *abs_to_ns_denom = rtclock.timebase_const.denom; ! 725: UNLOCK_RTC(s); ! 726: ! 727: /* ! 728: * Other values as returned by Mac OS 8.6. ! 729: */ ! 730: *delta = 1; ! 731: *proc_to_abs_num = *proc_to_abs_denom = 1; ! 732: } ! 733: ! 734: void ! 735: clock_set_timer_deadline( ! 736: AbsoluteTime deadline) ! 737: { ! 738: AbsoluteTime abstime; ! 739: int decr, mycpu; ! 740: spl_t s; ! 741: ! 742: LOCK_RTC(s); ! 743: mycpu = cpu_number(); ! 744: clock_get_uptime(&abstime); ! 745: rtclock.last_abstime[mycpu] = abstime; ! 746: rtclock.timer_deadline = deadline; ! 747: rtclock.timer_is_set = TRUE; ! 748: if ( (!rtclock.alarm_is_set || ! 749: CMP_ABSOLUTETIME(&rtclock.timer_deadline, ! 750: &rtclock.alarm_deadline) < 0) && ! 751: CMP_ABSOLUTETIME(&rtclock.timer_deadline, ! 752: &rtclock_tick_deadline[mycpu]) < 0) { ! 753: decr = deadline_to_decrementer(rtclock.timer_deadline, abstime); ! 754: if ( rtclock_decrementer_min != 0 && ! 755: rtclock_decrementer_min < (natural_t)decr ) ! 756: decr = rtclock_decrementer_min; ! 757: ! 758: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_DECI, 1) ! 759: | DBG_FUNC_NONE, decr, 2, 0, 0, 0); ! 760: ! 761: mtdec(decr); ! 762: rtclock.last_decr[mycpu] = decr; ! 763: } ! 764: UNLOCK_RTC(s); ! 765: } ! 766: ! 767: void ! 768: clock_set_timer_func( ! 769: clock_timer_func_t func) ! 770: { ! 771: spl_t s; ! 772: ! 773: LOCK_RTC(s); ! 774: if (rtclock.timer_expire == NULL) ! 775: rtclock.timer_expire = func; ! 776: UNLOCK_RTC(s); ! 777: } ! 778: ! 779: /* ! 780: * Reset the clock device. This causes the realtime clock ! 781: * device to reload its mode and count value (frequency). ! 782: */ ! 783: void ! 784: rtclock_reset(void) ! 785: { ! 786: return; ! 787: } ! 788: ! 789: /* ! 790: * Real-time clock device interrupt. ! 791: */ ! 792: void ! 793: rtclock_intr( ! 794: int device, ! 795: struct ppc_saved_state *ssp, ! 796: spl_t old_spl) ! 797: { ! 798: AbsoluteTime abstime; ! 799: mach_timespec_t timespec; ! 800: int decr[4], mycpu = cpu_number(); ! 801: spl_t s; ! 802: ! 803: /* ! 804: * We may receive interrupts too early, we must reject them. ! 805: */ ! 806: if (rtclock_initialized == FALSE) { ! 807: mtdec(DECREMENTER_MAX); /* Max the decrementer if not init */ ! 808: return; ! 809: } ! 810: ! 811: decr[1] = decr[2] = decr[3] = DECREMENTER_MAX; ! 812: ! 813: LOCK_RTC(s); ! 814: ! 815: rtclock.intr_entry++; ! 816: ! 817: clock_get_uptime(&abstime); ! 818: rtclock.last_abstime[mycpu] = abstime; ! 819: if (CMP_ABSOLUTETIME(&rtclock_tick_deadline[mycpu], &abstime) <= 0) { ! 820: clock_deadline_for_periodic_event(rtclock_tick_interval, abstime, ! 821: &rtclock_tick_deadline[mycpu]); ! 822: UNLOCK_RTC(s); ! 823: ! 824: hertz_tick(USER_MODE(ssp->srr1), ssp->srr0); ! 825: ! 826: LOCK_RTC(s); ! 827: } ! 828: ! 829: if (rtclock.timer_is_set && ! 830: CMP_ABSOLUTETIME(&rtclock.timer_deadline, &abstime) <= 0) { ! 831: rtclock.timer_is_set = FALSE; ! 832: UNLOCK_RTC(s); ! 833: ! 834: (*rtclock.timer_expire)(abstime); ! 835: ! 836: LOCK_RTC(s); ! 837: } ! 838: ! 839: if (rtclock.alarm_is_set && ! 840: CMP_ABSOLUTETIME(&rtclock.alarm_deadline, &abstime) <= 0) { ! 841: absolutetime_to_timespec_internal(abstime, ×pec); ! 842: rtclock.alarm_is_set = FALSE; ! 843: UNLOCK_RTC(s); ! 844: ! 845: clock_alarm_intr(SYSTEM_CLOCK, ×pec); ! 846: ! 847: LOCK_RTC(s); ! 848: } ! 849: ! 850: clock_get_uptime(&abstime); ! 851: rtclock.last_abstime[mycpu] = abstime; ! 852: decr[1] = deadline_to_decrementer(rtclock_tick_deadline[mycpu], abstime); ! 853: ! 854: if (rtclock.timer_is_set) ! 855: decr[2] = deadline_to_decrementer(rtclock.timer_deadline, abstime); ! 856: ! 857: if (rtclock.alarm_is_set) ! 858: decr[3] = deadline_to_decrementer(rtclock.alarm_deadline, abstime); ! 859: ! 860: if (decr[1] > decr[2]) ! 861: decr[1] = decr[2]; ! 862: ! 863: if (decr[1] > decr[3]) ! 864: decr[1] = decr[3]; ! 865: ! 866: if ( rtclock_decrementer_min != 0 && ! 867: rtclock_decrementer_min < (natural_t)decr[1] ) ! 868: decr[1] = rtclock_decrementer_min; ! 869: ! 870: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_DECI, 1) ! 871: | DBG_FUNC_NONE, decr[1], 3, 0, 0, 0); ! 872: ! 873: mtdec(decr[1]); ! 874: rtclock.last_decr[mycpu] = decr[1]; ! 875: ! 876: rtclock.intr_exit++; ! 877: ! 878: UNLOCK_RTC(s); ! 879: } ! 880: ! 881: void ! 882: clock_get_uptime( ! 883: AbsoluteTime *result) ! 884: { ! 885: natural_t hi, lo, hic; ! 886: ! 887: do { ! 888: asm volatile(" mftbu %0" : "=r" (hi)); ! 889: asm volatile(" mftb %0" : "=r" (lo)); ! 890: asm volatile(" mftbu %0" : "=r" (hic)); ! 891: } while (hic != hi); ! 892: ! 893: result->lo = lo; ! 894: result->hi = hi; ! 895: } ! 896: ! 897: static int ! 898: deadline_to_decrementer( ! 899: AbsoluteTime deadline, ! 900: AbsoluteTime now) ! 901: { ! 902: abstime_scalar_t delt; ! 903: ! 904: if (CMP_ABSOLUTETIME(&deadline, &now) <= 0) ! 905: return DECREMENTER_MIN; ! 906: else { ! 907: delt = AbsoluteTime_to_scalar(&deadline) - ! 908: AbsoluteTime_to_scalar(&now); ! 909: return (delt >= (DECREMENTER_MAX + 1))? DECREMENTER_MAX: ! 910: ((delt >= (DECREMENTER_MIN + 1))? (delt - 1): DECREMENTER_MIN); ! 911: } ! 912: } ! 913: ! 914: static void ! 915: absolutetime_to_timespec_internal( ! 916: AbsoluteTime abstime, ! 917: mach_timespec_t *result) ! 918: { ! 919: AbsoluteTime t64; ! 920: natural_t t32; ! 921: natural_t numer, denom; ! 922: ! 923: numer = rtclock.timebase_const.numer; ! 924: denom = rtclock.timebase_const.denom; ! 925: ! 926: umul_64by32(abstime, numer, &t64, &t32); ! 927: ! 928: udiv_96by32(t64, t32, denom, &t64, &t32); ! 929: ! 930: udiv_96by32to32and32(t64, t32, NSEC_PER_SEC, ! 931: &result->tv_sec, &result->tv_nsec); ! 932: } ! 933: ! 934: static void ! 935: timespec_to_absolutetime_internal( ! 936: mach_timespec_t timespec, ! 937: AbsoluteTime *result) ! 938: { ! 939: AbsoluteTime t64; ! 940: natural_t t32; ! 941: natural_t numer, denom; ! 942: ! 943: numer = rtclock.timebase_const.numer; ! 944: denom = rtclock.timebase_const.denom; ! 945: ! 946: asm volatile(" mullw %0,%1,%2" : ! 947: "=r" (t64.lo) : ! 948: "r" (timespec.tv_sec), "r" (NSEC_PER_SEC)); ! 949: ! 950: asm volatile(" mulhwu %0,%1,%2" : ! 951: "=r" (t64.hi) : ! 952: "r" (timespec.tv_sec), "r" (NSEC_PER_SEC)); ! 953: ! 954: AbsoluteTime_to_scalar(&t64) += timespec.tv_nsec; ! 955: ! 956: umul_64by32(t64, denom, &t64, &t32); ! 957: ! 958: udiv_96by32(t64, t32, numer, &t64, &t32); ! 959: ! 960: result->hi = t64.lo; ! 961: result->lo = t32; ! 962: } ! 963: ! 964: void ! 965: clock_interval_to_deadline( ! 966: natural_t interval, ! 967: natural_t scale_factor, ! 968: AbsoluteTime *result) ! 969: { ! 970: AbsoluteTime abstime; ! 971: ! 972: clock_get_uptime(result); ! 973: ! 974: clock_interval_to_absolutetime_interval(interval, scale_factor, &abstime); ! 975: ! 976: ADD_ABSOLUTETIME(result, &abstime); ! 977: } ! 978: ! 979: void ! 980: clock_interval_to_absolutetime_interval( ! 981: natural_t interval, ! 982: natural_t scale_factor, ! 983: AbsoluteTime *result) ! 984: { ! 985: AbsoluteTime t64; ! 986: natural_t t32; ! 987: natural_t numer, denom; ! 988: spl_t s; ! 989: ! 990: LOCK_RTC(s); ! 991: numer = rtclock.timebase_const.numer; ! 992: denom = rtclock.timebase_const.denom; ! 993: UNLOCK_RTC(s); ! 994: ! 995: asm volatile(" mullw %0,%1,%2" : ! 996: "=r" (t64.lo) : ! 997: "r" (interval), "r" (scale_factor)); ! 998: asm volatile(" mulhwu %0,%1,%2" : ! 999: "=r" (t64.hi) : ! 1000: "r" (interval), "r" (scale_factor)); ! 1001: ! 1002: umul_64by32(t64, denom, &t64, &t32); ! 1003: ! 1004: udiv_96by32(t64, t32, numer, &t64, &t32); ! 1005: ! 1006: result->hi = t64.lo; ! 1007: result->lo = t32; ! 1008: } ! 1009: ! 1010: void ! 1011: clock_absolutetime_interval_to_deadline( ! 1012: AbsoluteTime abstime, ! 1013: AbsoluteTime *result) ! 1014: { ! 1015: clock_get_uptime(result); ! 1016: ! 1017: ADD_ABSOLUTETIME(result, &abstime); ! 1018: } ! 1019: ! 1020: void ! 1021: absolutetime_to_nanoseconds( ! 1022: AbsoluteTime abstime, ! 1023: UInt64 *result) ! 1024: { ! 1025: AbsoluteTime t64; ! 1026: natural_t t32; ! 1027: natural_t numer, denom; ! 1028: spl_t s; ! 1029: ! 1030: LOCK_RTC(s); ! 1031: numer = rtclock.timebase_const.numer; ! 1032: denom = rtclock.timebase_const.denom; ! 1033: UNLOCK_RTC(s); ! 1034: ! 1035: umul_64by32(abstime, numer, &t64, &t32); ! 1036: ! 1037: udiv_96by32to64(t64, t32, denom, (void *)result); ! 1038: } ! 1039: ! 1040: void ! 1041: nanoseconds_to_absolutetime( ! 1042: UInt64 nanoseconds, ! 1043: AbsoluteTime *result) ! 1044: { ! 1045: AbsoluteTime t64; ! 1046: natural_t t32; ! 1047: natural_t numer, denom; ! 1048: spl_t s; ! 1049: ! 1050: LOCK_RTC(s); ! 1051: numer = rtclock.timebase_const.numer; ! 1052: denom = rtclock.timebase_const.denom; ! 1053: UNLOCK_RTC(s); ! 1054: ! 1055: AbsoluteTime_to_scalar(&t64) = nanoseconds; ! 1056: ! 1057: umul_64by32(t64, denom, &t64, &t32); ! 1058: ! 1059: udiv_96by32to64(t64, t32, numer, result); ! 1060: } ! 1061: ! 1062: /* ! 1063: * Spin-loop delay primitives. ! 1064: */ ! 1065: void ! 1066: delay_for_interval( ! 1067: natural_t interval, ! 1068: natural_t scale_factor) ! 1069: { ! 1070: AbsoluteTime now, end; ! 1071: ! 1072: clock_interval_to_deadline(interval, scale_factor, &end); ! 1073: ! 1074: do { ! 1075: clock_get_uptime(&now); ! 1076: } while (CMP_ABSOLUTETIME(&now, &end) < 0); ! 1077: } ! 1078: ! 1079: void ! 1080: clock_delay_until( ! 1081: AbsoluteTime deadline) ! 1082: { ! 1083: AbsoluteTime now; ! 1084: ! 1085: do { ! 1086: clock_get_uptime(&now); ! 1087: } while (CMP_ABSOLUTETIME(&now, &deadline) < 0); ! 1088: } ! 1089: ! 1090: void ! 1091: delay( ! 1092: int usec) ! 1093: { ! 1094: delay_for_interval((usec < 0)? -usec: usec, NSEC_PER_USEC); ! 1095: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.