module ti.sdo.io.Stream
index URL

Module to stream data to/from a driver

This module offers both the issue/reclaim model and the read/write model to send and receive data from drivers. [ more ... ]
C synopsis target-domain sourced in ti/sdo/io/Stream.xdc
#include <ti/sdo/io/Stream.h>
Functions
UInt 
Stream_abort// Abort all pending IO(Stream_Handle handle, Error_Block *eb);
Void 
Stream_add// Add to IConverter table at runtime(String name, IConverter_Handle handle, Error_Block *eb);
Void
Stream_construct// Initialize a new instance object inside the provided structure(Stream_Struct *structP, String name, UInt mode, const Stream_Params *params, Error_Block *eb);
Void 
Stream_control// Send a control command to the driver(Stream_Handle handle, DriverTypes_ControlCmd cmd, UArg cmdArg, Error_Block *eb);
Stream_Handle
Stream_create// Allocate and initialize a new instance object and return its handle(String name, UInt mode, const Stream_Params *params, Error_Block *eb);
Void
Stream_delete// Finalize and free this previously allocated instance object, setting the referenced handle to NULL(Stream_Handle *handleP);
Void
Stream_destruct// Finalize the instance object inside the provided structure(Stream_Struct *structP);
Void 
Stream_issue// Issue a buffer to the stream(Stream_Handle handle, Ptr buf, SizeT size, UArg arg, Error_Block *eb);
Void
Stream_Params_init// Initialize this config-params structure with supplier-specified defaults before instance creation(Stream_Params *params);
Void 
Stream_prime// Prime an OUTPUT stream instance(Stream_Handle handle, Ptr buf, UArg arg, Error_Block *eb);
SizeT 
Stream_read// Read data from a stream(Stream_Handle handle, Ptr bufp, SizeT size, UInt timeout, Error_Block *eb);
SizeT 
Stream_reclaim// Reclaim a buffer that was previously issued by calling issue(Stream_Handle handle, Ptr *pbufp, UInt timeout, UArg *parg, Error_Block *eb);
Void 
Stream_remove// Remove entry from IConverter table at runtime(String name, Error_Block *eb);
SizeT 
Stream_write// Write data to a stream(Stream_Handle handle, Ptr bufp, SizeT size, UInt timeout, Error_Block *eb);
Functions common to all target instances
Stream_handle// Convert this instance structure pointer into an instance handle, Stream_Handle_label// The label associated with this instance object, Stream_Handle_name// The name of this instance object, Stream_Object_count// The number of statically-created instance objects, Stream_Object_first// The handle of the first dynamically-created instance object, or NULL, Stream_Object_get// The handle of the i-th statically-created instance object (array == NULL), Stream_Object_heap// The heap used to allocate dynamically-created instance objects, Stream_Object_next// The handle of the next dynamically-created instance object, or NULL, Stream_struct// Convert this instance handle into an instance structure pointer
Functions common to all target modules
Stream_Module_getMask// Returns the diagnostics mask for this module, Stream_Module_hasMask// Test whether this module has a diagnostics mask, Stream_Module_heap// The heap from which this module allocates memory, Stream_Module_id// Get this module's unique id, Stream_Module_setMask// Set the diagnostics mask for this module, Stream_Module_startupDone// Test if this module has completed startup
Defines
#define
Stream_INOUT// mode for input & output (UInt)2
#define
Stream_INPUT// mode for input (UInt)0
#define
Stream_OUTPUT// mode for output (UInt)1
Typedefs
typedef Stream_Object *
Stream_Handle// Client reference to an instance object;
typedef struct
Stream_Object// Opaque internal representation of an instance object Stream_Object;
typedef struct
Stream_Params// Instance config-params structure ...
typedef struct
Stream_Struct// Opaque client structure large enough to hold an instance object Stream_Struct;
Constants
extern const Assert_Id 
Stream_A_badMode// Assert when read or write on wrong channel;
extern const Assert_Id 
Stream_A_pendingReclaims// Assert when there are more packets to be reclaimed;
extern const Assert_Id 
Stream_A_syncNonBlocking// Assert when ISync is non-blocking but Stream_read/write called;
extern const Error_Id 
Stream_E_noBuffersIssued// Error raised when reclaim called but no outstanding buffers issued;
extern const Error_Id 
Stream_E_noPackets// Error raised when there are no packets for IO;
extern const Error_Id 
Stream_E_notFound// Error raised when name not found in IConverter Table and DriverTable;
extern const Error_Id 
Stream_E_timeout// Error raised when a timeout occurs during reclaim;
extern const IGateProvider_Handle 
Stream_gate// For making the table thread safe;
extern const UInt 
Stream_maxNameLen// Length, in MAUs, of the name field in the table;
extern const UInt 
Stream_maxRuntimeEntries// Max entries that can be added at runtime;
 
