1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2021-2023 Digiteq Automotive
  4 *     author: Martin Tuma <martin.tuma@digiteqautomotive.com>
  5 *
  6 * This module handles the IIO trigger device. The card has two signal inputs
  7 * for event triggers that can be used to record events related to the video
  8 * stream. A standard linux IIO device with triggered buffer capability is
  9 * created and configured that can be used to fetch the events with the same
 10 * clock source as the video frames.
 11 */
 12
 13#include <linux/iio/iio.h>
 14#include <linux/iio/buffer.h>
 15#include <linux/iio/trigger.h>
 16#include <linux/iio/trigger_consumer.h>
 17#include <linux/iio/triggered_buffer.h>
 18#include <linux/pci.h>
 19#include <linux/dma/amd_xdma.h>
 20#include "mgb4_core.h"
 21#include "mgb4_trigger.h"
 22
 23struct trigger_data {
 24	struct mgb4_dev *mgbdev;
 25	struct iio_trigger *trig;
 26};
 27
 28static int trigger_read_raw(struct iio_dev *indio_dev,
 29			    struct iio_chan_spec const *chan, int *val,
 30			    int *val2, long mask)
 31{
 32	struct trigger_data *st = iio_priv(indio_dev);
 33
 34	switch (mask) {
 35	case IIO_CHAN_INFO_RAW:
 36		if (iio_buffer_enabled(indio_dev))
 37			return -EBUSY;
 38		*val = mgb4_read_reg(&st->mgbdev->video, 0xA0);
 39
 40		return IIO_VAL_INT;
 41	}
 42
 43	return -EINVAL;
 44}
 45
 46static int trigger_set_state(struct iio_trigger *trig, bool state)
 47{
 48	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 49	struct trigger_data *st = iio_priv(indio_dev);
 50	int irq = xdma_get_user_irq(st->mgbdev->xdev, 11);
 51
 52	if (state)
 53		xdma_enable_user_irq(st->mgbdev->xdev, irq);
 54	else
 55		xdma_disable_user_irq(st->mgbdev->xdev, irq);
 56
 57	return 0;
 58}
 59
 60static const struct iio_trigger_ops trigger_ops = {
 61	.set_trigger_state = &trigger_set_state,
 62};
 63
 64static const struct iio_info trigger_info = {
 65	.read_raw         = trigger_read_raw,
 66};
 67
 68#define TRIGGER_CHANNEL(_si) {                    \
 69	.type = IIO_ACTIVITY,                         \
 70	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 71	.scan_index = _si,                            \
 72	.scan_type = {                                \
 73		.sign = 'u',                              \
 74		.realbits = 32,                           \
 75		.storagebits = 32,                        \
 76		.shift = 0,                               \
 77		.endianness = IIO_CPU                     \
 78	},                                            \
 79}
 80
 81static const struct iio_chan_spec trigger_channels[] = {
 82	TRIGGER_CHANNEL(0),
 83	IIO_CHAN_SOFT_TIMESTAMP(1),
 84};
 85
 86static irqreturn_t trigger_handler(int irq, void *p)
 87{
 88	struct iio_poll_func *pf = p;
 89	struct iio_dev *indio_dev = pf->indio_dev;
 90	struct trigger_data *st = iio_priv(indio_dev);
 91	struct {
 92		u32 data;
 93		s64 ts __aligned(8);
 94	} scan;
 95
 96	scan.data = mgb4_read_reg(&st->mgbdev->video, 0xA0);
 97	mgb4_write_reg(&st->mgbdev->video, 0xA0, scan.data);
 98
 99	iio_push_to_buffers_with_timestamp(indio_dev, &scan, pf->timestamp);
100	iio_trigger_notify_done(indio_dev->trig);
101
102	mgb4_write_reg(&st->mgbdev->video, 0xB4, 1U << 11);
103
104	return IRQ_HANDLED;
105}
106
107static int probe_trigger(struct iio_dev *indio_dev, int irq)
108{
109	int ret;
110	struct trigger_data *st = iio_priv(indio_dev);
111
112	st->trig = iio_trigger_alloc(&st->mgbdev->pdev->dev, "%s-dev%d",
113				     indio_dev->name, iio_device_id(indio_dev));
114	if (!st->trig)
115		return -ENOMEM;
116
117	ret = request_irq(irq, &iio_trigger_generic_data_rdy_poll, 0,
118			  "mgb4-trigger", st->trig);
119	if (ret)
120		goto error_free_trig;
121
122	st->trig->ops = &trigger_ops;
123	iio_trigger_set_drvdata(st->trig, indio_dev);
124	ret = iio_trigger_register(st->trig);
125	if (ret)
126		goto error_free_irq;
127
128	indio_dev->trig = iio_trigger_get(st->trig);
129
130	return 0;
131
132error_free_irq:
133	free_irq(irq, st->trig);
134error_free_trig:
135	iio_trigger_free(st->trig);
136
137	return ret;
138}
139
140static void remove_trigger(struct iio_dev *indio_dev, int irq)
141{
142	struct trigger_data *st = iio_priv(indio_dev);
143
144	iio_trigger_unregister(st->trig);
145	free_irq(irq, st->trig);
146	iio_trigger_free(st->trig);
147}
148
149struct iio_dev *mgb4_trigger_create(struct mgb4_dev *mgbdev)
150{
151	struct iio_dev *indio_dev;
152	struct trigger_data *data;
153	struct pci_dev *pdev = mgbdev->pdev;
154	struct device *dev = &pdev->dev;
155	int rv, irq;
156
157	indio_dev = iio_device_alloc(dev, sizeof(*data));
158	if (!indio_dev)
159		return NULL;
160
161	indio_dev->info = &trigger_info;
162	indio_dev->name = "mgb4";
163	indio_dev->modes = INDIO_DIRECT_MODE;
164	indio_dev->channels = trigger_channels;
165	indio_dev->num_channels = ARRAY_SIZE(trigger_channels);
166
167	data = iio_priv(indio_dev);
168	data->mgbdev = mgbdev;
169
170	irq = xdma_get_user_irq(mgbdev->xdev, 11);
171	rv = probe_trigger(indio_dev, irq);
172	if (rv < 0) {
173		dev_err(dev, "iio triggered setup failed\n");
174		goto error_alloc;
175	}
176	rv = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
177					trigger_handler, NULL);
178	if (rv < 0) {
179		dev_err(dev, "iio triggered buffer setup failed\n");
180		goto error_trigger;
181	}
182	rv = iio_device_register(indio_dev);
183	if (rv < 0) {
184		dev_err(dev, "iio device register failed\n");
185		goto error_buffer;
186	}
187
188	return indio_dev;
189
190error_buffer:
191	iio_triggered_buffer_cleanup(indio_dev);
192error_trigger:
193	remove_trigger(indio_dev, irq);
194error_alloc:
195	iio_device_free(indio_dev);
196
197	return NULL;
198}
199
200void mgb4_trigger_free(struct iio_dev *indio_dev)
201{
202	struct trigger_data *st = iio_priv(indio_dev);
203
204	iio_device_unregister(indio_dev);
205	iio_triggered_buffer_cleanup(indio_dev);
206	remove_trigger(indio_dev, xdma_get_user_irq(st->mgbdev->xdev, 11));
207	iio_device_free(indio_dev);
208}