drivers/acpi/nvs.c

   1 /*
   2  * nvs.c - Routines for saving and restoring ACPI NVS memory region
   3  *
   4  * Copyright (C) 2008-2011 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>
  13 #include <linux/slab.h>
  14 #include <linux/acpi.h>
  15 #include <linux/acpi_io.h>
  16 #include <acpi/acpiosxf.h>
  17
  18 /*
  19  * Platforms, like ACPI, may want us to save some memory used by them during
  20  * suspend and to restore the contents of this memory during the subsequent
  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 /**
  35  *      suspend_nvs_register - register platform NVS memory region to save
  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  */
  43 int suspend_nvs_register(unsigned long start, unsigned long size)
  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 /**
  73  *      suspend_nvs_free - free data pages allocated for saving NVS regions
  74  */
  75 void suspend_nvs_free(void)
  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) {
  84                                 iounmap(entry->kaddr);
  85                                 entry->kaddr = NULL;
  86                         }
  87                 }
  88 }
  89
  90 /**
  91  *      suspend_nvs_alloc - allocate memory necessary for saving NVS regions
  92  */
  93 int suspend_nvs_alloc(void)
  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) {
 100                         suspend_nvs_free();
 101                         return -ENOMEM;
 102                 }
 103         }
 104         return 0;
 105 }
 106
 107 /**
 108  *      suspend_nvs_save - save NVS memory regions
 109  */
 110 int suspend_nvs_save(void)
 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) {
 118                         entry->kaddr = acpi_os_ioremap(entry->phys_start,
 119                                                     entry->size);
 120                         if (!entry->kaddr) {
 121                                 suspend_nvs_free();
 122                                 return -ENOMEM;
 123                         }
 124                         memcpy(entry->data, entry->kaddr, entry->size);
 125                 }
 126
 127         return 0;
 128 }
 129
 130 /**
 131  *      suspend_nvs_restore - restore NVS memory regions
 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  */
 136 void suspend_nvs_restore(void)
 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 }