DETAILS
This module offers both the issue/reclaim model and the read/write model to send and receive data from drivers.
In the issue/reclaim model, the client calls issue when he has a buffer of data. issue() is non-blocking and returns. The buffer has been issued for IO. To get the buffer back the client has to call reclaim. A call to reclaim() can block. Upon return from reclaim(), the client can re-use his buffer.
The client can issue many buffers before reclaiming them. Buffers are always reclaimed in the order that they were issued. The client can optionally pass a user argument to issue().
In the read/write model, clients will call read or write to send/receive data. Here the client may block until buffer is ready or a timeout occurs.
Stream also provides control to send down driver specific control commands. There is abort function to abort the stream.
Stream also maintains a name table of IConverter handles. This table is used by Stream to create an IO stack. The name passed to create is usually of the form "/scale/uart". This name may correspond to the following IO stack.
Stream Instance
|
V
IConverter Instance (/scale)
|
V
IDriver Instance (/uart)
In this case the Stream requires "/scale" to be in its IConverter table and "/uart" to be in DriverTable. The IConverter table associates a name with an IConverter Handle. Note that these names have to be of the form "/name1".
This module uses ti.sdo.utils.NameServer to maintain its IConverter table
Stream uses the xdc.runtime.knl.Sync module for synchronization. Stream will call xdc.runtime.knl.Sync.signal when IO completes and xdc.runtime.knl.Sync.wait to wait for IO completion.
Stream will create a Sync.Handle passing NULL for ISync handle to create.
 
const Stream_INOUT
index URL

mode for input & output

C synopsis target-domain
#define Stream_INOUT (UInt)2
 
 
const Stream_INPUT
index URL

mode for input

C synopsis target-domain
#define Stream_INPUT (UInt)0
 
 
const Stream_OUTPUT
index URL

mode for output

C synopsis target-domain
#define Stream_OUTPUT (UInt)1
 
 
config Stream_A_badMode  // module-wide
index URL

Assert when read or write on wrong channel

C synopsis target-domain
extern const Assert_Id Stream_A_badMode;
 
DETAILS
Assert when read is called and mode = OUTPUT or when write is called and mode = INPUT
 
config Stream_A_pendingReclaims  // module-wide
index URL

Assert when there are more packets to be reclaimed

C synopsis target-domain
extern const Assert_Id Stream_A_pendingReclaims;
 
 
config Stream_A_syncNonBlocking  // module-wide
index URL

Assert when ISync is non-blocking but Stream_read/write called

C synopsis target-domain
extern const Assert_Id Stream_A_syncNonBlocking;
 
 
config Stream_E_noBuffersIssued  // module-wide
index URL

Error raised when reclaim called but no outstanding buffers issued

C synopsis target-domain
extern const Error_Id Stream_E_noBuffersIssued;
 
DETAILS
Clients can check for this error while calling reclaim to make sure they got all their buffers back.
  #include <xdc/runtime/Error.h>
  #include <ti/sdo/io/Stream.h>

  Error_Block eb;
  Stream_Handle streamHdl;
  SizeT len;
  Ptr *bufp;
  
  Error_init(&eb); 
  
  do {
      len = Stream_reclaim(streamHdl, bufp, NULL, &eb); 
  }while (!Error_check(&eb));
  
  if (Error_getId == Stream_E_noBuffersIssued) {
      ....all issues buffers have been reclaimed
  }
 
