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