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         input_event(touchkey->input_dev, EV_MSC, MSC_SCAN, index);
 160
 161         if (data & TM2_TOUCHKEY_BIT_PRESS_EV) {
 162                 for (i = 0; i < touchkey->num_keycodes; i++)
 163                         input_report_key(touchkey->input_dev,
 164                                          touchkey->keycodes[i], 0);
 165         } else {
 166                 input_report_key(touchkey->input_dev,
 167                                  touchkey->keycodes[index], 1);
 168         }
 169
 170         input_sync(touchkey->input_dev);
 171
 172 out:
 173         if (touchkey->variant->fixed_regulator &&
 174                                 data & TM2_TOUCHKEY_BIT_PRESS_EV) {
 175                 /* touch turns backlight on, so make sure we're in sync */
 176                 if (touchkey->led_dev.brightness == LED_OFF)
 177                         tm2_touchkey_led_brightness_set(&touchkey->led_dev,
 178                                                         LED_OFF);
 179         }
 180
 181         return IRQ_HANDLED;
 182 }
 183
 184 static int tm2_touchkey_probe(struct i2c_client *client,
 185                               const struct i2c_device_id *id)
 186 {
 187         struct device_node *np = client->dev.of_node;
 188         struct tm2_touchkey_data *touchkey;
 189         int error;
 190         int i;
 191
 192         if (!i2c_check_functionality(client->adapter,
 193                         I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA)) {
 194                 dev_err(&client->dev, "incompatible I2C adapter\n");
 195                 return -EIO;
 196         }
 197
 198         touchkey = devm_kzalloc(&client->dev, sizeof(*touchkey), GFP_KERNEL);
 199         if (!touchkey)
 200                 return -ENOMEM;
 201
 202         touchkey->client = client;
 203         i2c_set_clientdata(client, touchkey);
 204
 205         touchkey->variant = of_device_get_match_data(&client->dev);
 206
 207         touchkey->regulators[0].supply = "vcc";
 208         touchkey->regulators[1].supply = "vdd";
 209         touchkey->regulators[2].supply = "vddio";
 210         error = devm_regulator_bulk_get(&client->dev,
 211                                         ARRAY_SIZE(touchkey->regulators),
 212                                         touchkey->regulators);
 213         if (error) {
 214                 dev_err(&client->dev, "failed to get regulators: %d\n", error);
 215                 return error;
 216         }
 217
 218         /* Save VDD for easy access */
 219         touchkey->vdd = touchkey->regulators[1].consumer;
 220
 221         touchkey->num_keycodes = of_property_read_variable_u32_array(np,
 222                                         "linux,keycodes", touchkey->keycodes, 0,
 223                                         ARRAY_SIZE(touchkey->keycodes));
 224         if (touchkey->num_keycodes <= 0) {
 225                 /* default keycodes */
 226                 touchkey->keycodes[0] = KEY_PHONE;
 227                 touchkey->keycodes[1] = KEY_BACK;
 228                 touchkey->num_keycodes = 2;
 229         }
 230
 231         error = tm2_touchkey_power_enable(touchkey);
 232         if (error) {
 233                 dev_err(&client->dev, "failed to power up device: %d\n", error);
 234                 return error;
 235         }
 236
 237         error = devm_add_action_or_reset(&client->dev,
 238                                          tm2_touchkey_power_disable, touchkey);
 239         if (error) {
 240                 dev_err(&client->dev,
 241                         "failed to install poweroff handler: %d\n", error);
 242                 return error;
 243         }
 244
 245         /* input device */
 246         touchkey->input_dev = devm_input_allocate_device(&client->dev);
 247         if (!touchkey->input_dev) {
 248                 dev_err(&client->dev, "failed to allocate input device\n");
 249                 return -ENOMEM;
 250         }
 251
 252         touchkey->input_dev->name = TM2_TOUCHKEY_DEV_NAME;
 253         touchkey->input_dev->id.bustype = BUS_I2C;
 254
 255         touchkey->input_dev->keycode = touchkey->keycodes;
 256         touchkey->input_dev->keycodemax = touchkey->num_keycodes;
 257         touchkey->input_dev->keycodesize = sizeof(touchkey->keycodes[0]);
 258
 259         input_set_capability(touchkey->input_dev, EV_MSC, MSC_SCAN);
 260         for (i = 0; i < touchkey->num_keycodes; i++)
 261                 input_set_capability(touchkey->input_dev, EV_KEY,
 262                                      touchkey->keycodes[i]);
 263
 264         error = input_register_device(touchkey->input_dev);
 265         if (error) {
 266                 dev_err(&client->dev,
 267                         "failed to register input device: %d\n", error);
 268                 return error;
 269         }
 270
 271         error = devm_request_threaded_irq(&client->dev, client->irq,
 272                                           NULL, tm2_touchkey_irq_handler,
 273                                           IRQF_ONESHOT,
 274                                           TM2_TOUCHKEY_DEV_NAME, touchkey);
 275         if (error) {
 276                 dev_err(&client->dev,
 277                         "failed to request threaded irq: %d\n", error);
 278                 return error;
 279         }
 280
 281         /* led device */
 282         touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME;
 283         touchkey->led_dev.brightness = LED_ON;
 284         touchkey->led_dev.max_brightness = LED_ON;
 285         touchkey->led_dev.brightness_set_blocking =
 286                                         tm2_touchkey_led_brightness_set;
 287
 288         error = devm_led_classdev_register(&client->dev, &touchkey->led_dev);
 289         if (error) {
 290                 dev_err(&client->dev,
 291                         "failed to register touchkey led: %d\n", error);
 292                 return error;
 293         }
 294
 295         if (touchkey->variant->fixed_regulator)
 296                 tm2_touchkey_led_brightness_set(&touchkey->led_dev, LED_ON);
 297
 298         return 0;
 299 }
 300
 301 static int __maybe_unused tm2_touchkey_suspend(struct device *dev)
 302 {
 303         struct i2c_client *client = to_i2c_client(dev);
 304         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 305
 306         disable_irq(client->irq);
 307         tm2_touchkey_power_disable(touchkey);
 308
 309         return 0;
 310 }
 311
 312 static int __maybe_unused tm2_touchkey_resume(struct device *dev)
 313 {
 314         struct i2c_client *client = to_i2c_client(dev);
 315         struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
 316         int ret;
 317
 318         enable_irq(client->irq);
 319
 320         ret = tm2_touchkey_power_enable(touchkey);
 321         if (ret)
 322                 dev_err(dev, "failed to enable power: %d\n", ret);
 323
 324         return ret;
 325 }
 326
 327 static SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops,
 328                          tm2_touchkey_suspend, tm2_touchkey_resume);
 329
 330 static const struct i2c_device_id tm2_touchkey_id_table[] = {
 331         { TM2_TOUCHKEY_DEV_NAME, 0 },
 332         { },
 333 };
 334 MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table);
 335
 336 static const struct of_device_id tm2_touchkey_of_match[] = {
 337         {
 338                 .compatible = "cypress,tm2-touchkey",
 339                 .data = &tm2_touchkey_variant,
 340         }, {
 341                 .compatible = "cypress,midas-touchkey",
 342                 .data = &midas_touchkey_variant,
 343         }, {
 344                 .compatible = "cypress,aries-touchkey",
 345                 .data = &aries_touchkey_variant,
 346         }, {
 347                 .compatible = "coreriver,tc360-touchkey",
 348                 .data = &tc360_touchkey_variant,
 349         },
 350         { },
 351 };
 352 MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match);
 353
 354 static struct i2c_driver tm2_touchkey_driver = {
 355         .driver = {
 356                 .name = TM2_TOUCHKEY_DEV_NAME,
 357                 .pm = &tm2_touchkey_pm_ops,
 358                 .of_match_table = of_match_ptr(tm2_touchkey_of_match),
 359         },
 360         .probe = tm2_touchkey_probe,
 361         .id_table = tm2_touchkey_id_table,
 362 };
 363 module_i2c_driver(tm2_touchkey_driver);
 364
 365 MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
 366 MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>");
 367 MODULE_DESCRIPTION("Samsung touchkey driver");
 368 MODULE_LICENSE("GPL v2");