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/pm.h> 23 #include <linux/regulator/consumer.h> 24 25 #define TM2_TOUCHKEY_DEV_NAME "tm2-touchkey" 26 27 #define ARIES_TOUCHKEY_CMD_LED_ON 0x1 28 #define ARIES_TOUCHKEY_CMD_LED_OFF 0x2 29 #define TM2_TOUCHKEY_CMD_LED_ON 0x10 30 #define TM2_TOUCHKEY_CMD_LED_OFF 0x20 31 #define TM2_TOUCHKEY_BIT_PRESS_EV BIT(3) 32 #define TM2_TOUCHKEY_BIT_KEYCODE GENMASK(2, 0) 33 #define TM2_TOUCHKEY_LED_VOLTAGE_MIN 2500000 34 #define TM2_TOUCHKEY_LED_VOLTAGE_MAX 3300000 35 36 struct touchkey_variant { 37 u8 keycode_reg; 38 u8 base_reg; 39 u8 cmd_led_on; 40 u8 cmd_led_off; 41 bool no_reg; 42 bool fixed_regulator; 43 }; 44 45 struct tm2_touchkey_data { 46 struct i2c_client *client; 47 struct input_dev *input_dev; 48 struct led_classdev led_dev; 49 struct regulator *vdd; 50 struct regulator_bulk_data regulators[3]; 51 const struct touchkey_variant *variant; 52 u32 keycodes[4]; 53 int num_keycodes; 54 }; 55 56 static const struct touchkey_variant tm2_touchkey_variant = { 57 .keycode_reg = 0x03, 58 .base_reg = 0x00, 59 .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON, 60 .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF, 61 }; 62 63 static const struct touchkey_variant midas_touchkey_variant = { 64 .keycode_reg = 0x00, 65 .base_reg = 0x00, 66 .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON, 67 .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF, 68 }; 69 70 static struct touchkey_variant aries_touchkey_variant = { 71 .no_reg = true, 72 .fixed_regulator = true, 73 .cmd_led_on = ARIES_TOUCHKEY_CMD_LED_ON, 74 .cmd_led_off = ARIES_TOUCHKEY_CMD_LED_OFF, 75 }; 76 77 static const struct touchkey_variant tc360_touchkey_variant = { 78 .keycode_reg = 0x00, 79 .base_reg = 0x00, 80 .fixed_regulator = true, 81 .cmd_led_on = TM2_TOUCHKEY_CMD_LED_ON, 82 .cmd_led_off = TM2_TOUCHKEY_CMD_LED_OFF, 83 }; 84 85 static int tm2_touchkey_led_brightness_set(struct led_classdev *led_dev, 86 enum led_brightness brightness) 87 { 88 struct tm2_touchkey_data *touchkey = 89 container_of(led_dev, struct tm2_touchkey_data, led_dev); 90 u32 volt; 91 u8 data; 92 93 if (brightness == LED_OFF) { 94 volt = TM2_TOUCHKEY_LED_VOLTAGE_MIN; 95 data = touchkey->variant->cmd_led_off; 96 } else { 97 volt = TM2_TOUCHKEY_LED_VOLTAGE_MAX; 98 data = touchkey->variant->cmd_led_on; 99 } 100 101 if (!touchkey->variant->fixed_regulator) 102 regulator_set_voltage(touchkey->vdd, volt, volt); 103 104 return touchkey->variant->no_reg ? 105 i2c_smbus_write_byte(touchkey->client, data) : 106 i2c_smbus_write_byte_data(touchkey->client, 107 touchkey->variant->base_reg, data); 108 } 109 110 static int tm2_touchkey_power_enable(struct tm2_touchkey_data *touchkey) 111 { 112 int error; 113 114 error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators), 115 touchkey->regulators); 116 if (error) 117 return error; 118 119 /* waiting for device initialization, at least 150ms */ 120 msleep(150); 121 122 return 0; 123 } 124 125 static void tm2_touchkey_power_disable(void *data) 126 { 127 struct tm2_touchkey_data *touchkey = data; 128 129 regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators), 130 touchkey->regulators); 131 } 132 133 static irqreturn_t tm2_touchkey_irq_handler(int irq, void *devid) 134 { 135 struct tm2_touchkey_data *touchkey = devid; 136 int data; 137 int index; 138 int i; 139 140 if (touchkey->variant->no_reg) 141 data = i2c_smbus_read_byte(touchkey->client); 142 else 143 data = i2c_smbus_read_byte_data(touchkey->client, 144 touchkey->variant->keycode_reg); 145 if (data < 0) { 146 dev_err(&touchkey->client->dev, 147 "failed to read i2c data: %d\n", data); 148 goto out; 149 } 150 151 index = (data & TM2_TOUCHKEY_BIT_KEYCODE) - 1; 152 if (index < 0 || index >= touchkey->num_keycodes) { 153 dev_warn(&touchkey->client->dev, 154 "invalid keycode index %d\n", index); 155 goto out; 156 } 157 158 input_event(touchkey->input_dev, EV_MSC, MSC_SCAN, index); 159 160 if (data & TM2_TOUCHKEY_BIT_PRESS_EV) { 161 for (i = 0; i < touchkey->num_keycodes; i++) 162 input_report_key(touchkey->input_dev, 163 touchkey->keycodes[i], 0); 164 } else { 165 input_report_key(touchkey->input_dev, 166 touchkey->keycodes[index], 1); 167 } 168 169 input_sync(touchkey->input_dev); 170 171 out: 172 if (touchkey->variant->fixed_regulator && 173 data & TM2_TOUCHKEY_BIT_PRESS_EV) { 174 /* touch turns backlight on, so make sure we're in sync */ 175 if (touchkey->led_dev.brightness == LED_OFF) 176 tm2_touchkey_led_brightness_set(&touchkey->led_dev, 177 LED_OFF); 178 } 179 180 return IRQ_HANDLED; 181 } 182 183 static int tm2_touchkey_probe(struct i2c_client *client) 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 touchkey->input_dev->keycode = touchkey->keycodes; 254 touchkey->input_dev->keycodemax = touchkey->num_keycodes; 255 touchkey->input_dev->keycodesize = sizeof(touchkey->keycodes[0]); 256 257 input_set_capability(touchkey->input_dev, EV_MSC, MSC_SCAN); 258 for (i = 0; i < touchkey->num_keycodes; i++) 259 input_set_capability(touchkey->input_dev, EV_KEY, 260 touchkey->keycodes[i]); 261 262 error = input_register_device(touchkey->input_dev); 263 if (error) { 264 dev_err(&client->dev, 265 "failed to register input device: %d\n", error); 266 return error; 267 } 268 269 error = devm_request_threaded_irq(&client->dev, client->irq, 270 NULL, tm2_touchkey_irq_handler, 271 IRQF_ONESHOT, 272 TM2_TOUCHKEY_DEV_NAME, touchkey); 273 if (error) { 274 dev_err(&client->dev, 275 "failed to request threaded irq: %d\n", error); 276 return error; 277 } 278 279 /* led device */ 280 touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME; 281 touchkey->led_dev.brightness = LED_ON; 282 touchkey->led_dev.max_brightness = LED_ON; 283 touchkey->led_dev.brightness_set_blocking = 284 tm2_touchkey_led_brightness_set; 285 286 error = devm_led_classdev_register(&client->dev, &touchkey->led_dev); 287 if (error) { 288 dev_err(&client->dev, 289 "failed to register touchkey led: %d\n", error); 290 return error; 291 } 292 293 if (touchkey->variant->fixed_regulator) 294 tm2_touchkey_led_brightness_set(&touchkey->led_dev, LED_ON); 295 296 return 0; 297 } 298 299 static int tm2_touchkey_suspend(struct device *dev) 300 { 301 struct i2c_client *client = to_i2c_client(dev); 302 struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client); 303 304 disable_irq(client->irq); 305 tm2_touchkey_power_disable(touchkey); 306 307 return 0; 308 } 309 310 static int tm2_touchkey_resume(struct device *dev) 311 { 312 struct i2c_client *client = to_i2c_client(dev); 313 struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client); 314 int ret; 315 316 enable_irq(client->irq); 317 318 ret = tm2_touchkey_power_enable(touchkey); 319 if (ret) 320 dev_err(dev, "failed to enable power: %d\n", ret); 321 322 return ret; 323 } 324 325 static DEFINE_SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops, 326 tm2_touchkey_suspend, tm2_touchkey_resume); 327 328 static const struct i2c_device_id tm2_touchkey_id_table[] = { 329 { TM2_TOUCHKEY_DEV_NAME, 0 }, 330 { }, 331 }; 332 MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table); 333 334 static const struct of_device_id tm2_touchkey_of_match[] = { 335 { 336 .compatible = "cypress,tm2-touchkey", 337 .data = &tm2_touchkey_variant, 338 }, { 339 .compatible = "cypress,midas-touchkey", 340 .data = &midas_touchkey_variant, 341 }, { 342 .compatible = "cypress,aries-touchkey", 343 .data = &aries_touchkey_variant, 344 }, { 345 .compatible = "coreriver,tc360-touchkey", 346 .data = &tc360_touchkey_variant, 347 }, 348 { }, 349 }; 350 MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match); 351 352 static struct i2c_driver tm2_touchkey_driver = { 353 .driver = { 354 .name = TM2_TOUCHKEY_DEV_NAME, 355 .pm = pm_sleep_ptr(&tm2_touchkey_pm_ops), 356 .of_match_table = tm2_touchkey_of_match, 357 }, 358 .probe = tm2_touchkey_probe, 359 .id_table = tm2_touchkey_id_table, 360 }; 361 module_i2c_driver(tm2_touchkey_driver); 362 363 MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>"); 364 MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>"); 365 MODULE_DESCRIPTION("Samsung touchkey driver"); 366 MODULE_LICENSE("GPL v2"); 367