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