xref: /rk3399_rockchip-uboot/drivers/video/drm/drm_of.c (revision e60b026785da96e7717a915cc49de297f487d63f)

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2023 Rockchip Electronics Co., Ltd
 *
 */
#include <dm/device.h>
#include <dm/read.h>

#include "drm_of.h"

enum drm_of_lvds_pixels {
	DRM_OF_LVDS_EVEN = BIT(0),
	DRM_OF_LVDS_ODD = BIT(1),
	DRM_OF_LVDS_LEFT = BIT(2),
	DRM_OF_LVDS_RIGHT = BIT(3),
};

static int
drm_of_lvds_get_port_pixels_type(const struct device_node *port_node)
{
	ofnode node = np_to_ofnode(port_node);

	bool even_pixels =
		ofnode_read_bool(node, "dual-lvds-even-pixels");
	bool odd_pixels =
		ofnode_read_bool(node, "dual-lvds-odd-pixels");
	bool left_pixels =
		ofnode_read_bool(node, "dual-lvds-left-pixels");
	bool right_pixels =
		ofnode_read_bool(node, "dual-lvds-right-pixels");

	return (even_pixels ? DRM_OF_LVDS_EVEN : 0) |
		   (odd_pixels ? DRM_OF_LVDS_ODD : 0) |
		   (left_pixels ? DRM_OF_LVDS_LEFT : 0) |
		   (right_pixels ? DRM_OF_LVDS_RIGHT : 0);
}

static int
drm_of_lvds_get_remote_pixels_type(const struct device_node *port_node)
{
	ofnode node = np_to_ofnode(port_node);
	ofnode endpoint;
	uint phandle;
	int pixels_type = -EPIPE;

	ofnode_for_each_subnode(endpoint, node) {
		int current_pt;
		const char *name;

		if (!ofnode_is_available(endpoint))
			continue;

		name = ofnode_get_name(endpoint);
		if (strncmp(name, "endpoint", 8) != 0)
			continue;

		if (ofnode_read_u32(endpoint, "remote-endpoint", &phandle))
			continue;

		endpoint = ofnode_get_by_phandle(phandle);
		if (!ofnode_valid(endpoint) || !ofnode_is_available(endpoint))
			continue;

		endpoint = ofnode_get_parent(endpoint);
		if (!ofnode_valid(endpoint))
			continue;

		current_pt =
			drm_of_lvds_get_port_pixels_type(ofnode_to_np(endpoint
				));
		if (pixels_type < 0)
			pixels_type = current_pt;

		/*
		 * Sanity check, ensure that all remote endpoints have the same
		 * pixel type. We may lift this restriction later if we need to
		 * support multiple sinks with different dual-link
		 * configurations by passing the endpoints explicitly to
		 * drm_of_lvds_get_dual_link_pixel_order().
		 */
		if (!current_pt || pixels_type != current_pt)
			return -EINVAL;
	}

	return pixels_type;
}

/**
 * drm_of_lvds_get_dual_link_pixel_order - Get LVDS dual-link pixel order
 * @port1: First DT port node of the Dual-link LVDS source
 * @port2: Second DT port node of the Dual-link LVDS source
 *
 * An LVDS dual-link connection is made of two links, the two link can transmit
 * odd pixels and even pixels independently, or the two link can also transmit
 * left pixels and right pixels independently. This function returns for two
 * ports of an LVDS dual-link source, based on the requirements of the connected
 * sink.
 *
 * The pixel order is determined from the dual-lvds-even-pixels +
 * dual-lvds-odd-pixels or dual-lvds-left-pixels + dual-lvds-right-pixels
 * properties in the sink's DT port nodes. If those
 * properties are not present, or if their usage is not valid, this function
 * returns -EINVAL.
 *
 * If either port is not connected, this function returns -EPIPE.
 *
 * @port1 and @port2 are typically DT sibling nodes, but may have different
 * parents when, for instance, two separate LVDS encoders carry the even and
 * odd pixels.
 *
 * Return:
 * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 carries even pixels and @port2
 *   carries odd pixels
 * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 carries odd pixels and @port2
 *   carries even pixels
 * * DRM_LVDS_DUAL_LINK_LEFT_RIGHT_PIXELS - @port1 carries left pixels and
 *   @port2 carries right pixels
 * * DRM_LVDS_DUAL_LINK_RIGHT_LEFT_PIXELS - @port1 carries right pixels and
 *   @port2 carries left pixels

 * * -EINVAL - @port1 and @port2 are not connected to a dual-link LVDS sink, or
 *   the sink configuration is invalid
 * * -EPIPE - when @port1 or @port2 are not connected
 */
int drm_of_lvds_get_dual_link_pixel_order(const struct device_node *port1,
					  const struct device_node *port2)
{
	int remote_p1_pt, remote_p2_pt;

	if (!port1 || !port2)
		return -EINVAL;

	remote_p1_pt = drm_of_lvds_get_remote_pixels_type(port1);
	if (remote_p1_pt < 0)
		return remote_p1_pt;

	remote_p2_pt = drm_of_lvds_get_remote_pixels_type(port2);
	if (remote_p2_pt < 0)
		return remote_p2_pt;

	/*
	 * A valid dual-lVDS bus is found when one remote port is marked with
	 * "dual-lvds-even-pixels" or "dual-lvds-left-pixels", and the other
	 * remote port is marked with "dual-lvds-odd-pixels"or
	 * "dual-lvds-right-pixels", bail out if the markers are not right.
	 */
	if ((remote_p1_pt + remote_p2_pt !=
		DRM_OF_LVDS_EVEN + DRM_OF_LVDS_ODD) &&
		(remote_p1_pt + remote_p2_pt !=
		DRM_OF_LVDS_LEFT + DRM_OF_LVDS_RIGHT))
		return -EINVAL;

	if (remote_p1_pt == DRM_OF_LVDS_EVEN)
		return DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS;
	else if (remote_p1_pt == DRM_OF_LVDS_ODD)
		return DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS;
	else if (remote_p1_pt == DRM_OF_LVDS_LEFT)
		return DRM_LVDS_DUAL_LINK_LEFT_RIGHT_PIXELS;
	else
		return DRM_LVDS_DUAL_LINK_RIGHT_LEFT_PIXELS;
}