Core DSP Operation

In many DSP algorithms, the Sum of Products or Multiply-Accumulate (MAC) operations are very common. A DSP CPU is designed to handle the math-intensive calculations necessary for common DSP algorithms. For efficient implementation of the MAC operation, the C6211 CPU has two multipliers and each of them can perform a 16-bit multiplication in each clock cycle. For example, if we want to compute the dot product of two length-40 vectors an a n and xn x n , we need to compute: y=∑n=140an×xn y n 1 40 a n x n (For example, the FIR filtering algorithm is exactly the same as this dot product operation.) When an a n and xn x n are stored in memory, starting from n=1 n 1 , we need to compute an×xn a n x n and add it to y y ( y y is initially 0 0) and repeat this up to n=40 n 40 . In the C62x assembly, this MAC operation can be written as:

1  MPY .M a,x,prod
2  ADD .L y,prod,y

Ignore .M and .L for now. Here, a,x,prod,y are numbers stored in memory and the instruction MPY multiplies two numbers a and x together and stores the result in prod. The ADD instruction adds two numbers y and prod together storing the result back to y.

Register Files

Where are the numbers stored in the CPU? In C62x, the numbers used in operations are stored in the registers. Because the registers are directly accessible though the data path of the CPU, accessing the registers are much faster than accessing data in the external memory.

The C62x CPU has two register files (A and B). Each of these files consists of sixteen 32-bit registers (A0-A15 for file A and B0-B15 for file B). The general-purpose registers can be used for data, data address pointers, or condition registers.

The general-purpose register files support data ranging in size from 16-bit data through 40-bit fixed-point. Values larger than 32 bits, such as 40-bit long quantities, are stored in register pairs. In a register pair, the 32 LSB's of data are placed in an even-numbered register and the remaining 8 MSB's in the next upper register (which is always an odd-numbered register). In assembly language syntax, a colon between two register names denotes the register pairs, and the odd-numbered register is specified first. For example, A1:A0 represents the register pair consisting of A0 and A1. But you don't need to be concerned with the 40-bit numbers too much. Throughout this course, you will be mostly handling either 16 or 32-bit values stored in a single register.

Let's for now focus on file A only. The registers in the register file A are named A0 to A15. Each register can store a 32-bit binary number. Then numbers such as a,x,prod,y above are stored in these registers. For example, register A0 stores a. For now, let's assume we interpret all 32-bit numbers stored in registers as unsigned integer. Therefore the range of values we can represent is 0 to 232-1 2 32 1 . (For representation of real numbers using binary bits, we will learn about the Q format numbers for fixed-point representation of real numbers.) Let's assume the numbers a,x,prod,y are in the registers A0, A1, A3, A4, respectively. Then the above assembly instructions can be written specifically:

1  MPY .M1 A0,A1,A3
2  ADD .L1 A4,A3,A4

The TI C62x CPU has a load/store architecture. This means that all the numbers must be stored in the registers for being used as operands of the operations for instructions such as MPY and ADD. The numbers can be read from a memory location to a register (using, for example, LDW, LDB instructions) or a register can be loaded with a constant value. The content of a register can be stored to a memory location (using, for example, STW, STB instructions).

In addition to the general-purpose register files, the CPU has a separate register file for the control registers. The control registers are used to control various CPU functions such as addressing mode, interrupts, etc. You will learn more about some of the control registers when we learn each individual topic.

Functional Units

Then, where do the actual operations such as multiplication and addition take place? The C62x CPU has several functional units that perform the actual operations. Each register file has 4 functional units named .M, .L, .S, and .D. The 4 functional units connected to the register file A are named .L1, .S1, .D1, and .M1. Those connected to the register file B are named .L2, .S2, .D2, and .M2. For example, the functional unit .M1 performs multiplication on the operands that are in register file A. When the CPU executes the MPY .M1 A0, A1, A3 above, the functional unit .M1 takes the value stored in A0 and A1, multiply them together and stores the result to A3. The .M1 in MPY .M1 A0, A1, A3 indicates that this operation is performed in the .M1 unit. The .M1 unit has a 16 bit multiplier and all the multiplications are performed by the .M1 (or .M2) unit.

Similarly, the ADD operation can be executed by the .L1 unit. The .L1 can perform all the logical operations such as bitwise AND operation (AND instruction) as well as basic addition (ADD instruction) and subtraction (SUB instruction).

We will later learn more about assigning the functional units for assembly instructions.

Memory Map and Linker Command File

When you have a piece of assembly code to execute on the CPU, you need to first load it up at some memory location. The C6211 CPU has some internal memory space to store program code and data. The DSK board also has an external RAM on the board you can use to store program code and data. The memory map of the DSL board is as follows:

The memory map is fixed by the CPU architecture itself and the way the external memory and input/output (I/O) devices are wired to the CPU. As shown above, each memory location has a 32-bit address and the addresses can be stored in the registers to be used as memory index for data load/store.

When you write an assembly program, you must designate where you want to load up each piece of your codes to execute it. After you write and assemble a piece of assembly code, you obtain a relocatable code, meaning that the code doesn't have any fixed memory reference in it and it can be placed at any memory location by supplying the information on where to be put in the memory map. Then, the linker combines different pieces of assembly codes together to produce the final executable code. The executable code has all the memory location information. For the linker to be able to generate an executable code by actually specifying the memory locations of each assembly code and data, we need to let the linker know the memory map (physical addresses) of the DSK board. For convenience, we can assign named to different pieces of the memory.

The linker command file is the file in which we let the linker know the memory map and the names of each memory sections.

A typical linker command file that can be used for our DSK board is listed below:

