[mirror_ubuntu-bionic-kernel.git] / arch / powerpc / platforms / pseries / dlpar.c

/*
 * Support for dynamic reconfiguration for PCI, Memory, and CPU
 * Hotplug and Dynamic Logical Partitioning on RPA platforms.
 *
 * Copyright (C) 2009 Nathan Fontenot
 * Copyright (C) 2009 IBM Corporation
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 */

#define pr_fmt(fmt)	"dlpar: " fmt

#include <linux/kernel.h>
#include <linux/notifier.h>
#include <linux/spinlock.h>
#include <linux/cpu.h>
#include <linux/slab.h>
#include <linux/of.h>
#include "offline_states.h"
#include "pseries.h"

#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/uaccess.h>
#include <asm/rtas.h>

struct cc_workarea {
	__be32	drc_index;
	__be32	zero;
	__be32	name_offset;
	__be32	prop_length;
	__be32	prop_offset;
};

void dlpar_free_cc_property(struct property *prop)
{
	kfree(prop->name);
	kfree(prop->value);
	kfree(prop);
}

static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
{
	struct property *prop;
	char *name;
	char *value;

	prop = kzalloc(sizeof(*prop), GFP_KERNEL);
	if (!prop)
		return NULL;

	name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
	prop->name = kstrdup(name, GFP_KERNEL);

	prop->length = be32_to_cpu(ccwa->prop_length);
	value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset);
	prop->value = kmemdup(value, prop->length, GFP_KERNEL);
	if (!prop->value) {
		dlpar_free_cc_property(prop);
		return NULL;
	}

	return prop;
}

static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa,
					       const char *path)
{
	struct device_node *dn;
	char *name;

	/* If parent node path is "/" advance path to NULL terminator to
	 * prevent double leading slashs in full_name.
	 */
	if (!path[1])
		path++;

	dn = kzalloc(sizeof(*dn), GFP_KERNEL);
	if (!dn)
		return NULL;

	name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
	dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name);
	if (!dn->full_name) {
		kfree(dn);
		return NULL;
	}

	of_node_set_flag(dn, OF_DYNAMIC);
	of_node_init(dn);

	return dn;
}

static void dlpar_free_one_cc_node(struct device_node *dn)
{
	struct property *prop;

	while (dn->properties) {
		prop = dn->properties;
		dn->properties = prop->next;
		dlpar_free_cc_property(prop);
	}

	kfree(dn->full_name);
	kfree(dn);
}

void dlpar_free_cc_nodes(struct device_node *dn)
{
	if (dn->child)
		dlpar_free_cc_nodes(dn->child);

	if (dn->sibling)
		dlpar_free_cc_nodes(dn->sibling);

	dlpar_free_one_cc_node(dn);
}

#define COMPLETE	0
#define NEXT_SIBLING    1
#define NEXT_CHILD      2
#define NEXT_PROPERTY   3
#define PREV_PARENT     4
#define MORE_MEMORY     5
#define CALL_AGAIN	-2
#define ERR_CFG_USE     -9003

struct device_node *dlpar_configure_connector(__be32 drc_index,
					      struct device_node *parent)
{
	struct device_node *dn;
	struct device_node *first_dn = NULL;
	struct device_node *last_dn = NULL;
	struct property *property;
	struct property *last_property = NULL;
	struct cc_workarea *ccwa;
	char *data_buf;
	const char *parent_path = parent->full_name;
	int cc_token;
	int rc = -1;

	cc_token = rtas_token("ibm,configure-connector");
	if (cc_token == RTAS_UNKNOWN_SERVICE)
		return NULL;

	data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
	if (!data_buf)
		return NULL;

	ccwa = (struct cc_workarea *)&data_buf[0];
	ccwa->drc_index = drc_index;
	ccwa->zero = 0;

