drivers/watchdog/intel-mid_wdt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *      intel-mid_wdt: generic Intel MID SCU watchdog driver
   4  *
   5  *      Platforms supported so far:
   6  *      - Merrifield only
   7  *
   8  *      Copyright (C) 2014 Intel Corporation. All rights reserved.
   9  *      Contact: David Cohen <david.a.cohen@linux.intel.com>
  10  */
  11
  12 #include <linux/interrupt.h>
  13 #include <linux/module.h>
  14 #include <linux/nmi.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/watchdog.h>
  17 #include <linux/platform_data/intel-mid_wdt.h>
  18
  19 #include <asm/intel_scu_ipc.h>
  20 #include <asm/intel-mid.h>
  21
  22 #define IPC_WATCHDOG 0xf8
  23
  24 #define MID_WDT_PRETIMEOUT              15
  25 #define MID_WDT_TIMEOUT_MIN             (1 + MID_WDT_PRETIMEOUT)
  26 #define MID_WDT_TIMEOUT_MAX             170
  27 #define MID_WDT_DEFAULT_TIMEOUT         90
  28
  29 /* SCU watchdog messages */
  30 enum {
  31         SCU_WATCHDOG_START = 0,
  32         SCU_WATCHDOG_STOP,
  33         SCU_WATCHDOG_KEEPALIVE,
  34 };
  35
  36 struct mid_wdt {
  37         struct watchdog_device wd;
  38         struct device *dev;
  39         struct intel_scu_ipc_dev *scu;
  40 };
  41
  42 static inline int
  43 wdt_command(struct mid_wdt *mid, int sub, const void *in, size_t inlen, size_t size)
  44 {
  45         struct intel_scu_ipc_dev *scu = mid->scu;
  46
  47         return intel_scu_ipc_dev_command_with_size(scu, IPC_WATCHDOG, sub, in,
  48                                                    inlen, size, NULL, 0);
  49 }
  50
  51 static int wdt_start(struct watchdog_device *wd)
  52 {
  53         struct mid_wdt *mid = watchdog_get_drvdata(wd);
  54         int ret, in_size;
  55         int timeout = wd->timeout;
  56         struct ipc_wd_start {
  57                 u32 pretimeout;
  58                 u32 timeout;
  59         } ipc_wd_start = { timeout - MID_WDT_PRETIMEOUT, timeout };
  60
  61         /*
  62          * SCU expects the input size for watchdog IPC to be 2 which is the
  63          * size of the structure in dwords. SCU IPC normally takes bytes
  64          * but this is a special case where we specify size to be different
  65          * than inlen.
  66          */
  67         in_size = DIV_ROUND_UP(sizeof(ipc_wd_start), 4);
  68
  69         ret = wdt_command(mid, SCU_WATCHDOG_START, &ipc_wd_start,
  70                           sizeof(ipc_wd_start), in_size);
  71         if (ret)
  72                 dev_crit(mid->dev, "error starting watchdog: %d\n", ret);
  73
  74         return ret;
  75 }
  76
  77 static int wdt_ping(struct watchdog_device *wd)
  78 {
  79         struct mid_wdt *mid = watchdog_get_drvdata(wd);
  80         int ret;
  81
  82         ret = wdt_command(mid, SCU_WATCHDOG_KEEPALIVE, NULL, 0, 0);
  83         if (ret)
  84                 dev_crit(mid->dev, "Error executing keepalive: %d\n", ret);
  85
  86         return ret;
  87 }
  88
  89 static int wdt_stop(struct watchdog_device *wd)
  90 {
  91         struct mid_wdt *mid = watchdog_get_drvdata(wd);
  92         int ret;
  93
  94         ret = wdt_command(mid, SCU_WATCHDOG_STOP, NULL, 0, 0);
  95         if (ret)
  96                 dev_crit(mid->dev, "Error stopping watchdog: %d\n", ret);
  97
  98         return ret;
  99 }
 100
 101 static irqreturn_t mid_wdt_irq(int irq, void *dev_id)
 102 {
 103         panic("Kernel Watchdog");
 104
 105         /* This code should not be reached */
 106         return IRQ_HANDLED;
 107 }
 108
 109 static const struct watchdog_info mid_wdt_info = {
 110         .identity = "Intel MID SCU watchdog",
 111         .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
 112 };
 113
 114 static const struct watchdog_ops mid_wdt_ops = {
 115         .owner = THIS_MODULE,
 116         .start = wdt_start,
 117         .stop = wdt_stop,
 118         .ping = wdt_ping,
 119 };
 120
 121 static int mid_wdt_probe(struct platform_device *pdev)
 122 {
 123         struct device *dev = &pdev->dev;
 124         struct watchdog_device *wdt_dev;
 125         struct intel_mid_wdt_pdata *pdata = dev->platform_data;
 126         struct mid_wdt *mid;
 127         int ret;
 128
 129         if (!pdata) {
 130                 dev_err(dev, "missing platform data\n");
 131                 return -EINVAL;
 132         }
 133
 134         if (pdata->probe) {
 135                 ret = pdata->probe(pdev);
 136                 if (ret)
 137                         return ret;
 138         }
 139
 140         mid = devm_kzalloc(dev, sizeof(*mid), GFP_KERNEL);
 141         if (!mid)
 142                 return -ENOMEM;
 143
 144         mid->dev = dev;
 145         wdt_dev = &mid->wd;
 146
 147         wdt_dev->info = &mid_wdt_info;
 148         wdt_dev->ops = &mid_wdt_ops;
 149         wdt_dev->min_timeout = MID_WDT_TIMEOUT_MIN;
 150         wdt_dev->max_timeout = MID_WDT_TIMEOUT_MAX;
 151         wdt_dev->timeout = MID_WDT_DEFAULT_TIMEOUT;
 152         wdt_dev->parent = dev;
 153
 154         watchdog_set_nowayout(wdt_dev, WATCHDOG_NOWAYOUT);
 155         watchdog_set_drvdata(wdt_dev, mid);
 156
 157         ret = devm_request_irq(dev, pdata->irq, mid_wdt_irq,
 158                                IRQF_SHARED | IRQF_NO_SUSPEND, "watchdog",
 159                                wdt_dev);
 160         if (ret) {
 161                 dev_err(dev, "error requesting warning irq %d\n", pdata->irq);
 162                 return ret;
 163         }
 164
 165         mid->scu = devm_intel_scu_ipc_dev_get(dev);
 166         if (!mid->scu)
 167                 return -EPROBE_DEFER;
 168
 169         /*
 170          * The firmware followed by U-Boot leaves the watchdog running
 171          * with the default threshold which may vary. When we get here
 172          * we should make a decision to prevent any side effects before
 173          * user space daemon will take care of it. The best option,
 174          * taking into consideration that there is no way to read values
 175          * back from hardware, is to enforce watchdog being run with
 176          * deterministic values.
 177          */
 178         ret = wdt_start(wdt_dev);
 179         if (ret)
 180                 return ret;
 181
 182         /* Make sure the watchdog is serviced */
 183         set_bit(WDOG_HW_RUNNING, &wdt_dev->status);
 184
 185         ret = devm_watchdog_register_device(dev, wdt_dev);
 186         if (ret)
 187                 return ret;
 188
 189         dev_info(dev, "Intel MID watchdog device probed\n");
 190
 191         return 0;
 192 }
 193
 194 static struct platform_driver mid_wdt_driver = {
 195         .probe          = mid_wdt_probe,
 196         .driver         = {
 197                 .name   = "intel_mid_wdt",
 198         },
 199 };
 200
 201 module_platform_driver(mid_wdt_driver);
 202
 203 MODULE_AUTHOR("David Cohen <david.a.cohen@linux.intel.com>");
 204 MODULE_DESCRIPTION("Watchdog Driver for Intel MID platform");
 205 MODULE_LICENSE("GPL");