time.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. /*
  2. * linux/arch/m68knommu/kernel/time.c
  3. *
  4. * Copyright (C) 1991, 1992, 1995 Linus Torvalds
  5. *
  6. * This file contains the m68k-specific time handling details.
  7. * Most of the stuff is located in the machine specific files.
  8. *
  9. * 1997-09-10 Updated NTP code according to technical memorandum Jan '96
  10. * "A Kernel Model for Precision Timekeeping" by Dave Mills
  11. */
  12. #include <linux/errno.h>
  13. #include <linux/module.h>
  14. #include <linux/sched.h>
  15. #include <linux/kernel.h>
  16. #include <linux/param.h>
  17. #include <linux/string.h>
  18. #include <linux/mm.h>
  19. #include <linux/profile.h>
  20. #include <linux/time.h>
  21. #include <linux/timex.h>
  22. #include <asm/machdep.h>
  23. #include <asm/io.h>
  24. #include <asm/irq_regs.h>
  25. #define TICK_SIZE (tick_nsec / 1000)
  26. static inline int set_rtc_mmss(unsigned long nowtime)
  27. {
  28. if (mach_set_clock_mmss)
  29. return mach_set_clock_mmss (nowtime);
  30. return -1;
  31. }
  32. /*
  33. * timer_interrupt() needs to keep up the real-time clock,
  34. * as well as call the "do_timer()" routine every clocktick
  35. */
  36. irqreturn_t arch_timer_interrupt(int irq, void *dummy)
  37. {
  38. /* last time the cmos clock got updated */
  39. static long last_rtc_update=0;
  40. write_seqlock(&xtime_lock);
  41. do_timer(1);
  42. #ifndef CONFIG_SMP
  43. update_process_times(user_mode(get_irq_regs()));
  44. #endif
  45. if (current->pid)
  46. profile_tick(CPU_PROFILING);
  47. /*
  48. * If we have an externally synchronized Linux clock, then update
  49. * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
  50. * called as close as possible to 500 ms before the new second starts.
  51. */
  52. if (ntp_synced() &&
  53. xtime.tv_sec > last_rtc_update + 660 &&
  54. (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
  55. (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
  56. if (set_rtc_mmss(xtime.tv_sec) == 0)
  57. last_rtc_update = xtime.tv_sec;
  58. else
  59. last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
  60. }
  61. #ifdef CONFIG_HEARTBEAT
  62. /* use power LED as a heartbeat instead -- much more useful
  63. for debugging -- based on the version for PReP by Cort */
  64. /* acts like an actual heart beat -- ie thump-thump-pause... */
  65. if (mach_heartbeat) {
  66. static unsigned cnt = 0, period = 0, dist = 0;
  67. if (cnt == 0 || cnt == dist)
  68. mach_heartbeat( 1 );
  69. else if (cnt == 7 || cnt == dist+7)
  70. mach_heartbeat( 0 );
  71. if (++cnt > period) {
  72. cnt = 0;
  73. /* The hyperbolic function below modifies the heartbeat period
  74. * length in dependency of the current (5min) load. It goes
  75. * through the points f(0)=126, f(1)=86, f(5)=51,
  76. * f(inf)->30. */
  77. period = ((672<<FSHIFT)/(5*avenrun[0]+(7<<FSHIFT))) + 30;
  78. dist = period / 4;
  79. }
  80. }
  81. #endif /* CONFIG_HEARTBEAT */
  82. write_sequnlock(&xtime_lock);
  83. return(IRQ_HANDLED);
  84. }
  85. void time_init(void)
  86. {
  87. unsigned int year, mon, day, hour, min, sec;
  88. if (mach_gettod)
  89. mach_gettod(&year, &mon, &day, &hour, &min, &sec);
  90. else
  91. year = mon = day = hour = min = sec = 0;
  92. if ((year += 1900) < 1970)
  93. year += 100;
  94. xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  95. xtime.tv_nsec = 0;
  96. wall_to_monotonic.tv_sec = -xtime.tv_sec;
  97. hw_timer_init();
  98. }
  99. /*
  100. * This version of gettimeofday has near microsecond resolution.
  101. */
  102. void do_gettimeofday(struct timeval *tv)
  103. {
  104. unsigned long flags;
  105. unsigned long seq;
  106. unsigned long usec, sec;
  107. do {
  108. seq = read_seqbegin_irqsave(&xtime_lock, flags);
  109. usec = hw_timer_offset();
  110. sec = xtime.tv_sec;
  111. usec += (xtime.tv_nsec / 1000);
  112. } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
  113. while (usec >= 1000000) {
  114. usec -= 1000000;
  115. sec++;
  116. }
  117. tv->tv_sec = sec;
  118. tv->tv_usec = usec;
  119. }
  120. EXPORT_SYMBOL(do_gettimeofday);
  121. int do_settimeofday(struct timespec *tv)
  122. {
  123. time_t wtm_sec, sec = tv->tv_sec;
  124. long wtm_nsec, nsec = tv->tv_nsec;
  125. if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
  126. return -EINVAL;
  127. write_seqlock_irq(&xtime_lock);
  128. /*
  129. * This is revolting. We need to set the xtime.tv_usec
  130. * correctly. However, the value in this location is
  131. * is value at the last tick.
  132. * Discover what correction gettimeofday
  133. * would have done, and then undo it!
  134. */
  135. nsec -= (hw_timer_offset() * 1000);
  136. wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
  137. wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
  138. set_normalized_timespec(&xtime, sec, nsec);
  139. set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
  140. ntp_clear();
  141. write_sequnlock_irq(&xtime_lock);
  142. clock_was_set();
  143. return 0;
  144. }
  145. EXPORT_SYMBOL(do_settimeofday);