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