	do {
		/* Since we release the rtas_data_buf lock between configure
		 * connector calls we want to re-populate the rtas_data_buffer
		 * with the contents of the previous call.
		 */
		spin_lock(&rtas_data_buf_lock);

		memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE);
		rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
		memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);

		spin_unlock(&rtas_data_buf_lock);

		switch (rc) {
		case COMPLETE:
			break;

		case NEXT_SIBLING:
			dn = dlpar_parse_cc_node(ccwa, parent_path);
			if (!dn)
				goto cc_error;

			dn->parent = last_dn->parent;
			last_dn->sibling = dn;
			last_dn = dn;
			break;

		case NEXT_CHILD:
			if (first_dn)
				parent_path = last_dn->full_name;

			dn = dlpar_parse_cc_node(ccwa, parent_path);
			if (!dn)
				goto cc_error;

			if (!first_dn) {
				dn->parent = parent;
				first_dn = dn;
			} else {
				dn->parent = last_dn;
				if (last_dn)
					last_dn->child = dn;
			}

			last_dn = dn;
			break;

		case NEXT_PROPERTY:
			property = dlpar_parse_cc_property(ccwa);
			if (!property)
				goto cc_error;

			if (!last_dn->properties)
				last_dn->properties = property;
			else
				last_property->next = property;

			last_property = property;
			break;

		case PREV_PARENT:
			last_dn = last_dn->parent;
			parent_path = last_dn->parent->full_name;
			break;

		case CALL_AGAIN:
			break;

		case MORE_MEMORY:
		case ERR_CFG_USE:
		default:
			printk(KERN_ERR "Unexpected Error (%d) "
			       "returned from configure-connector\n", rc);
			goto cc_error;
		}
	} while (rc);

cc_error:
	kfree(data_buf);

	if (rc) {
		if (first_dn)
			dlpar_free_cc_nodes(first_dn);

		return NULL;
	}

	return first_dn;
}

static struct device_node *derive_parent(const char *path)
{
	struct device_node *parent;
	char *last_slash;

	last_slash = strrchr(path, '/');
	if (last_slash == path) {
		parent = of_find_node_by_path("/");
	} else {
		char *parent_path;
		int parent_path_len = last_slash - path + 1;
		parent_path = kmalloc(parent_path_len, GFP_KERNEL);
		if (!parent_path)
			return NULL;

		strlcpy(parent_path, path, parent_path_len);
		parent = of_find_node_by_path(parent_path);
		kfree(parent_path);
	}

	return parent;
}

int dlpar_attach_node(struct device_node *dn)
{
	int rc;

	dn->parent = derive_parent(dn->full_name);
	if (!dn->parent)
		return -ENOMEM;

	rc = of_attach_node(dn);
	if (rc) {
		printk(KERN_ERR "Failed to add device node %s\n",
		       dn->full_name);
		return rc;
	}

	of_node_put(dn->parent);
	return 0;
}

int dlpar_detach_node(struct device_node *dn)
{
	struct device_node *child;
	int rc;

	child = of_get_next_child(dn, NULL);
	while (child) {
		dlpar_detach_node(child);
		child = of_get_next_child(dn, child);
	}

	rc = of_detach_node(dn);
	if (rc)
		return rc;

	of_node_put(dn); /* Must decrement the refcount */
	return 0;
}

#define DR_ENTITY_SENSE		9003
#define DR_ENTITY_PRESENT	1
#define DR_ENTITY_UNUSABLE	2
#define ALLOCATION_STATE	9003
#define ALLOC_UNUSABLE		0
#define ALLOC_USABLE		1
#define ISOLATION_STATE		9001
#define ISOLATE			0
#define UNISOLATE		1

int dlpar_acquire_drc(u32 drc_index)
{
	int dr_status, rc;

	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
		       DR_ENTITY_SENSE, drc_index);
	if (rc || dr_status != DR_ENTITY_UNUSABLE)
		return -1;

	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
	if (rc)
		return rc;

	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
	if (rc) {
		rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
		return rc;
	}

	return 0;
}

int dlpar_release_drc(u32 drc_index)
{
	int dr_status, rc;

	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
		       DR_ENTITY_SENSE, drc_index);
	if (rc || dr_status != DR_ENTITY_PRESENT)
		return -1;

	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
	if (rc)
		return rc;

	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
	if (rc) {
		rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
		return rc;
	}

	return 0;
}

#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE

static int dlpar_online_cpu(struct device_node *dn)
{
	int rc = 0;
	unsigned int cpu;
	int len, nthreads, i;
	const __be32 *intserv;
	u32 thread;

	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	if (!intserv)
		return -EINVAL;

	nthreads = len / sizeof(u32);

	cpu_maps_update_begin();
	for (i = 0; i < nthreads; i++) {
		thread = be32_to_cpu(intserv[i]);
		for_each_present_cpu(cpu) {
			if (get_hard_smp_processor_id(cpu) != thread)
				continue;
			BUG_ON(get_cpu_current_state(cpu)
					!= CPU_STATE_OFFLINE);
			cpu_maps_update_done();
			rc = device_online(get_cpu_device(cpu));
			if (rc)
				goto out;
			cpu_maps_update_begin();

			break;
		}
		if (cpu == num_possible_cpus())
			printk(KERN_WARNING "Could not find cpu to online "
			       "with physical id 0x%x\n", thread);
	}
	cpu_maps_update_done();

out:
	return rc;

}

