SysLink 02.00.00.68 c6x beta2 ReleaseNotes

= SYS/Link 02.00.00.68_c6x_beta2 =

This release is intended to be used on:


 * C6670
 * C6678

Introduction
This document is the Release Notes document for SYS/Link.

SYS/Link, also referred to as SysLink, is a software platform that simplifies the development of embedded applications in which a general-purpose microprocessor (GPP) controls and communicates with one or more processors (can be microprocessors / DSPs). SysLink provides control and communication paths between GPP OS threads and SYS/BIOS tasks.The SysLink product provides software connectivity between multiple processors. Each processor may run either an HLOS such as Linux, WinCE, Symbian etc. or a Real Time Operating System such as SYS/BIOS™ or PrOS. Based on specific characteristics of the Operating system running on the processor, the software architecture of each module shall differ.Current SysLink supports Linux on HLOS and SYS/BIOS on RTOS side.The associated Porting kit can be used to port SysLink to various OSes.

The SysLink product provides the following services to frameworks and applications:
 * Processor Manager
 * Inter-Processor Communication
 * Utility modules

SYS/BIOS operating system is expected to be running on the slaves with all of these platforms.

This is an early adopter release with limited validation. This release is provided to give an early look at SysLink to framework/application developers for the above devices.

The SysLink implementation is currently in-progress. Design changes are currently being evaluated and implemented for Linux-side sources to move the implementation of most modules (except Notify) to user-space. Several advanced features such as Dynamic Memory Mapping, Dynamic System Memory Management, Slave Error Handling, Advanced Power Management are not currently implemented and are planned for future releases.

Release Components
The SysLink release package contains following components:

Prerequisites

 * A Linux Host machine with CG TOOLS/CCS installed along with linux-c6x sdk. It is assumed that a successful linux-c6x product build is complete on this host.

C6670/C6678

 * For details of how to set the different profile modes, see upgrade and compatibility information in this release notes.

Documentation

 * ReleaseNotes - This document.
 * UserGuide - Provides information about SysLink architecture, modules, and enables users to write and debug applications using SysLink.
 * Doxygen generated API reference - Provides API reference documentation for SysLink modules. For API reference documentation of IPC modules, refer to the doxygen generated API reference in the IPC product

Generic features
Syslink provides user and kernel side APIs for:


 * Processor Manager
 * Inter-Processor Communication protocols

In this release, following HLOS modules are supported:


 * ProcMgr
 * Ipc
 * Notify
 * MessageQ
 * ListMP
 * SharedRegion
 * MultiProc
 * GateMP
 * NameServer
 * HeapBufMP
 * HeapMemMP

Ipc
The Ipc module initializes all IPC and SysLink components on the behalf of the application. It provides a single platform-specific location to implement system level module initialization and configuration. It also allows application to seamlessly configure the SysLink and IPC components.

Ipc module on multi-processors system resides on each processor and enables synchronizing between any two cores using the Ipc module for setting up the system configuration.

The Ipc is an optional module. The application writer can choose to use or not use Ipc module for configuring the modules. If not used, all IPC modules must be individually configured by the application writer. However, note that due to the complexity of this configuration, it is advisable to use the Ipc module for system configuration and synchronization.

Processor Manager module
The Processor Manager on a master processor provides control functionality for a slave device.

Allows Host application to attach an IPC instance to communicate with a remote core. Unlike in other platforms, ProcMgr in c6x port assumes that Slave cores are loaded and run using other mechanisms. i.e ProcMgr doesn't support loading and starting of slave cores. It supports minimum functionality to attach and start an IPC instance with a remote core. Once the slave cores are running, the application invokes the LOADCALLBACK and STARTCALLBACK control command IOCTLs. The slave cores's Ipc_ResetVector is passed in as an argument to LOADCALLBACK IOCTL command. This will create an IPC instance with the slave core. The IPC is started by invoking the STARTCALLBACK IOCTL. It can then invoke other IPC IOCTLs.

Notify
The Notify Manager manages the multiplexing/de-multiplexing of software interrupts over hardware interrupts. The Notify module uses notify drivers that do the actual management of the callback functions and interface to the hardware

