[net-next-2.6.git] / kernel / power / nvs.c

/*
 * linux/kernel/power/hibernate_nvs.c - Routines for handling NVS memory
 *
 * Copyright (C) 2008,2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
 *
 * This file is released under the GPLv2.
 */

#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/suspend.h>

/*
 * Platforms, like ACPI, may want us to save some memory used by them during
 * suspend and to restore the contents of this memory during the subsequent
 * resume.  The code below implements a mechanism allowing us to do that.
 */

struct nvs_page {
	unsigned long phys_start;
	unsigned int size;
	void *kaddr;
	void *data;
	struct list_head node;
};

static LIST_HEAD(nvs_list);

/**
 *	suspend_nvs_register - register platform NVS memory region to save
 *	@start - physical address of the region
 *	@size - size of the region
 *
 *	The NVS region need not be page-aligned (both ends) and we arrange
 *	things so that the data from page-aligned addresses in this region will
 *	be copied into separate RAM pages.
 */
int suspend_nvs_register(unsigned long start, unsigned long size)
{
	struct nvs_page *entry, *next;

	while (size > 0) {
		unsigned int nr_bytes;

		entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL);
		if (!entry)
			goto Error;

		list_add_tail(&entry->node, &nvs_list);
		entry->phys_start = start;
		nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK);
		entry->size = (size < nr_bytes) ? size : nr_bytes;

		start += entry->size;
		size -= entry->size;
	}
	return 0;

 Error:
	list_for_each_entry_safe(entry, next, &nvs_list, node) {
		list_del(&entry->node);
		kfree(entry);
	}
	return -ENOMEM;
}

/**
 *	suspend_nvs_free - free data pages allocated for saving NVS regions
 */
void suspend_nvs_free(void)
{
	struct nvs_page *entry;

	list_for_each_entry(entry, &nvs_list, node)
		if (entry->data) {
			free_page((unsigned long)entry->data);
			entry->data = NULL;
			if (entry->kaddr) {
				iounmap(entry->kaddr);
				entry->kaddr = NULL;
			}
		}
}

/**
 *	suspend_nvs_alloc - allocate memory necessary for saving NVS regions
 */
int suspend_nvs_alloc(void)
{
	struct nvs_page *entry;

	list_for_each_entry(entry, &nvs_list, node) {
		entry->data = (void *)__get_free_page(GFP_KERNEL);
		if (!entry->data) {
			suspend_nvs_free();
			return -ENOMEM;
		}
	}
	return 0;
}

/**
 *	suspend_nvs_save - save NVS memory regions
 */
void suspend_nvs_save(void)
{
	struct nvs_page *entry;

	printk(KERN_INFO "PM: Saving platform NVS memory\n");

	list_for_each_entry(entry, &nvs_list, node)
		if (entry->data) {
			entry->kaddr = ioremap(entry->phys_start, entry->size);
			memcpy(entry->data, entry->kaddr, entry->size);
		}
}

/**
 *	suspend_nvs_restore - restore NVS memory regions
 *
 *	This function is going to be called with interrupts disabled, so it
 *	cannot iounmap the virtual addresses used to access the NVS region.
 */
void suspend_nvs_restore(void)
{
	struct nvs_page *entry;

	printk(KERN_INFO "PM: Restoring platform NVS memory\n");

	list_for_each_entry(entry, &nvs_list, node)
		if (entry->data)
			memcpy(entry->kaddr, entry->data, entry->size);
}
Commit	Line	Data
fce2b111 CH	1	/*
	2	* linux/kernel/power/hibernate_nvs.c - Routines for handling NVS memory
	3	*
	4	* Copyright (C) 2008,2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
	5	*
	6	* This file is released under the GPLv2.
	7	*/
	8
	9	#include <linux/io.h>
	10	#include <linux/kernel.h>
	11	#include <linux/list.h>
	12	#include <linux/mm.h>
