Logo Search packages:      
Sourcecode: linux version File versions  Download package

blackfin_sram.c

/*
 * File:         arch/blackfin/mm/blackfin_sram.c
 * Based on:
 * Author:
 *
 * Created:
 * Description:  SRAM driver for Blackfin ADSP-BF5xx
 *
 * Modified:
 *               Copyright 2004-2007 Analog Devices Inc.
 *
 * Bugs:         Enter bugs at http://blackfin.uclinux.org/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see the file COPYING, or write
 * to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/ioport.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/rtc.h>
#include <asm/blackfin.h>
#include "blackfin_sram.h"

spinlock_t l1sram_lock, l1_data_sram_lock, l1_inst_sram_lock;

#if CONFIG_L1_MAX_PIECE < 16
#undef CONFIG_L1_MAX_PIECE
#define CONFIG_L1_MAX_PIECE        16
#endif

#if CONFIG_L1_MAX_PIECE > 1024
#undef CONFIG_L1_MAX_PIECE
#define CONFIG_L1_MAX_PIECE        1024
#endif

#define SRAM_SLT_NULL      0
#define SRAM_SLT_FREE      1
#define SRAM_SLT_ALLOCATED 2

/* the data structure for L1 scratchpad and DATA SRAM */
struct l1_sram_piece {
      void *paddr;
      int size;
      int flag;
      pid_t pid;
};

static struct l1_sram_piece l1_ssram[CONFIG_L1_MAX_PIECE];

#if L1_DATA_A_LENGTH != 0
static struct l1_sram_piece l1_data_A_sram[CONFIG_L1_MAX_PIECE];
#endif

#if L1_DATA_B_LENGTH != 0
static struct l1_sram_piece l1_data_B_sram[CONFIG_L1_MAX_PIECE];
#endif

#if L1_CODE_LENGTH != 0
static struct l1_sram_piece l1_inst_sram[CONFIG_L1_MAX_PIECE];
#endif

/* L1 Scratchpad SRAM initialization function */
void __init l1sram_init(void)
{
      printk(KERN_INFO "Blackfin Scratchpad data SRAM: %d KB\n",
             L1_SCRATCH_LENGTH >> 10);

      memset(&l1_ssram, 0x00, sizeof(l1_ssram));
      l1_ssram[0].paddr = (void *)L1_SCRATCH_START;
      l1_ssram[0].size = L1_SCRATCH_LENGTH;
      l1_ssram[0].flag = SRAM_SLT_FREE;

      /* mutex initialize */
      spin_lock_init(&l1sram_lock);
}

void __init l1_data_sram_init(void)
{
#if L1_DATA_A_LENGTH != 0
      memset(&l1_data_A_sram, 0x00, sizeof(l1_data_A_sram));
      l1_data_A_sram[0].paddr = (void *)L1_DATA_A_START +
                              (_ebss_l1 - _sdata_l1);
      l1_data_A_sram[0].size = L1_DATA_A_LENGTH - (_ebss_l1 - _sdata_l1);
      l1_data_A_sram[0].flag = SRAM_SLT_FREE;

      printk(KERN_INFO "Blackfin Data A SRAM: %d KB (%d KB free)\n",
             L1_DATA_A_LENGTH >> 10, l1_data_A_sram[0].size >> 10);
#endif
#if L1_DATA_B_LENGTH != 0
      memset(&l1_data_B_sram, 0x00, sizeof(l1_data_B_sram));
      l1_data_B_sram[0].paddr = (void *)L1_DATA_B_START +
                        (_ebss_b_l1 - _sdata_b_l1);
      l1_data_B_sram[0].size = L1_DATA_B_LENGTH - (_ebss_b_l1 - _sdata_b_l1);
      l1_data_B_sram[0].flag = SRAM_SLT_FREE;

      printk(KERN_INFO "Blackfin Data B SRAM: %d KB (%d KB free)\n",
             L1_DATA_B_LENGTH >> 10, l1_data_B_sram[0].size >> 10);
#endif

      /* mutex initialize */
      spin_lock_init(&l1_data_sram_lock);
}

void __init l1_inst_sram_init(void)
{
#if L1_CODE_LENGTH != 0
      memset(&l1_inst_sram, 0x00, sizeof(l1_inst_sram));
      l1_inst_sram[0].paddr = (void *)L1_CODE_START + (_etext_l1 - _stext_l1);
      l1_inst_sram[0].size = L1_CODE_LENGTH - (_etext_l1 - _stext_l1);
      l1_inst_sram[0].flag = SRAM_SLT_FREE;

      printk(KERN_INFO "Blackfin Instruction SRAM: %d KB (%d KB free)\n",
             L1_CODE_LENGTH >> 10, l1_inst_sram[0].size >> 10);
#endif

      /* mutex initialize */
      spin_lock_init(&l1_inst_sram_lock);
}