config Stream_E_noPackets  // module-wide
index URL

Error raised when there are no packets for IO

C synopsis target-domain
extern const Error_Id Stream_E_noPackets;
 
 
config Stream_E_notFound  // module-wide
index URL

Error raised when name not found in IConverter Table and DriverTable

C synopsis target-domain
extern const Error_Id Stream_E_notFound;
 
 
config Stream_E_timeout  // module-wide
index URL

Error raised when a timeout occurs during reclaim

C synopsis target-domain
extern const Error_Id Stream_E_timeout;
 
 
config Stream_gate  // module-wide
index URL

For making the table thread safe

C synopsis target-domain
extern const IGateProvider_Handle Stream_gate;
 
 
config Stream_maxNameLen  // module-wide
index URL

Length, in MAUs, of the name field in the table

C synopsis target-domain
extern const UInt Stream_maxNameLen;
 
 
config Stream_maxRuntimeEntries  // module-wide
index URL

Max entries that can be added at runtime

C synopsis target-domain
extern const UInt Stream_maxRuntimeEntries;
 
DETAILS
This module requires total number of converters that need to be added at runtime to be identified at configuration time.
 
Stream_add()  // module-wide
index URL

Add to IConverter table at runtime

C synopsis target-domain
Void Stream_add(String name, IConverter_Handle handle, Error_Block *eb);
 
ARGUMENTS
name — Name of entry
handle — IConverter handle
eb — Error Block
DETAILS
This API is not thread safe. Set gate parameter to protect table if called from multiple threads.
 
Stream_remove()  // module-wide
index URL

Remove entry from IConverter table at runtime

C synopsis target-domain
Void Stream_remove(String name, Error_Block *eb);
 
ARGUMENTS
name — name of entry
eb — error block
DETAILS
This API is not thread safe. Set gate parameter to protect table if called from multiple threads.
Module-Wide Built-Ins
index URL

C synopsis target-domain
Types_ModuleId Stream_Module_id();
// Get this module's unique id
 
Bool Stream_Module_startupDone();
// Test if this module has completed startup
 
IHeap_Handle Stream_Module_heap();
// The heap from which this module allocates memory
 
Bool Stream_Module_hasMask();
// Test whether this module has a diagnostics mask
 
Bits16 Stream_Module_getMask();
// Returns the diagnostics mask for this module
 
Void Stream_Module_setMask(Bits16 mask);
// Set the diagnostics mask for this module
Instance Object Types
index URL

C synopsis target-domain
typedef struct Stream_Object Stream_Object;
// Opaque internal representation of an instance object
 
typedef Stream_Object *Stream_Handle;
// Client reference to an instance object
 
typedef struct Stream_Struct Stream_Struct;
// Opaque client structure large enough to hold an instance object
 
Stream_Handle Stream_handle(Stream_Struct *structP);
// Convert this instance structure pointer into an instance handle
 
Stream_Struct *Stream_struct(Stream_Handle handle);
// Convert this instance handle into an instance structure pointer
Instance Config Parameters
index URL

C synopsis target-domain
typedef struct Stream_Params {
// Instance config-params structure
    IInstance_Params *instance;
    // Common per-instance configs
    UArg chanParams;
    // Channel params for driver if present in IO stack
    UInt maxIssues;
    // Max outstanding issues
    IHeap_Handle packetHeap;
    // Heap used to allocate DriverTypes.Packet in dynamic create
    ISync_Handle sync;
    // ISync handle used to signal IO completion
} Stream_Params;
 
Void Stream_Params_init(Stream_Params *params);
// Initialize this config-params structure with supplier-specified defaults before instance creation
 
config Stream_chanParams  // instance
index URL

Channel params for driver if present in IO stack

