[net-next-2.6.git] / arch / powerpc / platforms / pseries / phyp_dump.c

/*
 * Hypervisor-assisted dump
 *
 * Linas Vepstas, Manish Ahuja 2008
 * Copyright 2008 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/gfp.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/mm.h>
#include <linux/of.h>
#include <linux/pfn.h>
#include <linux/swap.h>
#include <linux/sysfs.h>

#include <asm/page.h>
#include <asm/phyp_dump.h>
#include <asm/machdep.h>
#include <asm/prom.h>
#include <asm/rtas.h>

/* Variables, used to communicate data between early boot and late boot */
static struct phyp_dump phyp_dump_vars;
struct phyp_dump *phyp_dump_info = &phyp_dump_vars;

static int ibm_configure_kernel_dump;
/* ------------------------------------------------- */
/* RTAS interfaces to declare the dump regions */

struct dump_section {
	u32 dump_flags;
	u16 source_type;
	u16 error_flags;
	u64 source_address;
	u64 source_length;
	u64 length_copied;
	u64 destination_address;
};

struct phyp_dump_header {
	u32 version;
	u16 num_of_sections;
	u16 status;

	u32 first_offset_section;
	u32 dump_disk_section;
	u64 block_num_dd;
	u64 num_of_blocks_dd;
	u32 offset_dd;
	u32 maxtime_to_auto;
	/* No dump disk path string used */

	struct dump_section cpu_data;
	struct dump_section hpte_data;
	struct dump_section kernel_data;
};

/* The dump header *must be* in low memory, so .bss it */
static struct phyp_dump_header phdr;

#define NUM_DUMP_SECTIONS	3
#define DUMP_HEADER_VERSION	0x1
#define DUMP_REQUEST_FLAG	0x1
#define DUMP_SOURCE_CPU		0x0001
#define DUMP_SOURCE_HPTE	0x0002
#define DUMP_SOURCE_RMO		0x0011
#define DUMP_ERROR_FLAG		0x2000
#define DUMP_TRIGGERED		0x4000
#define DUMP_PERFORMED		0x8000


/**
 * init_dump_header() - initialize the header declaring a dump
 * Returns: length of dump save area.
 *
 * When the hypervisor saves crashed state, it needs to put
 * it somewhere. The dump header tells the hypervisor where
 * the data can be saved.
 */
static unsigned long init_dump_header(struct phyp_dump_header *ph)
{
	unsigned long addr_offset = 0;

	/* Set up the dump header */
	ph->version = DUMP_HEADER_VERSION;
	ph->num_of_sections = NUM_DUMP_SECTIONS;
	ph->status = 0;

	ph->first_offset_section =
		(u32)offsetof(struct phyp_dump_header, cpu_data);
	ph->dump_disk_section = 0;
	ph->block_num_dd = 0;
	ph->num_of_blocks_dd = 0;
	ph->offset_dd = 0;

	ph->maxtime_to_auto = 0; /* disabled */

	/* The first two sections are mandatory */
	ph->cpu_data.dump_flags = DUMP_REQUEST_FLAG;
	ph->cpu_data.source_type = DUMP_SOURCE_CPU;
	ph->cpu_data.source_address = 0;
	ph->cpu_data.source_length = phyp_dump_info->cpu_state_size;
	ph->cpu_data.destination_address = addr_offset;
	addr_offset += phyp_dump_info->cpu_state_size;

	ph->hpte_data.dump_flags = DUMP_REQUEST_FLAG;
	ph->hpte_data.source_type = DUMP_SOURCE_HPTE;
	ph->hpte_data.source_address = 0;
	ph->hpte_data.source_length = phyp_dump_info->hpte_region_size;
	ph->hpte_data.destination_address = addr_offset;
	addr_offset += phyp_dump_info->hpte_region_size;

	/* This section describes the low kernel region */
	ph->kernel_data.dump_flags = DUMP_REQUEST_FLAG;
	ph->kernel_data.source_type = DUMP_SOURCE_RMO;
	ph->kernel_data.source_address = PHYP_DUMP_RMR_START;
	ph->kernel_data.source_length = PHYP_DUMP_RMR_END;
	ph->kernel_data.destination_address = addr_offset;
	addr_offset += ph->kernel_data.source_length;

	return addr_offset;
}

