英飞凌Aurix tc3xx 多核链接文件 lsl --（上篇）

最新推荐文章于 2024-05-01 23:53:47 发布
最新推荐文章于 2024-05-01 23:53:47 发布
阅读量198 收藏 4
点赞数
文章标签： 软件构建
原文链接：https://blog.csdn.net/weixin_42401233/article/details/132503100?spm=1001.2014.3001.5502
版权

本链接文件 为免费自带 实例lsl, 如有侵权，请告知/
/*分上下两部分，下一篇介绍 /sections 布局设计，包括数据存放位置，程序存放位置等信息/ */
/定义 core0 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA0_SIZE 8k

#define LCF_USTACK0_SIZE 2k

#define LCF_ISTACK0_SIZE 1k

/定义 core1 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA1_SIZE 8k

#define LCF_USTACK1_SIZE 2k

#define LCF_ISTACK1_SIZE 1k

/定义 core2 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA2_SIZE 8k

#define LCF_USTACK2_SIZE 2k

#define LCF_ISTACK2_SIZE 1k

/定义 core3 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA3_SIZE 8k

#define LCF_USTACK3_SIZE 2k

#define LCF_ISTACK3_SIZE 1k

/定义 core4 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA4_SIZE 8k

#define LCF_USTACK4_SIZE 2k

#define LCF_ISTACK4_SIZE 1k

/定义 core5 的 上下文空间，用户栈空间，中断空间/

#define LCF_CSA5_SIZE 8k

#define LCF_USTACK5_SIZE 2k

#define LCF_ISTACK5_SIZE 1k

/定义堆空间/

#define LCF_HEAP_SIZE 4k

/定义CPU cores/

#define LCF_CPU0 0

#define LCF_CPU1 1

#define LCF_CPU2 2

#define LCF_CPU3 3

#define LCF_CPU4 4

#define LCF_CPU5 5

/Un comment one of the below statements to enable CpuX DMI RAM to hold global variables/

#define LCF_DEFAULT_HOST LCF_CPU0

/#define LCF_DEFAULT_HOST LCF_CPU1/

/#define LCF_DEFAULT_HOST LCF_CPU2/

/#define LCF_DEFAULT_HOST LCF_CPU3/

/#define LCF_DEFAULT_HOST LCF_CPU4/

/#define LCF_DEFAULT_HOST LCF_CPU5/

/* Data Scratch Memory core5 数据ram 大小和 起始 位置*/

#define LCF_DSPR5_START 0x10000000

#define LCF_DSPR5_SIZE 96k

/* Data Scratch Memory core4 数据ram 大小和 起始 位置*/

#define LCF_DSPR4_START 0x30000000

#define LCF_DSPR4_SIZE 96k

/* Data Scratch Memory core3 数据ram 大小和 起始 位置*/

#define LCF_DSPR3_START 0x40000000

#define LCF_DSPR3_SIZE 96k

/* Data Scratch Memory core2 数据ram 大小和 起始 位置*/

#define LCF_DSPR2_START 0x50000000

#define LCF_DSPR2_SIZE 96k

/* Data Scratch Memory core1 数据ram 大小和 起始 位置*/

#define LCF_DSPR1_START 0x60000000

#define LCF_DSPR1_SIZE 240k

/* Data Scratch Memory core0 数据ram 大小和 起始 位置*/

#define LCF_DSPR0_START 0x70000000

#define LCF_DSPR0_SIZE 240k

/core5 上下文偏移地址/

/96 - 1 - 8 = 87 = 87 * 1024 = 0x00015C00/

#define LCF_CSA5_OFFSET (LCF_DSPR5_SIZE - 1k - LCF_CSA5_SIZE)

/core5 中断栈区偏移地址/

/871024 - 256 - 11024 = 0x00015700/

#define LCF_ISTACK5_OFFSET (LCF_CSA5_OFFSET - 256 - LCF_ISTACK5_SIZE)

/core5 用户栈区偏移地址/

/871024 - 256 - 11024 - 256 - 21024 = 0x00014E00*/

#define LCF_USTACK5_OFFSET (LCF_ISTACK5_OFFSET - 256 - LCF_USTACK5_SIZE)

/同core5 计算/

