[deliverable/linux.git] / drivers / acpi / nvs.c

/*
 * nvs.c - Routines for saving and restoring ACPI NVS memory region
 *
 * Copyright (C) 2008-2011 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/acpi.h>
#include <linux/acpi_io.h>
#include <acpi/acpiosxf.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
 */
int 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 = acpi_os_ioremap(entry->phys_start,
						    entry->size);
			if (!entry->kaddr) {
				suspend_nvs_free();
				return -ENOMEM;
			}
			memcpy(entry->data, entry->kaddr, entry->size);
		}

	return 0;
}

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