1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Texas Instruments' Palmas Power Button Input Driver
4  *
5  * Copyright (C) 2012-2014 Texas Instruments Incorporated - http://www.ti.com/
6  *	Girish S Ghongdemath
7  *	Nishanth Menon
8  */
9 
10 #include <linux/bitfield.h>
11 #include <linux/init.h>
12 #include <linux/input.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel.h>
15 #include <linux/mfd/palmas.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/platform_device.h>
19 #include <linux/slab.h>
20 
21 #define PALMAS_LPK_TIME_MASK		0x0c
22 #define PALMAS_PWRON_DEBOUNCE_MASK	0x03
23 #define PALMAS_PWR_KEY_Q_TIME_MS	20
24 
25 /**
26  * struct palmas_pwron - Palmas power on data
27  * @palmas:		pointer to palmas device
28  * @input_dev:		pointer to input device
29  * @input_work:		work for detecting release of key
30  * @irq:		irq that we are hooked on to
31  */
32 struct palmas_pwron {
33 	struct palmas *palmas;
34 	struct input_dev *input_dev;
35 	struct delayed_work input_work;
36 	int irq;
37 };
38 
39 /**
40  * struct palmas_pwron_config - configuration of palmas power on
41  * @long_press_time_val:	value for long press h/w shutdown event
42  * @pwron_debounce_val:		value for debounce of power button
43  */
44 struct palmas_pwron_config {
45 	u8 long_press_time_val;
46 	u8 pwron_debounce_val;
47 };
48 
49 /**
50  * palmas_power_button_work() - Detects the button release event
51  * @work:	work item to detect button release
52  */
53 static void palmas_power_button_work(struct work_struct *work)
54 {
55 	struct palmas_pwron *pwron = container_of(work,
56 						  struct palmas_pwron,
57 						  input_work.work);
58 	struct input_dev *input_dev = pwron->input_dev;
59 	unsigned int reg;
60 	int error;
61 
62 	error = palmas_read(pwron->palmas, PALMAS_INTERRUPT_BASE,
63 			    PALMAS_INT1_LINE_STATE, &reg);
64 	if (error) {
65 		dev_err(input_dev->dev.parent,
66 			"Cannot read palmas PWRON status: %d\n", error);
67 	} else if (reg & BIT(1)) {
68 		/* The button is released, report event. */
69 		input_report_key(input_dev, KEY_POWER, 0);
70 		input_sync(input_dev);
71 	} else {
72 		/* The button is still depressed, keep checking. */
73 		schedule_delayed_work(&pwron->input_work,
74 				msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
75 	}
76 }
77 
78 /**
79  * pwron_irq() - button press isr
80  * @irq:		irq
81  * @palmas_pwron:	pwron struct
82  *
83  * Return: IRQ_HANDLED
84  */
85 static irqreturn_t pwron_irq(int irq, void *palmas_pwron)
86 {
87 	struct palmas_pwron *pwron = palmas_pwron;
88 	struct input_dev *input_dev = pwron->input_dev;
89 
90 	input_report_key(input_dev, KEY_POWER, 1);
91 	pm_wakeup_event(input_dev->dev.parent, 0);
92 	input_sync(input_dev);
93 
94 	mod_delayed_work(system_wq, &pwron->input_work,
95 			 msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS));
96 
97 	return IRQ_HANDLED;
98 }
99 
100 /**
101  * palmas_pwron_params_ofinit() - device tree parameter parser
102  * @dev:	palmas button device
103  * @config:	configuration params that this fills up
104  */
105 static void palmas_pwron_params_ofinit(struct device *dev,
106 				       struct palmas_pwron_config *config)
107 {
108 	struct device_node *np;
109 	u32 val;
110 	int i, error;
111 	static const u8 lpk_times[] = { 6, 8, 10, 12 };
112 	static const int pwr_on_deb_ms[] = { 15, 100, 500, 1000 };
113 
114 	memset(config, 0, sizeof(*config));
115 
116 	/* Default config parameters */
117 	config->long_press_time_val = ARRAY_SIZE(lpk_times) - 1;
118 
119 	np = dev->of_node;
120 	if (!np)
121 		return;
122 
123 	error = of_property_read_u32(np, "ti,palmas-long-press-seconds", &val);
124 	if (!error) {
125 		for (i = 0; i < ARRAY_SIZE(lpk_times); i++) {
126 			if (val <= lpk_times[i]) {
127 				config->long_press_time_val = i;
128 				break;
129 			}
130 		}
131 	}
132 
133 	error = of_property_read_u32(np,
134 				     "ti,palmas-pwron-debounce-milli-seconds",
135 				     &val);
136 	if (!error) {
137 		for (i = 0; i < ARRAY_SIZE(pwr_on_deb_ms); i++) {
138 			if (val <= pwr_on_deb_ms[i]) {
139 				config->pwron_debounce_val = i;
140 				break;
141 			}
142 		}
143 	}
144 
145 	dev_info(dev, "h/w controlled shutdown duration=%d seconds\n",
146 		 lpk_times[config->long_press_time_val]);
147 }
148 
149 /**
150  * palmas_pwron_probe() - probe
151  * @pdev:	platform device for the button
152  *
153  * Return: 0 for successful probe else appropriate error
154  */
155 static int palmas_pwron_probe(struct platform_device *pdev)
156 {
157 	struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
158 	struct device *dev = &pdev->dev;
159 	struct input_dev *input_dev;
160 	struct palmas_pwron *pwron;
161 	struct palmas_pwron_config config;
162 	int val;
163 	int error;
164 
165 	palmas_pwron_params_ofinit(dev, &config);
166 
167 	pwron = kzalloc(sizeof(*pwron), GFP_KERNEL);
168 	if (!pwron)
169 		return -ENOMEM;
170 
171 	input_dev = input_allocate_device();
172 	if (!input_dev) {
173 		dev_err(dev, "Can't allocate power button\n");
174 		error = -ENOMEM;
175 		goto err_free_mem;
176 	}
177 
178 	input_dev->name = "palmas_pwron";
179 	input_dev->phys = "palmas_pwron/input0";
180 	input_dev->dev.parent = dev;
181 
182 	input_set_capability(input_dev, EV_KEY, KEY_POWER);
183 
184 	/*
185 	 * Setup default hardware shutdown option (long key press)
186 	 * and debounce.
187 	 */
188 	val = FIELD_PREP(PALMAS_LPK_TIME_MASK, config.long_press_time_val) |
189 	      FIELD_PREP(PALMAS_PWRON_DEBOUNCE_MASK, config.pwron_debounce_val);
190 	error = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE,
191 				   PALMAS_LONG_PRESS_KEY,
192 				   PALMAS_LPK_TIME_MASK |
193 					PALMAS_PWRON_DEBOUNCE_MASK,
194 				   val);
195 	if (error) {
196 		dev_err(dev, "LONG_PRESS_KEY_UPDATE failed: %d\n", error);
197 		goto err_free_input;
198 	}
199 
200 	pwron->palmas = palmas;
201 	pwron->input_dev = input_dev;
202 
203 	INIT_DELAYED_WORK(&pwron->input_work, palmas_power_button_work);
204 
205 	pwron->irq = platform_get_irq(pdev, 0);
206 	if (pwron->irq < 0) {
207 		error = pwron->irq;
208 		goto err_free_input;
209 	}
210 
211 	error = request_threaded_irq(pwron->irq, NULL, pwron_irq,
212 				     IRQF_TRIGGER_HIGH |
213 					IRQF_TRIGGER_LOW |
214 					IRQF_ONESHOT,
215 				     dev_name(dev), pwron);
216 	if (error) {
217 		dev_err(dev, "Can't get IRQ for pwron: %d\n", error);
218 		goto err_free_input;
219 	}
220 
221 	error = input_register_device(input_dev);
222 	if (error) {
223 		dev_err(dev, "Can't register power button: %d\n", error);
224 		goto err_free_irq;
225 	}
226 
227 	platform_set_drvdata(pdev, pwron);
228 	device_init_wakeup(dev, true);
229 
230 	return 0;
231 
232 err_free_irq:
233 	cancel_delayed_work_sync(&pwron->input_work);
234 	free_irq(pwron->irq, pwron);
235 err_free_input:
236 	input_free_device(input_dev);
237 err_free_mem:
238 	kfree(pwron);
239 	return error;
240 }
241 
242 /**
243  * palmas_pwron_remove() - Cleanup on removal
244  * @pdev:	platform device for the button
245  *
246  * Return: 0
247  */
248 static int palmas_pwron_remove(struct platform_device *pdev)
249 {
250 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);
251 
252 	free_irq(pwron->irq, pwron);
253 	cancel_delayed_work_sync(&pwron->input_work);
254 
255 	input_unregister_device(pwron->input_dev);
256 	kfree(pwron);
257 
258 	return 0;
259 }
260 
261 /**
262  * palmas_pwron_suspend() - suspend handler
263  * @dev:	power button device
264  *
265  * Cancel all pending work items for the power button, setup irq for wakeup
266  *
267  * Return: 0
268  */
269 static int palmas_pwron_suspend(struct device *dev)
270 {
271 	struct platform_device *pdev = to_platform_device(dev);
272 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);
273 
274 	cancel_delayed_work_sync(&pwron->input_work);
275 
276 	if (device_may_wakeup(dev))
277 		enable_irq_wake(pwron->irq);
278 
279 	return 0;
280 }
281 
282 /**
283  * palmas_pwron_resume() - resume handler
284  * @dev:	power button device
285  *
286  * Just disable the wakeup capability of irq here.
287  *
288  * Return: 0
289  */
290 static int palmas_pwron_resume(struct device *dev)
291 {
292 	struct platform_device *pdev = to_platform_device(dev);
293 	struct palmas_pwron *pwron = platform_get_drvdata(pdev);
294 
295 	if (device_may_wakeup(dev))
296 		disable_irq_wake(pwron->irq);
297 
298 	return 0;
299 }
300 
301 static DEFINE_SIMPLE_DEV_PM_OPS(palmas_pwron_pm,
302 				palmas_pwron_suspend, palmas_pwron_resume);
303 
304 #ifdef CONFIG_OF
305 static const struct of_device_id of_palmas_pwr_match[] = {
306 	{ .compatible = "ti,palmas-pwrbutton" },
307 	{ },
308 };
309 
310 MODULE_DEVICE_TABLE(of, of_palmas_pwr_match);
311 #endif
312 
313 static struct platform_driver palmas_pwron_driver = {
314 	.probe	= palmas_pwron_probe,
315 	.remove	= palmas_pwron_remove,
316 	.driver	= {
317 		.name	= "palmas_pwrbutton",
318 		.of_match_table = of_match_ptr(of_palmas_pwr_match),
319 		.pm	= pm_sleep_ptr(&palmas_pwron_pm),
320 	},
321 };
322 module_platform_driver(palmas_pwron_driver);
323 
324 MODULE_ALIAS("platform:palmas-pwrbutton");
325 MODULE_DESCRIPTION("Palmas Power Button");
326 MODULE_LICENSE("GPL v2");
327 MODULE_AUTHOR("Texas Instruments Inc.");
328