static int dc_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct dc_wdt *wdt; int ret; wdt = devm_kzalloc(dev, sizeof(struct dc_wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; wdt->base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(wdt->base)) return PTR_ERR(wdt->base); wdt->clk = devm_clk_get(dev, NULL); if (IS_ERR(wdt->clk)) return PTR_ERR(wdt->clk); dc_wdt_wdd.max_timeout = U32_MAX / clk_get_rate(wdt->clk); dc_wdt_wdd.timeout = dc_wdt_wdd.max_timeout; dc_wdt_wdd.parent = dev; spin_lock_init(&wdt->lock); watchdog_set_drvdata(&dc_wdt_wdd, wdt); watchdog_set_restart_priority(&dc_wdt_wdd, 128); watchdog_init_timeout(&dc_wdt_wdd, timeout, dev); watchdog_stop_on_reboot(&dc_wdt_wdd); ret = devm_watchdog_register_device(dev, &dc_wdt_wdd); if (ret) { dev_err(dev, "Failed to register watchdog device"); return ret; } return 0; }
static int rza_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rza_wdt *priv; unsigned long rate; int ret; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(priv->base)) return PTR_ERR(priv->base); priv->clk = devm_clk_get(dev, NULL); if (IS_ERR(priv->clk)) return PTR_ERR(priv->clk); rate = clk_get_rate(priv->clk); if (rate < 16384) { dev_err(dev, "invalid clock rate (%ld)\n", rate); return -ENOENT; } priv->wdev.info = &rza_wdt_ident, priv->wdev.ops = &rza_wdt_ops, priv->wdev.parent = dev; priv->cks = (u8)(uintptr_t) of_device_get_match_data(dev); if (priv->cks == CKS_4BIT) { /* Assume slowest clock rate possible (CKS=0xF) */ priv->wdev.max_timeout = (DIVIDER_4BIT * U8_MAX) / rate; } else if (priv->cks == CKS_3BIT) { /* Assume slowest clock rate possible (CKS=7) */ rate /= DIVIDER_3BIT; /* * Since the max possible timeout of our 8-bit count * register is less than a second, we must use * max_hw_heartbeat_ms. */ priv->wdev.max_hw_heartbeat_ms = (1000 * U8_MAX) / rate; dev_dbg(dev, "max hw timeout of %dms\n", priv->wdev.max_hw_heartbeat_ms); } priv->wdev.min_timeout = 1; priv->wdev.timeout = DEFAULT_TIMEOUT; watchdog_init_timeout(&priv->wdev, 0, dev); watchdog_set_drvdata(&priv->wdev, priv); ret = devm_watchdog_register_device(dev, &priv->wdev); if (ret) dev_err(dev, "Cannot register watchdog device\n"); return ret; }
static int __devinit max63xx_wdt_probe(struct platform_device *pdev) { struct resource *wdt_mem; struct max63xx_timeout *table; table = (struct max63xx_timeout *)pdev->id_entry->driver_data; if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT) heartbeat = DEFAULT_HEARTBEAT; dev_info(&pdev->dev, "requesting %ds heartbeat\n", heartbeat); current_timeout = max63xx_select_timeout(table, heartbeat); if (!current_timeout) { dev_err(&pdev->dev, "unable to satisfy heartbeat request\n"); return -EINVAL; } dev_info(&pdev->dev, "using %ds heartbeat with %ds initial delay\n", current_timeout->twd, current_timeout->tdelay); heartbeat = current_timeout->twd; wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); wdt_base = devm_request_and_ioremap(&pdev->dev, wdt_mem); if (!wdt_base) return -ENOMEM; max63xx_wdt_dev.timeout = heartbeat; watchdog_set_nowayout(&max63xx_wdt_dev, nowayout); watchdog_set_drvdata(&max63xx_wdt_dev, current_timeout); return watchdog_register_device(&max63xx_wdt_dev); }
static int rn5t618_wdt_probe(struct platform_device *pdev) { struct rn5t618 *rn5t618 = dev_get_drvdata(pdev->dev.parent); struct rn5t618_wdt *wdt; int min_timeout, max_timeout; wdt = devm_kzalloc(&pdev->dev, sizeof(struct rn5t618_wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; min_timeout = rn5t618_wdt_map[0].time; max_timeout = rn5t618_wdt_map[ARRAY_SIZE(rn5t618_wdt_map) - 1].time; wdt->rn5t618 = rn5t618; wdt->wdt_dev.info = &rn5t618_wdt_info; wdt->wdt_dev.ops = &rn5t618_wdt_ops; wdt->wdt_dev.min_timeout = min_timeout; wdt->wdt_dev.max_timeout = max_timeout; wdt->wdt_dev.timeout = max_timeout; wdt->wdt_dev.parent = &pdev->dev; watchdog_set_drvdata(&wdt->wdt_dev, wdt); watchdog_init_timeout(&wdt->wdt_dev, timeout, &pdev->dev); watchdog_set_nowayout(&wdt->wdt_dev, nowayout); platform_set_drvdata(pdev, wdt); return watchdog_register_device(&wdt->wdt_dev); }
static int sirfsoc_wdt_probe(struct platform_device *pdev) { struct resource *res; int ret; void __iomem *base; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(base)) return PTR_ERR(base); watchdog_set_drvdata(&sirfsoc_wdd, base); watchdog_init_timeout(&sirfsoc_wdd, timeout, &pdev->dev); watchdog_set_nowayout(&sirfsoc_wdd, nowayout); sirfsoc_wdd.parent = &pdev->dev; ret = watchdog_register_device(&sirfsoc_wdd); if (ret) return ret; platform_set_drvdata(pdev, &sirfsoc_wdd); return 0; }
static int moxart_wdt_probe(struct platform_device *pdev) { struct moxart_wdt_dev *moxart_wdt; struct device *dev = &pdev->dev; struct device_node *node = dev->of_node; struct resource *res; struct clk *clk; int err; unsigned int max_timeout; bool nowayout = WATCHDOG_NOWAYOUT; moxart_wdt = devm_kzalloc(dev, sizeof(*moxart_wdt), GFP_KERNEL); if (!moxart_wdt) return -ENOMEM; platform_set_drvdata(pdev, moxart_wdt); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); moxart_wdt->base = devm_ioremap_resource(dev, res); if (IS_ERR(moxart_wdt->base)) return PTR_ERR(moxart_wdt->base); clk = of_clk_get(node, 0); if (IS_ERR(clk)) { pr_err("%s: of_clk_get failed\n", __func__); return PTR_ERR(clk); } moxart_wdt->clock_frequency = clk_get_rate(clk); if (moxart_wdt->clock_frequency == 0) { pr_err("%s: incorrect clock frequency\n", __func__); return -EINVAL; } max_timeout = UINT_MAX / moxart_wdt->clock_frequency; moxart_wdt->dev.info = &moxart_wdt_info; moxart_wdt->dev.ops = &moxart_wdt_ops; moxart_wdt->dev.timeout = max_timeout; moxart_wdt->dev.min_timeout = 1; moxart_wdt->dev.max_timeout = max_timeout; moxart_wdt->dev.parent = dev; watchdog_init_timeout(&moxart_wdt->dev, heartbeat, dev); watchdog_set_nowayout(&moxart_wdt->dev, nowayout); watchdog_set_drvdata(&moxart_wdt->dev, moxart_wdt); err = watchdog_register_device(&moxart_wdt->dev); if (err) return err; moxart_restart_ctx = moxart_wdt; arm_pm_restart = moxart_wdt_restart; dev_dbg(dev, "Watchdog enabled (heartbeat=%d sec, nowayout=%d)\n", moxart_wdt->dev.timeout, nowayout); return 0; }
static int kempld_wdt_probe(struct platform_device *pdev) { struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent); struct kempld_wdt_data *wdt_data; struct device *dev = &pdev->dev; struct watchdog_device *wdd; u8 status; int ret = 0; wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL); if (!wdt_data) return -ENOMEM; wdt_data->pld = pld; wdd = &wdt_data->wdd; wdd->parent = dev; kempld_get_mutex(pld); status = kempld_read8(pld, KEMPLD_WDT_CFG); kempld_release_mutex(pld); /* Enable nowayout if watchdog is already locked */ if (status & (KEMPLD_WDT_CFG_ENABLE_LOCK | KEMPLD_WDT_CFG_GLOBAL_LOCK)) { if (!nowayout) dev_warn(dev, "Forcing nowayout - watchdog lock enabled!\n"); nowayout = true; } wdd->info = &kempld_wdt_info; wdd->ops = &kempld_wdt_ops; watchdog_set_drvdata(wdd, wdt_data); watchdog_set_nowayout(wdd, nowayout); ret = kempld_wdt_probe_stages(wdd); if (ret) return ret; kempld_wdt_set_timeout(wdd, timeout); kempld_wdt_set_pretimeout(wdd, pretimeout); /* Check if watchdog is already enabled */ if (status & KEMPLD_WDT_CFG_ENABLE) { /* Get current watchdog settings */ kempld_wdt_update_timeouts(wdt_data); dev_info(dev, "Watchdog was already enabled\n"); } platform_set_drvdata(pdev, wdt_data); ret = watchdog_register_device(wdd); if (ret) return ret; dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout); return 0; }
void mei_watchdog_unregister(struct mei_device *dev) { if (watchdog_get_drvdata(&amt_wd_dev) == NULL) return; watchdog_set_drvdata(&amt_wd_dev, NULL); watchdog_unregister_device(&amt_wd_dev); }
static int __devinit mcs814x_wdt_probe(struct platform_device *pdev) { struct resource *res; struct mcs814x_wdt *wdt; int ret; struct clk *clk; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; clk = clk_get(NULL, "wdt"); if (IS_ERR_OR_NULL(clk)) { dev_err(&pdev->dev, "failed to get watchdog clock\n"); return PTR_ERR(clk); } wdt = kzalloc(sizeof(*wdt), GFP_KERNEL); if (!wdt) { ret = -ENOMEM; goto out_clk; } spin_lock_init(&wdt->lock); wdt->clk = clk; wdt->wdt_dev.info = &mcs814x_wdt_ident; wdt->wdt_dev.ops = &mcs814x_wdt_ops; wdt->wdt_dev.min_timeout = 1; /* approximately 10995 secs */ wdt->wdt_dev.max_timeout = (WDT_MAX_VALUE / clk_get_rate(clk)); platform_set_drvdata(pdev, wdt); /* only ioremap registers, because the register is shared */ wdt->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!wdt->regs) { ret = -ENOMEM; goto out; } watchdog_set_drvdata(&wdt->wdt_dev, wdt); ret = watchdog_register_device(&wdt->wdt_dev); if (ret) { dev_err(&pdev->dev, "cannot register watchdog: %d\n", ret); goto out; } dev_info(&pdev->dev, "registered\n"); return 0; out: platform_set_drvdata(pdev, NULL); kfree(wdt); out_clk: clk_put(clk); return ret; }
static int atlas7_wdt_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct atlas7_wdog *wdt; struct resource *res; struct clk *clk; int ret; wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); wdt->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(wdt->base)) return PTR_ERR(wdt->base); clk = of_clk_get(np, 0); if (IS_ERR(clk)) return PTR_ERR(clk); ret = clk_prepare_enable(clk); if (ret) { dev_err(&pdev->dev, "clk enable failed\n"); goto err; } /* disable watchdog hardware */ writel(0, wdt->base + ATLAS7_WDT_CNT_CTRL); wdt->tick_rate = clk_get_rate(clk); if (!wdt->tick_rate) { ret = -EINVAL; goto err1; } wdt->clk = clk; atlas7_wdd.min_timeout = 1; atlas7_wdd.max_timeout = UINT_MAX / wdt->tick_rate; watchdog_init_timeout(&atlas7_wdd, 0, &pdev->dev); watchdog_set_nowayout(&atlas7_wdd, nowayout); watchdog_set_drvdata(&atlas7_wdd, wdt); platform_set_drvdata(pdev, &atlas7_wdd); ret = watchdog_register_device(&atlas7_wdd); if (ret) goto err1; return 0; err1: clk_disable_unprepare(clk); err: clk_put(clk); return ret; }
static int mid_wdt_probe(struct platform_device *pdev) { struct watchdog_device *wdt_dev; struct intel_mid_wdt_pdata *pdata = pdev->dev.platform_data; int ret; if (!pdata) { dev_err(&pdev->dev, "missing platform data\n"); return -EINVAL; } if (pdata->probe) { ret = pdata->probe(pdev); if (ret) return ret; } wdt_dev = devm_kzalloc(&pdev->dev, sizeof(*wdt_dev), GFP_KERNEL); if (!wdt_dev) return -ENOMEM; wdt_dev->info = &mid_wdt_info; wdt_dev->ops = &mid_wdt_ops; wdt_dev->min_timeout = MID_WDT_TIMEOUT_MIN; wdt_dev->max_timeout = MID_WDT_TIMEOUT_MAX; wdt_dev->timeout = MID_WDT_DEFAULT_TIMEOUT; wdt_dev->parent = &pdev->dev; watchdog_set_drvdata(wdt_dev, &pdev->dev); platform_set_drvdata(pdev, wdt_dev); ret = devm_request_irq(&pdev->dev, pdata->irq, mid_wdt_irq, IRQF_SHARED | IRQF_NO_SUSPEND, "watchdog", wdt_dev); if (ret) { dev_err(&pdev->dev, "error requesting warning irq %d\n", pdata->irq); return ret; } /* Make sure the watchdog is not running */ wdt_stop(wdt_dev); ret = watchdog_register_device(wdt_dev); if (ret) { dev_err(&pdev->dev, "error registering watchdog device\n"); return ret; } dev_info(&pdev->dev, "Intel MID watchdog device probed\n"); return 0; }
static int __devexit mcs814x_wdt_remove(struct platform_device *pdev) { struct mcs814x_wdt *wdt = platform_get_drvdata(pdev); clk_put(wdt->clk); watchdog_unregister_device(&wdt->wdt_dev); watchdog_set_drvdata(&wdt->wdt_dev, NULL); kfree(wdt); platform_set_drvdata(pdev, NULL); return 0; }
static int __devinit jz4740_wdt_probe(struct platform_device *pdev) { struct jz4740_wdt_drvdata *drvdata; struct watchdog_device *jz4740_wdt; struct resource *res; int ret; drvdata = devm_kzalloc(&pdev->dev, sizeof(struct jz4740_wdt_drvdata), GFP_KERNEL); if (!drvdata) { dev_err(&pdev->dev, "Unable to alloacate watchdog device\n"); return -ENOMEM; } if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT) heartbeat = DEFAULT_HEARTBEAT; jz4740_wdt = &drvdata->wdt; jz4740_wdt->info = &jz4740_wdt_info; jz4740_wdt->ops = &jz4740_wdt_ops; jz4740_wdt->timeout = heartbeat; jz4740_wdt->min_timeout = 1; jz4740_wdt->max_timeout = MAX_HEARTBEAT; watchdog_set_nowayout(jz4740_wdt, nowayout); watchdog_set_drvdata(jz4740_wdt, drvdata); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); drvdata->base = devm_request_and_ioremap(&pdev->dev, res); if (drvdata->base == NULL) { ret = -EBUSY; goto err_out; } drvdata->rtc_clk = clk_get(NULL, "rtc"); if (IS_ERR(drvdata->rtc_clk)) { dev_err(&pdev->dev, "cannot find RTC clock\n"); ret = PTR_ERR(drvdata->rtc_clk); goto err_out; } ret = watchdog_register_device(&drvdata->wdt); if (ret < 0) goto err_disable_clk; platform_set_drvdata(pdev, drvdata); return 0; err_disable_clk: clk_put(drvdata->rtc_clk); err_out: return ret; }
static int __init at91wdt_probe(struct platform_device *pdev) { struct at91wdt_drvdata *driver_data; struct resource *r; int ret; driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data), GFP_KERNEL); if (!driver_data) { dev_err(&pdev->dev, "Unable to alloacate watchdog device\n"); return -ENOMEM; } watchdog_set_drvdata(&at91wdt_wdd, driver_data); r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) return -ENODEV; driver_data->phybase = ioremap(r->start, resource_size(r)); if (!driver_data->phybase) { dev_err(&pdev->dev, "failed to map registers, aborting.\n"); return -ENOMEM; } ret = watchdog_register_device(&at91wdt_wdd); if (ret) { dev_err(&pdev->dev, "cannot register watchdog (%d)\n", ret); return ret; } watchdog_set_nowayout(&at91wdt_wdd, nowayout); watchdog_init_timeout(&at91wdt_wdd, heartbeat, pdev->dev.of_node); ret = at91wdt_enable(&at91wdt_wdd, ms_to_ticks(WDT_HW_TIMEOUT * 1000)); if (ret) { pr_info("the watchdog has been disabled\n"); return 0; } driver_data->next_heartbeat = jiffies + at91wdt_wdd.timeout * HZ; setup_timer(&driver_data->timer, at91wdt_timer_tick, (unsigned long)&at91wdt_wdd); mod_timer(&driver_data->timer, jiffies + WDT_TIMEOUT); pr_info("enabled (heartbeat=%d sec, nowayout=%d)\n", at91wdt_wdd.timeout, nowayout); return 0; }
static int meson_gxbb_wdt_probe(struct platform_device *pdev) { struct meson_gxbb_wdt *data; struct resource *res; int ret; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); data->reg_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(data->reg_base)) return PTR_ERR(data->reg_base); data->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(data->clk)) return PTR_ERR(data->clk); ret = clk_prepare_enable(data->clk); if (ret) return ret; platform_set_drvdata(pdev, data); data->wdt_dev.parent = &pdev->dev; data->wdt_dev.info = &meson_gxbb_wdt_info; data->wdt_dev.ops = &meson_gxbb_wdt_ops; data->wdt_dev.max_hw_heartbeat_ms = GXBB_WDT_TCNT_SETUP_MASK; data->wdt_dev.min_timeout = 1; data->wdt_dev.timeout = DEFAULT_TIMEOUT; watchdog_set_drvdata(&data->wdt_dev, data); /* Setup with 1ms timebase */ writel(((clk_get_rate(data->clk) / 1000) & GXBB_WDT_CTRL_DIV_MASK) | GXBB_WDT_CTRL_EE_RESET | GXBB_WDT_CTRL_CLK_EN | GXBB_WDT_CTRL_CLKDIV_EN, data->reg_base + GXBB_WDT_CTRL_REG); meson_gxbb_wdt_set_timeout(&data->wdt_dev, data->wdt_dev.timeout); ret = watchdog_register_device(&data->wdt_dev); if (ret) { clk_disable_unprepare(data->clk); return ret; } return 0; }
static int menf21bmc_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; int ret, bmc_timeout; struct menf21bmc_wdt *drv_data; struct i2c_client *i2c_client = to_i2c_client(dev->parent); drv_data = devm_kzalloc(dev, sizeof(struct menf21bmc_wdt), GFP_KERNEL); if (!drv_data) return -ENOMEM; drv_data->wdt.ops = &menf21bmc_wdt_ops; drv_data->wdt.info = &menf21bmc_wdt_info; drv_data->wdt.min_timeout = BMC_WD_TIMEOUT_MIN; drv_data->wdt.max_timeout = BMC_WD_TIMEOUT_MAX; drv_data->wdt.parent = dev; drv_data->i2c_client = i2c_client; /* * Get the current wdt timeout value from the BMC because * the BMC will save the value set before if the system restarts. */ bmc_timeout = i2c_smbus_read_word_data(drv_data->i2c_client, BMC_CMD_WD_TIME); if (bmc_timeout < 0) { dev_err(dev, "failed to get current WDT timeout\n"); return bmc_timeout; } watchdog_init_timeout(&drv_data->wdt, bmc_timeout / 10, dev); watchdog_set_nowayout(&drv_data->wdt, nowayout); watchdog_set_drvdata(&drv_data->wdt, drv_data); platform_set_drvdata(pdev, drv_data); ret = menf21bmc_wdt_set_bootstatus(drv_data); if (ret < 0) { dev_err(dev, "failed to set Watchdog bootstatus\n"); return ret; } ret = devm_watchdog_register_device(dev, &drv_data->wdt); if (ret) { dev_err(dev, "failed to register Watchdog device\n"); return ret; } dev_info(dev, "MEN 14F021P00 BMC Watchdog device enabled\n"); return 0; }
static int bcm2835_wdt_probe(struct platform_device *pdev) { struct resource *res; struct device *dev = &pdev->dev; struct bcm2835_wdt *wdt; int err; wdt = devm_kzalloc(dev, sizeof(struct bcm2835_wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; platform_set_drvdata(pdev, wdt); spin_lock_init(&wdt->lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); wdt->base = devm_ioremap_resource(dev, res); if (IS_ERR(wdt->base)) return PTR_ERR(wdt->base); watchdog_set_drvdata(&bcm2835_wdt_wdd, wdt); watchdog_init_timeout(&bcm2835_wdt_wdd, heartbeat, dev); watchdog_set_nowayout(&bcm2835_wdt_wdd, nowayout); bcm2835_wdt_wdd.parent = dev; if (bcm2835_wdt_is_running(wdt)) { /* * The currently active timeout value (set by the * bootloader) may be different from the module * heartbeat parameter or the value in device * tree. But we just need to set WDOG_HW_RUNNING, * because then the framework will "immediately" ping * the device, updating the timeout. */ set_bit(WDOG_HW_RUNNING, &bcm2835_wdt_wdd.status); } watchdog_set_restart_priority(&bcm2835_wdt_wdd, 128); watchdog_stop_on_reboot(&bcm2835_wdt_wdd); err = devm_watchdog_register_device(dev, &bcm2835_wdt_wdd); if (err) { dev_err(dev, "Failed to register watchdog device"); return err; } if (pm_power_off == NULL) pm_power_off = bcm2835_power_off; dev_info(dev, "Broadcom BCM2835 watchdog timer"); return 0; }
static int uniphier_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct uniphier_wdt_dev *wdev; struct regmap *regmap; struct device_node *parent; int ret; wdev = devm_kzalloc(dev, sizeof(*wdev), GFP_KERNEL); if (!wdev) return -ENOMEM; platform_set_drvdata(pdev, wdev); parent = of_get_parent(dev->of_node); /* parent should be syscon node */ regmap = syscon_node_to_regmap(parent); of_node_put(parent); if (IS_ERR(regmap)) return PTR_ERR(regmap); wdev->regmap = regmap; wdev->wdt_dev.info = &uniphier_wdt_info; wdev->wdt_dev.ops = &uniphier_wdt_ops; wdev->wdt_dev.max_timeout = WDT_PERIOD_MAX; wdev->wdt_dev.min_timeout = WDT_PERIOD_MIN; wdev->wdt_dev.parent = dev; if (watchdog_init_timeout(&wdev->wdt_dev, timeout, dev) < 0) { wdev->wdt_dev.timeout = WDT_DEFAULT_TIMEOUT; } watchdog_set_nowayout(&wdev->wdt_dev, nowayout); watchdog_stop_on_reboot(&wdev->wdt_dev); watchdog_set_drvdata(&wdev->wdt_dev, wdev); uniphier_watchdog_stop(&wdev->wdt_dev); ret = regmap_write(wdev->regmap, WDTRSTSEL, WDTRSTSEL_RSTSEL_BOTH); if (ret) return ret; ret = devm_watchdog_register_device(dev, &wdev->wdt_dev); if (ret) return ret; dev_info(dev, "watchdog driver (timeout=%d sec, nowayout=%d)\n", wdev->wdt_dev.timeout, nowayout); return 0; }
static int wm8350_wdt_probe(struct platform_device *pdev) { struct wm8350 *wm8350 = platform_get_drvdata(pdev); if (!wm8350) { pr_err("No driver data supplied\n"); return -ENODEV; } watchdog_set_nowayout(&wm8350_wdt, nowayout); watchdog_set_drvdata(&wm8350_wdt, wm8350); /* Default to 4s timeout */ wm8350_wdt_set_timeout(&wm8350_wdt, 4); return watchdog_register_device(&wm8350_wdt); }
static int aml_wdt_probe(struct platform_device *pdev) { struct watchdog_device *aml_wdt; struct aml_wdt_dev *wdev; int ret; aml_wdt = devm_kzalloc(&pdev->dev, sizeof(*aml_wdt), GFP_KERNEL); if (!aml_wdt) return -ENOMEM; wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL); if (!wdev) return -ENOMEM; wdev->dev = &pdev->dev; mutex_init(&wdev->lock); aml_init_pdata(wdev); aml_wdt->info = &aml_wdt_info; aml_wdt->ops = &aml_wdt_ops; aml_wdt->min_timeout = wdev->min_timeout; aml_wdt->max_timeout = wdev->max_timeout; aml_wdt->timeout = 0xffffffff; wdev->timeout = 0xffffffff; watchdog_set_drvdata(aml_wdt, wdev); platform_set_drvdata(pdev, aml_wdt); if (wdev->reset_watchdog_method == 1) { INIT_DELAYED_WORK(&wdev->boot_queue, boot_moniter_work); mod_delayed_work(system_freezable_wq, &wdev->boot_queue, round_jiffies(msecs_to_jiffies(wdev->reset_watchdog_time*1000))); enable_watchdog(wdev); set_watchdog_cnt(wdev, wdev->default_timeout * wdev->one_second); dev_info(wdev->dev, "creat work queue for watch dog\n"); } ret = watchdog_register_device(aml_wdt); if (ret) return ret; awdtv = wdev; register_pm_notifier(&aml_wdt_pm_notifier); register_reboot_notifier(&aml_wdt_reboot_notifier); dev_info(wdev->dev, "AML Watchdog Timer probed done\n"); return 0; }
static int stmp3xxx_wdt_probe(struct platform_device *pdev) { int ret; watchdog_set_drvdata(&stmp3xxx_wdd, &pdev->dev); stmp3xxx_wdd.timeout = clamp_t(unsigned, heartbeat, 1, STMP3XXX_MAX_TIMEOUT); ret = watchdog_register_device(&stmp3xxx_wdd); if (ret < 0) { dev_err(&pdev->dev, "cannot register watchdog device\n"); return ret; } dev_info(&pdev->dev, "initialized watchdog with heartbeat %ds\n", stmp3xxx_wdd.timeout); return 0; }
static int bcm_kona_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct bcm_kona_wdt *wdt; struct resource *res; int ret; wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); wdt->base = devm_ioremap_resource(dev, res); if (IS_ERR(wdt->base)) return -ENODEV; wdt->resolution = SECWDOG_DEFAULT_RESOLUTION; ret = bcm_kona_wdt_set_resolution_reg(wdt); if (ret) { dev_err(dev, "Failed to set resolution (error: %d)", ret); return ret; } spin_lock_init(&wdt->lock); platform_set_drvdata(pdev, wdt); watchdog_set_drvdata(&bcm_kona_wdt_wdd, wdt); ret = bcm_kona_wdt_set_timeout_reg(&bcm_kona_wdt_wdd, 0); if (ret) { dev_err(dev, "Failed set watchdog timeout"); return ret; } ret = watchdog_register_device(&bcm_kona_wdt_wdd); if (ret) { dev_err(dev, "Failed to register watchdog device"); return ret; } bcm_kona_wdt_debug_init(pdev); dev_dbg(dev, "Broadcom Kona Watchdog Timer"); return 0; }
static int dc_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct dc_wdt *wdt; int ret; wdt = devm_kzalloc(dev, sizeof(struct dc_wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; platform_set_drvdata(pdev, wdt); wdt->base = of_iomap(np, 0); if (!wdt->base) { dev_err(dev, "Failed to remap watchdog regs"); return -ENODEV; } wdt->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(wdt->clk)) { ret = PTR_ERR(wdt->clk); goto err_iounmap; } dc_wdt_wdd.max_timeout = U32_MAX / clk_get_rate(wdt->clk); dc_wdt_wdd.timeout = dc_wdt_wdd.max_timeout; dc_wdt_wdd.parent = &pdev->dev; spin_lock_init(&wdt->lock); watchdog_set_drvdata(&dc_wdt_wdd, wdt); watchdog_set_restart_priority(&dc_wdt_wdd, 128); watchdog_init_timeout(&dc_wdt_wdd, timeout, dev); ret = watchdog_register_device(&dc_wdt_wdd); if (ret) { dev_err(dev, "Failed to register watchdog device"); goto err_iounmap; } return 0; err_iounmap: iounmap(wdt->base); return ret; }
static int rtd119x_wdt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rtd119x_watchdog_device *data; int ret; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(data->base)) return PTR_ERR(data->base); data->clk = devm_clk_get(dev, NULL); if (IS_ERR(data->clk)) return PTR_ERR(data->clk); ret = clk_prepare_enable(data->clk); if (ret) return ret; ret = devm_add_action_or_reset(dev, rtd119x_clk_disable_unprepare, data->clk); if (ret) return ret; data->wdt_dev.info = &rtd119x_wdt_info; data->wdt_dev.ops = &rtd119x_wdt_ops; data->wdt_dev.timeout = 120; data->wdt_dev.max_timeout = 0xffffffff / clk_get_rate(data->clk); data->wdt_dev.min_timeout = 1; data->wdt_dev.parent = dev; watchdog_stop_on_reboot(&data->wdt_dev); watchdog_set_drvdata(&data->wdt_dev, data); platform_set_drvdata(pdev, data); writel_relaxed(RTD119X_TCWTR_WDCLR, data->base + RTD119X_TCWTR); rtd119x_wdt_set_timeout(&data->wdt_dev, data->wdt_dev.timeout); rtd119x_wdt_stop(&data->wdt_dev); return devm_watchdog_register_device(dev, &data->wdt_dev); }
static int ts72xx_wdt_probe(struct platform_device *pdev) { struct ts72xx_wdt_priv *priv; struct watchdog_device *wdd; struct resource *res; int ret; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->control_reg = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(priv->control_reg)) return PTR_ERR(priv->control_reg); res = platform_get_resource(pdev, IORESOURCE_MEM, 1); priv->feed_reg = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(priv->feed_reg)) return PTR_ERR(priv->feed_reg); wdd = &priv->wdd; wdd->info = &ts72xx_wdt_ident; wdd->ops = &ts72xx_wdt_ops; wdd->min_timeout = 1; wdd->max_hw_heartbeat_ms = 8000; wdd->parent = &pdev->dev; watchdog_set_nowayout(wdd, nowayout); wdd->timeout = TS72XX_WDT_DEFAULT_TIMEOUT; watchdog_init_timeout(wdd, timeout, &pdev->dev); watchdog_set_drvdata(wdd, priv); ret = devm_watchdog_register_device(&pdev->dev, wdd); if (ret) return ret; dev_info(&pdev->dev, "TS-72xx Watchdog driver\n"); return 0; }
int mei_watchdog_register(struct mei_device *dev) { int ret; /* unlock to perserve correct locking order */ mutex_unlock(&dev->device_lock); ret = watchdog_register_device(&amt_wd_dev); mutex_lock(&dev->device_lock); if (ret) { dev_err(dev->dev, "wd: unable to register watchdog device = %d.\n", ret); return ret; } dev_dbg(dev->dev, "wd: successfully register watchdog interface.\n"); watchdog_set_drvdata(&amt_wd_dev, dev); return 0; }
static int retu_wdt_probe(struct platform_device *pdev) { struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent); bool nowayout = WATCHDOG_NOWAYOUT; struct watchdog_device *retu_wdt; struct retu_wdt_dev *wdev; int ret; retu_wdt = devm_kzalloc(&pdev->dev, sizeof(*retu_wdt), GFP_KERNEL); if (!retu_wdt) return -ENOMEM; wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL); if (!wdev) return -ENOMEM; retu_wdt->info = &retu_wdt_info; retu_wdt->ops = &retu_wdt_ops; retu_wdt->timeout = RETU_WDT_MAX_TIMER; retu_wdt->min_timeout = 0; retu_wdt->max_timeout = RETU_WDT_MAX_TIMER; watchdog_set_drvdata(retu_wdt, wdev); watchdog_set_nowayout(retu_wdt, nowayout); wdev->rdev = rdev; wdev->dev = &pdev->dev; INIT_DELAYED_WORK(&wdev->ping_work, retu_wdt_ping_work); ret = watchdog_register_device(retu_wdt); if (ret < 0) return ret; if (nowayout) retu_wdt_ping(retu_wdt); else retu_wdt_ping_enable(wdev); platform_set_drvdata(pdev, retu_wdt); return 0; }
static int da9052_wdt_probe(struct platform_device *pdev) { struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent); struct da9052_wdt_data *driver_data; struct watchdog_device *da9052_wdt; int ret; driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data), GFP_KERNEL); if (!driver_data) { ret = -ENOMEM; goto err; } driver_data->da9052 = da9052; da9052_wdt = &driver_data->wdt; da9052_wdt->timeout = DA9052_DEF_TIMEOUT; da9052_wdt->info = &da9052_wdt_info; da9052_wdt->ops = &da9052_wdt_ops; da9052_wdt->parent = &pdev->dev; watchdog_set_drvdata(da9052_wdt, driver_data); ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, DA9052_CONTROLD_TWDSCALE, 0); if (ret < 0) { dev_err(&pdev->dev, "Failed to disable watchdog bits, %d\n", ret); goto err; } ret = watchdog_register_device(&driver_data->wdt); if (ret != 0) { dev_err(da9052->dev, "watchdog_register_device() failed: %d\n", ret); goto err; } platform_set_drvdata(pdev, driver_data); err: return ret; }
static int da9062_wdt_probe(struct platform_device *pdev) { int ret; struct da9062 *chip; struct da9062_watchdog *wdt; chip = dev_get_drvdata(pdev->dev.parent); if (!chip) return -EINVAL; wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL); if (!wdt) return -ENOMEM; wdt->hw = chip; wdt->wdtdev.info = &da9062_watchdog_info; wdt->wdtdev.ops = &da9062_watchdog_ops; wdt->wdtdev.min_timeout = DA9062_WDT_MIN_TIMEOUT; wdt->wdtdev.max_timeout = DA9062_WDT_MAX_TIMEOUT; wdt->wdtdev.timeout = DA9062_WDG_DEFAULT_TIMEOUT; wdt->wdtdev.status = WATCHDOG_NOWAYOUT_INIT_STATUS; wdt->wdtdev.parent = &pdev->dev; watchdog_set_drvdata(&wdt->wdtdev, wdt); dev_set_drvdata(&pdev->dev, wdt); ret = watchdog_register_device(&wdt->wdtdev); if (ret < 0) { dev_err(wdt->hw->dev, "watchdog registration failed (%d)\n", ret); return ret; } da9062_set_window_start(wdt); ret = da9062_wdt_ping(&wdt->wdtdev); if (ret < 0) watchdog_unregister_device(&wdt->wdtdev); return ret; }
static int da9055_wdt_probe(struct platform_device *pdev) { struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent); struct da9055_wdt_data *driver_data; struct watchdog_device *da9055_wdt; int ret; driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data), GFP_KERNEL); if (!driver_data) { dev_err(da9055->dev, "Failed to allocate watchdog device\n"); return -ENOMEM; } driver_data->da9055 = da9055; da9055_wdt = &driver_data->wdt; da9055_wdt->timeout = DA9055_DEF_TIMEOUT; da9055_wdt->info = &da9055_wdt_info; da9055_wdt->ops = &da9055_wdt_ops; watchdog_set_nowayout(da9055_wdt, nowayout); watchdog_set_drvdata(da9055_wdt, driver_data); kref_init(&driver_data->kref); ret = da9055_wdt_stop(da9055_wdt); if (ret < 0) { dev_err(&pdev->dev, "Failed to stop watchdog, %d\n", ret); goto err; } dev_set_drvdata(&pdev->dev, driver_data); ret = watchdog_register_device(&driver_data->wdt); if (ret != 0) dev_err(da9055->dev, "watchdog_register_device() failed: %d\n", ret); err: return ret; }