Texas Instruments TMS320 DSP User Manual

www.ti.com
3.1.9 Multiple Interface Support
Interfaces and Modules
typedef struct FIR_Obj { /* FIR_Obj definition */
int hist[16]; /* previous input value */
int frameLen; /* input frame length */
int *coeff;
} FIR_Obj;
FIR_Handle FIR_create(FIR_Obj *fir, const FIR_Params *params)
{
if (fir != NULL) {
if (params == NULL) { /* use defaults if params is NULL */
params = &FIR_PARAMS;
}
fir->frameLen = params->frameLen;
fir->coeff = params->coeff;
memset(fir->hist, 0, sizeof (fir->hist));
}
return (fir);
}
The delete entry point should release any resource held by the object being deleted and should gracefully
handle the deletion of partially constructed objects; the delete entry point may be called by the create
operation. In this case, there is nothing to do.
void FIR_delete(FIR_Handle fir)
{
}
Finally, the FIR module must provide a method for filtering a signal. This is accomplished via the apply
operation shown below.
void FIR_apply(FIR_Handle fir, int in[], int out[])
{
int I;
/* filter data using coefficients fir->coeff and
history fir->hist */
for (I = 0; I < fir->frameLen; I++) {
out[i] = filter(in[i], fir->coeff, fir->hist);
}
}
Of course, in a real FIR module, the filter operation would be implemented in assembly language.
However, because the state necessary to compute the algorithm is entirely contained in the object pointed
to by fir, this algorithm is reentrant. Thus, it is easy to use this module in multichannel applications or in
single-channel applications which require more than one FIR filter.
Modern component programming models support the ability of a single component to implement more
than one interface. This allows a single component to be used concurrently by a variety of different
applications. For example, in addition to a component's concrete interface (defined by its header) a
component might also support a debug interface that allows debuggers to inquire about the existence and
extent of the component's debug capabilities. If all debuggable components implement a common abstract
debug interface, debuggers can be written that can uniformly debug arbitrary components.
Support for multiple interfaces is generally incorporated into the development environment (via Code
wizards), the programming language itself, or both. Since this standard is intended to only require the C
language, the ability of a module to support multiple interfaces is at best awkward.
However, several significant benefits make this approach worthwhile:
• a vendor may decide not to implement certain interfaces for some components,
• new interfaces can be defined without affecting existing components,
• multiple implementations of the same interface may be present in a single system, and
• partitioning a large interface into multiple simpler interfaces makes it easier to understand the
component as a whole.
As stated before, interfaces are defined by header files; each header defines a single interface. A
SPRU352G – June 2005 – Revised February 2007 Algorithm Component Model 31
Submit Documentation Feedback

Texas Instruments TMS320 DSP Specifications

General

Category	Digital Signal Processor
Manufacturer	Texas Instruments
Data Bus Width	Varies by model (e.g., 16-bit, 32-bit)
Architecture	Harvard architecture
Address Bus Width	Varies by model
Memory	Varies by model
On-Chip RAM	Varies by model
On-Chip ROM	Varies by model
Applications	Audio processing, telecommunications
Operating Temperature	Varies by model
Package Type	Varies by model (e.g., QFP, BGA)

Summary

Preface

Read This First

Provides introductory information and context for the document.

Overview

Scope of the Standard

Defines the levels of guidelines for the TMS320 DSP Algorithm Standard.

Requirements of the Standard

Lists key elements and objectives for the TMS320 DSP Algorithm Standard.

Goals of the Standard

Outlines the objectives for creating and adhering to the TMS320 DSP Algorithm Standard.

Intentional Omissions

Lists aspects intentionally omitted from the current version of the standard.

System Architecture

Describes the common partitioning of modern DSP system architectures.

General Programming Guidelines

Use of C Language

Specifies adherence to C language run-time conventions for algorithm interoperability.

Threads and Reentrancy

Defines threads and discusses reentrancy requirements for algorithms.

