LXR linux/arch/sparc/kernel/prom

   1/* prom_common.c: OF device tree support common code.
   2 *
   3 * Paul Mackerras       August 1996.
   4 * Copyright (C) 1996-2005 Paul Mackerras.
   5 *
   6 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   7 *    {engebret|bergner}@us.ibm.com
   8 *
   9 *  Adapted for sparc by David S. Miller davem@davemloft.net
  10 *
  11 *      This program is free software; you can redistribute it and/or
  12 *      modify it under the terms of the GNU General Public License
  13 *      as published by the Free Software Foundation; either version
  14 *      2 of the License, or (at your option) any later version.
  15 */
  16
  17#include <linux/kernel.h>
  18#include <linux/export.h>
  19#include <linux/errno.h>
  20#include <linux/mutex.h>
  21#include <linux/slab.h>
  22#include <linux/of.h>
  23#include <linux/of_pdt.h>
  24#include <asm/prom.h>
  25#include <asm/oplib.h>
  26#include <asm/leon.h>
  27
  28#include "prom.h"
  29
  30struct device_node *of_console_device;
  31EXPORT_SYMBOL(of_console_device);
  32
  33char *of_console_path;
  34EXPORT_SYMBOL(of_console_path);
  35
  36char *of_console_options;
  37EXPORT_SYMBOL(of_console_options);
  38
  39int of_getintprop_default(struct device_node *np, const char *name, int def)
  40{
  41        struct property *prop;
  42        int len;
  43
  44        prop = of_find_property(np, name, &len);
  45        if (!prop || len != 4)
  46                return def;
  47
  48        return *(int *) prop->value;
  49}
  50EXPORT_SYMBOL(of_getintprop_default);
  51
  52DEFINE_MUTEX(of_set_property_mutex);
  53EXPORT_SYMBOL(of_set_property_mutex);
  54
  55int of_set_property(struct device_node *dp, const char *name, void *val, int len)
  56{
  57        struct property **prevp;
  58        void *new_val;
  59        int err;
  60
  61        new_val = kmemdup(val, len, GFP_KERNEL);
  62        if (!new_val)
  63                return -ENOMEM;
  64
  65        err = -ENODEV;
  66
  67        mutex_lock(&of_set_property_mutex);
  68        write_lock(&devtree_lock);
  69        prevp = &dp->properties;
  70        while (*prevp) {
  71                struct property *prop = *prevp;
  72
  73                if (!strcasecmp(prop->name, name)) {
  74                        void *old_val = prop->value;
  75                        int ret;
  76
  77                        ret = prom_setprop(dp->phandle, name, val, len);
  78
  79                        err = -EINVAL;
  80                        if (ret >= 0) {
  81                                prop->value = new_val;
  82                                prop->length = len;
  83
  84                                if (OF_IS_DYNAMIC(prop))
  85                                        kfree(old_val);
  86
  87                                OF_MARK_DYNAMIC(prop);
  88
  89                                err = 0;
  90                        }
  91                        break;
  92                }
  93                prevp = &(*prevp)->next;
  94        }
  95        write_unlock(&devtree_lock);
  96        mutex_unlock(&of_set_property_mutex);
  97
  98        /* XXX Upate procfs if necessary... */
  99
 100        return err;
 101}
 102EXPORT_SYMBOL(of_set_property);
 103
 104int of_find_in_proplist(const char *list, const char *match, int len)
 105{
 106        while (len > 0) {
 107                int l;
 108
 109                if (!strcmp(list, match))
 110                        return 1;
 111                l = strlen(list) + 1;
 112                list += l;
 113                len -= l;
 114        }
 115        return 0;
 116}
 117EXPORT_SYMBOL(of_find_in_proplist);
 118
 119/*
 120 * SPARC32 and SPARC64's prom_nextprop() do things differently
 121 * here, despite sharing the same interface.  SPARC32 doesn't fill in 'buf',
 122 * returning NULL on an error.  SPARC64 fills in 'buf', but sets it to an
 123 * empty string upon error.
 124 */
 125static int __init handle_nextprop_quirks(char *buf, const char *name)
 126{
 127        if (!name || strlen(name) == 0)
 128                return -1;
 129
 130#ifdef CONFIG_SPARC32
 131        strcpy(buf, name);
 132#endif
 133        return 0;
 134}
 135
 136static int __init prom_common_nextprop(phandle node, char *prev, char *buf)
 137{
 138        const char *name;
 139
 140        buf[0] = '\0';
 141        name = prom_nextprop(node, prev, buf);
 142        return handle_nextprop_quirks(buf, name);
 143}
 144
 145unsigned int prom_early_allocated __initdata;
 146
 147static struct of_pdt_ops prom_sparc_ops __initdata = {
 148        .nextprop = prom_common_nextprop,
 149        .getproplen = prom_getproplen,
 150        .getproperty = prom_getproperty,
 151        .getchild = prom_getchild,
 152        .getsibling = prom_getsibling,
 153};
 154
 155void __init prom_build_devicetree(void)
 156{
 157        of_pdt_build_devicetree(prom_root_node, &prom_sparc_ops);
 158        of_console_init();
 159
 160        pr_info("PROM: Built device tree with %u bytes of memory.\n",
 161                        prom_early_allocated);
 162}
 163