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