LXR linux/arch/metag/kernel/tcm.c

   1/*
   2 * Copyright (C) 2010 Imagination Technologies Ltd.
   3 */
   4
   5#include <linux/init.h>
   6#include <linux/kernel.h>
   7#include <linux/spinlock.h>
   8#include <linux/stddef.h>
   9#include <linux/genalloc.h>
  10#include <linux/string.h>
  11#include <linux/list.h>
  12#include <linux/slab.h>
  13#include <asm/page.h>
  14#include <asm/tcm.h>
  15
  16struct tcm_pool {
  17        struct list_head list;
  18        unsigned int tag;
  19        unsigned long start;
  20        unsigned long end;
  21        struct gen_pool *pool;
  22};
  23
  24static LIST_HEAD(pool_list);
  25
  26static struct tcm_pool *find_pool(unsigned int tag)
  27{
  28        struct list_head *lh;
  29        struct tcm_pool *pool;
  30
  31        list_for_each(lh, &pool_list) {
  32                pool = list_entry(lh, struct tcm_pool, list);
  33                if (pool->tag == tag)
  34                        return pool;
  35        }
  36
  37        return NULL;
  38}
  39
  40/**
  41 * tcm_alloc - allocate memory from a TCM pool
  42 * @tag: tag of the pool to allocate memory from
  43 * @len: number of bytes to be allocated
  44 *
  45 * Allocate the requested number of bytes from the pool matching
  46 * the specified tag. Returns the address of the allocated memory
  47 * or zero on failure.
  48 */
  49unsigned long tcm_alloc(unsigned int tag, size_t len)
  50{
  51        unsigned long vaddr;
  52        struct tcm_pool *pool;
  53
  54        pool = find_pool(tag);
  55        if (!pool)
  56                return 0;
  57
  58        vaddr = gen_pool_alloc(pool->pool, len);
  59        if (!vaddr)
  60                return 0;
  61
  62        return vaddr;
  63}
  64
  65/**
  66 * tcm_free - free a block of memory to a TCM pool
  67 * @tag: tag of the pool to free memory to
  68 * @addr: address of the memory to be freed
  69 * @len: number of bytes to be freed
  70 *
  71 * Free the requested number of bytes at a specific address to the
  72 * pool matching the specified tag.
  73 */
  74void tcm_free(unsigned int tag, unsigned long addr, size_t len)
  75{
  76        struct tcm_pool *pool;
  77
  78        pool = find_pool(tag);
  79        if (!pool)
  80                return;
  81        gen_pool_free(pool->pool, addr, len);
  82}
  83
  84/**
  85 * tcm_lookup_tag - find the tag matching an address
  86 * @p: memory address to lookup the tag for
  87 *
  88 * Find the tag of the tcm memory region that contains the
  89 * specified address. Returns %TCM_INVALID_TAG if no such
  90 * memory region could be found.
  91 */
  92unsigned int tcm_lookup_tag(unsigned long p)
  93{
  94        struct list_head *lh;
  95        struct tcm_pool *pool;
  96        unsigned long addr = (unsigned long) p;
  97
  98        list_for_each(lh, &pool_list) {
  99                pool = list_entry(lh, struct tcm_pool, list);
 100                if (addr >= pool->start && addr < pool->end)
 101                        return pool->tag;
 102        }
 103
 104        return TCM_INVALID_TAG;
 105}
 106
 107/**
 108 * tcm_add_region - add a memory region to TCM pool list
 109 * @reg: descriptor of region to be added
 110 *
 111 * Add a region of memory to the TCM pool list. Returns 0 on success.
 112 */
 113int __init tcm_add_region(struct tcm_region *reg)
 114{
 115        struct tcm_pool *pool;
 116
 117        pool = kmalloc(sizeof(*pool), GFP_KERNEL);
 118        if (!pool) {
 119                pr_err("Failed to alloc memory for TCM pool!\n");
 120                return -ENOMEM;
 121        }
 122
 123        pool->tag = reg->tag;
 124        pool->start = reg->res.start;
 125        pool->end = reg->res.end;
 126
 127        /*
 128         * 2^3 = 8 bytes granularity to allow for 64bit access alignment.
 129         * -1 = NUMA node specifier.
 130         */
 131        pool->pool = gen_pool_create(3, -1);
 132
 133        if (!pool->pool) {
 134                pr_err("Failed to create TCM pool!\n");
 135                kfree(pool);
 136                return -ENOMEM;
 137        }
 138
 139        if (gen_pool_add(pool->pool, reg->res.start,
 140                         reg->res.end - reg->res.start + 1, -1)) {
 141                pr_err("Failed to add memory to TCM pool!\n");
 142                return -ENOMEM;
 143        }
 144        pr_info("Added %s TCM pool (%08x bytes @ %08x)\n",
 145                reg->res.name, reg->res.end - reg->res.start + 1,
 146                reg->res.start);
 147
 148        list_add_tail(&pool->list, &pool_list);
 149
 150        return 0;
 151}
 152