/* L1 memory allocate function */
static void *_l1_sram_alloc(size_t size, struct l1_sram_piece *pfree, int count)
{
      int i, index = 0;
      void *addr = NULL;

      if (size <= 0)
            return NULL;

      /* Align the size */
      size = (size + 3) & ~3;

      /* not use the good method to match the best slot !!! */
      /* search an available memory slot */
      for (i = 0; i < count; i++) {
            if ((pfree[i].flag == SRAM_SLT_FREE)
                && (pfree[i].size >= size)) {
                  addr = pfree[i].paddr;
                  pfree[i].flag = SRAM_SLT_ALLOCATED;
                  pfree[i].pid = current->pid;
                  index = i;
                  break;
            }
      }
      if (i >= count)
            return NULL;

      /* updated the NULL memory slot !!! */
      if (pfree[i].size > size) {
            for (i = 0; i < count; i++) {
                  if (pfree[i].flag == SRAM_SLT_NULL) {
                        pfree[i].pid = 0;
                        pfree[i].flag = SRAM_SLT_FREE;
                        pfree[i].paddr = addr + size;
                        pfree[i].size = pfree[index].size - size;
                        pfree[index].size = size;
                        break;
                  }
            }
      }

      return addr;
}

/* Allocate the largest available block.  */
static void *_l1_sram_alloc_max(struct l1_sram_piece *pfree, int count,
                        unsigned long *psize)
{
      unsigned long best = 0;
      int i, index = -1;
      void *addr = NULL;

      /* search an available memory slot */
      for (i = 0; i < count; i++) {
            if (pfree[i].flag == SRAM_SLT_FREE && pfree[i].size > best) {
                  addr = pfree[i].paddr;
                  index = i;
                  best = pfree[i].size;
            }
      }
      if (index < 0)
            return NULL;
      *psize = best;

      pfree[index].pid = current->pid;
      pfree[index].flag = SRAM_SLT_ALLOCATED;
      return addr;
}

/* L1 memory free function */
static int _l1_sram_free(const void *addr,
                  struct l1_sram_piece *pfree,
                  int count)
{
      int i, index = 0;

      /* search the relevant memory slot */
      for (i = 0; i < count; i++) {
            if (pfree[i].paddr == addr) {
                  if (pfree[i].flag != SRAM_SLT_ALLOCATED) {
                        /* error log */
                        return -1;
                  }
                  index = i;
                  break;
            }
      }
      if (i >= count)
            return -1;

      pfree[index].pid = 0;
      pfree[index].flag = SRAM_SLT_FREE;

      /* link the next address slot */
      for (i = 0; i < count; i++) {
            if (((pfree[index].paddr + pfree[index].size) == pfree[i].paddr)
                && (pfree[i].flag == SRAM_SLT_FREE)) {
                  pfree[i].pid = 0;
                  pfree[i].flag = SRAM_SLT_NULL;
                  pfree[index].size += pfree[i].size;
                  pfree[index].flag = SRAM_SLT_FREE;
                  break;
            }
      }

      /* link the last address slot */
      for (i = 0; i < count; i++) {
            if (((pfree[i].paddr + pfree[i].size) == pfree[index].paddr) &&
                (pfree[i].flag == SRAM_SLT_FREE)) {
                  pfree[index].flag = SRAM_SLT_NULL;
                  pfree[i].size += pfree[index].size;
                  break;
            }
      }

      return 0;
}

int sram_free(const void *addr)
{
      if (0) {}
#if L1_CODE_LENGTH != 0
      else if (addr >= (void *)L1_CODE_START
             && addr < (void *)(L1_CODE_START + L1_CODE_LENGTH))
            return l1_inst_sram_free(addr);
#endif
#if L1_DATA_A_LENGTH != 0
      else if (addr >= (void *)L1_DATA_A_START
             && addr < (void *)(L1_DATA_A_START + L1_DATA_A_LENGTH))
            return l1_data_A_sram_free(addr);
#endif
#if L1_DATA_B_LENGTH != 0
      else if (addr >= (void *)L1_DATA_B_START
             && addr < (void *)(L1_DATA_B_START + L1_DATA_B_LENGTH))
            return l1_data_B_sram_free(addr);
#endif
      else
            return -1;
}
EXPORT_SYMBOL(sram_free);

