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 <linux/uaccess.h> 28 #include <asm/rtas.h> 29 30 static struct workqueue_struct *pseries_hp_wq; 31 32 struct pseries_hp_work { 33 struct work_struct work; 34 struct pseries_hp_errorlog *errlog; 35 struct completion *hp_completion; 36 int *rc; 37 }; 38 39 struct cc_workarea { 40 __be32 drc_index; 41 __be32 zero; 42 __be32 name_offset; 43 __be32 prop_length; 44 __be32 prop_offset; 45 }; 46 47 void dlpar_free_cc_property(struct property *prop) 48 { 49 kfree(prop->name); 50 kfree(prop->value); 51 kfree(prop); 52 } 53 54 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa) 55 { 56 struct property *prop; 57 char *name; 58 char *value; 59 60 prop = kzalloc(sizeof(*prop), GFP_KERNEL); 61 if (!prop) 62 return NULL; 63 64 name = (char *)ccwa + be32_to_cpu(ccwa->name_offset); 65 prop->name = kstrdup(name, GFP_KERNEL); 66 67 prop->length = be32_to_cpu(ccwa->prop_length); 68 value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset); 69 prop->value = kmemdup(value, prop->length, GFP_KERNEL); 70 if (!prop->value) { 71 dlpar_free_cc_property(prop); 72 return NULL; 73 } 74 75 return prop; 76 } 77 78 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa, 79 const char *path) 80 { 81 struct device_node *dn; 82 char *name; 83 84 /* If parent node path is "/" advance path to NULL terminator to 85 * prevent double leading slashs in full_name. 86 */ 87 if (!path[1]) 88 path++; 89 90 dn = kzalloc(sizeof(*dn), GFP_KERNEL); 91 if (!dn) 92 return NULL; 93 94 name = (char *)ccwa + be32_to_cpu(ccwa->name_offset); 95 dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name); 96 if (!dn->full_name) { 97 kfree(dn); 98 return NULL; 99 } 100 101 of_node_set_flag(dn, OF_DYNAMIC); 102 of_node_init(dn); 103 104 return dn; 105 } 106 107 static void dlpar_free_one_cc_node(struct device_node *dn) 108 { 109 struct property *prop; 110 111 while (dn->properties) { 112 prop = dn->properties; 113 dn->properties = prop->next; 114 dlpar_free_cc_property(prop); 115 } 116 117 kfree(dn->full_name); 118 kfree(dn); 119 } 120 121 void dlpar_free_cc_nodes(struct device_node *dn) 122 { 123 if (dn->child) 124 dlpar_free_cc_nodes(dn->child); 125 126 if (dn->sibling) 127 dlpar_free_cc_nodes(dn->sibling); 128 129 dlpar_free_one_cc_node(dn); 130 } 131 132 #define COMPLETE 0 133 #define NEXT_SIBLING 1 134 #define NEXT_CHILD 2 135 #define NEXT_PROPERTY 3 136 #define PREV_PARENT 4 137 #define MORE_MEMORY 5 138 #define CALL_AGAIN -2 139 #define ERR_CFG_USE -9003 140 141 struct device_node *dlpar_configure_connector(__be32 drc_index, 142 struct device_node *parent) 143 { 144 struct device_node *dn; 145 struct device_node *first_dn = NULL; 146 struct device_node *last_dn = NULL; 147 struct property *property; 148 struct property *last_property = NULL; 149 struct cc_workarea *ccwa; 150 char *data_buf; 151 const char *parent_path = parent->full_name; 152 int cc_token; 153 int rc = -1; 154 155 cc_token = rtas_token("ibm,configure-connector"); 156 if (cc_token == RTAS_UNKNOWN_SERVICE) 157 return NULL; 158 159 data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL); 160 if (!data_buf) 161 return NULL; 162 163 ccwa = (struct cc_workarea *)&data_buf[0]; 164 ccwa->drc_index = drc_index; 165 ccwa->zero = 0; 166 167 do { 168 /* Since we release the rtas_data_buf lock between configure 169 * connector calls we want to re-populate the rtas_data_buffer 170 * with the contents of the previous call. 171 */ 172 spin_lock(&rtas_data_buf_lock); 173 174 memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE); 175 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL); 176 memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE); 177 178 spin_unlock(&rtas_data_buf_lock); 179 180 switch (rc) { 181 case COMPLETE: 182 break; 183 184 case NEXT_SIBLING: 185 dn = dlpar_parse_cc_node(ccwa, parent_path); 186 if (!dn) 187 goto cc_error; 188 189 dn->parent = last_dn->parent; 190 last_dn->sibling = dn; 191 last_dn = dn; 192 break; 193 194 case NEXT_CHILD: 195 if (first_dn) 196 parent_path = last_dn->full_name; 197 198 dn = dlpar_parse_cc_node(ccwa, parent_path); 199 if (!dn) 200 goto cc_error; 201 202 if (!first_dn) { 203 dn->parent = parent; 204 first_dn = dn; 205 } else { 206 dn->parent = last_dn; 207 if (last_dn) 208 last_dn->child = dn; 209 } 210 211 last_dn = dn; 212 break; 213 214 case NEXT_PROPERTY: 215 property = dlpar_parse_cc_property(ccwa); 216 if (!property) 217 goto cc_error; 218 219 if (!last_dn->properties) 220 last_dn->properties = property; 221 else 222 last_property->next = property; 223 224 last_property = property; 225 break; 226 227 case PREV_PARENT: 228 last_dn = last_dn->parent; 229 parent_path = last_dn->parent->full_name; 230 break; 231 232 case CALL_AGAIN: 233 break; 234 235 case MORE_MEMORY: 236 case ERR_CFG_USE: 237 default: 238 printk(KERN_ERR "Unexpected Error (%d) " 239 "returned from configure-connector\n", rc); 240 goto cc_error; 241 } 242 } while (rc); 243 244 cc_error: 245 kfree(data_buf); 246 247 if (rc) { 248 if (first_dn) 249 dlpar_free_cc_nodes(first_dn); 250 251 return NULL; 252 } 253 254 return first_dn; 255 } 256 257 int dlpar_attach_node(struct device_node *dn) 258 { 259 int rc; 260 261 dn->parent = pseries_of_derive_parent(dn->full_name); 262 if (IS_ERR(dn->parent)) 263 return PTR_ERR(dn->parent); 264 265 rc = of_attach_node(dn); 266 if (rc) { 267 printk(KERN_ERR "Failed to add device node %s\n", 268 dn->full_name); 269 return rc; 270 } 271 272 of_node_put(dn->parent); 273 return 0; 274 } 275 276 int dlpar_detach_node(struct device_node *dn) 277 { 278 struct device_node *child; 279 int rc; 280 281 child = of_get_next_child(dn, NULL); 282 while (child) { 283 dlpar_detach_node(child); 284 child = of_get_next_child(dn, child); 285 } 286 287 rc = of_detach_node(dn); 288 if (rc) 289 return rc; 290 291 return 0; 292 } 293 294 #define DR_ENTITY_SENSE 9003 295 #define DR_ENTITY_PRESENT 1 296 #define DR_ENTITY_UNUSABLE 2 297 #define ALLOCATION_STATE 9003 298 #define ALLOC_UNUSABLE 0 299 #define ALLOC_USABLE 1 300 #define ISOLATION_STATE 9001 301 #define ISOLATE 0 302 #define UNISOLATE 1 303 304 int dlpar_acquire_drc(u32 drc_index) 305 { 306 int dr_status, rc; 307 308 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status, 309 DR_ENTITY_SENSE, drc_index); 310 if (rc || dr_status != DR_ENTITY_UNUSABLE) 311 return -1; 312 313 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE); 314 if (rc) 315 return rc; 316 317 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE); 318 if (rc) { 319 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE); 320 return rc; 321 } 322 323 return 0; 324 } 325 326 int dlpar_release_drc(u32 drc_index) 327 { 328 int dr_status, rc; 329 330 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status, 331 DR_ENTITY_SENSE, drc_index); 332 if (rc || dr_status != DR_ENTITY_PRESENT) 333 return -1; 334 335 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE); 336 if (rc) 337 return rc; 338 339 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE); 340 if (rc) { 341 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE); 342 return rc; 343 } 344 345 return 0; 346 } 347 348 static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog) 349 { 350 int rc; 351 352 /* pseries error logs are in BE format, convert to cpu type */ 353 switch (hp_elog->id_type) { 354 case PSERIES_HP_ELOG_ID_DRC_COUNT: 355 hp_elog->_drc_u.drc_count = 356 be32_to_cpu(hp_elog->_drc_u.drc_count); 357 break; 358 case PSERIES_HP_ELOG_ID_DRC_INDEX: 359 hp_elog->_drc_u.drc_index = 360 be32_to_cpu(hp_elog->_drc_u.drc_index); 361 break; 362 case PSERIES_HP_ELOG_ID_DRC_IC: 363 hp_elog->_drc_u.ic.count = 364 be32_to_cpu(hp_elog->_drc_u.ic.count); 365 hp_elog->_drc_u.ic.index = 366 be32_to_cpu(hp_elog->_drc_u.ic.index); 367 } 368 369 switch (hp_elog->resource) { 370 case PSERIES_HP_ELOG_RESOURCE_MEM: 371 rc = dlpar_memory(hp_elog); 372 break; 373 case PSERIES_HP_ELOG_RESOURCE_CPU: 374 rc = dlpar_cpu(hp_elog); 375 break; 376 default: 377 pr_warn_ratelimited("Invalid resource (%d) specified\n", 378 hp_elog->resource); 379 rc = -EINVAL; 380 } 381 382 return rc; 383 } 384 385 static void pseries_hp_work_fn(struct work_struct *work) 386 { 387 struct pseries_hp_work *hp_work = 388 container_of(work, struct pseries_hp_work, work); 389 390 if (hp_work->rc) 391 *(hp_work->rc) = handle_dlpar_errorlog(hp_work->errlog); 392 else 393 handle_dlpar_errorlog(hp_work->errlog); 394 395 if (hp_work->hp_completion) 396 complete(hp_work->hp_completion); 397 398 kfree(hp_work->errlog); 399 kfree((void *)work); 400 } 401 402 void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog, 403 struct completion *hotplug_done, int *rc) 404 { 405 struct pseries_hp_work *work; 406 struct pseries_hp_errorlog *hp_errlog_copy; 407 408 hp_errlog_copy = kmalloc(sizeof(struct pseries_hp_errorlog), 409 GFP_KERNEL); 410 memcpy(hp_errlog_copy, hp_errlog, sizeof(struct pseries_hp_errorlog)); 411 412 work = kmalloc(sizeof(struct pseries_hp_work), GFP_KERNEL); 413 if (work) { 414 INIT_WORK((struct work_struct *)work, pseries_hp_work_fn); 415 work->errlog = hp_errlog_copy; 416 work->hp_completion = hotplug_done; 417 work->rc = rc; 418 queue_work(pseries_hp_wq, (struct work_struct *)work); 419 } else { 420 *rc = -ENOMEM; 421 kfree(hp_errlog_copy); 422 complete(hotplug_done); 423 } 424 } 425 426 static int dlpar_parse_resource(char **cmd, struct pseries_hp_errorlog *hp_elog) 427 { 428 char *arg; 429 430 arg = strsep(cmd, " "); 431 if (!arg) 432 return -EINVAL; 433 434 if (sysfs_streq(arg, "memory")) { 435 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM; 436 } else if (sysfs_streq(arg, "cpu")) { 437 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_CPU; 438 } else { 439 pr_err("Invalid resource specified.\n"); 440 return -EINVAL; 441 } 442 443 return 0; 444 } 445 446 static int dlpar_parse_action(char **cmd, struct pseries_hp_errorlog *hp_elog) 447 { 448 char *arg; 449 450 arg = strsep(cmd, " "); 451 if (!arg) 452 return -EINVAL; 453 454 if (sysfs_streq(arg, "add")) { 455 hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD; 456 } else if (sysfs_streq(arg, "remove")) { 457 hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE; 458 } else { 459 pr_err("Invalid action specified.\n"); 460 return -EINVAL; 461 } 462 463 return 0; 464 } 465 466 static int dlpar_parse_id_type(char **cmd, struct pseries_hp_errorlog *hp_elog) 467 { 468 char *arg; 469 u32 count, index; 470 471 arg = strsep(cmd, " "); 472 if (!arg) 473 return -EINVAL; 474 475 if (sysfs_streq(arg, "indexed-count")) { 476 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_IC; 477 arg = strsep(cmd, " "); 478 if (!arg) { 479 pr_err("No DRC count specified.\n"); 480 return -EINVAL; 481 } 482 483 if (kstrtou32(arg, 0, &count)) { 484 pr_err("Invalid DRC count specified.\n"); 485 return -EINVAL; 486 } 487 488 arg = strsep(cmd, " "); 489 if (!arg) { 490 pr_err("No DRC Index specified.\n"); 491 return -EINVAL; 492 } 493 494 if (kstrtou32(arg, 0, &index)) { 495 pr_err("Invalid DRC Index specified.\n"); 496 return -EINVAL; 497 } 498 499 hp_elog->_drc_u.ic.count = cpu_to_be32(count); 500 hp_elog->_drc_u.ic.index = cpu_to_be32(index); 501 } else if (sysfs_streq(arg, "index")) { 502 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX; 503 arg = strsep(cmd, " "); 504 if (!arg) { 505 pr_err("No DRC Index specified.\n"); 506 return -EINVAL; 507 } 508 509 if (kstrtou32(arg, 0, &index)) { 510 pr_err("Invalid DRC Index specified.\n"); 511 return -EINVAL; 512 } 513 514 hp_elog->_drc_u.drc_index = cpu_to_be32(index); 515 } else if (sysfs_streq(arg, "count")) { 516 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT; 517 arg = strsep(cmd, " "); 518 if (!arg) { 519 pr_err("No DRC count specified.\n"); 520 return -EINVAL; 521 } 522 523 if (kstrtou32(arg, 0, &count)) { 524 pr_err("Invalid DRC count specified.\n"); 525 return -EINVAL; 526 } 527 528 hp_elog->_drc_u.drc_count = cpu_to_be32(count); 529 } else { 530 pr_err("Invalid id_type specified.\n"); 531 return -EINVAL; 532 } 533 534 return 0; 535 } 536 537 static ssize_t dlpar_store(struct class *class, struct class_attribute *attr, 538 const char *buf, size_t count) 539 { 540 struct pseries_hp_errorlog *hp_elog; 541 struct completion hotplug_done; 542 char *argbuf; 543 char *args; 544 int rc; 545 546 args = argbuf = kstrdup(buf, GFP_KERNEL); 547 hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL); 548 if (!hp_elog || !argbuf) { 549 pr_info("Could not allocate resources for DLPAR operation\n"); 550 kfree(argbuf); 551 kfree(hp_elog); 552 return -ENOMEM; 553 } 554 555 /* 556 * Parse out the request from the user, this will be in the form: 557 * <resource> <action> <id_type> <id> 558 */ 559 rc = dlpar_parse_resource(&args, hp_elog); 560 if (rc) 561 goto dlpar_store_out; 562 563 rc = dlpar_parse_action(&args, hp_elog); 564 if (rc) 565 goto dlpar_store_out; 566 567 rc = dlpar_parse_id_type(&args, hp_elog); 568 if (rc) 569 goto dlpar_store_out; 570 571 init_completion(&hotplug_done); 572 queue_hotplug_event(hp_elog, &hotplug_done, &rc); 573 wait_for_completion(&hotplug_done); 574 575 dlpar_store_out: 576 kfree(argbuf); 577 kfree(hp_elog); 578 579 if (rc) 580 pr_err("Could not handle DLPAR request \"%s\"\n", buf); 581 582 return rc ? rc : count; 583 } 584 585 static ssize_t dlpar_show(struct class *class, struct class_attribute *attr, 586 char *buf) 587 { 588 return sprintf(buf, "%s\n", "memory,cpu"); 589 } 590 591 static CLASS_ATTR(dlpar, S_IWUSR | S_IRUSR, dlpar_show, dlpar_store); 592 593 static int __init pseries_dlpar_init(void) 594 { 595 pseries_hp_wq = alloc_workqueue("pseries hotplug workqueue", 596 WQ_UNBOUND, 1); 597 return sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr); 598 } 599 machine_device_initcall(pseries, pseries_dlpar_init); 600 601