drivers/watchdog/wdt-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2017 Google, Inc
   4  */
   5
   6 #define LOG_CATEGORY UCLASS_WDT
   7
   8 #include <common.h>
   9 #include <cyclic.h>
  10 #include <dm.h>
  11 #include <errno.h>
  12 #include <hang.h>
  13 #include <log.h>
  14 #include <sysreset.h>
  15 #include <time.h>
  16 #include <wdt.h>
  17 #include <asm/global_data.h>
  18 #include <dm/device-internal.h>
  19 #include <dm/lists.h>
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 #define WATCHDOG_TIMEOUT_SECS   (CONFIG_WATCHDOG_TIMEOUT_MSECS / 1000)
  24
  25 struct wdt_priv {
  26         /* Timeout, in seconds, to configure this device to. */
  27         u32 timeout;
  28         /*
  29          * Time, in milliseconds, between calling the device's ->reset()
  30          * method from watchdog_reset().
  31          */
  32         ulong reset_period;
  33         /*
  34          * Next time (as returned by get_timer(0)) to call
  35          * ->reset().
  36          */
  37         ulong next_reset;
  38         /* Whether watchdog_start() has been called on the device. */
  39         bool running;
  40         /* No autostart */
  41         bool noautostart;
  42
  43         struct cyclic_info *cyclic;
  44 };
  45
  46 static void wdt_cyclic(void *ctx)
  47 {
  48         struct udevice *dev = ctx;
  49         struct wdt_priv *priv;
  50
  51         if (!device_active(dev))
  52                 return;
  53
  54         priv = dev_get_uclass_priv(dev);
  55         if (!priv->running)
  56                 return;
  57
  58         wdt_reset(dev);
  59 }
  60
  61 static void init_watchdog_dev(struct udevice *dev)
  62 {
  63         struct wdt_priv *priv;
  64         int ret;
  65
  66         priv = dev_get_uclass_priv(dev);
  67
  68         if (IS_ENABLED(CONFIG_SYSRESET_WATCHDOG_AUTO)) {
  69                 ret = sysreset_register_wdt(dev);
  70                 if (ret)
  71                         printf("WDT:   Failed to register %s for sysreset\n",
  72                                dev->name);
  73         }
  74
  75         if (!IS_ENABLED(CONFIG_WATCHDOG_AUTOSTART) || priv->noautostart) {
  76                 printf("WDT:   Not starting %s\n", dev->name);
  77                 return;
  78         }
  79
  80         ret = wdt_start(dev, priv->timeout * 1000, 0);
  81         if (ret != 0) {
  82                 printf("WDT:   Failed to start %s\n", dev->name);
  83                 return;
  84         }
  85 }
  86
  87 int initr_watchdog(void)
  88 {
  89         struct udevice *dev;
  90         struct uclass *uc;
  91         int ret;
  92
  93         ret = uclass_get(UCLASS_WDT, &uc);
  94         if (ret) {
  95                 log_debug("Error getting UCLASS_WDT: %d\n", ret);
  96                 return 0;
  97         }
  98
  99         uclass_foreach_dev(dev, uc) {
 100                 ret = device_probe(dev);
 101                 if (ret) {
 102                         log_debug("Error probing %s: %d\n", dev->name, ret);
 103                         continue;
 104                 }
 105                 init_watchdog_dev(dev);
 106         }
 107
 108         gd->flags |= GD_FLG_WDT_READY;
 109         return 0;
 110 }
 111
 112 int wdt_start(struct udevice *dev, u64 timeout_ms, ulong flags)
 113 {
 114         const struct wdt_ops *ops = device_get_ops(dev);
 115         int ret;
 116
 117         if (!ops->start)
 118                 return -ENOSYS;
 119
 120         ret = ops->start(dev, timeout_ms, flags);
 121         if (ret == 0) {
 122                 struct wdt_priv *priv = dev_get_uclass_priv(dev);
 123                 char str[16];
 124
 125                 priv->running = true;
 126
 127                 memset(str, 0, 16);
 128                 if (IS_ENABLED(CONFIG_WATCHDOG)) {
 129                         /* Register the watchdog driver as a cyclic function */
 130                         priv->cyclic = cyclic_register(wdt_cyclic,
 131                                                        priv->reset_period * 1000,
 132                                                        dev->name, dev);
 133                         if (!priv->cyclic) {
 134                                 printf("cyclic_register for %s failed\n",
 135                                        dev->name);
 136                                 return -ENODEV;
 137                         } else {
 138                                 snprintf(str, 16, "every %ldms",
 139                                          priv->reset_period);
 140                         }
 141                 }
 142
 143                 printf("WDT:   Started %s with%s servicing %s (%ds timeout)\n",
 144                        dev->name, IS_ENABLED(CONFIG_WATCHDOG) ? "" : "out",
 145                        str, priv->timeout);
 146         }
 147
 148         return ret;
 149 }
 150
 151 int wdt_stop(struct udevice *dev)
 152 {
 153         const struct wdt_ops *ops = device_get_ops(dev);
 154         int ret;
 155
 156         if (!ops->stop)
 157                 return -ENOSYS;
 158
 159         ret = ops->stop(dev);
 160         if (ret == 0) {
 161                 struct wdt_priv *priv = dev_get_uclass_priv(dev);
 162
 163                 priv->running = false;
 164         }
 165
 166         return ret;
 167 }
 168
 169 int wdt_stop_all(void)
 170 {
 171         struct wdt_priv *priv;
 172         struct udevice *dev;
 173         struct uclass *uc;
 174         int ret, err;
 175
 176         ret = uclass_get(UCLASS_WDT, &uc);
 177         if (ret)
 178                 return ret;
 179
 180         uclass_foreach_dev(dev, uc) {
 181                 if (!device_active(dev))
 182                         continue;
 183                 priv = dev_get_uclass_priv(dev);
 184                 if (!priv->running)
 185                         continue;
 186                 err = wdt_stop(dev);
 187                 if (!ret)
 188                         ret = err;
 189         }
 190
 191         return ret;
 192 }
 193
 194 int wdt_reset(struct udevice *dev)
 195 {
 196         const struct wdt_ops *ops = device_get_ops(dev);
 197
 198         if (!ops->reset)
 199                 return -ENOSYS;
 200
 201         return ops->reset(dev);
 202 }
 203
 204 int wdt_expire_now(struct udevice *dev, ulong flags)
 205 {
 206         int ret = 0;
 207         const struct wdt_ops *ops;
 208
 209         debug("WDT Resetting: %lu\n", flags);
 210         ops = device_get_ops(dev);
 211         if (ops->expire_now) {
 212                 return ops->expire_now(dev, flags);
 213         } else {
 214                 ret = wdt_start(dev, 1, flags);
 215
 216                 if (ret < 0)
 217                         return ret;
 218
 219                 hang();
 220         }
 221
 222         return ret;
 223 }
 224
 225 #if defined(CONFIG_WATCHDOG)
 226 /*
 227  * Called by macro WATCHDOG_RESET. This function be called *very* early,
 228  * so we need to make sure, that the watchdog driver is ready before using
 229  * it in this function.
 230  */
 231 void watchdog_reset(void)
 232 {
 233         /*
 234          * Empty function for now. The actual WDT handling is now done in
 235          * the cyclic function instead.
 236          */
 237 }
 238 #endif
 239
 240 static int wdt_post_bind(struct udevice *dev)
 241 {
 242 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 243         struct wdt_ops *ops = (struct wdt_ops *)device_get_ops(dev);
 244         static int reloc_done;
 245
 246         if (!reloc_done) {
 247                 if (ops->start)
 248                         ops->start += gd->reloc_off;
 249                 if (ops->stop)
 250                         ops->stop += gd->reloc_off;
 251                 if (ops->reset)
 252                         ops->reset += gd->reloc_off;
 253                 if (ops->expire_now)
 254                         ops->expire_now += gd->reloc_off;
 255
 256                 reloc_done++;
 257         }
 258 #endif
 259         return 0;
 260 }
 261
 262 static int wdt_pre_probe(struct udevice *dev)
 263 {
 264         u32 timeout = WATCHDOG_TIMEOUT_SECS;
 265         /*
 266          * Reset every 1000ms, or however often is required as
 267          * indicated by a hw_margin_ms property.
 268          */
 269         ulong reset_period = 1000;
 270         bool noautostart = false;
 271         struct wdt_priv *priv;
 272
 273         if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
 274                 timeout = dev_read_u32_default(dev, "timeout-sec", timeout);
 275                 reset_period = dev_read_u32_default(dev, "hw_margin_ms",
 276                                                     4 * reset_period) / 4;
 277                 noautostart = dev_read_bool(dev, "u-boot,noautostart");
 278         }
 279         priv = dev_get_uclass_priv(dev);
 280         priv->timeout = timeout;
 281         priv->reset_period = reset_period;
 282         priv->noautostart = noautostart;
 283         /*
 284          * Pretend this device was last reset "long" ago so the first
 285          * watchdog_reset will actually call its ->reset method.
 286          */
 287         priv->next_reset = get_timer(0);
 288
 289         return 0;
 290 }
 291
 292 UCLASS_DRIVER(wdt) = {
 293         .id                     = UCLASS_WDT,
 294         .name                   = "watchdog",
 295         .flags                  = DM_UC_FLAG_SEQ_ALIAS,
 296         .post_bind              = wdt_post_bind,
 297         .pre_probe              = wdt_pre_probe,
 298         .per_device_auto        = sizeof(struct wdt_priv),
 299 };