1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/cpu.h>
15#include <linux/err.h>
16#include <linux/hrtimer.h>
17#include <linux/interrupt.h>
18#include <linux/percpu.h>
19#include <linux/profile.h>
20#include <linux/sched.h>
21#include <linux/smp.h>
22#include <linux/module.h>
23
24#include "tick-internal.h"
25
26
27
28
29
30
31static struct tick_device tick_broadcast_device;
32static cpumask_var_t tick_broadcast_mask __cpumask_var_read_mostly;
33static cpumask_var_t tick_broadcast_on __cpumask_var_read_mostly;
34static cpumask_var_t tmpmask __cpumask_var_read_mostly;
35static int tick_broadcast_forced;
36
37static __cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
38
39#ifdef CONFIG_TICK_ONESHOT
40static void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
41static void tick_broadcast_clear_oneshot(int cpu);
42static void tick_resume_broadcast_oneshot(struct clock_event_device *bc);
43#else
44static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
45static inline void tick_broadcast_clear_oneshot(int cpu) { }
46static inline void tick_resume_broadcast_oneshot(struct clock_event_device *bc) { }
47#endif
48
49
50
51
52struct tick_device *tick_get_broadcast_device(void)
53{
54 return &tick_broadcast_device;
55}
56
57struct cpumask *tick_get_broadcast_mask(void)
58{
59 return tick_broadcast_mask;
60}
61
62
63
64
65static void tick_broadcast_start_periodic(struct clock_event_device *bc)
66{
67 if (bc)
68 tick_setup_periodic(bc, 1);
69}
70
71
72
73
74static bool tick_check_broadcast_device(struct clock_event_device *curdev,
75 struct clock_event_device *newdev)
76{
77 if ((newdev->features & CLOCK_EVT_FEAT_DUMMY) ||
78 (newdev->features & CLOCK_EVT_FEAT_PERCPU) ||
79 (newdev->features & CLOCK_EVT_FEAT_C3STOP))
80 return false;
81
82 if (tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT &&
83 !(newdev->features & CLOCK_EVT_FEAT_ONESHOT))
84 return false;
85
86 return !curdev || newdev->rating > curdev->rating;
87}
88
89
90
91
92void tick_install_broadcast_device(struct clock_event_device *dev)
93{
94 struct clock_event_device *cur = tick_broadcast_device.evtdev;
95
96 if (!tick_check_broadcast_device(cur, dev))
97 return;
98
99 if (!try_module_get(dev->owner))
100 return;
101
102 clockevents_exchange_device(cur, dev);
103 if (cur)
104 cur->event_handler = clockevents_handle_noop;
105 tick_broadcast_device.evtdev = dev;
106 if (!cpumask_empty(tick_broadcast_mask))
107 tick_broadcast_start_periodic(dev);
108
109
110
111
112
113
114
115
116 if (dev->features & CLOCK_EVT_FEAT_ONESHOT)
117 tick_clock_notify();
118}
119
120
121
122
123int tick_is_broadcast_device(struct clock_event_device *dev)
124{
125 return (dev && tick_broadcast_device.evtdev == dev);
126}
127
128int tick_broadcast_update_freq(struct clock_event_device *dev, u32 freq)
129{
130 int ret = -ENODEV;
131
132 if (tick_is_broadcast_device(dev)) {
133 raw_spin_lock(&tick_broadcast_lock);
134 ret = __clockevents_update_freq(dev, freq);
135 raw_spin_unlock(&tick_broadcast_lock);
136 }
137 return ret;
138}
139
140
141static void err_broadcast(const struct cpumask *mask)
142{
143 pr_crit_once("Failed to broadcast timer tick. Some CPUs may be unresponsive.\n");
144}
145
146static void tick_device_setup_broadcast_func(struct clock_event_device *dev)
147{
148 if (!dev->broadcast)
149 dev->broadcast = tick_broadcast;
150 if (!dev->broadcast) {
151 pr_warn_once("%s depends on broadcast, but no broadcast function available\n",
152 dev->name);
153 dev->broadcast = err_broadcast;
154 }
155}
156
157
158
159
160
161int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
162{
163 struct clock_event_device *bc = tick_broadcast_device.evtdev;
164 unsigned long flags;
165 int ret = 0;
166
167 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
168
169
170
171
172
173
174
175 if (!tick_device_is_functional(dev)) {
176 dev->event_handler = tick_handle_periodic;
177 tick_device_setup_broadcast_func(dev);
178 cpumask_set_cpu(cpu, tick_broadcast_mask);
179 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
180 tick_broadcast_start_periodic(bc);
181 else
182 tick_broadcast_setup_oneshot(bc);
183 ret = 1;
184 } else {
185
186
187
188
189 if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
190 cpumask_clear_cpu(cpu, tick_broadcast_mask);
191 else
192 tick_device_setup_broadcast_func(dev);
193
194
195
196
197
198 if (!cpumask_test_cpu(cpu, tick_broadcast_on))
199 cpumask_clear_cpu(cpu, tick_broadcast_mask);
200
201 switch (tick_broadcast_device.mode) {
202 case TICKDEV_MODE_ONESHOT:
203
204
205
206
207
208
209
210
211 tick_broadcast_clear_oneshot(cpu);
212 ret = 0;
213 break;
214
215 case TICKDEV_MODE_PERIODIC:
216
217
218
219
220
221 if (cpumask_empty(tick_broadcast_mask) && bc)
222 clockevents_shutdown(bc);
223
224
225
226
227
228
229
230
231 if (bc && !(bc->features & CLOCK_EVT_FEAT_HRTIMER))
232 ret = cpumask_test_cpu(cpu, tick_broadcast_mask);
233 break;
234 default:
235 break;
236 }
237 }
238 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
239 return ret;
240}
241
242#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
243int tick_receive_broadcast(void)
244{
245 struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
246 struct clock_event_device *evt = td->evtdev;
247
248 if (!evt)
249 return -ENODEV;
250
251 if (!evt->event_handler)
252 return -EINVAL;
253
254 evt->event_handler(evt);
255 return 0;
256}
257#endif
258
259
260
261
262static bool tick_do_broadcast(struct cpumask *mask)
263{
264 int cpu = smp_processor_id();
265 struct tick_device *td;
266 bool local = false;
267
268
269
270
271 if (cpumask_test_cpu(cpu, mask)) {
272 struct clock_event_device *bc = tick_broadcast_device.evtdev;
273
274 cpumask_clear_cpu(cpu, mask);
275
276
277
278
279
280
281
282
283
284
285
286
287 local = !(bc->features & CLOCK_EVT_FEAT_HRTIMER);
288 }
289
290 if (!cpumask_empty(mask)) {
291
292
293
294
295
296
297 td = &per_cpu(tick_cpu_device, cpumask_first(mask));
298 td->evtdev->broadcast(mask);
299 }
300 return local;
301}
302
303
304
305
306
307static bool tick_do_periodic_broadcast(void)
308{
309 cpumask_and(tmpmask, cpu_online_mask, tick_broadcast_mask);
310 return tick_do_broadcast(tmpmask);
311}
312
313
314
315
316static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
317{
318 struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
319 bool bc_local;
320
321 raw_spin_lock(&tick_broadcast_lock);
322
323
324 if (clockevent_state_shutdown(tick_broadcast_device.evtdev)) {
325 raw_spin_unlock(&tick_broadcast_lock);
326 return;
327 }
328
329 bc_local = tick_do_periodic_broadcast();
330
331 if (clockevent_state_oneshot(dev)) {
332 ktime_t next = ktime_add(dev->next_event, tick_period);
333
334 clockevents_program_event(dev, next, true);
335 }
336 raw_spin_unlock(&tick_broadcast_lock);
337
338
339
340
341
342
343 if (bc_local)
344 td->evtdev->event_handler(td->evtdev);
345}
346
347
348
349
350
351
352
353
354void tick_broadcast_control(enum tick_broadcast_mode mode)
355{
356 struct clock_event_device *bc, *dev;
357 struct tick_device *td;
358 int cpu, bc_stopped;
359 unsigned long flags;
360
361
362 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
363 td = this_cpu_ptr(&tick_cpu_device);
364 dev = td->evtdev;
365
366
367
368
369 if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))
370 goto out;
371
372 if (!tick_device_is_functional(dev))
373 goto out;
374
375 cpu = smp_processor_id();
376 bc = tick_broadcast_device.evtdev;
377 bc_stopped = cpumask_empty(tick_broadcast_mask);
378
379 switch (mode) {
380 case TICK_BROADCAST_FORCE:
381 tick_broadcast_forced = 1;
382 case TICK_BROADCAST_ON:
383 cpumask_set_cpu(cpu, tick_broadcast_on);
384 if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {
385
386
387
388
389
390
391
392
393 if (bc && !(bc->features & CLOCK_EVT_FEAT_HRTIMER) &&
394 tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
395 clockevents_shutdown(dev);
396 }
397 break;
398
399 case TICK_BROADCAST_OFF:
400 if (tick_broadcast_forced)
401 break;
402 cpumask_clear_cpu(cpu, tick_broadcast_on);
403 if (!tick_device_is_functional(dev))
404 break;
405 if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_mask)) {
406 if (tick_broadcast_device.mode ==
407 TICKDEV_MODE_PERIODIC)
408 tick_setup_periodic(dev, 0);
409 }
410 break;
411 }
412
413 if (bc) {
414 if (cpumask_empty(tick_broadcast_mask)) {
415 if (!bc_stopped)
416 clockevents_shutdown(bc);
417 } else if (bc_stopped) {
418 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
419 tick_broadcast_start_periodic(bc);
420 else
421 tick_broadcast_setup_oneshot(bc);
422 }
423 }
424out:
425 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
426}
427EXPORT_SYMBOL_GPL(tick_broadcast_control);
428
429
430
431
432void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
433{
434 if (!broadcast)
435 dev->event_handler = tick_handle_periodic;
436 else
437 dev->event_handler = tick_handle_periodic_broadcast;
438}
439
440#ifdef CONFIG_HOTPLUG_CPU
441
442
443
444void tick_shutdown_broadcast(unsigned int cpu)
445{
446 struct clock_event_device *bc;
447 unsigned long flags;
448
449 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
450
451 bc = tick_broadcast_device.evtdev;
452 cpumask_clear_cpu(cpu, tick_broadcast_mask);
453 cpumask_clear_cpu(cpu, tick_broadcast_on);
454
455 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
456 if (bc && cpumask_empty(tick_broadcast_mask))
457 clockevents_shutdown(bc);
458 }
459
460 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
461}
462#endif
463
464void tick_suspend_broadcast(void)
465{
466 struct clock_event_device *bc;
467 unsigned long flags;
468
469 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
470
471 bc = tick_broadcast_device.evtdev;
472 if (bc)
473 clockevents_shutdown(bc);
474
475 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
476}
477
478
479
480
481
482
483
484
485
486bool tick_resume_check_broadcast(void)
487{
488 if (tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT)
489 return false;
490 else
491 return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask);
492}
493
494void tick_resume_broadcast(void)
495{
496 struct clock_event_device *bc;
497 unsigned long flags;
498
499 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
500
501 bc = tick_broadcast_device.evtdev;
502
503 if (bc) {
504 clockevents_tick_resume(bc);
505
506 switch (tick_broadcast_device.mode) {
507 case TICKDEV_MODE_PERIODIC:
508 if (!cpumask_empty(tick_broadcast_mask))
509 tick_broadcast_start_periodic(bc);
510 break;
511 case TICKDEV_MODE_ONESHOT:
512 if (!cpumask_empty(tick_broadcast_mask))
513 tick_resume_broadcast_oneshot(bc);
514 break;
515 }
516 }
517 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
518}
519
520#ifdef CONFIG_TICK_ONESHOT
521
522static cpumask_var_t tick_broadcast_oneshot_mask __cpumask_var_read_mostly;
523static cpumask_var_t tick_broadcast_pending_mask __cpumask_var_read_mostly;
524static cpumask_var_t tick_broadcast_force_mask __cpumask_var_read_mostly;
525
526
527
528
529struct cpumask *tick_get_broadcast_oneshot_mask(void)
530{
531 return tick_broadcast_oneshot_mask;
532}
533
534
535
536
537
538
539
540
541int tick_check_broadcast_expired(void)
542{
543 return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask);
544}
545
546
547
548
549static void tick_broadcast_set_affinity(struct clock_event_device *bc,
550 const struct cpumask *cpumask)
551{
552 if (!(bc->features & CLOCK_EVT_FEAT_DYNIRQ))
553 return;
554
555 if (cpumask_equal(bc->cpumask, cpumask))
556 return;
557
558 bc->cpumask = cpumask;
559 irq_set_affinity(bc->irq, bc->cpumask);
560}
561
562static void tick_broadcast_set_event(struct clock_event_device *bc, int cpu,
563 ktime_t expires)
564{
565 if (!clockevent_state_oneshot(bc))
566 clockevents_switch_state(bc, CLOCK_EVT_STATE_ONESHOT);
567
568 clockevents_program_event(bc, expires, 1);
569 tick_broadcast_set_affinity(bc, cpumask_of(cpu));
570}
571
572static void tick_resume_broadcast_oneshot(struct clock_event_device *bc)
573{
574 clockevents_switch_state(bc, CLOCK_EVT_STATE_ONESHOT);
575}
576
577
578
579
580
581void tick_check_oneshot_broadcast_this_cpu(void)
582{
583 if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) {
584 struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
585
586
587
588
589
590
591 if (td->mode == TICKDEV_MODE_ONESHOT) {
592 clockevents_switch_state(td->evtdev,
593 CLOCK_EVT_STATE_ONESHOT);
594 }
595 }
596}
597
598
599
600
601static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
602{
603 struct tick_device *td;
604 ktime_t now, next_event;
605 int cpu, next_cpu = 0;
606 bool bc_local;
607
608 raw_spin_lock(&tick_broadcast_lock);
609 dev->next_event = KTIME_MAX;
610 next_event = KTIME_MAX;
611 cpumask_clear(tmpmask);
612 now = ktime_get();
613
614 for_each_cpu(cpu, tick_broadcast_oneshot_mask) {
615 td = &per_cpu(tick_cpu_device, cpu);
616 if (td->evtdev->next_event <= now) {
617 cpumask_set_cpu(cpu, tmpmask);
618
619
620
621
622
623 cpumask_set_cpu(cpu, tick_broadcast_pending_mask);
624 } else if (td->evtdev->next_event < next_event) {
625 next_event = td->evtdev->next_event;
626 next_cpu = cpu;
627 }
628 }
629
630
631
632
633
634 cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask);
635
636
637 cpumask_or(tmpmask, tmpmask, tick_broadcast_force_mask);
638 cpumask_clear(tick_broadcast_force_mask);
639
640
641
642
643
644 if (WARN_ON_ONCE(!cpumask_subset(tmpmask, cpu_online_mask)))
645 cpumask_and(tmpmask, tmpmask, cpu_online_mask);
646
647
648
649
650 bc_local = tick_do_broadcast(tmpmask);
651
652
653
654
655
656
657
658
659
660
661
662 if (next_event != KTIME_MAX)
663 tick_broadcast_set_event(dev, next_cpu, next_event);
664
665 raw_spin_unlock(&tick_broadcast_lock);
666
667 if (bc_local) {
668 td = this_cpu_ptr(&tick_cpu_device);
669 td->evtdev->event_handler(td->evtdev);
670 }
671}
672
673static int broadcast_needs_cpu(struct clock_event_device *bc, int cpu)
674{
675 if (!(bc->features & CLOCK_EVT_FEAT_HRTIMER))
676 return 0;
677 if (bc->next_event == KTIME_MAX)
678 return 0;
679 return bc->bound_on == cpu ? -EBUSY : 0;
680}
681
682static void broadcast_shutdown_local(struct clock_event_device *bc,
683 struct clock_event_device *dev)
684{
685
686
687
688
689
690 if (bc->features & CLOCK_EVT_FEAT_HRTIMER) {
691 if (broadcast_needs_cpu(bc, smp_processor_id()))
692 return;
693 if (dev->next_event < bc->next_event)
694 return;
695 }
696 clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
697}
698
699int __tick_broadcast_oneshot_control(enum tick_broadcast_state state)
700{
701 struct clock_event_device *bc, *dev;
702 int cpu, ret = 0;
703 ktime_t now;
704
705
706
707
708
709 if (!tick_broadcast_device.evtdev)
710 return -EBUSY;
711
712 dev = this_cpu_ptr(&tick_cpu_device)->evtdev;
713
714 raw_spin_lock(&tick_broadcast_lock);
715 bc = tick_broadcast_device.evtdev;
716 cpu = smp_processor_id();
717
718 if (state == TICK_BROADCAST_ENTER) {
719
720
721
722
723
724
725
726 ret = broadcast_needs_cpu(bc, cpu);
727 if (ret)
728 goto out;
729
730
731
732
733
734 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
735
736 if (bc->features & CLOCK_EVT_FEAT_HRTIMER)
737 ret = -EBUSY;
738 goto out;
739 }
740
741 if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_oneshot_mask)) {
742 WARN_ON_ONCE(cpumask_test_cpu(cpu, tick_broadcast_pending_mask));
743
744
745 broadcast_shutdown_local(bc, dev);
746
747
748
749
750
751
752
753
754
755
756
757 if (cpumask_test_cpu(cpu, tick_broadcast_force_mask)) {
758 ret = -EBUSY;
759 } else if (dev->next_event < bc->next_event) {
760 tick_broadcast_set_event(bc, cpu, dev->next_event);
761
762
763
764
765
766
767
768 ret = broadcast_needs_cpu(bc, cpu);
769 if (ret) {
770 cpumask_clear_cpu(cpu,
771 tick_broadcast_oneshot_mask);
772 }
773 }
774 }
775 } else {
776 if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_oneshot_mask)) {
777 clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT);
778
779
780
781
782
783
784
785
786
787 if (cpumask_test_and_clear_cpu(cpu,
788 tick_broadcast_pending_mask))
789 goto out;
790
791
792
793
794 if (dev->next_event == KTIME_MAX)
795 goto out;
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828 now = ktime_get();
829 if (dev->next_event <= now) {
830 cpumask_set_cpu(cpu, tick_broadcast_force_mask);
831 goto out;
832 }
833
834
835
836
837 tick_program_event(dev->next_event, 1);
838 }
839 }
840out:
841 raw_spin_unlock(&tick_broadcast_lock);
842 return ret;
843}
844
845
846
847
848
849
850static void tick_broadcast_clear_oneshot(int cpu)
851{
852 cpumask_clear_cpu(cpu, tick_broadcast_oneshot_mask);
853 cpumask_clear_cpu(cpu, tick_broadcast_pending_mask);
854}
855
856static void tick_broadcast_init_next_event(struct cpumask *mask,
857 ktime_t expires)
858{
859 struct tick_device *td;
860 int cpu;
861
862 for_each_cpu(cpu, mask) {
863 td = &per_cpu(tick_cpu_device, cpu);
864 if (td->evtdev)
865 td->evtdev->next_event = expires;
866 }
867}
868
869
870
871
872static void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
873{
874 int cpu = smp_processor_id();
875
876 if (!bc)
877 return;
878
879
880 if (bc->event_handler != tick_handle_oneshot_broadcast) {
881 int was_periodic = clockevent_state_periodic(bc);
882
883 bc->event_handler = tick_handle_oneshot_broadcast;
884
885
886
887
888
889
890
891 cpumask_copy(tmpmask, tick_broadcast_mask);
892 cpumask_clear_cpu(cpu, tmpmask);
893 cpumask_or(tick_broadcast_oneshot_mask,
894 tick_broadcast_oneshot_mask, tmpmask);
895
896 if (was_periodic && !cpumask_empty(tmpmask)) {
897 clockevents_switch_state(bc, CLOCK_EVT_STATE_ONESHOT);
898 tick_broadcast_init_next_event(tmpmask,
899 tick_next_period);
900 tick_broadcast_set_event(bc, cpu, tick_next_period);
901 } else
902 bc->next_event = KTIME_MAX;
903 } else {
904
905
906
907
908
909
910
911 tick_broadcast_clear_oneshot(cpu);
912 }
913}
914
915
916
917
918void tick_broadcast_switch_to_oneshot(void)
919{
920 struct clock_event_device *bc;
921 unsigned long flags;
922
923 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
924
925 tick_broadcast_device.mode = TICKDEV_MODE_ONESHOT;
926 bc = tick_broadcast_device.evtdev;
927 if (bc)
928 tick_broadcast_setup_oneshot(bc);
929
930 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
931}
932
933#ifdef CONFIG_HOTPLUG_CPU
934void hotplug_cpu__broadcast_tick_pull(int deadcpu)
935{
936 struct clock_event_device *bc;
937 unsigned long flags;
938
939 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
940 bc = tick_broadcast_device.evtdev;
941
942 if (bc && broadcast_needs_cpu(bc, deadcpu)) {
943
944 clockevents_program_event(bc, bc->next_event, 1);
945 }
946 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
947}
948
949
950
951
952void tick_shutdown_broadcast_oneshot(unsigned int cpu)
953{
954 unsigned long flags;
955
956 raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
957
958
959
960
961
962 cpumask_clear_cpu(cpu, tick_broadcast_oneshot_mask);
963 cpumask_clear_cpu(cpu, tick_broadcast_pending_mask);
964 cpumask_clear_cpu(cpu, tick_broadcast_force_mask);
965
966 raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
967}
968#endif
969
970
971
972
973int tick_broadcast_oneshot_active(void)
974{
975 return tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT;
976}
977
978
979
980
981bool tick_broadcast_oneshot_available(void)
982{
983 struct clock_event_device *bc = tick_broadcast_device.evtdev;
984
985 return bc ? bc->features & CLOCK_EVT_FEAT_ONESHOT : false;
986}
987
988#else
989int __tick_broadcast_oneshot_control(enum tick_broadcast_state state)
990{
991 struct clock_event_device *bc = tick_broadcast_device.evtdev;
992
993 if (!bc || (bc->features & CLOCK_EVT_FEAT_HRTIMER))
994 return -EBUSY;
995
996 return 0;
997}
998#endif
999
1000void __init tick_broadcast_init(void)
1001{
1002 zalloc_cpumask_var(&tick_broadcast_mask, GFP_NOWAIT);
1003 zalloc_cpumask_var(&tick_broadcast_on, GFP_NOWAIT);
1004 zalloc_cpumask_var(&tmpmask, GFP_NOWAIT);
1005#ifdef CONFIG_TICK_ONESHOT
1006 zalloc_cpumask_var(&tick_broadcast_oneshot_mask, GFP_NOWAIT);
1007 zalloc_cpumask_var(&tick_broadcast_pending_mask, GFP_NOWAIT);
1008 zalloc_cpumask_var(&tick_broadcast_force_mask, GFP_NOWAIT);
1009#endif
1010}
1011