void *l1_data_A_sram_alloc(size_t size)
{
      unsigned flags;
      void *addr = NULL;

      /* add mutex operation */
      spin_lock_irqsave(&l1_data_sram_lock, flags);

#if L1_DATA_A_LENGTH != 0
      addr = _l1_sram_alloc(size, l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));
#endif

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_data_sram_lock, flags);

      pr_debug("Allocated address in l1_data_A_sram_alloc is 0x%lx+0x%lx\n",
             (long unsigned int)addr, size);

      return addr;
}
EXPORT_SYMBOL(l1_data_A_sram_alloc);

int l1_data_A_sram_free(const void *addr)
{
      unsigned flags;
      int ret;

      /* add mutex operation */
      spin_lock_irqsave(&l1_data_sram_lock, flags);

#if L1_DATA_A_LENGTH != 0
      ret = _l1_sram_free(addr,
                     l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));
#else
      ret = -1;
#endif

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_data_sram_lock, flags);

      return ret;
}
EXPORT_SYMBOL(l1_data_A_sram_free);

void *l1_data_B_sram_alloc(size_t size)
{
#if L1_DATA_B_LENGTH != 0
      unsigned flags;
      void *addr;

      /* add mutex operation */
      spin_lock_irqsave(&l1_data_sram_lock, flags);

      addr = _l1_sram_alloc(size, l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_data_sram_lock, flags);

      pr_debug("Allocated address in l1_data_B_sram_alloc is 0x%lx+0x%lx\n",
             (long unsigned int)addr, size);

      return addr;
#else
      return NULL;
#endif
}
EXPORT_SYMBOL(l1_data_B_sram_alloc);

int l1_data_B_sram_free(const void *addr)
{
#if L1_DATA_B_LENGTH != 0
      unsigned flags;
      int ret;

      /* add mutex operation */
      spin_lock_irqsave(&l1_data_sram_lock, flags);

      ret = _l1_sram_free(addr, l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_data_sram_lock, flags);

      return ret;
#else
      return -1;
#endif
}
EXPORT_SYMBOL(l1_data_B_sram_free);

void *l1_data_sram_alloc(size_t size)
{
      void *addr = l1_data_A_sram_alloc(size);

      if (!addr)
            addr = l1_data_B_sram_alloc(size);

      return addr;
}
EXPORT_SYMBOL(l1_data_sram_alloc);

void *l1_data_sram_zalloc(size_t size)
{
      void *addr = l1_data_sram_alloc(size);

      if (addr)
            memset(addr, 0x00, size);

      return addr;
}
EXPORT_SYMBOL(l1_data_sram_zalloc);

int l1_data_sram_free(const void *addr)
{
      int ret;
      ret = l1_data_A_sram_free(addr);
      if (ret == -1)
            ret = l1_data_B_sram_free(addr);
      return ret;
}
EXPORT_SYMBOL(l1_data_sram_free);

