1296177Sjhibbits/****************************************************************************** 2296177Sjhibbits 3296177Sjhibbits � 1995-2003, 2004, 2005-2011 Freescale Semiconductor, Inc. 4296177Sjhibbits All rights reserved. 5296177Sjhibbits 6296177Sjhibbits This is proprietary source code of Freescale Semiconductor Inc., 7296177Sjhibbits and its use is subject to the NetComm Device Drivers EULA. 8296177Sjhibbits The copyright notice above does not evidence any actual or intended 9296177Sjhibbits publication of such source code. 10296177Sjhibbits 11296177Sjhibbits ALTERNATIVELY, redistribution and use in source and binary forms, with 12296177Sjhibbits or without modification, are permitted provided that the following 13296177Sjhibbits conditions are met: 14296177Sjhibbits * Redistributions of source code must retain the above copyright 15296177Sjhibbits notice, this list of conditions and the following disclaimer. 16296177Sjhibbits * Redistributions in binary form must reproduce the above copyright 17296177Sjhibbits notice, this list of conditions and the following disclaimer in the 18296177Sjhibbits documentation and/or other materials provided with the distribution. 19296177Sjhibbits * Neither the name of Freescale Semiconductor nor the 20296177Sjhibbits names of its contributors may be used to endorse or promote products 21296177Sjhibbits derived from this software without specific prior written permission. 22296177Sjhibbits 23296177Sjhibbits THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY 24296177Sjhibbits EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 25296177Sjhibbits WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26296177Sjhibbits DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY 27296177Sjhibbits DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 28296177Sjhibbits (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29296177Sjhibbits LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 30296177Sjhibbits ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31296177Sjhibbits (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 32296177Sjhibbits SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33296177Sjhibbits * 34296177Sjhibbits 35296177Sjhibbits 36296177Sjhibbits **************************************************************************/ 37296177Sjhibbits/****************************************************************************** 38296177Sjhibbits @File bm.c 39296177Sjhibbits 40296177Sjhibbits @Description BM 41296177Sjhibbits*//***************************************************************************/ 42296177Sjhibbits#include "error_ext.h" 43296177Sjhibbits#include "std_ext.h" 44296177Sjhibbits#include "string_ext.h" 45296177Sjhibbits#include "sprint_ext.h" 46296177Sjhibbits#include "debug_ext.h" 47296177Sjhibbits#include "mm_ext.h" 48296177Sjhibbits 49296177Sjhibbits#include "bm.h" 50296177Sjhibbits 51296177Sjhibbits 52296177Sjhibbitst_Error BM_ConfigException(t_Handle h_Bm, e_BmExceptions exception, bool enable); 53296177Sjhibbits 54296177Sjhibbits 55296177Sjhibbits/****************************************/ 56296177Sjhibbits/* static functions */ 57296177Sjhibbits/****************************************/ 58296177Sjhibbits 59296177Sjhibbitsstatic volatile bool blockingFlag = FALSE; 60296177Sjhibbitsstatic void BmIpcMsgCompletionCB(t_Handle h_Module, 61296177Sjhibbits uint8_t *p_Msg, 62296177Sjhibbits uint8_t *p_Reply, 63296177Sjhibbits uint32_t replyLength, 64296177Sjhibbits t_Error status) 65296177Sjhibbits{ 66296177Sjhibbits SANITY_CHECK_RETURN(h_Module, E_INVALID_HANDLE); 67296177Sjhibbits 68296177Sjhibbits#ifdef DISABLE_SANITY_CHECKS 69296177Sjhibbits UNUSED(h_Module); 70296177Sjhibbits#endif /* DISABLE_SANITY_CHECKS */ 71296177Sjhibbits UNUSED(p_Msg);UNUSED(p_Reply);UNUSED(replyLength);UNUSED(status); 72296177Sjhibbits 73296177Sjhibbits blockingFlag = FALSE; 74296177Sjhibbits} 75296177Sjhibbits 76296177Sjhibbitsstatic t_Error BmHandleIpcMsgCB(t_Handle h_Bm, 77296177Sjhibbits uint8_t *p_Msg, 78296177Sjhibbits uint32_t msgLength, 79296177Sjhibbits uint8_t *p_Reply, 80296177Sjhibbits uint32_t *p_ReplyLength) 81296177Sjhibbits{ 82296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 83296177Sjhibbits t_BmIpcMsg *p_IpcMsg = (t_BmIpcMsg*)p_Msg; 84296177Sjhibbits t_BmIpcReply *p_IpcReply = (t_BmIpcReply *)p_Reply; 85296177Sjhibbits 86296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 87296177Sjhibbits SANITY_CHECK_RETURN_ERROR((msgLength >= sizeof(uint32_t)), E_INVALID_VALUE); 88296177Sjhibbits 89296177Sjhibbits#ifdef DISABLE_SANITY_CHECKS 90296177Sjhibbits UNUSED(msgLength); 91296177Sjhibbits#endif /* DISABLE_SANITY_CHECKS */ 92296177Sjhibbits 93296177Sjhibbits ASSERT_COND(p_IpcMsg); 94296177Sjhibbits 95296177Sjhibbits memset(p_IpcReply, 0, (sizeof(uint8_t) * BM_IPC_MAX_REPLY_SIZE)); 96296177Sjhibbits *p_ReplyLength = 0; 97296177Sjhibbits 98296177Sjhibbits switch(p_IpcMsg->msgId) 99296177Sjhibbits { 100296177Sjhibbits case (BM_MASTER_IS_ALIVE): 101296177Sjhibbits *(uint8_t*)p_IpcReply->replyBody = 1; 102296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); 103296177Sjhibbits break; 104296177Sjhibbits case (BM_SET_POOL_THRESH): 105296177Sjhibbits { 106296177Sjhibbits t_Error err; 107296177Sjhibbits t_BmIpcPoolThreshParams ipcPoolThresh; 108296177Sjhibbits 109296177Sjhibbits memcpy((uint8_t*)&ipcPoolThresh, p_IpcMsg->msgBody, sizeof(t_BmIpcPoolThreshParams)); 110296177Sjhibbits if ((err = BmSetPoolThresholds(p_Bm, 111296177Sjhibbits ipcPoolThresh.bpid, 112296177Sjhibbits ipcPoolThresh.thresholds)) != E_OK) 113296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 114296177Sjhibbits break; 115296177Sjhibbits } 116296177Sjhibbits case (BM_UNSET_POOL_THRESH): 117296177Sjhibbits { 118296177Sjhibbits t_Error err; 119296177Sjhibbits t_BmIpcPoolThreshParams ipcPoolThresh; 120296177Sjhibbits 121296177Sjhibbits memcpy((uint8_t*)&ipcPoolThresh, p_IpcMsg->msgBody, sizeof(t_BmIpcPoolThreshParams)); 122296177Sjhibbits if ((err = BmUnSetPoolThresholds(p_Bm, 123296177Sjhibbits ipcPoolThresh.bpid)) != E_OK) 124296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 125296177Sjhibbits break; 126296177Sjhibbits } 127296177Sjhibbits case (BM_GET_COUNTER): 128296177Sjhibbits { 129296177Sjhibbits t_BmIpcGetCounter ipcCounter; 130296177Sjhibbits uint32_t count; 131296177Sjhibbits 132296177Sjhibbits memcpy((uint8_t*)&ipcCounter, p_IpcMsg->msgBody, sizeof(t_BmIpcGetCounter)); 133296177Sjhibbits count = BmGetCounter(p_Bm, 134296177Sjhibbits (e_BmInterModuleCounters)ipcCounter.enumId, 135296177Sjhibbits ipcCounter.bpid); 136296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&count, sizeof(uint32_t)); 137296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 138296177Sjhibbits break; 139296177Sjhibbits } 140296177Sjhibbits case (BM_GET_REVISION): 141296177Sjhibbits { 142296177Sjhibbits t_BmRevisionInfo revInfo; 143296177Sjhibbits t_BmIpcRevisionInfo ipcRevInfo; 144296177Sjhibbits 145296177Sjhibbits p_IpcReply->error = (uint32_t)BmGetRevision(h_Bm, &revInfo); 146296177Sjhibbits ipcRevInfo.majorRev = revInfo.majorRev; 147296177Sjhibbits ipcRevInfo.minorRev = revInfo.minorRev; 148296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&ipcRevInfo, sizeof(t_BmIpcRevisionInfo)); 149296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(t_BmIpcRevisionInfo); 150296177Sjhibbits break; 151296177Sjhibbits } 152296177Sjhibbits case (BM_FORCE_BPID): 153296177Sjhibbits { 154296177Sjhibbits t_BmIpcBpidParams ipcBpid; 155296177Sjhibbits uint32_t tmp; 156296177Sjhibbits 157296177Sjhibbits memcpy((uint8_t*)&ipcBpid, p_IpcMsg->msgBody, sizeof(t_BmIpcBpidParams)); 158296177Sjhibbits tmp = BmBpidGet(p_Bm, TRUE, ipcBpid.bpid); 159296177Sjhibbits memcpy(p_IpcReply->replyBody, (uint8_t*)&tmp, sizeof(uint32_t)); 160296177Sjhibbits *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); 161296177Sjhibbits break; 162296177Sjhibbits } 163296177Sjhibbits case (BM_PUT_BPID): 164296177Sjhibbits { 165296177Sjhibbits t_Error err; 166296177Sjhibbits t_BmIpcBpidParams ipcBpid; 167296177Sjhibbits 168296177Sjhibbits memcpy((uint8_t*)&ipcBpid, p_IpcMsg->msgBody, sizeof(t_BmIpcBpidParams)); 169296177Sjhibbits if ((err = BmBpidPut(p_Bm, ipcBpid.bpid)) != E_OK) 170296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 171296177Sjhibbits break; 172296177Sjhibbits } 173296177Sjhibbits default: 174296177Sjhibbits *p_ReplyLength = 0; 175296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("command not found!!!")); 176296177Sjhibbits } 177296177Sjhibbits 178296177Sjhibbits return E_OK; 179296177Sjhibbits} 180296177Sjhibbits 181296177Sjhibbitsstatic t_Error CheckBmParameters(t_Bm *p_Bm) 182296177Sjhibbits{ 183296177Sjhibbits if ((p_Bm->p_BmDriverParams->partBpidBase + p_Bm->p_BmDriverParams->partNumOfPools) > BM_MAX_NUM_OF_POOLS) 184296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("partBpidBase+partNumOfPools out of range!!!")); 185296177Sjhibbits 186296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 187296177Sjhibbits { 188296177Sjhibbits if (!p_Bm->p_BmDriverParams->totalNumOfBuffers) 189296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("totalNumOfBuffers must be larger than '0'!!!")); 190296177Sjhibbits if (p_Bm->p_BmDriverParams->totalNumOfBuffers > (128*MEGABYTE)) 191296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("totalNumOfBuffers must be equal or smaller than 128M!!!")); 192296177Sjhibbits if(!p_Bm->f_Exception) 193296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Exceptions callback not provided")); 194296177Sjhibbits } 195296177Sjhibbits 196296177Sjhibbits return E_OK; 197296177Sjhibbits} 198296177Sjhibbits 199296177Sjhibbitsstatic __inline__ uint32_t GenerateThresh(uint32_t val, int roundup) 200296177Sjhibbits{ 201296177Sjhibbits uint32_t e = 0; /* co-efficient, exponent */ 202296177Sjhibbits uint32_t oddbit = 0; 203296177Sjhibbits while(val > 0xff) { 204296177Sjhibbits oddbit = val & 1; 205296177Sjhibbits val >>= 1; 206296177Sjhibbits e++; 207296177Sjhibbits if(roundup && oddbit) 208296177Sjhibbits val++; 209296177Sjhibbits } 210296177Sjhibbits return (val | (e << 8)); 211296177Sjhibbits} 212296177Sjhibbits 213296177Sjhibbitsstatic t_Error BmSetPool(t_Handle h_Bm, 214296177Sjhibbits uint8_t bpid, 215296177Sjhibbits uint32_t swdet, 216296177Sjhibbits uint32_t swdxt, 217296177Sjhibbits uint32_t hwdet, 218296177Sjhibbits uint32_t hwdxt) 219296177Sjhibbits{ 220296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 221296177Sjhibbits 222296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 223296177Sjhibbits SANITY_CHECK_RETURN_ERROR(bpid < BM_MAX_NUM_OF_POOLS, E_INVALID_VALUE); 224296177Sjhibbits 225296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->swdet[bpid], GenerateThresh(swdet, 0)); 226296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->swdxt[bpid], GenerateThresh(swdxt, 1)); 227296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->hwdet[bpid], GenerateThresh(hwdet, 0)); 228296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->hwdxt[bpid], GenerateThresh(hwdxt, 1)); 229296177Sjhibbits 230296177Sjhibbits return E_OK; 231296177Sjhibbits} 232296177Sjhibbits 233296177Sjhibbits/****************************************/ 234296177Sjhibbits/* Inter-Module functions */ 235296177Sjhibbits/****************************************/ 236296177Sjhibbits 237296177Sjhibbitst_Error BmSetPoolThresholds(t_Handle h_Bm, uint8_t bpid, const uint32_t *thresholds) 238296177Sjhibbits{ 239296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 240296177Sjhibbits 241296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 242296177Sjhibbits SANITY_CHECK_RETURN_ERROR(bpid < BM_MAX_NUM_OF_POOLS, E_INVALID_VALUE); 243296177Sjhibbits 244296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 245296177Sjhibbits { 246296177Sjhibbits return BmSetPool(h_Bm, 247296177Sjhibbits bpid, 248296177Sjhibbits thresholds[0], 249296177Sjhibbits thresholds[1], 250296177Sjhibbits thresholds[2], 251296177Sjhibbits thresholds[3]); 252296177Sjhibbits } 253296177Sjhibbits else if (p_Bm->h_Session) 254296177Sjhibbits { 255296177Sjhibbits t_BmIpcMsg msg; 256296177Sjhibbits t_BmIpcPoolThreshParams ipcPoolThresh; 257296177Sjhibbits t_Error errCode = E_OK; 258296177Sjhibbits 259296177Sjhibbits memset(&msg, 0, sizeof(t_BmIpcMsg)); 260296177Sjhibbits ipcPoolThresh.bpid = bpid; 261296177Sjhibbits memcpy(ipcPoolThresh.thresholds, thresholds, sizeof(uintptr_t) * MAX_DEPLETION_THRESHOLDS); 262296177Sjhibbits msg.msgId = BM_SET_POOL_THRESH; 263296177Sjhibbits memcpy(msg.msgBody, &ipcPoolThresh, sizeof(t_BmIpcPoolThreshParams)); 264296177Sjhibbits if ((errCode = XX_IpcSendMessage(p_Bm->h_Session, 265296177Sjhibbits (uint8_t*)&msg, 266296177Sjhibbits sizeof(msg.msgId) + sizeof(t_BmIpcPoolThreshParams), 267296177Sjhibbits NULL, 268296177Sjhibbits NULL, 269296177Sjhibbits NULL, 270296177Sjhibbits NULL)) != E_OK) 271296177Sjhibbits RETURN_ERROR(MAJOR, errCode, NO_MSG); 272296177Sjhibbits return E_OK; 273296177Sjhibbits } 274296177Sjhibbits else 275296177Sjhibbits RETURN_ERROR(WARNING, E_NOT_SUPPORTED, ("IPC")); 276296177Sjhibbits} 277296177Sjhibbits 278296177Sjhibbitst_Error BmUnSetPoolThresholds(t_Handle h_Bm, uint8_t bpid) 279296177Sjhibbits{ 280296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 281296177Sjhibbits 282296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 283296177Sjhibbits SANITY_CHECK_RETURN_ERROR(bpid < BM_MAX_NUM_OF_POOLS, E_INVALID_VALUE); 284296177Sjhibbits 285296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 286296177Sjhibbits { 287296177Sjhibbits return BmSetPool(h_Bm, 288296177Sjhibbits bpid, 289296177Sjhibbits 0, 290296177Sjhibbits 0, 291296177Sjhibbits 0, 292296177Sjhibbits 0); 293296177Sjhibbits } 294296177Sjhibbits else if (p_Bm->h_Session) 295296177Sjhibbits { 296296177Sjhibbits t_BmIpcMsg msg; 297296177Sjhibbits t_BmIpcPoolThreshParams ipcPoolThresh; 298296177Sjhibbits t_Error errCode = E_OK; 299296177Sjhibbits 300296177Sjhibbits memset(&msg, 0, sizeof(t_BmIpcMsg)); 301296177Sjhibbits memset(&ipcPoolThresh, 0, sizeof(t_BmIpcPoolThreshParams)); 302296177Sjhibbits ipcPoolThresh.bpid = bpid; 303296177Sjhibbits msg.msgId = BM_UNSET_POOL_THRESH; 304296177Sjhibbits memcpy(msg.msgBody, &ipcPoolThresh, sizeof(t_BmIpcPoolThreshParams)); 305296177Sjhibbits if ((errCode = XX_IpcSendMessage(p_Bm->h_Session, 306296177Sjhibbits (uint8_t*)&msg, 307296177Sjhibbits sizeof(msg.msgId) + sizeof(t_BmIpcPoolThreshParams), 308296177Sjhibbits NULL, 309296177Sjhibbits NULL, 310296177Sjhibbits NULL, 311296177Sjhibbits NULL)) != E_OK) 312296177Sjhibbits RETURN_ERROR(MAJOR, errCode, NO_MSG); 313296177Sjhibbits return E_OK; 314296177Sjhibbits } 315296177Sjhibbits else 316296177Sjhibbits RETURN_ERROR(WARNING, E_NOT_SUPPORTED, ("IPC")); 317296177Sjhibbits} 318296177Sjhibbits 319296177Sjhibbitsuint32_t BmGetCounter(t_Handle h_Bm, e_BmInterModuleCounters counter, uint8_t bpid) 320296177Sjhibbits{ 321296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 322296177Sjhibbits 323296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Bm, E_INVALID_HANDLE, 0); 324296177Sjhibbits SANITY_CHECK_RETURN_VALUE(bpid < BM_MAX_NUM_OF_POOLS, E_INVALID_VALUE, 0); 325296177Sjhibbits SANITY_CHECK_RETURN_VALUE((((p_Bm->guestId == NCSW_MASTER_ID) && p_Bm->p_BmRegs) || 326296177Sjhibbits (p_Bm->guestId != NCSW_MASTER_ID)), E_INVALID_STATE, 0); 327296177Sjhibbits 328296177Sjhibbits if ((p_Bm->guestId == NCSW_MASTER_ID) || 329296177Sjhibbits (!p_Bm->h_Session && p_Bm->p_BmRegs)) 330296177Sjhibbits { 331296177Sjhibbits switch(counter) 332296177Sjhibbits { 333296177Sjhibbits case(e_BM_IM_COUNTERS_POOL_CONTENT): 334296177Sjhibbits return GET_UINT32(p_Bm->p_BmRegs->content[bpid]); 335296177Sjhibbits case(e_BM_IM_COUNTERS_POOL_SW_DEPLETION): 336296177Sjhibbits return GET_UINT32(p_Bm->p_BmRegs->sdcnt[bpid]); 337296177Sjhibbits case(e_BM_IM_COUNTERS_POOL_HW_DEPLETION): 338296177Sjhibbits return GET_UINT32(p_Bm->p_BmRegs->hdcnt[bpid]); 339296177Sjhibbits case(e_BM_IM_COUNTERS_FBPR): 340296177Sjhibbits return GET_UINT32(p_Bm->p_BmRegs->fbpr_fpc); 341296177Sjhibbits default: 342296177Sjhibbits break; 343296177Sjhibbits } 344296177Sjhibbits /* should never get here */ 345296177Sjhibbits ASSERT_COND(FALSE); 346296177Sjhibbits } 347296177Sjhibbits else if (p_Bm->h_Session) 348296177Sjhibbits { 349296177Sjhibbits t_BmIpcMsg msg; 350296177Sjhibbits t_BmIpcReply reply; 351296177Sjhibbits t_BmIpcGetCounter ipcCounter; 352296177Sjhibbits uint32_t replyLength; 353296177Sjhibbits uint32_t count; 354296177Sjhibbits t_Error errCode = E_OK; 355296177Sjhibbits 356296177Sjhibbits memset(&msg, 0, sizeof(t_BmIpcMsg)); 357296177Sjhibbits memset(&reply, 0, sizeof(t_BmIpcReply)); 358296177Sjhibbits ipcCounter.bpid = bpid; 359296177Sjhibbits ipcCounter.enumId = (uint32_t)counter; 360296177Sjhibbits msg.msgId = BM_GET_COUNTER; 361296177Sjhibbits memcpy(msg.msgBody, &ipcCounter, sizeof(t_BmIpcGetCounter)); 362296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint32_t); 363296177Sjhibbits if ((errCode = XX_IpcSendMessage(p_Bm->h_Session, 364296177Sjhibbits (uint8_t*)&msg, 365296177Sjhibbits sizeof(msg.msgId) + sizeof(t_BmIpcGetCounter), 366296177Sjhibbits (uint8_t*)&reply, 367296177Sjhibbits &replyLength, 368296177Sjhibbits NULL, 369296177Sjhibbits NULL)) != E_OK) 370296177Sjhibbits REPORT_ERROR(MAJOR, errCode, NO_MSG); 371296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(uint32_t))) 372296177Sjhibbits { 373296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 374296177Sjhibbits errCode = E_INVALID_VALUE; 375296177Sjhibbits } 376296177Sjhibbits if (errCode == E_OK) 377296177Sjhibbits { 378296177Sjhibbits memcpy((uint8_t*)&count, reply.replyBody, sizeof(uint32_t)); 379296177Sjhibbits return count; 380296177Sjhibbits } 381296177Sjhibbits } 382296177Sjhibbits else 383296177Sjhibbits REPORT_ERROR(WARNING, E_NOT_SUPPORTED, 384296177Sjhibbits ("In 'guest', either IPC or 'baseAddress' is required!")); 385296177Sjhibbits 386296177Sjhibbits return 0; 387296177Sjhibbits} 388296177Sjhibbits 389296177Sjhibbitst_Error BmGetRevision(t_Handle h_Bm, t_BmRevisionInfo *p_BmRevisionInfo) 390296177Sjhibbits{ 391296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 392296177Sjhibbits uint32_t tmpReg; 393296177Sjhibbits 394296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 395296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_BmRevisionInfo, E_NULL_POINTER); 396296177Sjhibbits SANITY_CHECK_RETURN_ERROR((((p_Bm->guestId == NCSW_MASTER_ID) && p_Bm->p_BmRegs) || 397296177Sjhibbits (p_Bm->guestId != NCSW_MASTER_ID)), E_INVALID_STATE); 398296177Sjhibbits 399296177Sjhibbits if ((p_Bm->guestId == NCSW_MASTER_ID) || 400296177Sjhibbits (!p_Bm->h_Session && p_Bm->p_BmRegs)) 401296177Sjhibbits { 402296177Sjhibbits /* read revision register 1 */ 403296177Sjhibbits tmpReg = GET_UINT32(p_Bm->p_BmRegs->ip_rev_1); 404296177Sjhibbits p_BmRevisionInfo->majorRev = (uint8_t)((tmpReg & REV1_MAJOR_MASK) >> REV1_MAJOR_SHIFT); 405296177Sjhibbits p_BmRevisionInfo->minorRev = (uint8_t)((tmpReg & REV1_MINOR_MASK) >> REV1_MINOR_SHIFT); 406296177Sjhibbits } 407296177Sjhibbits else if (p_Bm->h_Session) 408296177Sjhibbits { 409296177Sjhibbits t_BmIpcMsg msg; 410296177Sjhibbits t_BmIpcReply reply; 411296177Sjhibbits t_BmIpcRevisionInfo ipcRevInfo; 412296177Sjhibbits uint32_t replyLength; 413296177Sjhibbits t_Error errCode = E_OK; 414296177Sjhibbits 415296177Sjhibbits memset(&msg, 0, sizeof(t_BmIpcMsg)); 416296177Sjhibbits memset(&reply, 0, sizeof(t_BmIpcReply)); 417296177Sjhibbits msg.msgId = BM_GET_REVISION; 418296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(t_BmIpcRevisionInfo); 419296177Sjhibbits if ((errCode = XX_IpcSendMessage(p_Bm->h_Session, 420296177Sjhibbits (uint8_t*)&msg, 421296177Sjhibbits sizeof(msg.msgId), 422296177Sjhibbits (uint8_t*)&reply, 423296177Sjhibbits &replyLength, 424296177Sjhibbits NULL, 425296177Sjhibbits NULL)) != E_OK) 426296177Sjhibbits RETURN_ERROR(MAJOR, errCode, NO_MSG); 427296177Sjhibbits if (replyLength != (sizeof(uint32_t) + sizeof(t_BmIpcRevisionInfo))) 428296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 429296177Sjhibbits 430296177Sjhibbits memcpy((uint8_t*)&ipcRevInfo, reply.replyBody, sizeof(t_BmIpcRevisionInfo)); 431296177Sjhibbits p_BmRevisionInfo->majorRev = ipcRevInfo.majorRev; 432296177Sjhibbits p_BmRevisionInfo->minorRev = ipcRevInfo.minorRev; 433296177Sjhibbits return (t_Error)(reply.error); 434296177Sjhibbits } 435296177Sjhibbits else 436296177Sjhibbits RETURN_ERROR(WARNING, E_NOT_SUPPORTED, 437296177Sjhibbits ("In 'guest', either IPC or 'baseAddress' is required!")); 438296177Sjhibbits 439296177Sjhibbits return E_OK; 440296177Sjhibbits} 441296177Sjhibbits 442296177Sjhibbitsstatic void FreeInitResources(t_Bm *p_Bm) 443296177Sjhibbits{ 444296177Sjhibbits if (p_Bm->p_FbprBase) 445296177Sjhibbits XX_FreeSmart(p_Bm->p_FbprBase); 446296177Sjhibbits if (p_Bm->h_Session) 447296177Sjhibbits XX_IpcFreeSession(p_Bm->h_Session); 448296177Sjhibbits if (p_Bm->h_BpidMm) 449296177Sjhibbits MM_Free(p_Bm->h_BpidMm); 450296177Sjhibbits} 451296177Sjhibbits 452296177Sjhibbits/****************************************/ 453296177Sjhibbits/* API Init unit functions */ 454296177Sjhibbits/****************************************/ 455296177Sjhibbits 456296177Sjhibbitst_Handle BM_Config(t_BmParam *p_BmParam) 457296177Sjhibbits{ 458296177Sjhibbits t_Bm *p_Bm; 459296177Sjhibbits 460296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_BmParam, E_INVALID_HANDLE, NULL); 461296177Sjhibbits 462296177Sjhibbits p_Bm = (t_Bm *)XX_Malloc(sizeof(t_Bm)); 463296177Sjhibbits if (!p_Bm) 464296177Sjhibbits { 465296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("BM obj!!!")); 466296177Sjhibbits return NULL; 467296177Sjhibbits } 468296177Sjhibbits memset(p_Bm, 0, sizeof(t_Bm)); 469296177Sjhibbits 470296177Sjhibbits p_Bm->p_BmDriverParams = (t_BmDriverParams *)XX_Malloc(sizeof(t_BmDriverParams)); 471296177Sjhibbits if (!p_Bm->p_BmDriverParams) 472296177Sjhibbits { 473296177Sjhibbits XX_Free(p_Bm); 474296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Bm driver parameters")); 475296177Sjhibbits return NULL; 476296177Sjhibbits } 477296177Sjhibbits memset(p_Bm->p_BmDriverParams, 0, sizeof(t_BmDriverParams)); 478296177Sjhibbits 479296177Sjhibbits p_Bm->guestId = p_BmParam->guestId; 480296177Sjhibbits p_Bm->p_BmDriverParams->partNumOfPools = p_BmParam->partNumOfPools; 481296177Sjhibbits p_Bm->p_BmDriverParams->partBpidBase = p_BmParam->partBpidBase; 482296177Sjhibbits p_Bm->p_BmRegs = (t_BmRegs *)UINT_TO_PTR(p_BmParam->baseAddress); 483296177Sjhibbits 484296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 485296177Sjhibbits { 486296177Sjhibbits p_Bm->exceptions = DEFAULT_exceptions; 487296177Sjhibbits p_Bm->f_Exception = p_BmParam->f_Exception; 488296177Sjhibbits p_Bm->h_App = p_BmParam->h_App; 489296177Sjhibbits p_Bm->errIrq = p_BmParam->errIrq; 490296177Sjhibbits p_Bm->p_BmDriverParams->totalNumOfBuffers = p_BmParam->totalNumOfBuffers; 491296177Sjhibbits p_Bm->p_BmDriverParams->fbprMemPartitionId = p_BmParam->fbprMemPartitionId; 492296177Sjhibbits p_Bm->p_BmDriverParams->fbprThreshold = DEFAULT_fbprThreshold; 493296177Sjhibbits p_Bm->p_BmDriverParams->liodn = p_BmParam->liodn; 494296177Sjhibbits 495296177Sjhibbits } 496296177Sjhibbits /* build the BM partition IPC address */ 497296177Sjhibbits memset(p_Bm->moduleName, 0, MODULE_NAME_SIZE); 498296177Sjhibbits if(Sprint (p_Bm->moduleName, "BM_0_%d",p_Bm->guestId) != (p_Bm->guestId<10 ? 6:7)) 499296177Sjhibbits { 500296177Sjhibbits XX_Free(p_Bm->p_BmDriverParams); 501296177Sjhibbits XX_Free(p_Bm); 502296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 503296177Sjhibbits return NULL; 504296177Sjhibbits } 505296177Sjhibbits return p_Bm; 506296177Sjhibbits} 507296177Sjhibbits 508296177Sjhibbitst_Error BM_Init(t_Handle h_Bm) 509296177Sjhibbits{ 510296177Sjhibbits t_Bm *p_Bm = (t_Bm *)h_Bm; 511296177Sjhibbits t_Error err; 512296177Sjhibbits 513296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 514296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm->p_BmDriverParams, E_INVALID_HANDLE); 515296177Sjhibbits 516296177Sjhibbits CHECK_INIT_PARAMETERS(p_Bm, CheckBmParameters); 517296177Sjhibbits 518296177Sjhibbits if (p_Bm->p_BmDriverParams->partNumOfPools) 519296177Sjhibbits if (MM_Init(&p_Bm->h_BpidMm, p_Bm->p_BmDriverParams->partBpidBase, p_Bm->p_BmDriverParams->partNumOfPools) != E_OK) 520296177Sjhibbits { 521296177Sjhibbits FreeInitResources(p_Bm); 522296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("BM-BPIDS-MEM partition!!!")); 523296177Sjhibbits } 524296177Sjhibbits 525296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 526296177Sjhibbits { 527296177Sjhibbits uint64_t phyAddr; 528296177Sjhibbits t_BmRevisionInfo revInfo; 529296177Sjhibbits uint32_t dsSize, exp; 530296177Sjhibbits 531296177Sjhibbits BmGetRevision(p_Bm, &revInfo); 532296177Sjhibbits DBG(TRACE, ("Bman ver:%02x,%02x", revInfo.majorRev, revInfo.minorRev)); 533296177Sjhibbits 534296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->liodnr, (uint16_t)p_Bm->p_BmDriverParams->liodn); 535296177Sjhibbits 536296177Sjhibbits /* FBPR memory */ 537296177Sjhibbits dsSize = (uint32_t)(p_Bm->p_BmDriverParams->totalNumOfBuffers * (FBPR_ENTRY_SIZE / 8)); 538296177Sjhibbits LOG2(dsSize, exp); 539296177Sjhibbits if (!POWER_OF_2(dsSize)) (exp++); 540296177Sjhibbits dsSize = (uint32_t)(1 << exp); 541296177Sjhibbits if (dsSize < (4*KILOBYTE)) 542296177Sjhibbits { 543296177Sjhibbits dsSize = (4*KILOBYTE); 544296177Sjhibbits LOG2(dsSize, exp); 545296177Sjhibbits } 546296177Sjhibbits p_Bm->p_FbprBase = XX_MallocSmart(dsSize, (int)p_Bm->p_BmDriverParams->fbprMemPartitionId, dsSize); 547296177Sjhibbits if (!p_Bm->p_FbprBase) 548296177Sjhibbits { 549296177Sjhibbits FreeInitResources(p_Bm); 550296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("FBPR obj!!!")); 551296177Sjhibbits } 552296177Sjhibbits phyAddr = XX_VirtToPhys(p_Bm->p_FbprBase); 553296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->fbpr_bare, ((uint32_t)(phyAddr >> 32) & 0xffff)); 554296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->fbpr_bar, (uint32_t)phyAddr); 555296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->fbpr_ar, (exp - 1)); 556296177Sjhibbits 557296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->fbpr_fp_lwit, p_Bm->p_BmDriverParams->fbprThreshold); 558296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->err_isr, p_Bm->exceptions); 559296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->err_ier, p_Bm->exceptions); 560296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->err_isdr, 0x0); 561296177Sjhibbits if (p_Bm->errIrq != NO_IRQ) 562296177Sjhibbits { 563296177Sjhibbits XX_SetIntr(p_Bm->errIrq, BM_ErrorIsr, p_Bm); 564296177Sjhibbits XX_EnableIntr(p_Bm->errIrq); 565296177Sjhibbits } 566296177Sjhibbits 567296177Sjhibbits if ((err = XX_IpcRegisterMsgHandler(p_Bm->moduleName, BmHandleIpcMsgCB, p_Bm, BM_IPC_MAX_REPLY_SIZE)) != E_OK) 568296177Sjhibbits { 569296177Sjhibbits FreeInitResources(p_Bm); 570296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 571296177Sjhibbits } 572296177Sjhibbits } 573296177Sjhibbits else /* guest mode */ 574296177Sjhibbits { 575296177Sjhibbits char masterModuleName[MODULE_NAME_SIZE]; 576296177Sjhibbits 577296177Sjhibbits memset(masterModuleName, 0, MODULE_NAME_SIZE); 578296177Sjhibbits if(Sprint (masterModuleName, "BM_0_%d", NCSW_MASTER_ID) != (NCSW_MASTER_ID<10 ? 6:7)) 579296177Sjhibbits { 580296177Sjhibbits FreeInitResources(p_Bm); 581296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 582296177Sjhibbits } 583296177Sjhibbits 584296177Sjhibbits p_Bm->h_Session = XX_IpcInitSession(masterModuleName, p_Bm->moduleName); 585296177Sjhibbits if (p_Bm->h_Session) 586296177Sjhibbits { 587296177Sjhibbits t_BmIpcMsg msg; 588296177Sjhibbits uint8_t isMasterAlive = 0; 589296177Sjhibbits t_BmIpcReply reply; 590296177Sjhibbits uint32_t replyLength; 591296177Sjhibbits 592296177Sjhibbits memset(&msg, 0, sizeof(t_BmIpcMsg)); 593296177Sjhibbits memset(&reply, 0, sizeof(t_BmIpcReply)); 594296177Sjhibbits msg.msgId = BM_MASTER_IS_ALIVE; 595296177Sjhibbits replyLength = sizeof(uint32_t) + sizeof(uint8_t); 596296177Sjhibbits do 597296177Sjhibbits { 598296177Sjhibbits blockingFlag = TRUE; 599296177Sjhibbits if ((err = XX_IpcSendMessage(p_Bm->h_Session, 600296177Sjhibbits (uint8_t*)&msg, 601296177Sjhibbits sizeof(msg.msgId), 602296177Sjhibbits (uint8_t*)&reply, 603296177Sjhibbits &replyLength, 604296177Sjhibbits BmIpcMsgCompletionCB, 605296177Sjhibbits p_Bm)) != E_OK) 606296177Sjhibbits REPORT_ERROR(MAJOR, err, NO_MSG); 607296177Sjhibbits while(blockingFlag) ; 608296177Sjhibbits if(replyLength != (sizeof(uint32_t) + sizeof(uint8_t))) 609296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); 610296177Sjhibbits isMasterAlive = *(uint8_t*)(reply.replyBody); 611296177Sjhibbits } while (!isMasterAlive); 612296177Sjhibbits } 613296177Sjhibbits } 614296177Sjhibbits 615296177Sjhibbits XX_Free(p_Bm->p_BmDriverParams); 616296177Sjhibbits p_Bm->p_BmDriverParams = NULL; 617296177Sjhibbits 618296177Sjhibbits return E_OK; 619296177Sjhibbits} 620296177Sjhibbits 621296177Sjhibbitst_Error BM_Free(t_Handle h_Bm) 622296177Sjhibbits{ 623296177Sjhibbits t_Bm *p_Bm = (t_Bm *)h_Bm; 624296177Sjhibbits 625296177Sjhibbits if (!p_Bm) 626296177Sjhibbits return ERROR_CODE(E_INVALID_HANDLE); 627296177Sjhibbits 628296177Sjhibbits if (p_Bm->guestId == NCSW_MASTER_ID) 629296177Sjhibbits { 630296177Sjhibbits XX_IpcUnregisterMsgHandler(p_Bm->moduleName); 631296177Sjhibbits if (p_Bm->errIrq != NO_IRQ) 632296177Sjhibbits { 633296177Sjhibbits XX_DisableIntr(p_Bm->errIrq); 634296177Sjhibbits XX_FreeIntr(p_Bm->errIrq); 635296177Sjhibbits } 636296177Sjhibbits } 637296177Sjhibbits FreeInitResources(p_Bm); 638296177Sjhibbits 639296177Sjhibbits if(p_Bm->p_BmDriverParams) 640296177Sjhibbits XX_Free(p_Bm->p_BmDriverParams); 641296177Sjhibbits 642296177Sjhibbits XX_Free(p_Bm); 643296177Sjhibbits return E_OK; 644296177Sjhibbits} 645296177Sjhibbits 646296177Sjhibbitst_Error BM_ConfigException(t_Handle h_Bm, e_BmExceptions exception, bool enable) 647296177Sjhibbits{ 648296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 649296177Sjhibbits uint32_t bitMask = 0; 650296177Sjhibbits 651296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 652296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm->p_BmDriverParams, E_INVALID_HANDLE); 653296177Sjhibbits 654296177Sjhibbits GET_EXCEPTION_FLAG(bitMask, exception); 655296177Sjhibbits if(bitMask) 656296177Sjhibbits { 657296177Sjhibbits if (enable) 658296177Sjhibbits p_Bm->exceptions |= bitMask; 659296177Sjhibbits else 660296177Sjhibbits p_Bm->exceptions &= ~bitMask; 661296177Sjhibbits } 662296177Sjhibbits else 663296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception")); 664296177Sjhibbits 665296177Sjhibbits return E_OK; 666296177Sjhibbits} 667296177Sjhibbits 668296177Sjhibbitst_Error BM_ConfigFbprThreshold(t_Handle h_Bm, uint32_t threshold) 669296177Sjhibbits{ 670296177Sjhibbits t_Bm *p_Bm = (t_Bm *)h_Bm; 671296177Sjhibbits 672296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 673296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm->p_BmDriverParams, E_INVALID_HANDLE); 674296177Sjhibbits 675296177Sjhibbits p_Bm->p_BmDriverParams->fbprThreshold = threshold; 676296177Sjhibbits 677296177Sjhibbits return E_OK; 678296177Sjhibbits} 679296177Sjhibbits 680296177Sjhibbitsvoid BM_ErrorIsr(t_Handle h_Bm) 681296177Sjhibbits{ 682296177Sjhibbits t_Bm *p_Bm = (t_Bm *)h_Bm; 683296177Sjhibbits uint32_t tmpReg; 684296177Sjhibbits 685296177Sjhibbits SANITY_CHECK_RETURN(p_Bm, E_INVALID_HANDLE); 686296177Sjhibbits 687296177Sjhibbits if (p_Bm->guestId != NCSW_MASTER_ID) 688296177Sjhibbits { 689296177Sjhibbits REPORT_ERROR(WARNING, E_INVALID_OPERATION, ("Master Only")); 690296177Sjhibbits return; 691296177Sjhibbits } 692296177Sjhibbits 693296177Sjhibbits tmpReg = GET_UINT32(p_Bm->p_BmRegs->err_isr); 694296177Sjhibbits tmpReg &= GET_UINT32(p_Bm->p_BmRegs->err_ier); 695296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->err_isr, tmpReg); 696296177Sjhibbits 697296177Sjhibbits if (tmpReg & BM_EX_INVALID_COMMAND) 698296177Sjhibbits p_Bm->f_Exception(p_Bm->h_App, e_BM_EX_INVALID_COMMAND); 699296177Sjhibbits if (tmpReg & BM_EX_FBPR_THRESHOLD) 700296177Sjhibbits p_Bm->f_Exception(p_Bm->h_App, e_BM_EX_FBPR_THRESHOLD); 701296177Sjhibbits if (tmpReg & BM_EX_MULTI_ECC) 702296177Sjhibbits p_Bm->f_Exception(p_Bm->h_App, e_BM_EX_MULTI_ECC); 703296177Sjhibbits if (tmpReg & BM_EX_SINGLE_ECC) 704296177Sjhibbits p_Bm->f_Exception(p_Bm->h_App, e_BM_EX_SINGLE_ECC); 705296177Sjhibbits} 706296177Sjhibbits 707296177Sjhibbitsuint32_t BM_GetCounter(t_Handle h_Bm, e_BmCounters counter) 708296177Sjhibbits{ 709296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 710296177Sjhibbits 711296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_Bm, E_INVALID_HANDLE, 0); 712296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_Bm->p_BmDriverParams, E_INVALID_STATE, 0); 713296177Sjhibbits 714296177Sjhibbits switch(counter) 715296177Sjhibbits { 716296177Sjhibbits case(e_BM_COUNTERS_FBPR): 717296177Sjhibbits return BmGetCounter(p_Bm, e_BM_IM_COUNTERS_FBPR, 0); 718296177Sjhibbits default: 719296177Sjhibbits break; 720296177Sjhibbits } 721296177Sjhibbits /* should never get here */ 722296177Sjhibbits ASSERT_COND(FALSE); 723296177Sjhibbits 724296177Sjhibbits return 0; 725296177Sjhibbits} 726296177Sjhibbits 727296177Sjhibbitst_Error BM_SetException(t_Handle h_Bm, e_BmExceptions exception, bool enable) 728296177Sjhibbits{ 729296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 730296177Sjhibbits uint32_t tmpReg, bitMask = 0; 731296177Sjhibbits 732296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 733296177Sjhibbits 734296177Sjhibbits if (p_Bm->guestId != NCSW_MASTER_ID) 735296177Sjhibbits RETURN_ERROR(WARNING, E_INVALID_OPERATION, ("Master Only")); 736296177Sjhibbits 737296177Sjhibbits BM_ConfigException(p_Bm, exception, enable); 738296177Sjhibbits 739296177Sjhibbits tmpReg = GET_UINT32(p_Bm->p_BmRegs->err_ier); 740296177Sjhibbits 741296177Sjhibbits if(enable) 742296177Sjhibbits tmpReg |= bitMask; 743296177Sjhibbits else 744296177Sjhibbits tmpReg &= ~bitMask; 745296177Sjhibbits WRITE_UINT32(p_Bm->p_BmRegs->err_ier, tmpReg); 746296177Sjhibbits 747296177Sjhibbits return E_OK; 748296177Sjhibbits} 749296177Sjhibbits 750296177Sjhibbitst_Error BM_GetRevision(t_Handle h_Bm, t_BmRevisionInfo *p_BmRevisionInfo) 751296177Sjhibbits{ 752296177Sjhibbits t_Bm *p_Bm = (t_Bm*)h_Bm; 753296177Sjhibbits 754296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 755296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_BmRevisionInfo, E_NULL_POINTER); 756296177Sjhibbits 757296177Sjhibbits return BmGetRevision(p_Bm, p_BmRevisionInfo); 758296177Sjhibbits} 759296177Sjhibbits 760296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 761296177Sjhibbitst_Error BM_DumpRegs(t_Handle h_Bm) 762296177Sjhibbits{ 763296177Sjhibbits t_Bm *p_Bm = (t_Bm *)h_Bm; 764296177Sjhibbits 765296177Sjhibbits DECLARE_DUMP; 766296177Sjhibbits 767296177Sjhibbits if (p_Bm->guestId != NCSW_MASTER_ID) 768296177Sjhibbits RETURN_ERROR(WARNING, E_INVALID_OPERATION, ("Master Only")); 769296177Sjhibbits 770296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_Bm, E_INVALID_HANDLE); 771296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_Bm->p_BmDriverParams, E_INVALID_STATE); 772296177Sjhibbits 773296177Sjhibbits DUMP_SUBTITLE(("\n")); 774296177Sjhibbits 775296177Sjhibbits DUMP_TITLE(p_Bm->p_BmRegs, ("BmRegs Regs")); 776296177Sjhibbits 777296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, swdet); 778296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, hwdet); 779296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, swdxt); 780296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, hwdxt); 781296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, sdcnt); 782296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, hdcnt); 783296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, content); 784296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, hdptr); 785296177Sjhibbits 786296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,fbpr_fpc); 787296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,fbpr_fp_lwit); 788296177Sjhibbits 789296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, cmd_pm_cfg); 790296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, fl_pm_cfg); 791296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs, ecsr); 792296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs, ecir); 793296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs, eadr); 794296177Sjhibbits DUMP_ARR(p_Bm->p_BmRegs, edata); 795296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,sbet); 796296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,efcr); 797296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,efar); 798296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,sbec0); 799296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,sbec1); 800296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,ip_rev_1); 801296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,ip_rev_2); 802296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,fbpr_bare); 803296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,fbpr_bar); 804296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,fbpr_ar); 805296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,srcidr); 806296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,liodnr); 807296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,err_isr); 808296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,err_ier); 809296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,err_isdr); 810296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,err_iir); 811296177Sjhibbits DUMP_VAR(p_Bm->p_BmRegs,err_ifr); 812296177Sjhibbits 813296177Sjhibbits return E_OK; 814296177Sjhibbits} 815296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && ... */ 816