ltc2952-poweroff.c 9.14 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/*
 * LTC2952 (PowerPath) driver
 *
 * Copyright (C) 2014, Xsens Technologies BV <info@xsens.com>
 * Maintainer: Ren Moll <linux@r-moll.nl>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * ----------------------------------------
 * - Description
 * ----------------------------------------
 *
 * This driver is to be used with an external PowerPath Controller (LTC2952).
 * Its function is to determine when a external shut down is triggered
 * and react by properly shutting down the system.
 *
 * This driver expects a device tree with a ltc2952 entry for pin mapping.
 *
 * ----------------------------------------
 * - GPIO
 * ----------------------------------------
 *
 * The following GPIOs are used:
 * - trigger (input)
 *     A level change indicates the shut-down trigger. If it's state reverts
 *     within the time-out defined by trigger_delay, the shut down is not
35 36 37
 *     executed. If no pin is assigned to this input, the driver will start the
 *     watchdog toggle immediately. The chip will only power off the system if
 *     it is requested to do so through the kill line.
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
 *
 * - watchdog (output)
 *     Once a shut down is triggered, the driver will toggle this signal,
 *     with an internal (wde_interval) to stall the hardware shut down.
 *
 * - kill (output)
 *     The last action during shut down is triggering this signalling, such
 *     that the PowerPath Control will power down the hardware.
 *
 * ----------------------------------------
 * - Interrupts
 * ----------------------------------------
 *
 * The driver requires a non-shared, edge-triggered interrupt on the trigger
 * GPIO.
 *
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/ktime.h>
#include <linux/slab.h>
#include <linux/kmod.h>
#include <linux/module.h>
65
#include <linux/mod_devicetable.h>
66 67 68
#include <linux/gpio/consumer.h>
#include <linux/reboot.h>

69
struct ltc2952_poweroff {
70 71 72 73 74 75 76 77
	struct hrtimer timer_trigger;
	struct hrtimer timer_wde;

	ktime_t trigger_delay;
	ktime_t wde_interval;

	struct device *dev;

78 79 80
	struct gpio_desc *gpio_trigger;
	struct gpio_desc *gpio_watchdog;
	struct gpio_desc *gpio_kill;
81 82 83

	bool kernel_panic;
	struct notifier_block panic_notifier;
84 85
};

86 87 88 89 90 91 92
#define to_ltc2952(p, m) container_of(p, struct ltc2952_poweroff, m)

/*
 * This global variable is only needed for pm_power_off. We should
 * remove it entirely once we don't need the global state anymore.
 */
static struct ltc2952_poweroff *ltc2952_data;
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107

/**
 * ltc2952_poweroff_timer_wde - Timer callback
 * Toggles the watchdog reset signal each wde_interval
 *
 * @timer: corresponding timer
 *
 * Returns HRTIMER_RESTART for an infinite loop which will only stop when the
 * machine actually shuts down
 */
static enum hrtimer_restart ltc2952_poweroff_timer_wde(struct hrtimer *timer)
{
	ktime_t now;
	int state;
	unsigned long overruns;
108
	struct ltc2952_poweroff *data = to_ltc2952(timer, timer_wde);
109

110
	if (data->kernel_panic)
111 112
		return HRTIMER_NORESTART;

113 114
	state = gpiod_get_value(data->gpio_watchdog);
	gpiod_set_value(data->gpio_watchdog, !state);
115 116

	now = hrtimer_cb_get_time(timer);
117
	overruns = hrtimer_forward(timer, now, data->wde_interval);
118 119 120 121

	return HRTIMER_RESTART;
}

122
static void ltc2952_poweroff_start_wde(struct ltc2952_poweroff *data)
123
{
124
	hrtimer_start(&data->timer_wde, data->wde_interval, HRTIMER_MODE_REL);
125
}
126

127 128 129 130
static enum hrtimer_restart
ltc2952_poweroff_timer_trigger(struct hrtimer *timer)
{
	struct ltc2952_poweroff *data = to_ltc2952(timer, timer_trigger);
131

132 133
	ltc2952_poweroff_start_wde(data);
	dev_info(data->dev, "executing shutdown\n");
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
	orderly_poweroff(true);

	return HRTIMER_NORESTART;
}

/**
 * ltc2952_poweroff_handler - Interrupt handler
 * Triggered each time the trigger signal changes state and (de)activates a
 * time-out (timer_trigger). Once the time-out is actually reached the shut
 * down is executed.
 *
 * @irq: IRQ number
 * @dev_id: pointer to the main data structure
 */
static irqreturn_t ltc2952_poweroff_handler(int irq, void *dev_id)
{
150
	struct ltc2952_poweroff *data = dev_id;
151

152
	if (data->kernel_panic || hrtimer_active(&data->timer_wde)) {
153
		/* shutdown is already triggered, nothing to do any more */
154
		return IRQ_HANDLED;
155 156
	}

157
	if (gpiod_get_value(data->gpio_trigger)) {
158 159
		hrtimer_start(&data->timer_trigger, data->trigger_delay,
			      HRTIMER_MODE_REL);
160
	} else {
161
		hrtimer_cancel(&data->timer_trigger);
162 163 164 165 166 167
	}
	return IRQ_HANDLED;
}

static void ltc2952_poweroff_kill(void)
{
168
	gpiod_set_value(ltc2952_data->gpio_kill, 1);
169 170
}

