Blackfin arch: Extend sram malloc to handle L2 SRAM. (262c3825) · Commits · 戴 / test

arch/blackfin/kernel/module.c

+59 −15

Original line number	Diff line number	Diff line
		@@ -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);
		}

arch/blackfin/kernel/setup.c

+10 −0

Original line number	Diff line number	Diff line
		@@ -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 */

arch/blackfin/kernel/vmlinux.lds.S

+35 −5

Original line number	Diff line number	Diff line
		@@ -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.
		*/

arch/blackfin/mm/blackfin_sram.c

+137 −33

Original line number	Diff line number	Diff line
		@@ -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

include/asm-blackfin/bfin-global.h

+7 −1

Original line number	Diff line number	Diff line
		@@ -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;

Admin message