1 /* 2 * Touchkey driver for Freescale MPR121 Controllor 3 * 4 * Copyright (C) 2011 Freescale Semiconductor, Inc. 5 * Author: Zhang Jiejing <jiejing.zhang@freescale.com> 6 * 7 * Based on mcs_touchkey.c 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 */ 14 15 #include <linux/bitops.h> 16 #include <linux/delay.h> 17 #include <linux/i2c.h> 18 #include <linux/input.h> 19 #include <linux/interrupt.h> 20 #include <linux/module.h> 21 #include <linux/of.h> 22 #include <linux/property.h> 23 #include <linux/regulator/consumer.h> 24 #include <linux/slab.h> 25 26 /* Register definitions */ 27 #define ELE_TOUCH_STATUS_0_ADDR 0x0 28 #define ELE_TOUCH_STATUS_1_ADDR 0X1 29 #define MHD_RISING_ADDR 0x2b 30 #define NHD_RISING_ADDR 0x2c 31 #define NCL_RISING_ADDR 0x2d 32 #define FDL_RISING_ADDR 0x2e 33 #define MHD_FALLING_ADDR 0x2f 34 #define NHD_FALLING_ADDR 0x30 35 #define NCL_FALLING_ADDR 0x31 36 #define FDL_FALLING_ADDR 0x32 37 #define ELE0_TOUCH_THRESHOLD_ADDR 0x41 38 #define ELE0_RELEASE_THRESHOLD_ADDR 0x42 39 #define AFE_CONF_ADDR 0x5c 40 #define FILTER_CONF_ADDR 0x5d 41 42 /* 43 * ELECTRODE_CONF_ADDR: This register configures the number of 44 * enabled capacitance sensing inputs and its run/suspend mode. 45 */ 46 #define ELECTRODE_CONF_ADDR 0x5e 47 #define ELECTRODE_CONF_QUICK_CHARGE 0x80 48 #define AUTO_CONFIG_CTRL_ADDR 0x7b 49 #define AUTO_CONFIG_USL_ADDR 0x7d 50 #define AUTO_CONFIG_LSL_ADDR 0x7e 51 #define AUTO_CONFIG_TL_ADDR 0x7f 52 53 /* Threshold of touch/release trigger */ 54 #define TOUCH_THRESHOLD 0x08 55 #define RELEASE_THRESHOLD 0x05 56 /* Masks for touch and release triggers */ 57 #define TOUCH_STATUS_MASK 0xfff 58 /* MPR121 has 12 keys */ 59 #define MPR121_MAX_KEY_COUNT 12 60 61 struct mpr121_touchkey { 62 struct i2c_client *client; 63 struct input_dev *input_dev; 64 unsigned int statusbits; 65 unsigned int keycount; 66 u32 keycodes[MPR121_MAX_KEY_COUNT]; 67 }; 68 69 struct mpr121_init_register { 70 int addr; 71 u8 val; 72 }; 73 74 static const struct mpr121_init_register init_reg_table[] = { 75 { MHD_RISING_ADDR, 0x1 }, 76 { NHD_RISING_ADDR, 0x1 }, 77 { MHD_FALLING_ADDR, 0x1 }, 78 { NHD_FALLING_ADDR, 0x1 }, 79 { NCL_FALLING_ADDR, 0xff }, 80 { FDL_FALLING_ADDR, 0x02 }, 81 { FILTER_CONF_ADDR, 0x04 }, 82 { AFE_CONF_ADDR, 0x0b }, 83 { AUTO_CONFIG_CTRL_ADDR, 0x0b }, 84 }; 85 86 static void mpr121_vdd_supply_disable(void *data) 87 { 88 struct regulator *vdd_supply = data; 89 90 regulator_disable(vdd_supply); 91 } 92 93 static struct regulator *mpr121_vdd_supply_init(struct device *dev) 94 { 95 struct regulator *vdd_supply; 96 int err; 97 98 vdd_supply = devm_regulator_get(dev, "vdd"); 99 if (IS_ERR(vdd_supply)) { 100 dev_err(dev, "failed to get vdd regulator: %ld\n", 101 PTR_ERR(vdd_supply)); 102 return vdd_supply; 103 } 104 105 err = regulator_enable(vdd_supply); 106 if (err) { 107 dev_err(dev, "failed to enable vdd regulator: %d\n", err); 108 return ERR_PTR(err); 109 } 110 111 err = devm_add_action(dev, mpr121_vdd_supply_disable, vdd_supply); 112 if (err) { 113 regulator_disable(vdd_supply); 114 dev_err(dev, "failed to add disable regulator action: %d\n", 115 err); 116 return ERR_PTR(err); 117 } 118 119 return vdd_supply; 120 } 121 122 static irqreturn_t mpr_touchkey_interrupt(int irq, void *dev_id) 123 { 124 struct mpr121_touchkey *mpr121 = dev_id; 125 struct i2c_client *client = mpr121->client; 126 struct input_dev *input = mpr121->input_dev; 127 unsigned long bit_changed; 128 unsigned int key_num; 129 int reg; 130 131 reg = i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_1_ADDR); 132 if (reg < 0) { 133 dev_err(&client->dev, "i2c read error [%d]\n", reg); 134 goto out; 135 } 136 137 reg <<= 8; 138 reg |= i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_0_ADDR); 139 if (reg < 0) { 140 dev_err(&client->dev, "i2c read error [%d]\n", reg); 141 goto out; 142 } 143 144 reg &= TOUCH_STATUS_MASK; 145 /* use old press bit to figure out which bit changed */ 146 bit_changed = reg ^ mpr121->statusbits; 147 mpr121->statusbits = reg; 148 for_each_set_bit(key_num, &bit_changed, mpr121->keycount) { 149 unsigned int key_val, pressed; 150 151 pressed = reg & BIT(key_num); 152 key_val = mpr121->keycodes[key_num]; 153 154 input_event(input, EV_MSC, MSC_SCAN, key_num); 155 input_report_key(input, key_val, pressed); 156 157 dev_dbg(&client->dev, "key %d %d %s\n", key_num, key_val, 158 pressed ? "pressed" : "released"); 159 160 } 161 input_sync(input); 162 163 out: 164 return IRQ_HANDLED; 165 } 166 167 static int mpr121_phys_init(struct mpr121_touchkey *mpr121, 168 struct i2c_client *client, int vdd_uv) 169 { 170 const struct mpr121_init_register *reg; 171 unsigned char usl, lsl, tl, eleconf; 172 int i, t, vdd, ret; 173 174 /* Set up touch/release threshold for ele0-ele11 */ 175 for (i = 0; i <= MPR121_MAX_KEY_COUNT; i++) { 176 t = ELE0_TOUCH_THRESHOLD_ADDR + (i * 2); 177 ret = i2c_smbus_write_byte_data(client, t, TOUCH_THRESHOLD); 178 if (ret < 0) 179 goto err_i2c_write; 180 ret = i2c_smbus_write_byte_data(client, t + 1, 181 RELEASE_THRESHOLD); 182 if (ret < 0) 183 goto err_i2c_write; 184 } 185 186 /* Set up init register */ 187 for (i = 0; i < ARRAY_SIZE(init_reg_table); i++) { 188 reg = &init_reg_table[i]; 189 ret = i2c_smbus_write_byte_data(client, reg->addr, reg->val); 190 if (ret < 0) 191 goto err_i2c_write; 192 } 193 194 195 /* 196 * Capacitance on sensing input varies and needs to be compensated. 197 * The internal MPR121-auto-configuration can do this if it's 198 * registers are set properly (based on vdd_uv). 199 */ 200 vdd = vdd_uv / 1000; 201 usl = ((vdd - 700) * 256) / vdd; 202 lsl = (usl * 65) / 100; 203 tl = (usl * 90) / 100; 204 ret = i2c_smbus_write_byte_data(client, AUTO_CONFIG_USL_ADDR, usl); 205 ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_LSL_ADDR, lsl); 206 ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_TL_ADDR, tl); 207 208 /* 209 * Quick charge bit will let the capacitive charge to ready 210 * state quickly, or the buttons may not function after system 211 * boot. 212 */ 213 eleconf = mpr121->keycount | ELECTRODE_CONF_QUICK_CHARGE; 214 ret |= i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 215 eleconf); 216 if (ret != 0) 217 goto err_i2c_write; 218 219 dev_dbg(&client->dev, "set up with %x keys.\n", mpr121->keycount); 220 221 return 0; 222 223 err_i2c_write: 224 dev_err(&client->dev, "i2c write error: %d\n", ret); 225 return ret; 226 } 227 228 static int mpr_touchkey_probe(struct i2c_client *client, 229 const struct i2c_device_id *id) 230 { 231 struct device *dev = &client->dev; 232 struct regulator *vdd_supply; 233 int vdd_uv; 234 struct mpr121_touchkey *mpr121; 235 struct input_dev *input_dev; 236 int error; 237 int i; 238 239 if (!client->irq) { 240 dev_err(dev, "irq number should not be zero\n"); 241 return -EINVAL; 242 } 243 244 vdd_supply = mpr121_vdd_supply_init(dev); 245 if (IS_ERR(vdd_supply)) 246 return PTR_ERR(vdd_supply); 247 248 vdd_uv = regulator_get_voltage(vdd_supply); 249 250 mpr121 = devm_kzalloc(dev, sizeof(*mpr121), GFP_KERNEL); 251 if (!mpr121) 252 return -ENOMEM; 253 254 input_dev = devm_input_allocate_device(dev); 255 if (!input_dev) 256 return -ENOMEM; 257 258 mpr121->client = client; 259 mpr121->input_dev = input_dev; 260 mpr121->keycount = device_property_read_u32_array(dev, "linux,keycodes", 261 NULL, 0); 262 if (mpr121->keycount > MPR121_MAX_KEY_COUNT) { 263 dev_err(dev, "too many keys defined (%d)\n", mpr121->keycount); 264 return -EINVAL; 265 } 266 267 error = device_property_read_u32_array(dev, "linux,keycodes", 268 mpr121->keycodes, 269 mpr121->keycount); 270 if (error) { 271 dev_err(dev, 272 "failed to read linux,keycode property: %d\n", error); 273 return error; 274 } 275 276 input_dev->name = "Freescale MPR121 Touchkey"; 277 input_dev->id.bustype = BUS_I2C; 278 input_dev->dev.parent = dev; 279 if (device_property_read_bool(dev, "autorepeat")) 280 __set_bit(EV_REP, input_dev->evbit); 281 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 282 283 input_dev->keycode = mpr121->keycodes; 284 input_dev->keycodesize = sizeof(mpr121->keycodes[0]); 285 input_dev->keycodemax = mpr121->keycount; 286 287 for (i = 0; i < mpr121->keycount; i++) 288 input_set_capability(input_dev, EV_KEY, mpr121->keycodes[i]); 289 290 error = mpr121_phys_init(mpr121, client, vdd_uv); 291 if (error) { 292 dev_err(dev, "Failed to init register\n"); 293 return error; 294 } 295 296 error = devm_request_threaded_irq(dev, client->irq, NULL, 297 mpr_touchkey_interrupt, 298 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 299 dev->driver->name, mpr121); 300 if (error) { 301 dev_err(dev, "Failed to register interrupt\n"); 302 return error; 303 } 304 305 error = input_register_device(input_dev); 306 if (error) 307 return error; 308 309 i2c_set_clientdata(client, mpr121); 310 device_init_wakeup(dev, 311 device_property_read_bool(dev, "wakeup-source")); 312 313 return 0; 314 } 315 316 static int __maybe_unused mpr_suspend(struct device *dev) 317 { 318 struct i2c_client *client = to_i2c_client(dev); 319 320 if (device_may_wakeup(&client->dev)) 321 enable_irq_wake(client->irq); 322 323 i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 0x00); 324 325 return 0; 326 } 327 328 static int __maybe_unused mpr_resume(struct device *dev) 329 { 330 struct i2c_client *client = to_i2c_client(dev); 331 struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client); 332 333 if (device_may_wakeup(&client->dev)) 334 disable_irq_wake(client->irq); 335 336 i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 337 mpr121->keycount); 338 339 return 0; 340 } 341 342 static SIMPLE_DEV_PM_OPS(mpr121_touchkey_pm_ops, mpr_suspend, mpr_resume); 343 344 static const struct i2c_device_id mpr121_id[] = { 345 { "mpr121_touchkey", 0 }, 346 { } 347 }; 348 MODULE_DEVICE_TABLE(i2c, mpr121_id); 349 350 #ifdef CONFIG_OF 351 static const struct of_device_id mpr121_touchkey_dt_match_table[] = { 352 { .compatible = "fsl,mpr121-touchkey" }, 353 { }, 354 }; 355 MODULE_DEVICE_TABLE(of, mpr121_touchkey_dt_match_table); 356 #endif 357 358 static struct i2c_driver mpr_touchkey_driver = { 359 .driver = { 360 .name = "mpr121", 361 .pm = &mpr121_touchkey_pm_ops, 362 .of_match_table = of_match_ptr(mpr121_touchkey_dt_match_table), 363 }, 364 .id_table = mpr121_id, 365 .probe = mpr_touchkey_probe, 366 }; 367 368 module_i2c_driver(mpr_touchkey_driver); 369 370 MODULE_LICENSE("GPL"); 371 MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>"); 372 MODULE_DESCRIPTION("Touch Key driver for Freescale MPR121 Chip"); 373