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 <linux/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 buf = parse_node(buf, bufsize, &np); 307 308 if (!np) 309 return -ENODEV; 310 311 tmp = strchr(buf,' '); 312 if (tmp) 313 *tmp = '\0'; 314 315 if (strlen(buf) == 0) 316 return -EINVAL; 317 318 return of_remove_property(np, of_find_property(np, buf, NULL)); 319 } 320 321 static int do_update_property(char *buf, size_t bufsize) 322 { 323 struct device_node *np; 324 unsigned char *value; 325 char *name, *end, *next_prop; 326 int length; 327 struct property *newprop; 328 buf = parse_node(buf, bufsize, &np); 329 end = buf + bufsize; 330 331 if (!np) 332 return -ENODEV; 333 334 next_prop = parse_next_property(buf, end, &name, &length, &value); 335 if (!next_prop) 336 return -EINVAL; 337 338 if (!strlen(name)) 339 return -ENODEV; 340 341 newprop = new_property(name, length, value, NULL); 342 if (!newprop) 343 return -ENOMEM; 344 345 if (!strcmp(name, "slb-size") || !strcmp(name, "ibm,slb-size")) 346 slb_set_size(*(int *)value); 347 348 return of_update_property(np, newprop); 349 } 350 351 /** 352 * ofdt_write - perform operations on the Open Firmware device tree 353 * 354 * @file: not used 355 * @buf: command and arguments 356 * @count: size of the command buffer 357 * @off: not used 358 * 359 * Operations supported at this time are addition and removal of 360 * whole nodes along with their properties. Operations on individual 361 * properties are not implemented (yet). 362 */ 363 static ssize_t ofdt_write(struct file *file, const char __user *buf, size_t count, 364 loff_t *off) 365 { 366 int rv = 0; 367 char *kbuf; 368 char *tmp; 369 370 if (!(kbuf = kmalloc(count + 1, GFP_KERNEL))) { 371 rv = -ENOMEM; 372 goto out; 373 } 374 if (copy_from_user(kbuf, buf, count)) { 375 rv = -EFAULT; 376 goto out; 377 } 378 379 kbuf[count] = '\0'; 380 381 tmp = strchr(kbuf, ' '); 382 if (!tmp) { 383 rv = -EINVAL; 384 goto out; 385 } 386 *tmp = '\0'; 387 tmp++; 388 389 if (!strcmp(kbuf, "add_node")) 390 rv = do_add_node(tmp, count - (tmp - kbuf)); 391 else if (!strcmp(kbuf, "remove_node")) 392 rv = do_remove_node(tmp); 393 else if (!strcmp(kbuf, "add_property")) 394 rv = do_add_property(tmp, count - (tmp - kbuf)); 395 else if (!strcmp(kbuf, "remove_property")) 396 rv = do_remove_property(tmp, count - (tmp - kbuf)); 397 else if (!strcmp(kbuf, "update_property")) 398 rv = do_update_property(tmp, count - (tmp - kbuf)); 399 else 400 rv = -EINVAL; 401 out: 402 kfree(kbuf); 403 return rv ? rv : count; 404 } 405 406 static const struct file_operations ofdt_fops = { 407 .write = ofdt_write, 408 .llseek = noop_llseek, 409 }; 410 411 /* create /proc/powerpc/ofdt write-only by root */ 412 static int proc_ppc64_create_ofdt(void) 413 { 414 struct proc_dir_entry *ent; 415 416 ent = proc_create("powerpc/ofdt", S_IWUSR, NULL, &ofdt_fops); 417 if (ent) 418 proc_set_size(ent, 0); 419 420 return 0; 421 } 422 machine_device_initcall(pseries, proc_ppc64_create_ofdt); 423