[deliverable/linux.git] / arch / powerpc / platforms / powernv / opal-dump.c

/*
 * PowerNV OPAL Dump Interface
 *
 * Copyright 2013,2014 IBM Corp.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/kobject.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/pagemap.h>
#include <linux/delay.h>

#include <asm/opal.h>

#define DUMP_TYPE_FSP	0x01

struct dump_obj {
	struct kobject  kobj;
	struct bin_attribute dump_attr;
	uint32_t	id;  /* becomes object name */
	uint32_t	type;
	uint32_t	size;
	char		*buffer;
};
#define to_dump_obj(x) container_of(x, struct dump_obj, kobj)

struct dump_attribute {
	struct attribute attr;
	ssize_t (*show)(struct dump_obj *dump, struct dump_attribute *attr,
			char *buf);
	ssize_t (*store)(struct dump_obj *dump, struct dump_attribute *attr,
			 const char *buf, size_t count);
};
#define to_dump_attr(x) container_of(x, struct dump_attribute, attr)

static ssize_t dump_id_show(struct dump_obj *dump_obj,
			    struct dump_attribute *attr,
			    char *buf)
{
	return sprintf(buf, "0x%x\n", dump_obj->id);
}

static const char* dump_type_to_string(uint32_t type)
{
	switch (type) {
	case 0x01: return "SP Dump";
	case 0x02: return "System/Platform Dump";
	case 0x03: return "SMA Dump";
	default: return "unknown";
	}
}

static ssize_t dump_type_show(struct dump_obj *dump_obj,
			      struct dump_attribute *attr,
			      char *buf)
{
	
	return sprintf(buf, "0x%x %s\n", dump_obj->type,
		       dump_type_to_string(dump_obj->type));
}

static ssize_t dump_ack_show(struct dump_obj *dump_obj,
			     struct dump_attribute *attr,
			     char *buf)
{
	return sprintf(buf, "ack - acknowledge dump\n");
}

/*
 * Send acknowledgement to OPAL
 */
static int64_t dump_send_ack(uint32_t dump_id)
{
	int rc;

	rc = opal_dump_ack(dump_id);
	if (rc)
		pr_warn("%s: Failed to send ack to Dump ID 0x%x (%d)\n",
			__func__, dump_id, rc);
	return rc;
}

static ssize_t dump_ack_store(struct dump_obj *dump_obj,
			      struct dump_attribute *attr,
			      const char *buf,
			      size_t count)
{
	dump_send_ack(dump_obj->id);
	sysfs_remove_file_self(&dump_obj->kobj, &attr->attr);
	kobject_put(&dump_obj->kobj);
	return count;
}

/* Attributes of a dump
 * The binary attribute of the dump itself is dynamic
 * due to the dynamic size of the dump
 */
static struct dump_attribute id_attribute =
	__ATTR(id, 0666, dump_id_show, NULL);
static struct dump_attribute type_attribute =
	__ATTR(type, 0666, dump_type_show, NULL);
static struct dump_attribute ack_attribute =
	__ATTR(acknowledge, 0660, dump_ack_show, dump_ack_store);

static ssize_t init_dump_show(struct dump_obj *dump_obj,
			      struct dump_attribute *attr,
			      char *buf)
{
	return sprintf(buf, "1 - initiate dump\n");
}

static int64_t dump_fips_init(uint8_t type)
{
	int rc;

	rc = opal_dump_init(type);
	if (rc)
		pr_warn("%s: Failed to initiate FipS dump (%d)\n",
			__func__, rc);
	return rc;
}

static ssize_t init_dump_store(struct dump_obj *dump_obj,
			       struct dump_attribute *attr,
			       const char *buf,
			       size_t count)
{
	dump_fips_init(DUMP_TYPE_FSP);
	pr_info("%s: Initiated FSP dump\n", __func__);
	return count;
}

static struct dump_attribute initiate_attribute =
	__ATTR(initiate_dump, 0600, init_dump_show, init_dump_store);

static struct attribute *initiate_attrs[] = {
	&initiate_attribute.attr,
	NULL,
};

static struct attribute_group initiate_attr_group = {
	.attrs = initiate_attrs,
};

static struct kset *dump_kset;

