Please note as of Wednesday, August 15th, 2018 this wiki has been set to read only. If you are a TI Employee and require Edit ability please contact x0211426 from the company directory.

BIOS MCSDK 1.0 User Guide

From Texas Instruments Wiki
Jump to: navigation, search

Important Note:

The software found on this site is available for download, but is no longer being actively developed. This wiki is in maintenance mode and the software is supported on C64x Multi-core E2E forum



BIOS Multicore Software Development Kit

Version 1.00.00

User's Guide

Last updated: 05/08/2016




Introduction

The BIOS Multicore Software Development Kit (MCSDK) provides the core foundational building blocks that facilitate application software development on TI's high performance and multicore DSPs. The foundational components include:

  • SYS/BIOS which is a light-weight real-time embedded operating system for TI devices
  • Chip support libraries, drivers, and basic platform utilities
  • Interprocessor communication for communication across cores and devices
  • Basic networking stack and protocols
  • Optimized application-specific and application non-specific algorithm libraries
  • Debug and instrumentation
  • Bootloaders and boot utilities
  • Demonstrations and examples


The purpose of this User's Guide is to provide more detailed information regarding the software elements and infrastructure provided with MCSDK. MCSDK pulls together all the elements into demonstrable multicore applications and examples for supported EVMs. The objective being to demonstrate device, platform, and software capabilities and functionality as well as provide the user with instructive examples. The software provided is intended to be used as a reference when starting their development.

NoteNote: It is expected the user has gone through the EVM Quick Start Guide provided with their EVM and have booted the out-of-box demonstration application flashed on the device. It is also assumed the user has gone through the MCSDK Getting Started Guide and have installed both CCS and the MCSDK.

Acronyms and Definitions

The following acronyms are used throughout this document.

Acronym Meaning
AMC Advanced Mezzanine Card
CCS Texas Instruments Code Composer Studio
CSL Texas Instruments Chip Support Library
DDR Double Data Rate
DHCP Dynamic Host Configuration Protocol
DSP Digital Signal Processor
EDMA Enhanced Direct Memory Access
EEPROM Electrically Erasable Programmable Read-Only Memory
EVM Evaluation Module, hardware platform containing the Texas Instruments DSP
HUA High Performance Digital Signal Processor Utility Application
HTTP HyperText Transfer Protocol
IP Internet Protocol
IPC Texas Instruments Inter-Processor Communication Development Kit
JTAG Joint Test Action Group
MCSDK Texas Instruments Multi-Core Software Development Kit
NDK Texas Instruments Network Development Kit (IP Stack)
NIMU Network Interface Management Unit
PDK Texas Instruments Programmers Development Kit
RAM Random Access Memory
RTSC Eclipse Real-Time Software Components
SRIO Serial Rapid IO
TCP Transmission Control Protocol
TI Texas Instruments
UART Universal Asynchronous Receiver/Transmitter
UDP User Datagram Protocol
USB Universal Serial Bus


NoteNote: We use the abbreviation TMS when referring to a specific TI device (processor) and the abbreviation TMD when referring to a specific platform that the processor is on. For example, TMS320C6457 refers to the C6457 DSP processor and TMDSEVM6457L refers to the actual hardware EVM that the processor is on.


Supported Devices/Platforms

  • C6472: This release supports the Texas Instruments TMS320C6472 high performance DSP; the EVM supported by the software is TMDSEVM6472.
  • C6457: This release supports the Texas Instruments TMS320C6457 high performance DSP; the EVM supported by the software is TMDSEVM6457L.
  • C6474: This release supports the Texas Instruments TMS320C6474 high performance DSP; the EVM supported by the software is TMDSEVM6474L.


Getting Started Guides

The getting started guides walk you through setting up your EVM and running the "Out of Box" Demonstration application. This is where you should start after receiving your EVM.

Document Description
MCSDK Release Notes Contains latest information on the release including what’s changed, known issues and compatibility information. Each foundational component will have individual release notes as well.
MCSDK Getting Started Guide Discusses how to install the BIOS-MCSDK and access the demonstration application.
TMDSEVM6472 Quick Setup Guide Quick Setup Guides showing how to set up the EVM and run the Out of Box demonstration application from flash.
TMS320C6474L Quick Setup Guide
TMDSEVM6457L Quick Setup Guide



Hardware Overview

EVM

The following documents provide information about the EVM.

Document Description
TMDSEVM6472 Technical Reference Manual Discusses the technical aspects of your EVM including board block diagram, DIP Switch Settings, memory addresses and range, power supply and basic operation.
TMDSEVM6474L Technical Reference Manual
TMDSEVM6457L Technical Reference Manual

Processor

The following documents provide information about the processor used on the EVM.

Document Description
TMS320C6472 Data Manual Data manual for specific TI DSP
TMS320C6474 Data Manual
TMS320C6457 Data Manual


Package Overview

