arch/powerpc/platforms/pseries/reconfig.c

   1 /*
   2  * pSeries_reconfig.c - support for dynamic reconfiguration (including PCI
   3  * Hotplug and Dynamic Logical Partitioning on RPA platforms).
   4  *
   5  * Copyright (C) 2005 Nathan Lynch
   6  * Copyright (C) 2005 IBM Corporation
   7  *
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License version
  11  *      2 as published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/notifier.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/slab.h>
  18 #include <linux/of.h>
  19
  20 #include <asm/prom.h>
  21 #include <asm/machdep.h>
  22 #include <asm/uaccess.h>
  23 #include <asm/mmu.h>
  24
  25 #include "of_helpers.h"
  26
  27 static int pSeries_reconfig_add_node(const char *path, struct property *proplist)
  28 {
  29         struct device_node *np;
  30         int err = -ENOMEM;
  31
  32         np = kzalloc(sizeof(*np), GFP_KERNEL);
  33         if (!np)
  34                 goto out_err;
  35
  36         np->full_name = kstrdup(path, GFP_KERNEL);
  37         if (!np->full_name)
  38                 goto out_err;
  39
  40         np->properties = proplist;
  41         of_node_set_flag(np, OF_DYNAMIC);
  42         of_node_init(np);
  43
  44         np->parent = pseries_of_derive_parent(path);
  45         if (IS_ERR(np->parent)) {
  46                 err = PTR_ERR(np->parent);
  47                 goto out_err;
  48         }
  49
  50         err = of_attach_node(np);
  51         if (err) {
  52                 printk(KERN_ERR "Failed to add device node %s\n", path);
  53                 goto out_err;
  54         }
  55
  56         of_node_put(np->parent);
  57
  58         return 0;
  59
  60 out_err:
  61         if (np) {
  62                 of_node_put(np->parent);
  63                 kfree(np->full_name);
  64                 kfree(np);
  65         }
  66         return err;
  67 }
  68
  69 static int pSeries_reconfig_remove_node(struct device_node *np)
  70 {
  71         struct device_node *parent, *child;
  72
  73         parent = of_get_parent(np);
  74         if (!parent)
  75                 return -EINVAL;
  76
  77         if ((child = of_get_next_child(np, NULL))) {
  78                 of_node_put(child);
  79                 of_node_put(parent);
  80                 return -EBUSY;
  81         }
  82
  83         of_detach_node(np);
  84         of_node_put(parent);
  85         of_node_put(np); /* Must decrement the refcount */
  86         return 0;
  87 }
  88
  89 /*
  90  * /proc/powerpc/ofdt - yucky binary interface for adding and removing
  91  * OF device nodes.  Should be deprecated as soon as we get an
  92  * in-kernel wrapper for the RTAS ibm,configure-connector call.
  93  */
  94
  95 static void release_prop_list(const struct property *prop)
  96 {
  97         struct property *next;
  98         for (; prop; prop = next) {
  99                 next = prop->next;
 100                 kfree(prop->name);
 101                 kfree(prop->value);
 102                 kfree(prop);
 103         }
 104
 105 }
 106
 107 /**
 108  * parse_next_property - process the next property from raw input buffer
 109  * @buf: input buffer, must be nul-terminated
 110  * @end: end of the input buffer + 1, for validation
 111  * @name: return value; set to property name in buf
 112  * @length: return value; set to length of value
 113  * @value: return value; set to the property value in buf
 114  *
 115  * Note that the caller must make copies of the name and value returned,
 116  * this function does no allocation or copying of the data.  Return value
 117  * is set to the next name in buf, or NULL on error.
 118  */
 119 static char * parse_next_property(char *buf, char *end, char **name, int *length,
 120                                   unsigned char **value)
 121 {
 122         char *tmp;
 123
 124         *name = buf;
 125
 126         tmp = strchr(buf, ' ');
 127         if (!tmp) {
 128                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 129                        __func__, __LINE__);
 130                 return NULL;
 131         }
 132         *tmp = '\0';
 133
 134         if (++tmp >= end) {
 135                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 136                        __func__, __LINE__);
 137                 return NULL;
 138         }
 139
 140         /* now we're on the length */
 141         *length = -1;
 142         *length = simple_strtoul(tmp, &tmp, 10);
 143         if (*length == -1) {
 144                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 145                        __func__, __LINE__);
 146                 return NULL;
 147         }
 148         if (*tmp != ' ' || ++tmp >= end) {
 149                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 150                        __func__, __LINE__);
 151                 return NULL;
 152         }
 153
 154         /* now we're on the value */
 155         *value = tmp;
 156         tmp += *length;
 157         if (tmp > end) {
 158                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 159                        __func__, __LINE__);
 160                 return NULL;
 161         }
 162         else if (tmp < end && *tmp != ' ' && *tmp != '\0') {
 163                 printk(KERN_ERR "property parse failed in %s at line %d\n",
 164                        __func__, __LINE__);
 165                 return NULL;
 166         }
 167         tmp++;
 168
 169         /* and now we should be on the next name, or the end */
 170         return tmp;
 171 }
 172
 173 static struct property *new_property(const char *name, const int length,
 174                                      const unsigned char *value, struct property *last)
 175 {
 176         struct property *new = kzalloc(sizeof(*new), GFP_KERNEL);
 177
 178         if (!new)
 179                 return NULL;
 180
 181         if (!(new->name = kstrdup(name, GFP_KERNEL)))
 182                 goto cleanup;
 183         if (!(new->value = kmalloc(length + 1, GFP_KERNEL)))
 184                 goto cleanup;
 185
 186         memcpy(new->value, value, length);
 187         *(((char *)new->value) + length) = 0;
 188         new->length = length;
 189         new->next = last;
 190         return new;
 191
 192 cleanup:
 193         kfree(new->name);
 194         kfree(new->value);
 195         kfree(new);
 196         return NULL;
 197 }
 198
 199 static int do_add_node(char *buf, size_t bufsize)
 200 {
 201         char *path, *end, *name;
 202         struct device_node *np;
 203         struct property *prop = NULL;
 204         unsigned char* value;
 205         int length, rv = 0;
 206
 207         end = buf + bufsize;
 208         path = buf;
 209         buf = strchr(buf, ' ');
 210         if (!buf)
 211                 return -EINVAL;
 212         *buf = '\0';
 213         buf++;
 214
 215         if ((np = of_find_node_by_path(path))) {
 216                 of_node_put(np);
 217                 return -EINVAL;
 218         }
 219
 220         /* rv = build_prop_list(tmp, bufsize - (tmp - buf), &proplist); */
 221         while (buf < end &&
 222                (buf = parse_next_property(buf, end, &name, &length, &value))) {
 223                 struct property *last = prop;
 224
 225                 prop = new_property(name, length, value, last);
 226                 if (!prop) {
 227                         rv = -ENOMEM;
 228                         prop = last;
 229                         goto out;
 230                 }
 231         }
 232         if (!buf) {
 233                 rv = -EINVAL;
 234                 goto out;
 235         }
 236
 237         rv = pSeries_reconfig_add_node(path, prop);
 238
 239 out:
 240         if (rv)
 241                 release_prop_list(prop);
 242         return rv;
 243 }
 244
 245 static int do_remove_node(char *buf)
 246 {
 247         struct device_node *node;
 248         int rv = -ENODEV;
 249
 250         if ((node = of_find_node_by_path(buf)))
 251                 rv = pSeries_reconfig_remove_node(node);
 252
 253         of_node_put(node);
 254         return rv;
 255 }
 256
 257 static char *parse_node(char *buf, size_t bufsize, struct device_node **npp)
 258 {
 259         char *handle_str;
 260         phandle handle;
 261         *npp = NULL;
 262
 263         handle_str = buf;
 264
 265         buf = strchr(buf, ' ');
 266         if (!buf)
 267                 return NULL;
 268         *buf = '\0';
 269         buf++;
 270
 271         handle = simple_strtoul(handle_str, NULL, 0);
 272
 273         *npp = of_find_node_by_phandle(handle);
 274         return buf;
 275 }
 276
 277 static int do_add_property(char *buf, size_t bufsize)
 278 {
 279         struct property *prop = NULL;
 280         struct device_node *np;
 281         unsigned char *value;
 282         char *name, *end;
 283         int length;
 284         end = buf + bufsize;
 285         buf = parse_node(buf, bufsize, &np);
 286
 287         if (!np)
 288                 return -ENODEV;
 289
 290         if (parse_next_property(buf, end, &name, &length, &value) == NULL)
 291                 return -EINVAL;
 292
 293         prop = new_property(name, length, value, NULL);
 294         if (!prop)
 295                 return -ENOMEM;
 296
 297         of_add_property(np, prop);
 298
 299         return 0;
 300 }
 301
 302 static int do_remove_property(char *buf, size_t bufsize)
 303 {
 304         struct device_node *np;
 305         char *tmp;
 306         struct property *prop;
 307         buf = parse_node(buf, bufsize, &np);
 308
 309         if (!np)
 310                 return -ENODEV;
 311
 312         tmp = strchr(buf,' ');
 313         if (tmp)
 314                 *tmp = '\0';
 315
 316         if (strlen(buf) == 0)
 317                 return -EINVAL;
 318
 319         prop = of_find_property(np, buf, NULL);
 320
 321         return of_remove_property(np, prop);
 322 }
 323
 324 static int do_update_property(char *buf, size_t bufsize)
 325 {
 326         struct device_node *np;
 327         unsigned char *value;
 328         char *name, *end, *next_prop;
 329         int length;
 330         struct property *newprop;
 331         buf = parse_node(buf, bufsize, &np);
 332         end = buf + bufsize;
 333
 334         if (!np)
 335                 return -ENODEV;
 336
 337         next_prop = parse_next_property(buf, end, &name, &length, &value);
 338         if (!next_prop)
 339                 return -EINVAL;
 340
 341         if (!strlen(name))
 342                 return -ENODEV;
 343
 344         newprop = new_property(name, length, value, NULL);
 345         if (!newprop)
 346                 return -ENOMEM;
 347
 348         if (!strcmp(name, "slb-size") || !strcmp(name, "ibm,slb-size"))
 349                 slb_set_size(*(int *)value);
 350
 351         return of_update_property(np, newprop);
 352 }
 353
 354 /**
 355  * ofdt_write - perform operations on the Open Firmware device tree
 356  *
 357  * @file: not used
 358  * @buf: command and arguments
 359  * @count: size of the command buffer
 360  * @off: not used
 361  *
 362  * Operations supported at this time are addition and removal of
 363  * whole nodes along with their properties.  Operations on individual
 364  * properties are not implemented (yet).
 365  */
 366 static ssize_t ofdt_write(struct file *file, const char __user *buf, size_t count,
 367                           loff_t *off)
 368 {
 369         int rv = 0;
 370         char *kbuf;
 371         char *tmp;
 372
 373         if (!(kbuf = kmalloc(count + 1, GFP_KERNEL))) {
 374                 rv = -ENOMEM;
 375                 goto out;
 376         }
 377         if (copy_from_user(kbuf, buf, count)) {
 378                 rv = -EFAULT;
 379                 goto out;
 380         }
 381
 382         kbuf[count] = '\0';
 383
 384         tmp = strchr(kbuf, ' ');
 385         if (!tmp) {
 386                 rv = -EINVAL;
 387                 goto out;
 388         }
 389         *tmp = '\0';
 390         tmp++;
 391
 392         if (!strcmp(kbuf, "add_node"))
 393                 rv = do_add_node(tmp, count - (tmp - kbuf));
 394         else if (!strcmp(kbuf, "remove_node"))
 395                 rv = do_remove_node(tmp);
 396         else if (!strcmp(kbuf, "add_property"))
 397                 rv = do_add_property(tmp, count - (tmp - kbuf));
 398         else if (!strcmp(kbuf, "remove_property"))
 399                 rv = do_remove_property(tmp, count - (tmp - kbuf));
 400         else if (!strcmp(kbuf, "update_property"))
 401                 rv = do_update_property(tmp, count - (tmp - kbuf));
 402         else
 403                 rv = -EINVAL;
 404 out:
 405         kfree(kbuf);
 406         return rv ? rv : count;
 407 }
 408
 409 static const struct file_operations ofdt_fops = {
 410         .write = ofdt_write,
 411         .llseek = noop_llseek,
 412 };
 413
 414 /* create /proc/powerpc/ofdt write-only by root */
 415 static int proc_ppc64_create_ofdt(void)
 416 {
 417         struct proc_dir_entry *ent;
 418
 419         ent = proc_create("powerpc/ofdt", S_IWUSR, NULL, &ofdt_fops);
 420         if (ent)
 421                 proc_set_size(ent, 0);
 422
 423         return 0;
 424 }
 425 machine_device_initcall(pseries, proc_ppc64_create_ofdt);