void *l1_inst_sram_alloc(size_t size)
{
#if L1_DATA_A_LENGTH != 0
      unsigned flags;
      void *addr;

      /* add mutex operation */
      spin_lock_irqsave(&l1_inst_sram_lock, flags);

      addr = _l1_sram_alloc(size, l1_inst_sram, ARRAY_SIZE(l1_inst_sram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_inst_sram_lock, flags);

      pr_debug("Allocated address in l1_inst_sram_alloc is 0x%lx+0x%lx\n",
             (long unsigned int)addr, size);

      return addr;
#else
      return NULL;
#endif
}
EXPORT_SYMBOL(l1_inst_sram_alloc);

int l1_inst_sram_free(const void *addr)
{
#if L1_CODE_LENGTH != 0
      unsigned flags;
      int ret;

      /* add mutex operation */
      spin_lock_irqsave(&l1_inst_sram_lock, flags);

      ret = _l1_sram_free(addr, l1_inst_sram, ARRAY_SIZE(l1_inst_sram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1_inst_sram_lock, flags);

      return ret;
#else
      return -1;
#endif
}
EXPORT_SYMBOL(l1_inst_sram_free);

/* L1 Scratchpad memory allocate function */
void *l1sram_alloc(size_t size)
{
      unsigned flags;
      void *addr;

      /* add mutex operation */
      spin_lock_irqsave(&l1sram_lock, flags);

      addr = _l1_sram_alloc(size, l1_ssram, ARRAY_SIZE(l1_ssram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1sram_lock, flags);

      return addr;
}

/* L1 Scratchpad memory allocate function */
void *l1sram_alloc_max(size_t *psize)
{
      unsigned flags;
      void *addr;

      /* add mutex operation */
      spin_lock_irqsave(&l1sram_lock, flags);

      addr = _l1_sram_alloc_max(l1_ssram, ARRAY_SIZE(l1_ssram), psize);

      /* add mutex operation */
      spin_unlock_irqrestore(&l1sram_lock, flags);

      return addr;
}

/* L1 Scratchpad memory free function */
int l1sram_free(const void *addr)
{
      unsigned flags;
      int ret;

      /* add mutex operation */
      spin_lock_irqsave(&l1sram_lock, flags);

      ret = _l1_sram_free(addr, l1_ssram, ARRAY_SIZE(l1_ssram));

      /* add mutex operation */
      spin_unlock_irqrestore(&l1sram_lock, flags);

      return ret;
}

int sram_free_with_lsl(const void *addr)
{
      struct sram_list_struct *lsl, **tmp;
      struct mm_struct *mm = current->mm;

      for (tmp = &mm->context.sram_list; *tmp; tmp = &(*tmp)->next)
            if ((*tmp)->addr == addr)
                  goto found;
      return -1;
found:
      lsl = *tmp;
      sram_free(addr);
      *tmp = lsl->next;
      kfree(lsl);

      return 0;
}
EXPORT_SYMBOL(sram_free_with_lsl);

void *sram_alloc_with_lsl(size_t size, unsigned long flags)
{
      void *addr = NULL;
      struct sram_list_struct *lsl = NULL;
      struct mm_struct *mm = current->mm;

      lsl = kzalloc(sizeof(struct sram_list_struct), GFP_KERNEL);
      if (!lsl)
            return NULL;

      if (flags & L1_INST_SRAM)
            addr = l1_inst_sram_alloc(size);

      if (addr == NULL && (flags & L1_DATA_A_SRAM))
            addr = l1_data_A_sram_alloc(size);

      if (addr == NULL && (flags & L1_DATA_B_SRAM))
            addr = l1_data_B_sram_alloc(size);

      if (addr == NULL) {
            kfree(lsl);
            return NULL;
      }
      lsl->addr = addr;
      lsl->length = size;
      lsl->next = mm->context.sram_list;
      mm->context.sram_list = lsl;
      return addr;
}
EXPORT_SYMBOL(sram_alloc_with_lsl);

#ifdef CONFIG_PROC_FS
/* Once we get a real allocator, we'll throw all of this away.
 * Until then, we need some sort of visibility into the L1 alloc.
 */
static void _l1sram_proc_read(char *buf, int *len, const char *desc,
            struct l1_sram_piece *pfree, const int array_size)
{
      int i;

      *len += sprintf(&buf[*len], "--- L1 %-14s Size  PID State\n", desc);
      for (i = 0; i < array_size; ++i) {
            const char *alloc_type;
            switch (pfree[i].flag) {
            case SRAM_SLT_NULL:      alloc_type = "NULL"; break;
            case SRAM_SLT_FREE:      alloc_type = "FREE"; break;
            case SRAM_SLT_ALLOCATED: alloc_type = "ALLOCATED"; break;
            default:                 alloc_type = "????"; break;
            }
            *len += sprintf(&buf[*len], "%p-%p %8i %4i %s\n",
                  pfree[i].paddr, pfree[i].paddr + pfree[i].size,
                  pfree[i].size, pfree[i].pid, alloc_type);
      }
}
static int l1sram_proc_read(char *buf, char **start, off_t offset, int count,
            int *eof, void *data)
{
      int len = 0;

      _l1sram_proc_read(buf, &len, "Scratchpad",
                  l1_ssram, ARRAY_SIZE(l1_ssram));
#if L1_DATA_A_LENGTH != 0
      _l1sram_proc_read(buf, &len, "Data A",
                  l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));
#endif
#if L1_DATA_B_LENGTH != 0
      _l1sram_proc_read(buf, &len, "Data B",
                  l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));
#endif
#if L1_CODE_LENGTH != 0
      _l1sram_proc_read(buf, &len, "Instruction",
                  l1_inst_sram, ARRAY_SIZE(l1_inst_sram));
#endif

      return len;
}

static int __init l1sram_proc_init(void)
{
      struct proc_dir_entry *ptr;
      ptr = create_proc_entry("sram", S_IFREG | S_IRUGO, NULL);
      if (!ptr) {
            printk(KERN_WARNING "unable to create /proc/sram\n");
            return -1;
      }
      ptr->owner = THIS_MODULE;
      ptr->read_proc = l1sram_proc_read;
      return 0;
}
late_initcall(l1sram_proc_init);
#endif

Generated by  Doxygen 1.6.0   Back to index