A Package represents an individual piece of functionality that is installed either by BIOS-MCSDK or CCS. The following Packages are installed as they pertain to BIOS-MCSDK.


Packages
Platform Package Contains the platform library, platform/EVM specific software, applications, CCS configuration files and other board specific collaterals.
Platform Development Kit Package Contains device specific software consisting of a Chip Support Library (CSL) and Low Level Drivers (LLD) for various peripherals. Both the CSLs and LLDs include example projects and examples within the relevant directories which can be used with CCS.
EDMA3 LLD Package Contains the EDMA3 driver.
SYS/BIOS Package Contains the SYS/BIOS operating system.
Interprocessor Communication Package Contains the Interprocessor Communication framework.
Network Developer's Kit (NDK) Package Contains the NDK, which provides an IP stack and other network services.


Software Overview

The MCSDK is comprised of the foundational software infrastructure elements intended to enable development of application software on TI high-performance and multicore DSPs.


MCSDK100SoftwareStack.jpg


As can be seen in the architecure diagram, the MCSDK consists of those components in the yellow boxes. Specifically they are:

  • Chip Support Library
  • EDMA3 Low Level Driver
  • Ethernet Low Level Driver
  • NIMU Driver
  • Platform Library
  • Boot loader, POST and Utilities
  • SYS/BIOS
  • Interprocessor Communication Package
  • Network Developer's Kit (NDK) Package

Also available separately, and shown in the green boxes in the architecure diagram, are multiple optimized algorithm libraries:

  • DSPLIB: Optimized digital signal processing algorithms including FFT, adaptive filtering, filtering, and convolution.
  • IMGLIB: Optimized image and video processing algorithms including convolution, correlation, edge detection, median filtering, and morphological operations.
  • FastRTS: Optimized floating point math function library including atan, cos, sin, exp, log, power, sqrt, and reciprocal operations.
  • IQMath: Optimized fixed point math function library including atan, cos, sin, exp, log, power, sqrt, and reciprocal operations.
  • M-STK: Optimized functions for medical applications including ultrasound and OCT.
  • VoLIB: Optimized and field hardened voice processing components including echo cancellation, tone detection, caller ID, Voice Activity detection, packet loss concealment, noise matching.
  • FaxLIB: Optimized and field hardened T.38 fax and fax modem components.



Chip Support Library (CSL)

The Chip Support Library constitutes a set of well-defined APIs that abstract low-level details of the underlying SoC device so that a user can configure, control (start/stop, etc.) and have read/write access to peripherals without having to worry about register bit-field details. The CSL services are implemented as distinct modules that correspond with the underlying SoC device modules themselves. By design, CSL APIs follow a consistent style, uniformly across Processor Instruction Set Architecture and are independent of the OS. This helps in improving portability of code written using the CSL.

CSL is realized as twin-layer – a basic register-layer and a more abstracted functional-layer. The lower register layer comprises of a very basic set of macros and type definitions. The upper functional layer comprises of “C” functions that provide an increased degree of abstraction, but intended to provide “directed” control of underlying hardware.

It is important to note that CSL does not manage data-movement over underlying h/w devices. Such functionality is considered a prerogative of a device-driver and serious effort is made to not blur the boundary between device-driver and CSL services in this regard.

CSL does not model the device state machine. However, should there exist a mandatory (hardware dictated) sequence (possibly atomically executed) of register reads/writes to setup the device in chosen “operating modes” as per the device datasheet, then CSL does indeed support services for such operations.

The CSL services are decomposed into modules, each following the twin-layer of abstraction described above. The APIs of each such module are completely orthogonal (one module’s API does not internally call API of another module) and do not allocate memory dynamically from within. This is key to keeping CSL scalable to fit the specific usage scenarios and ease the effort to ROM a CSL based application.

The source code of the CSL is located under $(TI_PDK_INSTALL_DIR)\components directory.

Chip Support Library Summary
Component Type Library
Install Package PDK
Install Directory pdk_c64x_<version>\packages\ti\csl
Project Type CCS
Endian Support Little and Big
Library Name

Select for the EVM you are using
csl_c6472.lib (little) or csl_c6472e.lib (big)
csl_c6474.lib (little) or csl_c6474e.lib (big)
csl_c6457.lib (little) or csl_c6457e.lib (big)

Linker Path $(TI_PDK_INSTALL_DIR)\packages\ti\csl\{c6472,c6457,c6474}\csl_{c6472,c6457,c6474}\lib
Linker Sections .vecs , .switch, .args, .cio
Section Preference L2 Cache
Include Paths $(TI_PDK_INSTALL_DIR)\packages\ti\csl\{c6472,c6457,c6474}\csl_{c6472,c6457,c6474}\inc
Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources Chip support library
Downloads Product Updates
License BSD




EMAC Low Level Driver (LLD)

The EMAC driver provides a well defined API layer which allows applications to use the EMAC peripheral to control the flow of packet data from the processor to the PHY and the MDIO module to control PHY configuration and status monitoring.