Data Memory

Discusses memory allocation, types, and management for algorithms.

Program Memory

Covers requirements for code relocation and alignment in program memory.

ROM-ability

Addresses the ability of algorithm code to be placed in ROM.

Use of Peripherals

Prohibits direct peripheral access and outlines how algorithms can use DMA.

Algorithm Component Model

Interfaces and Modules

Describes modules as the basic software component and their interfaces.

Algorithms

Defines algorithms as modules implementing the IALG interface.

Packaging

Details how to bundle modules into a deliverable form for development systems.

Algorithm Performance Characterization

Data Memory

Characterizes algorithm data memory requirements (heap, stack, static).

Program Memory

Details requirements for characterizing algorithm program memory usage.

Interrupt Latency

Specifies how to characterize and limit worst-case interrupt latency.

Execution Time

Explains how to characterize typical and worst-case execution times for algorithms.

DSP-Specific Guidelines

CPU Register Types

Categorizes CPU registers and provides guidelines for their use.

Use of Floating Point

Advises against the use of floating-point data types to reduce library dependencies.

TMS320C6xxx Rules and Guidelines

Provides specific rules and guidelines for TMS320C6000 family DSPs.

TMS320C54xx Rules and Guidelines

Provides specific rules and guidelines for TMS320C5400 family DSPs.

TMS320C55x Rules and Guidelines

Provides specific rules and guidelines for TMS320C5500 family DSPs.

TMS320C24xx Guidelines

Provides specific rules and guidelines for TMS320C24xx family DSPs.

TMS320C28x Rules and Guidelines

Provides specific rules and guidelines for TMS320C28x family DSPs.

Use of the DMA Resource

Overview

Introduces rules and guidelines for algorithms utilizing DMA resources.

Algorithm and Framework

Defines the relationship between algorithms and frameworks for DMA resource management.

Requirements for the Use of the DMA Resource

Lists requirements for DMA usage in eXpressDSP-compliant algorithms.

Logical Channel

Explains the concept of logical DMA channels for algorithm use.

Data Transfer Properties

Defines parameters for DMA transfer blocks (frames, elements).

Data Transfer Synchronization

Discusses methods to ensure DMA transfers complete before CPU access.

Abstract Interface

Describes the IDMA2/IDMA3 interfaces for declaring DMA resource requirements.

Resource Characterization

Details how to characterize DMA resource usage (concurrency, size, frequency).

Runtime APIs

Lists allowed runtime APIs for configuring and managing DMA transfers.

Strong Ordering of DMA Transfer Requests

Explains FIFO ordering and queue ID properties for DMA transfers.

Submitting DMA Transfer Requests

Describes functions for submitting DMA transfer requests and their alignment requirements.

Device Independent DMA Optimization Guideline

Provides a guideline to minimize DMA channel reconfiguration overhead.

C6xxx Specific DMA Rules and Guidelines

Covers DMA rules and guidelines specific to C6000 series DSPs.

C55x Specific DMA Rules and Guidelines

Covers DMA rules and guidelines specific to C55x series DSPs.

Inter-Algorithm Synchronization

Discusses sharing physical DMA channels between algorithms.

Rules and Guidelines

General Rules

Enforces rules for eXpressDSP-compliant software and identifies guideline types.

Performance Characterization Rules

Lists rules related to characterizing algorithm performance metrics.

DMA Rules

Lists rules specifically for algorithms utilizing the DMA resource.

General Guidelines

Lists general recommendations for algorithm development.

DMA Guidelines

Lists guidelines related to DMA usage by algorithms.

Core Run-Time APIs

TI C-Language Run-Time Support Library

Lists allowable TI C-language run-time support library functions for algorithms.

DSP/BIOS Run-time Support Library

Lists allowable DSP/BIOS run-time support functions for algorithms.

Bibliography

Glossary

Glossary of Terms

Defines key terms used throughout the TMS320 DSP Algorithm Standard document.