Merge branch 'next' into for-linus
[muen/linux.git] / drivers / input / misc / axp20x-pek.c
1 /*
2  * axp20x power button driver.
3  *
4  * Copyright (C) 2013 Carlo Caione <carlo@caione.org>
5  *
6  * This file is subject to the terms and conditions of the GNU General
7  * Public License. See the file "COPYING" in the main directory of this
8  * archive for more details.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  */
15
16 #include <linux/acpi.h>
17 #include <linux/errno.h>
18 #include <linux/irq.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/axp20x.h>
24 #include <linux/module.h>
25 #include <linux/platform_device.h>
26 #include <linux/regmap.h>
27 #include <linux/slab.h>
28
29 #define AXP20X_PEK_STARTUP_MASK         (0xc0)
30 #define AXP20X_PEK_SHUTDOWN_MASK        (0x03)
31
32 struct axp20x_pek {
33         struct axp20x_dev *axp20x;
34         struct input_dev *input;
35         int irq_dbr;
36         int irq_dbf;
37 };
38
39 struct axp20x_time {
40         unsigned int time;
41         unsigned int idx;
42 };
43
44 static const struct axp20x_time startup_time[] = {
45         { .time = 128,  .idx = 0 },
46         { .time = 1000, .idx = 2 },
47         { .time = 3000, .idx = 1 },
48         { .time = 2000, .idx = 3 },
49 };
50
51 static const struct axp20x_time shutdown_time[] = {
52         { .time = 4000,  .idx = 0 },
53         { .time = 6000,  .idx = 1 },
54         { .time = 8000,  .idx = 2 },
55         { .time = 10000, .idx = 3 },
56 };
57
58 struct axp20x_pek_ext_attr {
59         const struct axp20x_time *p_time;
60         unsigned int mask;
61 };
62
63 static struct axp20x_pek_ext_attr axp20x_pek_startup_ext_attr = {
64         .p_time = startup_time,
65         .mask   = AXP20X_PEK_STARTUP_MASK,
66 };
67
68 static struct axp20x_pek_ext_attr axp20x_pek_shutdown_ext_attr = {
69         .p_time = shutdown_time,
70         .mask   = AXP20X_PEK_SHUTDOWN_MASK,
71 };
72
73 static struct axp20x_pek_ext_attr *get_axp_ext_attr(struct device_attribute *attr)
74 {
75         return container_of(attr, struct dev_ext_attribute, attr)->var;
76 }
77
78 static ssize_t axp20x_show_ext_attr(struct device *dev,
79                                     struct device_attribute *attr, char *buf)
80 {
81         struct axp20x_pek *axp20x_pek = dev_get_drvdata(dev);
82         struct axp20x_pek_ext_attr *axp20x_ea = get_axp_ext_attr(attr);
83         unsigned int val;
84         int ret, i;
85
86         ret = regmap_read(axp20x_pek->axp20x->regmap, AXP20X_PEK_KEY, &val);
87         if (ret != 0)
88                 return ret;
89
90         val &= axp20x_ea->mask;
91         val >>= ffs(axp20x_ea->mask) - 1;
92
93         for (i = 0; i < 4; i++)
94                 if (val == axp20x_ea->p_time[i].idx)
95                         val = axp20x_ea->p_time[i].time;
96
97         return sprintf(buf, "%u\n", val);
98 }
99
100 static ssize_t axp20x_store_ext_attr(struct device *dev,
101                                      struct device_attribute *attr,
102                                      const char *buf, size_t count)
103 {
104         struct axp20x_pek *axp20x_pek = dev_get_drvdata(dev);
105         struct axp20x_pek_ext_attr *axp20x_ea = get_axp_ext_attr(attr);
106         char val_str[20];
107         size_t len;
108         int ret, i;
109         unsigned int val, idx = 0;
110         unsigned int best_err = UINT_MAX;
111
112         val_str[sizeof(val_str) - 1] = '\0';
113         strncpy(val_str, buf, sizeof(val_str) - 1);
114         len = strlen(val_str);
115
116         if (len && val_str[len - 1] == '\n')
117                 val_str[len - 1] = '\0';
118
119         ret = kstrtouint(val_str, 10, &val);
120         if (ret)
121                 return ret;
122
123         for (i = 3; i >= 0; i--) {
124                 unsigned int err;
125
126                 err = abs(axp20x_ea->p_time[i].time - val);
127                 if (err < best_err) {
128                         best_err = err;
129                         idx = axp20x_ea->p_time[i].idx;
130                 }
131
132                 if (!err)
133                         break;
134         }
135
136         idx <<= ffs(axp20x_ea->mask) - 1;
137         ret = regmap_update_bits(axp20x_pek->axp20x->regmap,
138                                  AXP20X_PEK_KEY,
139                                  axp20x_ea->mask, idx);
140         if (ret != 0)
141                 return -EINVAL;
142
143         return count;
144 }
145
146 static struct dev_ext_attribute axp20x_dev_attr_startup = {
147         .attr   = __ATTR(startup, 0644, axp20x_show_ext_attr, axp20x_store_ext_attr),
148         .var    = &axp20x_pek_startup_ext_attr,
149 };
150
151 static struct dev_ext_attribute axp20x_dev_attr_shutdown = {
152         .attr   = __ATTR(shutdown, 0644, axp20x_show_ext_attr, axp20x_store_ext_attr),
153         .var    = &axp20x_pek_shutdown_ext_attr,
154 };
155
156 static struct attribute *axp20x_attributes[] = {
157         &axp20x_dev_attr_startup.attr.attr,
158         &axp20x_dev_attr_shutdown.attr.attr,
159         NULL,
160 };
161
162 static const struct attribute_group axp20x_attribute_group = {
163         .attrs = axp20x_attributes,
164 };
165
166 static irqreturn_t axp20x_pek_irq(int irq, void *pwr)
167 {
168         struct input_dev *idev = pwr;
169         struct axp20x_pek *axp20x_pek = input_get_drvdata(idev);
170
171         /*
172          * The power-button is connected to ground so a falling edge (dbf)
173          * means it is pressed.
174          */
175         if (irq == axp20x_pek->irq_dbf)
176                 input_report_key(idev, KEY_POWER, true);
177         else if (irq == axp20x_pek->irq_dbr)
178                 input_report_key(idev, KEY_POWER, false);
179
180         input_sync(idev);
181
182         return IRQ_HANDLED;
183 }
184
185 static void axp20x_remove_sysfs_group(void *_data)
186 {
187         struct device *dev = _data;
188
189         sysfs_remove_group(&dev->kobj, &axp20x_attribute_group);
190 }
191
192 static int axp20x_pek_probe_input_device(struct axp20x_pek *axp20x_pek,
193                                          struct platform_device *pdev)
194 {
195         struct axp20x_dev *axp20x = axp20x_pek->axp20x;
196         struct input_dev *idev;
197         int error;
198
199         axp20x_pek->irq_dbr = platform_get_irq_byname(pdev, "PEK_DBR");
200         if (axp20x_pek->irq_dbr < 0) {
201                 dev_err(&pdev->dev, "No IRQ for PEK_DBR, error=%d\n",
202                                 axp20x_pek->irq_dbr);
203                 return axp20x_pek->irq_dbr;
204         }
205         axp20x_pek->irq_dbr = regmap_irq_get_virq(axp20x->regmap_irqc,
206                                                   axp20x_pek->irq_dbr);
207
208         axp20x_pek->irq_dbf = platform_get_irq_byname(pdev, "PEK_DBF");
209         if (axp20x_pek->irq_dbf < 0) {
210                 dev_err(&pdev->dev, "No IRQ for PEK_DBF, error=%d\n",
211                                 axp20x_pek->irq_dbf);
212                 return axp20x_pek->irq_dbf;
213         }
214         axp20x_pek->irq_dbf = regmap_irq_get_virq(axp20x->regmap_irqc,
215                                                   axp20x_pek->irq_dbf);
216
217         axp20x_pek->input = devm_input_allocate_device(&pdev->dev);
218         if (!axp20x_pek->input)
219                 return -ENOMEM;
220
221         idev = axp20x_pek->input;
222
223         idev->name = "axp20x-pek";
224         idev->phys = "m1kbd/input2";
225         idev->dev.parent = &pdev->dev;
226
227         input_set_capability(idev, EV_KEY, KEY_POWER);
228
229         input_set_drvdata(idev, axp20x_pek);
230
231         error = devm_request_any_context_irq(&pdev->dev, axp20x_pek->irq_dbr,
232                                              axp20x_pek_irq, 0,
233                                              "axp20x-pek-dbr", idev);
234         if (error < 0) {
235                 dev_err(&pdev->dev, "Failed to request dbr IRQ#%d: %d\n",
236                         axp20x_pek->irq_dbr, error);
237                 return error;
238         }
239
240         error = devm_request_any_context_irq(&pdev->dev, axp20x_pek->irq_dbf,
241                                           axp20x_pek_irq, 0,
242                                           "axp20x-pek-dbf", idev);
243         if (error < 0) {
244                 dev_err(&pdev->dev, "Failed to request dbf IRQ#%d: %d\n",
245                         axp20x_pek->irq_dbf, error);
246                 return error;
247         }
248
249         error = input_register_device(idev);
250         if (error) {
251                 dev_err(&pdev->dev, "Can't register input device: %d\n",
252                         error);
253                 return error;
254         }
255
256         if (axp20x_pek->axp20x->variant == AXP288_ID)
257                 enable_irq_wake(axp20x_pek->irq_dbr);
258
259         return 0;
260 }
261
262 #ifdef CONFIG_ACPI
263 static bool axp20x_pek_should_register_input(struct axp20x_pek *axp20x_pek,
264                                              struct platform_device *pdev)
265 {
266         unsigned long long hrv = 0;
267         acpi_status status;
268
269         if (IS_ENABLED(CONFIG_INPUT_SOC_BUTTON_ARRAY) &&
270             axp20x_pek->axp20x->variant == AXP288_ID) {
271                 status = acpi_evaluate_integer(ACPI_HANDLE(pdev->dev.parent),
272                                                "_HRV", NULL, &hrv);
273                 if (ACPI_FAILURE(status))
274                         dev_err(&pdev->dev, "Failed to get PMIC hardware revision\n");
275
276                 /*
277                  * On Cherry Trail platforms (hrv == 3), do not register the
278                  * input device if there is an "INTCFD9" or "ACPI0011" gpio
279                  * button ACPI device, as that handles the power button too,
280                  * and otherwise we end up reporting all presses twice.
281                  */
282                 if (hrv == 3 && (acpi_dev_present("INTCFD9", NULL, -1) ||
283                                  acpi_dev_present("ACPI0011", NULL, -1)))
284                         return false;
285
286         }
287
288         return true;
289 }
290 #else
291 static bool axp20x_pek_should_register_input(struct axp20x_pek *axp20x_pek,
292                                              struct platform_device *pdev)
293 {
294         return true;
295 }
296 #endif
297
298 static int axp20x_pek_probe(struct platform_device *pdev)
299 {
300         struct axp20x_pek *axp20x_pek;
301         int error;
302
303         axp20x_pek = devm_kzalloc(&pdev->dev, sizeof(struct axp20x_pek),
304                                   GFP_KERNEL);
305         if (!axp20x_pek)
306                 return -ENOMEM;
307
308         axp20x_pek->axp20x = dev_get_drvdata(pdev->dev.parent);
309
310         if (axp20x_pek_should_register_input(axp20x_pek, pdev)) {
311                 error = axp20x_pek_probe_input_device(axp20x_pek, pdev);
312                 if (error)
313                         return error;
314         }
315
316         error = sysfs_create_group(&pdev->dev.kobj, &axp20x_attribute_group);
317         if (error) {
318                 dev_err(&pdev->dev, "Failed to create sysfs attributes: %d\n",
319                         error);
320                 return error;
321         }
322
323         error = devm_add_action(&pdev->dev,
324                                 axp20x_remove_sysfs_group, &pdev->dev);
325         if (error) {
326                 axp20x_remove_sysfs_group(&pdev->dev);
327                 dev_err(&pdev->dev, "Failed to add sysfs cleanup action: %d\n",
328                         error);
329                 return error;
330         }
331
332         platform_set_drvdata(pdev, axp20x_pek);
333
334         return 0;
335 }
336
337 static int __maybe_unused axp20x_pek_resume_noirq(struct device *dev)
338 {
339         struct axp20x_pek *axp20x_pek = dev_get_drvdata(dev);
340
341         if (axp20x_pek->axp20x->variant != AXP288_ID)
342                 return 0;
343
344         /*
345          * Clear interrupts from button presses during suspend, to avoid
346          * a wakeup power-button press getting reported to userspace.
347          */
348         regmap_write(axp20x_pek->axp20x->regmap,
349                      AXP20X_IRQ1_STATE + AXP288_IRQ_POKN / 8,
350                      BIT(AXP288_IRQ_POKN % 8));
351
352         return 0;
353 }
354
355 static const struct dev_pm_ops axp20x_pek_pm_ops = {
356 #ifdef CONFIG_PM_SLEEP
357         .resume_noirq = axp20x_pek_resume_noirq,
358 #endif
359 };
360
361 static struct platform_driver axp20x_pek_driver = {
362         .probe          = axp20x_pek_probe,
363         .driver         = {
364                 .name           = "axp20x-pek",
365                 .pm             = &axp20x_pek_pm_ops,
366         },
367 };
368 module_platform_driver(axp20x_pek_driver);
369
370 MODULE_DESCRIPTION("axp20x Power Button");
371 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
372 MODULE_LICENSE("GPL");
373 MODULE_ALIAS("platform:axp20x-pek");