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