static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
{
	struct device_node *dn, *parent;
	u32 drc_index;
	int rc;

	rc = kstrtou32(buf, 0, &drc_index);
	if (rc)
		return -EINVAL;

	rc = dlpar_acquire_drc(drc_index);
	if (rc)
		return -EINVAL;

	parent = of_find_node_by_path("/cpus");
	if (!parent)
		return -ENODEV;

	dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent);
	of_node_put(parent);
	if (!dn) {
		dlpar_release_drc(drc_index);
		return -EINVAL;
	}

	rc = dlpar_attach_node(dn);
	if (rc) {
		dlpar_release_drc(drc_index);
		dlpar_free_cc_nodes(dn);
		return rc;
	}

	rc = dlpar_online_cpu(dn);
	if (rc)
		return rc;

	return count;
}

static int dlpar_offline_cpu(struct device_node *dn)
{
	int rc = 0;
	unsigned int cpu;
	int len, nthreads, i;
	const __be32 *intserv;
	u32 thread;

	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	if (!intserv)
		return -EINVAL;

	nthreads = len / sizeof(u32);

	cpu_maps_update_begin();
	for (i = 0; i < nthreads; i++) {
		thread = be32_to_cpu(intserv[i]);
		for_each_present_cpu(cpu) {
			if (get_hard_smp_processor_id(cpu) != thread)
				continue;

			if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
				break;

			if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
				set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
				cpu_maps_update_done();
				rc = device_offline(get_cpu_device(cpu));
				if (rc)
					goto out;
				cpu_maps_update_begin();
				break;

			}

			/*
			 * The cpu is in CPU_STATE_INACTIVE.
			 * Upgrade it's state to CPU_STATE_OFFLINE.
			 */
			set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
			BUG_ON(plpar_hcall_norets(H_PROD, thread)
								!= H_SUCCESS);
			__cpu_die(cpu);
			break;
		}
		if (cpu == num_possible_cpus())
			printk(KERN_WARNING "Could not find cpu to offline "
			       "with physical id 0x%x\n", thread);
	}
	cpu_maps_update_done();

out:
	return rc;

}

static ssize_t dlpar_cpu_release(const char *buf, size_t count)
{
	struct device_node *dn;
	u32 drc_index;
	int rc;

	dn = of_find_node_by_path(buf);
	if (!dn)
		return -EINVAL;

	rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
	if (rc) {
		of_node_put(dn);
		return -EINVAL;
	}

	rc = dlpar_offline_cpu(dn);
	if (rc) {
		of_node_put(dn);
		return -EINVAL;
	}

	rc = dlpar_release_drc(drc_index);
	if (rc) {
		of_node_put(dn);
		return rc;
	}

	rc = dlpar_detach_node(dn);
	if (rc) {
		dlpar_acquire_drc(drc_index);
		return rc;
	}

	of_node_put(dn);

	return count;
}

#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */

static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
{
	int rc;

	/* pseries error logs are in BE format, convert to cpu type */
	switch (hp_elog->id_type) {
	case PSERIES_HP_ELOG_ID_DRC_COUNT:
		hp_elog->_drc_u.drc_count =
					be32_to_cpu(hp_elog->_drc_u.drc_count);
		break;
	case PSERIES_HP_ELOG_ID_DRC_INDEX:
		hp_elog->_drc_u.drc_index =
					be32_to_cpu(hp_elog->_drc_u.drc_index);
	}

	switch (hp_elog->resource) {
	case PSERIES_HP_ELOG_RESOURCE_MEM:
		rc = dlpar_memory(hp_elog);
		break;
	default:
		pr_warn_ratelimited("Invalid resource (%d) specified\n",
				    hp_elog->resource);
		rc = -EINVAL;
	}

	return rc;
}

