1 // SPDX-License-Identifier: GPL-2.0-only
3 * Support for dynamic reconfiguration for PCI, Memory, and CPU
4 * Hotplug and Dynamic Logical Partitioning on RPA platforms.
6 * Copyright (C) 2009 Nathan Fontenot
7 * Copyright (C) 2009 IBM Corporation
10 #define pr_fmt(fmt) "dlpar: " fmt
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>
19 #include "of_helpers.h"
23 #include <asm/machdep.h>
24 #include <linux/uaccess.h>
27 static struct workqueue_struct *pseries_hp_wq;
29 struct pseries_hp_work {
30 struct work_struct work;
31 struct pseries_hp_errorlog *errlog;
42 void dlpar_free_cc_property(struct property *prop)
49 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
51 struct property *prop;
55 prop = kzalloc(sizeof(*prop), GFP_KERNEL);
59 name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
60 prop->name = kstrdup(name, GFP_KERNEL);
62 prop->length = be32_to_cpu(ccwa->prop_length);
63 value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset);
64 prop->value = kmemdup(value, prop->length, GFP_KERNEL);
66 dlpar_free_cc_property(prop);
73 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa)
75 struct device_node *dn;
78 dn = kzalloc(sizeof(*dn), GFP_KERNEL);
82 name = (const char *)ccwa + be32_to_cpu(ccwa->name_offset);
83 dn->full_name = kstrdup(name, GFP_KERNEL);
89 of_node_set_flag(dn, OF_DYNAMIC);
95 static void dlpar_free_one_cc_node(struct device_node *dn)
97 struct property *prop;
99 while (dn->properties) {
100 prop = dn->properties;
101 dn->properties = prop->next;
102 dlpar_free_cc_property(prop);
105 kfree(dn->full_name);
109 void dlpar_free_cc_nodes(struct device_node *dn)
112 dlpar_free_cc_nodes(dn->child);
115 dlpar_free_cc_nodes(dn->sibling);
117 dlpar_free_one_cc_node(dn);
121 #define NEXT_SIBLING 1
123 #define NEXT_PROPERTY 3
124 #define PREV_PARENT 4
125 #define MORE_MEMORY 5
126 #define CALL_AGAIN -2
127 #define ERR_CFG_USE -9003
129 struct device_node *dlpar_configure_connector(__be32 drc_index,
130 struct device_node *parent)
132 struct device_node *dn;
133 struct device_node *first_dn = NULL;
134 struct device_node *last_dn = NULL;
135 struct property *property;
136 struct property *last_property = NULL;
137 struct cc_workarea *ccwa;
142 cc_token = rtas_token("ibm,configure-connector");
143 if (cc_token == RTAS_UNKNOWN_SERVICE)
146 data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
150 ccwa = (struct cc_workarea *)&data_buf[0];
151 ccwa->drc_index = drc_index;
155 /* Since we release the rtas_data_buf lock between configure
156 * connector calls we want to re-populate the rtas_data_buffer
157 * with the contents of the previous call.
159 spin_lock(&rtas_data_buf_lock);
161 memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE);
162 rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
163 memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);
165 spin_unlock(&rtas_data_buf_lock);
172 dn = dlpar_parse_cc_node(ccwa);
176 dn->parent = last_dn->parent;
177 last_dn->sibling = dn;
182 dn = dlpar_parse_cc_node(ccwa);
190 dn->parent = last_dn;
199 property = dlpar_parse_cc_property(ccwa);
203 if (!last_dn->properties)
204 last_dn->properties = property;
206 last_property->next = property;
208 last_property = property;
212 last_dn = last_dn->parent;
221 printk(KERN_ERR "Unexpected Error (%d) "
222 "returned from configure-connector\n", rc);
232 dlpar_free_cc_nodes(first_dn);
240 int dlpar_attach_node(struct device_node *dn, struct device_node *parent)
246 rc = of_attach_node(dn);
248 printk(KERN_ERR "Failed to add device node %pOF\n", dn);
255 int dlpar_detach_node(struct device_node *dn)
257 struct device_node *child;
260 child = of_get_next_child(dn, NULL);
262 dlpar_detach_node(child);
263 child = of_get_next_child(dn, child);
266 rc = of_detach_node(dn);
275 #define DR_ENTITY_SENSE 9003
276 #define DR_ENTITY_PRESENT 1
277 #define DR_ENTITY_UNUSABLE 2
278 #define ALLOCATION_STATE 9003
279 #define ALLOC_UNUSABLE 0
280 #define ALLOC_USABLE 1
281 #define ISOLATION_STATE 9001
285 int dlpar_acquire_drc(u32 drc_index)
289 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
290 DR_ENTITY_SENSE, drc_index);
291 if (rc || dr_status != DR_ENTITY_UNUSABLE)
294 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
298 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
300 rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
307 int dlpar_release_drc(u32 drc_index)
311 rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
312 DR_ENTITY_SENSE, drc_index);
313 if (rc || dr_status != DR_ENTITY_PRESENT)
316 rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
320 rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
322 rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
329 int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
333 /* pseries error logs are in BE format, convert to cpu type */
334 switch (hp_elog->id_type) {
335 case PSERIES_HP_ELOG_ID_DRC_COUNT:
336 hp_elog->_drc_u.drc_count =
337 be32_to_cpu(hp_elog->_drc_u.drc_count);
339 case PSERIES_HP_ELOG_ID_DRC_INDEX:
340 hp_elog->_drc_u.drc_index =
341 be32_to_cpu(hp_elog->_drc_u.drc_index);
343 case PSERIES_HP_ELOG_ID_DRC_IC:
344 hp_elog->_drc_u.ic.count =
345 be32_to_cpu(hp_elog->_drc_u.ic.count);
346 hp_elog->_drc_u.ic.index =
347 be32_to_cpu(hp_elog->_drc_u.ic.index);
350 switch (hp_elog->resource) {
351 case PSERIES_HP_ELOG_RESOURCE_MEM:
352 rc = dlpar_memory(hp_elog);
354 case PSERIES_HP_ELOG_RESOURCE_CPU:
355 rc = dlpar_cpu(hp_elog);
357 case PSERIES_HP_ELOG_RESOURCE_PMEM:
358 rc = dlpar_hp_pmem(hp_elog);
362 pr_warn_ratelimited("Invalid resource (%d) specified\n",
370 static void pseries_hp_work_fn(struct work_struct *work)
372 struct pseries_hp_work *hp_work =
373 container_of(work, struct pseries_hp_work, work);
375 handle_dlpar_errorlog(hp_work->errlog);
377 kfree(hp_work->errlog);
381 void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog)
383 struct pseries_hp_work *work;
384 struct pseries_hp_errorlog *hp_errlog_copy;
386 hp_errlog_copy = kmalloc(sizeof(struct pseries_hp_errorlog),
388 memcpy(hp_errlog_copy, hp_errlog, sizeof(struct pseries_hp_errorlog));
390 work = kmalloc(sizeof(struct pseries_hp_work), GFP_KERNEL);
392 INIT_WORK((struct work_struct *)work, pseries_hp_work_fn);
393 work->errlog = hp_errlog_copy;
394 queue_work(pseries_hp_wq, (struct work_struct *)work);
396 kfree(hp_errlog_copy);
400 static int dlpar_parse_resource(char **cmd, struct pseries_hp_errorlog *hp_elog)
404 arg = strsep(cmd, " ");
408 if (sysfs_streq(arg, "memory")) {
409 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM;
410 } else if (sysfs_streq(arg, "cpu")) {
411 hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_CPU;
413 pr_err("Invalid resource specified.\n");
420 static int dlpar_parse_action(char **cmd, struct pseries_hp_errorlog *hp_elog)
424 arg = strsep(cmd, " ");
428 if (sysfs_streq(arg, "add")) {
429 hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD;
430 } else if (sysfs_streq(arg, "remove")) {
431 hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE;
433 pr_err("Invalid action specified.\n");
440 static int dlpar_parse_id_type(char **cmd, struct pseries_hp_errorlog *hp_elog)
445 arg = strsep(cmd, " ");
449 if (sysfs_streq(arg, "indexed-count")) {
450 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_IC;
451 arg = strsep(cmd, " ");
453 pr_err("No DRC count specified.\n");
457 if (kstrtou32(arg, 0, &count)) {
458 pr_err("Invalid DRC count specified.\n");
462 arg = strsep(cmd, " ");
464 pr_err("No DRC Index specified.\n");
468 if (kstrtou32(arg, 0, &index)) {
469 pr_err("Invalid DRC Index specified.\n");
473 hp_elog->_drc_u.ic.count = cpu_to_be32(count);
474 hp_elog->_drc_u.ic.index = cpu_to_be32(index);
475 } else if (sysfs_streq(arg, "index")) {
476 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
477 arg = strsep(cmd, " ");
479 pr_err("No DRC Index specified.\n");
483 if (kstrtou32(arg, 0, &index)) {
484 pr_err("Invalid DRC Index specified.\n");
488 hp_elog->_drc_u.drc_index = cpu_to_be32(index);
489 } else if (sysfs_streq(arg, "count")) {
490 hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT;
491 arg = strsep(cmd, " ");
493 pr_err("No DRC count specified.\n");
497 if (kstrtou32(arg, 0, &count)) {
498 pr_err("Invalid DRC count specified.\n");
502 hp_elog->_drc_u.drc_count = cpu_to_be32(count);
504 pr_err("Invalid id_type specified.\n");
511 static ssize_t dlpar_store(struct class *class, struct class_attribute *attr,
512 const char *buf, size_t count)
514 struct pseries_hp_errorlog hp_elog;
519 args = argbuf = kstrdup(buf, GFP_KERNEL);
521 pr_info("Could not allocate resources for DLPAR operation\n");
527 * Parse out the request from the user, this will be in the form:
528 * <resource> <action> <id_type> <id>
530 rc = dlpar_parse_resource(&args, &hp_elog);
532 goto dlpar_store_out;
534 rc = dlpar_parse_action(&args, &hp_elog);
536 goto dlpar_store_out;
538 rc = dlpar_parse_id_type(&args, &hp_elog);
540 goto dlpar_store_out;
542 rc = handle_dlpar_errorlog(&hp_elog);
548 pr_err("Could not handle DLPAR request \"%s\"\n", buf);
550 return rc ? rc : count;
553 static ssize_t dlpar_show(struct class *class, struct class_attribute *attr,
556 return sprintf(buf, "%s\n", "memory,cpu");
559 static CLASS_ATTR_RW(dlpar);
561 int __init dlpar_workqueue_init(void)
566 pseries_hp_wq = alloc_workqueue("pseries hotplug workqueue",
569 return pseries_hp_wq ? 0 : -ENOMEM;
572 static int __init dlpar_sysfs_init(void)
576 rc = dlpar_workqueue_init();
580 return sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr);
582 machine_device_initcall(pseries, dlpar_sysfs_init);