#define LCF_CSA4_OFFSET (LCF_DSPR4_SIZE - 1k - LCF_CSA4_SIZE)

#define LCF_ISTACK4_OFFSET (LCF_CSA4_OFFSET - 256 - LCF_ISTACK4_SIZE)

#define LCF_USTACK4_OFFSET (LCF_ISTACK4_OFFSET - 256 - LCF_USTACK4_SIZE)

/同core5 计算/

#define LCF_CSA3_OFFSET (LCF_DSPR3_SIZE - 1k - LCF_CSA3_SIZE)

#define LCF_ISTACK3_OFFSET (LCF_CSA3_OFFSET - 256 - LCF_ISTACK3_SIZE)

#define LCF_USTACK3_OFFSET (LCF_ISTACK3_OFFSET - 256 - LCF_USTACK3_SIZE)

/同core5 计算/

#define LCF_CSA2_OFFSET (LCF_DSPR2_SIZE - 1k - LCF_CSA2_SIZE)

#define LCF_ISTACK2_OFFSET (LCF_CSA2_OFFSET - 256 - LCF_ISTACK2_SIZE)

#define LCF_USTACK2_OFFSET (LCF_ISTACK2_OFFSET - 256 - LCF_USTACK2_SIZE)

/同core5 计算/

#define LCF_CSA1_OFFSET (LCF_DSPR1_SIZE - 1k - LCF_CSA1_SIZE)

#define LCF_ISTACK1_OFFSET (LCF_CSA1_OFFSET - 256 - LCF_ISTACK1_SIZE)

#define LCF_USTACK1_OFFSET (LCF_ISTACK1_OFFSET - 256 - LCF_USTACK1_SIZE)

/同core5 计算/

#define LCF_CSA0_OFFSET (LCF_DSPR0_SIZE - 1k - LCF_CSA0_SIZE)

#define LCF_ISTACK0_OFFSET (LCF_CSA0_OFFSET - 256 - LCF_ISTACK0_SIZE)

#define LCF_USTACK0_OFFSET (LCF_ISTACK0_OFFSET - 256 - LCF_USTACK0_SIZE)

/定义堆区偏移地址 e.g.core5 0x00014E00 - 41024 = 0x00013E00*/

#define LCF_HEAP0_OFFSET (LCF_USTACK0_OFFSET - LCF_HEAP_SIZE)

#define LCF_HEAP1_OFFSET (LCF_USTACK1_OFFSET - LCF_HEAP_SIZE)

#define LCF_HEAP2_OFFSET (LCF_USTACK2_OFFSET - LCF_HEAP_SIZE)

#define LCF_HEAP3_OFFSET (LCF_USTACK3_OFFSET - LCF_HEAP_SIZE)

#define LCF_HEAP4_OFFSET (LCF_USTACK4_OFFSET - LCF_HEAP_SIZE)

#define LCF_HEAP5_OFFSET (LCF_USTACK5_OFFSET - LCF_HEAP_SIZE)

/定义各个核中断向量表起始地址，由此可见中断向量表起始地址都在每个core的Program flash空间的倒数8k的位置/

#define LCF_INTVEC0_START 0x802FE000

#define LCF_INTVEC1_START 0x805FE000

#define LCF_INTVEC2_START 0x808FE000

#define LCF_INTVEC3_START 0x80BFE000

#define LCF_INTVEC4_START 0x80EFE000

#define LCF_INTVEC5_START 0x80FFE000

/定义各个核trap(陷阱)向量表的起始位置，由此可见除了core0在pflash隔了100个bytes位起始位置，其他core 都是 pflash的起始位置/

#define LCF_TRAPVEC0_START 0x80000100

#define LCF_TRAPVEC1_START 0x80300000

#define LCF_TRAPVEC2_START 0x80600000

#define LCF_TRAPVEC3_START 0x80900000

#define LCF_TRAPVEC4_START 0x80C00000

#define LCF_TRAPVEC5_START 0x80F00000

/定义各个cores 起始指针位置(允许cache访问)/

#define LCF_STARTPTR_CPU0 0x80000000

#define LCF_STARTPTR_CPU1 0x80300100

#define LCF_STARTPTR_CPU2 0x80600100

