arch/m68k/atari/stram.c

   1 /*
   2  * Functions for ST-RAM allocations
   3  *
   4  * Copyright 1994-97 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 #include <linux/types.h>
  12 #include <linux/kernel.h>
  13 #include <linux/mm.h>
  14 #include <linux/kdev_t.h>
  15 #include <linux/major.h>
  16 #include <linux/init.h>
  17 #include <linux/slab.h>
  18 #include <linux/vmalloc.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/bootmem.h>
  21 #include <linux/mount.h>
  22 #include <linux/blkdev.h>
  23 #include <linux/module.h>
  24
  25 #include <asm/setup.h>
  26 #include <asm/machdep.h>
  27 #include <asm/page.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/atarihw.h>
  30 #include <asm/atari_stram.h>
  31 #include <asm/io.h>
  32
  33
  34 /*
  35  * The ST-RAM allocator allocates memory from a pool of reserved ST-RAM of
  36  * configurable size, set aside on ST-RAM init.
  37  * As long as this pool is not exhausted, allocation of real ST-RAM can be
  38  * guaranteed.
  39  */
  40
  41 /* set if kernel is in ST-RAM */
  42 static int kernel_in_stram;
  43
  44 static struct resource stram_pool = {
  45         .name = "ST-RAM Pool"
  46 };
  47
  48 static unsigned long pool_size = 1024*1024;
  49
  50
  51 static int __init atari_stram_setup(char *arg)
  52 {
  53         if (!MACH_IS_ATARI)
  54                 return 0;
  55
  56         pool_size = memparse(arg, NULL);
  57         return 0;
  58 }
  59
  60 early_param("stram_pool", atari_stram_setup);
  61
  62
  63 /*
  64  * This init function is called very early by atari/config.c
  65  * It initializes some internal variables needed for stram_alloc()
  66  */
  67 void __init atari_stram_init(void)
  68 {
  69         int i;
  70         void *stram_start;
  71
  72         /*
  73          * determine whether kernel code resides in ST-RAM
  74          * (then ST-RAM is the first memory block at virtual 0x0)
  75          */
  76         stram_start = phys_to_virt(0);
  77         kernel_in_stram = (stram_start == 0);
  78
  79         for (i = 0; i < m68k_num_memory; ++i) {
  80                 if (m68k_memory[i].addr == 0) {
  81                         return;
  82                 }
  83         }
  84
  85         /* Should never come here! (There is always ST-Ram!) */
  86         panic("atari_stram_init: no ST-RAM found!");
  87 }
  88
  89
  90 /*
  91  * This function is called from setup_arch() to reserve the pages needed for
  92  * ST-RAM management.
  93  */
  94 void __init atari_stram_reserve_pages(void *start_mem)
  95 {
  96         /*
  97          * always reserve first page of ST-RAM, the first 2 KiB are
  98          * supervisor-only!
  99          */
 100         if (!kernel_in_stram)
 101                 reserve_bootmem(0, PAGE_SIZE, BOOTMEM_DEFAULT);
 102
 103         stram_pool.start = (resource_size_t)alloc_bootmem_low_pages(pool_size);
 104         stram_pool.end = stram_pool.start + pool_size - 1;
 105         request_resource(&iomem_resource, &stram_pool);
 106
 107         pr_debug("atari_stram pool: size = %lu bytes, resource = %pR\n",
 108                  pool_size, &stram_pool);
 109 }
 110
 111
 112 void *atari_stram_alloc(unsigned long size, const char *owner)
 113 {
 114         struct resource *res;
 115         int error;
 116
 117         pr_debug("atari_stram_alloc: allocate %lu bytes\n", size);
 118
 119         /* round up */
 120         size = PAGE_ALIGN(size);
 121
 122         res = kzalloc(sizeof(struct resource), GFP_KERNEL);
 123         if (!res)
 124                 return NULL;
 125
 126         res->name = owner;
 127         error = allocate_resource(&stram_pool, res, size, 0, UINT_MAX,
 128                                   PAGE_SIZE, NULL, NULL);
 129         if (error < 0) {
 130                 pr_err("atari_stram_alloc: allocate_resource() failed %d!\n",
 131                        error);
 132                 kfree(res);
 133                 return NULL;
 134         }
 135
 136         pr_debug("atari_stram_alloc: returning %pR\n", res);
 137         return (void *)res->start;
 138 }
 139 EXPORT_SYMBOL(atari_stram_alloc);
 140
 141
 142 void atari_stram_free(void *addr)
 143 {
 144         unsigned long start = (unsigned long)addr;
 145         struct resource *res;
 146         unsigned long size;
 147
 148         res = lookup_resource(&stram_pool, start);
 149         if (!res) {
 150                 pr_err("atari_stram_free: trying to free nonexistent region "
 151                        "at %p\n", addr);
 152                 return;
 153         }
 154
 155         size = resource_size(res);
 156         pr_debug("atari_stram_free: free %lu bytes at %p\n", size, addr);
 157         release_resource(res);
 158         kfree(res);
 159 }
 160 EXPORT_SYMBOL(atari_stram_free);