← Documents Documentation/arch/arm/tcm.rst GitHub 원문 ↗

Linux 6.18.37 · Architecture

ARM TCM handling in Linux

ARM CPU 내부 ITCM·DTCM의 register, 1:1 mapping, TrustZone bank, tagging API와 allocation pool 사용법을 설명합니다.

Source pathDocumentation/arch/arm/tcm.rst
Source versionLinux v6.18.37
TranslationDUJINLABS 전문 번역 + 해설

요약·해설과 원문, 전문 번역을 서로 분리했습니다. API 이름, symbol, source path는 원문 표기를 사용합니다.

1. 요약·해설

원문의 핵심 논리와 kernel programming 관점의 보충 설명입니다. 아래의 전문 번역과는 별도로 작성했습니다.

요약과 해설

tcm.rst:1-161

TCM은 cache보다 작은 대신 접근 시간이 deterministic하고 외부 RAM controller 상태와 독립적입니다. Linux는 MMU-off code와의 혼동을 줄이기 위해 물리·가상 주소를 같은 위치에 두며 code, data, allocator의 세 방식으로 활용합니다.

TCM 배치와 사용
TCM status / region registersITCM 0xfffe0000__tcmfunc codeFIQ / idle loop
DTCM 0xfffe8000__tcmdata / __tcmconstgen_pooltcm_alloc / tcm_free

CPU 내부 memory가 linker tag와 gen_pool interface를 통해 code와 data에 연결됩니다.

ITCM과 DTCM
구분허용 content대표 tag
ITCMinstruction + data__tcmfunc, __tcmconst
DTCMdata only__tcmdata
undefinedundefined
undefinedundefined

두 memory는 허용하는 content와 대표 tag가 다릅니다.

2. 영어 원문 전체

번역 기준이 된 Linux v6.18.37 원문입니다. 줄 번호는 이 버전의 파일 좌표입니다.

