time.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516
  1. /*
  2. * linux/arch/arm/kernel/time.c
  3. *
  4. * Copyright (C) 1991, 1992, 1995 Linus Torvalds
  5. * Modifications for ARM (C) 1994-2001 Russell King
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 as
  9. * published by the Free Software Foundation.
  10. *
  11. * This file contains the ARM-specific time handling details:
  12. * reading the RTC at bootup, etc...
  13. *
  14. * 1994-07-02 Alan Modra
  15. * fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
  16. * 1998-12-20 Updated NTP code according to technical memorandum Jan '96
  17. * "A Kernel Model for Precision Timekeeping" by Dave Mills
  18. */
  19. #include <linux/module.h>
  20. #include <linux/kernel.h>
  21. #include <linux/interrupt.h>
  22. #include <linux/time.h>
  23. #include <linux/init.h>
  24. #include <linux/smp.h>
  25. #include <linux/timex.h>
  26. #include <linux/errno.h>
  27. #include <linux/profile.h>
  28. #include <linux/sysdev.h>
  29. #include <linux/timer.h>
  30. #include <linux/irq.h>
  31. #include <linux/mc146818rtc.h>
  32. #include <asm/leds.h>
  33. #include <asm/thread_info.h>
  34. #include <asm/mach/time.h>
  35. /*
  36. * Our system timer.
  37. */
  38. struct sys_timer *system_timer;
  39. #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
  40. /* this needs a better home */
  41. DEFINE_SPINLOCK(rtc_lock);
  42. #ifdef CONFIG_RTC_DRV_CMOS_MODULE
  43. EXPORT_SYMBOL(rtc_lock);
  44. #endif
  45. #endif /* pc-style 'CMOS' RTC support */
  46. /* change this if you have some constant time drift */
  47. #define USECS_PER_JIFFY (1000000/HZ)
  48. #ifdef CONFIG_SMP
  49. unsigned long profile_pc(struct pt_regs *regs)
  50. {
  51. unsigned long fp, pc = instruction_pointer(regs);
  52. if (in_lock_functions(pc)) {
  53. fp = regs->ARM_fp;
  54. pc = pc_pointer(((unsigned long *)fp)[-1]);
  55. }
  56. return pc;
  57. }
  58. EXPORT_SYMBOL(profile_pc);
  59. #endif
  60. /*
  61. * hook for setting the RTC's idea of the current time.
  62. */
  63. int (*set_rtc)(void);
  64. #ifndef CONFIG_GENERIC_TIME
  65. static unsigned long dummy_gettimeoffset(void)
  66. {
  67. return 0;
  68. }
  69. #endif
  70. /*
  71. * An implementation of printk_clock() independent from
  72. * sched_clock(). This avoids non-bootable kernels when
  73. * printk_clock is enabled.
  74. */
  75. unsigned long long printk_clock(void)
  76. {
  77. return (unsigned long long)(jiffies - INITIAL_JIFFIES) *
  78. (1000000000 / HZ);
  79. }
  80. static unsigned long next_rtc_update;
  81. /*
  82. * If we have an externally synchronized linux clock, then update
  83. * CMOS clock accordingly every ~11 minutes. set_rtc() has to be
  84. * called as close as possible to 500 ms before the new second
  85. * starts.
  86. */
  87. static inline void do_set_rtc(void)
  88. {
  89. if (!ntp_synced() || set_rtc == NULL)
  90. return;
  91. if (next_rtc_update &&
  92. time_before((unsigned long)xtime.tv_sec, next_rtc_update))
  93. return;
  94. if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
  95. xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
  96. return;
  97. if (set_rtc())
  98. /*
  99. * rtc update failed. Try again in 60s
  100. */
  101. next_rtc_update = xtime.tv_sec + 60;
  102. else
  103. next_rtc_update = xtime.tv_sec + 660;
  104. }
  105. #ifdef CONFIG_LEDS
  106. static void dummy_leds_event(led_event_t evt)
  107. {
  108. }
  109. void (*leds_event)(led_event_t) = dummy_leds_event;
  110. struct leds_evt_name {
  111. const char name[8];
  112. int on;
  113. int off;
  114. };
  115. static const struct leds_evt_name evt_names[] = {
  116. { "amber", led_amber_on, led_amber_off },
  117. { "blue", led_blue_on, led_blue_off },
  118. { "green", led_green_on, led_green_off },
  119. { "red", led_red_on, led_red_off },
  120. };
  121. static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
  122. {
  123. int ret = -EINVAL, len = strcspn(buf, " ");
  124. if (len > 0 && buf[len] == '\0')
  125. len--;
  126. if (strncmp(buf, "claim", len) == 0) {
  127. leds_event(led_claim);
  128. ret = size;
  129. } else if (strncmp(buf, "release", len) == 0) {
  130. leds_event(led_release);
  131. ret = size;
  132. } else {
  133. int i;
  134. for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
  135. if (strlen(evt_names[i].name) != len ||
  136. strncmp(buf, evt_names[i].name, len) != 0)
  137. continue;
  138. if (strncmp(buf+len, " on", 3) == 0) {
  139. leds_event(evt_names[i].on);
  140. ret = size;
  141. } else if (strncmp(buf+len, " off", 4) == 0) {
  142. leds_event(evt_names[i].off);
  143. ret = size;
  144. }
  145. break;
  146. }
  147. }
  148. return ret;
  149. }
  150. static SYSDEV_ATTR(event, 0200, NULL, leds_store);
  151. static int leds_suspend(struct sys_device *dev, pm_message_t state)
  152. {
  153. leds_event(led_stop);
  154. return 0;
  155. }
  156. static int leds_resume(struct sys_device *dev)
  157. {
  158. leds_event(led_start);
  159. return 0;
  160. }
  161. static int leds_shutdown(struct sys_device *dev)
  162. {
  163. leds_event(led_halted);
  164. return 0;
  165. }
  166. static struct sysdev_class leds_sysclass = {
  167. set_kset_name("leds"),
  168. .shutdown = leds_shutdown,
  169. .suspend = leds_suspend,
  170. .resume = leds_resume,
  171. };
  172. static struct sys_device leds_device = {
  173. .id = 0,
  174. .cls = &leds_sysclass,
  175. };
  176. static int __init leds_init(void)
  177. {
  178. int ret;
  179. ret = sysdev_class_register(&leds_sysclass);
  180. if (ret == 0)
  181. ret = sysdev_register(&leds_device);
  182. if (ret == 0)
  183. ret = sysdev_create_file(&leds_device, &attr_event);
  184. return ret;
  185. }
  186. device_initcall(leds_init);
  187. EXPORT_SYMBOL(leds_event);
  188. #endif
  189. #ifdef CONFIG_LEDS_TIMER
  190. static inline void do_leds(void)
  191. {
  192. static unsigned int count = HZ/2;
  193. if (--count == 0) {
  194. count = HZ/2;
  195. leds_event(led_timer);
  196. }
  197. }
  198. #else
  199. #define do_leds()
  200. #endif
  201. #ifndef CONFIG_GENERIC_TIME
  202. void do_gettimeofday(struct timeval *tv)
  203. {
  204. unsigned long flags;
  205. unsigned long seq;
  206. unsigned long usec, sec;
  207. do {
  208. seq = read_seqbegin_irqsave(&xtime_lock, flags);
  209. usec = system_timer->offset();
  210. sec = xtime.tv_sec;
  211. usec += xtime.tv_nsec / 1000;
  212. } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
  213. /* usec may have gone up a lot: be safe */
  214. while (usec >= 1000000) {
  215. usec -= 1000000;
  216. sec++;
  217. }
  218. tv->tv_sec = sec;
  219. tv->tv_usec = usec;
  220. }
  221. EXPORT_SYMBOL(do_gettimeofday);
  222. int do_settimeofday(struct timespec *tv)
  223. {
  224. time_t wtm_sec, sec = tv->tv_sec;
  225. long wtm_nsec, nsec = tv->tv_nsec;
  226. if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
  227. return -EINVAL;
  228. write_seqlock_irq(&xtime_lock);
  229. /*
  230. * This is revolting. We need to set "xtime" correctly. However, the
  231. * value in this location is the value at the most recent update of
  232. * wall time. Discover what correction gettimeofday() would have
  233. * done, and then undo it!
  234. */
  235. nsec -= system_timer->offset() * NSEC_PER_USEC;
  236. wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
  237. wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
  238. set_normalized_timespec(&xtime, sec, nsec);
  239. set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
  240. ntp_clear();
  241. write_sequnlock_irq(&xtime_lock);
  242. clock_was_set();
  243. return 0;
  244. }
  245. EXPORT_SYMBOL(do_settimeofday);
  246. #endif /* !CONFIG_GENERIC_TIME */
  247. /**
  248. * save_time_delta - Save the offset between system time and RTC time
  249. * @delta: pointer to timespec to store delta
  250. * @rtc: pointer to timespec for current RTC time
  251. *
  252. * Return a delta between the system time and the RTC time, such
  253. * that system time can be restored later with restore_time_delta()
  254. */
  255. void save_time_delta(struct timespec *delta, struct timespec *rtc)
  256. {
  257. set_normalized_timespec(delta,
  258. xtime.tv_sec - rtc->tv_sec,
  259. xtime.tv_nsec - rtc->tv_nsec);
  260. }
  261. EXPORT_SYMBOL(save_time_delta);
  262. /**
  263. * restore_time_delta - Restore the current system time
  264. * @delta: delta returned by save_time_delta()
  265. * @rtc: pointer to timespec for current RTC time
  266. */
  267. void restore_time_delta(struct timespec *delta, struct timespec *rtc)
  268. {
  269. struct timespec ts;
  270. set_normalized_timespec(&ts,
  271. delta->tv_sec + rtc->tv_sec,
  272. delta->tv_nsec + rtc->tv_nsec);
  273. do_settimeofday(&ts);
  274. }
  275. EXPORT_SYMBOL(restore_time_delta);
  276. /*
  277. * Kernel system timer support.
  278. */
  279. void timer_tick(void)
  280. {
  281. profile_tick(CPU_PROFILING);
  282. do_leds();
  283. do_set_rtc();
  284. do_timer(1);
  285. #ifndef CONFIG_SMP
  286. update_process_times(user_mode(get_irq_regs()));
  287. #endif
  288. }
  289. #ifdef CONFIG_PM
  290. static int timer_suspend(struct sys_device *dev, pm_message_t state)
  291. {
  292. struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
  293. if (timer->suspend != NULL)
  294. timer->suspend();
  295. return 0;
  296. }
  297. static int timer_resume(struct sys_device *dev)
  298. {
  299. struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
  300. if (timer->resume != NULL)
  301. timer->resume();
  302. return 0;
  303. }
  304. #else
  305. #define timer_suspend NULL
  306. #define timer_resume NULL
  307. #endif
  308. static struct sysdev_class timer_sysclass = {
  309. set_kset_name("timer"),
  310. .suspend = timer_suspend,
  311. .resume = timer_resume,
  312. };
  313. #ifdef CONFIG_NO_IDLE_HZ
  314. static int timer_dyn_tick_enable(void)
  315. {
  316. struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
  317. unsigned long flags;
  318. int ret = -ENODEV;
  319. if (dyn_tick) {
  320. spin_lock_irqsave(&dyn_tick->lock, flags);
  321. ret = 0;
  322. if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
  323. ret = dyn_tick->enable();
  324. if (ret == 0)
  325. dyn_tick->state |= DYN_TICK_ENABLED;
  326. }
  327. spin_unlock_irqrestore(&dyn_tick->lock, flags);
  328. }
  329. return ret;
  330. }
  331. static int timer_dyn_tick_disable(void)
  332. {
  333. struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
  334. unsigned long flags;
  335. int ret = -ENODEV;
  336. if (dyn_tick) {
  337. spin_lock_irqsave(&dyn_tick->lock, flags);
  338. ret = 0;
  339. if (dyn_tick->state & DYN_TICK_ENABLED) {
  340. ret = dyn_tick->disable();
  341. if (ret == 0)
  342. dyn_tick->state &= ~DYN_TICK_ENABLED;
  343. }
  344. spin_unlock_irqrestore(&dyn_tick->lock, flags);
  345. }
  346. return ret;
  347. }
  348. /*
  349. * Reprogram the system timer for at least the calculated time interval.
  350. * This function should be called from the idle thread with IRQs disabled,
  351. * immediately before sleeping.
  352. */
  353. void timer_dyn_reprogram(void)
  354. {
  355. struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
  356. unsigned long next, seq, flags;
  357. if (!dyn_tick)
  358. return;
  359. spin_lock_irqsave(&dyn_tick->lock, flags);
  360. if (dyn_tick->state & DYN_TICK_ENABLED) {
  361. next = next_timer_interrupt();
  362. do {
  363. seq = read_seqbegin(&xtime_lock);
  364. dyn_tick->reprogram(next - jiffies);
  365. } while (read_seqretry(&xtime_lock, seq));
  366. }
  367. spin_unlock_irqrestore(&dyn_tick->lock, flags);
  368. }
  369. static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
  370. {
  371. return sprintf(buf, "%i\n",
  372. (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
  373. }
  374. static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
  375. size_t count)
  376. {
  377. unsigned int enable = simple_strtoul(buf, NULL, 2);
  378. if (enable)
  379. timer_dyn_tick_enable();
  380. else
  381. timer_dyn_tick_disable();
  382. return count;
  383. }
  384. static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
  385. /*
  386. * dyntick=enable|disable
  387. */
  388. static char dyntick_str[4] __initdata = "";
  389. static int __init dyntick_setup(char *str)
  390. {
  391. if (str)
  392. strlcpy(dyntick_str, str, sizeof(dyntick_str));
  393. return 1;
  394. }
  395. __setup("dyntick=", dyntick_setup);
  396. #endif
  397. static int __init timer_init_sysfs(void)
  398. {
  399. int ret = sysdev_class_register(&timer_sysclass);
  400. if (ret == 0) {
  401. system_timer->dev.cls = &timer_sysclass;
  402. ret = sysdev_register(&system_timer->dev);
  403. }
  404. #ifdef CONFIG_NO_IDLE_HZ
  405. if (ret == 0 && system_timer->dyn_tick) {
  406. ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
  407. /*
  408. * Turn on dynamic tick after calibrate delay
  409. * for correct bogomips
  410. */
  411. if (ret == 0 && dyntick_str[0] == 'e')
  412. ret = timer_dyn_tick_enable();
  413. }
  414. #endif
  415. return ret;
  416. }
  417. device_initcall(timer_init_sysfs);
  418. void __init time_init(void)
  419. {
  420. #ifndef CONFIG_GENERIC_TIME
  421. if (system_timer->offset == NULL)
  422. system_timer->offset = dummy_gettimeoffset;
  423. #endif
  424. system_timer->init();
  425. #ifdef CONFIG_NO_IDLE_HZ
  426. if (system_timer->dyn_tick)
  427. system_timer->dyn_tick->lock = SPIN_LOCK_UNLOCKED;
  428. #endif
  429. }