drivers/timer/timer-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Thomas Chou <thomas@wytron.com.tw>
   4  */
   5
   6 #include <common.h>
   7 #include <clk.h>
   8 #include <cpu.h>
   9 #include <dm.h>
  10 #include <dm/lists.h>
  11 #include <dm/device_compat.h>
  12 #include <dm/device-internal.h>
  13 #include <dm/root.h>
  14 #include <errno.h>
  15 #include <init.h>
  16 #include <timer.h>
  17 #include <linux/err.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 /*
  22  * Implement a timer uclass to work with lib/time.c. The timer is usually
  23  * a 32/64 bits free-running up counter. The get_rate() method is used to get
  24  * the input clock frequency of the timer. The get_count() method is used
  25  * to get the current 64 bits count value. If the hardware is counting down,
  26  * the value should be inversed inside the method. There may be no real
  27  * tick, and no timer interrupt.
  28  */
  29
  30 int notrace timer_get_count(struct udevice *dev, u64 *count)
  31 {
  32         const struct timer_ops *ops = device_get_ops(dev);
  33
  34         if (!ops->get_count)
  35                 return -ENOSYS;
  36
  37         *count = ops->get_count(dev);
  38         return 0;
  39 }
  40
  41 unsigned long notrace timer_get_rate(struct udevice *dev)
  42 {
  43         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  44
  45         return uc_priv->clock_rate;
  46 }
  47
  48 static int timer_pre_probe(struct udevice *dev)
  49 {
  50 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
  51         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  52         struct clk timer_clk;
  53         int err;
  54         ulong ret;
  55
  56         /* It is possible that a timer device has a null ofnode */
  57         if (!dev_has_ofnode(dev))
  58                 return 0;
  59
  60         err = clk_get_by_index(dev, 0, &timer_clk);
  61         if (!err) {
  62                 ret = clk_get_rate(&timer_clk);
  63                 if (IS_ERR_VALUE(ret))
  64                         return ret;
  65                 uc_priv->clock_rate = ret;
  66         } else {
  67                 uc_priv->clock_rate =
  68                         dev_read_u32_default(dev, "clock-frequency", 0);
  69         }
  70 #endif
  71
  72         return 0;
  73 }
  74
  75 static int timer_post_probe(struct udevice *dev)
  76 {
  77         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  78
  79         if (!uc_priv->clock_rate)
  80                 return -EINVAL;
  81
  82         return 0;
  83 }
  84
  85 /*
  86  * TODO: should be CONFIG_IS_ENABLED(CPU), but the SPL config has _SUPPORT on
  87  * the end...
  88  */
  89 #if defined(CONFIG_CPU) || defined(CONFIG_SPL_CPU_SUPPORT)
  90 int timer_timebase_fallback(struct udevice *dev)
  91 {
  92         struct udevice *cpu;
  93         struct cpu_plat *cpu_plat;
  94         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  95
  96         /* Did we get our clock rate from the device tree? */
  97         if (uc_priv->clock_rate)
  98                 return 0;
  99
 100         /* Fall back to timebase-frequency */
 101         dev_dbg(dev, "missing clocks or clock-frequency property; falling back on timebase-frequency\n");
 102         cpu = cpu_get_current_dev();
 103         if (!cpu)
 104                 return -ENODEV;
 105
 106         cpu_plat = dev_get_parent_plat(cpu);
 107         if (!cpu_plat)
 108                 return -ENODEV;
 109
 110         uc_priv->clock_rate = cpu_plat->timebase_freq;
 111         return 0;
 112 }
 113 #endif
 114
 115 u64 timer_conv_64(u32 count)
 116 {
 117         /* increment tbh if tbl has rolled over */
 118         if (count < gd->timebase_l)
 119                 gd->timebase_h++;
 120         gd->timebase_l = count;
 121         return ((u64)gd->timebase_h << 32) | gd->timebase_l;
 122 }
 123
 124 int notrace dm_timer_init(void)
 125 {
 126         struct udevice *dev = NULL;
 127         __maybe_unused ofnode node;
 128         int ret;
 129
 130         if (gd->timer)
 131                 return 0;
 132
 133         /*
 134          * Directly access gd->dm_root to suppress error messages, if the
 135          * virtual root driver does not yet exist.
 136          */
 137         if (gd->dm_root == NULL)
 138                 return -EAGAIN;
 139
 140 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
 141         /* Check for a chosen timer to be used for tick */
 142         node = ofnode_get_chosen_node("tick-timer");
 143
 144         if (ofnode_valid(node) &&
 145             uclass_get_device_by_ofnode(UCLASS_TIMER, node, &dev)) {
 146                 /*
 147                  * If the timer is not marked to be bound before
 148                  * relocation, bind it anyway.
 149                  */
 150                 if (!lists_bind_fdt(dm_root(), node, &dev, false)) {
 151                         ret = device_probe(dev);
 152                         if (ret)
 153                                 return ret;
 154                 }
 155         }
 156 #endif
 157
 158         if (!dev) {
 159                 /* Fall back to the first available timer */
 160                 ret = uclass_first_device_err(UCLASS_TIMER, &dev);
 161                 if (ret)
 162                         return ret;
 163         }
 164
 165         if (dev) {
 166                 gd->timer = dev;
 167                 return 0;
 168         }
 169
 170         return -ENODEV;
 171 }
 172
 173 UCLASS_DRIVER(timer) = {
 174         .id             = UCLASS_TIMER,
 175         .name           = "timer",
 176         .pre_probe      = timer_pre_probe,
 177         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 178         .post_probe     = timer_post_probe,
 179         .per_device_auto        = sizeof(struct timer_dev_priv),
 180 };