clockevents.c 18 KB

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