[mirror_ubuntu-eoan-kernel.git] / arch / powerpc / mm / drmem.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Dynamic reconfiguration memory support
 *
 * Copyright 2017 IBM Corporation
 */

#define pr_fmt(fmt) "drmem: " fmt

#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/memblock.h>
#include <asm/prom.h>
#include <asm/drmem.h>

static struct drmem_lmb_info __drmem_info;
struct drmem_lmb_info *drmem_info = &__drmem_info;

u64 drmem_lmb_memory_max(void)
{
	struct drmem_lmb *last_lmb;

	last_lmb = &drmem_info->lmbs[drmem_info->n_lmbs - 1];
	return last_lmb->base_addr + drmem_lmb_size();
}

static u32 drmem_lmb_flags(struct drmem_lmb *lmb)
{
	/*
	 * Return the value of the lmb flags field minus the reserved
	 * bit used internally for hotplug processing.
	 */
	return lmb->flags & ~DRMEM_LMB_RESERVED;
}

static struct property *clone_property(struct property *prop, u32 prop_sz)
{
	struct property *new_prop;

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

	new_prop->name = kstrdup(prop->name, GFP_KERNEL);
	new_prop->value = kzalloc(prop_sz, GFP_KERNEL);
	if (!new_prop->name || !new_prop->value) {
		kfree(new_prop->name);
		kfree(new_prop->value);
		kfree(new_prop);
		return NULL;
	}

	new_prop->length = prop_sz;
#if defined(CONFIG_OF_DYNAMIC)
	of_property_set_flag(new_prop, OF_DYNAMIC);
#endif
	return new_prop;
}

static int drmem_update_dt_v1(struct device_node *memory,
			      struct property *prop)
{
	struct property *new_prop;
	struct of_drconf_cell_v1 *dr_cell;
	struct drmem_lmb *lmb;
	u32 *p;

	new_prop = clone_property(prop, prop->length);
	if (!new_prop)
		return -1;

	p = new_prop->value;
	*p++ = cpu_to_be32(drmem_info->n_lmbs);

	dr_cell = (struct of_drconf_cell_v1 *)p;

	for_each_drmem_lmb(lmb) {
		dr_cell->base_addr = cpu_to_be64(lmb->base_addr);
		dr_cell->drc_index = cpu_to_be32(lmb->drc_index);
		dr_cell->aa_index = cpu_to_be32(lmb->aa_index);
		dr_cell->flags = cpu_to_be32(drmem_lmb_flags(lmb));

		dr_cell++;
	}

	of_update_property(memory, new_prop);
	return 0;
}

static void init_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
				struct drmem_lmb *lmb)
{
	dr_cell->base_addr = cpu_to_be64(lmb->base_addr);
	dr_cell->drc_index = cpu_to_be32(lmb->drc_index);
	dr_cell->aa_index = cpu_to_be32(lmb->aa_index);
	dr_cell->flags = cpu_to_be32(drmem_lmb_flags(lmb));
}

static int drmem_update_dt_v2(struct device_node *memory,
			      struct property *prop)
{
	struct property *new_prop;
	struct of_drconf_cell_v2 *dr_cell;
	struct drmem_lmb *lmb, *prev_lmb;
	u32 lmb_sets, prop_sz, seq_lmbs;
	u32 *p;

	/* First pass, determine how many LMB sets are needed. */
	lmb_sets = 0;
	prev_lmb = NULL;
	for_each_drmem_lmb(lmb) {
		if (!prev_lmb) {
			prev_lmb = lmb;
			lmb_sets++;
			continue;
		}

		if (prev_lmb->aa_index != lmb->aa_index ||
		    drmem_lmb_flags(prev_lmb) != drmem_lmb_flags(lmb))
			lmb_sets++;

		prev_lmb = lmb;
	}

	prop_sz = lmb_sets * sizeof(*dr_cell) + sizeof(__be32);
	new_prop = clone_property(prop, prop_sz);
	if (!new_prop)
		return -1;

	p = new_prop->value;
	*p++ = cpu_to_be32(lmb_sets);

	dr_cell = (struct of_drconf_cell_v2 *)p;

