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