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/memblock.h>
  21 #include <linux/mount.h>
  22 #include <linux/blkdev.h>
  23 #include <linux/module.h>
  24 #include <linux/ioport.h>
  25
  26 #include <asm/setup.h>
  27 #include <asm/machdep.h>
  28 #include <asm/page.h>
  29 #include <asm/pgtable.h>
  30 #include <asm/atarihw.h>
  31 #include <asm/atari_stram.h>
  32 #include <asm/io.h>
  33
  34
  35 /*
  36  * The ST-RAM allocator allocates memory from a pool of reserved ST-RAM of
  37  * configurable size, set aside on ST-RAM init.
  38  * As long as this pool is not exhausted, allocation of real ST-RAM can be
  39  * guaranteed.
  40  */
  41
  42 /* set if kernel is in ST-RAM */
  43 static int kernel_in_stram;
  44
  45 static struct resource stram_pool = {
  46         .name = "ST-RAM Pool"
  47 };
  48
  49 static unsigned long pool_size = 1024*1024;
  50
  51 static unsigned long stram_virt_offset;
  52
  53 static int __init atari_stram_setup(char *arg)
  54 {
  55         if (!MACH_IS_ATARI)
  56                 return 0;
  57
  58         pool_size = memparse(arg, NULL);
  59         return 0;
  60 }
  61
  62 early_param("stram_pool", atari_stram_setup);
  63
  64
  65 /*
  66  * This init function is called very early by atari/config.c
  67  * It initializes some internal variables needed for stram_alloc()
  68  */
  69 void __init atari_stram_init(void)
  70 {
  71         int i;
  72
  73         /*
  74          * determine whether kernel code resides in ST-RAM
  75          * (then ST-RAM is the first memory block at virtual 0x0)
  76          */
  77         kernel_in_stram = (m68k_memory[0].addr == 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, if the kernel resides in ST-RAM.
  93  */
  94 void __init atari_stram_reserve_pages(void *start_mem)
  95 {
  96         if (kernel_in_stram) {
  97                 pr_debug("atari_stram pool: kernel in ST-RAM, using alloc_bootmem!\n");
  98                 stram_pool.start = (resource_size_t)memblock_alloc_low(pool_size,
  99                                                                        PAGE_SIZE);
 100                 if (!stram_pool.start)
 101                         panic("%s: Failed to allocate %lu bytes align=%lx\n",
 102                               __func__, pool_size, PAGE_SIZE);
 103
 104                 stram_pool.end = stram_pool.start + pool_size - 1;
 105                 request_resource(&iomem_resource, &stram_pool);
 106                 stram_virt_offset = 0;
 107                 pr_debug("atari_stram pool: size = %lu bytes, resource = %pR\n",
 108                         pool_size, &stram_pool);
 109                 pr_debug("atari_stram pool: stram_virt_offset = %lx\n",
 110                         stram_virt_offset);
 111         }
 112 }
 113
 114
 115 /*
 116  * This function is called as arch initcall to reserve the pages needed for
 117  * ST-RAM management, if the kernel does not reside in ST-RAM.
 118  */
 119 int __init atari_stram_map_pages(void)
 120 {
 121         if (!kernel_in_stram) {
 122                 /*
 123                  * Skip page 0, as the fhe first 2 KiB are supervisor-only!
 124                  */
 125                 pr_debug("atari_stram pool: kernel not in ST-RAM, using ioremap!\n");
 126                 stram_pool.start = PAGE_SIZE;
 127                 stram_pool.end = stram_pool.start + pool_size - 1;
 128                 request_resource(&iomem_resource, &stram_pool);
 129                 stram_virt_offset = (unsigned long) ioremap(stram_pool.start,
 130                                 resource_size(&stram_pool)) - stram_pool.start;
 131                 pr_debug("atari_stram pool: size = %lu bytes, resource = %pR\n",
 132                         pool_size, &stram_pool);
 133                 pr_debug("atari_stram pool: stram_virt_offset = %lx\n",
 134                         stram_virt_offset);
 135         }
 136         return 0;
 137 }
 138 arch_initcall(atari_stram_map_pages);
 139
 140
 141 void *atari_stram_to_virt(unsigned long phys)
 142 {
 143         return (void *)(phys + stram_virt_offset);
 144 }
 145 EXPORT_SYMBOL(atari_stram_to_virt);
 146
 147
 148 unsigned long atari_stram_to_phys(void *virt)
 149 {
 150         return (unsigned long)(virt - stram_virt_offset);
 151 }
 152 EXPORT_SYMBOL(atari_stram_to_phys);
 153
 154
 155 void *atari_stram_alloc(unsigned long size, const char *owner)
 156 {
 157         struct resource *res;
 158         int error;
 159
 160         pr_debug("atari_stram_alloc: allocate %lu bytes\n", size);
 161
 162         /* round up */
 163         size = PAGE_ALIGN(size);
 164
 165         res = kzalloc(sizeof(struct resource), GFP_KERNEL);
 166         if (!res)
 167                 return NULL;
 168
 169         res->name = owner;
 170         error = allocate_resource(&stram_pool, res, size, 0, UINT_MAX,
 171                                   PAGE_SIZE, NULL, NULL);
 172         if (error < 0) {
 173                 pr_err("atari_stram_alloc: allocate_resource() failed %d!\n",
 174                        error);
 175                 kfree(res);
 176                 return NULL;
 177         }
 178
 179         pr_debug("atari_stram_alloc: returning %pR\n", res);
 180         return atari_stram_to_virt(res->start);
 181 }
 182 EXPORT_SYMBOL(atari_stram_alloc);
 183
 184
 185 void atari_stram_free(void *addr)
 186 {
 187         unsigned long start = atari_stram_to_phys(addr);
 188         struct resource *res;
 189         unsigned long size;
 190
 191         res = lookup_resource(&stram_pool, start);
 192         if (!res) {
 193                 pr_err("atari_stram_free: trying to free nonexistent region "
 194                        "at %p\n", addr);
 195                 return;
 196         }
 197
 198         size = resource_size(res);
 199         pr_debug("atari_stram_free: free %lu bytes at %p\n", size, addr);
 200         release_resource(res);
 201         kfree(res);
 202 }
 203 EXPORT_SYMBOL(atari_stram_free);