// SPDX-License-Identifier: GPL-2.0-only
/*
 *  Helper functions for overlay objects on touchscreens
 *
 *  Copyright (c) 2023 Javier Carrasco <javier.carrasco@wolfvision.net>
 */

#include <linux/export.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/input/touch-overlay.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/property.h>

struct touch_overlay_segment {
        struct list_head list;
        u32 x_origin;
        u32 y_origin;
        u32 x_size;
        u32 y_size;
        u32 key;
        bool pressed;
        int slot;
};

static int touch_overlay_get_segment(struct fwnode_handle *segment_node,
                                     struct touch_overlay_segment *segment,
                                     struct input_dev *input)
{
        int error;

        error = fwnode_property_read_u32(segment_node, "x-origin",
                                         &segment->x_origin);
        if (error)
                return error;

        error = fwnode_property_read_u32(segment_node, "y-origin",
                                         &segment->y_origin);
        if (error)
                return error;

        error = fwnode_property_read_u32(segment_node, "x-size",
                                         &segment->x_size);
        if (error)
                return error;

        error = fwnode_property_read_u32(segment_node, "y-size",
                                         &segment->y_size);
        if (error)
                return error;

        error = fwnode_property_read_u32(segment_node, "linux,code",
                                         &segment->key);
        if (!error)
                input_set_capability(input, EV_KEY, segment->key);
        else if (error != -EINVAL)
                return error;

        return 0;
}

/**
 * touch_overlay_map - map overlay objects from the device tree and set
 * key capabilities if buttons are defined.
 * @list: pointer to the list that will hold the segments
 * @input: pointer to the already allocated input_dev
 *
 * Returns 0 on success and error number otherwise.
 *
 * If buttons are defined, key capabilities are set accordingly.
 */
int touch_overlay_map(struct list_head *list, struct input_dev *input)
{
        struct fwnode_handle *fw_segment;
        struct device *dev = input->dev.parent;
        struct touch_overlay_segment *segment;
        int error;

        struct fwnode_handle *overlay __free(fwnode_handle) =
                device_get_named_child_node(dev, "touch-overlay");
        if (!overlay)
                return 0;

        fwnode_for_each_available_child_node(overlay, fw_segment) {
                segment = devm_kzalloc(dev, sizeof(*segment), GFP_KERNEL);
                if (!segment) {
                        fwnode_handle_put(fw_segment);
                        return -ENOMEM;
                }
                error = touch_overlay_get_segment(fw_segment, segment, input);
                if (error) {
                        fwnode_handle_put(fw_segment);
                        return error;
                }
                list_add_tail(&segment->list, list);
        }

        return 0;
}
EXPORT_SYMBOL(touch_overlay_map);

/**
 * touch_overlay_get_touchscreen_abs - get abs size from the touchscreen area.
 * @list: pointer to the list that holds the segments
 * @x: horizontal abs
 * @y: vertical abs
 */
void touch_overlay_get_touchscreen_abs(struct list_head *list, u16 *x, u16 *y)
{
        struct touch_overlay_segment *segment;
        struct list_head *ptr;

        list_for_each(ptr, list) {
                segment = list_entry(ptr, struct touch_overlay_segment, list);
                if (!segment->key) {
                        *x = segment->x_size - 1;
                        *y = segment->y_size - 1;
                        break;
                }
        }
}
EXPORT_SYMBOL(touch_overlay_get_touchscreen_abs);

static bool touch_overlay_segment_event(struct touch_overlay_segment *seg,
                                        struct input_mt_pos *pos)
{
        if (pos->x >= seg->x_origin && pos->x < (seg->x_origin + seg->x_size) &&
            pos->y >= seg->y_origin && pos->y < (seg->y_origin + seg->y_size))
                return true;

        return false;
}

/**
 * touch_overlay_mapped_touchscreen - check if a touchscreen area is mapped
 * @list: pointer to the list that holds the segments
 *
 * Returns true if a touchscreen area is mapped or false otherwise.
 */
