/*
 * Copyright (C) 2018 Synaptics Incorporated. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND
 * SYNAPTICS EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE, AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY
 * INTELLECTUAL PROPERTY RIGHTS. IN NO EVENT SHALL SYNAPTICS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE, OR
 * CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION WITH THE USE
 * OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED AND
 * BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF
 * COMPETENT JURISDICTION DOES NOT PERMIT THE DISCLAIMER OF DIRECT
 * DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' TOTAL CUMULATIVE LIABILITY
 * TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. DOLLARS.
 */

/******************************************************************************
*	 Revision 1.4  2007-10-30 10:58:43-07  chengjun
*	 Remove interrpt from HBO to semaphore. Map dHub channel 0 interrupt to
*	 semaphore channel 0.
*
*	 Revision 1.3  2007-10-24 21:41:17-07  kbhatt
*	 add structures to api_dhub.h
*
*	 Revision 1.2  2007-10-12 21:36:54-07  oussama
*	 adapted the env to use Alpha's Cmodel driver
*
*	 Revision 1.1  2007-08-29 20:27:01-07  lsha
*	 Initial revision.
*
*
*	 DESCRIPTION:
*	 OS independent layer for dHub/HBO/SemaHub APIs.
*
******************************************************************************/

#ifndef DHUB_API
#define DHUB_API "		  DHUB_API >>>	  "
/**	DHUB_API
 */

#include "com_type.h"

typedef UNSG32              T64b [2];

typedef struct {
	UINT32 ra;
	INT32 depth[32];
} HDL_semaphore;

typedef struct HDL_hbo {
	UINT32	mem;
	UINT32	ra;
	HDL_semaphore fifoCtl;
	UINT32 base[32];
} HDL_hbo;

typedef struct HDL_dhub {
	UINT32	ra;
	HDL_semaphore semaHub;
	HDL_hbo hbo;
	INT32 MTUb[16];
} HDL_dhub;

typedef struct HDL_dhub2d {
	UINT32 ra;
	HDL_dhub dhub;
} HDL_dhub2d;