#define LCF_STARTPTR_CPU3 0x80900100

#define LCF_STARTPTR_CPU4 0x80C00100

#define LCF_STARTPTR_CPU5 0x80F00100

/定义各个cores 起始指针位置(不允许cache访问)/

#define LCF_STARTPTR_NC_CPU0 0xA0000000

#define LCF_STARTPTR_NC_CPU1 0xA0300100

#define LCF_STARTPTR_NC_CPU2 0xA0600100

#define LCF_STARTPTR_NC_CPU3 0xA0900100

#define LCF_STARTPTR_NC_CPU4 0xA0C00100

#define LCF_STARTPTR_NC_CPU5 0xA0F00100

/中断向量表 和 trap 向量表/

#define INTTAB0 (LCF_INTVEC0_START)

#define INTTAB1 (LCF_INTVEC1_START)

#define INTTAB2 (LCF_INTVEC2_START)

#define INTTAB3 (LCF_INTVEC3_START)

#define INTTAB4 (LCF_INTVEC4_START)

#define INTTAB5 (LCF_INTVEC5_START)

#define TRAPTAB0 (LCF_TRAPVEC0_START)

#define TRAPTAB1 (LCF_TRAPVEC1_START)

#define TRAPTAB2 (LCF_TRAPVEC2_START)

#define TRAPTAB3 (LCF_TRAPVEC3_START)

#define TRAPTAB4 (LCF_TRAPVEC4_START)

#define TRAPTAB5 (LCF_TRAPVEC5_START)

/定义reset位置位core0的起始指针位置(不运行cache访问)/

#define RESET LCF_STARTPTR_NC_CPU0

#include “tc1v1_6_2.lsl”

// Specify a multi-core processor environment (mpe)

/多核环境 芯片 Tc397/

processor mpe

{

derivative = tc39;

}

/各个核架构定义/

derivative tc39

{

core tc0

{

    architecture = TC1V1.6.2;

    space_id_offset = 100;            // add 100 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core tc1 // core 1 TC16E

{

    architecture = TC1V1.6.2;

    space_id_offset = 200;            // add 200 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core tc2 // core 2 TC16P

{

    architecture = TC1V1.6.2;

    space_id_offset = 300;            // add 300 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core tc3 // core 3 TC16P

{

    architecture = TC1V1.6.2;

    space_id_offset = 400;            // add 300 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core tc4 // core 4 TC16P

{

    architecture = TC1V1.6.2;

    space_id_offset = 500;            // add 300 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core tc5 // core 5 TC16P

{

    architecture = TC1V1.6.2;

    space_id_offset = 600;            // add 300 to all space IDs in the architecture definition

    copytable_space = vtc:linear;     // use the copy table in the virtual core for 'bss' and initialized data sections

}



core vtc

{

    architecture = TC1V1.6.2;

    import tc0;                     // add all address spaces of core tc0 to core vtc for linking and locating

    import tc1;                     //                                tc1

    import tc2;                     //                                tc2

    import tc3;                     //                                tc3

    import tc4;                     //                                tc4

    import tc5;                     //                                tc5

}

/内部数据bus定义/

bus sri

{

    mau = 8;    // 最小地址单位

    width = 32; // 地址行数

    

    /* map关键字指定此总线如何映射到另一个总线 */

    // map shared addresses one-to-one to real cores and virtual cores  

    /*  

        dest        参数指定目的地址。这可以是一个总线或另一个地址空间(仅适用于空间到空间的映射)。这个参数是必需的。

        src_offset  参数指定源地址的偏移量。与size一起，它指定了映射的地址范围。缺省情况下，源偏移量为0x0000。

        size        参数指定被映射的地址数量。这个参数是必需的。

        dest_offset 参数指定指定地址范围映射到的目标地址的位置。缺省情况下，目的偏移量为0x0000。

        */

    map (dest=bus:tc0:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:tc1:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:tc2:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:tc3:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:tc4:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:tc5:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

    map (dest=bus:vtc:fpi_bus, src_offset=0, dest_offset=0, size=0xc0000000);

}

/数据/

memory dsram5 // Data Scratch Pad Ram

{

    mau = 8;

    size = 96k;

    type = ram;

    /*priority: 

                如果定义内存，可以使用关键字priority和exec_priority在映射上设置定位优先级。

                这些优先级的值是相对的，这意味着它们增加了内存的优先级。

                内存上的优先级设置适用于通过内存映射可达的所有地址空间区域，

                而映射上的优先级设置仅适用于通过映射可达的地址空间区域。

                优先级最高的内存映射在定位时优先考虑。

                若要仅为非可执行(数据)部分设置优先级，请添加具有所需值的priority关键字，

                并将exec_priority设置为0。要仅为可执行(代码)部分设置优先级，

                只需将exec_priority关键字设置为所需的值。

        */

    map (dest=bus:tc5:fpi_bus, dest_offset=0xd0000000, size=96k, priority=8);

    map (dest=bus:sri, dest_offset=0x10000000, size=96k);

}

/程序/

memory psram5 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc5:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x10100000, size=64k);

}

memory dsram4 // Data Scratch Pad Ram

{

    mau = 8;

    size = 96k;

    type = ram;

    map (dest=bus:tc4:fpi_bus, dest_offset=0xd0000000, size=96k, priority=8);

    map (dest=bus:sri, dest_offset=0x30000000, size=96k);

}



memory psram4 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc4:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x30100000, size=64k);

}

memory dsram3 // Data Scratch Pad Ram

{

    mau = 8;

    size = 96k;

    type = ram;

    map (dest=bus:tc3:fpi_bus, dest_offset=0xd0000000, size=96k, priority=8);

    map (dest=bus:sri, dest_offset=0x40000000, size=96k);

}



memory psram3 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc3:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x40100000, size=64k);

}

memory dsram2 // Data Scratch Pad Ram

{

    mau = 8;

    size = 96k;

    type = ram;

    map (dest=bus:tc2:fpi_bus, dest_offset=0xd0000000, size=96k, priority=8);

    map (dest=bus:sri, dest_offset=0x50000000, size=96k);

}



memory psram2 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc2:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x50100000, size=64k);

}



