drivers/timer/timer-uclass.c

   1 /*
   2  * Copyright (C) 2015 Thomas Chou <thomas@wytron.com.tw>
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <dm/lists.h>
  10 #include <dm/device-internal.h>
  11 #include <errno.h>
  12 #include <timer.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /*
  17  * Implement a timer uclass to work with lib/time.c. The timer is usually
  18  * a 32/64 bits free-running up counter. The get_rate() method is used to get
  19  * the input clock frequency of the timer. The get_count() method is used
  20  * to get the current 64 bits count value. If the hardware is counting down,
  21  * the value should be inversed inside the method. There may be no real
  22  * tick, and no timer interrupt.
  23  */
  24
  25 int timer_get_count(struct udevice *dev, u64 *count)
  26 {
  27         const struct timer_ops *ops = device_get_ops(dev);
  28
  29         if (!ops->get_count)
  30                 return -ENOSYS;
  31
  32         return ops->get_count(dev, count);
  33 }
  34
  35 unsigned long timer_get_rate(struct udevice *dev)
  36 {
  37         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  38
  39         return uc_priv->clock_rate;
  40 }
  41
  42 static int timer_pre_probe(struct udevice *dev)
  43 {
  44         struct timer_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  45
  46         uc_priv->clock_rate = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
  47                                              "clock-frequency", 0);
  48
  49         return 0;
  50 }
  51
  52 u64 timer_conv_64(u32 count)
  53 {
  54         /* increment tbh if tbl has rolled over */
  55         if (count < gd->timebase_l)
  56                 gd->timebase_h++;
  57         gd->timebase_l = count;
  58         return ((u64)gd->timebase_h << 32) | gd->timebase_l;
  59 }
  60
  61 int notrace dm_timer_init(void)
  62 {
  63         const void *blob = gd->fdt_blob;
  64         struct udevice *dev = NULL;
  65         int node;
  66         int ret;
  67
  68         if (gd->timer)
  69                 return 0;
  70
  71         /* Check for a chosen timer to be used for tick */
  72         node = fdtdec_get_chosen_node(blob, "tick-timer");
  73         if (node < 0) {
  74                 /* No chosen timer, trying first available timer */
  75                 ret = uclass_first_device(UCLASS_TIMER, &dev);
  76                 if (ret)
  77                         return ret;
  78                 if (!dev)
  79                         return -ENODEV;
  80         } else {
  81                 if (uclass_get_device_by_of_offset(UCLASS_TIMER, node, &dev)) {
  82                         /*
  83                          * If the timer is not marked to be bound before
  84                          * relocation, bind it anyway.
  85                          */
  86                         if (node > 0 &&
  87                             !lists_bind_fdt(gd->dm_root, blob, node, &dev)) {
  88                                 ret = device_probe(dev);
  89                                 if (ret)
  90                                         return ret;
  91                         }
  92                 }
  93         }
  94
  95         if (dev) {
  96                 gd->timer = dev;
  97                 return 0;
  98         }
  99
 100         return -ENODEV;
 101 }
 102
 103 UCLASS_DRIVER(timer) = {
 104         .id             = UCLASS_TIMER,
 105         .name           = "timer",
 106         .pre_probe      = timer_pre_probe,
 107         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 108         .per_device_auto_alloc_size = sizeof(struct timer_dev_priv),
 109 };