再读内核存储管理(8)：片内SRAM的使用

 

快乐虾

http://blog.csdn.net/lights_joy/

lights@hb165.com

  

 

本文适用于

ADI bf561 DSP

uclinux-2008r1-rc8 (移植到vdsp5)

Visual DSP++ 5.0

  

 

欢迎转载，但请保留作者信息

 

1.1    片内SRAM的使用

BF561内部带有高达328K的片内SRAM，那么在内核中是如何使用这些东西的呢？

1.1.1   SRAM信息描述

BF561的片内SRAM由好几个不连续的块组成，内核使用了l1_sram_piece这个结构体进行描述：

/* the data structure for L1 scratchpad and DATA SRAM */

struct l1_sram_piece {

     void *paddr;

     int size;

     int flag;

     pid_t pid;

};

其中的flag可以取以下几个值：

#define SRAM_SLT_NULL      0

#define SRAM_SLT_FREE      1

#define SRAM_SLT_ALLOCATED 2

此外还有一个相关的宏定义：

#define        CONFIG_L1_MAX_PIECE                  16   // L1 SRAM 分为个小块

1.1.2   scratch pad SRAM

1.1.2.1             初始化：l1sram_init

在mem_init函数中(arch/blackfin/mm/init.c)有这样的调用：

       l1sram_init();

此函数位于 arch/blackfin/mm/blackfin_sram.c中：

static struct l1_sram_piece l1_ssram[CONFIG_L1_MAX_PIECE];

 

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

}

在这里有以下定义：

#define L1_SCRATCH_START    0xFFB00000

#define L1_SCRATCH_LENGTH   0x1000

实际上这个函数就是记录了scratch pad SRAM这4K片内SRAM的信息。

1.1.2.2             内存分配：l1sram_alloc

这个函数的实现如下：

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

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

}

从上述函数可以看出，它的分配策略很简单，就是从下往上搜索，找到第一个足够大的块，从这个块内取出指定大小的空间，然后将剩余的空间用一个空闲的描述结构体来表示。由于 CONFIG_L1_MAX_PIECE这个宏定义的关系，这个空间可以分配的块数是有限制的。当然在内核中实际也不会将它分成这么多块，毕竟总共才4K的空间。

在mem_init函数中，有这样一个调用：

     /* Allocate this once; never free it. We assume this gives us a

        pointer to the start of L1 scratchpad memory; panic if it

        doesn't. */

     tmp = (unsigned long)l1sram_alloc(sizeof(struct l1_scratch_task_info));

这是第一个使用l1sram_alloc的地方，因此在Scratchpad SRAM的最开始就是一个 l1_scratch_task_info结构体，通过访问指定的地址( L1_SCRATCH_START)就可以访问这个全局变量。

 

1.1.3   l1_data_sram_init

在mem_init函数中(arch/blackfin/mm/init.c)有这样的调用：

     l1_data_sram_init();

此函数位于 arch/blackfin/mm/blackfin_sram.c中：

static struct l1_sram_piece l1_data_A_sram[CONFIG_L1_MAX_PIECE];

static struct l1_sram_piece l1_data_B_sram[CONFIG_L1_MAX_PIECE];

void __init l1_data_sram_init(void)

{

     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);

 

     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);

 

     /* mutex initialize */

     spin_lock_init(&l1_data_sram_lock);

}

在这里有：

#define L1_DATA_A_START     0xFF800000

#define L1_DATA_B_START     0xFF900000

#define L1_DATA_A_LENGTH      (0x8000 - 0x4000)

#define L1_DATA_B_LENGTH      (0x8000 - 0x4000)

由于启用了cache，因此可用的L1_DATA_A和L1_DATA_B都只有16K可用。

这个函数也只是简单记录了这两个SRAM块的信息。

 

1.1.4   l1_inst_sram_init

在mem_init函数中(arch/blackfin/mm/init.c)有这样的调用：

     l1_inst_sram_init();

此函数位于 arch/blackfin/mm/blackfin_sram.c中：

static struct l1_sram_piece l1_inst_sram[CONFIG_L1_MAX_PIECE];

void __init l1_inst_sram_init(void)

{

     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);

 

     /* mutex initialize */

     spin_lock_init(&l1_inst_sram_lock);

}

在这里有：

#define L1_CODE_START     0xFFA00000

#define L1_CODE_LENGTH      0x4000