static void print_dump_header(const struct phyp_dump_header *ph)
{
#ifdef DEBUG
	if (ph == NULL)
		return;

	printk(KERN_INFO "dump header:\n");
	/* setup some ph->sections required */
	printk(KERN_INFO "version = %d\n", ph->version);
	printk(KERN_INFO "Sections = %d\n", ph->num_of_sections);
	printk(KERN_INFO "Status = 0x%x\n", ph->status);

	/* No ph->disk, so all should be set to 0 */
	printk(KERN_INFO "Offset to first section 0x%x\n",
		ph->first_offset_section);
	printk(KERN_INFO "dump disk sections should be zero\n");
	printk(KERN_INFO "dump disk section = %d\n", ph->dump_disk_section);
	printk(KERN_INFO "block num = %lld\n", ph->block_num_dd);
	printk(KERN_INFO "number of blocks = %lld\n", ph->num_of_blocks_dd);
	printk(KERN_INFO "dump disk offset = %d\n", ph->offset_dd);
	printk(KERN_INFO "Max auto time= %d\n", ph->maxtime_to_auto);

	/*set cpu state and hpte states as well scratch pad area */
	printk(KERN_INFO " CPU AREA\n");
	printk(KERN_INFO "cpu dump_flags =%d\n", ph->cpu_data.dump_flags);
	printk(KERN_INFO "cpu source_type =%d\n", ph->cpu_data.source_type);
	printk(KERN_INFO "cpu error_flags =%d\n", ph->cpu_data.error_flags);
	printk(KERN_INFO "cpu source_address =%llx\n",
		ph->cpu_data.source_address);
	printk(KERN_INFO "cpu source_length =%llx\n",
		ph->cpu_data.source_length);
	printk(KERN_INFO "cpu length_copied =%llx\n",
		ph->cpu_data.length_copied);

	printk(KERN_INFO " HPTE AREA\n");
	printk(KERN_INFO "HPTE dump_flags =%d\n", ph->hpte_data.dump_flags);
	printk(KERN_INFO "HPTE source_type =%d\n", ph->hpte_data.source_type);
	printk(KERN_INFO "HPTE error_flags =%d\n", ph->hpte_data.error_flags);
	printk(KERN_INFO "HPTE source_address =%llx\n",
		ph->hpte_data.source_address);
	printk(KERN_INFO "HPTE source_length =%llx\n",
		ph->hpte_data.source_length);
	printk(KERN_INFO "HPTE length_copied =%llx\n",
		ph->hpte_data.length_copied);

	printk(KERN_INFO " SRSD AREA\n");
	printk(KERN_INFO "SRSD dump_flags =%d\n", ph->kernel_data.dump_flags);
	printk(KERN_INFO "SRSD source_type =%d\n", ph->kernel_data.source_type);
	printk(KERN_INFO "SRSD error_flags =%d\n", ph->kernel_data.error_flags);
	printk(KERN_INFO "SRSD source_address =%llx\n",
		ph->kernel_data.source_address);
	printk(KERN_INFO "SRSD source_length =%llx\n",
		ph->kernel_data.source_length);
	printk(KERN_INFO "SRSD length_copied =%llx\n",
		ph->kernel_data.length_copied);
#endif
}

static ssize_t show_phyp_dump_active(struct kobject *kobj,
			struct kobj_attribute *attr, char *buf)
{

	/* create filesystem entry so kdump is phyp-dump aware */
	return sprintf(buf, "%lx\n", phyp_dump_info->phyp_dump_at_boot);
}

static struct kobj_attribute pdl = __ATTR(phyp_dump_active, 0600,
					show_phyp_dump_active,
					NULL);

static void register_dump_area(struct phyp_dump_header *ph, unsigned long addr)
{
	int rc;

	/* Add addr value if not initialized before */
	if (ph->cpu_data.destination_address == 0) {
		ph->cpu_data.destination_address += addr;
		ph->hpte_data.destination_address += addr;
		ph->kernel_data.destination_address += addr;
	}

	/* ToDo Invalidate kdump and free memory range. */

	do {
		rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
				1, ph, sizeof(struct phyp_dump_header));
	} while (rtas_busy_delay(rc));

	if (rc) {
		printk(KERN_ERR "phyp-dump: unexpected error (%d) on "
						"register\n", rc);
		print_dump_header(ph);
		return;
	}

	rc = sysfs_create_file(kernel_kobj, &pdl.attr);
	if (rc)
		printk(KERN_ERR "phyp-dump: unable to create sysfs"
				" file (%d)\n", rc);
}

static
void invalidate_last_dump(struct phyp_dump_header *ph, unsigned long addr)
{
	int rc;

	/* Add addr value if not initialized before */
	if (ph->cpu_data.destination_address == 0) {
		ph->cpu_data.destination_address += addr;
		ph->hpte_data.destination_address += addr;
		ph->kernel_data.destination_address += addr;
	}

	do {
		rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
				2, ph, sizeof(struct phyp_dump_header));
	} while (rtas_busy_delay(rc));

	if (rc) {
		printk(KERN_ERR "phyp-dump: unexpected error (%d) "
						"on invalidate\n", rc);
		print_dump_header(ph);
	}
}

/* ------------------------------------------------- */
/**
 * release_memory_range -- release memory previously lmb_reserved
 * @start_pfn: starting physical frame number
 * @nr_pages: number of pages to free.
 *
 * This routine will release memory that had been previously
 * lmb_reserved in early boot. The released memory becomes
 * available for genreal use.
 */
static void release_memory_range(unsigned long start_pfn,
			unsigned long nr_pages)
{
	struct page *rpage;
	unsigned long end_pfn;
	long i;

	end_pfn = start_pfn + nr_pages;

	for (i = start_pfn; i <= end_pfn; i++) {
		rpage = pfn_to_page(i);
		if (PageReserved(rpage)) {
			ClearPageReserved(rpage);
			init_page_count(rpage);
			__free_page(rpage);
			totalram_pages++;
		}
	}
}

