Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * This file contains functions which manage clock event devices.
4 : *
5 : * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
6 : * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
7 : * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
8 : */
9 :
10 : #include <linux/clockchips.h>
11 : #include <linux/hrtimer.h>
12 : #include <linux/init.h>
13 : #include <linux/module.h>
14 : #include <linux/smp.h>
15 : #include <linux/device.h>
16 :
17 : #include "tick-internal.h"
18 :
19 : /* The registered clock event devices */
20 : static LIST_HEAD(clockevent_devices);
21 : static LIST_HEAD(clockevents_released);
22 : /* Protection for the above */
23 : static DEFINE_RAW_SPINLOCK(clockevents_lock);
24 : /* Protection for unbind operations */
25 : static DEFINE_MUTEX(clockevents_mutex);
26 :
27 : struct ce_unbind {
28 : struct clock_event_device *ce;
29 : int res;
30 : };
31 :
32 8 : static u64 cev_delta2ns(unsigned long latch, struct clock_event_device *evt,
33 : bool ismax)
34 : {
35 8 : u64 clc = (u64) latch << evt->shift;
36 8 : u64 rnd;
37 :
38 8 : if (WARN_ON(!evt->mult))
39 0 : evt->mult = 1;
40 8 : rnd = (u64) evt->mult - 1;
41 :
42 : /*
43 : * Upper bound sanity check. If the backwards conversion is
44 : * not equal latch, we know that the above shift overflowed.
45 : */
46 8 : if ((clc >> evt->shift) != (u64)latch)
47 4 : clc = ~0ULL;
48 :
49 : /*
50 : * Scaled math oddities:
51 : *
52 : * For mult <= (1 << shift) we can safely add mult - 1 to
53 : * prevent integer rounding loss. So the backwards conversion
54 : * from nsec to device ticks will be correct.
55 : *
56 : * For mult > (1 << shift), i.e. device frequency is > 1GHz we
57 : * need to be careful. Adding mult - 1 will result in a value
58 : * which when converted back to device ticks can be larger
59 : * than latch by up to (mult - 1) >> shift. For the min_delta
60 : * calculation we still want to apply this in order to stay
61 : * above the minimum device ticks limit. For the upper limit
62 : * we would end up with a latch value larger than the upper
63 : * limit of the device, so we omit the add to stay below the
64 : * device upper boundary.
65 : *
66 : * Also omit the add if it would overflow the u64 boundary.
67 : */
68 8 : if ((~0ULL - clc > rnd) &&
69 0 : (!ismax || evt->mult <= (1ULL << evt->shift)))
70 4 : clc += rnd;
71 :
72 8 : do_div(clc, evt->mult);
73 :
74 : /* Deltas less than 1usec are pointless noise */
75 8 : return clc > 1000 ? clc : 1000;
76 : }
77 :
78 : /**
79 : * clockevents_delta2ns - Convert a latch value (device ticks) to nanoseconds
80 : * @latch: value to convert
81 : * @evt: pointer to clock event device descriptor
82 : *
83 : * Math helper, returns latch value converted to nanoseconds (bound checked)
84 : */
85 0 : u64 clockevent_delta2ns(unsigned long latch, struct clock_event_device *evt)
86 : {
87 0 : return cev_delta2ns(latch, evt, false);
88 : }
89 : EXPORT_SYMBOL_GPL(clockevent_delta2ns);
90 :
91 8 : static int __clockevents_switch_state(struct clock_event_device *dev,
92 : enum clock_event_state state)
93 : {
94 8 : if (dev->features & CLOCK_EVT_FEAT_DUMMY)
95 : return 0;
96 :
97 : /* Transition with new state-specific callbacks */
98 8 : switch (state) {
99 4 : case CLOCK_EVT_STATE_DETACHED:
100 : /* The clockevent device is getting replaced. Shut it down. */
101 :
102 : case CLOCK_EVT_STATE_SHUTDOWN:
103 4 : if (dev->set_state_shutdown)
104 4 : return dev->set_state_shutdown(dev);
105 : return 0;
106 :
107 0 : case CLOCK_EVT_STATE_PERIODIC:
108 : /* Core internal bug */
109 0 : if (!(dev->features & CLOCK_EVT_FEAT_PERIODIC))
110 : return -ENOSYS;
111 0 : if (dev->set_state_periodic)
112 0 : return dev->set_state_periodic(dev);
113 : return 0;
114 :
115 4 : case CLOCK_EVT_STATE_ONESHOT:
116 : /* Core internal bug */
117 4 : if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
118 : return -ENOSYS;
119 4 : if (dev->set_state_oneshot)
120 4 : return dev->set_state_oneshot(dev);
121 : return 0;
122 :
123 : case CLOCK_EVT_STATE_ONESHOT_STOPPED:
124 : /* Core internal bug */
125 0 : if (WARN_ONCE(!clockevent_state_oneshot(dev),
126 : "Current state: %d\n",
127 : clockevent_get_state(dev)))
128 : return -EINVAL;
129 :
130 0 : if (dev->set_state_oneshot_stopped)
131 0 : return dev->set_state_oneshot_stopped(dev);
132 : else
133 : return -ENOSYS;
134 :
135 : default:
136 : return -ENOSYS;
137 : }
138 : }
139 :
140 : /**
141 : * clockevents_switch_state - set the operating state of a clock event device
142 : * @dev: device to modify
143 : * @state: new state
144 : *
145 : * Must be called with interrupts disabled !
146 : */
147 12 : void clockevents_switch_state(struct clock_event_device *dev,
148 : enum clock_event_state state)
149 : {
150 12 : if (clockevent_get_state(dev) != state) {
151 8 : if (__clockevents_switch_state(dev, state))
152 : return;
153 :
154 8 : clockevent_set_state(dev, state);
155 :
156 : /*
157 : * A nsec2cyc multiplicator of 0 is invalid and we'd crash
158 : * on it, so fix it up and emit a warning:
159 : */
160 8 : if (clockevent_state_oneshot(dev)) {
161 4 : if (WARN_ON(!dev->mult))
162 0 : dev->mult = 1;
163 : }
164 : }
165 : }
166 :
167 : /**
168 : * clockevents_shutdown - shutdown the device and clear next_event
169 : * @dev: device to shutdown
170 : */
171 4 : void clockevents_shutdown(struct clock_event_device *dev)
172 : {
173 0 : clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
174 4 : dev->next_event = KTIME_MAX;
175 4 : }
176 :
177 : /**
178 : * clockevents_tick_resume - Resume the tick device before using it again
179 : * @dev: device to resume
180 : */
181 0 : int clockevents_tick_resume(struct clock_event_device *dev)
182 : {
183 0 : int ret = 0;
184 :
185 0 : if (dev->tick_resume)
186 0 : ret = dev->tick_resume(dev);
187 :
188 0 : return ret;
189 : }
190 :
191 : #ifdef CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST
192 :
193 : /* Limit min_delta to a jiffie */
194 : #define MIN_DELTA_LIMIT (NSEC_PER_SEC / HZ)
195 :
196 : /**
197 : * clockevents_increase_min_delta - raise minimum delta of a clock event device
198 : * @dev: device to increase the minimum delta
199 : *
200 : * Returns 0 on success, -ETIME when the minimum delta reached the limit.
201 : */
202 0 : static int clockevents_increase_min_delta(struct clock_event_device *dev)
203 : {
204 : /* Nothing to do if we already reached the limit */
205 0 : if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {
206 0 : printk_deferred(KERN_WARNING
207 : "CE: Reprogramming failure. Giving up\n");
208 0 : dev->next_event = KTIME_MAX;
209 0 : return -ETIME;
210 : }
211 :
212 0 : if (dev->min_delta_ns < 5000)
213 0 : dev->min_delta_ns = 5000;
214 : else
215 0 : dev->min_delta_ns += dev->min_delta_ns >> 1;
216 :
217 0 : if (dev->min_delta_ns > MIN_DELTA_LIMIT)
218 0 : dev->min_delta_ns = MIN_DELTA_LIMIT;
219 :
220 0 : printk_deferred(KERN_WARNING
221 : "CE: %s increased min_delta_ns to %llu nsec\n",
222 0 : dev->name ? dev->name : "?",
223 0 : (unsigned long long) dev->min_delta_ns);
224 0 : return 0;
225 : }
226 :
227 : /**
228 : * clockevents_program_min_delta - Set clock event device to the minimum delay.
229 : * @dev: device to program
230 : *
231 : * Returns 0 on success, -ETIME when the retry loop failed.
232 : */
233 8 : static int clockevents_program_min_delta(struct clock_event_device *dev)
234 : {
235 8 : unsigned long long clc;
236 8 : int64_t delta;
237 8 : int i;
238 :
239 8 : for (i = 0;;) {
240 8 : delta = dev->min_delta_ns;
241 8 : dev->next_event = ktime_add_ns(ktime_get(), delta);
242 :
243 8 : if (clockevent_state_shutdown(dev))
244 : return 0;
245 :
246 8 : dev->retries++;
247 8 : clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
248 8 : if (dev->set_next_event((unsigned long) clc, dev) == 0)
249 : return 0;
250 :
251 0 : if (++i > 2) {
252 : /*
253 : * We tried 3 times to program the device with the
254 : * given min_delta_ns. Try to increase the minimum
255 : * delta, if that fails as well get out of here.
256 : */
257 0 : if (clockevents_increase_min_delta(dev))
258 : return -ETIME;
259 : i = 0;
260 : }
261 : }
262 : }
263 :
264 : #else /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
265 :
266 : /**
267 : * clockevents_program_min_delta - Set clock event device to the minimum delay.
268 : * @dev: device to program
269 : *
270 : * Returns 0 on success, -ETIME when the retry loop failed.
271 : */
272 : static int clockevents_program_min_delta(struct clock_event_device *dev)
273 : {
274 : unsigned long long clc;
275 : int64_t delta = 0;
276 : int i;
277 :
278 : for (i = 0; i < 10; i++) {
279 : delta += dev->min_delta_ns;
280 : dev->next_event = ktime_add_ns(ktime_get(), delta);
281 :
282 : if (clockevent_state_shutdown(dev))
283 : return 0;
284 :
285 : dev->retries++;
286 : clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
287 : if (dev->set_next_event((unsigned long) clc, dev) == 0)
288 : return 0;
289 : }
290 : return -ETIME;
291 : }
292 :
293 : #endif /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
294 :
295 : /**
296 : * clockevents_program_event - Reprogram the clock event device.
297 : * @dev: device to program
298 : * @expires: absolute expiry time (monotonic clock)
299 : * @force: program minimum delay if expires can not be set
300 : *
301 : * Returns 0 on success, -ETIME when the event is in the past.
302 : */
303 30176 : int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
304 : bool force)
305 : {
306 30176 : unsigned long long clc;
307 30176 : int64_t delta;
308 30176 : int rc;
309 :
310 30176 : if (WARN_ON_ONCE(expires < 0))
311 : return -ETIME;
312 :
313 30176 : dev->next_event = expires;
314 :
315 30176 : if (clockevent_state_shutdown(dev))
316 : return 0;
317 :
318 : /* We must be in ONESHOT state here */
319 30176 : WARN_ONCE(!clockevent_state_oneshot(dev), "Current state: %d\n",
320 : clockevent_get_state(dev));
321 :
322 : /* Shortcut for clockevent devices that can deal with ktime. */
323 30176 : if (dev->features & CLOCK_EVT_FEAT_KTIME)
324 0 : return dev->set_next_ktime(expires, dev);
325 :
326 30176 : delta = ktime_to_ns(ktime_sub(expires, ktime_get()));
327 30586 : if (delta <= 0)
328 12 : return force ? clockevents_program_min_delta(dev) : -ETIME;
329 :
330 30574 : delta = min(delta, (int64_t) dev->max_delta_ns);
331 30574 : delta = max(delta, (int64_t) dev->min_delta_ns);
332 :
333 30574 : clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
334 30574 : rc = dev->set_next_event((unsigned long) clc, dev);
335 :
336 29521 : return (rc && force) ? clockevents_program_min_delta(dev) : rc;
337 : }
338 :
339 : /*
340 : * Called after a notify add to make devices available which were
341 : * released from the notifier call.
342 : */
343 4 : static void clockevents_notify_released(void)
344 : {
345 4 : struct clock_event_device *dev;
346 :
347 4 : while (!list_empty(&clockevents_released)) {
348 0 : dev = list_entry(clockevents_released.next,
349 : struct clock_event_device, list);
350 0 : list_del(&dev->list);
351 0 : list_add(&dev->list, &clockevent_devices);
352 0 : tick_check_new_device(dev);
353 : }
354 4 : }
355 :
356 : /*
357 : * Try to install a replacement clock event device
358 : */
359 0 : static int clockevents_replace(struct clock_event_device *ced)
360 : {
361 0 : struct clock_event_device *dev, *newdev = NULL;
362 :
363 0 : list_for_each_entry(dev, &clockevent_devices, list) {
364 0 : if (dev == ced || !clockevent_state_detached(dev))
365 0 : continue;
366 :
367 0 : if (!tick_check_replacement(newdev, dev))
368 0 : continue;
369 :
370 0 : if (!try_module_get(dev->owner))
371 : continue;
372 :
373 : if (newdev)
374 0 : module_put(newdev->owner);
375 : newdev = dev;
376 : }
377 0 : if (newdev) {
378 0 : tick_install_replacement(newdev);
379 0 : list_del_init(&ced->list);
380 : }
381 0 : return newdev ? 0 : -EBUSY;
382 : }
383 :
384 : /*
385 : * Called with clockevents_mutex and clockevents_lock held
386 : */
387 0 : static int __clockevents_try_unbind(struct clock_event_device *ced, int cpu)
388 : {
389 : /* Fast track. Device is unused */
390 0 : if (clockevent_state_detached(ced)) {
391 0 : list_del_init(&ced->list);
392 0 : return 0;
393 : }
394 :
395 0 : return ced == per_cpu(tick_cpu_device, cpu).evtdev ? -EAGAIN : -EBUSY;
396 : }
397 :
398 : /*
399 : * SMP function call to unbind a device
400 : */
401 0 : static void __clockevents_unbind(void *arg)
402 : {
403 0 : struct ce_unbind *cu = arg;
404 0 : int res;
405 :
406 0 : raw_spin_lock(&clockevents_lock);
407 0 : res = __clockevents_try_unbind(cu->ce, smp_processor_id());
408 0 : if (res == -EAGAIN)
409 0 : res = clockevents_replace(cu->ce);
410 0 : cu->res = res;
411 0 : raw_spin_unlock(&clockevents_lock);
412 0 : }
413 :
414 : /*
415 : * Issues smp function call to unbind a per cpu device. Called with
416 : * clockevents_mutex held.
417 : */
418 0 : static int clockevents_unbind(struct clock_event_device *ced, int cpu)
419 : {
420 0 : struct ce_unbind cu = { .ce = ced, .res = -ENODEV };
421 :
422 0 : smp_call_function_single(cpu, __clockevents_unbind, &cu, 1);
423 0 : return cu.res;
424 : }
425 :
426 : /*
427 : * Unbind a clockevents device.
428 : */
429 0 : int clockevents_unbind_device(struct clock_event_device *ced, int cpu)
430 : {
431 0 : int ret;
432 :
433 0 : mutex_lock(&clockevents_mutex);
434 0 : ret = clockevents_unbind(ced, cpu);
435 0 : mutex_unlock(&clockevents_mutex);
436 0 : return ret;
437 : }
438 : EXPORT_SYMBOL_GPL(clockevents_unbind_device);
439 :
440 : /**
441 : * clockevents_register_device - register a clock event device
442 : * @dev: device to register
443 : */
444 4 : void clockevents_register_device(struct clock_event_device *dev)
445 : {
446 4 : unsigned long flags;
447 :
448 : /* Initialize state to DETACHED */
449 4 : clockevent_set_state(dev, CLOCK_EVT_STATE_DETACHED);
450 :
451 4 : if (!dev->cpumask) {
452 0 : WARN_ON(num_possible_cpus() > 1);
453 0 : dev->cpumask = cpumask_of(smp_processor_id());
454 : }
455 :
456 4 : if (dev->cpumask == cpu_all_mask) {
457 0 : WARN(1, "%s cpumask == cpu_all_mask, using cpu_possible_mask instead\n",
458 : dev->name);
459 0 : dev->cpumask = cpu_possible_mask;
460 : }
461 :
462 4 : raw_spin_lock_irqsave(&clockevents_lock, flags);
463 :
464 4 : list_add(&dev->list, &clockevent_devices);
465 4 : tick_check_new_device(dev);
466 4 : clockevents_notify_released();
467 :
468 4 : raw_spin_unlock_irqrestore(&clockevents_lock, flags);
469 4 : }
470 : EXPORT_SYMBOL_GPL(clockevents_register_device);
471 :
472 4 : static void clockevents_config(struct clock_event_device *dev, u32 freq)
473 : {
474 4 : u64 sec;
475 :
476 4 : if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
477 : return;
478 :
479 : /*
480 : * Calculate the maximum number of seconds we can sleep. Limit
481 : * to 10 minutes for hardware which can program more than
482 : * 32bit ticks so we still get reasonable conversion values.
483 : */
484 4 : sec = dev->max_delta_ticks;
485 4 : do_div(sec, freq);
486 4 : if (!sec)
487 : sec = 1;
488 4 : else if (sec > 600 && dev->max_delta_ticks > UINT_MAX)
489 4 : sec = 600;
490 :
491 4 : clockevents_calc_mult_shift(dev, freq, sec);
492 4 : dev->min_delta_ns = cev_delta2ns(dev->min_delta_ticks, dev, false);
493 4 : dev->max_delta_ns = cev_delta2ns(dev->max_delta_ticks, dev, true);
494 : }
495 :
496 : /**
497 : * clockevents_config_and_register - Configure and register a clock event device
498 : * @dev: device to register
499 : * @freq: The clock frequency
500 : * @min_delta: The minimum clock ticks to program in oneshot mode
501 : * @max_delta: The maximum clock ticks to program in oneshot mode
502 : *
503 : * min/max_delta can be 0 for devices which do not support oneshot mode.
504 : */
505 4 : void clockevents_config_and_register(struct clock_event_device *dev,
506 : u32 freq, unsigned long min_delta,
507 : unsigned long max_delta)
508 : {
509 4 : dev->min_delta_ticks = min_delta;
510 4 : dev->max_delta_ticks = max_delta;
511 4 : clockevents_config(dev, freq);
512 4 : clockevents_register_device(dev);
513 4 : }
514 : EXPORT_SYMBOL_GPL(clockevents_config_and_register);
515 :
516 0 : int __clockevents_update_freq(struct clock_event_device *dev, u32 freq)
517 : {
518 0 : clockevents_config(dev, freq);
519 :
520 0 : if (clockevent_state_oneshot(dev))
521 0 : return clockevents_program_event(dev, dev->next_event, false);
522 :
523 0 : if (clockevent_state_periodic(dev))
524 0 : return __clockevents_switch_state(dev, CLOCK_EVT_STATE_PERIODIC);
525 :
526 : return 0;
527 : }
528 :
529 : /**
530 : * clockevents_update_freq - Update frequency and reprogram a clock event device.
531 : * @dev: device to modify
532 : * @freq: new device frequency
533 : *
534 : * Reconfigure and reprogram a clock event device in oneshot
535 : * mode. Must be called on the cpu for which the device delivers per
536 : * cpu timer events. If called for the broadcast device the core takes
537 : * care of serialization.
538 : *
539 : * Returns 0 on success, -ETIME when the event is in the past.
540 : */
541 0 : int clockevents_update_freq(struct clock_event_device *dev, u32 freq)
542 : {
543 0 : unsigned long flags;
544 0 : int ret;
545 :
546 0 : local_irq_save(flags);
547 0 : ret = tick_broadcast_update_freq(dev, freq);
548 0 : if (ret == -ENODEV)
549 0 : ret = __clockevents_update_freq(dev, freq);
550 0 : local_irq_restore(flags);
551 0 : return ret;
552 : }
553 :
554 : /*
555 : * Noop handler when we shut down an event device
556 : */
557 0 : void clockevents_handle_noop(struct clock_event_device *dev)
558 : {
559 0 : }
560 :
561 : /**
562 : * clockevents_exchange_device - release and request clock devices
563 : * @old: device to release (can be NULL)
564 : * @new: device to request (can be NULL)
565 : *
566 : * Called from various tick functions with clockevents_lock held and
567 : * interrupts disabled.
568 : */
569 4 : void clockevents_exchange_device(struct clock_event_device *old,
570 : struct clock_event_device *new)
571 : {
572 : /*
573 : * Caller releases a clock event device. We queue it into the
574 : * released list and do a notify add later.
575 : */
576 4 : if (old) {
577 0 : module_put(old->owner);
578 0 : clockevents_switch_state(old, CLOCK_EVT_STATE_DETACHED);
579 0 : list_del(&old->list);
580 0 : list_add(&old->list, &clockevents_released);
581 : }
582 :
583 4 : if (new) {
584 4 : BUG_ON(!clockevent_state_detached(new));
585 4 : clockevents_shutdown(new);
586 : }
587 4 : }
588 :
589 : /**
590 : * clockevents_suspend - suspend clock devices
591 : */
592 0 : void clockevents_suspend(void)
593 : {
594 0 : struct clock_event_device *dev;
595 :
596 0 : list_for_each_entry_reverse(dev, &clockevent_devices, list)
597 0 : if (dev->suspend && !clockevent_state_detached(dev))
598 0 : dev->suspend(dev);
599 0 : }
600 :
601 : /**
602 : * clockevents_resume - resume clock devices
603 : */
604 0 : void clockevents_resume(void)
605 : {
606 0 : struct clock_event_device *dev;
607 :
608 0 : list_for_each_entry(dev, &clockevent_devices, list)
609 0 : if (dev->resume && !clockevent_state_detached(dev))
610 0 : dev->resume(dev);
611 0 : }
612 :
613 : #ifdef CONFIG_HOTPLUG_CPU
614 :
615 : # ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
616 : /**
617 : * tick_offline_cpu - Take CPU out of the broadcast mechanism
618 : * @cpu: The outgoing CPU
619 : *
620 : * Called on the outgoing CPU after it took itself offline.
621 : */
622 0 : void tick_offline_cpu(unsigned int cpu)
623 : {
624 0 : raw_spin_lock(&clockevents_lock);
625 0 : tick_broadcast_offline(cpu);
626 0 : raw_spin_unlock(&clockevents_lock);
627 0 : }
628 : # endif
629 :
630 : /**
631 : * tick_cleanup_dead_cpu - Cleanup the tick and clockevents of a dead cpu
632 : */
633 0 : void tick_cleanup_dead_cpu(int cpu)
634 : {
635 0 : struct clock_event_device *dev, *tmp;
636 0 : unsigned long flags;
637 :
638 0 : raw_spin_lock_irqsave(&clockevents_lock, flags);
639 :
640 0 : tick_shutdown(cpu);
641 : /*
642 : * Unregister the clock event devices which were
643 : * released from the users in the notify chain.
644 : */
645 0 : list_for_each_entry_safe(dev, tmp, &clockevents_released, list)
646 0 : list_del(&dev->list);
647 : /*
648 : * Now check whether the CPU has left unused per cpu devices
649 : */
650 0 : list_for_each_entry_safe(dev, tmp, &clockevent_devices, list) {
651 0 : if (cpumask_test_cpu(cpu, dev->cpumask) &&
652 0 : cpumask_weight(dev->cpumask) == 1 &&
653 0 : !tick_is_broadcast_device(dev)) {
654 0 : BUG_ON(!clockevent_state_detached(dev));
655 0 : list_del(&dev->list);
656 : }
657 : }
658 0 : raw_spin_unlock_irqrestore(&clockevents_lock, flags);
659 0 : }
660 : #endif
661 :
662 : #ifdef CONFIG_SYSFS
663 : static struct bus_type clockevents_subsys = {
664 : .name = "clockevents",
665 : .dev_name = "clockevent",
666 : };
667 :
668 : static DEFINE_PER_CPU(struct device, tick_percpu_dev);
669 : static struct tick_device *tick_get_tick_dev(struct device *dev);
670 :
671 0 : static ssize_t sysfs_show_current_tick_dev(struct device *dev,
672 : struct device_attribute *attr,
673 : char *buf)
674 : {
675 0 : struct tick_device *td;
676 0 : ssize_t count = 0;
677 :
678 0 : raw_spin_lock_irq(&clockevents_lock);
679 0 : td = tick_get_tick_dev(dev);
680 0 : if (td && td->evtdev)
681 0 : count = snprintf(buf, PAGE_SIZE, "%s\n", td->evtdev->name);
682 0 : raw_spin_unlock_irq(&clockevents_lock);
683 0 : return count;
684 : }
685 : static DEVICE_ATTR(current_device, 0444, sysfs_show_current_tick_dev, NULL);
686 :
687 : /* We don't support the abomination of removable broadcast devices */
688 0 : static ssize_t sysfs_unbind_tick_dev(struct device *dev,
689 : struct device_attribute *attr,
690 : const char *buf, size_t count)
691 : {
692 0 : char name[CS_NAME_LEN];
693 0 : ssize_t ret = sysfs_get_uname(buf, name, count);
694 0 : struct clock_event_device *ce;
695 :
696 0 : if (ret < 0)
697 : return ret;
698 :
699 0 : ret = -ENODEV;
700 0 : mutex_lock(&clockevents_mutex);
701 0 : raw_spin_lock_irq(&clockevents_lock);
702 0 : list_for_each_entry(ce, &clockevent_devices, list) {
703 0 : if (!strcmp(ce->name, name)) {
704 0 : ret = __clockevents_try_unbind(ce, dev->id);
705 0 : break;
706 : }
707 : }
708 0 : raw_spin_unlock_irq(&clockevents_lock);
709 : /*
710 : * We hold clockevents_mutex, so ce can't go away
711 : */
712 0 : if (ret == -EAGAIN)
713 0 : ret = clockevents_unbind(ce, dev->id);
714 0 : mutex_unlock(&clockevents_mutex);
715 0 : return ret ? ret : count;
716 : }
717 : static DEVICE_ATTR(unbind_device, 0200, NULL, sysfs_unbind_tick_dev);
718 :
719 : #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
720 : static struct device tick_bc_dev = {
721 : .init_name = "broadcast",
722 : .id = 0,
723 : .bus = &clockevents_subsys,
724 : };
725 :
726 0 : static struct tick_device *tick_get_tick_dev(struct device *dev)
727 : {
728 0 : return dev == &tick_bc_dev ? tick_get_broadcast_device() :
729 0 : &per_cpu(tick_cpu_device, dev->id);
730 : }
731 :
732 1 : static __init int tick_broadcast_init_sysfs(void)
733 : {
734 1 : int err = device_register(&tick_bc_dev);
735 :
736 1 : if (!err)
737 1 : err = device_create_file(&tick_bc_dev, &dev_attr_current_device);
738 1 : return err;
739 : }
740 : #else
741 : static struct tick_device *tick_get_tick_dev(struct device *dev)
742 : {
743 : return &per_cpu(tick_cpu_device, dev->id);
744 : }
745 : static inline int tick_broadcast_init_sysfs(void) { return 0; }
746 : #endif
747 :
748 1 : static int __init tick_init_sysfs(void)
749 : {
750 1 : int cpu;
751 :
752 5 : for_each_possible_cpu(cpu) {
753 4 : struct device *dev = &per_cpu(tick_percpu_dev, cpu);
754 4 : int err;
755 :
756 4 : dev->id = cpu;
757 4 : dev->bus = &clockevents_subsys;
758 4 : err = device_register(dev);
759 4 : if (!err)
760 4 : err = device_create_file(dev, &dev_attr_current_device);
761 4 : if (!err)
762 4 : err = device_create_file(dev, &dev_attr_unbind_device);
763 4 : if (err)
764 0 : return err;
765 : }
766 1 : return tick_broadcast_init_sysfs();
767 : }
768 :
769 1 : static int __init clockevents_init_sysfs(void)
770 : {
771 1 : int err = subsys_system_register(&clockevents_subsys, NULL);
772 :
773 1 : if (!err)
774 1 : err = tick_init_sysfs();
775 1 : return err;
776 : }
777 : device_initcall(clockevents_init_sysfs);
778 : #endif /* SYSFS */
|