C synopsis target-domain
struct Stream_Params {
      ...
    UArg chanParams;
 
 
config Stream_maxIssues  // instance
index URL

Max outstanding issues

C synopsis target-domain
struct Stream_Params {
      ...
    UInt maxIssues;
 
 
config Stream_packetHeap  // instance
index URL

Heap used to allocate DriverTypes.Packet in dynamic create

C synopsis target-domain
struct Stream_Params {
      ...
    IHeap_Handle packetHeap;
 
 
config Stream_sync  // instance
index URL

ISync handle used to signal IO completion

C synopsis target-domain
struct Stream_Params {
      ...
    ISync_Handle sync;
 
Instance Creation
index URL

C synopsis target-domain
Stream_Handle Stream_create(String name, UInt mode, const Stream_Params *params, Error_Block *eb);
// Allocate and initialize a new instance object and return its handle
 
Void Stream_construct(Stream_Struct *structP, String name, UInt mode, const Stream_Params *params, Error_Block *eb);
// Initialize a new instance object inside the provided structure
ARGUMENTS
name — name that identifies the IO stack
mode — mode of channel.
params — per-instance config params, or NULL to select default values (target-domain only)
eb — active error-handling block, or NULL to select default policy (target-domain only)
DETAILS
Creates a new Stream instance and sets up the IO stack specified by name. The name is usually of the following form "/scale/uart". The mode is either INPUT or OUTPUT.
Instance Deletion
index URL

C synopsis target-domain
Void Stream_delete(Stream_Handle *handleP);
// Finalize and free this previously allocated instance object, setting the referenced handle to NULL
 
Void Stream_destruct(Stream_Struct *structP);
// Finalize the instance object inside the provided structure
 
Stream_abort()  // instance
index URL

Abort all pending IO

C synopsis target-domain
UInt Stream_abort(Stream_Handle handle, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
eb — error block
RETURNS
number of buffers aborted
DETAILS
The underlying device connected to stream is idled as a result of calling abort and all buffers are ready for reclaim().
The client still needs to call reclaim to get back his buffers. However the client will NOT block when calling reclaim() after an abort().
 
Stream_control()  // instance
index URL

Send a control command to the driver

C synopsis target-domain
Void Stream_control(Stream_Handle handle, DriverTypes_ControlCmd cmd, UArg cmdArg, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
cmd — device specific command
cmdArg — command specific arg
eb — error block
 
Stream_issue()  // instance
index URL

Issue a buffer to the stream

C synopsis target-domain
Void Stream_issue(Stream_Handle handle, Ptr buf, SizeT size, UArg arg, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
buf — buffer pointer
size — size of buffer
arg — app arg
eb — error block
DETAILS
This function issues a buffer to the stream for IO. This API is non-blocking.
Failure of issue() indicates that the stream was not able to accept the buffer being issued or that there was a error from the underlying IConverter or IDriver. Note that the error could be driver specific. If issue() fails because of an underlying driver problem abort should be called before attempting more I/O through the stream.
The interpretation of the logical size of a buffer, is direction dependent. For a stream opened in DriverTypes.OUTPUT mode, the logical size of the buffer indicates the number of minimum addressable units of of data it contains.
For a stream opened in DriverTypes.INPUT mode, the logical size of a buffer indicates the number of minimum addressable units being requested by the client. In either case, the logical size of the buffer must be less than or equal to the physical size of the buffer.
issue() is used in conjunction with reclaim. The issue() call sends a buffer to a stream, and reclaim() retrieves a buffer from a stream. In normal operation each issue() call is followed by an reclaim() call.
Short bursts of multiple issue() calls can be made without an intervening reclaim() call followed by short bursts of reclaim() calls, but over the life of the stream issue() and reclaim() must be called the same number of times. The number of issue() calls can exceed the number of reclaim() calls by maxIssues.
The client argument is not interpreted by Stream or the underlying modules, but is offered as a service to the stream client. All compliant device drivers preserve the value of arg and maintain its association with the data that it was issued with. arg provides a method for a client to associate additional information with a particular buffer of data. The arg is returned during reclaim().
 
Stream_prime()  // instance
index URL

Prime an OUTPUT stream instance

C synopsis target-domain
Void Stream_prime(Stream_Handle handle, Ptr buf, UArg arg, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
buf — buffer pointer
arg — app arg
eb — error block
DETAILS
This API facilitates buffering of an output channel. Consider a task that constantly gets data from input channel and sends to an output channel. To start with it may want to issue buffers to the input channel and output channel to enable double buffering. For an input channel there is no problem. For an output channel however the buffer data is sent out through the peripheral and in the case of a heterogenous system, the data will be sent to the other processor.
In such cases where the driver cannot handle dummy buffers, Stream_prime can be used to make buffers available instantly for reclaim without actually sending the buffers to the driver. This API is non-blocking.
The primary use of prime() is used when applications want to prime an output channel at startup, without sending data to the driver. This allows them to reclaim and issue in their task.
Failure of prime() indicates that the stream was not able to accept the buffer being issued due to un-avaibailibity of IO packets.
The client argument is not interpreted by Stream.
 
Stream_read()  // instance
index URL

Read data from a stream

C synopsis target-domain
SizeT Stream_read(Stream_Handle handle, Ptr bufp, SizeT size, UInt timeout, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
bufp — buffer pointer
size — size of buffer
timeout — timeout in microseconds
eb — error block
RETURNS
size transferred
DETAILS
Equivalent to an issue/reclaim pair for a instance with mode = DriverTypes.INPUT. This call is synchronous and the buffer has data upon return from this API.
 
Stream_reclaim()  // instance
index URL

Reclaim a buffer that was previously issued by calling issue

C synopsis target-domain
SizeT Stream_reclaim(Stream_Handle handle, Ptr *pbufp, UInt timeout, UArg *parg, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
pbufp — returned buffer pointer
timeout — timeout in microseconds
parg — pointer to client arg. Can be null.
eb — error block
RETURNS
size transferred
DETAILS
reclaim() is used to request a buffer back from a stream.
If a stream was created in DriverTypes.OUTPUT mode, then reclaim() returns a processed buffer, and size is zero. If a stream was opened in DriverTypes.INPUT mode, reclaim() returns a full buffer, and size is the number of minimum addressable units of data in the buffer.
reclaim() blocks until a buffer can be returned to the caller, or until a timeout occurs.
Failure of reclaim() indicates that no buffer was returned to the client. Therefore, if reclaim() fails, the client should not attempt to de-reference pbufp, since it is not guaranteed to contain a valid buffer pointer.
reclaim() is used in conjunction with issue to operate a stream. The issue() call sends a buffer to a stream, and reclaim() retrieves a buffer from a stream. In normal operation each issue call is followed by an reclaim call.
Short bursts of multiple issue() calls can be made without an intervening reclaim() call followed by short bursts of reclaim() calls, but over the life of the stream issue() and reclaim() must be called the same number of times. The number of issue() calls can exceed the number of reclaim() calls by maxIssues.
A reclaim() call should not be made without at least one outstanding issue() call. Calling reclaim() with no outstanding issue() calls results in an error E_noBuffersIssued
reclaim() only returns buffers that were passed in using issue(). It also returns the buffers in the same order that they were issued.
reclaim() returns the size transferred in case of success. It returns zero when an error is caught. In case of timeout, the error is E_timeout.
 
Stream_write()  // instance
index URL

Write data to a stream

C synopsis target-domain
SizeT Stream_write(Stream_Handle handle, Ptr bufp, SizeT size, UInt timeout, Error_Block *eb);
 
ARGUMENTS
handle — handle of a previously-created Stream instance object
bufp — buffer pointer
size — size of buffer
timeout — timeout in microseconds
eb — error block
RETURNS
size transferred
DETAILS
Equivalent to an issue/reclaim pair for a instance with mode = DriverTypes.OUTPUT. This call is synchronous and the driver has finished processing the buffer upon return from this API.
Instance Built-Ins
index URL

C synopsis target-domain
Int Stream_Object_count();
// The number of statically-created instance objects
 
Stream_Handle Stream_Object_get(Stream_Object *array, Int i);
// The handle of the i-th statically-created instance object (array == NULL)
 
Stream_Handle Stream_Object_first();
// The handle of the first dynamically-created instance object, or NULL
 
Stream_Handle Stream_Object_next(Stream_Handle handle);
// The handle of the next dynamically-created instance object, or NULL
 
IHeap_Handle Stream_Object_heap();
// The heap used to allocate dynamically-created instance objects
 
Types_Label *Stream_Handle_label(Stream_Handle handle, Types_Label *buf);
// The label associated with this instance object
 
String Stream_Handle_name(Stream_Handle handle);
// The name of this instance object
 
XDCscript usage meta-domain sourced in ti/sdo/io/Stream.xdc
var Stream = xdc.useModule('ti.sdo.io.Stream');
module-wide constants & types
    const Stream.INOUT// mode for input & output = 2;
    const Stream.INPUT// mode for input = 0;
    const Stream.OUTPUT// mode for output = 1;
 
    var obj = new Stream.BasicView// ;
        obj.label = String  ...
        obj.maxIssues = UInt  ...
        obj.issued = UInt  ...
        obj.ready = UInt  ...
        obj.mode = String  ...
        obj.userSuppliedSync = Bool  ...
module-wide config parameters
    Stream.A_badMode// Assert when read or write on wrong channel = Assert.Desc {
        msg: "A_badMode: Bad Mode"
    };
    Stream.A_pendingReclaims// Assert when there are more packets to be reclaimed = Assert.Desc {
        msg: "A_pendingReclaims: Packets issued but not reclaimed"
    };
    Stream.A_syncNonBlocking// Assert when ISync is non-blocking but Stream_read/write called = Assert.Desc {
        msg: "A_syncNonBlocking: ISync should have blocking quality"
    };
    Stream.E_noBuffersIssued// Error raised when reclaim called but no outstanding buffers issued = Error.Desc {
        msg: "E_noBuffersIssued: No outstanding buffers"
    };
    Stream.E_noPackets// Error raised when there are no packets for IO = Error.Desc {
        msg: "E_noPackets: No packets available. maxIssues is %d"
    };
    Stream.E_notFound// Error raised when name not found in IConverter Table and DriverTable = Error.Desc {
        msg: "E_notFound: %s name not found"
    };
    Stream.E_timeout// Error raised when a timeout occurs during reclaim = Error.Desc {
        msg: "E_timeout: Timeout"
    };
    Stream.gate// For making the table thread safe = IGateProvider.Handle null;
    Stream.maxNameLen// Length, in MAUs, of the name field in the table = UInt 16;
    Stream.maxRuntimeEntries// Max entries that can be added at runtime = UInt 0;
 
