metaonly module ti.platforms.evmAM572X.Platform

Platform support for AM572X

This module implements xdc.platform.IPlatform and defines configuration parameters that correspond to this platform's Cpu's, Board's, etc. [ more ... ]
Configuration settings sourced in ti/platforms/evmAM572X/Platform.xdc
var Platform = xdc.useModule('ti.platforms.evmAM572X.Platform');
module-wide constants & types
        obj.id// unique id within the platform = String  ...
        obj.boardName// name of the board = String  ...
        obj.boardFamily// optional family name = String  ...
        obj.boardRevision// optional revision string = String  ...
 
        obj.comment// description of this block = String  ...
        obj.name// name of memory segment = String  ...
        obj.space// "code", "data", "code/data", etc... = String  ...
        obj.page// page of memory segment = UInt  ...
        obj.base// base address of memory segment = UInt  ...
        obj.len// length of memory segment = UInt  ...
        obj.access// attributes of memory: "RWX" = String  ...
        obj.cacheable// Is this block cacheable? = Bool  ...
        obj.cacheAttrs// Device specific MMU attributes = Any  ...
module-wide config parameters
        id: "0",
        boardName: "evmAM572X",
        boardFamily: "evmAM572X",
        boardRevision: null
    };
    const Platform.DSP//  = IExeContext.Cpu {
        id: "0",
        clockRate: 700,
        catalogName: "ti.catalog.c6000",
        deviceName: "DRA7XX",
        revision: "1.0"
    };
    const Platform.DSP1//  = Any {
        externalMemoryMap: [
            [
                "DSP1_PROG",
                {
                    name: "DSP1_PROG",
                    space: "code/data",
                    access: "RWX",
                    base: 0x8C000000,
                    len: 0x1000000,
                    comment: "DSP1 Program Memory (16 MB)"
                }
            ],
            [
                "SR_0",
                Platform.SR_0
            ]
        ],
        codeMemory: "DSP1_PROG",
        dataMemory: "DSP1_PROG",
        stackMemory: "DSP1_PROG",
        l1DMode: "32k",
        l1PMode: "32k",
        l2Mode: "128k"
    };
    const Platform.DSP2//  = Any {
        externalMemoryMap: [
            [
                "DSP2_PROG",
                {
                    name: "DSP2_PROG",
                    space: "code/data",
                    access: "RWX",
                    base: 0x8D000000,
                    len: 0x1000000,
                    comment: "DSP2 Program Memory (16 MB)"
                }
            ],
            [
                "SR_0",
                Platform.SR_0
            ]
        ],
        codeMemory: "DSP2_PROG",
        dataMemory: "DSP2_PROG",
        stackMemory: "DSP2_PROG",
        l1DMode: "32k",
        l1PMode: "32k",
        l2Mode: "128k"
    };
    const Platform.GPP//  = IExeContext.Cpu {
        id: "3",
        clockRate: 1500.0,
        catalogName: "ti.catalog.arm.cortexa15",
        deviceName: "DRA7XX",
        revision: "1.0"
    };
    const Platform.HOST//  = Any {
        externalMemoryMap: [
            [
                "HOST_PROG",
                {
                    name: "HOST_PROG",
                    space: "code/data",
                    access: "RWX",
                    base: 0x8B000000,
                    len: 0x1000000,
                    comment: "HOST Program Memory (16 MB)"
                }
            ],
            [
                "SR_0",
                Platform.SR_0
            ]
        ],
        codeMemory: "HOST_PROG",
        dataMemory: "HOST_PROG",
        stackMemory: "HOST_PROG"
    };
    const Platform.IPU1//  = Any {
        externalMemoryMap: [
            [
                "IPU1_PROG",
                {
                    name: "IPU1_PROG",
                    space: "code/data",
                    access: "RWX",
                    base: 0x8A000000,
                    len: 0x800000,
                    comment: "IPU1 Program Memory (8 MB)"
                }
            ],
            [
                "SR_0",
                Platform.SR_0
            ]
        ],
        codeMemory: "IPU1_PROG",
        dataMemory: "IPU1_PROG",
        stackMemory: "IPU1_PROG"
    };
    const Platform.IPU2//  = Any {
        externalMemoryMap: [
            [
                "IPU2_PROG",
                {
                    name: "IPU2_PROG",
                    space: "code/data",
                    access: "RWX",
                    base: 0x8A800000,
                    len: 0x800000,
                    comment: "IPU2 Program Memory (8 MB)"
                }
            ],
            [
                "SR_0",
                Platform.SR_0
            ]
        ],
        codeMemory: "IPU2_PROG",
        dataMemory: "IPU2_PROG",
        stackMemory: "IPU2_PROG"
    };
    const Platform.M4//  = IExeContext.Cpu {
        id: "1",
        clockRate: 212.8,
        catalogName: "ti.catalog.arm.cortexm4",
        deviceName: "DRA7XX",
        revision: "1.0"
    };
    const Platform.SR_0//  = Any {
        name: "SR_0",
        space: "data",
        access: "RWX",
        base: 0x8E000000,
        len: 0x1000000,
        comment: "SR#0 Memory (16 MB)"
    };
