LXR linux/drivers/gpu/drm/rcar-du/rcar_du

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * rcar_du_of.c - Legacy DT bindings compatibility
   4 *
   5 * Copyright (C) 2018 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   6 *
   7 * Based on work from Jyri Sarha <jsarha@ti.com>
   8 * Copyright (C) 2015 Texas Instruments
   9 */
  10
  11#include <linux/init.h>
  12#include <linux/kernel.h>
  13#include <linux/of.h>
  14#include <linux/of_address.h>
  15#include <linux/of_fdt.h>
  16#include <linux/of_graph.h>
  17#include <linux/slab.h>
  18
  19#include "rcar_du_crtc.h"
  20#include "rcar_du_drv.h"
  21#include "rcar_du_of.h"
  22
  23/* -----------------------------------------------------------------------------
  24 * Generic Overlay Handling
  25 */
  26
  27struct rcar_du_of_overlay {
  28        const char *compatible;
  29        void *begin;
  30        void *end;
  31};
  32
  33#define RCAR_DU_OF_DTB(type, soc)                                       \
  34        extern char __dtb_rcar_du_of_##type##_##soc##_begin[];          \
  35        extern char __dtb_rcar_du_of_##type##_##soc##_end[]
  36
  37#define RCAR_DU_OF_OVERLAY(type, soc)                                   \
  38        {                                                               \
  39                .compatible = "renesas,du-" #soc,                       \
  40                .begin = __dtb_rcar_du_of_##type##_##soc##_begin,       \
  41                .end = __dtb_rcar_du_of_##type##_##soc##_end,           \
  42        }
  43
  44static int __init rcar_du_of_apply_overlay(const struct rcar_du_of_overlay *dtbs,
  45                                           const char *compatible)
  46{
  47        const struct rcar_du_of_overlay *dtb = NULL;
  48        unsigned int i;
  49        int ovcs_id;
  50
  51        for (i = 0; dtbs[i].compatible; ++i) {
  52                if (!strcmp(dtbs[i].compatible, compatible)) {
  53                        dtb = &dtbs[i];
  54                        break;
  55                }
  56        }
  57
  58        if (!dtb)
  59                return -ENODEV;
  60
  61        ovcs_id = 0;
  62        return of_overlay_fdt_apply(dtb->begin, dtb->end - dtb->begin,
  63                                    &ovcs_id);
  64}
  65
  66static int __init rcar_du_of_add_property(struct of_changeset *ocs,
  67                                          struct device_node *np,
  68                                          const char *name, const void *value,
  69                                          int length)
  70{
  71        struct property *prop;
  72        int ret = -ENOMEM;
  73
  74        prop = kzalloc(sizeof(*prop), GFP_KERNEL);
  75        if (!prop)
  76                return -ENOMEM;
  77
  78        prop->name = kstrdup(name, GFP_KERNEL);
  79        if (!prop->name)
  80                goto out_err;
  81
  82        prop->value = kmemdup(value, length, GFP_KERNEL);
  83        if (!prop->value)
  84                goto out_err;
  85
  86        of_property_set_flag(prop, OF_DYNAMIC);
  87
  88        prop->length = length;
  89
  90        ret = of_changeset_add_property(ocs, np, prop);
  91        if (!ret)
  92                return 0;
  93
  94out_err:
  95        kfree(prop->value);
  96        kfree(prop->name);
  97        kfree(prop);
  98        return ret;
  99}
 100
 101/* -----------------------------------------------------------------------------
 102 * LVDS Overlays
 103 */
 104
 105RCAR_DU_OF_DTB(lvds, r8a7790);
 106RCAR_DU_OF_DTB(lvds, r8a7791);
 107RCAR_DU_OF_DTB(lvds, r8a7793);
 108RCAR_DU_OF_DTB(lvds, r8a7795);
 109RCAR_DU_OF_DTB(lvds, r8a7796);
 110
 111static const struct rcar_du_of_overlay rcar_du_lvds_overlays[] __initconst = {
 112        RCAR_DU_OF_OVERLAY(lvds, r8a7790),
 113        RCAR_DU_OF_OVERLAY(lvds, r8a7791),
 114        RCAR_DU_OF_OVERLAY(lvds, r8a7793),
 115        RCAR_DU_OF_OVERLAY(lvds, r8a7795),
 116        RCAR_DU_OF_OVERLAY(lvds, r8a7796),
 117        { /* Sentinel */ },
 118};
 119
 120static struct of_changeset rcar_du_lvds_changeset;
 121
 122static void __init rcar_du_of_lvds_patch_one(struct device_node *lvds,
 123                                             const struct of_phandle_args *clk,
 124                                             struct device_node *local,
 125                                             struct device_node *remote)
 126{
 127        unsigned int psize;
 128        unsigned int i;
 129        __be32 value[4];
 130        int ret;
 131
 132        /*
 133         * Set the LVDS clocks property. This can't be performed by the overlay
 134         * as the structure of the clock specifier has changed over time, and we
 135         * don't know at compile time which binding version the system we will
 136         * run on uses.
 137         */
 138        if (clk->args_count >= ARRAY_SIZE(value) - 1)
 139                return;
 140
 141        of_changeset_init(&rcar_du_lvds_changeset);
 142
 143        value[0] = cpu_to_be32(clk->np->phandle);
 144        for (i = 0; i < clk->args_count; ++i)
 145                value[i + 1] = cpu_to_be32(clk->args[i]);
 146
 147        psize = (clk->args_count + 1) * 4;
 148        ret = rcar_du_of_add_property(&rcar_du_lvds_changeset, lvds,
 149                                      "clocks", value, psize);
 150        if (ret < 0)
 151                goto done;
 152
 153        /*
 154         * Insert the node in the OF graph: patch the LVDS ports remote-endpoint
 155         * properties to point to the endpoints of the sibling nodes in the
 156         * graph. This can't be performed by the overlay: on the input side the
 157         * overlay would contain a phandle for the DU LVDS output port that
 158         * would clash with the system DT, and on the output side the connection
 159         * is board-specific.
 160         */
 161        value[0] = cpu_to_be32(local->phandle);
 162        value[1] = cpu_to_be32(remote->phandle);
 163
 164        for (i = 0; i < 2; ++i) {
 165                struct device_node *endpoint;
 166
 167                endpoint = of_graph_get_endpoint_by_regs(lvds, i, 0);
 168                if (!endpoint) {
 169                        ret = -EINVAL;
 170                        goto done;
 171                }
 172
 173                ret = rcar_du_of_add_property(&rcar_du_lvds_changeset,
 174                                              endpoint, "remote-endpoint",
 175                                              &value[i], sizeof(value[i]));
 176                of_node_put(endpoint);
 177                if (ret < 0)
 178                        goto done;
 179        }
 180
 181        ret = of_changeset_apply(&rcar_du_lvds_changeset);
 182
 183done:
 184        if (ret < 0)
 185                of_changeset_destroy(&rcar_du_lvds_changeset);
 186}
 187
 188struct lvds_of_data {
 189        struct resource res;
 190        struct of_phandle_args clkspec;
 191        struct device_node *local;
 192        struct device_node *remote;
 193};
 194
 195static void __init rcar_du_of_lvds_patch(const struct of_device_id *of_ids)
 196{
 197        const struct rcar_du_device_info *info;
 198        const struct of_device_id *match;
 199        struct lvds_of_data lvds_data[2] = { };
 200        struct device_node *lvds_node;
 201        struct device_node *soc_node;
 202        struct device_node *du_node;
 203        char compatible[22];
 204        const char *soc_name;
 205        unsigned int i;
 206        int ret;
 207
 208        /* Get the DU node and exit if not present or disabled. */
 209        du_node = of_find_matching_node_and_match(NULL, of_ids, &match);
 210        if (!du_node || !of_device_is_available(du_node)) {
 211                of_node_put(du_node);
 212                return;
 213        }
 214
 215        info = match->data;
 216        soc_node = of_get_parent(du_node);
 217
 218        if (WARN_ON(info->num_lvds > ARRAY_SIZE(lvds_data)))
 219                goto done;
 220
 221        /*
 222         * Skip if the LVDS nodes already exists.
 223         *
 224         * The nodes are searched based on the compatible string, which we
 225         * construct from the SoC name found in the DU compatible string. As a
 226         * match has been found we know the compatible string matches the
 227         * expected format and can thus skip some of the string manipulation
 228         * normal safety checks.
 229         */
 230        soc_name = strchr(match->compatible, '-') + 1;
 231        sprintf(compatible, "renesas,%s-lvds", soc_name);
 232        lvds_node = of_find_compatible_node(NULL, NULL, compatible);
 233        if (lvds_node) {
 234                of_node_put(lvds_node);
 235                return;
 236        }
 237
 238        /*
 239         * Parse the DU node and store the register specifier, the clock
 240         * specifier and the local and remote endpoint of the LVDS link for
 241         * later use.
 242         */
 243        for (i = 0; i < info->num_lvds; ++i) {
 244                struct lvds_of_data *lvds = &lvds_data[i];
 245                unsigned int port;
 246                char name[7];
 247                int index;
 248
 249                sprintf(name, "lvds.%u", i);
 250                index = of_property_match_string(du_node, "clock-names", name);
 251                if (index < 0)
 252                        continue;
 253
 254                ret = of_parse_phandle_with_args(du_node, "clocks",
 255                                                 "#clock-cells", index,
 256                                                 &lvds->clkspec);
 257                if (ret < 0)
 258                        continue;
 259
 260                port = info->routes[RCAR_DU_OUTPUT_LVDS0 + i].port;
 261
 262                lvds->local = of_graph_get_endpoint_by_regs(du_node, port, 0);
 263                if (!lvds->local)
 264                        continue;
 265
 266                lvds->remote = of_graph_get_remote_endpoint(lvds->local);
 267                if (!lvds->remote)
 268                        continue;
 269
 270                index = of_property_match_string(du_node, "reg-names", name);
 271                if (index < 0)
 272                        continue;
 273
 274                of_address_to_resource(du_node, index, &lvds->res);
 275        }
 276
 277        /* Parse and apply the overlay. This will resolve phandles. */
 278        ret = rcar_du_of_apply_overlay(rcar_du_lvds_overlays,
 279                                       match->compatible);
 280        if (ret < 0)
 281                goto done;
 282
 283        /* Patch the newly created LVDS encoder nodes. */
 284        for_each_child_of_node(soc_node, lvds_node) {
 285                struct resource res;
 286
 287                if (!of_device_is_compatible(lvds_node, compatible))
 288                        continue;
 289
 290                /* Locate the lvds_data entry based on the resource start. */
 291                ret = of_address_to_resource(lvds_node, 0, &res);
 292                if (ret < 0)
 293                        continue;
 294
 295                for (i = 0; i < ARRAY_SIZE(lvds_data); ++i) {
 296                        if (lvds_data[i].res.start == res.start)
 297                                break;
 298                }
 299
 300                if (i == ARRAY_SIZE(lvds_data))
 301                        continue;
 302
 303                /* Patch the LVDS encoder. */
 304                rcar_du_of_lvds_patch_one(lvds_node, &lvds_data[i].clkspec,
 305                                          lvds_data[i].local,
 306                                          lvds_data[i].remote);
 307        }
 308
 309done:
 310        for (i = 0; i < info->num_lvds; ++i) {
 311                of_node_put(lvds_data[i].clkspec.np);
 312                of_node_put(lvds_data[i].local);
 313                of_node_put(lvds_data[i].remote);
 314        }
 315
 316        of_node_put(soc_node);
 317        of_node_put(du_node);
 318}
 319
 320void __init rcar_du_of_init(const struct of_device_id *of_ids)
 321{
 322        rcar_du_of_lvds_patch(of_ids);
 323}
 324