/**
 * track_freed_range -- Counts the range being freed.
 * Once the counter goes to zero, it re-registers dump for
 * future use.
 */
static void
track_freed_range(unsigned long addr, unsigned long length)
{
	static unsigned long scratch_area_size, reserved_area_size;

	if (addr < phyp_dump_info->init_reserve_start)
		return;

	if ((addr >= phyp_dump_info->init_reserve_start) &&
	    (addr <= phyp_dump_info->init_reserve_start +
	     phyp_dump_info->init_reserve_size))
		reserved_area_size += length;

	if ((addr >= phyp_dump_info->reserved_scratch_addr) &&
	    (addr <= phyp_dump_info->reserved_scratch_addr +
	     phyp_dump_info->reserved_scratch_size))
		scratch_area_size += length;

	if ((reserved_area_size == phyp_dump_info->init_reserve_size) &&
	    (scratch_area_size == phyp_dump_info->reserved_scratch_size)) {

		invalidate_last_dump(&phdr,
				phyp_dump_info->reserved_scratch_addr);
		register_dump_area(&phdr,
				phyp_dump_info->reserved_scratch_addr);
	}
}

/* ------------------------------------------------- */
/**
 * sysfs_release_region -- sysfs interface to release memory range.
 *
 * Usage:
 *   "echo <start addr> <length> > /sys/kernel/release_region"
 *
 * Example:
 *   "echo 0x40000000 0x10000000 > /sys/kernel/release_region"
 *
 * will release 256MB starting at 1GB.
 */
static ssize_t store_release_region(struct kobject *kobj,
				struct kobj_attribute *attr,
				const char *buf, size_t count)
{
	unsigned long start_addr, length, end_addr;
	unsigned long start_pfn, nr_pages;
	ssize_t ret;

	ret = sscanf(buf, "%lx %lx", &start_addr, &length);
	if (ret != 2)
		return -EINVAL;

	track_freed_range(start_addr, length);

	/* Range-check - don't free any reserved memory that
	 * wasn't reserved for phyp-dump */
	if (start_addr < phyp_dump_info->init_reserve_start)
		start_addr = phyp_dump_info->init_reserve_start;

	end_addr = phyp_dump_info->init_reserve_start +
			phyp_dump_info->init_reserve_size;
	if (start_addr+length > end_addr)
		length = end_addr - start_addr;

	/* Release the region of memory assed in by user */
	start_pfn = PFN_DOWN(start_addr);
	nr_pages = PFN_DOWN(length);
	release_memory_range(start_pfn, nr_pages);

	return count;
}

static ssize_t show_release_region(struct kobject *kobj,
			struct kobj_attribute *attr, char *buf)
{
	u64 second_addr_range;

	/* total reserved size - start of scratch area */
	second_addr_range = phyp_dump_info->init_reserve_size -
				phyp_dump_info->reserved_scratch_size;
	return sprintf(buf, "CPU:0x%llx-0x%llx: HPTE:0x%llx-0x%llx:"
			    " DUMP:0x%llx-0x%llx, 0x%lx-0x%llx:\n",
		phdr.cpu_data.destination_address,
		phdr.cpu_data.length_copied,
		phdr.hpte_data.destination_address,
		phdr.hpte_data.length_copied,
		phdr.kernel_data.destination_address,
		phdr.kernel_data.length_copied,
		phyp_dump_info->init_reserve_start,
		second_addr_range);
}

static struct kobj_attribute rr = __ATTR(release_region, 0600,
					show_release_region,
					store_release_region);

static int __init phyp_dump_setup(void)
{
	struct device_node *rtas;
	const struct phyp_dump_header *dump_header = NULL;
	unsigned long dump_area_start;
	unsigned long dump_area_length;
	int header_len = 0;
	int rc;

	/* If no memory was reserved in early boot, there is nothing to do */
	if (phyp_dump_info->init_reserve_size == 0)
		return 0;

	/* Return if phyp dump not supported */
	if (!phyp_dump_info->phyp_dump_configured)
		return -ENOSYS;

	/* Is there dump data waiting for us? If there isn't,
	 * then register a new dump area, and release all of
	 * the rest of the reserved ram.
	 *
	 * The /rtas/ibm,kernel-dump rtas node is present only
	 * if there is dump data waiting for us.
	 */
	rtas = of_find_node_by_path("/rtas");
	if (rtas) {
		dump_header = of_get_property(rtas, "ibm,kernel-dump",
						&header_len);
		of_node_put(rtas);
	}

	ibm_configure_kernel_dump = rtas_token("ibm,configure-kernel-dump");

	print_dump_header(dump_header);
	dump_area_length = init_dump_header(&phdr);
	/* align down */
	dump_area_start = phyp_dump_info->init_reserve_start & PAGE_MASK;

	if (dump_header == NULL) {
		register_dump_area(&phdr, dump_area_start);
		return 0;
	}

	/* re-register the dump area, if old dump was invalid */
	if ((dump_header) && (dump_header->status & DUMP_ERROR_FLAG)) {
		invalidate_last_dump(&phdr, dump_area_start);
		register_dump_area(&phdr, dump_area_start);
		return 0;
	}

	if (dump_header) {
		phyp_dump_info->reserved_scratch_addr =
				dump_header->cpu_data.destination_address;
		phyp_dump_info->reserved_scratch_size =
				dump_header->cpu_data.source_length +
				dump_header->hpte_data.source_length +
				dump_header->kernel_data.source_length;
	}

	/* Should we create a dump_subsys, analogous to s390/ipl.c ? */
	rc = sysfs_create_file(kernel_kobj, &rr.attr);
	if (rc)
		printk(KERN_ERR "phyp-dump: unable to create sysfs file (%d)\n",
									rc);

	/* ToDo: re-register the dump area, for next time. */
	return 0;
}
machine_subsys_initcall(pseries, phyp_dump_setup);

