ixhssacccodelet_p.h

intel IXP400系列cpu（2.3版）的库文件

    IxHssAccHdlcPort hdlcPortId);

/**
 * fn void ixHssAccCodeletPacketisedServiceStop (
           IxHssAccHssPort hssPortId,
           IxHssAccHdlcPort hdlcPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 * param IxHssAccHdlcPort hdlcPortId (in) - the port id (0,1,2,3) to stop
 * the service on.
 *
 * Stop the Packetised Service and disable the RX flow by calling
 * ixHssAccPktPortDisable().
 * <P>
 * Disconnect the client from the HDLC port by invoking
 * ixHssAccPktPortDisconnect().
 */
void
ixHssAccCodeletPacketisedServiceStop (
    IxHssAccHssPort hssPortId,
    IxHssAccHdlcPort hdlcPortId);

/**
 * fn void ixHssAccCodeletPacketisedVerifySet (
           BOOL verifyOn)
 *
 * param BOOL verifyOn (in) - whether to verify data or not.
 *
 * This function sets the verification of data on or off.  Verification of
 * data can be turned off to improve performance.
 */
void
ixHssAccCodeletPacketisedVerifySet (
    BOOL verifyOn);

/**
 * fn void ixHssAccCodeletChannelisedServiceConfigure (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * First create both the TX and RX buffers.
 * <P>
 * For controlling the RX and TX of data, a frequent sampling rate will be
 * used.  This allows flexibility in deciding when to RX and TX data.  The
 * common configuration for the Channelised Service will be as follows:
 * <UL>
 *   <LI> Trigger rate = <B>1ms</B>
 *   <LI> Bytes per timeslot trigger = <B>8</B> (8 bytes @ 1ms => 64Kbps)
 *   <LI> Number of channels = <B>16</B>
 *   <LI> Bytes per sample = <B>44 bytes</B> (5.5ms sampling rate)
 * </UL>
 * These parameters are example values that would be typical of a voice
 * over ATM application.  A voice sample of 44 bytes plus an AAL2 header
 * will fit into the 48 byte payload of an ATM cell.  A trigger rate of 1ms
 * ensures that we are very responsive to handling voice samples.  A
 * trigger rate of 5ms or 6ms would seem more appropriate, but missing a
 * trigger due to busy CPU means a much longer delay before the data gets
 * processed on the next trigger.
 * <P>
 * A latency factor is introduced for the RX path to give the client
 * sufficient time to process the data received from the HSS port.  For
 * example, the client may wish to retransmit the data over an ATM network.
 * The higher this latency, the longer it will be before data received from
 * the HSS port is overwritten.  The RX configuration will be as follows:
 * <UL>
 *   <LI> RX latency factor = <B>4</B> (=> 3 * 5.5ms before data is
 * over-written)
 *   <LI> RX buffer size per channel = <B>176 bytes</B> (bytes per sample
 * times latency factor, i.e. 44 * 4)
 *   <LI> RX buffer size for all channels = <B>2816 bytes</B> (buffer size
 * per channel times number of channels, i.e. 176 * 16)
 * </UL>
 * <P>
 * A latency factor is introduced for the TX path to absorb the jitter
 * introduced by the network the data is coming from.  The HSS port
 * transmits data at a constant rate, however packets don't arrive at a
 * constant rate from a data network.  The TX configuration will be as
 * follows:
 * <UL>
 *   <LI> TX latency factor = <B>8</B> (=> 7 * 5.5ms before TX data runs
 * out)
 *   <LI> TX buffer size per channel = <B>352 bytes</B> (bytes per sample
 * times latency factor, i.e. 44 * 8)
 *   <LI> TX buffer size for all channels = <B>5632 bytes</B> (buffer size
 * per channel times number of channels, i.e. 352 * 16)
 * </UL>
 * <P>
 * For the TX service an array of pointers to samples is also required.
 * This array will contain a pointer to each 44-byte sample in the TX
 * buffer, i.e. 5632 / 44 = 128 pointers (or in other words the number of
 * channels times the latency factor, i.e. 16 * 8).
 * <P>
 * Next connect the client to the TX/RX NPE Channelised Service by invoking
 * ixHssAccChanConnect().  The connection parameters will be as follows:
 * <UL>
 *   <LI> Bytes per timeslot trigger = <B>8</B>
 *   <LI> RX circular buffer = <B>RX buffer</B>
 *   <LI> Number of RX bytes per timeslot = <B>176</B> (RX buffer size per
 * channel)
 *   <LI> TX pointer list = <B>TX pointer array</B>
 *   <LI> Number of TX pointer lists = <B>8</B> (latency factor)
 *   <LI> Number of TX bytes per block = <B>44</B> (bytes per sample)
 * </UL>
 * <P>
 * The client will supply ixHssAccCodeletChanRxCallback() as the
 * IxHssAccChanRxCallback parameter to handle the actual TX/RX of
 * channelised data.
 * <P>
 * Note, before starting the service the Codelet will need to prepare the
 * data to be transmitted.
 */
