1/*
  2 * Copyright (C) 2015 Free Electrons
  3 * Copyright (C) 2015 NextThing Co
  4 *
  5 * Maxime Ripard <maxime.ripard@free-electrons.com>
  6 *
  7 * This program is free software; you can redistribute it and/or
  8 * modify it under the terms of the GNU General Public License as
  9 * published by the Free Software Foundation; either version 2 of
 10 * the License, or (at your option) any later version.
 11 */
 12
 13#include <drm/drmP.h>
 14#include <drm/drm_atomic_helper.h>
 15#include <drm/drm_crtc.h>
 16#include <drm/drm_crtc_helper.h>
 17#include <drm/drm_modes.h>
 18
 19#include <linux/clk-provider.h>
 20#include <linux/ioport.h>
 21#include <linux/of_address.h>
 22#include <linux/of_graph.h>
 23#include <linux/of_irq.h>
 24#include <linux/regmap.h>
 25
 26#include <video/videomode.h>
 27
 28#include "sun4i_backend.h"
 29#include "sun4i_crtc.h"
 30#include "sun4i_drv.h"
 31#include "sunxi_engine.h"
 32#include "sun4i_tcon.h"
 33
 34/*
 35 * While this isn't really working in the DRM theory, in practice we
 36 * can only ever have one encoder per TCON since we have a mux in our
 37 * TCON.
 38 */
 39static struct drm_encoder *sun4i_crtc_get_encoder(struct drm_crtc *crtc)
 40{
 41	struct drm_encoder *encoder;
 42
 43	drm_for_each_encoder(encoder, crtc->dev)
 44		if (encoder->crtc == crtc)
 45			return encoder;
 46
 47	return NULL;
 48}
 49
 50static int sun4i_crtc_atomic_check(struct drm_crtc *crtc,
 51				    struct drm_crtc_state *state)
 52{
 53	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 54	struct sunxi_engine *engine = scrtc->engine;
 55	int ret = 0;
 56
 57	if (engine && engine->ops && engine->ops->atomic_check)
 58		ret = engine->ops->atomic_check(engine, state);
 59
 60	return ret;
 61}
 62
 63static void sun4i_crtc_atomic_begin(struct drm_crtc *crtc,
 64				    struct drm_crtc_state *old_state)
 65{
 66	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 67	struct drm_device *dev = crtc->dev;
 68	struct sunxi_engine *engine = scrtc->engine;
 69	unsigned long flags;
 70
 71	if (crtc->state->event) {
 72		WARN_ON(drm_crtc_vblank_get(crtc) != 0);
 73
 74		spin_lock_irqsave(&dev->event_lock, flags);
 75		scrtc->event = crtc->state->event;
 76		spin_unlock_irqrestore(&dev->event_lock, flags);
 77		crtc->state->event = NULL;
 78	}
 79
 80	if (engine->ops->atomic_begin)
 81		engine->ops->atomic_begin(engine, old_state);
 82}
 83
 84static void sun4i_crtc_atomic_flush(struct drm_crtc *crtc,
 85				    struct drm_crtc_state *old_state)
 86{
 87	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
 88	struct drm_pending_vblank_event *event = crtc->state->event;
 89
 90	DRM_DEBUG_DRIVER("Committing plane changes\n");
 91
 92	sunxi_engine_commit(scrtc->engine);
 93
 94	if (event) {
 95		crtc->state->event = NULL;
 96
 97		spin_lock_irq(&crtc->dev->event_lock);
 98		if (drm_crtc_vblank_get(crtc) == 0)
 99			drm_crtc_arm_vblank_event(crtc, event);
100		else
101			drm_crtc_send_vblank_event(crtc, event);
102		spin_unlock_irq(&crtc->dev->event_lock);
103	}
104}
105
106static void sun4i_crtc_atomic_disable(struct drm_crtc *crtc,
107				      struct drm_crtc_state *old_state)
108{
109	struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
110	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
111
112	DRM_DEBUG_DRIVER("Disabling the CRTC\n");
113
114	drm_crtc_vblank_off(crtc);
115
116	sun4i_tcon_set_status(scrtc->tcon, encoder, false);
117
118	if (crtc->state->event && !crtc->state->active) {
119		spin_lock_irq(&crtc->dev->event_lock);
120		drm_crtc_send_vblank_event(crtc, crtc->state->event);
121		spin_unlock_irq(&crtc->dev->event_lock);
122
123		crtc->state->event = NULL;
124	}
125}
126
127static void sun4i_crtc_atomic_enable(struct drm_crtc *crtc,
128				     struct drm_crtc_state *old_state)
129{
130	struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
131	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
132
133	DRM_DEBUG_DRIVER("Enabling the CRTC\n");
134
135	sun4i_tcon_set_status(scrtc->tcon, encoder, true);
136
137	drm_crtc_vblank_on(crtc);
138}
139
140static void sun4i_crtc_mode_set_nofb(struct drm_crtc *crtc)
141{
142	struct drm_display_mode *mode = &crtc->state->adjusted_mode;
143	struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
144	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
145
146	sun4i_tcon_mode_set(scrtc->tcon, encoder, mode);
147}
148
149static const struct drm_crtc_helper_funcs sun4i_crtc_helper_funcs = {
150	.atomic_check	= sun4i_crtc_atomic_check,
151	.atomic_begin	= sun4i_crtc_atomic_begin,
152	.atomic_flush	= sun4i_crtc_atomic_flush,
153	.atomic_enable	= sun4i_crtc_atomic_enable,
154	.atomic_disable	= sun4i_crtc_atomic_disable,
155	.mode_set_nofb	= sun4i_crtc_mode_set_nofb,
156};
157
158static int sun4i_crtc_enable_vblank(struct drm_crtc *crtc)
159{
160	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
161
162	DRM_DEBUG_DRIVER("Enabling VBLANK on crtc %p\n", crtc);
163
164	sun4i_tcon_enable_vblank(scrtc->tcon, true);
165
166	return 0;
167}
168
169static void sun4i_crtc_disable_vblank(struct drm_crtc *crtc)
170{
171	struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
172
173	DRM_DEBUG_DRIVER("Disabling VBLANK on crtc %p\n", crtc);
174
175	sun4i_tcon_enable_vblank(scrtc->tcon, false);
176}
177
178static const struct drm_crtc_funcs sun4i_crtc_funcs = {
179	.atomic_destroy_state	= drm_atomic_helper_crtc_destroy_state,
180	.atomic_duplicate_state	= drm_atomic_helper_crtc_duplicate_state,
181	.destroy		= drm_crtc_cleanup,
182	.page_flip		= drm_atomic_helper_page_flip,
183	.reset			= drm_atomic_helper_crtc_reset,
184	.set_config		= drm_atomic_helper_set_config,
185	.enable_vblank		= sun4i_crtc_enable_vblank,
186	.disable_vblank		= sun4i_crtc_disable_vblank,
187};
188
189struct sun4i_crtc *sun4i_crtc_init(struct drm_device *drm,
190				   struct sunxi_engine *engine,
191				   struct sun4i_tcon *tcon)
192{
193	struct sun4i_crtc *scrtc;
194	struct drm_plane **planes;
195	struct drm_plane *primary = NULL, *cursor = NULL;
196	int ret, i;
197
198	scrtc = devm_kzalloc(drm->dev, sizeof(*scrtc), GFP_KERNEL);
199	if (!scrtc)
200		return ERR_PTR(-ENOMEM);
201	scrtc->engine = engine;
202	scrtc->tcon = tcon;
203
204	/* Create our layers */
205	planes = sunxi_engine_layers_init(drm, engine);
206	if (IS_ERR(planes)) {
207		dev_err(drm->dev, "Couldn't create the planes\n");
208		return NULL;
209	}
210
211	/* find primary and cursor planes for drm_crtc_init_with_planes */
212	for (i = 0; planes[i]; i++) {
213		struct drm_plane *plane = planes[i];
214
215		switch (plane->type) {
216		case DRM_PLANE_TYPE_PRIMARY:
217			primary = plane;
218			break;
219		case DRM_PLANE_TYPE_CURSOR:
220			cursor = plane;
221			break;
222		default:
223			break;
224		}
225	}
226
227	ret = drm_crtc_init_with_planes(drm, &scrtc->crtc,
228					primary,
229					cursor,
230					&sun4i_crtc_funcs,
231					NULL);
232	if (ret) {
233		dev_err(drm->dev, "Couldn't init DRM CRTC\n");
234		return ERR_PTR(ret);
235	}
236
237	drm_crtc_helper_add(&scrtc->crtc, &sun4i_crtc_helper_funcs);
238
239	/* Set crtc.port to output port node of the tcon */
240	scrtc->crtc.port = of_graph_get_port_by_id(scrtc->tcon->dev->of_node,
241						   1);
242
243	/* Set possible_crtcs to this crtc for overlay planes */
244	for (i = 0; planes[i]; i++) {
245		uint32_t possible_crtcs = BIT(drm_crtc_index(&scrtc->crtc));
246		struct drm_plane *plane = planes[i];
247
248		if (plane->type == DRM_PLANE_TYPE_OVERLAY)
249			plane->possible_crtcs = possible_crtcs;
250	}
251
252	return scrtc;
253}