1 /* 2 * Support for dynamic reconfiguration for PCI, Memory, and CPU 3 * Hotplug and Dynamic Logical Partitioning on RPA platforms. 4 * 5 * Copyright (C) 2009 Nathan Fontenot 6 * Copyright (C) 2009 IBM Corporation 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License version 10 * 2 as published by the Free Software Foundation. 11 */ 12 13 #define pr_fmt(fmt) "dlpar: " fmt 14 15 #include <linux/kernel.h> 16 #include <linux/notifier.h> 17 #include <linux/spinlock.h> 18 #include <linux/cpu.h> 19 #include <linux/slab.h> 20 #include <linux/of.h> 21 22 #include "of_helpers.h" 23 #include "pseries.h" 24 25 #include <asm/prom.h> 26 #include <asm/machdep.h> 27 #include <asm/uaccess.h> 28 #include <asm/rtas.h> 29 30 struct cc_workarea { 31 __be32 drc_index; 32 __be32 zero; 33 __be32 name_offset; 34 __be32 prop_length; 35 __be32 prop_offset; 36 }; 37 38 void dlpar_free_cc_property(struct property *prop) 39 { 40 kfree(prop->name); 41 kfree(prop->value); 42 kfree(prop); 43 } 44 45 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa) 46 { 47 struct property *prop; 48 char *name; 49 char *value; 50 51 prop = kzalloc(sizeof(*prop), GFP_KERNEL); 52 if (!prop) 53 return NULL; 54 55 name = (char *)ccwa + be32_to_cpu(ccwa->name_offset); 56 prop->name = kstrdup(name, GFP_KERNEL); 57 58 prop->length = be32_to_cpu(ccwa->prop_length); 59 value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset); 60 prop->value = kmemdup(value, prop->length, GFP_KERNEL); 61 if (!prop->value) { 62 dlpar_free_cc_property(prop); 63 return NULL; 64 } 65 66 return prop; 67 } 68 69 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa, 70 const char *path) 71 { 72 struct device_node *dn; 73 char *name; 74 75 /* If parent node path is "/" advance path to NULL terminator to 76 * prevent double leading slashs in full_name. 77 */ 78 if (!path[1]) 79 path++; 80 81 dn = kzalloc(sizeof(*dn), GFP_KERNEL); 82 if (!dn) 83 return NULL; 84 85 name = (char *)ccwa + be32_to_cpu(ccwa->name_offset); 86 dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name); 87 if (!dn->full_name) { 88 kfree(dn); 89 return NULL; 90 } 91 92 of_node_set_flag(dn, OF_DYNAMIC); 93 of_node_init(dn); 94 95 return dn; 96 } 97 98 static void dlpar_free_one_cc_node(struct device_node *dn) 99 { 100 struct property *prop; 101 102 while (dn->properties) { 103 prop = dn->properties; 104 dn->properties = prop->next; 105 dlpar_free_cc_property(prop); 106 } 107 108 kfree(dn->full_name); 109 kfree(dn); 110 } 111 112 void dlpar_free_cc_nodes(struct device_node *dn) 113 { 114 if (dn->child) 115 dlpar_free_cc_nodes(dn->child); 116 117 if (dn->sibling) 118 dlpar_free_cc_nodes(dn->sibling); 119 120 dlpar_free_one_cc_node(dn); 121 } 122 123 #define COMPLETE 0 124 #define NEXT_SIBLING 1 125 #define NEXT_CHILD 2 126 #define NEXT_PROPERTY 3 127 #define PREV_PARENT 4 128 #define MORE_MEMORY 5 129 #define CALL_AGAIN -2 130 #define ERR_CFG_USE -9003 131 132 struct device_node *dlpar_configure_connector(__be32 drc_index, 133 struct device_node *parent) 134 { 135 struct device_node *dn; 136 struct device_node *first_dn = NULL; 137 struct device_node *last_dn = NULL; 138 struct property *property; 139 struct property *last_property = NULL; 140 struct cc_workarea *ccwa; 141 char *data_buf; 142 const char *parent_path = parent->full_name; 143 int cc_token; 144 int rc = -1; 145 146 cc_token = rtas_token("ibm,configure-connector"); 147 if (cc_token == RTAS_UNKNOWN_SERVICE) 148 return NULL; 149 150 data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL); 151 if (!data_buf) 152 return NULL; 153 154 ccwa = (struct cc_workarea *)&data_buf[0]; 155 ccwa->drc_index = drc_index; 156 ccwa->zero = 0; 157 158 do { 159 /* Since we release the rtas_data_buf lock between configure 160 * connector calls we want to re-populate the rtas_data_buffer 161 * with the contents of the previous call. 162 */ 163 spin_lock(&rtas_data_buf_lock); 164 165 memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE); 166 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL); 167 memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE); 168 169 spin_unlock(&rtas_data_buf_lock); 170 171 switch (rc) { 172 case COMPLETE: 173 break; 174 175 case NEXT_SIBLING: 176 dn = dlpar_parse_cc_node(ccwa, parent_path); 177 if (!dn) 178 goto cc_error; 179 180 dn->parent = last_dn->parent; 181 last_dn->sibling = dn; 182 last_dn = dn; 183 break; 184 185 case NEXT_CHILD: 186 if (first_dn) 187 parent_path = last_dn->full_name; 188 189 dn = dlpar_parse_cc_node(ccwa, parent_path); 190 if (!dn) 191 goto cc_error; 192 193 if (!first_dn) { 194 dn->parent = parent; 195 first_dn = dn; 196 } else { 197 dn->parent = last_dn; 198 if (last_dn) 199 last_dn->child = dn; 200 } 201 202 last_dn = dn; 203 break; 204 205 case NEXT_PROPERTY: 206 property = dlpar_parse_cc_property(ccwa); 207 if (!property) 208 goto cc_error; 209 210 if (!last_dn->properties) 211 last_dn->properties = property; 212 else 213 last_property->next = property; 214 215 last_property = property; 216 break; 217 218 case PREV_PARENT: 219 last_dn = last_dn->parent; 220 parent_path = last_dn->parent->full_name; 221 break; 222 223 case CALL_AGAIN: 224 break; 225 226 case MORE_MEMORY: 227 case ERR_CFG_USE: 228 default: 229 printk(KERN_ERR "Unexpected Error (%d) " 230 "returned from configure-connector\n", rc); 231 goto cc_error; 232 } 233 } while (rc); 234 235 cc_error: 236 kfree(data_buf); 237 238 if (rc) { 239 if (first_dn) 240 dlpar_free_cc_nodes(first_dn); 241 242 return NULL; 243 } 244 245 return first_dn; 246 } 247 248 int dlpar_attach_node(struct device_node *dn) 249 { 250 int rc; 251 252 dn->parent = pseries_of_derive_parent(dn->full_name); 253 if (IS_ERR(dn->parent)) 254 return PTR_ERR(dn->parent); 255 256 rc = of_attach_node(dn); 257 if (rc) { 258 printk(KERN_ERR "Failed to add device node %s\n", 259 dn->full_name); 260 return rc; 261 } 262 263 of_node_put(dn->parent); 264 return 0; 265 } 266 267 int dlpar_detach_node(struct device_node *dn) 268 { 269 struct device_node *child; 270 int rc; 271 272 child = of_get_next_child(dn, NULL); 273 while (child) { 274 dlpar_detach_node(child); 275 child = of_get_next_child(dn, child); 276 } 277 278 rc = of_detach_node(dn); 279 if (rc) 280 return rc; 281 282 of_node_put(dn); /* Must decrement the refcount */ 283 return 0; 284 } 285 286 #define DR_ENTITY_SENSE 9003 287 #define DR_ENTITY_PRESENT 1 288 #define DR_ENTITY_UNUSABLE 2 289 #define ALLOCATION_STATE 9003 290 #define ALLOC_UNUSABLE 0 291 #define ALLOC_USABLE 1 292 #define ISOLATION_STATE 9001 293 #define ISOLATE 0 294 #define UNISOLATE 1 295 296 int dlpar_acquire_drc(u32 drc_index) 297 { 298 int dr_status, rc; 299 300 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status, 301 DR_ENTITY_SENSE, drc_index); 302 if (rc || dr_status != DR_ENTITY_UNUSABLE) 303 return -1; 304 305 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE); 306 if (rc) 307 return rc; 308 309 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE); 310 if (rc) { 311 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE); 312 return rc; 313 } 314 315 return 0; 316 } 317 318 int dlpar_release_drc(u32 drc_index) 319 { 320 int dr_status, rc; 321 322 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status, 323 DR_ENTITY_SENSE, drc_index); 324 if (rc || dr_status != DR_ENTITY_PRESENT) 325 return -1; 326 327 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE); 328 if (rc) 329 return rc; 330 331 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE); 332 if (rc) { 333 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE); 334 return rc; 335 } 336 337 return 0; 338 } 339 340 static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog) 341 { 342 int rc; 343 344 /* pseries error logs are in BE format, convert to cpu type */ 345 switch (hp_elog->id_type) { 346 case PSERIES_HP_ELOG_ID_DRC_COUNT: 347 hp_elog->_drc_u.drc_count = 348 be32_to_cpu(hp_elog->_drc_u.drc_count); 349 break; 350 case PSERIES_HP_ELOG_ID_DRC_INDEX: 351 hp_elog->_drc_u.drc_index = 352 be32_to_cpu(hp_elog->_drc_u.drc_index); 353 } 354 355 switch (hp_elog->resource) { 356 case PSERIES_HP_ELOG_RESOURCE_MEM: 357 rc = dlpar_memory(hp_elog); 358 break; 359 case PSERIES_HP_ELOG_RESOURCE_CPU: 360 rc = dlpar_cpu(hp_elog); 361 break; 362 default: 363 pr_warn_ratelimited("Invalid resource (%d) specified\n", 364 hp_elog->resource); 365 rc = -EINVAL; 366 } 367 368 return rc; 369 } 370 371 static ssize_t dlpar_store(struct class *class, struct class_attribute *attr, 372 const char *buf, size_t count) 373 { 374 struct pseries_hp_errorlog *hp_elog; 375 const char *arg; 376 int rc; 377 378 hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL); 379 if (!hp_elog) { 380 rc = -ENOMEM; 381 goto dlpar_store_out; 382 } 383 384 /* Parse out the request from the user, this will be in the form 385 * <resource> <action> <id_type> <id> 386 */ 387 arg = buf; 388 if (!strncmp(arg, "memory", 6)) { 389 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM; 390 arg += strlen("memory "); 391 } else if (!strncmp(arg, "cpu", 3)) { 392 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_CPU; 393 arg += strlen("cpu "); 394 } else { 395 pr_err("Invalid resource specified: \"%s\"\n", buf); 396 rc = -EINVAL; 397 goto dlpar_store_out; 398 } 399 400 if (!strncmp(arg, "add", 3)) { 401 hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD; 402 arg += strlen("add "); 403 } else if (!strncmp(arg, "remove", 6)) { 404 hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE; 405 arg += strlen("remove "); 406 } else { 407 pr_err("Invalid action specified: \"%s\"\n", buf); 408 rc = -EINVAL; 409 goto dlpar_store_out; 410 } 411 412 if (!strncmp(arg, "index", 5)) { 413 u32 index; 414 415 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX; 416 arg += strlen("index "); 417 if (kstrtou32(arg, 0, &index)) { 418 rc = -EINVAL; 419 pr_err("Invalid drc_index specified: \"%s\"\n", buf); 420 goto dlpar_store_out; 421 } 422 423 hp_elog->_drc_u.drc_index = cpu_to_be32(index); 424 } else if (!strncmp(arg, "count", 5)) { 425 u32 count; 426 427 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT; 428 arg += strlen("count "); 429 if (kstrtou32(arg, 0, &count)) { 430 rc = -EINVAL; 431 pr_err("Invalid count specified: \"%s\"\n", buf); 432 goto dlpar_store_out; 433 } 434 435 hp_elog->_drc_u.drc_count = cpu_to_be32(count); 436 } else { 437 pr_err("Invalid id_type specified: \"%s\"\n", buf); 438 rc = -EINVAL; 439 goto dlpar_store_out; 440 } 441 442 rc = handle_dlpar_errorlog(hp_elog); 443 444 dlpar_store_out: 445 kfree(hp_elog); 446 return rc ? rc : count; 447 } 448 449 static CLASS_ATTR(dlpar, S_IWUSR, NULL, dlpar_store); 450 451 static int __init pseries_dlpar_init(void) 452 { 453 return sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr); 454 } 455 machine_device_initcall(pseries, pseries_dlpar_init); 456 457