1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Analog Devices ADP5585 Keys driver 4 * 5 * Copyright (C) 2025 Analog Devices, Inc. 6 */ 7 8 #include <linux/bitmap.h> 9 #include <linux/container_of.h> 10 #include <linux/device.h> 11 #include <linux/find.h> 12 #include <linux/input.h> 13 #include <linux/input/matrix_keypad.h> 14 #include <linux/mfd/adp5585.h> 15 #include <linux/module.h> 16 #include <linux/notifier.h> 17 #include <linux/platform_device.h> 18 #include <linux/property.h> 19 #include <linux/regmap.h> 20 #include <linux/types.h> 21 22 /* As needed for the matrix parsing code */ 23 #define ADP5589_MAX_KEYMAPSIZE 123 24 25 struct adp5585_kpad_chip { 26 u8 key_ev_min; 27 u8 key_ev_max; 28 u8 max_rows; 29 u8 max_cols; 30 }; 31 32 struct adp5585_kpad { 33 const struct adp5585_kpad_chip *info; 34 struct notifier_block nb; 35 struct input_dev *input; 36 unsigned short keycode[ADP5589_MAX_KEYMAPSIZE]; 37 struct device *dev; 38 unsigned long keypad; 39 int row_shift; 40 }; 41 42 static int adp5585_keys_validate_events(const struct adp5585_kpad *kpad, 43 const u32 *events, u32 n_events) 44 { 45 unsigned int ev; 46 u32 row, col; 47 48 for (ev = 0; ev < n_events; ev++) { 49 if (events[ev] < kpad->info->key_ev_min || 50 events[ev] > kpad->info->key_ev_max) 51 continue; 52 53 /* 54 * if the event is to be generated by the keymap, we need to make 55 * sure that the pins are part of it! 56 */ 57 row = (events[ev] - 1) / kpad->info->max_cols; 58 col = (events[ev] - 1) % kpad->info->max_cols; 59 60 if (test_bit(row, &kpad->keypad) && 61 test_bit(col + kpad->info->max_rows, &kpad->keypad)) 62 continue; 63 64 return dev_err_probe(kpad->dev, -EINVAL, 65 "Invalid unlock/reset event(%u) not used in the keypad\n", 66 events[ev]); 67 } 68 69 return 0; 70 } 71 72 static int adp5585_keys_check_special_events(const struct adp5585_dev *adp5585, 73 const struct adp5585_kpad *kpad) 74 { 75 int error; 76 77 error = adp5585_keys_validate_events(kpad, adp5585->unlock_keys, 78 adp5585->nkeys_unlock); 79 if (error) 80 return error; 81 82 error = adp5585_keys_validate_events(kpad, adp5585->reset1_keys, 83 adp5585->nkeys_reset1); 84 if (error) 85 return error; 86 87 return adp5585_keys_validate_events(kpad, adp5585->reset2_keys, 88 adp5585->nkeys_reset2); 89 } 90 91 static void adp5585_keys_pins_free(void *data) 92 { 93 struct adp5585_kpad *kpad = data; 94 struct adp5585_dev *adp5585 = dev_get_drvdata(kpad->dev->parent); 95 unsigned int pin; 96 97 for_each_set_bit(pin, &kpad->keypad, adp5585->n_pins) 98 clear_bit(pin, adp5585->pin_usage); 99 } 100 101 static int adp5585_keys_parse_fw(const struct adp5585_dev *adp5585, 102 struct adp5585_kpad *kpad) 103 { 104 struct device *dev = kpad->dev; 105 u32 cols = 0, rows = 0, pin; 106 int error, n_pins; 107 108 /* 109 * We do not check for errors (or no value) since the input device is 110 * only added if this property is present in the first place. 111 */ 112 n_pins = device_property_count_u32(dev, "adi,keypad-pins"); 113 if (n_pins > adp5585->n_pins) 114 return dev_err_probe(dev, -EINVAL, 115 "Too many keypad pins (%d) defined (max=%d)\n", 116 n_pins, adp5585->n_pins); 117 118 unsigned int *keypad_pins __free(kfree) = kzalloc_objs(*keypad_pins, 119 n_pins); 120 if (!keypad_pins) 121 return -ENOMEM; 122 123 error = device_property_read_u32_array(dev, "adi,keypad-pins", 124 keypad_pins, n_pins); 125 if (error) 126 return error; 127 128 /* 129 * We can add the action here since it makes the code easier and nothing 130 * "bad" will happen out of it. Worst case, it will be a no-op and no 131 * bit will set. 132 */ 133 error = devm_add_action_or_reset(dev, adp5585_keys_pins_free, kpad); 134 if (error) 135 return error; 136 137 for (pin = 0; pin < n_pins; pin++) { 138 if (keypad_pins[pin] >= adp5585->n_pins) 139 return dev_err_probe(dev, -EINVAL, 140 "Invalid keypad pin(%u) defined\n", 141 keypad_pins[pin]); 142 143 if (test_and_set_bit(keypad_pins[pin], adp5585->pin_usage)) 144 return dev_err_probe(dev, -EBUSY, 145 "Keypad pin(%u) already used\n", 146 keypad_pins[pin]); 147 148 __set_bit(keypad_pins[pin], &kpad->keypad); 149 } 150 151 /* 152 * Note that given that we get a mask (and the HW allows it), we 153 * can have holes in our keypad (eg: row0, row1 and row7 enabled). 154 * However, for the matrix parsing functions we need to pass the 155 * number of rows/cols as the maximum row/col used plus 1. This 156 * pretty much means we will also have holes in our SW keypad. 157 */ 158 159 rows = find_last_bit(&kpad->keypad, kpad->info->max_rows) + 1; 160 if (rows == kpad->info->max_rows + 1) 161 return dev_err_probe(dev, -EINVAL, 162 "Now rows defined in the keypad!\n"); 163 164 cols = find_last_bit(&kpad->keypad, kpad->info->max_cols + kpad->info->max_rows); 165 if (cols < kpad->info->max_rows) 166 return dev_err_probe(dev, -EINVAL, 167 "No columns defined in the keypad!\n"); 168 169 cols = cols + 1 - kpad->info->max_rows; 170 171 error = matrix_keypad_build_keymap(NULL, NULL, rows, cols, 172 kpad->keycode, kpad->input); 173 if (error) 174 return error; 175 176 kpad->row_shift = get_count_order(cols); 177 178 if (device_property_read_bool(kpad->dev, "autorepeat")) 179 __set_bit(EV_REP, kpad->input->evbit); 180 181 error = adp5585_keys_check_special_events(adp5585, kpad); 182 if (error) 183 return error; 184 185 return 0; 186 } 187 188 static int adp5585_keys_setup(const struct adp5585_dev *adp5585, 189 struct adp5585_kpad *kpad) 190 { 191 unsigned long keys_bits, start = 0, nbits = kpad->info->max_rows; 192 const struct adp5585_regs *regs = adp5585->regs; 193 unsigned int i = 0, max_cols = kpad->info->max_cols; 194 int error; 195 196 /* 197 * Take care as the below assumes max_rows is always less or equal than 198 * 8 which is true for the supported devices. If we happen to add 199 * another device we need to make sure this still holds true. Although 200 * adding a new device is very unlikely. 201 */ 202 do { 203 keys_bits = bitmap_read(&kpad->keypad, start, nbits); 204 if (keys_bits) { 205 error = regmap_write(adp5585->regmap, regs->pin_cfg_a + i, 206 keys_bits); 207 if (error) 208 return error; 209 } 210 211 start += nbits; 212 if (max_cols > 8) { 213 nbits = 8; 214 max_cols -= nbits; 215 } else { 216 nbits = max_cols; 217 } 218 219 i++; 220 } while (start < kpad->info->max_rows + kpad->info->max_cols); 221 222 return 0; 223 } 224 225 static int adp5585_keys_ev_handle(struct notifier_block *nb, unsigned long key, 226 void *data) 227 { 228 struct adp5585_kpad *kpad = container_of(nb, struct adp5585_kpad, nb); 229 unsigned long key_press = (unsigned long)data; 230 unsigned int row, col, code; 231 232 /* make sure the event is for us */ 233 if (key < kpad->info->key_ev_min || key > kpad->info->key_ev_max) 234 return NOTIFY_DONE; 235 236 /* 237 * Unlikely but lets be on the safe side! We do not return any error 238 * because the event was indeed for us but with some weird value. So, 239 * we still want the caller know that the right handler was called. 240 */ 241 if (!key) 242 return NOTIFY_BAD; 243 244 row = (key - 1) / (kpad->info->max_cols); 245 col = (key - 1) % (kpad->info->max_cols); 246 code = MATRIX_SCAN_CODE(row, col, kpad->row_shift); 247 248 dev_dbg_ratelimited(kpad->dev, "report key(%lu) r(%d) c(%d) code(%d)\n", 249 key, row, col, kpad->keycode[code]); 250 251 input_report_key(kpad->input, kpad->keycode[code], key_press); 252 input_sync(kpad->input); 253 254 return NOTIFY_STOP; 255 } 256 257 static void adp5585_keys_unreg_notifier(void *data) 258 { 259 struct adp5585_kpad *kpad = data; 260 struct adp5585_dev *adp5585 = dev_get_drvdata(kpad->dev->parent); 261 262 blocking_notifier_chain_unregister(&adp5585->event_notifier, 263 &kpad->nb); 264 } 265 266 static int adp5585_keys_probe(struct platform_device *pdev) 267 { 268 const struct platform_device_id *id = platform_get_device_id(pdev); 269 struct adp5585_dev *adp5585 = dev_get_drvdata(pdev->dev.parent); 270 struct device *dev = &pdev->dev; 271 struct adp5585_kpad *kpad; 272 unsigned int revid; 273 const char *phys; 274 int error; 275 276 kpad = devm_kzalloc(dev, sizeof(*kpad), GFP_KERNEL); 277 if (!kpad) 278 return -ENOMEM; 279 280 if (!adp5585->irq) 281 return dev_err_probe(dev, -EINVAL, 282 "IRQ is mandatory for the keypad\n"); 283 284 kpad->dev = dev; 285 286 kpad->input = devm_input_allocate_device(dev); 287 if (!kpad->input) 288 return -ENOMEM; 289 290 kpad->info = (const struct adp5585_kpad_chip *)id->driver_data; 291 if (!kpad->info) 292 return -ENODEV; 293 294 error = regmap_read(adp5585->regmap, ADP5585_ID, &revid); 295 if (error) 296 return dev_err_probe(dev, error, "Failed to read device ID\n"); 297 298 phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", pdev->name); 299 if (!phys) 300 return -ENOMEM; 301 302 kpad->input->name = pdev->name; 303 kpad->input->phys = phys; 304 305 kpad->input->id.bustype = BUS_I2C; 306 kpad->input->id.vendor = 0x0001; 307 kpad->input->id.product = 0x0001; 308 kpad->input->id.version = revid & ADP5585_REV_ID_MASK; 309 310 device_set_of_node_from_dev(dev, dev->parent); 311 312 error = adp5585_keys_parse_fw(adp5585, kpad); 313 if (error) 314 return error; 315 316 error = adp5585_keys_setup(adp5585, kpad); 317 if (error) 318 return error; 319 320 kpad->nb.notifier_call = adp5585_keys_ev_handle; 321 error = blocking_notifier_chain_register(&adp5585->event_notifier, 322 &kpad->nb); 323 if (error) 324 return error; 325 326 error = devm_add_action_or_reset(dev, adp5585_keys_unreg_notifier, kpad); 327 if (error) 328 return error; 329 330 error = input_register_device(kpad->input); 331 if (error) 332 return dev_err_probe(dev, error, 333 "Failed to register input device\n"); 334 335 return 0; 336 } 337 338 static const struct adp5585_kpad_chip adp5585_kpad_chip_info = { 339 .max_rows = 6, 340 .max_cols = 5, 341 .key_ev_min = ADP5585_ROW5_KEY_EVENT_START, 342 .key_ev_max = ADP5585_ROW5_KEY_EVENT_END, 343 }; 344 345 static const struct adp5585_kpad_chip adp5589_kpad_chip_info = { 346 .max_rows = 8, 347 .max_cols = 11, 348 .key_ev_min = ADP5589_KEY_EVENT_START, 349 .key_ev_max = ADP5589_KEY_EVENT_END, 350 }; 351 352 static const struct platform_device_id adp5585_keys_id_table[] = { 353 { "adp5585-keys", (kernel_ulong_t)&adp5585_kpad_chip_info }, 354 { "adp5589-keys", (kernel_ulong_t)&adp5589_kpad_chip_info }, 355 { } 356 }; 357 MODULE_DEVICE_TABLE(platform, adp5585_keys_id_table); 358 359 static struct platform_driver adp5585_keys_driver = { 360 .driver = { 361 .name = "adp5585-keys", 362 }, 363 .probe = adp5585_keys_probe, 364 .id_table = adp5585_keys_id_table, 365 }; 366 module_platform_driver(adp5585_keys_driver); 367 368 MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>"); 369 MODULE_DESCRIPTION("ADP5585 Keys Driver"); 370 MODULE_LICENSE("GPL"); 371