drivers/gpu/drm/tilcdc/tilcdc_slave_compat.c

   1 /*
   2  * Copyright (C) 2015 Texas Instruments
   3  * Author: Jyri Sarha <jsarha@ti.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  */
  10
  11 /*
  12  * To support the old "ti,tilcdc,slave" binding the binding has to be
  13  * transformed to the new external encoder binding.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/of.h>
  18 #include <linux/of_graph.h>
  19 #include <linux/of_fdt.h>
  20 #include <linux/slab.h>
  21 #include <linux/list.h>
  22
  23 #include "tilcdc_slave_compat.h"
  24
  25 struct kfree_table {
  26         int total;
  27         int num;
  28         void **table;
  29 };
  30
  31 static int __init kfree_table_init(struct kfree_table *kft)
  32 {
  33         kft->total = 32;
  34         kft->num = 0;
  35         kft->table = kmalloc(kft->total * sizeof(*kft->table),
  36                              GFP_KERNEL);
  37         if (!kft->table)
  38                 return -ENOMEM;
  39
  40         return 0;
  41 }
  42
  43 static int __init kfree_table_add(struct kfree_table *kft, void *p)
  44 {
  45         if (kft->num == kft->total) {
  46                 void **old = kft->table;
  47
  48                 kft->total *= 2;
  49                 kft->table = krealloc(old, kft->total * sizeof(*kft->table),
  50                                       GFP_KERNEL);
  51                 if (!kft->table) {
  52                         kft->table = old;
  53                         kfree(p);
  54                         return -ENOMEM;
  55                 }
  56         }
  57         kft->table[kft->num++] = p;
  58         return 0;
  59 }
  60
  61 static void __init kfree_table_free(struct kfree_table *kft)
  62 {
  63         int i;
  64
  65         for (i = 0; i < kft->num; i++)
  66                 kfree(kft->table[i]);
  67
  68         kfree(kft->table);
  69 }
  70
  71 static
  72 struct property * __init tilcdc_prop_dup(const struct property *prop,
  73                                          struct kfree_table *kft)
  74 {
  75         struct property *nprop;
  76
  77         nprop = kzalloc(sizeof(*nprop), GFP_KERNEL);
  78         if (!nprop || kfree_table_add(kft, nprop))
  79                 return NULL;
  80
  81         nprop->name = kstrdup(prop->name, GFP_KERNEL);
  82         if (!nprop->name || kfree_table_add(kft, nprop->name))
  83                 return NULL;
  84
  85         nprop->value = kmemdup(prop->value, prop->length, GFP_KERNEL);
  86         if (!nprop->value || kfree_table_add(kft, nprop->value))
  87                 return NULL;
  88
  89         nprop->length = prop->length;
  90
  91         return nprop;
  92 }
  93
  94 static void __init tilcdc_copy_props(struct device_node *from,
  95                                      struct device_node *to,
  96                                      const char * const props[],
  97                                      struct kfree_table *kft)
  98 {
  99         struct property *prop;
 100         int i;
 101
 102         for (i = 0; props[i]; i++) {
 103                 prop = of_find_property(from, props[i], NULL);
 104                 if (!prop)
 105                         continue;
 106
 107                 prop = tilcdc_prop_dup(prop, kft);
 108                 if (!prop)
 109                         continue;
 110
 111                 prop->next = to->properties;
 112                 to->properties = prop;
 113         }
 114 }
 115
 116 static int __init tilcdc_prop_str_update(struct property *prop,
 117                                           const char *str,
 118                                           struct kfree_table *kft)
 119 {
 120         prop->value = kstrdup(str, GFP_KERNEL);
 121         if (kfree_table_add(kft, prop->value) || !prop->value)
 122                 return -ENOMEM;
 123         prop->length = strlen(str)+1;
 124         return 0;
 125 }
 126
 127 static void __init tilcdc_node_disable(struct device_node *node)
 128 {
 129         struct property *prop;
 130
 131         prop = kzalloc(sizeof(*prop), GFP_KERNEL);
 132         if (!prop)
 133                 return;
 134
 135         prop->name = "status";
 136         prop->value = "disabled";
 137         prop->length = strlen((char *)prop->value)+1;
 138
 139         of_update_property(node, prop);
 140 }
 141
 142 static struct device_node * __init tilcdc_get_overlay(struct kfree_table *kft)
 143 {
 144         const int size = __dtb_tilcdc_slave_compat_end -
 145                 __dtb_tilcdc_slave_compat_begin;
 146         static void *overlay_data;
 147         struct device_node *overlay;
 148
 149         if (!size) {
 150                 pr_warn("%s: No overlay data\n", __func__);
 151                 return NULL;
 152         }
 153
 154         overlay_data = kmemdup(__dtb_tilcdc_slave_compat_begin,
 155                                size, GFP_KERNEL);
 156         if (!overlay_data || kfree_table_add(kft, overlay_data))
 157                 return NULL;
 158
 159         of_fdt_unflatten_tree(overlay_data, NULL, &overlay);
 160         if (!overlay) {
 161                 pr_warn("%s: Unfattening overlay tree failed\n", __func__);
 162                 return NULL;
 163         }
 164
 165         of_node_set_flag(overlay, OF_DETACHED);
 166
 167         return overlay;
 168 }
 169
 170 static const struct of_device_id tilcdc_slave_of_match[] __initconst = {
 171         { .compatible = "ti,tilcdc,slave", },
 172         {},
 173 };
 174
 175 static const struct of_device_id tilcdc_of_match[] __initconst = {
 176         { .compatible = "ti,am33xx-tilcdc", },
 177         {},
 178 };
 179
 180 static const struct of_device_id tilcdc_tda998x_of_match[] __initconst = {
 181         { .compatible = "nxp,tda998x", },
 182         {},
 183 };
 184
 185 static const char * const tilcdc_slave_props[] __initconst = {
 186         "pinctrl-names",
 187         "pinctrl-0",
 188         "pinctrl-1",
 189         NULL
 190 };
 191
 192 static void __init tilcdc_convert_slave_node(void)
 193 {
 194         struct device_node *slave = NULL, *lcdc = NULL;
 195         struct device_node *i2c = NULL, *fragment = NULL;
 196         struct device_node *overlay, *encoder;
 197         struct property *prop;
 198         /* For all memory needed for the overlay tree. This memory can
 199            be freed after the overlay has been applied. */
 200         struct kfree_table kft;
 201         int ovcs_id, ret;
 202
 203         if (kfree_table_init(&kft))
 204                 return;
 205
 206         lcdc = of_find_matching_node(NULL, tilcdc_of_match);
 207         slave = of_find_matching_node(NULL, tilcdc_slave_of_match);
 208
 209         if (!slave || !of_device_is_available(lcdc))
 210                 goto out;
 211
 212         i2c = of_parse_phandle(slave, "i2c", 0);
 213         if (!i2c) {
 214                 pr_err("%s: Can't find i2c node trough phandle\n", __func__);
 215                 goto out;
 216         }
 217
 218         overlay = tilcdc_get_overlay(&kft);
 219         if (!overlay)
 220                 goto out;
 221
 222         encoder = of_find_matching_node(overlay, tilcdc_tda998x_of_match);
 223         if (!encoder) {
 224                 pr_err("%s: Failed to find tda998x node\n", __func__);
 225                 goto out;
 226         }
 227
 228         tilcdc_copy_props(slave, encoder, tilcdc_slave_props, &kft);
 229
 230         for_each_child_of_node(overlay, fragment) {
 231                 prop = of_find_property(fragment, "target-path", NULL);
 232                 if (!prop)
 233                         continue;
 234                 if (!strncmp("i2c", (char *)prop->value, prop->length))
 235                         if (tilcdc_prop_str_update(prop, i2c->full_name, &kft))
 236                                 goto out;
 237                 if (!strncmp("lcdc", (char *)prop->value, prop->length))
 238                         if (tilcdc_prop_str_update(prop, lcdc->full_name, &kft))
 239                                 goto out;
 240         }
 241
 242         tilcdc_node_disable(slave);
 243
 244         ovcs_id = 0;
 245         ret = of_overlay_apply(overlay, &ovcs_id);
 246         if (ret)
 247                 pr_err("%s: Applying overlay changeset failed: %d\n",
 248                         __func__, ret);
 249         else
 250                 pr_info("%s: ti,tilcdc,slave node successfully converted\n",
 251                         __func__);
 252 out:
 253         kfree_table_free(&kft);
 254         of_node_put(i2c);
 255         of_node_put(slave);
 256         of_node_put(lcdc);
 257         of_node_put(fragment);
 258 }
 259
 260 static int __init tilcdc_slave_compat_init(void)
 261 {
 262         tilcdc_convert_slave_node();
 263         return 0;
 264 }
 265
 266 subsys_initcall(tilcdc_slave_compat_init);