1  MEMORY
2   {
3   VECS:      org =         0h,  len =      0x220
4   I_HS_MEM:  org = 0x00000220,  len = 0x00000020
5   IRAM:      org = 0x00000240,  len = 0x0000FDC0
6   SDRAM:     org = 0x80000000,  len = 0x01000000
7   FLASH:     org = 0x90000000,  len = 0x00020000
8   }
9   
10  SECTIONS
11  {
12    /* Created in vectors.asm */
13    vectors  :> VECS
14  
15    /* Created by Assembler */
16    .text    :> IRAM
17 
18  }

The file consists of two parts MEMORY and SECTIONS. The MEMORY part defines the physical addresses of memory blocks memory gap). In C6211, the internal RAM starts at 0x00000000 and the first 0x220 bytes contain the rest and interrupt vectors (we will later learn what they are). The above file named this block VECS. Most of the rest of the internal memory was named IRAM and is used to load program and data (defined in SECTIONS part). The external SDRAM was named SDRAM and the FLASH ROM memory is named FLASH. Note that the starting addresses and lengths of each memory exactly represent the memory map of our DSK board.

The SECTIONS part defines at which memory address to load each “section” of the program code or data. A section is a named piece of code. The section names are defined either in the source files (either assembly or C) or by the C compiler. Line 13 indicates that the vectors section (defined in vectors.asm file) is to be loaded starting at VECS memory address (which starts at 0x00000000). Other sections are all generated by either the assembler or the C compiler. For example, .text section represents the piece of program code generated by the assembler or the C compiler, and the linker command file directs it to be loaded on the internal memory (TRAM). For detailed description of all different sections, please refer to TMS320C6x Assembly Language Tools User’s Guide and TMSS3206x Optimizing C Compiler User’s Guide.

Reset and Interrupt Vector File

After you load up your program code and data at some memory locations, you need to let the CPU to start executing the code. If you reset the CPU, the C6211 CPU starts executing the program code at memory location 0x00000000. Therefore, to execute your own program located at some other location, you have to write a short assembly code the jumps to your program’s entry point. To do this, you need another separate assembly code that is loaded at memory address 0x00000000. We call this file the reset vector file. Here is a example of the reset vector file:

1	.title	"vectors.asm"
2
3	.ref	entry
4
5	.sect	"vectors"
6  rst:	mvkl	.s2	entry,b0
7       mvkl	.s2	entry,b0
S	b	.s2	b0
9       nop
10      nop
11	nop
12      nop
13      nop

The first line names this piece of code as vector.asm. The .ref assembler directive lists the symbolic names defined in another file and used in the current file. That is, it declares that entry is a symbol (the address of the entry point defined in your own assembly program file) defined elsewhere. (.ref is similar to extern declaration in C). The .sect directive simply says that the linker should load the following assembly instructions in the vectors section defined in the linker command file. Because the linker command file above defines the vectors section to start at memory address 0x00000000, the assembly instructions are loaded starting at this location. This is exactly what we want.

When the C6211 DSP receives the reset signal, the CPU first initializes all registers and starts fetching and executing the code at memory address 0x00000000. Thus, we need to load the reset codes at memory address 0x00000000 before running any code. The file vectors.asm is the piece of code we let the linker load at this address.

When you have the entry point of your program code named entry, upon reset we direct the execution to this entry point. Lines 6 and 7 in the above vectors.asm load b0 register with the memory address of the entry to jump (branch) to the address contained in the b0 using the b (branch) instruction in line 8. Because the pipeline function of the processor (discussed later), unless we want to execute extra instructions before branching, we need five nop (no operation) instructions after each b instruction. For more detailed discussion of C62x instructions and the pipeline functions, refer to the TMS320C62x/67x CPU and Instruction Set Reference Guide.

To be able to write your own vectors.asm file, you need to know basic assembly programming. For now, all the reset vector files will have exactly same format as above - loading b0 register with the address to jump and then b instruction followed by five nop instructions.

Writing Simple Assembly Programs

Now let’s write a very short assembly program that adds two numbers. The program does the following:

The core of the program will consist of three instructions.

1	MVK 0x1234,A0
2	MVK 0x0012,Al
3	ADD A0,A1,A2
       

Putting all these together, we obtain

1	  .text
2	  .def entry
3  entry: MVK 0x1234,A0
4         MVK 0x0012,A1
5  	  ADD AO,Al,A2
6	  IDLE
7	  .end
       

Assembly and Execution Using Code Composer Studio

Now you should have three files, vectors.asm, dsk6211.cmd, and add.asm. You’re ready to assemble them and execute your code under the Code Composer Studio.

Creating A New Project

The first thing you should do is to create a project and add the files to the project. This is exactly same as you did with the example C program in (Reference). The files you need to add are add.asm (assuming this is your assembly file name), vectors.asm, and c6211dsk.cmd. You do not need any run-time support library because your assembly program is simple and does not require any library support.

Defining and Using Symbolic Names

To make your code more readable and easier to understand, you can define symbolic variables using the .set assembler directive (.eqn does the same job). We can re-write the program as follows:

1  a	  .set 0x1234
2  b	  .set 0x0012
3	  .text
4         .def entry
3  entry: MVK a,A0
6	  MVK b,Al
7	  ADD AO,Al,A2
8	  IDLE
9	  .end
       

1  a      .set 0x1234
2  b      .set 0x0012
3  x      .set 0x3
4	  .text
5	  .def entry
6  entry: MVK 0,A2
7	  MVK 0,A4
8	  MVK a,A0
9	  MVK b,Al
10	  MVX x,A3
11	  MPY A0,A3,A4
12	  ADD A4,A1,A2
13	  IDLE
14	  .end