per-instance config parameters
    var params = new Platform.Params// Instance config-params object;
        params.codeMemory// The default segment for code sections = String undefined;
        params.dataMemory// The default segment for data sections = String undefined;
            [
                "EXT_RAM",
                {
                    comment: "2 GB External RAM Memory",
                    name: "EXT_RAM",
                    base: 0x80000000,
                    len: 0x80000000
                }
            ]
        ];
        params.l1DMode//  = String "32k";
        params.l1PMode//  = String "32k";
        params.l2Mode//  = String "0k";
        params.renameMap// A map for renaming memory objects = String[string] undefined;
        params.sectMap// A mapping of linker output section names to memory segments = String[string] undefined;
        params.stackMemory// The default segment for stack = String undefined;
per-instance creation
    var inst = Platform.create// Create an instance-object(String name, params);
per-instance functions
 
DETAILS
This module implements xdc.platform.IPlatform and defines configuration parameters that correspond to this platform's Cpu's, Board's, etc.
The configuration parameters are initialized in this package's configuration script (package.cfg) and "bound" to the TCOM object model. Once they are part of the model, these parameters are queried by a program's configuration script.
This particular platform has 1 Cortex-A15, 2 Benelli/IPU Sub-system (Dual M4's) and 2 C66x DSP's.
 
struct Platform.Board

Board-level description

Configuration settings
var obj = new Platform.Board;
 
    obj.id = String  ...
    // unique id within the platform
    obj.boardName = String  ...
    // name of the board
    obj.boardFamily = String  ...
    // optional family name
    obj.boardRevision = String  ...
    // optional revision string
 
 
struct Platform.Memory

A named contiguous range of addresses

Configuration settings
var obj = new Platform.Memory;
 
    obj.comment = String  ...
    // description of this block
    obj.name = String  ...
    // name of memory segment
    obj.space = String  ...
    // "code", "data", "code/data", etc...
    obj.page = UInt  ...
    // page of memory segment
    obj.base = UInt  ...
    // base address of memory segment
    obj.len = UInt  ...
    // length of memory segment
    obj.access = String  ...
    // attributes of memory: "RWX"
    obj.cacheable = Bool  ...
    // Is this block cacheable?
    obj.cacheAttrs = Any  ...
    // Device specific MMU attributes
 
DETAILS
Memory structures are used in the description of the memory available from CPUs and platforms.
 
config Platform.BOARD  // module-wide
Configuration settings
const Platform.BOARD = IPlatform.Board {
    id: "0",
    boardName: "evmAM572X",
    boardFamily: "evmAM572X",
    boardRevision: null
};
 
 
config Platform.DSP  // module-wide
Configuration settings
const Platform.DSP = IExeContext.Cpu {
    id: "0",
    clockRate: 700,
    catalogName: "ti.catalog.c6000",
    deviceName: "DRA7XX",
    revision: "1.0"
};
 
 
config Platform.DSP1  // module-wide
Configuration settings
const Platform.DSP1 = Any {
    externalMemoryMap: [
        [
            "DSP1_PROG",
            {
                name: "DSP1_PROG",
                space: "code/data",
                access: "RWX",
                base: 0x8C000000,
                len: 0x1000000,
                comment: "DSP1 Program Memory (16 MB)"
            }
        ],
        [
            "SR_0",
            Platform.SR_0
        ]
    ],
    codeMemory: "DSP1_PROG",
    dataMemory: "DSP1_PROG",
    stackMemory: "DSP1_PROG",
    l1DMode: "32k",
    l1PMode: "32k",
    l2Mode: "128k"
};
 
 
config Platform.DSP2  // module-wide
Configuration settings
const Platform.DSP2 = Any {
    externalMemoryMap: [
        [
            "DSP2_PROG",
            {
                name: "DSP2_PROG",
                space: "code/data",
                access: "RWX",
                base: 0x8D000000,
                len: 0x1000000,
                comment: "DSP2 Program Memory (16 MB)"
            }
        ],
        [
            "SR_0",
            Platform.SR_0
        ]
    ],
    codeMemory: "DSP2_PROG",
    dataMemory: "DSP2_PROG",
    stackMemory: "DSP2_PROG",
    l1DMode: "32k",
    l1PMode: "32k",
    l2Mode: "128k"
};
 
 
config Platform.GPP  // module-wide
Configuration settings
const Platform.GPP = IExeContext.Cpu {
    id: "3",
    clockRate: 1500.0,
    catalogName: "ti.catalog.arm.cortexa15",
    deviceName: "DRA7XX",
    revision: "1.0"
};
 
 
config Platform.HOST  // module-wide
Configuration settings
const Platform.HOST = Any {
    externalMemoryMap: [
        [
            "HOST_PROG",
            {
                name: "HOST_PROG",
                space: "code/data",
                access: "RWX",
                base: 0x8B000000,
                len: 0x1000000,
                comment: "HOST Program Memory (16 MB)"
            }
        ],
        [
            "SR_0",
            Platform.SR_0
        ]
    ],
    codeMemory: "HOST_PROG",
    dataMemory: "HOST_PROG",
    stackMemory: "HOST_PROG"
};
 
 
config Platform.IPU1  // module-wide
Configuration settings
const Platform.IPU1 = Any {
    externalMemoryMap: [
        [
            "IPU1_PROG",
            {
                name: "IPU1_PROG",
                space: "code/data",
                access: "RWX",
                base: 0x8A000000,
                len: 0x800000,
                comment: "IPU1 Program Memory (8 MB)"
            }
        ],
        [
            "SR_0",
            Platform.SR_0
        ]
    ],
    codeMemory: "IPU1_PROG",
    dataMemory: "IPU1_PROG",
    stackMemory: "IPU1_PROG"
};
 
 
config Platform.IPU2  // module-wide
Configuration settings
const Platform.IPU2 = Any {
    externalMemoryMap: [
        [
            "IPU2_PROG",
            {
                name: "IPU2_PROG",
                space: "code/data",
                access: "RWX",
                base: 0x8A800000,
                len: 0x800000,
                comment: "IPU2 Program Memory (8 MB)"
            }
        ],
        [
            "SR_0",
            Platform.SR_0
        ]
    ],
    codeMemory: "IPU2_PROG",
    dataMemory: "IPU2_PROG",
    stackMemory: "IPU2_PROG"
};
 
 
config Platform.M4  // module-wide
Configuration settings
const Platform.M4 = IExeContext.Cpu {
    id: "1",
    clockRate: 212.8,
    catalogName: "ti.catalog.arm.cortexm4",
    deviceName: "DRA7XX",
    revision: "1.0"
};
 
 
config Platform.SR_0  // module-wide
Configuration settings
const Platform.SR_0 = Any {
    name: "SR_0",
    space: "data",
    access: "RWX",
    base: 0x8E000000,
    len: 0x1000000,
    comment: "SR#0 Memory (16 MB)"
};
 
Instance Config Parameters

Configuration settings
var params = new Platform.Params;
// Instance config-params object
    params.codeMemory = String undefined;
    // The default segment for code sections
    params.customMemoryMap = IPlatform.Memory[string] undefined;
    // A custom mapping of memory names to memory objects
    params.dataMemory = String undefined;
    // The default segment for data sections
    params.externalMemoryMap = IPlatform.Memory[string] [
    // Memory regions as defined in the AM572X Specification
        [
            "EXT_RAM",
            {
                comment: "2 GB External RAM Memory",
                name: "EXT_RAM",
                base: 0x80000000,
                len: 0x80000000
            }
        ]
    ];
    params.l1DMode = String "32k";
    // 
    params.l1PMode = String "32k";
    // 
    params.l2Mode = String "0k";
    // 
    params.renameMap = String[string] undefined;
    // A map for renaming memory objects
    params.sectMap = String[string] undefined;
    // A mapping of linker output section names to memory segments
    params.stackMemory = String undefined;
    // The default segment for stack
 
config Platform.Params.codeMemory  // instance

The default segment for code sections

Configuration settings
var params = new Platform.Params;
  ...
params.codeMemory = String undefined;
 
DETAILS
Each target has a section map with keys equal to the names of all sections that compiler and assembler for that target generate. The value for each key is either "code" or "data" or "stack". A linker template reads that map and puts all "code" sections in the segment defined by this configuration parameter.
SEE
 
config Platform.Params.customMemoryMap  // instance

A custom mapping of memory names to memory objects

Configuration settings
var params = new Platform.Params;
  ...
params.customMemoryMap = IPlatform.Memory[string] undefined;
 
DETAILS
This parameter allows platform instances to completely overwrite a default memory map based on the internal memory map coming from CPU's memory map and externalMemoryMap.
Custom memory map must fit within the default memory map, unless the verification of the fit is disabled (see xdc.platform).
 
config Platform.Params.dataMemory  // instance

The default segment for data sections

Configuration settings
var params = new Platform.Params;
  ...
params.dataMemory = String undefined;
 
DETAILS
Each target has a section map with keys equal to the names of all sections that compiler and assembler for that target generate. The value for each key is either "code" or "data" or "stack". A linker template reads that map and puts all "data" sections in the segment defined by this configuration parameter.
SEE
 
config Platform.Params.externalMemoryMap  // instance

Memory regions as defined in the AM572X Specification

Configuration settings
var params = new Platform.Params;
  ...
const params.externalMemoryMap = IPlatform.Memory[string] [
    [
        "EXT_RAM",
        {
            comment: "2 GB External RAM Memory",
            name: "EXT_RAM",
            base: 0x80000000,
            len: 0x80000000
        }
    ]
];
 
DETAILS
This parameter defines the external portion of the platform's memory map.
 
config Platform.Params.l1DMode  // instance
Configuration settings
var params = new Platform.Params;
  ...
params.l1DMode = String "32k";
 
 
config Platform.Params.l1PMode  // instance
Configuration settings
var params = new Platform.Params;
  ...
params.l1PMode = String "32k";
 
 
config Platform.Params.l2Mode  // instance
Configuration settings
var params = new Platform.Params;
  ...
params.l2Mode = String "0k";
 
 
config Platform.Params.renameMap  // instance

A map for renaming memory objects

Configuration settings
var params = new Platform.Params;
  ...
params.renameMap = String[string] undefined;
 
DETAILS
This map renames memory objects. If you do not want to change addresses in the default memory map, but you only want to rename the existing memory objects, you should use this parameter.
This map and customMemoryMap should not be used together because this map renames the default memory, but then customMemoryMap replaces the default memory objects. The parameters codeMemory, dataMemory and stackMemory are not automatically reassigned to new names. It is the user's responsibility to set those parameters accordingly to renameMap.
 
config Platform.Params.sectMap  // instance

A mapping of linker output section names to memory segments

Configuration settings
var params = new Platform.Params;
  ...
params.sectMap = String[string] undefined;
 
DETAILS
During the generation of linker command files, the templates used to create these files examine several sources of information to determine the placement of named output sections into memory segments defined by the platform. The default placement, described below, uses information from the target and this platform's codeMemory, dataMemory, and stackMemory configuration parameters.
sectMap is used to override this default placement of output sections (".text", ".cinit", etc.) to a memory segment defined by the platform's memory map. For example, even if a platform's codeMemory parameter is defined to be "SRAM" and ".cinit" output sections are "code" sections, if the platform also defines the following sectMap, the section ".cinit" will be placed into a memory segment named "DDR2".
      sectMap[] = [
          [".cinit", "DDR2"],
      ];
NOTE
If an output section has an entry in Program.sectMap, that entry overrides the placement specified by this sectMap. A program's sectMap configuration always overrides the platform's sectMap settings.
DEFAULT MAPPING
The default placement of a target's output sections into memory segments defined by the platform is determined by the following configuration parameters:
  • ITarget.sectMap used to map a named output section to either "code", "data", or "stack"
  • codeMemory names a memory segment that will contain all "code" output sections
  • dataMemory names a memory segment that will contain all "data" output sections
  • stackMemory names a memory segment that will contain all "stack" output sections
SEE
 
config Platform.Params.stackMemory  // instance

The default segment for stack

Configuration settings
var params = new Platform.Params;
  ...
params.stackMemory = String undefined;
 
DETAILS
Each target has a section map with keys equal to the names of all sections that compiler and assembler for that target generate. The value for each key is either "code" or "data" or "stack". A linker template reads that map and puts all "stack" sections in the segment defined by this configuration parameter.
SEE
Static Instance Creation

Configuration settings
var params = new Platform.Params;
// Allocate instance config-params
params.config =   ...
// Assign individual configs
 
var inst = Platform.create(String name, params);
// Create an instance-object
ARGUMENTS
name — the name of the platform instance being created
This name is the suffix of the platform specification supplied in the build script after the platform name (and optional ':') prefix has been removed. So the platform instance name "joes.platform.foo:bar" results in the name "bar" and the name "joes.platform.foo" result in the name "".
 
Platform.getCpuDataSheet()  // instance

Get the Cpu data sheet object corresponding to specified cpu id

Configuration settings
inst.getCpuDataSheet(Any cpuId) returns Any
 
ARGUMENTS
cpuId — a string that corresponds to the platform-specific id of a CPU on this platform that runs executables.
DETAILS
This function executes in either the Configuration object model or the Build object model.
RETURNS
Returns an xdc.platform.ICpuDataSheet instance object that corresponds to the specified cpuId.
THROWS
Error exceptions are thrown for fatal errors.
 
Platform.getExeContext()  // instance

Get execution context object corresponding to the specified program

Configuration settings
inst.getExeContext(Any prog) returns Any
 
ARGUMENTS
prog — the xdc.cfg.Program object representing the program being configured.
This object contains the following properties that allows the platform to determine the appropriate Cpu object to return (if there is more than one): prog.build.cpuId, prog.build.cpuArgs, prog.build.target,
DETAILS
This is called before the program's configuration script runs to get the Cpu object that is assigned to the program's cpu field.
Note: that the build script for the program is responsible for specifying the CPU; this is done by either implicitly naming the platform or explicitly naming a particular CPU on the platform (see xdc.bld.Executable.Attrs.cpuId).
This function executes in the Configuration object model.
RETURNS
Returns an xdc.platform.IExeContext instance object that corresponds to the CPU that will run the specified program.
THROWS
Error exceptions are thrown for fatal errors.
 
Platform.getExecCmd()  // instance

Get the exec command used to run the program on this platform

Configuration settings
inst.getExecCmd(Any prog, Any platPath) returns Any
 
ARGUMENTS
prog — the xdc.cfg.Program object representing the program being configured.
This object contains the following properties that allows the platform to determine the appropriate Cpu object to return (if there is more than one): prog.build.cpuId, prog.build.cpuArgs, prog.build.target
platPath — full path to the platform package for the program
DETAILS
This function is called after the program's configuration script runs and returns commands that are used to load and run the specified program. These commands are placed in a makefile that is included by the client package's generated makefile. Thus, the commands may refer to macros defined in this environment; e.g., $(SHELL) and $(XDCROOT), etc.
The special macro $(1) expands to test-specific arguments (xdc.bld.Test.attrs.execArgs) that are passed from the test to the platform's exec command. Thus, all platforms that support arguments to their exec command, should embed "$(1)" within the command string at the appropriate place to have these arguments interpreted by the exec command.
For example, a platform that uses a shell script to run executables and allows options to be passed to the shell script might return the following string:
	    "$(SHELL) <exec_path> $(1) <exe_name>"
where, <exec_path> is the absolute path to the platform's exec shell script, and <prog_name> is the name of the executable relative to the package's base directory (i.e., xdc.cfg.Program.name).
This function executes in the Configuration object model.
RETURNS
Returns a string of commands used to execute this program in the context of the XDC generated makefiles.
THROWS
Error exceptions are thrown for fatal errors.
 
Platform.getLinkTemplate()  // instance

Get Linker Command file template used to link an executable

Configuration settings
inst.getLinkTemplate(Any prog) returns Any
 
ARGUMENTS
prog — the xdc.cfg.Program object representing the program being configured.
This object contains the following properties that allows the platform to determine the appropriate link template to return:
  • prog.build.cpuId,
  • prog.build.cpuArgs,
  • prog.build.target
DETAILS
In the event that no template is provided by the program configuration script (see xdc.cfg.Program.linkTemplate), the template file identified by this method is used to generate the linker command file used to create the executable.
This function executes in the Configuration object model and is called after the program configuration script runs. The template is expanded in the context of the Configuration Object Model.
RETURNS
Returns a path string to a template file or null. If null, no linker command file is generated; otherwise this path is relative to the package path.
THROWS
Error exceptions are thrown for fatal errors.
generated on Tue, 14 Feb 2017 20:00:56 GMT