int __init early_init_dt_scan_phyp_dump(unsigned long node,
		const char *uname, int depth, void *data)
{
	const unsigned int *sizes;

	phyp_dump_info->phyp_dump_configured = 0;
	phyp_dump_info->phyp_dump_is_active = 0;

	if (depth != 1 || strcmp(uname, "rtas") != 0)
		return 0;

	if (of_get_flat_dt_prop(node, "ibm,configure-kernel-dump", NULL))
		phyp_dump_info->phyp_dump_configured++;

	if (of_get_flat_dt_prop(node, "ibm,dump-kernel", NULL))
		phyp_dump_info->phyp_dump_is_active++;

	sizes = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump-sizes",
				    NULL);
	if (!sizes)
		return 0;

	if (sizes[0] == 1)
		phyp_dump_info->cpu_state_size = *((unsigned long *)&sizes[1]);

	if (sizes[3] == 2)
		phyp_dump_info->hpte_region_size =
						*((unsigned long *)&sizes[4]);
	return 1;
}

/* Look for phyp_dump= cmdline option */
static int __init early_phyp_dump_enabled(char *p)
{
	phyp_dump_info->phyp_dump_at_boot = 1;

        if (!p)
                return 0;

        if (strncmp(p, "1", 1) == 0)
		phyp_dump_info->phyp_dump_at_boot = 1;
        else if (strncmp(p, "0", 1) == 0)
		phyp_dump_info->phyp_dump_at_boot = 0;

        return 0;
}
early_param("phyp_dump", early_phyp_dump_enabled);

/* Look for phyp_dump_reserve_size= cmdline option */
static int __init early_phyp_dump_reserve_size(char *p)
{
        if (p)
		phyp_dump_info->reserve_bootvar = memparse(p, &p);

        return 0;
}
early_param("phyp_dump_reserve_size", early_phyp_dump_reserve_size);
Commit	Line	Data
6ac26c8a MA	1	/*
	2	* Hypervisor-assisted dump
	3	*
	4	* Linas Vepstas, Manish Ahuja 2008
	5	* Copyright 2008 IBM Corp.
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*
	12	*/
	13
5a0e3ad6	14	#include <linux/gfp.h>
6ac26c8a	15	#include <linux/init.h>
d5a29c7a	16	#include <linux/kobject.h>
6ac26c8a	17	#include <linux/mm.h>
d5a29c7a	18	#include <linux/of.h>
6ac26c8a MA	19	#include <linux/pfn.h>
6ac26c8a MA	20	#include <linux/swap.h>
d5a29c7a	21	#include <linux/sysfs.h>
6ac26c8a MA	22
	23	#include <asm/page.h>
	24	#include <asm/phyp_dump.h>
	25	#include <asm/machdep.h>
	26	#include <asm/prom.h>
d5a29c7a	27	#include <asm/rtas.h>
6ac26c8a MA	28
	29	/* Variables, used to communicate data between early boot and late boot */
	30	static struct phyp_dump phyp_dump_vars;
	31	struct phyp_dump *phyp_dump_info = &phyp_dump_vars;
	32
2c4f4113 MA	33	static int ibm_configure_kernel_dump;
	34	/* ------------------------------------------------- */
	35	/* RTAS interfaces to declare the dump regions */
	36
	37	struct dump_section {
	38	u32 dump_flags;
	39	u16 source_type;
	40	u16 error_flags;
	41	u64 source_address;
	42	u64 source_length;
	43	u64 length_copied;
	44	u64 destination_address;
	45	};
	46
	47	struct phyp_dump_header {
	48	u32 version;
	49	u16 num_of_sections;
	50	u16 status;
	51
	52	u32 first_offset_section;
	53	u32 dump_disk_section;
	54	u64 block_num_dd;
	55	u64 num_of_blocks_dd;
	56	u32 offset_dd;
	57	u32 maxtime_to_auto;
	58	/* No dump disk path string used */
	59
	60	struct dump_section cpu_data;
	61	struct dump_section hpte_data;
	62	struct dump_section kernel_data;
	63	};
	64
	65	/* The dump header must be in low memory, so .bss it */
	66	static struct phyp_dump_header phdr;
	67
	68	#define NUM_DUMP_SECTIONS 3
	69	#define DUMP_HEADER_VERSION 0x1
	70	#define DUMP_REQUEST_FLAG 0x1
	71	#define DUMP_SOURCE_CPU 0x0001
	72	#define DUMP_SOURCE_HPTE 0x0002
	73	#define DUMP_SOURCE_RMO 0x0011
