1/* 2 * Copyright (C) ST-Ericsson SA 2010 3 * 4 * License Terms: GNU General Public License, version 2 5 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson 6 */ 7 8#include <linux/module.h> 9#include <linux/slab.h> 10#include <linux/input.h> 11#include <linux/interrupt.h> 12#include <linux/platform_device.h> 13#include <linux/input/matrix_keypad.h> 14#include <linux/mfd/stmpe.h> 15 16/* These are at the same addresses in all STMPE variants */ 17#define STMPE_KPC_COL 0x60 18#define STMPE_KPC_ROW_MSB 0x61 19#define STMPE_KPC_ROW_LSB 0x62 20#define STMPE_KPC_CTRL_MSB 0x63 21#define STMPE_KPC_CTRL_LSB 0x64 22#define STMPE_KPC_COMBI_KEY_0 0x65 23#define STMPE_KPC_COMBI_KEY_1 0x66 24#define STMPE_KPC_COMBI_KEY_2 0x67 25#define STMPE_KPC_DATA_BYTE0 0x68 26#define STMPE_KPC_DATA_BYTE1 0x69 27#define STMPE_KPC_DATA_BYTE2 0x6a 28#define STMPE_KPC_DATA_BYTE3 0x6b 29#define STMPE_KPC_DATA_BYTE4 0x6c 30 31#define STMPE_KPC_CTRL_LSB_SCAN (0x1 << 0) 32#define STMPE_KPC_CTRL_LSB_DEBOUNCE (0x7f << 1) 33#define STMPE_KPC_CTRL_MSB_SCAN_COUNT (0xf << 4) 34 35#define STMPE_KPC_ROW_MSB_ROWS 0xff 36 37#define STMPE_KPC_DATA_UP (0x1 << 7) 38#define STMPE_KPC_DATA_ROW (0xf << 3) 39#define STMPE_KPC_DATA_COL (0x7 << 0) 40#define STMPE_KPC_DATA_NOKEY_MASK 0x78 41 42#define STMPE_KEYPAD_MAX_DEBOUNCE 127 43#define STMPE_KEYPAD_MAX_SCAN_COUNT 15 44 45#define STMPE_KEYPAD_MAX_ROWS 8 46#define STMPE_KEYPAD_MAX_COLS 8 47#define STMPE_KEYPAD_ROW_SHIFT 3 48#define STMPE_KEYPAD_KEYMAP_SIZE \ 49 (STMPE_KEYPAD_MAX_ROWS * STMPE_KEYPAD_MAX_COLS) 50 51/** 52 * struct stmpe_keypad_variant - model-specific attributes 53 * @auto_increment: whether the KPC_DATA_BYTE register address 54 * auto-increments on multiple read 55 * @num_data: number of data bytes 56 * @num_normal_data: number of normal keys' data bytes 57 * @max_cols: maximum number of columns supported 58 * @max_rows: maximum number of rows supported 59 * @col_gpios: bitmask of gpios which can be used for columns 60 * @row_gpios: bitmask of gpios which can be used for rows 61 */ 62struct stmpe_keypad_variant { 63 bool auto_increment; 64 int num_data; 65 int num_normal_data; 66 int max_cols; 67 int max_rows; 68 unsigned int col_gpios; 69 unsigned int row_gpios; 70}; 71 72static const struct stmpe_keypad_variant stmpe_keypad_variants[] = { 73 [STMPE1601] = { 74 .auto_increment = true, 75 .num_data = 5, 76 .num_normal_data = 3, 77 .max_cols = 8, 78 .max_rows = 8, 79 .col_gpios = 0x000ff, /* GPIO 0 - 7 */ 80 .row_gpios = 0x0ff00, /* GPIO 8 - 15 */ 81 }, 82 [STMPE2401] = { 83 .auto_increment = false, 84 .num_data = 3, 85 .num_normal_data = 2, 86 .max_cols = 8, 87 .max_rows = 12, 88 .col_gpios = 0x0000ff, /* GPIO 0 - 7*/ 89 .row_gpios = 0x1f7f00, /* GPIO 8-14, 16-20 */ 90 }, 91 [STMPE2403] = { 92 .auto_increment = true, 93 .num_data = 5, 94 .num_normal_data = 3, 95 .max_cols = 8, 96 .max_rows = 12, 97 .col_gpios = 0x0000ff, /* GPIO 0 - 7*/ 98 .row_gpios = 0x1fef00, /* GPIO 8-14, 16-20 */ 99 }, 100}; 101 102struct stmpe_keypad { 103 struct stmpe *stmpe; 104 struct input_dev *input; 105 const struct stmpe_keypad_variant *variant; 106 const struct stmpe_keypad_platform_data *plat; 107 108 unsigned int rows; 109 unsigned int cols; 110 111 unsigned short keymap[STMPE_KEYPAD_KEYMAP_SIZE]; 112}; 113 114static int stmpe_keypad_read_data(struct stmpe_keypad *keypad, u8 *data) 115{ 116 const struct stmpe_keypad_variant *variant = keypad->variant; 117 struct stmpe *stmpe = keypad->stmpe; 118 int ret; 119 int i; 120 121 if (variant->auto_increment) 122 return stmpe_block_read(stmpe, STMPE_KPC_DATA_BYTE0, 123 variant->num_data, data); 124 125 for (i = 0; i < variant->num_data; i++) { 126 ret = stmpe_reg_read(stmpe, STMPE_KPC_DATA_BYTE0 + i); 127 if (ret < 0) 128 return ret; 129 130 data[i] = ret; 131 } 132 133 return 0; 134} 135 136static irqreturn_t stmpe_keypad_irq(int irq, void *dev) 137{ 138 struct stmpe_keypad *keypad = dev; 139 struct input_dev *input = keypad->input; 140 const struct stmpe_keypad_variant *variant = keypad->variant; 141 u8 fifo[variant->num_data]; 142 int ret; 143 int i; 144 145 ret = stmpe_keypad_read_data(keypad, fifo); 146 if (ret < 0) 147 return IRQ_NONE; 148 149 for (i = 0; i < variant->num_normal_data; i++) { 150 u8 data = fifo[i]; 151 int row = (data & STMPE_KPC_DATA_ROW) >> 3; 152 int col = data & STMPE_KPC_DATA_COL; 153 int code = MATRIX_SCAN_CODE(row, col, STMPE_KEYPAD_ROW_SHIFT); 154 bool up = data & STMPE_KPC_DATA_UP; 155 156 if ((data & STMPE_KPC_DATA_NOKEY_MASK) 157 == STMPE_KPC_DATA_NOKEY_MASK) 158 continue; 159 160 input_event(input, EV_MSC, MSC_SCAN, code); 161 input_report_key(input, keypad->keymap[code], !up); 162 input_sync(input); 163 } 164 165 return IRQ_HANDLED; 166} 167 168static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad) 169{ 170 const struct stmpe_keypad_variant *variant = keypad->variant; 171 unsigned int col_gpios = variant->col_gpios; 172 unsigned int row_gpios = variant->row_gpios; 173 struct stmpe *stmpe = keypad->stmpe; 174 unsigned int pins = 0; 175 int i; 176 177 /* 178 * Figure out which pins need to be set to the keypad alternate 179 * function. 180 * 181 * {cols,rows}_gpios are bitmasks of which pins on the chip can be used 182 * for the keypad. 183 * 184 * keypad->{cols,rows} are a bitmask of which pins (of the ones useable 185 * for the keypad) are used on the board. 186 */ 187 188 for (i = 0; i < variant->max_cols; i++) { 189 int num = __ffs(col_gpios); 190 191 if (keypad->cols & (1 << i)) 192 pins |= 1 << num; 193 194 col_gpios &= ~(1 << num); 195 } 196 197 for (i = 0; i < variant->max_rows; i++) { 198 int num = __ffs(row_gpios); 199 200 if (keypad->rows & (1 << i)) 201 pins |= 1 << num; 202 203 row_gpios &= ~(1 << num); 204 } 205 206 return stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD); 207} 208 209static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad) 210{ 211 const struct stmpe_keypad_platform_data *plat = keypad->plat; 212 const struct stmpe_keypad_variant *variant = keypad->variant; 213 struct stmpe *stmpe = keypad->stmpe; 214 int ret; 215 216 if (plat->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE) 217 return -EINVAL; 218 219 if (plat->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT) 220 return -EINVAL; 221 222 ret = stmpe_enable(stmpe, STMPE_BLOCK_KEYPAD); 223 if (ret < 0) 224 return ret; 225 226 ret = stmpe_keypad_altfunc_init(keypad); 227 if (ret < 0) 228 return ret; 229 230 ret = stmpe_reg_write(stmpe, STMPE_KPC_COL, keypad->cols); 231 if (ret < 0) 232 return ret; 233 234 ret = stmpe_reg_write(stmpe, STMPE_KPC_ROW_LSB, keypad->rows); 235 if (ret < 0) 236 return ret; 237 238 if (variant->max_rows > 8) { 239 ret = stmpe_set_bits(stmpe, STMPE_KPC_ROW_MSB, 240 STMPE_KPC_ROW_MSB_ROWS, 241 keypad->rows >> 8); 242 if (ret < 0) 243 return ret; 244 } 245 246 ret = stmpe_set_bits(stmpe, STMPE_KPC_CTRL_MSB, 247 STMPE_KPC_CTRL_MSB_SCAN_COUNT, 248 plat->scan_count << 4); 249 if (ret < 0) 250 return ret; 251 252 return stmpe_set_bits(stmpe, STMPE_KPC_CTRL_LSB, 253 STMPE_KPC_CTRL_LSB_SCAN | 254 STMPE_KPC_CTRL_LSB_DEBOUNCE, 255 STMPE_KPC_CTRL_LSB_SCAN | 256 (plat->debounce_ms << 1)); 257} 258 259static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad) 260{ 261 int row, col; 262 263 for (row = 0; row < STMPE_KEYPAD_MAX_ROWS; row++) { 264 for (col = 0; col < STMPE_KEYPAD_MAX_COLS; col++) { 265 int code = MATRIX_SCAN_CODE(row, col, 266 STMPE_KEYPAD_ROW_SHIFT); 267 if (keypad->keymap[code] != KEY_RESERVED) { 268 keypad->rows |= 1 << row; 269 keypad->cols |= 1 << col; 270 } 271 } 272 } 273} 274 275#ifdef CONFIG_OF 276static const struct stmpe_keypad_platform_data * 277stmpe_keypad_of_probe(struct device *dev) 278{ 279 struct device_node *np = dev->of_node; 280 struct stmpe_keypad_platform_data *plat; 281 282 if (!np) 283 return ERR_PTR(-ENODEV); 284 285 plat = devm_kzalloc(dev, sizeof(*plat), GFP_KERNEL); 286 if (!plat) 287 return ERR_PTR(-ENOMEM); 288 289 of_property_read_u32(np, "debounce-interval", &plat->debounce_ms); 290 of_property_read_u32(np, "st,scan-count", &plat->scan_count); 291 292 plat->no_autorepeat = of_property_read_bool(np, "st,no-autorepeat"); 293 294 return plat; 295} 296#else 297static inline const struct stmpe_keypad_platform_data * 298stmpe_keypad_of_probe(struct device *dev) 299{ 300 return ERR_PTR(-EINVAL); 301} 302#endif 303 304static int stmpe_keypad_probe(struct platform_device *pdev) 305{ 306 struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent); 307 const struct stmpe_keypad_platform_data *plat; 308 struct stmpe_keypad *keypad; 309 struct input_dev *input; 310 int error; 311 int irq; 312 313 plat = stmpe->pdata->keypad; 314 if (!plat) { 315 plat = stmpe_keypad_of_probe(&pdev->dev); 316 if (IS_ERR(plat)) 317 return PTR_ERR(plat); 318 } 319 320 irq = platform_get_irq(pdev, 0); 321 if (irq < 0) 322 return irq; 323 324 keypad = devm_kzalloc(&pdev->dev, sizeof(struct stmpe_keypad), 325 GFP_KERNEL); 326 if (!keypad) 327 return -ENOMEM; 328 329 input = devm_input_allocate_device(&pdev->dev); 330 if (!input) 331 return -ENOMEM; 332 333 input->name = "STMPE keypad"; 334 input->id.bustype = BUS_I2C; 335 input->dev.parent = &pdev->dev; 336 337 error = matrix_keypad_build_keymap(plat->keymap_data, NULL, 338 STMPE_KEYPAD_MAX_ROWS, 339 STMPE_KEYPAD_MAX_COLS, 340 keypad->keymap, input); 341 if (error) 342 return error; 343 344 input_set_capability(input, EV_MSC, MSC_SCAN); 345 if (!plat->no_autorepeat) 346 __set_bit(EV_REP, input->evbit); 347 348 stmpe_keypad_fill_used_pins(keypad); 349 350 keypad->stmpe = stmpe; 351 keypad->plat = plat; 352 keypad->input = input; 353 keypad->variant = &stmpe_keypad_variants[stmpe->partnum]; 354 355 error = stmpe_keypad_chip_init(keypad); 356 if (error < 0) 357 return error; 358 359 error = devm_request_threaded_irq(&pdev->dev, irq, 360 NULL, stmpe_keypad_irq, 361 IRQF_ONESHOT, "stmpe-keypad", keypad); 362 if (error) { 363 dev_err(&pdev->dev, "unable to get irq: %d\n", error); 364 return error; 365 } 366 367 error = input_register_device(input); 368 if (error) { 369 dev_err(&pdev->dev, 370 "unable to register input device: %d\n", error); 371 return error; 372 } 373 374 platform_set_drvdata(pdev, keypad); 375 376 return 0; 377} 378 379static int stmpe_keypad_remove(struct platform_device *pdev) 380{ 381 struct stmpe_keypad *keypad = platform_get_drvdata(pdev); 382 383 stmpe_disable(keypad->stmpe, STMPE_BLOCK_KEYPAD); 384 385 return 0; 386} 387 388static struct platform_driver stmpe_keypad_driver = { 389 .driver.name = "stmpe-keypad", 390 .driver.owner = THIS_MODULE, 391 .probe = stmpe_keypad_probe, 392 .remove = stmpe_keypad_remove, 393}; 394module_platform_driver(stmpe_keypad_driver); 395 396MODULE_LICENSE("GPL v2"); 397MODULE_DESCRIPTION("STMPExxxx keypad driver"); 398MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>"); 399