	/* Second pass, populate the LMB set data */
	prev_lmb = NULL;
	seq_lmbs = 0;
	for_each_drmem_lmb(lmb) {
		if (prev_lmb == NULL) {
			/* Start of first LMB set */
			prev_lmb = lmb;
			init_drconf_v2_cell(dr_cell, lmb);
			seq_lmbs++;
			continue;
		}

		if (prev_lmb->aa_index != lmb->aa_index ||
		    drmem_lmb_flags(prev_lmb) != drmem_lmb_flags(lmb)) {
			/* end of one set, start of another */
			dr_cell->seq_lmbs = cpu_to_be32(seq_lmbs);
			dr_cell++;

			init_drconf_v2_cell(dr_cell, lmb);
			seq_lmbs = 1;
		} else {
			seq_lmbs++;
		}

		prev_lmb = lmb;
	}

	/* close out last LMB set */
	dr_cell->seq_lmbs = cpu_to_be32(seq_lmbs);
	of_update_property(memory, new_prop);
	return 0;
}

int drmem_update_dt(void)
{
	struct device_node *memory;
	struct property *prop;
	int rc = -1;

	memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
	if (!memory)
		return -1;

	prop = of_find_property(memory, "ibm,dynamic-memory", NULL);
	if (prop) {
		rc = drmem_update_dt_v1(memory, prop);
	} else {
		prop = of_find_property(memory, "ibm,dynamic-memory-v2", NULL);
		if (prop)
			rc = drmem_update_dt_v2(memory, prop);
	}

	of_node_put(memory);
	return rc;
}

static void __init read_drconf_v1_cell(struct drmem_lmb *lmb,
				       const __be32 **prop)
{
	const __be32 *p = *prop;

	lmb->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
	lmb->drc_index = of_read_number(p++, 1);

	p++; /* skip reserved field */

	lmb->aa_index = of_read_number(p++, 1);
	lmb->flags = of_read_number(p++, 1);

	*prop = p;
}

static void __init __walk_drmem_v1_lmbs(const __be32 *prop, const __be32 *usm,
			void (*func)(struct drmem_lmb *, const __be32 **))
{
	struct drmem_lmb lmb;
	u32 i, n_lmbs;

	n_lmbs = of_read_number(prop++, 1);
	if (n_lmbs == 0)
		return;

	for (i = 0; i < n_lmbs; i++) {
		read_drconf_v1_cell(&lmb, &prop);
		func(&lmb, &usm);
	}
}

static void __init read_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
				       const __be32 **prop)
{
	const __be32 *p = *prop;

	dr_cell->seq_lmbs = of_read_number(p++, 1);
	dr_cell->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
	dr_cell->drc_index = of_read_number(p++, 1);
	dr_cell->aa_index = of_read_number(p++, 1);
	dr_cell->flags = of_read_number(p++, 1);

	*prop = p;
}

static void __init __walk_drmem_v2_lmbs(const __be32 *prop, const __be32 *usm,
			void (*func)(struct drmem_lmb *, const __be32 **))
{
	struct of_drconf_cell_v2 dr_cell;
	struct drmem_lmb lmb;
	u32 i, j, lmb_sets;

	lmb_sets = of_read_number(prop++, 1);
	if (lmb_sets == 0)
		return;

	for (i = 0; i < lmb_sets; i++) {
		read_drconf_v2_cell(&dr_cell, &prop);

		for (j = 0; j < dr_cell.seq_lmbs; j++) {
			lmb.base_addr = dr_cell.base_addr;
			dr_cell.base_addr += drmem_lmb_size();

			lmb.drc_index = dr_cell.drc_index;
			dr_cell.drc_index++;

			lmb.aa_index = dr_cell.aa_index;
			lmb.flags = dr_cell.flags;

			func(&lmb, &usm);
		}
	}
}

#ifdef CONFIG_PPC_PSERIES
void __init walk_drmem_lmbs_early(unsigned long node,
			void (*func)(struct drmem_lmb *, const __be32 **))
{
	const __be32 *prop, *usm;
	int len;

	prop = of_get_flat_dt_prop(node, "ibm,lmb-size", &len);
	if (!prop || len < dt_root_size_cells * sizeof(__be32))
		return;

	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);

	usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory", &len);

	prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &len);
	if (prop) {
		__walk_drmem_v1_lmbs(prop, usm, func);
	} else {
		prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory-v2",
					   &len);
		if (prop)
			__walk_drmem_v2_lmbs(prop, usm, func);
	}

	memblock_dump_all();
}