171
static void ltc2952_poweroff_default(struct ltc2952_poweroff *data)
172
{
173
	data->wde_interval = 300L * 1E6L;
174 175 176
	data->trigger_delay = ktime_set(2, 500L*1E6L);

	hrtimer_init(&data->timer_trigger, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
177
	data->timer_trigger.function = ltc2952_poweroff_timer_trigger;
178 179

	hrtimer_init(&data->timer_wde, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
180
	data->timer_wde.function = ltc2952_poweroff_timer_wde;
181 182 183 184
}

static int ltc2952_poweroff_init(struct platform_device *pdev)
{
185
	int ret;
186
	struct ltc2952_poweroff *data = platform_get_drvdata(pdev);
187

188
	ltc2952_poweroff_default(data);
189

190 191 192 193
	data->gpio_watchdog = devm_gpiod_get(&pdev->dev, "watchdog",
					     GPIOD_OUT_LOW);
	if (IS_ERR(data->gpio_watchdog)) {
		ret = PTR_ERR(data->gpio_watchdog);
194 195 196
		dev_err(&pdev->dev, "unable to claim gpio \"watchdog\"\n");
		return ret;
	}
197

198 199 200
	data->gpio_kill = devm_gpiod_get(&pdev->dev, "kill", GPIOD_OUT_LOW);
	if (IS_ERR(data->gpio_kill)) {
		ret = PTR_ERR(data->gpio_kill);
201
		dev_err(&pdev->dev, "unable to claim gpio \"kill\"\n");
202
		return ret;
203 204
	}

205 206
	data->gpio_trigger = devm_gpiod_get_optional(&pdev->dev, "trigger",
						     GPIOD_IN);
207 208 209 210 211 212
	if (IS_ERR(data->gpio_trigger)) {
		/*
		 * It's not a problem if the trigger gpio isn't available, but
		 * it is worth a warning if its use was defined in the device
		 * tree.
		 */
213
		dev_err(&pdev->dev, "unable to claim gpio \"trigger\"\n");
214
		data->gpio_trigger = NULL;
215 216
	}

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	if (devm_request_irq(&pdev->dev, gpiod_to_irq(data->gpio_trigger),
			     ltc2952_poweroff_handler,
			     (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING),
			     "ltc2952-poweroff",
			     data)) {
		/*
		 * Some things may have happened:
		 * - No trigger input was defined
		 * - Claiming the GPIO failed
		 * - We could not map to an IRQ
		 * - We couldn't register an interrupt handler
		 *
		 * None of these really are problems, but all of them
		 * disqualify the push button from controlling the power.
		 *
		 * It is therefore important to note that if the ltc2952
		 * detects a button press for long enough, it will still start
		 * its own powerdown window and cut the power on us if we don't
		 * start the watchdog trigger.
		 */
		if (data->gpio_trigger) {
			dev_warn(&pdev->dev,
				 "unable to configure the trigger interrupt\n");
			devm_gpiod_put(&pdev->dev, data->gpio_trigger);
			data->gpio_trigger = NULL;
		}
		dev_info(&pdev->dev,
			 "power down trigger input will not be used\n");
		ltc2952_poweroff_start_wde(data);
246 247 248 249 250
	}

	return 0;
}

251 252 253 254 255 256 257 258 259
static int ltc2952_poweroff_notify_panic(struct notifier_block *nb,
					 unsigned long code, void *unused)
{
	struct ltc2952_poweroff *data = to_ltc2952(nb, panic_notifier);

	data->kernel_panic = true;
	return NOTIFY_DONE;
}

260 261 262
static int ltc2952_poweroff_probe(struct platform_device *pdev)
{
	int ret;
263
	struct ltc2952_poweroff *data;
264 265 266 267 268 269

	if (pm_power_off) {
		dev_err(&pdev->dev, "pm_power_off already registered");
		return -EBUSY;
	}

270 271
	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
272 273
		return -ENOMEM;

274 275
	data->dev = &pdev->dev;
	platform_set_drvdata(pdev, data);
276 277 278

	ret = ltc2952_poweroff_init(pdev);
	if (ret)
279
		return ret;
280

281 282
	/* TODO: remove ltc2952_data */
	ltc2952_data = data;
283
	pm_power_off = ltc2952_poweroff_kill;
284

285 286 287
	data->panic_notifier.notifier_call = ltc2952_poweroff_notify_panic;
	atomic_notifier_chain_register(&panic_notifier_list,
				       &data->panic_notifier);
288 289 290 291 292 293 294
	dev_info(&pdev->dev, "probe successful\n");

	return 0;
}

static int ltc2952_poweroff_remove(struct platform_device *pdev)
{
295
	struct ltc2952_poweroff *data = platform_get_drvdata(pdev);
296

297
	pm_power_off = NULL;
298 299
	hrtimer_cancel(&data->timer_trigger);
	hrtimer_cancel(&data->timer_wde);
300 301
	atomic_notifier_chain_unregister(&panic_notifier_list,
					 &data->panic_notifier);
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
	return 0;
}

static const struct of_device_id of_ltc2952_poweroff_match[] = {
	{ .compatible = "lltc,ltc2952"},
	{},
};
MODULE_DEVICE_TABLE(of, of_ltc2952_poweroff_match);

static struct platform_driver ltc2952_poweroff_driver = {
	.probe = ltc2952_poweroff_probe,
	.remove = ltc2952_poweroff_remove,
	.driver = {
		.name = "ltc2952-poweroff",
		.of_match_table = of_ltc2952_poweroff_match,
	},
};

320
module_platform_driver(ltc2952_poweroff_driver);
321 322 323 324

MODULE_AUTHOR("Ren Moll <rene.moll@xsens.com>");
MODULE_DESCRIPTION("LTC PowerPath power-off driver");
MODULE_LICENSE("GPL v2");