分支自 DSP/ADSP21569/DSP-21569

graydon
2023-09-20 d40b58b3ecbfb79e015f55755127849335e289b7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/*
 * memory.c
 *
 *  Created on: 2021Äê12ÔÂ25ÈÕ
 *      Author: graydon
 */
 
#include <stdio.h>
#include <string.h>
#include "memory.h"
 
//L1¿Õ¼ä
#define L1_DM1_SIZE 64*1024+16
#define L1_DM2_SIZE 0
#define L1_PM_SIZE 64*1024+16
static char l1mem_dm[L1_DM1_SIZE];
static char l1mem_dm2[L1_DM2_SIZE];
static pm char l1mem_pm[L1_PM_SIZE];
 
//ÓÉÓÚL1·ÇÁ¬Ðø£¬ÐèÒª¶¨ÖÆÄÚ´æ.
#define BANKNUM 3
static int memIndex[BANKNUM] ={255,255,255};
 
int sram_init()
{
//    heap_init(SRAM_L2);
//    heap_init(SRAM_L1);
//    heap_init(SRAM_DDR);
#if L1_DM1_SIZE> 0
    memIndex[mem_dm1] = heap_install(l1mem_dm, L1_DM1_SIZE , 10);
#endif
#if L1_DM2_SIZE> 0
    memIndex[mem_dm2] = heap_install(l1mem_dm2, L1_DM2_SIZE , 11);
#endif
#if L1_PM_SIZE> 0
    memIndex[mem_pm] = heap_install(l1mem_pm, L1_PM_SIZE , 12);
#endif
 
    return 0;
}
 
static void* sram_alloc_l1(meml1_sub_type subType, int size) {
    int i, memid;
    void* ptr = NULL;
 
    switch(subType){
    case mem_dm1:
    case mem_dm2:
    case mem_pm:
        if(memIndex[subType] != 255)
            ptr = heap_malloc(memIndex[subType],size);
        break;
    case mem_heap:
        ptr = heap_malloc(SRAM_L1,size);
        break;
    case mem_any:
        ptr = heap_malloc(SRAM_L1,size);
        if(ptr) break;
        ptr = heap_malloc(memIndex[mem_dm1],size);
        if(ptr) break;
        ptr = heap_malloc(memIndex[mem_dm2],size);
        if(ptr) break;
        ptr = heap_malloc(memIndex[mem_pm],size);
        if(ptr) break;
    }
 
    if(ptr == NULL) {
        memid = -1;
    }
    return ptr;
}
 
void* sram_malloc(MemoryType memtype , meml1_sub_type subType ,int size)
{
    void* p = NULL;
 
    switch(memtype) {
    case SRAM_L2:
    case SRAM_DDR:
        p = heap_malloc(memtype,size);
        break;
    case SRAM_L1:
        p = sram_alloc_l1(subType, size);
        break;
    case SRAM_AUTO:
        p = sram_alloc_l1(subType, size);
        if(p == NULL) {
            p = heap_malloc(SRAM_L2,size);
        }
        if(p == NULL) {
            p = heap_malloc(SRAM_DDR,size);
        }
        break;
    default:
        break;
    }
 
 
    return p;
}
 
void sram_free(MemoryType memtype ,void* ptr)
{
    if(memtype < SRAM_AUTO) {
        heap_free(memtype, ptr);
    }
}
 
int sram_free_space(MemoryType memtype, meml1_sub_type subType)
{
    int size = 0;
    int memid ;
 
    switch(memtype) {
    case SRAM_L2:
    case SRAM_DDR:
        size = heap_space_unused(memtype);
        break;
    case SRAM_L1:
        switch(subType) {
        case mem_heap:
            size = heap_space_unused(memtype);
            break;
        case mem_pm:
        case mem_dm1:
        case mem_dm2:
            size = heap_space_unused(memIndex[subType]);
            break;
        }
        break;
    case SRAM_AUTO:
        break;
    default:
        break;
    }
 
    return  size;
}