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