// SPDX-License-Identifier: GPL-2.0-only OR MIT
/* Copyright The Asahi Linux Contributors */

#include <drm/drm_modes.h>
#include <drm/drm_rect.h>

#include "dcp-internal.h"

struct apple_dcp;

typedef void (*dcp_callback_t)(struct apple_dcp *, void *, void *);


#define DCP_THUNK_VOID(func, handle)                                         \
	static void func(struct apple_dcp *dcp, bool oob, dcp_callback_t cb, \
			 void *cookie)                                       \
	{                                                                    \
		dcp_push(dcp, oob, &dcp_methods[handle], 0, 0, NULL, cb, cookie);          \
	}

#define DCP_THUNK_OUT(func, handle, T)                                       \
	static void func(struct apple_dcp *dcp, bool oob, dcp_callback_t cb, \
			 void *cookie)                                       \
	{                                                                    \
		dcp_push(dcp, oob, &dcp_methods[handle], 0, sizeof(T), NULL, cb, cookie);  \
	}

#define DCP_THUNK_IN(func, handle, T)                                       \
	static void func(struct apple_dcp *dcp, bool oob, T *data,          \
			 dcp_callback_t cb, void *cookie)                   \
	{                                                                   \
		dcp_push(dcp, oob, &dcp_methods[handle], sizeof(T), 0, data, cb, cookie); \
	}

#define DCP_THUNK_INOUT(func, handle, T_in, T_out)                            \
	static void func(struct apple_dcp *dcp, bool oob, T_in *data,         \
			 dcp_callback_t cb, void *cookie)                     \
	{                                                                     \
		dcp_push(dcp, oob, &dcp_methods[handle], sizeof(T_in), sizeof(T_out), data, \
			 cb, cookie);                                         \
	}

#define IOMFB_THUNK_INOUT(name)                                     \
	static void iomfb_ ## name(struct apple_dcp *dcp, bool oob, \
			struct iomfb_ ## name ## _req *data,        \
			dcp_callback_t cb, void *cookie)            \
	{                                                           \
		dcp_push(dcp, oob, &dcp_methods[iomfbep_ ## name],                \
			 sizeof(struct iomfb_ ## name ## _req),     \
			 sizeof(struct iomfb_ ## name ## _resp),    \
			 data,  cb, cookie);                        \
	}

/*
 * Define type-safe trampolines. Define typedefs to enforce type-safety on the
 * input data (so if the types don't match, gcc errors out).
 */

#define TRAMPOLINE_VOID(func, handler)                                        \
	static bool __maybe_unused func(struct apple_dcp *dcp, int tag, void *out, void *in) \
	{                                                                     \
		trace_iomfb_callback(dcp, tag, #handler);                     \
		handler(dcp);                                                 \
		return true;                                                  \
	}

#define TRAMPOLINE_IN(func, handler, T_in)                                    \
	typedef void (*callback_##handler)(struct apple_dcp *, T_in *);       \
                                                                              \
	static bool __maybe_unused func(struct apple_dcp *dcp, int tag, void *out, void *in) \
	{                                                                     \
		callback_##handler cb = handler;                              \
                                                                              \
		trace_iomfb_callback(dcp, tag, #handler);                     \
		cb(dcp, in);                                                  \
		return true;                                                  \
	}

#define TRAMPOLINE_INOUT(func, handler, T_in, T_out)                          \
	typedef T_out (*callback_##handler)(struct apple_dcp *, T_in *);      \
                                                                              \
	static bool __maybe_unused func(struct apple_dcp *dcp, int tag, void *out, void *in) \
	{                                                                     \
		T_out *typed_out = out;                                       \
		callback_##handler cb = handler;                              \
                                                                              \
		trace_iomfb_callback(dcp, tag, #handler);                     \
		*typed_out = cb(dcp, in);                                     \
		return true;                                                  \
	}

#define TRAMPOLINE_OUT(func, handler, T_out)                                  \
	static bool __maybe_unused func(struct apple_dcp *dcp, int tag, void *out, void *in) \
	{                                                                     \
		T_out *typed_out = out;                                       \
                                                                              \
		trace_iomfb_callback(dcp, tag, #handler);                     \
		*typed_out = handler(dcp);                                    \
		return true;                                                  \
	}

/* Call a DCP function given by a tag */
void dcp_push(struct apple_dcp *dcp, bool oob, const struct dcp_method_entry *call,
		     u32 in_len, u32 out_len, void *data, dcp_callback_t cb,
		     void *cookie);

/* Parse a callback tag "D123" into the ID 123. Returns -EINVAL on failure. */
int dcp_parse_tag(char tag[4]);

void dcp_ack(struct apple_dcp *dcp, enum dcp_context_id context);

/*
 * DRM specifies rectangles as start and end coordinates.  DCP specifies
 * rectangles as a start coordinate and a width/height. Convert a DRM rectangle
 * to a DCP rectangle.
 */
struct dcp_rect drm_to_dcp_rect(struct drm_rect *rect);

u32 drm_format_to_dcp(u32 drm);

/* The user may own drm_display_mode, so we need to search for our copy */
struct dcp_display_mode *lookup_mode(struct apple_dcp *dcp,
					    const struct drm_display_mode *mode);