The EMAC driver is designed to meet the following requirements:

  • Support multiple EMAC ports (if available on the device) per core.
  • Support multiple channels/MAC addresses per core.
  • Support multiple cores to use different channels on the same EMAC port.
  • The driver is OS independent and exposes all the operating system callouts via the OSAL layer.
  • EMAC example test application provides standard configurations and demonstrates measureable benchmarks.
The functional architecure for the driver is shown below.
Etharch.png
EMAC Driver Summary
Component Type Library
Install Package PDK
Install Directory pdk_c64x_<version>\packages\ti\drv\emac
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name

Select for the EVM you are using:
emac_drv_c6472.lib (little) or emac_drv_c6472e.lib (big)
emac_drv_c6474.lib (little) or emac_drv_c6474e.lib (big)
emac_drv_c6457.lib (little) or emac_drv_c6457e.lib (big)

Linker Path $(TI_PDK_INSTALL_DIR)/packages\ti\drv\emac\lib
Linker Sections .far:EMAC_DRV , emacComm
Section Preference L2 Cache (shared L2 for emacComm)
Include Paths $(TI_PDK_INSTALL_DIR)/packages\ti\drv\emac\src\inc
Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources Texas Instruments Embedded Processors Wiki
Downloads Product Updates
License BSD




EDMA3 Low Level Driver (LLD)

EDMA3 Low Level Driver is targeted to users (device drivers and applications) for submitting and synchronizing EDMA3-based DMA transfers.

EDMA3 is a peripheral that supports data transfers between two memory mapped devices. It supports EDMA as well as QDMA channels for data transfer. This peripheral IP is re-used in different SoCs with only a few configuration changes like number of DMA and QDMA channels supported, number of PARAM sets available, number of event queues and transfer controllers etc. The EDMA3 peripheral is used by other peripherals for their DMA needs thus the EDMA3 Driver needs to cater to the requirements of device drivers of these peripherals as well as other application software that may need to use DMA services.

The EDMA3 LLD consists of an EDMA3 Driver and EDMA3 Resource Manager. The EDMA3 Driver provides functionality that allows device drivers and applications for submitting and synchronizing with EDMA3 based DMA transfers. In order to simplify the usage, this component internally uses the services of the EDMA3 Resource Manager and provides one consistent interface for applications or device drivers.

EDMA3 Driver Summary
Component Type  
Install Package  
Install Directory  
Project Type  
Endian Support  
Library Name  
Linker Path  
Linker Sections  
Section Preference  
Include Paths  
Reference Guides  
Support Technical Support
Additional Resources Programming the EDMA3 using the Low-Level Driver (LLD)
Downloads Product Updates
License BSD


Platform Library

The platform library defines a standard interface for platform utilities and functionality and provides sample implementations for the EVM platform. These include things such as reading and writing to EEPROM, FLASH, UART, etc.

Platform Library Summary
Component Type Library
Install Package MCSDK
Install Directory mcsdk_<version>\packages\ti\platform
Project Type CCS
Endian Support Little and Big
Library Name Must re-build for big as same name. Select for the EVM you are using.

platform_utils_evm6472.lib (little)
platform_utils_evm6474l.lib (little)
platform_utils_evm6457l.lib (little)

