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         int ret;
 149
 150         if (!size) {
 151                 pr_warn("%s: No overlay data\n", __func__);
 152                 return NULL;
 153         }
 154
 155         overlay_data = kmemdup(__dtb_tilcdc_slave_compat_begin,
 156                                size, GFP_KERNEL);
 157         if (!overlay_data || kfree_table_add(kft, overlay_data))
 158                 return NULL;
 159
 160         of_fdt_unflatten_tree(overlay_data, NULL, &overlay);
 161         if (!overlay) {
 162                 pr_warn("%s: Unfattening overlay tree failed\n", __func__);
 163                 return NULL;
 164         }
 165
 166         ret = of_resolve_phandles(overlay);
 167         if (ret) {
 168                 pr_err("%s: Failed to resolve phandles: %d\n", __func__, ret);
 169                 return NULL;
 170         }
 171
 172         return overlay;
 173 }
 174
 175 static const struct of_device_id tilcdc_slave_of_match[] __initconst = {
 176         { .compatible = "ti,tilcdc,slave", },
 177         {},
 178 };
 179
 180 static const struct of_device_id tilcdc_of_match[] __initconst = {
 181         { .compatible = "ti,am33xx-tilcdc", },
 182         {},
 183 };
 184
 185 static const struct of_device_id tilcdc_tda998x_of_match[] __initconst = {
 186         { .compatible = "nxp,tda998x", },
 187         {},
 188 };
 189
 190 static const char * const tilcdc_slave_props[] __initconst = {
 191         "pinctrl-names",
 192         "pinctrl-0",
 193         "pinctrl-1",
 194         NULL
 195 };
 196
 197 static void __init tilcdc_convert_slave_node(void)
 198 {
 199         struct device_node *slave = NULL, *lcdc = NULL;
 200         struct device_node *i2c = NULL, *fragment = NULL;
 201         struct device_node *overlay, *encoder;
 202         struct property *prop;
 203         /* For all memory needed for the overlay tree. This memory can
 204            be freed after the overlay has been applied. */
 205         struct kfree_table kft;
 206         int ret;
 207
 208         if (kfree_table_init(&kft))
 209                 return;
 210
 211         lcdc = of_find_matching_node(NULL, tilcdc_of_match);
 212         slave = of_find_matching_node(NULL, tilcdc_slave_of_match);
 213
 214         if (!slave || !of_device_is_available(lcdc))
 215                 goto out;
 216
 217         i2c = of_parse_phandle(slave, "i2c", 0);
 218         if (!i2c) {
 219                 pr_err("%s: Can't find i2c node trough phandle\n", __func__);
 220                 goto out;
 221         }
 222
 223         overlay = tilcdc_get_overlay(&kft);
 224         if (!overlay)
 225                 goto out;
 226
 227         encoder = of_find_matching_node(overlay, tilcdc_tda998x_of_match);
 228         if (!encoder) {
 229                 pr_err("%s: Failed to find tda998x node\n", __func__);
 230                 goto out;
 231         }
 232
 233         tilcdc_copy_props(slave, encoder, tilcdc_slave_props, &kft);
 234
 235         for_each_child_of_node(overlay, fragment) {
 236                 prop = of_find_property(fragment, "target-path", NULL);
 237                 if (!prop)
 238                         continue;
 239                 if (!strncmp("i2c", (char *)prop->value, prop->length))
 240                         if (tilcdc_prop_str_update(prop, i2c->full_name, &kft))
 241                                 goto out;
 242                 if (!strncmp("lcdc", (char *)prop->value, prop->length))
 243                         if (tilcdc_prop_str_update(prop, lcdc->full_name, &kft))
 244                                 goto out;
 245         }
 246
 247         tilcdc_node_disable(slave);
 248
 249         ret = of_overlay_create(overlay);
 250         if (ret)
 251                 pr_err("%s: Creating overlay failed: %d\n", __func__, ret);
 252         else
 253                 pr_info("%s: ti,tilcdc,slave node successfully converted\n",
 254                         __func__);
 255 out:
 256         kfree_table_free(&kft);
 257         of_node_put(i2c);
 258         of_node_put(slave);
 259         of_node_put(lcdc);
 260         of_node_put(fragment);
 261 }
 262
 263 static int __init tilcdc_slave_compat_init(void)
 264 {
 265         tilcdc_convert_slave_node();
 266         return 0;
 267 }
 268
 269 subsys_initcall(tilcdc_slave_compat_init);