a9c508da MA	74	#define DUMP_ERROR_FLAG 0x2000
	75	#define DUMP_TRIGGERED 0x4000
	76	#define DUMP_PERFORMED 0x8000
	77
2c4f4113 MA	78
	79	/**
	80	* init_dump_header() - initialize the header declaring a dump
	81	* Returns: length of dump save area.
	82	*
	83	* When the hypervisor saves crashed state, it needs to put
	84	* it somewhere. The dump header tells the hypervisor where
	85	* the data can be saved.
	86	*/
	87	static unsigned long init_dump_header(struct phyp_dump_header *ph)
	88	{
	89	unsigned long addr_offset = 0;
	90
	91	/* Set up the dump header */
	92	ph->version = DUMP_HEADER_VERSION;
	93	ph->num_of_sections = NUM_DUMP_SECTIONS;
	94	ph->status = 0;
	95
	96	ph->first_offset_section =
	97	(u32)offsetof(struct phyp_dump_header, cpu_data);
	98	ph->dump_disk_section = 0;
	99	ph->block_num_dd = 0;
	100	ph->num_of_blocks_dd = 0;
	101	ph->offset_dd = 0;
	102
	103	ph->maxtime_to_auto = 0; /* disabled */
	104
	105	/* The first two sections are mandatory */
	106	ph->cpu_data.dump_flags = DUMP_REQUEST_FLAG;
	107	ph->cpu_data.source_type = DUMP_SOURCE_CPU;
	108	ph->cpu_data.source_address = 0;
	109	ph->cpu_data.source_length = phyp_dump_info->cpu_state_size;
	110	ph->cpu_data.destination_address = addr_offset;
	111	addr_offset += phyp_dump_info->cpu_state_size;
	112
	113	ph->hpte_data.dump_flags = DUMP_REQUEST_FLAG;
	114	ph->hpte_data.source_type = DUMP_SOURCE_HPTE;
	115	ph->hpte_data.source_address = 0;
	116	ph->hpte_data.source_length = phyp_dump_info->hpte_region_size;
	117	ph->hpte_data.destination_address = addr_offset;
	118	addr_offset += phyp_dump_info->hpte_region_size;
	119
	120	/* This section describes the low kernel region */
	121	ph->kernel_data.dump_flags = DUMP_REQUEST_FLAG;
	122	ph->kernel_data.source_type = DUMP_SOURCE_RMO;
	123	ph->kernel_data.source_address = PHYP_DUMP_RMR_START;
	124	ph->kernel_data.source_length = PHYP_DUMP_RMR_END;
	125	ph->kernel_data.destination_address = addr_offset;
	126	addr_offset += ph->kernel_data.source_length;
	127
	128	return addr_offset;
	129	}
	130
599c1aa5 MA	131	static void print_dump_header(const struct phyp_dump_header *ph)
	132	{
	133	#ifdef DEBUG
7a2eab0d TB	134	if (ph == NULL)
	135	return;
	136
599c1aa5 MA	137	printk(KERN_INFO "dump header:\n");
	138	/* setup some ph->sections required */
	139	printk(KERN_INFO "version = %d\n", ph->version);
	140	printk(KERN_INFO "Sections = %d\n", ph->num_of_sections);
	141	printk(KERN_INFO "Status = 0x%x\n", ph->status);
	142
	143	/* No ph->disk, so all should be set to 0 */
	144	printk(KERN_INFO "Offset to first section 0x%x\n",
	145	ph->first_offset_section);
	146	printk(KERN_INFO "dump disk sections should be zero\n");
	147	printk(KERN_INFO "dump disk section = %d\n", ph->dump_disk_section);
802bdea8 SR	148	printk(KERN_INFO "block num = %lld\n", ph->block_num_dd);
802bdea8 SR	149	printk(KERN_INFO "number of blocks = %lld\n", ph->num_of_blocks_dd);
599c1aa5 MA	150	printk(KERN_INFO "dump disk offset = %d\n", ph->offset_dd);
	151	printk(KERN_INFO "Max auto time= %d\n", ph->maxtime_to_auto);
	152
	153	/set cpu state and hpte states as well scratch pad area /
8354be9c	154	printk(KERN_INFO " CPU AREA\n");
599c1aa5 MA	155	printk(KERN_INFO "cpu dump_flags =%d\n", ph->cpu_data.dump_flags);
	156	printk(KERN_INFO "cpu source_type =%d\n", ph->cpu_data.source_type);
	157	printk(KERN_INFO "cpu error_flags =%d\n", ph->cpu_data.error_flags);
802bdea8	158	printk(KERN_INFO "cpu source_address =%llx\n",
599c1aa5	159	ph->cpu_data.source_address);
802bdea8	160	printk(KERN_INFO "cpu source_length =%llx\n",
599c1aa5	161	ph->cpu_data.source_length);
802bdea8	162	printk(KERN_INFO "cpu length_copied =%llx\n",
599c1aa5 MA	163	ph->cpu_data.length_copied);
599c1aa5 MA	164
8354be9c	165	printk(KERN_INFO " HPTE AREA\n");
599c1aa5 MA	166	printk(KERN_INFO "HPTE dump_flags =%d\n", ph->hpte_data.dump_flags);
	167	printk(KERN_INFO "HPTE source_type =%d\n", ph->hpte_data.source_type);
	168	printk(KERN_INFO "HPTE error_flags =%d\n", ph->hpte_data.error_flags);
802bdea8	169	printk(KERN_INFO "HPTE source_address =%llx\n",
599c1aa5	170	ph->hpte_data.source_address);
802bdea8	171	printk(KERN_INFO "HPTE source_length =%llx\n",
599c1aa5	172	ph->hpte_data.source_length);
802bdea8	173	printk(KERN_INFO "HPTE length_copied =%llx\n",
599c1aa5 MA	174	ph->hpte_data.length_copied);
599c1aa5 MA	175
8354be9c	176	printk(KERN_INFO " SRSD AREA\n");
599c1aa5 MA	177	printk(KERN_INFO "SRSD dump_flags =%d\n", ph->kernel_data.dump_flags);
	178	printk(KERN_INFO "SRSD source_type =%d\n", ph->kernel_data.source_type);
	179	printk(KERN_INFO "SRSD error_flags =%d\n", ph->kernel_data.error_flags);
802bdea8	180	printk(KERN_INFO "SRSD source_address =%llx\n",
599c1aa5	181	ph->kernel_data.source_address);
802bdea8	182	printk(KERN_INFO "SRSD source_length =%llx\n",
599c1aa5	183	ph->kernel_data.source_length);
802bdea8	184	printk(KERN_INFO "SRSD length_copied =%llx\n",
599c1aa5 MA	185	ph->kernel_data.length_copied);
	186	#endif
	187	}
	188
