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#include "std_ext.h" 34296177Sjhibbits#include "error_ext.h" 35296177Sjhibbits#include "sprint_ext.h" 36296177Sjhibbits#include "string_ext.h" 37296177Sjhibbits 38296177Sjhibbits#include "fm_common.h" 39296177Sjhibbits#include "fm_hc.h" 40296177Sjhibbits 41296177Sjhibbits 42296177Sjhibbits#define HC_HCOR_OPCODE_PLCR_PRFL 0x0 43296177Sjhibbits#define HC_HCOR_OPCODE_KG_SCM 0x1 44296177Sjhibbits#define HC_HCOR_OPCODE_SYNC 0x2 45296177Sjhibbits#define HC_HCOR_OPCODE_CC 0x3 46296177Sjhibbits#define HC_HCOR_OPCODE_CC_CAPWAP_REASSM_TIMEOUT 0x5 47296177Sjhibbits 48296177Sjhibbits#define HC_HCOR_GBL 0x20000000 49296177Sjhibbits 50296177Sjhibbits#define SIZE_OF_HC_FRAME_PORT_REGS (sizeof(t_HcFrame)-sizeof(t_FmPcdKgInterModuleSchemeRegs)+sizeof(t_FmPcdKgPortRegs)) 51296177Sjhibbits#define SIZE_OF_HC_FRAME_SCHEME_REGS sizeof(t_HcFrame) 52296177Sjhibbits#define SIZE_OF_HC_FRAME_PROFILES_REGS (sizeof(t_HcFrame)-sizeof(t_FmPcdKgInterModuleSchemeRegs)+sizeof(t_FmPcdPlcrInterModuleProfileRegs)) 53296177Sjhibbits#define SIZE_OF_HC_FRAME_PROFILE_CNT (sizeof(t_HcFrame)-sizeof(t_FmPcdPlcrInterModuleProfileRegs)+sizeof(uint32_t)) 54296177Sjhibbits#define SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC 16 55296177Sjhibbits 56296177Sjhibbits#define BUILD_FD(len) \ 57296177Sjhibbitsdo { \ 58296177Sjhibbits memset(&fmFd, 0, sizeof(t_DpaaFD)); \ 59296177Sjhibbits DPAA_FD_SET_ADDR(&fmFd, p_HcFrame); \ 60296177Sjhibbits DPAA_FD_SET_OFFSET(&fmFd, 0); \ 61296177Sjhibbits DPAA_FD_SET_LENGTH(&fmFd, len); \ 62296177Sjhibbits} while (0) 63296177Sjhibbits 64296177Sjhibbits 65296177Sjhibbits#if defined(__MWERKS__) && !defined(__GNUC__) 66296177Sjhibbits#pragma pack(push,1) 67296177Sjhibbits#endif /* defined(__MWERKS__) && ... */ 68296177Sjhibbits#define MEM_MAP_START 69296177Sjhibbits 70296177Sjhibbits/**************************************************************************//** 71296177Sjhibbits @Description PCD KG scheme registers 72296177Sjhibbits*//***************************************************************************/ 73296177Sjhibbitstypedef _Packed struct t_FmPcdKgSchemeRegsWithoutCounter { 74296177Sjhibbits volatile uint32_t kgse_mode; /**< MODE */ 75296177Sjhibbits volatile uint32_t kgse_ekfc; /**< Extract Known Fields Command */ 76296177Sjhibbits volatile uint32_t kgse_ekdv; /**< Extract Known Default Value */ 77296177Sjhibbits volatile uint32_t kgse_bmch; /**< Bit Mask Command High */ 78296177Sjhibbits volatile uint32_t kgse_bmcl; /**< Bit Mask Command Low */ 79296177Sjhibbits volatile uint32_t kgse_fqb; /**< Frame Queue Base */ 80296177Sjhibbits volatile uint32_t kgse_hc; /**< Hash Command */ 81296177Sjhibbits volatile uint32_t kgse_ppc; /**< Policer Profile Command */ 82296177Sjhibbits volatile uint32_t kgse_gec[FM_PCD_KG_NUM_OF_GENERIC_REGS]; 83296177Sjhibbits /**< Generic Extract Command */ 84296177Sjhibbits volatile uint32_t kgse_dv0; /**< KeyGen Scheme Entry Default Value 0 */ 85296177Sjhibbits volatile uint32_t kgse_dv1; /**< KeyGen Scheme Entry Default Value 1 */ 86296177Sjhibbits volatile uint32_t kgse_ccbs; /**< KeyGen Scheme Entry Coarse Classification Bit*/ 87296177Sjhibbits volatile uint32_t kgse_mv; /**< KeyGen Scheme Entry Match vector */ 88296177Sjhibbits} _PackedType t_FmPcdKgSchemeRegsWithoutCounter; 89296177Sjhibbits 90296177Sjhibbitstypedef _Packed struct t_FmPcdKgPortRegs { 91296177Sjhibbits volatile uint32_t spReg; 92296177Sjhibbits volatile uint32_t cppReg; 93296177Sjhibbits} _PackedType t_FmPcdKgPortRegs; 94296177Sjhibbits 95296177Sjhibbitstypedef _Packed struct t_HcFrame { 96296177Sjhibbits volatile uint32_t opcode; 97296177Sjhibbits volatile uint32_t actionReg; 98296177Sjhibbits volatile uint32_t extraReg; 99296177Sjhibbits volatile uint32_t commandSequence; 100296177Sjhibbits union { 101296177Sjhibbits t_FmPcdKgInterModuleSchemeRegs schemeRegs; 102296177Sjhibbits t_FmPcdKgInterModuleSchemeRegs schemeRegsWithoutCounter; 103296177Sjhibbits t_FmPcdPlcrInterModuleProfileRegs profileRegs; 104296177Sjhibbits volatile uint32_t singleRegForWrite; /* for writing SP, CPP, profile counter */ 105296177Sjhibbits t_FmPcdKgPortRegs portRegsForRead; 106296177Sjhibbits volatile uint32_t clsPlanEntries[CLS_PLAN_NUM_PER_GRP]; 107296177Sjhibbits t_FmPcdCcCapwapReassmTimeoutParams ccCapwapReassmTimeout; 108296177Sjhibbits } hcSpecificData; 109296177Sjhibbits} _PackedType t_HcFrame; 110296177Sjhibbits 111296177Sjhibbits#define MEM_MAP_END 112296177Sjhibbits#if defined(__MWERKS__) && !defined(__GNUC__) 113296177Sjhibbits#pragma pack(pop) 114296177Sjhibbits#endif /* defined(__MWERKS__) && ... */ 115296177Sjhibbits 116296177Sjhibbits 117296177Sjhibbitstypedef struct t_FmHc { 118296177Sjhibbits t_Handle h_FmPcd; 119296177Sjhibbits t_Handle h_HcPortDev; 120296177Sjhibbits t_FmPcdQmEnqueueCallback *f_QmEnqueue; /**< A callback for enqueuing frames to the QM */ 121296177Sjhibbits t_Handle h_QmArg; /**< A handle to the QM module */ 122296177Sjhibbits uint8_t padTill16; 123296177Sjhibbits 124296177Sjhibbits uint32_t seqNum; 125296177Sjhibbits volatile bool wait[32]; 126296177Sjhibbits} t_FmHc; 127296177Sjhibbits 128296177Sjhibbits 129296177Sjhibbitsstatic __inline__ t_Error EnQFrm(t_FmHc *p_FmHc, t_DpaaFD *p_FmFd, volatile uint32_t *p_SeqNum) 130296177Sjhibbits{ 131296177Sjhibbits t_Error err = E_OK; 132296177Sjhibbits uint32_t savedSeqNum; 133296177Sjhibbits uint32_t intFlags; 134296177Sjhibbits uint32_t timeout=100; 135296177Sjhibbits 136296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 137296177Sjhibbits *p_SeqNum = p_FmHc->seqNum; 138296177Sjhibbits savedSeqNum = p_FmHc->seqNum; 139296177Sjhibbits p_FmHc->seqNum = (uint32_t)((p_FmHc->seqNum+1)%32); 140296177Sjhibbits ASSERT_COND(!p_FmHc->wait[savedSeqNum]); 141296177Sjhibbits p_FmHc->wait[savedSeqNum] = TRUE; 142296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 143296177Sjhibbits DBG(TRACE, ("Send Hc, SeqNum %d, FD@0x%x, fd offset 0x%x", 144296177Sjhibbits savedSeqNum,DPAA_FD_GET_ADDR(p_FmFd),DPAA_FD_GET_OFFSET(p_FmFd))); 145296177Sjhibbits err = p_FmHc->f_QmEnqueue(p_FmHc->h_QmArg, (void *)p_FmFd); 146296177Sjhibbits if(err) 147296177Sjhibbits RETURN_ERROR(MINOR, err, ("HC enqueue failed")); 148296177Sjhibbits 149296177Sjhibbits while (p_FmHc->wait[savedSeqNum] && --timeout) 150296177Sjhibbits XX_UDelay(100); 151296177Sjhibbits 152296177Sjhibbits if (!timeout) 153296177Sjhibbits RETURN_ERROR(MINOR, E_TIMEOUT, ("HC Callback, timeout exceeded")); 154296177Sjhibbits 155296177Sjhibbits return err; 156296177Sjhibbits} 157296177Sjhibbits 158296177Sjhibbitsstatic t_Error CcHcDoDynamicChange(t_FmHc *p_FmHc, t_Handle p_OldPointer, t_Handle p_NewPointer) 159296177Sjhibbits{ 160296177Sjhibbits t_HcFrame *p_HcFrame; 161296177Sjhibbits t_DpaaFD fmFd; 162296177Sjhibbits t_Error err = E_OK; 163296177Sjhibbits 164296177Sjhibbits ASSERT_COND(p_FmHc); 165296177Sjhibbits 166296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 167296177Sjhibbits if (!p_HcFrame) 168296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 169296177Sjhibbits 170296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 171296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_CC); 172296177Sjhibbits p_HcFrame->actionReg = FmPcdCcGetNodeAddrOffsetFromNodeInfo(p_FmHc->h_FmPcd, p_NewPointer); 173296177Sjhibbits if(p_HcFrame->actionReg == (uint32_t)ILLEGAL_BASE) 174296177Sjhibbits { 175296177Sjhibbits XX_FreeSmart(p_HcFrame); 176296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Something wrong with base address")); 177296177Sjhibbits } 178296177Sjhibbits 179296177Sjhibbits p_HcFrame->actionReg |= 0xc0000000; 180296177Sjhibbits p_HcFrame->extraReg = FmPcdCcGetNodeAddrOffsetFromNodeInfo(p_FmHc->h_FmPcd, p_OldPointer); 181296177Sjhibbits if(p_HcFrame->extraReg == (uint32_t)ILLEGAL_BASE) 182296177Sjhibbits { 183296177Sjhibbits XX_FreeSmart(p_HcFrame); 184296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Something wrong with base address")); 185296177Sjhibbits } 186296177Sjhibbits 187296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 188296177Sjhibbits 189296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 190296177Sjhibbits { 191296177Sjhibbits XX_FreeSmart(p_HcFrame); 192296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 193296177Sjhibbits } 194296177Sjhibbits 195296177Sjhibbits XX_FreeSmart(p_HcFrame); 196296177Sjhibbits 197296177Sjhibbits return E_OK; 198296177Sjhibbits} 199296177Sjhibbits 200296177Sjhibbitsstatic t_Error HcDynamicChange(t_FmHc *p_FmHc,t_List *h_OldPointersLst, t_List *h_NewPointersLst, t_Handle *h_Params) 201296177Sjhibbits{ 202296177Sjhibbits 203296177Sjhibbits t_List *p_PosOld, *p_PosNew; 204296177Sjhibbits uint16_t i = 0; 205296177Sjhibbits t_Error err = E_OK; 206296177Sjhibbits uint8_t numOfModifiedPtr; 207296177Sjhibbits 208296177Sjhibbits SANITY_CHECK_RETURN_ERROR((LIST_NumOfObjs(h_NewPointersLst) == LIST_NumOfObjs(h_OldPointersLst)),E_INVALID_STATE); 209296177Sjhibbits 210296177Sjhibbits numOfModifiedPtr = (uint8_t)LIST_NumOfObjs(h_NewPointersLst); 211296177Sjhibbits p_PosNew = NCSW_LIST_FIRST(h_NewPointersLst); 212296177Sjhibbits p_PosOld = NCSW_LIST_FIRST(h_OldPointersLst); 213296177Sjhibbits for(i = 0; i < numOfModifiedPtr; i++) 214296177Sjhibbits { 215296177Sjhibbits err = CcHcDoDynamicChange(p_FmHc, p_PosOld, p_PosNew); 216296177Sjhibbits if(err) 217296177Sjhibbits { 218296177Sjhibbits FmPcdCcReleaseModifiedDataStructure(p_FmHc->h_FmPcd, h_OldPointersLst, h_NewPointersLst, i, h_Params); 219296177Sjhibbits RETURN_ERROR(MAJOR, err, ("For part of nodes changes are done - situation is danger")); 220296177Sjhibbits } 221296177Sjhibbits p_PosNew = NCSW_LIST_NEXT(p_PosNew); 222296177Sjhibbits p_PosOld = NCSW_LIST_NEXT(p_PosOld); 223296177Sjhibbits } 224296177Sjhibbits 225296177Sjhibbits err = FmPcdCcReleaseModifiedDataStructure(p_FmHc->h_FmPcd, h_OldPointersLst, h_NewPointersLst, i, h_Params); 226296177Sjhibbits if(err) 227296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 228296177Sjhibbits 229296177Sjhibbits return E_OK; 230296177Sjhibbits} 231296177Sjhibbits 232296177Sjhibbits 233296177Sjhibbitst_Handle FmHcConfigAndInit(t_FmHcParams *p_FmHcParams) 234296177Sjhibbits{ 235296177Sjhibbits t_FmHc *p_FmHc; 236296177Sjhibbits t_FmPortParams fmPortParam; 237296177Sjhibbits t_Error err = E_OK; 238296177Sjhibbits 239296177Sjhibbits p_FmHc = (t_FmHc *)XX_Malloc(sizeof(t_FmHc)); 240296177Sjhibbits if (!p_FmHc) 241296177Sjhibbits { 242296177Sjhibbits REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC obj")); 243296177Sjhibbits return NULL; 244296177Sjhibbits } 245296177Sjhibbits memset(p_FmHc,0,sizeof(t_FmHc)); 246296177Sjhibbits 247296177Sjhibbits p_FmHc->h_FmPcd = p_FmHcParams->h_FmPcd; 248296177Sjhibbits p_FmHc->f_QmEnqueue = p_FmHcParams->params.f_QmEnqueue; 249296177Sjhibbits p_FmHc->h_QmArg = p_FmHcParams->params.h_QmArg; 250296177Sjhibbits 251296177Sjhibbits if (!FmIsMaster(p_FmHcParams->h_Fm)) 252296177Sjhibbits return (t_Handle)p_FmHc; 253296177Sjhibbits 254296177Sjhibbits/* 255296177SjhibbitsTKT056919 - axi12axi0 can hang if read request follows the single byte write on the very next cycle 256296177SjhibbitsTKT038900 - FM dma lockup occur due to AXI slave protocol violation 257296177Sjhibbits*/ 258296177Sjhibbits#ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 259296177Sjhibbits p_FmHc->padTill16 = 16 - (sizeof(t_FmHc) % 16); 260296177Sjhibbits#endif /* FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 */ 261296177Sjhibbits memset(&fmPortParam, 0, sizeof(fmPortParam)); 262296177Sjhibbits fmPortParam.baseAddr = p_FmHcParams->params.portBaseAddr; 263296177Sjhibbits fmPortParam.portType = e_FM_PORT_TYPE_OH_HOST_COMMAND; 264296177Sjhibbits fmPortParam.portId = p_FmHcParams->params.portId; 265296177Sjhibbits fmPortParam.liodnBase = p_FmHcParams->params.liodnBase; 266296177Sjhibbits fmPortParam.h_Fm = p_FmHcParams->h_Fm; 267296177Sjhibbits 268296177Sjhibbits fmPortParam.specificParams.nonRxParams.errFqid = p_FmHcParams->params.errFqid; 269296177Sjhibbits fmPortParam.specificParams.nonRxParams.dfltFqid = p_FmHcParams->params.confFqid; 270296177Sjhibbits fmPortParam.specificParams.nonRxParams.qmChannel = p_FmHcParams->params.qmChannel; 271296177Sjhibbits 272296177Sjhibbits p_FmHc->h_HcPortDev = FM_PORT_Config(&fmPortParam); 273296177Sjhibbits if(!p_FmHc->h_HcPortDev) 274296177Sjhibbits { 275296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_HANDLE, ("FM HC port!")); 276296177Sjhibbits XX_Free(p_FmHc); 277296177Sjhibbits return NULL; 278296177Sjhibbits } 279296177Sjhibbits 280296177Sjhibbits /* final init */ 281296177Sjhibbits if ((err = FM_PORT_Init(p_FmHc->h_HcPortDev)) != E_OK) 282296177Sjhibbits { 283296177Sjhibbits REPORT_ERROR(MAJOR, err, ("FM HC port!")); 284296177Sjhibbits FmHcFree(p_FmHc); 285296177Sjhibbits return NULL; 286296177Sjhibbits } 287296177Sjhibbits 288296177Sjhibbits if ((err = FM_PORT_Enable(p_FmHc->h_HcPortDev)) != E_OK) 289296177Sjhibbits { 290296177Sjhibbits REPORT_ERROR(MAJOR, err, ("FM HC port!")); 291296177Sjhibbits FmHcFree(p_FmHc); 292296177Sjhibbits return NULL; 293296177Sjhibbits } 294296177Sjhibbits 295296177Sjhibbits return (t_Handle)p_FmHc; 296296177Sjhibbits} 297296177Sjhibbits 298296177Sjhibbitsvoid FmHcFree(t_Handle h_FmHc) 299296177Sjhibbits{ 300296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 301296177Sjhibbits 302296177Sjhibbits if (!p_FmHc) 303296177Sjhibbits return; 304296177Sjhibbits 305296177Sjhibbits if (p_FmHc->h_HcPortDev) 306296177Sjhibbits FM_PORT_Free(p_FmHc->h_HcPortDev); 307296177Sjhibbits 308296177Sjhibbits XX_Free(p_FmHc); 309296177Sjhibbits} 310296177Sjhibbits 311296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 312296177Sjhibbitst_Error FmHcDumpRegs(t_Handle h_FmHc) 313296177Sjhibbits{ 314296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 315296177Sjhibbits 316296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmHc, E_INVALID_HANDLE); 317296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmHc->h_HcPortDev, E_INVALID_HANDLE); 318296177Sjhibbits 319296177Sjhibbits return FM_PORT_DumpRegs(p_FmHc->h_HcPortDev); 320296177Sjhibbits 321296177Sjhibbits} 322296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && ... */ 323296177Sjhibbits 324296177Sjhibbitsvoid FmHcTxConf(t_Handle h_FmHc, t_DpaaFD *p_Fd) 325296177Sjhibbits{ 326296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 327296177Sjhibbits t_HcFrame *p_HcFrame; 328296177Sjhibbits uint32_t intFlags; 329296177Sjhibbits 330296177Sjhibbits ASSERT_COND(p_FmHc); 331296177Sjhibbits 332296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 333296177Sjhibbits p_HcFrame = (t_HcFrame *)PTR_MOVE(DPAA_FD_GET_ADDR(p_Fd), DPAA_FD_GET_OFFSET(p_Fd)); 334296177Sjhibbits 335296177Sjhibbits DBG(TRACE, ("Hc Conf, SeqNum %d, FD@0x%x, fd offset 0x%x", 336296177Sjhibbits p_HcFrame->commandSequence, DPAA_FD_GET_ADDR(p_Fd), DPAA_FD_GET_OFFSET(p_Fd))); 337296177Sjhibbits 338296177Sjhibbits if (!(p_FmHc->wait[p_HcFrame->commandSequence])) 339296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_FRAME, ("Not an Host-Command frame received!")); 340296177Sjhibbits else 341296177Sjhibbits p_FmHc->wait[p_HcFrame->commandSequence] = FALSE; 342296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 343296177Sjhibbits} 344296177Sjhibbits 345296177Sjhibbitst_Handle FmHcPcdKgSetScheme(t_Handle h_FmHc, t_FmPcdKgSchemeParams *p_Scheme) 346296177Sjhibbits{ 347296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 348296177Sjhibbits t_Error err = E_OK; 349296177Sjhibbits t_FmPcdKgInterModuleSchemeRegs schemeRegs; 350296177Sjhibbits t_HcFrame *p_HcFrame; 351296177Sjhibbits t_DpaaFD fmFd; 352296177Sjhibbits uint32_t intFlags; 353296177Sjhibbits uint8_t physicalSchemeId, relativeSchemeId; 354296177Sjhibbits 355296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 356296177Sjhibbits if (!p_HcFrame) 357296177Sjhibbits { 358296177Sjhibbits REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 359296177Sjhibbits return NULL; 360296177Sjhibbits } 361296177Sjhibbits 362296177Sjhibbits if(!p_Scheme->modify) 363296177Sjhibbits { 364296177Sjhibbits /* check that schemeId is in range */ 365296177Sjhibbits if(p_Scheme->id.relativeSchemeId >= FmPcdKgGetNumOfPartitionSchemes(p_FmHc->h_FmPcd)) 366296177Sjhibbits { 367296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_IN_RANGE, ("Scheme is out of range")); 368296177Sjhibbits XX_FreeSmart(p_HcFrame); 369296177Sjhibbits return NULL; 370296177Sjhibbits } 371296177Sjhibbits 372296177Sjhibbits relativeSchemeId = p_Scheme->id.relativeSchemeId; 373296177Sjhibbits 374296177Sjhibbits if (FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, FALSE)) 375296177Sjhibbits { 376296177Sjhibbits XX_FreeSmart(p_HcFrame); 377296177Sjhibbits return NULL; 378296177Sjhibbits } 379296177Sjhibbits 380296177Sjhibbits physicalSchemeId = FmPcdKgGetPhysicalSchemeId(p_FmHc->h_FmPcd, relativeSchemeId); 381296177Sjhibbits 382296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 383296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 384296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); 385296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 386296177Sjhibbits 387296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 388296177Sjhibbits 389296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 390296177Sjhibbits { 391296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 392296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 393296177Sjhibbits XX_FreeSmart(p_HcFrame); 394296177Sjhibbits return NULL; 395296177Sjhibbits } 396296177Sjhibbits 397296177Sjhibbits /* check if this scheme is already used */ 398296177Sjhibbits if (FmPcdKgHwSchemeIsValid(p_HcFrame->hcSpecificData.schemeRegs.kgse_mode)) 399296177Sjhibbits { 400296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 401296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("Scheme is already used")); 402296177Sjhibbits XX_FreeSmart(p_HcFrame); 403296177Sjhibbits return NULL; 404296177Sjhibbits } 405296177Sjhibbits } 406296177Sjhibbits else 407296177Sjhibbits { 408296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 409296177Sjhibbits physicalSchemeId = (uint8_t)(PTR_TO_UINT(p_Scheme->id.h_Scheme)-1); 410296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); 411296177Sjhibbits if( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 412296177Sjhibbits { 413296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 414296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 415296177Sjhibbits XX_FreeSmart(p_HcFrame); 416296177Sjhibbits return NULL; 417296177Sjhibbits } 418296177Sjhibbits err = FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, TRUE); 419296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 420296177Sjhibbits if (err) 421296177Sjhibbits { 422296177Sjhibbits XX_FreeSmart(p_HcFrame); 423296177Sjhibbits return NULL; 424296177Sjhibbits } 425296177Sjhibbits } 426296177Sjhibbits 427296177Sjhibbits err = FmPcdKgBuildScheme(p_FmHc->h_FmPcd, p_Scheme, &schemeRegs); 428296177Sjhibbits if(err) 429296177Sjhibbits { 430296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 431296177Sjhibbits REPORT_ERROR(MAJOR, err, NO_MSG); 432296177Sjhibbits XX_FreeSmart(p_HcFrame); 433296177Sjhibbits return NULL; 434296177Sjhibbits } 435296177Sjhibbits 436296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 437296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 438296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, p_Scheme->schemeCounter.update); 439296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 440296177Sjhibbits memcpy(&p_HcFrame->hcSpecificData.schemeRegs, &schemeRegs, sizeof(t_FmPcdKgInterModuleSchemeRegs)); 441296177Sjhibbits if(!p_Scheme->schemeCounter.update) 442296177Sjhibbits { 443296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_dv0 = schemeRegs.kgse_dv0; 444296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_dv1 = schemeRegs.kgse_dv1; 445296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_ccbs = schemeRegs.kgse_ccbs; 446296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_mv = schemeRegs.kgse_mv; 447296177Sjhibbits } 448296177Sjhibbits 449296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 450296177Sjhibbits 451296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 452296177Sjhibbits { 453296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 454296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 455296177Sjhibbits XX_FreeSmart(p_HcFrame); 456296177Sjhibbits return NULL; 457296177Sjhibbits } 458296177Sjhibbits 459296177Sjhibbits FmPcdKgValidateSchemeSw(p_FmHc->h_FmPcd, relativeSchemeId); 460296177Sjhibbits 461296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 462296177Sjhibbits 463296177Sjhibbits XX_FreeSmart(p_HcFrame); 464296177Sjhibbits 465296177Sjhibbits return (t_Handle)(UINT_TO_PTR(physicalSchemeId + 1)); 466296177Sjhibbits} 467296177Sjhibbits 468296177Sjhibbitst_Error FmHcPcdKgDeleteScheme(t_Handle h_FmHc, t_Handle h_Scheme) 469296177Sjhibbits{ 470296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 471296177Sjhibbits t_Error err = E_OK; 472296177Sjhibbits t_HcFrame *p_HcFrame; 473296177Sjhibbits t_DpaaFD fmFd; 474296177Sjhibbits uint8_t relativeSchemeId; 475296177Sjhibbits uint8_t physicalSchemeId = (uint8_t)(PTR_TO_UINT(h_Scheme)-1); 476296177Sjhibbits 477296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); 478296177Sjhibbits 479296177Sjhibbits if ((err = FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, FALSE)) != E_OK) 480296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 481296177Sjhibbits 482296177Sjhibbits if(relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 483296177Sjhibbits { 484296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 485296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 486296177Sjhibbits } 487296177Sjhibbits 488296177Sjhibbits err = FmPcdKgCheckInvalidateSchemeSw(p_FmHc->h_FmPcd, relativeSchemeId); 489296177Sjhibbits if (err) 490296177Sjhibbits { 491296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 492296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 493296177Sjhibbits } 494296177Sjhibbits 495296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 496296177Sjhibbits if (!p_HcFrame) 497296177Sjhibbits { 498296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 499296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 500296177Sjhibbits } 501296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 502296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 503296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, TRUE); 504296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 505296177Sjhibbits memset(&p_HcFrame->hcSpecificData.schemeRegs, 0, sizeof(t_FmPcdKgInterModuleSchemeRegs)); 506296177Sjhibbits 507296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 508296177Sjhibbits 509296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 510296177Sjhibbits { 511296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 512296177Sjhibbits XX_FreeSmart(p_HcFrame); 513296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 514296177Sjhibbits } 515296177Sjhibbits 516296177Sjhibbits FmPcdKgInvalidateSchemeSw(p_FmHc->h_FmPcd, relativeSchemeId); 517296177Sjhibbits 518296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 519296177Sjhibbits 520296177Sjhibbits XX_FreeSmart(p_HcFrame); 521296177Sjhibbits 522296177Sjhibbits return E_OK; 523296177Sjhibbits} 524296177Sjhibbits 525296177Sjhibbitst_Error FmHcPcdKgCcGetSetParams(t_Handle h_FmHc, t_Handle h_Scheme, uint32_t requiredAction) 526296177Sjhibbits{ 527296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 528296177Sjhibbits t_Error err = E_OK; 529296177Sjhibbits t_HcFrame *p_HcFrame; 530296177Sjhibbits t_DpaaFD fmFd; 531296177Sjhibbits uint8_t relativeSchemeId; 532296177Sjhibbits uint8_t physicalSchemeId = (uint8_t)(PTR_TO_UINT(h_Scheme)-1); 533296177Sjhibbits uint32_t tmpReg32 = 0; 534296177Sjhibbits 535296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); 536296177Sjhibbits if( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 537296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 538296177Sjhibbits 539296177Sjhibbits if (FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, FALSE)) 540296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Lock of the scheme FAILED")); 541296177Sjhibbits 542296177Sjhibbits if(!FmPcdKgGetPointedOwners(p_FmHc->h_FmPcd, relativeSchemeId) || 543296177Sjhibbits !(FmPcdKgGetRequiredAction(p_FmHc->h_FmPcd, relativeSchemeId) & requiredAction)) 544296177Sjhibbits { 545296177Sjhibbits 546296177Sjhibbits if(requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) 547296177Sjhibbits { 548296177Sjhibbits if((FmPcdKgGetNextEngine(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_DONE) && (FmPcdKgGetDoneAction(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_ENQ_FRAME)) 549296177Sjhibbits 550296177Sjhibbits { 551296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 552296177Sjhibbits if (!p_HcFrame) 553296177Sjhibbits { 554296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 555296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 556296177Sjhibbits } 557296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 558296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 559296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); 560296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 561296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 562296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 563296177Sjhibbits { 564296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 565296177Sjhibbits XX_FreeSmart(p_HcFrame); 566296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 567296177Sjhibbits } 568296177Sjhibbits 569296177Sjhibbits /* check if this scheme is already used */ 570296177Sjhibbits if (!FmPcdKgHwSchemeIsValid(p_HcFrame->hcSpecificData.schemeRegs.kgse_mode)) 571296177Sjhibbits { 572296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 573296177Sjhibbits XX_FreeSmart(p_HcFrame); 574296177Sjhibbits RETURN_ERROR(MAJOR, E_ALREADY_EXISTS, ("Scheme is already used")); 575296177Sjhibbits } 576296177Sjhibbits tmpReg32 = p_HcFrame->hcSpecificData.schemeRegs.kgse_mode; 577296177Sjhibbits 578296177Sjhibbits ASSERT_COND(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)); 579296177Sjhibbits 580296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_mode = tmpReg32 | NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; 581296177Sjhibbits 582296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 583296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, FALSE); 584296177Sjhibbits p_HcFrame->extraReg = 0x80000000; 585296177Sjhibbits 586296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 587296177Sjhibbits 588296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 589296177Sjhibbits { 590296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 591296177Sjhibbits XX_FreeSmart(p_HcFrame); 592296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 593296177Sjhibbits } 594296177Sjhibbits 595296177Sjhibbits XX_FreeSmart(p_HcFrame); 596296177Sjhibbits } 597296177Sjhibbits else if (FmPcdKgGetNextEngine(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_PLCR) 598296177Sjhibbits { 599296177Sjhibbits 600296177Sjhibbits if((FmPcdKgIsDirectPlcr(p_FmHc->h_FmPcd, relativeSchemeId) == FALSE) || 601296177Sjhibbits (FmPcdKgIsDistrOnPlcrProfile(p_FmHc->h_FmPcd, relativeSchemeId) == TRUE)) 602296177Sjhibbits { 603296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 604296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("In this situation PP can not be with distribution and has to be shared")); 605296177Sjhibbits } 606296177Sjhibbits err = FmPcdPlcrCcGetSetParams(p_FmHc->h_FmPcd, FmPcdKgGetRelativeProfileId(p_FmHc->h_FmPcd, relativeSchemeId), requiredAction); 607296177Sjhibbits if(err) 608296177Sjhibbits { 609296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 610296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 611296177Sjhibbits } 612296177Sjhibbits } 613296177Sjhibbits } 614296177Sjhibbits } 615296177Sjhibbits 616296177Sjhibbits FmPcdKgUpatePointedOwner(p_FmHc->h_FmPcd, relativeSchemeId,TRUE); 617296177Sjhibbits FmPcdKgUpdateRequiredAction(p_FmHc->h_FmPcd, relativeSchemeId,requiredAction); 618296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 619296177Sjhibbits 620296177Sjhibbits return E_OK; 621296177Sjhibbits} 622296177Sjhibbits 623296177Sjhibbitsuint32_t FmHcPcdKgGetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme) 624296177Sjhibbits{ 625296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 626296177Sjhibbits t_Error err = E_OK; 627296177Sjhibbits t_HcFrame *p_HcFrame; 628296177Sjhibbits t_DpaaFD fmFd; 629296177Sjhibbits uint32_t retVal; 630296177Sjhibbits uint8_t relativeSchemeId; 631296177Sjhibbits uint8_t physicalSchemeId = (uint8_t)(PTR_TO_UINT(h_Scheme)-1); 632296177Sjhibbits 633296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); 634296177Sjhibbits if( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 635296177Sjhibbits { 636296177Sjhibbits REPORT_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 637296177Sjhibbits return 0; 638296177Sjhibbits } 639296177Sjhibbits 640296177Sjhibbits if ((err = FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, FALSE)) != E_OK) 641296177Sjhibbits { 642296177Sjhibbits REPORT_ERROR(MAJOR, err, ("Scheme lock")); 643296177Sjhibbits return 0; 644296177Sjhibbits } 645296177Sjhibbits 646296177Sjhibbits /* first read scheme and check that it is valid */ 647296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 648296177Sjhibbits if (!p_HcFrame) 649296177Sjhibbits { 650296177Sjhibbits REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 651296177Sjhibbits return 0; 652296177Sjhibbits } 653296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 654296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 655296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); 656296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 657296177Sjhibbits 658296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 659296177Sjhibbits 660296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 661296177Sjhibbits { 662296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 663296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 664296177Sjhibbits XX_FreeSmart(p_HcFrame); 665296177Sjhibbits return 0; 666296177Sjhibbits } 667296177Sjhibbits 668296177Sjhibbits if (!FmPcdKgHwSchemeIsValid(p_HcFrame->hcSpecificData.schemeRegs.kgse_mode)) 669296177Sjhibbits { 670296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("Scheme is invalid")); 671296177Sjhibbits XX_FreeSmart(p_HcFrame); 672296177Sjhibbits return 0; 673296177Sjhibbits } 674296177Sjhibbits 675296177Sjhibbits retVal = p_HcFrame->hcSpecificData.schemeRegs.kgse_spc; 676296177Sjhibbits 677296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 678296177Sjhibbits 679296177Sjhibbits XX_FreeSmart(p_HcFrame); 680296177Sjhibbits 681296177Sjhibbits return retVal; 682296177Sjhibbits} 683296177Sjhibbits 684296177Sjhibbitst_Error FmHcPcdKgSetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme, uint32_t value) 685296177Sjhibbits{ 686296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 687296177Sjhibbits t_Error err = E_OK; 688296177Sjhibbits t_HcFrame *p_HcFrame; 689296177Sjhibbits t_DpaaFD fmFd; 690296177Sjhibbits uint8_t relativeSchemeId, physicalSchemeId = (uint8_t)(PTR_TO_UINT(h_Scheme)-1); 691296177Sjhibbits 692296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); 693296177Sjhibbits if( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 694296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 695296177Sjhibbits 696296177Sjhibbits if ((err = FmPcdKgSchemeTryLock(p_FmHc->h_FmPcd, relativeSchemeId, FALSE)) != E_OK) 697296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 698296177Sjhibbits 699296177Sjhibbits /* first read scheme and check that it is valid */ 700296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 701296177Sjhibbits if (!p_HcFrame) 702296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 703296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 704296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 705296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); 706296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 707296177Sjhibbits 708296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 709296177Sjhibbits 710296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 711296177Sjhibbits { 712296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 713296177Sjhibbits XX_FreeSmart(p_HcFrame); 714296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 715296177Sjhibbits } 716296177Sjhibbits 717296177Sjhibbits /* check that scheme is valid */ 718296177Sjhibbits if (!FmPcdKgHwSchemeIsValid(p_HcFrame->hcSpecificData.schemeRegs.kgse_mode)) 719296177Sjhibbits { 720296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 721296177Sjhibbits XX_FreeSmart(p_HcFrame); 722296177Sjhibbits RETURN_ERROR(MAJOR, E_ALREADY_EXISTS, ("Scheme is invalid")); 723296177Sjhibbits } 724296177Sjhibbits 725296177Sjhibbits /* Write scheme back, with modified counter */ 726296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 727296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, TRUE); 728296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 729296177Sjhibbits /* write counter */ 730296177Sjhibbits p_HcFrame->hcSpecificData.schemeRegs.kgse_spc = value; 731296177Sjhibbits 732296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 733296177Sjhibbits 734296177Sjhibbits err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence); 735296177Sjhibbits 736296177Sjhibbits FmPcdKgReleaseSchemeLock(p_FmHc->h_FmPcd, relativeSchemeId); 737296177Sjhibbits XX_FreeSmart(p_HcFrame); 738296177Sjhibbits 739296177Sjhibbits return err; 740296177Sjhibbits} 741296177Sjhibbits 742296177Sjhibbitst_Error FmHcPcdKgSetClsPlan(t_Handle h_FmHc, t_FmPcdKgInterModuleClsPlanSet *p_Set) 743296177Sjhibbits{ 744296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 745296177Sjhibbits t_HcFrame *p_HcFrame; 746296177Sjhibbits t_DpaaFD fmFd; 747296177Sjhibbits uint32_t i; 748296177Sjhibbits t_Error err = E_OK; 749296177Sjhibbits 750296177Sjhibbits ASSERT_COND(p_FmHc); 751296177Sjhibbits 752296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 753296177Sjhibbits if (!p_HcFrame) 754296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 755296177Sjhibbits 756296177Sjhibbits for(i=p_Set->baseEntry;i<p_Set->baseEntry+p_Set->numOfClsPlanEntries;i+=8) 757296177Sjhibbits { 758296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 759296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 760296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWriteClsPlanBlockActionReg((uint8_t)(i / CLS_PLAN_NUM_PER_GRP)); 761296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 762296177Sjhibbits memcpy((void*)&p_HcFrame->hcSpecificData.clsPlanEntries, (void *)&p_Set->vectors[i-p_Set->baseEntry], CLS_PLAN_NUM_PER_GRP*sizeof(uint32_t)); 763296177Sjhibbits 764296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 765296177Sjhibbits 766296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 767296177Sjhibbits { 768296177Sjhibbits XX_FreeSmart(p_HcFrame); 769296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 770296177Sjhibbits } 771296177Sjhibbits } 772296177Sjhibbits XX_FreeSmart(p_HcFrame); 773296177Sjhibbits 774296177Sjhibbits return err; 775296177Sjhibbits} 776296177Sjhibbits 777296177Sjhibbitst_Error FmHcPcdKgDeleteClsPlan(t_Handle h_FmHc, uint8_t grpId) 778296177Sjhibbits{ 779296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 780296177Sjhibbits t_FmPcdKgInterModuleClsPlanSet *p_ClsPlanSet; 781296177Sjhibbits 782296177Sjhibbits /* clear clsPlan entries in memory */ 783296177Sjhibbits p_ClsPlanSet = (t_FmPcdKgInterModuleClsPlanSet *)XX_Malloc(sizeof(t_FmPcdKgInterModuleClsPlanSet)); 784296177Sjhibbits if (!p_ClsPlanSet) 785296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("memory allocation failed for p_ClsPlanSetd")); 786296177Sjhibbits memset(p_ClsPlanSet, 0, sizeof(t_FmPcdKgInterModuleClsPlanSet)); 787296177Sjhibbits 788296177Sjhibbits p_ClsPlanSet->baseEntry = FmPcdKgGetClsPlanGrpBase(p_FmHc->h_FmPcd, grpId); 789296177Sjhibbits p_ClsPlanSet->numOfClsPlanEntries = FmPcdKgGetClsPlanGrpSize(p_FmHc->h_FmPcd, grpId); 790296177Sjhibbits ASSERT_COND(p_ClsPlanSet->numOfClsPlanEntries <= FM_PCD_MAX_NUM_OF_CLS_PLANS); 791296177Sjhibbits 792296177Sjhibbits if (FmHcPcdKgSetClsPlan(p_FmHc, p_ClsPlanSet) != E_OK) 793296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 794296177Sjhibbits XX_Free(p_ClsPlanSet); 795296177Sjhibbits 796296177Sjhibbits FmPcdKgDestroyClsPlanGrp(p_FmHc->h_FmPcd, grpId); 797296177Sjhibbits 798296177Sjhibbits return E_OK; 799296177Sjhibbits} 800296177Sjhibbits 801296177Sjhibbitst_Error FmHcPcdCcCapwapTimeoutReassm(t_Handle h_FmHc, t_FmPcdCcCapwapReassmTimeoutParams *p_CcCapwapReassmTimeoutParams ) 802296177Sjhibbits{ 803296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 804296177Sjhibbits t_HcFrame *p_HcFrame; 805296177Sjhibbits uint32_t intFlags; 806296177Sjhibbits t_DpaaFD fmFd; 807296177Sjhibbits t_Error err; 808296177Sjhibbits 809296177Sjhibbits SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 810296177Sjhibbits 811296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 812296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 813296177Sjhibbits if (!p_HcFrame) 814296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 815296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 816296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_CC_CAPWAP_REASSM_TIMEOUT); 817296177Sjhibbits memcpy(&p_HcFrame->hcSpecificData.ccCapwapReassmTimeout, p_CcCapwapReassmTimeoutParams, sizeof(t_FmPcdCcCapwapReassmTimeoutParams)); 818296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 819296177Sjhibbits 820296177Sjhibbits err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence); 821296177Sjhibbits 822296177Sjhibbits XX_FreeSmart(p_HcFrame); 823296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 824296177Sjhibbits return err; 825296177Sjhibbits} 826296177Sjhibbits 827296177Sjhibbits 828296177Sjhibbitst_Error FmHcPcdPlcrCcGetSetParams(t_Handle h_FmHc,uint16_t absoluteProfileId, uint32_t requiredAction) 829296177Sjhibbits{ 830296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 831296177Sjhibbits t_HcFrame *p_HcFrame; 832296177Sjhibbits t_DpaaFD fmFd; 833296177Sjhibbits t_Error err; 834296177Sjhibbits uint32_t tmpReg32 = 0; 835296177Sjhibbits uint32_t requiredActionTmp, pointedOwnersTmp; 836296177Sjhibbits 837296177Sjhibbits SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 838296177Sjhibbits 839296177Sjhibbits if (absoluteProfileId >= FM_PCD_PLCR_NUM_ENTRIES) 840296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE,("Policer profile out of range")); 841296177Sjhibbits 842296177Sjhibbits if (FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, absoluteProfileId, FALSE)) 843296177Sjhibbits return ERROR_CODE(E_BUSY); 844296177Sjhibbits 845296177Sjhibbits 846296177Sjhibbits requiredActionTmp = FmPcdPlcrGetRequiredAction(p_FmHc->h_FmPcd, absoluteProfileId); 847296177Sjhibbits pointedOwnersTmp = FmPcdPlcrGetPointedOwners(p_FmHc->h_FmPcd, absoluteProfileId); 848296177Sjhibbits 849296177Sjhibbits if(!pointedOwnersTmp || !(requiredActionTmp & requiredAction)) 850296177Sjhibbits { 851296177Sjhibbits 852296177Sjhibbits if(requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) 853296177Sjhibbits { 854296177Sjhibbits 855296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 856296177Sjhibbits if (!p_HcFrame) 857296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 858296177Sjhibbits /* first read scheme and check that it is valid */ 859296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 860296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 861296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(absoluteProfileId); 862296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 863296177Sjhibbits 864296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 865296177Sjhibbits 866296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 867296177Sjhibbits { 868296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 869296177Sjhibbits XX_FreeSmart(p_HcFrame); 870296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 871296177Sjhibbits } 872296177Sjhibbits 873296177Sjhibbits /* check that profile is valid */ 874296177Sjhibbits if (!FmPcdPlcrHwProfileIsValid(p_HcFrame->hcSpecificData.profileRegs.fmpl_pemode)) 875296177Sjhibbits { 876296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 877296177Sjhibbits XX_FreeSmart(p_HcFrame); 878296177Sjhibbits RETURN_ERROR(MAJOR, E_ALREADY_EXISTS, ("Policer is already used")); 879296177Sjhibbits } 880296177Sjhibbits 881296177Sjhibbits tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_pegnia; 882296177Sjhibbits if(!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) 883296177Sjhibbits { 884296177Sjhibbits XX_FreeSmart(p_HcFrame); 885296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); 886296177Sjhibbits } 887296177Sjhibbits tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; 888296177Sjhibbits 889296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 890296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); 891296177Sjhibbits p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(TRUE, FALSE, FALSE); 892296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 893296177Sjhibbits p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; 894296177Sjhibbits 895296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); 896296177Sjhibbits 897296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 898296177Sjhibbits { 899296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 900296177Sjhibbits XX_FreeSmart(p_HcFrame); 901296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 902296177Sjhibbits } 903296177Sjhibbits 904296177Sjhibbits tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_peynia; 905296177Sjhibbits if(!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) 906296177Sjhibbits { 907296177Sjhibbits XX_FreeSmart(p_HcFrame); 908296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); 909296177Sjhibbits } 910296177Sjhibbits tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; 911296177Sjhibbits 912296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 913296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); 914296177Sjhibbits p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(FALSE, TRUE, FALSE); 915296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 916296177Sjhibbits p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; 917296177Sjhibbits 918296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); 919296177Sjhibbits 920296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 921296177Sjhibbits { 922296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 923296177Sjhibbits XX_FreeSmart(p_HcFrame); 924296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 925296177Sjhibbits } 926296177Sjhibbits 927296177Sjhibbits tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_pernia; 928296177Sjhibbits if(!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) 929296177Sjhibbits { 930296177Sjhibbits XX_FreeSmart(p_HcFrame); 931296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); 932296177Sjhibbits } 933296177Sjhibbits tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; 934296177Sjhibbits 935296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 936296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); 937296177Sjhibbits p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(FALSE, FALSE, TRUE); 938296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 939296177Sjhibbits p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; 940296177Sjhibbits 941296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); 942296177Sjhibbits 943296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 944296177Sjhibbits { 945296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 946296177Sjhibbits XX_FreeSmart(p_HcFrame); 947296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 948296177Sjhibbits } 949296177Sjhibbits XX_FreeSmart(p_HcFrame); 950296177Sjhibbits } 951296177Sjhibbits } 952296177Sjhibbits 953296177Sjhibbits FmPcdPlcrUpatePointedOwner(p_FmHc->h_FmPcd, absoluteProfileId, TRUE); 954296177Sjhibbits FmPcdPlcrUpdateRequiredAction(p_FmHc->h_FmPcd, absoluteProfileId, requiredAction); 955296177Sjhibbits 956296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 957296177Sjhibbits 958296177Sjhibbits return E_OK; 959296177Sjhibbits} 960296177Sjhibbits 961296177Sjhibbitst_Handle FmHcPcdPlcrSetProfile(t_Handle h_FmHc,t_FmPcdPlcrProfileParams *p_Profile) 962296177Sjhibbits{ 963296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 964296177Sjhibbits t_FmPcdPlcrInterModuleProfileRegs profileRegs; 965296177Sjhibbits t_Error err = E_OK; 966296177Sjhibbits uint32_t intFlags; 967296177Sjhibbits uint16_t profileIndx; 968296177Sjhibbits t_HcFrame *p_HcFrame; 969296177Sjhibbits t_DpaaFD fmFd; 970296177Sjhibbits 971296177Sjhibbits if (p_Profile->modify) 972296177Sjhibbits { 973296177Sjhibbits profileIndx = (uint16_t)(PTR_TO_UINT(p_Profile->id.h_Profile)-1); 974296177Sjhibbits if (FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, profileIndx, FALSE)) 975296177Sjhibbits return NULL; 976296177Sjhibbits } 977296177Sjhibbits else 978296177Sjhibbits { 979296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 980296177Sjhibbits err = FmPcdPlcrGetAbsoluteProfileId(p_FmHc->h_FmPcd, 981296177Sjhibbits p_Profile->id.newParams.profileType, 982296177Sjhibbits p_Profile->id.newParams.h_FmPort, 983296177Sjhibbits p_Profile->id.newParams.relativeProfileId, 984296177Sjhibbits &profileIndx); 985296177Sjhibbits if (err) 986296177Sjhibbits { 987296177Sjhibbits REPORT_ERROR(MAJOR, err, NO_MSG); 988296177Sjhibbits return NULL; 989296177Sjhibbits } 990296177Sjhibbits err = FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, profileIndx, TRUE); 991296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 992296177Sjhibbits if (err) 993296177Sjhibbits return NULL; 994296177Sjhibbits } 995296177Sjhibbits 996296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 997296177Sjhibbits if (!p_HcFrame) 998296177Sjhibbits { 999296177Sjhibbits REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1000296177Sjhibbits return NULL; 1001296177Sjhibbits } 1002296177Sjhibbits 1003296177Sjhibbits if(!p_Profile->modify) 1004296177Sjhibbits { 1005296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1006296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1007296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(profileIndx); 1008296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1009296177Sjhibbits 1010296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 1011296177Sjhibbits 1012296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1013296177Sjhibbits { 1014296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, profileIndx); 1015296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1016296177Sjhibbits XX_FreeSmart(p_HcFrame); 1017296177Sjhibbits return NULL; 1018296177Sjhibbits } 1019296177Sjhibbits 1020296177Sjhibbits /* check if this scheme is already used */ 1021296177Sjhibbits if (FmPcdPlcrHwProfileIsValid(p_HcFrame->hcSpecificData.profileRegs.fmpl_pemode)) 1022296177Sjhibbits { 1023296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, profileIndx); 1024296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("Policer is already used")); 1025296177Sjhibbits XX_FreeSmart(p_HcFrame); 1026296177Sjhibbits return NULL; 1027296177Sjhibbits } 1028296177Sjhibbits } 1029296177Sjhibbits 1030296177Sjhibbits memset(&profileRegs, 0, sizeof(t_FmPcdPlcrInterModuleProfileRegs)); 1031296177Sjhibbits err = FmPcdPlcrBuildProfile(p_FmHc->h_FmPcd, p_Profile, &profileRegs); 1032296177Sjhibbits if(err) 1033296177Sjhibbits { 1034296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, profileIndx); 1035296177Sjhibbits REPORT_ERROR(MAJOR, err, NO_MSG); 1036296177Sjhibbits XX_FreeSmart(p_HcFrame); 1037296177Sjhibbits return NULL; 1038296177Sjhibbits } 1039296177Sjhibbits 1040296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1041296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1042296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionRegs(profileIndx); 1043296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1044296177Sjhibbits memcpy(&p_HcFrame->hcSpecificData.profileRegs, &profileRegs, sizeof(t_FmPcdPlcrInterModuleProfileRegs)); 1045296177Sjhibbits 1046296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 1047296177Sjhibbits 1048296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1049296177Sjhibbits { 1050296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, profileIndx); 1051296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1052296177Sjhibbits XX_FreeSmart(p_HcFrame); 1053296177Sjhibbits return NULL; 1054296177Sjhibbits } 1055296177Sjhibbits 1056296177Sjhibbits FmPcdPlcrValidateProfileSw(p_FmHc->h_FmPcd, profileIndx); 1057296177Sjhibbits 1058296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, profileIndx); 1059296177Sjhibbits 1060296177Sjhibbits XX_FreeSmart(p_HcFrame); 1061296177Sjhibbits 1062296177Sjhibbits return UINT_TO_PTR((uint64_t)profileIndx+1); 1063296177Sjhibbits} 1064296177Sjhibbits 1065296177Sjhibbitst_Error FmHcPcdPlcrDeleteProfile(t_Handle h_FmHc, t_Handle h_Profile) 1066296177Sjhibbits{ 1067296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1068296177Sjhibbits uint16_t absoluteProfileId = (uint16_t)(PTR_TO_UINT(h_Profile)-1); 1069296177Sjhibbits t_Error err = E_OK; 1070296177Sjhibbits t_HcFrame *p_HcFrame; 1071296177Sjhibbits t_DpaaFD fmFd; 1072296177Sjhibbits 1073296177Sjhibbits if (FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, absoluteProfileId, FALSE)) 1074296177Sjhibbits return ERROR_CODE(E_BUSY); 1075296177Sjhibbits 1076296177Sjhibbits FmPcdPlcrInvalidateProfileSw(p_FmHc->h_FmPcd, absoluteProfileId); 1077296177Sjhibbits 1078296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 1079296177Sjhibbits if (!p_HcFrame) 1080296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1081296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1082296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1083296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); 1084296177Sjhibbits p_HcFrame->actionReg |= 0x00008000; 1085296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1086296177Sjhibbits memset(&p_HcFrame->hcSpecificData.profileRegs, 0, sizeof(t_FmPcdPlcrInterModuleProfileRegs)); 1087296177Sjhibbits 1088296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 1089296177Sjhibbits 1090296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1091296177Sjhibbits { 1092296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1093296177Sjhibbits XX_FreeSmart(p_HcFrame); 1094296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1095296177Sjhibbits } 1096296177Sjhibbits 1097296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1098296177Sjhibbits 1099296177Sjhibbits XX_FreeSmart(p_HcFrame); 1100296177Sjhibbits 1101296177Sjhibbits return E_OK; 1102296177Sjhibbits} 1103296177Sjhibbits 1104296177Sjhibbitst_Error FmHcPcdPlcrSetProfileCounter(t_Handle h_FmHc, t_Handle h_Profile, e_FmPcdPlcrProfileCounters counter, uint32_t value) 1105296177Sjhibbits{ 1106296177Sjhibbits 1107296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1108296177Sjhibbits uint16_t absoluteProfileId = (uint16_t)(PTR_TO_UINT(h_Profile)-1); 1109296177Sjhibbits t_Error err = E_OK; 1110296177Sjhibbits t_HcFrame *p_HcFrame; 1111296177Sjhibbits t_DpaaFD fmFd; 1112296177Sjhibbits 1113296177Sjhibbits if (FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, absoluteProfileId, FALSE)) 1114296177Sjhibbits return ERROR_CODE(E_BUSY); 1115296177Sjhibbits 1116296177Sjhibbits /* first read scheme and check that it is valid */ 1117296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 1118296177Sjhibbits if (!p_HcFrame) 1119296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1120296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1121296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1122296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(absoluteProfileId); 1123296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1124296177Sjhibbits 1125296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 1126296177Sjhibbits 1127296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1128296177Sjhibbits { 1129296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1130296177Sjhibbits XX_FreeSmart(p_HcFrame); 1131296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1132296177Sjhibbits } 1133296177Sjhibbits 1134296177Sjhibbits /* check that profile is valid */ 1135296177Sjhibbits if (!FmPcdPlcrHwProfileIsValid(p_HcFrame->hcSpecificData.profileRegs.fmpl_pemode)) 1136296177Sjhibbits { 1137296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1138296177Sjhibbits XX_FreeSmart(p_HcFrame); 1139296177Sjhibbits RETURN_ERROR(MAJOR, E_ALREADY_EXISTS, ("Policer is already used")); 1140296177Sjhibbits } 1141296177Sjhibbits 1142296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1143296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); 1144296177Sjhibbits p_HcFrame->actionReg |= FmPcdPlcrBuildCounterProfileReg(counter); 1145296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1146296177Sjhibbits p_HcFrame->hcSpecificData.singleRegForWrite = value; 1147296177Sjhibbits 1148296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); 1149296177Sjhibbits 1150296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1151296177Sjhibbits { 1152296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1153296177Sjhibbits XX_FreeSmart(p_HcFrame); 1154296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1155296177Sjhibbits } 1156296177Sjhibbits 1157296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1158296177Sjhibbits 1159296177Sjhibbits XX_FreeSmart(p_HcFrame); 1160296177Sjhibbits 1161296177Sjhibbits return E_OK; 1162296177Sjhibbits} 1163296177Sjhibbits 1164296177Sjhibbitsuint32_t FmHcPcdPlcrGetProfileCounter(t_Handle h_FmHc, t_Handle h_Profile, e_FmPcdPlcrProfileCounters counter) 1165296177Sjhibbits{ 1166296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1167296177Sjhibbits uint16_t absoluteProfileId = (uint16_t)(PTR_TO_UINT(h_Profile)-1); 1168296177Sjhibbits t_Error err = E_OK; 1169296177Sjhibbits t_HcFrame *p_HcFrame; 1170296177Sjhibbits t_DpaaFD fmFd; 1171296177Sjhibbits uint32_t retVal = 0; 1172296177Sjhibbits 1173296177Sjhibbits SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 1174296177Sjhibbits 1175296177Sjhibbits if (FmPcdPlcrProfileTryLock(p_FmHc->h_FmPcd, absoluteProfileId, FALSE)) 1176296177Sjhibbits return 0; 1177296177Sjhibbits 1178296177Sjhibbits /* first read scheme and check that it is valid */ 1179296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 1180296177Sjhibbits if (!p_HcFrame) 1181296177Sjhibbits { 1182296177Sjhibbits REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1183296177Sjhibbits return 0; 1184296177Sjhibbits } 1185296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1186296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); 1187296177Sjhibbits p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(absoluteProfileId); 1188296177Sjhibbits p_HcFrame->extraReg = 0x00008000; 1189296177Sjhibbits 1190296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); 1191296177Sjhibbits 1192296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1193296177Sjhibbits { 1194296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1195296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 1196296177Sjhibbits XX_FreeSmart(p_HcFrame); 1197296177Sjhibbits return 0; 1198296177Sjhibbits } 1199296177Sjhibbits 1200296177Sjhibbits /* check that profile is valid */ 1201296177Sjhibbits if (!FmPcdPlcrHwProfileIsValid(p_HcFrame->hcSpecificData.profileRegs.fmpl_pemode)) 1202296177Sjhibbits { 1203296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1204296177Sjhibbits XX_FreeSmart(p_HcFrame); 1205296177Sjhibbits REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("invalid Policer profile")); 1206296177Sjhibbits return 0; 1207296177Sjhibbits } 1208296177Sjhibbits 1209296177Sjhibbits switch (counter) 1210296177Sjhibbits { 1211296177Sjhibbits case e_FM_PCD_PLCR_PROFILE_GREEN_PACKET_TOTAL_COUNTER: 1212296177Sjhibbits retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_pegpc; 1213296177Sjhibbits break; 1214296177Sjhibbits case e_FM_PCD_PLCR_PROFILE_YELLOW_PACKET_TOTAL_COUNTER: 1215296177Sjhibbits retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_peypc; 1216296177Sjhibbits break; 1217296177Sjhibbits case e_FM_PCD_PLCR_PROFILE_RED_PACKET_TOTAL_COUNTER: 1218296177Sjhibbits retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perpc; 1219296177Sjhibbits break; 1220296177Sjhibbits case e_FM_PCD_PLCR_PROFILE_RECOLOURED_YELLOW_PACKET_TOTAL_COUNTER: 1221296177Sjhibbits retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perypc; 1222296177Sjhibbits break; 1223296177Sjhibbits case e_FM_PCD_PLCR_PROFILE_RECOLOURED_RED_PACKET_TOTAL_COUNTER: 1224296177Sjhibbits retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perrpc; 1225296177Sjhibbits break; 1226296177Sjhibbits default: 1227296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_SELECTION, NO_MSG); 1228296177Sjhibbits } 1229296177Sjhibbits 1230296177Sjhibbits FmPcdPlcrReleaseProfileLock(p_FmHc->h_FmPcd, absoluteProfileId); 1231296177Sjhibbits 1232296177Sjhibbits XX_FreeSmart(p_HcFrame); 1233296177Sjhibbits 1234296177Sjhibbits return retVal; 1235296177Sjhibbits} 1236296177Sjhibbits 1237296177Sjhibbitst_Error FmHcPcdCcModifyTreeNextEngine(t_Handle h_FmHc, t_Handle h_CcTree, uint8_t grpId, uint8_t index, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 1238296177Sjhibbits{ 1239296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1240296177Sjhibbits t_Error err = E_OK; 1241296177Sjhibbits uint32_t intFlags; 1242296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1243296177Sjhibbits t_Handle h_Params; 1244296177Sjhibbits 1245296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1246296177Sjhibbits err = FmPcdCcTreeTryLock(h_CcTree); 1247296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1248296177Sjhibbits if (err) 1249296177Sjhibbits return err; 1250296177Sjhibbits 1251296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1252296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1253296177Sjhibbits 1254296177Sjhibbits err = FmPcdCcModifyNextEngineParamTree(p_FmHc->h_FmPcd, h_CcTree, grpId, index, p_FmPcdCcNextEngineParams, 1255296177Sjhibbits &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1256296177Sjhibbits if(err) 1257296177Sjhibbits { 1258296177Sjhibbits FmPcdCcTreeReleaseLock(h_CcTree); 1259296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1260296177Sjhibbits } 1261296177Sjhibbits 1262296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1263296177Sjhibbits 1264296177Sjhibbits FmPcdCcTreeReleaseLock(h_CcTree); 1265296177Sjhibbits 1266296177Sjhibbits return err; 1267296177Sjhibbits} 1268296177Sjhibbits 1269296177Sjhibbits 1270296177Sjhibbitst_Error FmHcPcdCcModifyNodeMissNextEngine(t_Handle h_FmHc, t_Handle h_CcNode, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 1271296177Sjhibbits{ 1272296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1273296177Sjhibbits t_Handle h_Params; 1274296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1275296177Sjhibbits t_Error err = E_OK; 1276296177Sjhibbits t_List h_List; 1277296177Sjhibbits uint32_t intFlags; 1278296177Sjhibbits 1279296177Sjhibbits INIT_LIST(&h_List); 1280296177Sjhibbits 1281296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1282296177Sjhibbits 1283296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1284296177Sjhibbits { 1285296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1286296177Sjhibbits return err; 1287296177Sjhibbits } 1288296177Sjhibbits 1289296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1290296177Sjhibbits 1291296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1292296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1293296177Sjhibbits 1294296177Sjhibbits err = FmPcdCcModifyMissNextEngineParamNode(p_FmHc->h_FmPcd, h_CcNode, p_FmPcdCcNextEngineParams, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1295296177Sjhibbits if(err) 1296296177Sjhibbits { 1297296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1298296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1299296177Sjhibbits } 1300296177Sjhibbits 1301296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1302296177Sjhibbits 1303296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1304296177Sjhibbits 1305296177Sjhibbits 1306296177Sjhibbits return E_OK; 1307296177Sjhibbits} 1308296177Sjhibbits 1309296177Sjhibbitst_Error FmHcPcdCcRemoveKey(t_Handle h_FmHc, t_Handle h_CcNode, uint8_t keyIndex) 1310296177Sjhibbits{ 1311296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1312296177Sjhibbits t_Handle h_Params; 1313296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1314296177Sjhibbits t_Error err = E_OK; 1315296177Sjhibbits t_List h_List; 1316296177Sjhibbits uint32_t intFlags; 1317296177Sjhibbits 1318296177Sjhibbits INIT_LIST(&h_List); 1319296177Sjhibbits 1320296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1321296177Sjhibbits 1322296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1323296177Sjhibbits { 1324296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1325296177Sjhibbits return err; 1326296177Sjhibbits } 1327296177Sjhibbits 1328296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1329296177Sjhibbits 1330296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1331296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1332296177Sjhibbits 1333296177Sjhibbits 1334296177Sjhibbits err = FmPcdCcRemoveKey(p_FmHc->h_FmPcd,h_CcNode,keyIndex, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1335296177Sjhibbits if(err) 1336296177Sjhibbits { 1337296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1338296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1339296177Sjhibbits } 1340296177Sjhibbits 1341296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1342296177Sjhibbits 1343296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1344296177Sjhibbits 1345296177Sjhibbits return err; 1346296177Sjhibbits 1347296177Sjhibbits} 1348296177Sjhibbits 1349296177Sjhibbitst_Error FmHcPcdCcAddKey(t_Handle h_FmHc, t_Handle h_CcNode, uint8_t keyIndex, uint8_t keySize, t_FmPcdCcKeyParams *p_KeyParams) 1350296177Sjhibbits{ 1351296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1352296177Sjhibbits t_Handle h_Params; 1353296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1354296177Sjhibbits t_Error err = E_OK; 1355296177Sjhibbits t_List h_List; 1356296177Sjhibbits uint32_t intFlags; 1357296177Sjhibbits 1358296177Sjhibbits INIT_LIST(&h_List); 1359296177Sjhibbits 1360296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1361296177Sjhibbits 1362296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1363296177Sjhibbits { 1364296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1365296177Sjhibbits return err; 1366296177Sjhibbits } 1367296177Sjhibbits 1368296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1369296177Sjhibbits 1370296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1371296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1372296177Sjhibbits 1373296177Sjhibbits 1374296177Sjhibbits err = FmPcdCcAddKey(p_FmHc->h_FmPcd,h_CcNode,keyIndex,keySize, p_KeyParams, &h_OldPointersLst,&h_NewPointersLst, &h_Params); 1375296177Sjhibbits if(err) 1376296177Sjhibbits { 1377296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1378296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1379296177Sjhibbits } 1380296177Sjhibbits 1381296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1382296177Sjhibbits 1383296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1384296177Sjhibbits 1385296177Sjhibbits return err; 1386296177Sjhibbits} 1387296177Sjhibbits 1388296177Sjhibbits 1389296177Sjhibbitst_Error FmHcPcdCcModifyKey(t_Handle h_FmHc, t_Handle h_CcNode, uint8_t keyIndex, uint8_t keySize, uint8_t *p_Key, uint8_t *p_Mask) 1390296177Sjhibbits{ 1391296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1392296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1393296177Sjhibbits t_Error err = E_OK; 1394296177Sjhibbits t_List h_List; 1395296177Sjhibbits uint32_t intFlags; 1396296177Sjhibbits t_Handle h_Params; 1397296177Sjhibbits 1398296177Sjhibbits UNUSED(keySize); 1399296177Sjhibbits 1400296177Sjhibbits INIT_LIST(&h_List); 1401296177Sjhibbits 1402296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1403296177Sjhibbits 1404296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1405296177Sjhibbits { 1406296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1407296177Sjhibbits return err; 1408296177Sjhibbits } 1409296177Sjhibbits 1410296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1411296177Sjhibbits 1412296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1413296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1414296177Sjhibbits 1415296177Sjhibbits err = FmPcdCcModifyKey(p_FmHc->h_FmPcd, h_CcNode, keyIndex, keySize, p_Key, p_Mask, &h_OldPointersLst,&h_NewPointersLst, &h_Params); 1416296177Sjhibbits if(err) 1417296177Sjhibbits { 1418296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1419296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1420296177Sjhibbits } 1421296177Sjhibbits 1422296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1423296177Sjhibbits 1424296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1425296177Sjhibbits 1426296177Sjhibbits return err; 1427296177Sjhibbits} 1428296177Sjhibbits 1429296177Sjhibbitst_Error FmHcPcdCcModifyNodeNextEngine(t_Handle h_FmHc, t_Handle h_CcNode, uint8_t keyIndex, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 1430296177Sjhibbits{ 1431296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1432296177Sjhibbits t_Error err = E_OK; 1433296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1434296177Sjhibbits t_List h_List; 1435296177Sjhibbits uint32_t intFlags; 1436296177Sjhibbits t_Handle h_Params; 1437296177Sjhibbits 1438296177Sjhibbits INIT_LIST(&h_List); 1439296177Sjhibbits 1440296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1441296177Sjhibbits 1442296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1443296177Sjhibbits { 1444296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1445296177Sjhibbits return err; 1446296177Sjhibbits } 1447296177Sjhibbits 1448296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1449296177Sjhibbits 1450296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1451296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1452296177Sjhibbits 1453296177Sjhibbits err = FmPcdCcModiyNextEngineParamNode(p_FmHc->h_FmPcd, h_CcNode, keyIndex, p_FmPcdCcNextEngineParams, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1454296177Sjhibbits if(err) 1455296177Sjhibbits { 1456296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1457296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1458296177Sjhibbits } 1459296177Sjhibbits 1460296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1461296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1462296177Sjhibbits return err; 1463296177Sjhibbits} 1464296177Sjhibbits 1465296177Sjhibbits 1466296177Sjhibbitst_Error FmHcPcdCcModifyKeyAndNextEngine(t_Handle h_FmHc, t_Handle h_CcNode, uint8_t keyIndex, uint8_t keySize, t_FmPcdCcKeyParams *p_KeyParams) 1467296177Sjhibbits{ 1468296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1469296177Sjhibbits t_List h_OldPointersLst, h_NewPointersLst; 1470296177Sjhibbits t_Error err = E_OK; 1471296177Sjhibbits t_List h_List; 1472296177Sjhibbits uint32_t intFlags; 1473296177Sjhibbits t_Handle h_Params; 1474296177Sjhibbits 1475296177Sjhibbits INIT_LIST(&h_OldPointersLst); 1476296177Sjhibbits INIT_LIST(&h_NewPointersLst); 1477296177Sjhibbits INIT_LIST(&h_List); 1478296177Sjhibbits 1479296177Sjhibbits intFlags = FmPcdLock(p_FmHc->h_FmPcd); 1480296177Sjhibbits 1481296177Sjhibbits if ((err = FmPcdCcNodeTreeTryLock(p_FmHc->h_FmPcd, h_CcNode, &h_List)) != E_OK) 1482296177Sjhibbits { 1483296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1484296177Sjhibbits return err; 1485296177Sjhibbits } 1486296177Sjhibbits 1487296177Sjhibbits FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); 1488296177Sjhibbits 1489296177Sjhibbits 1490296177Sjhibbits err = FmPcdCcModifyKeyAndNextEngine(p_FmHc->h_FmPcd,h_CcNode,keyIndex,keySize, p_KeyParams, &h_OldPointersLst,&h_NewPointersLst, &h_Params); 1491296177Sjhibbits if(err) 1492296177Sjhibbits { 1493296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1494296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 1495296177Sjhibbits } 1496296177Sjhibbits 1497296177Sjhibbits err = HcDynamicChange(p_FmHc, &h_OldPointersLst, &h_NewPointersLst, &h_Params); 1498296177Sjhibbits 1499296177Sjhibbits FmPcdCcNodeTreeReleaseLock(&h_List); 1500296177Sjhibbits 1501296177Sjhibbits 1502296177Sjhibbits return err; 1503296177Sjhibbits} 1504296177Sjhibbits 1505296177Sjhibbits 1506296177Sjhibbitst_Error FmHcKgWriteSp(t_Handle h_FmHc, uint8_t hardwarePortId, uint32_t spReg, bool add) 1507296177Sjhibbits{ 1508296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1509296177Sjhibbits t_HcFrame *p_HcFrame; 1510296177Sjhibbits t_DpaaFD fmFd; 1511296177Sjhibbits t_Error err = E_OK; 1512296177Sjhibbits 1513296177Sjhibbits ASSERT_COND(p_FmHc); 1514296177Sjhibbits 1515296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 1516296177Sjhibbits if (!p_HcFrame) 1517296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1518296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1519296177Sjhibbits /* first read SP register */ 1520296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 1521296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildReadPortSchemeBindActionReg(hardwarePortId); 1522296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 1523296177Sjhibbits 1524296177Sjhibbits BUILD_FD(SIZE_OF_HC_FRAME_PORT_REGS); 1525296177Sjhibbits 1526296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1527296177Sjhibbits { 1528296177Sjhibbits XX_FreeSmart(p_HcFrame); 1529296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1530296177Sjhibbits } 1531296177Sjhibbits 1532296177Sjhibbits /* spReg is the first reg, so we can use it both for read and for write */ 1533296177Sjhibbits if(add) 1534296177Sjhibbits p_HcFrame->hcSpecificData.portRegsForRead.spReg |= spReg; 1535296177Sjhibbits else 1536296177Sjhibbits p_HcFrame->hcSpecificData.portRegsForRead.spReg &= ~spReg; 1537296177Sjhibbits 1538296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWritePortSchemeBindActionReg(hardwarePortId); 1539296177Sjhibbits 1540296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 1541296177Sjhibbits 1542296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1543296177Sjhibbits { 1544296177Sjhibbits XX_FreeSmart(p_HcFrame); 1545296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1546296177Sjhibbits } 1547296177Sjhibbits 1548296177Sjhibbits XX_FreeSmart(p_HcFrame); 1549296177Sjhibbits 1550296177Sjhibbits return E_OK; 1551296177Sjhibbits} 1552296177Sjhibbits 1553296177Sjhibbitst_Error FmHcKgWriteCpp(t_Handle h_FmHc, uint8_t hardwarePortId, uint32_t cppReg) 1554296177Sjhibbits{ 1555296177Sjhibbits t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; 1556296177Sjhibbits t_HcFrame *p_HcFrame; 1557296177Sjhibbits t_DpaaFD fmFd; 1558296177Sjhibbits t_Error err = E_OK; 1559296177Sjhibbits 1560296177Sjhibbits ASSERT_COND(p_FmHc); 1561296177Sjhibbits 1562296177Sjhibbits p_HcFrame = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + p_FmHc->padTill16), 0, 16); 1563296177Sjhibbits if (!p_HcFrame) 1564296177Sjhibbits RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame obj")); 1565296177Sjhibbits memset(p_HcFrame, 0, sizeof(t_HcFrame)); 1566296177Sjhibbits /* first read SP register */ 1567296177Sjhibbits p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); 1568296177Sjhibbits p_HcFrame->actionReg = FmPcdKgBuildWritePortClsPlanBindActionReg(hardwarePortId); 1569296177Sjhibbits p_HcFrame->extraReg = 0xFFFFF800; 1570296177Sjhibbits p_HcFrame->hcSpecificData.singleRegForWrite = cppReg; 1571296177Sjhibbits 1572296177Sjhibbits BUILD_FD(sizeof(t_HcFrame)); 1573296177Sjhibbits 1574296177Sjhibbits if ((err = EnQFrm(p_FmHc, &fmFd, &p_HcFrame->commandSequence)) != E_OK) 1575296177Sjhibbits { 1576296177Sjhibbits XX_FreeSmart(p_HcFrame); 1577296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1578296177Sjhibbits } 1579296177Sjhibbits 1580296177Sjhibbits XX_FreeSmart(p_HcFrame); 1581296177Sjhibbits 1582296177Sjhibbits return E_OK; 1583296177Sjhibbits} 1584296177Sjhibbits 1585