1296177Sjhibbits/* Copyright (c) 2008-2011 Freescale Semiconductor, Inc. 2296177Sjhibbits * All rights reserved. 3296177Sjhibbits * 4296177Sjhibbits * Redistribution and use in source and binary forms, with or without 5296177Sjhibbits * modification, are permitted provided that the following conditions are met: 6296177Sjhibbits * * Redistributions of source code must retain the above copyright 7296177Sjhibbits * notice, this list of conditions and the following disclaimer. 8296177Sjhibbits * * Redistributions in binary form must reproduce the above copyright 9296177Sjhibbits * notice, this list of conditions and the following disclaimer in the 10296177Sjhibbits * documentation and/or other materials provided with the distribution. 11296177Sjhibbits * * Neither the name of Freescale Semiconductor nor the 12296177Sjhibbits * names of its contributors may be used to endorse or promote products 13296177Sjhibbits * derived from this software without specific prior written permission. 14296177Sjhibbits * 15296177Sjhibbits * 16296177Sjhibbits * ALTERNATIVELY, this software may be distributed under the terms of the 17296177Sjhibbits * GNU General Public License ("GPL") as published by the Free Software 18296177Sjhibbits * Foundation, either version 2 of that License or (at your option) any 19296177Sjhibbits * later version. 20296177Sjhibbits * 21296177Sjhibbits * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY 22296177Sjhibbits * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23296177Sjhibbits * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24296177Sjhibbits * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY 25296177Sjhibbits * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26296177Sjhibbits * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27296177Sjhibbits * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 28296177Sjhibbits * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29296177Sjhibbits * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30296177Sjhibbits * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31296177Sjhibbits */ 32296177Sjhibbits 33296177Sjhibbits/****************************************************************************** 34296177Sjhibbits @File fm.c 35296177Sjhibbits 36296177Sjhibbits @Description FM driver routines implementation. 37296177Sjhibbits*//***************************************************************************/ 38296177Sjhibbits#include "std_ext.h" 39296177Sjhibbits#include "error_ext.h" 40296177Sjhibbits#include "xx_ext.h" 41296177Sjhibbits#include "string_ext.h" 42296177Sjhibbits#include "sprint_ext.h" 43296177Sjhibbits#include "debug_ext.h" 44296177Sjhibbits#include "fm_muram_ext.h" 45296177Sjhibbits 46296177Sjhibbits#include "fm_common.h" 47296177Sjhibbits#include "fm_ipc.h" 48296177Sjhibbits#include "fm.h" 49296177Sjhibbits 50296177Sjhibbits 51296177Sjhibbits/****************************************/ 52296177Sjhibbits/* static functions */ 53296177Sjhibbits/****************************************/ 54296177Sjhibbits 55296177Sjhibbitsstatic volatile bool blockingFlag = FALSE; 56296177Sjhibbitsstatic void IpcMsgCompletionCB(t_Handle h_Fm, 57296177Sjhibbits uint8_t *p_Msg, 58296177Sjhibbits uint8_t *p_Reply, 59296177Sjhibbits uint32_t replyLength, 60296177Sjhibbits t_Error status) 61296177Sjhibbits{ 62296177Sjhibbits UNUSED(h_Fm);UNUSED(p_Msg);UNUSED(p_Reply);UNUSED(replyLength);UNUSED(status); 63296177Sjhibbits blockingFlag = FALSE; 64296177Sjhibbits} 65296177Sjhibbits 66296177Sjhibbitsstatic bool IsFmanCtrlCodeLoaded(t_Fm *p_Fm) 67296177Sjhibbits{ 68296177Sjhibbits t_FMIramRegs *p_Iram; 69296177Sjhibbits 70296177Sjhibbits ASSERT_COND(p_Fm); 71296177Sjhibbits p_Iram = (t_FMIramRegs *)UINT_TO_PTR(p_Fm->baseAddr + FM_MM_IMEM); 72296177Sjhibbits 73296177Sjhibbits return (bool)!!(GET_UINT32(p_Iram->iready) & IRAM_READY); 74296177Sjhibbits} 75296177Sjhibbits 76296177Sjhibbitsstatic t_Error CheckFmParameters(t_Fm *p_Fm) 77296177Sjhibbits{ 78296177Sjhibbits if (IsFmanCtrlCodeLoaded(p_Fm) && !p_Fm->p_FmDriverParam->resetOnInit) 79296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Old FMan CTRL code is loaded; FM must be reset!")); 80296177Sjhibbits if(!p_Fm->p_FmDriverParam->dmaAxiDbgNumOfBeats || (p_Fm->p_FmDriverParam->dmaAxiDbgNumOfBeats > DMA_MODE_MAX_AXI_DBG_NUM_OF_BEATS)) 81296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("axiDbgNumOfBeats has to be in the range 1 - %d", DMA_MODE_MAX_AXI_DBG_NUM_OF_BEATS)); 82296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaCamNumOfEntries % DMA_CAM_UNITS) 83296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaCamNumOfEntries has to be divisble by %d", DMA_CAM_UNITS)); 84296177Sjhibbits if(!p_Fm->p_FmDriverParam->dmaCamNumOfEntries || (p_Fm->p_FmDriverParam->dmaCamNumOfEntries > DMA_MODE_MAX_CAM_NUM_OF_ENTRIES)) 85296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaCamNumOfEntries has to be in the range 1 - %d", DMA_MODE_MAX_CAM_NUM_OF_ENTRIES)); 86296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaCommQThresholds.assertEmergency > DMA_THRESH_MAX_COMMQ) 87296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaCommQThresholds.assertEmergency can not be larger than %d", DMA_THRESH_MAX_COMMQ)); 88296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaCommQThresholds.clearEmergency > DMA_THRESH_MAX_COMMQ) 89296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaCommQThresholds.clearEmergency can not be larger than %d", DMA_THRESH_MAX_COMMQ)); 90296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaCommQThresholds.clearEmergency >= p_Fm->p_FmDriverParam->dmaCommQThresholds.assertEmergency) 91296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaCommQThresholds.clearEmergency must be smaller than dmaCommQThresholds.assertEmergency")); 92296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaReadBufThresholds.assertEmergency > DMA_THRESH_MAX_BUF) 93296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaReadBufThresholds.assertEmergency can not be larger than %d", DMA_THRESH_MAX_BUF)); 94296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaReadBufThresholds.clearEmergency > DMA_THRESH_MAX_BUF) 95296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaReadBufThresholds.clearEmergency can not be larger than %d", DMA_THRESH_MAX_BUF)); 96296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaReadBufThresholds.clearEmergency >= p_Fm->p_FmDriverParam->dmaReadBufThresholds.assertEmergency) 97296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaReadBufThresholds.clearEmergency must be smaller than dmaReadBufThresholds.assertEmergency")); 98296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaWriteBufThresholds.assertEmergency > DMA_THRESH_MAX_BUF) 99296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaWriteBufThresholds.assertEmergency can not be larger than %d", DMA_THRESH_MAX_BUF)); 100296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaWriteBufThresholds.clearEmergency > DMA_THRESH_MAX_BUF) 101296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaWriteBufThresholds.clearEmergency can not be larger than %d", DMA_THRESH_MAX_BUF)); 102296177Sjhibbits if(p_Fm->p_FmDriverParam->dmaWriteBufThresholds.clearEmergency >= p_Fm->p_FmDriverParam->dmaWriteBufThresholds.assertEmergency) 103296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dmaWriteBufThresholds.clearEmergency must be smaller than dmaWriteBufThresholds.assertEmergency")); 104296177Sjhibbits 105296177Sjhibbits if(!p_Fm->p_FmStateStruct->fmClkFreq) 106296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("fmClkFreq must be set.")); 107296177Sjhibbits if (USEC_TO_CLK(p_Fm->p_FmDriverParam->dmaWatchdog, p_Fm->p_FmStateStruct->fmClkFreq) > DMA_MAX_WATCHDOG) 108296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 109296177Sjhibbits ("dmaWatchdog depends on FM clock. dmaWatchdog(in microseconds) * clk (in Mhz), may not exceed 0x08x", DMA_MAX_WATCHDOG)); 110296177Sjhibbits 111296177Sjhibbits#ifdef FM_PARTITION_ARRAY 112296177Sjhibbits { 113296177Sjhibbits t_FmRevisionInfo revInfo; 114296177Sjhibbits uint8_t i; 115296177Sjhibbits 116296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 117296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 118296177Sjhibbits for (i=0; i<FM_SIZE_OF_LIODN_TABLE; i++) 119296177Sjhibbits if (p_Fm->p_FmDriverParam->liodnBasePerPort[i] & ~FM_LIODN_BASE_MASK) 120296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("liodn number is out of range")); 121296177Sjhibbits } 122296177Sjhibbits#endif /* FM_PARTITION_ARRAY */ 123296177Sjhibbits 124296177Sjhibbits if(p_Fm->p_FmStateStruct->totalFifoSize % BMI_FIFO_UNITS) 125296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("totalFifoSize number has to be divisible by %d", BMI_FIFO_UNITS)); 126296177Sjhibbits if(!p_Fm->p_FmStateStruct->totalFifoSize || (p_Fm->p_FmStateStruct->totalFifoSize > BMI_MAX_FIFO_SIZE)) 127296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("totalFifoSize number has to be in the range 256 - %d", BMI_MAX_FIFO_SIZE)); 128296177Sjhibbits if(!p_Fm->p_FmStateStruct->totalNumOfTasks || (p_Fm->p_FmStateStruct->totalNumOfTasks > BMI_MAX_NUM_OF_TASKS)) 129296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("totalNumOfTasks number has to be in the range 1 - %d", BMI_MAX_NUM_OF_TASKS)); 130296177Sjhibbits if(!p_Fm->p_FmStateStruct->maxNumOfOpenDmas || (p_Fm->p_FmStateStruct->maxNumOfOpenDmas > BMI_MAX_NUM_OF_DMAS)) 131296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("maxNumOfOpenDmas number has to be in the range 1 - %d", BMI_MAX_NUM_OF_DMAS)); 132296177Sjhibbits 133296177Sjhibbits if(p_Fm->p_FmDriverParam->thresholds.dispLimit > FPM_MAX_DISP_LIMIT) 134296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("thresholds.dispLimit can't be greater than %d", FPM_MAX_DISP_LIMIT)); 135296177Sjhibbits 136296177Sjhibbits if(!p_Fm->f_Exception) 137296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Exceptions callback not provided")); 138296177Sjhibbits if(!p_Fm->f_BusError) 139296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Exceptions callback not provided")); 140296177Sjhibbits 141296177Sjhibbits return E_OK; 142296177Sjhibbits} 143296177Sjhibbits 144296177Sjhibbitsstatic void SendIpcIsr(t_Fm *p_Fm, uint32_t macEvent, uint32_t pendingReg) 145296177Sjhibbits{ 146296177Sjhibbits t_Error err; 147296177Sjhibbits t_FmIpcIsr fmIpcIsr; 148296177Sjhibbits t_FmIpcMsg msg; 149296177Sjhibbits 150296177Sjhibbits ASSERT_COND(p_Fm->guestId == NCSW_MASTER_ID); 151296177Sjhibbits ASSERT_COND(p_Fm->h_IpcSessions[p_Fm->intrMng[macEvent].guestId]); 152296177Sjhibbits if (p_Fm->intrMng[macEvent].guestId != NCSW_MASTER_ID) 153296177Sjhibbits { 154296177Sjhibbits memset(&msg, 0, sizeof(msg)); 155296177Sjhibbits msg.msgId = FM_GUEST_ISR; 156296177Sjhibbits fmIpcIsr.pendingReg = pendingReg; 157296177Sjhibbits fmIpcIsr.boolErr = FALSE; 158296177Sjhibbits memcpy(msg.msgBody, &fmIpcIsr, sizeof(fmIpcIsr)); 159296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[p_Fm->intrMng[macEvent].guestId], 160296177Sjhibbits (uint8_t*)&msg, 161296177Sjhibbits sizeof(msg.msgId) + sizeof(fmIpcIsr), 162296177Sjhibbits NULL, 163296177Sjhibbits NULL, 164296177Sjhibbits NULL, 165296177Sjhibbits NULL)) != E_OK) 166296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 167296177Sjhibbits return; 168296177Sjhibbits } 169296177Sjhibbits else 170296177Sjhibbits p_Fm->intrMng[macEvent].f_Isr(p_Fm->intrMng[macEvent].h_SrcHandle); 171296177Sjhibbits} 172296177Sjhibbits 173296177Sjhibbitsstatic void BmiErrEvent(t_Fm *p_Fm) 174296177Sjhibbits{ 175296177Sjhibbits uint32_t event, mask, force; 176296177Sjhibbits 177296177Sjhibbits event = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ievr); 178296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier); 179296177Sjhibbits event &= mask; 180296177Sjhibbits 181296177Sjhibbits /* clear the forced events */ 182296177Sjhibbits force = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr); 183296177Sjhibbits if(force & event) 184296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr, force & ~event); 185296177Sjhibbits 186296177Sjhibbits 187296177Sjhibbits /* clear the acknowledged events */ 188296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ievr, event); 189296177Sjhibbits 190296177Sjhibbits if(event & BMI_ERR_INTR_EN_PIPELINE_ECC) 191296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_BMI_PIPELINE_ECC); 192296177Sjhibbits if(event & BMI_ERR_INTR_EN_LIST_RAM_ECC) 193296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_BMI_LIST_RAM_ECC); 194296177Sjhibbits if(event & BMI_ERR_INTR_EN_STATISTICS_RAM_ECC) 195296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_BMI_STATISTICS_RAM_ECC); 196296177Sjhibbits if(event & BMI_ERR_INTR_EN_DISPATCH_RAM_ECC) 197296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_BMI_DISPATCH_RAM_ECC); 198296177Sjhibbits} 199296177Sjhibbits 200296177Sjhibbitsstatic void QmiErrEvent(t_Fm *p_Fm) 201296177Sjhibbits{ 202296177Sjhibbits uint32_t event, mask, force; 203296177Sjhibbits 204296177Sjhibbits event = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_eie); 205296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien); 206296177Sjhibbits 207296177Sjhibbits event &= mask; 208296177Sjhibbits 209296177Sjhibbits /* clear the forced events */ 210296177Sjhibbits force = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_eif); 211296177Sjhibbits if(force & event) 212296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eif, force & ~event); 213296177Sjhibbits 214296177Sjhibbits /* clear the acknowledged events */ 215296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eie, event); 216296177Sjhibbits 217296177Sjhibbits if(event & QMI_ERR_INTR_EN_DOUBLE_ECC) 218296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_QMI_DOUBLE_ECC); 219296177Sjhibbits if(event & QMI_ERR_INTR_EN_DEQ_FROM_DEF) 220296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_QMI_DEQ_FROM_UNKNOWN_PORTID); 221296177Sjhibbits} 222296177Sjhibbits 223296177Sjhibbitsstatic void DmaErrEvent(t_Fm *p_Fm) 224296177Sjhibbits{ 225296177Sjhibbits uint64_t addr=0; 226296177Sjhibbits uint32_t status, mask, tmpReg=0; 227296177Sjhibbits uint8_t tnum; 228296177Sjhibbits uint8_t hardwarePortId; 229296177Sjhibbits uint8_t relativePortId; 230296177Sjhibbits uint16_t liodn; 231296177Sjhibbits 232296177Sjhibbits status = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmsr); 233296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr); 234296177Sjhibbits 235296177Sjhibbits /* get bus error regs befor clearing BER */ 236296177Sjhibbits if ((status & DMA_STATUS_BUS_ERR) && (mask & DMA_MODE_BER)) 237296177Sjhibbits { 238296177Sjhibbits addr = (uint64_t)GET_UINT32(p_Fm->p_FmDmaRegs->fmdmtal); 239296177Sjhibbits addr |= ((uint64_t)(GET_UINT32(p_Fm->p_FmDmaRegs->fmdmtah)) << 32); 240296177Sjhibbits 241296177Sjhibbits /* get information about the owner of that bus error */ 242296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmtcid); 243296177Sjhibbits } 244296177Sjhibbits 245296177Sjhibbits /* clear set events */ 246296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmsr, status); 247296177Sjhibbits 248296177Sjhibbits if ((status & DMA_STATUS_BUS_ERR) && (mask & DMA_MODE_BER)) 249296177Sjhibbits { 250296177Sjhibbits hardwarePortId = (uint8_t)(((tmpReg & DMA_TRANSFER_PORTID_MASK) >> DMA_TRANSFER_PORTID_SHIFT)); 251296177Sjhibbits HW_PORT_ID_TO_SW_PORT_ID(relativePortId, hardwarePortId); 252296177Sjhibbits tnum = (uint8_t)((tmpReg & DMA_TRANSFER_TNUM_MASK) >> DMA_TRANSFER_TNUM_SHIFT); 253296177Sjhibbits liodn = (uint16_t)(tmpReg & DMA_TRANSFER_LIODN_MASK); 254296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->portsTypes[hardwarePortId] != e_FM_PORT_TYPE_DUMMY); 255296177Sjhibbits p_Fm->f_BusError(p_Fm->h_App, p_Fm->p_FmStateStruct->portsTypes[hardwarePortId], relativePortId, addr, tnum, liodn); 256296177Sjhibbits } 257296177Sjhibbits if(mask & DMA_MODE_ECC) 258296177Sjhibbits { 259296177Sjhibbits if (status & DMA_STATUS_READ_ECC) 260296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App, e_FM_EX_DMA_READ_ECC); 261296177Sjhibbits if (status & DMA_STATUS_SYSTEM_WRITE_ECC) 262296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App, e_FM_EX_DMA_SYSTEM_WRITE_ECC); 263296177Sjhibbits if (status & DMA_STATUS_FM_WRITE_ECC) 264296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App, e_FM_EX_DMA_FM_WRITE_ECC); 265296177Sjhibbits } 266296177Sjhibbits} 267296177Sjhibbits 268296177Sjhibbitsstatic void FpmErrEvent(t_Fm *p_Fm) 269296177Sjhibbits{ 270296177Sjhibbits uint32_t event; 271296177Sjhibbits 272296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fpmem); 273296177Sjhibbits 274296177Sjhibbits /* clear the all occurred events */ 275296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, event); 276296177Sjhibbits 277296177Sjhibbits if((event & FPM_EV_MASK_DOUBLE_ECC) && (event & FPM_EV_MASK_DOUBLE_ECC_EN)) 278296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_FPM_DOUBLE_ECC); 279296177Sjhibbits if((event & FPM_EV_MASK_STALL) && (event & FPM_EV_MASK_STALL_EN)) 280296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_FPM_STALL_ON_TASKS); 281296177Sjhibbits if((event & FPM_EV_MASK_SINGLE_ECC) && (event & FPM_EV_MASK_SINGLE_ECC_EN)) 282296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_FPM_SINGLE_ECC); 283296177Sjhibbits} 284296177Sjhibbits 285296177Sjhibbitsstatic void MuramErrIntr(t_Fm *p_Fm) 286296177Sjhibbits{ 287296177Sjhibbits uint32_t event, mask; 288296177Sjhibbits 289296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmrcr); 290296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmFpmRegs->fmrie); 291296177Sjhibbits 292296177Sjhibbits /* clear MURAM event bit */ 293296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, event & ~FPM_RAM_CTL_IRAM_ECC); 294296177Sjhibbits 295296177Sjhibbits ASSERT_COND(event & FPM_RAM_CTL_MURAM_ECC); 296296177Sjhibbits ASSERT_COND(event & FPM_RAM_CTL_RAMS_ECC_EN); 297296177Sjhibbits 298296177Sjhibbits if ((mask & FPM_MURAM_ECC_ERR_EX_EN)) 299296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App, e_FM_EX_MURAM_ECC); 300296177Sjhibbits} 301296177Sjhibbits 302296177Sjhibbitsstatic void IramErrIntr(t_Fm *p_Fm) 303296177Sjhibbits{ 304296177Sjhibbits uint32_t event, mask; 305296177Sjhibbits 306296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmrcr) ; 307296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmFpmRegs->fmrie); 308296177Sjhibbits /* clear the acknowledged events (do not clear IRAM event) */ 309296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, event & ~FPM_RAM_CTL_MURAM_ECC); 310296177Sjhibbits 311296177Sjhibbits ASSERT_COND(event & FPM_RAM_CTL_IRAM_ECC); 312296177Sjhibbits ASSERT_COND(event & FPM_RAM_CTL_IRAM_ECC_EN); 313296177Sjhibbits 314296177Sjhibbits if ((mask & FPM_IRAM_ECC_ERR_EX_EN)) 315296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App, e_FM_EX_IRAM_ECC); 316296177Sjhibbits} 317296177Sjhibbits 318296177Sjhibbitsstatic void QmiEvent(t_Fm *p_Fm) 319296177Sjhibbits{ 320296177Sjhibbits uint32_t event, mask, force; 321296177Sjhibbits 322296177Sjhibbits event = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_ie); 323296177Sjhibbits mask = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_ien); 324296177Sjhibbits 325296177Sjhibbits event &= mask; 326296177Sjhibbits 327296177Sjhibbits /* clear the forced events */ 328296177Sjhibbits force = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_if); 329296177Sjhibbits if(force & event) 330296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_if, force & ~event); 331296177Sjhibbits 332296177Sjhibbits /* clear the acknowledged events */ 333296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_ie, event); 334296177Sjhibbits 335296177Sjhibbits if(event & QMI_INTR_EN_SINGLE_ECC) 336296177Sjhibbits p_Fm->f_Exception(p_Fm->h_App,e_FM_EX_QMI_SINGLE_ECC); 337296177Sjhibbits} 338296177Sjhibbits 339296177Sjhibbitsstatic void UnimplementedIsr(t_Handle h_Arg) 340296177Sjhibbits{ 341296177Sjhibbits UNUSED(h_Arg); 342296177Sjhibbits 343296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Unimplemented Isr!")); 344296177Sjhibbits} 345296177Sjhibbits 346296177Sjhibbitsstatic void UnimplementedFmanCtrlIsr(t_Handle h_Arg, uint32_t event) 347296177Sjhibbits{ 348296177Sjhibbits UNUSED(h_Arg); UNUSED(event); 349296177Sjhibbits 350296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Unimplemented FmCtl Isr!")); 351296177Sjhibbits} 352296177Sjhibbits 353296177Sjhibbitsstatic void FmEnableTimeStamp(t_Fm *p_Fm) 354296177Sjhibbits{ 355296177Sjhibbits uint32_t tmpReg; 356296177Sjhibbits uint64_t fraction; 357296177Sjhibbits uint32_t integer; 358296177Sjhibbits uint8_t count1MicroBit = 8; 359296177Sjhibbits uint32_t tsFrequency = (uint32_t)(1<<count1MicroBit); /* in Mhz */ 360296177Sjhibbits 361296177Sjhibbits /* configure timestamp so that bit 8 will count 1 microsecond */ 362296177Sjhibbits /* Find effective count rate at TIMESTAMP least significant bits: 363296177Sjhibbits Effective_Count_Rate = 1MHz x 2^8 = 256MHz 364296177Sjhibbits Find frequency ratio between effective count rate and the clock: 365296177Sjhibbits Effective_Count_Rate / CLK e.g. for 600 MHz clock: 366296177Sjhibbits 256/600 = 0.4266666... */ 367296177Sjhibbits integer = tsFrequency/p_Fm->p_FmStateStruct->fmClkFreq; 368296177Sjhibbits /* we multiply by 2^16 to keep the fraction of the division */ 369296177Sjhibbits /* we do not divid back, since we write this value as fraction - see spec */ 370296177Sjhibbits fraction = ((tsFrequency << 16) - (integer << 16)*p_Fm->p_FmStateStruct->fmClkFreq)/p_Fm->p_FmStateStruct->fmClkFreq; 371296177Sjhibbits /* we check remainder of the division in order to round up if not integer */ 372296177Sjhibbits if(((tsFrequency << 16) - (integer << 16)*p_Fm->p_FmStateStruct->fmClkFreq) % p_Fm->p_FmStateStruct->fmClkFreq) 373296177Sjhibbits fraction++; 374296177Sjhibbits 375296177Sjhibbits tmpReg = (integer << FPM_TS_INT_SHIFT) | (uint16_t)fraction; 376296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmtsc2, tmpReg); 377296177Sjhibbits 378296177Sjhibbits /* enable timestamp with original clock */ 379296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmtsc1, FPM_TS_CTL_EN); 380296177Sjhibbits 381296177Sjhibbits p_Fm->p_FmStateStruct->count1MicroBit = count1MicroBit; 382296177Sjhibbits p_Fm->p_FmStateStruct->enabledTimeStamp = TRUE; 383296177Sjhibbits} 384296177Sjhibbits 385296177Sjhibbitsstatic void FreeInitResources(t_Fm *p_Fm) 386296177Sjhibbits{ 387296177Sjhibbits if (p_Fm->camBaseAddr) 388296177Sjhibbits FM_MURAM_FreeMem(p_Fm->h_FmMuram, UINT_TO_PTR(p_Fm->camBaseAddr)); 389296177Sjhibbits if (p_Fm->fifoBaseAddr) 390296177Sjhibbits FM_MURAM_FreeMem(p_Fm->h_FmMuram, UINT_TO_PTR(p_Fm->fifoBaseAddr)); 391296177Sjhibbits if (p_Fm->resAddr) 392296177Sjhibbits FM_MURAM_FreeMem(p_Fm->h_FmMuram, UINT_TO_PTR(p_Fm->resAddr)); 393296177Sjhibbits} 394296177Sjhibbits 395296177Sjhibbitsstatic t_Error ClearIRam(t_Fm *p_Fm) 396296177Sjhibbits{ 397296177Sjhibbits t_FMIramRegs *p_Iram; 398296177Sjhibbits int i; 399296177Sjhibbits 400296177Sjhibbits ASSERT_COND(p_Fm); 401296177Sjhibbits p_Iram = (t_FMIramRegs *)UINT_TO_PTR(p_Fm->baseAddr + FM_MM_IMEM); 402296177Sjhibbits 403296177Sjhibbits /* Enable the auto-increment */ 404296177Sjhibbits WRITE_UINT32(p_Iram->iadd, IRAM_IADD_AIE); 405296177Sjhibbits while (GET_UINT32(p_Iram->iadd) != IRAM_IADD_AIE) ; 406296177Sjhibbits 407296177Sjhibbits for (i=0; i < (FM_IRAM_SIZE/4); i++) 408296177Sjhibbits WRITE_UINT32(p_Iram->idata, 0xffffffff); 409296177Sjhibbits 410296177Sjhibbits WRITE_UINT32(p_Iram->iadd, FM_IRAM_SIZE - 4); 411296177Sjhibbits CORE_MemoryBarrier(); 412296177Sjhibbits while (GET_UINT32(p_Iram->idata) != 0xffffffff) ; 413296177Sjhibbits 414296177Sjhibbits return E_OK; 415296177Sjhibbits} 416296177Sjhibbits 417296177Sjhibbitsstatic t_Error LoadFmanCtrlCode(t_Fm *p_Fm) 418296177Sjhibbits{ 419296177Sjhibbits t_FMIramRegs *p_Iram; 420296177Sjhibbits int i; 421296177Sjhibbits uint32_t tmp; 422296177Sjhibbits uint8_t compTo16; 423296177Sjhibbits 424296177Sjhibbits ASSERT_COND(p_Fm); 425296177Sjhibbits p_Iram = (t_FMIramRegs *)UINT_TO_PTR(p_Fm->baseAddr + FM_MM_IMEM); 426296177Sjhibbits 427296177Sjhibbits /* Enable the auto-increment */ 428296177Sjhibbits WRITE_UINT32(p_Iram->iadd, IRAM_IADD_AIE); 429296177Sjhibbits while (GET_UINT32(p_Iram->iadd) != IRAM_IADD_AIE) ; 430296177Sjhibbits 431296177Sjhibbits for (i=0; i < (p_Fm->p_FmDriverParam->firmware.size / 4); i++) 432296177Sjhibbits WRITE_UINT32(p_Iram->idata, p_Fm->p_FmDriverParam->firmware.p_Code[i]); 433296177Sjhibbits 434296177Sjhibbits compTo16 = (uint8_t)(p_Fm->p_FmDriverParam->firmware.size % 16); 435296177Sjhibbits if(compTo16) 436296177Sjhibbits for (i=0; i < ((16-compTo16) / 4); i++) 437296177Sjhibbits WRITE_UINT32(p_Iram->idata, 0xffffffff); 438296177Sjhibbits 439296177Sjhibbits WRITE_UINT32(p_Iram->iadd,p_Fm->p_FmDriverParam->firmware.size-4); 440296177Sjhibbits while(GET_UINT32(p_Iram->iadd) != (p_Fm->p_FmDriverParam->firmware.size-4)) ; 441296177Sjhibbits 442296177Sjhibbits /* verify that writing has completed */ 443296177Sjhibbits while (GET_UINT32(p_Iram->idata) != p_Fm->p_FmDriverParam->firmware.p_Code[(p_Fm->p_FmDriverParam->firmware.size / 4)-1]) ; 444296177Sjhibbits 445296177Sjhibbits if (p_Fm->p_FmDriverParam->fwVerify) 446296177Sjhibbits { 447296177Sjhibbits WRITE_UINT32(p_Iram->iadd, IRAM_IADD_AIE); 448296177Sjhibbits while (GET_UINT32(p_Iram->iadd) != IRAM_IADD_AIE) ; 449296177Sjhibbits for (i=0; i < (p_Fm->p_FmDriverParam->firmware.size / 4); i++) 450296177Sjhibbits if ((tmp=GET_UINT32(p_Iram->idata)) != p_Fm->p_FmDriverParam->firmware.p_Code[i]) 451296177Sjhibbits RETURN_ERROR(MAJOR, E_WRITE_FAILED, 452296177Sjhibbits ("UCode write error : write 0x%x, read 0x%x", 453296177Sjhibbits p_Fm->p_FmDriverParam->firmware.p_Code[i],tmp)); 454296177Sjhibbits WRITE_UINT32(p_Iram->iadd, 0x0); 455296177Sjhibbits } 456296177Sjhibbits 457296177Sjhibbits /* Enable patch from IRAM */ 458296177Sjhibbits WRITE_UINT32(p_Iram->iready, IRAM_READY); 459296177Sjhibbits XX_UDelay(1000); 460296177Sjhibbits 461296177Sjhibbits DBG(INFO, ("FMan-Controller code (ver %d.%d) loaded to IRAM.", 462296177Sjhibbits ((uint8_t *)p_Fm->p_FmDriverParam->firmware.p_Code)[5], 463296177Sjhibbits ((uint8_t *)p_Fm->p_FmDriverParam->firmware.p_Code)[7])); 464296177Sjhibbits 465296177Sjhibbits return E_OK; 466296177Sjhibbits} 467296177Sjhibbits 468296177Sjhibbitsstatic void GuestErrorIsr(t_Fm *p_Fm, uint32_t pending) 469296177Sjhibbits{ 470296177Sjhibbits#define FM_G_CALL_1G_MAC_ERR_ISR(_id) \ 471296177Sjhibbitsdo { \ 472296177Sjhibbits p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id)].f_Isr(p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id)].h_SrcHandle);\ 473296177Sjhibbits} while (0) 474296177Sjhibbits#define FM_G_CALL_10G_MAC_ERR_ISR(_id) \ 475296177Sjhibbitsdo { \ 476296177Sjhibbits p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_10G_MAC0+_id)].f_Isr(p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_10G_MAC0+_id)].h_SrcHandle);\ 477296177Sjhibbits} while (0) 478296177Sjhibbits 479296177Sjhibbits /* error interrupts */ 480296177Sjhibbits if (pending & ERR_INTR_EN_1G_MAC0) 481296177Sjhibbits FM_G_CALL_1G_MAC_ERR_ISR(0); 482296177Sjhibbits if (pending & ERR_INTR_EN_1G_MAC1) 483296177Sjhibbits FM_G_CALL_1G_MAC_ERR_ISR(1); 484296177Sjhibbits if (pending & ERR_INTR_EN_1G_MAC2) 485296177Sjhibbits FM_G_CALL_1G_MAC_ERR_ISR(2); 486296177Sjhibbits if (pending & ERR_INTR_EN_1G_MAC3) 487296177Sjhibbits FM_G_CALL_1G_MAC_ERR_ISR(3); 488296177Sjhibbits if (pending & ERR_INTR_EN_1G_MAC4) 489296177Sjhibbits FM_G_CALL_1G_MAC_ERR_ISR(4); 490296177Sjhibbits if (pending & ERR_INTR_EN_10G_MAC0) 491296177Sjhibbits FM_G_CALL_10G_MAC_ERR_ISR(0); 492296177Sjhibbits} 493296177Sjhibbits 494296177Sjhibbitsstatic void GuestEventIsr(t_Fm *p_Fm, uint32_t pending) 495296177Sjhibbits{ 496296177Sjhibbits#define FM_G_CALL_1G_MAC_TMR_ISR(_id) \ 497296177Sjhibbitsdo { \ 498296177Sjhibbits p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id)].f_Isr(p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id)].h_SrcHandle);\ 499296177Sjhibbits} while (0) 500296177Sjhibbits 501296177Sjhibbits if (pending & INTR_EN_1G_MAC0_TMR) 502296177Sjhibbits FM_G_CALL_1G_MAC_TMR_ISR(0); 503296177Sjhibbits if (pending & INTR_EN_1G_MAC1_TMR) 504296177Sjhibbits FM_G_CALL_1G_MAC_TMR_ISR(1); 505296177Sjhibbits if (pending & INTR_EN_1G_MAC2_TMR) 506296177Sjhibbits FM_G_CALL_1G_MAC_TMR_ISR(2); 507296177Sjhibbits if (pending & INTR_EN_1G_MAC3_TMR) 508296177Sjhibbits FM_G_CALL_1G_MAC_TMR_ISR(3); 509296177Sjhibbits if (pending & INTR_EN_1G_MAC4_TMR) 510296177Sjhibbits FM_G_CALL_1G_MAC_TMR_ISR(4); 511296177Sjhibbits if(pending & INTR_EN_TMR) 512296177Sjhibbits p_Fm->intrMng[e_FM_EV_TMR].f_Isr(p_Fm->intrMng[e_FM_EV_TMR].h_SrcHandle); 513296177Sjhibbits} 514296177Sjhibbits 515296177Sjhibbits 516296177Sjhibbits/****************************************/ 517296177Sjhibbits/* Inter-Module functions */ 518296177Sjhibbits/****************************************/ 519296177Sjhibbitsstatic t_Error FmGuestHandleIpcMsgCB(t_Handle h_Fm, 520296177Sjhibbits uint8_t *p_Msg, 521296177Sjhibbits uint32_t msgLength, 522296177Sjhibbits uint8_t *p_Reply, 523296177Sjhibbits uint32_t *p_ReplyLength) 524296177Sjhibbits{ 525296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 526296177Sjhibbits t_FmIpcMsg *p_IpcMsg = (t_FmIpcMsg*)p_Msg; 527296177Sjhibbits 528296177Sjhibbits UNUSED(p_Reply); 529296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 530296177Sjhibbits SANITY_CHECK_RETURN_ERROR((msgLength > sizeof(uint32_t)), E_INVALID_VALUE); 531296177Sjhibbits 532296177Sjhibbits#ifdef DISABLE_SANITY_CHECKS 533296177Sjhibbits UNUSED(msgLength); 534296177Sjhibbits#endif /* DISABLE_SANITY_CHECKS */ 535296177Sjhibbits 536296177Sjhibbits ASSERT_COND(p_Msg); 537296177Sjhibbits 538296177Sjhibbits *p_ReplyLength = 0; 539296177Sjhibbits 540296177Sjhibbits switch(p_IpcMsg->msgId) 541296177Sjhibbits { 542296177Sjhibbits case (FM_GUEST_ISR): 543296177Sjhibbits { 544296177Sjhibbits t_FmIpcIsr ipcIsr; 545296177Sjhibbits 546296177Sjhibbits memcpy((uint8_t*)&ipcIsr, p_IpcMsg->msgBody, sizeof(t_FmIpcIsr)); 547296177Sjhibbits if(ipcIsr.boolErr) 548296177Sjhibbits GuestErrorIsr(p_Fm, ipcIsr.pendingReg); 549296177Sjhibbits else 550296177Sjhibbits GuestEventIsr(p_Fm, ipcIsr.pendingReg); 551296177Sjhibbits break; 552296177Sjhibbits } 553296177Sjhibbits default: 554296177Sjhibbits *p_ReplyLength = 0; 555296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("command not found!!!")); 556296177Sjhibbits } 557296177Sjhibbits return E_OK; 558296177Sjhibbits} 559296177Sjhibbits 560296177Sjhibbitsstatic t_Error FmHandleIpcMsgCB(t_Handle h_Fm, 561296177Sjhibbits uint8_t *p_Msg, 562296177Sjhibbits uint32_t msgLength, 563296177Sjhibbits uint8_t *p_Reply, 564296177Sjhibbits uint32_t *p_ReplyLength) 565296177Sjhibbits{ 566296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 567296177Sjhibbits t_FmIpcMsg *p_IpcMsg = (t_FmIpcMsg*)p_Msg; 568296177Sjhibbits t_FmIpcReply *p_IpcReply = (t_FmIpcReply*)p_Reply; 569296177Sjhibbits 570296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 571296177Sjhibbits SANITY_CHECK_RETURN_ERROR((msgLength >= sizeof(uint32_t)), E_INVALID_VALUE); 572296177Sjhibbits 573296177Sjhibbits#ifdef DISABLE_SANITY_CHECKS 574296177Sjhibbits UNUSED(msgLength); 575296177Sjhibbits#endif /* DISABLE_SANITY_CHECKS */ 576296177Sjhibbits 577296177Sjhibbits ASSERT_COND(p_IpcMsg); 578296177Sjhibbits 579296177Sjhibbits memset(p_IpcReply, 0, (sizeof(uint8_t) * FM_IPC_MAX_REPLY_SIZE)); 580296177Sjhibbits *p_ReplyLength = 0; 581296177Sjhibbits 582296177Sjhibbits switch(p_IpcMsg->msgId) 583296177Sjhibbits { 584296177Sjhibbits case (FM_GET_SET_PORT_PARAMS): 585296177Sjhibbits { 586296177Sjhibbits t_FmIpcPortInInitParams ipcInitParams; 587296177Sjhibbits t_FmInterModulePortInitParams initParams; 588296177Sjhibbits t_FmIpcPhysAddr ipcPhysAddr; 589296177Sjhibbits 590296177Sjhibbits memcpy((uint8_t*)&ipcInitParams, p_IpcMsg->msgBody, sizeof(t_FmIpcPortInInitParams)); 591296177Sjhibbits initParams.hardwarePortId = ipcInitParams.hardwarePortId; 592296177Sjhibbits initParams.portType = (e_FmPortType)ipcInitParams.enumPortType; 593296177Sjhibbits initParams.independentMode = (bool)(ipcInitParams.boolIndependentMode); 594296177Sjhibbits initParams.liodnOffset = ipcInitParams.liodnOffset; 595296177Sjhibbits initParams.numOfTasks = ipcInitParams.numOfTasks; 596296177Sjhibbits initParams.numOfExtraTasks = ipcInitParams.numOfExtraTasks; 597296177Sjhibbits initParams.numOfOpenDmas = ipcInitParams.numOfOpenDmas; 598296177Sjhibbits initParams.numOfExtraOpenDmas = ipcInitParams.numOfExtraOpenDmas; 599296177Sjhibbits initParams.sizeOfFifo = ipcInitParams.sizeOfFifo; 600296177Sjhibbits initParams.extraSizeOfFifo = ipcInitParams.extraSizeOfFifo; 601296177Sjhibbits initParams.deqPipelineDepth = ipcInitParams.deqPipelineDepth; 602296177Sjhibbits initParams.liodnBase = ipcInitParams.liodnBase; 603296177Sjhibbits 604296177Sjhibbits p_IpcReply->error = (uint32_t)FmGetSetPortParams(h_Fm, &initParams); 605296177Sjhibbits ipcPhysAddr.high = initParams.fmMuramPhysBaseAddr.high; 606296177Sjhibbits ipcPhysAddr.low = initParams.fmMuramPhysBaseAddr.low; 607296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcPhysAddr, sizeof(t_FmIpcPhysAddr)); 608296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(t_FmIpcPhysAddr); 609296177Sjhibbits break; 610296177Sjhibbits } 611296177Sjhibbits case (FM_SET_SIZE_OF_FIFO): 612296177Sjhibbits { 613296177Sjhibbits t_FmIpcPortFifoParams ipcPortFifoParams; 614296177Sjhibbits t_FmInterModulePortRxPoolsParams rxPoolsParams; 615296177Sjhibbits 616296177Sjhibbits memcpy((uint8_t*)&ipcPortFifoParams, p_IpcMsg->msgBody, sizeof(t_FmIpcPortFifoParams)); 617296177Sjhibbits rxPoolsParams.numOfPools = ipcPortFifoParams.numOfPools; 618296177Sjhibbits rxPoolsParams.secondLargestBufSize = ipcPortFifoParams.secondLargestBufSize; 619296177Sjhibbits rxPoolsParams.largestBufSize = ipcPortFifoParams.largestBufSize; 620296177Sjhibbits 621296177Sjhibbits p_IpcReply->error = (uint32_t)FmSetSizeOfFifo(h_Fm, ipcPortFifoParams.rsrcParams.hardwarePortId, 622296177Sjhibbits (e_FmPortType)ipcPortFifoParams.enumPortType, 623296177Sjhibbits (bool)ipcPortFifoParams.boolIndependentMode, 624296177Sjhibbits &ipcPortFifoParams.rsrcParams.val, 625296177Sjhibbits ipcPortFifoParams.rsrcParams.extra, 626296177Sjhibbits ipcPortFifoParams.deqPipelineDepth, 627296177Sjhibbits &rxPoolsParams, 628296177Sjhibbits (bool)ipcPortFifoParams.boolInitialConfig); 629296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcPortFifoParams.rsrcParams.val, sizeof(uint32_t)); 630296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 631296177Sjhibbits break; 632296177Sjhibbits } 633296177Sjhibbits case (FM_SET_NUM_OF_TASKS): 634296177Sjhibbits { 635296177Sjhibbits t_FmIpcPortRsrcParams ipcPortRsrcParams; 636296177Sjhibbits 637296177Sjhibbits memcpy((uint8_t*)&ipcPortRsrcParams, p_IpcMsg->msgBody, sizeof(t_FmIpcPortRsrcParams)); 638296177Sjhibbits p_IpcReply->error = (uint32_t)FmSetNumOfTasks(h_Fm, ipcPortRsrcParams.hardwarePortId, 639296177Sjhibbits (uint8_t)ipcPortRsrcParams.val, 640296177Sjhibbits (uint8_t)ipcPortRsrcParams.extra, 641296177Sjhibbits (bool)ipcPortRsrcParams.boolInitialConfig); 642296177Sjhibbits *p_ReplyLength = sizeof(uint32_t); 643296177Sjhibbits break; 644296177Sjhibbits } 645296177Sjhibbits case (FM_SET_NUM_OF_OPEN_DMAS): 646296177Sjhibbits { 647296177Sjhibbits t_FmIpcPortRsrcParams ipcPortRsrcParams; 648296177Sjhibbits 649296177Sjhibbits memcpy((uint8_t*)&ipcPortRsrcParams, p_IpcMsg->msgBody, sizeof(t_FmIpcPortRsrcParams)); 650296177Sjhibbits p_IpcReply->error = (uint32_t)FmSetNumOfOpenDmas(h_Fm, ipcPortRsrcParams.hardwarePortId, 651296177Sjhibbits (uint8_t)ipcPortRsrcParams.val, 652296177Sjhibbits (uint8_t)ipcPortRsrcParams.extra, 653296177Sjhibbits (bool)ipcPortRsrcParams.boolInitialConfig); 654296177Sjhibbits *p_ReplyLength = sizeof(uint32_t); 655296177Sjhibbits break; 656296177Sjhibbits } 657296177Sjhibbits case (FM_RESUME_STALLED_PORT): 658296177Sjhibbits *p_ReplyLength = sizeof(uint32_t); 659296177Sjhibbits p_IpcReply->error = (uint32_t)FmResumeStalledPort(h_Fm, p_IpcMsg->msgBody[0]); 660296177Sjhibbits break; 661296177Sjhibbits case (FM_MASTER_IS_ALIVE): 662296177Sjhibbits { 663296177Sjhibbits uint8_t guestId = p_IpcMsg->msgBody[0]; 664296177Sjhibbits /* build the FM master partition IPC address */ 665296177Sjhibbits memset(p_Fm->fmIpcHandlerModuleName[guestId], 0, (sizeof(char)) * MODULE_NAME_SIZE); 666296177Sjhibbits if(Sprint (p_Fm->fmIpcHandlerModuleName[guestId], "FM_%d_%d",p_Fm->p_FmStateStruct->fmId, guestId) != (guestId<10 ? 6:7)) 667296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 668296177Sjhibbits p_Fm->h_IpcSessions[guestId] = XX_IpcInitSession(p_Fm->fmIpcHandlerModuleName[guestId], p_Fm->fmModuleName); 669296177Sjhibbits if (p_Fm->h_IpcSessions[guestId] == NULL) 670296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("FM Master IPC session for guest %d", guestId)); 671296177Sjhibbits *(uint8_t*)(p_IpcReply->replyBody) = 1; 672296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); 673296177Sjhibbits break; 674296177Sjhibbits } 675296177Sjhibbits case (FM_IS_PORT_STALLED): 676296177Sjhibbits { 677296177Sjhibbits bool tmp; 678296177Sjhibbits 679296177Sjhibbits p_IpcReply->error = (uint32_t)FmIsPortStalled(h_Fm, p_IpcMsg->msgBody[0], &tmp); 680296177Sjhibbits *(uint8_t*)(p_IpcReply->replyBody) = (uint8_t)tmp; 681296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); 682296177Sjhibbits break; 683296177Sjhibbits } 684296177Sjhibbits case (FM_RESET_MAC): 685296177Sjhibbits { 686296177Sjhibbits t_FmIpcMacParams ipcMacParams; 687296177Sjhibbits 688296177Sjhibbits memcpy((uint8_t*)&ipcMacParams, p_IpcMsg->msgBody, sizeof(t_FmIpcMacParams)); 689296177Sjhibbits p_IpcReply->error = (uint32_t)FmResetMac(p_Fm, 690296177Sjhibbits (e_FmMacType)(ipcMacParams.enumType), 691296177Sjhibbits ipcMacParams.id); 692296177Sjhibbits *p_ReplyLength = sizeof(uint32_t); 693296177Sjhibbits break; 694296177Sjhibbits } 695296177Sjhibbits case (FM_SET_MAC_MAX_FRAME): 696296177Sjhibbits { 697296177Sjhibbits t_Error err; 698296177Sjhibbits t_FmIpcMacMaxFrameParams ipcMacMaxFrameParams; 699296177Sjhibbits 700296177Sjhibbits memcpy((uint8_t*)&ipcMacMaxFrameParams, p_IpcMsg->msgBody, sizeof(t_FmIpcMacMaxFrameParams)); 701296177Sjhibbits if ((err = FmSetMacMaxFrame(p_Fm, 702296177Sjhibbits (e_FmMacType)(ipcMacMaxFrameParams.macParams.enumType), 703296177Sjhibbits ipcMacMaxFrameParams.macParams.id, 704296177Sjhibbits ipcMacMaxFrameParams.maxFrameLength)) != E_OK) 705296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 706296177Sjhibbits break; 707296177Sjhibbits } 708296177Sjhibbits case (FM_GET_CLK_FREQ): 709296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&p_Fm->p_FmStateStruct->fmClkFreq, sizeof(uint16_t)); 710296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint16_t); 711296177Sjhibbits break; 712296177Sjhibbits case (FM_FREE_PORT): 713296177Sjhibbits { 714296177Sjhibbits t_FmInterModulePortFreeParams portParams; 715296177Sjhibbits t_FmIpcPortFreeParams ipcPortParams; 716296177Sjhibbits 717296177Sjhibbits memcpy((uint8_t*)&ipcPortParams, p_IpcMsg->msgBody, sizeof(t_FmIpcPortFreeParams)); 718296177Sjhibbits portParams.hardwarePortId = ipcPortParams.hardwarePortId; 719296177Sjhibbits portParams.portType = (e_FmPortType)(ipcPortParams.enumPortType); 720296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 721296177Sjhibbits portParams.deqPipelineDepth = ipcPortParams.deqPipelineDepth; 722296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 723296177Sjhibbits FmFreePortParams(h_Fm, &portParams); 724296177Sjhibbits break; 725296177Sjhibbits } 726296177Sjhibbits case (FM_REGISTER_INTR): 727296177Sjhibbits { 728296177Sjhibbits t_FmIpcRegisterIntr ipcRegIntr; 729296177Sjhibbits 730296177Sjhibbits memcpy((uint8_t*)&ipcRegIntr, p_IpcMsg->msgBody, sizeof(ipcRegIntr)); 731296177Sjhibbits p_Fm->intrMng[ipcRegIntr.event].guestId = ipcRegIntr.guestId; 732296177Sjhibbits break; 733296177Sjhibbits } 734296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 735296177Sjhibbits case (FM_DUMP_REGS): 736296177Sjhibbits { 737296177Sjhibbits t_Error err; 738296177Sjhibbits if ((err = FM_DumpRegs(h_Fm)) != E_OK) 739296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 740296177Sjhibbits break; 741296177Sjhibbits } 742296177Sjhibbits case (FM_DUMP_PORT_REGS): 743296177Sjhibbits { 744296177Sjhibbits t_Error err; 745296177Sjhibbits 746296177Sjhibbits if ((err = FmDumpPortRegs(h_Fm, p_IpcMsg->msgBody[0])) != E_OK) 747296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 748296177Sjhibbits break; 749296177Sjhibbits } 750296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && ... */ 751296177Sjhibbits case (FM_GET_REV): 752296177Sjhibbits { 753296177Sjhibbits t_FmRevisionInfo revInfo; 754296177Sjhibbits t_FmIpcRevisionInfo ipcRevInfo; 755296177Sjhibbits 756296177Sjhibbits p_IpcReply->error = (uint32_t)FM_GetRevision(h_Fm, &revInfo); 757296177Sjhibbits ipcRevInfo.majorRev = revInfo.majorRev; 758296177Sjhibbits ipcRevInfo.minorRev = revInfo.minorRev; 759296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcRevInfo, sizeof(t_FmIpcRevisionInfo)); 760296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(t_FmIpcRevisionInfo); 761296177Sjhibbits break; 762296177Sjhibbits } 763296177Sjhibbits case (FM_DMA_STAT): 764296177Sjhibbits { 765296177Sjhibbits t_FmDmaStatus dmaStatus; 766296177Sjhibbits t_FmIpcDmaStatus ipcDmaStatus; 767296177Sjhibbits 768296177Sjhibbits FM_GetDmaStatus(h_Fm, &dmaStatus); 769296177Sjhibbits ipcDmaStatus.boolCmqNotEmpty = (uint8_t)dmaStatus.cmqNotEmpty; 770296177Sjhibbits ipcDmaStatus.boolBusError = (uint8_t)dmaStatus.busError; 771296177Sjhibbits ipcDmaStatus.boolReadBufEccError = (uint8_t)dmaStatus.readBufEccError; 772296177Sjhibbits ipcDmaStatus.boolWriteBufEccSysError = (uint8_t)dmaStatus.writeBufEccSysError; 773296177Sjhibbits ipcDmaStatus.boolWriteBufEccFmError = (uint8_t)dmaStatus.writeBufEccFmError; 774296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcDmaStatus, sizeof(t_FmIpcDmaStatus)); 775296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(t_FmIpcDmaStatus); 776296177Sjhibbits break; 777296177Sjhibbits } 778296177Sjhibbits case (FM_ALLOC_FMAN_CTRL_EVENT_REG): 779296177Sjhibbits p_IpcReply->error = (uint32_t)FmAllocFmanCtrlEventReg(h_Fm, (uint8_t*)p_IpcReply->replyBody); 780296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); 781296177Sjhibbits break; 782296177Sjhibbits case (FM_FREE_FMAN_CTRL_EVENT_REG): 783296177Sjhibbits FmFreeFmanCtrlEventReg(h_Fm, p_IpcMsg->msgBody[0]); 784296177Sjhibbits break; 785296177Sjhibbits case (FM_GET_TIMESTAMP_SCALE): 786296177Sjhibbits { 787296177Sjhibbits uint32_t timeStamp = FmGetTimeStampScale(h_Fm); 788296177Sjhibbits 789296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&timeStamp, sizeof(uint32_t)); 790296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 791296177Sjhibbits break; 792296177Sjhibbits } 793296177Sjhibbits case (FM_GET_COUNTER): 794296177Sjhibbits { 795296177Sjhibbits e_FmCounters inCounter; 796296177Sjhibbits uint32_t outCounter; 797296177Sjhibbits 798296177Sjhibbits memcpy((uint8_t*)&inCounter, p_IpcMsg->msgBody, sizeof(uint32_t)); 799296177Sjhibbits outCounter = FM_GetCounter(h_Fm, inCounter); 800296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&outCounter, sizeof(uint32_t)); 801296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 802296177Sjhibbits break; 803296177Sjhibbits } 804296177Sjhibbits case (FM_SET_FMAN_CTRL_EVENTS_ENABLE): 805296177Sjhibbits { 806296177Sjhibbits t_FmIpcFmanEvents ipcFmanEvents; 807296177Sjhibbits 808296177Sjhibbits memcpy((uint8_t*)&ipcFmanEvents, p_IpcMsg->msgBody, sizeof(t_FmIpcFmanEvents)); 809296177Sjhibbits FmSetFmanCtrlIntr(h_Fm, 810296177Sjhibbits ipcFmanEvents.eventRegId, 811296177Sjhibbits ipcFmanEvents.enableEvents); 812296177Sjhibbits break; 813296177Sjhibbits } 814296177Sjhibbits case (FM_GET_FMAN_CTRL_EVENTS_ENABLE): 815296177Sjhibbits { 816296177Sjhibbits uint32_t tmp = FmGetFmanCtrlIntr(h_Fm, p_IpcMsg->msgBody[0]); 817296177Sjhibbits 818296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&tmp, sizeof(uint32_t)); 819296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 820296177Sjhibbits break; 821296177Sjhibbits } 822296177Sjhibbits case (FM_GET_PHYS_MURAM_BASE): 823296177Sjhibbits { 824296177Sjhibbits t_FmPhysAddr physAddr; 825296177Sjhibbits t_FmIpcPhysAddr ipcPhysAddr; 826296177Sjhibbits 827296177Sjhibbits FmGetPhysicalMuramBase(h_Fm, &physAddr); 828296177Sjhibbits ipcPhysAddr.high = physAddr.high; 829296177Sjhibbits ipcPhysAddr.low = physAddr.low; 830296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcPhysAddr, sizeof(t_FmIpcPhysAddr)); 831296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(t_FmIpcPhysAddr); 832296177Sjhibbits break; 833296177Sjhibbits } 834296177Sjhibbits case (FM_ENABLE_RAM_ECC): 835296177Sjhibbits { 836296177Sjhibbits t_Error err; 837296177Sjhibbits 838296177Sjhibbits if (((err = FM_EnableRamsEcc(h_Fm)) != E_OK) || 839296177Sjhibbits ((err = FM_SetException(h_Fm, e_FM_EX_IRAM_ECC, TRUE)) != E_OK) || 840296177Sjhibbits ((err = FM_SetException(h_Fm, e_FM_EX_MURAM_ECC, TRUE)) != E_OK)) 841296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 842296177Sjhibbits break; 843296177Sjhibbits } 844296177Sjhibbits case (FM_DISABLE_RAM_ECC): 845296177Sjhibbits { 846296177Sjhibbits t_Error err; 847296177Sjhibbits 848296177Sjhibbits if (((err = FM_SetException(h_Fm, e_FM_EX_IRAM_ECC, FALSE)) != E_OK) || 849296177Sjhibbits ((err = FM_SetException(h_Fm, e_FM_EX_MURAM_ECC, FALSE)) != E_OK) || 850296177Sjhibbits ((err = FM_DisableRamsEcc(h_Fm)) != E_OK)) 851296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 852296177Sjhibbits break; 853296177Sjhibbits } 854296177Sjhibbits case (FM_SET_NUM_OF_FMAN_CTRL): 855296177Sjhibbits { 856296177Sjhibbits t_Error err; 857296177Sjhibbits t_FmIpcPortNumOfFmanCtrls ipcPortNumOfFmanCtrls; 858296177Sjhibbits 859296177Sjhibbits memcpy((uint8_t*)&ipcPortNumOfFmanCtrls, p_IpcMsg->msgBody, sizeof(t_FmIpcPortNumOfFmanCtrls)); 860296177Sjhibbits if ((err = FmSetNumOfRiscsPerPort(h_Fm, 861296177Sjhibbits ipcPortNumOfFmanCtrls.hardwarePortId, 862296177Sjhibbits ipcPortNumOfFmanCtrls.numOfFmanCtrls)) != E_OK) 863296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 864296177Sjhibbits break; 865296177Sjhibbits } 866296177Sjhibbits#ifdef FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 867296177Sjhibbits case (FM_10G_TX_ECC_WA): 868296177Sjhibbits p_IpcReply->error = (uint32_t)Fm10GTxEccWorkaround(h_Fm, p_IpcMsg->msgBody[0]); 869296177Sjhibbits *p_ReplyLength = sizeof(uint32_t); 870296177Sjhibbits break; 871296177Sjhibbits#endif /* FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 */ 872296177Sjhibbits default: 873296177Sjhibbits *p_ReplyLength = 0; 874296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("command not found!!!")); 875296177Sjhibbits } 876296177Sjhibbits return E_OK; 877296177Sjhibbits} 878296177Sjhibbits 879296177Sjhibbitsstatic void ErrorIsrCB(t_Handle h_Fm) 880296177Sjhibbits{ 881296177Sjhibbits#define FM_M_CALL_1G_MAC_ERR_ISR(_id) \ 882296177Sjhibbits { \ 883296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id)].guestId) \ 884296177Sjhibbits SendIpcIsr(p_Fm, (e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id), pending); \ 885296177Sjhibbits else \ 886296177Sjhibbits p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id)].f_Isr(p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_ERR_1G_MAC0+_id)].h_SrcHandle);\ 887296177Sjhibbits } 888296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 889296177Sjhibbits uint32_t pending; 890296177Sjhibbits 891296177Sjhibbits SANITY_CHECK_RETURN(h_Fm, E_INVALID_HANDLE); 892296177Sjhibbits 893296177Sjhibbits /* error interrupts */ 894296177Sjhibbits pending = GET_UINT32(p_Fm->p_FmFpmRegs->fmepi); 895296177Sjhibbits if (!pending) 896296177Sjhibbits return; 897296177Sjhibbits 898296177Sjhibbits if(pending & ERR_INTR_EN_BMI) 899296177Sjhibbits BmiErrEvent(p_Fm); 900296177Sjhibbits if(pending & ERR_INTR_EN_QMI) 901296177Sjhibbits QmiErrEvent(p_Fm); 902296177Sjhibbits if(pending & ERR_INTR_EN_FPM) 903296177Sjhibbits FpmErrEvent(p_Fm); 904296177Sjhibbits if(pending & ERR_INTR_EN_DMA) 905296177Sjhibbits DmaErrEvent(p_Fm); 906296177Sjhibbits if(pending & ERR_INTR_EN_IRAM) 907296177Sjhibbits IramErrIntr(p_Fm); 908296177Sjhibbits if(pending & ERR_INTR_EN_MURAM) 909296177Sjhibbits MuramErrIntr(p_Fm); 910296177Sjhibbits if(pending & ERR_INTR_EN_PRS) 911296177Sjhibbits p_Fm->intrMng[e_FM_EV_ERR_PRS].f_Isr(p_Fm->intrMng[e_FM_EV_ERR_PRS].h_SrcHandle); 912296177Sjhibbits if(pending & ERR_INTR_EN_PLCR) 913296177Sjhibbits p_Fm->intrMng[e_FM_EV_ERR_PLCR].f_Isr(p_Fm->intrMng[e_FM_EV_ERR_PLCR].h_SrcHandle); 914296177Sjhibbits if(pending & ERR_INTR_EN_KG) 915296177Sjhibbits p_Fm->intrMng[e_FM_EV_ERR_KG].f_Isr(p_Fm->intrMng[e_FM_EV_ERR_KG].h_SrcHandle); 916296177Sjhibbits 917296177Sjhibbits /* MAC events may belong to different partitions */ 918296177Sjhibbits if(pending & ERR_INTR_EN_1G_MAC0) 919296177Sjhibbits FM_M_CALL_1G_MAC_ERR_ISR(0); 920296177Sjhibbits if(pending & ERR_INTR_EN_1G_MAC1) 921296177Sjhibbits FM_M_CALL_1G_MAC_ERR_ISR(1); 922296177Sjhibbits if(pending & ERR_INTR_EN_1G_MAC2) 923296177Sjhibbits FM_M_CALL_1G_MAC_ERR_ISR(2); 924296177Sjhibbits if(pending & ERR_INTR_EN_1G_MAC3) 925296177Sjhibbits FM_M_CALL_1G_MAC_ERR_ISR(3); 926296177Sjhibbits if(pending & ERR_INTR_EN_1G_MAC4) 927296177Sjhibbits FM_M_CALL_1G_MAC_ERR_ISR(4); 928296177Sjhibbits if(pending & ERR_INTR_EN_10G_MAC0) 929296177Sjhibbits { 930296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[e_FM_EV_ERR_10G_MAC0].guestId) 931296177Sjhibbits SendIpcIsr(p_Fm, e_FM_EV_ERR_10G_MAC0, pending); 932296177Sjhibbits else 933296177Sjhibbits p_Fm->intrMng[e_FM_EV_ERR_10G_MAC0].f_Isr(p_Fm->intrMng[e_FM_EV_ERR_10G_MAC0].h_SrcHandle); 934296177Sjhibbits } 935296177Sjhibbits} 936296177Sjhibbits 937296177Sjhibbits 938296177Sjhibbits#ifdef FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 939296177Sjhibbitst_Error Fm10GTxEccWorkaround(t_Handle h_Fm, uint8_t macId) 940296177Sjhibbits{ 941296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 942296177Sjhibbits int timeout = 1000; 943296177Sjhibbits t_Error err = E_OK; 944296177Sjhibbits t_FmIpcMsg msg; 945296177Sjhibbits t_FmIpcReply reply; 946296177Sjhibbits uint32_t replyLength; 947296177Sjhibbits uint8_t rxHardwarePortId, txHardwarePortId; 948296177Sjhibbits 949296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 950296177Sjhibbits { 951296177Sjhibbits memset(&msg, 0, sizeof(msg)); 952296177Sjhibbits memset(&reply, 0, sizeof(reply)); 953296177Sjhibbits msg.msgId = FM_10G_TX_ECC_WA; 954296177Sjhibbits msg.msgBody[0] = macId; 955296177Sjhibbits replyLength = sizeof(uint32_t); 956296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 957296177Sjhibbits (uint8_t*)&msg, 958296177Sjhibbits sizeof(msg.msgId)+sizeof(macId), 959296177Sjhibbits (uint8_t*)&reply, 960296177Sjhibbits &replyLength, 961296177Sjhibbits NULL, 962296177Sjhibbits NULL)) != E_OK) 963296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 964296177Sjhibbits if (replyLength != sizeof(uint32_t)) 965296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 966296177Sjhibbits return (t_Error)(reply.error); 967296177Sjhibbits } 968296177Sjhibbits 969296177Sjhibbits SANITY_CHECK_RETURN_ERROR((macId == 0), E_NOT_SUPPORTED); 970296177Sjhibbits SANITY_CHECK_RETURN_ERROR(IsFmanCtrlCodeLoaded(p_Fm), E_INVALID_STATE); 971296177Sjhibbits 972296177Sjhibbits SW_PORT_ID_TO_HW_PORT_ID(rxHardwarePortId, e_FM_PORT_TYPE_RX_10G, macId); 973296177Sjhibbits SW_PORT_ID_TO_HW_PORT_ID(txHardwarePortId, e_FM_PORT_TYPE_TX_10G, macId); 974296177Sjhibbits if ((p_Fm->p_FmStateStruct->portsTypes[rxHardwarePortId] != e_FM_PORT_TYPE_DUMMY) || 975296177Sjhibbits (p_Fm->p_FmStateStruct->portsTypes[txHardwarePortId] != e_FM_PORT_TYPE_DUMMY)) 976296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, 977296177Sjhibbits ("MAC should be initialized prior to rx and tx ports!")); 978296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmextc, 0x40000000); 979296177Sjhibbits CORE_MemoryBarrier(); 980296177Sjhibbits while ((GET_UINT32(p_Fm->p_FmFpmRegs->fpmextc) & 0x40000000) && 981296177Sjhibbits --timeout) ; 982296177Sjhibbits if (!timeout) 983296177Sjhibbits return ERROR_CODE(E_TIMEOUT); 984296177Sjhibbits return E_OK; 985296177Sjhibbits} 986296177Sjhibbits#endif /* FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 */ 987296177Sjhibbits 988296177Sjhibbitsuintptr_t FmGetPcdPrsBaseAddr(t_Handle h_Fm) 989296177Sjhibbits{ 990296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 991296177Sjhibbits 992296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, 0); 993296177Sjhibbits 994296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 995296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Guset")); 996296177Sjhibbits 997296177Sjhibbits return (p_Fm->baseAddr + FM_MM_PRS); 998296177Sjhibbits} 999296177Sjhibbits 1000296177Sjhibbitsuintptr_t FmGetPcdKgBaseAddr(t_Handle h_Fm) 1001296177Sjhibbits{ 1002296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1003296177Sjhibbits 1004296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, 0); 1005296177Sjhibbits 1006296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1007296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Guset")); 1008296177Sjhibbits 1009296177Sjhibbits return (p_Fm->baseAddr + FM_MM_KG); 1010296177Sjhibbits} 1011296177Sjhibbits 1012296177Sjhibbitsuintptr_t FmGetPcdPlcrBaseAddr(t_Handle h_Fm) 1013296177Sjhibbits{ 1014296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1015296177Sjhibbits 1016296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, 0); 1017296177Sjhibbits 1018296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1019296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Guset")); 1020296177Sjhibbits 1021296177Sjhibbits return (p_Fm->baseAddr + FM_MM_PLCR); 1022296177Sjhibbits} 1023296177Sjhibbits 1024296177Sjhibbitst_Handle FmGetMuramHandle(t_Handle h_Fm) 1025296177Sjhibbits{ 1026296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1027296177Sjhibbits 1028296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, NULL); 1029296177Sjhibbits 1030296177Sjhibbits return (p_Fm->h_FmMuram); 1031296177Sjhibbits} 1032296177Sjhibbits 1033296177Sjhibbitsvoid FmGetPhysicalMuramBase(t_Handle h_Fm, t_FmPhysAddr *p_FmPhysAddr) 1034296177Sjhibbits{ 1035296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1036296177Sjhibbits t_Error err; 1037296177Sjhibbits t_FmIpcMsg msg; 1038296177Sjhibbits t_FmIpcReply reply; 1039296177Sjhibbits uint32_t replyLength; 1040296177Sjhibbits t_FmIpcPhysAddr ipcPhysAddr; 1041296177Sjhibbits 1042296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1043296177Sjhibbits { 1044296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1045296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1046296177Sjhibbits msg.msgId = FM_GET_PHYS_MURAM_BASE; 1047296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(t_FmPhysAddr); 1048296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1049296177Sjhibbits (uint8_t*)&msg, 1050296177Sjhibbits sizeof(msg.msgId), 1051296177Sjhibbits (uint8_t*)&reply, 1052296177Sjhibbits &replyLength, 1053296177Sjhibbits NULL, 1054296177Sjhibbits NULL)) != E_OK) 1055296177Sjhibbits { 1056296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1057296177Sjhibbits return; 1058296177Sjhibbits } 1059296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(t_FmPhysAddr))) 1060296177Sjhibbits { 1061296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_VALUE,("IPC reply length mismatch")); 1062296177Sjhibbits return; 1063296177Sjhibbits } 1064296177Sjhibbits memcpy((uint8_t*)&ipcPhysAddr, reply.replyBody, sizeof(t_FmIpcPhysAddr)); 1065296177Sjhibbits p_FmPhysAddr->high = ipcPhysAddr.high; 1066296177Sjhibbits p_FmPhysAddr->low = ipcPhysAddr.low; 1067296177Sjhibbits return ; 1068296177Sjhibbits } 1069296177Sjhibbits 1070296177Sjhibbits /* General FM driver initialization */ 1071296177Sjhibbits p_FmPhysAddr->low = (uint32_t)p_Fm->fmMuramPhysBaseAddr; 1072296177Sjhibbits p_FmPhysAddr->high = (uint8_t)((p_Fm->fmMuramPhysBaseAddr & 0x000000ff00000000LL) >> 32); 1073296177Sjhibbits} 1074296177Sjhibbits 1075296177Sjhibbitst_Error FmAllocFmanCtrlEventReg(t_Handle h_Fm, uint8_t *p_EventId) 1076296177Sjhibbits{ 1077296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1078296177Sjhibbits uint8_t i; 1079296177Sjhibbits t_Error err; 1080296177Sjhibbits t_FmIpcMsg msg; 1081296177Sjhibbits t_FmIpcReply reply; 1082296177Sjhibbits uint32_t replyLength; 1083296177Sjhibbits 1084296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1085296177Sjhibbits { 1086296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1087296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1088296177Sjhibbits msg.msgId = FM_ALLOC_FMAN_CTRL_EVENT_REG; 1089296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint8_t); 1090296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1091296177Sjhibbits (uint8_t*)&msg, 1092296177Sjhibbits sizeof(msg.msgId), 1093296177Sjhibbits (uint8_t*)&reply, 1094296177Sjhibbits &replyLength, 1095296177Sjhibbits NULL, 1096296177Sjhibbits NULL)) != E_OK) 1097296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1098296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(uint8_t))) 1099296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1100296177Sjhibbits 1101296177Sjhibbits *p_EventId = *(uint8_t*)(reply.replyBody); 1102296177Sjhibbits 1103296177Sjhibbits return (t_Error)(reply.error); 1104296177Sjhibbits } 1105296177Sjhibbits 1106296177Sjhibbits for(i=0;i<FM_NUM_OF_FMAN_CTRL_EVENT_REGS;i++) 1107296177Sjhibbits if (!p_Fm->usedEventRegs[i]) 1108296177Sjhibbits { 1109296177Sjhibbits p_Fm->usedEventRegs[i] = TRUE; 1110296177Sjhibbits *p_EventId = i; 1111296177Sjhibbits break; 1112296177Sjhibbits } 1113296177Sjhibbits 1114296177Sjhibbits if (i==FM_NUM_OF_FMAN_CTRL_EVENT_REGS) 1115296177Sjhibbits RETURN_ERROR(MAJOR, E_BUSY, ("No resource - Fman controller event register.")); 1116296177Sjhibbits 1117296177Sjhibbits return E_OK; 1118296177Sjhibbits} 1119296177Sjhibbits 1120296177Sjhibbitsvoid FmFreeFmanCtrlEventReg(t_Handle h_Fm, uint8_t eventId) 1121296177Sjhibbits{ 1122296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1123296177Sjhibbits t_Error err; 1124296177Sjhibbits t_FmIpcMsg msg; 1125296177Sjhibbits 1126296177Sjhibbits if(((t_Fm *)h_Fm)->guestId != NCSW_MASTER_ID) 1127296177Sjhibbits { 1128296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1129296177Sjhibbits msg.msgId = FM_FREE_FMAN_CTRL_EVENT_REG; 1130296177Sjhibbits msg.msgBody[0] = eventId; 1131296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1132296177Sjhibbits (uint8_t*)&msg, 1133296177Sjhibbits sizeof(msg.msgId)+sizeof(eventId), 1134296177Sjhibbits NULL, 1135296177Sjhibbits NULL, 1136296177Sjhibbits NULL, 1137296177Sjhibbits NULL)) != E_OK) 1138296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1139296177Sjhibbits return; 1140296177Sjhibbits } 1141296177Sjhibbits 1142296177Sjhibbits ((t_Fm*)h_Fm)->usedEventRegs[eventId] = FALSE; 1143296177Sjhibbits} 1144296177Sjhibbits 1145296177Sjhibbitsvoid FmRegisterIntr(t_Handle h_Fm, 1146296177Sjhibbits e_FmEventModules module, 1147296177Sjhibbits uint8_t modId, 1148296177Sjhibbits e_FmIntrType intrType, 1149296177Sjhibbits void (*f_Isr) (t_Handle h_Arg), 1150296177Sjhibbits t_Handle h_Arg) 1151296177Sjhibbits{ 1152296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1153296177Sjhibbits uint8_t event= 0; 1154296177Sjhibbits t_FmIpcRegisterIntr fmIpcRegisterIntr; 1155296177Sjhibbits t_Error err; 1156296177Sjhibbits t_FmIpcMsg msg; 1157296177Sjhibbits 1158296177Sjhibbits ASSERT_COND(h_Fm); 1159296177Sjhibbits 1160296177Sjhibbits GET_FM_MODULE_EVENT(module, modId,intrType, event); 1161296177Sjhibbits 1162296177Sjhibbits /* register in local FM structure */ 1163296177Sjhibbits ASSERT_COND(event != e_FM_EV_DUMMY_LAST); 1164296177Sjhibbits p_Fm->intrMng[event].f_Isr = f_Isr; 1165296177Sjhibbits p_Fm->intrMng[event].h_SrcHandle = h_Arg; 1166296177Sjhibbits 1167296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1168296177Sjhibbits { 1169296177Sjhibbits if(p_Fm->h_IpcSessions[0]) 1170296177Sjhibbits { 1171296177Sjhibbits /* register in Master FM structure */ 1172296177Sjhibbits fmIpcRegisterIntr.event = event; 1173296177Sjhibbits fmIpcRegisterIntr.guestId = p_Fm->guestId; 1174296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1175296177Sjhibbits msg.msgId = FM_REGISTER_INTR; 1176296177Sjhibbits memcpy(msg.msgBody, &fmIpcRegisterIntr, sizeof(fmIpcRegisterIntr)); 1177296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1178296177Sjhibbits (uint8_t*)&msg, 1179296177Sjhibbits sizeof(msg.msgId) + sizeof(fmIpcRegisterIntr), 1180296177Sjhibbits NULL, 1181296177Sjhibbits NULL, 1182296177Sjhibbits NULL, 1183296177Sjhibbits NULL)) != E_OK) 1184296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1185296177Sjhibbits } 1186296177Sjhibbits else 1187296177Sjhibbits DBG(WARNING,("'Register interrupt' - unavailable - No IPC")); 1188296177Sjhibbits } 1189296177Sjhibbits 1190296177Sjhibbits} 1191296177Sjhibbits 1192296177Sjhibbitsvoid FmUnregisterIntr(t_Handle h_Fm, 1193296177Sjhibbits e_FmEventModules module, 1194296177Sjhibbits uint8_t modId, 1195296177Sjhibbits e_FmIntrType intrType) 1196296177Sjhibbits{ 1197296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1198296177Sjhibbits uint8_t event= 0; 1199296177Sjhibbits 1200296177Sjhibbits ASSERT_COND(h_Fm); 1201296177Sjhibbits 1202296177Sjhibbits GET_FM_MODULE_EVENT(module, modId,intrType, event); 1203296177Sjhibbits 1204296177Sjhibbits ASSERT_COND(event != e_FM_EV_DUMMY_LAST); 1205296177Sjhibbits p_Fm->intrMng[event].f_Isr = UnimplementedIsr; 1206296177Sjhibbits p_Fm->intrMng[event].h_SrcHandle = NULL; 1207296177Sjhibbits} 1208296177Sjhibbits 1209296177Sjhibbitsvoid FmSetFmanCtrlIntr(t_Handle h_Fm, uint8_t eventRegId, uint32_t enableEvents) 1210296177Sjhibbits{ 1211296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1212296177Sjhibbits t_FmIpcFmanEvents fmanCtrl; 1213296177Sjhibbits t_Error err; 1214296177Sjhibbits t_FmIpcMsg msg; 1215296177Sjhibbits 1216296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1217296177Sjhibbits { 1218296177Sjhibbits fmanCtrl.eventRegId = eventRegId; 1219296177Sjhibbits fmanCtrl.enableEvents = enableEvents; 1220296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1221296177Sjhibbits msg.msgId = FM_SET_FMAN_CTRL_EVENTS_ENABLE; 1222296177Sjhibbits memcpy(msg.msgBody, &fmanCtrl, sizeof(fmanCtrl)); 1223296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1224296177Sjhibbits (uint8_t*)&msg, 1225296177Sjhibbits sizeof(msg.msgId)+sizeof(fmanCtrl), 1226296177Sjhibbits NULL, 1227296177Sjhibbits NULL, 1228296177Sjhibbits NULL, 1229296177Sjhibbits NULL)) != E_OK) 1230296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1231296177Sjhibbits return; 1232296177Sjhibbits } 1233296177Sjhibbits 1234296177Sjhibbits ASSERT_COND(eventRegId < FM_NUM_OF_FMAN_CTRL_EVENT_REGS); 1235296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[eventRegId], enableEvents); 1236296177Sjhibbits} 1237296177Sjhibbits 1238296177Sjhibbitsuint32_t FmGetFmanCtrlIntr(t_Handle h_Fm, uint8_t eventRegId) 1239296177Sjhibbits{ 1240296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1241296177Sjhibbits t_Error err; 1242296177Sjhibbits t_FmIpcMsg msg; 1243296177Sjhibbits t_FmIpcReply reply; 1244296177Sjhibbits uint32_t replyLength, ctrlIntr; 1245296177Sjhibbits 1246296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1247296177Sjhibbits { 1248296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1249296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1250296177Sjhibbits msg.msgId = FM_GET_FMAN_CTRL_EVENTS_ENABLE; 1251296177Sjhibbits msg.msgBody[0] = eventRegId; 1252296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint32_t); 1253296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1254296177Sjhibbits (uint8_t*)&msg, 1255296177Sjhibbits sizeof(msg.msgId)+sizeof(eventRegId), 1256296177Sjhibbits (uint8_t*)&reply, 1257296177Sjhibbits &replyLength, 1258296177Sjhibbits NULL, 1259296177Sjhibbits NULL)) != E_OK) 1260296177Sjhibbits { 1261296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1262296177Sjhibbits return 0; 1263296177Sjhibbits } 1264296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(uint32_t))) 1265296177Sjhibbits { 1266296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1267296177Sjhibbits return 0; 1268296177Sjhibbits } 1269296177Sjhibbits memcpy((uint8_t*)&ctrlIntr, reply.replyBody, sizeof(uint32_t)); 1270296177Sjhibbits return ctrlIntr; 1271296177Sjhibbits } 1272296177Sjhibbits 1273296177Sjhibbits return GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[eventRegId]); 1274296177Sjhibbits} 1275296177Sjhibbits 1276296177Sjhibbitsvoid FmRegisterFmanCtrlIntr(t_Handle h_Fm, uint8_t eventRegId, void (*f_Isr) (t_Handle h_Arg, uint32_t event), t_Handle h_Arg) 1277296177Sjhibbits{ 1278296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1279296177Sjhibbits 1280296177Sjhibbits ASSERT_COND(eventRegId<FM_NUM_OF_FMAN_CTRL_EVENT_REGS); 1281296177Sjhibbits 1282296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1283296177Sjhibbits { 1284296177Sjhibbits ASSERT_COND(0); 1285296177Sjhibbits /* TODO */ 1286296177Sjhibbits } 1287296177Sjhibbits 1288296177Sjhibbits p_Fm->fmanCtrlIntr[eventRegId].f_Isr = f_Isr; 1289296177Sjhibbits p_Fm->fmanCtrlIntr[eventRegId].h_SrcHandle = h_Arg; 1290296177Sjhibbits} 1291296177Sjhibbits 1292296177Sjhibbitsvoid FmUnregisterFmanCtrlIntr(t_Handle h_Fm, uint8_t eventRegId) 1293296177Sjhibbits{ 1294296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1295296177Sjhibbits 1296296177Sjhibbits ASSERT_COND(eventRegId<FM_NUM_OF_FMAN_CTRL_EVENT_REGS); 1297296177Sjhibbits 1298296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1299296177Sjhibbits { 1300296177Sjhibbits ASSERT_COND(0); 1301296177Sjhibbits /* TODO */ 1302296177Sjhibbits } 1303296177Sjhibbits 1304296177Sjhibbits p_Fm->fmanCtrlIntr[eventRegId].f_Isr = UnimplementedFmanCtrlIsr; 1305296177Sjhibbits p_Fm->fmanCtrlIntr[eventRegId].h_SrcHandle = NULL; 1306296177Sjhibbits} 1307296177Sjhibbits 1308296177Sjhibbitsvoid FmRegisterPcd(t_Handle h_Fm, t_Handle h_FmPcd) 1309296177Sjhibbits{ 1310296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1311296177Sjhibbits 1312296177Sjhibbits if(p_Fm->h_Pcd) 1313296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("PCD already set")); 1314296177Sjhibbits 1315296177Sjhibbits p_Fm->h_Pcd = h_FmPcd; 1316296177Sjhibbits 1317296177Sjhibbits} 1318296177Sjhibbits 1319296177Sjhibbitsvoid FmUnregisterPcd(t_Handle h_Fm) 1320296177Sjhibbits{ 1321296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1322296177Sjhibbits 1323296177Sjhibbits if(!p_Fm->h_Pcd) 1324296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("No PCD")); 1325296177Sjhibbits 1326296177Sjhibbits p_Fm->h_Pcd = NULL; 1327296177Sjhibbits 1328296177Sjhibbits} 1329296177Sjhibbits 1330296177Sjhibbitst_Handle FmGetPcdHandle(t_Handle h_Fm) 1331296177Sjhibbits{ 1332296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1333296177Sjhibbits 1334296177Sjhibbits return p_Fm->h_Pcd; 1335296177Sjhibbits} 1336296177Sjhibbits 1337296177Sjhibbitsuint8_t FmGetId(t_Handle h_Fm) 1338296177Sjhibbits{ 1339296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1340296177Sjhibbits 1341296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, 0xff); 1342296177Sjhibbits 1343296177Sjhibbits return p_Fm->p_FmStateStruct->fmId; 1344296177Sjhibbits} 1345296177Sjhibbits 1346296177Sjhibbitst_Error FmSetNumOfRiscsPerPort(t_Handle h_Fm, uint8_t hardwarePortId, uint8_t numOfFmanCtrls) 1347296177Sjhibbits{ 1348296177Sjhibbits 1349296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1350296177Sjhibbits uint32_t tmpReg = 0; 1351296177Sjhibbits t_Error err; 1352296177Sjhibbits t_FmIpcPortNumOfFmanCtrls params; 1353296177Sjhibbits t_FmIpcMsg msg; 1354296177Sjhibbits 1355296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 1356296177Sjhibbits SANITY_CHECK_RETURN_ERROR(((numOfFmanCtrls > 0) && (numOfFmanCtrls < 3)) , E_INVALID_HANDLE); 1357296177Sjhibbits 1358296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1359296177Sjhibbits { 1360296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1361296177Sjhibbits params.hardwarePortId = hardwarePortId; 1362296177Sjhibbits params.numOfFmanCtrls = numOfFmanCtrls; 1363296177Sjhibbits msg.msgId = FM_SET_NUM_OF_FMAN_CTRL; 1364296177Sjhibbits memcpy(msg.msgBody, ¶ms, sizeof(params)); 1365296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1366296177Sjhibbits (uint8_t*)&msg, 1367296177Sjhibbits sizeof(msg.msgId) +sizeof(params), 1368296177Sjhibbits NULL, 1369296177Sjhibbits NULL, 1370296177Sjhibbits NULL, 1371296177Sjhibbits NULL)) != E_OK) 1372296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1373296177Sjhibbits 1374296177Sjhibbits return E_OK; 1375296177Sjhibbits } 1376296177Sjhibbits 1377296177Sjhibbits XX_LockSpinlock(p_Fm->h_Spinlock); 1378296177Sjhibbits 1379296177Sjhibbits tmpReg = (uint32_t)(hardwarePortId << FPM_PORT_FM_CTL_PORTID_SHIFT); 1380296177Sjhibbits 1381296177Sjhibbits /*TODO - maybe to put CTL# according to another criteria*/ 1382296177Sjhibbits 1383296177Sjhibbits if(numOfFmanCtrls == 2) 1384296177Sjhibbits tmpReg = FPM_PORT_FM_CTL2 | FPM_PORT_FM_CTL1; 1385296177Sjhibbits 1386296177Sjhibbits /* order restoration */ 1387296177Sjhibbits if(hardwarePortId%2) 1388296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT) | FPM_PORT_FM_CTL1; 1389296177Sjhibbits else 1390296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT) | FPM_PORT_FM_CTL2; 1391296177Sjhibbits 1392296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmpr, tmpReg); 1393296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1394296177Sjhibbits 1395296177Sjhibbits return E_OK; 1396296177Sjhibbits} 1397296177Sjhibbits 1398296177Sjhibbitst_Error FmGetSetPortParams(t_Handle h_Fm,t_FmInterModulePortInitParams *p_PortParams) 1399296177Sjhibbits{ 1400296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1401296177Sjhibbits uint32_t tmpReg; 1402296177Sjhibbits uint8_t hardwarePortId = p_PortParams->hardwarePortId; 1403296177Sjhibbits t_FmIpcPortInInitParams portInParams; 1404296177Sjhibbits t_FmIpcPhysAddr ipcPhysAddr; 1405296177Sjhibbits t_Error err; 1406296177Sjhibbits t_FmIpcMsg msg; 1407296177Sjhibbits t_FmIpcReply reply; 1408296177Sjhibbits uint32_t replyLength; 1409296177Sjhibbits 1410296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1411296177Sjhibbits { 1412296177Sjhibbits portInParams.hardwarePortId = p_PortParams->hardwarePortId; 1413296177Sjhibbits portInParams.enumPortType = (uint32_t)p_PortParams->portType; 1414296177Sjhibbits portInParams.boolIndependentMode = (uint8_t)p_PortParams->independentMode; 1415296177Sjhibbits portInParams.liodnOffset = p_PortParams->liodnOffset; 1416296177Sjhibbits portInParams.numOfTasks = p_PortParams->numOfTasks; 1417296177Sjhibbits portInParams.numOfExtraTasks = p_PortParams->numOfExtraTasks; 1418296177Sjhibbits portInParams.numOfOpenDmas = p_PortParams->numOfOpenDmas; 1419296177Sjhibbits portInParams.numOfExtraOpenDmas = p_PortParams->numOfExtraOpenDmas; 1420296177Sjhibbits portInParams.sizeOfFifo = p_PortParams->sizeOfFifo; 1421296177Sjhibbits portInParams.extraSizeOfFifo = p_PortParams->extraSizeOfFifo; 1422296177Sjhibbits portInParams.deqPipelineDepth = p_PortParams->deqPipelineDepth; 1423296177Sjhibbits portInParams.liodnBase = p_PortParams->liodnBase; 1424296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1425296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1426296177Sjhibbits msg.msgId = FM_GET_SET_PORT_PARAMS; 1427296177Sjhibbits memcpy(msg.msgBody, &portInParams, sizeof(portInParams)); 1428296177Sjhibbits replyLength = (sizeof(uint32_t) + sizeof(p_PortParams->fmMuramPhysBaseAddr)); 1429296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1430296177Sjhibbits (uint8_t*)&msg, 1431296177Sjhibbits sizeof(msg.msgId) +sizeof(portInParams), 1432296177Sjhibbits (uint8_t*)&reply, 1433296177Sjhibbits &replyLength, 1434296177Sjhibbits NULL, 1435296177Sjhibbits NULL)) != E_OK) 1436296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1437296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(p_PortParams->fmMuramPhysBaseAddr))) 1438296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1439296177Sjhibbits memcpy((uint8_t*)&ipcPhysAddr, reply.replyBody, sizeof(t_FmIpcPhysAddr)); 1440296177Sjhibbits p_PortParams->fmMuramPhysBaseAddr.high = ipcPhysAddr.high; 1441296177Sjhibbits p_PortParams->fmMuramPhysBaseAddr.low = ipcPhysAddr.low; 1442296177Sjhibbits 1443296177Sjhibbits return (t_Error)(reply.error); 1444296177Sjhibbits } 1445296177Sjhibbits 1446296177Sjhibbits ASSERT_COND(IN_RANGE(1, hardwarePortId, 63)); 1447296177Sjhibbits XX_LockSpinlock(p_Fm->h_Spinlock); 1448296177Sjhibbits 1449296177Sjhibbits if(p_PortParams->independentMode) 1450296177Sjhibbits { 1451296177Sjhibbits /* set port parameters */ 1452296177Sjhibbits p_Fm->independentMode = p_PortParams->independentMode; 1453296177Sjhibbits /* disable dispatch limit */ 1454296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmflc, 0); 1455296177Sjhibbits } 1456296177Sjhibbits 1457296177Sjhibbits if(p_PortParams->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 1458296177Sjhibbits { 1459296177Sjhibbits if(p_Fm->hcPortInitialized) 1460296177Sjhibbits { 1461296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1462296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Only one host command port is allowed.")); 1463296177Sjhibbits } 1464296177Sjhibbits else 1465296177Sjhibbits p_Fm->hcPortInitialized = TRUE; 1466296177Sjhibbits } 1467296177Sjhibbits p_Fm->p_FmStateStruct->portsTypes[hardwarePortId] = p_PortParams->portType; 1468296177Sjhibbits 1469296177Sjhibbits err = FmSetNumOfTasks(p_Fm, p_PortParams->hardwarePortId, p_PortParams->numOfTasks, p_PortParams->numOfExtraTasks, TRUE); 1470296177Sjhibbits if(err) 1471296177Sjhibbits { 1472296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1473296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1474296177Sjhibbits } 1475296177Sjhibbits 1476296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 1477296177Sjhibbits if((p_PortParams->portType != e_FM_PORT_TYPE_RX) && (p_PortParams->portType != e_FM_PORT_TYPE_RX_10G)) 1478296177Sjhibbits /* for transmit & O/H ports */ 1479296177Sjhibbits { 1480296177Sjhibbits uint8_t enqTh; 1481296177Sjhibbits uint8_t deqTh; 1482296177Sjhibbits bool update = FALSE; 1483296177Sjhibbits 1484296177Sjhibbits /* update qmi ENQ/DEQ threshold */ 1485296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums += p_PortParams->deqPipelineDepth; 1486296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc); 1487296177Sjhibbits enqTh = (uint8_t)(tmpReg>>8); 1488296177Sjhibbits /* if enqTh is too big, we reduce it to the max value that is still OK */ 1489296177Sjhibbits if(enqTh >= (QMI_MAX_NUM_OF_TNUMS - p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums)) 1490296177Sjhibbits { 1491296177Sjhibbits enqTh = (uint8_t)(QMI_MAX_NUM_OF_TNUMS - p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums - 1); 1492296177Sjhibbits tmpReg &= ~QMI_CFG_ENQ_MASK; 1493296177Sjhibbits tmpReg |= ((uint32_t)enqTh << 8); 1494296177Sjhibbits update = TRUE; 1495296177Sjhibbits } 1496296177Sjhibbits 1497296177Sjhibbits deqTh = (uint8_t)tmpReg; 1498296177Sjhibbits /* if deqTh is too small, we enlarge it to the min value that is still OK. 1499296177Sjhibbits deqTh may not be larger than 63 (QMI_MAX_NUM_OF_TNUMS-1). */ 1500296177Sjhibbits if((deqTh <= p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums) && (deqTh < QMI_MAX_NUM_OF_TNUMS-1)) 1501296177Sjhibbits { 1502296177Sjhibbits deqTh = (uint8_t)(p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums + 1); 1503296177Sjhibbits tmpReg &= ~QMI_CFG_DEQ_MASK; 1504296177Sjhibbits tmpReg |= (uint32_t)deqTh; 1505296177Sjhibbits update = TRUE; 1506296177Sjhibbits } 1507296177Sjhibbits if(update) 1508296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc, tmpReg); 1509296177Sjhibbits } 1510296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 1511296177Sjhibbits 1512296177Sjhibbits#ifdef FM_LOW_END_RESTRICTION 1513296177Sjhibbits if((hardwarePortId==0x1) || (hardwarePortId==0x29)) 1514296177Sjhibbits { 1515296177Sjhibbits if(p_Fm->p_FmStateStruct->lowEndRestriction) 1516296177Sjhibbits { 1517296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1518296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("OP #0 cannot work with Tx Port #1.")); 1519296177Sjhibbits } 1520296177Sjhibbits else 1521296177Sjhibbits p_Fm->p_FmStateStruct->lowEndRestriction = TRUE; 1522296177Sjhibbits } 1523296177Sjhibbits#endif /* FM_LOW_END_RESTRICTION */ 1524296177Sjhibbits 1525296177Sjhibbits err = FmSetSizeOfFifo(p_Fm, 1526296177Sjhibbits p_PortParams->hardwarePortId, 1527296177Sjhibbits p_PortParams->portType, 1528296177Sjhibbits p_PortParams->independentMode, 1529296177Sjhibbits &p_PortParams->sizeOfFifo, 1530296177Sjhibbits p_PortParams->extraSizeOfFifo, 1531296177Sjhibbits p_PortParams->deqPipelineDepth, 1532296177Sjhibbits NULL, 1533296177Sjhibbits TRUE); 1534296177Sjhibbits if(err) 1535296177Sjhibbits { 1536296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1537296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1538296177Sjhibbits } 1539296177Sjhibbits 1540296177Sjhibbits err = FmSetNumOfOpenDmas(p_Fm, p_PortParams->hardwarePortId, p_PortParams->numOfOpenDmas, p_PortParams->numOfExtraOpenDmas, TRUE); 1541296177Sjhibbits if(err) 1542296177Sjhibbits { 1543296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1544296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1545296177Sjhibbits } 1546296177Sjhibbits 1547296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ppid[hardwarePortId-1], (uint32_t)p_PortParams->liodnOffset); 1548296177Sjhibbits 1549296177Sjhibbits tmpReg = (uint32_t)(hardwarePortId << FPM_PORT_FM_CTL_PORTID_SHIFT); 1550296177Sjhibbits if(p_PortParams->independentMode) 1551296177Sjhibbits { 1552296177Sjhibbits if((p_PortParams->portType==e_FM_PORT_TYPE_RX) || (p_PortParams->portType==e_FM_PORT_TYPE_RX_10G)) 1553296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT) |FPM_PORT_FM_CTL1; 1554296177Sjhibbits else 1555296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT) |FPM_PORT_FM_CTL2; 1556296177Sjhibbits } 1557296177Sjhibbits else 1558296177Sjhibbits { 1559296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL2|FPM_PORT_FM_CTL1); 1560296177Sjhibbits 1561296177Sjhibbits /* order restoration */ 1562296177Sjhibbits if(hardwarePortId%2) 1563296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT); 1564296177Sjhibbits else 1565296177Sjhibbits tmpReg |= (FPM_PORT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT); 1566296177Sjhibbits } 1567296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmpr, tmpReg); 1568296177Sjhibbits 1569296177Sjhibbits { 1570296177Sjhibbits#ifdef FM_PARTITION_ARRAY 1571296177Sjhibbits t_FmRevisionInfo revInfo; 1572296177Sjhibbits 1573296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 1574296177Sjhibbits if (revInfo.majorRev >= 2) 1575296177Sjhibbits#endif /* FM_PARTITION_ARRAY */ 1576296177Sjhibbits { 1577296177Sjhibbits /* set LIODN base for this port */ 1578296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmplr[hardwarePortId/2]); 1579296177Sjhibbits if(hardwarePortId%2) 1580296177Sjhibbits { 1581296177Sjhibbits tmpReg &= ~FM_LIODN_BASE_MASK; 1582296177Sjhibbits tmpReg |= (uint32_t)p_PortParams->liodnBase; 1583296177Sjhibbits } 1584296177Sjhibbits else 1585296177Sjhibbits { 1586296177Sjhibbits tmpReg &= ~(FM_LIODN_BASE_MASK<< DMA_LIODN_SHIFT); 1587296177Sjhibbits tmpReg |= (uint32_t)p_PortParams->liodnBase << DMA_LIODN_SHIFT; 1588296177Sjhibbits } 1589296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmplr[hardwarePortId/2], tmpReg); 1590296177Sjhibbits } 1591296177Sjhibbits } 1592296177Sjhibbits 1593296177Sjhibbits FmGetPhysicalMuramBase(p_Fm, &p_PortParams->fmMuramPhysBaseAddr); 1594296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1595296177Sjhibbits 1596296177Sjhibbits return E_OK; 1597296177Sjhibbits} 1598296177Sjhibbits 1599296177Sjhibbitsvoid FmFreePortParams(t_Handle h_Fm,t_FmInterModulePortFreeParams *p_PortParams) 1600296177Sjhibbits{ 1601296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1602296177Sjhibbits uint32_t tmpReg; 1603296177Sjhibbits uint8_t hardwarePortId = p_PortParams->hardwarePortId; 1604296177Sjhibbits uint8_t numOfTasks; 1605296177Sjhibbits t_Error err; 1606296177Sjhibbits t_FmIpcPortFreeParams portParams; 1607296177Sjhibbits t_FmIpcMsg msg; 1608296177Sjhibbits 1609296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1610296177Sjhibbits { 1611296177Sjhibbits portParams.hardwarePortId = p_PortParams->hardwarePortId; 1612296177Sjhibbits portParams.enumPortType = (uint32_t)p_PortParams->portType; 1613296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 1614296177Sjhibbits portParams.deqPipelineDepth = p_PortParams->deqPipelineDepth; 1615296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 1616296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1617296177Sjhibbits msg.msgId = FM_FREE_PORT; 1618296177Sjhibbits memcpy(msg.msgBody, &portParams, sizeof(portParams)); 1619296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1620296177Sjhibbits (uint8_t*)&msg, 1621296177Sjhibbits sizeof(msg.msgId)+sizeof(portParams), 1622296177Sjhibbits NULL, 1623296177Sjhibbits NULL, 1624296177Sjhibbits NULL, 1625296177Sjhibbits NULL)) != E_OK) 1626296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1627296177Sjhibbits return; 1628296177Sjhibbits } 1629296177Sjhibbits 1630296177Sjhibbits ASSERT_COND(IN_RANGE(1, hardwarePortId, 63)); 1631296177Sjhibbits XX_LockSpinlock(p_Fm->h_Spinlock); 1632296177Sjhibbits 1633296177Sjhibbits 1634296177Sjhibbits if(p_PortParams->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 1635296177Sjhibbits { 1636296177Sjhibbits ASSERT_COND(p_Fm->hcPortInitialized); 1637296177Sjhibbits p_Fm->hcPortInitialized = FALSE; 1638296177Sjhibbits } 1639296177Sjhibbits 1640296177Sjhibbits p_Fm->p_FmStateStruct->portsTypes[hardwarePortId] = e_FM_PORT_TYPE_DUMMY; 1641296177Sjhibbits 1642296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1]); 1643296177Sjhibbits /* free numOfTasks */ 1644296177Sjhibbits numOfTasks = (uint8_t)(((tmpReg & BMI_NUM_OF_TASKS_MASK) >> BMI_NUM_OF_TASKS_SHIFT) + 1); 1645296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedNumOfTasks >= numOfTasks); 1646296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfTasks -= numOfTasks; 1647296177Sjhibbits 1648296177Sjhibbits /* free numOfOpenDmas */ 1649296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas >= ((tmpReg & BMI_NUM_OF_DMAS_MASK) >> BMI_NUM_OF_DMAS_SHIFT) + 1); 1650296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas -= (((tmpReg & BMI_NUM_OF_DMAS_MASK) >> BMI_NUM_OF_DMAS_SHIFT) + 1); 1651296177Sjhibbits 1652296177Sjhibbits /* update total num of DMA's with committed number of open DMAS, and max uncommitted pool. */ 1653296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2) & ~BMI_CFG2_DMAS_MASK; 1654296177Sjhibbits tmpReg |= (uint32_t)(p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas + p_Fm->p_FmStateStruct->extraOpenDmasPoolSize - 1) << BMI_CFG2_DMAS_SHIFT; 1655296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2, tmpReg); 1656296177Sjhibbits 1657296177Sjhibbits /* free sizeOfFifo */ 1658296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1]); 1659296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedFifoSize >= 1660296177Sjhibbits (((tmpReg & BMI_FIFO_SIZE_MASK) + 1) * BMI_FIFO_UNITS)); 1661296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedFifoSize -= 1662296177Sjhibbits (((tmpReg & BMI_FIFO_SIZE_MASK) + 1) * BMI_FIFO_UNITS); 1663296177Sjhibbits 1664296177Sjhibbits /* clear registers */ 1665296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1], 0); 1666296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1], 0); 1667296177Sjhibbits /* WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ppid[hardwarePortId-1], 0); */ 1668296177Sjhibbits 1669296177Sjhibbits#ifdef FM_PORT_DISABLED_ERRATA_FMANx9 1670296177Sjhibbits /* this errata means that when a port is taken down, other port may not use its 1671296177Sjhibbits * resources for a while as it may still be using it (in case of reject). 1672296177Sjhibbits */ 1673296177Sjhibbits { 1674296177Sjhibbits t_FmRevisionInfo revInfo; 1675296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 1676296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1677296177Sjhibbits XX_UDelay(100000); 1678296177Sjhibbits } 1679296177Sjhibbits#endif /* FM_PORT_DISABLED_ERRATA_FMANx9 */ 1680296177Sjhibbits 1681296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 1682296177Sjhibbits if((p_PortParams->portType != e_FM_PORT_TYPE_RX) && (p_PortParams->portType != e_FM_PORT_TYPE_RX_10G)) 1683296177Sjhibbits /* for transmit & O/H ports */ 1684296177Sjhibbits { 1685296177Sjhibbits uint8_t enqTh; 1686296177Sjhibbits uint8_t deqTh; 1687296177Sjhibbits 1688296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc); 1689296177Sjhibbits /* update qmi ENQ/DEQ threshold */ 1690296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums -= p_PortParams->deqPipelineDepth; 1691296177Sjhibbits 1692296177Sjhibbits /* p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums is now smaller, 1693296177Sjhibbits so we can enlarge enqTh */ 1694296177Sjhibbits enqTh = (uint8_t)(QMI_MAX_NUM_OF_TNUMS - p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums - 1); 1695296177Sjhibbits tmpReg &= ~QMI_CFG_ENQ_MASK; 1696296177Sjhibbits tmpReg |= ((uint32_t)enqTh << QMI_CFG_ENQ_SHIFT); 1697296177Sjhibbits 1698296177Sjhibbits /* p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums is now smaller, 1699296177Sjhibbits so we can reduce deqTh */ 1700296177Sjhibbits deqTh = (uint8_t)(p_Fm->p_FmStateStruct->accumulatedNumOfDeqTnums + 1); 1701296177Sjhibbits tmpReg &= ~QMI_CFG_DEQ_MASK; 1702296177Sjhibbits tmpReg |= (uint32_t)deqTh; 1703296177Sjhibbits 1704296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc, tmpReg); 1705296177Sjhibbits } 1706296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 1707296177Sjhibbits 1708296177Sjhibbits#ifdef FM_LOW_END_RESTRICTION 1709296177Sjhibbits if((hardwarePortId==0x1) || (hardwarePortId==0x29)) 1710296177Sjhibbits p_Fm->p_FmStateStruct->lowEndRestriction = FALSE; 1711296177Sjhibbits#endif /* FM_LOW_END_RESTRICTION */ 1712296177Sjhibbits XX_UnlockSpinlock(p_Fm->h_Spinlock); 1713296177Sjhibbits} 1714296177Sjhibbits 1715296177Sjhibbitst_Error FmIsPortStalled(t_Handle h_Fm, uint8_t hardwarePortId, bool *p_IsStalled) 1716296177Sjhibbits{ 1717296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1718296177Sjhibbits uint32_t tmpReg; 1719296177Sjhibbits t_Error err; 1720296177Sjhibbits t_FmIpcMsg msg; 1721296177Sjhibbits t_FmIpcReply reply; 1722296177Sjhibbits uint32_t replyLength; 1723296177Sjhibbits 1724296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1725296177Sjhibbits { 1726296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1727296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1728296177Sjhibbits msg.msgId = FM_IS_PORT_STALLED; 1729296177Sjhibbits msg.msgBody[0] = hardwarePortId; 1730296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint8_t); 1731296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1732296177Sjhibbits (uint8_t*)&msg, 1733296177Sjhibbits sizeof(msg.msgId)+sizeof(hardwarePortId), 1734296177Sjhibbits (uint8_t*)&reply, 1735296177Sjhibbits &replyLength, 1736296177Sjhibbits NULL, 1737296177Sjhibbits NULL)) != E_OK) 1738296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1739296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(uint8_t))) 1740296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1741296177Sjhibbits 1742296177Sjhibbits *p_IsStalled = (bool)!!(*(uint8_t*)(reply.replyBody)); 1743296177Sjhibbits 1744296177Sjhibbits return (t_Error)(reply.error); 1745296177Sjhibbits } 1746296177Sjhibbits 1747296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmfp_ps[hardwarePortId]); 1748296177Sjhibbits *p_IsStalled = (bool)!!(tmpReg & FPM_PS_STALLED); 1749296177Sjhibbits 1750296177Sjhibbits return E_OK; 1751296177Sjhibbits} 1752296177Sjhibbits 1753296177Sjhibbitst_Error FmResumeStalledPort(t_Handle h_Fm, uint8_t hardwarePortId) 1754296177Sjhibbits{ 1755296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1756296177Sjhibbits uint32_t tmpReg; 1757296177Sjhibbits t_Error err; 1758296177Sjhibbits bool isStalled; 1759296177Sjhibbits t_FmIpcMsg msg; 1760296177Sjhibbits t_FmIpcReply reply; 1761296177Sjhibbits uint32_t replyLength; 1762296177Sjhibbits 1763296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1764296177Sjhibbits { 1765296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1766296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1767296177Sjhibbits msg.msgId = FM_RESUME_STALLED_PORT; 1768296177Sjhibbits msg.msgBody[0] = hardwarePortId; 1769296177Sjhibbits replyLength = sizeof(uint32_t); 1770296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1771296177Sjhibbits (uint8_t*)&msg, 1772296177Sjhibbits sizeof(msg.msgId) + sizeof(hardwarePortId), 1773296177Sjhibbits (uint8_t*)&reply, 1774296177Sjhibbits &replyLength, 1775296177Sjhibbits NULL, 1776296177Sjhibbits NULL)) != E_OK) 1777296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1778296177Sjhibbits if (replyLength != sizeof(uint32_t)) 1779296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1780296177Sjhibbits return (t_Error)(reply.error); 1781296177Sjhibbits } 1782296177Sjhibbits 1783296177Sjhibbits /* Get port status */ 1784296177Sjhibbits err = FmIsPortStalled(h_Fm, hardwarePortId, &isStalled); 1785296177Sjhibbits if(err) 1786296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Can't get port status")); 1787296177Sjhibbits if (!isStalled) 1788296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Port is not stalled")); 1789296177Sjhibbits 1790296177Sjhibbits tmpReg = (uint32_t)((hardwarePortId << FPM_PORT_FM_CTL_PORTID_SHIFT) | FPM_PRC_REALSE_STALLED); 1791296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmpr, tmpReg); 1792296177Sjhibbits 1793296177Sjhibbits return E_OK; 1794296177Sjhibbits} 1795296177Sjhibbits 1796296177Sjhibbitst_Error FmResetMac(t_Handle h_Fm, e_FmMacType type, uint8_t macId) 1797296177Sjhibbits{ 1798296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1799296177Sjhibbits uint32_t bitMask, timeout = 1000; 1800296177Sjhibbits t_FmIpcMacParams macParams; 1801296177Sjhibbits t_Error err; 1802296177Sjhibbits t_FmIpcMsg msg; 1803296177Sjhibbits t_FmIpcReply reply; 1804296177Sjhibbits uint32_t replyLength; 1805296177Sjhibbits 1806296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1807296177Sjhibbits { 1808296177Sjhibbits if(p_Fm->h_IpcSessions[0]) 1809296177Sjhibbits { 1810296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1811296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1812296177Sjhibbits macParams.id = macId; 1813296177Sjhibbits macParams.enumType = (uint32_t)type; 1814296177Sjhibbits msg.msgId = FM_RESET_MAC; 1815296177Sjhibbits memcpy(msg.msgBody, &macParams, sizeof(macParams)); 1816296177Sjhibbits replyLength = sizeof(uint32_t); 1817296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1818296177Sjhibbits (uint8_t*)&msg, 1819296177Sjhibbits sizeof(msg.msgId)+sizeof(macParams), 1820296177Sjhibbits (uint8_t*)&reply, 1821296177Sjhibbits &replyLength, 1822296177Sjhibbits NULL, 1823296177Sjhibbits NULL)) != E_OK) 1824296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1825296177Sjhibbits if (replyLength != sizeof(uint32_t)) 1826296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1827296177Sjhibbits return (t_Error)(reply.error); 1828296177Sjhibbits } 1829296177Sjhibbits else 1830296177Sjhibbits if(!p_Fm->p_FmFpmRegs) 1831296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("No IPC and no registers address")); 1832296177Sjhibbits } 1833296177Sjhibbits 1834296177Sjhibbits /* Get the relevant bit mask */ 1835296177Sjhibbits if (type == e_FM_MAC_10G) 1836296177Sjhibbits { 1837296177Sjhibbits switch(macId) 1838296177Sjhibbits { 1839296177Sjhibbits case(0): 1840296177Sjhibbits bitMask = FPM_RSTC_10G0_RESET; 1841296177Sjhibbits break; 1842296177Sjhibbits default: 1843296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_VALUE, ("Illegal MAC Id")); 1844296177Sjhibbits } 1845296177Sjhibbits } 1846296177Sjhibbits else 1847296177Sjhibbits { 1848296177Sjhibbits switch(macId) 1849296177Sjhibbits { 1850296177Sjhibbits case(0): 1851296177Sjhibbits bitMask = FPM_RSTC_1G0_RESET; 1852296177Sjhibbits break; 1853296177Sjhibbits case(1): 1854296177Sjhibbits bitMask = FPM_RSTC_1G1_RESET; 1855296177Sjhibbits break; 1856296177Sjhibbits case(2): 1857296177Sjhibbits bitMask = FPM_RSTC_1G2_RESET; 1858296177Sjhibbits break; 1859296177Sjhibbits case(3): 1860296177Sjhibbits bitMask = FPM_RSTC_1G3_RESET; 1861296177Sjhibbits break; 1862296177Sjhibbits case(4): 1863296177Sjhibbits bitMask = FPM_RSTC_1G4_RESET; 1864296177Sjhibbits break; 1865296177Sjhibbits default: 1866296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_VALUE, ("Illegal MAC Id")); 1867296177Sjhibbits } 1868296177Sjhibbits } 1869296177Sjhibbits 1870296177Sjhibbits /* reset */ 1871296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrstc, bitMask); 1872296177Sjhibbits while ((GET_UINT32(p_Fm->p_FmFpmRegs->fmrstc) & bitMask) && 1873296177Sjhibbits --timeout) ; 1874296177Sjhibbits if (!timeout) 1875296177Sjhibbits return ERROR_CODE(E_TIMEOUT); 1876296177Sjhibbits return E_OK; 1877296177Sjhibbits} 1878296177Sjhibbits 1879296177Sjhibbitst_Error FmSetMacMaxFrame(t_Handle h_Fm, e_FmMacType type, uint8_t macId, uint16_t mtu) 1880296177Sjhibbits{ 1881296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1882296177Sjhibbits t_FmIpcMacMaxFrameParams macMaxFrameLengthParams; 1883296177Sjhibbits t_Error err; 1884296177Sjhibbits t_FmIpcMsg msg; 1885296177Sjhibbits 1886296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1887296177Sjhibbits { 1888296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1889296177Sjhibbits macMaxFrameLengthParams.macParams.id = macId; 1890296177Sjhibbits macMaxFrameLengthParams.macParams.enumType = (uint32_t)type; 1891296177Sjhibbits macMaxFrameLengthParams.maxFrameLength = (uint16_t)mtu; 1892296177Sjhibbits msg.msgId = FM_SET_MAC_MAX_FRAME; 1893296177Sjhibbits memcpy(msg.msgBody, &macMaxFrameLengthParams, sizeof(macMaxFrameLengthParams)); 1894296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1895296177Sjhibbits (uint8_t*)&msg, 1896296177Sjhibbits sizeof(msg.msgId)+sizeof(macMaxFrameLengthParams), 1897296177Sjhibbits NULL, 1898296177Sjhibbits NULL, 1899296177Sjhibbits NULL, 1900296177Sjhibbits NULL)) != E_OK) 1901296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1902296177Sjhibbits return E_OK; 1903296177Sjhibbits } 1904296177Sjhibbits 1905296177Sjhibbits#if (defined(FM_MAX_NUM_OF_10G_MACS) && (FM_MAX_NUM_OF_10G_MACS)) 1906296177Sjhibbits if (type == e_FM_MAC_10G) 1907296177Sjhibbits p_Fm->p_FmStateStruct->macMaxFrameLengths10G[macId] = mtu; 1908296177Sjhibbits else 1909296177Sjhibbits#else 1910296177Sjhibbits UNUSED(type); 1911296177Sjhibbits#endif /* (defined(FM_MAX_NUM_OF_10G_MACS) && ... */ 1912296177Sjhibbits p_Fm->p_FmStateStruct->macMaxFrameLengths1G[macId] = mtu; 1913296177Sjhibbits 1914296177Sjhibbits return E_OK; 1915296177Sjhibbits} 1916296177Sjhibbits 1917296177Sjhibbitsuint16_t FmGetClockFreq(t_Handle h_Fm) 1918296177Sjhibbits{ 1919296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1920296177Sjhibbits /* for MC environment: this depends on the 1921296177Sjhibbits * fact that fmClkFreq was properly initialized at "init". */ 1922296177Sjhibbits return p_Fm->p_FmStateStruct->fmClkFreq; 1923296177Sjhibbits} 1924296177Sjhibbits 1925296177Sjhibbitsuint32_t FmGetTimeStampScale(t_Handle h_Fm) 1926296177Sjhibbits{ 1927296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1928296177Sjhibbits t_Error err; 1929296177Sjhibbits t_FmIpcMsg msg; 1930296177Sjhibbits t_FmIpcReply reply; 1931296177Sjhibbits uint32_t replyLength, timeStamp; 1932296177Sjhibbits 1933296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 1934296177Sjhibbits { 1935296177Sjhibbits memset(&msg, 0, sizeof(msg)); 1936296177Sjhibbits memset(&reply, 0, sizeof(reply)); 1937296177Sjhibbits msg.msgId = FM_GET_TIMESTAMP_SCALE; 1938296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint32_t); 1939296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 1940296177Sjhibbits (uint8_t*)&msg, 1941296177Sjhibbits sizeof(msg.msgId), 1942296177Sjhibbits (uint8_t*)&reply, 1943296177Sjhibbits &replyLength, 1944296177Sjhibbits NULL, 1945296177Sjhibbits NULL)) != E_OK) 1946296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1947296177Sjhibbits if(replyLength != (sizeof(uint32_t) + sizeof(uint32_t))) 1948296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 1949296177Sjhibbits 1950296177Sjhibbits memcpy((uint8_t*)&timeStamp, reply.replyBody, sizeof(uint32_t)); 1951296177Sjhibbits return timeStamp; 1952296177Sjhibbits } 1953296177Sjhibbits 1954296177Sjhibbits if(!p_Fm->p_FmStateStruct->enabledTimeStamp) 1955296177Sjhibbits FmEnableTimeStamp(p_Fm); 1956296177Sjhibbits 1957296177Sjhibbits return p_Fm->p_FmStateStruct->count1MicroBit; 1958296177Sjhibbits} 1959296177Sjhibbits 1960296177Sjhibbitsbool FmRamsEccIsExternalCtl(t_Handle h_Fm) 1961296177Sjhibbits{ 1962296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1963296177Sjhibbits uint32_t tmpReg; 1964296177Sjhibbits 1965296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmrcr); 1966296177Sjhibbits if(tmpReg & FPM_RAM_CTL_RAMS_ECC_EN_SRC_SEL) 1967296177Sjhibbits return TRUE; 1968296177Sjhibbits else 1969296177Sjhibbits return FALSE; 1970296177Sjhibbits} 1971296177Sjhibbits 1972296177Sjhibbitst_Error FmEnableRamsEcc(t_Handle h_Fm) 1973296177Sjhibbits{ 1974296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1975296177Sjhibbits 1976296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 1977296177Sjhibbits 1978296177Sjhibbits p_Fm->p_FmStateStruct->ramsEccOwners++; 1979296177Sjhibbits p_Fm->p_FmStateStruct->internalCall = TRUE; 1980296177Sjhibbits 1981296177Sjhibbits return FM_EnableRamsEcc(p_Fm); 1982296177Sjhibbits} 1983296177Sjhibbits 1984296177Sjhibbitst_Error FmDisableRamsEcc(t_Handle h_Fm) 1985296177Sjhibbits{ 1986296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 1987296177Sjhibbits 1988296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 1989296177Sjhibbits 1990296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->ramsEccOwners); 1991296177Sjhibbits p_Fm->p_FmStateStruct->ramsEccOwners--; 1992296177Sjhibbits 1993296177Sjhibbits if(p_Fm->p_FmStateStruct->ramsEccOwners==0) 1994296177Sjhibbits { 1995296177Sjhibbits p_Fm->p_FmStateStruct->internalCall = TRUE; 1996296177Sjhibbits return FM_DisableRamsEcc(p_Fm); 1997296177Sjhibbits } 1998296177Sjhibbits return E_OK; 1999296177Sjhibbits} 2000296177Sjhibbits 2001296177Sjhibbitsuint8_t FmGetGuestId(t_Handle h_Fm) 2002296177Sjhibbits{ 2003296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 2004296177Sjhibbits 2005296177Sjhibbits return p_Fm->guestId; 2006296177Sjhibbits} 2007296177Sjhibbits 2008296177Sjhibbitsbool FmIsMaster(t_Handle h_Fm) 2009296177Sjhibbits{ 2010296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 2011296177Sjhibbits 2012296177Sjhibbits return (p_Fm->guestId == NCSW_MASTER_ID); 2013296177Sjhibbits} 2014296177Sjhibbits 2015296177Sjhibbitst_Error FmSetSizeOfFifo(t_Handle h_Fm, 2016296177Sjhibbits uint8_t hardwarePortId, 2017296177Sjhibbits e_FmPortType portType, 2018296177Sjhibbits bool independentMode, 2019296177Sjhibbits uint32_t *p_SizeOfFifo, 2020296177Sjhibbits uint32_t extraSizeOfFifo, 2021296177Sjhibbits uint8_t deqPipelineDepth, 2022296177Sjhibbits t_FmInterModulePortRxPoolsParams *p_RxPoolsParams, 2023296177Sjhibbits bool initialConfig) 2024296177Sjhibbits{ 2025296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 2026296177Sjhibbits uint8_t relativePortId; 2027296177Sjhibbits uint16_t macMaxFrameLength = 0, oldVal; 2028296177Sjhibbits uint32_t minFifoSizeRequired = 0, sizeOfFifo, tmpReg = 0; 2029296177Sjhibbits t_FmIpcPortFifoParams fifoParams; 2030296177Sjhibbits t_Error err; 2031296177Sjhibbits 2032296177Sjhibbits ASSERT_COND(IN_RANGE(1, hardwarePortId, 63)); 2033296177Sjhibbits ASSERT_COND(initialConfig || p_RxPoolsParams); 2034296177Sjhibbits 2035296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 2036296177Sjhibbits { 2037296177Sjhibbits t_FmIpcMsg msg; 2038296177Sjhibbits t_FmIpcReply reply; 2039296177Sjhibbits uint32_t replyLength; 2040296177Sjhibbits 2041296177Sjhibbits ASSERT_COND(p_RxPoolsParams); 2042296177Sjhibbits 2043296177Sjhibbits memset(&fifoParams, 0, sizeof(fifoParams)); 2044296177Sjhibbits fifoParams.rsrcParams.hardwarePortId = hardwarePortId; 2045296177Sjhibbits fifoParams.rsrcParams.val = *p_SizeOfFifo; 2046296177Sjhibbits fifoParams.rsrcParams.extra = extraSizeOfFifo; 2047296177Sjhibbits fifoParams.enumPortType = (uint32_t)portType; 2048296177Sjhibbits fifoParams.boolIndependentMode = (uint8_t)independentMode; 2049296177Sjhibbits fifoParams.deqPipelineDepth = deqPipelineDepth; 2050296177Sjhibbits fifoParams.numOfPools = p_RxPoolsParams->numOfPools; 2051296177Sjhibbits fifoParams.secondLargestBufSize = p_RxPoolsParams->secondLargestBufSize; 2052296177Sjhibbits fifoParams.largestBufSize = p_RxPoolsParams->largestBufSize; 2053296177Sjhibbits fifoParams.boolInitialConfig = (uint8_t)initialConfig; 2054296177Sjhibbits 2055296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2056296177Sjhibbits memset(&reply, 0, sizeof(reply)); 2057296177Sjhibbits msg.msgId = FM_SET_SIZE_OF_FIFO; 2058296177Sjhibbits memcpy(msg.msgBody, &fifoParams, sizeof(fifoParams)); 2059296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint32_t); 2060296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2061296177Sjhibbits (uint8_t*)&msg, 2062296177Sjhibbits sizeof(msg.msgId) + sizeof(fifoParams), 2063296177Sjhibbits (uint8_t*)&reply, 2064296177Sjhibbits &replyLength, 2065296177Sjhibbits NULL, 2066296177Sjhibbits NULL)) != E_OK) 2067296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 2068296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(uint32_t))) 2069296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 2070296177Sjhibbits memcpy((uint8_t*)p_SizeOfFifo, reply.replyBody, sizeof(uint32_t)); 2071296177Sjhibbits 2072296177Sjhibbits return (t_Error)(reply.error); 2073296177Sjhibbits } 2074296177Sjhibbits sizeOfFifo = *p_SizeOfFifo; 2075296177Sjhibbits /* if neseccary (cases where frame length is relevant), update sizeOfFifo field. */ 2076296177Sjhibbits if((portType == e_FM_PORT_TYPE_TX) || ((portType == e_FM_PORT_TYPE_RX) && independentMode)) 2077296177Sjhibbits { 2078296177Sjhibbits HW_PORT_ID_TO_SW_PORT_ID(relativePortId, hardwarePortId); 2079296177Sjhibbits ASSERT_COND(relativePortId < FM_MAX_NUM_OF_1G_MACS); 2080296177Sjhibbits macMaxFrameLength = p_Fm->p_FmStateStruct->macMaxFrameLengths1G[relativePortId]; 2081296177Sjhibbits } 2082296177Sjhibbits 2083296177Sjhibbits#if (defined(FM_MAX_NUM_OF_10G_MACS) && (FM_MAX_NUM_OF_10G_MACS)) 2084296177Sjhibbits if((portType == e_FM_PORT_TYPE_TX_10G) || ((portType == e_FM_PORT_TYPE_RX_10G) && independentMode)) 2085296177Sjhibbits { 2086296177Sjhibbits HW_PORT_ID_TO_SW_PORT_ID(relativePortId, hardwarePortId); 2087296177Sjhibbits ASSERT_COND(relativePortId < FM_MAX_NUM_OF_10G_MACS); 2088296177Sjhibbits macMaxFrameLength = p_Fm->p_FmStateStruct->macMaxFrameLengths10G[relativePortId]; 2089296177Sjhibbits } 2090296177Sjhibbits#endif /* (defined(FM_MAX_NUM_OF_10G_MACS) && ... */ 2091296177Sjhibbits 2092296177Sjhibbits /*************************/ 2093296177Sjhibbits /* TX PORTS */ 2094296177Sjhibbits /*************************/ 2095296177Sjhibbits if((portType == e_FM_PORT_TYPE_TX) || (portType == e_FM_PORT_TYPE_TX_10G)) 2096296177Sjhibbits { 2097296177Sjhibbits if(independentMode) 2098296177Sjhibbits minFifoSizeRequired = (uint32_t)((macMaxFrameLength % BMI_FIFO_UNITS ? 2099296177Sjhibbits (macMaxFrameLength/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS : 2100296177Sjhibbits macMaxFrameLength) + 2101296177Sjhibbits (3*BMI_FIFO_UNITS)); 2102296177Sjhibbits else 2103296177Sjhibbits minFifoSizeRequired = (uint32_t)((macMaxFrameLength % BMI_FIFO_UNITS ? 2104296177Sjhibbits (macMaxFrameLength/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS : 2105296177Sjhibbits macMaxFrameLength) + 2106296177Sjhibbits (deqPipelineDepth+3)*BMI_FIFO_UNITS); 2107296177Sjhibbits } 2108296177Sjhibbits /*************************/ 2109296177Sjhibbits /* RX IM PORTS */ 2110296177Sjhibbits /*************************/ 2111296177Sjhibbits else if(((portType == e_FM_PORT_TYPE_RX) || (portType == e_FM_PORT_TYPE_RX_10G)) && independentMode) 2112296177Sjhibbits minFifoSizeRequired = (uint32_t)(((macMaxFrameLength % BMI_FIFO_UNITS) ? 2113296177Sjhibbits ((macMaxFrameLength/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS) : 2114296177Sjhibbits macMaxFrameLength) + 2115296177Sjhibbits (4*BMI_FIFO_UNITS)); 2116296177Sjhibbits 2117296177Sjhibbits /* for Rx (non-Im) ports or OP, buffer pools are relevant for fifo size. 2118296177Sjhibbits If this routine is called as part of the "GetSet" routine, initialConfig is TRUE 2119296177Sjhibbits and these checks where done in the port routine. 2120296177Sjhibbits If it is called by an explicit user request ("SetSizeOfFifo"), than these parameters 2121296177Sjhibbits should be checked/updated */ 2122296177Sjhibbits if(!initialConfig && 2123296177Sjhibbits ((portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || 2124296177Sjhibbits (((portType == e_FM_PORT_TYPE_RX) || (portType == e_FM_PORT_TYPE_RX_10G)) && !independentMode))) 2125296177Sjhibbits { 2126296177Sjhibbits if((portType == e_FM_PORT_TYPE_RX) || (portType == e_FM_PORT_TYPE_RX_10G)) 2127296177Sjhibbits { 2128296177Sjhibbits /*************************/ 2129296177Sjhibbits /* RX non-IM PORTS */ 2130296177Sjhibbits /*************************/ 2131296177Sjhibbits#ifdef FM_FIFO_ALLOCATION_OLD_ALG 2132296177Sjhibbits t_FmRevisionInfo revInfo; 2133296177Sjhibbits 2134296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 2135296177Sjhibbits if(revInfo.majorRev != 4) 2136296177Sjhibbits minFifoSizeRequired = (uint32_t)(((p_RxPoolsParams->largestBufSize % BMI_FIFO_UNITS) ? 2137296177Sjhibbits ((p_RxPoolsParams->largestBufSize/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS) : 2138296177Sjhibbits p_RxPoolsParams->largestBufSize) + 2139296177Sjhibbits (7*BMI_FIFO_UNITS)); 2140296177Sjhibbits else 2141296177Sjhibbits#endif /* FM_FIFO_ALLOCATION_OLD_ALG */ 2142296177Sjhibbits { 2143296177Sjhibbits if(p_RxPoolsParams->numOfPools == 1) 2144296177Sjhibbits minFifoSizeRequired = 8*BMI_FIFO_UNITS; 2145296177Sjhibbits else 2146296177Sjhibbits { 2147296177Sjhibbits minFifoSizeRequired = (uint32_t)(((p_RxPoolsParams->secondLargestBufSize % BMI_FIFO_UNITS) ? 2148296177Sjhibbits ((p_RxPoolsParams->secondLargestBufSize/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS) : 2149296177Sjhibbits p_RxPoolsParams->secondLargestBufSize) + 2150296177Sjhibbits (7*BMI_FIFO_UNITS)); 2151296177Sjhibbits if((sizeOfFifo < minFifoSizeRequired)) 2152296177Sjhibbits { 2153296177Sjhibbits DBG(WARNING, ("User set FIFO size for Rx port is not optimized. (not modified by driver)")); 2154296177Sjhibbits minFifoSizeRequired = 8*BMI_FIFO_UNITS; 2155296177Sjhibbits } 2156296177Sjhibbits } 2157296177Sjhibbits } 2158296177Sjhibbits } 2159296177Sjhibbits else 2160296177Sjhibbits { 2161296177Sjhibbits /*************************/ 2162296177Sjhibbits /* OP PORTS */ 2163296177Sjhibbits /*************************/ 2164296177Sjhibbits /* check if pool size is not too big */ 2165296177Sjhibbits if(p_RxPoolsParams->largestBufSize > sizeOfFifo ) 2166296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Largest pool size is bigger than ports committed fifo size")); 2167296177Sjhibbits } 2168296177Sjhibbits } 2169296177Sjhibbits 2170296177Sjhibbits 2171296177Sjhibbits if (minFifoSizeRequired && (sizeOfFifo < minFifoSizeRequired)) 2172296177Sjhibbits { 2173296177Sjhibbits sizeOfFifo = minFifoSizeRequired; 2174296177Sjhibbits DBG(WARNING, ("FIFO size enlarged to %d for port %#x", minFifoSizeRequired, hardwarePortId)); 2175296177Sjhibbits } 2176296177Sjhibbits 2177296177Sjhibbits if(initialConfig) 2178296177Sjhibbits oldVal = 0; 2179296177Sjhibbits else 2180296177Sjhibbits { 2181296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1]); 2182296177Sjhibbits /* read into oldVal the current extra fifo size */ 2183296177Sjhibbits oldVal = (uint16_t)((((tmpReg & BMI_EXTRA_FIFO_SIZE_MASK) + 1)*BMI_FIFO_UNITS) >> BMI_EXTRA_FIFO_SIZE_SHIFT); 2184296177Sjhibbits } 2185296177Sjhibbits 2186296177Sjhibbits if(extraSizeOfFifo > oldVal) 2187296177Sjhibbits p_Fm->p_FmStateStruct->extraFifoPoolSize = NCSW_MAX(p_Fm->p_FmStateStruct->extraFifoPoolSize, extraSizeOfFifo); 2188296177Sjhibbits 2189296177Sjhibbits if(!initialConfig) 2190296177Sjhibbits /* read into oldVal the current num of tasks */ 2191296177Sjhibbits oldVal = (uint16_t)(((tmpReg & BMI_FIFO_SIZE_MASK) + 1)*BMI_FIFO_UNITS); 2192296177Sjhibbits 2193296177Sjhibbits /* check that there are enough uncommitted fifo size */ 2194296177Sjhibbits if((p_Fm->p_FmStateStruct->accumulatedFifoSize - oldVal + sizeOfFifo) > 2195296177Sjhibbits (p_Fm->p_FmStateStruct->totalFifoSize - p_Fm->p_FmStateStruct->extraFifoPoolSize)) 2196296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("Requested fifo size and extra size exceed total FIFO size.")); 2197296177Sjhibbits else 2198296177Sjhibbits { 2199296177Sjhibbits /* update acummulated */ 2200296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedFifoSize >= oldVal); 2201296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedFifoSize -= oldVal; 2202296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedFifoSize += sizeOfFifo; 2203296177Sjhibbits /* calculate reg */ 2204296177Sjhibbits tmpReg = (uint32_t)((sizeOfFifo/BMI_FIFO_UNITS - 1) | 2205296177Sjhibbits ((extraSizeOfFifo/BMI_FIFO_UNITS) << BMI_EXTRA_FIFO_SIZE_SHIFT)); 2206296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1], tmpReg); 2207296177Sjhibbits } 2208296177Sjhibbits *p_SizeOfFifo = sizeOfFifo; 2209296177Sjhibbits 2210296177Sjhibbits return E_OK; 2211296177Sjhibbits} 2212296177Sjhibbits 2213296177Sjhibbitst_Error FmSetNumOfTasks(t_Handle h_Fm, 2214296177Sjhibbits uint8_t hardwarePortId, 2215296177Sjhibbits uint8_t numOfTasks, 2216296177Sjhibbits uint8_t numOfExtraTasks, 2217296177Sjhibbits bool initialConfig) 2218296177Sjhibbits{ 2219296177Sjhibbits t_Fm *p_Fm = (t_Fm *)h_Fm; 2220296177Sjhibbits uint8_t oldVal; 2221296177Sjhibbits uint32_t tmpReg = 0; 2222296177Sjhibbits t_FmIpcPortRsrcParams rsrcParams; 2223296177Sjhibbits t_Error err; 2224296177Sjhibbits 2225296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 2226296177Sjhibbits { 2227296177Sjhibbits t_FmIpcMsg msg; 2228296177Sjhibbits t_FmIpcReply reply; 2229296177Sjhibbits uint32_t replyLength; 2230296177Sjhibbits 2231296177Sjhibbits rsrcParams.hardwarePortId = hardwarePortId; 2232296177Sjhibbits rsrcParams.val = numOfTasks; 2233296177Sjhibbits rsrcParams.extra = numOfExtraTasks; 2234296177Sjhibbits rsrcParams.boolInitialConfig = (uint8_t)initialConfig; 2235296177Sjhibbits 2236296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2237296177Sjhibbits memset(&reply, 0, sizeof(reply)); 2238296177Sjhibbits msg.msgId = FM_SET_NUM_OF_TASKS; 2239296177Sjhibbits memcpy(msg.msgBody, &rsrcParams, sizeof(rsrcParams)); 2240296177Sjhibbits replyLength = sizeof(uint32_t); 2241296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2242296177Sjhibbits (uint8_t*)&msg, 2243296177Sjhibbits sizeof(msg.msgId) + sizeof(rsrcParams), 2244296177Sjhibbits (uint8_t*)&reply, 2245296177Sjhibbits &replyLength, 2246296177Sjhibbits NULL, 2247296177Sjhibbits NULL)) != E_OK) 2248296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 2249296177Sjhibbits if (replyLength != sizeof(uint32_t)) 2250296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 2251296177Sjhibbits return (t_Error)(reply.error); 2252296177Sjhibbits } 2253296177Sjhibbits 2254296177Sjhibbits ASSERT_COND(IN_RANGE(1, hardwarePortId, 63)); 2255296177Sjhibbits 2256296177Sjhibbits if(initialConfig) 2257296177Sjhibbits oldVal = 0; 2258296177Sjhibbits else 2259296177Sjhibbits { 2260296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1]); 2261296177Sjhibbits /* read into oldVal the current extra tasks */ 2262296177Sjhibbits oldVal = (uint8_t)((tmpReg & BMI_NUM_OF_EXTRA_TASKS_MASK) >> BMI_EXTRA_NUM_OF_TASKS_SHIFT); 2263296177Sjhibbits } 2264296177Sjhibbits 2265296177Sjhibbits if(numOfExtraTasks > oldVal) 2266296177Sjhibbits p_Fm->p_FmStateStruct->extraTasksPoolSize = (uint8_t)NCSW_MAX(p_Fm->p_FmStateStruct->extraTasksPoolSize, numOfExtraTasks); 2267296177Sjhibbits 2268296177Sjhibbits if(!initialConfig) 2269296177Sjhibbits /* read into oldVal the current num of tasks */ 2270296177Sjhibbits oldVal = (uint8_t)(((tmpReg & BMI_NUM_OF_TASKS_MASK) >> BMI_NUM_OF_TASKS_SHIFT) + 1); 2271296177Sjhibbits 2272296177Sjhibbits /* check that there are enough uncommitted tasks */ 2273296177Sjhibbits if((p_Fm->p_FmStateStruct->accumulatedNumOfTasks - oldVal + numOfTasks) > 2274296177Sjhibbits (p_Fm->p_FmStateStruct->totalNumOfTasks - p_Fm->p_FmStateStruct->extraTasksPoolSize)) 2275296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, 2276296177Sjhibbits ("Requested numOfTasks and extra tasks pool for fm%d exceed total numOfTasks.", 2277296177Sjhibbits p_Fm->p_FmStateStruct->fmId)); 2278296177Sjhibbits else 2279296177Sjhibbits { 2280296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedNumOfTasks >= oldVal); 2281296177Sjhibbits /* update acummulated */ 2282296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfTasks -= oldVal; 2283296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfTasks += numOfTasks; 2284296177Sjhibbits /* calculate reg */ 2285296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1]) & ~(BMI_NUM_OF_TASKS_MASK | BMI_NUM_OF_EXTRA_TASKS_MASK); 2286296177Sjhibbits tmpReg |= (uint32_t)(((numOfTasks-1) << BMI_NUM_OF_TASKS_SHIFT) | 2287296177Sjhibbits (numOfExtraTasks << BMI_EXTRA_NUM_OF_TASKS_SHIFT)); 2288296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1],tmpReg); 2289296177Sjhibbits } 2290296177Sjhibbits 2291296177Sjhibbits return E_OK; 2292296177Sjhibbits} 2293296177Sjhibbits 2294296177Sjhibbitst_Error FmSetNumOfOpenDmas(t_Handle h_Fm, 2295296177Sjhibbits uint8_t hardwarePortId, 2296296177Sjhibbits uint8_t numOfOpenDmas, 2297296177Sjhibbits uint8_t numOfExtraOpenDmas, 2298296177Sjhibbits bool initialConfig) 2299296177Sjhibbits 2300296177Sjhibbits{ 2301296177Sjhibbits t_Fm *p_Fm = (t_Fm *)h_Fm; 2302296177Sjhibbits uint8_t oldVal; 2303296177Sjhibbits uint32_t tmpReg = 0; 2304296177Sjhibbits t_FmIpcPortRsrcParams rsrcParams; 2305296177Sjhibbits t_Error err; 2306296177Sjhibbits 2307296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 2308296177Sjhibbits { 2309296177Sjhibbits t_FmIpcMsg msg; 2310296177Sjhibbits t_FmIpcReply reply; 2311296177Sjhibbits uint32_t replyLength; 2312296177Sjhibbits 2313296177Sjhibbits rsrcParams.hardwarePortId = hardwarePortId; 2314296177Sjhibbits rsrcParams.val = numOfOpenDmas; 2315296177Sjhibbits rsrcParams.extra = numOfExtraOpenDmas; 2316296177Sjhibbits rsrcParams.boolInitialConfig = (uint8_t)initialConfig; 2317296177Sjhibbits 2318296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2319296177Sjhibbits memset(&reply, 0, sizeof(reply)); 2320296177Sjhibbits msg.msgId = FM_SET_NUM_OF_OPEN_DMAS; 2321296177Sjhibbits memcpy(msg.msgBody, &rsrcParams, sizeof(rsrcParams)); 2322296177Sjhibbits replyLength = sizeof(uint32_t); 2323296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2324296177Sjhibbits (uint8_t*)&msg, 2325296177Sjhibbits sizeof(msg.msgId) + sizeof(rsrcParams), 2326296177Sjhibbits (uint8_t*)&reply, 2327296177Sjhibbits &replyLength, 2328296177Sjhibbits NULL, 2329296177Sjhibbits NULL)) != E_OK) 2330296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 2331296177Sjhibbits if (replyLength != sizeof(uint32_t)) 2332296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 2333296177Sjhibbits return (t_Error)(reply.error); 2334296177Sjhibbits } 2335296177Sjhibbits 2336296177Sjhibbits ASSERT_COND(IN_RANGE(1, hardwarePortId, 63)); 2337296177Sjhibbits 2338296177Sjhibbits if(initialConfig) 2339296177Sjhibbits oldVal = 0; 2340296177Sjhibbits else 2341296177Sjhibbits { 2342296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1]); 2343296177Sjhibbits /* read into oldVal the current extra tasks */ 2344296177Sjhibbits oldVal = (uint8_t)((tmpReg & BMI_NUM_OF_EXTRA_DMAS_MASK) >> BMI_EXTRA_NUM_OF_DMAS_SHIFT); 2345296177Sjhibbits } 2346296177Sjhibbits 2347296177Sjhibbits if(numOfExtraOpenDmas > oldVal) 2348296177Sjhibbits p_Fm->p_FmStateStruct->extraOpenDmasPoolSize = (uint8_t)NCSW_MAX(p_Fm->p_FmStateStruct->extraOpenDmasPoolSize, numOfExtraOpenDmas); 2349296177Sjhibbits 2350296177Sjhibbits if(!initialConfig) 2351296177Sjhibbits /* read into oldVal the current num of tasks */ 2352296177Sjhibbits oldVal = (uint8_t)(((tmpReg & BMI_NUM_OF_DMAS_MASK) >> BMI_NUM_OF_DMAS_SHIFT) + 1); 2353296177Sjhibbits 2354296177Sjhibbits /* check that there are enough uncommitted open DMA's */ 2355296177Sjhibbits ASSERT_COND(p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas >= oldVal); 2356296177Sjhibbits if((p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas - oldVal + numOfOpenDmas) > 2357296177Sjhibbits p_Fm->p_FmStateStruct->maxNumOfOpenDmas) 2358296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, 2359296177Sjhibbits ("Requested numOfOpenDmas for fm%d exceeds total numOfOpenDmas.", 2360296177Sjhibbits p_Fm->p_FmStateStruct->fmId)); 2361296177Sjhibbits else 2362296177Sjhibbits { 2363296177Sjhibbits /* update acummulated */ 2364296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas -= oldVal; 2365296177Sjhibbits p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas += numOfOpenDmas; 2366296177Sjhibbits /* calculate reg */ 2367296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1]) & ~(BMI_NUM_OF_DMAS_MASK | BMI_NUM_OF_EXTRA_DMAS_MASK); 2368296177Sjhibbits tmpReg |= (uint32_t)(((numOfOpenDmas-1) << BMI_NUM_OF_DMAS_SHIFT) | 2369296177Sjhibbits (numOfExtraOpenDmas << BMI_EXTRA_NUM_OF_DMAS_SHIFT)); 2370296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1], tmpReg); 2371296177Sjhibbits 2372296177Sjhibbits /* update total num of DMA's with committed number of open DMAS, and max uncommitted pool. */ 2373296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2) & ~BMI_CFG2_DMAS_MASK; 2374296177Sjhibbits tmpReg |= (uint32_t)(p_Fm->p_FmStateStruct->accumulatedNumOfOpenDmas + p_Fm->p_FmStateStruct->extraOpenDmasPoolSize - 1) << BMI_CFG2_DMAS_SHIFT; 2375296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2, tmpReg); 2376296177Sjhibbits } 2377296177Sjhibbits 2378296177Sjhibbits return E_OK; 2379296177Sjhibbits} 2380296177Sjhibbits 2381296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 2382296177Sjhibbitst_Error FmDumpPortRegs (t_Handle h_Fm,uint8_t hardwarePortId) 2383296177Sjhibbits{ 2384296177Sjhibbits t_Fm *p_Fm = (t_Fm *)h_Fm; 2385296177Sjhibbits t_FmIpcMsg msg; 2386296177Sjhibbits t_Error err; 2387296177Sjhibbits 2388296177Sjhibbits DECLARE_DUMP; 2389296177Sjhibbits 2390296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 2391296177Sjhibbits { 2392296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2393296177Sjhibbits msg.msgId = FM_DUMP_PORT_REGS; 2394296177Sjhibbits msg.msgBody[0] = hardwarePortId; 2395296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2396296177Sjhibbits (uint8_t*)&msg, 2397296177Sjhibbits sizeof(msg.msgId)+sizeof(hardwarePortId), 2398296177Sjhibbits NULL, 2399296177Sjhibbits NULL, 2400296177Sjhibbits NULL, 2401296177Sjhibbits NULL)) != E_OK) 2402296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 2403296177Sjhibbits return E_OK; 2404296177Sjhibbits } 2405296177Sjhibbits 2406296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 2407296177Sjhibbits 2408296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1], ("fmbm_pp for port %u", (hardwarePortId))); 2409296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmBmiRegs->fmbm_pp[hardwarePortId-1], sizeof(uint32_t)); 2410296177Sjhibbits 2411296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1], ("fmbm_pfs for port %u", (hardwarePortId ))); 2412296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmBmiRegs->fmbm_pfs[hardwarePortId-1], sizeof(uint32_t)); 2413296177Sjhibbits 2414296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmBmiRegs->fmbm_ppid[hardwarePortId-1], ("bm_ppid for port %u", (hardwarePortId))); 2415296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmBmiRegs->fmbm_ppid[hardwarePortId-1], sizeof(uint32_t)); 2416296177Sjhibbits 2417296177Sjhibbits return E_OK; 2418296177Sjhibbits} 2419296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) */ 2420296177Sjhibbits 2421296177Sjhibbits 2422296177Sjhibbits/*****************************************************************************/ 2423296177Sjhibbits/* API Init unit functions */ 2424296177Sjhibbits/*****************************************************************************/ 2425296177Sjhibbitst_Handle FM_Config(t_FmParams *p_FmParam) 2426296177Sjhibbits{ 2427296177Sjhibbits t_Fm *p_Fm; 2428296177Sjhibbits uint8_t i; 2429296177Sjhibbits uintptr_t baseAddr; 2430296177Sjhibbits 2431296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmParam, E_NULL_POINTER, NULL); 2432296177Sjhibbits SANITY_CHECK_RETURN_VALUE(((p_FmParam->firmware.p_Code && p_FmParam->firmware.size) || 2433296177Sjhibbits (!p_FmParam->firmware.p_Code && !p_FmParam->firmware.size)), 2434296177Sjhibbits E_INVALID_VALUE, NULL); 2435296177Sjhibbits 2436296177Sjhibbits baseAddr = p_FmParam->baseAddr; 2437296177Sjhibbits 2438296177Sjhibbits /* Allocate FM structure */ 2439296177Sjhibbits p_Fm = (t_Fm *) XX_Malloc(sizeof(t_Fm)); 2440296177Sjhibbits if (!p_Fm) 2441296177Sjhibbits { 2442296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM driver structure")); 2443296177Sjhibbits return NULL; 2444296177Sjhibbits } 2445296177Sjhibbits memset(p_Fm, 0, sizeof(t_Fm)); 2446296177Sjhibbits 2447296177Sjhibbits p_Fm->p_FmStateStruct = (t_FmStateStruct *) XX_Malloc(sizeof(t_FmStateStruct)); 2448296177Sjhibbits if (!p_Fm->p_FmStateStruct) 2449296177Sjhibbits { 2450296177Sjhibbits XX_Free(p_Fm); 2451296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Status structure")); 2452296177Sjhibbits return NULL; 2453296177Sjhibbits } 2454296177Sjhibbits memset(p_Fm->p_FmStateStruct, 0, sizeof(t_FmStateStruct)); 2455296177Sjhibbits 2456296177Sjhibbits /* Initialize FM parameters which will be kept by the driver */ 2457296177Sjhibbits p_Fm->p_FmStateStruct->fmId = p_FmParam->fmId; 2458296177Sjhibbits p_Fm->guestId = p_FmParam->guestId; 2459296177Sjhibbits 2460296177Sjhibbits for(i=0; i<FM_MAX_NUM_OF_HW_PORT_IDS; i++) 2461296177Sjhibbits p_Fm->p_FmStateStruct->portsTypes[i] = e_FM_PORT_TYPE_DUMMY; 2462296177Sjhibbits 2463296177Sjhibbits /* Allocate the FM driver's parameters structure */ 2464296177Sjhibbits p_Fm->p_FmDriverParam = (t_FmDriverParam *)XX_Malloc(sizeof(t_FmDriverParam)); 2465296177Sjhibbits if (!p_Fm->p_FmDriverParam) 2466296177Sjhibbits { 2467296177Sjhibbits XX_Free(p_Fm->p_FmStateStruct); 2468296177Sjhibbits XX_Free(p_Fm); 2469296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM driver parameters")); 2470296177Sjhibbits return NULL; 2471296177Sjhibbits } 2472296177Sjhibbits memset(p_Fm->p_FmDriverParam, 0, sizeof(t_FmDriverParam)); 2473296177Sjhibbits 2474296177Sjhibbits /* Initialize FM parameters which will be kept by the driver */ 2475296177Sjhibbits p_Fm->p_FmStateStruct->fmId = p_FmParam->fmId; 2476296177Sjhibbits p_Fm->h_FmMuram = p_FmParam->h_FmMuram; 2477296177Sjhibbits p_Fm->h_App = p_FmParam->h_App; 2478296177Sjhibbits p_Fm->p_FmStateStruct->fmClkFreq = p_FmParam->fmClkFreq; 2479296177Sjhibbits p_Fm->f_Exception = p_FmParam->f_Exception; 2480296177Sjhibbits p_Fm->f_BusError = p_FmParam->f_BusError; 2481296177Sjhibbits p_Fm->p_FmFpmRegs = (t_FmFpmRegs *)UINT_TO_PTR(baseAddr + FM_MM_FPM); 2482296177Sjhibbits p_Fm->p_FmBmiRegs = (t_FmBmiRegs *)UINT_TO_PTR(baseAddr + FM_MM_BMI); 2483296177Sjhibbits p_Fm->p_FmQmiRegs = (t_FmQmiRegs *)UINT_TO_PTR(baseAddr + FM_MM_QMI); 2484296177Sjhibbits p_Fm->p_FmDmaRegs = (t_FmDmaRegs *)UINT_TO_PTR(baseAddr + FM_MM_DMA); 2485296177Sjhibbits p_Fm->baseAddr = baseAddr; 2486296177Sjhibbits p_Fm->p_FmStateStruct->irq = p_FmParam->irq; 2487296177Sjhibbits p_Fm->p_FmStateStruct->errIrq = p_FmParam->errIrq; 2488296177Sjhibbits p_Fm->hcPortInitialized = FALSE; 2489296177Sjhibbits p_Fm->independentMode = FALSE; 2490296177Sjhibbits p_Fm->p_FmStateStruct->ramsEccEnable = FALSE; 2491296177Sjhibbits p_Fm->p_FmStateStruct->totalNumOfTasks = DEFAULT_totalNumOfTasks; 2492296177Sjhibbits p_Fm->p_FmStateStruct->totalFifoSize = DEFAULT_totalFifoSize; 2493296177Sjhibbits p_Fm->p_FmStateStruct->maxNumOfOpenDmas = DEFAULT_maxNumOfOpenDmas; 2494296177Sjhibbits p_Fm->p_FmStateStruct->extraFifoPoolSize = FM_MAX_NUM_OF_RX_PORTS*BMI_FIFO_UNITS; 2495296177Sjhibbits p_Fm->p_FmStateStruct->exceptions = DEFAULT_exceptions; 2496296177Sjhibbits for(i = 0;i<FM_MAX_NUM_OF_1G_MACS;i++) 2497296177Sjhibbits p_Fm->p_FmStateStruct->macMaxFrameLengths1G[i] = DEFAULT_mtu; 2498296177Sjhibbits#if defined(FM_MAX_NUM_OF_10G_MACS) && (FM_MAX_NUM_OF_10G_MACS) 2499296177Sjhibbits for(i = 0;i<FM_MAX_NUM_OF_10G_MACS;i++) 2500296177Sjhibbits p_Fm->p_FmStateStruct->macMaxFrameLengths10G[i] = DEFAULT_mtu; 2501296177Sjhibbits#endif /*defined(FM_MAX_NUM_OF_10G_MACS) && (FM_MAX_NUM_OF_10G_MACS)*/ 2502296177Sjhibbits 2503296177Sjhibbits p_Fm->h_Spinlock = XX_InitSpinlock(); 2504296177Sjhibbits if (!p_Fm->h_Spinlock) 2505296177Sjhibbits { 2506296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam); 2507296177Sjhibbits XX_Free(p_Fm->p_FmStateStruct); 2508296177Sjhibbits XX_Free(p_Fm); 2509296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("cant allocate spinlock!")); 2510296177Sjhibbits return NULL; 2511296177Sjhibbits } 2512296177Sjhibbits 2513296177Sjhibbits#ifdef FM_PARTITION_ARRAY 2514296177Sjhibbits /* Initialize FM driver parameters parameters (for initialization phase only) */ 2515296177Sjhibbits memcpy(p_Fm->p_FmDriverParam->liodnBasePerPort, p_FmParam->liodnBasePerPort, FM_SIZE_OF_LIODN_TABLE*sizeof(uint16_t)); 2516296177Sjhibbits#endif /* FM_PARTITION_ARRAY */ 2517296177Sjhibbits 2518296177Sjhibbits /*p_Fm->p_FmDriverParam->numOfPartitions = p_FmParam->numOfPartitions; */ 2519296177Sjhibbits p_Fm->p_FmDriverParam->enCounters = FALSE; 2520296177Sjhibbits 2521296177Sjhibbits p_Fm->p_FmDriverParam->resetOnInit = DEFAULT_resetOnInit; 2522296177Sjhibbits 2523296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.dispLimit = DEFAULT_dispLimit; 2524296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.prsDispTh = DEFAULT_prsDispTh; 2525296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.plcrDispTh = DEFAULT_plcrDispTh; 2526296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.kgDispTh = DEFAULT_kgDispTh; 2527296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.bmiDispTh = DEFAULT_bmiDispTh; 2528296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.qmiEnqDispTh = DEFAULT_qmiEnqDispTh; 2529296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.qmiDeqDispTh = DEFAULT_qmiDeqDispTh; 2530296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.fmCtl1DispTh = DEFAULT_fmCtl1DispTh; 2531296177Sjhibbits p_Fm->p_FmDriverParam->thresholds.fmCtl2DispTh = DEFAULT_fmCtl2DispTh; 2532296177Sjhibbits 2533296177Sjhibbits p_Fm->p_FmDriverParam->dmaStopOnBusError = DEFAULT_dmaStopOnBusError; 2534296177Sjhibbits 2535296177Sjhibbits p_Fm->p_FmDriverParam->dmaCacheOverride = DEFAULT_cacheOverride; 2536296177Sjhibbits p_Fm->p_FmDriverParam->dmaAidMode = DEFAULT_aidMode; 2537296177Sjhibbits p_Fm->p_FmDriverParam->dmaAidOverride = DEFAULT_aidOverride; 2538296177Sjhibbits p_Fm->p_FmDriverParam->dmaAxiDbgNumOfBeats = DEFAULT_axiDbgNumOfBeats; 2539296177Sjhibbits p_Fm->p_FmDriverParam->dmaCamNumOfEntries = DEFAULT_dmaCamNumOfEntries; 2540296177Sjhibbits p_Fm->p_FmDriverParam->dmaWatchdog = DEFAULT_dmaWatchdog; 2541296177Sjhibbits 2542296177Sjhibbits p_Fm->p_FmDriverParam->dmaCommQThresholds.clearEmergency = DEFAULT_dmaCommQLow; 2543296177Sjhibbits p_Fm->p_FmDriverParam->dmaCommQThresholds.assertEmergency = DEFAULT_dmaCommQHigh; 2544296177Sjhibbits p_Fm->p_FmDriverParam->dmaReadBufThresholds.clearEmergency = DEFAULT_dmaReadIntBufLow; 2545296177Sjhibbits p_Fm->p_FmDriverParam->dmaReadBufThresholds.assertEmergency = DEFAULT_dmaReadIntBufHigh; 2546296177Sjhibbits p_Fm->p_FmDriverParam->dmaWriteBufThresholds.clearEmergency = DEFAULT_dmaWriteIntBufLow; 2547296177Sjhibbits p_Fm->p_FmDriverParam->dmaWriteBufThresholds.assertEmergency = DEFAULT_dmaWriteIntBufHigh; 2548296177Sjhibbits p_Fm->p_FmDriverParam->dmaSosEmergency = DEFAULT_dmaSosEmergency; 2549296177Sjhibbits 2550296177Sjhibbits p_Fm->p_FmDriverParam->dmaDbgCntMode = DEFAULT_dmaDbgCntMode; 2551296177Sjhibbits 2552296177Sjhibbits p_Fm->p_FmDriverParam->dmaEnEmergency = FALSE; 2553296177Sjhibbits p_Fm->p_FmDriverParam->dmaEnEmergencySmoother = FALSE; 2554296177Sjhibbits p_Fm->p_FmDriverParam->catastrophicErr = DEFAULT_catastrophicErr; 2555296177Sjhibbits p_Fm->p_FmDriverParam->dmaErr = DEFAULT_dmaErr; 2556296177Sjhibbits p_Fm->p_FmDriverParam->haltOnExternalActivation = DEFAULT_haltOnExternalActivation; 2557296177Sjhibbits p_Fm->p_FmDriverParam->haltOnUnrecoverableEccError = DEFAULT_haltOnUnrecoverableEccError; 2558296177Sjhibbits p_Fm->p_FmDriverParam->enIramTestMode = FALSE; 2559296177Sjhibbits p_Fm->p_FmDriverParam->enMuramTestMode = FALSE; 2560296177Sjhibbits p_Fm->p_FmDriverParam->externalEccRamsEnable = DEFAULT_externalEccRamsEnable; 2561296177Sjhibbits 2562296177Sjhibbits p_Fm->p_FmDriverParam->fwVerify = DEFAULT_VerifyUcode; 2563296177Sjhibbits p_Fm->p_FmDriverParam->firmware.size = p_FmParam->firmware.size; 2564296177Sjhibbits if (p_Fm->p_FmDriverParam->firmware.size) 2565296177Sjhibbits { 2566296177Sjhibbits p_Fm->p_FmDriverParam->firmware.p_Code = (uint32_t *)XX_Malloc(p_Fm->p_FmDriverParam->firmware.size); 2567296177Sjhibbits if (!p_Fm->p_FmDriverParam->firmware.p_Code) 2568296177Sjhibbits { 2569296177Sjhibbits XX_FreeSpinlock(p_Fm->h_Spinlock); 2570296177Sjhibbits XX_Free(p_Fm->p_FmStateStruct); 2571296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam); 2572296177Sjhibbits XX_Free(p_Fm); 2573296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM firmware code")); 2574296177Sjhibbits return NULL; 2575296177Sjhibbits } 2576296177Sjhibbits memcpy(p_Fm->p_FmDriverParam->firmware.p_Code, p_FmParam->firmware.p_Code, p_Fm->p_FmDriverParam->firmware.size); 2577296177Sjhibbits } 2578296177Sjhibbits 2579296177Sjhibbits return p_Fm; 2580296177Sjhibbits} 2581296177Sjhibbits 2582296177Sjhibbits/**************************************************************************//** 2583296177Sjhibbits @Function FM_Init 2584296177Sjhibbits 2585296177Sjhibbits @Description Initializes the FM module 2586296177Sjhibbits 2587296177Sjhibbits @Param[in] h_Fm - FM module descriptor 2588296177Sjhibbits 2589296177Sjhibbits @Return E_OK on success; Error code otherwise. 2590296177Sjhibbits*//***************************************************************************/ 2591296177Sjhibbitst_Error FM_Init(t_Handle h_Fm) 2592296177Sjhibbits{ 2593296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 2594296177Sjhibbits t_FmDriverParam *p_FmDriverParam = NULL; 2595296177Sjhibbits t_Error err = E_OK; 2596296177Sjhibbits uint32_t tmpReg, cfgReg = 0; 2597296177Sjhibbits int i; 2598296177Sjhibbits uint16_t periodInFmClocks; 2599296177Sjhibbits uint8_t remainder; 2600296177Sjhibbits t_FmRevisionInfo revInfo; 2601296177Sjhibbits 2602296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_Fm, E_INVALID_HANDLE); 2603296177Sjhibbits 2604296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 2605296177Sjhibbits { 2606296177Sjhibbits uint8_t isMasterAlive; 2607296177Sjhibbits t_FmIpcMsg msg; 2608296177Sjhibbits t_FmIpcReply reply; 2609296177Sjhibbits uint32_t replyLength; 2610296177Sjhibbits 2611296177Sjhibbits /* build the FM guest partition IPC address */ 2612296177Sjhibbits if(Sprint (p_Fm->fmModuleName, "FM_%d_%d",p_Fm->p_FmStateStruct->fmId, p_Fm->guestId) != (p_Fm->guestId<10 ? 6:7)) 2613296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 2614296177Sjhibbits 2615296177Sjhibbits /* build the FM master partition IPC address */ 2616296177Sjhibbits memset(p_Fm->fmIpcHandlerModuleName, 0, (sizeof(char)) * MODULE_NAME_SIZE); 2617296177Sjhibbits if(Sprint (p_Fm->fmIpcHandlerModuleName[0], "FM_%d_%d",p_Fm->p_FmStateStruct->fmId, NCSW_MASTER_ID) != 6) 2618296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 2619296177Sjhibbits 2620296177Sjhibbits for(i=0;i<e_FM_EV_DUMMY_LAST;i++) 2621296177Sjhibbits p_Fm->intrMng[i].f_Isr = UnimplementedIsr; 2622296177Sjhibbits 2623296177Sjhibbits p_Fm->h_IpcSessions[0] = XX_IpcInitSession(p_Fm->fmIpcHandlerModuleName[0], p_Fm->fmModuleName); 2624296177Sjhibbits if (p_Fm->h_IpcSessions[0]) 2625296177Sjhibbits { 2626296177Sjhibbits err = XX_IpcRegisterMsgHandler(p_Fm->fmModuleName, FmGuestHandleIpcMsgCB, p_Fm, FM_IPC_MAX_REPLY_SIZE); 2627296177Sjhibbits if(err) 2628296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2629296177Sjhibbits 2630296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2631296177Sjhibbits memset(&reply, 0, sizeof(reply)); 2632296177Sjhibbits msg.msgId = FM_MASTER_IS_ALIVE; 2633296177Sjhibbits msg.msgBody[0] = p_Fm->guestId; 2634296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint8_t); 2635296177Sjhibbits do 2636296177Sjhibbits { 2637296177Sjhibbits blockingFlag = TRUE; 2638296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2639296177Sjhibbits (uint8_t*)&msg, 2640296177Sjhibbits sizeof(msg.msgId)+sizeof(p_Fm->guestId), 2641296177Sjhibbits (uint8_t*)&reply, 2642296177Sjhibbits &replyLength, 2643296177Sjhibbits IpcMsgCompletionCB, 2644296177Sjhibbits h_Fm)) != E_OK) 2645296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 2646296177Sjhibbits while(blockingFlag) ; 2647296177Sjhibbits if(replyLength != (sizeof(uint32_t) + sizeof(uint8_t))) 2648296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 2649296177Sjhibbits isMasterAlive = *(uint8_t*)(reply.replyBody); 2650296177Sjhibbits } while (!isMasterAlive); 2651296177Sjhibbits 2652296177Sjhibbits memset(&msg, 0, sizeof(msg)); 2653296177Sjhibbits memset(&reply, 0, sizeof(reply)); 2654296177Sjhibbits msg.msgId = FM_GET_CLK_FREQ; 2655296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(p_Fm->p_FmStateStruct->fmClkFreq); 2656296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 2657296177Sjhibbits (uint8_t*)&msg, 2658296177Sjhibbits sizeof(msg.msgId), 2659296177Sjhibbits (uint8_t*)&reply, 2660296177Sjhibbits &replyLength, 2661296177Sjhibbits NULL, 2662296177Sjhibbits NULL)) != E_OK) 2663296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2664296177Sjhibbits if(replyLength != (sizeof(uint32_t) + sizeof(p_Fm->p_FmStateStruct->fmClkFreq))) 2665296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 2666296177Sjhibbits memcpy((uint8_t*)&p_Fm->p_FmStateStruct->fmClkFreq, reply.replyBody, sizeof(uint16_t)); 2667296177Sjhibbits } 2668296177Sjhibbits else 2669296177Sjhibbits { 2670296177Sjhibbits DBG(WARNING, ("FM Guest mode - without IPC")); 2671296177Sjhibbits if(!p_Fm->p_FmStateStruct->fmClkFreq ) 2672296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("No fmClkFreq configured for guest without IPC")); 2673296177Sjhibbits if(!p_Fm->baseAddr) 2674296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("No baseAddr configured for guest without IPC")); 2675296177Sjhibbits } 2676296177Sjhibbits 2677296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam); 2678296177Sjhibbits p_Fm->p_FmDriverParam = NULL; 2679296177Sjhibbits 2680296177Sjhibbits if ((p_Fm->guestId == NCSW_MASTER_ID) || 2681296177Sjhibbits (p_Fm->h_IpcSessions[0])) 2682296177Sjhibbits { 2683296177Sjhibbits FM_DisableRamsEcc(p_Fm); 2684296177Sjhibbits FmMuramClear(p_Fm->h_FmMuram); 2685296177Sjhibbits FM_EnableRamsEcc(p_Fm); 2686296177Sjhibbits } 2687296177Sjhibbits 2688296177Sjhibbits return E_OK; 2689296177Sjhibbits } 2690296177Sjhibbits 2691296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 2692296177Sjhibbits 2693296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 2694296177Sjhibbits 2695296177Sjhibbits#ifdef FM_NO_DISPATCH_RAM_ECC 2696296177Sjhibbits if (revInfo.majorRev != 4) 2697296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~FM_EX_BMI_DISPATCH_RAM_ECC; 2698296177Sjhibbits#endif /* FM_NO_DISPATCH_RAM_ECC */ 2699296177Sjhibbits 2700296177Sjhibbits#ifdef FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 2701296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2702296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~FM_EX_BMI_LIST_RAM_ECC; 2703296177Sjhibbits#endif /* FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 */ 2704296177Sjhibbits 2705296177Sjhibbits#ifdef FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 2706296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2707296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~FM_EX_BMI_PIPELINE_ECC; 2708296177Sjhibbits#endif /* FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 */ 2709296177Sjhibbits 2710296177Sjhibbits#ifdef FM_QMI_NO_ECC_EXCEPTIONS 2711296177Sjhibbits if (revInfo.majorRev == 4) 2712296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~(FM_EX_QMI_SINGLE_ECC | FM_EX_QMI_DOUBLE_ECC); 2713296177Sjhibbits#endif /* FM_QMI_NO_ECC_EXCEPTIONS */ 2714296177Sjhibbits 2715296177Sjhibbits CHECK_INIT_PARAMETERS(p_Fm, CheckFmParameters); 2716296177Sjhibbits 2717296177Sjhibbits p_FmDriverParam = p_Fm->p_FmDriverParam; 2718296177Sjhibbits 2719296177Sjhibbits FmMuramClear(p_Fm->h_FmMuram); 2720296177Sjhibbits 2721296177Sjhibbits#ifdef FM_UCODE_NOT_RESET_ERRATA_BUGZILLA6173 2722296177Sjhibbits if (p_FmDriverParam->resetOnInit) 2723296177Sjhibbits { 2724296177Sjhibbits t_FMIramRegs *p_Iram = (t_FMIramRegs *)UINT_TO_PTR(p_Fm->baseAddr + FM_MM_IMEM); 2725296177Sjhibbits uint32_t debug_reg; 2726296177Sjhibbits 2727296177Sjhibbits /* write to IRAM first location the debug instruction */ 2728296177Sjhibbits WRITE_UINT32(p_Iram->iadd, 0); 2729296177Sjhibbits while (GET_UINT32(p_Iram->iadd) != 0) ; 2730296177Sjhibbits WRITE_UINT32(p_Iram->idata, FM_UCODE_DEBUG_INSTRUCTION); 2731296177Sjhibbits 2732296177Sjhibbits WRITE_UINT32(p_Iram->iadd, 0); 2733296177Sjhibbits while (GET_UINT32(p_Iram->iadd) != 0) ; 2734296177Sjhibbits while (GET_UINT32(p_Iram->idata) != FM_UCODE_DEBUG_INSTRUCTION) ; 2735296177Sjhibbits 2736296177Sjhibbits /* Enable patch from IRAM */ 2737296177Sjhibbits WRITE_UINT32(p_Iram->iready, IRAM_READY); 2738296177Sjhibbits XX_UDelay(100); 2739296177Sjhibbits 2740296177Sjhibbits /* reset FMAN */ 2741296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrstc, FPM_RSTC_FM_RESET); 2742296177Sjhibbits XX_UDelay(100); 2743296177Sjhibbits 2744296177Sjhibbits /* verify breakpoint debug status register */ 2745296177Sjhibbits debug_reg = GET_UINT32(*(uint32_t *)UINT_TO_PTR(p_Fm->baseAddr + FM_DEBUG_STATUS_REGISTER_OFFSET)); 2746296177Sjhibbits#ifndef NCSW_LINUX 2747296177Sjhibbits if(!debug_reg) 2748296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Invalid debug status register value = 0")); 2749296177Sjhibbits#else 2750296177Sjhibbits if(!debug_reg) 2751296177Sjhibbits DBG(INFO,("Invalid debug status register value = 0")); 2752296177Sjhibbits#endif 2753296177Sjhibbits /*************************************/ 2754296177Sjhibbits /* Load FMan-Controller code to Iram */ 2755296177Sjhibbits /*************************************/ 2756296177Sjhibbits if (ClearIRam(p_Fm) != E_OK) 2757296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2758296177Sjhibbits if (p_Fm->p_FmDriverParam->firmware.p_Code && 2759296177Sjhibbits (LoadFmanCtrlCode(p_Fm) != E_OK)) 2760296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2761296177Sjhibbits XX_UDelay(100); 2762296177Sjhibbits 2763296177Sjhibbits /* reset FMAN again to start the microcode */ 2764296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrstc, FPM_RSTC_FM_RESET); 2765296177Sjhibbits XX_UDelay(1000); 2766296177Sjhibbits } 2767296177Sjhibbits else 2768296177Sjhibbits { 2769296177Sjhibbits#endif /* FM_UCODE_NOT_RESET_ERRATA_BUGZILLA6173 */ 2770296177Sjhibbits if(p_FmDriverParam->resetOnInit) 2771296177Sjhibbits { 2772296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrstc, FPM_RSTC_FM_RESET); 2773296177Sjhibbits XX_UDelay(100); 2774296177Sjhibbits } 2775296177Sjhibbits 2776296177Sjhibbits /*************************************/ 2777296177Sjhibbits /* Load FMan-Controller code to Iram */ 2778296177Sjhibbits /*************************************/ 2779296177Sjhibbits if (ClearIRam(p_Fm) != E_OK) 2780296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2781296177Sjhibbits if (p_Fm->p_FmDriverParam->firmware.p_Code && 2782296177Sjhibbits (LoadFmanCtrlCode(p_Fm) != E_OK)) 2783296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2784296177Sjhibbits#ifdef FM_UCODE_NOT_RESET_ERRATA_BUGZILLA6173 2785296177Sjhibbits } 2786296177Sjhibbits#endif /* FM_UCODE_NOT_RESET_ERRATA_BUGZILLA6173 */ 2787296177Sjhibbits 2788296177Sjhibbits#ifdef FM_CAPWAP_SUPPORT 2789296177Sjhibbits /* save first 256 byte in MURAM */ 2790296177Sjhibbits p_Fm->resAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_Fm->h_FmMuram, 256, 0)); 2791296177Sjhibbits if (!p_Fm->resAddr) 2792296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for reserved Area failed")); 2793296177Sjhibbits 2794296177Sjhibbits WRITE_BLOCK(UINT_TO_PTR(p_Fm->resAddr), 0, 256); 2795296177Sjhibbits#endif /* FM_CAPWAP_SUPPORT */ 2796296177Sjhibbits 2797296177Sjhibbits /* General FM driver initialization */ 2798296177Sjhibbits p_Fm->fmMuramPhysBaseAddr = (uint64_t)(XX_VirtToPhys(UINT_TO_PTR(p_Fm->baseAddr + FM_MM_MURAM))); 2799296177Sjhibbits for(i=0;i<e_FM_EV_DUMMY_LAST;i++) 2800296177Sjhibbits p_Fm->intrMng[i].f_Isr = UnimplementedIsr; 2801296177Sjhibbits for(i=0;i<FM_NUM_OF_FMAN_CTRL_EVENT_REGS;i++) 2802296177Sjhibbits p_Fm->fmanCtrlIntr[i].f_Isr = UnimplementedFmanCtrlIsr; 2803296177Sjhibbits 2804296177Sjhibbits /**********************/ 2805296177Sjhibbits /* Init DMA Registers */ 2806296177Sjhibbits /**********************/ 2807296177Sjhibbits /* clear status reg events */ 2808296177Sjhibbits tmpReg = (DMA_STATUS_BUS_ERR | DMA_STATUS_READ_ECC | DMA_STATUS_SYSTEM_WRITE_ECC | DMA_STATUS_FM_WRITE_ECC); 2809296177Sjhibbits /*tmpReg |= (DMA_STATUS_SYSTEM_DPEXT_ECC | DMA_STATUS_FM_DPEXT_ECC | DMA_STATUS_SYSTEM_DPDAT_ECC | DMA_STATUS_FM_DPDAT_ECC | DMA_STATUS_FM_SPDAT_ECC);*/ 2810296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmsr, GET_UINT32(p_Fm->p_FmDmaRegs->fmdmsr) | tmpReg); 2811296177Sjhibbits 2812296177Sjhibbits /* configure mode register */ 2813296177Sjhibbits tmpReg = 0; 2814296177Sjhibbits tmpReg |= p_FmDriverParam->dmaCacheOverride << DMA_MODE_CACHE_OR_SHIFT; 2815296177Sjhibbits if(p_FmDriverParam->dmaAidOverride) 2816296177Sjhibbits tmpReg |= DMA_MODE_AID_OR; 2817296177Sjhibbits if (p_Fm->p_FmStateStruct->exceptions & FM_EX_DMA_BUS_ERROR) 2818296177Sjhibbits tmpReg |= DMA_MODE_BER; 2819296177Sjhibbits if ((p_Fm->p_FmStateStruct->exceptions & FM_EX_DMA_SYSTEM_WRITE_ECC) | (p_Fm->p_FmStateStruct->exceptions & FM_EX_DMA_READ_ECC) | (p_Fm->p_FmStateStruct->exceptions & FM_EX_DMA_FM_WRITE_ECC)) 2820296177Sjhibbits tmpReg |= DMA_MODE_ECC; 2821296177Sjhibbits if(p_FmDriverParam->dmaStopOnBusError) 2822296177Sjhibbits tmpReg |= DMA_MODE_SBER; 2823296177Sjhibbits tmpReg |= (uint32_t)(p_FmDriverParam->dmaAxiDbgNumOfBeats - 1) << DMA_MODE_AXI_DBG_SHIFT; 2824296177Sjhibbits if (p_FmDriverParam->dmaEnEmergency) 2825296177Sjhibbits { 2826296177Sjhibbits tmpReg |= p_FmDriverParam->dmaEmergency.emergencyBusSelect; 2827296177Sjhibbits tmpReg |= p_FmDriverParam->dmaEmergency.emergencyLevel << DMA_MODE_EMERGENCY_LEVEL_SHIFT; 2828296177Sjhibbits if(p_FmDriverParam->dmaEnEmergencySmoother) 2829296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmemsr, p_FmDriverParam->dmaEmergencySwitchCounter); 2830296177Sjhibbits } 2831296177Sjhibbits tmpReg |= ((p_FmDriverParam->dmaCamNumOfEntries/DMA_CAM_UNITS) - 1) << DMA_MODE_CEN_SHIFT; 2832296177Sjhibbits 2833296177Sjhibbits tmpReg |= DMA_MODE_SECURE_PROT; 2834296177Sjhibbits tmpReg |= p_FmDriverParam->dmaDbgCntMode << DMA_MODE_DBG_SHIFT; 2835296177Sjhibbits tmpReg |= p_FmDriverParam->dmaAidMode << DMA_MODE_AID_MODE_SHIFT; 2836296177Sjhibbits 2837296177Sjhibbits#ifdef FM_PEDANTIC_DMA 2838296177Sjhibbits tmpReg |= DMA_MODE_EMERGENCY_READ; 2839296177Sjhibbits#endif /* FM_PEDANTIC_DMA */ 2840296177Sjhibbits 2841296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, tmpReg); 2842296177Sjhibbits 2843296177Sjhibbits /* configure thresholds register */ 2844296177Sjhibbits tmpReg = ((uint32_t)p_FmDriverParam->dmaCommQThresholds.assertEmergency << DMA_THRESH_COMMQ_SHIFT) | 2845296177Sjhibbits ((uint32_t)p_FmDriverParam->dmaReadBufThresholds.assertEmergency << DMA_THRESH_READ_INT_BUF_SHIFT) | 2846296177Sjhibbits ((uint32_t)p_FmDriverParam->dmaWriteBufThresholds.assertEmergency); 2847296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmtr, tmpReg); 2848296177Sjhibbits 2849296177Sjhibbits /* configure hysteresis register */ 2850296177Sjhibbits tmpReg = ((uint32_t)p_FmDriverParam->dmaCommQThresholds.clearEmergency << DMA_THRESH_COMMQ_SHIFT) | 2851296177Sjhibbits ((uint32_t)p_FmDriverParam->dmaReadBufThresholds.clearEmergency << DMA_THRESH_READ_INT_BUF_SHIFT) | 2852296177Sjhibbits ((uint32_t)p_FmDriverParam->dmaWriteBufThresholds.clearEmergency); 2853296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmhy, tmpReg); 2854296177Sjhibbits 2855296177Sjhibbits /* configure emergency threshold */ 2856296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmsetr, p_FmDriverParam->dmaSosEmergency); 2857296177Sjhibbits 2858296177Sjhibbits /* configure Watchdog */ 2859296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmwcr, USEC_TO_CLK(p_FmDriverParam->dmaWatchdog, p_Fm->p_FmStateStruct->fmClkFreq)); 2860296177Sjhibbits 2861296177Sjhibbits /* Allocate MURAM for CAM */ 2862296177Sjhibbits p_Fm->camBaseAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_Fm->h_FmMuram, 2863296177Sjhibbits (uint32_t)(p_FmDriverParam->dmaCamNumOfEntries*DMA_CAM_SIZEOF_ENTRY), 2864296177Sjhibbits DMA_CAM_ALIGN)); 2865296177Sjhibbits if (!p_Fm->camBaseAddr ) 2866296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for DMA CAM failed")); 2867296177Sjhibbits 2868296177Sjhibbits WRITE_BLOCK(UINT_TO_PTR(p_Fm->camBaseAddr), 0, (uint32_t)(p_FmDriverParam->dmaCamNumOfEntries*DMA_CAM_SIZEOF_ENTRY)); 2869296177Sjhibbits 2870296177Sjhibbits /* VirtToPhys */ 2871296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmebcr, 2872296177Sjhibbits (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Fm->camBaseAddr)) - p_Fm->fmMuramPhysBaseAddr)); 2873296177Sjhibbits 2874296177Sjhibbits#ifdef FM_PARTITION_ARRAY 2875296177Sjhibbits { 2876296177Sjhibbits t_FmRevisionInfo revInfo; 2877296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 2878296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2879296177Sjhibbits /* liodn-partitions */ 2880296177Sjhibbits for (i=0 ; i<FM_SIZE_OF_LIODN_TABLE ; i+=2) 2881296177Sjhibbits { 2882296177Sjhibbits tmpReg = (((uint32_t)p_FmDriverParam->liodnBasePerPort[i] << DMA_LIODN_SHIFT) | 2883296177Sjhibbits (uint32_t)p_FmDriverParam->liodnBasePerPort[i+1]); 2884296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmplr[i/2], tmpReg); 2885296177Sjhibbits } 2886296177Sjhibbits } 2887296177Sjhibbits#endif /* FM_PARTITION_ARRAY */ 2888296177Sjhibbits 2889296177Sjhibbits /**********************/ 2890296177Sjhibbits /* Init FPM Registers */ 2891296177Sjhibbits /**********************/ 2892296177Sjhibbits tmpReg = (uint32_t)(p_FmDriverParam->thresholds.dispLimit << FPM_DISP_LIMIT_SHIFT); 2893296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmflc, tmpReg); 2894296177Sjhibbits 2895296177Sjhibbits tmpReg = (((uint32_t)p_FmDriverParam->thresholds.prsDispTh << FPM_THR1_PRS_SHIFT) | 2896296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.kgDispTh << FPM_THR1_KG_SHIFT) | 2897296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.plcrDispTh << FPM_THR1_PLCR_SHIFT) | 2898296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.bmiDispTh << FPM_THR1_BMI_SHIFT)); 2899296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmdis1, tmpReg); 2900296177Sjhibbits 2901296177Sjhibbits tmpReg = (((uint32_t)p_FmDriverParam->thresholds.qmiEnqDispTh << FPM_THR2_QMI_ENQ_SHIFT) | 2902296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.qmiDeqDispTh << FPM_THR2_QMI_DEQ_SHIFT) | 2903296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.fmCtl1DispTh << FPM_THR2_FM_CTL1_SHIFT) | 2904296177Sjhibbits ((uint32_t)p_FmDriverParam->thresholds.fmCtl2DispTh << FPM_THR2_FM_CTL2_SHIFT)); 2905296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmdis2, tmpReg); 2906296177Sjhibbits 2907296177Sjhibbits /* define exceptions and error behavior */ 2908296177Sjhibbits tmpReg = 0; 2909296177Sjhibbits /* Clear events */ 2910296177Sjhibbits tmpReg |= (FPM_EV_MASK_STALL | FPM_EV_MASK_DOUBLE_ECC | FPM_EV_MASK_SINGLE_ECC); 2911296177Sjhibbits /* enable interrupts */ 2912296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_FPM_STALL_ON_TASKS) 2913296177Sjhibbits tmpReg |= FPM_EV_MASK_STALL_EN; 2914296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_FPM_SINGLE_ECC) 2915296177Sjhibbits tmpReg |= FPM_EV_MASK_SINGLE_ECC_EN; 2916296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_FPM_DOUBLE_ECC) 2917296177Sjhibbits tmpReg |= FPM_EV_MASK_DOUBLE_ECC_EN; 2918296177Sjhibbits tmpReg |= (p_Fm->p_FmDriverParam->catastrophicErr << FPM_EV_MASK_CAT_ERR_SHIFT); 2919296177Sjhibbits tmpReg |= (p_Fm->p_FmDriverParam->dmaErr << FPM_EV_MASK_DMA_ERR_SHIFT); 2920296177Sjhibbits if(!p_Fm->p_FmDriverParam->haltOnExternalActivation) 2921296177Sjhibbits tmpReg |= FPM_EV_MASK_EXTERNAL_HALT; 2922296177Sjhibbits if(!p_Fm->p_FmDriverParam->haltOnUnrecoverableEccError) 2923296177Sjhibbits tmpReg |= FPM_EV_MASK_ECC_ERR_HALT; 2924296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, tmpReg); 2925296177Sjhibbits 2926296177Sjhibbits /* clear all fmCtls event registers */ 2927296177Sjhibbits for(i=0;i<FM_NUM_OF_FMAN_CTRL_EVENT_REGS;i++) 2928296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmcev[i], 0xFFFFFFFF); 2929296177Sjhibbits 2930296177Sjhibbits /* RAM ECC - enable and clear events*/ 2931296177Sjhibbits /* first we need to clear all parser memory, as it is uninitialized and 2932296177Sjhibbits may cause ECC errors */ 2933296177Sjhibbits tmpReg = 0; 2934296177Sjhibbits /* event bits */ 2935296177Sjhibbits tmpReg = (FPM_RAM_CTL_MURAM_ECC | FPM_RAM_CTL_IRAM_ECC); 2936296177Sjhibbits /* Rams enable is not effected by the RCR bit, but by a COP configuration */ 2937296177Sjhibbits if(p_Fm->p_FmDriverParam->externalEccRamsEnable) 2938296177Sjhibbits tmpReg |= FPM_RAM_CTL_RAMS_ECC_EN_SRC_SEL; 2939296177Sjhibbits 2940296177Sjhibbits /* enable test mode */ 2941296177Sjhibbits if(p_FmDriverParam->enMuramTestMode) 2942296177Sjhibbits tmpReg |= FPM_RAM_CTL_MURAM_TEST_ECC; 2943296177Sjhibbits if(p_FmDriverParam->enIramTestMode) 2944296177Sjhibbits tmpReg |= FPM_RAM_CTL_IRAM_TEST_ECC; 2945296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, tmpReg); 2946296177Sjhibbits 2947296177Sjhibbits tmpReg = 0; 2948296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_IRAM_ECC) 2949296177Sjhibbits { 2950296177Sjhibbits tmpReg |= FPM_IRAM_ECC_ERR_EX_EN; 2951296177Sjhibbits FmEnableRamsEcc(p_Fm); 2952296177Sjhibbits } 2953296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_NURAM_ECC) 2954296177Sjhibbits { 2955296177Sjhibbits tmpReg |= FPM_MURAM_ECC_ERR_EX_EN; 2956296177Sjhibbits FmEnableRamsEcc(p_Fm); 2957296177Sjhibbits } 2958296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrie, tmpReg); 2959296177Sjhibbits 2960296177Sjhibbits /**********************/ 2961296177Sjhibbits /* Init BMI Registers */ 2962296177Sjhibbits /**********************/ 2963296177Sjhibbits 2964296177Sjhibbits /* define common resources */ 2965296177Sjhibbits /* allocate MURAM for FIFO according to total size */ 2966296177Sjhibbits p_Fm->fifoBaseAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_Fm->h_FmMuram, 2967296177Sjhibbits p_Fm->p_FmStateStruct->totalFifoSize, 2968296177Sjhibbits BMI_FIFO_ALIGN)); 2969296177Sjhibbits if (!p_Fm->fifoBaseAddr) 2970296177Sjhibbits { 2971296177Sjhibbits FreeInitResources(p_Fm); 2972296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for FIFO failed")); 2973296177Sjhibbits } 2974296177Sjhibbits 2975296177Sjhibbits tmpReg = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Fm->fifoBaseAddr)) - p_Fm->fmMuramPhysBaseAddr); 2976296177Sjhibbits tmpReg = tmpReg / BMI_FIFO_ALIGN; 2977296177Sjhibbits 2978296177Sjhibbits tmpReg |= ((p_Fm->p_FmStateStruct->totalFifoSize/BMI_FIFO_UNITS - 1) << BMI_CFG1_FIFO_SIZE_SHIFT); 2979296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg1, tmpReg); 2980296177Sjhibbits 2981296177Sjhibbits tmpReg = ((uint32_t)(p_Fm->p_FmStateStruct->totalNumOfTasks - 1) << BMI_CFG2_TASKS_SHIFT ); 2982296177Sjhibbits /* num of DMA's will be dynamically updated when each port is set */ 2983296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2, tmpReg); 2984296177Sjhibbits 2985296177Sjhibbits /* define unmaskable exceptions, enable and clear events */ 2986296177Sjhibbits tmpReg = 0; 2987296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ievr, (BMI_ERR_INTR_EN_LIST_RAM_ECC | 2988296177Sjhibbits BMI_ERR_INTR_EN_PIPELINE_ECC | 2989296177Sjhibbits BMI_ERR_INTR_EN_STATISTICS_RAM_ECC | 2990296177Sjhibbits BMI_ERR_INTR_EN_DISPATCH_RAM_ECC)); 2991296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_LIST_RAM_ECC) 2992296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_LIST_RAM_ECC; 2993296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_PIPELINE_ECC) 2994296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_PIPELINE_ECC; 2995296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_STATISTICS_RAM_ECC) 2996296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_STATISTICS_RAM_ECC; 2997296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_DISPATCH_RAM_ECC) 2998296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_DISPATCH_RAM_ECC; 2999296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier, tmpReg); 3000296177Sjhibbits 3001296177Sjhibbits /**********************/ 3002296177Sjhibbits /* Init QMI Registers */ 3003296177Sjhibbits /**********************/ 3004296177Sjhibbits /* Clear error interrupt events */ 3005296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eie, (QMI_ERR_INTR_EN_DOUBLE_ECC | QMI_ERR_INTR_EN_DEQ_FROM_DEF)); 3006296177Sjhibbits tmpReg = 0; 3007296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_DEQ_FROM_UNKNOWN_PORTID) 3008296177Sjhibbits tmpReg |= QMI_ERR_INTR_EN_DEQ_FROM_DEF; 3009296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_DOUBLE_ECC) 3010296177Sjhibbits tmpReg |= QMI_ERR_INTR_EN_DOUBLE_ECC; 3011296177Sjhibbits /* enable events */ 3012296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien, tmpReg); 3013296177Sjhibbits 3014296177Sjhibbits if(p_Fm->p_FmDriverParam->tnumAgingPeriod) 3015296177Sjhibbits { 3016296177Sjhibbits /* tnumAgingPeriod is in units of microseconds, p_FmClockFreq is in Mhz */ 3017296177Sjhibbits periodInFmClocks = (uint16_t)(p_Fm->p_FmDriverParam->tnumAgingPeriod*p_Fm->p_FmStateStruct->fmClkFreq); 3018296177Sjhibbits /* periodInFmClocks must be a 64 multiply */ 3019296177Sjhibbits remainder = (uint8_t)(periodInFmClocks % 64); 3020296177Sjhibbits if (remainder > 64) 3021296177Sjhibbits tmpReg = (uint32_t)((periodInFmClocks/64) + 1); 3022296177Sjhibbits else 3023296177Sjhibbits { 3024296177Sjhibbits tmpReg = (uint32_t)(periodInFmClocks/64); 3025296177Sjhibbits if(!tmpReg) 3026296177Sjhibbits tmpReg = 1; 3027296177Sjhibbits } 3028296177Sjhibbits tmpReg <<= QMI_TAPC_TAP; 3029296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_tapc, tmpReg); 3030296177Sjhibbits 3031296177Sjhibbits } 3032296177Sjhibbits tmpReg = 0; 3033296177Sjhibbits /* Clear interrupt events */ 3034296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_ie, QMI_INTR_EN_SINGLE_ECC); 3035296177Sjhibbits if(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_SINGLE_ECC) 3036296177Sjhibbits tmpReg |= QMI_INTR_EN_SINGLE_ECC; 3037296177Sjhibbits /* enable events */ 3038296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_ien, tmpReg); 3039296177Sjhibbits 3040296177Sjhibbits /* clear & enable global counters - calculate reg and save for later, 3041296177Sjhibbits because it's the same reg for QMI enable */ 3042296177Sjhibbits if(p_Fm->p_FmDriverParam->enCounters) 3043296177Sjhibbits cfgReg = QMI_CFG_EN_COUNTERS; 3044296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 3045296177Sjhibbits cfgReg |= (uint32_t)(((QMI_DEF_TNUMS_THRESH) << 8) | (uint32_t)QMI_DEF_TNUMS_THRESH); 3046296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 3047296177Sjhibbits 3048296177Sjhibbits if (p_Fm->p_FmStateStruct->irq != NO_IRQ) 3049296177Sjhibbits { 3050296177Sjhibbits XX_SetIntr(p_Fm->p_FmStateStruct->irq, FM_EventIsr, p_Fm); 3051296177Sjhibbits XX_EnableIntr(p_Fm->p_FmStateStruct->irq); 3052296177Sjhibbits } 3053296177Sjhibbits 3054296177Sjhibbits if (p_Fm->p_FmStateStruct->errIrq != NO_IRQ) 3055296177Sjhibbits { 3056296177Sjhibbits XX_SetIntr(p_Fm->p_FmStateStruct->errIrq, ErrorIsrCB, p_Fm); 3057296177Sjhibbits XX_EnableIntr(p_Fm->p_FmStateStruct->errIrq); 3058296177Sjhibbits } 3059296177Sjhibbits 3060296177Sjhibbits /* build the FM master partition IPC address */ 3061296177Sjhibbits if (Sprint (p_Fm->fmModuleName, "FM_%d_%d",p_Fm->p_FmStateStruct->fmId, NCSW_MASTER_ID) != 6) 3062296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 3063296177Sjhibbits 3064296177Sjhibbits err = XX_IpcRegisterMsgHandler(p_Fm->fmModuleName, FmHandleIpcMsgCB, p_Fm, FM_IPC_MAX_REPLY_SIZE); 3065296177Sjhibbits if(err) 3066296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 3067296177Sjhibbits 3068296177Sjhibbits /**********************/ 3069296177Sjhibbits /* Enable all modules */ 3070296177Sjhibbits /**********************/ 3071296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_init, BMI_INIT_START); 3072296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc, cfgReg | QMI_CFG_ENQ_EN | QMI_CFG_DEQ_EN); 3073296177Sjhibbits 3074296177Sjhibbits if (p_Fm->p_FmDriverParam->firmware.p_Code) 3075296177Sjhibbits { 3076296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam->firmware.p_Code); 3077296177Sjhibbits p_Fm->p_FmDriverParam->firmware.p_Code = NULL; 3078296177Sjhibbits } 3079296177Sjhibbits 3080296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam); 3081296177Sjhibbits p_Fm->p_FmDriverParam = NULL; 3082296177Sjhibbits 3083296177Sjhibbits return E_OK; 3084296177Sjhibbits} 3085296177Sjhibbits 3086296177Sjhibbits/**************************************************************************//** 3087296177Sjhibbits @Function FM_Free 3088296177Sjhibbits 3089296177Sjhibbits @Description Frees all resources that were assigned to FM module. 3090296177Sjhibbits 3091296177Sjhibbits Calling this routine invalidates the descriptor. 3092296177Sjhibbits 3093296177Sjhibbits @Param[in] h_Fm - FM module descriptor 3094296177Sjhibbits 3095296177Sjhibbits @Return E_OK on success; Error code otherwise. 3096296177Sjhibbits*//***************************************************************************/ 3097296177Sjhibbitst_Error FM_Free(t_Handle h_Fm) 3098296177Sjhibbits{ 3099296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3100296177Sjhibbits 3101296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3102296177Sjhibbits 3103296177Sjhibbits if (p_Fm->guestId != NCSW_MASTER_ID) 3104296177Sjhibbits { 3105296177Sjhibbits XX_IpcUnregisterMsgHandler(p_Fm->fmModuleName); 3106296177Sjhibbits 3107296177Sjhibbits if(!p_Fm->recoveryMode) 3108296177Sjhibbits XX_Free(p_Fm->p_FmStateStruct); 3109296177Sjhibbits 3110296177Sjhibbits XX_Free(p_Fm); 3111296177Sjhibbits 3112296177Sjhibbits return E_OK; 3113296177Sjhibbits } 3114296177Sjhibbits 3115296177Sjhibbits /* disable BMI and QMI */ 3116296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_init, 0); 3117296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc, 0); 3118296177Sjhibbits 3119296177Sjhibbits /* release BMI resources */ 3120296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg2, 0); 3121296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_cfg1, 0); 3122296177Sjhibbits 3123296177Sjhibbits /* disable ECC */ 3124296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, 0); 3125296177Sjhibbits 3126296177Sjhibbits if ((p_Fm->guestId == NCSW_MASTER_ID) && (p_Fm->fmModuleName[0] != 0)) 3127296177Sjhibbits XX_IpcUnregisterMsgHandler(p_Fm->fmModuleName); 3128296177Sjhibbits 3129296177Sjhibbits if (p_Fm->p_FmStateStruct) 3130296177Sjhibbits { 3131296177Sjhibbits if (p_Fm->p_FmStateStruct->irq != NO_IRQ) 3132296177Sjhibbits { 3133296177Sjhibbits XX_DisableIntr(p_Fm->p_FmStateStruct->irq); 3134296177Sjhibbits XX_FreeIntr(p_Fm->p_FmStateStruct->irq); 3135296177Sjhibbits } 3136296177Sjhibbits if (p_Fm->p_FmStateStruct->errIrq != NO_IRQ) 3137296177Sjhibbits { 3138296177Sjhibbits XX_DisableIntr(p_Fm->p_FmStateStruct->errIrq); 3139296177Sjhibbits XX_FreeIntr(p_Fm->p_FmStateStruct->errIrq); 3140296177Sjhibbits } 3141296177Sjhibbits } 3142296177Sjhibbits 3143296177Sjhibbits if (p_Fm->h_Spinlock) 3144296177Sjhibbits XX_FreeSpinlock(p_Fm->h_Spinlock); 3145296177Sjhibbits 3146296177Sjhibbits if (p_Fm->p_FmDriverParam) 3147296177Sjhibbits { 3148296177Sjhibbits if (p_Fm->p_FmDriverParam->firmware.p_Code) 3149296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam->firmware.p_Code); 3150296177Sjhibbits XX_Free(p_Fm->p_FmDriverParam); 3151296177Sjhibbits p_Fm->p_FmDriverParam = NULL; 3152296177Sjhibbits } 3153296177Sjhibbits 3154296177Sjhibbits FreeInitResources(p_Fm); 3155296177Sjhibbits 3156296177Sjhibbits if (!p_Fm->recoveryMode && p_Fm->p_FmStateStruct) 3157296177Sjhibbits XX_Free(p_Fm->p_FmStateStruct); 3158296177Sjhibbits 3159296177Sjhibbits XX_Free(p_Fm); 3160296177Sjhibbits 3161296177Sjhibbits return E_OK; 3162296177Sjhibbits} 3163296177Sjhibbits 3164296177Sjhibbits/*************************************************/ 3165296177Sjhibbits/* API Advanced Init unit functions */ 3166296177Sjhibbits/*************************************************/ 3167296177Sjhibbits 3168296177Sjhibbitst_Error FM_ConfigResetOnInit(t_Handle h_Fm, bool enable) 3169296177Sjhibbits{ 3170296177Sjhibbits 3171296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3172296177Sjhibbits 3173296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3174296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3175296177Sjhibbits 3176296177Sjhibbits p_Fm->p_FmDriverParam->resetOnInit = enable; 3177296177Sjhibbits 3178296177Sjhibbits return E_OK; 3179296177Sjhibbits} 3180296177Sjhibbits 3181296177Sjhibbits 3182296177Sjhibbitst_Error FM_ConfigTotalNumOfTasks(t_Handle h_Fm, uint8_t totalNumOfTasks) 3183296177Sjhibbits{ 3184296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3185296177Sjhibbits 3186296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3187296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3188296177Sjhibbits 3189296177Sjhibbits p_Fm->p_FmStateStruct->totalNumOfTasks = totalNumOfTasks; 3190296177Sjhibbits 3191296177Sjhibbits return E_OK; 3192296177Sjhibbits} 3193296177Sjhibbits 3194296177Sjhibbitst_Error FM_ConfigTotalFifoSize(t_Handle h_Fm, uint32_t totalFifoSize) 3195296177Sjhibbits{ 3196296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3197296177Sjhibbits 3198296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3199296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3200296177Sjhibbits 3201296177Sjhibbits p_Fm->p_FmStateStruct->totalFifoSize = totalFifoSize; 3202296177Sjhibbits 3203296177Sjhibbits return E_OK; 3204296177Sjhibbits} 3205296177Sjhibbits 3206296177Sjhibbitst_Error FM_ConfigMaxNumOfOpenDmas(t_Handle h_Fm, uint8_t maxNumOfOpenDmas) 3207296177Sjhibbits{ 3208296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3209296177Sjhibbits 3210296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3211296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3212296177Sjhibbits 3213296177Sjhibbits p_Fm->p_FmStateStruct->maxNumOfOpenDmas = maxNumOfOpenDmas; 3214296177Sjhibbits 3215296177Sjhibbits return E_OK; 3216296177Sjhibbits} 3217296177Sjhibbits 3218296177Sjhibbitst_Error FM_ConfigThresholds(t_Handle h_Fm, t_FmThresholds *p_FmThresholds) 3219296177Sjhibbits{ 3220296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3221296177Sjhibbits 3222296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3223296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3224296177Sjhibbits 3225296177Sjhibbits memcpy(&p_Fm->p_FmDriverParam->thresholds, p_FmThresholds, sizeof(t_FmThresholds)); 3226296177Sjhibbits 3227296177Sjhibbits return E_OK; 3228296177Sjhibbits} 3229296177Sjhibbits 3230296177Sjhibbitst_Error FM_ConfigDmaCacheOverride(t_Handle h_Fm, e_FmDmaCacheOverride cacheOverride) 3231296177Sjhibbits{ 3232296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3233296177Sjhibbits 3234296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3235296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3236296177Sjhibbits 3237296177Sjhibbits p_Fm->p_FmDriverParam->dmaCacheOverride = cacheOverride; 3238296177Sjhibbits 3239296177Sjhibbits return E_OK; 3240296177Sjhibbits} 3241296177Sjhibbits 3242296177Sjhibbitst_Error FM_ConfigDmaAidOverride(t_Handle h_Fm, bool aidOverride) 3243296177Sjhibbits{ 3244296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3245296177Sjhibbits 3246296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3247296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3248296177Sjhibbits 3249296177Sjhibbits p_Fm->p_FmDriverParam->dmaAidOverride = aidOverride; 3250296177Sjhibbits 3251296177Sjhibbits return E_OK; 3252296177Sjhibbits} 3253296177Sjhibbits 3254296177Sjhibbitst_Error FM_ConfigDmaAidMode(t_Handle h_Fm, e_FmDmaAidMode aidMode) 3255296177Sjhibbits{ 3256296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3257296177Sjhibbits 3258296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3259296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3260296177Sjhibbits 3261296177Sjhibbits p_Fm->p_FmDriverParam->dmaAidMode = aidMode; 3262296177Sjhibbits 3263296177Sjhibbits return E_OK; 3264296177Sjhibbits} 3265296177Sjhibbits 3266296177Sjhibbitst_Error FM_ConfigDmaAxiDbgNumOfBeats(t_Handle h_Fm, uint8_t axiDbgNumOfBeats) 3267296177Sjhibbits{ 3268296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3269296177Sjhibbits 3270296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3271296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3272296177Sjhibbits 3273296177Sjhibbits p_Fm->p_FmDriverParam->dmaAxiDbgNumOfBeats = axiDbgNumOfBeats; 3274296177Sjhibbits 3275296177Sjhibbits return E_OK; 3276296177Sjhibbits} 3277296177Sjhibbits 3278296177Sjhibbitst_Error FM_ConfigDmaCamNumOfEntries(t_Handle h_Fm, uint8_t numOfEntries) 3279296177Sjhibbits{ 3280296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3281296177Sjhibbits 3282296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3283296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3284296177Sjhibbits 3285296177Sjhibbits p_Fm->p_FmDriverParam->dmaCamNumOfEntries = numOfEntries; 3286296177Sjhibbits 3287296177Sjhibbits return E_OK; 3288296177Sjhibbits} 3289296177Sjhibbits 3290296177Sjhibbitst_Error FM_ConfigDmaWatchdog(t_Handle h_Fm, uint32_t watchdogValue) 3291296177Sjhibbits{ 3292296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3293296177Sjhibbits 3294296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3295296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3296296177Sjhibbits 3297296177Sjhibbits#ifdef FM_NO_WATCHDOG 3298296177Sjhibbits { 3299296177Sjhibbits t_FmRevisionInfo revInfo; 3300296177Sjhibbits FM_GetRevision(h_Fm, &revInfo); 3301296177Sjhibbits if (revInfo.majorRev != 4) 3302296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("watchdog!")); 3303296177Sjhibbits } 3304296177Sjhibbits#endif /* FM_NO_WATCHDOG */ 3305296177Sjhibbits 3306296177Sjhibbits p_Fm->p_FmDriverParam->dmaWatchdog = watchdogValue; 3307296177Sjhibbits 3308296177Sjhibbits return E_OK; 3309296177Sjhibbits} 3310296177Sjhibbits 3311296177Sjhibbitst_Error FM_ConfigDmaWriteBufThresholds(t_Handle h_Fm, t_FmDmaThresholds *p_FmDmaThresholds) 3312296177Sjhibbits 3313296177Sjhibbits{ 3314296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3315296177Sjhibbits 3316296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3317296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3318296177Sjhibbits 3319296177Sjhibbits memcpy(&p_Fm->p_FmDriverParam->dmaWriteBufThresholds, p_FmDmaThresholds, sizeof(t_FmDmaThresholds)); 3320296177Sjhibbits 3321296177Sjhibbits return E_OK; 3322296177Sjhibbits} 3323296177Sjhibbits 3324296177Sjhibbitst_Error FM_ConfigDmaCommQThresholds(t_Handle h_Fm, t_FmDmaThresholds *p_FmDmaThresholds) 3325296177Sjhibbits{ 3326296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3327296177Sjhibbits 3328296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3329296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3330296177Sjhibbits 3331296177Sjhibbits memcpy(&p_Fm->p_FmDriverParam->dmaCommQThresholds, p_FmDmaThresholds, sizeof(t_FmDmaThresholds)); 3332296177Sjhibbits 3333296177Sjhibbits return E_OK; 3334296177Sjhibbits} 3335296177Sjhibbits 3336296177Sjhibbitst_Error FM_ConfigDmaReadBufThresholds(t_Handle h_Fm, t_FmDmaThresholds *p_FmDmaThresholds) 3337296177Sjhibbits{ 3338296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3339296177Sjhibbits 3340296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3341296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3342296177Sjhibbits 3343296177Sjhibbits memcpy(&p_Fm->p_FmDriverParam->dmaReadBufThresholds, p_FmDmaThresholds, sizeof(t_FmDmaThresholds)); 3344296177Sjhibbits 3345296177Sjhibbits return E_OK; 3346296177Sjhibbits} 3347296177Sjhibbits 3348296177Sjhibbitst_Error FM_ConfigDmaEmergency(t_Handle h_Fm, t_FmDmaEmergency *p_Emergency) 3349296177Sjhibbits{ 3350296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3351296177Sjhibbits 3352296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3353296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3354296177Sjhibbits 3355296177Sjhibbits p_Fm->p_FmDriverParam->dmaEnEmergency = TRUE; 3356296177Sjhibbits memcpy(&p_Fm->p_FmDriverParam->dmaEmergency, p_Emergency, sizeof(t_FmDmaEmergency)); 3357296177Sjhibbits 3358296177Sjhibbits return E_OK; 3359296177Sjhibbits} 3360296177Sjhibbits 3361296177Sjhibbitst_Error FM_ConfigDmaEmergencySmoother(t_Handle h_Fm, uint32_t emergencyCnt) 3362296177Sjhibbits{ 3363296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3364296177Sjhibbits 3365296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3366296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3367296177Sjhibbits 3368296177Sjhibbits if(!p_Fm->p_FmDriverParam->dmaEnEmergency) 3369296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("FM_ConfigEnDmaEmergencySmoother may be called only after FM_ConfigEnDmaEmergency")); 3370296177Sjhibbits 3371296177Sjhibbits p_Fm->p_FmDriverParam->dmaEnEmergencySmoother = TRUE; 3372296177Sjhibbits p_Fm->p_FmDriverParam->dmaEmergencySwitchCounter = emergencyCnt; 3373296177Sjhibbits 3374296177Sjhibbits return E_OK; 3375296177Sjhibbits} 3376296177Sjhibbits 3377296177Sjhibbitst_Error FM_ConfigDmaDbgCounter(t_Handle h_Fm, e_FmDmaDbgCntMode fmDmaDbgCntMode) 3378296177Sjhibbits{ 3379296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3380296177Sjhibbits 3381296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3382296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3383296177Sjhibbits 3384296177Sjhibbits p_Fm->p_FmDriverParam->dmaDbgCntMode = fmDmaDbgCntMode; 3385296177Sjhibbits 3386296177Sjhibbits return E_OK; 3387296177Sjhibbits} 3388296177Sjhibbits 3389296177Sjhibbitst_Error FM_ConfigDmaStopOnBusErr(t_Handle h_Fm, bool stop) 3390296177Sjhibbits{ 3391296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3392296177Sjhibbits 3393296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3394296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3395296177Sjhibbits 3396296177Sjhibbits p_Fm->p_FmDriverParam->dmaStopOnBusError = stop; 3397296177Sjhibbits 3398296177Sjhibbits return E_OK; 3399296177Sjhibbits} 3400296177Sjhibbits 3401296177Sjhibbitst_Error FM_ConfigDmaSosEmergencyThreshold(t_Handle h_Fm, uint32_t dmaSosEmergency) 3402296177Sjhibbits{ 3403296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3404296177Sjhibbits 3405296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3406296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3407296177Sjhibbits 3408296177Sjhibbits p_Fm->p_FmDriverParam->dmaSosEmergency = dmaSosEmergency; 3409296177Sjhibbits 3410296177Sjhibbits return E_OK; 3411296177Sjhibbits} 3412296177Sjhibbits 3413296177Sjhibbitst_Error FM_ConfigEnableCounters(t_Handle h_Fm) 3414296177Sjhibbits{ 3415296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3416296177Sjhibbits 3417296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3418296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3419296177Sjhibbits 3420296177Sjhibbits p_Fm->p_FmDriverParam->enCounters = TRUE; 3421296177Sjhibbits 3422296177Sjhibbits return E_OK; 3423296177Sjhibbits} 3424296177Sjhibbits 3425296177Sjhibbitst_Error FM_ConfigDmaErr(t_Handle h_Fm, e_FmDmaErr dmaErr) 3426296177Sjhibbits{ 3427296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3428296177Sjhibbits 3429296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3430296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3431296177Sjhibbits 3432296177Sjhibbits p_Fm->p_FmDriverParam->dmaErr = dmaErr; 3433296177Sjhibbits 3434296177Sjhibbits return E_OK; 3435296177Sjhibbits} 3436296177Sjhibbits 3437296177Sjhibbitst_Error FM_ConfigCatastrophicErr(t_Handle h_Fm, e_FmCatastrophicErr catastrophicErr) 3438296177Sjhibbits{ 3439296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3440296177Sjhibbits 3441296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3442296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3443296177Sjhibbits 3444296177Sjhibbits p_Fm->p_FmDriverParam->catastrophicErr = catastrophicErr; 3445296177Sjhibbits 3446296177Sjhibbits return E_OK; 3447296177Sjhibbits} 3448296177Sjhibbits 3449296177Sjhibbitst_Error FM_ConfigEnableMuramTestMode(t_Handle h_Fm) 3450296177Sjhibbits{ 3451296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3452296177Sjhibbits 3453296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3454296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3455296177Sjhibbits 3456296177Sjhibbits p_Fm->p_FmDriverParam->enMuramTestMode = TRUE; 3457296177Sjhibbits 3458296177Sjhibbits return E_OK; 3459296177Sjhibbits} 3460296177Sjhibbits 3461296177Sjhibbitst_Error FM_ConfigEnableIramTestMode(t_Handle h_Fm) 3462296177Sjhibbits{ 3463296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3464296177Sjhibbits 3465296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3466296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3467296177Sjhibbits 3468296177Sjhibbits p_Fm->p_FmDriverParam->enIramTestMode = TRUE; 3469296177Sjhibbits 3470296177Sjhibbits return E_OK; 3471296177Sjhibbits} 3472296177Sjhibbits 3473296177Sjhibbitst_Error FM_ConfigHaltOnExternalActivation(t_Handle h_Fm, bool enable) 3474296177Sjhibbits{ 3475296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3476296177Sjhibbits 3477296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3478296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3479296177Sjhibbits 3480296177Sjhibbits#ifdef FM_HALT_SIG_ERRATA_GEN12 3481296177Sjhibbits { 3482296177Sjhibbits t_FmRevisionInfo revInfo; 3483296177Sjhibbits FM_GetRevision(h_Fm, &revInfo); 3484296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 3485296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("HaltOnExternalActivation!")); 3486296177Sjhibbits } 3487296177Sjhibbits#endif /* FM_HALT_SIG_ERRATA_GEN12 */ 3488296177Sjhibbits 3489296177Sjhibbits p_Fm->p_FmDriverParam->haltOnExternalActivation = enable; 3490296177Sjhibbits 3491296177Sjhibbits return E_OK; 3492296177Sjhibbits} 3493296177Sjhibbits 3494296177Sjhibbitst_Error FM_ConfigHaltOnUnrecoverableEccError(t_Handle h_Fm, bool enable) 3495296177Sjhibbits{ 3496296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3497296177Sjhibbits 3498296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3499296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3500296177Sjhibbits 3501296177Sjhibbits#ifdef FM_ECC_HALT_NO_SYNC_ERRATA_10GMAC_A008 3502296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("HaltOnEccError!")); 3503296177Sjhibbits#endif /* FM_ECC_HALT_NO_SYNC_ERRATA_10GMAC_A008 */ 3504296177Sjhibbits 3505296177Sjhibbits p_Fm->p_FmDriverParam->haltOnUnrecoverableEccError = enable; 3506296177Sjhibbits 3507296177Sjhibbits return E_OK; 3508296177Sjhibbits} 3509296177Sjhibbits 3510296177Sjhibbitst_Error FM_ConfigException(t_Handle h_Fm, e_FmExceptions exception, bool enable) 3511296177Sjhibbits{ 3512296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3513296177Sjhibbits uint32_t bitMask = 0; 3514296177Sjhibbits t_FmRevisionInfo revInfo; 3515296177Sjhibbits 3516296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3517296177Sjhibbits 3518296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 3519296177Sjhibbits#ifdef FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 3520296177Sjhibbits if((exception == e_FM_EX_BMI_PIPELINE_ECC) && (enable)) 3521296177Sjhibbits { 3522296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 3523296177Sjhibbits { 3524296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_PIPELINE_ECC!")); 3525296177Sjhibbits return E_OK; 3526296177Sjhibbits } 3527296177Sjhibbits } 3528296177Sjhibbits#endif /* FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 */ 3529296177Sjhibbits#ifdef FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 3530296177Sjhibbits if((exception == e_FM_EX_BMI_LIST_RAM_ECC) && (enable)) 3531296177Sjhibbits { 3532296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 3533296177Sjhibbits { 3534296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_LIST_RAM_ECC!")); 3535296177Sjhibbits return E_OK; 3536296177Sjhibbits } 3537296177Sjhibbits } 3538296177Sjhibbits#endif /* FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 */ 3539296177Sjhibbits#ifdef FM_QMI_NO_ECC_EXCEPTIONS 3540296177Sjhibbits if(((exception == e_FM_EX_QMI_SINGLE_ECC) || (exception == e_FM_EX_QMI_DOUBLE_ECC)) && 3541296177Sjhibbits enable) 3542296177Sjhibbits { 3543296177Sjhibbits if (revInfo.majorRev == 4) 3544296177Sjhibbits { 3545296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("QMI ECC exception!")); 3546296177Sjhibbits return E_OK; 3547296177Sjhibbits } 3548296177Sjhibbits } 3549296177Sjhibbits#endif /* FM_QMI_NO_ECC_EXCEPTIONS */ 3550296177Sjhibbits#ifdef FM_NO_DISPATCH_RAM_ECC 3551296177Sjhibbits if((exception == e_FM_EX_BMI_DISPATCH_RAM_ECC) && (enable)) 3552296177Sjhibbits { 3553296177Sjhibbits if (revInfo.majorRev != 4) 3554296177Sjhibbits { 3555296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_DISPATCH_RAM_ECC!")); 3556296177Sjhibbits return E_OK; 3557296177Sjhibbits } 3558296177Sjhibbits } 3559296177Sjhibbits#endif /* FM_NO_DISPATCH_RAM_ECC */ 3560296177Sjhibbits 3561296177Sjhibbits GET_EXCEPTION_FLAG(bitMask, exception); 3562296177Sjhibbits if(bitMask) 3563296177Sjhibbits { 3564296177Sjhibbits if (enable) 3565296177Sjhibbits p_Fm->p_FmStateStruct->exceptions |= bitMask; 3566296177Sjhibbits else 3567296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~bitMask; 3568296177Sjhibbits } 3569296177Sjhibbits else 3570296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception")); 3571296177Sjhibbits 3572296177Sjhibbits return E_OK; 3573296177Sjhibbits} 3574296177Sjhibbits 3575296177Sjhibbitst_Error FM_ConfigExternalEccRamsEnable(t_Handle h_Fm, bool enable) 3576296177Sjhibbits{ 3577296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3578296177Sjhibbits 3579296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3580296177Sjhibbits 3581296177Sjhibbits p_Fm->p_FmDriverParam->externalEccRamsEnable = enable; 3582296177Sjhibbits 3583296177Sjhibbits return E_OK; 3584296177Sjhibbits} 3585296177Sjhibbits 3586296177Sjhibbitst_Error FM_ConfigTnumAgingPeriod(t_Handle h_Fm, uint16_t tnumAgingPeriod) 3587296177Sjhibbits{ 3588296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3589296177Sjhibbits#ifdef FM_NO_TNUM_AGING 3590296177Sjhibbits t_FmRevisionInfo revInfo; 3591296177Sjhibbits#endif /* FM_NO_TNUM_AGING */ 3592296177Sjhibbits 3593296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3594296177Sjhibbits 3595296177Sjhibbits#ifdef FM_NO_TNUM_AGING 3596296177Sjhibbits FM_GetRevision(h_Fm, &revInfo); 3597296177Sjhibbits if (revInfo.majorRev != 4) 3598296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("FM_ConfigTnumAgingPeriod!")); 3599296177Sjhibbits#endif /* FM_NO_TNUM_AGING */ 3600296177Sjhibbits 3601296177Sjhibbits p_Fm->p_FmDriverParam->tnumAgingPeriod = tnumAgingPeriod; 3602296177Sjhibbits 3603296177Sjhibbits return E_OK; 3604296177Sjhibbits 3605296177Sjhibbits} 3606296177Sjhibbits 3607296177Sjhibbits/****************************************************/ 3608296177Sjhibbits/* API Run-time Control uint functions */ 3609296177Sjhibbits/****************************************************/ 3610296177Sjhibbitst_Handle FM_GetPcdHandle(t_Handle h_Fm) 3611296177Sjhibbits{ 3612296177Sjhibbits SANITY_CHECK_RETURN_VALUE(h_Fm, E_INVALID_HANDLE, NULL); 3613296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!((t_Fm*)h_Fm)->p_FmDriverParam, E_INVALID_STATE, NULL); 3614296177Sjhibbits 3615296177Sjhibbits return ((t_Fm*)h_Fm)->h_Pcd; 3616296177Sjhibbits} 3617296177Sjhibbits 3618296177Sjhibbitsvoid FM_EventIsr(t_Handle h_Fm) 3619296177Sjhibbits{ 3620296177Sjhibbits#define FM_M_CALL_1G_MAC_TMR_ISR(_id) \ 3621296177Sjhibbits { \ 3622296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id)].guestId) \ 3623296177Sjhibbits SendIpcIsr(p_Fm, (e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id), pending); \ 3624296177Sjhibbits else \ 3625296177Sjhibbits p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id)].f_Isr(p_Fm->intrMng[(e_FmInterModuleEvent)(e_FM_EV_1G_MAC0_TMR+_id)].h_SrcHandle);\ 3626296177Sjhibbits } 3627296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3628296177Sjhibbits uint32_t pending, event; 3629296177Sjhibbits 3630296177Sjhibbits SANITY_CHECK_RETURN(h_Fm, E_INVALID_HANDLE); 3631296177Sjhibbits 3632296177Sjhibbits /* normal interrupts */ 3633296177Sjhibbits pending = GET_UINT32(p_Fm->p_FmFpmRegs->fmnpi); 3634296177Sjhibbits ASSERT_COND(pending); 3635296177Sjhibbits if (pending & INTR_EN_BMI) 3636296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("BMI Event - undefined!")); 3637296177Sjhibbits if (pending & INTR_EN_QMI) 3638296177Sjhibbits QmiEvent(p_Fm); 3639296177Sjhibbits if (pending & INTR_EN_PRS) 3640296177Sjhibbits p_Fm->intrMng[e_FM_EV_PRS].f_Isr(p_Fm->intrMng[e_FM_EV_PRS].h_SrcHandle); 3641296177Sjhibbits if (pending & INTR_EN_PLCR) 3642296177Sjhibbits p_Fm->intrMng[e_FM_EV_PLCR].f_Isr(p_Fm->intrMng[e_FM_EV_PLCR].h_SrcHandle); 3643296177Sjhibbits if (pending & INTR_EN_KG) 3644296177Sjhibbits p_Fm->intrMng[e_FM_EV_KG].f_Isr(p_Fm->intrMng[e_FM_EV_KG].h_SrcHandle); 3645296177Sjhibbits if (pending & INTR_EN_TMR) 3646296177Sjhibbits p_Fm->intrMng[e_FM_EV_TMR].f_Isr(p_Fm->intrMng[e_FM_EV_TMR].h_SrcHandle); 3647296177Sjhibbits 3648296177Sjhibbits /* MAC events may belong to different partitions */ 3649296177Sjhibbits if (pending & INTR_EN_1G_MAC0_TMR) 3650296177Sjhibbits FM_M_CALL_1G_MAC_TMR_ISR(0); 3651296177Sjhibbits if (pending & INTR_EN_1G_MAC1_TMR) 3652296177Sjhibbits FM_M_CALL_1G_MAC_TMR_ISR(1); 3653296177Sjhibbits if (pending & INTR_EN_1G_MAC2_TMR) 3654296177Sjhibbits FM_M_CALL_1G_MAC_TMR_ISR(2); 3655296177Sjhibbits if (pending & INTR_EN_1G_MAC3_TMR) 3656296177Sjhibbits FM_M_CALL_1G_MAC_TMR_ISR(3); 3657296177Sjhibbits if (pending & INTR_EN_1G_MAC4_TMR) 3658296177Sjhibbits FM_M_CALL_1G_MAC_TMR_ISR(4); 3659296177Sjhibbits 3660296177Sjhibbits /* IM port events may belong to different partitions */ 3661296177Sjhibbits if (pending & INTR_EN_REV0) 3662296177Sjhibbits { 3663296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcev[0]) & GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[0]); 3664296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmcev[0], event); 3665296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[e_FM_EV_FMAN_CTRL_0].guestId) 3666296177Sjhibbits /*TODO IPC ISR For Fman Ctrl */ 3667296177Sjhibbits ASSERT_COND(0); 3668296177Sjhibbits /* SendIpcIsr(p_Fm, e_FM_EV_FMAN_CTRL_0, pending); */ 3669296177Sjhibbits else 3670296177Sjhibbits p_Fm->fmanCtrlIntr[0].f_Isr(p_Fm->fmanCtrlIntr[0].h_SrcHandle, event); 3671296177Sjhibbits 3672296177Sjhibbits } 3673296177Sjhibbits if (pending & INTR_EN_REV1) 3674296177Sjhibbits { 3675296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcev[1]) & GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[1]); 3676296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmcev[1], event); 3677296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[e_FM_EV_FMAN_CTRL_1].guestId) 3678296177Sjhibbits /*TODO IPC ISR For Fman Ctrl */ 3679296177Sjhibbits ASSERT_COND(0); 3680296177Sjhibbits /* SendIpcIsr(p_Fm, e_FM_EV_FMAN_CTRL_1, pending); */ 3681296177Sjhibbits else 3682296177Sjhibbits p_Fm->fmanCtrlIntr[1].f_Isr(p_Fm->fmanCtrlIntr[1].h_SrcHandle, event); 3683296177Sjhibbits 3684296177Sjhibbits } 3685296177Sjhibbits if (pending & INTR_EN_REV2) 3686296177Sjhibbits { 3687296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcev[2]) & GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[2]); 3688296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmcev[2], event); 3689296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[e_FM_EV_FMAN_CTRL_2].guestId) 3690296177Sjhibbits /*TODO IPC ISR For Fman Ctrl */ 3691296177Sjhibbits ASSERT_COND(0); 3692296177Sjhibbits /* SendIpcIsr(p_Fm, e_FM_EV_FMAN_CTRL_2, pending); */ 3693296177Sjhibbits else 3694296177Sjhibbits p_Fm->fmanCtrlIntr[2].f_Isr(p_Fm->fmanCtrlIntr[2].h_SrcHandle, event); 3695296177Sjhibbits } 3696296177Sjhibbits if (pending & INTR_EN_REV3) 3697296177Sjhibbits { 3698296177Sjhibbits event = GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcev[3]) & GET_UINT32(p_Fm->p_FmFpmRegs->fmfpfcee[3]); 3699296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmcev[3], event); 3700296177Sjhibbits if (p_Fm->guestId != p_Fm->intrMng[e_FM_EV_FMAN_CTRL_3].guestId) 3701296177Sjhibbits /*TODO IPC ISR For Fman Ctrl */ 3702296177Sjhibbits ASSERT_COND(0); 3703296177Sjhibbits /* SendIpcIsr(p_Fm, e_FM_EV_FMAN_CTRL_2, pendin3); */ 3704296177Sjhibbits else 3705296177Sjhibbits p_Fm->fmanCtrlIntr[3].f_Isr(p_Fm->fmanCtrlIntr[3].h_SrcHandle, event); 3706296177Sjhibbits } 3707296177Sjhibbits} 3708296177Sjhibbits 3709296177Sjhibbitst_Error FM_ErrorIsr(t_Handle h_Fm) 3710296177Sjhibbits{ 3711296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3712296177Sjhibbits 3713296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_Fm, E_INVALID_HANDLE); 3714296177Sjhibbits 3715296177Sjhibbits /* error interrupts */ 3716296177Sjhibbits if (GET_UINT32(p_Fm->p_FmFpmRegs->fmepi) == 0) 3717296177Sjhibbits return ERROR_CODE(E_EMPTY); 3718296177Sjhibbits 3719296177Sjhibbits ErrorIsrCB(p_Fm); 3720296177Sjhibbits return E_OK; 3721296177Sjhibbits} 3722296177Sjhibbits 3723296177Sjhibbitst_Error FM_SetPortsBandwidth(t_Handle h_Fm, t_FmPortsBandwidthParams *p_PortsBandwidth) 3724296177Sjhibbits{ 3725296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3726296177Sjhibbits int i; 3727296177Sjhibbits uint8_t sum; 3728296177Sjhibbits uint8_t hardwarePortId; 3729296177Sjhibbits uint32_t tmpRegs[8] = {0,0,0,0,0,0,0,0}; 3730296177Sjhibbits uint8_t relativePortId, shift, weight, maxPercent = 0; 3731296177Sjhibbits 3732296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3733296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 3734296177Sjhibbits 3735296177Sjhibbits /* check that all ports add up to 100% */ 3736296177Sjhibbits sum = 0; 3737296177Sjhibbits for (i=0;i<p_PortsBandwidth->numOfPorts;i++) 3738296177Sjhibbits sum +=p_PortsBandwidth->portsBandwidths[i].bandwidth; 3739296177Sjhibbits if (sum != 100) 3740296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Sum of ports bandwidth differ from 100%")); 3741296177Sjhibbits 3742296177Sjhibbits /* find highest precent */ 3743296177Sjhibbits for (i=0;i<p_PortsBandwidth->numOfPorts;i++) 3744296177Sjhibbits { 3745296177Sjhibbits if (p_PortsBandwidth->portsBandwidths[i].bandwidth > maxPercent) 3746296177Sjhibbits maxPercent = p_PortsBandwidth->portsBandwidths[i].bandwidth; 3747296177Sjhibbits } 3748296177Sjhibbits 3749296177Sjhibbits /* calculate weight for each port */ 3750296177Sjhibbits for (i=0;i<p_PortsBandwidth->numOfPorts;i++) 3751296177Sjhibbits { 3752296177Sjhibbits weight = (uint8_t)((p_PortsBandwidth->portsBandwidths[i].bandwidth * PORT_MAX_WEIGHT )/maxPercent); 3753296177Sjhibbits /* we want even division between 1-to-PORT_MAX_WEIGHT. so if exect division 3754296177Sjhibbits is not reached, we round up so that: 3755296177Sjhibbits 0 until maxPercent/PORT_MAX_WEIGHT get "1" 3756296177Sjhibbits maxPercent/PORT_MAX_WEIGHT+1 until (maxPercent/PORT_MAX_WEIGHT)*2 get "2" 3757296177Sjhibbits ... 3758296177Sjhibbits maxPercent - maxPercent/PORT_MAX_WEIGHT until maxPercent get "PORT_MAX_WEIGHT: */ 3759296177Sjhibbits if ((uint8_t)((p_PortsBandwidth->portsBandwidths[i].bandwidth * PORT_MAX_WEIGHT ) % maxPercent)) 3760296177Sjhibbits weight++; 3761296177Sjhibbits 3762296177Sjhibbits /* find the location of this port within the register */ 3763296177Sjhibbits SW_PORT_ID_TO_HW_PORT_ID(hardwarePortId, 3764296177Sjhibbits p_PortsBandwidth->portsBandwidths[i].type, 3765296177Sjhibbits p_PortsBandwidth->portsBandwidths[i].relativePortId); 3766296177Sjhibbits relativePortId = (uint8_t)(hardwarePortId % 8); 3767296177Sjhibbits shift = (uint8_t)(32-4*(relativePortId+1)); 3768296177Sjhibbits 3769296177Sjhibbits 3770296177Sjhibbits if(weight > 1) 3771296177Sjhibbits /* Add this port to tmpReg */ 3772296177Sjhibbits /* (each 8 ports result in one register)*/ 3773296177Sjhibbits tmpRegs[hardwarePortId/8] |= ((weight-1) << shift); 3774296177Sjhibbits } 3775296177Sjhibbits 3776296177Sjhibbits for(i=0;i<8;i++) 3777296177Sjhibbits if(tmpRegs[i]) 3778296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_arb[i], tmpRegs[i]); 3779296177Sjhibbits 3780296177Sjhibbits return E_OK; 3781296177Sjhibbits} 3782296177Sjhibbits 3783296177Sjhibbitst_Error FM_EnableRamsEcc(t_Handle h_Fm) 3784296177Sjhibbits{ 3785296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3786296177Sjhibbits uint32_t tmpReg; 3787296177Sjhibbits 3788296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3789296177Sjhibbits 3790296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 3791296177Sjhibbits { 3792296177Sjhibbits t_FmIpcMsg msg; 3793296177Sjhibbits t_Error err; 3794296177Sjhibbits 3795296177Sjhibbits memset(&msg, 0, sizeof(msg)); 3796296177Sjhibbits msg.msgId = FM_ENABLE_RAM_ECC; 3797296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 3798296177Sjhibbits (uint8_t*)&msg, 3799296177Sjhibbits sizeof(msg.msgId), 3800296177Sjhibbits NULL, 3801296177Sjhibbits NULL, 3802296177Sjhibbits NULL, 3803296177Sjhibbits NULL)) != E_OK) 3804296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 3805296177Sjhibbits return E_OK; 3806296177Sjhibbits } 3807296177Sjhibbits 3808296177Sjhibbits if(!p_Fm->p_FmStateStruct->internalCall) 3809296177Sjhibbits p_Fm->p_FmStateStruct->explicitEnable = TRUE; 3810296177Sjhibbits p_Fm->p_FmStateStruct->internalCall = FALSE; 3811296177Sjhibbits 3812296177Sjhibbits if(p_Fm->p_FmStateStruct->ramsEccEnable) 3813296177Sjhibbits return E_OK; 3814296177Sjhibbits else 3815296177Sjhibbits { 3816296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmrcr); 3817296177Sjhibbits if(tmpReg & FPM_RAM_CTL_RAMS_ECC_EN_SRC_SEL) 3818296177Sjhibbits { 3819296177Sjhibbits DBG(WARNING, ("Rams ECC is configured to be controlled through JTAG")); 3820296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, tmpReg | FPM_RAM_CTL_IRAM_ECC_EN); 3821296177Sjhibbits } 3822296177Sjhibbits else 3823296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, tmpReg | (FPM_RAM_CTL_RAMS_ECC_EN | FPM_RAM_CTL_IRAM_ECC_EN)); 3824296177Sjhibbits p_Fm->p_FmStateStruct->ramsEccEnable = TRUE; 3825296177Sjhibbits } 3826296177Sjhibbits 3827296177Sjhibbits return E_OK; 3828296177Sjhibbits} 3829296177Sjhibbits 3830296177Sjhibbitst_Error FM_DisableRamsEcc(t_Handle h_Fm) 3831296177Sjhibbits{ 3832296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3833296177Sjhibbits uint32_t tmpReg; 3834296177Sjhibbits bool explicitDisable = FALSE; 3835296177Sjhibbits 3836296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3837296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_HANDLE); 3838296177Sjhibbits 3839296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 3840296177Sjhibbits { 3841296177Sjhibbits t_Error err; 3842296177Sjhibbits t_FmIpcMsg msg; 3843296177Sjhibbits 3844296177Sjhibbits memset(&msg, 0, sizeof(msg)); 3845296177Sjhibbits msg.msgId = FM_DISABLE_RAM_ECC; 3846296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 3847296177Sjhibbits (uint8_t*)&msg, 3848296177Sjhibbits sizeof(msg.msgId), 3849296177Sjhibbits NULL, 3850296177Sjhibbits NULL, 3851296177Sjhibbits NULL, 3852296177Sjhibbits NULL)) != E_OK) 3853296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 3854296177Sjhibbits return E_OK; 3855296177Sjhibbits } 3856296177Sjhibbits 3857296177Sjhibbits if(!p_Fm->p_FmStateStruct->internalCall) 3858296177Sjhibbits explicitDisable = TRUE; 3859296177Sjhibbits p_Fm->p_FmStateStruct->internalCall = FALSE; 3860296177Sjhibbits 3861296177Sjhibbits /* if rams are already disabled, or if rams were explicitly enabled and are 3862296177Sjhibbits currently called indirectly (not explicitly), ignore this call. */ 3863296177Sjhibbits if(!p_Fm->p_FmStateStruct->ramsEccEnable || (p_Fm->p_FmStateStruct->explicitEnable && !explicitDisable)) 3864296177Sjhibbits return E_OK; 3865296177Sjhibbits else 3866296177Sjhibbits { 3867296177Sjhibbits if(p_Fm->p_FmStateStruct->explicitEnable) 3868296177Sjhibbits /* This is the case were both explicit are TRUE. 3869296177Sjhibbits Turn off this flag for cases were following ramsEnable 3870296177Sjhibbits routines are called */ 3871296177Sjhibbits p_Fm->p_FmStateStruct->explicitEnable = FALSE; 3872296177Sjhibbits 3873296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmrcr); 3874296177Sjhibbits if(tmpReg & FPM_RAM_CTL_RAMS_ECC_EN_SRC_SEL) 3875296177Sjhibbits { 3876296177Sjhibbits DBG(WARNING, ("Rams ECC is configured to be controlled through JTAG")); 3877296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, tmpReg & ~FPM_RAM_CTL_IRAM_ECC_EN); 3878296177Sjhibbits } 3879296177Sjhibbits else 3880296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrcr, tmpReg & ~(FPM_RAM_CTL_RAMS_ECC_EN | FPM_RAM_CTL_IRAM_ECC_EN)); 3881296177Sjhibbits p_Fm->p_FmStateStruct->ramsEccEnable = FALSE; 3882296177Sjhibbits } 3883296177Sjhibbits 3884296177Sjhibbits return E_OK; 3885296177Sjhibbits} 3886296177Sjhibbits 3887296177Sjhibbitst_Error FM_SetException(t_Handle h_Fm, e_FmExceptions exception, bool enable) 3888296177Sjhibbits{ 3889296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 3890296177Sjhibbits uint32_t bitMask = 0; 3891296177Sjhibbits uint32_t tmpReg; 3892296177Sjhibbits 3893296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 3894296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 3895296177Sjhibbits 3896296177Sjhibbits GET_EXCEPTION_FLAG(bitMask, exception); 3897296177Sjhibbits if(bitMask) 3898296177Sjhibbits { 3899296177Sjhibbits if (enable) 3900296177Sjhibbits p_Fm->p_FmStateStruct->exceptions |= bitMask; 3901296177Sjhibbits else 3902296177Sjhibbits p_Fm->p_FmStateStruct->exceptions &= ~bitMask; 3903296177Sjhibbits 3904296177Sjhibbits switch(exception) 3905296177Sjhibbits { 3906296177Sjhibbits case(e_FM_EX_DMA_BUS_ERROR): 3907296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr); 3908296177Sjhibbits if(enable) 3909296177Sjhibbits tmpReg |= DMA_MODE_BER; 3910296177Sjhibbits else 3911296177Sjhibbits tmpReg &= ~DMA_MODE_BER; 3912296177Sjhibbits /* disable bus error */ 3913296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, tmpReg); 3914296177Sjhibbits break; 3915296177Sjhibbits case(e_FM_EX_DMA_READ_ECC): 3916296177Sjhibbits case(e_FM_EX_DMA_SYSTEM_WRITE_ECC): 3917296177Sjhibbits case(e_FM_EX_DMA_FM_WRITE_ECC): 3918296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr); 3919296177Sjhibbits if(enable) 3920296177Sjhibbits tmpReg |= DMA_MODE_ECC; 3921296177Sjhibbits else 3922296177Sjhibbits tmpReg &= ~DMA_MODE_ECC; 3923296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, tmpReg); 3924296177Sjhibbits break; 3925296177Sjhibbits case(e_FM_EX_FPM_STALL_ON_TASKS): 3926296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fpmem); 3927296177Sjhibbits if(enable) 3928296177Sjhibbits tmpReg |= FPM_EV_MASK_STALL_EN; 3929296177Sjhibbits else 3930296177Sjhibbits tmpReg &= ~FPM_EV_MASK_STALL_EN; 3931296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, tmpReg); 3932296177Sjhibbits break; 3933296177Sjhibbits case(e_FM_EX_FPM_SINGLE_ECC): 3934296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fpmem); 3935296177Sjhibbits if(enable) 3936296177Sjhibbits tmpReg |= FPM_EV_MASK_SINGLE_ECC_EN; 3937296177Sjhibbits else 3938296177Sjhibbits tmpReg &= ~FPM_EV_MASK_SINGLE_ECC_EN; 3939296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, tmpReg); 3940296177Sjhibbits break; 3941296177Sjhibbits case( e_FM_EX_FPM_DOUBLE_ECC): 3942296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fpmem); 3943296177Sjhibbits if(enable) 3944296177Sjhibbits tmpReg |= FPM_EV_MASK_DOUBLE_ECC_EN; 3945296177Sjhibbits else 3946296177Sjhibbits tmpReg &= ~FPM_EV_MASK_DOUBLE_ECC_EN; 3947296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, tmpReg); 3948296177Sjhibbits break; 3949296177Sjhibbits case( e_FM_EX_QMI_SINGLE_ECC): 3950296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_ien); 3951296177Sjhibbits if(enable) 3952296177Sjhibbits { 3953296177Sjhibbits#ifdef FM_QMI_NO_ECC_EXCEPTIONS 3954296177Sjhibbits t_FmRevisionInfo revInfo; 3955296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 3956296177Sjhibbits if (revInfo.majorRev == 4) 3957296177Sjhibbits { 3958296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_QMI_SINGLE_ECC")); 3959296177Sjhibbits return E_OK; 3960296177Sjhibbits } 3961296177Sjhibbits#endif /* FM_QMI_NO_ECC_EXCEPTIONS */ 3962296177Sjhibbits tmpReg |= QMI_INTR_EN_SINGLE_ECC; 3963296177Sjhibbits } 3964296177Sjhibbits else 3965296177Sjhibbits tmpReg &= ~QMI_INTR_EN_SINGLE_ECC; 3966296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_ien, tmpReg); 3967296177Sjhibbits break; 3968296177Sjhibbits case(e_FM_EX_QMI_DOUBLE_ECC): 3969296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien); 3970296177Sjhibbits if(enable) 3971296177Sjhibbits { 3972296177Sjhibbits#ifdef FM_QMI_NO_ECC_EXCEPTIONS 3973296177Sjhibbits t_FmRevisionInfo revInfo; 3974296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 3975296177Sjhibbits if (revInfo.majorRev == 4) 3976296177Sjhibbits { 3977296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_QMI_DOUBLE_ECC")); 3978296177Sjhibbits return E_OK; 3979296177Sjhibbits } 3980296177Sjhibbits#endif /* FM_QMI_NO_ECC_EXCEPTIONS */ 3981296177Sjhibbits tmpReg |= QMI_ERR_INTR_EN_DOUBLE_ECC; 3982296177Sjhibbits } 3983296177Sjhibbits else 3984296177Sjhibbits tmpReg &= ~QMI_ERR_INTR_EN_DOUBLE_ECC; 3985296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien, tmpReg); 3986296177Sjhibbits break; 3987296177Sjhibbits case(e_FM_EX_QMI_DEQ_FROM_UNKNOWN_PORTID): 3988296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien); 3989296177Sjhibbits if(enable) 3990296177Sjhibbits tmpReg |= QMI_ERR_INTR_EN_DEQ_FROM_DEF; 3991296177Sjhibbits else 3992296177Sjhibbits tmpReg &= ~QMI_ERR_INTR_EN_DEQ_FROM_DEF; 3993296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eien, tmpReg); 3994296177Sjhibbits break; 3995296177Sjhibbits case(e_FM_EX_BMI_LIST_RAM_ECC): 3996296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier); 3997296177Sjhibbits if(enable) 3998296177Sjhibbits { 3999296177Sjhibbits#ifdef FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 4000296177Sjhibbits t_FmRevisionInfo revInfo; 4001296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 4002296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 4003296177Sjhibbits { 4004296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_LIST_RAM_ECC")); 4005296177Sjhibbits return E_OK; 4006296177Sjhibbits } 4007296177Sjhibbits#endif /* FM_RAM_LIST_ERR_IRQ_ERRATA_FMAN8 */ 4008296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_LIST_RAM_ECC; 4009296177Sjhibbits } 4010296177Sjhibbits else 4011296177Sjhibbits tmpReg &= ~BMI_ERR_INTR_EN_LIST_RAM_ECC; 4012296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier, tmpReg); 4013296177Sjhibbits break; 4014296177Sjhibbits case(e_FM_EX_BMI_PIPELINE_ECC): 4015296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier); 4016296177Sjhibbits if(enable) 4017296177Sjhibbits { 4018296177Sjhibbits#ifdef FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 4019296177Sjhibbits t_FmRevisionInfo revInfo; 4020296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 4021296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 4022296177Sjhibbits { 4023296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_PIPELINE_ECCBMI_LIST_RAM_ECC")); 4024296177Sjhibbits return E_OK; 4025296177Sjhibbits } 4026296177Sjhibbits#endif /* FM_BMI_PIPELINE_ERR_IRQ_ERRATA_FMAN9 */ 4027296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_PIPELINE_ECC; 4028296177Sjhibbits } 4029296177Sjhibbits else 4030296177Sjhibbits tmpReg &= ~BMI_ERR_INTR_EN_PIPELINE_ECC; 4031296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier, tmpReg); 4032296177Sjhibbits break; 4033296177Sjhibbits case(e_FM_EX_BMI_STATISTICS_RAM_ECC): 4034296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier); 4035296177Sjhibbits if(enable) 4036296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_STATISTICS_RAM_ECC; 4037296177Sjhibbits else 4038296177Sjhibbits tmpReg &= ~BMI_ERR_INTR_EN_STATISTICS_RAM_ECC; 4039296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier, tmpReg); 4040296177Sjhibbits break; 4041296177Sjhibbits case(e_FM_EX_BMI_DISPATCH_RAM_ECC): 4042296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier); 4043296177Sjhibbits if(enable) 4044296177Sjhibbits { 4045296177Sjhibbits#ifdef FM_NO_DISPATCH_RAM_ECC 4046296177Sjhibbits t_FmRevisionInfo revInfo; 4047296177Sjhibbits FM_GetRevision(p_Fm, &revInfo); 4048296177Sjhibbits if (revInfo.majorRev != 4) 4049296177Sjhibbits { 4050296177Sjhibbits REPORT_ERROR(MINOR, E_NOT_SUPPORTED, ("e_FM_EX_BMI_DISPATCH_RAM_ECC")); 4051296177Sjhibbits return E_OK; 4052296177Sjhibbits } 4053296177Sjhibbits#endif /* FM_NO_DISPATCH_RAM_ECC */ 4054296177Sjhibbits tmpReg |= BMI_ERR_INTR_EN_DISPATCH_RAM_ECC; 4055296177Sjhibbits } 4056296177Sjhibbits else 4057296177Sjhibbits tmpReg &= ~BMI_ERR_INTR_EN_DISPATCH_RAM_ECC; 4058296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ier, tmpReg); 4059296177Sjhibbits break; 4060296177Sjhibbits case(e_FM_EX_IRAM_ECC): 4061296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmrie); 4062296177Sjhibbits if(enable) 4063296177Sjhibbits { 4064296177Sjhibbits /* enable ECC if not enabled */ 4065296177Sjhibbits FmEnableRamsEcc(p_Fm); 4066296177Sjhibbits /* enable ECC interrupts */ 4067296177Sjhibbits tmpReg |= FPM_IRAM_ECC_ERR_EX_EN; 4068296177Sjhibbits } 4069296177Sjhibbits else 4070296177Sjhibbits { 4071296177Sjhibbits /* ECC mechanism may be disabled, depending on driver status */ 4072296177Sjhibbits FmDisableRamsEcc(p_Fm); 4073296177Sjhibbits tmpReg &= ~FPM_IRAM_ECC_ERR_EX_EN; 4074296177Sjhibbits } 4075296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrie, tmpReg); 4076296177Sjhibbits break; 4077296177Sjhibbits 4078296177Sjhibbits case(e_FM_EX_MURAM_ECC): 4079296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fmrie); 4080296177Sjhibbits if(enable) 4081296177Sjhibbits { 4082296177Sjhibbits /* enable ECC if not enabled */ 4083296177Sjhibbits FmEnableRamsEcc(p_Fm); 4084296177Sjhibbits /* enable ECC interrupts */ 4085296177Sjhibbits tmpReg |= FPM_MURAM_ECC_ERR_EX_EN; 4086296177Sjhibbits } 4087296177Sjhibbits else 4088296177Sjhibbits { 4089296177Sjhibbits /* ECC mechanism may be disabled, depending on driver status */ 4090296177Sjhibbits FmDisableRamsEcc(p_Fm); 4091296177Sjhibbits tmpReg &= ~FPM_MURAM_ECC_ERR_EX_EN; 4092296177Sjhibbits } 4093296177Sjhibbits 4094296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fmrie, tmpReg); 4095296177Sjhibbits break; 4096296177Sjhibbits default: 4097296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_SELECTION, NO_MSG); 4098296177Sjhibbits } 4099296177Sjhibbits } 4100296177Sjhibbits else 4101296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception")); 4102296177Sjhibbits 4103296177Sjhibbits return E_OK; 4104296177Sjhibbits} 4105296177Sjhibbits 4106296177Sjhibbitst_Error FM_GetRevision(t_Handle h_Fm, t_FmRevisionInfo *p_FmRevisionInfo) 4107296177Sjhibbits{ 4108296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4109296177Sjhibbits uint32_t tmpReg; 4110296177Sjhibbits t_Error err; 4111296177Sjhibbits t_FmIpcMsg msg; 4112296177Sjhibbits t_FmIpcReply reply; 4113296177Sjhibbits uint32_t replyLength; 4114296177Sjhibbits t_FmIpcRevisionInfo ipcRevInfo; 4115296177Sjhibbits 4116296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 4117296177Sjhibbits 4118296177Sjhibbits if (p_Fm->guestId != NCSW_MASTER_ID) 4119296177Sjhibbits { 4120296177Sjhibbits memset(&msg, 0, sizeof(msg)); 4121296177Sjhibbits memset(&reply, 0, sizeof(reply)); 4122296177Sjhibbits msg.msgId = FM_GET_REV; 4123296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(t_FmRevisionInfo); 4124296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 4125296177Sjhibbits (uint8_t*)&msg, 4126296177Sjhibbits sizeof(msg.msgId), 4127296177Sjhibbits (uint8_t*)&reply, 4128296177Sjhibbits &replyLength, 4129296177Sjhibbits NULL, 4130296177Sjhibbits NULL)) != E_OK) 4131296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 4132296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(t_FmRevisionInfo))) 4133296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 4134296177Sjhibbits memcpy((uint8_t*)&ipcRevInfo, reply.replyBody, sizeof(t_FmRevisionInfo)); 4135296177Sjhibbits p_FmRevisionInfo->majorRev = ipcRevInfo.majorRev; 4136296177Sjhibbits p_FmRevisionInfo->minorRev = ipcRevInfo.minorRev; 4137296177Sjhibbits return (t_Error)(reply.error); 4138296177Sjhibbits } 4139296177Sjhibbits 4140296177Sjhibbits /* read revision register 1 */ 4141296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fm_ip_rev_1); 4142296177Sjhibbits p_FmRevisionInfo->majorRev = (uint8_t)((tmpReg & FPM_REV1_MAJOR_MASK) >> FPM_REV1_MAJOR_SHIFT); 4143296177Sjhibbits p_FmRevisionInfo->minorRev = (uint8_t)((tmpReg & FPM_REV1_MINOR_MASK) >> FPM_REV1_MINOR_SHIFT); 4144296177Sjhibbits 4145296177Sjhibbits return E_OK; 4146296177Sjhibbits} 4147296177Sjhibbits 4148296177Sjhibbitsuint32_t FM_GetCounter(t_Handle h_Fm, e_FmCounters counter) 4149296177Sjhibbits{ 4150296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4151296177Sjhibbits t_Error err; 4152296177Sjhibbits uint32_t counterValue; 4153296177Sjhibbits t_FmIpcMsg msg; 4154296177Sjhibbits t_FmIpcReply reply; 4155296177Sjhibbits uint32_t replyLength, outCounter; 4156296177Sjhibbits 4157296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Fm, E_INVALID_HANDLE, 0); 4158296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_Fm->p_FmDriverParam, E_INVALID_STATE, 0); 4159296177Sjhibbits 4160296177Sjhibbits 4161296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 4162296177Sjhibbits { 4163296177Sjhibbits memset(&msg, 0, sizeof(msg)); 4164296177Sjhibbits memset(&reply, 0, sizeof(reply)); 4165296177Sjhibbits msg.msgId = FM_GET_COUNTER; 4166296177Sjhibbits memcpy(msg.msgBody, (uint8_t *)&counter, sizeof(uint32_t)); 4167296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint32_t); 4168296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 4169296177Sjhibbits (uint8_t*)&msg, 4170296177Sjhibbits sizeof(msg.msgId) +sizeof(counterValue), 4171296177Sjhibbits (uint8_t*)&reply, 4172296177Sjhibbits &replyLength, 4173296177Sjhibbits NULL, 4174296177Sjhibbits NULL)) != E_OK) 4175296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4176296177Sjhibbits if(replyLength != (sizeof(uint32_t) + sizeof(uint32_t))) 4177296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 4178296177Sjhibbits memcpy((uint8_t*)&outCounter, reply.replyBody, sizeof(uint32_t)); 4179296177Sjhibbits 4180296177Sjhibbits return outCounter; 4181296177Sjhibbits } 4182296177Sjhibbits 4183296177Sjhibbits switch(counter) 4184296177Sjhibbits { 4185296177Sjhibbits case(e_FM_COUNTERS_ENQ_TOTAL_FRAME): 4186296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_etfc); 4187296177Sjhibbits case(e_FM_COUNTERS_DEQ_TOTAL_FRAME): 4188296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dtfc); 4189296177Sjhibbits case(e_FM_COUNTERS_DEQ_0): 4190296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc0); 4191296177Sjhibbits case(e_FM_COUNTERS_DEQ_1): 4192296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc1); 4193296177Sjhibbits case(e_FM_COUNTERS_DEQ_2): 4194296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc2); 4195296177Sjhibbits case(e_FM_COUNTERS_DEQ_3): 4196296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc3); 4197296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_DEFAULT): 4198296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dfdc); 4199296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_CONTEXT): 4200296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dfcc); 4201296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_FD): 4202296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dffc); 4203296177Sjhibbits case(e_FM_COUNTERS_DEQ_CONFIRM): 4204296177Sjhibbits return GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_dcc); 4205296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_ENTRY_FULL_REJECT): 4206296177Sjhibbits return GET_UINT32(p_Fm->p_FmDmaRegs->fmdmsefrc); 4207296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_QUEUE_FULL_REJECT): 4208296177Sjhibbits return GET_UINT32(p_Fm->p_FmDmaRegs->fmdmsqfrc); 4209296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_SYNC_REJECT): 4210296177Sjhibbits return GET_UINT32(p_Fm->p_FmDmaRegs->fmdmssrc); 4211296177Sjhibbits default: 4212296177Sjhibbits break; 4213296177Sjhibbits } 4214296177Sjhibbits /* should never get here */ 4215296177Sjhibbits ASSERT_COND(FALSE); 4216296177Sjhibbits 4217296177Sjhibbits return 0; 4218296177Sjhibbits} 4219296177Sjhibbits 4220296177Sjhibbitst_Error FM_ModifyCounter(t_Handle h_Fm, e_FmCounters counter, uint32_t val) 4221296177Sjhibbits{ 4222296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4223296177Sjhibbits 4224296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 4225296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4226296177Sjhibbits 4227296177Sjhibbits /* When applicable (when there is an 'enable counters' bit, 4228296177Sjhibbits check that counters are enabled */ 4229296177Sjhibbits switch(counter) 4230296177Sjhibbits { 4231296177Sjhibbits case(e_FM_COUNTERS_ENQ_TOTAL_FRAME): 4232296177Sjhibbits case(e_FM_COUNTERS_DEQ_TOTAL_FRAME): 4233296177Sjhibbits case(e_FM_COUNTERS_DEQ_0): 4234296177Sjhibbits case(e_FM_COUNTERS_DEQ_1): 4235296177Sjhibbits case(e_FM_COUNTERS_DEQ_2): 4236296177Sjhibbits case(e_FM_COUNTERS_DEQ_3): 4237296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_DEFAULT): 4238296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_CONTEXT): 4239296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_FD): 4240296177Sjhibbits case(e_FM_COUNTERS_DEQ_CONFIRM): 4241296177Sjhibbits if(!(GET_UINT32(p_Fm->p_FmQmiRegs->fmqm_gc) & QMI_CFG_EN_COUNTERS)) 4242296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 4243296177Sjhibbits break; 4244296177Sjhibbits default: 4245296177Sjhibbits break; 4246296177Sjhibbits } 4247296177Sjhibbits 4248296177Sjhibbits /* Set counter */ 4249296177Sjhibbits switch(counter) 4250296177Sjhibbits { 4251296177Sjhibbits case(e_FM_COUNTERS_ENQ_TOTAL_FRAME): 4252296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_etfc, val); 4253296177Sjhibbits break; 4254296177Sjhibbits case(e_FM_COUNTERS_DEQ_TOTAL_FRAME): 4255296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dtfc, val); 4256296177Sjhibbits break; 4257296177Sjhibbits case(e_FM_COUNTERS_DEQ_0): 4258296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc0, val); 4259296177Sjhibbits break; 4260296177Sjhibbits case(e_FM_COUNTERS_DEQ_1): 4261296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc1, val); 4262296177Sjhibbits break; 4263296177Sjhibbits case(e_FM_COUNTERS_DEQ_2): 4264296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc2, val); 4265296177Sjhibbits break; 4266296177Sjhibbits case(e_FM_COUNTERS_DEQ_3): 4267296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dc3, val); 4268296177Sjhibbits break; 4269296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_DEFAULT): 4270296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dfdc, val); 4271296177Sjhibbits break; 4272296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_CONTEXT): 4273296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dfcc, val); 4274296177Sjhibbits break; 4275296177Sjhibbits case(e_FM_COUNTERS_DEQ_FROM_FD): 4276296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dffc, val); 4277296177Sjhibbits break; 4278296177Sjhibbits case(e_FM_COUNTERS_DEQ_CONFIRM): 4279296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_dcc, val); 4280296177Sjhibbits break; 4281296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_ENTRY_FULL_REJECT): 4282296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmsefrc, val); 4283296177Sjhibbits break; 4284296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_QUEUE_FULL_REJECT): 4285296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmsqfrc, val); 4286296177Sjhibbits break; 4287296177Sjhibbits case(e_FM_COUNTERS_SEMAPHOR_SYNC_REJECT): 4288296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmssrc, val); 4289296177Sjhibbits break; 4290296177Sjhibbits default: 4291296177Sjhibbits break; 4292296177Sjhibbits } 4293296177Sjhibbits 4294296177Sjhibbits return E_OK; 4295296177Sjhibbits} 4296296177Sjhibbits 4297296177Sjhibbitsvoid FM_SetDmaEmergency(t_Handle h_Fm, e_FmDmaMuramPort muramPort, bool enable) 4298296177Sjhibbits{ 4299296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4300296177Sjhibbits uint32_t bitMask; 4301296177Sjhibbits 4302296177Sjhibbits SANITY_CHECK_RETURN(p_Fm, E_INVALID_HANDLE); 4303296177Sjhibbits SANITY_CHECK_RETURN(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4304296177Sjhibbits 4305296177Sjhibbits bitMask = (uint32_t)((muramPort==e_FM_DMA_MURAM_PORT_WRITE) ? DMA_MODE_EMERGENCY_WRITE : DMA_MODE_EMERGENCY_READ); 4306296177Sjhibbits 4307296177Sjhibbits if(enable) 4308296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr) | bitMask); 4309296177Sjhibbits else /* disable */ 4310296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr) & ~bitMask); 4311296177Sjhibbits 4312296177Sjhibbits return; 4313296177Sjhibbits} 4314296177Sjhibbits 4315296177Sjhibbitsvoid FM_SetDmaExtBusPri(t_Handle h_Fm, e_FmDmaExtBusPri pri) 4316296177Sjhibbits{ 4317296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4318296177Sjhibbits 4319296177Sjhibbits SANITY_CHECK_RETURN(p_Fm, E_INVALID_HANDLE); 4320296177Sjhibbits SANITY_CHECK_RETURN(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4321296177Sjhibbits 4322296177Sjhibbits WRITE_UINT32(p_Fm->p_FmDmaRegs->fmdmmr, GET_UINT32(p_Fm->p_FmDmaRegs->fmdmmr) | ((uint32_t)pri << DMA_MODE_BUS_PRI_SHIFT) ); 4323296177Sjhibbits 4324296177Sjhibbits return; 4325296177Sjhibbits} 4326296177Sjhibbits 4327296177Sjhibbitsvoid FM_GetDmaStatus(t_Handle h_Fm, t_FmDmaStatus *p_FmDmaStatus) 4328296177Sjhibbits{ 4329296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4330296177Sjhibbits uint32_t tmpReg; 4331296177Sjhibbits t_Error err; 4332296177Sjhibbits t_FmIpcMsg msg; 4333296177Sjhibbits t_FmIpcReply reply; 4334296177Sjhibbits uint32_t replyLength; 4335296177Sjhibbits t_FmIpcDmaStatus ipcDmaStatus; 4336296177Sjhibbits 4337296177Sjhibbits SANITY_CHECK_RETURN(p_Fm, E_INVALID_HANDLE); 4338296177Sjhibbits SANITY_CHECK_RETURN(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4339296177Sjhibbits 4340296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 4341296177Sjhibbits { 4342296177Sjhibbits memset(&msg, 0, sizeof(msg)); 4343296177Sjhibbits memset(&reply, 0, sizeof(reply)); 4344296177Sjhibbits msg.msgId = FM_DMA_STAT; 4345296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(t_FmIpcDmaStatus); 4346296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 4347296177Sjhibbits (uint8_t*)&msg, 4348296177Sjhibbits sizeof(msg.msgId), 4349296177Sjhibbits (uint8_t*)&reply, 4350296177Sjhibbits &replyLength, 4351296177Sjhibbits NULL, 4352296177Sjhibbits NULL)) != E_OK) 4353296177Sjhibbits { 4354296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 4355296177Sjhibbits return; 4356296177Sjhibbits } 4357296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(t_FmIpcDmaStatus))) 4358296177Sjhibbits { 4359296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 4360296177Sjhibbits return; 4361296177Sjhibbits } 4362296177Sjhibbits memcpy((uint8_t*)&ipcDmaStatus, reply.replyBody, sizeof(t_FmIpcDmaStatus)); 4363296177Sjhibbits 4364296177Sjhibbits p_FmDmaStatus->cmqNotEmpty = (bool)ipcDmaStatus.boolCmqNotEmpty; /**< Command queue is not empty */ 4365296177Sjhibbits p_FmDmaStatus->busError = (bool)ipcDmaStatus.boolBusError; /**< Bus error occurred */ 4366296177Sjhibbits p_FmDmaStatus->readBufEccError = (bool)ipcDmaStatus.boolReadBufEccError; /**< Double ECC error on buffer Read */ 4367296177Sjhibbits p_FmDmaStatus->writeBufEccSysError =(bool)ipcDmaStatus.boolWriteBufEccSysError; /**< Double ECC error on buffer write from system side */ 4368296177Sjhibbits p_FmDmaStatus->writeBufEccFmError = (bool)ipcDmaStatus.boolWriteBufEccFmError; /**< Double ECC error on buffer write from FM side */ 4369296177Sjhibbits return; 4370296177Sjhibbits } 4371296177Sjhibbits 4372296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmDmaRegs->fmdmsr); 4373296177Sjhibbits 4374296177Sjhibbits p_FmDmaStatus->cmqNotEmpty = (bool)(tmpReg & DMA_STATUS_CMD_QUEUE_NOT_EMPTY); 4375296177Sjhibbits p_FmDmaStatus->busError = (bool)(tmpReg & DMA_STATUS_BUS_ERR); 4376296177Sjhibbits p_FmDmaStatus->readBufEccError = (bool)(tmpReg & DMA_STATUS_READ_ECC); 4377296177Sjhibbits p_FmDmaStatus->writeBufEccSysError = (bool)(tmpReg & DMA_STATUS_SYSTEM_WRITE_ECC); 4378296177Sjhibbits p_FmDmaStatus->writeBufEccFmError = (bool)(tmpReg & DMA_STATUS_FM_WRITE_ECC); 4379296177Sjhibbits return; 4380296177Sjhibbits} 4381296177Sjhibbits 4382296177Sjhibbitst_Error FM_ForceIntr (t_Handle h_Fm, e_FmExceptions exception) 4383296177Sjhibbits{ 4384296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4385296177Sjhibbits 4386296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 4387296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4388296177Sjhibbits 4389296177Sjhibbits switch(exception) 4390296177Sjhibbits { 4391296177Sjhibbits case e_FM_EX_QMI_DEQ_FROM_UNKNOWN_PORTID: 4392296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_DEQ_FROM_UNKNOWN_PORTID)) 4393296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4394296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eif, QMI_ERR_INTR_EN_DEQ_FROM_DEF); 4395296177Sjhibbits break; 4396296177Sjhibbits case e_FM_EX_QMI_SINGLE_ECC: 4397296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_SINGLE_ECC)) 4398296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4399296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_if, QMI_INTR_EN_SINGLE_ECC); 4400296177Sjhibbits break; 4401296177Sjhibbits case e_FM_EX_QMI_DOUBLE_ECC: 4402296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_QMI_DOUBLE_ECC)) 4403296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4404296177Sjhibbits WRITE_UINT32(p_Fm->p_FmQmiRegs->fmqm_eif, QMI_ERR_INTR_EN_DOUBLE_ECC); 4405296177Sjhibbits break; 4406296177Sjhibbits case e_FM_EX_BMI_LIST_RAM_ECC: 4407296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_LIST_RAM_ECC)) 4408296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4409296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr, BMI_ERR_INTR_EN_LIST_RAM_ECC); 4410296177Sjhibbits break; 4411296177Sjhibbits case e_FM_EX_BMI_PIPELINE_ECC: 4412296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_PIPELINE_ECC)) 4413296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4414296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr, BMI_ERR_INTR_EN_PIPELINE_ECC); 4415296177Sjhibbits break; 4416296177Sjhibbits case e_FM_EX_BMI_STATISTICS_RAM_ECC: 4417296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_STATISTICS_RAM_ECC)) 4418296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4419296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr, BMI_ERR_INTR_EN_STATISTICS_RAM_ECC); 4420296177Sjhibbits break; 4421296177Sjhibbits case e_FM_EX_BMI_DISPATCH_RAM_ECC: 4422296177Sjhibbits if (!(p_Fm->p_FmStateStruct->exceptions & FM_EX_BMI_DISPATCH_RAM_ECC)) 4423296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); 4424296177Sjhibbits WRITE_UINT32(p_Fm->p_FmBmiRegs->fmbm_ifr, BMI_ERR_INTR_EN_DISPATCH_RAM_ECC); 4425296177Sjhibbits break; 4426296177Sjhibbits default: 4427296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception may not be forced")); 4428296177Sjhibbits } 4429296177Sjhibbits 4430296177Sjhibbits return E_OK; 4431296177Sjhibbits} 4432296177Sjhibbits 4433296177Sjhibbitsvoid FM_Resume(t_Handle h_Fm) 4434296177Sjhibbits{ 4435296177Sjhibbits t_Fm *p_Fm = (t_Fm*)h_Fm; 4436296177Sjhibbits uint32_t tmpReg; 4437296177Sjhibbits 4438296177Sjhibbits SANITY_CHECK_RETURN(p_Fm, E_INVALID_HANDLE); 4439296177Sjhibbits SANITY_CHECK_RETURN(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4440296177Sjhibbits 4441296177Sjhibbits if (p_Fm->guestId == NCSW_MASTER_ID) 4442296177Sjhibbits { 4443296177Sjhibbits tmpReg = GET_UINT32(p_Fm->p_FmFpmRegs->fpmem); 4444296177Sjhibbits /* clear tmpReg event bits in order not to clear standing events */ 4445296177Sjhibbits tmpReg &= ~(FPM_EV_MASK_DOUBLE_ECC | FPM_EV_MASK_STALL | FPM_EV_MASK_SINGLE_ECC); 4446296177Sjhibbits WRITE_UINT32(p_Fm->p_FmFpmRegs->fpmem, tmpReg | FPM_EV_MASK_RELEASE_FM); 4447296177Sjhibbits } 4448296177Sjhibbits else 4449296177Sjhibbits ASSERT_COND(0); /* TODO */ 4450296177Sjhibbits} 4451296177Sjhibbits 4452296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 4453296177Sjhibbitst_Error FM_DumpRegs(t_Handle h_Fm) 4454296177Sjhibbits{ 4455296177Sjhibbits t_Fm *p_Fm = (t_Fm *)h_Fm; 4456296177Sjhibbits uint8_t i = 0; 4457296177Sjhibbits t_Error err; 4458296177Sjhibbits t_FmIpcMsg msg; 4459296177Sjhibbits 4460296177Sjhibbits DECLARE_DUMP; 4461296177Sjhibbits 4462296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE); 4463296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE); 4464296177Sjhibbits 4465296177Sjhibbits 4466296177Sjhibbits if(p_Fm->guestId != NCSW_MASTER_ID) 4467296177Sjhibbits { 4468296177Sjhibbits memset(&msg, 0, sizeof(msg)); 4469296177Sjhibbits msg.msgId = FM_DUMP_REGS; 4470296177Sjhibbits if ((err = XX_IpcSendMessage(p_Fm->h_IpcSessions[0], 4471296177Sjhibbits (uint8_t*)&msg, 4472296177Sjhibbits sizeof(msg.msgId), 4473296177Sjhibbits NULL, 4474296177Sjhibbits NULL, 4475296177Sjhibbits NULL, 4476296177Sjhibbits NULL)) != E_OK) 4477296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 4478296177Sjhibbits return E_OK; 4479296177Sjhibbits } 4480296177Sjhibbits 4481296177Sjhibbits 4482296177Sjhibbits DUMP_SUBTITLE(("\n")); 4483296177Sjhibbits 4484296177Sjhibbits DUMP_TITLE(p_Fm->p_FmFpmRegs, ("FmFpmRegs Regs")); 4485296177Sjhibbits 4486296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmtnc); 4487296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmpr); 4488296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,brkc); 4489296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmflc); 4490296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmdis1); 4491296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmdis2); 4492296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmepi); 4493296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmrie); 4494296177Sjhibbits 4495296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfpfcev, ("fmfpfcev")); 4496296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 4) 4497296177Sjhibbits { 4498296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfpfcev[i], sizeof(uint32_t)); 4499296177Sjhibbits } 4500296177Sjhibbits 4501296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfpfcee, ("fmfpfcee")); 4502296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 4) 4503296177Sjhibbits { 4504296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfpfcee[i], sizeof(uint32_t)); 4505296177Sjhibbits } 4506296177Sjhibbits 4507296177Sjhibbits DUMP_SUBTITLE(("\n")); 4508296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmtsc1); 4509296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmtsc2); 4510296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmtsp); 4511296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmtsf); 4512296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmrcr); 4513296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmextc); 4514296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmext1); 4515296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmext2); 4516296177Sjhibbits 4517296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmFpmRegs->fpmdrd, ("fpmdrd")); 4518296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 16) 4519296177Sjhibbits { 4520296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fpmdrd[i], sizeof(uint32_t)); 4521296177Sjhibbits } 4522296177Sjhibbits 4523296177Sjhibbits DUMP_SUBTITLE(("\n")); 4524296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmdra); 4525296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fm_ip_rev_1); 4526296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fm_ip_rev_2); 4527296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmrstc); 4528296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmcld); 4529296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fmnpi); 4530296177Sjhibbits DUMP_VAR(p_Fm->p_FmFpmRegs,fpmem); 4531296177Sjhibbits 4532296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmFpmRegs->fpmcev, ("fpmcev")); 4533296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 4) 4534296177Sjhibbits { 4535296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fpmcev[i], sizeof(uint32_t)); 4536296177Sjhibbits } 4537296177Sjhibbits 4538296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfp_ps, ("fmfp_ps")); 4539296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 64) 4540296177Sjhibbits { 4541296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_ps[i], sizeof(uint32_t)); 4542296177Sjhibbits } 4543296177Sjhibbits 4544296177Sjhibbits 4545296177Sjhibbits DUMP_TITLE(p_Fm->p_FmDmaRegs, ("p_FmDmaRegs Regs")); 4546296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsr); 4547296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmmr); 4548296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtr); 4549296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmhy); 4550296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsetr); 4551296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtah); 4552296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtal); 4553296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtcid); 4554296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmra); 4555296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmrd); 4556296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmwcr); 4557296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmebcr); 4558296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmccqdr); 4559296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmccqvr1); 4560296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmccqvr2); 4561296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmcqvr3); 4562296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmcqvr4); 4563296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmcqvr5); 4564296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsefrc); 4565296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsqfrc); 4566296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmssrc); 4567296177Sjhibbits DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmdcr); 4568296177Sjhibbits 4569296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmDmaRegs->fmdmplr, ("fmdmplr")); 4570296177Sjhibbits 4571296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_SIZE_OF_LIODN_TABLE/2) 4572296177Sjhibbits { 4573296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmDmaRegs->fmdmplr[i], sizeof(uint32_t)); 4574296177Sjhibbits } 4575296177Sjhibbits 4576296177Sjhibbits DUMP_TITLE(p_Fm->p_FmBmiRegs, ("p_FmBmiRegs COMMON Regs")); 4577296177Sjhibbits DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_init); 4578296177Sjhibbits DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_cfg1); 4579296177Sjhibbits DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_cfg2); 4580296177Sjhibbits DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_ievr); 4581296177Sjhibbits DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_ier); 4582296177Sjhibbits 4583296177Sjhibbits DUMP_TITLE(&p_Fm->p_FmBmiRegs->fmbm_arb, ("fmbm_arb")); 4584296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, 8) 4585296177Sjhibbits { 4586296177Sjhibbits DUMP_MEMORY(&p_Fm->p_FmBmiRegs->fmbm_arb[i], sizeof(uint32_t)); 4587296177Sjhibbits } 4588296177Sjhibbits 4589296177Sjhibbits 4590296177Sjhibbits DUMP_TITLE(p_Fm->p_FmQmiRegs, ("p_FmQmiRegs COMMON Regs")); 4591296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_gc); 4592296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eie); 4593296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eien); 4594296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eif); 4595296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_ie); 4596296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_ien); 4597296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_if); 4598296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_gs); 4599296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_ts); 4600296177Sjhibbits DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_etfc); 4601296177Sjhibbits 4602296177Sjhibbits return E_OK; 4603296177Sjhibbits} 4604296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && ... */ 4605296177Sjhibbits 4606