7415d5e0 MA	189	static ssize_t show_phyp_dump_active(struct kobject *kobj,
	190	struct kobj_attribute attr, char buf)
	191	{
	192
	193	/* create filesystem entry so kdump is phyp-dump aware */
	194	return sprintf(buf, "%lx\n", phyp_dump_info->phyp_dump_at_boot);
	195	}
	196
	197	static struct kobj_attribute pdl = __ATTR(phyp_dump_active, 0600,
	198	show_phyp_dump_active,
	199	NULL);
	200
2c4f4113 MA	201	static void register_dump_area(struct phyp_dump_header *ph, unsigned long addr)
	202	{
	203	int rc;
a9c508da MA	204
	205	/* Add addr value if not initialized before */
	206	if (ph->cpu_data.destination_address == 0) {
	207	ph->cpu_data.destination_address += addr;
	208	ph->hpte_data.destination_address += addr;
	209	ph->kernel_data.destination_address += addr;
	210	}
	211
	212	/* ToDo Invalidate kdump and free memory range. */
2c4f4113 MA	213
	214	do {
	215	rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
	216	1, ph, sizeof(struct phyp_dump_header));
	217	} while (rtas_busy_delay(rc));
	218
599c1aa5	219	if (rc) {
2c4f4113 MA	220	printk(KERN_ERR "phyp-dump: unexpected error (%d) on "
2c4f4113 MA	221	"register\n", rc);
599c1aa5	222	print_dump_header(ph);
7415d5e0	223	return;
599c1aa5	224	}
7415d5e0 MA	225
	226	rc = sysfs_create_file(kernel_kobj, &pdl.attr);
	227	if (rc)
	228	printk(KERN_ERR "phyp-dump: unable to create sysfs"
	229	" file (%d)\n", rc);
2c4f4113 MA	230	}
2c4f4113 MA	231
a9c508da MA	232	static
	233	void invalidate_last_dump(struct phyp_dump_header *ph, unsigned long addr)
	234	{
	235	int rc;
	236
	237	/* Add addr value if not initialized before */
	238	if (ph->cpu_data.destination_address == 0) {
	239	ph->cpu_data.destination_address += addr;
	240	ph->hpte_data.destination_address += addr;
	241	ph->kernel_data.destination_address += addr;
	242	}
	243
	244	do {
	245	rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
	246	2, ph, sizeof(struct phyp_dump_header));
	247	} while (rtas_busy_delay(rc));
	248
	249	if (rc) {
	250	printk(KERN_ERR "phyp-dump: unexpected error (%d) "
	251	"on invalidate\n", rc);
	252	print_dump_header(ph);
	253	}
	254	}
	255
d5a29c7a	256	/* ------------------------------------------------- */
6ac26c8a MA	257	/**
	258	* release_memory_range -- release memory previously lmb_reserved
	259	* @start_pfn: starting physical frame number
	260	* @nr_pages: number of pages to free.
	261	*
	262	* This routine will release memory that had been previously
	263	* lmb_reserved in early boot. The released memory becomes
	264	* available for genreal use.
	265	*/