#endif

static int __init init_drmem_lmb_size(struct device_node *dn)
{
	const __be32 *prop;
	int len;

	if (drmem_info->lmb_size)
		return 0;

	prop = of_get_property(dn, "ibm,lmb-size", &len);
	if (!prop || len < dt_root_size_cells * sizeof(__be32)) {
		pr_info("Could not determine LMB size\n");
		return -1;
	}

	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);
	return 0;
}

/*
 * Returns the property linux,drconf-usable-memory if
 * it exists (the property exists only in kexec/kdump kernels,
 * added by kexec-tools)
 */
static const __be32 *of_get_usable_memory(struct device_node *dn)
{
	const __be32 *prop;
	u32 len;

	prop = of_get_property(dn, "linux,drconf-usable-memory", &len);
	if (!prop || len < sizeof(unsigned int))
		return NULL;

	return prop;
}

void __init walk_drmem_lmbs(struct device_node *dn,
			    void (*func)(struct drmem_lmb *, const __be32 **))
{
	const __be32 *prop, *usm;

	if (init_drmem_lmb_size(dn))
		return;

	usm = of_get_usable_memory(dn);

	prop = of_get_property(dn, "ibm,dynamic-memory", NULL);
	if (prop) {
		__walk_drmem_v1_lmbs(prop, usm, func);
	} else {
		prop = of_get_property(dn, "ibm,dynamic-memory-v2", NULL);
		if (prop)
			__walk_drmem_v2_lmbs(prop, usm, func);
	}
}

static void __init init_drmem_v1_lmbs(const __be32 *prop)
{
	struct drmem_lmb *lmb;

	drmem_info->n_lmbs = of_read_number(prop++, 1);
	if (drmem_info->n_lmbs == 0)
		return;

	drmem_info->lmbs = kcalloc(drmem_info->n_lmbs, sizeof(*lmb),
				   GFP_KERNEL);
	if (!drmem_info->lmbs)
		return;

	for_each_drmem_lmb(lmb) {
		read_drconf_v1_cell(lmb, &prop);
		lmb_set_nid(lmb);
	}
}

static void __init init_drmem_v2_lmbs(const __be32 *prop)
{
	struct drmem_lmb *lmb;
	struct of_drconf_cell_v2 dr_cell;
	const __be32 *p;
	u32 i, j, lmb_sets;
	int lmb_index;

	lmb_sets = of_read_number(prop++, 1);
	if (lmb_sets == 0)
		return;

	/* first pass, calculate the number of LMBs */
	p = prop;
	for (i = 0; i < lmb_sets; i++) {
		read_drconf_v2_cell(&dr_cell, &p);
		drmem_info->n_lmbs += dr_cell.seq_lmbs;
	}

	drmem_info->lmbs = kcalloc(drmem_info->n_lmbs, sizeof(*lmb),
				   GFP_KERNEL);
	if (!drmem_info->lmbs)
		return;

	/* second pass, read in the LMB information */
	lmb_index = 0;
	p = prop;

	for (i = 0; i < lmb_sets; i++) {
		read_drconf_v2_cell(&dr_cell, &p);

		for (j = 0; j < dr_cell.seq_lmbs; j++) {
			lmb = &drmem_info->lmbs[lmb_index++];

			lmb->base_addr = dr_cell.base_addr;
			dr_cell.base_addr += drmem_info->lmb_size;

			lmb->drc_index = dr_cell.drc_index;
			dr_cell.drc_index++;

			lmb->aa_index = dr_cell.aa_index;
			lmb->flags = dr_cell.flags;

			lmb_set_nid(lmb);
		}
	}
}

