URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [blackfin/] [mm/] [blackfin_sram.c] - Blame information for rev 17

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * 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

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [blackfin/] [mm/] [blackfin_sram.c] - Blame information for rev 17

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* File: arch/blackfin/mm/blackfin_sram.c`
3			`* Based on:`
4			`* Author:`
5			`*`
6			`* Created:`
7			`* Description: SRAM driver for Blackfin ADSP-BF5xx`
8			`*`
9			`* Modified:`
10			`* Copyright 2004-2007 Analog Devices Inc.`
11			`*`
12			`* Bugs: Enter bugs at http://blackfin.uclinux.org/`
13			`*`
14			`* This program is free software; you can redistribute it and/or modify`
15			`* it under the terms of the GNU General Public License as published by`
16			`* the Free Software Foundation; either version 2 of the License, or`
17			`* (at your option) any later version.`
18			`*`
19			`* This program is distributed in the hope that it will be useful,`
20			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
21			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
22			`* GNU General Public License for more details.`
23			`*`
24			`* You should have received a copy of the GNU General Public License`
25			`* along with this program; if not, see the file COPYING, or write`
26			`* to the Free Software Foundation, Inc.,`
27			`* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA`
28			`*/`
29
30			`#include <linux/module.h>`
31			`#include <linux/kernel.h>`
32			`#include <linux/types.h>`
33			`#include <linux/miscdevice.h>`
34			`#include <linux/ioport.h>`
35			`#include <linux/fcntl.h>`
36			`#include <linux/init.h>`
37			`#include <linux/poll.h>`
38			`#include <linux/proc_fs.h>`
39			`#include <linux/spinlock.h>`
40			`#include <linux/rtc.h>`
41			`#include <asm/blackfin.h>`
42			`#include "blackfin_sram.h"`
43
44			`spinlock_t l1sram_lock, l1_data_sram_lock, l1_inst_sram_lock;`
45
46			`#if CONFIG_L1_MAX_PIECE < 16`
47			`#undef CONFIG_L1_MAX_PIECE`
48			`#define CONFIG_L1_MAX_PIECE 16`
49			`#endif`
50
51			`#if CONFIG_L1_MAX_PIECE > 1024`
52			`#undef CONFIG_L1_MAX_PIECE`
53			`#define CONFIG_L1_MAX_PIECE 1024`
54			`#endif`
55
56			`#define SRAM_SLT_NULL 0`
57			`#define SRAM_SLT_FREE 1`
58			`#define SRAM_SLT_ALLOCATED 2`
59
60			`/* the data structure for L1 scratchpad and DATA SRAM */`
61			`struct l1_sram_piece {`
62			`void *paddr;`
63			`int size;`
64			`int flag;`
65			`pid_t pid;`
66			`};`
67
68			`static struct l1_sram_piece l1_ssram[CONFIG_L1_MAX_PIECE];`
69
70			`#if L1_DATA_A_LENGTH != 0`
71			`static struct l1_sram_piece l1_data_A_sram[CONFIG_L1_MAX_PIECE];`
72			`#endif`
73
74			`#if L1_DATA_B_LENGTH != 0`
75			`static struct l1_sram_piece l1_data_B_sram[CONFIG_L1_MAX_PIECE];`
76			`#endif`
77
78			`#if L1_CODE_LENGTH != 0`
79			`static struct l1_sram_piece l1_inst_sram[CONFIG_L1_MAX_PIECE];`
80			`#endif`
81
82			`/* L1 Scratchpad SRAM initialization function */`
83			`void __init l1sram_init(void)`
84			`{`
85			`printk(KERN_INFO "Blackfin Scratchpad data SRAM: %d KB\n",`
86			`L1_SCRATCH_LENGTH >> 10);`
87
88			`memset(&l1_ssram, 0x00, sizeof(l1_ssram));`
89			`l1_ssram[0].paddr = (void *)L1_SCRATCH_START;`
90			`l1_ssram[0].size = L1_SCRATCH_LENGTH;`
91			`l1_ssram[0].flag = SRAM_SLT_FREE;`
92
93			`/* mutex initialize */`
94			`spin_lock_init(&l1sram_lock);`
95			`}`
96
97			`void __init l1_data_sram_init(void)`
98			`{`
99			`#if L1_DATA_A_LENGTH != 0`
100			`memset(&l1_data_A_sram, 0x00, sizeof(l1_data_A_sram));`
101			`l1_data_A_sram[0].paddr = (void *)L1_DATA_A_START +`
102			`(_ebss_l1 - _sdata_l1);`
103			`l1_data_A_sram[0].size = L1_DATA_A_LENGTH - (_ebss_l1 - _sdata_l1);`
104			`l1_data_A_sram[0].flag = SRAM_SLT_FREE;`
105
106			`printk(KERN_INFO "Blackfin Data A SRAM: %d KB (%d KB free)\n",`
107			`L1_DATA_A_LENGTH >> 10, l1_data_A_sram[0].size >> 10);`
108			`#endif`
109			`#if L1_DATA_B_LENGTH != 0`
110			`memset(&l1_data_B_sram, 0x00, sizeof(l1_data_B_sram));`
111			`l1_data_B_sram[0].paddr = (void *)L1_DATA_B_START +`
112			`(_ebss_b_l1 - _sdata_b_l1);`
113			`l1_data_B_sram[0].size = L1_DATA_B_LENGTH - (_ebss_b_l1 - _sdata_b_l1);`
114			`l1_data_B_sram[0].flag = SRAM_SLT_FREE;`
115
116			`printk(KERN_INFO "Blackfin Data B SRAM: %d KB (%d KB free)\n",`
117			`L1_DATA_B_LENGTH >> 10, l1_data_B_sram[0].size >> 10);`
118			`#endif`
119
120			`/* mutex initialize */`
121			`spin_lock_init(&l1_data_sram_lock);`
122			`}`
123
124			`void __init l1_inst_sram_init(void)`
125			`{`
126			`#if L1_CODE_LENGTH != 0`
127			`memset(&l1_inst_sram, 0x00, sizeof(l1_inst_sram));`
128			`l1_inst_sram[0].paddr = (void *)L1_CODE_START + (_etext_l1 - _stext_l1);`
129			`l1_inst_sram[0].size = L1_CODE_LENGTH - (_etext_l1 - _stext_l1);`
130			`l1_inst_sram[0].flag = SRAM_SLT_FREE;`
131
132			`printk(KERN_INFO "Blackfin Instruction SRAM: %d KB (%d KB free)\n",`
133			`L1_CODE_LENGTH >> 10, l1_inst_sram[0].size >> 10);`
134			`#endif`
135
136			`/* mutex initialize */`
137			`spin_lock_init(&l1_inst_sram_lock);`
138			`}`
139
140			`/* L1 memory allocate function */`
141			`static void _l1_sram_alloc(size_t size, struct l1_sram_piece pfree, int count)`
142			`{`
143			`int i, index = 0;`
144			`void *addr = NULL;`
145
146			`if (size <= 0)`
147			`return NULL;`
148
149			`/* Align the size */`
150			`size = (size + 3) & ~3;`
151
152			`/* not use the good method to match the best slot !!! */`
153			`/* search an available memory slot */`
154			`for (i = 0; i < count; i++) {`
155			`if ((pfree[i].flag == SRAM_SLT_FREE)`
156			`&& (pfree[i].size >= size)) {`
157			`addr = pfree[i].paddr;`
158			`pfree[i].flag = SRAM_SLT_ALLOCATED;`
159			`pfree[i].pid = current->pid;`
160			`index = i;`
161			`break;`
162			`}`
163			`}`
164			`if (i >= count)`
165			`return NULL;`
166
167			`/* updated the NULL memory slot !!! */`
168			`if (pfree[i].size > size) {`
169			`for (i = 0; i < count; i++) {`
170			`if (pfree[i].flag == SRAM_SLT_NULL) {`
171			`pfree[i].pid = 0;`
172			`pfree[i].flag = SRAM_SLT_FREE;`
173			`pfree[i].paddr = addr + size;`
174			`pfree[i].size = pfree[index].size - size;`
175			`pfree[index].size = size;`
176			`break;`
177			`}`
178			`}`
179			`}`
180
181			`return addr;`
182			`}`
183
184			`/* Allocate the largest available block. */`
185			`static void _l1_sram_alloc_max(struct l1_sram_piece pfree, int count,`
186			`unsigned long *psize)`
187			`{`
188			`unsigned long best = 0;`
189			`int i, index = -1;`
190			`void *addr = NULL;`
191
192			`/* search an available memory slot */`
193			`for (i = 0; i < count; i++) {`
194			`if (pfree[i].flag == SRAM_SLT_FREE && pfree[i].size > best) {`
195			`addr = pfree[i].paddr;`
196			`index = i;`
197			`best = pfree[i].size;`
198			`}`
199			`}`
200			`if (index < 0)`
201			`return NULL;`
202			`*psize = best;`
203
204			`pfree[index].pid = current->pid;`
205			`pfree[index].flag = SRAM_SLT_ALLOCATED;`
206			`return addr;`
207			`}`
208
209			`/* L1 memory free function */`
210			`static int _l1_sram_free(const void *addr,`
211			`struct l1_sram_piece *pfree,`
212			`int count)`
213			`{`
214			`int i, index = 0;`
215
216			`/* search the relevant memory slot */`
217			`for (i = 0; i < count; i++) {`
218			`if (pfree[i].paddr == addr) {`
219			`if (pfree[i].flag != SRAM_SLT_ALLOCATED) {`
220			`/* error log */`
221			`return -1;`
222			`}`
223			`index = i;`
224			`break;`
225			`}`
226			`}`
227			`if (i >= count)`
228			`return -1;`
229
230			`pfree[index].pid = 0;`
231			`pfree[index].flag = SRAM_SLT_FREE;`
232
233			`/* link the next address slot */`
234			`for (i = 0; i < count; i++) {`
235			`if (((pfree[index].paddr + pfree[index].size) == pfree[i].paddr)`
236			`&& (pfree[i].flag == SRAM_SLT_FREE)) {`
237			`pfree[i].pid = 0;`
238			`pfree[i].flag = SRAM_SLT_NULL;`
239			`pfree[index].size += pfree[i].size;`
240			`pfree[index].flag = SRAM_SLT_FREE;`
241			`break;`
242			`}`
243			`}`
244
245			`/* link the last address slot */`
246			`for (i = 0; i < count; i++) {`
247			`if (((pfree[i].paddr + pfree[i].size) == pfree[index].paddr) &&`
248			`(pfree[i].flag == SRAM_SLT_FREE)) {`
249			`pfree[index].flag = SRAM_SLT_NULL;`
250			`pfree[i].size += pfree[index].size;`
251			`break;`
252			`}`
253			`}`
254
255			`return 0;`
256			`}`
257
258			`int sram_free(const void *addr)`
259			`{`
260			`if (0) {}`
261			`#if L1_CODE_LENGTH != 0`
262			`else if (addr >= (void *)L1_CODE_START`
263			`&& addr < (void *)(L1_CODE_START + L1_CODE_LENGTH))`
264			`return l1_inst_sram_free(addr);`
265			`#endif`
266			`#if L1_DATA_A_LENGTH != 0`
267			`else if (addr >= (void *)L1_DATA_A_START`
268			`&& addr < (void *)(L1_DATA_A_START + L1_DATA_A_LENGTH))`
269			`return l1_data_A_sram_free(addr);`
270			`#endif`
271			`#if L1_DATA_B_LENGTH != 0`
272			`else if (addr >= (void *)L1_DATA_B_START`
273			`&& addr < (void *)(L1_DATA_B_START + L1_DATA_B_LENGTH))`
274			`return l1_data_B_sram_free(addr);`
275			`#endif`
276			`else`
277			`return -1;`
278			`}`
279			`EXPORT_SYMBOL(sram_free);`
280
281			`void *l1_data_A_sram_alloc(size_t size)`
282			`{`
283			`unsigned flags;`
284			`void *addr = NULL;`
285
286			`/* add mutex operation */`
287			`spin_lock_irqsave(&l1_data_sram_lock, flags);`
288
289			`#if L1_DATA_A_LENGTH != 0`
290			`addr = _l1_sram_alloc(size, l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));`
291			`#endif`
292
293			`/* add mutex operation */`
294			`spin_unlock_irqrestore(&l1_data_sram_lock, flags);`
295
296			`pr_debug("Allocated address in l1_data_A_sram_alloc is 0x%lx+0x%lx\n",`
297			`(long unsigned int)addr, size);`
298
299			`return addr;`
300			`}`
301			`EXPORT_SYMBOL(l1_data_A_sram_alloc);`
302
303			`int l1_data_A_sram_free(const void *addr)`
304			`{`
305			`unsigned flags;`
306			`int ret;`
307
308			`/* add mutex operation */`
309			`spin_lock_irqsave(&l1_data_sram_lock, flags);`
310
311			`#if L1_DATA_A_LENGTH != 0`
312			`ret = _l1_sram_free(addr,`
313			`l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));`
314			`#else`
315			`ret = -1;`
316			`#endif`
317
318			`/* add mutex operation */`
319			`spin_unlock_irqrestore(&l1_data_sram_lock, flags);`
320
321			`return ret;`
322			`}`
323			`EXPORT_SYMBOL(l1_data_A_sram_free);`
324
325			`void *l1_data_B_sram_alloc(size_t size)`
326			`{`
327			`#if L1_DATA_B_LENGTH != 0`
328			`unsigned flags;`
329			`void *addr;`
330
331			`/* add mutex operation */`
332			`spin_lock_irqsave(&l1_data_sram_lock, flags);`
333
334			`addr = _l1_sram_alloc(size, l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));`
335
336			`/* add mutex operation */`
337			`spin_unlock_irqrestore(&l1_data_sram_lock, flags);`
338
339			`pr_debug("Allocated address in l1_data_B_sram_alloc is 0x%lx+0x%lx\n",`
340			`(long unsigned int)addr, size);`
341
342			`return addr;`
343			`#else`
344			`return NULL;`
345			`#endif`
346			`}`
347			`EXPORT_SYMBOL(l1_data_B_sram_alloc);`
348
349			`int l1_data_B_sram_free(const void *addr)`
350			`{`
351			`#if L1_DATA_B_LENGTH != 0`
352			`unsigned flags;`
353			`int ret;`
354
355			`/* add mutex operation */`
356			`spin_lock_irqsave(&l1_data_sram_lock, flags);`
357
358			`ret = _l1_sram_free(addr, l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));`
359
360			`/* add mutex operation */`
361			`spin_unlock_irqrestore(&l1_data_sram_lock, flags);`
362
363			`return ret;`
364			`#else`
365			`return -1;`
366			`#endif`
367			`}`
368			`EXPORT_SYMBOL(l1_data_B_sram_free);`
369
370			`void *l1_data_sram_alloc(size_t size)`
371			`{`
372			`void *addr = l1_data_A_sram_alloc(size);`
373
374			`if (!addr)`
375			`addr = l1_data_B_sram_alloc(size);`
376
377			`return addr;`
378			`}`
379			`EXPORT_SYMBOL(l1_data_sram_alloc);`
380
381			`void *l1_data_sram_zalloc(size_t size)`
382			`{`
383			`void *addr = l1_data_sram_alloc(size);`
384
385			`if (addr)`
386			`memset(addr, 0x00, size);`
387
388			`return addr;`
389			`}`
390			`EXPORT_SYMBOL(l1_data_sram_zalloc);`
391
392			`int l1_data_sram_free(const void *addr)`
393			`{`
394			`int ret;`
395			`ret = l1_data_A_sram_free(addr);`
396			`if (ret == -1)`
397			`ret = l1_data_B_sram_free(addr);`
398			`return ret;`
399			`}`
400			`EXPORT_SYMBOL(l1_data_sram_free);`
401
402			`void *l1_inst_sram_alloc(size_t size)`
403			`{`
404			`#if L1_DATA_A_LENGTH != 0`
405			`unsigned flags;`
406			`void *addr;`
407
408			`/* add mutex operation */`
409			`spin_lock_irqsave(&l1_inst_sram_lock, flags);`
410
411			`addr = _l1_sram_alloc(size, l1_inst_sram, ARRAY_SIZE(l1_inst_sram));`
412
413			`/* add mutex operation */`
414			`spin_unlock_irqrestore(&l1_inst_sram_lock, flags);`
415
416			`pr_debug("Allocated address in l1_inst_sram_alloc is 0x%lx+0x%lx\n",`
417			`(long unsigned int)addr, size);`
418
419			`return addr;`
420			`#else`
421			`return NULL;`
422			`#endif`
423			`}`
424			`EXPORT_SYMBOL(l1_inst_sram_alloc);`
425
426			`int l1_inst_sram_free(const void *addr)`
427			`{`
428			`#if L1_CODE_LENGTH != 0`
429			`unsigned flags;`
430			`int ret;`
431
432			`/* add mutex operation */`
433			`spin_lock_irqsave(&l1_inst_sram_lock, flags);`
434
435			`ret = _l1_sram_free(addr, l1_inst_sram, ARRAY_SIZE(l1_inst_sram));`
436
437			`/* add mutex operation */`
438			`spin_unlock_irqrestore(&l1_inst_sram_lock, flags);`
439
440			`return ret;`
441			`#else`
442			`return -1;`
443			`#endif`
444			`}`
445			`EXPORT_SYMBOL(l1_inst_sram_free);`
446
447			`/* L1 Scratchpad memory allocate function */`
448			`void *l1sram_alloc(size_t size)`
449			`{`
450			`unsigned flags;`
451			`void *addr;`
452
453			`/* add mutex operation */`
454			`spin_lock_irqsave(&l1sram_lock, flags);`
455
456			`addr = _l1_sram_alloc(size, l1_ssram, ARRAY_SIZE(l1_ssram));`
457
458			`/* add mutex operation */`
459			`spin_unlock_irqrestore(&l1sram_lock, flags);`
460
461			`return addr;`
462			`}`
463
464			`/* L1 Scratchpad memory allocate function */`
465			`void l1sram_alloc_max(size_t psize)`
466			`{`
467			`unsigned flags;`
468			`void *addr;`
469
470			`/* add mutex operation */`
471			`spin_lock_irqsave(&l1sram_lock, flags);`
472
473			`addr = _l1_sram_alloc_max(l1_ssram, ARRAY_SIZE(l1_ssram), psize);`
474
475			`/* add mutex operation */`
476			`spin_unlock_irqrestore(&l1sram_lock, flags);`
477
478			`return addr;`
479			`}`
480
481			`/* L1 Scratchpad memory free function */`
482			`int l1sram_free(const void *addr)`
483			`{`
484			`unsigned flags;`
485			`int ret;`
486
487			`/* add mutex operation */`
488			`spin_lock_irqsave(&l1sram_lock, flags);`
489
490			`ret = _l1_sram_free(addr, l1_ssram, ARRAY_SIZE(l1_ssram));`
491
492			`/* add mutex operation */`
493			`spin_unlock_irqrestore(&l1sram_lock, flags);`
494
495			`return ret;`
496			`}`
497
498			`int sram_free_with_lsl(const void *addr)`
499			`{`
500			`struct sram_list_struct lsl, *tmp;`
501			`struct mm_struct *mm = current->mm;`
502
503			`for (tmp = &mm->context.sram_list; tmp; tmp = &(tmp)->next)`
504			`if ((*tmp)->addr == addr)`
505			`goto found;`
506			`return -1;`
507			`found:`
508			`lsl = *tmp;`
509			`sram_free(addr);`
510			`*tmp = lsl->next;`
511			`kfree(lsl);`
512
513			`return 0;`
514			`}`
515			`EXPORT_SYMBOL(sram_free_with_lsl);`
516
517			`void *sram_alloc_with_lsl(size_t size, unsigned long flags)`
518			`{`
519			`void *addr = NULL;`
520			`struct sram_list_struct *lsl = NULL;`
521			`struct mm_struct *mm = current->mm;`
522
523			`lsl = kzalloc(sizeof(struct sram_list_struct), GFP_KERNEL);`
524			`if (!lsl)`
525			`return NULL;`
526
527			`if (flags & L1_INST_SRAM)`
528			`addr = l1_inst_sram_alloc(size);`
529
530			`if (addr == NULL && (flags & L1_DATA_A_SRAM))`
531			`addr = l1_data_A_sram_alloc(size);`
532
533			`if (addr == NULL && (flags & L1_DATA_B_SRAM))`
534			`addr = l1_data_B_sram_alloc(size);`
535
536			`if (addr == NULL) {`
537			`kfree(lsl);`
538			`return NULL;`
539			`}`
540			`lsl->addr = addr;`
541			`lsl->length = size;`
542			`lsl->next = mm->context.sram_list;`
543			`mm->context.sram_list = lsl;`
544			`return addr;`
545			`}`
546			`EXPORT_SYMBOL(sram_alloc_with_lsl);`
547
548			`#ifdef CONFIG_PROC_FS`
549			`/* Once we get a real allocator, we'll throw all of this away.`
550			`* Until then, we need some sort of visibility into the L1 alloc.`
551			`*/`
552			`static void _l1sram_proc_read(char buf, int len, const char *desc,`
553			`struct l1_sram_piece *pfree, const int array_size)`
554			`{`
555			`int i;`
556
557			`len += sprintf(&buf[len], "--- L1 %-14s Size PID State\n", desc);`
558			`for (i = 0; i < array_size; ++i) {`
559			`const char *alloc_type;`
560			`switch (pfree[i].flag) {`
561			`case SRAM_SLT_NULL: alloc_type = "NULL"; break;`
562			`case SRAM_SLT_FREE: alloc_type = "FREE"; break;`
563			`case SRAM_SLT_ALLOCATED: alloc_type = "ALLOCATED"; break;`
564			`default: alloc_type = "????"; break;`
565			`}`
566			`len += sprintf(&buf[len], "%p-%p %8i %4i %s\n",`
567			`pfree[i].paddr, pfree[i].paddr + pfree[i].size,`
568			`pfree[i].size, pfree[i].pid, alloc_type);`
569			`}`
570			`}`
571			`static int l1sram_proc_read(char buf, char *start, off_t offset, int count,`
572			`int eof, void data)`
573			`{`
574			`int len = 0;`
575
576			`_l1sram_proc_read(buf, &len, "Scratchpad",`
577			`l1_ssram, ARRAY_SIZE(l1_ssram));`
578			`#if L1_DATA_A_LENGTH != 0`
579			`_l1sram_proc_read(buf, &len, "Data A",`
580			`l1_data_A_sram, ARRAY_SIZE(l1_data_A_sram));`
581			`#endif`
582			`#if L1_DATA_B_LENGTH != 0`
583			`_l1sram_proc_read(buf, &len, "Data B",`
584			`l1_data_B_sram, ARRAY_SIZE(l1_data_B_sram));`
585			`#endif`
586			`#if L1_CODE_LENGTH != 0`
587			`_l1sram_proc_read(buf, &len, "Instruction",`
588			`l1_inst_sram, ARRAY_SIZE(l1_inst_sram));`
589			`#endif`
590
591			`return len;`
592			`}`
593
594			`static int __init l1sram_proc_init(void)`
595			`{`
596			`struct proc_dir_entry *ptr;`
597			`ptr = create_proc_entry("sram", S_IFREG \| S_IRUGO, NULL);`
598			`if (!ptr) {`
599			`printk(KERN_WARNING "unable to create /proc/sram\n");`
600			`return -1;`
601			`}`
602			`ptr->owner = THIS_MODULE;`
603			`ptr->read_proc = l1sram_proc_read;`
604			`return 0;`
605			`}`
606			`late_initcall(l1sram_proc_init);`
607			`#endif`