linux/drivers/gpu/drm/tilcdc/tilcdc_panel_legacy.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2025 Bootlin
 * Author: Kory Maincent <kory.maincent@bootlin.com>
 *
 * To support the legacy "ti,tilcdc,panel" binding, the devicetree has to
 * be transformed to the new panel-dpi binding with the endpoint associated.
 */

#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/slab.h>

/* Embedded dtbo symbols created by cmd_wrap_S_dtb in scripts/Makefile.lib */
extern char __dtbo_tilcdc_panel_legacy_begin[];
extern char __dtbo_tilcdc_panel_legacy_end[];

static int __init
tilcdc_panel_update_prop(struct of_changeset *ocs, struct device_node *node,
			 char *name, void *val, int length)
{
	struct property *prop;

	prop = kzalloc_obj(*prop);
	if (!prop)
		return -ENOMEM;

	prop->name = kstrdup(name, GFP_KERNEL);
	prop->length = length;
	prop->value = kmemdup(val, length, GFP_KERNEL);
	if (!prop->name || !prop->value) {
		kfree(prop->name);
		kfree(prop->value);
		kfree(prop);
		return -ENOMEM;
	}

	return of_changeset_update_property(ocs, node, prop);
}

static int __init tilcdc_panel_copy_props(struct device_node *old_panel,
					  struct device_node *new_panel)
{
	struct device_node *old_timing __free(device_node) = NULL;
	struct device_node *new_timing __free(device_node) = NULL;
	struct device_node *panel_info __free(device_node) = NULL;
	struct device_node *child __free(device_node) = NULL;
	u32 invert_pxl_clk = 0, sync_edge = 0;
	struct of_changeset ocs;
	struct property *prop;
	int ret;

	child = of_get_child_by_name(old_panel, "display-timings");
	if (!child)
		return -EINVAL;

	/* The default display timing is the one specified as native-mode.
	 * If no native-mode is specified then the first node is assumed
	 * to be the native mode.
	 */
	old_timing = of_parse_phandle(child, "native-mode", 0);
	if (!old_timing) {
		old_timing = of_get_next_child(child, NULL);
		if (!old_timing)
			return -EINVAL;
	}

	panel_info = of_get_child_by_name(old_panel, "panel-info");
	if (!panel_info)
		return -EINVAL;

	of_changeset_init(&ocs);

	/* Copy all panel properties to the new panel node */
	for_each_property_of_node(old_panel, prop) {
		if (!strncmp(prop->name, "compatible", sizeof("compatible")))
			continue;

		ret = tilcdc_panel_update_prop(&ocs, new_panel, prop->name,
					       prop->value, prop->length);
		if (ret)
			goto destroy_ocs;
	}

	new_timing = of_changeset_create_node(&ocs, new_panel, "panel-timing");
	if (!new_timing) {
		ret = -ENODEV;
		goto destroy_ocs;
	}

	/* Copy all panel timing properties to the new panel node */
	for_each_property_of_node(old_timing, prop) {
		ret = tilcdc_panel_update_prop(&ocs, new_timing, prop->name,
					       prop->value, prop->length);
		if (ret)
			goto destroy_ocs;
	}

	/* Looked only for these two parameter as all the other are always
	 * set to default and not related to common DRM properties.
	 */
	of_property_read_u32(panel_info, "invert-pxl-clk", &invert_pxl_clk);
	of_property_read_u32(panel_info, "sync-edge", &sync_edge);

	if (!invert_pxl_clk) {
		ret = tilcdc_panel_update_prop(&ocs, new_timing, "pixelclk-active",
					       &(__be32){cpu_to_be32(1)}, sizeof(__be32));
		if (ret)
			goto destroy_ocs;
	}

	if (!sync_edge) {
		ret = tilcdc_panel_update_prop(&ocs, new_timing, "syncclk-active",
					       &(__be32){cpu_to_be32(1)}, sizeof(__be32));
		if (ret)
			goto destroy_ocs;
	}

	/* Remove compatible property to avoid any driver compatible match */
	of_changeset_remove_property(&ocs, old_panel,
				     of_find_property(old_panel, "compatible", NULL));

	of_changeset_apply(&ocs);
	return 0;

destroy_ocs:
	of_changeset_destroy(&ocs);
	return ret;
}

static const struct of_device_id tilcdc_panel_of_match[] __initconst = {
	{ .compatible = "ti,tilcdc,panel", },
	{},
};

static const struct of_device_id tilcdc_of_match[] __initconst = {
	{ .compatible = "ti,am33xx-tilcdc", },
	{ .compatible = "ti,da850-tilcdc", },
	{},
};

static int __init tilcdc_panel_legacy_init(void)
{
	struct device_node *new_panel __free(device_node) = NULL;
	struct device_node *panel __free(device_node) = NULL;
	struct device_node *lcdc __free(device_node) = NULL;
	void *dtbo_start;
	u32 dtbo_size;
	int ovcs_id;
	int ret;

	lcdc = of_find_matching_node(NULL, tilcdc_of_match);
	panel = of_find_matching_node(NULL, tilcdc_panel_of_match);

	if (!of_device_is_available(panel) ||
	    !of_device_is_available(lcdc))
		return 0;

	dtbo_start = __dtbo_tilcdc_panel_legacy_begin;
	dtbo_size = __dtbo_tilcdc_panel_legacy_end -
		    __dtbo_tilcdc_panel_legacy_begin;

	ret = of_overlay_fdt_apply(dtbo_start, dtbo_size, &ovcs_id, NULL);
	if (ret)
		return ret;

	new_panel = of_find_node_by_name(NULL, "tilcdc-panel-dpi");
	if (!new_panel) {
		ret = -ENODEV;
		goto overlay_remove;
	}

	ret = tilcdc_panel_copy_props(panel, new_panel);
	if (ret)
		goto overlay_remove;

	return 0;

overlay_remove:
	of_overlay_remove(&ovcs_id);
	return ret;
}

subsys_initcall(tilcdc_panel_legacy_init);