Blackfin arch: Extend sram malloc to handle L2 SRAM.
Sonic Zhang [Sat, 19 Jul 2008 07:42:41 +0000 (15:42 +0800)]
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>

arch/blackfin/kernel/module.c
arch/blackfin/kernel/setup.c
arch/blackfin/kernel/vmlinux.lds.S
arch/blackfin/mm/blackfin_sram.c
include/asm-blackfin/bfin-global.h
include/asm-blackfin/elf.h
include/asm-blackfin/module.h

index 14a4284..e1bebc8 100644 (file)
@@ -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);
 }
index 861a1db..8671d1d 100644 (file)
@@ -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 */
index 3ecc64c..0896e38 100644 (file)
@@ -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,14 +187,13 @@ 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.
         */
index b58cf19..5af3c31 100644 (file)
@@ -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)
 {
@@ -334,6 +367,11 @@ int sram_free(const void *addr)
                 && 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
index 7603383..320aa5e 100644 (file)
@@ -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;
index 30303fc..67a03a8 100644 (file)
@@ -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;
 
index 3c7ce16..e3128df 100644 (file)
@@ -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 */