static ssize_t dump_attr_show(struct kobject *kobj,
			      struct attribute *attr,
			      char *buf)
{
	struct dump_attribute *attribute;
	struct dump_obj *dump;

	attribute = to_dump_attr(attr);
	dump = to_dump_obj(kobj);

	if (!attribute->show)
		return -EIO;

	return attribute->show(dump, attribute, buf);
}

static ssize_t dump_attr_store(struct kobject *kobj,
			       struct attribute *attr,
			       const char *buf, size_t len)
{
	struct dump_attribute *attribute;
	struct dump_obj *dump;

	attribute = to_dump_attr(attr);
	dump = to_dump_obj(kobj);

	if (!attribute->store)
		return -EIO;

	return attribute->store(dump, attribute, buf, len);
}

static const struct sysfs_ops dump_sysfs_ops = {
	.show = dump_attr_show,
	.store = dump_attr_store,
};

static void dump_release(struct kobject *kobj)
{
	struct dump_obj *dump;

	dump = to_dump_obj(kobj);
	vfree(dump->buffer);
	kfree(dump);
}

static struct attribute *dump_default_attrs[] = {
	&id_attribute.attr,
	&type_attribute.attr,
	&ack_attribute.attr,
	NULL,
};

static struct kobj_type dump_ktype = {
	.sysfs_ops = &dump_sysfs_ops,
	.release = &dump_release,
	.default_attrs = dump_default_attrs,
};

static int64_t dump_read_info(uint32_t *dump_id, uint32_t *dump_size, uint32_t *dump_type)
{
	__be32 id, size, type;
	int rc;

	type = cpu_to_be32(0xffffffff);

	rc = opal_dump_info2(&id, &size, &type);
	if (rc == OPAL_PARAMETER)
		rc = opal_dump_info(&id, &size);

	*dump_id = be32_to_cpu(id);
	*dump_size = be32_to_cpu(size);
	*dump_type = be32_to_cpu(type);

	if (rc)
		pr_warn("%s: Failed to get dump info (%d)\n",
			__func__, rc);
	return rc;
}

static int64_t dump_read_data(struct dump_obj *dump)
{
	struct opal_sg_list *list;
	uint64_t addr;
	int64_t rc;

	/* Allocate memory */
	dump->buffer = vzalloc(PAGE_ALIGN(dump->size));
	if (!dump->buffer) {
		pr_err("%s : Failed to allocate memory\n", __func__);
		rc = -ENOMEM;
		goto out;
	}

	/* Generate SG list */
	list = opal_vmalloc_to_sg_list(dump->buffer, dump->size);
	if (!list) {
		rc = -ENOMEM;
		goto out;
	}

	/* First entry address */
	addr = __pa(list);

	/* Fetch data */
	rc = OPAL_BUSY_EVENT;
	while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
		rc = opal_dump_read(dump->id, addr);
		if (rc == OPAL_BUSY_EVENT) {
			opal_poll_events(NULL);
			msleep(20);
		}
	}

	if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL)
		pr_warn("%s: Extract dump failed for ID 0x%x\n",
			__func__, dump->id);

	/* Free SG list */
	opal_free_sg_list(list);

out:
	return rc;
}

static ssize_t dump_attr_read(struct file *filep, struct kobject *kobj,
			      struct bin_attribute *bin_attr,
			      char *buffer, loff_t pos, size_t count)
{
	ssize_t rc;

	struct dump_obj *dump = to_dump_obj(kobj);

	if (!dump->buffer) {
		rc = dump_read_data(dump);

		if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
			vfree(dump->buffer);
			dump->buffer = NULL;

			return -EIO;
		}
		if (rc == OPAL_PARTIAL) {
			/* On a partial read, we just return EIO
			 * and rely on userspace to ask us to try
			 * again.
			 */
			pr_info("%s: Platform dump partially read.ID = 0x%x\n",
				__func__, dump->id);
			return -EIO;
		}
	}

	memcpy(buffer, dump->buffer + pos, count);

	/* You may think we could free the dump buffer now and retrieve
	 * it again later if needed, but due to current firmware limitation,
	 * that's not the case. So, once read into userspace once,
	 * we keep the dump around until it's acknowledged by userspace.
	 */

	return count;
}