5a0e3ad6	13	#include <linux/slab.h>
fce2b111 CH	14	#include <linux/suspend.h>
	15
	16	/*
	17	* Platforms, like ACPI, may want us to save some memory used by them during
dd4c4f17	18	* suspend and to restore the contents of this memory during the subsequent
fce2b111 CH	19	* resume. The code below implements a mechanism allowing us to do that.
	20	*/
	21
	22	struct nvs_page {
	23	unsigned long phys_start;
	24	unsigned int size;
	25	void *kaddr;
	26	void *data;
	27	struct list_head node;
	28	};
	29
	30	static LIST_HEAD(nvs_list);
	31
	32	/**
dd4c4f17	33	* suspend_nvs_register - register platform NVS memory region to save
fce2b111 CH	34	* @start - physical address of the region
	35	* @size - size of the region
	36	*
	37	* The NVS region need not be page-aligned (both ends) and we arrange
	38	* things so that the data from page-aligned addresses in this region will
	39	* be copied into separate RAM pages.
	40	*/
dd4c4f17	41	int suspend_nvs_register(unsigned long start, unsigned long size)
fce2b111 CH	42	{
	43	struct nvs_page entry, next;
	44
	45	while (size > 0) {
	46	unsigned int nr_bytes;
	47
	48	entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL);
	49	if (!entry)
	50	goto Error;
	51
	52	list_add_tail(&entry->node, &nvs_list);
	53	entry->phys_start = start;
	54	nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK);
	55	entry->size = (size < nr_bytes) ? size : nr_bytes;
	56
	57	start += entry->size;
	58	size -= entry->size;
	59	}
	60	return 0;
	61
	62	Error:
	63	list_for_each_entry_safe(entry, next, &nvs_list, node) {
	64	list_del(&entry->node);
	65	kfree(entry);
	66	}
	67	return -ENOMEM;
	68	}
	69
	70	/**
dd4c4f17	71	* suspend_nvs_free - free data pages allocated for saving NVS regions
fce2b111	72	*/
dd4c4f17	73	void suspend_nvs_free(void)
fce2b111 CH	74	{
	75	struct nvs_page *entry;
	76
	77	list_for_each_entry(entry, &nvs_list, node)
	78	if (entry->data) {
	79	free_page((unsigned long)entry->data);
	80	entry->data = NULL;
	81	if (entry->kaddr) {
	82	iounmap(entry->kaddr);
	83	entry->kaddr = NULL;
	84	}
	85	}
	86	}
	87
	88	/**
dd4c4f17	89	* suspend_nvs_alloc - allocate memory necessary for saving NVS regions
fce2b111	90	*/
dd4c4f17	91	int suspend_nvs_alloc(void)
fce2b111 CH	92	{
	93	struct nvs_page *entry;
	94
	95	list_for_each_entry(entry, &nvs_list, node) {
	96	entry->data = (void *)__get_free_page(GFP_KERNEL);
	97	if (!entry->data) {
dd4c4f17	98	suspend_nvs_free();
fce2b111 CH	99	return -ENOMEM;
	100	}
	101	}
	102	return 0;
	103	}
	104
	105	/**
dd4c4f17	106	* suspend_nvs_save - save NVS memory regions
fce2b111	107	*/
dd4c4f17	108	void suspend_nvs_save(void)
fce2b111 CH	109	{
	110	struct nvs_page *entry;
	111
	112	printk(KERN_INFO "PM: Saving platform NVS memory\n");
	113
	114	list_for_each_entry(entry, &nvs_list, node)
	115	if (entry->data) {
	116	entry->kaddr = ioremap(entry->phys_start, entry->size);
	117	memcpy(entry->data, entry->kaddr, entry->size);
	118	}
	119	}
	120
	121	/**
dd4c4f17	122	* suspend_nvs_restore - restore NVS memory regions
fce2b111 CH	123	*
	124	* This function is going to be called with interrupts disabled, so it
	125	* cannot iounmap the virtual addresses used to access the NVS region.
	126	*/
dd4c4f17	127	void suspend_nvs_restore(void)
fce2b111 CH	128	{
	129	struct nvs_page *entry;
	130
	131	printk(KERN_INFO "PM: Restoring platform NVS memory\n");
	132
	133	list_for_each_entry(entry, &nvs_list, node)
	134	if (entry->data)
	135	memcpy(entry->kaddr, entry->data, entry->size);
	136	}