Blackfin arch: Extend sram malloc to handle L2 SRAM.
Extend system call to alloc L2 SRAM in application. Automatically move following sections to L2 SRAM: 1. kernel built-in l2 attribute section 2. kernel module l2 attribute section 3. elf-fdpic application l2 attribute section Signed-off-by: Sonic Zhang <sonic.zhang@analog.com> Signed-off-by: Bryan Wu <cooloney@kernel.org>
This commit is contained in:
Sonic Zhang
Bryan Wu
parent
bafcc1b973
commit
262c3825a9
|
|
@ -173,7 +173,7 @@ module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
|
|||
for (s = sechdrs; s < sechdrs_end; ++s) {
|
||||
if ((strcmp(".l1.text", secstrings + s->sh_name) == 0) ||
|
||||
((strcmp(".text", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & FLG_CODE_IN_L1) && (s->sh_size > 0))) {
|
||||
(hdr->e_flags & EF_BFIN_CODE_IN_L1) && (s->sh_size > 0))) {
|
||||
dest = l1_inst_sram_alloc(s->sh_size);
|
||||
mod->arch.text_l1 = dest;
|
||||
if (dest == NULL) {
|
||||
|
|
@ -188,7 +188,7 @@ module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
|
|||
}
|
||||
if ((strcmp(".l1.data", secstrings + s->sh_name) == 0) ||
|
||||
((strcmp(".data", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & FLG_DATA_IN_L1) && (s->sh_size > 0))) {
|
||||
(hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
|
||||
dest = l1_data_sram_alloc(s->sh_size);
|
||||
mod->arch.data_a_l1 = dest;
|
||||
if (dest == NULL) {
|
||||
|
|
@ -203,7 +203,7 @@ module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
|
|||
}
|
||||
if (strcmp(".l1.bss", secstrings + s->sh_name) == 0 ||
|
||||
((strcmp(".bss", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & FLG_DATA_IN_L1) && (s->sh_size > 0))) {
|
||||
(hdr->e_flags & EF_BFIN_DATA_IN_L1) && (s->sh_size > 0))) {
|
||||
dest = l1_data_sram_alloc(s->sh_size);
|
||||
mod->arch.bss_a_l1 = dest;
|
||||
if (dest == NULL) {
|
||||
|
|
@ -242,6 +242,51 @@ module_frob_arch_sections(Elf_Ehdr * hdr, Elf_Shdr * sechdrs,
|
|||
s->sh_flags &= ~SHF_ALLOC;
|
||||
s->sh_addr = (unsigned long)dest;
|
||||
}
|
||||
if ((strcmp(".l2.text", secstrings + s->sh_name) == 0) ||
|
||||
((strcmp(".text", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & EF_BFIN_CODE_IN_L2) && (s->sh_size > 0))) {
|
||||
dest = l2_sram_alloc(s->sh_size);
|
||||
mod->arch.text_l2 = dest;
|
||||
if (dest == NULL) {
|
||||
printk(KERN_ERR
|
||||
"module %s: L2 SRAM allocation failed\n",
|
||||
mod->name);
|
||||
return -1;
|
||||
}
|
||||
memcpy(dest, (void *)s->sh_addr, s->sh_size);
|
||||
s->sh_flags &= ~SHF_ALLOC;
|
||||
s->sh_addr = (unsigned long)dest;
|
||||
}
|
||||
if ((strcmp(".l2.data", secstrings + s->sh_name) == 0) ||
|
||||
((strcmp(".data", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
|
||||
dest = l2_sram_alloc(s->sh_size);
|
||||
mod->arch.data_l2 = dest;
|
||||
if (dest == NULL) {
|
||||
printk(KERN_ERR
|
||||
"module %s: L2 SRAM allocation failed\n",
|
||||
mod->name);
|
||||
return -1;
|
||||
}
|
||||
memcpy(dest, (void *)s->sh_addr, s->sh_size);
|
||||
s->sh_flags &= ~SHF_ALLOC;
|
||||
s->sh_addr = (unsigned long)dest;
|
||||
}
|
||||
if (strcmp(".l2.bss", secstrings + s->sh_name) == 0 ||
|
||||
((strcmp(".bss", secstrings + s->sh_name) == 0) &&
|
||||
(hdr->e_flags & EF_BFIN_DATA_IN_L2) && (s->sh_size > 0))) {
|
||||
dest = l2_sram_alloc(s->sh_size);
|
||||
mod->arch.bss_l2 = dest;
|
||||
if (dest == NULL) {
|
||||
printk(KERN_ERR
|
||||
"module %s: L2 SRAM allocation failed\n",
|
||||
mod->name);
|
||||
return -1;
|
||||
}
|
||||
memset(dest, 0, s->sh_size);
|
||||
s->sh_flags &= ~SHF_ALLOC;
|
||||
s->sh_addr = (unsigned long)dest;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -411,9 +456,10 @@ module_finalize(const Elf_Ehdr * hdr,
|
|||
continue;
|
||||
|
||||
if ((sechdrs[i].sh_type == SHT_RELA) &&
|
||||
((strcmp(".rela.l1.text", secstrings + sechdrs[i].sh_name) == 0) ||
|
||||
((strcmp(".rela.l2.text", secstrings + sechdrs[i].sh_name) == 0) ||
|
||||
(strcmp(".rela.l1.text", secstrings + sechdrs[i].sh_name) == 0) ||
|
||||
((strcmp(".rela.text", secstrings + sechdrs[i].sh_name) == 0) &&
|
||||
(hdr->e_flags & FLG_CODE_IN_L1)))) {
|
||||
(hdr->e_flags & (EF_BFIN_CODE_IN_L1|EF_BFIN_CODE_IN_L2))))) {
|
||||
apply_relocate_add((Elf_Shdr *) sechdrs, strtab,
|
||||
symindex, i, mod);
|
||||
}
|
||||
|
|
@ -423,14 +469,12 @@ module_finalize(const Elf_Ehdr * hdr,
|
|||
|
||||
void module_arch_cleanup(struct module *mod)
|
||||
{
|
||||
if (mod->arch.text_l1)
|
||||
l1_inst_sram_free((void *)mod->arch.text_l1);
|
||||
if (mod->arch.data_a_l1)
|
||||
l1_data_sram_free((void *)mod->arch.data_a_l1);
|
||||
if (mod->arch.bss_a_l1)
|
||||
l1_data_sram_free((void *)mod->arch.bss_a_l1);
|
||||
if (mod->arch.data_b_l1)
|
||||
l1_data_B_sram_free((void *)mod->arch.data_b_l1);
|
||||
if (mod->arch.bss_b_l1)
|
||||
l1_data_B_sram_free((void *)mod->arch.bss_b_l1);
|
||||
l1_inst_sram_free(mod->arch.text_l1);
|
||||
l1_data_A_sram_free(mod->arch.data_a_l1);
|
||||
l1_data_A_sram_free(mod->arch.bss_a_l1);
|
||||
l1_data_B_sram_free(mod->arch.data_b_l1);
|
||||
l1_data_B_sram_free(mod->arch.bss_b_l1);
|
||||
l2_sram_free(mod->arch.text_l2);
|
||||
l2_sram_free(mod->arch.data_l2);
|
||||
l2_sram_free(mod->arch.bss_l2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -104,6 +104,7 @@ void __init bf53x_relocate_l1_mem(void)
|
|||
unsigned long l1_code_length;
|
||||
unsigned long l1_data_a_length;
|
||||
unsigned long l1_data_b_length;
|
||||
unsigned long l2_length;
|
||||
|
||||
l1_code_length = _etext_l1 - _stext_l1;
|
||||
if (l1_code_length > L1_CODE_LENGTH)
|
||||
|
|
@ -129,6 +130,15 @@ void __init bf53x_relocate_l1_mem(void)
|
|||
/* Copy _sdata_b_l1 to _ebss_b_l1 to L1 data bank B SRAM */
|
||||
dma_memcpy(_sdata_b_l1, _l1_lma_start + l1_code_length +
|
||||
l1_data_a_length, l1_data_b_length);
|
||||
|
||||
#ifdef L2_LENGTH
|
||||
l2_length = _ebss_l2 - _stext_l2;
|
||||
if (l2_length > L2_LENGTH)
|
||||
panic("L2 SRAM Overflow\n");
|
||||
|
||||
/* Copy _stext_l2 to _edata_l2 to L2 SRAM */
|
||||
dma_memcpy(_stext_l2, _l2_lma_start, l2_length);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* add_memory_region to memmap */
|
||||
|
|
|
|||
|
|
@ -101,6 +101,11 @@ SECTIONS
|
|||
#if !L1_DATA_B_LENGTH
|
||||
*(.l1.data.B)
|
||||
#endif
|
||||
#ifndef L2_LENGTH
|
||||
. = ALIGN(32);
|
||||
*(.data_l2.cacheline_aligned)
|
||||
*(.l2.data)
|
||||
#endif
|
||||
|
||||
DATA_DATA
|
||||
*(.data.*)
|
||||
|
|
@ -182,13 +187,12 @@ SECTIONS
|
|||
*(.l1.data)
|
||||
__edata_l1 = .;
|
||||
|
||||
. = ALIGN(4);
|
||||
__sbss_l1 = .;
|
||||
*(.l1.bss)
|
||||
|
||||
. = ALIGN(32);
|
||||
*(.data_l1.cacheline_aligned)
|
||||
|
||||
. = ALIGN(4);
|
||||
__sbss_l1 = .;
|
||||
*(.l1.bss)
|
||||
. = ALIGN(4);
|
||||
__ebss_l1 = .;
|
||||
}
|
||||
|
|
@ -203,11 +207,37 @@ SECTIONS
|
|||
. = ALIGN(4);
|
||||
__sbss_b_l1 = .;
|
||||
*(.l1.bss.B)
|
||||
|
||||
. = ALIGN(4);
|
||||
__ebss_b_l1 = .;
|
||||
}
|
||||
|
||||
#ifdef L2_LENGTH
|
||||
__l2_lma_start = .;
|
||||
|
||||
.text_data_l2 L2_START : AT(LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1))
|
||||
{
|
||||
. = ALIGN(4);
|
||||
__stext_l2 = .;
|
||||
*(.l1.text)
|
||||
. = ALIGN(4);
|
||||
__etext_l2 = .;
|
||||
|
||||
. = ALIGN(4);
|
||||
__sdata_l2 = .;
|
||||
*(.l1.data)
|
||||
__edata_l2 = .;
|
||||
|
||||
. = ALIGN(32);
|
||||
*(.data_l2.cacheline_aligned)
|
||||
|
||||
. = ALIGN(4);
|
||||
__sbss_l2 = .;
|
||||
*(.l1.bss)
|
||||
. = ALIGN(4);
|
||||
__ebss_l2 = .;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Force trailing alignment of our init section so that when we
|
||||
* free our init memory, we don't leave behind a partial page.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -42,6 +42,7 @@
|
|||
#include "blackfin_sram.h"
|
||||
|
||||
static spinlock_t l1sram_lock, l1_data_sram_lock, l1_inst_sram_lock;
|
||||
static spinlock_t l2_sram_lock;
|
||||
|
||||
/* the data structure for L1 scratchpad and DATA SRAM */
|
||||
struct sram_piece {
|
||||
|
|
@ -65,6 +66,10 @@ static struct sram_piece free_l1_data_B_sram_head, used_l1_data_B_sram_head;
|
|||
static struct sram_piece free_l1_inst_sram_head, used_l1_inst_sram_head;
|
||||
#endif
|
||||
|
||||
#ifdef L2_LENGTH
|
||||
static struct sram_piece free_l2_sram_head, used_l2_sram_head;
|
||||
#endif
|
||||
|
||||
static struct kmem_cache *sram_piece_cache;
|
||||
|
||||
/* L1 Scratchpad SRAM initialization function */
|
||||
|
|
@ -97,7 +102,7 @@ static void __init l1_data_sram_init(void)
|
|||
free_l1_data_A_sram_head.next =
|
||||
kmem_cache_alloc(sram_piece_cache, GFP_KERNEL);
|
||||
if (!free_l1_data_A_sram_head.next) {
|
||||
printk(KERN_INFO"Fail to initialize Data A SRAM.\n");
|
||||
printk(KERN_INFO"Fail to initialize L1 Data A SRAM.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -110,7 +115,7 @@ static void __init l1_data_sram_init(void)
|
|||
|
||||
used_l1_data_A_sram_head.next = NULL;
|
||||
|
||||
printk(KERN_INFO "Blackfin Data A SRAM: %d KB (%d KB free)\n",
|
||||
printk(KERN_INFO "Blackfin L1 Data A SRAM: %d KB (%d KB free)\n",
|
||||
L1_DATA_A_LENGTH >> 10,
|
||||
free_l1_data_A_sram_head.next->size >> 10);
|
||||
#endif
|
||||
|
|
@ -118,7 +123,7 @@ static void __init l1_data_sram_init(void)
|
|||
free_l1_data_B_sram_head.next =
|
||||
kmem_cache_alloc(sram_piece_cache, GFP_KERNEL);
|
||||
if (!free_l1_data_B_sram_head.next) {
|
||||
printk(KERN_INFO"Fail to initialize Data B SRAM.\n");
|
||||
printk(KERN_INFO"Fail to initialize L1 Data B SRAM.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -131,7 +136,7 @@ static void __init l1_data_sram_init(void)
|
|||
|
||||
used_l1_data_B_sram_head.next = NULL;
|
||||
|
||||
printk(KERN_INFO "Blackfin Data B SRAM: %d KB (%d KB free)\n",
|
||||
printk(KERN_INFO "Blackfin L1 Data B SRAM: %d KB (%d KB free)\n",
|
||||
L1_DATA_B_LENGTH >> 10,
|
||||
free_l1_data_B_sram_head.next->size >> 10);
|
||||
#endif
|
||||
|
|
@ -146,7 +151,7 @@ static void __init l1_inst_sram_init(void)
|
|||
free_l1_inst_sram_head.next =
|
||||
kmem_cache_alloc(sram_piece_cache, GFP_KERNEL);
|
||||
if (!free_l1_inst_sram_head.next) {
|
||||
printk(KERN_INFO"Fail to initialize Instruction SRAM.\n");
|
||||
printk(KERN_INFO"Fail to initialize L1 Instruction SRAM.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -159,7 +164,7 @@ static void __init l1_inst_sram_init(void)
|
|||
|
||||
used_l1_inst_sram_head.next = NULL;
|
||||
|
||||
printk(KERN_INFO "Blackfin Instruction SRAM: %d KB (%d KB free)\n",
|
||||
printk(KERN_INFO "Blackfin L1 Instruction SRAM: %d KB (%d KB free)\n",
|
||||
L1_CODE_LENGTH >> 10,
|
||||
free_l1_inst_sram_head.next->size >> 10);
|
||||
#endif
|
||||
|
|
@ -168,6 +173,33 @@ static void __init l1_inst_sram_init(void)
|
|||
spin_lock_init(&l1_inst_sram_lock);
|
||||
}
|
||||
|
||||
static void __init l2_sram_init(void)
|
||||
{
|
||||
#ifdef L2_LENGTH
|
||||
free_l2_sram_head.next =
|
||||
kmem_cache_alloc(sram_piece_cache, GFP_KERNEL);
|
||||
if (!free_l2_sram_head.next) {
|
||||
printk(KERN_INFO"Fail to initialize L2 SRAM.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
free_l2_sram_head.next->paddr = (void *)L2_START +
|
||||
(_etext_l2 - _stext_l2) + (_edata_l2 - _sdata_l2);
|
||||
free_l2_sram_head.next->size = L2_LENGTH -
|
||||
(_etext_l2 - _stext_l2) + (_edata_l2 - _sdata_l2);
|
||||
free_l2_sram_head.next->pid = 0;
|
||||
free_l2_sram_head.next->next = NULL;
|
||||
|
||||
used_l2_sram_head.next = NULL;
|
||||
|
||||
printk(KERN_INFO "Blackfin L2 SRAM: %d KB (%d KB free)\n",
|
||||
L2_LENGTH >> 10,
|
||||
free_l2_sram_head.next->size >> 10);
|
||||
#endif
|
||||
|
||||
/* mutex initialize */
|
||||
spin_lock_init(&l2_sram_lock);
|
||||
}
|
||||
void __init bfin_sram_init(void)
|
||||
{
|
||||
sram_piece_cache = kmem_cache_create("sram_piece_cache",
|
||||
|
|
@ -177,10 +209,11 @@ void __init bfin_sram_init(void)
|
|||
l1sram_init();
|
||||
l1_data_sram_init();
|
||||
l1_inst_sram_init();
|
||||
l2_sram_init();
|
||||
}
|
||||
|
||||
/* L1 memory allocate function */
|
||||
static void *_l1_sram_alloc(size_t size, struct sram_piece *pfree_head,
|
||||
/* SRAM allocate function */
|
||||
static void *_sram_alloc(size_t size, struct sram_piece *pfree_head,
|
||||
struct sram_piece *pused_head)
|
||||
{
|
||||
struct sram_piece *pslot, *plast, *pavail;
|
||||
|
|
@ -236,7 +269,7 @@ static void *_l1_sram_alloc(size_t size, struct sram_piece *pfree_head,
|
|||
}
|
||||
|
||||
/* Allocate the largest available block. */
|
||||
static void *_l1_sram_alloc_max(struct sram_piece *pfree_head,
|
||||
static void *_sram_alloc_max(struct sram_piece *pfree_head,
|
||||
struct sram_piece *pused_head,
|
||||
unsigned long *psize)
|
||||
{
|
||||
|
|
@ -259,11 +292,11 @@ static void *_l1_sram_alloc_max(struct sram_piece *pfree_head,
|
|||
|
||||
*psize = pmax->size;
|
||||
|
||||
return _l1_sram_alloc(*psize, pfree_head, pused_head);
|
||||
return _sram_alloc(*psize, pfree_head, pused_head);
|
||||
}
|
||||
|
||||
/* L1 memory free function */
|
||||
static int _l1_sram_free(const void *addr,
|
||||
/* SRAM free function */
|
||||
static int _sram_free(const void *addr,
|
||||
struct sram_piece *pfree_head,
|
||||
struct sram_piece *pused_head)
|
||||
{
|
||||
|
|
@ -333,6 +366,11 @@ int sram_free(const void *addr)
|
|||
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
|
||||
#ifdef L2_LENGTH
|
||||
else if (addr >= (void *)L2_START
|
||||
&& addr < (void *)(L2_START + L2_LENGTH))
|
||||
return l2_sram_free(addr);
|
||||
#endif
|
||||
else
|
||||
return -1;
|
||||
|
|
@ -348,7 +386,7 @@ void *l1_data_A_sram_alloc(size_t size)
|
|||
spin_lock_irqsave(&l1_data_sram_lock, flags);
|
||||
|
||||
#if L1_DATA_A_LENGTH != 0
|
||||
addr = _l1_sram_alloc(size, &free_l1_data_A_sram_head,
|
||||
addr = _sram_alloc(size, &free_l1_data_A_sram_head,
|
||||
&used_l1_data_A_sram_head);
|
||||
#endif
|
||||
|
||||
|
|
@ -371,7 +409,7 @@ int l1_data_A_sram_free(const void *addr)
|
|||
spin_lock_irqsave(&l1_data_sram_lock, flags);
|
||||
|
||||
#if L1_DATA_A_LENGTH != 0
|
||||
ret = _l1_sram_free(addr, &free_l1_data_A_sram_head,
|
||||
ret = _sram_free(addr, &free_l1_data_A_sram_head,
|
||||
&used_l1_data_A_sram_head);
|
||||
#else
|
||||
ret = -1;
|
||||
|
|
@ -393,7 +431,7 @@ void *l1_data_B_sram_alloc(size_t size)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1_data_sram_lock, flags);
|
||||
|
||||
addr = _l1_sram_alloc(size, &free_l1_data_B_sram_head,
|
||||
addr = _sram_alloc(size, &free_l1_data_B_sram_head,
|
||||
&used_l1_data_B_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -418,7 +456,7 @@ int l1_data_B_sram_free(const void *addr)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1_data_sram_lock, flags);
|
||||
|
||||
ret = _l1_sram_free(addr, &free_l1_data_B_sram_head,
|
||||
ret = _sram_free(addr, &free_l1_data_B_sram_head,
|
||||
&used_l1_data_B_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -472,7 +510,7 @@ void *l1_inst_sram_alloc(size_t size)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1_inst_sram_lock, flags);
|
||||
|
||||
addr = _l1_sram_alloc(size, &free_l1_inst_sram_head,
|
||||
addr = _sram_alloc(size, &free_l1_inst_sram_head,
|
||||
&used_l1_inst_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -497,7 +535,7 @@ int l1_inst_sram_free(const void *addr)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1_inst_sram_lock, flags);
|
||||
|
||||
ret = _l1_sram_free(addr, &free_l1_inst_sram_head,
|
||||
ret = _sram_free(addr, &free_l1_inst_sram_head,
|
||||
&used_l1_inst_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -519,7 +557,7 @@ void *l1sram_alloc(size_t size)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1sram_lock, flags);
|
||||
|
||||
addr = _l1_sram_alloc(size, &free_l1_ssram_head,
|
||||
addr = _sram_alloc(size, &free_l1_ssram_head,
|
||||
&used_l1_ssram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -537,7 +575,7 @@ void *l1sram_alloc_max(size_t *psize)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1sram_lock, flags);
|
||||
|
||||
addr = _l1_sram_alloc_max(&free_l1_ssram_head,
|
||||
addr = _sram_alloc_max(&free_l1_ssram_head,
|
||||
&used_l1_ssram_head, psize);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -555,7 +593,7 @@ int l1sram_free(const void *addr)
|
|||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l1sram_lock, flags);
|
||||
|
||||
ret = _l1_sram_free(addr, &free_l1_ssram_head,
|
||||
ret = _sram_free(addr, &free_l1_ssram_head,
|
||||
&used_l1_ssram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
|
|
@ -564,6 +602,64 @@ int l1sram_free(const void *addr)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void *l2_sram_alloc(size_t size)
|
||||
{
|
||||
#ifdef L2_LENGTH
|
||||
unsigned flags;
|
||||
void *addr;
|
||||
|
||||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l2_sram_lock, flags);
|
||||
|
||||
addr = _sram_alloc(size, &free_l2_sram_head,
|
||||
&used_l2_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
spin_unlock_irqrestore(&l2_sram_lock, flags);
|
||||
|
||||
pr_debug("Allocated address in l2_sram_alloc is 0x%lx+0x%lx\n",
|
||||
(long unsigned int)addr, size);
|
||||
|
||||
return addr;
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(l2_sram_alloc);
|
||||
|
||||
void *l2_sram_zalloc(size_t size)
|
||||
{
|
||||
void *addr = l2_sram_alloc(size);
|
||||
|
||||
if (addr)
|
||||
memset(addr, 0x00, size);
|
||||
|
||||
return addr;
|
||||
}
|
||||
EXPORT_SYMBOL(l2_sram_zalloc);
|
||||
|
||||
int l2_sram_free(const void *addr)
|
||||
{
|
||||
#ifdef L2_LENGTH
|
||||
unsigned flags;
|
||||
int ret;
|
||||
|
||||
/* add mutex operation */
|
||||
spin_lock_irqsave(&l2_sram_lock, flags);
|
||||
|
||||
ret = _sram_free(addr, &free_l2_sram_head,
|
||||
&used_l2_sram_head);
|
||||
|
||||
/* add mutex operation */
|
||||
spin_unlock_irqrestore(&l2_sram_lock, flags);
|
||||
|
||||
return ret;
|
||||
#else
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
EXPORT_SYMBOL(l2_sram_free);
|
||||
|
||||
int sram_free_with_lsl(const void *addr)
|
||||
{
|
||||
struct sram_list_struct *lsl, **tmp;
|
||||
|
|
@ -602,6 +698,9 @@ void *sram_alloc_with_lsl(size_t size, unsigned long flags)
|
|||
if (addr == NULL && (flags & L1_DATA_B_SRAM))
|
||||
addr = l1_data_B_sram_alloc(size);
|
||||
|
||||
if (addr == NULL && (flags & L2_SRAM))
|
||||
addr = l2_sram_alloc(size);
|
||||
|
||||
if (addr == NULL) {
|
||||
kfree(lsl);
|
||||
return NULL;
|
||||
|
|
@ -621,7 +720,7 @@ EXPORT_SYMBOL(sram_alloc_with_lsl);
|
|||
/* Need to keep line of output the same. Currently, that is 44 bytes
|
||||
* (including newline).
|
||||
*/
|
||||
static int _l1sram_proc_read(char *buf, int *len, int count, const char *desc,
|
||||
static int _sram_proc_read(char *buf, int *len, int count, const char *desc,
|
||||
struct sram_piece *pfree_head,
|
||||
struct sram_piece *pused_head)
|
||||
{
|
||||
|
|
@ -630,13 +729,13 @@ static int _l1sram_proc_read(char *buf, int *len, int count, const char *desc,
|
|||
if (!pfree_head || !pused_head)
|
||||
return -1;
|
||||
|
||||
*len += sprintf(&buf[*len], "--- L1 %-14s Size PID State \n", desc);
|
||||
*len += sprintf(&buf[*len], "--- SRAM %-14s Size PID State \n", desc);
|
||||
|
||||
/* search the relevant memory slot */
|
||||
pslot = pused_head->next;
|
||||
|
||||
while (pslot != NULL) {
|
||||
*len += sprintf(&buf[*len], "%p-%p %8i %5i %-10s\n",
|
||||
*len += sprintf(&buf[*len], "%p-%p %10i %5i %-10s\n",
|
||||
pslot->paddr, pslot->paddr + pslot->size,
|
||||
pslot->size, pslot->pid, "ALLOCATED");
|
||||
|
||||
|
|
@ -646,7 +745,7 @@ static int _l1sram_proc_read(char *buf, int *len, int count, const char *desc,
|
|||
pslot = pfree_head->next;
|
||||
|
||||
while (pslot != NULL) {
|
||||
*len += sprintf(&buf[*len], "%p-%p %8i %5i %-10s\n",
|
||||
*len += sprintf(&buf[*len], "%p-%p %10i %5i %-10s\n",
|
||||
pslot->paddr, pslot->paddr + pslot->size,
|
||||
pslot->size, pslot->pid, "FREE");
|
||||
|
||||
|
|
@ -655,38 +754,43 @@ static int _l1sram_proc_read(char *buf, int *len, int count, const char *desc,
|
|||
|
||||
return 0;
|
||||
}
|
||||
static int l1sram_proc_read(char *buf, char **start, off_t offset, int count,
|
||||
static int sram_proc_read(char *buf, char **start, off_t offset, int count,
|
||||
int *eof, void *data)
|
||||
{
|
||||
int len = 0;
|
||||
|
||||
if (_l1sram_proc_read(buf, &len, count, "Scratchpad",
|
||||
if (_sram_proc_read(buf, &len, count, "Scratchpad",
|
||||
&free_l1_ssram_head, &used_l1_ssram_head))
|
||||
goto not_done;
|
||||
#if L1_DATA_A_LENGTH != 0
|
||||
if (_l1sram_proc_read(buf, &len, count, "Data A",
|
||||
if (_sram_proc_read(buf, &len, count, "L1 Data A",
|
||||
&free_l1_data_A_sram_head,
|
||||
&used_l1_data_A_sram_head))
|
||||
goto not_done;
|
||||
#endif
|
||||
#if L1_DATA_B_LENGTH != 0
|
||||
if (_l1sram_proc_read(buf, &len, count, "Data B",
|
||||
if (_sram_proc_read(buf, &len, count, "L1 Data B",
|
||||
&free_l1_data_B_sram_head,
|
||||
&used_l1_data_B_sram_head))
|
||||
goto not_done;
|
||||
#endif
|
||||
#if L1_CODE_LENGTH != 0
|
||||
if (_l1sram_proc_read(buf, &len, count, "Instruction",
|
||||
if (_sram_proc_read(buf, &len, count, "L1 Instruction",
|
||||
&free_l1_inst_sram_head, &used_l1_inst_sram_head))
|
||||
goto not_done;
|
||||
#endif
|
||||
#ifdef L2_LENGTH
|
||||
if (_sram_proc_read(buf, &len, count, "L2",
|
||||
&free_l2_sram_head, &used_l2_sram_head))
|
||||
goto not_done;
|
||||
#endif
|
||||
|
||||
*eof = 1;
|
||||
not_done:
|
||||
return len;
|
||||
}
|
||||
|
||||
static int __init l1sram_proc_init(void)
|
||||
static int __init sram_proc_init(void)
|
||||
{
|
||||
struct proc_dir_entry *ptr;
|
||||
ptr = create_proc_entry("sram", S_IFREG | S_IRUGO, NULL);
|
||||
|
|
@ -695,8 +799,8 @@ static int __init l1sram_proc_init(void)
|
|||
return -1;
|
||||
}
|
||||
ptr->owner = THIS_MODULE;
|
||||
ptr->read_proc = l1sram_proc_read;
|
||||
ptr->read_proc = sram_proc_read;
|
||||
return 0;
|
||||
}
|
||||
late_initcall(l1sram_proc_init);
|
||||
late_initcall(sram_proc_init);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -92,16 +92,20 @@ extern void *l1_data_B_sram_alloc(size_t);
|
|||
extern void *l1_inst_sram_alloc(size_t);
|
||||
extern void *l1_data_sram_alloc(size_t);
|
||||
extern void *l1_data_sram_zalloc(size_t);
|
||||
extern void *l2_sram_alloc(size_t);
|
||||
extern void *l2_sram_zalloc(size_t);
|
||||
extern int l1_data_A_sram_free(const void*);
|
||||
extern int l1_data_B_sram_free(const void*);
|
||||
extern int l1_inst_sram_free(const void*);
|
||||
extern int l1_data_sram_free(const void*);
|
||||
extern int l2_sram_free(const void *);
|
||||
extern int sram_free(const void*);
|
||||
|
||||
#define L1_INST_SRAM 0x00000001
|
||||
#define L1_DATA_A_SRAM 0x00000002
|
||||
#define L1_DATA_B_SRAM 0x00000004
|
||||
#define L1_DATA_SRAM 0x00000006
|
||||
#define L2_SRAM 0x00000008
|
||||
extern void *sram_alloc_with_lsl(size_t, unsigned long);
|
||||
extern int sram_free_with_lsl(const void*);
|
||||
|
||||
|
|
@ -114,7 +118,9 @@ extern struct file_operations dpmc_fops;
|
|||
extern unsigned long _ramstart, _ramend, _rambase;
|
||||
extern unsigned long memory_start, memory_end, physical_mem_end;
|
||||
extern char _stext_l1[], _etext_l1[], _sdata_l1[], _edata_l1[], _sbss_l1[],
|
||||
_ebss_l1[], _l1_lma_start[], _sdata_b_l1[], _ebss_b_l1[];
|
||||
_ebss_l1[], _l1_lma_start[], _sdata_b_l1[], _ebss_b_l1[],
|
||||
_stext_l2[], _etext_l2[], _sdata_l2[], _edata_l2[], _sbss_l2[],
|
||||
_ebss_l2[], _l2_lma_start[];
|
||||
|
||||
#ifdef CONFIG_MTD_UCLINUX
|
||||
extern unsigned long memory_mtd_start, memory_mtd_end, mtd_size;
|
||||
|
|
|
|||
|
|
@ -15,6 +15,8 @@
|
|||
#define EF_BFIN_FDPIC 0x00000002 /* -mfdpic */
|
||||
#define EF_BFIN_CODE_IN_L1 0x00000010 /* --code-in-l1 */
|
||||
#define EF_BFIN_DATA_IN_L1 0x00000020 /* --data-in-l1 */
|
||||
#define EF_BFIN_CODE_IN_L2 0x00000040 /* --code-in-l2 */
|
||||
#define EF_BFIN_DATA_IN_L2 0x00000080 /* --data-in-l2 */
|
||||
|
||||
typedef unsigned long elf_greg_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,8 +6,6 @@
|
|||
#define Elf_Shdr Elf32_Shdr
|
||||
#define Elf_Sym Elf32_Sym
|
||||
#define Elf_Ehdr Elf32_Ehdr
|
||||
#define FLG_CODE_IN_L1 0x10
|
||||
#define FLG_DATA_IN_L1 0x20
|
||||
|
||||
struct mod_arch_specific {
|
||||
Elf_Shdr *text_l1;
|
||||
|
|
@ -15,5 +13,8 @@ struct mod_arch_specific {
|
|||
Elf_Shdr *bss_a_l1;
|
||||
Elf_Shdr *data_b_l1;
|
||||
Elf_Shdr *bss_b_l1;
|
||||
Elf_Shdr *text_l2;
|
||||
Elf_Shdr *data_l2;
|
||||
Elf_Shdr *bss_l2;
|
||||
};
|
||||
#endif /* _ASM_BFIN_MODULE_H */
|
||||
|
|
|
|||
Loading…
Reference in New Issue