LCOV - code coverage report
Current view: top level - kernel/time - clockevents.c (source / functions) Hit Total Coverage
Test: Real Lines: 103 210 49.0 %
Date: 2020-10-17 15:46:16 Functions: 0 26 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     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                 :          3 : static u64 cev_delta2ns(unsigned long latch, struct clock_event_device *evt,
      33                 :            :                         bool ismax)
      34                 :            : {
      35                 :          3 :         u64 clc = (u64) latch << evt->shift;
      36                 :            :         u64 rnd;
      37                 :            : 
      38                 :          3 :         if (WARN_ON(!evt->mult))
      39                 :          0 :                 evt->mult = 1;
      40                 :          3 :         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                 :          3 :         if ((clc >> evt->shift) != (u64)latch)
      47                 :          0 :                 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                 :          3 :         if ((~0ULL - clc > rnd) &&
      69                 :          3 :             (!ismax || evt->mult <= (1ULL << evt->shift)))
      70                 :          3 :                 clc += rnd;
      71                 :            : 
      72                 :          3 :         do_div(clc, evt->mult);
      73                 :            : 
      74                 :            :         /* Deltas less than 1usec are pointless noise */
      75                 :          3 :         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                 :          3 : static int __clockevents_switch_state(struct clock_event_device *dev,
      92                 :            :                                       enum clock_event_state state)
      93                 :            : {
      94                 :          3 :         if (dev->features & CLOCK_EVT_FEAT_DUMMY)
      95                 :            :                 return 0;
      96                 :            : 
      97                 :            :         /* Transition with new state-specific callbacks */
      98                 :          3 :         switch (state) {
      99                 :            :         case CLOCK_EVT_STATE_DETACHED:
     100                 :            :                 /* The clockevent device is getting replaced. Shut it down. */
     101                 :            : 
     102                 :            :         case CLOCK_EVT_STATE_SHUTDOWN:
     103                 :          3 :                 if (dev->set_state_shutdown)
     104                 :          3 :                         return dev->set_state_shutdown(dev);
     105                 :            :                 return 0;
     106                 :            : 
     107                 :            :         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                 :            :         case CLOCK_EVT_STATE_ONESHOT:
     116                 :            :                 /* Core internal bug */
     117                 :          3 :                 if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
     118                 :            :                         return -ENOSYS;
     119                 :          3 :                 if (dev->set_state_oneshot)
     120                 :          0 :                         return dev->set_state_oneshot(dev);
     121                 :            :                 return 0;
     122                 :            : 
     123                 :            :         case CLOCK_EVT_STATE_ONESHOT_STOPPED:
     124                 :            :                 /* Core internal bug */
     125                 :          3 :                 if (WARN_ONCE(!clockevent_state_oneshot(dev),
     126                 :            :                               "Current state: %d\n",
     127                 :            :                               clockevent_get_state(dev)))
     128                 :            :                         return -EINVAL;
     129                 :            : 
     130                 :          3 :                 if (dev->set_state_oneshot_stopped)
     131                 :          3 :                         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                 :          3 : void clockevents_switch_state(struct clock_event_device *dev,
     148                 :            :                               enum clock_event_state state)
     149                 :            : {
     150                 :          3 :         if (clockevent_get_state(dev) != state) {
     151                 :          3 :                 if (__clockevents_switch_state(dev, state))
     152                 :          3 :                         return;
     153                 :            : 
     154                 :            :                 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                 :          3 :                 if (clockevent_state_oneshot(dev)) {
     161                 :          3 :                         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                 :          0 : void clockevents_shutdown(struct clock_event_device *dev)
     172                 :            : {
     173                 :          3 :         clockevents_switch_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
     174                 :          3 :         dev->next_event = KTIME_MAX;
     175                 :          0 : }
     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                 :            :         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                 :            : static int clockevents_increase_min_delta(struct clock_event_device *dev)
     203                 :            : {
     204                 :            :         /* Nothing to do if we already reached the limit */
     205                 :            :         if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {
     206                 :            :                 printk_deferred(KERN_WARNING
     207                 :            :                                 "CE: Reprogramming failure. Giving up\n");
     208                 :            :                 dev->next_event = KTIME_MAX;
     209                 :            :                 return -ETIME;
     210                 :            :         }
     211                 :            : 
     212                 :            :         if (dev->min_delta_ns < 5000)
     213                 :            :                 dev->min_delta_ns = 5000;
     214                 :            :         else
     215                 :            :                 dev->min_delta_ns += dev->min_delta_ns >> 1;
     216                 :            : 
     217                 :            :         if (dev->min_delta_ns > MIN_DELTA_LIMIT)
     218                 :            :                 dev->min_delta_ns = MIN_DELTA_LIMIT;
     219                 :            : 
     220                 :            :         printk_deferred(KERN_WARNING
     221                 :            :                         "CE: %s increased min_delta_ns to %llu nsec\n",
     222                 :            :                         dev->name ? dev->name : "?",
     223                 :            :                         (unsigned long long) dev->min_delta_ns);
     224                 :            :         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                 :            : static int clockevents_program_min_delta(struct clock_event_device *dev)
     234                 :            : {
     235                 :            :         unsigned long long clc;
     236                 :            :         int64_t delta;
     237                 :            :         int i;
     238                 :            : 
     239                 :            :         for (i = 0;;) {
     240                 :            :                 delta = dev->min_delta_ns;
     241                 :            :                 dev->next_event = ktime_add_ns(ktime_get(), delta);
     242                 :            : 
     243                 :            :                 if (clockevent_state_shutdown(dev))
     244                 :            :                         return 0;
     245                 :            : 
     246                 :            :                 dev->retries++;
     247                 :            :                 clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
     248                 :            :                 if (dev->set_next_event((unsigned long) clc, dev) == 0)
     249                 :            :                         return 0;
     250                 :            : 
     251                 :            :                 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                 :            :                         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                 :          3 : 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                 :          3 :         for (i = 0; i < 10; i++) {
     279                 :          3 :                 delta += dev->min_delta_ns;
     280                 :          3 :                 dev->next_event = ktime_add_ns(ktime_get(), delta);
     281                 :            : 
     282                 :          3 :                 if (clockevent_state_shutdown(dev))
     283                 :            :                         return 0;
     284                 :            : 
     285                 :          3 :                 dev->retries++;
     286                 :          3 :                 clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
     287                 :          3 :                 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                 :          3 : int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
     304                 :            :                               bool force)
     305                 :            : {
     306                 :            :         unsigned long long clc;
     307                 :            :         int64_t delta;
     308                 :            :         int rc;
     309                 :            : 
     310                 :          3 :         if (WARN_ON_ONCE(expires < 0))
     311                 :            :                 return -ETIME;
     312                 :            : 
     313                 :          3 :         dev->next_event = expires;
     314                 :            : 
     315                 :          3 :         if (clockevent_state_shutdown(dev))
     316                 :            :                 return 0;
     317                 :            : 
     318                 :            :         /* We must be in ONESHOT state here */
     319                 :          3 :         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                 :          3 :         if (dev->features & CLOCK_EVT_FEAT_KTIME)
     324                 :          0 :                 return dev->set_next_ktime(expires, dev);
     325                 :            : 
     326                 :          3 :         delta = ktime_to_ns(ktime_sub(expires, ktime_get()));
     327                 :          3 :         if (delta <= 0)
     328                 :          3 :                 return force ? clockevents_program_min_delta(dev) : -ETIME;
     329                 :            : 
     330                 :          3 :         delta = min(delta, (int64_t) dev->max_delta_ns);
     331                 :          3 :         delta = max(delta, (int64_t) dev->min_delta_ns);
     332                 :            : 
     333                 :          3 :         clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
     334                 :          3 :         rc = dev->set_next_event((unsigned long) clc, dev);
     335                 :            : 
     336                 :          3 :         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                 :          3 : static void clockevents_notify_released(void)
     344                 :            : {
     345                 :            :         struct clock_event_device *dev;
     346                 :            : 
     347                 :          3 :         while (!list_empty(&clockevents_released)) {
     348                 :          0 :                 dev = list_entry(clockevents_released.next,
     349                 :            :                                  struct clock_event_device, list);
     350                 :            :                 list_del(&dev->list);
     351                 :          0 :                 list_add(&dev->list, &clockevent_devices);
     352                 :          0 :                 tick_check_new_device(dev);
     353                 :            :         }
     354                 :          3 : }
     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                 :            :         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                 :          0 :                         continue;
     372                 :            : 
     373                 :          0 :                 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                 :            : 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                 :            :                 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                 :            :         struct ce_unbind *cu = arg;
     404                 :            :         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                 :            :         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                 :            : 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                 :            :         int ret;
     432                 :            : 
     433                 :          0 :         mutex_lock(&clockevents_mutex);
     434                 :            :         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                 :          3 : void clockevents_register_device(struct clock_event_device *dev)
     445                 :            : {
     446                 :            :         unsigned long flags;
     447                 :            : 
     448                 :            :         /* Initialize state to DETACHED */
     449                 :            :         clockevent_set_state(dev, CLOCK_EVT_STATE_DETACHED);
     450                 :            : 
     451                 :          3 :         if (!dev->cpumask) {
     452                 :          0 :                 WARN_ON(num_possible_cpus() > 1);
     453                 :          0 :                 dev->cpumask = cpumask_of(smp_processor_id());
     454                 :            :         }
     455                 :            : 
     456                 :          3 :         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                 :          3 :         raw_spin_lock_irqsave(&clockevents_lock, flags);
     463                 :            : 
     464                 :          3 :         list_add(&dev->list, &clockevent_devices);
     465                 :          3 :         tick_check_new_device(dev);
     466                 :          3 :         clockevents_notify_released();
     467                 :            : 
     468                 :          3 :         raw_spin_unlock_irqrestore(&clockevents_lock, flags);
     469                 :          3 : }
     470                 :            : EXPORT_SYMBOL_GPL(clockevents_register_device);
     471                 :            : 
     472                 :          3 : static void clockevents_config(struct clock_event_device *dev, u32 freq)
     473                 :            : {
     474                 :            :         u64 sec;
     475                 :            : 
     476                 :          3 :         if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
     477                 :          0 :                 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                 :          3 :         sec = dev->max_delta_ticks;
     485                 :          3 :         do_div(sec, freq);
     486                 :          3 :         if (!sec)
     487                 :          0 :                 sec = 1;
     488                 :            :         else if (sec > 600 && dev->max_delta_ticks > UINT_MAX)
     489                 :            :                 sec = 600;
     490                 :            : 
     491                 :          3 :         clockevents_calc_mult_shift(dev, freq, sec);
     492                 :          3 :         dev->min_delta_ns = cev_delta2ns(dev->min_delta_ticks, dev, false);
     493                 :          3 :         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                 :          3 : void clockevents_config_and_register(struct clock_event_device *dev,
     506                 :            :                                      u32 freq, unsigned long min_delta,
     507                 :            :                                      unsigned long max_delta)
     508                 :            : {
     509                 :          3 :         dev->min_delta_ticks = min_delta;
     510                 :          3 :         dev->max_delta_ticks = max_delta;
     511                 :          3 :         clockevents_config(dev, freq);
     512                 :          3 :         clockevents_register_device(dev);
     513                 :          3 : }
     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                 :            :         unsigned long flags;
     544                 :            :         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                 :          3 : 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                 :          3 :         if (old) {
     577                 :          0 :                 module_put(old->owner);
     578                 :          0 :                 clockevents_switch_state(old, CLOCK_EVT_STATE_DETACHED);
     579                 :            :                 list_del(&old->list);
     580                 :          0 :                 list_add(&old->list, &clockevents_released);
     581                 :            :         }
     582                 :            : 
     583                 :          3 :         if (new) {
     584                 :          3 :                 BUG_ON(!clockevent_state_detached(new));
     585                 :            :                 clockevents_shutdown(new);
     586                 :            :         }
     587                 :          3 : }
     588                 :            : 
     589                 :            : /**
     590                 :            :  * clockevents_suspend - suspend clock devices
     591                 :            :  */
     592                 :          0 : void clockevents_suspend(void)
     593                 :            : {
     594                 :            :         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                 :            :         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                 :            : void tick_offline_cpu(unsigned int cpu)
     623                 :            : {
     624                 :            :         raw_spin_lock(&clockevents_lock);
     625                 :            :         tick_broadcast_offline(cpu);
     626                 :            :         raw_spin_unlock(&clockevents_lock);
     627                 :            : }
     628                 :            : # endif
     629                 :            : 
     630                 :            : /**
     631                 :            :  * tick_cleanup_dead_cpu - Cleanup the tick and clockevents of a dead cpu
     632                 :            :  */
     633                 :            : void tick_cleanup_dead_cpu(int cpu)
     634                 :            : {
     635                 :            :         struct clock_event_device *dev, *tmp;
     636                 :            :         unsigned long flags;
     637                 :            : 
     638                 :            :         raw_spin_lock_irqsave(&clockevents_lock, flags);
     639                 :            : 
     640                 :            :         tick_shutdown(cpu);
     641                 :            :         /*
     642                 :            :          * Unregister the clock event devices which were
     643                 :            :          * released from the users in the notify chain.
     644                 :            :          */
     645                 :            :         list_for_each_entry_safe(dev, tmp, &clockevents_released, list)
     646                 :            :                 list_del(&dev->list);
     647                 :            :         /*
     648                 :            :          * Now check whether the CPU has left unused per cpu devices
     649                 :            :          */
     650                 :            :         list_for_each_entry_safe(dev, tmp, &clockevent_devices, list) {
     651                 :            :                 if (cpumask_test_cpu(cpu, dev->cpumask) &&
     652                 :            :                     cpumask_weight(dev->cpumask) == 1 &&
     653                 :            :                     !tick_is_broadcast_device(dev)) {
     654                 :            :                         BUG_ON(!clockevent_state_detached(dev));
     655                 :            :                         list_del(&dev->list);
     656                 :            :                 }
     657                 :            :         }
     658                 :            :         raw_spin_unlock_irqrestore(&clockevents_lock, flags);
     659                 :            : }
     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                 :            :         struct tick_device *td;
     676                 :            :         ssize_t count = 0;
     677                 :            : 
     678                 :          0 :         raw_spin_lock_irq(&clockevents_lock);
     679                 :            :         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                 :            :         char name[CS_NAME_LEN];
     693                 :          0 :         ssize_t ret = sysfs_get_uname(buf, name, count);
     694                 :            :         struct clock_event_device *ce;
     695                 :            : 
     696                 :          0 :         if (ret < 0)
     697                 :            :                 return ret;
     698                 :            : 
     699                 :            :         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                 :            : 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                 :          3 : static __init int tick_broadcast_init_sysfs(void)
     733                 :            : {
     734                 :          3 :         int err = device_register(&tick_bc_dev);
     735                 :            : 
     736                 :          3 :         if (!err)
     737                 :          3 :                 err = device_create_file(&tick_bc_dev, &dev_attr_current_device);
     738                 :          3 :         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                 :          3 : static int __init tick_init_sysfs(void)
     749                 :            : {
     750                 :            :         int cpu;
     751                 :            : 
     752                 :          3 :         for_each_possible_cpu(cpu) {
     753                 :          3 :                 struct device *dev = &per_cpu(tick_percpu_dev, cpu);
     754                 :            :                 int err;
     755                 :            : 
     756                 :          3 :                 dev->id = cpu;
     757                 :          3 :                 dev->bus = &clockevents_subsys;
     758                 :          3 :                 err = device_register(dev);
     759                 :          3 :                 if (!err)
     760                 :          3 :                         err = device_create_file(dev, &dev_attr_current_device);
     761                 :          3 :                 if (!err)
     762                 :          3 :                         err = device_create_file(dev, &dev_attr_unbind_device);
     763                 :          3 :                 if (err)
     764                 :          0 :                         return err;
     765                 :            :         }
     766                 :          3 :         return tick_broadcast_init_sysfs();
     767                 :            : }
     768                 :            : 
     769                 :          3 : static int __init clockevents_init_sysfs(void)
     770                 :            : {
     771                 :          3 :         int err = subsys_system_register(&clockevents_subsys, NULL);
     772                 :            : 
     773                 :          3 :         if (!err)
     774                 :          3 :                 err = tick_init_sysfs();
     775                 :          3 :         return err;
     776                 :            : }
     777                 :            : device_initcall(clockevents_init_sysfs);
     778                 :            : #endif /* SYSFS */
    

Generated by: LCOV version 1.14