static struct dump_obj *create_dump_obj(uint32_t id, size_t size,
					uint32_t type)
{
	struct dump_obj *dump;
	int rc;

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

	dump->kobj.kset = dump_kset;

	kobject_init(&dump->kobj, &dump_ktype);

	sysfs_bin_attr_init(&dump->dump_attr);

	dump->dump_attr.attr.name = "dump";
	dump->dump_attr.attr.mode = 0400;
	dump->dump_attr.size = size;
	dump->dump_attr.read = dump_attr_read;

	dump->id = id;
	dump->size = size;
	dump->type = type;

	rc = kobject_add(&dump->kobj, NULL, "0x%x-0x%x", type, id);
	if (rc) {
		kobject_put(&dump->kobj);
		return NULL;
	}

	rc = sysfs_create_bin_file(&dump->kobj, &dump->dump_attr);
	if (rc) {
		kobject_put(&dump->kobj);
		return NULL;
	}

	pr_info("%s: New platform dump. ID = 0x%x Size %u\n",
		__func__, dump->id, dump->size);

	kobject_uevent(&dump->kobj, KOBJ_ADD);

	return dump;
}

static int process_dump(void)
{
	int rc;
	uint32_t dump_id, dump_size, dump_type;
	struct dump_obj *dump;
	char name[22];

	rc = dump_read_info(&dump_id, &dump_size, &dump_type);
	if (rc != OPAL_SUCCESS)
		return rc;

	sprintf(name, "0x%x-0x%x", dump_type, dump_id);

	/* we may get notified twice, let's handle
	 * that gracefully and not create two conflicting
	 * entries.
	 */
	if (kset_find_obj(dump_kset, name))
		return 0;

	dump = create_dump_obj(dump_id, dump_size, dump_type);
	if (!dump)
		return -1;

	return 0;
}

static void dump_work_fn(struct work_struct *work)
{
	process_dump();
}

static DECLARE_WORK(dump_work, dump_work_fn);

static void schedule_process_dump(void)
{
	schedule_work(&dump_work);
}

/*
 * New dump available notification
 *
 * Once we get notification, we add sysfs entries for it.
 * We only fetch the dump on demand, and create sysfs asynchronously.
 */
static int dump_event(struct notifier_block *nb,
		      unsigned long events, void *change)
{
	if (events & OPAL_EVENT_DUMP_AVAIL)
		schedule_process_dump();

	return 0;
}

static struct notifier_block dump_nb = {
	.notifier_call  = dump_event,
	.next           = NULL,
	.priority       = 0
};