Linker Path $(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\lib
Linker Sections none
Section Preference none
Include Paths $(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\inc

platform_utils.h defines the interface

Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources Texas Instruments Embedded Processors Wiki
Downloads Product Updates
License BSD


SYS/BIOS

SYS/BIOS is a scalable real-time kernel. It is designed to be used by applications that require real-time scheduling and synchronization or realtime instrumentation. SYS/BIOS provides preemptive multi-threading, hardware abstraction, real-time analysis, and configuration tools. SYS/BIOS is designed to minimize memory and CPU requirements on the target.

SYS/BIOS Summary
Component Type Libraries
Install Package SYS/BIOS
Install Directory bios_6_<version>\
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name The appropriate libraries are selected for your device and platform as set in the RTSC build properties for your project and based on the use module statements in your configuration.
Linker Path The appropriate path is selected to the libraries for your device and platform as set in the RTSC build properties for your project.
Linker Sections N/A
Section Preference N/A
Include Paths

BIOS_CG_ROOT is set automatically by CCS based on the version of BIOS you have checked to build with.
${BIOS_CG_ROOT}\packages\ti\bios\include

Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources Eclipse RTSC Home
Downloads

SYS/BIOS Downloads

License BSD


Interprocessor Communication

Inter-Processor Communication (IPC) provides communication between processors in a multi-processor environment, communication to other threads on same processor, and communication to peripherals. It includes message passing, streams, and linked lists.

IPC can be used to communicate with the following:

  • Other threads on the same processor
  • Threads on other processors running SYS/BIOS
  • Threads on GPP processors running SysLink (e.g., Linux)
IPC Summary
Component Type Libraries
Install Package IPC
Install Directory ipc_<version>\
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name The appropriate libraries are selected for your device and platform as set in the RTSC build properties for your project and based on the use module statements in your configuration.
Linker Path The appropriate path is selected to the libraries for your device and platform as set in the RTSC build properties for your project.
Linker Sections  
Section Preference  
Include Paths  
Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources Eclipse RTSC Home
Downloads IPC Downloads
License BSD


XDC

RTSC is a C-based programming model for developing, delivering, and deploying Real-Time Software Components targeted for embedded platforms. The XDCtools product includes tooling and runtime elements for component-based programming using RTSC.

XDC Summary
Component Type Tools
Install Package XDC
Install Directory xdctools_<version>\
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name The appropriate libraries are selected for your device and platform as set in the RTSC build properties for your project and based on the use module statements in your configuration.
Linker Path The appropriate path is selected to the libraries for your device and platform as set in the RTSC build properties for your project.
Linker Sections systemHeap
Section Preference none
Include Paths  
Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources

Eclipse RTSC Home
Users Guide and Reference Manual

Downloads  
License See XDC Manifest in the install directory


Network Development Kit (NDK)

The NDK is a platform for development and demonstration of network enabled applications on DSP devices and includes demonstration software showcasing DSP capabilities across a range of network enabled applications. The NDK serves as a rapid prototype platform for the development of network and packet processing applications, or to add network connectivity to existing DSP applications for communications, configuration, and control. Using the components provided in the NDK, developers can quickly move from development concepts to working implementations attached to the network.

The NDK provides an IPv6 and IPv4 compliant TCP/IP stack working with the SYS/BIOS real-time operating system. Its primary focus is on providing the core Layer 3 and Layer 4 stack services along with additional higher-level network applications such as HTTP server and DHCP.

The NDK itself does not include any platform or device specific software. The NDK interfaces through well-defined interfaces to the PDK and platform software elements needed for operation.

The functional architecure for NDK is shown below.
Ndkarch.png
Network Development Kit Summary
Component Type Libraries
Install Package NDK
Install Directory ndk_<version>\
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name

binsrc.lib or binsrce.lib
and
cgi.lib or cgie.lib
and
console.lib or consolee.lib
and
hdlc.lib or hdlce.lib
and
miniPrintf.lib or miniPrintfe.lib
and
netctrl.lib or netctrle.lib
and
nettool.lib or nettoole.lib
and
os.lib or ose.lib
and
servers.lib or serverse.lib
and
stack.lib or stacke.lib

Linker Path $(NDK_INSTALL_DIR)\packages\ti\ndk\lib\<arch>
Linker Sections .far:NDK_OBJMEM, .far:NDK_PACKETMEM
Section Preference L2 Cache
Include Paths NDK_INSTALL_DIR is set automatically by CCS based on the version of NDK you have checked to build with.

${NDK_INSTALL_DIR}\packages\ti\ndk\inc
${NDK_INSTALL_DIR}\packages\ti\ndk\inc\tools

Reference Guides See docs under Install Directory
Support Technical Support
Additional Resources The NDK unit test examples are available in
$(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\nimu\test\evm####
Extended Support

Eclipse RTSC Home
NDK User's Guide
NDK Programmer's Reference Guide
NDK Support Package Ethernet Driver Design Guide
NDK FAQ
Rebuilding NDK Core

Downloads NDK Downloads
License BSD


Network Interface Management Unit (NIMU)

NIMU sits between NDK common software and the EMAC LLD and provides a common interface for NDK to communicate with. This package have NDK unit test examples for all supported platforms.


NoteNote: This module is only intended to be used with NDK. As such, users should not tie up to its API directly.

NIMU Summary
Component Type Library
Install Package MCSDK
Install Directory mcsdk_<version>\packages\ti\platform\nimu
Project Type Eclipse RTSC
Endian Support Little and Big
Library Name nimu_eth.lib (little) or nimu_ethe.lib (big)
Linker Path $(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\nimu\lib
Linker Sections None
Section Preference None
Include Paths $(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\nimu\src\inc
Reference Guides See EMAC LLD or NDK Documents
Support Technical Support
Additional Resources The NDK unit test examples are available in
$(TI_MCSDK_INSTALL_DIR)\packages\ti\platform\nimu\test\evm####
Downloads http://focus.ti.com/docs/toolsw/folders/print/bioslinuxmcsdk.html
License BSD


Bootloader and Boot Utilities

The platform package includes POST (power on self test), bootloader software and utilities to write images to the EEPROM and NAND Flash.

Demonstration Software

The MCSDK consist of demonstration software to illustrate device and software capabilities, benchmarks, and usage.

High-Performance DSP Utility Application (HUA)

HUA is the MCSDK out-of-box demonstration/utility application which includes a web server and has pages to query information about the platform and software versions, network statistics, network throughput benchmark, board diagnostics, flash read and write, and EEPROM read and write functions. This is a basic utility application which demonstrates basic platform functionality and how to integrate some of the basic software infrastructure (e.g., SYS/BIOS, NDK, Platform Library). The utility is accessed from a PC web browser.

Tools Overview

The following documents provide information on the various development tools available to you.

Document Description
CCS v4 Getting Started Guide How to get up and running with CCS v4
TMS320C6000 Optimizing Compiler v 7.0 Users Guide Everything you wanted to know about the compiler, assembler, library-build process and C++ name demangler.
TMS320C6000 Assembly Language Tools v 7.0 More in-depth information on the assembler, linker command files and other utilities.


High Performance DSP Utility Application (HUA)

The High Performance DSP Utility Application (HUA) is the Out-of-Box (OOB) demo for the MCSDK which demonstrates, through illustrative code and web pages, how you can interface your own DSP application to the various TI MCSDK software elements including SYS/BIOS, Network Development Kit (NDK), the Chip Support Library (CSL), and Platform Library.

Software Architecture

HUA Architecture

The high level software architecture for the HUA is shown in Figure 2.

As can be seen in the diagram, the Utility provides an HTTP and Telnet Server. These servers use standard socket interfaces to the IP stack (NDK) which in turn interfaces to the Ethernet through the NIMU and EMAC Driver components.

The HTTP server serves pages that allow either various operations to be performed on the EVM (e.g., diagnostics) or provide information (e.g., statistics). The web pages are either dynamically created through a CGI-BIN interface (.cgi) or are static pages that are served directly back (.html).


Tasks

As this is an embedded system, it uses SYS/BIOS to provide tasking and OS primitives such as semaphores, timers and so forth. The main thread is the task hpdspuaStart. This task will configure the IP stack and bring the system up into a free running state.


NoteNote: The main for the Utility simply start SYS/BIOS. SYS/BIOS in turn will run the task.


Platform Initialization

Platform initialization is performed by a function within the utility called EVM_init(). This function is configured to be called by SYS/BIOS before it starts up. Platform initialization configures DDR, the I2C bus, clocking and all other items that are platform dependent.


Building the Application

See High Performance DSP Utility Application Users Guide for the steps to building the application. The Guide is accessible from Eclipse Help or can be found in the doc directory inside the hpdspua project.

EVM Booting

The MCSDK includes a Boot Package which provides boot loaders and boot utilities for use with the TI EVMs and are intended to serve as example/reference for customers.

The MCSDK Boot Package is located in the mcsdk_1_00_00_xx\packages\ti\platform\evmxxxx\bootloader_package directory and includes:

  • NAND Secondary Bootloader: Bootloader for booting an application from the NAND flash.
  • POST: Executes a Power-On Self Test.
  • Boot Utilities: Converting and loading images to EEPROM and NAND Flash.


NoteNote: Only Common Object File Format (COFF) images are supported for booting.


The sections below provide an overview of the different supported EVM boot modes as well as processes for flashing software onto the EEPROM and NAND using the provided boot utilities.

Boot Mode Overview

The bootloading process is a multi-stage process. On power to the EVM, a Chip ROM boot loader is executed. This boot loader will load an image from the EEPROM, depending upon the DIP switch settings, and execute it. The switch settings supported by the MCSDK are boot from EEPROM address (0x50) or boot from EEPROM address (0x51). The EVM is shipped with EEPROM (address 0x51) flashed with the NAND secondary bootloader, and EEPROM (address 0x50) flashed with POST. POST (Power On Self Test) is a small application that tests a minimum set of EVM components.


NoteNote: The actual boot sequence is controlled by the DIP switch settings and there will be several boot modes available. The POST and NAND Boot modes are provided on the EVM and thus are the only ones talked about in this document. Refer to the Hardware Technical Reference (Data Manual) for your EVM for other possible boot modes supported by the device.


NAND Boot

NAND Boot
NAND boot is a multi-stage process which is designed to boot an application from NAND flash after reset. Figure 3 illustrates the elements of the NAND boot process.

On reset the DSP starts execution with the bootrom which transfers execution to the NAND secondary bootloader from EEPROM using the I2C slave address 0x51. The secondary NAND bootloader loads the application program from NAND flash then transfers control to the application. To execute the NAND bootloader you must ensure the DIP switches for your platform are properly configured for I2C Master Boot B or address 51h (refer to the Data Manual for switch settings).

NAND secondary boot sequence:

  1. Switch ON EVM LEDs to indicate successful I2C boot.
  2. Initialize DDR2 and read the bad block table from NAND flash block 0 and page 0.
  3. Search the NAND starting from block 1 for the structure that provides information about the application (.out file).
  4. Copy the application (.out file) from NAND flash to DDR2 buffer. The number of NAND pages to read, start block and start page addresses are read from the structure.
  5. Parse the .out file from the DDR2 buffer and load the sections of the application to their respective load addresses.
  6. Switch OFF the EVM LEDs to indicate that the application is successfully loaded.
  7. Call the application entry point using a function pointer.
  8. The EVM LEDs will remain ON if the NAND secondary bootloader fails to load the application.


Flash Layout


The typical layout for the flash is shown in the picture below.

Flash.png

Block 0 Page 0 is used for the bad block table. The bootable image (the one loaded by the NAND Boot loader) is stored starting at Block 1. Note: If Block 1 is bad then it starts at 2 and so forth.


POST

The Power-On Self Test (POST) boot is designed to execute a series of platform/EVM factory tests on reset (e.g., memory test, ethernet loopback) and indicate a PASS/FAIL condition using the LEDs. At power on, the DSP starts execution with bootrom which transfers execution to the POST boot program from EEPROM using the I2C slave address as 0x50. The POST will run through a sequence of platform tests. Upon power on, the EVM LEDs will be off by default, turn ON after approximately 4 sec to indicate sucessful boot, remain ON for approximately 3 sec, then turn OFF. On successful execution of the memory test and EMAC loopback tests EVM LED-1 and LED-2 are turned on respectively.


NoteNote: To execute the POST you must ensure the DIP switches for your platform are properly configured.


On newer platforms the POST will put board information on the UART console.

Postresult.png

Host Boot Utilities and Recovery Procedures

The following boot utilities for loading code into the EEPROM and NAND are provided as part of the Boot Package with the MCSDK. All source code is provided along with documentation so that customers can port to other environments as necessary or to make modifications and enhancements.

  • EEPROM_flash_image_gen: Utility which converts either the NAND bootloader or POST out files into an image format that can be writtent to the EEPROM using the I2C_EEPROM_writer. This utility is specific to Microsoft Windows and generates an image format that MUST be loaded into CCS memory.
  • I2C_EEPROM_writer: Utility for writing an image to the I2C EEPROM. This utility executes on the EVM using CCS and JTAG.
  • Nandwriter: Utility for writing to the NAND flash. This utility executes on the EVM using CCS and JTAG.

These utilities are used to recover the board from corrupted EEPROM or FLASH. The detail procedures are provided below.


Flashing I2C EEPROM (address 0x50) with POST boot

Perform the following steps to flash the POST boot program to I2C EEPROM (address 0x50):

  1. Build the POST application. The steps to build the application are documented in the ReadMe.txt file located in the project directory.
  2. Create an I2C EEPROM flash image (.dat file) using the EEPRM_flash_image_gen utility.
    • Copy the COFF application file which needs to be flashed into EEPROM after successful build to <EEPROM_flash_image_gen\I2Cboot\input> folder.
    • Open EEPROM_flash_image_gen <EEPROM_flash_image_gen\I2Cboot\input\simple.rmd> file and change the name of the .out input file on the first line as per your application name.
    • Change the 5th line of <i2cconfig.txt> file to specify the I2C address for the EEPROM where the image is to be written: 0x00800050 for I2C slave address 0x50.
    • Double click <EEPROM_flash_image_gen\I2Cboot\I2Cboot.bat> file to generate the flash image i2cromdsp.dat in <EEPROM_flash_image_gen\I2Cboot\output>.
  3. Flash this EEPROM image to EEPROM using I2C_EEPROM_writer utility
    • Open CCS
    • Build and load the I2C_EEPROM_writer application. The steps to build the application are documented in the ReadMe.txt file located in the project directory. Ensure that the macro EEPROM_SLAVE_ADDR is set to EEPROM_SLAVE_ADDR_50.
    • Open a memory view (view->memory)
    • Select the Load option from the drop down list of the toolbar of the memory view and browse to the <EEPROM_flash_image_gen\I2Cboot\output> directory and select i2cromdsp.dat. Then select Use the file header... check box. This will load the data file into DSP memory.
    • Run the project (Press F8)
    • On successful execution you will get the message: "I2C EEPROM written successfully".


Flashing I2C EEPROM (address 0x51) with NAND bootloader

Perform the following steps to flash the NAND secondary bootloader to I2C EEPROM (address 0x51):

  1. Build the nandboot application. The steps to build the application are documented in the ReadMe.txt file located in the project directory.
  2. Create an I2C EEPROM flash image (.dat file) using the EEPRM_flash_image_gen utility.
    • Copy the COFF application file which needs to be flashed into EEPROM after successful build to <EEPROM_flash_image_gen\I2Cboot\input> folder.
    • Open EEPROM_flash_image_gen <EEPROM_flash_image_gen\I2Cboot\input\simple.rmd> file and change the name of the .out input file on the first line as per your application name.
    • Change the 5th line of <i2cconfig.txt> file to specify the I2C address for the EEPROM where the image is to be written: 0x00800051 for I2C slave address 0x51.
    • Double click <EEPROM_flash_image_gen\I2Cboot\I2Cboot.bat> file to generate the flash image i2cromdsp.dat in <EEPROM_flash_image_gen\I2Cboot\output>.
  3. Flash this EEPROM image to EEPROM using I2C_EEPROM_writer utility
    • Open CCS
    • Build and load the I2C_EEPROM_writer application. The steps to build the application are documented in the ReadMe.txt file located in the project directory.Ensure that the macro EEPROM_SLAVE_ADDR is set to EEPROM_SLAVE_ADDR_51.
    • Open a memory view (view->memory)
    • Select the Load option from the drop down list of the toolbar of the memory view and browse to the <EEPROM_flash_image_gen\I2Cboot\output> directory and select i2cromdsp.dat. Then select Use the file header... check box. This will load the data file into DSP memory.
    • Run the project (Press F8)
    • On successful execution you will get the message: "I2C EEPROM written successfully".


Flashing NAND FLASH with sample application for NAND boot

Perform the following steps to program the NAND Flash memory with the demo application:

  1. Build the HUA demo application.
  2. The .out file generated can be directly written to NAND. In order to reduce the .out file size strip the file using strip6x CCS utility using the command: <CCSv4 installation directory.\ccsv4\tools\compiler\c6000\bin\strip6x -p -o <output filename> <input filename>
  3. Write the stripped or unstripped .out file to NAND flash
    • Open CCS
    • Build and load the nandWriter application into the DSP. The steps to build the application are documented in the ReadMe.txt file located in the project directory.
    • Run the application by pressing F8 or selecting target->Run in the Debug perspective.
    • User will be prompted to enter the COFF (.out) file name. Provide the full name of the application .out file including the full path in the console view.
    • On successful flashing the application the following message will be displayed in the console: "NAND flash is successfully flashed with application".


Getting Started With Development

Re-building Platform Utility Library

We will be building library in place which will allow other dependent application to pick up the library from usual place.

The following procedure assumes the MCSDK is installed in C:\Program Files\Texas Instruments.

  • Open CCS (preferably with a new workspace)
  • Goto Project->Import Existing CCS/CCE Eclipse project
  • In the Select search-directory: enter C:\Program Files\Texas Instruments\mcsdk_#_##_##_##\packages\ti\platform\evm####\platform_utils and hit Browse. See Import Project Settings. This will import platform_utils_evm#### into the workspace.
Import Project Settings
  • Make sure the Copy projects into workspace is not checked. Then hit Finish.
  • The project platform_utils_evm#### will be imported into the CCS.
  • Now Project->Rebuild All should rebuild the project and library is created in C:\Program Files\Texas Instruments\mcsdk_#_##_##_##\packages\ti\platform\libwith name platform_utils_evm####.lib
    • The build should go smoothly. In case it fails set TI_MCSDK_INSTALL_DIR to C:\Program Files\Texas Instruments\mcsdk_#_##_##_## and TI_PDK_INSTALL_DIR to C:\Program Files\Texas Instruments\pdk_c64x_#_##_##_## in build environment. See image Environment Variables Setup.

See platform_library_user_guide for more information on the re-building of other components (eg: bootloader, platform utilities, etc.).


Building and running a simple platform library application

The following procedure assumes the MCSDK is installed in C:\Program Files\Texas Instruments.

  • Open CCS (preferably with a new workspace).
  • Open File->New->CCS Project and in the project name field enter led_play", then hit Next.
  • In the CCS project window, select Project Type: as C6000 and hit Next and hit Next again to skip the next page for "Additional Project Settings.
  • In the New CCS Project, select Device Variant: as Generic C64x+ Device and hit Next. See Project Settings.
Project Settings
  • In the Project Templets window select Empty Project and hit Next.
  • It should open an empty project with name led_play.
  • Select File->New->Source File, enter Source File name as led_play.c, then hit Finish.
  • It should open led_play.c empty file in the eclipse editor. Paste following source code in the editor
#include <stdio.h>
#include <string.h>
#include "platform_utils.h"
 
void main(void) {
    platform_init_flags init_flags;
    platform_init_config init_config;
    platform_info p_info;
    Int led_no = 0;
    Uint8 message[] = "\r\nHello World.....\r\n";
    Int length = strlen((char *)message);
    Int i;
 
    /* Initialize platform with default values */
    memset(&init_flags, 0x01, sizeof(platform_init_flags));
    memset(&init_config, 0, sizeof(platform_init_config));
    if (platform_init(&init_flags, &init_config) != Platform_EOK) {
        return;
    }
 
    platform_get_info(&p_info);
 
    /* Write to the UART */
    for (i = 0; i < length; i++) {
        if (platform_uart_write(message[i]) != Platform_EOK) {
            return;
        }
    }
 
    /* Play forever */
    while(1) {
        platform_led(led_no, PLATFORM_LED_ON);
        platform_delay(30000);
        platform_led(led_no, PLATFORM_LED_OFF);
        led_no = (++led_no) % p_info.led.count;
    }
}
  • Select File->New->File, enter File Name as led_play.cmd and hit Finish.
  • It would open led_play.cmd file in the editor, paste following memory map file in the editor
-stack 0xa000
-lrts64plus.lib
 
MEMORY
{
ram: o = 00800000h l = 00050000h
}
 
SECTIONS
{
 .text: .stack: .bss: .cinit: .far: .switch: .const: ram
}
  • Select Project->Properties, it should open Properties window for led_play project, select C/C++ Build from the left pane.
  • In the Tool Settings tab, select Include Options, add following two items in the Add dir to #include search path...
${TI_MCSDK_INSTALL_DIR}\packages\ti\platform\inc
${TI_PDK_INSTALL_DIR}\packages\ti\csl\c####\csl_c####\inc
Note: In above items #### refers to processor type (6472 for TMS320C6472, 6457 for TMS320C6457, etc.). See Include Path
Include Path
  • Select File Search Path from C6000 Linker section. Add following items in Include library... section
csl_c####.lib
platform_utils_evm$$$$$.lib
And add following items in Add <dir> to library... section
${TI_PDK_INSTALL_DIR}\packages\ti\csl\c####\csl_c####\lib
${TI_MCSDK_INSTALL_DIR}\packages\ti\platform\lib
Note: In above items #### refers to processor type (6472 for TMS320C6472, 6457 for TMS320C6457, etc.) and $$$$$ refers to evm type (6472 for TMDSEVM6472, 6457l for TMDSEVM6457L and 6474l for TMDSEVM6474L). See Linker Input.
Linker Input
  • Select OK to close the properties dialog box.
  • Select Project->Build Project to build the project.
    • If the build throws linking or include file not found error, then the eclipse environment variables are not present. You need to set *_INSTALL_DIR variables manually. Go to Project->Properties, select C/C++ Build and Environment tab. Then add TI_PDK_INSTALL_DIR variable with the value as the directory where PDK package is installed and add TI_MCSDK_INSTALL_DIR variable with the value as the directory where MCSDK package is installed. Then build again as described above. See image Environment Variables Setup.
Environment Variables Setup
  • Select View->Target Configurations to open target configuration tab in the left pane (this step assumes you have followed Getting Started Guide to create target configuration for your setup).
  • Right click on the configurations file (######.ccxml) and select Launch Selected Configuration.
  • It should change the CCS prospective to Debug and load the configuration.
  • After loading is complete select Device for core 0 (e.g. C64XP_0).
  • Select Target->Connect Target to connect to the core.
  • After core 0 is connected, select Target->Load Program, then hit Browse Project....
  • It should open Select program to load dialog, then select led_play.out [....] and hit OK and another OK to load the program to core 0.
  • After loading completes, select Target->Run to run the application.
  • The application should print Hello World if UART is connected to the board at 19200 baud rate and should flash LEDs.


Frequently Asked Questions, Tips, Hints and Tricks

Modifying a Library

  • If you want to modify and re-build a library its best not to copy it into your workspace. We suggest building it "in-place". When you build in-place you will not need to change build macros and so forth.
  • If you want to experiment with a library routine, debug it or try some new functionality, add the file to your project and use it there. Once you are done with it, if its a change you need to add then you can re-build it in the library.


Using JTAG and CCS

Did you know that CCS will execute all code up to the cinit when loading an out file through the JTAG? This is an option that is enabled, by default, in the Target Configuration file. Initialization code may sometimes execute before this. For example if you hook a function into the SYS/BIOS startup function list it will execute before cinit. If you need to debug that code or it is causing your load to hang (i.e. you do not get the run button highlighted) change the default setting.


Access to documents

NoteNote: : Once BIOS-MCSDK is installed in the system, many of the documents can be accessed from CCS->Help->Help Contents.

CCS Help Menu


Un-installing BIOS MCSDK

The BIOS MCSDK 1.00 installer installs the un-installer in mcsdk_1_00_00_## directory. The name of the un-installer is Uninstall-BIOS-MCSDK-1.00.00.##.exe. It also adds links of the un-installer in Programs->Texas Instruments->BIOS Multi-Core SDK program menu and in Windows Add and Remove Programs menu with name TI BIOS Multi-Core SDK. Selecting any one of the links will start the un-installer and remove the BIOS-MCSDK components from the system.

NoteNote: : The EDMA3 LLD component is installed as a separate package in the system. If you have selected EDMA3 to be installed in your system, then un-install it from Programs->EDMA3 Low Level Driver.


Technical Support and Product Updates

For technical discussions and issues, please visit


NoteNote: When asking for help in the forum you should tag your posts in the Subject with “MCSDK”, the part number (e.g. “C6472”) and additionally the component (e.g. “NDK”).


For product updates, please visit


NoteNote: The EVM comes with disks containing the MCSDK software and CCS. You can start with these or go to the MCSDK software download site listed above to check for the latest updates and version. The BIOS-MCSDK release download will also have pointers to applicable CCS and compiler release versions as well. Please review the release notes and software manifest before downloading and/or installing the software.