[linux-2.6-block.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.
 */

#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 <asm/prom.h>
#include <asm/machdep.h>
#include <asm/uaccess.h>
#include <asm/rtas.h>

struct cc_workarea {
	u32	drc_index;
	u32	zero;
	u32	name_offset;
	u32	prop_length;
	u32	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 + ccwa->name_offset;
	prop->name = kstrdup(name, GFP_KERNEL);

	prop->length = ccwa->prop_length;
	value = (char *)ccwa + 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 + 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(u32 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 u32 *intserv;

	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++) {
		for_each_present_cpu(cpu) {
			if (get_hard_smp_processor_id(cpu) != intserv[i])
				continue;
			BUG_ON(get_cpu_current_state(cpu)
					!= CPU_STATE_OFFLINE);
			cpu_maps_update_done();
			rc = cpu_up(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", intserv[i]);
	}
	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;

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

	dn = dlpar_configure_connector(drc_index, parent);
	if (!dn)
		return -EINVAL;

	of_node_put(parent);

	rc = dlpar_acquire_drc(drc_index);
	if (rc) {
		dlpar_free_cc_nodes(dn);
		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 u32 *intserv;

	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++) {
		for_each_present_cpu(cpu) {
			if (get_hard_smp_processor_id(cpu) != intserv[i])
				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 = cpu_down(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, intserv[i])
								!= 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", intserv[i]);
	}
	cpu_maps_update_done();

out:
	return rc;

}

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

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

	drc_index = of_get_property(dn, "ibm,my-drc-index", NULL);
	if (!drc_index) {
		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;
}

static int __init pseries_dlpar_init(void)
{
	ppc_md.cpu_probe = dlpar_cpu_probe;
	ppc_md.cpu_release = dlpar_cpu_release;

	return 0;
}
machine_device_initcall(pseries, pseries_dlpar_init);

#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
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
	13	#include <linux/kernel.h>
ab519a01	14	#include <linux/notifier.h>
ab519a01 NF	15	#include <linux/spinlock.h>
ab519a01 NF	16	#include <linux/cpu.h>
5a0e3ad6	17	#include <linux/slab.h>
1cf3d8b3	18	#include <linux/of.h>
b6db63d1	19	#include "offline_states.h"
ab519a01 NF	20
	21	#include <asm/prom.h>
	22	#include <asm/machdep.h>
	23	#include <asm/uaccess.h>
	24	#include <asm/rtas.h>
ab519a01 NF	25
	26	struct cc_workarea {
	27	u32 drc_index;
	28	u32 zero;
	29	u32 name_offset;
	30	u32 prop_length;
	31	u32 prop_offset;
	32	};
	33
20648974	34	void dlpar_free_cc_property(struct property *prop)
ab519a01 NF	35	{
	36	kfree(prop->name);
	37	kfree(prop->value);
	38	kfree(prop);
	39	}
	40
	41	static struct property dlpar_parse_cc_property(struct cc_workarea ccwa)
	42	{
	43	struct property *prop;
	44	char *name;
	45	char *value;
	46
	47	prop = kzalloc(sizeof(*prop), GFP_KERNEL);
	48	if (!prop)
	49	return NULL;
	50
	51	name = (char *)ccwa + ccwa->name_offset;
	52	prop->name = kstrdup(name, GFP_KERNEL);
	53
	54	prop->length = ccwa->prop_length;
	55	value = (char *)ccwa + ccwa->prop_offset;
e72ed6b5	56	prop->value = kmemdup(value, prop->length, GFP_KERNEL);
ab519a01 NF	57	if (!prop->value) {
	58	dlpar_free_cc_property(prop);
	59	return NULL;
	60	}
	61
ab519a01 NF	62	return prop;
	63	}
	64
8d5ff320 TD	65	static struct device_node dlpar_parse_cc_node(struct cc_workarea ccwa,
8d5ff320 TD	66	const char *path)
ab519a01 NF	67	{
	68	struct device_node *dn;
	69	char *name;
	70
8d5ff320 TD	71	/* If parent node path is "/" advance path to NULL terminator to
	72	* prevent double leading slashs in full_name.
	73	*/
	74	if (!path[1])
	75	path++;
	76
ab519a01 NF	77	dn = kzalloc(sizeof(*dn), GFP_KERNEL);
	78	if (!dn)
	79	return NULL;
	80
ab519a01	81	name = (char *)ccwa + ccwa->name_offset;
8d5ff320	82	dn->full_name = kasprintf(GFP_KERNEL, "%s/%s", path, name);
ab519a01 NF	83	if (!dn->full_name) {
	84	kfree(dn);
	85	return NULL;
	86	}
	87
1578cb76	88	of_node_set_flag(dn, OF_DYNAMIC);
97a9a717	89	of_node_init(dn);
1578cb76	90
ab519a01 NF	91	return dn;
	92	}
	93
	94	static void dlpar_free_one_cc_node(struct device_node *dn)
	95	{
	96	struct property *prop;
	97
	98	while (dn->properties) {
	99	prop = dn->properties;
	100	dn->properties = prop->next;
	101	dlpar_free_cc_property(prop);
	102	}
	103
	104	kfree(dn->full_name);
	105	kfree(dn);
	106	}
	107
20648974	108	void dlpar_free_cc_nodes(struct device_node *dn)
ab519a01 NF	109	{
	110	if (dn->child)
	111	dlpar_free_cc_nodes(dn->child);
	112
	113	if (dn->sibling)
	114	dlpar_free_cc_nodes(dn->sibling);
	115
	116	dlpar_free_one_cc_node(dn);
	117	}
	118
9c740025	119	#define COMPLETE 0
ab519a01 NF	120	#define NEXT_SIBLING 1
	121	#define NEXT_CHILD 2
	122	#define NEXT_PROPERTY 3
	123	#define PREV_PARENT 4
	124	#define MORE_MEMORY 5
	125	#define CALL_AGAIN -2
	126	#define ERR_CFG_USE -9003
	127
8d5ff320 TD	128	struct device_node *dlpar_configure_connector(u32 drc_index,
8d5ff320 TD	129	struct device_node *parent)
ab519a01 NF	130	{
	131	struct device_node *dn;
	132	struct device_node *first_dn = NULL;
	133	struct device_node *last_dn = NULL;
	134	struct property *property;
	135	struct property *last_property = NULL;
	136	struct cc_workarea *ccwa;
93f68f1e	137	char *data_buf;
8d5ff320	138	const char *parent_path = parent->full_name;
ab519a01	139	int cc_token;
93f68f1e	140	int rc = -1;
ab519a01 NF	141
	142	cc_token = rtas_token("ibm,configure-connector");
	143	if (cc_token == RTAS_UNKNOWN_SERVICE)
	144	return NULL;
	145
93f68f1e NF	146	data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
	147	if (!data_buf)
	148	return NULL;
	149
	150	ccwa = (struct cc_workarea *)&data_buf[0];
ab519a01 NF	151	ccwa->drc_index = drc_index;
	152	ccwa->zero = 0;
	153
93f68f1e NF	154	do {
	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.
	158	*/
	159	spin_lock(&rtas_data_buf_lock);
	160
	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);
	164
	165	spin_unlock(&rtas_data_buf_lock);
	166
ab519a01	167	switch (rc) {
9c740025 AB	168	case COMPLETE:
	169	break;
	170
ab519a01	171	case NEXT_SIBLING:
8d5ff320	172	dn = dlpar_parse_cc_node(ccwa, parent_path);
ab519a01 NF	173	if (!dn)
	174	goto cc_error;
	175
	176	dn->parent = last_dn->parent;
	177	last_dn->sibling = dn;
	178	last_dn = dn;
	179	break;
	180
	181	case NEXT_CHILD:
8d5ff320 TD	182	if (first_dn)
	183	parent_path = last_dn->full_name;
	184
	185	dn = dlpar_parse_cc_node(ccwa, parent_path);
ab519a01 NF	186	if (!dn)
	187	goto cc_error;
	188
8d5ff320 TD	189	if (!first_dn) {
8d5ff320 TD	190	dn->parent = parent;
ab519a01	191	first_dn = dn;
8d5ff320	192	} else {
ab519a01 NF	193	dn->parent = last_dn;
	194	if (last_dn)
	195	last_dn->child = dn;
	196	}
	197
	198	last_dn = dn;
	199	break;
	200
	201	case NEXT_PROPERTY:
	202	property = dlpar_parse_cc_property(ccwa);
	203	if (!property)
	204	goto cc_error;
	205
	206	if (!last_dn->properties)
	207	last_dn->properties = property;
	208	else
	209	last_property->next = property;
	210
	211	last_property = property;
	212	break;
	213
	214	case PREV_PARENT:
	215	last_dn = last_dn->parent;
8d5ff320	216	parent_path = last_dn->parent->full_name;
ab519a01 NF	217	break;
	218
	219	case CALL_AGAIN:
	220	break;
	221
	222	case MORE_MEMORY:
	223	case ERR_CFG_USE:
	224	default:
	225	printk(KERN_ERR "Unexpected Error (%d) "
	226	"returned from configure-connector\n", rc);
	227	goto cc_error;
	228	}
93f68f1e	229	} while (rc);
ab519a01	230
93f68f1e NF	231	cc_error:
	232	kfree(data_buf);
	233
	234	if (rc) {
	235	if (first_dn)
	236	dlpar_free_cc_nodes(first_dn);
	237
	238	return NULL;
ab519a01 NF	239	}
ab519a01 NF	240
ab519a01	241	return first_dn;
ab519a01 NF	242	}
	243
	244	static struct device_node derive_parent(const char path)
	245	{
	246	struct device_node *parent;
	247	char *last_slash;
	248
	249	last_slash = strrchr(path, '/');
	250	if (last_slash == path) {
	251	parent = of_find_node_by_path("/");
	252	} else {
	253	char *parent_path;
	254	int parent_path_len = last_slash - path + 1;
	255	parent_path = kmalloc(parent_path_len, GFP_KERNEL);
	256	if (!parent_path)
	257	return NULL;
	258
	259	strlcpy(parent_path, path, parent_path_len);
	260	parent = of_find_node_by_path(parent_path);
	261	kfree(parent_path);
	262	}
	263
	264	return parent;
	265	}
	266
	267	int dlpar_attach_node(struct device_node *dn)
	268	{
ab519a01 NF	269	int rc;
ab519a01 NF	270
ab519a01 NF	271	dn->parent = derive_parent(dn->full_name);
	272	if (!dn->parent)
	273	return -ENOMEM;
	274
1cf3d8b3	275	rc = of_attach_node(dn);
3aef19f0	276	if (rc) {
ab519a01 NF	277	printk(KERN_ERR "Failed to add device node %s\n",
ab519a01 NF	278	dn->full_name);
3aef19f0	279	return rc;
ab519a01 NF	280	}
ab519a01 NF	281
ab519a01 NF	282	of_node_put(dn->parent);
	283	return 0;
	284	}
	285
	286	int dlpar_detach_node(struct device_node *dn)
	287	{
5935ff43	288	struct device_node *child;
1cf3d8b3	289	int rc;
ab519a01	290
5935ff43 TD	291	child = of_get_next_child(dn, NULL);
	292	while (child) {
	293	dlpar_detach_node(child);
	294	child = of_get_next_child(dn, child);
	295	}
	296
1cf3d8b3 NF	297	rc = of_detach_node(dn);
	298	if (rc)
	299	return rc;
	300
	301	of_node_put(dn); /* Must decrement the refcount */
ab519a01 NF	302	return 0;
	303	}
	304
	305	#define DR_ENTITY_SENSE 9003
	306	#define DR_ENTITY_PRESENT 1
	307	#define DR_ENTITY_UNUSABLE 2
	308	#define ALLOCATION_STATE 9003
	309	#define ALLOC_UNUSABLE 0
	310	#define ALLOC_USABLE 1
	311	#define ISOLATION_STATE 9001
	312	#define ISOLATE 0
	313	#define UNISOLATE 1
	314
	315	int dlpar_acquire_drc(u32 drc_index)
	316	{
	317	int dr_status, rc;
	318
	319	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
	320	DR_ENTITY_SENSE, drc_index);
	321	if (rc \|\| dr_status != DR_ENTITY_UNUSABLE)
	322	return -1;
	323
	324	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
	325	if (rc)
	326	return rc;
	327
	328	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
	329	if (rc) {
	330	rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
	331	return rc;
	332	}
	333
	334	return 0;
	335	}
	336
	337	int dlpar_release_drc(u32 drc_index)
	338	{
	339	int dr_status, rc;
	340
	341	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
	342	DR_ENTITY_SENSE, drc_index);
	343	if (rc \|\| dr_status != DR_ENTITY_PRESENT)
	344	return -1;
	345
	346	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
	347	if (rc)
	348	return rc;
	349
	350	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
	351	if (rc) {
	352	rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
	353	return rc;
	354	}
	355
	356	return 0;
	357	}
	358
1a8061c4	359	#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
ab519a01	360
275a64f6 NF	361	static int dlpar_online_cpu(struct device_node *dn)
	362	{
	363	int rc = 0;
	364	unsigned int cpu;
	365	int len, nthreads, i;
	366	const u32 *intserv;
	367
	368	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	369	if (!intserv)
	370	return -EINVAL;
	371
	372	nthreads = len / sizeof(u32);
	373
	374	cpu_maps_update_begin();
	375	for (i = 0; i < nthreads; i++) {
	376	for_each_present_cpu(cpu) {
	377	if (get_hard_smp_processor_id(cpu) != intserv[i])
	378	continue;
	379	BUG_ON(get_cpu_current_state(cpu)
	380	!= CPU_STATE_OFFLINE);
	381	cpu_maps_update_done();
	382	rc = cpu_up(cpu);
	383	if (rc)
	384	goto out;
	385	cpu_maps_update_begin();
	386
	387	break;
	388	}
	389	if (cpu == num_possible_cpus())
	390	printk(KERN_WARNING "Could not find cpu to online "
	391	"with physical id 0x%x\n", intserv[i]);
	392	}
	393	cpu_maps_update_done();
	394
	395	out:
	396	return rc;
	397
	398	}
	399
1a8061c4 NF	400	static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
1a8061c4 NF	401	{
8d5ff320	402	struct device_node dn, parent;
1618bd53	403	u32 drc_index;
1a8061c4 NF	404	int rc;
1a8061c4 NF	405
1618bd53	406	rc = kstrtou32(buf, 0, &drc_index);
6dedcca6 TK	407	if (rc)
6dedcca6 TK	408	return -EINVAL;
1a8061c4	409
8d5ff320	410	parent = of_find_node_by_path("/cpus");
6dedcca6 TK	411	if (!parent)
6dedcca6 TK	412	return -ENODEV;
1a8061c4	413
8d5ff320	414	dn = dlpar_configure_connector(drc_index, parent);
6dedcca6 TK	415	if (!dn)
6dedcca6 TK	416	return -EINVAL;
1a8061c4	417
8d5ff320	418	of_node_put(parent);
1a8061c4 NF	419
	420	rc = dlpar_acquire_drc(drc_index);
	421	if (rc) {
	422	dlpar_free_cc_nodes(dn);
6dedcca6	423	return -EINVAL;
1a8061c4 NF	424	}
	425
	426	rc = dlpar_attach_node(dn);
	427	if (rc) {
	428	dlpar_release_drc(drc_index);
	429	dlpar_free_cc_nodes(dn);
6dedcca6	430	return rc;
1a8061c4 NF	431	}
1a8061c4 NF	432
275a64f6	433	rc = dlpar_online_cpu(dn);
6dedcca6 TK	434	if (rc)
6dedcca6 TK	435	return rc;
b6db63d1	436
6dedcca6	437	return count;
1a8061c4 NF	438	}
1a8061c4 NF	439
275a64f6 NF	440	static int dlpar_offline_cpu(struct device_node *dn)
	441	{
	442	int rc = 0;
	443	unsigned int cpu;
	444	int len, nthreads, i;
	445	const u32 *intserv;
	446
	447	intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
	448	if (!intserv)
	449	return -EINVAL;
	450
	451	nthreads = len / sizeof(u32);
	452
	453	cpu_maps_update_begin();
	454	for (i = 0; i < nthreads; i++) {
	455	for_each_present_cpu(cpu) {
	456	if (get_hard_smp_processor_id(cpu) != intserv[i])
	457	continue;
	458
	459	if (get_cpu_current_state(cpu) == CPU_STATE_OFFLINE)
	460	break;
	461
	462	if (get_cpu_current_state(cpu) == CPU_STATE_ONLINE) {
ceddee23	463	set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
275a64f6 NF	464	cpu_maps_update_done();
	465	rc = cpu_down(cpu);
	466	if (rc)
	467	goto out;
	468	cpu_maps_update_begin();
	469	break;
	470
	471	}
	472
	473	/*
	474	* The cpu is in CPU_STATE_INACTIVE.
	475	* Upgrade it's state to CPU_STATE_OFFLINE.
	476	*/
	477	set_preferred_offline_state(cpu, CPU_STATE_OFFLINE);
	478	BUG_ON(plpar_hcall_norets(H_PROD, intserv[i])
	479	!= H_SUCCESS);
	480	__cpu_die(cpu);
	481	break;
	482	}
	483	if (cpu == num_possible_cpus())
	484	printk(KERN_WARNING "Could not find cpu to offline "
	485	"with physical id 0x%x\n", intserv[i]);
	486	}
	487	cpu_maps_update_done();
	488
	489	out:
	490	return rc;
	491
	492	}
	493
1a8061c4 NF	494	static ssize_t dlpar_cpu_release(const char *buf, size_t count)
	495	{
	496	struct device_node *dn;
	497	const u32 *drc_index;
	498	int rc;
	499
	500	dn = of_find_node_by_path(buf);
	501	if (!dn)
	502	return -EINVAL;
	503
	504	drc_index = of_get_property(dn, "ibm,my-drc-index", NULL);
	505	if (!drc_index) {
	506	of_node_put(dn);
	507	return -EINVAL;
	508	}
	509
275a64f6	510	rc = dlpar_offline_cpu(dn);
b6db63d1 GS	511	if (rc) {
b6db63d1 GS	512	of_node_put(dn);
6dedcca6	513	return -EINVAL;
b6db63d1 GS	514	}
b6db63d1 GS	515
1a8061c4 NF	516	rc = dlpar_release_drc(*drc_index);
	517	if (rc) {
	518	of_node_put(dn);
6dedcca6	519	return rc;
1a8061c4 NF	520	}
	521
	522	rc = dlpar_detach_node(dn);
	523	if (rc) {
	524	dlpar_acquire_drc(*drc_index);
6dedcca6	525	return rc;
1a8061c4 NF	526	}
	527
	528	of_node_put(dn);
6dedcca6 TK	529
6dedcca6 TK	530	return count;
1a8061c4 NF	531	}
	532
	533	static int __init pseries_dlpar_init(void)
	534	{
	535	ppc_md.cpu_probe = dlpar_cpu_probe;
	536	ppc_md.cpu_release = dlpar_cpu_release;
	537
	538	return 0;
	539	}
	540	machine_device_initcall(pseries, pseries_dlpar_init);
	541
	542	#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */