/*************************************************************************/ /*!
@File
@Title          Transport Layer kernel side API.
@Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
@Description    TL provides driver components with a way to copy data from kernel
                space to user space (e.g. screen/file).

                Data can be passed to the Transport Layer through the
                TL Stream (kernel space) API interface.

                The buffer provided to every stream is a modified version of a
                circular buffer. Which CB version is created is specified by
                relevant flags when creating a stream. Currently two types
                of buffer are available:
                - TL_OPMODE_DROP_NEWER:
                  When the buffer is full, incoming data are dropped
                  (instead of overwriting older data) and a marker is set
                  to let the user know that data have been lost.
                - TL_OPMODE_BLOCK:
                  When the circular buffer is full, reserve/write calls block
                  until enough space is freed.
                - TL_OPMODE_DROP_OLDEST:
                  When the circular buffer is full, the oldest packets in the
                  buffer are dropped and a flag is set in header of next packet
                  to let the user know that data have been lost.

                All size/space requests are in bytes. However, the actual
                implementation uses native word sizes (i.e. 4 byte aligned).

                The user does not need to provide space for the stream buffer
                as the TL handles memory allocations and usage.

                Inserting data to a stream's buffer can be done either:
                - by using TLReserve/TLCommit: User is provided with a buffer
                                                 to write data to.
                - or by using TLWrite:         User provides a buffer with
                                                 data to be committed. The TL
                                                 copies the data from the
                                                 buffer into the stream buffer
                                                 and returns.
                Users should be aware that there are implementation overheads
                associated with every stream buffer. If you find that less
                data are captured than expected then try increasing the
                stream buffer size or use TLInfo to obtain buffer parameters
                and calculate optimum required values at run time.
@License        Dual MIT/GPLv2

The contents of this file are subject to the MIT license as set out below.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 ("GPL") in which case the provisions
of GPL are applicable instead of those above.

If you wish to allow use of your version of this file only under the terms of
GPL, and not to allow others to use your version of this file under the terms
of the MIT license, indicate your decision by deleting the provisions above
and replace them with the notice and other provisions required by GPL as set
out in the file called "GPL-COPYING" included in this distribution. If you do
not delete the provisions above, a recipient may use your version of this file
under the terms of either the MIT license or GPL.

This License is also included in this distribution in the file called
"MIT-COPYING".

EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ /**************************************************************************/
#ifndef TLSTREAM_H
#define TLSTREAM_H

#include "img_types.h"
#include "img_defs.h"
#include "pvrsrv_error.h"
#include "pvrsrv_tlcommon.h"
#include "device.h"

/*! Extract TL stream opmode from the given stream create flags.
 * Last 3 bits of streamFlag is used for storing opmode, hence
 * opmode mask is set as following. */
#define TL_OPMODE_MASK 0x7

/*
 * NOTE: This enum is used to directly access the HTB_OPMODE_xxx values
 * within htbserver.c.
 * As such we *MUST* keep the values matching in order of declaration.
 */
/*! Opmode specifying circular buffer behaviour */
typedef enum
{
	/*! Undefined operation mode */
	TL_OPMODE_UNDEF = 0,

	/*! Reject new data if the buffer is full, producer may then decide to
	 *    drop the data or retry after some time. */
	TL_OPMODE_DROP_NEWER,

	/*! When buffer is full, advance the tail/read position to accept the new
	 * reserve call (size permitting), effectively overwriting the oldest
	 * data in the circular buffer. Not supported yet. */
	TL_OPMODE_DROP_OLDEST,

	/*! Block Reserve (subsequently Write) calls if there is not enough space
	 *    until some space is freed via a client read operation. */
	TL_OPMODE_BLOCK,

	/*!< For error checking */
	TL_OPMODE_LAST

} TL_OPMODE;

typedef enum {
	/* Enum to be used in conjunction with new Flags feature */

	/* Flag set when Drop Oldest is set and packets have been dropped */
	TL_FLAG_OVERWRITE_DETECTED = (1 << 0),

} TL_Flags;

static_assert(TL_OPMODE_LAST <= TL_OPMODE_MASK,
	      "TL_OPMODE_LAST must not exceed TL_OPMODE_MASK");

/*! Flags specifying stream behaviour */
/*! Do not destroy stream if there still are data that have not been
 *     copied in user space. Block until the stream is emptied. */
#define TL_FLAG_FORCE_FLUSH            (1U<<8)
/*! Do not signal consumers on commit automatically when the stream buffer
 * transitions from empty to non-empty. Producer responsible for signal when
 * it chooses. */
#define TL_FLAG_NO_SIGNAL_ON_COMMIT    (1U<<9)

/*! When a stream has this property it never wraps around and
 * overwrites existing data, hence it is a fixed size persistent
 * buffer, data written is permanent. Producers need to ensure
 * the buffer is big enough for their needs.
 * When a stream is opened for reading the client will always
 * find the read position at the start of the buffer/data. */
#define TL_FLAG_PERMANENT_NO_WRAP      (1U<<10)

/*! Defer allocation of stream's shared memory until first open. */
#define TL_FLAG_ALLOCATE_ON_FIRST_OPEN (1U<<11)

/*! Structure used to pass internal TL stream sizes information to users.*/
typedef struct _TL_STREAM_INFO_
{
    IMG_UINT32 headerSize;          /*!< Packet header size in bytes */
    IMG_UINT32 minReservationSize;  /*!< Minimum data size reserved in bytes */
    IMG_UINT32 pageSize;            /*!< Page size in bytes */
    IMG_UINT32 pageAlign;           /*!< Page alignment in bytes */
    IMG_UINT32 maxTLpacketSize;     /*! Max allowed TL packet size*/
} TL_STREAM_INFO, *PTL_STREAM_INFO;

/*! Callback operations or notifications that a stream producer may handle
 * when requested by the Transport Layer.
 */
#define TL_SOURCECB_OP_CLIENT_EOS 0x01  /*!< Client has reached end of stream,
                                         * can anymore data be supplied?
                                         * ui32Resp ignored in this operation */

/*! Function pointer type for the callback handler into the "producer" code
 * that writes data to the TL stream.  Producer should handle the notification
 * or operation supplied in ui32ReqOp on stream hStream. The
 * Operations and notifications are defined above in TL_SOURCECB_OP */
typedef PVRSRV_ERROR (*TL_STREAM_SOURCECB)(IMG_HANDLE hStream,
		IMG_UINT32 ui32ReqOp, IMG_UINT32* ui32Resp, void* pvUser);

typedef void (*TL_STREAM_ONREADEROPENCB)(void *pvArg);

