| /* |
| * 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. |
| */ |
| |
| #include "vpp_bcmbuf.h" |
| #include "vpp_module.h" |
| #include "vpp_api.h" |
| #include "avio.h" |
| #include "util.h" |
| #include "common.h" |
| |
| static inline void FLUSH_DCACHE_RANGE(void* start, unsigned int size) |
| { |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wpointer-to-int-cast" |
| #pragma GCC diagnostic ignored "-Wint-to-pointer-cast" |
| flush_dcache_range(start, (void*)(((int)(start))+(size))); |
| #pragma GCC diagnostic pop |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: allocate register programming buffer |
| * PARAMS: *buf - pointer to a register programming buffer |
| * : size - size of the buffer to allocate |
| * : - (should be a multiple of 4) |
| * RETURN: 1 - succeed |
| * 0 - failed to initialize a BCM buffer |
| ******************************************************************************/ |
| INT VPP_BCMBUF_Create(BCMBUF *pbcmbuf, int size) |
| { |
| pbcmbuf->handle = NULL; |
| pbcmbuf->handle = UtilMemAllocZ(size); |
| if(pbcmbuf->handle == NULL) { |
| printf("TRACE alloc failure\n"); |
| return -1; |
| } |
| pbcmbuf->size = size; |
| pbcmbuf->head = pbcmbuf->handle; |
| pbcmbuf->phy_addr = pbcmbuf->handle; |
| return 0; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: free register programming buffer |
| * PARAMS: *buf - pointer to a register programming buffer |
| * RETURN: 1 - succeed |
| * 0 - failed to initialize a BCM buffer |
| ******************************************************************************/ |
| INT VPP_BCMBUF_Destroy(BCMBUF *pbcmbuf) |
| { |
| /* allocate memory for the buffer */ |
| if (!pbcmbuf->head) |
| return MV_VPP_EBADCALL; |
| |
| pbcmbuf->head = NULL; |
| return MV_VPP_OK; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: reset a register programming buffer |
| * PARAMS: *buf - pointer to a register programming buffer |
| * RETURN: 1 - succeed |
| * 0 - failed to initialize a BCM buffer |
| ******************************************************************************/ |
| INT VPP_BCMBUF_Reset(BCMBUF *pbcmbuf) |
| { |
| pbcmbuf->tail = pbcmbuf->head + (pbcmbuf->size/4); |
| /*set pointers to the head*/ |
| pbcmbuf->writer = pbcmbuf->head; |
| pbcmbuf->dv1_head = pbcmbuf->head; |
| pbcmbuf->dv2_head = pbcmbuf->dv1_head + (pbcmbuf->size/12); |
| pbcmbuf->dv3_head = pbcmbuf->dv2_head + (pbcmbuf->size/12); |
| pbcmbuf->subID = -1; /* total */ |
| return MV_VPP_OK; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: selest BCM sub-buffer to use |
| * PARAMS: *buf - pointer to the buffer descriptor |
| * subID - DV_1, DV_2, DV_3 |
| ******************************************************************************/ |
| void VPP_BCMBUF_Select(BCMBUF *pbcmbuf, INT subID) |
| { |
| /* reset read/write pointer of the buffer */ |
| if (subID == CPCB_1) |
| pbcmbuf->writer = pbcmbuf->dv1_head; |
| else |
| pbcmbuf->writer = pbcmbuf->head; |
| |
| pbcmbuf->subID = subID; |
| return; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: write register address (4bytes) and value |
| * (4bytes) to the buffer |
| * PARAMS: *buf - pointer to the buffer descriptor |
| * address - address of the register to be set |
| * value - the value to be written into the |
| * register |
| * RETURN: 1 - succeed |
| * 0 - register programming buffer is full |
| ******************************************************************************/ |
| INT VPP_BCMBUF_Write(BCMBUF *pbcmbuf, UINT32 address, UINT32 value) |
| { |
| UINT32 *end; |
| /*if not enough space for storing another 8 bytes, wrap around happens*/ |
| if (pbcmbuf->subID == CPCB_1) |
| end = pbcmbuf->dv2_head; |
| else |
| end = pbcmbuf->tail; |
| |
| if (pbcmbuf->writer == end) { |
| /*the buffer is full, no space for wrap around*/ |
| return MV_VPP_EBCMBUFFULL; |
| } |
| |
| *pbcmbuf->writer = value; |
| pbcmbuf->writer++; |
| *pbcmbuf->writer = address; |
| pbcmbuf->writer++; |
| return MV_VPP_OK; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: write a block of data to BCM buffer |
| * PARAMS: *buf - pointer to the buffer descriptor |
| * *pdata - pointer to the data |
| * length - the length of the data to be written |
| * to BCM buffer |
| * RETURN: 1 - succeed |
| * 0 - register programming buffer is full |
| ******************************************************************************/ |
| INT VPP_BCMBUF_WriteBlock(BCMBUF *pbcmbuf, UINT32 *pdata, UINT32 length) |
| { |
| UINT32 *end; |
| |
| if (pbcmbuf->subID == CPCB_1) |
| end = pbcmbuf->dv2_head; |
| else |
| end = pbcmbuf->tail; |
| |
| if (pbcmbuf->writer > end-(length >> 2)) { |
| /*the buffer is full*/ |
| return MV_VPP_EBCMBUFFULL; |
| } |
| |
| /*save the data to BCM buffer*/ |
| UtilMemCpy(pbcmbuf->writer, pdata, length); |
| pbcmbuf->writer += (length >> 2); |
| |
| return MV_VPP_OK; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: do the hardware transmission |
| * PARAMS: block - 0:return without waiting for |
| * transactionfinishing |
| * 1:return after waiting for |
| * transaction finishing |
| ******************************************************************************/ |
| void VPP_BCMBUF_HardwareTrans(BCMBUF *pbcmbuf, INT block) |
| { |
| HDL_semaphore *pSemHandle; |
| HDL_dhub2d *pDhubHandle; |
| UINT32 *start; |
| int status; |
| int dhubID, size; |
| INT32 shm_offset; |
| unsigned int bcm_sched_cmd[2]; |
| |
| if (pbcmbuf->subID == CPCB_1) { |
| start = pbcmbuf->dv1_head; |
| shm_offset = pbcmbuf->dv1_head - pbcmbuf->head; |
| } else { |
| start = pbcmbuf->head; |
| shm_offset = 0; |
| } |
| |
| size = pbcmbuf->writer-start; |
| if (size <= 0) |
| return; |
| size = size<<2; |
| /* flush data in D$ */ |
| FLUSH_DCACHE_RANGE(pbcmbuf->phy_addr+shm_offset, size); |
| /* get non-cache physical address for DMA */ |
| //VPP_SHM_GetPhysicalAddress(pbcmbuf->handle, shm_offset, &start); |
| start = pbcmbuf->handle + shm_offset; |
| |
| /* start BCM engine */ |
| dhubID = avioDhubChMap_aio64b_BCM_R; |
| pDhubHandle = &AG_dhubHandle; |
| |
| if (block) { |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| /* clear possible BCM previous interrupt */ |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| if (status) { |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| } |
| } |
| /* clear BCM interrupt */ |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| while (status) { |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| } |
| |
| dhub_channel_generate_cmd(&(pDhubHandle->dhub), dhubID, start, |
| size, 0, 0, 0, 1, (int*)bcm_sched_cmd); |
| |
| while (!BCM_SCHED_PushCmd(BCM_SCHED_Q12, bcm_sched_cmd, NULL)) { |
| /* Wait till HW transaction |
| compeltes |
| */ |
| } |
| |
| if (block) { |
| /* check BCM interrupt */ |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| while (!status) |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| /* clear BCM interrupt */ |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| } |
| } |
| |
| void VPP_BCMBUF_HardwareTrans_Direct(INT block, UINT32 *start, int size) |
| { |
| HDL_semaphore *pSemHandle; |
| HDL_dhub2d *pDhubHandle; |
| int status; |
| int dhubID; |
| unsigned int bcm_sched_cmd[2]; |
| |
| if (size <= 0) |
| return; |
| size = size<<2; |
| /* flush data in D$ */ |
| FLUSH_DCACHE_RANGE(start, size); |
| |
| /* start BCM engine */ |
| dhubID = avioDhubChMap_aio64b_BCM_R; |
| pDhubHandle = &AG_dhubHandle; |
| |
| if (block) { |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| /* clear possible BCM previous interrupt */ |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| if (status) { |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| } |
| } |
| /* clear BCM interrupt */ |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| while (status) { |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| } |
| |
| dhub_channel_generate_cmd(&(pDhubHandle->dhub), dhubID, start, |
| size, 0, 0, 0, 1, (int*)bcm_sched_cmd); |
| |
| while (!BCM_SCHED_PushCmd(BCM_SCHED_Q12, bcm_sched_cmd, NULL)) { |
| /* Wait till HW transaction |
| compeltes |
| */ |
| } |
| |
| if (block) { |
| /* check BCM interrupt */ |
| pSemHandle = dhub_semaphore(&(pDhubHandle->dhub)); |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| while (!status) |
| status = semaphore_chk_full(pSemHandle, dhubID); |
| /* clear BCM interrupt */ |
| semaphore_pop(pSemHandle, dhubID, 1); |
| semaphore_clr_full(pSemHandle, dhubID); |
| } |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: send a BCM BUF info info to a BCM cfgQ |
| * PARAMS: *pbcmbuf - pointer to the BCMBUF |
| * *cfgQ - target BCM cfgQ |
| * NOTE: this API is only called from VBI/VDE ISR. |
| *****************************************************************************/ |
| int VPP_BCMBUF_To_CFGQ(BCMBUF *pbcmbuf, DHUB_CFGQ *cfgQ) |
| { |
| UINT32 *start, *phy_start; |
| INT32 size, shm_offset; |
| unsigned int bcm_sched_cmd[2]; |
| |
| if (pbcmbuf->subID == CPCB_1) { |
| start = pbcmbuf->dv1_head; |
| shm_offset = pbcmbuf->dv1_head - pbcmbuf->head; |
| phy_start = pbcmbuf->phy_addr; |
| } else { |
| start = pbcmbuf->head; |
| shm_offset = 0; |
| phy_start = pbcmbuf->phy_addr; |
| } |
| |
| size = pbcmbuf->writer-start; |
| |
| if (size <= 0) |
| return MV_VPP_EBADPARAM; |
| |
| size = size << 2; |
| FLUSH_DCACHE_RANGE(pbcmbuf->phy_addr+shm_offset, size); |
| dhub_channel_generate_cmd(&(AG_dhubHandle.dhub), |
| avioDhubChMap_aio64b_BCM_R, |
| phy_start, size, 0, 0, 0, 1, (int*)bcm_sched_cmd); |
| while (!BCM_SCHED_PushCmd(BCM_SCHED_Q13, bcm_sched_cmd, |
| cfgQ->addr + cfgQ->len*2)) { |
| /* Wait till transaction */ |
| } |
| |
| cfgQ->len += 2; |
| |
| return MV_VPP_OK; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: send a raw BCM BUF info to a BCM cfgQ |
| * PARAMS: pdata - pointer to the data block |
| * length - data length for transaction |
| * *cfgQ - target BCM cfgQ |
| * NOTE: this API is only called from VBI/VDE ISR. |
| *****************************************************************************/ |
| void VPP_BCMBUF_Raw_To_CFGQ(UINT32 *pdata, UINT32 length, |
| DHUB_CFGQ *cfgQ) |
| { |
| unsigned int bcm_sched_cmd[2]; |
| |
| dhub_channel_generate_cmd(&(AG_dhubHandle.dhub), |
| avioDhubChMap_aio64b_BCM_R, pdata, |
| length, 0, 0, 0, 1, (int*)bcm_sched_cmd); |
| while (!BCM_SCHED_PushCmd(BCM_SCHED_Q13, bcm_sched_cmd, |
| cfgQ->addr + cfgQ->len*2)) { |
| /* Wait till transaction */ |
| } |
| cfgQ->len += 2; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: send a BCM cfgQ info to a BCM cfgQ |
| * PARAMS: src_cfgQ - pointer to the source BCM cfgQ |
| * *cfgQ - target BCM cfgQ |
| * NOTE: this API is only called from VBI/VDE ISR. |
| *****************************************************************************/ |
| void VPP_CFGQ_To_CFGQ(DHUB_CFGQ *src_cfgQ, DHUB_CFGQ *cfgQ) |
| { |
| unsigned int bcm_sched_cmd[2]; |
| |
| if (src_cfgQ->len <= 0) |
| return; |
| |
| FLUSH_DCACHE_RANGE(src_cfgQ->phy_addr, src_cfgQ->len*8); |
| dhub_channel_generate_cmd(&(AG_dhubHandle.dhub), |
| avioDhubChMap_aio64b_BCM_R, |
| src_cfgQ->phy_addr, (INT)src_cfgQ->len*8, |
| 0, 0, 0, 1, (int*)bcm_sched_cmd); |
| while (!BCM_SCHED_PushCmd(BCM_SCHED_Q13, bcm_sched_cmd, |
| cfgQ->addr + cfgQ->len*2)) { |
| /* Wait till transaction */ |
| } |
| cfgQ->len += 2; |
| } |
| |
| /****************************************************************************** |
| * FUNCTION: commit cfgQ which contains BCM DHUB programming info to interrupt |
| * service routine |
| * PARAMS: *cfgQ - cfgQ |
| * cpcbID - cpcb ID which this cmdQ belongs to |
| * intrType - interrupt type which this cmdQ belongs to: |
| * 0-VBI, 1-VDE |
| * NOTE: this API is only called from VBI/VDE ISR. |
| *****************************************************************************/ |
| int VPP_BCMDHUB_CFGQ_Commit(DHUB_CFGQ *cfgQ, int cpcbID, int intrType) |
| { |
| unsigned int sched_qid = BCM_SCHED_Q1; |
| unsigned int bcm_sched_cmd[2]; |
| |
| if (cfgQ->len <= 0) |
| return MV_VPP_EBADPARAM; |
| |
| if (cpcbID == CPCB_1) { |
| if (intrType == 0) |
| sched_qid = BCM_SCHED_Q0; |
| else |
| sched_qid = BCM_SCHED_Q1; |
| } |
| |
| FLUSH_DCACHE_RANGE(cfgQ->phy_addr, cfgQ->len*8); |
| dhub_channel_generate_cmd(&(AG_dhubHandle.dhub), |
| avioDhubChMap_aio64b_BCM_R, |
| cfgQ->phy_addr, cfgQ->len*8, 0, 0, |
| 0, 1, (int*)bcm_sched_cmd); |
| while (!BCM_SCHED_PushCmd(sched_qid, bcm_sched_cmd, NULL)) { |
| /* Wait till BCM DHUB transaction |
| compeltes |
| */ |
| } |
| return MV_VPP_OK; |
| } |
| |
| void VPP_REG_Block_Write(unsigned int *start, unsigned int size, int use_dhub) |
| { |
| if(use_dhub) |
| { |
| VPP_BCMBUF_HardwareTrans_Direct(1, start, size); |
| } |
| else |
| { |
| unsigned int i = 0; |
| |
| for(i = 0; i < size/(sizeof(unsigned)); i+=2) |
| GA_REG_WORD32_WRITE(start[i+1], start[i]); |
| } |
| } |