void __init opal_platform_dump_init(void)
{
	int rc;

	dump_kset = kset_create_and_add("dump", NULL, opal_kobj);
	if (!dump_kset) {
		pr_warn("%s: Failed to create dump kset\n", __func__);
		return;
	}

	rc = sysfs_create_group(&dump_kset->kobj, &initiate_attr_group);
	if (rc) {
		pr_warn("%s: Failed to create initiate dump attr group\n",
			__func__);
		kobject_put(&dump_kset->kobj);
		return;
	}

	rc = opal_notifier_register(&dump_nb);
	if (rc) {
		pr_warn("%s: Can't register OPAL event notifier (%d)\n",
			__func__, rc);
		return;
	}

	opal_dump_resend_notification();
}
Commit	Line	Data
c7e64b9c SS	1	/*
	2	* PowerNV OPAL Dump Interface
	3	*
	4	* Copyright 2013,2014 IBM Corp.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/kobject.h>
	13	#include <linux/mm.h>
	14	#include <linux/slab.h>
	15	#include <linux/vmalloc.h>
	16	#include <linux/pagemap.h>
	17	#include <linux/delay.h>
	18
	19	#include <asm/opal.h>
	20
	21	#define DUMP_TYPE_FSP 0x01
	22
	23	struct dump_obj {
	24	struct kobject kobj;
	25	struct bin_attribute dump_attr;
	26	uint32_t id; /* becomes object name */
	27	uint32_t type;
	28	uint32_t size;
	29	char *buffer;
	30	};
	31	#define to_dump_obj(x) container_of(x, struct dump_obj, kobj)
	32
	33	struct dump_attribute {
	34	struct attribute attr;
	35	ssize_t (show)(struct dump_obj dump, struct dump_attribute *attr,
	36	char *buf);
	37	ssize_t (store)(struct dump_obj dump, struct dump_attribute *attr,
	38	const char *buf, size_t count);
	39	};
	40	#define to_dump_attr(x) container_of(x, struct dump_attribute, attr)
	41
	42	static ssize_t dump_id_show(struct dump_obj *dump_obj,
	43	struct dump_attribute *attr,
	44	char *buf)
	45	{
	46	return sprintf(buf, "0x%x\n", dump_obj->id);
	47	}
	48
	49	static const char* dump_type_to_string(uint32_t type)
	50	{
	51	switch (type) {
	52	case 0x01: return "SP Dump";
	53	case 0x02: return "System/Platform Dump";
	54	case 0x03: return "SMA Dump";
	55	default: return "unknown";
	56	}
	57	}
	58
	59	static ssize_t dump_type_show(struct dump_obj *dump_obj,
	60	struct dump_attribute *attr,
	61	char *buf)
	62	{
	63
	64	return sprintf(buf, "0x%x %s\n", dump_obj->type,
65	dump_type_to_string(dump_obj->type));
66	}
67
68	static ssize_t dump_ack_show(struct dump_obj *dump_obj,
69	struct dump_attribute *attr,
70	char *buf)
71	{
72	return sprintf(buf, "ack - acknowledge dump\n");
73	}
74
75	/*
76	* Send acknowledgement to OPAL
77	*/
78	static int64_t dump_send_ack(uint32_t dump_id)
79	{
80	int rc;
81
82	rc = opal_dump_ack(dump_id);
83	if (rc)
84	pr_warn("%s: Failed to send ack to Dump ID 0x%x (%d)\n",
85	__func__, dump_id, rc);
86	return rc;
87	}
88
c7e64b9c SS	89	static ssize_t dump_ack_store(struct dump_obj *dump_obj,
	90	struct dump_attribute *attr,
	91	const char *buf,
	92	size_t count)
	93	{
	94	dump_send_ack(dump_obj->id);
cc4f265a SS	95	sysfs_remove_file_self(&dump_obj->kobj, &attr->attr);
cc4f265a SS	96	kobject_put(&dump_obj->kobj);
c7e64b9c SS	97	return count;
	98	}
	99
	100	/* Attributes of a dump
	101	* The binary attribute of the dump itself is dynamic
	102	* due to the dynamic size of the dump
	103	*/
	104	static struct dump_attribute id_attribute =
	105	__ATTR(id, 0666, dump_id_show, NULL);
	106	static struct dump_attribute type_attribute =
	107	__ATTR(type, 0666, dump_type_show, NULL);
	108	static struct dump_attribute ack_attribute =
	109	__ATTR(acknowledge, 0660, dump_ack_show, dump_ack_store);
	110
	111	static ssize_t init_dump_show(struct dump_obj *dump_obj,
	112	struct dump_attribute *attr,
	113	char *buf)
	114	{
	115	return sprintf(buf, "1 - initiate dump\n");
	116	}
	117
	118	static int64_t dump_fips_init(uint8_t type)
	119	{
	120	int rc;
	121
	122	rc = opal_dump_init(type);
	123	if (rc)
	124	pr_warn("%s: Failed to initiate FipS dump (%d)\n",
	125	__func__, rc);
	126	return rc;
	127	}
	128
	129	static ssize_t init_dump_store(struct dump_obj *dump_obj,
	130	struct dump_attribute *attr,
	131	const char *buf,
	132	size_t count)
	133	{
	134	dump_fips_init(DUMP_TYPE_FSP);
	135	pr_info("%s: Initiated FSP dump\n", __func__);
	136	return count;
	137	}
	138
	139	static struct dump_attribute initiate_attribute =
	140	__ATTR(initiate_dump, 0600, init_dump_show, init_dump_store);
	141
	142	static struct attribute *initiate_attrs[] = {
	143	&initiate_attribute.attr,
	144	NULL,
	145	};
	146
	147	static struct attribute_group initiate_attr_group = {
	148	.attrs = initiate_attrs,
	149	};
	150
	151	static struct kset *dump_kset;
	152
	153	static ssize_t dump_attr_show(struct kobject *kobj,
	154	struct attribute *attr,
	155	char *buf)
	156	{
	157	struct dump_attribute *attribute;
	158	struct dump_obj *dump;
	159
	160	attribute = to_dump_attr(attr);
161	dump = to_dump_obj(kobj);
162
163	if (!attribute->show)
164	return -EIO;
165
166	return attribute->show(dump, attribute, buf);
167	}
168
169	static ssize_t dump_attr_store(struct kobject *kobj,
170	struct attribute *attr,
171	const char *buf, size_t len)
172	{
173	struct dump_attribute *attribute;
174	struct dump_obj *dump;
175
176	attribute = to_dump_attr(attr);
177	dump = to_dump_obj(kobj);
178
179	if (!attribute->store)
180	return -EIO;
181
182	return attribute->store(dump, attribute, buf, len);
183	}
184
185	static const struct sysfs_ops dump_sysfs_ops = {
186	.show = dump_attr_show,
187	.store = dump_attr_store,
188	};
189
190	static void dump_release(struct kobject *kobj)
191	{
192	struct dump_obj *dump;
193
194	dump = to_dump_obj(kobj);
195	vfree(dump->buffer);
196	kfree(dump);
197	}
198
199	static struct attribute *dump_default_attrs[] = {
200	&id_attribute.attr,
201	&type_attribute.attr,
202	&ack_attribute.attr,
203	NULL,
204	};
205
206	static struct kobj_type dump_ktype = {
207	.sysfs_ops = &dump_sysfs_ops,
208	.release = &dump_release,
209	.default_attrs = dump_default_attrs,
210	};
211
2d6b63bb	212	static int64_t dump_read_info(uint32_t dump_id, uint32_t dump_size, uint32_t *dump_type)
c7e64b9c	213	{
2d6b63bb	214	__be32 id, size, type;
c7e64b9c	215	int rc;
c7e64b9c	216
2d6b63bb	217	type = cpu_to_be32(0xffffffff);
c7e64b9c	218
2d6b63bb	219	rc = opal_dump_info2(&id, &size, &type);
c7e64b9c	220	if (rc == OPAL_PARAMETER)
2d6b63bb AB	221	rc = opal_dump_info(&id, &size);
	222
	223	*dump_id = be32_to_cpu(id);
	224	*dump_size = be32_to_cpu(size);
	225	*dump_type = be32_to_cpu(type);
c7e64b9c SS	226
	227	if (rc)
	228	pr_warn("%s: Failed to get dump info (%d)\n",
	229	__func__, rc);
	230	return rc;
	231	}
	232
	233	static int64_t dump_read_data(struct dump_obj *dump)
	234	{
	235	struct opal_sg_list *list;
	236	uint64_t addr;
	237	int64_t rc;
	238
	239	/* Allocate memory */
	240	dump->buffer = vzalloc(PAGE_ALIGN(dump->size));
	241	if (!dump->buffer) {
	242	pr_err("%s : Failed to allocate memory\n", __func__);
	243	rc = -ENOMEM;
	244	goto out;
	245	}
	246
	247	/* Generate SG list */
3441f04b	248	list = opal_vmalloc_to_sg_list(dump->buffer, dump->size);
c7e64b9c SS	249	if (!list) {
	250	rc = -ENOMEM;
	251	goto out;
	252	}
	253
c7e64b9c SS	254	/* First entry address */
	255	addr = __pa(list);
	256
	257	/* Fetch data */
	258	rc = OPAL_BUSY_EVENT;
	259	while (rc == OPAL_BUSY \|\| rc == OPAL_BUSY_EVENT) {
	260	rc = opal_dump_read(dump->id, addr);
	261	if (rc == OPAL_BUSY_EVENT) {
	262	opal_poll_events(NULL);
	263	msleep(20);
	264	}
	265	}
	266
	267	if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL)
	268	pr_warn("%s: Extract dump failed for ID 0x%x\n",
	269	__func__, dump->id);
	270
	271	/* Free SG list */