a9c508da MA	266	static void release_memory_range(unsigned long start_pfn,
a9c508da MA	267	unsigned long nr_pages)
6ac26c8a MA	268	{
	269	struct page *rpage;
	270	unsigned long end_pfn;
	271	long i;
	272
	273	end_pfn = start_pfn + nr_pages;
	274
	275	for (i = start_pfn; i <= end_pfn; i++) {
	276	rpage = pfn_to_page(i);
	277	if (PageReserved(rpage)) {
	278	ClearPageReserved(rpage);
	279	init_page_count(rpage);
	280	__free_page(rpage);
	281	totalram_pages++;
	282	}
	283	}
	284	}
	285
fd35cff8 MA	286	/**
	287	* track_freed_range -- Counts the range being freed.
	288	* Once the counter goes to zero, it re-registers dump for
	289	* future use.
	290	*/
	291	static void
	292	track_freed_range(unsigned long addr, unsigned long length)
	293	{
	294	static unsigned long scratch_area_size, reserved_area_size;
	295
	296	if (addr < phyp_dump_info->init_reserve_start)
	297	return;
	298
	299	if ((addr >= phyp_dump_info->init_reserve_start) &&
	300	(addr <= phyp_dump_info->init_reserve_start +
	301	phyp_dump_info->init_reserve_size))
	302	reserved_area_size += length;
	303
	304	if ((addr >= phyp_dump_info->reserved_scratch_addr) &&
	305	(addr <= phyp_dump_info->reserved_scratch_addr +
	306	phyp_dump_info->reserved_scratch_size))
	307	scratch_area_size += length;
	308
	309	if ((reserved_area_size == phyp_dump_info->init_reserve_size) &&
	310	(scratch_area_size == phyp_dump_info->reserved_scratch_size)) {
	311
	312	invalidate_last_dump(&phdr,
	313	phyp_dump_info->reserved_scratch_addr);
	314	register_dump_area(&phdr,
	315	phyp_dump_info->reserved_scratch_addr);
	316	}
	317	}
	318
d5a29c7a MA	319	/* ------------------------------------------------- */
	320	/**
	321	* sysfs_release_region -- sysfs interface to release memory range.
	322	*
	323	* Usage:
	324	* "echo <start addr> <length> > /sys/kernel/release_region"
	325	*
	326	* Example:
	327	* "echo 0x40000000 0x10000000 > /sys/kernel/release_region"
	328	*
	329	* will release 256MB starting at 1GB.
	330	*/
	331	static ssize_t store_release_region(struct kobject *kobj,
	332	struct kobj_attribute *attr,
	333	const char *buf, size_t count)
6ac26c8a	334	{
d5a29c7a	335	unsigned long start_addr, length, end_addr;
6ac26c8a	336	unsigned long start_pfn, nr_pages;
d5a29c7a MA	337	ssize_t ret;
	338
	339	ret = sscanf(buf, "%lx %lx", &start_addr, &length);
	340	if (ret != 2)
	341	return -EINVAL;
	342
fd35cff8 MA	343	track_freed_range(start_addr, length);
fd35cff8 MA	344
d5a29c7a MA	345	/* Range-check - don't free any reserved memory that
	346	* wasn't reserved for phyp-dump */
	347	if (start_addr < phyp_dump_info->init_reserve_start)
	348	start_addr = phyp_dump_info->init_reserve_start;
	349
	350	end_addr = phyp_dump_info->init_reserve_start +
	351	phyp_dump_info->init_reserve_size;
	352	if (start_addr+length > end_addr)
	353	length = end_addr - start_addr;
	354
	355	/* Release the region of memory assed in by user */
	356	start_pfn = PFN_DOWN(start_addr);
	357	nr_pages = PFN_DOWN(length);
	358	release_memory_range(start_pfn, nr_pages);
	359
	360	return count;
	361	}
	362
a9c508da MA	363	static ssize_t show_release_region(struct kobject *kobj,
	364	struct kobj_attribute attr, char buf)
	365	{
	366	u64 second_addr_range;
	367
	368	/* total reserved size - start of scratch area */
	369	second_addr_range = phyp_dump_info->init_reserve_size -
	370	phyp_dump_info->reserved_scratch_size;
802bdea8 SR	371	return sprintf(buf, "CPU:0x%llx-0x%llx: HPTE:0x%llx-0x%llx:"
802bdea8 SR	372	" DUMP:0x%llx-0x%llx, 0x%lx-0x%llx:\n",
a9c508da MA	373	phdr.cpu_data.destination_address,
	374	phdr.cpu_data.length_copied,
	375	phdr.hpte_data.destination_address,
	376	phdr.hpte_data.length_copied,
	377	phdr.kernel_data.destination_address,
	378	phdr.kernel_data.length_copied,
	379	phyp_dump_info->init_reserve_start,
	380	second_addr_range);
	381	}
	382