static int __init drmem_init(void)
{
	struct device_node *dn;
	const __be32 *prop;

	dn = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
	if (!dn) {
		pr_info("No dynamic reconfiguration memory found\n");
		return 0;
	}

	if (init_drmem_lmb_size(dn)) {
		of_node_put(dn);
		return 0;
	}

	prop = of_get_property(dn, "ibm,dynamic-memory", NULL);
	if (prop) {
		init_drmem_v1_lmbs(prop);
	} else {
		prop = of_get_property(dn, "ibm,dynamic-memory-v2", NULL);
		if (prop)
			init_drmem_v2_lmbs(prop);
	}

	of_node_put(dn);
	return 0;
}
late_initcall(drmem_init);
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
6c6ea537 NF	2	/*
	3	* Dynamic reconfiguration memory support
	4	*
	5	* Copyright 2017 IBM Corporation
6c6ea537 NF	6	*/
	7
	8	#define pr_fmt(fmt) "drmem: " fmt
	9
	10	#include <linux/kernel.h>
	11	#include <linux/of.h>
	12	#include <linux/of_fdt.h>
	13	#include <linux/memblock.h>
	14	#include <asm/prom.h>
	15	#include <asm/drmem.h>
	16
	17	static struct drmem_lmb_info __drmem_info;
	18	struct drmem_lmb_info *drmem_info = &__drmem_info;
	19
514a9cb3 NF	20	u64 drmem_lmb_memory_max(void)
	21	{
	22	struct drmem_lmb *last_lmb;
	23
	24	last_lmb = &drmem_info->lmbs[drmem_info->n_lmbs - 1];
	25	return last_lmb->base_addr + drmem_lmb_size();
	26	}
	27
6195a500 NF	28	static u32 drmem_lmb_flags(struct drmem_lmb *lmb)
	29	{
	30	/*
	31	* Return the value of the lmb flags field minus the reserved
	32	* bit used internally for hotplug processing.
	33	*/
	34	return lmb->flags & ~DRMEM_LMB_RESERVED;
	35	}
	36
	37	static struct property clone_property(struct property prop, u32 prop_sz)
	38	{
	39	struct property *new_prop;
	40
	41	new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL);
	42	if (!new_prop)
	43	return NULL;
	44
	45	new_prop->name = kstrdup(prop->name, GFP_KERNEL);
	46	new_prop->value = kzalloc(prop_sz, GFP_KERNEL);
	47	if (!new_prop->name \|\| !new_prop->value) {
	48	kfree(new_prop->name);
	49	kfree(new_prop->value);
	50	kfree(new_prop);
	51	return NULL;
	52	}
	53
	54	new_prop->length = prop_sz;
	55	#if defined(CONFIG_OF_DYNAMIC)
	56	of_property_set_flag(new_prop, OF_DYNAMIC);
	57	#endif
	58	return new_prop;
	59	}
	60
	61	static int drmem_update_dt_v1(struct device_node *memory,
	62	struct property *prop)
	63	{
	64	struct property *new_prop;
2c777215	65	struct of_drconf_cell_v1 *dr_cell;
6195a500 NF	66	struct drmem_lmb *lmb;
	67	u32 *p;
	68
	69	new_prop = clone_property(prop, prop->length);
	70	if (!new_prop)
	71	return -1;
	72
	73	p = new_prop->value;
	74	*p++ = cpu_to_be32(drmem_info->n_lmbs);
	75
2c777215	76	dr_cell = (struct of_drconf_cell_v1 *)p;
6195a500 NF	77
	78	for_each_drmem_lmb(lmb) {
	79	dr_cell->base_addr = cpu_to_be64(lmb->base_addr);
	80	dr_cell->drc_index = cpu_to_be32(lmb->drc_index);
	81	dr_cell->aa_index = cpu_to_be32(lmb->aa_index);
	82	dr_cell->flags = cpu_to_be32(drmem_lmb_flags(lmb));
	83
	84	dr_cell++;
	85	}
	86
	87	of_update_property(memory, new_prop);
	88	return 0;
	89	}
	90
