drivers/input/touchscreen/resistive-adc-touch.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ADC generic resistive touchscreen (GRTS)
   4  * This is a generic input driver that connects to an ADC
   5  * given the channels in device tree, and reports events to the input
   6  * subsystem.
   7  *
   8  * Copyright (C) 2017,2018 Microchip Technology,
   9  * Author: Eugen Hristev <eugen.hristev@microchip.com>
  10  *
  11  */
  12 #include <linux/input.h>
  13 #include <linux/input/touchscreen.h>
  14 #include <linux/iio/consumer.h>
  15 #include <linux/iio/iio.h>
  16 #include <linux/mod_devicetable.h>
  17 #include <linux/module.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/property.h>
  20
  21 #define DRIVER_NAME                                     "resistive-adc-touch"
  22 #define GRTS_DEFAULT_PRESSURE_MIN                       50000
  23 #define GRTS_DEFAULT_PRESSURE_MAX                       65535
  24 #define GRTS_MAX_POS_MASK                               GENMASK(11, 0)
  25 #define GRTS_MAX_CHANNELS                               4
  26
  27 enum grts_ch_type {
  28         GRTS_CH_X,
  29         GRTS_CH_Y,
  30         GRTS_CH_PRESSURE,
  31         GRTS_CH_Z1,
  32         GRTS_CH_Z2,
  33         GRTS_CH_MAX = GRTS_CH_Z2 + 1
  34 };
  35
  36 /**
  37  * struct grts_state - generic resistive touch screen information struct
  38  * @x_plate_ohms:       resistance of the X plate
  39  * @pressure_min:       number representing the minimum for the pressure
  40  * @pressure:           are we getting pressure info or not
  41  * @iio_chans:          list of channels acquired
  42  * @iio_cb:             iio_callback buffer for the data
  43  * @input:              the input device structure that we register
  44  * @prop:               touchscreen properties struct
  45  * @ch_map:             map of channels that are defined for the touchscreen
  46  */
  47 struct grts_state {
  48         u32                             x_plate_ohms;
  49         u32                             pressure_min;
  50         bool                            pressure;
  51         struct iio_channel              *iio_chans;
  52         struct iio_cb_buffer            *iio_cb;
  53         struct input_dev                *input;
  54         struct touchscreen_properties   prop;
  55         u8                              ch_map[GRTS_CH_MAX];
  56 };
  57
  58 static int grts_cb(const void *data, void *private)
  59 {
  60         const u16 *touch_info = data;
  61         struct grts_state *st = private;
  62         unsigned int x, y, press = 0;
  63
  64         x = touch_info[st->ch_map[GRTS_CH_X]];
  65         y = touch_info[st->ch_map[GRTS_CH_Y]];
  66
  67         if (st->ch_map[GRTS_CH_PRESSURE] < GRTS_MAX_CHANNELS) {
  68                 press = touch_info[st->ch_map[GRTS_CH_PRESSURE]];
  69         } else if (st->ch_map[GRTS_CH_Z1] < GRTS_MAX_CHANNELS) {
  70                 unsigned int z1 = touch_info[st->ch_map[GRTS_CH_Z1]];
  71                 unsigned int z2 = touch_info[st->ch_map[GRTS_CH_Z2]];
  72                 unsigned int Rt;
  73
  74                 if (likely(x && z1)) {
  75                         Rt = z2;
  76                         Rt -= z1;
  77                         Rt *= st->x_plate_ohms;
  78                         Rt = DIV_ROUND_CLOSEST(Rt, 16);
  79                         Rt *= x;
  80                         Rt /= z1;
  81                         Rt = DIV_ROUND_CLOSEST(Rt, 256);
  82                         /*
  83                          * On increased pressure the resistance (Rt) is
  84                          * decreasing so, convert values to make it looks as
  85                          * real pressure.
  86                          */
  87                         if (Rt < GRTS_DEFAULT_PRESSURE_MAX)
  88                                 press = GRTS_DEFAULT_PRESSURE_MAX - Rt;
  89                 }
  90         }
  91
  92         if ((!x && !y) || (st->pressure && (press < st->pressure_min))) {
  93                 /* report end of touch */
  94                 input_report_key(st->input, BTN_TOUCH, 0);
  95                 input_sync(st->input);
  96                 return 0;
  97         }
  98
  99         /* report proper touch to subsystem*/
 100         touchscreen_report_pos(st->input, &st->prop, x, y, false);
 101         if (st->pressure)
 102                 input_report_abs(st->input, ABS_PRESSURE, press);
 103         input_report_key(st->input, BTN_TOUCH, 1);
 104         input_sync(st->input);
 105
 106         return 0;
 107 }
 108
 109 static int grts_open(struct input_dev *dev)
 110 {
 111         int error;
 112         struct grts_state *st = input_get_drvdata(dev);
 113
 114         error = iio_channel_start_all_cb(st->iio_cb);
 115         if (error) {
 116                 dev_err(dev->dev.parent, "failed to start callback buffer.\n");
 117                 return error;
 118         }
 119         return 0;
 120 }
 121
 122 static void grts_close(struct input_dev *dev)
 123 {
 124         struct grts_state *st = input_get_drvdata(dev);
 125
 126         iio_channel_stop_all_cb(st->iio_cb);
 127 }
 128
 129 static void grts_disable(void *data)
 130 {
 131         iio_channel_release_all_cb(data);
 132 }
 133
 134 static int grts_map_channel(struct grts_state *st, struct device *dev,
 135                             enum grts_ch_type type, const char *name,
 136                             bool optional)
 137 {
 138         int idx;
 139
 140         idx = device_property_match_string(dev, "io-channel-names", name);
 141         if (idx < 0) {
 142                 if (!optional)
 143                         return idx;
 144                 idx = GRTS_MAX_CHANNELS;
 145         } else if (idx >= GRTS_MAX_CHANNELS) {
 146                 return -EOVERFLOW;
 147         }
 148
 149         st->ch_map[type] = idx;
 150         return 0;
 151 }
 152
 153 static int grts_get_properties(struct grts_state *st, struct device *dev)
 154 {
 155         int error;
 156
 157         error = grts_map_channel(st, dev, GRTS_CH_X, "x", false);
 158         if (error)
 159                 return error;
 160
 161         error = grts_map_channel(st, dev, GRTS_CH_Y, "y", false);
 162         if (error)
 163                 return error;
 164
 165         /* pressure is optional */
 166         error = grts_map_channel(st, dev, GRTS_CH_PRESSURE, "pressure", true);
 167         if (error)
 168                 return error;
 169
 170         if (st->ch_map[GRTS_CH_PRESSURE] < GRTS_MAX_CHANNELS) {
 171                 st->pressure = true;
 172                 return 0;
 173         }
 174
 175         /* if no pressure is defined, try optional z1 + z2 */
 176         error = grts_map_channel(st, dev, GRTS_CH_Z1, "z1", true);
 177         if (error)
 178                 return error;
 179
 180         if (st->ch_map[GRTS_CH_Z1] >= GRTS_MAX_CHANNELS)
 181                 return 0;
 182
 183         /* if z1 is provided z2 is not optional */
 184         error = grts_map_channel(st, dev, GRTS_CH_Z2, "z2", true);
 185         if (error)
 186                 return error;
 187
 188         error = device_property_read_u32(dev,
 189                                          "touchscreen-x-plate-ohms",
 190                                          &st->x_plate_ohms);
 191         if (error) {
 192                 dev_err(dev, "can't get touchscreen-x-plate-ohms property\n");
 193                 return error;
 194         }
 195
 196         st->pressure = true;
 197         return 0;
 198 }
 199
 200 static int grts_probe(struct platform_device *pdev)
 201 {
 202         struct grts_state *st;
 203         struct input_dev *input;
 204         struct device *dev = &pdev->dev;
 205         int error;
 206
 207         st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL);
 208         if (!st)
 209                 return -ENOMEM;
 210
 211         /* get the channels from IIO device */
 212         st->iio_chans = devm_iio_channel_get_all(dev);
 213         if (IS_ERR(st->iio_chans))
 214                 return dev_err_probe(dev, PTR_ERR(st->iio_chans), "can't get iio channels\n");
 215
 216         if (!device_property_present(dev, "io-channel-names"))
 217                 return -ENODEV;
 218
 219         error = grts_get_properties(st, dev);
 220         if (error) {
 221                 dev_err(dev, "Failed to parse properties\n");
 222                 return error;
 223         }
 224
 225         if (st->pressure) {
 226                 error = device_property_read_u32(dev,
 227                                                  "touchscreen-min-pressure",
 228                                                  &st->pressure_min);
 229                 if (error) {
 230                         dev_dbg(dev, "can't get touchscreen-min-pressure property.\n");
 231                         st->pressure_min = GRTS_DEFAULT_PRESSURE_MIN;
 232                 }
 233         }
 234
 235         input = devm_input_allocate_device(dev);
 236         if (!input) {
 237                 dev_err(dev, "failed to allocate input device.\n");
 238                 return -ENOMEM;
 239         }
 240
 241         input->name = DRIVER_NAME;
 242         input->id.bustype = BUS_HOST;
 243         input->open = grts_open;
 244         input->close = grts_close;
 245
 246         input_set_abs_params(input, ABS_X, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
 247         input_set_abs_params(input, ABS_Y, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
 248         if (st->pressure)
 249                 input_set_abs_params(input, ABS_PRESSURE, st->pressure_min,
 250                                      GRTS_DEFAULT_PRESSURE_MAX, 0, 0);
 251
 252         input_set_capability(input, EV_KEY, BTN_TOUCH);
 253
 254         /* parse optional device tree properties */
 255         touchscreen_parse_properties(input, false, &st->prop);
 256
 257         st->input = input;
 258         input_set_drvdata(input, st);
 259
 260         error = input_register_device(input);
 261         if (error) {
 262                 dev_err(dev, "failed to register input device.");
 263                 return error;
 264         }
 265
 266         st->iio_cb = iio_channel_get_all_cb(dev, grts_cb, st);
 267         if (IS_ERR(st->iio_cb)) {
 268                 dev_err(dev, "failed to allocate callback buffer.\n");
 269                 return PTR_ERR(st->iio_cb);
 270         }
 271
 272         error = devm_add_action_or_reset(dev, grts_disable, st->iio_cb);
 273         if (error) {
 274                 dev_err(dev, "failed to add disable action.\n");
 275                 return error;
 276         }
 277
 278         return 0;
 279 }
 280
 281 static const struct of_device_id grts_of_match[] = {
 282         {
 283                 .compatible = "resistive-adc-touch",
 284         }, {
 285                 /* sentinel */
 286         },
 287 };
 288
 289 MODULE_DEVICE_TABLE(of, grts_of_match);
 290
 291 static struct platform_driver grts_driver = {
 292         .probe = grts_probe,
 293         .driver = {
 294                 .name = DRIVER_NAME,
 295                 .of_match_table = grts_of_match,
 296         },
 297 };
 298
 299 module_platform_driver(grts_driver);
 300
 301 MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>");
 302 MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver");
 303 MODULE_LICENSE("GPL v2");