/*************************************************************************/ /*!
 @Function      TLAllocSharedMemIfNull
 @Description   Allocates shared memory for the stream.
 @Input         hStream     Stream handle.
 @Return        eError      Internal services call returned eError error
                            number.
 @Return        PVRSRV_OK
*/ /**************************************************************************/
PVRSRV_ERROR
TLAllocSharedMemIfNull(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLFreeSharedMem
 @Description   Frees stream's shared memory.
 @Input         phStream    Stream handle.
*/ /**************************************************************************/
void
TLFreeSharedMem(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamCreate
 @Description   Request the creation of a new stream and open a handle.
				If creating a stream which should continue to exist after the
				current context is finished, then TLStreamCreate must be
				followed by a TLStreamOpen call. On any case, the number of
				create/open calls must balance with the number of close calls
				used. This ensures the resources of a stream are released when
				it is no longer required.
 @Output        phStream        Pointer to handle to store the new stream.
 @Input			psDevNode       Pointer to the Device Node to be used for
                                stream allocation.
 @Input         szStreamName    Name of stream, maximum length:
                                PRVSRVTL_MAX_STREAM_NAME_SIZE.
                                If a longer string is provided,creation fails.
 @Input         ui32Size        Desired buffer size in bytes.
 @Input         ui32StreamFlags Used to configure buffer behaviour. See above.
 @Input         pfOnReaderOpenCB    Optional callback called when a client
                                    opens this stream, may be null.
 @Input         pvOnReaderOpenUD    Optional user data for pfOnReaderOpenCB,
                                    may be null.
 @Input         pfProducerCB    Optional callback, may be null.
 @Input         pvProducerUD    Optional user data for callback, may be null.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handle or string name
                                             exceeded MAX_STREAM_NAME_SIZE
 @Return        PVRSRV_ERROR_OUT_OF_MEMORY   Failed to allocate space for
                                             stream handle.
 @Return        PVRSRV_ERROR_DUPLICATE_VALUE There already exists a stream with
                                             the same stream name string.
 @Return        eError                       Internal services call returned
                                             eError error number.
 @Return        PVRSRV_OK
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamCreate(IMG_HANDLE *phStream,
               PVRSRV_DEVICE_NODE *psDevNode,
               const IMG_CHAR *szStreamName,
               IMG_UINT32 ui32Size,
               IMG_UINT32 ui32StreamFlags,
               TL_STREAM_ONREADEROPENCB pfOnReaderOpenCB,
               void *pvOnReaderOpenUD,
               TL_STREAM_SOURCECB pfProducerCB,
               void *pvProducerUD);

/*************************************************************************/ /*!
 @Function      TLStreamOpen
 @Description   Attach to existing stream that has already been created by a
                  TLStreamCreate call. A handle is returned to the stream.
 @Output        phStream        Pointer to handle to store the stream.
 @Input         szStreamName    Name of stream, should match an already
                                  existing stream name
 @Return        PVRSRV_ERROR_NOT_FOUND       None of the streams matched the
                                             requested stream name.
				PVRSRV_ERROR_INVALID_PARAMS  Non-NULL pointer to stream
                                             handler is required.
 @Return        PVRSRV_OK                    Success.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamOpen(IMG_HANDLE     *phStream,
             const IMG_CHAR *szStreamName);


/*************************************************************************/ /*!
 @Function      TLStreamReset
 @Description   Resets read and write pointers and pending flag.
 @Output        phStream Pointer to stream's handle
*/ /**************************************************************************/
void TLStreamReset(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamSetNotifStream
 @Description   Registers a "notification stream" which will be used to
                publish information about state change of the "hStream"
                stream. Notification can inform about events such as stream
                open/close, etc.
 @Input         hStream         Handle to stream to update.
 @Input         hNotifStream    Handle to the stream which will be used for
                                publishing notifications.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  If either of the parameters is
                                             NULL
 @Return        PVRSRV_OK                    Success.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamSetNotifStream(IMG_HANDLE hStream, IMG_HANDLE hNotifStream);

/*************************************************************************/ /*!
 @Function      TLStreamReconfigure
 @Description   Request the stream flags controlling buffer behaviour to
                be updated.
                In the case where TL_OPMODE_BLOCK is to be used,
                TLStreamCreate should be called without that flag and this
                function used to change the stream mode once a consumer process
                has been started. This avoids a deadlock scenario where the
                TLStreaWrite/TLStreamReserve call will hold the Bridge Lock
                while blocking if the TL buffer is full.
                The TL_OPMODE_BLOCK should never drop the Bridge Lock
                as this leads to another deadlock scenario where the caller to
                TLStreamWrite/TLStreamReserve has already acquired another lock
                (e.g. gHandleLock) which is not dropped. This then leads to that
                thread acquiring locks out of order.
 @Input         hStream         Handle to stream to update.
 @Input         ui32StreamFlags Flags that configure buffer behaviour. See above.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handle or inconsistent
                                             stream flags.
 @Return        PVRSRV_ERROR_NOT_READY       Stream is currently being written to
                                             try again later.
 @Return        eError                       Internal services call returned
                                             eError error number.
 @Return        PVRSRV_OK
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamReconfigure(IMG_HANDLE hStream,
                    IMG_UINT32 ui32StreamFlags);

/*************************************************************************/ /*!
 @Function      TLStreamClose
 @Description   Detach from the stream associated with the given handle. If
                  the current handle is the last one accessing the stream
				  (i.e. the number of TLStreamCreate+TLStreamOpen calls matches
				  the number of TLStreamClose calls) then the stream is also
				  deleted.
				On return the handle is no longer valid.
 @Input         hStream     Handle to stream that will be closed.
 @Return        None.
*/ /**************************************************************************/
void
TLStreamClose(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamReserve
 @Description   Reserve space in stream buffer. When successful every
                  TLStreamReserve call must be followed by a matching
                  TLStreamCommit call. While a TLStreamCommit call is pending
                  for a stream, subsequent TLStreamReserve calls for this
                  stream will fail.
 @Input         hStream         Stream handle.
 @Output        ppui8Data       Pointer to a pointer to a location in the
                                  buffer. The caller can then use this address
                                  in writing data into the stream.
 @Input         ui32Size        Number of bytes to reserve in buffer.
 @Return        PVRSRV_INVALID_PARAMS       NULL stream handler.
 @Return        PVRSRV_ERROR_NOT_READY      There are data previously reserved
                                              that are pending to be committed.
 @Return        PVRSRV_ERROR_STREAM_MISUSE  Misusing the stream by trying to
                                              reserve more space than the
                                              buffer size.
 @Return        PVRSRV_ERROR_STREAM_FULL    The reserve size requested
                                            is larger than the free
                                            space.
 @Return         PVRSRV_ERROR_TLPACKET_SIZE_LIMIT_EXCEEDED  The reserve size
                                                            requested is larger
                                                            than max TL packet size
 @Return        PVRSRV_ERROR_STREAM_NOT_ENOUGH_SPACE Permanent stream buffer
                                                     does not have enough space
                                                     for the reserve.
 @Return        PVRSRV_OK                   Success, output arguments valid.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamReserve(IMG_HANDLE hStream,
                IMG_UINT8  **ppui8Data,
                IMG_UINT32 ui32Size);

/*************************************************************************/ /*!
 @Function      TLStreamReserve2
 @Description   Reserve space in stream buffer. When successful every
                  TLStreamReserve call must be followed by a matching
                  TLStreamCommit call. While a TLStreamCommit call is pending
                  for a stream, subsequent TLStreamReserve calls for this
                  stream will fail.
 @Input         hStream         Stream handle.
 @Output        ppui8Data       Pointer to a pointer to a location in the
                                  buffer. The caller can then use this address
                                  in writing data into the stream.
 @Input         ui32Size        Ideal number of bytes to reserve in buffer.
 @Input         ui32SizeMin     Minimum number of bytes to reserve in buffer.
 @Input         pui32Available  Optional, but when present and the
                                  RESERVE_TOO_BIG error is returned, a size
                                  suggestion is returned in this argument which
                                  the caller can attempt to reserve again for a
                                  successful allocation.
 @Return        PVRSRV_INVALID_PARAMS        NULL stream handler.
 @Return        PVRSRV_ERROR_NOT_READY       There are data previously reserved
                                             that are pending to be committed.
 @Return        PVRSRV_ERROR_STREAM_MISUSE   Misusing the stream by trying to
                                             reserve more space than the
                                             buffer size.
 @Return        PVRSRV_ERROR_STREAM_FULL     The reserve size requested
                                             is larger than the free
                                             space.
                                             Check the pui32Available
                                             value for the correct
                                             reserve size to use.
 @Return         PVRSRV_ERROR_TLPACKET_SIZE_LIMIT_EXCEEDED   The reserve size
                                                             requested is larger
                                                             than max TL packet size
 @Return        PVRSRV_ERROR_STREAM_NOT_ENOUGH_SPACE Permanent stream buffer
                                                     does not have enough space
                                                     for the reserve.
 @Return        PVRSRV_OK                   Success, output arguments valid.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamReserve2(IMG_HANDLE hStream,
                IMG_UINT8  **ppui8Data,
                IMG_UINT32 ui32Size,
                IMG_UINT32 ui32SizeMin,
                IMG_UINT32* pui32Available);

/*************************************************************************/ /*!
 @Function      TLStreamReserveReturnFlags
 @Description   Reserve space in stream buffer. When successful every
                  TLStreamReserve call must be followed by a matching
                  TLStreamCommit call. While a TLStreamCommit call is pending
                  for a stream, subsequent TLStreamReserve calls for this
                  stream will fail.
 @Input         hStream         Stream handle.
 @Output        ppui8Data       Pointer to a pointer to a location in the
                                  buffer. The caller can then use this address
                                  in writing data into the stream.
 @Input         ui32Size        Ideal number of bytes to reserve in buffer.
 @Output        pui32Flags      Output parameter to return flags generated within
                                the reserve function.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamReserveReturnFlags(IMG_HANDLE hStream,
        IMG_UINT8  **ppui8Data,
        IMG_UINT32 ui32Size,
		IMG_UINT32* pui32Flags);

/*************************************************************************/ /*!
 @Function      TLStreamGetUT
 @Description   Returns the current stream utilisation in bytes
 @Input         hStream     Stream handle.
 @Return        IMG_UINT32  Stream utilisation
*/ /**************************************************************************/
IMG_UINT32 TLStreamGetUT(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamCommit
 @Description   Notify TL that data have been written in the stream buffer.
                  Should always follow and match TLStreamReserve call.
 @Input         hStream         Stream handle.
 @Input         ui32Size        Number of bytes that have been added to the
                                  stream.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handle.
 @Return        PVRSRV_ERROR_STREAM_MISUSE   Commit results in more data
                                             committed than the buffer size,
                                             the stream is misused.
 @Return        eError                       Commit was successful but
                                             internal services call returned
                                             eError error number.
 @Return        PVRSRV_OK
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamCommit(IMG_HANDLE hStream,
               IMG_UINT32 ui32Size);

/*************************************************************************/ /*!
 @Function      TLStreamWrite
 @Description   Combined Reserve/Commit call. This function Reserves space in
                  the specified stream buffer, copies ui32Size bytes of data
                  from the array pui8Src points to and Commits in an "atomic"
                  style operation.
 @Input         hStream         Stream handle.
 @Input         pui8Src         Source to read data from.
 @Input         ui32Size        Number of bytes to copy and commit.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handler.
 @Return        eError                       Error codes returned by either
                                               Reserve or Commit.
 @Return        PVRSRV_OK
 */ /**************************************************************************/
PVRSRV_ERROR
TLStreamWrite(IMG_HANDLE hStream,
              IMG_UINT8  *pui8Src,
              IMG_UINT32 ui32Size);

/*************************************************************************/ /*!
 @Function      TLStreamWriteRetFlags
 @Description   Combined Reserve/Commit call. This function Reserves space in
                  the specified stream buffer, copies ui32Size bytes of data
                  from the array pui8Src points to and Commits in an "atomic"
                  style operation. Also accepts a pointer to a bit flag value
                  for returning write status flags.
 @Input         hStream         Stream handle.
 @Input         pui8Src         Source to read data from.
 @Input         ui32Size        Number of bytes to copy and commit.
 @Output        pui32Flags      Output parameter for write status info
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handler.
 @Return        eError                       Error codes returned by either
                                               Reserve or Commit.
 @Return        PVRSRV_OK
 */ /**************************************************************************/
PVRSRV_ERROR
TLStreamWriteRetFlags(IMG_HANDLE hStream,
                      IMG_UINT8 *pui8Src,
					  IMG_UINT32 ui32Size,
					  IMG_UINT32 *pui32Flags);

/*************************************************************************/ /*!
 @Function      TLStreamSync
 @Description   Signal the consumer to start acquiring data from the stream
                buffer. Called by producers that use the flag
                TL_FLAG_NO_SIGNAL_ON_COMMIT to manually control when
                consumers starting reading the stream.
                Used when multiple small writes need to be batched.
 @Input         hStream         Stream handle.
 @Return        PVRSRV_ERROR_INVALID_PARAMS  NULL stream handle.
 @Return        eError                       Error codes returned by either
                                             Reserve or Commit.
 @Return        PVRSRV_OK
 */ /**************************************************************************/
PVRSRV_ERROR
TLStreamSync(IMG_HANDLE hStream);


/*************************************************************************/ /*!
 @Function      TLStreamMarkEOS
 @Description   Insert a EOS marker packet in the given stream.
 @Input         hStream         Stream handle.
 @Input         bRemoveOld      if TRUE, remove old stream record file before
                                splitting to new file.
 @Return        PVRSRV_ERROR_INVALID_PARAMS NULL stream handler.
 @Return        eError                       Error codes returned by either
                                             Reserve or Commit.
 @Return        PVRSRV_OK                    Success.
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamMarkEOS(IMG_HANDLE hStream, IMG_BOOL bRemoveOld);

/*************************************************************************/ /*!
@Function       TLStreamMarkStreamOpen
@Description    Puts *open* stream packet into hStream's notification stream,
                if set, error otherwise."
@Input          hStream Stream handle.
@Return         PVRSRV_OK on success and error code on failure
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamMarkStreamOpen(IMG_HANDLE hStream);

/*************************************************************************/ /*!
@Function       TLStreamMarkStreamClose
@Description    Puts *close* stream packet into hStream's notification stream,
                if set, error otherwise."
@Input          hStream Stream handle.
@Return         PVRSRV_OK on success and error code on failure
*/ /**************************************************************************/
PVRSRV_ERROR
TLStreamMarkStreamClose(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamInfo
 @Description   Run time information about buffer elemental sizes.
                It sets psInfo members accordingly. Users can use those values
                to calculate the parameters they use in TLStreamCreate and
                TLStreamReserve.
 @Output        psInfo          pointer to stream info structure.
 @Return        None.
*/ /**************************************************************************/
void
TLStreamInfo(IMG_HANDLE hStream, PTL_STREAM_INFO psInfo);

/*************************************************************************/ /*!
 @Function      TLStreamIsOpenForReading
 @Description   Query if a stream has any readers connected.
 @Input         hStream         Stream handle.
 @Return        IMG_BOOL        True if at least one reader is connected,
                                false otherwise
*/ /**************************************************************************/
IMG_BOOL
TLStreamIsOpenForReading(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamOutOfData
 @Description   Query if the stream is empty (no data waiting to be read).
 @Input         hStream         Stream handle.
 @Return        IMG_BOOL        True if read==write, no data waiting,
                                false otherwise
*/ /**************************************************************************/
IMG_BOOL TLStreamOutOfData(IMG_HANDLE hStream);

/*************************************************************************/ /*!
 @Function      TLStreamResetProducerByteCount
 @Description   Reset the producer byte counter on the specified stream.
 @Input         hStream         Stream handle.
 @Input         IMG_UINT32      Value to reset counter to, often 0.
 @Return        PVRSRV_OK                   Success.
 @Return        PVRSRV_ERROR_STREAM_MISUSE  Success but the read and write
                                            positions did not match,
                                            stream not empty.
*/ /**************************************************************************/

PVRSRV_ERROR
TLStreamResetProducerByteCount(IMG_HANDLE hStream, IMG_UINT32 ui32Value);

#endif /* TLSTREAM_H */
/*****************************************************************************
 End of file (tlstream.h)
*****************************************************************************/