static ssize_t dlpar_store(struct class *class, struct class_attribute *attr,
			   const char *buf, size_t count)
{
	struct pseries_hp_errorlog *hp_elog;
	const char *arg;
	int rc;

	hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL);
	if (!hp_elog) {
		rc = -ENOMEM;
		goto dlpar_store_out;
	}

	/* Parse out the request from the user, this will be in the form
	 * <resource> <action> <id_type> <id>
	 */
	arg = buf;
	if (!strncmp(arg, "memory", 6)) {
		hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM;
		arg += strlen("memory ");
	} else {
		pr_err("Invalid resource specified: \"%s\"\n", buf);
		rc = -EINVAL;
		goto dlpar_store_out;
	}

	if (!strncmp(arg, "add", 3)) {
		hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD;
		arg += strlen("add ");
	} else if (!strncmp(arg, "remove", 6)) {
		hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE;
		arg += strlen("remove ");
	} else {
		pr_err("Invalid action specified: \"%s\"\n", buf);
		rc = -EINVAL;
		goto dlpar_store_out;
	}

	if (!strncmp(arg, "index", 5)) {
		u32 index;

		hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
		arg += strlen("index ");
		if (kstrtou32(arg, 0, &index)) {
			rc = -EINVAL;
			pr_err("Invalid drc_index specified: \"%s\"\n", buf);
			goto dlpar_store_out;
		}

		hp_elog->_drc_u.drc_index = cpu_to_be32(index);
	} else if (!strncmp(arg, "count", 5)) {
		u32 count;

		hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT;
		arg += strlen("count ");
		if (kstrtou32(arg, 0, &count)) {
			rc = -EINVAL;
			pr_err("Invalid count specified: \"%s\"\n", buf);
			goto dlpar_store_out;
		}

		hp_elog->_drc_u.drc_count = cpu_to_be32(count);
	} else {
		pr_err("Invalid id_type specified: \"%s\"\n", buf);
		rc = -EINVAL;
		goto dlpar_store_out;
	}

	rc = handle_dlpar_errorlog(hp_elog);

dlpar_store_out:
	kfree(hp_elog);
	return rc ? rc : count;
}

static CLASS_ATTR(dlpar, S_IWUSR, NULL, dlpar_store);

static int __init pseries_dlpar_init(void)
{
	int rc;

#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
	ppc_md.cpu_probe = dlpar_cpu_probe;
	ppc_md.cpu_release = dlpar_cpu_release;
#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */

	rc = sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr);

	return rc;
}
machine_device_initcall(pseries, pseries_dlpar_init);
Commit	Line	Data
ab519a01 NF	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
999e2dad NF	13	#define pr_fmt(fmt) "dlpar: " fmt
999e2dad NF	14
ab519a01	15	#include <linux/kernel.h>
ab519a01	16	#include <linux/notifier.h>
ab519a01 NF	17	#include <linux/spinlock.h>
ab519a01 NF	18	#include <linux/cpu.h>
5a0e3ad6	19	#include <linux/slab.h>
1cf3d8b3	20	#include <linux/of.h>
b6db63d1	21	#include "offline_states.h"
1217d34b	22	#include "pseries.h"
ab519a01 NF	23
	24	#include <asm/prom.h>
	25	#include <asm/machdep.h>
	26	#include <asm/uaccess.h>
	27	#include <asm/rtas.h>
ab519a01 NF	28
ab519a01 NF	29	struct cc_workarea {
d6f1e7ab BR	30	__be32 drc_index;
	31	__be32 zero;
	32	__be32 name_offset;
	33	__be32 prop_length;
	34	__be32 prop_offset;
ab519a01 NF	35	};
ab519a01 NF	36
20648974	37	void dlpar_free_cc_property(struct property *prop)
ab519a01 NF	38	{
	39	kfree(prop->name);
	40	kfree(prop->value);
	41	kfree(prop);
	42	}
	43
	44	static struct property dlpar_parse_cc_property(struct cc_workarea ccwa)
	45	{
	46	struct property *prop;
	47	char *name;
	48	char *value;
	49
	50	prop = kzalloc(sizeof(*prop), GFP_KERNEL);
	51	if (!prop)
	52	return NULL;
	53
d6f1e7ab	54	name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
ab519a01 NF	55	prop->name = kstrdup(name, GFP_KERNEL);
ab519a01 NF	56
d6f1e7ab BR	57	prop->length = be32_to_cpu(ccwa->prop_length);
d6f1e7ab BR	58	value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset);
e72ed6b5	59	prop->value = kmemdup(value, prop->length, GFP_KERNEL);
ab519a01 NF	60	if (!prop->value) {
	61	dlpar_free_cc_property(prop);
	62	return NULL;
	63	}
	64
ab519a01 NF	65	return prop;
	66	}
	67
8d5ff320 TD	68	static struct device_node dlpar_parse_cc_node(struct cc_workarea ccwa,
8d5ff320 TD	69	const char *path)
ab519a01 NF	70	{
	71	struct device_node *dn;
	72	char *name;
	73
8d5ff320 TD	74	/* If parent node path is "/" advance path to NULL terminator to
	75	* prevent double leading slashs in full_name.
	76	*/
	77	if (!path[1])
	78	path++;
	79
ab519a01 NF	80	dn = kzalloc(sizeof(*dn), GFP_KERNEL);
	81	if (!dn)
	82	return NULL;
	83
d6f1e7ab	84	name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
8d5ff320	85	dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name);
ab519a01 NF	86	if (!dn->full_name) {
	87	kfree(dn);
	88	return NULL;
	89	}
	90
