// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2021-2023 Digiteq Automotive
 *     author: Martin Tuma <martin.tuma@digiteqautomotive.com>
 *
 * This module handles the IIO trigger device. The card has two signal inputs
 * for event triggers that can be used to record events related to the video
 * stream. A standard linux IIO device with triggered buffer capability is
 * created and configured that can be used to fetch the events with the same
 * clock source as the video frames.
 */

#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/pci.h>
#include <linux/dma/amd_xdma.h>
#include <linux/types.h>
#include "mgb4_core.h"
#include "mgb4_trigger.h"

struct trigger_data {
        struct mgb4_dev *mgbdev;
        struct iio_trigger *trig;
};

static int trigger_read_raw(struct iio_dev *indio_dev,
                            struct iio_chan_spec const *chan, int *val,
                            int *val2, long mask)
{
        struct trigger_data *st = iio_priv(indio_dev);

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                if (iio_buffer_enabled(indio_dev))
                        return -EBUSY;
                *val = mgb4_read_reg(&st->mgbdev->video, 0xA0);

                return IIO_VAL_INT;
        }

        return -EINVAL;
}

static int trigger_set_state(struct iio_trigger *trig, bool state)
{
        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
        struct trigger_data *st = iio_priv(indio_dev);
        int irq = xdma_get_user_irq(st->mgbdev->xdev, 11);

        if (state)
                xdma_enable_user_irq(st->mgbdev->xdev, irq);
        else
                xdma_disable_user_irq(st->mgbdev->xdev, irq);

        return 0;
}

static const struct iio_trigger_ops trigger_ops = {
        .set_trigger_state = &trigger_set_state,
};

static const struct iio_info trigger_info = {
        .read_raw         = trigger_read_raw,
};

#define TRIGGER_CHANNEL(_si) {                    \
        .type = IIO_ACTIVITY,                         \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
        .scan_index = _si,                            \
        .scan_type = {                                \
                .sign = 'u',                              \
                .realbits = 32,                           \
                .storagebits = 32,                        \
                .shift = 0,                               \
                .endianness = IIO_CPU                     \
        },                                            \
}

static const struct iio_chan_spec trigger_channels[] = {
        TRIGGER_CHANNEL(0),
        IIO_CHAN_SOFT_TIMESTAMP(1),
};

static irqreturn_t trigger_handler(int irq, void *p)
{
        struct iio_poll_func *pf = p;
        struct iio_dev *indio_dev = pf->indio_dev;
        struct trigger_data *st = iio_priv(indio_dev);
        struct {
                u32 data;
                aligned_s64 ts;
        } scan = { };

        scan.data = mgb4_read_reg(&st->mgbdev->video, 0xA0);
        mgb4_write_reg(&st->mgbdev->video, 0xA0, scan.data);

        iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), pf->timestamp);
        iio_trigger_notify_done(indio_dev->trig);

        mgb4_write_reg(&st->mgbdev->video, 0xB4, 1U << 11);

        return IRQ_HANDLED;
}

static int probe_trigger(struct iio_dev *indio_dev, int irq)
{
        int ret;
        struct trigger_data *st = iio_priv(indio_dev);

        st->trig = iio_trigger_alloc(&st->mgbdev->pdev->dev, "%s-dev%d",
                                     indio_dev->name, iio_device_id(indio_dev));
        if (!st->trig)
                return -ENOMEM;

        ret = request_irq(irq, &iio_trigger_generic_data_rdy_poll, IRQF_NO_THREAD,
                          "mgb4-trigger", st->trig);
        if (ret)
                goto error_free_trig;

        st->trig->ops = &trigger_ops;
        iio_trigger_set_drvdata(st->trig, indio_dev);
        ret = iio_trigger_register(st->trig);
        if (ret)
                goto error_free_irq;

        indio_dev->trig = iio_trigger_get(st->trig);

        return 0;

error_free_irq:
        free_irq(irq, st->trig);
error_free_trig:
        iio_trigger_free(st->trig);

        return ret;
}

static void remove_trigger(struct iio_dev *indio_dev, int irq)
{
        struct trigger_data *st = iio_priv(indio_dev);

        iio_trigger_unregister(st->trig);
        free_irq(irq, st->trig);
        iio_trigger_free(st->trig);
}

struct iio_dev *mgb4_trigger_create(struct mgb4_dev *mgbdev)
{
        struct iio_dev *indio_dev;
        struct trigger_data *data;
        struct pci_dev *pdev = mgbdev->pdev;
        struct device *dev = &pdev->dev;
        int rv, irq;

        indio_dev = iio_device_alloc(dev, sizeof(*data));
        if (!indio_dev)
                return NULL;

        indio_dev->info = &trigger_info;
        indio_dev->name = "mgb4";
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->channels = trigger_channels;
        indio_dev->num_channels = ARRAY_SIZE(trigger_channels);

        data = iio_priv(indio_dev);
        data->mgbdev = mgbdev;

        irq = xdma_get_user_irq(mgbdev->xdev, 11);
        rv = probe_trigger(indio_dev, irq);
        if (rv < 0) {
                dev_err(dev, "iio triggered setup failed\n");
                goto error_alloc;
        }
        rv = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
                                        trigger_handler, NULL);
        if (rv < 0) {
                dev_err(dev, "iio triggered buffer setup failed\n");
                goto error_trigger;
        }
        rv = iio_device_register(indio_dev);
        if (rv < 0) {
                dev_err(dev, "iio device register failed\n");
                goto error_buffer;
        }

        return indio_dev;

error_buffer:
        iio_triggered_buffer_cleanup(indio_dev);
error_trigger:
        remove_trigger(indio_dev, irq);
error_alloc:
        iio_device_free(indio_dev);

        return NULL;
}

void mgb4_trigger_free(struct iio_dev *indio_dev)
{
        struct trigger_data *st = iio_priv(indio_dev);

        iio_device_unregister(indio_dev);
        iio_triggered_buffer_cleanup(indio_dev);
        remove_trigger(indio_dev, xdma_get_user_irq(st->mgbdev->xdev, 11));
        iio_device_free(indio_dev);
}