clocksource.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510
  1. /*
  2. * linux/kernel/time/clocksource.c
  3. *
  4. * This file contains the functions which manage clocksource drivers.
  5. *
  6. * Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com)
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21. *
  22. * TODO WishList:
  23. * o Allow clocksource drivers to be unregistered
  24. * o get rid of clocksource_jiffies extern
  25. */
  26. #include <linux/clocksource.h>
  27. #include <linux/sysdev.h>
  28. #include <linux/init.h>
  29. #include <linux/module.h>
  30. #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
  31. #include <linux/tick.h>
  32. /* XXX - Would like a better way for initializing curr_clocksource */
  33. extern struct clocksource clocksource_jiffies;
  34. /*[Clocksource internal variables]---------
  35. * curr_clocksource:
  36. * currently selected clocksource. Initialized to clocksource_jiffies.
  37. * next_clocksource:
  38. * pending next selected clocksource.
  39. * clocksource_list:
  40. * linked list with the registered clocksources
  41. * clocksource_lock:
  42. * protects manipulations to curr_clocksource and next_clocksource
  43. * and the clocksource_list
  44. * override_name:
  45. * Name of the user-specified clocksource.
  46. */
  47. static struct clocksource *curr_clocksource = &clocksource_jiffies;
  48. static struct clocksource *next_clocksource;
  49. static struct clocksource *clocksource_override;
  50. static LIST_HEAD(clocksource_list);
  51. static DEFINE_SPINLOCK(clocksource_lock);
  52. static char override_name[32];
  53. static int finished_booting;
  54. /* clocksource_done_booting - Called near the end of core bootup
  55. *
  56. * Hack to avoid lots of clocksource churn at boot time.
  57. * We use fs_initcall because we want this to start before
  58. * device_initcall but after subsys_initcall.
  59. */
  60. static int __init clocksource_done_booting(void)
  61. {
  62. finished_booting = 1;
  63. return 0;
  64. }
  65. fs_initcall(clocksource_done_booting);
  66. #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
  67. static LIST_HEAD(watchdog_list);
  68. static struct clocksource *watchdog;
  69. static struct timer_list watchdog_timer;
  70. static DEFINE_SPINLOCK(watchdog_lock);
  71. static cycle_t watchdog_last;
  72. static unsigned long watchdog_resumed;
  73. /*
  74. * Interval: 0.5sec Threshold: 0.0625s
  75. */
  76. #define WATCHDOG_INTERVAL (HZ >> 1)
  77. #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
  78. static void clocksource_ratewd(struct clocksource *cs, int64_t delta)
  79. {
  80. if (delta > -WATCHDOG_THRESHOLD && delta < WATCHDOG_THRESHOLD)
  81. return;
  82. printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
  83. cs->name, delta);
  84. cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
  85. clocksource_change_rating(cs, 0);
  86. cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
  87. list_del(&cs->wd_list);
  88. }
  89. static void clocksource_watchdog(unsigned long data)
  90. {
  91. struct clocksource *cs, *tmp;
  92. cycle_t csnow, wdnow;
  93. int64_t wd_nsec, cs_nsec;
  94. int resumed;
  95. spin_lock(&watchdog_lock);
  96. resumed = test_and_clear_bit(0, &watchdog_resumed);
  97. wdnow = watchdog->read();
  98. wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
  99. watchdog_last = wdnow;
  100. list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
  101. csnow = cs->read();
  102. if (unlikely(resumed)) {
  103. cs->wd_last = csnow;
  104. continue;
  105. }
  106. /* Initialized ? */
  107. if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
  108. if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
  109. (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
  110. cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
  111. /*
  112. * We just marked the clocksource as
  113. * highres-capable, notify the rest of the
  114. * system as well so that we transition
  115. * into high-res mode:
  116. */
  117. tick_clock_notify();
  118. }
  119. cs->flags |= CLOCK_SOURCE_WATCHDOG;
  120. cs->wd_last = csnow;
  121. } else {
  122. cs_nsec = cyc2ns(cs, (csnow - cs->wd_last) & cs->mask);
  123. cs->wd_last = csnow;
  124. /* Check the delta. Might remove from the list ! */
  125. clocksource_ratewd(cs, cs_nsec - wd_nsec);
  126. }
  127. }
  128. if (!list_empty(&watchdog_list)) {
  129. __mod_timer(&watchdog_timer,
  130. watchdog_timer.expires + WATCHDOG_INTERVAL);
  131. }
  132. spin_unlock(&watchdog_lock);
  133. }
  134. static void clocksource_resume_watchdog(void)
  135. {
  136. set_bit(0, &watchdog_resumed);
  137. }
  138. static void clocksource_check_watchdog(struct clocksource *cs)
  139. {
  140. struct clocksource *cse;
  141. unsigned long flags;
  142. spin_lock_irqsave(&watchdog_lock, flags);
  143. if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
  144. int started = !list_empty(&watchdog_list);
  145. list_add(&cs->wd_list, &watchdog_list);
  146. if (!started && watchdog) {
  147. watchdog_last = watchdog->read();
  148. watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
  149. add_timer(&watchdog_timer);
  150. }
  151. } else {
  152. if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
  153. cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
  154. if (!watchdog || cs->rating > watchdog->rating) {
  155. if (watchdog)
  156. del_timer(&watchdog_timer);
  157. watchdog = cs;
  158. init_timer(&watchdog_timer);
  159. watchdog_timer.function = clocksource_watchdog;
  160. /* Reset watchdog cycles */
  161. list_for_each_entry(cse, &watchdog_list, wd_list)
  162. cse->flags &= ~CLOCK_SOURCE_WATCHDOG;
  163. /* Start if list is not empty */
  164. if (!list_empty(&watchdog_list)) {
  165. watchdog_last = watchdog->read();
  166. watchdog_timer.expires =
  167. jiffies + WATCHDOG_INTERVAL;
  168. add_timer(&watchdog_timer);
  169. }
  170. }
  171. }
  172. spin_unlock_irqrestore(&watchdog_lock, flags);
  173. }
  174. #else
  175. static void clocksource_check_watchdog(struct clocksource *cs)
  176. {
  177. if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
  178. cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
  179. }
  180. static inline void clocksource_resume_watchdog(void) { }
  181. #endif
  182. /**
  183. * clocksource_resume - resume the clocksource(s)
  184. */
  185. void clocksource_resume(void)
  186. {
  187. struct clocksource *cs;
  188. unsigned long flags;
  189. spin_lock_irqsave(&clocksource_lock, flags);
  190. list_for_each_entry(cs, &clocksource_list, list) {
  191. if (cs->resume)
  192. cs->resume();
  193. }
  194. clocksource_resume_watchdog();
  195. spin_unlock_irqrestore(&clocksource_lock, flags);
  196. }
  197. /**
  198. * clocksource_get_next - Returns the selected clocksource
  199. *
  200. */
  201. struct clocksource *clocksource_get_next(void)
  202. {
  203. unsigned long flags;
  204. spin_lock_irqsave(&clocksource_lock, flags);
  205. if (next_clocksource && finished_booting) {
  206. curr_clocksource = next_clocksource;
  207. next_clocksource = NULL;
  208. }
  209. spin_unlock_irqrestore(&clocksource_lock, flags);
  210. return curr_clocksource;
  211. }
  212. /**
  213. * select_clocksource - Selects the best registered clocksource.
  214. *
  215. * Private function. Must hold clocksource_lock when called.
  216. *
  217. * Select the clocksource with the best rating, or the clocksource,
  218. * which is selected by userspace override.
  219. */
  220. static struct clocksource *select_clocksource(void)
  221. {
  222. struct clocksource *next;
  223. if (list_empty(&clocksource_list))
  224. return NULL;
  225. if (clocksource_override)
  226. next = clocksource_override;
  227. else
  228. next = list_entry(clocksource_list.next, struct clocksource,
  229. list);
  230. if (next == curr_clocksource)
  231. return NULL;
  232. return next;
  233. }
  234. /*
  235. * Enqueue the clocksource sorted by rating
  236. */
  237. static int clocksource_enqueue(struct clocksource *c)
  238. {
  239. struct list_head *tmp, *entry = &clocksource_list;
  240. list_for_each(tmp, &clocksource_list) {
  241. struct clocksource *cs;
  242. cs = list_entry(tmp, struct clocksource, list);
  243. if (cs == c)
  244. return -EBUSY;
  245. /* Keep track of the place, where to insert */
  246. if (cs->rating >= c->rating)
  247. entry = tmp;
  248. }
  249. list_add(&c->list, entry);
  250. if (strlen(c->name) == strlen(override_name) &&
  251. !strcmp(c->name, override_name))
  252. clocksource_override = c;
  253. return 0;
  254. }
  255. /**
  256. * clocksource_register - Used to install new clocksources
  257. * @t: clocksource to be registered
  258. *
  259. * Returns -EBUSY if registration fails, zero otherwise.
  260. */
  261. int clocksource_register(struct clocksource *c)
  262. {
  263. unsigned long flags;
  264. int ret;
  265. spin_lock_irqsave(&clocksource_lock, flags);
  266. ret = clocksource_enqueue(c);
  267. if (!ret)
  268. next_clocksource = select_clocksource();
  269. spin_unlock_irqrestore(&clocksource_lock, flags);
  270. if (!ret)
  271. clocksource_check_watchdog(c);
  272. return ret;
  273. }
  274. EXPORT_SYMBOL(clocksource_register);
  275. /**
  276. * clocksource_change_rating - Change the rating of a registered clocksource
  277. *
  278. */
  279. void clocksource_change_rating(struct clocksource *cs, int rating)
  280. {
  281. unsigned long flags;
  282. spin_lock_irqsave(&clocksource_lock, flags);
  283. list_del(&cs->list);
  284. cs->rating = rating;
  285. clocksource_enqueue(cs);
  286. next_clocksource = select_clocksource();
  287. spin_unlock_irqrestore(&clocksource_lock, flags);
  288. }
  289. #ifdef CONFIG_SYSFS
  290. /**
  291. * sysfs_show_current_clocksources - sysfs interface for current clocksource
  292. * @dev: unused
  293. * @buf: char buffer to be filled with clocksource list
  294. *
  295. * Provides sysfs interface for listing current clocksource.
  296. */
  297. static ssize_t
  298. sysfs_show_current_clocksources(struct sys_device *dev, char *buf)
  299. {
  300. char *curr = buf;
  301. spin_lock_irq(&clocksource_lock);
  302. curr += sprintf(curr, "%s ", curr_clocksource->name);
  303. spin_unlock_irq(&clocksource_lock);
  304. curr += sprintf(curr, "\n");
  305. return curr - buf;
  306. }
  307. /**
  308. * sysfs_override_clocksource - interface for manually overriding clocksource
  309. * @dev: unused
  310. * @buf: name of override clocksource
  311. * @count: length of buffer
  312. *
  313. * Takes input from sysfs interface for manually overriding the default
  314. * clocksource selction.
  315. */
  316. static ssize_t sysfs_override_clocksource(struct sys_device *dev,
  317. const char *buf, size_t count)
  318. {
  319. struct clocksource *ovr = NULL;
  320. size_t ret = count;
  321. int len;
  322. /* strings from sysfs write are not 0 terminated! */
  323. if (count >= sizeof(override_name))
  324. return -EINVAL;
  325. /* strip of \n: */
  326. if (buf[count-1] == '\n')
  327. count--;
  328. spin_lock_irq(&clocksource_lock);
  329. if (count > 0)
  330. memcpy(override_name, buf, count);
  331. override_name[count] = 0;
  332. len = strlen(override_name);
  333. if (len) {
  334. struct clocksource *cs;
  335. ovr = clocksource_override;
  336. /* try to select it: */
  337. list_for_each_entry(cs, &clocksource_list, list) {
  338. if (strlen(cs->name) == len &&
  339. !strcmp(cs->name, override_name))
  340. ovr = cs;
  341. }
  342. }
  343. /* Reselect, when the override name has changed */
  344. if (ovr != clocksource_override) {
  345. clocksource_override = ovr;
  346. next_clocksource = select_clocksource();
  347. }
  348. spin_unlock_irq(&clocksource_lock);
  349. return ret;
  350. }
  351. /**
  352. * sysfs_show_available_clocksources - sysfs interface for listing clocksource
  353. * @dev: unused
  354. * @buf: char buffer to be filled with clocksource list
  355. *
  356. * Provides sysfs interface for listing registered clocksources
  357. */
  358. static ssize_t
  359. sysfs_show_available_clocksources(struct sys_device *dev, char *buf)
  360. {
  361. struct clocksource *src;
  362. char *curr = buf;
  363. spin_lock_irq(&clocksource_lock);
  364. list_for_each_entry(src, &clocksource_list, list) {
  365. curr += sprintf(curr, "%s ", src->name);
  366. }
  367. spin_unlock_irq(&clocksource_lock);
  368. curr += sprintf(curr, "\n");
  369. return curr - buf;
  370. }
  371. /*
  372. * Sysfs setup bits:
  373. */
  374. static SYSDEV_ATTR(current_clocksource, 0600, sysfs_show_current_clocksources,
  375. sysfs_override_clocksource);
  376. static SYSDEV_ATTR(available_clocksource, 0600,
  377. sysfs_show_available_clocksources, NULL);
  378. static struct sysdev_class clocksource_sysclass = {
  379. .name = "clocksource",
  380. };
  381. static struct sys_device device_clocksource = {
  382. .id = 0,
  383. .cls = &clocksource_sysclass,
  384. };
  385. static int __init init_clocksource_sysfs(void)
  386. {
  387. int error = sysdev_class_register(&clocksource_sysclass);
  388. if (!error)
  389. error = sysdev_register(&device_clocksource);
  390. if (!error)
  391. error = sysdev_create_file(
  392. &device_clocksource,
  393. &attr_current_clocksource);
  394. if (!error)
  395. error = sysdev_create_file(
  396. &device_clocksource,
  397. &attr_available_clocksource);
  398. return error;
  399. }
  400. device_initcall(init_clocksource_sysfs);
  401. #endif /* CONFIG_SYSFS */
  402. /**
  403. * boot_override_clocksource - boot clock override
  404. * @str: override name
  405. *
  406. * Takes a clocksource= boot argument and uses it
  407. * as the clocksource override name.
  408. */
  409. static int __init boot_override_clocksource(char* str)
  410. {
  411. unsigned long flags;
  412. spin_lock_irqsave(&clocksource_lock, flags);
  413. if (str)
  414. strlcpy(override_name, str, sizeof(override_name));
  415. spin_unlock_irqrestore(&clocksource_lock, flags);
  416. return 1;
  417. }
  418. __setup("clocksource=", boot_override_clocksource);
  419. /**
  420. * boot_override_clock - Compatibility layer for deprecated boot option
  421. * @str: override name
  422. *
  423. * DEPRECATED! Takes a clock= boot argument and uses it
  424. * as the clocksource override name
  425. */
  426. static int __init boot_override_clock(char* str)
  427. {
  428. if (!strcmp(str, "pmtmr")) {
  429. printk("Warning: clock=pmtmr is deprecated. "
  430. "Use clocksource=acpi_pm.\n");
  431. return boot_override_clocksource("acpi_pm");
  432. }
  433. printk("Warning! clock= boot option is deprecated. "
  434. "Use clocksource=xyz\n");
  435. return boot_override_clocksource(str);
  436. }
  437. __setup("clock=", boot_override_clock);