1578cb76	91	of_node_set_flag(dn, OF_DYNAMIC);
97a9a717	92	of_node_init(dn);
1578cb76	93
ab519a01 NF	94	return dn;
	95	}
	96
	97	static void dlpar_free_one_cc_node(struct device_node *dn)
	98	{
	99	struct property *prop;
	100
	101	while (dn->properties) {
	102	prop = dn->properties;
	103	dn->properties = prop->next;
	104	dlpar_free_cc_property(prop);
	105	}
	106
	107	kfree(dn->full_name);
	108	kfree(dn);
	109	}
	110
20648974	111	void dlpar_free_cc_nodes(struct device_node *dn)
ab519a01 NF	112	{
	113	if (dn->child)
	114	dlpar_free_cc_nodes(dn->child);
	115
	116	if (dn->sibling)
	117	dlpar_free_cc_nodes(dn->sibling);
	118
	119	dlpar_free_one_cc_node(dn);
	120	}
	121
9c740025	122	#define COMPLETE 0
ab519a01 NF	123	#define NEXT_SIBLING 1
	124	#define NEXT_CHILD 2
	125	#define NEXT_PROPERTY 3
	126	#define PREV_PARENT 4
	127	#define MORE_MEMORY 5
	128	#define CALL_AGAIN -2
	129	#define ERR_CFG_USE -9003
	130
d6f1e7ab	131	struct device_node *dlpar_configure_connector(__be32 drc_index,
8d5ff320	132	struct device_node *parent)
ab519a01 NF	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;
93f68f1e	140	char *data_buf;
8d5ff320	141	const char *parent_path = parent->full_name;
ab519a01	142	int cc_token;
93f68f1e	143	int rc = -1;
ab519a01 NF	144
	145	cc_token = rtas_token("ibm,configure-connector");
	146	if (cc_token == RTAS_UNKNOWN_SERVICE)
	147	return NULL;
	148
93f68f1e NF	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];
ab519a01 NF	154	ccwa->drc_index = drc_index;
	155	ccwa->zero = 0;
	156
