1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28#include <linux/device.h>
29#include <linux/clocksource.h>
30#include <linux/init.h>
31#include <linux/module.h>
32#include <linux/sched.h>
33#include <linux/tick.h>
34#include <linux/kthread.h>
35
36#include "tick-internal.h"
37#include "timekeeping_internal.h"
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62void
63clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec)
64{
65 u64 tmp;
66 u32 sft, sftacc= 32;
67
68
69
70
71
72 tmp = ((u64)maxsec * from) >> 32;
73 while (tmp) {
74 tmp >>=1;
75 sftacc--;
76 }
77
78
79
80
81
82 for (sft = 32; sft > 0; sft--) {
83 tmp = (u64) to << sft;
84 tmp += from / 2;
85 do_div(tmp, from);
86 if ((tmp >> sftacc) == 0)
87 break;
88 }
89 *mult = tmp;
90 *shift = sft;
91}
92EXPORT_SYMBOL_GPL(clocks_calc_mult_shift);
93
94
95
96
97
98
99
100
101
102
103
104static struct clocksource *curr_clocksource;
105static LIST_HEAD(clocksource_list);
106static DEFINE_MUTEX(clocksource_mutex);
107static char override_name[CS_NAME_LEN];
108static int finished_booting;
109
110#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
111static void clocksource_watchdog_work(struct work_struct *work);
112static void clocksource_select(void);
113
114static LIST_HEAD(watchdog_list);
115static struct clocksource *watchdog;
116static struct timer_list watchdog_timer;
117static DECLARE_WORK(watchdog_work, clocksource_watchdog_work);
118static DEFINE_SPINLOCK(watchdog_lock);
119static int watchdog_running;
120static atomic_t watchdog_reset_pending;
121
122static int clocksource_watchdog_kthread(void *data);
123static void __clocksource_change_rating(struct clocksource *cs, int rating);
124
125
126
127
128#define WATCHDOG_INTERVAL (HZ >> 1)
129#define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
130
131static void clocksource_watchdog_work(struct work_struct *work)
132{
133
134
135
136
137 kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");
138}
139
140static void __clocksource_unstable(struct clocksource *cs)
141{
142 cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
143 cs->flags |= CLOCK_SOURCE_UNSTABLE;
144
145 if (cs->mark_unstable)
146 cs->mark_unstable(cs);
147
148 if (finished_booting)
149 schedule_work(&watchdog_work);
150}
151
152
153
154
155
156
157
158
159
160
161void clocksource_mark_unstable(struct clocksource *cs)
162{
163 unsigned long flags;
164
165 spin_lock_irqsave(&watchdog_lock, flags);
166 if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) {
167 if (list_empty(&cs->wd_list))
168 list_add(&cs->wd_list, &watchdog_list);
169 __clocksource_unstable(cs);
170 }
171 spin_unlock_irqrestore(&watchdog_lock, flags);
172}
173
174static void clocksource_watchdog(struct timer_list *unused)
175{
176 struct clocksource *cs;
177 u64 csnow, wdnow, cslast, wdlast, delta;
178 int64_t wd_nsec, cs_nsec;
179 int next_cpu, reset_pending;
180
181 spin_lock(&watchdog_lock);
182 if (!watchdog_running)
183 goto out;
184
185 reset_pending = atomic_read(&watchdog_reset_pending);
186
187 list_for_each_entry(cs, &watchdog_list, wd_list) {
188
189
190 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
191 if (finished_booting)
192 schedule_work(&watchdog_work);
193 continue;
194 }
195
196 local_irq_disable();
197 csnow = cs->read(cs);
198 wdnow = watchdog->read(watchdog);
199 local_irq_enable();
200
201
202 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) ||
203 atomic_read(&watchdog_reset_pending)) {
204 cs->flags |= CLOCK_SOURCE_WATCHDOG;
205 cs->wd_last = wdnow;
206 cs->cs_last = csnow;
207 continue;
208 }
209
210 delta = clocksource_delta(wdnow, cs->wd_last, watchdog->mask);
211 wd_nsec = clocksource_cyc2ns(delta, watchdog->mult,
212 watchdog->shift);
213
214 delta = clocksource_delta(csnow, cs->cs_last, cs->mask);
215 cs_nsec = clocksource_cyc2ns(delta, cs->mult, cs->shift);
216 wdlast = cs->wd_last;
217 cslast = cs->cs_last;
218 cs->cs_last = csnow;
219 cs->wd_last = wdnow;
220
221 if (atomic_read(&watchdog_reset_pending))
222 continue;
223
224
225 if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) {
226 pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n",
227 smp_processor_id(), cs->name);
228 pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n",
229 watchdog->name, wdnow, wdlast, watchdog->mask);
230 pr_warn(" '%s' cs_now: %llx cs_last: %llx mask: %llx\n",
231 cs->name, csnow, cslast, cs->mask);
232 __clocksource_unstable(cs);
233 continue;
234 }
235
236 if (cs == curr_clocksource && cs->tick_stable)
237 cs->tick_stable(cs);
238
239 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
240 (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
241 (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
242
243 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
244
245
246
247
248
249 if (!finished_booting)
250 continue;
251
252
253
254
255
256
257
258
259
260 if (cs != curr_clocksource) {
261 cs->flags |= CLOCK_SOURCE_RESELECT;
262 schedule_work(&watchdog_work);
263 } else {
264 tick_clock_notify();
265 }
266 }
267 }
268
269
270
271
272
273 if (reset_pending)
274 atomic_dec(&watchdog_reset_pending);
275
276
277
278
279
280 next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
281 if (next_cpu >= nr_cpu_ids)
282 next_cpu = cpumask_first(cpu_online_mask);
283 watchdog_timer.expires += WATCHDOG_INTERVAL;
284 add_timer_on(&watchdog_timer, next_cpu);
285out:
286 spin_unlock(&watchdog_lock);
287}
288
289static inline void clocksource_start_watchdog(void)
290{
291 if (watchdog_running || !watchdog || list_empty(&watchdog_list))
292 return;
293 timer_setup(&watchdog_timer, clocksource_watchdog, 0);
294 watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
295 add_timer_on(&watchdog_timer, cpumask_first(cpu_online_mask));
296 watchdog_running = 1;
297}
298
299static inline void clocksource_stop_watchdog(void)
300{
301 if (!watchdog_running || (watchdog && !list_empty(&watchdog_list)))
302 return;
303 del_timer(&watchdog_timer);
304 watchdog_running = 0;
305}
306
307static inline void clocksource_reset_watchdog(void)
308{
309 struct clocksource *cs;
310
311 list_for_each_entry(cs, &watchdog_list, wd_list)
312 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
313}
314
315static void clocksource_resume_watchdog(void)
316{
317 atomic_inc(&watchdog_reset_pending);
318}
319
320static void clocksource_enqueue_watchdog(struct clocksource *cs)
321{
322 unsigned long flags;
323
324 spin_lock_irqsave(&watchdog_lock, flags);
325 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
326
327 list_add(&cs->wd_list, &watchdog_list);
328 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
329 } else {
330
331 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
332 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
333 }
334 spin_unlock_irqrestore(&watchdog_lock, flags);
335}
336
337static void clocksource_select_watchdog(bool fallback)
338{
339 struct clocksource *cs, *old_wd;
340 unsigned long flags;
341
342 spin_lock_irqsave(&watchdog_lock, flags);
343
344 old_wd = watchdog;
345 if (fallback)
346 watchdog = NULL;
347
348 list_for_each_entry(cs, &clocksource_list, list) {
349
350 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY)
351 continue;
352
353
354 if (fallback && cs == old_wd)
355 continue;
356
357
358 if (!watchdog || cs->rating > watchdog->rating)
359 watchdog = cs;
360 }
361
362 if (!watchdog)
363 watchdog = old_wd;
364
365
366 if (watchdog != old_wd)
367 clocksource_reset_watchdog();
368
369
370 clocksource_start_watchdog();
371 spin_unlock_irqrestore(&watchdog_lock, flags);
372}
373
374static void clocksource_dequeue_watchdog(struct clocksource *cs)
375{
376 unsigned long flags;
377
378 spin_lock_irqsave(&watchdog_lock, flags);
379 if (cs != watchdog) {
380 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
381
382 list_del_init(&cs->wd_list);
383
384 clocksource_stop_watchdog();
385 }
386 }
387 spin_unlock_irqrestore(&watchdog_lock, flags);
388}
389
390static int __clocksource_watchdog_kthread(void)
391{
392 struct clocksource *cs, *tmp;
393 unsigned long flags;
394 LIST_HEAD(unstable);
395 int select = 0;
396
397 spin_lock_irqsave(&watchdog_lock, flags);
398 list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
399 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
400 list_del_init(&cs->wd_list);
401 list_add(&cs->wd_list, &unstable);
402 select = 1;
403 }
404 if (cs->flags & CLOCK_SOURCE_RESELECT) {
405 cs->flags &= ~CLOCK_SOURCE_RESELECT;
406 select = 1;
407 }
408 }
409
410 clocksource_stop_watchdog();
411 spin_unlock_irqrestore(&watchdog_lock, flags);
412
413
414 list_for_each_entry_safe(cs, tmp, &unstable, wd_list) {
415 list_del_init(&cs->wd_list);
416 __clocksource_change_rating(cs, 0);
417 }
418 return select;
419}
420
421static int clocksource_watchdog_kthread(void *data)
422{
423 mutex_lock(&clocksource_mutex);
424 if (__clocksource_watchdog_kthread())
425 clocksource_select();
426 mutex_unlock(&clocksource_mutex);
427 return 0;
428}
429
430static bool clocksource_is_watchdog(struct clocksource *cs)
431{
432 return cs == watchdog;
433}
434
435#else
436
437static void clocksource_enqueue_watchdog(struct clocksource *cs)
438{
439 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
440 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
441}
442
443static void clocksource_select_watchdog(bool fallback) { }
444static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }
445static inline void clocksource_resume_watchdog(void) { }
446static inline int __clocksource_watchdog_kthread(void) { return 0; }
447static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }
448void clocksource_mark_unstable(struct clocksource *cs) { }
449
450#endif
451
452
453
454
455void clocksource_suspend(void)
456{
457 struct clocksource *cs;
458
459 list_for_each_entry_reverse(cs, &clocksource_list, list)
460 if (cs->suspend)
461 cs->suspend(cs);
462}
463
464
465
466
467void clocksource_resume(void)
468{
469 struct clocksource *cs;
470
471 list_for_each_entry(cs, &clocksource_list, list)
472 if (cs->resume)
473 cs->resume(cs);
474
475 clocksource_resume_watchdog();
476}
477
478
479
480
481
482
483
484
485void clocksource_touch_watchdog(void)
486{
487 clocksource_resume_watchdog();
488}
489
490
491
492
493
494
495static u32 clocksource_max_adjustment(struct clocksource *cs)
496{
497 u64 ret;
498
499
500
501 ret = (u64)cs->mult * 11;
502 do_div(ret,100);
503 return (u32)ret;
504}
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521u64 clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cyc)
522{
523 u64 max_nsecs, max_cycles;
524
525
526
527
528
529 max_cycles = ULLONG_MAX;
530 do_div(max_cycles, mult+maxadj);
531
532
533
534
535
536
537
538 max_cycles = min(max_cycles, mask);
539 max_nsecs = clocksource_cyc2ns(max_cycles, mult - maxadj, shift);
540
541
542 if (max_cyc)
543 *max_cyc = max_cycles;
544
545
546 max_nsecs >>= 1;
547
548 return max_nsecs;
549}
550
551
552
553
554
555
556static inline void clocksource_update_max_deferment(struct clocksource *cs)
557{
558 cs->max_idle_ns = clocks_calc_max_nsecs(cs->mult, cs->shift,
559 cs->maxadj, cs->mask,
560 &cs->max_cycles);
561}
562
563#ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
564
565static struct clocksource *clocksource_find_best(bool oneshot, bool skipcur)
566{
567 struct clocksource *cs;
568
569 if (!finished_booting || list_empty(&clocksource_list))
570 return NULL;
571
572
573
574
575
576
577 list_for_each_entry(cs, &clocksource_list, list) {
578 if (skipcur && cs == curr_clocksource)
579 continue;
580 if (oneshot && !(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES))
581 continue;
582 return cs;
583 }
584 return NULL;
585}
586
587static void __clocksource_select(bool skipcur)
588{
589 bool oneshot = tick_oneshot_mode_active();
590 struct clocksource *best, *cs;
591
592
593 best = clocksource_find_best(oneshot, skipcur);
594 if (!best)
595 return;
596
597
598 list_for_each_entry(cs, &clocksource_list, list) {
599 if (skipcur && cs == curr_clocksource)
600 continue;
601 if (strcmp(cs->name, override_name) != 0)
602 continue;
603
604
605
606
607
608 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) && oneshot) {
609
610 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
611 pr_warn("Override clocksource %s is unstable and not HRT compatible - cannot switch while in HRT/NOHZ mode\n",
612 cs->name);
613 override_name[0] = 0;
614 } else {
615
616
617
618
619 pr_info("Override clocksource %s is not currently HRT compatible - deferring\n",
620 cs->name);
621 }
622 } else
623
624 best = cs;
625 break;
626 }
627
628 if (curr_clocksource != best && !timekeeping_notify(best)) {
629 pr_info("Switched to clocksource %s\n", best->name);
630 curr_clocksource = best;
631 }
632}
633
634
635
636
637
638
639
640
641
642static void clocksource_select(void)
643{
644 __clocksource_select(false);
645}
646
647static void clocksource_select_fallback(void)
648{
649 __clocksource_select(true);
650}
651
652#else
653static inline void clocksource_select(void) { }
654static inline void clocksource_select_fallback(void) { }
655
656#endif
657
658
659
660
661
662
663
664
665static int __init clocksource_done_booting(void)
666{
667 mutex_lock(&clocksource_mutex);
668 curr_clocksource = clocksource_default_clock();
669 finished_booting = 1;
670
671
672
673 __clocksource_watchdog_kthread();
674 clocksource_select();
675 mutex_unlock(&clocksource_mutex);
676 return 0;
677}
678fs_initcall(clocksource_done_booting);
679
680
681
682
683static void clocksource_enqueue(struct clocksource *cs)
684{
685 struct list_head *entry = &clocksource_list;
686 struct clocksource *tmp;
687
688 list_for_each_entry(tmp, &clocksource_list, list) {
689
690 if (tmp->rating < cs->rating)
691 break;
692 entry = &tmp->list;
693 }
694 list_add(&cs->list, entry);
695}
696
697
698
699
700
701
702
703
704
705
706
707
708
709void __clocksource_update_freq_scale(struct clocksource *cs, u32 scale, u32 freq)
710{
711 u64 sec;
712
713
714
715
716
717 if (freq) {
718
719
720
721
722
723
724
725
726
727 sec = cs->mask;
728 do_div(sec, freq);
729 do_div(sec, scale);
730 if (!sec)
731 sec = 1;
732 else if (sec > 600 && cs->mask > UINT_MAX)
733 sec = 600;
734
735 clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
736 NSEC_PER_SEC / scale, sec * scale);
737 }
738
739
740
741
742 cs->maxadj = clocksource_max_adjustment(cs);
743 while (freq && ((cs->mult + cs->maxadj < cs->mult)
744 || (cs->mult - cs->maxadj > cs->mult))) {
745 cs->mult >>= 1;
746 cs->shift--;
747 cs->maxadj = clocksource_max_adjustment(cs);
748 }
749
750
751
752
753
754 WARN_ONCE(cs->mult + cs->maxadj < cs->mult,
755 "timekeeping: Clocksource %s might overflow on 11%% adjustment\n",
756 cs->name);
757
758 clocksource_update_max_deferment(cs);
759
760 pr_info("%s: mask: 0x%llx max_cycles: 0x%llx, max_idle_ns: %lld ns\n",
761 cs->name, cs->mask, cs->max_cycles, cs->max_idle_ns);
762}
763EXPORT_SYMBOL_GPL(__clocksource_update_freq_scale);
764
765
766
767
768
769
770
771
772
773
774
775
776int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
777{
778
779
780 __clocksource_update_freq_scale(cs, scale, freq);
781
782
783 mutex_lock(&clocksource_mutex);
784 clocksource_enqueue(cs);
785 clocksource_enqueue_watchdog(cs);
786 clocksource_select();
787 clocksource_select_watchdog(false);
788 mutex_unlock(&clocksource_mutex);
789 return 0;
790}
791EXPORT_SYMBOL_GPL(__clocksource_register_scale);
792
793static void __clocksource_change_rating(struct clocksource *cs, int rating)
794{
795 list_del(&cs->list);
796 cs->rating = rating;
797 clocksource_enqueue(cs);
798}
799
800
801
802
803
804
805void clocksource_change_rating(struct clocksource *cs, int rating)
806{
807 mutex_lock(&clocksource_mutex);
808 __clocksource_change_rating(cs, rating);
809 clocksource_select();
810 clocksource_select_watchdog(false);
811 mutex_unlock(&clocksource_mutex);
812}
813EXPORT_SYMBOL(clocksource_change_rating);
814
815
816
817
818static int clocksource_unbind(struct clocksource *cs)
819{
820 if (clocksource_is_watchdog(cs)) {
821
822 clocksource_select_watchdog(true);
823 if (clocksource_is_watchdog(cs))
824 return -EBUSY;
825 }
826
827 if (cs == curr_clocksource) {
828
829 clocksource_select_fallback();
830 if (curr_clocksource == cs)
831 return -EBUSY;
832 }
833 clocksource_dequeue_watchdog(cs);
834 list_del_init(&cs->list);
835 return 0;
836}
837
838
839
840
841
842int clocksource_unregister(struct clocksource *cs)
843{
844 int ret = 0;
845
846 mutex_lock(&clocksource_mutex);
847 if (!list_empty(&cs->list))
848 ret = clocksource_unbind(cs);
849 mutex_unlock(&clocksource_mutex);
850 return ret;
851}
852EXPORT_SYMBOL(clocksource_unregister);
853
854#ifdef CONFIG_SYSFS
855
856
857
858
859
860
861
862
863static ssize_t
864sysfs_show_current_clocksources(struct device *dev,
865 struct device_attribute *attr, char *buf)
866{
867 ssize_t count = 0;
868
869 mutex_lock(&clocksource_mutex);
870 count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
871 mutex_unlock(&clocksource_mutex);
872
873 return count;
874}
875
876ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt)
877{
878 size_t ret = cnt;
879
880
881 if (!cnt || cnt >= CS_NAME_LEN)
882 return -EINVAL;
883
884
885 if (buf[cnt-1] == '\n')
886 cnt--;
887 if (cnt > 0)
888 memcpy(dst, buf, cnt);
889 dst[cnt] = 0;
890 return ret;
891}
892
893
894
895
896
897
898
899
900
901
902
903static ssize_t sysfs_override_clocksource(struct device *dev,
904 struct device_attribute *attr,
905 const char *buf, size_t count)
906{
907 ssize_t ret;
908
909 mutex_lock(&clocksource_mutex);
910
911 ret = sysfs_get_uname(buf, override_name, count);
912 if (ret >= 0)
913 clocksource_select();
914
915 mutex_unlock(&clocksource_mutex);
916
917 return ret;
918}
919
920
921
922
923
924
925
926
927
928
929static ssize_t sysfs_unbind_clocksource(struct device *dev,
930 struct device_attribute *attr,
931 const char *buf, size_t count)
932{
933 struct clocksource *cs;
934 char name[CS_NAME_LEN];
935 ssize_t ret;
936
937 ret = sysfs_get_uname(buf, name, count);
938 if (ret < 0)
939 return ret;
940
941 ret = -ENODEV;
942 mutex_lock(&clocksource_mutex);
943 list_for_each_entry(cs, &clocksource_list, list) {
944 if (strcmp(cs->name, name))
945 continue;
946 ret = clocksource_unbind(cs);
947 break;
948 }
949 mutex_unlock(&clocksource_mutex);
950
951 return ret ? ret : count;
952}
953
954
955
956
957
958
959
960
961
962static ssize_t
963sysfs_show_available_clocksources(struct device *dev,
964 struct device_attribute *attr,
965 char *buf)
966{
967 struct clocksource *src;
968 ssize_t count = 0;
969
970 mutex_lock(&clocksource_mutex);
971 list_for_each_entry(src, &clocksource_list, list) {
972
973
974
975
976 if (!tick_oneshot_mode_active() ||
977 (src->flags & CLOCK_SOURCE_VALID_FOR_HRES))
978 count += snprintf(buf + count,
979 max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
980 "%s ", src->name);
981 }
982 mutex_unlock(&clocksource_mutex);
983
984 count += snprintf(buf + count,
985 max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
986
987 return count;
988}
989
990
991
992
993static DEVICE_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources,
994 sysfs_override_clocksource);
995
996static DEVICE_ATTR(unbind_clocksource, 0200, NULL, sysfs_unbind_clocksource);
997
998static DEVICE_ATTR(available_clocksource, 0444,
999 sysfs_show_available_clocksources, NULL);
1000
1001static struct bus_type clocksource_subsys = {
1002 .name = "clocksource",
1003 .dev_name = "clocksource",
1004};
1005
1006static struct device device_clocksource = {
1007 .id = 0,
1008 .bus = &clocksource_subsys,
1009};
1010
1011static int __init init_clocksource_sysfs(void)
1012{
1013 int error = subsys_system_register(&clocksource_subsys, NULL);
1014
1015 if (!error)
1016 error = device_register(&device_clocksource);
1017 if (!error)
1018 error = device_create_file(
1019 &device_clocksource,
1020 &dev_attr_current_clocksource);
1021 if (!error)
1022 error = device_create_file(&device_clocksource,
1023 &dev_attr_unbind_clocksource);
1024 if (!error)
1025 error = device_create_file(
1026 &device_clocksource,
1027 &dev_attr_available_clocksource);
1028 return error;
1029}
1030
1031device_initcall(init_clocksource_sysfs);
1032#endif
1033
1034
1035
1036
1037
1038
1039
1040
1041static int __init boot_override_clocksource(char* str)
1042{
1043 mutex_lock(&clocksource_mutex);
1044 if (str)
1045 strlcpy(override_name, str, sizeof(override_name));
1046 mutex_unlock(&clocksource_mutex);
1047 return 1;
1048}
1049
1050__setup("clocksource=", boot_override_clocksource);
1051
1052
1053
1054
1055
1056
1057
1058
1059static int __init boot_override_clock(char* str)
1060{
1061 if (!strcmp(str, "pmtmr")) {
1062 pr_warn("clock=pmtmr is deprecated - use clocksource=acpi_pm\n");
1063 return boot_override_clocksource("acpi_pm");
1064 }
1065 pr_warn("clock= boot option is deprecated - use clocksource=xyz\n");
1066 return boot_override_clocksource(str);
1067}
1068
1069__setup("clock=", boot_override_clock);
1070