    Stream.common$// Common module configuration parameters = Types.Common$ undefined;
    Stream.rovViewInfo//  = ViewInfo.Instance ViewInfo.create;
    Stream.tableSection// Section name used to place the IConverter table = String null;
module-wide functions
    Stream.addMeta// Add to IConverter table at configuration time(String name, IConverter.Handle handle) returns Void
per-instance config parameters
    var params = new Stream.Params// Instance config-params object;
        params.chanParams// Channel params for driver if present in IO stack = UArg null;
        params.maxIssues// Max outstanding issues = UInt 2;
        params.packetHeap// Heap used to allocate DriverTypes.Packet in dynamic create = IHeap.Handle null;
        params.packetSection// Section name used to place DriverTypes.Packet = String null;
        params.sync// ISync handle used to signal IO completion = ISync.Handle null;
per-instance creation
    var inst = Stream.create// Create an instance-object(String name, UInt mode, params);
 
 
const Stream.INOUT
index URL

mode for input & output

XDCscript usage meta-domain
const Stream.INOUT = 2;
 
C SYNOPSIS
Stream_INOUT
 
const Stream.INPUT
index URL

mode for input

XDCscript usage meta-domain
const Stream.INPUT = 0;
 
C SYNOPSIS
Stream_INPUT
 
const Stream.OUTPUT
index URL

mode for output

XDCscript usage meta-domain
const Stream.OUTPUT = 1;
 
C SYNOPSIS
Stream_OUTPUT
 
metaonly struct Stream.BasicView
index URL
XDCscript usage meta-domain
var obj = new Stream.BasicView;
 
