2 * LTC2952 (PowerPath) driver
4 * Copyright (C) 2014, Xsens Technologies BV <info@xsens.com>
5 * Maintainer: René Moll <linux@r-moll.nl>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * ----------------------------------------
19 * ----------------------------------------
21 * This driver is to be used with an external PowerPath Controller (LTC2952).
22 * Its function is to determine when a external shut down is triggered
23 * and react by properly shutting down the system.
25 * This driver expects a device tree with a ltc2952 entry for pin mapping.
27 * ----------------------------------------
29 * ----------------------------------------
31 * The following GPIOs are used:
33 * A level change indicates the shut-down trigger. If it's state reverts
34 * within the time-out defined by trigger_delay, the shut down is not
35 * executed. If no pin is assigned to this input, the driver will start the
36 * watchdog toggle immediately. The chip will only power off the system if
37 * it is requested to do so through the kill line.
40 * Once a shut down is triggered, the driver will toggle this signal,
41 * with an internal (wde_interval) to stall the hardware shut down.
44 * The last action during shut down is triggering this signalling, such
45 * that the PowerPath Control will power down the hardware.
47 * ----------------------------------------
49 * ----------------------------------------
51 * The driver requires a non-shared, edge-triggered interrupt on the trigger
56 #include <linux/kernel.h>
57 #include <linux/init.h>
58 #include <linux/interrupt.h>
59 #include <linux/device.h>
60 #include <linux/platform_device.h>
61 #include <linux/ktime.h>
62 #include <linux/slab.h>
63 #include <linux/kmod.h>
64 #include <linux/module.h>
65 #include <linux/gpio/consumer.h>
66 #include <linux/reboot.h>
68 struct ltc2952_poweroff
{
69 struct hrtimer timer_trigger
;
70 struct hrtimer timer_wde
;
72 ktime_t trigger_delay
;
77 struct gpio_desc
*gpio_trigger
;
78 struct gpio_desc
*gpio_watchdog
;
79 struct gpio_desc
*gpio_kill
;
82 struct notifier_block panic_notifier
;
85 #define to_ltc2952(p, m) container_of(p, struct ltc2952_poweroff, m)
88 * This global variable is only needed for pm_power_off. We should
89 * remove it entirely once we don't need the global state anymore.
91 static struct ltc2952_poweroff
*ltc2952_data
;
94 * ltc2952_poweroff_timer_wde - Timer callback
95 * Toggles the watchdog reset signal each wde_interval
97 * @timer: corresponding timer
99 * Returns HRTIMER_RESTART for an infinite loop which will only stop when the
100 * machine actually shuts down
102 static enum hrtimer_restart
ltc2952_poweroff_timer_wde(struct hrtimer
*timer
)
106 unsigned long overruns
;
107 struct ltc2952_poweroff
*data
= to_ltc2952(timer
, timer_wde
);
109 if (data
->kernel_panic
)
110 return HRTIMER_NORESTART
;
112 state
= gpiod_get_value(data
->gpio_watchdog
);
113 gpiod_set_value(data
->gpio_watchdog
, !state
);
115 now
= hrtimer_cb_get_time(timer
);
116 overruns
= hrtimer_forward(timer
, now
, data
->wde_interval
);
118 return HRTIMER_RESTART
;
121 static void ltc2952_poweroff_start_wde(struct ltc2952_poweroff
*data
)
123 hrtimer_start(&data
->timer_wde
, data
->wde_interval
, HRTIMER_MODE_REL
);
126 static enum hrtimer_restart
127 ltc2952_poweroff_timer_trigger(struct hrtimer
*timer
)
129 struct ltc2952_poweroff
*data
= to_ltc2952(timer
, timer_trigger
);
131 ltc2952_poweroff_start_wde(data
);
132 dev_info(data
->dev
, "executing shutdown\n");
133 orderly_poweroff(true);
135 return HRTIMER_NORESTART
;
139 * ltc2952_poweroff_handler - Interrupt handler
140 * Triggered each time the trigger signal changes state and (de)activates a
141 * time-out (timer_trigger). Once the time-out is actually reached the shut
145 * @dev_id: pointer to the main data structure
147 static irqreturn_t
ltc2952_poweroff_handler(int irq
, void *dev_id
)
149 struct ltc2952_poweroff
*data
= dev_id
;
151 if (data
->kernel_panic
|| hrtimer_active(&data
->timer_wde
)) {
152 /* shutdown is already triggered, nothing to do any more */
156 if (gpiod_get_value(data
->gpio_trigger
)) {
157 hrtimer_start(&data
->timer_trigger
, data
->trigger_delay
,
160 hrtimer_cancel(&data
->timer_trigger
);
165 static void ltc2952_poweroff_kill(void)
167 gpiod_set_value(ltc2952_data
->gpio_kill
, 1);
170 static void ltc2952_poweroff_default(struct ltc2952_poweroff
*data
)
172 data
->wde_interval
= ktime_set(0, 300L*1E6L
);
173 data
->trigger_delay
= ktime_set(2, 500L*1E6L
);
175 hrtimer_init(&data
->timer_trigger
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
176 data
->timer_trigger
.function
= ltc2952_poweroff_timer_trigger
;
178 hrtimer_init(&data
->timer_wde
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
179 data
->timer_wde
.function
= ltc2952_poweroff_timer_wde
;
182 static int ltc2952_poweroff_init(struct platform_device
*pdev
)
185 struct ltc2952_poweroff
*data
= platform_get_drvdata(pdev
);
187 ltc2952_poweroff_default(data
);
189 data
->gpio_watchdog
= devm_gpiod_get(&pdev
->dev
, "watchdog",
191 if (IS_ERR(data
->gpio_watchdog
)) {
192 ret
= PTR_ERR(data
->gpio_watchdog
);
193 dev_err(&pdev
->dev
, "unable to claim gpio \"watchdog\"\n");
197 data
->gpio_kill
= devm_gpiod_get(&pdev
->dev
, "kill", GPIOD_OUT_LOW
);
198 if (IS_ERR(data
->gpio_kill
)) {
199 ret
= PTR_ERR(data
->gpio_kill
);
200 dev_err(&pdev
->dev
, "unable to claim gpio \"kill\"\n");
204 data
->gpio_trigger
= devm_gpiod_get_optional(&pdev
->dev
, "trigger",
206 if (IS_ERR(data
->gpio_trigger
)) {
208 * It's not a problem if the trigger gpio isn't available, but
209 * it is worth a warning if its use was defined in the device
212 dev_err(&pdev
->dev
, "unable to claim gpio \"trigger\"\n");
213 data
->gpio_trigger
= NULL
;
216 if (devm_request_irq(&pdev
->dev
, gpiod_to_irq(data
->gpio_trigger
),
217 ltc2952_poweroff_handler
,
218 (IRQF_TRIGGER_FALLING
| IRQF_TRIGGER_RISING
),
222 * Some things may have happened:
223 * - No trigger input was defined
224 * - Claiming the GPIO failed
225 * - We could not map to an IRQ
226 * - We couldn't register an interrupt handler
228 * None of these really are problems, but all of them
229 * disqualify the push button from controlling the power.
231 * It is therefore important to note that if the ltc2952
232 * detects a button press for long enough, it will still start
233 * its own powerdown window and cut the power on us if we don't
234 * start the watchdog trigger.
236 if (data
->gpio_trigger
) {
238 "unable to configure the trigger interrupt\n");
239 devm_gpiod_put(&pdev
->dev
, data
->gpio_trigger
);
240 data
->gpio_trigger
= NULL
;
243 "power down trigger input will not be used\n");
244 ltc2952_poweroff_start_wde(data
);
250 static int ltc2952_poweroff_notify_panic(struct notifier_block
*nb
,
251 unsigned long code
, void *unused
)
253 struct ltc2952_poweroff
*data
= to_ltc2952(nb
, panic_notifier
);
255 data
->kernel_panic
= true;
259 static int ltc2952_poweroff_probe(struct platform_device
*pdev
)
262 struct ltc2952_poweroff
*data
;
265 dev_err(&pdev
->dev
, "pm_power_off already registered");
269 data
= devm_kzalloc(&pdev
->dev
, sizeof(*data
), GFP_KERNEL
);
273 data
->dev
= &pdev
->dev
;
274 platform_set_drvdata(pdev
, data
);
276 ret
= ltc2952_poweroff_init(pdev
);
280 /* TODO: remove ltc2952_data */
282 pm_power_off
= ltc2952_poweroff_kill
;
284 data
->panic_notifier
.notifier_call
= ltc2952_poweroff_notify_panic
;
285 atomic_notifier_chain_register(&panic_notifier_list
,
286 &data
->panic_notifier
);
287 dev_info(&pdev
->dev
, "probe successful\n");
292 static int ltc2952_poweroff_remove(struct platform_device
*pdev
)
294 struct ltc2952_poweroff
*data
= platform_get_drvdata(pdev
);
297 hrtimer_cancel(&data
->timer_trigger
);
298 hrtimer_cancel(&data
->timer_wde
);
299 atomic_notifier_chain_unregister(&panic_notifier_list
,
300 &data
->panic_notifier
);
304 static const struct of_device_id of_ltc2952_poweroff_match
[] = {
305 { .compatible
= "lltc,ltc2952"},
308 MODULE_DEVICE_TABLE(of
, of_ltc2952_poweroff_match
);
310 static struct platform_driver ltc2952_poweroff_driver
= {
311 .probe
= ltc2952_poweroff_probe
,
312 .remove
= ltc2952_poweroff_remove
,
314 .name
= "ltc2952-poweroff",
315 .of_match_table
= of_ltc2952_poweroff_match
,
319 module_platform_driver(ltc2952_poweroff_driver
);
321 MODULE_AUTHOR("René Moll <rene.moll@xsens.com>");
322 MODULE_DESCRIPTION("LTC PowerPath power-off driver");
323 MODULE_LICENSE("GPL v2");