2b31e3ae NF	91	static void init_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
	92	struct drmem_lmb *lmb)
	93	{
	94	dr_cell->base_addr = cpu_to_be64(lmb->base_addr);
	95	dr_cell->drc_index = cpu_to_be32(lmb->drc_index);
	96	dr_cell->aa_index = cpu_to_be32(lmb->aa_index);
2f7d03e0	97	dr_cell->flags = cpu_to_be32(drmem_lmb_flags(lmb));
2b31e3ae NF	98	}
	99
	100	static int drmem_update_dt_v2(struct device_node *memory,
	101	struct property *prop)
	102	{
	103	struct property *new_prop;
	104	struct of_drconf_cell_v2 *dr_cell;
	105	struct drmem_lmb lmb, prev_lmb;
	106	u32 lmb_sets, prop_sz, seq_lmbs;
	107	u32 *p;
	108
	109	/* First pass, determine how many LMB sets are needed. */
	110	lmb_sets = 0;
	111	prev_lmb = NULL;
	112	for_each_drmem_lmb(lmb) {
	113	if (!prev_lmb) {
	114	prev_lmb = lmb;
	115	lmb_sets++;
	116	continue;
	117	}
	118
	119	if (prev_lmb->aa_index != lmb->aa_index \|\|
2f7d03e0	120	drmem_lmb_flags(prev_lmb) != drmem_lmb_flags(lmb))
2b31e3ae NF	121	lmb_sets++;
	122
	123	prev_lmb = lmb;
	124	}
	125
	126	prop_sz = lmb_sets * sizeof(*dr_cell) + sizeof(__be32);
	127	new_prop = clone_property(prop, prop_sz);
	128	if (!new_prop)
	129	return -1;
	130
	131	p = new_prop->value;
	132	*p++ = cpu_to_be32(lmb_sets);
	133
	134	dr_cell = (struct of_drconf_cell_v2 *)p;
	135
	136	/* Second pass, populate the LMB set data */
	137	prev_lmb = NULL;
	138	seq_lmbs = 0;
	139	for_each_drmem_lmb(lmb) {
	140	if (prev_lmb == NULL) {
	141	/* Start of first LMB set */
	142	prev_lmb = lmb;
	143	init_drconf_v2_cell(dr_cell, lmb);
	144	seq_lmbs++;
	145	continue;
	146	}
	147
	148	if (prev_lmb->aa_index != lmb->aa_index \|\|
2f7d03e0	149	drmem_lmb_flags(prev_lmb) != drmem_lmb_flags(lmb)) {
2b31e3ae NF	150	/* end of one set, start of another */
	151	dr_cell->seq_lmbs = cpu_to_be32(seq_lmbs);
	152	dr_cell++;
	153
	154	init_drconf_v2_cell(dr_cell, lmb);
	155	seq_lmbs = 1;
	156	} else {
	157	seq_lmbs++;
	158	}
	159
	160	prev_lmb = lmb;
	161	}
	162
	163	/* close out last LMB set */
	164	dr_cell->seq_lmbs = cpu_to_be32(seq_lmbs);
	165	of_update_property(memory, new_prop);
	166	return 0;
	167	}
	168
6195a500 NF	169	int drmem_update_dt(void)
	170	{
	171	struct device_node *memory;
	172	struct property *prop;
	173	int rc = -1;
	174
	175	memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
	176	if (!memory)
	177	return -1;
	178
	179	prop = of_find_property(memory, "ibm,dynamic-memory", NULL);
2b31e3ae	180	if (prop) {
6195a500	181	rc = drmem_update_dt_v1(memory, prop);
2b31e3ae NF	182	} else {
	183	prop = of_find_property(memory, "ibm,dynamic-memory-v2", NULL);
	184	if (prop)
	185	rc = drmem_update_dt_v2(memory, prop);
	186	}
6195a500 NF	187
	188	of_node_put(memory);
	189	return rc;
	190	}
	191
6c6ea537 NF	192	static void __init read_drconf_v1_cell(struct drmem_lmb *lmb,
	193	const __be32 **prop)
	194	{
	195	const __be32 p = prop;
	196
	197	lmb->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
	198	lmb->drc_index = of_read_number(p++, 1);
	199
	200	p++; /* skip reserved field */
	201
	202	lmb->aa_index = of_read_number(p++, 1);
	203	lmb->flags = of_read_number(p++, 1);
	204
	205	*prop = p;
	206	}
	207
	208	static void __init __walk_drmem_v1_lmbs(const __be32 prop, const __be32 usm,
	209	void (func)(struct drmem_lmb , const __be32 **))
	210	{
	211	struct drmem_lmb lmb;
	212	u32 i, n_lmbs;
	213
	214	n_lmbs = of_read_number(prop++, 1);
2c10636a NF	215	if (n_lmbs == 0)
2c10636a NF	216	return;
6c6ea537 NF	217
	218	for (i = 0; i < n_lmbs; i++) {
	219	read_drconf_v1_cell(&lmb, &prop);
	220	func(&lmb, &usm);
	221	}
	222	}
	223