memory dsram1 // Data Scratch Pad Ram

{

    mau = 8;

    size = 240k;

    type = ram;

    map (dest=bus:tc1:fpi_bus, dest_offset=0xd0000000, size=240k, priority=8);

    map (dest=bus:sri, dest_offset=0x60000000, size=240k);

}



memory psram1 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc1:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x60100000, size=64k);

}

memory dsram0 // Data Scratch Pad Ram

{

    mau = 8;

    size = 240k;

    type = ram;

    map (dest=bus:tc0:fpi_bus, dest_offset=0xd0000000, size=240k, priority=8);

    map (dest=bus:sri, dest_offset=0x70000000, size=240k);

}



memory psram0 // Program Scratch Pad Ram

{

    mau = 8;

    size = 64k;

    type = ram;

    map (dest=bus:tc0:fpi_bus, dest_offset=0xc0000000, size=64k, priority=8);

    map (dest=bus:sri, dest_offset=0x70100000, size=64k);

}



memory pfls0

{

    mau = 8;

    size = 3M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80000000,           size=3M);

    map not_cached (dest=bus:sri, dest_offset=0xa0000000, reserved, size=3M);

}



memory pfls1

{

    mau = 8;

    size = 3M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80300000,           size=3M);

    map not_cached (dest=bus:sri, dest_offset=0xa0300000, reserved, size=3M);

}



memory pfls2

{

    mau = 8;

    size = 3M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80600000,           size=3M);

    map not_cached (dest=bus:sri, dest_offset=0xa0600000, reserved, size=3M);

}



memory pfls3

{

    mau = 8;

    size = 3M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80900000,           size=3M);

    map not_cached (dest=bus:sri, dest_offset=0xa0900000, reserved, size=3M);

}



memory pfls4

{

    mau = 8;

    size = 3M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80c00000,           size=3M);

    map not_cached (dest=bus:sri, dest_offset=0xa0c00000, reserved, size=3M);

}



memory pfls5

{

    mau = 8;

    size = 1M;

    type = rom;

    map     cached (dest=bus:sri, dest_offset=0x80f00000,           size=1M);

    map not_cached (dest=bus:sri, dest_offset=0xa0f00000, reserved, size=1M);

}



