| /* |
| * 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 |