void
ixHssAccCodeletChannelisedServiceConfigure (
    IxHssAccHssPort hssPortId);

/**
 * fn void ixHssAccCodeletChannelisedServiceStart (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * Start the Channelised Service and enable the TX/RX flows by
 * invoking ixHssAccChanPortEnable().
 */
void
ixHssAccCodeletChannelisedServiceStart (
    IxHssAccHssPort hssPortId);

/**
 * fn void ixHssAccCodeletChannelisedServiceRun (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * Transmit traffic via the TX buffer and receive traffic via the RX
 * buffer.  No action needs to be taken to transmit or receive data.  Once
 * the Channelised Service is started the NPE will automatically transmit
 * data from the TX buffer and receive data into the RX buffer.
 * <P>
 * The callback routine ixHssAccCodeletChanRxCallback() will be called at
 * the sampling rate to tell the Codelet where data is currently being
 * transmitted from the TX buffer and received into the RX buffer.  This
 * callback will maintain statistics of data transmitted and received and
 * number of HSS errors.
 * <P>
 * When the Codelet is acting as data source/sink the data in the TX buffer
 * will be prepared for transmission.  This will involve writing a unique,
 * changing bit pattern to each channel.  The data in the RX buffer will be
 * verified to ensure it matches the data transmitted (the HSS is as loopback).
 * <P>
 * For transmitting data, the strategy used will be to write tx data to
 * slots we know the NPE has finished transmitting from.  As the NPE
 * transmits data and moves on to the next set of pointers, we will fill in
 * new data in the set of pointers just transmitted.  In this way the NPE
 * will always be transmitting new data.  Note, this is an artificial
 * scenario as we always have tx data available without any delay.  In a
 * real application data should be transmitted when available, while
 * ensuring that the NPE isn't too far behind (causing latency) or too
 * close behind (trying to transmit when there is no data ready).  Also, as
 * we are creating the tx data ourselves we can simply use one large tx
 * buffer and pass pointers to this buffer to the NPE.
 * <P>
 * For receiving data, the NPE tells us where data is currently being
 * received to.  As we want to handle voice data as samples, we wait for a
 * full sample to be received before processing it.
 */
void
ixHssAccCodeletChannelisedServiceRun (
    IxHssAccHssPort hssPortId);

/**
 * fn void ixHssAccCodeletChannelisedServiceStop (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * Stop the Channelised Service and disable the TX/RX flows by calling
 * ixHssAccChanPortDisable().
 * <P>
 * Disconnect the client from the TX/RX NPE Channelised Service by invoking
 * ixHssAccChanDisconnect().
 */
void
ixHssAccCodeletChannelisedServiceStop (
    IxHssAccHssPort hssPortId);

/**
 * fn void ixHssAccCodeletChannelisedVerifySet (
           BOOL verifyOn)
 *
 * param BOOL verifyOn (in) - whether to verify data or not.
 *
 * This function sets the verification of data on or off.  Verification of
 * data can be turned off to improve performance.
 */
void
ixHssAccCodeletChannelisedVerifySet (
    BOOL verifyOn);

/**
 * fn void ixHssAccCodeletShow (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * Display statistics for the specified HSS port.
 */
void
ixHssAccCodeletShow (
    IxHssAccHssPort hssPortId);

/**
 * fn void ixHssAccCodeletShowReset (
           IxHssAccHssPort hssPortId)
 *
 * param IxHssAccHssPort hssPortId (in) - the HSS port ID (0 or 1).
 *
 * Reset the statistics for the specified HSS port.
 */
void
ixHssAccCodeletShowReset (
    IxHssAccHssPort hssPortId);

/**
 * fn BOOL ixHssAccCodeletCodeletLoopbackGet (void)
 *
 * This function returns the Codelet loopback state.
 */

BOOL
ixHssAccCodeletCodeletLoopbackGet (void);

/**
 * fn void ixHssAccCodeletCodeletLoopbackSet (
           BOOL codeletLoopback)
 *
 * param BOOL codeletLoopback (in) - the Codelet loopback state.
 *
 * This function sets the Codelet loopback state.
 */

void
ixHssAccCodeletCodeletLoopbackSet (
    BOOL codeletLoopback);

/**
 * fn BOOL ixHssAccCodeletHssLoopbackGet (void)
 *
 * This function returns the HSS loopback state.
 */

BOOL
ixHssAccCodeletHssLoopbackGet (void);

/**
 * fn void ixHssAccCodeletHssLoopbackSet (
           BOOL hssLoopback)
 *
 * param BOOL hssLoopback (in) - the HSS loopback state.
 *
 * This function sets the HSS loopback state.
 */

void
ixHssAccCodeletHssLoopbackSet (
    BOOL hssLoopback);


#endif /* IXHSSACCCODELET_P_H */

/** } defgroup IxHssAccCodelet*/

/** } defgroup Codelets*/