arch/powerpc/sysdev/fsl_85xx_cache_sram.c

   1 /*
   2  * Copyright 2009-2010 Freescale Semiconductor, Inc.
   3  *
   4  * Simple memory allocator abstraction for QorIQ (P1/P2) based Cache-SRAM
   5  *
   6  * Author: Vivek Mahajan <vivek.mahajan@freescale.com>
   7  *
   8  * This file is derived from the original work done
   9  * by Sylvain Munaut for the Bestcomm SRAM allocator.
  10  *
  11  * This program is free software; you can redistribute  it and/or modify it
  12  * under  the terms of  the GNU General  Public License as published by the
  13  * Free Software Foundation;  either version 2 of the  License, or (at your
  14  * option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/slab.h>
  28 #include <linux/err.h>
  29 #include <linux/of_platform.h>
  30 #include <asm/pgtable.h>
  31 #include <asm/fsl_85xx_cache_sram.h>
  32
  33 #include "fsl_85xx_cache_ctlr.h"
  34
  35 struct mpc85xx_cache_sram *cache_sram;
  36
  37 void *mpc85xx_cache_sram_alloc(unsigned int size,
  38                                 phys_addr_t *phys, unsigned int align)
  39 {
  40         unsigned long offset;
  41         unsigned long flags;
  42
  43         if (unlikely(cache_sram == NULL))
  44                 return NULL;
  45
  46         if (!size || (size > cache_sram->size) || (align > cache_sram->size)) {
  47                 pr_err("%s(): size(=%x) or align(=%x) zero or too big\n",
  48                         __func__, size, align);
  49                 return NULL;
  50         }
  51
  52         if ((align & (align - 1)) || align <= 1) {
  53                 pr_err("%s(): align(=%x) must be power of two and >1\n",
  54                         __func__, align);
  55                 return NULL;
  56         }
  57
  58         spin_lock_irqsave(&cache_sram->lock, flags);
  59         offset = rh_alloc_align(cache_sram->rh, size, align, NULL);
  60         spin_unlock_irqrestore(&cache_sram->lock, flags);
  61
  62         if (IS_ERR_VALUE(offset))
  63                 return NULL;
  64
  65         *phys = cache_sram->base_phys + offset;
  66
  67         return (unsigned char *)cache_sram->base_virt + offset;
  68 }
  69 EXPORT_SYMBOL(mpc85xx_cache_sram_alloc);
  70
  71 void mpc85xx_cache_sram_free(void *ptr)
  72 {
  73         unsigned long flags;
  74         BUG_ON(!ptr);
  75
  76         spin_lock_irqsave(&cache_sram->lock, flags);
  77         rh_free(cache_sram->rh, ptr - cache_sram->base_virt);
  78         spin_unlock_irqrestore(&cache_sram->lock, flags);
  79 }
  80 EXPORT_SYMBOL(mpc85xx_cache_sram_free);
  81
  82 int __init instantiate_cache_sram(struct platform_device *dev,
  83                 struct sram_parameters sram_params)
  84 {
  85         int ret = 0;
  86
  87         if (cache_sram) {
  88                 dev_err(&dev->dev, "Already initialized cache-sram\n");
  89                 return -EBUSY;
  90         }
  91
  92         cache_sram = kzalloc(sizeof(struct mpc85xx_cache_sram), GFP_KERNEL);
  93         if (!cache_sram) {
  94                 dev_err(&dev->dev, "Out of memory for cache_sram structure\n");
  95                 return -ENOMEM;
  96         }
  97
  98         cache_sram->base_phys = sram_params.sram_offset;
  99         cache_sram->size = sram_params.sram_size;
 100
 101         if (!request_mem_region(cache_sram->base_phys, cache_sram->size,
 102                                                 "fsl_85xx_cache_sram")) {
 103                 dev_err(&dev->dev, "%s: request memory failed\n",
 104                                 dev->dev.of_node->full_name);
 105                 ret = -ENXIO;
 106                 goto out_free;
 107         }
 108
 109         cache_sram->base_virt = ioremap_flags(cache_sram->base_phys,
 110                                 cache_sram->size, _PAGE_COHERENT | PAGE_KERNEL);
 111         if (!cache_sram->base_virt) {
 112                 dev_err(&dev->dev, "%s: ioremap_flags failed\n",
 113                                 dev->dev.of_node->full_name);
 114                 ret = -ENOMEM;
 115                 goto out_release;
 116         }
 117
 118         cache_sram->rh = rh_create(sizeof(unsigned int));
 119         if (IS_ERR(cache_sram->rh)) {
 120                 dev_err(&dev->dev, "%s: Unable to create remote heap\n",
 121                                 dev->dev.of_node->full_name);
 122                 ret = PTR_ERR(cache_sram->rh);
 123                 goto out_unmap;
 124         }
 125
 126         rh_attach_region(cache_sram->rh, 0, cache_sram->size);
 127         spin_lock_init(&cache_sram->lock);
 128
 129         dev_info(&dev->dev, "[base:0x%llx, size:0x%x] configured and loaded\n",
 130                 (unsigned long long)cache_sram->base_phys, cache_sram->size);
 131
 132         return 0;
 133
 134 out_unmap:
 135         iounmap(cache_sram->base_virt);
 136
 137 out_release:
 138         release_mem_region(cache_sram->base_phys, cache_sram->size);
 139
 140 out_free:
 141         kfree(cache_sram);
 142         return ret;
 143 }
 144
 145 void remove_cache_sram(struct platform_device *dev)
 146 {
 147         BUG_ON(!cache_sram);
 148
 149         rh_detach_region(cache_sram->rh, 0, cache_sram->size);
 150         rh_destroy(cache_sram->rh);
 151
 152         iounmap(cache_sram->base_virt);
 153         release_mem_region(cache_sram->base_phys, cache_sram->size);
 154
 155         kfree(cache_sram);
 156         cache_sram = NULL;
 157
 158         dev_info(&dev->dev, "MPC85xx Cache-SRAM driver unloaded\n");
 159 }