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[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 <beomho.seo@samsung.com>"); 358 MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>"); 359 MODULE_DESCRIPTION("Samsung touchkey driver"); 360 MODULE_LICENSE("GPL v2"); 361