bool touch_overlay_mapped_touchscreen(struct list_head *list)
{
        struct touch_overlay_segment *segment;
        struct list_head *ptr;

        list_for_each(ptr, list) {
                segment = list_entry(ptr, struct touch_overlay_segment, list);
                if (!segment->key)
                        return true;
        }

        return false;
}
EXPORT_SYMBOL(touch_overlay_mapped_touchscreen);

static bool touch_overlay_event_on_ts(struct list_head *list,
                                      struct input_mt_pos *pos)
{
        struct touch_overlay_segment *segment;
        struct list_head *ptr;

        list_for_each(ptr, list) {
                segment = list_entry(ptr, struct touch_overlay_segment, list);
                if (segment->key)
                        continue;

                if (touch_overlay_segment_event(segment, pos)) {
                        pos->x -= segment->x_origin;
                        pos->y -= segment->y_origin;
                        return true;
                }
                /* ignore touch events outside the defined area */
                return false;
        }

        return true;
}

static bool touch_overlay_button_event(struct input_dev *input,
                                       struct touch_overlay_segment *segment,
                                       struct input_mt_pos *pos, int slot)
{
        struct input_mt *mt = input->mt;
        struct input_mt_slot *s = &mt->slots[slot];
        bool button_contact = touch_overlay_segment_event(segment, pos);

        if (segment->slot == slot && segment->pressed) {
                /* sliding out of the button releases it */
                if (!button_contact) {
                        input_report_key(input, segment->key, false);
                        segment->pressed = false;
                        /* keep available for a possible touch event */
                        return false;
                }
                /* ignore sliding on the button while pressed */
                s->frame = mt->frame;
                return true;
        } else if (button_contact) {
                input_report_key(input, segment->key, true);
                s->frame = mt->frame;
                segment->slot = slot;
                segment->pressed = true;
                return true;
        }

        return false;
}

/**
 * touch_overlay_sync_frame - update the status of the segments and report
 * buttons whose tracked slot is unused.
 * @list: pointer to the list that holds the segments
 * @input: pointer to the input device associated to the contact
 */
void touch_overlay_sync_frame(struct list_head *list, struct input_dev *input)
{
        struct touch_overlay_segment *segment;
        struct input_mt *mt = input->mt;
        struct input_mt_slot *s;
        struct list_head *ptr;

        list_for_each(ptr, list) {
                segment = list_entry(ptr, struct touch_overlay_segment, list);
                if (!segment->key)
                        continue;

                s = &mt->slots[segment->slot];
                if (!input_mt_is_used(mt, s) && segment->pressed) {
                        input_report_key(input, segment->key, false);
                        segment->pressed = false;
                }
        }
}
EXPORT_SYMBOL(touch_overlay_sync_frame);

/**
 * touch_overlay_process_contact - process contacts according to the overlay
 * mapping. This function acts as a filter to release the calling driver
 * from the contacts that are either related to overlay buttons or out of the
 * overlay touchscreen area, if defined.
 * @list: pointer to the list that holds the segments
 * @input: pointer to the input device associated to the contact
 * @pos: pointer to the contact position
 * @slot: slot associated to the contact (0 if multitouch is not supported)
 *
 * Returns true if the contact was processed (reported for valid key events
 * and dropped for contacts outside the overlay touchscreen area) or false
 * if the contact must be processed by the caller. In that case this function
 * shifts the (x,y) coordinates to the overlay touchscreen axis if required.
 */
bool touch_overlay_process_contact(struct list_head *list,
                                   struct input_dev *input,
                                   struct input_mt_pos *pos, int slot)
{
        struct touch_overlay_segment *segment;
        struct list_head *ptr;

        /*
         * buttons must be prioritized over overlay touchscreens to account for
         * overlappings e.g. a button inside the touchscreen area.
         */
        list_for_each(ptr, list) {
                segment = list_entry(ptr, struct touch_overlay_segment, list);
                if (segment->key &&
                    touch_overlay_button_event(input, segment, pos, slot))
                        return true;
        }

        /*
         * valid contacts on the overlay touchscreen are left for the client
         * to be processed/reported according to its (possibly) unique features.
         */
        return !touch_overlay_event_on_ts(list, pos);
}
EXPORT_SYMBOL(touch_overlay_process_contact);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Helper functions for overlay objects on touch devices");