d5a29c7a	383	static struct kobj_attribute rr = __ATTR(release_region, 0600,
a9c508da MA	384	show_release_region,
a9c508da MA	385	store_release_region);
d5a29c7a MA	386
	387	static int __init phyp_dump_setup(void)
	388	{
	389	struct device_node *rtas;
2c4f4113 MA	390	const struct phyp_dump_header *dump_header = NULL;
	391	unsigned long dump_area_start;
	392	unsigned long dump_area_length;
d5a29c7a MA	393	int header_len = 0;
d5a29c7a MA	394	int rc;
6ac26c8a MA	395
	396	/* If no memory was reserved in early boot, there is nothing to do */
	397	if (phyp_dump_info->init_reserve_size == 0)
	398	return 0;
	399
d5a29c7a MA	400	/* Return if phyp dump not supported */
	401	if (!phyp_dump_info->phyp_dump_configured)
	402	return -ENOSYS;
	403
2c4f4113 MA	404	/* Is there dump data waiting for us? If there isn't,
	405	* then register a new dump area, and release all of
	406	* the rest of the reserved ram.
	407	*
	408	* The /rtas/ibm,kernel-dump rtas node is present only
	409	* if there is dump data waiting for us.
	410	*/
d5a29c7a MA	411	rtas = of_find_node_by_path("/rtas");
	412	if (rtas) {
	413	dump_header = of_get_property(rtas, "ibm,kernel-dump",
	414	&header_len);
	415	of_node_put(rtas);
	416	}
	417
532774ec TB	418	ibm_configure_kernel_dump = rtas_token("ibm,configure-kernel-dump");
532774ec TB	419
599c1aa5	420	print_dump_header(dump_header);
2c4f4113	421	dump_area_length = init_dump_header(&phdr);
2c4f4113 MA	422	/* align down */
	423	dump_area_start = phyp_dump_info->init_reserve_start & PAGE_MASK;
	424
	425	if (dump_header == NULL) {
	426	register_dump_area(&phdr, dump_area_start);
d5a29c7a	427	return 0;
2c4f4113	428	}
d5a29c7a	429
a9c508da MA	430	/* re-register the dump area, if old dump was invalid */
	431	if ((dump_header) && (dump_header->status & DUMP_ERROR_FLAG)) {
	432	invalidate_last_dump(&phdr, dump_area_start);
	433	register_dump_area(&phdr, dump_area_start);
	434	return 0;
	435	}
	436
	437	if (dump_header) {
	438	phyp_dump_info->reserved_scratch_addr =
	439	dump_header->cpu_data.destination_address;
	440	phyp_dump_info->reserved_scratch_size =
	441	dump_header->cpu_data.source_length +
	442	dump_header->hpte_data.source_length +
	443	dump_header->kernel_data.source_length;
	444	}
	445
d5a29c7a MA	446	/* Should we create a dump_subsys, analogous to s390/ipl.c ? */
d5a29c7a MA	447	rc = sysfs_create_file(kernel_kobj, &rr.attr);
2c4f4113	448	if (rc)
d5a29c7a MA	449	printk(KERN_ERR "phyp-dump: unable to create sysfs file (%d)\n",
d5a29c7a MA	450	rc);
6ac26c8a	451
2c4f4113	452	/* ToDo: re-register the dump area, for next time. */
6ac26c8a MA	453	return 0;
	454	}
	455	machine_subsys_initcall(pseries, phyp_dump_setup);
	456
	457	int __init early_init_dt_scan_phyp_dump(unsigned long node,
	458	const char uname, int depth, void data)
	459	{
	460	const unsigned int *sizes;
	461
	462	phyp_dump_info->phyp_dump_configured = 0;
	463	phyp_dump_info->phyp_dump_is_active = 0;
	464
	465	if (depth != 1 \|\| strcmp(uname, "rtas") != 0)
	466	return 0;
	467
	468	if (of_get_flat_dt_prop(node, "ibm,configure-kernel-dump", NULL))
	469	phyp_dump_info->phyp_dump_configured++;
	470
	471	if (of_get_flat_dt_prop(node, "ibm,dump-kernel", NULL))
	472	phyp_dump_info->phyp_dump_is_active++;
	473
	474	sizes = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump-sizes",
	475	NULL);
	476	if (!sizes)
	477	return 0;
	478
	479	if (sizes[0] == 1)
	480	phyp_dump_info->cpu_state_size = ((unsigned long )&sizes[1]);
	481
	482	if (sizes[3] == 2)
	483	phyp_dump_info->hpte_region_size =
	484	((unsigned long )&sizes[4]);
	485	return 1;
	486	}
654f596d MA	487
	488	/* Look for phyp_dump= cmdline option */
	489	static int __init early_phyp_dump_enabled(char *p)
	490	{
	491	phyp_dump_info->phyp_dump_at_boot = 1;
	492
	493	if (!p)
	494	return 0;
	495
	496	if (strncmp(p, "1", 1) == 0)
	497	phyp_dump_info->phyp_dump_at_boot = 1;
	498	else if (strncmp(p, "0", 1) == 0)
	499	phyp_dump_info->phyp_dump_at_boot = 0;
	500
	501	return 0;
	502	}
	503	early_param("phyp_dump", early_phyp_dump_enabled);
	504
37ddd5d0 MA	505	/* Look for phyp_dump_reserve_size= cmdline option */
	506	static int __init early_phyp_dump_reserve_size(char *p)
	507	{
	508	if (p)
	509	phyp_dump_info->reserve_bootvar = memparse(p, &p);
	510
	511	return 0;
	512	}
	513	early_param("phyp_dump_reserve_size", early_phyp_dump_reserve_size);