    obj.label = String  ...
    obj.maxIssues = UInt  ...
    obj.issued = UInt  ...
    obj.ready = UInt  ...
    obj.mode = String  ...
    obj.userSuppliedSync = Bool  ...
 
 
config Stream.A_badMode  // module-wide
index URL

Assert when read or write on wrong channel

XDCscript usage meta-domain
Stream.A_badMode = Assert.Desc {
    msg: "A_badMode: Bad Mode"
};
 
DETAILS
Assert when read is called and mode = OUTPUT or when write is called and mode = INPUT
C SYNOPSIS
Stream_A_badMode
 
config Stream.A_pendingReclaims  // module-wide
index URL

Assert when there are more packets to be reclaimed

XDCscript usage meta-domain
Stream.A_pendingReclaims = Assert.Desc {
    msg: "A_pendingReclaims: Packets issued but not reclaimed"
};
 
C SYNOPSIS
Stream_A_pendingReclaims
 
config Stream.A_syncNonBlocking  // module-wide
index URL

Assert when ISync is non-blocking but Stream_read/write called

XDCscript usage meta-domain
Stream.A_syncNonBlocking = Assert.Desc {
    msg: "A_syncNonBlocking: ISync should have blocking quality"
};
 
C SYNOPSIS
Stream_A_syncNonBlocking
 
config Stream.E_noBuffersIssued  // module-wide
index URL

Error raised when reclaim called but no outstanding buffers issued

XDCscript usage meta-domain
Stream.E_noBuffersIssued = Error.Desc {
    msg: "E_noBuffersIssued: No outstanding buffers"
};
 
DETAILS
Clients can check for this error while calling reclaim to make sure they got all their buffers back.
  #include <xdc/runtime/Error.h>
  #include <ti/sdo/io/Stream.h>