3441f04b	272	opal_free_sg_list(list);
c7e64b9c SS	273
	274	out:
	275	return rc;
	276	}
	277
	278	static ssize_t dump_attr_read(struct file filep, struct kobject kobj,
	279	struct bin_attribute *bin_attr,
	280	char *buffer, loff_t pos, size_t count)
	281	{
	282	ssize_t rc;
	283
	284	struct dump_obj *dump = to_dump_obj(kobj);
	285
	286	if (!dump->buffer) {
	287	rc = dump_read_data(dump);
	288
	289	if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
	290	vfree(dump->buffer);
	291	dump->buffer = NULL;
	292
	293	return -EIO;
	294	}
	295	if (rc == OPAL_PARTIAL) {
	296	/* On a partial read, we just return EIO
	297	* and rely on userspace to ask us to try
	298	* again.
	299	*/
	300	pr_info("%s: Platform dump partially read.ID = 0x%x\n",
	301	__func__, dump->id);
	302	return -EIO;
	303	}
	304	}
	305
	306	memcpy(buffer, dump->buffer + pos, count);
	307
	308	/* You may think we could free the dump buffer now and retrieve
	309	* it again later if needed, but due to current firmware limitation,
	310	* that's not the case. So, once read into userspace once,
	311	* we keep the dump around until it's acknowledged by userspace.
	312	*/
	313
	314	return count;
	315	}
	316
	317	static struct dump_obj *create_dump_obj(uint32_t id, size_t size,
	318	uint32_t type)
	319	{
	320	struct dump_obj *dump;
	321	int rc;
	322
	323	dump = kzalloc(sizeof(*dump), GFP_KERNEL);
	324	if (!dump)
	325	return NULL;
	326
	327	dump->kobj.kset = dump_kset;
	328
	329	kobject_init(&dump->kobj, &dump_ktype);
	330
	331	sysfs_bin_attr_init(&dump->dump_attr);
	332
	333	dump->dump_attr.attr.name = "dump";
	334	dump->dump_attr.attr.mode = 0400;
	335	dump->dump_attr.size = size;
	336	dump->dump_attr.read = dump_attr_read;
337
338	dump->id = id;
339	dump->size = size;
340	dump->type = type;
341
342	rc = kobject_add(&dump->kobj, NULL, "0x%x-0x%x", type, id);
343	if (rc) {
344	kobject_put(&dump->kobj);
345	return NULL;
346	}
347
348	rc = sysfs_create_bin_file(&dump->kobj, &dump->dump_attr);
349	if (rc) {
350	kobject_put(&dump->kobj);
351	return NULL;
352	}
353
354	pr_info("%s: New platform dump. ID = 0x%x Size %u\n",
355	__func__, dump->id, dump->size);
356
357	kobject_uevent(&dump->kobj, KOBJ_ADD);
358
359	return dump;
360	}
361
362	static int process_dump(void)
363	{
364	int rc;
365	uint32_t dump_id, dump_size, dump_type;
366	struct dump_obj *dump;
367	char name[22];
368
369	rc = dump_read_info(&dump_id, &dump_size, &dump_type);
370	if (rc != OPAL_SUCCESS)
371	return rc;
372
373	sprintf(name, "0x%x-0x%x", dump_type, dump_id);
374
375	/* we may get notified twice, let's handle
376	* that gracefully and not create two conflicting
377	* entries.
378	*/
379	if (kset_find_obj(dump_kset, name))
380	return 0;
381
382	dump = create_dump_obj(dump_id, dump_size, dump_type);
383	if (!dump)
384	return -1;
385
386	return 0;
387	}
388
389	static void dump_work_fn(struct work_struct *work)
390	{
391	process_dump();
392	}
393
394	static DECLARE_WORK(dump_work, dump_work_fn);
395
396	static void schedule_process_dump(void)
397	{
398	schedule_work(&dump_work);
399	}
400
401	/*
402	* New dump available notification
403	*
404	* Once we get notification, we add sysfs entries for it.
405	* We only fetch the dump on demand, and create sysfs asynchronously.
406	*/
407	static int dump_event(struct notifier_block *nb,
408	unsigned long events, void *change)
409	{
410	if (events & OPAL_EVENT_DUMP_AVAIL)
411	schedule_process_dump();
412
413	return 0;
414	}
415
416	static struct notifier_block dump_nb = {
417	.notifier_call = dump_event,
418	.next = NULL,
419	.priority = 0
420	};
421
422	void __init opal_platform_dump_init(void)
423	{
424	int rc;
425
426	dump_kset = kset_create_and_add("dump", NULL, opal_kobj);
427	if (!dump_kset) {
428	pr_warn("%s: Failed to create dump kset\n", __func__);
429	return;
430	}
431
432	rc = sysfs_create_group(&dump_kset->kobj, &initiate_attr_group);
433	if (rc) {
434	pr_warn("%s: Failed to create initiate dump attr group\n",
435	__func__);
436	kobject_put(&dump_kset->kobj);
437	return;
438	}
439
440	rc = opal_notifier_register(&dump_nb);
441	if (rc) {
442	pr_warn("%s: Can't register OPAL event notifier (%d)\n",
443	__func__, rc);
444	return;
445	}
446
447	opal_dump_resend_notification();
448	}