2b31e3ae NF	224	static void __init read_drconf_v2_cell(struct of_drconf_cell_v2 *dr_cell,
	225	const __be32 **prop)
	226	{
	227	const __be32 p = prop;
	228
	229	dr_cell->seq_lmbs = of_read_number(p++, 1);
	230	dr_cell->base_addr = dt_mem_next_cell(dt_root_addr_cells, &p);
	231	dr_cell->drc_index = of_read_number(p++, 1);
	232	dr_cell->aa_index = of_read_number(p++, 1);
	233	dr_cell->flags = of_read_number(p++, 1);
	234
	235	*prop = p;
	236	}
	237
	238	static void __init __walk_drmem_v2_lmbs(const __be32 prop, const __be32 usm,
	239	void (func)(struct drmem_lmb , const __be32 **))
	240	{
	241	struct of_drconf_cell_v2 dr_cell;
	242	struct drmem_lmb lmb;
	243	u32 i, j, lmb_sets;
	244
	245	lmb_sets = of_read_number(prop++, 1);
2c10636a NF	246	if (lmb_sets == 0)
2c10636a NF	247	return;
2b31e3ae NF	248
	249	for (i = 0; i < lmb_sets; i++) {
	250	read_drconf_v2_cell(&dr_cell, &prop);
	251
	252	for (j = 0; j < dr_cell.seq_lmbs; j++) {
	253	lmb.base_addr = dr_cell.base_addr;
	254	dr_cell.base_addr += drmem_lmb_size();
	255
	256	lmb.drc_index = dr_cell.drc_index;
	257	dr_cell.drc_index++;
	258
	259	lmb.aa_index = dr_cell.aa_index;
	260	lmb.flags = dr_cell.flags;
	261
	262	func(&lmb, &usm);
	263	}
	264	}
	265	}
	266
514a9cb3	267	#ifdef CONFIG_PPC_PSERIES
6c6ea537 NF	268	void __init walk_drmem_lmbs_early(unsigned long node,
	269	void (func)(struct drmem_lmb , const __be32 **))
	270	{
	271	const __be32 prop, usm;
	272	int len;
	273
	274	prop = of_get_flat_dt_prop(node, "ibm,lmb-size", &len);
	275	if (!prop \|\| len < dt_root_size_cells * sizeof(__be32))
	276	return;
	277
	278	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);
	279
	280	usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory", &len);
	281
	282	prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &len);
2b31e3ae	283	if (prop) {
6c6ea537	284	__walk_drmem_v1_lmbs(prop, usm, func);
2b31e3ae NF	285	} else {
	286	prop = of_get_flat_dt_prop(node, "ibm,dynamic-memory-v2",
	287	&len);
	288	if (prop)
	289	__walk_drmem_v2_lmbs(prop, usm, func);
	290	}
6c6ea537 NF	291
	292	memblock_dump_all();
	293	}
	294
	295	#endif
