1/*
  2 * Copyright (C) 2016 BayLibre, SAS
  3 * Author: Neil Armstrong <narmstrong@baylibre.com>
  4 * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
  5 * Copyright (C) 2014 Endless Mobile
  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 the
 10 * License, or (at your option) any later version.
 11 *
 12 * This program is distributed in the hope that it will be useful, but
 13 * WITHOUT ANY WARRANTY; without even the implied warranty of
 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15 * General Public License for more details.
 16 *
 17 * You should have received a copy of the GNU General Public License
 18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 19 *
 20 * Written by:
 21 *     Jasper St. Pierre <jstpierre@mecheye.net>
 22 */
 23
 24#include <linux/kernel.h>
 25#include <linux/module.h>
 26#include <linux/of_graph.h>
 27
 28#include <drm/drmP.h>
 29#include <drm/drm_edid.h>
 30#include <drm/drm_crtc_helper.h>
 31#include <drm/drm_atomic_helper.h>
 32
 33#include "meson_venc_cvbs.h"
 34#include "meson_venc.h"
 35#include "meson_registers.h"
 36
 37/* HHI VDAC Registers */
 38#define HHI_VDAC_CNTL0		0x2F4 /* 0xbd offset in data sheet */
 39#define HHI_VDAC_CNTL1		0x2F8 /* 0xbe offset in data sheet */
 40
 41struct meson_venc_cvbs {
 42	struct drm_encoder	encoder;
 43	struct drm_connector	connector;
 44	struct meson_drm	*priv;
 45};
 46#define encoder_to_meson_venc_cvbs(x) \
 47	container_of(x, struct meson_venc_cvbs, encoder)
 48
 49#define connector_to_meson_venc_cvbs(x) \
 50	container_of(x, struct meson_venc_cvbs, connector)
 51
 52/* Supported Modes */
 53
 54struct meson_cvbs_mode meson_cvbs_modes[MESON_CVBS_MODES_COUNT] = {
 55	{ /* PAL */
 56		.enci = &meson_cvbs_enci_pal,
 57		.mode = {
 58			DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500,
 59				 720, 732, 795, 864, 0, 576, 580, 586, 625, 0,
 60				 DRM_MODE_FLAG_INTERLACE),
 61			.vrefresh = 50,
 62			.picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
 63		},
 64	},
 65	{ /* NTSC */
 66		.enci = &meson_cvbs_enci_ntsc,
 67		.mode = {
 68			DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500,
 69				720, 739, 801, 858, 0, 480, 488, 494, 525, 0,
 70				DRM_MODE_FLAG_INTERLACE),
 71			.vrefresh = 60,
 72			.picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
 73		},
 74	},
 75};
 76
 77/* Connector */
 78
 79static void meson_cvbs_connector_destroy(struct drm_connector *connector)
 80{
 81	drm_connector_cleanup(connector);
 82}
 83
 84static enum drm_connector_status
 85meson_cvbs_connector_detect(struct drm_connector *connector, bool force)
 86{
 87	/* FIXME: Add load-detect or jack-detect if possible */
 88	return connector_status_connected;
 89}
 90
 91static int meson_cvbs_connector_get_modes(struct drm_connector *connector)
 92{
 93	struct drm_device *dev = connector->dev;
 94	struct drm_display_mode *mode;
 95	int i;
 96
 97	for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
 98		struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
 99
100		mode = drm_mode_duplicate(dev, &meson_mode->mode);
101		if (!mode) {
102			DRM_ERROR("Failed to create a new display mode\n");
103			return 0;
104		}
105
106		drm_mode_probed_add(connector, mode);
107	}
108
109	return i;
110}
111
112static int meson_cvbs_connector_mode_valid(struct drm_connector *connector,
113					   struct drm_display_mode *mode)
114{
115	/* Validate the modes added in get_modes */
116	return MODE_OK;
117}
118
119static const struct drm_connector_funcs meson_cvbs_connector_funcs = {
120	.dpms			= drm_atomic_helper_connector_dpms,
121	.detect			= meson_cvbs_connector_detect,
122	.fill_modes		= drm_helper_probe_single_connector_modes,
123	.destroy		= meson_cvbs_connector_destroy,
124	.reset			= drm_atomic_helper_connector_reset,
125	.atomic_duplicate_state	= drm_atomic_helper_connector_duplicate_state,
126	.atomic_destroy_state	= drm_atomic_helper_connector_destroy_state,
127};
128
129static const
130struct drm_connector_helper_funcs meson_cvbs_connector_helper_funcs = {
131	.get_modes	= meson_cvbs_connector_get_modes,
132	.mode_valid	= meson_cvbs_connector_mode_valid,
133};
134
135/* Encoder */
136
137static void meson_venc_cvbs_encoder_destroy(struct drm_encoder *encoder)
138{
139	drm_encoder_cleanup(encoder);
140}
141
142static const struct drm_encoder_funcs meson_venc_cvbs_encoder_funcs = {
143	.destroy        = meson_venc_cvbs_encoder_destroy,
144};
145
146static int meson_venc_cvbs_encoder_atomic_check(struct drm_encoder *encoder,
147					struct drm_crtc_state *crtc_state,
148					struct drm_connector_state *conn_state)
149{
150	int i;
151
152	for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
153		struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
154
155		if (drm_mode_equal(&crtc_state->mode, &meson_mode->mode))
156			return 0;
157	}
158
159	return -EINVAL;
160}
161
162static void meson_venc_cvbs_encoder_disable(struct drm_encoder *encoder)
163{
164	struct meson_venc_cvbs *meson_venc_cvbs =
165					encoder_to_meson_venc_cvbs(encoder);
166	struct meson_drm *priv = meson_venc_cvbs->priv;
167
168	/* Disable CVBS VDAC */
169	regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0);
170	regmap_write(priv->hhi, HHI_VDAC_CNTL1, 8);
171}
172
173static void meson_venc_cvbs_encoder_enable(struct drm_encoder *encoder)
174{
175	struct meson_venc_cvbs *meson_venc_cvbs =
176					encoder_to_meson_venc_cvbs(encoder);
177	struct meson_drm *priv = meson_venc_cvbs->priv;
178
179	/* VDAC0 source is not from ATV */
180	writel_bits_relaxed(BIT(5), 0, priv->io_base + _REG(VENC_VDAC_DACSEL0));
181
182	if (meson_vpu_is_compatible(priv, "amlogic,meson-gxbb-vpu"))
183		regmap_write(priv->hhi, HHI_VDAC_CNTL0, 1);
184	else if (meson_vpu_is_compatible(priv, "amlogic,meson-gxm-vpu") ||
185		 meson_vpu_is_compatible(priv, "amlogic,meson-gxl-vpu"))
186		regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0xf0001);
187
188	regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
189}
190
191static void meson_venc_cvbs_encoder_mode_set(struct drm_encoder *encoder,
192				   struct drm_display_mode *mode,
193				   struct drm_display_mode *adjusted_mode)
194{
195	struct meson_venc_cvbs *meson_venc_cvbs =
196					encoder_to_meson_venc_cvbs(encoder);
197	int i;
198
199	for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
200		struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
201
202		if (drm_mode_equal(mode, &meson_mode->mode)) {
203			meson_venci_cvbs_mode_set(meson_venc_cvbs->priv,
204						  meson_mode->enci);
205			break;
206		}
207	}
208}
209
210static const struct drm_encoder_helper_funcs
211				meson_venc_cvbs_encoder_helper_funcs = {
212	.atomic_check	= meson_venc_cvbs_encoder_atomic_check,
213	.disable	= meson_venc_cvbs_encoder_disable,
214	.enable		= meson_venc_cvbs_encoder_enable,
215	.mode_set	= meson_venc_cvbs_encoder_mode_set,
216};
217
218static bool meson_venc_cvbs_connector_is_available(struct meson_drm *priv)
219{
220	struct device_node *ep, *remote;
221
222	/* CVBS VDAC output is on the first port, first endpoint */
223	ep = of_graph_get_endpoint_by_regs(priv->dev->of_node, 0, 0);
224	if (!ep)
225		return false;
226
227
228	/* If the endpoint node exists, consider it enabled */
229	remote = of_graph_get_remote_port(ep);
230	if (remote) {
231		of_node_put(ep);
232		return true;
233	}
234
235	of_node_put(ep);
236	of_node_put(remote);
237
238	return false;
239}
240
241int meson_venc_cvbs_create(struct meson_drm *priv)
242{
243	struct drm_device *drm = priv->drm;
244	struct meson_venc_cvbs *meson_venc_cvbs;
245	struct drm_connector *connector;
246	struct drm_encoder *encoder;
247	int ret;
248
249	if (!meson_venc_cvbs_connector_is_available(priv)) {
250		dev_info(drm->dev, "CVBS Output connector not available\n");
251		return -ENODEV;
252	}
253
254	meson_venc_cvbs = devm_kzalloc(priv->dev, sizeof(*meson_venc_cvbs),
255				       GFP_KERNEL);
256	if (!meson_venc_cvbs)
257		return -ENOMEM;
258
259	meson_venc_cvbs->priv = priv;
260	encoder = &meson_venc_cvbs->encoder;
261	connector = &meson_venc_cvbs->connector;
262
263	/* Connector */
264
265	drm_connector_helper_add(connector,
266				 &meson_cvbs_connector_helper_funcs);
267
268	ret = drm_connector_init(drm, connector, &meson_cvbs_connector_funcs,
269				 DRM_MODE_CONNECTOR_Composite);
270	if (ret) {
271		dev_err(priv->dev, "Failed to init CVBS connector\n");
272		return ret;
273	}
274
275	connector->interlace_allowed = 1;
276
277	/* Encoder */
278
279	drm_encoder_helper_add(encoder, &meson_venc_cvbs_encoder_helper_funcs);
280
281	ret = drm_encoder_init(drm, encoder, &meson_venc_cvbs_encoder_funcs,
282			       DRM_MODE_ENCODER_TVDAC, "meson_venc_cvbs");
283	if (ret) {
284		dev_err(priv->dev, "Failed to init CVBS encoder\n");
285		return ret;
286	}
287
288	encoder->possible_crtcs = BIT(0);
289
290	drm_mode_connector_attach_encoder(connector, encoder);
291
292	return 0;
293}