MessageQ
The MessageQ module supports the structured sending and receiving of variable length messages. This module can be used for homogeneous or heterogeneous multi-processor messaging.

MessageQ provides more sophisticated messaging than other modules. It is typically used for complex situations such as multi-processor messaging. The following are key features of the MessageQ module:


 * Writers and readers can be relocated to another processor with no runtime code changes.
 * Timeouts are allowed when receiving messages.
 * Readers can determine the writer and reply back.
 * Messages can reside on any message queue.
 * Supports zero-copy transfers.
 * Notification mechanism is specified by application.

GateMP
This module provides the design for implementing multi-processor critical section gates with remote and local protection. The type of gate used, whether s/w (GatePeterson) or h/w (GateHwSpinlock/GateHwSem/GateAAMonitor) depends on the device capabilities.

ListMP
The ListMP Manager is a doubly linked-list based module designed to be used in a multi-processor environment. It provides a way for multiple processors to create, access, and manipulate a link list in shared memory.

HeapBufMP/HeapMemMP
The HeapBufMP memory manager provides functions to allocate and free storage from a heap of type HeapBufMP which inherits from IHeap. HeapBufMP manages a single fixed-size buffer, split into equally sized allocable blocks. The HeapBufMP module is intended as a very fast memory manager which can only allocate blocks of a single size. It is ideal for managing a heap that is only used for allocating a single type of object, or for objects that have very similar sizes.

The HeapMemMP module is a variable size multi-processor memory manager, protected with a multi-processor GateMP.

SharedRegion
The SharedRegion module is designed to be used in a multi-processor environment where there are memory regions that are shared and accessed across different processors.

This module creates a shared memory region lookup table. This lookup table contains the processor's view for every shared region in the system. Each processor has its own lookup table. Each processor's view of a particular shared memory region can be determined by the same table index across all lookup tables. Each table entry is a base and length pair. During runtime, this table along with the shared region pointer is used to do a quick address translation.

If specified in configuration, a multi-processor heap can be created in the SharedRegion, which can be used by applications for their shared memory requirements. The heap created is of type HeapMemMP and is protected by the system gate.

List
The List module makes available a set of functions that manipulate List objects accessed through handles of type List_Handle. Each List contains a linked sequence of zero or more elements referenced through variables of type List_Elem, which are typically embedded as the first field within a structure.

MultiProc
Many multi-processor modules have the concept of processor id. MultiProc centralizes the processor id management into one module.

Generally to improve performance and to minimize data footprint, MultiProc provides information about the remote processors.

NameServer
The NameServer module manages local name/value pairs that enable an application and other modules to store and retrieve values based on a name. The module supports different lengths of values. The add/get functions are for variable length values. The NameServer module can be used in a multiprocessor system. The module communicates to other processors via the Remote driver.

Sample applications
Sample applications to demonstrate usage of modules have been provided for:


 * ProcMgr
 * Notify
 * MessageQ
 * HeapBufMP
 * HeapMemMP
 * ListMP
 * SharedRegion
 * GateMP

What's not supported

 * Unsupported features in this release:
 * FrameQ
 * RingIO
 * HeapMultiBufMP module

Host Support
This release has been validated on the following host machines:


 * Red Hat Enterprise Linux 4 for linux-c6x sdk builds
 * Windows XP SP2 for CCS v5 Installation

Device Support
This release supports the following devices.
 * C6670
 * C6678

Validation Information
This engineering release has been validated using the following configurations:

Known Issues
* Shared Memory transport is only verified using MSMC memory. * Assert log message seen when doing rmmod syslink.ko after running messageQ sample application * SysLink - GateMP, on RTOS side sendEvent fail log message is seen (but sample application runs to completion) * Assert log message seen when running HeapMemMP sample application * Functionality is verified only in Little Endian mode * Not verified with TI gcc wrapper tool (CGT based)

Versioning
This is the SysLink_02.00.00.68_c6x_beta2 release

Technical Support and Product Updates
Procedure to report problems/issues for TI products is available at the TI support page:


 * External forums Or:
 * http://support.ti.com