93f68f1e NF	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
ab519a01	170	switch (rc) {
9c740025 AB	171	case COMPLETE:
	172	break;
	173
ab519a01	174	case NEXT_SIBLING:
8d5ff320	175	dn = dlpar_parse_cc_node(ccwa, parent_path);
ab519a01 NF	176	if (!dn)
	177	goto cc_error;
	178
	179	dn->parent = last_dn->parent;
	180	last_dn->sibling = dn;
	181	last_dn = dn;
	182	break;
	183
	184	case NEXT_CHILD:
8d5ff320 TD	185	if (first_dn)
	186	parent_path = last_dn->full_name;
	187
	188	dn = dlpar_parse_cc_node(ccwa, parent_path);
ab519a01 NF	189	if (!dn)
	190	goto cc_error;
	191
8d5ff320 TD	192	if (!first_dn) {
8d5ff320 TD	193	dn->parent = parent;
ab519a01	194	first_dn = dn;
8d5ff320	195	} else {
ab519a01 NF	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;
8d5ff320	219	parent_path = last_dn->parent->full_name;
ab519a01 NF	220	break;
	221
	222	case CALL_AGAIN:
	223	break;
	224
	225	case MORE_MEMORY:
	226	case ERR_CFG_USE:
	227	default:
	228	printk(KERN_ERR "Unexpected Error (%d) "
	229	"returned from configure-connector\n", rc);
	230	goto cc_error;
	231	}
93f68f1e	232	} while (rc);
ab519a01	233
93f68f1e NF	234	cc_error:
	235	kfree(data_buf);
	236
	237	if (rc) {
	238	if (first_dn)
	239	dlpar_free_cc_nodes(first_dn);
	240
	241	return NULL;
ab519a01 NF	242	}
ab519a01 NF	243
ab519a01	244	return first_dn;
ab519a01 NF	245	}
	246
	247	static struct device_node derive_parent(const char path)
	248	{
	249	struct device_node *parent;
	250	char *last_slash;
	251
	252	last_slash = strrchr(path, '/');
	253	if (last_slash == path) {
	254	parent = of_find_node_by_path("/");
	255	} else {
	256	char *parent_path;
	257	int parent_path_len = last_slash - path + 1;
	258	parent_path = kmalloc(parent_path_len, GFP_KERNEL);
	259	if (!parent_path)
	260	return NULL;
	261
	262	strlcpy(parent_path, path, parent_path_len);
	263	parent = of_find_node_by_path(parent_path);
	264	kfree(parent_path);
	265	}
	266
	267	return parent;
	268	}
	269
	270	int dlpar_attach_node(struct device_node *dn)
	271	{
ab519a01 NF	272	int rc;
ab519a01 NF	273
ab519a01 NF	274	dn->parent = derive_parent(dn->full_name);
	275	if (!dn->parent)
	276	return -ENOMEM;
	277
1cf3d8b3	278	rc = of_attach_node(dn);
3aef19f0	279	if (rc) {
ab519a01 NF	280	printk(KERN_ERR "Failed to add device node %s\n",
ab519a01 NF	281	dn->full_name);
3aef19f0	282	return rc;
ab519a01 NF	283	}
ab519a01 NF	284
ab519a01 NF	285	of_node_put(dn->parent);
	286	return 0;
	287	}
	288
	289	int dlpar_detach_node(struct device_node *dn)
	290	{
5935ff43	291	struct device_node *child;
1cf3d8b3	292	int rc;
ab519a01	293
5935ff43 TD	294	child = of_get_next_child(dn, NULL);
	295	while (child) {
	296	dlpar_detach_node(child);
	297	child = of_get_next_child(dn, child);
	298	}
	299
1cf3d8b3 NF	300	rc = of_detach_node(dn);
	301	if (rc)
	302	return rc;
	303
	304	of_node_put(dn); /* Must decrement the refcount */
ab519a01 NF	305	return 0;
	306	}
	307
	308	#define DR_ENTITY_SENSE 9003
	309	#define DR_ENTITY_PRESENT 1
	310	#define DR_ENTITY_UNUSABLE 2
	311	#define ALLOCATION_STATE 9003
	312	#define ALLOC_UNUSABLE 0
	313	#define ALLOC_USABLE 1
	314	#define ISOLATION_STATE 9001
	315	#define ISOLATE 0
	316	#define UNISOLATE 1
	317
	318	int dlpar_acquire_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_UNUSABLE)
	325	return -1;
	326
	327	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
	328	if (rc)
	329	return rc;
	330
	331	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
	332	if (rc) {
	333	rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
	334	return rc;
	335	}
	336
	337	return 0;
	338	}
	339
	340	int dlpar_release_drc(u32 drc_index)
	341	{
	342	int dr_status, rc;
	343
	344	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
	345	DR_ENTITY_SENSE, drc_index);
	346	if (rc \|\| dr_status != DR_ENTITY_PRESENT)
	347	return -1;
	348
	349	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
	350	if (rc)
	351	return rc;
	352
	353	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
	354	if (rc) {
	355	rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
	356	return rc;
	357	}
	358
	359	return 0;
	360	}
	361
1a8061c4	362	#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
ab519a01	363
275a64f6 NF	364	static int dlpar_online_cpu(struct device_node *dn)
	365	{
	366	int rc = 0;
	367	unsigned int cpu;
	368	int len, nthreads, i;
822e7122 TF	369	const __be32 *intserv;
822e7122 TF	370	u32 thread;
275a64f6 NF	371
	372	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	373	if (!intserv)
	374	return -EINVAL;
	375
	376	nthreads = len / sizeof(u32);
	377
	378	cpu_maps_update_begin();
	379	for (i = 0; i < nthreads; i++) {
822e7122	380	thread = be32_to_cpu(intserv[i]);
275a64f6	381	for_each_present_cpu(cpu) {
822e7122	382	if (get_hard_smp_processor_id(cpu) != thread)
275a64f6 NF	383	continue;
	384	BUG_ON(get_cpu_current_state(cpu)
	385	!= CPU_STATE_OFFLINE);
	386	cpu_maps_update_done();
10ccaf17	387	rc = device_online(get_cpu_device(cpu));
275a64f6 NF	388	if (rc)
	389	goto out;
	390	cpu_maps_update_begin();
	391
	392	break;
	393	}
	394	if (cpu == num_possible_cpus())
	395	printk(KERN_WARNING "Could not find cpu to online "
822e7122	396	"with physical id 0x%x\n", thread);
275a64f6 NF	397	}
	398	cpu_maps_update_done();
	399
	400	out:
	401	return rc;
	402
	403	}
	404
