1 /* 2 * Meson Watchdog Driver 3 * 4 * Copyright (c) 2014 Carlo Caione 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/clk.h> 13 #include <linux/delay.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/io.h> 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/moduleparam.h> 20 #include <linux/of.h> 21 #include <linux/of_device.h> 22 #include <linux/platform_device.h> 23 #include <linux/types.h> 24 #include <linux/watchdog.h> 25 26 #define DRV_NAME "meson_wdt" 27 28 #define MESON_WDT_TC 0x00 29 #define MESON_WDT_DC_RESET (3 << 24) 30 31 #define MESON_WDT_RESET 0x04 32 33 #define MESON_WDT_TIMEOUT 30 34 #define MESON_WDT_MIN_TIMEOUT 1 35 36 #define MESON_SEC_TO_TC(s, c) ((s) * (c)) 37 38 static bool nowayout = WATCHDOG_NOWAYOUT; 39 static unsigned int timeout = MESON_WDT_TIMEOUT; 40 41 struct meson_wdt_data { 42 unsigned int enable; 43 unsigned int terminal_count_mask; 44 unsigned int count_unit; 45 }; 46 47 static struct meson_wdt_data meson6_wdt_data = { 48 .enable = BIT(22), 49 .terminal_count_mask = 0x3fffff, 50 .count_unit = 100000, /* 10 us */ 51 }; 52 53 static struct meson_wdt_data meson8b_wdt_data = { 54 .enable = BIT(19), 55 .terminal_count_mask = 0xffff, 56 .count_unit = 7812, /* 128 us */ 57 }; 58 59 struct meson_wdt_dev { 60 struct watchdog_device wdt_dev; 61 void __iomem *wdt_base; 62 const struct meson_wdt_data *data; 63 }; 64 65 static int meson_wdt_restart(struct watchdog_device *wdt_dev, 66 unsigned long action, void *data) 67 { 68 struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev); 69 u32 tc_reboot = MESON_WDT_DC_RESET; 70 71 tc_reboot |= meson_wdt->data->enable; 72 73 while (1) { 74 writel(tc_reboot, meson_wdt->wdt_base + MESON_WDT_TC); 75 mdelay(5); 76 } 77 78 return 0; 79 } 80 81 static int meson_wdt_ping(struct watchdog_device *wdt_dev) 82 { 83 struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev); 84 85 writel(0, meson_wdt->wdt_base + MESON_WDT_RESET); 86 87 return 0; 88 } 89 90 static void meson_wdt_change_timeout(struct watchdog_device *wdt_dev, 91 unsigned int timeout) 92 { 93 struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev); 94 u32 reg; 95 96 reg = readl(meson_wdt->wdt_base + MESON_WDT_TC); 97 reg &= ~meson_wdt->data->terminal_count_mask; 98 reg |= MESON_SEC_TO_TC(timeout, meson_wdt->data->count_unit); 99 writel(reg, meson_wdt->wdt_base + MESON_WDT_TC); 100 } 101 102 static int meson_wdt_set_timeout(struct watchdog_device *wdt_dev, 103 unsigned int timeout) 104 { 105 wdt_dev->timeout = timeout; 106 107 meson_wdt_change_timeout(wdt_dev, timeout); 108 meson_wdt_ping(wdt_dev); 109 110 return 0; 111 } 112 113 static int meson_wdt_stop(struct watchdog_device *wdt_dev) 114 { 115 struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev); 116 u32 reg; 117 118 reg = readl(meson_wdt->wdt_base + MESON_WDT_TC); 119 reg &= ~meson_wdt->data->enable; 120 writel(reg, meson_wdt->wdt_base + MESON_WDT_TC); 121 122 return 0; 123 } 124 125 static int meson_wdt_start(struct watchdog_device *wdt_dev) 126 { 127 struct meson_wdt_dev *meson_wdt = watchdog_get_drvdata(wdt_dev); 128 u32 reg; 129 130 meson_wdt_change_timeout(wdt_dev, meson_wdt->wdt_dev.timeout); 131 meson_wdt_ping(wdt_dev); 132 133 reg = readl(meson_wdt->wdt_base + MESON_WDT_TC); 134 reg |= meson_wdt->data->enable; 135 writel(reg, meson_wdt->wdt_base + MESON_WDT_TC); 136 137 return 0; 138 } 139 140 static const struct watchdog_info meson_wdt_info = { 141 .identity = DRV_NAME, 142 .options = WDIOF_SETTIMEOUT | 143 WDIOF_KEEPALIVEPING | 144 WDIOF_MAGICCLOSE, 145 }; 146 147 static const struct watchdog_ops meson_wdt_ops = { 148 .owner = THIS_MODULE, 149 .start = meson_wdt_start, 150 .stop = meson_wdt_stop, 151 .ping = meson_wdt_ping, 152 .set_timeout = meson_wdt_set_timeout, 153 .restart = meson_wdt_restart, 154 }; 155 156 static const struct of_device_id meson_wdt_dt_ids[] = { 157 { .compatible = "amlogic,meson6-wdt", .data = &meson6_wdt_data }, 158 { .compatible = "amlogic,meson8b-wdt", .data = &meson8b_wdt_data }, 159 { /* sentinel */ } 160 }; 161 MODULE_DEVICE_TABLE(of, meson_wdt_dt_ids); 162 163 static int meson_wdt_probe(struct platform_device *pdev) 164 { 165 struct resource *res; 166 struct meson_wdt_dev *meson_wdt; 167 const struct of_device_id *of_id; 168 int err; 169 170 meson_wdt = devm_kzalloc(&pdev->dev, sizeof(*meson_wdt), GFP_KERNEL); 171 if (!meson_wdt) 172 return -ENOMEM; 173 174 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 175 meson_wdt->wdt_base = devm_ioremap_resource(&pdev->dev, res); 176 if (IS_ERR(meson_wdt->wdt_base)) 177 return PTR_ERR(meson_wdt->wdt_base); 178 179 of_id = of_match_device(meson_wdt_dt_ids, &pdev->dev); 180 if (!of_id) { 181 dev_err(&pdev->dev, "Unable to initialize WDT data\n"); 182 return -ENODEV; 183 } 184 meson_wdt->data = of_id->data; 185 186 meson_wdt->wdt_dev.parent = &pdev->dev; 187 meson_wdt->wdt_dev.info = &meson_wdt_info; 188 meson_wdt->wdt_dev.ops = &meson_wdt_ops; 189 meson_wdt->wdt_dev.max_timeout = 190 meson_wdt->data->terminal_count_mask / meson_wdt->data->count_unit; 191 meson_wdt->wdt_dev.min_timeout = MESON_WDT_MIN_TIMEOUT; 192 meson_wdt->wdt_dev.timeout = min_t(unsigned int, 193 MESON_WDT_TIMEOUT, 194 meson_wdt->wdt_dev.max_timeout); 195 196 watchdog_set_drvdata(&meson_wdt->wdt_dev, meson_wdt); 197 198 watchdog_init_timeout(&meson_wdt->wdt_dev, timeout, &pdev->dev); 199 watchdog_set_nowayout(&meson_wdt->wdt_dev, nowayout); 200 watchdog_set_restart_priority(&meson_wdt->wdt_dev, 128); 201 202 meson_wdt_stop(&meson_wdt->wdt_dev); 203 204 err = watchdog_register_device(&meson_wdt->wdt_dev); 205 if (err) 206 return err; 207 208 platform_set_drvdata(pdev, meson_wdt); 209 210 dev_info(&pdev->dev, "Watchdog enabled (timeout=%d sec, nowayout=%d)", 211 meson_wdt->wdt_dev.timeout, nowayout); 212 213 return 0; 214 } 215 216 static int meson_wdt_remove(struct platform_device *pdev) 217 { 218 struct meson_wdt_dev *meson_wdt = platform_get_drvdata(pdev); 219 220 watchdog_unregister_device(&meson_wdt->wdt_dev); 221 222 return 0; 223 } 224 225 static void meson_wdt_shutdown(struct platform_device *pdev) 226 { 227 struct meson_wdt_dev *meson_wdt = platform_get_drvdata(pdev); 228 229 meson_wdt_stop(&meson_wdt->wdt_dev); 230 } 231 232 static struct platform_driver meson_wdt_driver = { 233 .probe = meson_wdt_probe, 234 .remove = meson_wdt_remove, 235 .shutdown = meson_wdt_shutdown, 236 .driver = { 237 .name = DRV_NAME, 238 .of_match_table = meson_wdt_dt_ids, 239 }, 240 }; 241 242 module_platform_driver(meson_wdt_driver); 243 244 module_param(timeout, uint, 0); 245 MODULE_PARM_DESC(timeout, "Watchdog heartbeat in seconds"); 246 247 module_param(nowayout, bool, 0); 248 MODULE_PARM_DESC(nowayout, 249 "Watchdog cannot be stopped once started (default=" 250 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 251 252 MODULE_LICENSE("GPL"); 253 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>"); 254 MODULE_DESCRIPTION("Meson Watchdog Timer Driver"); 255