원문 전체 펼치기
1 ==================================================
2 ARM TCM (Tightly-Coupled Memory) handling in Linux
3 ==================================================
4
5 Written by Linus Walleij <[email protected]>
6
7 Some ARM SoCs have a so-called TCM (Tightly-Coupled Memory).
8 This is usually just a few (4-64) KiB of RAM inside the ARM
9 processor.
10
11 Due to being embedded inside the CPU, the TCM has a
12 Harvard-architecture, so there is an ITCM (instruction TCM)
13 and a DTCM (data TCM). The DTCM can not contain any
14 instructions, but the ITCM can actually contain data.
15 The size of DTCM or ITCM is minimum 4KiB so the typical
16 minimum configuration is 4KiB ITCM and 4KiB DTCM.
17
18 ARM CPUs have special registers to read out status, physical
19 location and size of TCM memories. arch/arm/include/asm/cputype.h
20 defines a CPUID_TCM register that you can read out from the
21 system control coprocessor. Documentation from ARM can be found
22 at http://infocenter.arm.com, search for "TCM Status Register"
23 to see documents for all CPUs. Reading this register you can
24 determine if ITCM (bits 1-0) and/or DTCM (bit 17-16) is present
25 in the machine.
26
27 There is further a TCM region register (search for "TCM Region
28 Registers" at the ARM site) that can report and modify the location
29 size of TCM memories at runtime. This is used to read out and modify
30 TCM location and size. Notice that this is not a MMU table: you
31 actually move the physical location of the TCM around. At the
32 place you put it, it will mask any underlying RAM from the
33 CPU so it is usually wise not to overlap any physical RAM with
34 the TCM.
35
36 The TCM memory can then be remapped to another address again using
37 the MMU, but notice that the TCM is often used in situations where
38 the MMU is turned off. To avoid confusion the current Linux
39 implementation will map the TCM 1 to 1 from physical to virtual
40 memory in the location specified by the kernel. Currently Linux
41 will map ITCM to 0xfffe0000 and on, and DTCM to 0xfffe8000 and
42 on, supporting a maximum of 32KiB of ITCM and 32KiB of DTCM.
43
44 Newer versions of the region registers also support dividing these
45 TCMs in two separate banks, so for example an 8KiB ITCM is divided
46 into two 4KiB banks with its own control registers. The idea is to
47 be able to lock and hide one of the banks for use by the secure
48 world (TrustZone).
49
50 TCM is used for a few things:
51
52 - FIQ and other interrupt handlers that need deterministic
53 timing and cannot wait for cache misses.
54
55 - Idle loops where all external RAM is set to self-refresh
56 retention mode, so only on-chip RAM is accessible by
57 the CPU and then we hang inside ITCM waiting for an
58 interrupt.
59
60 - Other operations which implies shutting off or reconfiguring
61 the external RAM controller.
62
63 There is an interface for using TCM on the ARM architecture
64 in <asm/tcm.h>. Using this interface it is possible to:
65
66 - Define the physical address and size of ITCM and DTCM.
67
68 - Tag functions to be compiled into ITCM.
69
70 - Tag data and constants to be allocated to DTCM and ITCM.
71
72 - Have the remaining TCM RAM added to a special
73 allocation pool with gen_pool_create() and gen_pool_add()
74 and provide tcm_alloc() and tcm_free() for this
75 memory. Such a heap is great for things like saving
76 device state when shutting off device power domains.
77
78 A machine that has TCM memory shall select HAVE_TCM from
79 arch/arm/Kconfig for itself. Code that needs to use TCM shall
80 #include <asm/tcm.h>
81
82 Functions to go into itcm can be tagged like this:
83 int __tcmfunc foo(int bar);
84
85 Since these are marked to become long_calls and you may want
86 to have functions called locally inside the TCM without
87 wasting space, there is also the __tcmlocalfunc prefix that
88 will make the call relative.
89
90 Variables to go into dtcm can be tagged like this::
91
92 int __tcmdata foo;
93
94 Constants can be tagged like this::
95
96 int __tcmconst foo;
97
98 To put assembler into TCM just use::
99
100 .section ".tcm.text" or .section ".tcm.data"
101
102 respectively.
103
104 Example code::
105
106 #include <asm/tcm.h>
107
108 /* Uninitialized data */
109 static u32 __tcmdata tcmvar;
110 /* Initialized data */
111 static u32 __tcmdata tcmassigned = 0x2BADBABEU;
112 /* Constant */
113 static const u32 __tcmconst tcmconst = 0xCAFEBABEU;
114
115 static void __tcmlocalfunc tcm_to_tcm(void)
116 {
117 int i;
118 for (i = 0; i < 100; i++)
119 tcmvar ++;
120 }
121
122 static void __tcmfunc hello_tcm(void)
123 {
124 /* Some abstract code that runs in ITCM */
125 int i;
126 for (i = 0; i < 100; i++) {
127 tcmvar ++;
128 }
129 tcm_to_tcm();
130 }
131
132 static void __init test_tcm(void)
133 {
134 u32 *tcmem;
135 int i;
136
137 hello_tcm();
138 printk("Hello TCM executed from ITCM RAM\n");
139
140 printk("TCM variable from testrun: %u @ %p\n", tcmvar, &tcmvar);
141 tcmvar = 0xDEADBEEFU;
142 printk("TCM variable: 0x%x @ %p\n", tcmvar, &tcmvar);
143
144 printk("TCM assigned variable: 0x%x @ %p\n", tcmassigned, &tcmassigned);
145
146 printk("TCM constant: 0x%x @ %p\n", tcmconst, &tcmconst);
147
148 /* Allocate some TCM memory from the pool */
149 tcmem = tcm_alloc(20);
150 if (tcmem) {
151 printk("TCM Allocated 20 bytes of TCM @ %p\n", tcmem);
152 tcmem[0] = 0xDEADBEEFU;
153 tcmem[1] = 0x2BADBABEU;
154 tcmem[2] = 0xCAFEBABEU;
155 tcmem[3] = 0xDEADBEEFU;
156 tcmem[4] = 0x2BADBABEU;
157 for (i = 0; i < 5; i++)
158 printk("TCM tcmem[%d] = %08x\n", i, tcmem[i]);
159 tcm_free(tcmem, 20);
160 }
161 }
162

3. 한국어 전문 번역

영어 원문의 문단 순서와 의미를 유지한 전체 번역입니다. 코드, 함수명, symbol과 URL은 원문 표기를 유지합니다.

ARM TCM (Tightly-Coupled Memory) handling in Linux

1-6

Linus Walleij `<[email protected]>`가 작성한 ARM TCM Linux 처리 문서입니다.

ITCM과 DTCM 구조

7-17

일부 ARM SoC에는 ARM processor 내부에 보통 4~64KiB 정도의 작은 TCM(Tightly-Coupled Memory)이 있습니다.

CPU 내부에 있으므로 TCM은 Harvard architecture를 따르고 instruction TCM인 ITCM과 data TCM인 DTCM으로 나뉩니다. DTCM에는 instruction을 넣을 수 없지만 ITCM에는 data도 넣을 수 있습니다. 각각 최소 크기가 4KiB이므로 일반적인 최소 구성은 ITCM 4KiB + DTCM 4KiB입니다.

TCM status register

18-26

ARM CPU에는 TCM의 status, physical location, size를 읽는 special register가 있습니다. `arch/arm/include/asm/cputype.h`는 system-control coprocessor에서 읽을 `CPUID_TCM` register를 정의합니다.

ARM 문서의 `TCM Status Register`를 참고하면 이 register의 ITCM presence bit 1-0과 DTCM presence bit 17-16으로 machine에 각 memory가 있는지 판단할 수 있습니다.

TCM region register

27-35

`TCM Region Registers`는 runtime에 TCM memory의 location과 size를 보고하고 수정합니다. 이것은 MMU table을 바꾸는 일이 아니라 TCM의 실제 physical location을 이동하는 것입니다. 배치한 위치에서는 아래의 RAM이 CPU에 가려지므로 physical RAM과 겹치지 않게 하는 편이 좋습니다.

Linux의 1:1 mapping

36-43

TCM을 MMU로 다른 address에 다시 mapping할 수 있지만 TCM은 MMU를 끈 상황에서도 자주 사용됩니다. 혼동을 피하려고 현재 Linux 구현은 kernel이 지정한 위치에서 physical과 virtual을 1:1로 mapping합니다.

영역Linux address최대 지원 크기
ITCM`0xfffe0000` 이상32KiB
DTCM`0xfffe8000` 이상32KiB

분할 bank와 TrustZone

44-49

새 region register는 TCM을 두 bank로 나눌 수도 있습니다. 예를 들어 8KiB ITCM을 control register가 각각 있는 4KiB bank 두 개로 나눕니다. 목적은 한 bank를 lock하고 숨겨 secure world, 즉 TrustZone이 쓰게 하는 것입니다.

TCM 사용 사례

50-62
  • cache miss를 기다릴 수 없고 deterministic timing이 필요한 FIQ와 다른 interrupt handler
  • 외부 RAM 전체를 self-refresh retention mode에 두어 on-chip RAM만 접근 가능한 동안 ITCM 안에서 interrupt를 기다리는 idle loop
  • 외부 RAM controller를 끄거나 재구성해야 하는 다른 operation

<asm/tcm.h> interface

63-77

ARM architecture의 TCM interface는 `<asm/tcm.h>`에 있으며 다음을 지원합니다.

  • ITCM과 DTCM의 physical address와 size 정의
  • ITCM에 compile할 function tagging
  • DTCM·ITCM에 할당할 data와 constant tagging
  • 남는 TCM RAM을 `gen_pool_create()`와 `gen_pool_add()`로 special allocation pool에 넣고 `tcm_alloc()`·`tcm_free()` 제공

이 heap은 device power domain을 끌 때 device state를 저장하는 용도 등에 적합합니다.

Kconfig와 function tag

78-88

TCM memory가 있는 machine은 `arch/arm/Kconfig`에서 스스로 `HAVE_TCM`을 select해야 합니다. TCM을 쓰는 code는 `#include <asm/tcm.h>`를 포함합니다.

ITCM에 둘 function에는 다음과 같이 `__tcmfunc` tag를 붙입니다.

int __tcmfunc foo(int bar);

이 function은 `long_calls`가 됩니다. TCM 안에서 local function을 호출하면서 공간을 낭비하지 않으려면 call을 relative로 만드는 `__tcmlocalfunc` prefix를 사용할 수 있습니다.

Data, constant and assembly tags

89-103

DTCM에 둘 variable에는 `__tcmdata`를 붙입니다.

int __tcmdata foo;

constant에는 `__tcmconst`를 붙입니다.

int __tcmconst foo;

assembler를 TCM에 넣을 때는 해당 section을 사용합니다.

.section ".tcm.text" or .section ".tcm.data"

각각 `.tcm.text`는 instruction 쪽, `.tcm.data`는 data 쪽 배치에 대응합니다.

Example code

104-161

다음 원문 예제는 uninitialized·initialized DTCM data와 constant를 선언하고, ITCM local/function tag를 사용한 뒤, 남은 TCM pool에서 20 byte를 allocate해 값을 쓰고 free하는 전체 흐름을 보여 줍니다.

#include <asm/tcm.h>

/* Uninitialized data */
static u32 __tcmdata tcmvar;
/* Initialized data */
static u32 __tcmdata tcmassigned = 0x2BADBABEU;
/* Constant */
static const u32 __tcmconst tcmconst = 0xCAFEBABEU;

static void __tcmlocalfunc tcm_to_tcm(void)
{
      int i;
      for (i = 0; i < 100; i++)
              tcmvar ++;
}

static void __tcmfunc hello_tcm(void)
{
      /* Some abstract code that runs in ITCM */
      int i;
      for (i = 0; i < 100; i++) {
              tcmvar ++;
      }
      tcm_to_tcm();
}

static void __init test_tcm(void)
{
      u32 *tcmem;
      int i;

      hello_tcm();
      printk("Hello TCM executed from ITCM RAM\n");

      printk("TCM variable from testrun: %u @ %p\n", tcmvar, &tcmvar);
      tcmvar = 0xDEADBEEFU;
      printk("TCM variable: 0x%x @ %p\n", tcmvar, &tcmvar);

      printk("TCM assigned variable: 0x%x @ %p\n", tcmassigned, &tcmassigned);

      printk("TCM constant: 0x%x @ %p\n", tcmconst, &tcmconst);

      /* Allocate some TCM memory from the pool */
      tcmem = tcm_alloc(20);
      if (tcmem) {
              printk("TCM Allocated 20 bytes of TCM @ %p\n", tcmem);
              tcmem[0] = 0xDEADBEEFU;
              tcmem[1] = 0x2BADBABEU;
              tcmem[2] = 0xCAFEBABEU;
              tcmem[3] = 0xDEADBEEFU;
              tcmem[4] = 0x2BADBABEU;
              for (i = 0; i < 5; i++)
                      printk("TCM tcmem[%d] = %08x\n", i, tcmem[i]);
              tcm_free(tcmem, 20);
      }
}