1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/clockchips.h>
15#include <linux/hrtimer.h>
16#include <linux/init.h>
17#include <linux/module.h>
18#include <linux/smp.h>
19#include <linux/device.h>
20
21#include "tick-internal.h"
22
23
24static LIST_HEAD(clockevent_devices);
25static LIST_HEAD(clockevents_released);
26
27static DEFINE_RAW_SPINLOCK(clockevents_lock);
28
29static DEFINE_MUTEX(clockevents_mutex);
30
31struct ce_unbind {
32 struct clock_event_device *ce;
33 int res;
34};
35
36static u64 cev_delta2ns(unsigned long latch, struct clock_event_device *evt,
37 bool ismax)
38{
39 u64 clc = (u64) latch << evt->shift;
40 u64 rnd;
41
42 if (unlikely(!evt->mult)) {
43 evt->mult = 1;
44 WARN_ON(1);
45 }
46 rnd = (u64) evt->mult - 1;
47
48
49
50
51
52 if ((clc >> evt->shift) != (u64)latch)
53 clc = ~0ULL;
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74 if ((~0ULL - clc > rnd) &&
75 (!ismax || evt->mult <= (1ULL << evt->shift)))
76 clc += rnd;
77
78 do_div(clc, evt->mult);
79
80
81 return clc > 1000 ? clc : 1000;
82}
83
84
85
86
87
88
89
90
91u64 clockevent_delta2ns(unsigned long latch, struct clock_event_device *evt)
92{
93 return cev_delta2ns(latch, evt, false);
94}
95EXPORT_SYMBOL_GPL(clockevent_delta2ns);
96
97static int __clockevents_switch_state(struct clock_event_device *dev,
98 enum clock_event_state state)
99{
100 if (dev->features & CLOCK_EVT_FEAT_DUMMY)
101 return 0;
102
103
104 switch (state) {
105 case CLOCK_EVT_STATE_DETACHED:
106
107
108 case CLOCK_EVT_STATE_SHUTDOWN:
109 if (dev->set_state_shutdown)
110 return dev->set_state_shutdown(dev);
111 return 0;
112
113 case CLOCK_EVT_STATE_PERIODIC:
114
115 if (!(dev->features & CLOCK_EVT_FEAT_PERIODIC))
116 return -ENOSYS;
117 if (dev->set_state_periodic)
118 return dev->set_state_periodic(dev);
119 return 0;
120
121 case CLOCK_EVT_STATE_ONESHOT:
122
123 if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
124 return -ENOSYS;
125 if (dev->set_state_oneshot)
126 return dev->set_state_oneshot(dev);
127 return 0;
128
129 case CLOCK_EVT_STATE_ONESHOT_STOPPED:
130
131 if (WARN_ONCE(!clockevent_state_oneshot(dev),
132 "Current state: %d\n",
133 clockevent_get_state(dev)))
134 return -EINVAL;
135
136 if (dev->set_state_oneshot_stopped)
137 return dev->set_state_oneshot_stopped(dev);
138 else
139 return -ENOSYS;
140
141 default:
142 return -ENOSYS;
143 }
144}
145
146
147
148
149
150
151
152
153void clockevents_switch_state(struct clock_event_device *dev,
154 enum clock_event_state state)
155{
156 if (clockevent_get_state(dev) != state) {
157 if (__clockevents_switch_state(dev, state))
158 return;
159
160 clockevent_set_state(dev, state);
161
162
163
164
165
166 if (clockevent_state_oneshot(dev)) {
167 if (unlikely(!dev->mult)) {
168 dev->mult = 1;
169 WARN_ON(1);
170 }
171 }
172 }
173}
174
175
176
177
178
179void clockevents_shutdown(struct clock_event_device *dev)
180{
181 clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
182 dev->next_event.tv64 = KTIME_MAX;
183}
184
185
186
187
188
189int clockevents_tick_resume(struct clock_event_device *dev)
190{
191 int ret = 0;
192
193 if (dev->tick_resume)
194 ret = dev->tick_resume(dev);
195
196 return ret;
197}
198
199#ifdef CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST
200
201
202#define MIN_DELTA_LIMIT (NSEC_PER_SEC / HZ)
203
204
205
206
207
208
209
210static int clockevents_increase_min_delta(struct clock_event_device *dev)
211{
212
213 if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {
214 printk_deferred(KERN_WARNING
215 "CE: Reprogramming failure. Giving up\n");
216 dev->next_event.tv64 = KTIME_MAX;
217 return -ETIME;
218 }
219
220 if (dev->min_delta_ns < 5000)
221 dev->min_delta_ns = 5000;
222 else
223 dev->min_delta_ns += dev->min_delta_ns >> 1;
224
225 if (dev->min_delta_ns > MIN_DELTA_LIMIT)
226 dev->min_delta_ns = MIN_DELTA_LIMIT;
227
228 printk_deferred(KERN_WARNING
229 "CE: %s increased min_delta_ns to %llu nsec\n",
230 dev->name ? dev->name : "?",
231 (unsigned long long) dev->min_delta_ns);
232 return 0;
233}
234
235
236
237
238
239
240
241static int clockevents_program_min_delta(struct clock_event_device *dev)
242{
243 unsigned long long clc;
244 int64_t delta;
245 int i;
246
247 for (i = 0;;) {
248 delta = dev->min_delta_ns;
249 dev->next_event = ktime_add_ns(ktime_get(), delta);
250
251 if (clockevent_state_shutdown(dev))
252 return 0;
253
254 dev->retries++;
255 clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
256 if (dev->set_next_event((unsigned long) clc, dev) == 0)
257 return 0;
258
259 if (++i > 2) {
260
261
262
263
264
265 if (clockevents_increase_min_delta(dev))
266 return -ETIME;
267 i = 0;
268 }
269 }
270}
271
272#else
273
274
275
276
277
278
279
280static int clockevents_program_min_delta(struct clock_event_device *dev)
281{
282 unsigned long long clc;
283 int64_t delta;
284
285 delta = dev->min_delta_ns;
286 dev->next_event = ktime_add_ns(ktime_get(), delta);
287
288 if (clockevent_state_shutdown(dev))
289 return 0;
290
291 dev->retries++;
292 clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
293 return dev->set_next_event((unsigned long) clc, dev);
294}
295
296#endif
297
298
299
300
301
302
303
304
305
306int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
307 bool force)
308{
309 unsigned long long clc;
310 int64_t delta;
311 int rc;
312
313 if (unlikely(expires.tv64 < 0)) {
314 WARN_ON_ONCE(1);
315 return -ETIME;
316 }
317
318 dev->next_event = expires;
319
320 if (clockevent_state_shutdown(dev))
321 return 0;
322
323
324 WARN_ONCE(!clockevent_state_oneshot(dev), "Current state: %d\n",
325 clockevent_get_state(dev));
326
327
328 if (dev->features & CLOCK_EVT_FEAT_KTIME)
329 return dev->set_next_ktime(expires, dev);
330
331 delta = ktime_to_ns(ktime_sub(expires, ktime_get()));
332 if (delta <= 0)
333 return force ? clockevents_program_min_delta(dev) : -ETIME;
334
335 delta = min(delta, (int64_t) dev->max_delta_ns);
336 delta = max(delta, (int64_t) dev->min_delta_ns);
337
338 clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
339 rc = dev->set_next_event((unsigned long) clc, dev);
340
341 return (rc && force) ? clockevents_program_min_delta(dev) : rc;
342}
343
344
345
346
347
348static void clockevents_notify_released(void)
349{
350 struct clock_event_device *dev;
351
352 while (!list_empty(&clockevents_released)) {
353 dev = list_entry(clockevents_released.next,
354 struct clock_event_device, list);
355 list_del(&dev->list);
356 list_add(&dev->list, &clockevent_devices);
357 tick_check_new_device(dev);
358 }
359}
360
361
362
363
364static int clockevents_replace(struct clock_event_device *ced)
365{
366 struct clock_event_device *dev, *newdev = NULL;
367
368 list_for_each_entry(dev, &clockevent_devices, list) {
369 if (dev == ced || !clockevent_state_detached(dev))
370 continue;
371
372 if (!tick_check_replacement(newdev, dev))
373 continue;
374
375 if (!try_module_get(dev->owner))
376 continue;
377
378 if (newdev)
379 module_put(newdev->owner);
380 newdev = dev;
381 }
382 if (newdev) {
383 tick_install_replacement(newdev);
384 list_del_init(&ced->list);
385 }
386 return newdev ? 0 : -EBUSY;
387}
388
389
390
391
392static int __clockevents_try_unbind(struct clock_event_device *ced, int cpu)
393{
394
395 if (clockevent_state_detached(ced)) {
396 list_del_init(&ced->list);
397 return 0;
398 }
399
400 return ced == per_cpu(tick_cpu_device, cpu).evtdev ? -EAGAIN : -EBUSY;
401}
402
403
404
405
406static void __clockevents_unbind(void *arg)
407{
408 struct ce_unbind *cu = arg;
409 int res;
410
411 raw_spin_lock(&clockevents_lock);
412 res = __clockevents_try_unbind(cu->ce, smp_processor_id());
413 if (res == -EAGAIN)
414 res = clockevents_replace(cu->ce);
415 cu->res = res;
416 raw_spin_unlock(&clockevents_lock);
417}
418
419
420
421
422
423static int clockevents_unbind(struct clock_event_device *ced, int cpu)
424{
425 struct ce_unbind cu = { .ce = ced, .res = -ENODEV };
426
427 smp_call_function_single(cpu, __clockevents_unbind, &cu, 1);
428 return cu.res;
429}
430
431
432
433
434int clockevents_unbind_device(struct clock_event_device *ced, int cpu)
435{
436 int ret;
437
438 mutex_lock(&clockevents_mutex);
439 ret = clockevents_unbind(ced, cpu);
440 mutex_unlock(&clockevents_mutex);
441 return ret;
442}
443EXPORT_SYMBOL_GPL(clockevents_unbind_device);
444
445
446
447
448
449void clockevents_register_device(struct clock_event_device *dev)
450{
451 unsigned long flags;
452
453
454 clockevent_set_state(dev, CLOCK_EVT_STATE_DETACHED);
455
456 if (!dev->cpumask) {
457 WARN_ON(num_possible_cpus() > 1);
458 dev->cpumask = cpumask_of(smp_processor_id());
459 }
460
461 raw_spin_lock_irqsave(&clockevents_lock, flags);
462
463 list_add(&dev->list, &clockevent_devices);
464 tick_check_new_device(dev);
465 clockevents_notify_released();
466
467 raw_spin_unlock_irqrestore(&clockevents_lock, flags);
468}
469EXPORT_SYMBOL_GPL(clockevents_register_device);
470
471void clockevents_config(struct clock_event_device *dev, u32 freq)
472{
473 u64 sec;
474
475 if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
476 return;
477
478
479
480
481
482
483 sec = dev->max_delta_ticks;
484 do_div(sec, freq);
485 if (!sec)
486 sec = 1;
487 else if (sec > 600 && dev->max_delta_ticks > UINT_MAX)
488 sec = 600;
489
490 clockevents_calc_mult_shift(dev, freq, sec);
491 dev->min_delta_ns = cev_delta2ns(dev->min_delta_ticks, dev, false);
492 dev->max_delta_ns = cev_delta2ns(dev->max_delta_ticks, dev, true);
493}
494
495
496
497
498
499
500
501
502
503
504void clockevents_config_and_register(struct clock_event_device *dev,
505 u32 freq, unsigned long min_delta,
506 unsigned long max_delta)
507{
508 dev->min_delta_ticks = min_delta;
509 dev->max_delta_ticks = max_delta;
510 clockevents_config(dev, freq);
511 clockevents_register_device(dev);
512}
513EXPORT_SYMBOL_GPL(clockevents_config_and_register);
514
515int __clockevents_update_freq(struct clock_event_device *dev, u32 freq)
516{
517 clockevents_config(dev, freq);
518
519 if (clockevent_state_oneshot(dev))
520 return clockevents_program_event(dev, dev->next_event, false);
521
522 if (clockevent_state_periodic(dev))
523 return __clockevents_switch_state(dev, CLOCK_EVT_STATE_PERIODIC);
524
525 return 0;
526}
527
528
529
530
531
532
533
534
535
536
537
538
539
540int clockevents_update_freq(struct clock_event_device *dev, u32 freq)
541{
542 unsigned long flags;
543 int ret;
544
545 local_irq_save(flags);
546 ret = tick_broadcast_update_freq(dev, freq);
547 if (ret == -ENODEV)
548 ret = __clockevents_update_freq(dev, freq);
549 local_irq_restore(flags);
550 return ret;
551}
552
553
554
555
556void clockevents_handle_noop(struct clock_event_device *dev)
557{
558}
559
560
561
562
563
564
565
566
567
568void clockevents_exchange_device(struct clock_event_device *old,
569 struct clock_event_device *new)
570{
571
572
573
574
575 if (old) {
576 module_put(old->owner);
577 clockevents_switch_state(old, CLOCK_EVT_STATE_DETACHED);
578 list_del(&old->list);
579 list_add(&old->list, &clockevents_released);
580 }
581
582 if (new) {
583 BUG_ON(!clockevent_state_detached(new));
584 clockevents_shutdown(new);
585 }
586}
587
588
589
590
591void clockevents_suspend(void)
592{
593 struct clock_event_device *dev;
594
595 list_for_each_entry_reverse(dev, &clockevent_devices, list)
596 if (dev->suspend && !clockevent_state_detached(dev))
597 dev->suspend(dev);
598}
599
600
601
602
603void clockevents_resume(void)
604{
605 struct clock_event_device *dev;
606
607 list_for_each_entry(dev, &clockevent_devices, list)
608 if (dev->resume && !clockevent_state_detached(dev))
609 dev->resume(dev);
610}
611
612#ifdef CONFIG_HOTPLUG_CPU
613
614
615
616void tick_cleanup_dead_cpu(int cpu)
617{
618 struct clock_event_device *dev, *tmp;
619 unsigned long flags;
620
621 raw_spin_lock_irqsave(&clockevents_lock, flags);
622
623 tick_shutdown_broadcast_oneshot(cpu);
624 tick_shutdown_broadcast(cpu);
625 tick_shutdown(cpu);
626
627
628
629
630 list_for_each_entry_safe(dev, tmp, &clockevents_released, list)
631 list_del(&dev->list);
632
633
634
635 list_for_each_entry_safe(dev, tmp, &clockevent_devices, list) {
636 if (cpumask_test_cpu(cpu, dev->cpumask) &&
637 cpumask_weight(dev->cpumask) == 1 &&
638 !tick_is_broadcast_device(dev)) {
639 BUG_ON(!clockevent_state_detached(dev));
640 list_del(&dev->list);
641 }
642 }
643 raw_spin_unlock_irqrestore(&clockevents_lock, flags);
644}
645#endif
646
647#ifdef CONFIG_SYSFS
648struct bus_type clockevents_subsys = {
649 .name = "clockevents",
650 .dev_name = "clockevent",
651};
652
653static DEFINE_PER_CPU(struct device, tick_percpu_dev);
654static struct tick_device *tick_get_tick_dev(struct device *dev);
655
656static ssize_t sysfs_show_current_tick_dev(struct device *dev,
657 struct device_attribute *attr,
658 char *buf)
659{
660 struct tick_device *td;
661 ssize_t count = 0;
662
663 raw_spin_lock_irq(&clockevents_lock);
664 td = tick_get_tick_dev(dev);
665 if (td && td->evtdev)
666 count = snprintf(buf, PAGE_SIZE, "%s\n", td->evtdev->name);
667 raw_spin_unlock_irq(&clockevents_lock);
668 return count;
669}
670static DEVICE_ATTR(current_device, 0444, sysfs_show_current_tick_dev, NULL);
671
672
673static ssize_t sysfs_unbind_tick_dev(struct device *dev,
674 struct device_attribute *attr,
675 const char *buf, size_t count)
676{
677 char name[CS_NAME_LEN];
678 ssize_t ret = sysfs_get_uname(buf, name, count);
679 struct clock_event_device *ce;
680
681 if (ret < 0)
682 return ret;
683
684 ret = -ENODEV;
685 mutex_lock(&clockevents_mutex);
686 raw_spin_lock_irq(&clockevents_lock);
687 list_for_each_entry(ce, &clockevent_devices, list) {
688 if (!strcmp(ce->name, name)) {
689 ret = __clockevents_try_unbind(ce, dev->id);
690 break;
691 }
692 }
693 raw_spin_unlock_irq(&clockevents_lock);
694
695
696
697 if (ret == -EAGAIN)
698 ret = clockevents_unbind(ce, dev->id);
699 mutex_unlock(&clockevents_mutex);
700 return ret ? ret : count;
701}
702static DEVICE_ATTR(unbind_device, 0200, NULL, sysfs_unbind_tick_dev);
703
704#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
705static struct device tick_bc_dev = {
706 .init_name = "broadcast",
707 .id = 0,
708 .bus = &clockevents_subsys,
709};
710
711static struct tick_device *tick_get_tick_dev(struct device *dev)
712{
713 return dev == &tick_bc_dev ? tick_get_broadcast_device() :
714 &per_cpu(tick_cpu_device, dev->id);
715}
716
717static __init int tick_broadcast_init_sysfs(void)
718{
719 int err = device_register(&tick_bc_dev);
720
721 if (!err)
722 err = device_create_file(&tick_bc_dev, &dev_attr_current_device);
723 return err;
724}
725#else
726static struct tick_device *tick_get_tick_dev(struct device *dev)
727{
728 return &per_cpu(tick_cpu_device, dev->id);
729}
730static inline int tick_broadcast_init_sysfs(void) { return 0; }
731#endif
732
733static int __init tick_init_sysfs(void)
734{
735 int cpu;
736
737 for_each_possible_cpu(cpu) {
738 struct device *dev = &per_cpu(tick_percpu_dev, cpu);
739 int err;
740
741 dev->id = cpu;
742 dev->bus = &clockevents_subsys;
743 err = device_register(dev);
744 if (!err)
745 err = device_create_file(dev, &dev_attr_current_device);
746 if (!err)
747 err = device_create_file(dev, &dev_attr_unbind_device);
748 if (err)
749 return err;
750 }
751 return tick_broadcast_init_sysfs();
752}
753
754static int __init clockevents_init_sysfs(void)
755{
756 int err = subsys_system_register(&clockevents_subsys, NULL);
757
758 if (!err)
759 err = tick_init_sysfs();
760 return err;
761}
762device_initcall(clockevents_init_sysfs);
763#endif
764