1a8061c4 NF	405	static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
1a8061c4 NF	406	{
8d5ff320	407	struct device_node dn, parent;
1618bd53	408	u32 drc_index;
1a8061c4 NF	409	int rc;
1a8061c4 NF	410
1618bd53	411	rc = kstrtou32(buf, 0, &drc_index);
6dedcca6 TK	412	if (rc)
6dedcca6 TK	413	return -EINVAL;
1a8061c4	414
f32393c9 NF	415	rc = dlpar_acquire_drc(drc_index);
	416	if (rc)
	417	return -EINVAL;
	418
8d5ff320	419	parent = of_find_node_by_path("/cpus");
6dedcca6 TK	420	if (!parent)
6dedcca6 TK	421	return -ENODEV;
1a8061c4	422
d6f1e7ab	423	dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent);
2222ce0f	424	of_node_put(parent);
daebaabb BR	425	if (!dn) {
daebaabb BR	426	dlpar_release_drc(drc_index);
6dedcca6	427	return -EINVAL;
daebaabb	428	}
1a8061c4	429
1a8061c4 NF	430	rc = dlpar_attach_node(dn);
	431	if (rc) {
	432	dlpar_release_drc(drc_index);
	433	dlpar_free_cc_nodes(dn);
6dedcca6	434	return rc;
1a8061c4 NF	435	}
1a8061c4 NF	436
275a64f6	437	rc = dlpar_online_cpu(dn);
6dedcca6 TK	438	if (rc)
6dedcca6 TK	439	return rc;
b6db63d1	440
6dedcca6	441	return count;
1a8061c4 NF	442	}
1a8061c4 NF	443
275a64f6 NF	444	static int dlpar_offline_cpu(struct device_node *dn)
	445	{
	446	int rc = 0;
	447	unsigned int cpu;
	448	int len, nthreads, i;
e36d1227 TF	449	const __be32 *intserv;
e36d1227 TF	450	u32 thread;
275a64f6 NF	451
	452	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	453	if (!intserv)
	454	return -EINVAL;
	455
	456	nthreads = len / sizeof(u32);
	457
	458	cpu_maps_update_begin();
	459	for (i = 0; i < nthreads; i++) {
e36d1227	460	thread = be32_to_cpu(intserv[i]);
275a64f6	461	for_each_present_cpu(cpu) {
e36d1227	462	if (get_hard_smp_processor_id(cpu) != thread)
275a64f6 NF	463	continue;
	464
	465	if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
	466	break;
	467
	468	if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
ceddee23	469	set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
275a64f6	470	cpu_maps_update_done();
10ccaf17	471	rc = device_offline(get_cpu_device(cpu));
275a64f6 NF	472	if (rc)
	473	goto out;
	474	cpu_maps_update_begin();
	475	break;
	476
	477	}
	478
	479	/*
	480	* The cpu is in CPU_STATE_INACTIVE.
	481	* Upgrade it's state to CPU_STATE_OFFLINE.
	482	*/
	483	set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
e36d1227	484	BUG_ON(plpar_hcall_norets(H_PROD, thread)
275a64f6 NF	485	!= H_SUCCESS);
	486	__cpu_die(cpu);
	487	break;
	488	}
	489	if (cpu == num_possible_cpus())
	490	printk(KERN_WARNING "Could not find cpu to offline "
e36d1227	491	"with physical id 0x%x\n", thread);
275a64f6 NF	492	}
	493	cpu_maps_update_done();
	494
	495	out:
	496	return rc;
	497
	498	}
	499
