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 <[email protected]>
   9  * Author: Jaechul Lee <[email protected]>
  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[2];
  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         error = devm_regulator_bulk_get(&client->dev,
 208                                         ARRAY_SIZE(touchkey->regulators),
 209                                         touchkey->regulators);
 210         if (error) {
 211                 dev_err(&client->dev, "failed to get regulators: %d\n", error);
 212                 return error;
 213         }
 214
 215         /* Save VDD for easy access */
 216         touchkey->vdd = touchkey->regulators[1].consumer;
 217
 218         touchkey->num_keycodes = of_property_read_variable_u32_array(np,
 219                                         "linux,keycodes", touchkey->keycodes, 0,
 220                                         ARRAY_SIZE(touchkey->keycodes));
 221         if (touchkey->num_keycodes <= 0) {
 222                 /* default keycodes */
 223                 touchkey->keycodes[0] = KEY_PHONE;
 224                 touchkey->keycodes[1] = KEY_BACK;
 225                 touchkey->num_keycodes = 2;
 226         }
 227
 228         error = tm2_touchkey_power_enable(touchkey);
 229         if (error) {
 230                 dev_err(&client->dev, "failed to power up device: %d\n", error);
 231                 return error;
 232         }
 233
 234         error = devm_add_action_or_reset(&client->dev,
 235                                          tm2_touchkey_power_disable, touchkey);
 236         if (error) {
 237                 dev_err(&client->dev,
 238                         "failed to install poweroff handler: %d\n", error);
 239                 return error;
 240         }
 241
 242         /* input device */
 243         touchkey->input_dev = devm_input_allocate_device(&client->dev);
 244         if (!touchkey->input_dev) {
 245                 dev_err(&client->dev, "failed to allocate input device\n");
 246                 return -ENOMEM;
 247         }
 248
 249         touchkey->input_dev->name = TM2_TOUCHKEY_DEV_NAME;
 250         touchkey->input_dev->id.bustype = BUS_I2C;
 251
 252         for (i = 0; i < touchkey->num_keycodes; i++)
 253                 input_set_capability(touchkey->input_dev, EV_KEY,
 254                                      touchkey->keycodes[i]);
 255
 256         error = input_register_device(touchkey->input_dev);
 257         if (error) {
 258                 dev_err(&client->dev,
 259                         "failed to register input device: %d\n", error);
 260                 return error;
 261         }
 262
 263         error = devm_request_threaded_irq(&client->dev, client->irq,
 264                                           NULL, tm2_touchkey_irq_handler,
 265                                           IRQF_ONESHOT,
 266                                           TM2_TOUCHKEY_DEV_NAME, touchkey);
 267         if (error) {
 268                 dev_err(&client->dev,
 269                         "failed to request threaded irq: %d\n", error);
 270                 return error;
 271         }
 272
 273         /* led device */
 274         touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME;
 275         touchkey->led_dev.brightness = LED_ON;
 276         touchkey->led_dev.max_brightness = LED_ON;
 277         touchkey->led_dev.brightness_set_blocking =
 278                                         tm2_touchkey_led_brightness_set;
 279
 280         error = devm_led_classdev_register(&client->dev, &touchkey->led_dev);
 281         if (error) {
 282                 dev_err(&client->dev,
 283                         "failed to register touchkey led: %d\n", error);
 284                 return error;
 285         }
 286
 287         if (touchkey->variant->fixed_regulator)
 288                 tm2_touchkey_led_brightness_set(&touchkey->led_dev, LED_ON);
 289
 290         return 0;
 291 }
 292
 293 static int __maybe_unused tm2_touchkey_suspend(struct device *dev)
 294 {
 295         struct i2c_client *client = to_i2c_client(dev);
 296         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 297
 298         disable_irq(client->irq);
 299         tm2_touchkey_power_disable(touchkey);
 300
 301         return 0;
 302 }
 303
 304 static int __maybe_unused tm2_touchkey_resume(struct device *dev)
 305 {
 306         struct i2c_client *client = to_i2c_client(dev);
 307         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 308         int ret;
 309
 310         enable_irq(client->irq);
 311
 312         ret = tm2_touchkey_power_enable(touchkey);
 313         if (ret)
 314                 dev_err(dev, "failed to enable power: %d\n", ret);
 315
 316         return ret;
 317 }
 318
 319 static SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops,
 320                          tm2_touchkey_suspend, tm2_touchkey_resume);
 321
 322 static const struct i2c_device_id tm2_touchkey_id_table[] = {
 323         { TM2_TOUCHKEY_DEV_NAME, 0 },
 324         { },
 325 };
 326 MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table);
 327
 328 static const struct of_device_id tm2_touchkey_of_match[] = {
 329         {
 330                 .compatible = "cypress,tm2-touchkey",
 331                 .data = &tm2_touchkey_variant,
 332         }, {
 333                 .compatible = "cypress,midas-touchkey",
 334                 .data = &midas_touchkey_variant,
 335         }, {
 336                 .compatible = "cypress,aries-touchkey",
 337                 .data = &aries_touchkey_variant,
 338         }, {
 339                 .compatible = "coreriver,tc360-touchkey",
 340                 .data = &tc360_touchkey_variant,
 341         },
 342         { },
 343 };
 344 MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match);
 345
 346 static struct i2c_driver tm2_touchkey_driver = {
 347         .driver = {
 348                 .name = TM2_TOUCHKEY_DEV_NAME,
 349                 .pm = &tm2_touchkey_pm_ops,
 350                 .of_match_table = of_match_ptr(tm2_touchkey_of_match),
 351         },
 352         .probe = tm2_touchkey_probe,
 353         .id_table = tm2_touchkey_id_table,
 354 };
 355 module_i2c_driver(tm2_touchkey_driver);
 356
 357 MODULE_AUTHOR("Beomho Seo <[email protected]>");
 358 MODULE_AUTHOR("Jaechul Lee <[email protected]>");
 359 MODULE_DESCRIPTION("Samsung touchkey driver");
 360 MODULE_LICENSE("GPL v2");