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         return 0;
 257 }
 258
 259 static int axp20x_pek_probe(struct platform_device *pdev)
 260 {
 261         struct axp20x_pek *axp20x_pek;
 262         int error;
 263
 264         axp20x_pek = devm_kzalloc(&pdev->dev, sizeof(struct axp20x_pek),
 265                                   GFP_KERNEL);
 266         if (!axp20x_pek)
 267                 return -ENOMEM;
 268
 269         axp20x_pek->axp20x = dev_get_drvdata(pdev->dev.parent);
 270
 271         /*
 272          * Do not register the input device if there is an "INTCFD9"
 273          * gpio button ACPI device, that handles the power button too,
 274          * and otherwise we end up reporting all presses twice.
 275          */
 276         if (!acpi_dev_found("INTCFD9") ||
 277             !IS_ENABLED(CONFIG_INPUT_SOC_BUTTON_ARRAY)) {
 278                 error = axp20x_pek_probe_input_device(axp20x_pek, pdev);
 279                 if (error)
 280                         return error;
 281         }
 282
 283         error = sysfs_create_group(&pdev->dev.kobj, &axp20x_attribute_group);
 284         if (error) {
 285                 dev_err(&pdev->dev, "Failed to create sysfs attributes: %d\n",
 286                         error);
 287                 return error;
 288         }
 289
 290         error = devm_add_action(&pdev->dev,
 291                                 axp20x_remove_sysfs_group, &pdev->dev);
 292         if (error) {
 293                 axp20x_remove_sysfs_group(&pdev->dev);
 294                 dev_err(&pdev->dev, "Failed to add sysfs cleanup action: %d\n",
 295                         error);
 296                 return error;
 297         }
 298
 299         platform_set_drvdata(pdev, axp20x_pek);
 300
 301         return 0;
 302 }
 303
 304 static struct platform_driver axp20x_pek_driver = {
 305         .probe          = axp20x_pek_probe,
 306         .driver         = {
 307                 .name           = "axp20x-pek",
 308         },
 309 };
 310 module_platform_driver(axp20x_pek_driver);
 311
 312 MODULE_DESCRIPTION("axp20x Power Button");
 313 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
 314 MODULE_LICENSE("GPL");
 315 MODULE_ALIAS("platform:axp20x-pek");