1a8061c4 NF	500	static ssize_t dlpar_cpu_release(const char *buf, size_t count)
	501	{
	502	struct device_node *dn;
e36d1227	503	u32 drc_index;
1a8061c4 NF	504	int rc;
	505
	506	dn = of_find_node_by_path(buf);
	507	if (!dn)
	508	return -EINVAL;
	509
e36d1227 TF	510	rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
e36d1227 TF	511	if (rc) {
1a8061c4 NF	512	of_node_put(dn);
	513	return -EINVAL;
	514	}
	515
275a64f6	516	rc = dlpar_offline_cpu(dn);
b6db63d1 GS	517	if (rc) {
b6db63d1 GS	518	of_node_put(dn);
6dedcca6	519	return -EINVAL;
b6db63d1 GS	520	}
b6db63d1 GS	521
e36d1227	522	rc = dlpar_release_drc(drc_index);
1a8061c4 NF	523	if (rc) {
1a8061c4 NF	524	of_node_put(dn);
6dedcca6	525	return rc;
1a8061c4 NF	526	}
	527
	528	rc = dlpar_detach_node(dn);
	529	if (rc) {
e36d1227	530	dlpar_acquire_drc(drc_index);
6dedcca6	531	return rc;
1a8061c4 NF	532	}
	533
	534	of_node_put(dn);
6dedcca6 TK	535
6dedcca6 TK	536	return count;
1a8061c4 NF	537	}
1a8061c4 NF	538
999e2dad NF	539	#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
	540
	541	static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
	542	{
	543	int rc;
	544
	545	/* pseries error logs are in BE format, convert to cpu type */
	546	switch (hp_elog->id_type) {
	547	case PSERIES_HP_ELOG_ID_DRC_COUNT:
	548	hp_elog->_drc_u.drc_count =
	549	be32_to_cpu(hp_elog->_drc_u.drc_count);
	550	break;
	551	case PSERIES_HP_ELOG_ID_DRC_INDEX:
	552	hp_elog->_drc_u.drc_index =
	553	be32_to_cpu(hp_elog->_drc_u.drc_index);
	554	}
	555
	556	switch (hp_elog->resource) {
	557	case PSERIES_HP_ELOG_RESOURCE_MEM:
	558	rc = dlpar_memory(hp_elog);
	559	break;
	560	default:
	561	pr_warn_ratelimited("Invalid resource (%d) specified\n",
	562	hp_elog->resource);
	563	rc = -EINVAL;
	564	}
	565
	566	return rc;
	567	}
	568
	569	static ssize_t dlpar_store(struct class class, struct class_attribute attr,
	570	const char *buf, size_t count)
	571	{
	572	struct pseries_hp_errorlog *hp_elog;
	573	const char *arg;
	574	int rc;
	575
	576	hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL);
	577	if (!hp_elog) {
	578	rc = -ENOMEM;
	579	goto dlpar_store_out;
	580	}
	581
	582	/* Parse out the request from the user, this will be in the form
	583	* <resource> <action> <id_type> <id>
	584	*/
	585	arg = buf;
	586	if (!strncmp(arg, "memory", 6)) {
	587	hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM;
	588	arg += strlen("memory ");
	589	} else {
	590	pr_err("Invalid resource specified: \"%s\"\n", buf);
	591	rc = -EINVAL;
	592	goto dlpar_store_out;
	593	}
	594
	595	if (!strncmp(arg, "add", 3)) {
	596	hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD;
	597	arg += strlen("add ");
	598	} else if (!strncmp(arg, "remove", 6)) {
	599	hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE;
	600	arg += strlen("remove ");
	601	} else {
	602	pr_err("Invalid action specified: \"%s\"\n", buf);
603	rc = -EINVAL;
604	goto dlpar_store_out;
605	}
606
607	if (!strncmp(arg, "index", 5)) {
608	u32 index;
609
610	hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
611	arg += strlen("index ");
612	if (kstrtou32(arg, 0, &index)) {
613	rc = -EINVAL;
614	pr_err("Invalid drc_index specified: \"%s\"\n", buf);
615	goto dlpar_store_out;
616	}
617
618	hp_elog->_drc_u.drc_index = cpu_to_be32(index);
619	} else if (!strncmp(arg, "count", 5)) {
620	u32 count;
621
622	hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT;
623	arg += strlen("count ");
624	if (kstrtou32(arg, 0, &count)) {
625	rc = -EINVAL;
626	pr_err("Invalid count specified: \"%s\"\n", buf);
627	goto dlpar_store_out;
628	}
629
630	hp_elog->_drc_u.drc_count = cpu_to_be32(count);
631	} else {
632	pr_err("Invalid id_type specified: \"%s\"\n", buf);
633	rc = -EINVAL;
634	goto dlpar_store_out;
635	}
636
637	rc = handle_dlpar_errorlog(hp_elog);
638
639	dlpar_store_out:
640	kfree(hp_elog);
641	return rc ? rc : count;
642	}
643
644	static CLASS_ATTR(dlpar, S_IWUSR, NULL, dlpar_store);
645
1a8061c4 NF	646	static int __init pseries_dlpar_init(void)
1a8061c4 NF	647	{
999e2dad NF	648	int rc;
	649
	650	#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
1a8061c4 NF	651	ppc_md.cpu_probe = dlpar_cpu_probe;
1a8061c4 NF	652	ppc_md.cpu_release = dlpar_cpu_release;
999e2dad	653	#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
1a8061c4	654
999e2dad NF	655	rc = sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr);
	656
	657	return rc;
1a8061c4 NF	658	}
	659	machine_device_initcall(pseries, pseries_dlpar_init);
	660