  Error_Block eb;
  Stream_Handle streamHdl;
  SizeT len;
  Ptr *bufp;
  
  Error_init(&eb); 
  
  do {
      len = Stream_reclaim(streamHdl, bufp, NULL, &eb); 
  }while (!Error_check(&eb));
  
  if (Error_getId == Stream_E_noBuffersIssued) {
      ....all issues buffers have been reclaimed
  }
C SYNOPSIS
Stream_E_noBuffersIssued
 
config Stream.E_noPackets  // module-wide
index URL

Error raised when there are no packets for IO

XDCscript usage meta-domain
Stream.E_noPackets = Error.Desc {
    msg: "E_noPackets: No packets available. maxIssues is %d"
};
 
C SYNOPSIS
Stream_E_noPackets
 
config Stream.E_notFound  // module-wide
index URL

Error raised when name not found in IConverter Table and DriverTable

XDCscript usage meta-domain
Stream.E_notFound = Error.Desc {
    msg: "E_notFound: %s name not found"
};
 
C SYNOPSIS
Stream_E_notFound
 
config Stream.E_timeout  // module-wide
index URL

Error raised when a timeout occurs during reclaim

XDCscript usage meta-domain
Stream.E_timeout = Error.Desc {
    msg: "E_timeout: Timeout"
};
 
C SYNOPSIS
Stream_E_timeout
 
config Stream.gate  // module-wide
index URL

For making the table thread safe

XDCscript usage meta-domain
Stream.gate = IGateProvider.Handle null;
 
C SYNOPSIS
Stream_gate
 
config Stream.maxNameLen  // module-wide
index URL

Length, in MAUs, of the name field in the table

XDCscript usage meta-domain
Stream.maxNameLen = UInt 16;
 
C SYNOPSIS
Stream_maxNameLen
 
config Stream.maxRuntimeEntries  // module-wide
index URL

Max entries that can be added at runtime

XDCscript usage meta-domain
Stream.maxRuntimeEntries = UInt 0;
 
DETAILS
This module requires total number of converters that need to be added at runtime to be identified at configuration time.
C SYNOPSIS
Stream_maxRuntimeEntries
 
metaonly config Stream.common$  // module-wide
index URL

Common module configuration parameters

XDCscript usage meta-domain
Stream.common$ = Types.Common$ undefined;
 
DETAILS
All modules have this configuration parameter. Its name contains the '$' character to ensure it does not conflict with configuration parameters declared by the module. This allows new configuration parameters to be added in the future without any chance of breaking existing modules.
 
metaonly config Stream.rovViewInfo  // module-wide
index URL
XDCscript usage meta-domain
Stream.rovViewInfo = ViewInfo.Instance ViewInfo.create;
 
 
metaonly config Stream.tableSection  // module-wide
index URL

Section name used to place the IConverter table

XDCscript usage meta-domain
Stream.tableSection = String null;
 
 
metaonly Stream.addMeta()  // module-wide
index URL

Add to IConverter table at configuration time

XDCscript usage meta-domain
Stream.addMeta(String name, IConverter.Handle handle) returns Void
 
ARGUMENTS
name — name of entry
handle — IConverter handle
Instance Config Parameters
index URL

XDCscript usage meta-domain
var params = new Stream.Params;
// Instance config-params object
    params.chanParams = UArg null;
    // Channel params for driver if present in IO stack
    params.maxIssues = UInt 2;
    // Max outstanding issues
    params.packetHeap = IHeap.Handle null;
    // Heap used to allocate DriverTypes.Packet in dynamic create
    params.packetSection = String null;
    // Section name used to place DriverTypes.Packet
    params.sync = ISync.Handle null;
    // ISync handle used to signal IO completion
 
config Stream.chanParams  // instance
index URL

Channel params for driver if present in IO stack

XDCscript usage meta-domain
var params = new Stream.Params;
  ...
params.chanParams = UArg null;
 
C SYNOPSIS
null
 
config Stream.maxIssues  // instance
index URL

Max outstanding issues

XDCscript usage meta-domain
var params = new Stream.Params;
  ...
params.maxIssues = UInt 2;
 
C SYNOPSIS
null
 
config Stream.packetHeap  // instance
index URL

Heap used to allocate DriverTypes.Packet in dynamic create

XDCscript usage meta-domain
var params = new Stream.Params;
  ...
params.packetHeap = IHeap.Handle null;
 
C SYNOPSIS
null
 
config Stream.sync  // instance
index URL

ISync handle used to signal IO completion

XDCscript usage meta-domain
var params = new Stream.Params;
  ...
params.sync = ISync.Handle null;
 
C SYNOPSIS
null
 
metaonly config Stream.packetSection  // instance
index URL

Section name used to place DriverTypes.Packet

XDCscript usage meta-domain
var params = new Stream.Params;
  ...
params.packetSection = String null;
 
DETAILS
Default of null results in no explicit section placement.
Instance Creation
index URL

XDCscript usage meta-domain
var params = new Stream.Params;
// Allocate instance config-params
params.config =   ...
// Assign individual configs
 
var inst = Stream.create(String name, UInt mode, params);
// Create an instance-object
ARGUMENTS
name — name that identifies the IO stack
mode — mode of channel.
params — per-instance config params, or NULL to select default values (target-domain only)
eb — active error-handling block, or NULL to select default policy (target-domain only)
DETAILS
Creates a new Stream instance and sets up the IO stack specified by name. The name is usually of the following form "/scale/uart". The mode is either INPUT or OUTPUT.
generated on Tue, 22 May 2012 23:44:35 GMT