memory dfls0

{

    mau = 8;

    size = 1M;

    type = reserved nvram;

    map (dest=bus:sri, dest_offset=0xaf000000, size=1M  );

}



memory ucb

{

    mau = 8;

    size = 24k;

    type = rom;

    map (dest=bus:sri, dest_offset=0xaf400000, reserved, size=24k);

}



memory cpu0_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90000000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0000000, reserved, size=64k);

}



memory cpu1_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90010000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0010000, reserved, size=64k);

}



memory cpu2_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90020000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0020000, reserved, size=64k);

}



memory cpu3_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90030000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0030000, reserved, size=64k);

}

memory lmuram

{

    mau = 8;

    size = 768K;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90040000,           size=768K);

    map not_cached (dest=bus:sri, dest_offset=0xb0040000, reserved, size=768K);

}



memory cpu4_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90100000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0100000, reserved, size=64k);

}



memory cpu5_dlmu

{

    mau = 8;

    size = 64k;

    type = ram;

    map     cached (dest=bus:sri, dest_offset=0x90110000,           size=64k);

    map not_cached (dest=bus:sri, dest_offset=0xb0110000, reserved, size=64k);

}



memory edmem

{

    mau = 8;

    size = 4M;

    type = ram;

    map (dest=bus:sri, dest_offset=0x99000000, size=4M);

    map (dest=bus:sri, dest_offset=0xb9000000, reserved, size=4M);

}

/section 设置/

#if (VERSION >= 6003)

section_setup :vtc:linear

{

    heap "heap" (min_size = (1k), fixed, align = 8);    /* 最小堆区1k, 字节对齐8字节 */

}

#endif

/*

        软件运行起始地址标志位

        在程序中的入口函数

        如

        void _START(void)

        {

             Ifx_Ssw_jumpToFunction(__StartUpSoftware);

        }

        然后运行到函数Ifx_Ssw_jumpToFunction(__StartUpSoftware) 进行初始化

        */

section_setup :vtc:linear

{

    start_address

    (

        symbol = "_START"   

    );

}

/*

        min_size语句必须存在。

        min_size值必须大于等于1。

                最多可以指定一个align语句，一个grow语句和一个threads语句。

                每个堆栈定义可以有一个或多个entry_points语句用于堆栈评估。symbol_name相对应编译器生成的.CALLS指令中名称

        */

section_setup :vtc:linear

{

    stack "ustack_tc0" (min_size = 1k, fixed, align = 8);

    stack "istack_tc0" (min_size = 1k, fixed, align = 8);

    stack "ustack_tc1" (min_size = 1k, fixed, align = 8);

    stack "istack_tc1" (min_size = 1k, fixed, align = 8);

    stack "ustack_tc2" (min_size = 1k, fixed, align = 8);

    stack "istack_tc2" (min_size = 1k, fixed, align = 8);

    stack "ustack_tc3" (min_size = 1k, fixed, align = 8);

    stack "istack_tc3" (min_size = 1k, fixed, align = 8);

    stack "ustack_tc4" (min_size = 1k, fixed, align = 8);

    stack "istack_tc4" (min_size = 1k, fixed, align = 8);

    stack "ustack_tc5" (min_size = 1k, fixed, align = 8);

    stack "istack_tc5" (min_size = 1k, fixed, align = 8);

}



/*Section setup for the copy table*/

/*

        copy_unit是由启动代码移动数据的MAUs大小定义的。

        dest语句只在启动代码初始化内存时被另一个没有ROM访问权限的处理器使用。

        space_name是指一个已定义的地址空间。

*/

section_setup :vtc:linear

