1 /* 2 * System monitoring driver for DA9052 PMICs. 3 * 4 * Copyright(c) 2012 Dialog Semiconductor Ltd. 5 * 6 * Author: Anthony Olech <Anthony.Olech@diasemi.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 */ 14 15 #include <linux/module.h> 16 #include <linux/delay.h> 17 #include <linux/uaccess.h> 18 #include <linux/platform_device.h> 19 #include <linux/time.h> 20 #include <linux/watchdog.h> 21 #include <linux/types.h> 22 #include <linux/kernel.h> 23 #include <linux/jiffies.h> 24 25 #include <linux/mfd/da9052/reg.h> 26 #include <linux/mfd/da9052/da9052.h> 27 28 #define DA9052_DEF_TIMEOUT 4 29 #define DA9052_TWDMIN 256 30 31 struct da9052_wdt_data { 32 struct watchdog_device wdt; 33 struct da9052 *da9052; 34 unsigned long jpast; 35 }; 36 37 static const struct { 38 u8 reg_val; 39 int time; /* Seconds */ 40 } da9052_wdt_maps[] = { 41 { 1, 2 }, 42 { 2, 4 }, 43 { 3, 8 }, 44 { 4, 16 }, 45 { 5, 32 }, 46 { 5, 33 }, /* Actual time 32.768s so included both 32s and 33s */ 47 { 6, 65 }, 48 { 6, 66 }, /* Actual time 65.536s so include both, 65s and 66s */ 49 { 7, 131 }, 50 }; 51 52 53 static int da9052_wdt_set_timeout(struct watchdog_device *wdt_dev, 54 unsigned int timeout) 55 { 56 struct da9052_wdt_data *driver_data = watchdog_get_drvdata(wdt_dev); 57 struct da9052 *da9052 = driver_data->da9052; 58 int ret, i; 59 60 /* 61 * Disable the Watchdog timer before setting 62 * new time out. 63 */ 64 ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, 65 DA9052_CONTROLD_TWDSCALE, 0); 66 if (ret < 0) { 67 dev_err(da9052->dev, "Failed to disable watchdog bit, %d\n", 68 ret); 69 return ret; 70 } 71 if (timeout) { 72 /* 73 * To change the timeout, da9052 needs to 74 * be disabled for at least 150 us. 75 */ 76 udelay(150); 77 78 /* Set the desired timeout */ 79 for (i = 0; i < ARRAY_SIZE(da9052_wdt_maps); i++) 80 if (da9052_wdt_maps[i].time == timeout) 81 break; 82 83 if (i == ARRAY_SIZE(da9052_wdt_maps)) 84 ret = -EINVAL; 85 else 86 ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, 87 DA9052_CONTROLD_TWDSCALE, 88 da9052_wdt_maps[i].reg_val); 89 if (ret < 0) { 90 dev_err(da9052->dev, 91 "Failed to update timescale bit, %d\n", ret); 92 return ret; 93 } 94 95 wdt_dev->timeout = timeout; 96 driver_data->jpast = jiffies; 97 } 98 99 return 0; 100 } 101 102 static int da9052_wdt_start(struct watchdog_device *wdt_dev) 103 { 104 return da9052_wdt_set_timeout(wdt_dev, wdt_dev->timeout); 105 } 106 107 static int da9052_wdt_stop(struct watchdog_device *wdt_dev) 108 { 109 return da9052_wdt_set_timeout(wdt_dev, 0); 110 } 111 112 static int da9052_wdt_ping(struct watchdog_device *wdt_dev) 113 { 114 struct da9052_wdt_data *driver_data = watchdog_get_drvdata(wdt_dev); 115 struct da9052 *da9052 = driver_data->da9052; 116 unsigned long msec, jnow = jiffies; 117 int ret; 118 119 /* 120 * We have a minimum time for watchdog window called TWDMIN. A write 121 * to the watchdog before this elapsed time should cause an error. 122 */ 123 msec = (jnow - driver_data->jpast) * 1000/HZ; 124 if (msec < DA9052_TWDMIN) 125 mdelay(msec); 126 127 /* Reset the watchdog timer */ 128 ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, 129 DA9052_CONTROLD_WATCHDOG, 1 << 7); 130 if (ret < 0) 131 goto err_strobe; 132 133 /* 134 * FIXME: Reset the watchdog core, in general PMIC 135 * is supposed to do this 136 */ 137 ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, 138 DA9052_CONTROLD_WATCHDOG, 0 << 7); 139 err_strobe: 140 return ret; 141 } 142 143 static struct watchdog_info da9052_wdt_info = { 144 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING, 145 .identity = "DA9052 Watchdog", 146 }; 147 148 static const struct watchdog_ops da9052_wdt_ops = { 149 .owner = THIS_MODULE, 150 .start = da9052_wdt_start, 151 .stop = da9052_wdt_stop, 152 .ping = da9052_wdt_ping, 153 .set_timeout = da9052_wdt_set_timeout, 154 }; 155 156 157 static int da9052_wdt_probe(struct platform_device *pdev) 158 { 159 struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent); 160 struct da9052_wdt_data *driver_data; 161 struct watchdog_device *da9052_wdt; 162 int ret; 163 164 driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data), 165 GFP_KERNEL); 166 if (!driver_data) { 167 ret = -ENOMEM; 168 goto err; 169 } 170 driver_data->da9052 = da9052; 171 172 da9052_wdt = &driver_data->wdt; 173 174 da9052_wdt->timeout = DA9052_DEF_TIMEOUT; 175 da9052_wdt->info = &da9052_wdt_info; 176 da9052_wdt->ops = &da9052_wdt_ops; 177 da9052_wdt->parent = &pdev->dev; 178 watchdog_set_drvdata(da9052_wdt, driver_data); 179 180 ret = da9052_reg_update(da9052, DA9052_CONTROL_D_REG, 181 DA9052_CONTROLD_TWDSCALE, 0); 182 if (ret < 0) { 183 dev_err(&pdev->dev, "Failed to disable watchdog bits, %d\n", 184 ret); 185 goto err; 186 } 187 188 ret = watchdog_register_device(&driver_data->wdt); 189 if (ret != 0) { 190 dev_err(da9052->dev, "watchdog_register_device() failed: %d\n", 191 ret); 192 goto err; 193 } 194 195 platform_set_drvdata(pdev, driver_data); 196 err: 197 return ret; 198 } 199 200 static int da9052_wdt_remove(struct platform_device *pdev) 201 { 202 struct da9052_wdt_data *driver_data = platform_get_drvdata(pdev); 203 204 watchdog_unregister_device(&driver_data->wdt); 205 206 return 0; 207 } 208 209 static struct platform_driver da9052_wdt_driver = { 210 .probe = da9052_wdt_probe, 211 .remove = da9052_wdt_remove, 212 .driver = { 213 .name = "da9052-watchdog", 214 }, 215 }; 216 217 module_platform_driver(da9052_wdt_driver); 218 219 MODULE_AUTHOR("Anthony Olech <Anthony.Olech@diasemi.com>"); 220 MODULE_DESCRIPTION("DA9052 SM Device Driver"); 221 MODULE_LICENSE("GPL"); 222 MODULE_ALIAS("platform:da9052-watchdog"); 223