514a9cb3 NF	296
	297	static int __init init_drmem_lmb_size(struct device_node *dn)
	298	{
	299	const __be32 *prop;
	300	int len;
	301
	302	if (drmem_info->lmb_size)
	303	return 0;
	304
	305	prop = of_get_property(dn, "ibm,lmb-size", &len);
	306	if (!prop \|\| len < dt_root_size_cells * sizeof(__be32)) {
	307	pr_info("Could not determine LMB size\n");
	308	return -1;
	309	}
	310
	311	drmem_info->lmb_size = dt_mem_next_cell(dt_root_size_cells, &prop);
	312	return 0;
	313	}
	314
	315	/*
	316	* Returns the property linux,drconf-usable-memory if
	317	* it exists (the property exists only in kexec/kdump kernels,
	318	* added by kexec-tools)
	319	*/
	320	static const __be32 of_get_usable_memory(struct device_node dn)
	321	{
	322	const __be32 *prop;
	323	u32 len;
	324
	325	prop = of_get_property(dn, "linux,drconf-usable-memory", &len);
	326	if (!prop \|\| len < sizeof(unsigned int))
	327	return NULL;
	328
	329	return prop;
	330	}
	331
	332	void __init walk_drmem_lmbs(struct device_node *dn,
	333	void (func)(struct drmem_lmb , const __be32 **))
	334	{
	335	const __be32 prop, usm;
	336
	337	if (init_drmem_lmb_size(dn))
	338	return;
	339
	340	usm = of_get_usable_memory(dn);
	341
	342	prop = of_get_property(dn, "ibm,dynamic-memory", NULL);
2b31e3ae	343	if (prop) {
514a9cb3	344	__walk_drmem_v1_lmbs(prop, usm, func);
2b31e3ae NF	345	} else {
	346	prop = of_get_property(dn, "ibm,dynamic-memory-v2", NULL);
	347	if (prop)
	348	__walk_drmem_v2_lmbs(prop, usm, func);
	349	}
514a9cb3 NF	350	}
	351
	352	static void __init init_drmem_v1_lmbs(const __be32 *prop)
	353	{
	354	struct drmem_lmb *lmb;
	355
	356	drmem_info->n_lmbs = of_read_number(prop++, 1);
2c10636a NF	357	if (drmem_info->n_lmbs == 0)
2c10636a NF	358	return;
514a9cb3 NF	359
	360	drmem_info->lmbs = kcalloc(drmem_info->n_lmbs, sizeof(*lmb),
	361	GFP_KERNEL);
	362	if (!drmem_info->lmbs)
	363	return;
	364
b2d3b5ee	365	for_each_drmem_lmb(lmb) {
514a9cb3	366	read_drconf_v1_cell(lmb, &prop);
b2d3b5ee NF	367	lmb_set_nid(lmb);
b2d3b5ee NF	368	}
514a9cb3 NF	369	}
514a9cb3 NF	370
2b31e3ae NF	371	static void __init init_drmem_v2_lmbs(const __be32 *prop)
	372	{
	373	struct drmem_lmb *lmb;
	374	struct of_drconf_cell_v2 dr_cell;
	375	const __be32 *p;
	376	u32 i, j, lmb_sets;
	377	int lmb_index;
	378
	379	lmb_sets = of_read_number(prop++, 1);
2c10636a NF	380	if (lmb_sets == 0)
2c10636a NF	381	return;
2b31e3ae NF	382
	383	/* first pass, calculate the number of LMBs */
	384	p = prop;
	385	for (i = 0; i < lmb_sets; i++) {
	386	read_drconf_v2_cell(&dr_cell, &p);
	387	drmem_info->n_lmbs += dr_cell.seq_lmbs;
	388	}
	389
	390	drmem_info->lmbs = kcalloc(drmem_info->n_lmbs, sizeof(*lmb),
	391	GFP_KERNEL);
	392	if (!drmem_info->lmbs)
	393	return;
	394
	395	/* second pass, read in the LMB information */
	396	lmb_index = 0;
	397	p = prop;
	398
	399	for (i = 0; i < lmb_sets; i++) {
	400	read_drconf_v2_cell(&dr_cell, &p);
	401
	402	for (j = 0; j < dr_cell.seq_lmbs; j++) {
	403	lmb = &drmem_info->lmbs[lmb_index++];
	404
	405	lmb->base_addr = dr_cell.base_addr;
	406	dr_cell.base_addr += drmem_info->lmb_size;
	407
	408	lmb->drc_index = dr_cell.drc_index;
	409	dr_cell.drc_index++;
	410
	411	lmb->aa_index = dr_cell.aa_index;
	412	lmb->flags = dr_cell.flags;
b2d3b5ee NF	413
b2d3b5ee NF	414	lmb_set_nid(lmb);
2b31e3ae NF	415	}
	416	}
	417	}
	418
514a9cb3 NF	419	static int __init drmem_init(void)
	420	{
	421	struct device_node *dn;
	422	const __be32 *prop;
	423
	424	dn = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
	425	if (!dn) {
	426	pr_info("No dynamic reconfiguration memory found\n");
	427	return 0;
	428	}
	429
	430	if (init_drmem_lmb_size(dn)) {
	431	of_node_put(dn);
	432	return 0;
	433	}
	434
	435	prop = of_get_property(dn, "ibm,dynamic-memory", NULL);
2b31e3ae	436	if (prop) {
514a9cb3	437	init_drmem_v1_lmbs(prop);
2b31e3ae NF	438	} else {
	439	prop = of_get_property(dn, "ibm,dynamic-memory-v2", NULL);
	440	if (prop)
	441	init_drmem_v2_lmbs(prop);
	442	}
514a9cb3 NF	443
	444	of_node_put(dn);
	445	return 0;
	446	}
	447	late_initcall(drmem_init);