1 /* 2 * Input driver for resistor ladder connected on ADC 3 * 4 * Copyright (c) 2016 Alexandre Belloni 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published by 8 * the Free Software Foundation. 9 */ 10 11 #include <linux/err.h> 12 #include <linux/iio/consumer.h> 13 #include <linux/iio/types.h> 14 #include <linux/input.h> 15 #include <linux/input-polldev.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/platform_device.h> 20 #include <linux/property.h> 21 #include <linux/slab.h> 22 23 struct adc_keys_button { 24 u32 voltage; 25 u32 keycode; 26 }; 27 28 struct adc_keys_state { 29 struct iio_channel *channel; 30 u32 num_keys; 31 u32 last_key; 32 u32 keyup_voltage; 33 const struct adc_keys_button *map; 34 }; 35 36 static void adc_keys_poll(struct input_polled_dev *dev) 37 { 38 struct adc_keys_state *st = dev->private; 39 int i, value, ret; 40 u32 diff, closest = 0xffffffff; 41 int keycode = 0; 42 43 ret = iio_read_channel_processed(st->channel, &value); 44 if (unlikely(ret < 0)) { 45 /* Forcibly release key if any was pressed */ 46 value = st->keyup_voltage; 47 } else { 48 for (i = 0; i < st->num_keys; i++) { 49 diff = abs(st->map[i].voltage - value); 50 if (diff < closest) { 51 closest = diff; 52 keycode = st->map[i].keycode; 53 } 54 } 55 } 56 57 if (abs(st->keyup_voltage - value) < closest) 58 keycode = 0; 59 60 if (st->last_key && st->last_key != keycode) 61 input_report_key(dev->input, st->last_key, 0); 62 63 if (keycode) 64 input_report_key(dev->input, keycode, 1); 65 66 input_sync(dev->input); 67 st->last_key = keycode; 68 } 69 70 static int adc_keys_load_keymap(struct device *dev, struct adc_keys_state *st) 71 { 72 struct adc_keys_button *map; 73 struct fwnode_handle *child; 74 int i; 75 76 st->num_keys = device_get_child_node_count(dev); 77 if (st->num_keys == 0) { 78 dev_err(dev, "keymap is missing\n"); 79 return -EINVAL; 80 } 81 82 map = devm_kmalloc_array(dev, st->num_keys, sizeof(*map), GFP_KERNEL); 83 if (!map) 84 return -ENOMEM; 85 86 i = 0; 87 device_for_each_child_node(dev, child) { 88 if (fwnode_property_read_u32(child, "press-threshold-microvolt", 89 &map[i].voltage)) { 90 dev_err(dev, "Key with invalid or missing voltage\n"); 91 fwnode_handle_put(child); 92 return -EINVAL; 93 } 94 map[i].voltage /= 1000; 95 96 if (fwnode_property_read_u32(child, "linux,code", 97 &map[i].keycode)) { 98 dev_err(dev, "Key with invalid or missing linux,code\n"); 99 fwnode_handle_put(child); 100 return -EINVAL; 101 } 102 103 i++; 104 } 105 106 st->map = map; 107 return 0; 108 } 109 110 static int adc_keys_probe(struct platform_device *pdev) 111 { 112 struct device *dev = &pdev->dev; 113 struct adc_keys_state *st; 114 struct input_polled_dev *poll_dev; 115 struct input_dev *input; 116 enum iio_chan_type type; 117 int i, value; 118 int error; 119 120 st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL); 121 if (!st) 122 return -ENOMEM; 123 124 st->channel = devm_iio_channel_get(dev, "buttons"); 125 if (IS_ERR(st->channel)) 126 return PTR_ERR(st->channel); 127 128 if (!st->channel->indio_dev) 129 return -ENXIO; 130 131 error = iio_get_channel_type(st->channel, &type); 132 if (error < 0) 133 return error; 134 135 if (type != IIO_VOLTAGE) { 136 dev_err(dev, "Incompatible channel type %d\n", type); 137 return -EINVAL; 138 } 139 140 if (device_property_read_u32(dev, "keyup-threshold-microvolt", 141 &st->keyup_voltage)) { 142 dev_err(dev, "Invalid or missing keyup voltage\n"); 143 return -EINVAL; 144 } 145 st->keyup_voltage /= 1000; 146 147 error = adc_keys_load_keymap(dev, st); 148 if (error) 149 return error; 150 151 platform_set_drvdata(pdev, st); 152 153 poll_dev = devm_input_allocate_polled_device(dev); 154 if (!poll_dev) { 155 dev_err(dev, "failed to allocate input device\n"); 156 return -ENOMEM; 157 } 158 159 if (!device_property_read_u32(dev, "poll-interval", &value)) 160 poll_dev->poll_interval = value; 161 162 poll_dev->poll = adc_keys_poll; 163 poll_dev->private = st; 164 165 input = poll_dev->input; 166 167 input->name = pdev->name; 168 input->phys = "adc-keys/input0"; 169 170 input->id.bustype = BUS_HOST; 171 input->id.vendor = 0x0001; 172 input->id.product = 0x0001; 173 input->id.version = 0x0100; 174 175 __set_bit(EV_KEY, input->evbit); 176 for (i = 0; i < st->num_keys; i++) 177 __set_bit(st->map[i].keycode, input->keybit); 178 179 if (device_property_read_bool(dev, "autorepeat")) 180 __set_bit(EV_REP, input->evbit); 181 182 error = input_register_polled_device(poll_dev); 183 if (error) { 184 dev_err(dev, "Unable to register input device: %d\n", error); 185 return error; 186 } 187 188 return 0; 189 } 190 191 #ifdef CONFIG_OF 192 static const struct of_device_id adc_keys_of_match[] = { 193 { .compatible = "adc-keys", }, 194 { } 195 }; 196 MODULE_DEVICE_TABLE(of, adc_keys_of_match); 197 #endif 198 199 static struct platform_driver __refdata adc_keys_driver = { 200 .driver = { 201 .name = "adc_keys", 202 .of_match_table = of_match_ptr(adc_keys_of_match), 203 }, 204 .probe = adc_keys_probe, 205 }; 206 module_platform_driver(adc_keys_driver); 207 208 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>"); 209 MODULE_DESCRIPTION("Input driver for resistor ladder connected on ADC"); 210 MODULE_LICENSE("GPL v2"); 211