#ifdef __cplusplus
	extern	  "C"
	{
#endif

/**	SECTION - handle of local contexts
 */
extern	  UINT32	sizeof_hdl_semaphore;
extern	  UINT32	sizeof_hdl_hbo;
extern	  UINT32	sizeof_hdl_dhub;
extern	  UINT32	sizeof_hdl_dhub2d;

/**	ENDOFSECTION
 */

/**	SECTION - API definitions for $SemaHub
 */
/******************************************************************************
*	 Function: semaphore_hdl
*	 Description: Initialize HDL_semaphore with a $SemaHub BIU instance.
******************************************************************************/
void semaphore_hdl(UINT32 ra, void *hdl);

/******************************************************************************
*	 Function: semaphore_cfg
*	 Description: Configurate a semaphore's depth & reset pointers.
*	 Return:	UINT32	  -Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 semaphore_cfg(void *hdl, INT32	id, INT32 depth, T64b cfgQ[]);


/******************************************************************************
*	 Function: semaphore_intr_enable
*	 Description: Configurate interrupt enable bits of a semaphore.
******************************************************************************/
void semaphore_intr_enable(void *hdl, INT32 id, INT32 empty, INT32 full,
			INT32 almostEmpty, INT32 almostFull, INT32 cpu);

/******************************************************************************
*	 Function: semaphore_query
*	 Description: Query current status (counter & pointer) of a semaphore.
*	 Return:	UINT32	  -Current available unit level
******************************************************************************/
UINT32 semaphore_query(void *hdl, INT32 id, INT32	 master, UINT32	*ptr);

/******************************************************************************
*	 Function: semaphore_push
*	 Description: Producer semaphore push.
******************************************************************************/
void semaphore_push(void *hdl, INT32 id, INT32 delta);

/******************************************************************************
*	 Function: semaphore_push
*	 Description: Consumer semaphore pop.
******************************************************************************/
void semaphore_pop(void *hdl, INT32 id, INT32 delta);

/******************************************************************************
*	 Function: semaphore_chk_empty
*	 Description: Check 'empty' status of a semaphore(or all semaphores).
*	 Return:	UINT32	  -status bit of given semaphore, or
*			 status bits of all semaphores if id==-1
******************************************************************************/
UINT32 semaphore_chk_empty(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_chk_full
*	 Description: Check 'full' status of a semaphore (or all semaphores).
*	 Return: UINT32	-status bit of given semaphore, or
*			 status bits of all semaphores if id==-1
******************************************************************************/
UINT32 semaphore_chk_full(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_chk_almostEmpty
*	 Description: Check 'almostEmpty' status of a semaphore
*					(or all semaphores).
*	 Return:	UINT32	  -status bit of given semaphore, or
*			 status bits of all semaphores if id==-1
******************************************************************************/
UINT32 semaphore_chk_almostEmpty(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_chk_almostFull
*	 Description: Check 'almostFull' status of a semaphore
*				  (or all semaphores).
*	 Return:	UINT32	  -status bit of given semaphore, or
*			 status bits of all semaphores if id==-1
******************************************************************************/
UINT32 semaphore_chk_almostFull(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_clr_empty
*	 Description: Clear 'empty' status of a semaphore.
******************************************************************************/
void semaphore_clr_empty(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_clr_full
*	 Description: Clear 'full' status of a semaphore.
******************************************************************************/
void semaphore_clr_full(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_clr_almostEmpty
*	 Description: Clear 'almostEmpty' status of a semaphore.
******************************************************************************/
void semaphore_clr_almostEmpty(void *hdl, INT32 id);

/******************************************************************************
*	 Function: semaphore_clr_almostFull
*	 Description: Clear 'almostFull' status of a semaphore.
******************************************************************************/
void semaphore_clr_almostFull(void *hdl, INT32 id);

/**	ENDOFSECTION
 */

/**	SECTION - API definitions for $HBO
 */
/******************************************************************************
*	 Function: hbo_hdl
*	 Description: Initialize HDL_hbo with a $HBO BIU instance.
******************************************************************************/
void hbo_hdl(UINT32 mem, INT32 ra, void *hdl);

/******************************************************************************
*	 Function: hbo_fifoCtl
*	 Description: Get HDL_semaphore pointer from a HBO instance.
*	 Return:	void*	 -Handle for HBO.FiFoCtl
******************************************************************************/
void *hbo_fifoCtl(void	*hdl);

/******************************************************************************
*	 DEFINITION - convert HBO FIFO control to semaphore control
******************************************************************************/
#define hbo_queue_intr_enable(hdl, id, empty, full, almostEmpty, \
	almostFull, cpu) \
	semaphore_intr_enable(hbo_fifoCtl(hdl), id, empty, full, almostEmpty, \
		almostFull, cpu)

#define	hbo_queue_query(hdl, id, master, ptr) \
		semaphore_query(hbo_fifoCtl(hdl), id, master, ptr)

#define	hbo_queue_push(hdl, id, delta)	\
			  semaphore_push(hbo_fifoCtl(hdl), id, delta)

#define	hbo_queue_pop(hdl, id, delta)	  \
			  semaphore_pop(hbo_fifoCtl(hdl), id, delta)

#define	hbo_queue_chk_empty(hdl, id)	  \
			  semaphore_chk_empty(hbo_fifoCtl(hdl), id)

#define	hbo_queue_chk_full(hdl, id)	 \
			  semaphore_chk_full(hbo_fifoCtl(hdl), id)

#define	hbo_queue_chk_almostEmpty(hdl, id)\
			  semaphore_chk_almostEmpty(hbo_fifoCtl(hdl), id)

#define	hbo_queue_chk_almostFull(hdl, id)\
			  semaphore_chk_almostFull(hbo_fifoCtl(hdl), id)

#define	hbo_queue_clr_empty(hdl, id)	  \
			  semaphore_clr_empty(hbo_fifoCtl(hdl), id)

#define	hbo_queue_clr_full(hdl, id)	 \
			  semaphore_clr_full(hbo_fifoCtl(hdl), id)

#define	hbo_queue_clr_almostEmpty(hdl, id)\
			  semaphore_clr_almostEmpty(hbo_fifoCtl(hdl), id)

#define	hbo_queue_clr_almostFull(hdl, id)\
			  semaphore_clr_almostFull(hbo_fifoCtl(hdl), id)

/******************************************************************************
*	 Function: hbo_queue_cfg
*	 Description: Configurate a FIFO's base, depth & reset pointers.
*	 Return:	UINT32	  -Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 hbo_queue_cfg(void *hdl, INT32 id, UINT32 base, INT32 depth,
		INT32 enable, T64b cfgQ[]);

/******************************************************************************
*	 Function: hbo_queue_enable
*	 Description: HBO FIFO enable/disable.
*	 Return:	UINT32	  -Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 hbo_queue_enable(void *hdl, INT32 id, INT32 enable, T64b cfgQ[]);

/******************************************************************************
*	 Function: hbo_queue_clear
*	 Description: Issue HBO FIFO clear (will NOT wait for finish).
******************************************************************************/
void hbo_queue_clear(void *hdl, INT32 id);

/******************************************************************************
*	 Function: hbo_queue_busy
*	 Description: Read HBO 'BUSY' status for all channel FIFOs.
*	 Return:	UINT32	  -'BUSY' status bits of all channels
******************************************************************************/
UINT32	  hbo_queue_busy(void *hdl);

/******************************************************************************
*	 Function: hbo_queue_clear_done
*	 Description: Wait for a given channel or all channels to be cleared.
******************************************************************************/
void hbo_queue_clear_done(void *hdl, INT32 id);

/******************************************************************************
*	 Function: hbo_queue_read
*	 Description: Read a number of 64b data & pop FIFO from HBO SRAM.
*	 Return: UINT32 -Number of 64b data being read (=n),
*			 or (when cfgQ==NULL)
*			 0 if there're not sufficient data in FIFO
******************************************************************************/
UINT32 hbo_queue_read(void *hdl, INT32 id, INT32 n, T64b data[], UINT32 *ptr);

/******************************************************************************
*	 Function: hbo_queue_write
*	 Description: Write a number of 64b data & push FIFO to HBO SRAM.
*	 Return: UINT32-Number of (adr,pair) added to cfgQ, or (when cfgQ==NULL)
*			 0 if there're not sufficient space in FIFO
******************************************************************************/
UINT32 hbo_queue_write(void *hdl, INT32 id, INT32 n,
		T64b data[], T64b cfgQ[], UINT32 *ptr);

/**	ENDOFSECTION
 */

/**	SECTION - API definitions for $dHubReg
 */
/******************************************************************************
*	 Function: dhub_hdl
*	 Description: Initialize HDL_dhub with a $dHub BIU instance.
******************************************************************************/
void dhub_hdl(UINT32	mem, UINT32 ra, void *hdl);

/******************************************************************************
*	 Function: dhub_semaphore
*	 Description: Get HDL_semaphore pointer from a dHub instance.
*	 Return:	void* -	Handle for dHub.SemaHub
******************************************************************************/
void *dhub_semaphore(void *hdl);

/******************************************************************************
*	 Function: dhub_hbo
*	 Description: Get HDL_hbo pointer from a dHub instance.
*	 Return:	void*	 -Handle for dHub.HBO
******************************************************************************/
void *dhub_hbo(void *hdl);

/******************************************************************************
*	 Function: dhub_hbo_fifoCtl
*	 Description: Get HDL_semaphore pointer from the HBO of a dHub instance.
*	 Return:	void*	 -Handle for dHub.HBO.FiFoCtl
******************************************************************************/
#define	dhub_hbo_fifoCtl(hdl)		(hbo_fifoCtl(dhub_hbo(hdl)))

/******************************************************************************
*	 DEFINITION - convert from dHub channel ID to HBO FIFO ID & semaphore (interrupt) ID
******************************************************************************/
#define	dhub_id2intr(id) ((id))
#define	dhub_id2hbo_cmdQ(id) ((id)*2)
#define	dhub_id2hbo_data(id) ((id)*2+1)

/******************************************************************************
*	 DEFINITION - convert dHub cmdQ/dataQ/channel-done interrupt control to
*					HBO/semaphore control
******************************************************************************/

#define	dhub_channel_intr_enable(hdl, id, full, cpu)	\
			  semaphore_intr_enable(dhub_semaphore(hdl), \
			  dhub_id2intr(id), 0, full, \
			  0, 0, cpu)

#define	dhub_hbo_cmdQ_intr_enable(hdl, id, empty, almostEmpty, cpu) \
			  hbo_queue_intr_enable(dhub_hbo(hdl), \
			  dhub_id2hbo_cmdQ(id), empty,\
			  0, almostEmpty, 0, cpu)

#define	dhub_hbo_data_intr_enable(hdl, id, empty, full, almostEmpty,\
		almostFull, cpu) \
			  hbo_queue_intr_enable(dhub_hbo(hdl), \
			  dhub_id2hbo_data(id), empty, \
			  full, almostEmpty, almostFull, cpu)

/******************************************************************************
*	 DEFINITION - convert dHub cmdQ opehdltions to HBO FIFO opehdltions
******************************************************************************/
#define	dhub_cmdQ_query(hdl, id, ptr)		\
		  hbo_queue_query(dhub_hbo(hdl), \
		  dhub_id2hbo_cmdQ(id), 0, ptr)

#define	dhub_cmdQ_push(hdl, id, delta)	\
		  hbo_queue_push(dhub_hbo(hdl), \
		  dhub_id2hbo_cmdQ(id), delta)

/******************************************************************************
*	 DEFINITION - convert dHub dataQ opehdltions to HBO FIFO opehdltions
******************************************************************************/
#define	dhub_data_query(hdl, id, master, ptr)\
		  hbo_queue_query(dhub_hbo(hdl), dhub_id2hbo_data(id),\
		  master, ptr)

#define	dhub_data_push(hdl, id, delta)	\
		  hbo_queue_push(dhub_hbo(hdl), dhub_id2hbo_data(id),\
		  delta)

#define	dhub_data_pop(hdl, id, delta)	  \
		  hbo_queue_pop(dhub_hbo(hdl), dhub_id2hbo_data(id), \
		  delta)

/******************************************************************************
*	 Function: dhub_channel_cfg
*	 Description: Configurate a dHub channel.
*	 Return: UINT32-Number of (adr,pair) added to cfgQ, or (when cfgQ==NULL)
*			 0 if either cmdQ or dataQ in HBO is still busy
******************************************************************************/
UINT32 dhub_channel_cfg(void *hdl, INT32 id, UINT32 baseCmd,
		 UINT32 baseData, INT32 depthCmd, INT32 depthData,
		 INT32 MTU, INT32 QoS, INT32 selfLoop,
		 INT32 enable, T64b cfgQ[]);

/******************************************************************************
*	 Function: dhub_channel_enable
*	 Description: dHub channel enable/disable.
*	 Return:	UINT32	  -Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 dhub_channel_enable(void *hdl, INT32 id, INT32 enable, T64b cfgQ[]);

/******************************************************************************
*	 Function: dhub_channel_clear
*	 Description: Issue dHub channel clear (will NOT wait for finish).
******************************************************************************/
void dhub_channel_clear(void *hdl, INT32 id);

/******************************************************************************
*	 Function: dhub_channel_flush
*	 Description: Issue dHub channel (H2M only) flush
*				  (will NOT wait for finish).
******************************************************************************/
void dhub_channel_flush(void *hdl, INT32 id);

/******************************************************************************
*	 Function: dhub_channel_busy
*	 Description: Read dHub 'BUSY' status for all channel FIFOs.
*	 Return:	UINT32	  -'BUSY' status bits of all channels
******************************************************************************/
UINT32 dhub_channel_busy(void *hdl);

/******************************************************************************
*	 Function: dhub_channel_pending
*	 Description: Read dHub 'PENDING' status for all channel FIFOs.
*	 Return:	UINT32	  -'PENDING' status bits of all channels
******************************************************************************/
UINT32 dhub_channel_pending(void *hdl);

/******************************************************************************
*	 Function: dhub_channel_clear_done
*	 Description: Wait for a given channel or all channels to be cleared or
*				  flushed.
******************************************************************************/
void dhub_channel_clear_done(void *hdl, INT32 id);

/******************************************************************************
*	 Function: dhub_channel_write_cmd
*	 Description: Write a 64b command for a dHub channel.
*	 Return: UINT32-Number of (adr,pair) added to cfgQ if success, or
*			 0 if there're not sufficient space in FIFO
******************************************************************************/
UINT32 dhub_channel_write_cmd(void *hdl, INT32 id, UINT32 addr,
		INT32 size, INT32 semOnMTU, INT32 chkSemId,
		INT32 updSemId, INT32 interrupt, T64b cfgQ[],
		UINT32  *ptr);

/**	ENDOFSECTION
 */

void dhub_channel_generate_cmd(void *hdl, INT32 id, UINT32 *addr,
		INT32 size, INT32 semOnMTU, INT32 chkSemId,
		INT32 updSemId, INT32 interrupt, INT32  *pData);

/******************************************************************************
*		Function: dhub_channel_big_write_cmd
*		Description: Write a sequence of 64b command for a dHub channel.
*		Return: UINT32-Number of (adr,pair) added to cfgQ if success, or
*				0 if there're not sufficient space in FIFO.
******************************************************************************/
UINT32 dhub_channel_big_write_cmd(void *hdl, INT32 id, UINT32 addr,
		INT32 size, INT32 semOnMTU, INT32 chkSemId,
		INT32 updSemId, INT32 interrupt, T64b cfgQ[], UINT32 *ptr);


/**	SECTION - API definitions for $dHubReg2D
 */
/******************************************************************************
*	 Function: dhub2d_hdl
*	 Description: Initialize HDL_dhub2d with a $dHub2D BIU instance.
******************************************************************************/
void dhub2d_hdl(UINT32 mem, UINT32 ra, void *hdl);

/******************************************************************************
*	 Function: dhub2d_channel_cfg
*	 Description: Configurate a dHub2D channel.
*	 Return:	UINT32	  -Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 dhub2d_channel_cfg(void *hdl, INT32 id, UINT32 addr,
		 INT32 stride, INT32  width, INT32 height,
		 INT32 semLoop, INT32  semOnMTU, INT32 chkSemId[],
		 INT32  updSemId[], INT32 interrupt, INT32 enable,
		 T64b cfgQ[]);

/******************************************************************************
*	 Function: dhub2d_channel_enable
*	 Description: dHub2D channel enable/disable.
*	 Return: UINT32 - Number of (adr,pair) added to cfgQ
******************************************************************************/
UINT32 dhub2d_channel_enable(void *hdl, INT32 id,
						INT32 enable, T64b cfgQ[]);

/******************************************************************************
*	 Function: dhub2d_channel_clear
*	 Description: Issue dHub2D channel clear (will NOT wait for finish).
******************************************************************************/
void dhub2d_channel_clear(void *hdl, INT32 id);

/******************************************************************************
*	 Function: dhub2d_channel_busy
*	 Description: Read dHub2D 'BUSY' status for all channel FIFOs.
*	 Return: UINT32 -	'BUSY' status bits of all channels
******************************************************************************/
UINT32 dhub2d_channel_busy(void *hdl);

/******************************************************************************
*	 Function: dhub2d_channel_clear_done
*	 Description: Wait for a given channel or all channels to be cleared.
******************************************************************************/
void dhub2d_channel_clear_done(void *hdl, INT32 id);

    /******************************************************************************************************************
     *   Function: dhub2nd_channel_cfg
     *   Description: Configurate a dHub2ND channel.
     *   Return:         UNSG32                      -   Number of (adr,pair) added to cfgQ
     ******************************************************************************************************************/
    UNSG32  dhub2nd_channel_cfg(
            void        *hdl,               /*! Handle to HDL_dhub2d !*/
            SIGN32      id,                 /*! Channel ID in $dHubReg2D !*/
            UNSG32      addr,               /*! CMD: 2ND-buffer address !*/
            SIGN32      burst,              /*! CMD: line stride size in bytes !*/
            SIGN32      step1,              /*! CMD: buffer width in bytes !*/
            SIGN32      size1,              /*! CMD: buffer height in lines !*/
            SIGN32      step2,              /*! CMD: loop size (1~4) of semaphore operations !*/
            SIGN32      size2,              /*! CMD: semaphore operation at CMD/MTU (0/1) !*/
            SIGN32      chkSemId,           /*! CMD: semaphore loop pattern - non-zero to check !*/
            SIGN32      updSemId,           /*! CMD: semaphore loop pattern - non-zero to update !*/
            SIGN32      interrupt,          /*! CMD: raise interrupt at CMD finish !*/
            SIGN32      enable,             /*! 0 to disable, 1 to enable !*/
            T64b        cfgQ[]              /*! Pass NULL to directly init dHub2ND, or
                                              Pass non-zero to receive programming sequence
                                              in (adr,data) pairs
                                              !*/
            );

    /******************************************************************************************************************
     *   Function: dhub2nd_channel_enable
     *   Description: dHub2ND channel enable/disable.
     *   Return:         UNSG32                      -   Number of (adr,pair) added to cfgQ
     ******************************************************************************************************************/
    UNSG32  dhub2nd_channel_enable(
            void        *hdl,               /*! Handle to HDL_dhub2d !*/
            SIGN32      id,                 /*! Channel ID in $dHubReg2D !*/
            SIGN32      enable,             /*! 0 to disable, 1 to enable !*/
            T64b        cfgQ[]              /*! Pass NULL to directly init dHub2D, or
                                              Pass non-zero to receive programming sequence
                                              in (adr,data) pairs
                                              !*/
            );

    /******************************************************************************************************************
     *   Function: dhub2nd_channel_clear
     *   Description: Issue dHub2ND channel clear (will NOT wait for finish).
     ******************************************************************************************************************/
    void    dhub2nd_channel_clear(
            void        *hdl,               /*! Handle to HDL_dhub2d !*/
            SIGN32      id                  /*! Channel ID in $dHubReg2D !*/
            );

    UNSG32 dhub_channel_enable_InverseScan_vppBcm(void *hdl, SIGN32 id,
                    SIGN32 iMode, UNSG32 pbcmbuf);

#if (BERLIN_CHIP_VERSION >= BERLIN_BG2_CT)
/******************************************************************************************************************
*       Function: dhub_channel_enable_InverseScan
*       Description: Enable the inverse scan at loader.
******************************************************************************************************************/
UNSG32 dhub_channel_enable_InverseScan(void *hdl, SIGN32 id, SIGN32 iMode, T64b cfgQ[]);
int getDhubChannelInfo(HDL_dhub2d *pdhubHandle, SIGN32 IChannel, T32dHubChannel_CFG *cfg);
#endif

void dhub2d_channel_start_seq(void *hdl, INT32 id);
void dhub2d_channel_clear_seq(void *hdl, INT32 id);
void dhub2d_channel_clear_seq_bcm(void *hdl, INT32 id, void *pbcmbuf);

/**	ENDOFSECTION
 */

#if (BERLIN_CHIP_VERSION >= BERLIN_BG2)
typedef enum {
	BCM_SCHED_Q0 = 0,
	BCM_SCHED_Q1,
	BCM_SCHED_Q2,
	BCM_SCHED_Q3,
	BCM_SCHED_Q4,
	BCM_SCHED_Q5,
	BCM_SCHED_Q6,
	BCM_SCHED_Q7,
	BCM_SCHED_Q8,
	BCM_SCHED_Q9,
	BCM_SCHED_Q10,
	BCM_SCHED_Q11,
	BCM_SCHED_Q12,
	BCM_SCHED_Q13,
	BCM_SCHED_Q14,
	BCM_SCHED_Q15,
	BCM_SCHED_Q16,
	BCM_SCHED_Q17,
	BCM_SCHED_Q18,
} ENUM_BCM_SCHED_QID;


typedef struct VIP_BCMBUF_T {
	unsigned int *head;
	unsigned int *tail;
	unsigned int *writer;
	int size;
} VIP_BCMBUF;

typedef enum {
	BCM_SCHED_TRIG_CPCB0_VBI = 0,
	BCM_SCHED_TRIG_CPCB1_VBI,
	BCM_SCHED_TRIG_CPCB2_VBI,
	BCM_SCHED_TRIG_CPCB0_VDE,
	BCM_SCHED_TRIG_CPCB1_VDE,
	BCM_SCHED_TRIG_CPCB2_VDE,
	BCM_SCHED_TRIG_AUD_PRIM,
	BCM_SCHED_TRIG_AUD_SEC,
	BCM_SCHED_TRIG_AUD_HDMI,
	BCM_SCHED_TRIG_AUD_SPDIF,
	BCM_SCHED_TRIG_AUD_MIC,/*0xA*/
	BCM_SCHED_TRIG_VBI_VDE,
	BCM_SCHED_TRIG_DVI_VDE,
	BCM_SCHED_TRIG_SD_WRE,
	BCM_SCHED_TRIG_SD_RDE,
	BCM_SCHED_TRIG_SD_ERR,/*0xF*/
	BCM_SCHED_TRIG_NONE = 0x1f,

} ENUM_BCM_SCHED_TRIG_EVENT;

void BCM_SCHED_Open(void);
void BCM_SCHED_Close(void);
void BCM_SCHED_SetMux(UNSG32 QID, UNSG32 TrigEvent);

int BCM_SCHED_PushCmd(UINT32 QID, UINT32 *pCmd, UINT32 *cfgQ);

int BCM_SCHED_AutoPushCmd(UNSG32 QID, UNSG8 uchEnable);

#if (BERLIN_CHIP_VERSION >= BERLIN_BG2)
void BCM_SCHED_SetMux(UINT32 QID, UINT32 TrigEvent);
#endif
void BCM_SCHED_GetEmptySts(UINT32 QID, UINT32 *EmptySts);

#endif

#ifdef __cplusplus
	}
#endif

/**	DHUB_API
 */
#endif