drivers/input/keyboard/tm2-touchkey.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * TM2 touchkey device driver
   4  *
   5  * Copyright 2005 Phil Blundell
   6  * Copyright 2016 Samsung Electronics Co., Ltd.
   7  *
   8  * Author: Beomho Seo <beomho.seo@samsung.com>
   9  * Author: Jaechul Lee <jcsing.lee@samsung.com>
  10  */
  11
  12 #include <linux/bitops.h>
  13 #include <linux/delay.h>
  14 #include <linux/device.h>
  15 #include <linux/i2c.h>
  16 #include <linux/input.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/irq.h>
  19 #include <linux/leds.h>
  20 #include <linux/module.h>
  21 #include <linux/of.h>
  22 #include <linux/of_device.h>
  23 #include <linux/pm.h>
  24 #include <linux/regulator/consumer.h>
  25
  26 #define TM2_TOUCHKEY_DEV_NAME           "tm2-touchkey"
  27
  28 #define ARIES_TOUCHKEY_CMD_LED_ON       0x1
  29 #define ARIES_TOUCHKEY_CMD_LED_OFF      0x2
  30 #define TM2_TOUCHKEY_CMD_LED_ON         0x10
  31 #define TM2_TOUCHKEY_CMD_LED_OFF        0x20
  32 #define TM2_TOUCHKEY_BIT_PRESS_EV       BIT(3)
  33 #define TM2_TOUCHKEY_BIT_KEYCODE        GENMASK(2, 0)
  34 #define TM2_TOUCHKEY_LED_VOLTAGE_MIN    2500000
  35 #define TM2_TOUCHKEY_LED_VOLTAGE_MAX    3300000
  36
  37 struct touchkey_variant {
  38         u8 keycode_reg;
  39         u8 base_reg;
  40         u8 cmd_led_on;
  41         u8 cmd_led_off;
  42         bool no_reg;
  43         bool fixed_regulator;
  44 };
  45
  46 struct tm2_touchkey_data {
  47         struct i2c_client *client;
  48         struct input_dev *input_dev;
  49         struct led_classdev led_dev;
  50         struct regulator *vdd;
  51         struct regulator_bulk_data regulators[3];
  52         const struct touchkey_variant *variant;
  53         u32 keycodes[4];
  54         int num_keycodes;
  55 };
  56
  57 static const struct touchkey_variant tm2_touchkey_variant = {
  58         .keycode_reg = 0x03,
  59         .base_reg = 0x00,
  60         .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON,
  61         .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF,
  62 };
  63
  64 static const struct touchkey_variant midas_touchkey_variant = {
  65         .keycode_reg = 0x00,
  66         .base_reg = 0x00,
  67         .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON,
  68         .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF,
  69 };
  70
  71 static struct touchkey_variant aries_touchkey_variant = {
  72         .no_reg = true,
  73         .fixed_regulator = true,
  74         .cmd_led_on = ARIES_TOUCHKEY_CMD_LED_ON,
  75         .cmd_led_off = ARIES_TOUCHKEY_CMD_LED_OFF,
  76 };
  77
  78 static const struct touchkey_variant tc360_touchkey_variant = {
  79         .keycode_reg = 0x00,
  80         .base_reg = 0x00,
  81         .fixed_regulator = true,
  82         .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON,
  83         .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF,
  84 };
  85
  86 static int tm2_touchkey_led_brightness_set(struct led_classdev *led_dev,
  87                                             enum led_brightness brightness)
  88 {
  89         struct tm2_touchkey_data *touchkey =
  90                 container_of(led_dev, struct tm2_touchkey_data, led_dev);
  91         u32 volt;
  92         u8 data;
  93
  94         if (brightness == LED_OFF) {
  95                 volt = TM2_TOUCHKEY_LED_VOLTAGE_MIN;
  96                 data = touchkey->variant->cmd_led_off;
  97         } else {
  98                 volt = TM2_TOUCHKEY_LED_VOLTAGE_MAX;
  99                 data = touchkey->variant->cmd_led_on;
 100         }
 101
 102         if (!touchkey->variant->fixed_regulator)
 103                 regulator_set_voltage(touchkey->vdd, volt, volt);
 104
 105         return touchkey->variant->no_reg ?
 106                 i2c_smbus_write_byte(touchkey->client, data) :
 107                 i2c_smbus_write_byte_data(touchkey->client,
 108                                           touchkey->variant->base_reg, data);
 109 }
 110
 111 static int tm2_touchkey_power_enable(struct tm2_touchkey_data *touchkey)
 112 {
 113         int error;
 114
 115         error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators),
 116                                       touchkey->regulators);
 117         if (error)
 118                 return error;
 119
 120         /* waiting for device initialization, at least 150ms */
 121         msleep(150);
 122
 123         return 0;
 124 }
 125
 126 static void tm2_touchkey_power_disable(void *data)
 127 {
 128         struct tm2_touchkey_data *touchkey = data;
 129
 130         regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators),
 131                                touchkey->regulators);
 132 }
 133
 134 static irqreturn_t tm2_touchkey_irq_handler(int irq, void *devid)
 135 {
 136         struct tm2_touchkey_data *touchkey = devid;
 137         int data;
 138         int index;
 139         int i;
 140
 141         if (touchkey->variant->no_reg)
 142                 data = i2c_smbus_read_byte(touchkey->client);
 143         else
 144                 data = i2c_smbus_read_byte_data(touchkey->client,
 145                                                 touchkey->variant->keycode_reg);
 146         if (data < 0) {
 147                 dev_err(&touchkey->client->dev,
 148                         "failed to read i2c data: %d\n", data);
 149                 goto out;
 150         }
 151
 152         index = (data & TM2_TOUCHKEY_BIT_KEYCODE) - 1;
 153         if (index < 0 || index >= touchkey->num_keycodes) {
 154                 dev_warn(&touchkey->client->dev,
 155                          "invalid keycode index %d\n", index);
 156                 goto out;
 157         }
 158
 159         if (data & TM2_TOUCHKEY_BIT_PRESS_EV) {
 160                 for (i = 0; i < touchkey->num_keycodes; i++)
 161                         input_report_key(touchkey->input_dev,
 162                                          touchkey->keycodes[i], 0);
 163         } else {
 164                 input_report_key(touchkey->input_dev,
 165                                  touchkey->keycodes[index], 1);
 166         }
 167
 168         input_sync(touchkey->input_dev);
 169
 170 out:
 171         if (touchkey->variant->fixed_regulator &&
 172                                 data & TM2_TOUCHKEY_BIT_PRESS_EV) {
 173                 /* touch turns backlight on, so make sure we're in sync */
 174                 if (touchkey->led_dev.brightness == LED_OFF)
 175                         tm2_touchkey_led_brightness_set(&touchkey->led_dev,
 176                                                         LED_OFF);
 177         }
 178
 179         return IRQ_HANDLED;
 180 }
 181
 182 static int tm2_touchkey_probe(struct i2c_client *client,
 183                               const struct i2c_device_id *id)
 184 {
 185         struct device_node *np = client->dev.of_node;
 186         struct tm2_touchkey_data *touchkey;
 187         int error;
 188         int i;
 189
 190         if (!i2c_check_functionality(client->adapter,
 191                         I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA)) {
 192                 dev_err(&client->dev, "incompatible I2C adapter\n");
 193                 return -EIO;
 194         }
 195
 196         touchkey = devm_kzalloc(&client->dev, sizeof(*touchkey), GFP_KERNEL);
 197         if (!touchkey)
 198                 return -ENOMEM;
 199
 200         touchkey->client = client;
 201         i2c_set_clientdata(client, touchkey);
 202
 203         touchkey->variant = of_device_get_match_data(&client->dev);
 204
 205         touchkey->regulators[0].supply = "vcc";
 206         touchkey->regulators[1].supply = "vdd";
 207         touchkey->regulators[2].supply = "vddio";
 208         error = devm_regulator_bulk_get(&client->dev,
 209                                         ARRAY_SIZE(touchkey->regulators),
 210                                         touchkey->regulators);
 211         if (error) {
 212                 dev_err(&client->dev, "failed to get regulators: %d\n", error);
 213                 return error;
 214         }
 215
 216         /* Save VDD for easy access */
 217         touchkey->vdd = touchkey->regulators[1].consumer;
 218
 219         touchkey->num_keycodes = of_property_read_variable_u32_array(np,
 220                                         "linux,keycodes", touchkey->keycodes, 0,
 221                                         ARRAY_SIZE(touchkey->keycodes));
 222         if (touchkey->num_keycodes <= 0) {
 223                 /* default keycodes */
 224                 touchkey->keycodes[0] = KEY_PHONE;
 225                 touchkey->keycodes[1] = KEY_BACK;
 226                 touchkey->num_keycodes = 2;
 227         }
 228
 229         error = tm2_touchkey_power_enable(touchkey);
 230         if (error) {
 231                 dev_err(&client->dev, "failed to power up device: %d\n", error);
 232                 return error;
 233         }
 234
 235         error = devm_add_action_or_reset(&client->dev,
 236                                          tm2_touchkey_power_disable, touchkey);
 237         if (error) {
 238                 dev_err(&client->dev,
 239                         "failed to install poweroff handler: %d\n", error);
 240                 return error;
 241         }
 242
 243         /* input device */
 244         touchkey->input_dev = devm_input_allocate_device(&client->dev);
 245         if (!touchkey->input_dev) {
 246                 dev_err(&client->dev, "failed to allocate input device\n");
 247                 return -ENOMEM;
 248         }
 249
 250         touchkey->input_dev->name = TM2_TOUCHKEY_DEV_NAME;
 251         touchkey->input_dev->id.bustype = BUS_I2C;
 252
 253         for (i = 0; i < touchkey->num_keycodes; i++)
 254                 input_set_capability(touchkey->input_dev, EV_KEY,
 255                                      touchkey->keycodes[i]);
 256
 257         error = input_register_device(touchkey->input_dev);
 258         if (error) {
 259                 dev_err(&client->dev,
 260                         "failed to register input device: %d\n", error);
 261                 return error;
 262         }
 263
 264         error = devm_request_threaded_irq(&client->dev, client->irq,
 265                                           NULL, tm2_touchkey_irq_handler,
 266                                           IRQF_ONESHOT,
 267                                           TM2_TOUCHKEY_DEV_NAME, touchkey);
 268         if (error) {
 269                 dev_err(&client->dev,
 270                         "failed to request threaded irq: %d\n", error);
 271                 return error;
 272         }
 273
 274         /* led device */
 275         touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME;
 276         touchkey->led_dev.brightness = LED_ON;
 277         touchkey->led_dev.max_brightness = LED_ON;
 278         touchkey->led_dev.brightness_set_blocking =
 279                                         tm2_touchkey_led_brightness_set;
 280
 281         error = devm_led_classdev_register(&client->dev, &touchkey->led_dev);
 282         if (error) {
 283                 dev_err(&client->dev,
 284                         "failed to register touchkey led: %d\n", error);
 285                 return error;
 286         }
 287
 288         if (touchkey->variant->fixed_regulator)
 289                 tm2_touchkey_led_brightness_set(&touchkey->led_dev, LED_ON);
 290
 291         return 0;
 292 }
 293
 294 static int __maybe_unused tm2_touchkey_suspend(struct device *dev)
 295 {
 296         struct i2c_client *client = to_i2c_client(dev);
 297         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 298
 299         disable_irq(client->irq);
 300         tm2_touchkey_power_disable(touchkey);
 301
 302         return 0;
 303 }
 304
 305 static int __maybe_unused tm2_touchkey_resume(struct device *dev)
 306 {
 307         struct i2c_client *client = to_i2c_client(dev);
 308         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 309         int ret;
 310
 311         enable_irq(client->irq);
 312
 313         ret = tm2_touchkey_power_enable(touchkey);
 314         if (ret)
 315                 dev_err(dev, "failed to enable power: %d\n", ret);
 316
 317         return ret;
 318 }
 319
 320 static SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops,
 321                          tm2_touchkey_suspend, tm2_touchkey_resume);
 322
 323 static const struct i2c_device_id tm2_touchkey_id_table[] = {
 324         { TM2_TOUCHKEY_DEV_NAME, 0 },
 325         { },
 326 };
 327 MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table);
 328
 329 static const struct of_device_id tm2_touchkey_of_match[] = {
 330         {
 331                 .compatible = "cypress,tm2-touchkey",
 332                 .data = &tm2_touchkey_variant,
 333         }, {
 334                 .compatible = "cypress,midas-touchkey",
 335                 .data = &midas_touchkey_variant,
 336         }, {
 337                 .compatible = "cypress,aries-touchkey",
 338                 .data = &aries_touchkey_variant,
 339         }, {
 340                 .compatible = "coreriver,tc360-touchkey",
 341                 .data = &tc360_touchkey_variant,
 342         },
 343         { },
 344 };
 345 MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match);
 346
 347 static struct i2c_driver tm2_touchkey_driver = {
 348         .driver = {
 349                 .name = TM2_TOUCHKEY_DEV_NAME,
 350                 .pm = &tm2_touchkey_pm_ops,
 351                 .of_match_table = of_match_ptr(tm2_touchkey_of_match),
 352         },
 353         .probe = tm2_touchkey_probe,
 354         .id_table = tm2_touchkey_id_table,
 355 };
 356 module_i2c_driver(tm2_touchkey_driver);
 357
 358 MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
 359 MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>");
 360 MODULE_DESCRIPTION("Samsung touchkey driver");
 361 MODULE_LICENSE("GPL v2");