{

    copytable

    (

        align = 4,

        dest = linear,

        table

        {

            symbol = "_lc_ub_table_tc0";

            space = :tc0:linear, :tc0:abs24, :tc0:abs18, :tc0:csa;

        },

        table

        {

            symbol = "_lc_ub_table_tc1";

            space = :tc1:linear, :tc1:abs24, :tc1:abs18, :tc1:csa;

        },

        table

        {

            symbol = "_lc_ub_table_tc2";

            space = :tc2:linear, :tc2:abs24, :tc2:abs18, :tc2:csa;

        },

        table

        {

            symbol = "_lc_ub_table_tc3";

            space = :tc3:linear, :tc3:abs24, :tc3:abs18, :tc3:csa;

        },

        table

        {

            symbol = "_lc_ub_table_tc4";

            space = :tc4:linear, :tc4:abs24, :tc4:abs18, :tc4:csa;

        },

        table

        {

            symbol = "_lc_ub_table_tc5";

            space = :tc5:linear, :tc5:abs24, :tc5:abs18, :tc5:csa;

        }

    );

}
天宇瞳曚
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TASKING LSL 脚本语言介绍.pptx
08-26
Tasking编译器链接脚本用法介绍，LSL脚本语言，用于给英飞凌系列的单片机软件开发的代码分配地址。
英飞凌Tasking lsl文件内存分段和指定变量\函数在物理内存中存放
02-18
英飞凌Tasking lsl文件内存分段和指定变量\函数在物理内存中存放 Linker Script Language (LSL) 是大家在使用TASKING进行链接时所必不可少的文件，在LSL文件中指明某些特性(与linker相关的部分)到所使用的目标板上，设置代码在指定核心上运行，方便为某些代码选择运行核心。 不同公司的LSL的写法和风格也是不一样的。在TASKING中，您可以直接使用TASKING自带的LSL文件，也可以使用Baseframework中英飞凌风格的LSL文件。 LSL常用的关键字有： – run_addr = address (运行时地址，address at run-time) – load_addr = address (在复制到运行地址前，初始地址在ROM中（initial address)) – ordered (以group中定义的排序方式来将sections定位到地址空间中) – contiguous (在group中某单个地址范围内随意布局
Aurix Tricore TC397定义变量至指定的地址空间
HuskieMe的博客
09-30 3334
AURIX TC397一般拥有多块存储器，包括PSRR、DSRR、DLMU、LMU等，在AURIX development studio下的lsl链接文件中定义了这几个区段。
Aurix tc3xx 多核链接文件 lsl --- 上篇
weixin_42401233的博客
08-25 688
*定义各个核trap(陷阱)向量表的起始位置，由此可见除了core0在pflash隔了100个bytes位起始位置，其他core 都是 pflash的起始位置*/dest_offset 参数指定指定地址范围映射到的目标地址的位置。/*字数太多，无法上传，分上下两部分，下一篇介绍 /*sections 布局设计，包括数据存放位置，程序存放位置等信息*/ *//*定义各个核中断向量表起始地址，由此可见中断向量表起始地址都在每个core的Program flash空间的倒数8k的位置*/
【Aurix/Tricore实验分享四 - Trap】
OceanLake_W的博客
02-02 745
简介：实现DSE、DAE、OVF和SYS四种Trap测试验证。
英飞凌程序下载教程
10-11
文档是关于英飞凌芯片下载程序的流程说明，英飞凌这个芯片总的来说是比较怪异的，下载模式多样，希望这教程能够帮到大家。我使用的芯片是XMC1302，大家如果有其他问题可以来咨询我。谢谢大家。
Aurix tc3xx 多核链接文件 lsl -- (下篇)
最新发布
l0808ai0102的博客
05-01 76
* 接上篇 *//*首先认识一下缩写*/根据上面注释， 理解下面把对应的数据放在对应的区域里。
Aurix 多核链接文件 lsl --- 下篇
weixin_45576679的博客
11-19 4061
/*接上篇 */ /*首先认识一下缩写 默认sections .text 代码section .data 需要初始化的数据 .bss 不需要初始化的数据 .rodata 存储的只读数据 .version_info 编译器相...
Aurix tc3xx 多核链接文件 lsl --- 下篇
weixin_42401233的博客
08-25 528
只需要在下面groip对应的dsram4 里面把 c 的部分名字select一下，这里的* 意思是 任意通配符。.zbss 不需要初始化的数据，可以存放在绝对的地址里面。.zdata 需要初始化的数据，可以存放在绝对的地址里面。.zrodata 只读数据，可以存放在绝对的地址里面。.bss 不需要初始化的数据。/*根据上面注释， 理解下面把对应的数据放在对应的区域里*/
链接文件学习（七）：英飞凌MCU Tasking编译器LSL链接文件解析 及代码变量定位方法
梦想技术家
10-09 2784
Data 区域是用来存放带初始化值的全局变量，在 link 文件中，这个区域有两种类型，一种是预先定义的区域和默认区域。预定义就是事先定义好的，默认的就是没有定义的。预先定义的 Data 区域,例如.data.Ifx_Ssw_Tc1 和.data.Cpu1_Main.*（此处表示整个Cpu1_Main.c）, 在 cpu1_main.c中如果定义了一个带初始化值的变量，则它会放在 DSRAM1 中的.data.Cpu1_Main.*段中。
AURIX TC37X 空工程
07-15
采用了 Tasking 和 HighTec 两个 IDE 创建的 AURIX TC37X demo 工程，使用的是 illD 库，快速上手使用，无需重新创建工程。
英飞凌平台tasking建立自己的工程
09-26
此PDF文档详细的讲述了怎么在原来基础上搭建自己的工程
tricore-lsl ,LSL文件语法
06-18
tricore LSL 语法
TC3xx MCAL中Tasking Link文件解析以及代码变量定位方法
06-07
Tasking Link文件是英飞凌TC3xx微控制器（MCU）在编译过程中用于指定内存分配和链接规则的关键配置文件。理解并掌握如何解析Link文件以及如何调整变量、常量和代码在RAM和Flash中的定位，对优化程序性能和满足特定...
LSL-using-Control-Program.pdf
07-19
LSL（Linker Script Language）是一种 powerful 的链接脚本语言，用于控制编译器和链接器的行为。LSL控制程序是一种高级的任务管理工具，允许开发者在编译和链接过程中精细地控制程序的布局和组织。 1. 如何在特定...
英飞凌 Tricore TC26X（TC265/TC264等）单片机iLLD库
10-19
英飞凌Tricore TC26X系列单片机是高性能微控制器，广泛应用于汽车电子、工业自动化和嵌入式系统等领域。其中，TC265和TC264是该系列的代表型号，它们基于32位Tricore架构，提供强大的计算能力和丰富的外设接口，以...
关于Aurix的内存，缓存Cache，PSPR等的理解-（持续更新）
xiandang8023的博客
03-24 3431
举例：一个手机里存着我们很多的数据，如果手机关机，这些数据或者图片是存放在FLASH里的，因为FLASH是存放静态数据的，而当手机重新上电的时候，flash里的数据会通过指令传输到RAM里，之后在被系统里的函数调用，从而开机后，手机可以看到关机前的数据。根据要寻址的地址的tag来逐一与cache中的tag字段比较，如果有与之匹配的cache line，也就是cache hit，如果遍历整个cache，也没有找到匹配的cache line，那就是cache miss了。但是如果掉电，RAM里的数据不会保存，
AURIX TC3XX启动文件解析
kunkliu的博客
06-10 2500
启动文件流程图：TC3xx系列MCU复位后会从Ifx_Ssw_Tc0.c文件的_START()函数开始启动，启动的时候都会从CPU0开始运行，直到在__StartUpSoftware_Phase6()函数中才会根据用户配置依次启动其他核。 _START()_START()的地址由link文件中RESET决定，以Tasking为例. 在Link文件中： 这个地址也必须和BMHD中的应用程序起始地址定义一致。 _START()代码解析： __StartUpSoftware()__StartUpSoftwa
multiple uses of --lsl-core= are not allowed
07-16
"multiple uses of --lsl-core=" 是一个编译器错误，它表示在编译命令中多次使用了相同的 --lsl-core= 标志。这个错误通常发生在链接库或依赖项的指定上。 要解决这个问题，你可以尝试以下几个步骤： 1. 检查编译命令中是否多次指定了相同的 --lsl-core= 标志。确保只使用一次。 2. 如果你确实需要多个 --lsl-core= 标志，那么可能是编译器不支持多次使用该标志的情况。你可以尝试使用其他编译选项或重新安排代码结构来解决此问题。 3. 如果你使用的是某个框架或库，可以查阅相关文档以了解正确的编译选项和用法。 如果以上步骤都无法解决问题，建议你提供更多的上下文和具体的编译命令，以便我能够提供更准确的帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值