fm_port.c revision 296177
1296177Sjhibbits/* Copyright (c) 2008-2011 Freescale Semiconductor, Inc. 2296177Sjhibbits * All rights reserved. 3296177Sjhibbits * 4296177Sjhibbits * Redistribution and use in source and binary forms, with or without 5296177Sjhibbits * modification, are permitted provided that the following conditions are met: 6296177Sjhibbits * * Redistributions of source code must retain the above copyright 7296177Sjhibbits * notice, this list of conditions and the following disclaimer. 8296177Sjhibbits * * Redistributions in binary form must reproduce the above copyright 9296177Sjhibbits * notice, this list of conditions and the following disclaimer in the 10296177Sjhibbits * documentation and/or other materials provided with the distribution. 11296177Sjhibbits * * Neither the name of Freescale Semiconductor nor the 12296177Sjhibbits * names of its contributors may be used to endorse or promote products 13296177Sjhibbits * derived from this software without specific prior written permission. 14296177Sjhibbits * 15296177Sjhibbits * 16296177Sjhibbits * ALTERNATIVELY, this software may be distributed under the terms of the 17296177Sjhibbits * GNU General Public License ("GPL") as published by the Free Software 18296177Sjhibbits * Foundation, either version 2 of that License or (at your option) any 19296177Sjhibbits * later version. 20296177Sjhibbits * 21296177Sjhibbits * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY 22296177Sjhibbits * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23296177Sjhibbits * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24296177Sjhibbits * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY 25296177Sjhibbits * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26296177Sjhibbits * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27296177Sjhibbits * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 28296177Sjhibbits * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29296177Sjhibbits * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30296177Sjhibbits * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31296177Sjhibbits */ 32296177Sjhibbits 33296177Sjhibbits/****************************************************************************** 34296177Sjhibbits @File fm_port.c 35296177Sjhibbits 36296177Sjhibbits @Description FM driver routines implementation. 37296177Sjhibbits*//***************************************************************************/ 38296177Sjhibbits#include "error_ext.h" 39296177Sjhibbits#include "std_ext.h" 40296177Sjhibbits#include "string_ext.h" 41296177Sjhibbits#include "sprint_ext.h" 42296177Sjhibbits#include "debug_ext.h" 43296177Sjhibbits#include "fm_pcd_ext.h" 44296177Sjhibbits 45296177Sjhibbits#include "fm_port.h" 46296177Sjhibbits 47296177Sjhibbits 48296177Sjhibbits/****************************************/ 49296177Sjhibbits/* static functions */ 50296177Sjhibbits/****************************************/ 51296177Sjhibbits 52296177Sjhibbitsstatic t_Error CheckInitParameters(t_FmPort *p_FmPort) 53296177Sjhibbits{ 54296177Sjhibbits t_FmPortDriverParam *p_Params = p_FmPort->p_FmPortDriverParam; 55296177Sjhibbits t_Error ans = E_OK; 56296177Sjhibbits uint32_t unusedMask; 57296177Sjhibbits uint8_t i; 58296177Sjhibbits uint8_t j; 59296177Sjhibbits bool found; 60296177Sjhibbits 61296177Sjhibbits if (p_FmPort->imEn) 62296177Sjhibbits { 63296177Sjhibbits if ((ans = FmPortImCheckInitParameters(p_FmPort)) != E_OK) 64296177Sjhibbits return ERROR_CODE(ans); 65296177Sjhibbits } 66296177Sjhibbits else 67296177Sjhibbits { 68296177Sjhibbits /****************************************/ 69296177Sjhibbits /* Rx only */ 70296177Sjhibbits /****************************************/ 71296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 72296177Sjhibbits { 73296177Sjhibbits /* external buffer pools */ 74296177Sjhibbits if(!p_Params->extBufPools.numOfPoolsUsed) 75296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("extBufPools.numOfPoolsUsed=0. At least one buffer pool must be defined")); 76296177Sjhibbits 77296177Sjhibbits if(p_Params->extBufPools.numOfPoolsUsed > FM_PORT_MAX_NUM_OF_EXT_POOLS) 78296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("numOfPoolsUsed can't be larger than %d", FM_PORT_MAX_NUM_OF_EXT_POOLS)); 79296177Sjhibbits 80296177Sjhibbits for(i=0;i<p_Params->extBufPools.numOfPoolsUsed;i++) 81296177Sjhibbits { 82296177Sjhibbits if(p_Params->extBufPools.extBufPool[i].id >= BM_MAX_NUM_OF_POOLS) 83296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("extBufPools.extBufPool[%d].id can't be larger than %d", i, BM_MAX_NUM_OF_POOLS)); 84296177Sjhibbits if(!p_Params->extBufPools.extBufPool[i].size) 85296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("extBufPools.extBufPool[%d].size is 0", i)); 86296177Sjhibbits } 87296177Sjhibbits 88296177Sjhibbits /* backup BM pools indication is valid only for some chip deriviatives 89296177Sjhibbits (limited by the config routine) */ 90296177Sjhibbits if(p_Params->p_BackupBmPools) 91296177Sjhibbits { 92296177Sjhibbits if(p_Params->p_BackupBmPools->numOfBackupPools >= p_Params->extBufPools.numOfPoolsUsed) 93296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("p_BackupBmPools must be smaller than extBufPools.numOfPoolsUsed")); 94296177Sjhibbits found = FALSE; 95296177Sjhibbits for(i = 0;i<p_Params->p_BackupBmPools->numOfBackupPools;i++) 96296177Sjhibbits for(j=0;j<p_Params->extBufPools.numOfPoolsUsed;j++) 97296177Sjhibbits if(p_Params->p_BackupBmPools->poolIds[i] == p_Params->extBufPools.extBufPool[j].id) 98296177Sjhibbits found = TRUE; 99296177Sjhibbits if (!found) 100296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("All p_BackupBmPools.poolIds must be included in extBufPools.extBufPool[n].id")); 101296177Sjhibbits } 102296177Sjhibbits 103296177Sjhibbits /* up to extBufPools.numOfPoolsUsed pools may be defined */ 104296177Sjhibbits if(p_Params->bufPoolDepletion.numberOfPoolsModeEnable) 105296177Sjhibbits { 106296177Sjhibbits if((p_Params->bufPoolDepletion.numOfPools > p_Params->extBufPools.numOfPoolsUsed)) 107296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufPoolDepletion.numOfPools can't be larger than %d and can't be larger than numOfPoolsUsed", FM_PORT_MAX_NUM_OF_EXT_POOLS)); 108296177Sjhibbits 109296177Sjhibbits if(!p_Params->bufPoolDepletion.numOfPools) 110296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufPoolDepletion.numOfPoolsToConsider can not be 0 when numberOfPoolsModeEnable=TRUE")); 111296177Sjhibbits } 112296177Sjhibbits /* Check that part of IC that needs copying is small enough to enter start margin */ 113296177Sjhibbits if(p_Params->intContext.size + p_Params->intContext.extBufOffset > p_Params->bufMargins.startMargins) 114296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.size is larger than start margins")); 115296177Sjhibbits 116296177Sjhibbits if(p_Params->liodnOffset & ~FM_LIODN_OFFSET_MASK) 117296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("liodnOffset is larger than %d", FM_LIODN_OFFSET_MASK+1)); 118296177Sjhibbits#ifdef FM_PARTITION_ARRAY 119296177Sjhibbits { 120296177Sjhibbits t_FmRevisionInfo revInfo; 121296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 122296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 123296177Sjhibbits { 124296177Sjhibbits if(p_Params->liodnOffset >= MAX_LIODN_OFFSET) 125296177Sjhibbits { 126296177Sjhibbits p_Params->liodnOffset = (uint16_t)(p_Params->liodnOffset & (MAX_LIODN_OFFSET-1)); 127296177Sjhibbits DBG(WARNING, ("liodnOffset number is out of rev1 range - MSB bits cleard.")); 128296177Sjhibbits } 129296177Sjhibbits } 130296177Sjhibbits } 131296177Sjhibbits#endif /* FM_PARTITION_ARRAY */ 132296177Sjhibbits } 133296177Sjhibbits 134296177Sjhibbits /****************************************/ 135296177Sjhibbits /* Non Rx ports */ 136296177Sjhibbits /****************************************/ 137296177Sjhibbits else 138296177Sjhibbits { 139296177Sjhibbits if(p_Params->deqSubPortal >= MAX_QMI_DEQ_SUBPORTAL) 140296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, (" deqSubPortal has to be in the range of 0 - %d", MAX_QMI_DEQ_SUBPORTAL)); 141296177Sjhibbits 142296177Sjhibbits /* to protect HW internal-context from overwrite */ 143296177Sjhibbits if((p_Params->intContext.size) && (p_Params->intContext.intContextOffset < MIN_TX_INT_OFFSET)) 144296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("non-Rx intContext.intContextOffset can't be smaller than %d", MIN_TX_INT_OFFSET)); 145296177Sjhibbits } 146296177Sjhibbits 147296177Sjhibbits /****************************************/ 148296177Sjhibbits /* Rx Or Offline Parsing */ 149296177Sjhibbits /****************************************/ 150296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 151296177Sjhibbits { 152296177Sjhibbits 153296177Sjhibbits if(!p_Params->dfltFqid) 154296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dfltFqid must be between 1 and 2^24-1")); 155296177Sjhibbits#if defined(FM_CAPWAP_SUPPORT) && defined(FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004) 156296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace % 16) 157296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufferPrefixContent.manipExtraSpace has to be devidable by 16")); 158296177Sjhibbits#endif /* defined(FM_CAPWAP_SUPPORT) && ... */ 159296177Sjhibbits } 160296177Sjhibbits 161296177Sjhibbits /****************************************/ 162296177Sjhibbits /* All ports */ 163296177Sjhibbits /****************************************/ 164296177Sjhibbits /* common BMI registers values */ 165296177Sjhibbits /* Check that Queue Id is not larger than 2^24, and is not 0 */ 166296177Sjhibbits if((p_Params->errFqid & ~0x00FFFFFF) || !p_Params->errFqid) 167296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("errFqid must be between 1 and 2^24-1")); 168296177Sjhibbits if(p_Params->dfltFqid & ~0x00FFFFFF) 169296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dfltFqid must be between 1 and 2^24-1")); 170296177Sjhibbits } 171296177Sjhibbits 172296177Sjhibbits /****************************************/ 173296177Sjhibbits /* Rx only */ 174296177Sjhibbits /****************************************/ 175296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 176296177Sjhibbits { 177296177Sjhibbits /* Check that divisible by 256 and not larger than 256 */ 178296177Sjhibbits if(p_Params->rxFifoPriElevationLevel % BMI_FIFO_UNITS) 179296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("rxFifoPriElevationLevel has to be divisible by %d", BMI_FIFO_UNITS)); 180296177Sjhibbits if(!p_Params->rxFifoPriElevationLevel || (p_Params->rxFifoPriElevationLevel > BMI_MAX_FIFO_SIZE)) 181296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("rxFifoPriElevationLevel has to be in the range of 256 - %d", BMI_MAX_FIFO_SIZE)); 182296177Sjhibbits if(p_Params->rxFifoThreshold % BMI_FIFO_UNITS) 183296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("rxFifoThreshold has to be divisible by %d", BMI_FIFO_UNITS)); 184296177Sjhibbits if(!p_Params->rxFifoThreshold ||(p_Params->rxFifoThreshold > BMI_MAX_FIFO_SIZE)) 185296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("rxFifoThreshold has to be in the range of 256 - %d", BMI_MAX_FIFO_SIZE)); 186296177Sjhibbits 187296177Sjhibbits /* Check that not larger than 16 */ 188296177Sjhibbits if(p_Params->cutBytesFromEnd > FRAME_END_DATA_SIZE) 189296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("cutBytesFromEnd can't be larger than %d", FRAME_END_DATA_SIZE)); 190296177Sjhibbits 191296177Sjhibbits /* Check the margin definition */ 192296177Sjhibbits if(p_Params->bufMargins.startMargins > MAX_EXT_BUFFER_OFFSET) 193296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufMargins.startMargins can't be larger than %d", MAX_EXT_BUFFER_OFFSET)); 194296177Sjhibbits if(p_Params->bufMargins.endMargins > MAX_EXT_BUFFER_OFFSET) 195296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufMargins.endMargins can't be larger than %d", MAX_EXT_BUFFER_OFFSET)); 196296177Sjhibbits 197296177Sjhibbits /* extra FIFO size (allowed only to Rx ports) */ 198296177Sjhibbits if(p_FmPort->fifoBufs.extra % BMI_FIFO_UNITS) 199296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("fifoBufs.extra has to be divisible by %d", BMI_FIFO_UNITS)); 200296177Sjhibbits 201296177Sjhibbits if(p_Params->bufPoolDepletion.numberOfPoolsModeEnable && 202296177Sjhibbits !p_Params->bufPoolDepletion.numOfPools) 203296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufPoolDepletion.numOfPoolsToConsider can not be 0 when numberOfPoolsModeEnable=TRUE")); 204296177Sjhibbits#ifdef FM_CSI_CFED_LIMIT 205296177Sjhibbits { 206296177Sjhibbits t_FmRevisionInfo revInfo; 207296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 208296177Sjhibbits 209296177Sjhibbits if (revInfo.majorRev == 4) 210296177Sjhibbits { 211296177Sjhibbits /* Check that not larger than 16 */ 212296177Sjhibbits if(p_Params->cutBytesFromEnd + p_Params->cheksumLastBytesIgnore > FRAME_END_DATA_SIZE) 213296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("cheksumLastBytesIgnore + cutBytesFromEnd can't be larger than %d", FRAME_END_DATA_SIZE)); 214296177Sjhibbits } 215296177Sjhibbits } 216296177Sjhibbits#endif /* FM_CSI_CFED_LIMIT */ 217296177Sjhibbits 218296177Sjhibbits } 219296177Sjhibbits 220296177Sjhibbits /****************************************/ 221296177Sjhibbits /* Non Rx ports */ 222296177Sjhibbits /****************************************/ 223296177Sjhibbits else 224296177Sjhibbits /* extra FIFO size (allowed only to Rx ports) */ 225296177Sjhibbits if(p_FmPort->fifoBufs.extra) 226296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, (" No fifoBufs.extra for non Rx ports")); 227296177Sjhibbits 228296177Sjhibbits /****************************************/ 229296177Sjhibbits /* Rx & Tx */ 230296177Sjhibbits /****************************************/ 231296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_TX) || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G) || 232296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 233296177Sjhibbits { 234296177Sjhibbits /* Check that not larger than 16 */ 235296177Sjhibbits if(p_Params->cheksumLastBytesIgnore > FRAME_END_DATA_SIZE) 236296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("cheksumLastBytesIgnore can't be larger than %d", FRAME_END_DATA_SIZE)); 237296177Sjhibbits } 238296177Sjhibbits 239296177Sjhibbits /****************************************/ 240296177Sjhibbits /* Tx only */ 241296177Sjhibbits /****************************************/ 242296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_TX) || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)) 243296177Sjhibbits { 244296177Sjhibbits /* Check that divisible by 256 and not larger than 256 */ 245296177Sjhibbits if(p_Params->txFifoMinFillLevel % BMI_FIFO_UNITS) 246296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoMinFillLevel has to be divisible by %d", BMI_FIFO_UNITS)); 247296177Sjhibbits if(p_Params->txFifoMinFillLevel > (BMI_MAX_FIFO_SIZE - 256)) 248296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoMinFillLevel has to be in the range of 0 - %d", BMI_MAX_FIFO_SIZE)); 249296177Sjhibbits if(p_Params->txFifoLowComfLevel % BMI_FIFO_UNITS) 250296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoLowComfLevel has to be divisible by %d", BMI_FIFO_UNITS)); 251296177Sjhibbits if(!p_Params->txFifoLowComfLevel || (p_Params->txFifoLowComfLevel > BMI_MAX_FIFO_SIZE)) 252296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoLowComfLevel has to be in the range of 256 - %d", BMI_MAX_FIFO_SIZE)); 253296177Sjhibbits 254296177Sjhibbits /* Check that not larger than 8 */ 255296177Sjhibbits if((!p_FmPort->txFifoDeqPipelineDepth) ||( p_FmPort->txFifoDeqPipelineDepth > MAX_FIFO_PIPELINE_DEPTH)) 256296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoDeqPipelineDepth can't be larger than %d", MAX_FIFO_PIPELINE_DEPTH)); 257296177Sjhibbits if(p_FmPort->portType == e_FM_PORT_TYPE_TX) 258296177Sjhibbits if(p_FmPort->txFifoDeqPipelineDepth > 2) 259296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("txFifoDeqPipelineDepth for !G can't be larger than 2")); 260296177Sjhibbits } 261296177Sjhibbits else 262296177Sjhibbits /****************************************/ 263296177Sjhibbits /* Non Tx Ports */ 264296177Sjhibbits /****************************************/ 265296177Sjhibbits { 266296177Sjhibbits /* If discard override was selected , no frames may be discarded. */ 267296177Sjhibbits if(p_Params->frmDiscardOverride && p_Params->errorsToDiscard) 268296177Sjhibbits RETURN_ERROR(MAJOR, E_CONFLICT, ("errorsToDiscard is not empty, but frmDiscardOverride selected (all discarded frames to be enqueued to error queue).")); 269296177Sjhibbits } 270296177Sjhibbits 271296177Sjhibbits /****************************************/ 272296177Sjhibbits /* Rx and Offline parsing */ 273296177Sjhibbits /****************************************/ 274296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) 275296177Sjhibbits || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 276296177Sjhibbits { 277296177Sjhibbits if(p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 278296177Sjhibbits unusedMask = BMI_STATUS_OP_MASK_UNUSED; 279296177Sjhibbits else 280296177Sjhibbits unusedMask = BMI_STATUS_RX_MASK_UNUSED; 281296177Sjhibbits 282296177Sjhibbits /* Check that no common bits with BMI_STATUS_MASK_UNUSED */ 283296177Sjhibbits if(p_Params->errorsToDiscard & unusedMask) 284296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_SELECTION, ("errorsToDiscard contains undefined bits")); 285296177Sjhibbits } 286296177Sjhibbits 287296177Sjhibbits /****************************************/ 288296177Sjhibbits /* All ports */ 289296177Sjhibbits /****************************************/ 290296177Sjhibbits 291296177Sjhibbits /* Check that divisible by 16 and not larger than 240 */ 292296177Sjhibbits if(p_Params->intContext.intContextOffset >MAX_INT_OFFSET) 293296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.intContextOffset can't be larger than %d", MAX_INT_OFFSET)); 294296177Sjhibbits if(p_Params->intContext.intContextOffset % OFFSET_UNITS) 295296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.intContextOffset has to be divisible by %d", OFFSET_UNITS)); 296296177Sjhibbits 297296177Sjhibbits /* check that ic size+ic internal offset, does not exceed ic block size */ 298296177Sjhibbits if(p_Params->intContext.size + p_Params->intContext.intContextOffset > MAX_IC_SIZE) 299296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.size + intContext.intContextOffset has to be smaller than %d", MAX_IC_SIZE)); 300296177Sjhibbits /* Check that divisible by 16 and not larger than 256 */ 301296177Sjhibbits if(p_Params->intContext.size % OFFSET_UNITS) 302296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.size has to be divisible by %d", OFFSET_UNITS)); 303296177Sjhibbits 304296177Sjhibbits /* Check that divisible by 16 and not larger than 4K */ 305296177Sjhibbits if(p_Params->intContext.extBufOffset > MAX_EXT_OFFSET) 306296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.extBufOffset can't be larger than %d", MAX_EXT_OFFSET)); 307296177Sjhibbits if(p_Params->intContext.extBufOffset % OFFSET_UNITS) 308296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("intContext.extBufOffset has to be divisible by %d", OFFSET_UNITS)); 309296177Sjhibbits 310296177Sjhibbits /* common BMI registers values */ 311296177Sjhibbits if((!p_FmPort->tasks.num) || (p_FmPort->tasks.num > MAX_NUM_OF_TASKS)) 312296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("tasks.num can't be larger than %d", MAX_NUM_OF_TASKS)); 313296177Sjhibbits if(p_FmPort->tasks.extra > MAX_NUM_OF_EXTRA_TASKS) 314296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("tasks.extra can't be larger than %d", MAX_NUM_OF_EXTRA_TASKS)); 315296177Sjhibbits if((!p_FmPort->openDmas.num) || (p_FmPort->openDmas.num > MAX_NUM_OF_DMAS)) 316296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("openDmas.num can't be larger than %d", MAX_NUM_OF_DMAS)); 317296177Sjhibbits if(p_FmPort->openDmas.extra > MAX_NUM_OF_EXTRA_DMAS) 318296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("openDmas.extra can't be larger than %d", MAX_NUM_OF_EXTRA_DMAS)); 319296177Sjhibbits if(!p_FmPort->fifoBufs.num || (p_FmPort->fifoBufs.num > BMI_MAX_FIFO_SIZE)) 320296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("fifoBufs.num has to be in the range of 256 - %d", BMI_MAX_FIFO_SIZE)); 321296177Sjhibbits if(p_FmPort->fifoBufs.num % BMI_FIFO_UNITS) 322296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("fifoBufs.num has to be divisible by %d", BMI_FIFO_UNITS)); 323296177Sjhibbits 324296177Sjhibbits return E_OK; 325296177Sjhibbits} 326296177Sjhibbits 327296177Sjhibbitsstatic void FmPortDriverParamFree(t_FmPort *p_FmPort) 328296177Sjhibbits{ 329296177Sjhibbits if(p_FmPort->p_FmPortDriverParam) 330296177Sjhibbits { 331296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam); 332296177Sjhibbits p_FmPort->p_FmPortDriverParam = NULL; 333296177Sjhibbits } 334296177Sjhibbits} 335296177Sjhibbits 336296177Sjhibbitsstatic t_Error SetExtBufferPools(t_FmPort *p_FmPort) 337296177Sjhibbits{ 338296177Sjhibbits t_FmPortExtPools *p_ExtBufPools = &p_FmPort->p_FmPortDriverParam->extBufPools; 339296177Sjhibbits t_FmPortBufPoolDepletion *p_BufPoolDepletion = &p_FmPort->p_FmPortDriverParam->bufPoolDepletion; 340296177Sjhibbits volatile uint32_t *p_ExtBufRegs; 341296177Sjhibbits volatile uint32_t *p_BufPoolDepletionReg; 342296177Sjhibbits bool rxPort; 343296177Sjhibbits bool found; 344296177Sjhibbits uint8_t orderedArray[FM_PORT_MAX_NUM_OF_EXT_POOLS]; 345296177Sjhibbits uint16_t sizesArray[BM_MAX_NUM_OF_POOLS]; 346296177Sjhibbits uint8_t count = 0; 347296177Sjhibbits uint8_t numOfPools; 348296177Sjhibbits uint16_t bufSize = 0, largestBufSize = 0; 349296177Sjhibbits int i=0, j=0, k=0; 350296177Sjhibbits uint32_t tmpReg, vector, minFifoSizeRequired=0; 351296177Sjhibbits 352296177Sjhibbits memset(&orderedArray, 0, sizeof(uint8_t) * FM_PORT_MAX_NUM_OF_EXT_POOLS); 353296177Sjhibbits memset(&sizesArray, 0, sizeof(uint16_t) * BM_MAX_NUM_OF_POOLS); 354296177Sjhibbits memcpy(&p_FmPort->extBufPools, p_ExtBufPools, sizeof(t_FmPortExtPools)); 355296177Sjhibbits 356296177Sjhibbits switch(p_FmPort->portType) 357296177Sjhibbits { 358296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 359296177Sjhibbits case(e_FM_PORT_TYPE_RX): 360296177Sjhibbits p_ExtBufRegs = p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi; 361296177Sjhibbits p_BufPoolDepletionReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_mpd; 362296177Sjhibbits rxPort = TRUE; 363296177Sjhibbits break; 364296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 365296177Sjhibbits p_ExtBufRegs = p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oebmpi; 366296177Sjhibbits p_BufPoolDepletionReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ompd; 367296177Sjhibbits rxPort = FALSE; 368296177Sjhibbits break; 369296177Sjhibbits default: 370296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("Not available for port type")); 371296177Sjhibbits } 372296177Sjhibbits 373296177Sjhibbits /* First we copy the external buffers pools information to an ordered local array */ 374296177Sjhibbits for(i=0;i<p_ExtBufPools->numOfPoolsUsed;i++) 375296177Sjhibbits { 376296177Sjhibbits /* get pool size */ 377296177Sjhibbits bufSize = p_ExtBufPools->extBufPool[i].size; 378296177Sjhibbits 379296177Sjhibbits /* keep sizes in an array according to poolId for direct access */ 380296177Sjhibbits sizesArray[p_ExtBufPools->extBufPool[i].id] = bufSize; 381296177Sjhibbits 382296177Sjhibbits /* save poolId in an ordered array according to size */ 383296177Sjhibbits for (j=0;j<=i;j++) 384296177Sjhibbits { 385296177Sjhibbits /* this is the next free place in the array */ 386296177Sjhibbits if (j==i) 387296177Sjhibbits orderedArray[i] = p_ExtBufPools->extBufPool[i].id; 388296177Sjhibbits else 389296177Sjhibbits { 390296177Sjhibbits /* find the right place for this poolId */ 391296177Sjhibbits if(bufSize < sizesArray[orderedArray[j]]) 392296177Sjhibbits { 393296177Sjhibbits /* move the poolIds one place ahead to make room for this poolId */ 394296177Sjhibbits for(k=i;k>j;k--) 395296177Sjhibbits orderedArray[k] = orderedArray[k-1]; 396296177Sjhibbits 397296177Sjhibbits /* now k==j, this is the place for the new size */ 398296177Sjhibbits orderedArray[k] = p_ExtBufPools->extBufPool[i].id; 399296177Sjhibbits break; 400296177Sjhibbits } 401296177Sjhibbits } 402296177Sjhibbits } 403296177Sjhibbits } 404296177Sjhibbits 405296177Sjhibbits /* build the register value */ 406296177Sjhibbits 407296177Sjhibbits for(i=0;i<p_ExtBufPools->numOfPoolsUsed;i++) 408296177Sjhibbits { 409296177Sjhibbits tmpReg = BMI_EXT_BUF_POOL_VALID | BMI_EXT_BUF_POOL_EN_COUNTER; 410296177Sjhibbits tmpReg |= ((uint32_t)orderedArray[i] << BMI_EXT_BUF_POOL_ID_SHIFT); 411296177Sjhibbits tmpReg |= sizesArray[orderedArray[i]]; 412296177Sjhibbits /* functionality available only for some deriviatives (limited by config) */ 413296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->p_BackupBmPools) 414296177Sjhibbits for(j=0;j<p_FmPort->p_FmPortDriverParam->p_BackupBmPools->numOfBackupPools;j++) 415296177Sjhibbits if(orderedArray[i] == p_FmPort->p_FmPortDriverParam->p_BackupBmPools->poolIds[j]) 416296177Sjhibbits { 417296177Sjhibbits tmpReg |= BMI_EXT_BUF_POOL_BACKUP; 418296177Sjhibbits break; 419296177Sjhibbits } 420296177Sjhibbits WRITE_UINT32(*(p_ExtBufRegs+i), tmpReg); 421296177Sjhibbits } 422296177Sjhibbits 423296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->p_BackupBmPools) 424296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam->p_BackupBmPools); 425296177Sjhibbits 426296177Sjhibbits numOfPools = (uint8_t)(rxPort ? FM_PORT_MAX_NUM_OF_EXT_POOLS:FM_PORT_MAX_NUM_OF_OBSERVED_EXT_POOLS); 427296177Sjhibbits 428296177Sjhibbits /* clear unused pools */ 429296177Sjhibbits for(i=p_ExtBufPools->numOfPoolsUsed;i<numOfPools;i++) 430296177Sjhibbits WRITE_UINT32(*(p_ExtBufRegs+i), 0); 431296177Sjhibbits 432296177Sjhibbits p_FmPort->rxPoolsParams.largestBufSize = largestBufSize = sizesArray[orderedArray[p_ExtBufPools->numOfPoolsUsed-1]]; 433296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 434296177Sjhibbits { 435296177Sjhibbits#ifdef FM_FIFO_ALLOCATION_OLD_ALG 436296177Sjhibbits t_FmRevisionInfo revInfo; 437296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 438296177Sjhibbits 439296177Sjhibbits if(revInfo.majorRev != 4) 440296177Sjhibbits { 441296177Sjhibbits minFifoSizeRequired = (uint32_t)(((largestBufSize % BMI_FIFO_UNITS) ? 442296177Sjhibbits ((largestBufSize/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS) : 443296177Sjhibbits largestBufSize) + 444296177Sjhibbits (7*BMI_FIFO_UNITS)); 445296177Sjhibbits } 446296177Sjhibbits else 447296177Sjhibbits#endif /* FM_FIFO_ALLOCATION_OLD_ALG */ 448296177Sjhibbits { 449296177Sjhibbits p_FmPort->rxPoolsParams.numOfPools = p_ExtBufPools->numOfPoolsUsed; 450296177Sjhibbits if(p_ExtBufPools->numOfPoolsUsed == 1) 451296177Sjhibbits minFifoSizeRequired = 8*BMI_FIFO_UNITS; 452296177Sjhibbits else 453296177Sjhibbits { 454296177Sjhibbits uint16_t secondLargestBufSize = sizesArray[orderedArray[p_ExtBufPools->numOfPoolsUsed-2]]; 455296177Sjhibbits p_FmPort->rxPoolsParams.secondLargestBufSize = secondLargestBufSize; 456296177Sjhibbits minFifoSizeRequired = (uint32_t)(((secondLargestBufSize % BMI_FIFO_UNITS) ? 457296177Sjhibbits ((secondLargestBufSize/BMI_FIFO_UNITS + 1) * BMI_FIFO_UNITS) : 458296177Sjhibbits secondLargestBufSize) + 459296177Sjhibbits (7*BMI_FIFO_UNITS)); 460296177Sjhibbits } 461296177Sjhibbits } 462296177Sjhibbits if(p_FmPort->fifoBufs.num < minFifoSizeRequired) 463296177Sjhibbits { 464296177Sjhibbits p_FmPort->fifoBufs.num = minFifoSizeRequired; 465296177Sjhibbits DBG(INFO, ("FIFO size for Rx port enlarged to %d",minFifoSizeRequired)); 466296177Sjhibbits } 467296177Sjhibbits } 468296177Sjhibbits 469296177Sjhibbits /* check if pool size is not too big */ 470296177Sjhibbits /* This is a definition problem in which if the fifo for the RX port 471296177Sjhibbits is lower than the largest pool size the hardware will allocate scatter gather 472296177Sjhibbits buffers even though the frame size can fit in a single buffer. */ 473296177Sjhibbits if (largestBufSize > p_FmPort->fifoBufs.num) 474296177Sjhibbits DBG(WARNING, ("Frame larger than port Fifo size (%u) will be split to more than a single buffer (S/G) even if shorter than largest buffer size (%u)", 475296177Sjhibbits p_FmPort->fifoBufs.num, largestBufSize)); 476296177Sjhibbits 477296177Sjhibbits /* pool depletion */ 478296177Sjhibbits tmpReg = 0; 479296177Sjhibbits if(p_BufPoolDepletion->numberOfPoolsModeEnable) 480296177Sjhibbits { 481296177Sjhibbits /* calculate vector for number of pools depletion */ 482296177Sjhibbits found = FALSE; 483296177Sjhibbits vector = 0; 484296177Sjhibbits count = 0; 485296177Sjhibbits for(i=0;i<BM_MAX_NUM_OF_POOLS;i++) 486296177Sjhibbits { 487296177Sjhibbits if(p_BufPoolDepletion->poolsToConsider[i]) 488296177Sjhibbits { 489296177Sjhibbits for(j=0;j<p_ExtBufPools->numOfPoolsUsed;j++) 490296177Sjhibbits { 491296177Sjhibbits if (i == orderedArray[j]) 492296177Sjhibbits { 493296177Sjhibbits vector |= 0x80000000 >> j; 494296177Sjhibbits found = TRUE; 495296177Sjhibbits count++; 496296177Sjhibbits break; 497296177Sjhibbits } 498296177Sjhibbits } 499296177Sjhibbits if (!found) 500296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Pools selected for depletion are not used.")); 501296177Sjhibbits else 502296177Sjhibbits found = FALSE; 503296177Sjhibbits } 504296177Sjhibbits } 505296177Sjhibbits if (count < p_BufPoolDepletion->numOfPools) 506296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufPoolDepletion.numOfPools is larger than the number of pools defined.")); 507296177Sjhibbits 508296177Sjhibbits /* configure num of pools and vector for number of pools mode */ 509296177Sjhibbits tmpReg |= (((uint32_t)p_BufPoolDepletion->numOfPools - 1) << BMI_POOL_DEP_NUM_OF_POOLS_SHIFT); 510296177Sjhibbits tmpReg |= vector; 511296177Sjhibbits } 512296177Sjhibbits 513296177Sjhibbits if(p_BufPoolDepletion->singlePoolModeEnable) 514296177Sjhibbits { 515296177Sjhibbits /* calculate vector for number of pools depletion */ 516296177Sjhibbits found = FALSE; 517296177Sjhibbits vector = 0; 518296177Sjhibbits count = 0; 519296177Sjhibbits for(i=0;i<BM_MAX_NUM_OF_POOLS;i++) 520296177Sjhibbits { 521296177Sjhibbits if(p_BufPoolDepletion->poolsToConsiderForSingleMode[i]) 522296177Sjhibbits { 523296177Sjhibbits for(j=0;j<p_ExtBufPools->numOfPoolsUsed;j++) 524296177Sjhibbits { 525296177Sjhibbits if (i == orderedArray[j]) 526296177Sjhibbits { 527296177Sjhibbits vector |= 0x00000080 >> j; 528296177Sjhibbits found = TRUE; 529296177Sjhibbits count++; 530296177Sjhibbits break; 531296177Sjhibbits } 532296177Sjhibbits } 533296177Sjhibbits if (!found) 534296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Pools selected for depletion are not used.")); 535296177Sjhibbits else 536296177Sjhibbits found = FALSE; 537296177Sjhibbits } 538296177Sjhibbits } 539296177Sjhibbits if (!count) 540296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("No pools defined for single buffer mode pool depletion.")); 541296177Sjhibbits 542296177Sjhibbits /* configure num of pools and vector for number of pools mode */ 543296177Sjhibbits tmpReg |= vector; 544296177Sjhibbits } 545296177Sjhibbits 546296177Sjhibbits WRITE_UINT32(*p_BufPoolDepletionReg, tmpReg); 547296177Sjhibbits 548296177Sjhibbits return E_OK; 549296177Sjhibbits} 550296177Sjhibbits 551296177Sjhibbitsstatic t_Error ClearPerfCnts(t_FmPort *p_FmPort) 552296177Sjhibbits{ 553296177Sjhibbits FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL, 0); 554296177Sjhibbits FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_QUEUE_UTIL, 0); 555296177Sjhibbits FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL, 0); 556296177Sjhibbits FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL, 0); 557296177Sjhibbits return E_OK; 558296177Sjhibbits} 559296177Sjhibbits 560296177Sjhibbitsstatic t_Error BmiRxPortInit(t_FmPort *p_FmPort) 561296177Sjhibbits{ 562296177Sjhibbits t_FmPortRxBmiRegs *p_Regs = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs; 563296177Sjhibbits uint32_t tmpReg; 564296177Sjhibbits t_FmPortDriverParam *p_Params = p_FmPort->p_FmPortDriverParam; 565296177Sjhibbits uint32_t errorsToEnq = 0; 566296177Sjhibbits t_FmPortPerformanceCnt performanceContersParams; 567296177Sjhibbits t_Error err; 568296177Sjhibbits 569296177Sjhibbits /* check that port is not busy */ 570296177Sjhibbits if (GET_UINT32(p_Regs->fmbm_rcfg) & BMI_PORT_CFG_EN) 571296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, 572296177Sjhibbits ("Port(%d,%d) is already enabled",p_FmPort->portType, p_FmPort->portId)); 573296177Sjhibbits 574296177Sjhibbits /* Set Config register */ 575296177Sjhibbits tmpReg = 0; 576296177Sjhibbits if (p_FmPort->imEn) 577296177Sjhibbits tmpReg |= BMI_PORT_CFG_IM; 578296177Sjhibbits /* No discard - all error frames go to error queue */ 579296177Sjhibbits else if (p_Params->frmDiscardOverride) 580296177Sjhibbits tmpReg |= BMI_PORT_CFG_FDOVR; 581296177Sjhibbits 582296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rcfg, tmpReg); 583296177Sjhibbits 584296177Sjhibbits /* Configure dma attributes */ 585296177Sjhibbits tmpReg = 0; 586296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaSwapData << BMI_DMA_ATTR_SWP_SHIFT; 587296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaIntContextCacheAttr << BMI_DMA_ATTR_IC_CACHE_SHIFT; 588296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaHeaderCacheAttr << BMI_DMA_ATTR_HDR_CACHE_SHIFT; 589296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaScatterGatherCacheAttr << BMI_DMA_ATTR_SG_CACHE_SHIFT; 590296177Sjhibbits if(p_Params->dmaWriteOptimize) 591296177Sjhibbits tmpReg |= BMI_DMA_ATTR_WRITE_OPTIMIZE; 592296177Sjhibbits 593296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rda, tmpReg); 594296177Sjhibbits 595296177Sjhibbits /* Configure Rx Fifo params */ 596296177Sjhibbits tmpReg = 0; 597296177Sjhibbits tmpReg |= ((p_Params->rxFifoPriElevationLevel/BMI_FIFO_UNITS - 1) << BMI_RX_FIFO_PRI_ELEVATION_SHIFT); 598296177Sjhibbits tmpReg |= ((p_Params->rxFifoThreshold/BMI_FIFO_UNITS - 1) << BMI_RX_FIFO_THRESHOLD_SHIFT); 599296177Sjhibbits 600296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfp, tmpReg); 601296177Sjhibbits 602296177Sjhibbits { 603296177Sjhibbits#ifdef FM_NO_THRESHOLD_REG 604296177Sjhibbits t_FmRevisionInfo revInfo; 605296177Sjhibbits 606296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 607296177Sjhibbits if (revInfo.majorRev > 1) 608296177Sjhibbits#endif /* FM_NO_THRESHOLD_REG */ 609296177Sjhibbits /* always allow access to the extra resources */ 610296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_reth, BMI_RX_FIFO_THRESHOLD_BC); 611296177Sjhibbits } 612296177Sjhibbits 613296177Sjhibbits /* frame end parameters */ 614296177Sjhibbits tmpReg = 0; 615296177Sjhibbits tmpReg |= ((uint32_t)p_Params->cheksumLastBytesIgnore << BMI_RX_FRAME_END_CS_IGNORE_SHIFT); 616296177Sjhibbits tmpReg |= ((uint32_t)p_Params->cutBytesFromEnd<< BMI_RX_FRAME_END_CUT_SHIFT); 617296177Sjhibbits 618296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfed, tmpReg); 619296177Sjhibbits 620296177Sjhibbits /* IC parameters */ 621296177Sjhibbits tmpReg = 0; 622296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.extBufOffset/OFFSET_UNITS) << BMI_IC_TO_EXT_SHIFT); 623296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.intContextOffset/OFFSET_UNITS) << BMI_IC_FROM_INT_SHIFT); 624296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.size/OFFSET_UNITS) << BMI_IC_SIZE_SHIFT); 625296177Sjhibbits 626296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ricp, tmpReg); 627296177Sjhibbits 628296177Sjhibbits if (!p_FmPort->imEn) 629296177Sjhibbits { 630296177Sjhibbits /* check if the largest external buffer pool is large enough */ 631296177Sjhibbits if(p_Params->bufMargins.startMargins + MIN_EXT_BUF_SIZE + p_Params->bufMargins.endMargins > p_FmPort->rxPoolsParams.largestBufSize) 632296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("bufMargins.startMargins (%d) + minimum buf size (64) + bufMargins.endMargins (%d) is larger than maximum external buffer size (%d)", 633296177Sjhibbits p_Params->bufMargins.startMargins, p_Params->bufMargins.endMargins, p_FmPort->rxPoolsParams.largestBufSize)); 634296177Sjhibbits 635296177Sjhibbits /* buffer margins */ 636296177Sjhibbits tmpReg = 0; 637296177Sjhibbits tmpReg |= (((uint32_t)p_Params->bufMargins.startMargins) << BMI_EXT_BUF_MARG_START_SHIFT); 638296177Sjhibbits tmpReg |= (((uint32_t)p_Params->bufMargins.endMargins) << BMI_EXT_BUF_MARG_END_SHIFT); 639296177Sjhibbits 640296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rebm, tmpReg); 641296177Sjhibbits } 642296177Sjhibbits 643296177Sjhibbits 644296177Sjhibbits if(p_FmPort->internalBufferOffset) 645296177Sjhibbits { 646296177Sjhibbits tmpReg = (uint32_t)((p_FmPort->internalBufferOffset % OFFSET_UNITS) ? 647296177Sjhibbits (p_FmPort->internalBufferOffset/OFFSET_UNITS + 1): 648296177Sjhibbits (p_FmPort->internalBufferOffset/OFFSET_UNITS)); 649296177Sjhibbits p_FmPort->internalBufferOffset = (uint8_t)(tmpReg * OFFSET_UNITS); 650296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rim, tmpReg << BMI_IM_FOF_SHIFT); 651296177Sjhibbits } 652296177Sjhibbits 653296177Sjhibbits /* NIA */ 654296177Sjhibbits if (p_FmPort->imEn) 655296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfne, NIA_ENG_FM_CTL | NIA_FM_CTL_AC_IND_MODE_RX); 656296177Sjhibbits else 657296177Sjhibbits { 658296177Sjhibbits tmpReg = 0; 659296177Sjhibbits if (p_Params->forwardReuseIntContext) 660296177Sjhibbits tmpReg |= BMI_PORT_RFNE_FRWD_RPD; 661296177Sjhibbits /* L3/L4 checksum verify is enabled by default. */ 662296177Sjhibbits /*tmpReg |= BMI_PORT_RFNE_FRWD_DCL4C;*/ 663296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfne, tmpReg | NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME); 664296177Sjhibbits } 665296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfene, NIA_ENG_QMI_ENQ | NIA_ORDER_RESTOR); 666296177Sjhibbits 667296177Sjhibbits /* command attribute */ 668296177Sjhibbits tmpReg = BMI_CMD_RX_MR_DEF; 669296177Sjhibbits if (!p_FmPort->imEn) 670296177Sjhibbits { 671296177Sjhibbits tmpReg |= BMI_CMD_ATTR_ORDER; 672296177Sjhibbits if(p_Params->syncReq) 673296177Sjhibbits tmpReg |= BMI_CMD_ATTR_SYNC; 674296177Sjhibbits tmpReg |= ((uint32_t)p_Params->color << BMI_CMD_ATTR_COLOR_SHIFT); 675296177Sjhibbits } 676296177Sjhibbits 677296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfca, tmpReg); 678296177Sjhibbits 679296177Sjhibbits /* default queues */ 680296177Sjhibbits if (!p_FmPort->imEn) 681296177Sjhibbits { 682296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfqid, p_Params->dfltFqid); 683296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_refqid, p_Params->errFqid); 684296177Sjhibbits } 685296177Sjhibbits 686296177Sjhibbits /* set counters */ 687296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rstc, BMI_COUNTERS_EN); 688296177Sjhibbits 689296177Sjhibbits performanceContersParams.taskCompVal = (uint8_t)p_FmPort->tasks.num; 690296177Sjhibbits performanceContersParams.queueCompVal = 1; 691296177Sjhibbits performanceContersParams.dmaCompVal =(uint8_t) p_FmPort->openDmas.num; 692296177Sjhibbits performanceContersParams.fifoCompVal = p_FmPort->fifoBufs.num; 693296177Sjhibbits if((err = FM_PORT_SetPerformanceCountersParams(p_FmPort, &performanceContersParams)) != E_OK) 694296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 695296177Sjhibbits 696296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rpc, BMI_COUNTERS_EN); 697296177Sjhibbits 698296177Sjhibbits /* error/status mask - check that if discard OV is set, no 699296177Sjhibbits discard is required for specific errors.*/ 700296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfsdm, p_Params->errorsToDiscard); 701296177Sjhibbits 702296177Sjhibbits errorsToEnq = (RX_ERRS_TO_ENQ & ~p_Params->errorsToDiscard); 703296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_rfsem, errorsToEnq); 704296177Sjhibbits 705296177Sjhibbits#ifdef FM_BMI_TO_RISC_ENQ_ERRATA_FMANc 706296177Sjhibbits if((GET_UINT32(p_Regs->fmbm_rfene) && NIA_ENG_MASK)== NIA_ENG_FM_CTL) 707296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("NIA not supported at this stage")); 708296177Sjhibbits#endif /* FM_BMI_TO_RISC_ENQ_ERRATA_FMANc */ 709296177Sjhibbits 710296177Sjhibbits return E_OK; 711296177Sjhibbits} 712296177Sjhibbits 713296177Sjhibbitsstatic t_Error BmiTxPortInit(t_FmPort *p_FmPort) 714296177Sjhibbits{ 715296177Sjhibbits t_FmPortTxBmiRegs *p_Regs = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs; 716296177Sjhibbits uint32_t tmpReg; 717296177Sjhibbits t_FmPortDriverParam *p_Params = p_FmPort->p_FmPortDriverParam; 718296177Sjhibbits /*uint32_t rateCountUnit;*/ 719296177Sjhibbits t_FmPortPerformanceCnt performanceContersParams; 720296177Sjhibbits 721296177Sjhibbits /* check that port is not busy */ 722296177Sjhibbits if (GET_UINT32(p_Regs->fmbm_tcfg) & BMI_PORT_CFG_EN) 723296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Port is already enabled")); 724296177Sjhibbits 725296177Sjhibbits tmpReg = 0; 726296177Sjhibbits if (p_FmPort->imEn) 727296177Sjhibbits tmpReg |= BMI_PORT_CFG_IM; 728296177Sjhibbits 729296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tcfg, tmpReg); 730296177Sjhibbits 731296177Sjhibbits /* Configure dma attributes */ 732296177Sjhibbits tmpReg = 0; 733296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaSwapData << BMI_DMA_ATTR_SWP_SHIFT; 734296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaIntContextCacheAttr << BMI_DMA_ATTR_IC_CACHE_SHIFT; 735296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaHeaderCacheAttr << BMI_DMA_ATTR_HDR_CACHE_SHIFT; 736296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaScatterGatherCacheAttr << BMI_DMA_ATTR_SG_CACHE_SHIFT; 737296177Sjhibbits 738296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tda, tmpReg); 739296177Sjhibbits 740296177Sjhibbits /* Configure Tx Fifo params */ 741296177Sjhibbits tmpReg = 0; 742296177Sjhibbits tmpReg |= ((p_Params->txFifoMinFillLevel/BMI_FIFO_UNITS) << BMI_TX_FIFO_MIN_FILL_SHIFT); 743296177Sjhibbits tmpReg |= (((uint32_t)p_FmPort->txFifoDeqPipelineDepth - 1) << BMI_TX_FIFO_PIPELINE_DEPTH_SHIFT); 744296177Sjhibbits tmpReg |= ((p_Params->txFifoLowComfLevel/BMI_FIFO_UNITS - 1) << BMI_TX_LOW_COMF_SHIFT); 745296177Sjhibbits 746296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfp, tmpReg); 747296177Sjhibbits 748296177Sjhibbits /* frame end parameters */ 749296177Sjhibbits tmpReg = 0; 750296177Sjhibbits tmpReg |= ((uint32_t)p_Params->cheksumLastBytesIgnore << BMI_TX_FRAME_END_CS_IGNORE_SHIFT); 751296177Sjhibbits 752296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfed, tmpReg); 753296177Sjhibbits 754296177Sjhibbits if (!p_FmPort->imEn) 755296177Sjhibbits { 756296177Sjhibbits /* IC parameters */ 757296177Sjhibbits tmpReg = 0; 758296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.extBufOffset/OFFSET_UNITS) << BMI_IC_TO_EXT_SHIFT); 759296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.intContextOffset/OFFSET_UNITS) << BMI_IC_FROM_INT_SHIFT); 760296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.size/OFFSET_UNITS) << BMI_IC_SIZE_SHIFT); 761296177Sjhibbits 762296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ticp, tmpReg); 763296177Sjhibbits } 764296177Sjhibbits 765296177Sjhibbits /* NIA */ 766296177Sjhibbits if (p_FmPort->imEn) 767296177Sjhibbits { 768296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfne, NIA_ENG_FM_CTL | NIA_FM_CTL_AC_IND_MODE_TX); 769296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfene, NIA_ENG_FM_CTL | NIA_FM_CTL_AC_IND_MODE_TX); 770296177Sjhibbits } 771296177Sjhibbits else 772296177Sjhibbits { 773296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfne, NIA_ENG_QMI_DEQ); 774296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfene, NIA_ENG_QMI_ENQ | NIA_ORDER_RESTOR); 775296177Sjhibbits /* The line bellow is a trick so the FM will not release the buffer 776296177Sjhibbits to BM nor will try to enq the frame to QM */ 777296177Sjhibbits if(!p_Params->dfltFqid && p_Params->dontReleaseBuf) 778296177Sjhibbits { 779296177Sjhibbits /* override fmbm_tcfqid 0 with a false non-0 value. This will force FM to 780296177Sjhibbits * act acording to tfene. Otherwise, if fmbm_tcfqid is 0 the FM will release 781296177Sjhibbits * buffers to BM regardless of fmbm_tfene 782296177Sjhibbits */ 783296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tcfqid, 0xFFFFFF); 784296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfene, NIA_ENG_BMI | NIA_BMI_AC_TX_RELEASE); 785296177Sjhibbits } 786296177Sjhibbits } 787296177Sjhibbits 788296177Sjhibbits /* command attribute */ 789296177Sjhibbits tmpReg = BMI_CMD_TX_MR_DEF; 790296177Sjhibbits if (p_FmPort->imEn) 791296177Sjhibbits tmpReg |= BMI_CMD_MR_DEAS; 792296177Sjhibbits else 793296177Sjhibbits { 794296177Sjhibbits tmpReg |= BMI_CMD_ATTR_ORDER; 795296177Sjhibbits /* if we set syncReq, we may get stuck when HC command is running */ 796296177Sjhibbits /*if(p_Params->syncReq) 797296177Sjhibbits tmpReg |= BMI_CMD_ATTR_SYNC;*/ 798296177Sjhibbits tmpReg |= ((uint32_t)p_Params->color << BMI_CMD_ATTR_COLOR_SHIFT); 799296177Sjhibbits } 800296177Sjhibbits 801296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfca, tmpReg); 802296177Sjhibbits 803296177Sjhibbits /* default queues */ 804296177Sjhibbits if (!p_FmPort->imEn) 805296177Sjhibbits { 806296177Sjhibbits if(p_Params->dfltFqid || !p_Params->dontReleaseBuf) 807296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tcfqid, p_Params->dfltFqid); 808296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tfeqid, p_Params->errFqid); 809296177Sjhibbits } 810296177Sjhibbits 811296177Sjhibbits /* statistics & performance counters */ 812296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tstc, BMI_COUNTERS_EN); 813296177Sjhibbits 814296177Sjhibbits performanceContersParams.taskCompVal = (uint8_t)p_FmPort->tasks.num; 815296177Sjhibbits performanceContersParams.queueCompVal = 1; 816296177Sjhibbits performanceContersParams.dmaCompVal = (uint8_t)p_FmPort->openDmas.num; 817296177Sjhibbits performanceContersParams.fifoCompVal = p_FmPort->fifoBufs.num; 818296177Sjhibbits FM_PORT_SetPerformanceCountersParams(p_FmPort, &performanceContersParams); 819296177Sjhibbits 820296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_tpc, BMI_COUNTERS_EN); 821296177Sjhibbits 822296177Sjhibbits return E_OK; 823296177Sjhibbits} 824296177Sjhibbits 825296177Sjhibbitsstatic t_Error BmiOhPortInit(t_FmPort *p_FmPort) 826296177Sjhibbits{ 827296177Sjhibbits t_FmPortOhBmiRegs *p_Regs = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs; 828296177Sjhibbits uint32_t tmpReg, errorsToEnq = 0; 829296177Sjhibbits t_FmPortDriverParam *p_Params = p_FmPort->p_FmPortDriverParam; 830296177Sjhibbits t_FmPortPerformanceCnt performanceContersParams; 831296177Sjhibbits t_Error err; 832296177Sjhibbits 833296177Sjhibbits /* check that port is not busy */ 834296177Sjhibbits if (GET_UINT32(p_Regs->fmbm_ocfg) & BMI_PORT_CFG_EN) 835296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Port is already enabled")); 836296177Sjhibbits 837296177Sjhibbits /* Configure dma attributes */ 838296177Sjhibbits tmpReg = 0; 839296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaSwapData << BMI_DMA_ATTR_SWP_SHIFT; 840296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaIntContextCacheAttr << BMI_DMA_ATTR_IC_CACHE_SHIFT; 841296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaHeaderCacheAttr << BMI_DMA_ATTR_HDR_CACHE_SHIFT; 842296177Sjhibbits tmpReg |= (uint32_t)p_Params->dmaScatterGatherCacheAttr << BMI_DMA_ATTR_SG_CACHE_SHIFT; 843296177Sjhibbits if(p_Params->dmaWriteOptimize) 844296177Sjhibbits tmpReg |= BMI_DMA_ATTR_WRITE_OPTIMIZE; 845296177Sjhibbits 846296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_oda, tmpReg); 847296177Sjhibbits 848296177Sjhibbits /* IC parameters */ 849296177Sjhibbits tmpReg = 0; 850296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.extBufOffset/OFFSET_UNITS) << BMI_IC_TO_EXT_SHIFT); 851296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.intContextOffset/OFFSET_UNITS) << BMI_IC_FROM_INT_SHIFT); 852296177Sjhibbits tmpReg |= (((uint32_t)p_Params->intContext.size/OFFSET_UNITS) << BMI_IC_SIZE_SHIFT); 853296177Sjhibbits 854296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_oicp, tmpReg); 855296177Sjhibbits 856296177Sjhibbits /* NIA */ 857296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofdne, NIA_ENG_QMI_DEQ); 858296177Sjhibbits 859296177Sjhibbits if (p_FmPort->portType==e_FM_PORT_TYPE_OH_HOST_COMMAND) 860296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofene, NIA_ENG_QMI_ENQ); 861296177Sjhibbits else 862296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofene, NIA_ENG_QMI_ENQ | NIA_ORDER_RESTOR); 863296177Sjhibbits 864296177Sjhibbits /* command attribute */ 865296177Sjhibbits if (p_FmPort->portType==e_FM_PORT_TYPE_OH_HOST_COMMAND) 866296177Sjhibbits tmpReg = BMI_CMD_MR_DEAS | BMI_CMD_MR_MA; 867296177Sjhibbits else 868296177Sjhibbits tmpReg = BMI_CMD_ATTR_ORDER | BMI_CMD_MR_DEAS | BMI_CMD_MR_MA; 869296177Sjhibbits 870296177Sjhibbits if(p_Params->syncReq) 871296177Sjhibbits tmpReg |= BMI_CMD_ATTR_SYNC; 872296177Sjhibbits tmpReg |= ((uint32_t)p_Params->color << BMI_CMD_ATTR_COLOR_SHIFT); 873296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofca, tmpReg); 874296177Sjhibbits 875296177Sjhibbits /* No discard - all error frames go to error queue */ 876296177Sjhibbits if (p_Params->frmDiscardOverride) 877296177Sjhibbits tmpReg = BMI_PORT_CFG_FDOVR; 878296177Sjhibbits else 879296177Sjhibbits tmpReg = 0; 880296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ocfg, tmpReg); 881296177Sjhibbits 882296177Sjhibbits if(p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 883296177Sjhibbits { 884296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofsdm, p_Params->errorsToDiscard); 885296177Sjhibbits 886296177Sjhibbits errorsToEnq = (OP_ERRS_TO_ENQ & ~p_Params->errorsToDiscard); 887296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofsem, errorsToEnq); 888296177Sjhibbits 889296177Sjhibbits /* NIA */ 890296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofne, NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME); 891296177Sjhibbits { 892296177Sjhibbits#ifdef FM_NO_OP_OBSERVED_POOLS 893296177Sjhibbits t_FmRevisionInfo revInfo; 894296177Sjhibbits 895296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 896296177Sjhibbits if ((revInfo.majorRev == 4) && (p_Params->enBufPoolDepletion)) 897296177Sjhibbits#endif /* FM_NO_OP_OBSERVED_POOLS */ 898296177Sjhibbits { 899296177Sjhibbits /* define external buffer pools */ 900296177Sjhibbits err = SetExtBufferPools(p_FmPort); 901296177Sjhibbits if(err) 902296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 903296177Sjhibbits } 904296177Sjhibbits } 905296177Sjhibbits } 906296177Sjhibbits else 907296177Sjhibbits /* NIA */ 908296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofne, NIA_ENG_FM_CTL | NIA_FM_CTL_AC_HC); 909296177Sjhibbits 910296177Sjhibbits /* default queues */ 911296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ofqid, p_Params->dfltFqid); 912296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_oefqid, p_Params->errFqid); 913296177Sjhibbits 914296177Sjhibbits if(p_FmPort->internalBufferOffset) 915296177Sjhibbits { 916296177Sjhibbits tmpReg = (uint32_t)((p_FmPort->internalBufferOffset % OFFSET_UNITS) ? 917296177Sjhibbits (p_FmPort->internalBufferOffset/OFFSET_UNITS + 1): 918296177Sjhibbits (p_FmPort->internalBufferOffset/OFFSET_UNITS)); 919296177Sjhibbits p_FmPort->internalBufferOffset = (uint8_t)(tmpReg * OFFSET_UNITS); 920296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_oim, tmpReg << BMI_IM_FOF_SHIFT); 921296177Sjhibbits } 922296177Sjhibbits /* statistics & performance counters */ 923296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_ostc, BMI_COUNTERS_EN); 924296177Sjhibbits 925296177Sjhibbits performanceContersParams.taskCompVal = (uint8_t)p_FmPort->tasks.num; 926296177Sjhibbits performanceContersParams.queueCompVal = 0; 927296177Sjhibbits performanceContersParams.dmaCompVal = (uint8_t)p_FmPort->openDmas.num; 928296177Sjhibbits performanceContersParams.fifoCompVal = p_FmPort->fifoBufs.num; 929296177Sjhibbits FM_PORT_SetPerformanceCountersParams(p_FmPort, &performanceContersParams); 930296177Sjhibbits 931296177Sjhibbits WRITE_UINT32(p_Regs->fmbm_opc, BMI_COUNTERS_EN); 932296177Sjhibbits 933296177Sjhibbits return E_OK; 934296177Sjhibbits} 935296177Sjhibbits 936296177Sjhibbitsstatic t_Error QmiInit(t_FmPort *p_FmPort) 937296177Sjhibbits{ 938296177Sjhibbits t_FmPortDriverParam *p_Params = NULL; 939296177Sjhibbits uint32_t tmpReg; 940296177Sjhibbits 941296177Sjhibbits p_Params = p_FmPort->p_FmPortDriverParam; 942296177Sjhibbits 943296177Sjhibbits /* check that port is not busy */ 944296177Sjhibbits if(((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 945296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX)) && 946296177Sjhibbits (GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc) & QMI_PORT_CFG_EN)) 947296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Port is already enabled")); 948296177Sjhibbits 949296177Sjhibbits /* enable & clear counters */ 950296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc, QMI_PORT_CFG_EN_COUNTERS); 951296177Sjhibbits 952296177Sjhibbits /* The following is done for non-Rx ports only */ 953296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 954296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 955296177Sjhibbits { 956296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G) || 957296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_TX)) 958296177Sjhibbits { 959296177Sjhibbits /* define dequeue NIA */ 960296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn, NIA_ENG_BMI | NIA_BMI_AC_TX); 961296177Sjhibbits /* define enqueue NIA */ 962296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, NIA_ENG_BMI | NIA_BMI_AC_TX_RELEASE); 963296177Sjhibbits } 964296177Sjhibbits else /* for HC & OP */ 965296177Sjhibbits { 966296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn, NIA_ENG_BMI | NIA_BMI_AC_FETCH); 967296177Sjhibbits /* define enqueue NIA */ 968296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, NIA_ENG_BMI | NIA_BMI_AC_RELEASE); 969296177Sjhibbits } 970296177Sjhibbits 971296177Sjhibbits /* configure dequeue */ 972296177Sjhibbits tmpReg = 0; 973296177Sjhibbits if(p_Params->deqHighPriority) 974296177Sjhibbits tmpReg |= QMI_DEQ_CFG_PRI; 975296177Sjhibbits 976296177Sjhibbits switch(p_Params->deqType) 977296177Sjhibbits { 978296177Sjhibbits case(e_FM_PORT_DEQ_TYPE1): 979296177Sjhibbits tmpReg |= QMI_DEQ_CFG_TYPE1; 980296177Sjhibbits break; 981296177Sjhibbits case(e_FM_PORT_DEQ_TYPE2): 982296177Sjhibbits tmpReg |= QMI_DEQ_CFG_TYPE2; 983296177Sjhibbits break; 984296177Sjhibbits case(e_FM_PORT_DEQ_TYPE3): 985296177Sjhibbits tmpReg |= QMI_DEQ_CFG_TYPE3; 986296177Sjhibbits break; 987296177Sjhibbits default: 988296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid dequeue type")); 989296177Sjhibbits } 990296177Sjhibbits 991296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 992296177Sjhibbits switch(p_Params->deqPrefetchOption) 993296177Sjhibbits { 994296177Sjhibbits case(e_FM_PORT_DEQ_NO_PREFETCH): 995296177Sjhibbits /* Do nothing - QMI_DEQ_CFG_PREFETCH_WAITING_TNUM | QMI_DEQ_CFG_PREFETCH_1_FRAME = 0 */ 996296177Sjhibbits break; 997296177Sjhibbits case(e_FM_PORT_DEQ_PARTIAL_PREFETCH): 998296177Sjhibbits tmpReg |= QMI_DEQ_CFG_PREFETCH_WAITING_TNUM | QMI_DEQ_CFG_PREFETCH_3_FRAMES; 999296177Sjhibbits break; 1000296177Sjhibbits case(e_FM_PORT_DEQ_FULL_PREFETCH): 1001296177Sjhibbits tmpReg |= QMI_DEQ_CFG_PREFETCH_NO_TNUM | QMI_DEQ_CFG_PREFETCH_3_FRAMES; 1002296177Sjhibbits break; 1003296177Sjhibbits default: 1004296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid dequeue prefetch option")); 1005296177Sjhibbits } 1006296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 1007296177Sjhibbits 1008296177Sjhibbits tmpReg |= p_Params->deqByteCnt; 1009296177Sjhibbits tmpReg |= (uint32_t)p_Params->deqSubPortal << QMI_DEQ_CFG_SUBPORTAL_SHIFT; 1010296177Sjhibbits 1011296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndc, tmpReg); 1012296177Sjhibbits } 1013296177Sjhibbits else /* rx port */ 1014296177Sjhibbits /* define enqueue NIA */ 1015296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, NIA_ENG_BMI | NIA_BMI_AC_RELEASE); 1016296177Sjhibbits 1017296177Sjhibbits return E_OK; 1018296177Sjhibbits} 1019296177Sjhibbits 1020296177Sjhibbitsstatic t_Error BmiRxPortCheckAndGetCounterPtr(t_FmPort *p_FmPort, e_FmPortCounters counter, volatile uint32_t **p_Ptr) 1021296177Sjhibbits{ 1022296177Sjhibbits t_FmPortRxBmiRegs *p_BmiRegs = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs; 1023296177Sjhibbits 1024296177Sjhibbits /* check that counters are enabled */ 1025296177Sjhibbits switch(counter) 1026296177Sjhibbits { 1027296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1028296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1029296177Sjhibbits case(e_FM_PORT_COUNTERS_QUEUE_UTIL): 1030296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1031296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1032296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_PAUSE_ACTIVATION): 1033296177Sjhibbits /* performance counters - may be read when disabled */ 1034296177Sjhibbits break; 1035296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1036296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1037296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_BAD_FRAME): 1038296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LARGE_FRAME): 1039296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_FILTER_FRAME): 1040296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LIST_DMA_ERR): 1041296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_OUT_OF_BUFFERS_DISCARD): 1042296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1043296177Sjhibbits if(!(GET_UINT32(p_BmiRegs->fmbm_rstc) & BMI_COUNTERS_EN)) 1044296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 1045296177Sjhibbits break; 1046296177Sjhibbits default: 1047296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Rx ports")); 1048296177Sjhibbits } 1049296177Sjhibbits 1050296177Sjhibbits /* Set counter */ 1051296177Sjhibbits switch(counter) 1052296177Sjhibbits { 1053296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1054296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rccn; 1055296177Sjhibbits break; 1056296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1057296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rtuc; 1058296177Sjhibbits break; 1059296177Sjhibbits case(e_FM_PORT_COUNTERS_QUEUE_UTIL): 1060296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rrquc; 1061296177Sjhibbits break; 1062296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1063296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rduc; 1064296177Sjhibbits break; 1065296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1066296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rfuc; 1067296177Sjhibbits break; 1068296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_PAUSE_ACTIVATION): 1069296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rpac; 1070296177Sjhibbits break; 1071296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1072296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rfrc; 1073296177Sjhibbits break; 1074296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1075296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rfcd; 1076296177Sjhibbits break; 1077296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_BAD_FRAME): 1078296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rfbc; 1079296177Sjhibbits break; 1080296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LARGE_FRAME): 1081296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rlfc; 1082296177Sjhibbits break; 1083296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_FILTER_FRAME): 1084296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rffc; 1085296177Sjhibbits break; 1086296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LIST_DMA_ERR): 1087296177Sjhibbits#ifdef FM_PORT_COUNTERS_ERRATA_FMANg 1088296177Sjhibbits { 1089296177Sjhibbits t_FmRevisionInfo revInfo; 1090296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 1091296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1092296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("Requested counter is not available in rev1")); 1093296177Sjhibbits } 1094296177Sjhibbits#endif /* FM_PORT_COUNTERS_ERRATA_FMANg */ 1095296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rfldec; 1096296177Sjhibbits break; 1097296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_OUT_OF_BUFFERS_DISCARD): 1098296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rodc; 1099296177Sjhibbits break; 1100296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1101296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_rbdc; 1102296177Sjhibbits break; 1103296177Sjhibbits default: 1104296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Rx ports")); 1105296177Sjhibbits } 1106296177Sjhibbits 1107296177Sjhibbits return E_OK; 1108296177Sjhibbits} 1109296177Sjhibbits 1110296177Sjhibbitsstatic t_Error BmiTxPortCheckAndGetCounterPtr(t_FmPort *p_FmPort, e_FmPortCounters counter, volatile uint32_t **p_Ptr) 1111296177Sjhibbits{ 1112296177Sjhibbits t_FmPortTxBmiRegs *p_BmiRegs = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs; 1113296177Sjhibbits 1114296177Sjhibbits /* check that counters are enabled */ 1115296177Sjhibbits switch(counter) 1116296177Sjhibbits { 1117296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1118296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1119296177Sjhibbits case(e_FM_PORT_COUNTERS_QUEUE_UTIL): 1120296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1121296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1122296177Sjhibbits /* performance counters - may be read when disabled */ 1123296177Sjhibbits break; 1124296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1125296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1126296177Sjhibbits case(e_FM_PORT_COUNTERS_LENGTH_ERR): 1127296177Sjhibbits case(e_FM_PORT_COUNTERS_UNSUPPRTED_FORMAT): 1128296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1129296177Sjhibbits if(!(GET_UINT32(p_BmiRegs->fmbm_tstc) & BMI_COUNTERS_EN)) 1130296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 1131296177Sjhibbits break; 1132296177Sjhibbits default: 1133296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Tx ports")); 1134296177Sjhibbits } 1135296177Sjhibbits 1136296177Sjhibbits /* Set counter */ 1137296177Sjhibbits switch(counter) 1138296177Sjhibbits { 1139296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1140296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tccn; 1141296177Sjhibbits break; 1142296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1143296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ttuc; 1144296177Sjhibbits break; 1145296177Sjhibbits case(e_FM_PORT_COUNTERS_QUEUE_UTIL): 1146296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ttcquc; 1147296177Sjhibbits break; 1148296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1149296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tduc; 1150296177Sjhibbits break; 1151296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1152296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tfuc; 1153296177Sjhibbits break; 1154296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1155296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tfrc; 1156296177Sjhibbits break; 1157296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1158296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tfdc; 1159296177Sjhibbits break; 1160296177Sjhibbits case(e_FM_PORT_COUNTERS_LENGTH_ERR): 1161296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tfledc; 1162296177Sjhibbits break; 1163296177Sjhibbits case(e_FM_PORT_COUNTERS_UNSUPPRTED_FORMAT): 1164296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tfufdc; 1165296177Sjhibbits break; 1166296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1167296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_tbdc; 1168296177Sjhibbits break; 1169296177Sjhibbits default: 1170296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Tx ports")); 1171296177Sjhibbits } 1172296177Sjhibbits 1173296177Sjhibbits return E_OK; 1174296177Sjhibbits} 1175296177Sjhibbits 1176296177Sjhibbitsstatic t_Error BmiOhPortCheckAndGetCounterPtr(t_FmPort *p_FmPort, e_FmPortCounters counter, volatile uint32_t **p_Ptr) 1177296177Sjhibbits{ 1178296177Sjhibbits t_FmPortOhBmiRegs *p_BmiRegs = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs; 1179296177Sjhibbits 1180296177Sjhibbits /* check that counters are enabled */ 1181296177Sjhibbits switch(counter) 1182296177Sjhibbits { 1183296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1184296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1185296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1186296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1187296177Sjhibbits /* performance counters - may be read when disabled */ 1188296177Sjhibbits break; 1189296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1190296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1191296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LIST_DMA_ERR): 1192296177Sjhibbits case(e_FM_PORT_COUNTERS_WRED_DISCARD): 1193296177Sjhibbits case(e_FM_PORT_COUNTERS_LENGTH_ERR): 1194296177Sjhibbits case(e_FM_PORT_COUNTERS_UNSUPPRTED_FORMAT): 1195296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1196296177Sjhibbits if(!(GET_UINT32(p_BmiRegs->fmbm_ostc) & BMI_COUNTERS_EN)) 1197296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 1198296177Sjhibbits break; 1199296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_FILTER_FRAME): /* only valid for offline parsing */ 1200296177Sjhibbits if(p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 1201296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Host Command ports")); 1202296177Sjhibbits if(!(GET_UINT32(p_BmiRegs->fmbm_ostc) & BMI_COUNTERS_EN)) 1203296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 1204296177Sjhibbits break; 1205296177Sjhibbits default: 1206296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for O/H ports")); 1207296177Sjhibbits } 1208296177Sjhibbits 1209296177Sjhibbits /* Set counter */ 1210296177Sjhibbits switch(counter) 1211296177Sjhibbits { 1212296177Sjhibbits case(e_FM_PORT_COUNTERS_CYCLE): 1213296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_occn; 1214296177Sjhibbits break; 1215296177Sjhibbits case(e_FM_PORT_COUNTERS_TASK_UTIL): 1216296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_otuc; 1217296177Sjhibbits break; 1218296177Sjhibbits case(e_FM_PORT_COUNTERS_DMA_UTIL): 1219296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_oduc; 1220296177Sjhibbits break; 1221296177Sjhibbits case(e_FM_PORT_COUNTERS_FIFO_UTIL): 1222296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofuc; 1223296177Sjhibbits break; 1224296177Sjhibbits case(e_FM_PORT_COUNTERS_FRAME): 1225296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofrc; 1226296177Sjhibbits break; 1227296177Sjhibbits case(e_FM_PORT_COUNTERS_DISCARD_FRAME): 1228296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofdc; 1229296177Sjhibbits break; 1230296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_FILTER_FRAME): 1231296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_offc; 1232296177Sjhibbits break; 1233296177Sjhibbits case(e_FM_PORT_COUNTERS_RX_LIST_DMA_ERR): 1234296177Sjhibbits#ifdef FM_PORT_COUNTERS_ERRATA_FMANg 1235296177Sjhibbits { 1236296177Sjhibbits t_FmRevisionInfo revInfo; 1237296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 1238296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1239296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("Requested counter is not available in rev1")); 1240296177Sjhibbits } 1241296177Sjhibbits#endif /* FM_PORT_COUNTERS_ERRATA_FMANg */ 1242296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofldec; 1243296177Sjhibbits break; 1244296177Sjhibbits case(e_FM_PORT_COUNTERS_WRED_DISCARD): 1245296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofwdc; 1246296177Sjhibbits break; 1247296177Sjhibbits case(e_FM_PORT_COUNTERS_LENGTH_ERR): 1248296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofledc; 1249296177Sjhibbits break; 1250296177Sjhibbits case(e_FM_PORT_COUNTERS_UNSUPPRTED_FORMAT): 1251296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_ofufdc; 1252296177Sjhibbits break; 1253296177Sjhibbits case(e_FM_PORT_COUNTERS_DEALLOC_BUF): 1254296177Sjhibbits *p_Ptr = &p_BmiRegs->fmbm_obdc; 1255296177Sjhibbits break; 1256296177Sjhibbits default: 1257296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for O/H ports")); 1258296177Sjhibbits } 1259296177Sjhibbits 1260296177Sjhibbits return E_OK; 1261296177Sjhibbits} 1262296177Sjhibbits 1263296177Sjhibbitsstatic t_Error AdditionalPrsParams(t_FmPort *p_FmPort, t_FmPcdPrsAdditionalHdrParams *p_HdrParams, uint32_t *p_SoftSeqAttachReg) 1264296177Sjhibbits{ 1265296177Sjhibbits uint8_t hdrNum, Ipv4HdrNum; 1266296177Sjhibbits u_FmPcdHdrPrsOpts *p_prsOpts; 1267296177Sjhibbits uint32_t tmpReg = 0, tmpPrsOffset; 1268296177Sjhibbits 1269296177Sjhibbits if(IS_PRIVATE_HEADER(p_HdrParams->hdr) || IS_SPECIAL_HEADER(p_HdrParams->hdr)) 1270296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("No additional parameters for private or special headers.")); 1271296177Sjhibbits 1272296177Sjhibbits if(p_HdrParams->errDisable) 1273296177Sjhibbits tmpReg |= PRS_HDR_ERROR_DIS; 1274296177Sjhibbits 1275296177Sjhibbits /* Set parser options */ 1276296177Sjhibbits if(p_HdrParams->usePrsOpts) 1277296177Sjhibbits { 1278296177Sjhibbits p_prsOpts = &p_HdrParams->prsOpts; 1279296177Sjhibbits switch(p_HdrParams->hdr) 1280296177Sjhibbits { 1281296177Sjhibbits case(HEADER_TYPE_MPLS): 1282296177Sjhibbits if(p_prsOpts->mplsPrsOptions.labelInterpretationEnable) 1283296177Sjhibbits tmpReg |= PRS_HDR_MPLS_LBL_INTER_EN; 1284296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, p_prsOpts->mplsPrsOptions.nextParse); 1285296177Sjhibbits if(hdrNum == ILLEGAL_HDR_NUM) 1286296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, NO_MSG); 1287296177Sjhibbits GET_PRS_HDR_NUM(Ipv4HdrNum, HEADER_TYPE_IPv4); 1288296177Sjhibbits if(hdrNum < Ipv4HdrNum) 1289296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 1290296177Sjhibbits ("Header must be equal or higher than IPv4")); 1291296177Sjhibbits tmpReg |= ((uint32_t)hdrNum * PRS_HDR_ENTRY_SIZE) << PRS_HDR_MPLS_NEXT_HDR_SHIFT; 1292296177Sjhibbits break; 1293296177Sjhibbits case(HEADER_TYPE_PPPoE): 1294296177Sjhibbits if(p_prsOpts->pppoePrsOptions.enableMTUCheck) 1295296177Sjhibbits { 1296296177Sjhibbits#ifdef FM_PPPOE_NO_MTU_CHECK 1297296177Sjhibbits t_FmRevisionInfo revInfo; 1298296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 1299296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1300296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Invalid parser option")); 1301296177Sjhibbits else 1302296177Sjhibbits#endif /* FM_PPPOE_NO_MTU_CHECK */ 1303296177Sjhibbits tmpReg |= PRS_HDR_PPPOE_MTU_CHECK_EN; 1304296177Sjhibbits } 1305296177Sjhibbits break; 1306296177Sjhibbits case(HEADER_TYPE_IPv6): 1307296177Sjhibbits if(p_prsOpts->ipv6PrsOptions.routingHdrDisable) 1308296177Sjhibbits tmpReg |= PRS_HDR_IPV6_ROUTE_HDR_DIS; 1309296177Sjhibbits break; 1310296177Sjhibbits case(HEADER_TYPE_TCP): 1311296177Sjhibbits if(p_prsOpts->tcpPrsOptions.padIgnoreChecksum) 1312296177Sjhibbits tmpReg |= PRS_HDR_TCP_PAD_REMOVAL; 1313296177Sjhibbits break; 1314296177Sjhibbits case(HEADER_TYPE_UDP): 1315296177Sjhibbits if(p_prsOpts->udpPrsOptions.padIgnoreChecksum) 1316296177Sjhibbits tmpReg |= PRS_HDR_TCP_PAD_REMOVAL; 1317296177Sjhibbits break; 1318296177Sjhibbits default: 1319296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid header")); 1320296177Sjhibbits } 1321296177Sjhibbits } 1322296177Sjhibbits 1323296177Sjhibbits /* set software parsing (address is devided in 2 since parser uses 2 byte access. */ 1324296177Sjhibbits if(p_HdrParams->swPrsEnable) 1325296177Sjhibbits { 1326296177Sjhibbits tmpPrsOffset = FmPcdGetSwPrsOffset(p_FmPort->h_FmPcd, p_HdrParams->hdr, p_HdrParams->indexPerHdr); 1327296177Sjhibbits if(tmpPrsOffset == ILLEGAL_BASE) 1328296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_VALUE, NO_MSG); 1329296177Sjhibbits tmpReg |= (PRS_HDR_SW_PRS_EN | tmpPrsOffset); 1330296177Sjhibbits } 1331296177Sjhibbits *p_SoftSeqAttachReg = tmpReg; 1332296177Sjhibbits 1333296177Sjhibbits return E_OK; 1334296177Sjhibbits} 1335296177Sjhibbits 1336296177Sjhibbitsstatic uint32_t GetPortSchemeBindParams(t_Handle h_FmPort, t_FmPcdKgInterModuleBindPortToSchemes *p_SchemeBind) 1337296177Sjhibbits{ 1338296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 1339296177Sjhibbits uint32_t walking1Mask = 0x80000000, tmp; 1340296177Sjhibbits uint8_t idx = 0; 1341296177Sjhibbits 1342296177Sjhibbits p_SchemeBind->netEnvId = p_FmPort->netEnvId; 1343296177Sjhibbits p_SchemeBind->hardwarePortId = p_FmPort->hardwarePortId; 1344296177Sjhibbits p_SchemeBind->useClsPlan = p_FmPort->useClsPlan; 1345296177Sjhibbits p_SchemeBind->numOfSchemes = 0; 1346296177Sjhibbits tmp = p_FmPort->schemesPerPortVector; 1347296177Sjhibbits if(tmp) 1348296177Sjhibbits { 1349296177Sjhibbits while (tmp) 1350296177Sjhibbits { 1351296177Sjhibbits if(tmp & walking1Mask) 1352296177Sjhibbits { 1353296177Sjhibbits p_SchemeBind->schemesIds[p_SchemeBind->numOfSchemes] = FmPcdKgGetSchemeSwId(p_FmPort->h_FmPcd, idx); 1354296177Sjhibbits p_SchemeBind->numOfSchemes++; 1355296177Sjhibbits tmp &= ~walking1Mask; 1356296177Sjhibbits } 1357296177Sjhibbits walking1Mask >>= 1; 1358296177Sjhibbits idx++; 1359296177Sjhibbits } 1360296177Sjhibbits } 1361296177Sjhibbits 1362296177Sjhibbits return tmp; 1363296177Sjhibbits} 1364296177Sjhibbits 1365296177Sjhibbitsstatic t_Error BuildBufferStructure(t_FmPort *p_FmPort) 1366296177Sjhibbits{ 1367296177Sjhibbits uint32_t tmp; 1368296177Sjhibbits 1369296177Sjhibbits ASSERT_COND(p_FmPort); 1370296177Sjhibbits 1371296177Sjhibbits /* Align start of internal context data to 16 byte */ 1372296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.extBufOffset = 1373296177Sjhibbits (uint16_t)((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.privDataSize & (OFFSET_UNITS-1)) ? 1374296177Sjhibbits ((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.privDataSize + OFFSET_UNITS) & ~(uint16_t)(OFFSET_UNITS-1)) : 1375296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.privDataSize); 1376296177Sjhibbits 1377296177Sjhibbits /* Translate margin and intContext params to FM parameters */ 1378296177Sjhibbits#ifdef FM_INCORRECT_CS_ERRATA_FMAN18 1379296177Sjhibbits { 1380296177Sjhibbits t_FmRevisionInfo revInfo; 1381296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 1382296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1383296177Sjhibbits { 1384296177Sjhibbits uint8_t mod = p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign % 256; 1385296177Sjhibbits if(mod) 1386296177Sjhibbits { 1387296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign += (256-mod); 1388296177Sjhibbits DBG(WARNING,("dataAlign modified to next 256 to conform with FMAN18 errata\n")); 1389296177Sjhibbits } 1390296177Sjhibbits } 1391296177Sjhibbits } 1392296177Sjhibbits#endif /* FM_INCORRECT_CS_ERRATA_FMAN18 */ 1393296177Sjhibbits 1394296177Sjhibbits /* Initialize with illegal value. Later we'll set legal values. */ 1395296177Sjhibbits p_FmPort->bufferOffsets.prsResultOffset = (uint32_t)ILLEGAL_BASE; 1396296177Sjhibbits p_FmPort->bufferOffsets.timeStampOffset = (uint32_t)ILLEGAL_BASE; 1397296177Sjhibbits p_FmPort->bufferOffsets.hashResultOffset= (uint32_t)ILLEGAL_BASE; 1398296177Sjhibbits p_FmPort->bufferOffsets.pcdInfoOffset = (uint32_t)ILLEGAL_BASE; 1399296177Sjhibbits#ifdef DEBUG 1400296177Sjhibbits p_FmPort->bufferOffsets.debugOffset = (uint32_t)ILLEGAL_BASE; 1401296177Sjhibbits#endif /* DEBUG */ 1402296177Sjhibbits 1403296177Sjhibbits /* Internally the driver supports 4 options 1404296177Sjhibbits 1. prsResult/timestamp/hashResult selection (in fact 8 options, but for simplicity we'll 1405296177Sjhibbits relate to it as 1). 1406296177Sjhibbits 2. All IC context (from AD) except debug. 1407296177Sjhibbits 3. Debug information only. 1408296177Sjhibbits 4. All IC context (from AD) including debug. 1409296177Sjhibbits Note, that if user asks for prsResult/timestamp/hashResult and Debug, we give them (4) */ 1410296177Sjhibbits 1411296177Sjhibbits /* This 'if' covers options 2 & 4. We copy from beginning of context with or without debug. */ 1412296177Sjhibbits /* If passAllOtherPCDInfo explicitly requested, or passDebugInfo+prs/ts --> we also take passAllOtherPCDInfo */ 1413296177Sjhibbits if ((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passAllOtherPCDInfo) 1414296177Sjhibbits#ifdef DEBUG 1415296177Sjhibbits || (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passDebugInfo && 1416296177Sjhibbits (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult || 1417296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp || 1418296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passHashResult)) 1419296177Sjhibbits#endif /* DEBUG */ 1420296177Sjhibbits ) 1421296177Sjhibbits { 1422296177Sjhibbits#ifdef DEBUG 1423296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passDebugInfo) 1424296177Sjhibbits { 1425296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.size = 240; 1426296177Sjhibbits p_FmPort->bufferOffsets.debugOffset = 1427296177Sjhibbits (uint32_t)(p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 128); 1428296177Sjhibbits } 1429296177Sjhibbits else 1430296177Sjhibbits#endif /* DEBUG */ 1431296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.size = 128; /* must be aligned to 16 */ 1432296177Sjhibbits /* Start copying data after 16 bytes (FD) from the beginning of the internal context */ 1433296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.intContextOffset = 16; 1434296177Sjhibbits 1435296177Sjhibbits if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passAllOtherPCDInfo) 1436296177Sjhibbits p_FmPort->bufferOffsets.pcdInfoOffset = p_FmPort->p_FmPortDriverParam->intContext.extBufOffset; 1437296177Sjhibbits if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult) 1438296177Sjhibbits p_FmPort->bufferOffsets.prsResultOffset = 1439296177Sjhibbits (uint32_t)(p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 16); 1440296177Sjhibbits if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp) 1441296177Sjhibbits p_FmPort->bufferOffsets.timeStampOffset = 1442296177Sjhibbits (uint32_t)(p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 48); 1443296177Sjhibbits if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passHashResult) 1444296177Sjhibbits p_FmPort->bufferOffsets.hashResultOffset = 1445296177Sjhibbits (uint32_t)(p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 56); 1446296177Sjhibbits } 1447296177Sjhibbits else 1448296177Sjhibbits { 1449296177Sjhibbits#ifdef DEBUG 1450296177Sjhibbits if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passDebugInfo) 1451296177Sjhibbits { 1452296177Sjhibbits /* This case covers option 3 */ 1453296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.size = 112; 1454296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.intContextOffset = 144; 1455296177Sjhibbits p_FmPort->bufferOffsets.debugOffset = p_FmPort->p_FmPortDriverParam->intContext.extBufOffset; 1456296177Sjhibbits } 1457296177Sjhibbits else 1458296177Sjhibbits#endif /* DEBUG */ 1459296177Sjhibbits { 1460296177Sjhibbits /* This case covers the options under 1 */ 1461296177Sjhibbits /* Copy size must be in 16-byte granularity. */ 1462296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.size = 1463296177Sjhibbits (uint16_t)((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult ? 32 : 0) + 1464296177Sjhibbits ((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp || 1465296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passHashResult) ? 16 : 0)); 1466296177Sjhibbits 1467296177Sjhibbits /* Align start of internal context data to 16 byte */ 1468296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.intContextOffset = 1469296177Sjhibbits (uint8_t)(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult ? 32 : 1470296177Sjhibbits ((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp || 1471296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passHashResult) ? 64 : 0)); 1472296177Sjhibbits 1473296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult) 1474296177Sjhibbits p_FmPort->bufferOffsets.prsResultOffset = p_FmPort->p_FmPortDriverParam->intContext.extBufOffset; 1475296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp) 1476296177Sjhibbits p_FmPort->bufferOffsets.timeStampOffset = p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult ? 1477296177Sjhibbits (p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + sizeof(t_FmPrsResult)) : 1478296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.extBufOffset; 1479296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passHashResult) 1480296177Sjhibbits /* If PR is not requested, whether TS is requested or not, IC will be copied from TS */ 1481296177Sjhibbits p_FmPort->bufferOffsets.hashResultOffset = p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult ? 1482296177Sjhibbits (p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + sizeof(t_FmPrsResult) + 8) : 1483296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 8; 1484296177Sjhibbits } 1485296177Sjhibbits } 1486296177Sjhibbits 1487296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufMargins.startMargins = 1488296177Sjhibbits (uint16_t)(p_FmPort->p_FmPortDriverParam->intContext.extBufOffset + 1489296177Sjhibbits p_FmPort->p_FmPortDriverParam->intContext.size); 1490296177Sjhibbits#ifdef FM_CAPWAP_SUPPORT 1491296177Sjhibbits /* save extra space for manip in both external and internal buffers */ 1492296177Sjhibbits if(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace) 1493296177Sjhibbits { 1494296177Sjhibbits if((p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace + FRAG_EXTRA_SPACE) >= 256) 1495296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace + 32 can not be equal or larger to 256")); 1496296177Sjhibbits p_FmPort->bufferOffsets.manipOffset = p_FmPort->p_FmPortDriverParam->bufMargins.startMargins; 1497296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufMargins.startMargins += (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace + FRAG_EXTRA_SPACE); 1498296177Sjhibbits p_FmPort->p_FmPortDriverParam->internalBufferOffset = 1499296177Sjhibbits (uint8_t)(p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace + FRAG_EXTRA_SPACE); 1500296177Sjhibbits } 1501296177Sjhibbits#endif /* FM_CAPWAP_SUPPORT */ 1502296177Sjhibbits 1503296177Sjhibbits /* align data start */ 1504296177Sjhibbits tmp = (uint32_t)(p_FmPort->p_FmPortDriverParam->bufMargins.startMargins % 1505296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign); 1506296177Sjhibbits if (tmp) 1507296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufMargins.startMargins += (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign-tmp); 1508296177Sjhibbits p_FmPort->bufferOffsets.dataOffset = p_FmPort->p_FmPortDriverParam->bufMargins.startMargins; 1509296177Sjhibbits p_FmPort->internalBufferOffset = p_FmPort->p_FmPortDriverParam->internalBufferOffset; 1510296177Sjhibbits 1511296177Sjhibbits return E_OK; 1512296177Sjhibbits} 1513296177Sjhibbits 1514296177Sjhibbitsstatic t_Error SetPcd(t_Handle h_FmPort, t_FmPortPcdParams *p_PcdParams) 1515296177Sjhibbits{ 1516296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 1517296177Sjhibbits t_Error err = E_OK; 1518296177Sjhibbits uint32_t tmpReg; 1519296177Sjhibbits volatile uint32_t *p_BmiNia=NULL; 1520296177Sjhibbits volatile uint32_t *p_BmiPrsNia=NULL; 1521296177Sjhibbits volatile uint32_t *p_BmiPrsStartOffset=NULL; 1522296177Sjhibbits volatile uint32_t *p_BmiInitPrsResult=NULL; 1523296177Sjhibbits volatile uint32_t *p_BmiCcBase=NULL; 1524296177Sjhibbits uint8_t hdrNum, L3HdrNum, greHdrNum; 1525296177Sjhibbits int i; 1526296177Sjhibbits bool isEmptyClsPlanGrp; 1527296177Sjhibbits uint32_t tmpHxs[FM_PCD_PRS_NUM_OF_HDRS]; 1528296177Sjhibbits uint16_t absoluteProfileId; 1529296177Sjhibbits uint8_t physicalSchemeId; 1530296177Sjhibbits uint32_t ccTreePhysOffset; 1531296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 1532296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 1533296177Sjhibbits 1534296177Sjhibbits if (p_FmPort->imEn) 1535296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 1536296177Sjhibbits 1537296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 1538296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX) && 1539296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 1540296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 1541296177Sjhibbits 1542296177Sjhibbits p_FmPort->netEnvId = (uint8_t)(PTR_TO_UINT(p_PcdParams->h_NetEnv)-1); 1543296177Sjhibbits 1544296177Sjhibbits p_FmPort->pcdEngines = 0; 1545296177Sjhibbits 1546296177Sjhibbits /* initialize p_FmPort->pcdEngines field in port's structure */ 1547296177Sjhibbits switch(p_PcdParams->pcdSupport) 1548296177Sjhibbits { 1549296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_NONE): 1550296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("No PCD configuration required if e_FM_PORT_PCD_SUPPORT_NONE selected")); 1551296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_ONLY): 1552296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1553296177Sjhibbits break; 1554296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PLCR_ONLY): 1555296177Sjhibbits if (CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1556296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("parser support is required")); 1557296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PLCR; 1558296177Sjhibbits break; 1559296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_PLCR): 1560296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1561296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PLCR; 1562296177Sjhibbits break; 1563296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG): 1564296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1565296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1566296177Sjhibbits break; 1567296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_CC): 1568296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1569296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_CC; 1570296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1571296177Sjhibbits break; 1572296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_CC_AND_PLCR): 1573296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1574296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1575296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_CC; 1576296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PLCR; 1577296177Sjhibbits break; 1578296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_PLCR): 1579296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PRS; 1580296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1581296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PLCR; 1582296177Sjhibbits break; 1583296177Sjhibbits 1584296177Sjhibbits#ifdef FM_CAPWAP_SUPPORT 1585296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_CC_ONLY): 1586296177Sjhibbits if (CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1587296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("parser support is required")); 1588296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_CC; 1589296177Sjhibbits break; 1590296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_CC_AND_KG): 1591296177Sjhibbits if (CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1592296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("parser support is required")); 1593296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_CC; 1594296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1595296177Sjhibbits break; 1596296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_CC_AND_KG_AND_PLCR): 1597296177Sjhibbits if (CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1598296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("parser support is required")); 1599296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_CC; 1600296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_KG; 1601296177Sjhibbits p_FmPort->pcdEngines |= FM_PCD_PLCR; 1602296177Sjhibbits break; 1603296177Sjhibbits#endif /* FM_CAPWAP_SUPPORT */ 1604296177Sjhibbits default: 1605296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid pcdSupport")); 1606296177Sjhibbits } 1607296177Sjhibbits 1608296177Sjhibbits if((p_FmPort->pcdEngines & FM_PCD_PRS) && (p_PcdParams->p_PrsParams->numOfHdrsWithAdditionalParams > FM_PCD_PRS_NUM_OF_HDRS)) 1609296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Port parser numOfHdrsWithAdditionalParams may not exceed %d", FM_PCD_PRS_NUM_OF_HDRS)); 1610296177Sjhibbits 1611296177Sjhibbits /* check that parameters exist for each and only each defined engine */ 1612296177Sjhibbits if((!!(p_FmPort->pcdEngines & FM_PCD_PRS) != !!p_PcdParams->p_PrsParams) || 1613296177Sjhibbits (!!(p_FmPort->pcdEngines & FM_PCD_KG) != !!p_PcdParams->p_KgParams) || 1614296177Sjhibbits (!!(p_FmPort->pcdEngines & FM_PCD_CC) != !!p_PcdParams->p_CcParams)) 1615296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("PCD initialization structure is not consistant with pcdSupport")); 1616296177Sjhibbits 1617296177Sjhibbits /* get PCD registers pointers */ 1618296177Sjhibbits switch(p_FmPort->portType) 1619296177Sjhibbits { 1620296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 1621296177Sjhibbits case(e_FM_PORT_TYPE_RX): 1622296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 1623296177Sjhibbits p_BmiPrsNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne; 1624296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpso; 1625296177Sjhibbits p_BmiInitPrsResult = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rprai[0]; 1626296177Sjhibbits p_BmiCcBase = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rccb; 1627296177Sjhibbits break; 1628296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 1629296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 1630296177Sjhibbits p_BmiPrsNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofpne; 1631296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opso; 1632296177Sjhibbits p_BmiInitPrsResult = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oprai[0]; 1633296177Sjhibbits p_BmiCcBase = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_occb; 1634296177Sjhibbits break; 1635296177Sjhibbits default: 1636296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 1637296177Sjhibbits } 1638296177Sjhibbits 1639296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_KG) 1640296177Sjhibbits { 1641296177Sjhibbits 1642296177Sjhibbits if(p_PcdParams->p_KgParams->numOfSchemes == 0) 1643296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("For ports using Keygen, at lease one scheme must be bound. ")); 1644296177Sjhibbits /* for each scheme */ 1645296177Sjhibbits for(i = 0; i<p_PcdParams->p_KgParams->numOfSchemes; i++) 1646296177Sjhibbits { 1647296177Sjhibbits physicalSchemeId = (uint8_t)(PTR_TO_UINT(p_PcdParams->p_KgParams->h_Schemes[i])-1); 1648296177Sjhibbits /* build vector */ 1649296177Sjhibbits p_FmPort->schemesPerPortVector |= 1 << (31 - (uint32_t)physicalSchemeId); 1650296177Sjhibbits } 1651296177Sjhibbits 1652296177Sjhibbits err = FmPcdKgSetOrBindToClsPlanGrp(p_FmPort->h_FmPcd, 1653296177Sjhibbits p_FmPort->hardwarePortId, 1654296177Sjhibbits p_FmPort->netEnvId, 1655296177Sjhibbits p_FmPort->optArray, 1656296177Sjhibbits &p_FmPort->clsPlanGrpId, 1657296177Sjhibbits &isEmptyClsPlanGrp); 1658296177Sjhibbits if(err) 1659296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("FmPcdKgSetOrBindToClsPlanGrp failed. ")); 1660296177Sjhibbits 1661296177Sjhibbits p_FmPort->useClsPlan = !isEmptyClsPlanGrp; 1662296177Sjhibbits } 1663296177Sjhibbits 1664296177Sjhibbits /* set PCD port parameter */ 1665296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_CC) 1666296177Sjhibbits { 1667296177Sjhibbits err = FmPcdCcBindTree(p_FmPort->h_FmPcd, p_PcdParams->p_CcParams->h_CcTree, &ccTreePhysOffset, h_FmPort); 1668296177Sjhibbits if(err) 1669296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1670296177Sjhibbits 1671296177Sjhibbits WRITE_UINT32(*p_BmiCcBase, ccTreePhysOffset); 1672296177Sjhibbits p_FmPort->ccTreeId = p_PcdParams->p_CcParams->h_CcTree; 1673296177Sjhibbits } 1674296177Sjhibbits 1675296177Sjhibbits /***************************/ 1676296177Sjhibbits /* configure NIA after BMI */ 1677296177Sjhibbits /***************************/ 1678296177Sjhibbits if (!CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1679296177Sjhibbits /* rfne may contain FDCS bits, so first we read them. */ 1680296177Sjhibbits p_FmPort->savedBmiNia = GET_UINT32(*p_BmiNia) & BMI_RFNE_FDCS_MASK; 1681296177Sjhibbits 1682296177Sjhibbits /* If policer is used directly after BMI or PRS */ 1683296177Sjhibbits if((p_FmPort->pcdEngines & FM_PCD_PLCR) && 1684296177Sjhibbits ((p_PcdParams->pcdSupport == e_FM_PORT_PCD_SUPPORT_PLCR_ONLY) || 1685296177Sjhibbits (p_PcdParams->pcdSupport == e_FM_PORT_PCD_SUPPORT_PRS_AND_PLCR))) 1686296177Sjhibbits { 1687296177Sjhibbits absoluteProfileId = (uint16_t)(PTR_TO_UINT(p_PcdParams->p_PlcrParams->h_Profile)-1); 1688296177Sjhibbits 1689296177Sjhibbits if(!FmPcdPlcrIsProfileValid(p_FmPort->h_FmPcd, absoluteProfileId)) 1690296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Private port profile not valid.")); 1691296177Sjhibbits 1692296177Sjhibbits tmpReg = (uint32_t)(absoluteProfileId | NIA_PLCR_ABSOLUTE); 1693296177Sjhibbits 1694296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_PRS) /* e_FM_PCD_SUPPORT_PRS_AND_PLCR */ 1695296177Sjhibbits { 1696296177Sjhibbits /* update BMI HPNIA */ 1697296177Sjhibbits WRITE_UINT32(*p_BmiPrsNia, (uint32_t)(NIA_ENG_PLCR | tmpReg)); 1698296177Sjhibbits } 1699296177Sjhibbits else /* e_FM_PCD_SUPPORT_PLCR_ONLY */ 1700296177Sjhibbits /* update BMI NIA */ 1701296177Sjhibbits p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_PLCR); 1702296177Sjhibbits } 1703296177Sjhibbits 1704296177Sjhibbits#ifdef FM_CAPWAP_SUPPORT 1705296177Sjhibbits /* if CC is used directly after BMI */ 1706296177Sjhibbits if((p_PcdParams->pcdSupport == e_FM_PORT_PCD_SUPPORT_CC_ONLY) || 1707296177Sjhibbits (p_PcdParams->pcdSupport == e_FM_PORT_PCD_SUPPORT_CC_AND_KG) || 1708296177Sjhibbits (p_PcdParams->pcdSupport == e_FM_PORT_PCD_SUPPORT_CC_AND_KG_AND_PLCR)) 1709296177Sjhibbits { 1710296177Sjhibbits if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 1711296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("e_FM_PORT_PCD_SUPPORT_CC_xx available for offline parsing ports only")); 1712296177Sjhibbits p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_FM_CTL | NIA_FM_CTL_AC_CC); 1713296177Sjhibbits /* check that prs start offset == RIM[FOF] */ 1714296177Sjhibbits } 1715296177Sjhibbits#endif /* FM_CAPWAP_SUPPORT */ 1716296177Sjhibbits 1717296177Sjhibbits if (p_FmPort->pcdEngines & FM_PCD_PRS) 1718296177Sjhibbits { 1719296177Sjhibbits ASSERT_COND(p_PcdParams->p_PrsParams); 1720296177Sjhibbits /* if PRS is used it is always first */ 1721296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, p_PcdParams->p_PrsParams->firstPrsHdr); 1722296177Sjhibbits if (hdrNum == ILLEGAL_HDR_NUM) 1723296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Unsupported header.")); 1724296177Sjhibbits if (!CHECK_FM_CTL_AC_POST_FETCH_PCD(p_FmPort->savedBmiNia)) 1725296177Sjhibbits p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_PRS | (uint32_t)(hdrNum)); 1726296177Sjhibbits /* set after parser NIA */ 1727296177Sjhibbits tmpReg = 0; 1728296177Sjhibbits switch(p_PcdParams->pcdSupport) 1729296177Sjhibbits { 1730296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_ONLY): 1731296177Sjhibbits WRITE_UINT32(*p_BmiPrsNia, NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME); 1732296177Sjhibbits break; 1733296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_CC): 1734296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_CC_AND_PLCR): 1735296177Sjhibbits tmpReg = NIA_KG_CC_EN; 1736296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG): 1737296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_KG_AND_PLCR): 1738296177Sjhibbits if(p_PcdParams->p_KgParams->directScheme) 1739296177Sjhibbits { 1740296177Sjhibbits physicalSchemeId = (uint8_t)(PTR_TO_UINT(p_PcdParams->p_KgParams->h_DirectScheme)-1); 1741296177Sjhibbits /* check that this scheme was bound to this port */ 1742296177Sjhibbits for(i=0 ; i<p_PcdParams->p_KgParams->numOfSchemes; i++) 1743296177Sjhibbits if(p_PcdParams->p_KgParams->h_DirectScheme == p_PcdParams->p_KgParams->h_Schemes[i]) 1744296177Sjhibbits break; 1745296177Sjhibbits if(i == p_PcdParams->p_KgParams->numOfSchemes) 1746296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Direct scheme is not one of the port selected schemes.")); 1747296177Sjhibbits tmpReg |= (uint32_t)(NIA_KG_DIRECT | physicalSchemeId); 1748296177Sjhibbits } 1749296177Sjhibbits WRITE_UINT32(*p_BmiPrsNia, NIA_ENG_KG | tmpReg); 1750296177Sjhibbits break; 1751296177Sjhibbits case(e_FM_PORT_PCD_SUPPORT_PRS_AND_PLCR): 1752296177Sjhibbits break; 1753296177Sjhibbits default: 1754296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid PCD support")); 1755296177Sjhibbits } 1756296177Sjhibbits 1757296177Sjhibbits /* set start parsing offset */ 1758296177Sjhibbits /* WRITE_UINT32(*p_BmiPrsStartOffset, p_PcdParams->p_PrsParams->parsingOffset); */ 1759296177Sjhibbits 1760296177Sjhibbits /************************************/ 1761296177Sjhibbits /* Parser port parameters */ 1762296177Sjhibbits /************************************/ 1763296177Sjhibbits /* stop before configuring */ 1764296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, PRS_CAC_STOP); 1765296177Sjhibbits /* wait for parser to be in idle state */ 1766296177Sjhibbits while(GET_UINT32(p_FmPort->p_FmPortPrsRegs->pcac) & PRS_CAC_ACTIVE) ; 1767296177Sjhibbits 1768296177Sjhibbits /* set soft seq attachment register */ 1769296177Sjhibbits memset(tmpHxs, 0, FM_PCD_PRS_NUM_OF_HDRS*sizeof(uint32_t)); 1770296177Sjhibbits 1771296177Sjhibbits /* set protocol options */ 1772296177Sjhibbits for(i=0;p_FmPort->optArray[i];i++) 1773296177Sjhibbits switch(p_FmPort->optArray[i]) 1774296177Sjhibbits { 1775296177Sjhibbits case(ETH_BROADCAST): 1776296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_ETH) 1777296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_ETH_BC_SHIFT; 1778296177Sjhibbits break; 1779296177Sjhibbits case(ETH_MULTICAST): 1780296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_ETH) 1781296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_ETH_MC_SHIFT; 1782296177Sjhibbits break; 1783296177Sjhibbits case(VLAN_STACKED): 1784296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_VLAN) 1785296177Sjhibbits tmpHxs[hdrNum] |= (i+1)<< PRS_HDR_VLAN_STACKED_SHIFT; 1786296177Sjhibbits break; 1787296177Sjhibbits case(MPLS_STACKED): 1788296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_MPLS) 1789296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_MPLS_STACKED_SHIFT; 1790296177Sjhibbits break; 1791296177Sjhibbits case(IPV4_BROADCAST_1): 1792296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv4) 1793296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV4_1_BC_SHIFT; 1794296177Sjhibbits break; 1795296177Sjhibbits case(IPV4_MULTICAST_1): 1796296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv4) 1797296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV4_1_MC_SHIFT; 1798296177Sjhibbits break; 1799296177Sjhibbits case(IPV4_UNICAST_2): 1800296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv4) 1801296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV4_2_UC_SHIFT; 1802296177Sjhibbits break; 1803296177Sjhibbits case(IPV4_MULTICAST_BROADCAST_2): 1804296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv4) 1805296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV4_2_MC_BC_SHIFT; 1806296177Sjhibbits break; 1807296177Sjhibbits case(IPV6_MULTICAST_1): 1808296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv6) 1809296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV6_1_MC_SHIFT; 1810296177Sjhibbits break; 1811296177Sjhibbits case(IPV6_UNICAST_2): 1812296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv6) 1813296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV6_2_UC_SHIFT; 1814296177Sjhibbits break; 1815296177Sjhibbits case(IPV6_MULTICAST_2): 1816296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPv6) 1817296177Sjhibbits tmpHxs[hdrNum] |= (i+1) << PRS_HDR_IPV6_2_MC_SHIFT; 1818296177Sjhibbits break; 1819296177Sjhibbits } 1820296177Sjhibbits 1821296177Sjhibbits if (FmPcdNetEnvIsHdrExist(p_FmPort->h_FmPcd, p_FmPort->netEnvId, HEADER_TYPE_UDP_ENCAP_ESP)) 1822296177Sjhibbits { 1823296177Sjhibbits p_PcdParams->p_PrsParams->additionalParams 1824296177Sjhibbits [p_PcdParams->p_PrsParams->numOfHdrsWithAdditionalParams].hdr = HEADER_TYPE_UDP; 1825296177Sjhibbits p_PcdParams->p_PrsParams->additionalParams 1826296177Sjhibbits [p_PcdParams->p_PrsParams->numOfHdrsWithAdditionalParams].swPrsEnable = TRUE; 1827296177Sjhibbits p_PcdParams->p_PrsParams->numOfHdrsWithAdditionalParams++; 1828296177Sjhibbits } 1829296177Sjhibbits 1830296177Sjhibbits /* set MPLS default next header - HW reset workaround */ 1831296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_MPLS) 1832296177Sjhibbits tmpHxs[hdrNum] |= PRS_HDR_MPLS_LBL_INTER_EN; 1833296177Sjhibbits GET_PRS_HDR_NUM(L3HdrNum, HEADER_TYPE_USER_DEFINED_L3); 1834296177Sjhibbits tmpHxs[hdrNum] |= (uint32_t)L3HdrNum << PRS_HDR_MPLS_NEXT_HDR_SHIFT; 1835296177Sjhibbits 1836296177Sjhibbits /* for GRE, disable errors */ 1837296177Sjhibbits GET_PRS_HDR_NUM(greHdrNum, HEADER_TYPE_GRE); 1838296177Sjhibbits tmpHxs[greHdrNum] |= PRS_HDR_ERROR_DIS; 1839296177Sjhibbits 1840296177Sjhibbits /* config additional params for specific headers */ 1841296177Sjhibbits for(i=0 ; i<p_PcdParams->p_PrsParams->numOfHdrsWithAdditionalParams ; i++) 1842296177Sjhibbits { 1843296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, p_PcdParams->p_PrsParams->additionalParams[i].hdr); 1844296177Sjhibbits if(hdrNum== ILLEGAL_HDR_NUM) 1845296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, NO_MSG); 1846296177Sjhibbits if(hdrNum==NO_HDR_NUM) 1847296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Private headers may not use additional parameters")); 1848296177Sjhibbits 1849296177Sjhibbits err = AdditionalPrsParams(p_FmPort, &p_PcdParams->p_PrsParams->additionalParams[i], &tmpReg); 1850296177Sjhibbits if(err) 1851296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, NO_MSG); 1852296177Sjhibbits 1853296177Sjhibbits tmpHxs[hdrNum] |= tmpReg; 1854296177Sjhibbits } 1855296177Sjhibbits#ifdef FM_PRS_L4_SHELL_ERRATA_FMANb 1856296177Sjhibbits { 1857296177Sjhibbits t_FmRevisionInfo revInfo; 1858296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 1859296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 1860296177Sjhibbits { 1861296177Sjhibbits /* link to sw parser code for L4 shells - only if no other code is applied. */ 1862296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_SCTP) 1863296177Sjhibbits if(!(tmpHxs[hdrNum] & PRS_HDR_SW_PRS_EN)) 1864296177Sjhibbits tmpHxs[hdrNum] |= (PRS_HDR_SW_PRS_EN | SCTP_SW_PATCH_START); 1865296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_DCCP) 1866296177Sjhibbits if(!(tmpHxs[hdrNum] & PRS_HDR_SW_PRS_EN)) 1867296177Sjhibbits tmpHxs[hdrNum] |= (PRS_HDR_SW_PRS_EN | DCCP_SW_PATCH_START); 1868296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, HEADER_TYPE_IPSEC_AH) 1869296177Sjhibbits if(!(tmpHxs[hdrNum] & PRS_HDR_SW_PRS_EN)) 1870296177Sjhibbits tmpHxs[hdrNum] |= (PRS_HDR_SW_PRS_EN | IPSEC_SW_PATCH_START); 1871296177Sjhibbits } 1872296177Sjhibbits } 1873296177Sjhibbits#endif /* FM_PRS_L4_SHELL_ERRATA_FMANb */ 1874296177Sjhibbits 1875296177Sjhibbits for(i=0 ; i<FM_PCD_PRS_NUM_OF_HDRS ; i++) 1876296177Sjhibbits { 1877296177Sjhibbits /* For all header set LCV as taken from netEnv*/ 1878296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->hdrs[i].lcv, FmPcdGetLcv(p_FmPort->h_FmPcd, p_FmPort->netEnvId, (uint8_t)i)); 1879296177Sjhibbits /* set HXS register according to default+Additional params+protocol options */ 1880296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->hdrs[i].softSeqAttach, tmpHxs[i]); 1881296177Sjhibbits } 1882296177Sjhibbits 1883296177Sjhibbits /* set tpid. */ 1884296177Sjhibbits tmpReg = PRS_TPID_DFLT; 1885296177Sjhibbits if(p_PcdParams->p_PrsParams->setVlanTpid1) 1886296177Sjhibbits { 1887296177Sjhibbits tmpReg &= PRS_TPID2_MASK; 1888296177Sjhibbits tmpReg |= (uint32_t)p_PcdParams->p_PrsParams->vlanTpid1 << PRS_PCTPID_SHIFT; 1889296177Sjhibbits } 1890296177Sjhibbits if(p_PcdParams->p_PrsParams->setVlanTpid2) 1891296177Sjhibbits { 1892296177Sjhibbits tmpReg &= PRS_TPID1_MASK; 1893296177Sjhibbits tmpReg |= (uint32_t)p_PcdParams->p_PrsParams->vlanTpid2; 1894296177Sjhibbits } 1895296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pctpid, tmpReg); 1896296177Sjhibbits 1897296177Sjhibbits /* enable parser */ 1898296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, 0); 1899296177Sjhibbits 1900296177Sjhibbits if(p_PcdParams->p_PrsParams->prsResultPrivateInfo) 1901296177Sjhibbits p_FmPort->privateInfo = p_PcdParams->p_PrsParams->prsResultPrivateInfo; 1902296177Sjhibbits 1903296177Sjhibbits } /* end parser */ 1904296177Sjhibbits else 1905296177Sjhibbits p_FmPort->privateInfo = 0; 1906296177Sjhibbits 1907296177Sjhibbits WRITE_UINT32(*p_BmiPrsStartOffset, GET_UINT32(*p_BmiPrsStartOffset) + p_FmPort->internalBufferOffset); 1908296177Sjhibbits 1909296177Sjhibbits /* set initial parser result - used for all engines */ 1910296177Sjhibbits for (i=0;i<FM_PORT_PRS_RESULT_NUM_OF_WORDS;i++) 1911296177Sjhibbits { 1912296177Sjhibbits if (!i) 1913296177Sjhibbits WRITE_UINT32(*(p_BmiInitPrsResult), (uint32_t)(((uint32_t)p_FmPort->privateInfo << BMI_PR_PORTID_SHIFT) 1914296177Sjhibbits | BMI_PRS_RESULT_HIGH)); 1915296177Sjhibbits else 1916296177Sjhibbits if (i< FM_PORT_PRS_RESULT_NUM_OF_WORDS/2) 1917296177Sjhibbits WRITE_UINT32(*(p_BmiInitPrsResult+i), BMI_PRS_RESULT_HIGH); 1918296177Sjhibbits else 1919296177Sjhibbits WRITE_UINT32(*(p_BmiInitPrsResult+i), BMI_PRS_RESULT_LOW); 1920296177Sjhibbits } 1921296177Sjhibbits 1922296177Sjhibbits return E_OK; 1923296177Sjhibbits} 1924296177Sjhibbits 1925296177Sjhibbitsstatic t_Error DeletePcd(t_Handle h_FmPort) 1926296177Sjhibbits{ 1927296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 1928296177Sjhibbits t_Error err = E_OK; 1929296177Sjhibbits volatile uint32_t *p_BmiNia=NULL; 1930296177Sjhibbits 1931296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 1932296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 1933296177Sjhibbits 1934296177Sjhibbits if (p_FmPort->imEn) 1935296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 1936296177Sjhibbits 1937296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 1938296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX) && 1939296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 1940296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 1941296177Sjhibbits 1942296177Sjhibbits if(!p_FmPort->pcdEngines) 1943296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("called for non PCD port")); 1944296177Sjhibbits 1945296177Sjhibbits /* get PCD registers pointers */ 1946296177Sjhibbits switch(p_FmPort->portType) 1947296177Sjhibbits { 1948296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 1949296177Sjhibbits case(e_FM_PORT_TYPE_RX): 1950296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 1951296177Sjhibbits break; 1952296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 1953296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 1954296177Sjhibbits break; 1955296177Sjhibbits default: 1956296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 1957296177Sjhibbits } 1958296177Sjhibbits 1959296177Sjhibbits if((GET_UINT32(*p_BmiNia) & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) != (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) 1960296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("port has to be detached previousely")); 1961296177Sjhibbits 1962296177Sjhibbits /* "cut" PCD out of the port's flow - go to BMI */ 1963296177Sjhibbits /* WRITE_UINT32(*p_BmiNia, (p_FmPort->savedBmiNia & BMI_RFNE_FDCS_MASK) | (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)); */ 1964296177Sjhibbits 1965296177Sjhibbits if(p_FmPort->pcdEngines | FM_PCD_PRS) 1966296177Sjhibbits { 1967296177Sjhibbits /* stop parser */ 1968296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, PRS_CAC_STOP); 1969296177Sjhibbits /* wait for parser to be in idle state */ 1970296177Sjhibbits while(GET_UINT32(p_FmPort->p_FmPortPrsRegs->pcac) & PRS_CAC_ACTIVE) ; 1971296177Sjhibbits } 1972296177Sjhibbits 1973296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_KG) 1974296177Sjhibbits { 1975296177Sjhibbits err = FmPcdKgDeleteOrUnbindPortToClsPlanGrp(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId, p_FmPort->clsPlanGrpId); 1976296177Sjhibbits if(err) 1977296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1978296177Sjhibbits p_FmPort->useClsPlan = FALSE; 1979296177Sjhibbits } 1980296177Sjhibbits 1981296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_CC) 1982296177Sjhibbits { 1983296177Sjhibbits /* unbind - we need to get the treeId too */ 1984296177Sjhibbits err = FmPcdCcUnbindTree(p_FmPort->h_FmPcd, p_FmPort->ccTreeId); 1985296177Sjhibbits if(err) 1986296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 1987296177Sjhibbits } 1988296177Sjhibbits 1989296177Sjhibbits p_FmPort->pcdEngines = 0; 1990296177Sjhibbits 1991296177Sjhibbits return E_OK; 1992296177Sjhibbits} 1993296177Sjhibbits 1994296177Sjhibbits 1995296177Sjhibbits/********************************************/ 1996296177Sjhibbits/* Inter-module API */ 1997296177Sjhibbits/********************************************/ 1998296177Sjhibbitsvoid FmPortSetMacsecLcv(t_Handle h_FmPort) 1999296177Sjhibbits{ 2000296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2001296177Sjhibbits volatile uint32_t *p_BmiCfgReg = NULL; 2002296177Sjhibbits uint32_t macsecEn = BMI_PORT_CFG_EN_MACSEC; 2003296177Sjhibbits uint32_t lcv, walking1Mask = 0x80000000; 2004296177Sjhibbits uint8_t cnt = 0; 2005296177Sjhibbits 2006296177Sjhibbits SANITY_CHECK_RETURN(p_FmPort, E_INVALID_HANDLE); 2007296177Sjhibbits SANITY_CHECK_RETURN(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 2008296177Sjhibbits 2009296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2010296177Sjhibbits { 2011296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_OPERATION, ("The routine is relevant for Rx ports only")); 2012296177Sjhibbits return; 2013296177Sjhibbits } 2014296177Sjhibbits 2015296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcfg; 2016296177Sjhibbits /* get LCV for MACSEC */ 2017296177Sjhibbits if ((p_FmPort->h_FmPcd) && ((lcv = FmPcdGetMacsecLcv(p_FmPort->h_FmPcd, p_FmPort->netEnvId))!= 0)) 2018296177Sjhibbits { 2019296177Sjhibbits while(!(lcv & walking1Mask)) 2020296177Sjhibbits { 2021296177Sjhibbits cnt++; 2022296177Sjhibbits walking1Mask >>= 1; 2023296177Sjhibbits } 2024296177Sjhibbits 2025296177Sjhibbits macsecEn |= (uint32_t)cnt << BMI_PORT_CFG_MS_SEL_SHIFT; 2026296177Sjhibbits } 2027296177Sjhibbits 2028296177Sjhibbits WRITE_UINT32(*p_BmiCfgReg, GET_UINT32(*p_BmiCfgReg) | macsecEn); 2029296177Sjhibbits} 2030296177Sjhibbits 2031296177Sjhibbitsvoid FmPortSetMacsecCmd(t_Handle h_FmPort, uint8_t dfltSci) 2032296177Sjhibbits{ 2033296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2034296177Sjhibbits volatile uint32_t *p_BmiCfgReg = NULL; 2035296177Sjhibbits uint32_t tmpReg; 2036296177Sjhibbits 2037296177Sjhibbits SANITY_CHECK_RETURN(p_FmPort, E_INVALID_HANDLE); 2038296177Sjhibbits SANITY_CHECK_RETURN(p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 2039296177Sjhibbits 2040296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_TX)) 2041296177Sjhibbits { 2042296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_OPERATION, ("The routine is relevant for Tx ports only")); 2043296177Sjhibbits return; 2044296177Sjhibbits } 2045296177Sjhibbits 2046296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tfca; 2047296177Sjhibbits tmpReg = GET_UINT32(*p_BmiCfgReg) & ~BMI_CMD_ATTR_MACCMD_MASK; 2048296177Sjhibbits tmpReg |= BMI_CMD_ATTR_MACCMD_SECURED; 2049296177Sjhibbits tmpReg |= (((uint32_t)dfltSci << BMI_CMD_ATTR_MACCMD_SC_SHIFT) & BMI_CMD_ATTR_MACCMD_SC_MASK); 2050296177Sjhibbits 2051296177Sjhibbits WRITE_UINT32(*p_BmiCfgReg, tmpReg); 2052296177Sjhibbits} 2053296177Sjhibbits 2054296177Sjhibbitsuint8_t FmPortGetNetEnvId(t_Handle h_FmPort) 2055296177Sjhibbits{ 2056296177Sjhibbits return ((t_FmPort*)h_FmPort)->netEnvId; 2057296177Sjhibbits} 2058296177Sjhibbits 2059296177Sjhibbitsuint8_t FmPortGetHardwarePortId(t_Handle h_FmPort) 2060296177Sjhibbits{ 2061296177Sjhibbits return ((t_FmPort*)h_FmPort)->hardwarePortId; 2062296177Sjhibbits} 2063296177Sjhibbits 2064296177Sjhibbitsuint32_t FmPortGetPcdEngines(t_Handle h_FmPort) 2065296177Sjhibbits{ 2066296177Sjhibbits return ((t_FmPort*)h_FmPort)->pcdEngines; 2067296177Sjhibbits} 2068296177Sjhibbits 2069296177Sjhibbitst_Error FmPortAttachPCD(t_Handle h_FmPort) 2070296177Sjhibbits{ 2071296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2072296177Sjhibbits volatile uint32_t *p_BmiNia=NULL; 2073296177Sjhibbits 2074296177Sjhibbits/*TODO - to take care about the chnges that were made in the port because of the previously assigned tree. 2075296177Sjhibbitspndn, pnen ... maybe were changed because of the Tree requirement*/ 2076296177Sjhibbits 2077296177Sjhibbits /* get PCD registers pointers */ 2078296177Sjhibbits switch(p_FmPort->portType) 2079296177Sjhibbits { 2080296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2081296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2082296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 2083296177Sjhibbits break; 2084296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2085296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 2086296177Sjhibbits break; 2087296177Sjhibbits default: 2088296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 2089296177Sjhibbits } 2090296177Sjhibbits 2091296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY) 2092296177Sjhibbits if(FmSetNumOfRiscsPerPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId, 1)!= E_OK) 2093296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2094296177Sjhibbits 2095296177Sjhibbits /* check that current NIA is BMI to BMI */ 2096296177Sjhibbits if((GET_UINT32(*p_BmiNia) & ~BMI_RFNE_FDCS_MASK) != (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) 2097296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("may be called only for ports in BMI-to-BMI state.")); 2098296177Sjhibbits 2099296177Sjhibbits WRITE_UINT32(*p_BmiNia, p_FmPort->savedBmiNia); 2100296177Sjhibbits 2101296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_NIA_PNEN) 2102296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, p_FmPort->savedQmiPnen); 2103296177Sjhibbits 2104296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_NIA_PNDN) 2105296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn, p_FmPort->savedNonRxQmiRegsPndn); 2106296177Sjhibbits 2107296177Sjhibbits 2108296177Sjhibbits return E_OK; 2109296177Sjhibbits} 2110296177Sjhibbits 2111296177Sjhibbitst_Error FmPortGetSetCcParams(t_Handle h_FmPort, t_FmPortGetSetCcParams *p_CcParams) 2112296177Sjhibbits{ 2113296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2114296177Sjhibbits int tmpInt; 2115296177Sjhibbits volatile uint32_t *p_BmiPrsStartOffset = NULL; 2116296177Sjhibbits 2117296177Sjhibbits /* this function called from Cc for pass and receive parameters port params between CC and PORT*/ 2118296177Sjhibbits 2119296177Sjhibbits if((p_CcParams->getCcParams.type & OFFSET_OF_PR) && (p_FmPort->bufferOffsets.prsResultOffset != ILLEGAL_BASE)) 2120296177Sjhibbits { 2121296177Sjhibbits p_CcParams->getCcParams.prOffset = (uint8_t)p_FmPort->bufferOffsets.prsResultOffset; 2122296177Sjhibbits p_CcParams->getCcParams.type &= ~OFFSET_OF_PR; 2123296177Sjhibbits } 2124296177Sjhibbits if(p_CcParams->getCcParams.type & HW_PORT_ID) 2125296177Sjhibbits { 2126296177Sjhibbits p_CcParams->getCcParams.hardwarePortId = (uint8_t)p_FmPort->hardwarePortId; 2127296177Sjhibbits p_CcParams->getCcParams.type &= ~HW_PORT_ID; 2128296177Sjhibbits } 2129296177Sjhibbits if((p_CcParams->getCcParams.type & OFFSET_OF_DATA) && (p_FmPort->bufferOffsets.dataOffset != ILLEGAL_BASE)) 2130296177Sjhibbits { 2131296177Sjhibbits p_CcParams->getCcParams.dataOffset = (uint16_t)p_FmPort->bufferOffsets.dataOffset; 2132296177Sjhibbits p_CcParams->getCcParams.type &= ~OFFSET_OF_DATA; 2133296177Sjhibbits } 2134296177Sjhibbits if(p_CcParams->getCcParams.type & NUM_OF_TASKS) 2135296177Sjhibbits { 2136296177Sjhibbits p_CcParams->getCcParams.numOfTasks = p_FmPort->numOfTasks; 2137296177Sjhibbits p_CcParams->getCcParams.type &= ~NUM_OF_TASKS; 2138296177Sjhibbits } 2139296177Sjhibbits if(p_CcParams->getCcParams.type & BUFFER_POOL_ID_FOR_MANIP) 2140296177Sjhibbits { 2141296177Sjhibbits if(p_CcParams->getCcParams.poolIndex < p_FmPort->extBufPools.numOfPoolsUsed) 2142296177Sjhibbits { 2143296177Sjhibbits p_CcParams->getCcParams.poolIdForManip = p_FmPort->extBufPools.extBufPool[p_CcParams->getCcParams.poolIndex].id; 2144296177Sjhibbits p_CcParams->getCcParams.type &= ~BUFFER_POOL_ID_FOR_MANIP; 2145296177Sjhibbits } 2146296177Sjhibbits } 2147296177Sjhibbits 2148296177Sjhibbits if((p_CcParams->setCcParams.type & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY) && !(p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY)) 2149296177Sjhibbits { 2150296177Sjhibbits p_FmPort->requiredAction |= UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY; 2151296177Sjhibbits } 2152296177Sjhibbits 2153296177Sjhibbits if((p_CcParams->setCcParams.type & UPDATE_NIA_PNEN) && !(p_FmPort->requiredAction & UPDATE_NIA_PNEN)) 2154296177Sjhibbits { 2155296177Sjhibbits p_FmPort->savedQmiPnen = p_CcParams->setCcParams.nia; 2156296177Sjhibbits p_FmPort->requiredAction |= UPDATE_NIA_PNEN; 2157296177Sjhibbits } 2158296177Sjhibbits else if (p_CcParams->setCcParams.type & UPDATE_NIA_PNEN) 2159296177Sjhibbits { 2160296177Sjhibbits if(p_FmPort->savedQmiPnen != p_CcParams->setCcParams.nia) 2161296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("pnen was defined previously different")); 2162296177Sjhibbits } 2163296177Sjhibbits 2164296177Sjhibbits if((p_CcParams->setCcParams.type & UPDATE_NIA_PNDN) && !(p_FmPort->requiredAction & UPDATE_NIA_PNDN)) 2165296177Sjhibbits { 2166296177Sjhibbits p_FmPort->savedNonRxQmiRegsPndn = p_CcParams->setCcParams.nia; 2167296177Sjhibbits p_FmPort->requiredAction |= UPDATE_NIA_PNDN; 2168296177Sjhibbits } 2169296177Sjhibbits else if(p_CcParams->setCcParams.type & UPDATE_NIA_PNDN) 2170296177Sjhibbits { 2171296177Sjhibbits if(p_FmPort->savedNonRxQmiRegsPndn != p_CcParams->setCcParams.nia) 2172296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("pndn was defined previously different")); 2173296177Sjhibbits } 2174296177Sjhibbits 2175296177Sjhibbits 2176296177Sjhibbits if((p_CcParams->setCcParams.type & UPDATE_PSO) && !(p_FmPort->requiredAction & UPDATE_PSO)) 2177296177Sjhibbits { 2178296177Sjhibbits /* get PCD registers pointers */ 2179296177Sjhibbits switch(p_FmPort->portType) 2180296177Sjhibbits { 2181296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2182296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2183296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpso; 2184296177Sjhibbits break; 2185296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2186296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opso; 2187296177Sjhibbits break; 2188296177Sjhibbits default: 2189296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 2190296177Sjhibbits } 2191296177Sjhibbits /* set start parsing offset */ 2192296177Sjhibbits tmpInt = (int)GET_UINT32(*p_BmiPrsStartOffset)+ p_CcParams->setCcParams.psoSize; 2193296177Sjhibbits if(tmpInt>0) 2194296177Sjhibbits WRITE_UINT32(*p_BmiPrsStartOffset, (uint32_t)tmpInt); 2195296177Sjhibbits 2196296177Sjhibbits p_FmPort->requiredAction |= UPDATE_PSO; 2197296177Sjhibbits p_FmPort->savedPrsStartOffset = p_CcParams->setCcParams.psoSize; 2198296177Sjhibbits 2199296177Sjhibbits } 2200296177Sjhibbits else if (p_CcParams->setCcParams.type & UPDATE_PSO) 2201296177Sjhibbits { 2202296177Sjhibbits if(p_FmPort->savedPrsStartOffset != p_CcParams->setCcParams.psoSize) 2203296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("parser start offset was defoned previousley different")); 2204296177Sjhibbits } 2205296177Sjhibbits return E_OK; 2206296177Sjhibbits} 2207296177Sjhibbits/********************************** End of inter-module routines ********************************/ 2208296177Sjhibbits 2209296177Sjhibbits/****************************************/ 2210296177Sjhibbits/* API Init unit functions */ 2211296177Sjhibbits/****************************************/ 2212296177Sjhibbitst_Handle FM_PORT_Config(t_FmPortParams *p_FmPortParams) 2213296177Sjhibbits{ 2214296177Sjhibbits t_FmPort *p_FmPort; 2215296177Sjhibbits uintptr_t baseAddr = p_FmPortParams->baseAddr; 2216296177Sjhibbits 2217296177Sjhibbits /* Allocate FM structure */ 2218296177Sjhibbits p_FmPort = (t_FmPort *) XX_Malloc(sizeof(t_FmPort)); 2219296177Sjhibbits if (!p_FmPort) 2220296177Sjhibbits { 2221296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Port driver structure")); 2222296177Sjhibbits return NULL; 2223296177Sjhibbits } 2224296177Sjhibbits memset(p_FmPort, 0, sizeof(t_FmPort)); 2225296177Sjhibbits 2226296177Sjhibbits /* Allocate the FM driver's parameters structure */ 2227296177Sjhibbits p_FmPort->p_FmPortDriverParam = (t_FmPortDriverParam *)XX_Malloc(sizeof(t_FmPortDriverParam)); 2228296177Sjhibbits if (!p_FmPort->p_FmPortDriverParam) 2229296177Sjhibbits { 2230296177Sjhibbits XX_Free(p_FmPort); 2231296177Sjhibbits REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Port driver parameters")); 2232296177Sjhibbits return NULL; 2233296177Sjhibbits } 2234296177Sjhibbits memset(p_FmPort->p_FmPortDriverParam, 0, sizeof(t_FmPortDriverParam)); 2235296177Sjhibbits 2236296177Sjhibbits /* Initialize FM port parameters which will be kept by the driver */ 2237296177Sjhibbits p_FmPort->portType = p_FmPortParams->portType; 2238296177Sjhibbits p_FmPort->portId = p_FmPortParams->portId; 2239296177Sjhibbits p_FmPort->pcdEngines = FM_PCD_NONE; 2240296177Sjhibbits p_FmPort->f_Exception = p_FmPortParams->f_Exception; 2241296177Sjhibbits p_FmPort->h_App = p_FmPortParams->h_App; 2242296177Sjhibbits p_FmPort->h_Fm = p_FmPortParams->h_Fm; 2243296177Sjhibbits 2244296177Sjhibbits /* calculate global portId number */ 2245296177Sjhibbits SW_PORT_ID_TO_HW_PORT_ID(p_FmPort->hardwarePortId, p_FmPort->portType, p_FmPortParams->portId); 2246296177Sjhibbits 2247296177Sjhibbits /* Initialize FM port parameters for initialization phase only */ 2248296177Sjhibbits p_FmPort->p_FmPortDriverParam->baseAddr = baseAddr; 2249296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.privDataSize = DEFAULT_PORT_bufferPrefixContent_privDataSize; 2250296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult= DEFAULT_PORT_bufferPrefixContent_passPrsResult; 2251296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp= DEFAULT_PORT_bufferPrefixContent_passTimeStamp; 2252296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passAllOtherPCDInfo 2253296177Sjhibbits = DEFAULT_PORT_bufferPrefixContent_passTimeStamp; 2254296177Sjhibbits#ifdef DEBUG 2255296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passDebugInfo= DEFAULT_PORT_bufferPrefixContent_debugInfo; 2256296177Sjhibbits#endif /* DEBUG */ 2257296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign = DEFAULT_PORT_bufferPrefixContent_dataAlign; 2258296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaSwapData = DEFAULT_PORT_dmaSwapData; 2259296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaIntContextCacheAttr = DEFAULT_PORT_dmaIntContextCacheAttr; 2260296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaHeaderCacheAttr = DEFAULT_PORT_dmaHeaderCacheAttr; 2261296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaScatterGatherCacheAttr = DEFAULT_PORT_dmaScatterGatherCacheAttr; 2262296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaWriteOptimize = DEFAULT_PORT_dmaWriteOptimize; 2263296177Sjhibbits p_FmPort->p_FmPortDriverParam->liodnBase = p_FmPortParams->liodnBase; 2264296177Sjhibbits 2265296177Sjhibbits /* resource distribution. */ 2266296177Sjhibbits p_FmPort->fifoBufs.num = DEFAULT_PORT_sizeOfFifo(p_FmPort->portType); 2267296177Sjhibbits p_FmPort->fifoBufs.extra = DEFAULT_PORT_extraSizeOfFifo(p_FmPort->portType); 2268296177Sjhibbits p_FmPort->openDmas.num = DEFAULT_PORT_numOfOpenDmas(p_FmPort->portType); 2269296177Sjhibbits p_FmPort->openDmas.extra = DEFAULT_PORT_extraNumOfOpenDmas(p_FmPort->portType); 2270296177Sjhibbits p_FmPort->tasks.num = DEFAULT_PORT_numOfTasks(p_FmPort->portType); 2271296177Sjhibbits p_FmPort->tasks.extra = DEFAULT_PORT_extraNumOfTasks(p_FmPort->portType); 2272296177Sjhibbits p_FmPort->numOfTasks = (uint8_t)p_FmPort->tasks.num; 2273296177Sjhibbits#ifdef FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 2274296177Sjhibbits { 2275296177Sjhibbits t_FmRevisionInfo revInfo; 2276296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2277296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2278296177Sjhibbits { 2279296177Sjhibbits p_FmPort->fifoBufs.extra = 0; 2280296177Sjhibbits p_FmPort->openDmas.extra = 0; 2281296177Sjhibbits p_FmPort->tasks.extra = 0; 2282296177Sjhibbits } 2283296177Sjhibbits } 2284296177Sjhibbits#endif /* FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 */ 2285296177Sjhibbits 2286296177Sjhibbits p_FmPort->p_FmPortDriverParam->color = DEFAULT_PORT_color; 2287296177Sjhibbits#ifdef FM_OP_PORT_QMAN_REJECT_ERRATA_FMAN21 2288296177Sjhibbits { 2289296177Sjhibbits t_FmRevisionInfo revInfo; 2290296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2291296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0) && 2292296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 2293296177Sjhibbits p_FmPort->p_FmPortDriverParam->color = e_FM_PORT_COLOR_OVERRIDE; 2294296177Sjhibbits } 2295296177Sjhibbits#endif /* FM_OP_PORT_QMAN_REJECT_ERRATA_FMAN21 */ 2296296177Sjhibbits 2297296177Sjhibbits if (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 2298296177Sjhibbits p_FmPort->p_FmPortDriverParam->syncReq = DEFAULT_PORT_syncReqForHc; 2299296177Sjhibbits else 2300296177Sjhibbits p_FmPort->p_FmPortDriverParam->syncReq = DEFAULT_PORT_syncReq; 2301296177Sjhibbits 2302296177Sjhibbits#ifdef FM_PORT_SYNC_ERRATA_FMAN6 2303296177Sjhibbits { 2304296177Sjhibbits t_FmRevisionInfo revInfo; 2305296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2306296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0) && 2307296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 2308296177Sjhibbits p_FmPort->p_FmPortDriverParam->syncReq = FALSE; 2309296177Sjhibbits } 2310296177Sjhibbits#endif /* FM_PORT_SYNC_ERRATA_FMAN6 */ 2311296177Sjhibbits 2312296177Sjhibbits /* Port type specific initialization: */ 2313296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_TX) && 2314296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_TX_10G)) 2315296177Sjhibbits p_FmPort->p_FmPortDriverParam->frmDiscardOverride = DEFAULT_PORT_frmDiscardOverride; 2316296177Sjhibbits 2317296177Sjhibbits switch(p_FmPort->portType) 2318296177Sjhibbits { 2319296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2320296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2321296177Sjhibbits /* Initialize FM port parameters for initialization phase only */ 2322296177Sjhibbits p_FmPort->p_FmPortDriverParam->cutBytesFromEnd = DEFAULT_PORT_cutBytesFromEnd; 2323296177Sjhibbits p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = FALSE; 2324296177Sjhibbits p_FmPort->p_FmPortDriverParam->frmDiscardOverride = DEFAULT_PORT_frmDiscardOverride; 2325296177Sjhibbits p_FmPort->p_FmPortDriverParam->rxFifoPriElevationLevel = DEFAULT_PORT_rxFifoPriElevationLevel; 2326296177Sjhibbits p_FmPort->p_FmPortDriverParam->rxFifoThreshold = DEFAULT_PORT_rxFifoThreshold; 2327296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufMargins.endMargins = DEFAULT_PORT_BufMargins_endMargins; 2328296177Sjhibbits p_FmPort->p_FmPortDriverParam->errorsToDiscard = DEFAULT_PORT_errorsToDiscard; 2329296177Sjhibbits p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore = DEFAULT_PORT_cheksumLastBytesIgnore; 2330296177Sjhibbits p_FmPort->p_FmPortDriverParam->forwardReuseIntContext = DEFAULT_PORT_forwardIntContextReuse; 2331296177Sjhibbits break; 2332296177Sjhibbits 2333296177Sjhibbits case(e_FM_PORT_TYPE_TX): 2334296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth = DEFAULT_PORT_txFifoDeqPipelineDepth_1G; 2335296177Sjhibbits p_FmPort->p_FmPortDriverParam->dontReleaseBuf = FALSE; 2336296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 2337296177Sjhibbits if(p_FmPort->portType == e_FM_PORT_TYPE_TX_10G) 2338296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth = DEFAULT_PORT_txFifoDeqPipelineDepth_10G; 2339296177Sjhibbits p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore = DEFAULT_PORT_cheksumLastBytesIgnore; 2340296177Sjhibbits p_FmPort->p_FmPortDriverParam->txFifoMinFillLevel = DEFAULT_PORT_txFifoMinFillLevel; 2341296177Sjhibbits p_FmPort->p_FmPortDriverParam->txFifoLowComfLevel = DEFAULT_PORT_txFifoLowComfLevel; 2342296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2343296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 2344296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqHighPriority = DEFAULT_PORT_deqHighPriority; 2345296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqType = DEFAULT_PORT_deqType; 2346296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 2347296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqPrefetchOption = DEFAULT_PORT_deqPrefetchOption; 2348296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 2349296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqByteCnt = DEFAULT_PORT_deqByteCnt; 2350296177Sjhibbits 2351296177Sjhibbits if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 2352296177Sjhibbits p_FmPort->p_FmPortDriverParam->errorsToDiscard = DEFAULT_PORT_errorsToDiscard; 2353296177Sjhibbits break; 2354296177Sjhibbits 2355296177Sjhibbits default: 2356296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam); 2357296177Sjhibbits XX_Free(p_FmPort); 2358296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 2359296177Sjhibbits return NULL; 2360296177Sjhibbits } 2361296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 2362296177Sjhibbits if (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 2363296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqPrefetchOption = DEFAULT_PORT_deqPrefetchOption_HC; 2364296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 2365296177Sjhibbits 2366296177Sjhibbits if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || 2367296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 2368296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth = OH_PIPELINE_DEPTH; 2369296177Sjhibbits 2370296177Sjhibbits p_FmPort->imEn = p_FmPortParams->independentModeEnable; 2371296177Sjhibbits 2372296177Sjhibbits if (p_FmPort->imEn) 2373296177Sjhibbits { 2374296177Sjhibbits if ((p_FmPort->portType == e_FM_PORT_TYPE_TX) || 2375296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)) 2376296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth = DEFAULT_PORT_txFifoDeqPipelineDepth_IM; 2377296177Sjhibbits FmPortConfigIM(p_FmPort, p_FmPortParams); 2378296177Sjhibbits } 2379296177Sjhibbits else 2380296177Sjhibbits { 2381296177Sjhibbits switch(p_FmPort->portType) 2382296177Sjhibbits { 2383296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2384296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2385296177Sjhibbits /* Initialize FM port parameters for initialization phase only */ 2386296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools, 2387296177Sjhibbits &p_FmPortParams->specificParams.rxParams.extBufPools, 2388296177Sjhibbits sizeof(t_FmPortExtPools)); 2389296177Sjhibbits p_FmPort->p_FmPortDriverParam->errFqid = p_FmPortParams->specificParams.rxParams.errFqid; 2390296177Sjhibbits p_FmPort->p_FmPortDriverParam->dfltFqid = p_FmPortParams->specificParams.rxParams.dfltFqid; 2391296177Sjhibbits p_FmPort->p_FmPortDriverParam->liodnOffset = p_FmPortParams->specificParams.rxParams.liodnOffset; 2392296177Sjhibbits break; 2393296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2394296177Sjhibbits#ifdef FM_OP_PARTITION_ERRATA_FMANx8 2395296177Sjhibbits { 2396296177Sjhibbits t_FmRevisionInfo revInfo; 2397296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2398296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2399296177Sjhibbits p_FmPort->p_FmPortDriverParam->liodnOffset = p_FmPortParams->specificParams.nonRxParams.opLiodnOffset; 2400296177Sjhibbits } 2401296177Sjhibbits#endif /* FM_OP_PARTITION_ERRATA_FMANx8 */ 2402296177Sjhibbits case(e_FM_PORT_TYPE_TX): 2403296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 2404296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 2405296177Sjhibbits p_FmPort->p_FmPortDriverParam->errFqid = p_FmPortParams->specificParams.nonRxParams.errFqid; 2406296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqSubPortal = 2407296177Sjhibbits (uint8_t)(p_FmPortParams->specificParams.nonRxParams.qmChannel & QMI_DEQ_CFG_SUBPORTAL_MASK); 2408296177Sjhibbits p_FmPort->p_FmPortDriverParam->dfltFqid = p_FmPortParams->specificParams.nonRxParams.dfltFqid; 2409296177Sjhibbits break; 2410296177Sjhibbits default: 2411296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam); 2412296177Sjhibbits XX_Free(p_FmPort); 2413296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 2414296177Sjhibbits return NULL; 2415296177Sjhibbits } 2416296177Sjhibbits } 2417296177Sjhibbits 2418296177Sjhibbits memset(p_FmPort->name, 0, (sizeof(char)) * MODULE_NAME_SIZE); 2419296177Sjhibbits if(Sprint (p_FmPort->name, "FM-%d-port-%s-%d", 2420296177Sjhibbits FmGetId(p_FmPort->h_Fm), 2421296177Sjhibbits ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING || 2422296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) ? 2423296177Sjhibbits "OH" : (p_FmPort->portType == e_FM_PORT_TYPE_RX ? 2424296177Sjhibbits "1g-RX" : (p_FmPort->portType == e_FM_PORT_TYPE_TX ? 2425296177Sjhibbits "1g-TX" : (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G ? 2426296177Sjhibbits "10g-RX" : "10g-TX")))), 2427296177Sjhibbits p_FmPort->portId) == 0) 2428296177Sjhibbits { 2429296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam); 2430296177Sjhibbits XX_Free(p_FmPort); 2431296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 2432296177Sjhibbits return NULL; 2433296177Sjhibbits } 2434296177Sjhibbits 2435296177Sjhibbits p_FmPort->h_Spinlock = XX_InitSpinlock(); 2436296177Sjhibbits if (!p_FmPort->h_Spinlock) 2437296177Sjhibbits { 2438296177Sjhibbits XX_Free(p_FmPort->p_FmPortDriverParam); 2439296177Sjhibbits XX_Free(p_FmPort); 2440296177Sjhibbits REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); 2441296177Sjhibbits return NULL; 2442296177Sjhibbits } 2443296177Sjhibbits 2444296177Sjhibbits return p_FmPort; 2445296177Sjhibbits} 2446296177Sjhibbits 2447296177Sjhibbits/**************************************************************************//** 2448296177Sjhibbits @Function FM_PORT_Init 2449296177Sjhibbits 2450296177Sjhibbits @Description Initializes the FM module 2451296177Sjhibbits 2452296177Sjhibbits @Param[in] h_FmPort - FM module descriptor 2453296177Sjhibbits 2454296177Sjhibbits @Return E_OK on success; Error code otherwise. 2455296177Sjhibbits*//***************************************************************************/ 2456296177Sjhibbitst_Error FM_PORT_Init(t_Handle h_FmPort) 2457296177Sjhibbits{ 2458296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2459296177Sjhibbits t_FmPortDriverParam *p_Params; 2460296177Sjhibbits t_Error err = E_OK; 2461296177Sjhibbits t_FmInterModulePortInitParams fmParams; 2462296177Sjhibbits uint32_t minFifoSizeRequired = 0; 2463296177Sjhibbits 2464296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 2465296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2466296177Sjhibbits 2467296177Sjhibbits if ((err = BuildBufferStructure(p_FmPort)) != E_OK) 2468296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 2469296177Sjhibbits 2470296177Sjhibbits CHECK_INIT_PARAMETERS(p_FmPort, CheckInitParameters); 2471296177Sjhibbits 2472296177Sjhibbits p_Params = p_FmPort->p_FmPortDriverParam; 2473296177Sjhibbits 2474296177Sjhibbits /* set memory map pointers */ 2475296177Sjhibbits p_FmPort->p_FmPortQmiRegs = (t_FmPortQmiRegs *)UINT_TO_PTR(p_Params->baseAddr + QMI_PORT_REGS_OFFSET); 2476296177Sjhibbits p_FmPort->p_FmPortBmiRegs = (u_FmPortBmiRegs *)UINT_TO_PTR(p_Params->baseAddr + BMI_PORT_REGS_OFFSET); 2477296177Sjhibbits p_FmPort->p_FmPortPrsRegs = (t_FmPortPrsRegs *)UINT_TO_PTR(p_Params->baseAddr + PRS_PORT_REGS_OFFSET); 2478296177Sjhibbits 2479296177Sjhibbits /* For O/H ports, check fifo size and update if necessary */ 2480296177Sjhibbits if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 2481296177Sjhibbits { 2482296177Sjhibbits minFifoSizeRequired = (uint32_t)((p_FmPort->txFifoDeqPipelineDepth+4)*BMI_FIFO_UNITS); 2483296177Sjhibbits if (p_FmPort->fifoBufs.num < minFifoSizeRequired) 2484296177Sjhibbits { 2485296177Sjhibbits p_FmPort->fifoBufs.num = minFifoSizeRequired; 2486296177Sjhibbits DBG(WARNING, ("FIFO size enlarged to %d due to txFifoDeqPipelineDepth size", minFifoSizeRequired)); 2487296177Sjhibbits } 2488296177Sjhibbits } 2489296177Sjhibbits 2490296177Sjhibbits /* For Rx Ports, call the external Buffer routine which also checks fifo 2491296177Sjhibbits size and updates it if necessary */ 2492296177Sjhibbits if(((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 2493296177Sjhibbits && !p_FmPort->imEn) 2494296177Sjhibbits { 2495296177Sjhibbits /* define external buffer pools and pool depletion*/ 2496296177Sjhibbits err = SetExtBufferPools(p_FmPort); 2497296177Sjhibbits if(err) 2498296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2499296177Sjhibbits } 2500296177Sjhibbits 2501296177Sjhibbits /************************************************************/ 2502296177Sjhibbits /* Call FM module routine for communicating parameters */ 2503296177Sjhibbits /************************************************************/ 2504296177Sjhibbits memset(&fmParams, 0, sizeof(fmParams)); 2505296177Sjhibbits fmParams.hardwarePortId = p_FmPort->hardwarePortId; 2506296177Sjhibbits fmParams.portType = (e_FmPortType)p_FmPort->portType; 2507296177Sjhibbits fmParams.numOfTasks = (uint8_t)p_FmPort->tasks.num; 2508296177Sjhibbits fmParams.numOfExtraTasks = (uint8_t)p_FmPort->tasks.extra; 2509296177Sjhibbits fmParams.numOfOpenDmas = (uint8_t)p_FmPort->openDmas.num; 2510296177Sjhibbits fmParams.numOfExtraOpenDmas = (uint8_t)p_FmPort->openDmas.extra; 2511296177Sjhibbits fmParams.sizeOfFifo = p_FmPort->fifoBufs.num; 2512296177Sjhibbits fmParams.extraSizeOfFifo = p_FmPort->fifoBufs.extra; 2513296177Sjhibbits fmParams.independentMode = p_FmPort->imEn; 2514296177Sjhibbits fmParams.liodnOffset = p_Params->liodnOffset; 2515296177Sjhibbits fmParams.liodnBase = p_Params->liodnBase; 2516296177Sjhibbits 2517296177Sjhibbits switch(p_FmPort->portType) 2518296177Sjhibbits { 2519296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2520296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2521296177Sjhibbits break; 2522296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 2523296177Sjhibbits case(e_FM_PORT_TYPE_TX): 2524296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2525296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 2526296177Sjhibbits fmParams.deqPipelineDepth = p_FmPort->txFifoDeqPipelineDepth; 2527296177Sjhibbits break; 2528296177Sjhibbits default: 2529296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2530296177Sjhibbits } 2531296177Sjhibbits 2532296177Sjhibbits err = FmGetSetPortParams(p_FmPort->h_Fm, &fmParams); 2533296177Sjhibbits if(err) 2534296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2535296177Sjhibbits 2536296177Sjhibbits p_FmPort->tasks.num = fmParams.numOfTasks; 2537296177Sjhibbits p_FmPort->tasks.extra = fmParams.numOfExtraTasks; 2538296177Sjhibbits p_FmPort->openDmas.num = fmParams.numOfOpenDmas; 2539296177Sjhibbits p_FmPort->openDmas.extra = fmParams.numOfExtraOpenDmas; 2540296177Sjhibbits p_FmPort->fifoBufs.num = fmParams.sizeOfFifo; 2541296177Sjhibbits p_FmPort->fifoBufs.extra = fmParams.extraSizeOfFifo; 2542296177Sjhibbits 2543296177Sjhibbits /* get params for use in init */ 2544296177Sjhibbits p_Params->fmMuramPhysBaseAddr = 2545296177Sjhibbits (uint64_t)((uint64_t)(fmParams.fmMuramPhysBaseAddr.low) | 2546296177Sjhibbits ((uint64_t)(fmParams.fmMuramPhysBaseAddr.high) << 32)); 2547296177Sjhibbits 2548296177Sjhibbits /**********************/ 2549296177Sjhibbits /* Init BMI Registers */ 2550296177Sjhibbits /**********************/ 2551296177Sjhibbits switch(p_FmPort->portType) 2552296177Sjhibbits { 2553296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 2554296177Sjhibbits case(e_FM_PORT_TYPE_RX): 2555296177Sjhibbits err = BmiRxPortInit(p_FmPort); 2556296177Sjhibbits if(err) 2557296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2558296177Sjhibbits break; 2559296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 2560296177Sjhibbits case(e_FM_PORT_TYPE_TX): 2561296177Sjhibbits err = BmiTxPortInit(p_FmPort); 2562296177Sjhibbits if(err) 2563296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2564296177Sjhibbits break; 2565296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 2566296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 2567296177Sjhibbits err = BmiOhPortInit(p_FmPort); 2568296177Sjhibbits if(err) 2569296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2570296177Sjhibbits break; 2571296177Sjhibbits default: 2572296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 2573296177Sjhibbits } 2574296177Sjhibbits 2575296177Sjhibbits /**********************/ 2576296177Sjhibbits /* Init QMI Registers */ 2577296177Sjhibbits /**********************/ 2578296177Sjhibbits if (!p_FmPort->imEn && ((err = QmiInit(p_FmPort)) != E_OK)) 2579296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2580296177Sjhibbits 2581296177Sjhibbits if (p_FmPort->imEn && ((err = FmPortImInit(p_FmPort)) != E_OK)) 2582296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 2583296177Sjhibbits 2584296177Sjhibbits FmPortDriverParamFree(p_FmPort); 2585296177Sjhibbits 2586296177Sjhibbits return E_OK; 2587296177Sjhibbits} 2588296177Sjhibbits 2589296177Sjhibbits/**************************************************************************//** 2590296177Sjhibbits @Function FM_PORT_Free 2591296177Sjhibbits 2592296177Sjhibbits @Description Frees all resources that were assigned to FM module. 2593296177Sjhibbits 2594296177Sjhibbits Calling this routine invalidates the descriptor. 2595296177Sjhibbits 2596296177Sjhibbits @Param[in] h_FmPort - FM module descriptor 2597296177Sjhibbits 2598296177Sjhibbits @Return E_OK on success; Error code otherwise. 2599296177Sjhibbits*//***************************************************************************/ 2600296177Sjhibbitst_Error FM_PORT_Free(t_Handle h_FmPort) 2601296177Sjhibbits{ 2602296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2603296177Sjhibbits t_FmInterModulePortFreeParams fmParams; 2604296177Sjhibbits 2605296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2606296177Sjhibbits 2607296177Sjhibbits if(p_FmPort->pcdEngines) 2608296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Trying to free a port with PCD. FM_PORT_DeletePCD must be called first.")); 2609296177Sjhibbits 2610296177Sjhibbits if (p_FmPort->enabled) 2611296177Sjhibbits { 2612296177Sjhibbits if (FM_PORT_Disable(p_FmPort) != E_OK) 2613296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("FM_PORT_Disable FAILED")); 2614296177Sjhibbits } 2615296177Sjhibbits 2616296177Sjhibbits FmPortDriverParamFree(p_FmPort); 2617296177Sjhibbits 2618296177Sjhibbits if (p_FmPort->imEn) 2619296177Sjhibbits FmPortImFree(p_FmPort); 2620296177Sjhibbits 2621296177Sjhibbits fmParams.hardwarePortId = p_FmPort->hardwarePortId; 2622296177Sjhibbits fmParams.portType = (e_FmPortType)p_FmPort->portType; 2623296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 2624296177Sjhibbits fmParams.deqPipelineDepth = p_FmPort->txFifoDeqPipelineDepth; 2625296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 2626296177Sjhibbits 2627296177Sjhibbits FmFreePortParams(p_FmPort->h_Fm, &fmParams); 2628296177Sjhibbits 2629296177Sjhibbits if (p_FmPort->h_Spinlock) 2630296177Sjhibbits XX_FreeSpinlock(p_FmPort->h_Spinlock); 2631296177Sjhibbits 2632296177Sjhibbits XX_Free(p_FmPort); 2633296177Sjhibbits 2634296177Sjhibbits return E_OK; 2635296177Sjhibbits} 2636296177Sjhibbits 2637296177Sjhibbits 2638296177Sjhibbits/*************************************************/ 2639296177Sjhibbits/* API Advanced Init unit functions */ 2640296177Sjhibbits/*************************************************/ 2641296177Sjhibbits 2642296177Sjhibbitst_Error FM_PORT_ConfigDeqHighPriority(t_Handle h_FmPort, bool highPri) 2643296177Sjhibbits{ 2644296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2645296177Sjhibbits 2646296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2647296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2648296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX)) 2649296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("not available for Rx ports")); 2650296177Sjhibbits 2651296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqHighPriority = highPri; 2652296177Sjhibbits 2653296177Sjhibbits return E_OK; 2654296177Sjhibbits} 2655296177Sjhibbits 2656296177Sjhibbitst_Error FM_PORT_ConfigDeqType(t_Handle h_FmPort, e_FmPortDeqType deqType) 2657296177Sjhibbits{ 2658296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2659296177Sjhibbits 2660296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2661296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2662296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX)) 2663296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("not available for Rx ports")); 2664296177Sjhibbits 2665296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqType = deqType; 2666296177Sjhibbits 2667296177Sjhibbits return E_OK; 2668296177Sjhibbits} 2669296177Sjhibbits 2670296177Sjhibbits#ifdef FM_QMI_DEQ_OPTIONS_SUPPORT 2671296177Sjhibbitst_Error FM_PORT_ConfigDeqPrefetchOption(t_Handle h_FmPort, e_FmPortDeqPrefetchOption deqPrefetchOption) 2672296177Sjhibbits{ 2673296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2674296177Sjhibbits 2675296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2676296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2677296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX)) 2678296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("not available for Rx ports")); 2679296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqPrefetchOption = deqPrefetchOption; 2680296177Sjhibbits return E_OK; 2681296177Sjhibbits} 2682296177Sjhibbits#endif /* FM_QMI_DEQ_OPTIONS_SUPPORT */ 2683296177Sjhibbits 2684296177Sjhibbitst_Error FM_PORT_ConfigBackupPools(t_Handle h_FmPort, t_FmPortBackupBmPools *p_BackupBmPools) 2685296177Sjhibbits{ 2686296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2687296177Sjhibbits#ifdef FM_NO_BACKUP_POOLS 2688296177Sjhibbits t_FmRevisionInfo revInfo; 2689296177Sjhibbits#endif /* FM_NO_BACKUP_POOLS */ 2690296177Sjhibbits 2691296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2692296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2693296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2694296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 2695296177Sjhibbits 2696296177Sjhibbits#ifdef FM_NO_BACKUP_POOLS 2697296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2698296177Sjhibbits if (revInfo.majorRev != 4) 2699296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("FM_PORT_ConfigBackupPools")); 2700296177Sjhibbits#endif /* FM_NO_BACKUP_POOLS */ 2701296177Sjhibbits 2702296177Sjhibbits p_FmPort->p_FmPortDriverParam->p_BackupBmPools = (t_FmPortBackupBmPools *)XX_Malloc(sizeof(t_FmPortBackupBmPools)); 2703296177Sjhibbits if(!p_FmPort->p_FmPortDriverParam->p_BackupBmPools) 2704296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("p_BackupBmPools allocation failed")); 2705296177Sjhibbits memcpy(p_FmPort->p_FmPortDriverParam->p_BackupBmPools, p_BackupBmPools, sizeof(t_FmPortBackupBmPools)); 2706296177Sjhibbits 2707296177Sjhibbits return E_OK; 2708296177Sjhibbits} 2709296177Sjhibbits 2710296177Sjhibbitst_Error FM_PORT_ConfigDeqByteCnt(t_Handle h_FmPort, uint16_t deqByteCnt) 2711296177Sjhibbits{ 2712296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2713296177Sjhibbits 2714296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2715296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2716296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX)) 2717296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("not available for Rx ports")); 2718296177Sjhibbits 2719296177Sjhibbits p_FmPort->p_FmPortDriverParam->deqByteCnt = deqByteCnt; 2720296177Sjhibbits 2721296177Sjhibbits return E_OK; 2722296177Sjhibbits} 2723296177Sjhibbits 2724296177Sjhibbitst_Error FM_PORT_ConfigBufferPrefixContent(t_Handle h_FmPort, t_FmPortBufferPrefixContent *p_FmPortBufferPrefixContent) 2725296177Sjhibbits{ 2726296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2727296177Sjhibbits 2728296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2729296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2730296177Sjhibbits 2731296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->bufferPrefixContent, p_FmPortBufferPrefixContent, sizeof(t_FmPortBufferPrefixContent)); 2732296177Sjhibbits /* if dataAlign was not initialized by user, we return to driver's deafult */ 2733296177Sjhibbits if (!p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign) 2734296177Sjhibbits p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign = DEFAULT_PORT_bufferPrefixContent_dataAlign; 2735296177Sjhibbits 2736296177Sjhibbits return E_OK; 2737296177Sjhibbits} 2738296177Sjhibbits 2739296177Sjhibbitst_Error FM_PORT_ConfigCheksumLastBytesIgnore(t_Handle h_FmPort, uint8_t cheksumLastBytesIgnore) 2740296177Sjhibbits{ 2741296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2742296177Sjhibbits 2743296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2744296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2745296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 2746296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx & Tx ports only")); 2747296177Sjhibbits 2748296177Sjhibbits p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore = cheksumLastBytesIgnore; 2749296177Sjhibbits 2750296177Sjhibbits return E_OK; 2751296177Sjhibbits} 2752296177Sjhibbits 2753296177Sjhibbitst_Error FM_PORT_ConfigCutBytesFromEnd(t_Handle h_FmPort, uint8_t cutBytesFromEnd) 2754296177Sjhibbits{ 2755296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2756296177Sjhibbits 2757296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2758296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2759296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2760296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 2761296177Sjhibbits 2762296177Sjhibbits p_FmPort->p_FmPortDriverParam->cutBytesFromEnd = cutBytesFromEnd; 2763296177Sjhibbits 2764296177Sjhibbits return E_OK; 2765296177Sjhibbits} 2766296177Sjhibbits 2767296177Sjhibbitst_Error FM_PORT_ConfigPoolDepletion(t_Handle h_FmPort, t_FmPortBufPoolDepletion *p_BufPoolDepletion) 2768296177Sjhibbits{ 2769296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2770296177Sjhibbits 2771296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2772296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2773296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2774296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 2775296177Sjhibbits 2776296177Sjhibbits p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = TRUE; 2777296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->bufPoolDepletion, p_BufPoolDepletion, sizeof(t_FmPortBufPoolDepletion)); 2778296177Sjhibbits 2779296177Sjhibbits return E_OK; 2780296177Sjhibbits} 2781296177Sjhibbits 2782296177Sjhibbitst_Error FM_PORT_ConfigObservedPoolDepletion(t_Handle h_FmPort, t_FmPortObservedBufPoolDepletion *p_FmPortObservedBufPoolDepletion) 2783296177Sjhibbits{ 2784296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2785296177Sjhibbits 2786296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2787296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2788296177Sjhibbits if(p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 2789296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for OP ports only")); 2790296177Sjhibbits 2791296177Sjhibbits p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = TRUE; 2792296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->bufPoolDepletion, &p_FmPortObservedBufPoolDepletion->poolDepletionParams, sizeof(t_FmPortBufPoolDepletion)); 2793296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools, &p_FmPortObservedBufPoolDepletion->poolsParams, sizeof(t_FmPortExtPools)); 2794296177Sjhibbits 2795296177Sjhibbits return E_OK; 2796296177Sjhibbits} 2797296177Sjhibbits 2798296177Sjhibbitst_Error FM_PORT_ConfigExtBufPools(t_Handle h_FmPort, t_FmPortExtPools *p_FmPortExtPools) 2799296177Sjhibbits{ 2800296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2801296177Sjhibbits 2802296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2803296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2804296177Sjhibbits if(p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 2805296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for OP ports only")); 2806296177Sjhibbits 2807296177Sjhibbits memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools, p_FmPortExtPools, sizeof(t_FmPortExtPools)); 2808296177Sjhibbits 2809296177Sjhibbits return E_OK; 2810296177Sjhibbits} 2811296177Sjhibbits 2812296177Sjhibbitst_Error FM_PORT_ConfigRxFifoThreshold(t_Handle h_FmPort, uint32_t fifoThreshold) 2813296177Sjhibbits{ 2814296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2815296177Sjhibbits 2816296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2817296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2818296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2819296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 2820296177Sjhibbits 2821296177Sjhibbits p_FmPort->p_FmPortDriverParam->rxFifoThreshold = fifoThreshold; 2822296177Sjhibbits 2823296177Sjhibbits return E_OK; 2824296177Sjhibbits} 2825296177Sjhibbits 2826296177Sjhibbitst_Error FM_PORT_ConfigRxFifoPriElevationLevel(t_Handle h_FmPort, uint32_t priElevationLevel) 2827296177Sjhibbits{ 2828296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2829296177Sjhibbits 2830296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2831296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2832296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 2833296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 2834296177Sjhibbits 2835296177Sjhibbits p_FmPort->p_FmPortDriverParam->rxFifoPriElevationLevel = priElevationLevel; 2836296177Sjhibbits 2837296177Sjhibbits return E_OK; 2838296177Sjhibbits} 2839296177Sjhibbits 2840296177Sjhibbitst_Error FM_PORT_ConfigTxFifoMinFillLevel(t_Handle h_FmPort, uint32_t minFillLevel) 2841296177Sjhibbits{ 2842296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2843296177Sjhibbits 2844296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2845296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2846296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_TX)) 2847296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx ports only")); 2848296177Sjhibbits 2849296177Sjhibbits p_FmPort->p_FmPortDriverParam->txFifoMinFillLevel = minFillLevel; 2850296177Sjhibbits 2851296177Sjhibbits return E_OK; 2852296177Sjhibbits} 2853296177Sjhibbits 2854296177Sjhibbitst_Error FM_PORT_ConfigTxFifoDeqPipelineDepth(t_Handle h_FmPort, uint8_t deqPipelineDepth) 2855296177Sjhibbits{ 2856296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2857296177Sjhibbits 2858296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2859296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2860296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G) && 2861296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_TX)) 2862296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx ports only")); 2863296177Sjhibbits if (p_FmPort->imEn) 2864296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("Not available for IM ports!")); 2865296177Sjhibbits 2866296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth = deqPipelineDepth; 2867296177Sjhibbits 2868296177Sjhibbits return E_OK; 2869296177Sjhibbits} 2870296177Sjhibbits 2871296177Sjhibbitst_Error FM_PORT_ConfigTxFifoLowComfLevel(t_Handle h_FmPort, uint32_t fifoLowComfLevel) 2872296177Sjhibbits{ 2873296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2874296177Sjhibbits 2875296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2876296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2877296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_TX)) 2878296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx ports only")); 2879296177Sjhibbits 2880296177Sjhibbits p_FmPort->p_FmPortDriverParam->txFifoLowComfLevel = fifoLowComfLevel; 2881296177Sjhibbits 2882296177Sjhibbits return E_OK; 2883296177Sjhibbits} 2884296177Sjhibbits 2885296177Sjhibbitst_Error FM_PORT_ConfigDontReleaseTxBufToBM(t_Handle h_FmPort) 2886296177Sjhibbits{ 2887296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2888296177Sjhibbits 2889296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2890296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2891296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_TX)) 2892296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx ports only")); 2893296177Sjhibbits 2894296177Sjhibbits p_FmPort->p_FmPortDriverParam->dontReleaseBuf = TRUE; 2895296177Sjhibbits 2896296177Sjhibbits return E_OK; 2897296177Sjhibbits} 2898296177Sjhibbits 2899296177Sjhibbitst_Error FM_PORT_ConfigDfltColor(t_Handle h_FmPort, e_FmPortColor color) 2900296177Sjhibbits{ 2901296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2902296177Sjhibbits 2903296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2904296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2905296177Sjhibbits#ifdef FM_OP_PORT_QMAN_REJECT_ERRATA_FMAN21 2906296177Sjhibbits { 2907296177Sjhibbits t_FmRevisionInfo revInfo; 2908296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2909296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2910296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("FM_PORT_ConfigDfltColor!")); 2911296177Sjhibbits } 2912296177Sjhibbits#endif /* FM_OP_PORT_QMAN_REJECT_ERRATA_FMAN21 */ 2913296177Sjhibbits p_FmPort->p_FmPortDriverParam->color = color; 2914296177Sjhibbits 2915296177Sjhibbits return E_OK; 2916296177Sjhibbits} 2917296177Sjhibbits 2918296177Sjhibbitst_Error FM_PORT_ConfigSyncReq(t_Handle h_FmPort, bool syncReq) 2919296177Sjhibbits{ 2920296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2921296177Sjhibbits 2922296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2923296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2924296177Sjhibbits#ifdef FM_PORT_SYNC_ERRATA_FMAN6 2925296177Sjhibbits { 2926296177Sjhibbits t_FmRevisionInfo revInfo; 2927296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 2928296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0)) 2929296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("port-sync!")); 2930296177Sjhibbits } 2931296177Sjhibbits#endif /* FM_PORT_SYNC_ERRATA_FMAN6 */ 2932296177Sjhibbits 2933296177Sjhibbits p_FmPort->p_FmPortDriverParam->syncReq = syncReq; 2934296177Sjhibbits 2935296177Sjhibbits return E_OK; 2936296177Sjhibbits} 2937296177Sjhibbits 2938296177Sjhibbits 2939296177Sjhibbitst_Error FM_PORT_ConfigFrmDiscardOverride(t_Handle h_FmPort, bool override) 2940296177Sjhibbits{ 2941296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2942296177Sjhibbits 2943296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2944296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2945296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G) && (p_FmPort->portType == e_FM_PORT_TYPE_TX)) 2946296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("not available for Tx ports")); 2947296177Sjhibbits 2948296177Sjhibbits p_FmPort->p_FmPortDriverParam->frmDiscardOverride = override; 2949296177Sjhibbits 2950296177Sjhibbits return E_OK; 2951296177Sjhibbits} 2952296177Sjhibbits 2953296177Sjhibbitst_Error FM_PORT_ConfigErrorsToDiscard(t_Handle h_FmPort, fmPortFrameErrSelect_t errs) 2954296177Sjhibbits{ 2955296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2956296177Sjhibbits 2957296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2958296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2959296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX) && 2960296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 2961296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 2962296177Sjhibbits 2963296177Sjhibbits p_FmPort->p_FmPortDriverParam->errorsToDiscard = errs; 2964296177Sjhibbits 2965296177Sjhibbits return E_OK; 2966296177Sjhibbits} 2967296177Sjhibbits 2968296177Sjhibbitst_Error FM_PORT_ConfigDmaSwapData(t_Handle h_FmPort, e_FmPortDmaSwap swapData) 2969296177Sjhibbits{ 2970296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2971296177Sjhibbits 2972296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2973296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2974296177Sjhibbits 2975296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaSwapData = swapData; 2976296177Sjhibbits 2977296177Sjhibbits return E_OK; 2978296177Sjhibbits} 2979296177Sjhibbits 2980296177Sjhibbitst_Error FM_PORT_ConfigDmaIcCacheAttr(t_Handle h_FmPort, e_FmPortDmaCache intContextCacheAttr) 2981296177Sjhibbits{ 2982296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2983296177Sjhibbits 2984296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2985296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2986296177Sjhibbits 2987296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaIntContextCacheAttr = intContextCacheAttr; 2988296177Sjhibbits 2989296177Sjhibbits return E_OK; 2990296177Sjhibbits} 2991296177Sjhibbits 2992296177Sjhibbitst_Error FM_PORT_ConfigDmaHdrAttr(t_Handle h_FmPort, e_FmPortDmaCache headerCacheAttr) 2993296177Sjhibbits{ 2994296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 2995296177Sjhibbits 2996296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 2997296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 2998296177Sjhibbits 2999296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaHeaderCacheAttr = headerCacheAttr; 3000296177Sjhibbits 3001296177Sjhibbits return E_OK; 3002296177Sjhibbits} 3003296177Sjhibbits 3004296177Sjhibbitst_Error FM_PORT_ConfigDmaScatterGatherAttr(t_Handle h_FmPort, e_FmPortDmaCache scatterGatherCacheAttr) 3005296177Sjhibbits{ 3006296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3007296177Sjhibbits 3008296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3009296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3010296177Sjhibbits 3011296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaScatterGatherCacheAttr = scatterGatherCacheAttr; 3012296177Sjhibbits 3013296177Sjhibbits return E_OK; 3014296177Sjhibbits} 3015296177Sjhibbits 3016296177Sjhibbitst_Error FM_PORT_ConfigDmaWriteOptimize(t_Handle h_FmPort, bool optimize) 3017296177Sjhibbits{ 3018296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3019296177Sjhibbits 3020296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3021296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3022296177Sjhibbits 3023296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_TX)) 3024296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("Not available for Tx ports")); 3025296177Sjhibbits 3026296177Sjhibbits p_FmPort->p_FmPortDriverParam->dmaWriteOptimize = optimize; 3027296177Sjhibbits 3028296177Sjhibbits return E_OK; 3029296177Sjhibbits} 3030296177Sjhibbits 3031296177Sjhibbitst_Error FM_PORT_ConfigForwardReuseIntContext(t_Handle h_FmPort, bool forwardReuse) 3032296177Sjhibbits{ 3033296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3034296177Sjhibbits 3035296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3036296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3037296177Sjhibbits 3038296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 3039296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 3040296177Sjhibbits 3041296177Sjhibbits p_FmPort->p_FmPortDriverParam->forwardReuseIntContext = forwardReuse; 3042296177Sjhibbits 3043296177Sjhibbits return E_OK; 3044296177Sjhibbits} 3045296177Sjhibbits 3046296177Sjhibbits 3047296177Sjhibbits/****************************************************/ 3048296177Sjhibbits/* PCD Advaced config API */ 3049296177Sjhibbits/****************************************************/ 3050296177Sjhibbits 3051296177Sjhibbits/****************************************************/ 3052296177Sjhibbits/* API Run-time Control unit functions */ 3053296177Sjhibbits/****************************************************/ 3054296177Sjhibbits 3055296177Sjhibbitst_Error FM_PORT_SetNumOfOpenDmas(t_Handle h_FmPort, t_FmPortRsrc *p_NumOfOpenDmas) 3056296177Sjhibbits{ 3057296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3058296177Sjhibbits t_Error err; 3059296177Sjhibbits 3060296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3061296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3062296177Sjhibbits 3063296177Sjhibbits#ifdef FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 3064296177Sjhibbits { 3065296177Sjhibbits t_FmRevisionInfo revInfo; 3066296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 3067296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0) && 3068296177Sjhibbits (p_NumOfOpenDmas->extra)) 3069296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("excessive resources")); 3070296177Sjhibbits } 3071296177Sjhibbits#endif /* FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 */ 3072296177Sjhibbits 3073296177Sjhibbits if((!p_NumOfOpenDmas->num) || (p_NumOfOpenDmas->num > MAX_NUM_OF_DMAS)) 3074296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("openDmas-num can't be larger than %d", MAX_NUM_OF_DMAS)); 3075296177Sjhibbits if(p_NumOfOpenDmas->extra > MAX_NUM_OF_EXTRA_DMAS) 3076296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("openDmas-extra can't be larger than %d", MAX_NUM_OF_EXTRA_DMAS)); 3077296177Sjhibbits err = FmSetNumOfOpenDmas(p_FmPort->h_Fm, p_FmPort->hardwarePortId, (uint8_t)p_NumOfOpenDmas->num, (uint8_t)p_NumOfOpenDmas->extra, FALSE); 3078296177Sjhibbits if(err) 3079296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 3080296177Sjhibbits 3081296177Sjhibbits memcpy(&p_FmPort->openDmas, p_NumOfOpenDmas, sizeof(t_FmPortRsrc)); 3082296177Sjhibbits 3083296177Sjhibbits return E_OK; 3084296177Sjhibbits} 3085296177Sjhibbits 3086296177Sjhibbitst_Error FM_PORT_SetNumOfTasks(t_Handle h_FmPort, t_FmPortRsrc *p_NumOfTasks) 3087296177Sjhibbits{ 3088296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3089296177Sjhibbits t_Error err; 3090296177Sjhibbits 3091296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3092296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3093296177Sjhibbits 3094296177Sjhibbits if (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND) 3095296177Sjhibbits RETURN_ERROR(MAJOR, E_NO_MEMORY, ("not available for host command port where number is always 1")); 3096296177Sjhibbits 3097296177Sjhibbits#ifdef FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 3098296177Sjhibbits { 3099296177Sjhibbits t_FmRevisionInfo revInfo; 3100296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 3101296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0) && 3102296177Sjhibbits (p_NumOfTasks->extra)) 3103296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("excessive resources")); 3104296177Sjhibbits } 3105296177Sjhibbits#endif /* FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 */ 3106296177Sjhibbits 3107296177Sjhibbits if((!p_NumOfTasks->num) || (p_NumOfTasks->num > MAX_NUM_OF_TASKS)) 3108296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("NumOfTasks-num can't be larger than %d", MAX_NUM_OF_TASKS)); 3109296177Sjhibbits if(p_NumOfTasks->extra > MAX_NUM_OF_EXTRA_TASKS) 3110296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("NumOfTasks-extra can't be larger than %d", MAX_NUM_OF_EXTRA_TASKS)); 3111296177Sjhibbits 3112296177Sjhibbits err = FmSetNumOfTasks(p_FmPort->h_Fm, p_FmPort->hardwarePortId, (uint8_t)p_NumOfTasks->num, (uint8_t)p_NumOfTasks->extra, FALSE); 3113296177Sjhibbits if(err) 3114296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 3115296177Sjhibbits 3116296177Sjhibbits /* update driver's struct */ 3117296177Sjhibbits memcpy(&p_FmPort->tasks, p_NumOfTasks, sizeof(t_FmPortRsrc)); 3118296177Sjhibbits return E_OK; 3119296177Sjhibbits} 3120296177Sjhibbits 3121296177Sjhibbitst_Error FM_PORT_SetSizeOfFifo(t_Handle h_FmPort, t_FmPortRsrc *p_SizeOfFifo) 3122296177Sjhibbits{ 3123296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3124296177Sjhibbits t_Error err; 3125296177Sjhibbits t_FmInterModulePortRxPoolsParams rxPoolsParams; 3126296177Sjhibbits uint32_t minFifoSizeRequired; 3127296177Sjhibbits 3128296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3129296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3130296177Sjhibbits 3131296177Sjhibbits#ifdef FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 3132296177Sjhibbits { 3133296177Sjhibbits t_FmRevisionInfo revInfo; 3134296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 3135296177Sjhibbits if ((revInfo.majorRev == 1) && (revInfo.minorRev == 0) && 3136296177Sjhibbits (p_SizeOfFifo->extra)) 3137296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("excessive resources")); 3138296177Sjhibbits } 3139296177Sjhibbits#endif /* FM_PORT_EXCESSIVE_BUDGET_ERRATA_FMANx16 */ 3140296177Sjhibbits if(!p_SizeOfFifo->num || (p_SizeOfFifo->num > BMI_MAX_FIFO_SIZE)) 3141296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("SizeOfFifo-num has to be in the range of 256 - %d", BMI_MAX_FIFO_SIZE)); 3142296177Sjhibbits if(p_SizeOfFifo->num % BMI_FIFO_UNITS) 3143296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("SizeOfFifo-num has to be divisible by %d", BMI_FIFO_UNITS)); 3144296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 3145296177Sjhibbits { 3146296177Sjhibbits /* extra FIFO size (allowed only to Rx ports) */ 3147296177Sjhibbits if(p_SizeOfFifo->extra % BMI_FIFO_UNITS) 3148296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("SizeOfFifo-extra has to be divisible by %d", BMI_FIFO_UNITS)); 3149296177Sjhibbits } 3150296177Sjhibbits else 3151296177Sjhibbits if(p_SizeOfFifo->extra) 3152296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, (" No SizeOfFifo-extra for non Rx ports")); 3153296177Sjhibbits 3154296177Sjhibbits /* For O/H ports, check fifo size and update if necessary */ 3155296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 3156296177Sjhibbits { 3157296177Sjhibbits minFifoSizeRequired = (uint32_t)((p_FmPort->txFifoDeqPipelineDepth+4)*BMI_FIFO_UNITS); 3158296177Sjhibbits if (p_FmPort->fifoBufs.num < minFifoSizeRequired) 3159296177Sjhibbits { 3160296177Sjhibbits p_FmPort->fifoBufs.num = minFifoSizeRequired; 3161296177Sjhibbits DBG(INFO, ("FIFO size enlarged to %d", minFifoSizeRequired)); 3162296177Sjhibbits } 3163296177Sjhibbits } 3164296177Sjhibbits memcpy(&rxPoolsParams, &p_FmPort->rxPoolsParams, sizeof(rxPoolsParams)); 3165296177Sjhibbits err = FmSetSizeOfFifo(p_FmPort->h_Fm, 3166296177Sjhibbits p_FmPort->hardwarePortId, 3167296177Sjhibbits p_FmPort->portType, 3168296177Sjhibbits p_FmPort->imEn, 3169296177Sjhibbits &p_SizeOfFifo->num, 3170296177Sjhibbits p_SizeOfFifo->extra, 3171296177Sjhibbits p_FmPort->txFifoDeqPipelineDepth, 3172296177Sjhibbits &rxPoolsParams, 3173296177Sjhibbits FALSE); 3174296177Sjhibbits if(err) 3175296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 3176296177Sjhibbits 3177296177Sjhibbits /* update driver's structure AFTER the FM routine, as it may change by the FM. */ 3178296177Sjhibbits memcpy(&p_FmPort->fifoBufs, p_SizeOfFifo, sizeof(t_FmPortRsrc)); 3179296177Sjhibbits 3180296177Sjhibbits return E_OK; 3181296177Sjhibbits} 3182296177Sjhibbits 3183296177Sjhibbitsuint32_t FM_PORT_GetBufferDataOffset(t_Handle h_FmPort) 3184296177Sjhibbits{ 3185296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3186296177Sjhibbits 3187296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 3188296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, 0); 3189296177Sjhibbits 3190296177Sjhibbits return p_FmPort->bufferOffsets.dataOffset; 3191296177Sjhibbits} 3192296177Sjhibbits 3193296177Sjhibbitsuint8_t * FM_PORT_GetBufferICInfo(t_Handle h_FmPort, char *p_Data) 3194296177Sjhibbits{ 3195296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3196296177Sjhibbits 3197296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 3198296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, 0); 3199296177Sjhibbits 3200296177Sjhibbits if(p_FmPort->bufferOffsets.pcdInfoOffset == ILLEGAL_BASE) 3201296177Sjhibbits return NULL; 3202296177Sjhibbits 3203296177Sjhibbits return (uint8_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.pcdInfoOffset); 3204296177Sjhibbits} 3205296177Sjhibbits 3206296177Sjhibbits#ifdef DEBUG 3207296177Sjhibbitsuint8_t * FM_PORT_GetBufferDebugInfo(t_Handle h_FmPort, char *p_Data) 3208296177Sjhibbits{ 3209296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3210296177Sjhibbits 3211296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 3212296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, 0); 3213296177Sjhibbits 3214296177Sjhibbits if(p_FmPort->bufferOffsets.debugOffset == ILLEGAL_BASE) 3215296177Sjhibbits return NULL; 3216296177Sjhibbits 3217296177Sjhibbits return (uint8_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.debugOffset); 3218296177Sjhibbits} 3219296177Sjhibbits#endif /* DEBUG */ 3220296177Sjhibbits 3221296177Sjhibbitst_FmPrsResult * FM_PORT_GetBufferPrsResult(t_Handle h_FmPort, char *p_Data) 3222296177Sjhibbits{ 3223296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3224296177Sjhibbits 3225296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL); 3226296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, NULL); 3227296177Sjhibbits 3228296177Sjhibbits if(p_FmPort->bufferOffsets.prsResultOffset == ILLEGAL_BASE) 3229296177Sjhibbits return NULL; 3230296177Sjhibbits 3231296177Sjhibbits return (t_FmPrsResult *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.prsResultOffset); 3232296177Sjhibbits} 3233296177Sjhibbits 3234296177Sjhibbitsuint64_t * FM_PORT_GetBufferTimeStamp(t_Handle h_FmPort, char *p_Data) 3235296177Sjhibbits{ 3236296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3237296177Sjhibbits 3238296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL); 3239296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, NULL); 3240296177Sjhibbits 3241296177Sjhibbits if(p_FmPort->bufferOffsets.timeStampOffset == ILLEGAL_BASE) 3242296177Sjhibbits return NULL; 3243296177Sjhibbits 3244296177Sjhibbits return (uint64_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.timeStampOffset); 3245296177Sjhibbits} 3246296177Sjhibbits 3247296177Sjhibbitsuint8_t * FM_PORT_GetBufferHashResult(t_Handle h_FmPort, char *p_Data) 3248296177Sjhibbits{ 3249296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3250296177Sjhibbits 3251296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 3252296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, 0); 3253296177Sjhibbits 3254296177Sjhibbits if(p_FmPort->bufferOffsets.hashResultOffset == ILLEGAL_BASE) 3255296177Sjhibbits return NULL; 3256296177Sjhibbits 3257296177Sjhibbits return (uint8_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.hashResultOffset); 3258296177Sjhibbits} 3259296177Sjhibbits 3260296177Sjhibbitst_Error FM_PORT_Disable(t_Handle h_FmPort) 3261296177Sjhibbits{ 3262296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3263296177Sjhibbits volatile uint32_t *p_BmiCfgReg = NULL; 3264296177Sjhibbits volatile uint32_t *p_BmiStatusReg = NULL; 3265296177Sjhibbits bool rxPort = FALSE; 3266296177Sjhibbits int tries; 3267296177Sjhibbits 3268296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3269296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3270296177Sjhibbits 3271296177Sjhibbits switch(p_FmPort->portType) 3272296177Sjhibbits { 3273296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3274296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3275296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcfg; 3276296177Sjhibbits p_BmiStatusReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rst; 3277296177Sjhibbits rxPort = TRUE; 3278296177Sjhibbits break; 3279296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3280296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3281296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcfg; 3282296177Sjhibbits p_BmiStatusReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tst; 3283296177Sjhibbits break; 3284296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3285296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3286296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocfg; 3287296177Sjhibbits p_BmiStatusReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ost; 3288296177Sjhibbits break; 3289296177Sjhibbits default: 3290296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3291296177Sjhibbits } 3292296177Sjhibbits /* check if port is already disabled */ 3293296177Sjhibbits if(!(GET_UINT32(*p_BmiCfgReg) & BMI_PORT_CFG_EN)) 3294296177Sjhibbits { 3295296177Sjhibbits if (!rxPort && !p_FmPort->imEn) 3296296177Sjhibbits { 3297296177Sjhibbits if(!(GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc)& QMI_PORT_CFG_EN)) 3298296177Sjhibbits /* port is disabled */ 3299296177Sjhibbits return E_OK; 3300296177Sjhibbits else 3301296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Inconsistency: Port's QMI is enabled but BMI disabled")); 3302296177Sjhibbits } 3303296177Sjhibbits /* port is disabled */ 3304296177Sjhibbits return E_OK; 3305296177Sjhibbits } 3306296177Sjhibbits 3307296177Sjhibbits /* Disable QMI */ 3308296177Sjhibbits if (!rxPort && !p_FmPort->imEn) 3309296177Sjhibbits { 3310296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc, 3311296177Sjhibbits GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc) & ~QMI_PORT_CFG_EN); 3312296177Sjhibbits /* wait for QMI to finish Handling dequeue tnums */ 3313296177Sjhibbits tries=1000; 3314296177Sjhibbits while ((GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pns) & QMI_PORT_STATUS_DEQ_FD_BSY) && 3315296177Sjhibbits --tries) 3316296177Sjhibbits XX_UDelay(1); 3317296177Sjhibbits if (!tries) 3318296177Sjhibbits RETURN_ERROR(MINOR, E_BUSY, ("%s: can't disable!", p_FmPort->name)); 3319296177Sjhibbits } 3320296177Sjhibbits 3321296177Sjhibbits /* Disable BMI */ 3322296177Sjhibbits WRITE_UINT32(*p_BmiCfgReg, GET_UINT32(*p_BmiCfgReg) & ~BMI_PORT_CFG_EN); 3323296177Sjhibbits 3324296177Sjhibbits if (p_FmPort->imEn) 3325296177Sjhibbits FmPortImDisable(p_FmPort); 3326296177Sjhibbits 3327296177Sjhibbits tries=5000; 3328296177Sjhibbits while ((GET_UINT32(*p_BmiStatusReg) & BMI_PORT_STATUS_BSY) && 3329296177Sjhibbits --tries) 3330296177Sjhibbits XX_UDelay(1); 3331296177Sjhibbits 3332296177Sjhibbits if (!tries) 3333296177Sjhibbits RETURN_ERROR(MINOR, E_BUSY, ("%s: can't disable!", p_FmPort->name)); 3334296177Sjhibbits 3335296177Sjhibbits p_FmPort->enabled = 0; 3336296177Sjhibbits 3337296177Sjhibbits return E_OK; 3338296177Sjhibbits} 3339296177Sjhibbits 3340296177Sjhibbitst_Error FM_PORT_Enable(t_Handle h_FmPort) 3341296177Sjhibbits{ 3342296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3343296177Sjhibbits volatile uint32_t *p_BmiCfgReg = NULL; 3344296177Sjhibbits bool rxPort = FALSE; 3345296177Sjhibbits 3346296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3347296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3348296177Sjhibbits 3349296177Sjhibbits switch(p_FmPort->portType) 3350296177Sjhibbits { 3351296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3352296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3353296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcfg; 3354296177Sjhibbits rxPort = TRUE; 3355296177Sjhibbits break; 3356296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3357296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3358296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcfg; 3359296177Sjhibbits break; 3360296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3361296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3362296177Sjhibbits p_BmiCfgReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocfg; 3363296177Sjhibbits break; 3364296177Sjhibbits default: 3365296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3366296177Sjhibbits } 3367296177Sjhibbits 3368296177Sjhibbits /* check if port is already enabled */ 3369296177Sjhibbits if(GET_UINT32(*p_BmiCfgReg) & BMI_PORT_CFG_EN) 3370296177Sjhibbits { 3371296177Sjhibbits if (!rxPort && !p_FmPort->imEn) 3372296177Sjhibbits { 3373296177Sjhibbits if(GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc)& QMI_PORT_CFG_EN) 3374296177Sjhibbits /* port is enabled */ 3375296177Sjhibbits return E_OK; 3376296177Sjhibbits else 3377296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Inconsistency: Port's BMI is enabled but QMI disabled")); 3378296177Sjhibbits } 3379296177Sjhibbits /* port is enabled */ 3380296177Sjhibbits return E_OK; 3381296177Sjhibbits } 3382296177Sjhibbits 3383296177Sjhibbits if (p_FmPort->imEn) 3384296177Sjhibbits FmPortImEnable(p_FmPort); 3385296177Sjhibbits 3386296177Sjhibbits /* Enable QMI */ 3387296177Sjhibbits if (!rxPort && !p_FmPort->imEn) 3388296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc, 3389296177Sjhibbits GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc) | QMI_PORT_CFG_EN); 3390296177Sjhibbits 3391296177Sjhibbits /* Enable BMI */ 3392296177Sjhibbits WRITE_UINT32(*p_BmiCfgReg, GET_UINT32(*p_BmiCfgReg) | BMI_PORT_CFG_EN); 3393296177Sjhibbits 3394296177Sjhibbits p_FmPort->enabled = 1; 3395296177Sjhibbits 3396296177Sjhibbits return E_OK; 3397296177Sjhibbits} 3398296177Sjhibbits 3399296177Sjhibbitst_Error FM_PORT_SetRateLimit(t_Handle h_FmPort, t_FmPortRateLimit *p_RateLimit) 3400296177Sjhibbits{ 3401296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3402296177Sjhibbits uint32_t tmpRateLimit, tmpRateLimitScale; 3403296177Sjhibbits volatile uint32_t *p_RateLimitReg, *p_RateLimitScaleReg; 3404296177Sjhibbits uint8_t factor, countUnitBit; 3405296177Sjhibbits uint16_t baseGran; 3406296177Sjhibbits 3407296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3408296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3409296177Sjhibbits 3410296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX) || 3411296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 3412296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx and Offline parsing ports only")); 3413296177Sjhibbits 3414296177Sjhibbits switch(p_FmPort->portType) 3415296177Sjhibbits { 3416296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3417296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3418296177Sjhibbits p_RateLimitReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_trlmt; 3419296177Sjhibbits p_RateLimitScaleReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_trlmts; 3420296177Sjhibbits baseGran = 16000; 3421296177Sjhibbits break; 3422296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3423296177Sjhibbits p_RateLimitReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_orlmt; 3424296177Sjhibbits p_RateLimitScaleReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_orlmts; 3425296177Sjhibbits baseGran = 10000; 3426296177Sjhibbits break; 3427296177Sjhibbits default: 3428296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3429296177Sjhibbits } 3430296177Sjhibbits 3431296177Sjhibbits countUnitBit = (uint8_t)FmGetTimeStampScale(p_FmPort->h_Fm); /* TimeStamp per nano seconds units */ 3432296177Sjhibbits /* normally, we use 1 usec as the reference count */ 3433296177Sjhibbits factor = 1; 3434296177Sjhibbits /* if ratelimit is too small for a 1usec factor, multiply the factor */ 3435296177Sjhibbits while (p_RateLimit->rateLimit < baseGran/factor) 3436296177Sjhibbits { 3437296177Sjhibbits if (countUnitBit==31) 3438296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Rate limit is too small")); 3439296177Sjhibbits 3440296177Sjhibbits countUnitBit++; 3441296177Sjhibbits factor <<= 1; 3442296177Sjhibbits } 3443296177Sjhibbits /* if ratelimit is too large for a 1usec factor, it is also larger than max rate*/ 3444296177Sjhibbits if (p_RateLimit->rateLimit > ((uint32_t)baseGran * (1<<10) * (uint32_t)factor)) 3445296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Rate limit is too large")); 3446296177Sjhibbits 3447296177Sjhibbits tmpRateLimit = (uint32_t)(p_RateLimit->rateLimit*factor/baseGran - 1); 3448296177Sjhibbits 3449296177Sjhibbits if(!p_RateLimit->maxBurstSize || (p_RateLimit->maxBurstSize > MAX_BURST_SIZE)) 3450296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("maxBurstSize must be between 1K and %dk", MAX_BURST_SIZE)); 3451296177Sjhibbits 3452296177Sjhibbits tmpRateLimitScale = ((31 - (uint32_t)countUnitBit) << BMI_COUNT_RATE_UNIT_SHIFT) | BMI_RATE_LIMIT_EN; 3453296177Sjhibbits 3454296177Sjhibbits if(p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING) 3455296177Sjhibbits tmpRateLimit |= (uint32_t)(p_RateLimit->maxBurstSize - 1) << BMI_MAX_BURST_SHIFT; 3456296177Sjhibbits else 3457296177Sjhibbits { 3458296177Sjhibbits#ifndef FM_NO_ADVANCED_RATE_LIMITER 3459296177Sjhibbits t_FmRevisionInfo revInfo; 3460296177Sjhibbits 3461296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 3462296177Sjhibbits if (revInfo.majorRev == 4) 3463296177Sjhibbits { 3464296177Sjhibbits switch(p_RateLimit->rateLimitDivider) 3465296177Sjhibbits { 3466296177Sjhibbits case(e_FM_PORT_DUAL_RATE_LIMITER_NONE): 3467296177Sjhibbits break; 3468296177Sjhibbits case(e_FM_PORT_DUAL_RATE_LIMITER_SCALE_DOWN_BY_2): 3469296177Sjhibbits tmpRateLimitScale |= BMI_RATE_LIMIT_SCALE_BY_2; 3470296177Sjhibbits break; 3471296177Sjhibbits case(e_FM_PORT_DUAL_RATE_LIMITER_SCALE_DOWN_BY_4): 3472296177Sjhibbits tmpRateLimitScale |= BMI_RATE_LIMIT_SCALE_BY_4; 3473296177Sjhibbits break; 3474296177Sjhibbits case(e_FM_PORT_DUAL_RATE_LIMITER_SCALE_DOWN_BY_8): 3475296177Sjhibbits tmpRateLimitScale |= BMI_RATE_LIMIT_SCALE_BY_8; 3476296177Sjhibbits break; 3477296177Sjhibbits default: 3478296177Sjhibbits break; 3479296177Sjhibbits } 3480296177Sjhibbits tmpRateLimit |= BMI_RATE_LIMIT_BURST_SIZE_GRAN; 3481296177Sjhibbits } 3482296177Sjhibbits else 3483296177Sjhibbits#endif /* ! FM_NO_ADVANCED_RATE_LIMITER */ 3484296177Sjhibbits { 3485296177Sjhibbits if(p_RateLimit->rateLimitDivider != e_FM_PORT_DUAL_RATE_LIMITER_NONE) 3486296177Sjhibbits RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("FM_PORT_ConfigDualRateLimitScaleDown")); 3487296177Sjhibbits 3488296177Sjhibbits if(p_RateLimit->maxBurstSize % 1000) 3489296177Sjhibbits { 3490296177Sjhibbits p_RateLimit->maxBurstSize = (uint16_t)((p_RateLimit->maxBurstSize/1000)+1); 3491296177Sjhibbits DBG(WARNING, ("rateLimit.maxBurstSize rounded up to %d", (p_RateLimit->maxBurstSize/1000+1)*1000)); 3492296177Sjhibbits } 3493296177Sjhibbits else 3494296177Sjhibbits p_RateLimit->maxBurstSize = (uint16_t)(p_RateLimit->maxBurstSize/1000); 3495296177Sjhibbits } 3496296177Sjhibbits tmpRateLimit |= (uint32_t)(p_RateLimit->maxBurstSize - 1) << BMI_MAX_BURST_SHIFT; 3497296177Sjhibbits 3498296177Sjhibbits } 3499296177Sjhibbits WRITE_UINT32(*p_RateLimitScaleReg, tmpRateLimitScale); 3500296177Sjhibbits WRITE_UINT32(*p_RateLimitReg, tmpRateLimit); 3501296177Sjhibbits 3502296177Sjhibbits return E_OK; 3503296177Sjhibbits} 3504296177Sjhibbits 3505296177Sjhibbitst_Error FM_PORT_DeleteRateLimit(t_Handle h_FmPort) 3506296177Sjhibbits{ 3507296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3508296177Sjhibbits volatile uint32_t *p_RateLimitReg, *p_RateLimitScaleReg; 3509296177Sjhibbits 3510296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3511296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE); 3512296177Sjhibbits 3513296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX) || 3514296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 3515296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Tx and Offline parsing ports only")); 3516296177Sjhibbits 3517296177Sjhibbits switch(p_FmPort->portType) 3518296177Sjhibbits { 3519296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3520296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3521296177Sjhibbits p_RateLimitReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_trlmt; 3522296177Sjhibbits p_RateLimitScaleReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_trlmts; 3523296177Sjhibbits break; 3524296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3525296177Sjhibbits p_RateLimitReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_orlmt; 3526296177Sjhibbits p_RateLimitScaleReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_orlmts; 3527296177Sjhibbits break; 3528296177Sjhibbits default: 3529296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3530296177Sjhibbits } 3531296177Sjhibbits 3532296177Sjhibbits WRITE_UINT32(*p_RateLimitScaleReg, 0); 3533296177Sjhibbits WRITE_UINT32(*p_RateLimitReg, 0); 3534296177Sjhibbits 3535296177Sjhibbits return E_OK; 3536296177Sjhibbits} 3537296177Sjhibbits 3538296177Sjhibbits 3539296177Sjhibbitst_Error FM_PORT_SetFrameQueueCounters(t_Handle h_FmPort, bool enable) 3540296177Sjhibbits{ 3541296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3542296177Sjhibbits uint32_t tmpReg; 3543296177Sjhibbits 3544296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3545296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3546296177Sjhibbits 3547296177Sjhibbits tmpReg = GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc); 3548296177Sjhibbits if(enable) 3549296177Sjhibbits tmpReg |= QMI_PORT_CFG_EN_COUNTERS ; 3550296177Sjhibbits else 3551296177Sjhibbits tmpReg &= ~QMI_PORT_CFG_EN_COUNTERS; 3552296177Sjhibbits 3553296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc, tmpReg); 3554296177Sjhibbits 3555296177Sjhibbits return E_OK; 3556296177Sjhibbits} 3557296177Sjhibbits 3558296177Sjhibbitst_Error FM_PORT_SetPerformanceCounters(t_Handle h_FmPort, bool enable) 3559296177Sjhibbits{ 3560296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3561296177Sjhibbits volatile uint32_t *p_BmiPcReg = NULL; 3562296177Sjhibbits 3563296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3564296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3565296177Sjhibbits 3566296177Sjhibbits switch(p_FmPort->portType) 3567296177Sjhibbits { 3568296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3569296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3570296177Sjhibbits p_BmiPcReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpc; 3571296177Sjhibbits break; 3572296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3573296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3574296177Sjhibbits p_BmiPcReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tpc; 3575296177Sjhibbits break; 3576296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3577296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3578296177Sjhibbits p_BmiPcReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opc; 3579296177Sjhibbits break; 3580296177Sjhibbits default: 3581296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3582296177Sjhibbits } 3583296177Sjhibbits 3584296177Sjhibbits if(enable) 3585296177Sjhibbits WRITE_UINT32(*p_BmiPcReg, BMI_COUNTERS_EN); 3586296177Sjhibbits else 3587296177Sjhibbits WRITE_UINT32(*p_BmiPcReg, 0); 3588296177Sjhibbits 3589296177Sjhibbits return E_OK; 3590296177Sjhibbits} 3591296177Sjhibbits 3592296177Sjhibbitst_Error FM_PORT_SetPerformanceCountersParams(t_Handle h_FmPort, t_FmPortPerformanceCnt *p_FmPortPerformanceCnt) 3593296177Sjhibbits{ 3594296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3595296177Sjhibbits uint32_t tmpReg; 3596296177Sjhibbits volatile uint32_t *p_BmiPcpReg = NULL; 3597296177Sjhibbits 3598296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3599296177Sjhibbits 3600296177Sjhibbits switch(p_FmPort->portType) 3601296177Sjhibbits { 3602296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3603296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3604296177Sjhibbits p_BmiPcpReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpcp; 3605296177Sjhibbits break; 3606296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3607296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3608296177Sjhibbits p_BmiPcpReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tpcp; 3609296177Sjhibbits break; 3610296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3611296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3612296177Sjhibbits p_BmiPcpReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opcp; 3613296177Sjhibbits break; 3614296177Sjhibbits default: 3615296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3616296177Sjhibbits } 3617296177Sjhibbits 3618296177Sjhibbits /* check parameters */ 3619296177Sjhibbits if (!p_FmPortPerformanceCnt->taskCompVal || 3620296177Sjhibbits (p_FmPortPerformanceCnt->taskCompVal > p_FmPort->tasks.num)) 3621296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3622296177Sjhibbits ("performanceCnt.taskCompVal has to be in the range of 1 - %d (current value)!", 3623296177Sjhibbits p_FmPort->tasks.num)); 3624296177Sjhibbits if (!p_FmPortPerformanceCnt->dmaCompVal || 3625296177Sjhibbits (p_FmPortPerformanceCnt->dmaCompVal > p_FmPort->openDmas.num)) 3626296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3627296177Sjhibbits ("performanceCnt.dmaCompVal has to be in the range of 1 - %d (current value)!", 3628296177Sjhibbits p_FmPort->openDmas.num)); 3629296177Sjhibbits if (!p_FmPortPerformanceCnt->fifoCompVal || 3630296177Sjhibbits (p_FmPortPerformanceCnt->fifoCompVal > p_FmPort->fifoBufs.num)) 3631296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3632296177Sjhibbits ("performanceCnt.fifoCompVal has to be in the range of 256 - %d (current value)!", 3633296177Sjhibbits p_FmPort->fifoBufs.num)); 3634296177Sjhibbits if (p_FmPortPerformanceCnt->fifoCompVal % BMI_FIFO_UNITS) 3635296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3636296177Sjhibbits ("performanceCnt.fifoCompVal has to be divisible by %d", 3637296177Sjhibbits BMI_FIFO_UNITS)); 3638296177Sjhibbits switch(p_FmPort->portType) 3639296177Sjhibbits { 3640296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3641296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3642296177Sjhibbits if (!p_FmPortPerformanceCnt->queueCompVal || 3643296177Sjhibbits (p_FmPortPerformanceCnt->queueCompVal > MAX_PERFORMANCE_RX_QUEUE_COMP)) 3644296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3645296177Sjhibbits ("performanceCnt.queueCompVal for Rx has to be in the range of 1 - %d", 3646296177Sjhibbits MAX_PERFORMANCE_RX_QUEUE_COMP)); 3647296177Sjhibbits break; 3648296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3649296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3650296177Sjhibbits if (!p_FmPortPerformanceCnt->queueCompVal || 3651296177Sjhibbits (p_FmPortPerformanceCnt->queueCompVal > MAX_PERFORMANCE_TX_QUEUE_COMP)) 3652296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3653296177Sjhibbits ("performanceCnt.queueCompVal for Tx has to be in the range of 1 - %d", 3654296177Sjhibbits MAX_PERFORMANCE_TX_QUEUE_COMP)); 3655296177Sjhibbits break; 3656296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3657296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3658296177Sjhibbits if (p_FmPortPerformanceCnt->queueCompVal) 3659296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("performanceCnt.queueCompVal is not relevant for H/O ports.")); 3660296177Sjhibbits break; 3661296177Sjhibbits default: 3662296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3663296177Sjhibbits } 3664296177Sjhibbits 3665296177Sjhibbits tmpReg = 0; 3666296177Sjhibbits tmpReg |= ((uint32_t)(p_FmPortPerformanceCnt->queueCompVal - 1) << BMI_PERFORMANCE_PORT_COMP_SHIFT); 3667296177Sjhibbits tmpReg |= ((uint32_t)(p_FmPortPerformanceCnt->dmaCompVal- 1) << BMI_PERFORMANCE_DMA_COMP_SHIFT); 3668296177Sjhibbits tmpReg |= ((uint32_t)(p_FmPortPerformanceCnt->fifoCompVal/BMI_FIFO_UNITS - 1) << BMI_PERFORMANCE_FIFO_COMP_SHIFT); 3669296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING) && (p_FmPort->portType != e_FM_PORT_TYPE_OH_HOST_COMMAND)) 3670296177Sjhibbits tmpReg |= ((uint32_t)(p_FmPortPerformanceCnt->taskCompVal - 1) << BMI_PERFORMANCE_TASK_COMP_SHIFT); 3671296177Sjhibbits 3672296177Sjhibbits WRITE_UINT32(*p_BmiPcpReg, tmpReg); 3673296177Sjhibbits 3674296177Sjhibbits return E_OK; 3675296177Sjhibbits} 3676296177Sjhibbits 3677296177Sjhibbitst_Error FM_PORT_AnalyzePerformanceParams(t_Handle h_FmPort) 3678296177Sjhibbits{ 3679296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3680296177Sjhibbits t_FmPortPerformanceCnt currParams, savedParams; 3681296177Sjhibbits t_Error err; 3682296177Sjhibbits bool underTest, failed = FALSE; 3683296177Sjhibbits 3684296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3685296177Sjhibbits 3686296177Sjhibbits XX_Print("Analyzing Performance parameters for port (type %d, id%d)\n", 3687296177Sjhibbits p_FmPort->portType, p_FmPort->portId); 3688296177Sjhibbits 3689296177Sjhibbits currParams.taskCompVal = (uint8_t)p_FmPort->tasks.num; 3690296177Sjhibbits if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) || 3691296177Sjhibbits (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) 3692296177Sjhibbits currParams.queueCompVal = 0; 3693296177Sjhibbits else 3694296177Sjhibbits currParams.queueCompVal = 1; 3695296177Sjhibbits currParams.dmaCompVal =(uint8_t) p_FmPort->openDmas.num; 3696296177Sjhibbits currParams.fifoCompVal = p_FmPort->fifoBufs.num; 3697296177Sjhibbits 3698296177Sjhibbits FM_PORT_SetPerformanceCounters(p_FmPort, FALSE); 3699296177Sjhibbits ClearPerfCnts(p_FmPort); 3700296177Sjhibbits if ((err = FM_PORT_SetPerformanceCountersParams(p_FmPort, &currParams)) != E_OK) 3701296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 3702296177Sjhibbits FM_PORT_SetPerformanceCounters(p_FmPort, TRUE); 3703296177Sjhibbits XX_UDelay(1000000); 3704296177Sjhibbits FM_PORT_SetPerformanceCounters(p_FmPort, FALSE); 3705296177Sjhibbits if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL)) 3706296177Sjhibbits { 3707296177Sjhibbits XX_Print ("Max num of defined port tasks (%d) utilized - Please enlarge\n",p_FmPort->tasks.num); 3708296177Sjhibbits failed = TRUE; 3709296177Sjhibbits } 3710296177Sjhibbits if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL)) 3711296177Sjhibbits { 3712296177Sjhibbits XX_Print ("Max num of defined port openDmas (%d) utilized - Please enlarge\n",p_FmPort->openDmas.num); 3713296177Sjhibbits failed = TRUE; 3714296177Sjhibbits } 3715296177Sjhibbits if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL)) 3716296177Sjhibbits { 3717296177Sjhibbits XX_Print ("Max size of defined port fifo (%d) utilized - Please enlarge\n",p_FmPort->fifoBufs.num*BMI_FIFO_UNITS); 3718296177Sjhibbits failed = TRUE; 3719296177Sjhibbits } 3720296177Sjhibbits if (failed) 3721296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3722296177Sjhibbits 3723296177Sjhibbits memset(&savedParams, 0, sizeof(savedParams)); 3724296177Sjhibbits while (TRUE) 3725296177Sjhibbits { 3726296177Sjhibbits underTest = FALSE; 3727296177Sjhibbits if ((currParams.taskCompVal != 1) && !savedParams.taskCompVal) 3728296177Sjhibbits { 3729296177Sjhibbits currParams.taskCompVal--; 3730296177Sjhibbits underTest = TRUE; 3731296177Sjhibbits } 3732296177Sjhibbits if ((currParams.dmaCompVal != 1) && !savedParams.dmaCompVal) 3733296177Sjhibbits { 3734296177Sjhibbits currParams.dmaCompVal--; 3735296177Sjhibbits underTest = TRUE; 3736296177Sjhibbits } 3737296177Sjhibbits if ((currParams.fifoCompVal != BMI_FIFO_UNITS) && !savedParams.fifoCompVal) 3738296177Sjhibbits { 3739296177Sjhibbits currParams.fifoCompVal -= BMI_FIFO_UNITS; 3740296177Sjhibbits underTest = TRUE; 3741296177Sjhibbits } 3742296177Sjhibbits if (!underTest) 3743296177Sjhibbits break; 3744296177Sjhibbits 3745296177Sjhibbits ClearPerfCnts(p_FmPort); 3746296177Sjhibbits if ((err = FM_PORT_SetPerformanceCountersParams(p_FmPort, &currParams)) != E_OK) 3747296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 3748296177Sjhibbits FM_PORT_SetPerformanceCounters(p_FmPort, TRUE); 3749296177Sjhibbits XX_UDelay(1000000); 3750296177Sjhibbits FM_PORT_SetPerformanceCounters(p_FmPort, FALSE); 3751296177Sjhibbits 3752296177Sjhibbits if (!savedParams.taskCompVal && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL)) 3753296177Sjhibbits savedParams.taskCompVal = (uint8_t)(currParams.taskCompVal+2); 3754296177Sjhibbits if (!savedParams.dmaCompVal && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL)) 3755296177Sjhibbits savedParams.dmaCompVal = (uint8_t)(currParams.dmaCompVal+2); 3756296177Sjhibbits if (!savedParams.fifoCompVal && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL)) 3757296177Sjhibbits savedParams.fifoCompVal = currParams.fifoCompVal+2; 3758296177Sjhibbits } 3759296177Sjhibbits 3760296177Sjhibbits XX_Print("best vals: tasks %d, dmas %d, fifos %d\n", 3761296177Sjhibbits savedParams.taskCompVal, savedParams.dmaCompVal, savedParams.fifoCompVal); 3762296177Sjhibbits return E_OK; 3763296177Sjhibbits} 3764296177Sjhibbits 3765296177Sjhibbitst_Error FM_PORT_SetStatisticsCounters(t_Handle h_FmPort, bool enable) 3766296177Sjhibbits{ 3767296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3768296177Sjhibbits uint32_t tmpReg; 3769296177Sjhibbits volatile uint32_t *p_BmiStcReg = NULL; 3770296177Sjhibbits 3771296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3772296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3773296177Sjhibbits 3774296177Sjhibbits switch(p_FmPort->portType) 3775296177Sjhibbits { 3776296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3777296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3778296177Sjhibbits p_BmiStcReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rstc; 3779296177Sjhibbits break; 3780296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3781296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3782296177Sjhibbits p_BmiStcReg = &p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tstc; 3783296177Sjhibbits break; 3784296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3785296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3786296177Sjhibbits p_BmiStcReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ostc; 3787296177Sjhibbits break; 3788296177Sjhibbits default: 3789296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 3790296177Sjhibbits } 3791296177Sjhibbits 3792296177Sjhibbits tmpReg = GET_UINT32(*p_BmiStcReg); 3793296177Sjhibbits 3794296177Sjhibbits if(enable) 3795296177Sjhibbits tmpReg |= BMI_COUNTERS_EN; 3796296177Sjhibbits else 3797296177Sjhibbits tmpReg &= ~BMI_COUNTERS_EN; 3798296177Sjhibbits 3799296177Sjhibbits WRITE_UINT32(*p_BmiStcReg, tmpReg); 3800296177Sjhibbits 3801296177Sjhibbits return E_OK; 3802296177Sjhibbits} 3803296177Sjhibbits 3804296177Sjhibbitst_Error FM_PORT_SetErrorsRoute(t_Handle h_FmPort, fmPortFrameErrSelect_t errs) 3805296177Sjhibbits{ 3806296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3807296177Sjhibbits volatile uint32_t *p_ErrQReg, *p_ErrDiscard; 3808296177Sjhibbits 3809296177Sjhibbits switch(p_FmPort->portType) 3810296177Sjhibbits { 3811296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3812296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3813296177Sjhibbits p_ErrQReg = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsem; 3814296177Sjhibbits p_ErrDiscard = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsdm; 3815296177Sjhibbits break; 3816296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3817296177Sjhibbits p_ErrQReg = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsem; 3818296177Sjhibbits p_ErrDiscard = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm; 3819296177Sjhibbits break; 3820296177Sjhibbits default: 3821296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 3822296177Sjhibbits } 3823296177Sjhibbits 3824296177Sjhibbits if (GET_UINT32(*p_ErrDiscard) & errs) 3825296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_SELECTION, ("Selectd Errors that were configured to cause frame discard.")); 3826296177Sjhibbits 3827296177Sjhibbits WRITE_UINT32(*p_ErrQReg, errs); 3828296177Sjhibbits 3829296177Sjhibbits return E_OK; 3830296177Sjhibbits} 3831296177Sjhibbits 3832296177Sjhibbitst_Error FM_PORT_SetAllocBufCounter(t_Handle h_FmPort, uint8_t poolId, bool enable) 3833296177Sjhibbits{ 3834296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3835296177Sjhibbits uint32_t tmpReg; 3836296177Sjhibbits int i; 3837296177Sjhibbits 3838296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3839296177Sjhibbits SANITY_CHECK_RETURN_ERROR(poolId<BM_MAX_NUM_OF_POOLS, E_INVALID_HANDLE); 3840296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3841296177Sjhibbits 3842296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 3843296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 3844296177Sjhibbits 3845296177Sjhibbits for(i=0 ; i< FM_PORT_MAX_NUM_OF_EXT_POOLS ; i++) 3846296177Sjhibbits { 3847296177Sjhibbits tmpReg = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i]); 3848296177Sjhibbits if ((uint8_t)((tmpReg & BMI_EXT_BUF_POOL_ID_MASK) >> BMI_EXT_BUF_POOL_ID_SHIFT) == poolId) 3849296177Sjhibbits { 3850296177Sjhibbits if(enable) 3851296177Sjhibbits tmpReg |= BMI_EXT_BUF_POOL_EN_COUNTER; 3852296177Sjhibbits else 3853296177Sjhibbits tmpReg &= ~BMI_EXT_BUF_POOL_EN_COUNTER; 3854296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i], tmpReg); 3855296177Sjhibbits break; 3856296177Sjhibbits } 3857296177Sjhibbits } 3858296177Sjhibbits if (i == FM_PORT_MAX_NUM_OF_EXT_POOLS) 3859296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_VALUE,("poolId %d is not included in this ports pools", poolId)); 3860296177Sjhibbits 3861296177Sjhibbits return E_OK; 3862296177Sjhibbits} 3863296177Sjhibbits 3864296177Sjhibbitsuint32_t FM_PORT_GetCounter(t_Handle h_FmPort, e_FmPortCounters counter) 3865296177Sjhibbits{ 3866296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3867296177Sjhibbits bool bmiCounter = FALSE; 3868296177Sjhibbits volatile uint32_t *p_Reg; 3869296177Sjhibbits 3870296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 3871296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3872296177Sjhibbits 3873296177Sjhibbits switch(counter) 3874296177Sjhibbits { 3875296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_TOTAL): 3876296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_FROM_DEFAULT): 3877296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_CONFIRM ): 3878296177Sjhibbits /* check that counter is available for the port type */ 3879296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 3880296177Sjhibbits { 3881296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Rx ports")); 3882296177Sjhibbits return 0; 3883296177Sjhibbits } 3884296177Sjhibbits bmiCounter = FALSE; 3885296177Sjhibbits case(e_FM_PORT_COUNTERS_ENQ_TOTAL): 3886296177Sjhibbits bmiCounter = FALSE; 3887296177Sjhibbits break; 3888296177Sjhibbits default: /* BMI counters (or error - will be checked in BMI routine )*/ 3889296177Sjhibbits bmiCounter = TRUE; 3890296177Sjhibbits break; 3891296177Sjhibbits } 3892296177Sjhibbits 3893296177Sjhibbits if(bmiCounter) 3894296177Sjhibbits { 3895296177Sjhibbits switch(p_FmPort->portType) 3896296177Sjhibbits { 3897296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3898296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3899296177Sjhibbits if(BmiRxPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3900296177Sjhibbits { 3901296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3902296177Sjhibbits return 0; 3903296177Sjhibbits } 3904296177Sjhibbits break; 3905296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3906296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3907296177Sjhibbits if(BmiTxPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3908296177Sjhibbits { 3909296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3910296177Sjhibbits return 0; 3911296177Sjhibbits } 3912296177Sjhibbits break; 3913296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3914296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3915296177Sjhibbits if(BmiOhPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3916296177Sjhibbits { 3917296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3918296177Sjhibbits return 0; 3919296177Sjhibbits } 3920296177Sjhibbits break; 3921296177Sjhibbits default: 3922296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Unsupported port type")); 3923296177Sjhibbits return 0; 3924296177Sjhibbits } 3925296177Sjhibbits return GET_UINT32(*p_Reg); 3926296177Sjhibbits } 3927296177Sjhibbits else /* QMI counter */ 3928296177Sjhibbits { 3929296177Sjhibbits 3930296177Sjhibbits /* check that counters are enabled */ 3931296177Sjhibbits if(!(GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc) & QMI_PORT_CFG_EN_COUNTERS)) 3932296177Sjhibbits { 3933296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 3934296177Sjhibbits return 0; 3935296177Sjhibbits } 3936296177Sjhibbits 3937296177Sjhibbits /* Set counter */ 3938296177Sjhibbits switch(counter) 3939296177Sjhibbits { 3940296177Sjhibbits case(e_FM_PORT_COUNTERS_ENQ_TOTAL): 3941296177Sjhibbits return GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnetfc); 3942296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_TOTAL): 3943296177Sjhibbits return GET_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndtfc); 3944296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_FROM_DEFAULT): 3945296177Sjhibbits return GET_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndfdc); 3946296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_CONFIRM): 3947296177Sjhibbits return GET_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndcc); 3948296177Sjhibbits default: 3949296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available")); 3950296177Sjhibbits return 0; 3951296177Sjhibbits } 3952296177Sjhibbits } 3953296177Sjhibbits 3954296177Sjhibbits return 0; 3955296177Sjhibbits} 3956296177Sjhibbits 3957296177Sjhibbitst_Error FM_PORT_ModifyCounter(t_Handle h_FmPort, e_FmPortCounters counter, uint32_t value) 3958296177Sjhibbits{ 3959296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 3960296177Sjhibbits bool bmiCounter = FALSE; 3961296177Sjhibbits volatile uint32_t *p_Reg; 3962296177Sjhibbits 3963296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 3964296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 3965296177Sjhibbits 3966296177Sjhibbits switch(counter) 3967296177Sjhibbits { 3968296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_TOTAL): 3969296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_FROM_DEFAULT): 3970296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_CONFIRM ): 3971296177Sjhibbits /* check that counter is available for the port type */ 3972296177Sjhibbits if((p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 3973296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for Rx ports")); 3974296177Sjhibbits case(e_FM_PORT_COUNTERS_ENQ_TOTAL): 3975296177Sjhibbits bmiCounter = FALSE; 3976296177Sjhibbits break; 3977296177Sjhibbits default: /* BMI counters (or error - will be checked in BMI routine )*/ 3978296177Sjhibbits bmiCounter = TRUE; 3979296177Sjhibbits break; 3980296177Sjhibbits } 3981296177Sjhibbits 3982296177Sjhibbits if(bmiCounter) 3983296177Sjhibbits { 3984296177Sjhibbits switch(p_FmPort->portType) 3985296177Sjhibbits { 3986296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 3987296177Sjhibbits case(e_FM_PORT_TYPE_RX): 3988296177Sjhibbits if(BmiRxPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3989296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3990296177Sjhibbits break; 3991296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 3992296177Sjhibbits case(e_FM_PORT_TYPE_TX): 3993296177Sjhibbits if(BmiTxPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3994296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 3995296177Sjhibbits break; 3996296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 3997296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 3998296177Sjhibbits if(BmiOhPortCheckAndGetCounterPtr(p_FmPort, counter, &p_Reg)) 3999296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, NO_MSG); 4000296177Sjhibbits break; 4001296177Sjhibbits default: 4002296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported port type")); 4003296177Sjhibbits } 4004296177Sjhibbits WRITE_UINT32(*p_Reg, value); 4005296177Sjhibbits } 4006296177Sjhibbits else /* QMI counter */ 4007296177Sjhibbits { 4008296177Sjhibbits 4009296177Sjhibbits /* check that counters are enabled */ 4010296177Sjhibbits if(!(GET_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnc) & QMI_PORT_CFG_EN_COUNTERS)) 4011296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); 4012296177Sjhibbits 4013296177Sjhibbits /* Set counter */ 4014296177Sjhibbits switch(counter) 4015296177Sjhibbits { 4016296177Sjhibbits case(e_FM_PORT_COUNTERS_ENQ_TOTAL): 4017296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnetfc, value); 4018296177Sjhibbits break; 4019296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_TOTAL): 4020296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndtfc, value); 4021296177Sjhibbits break; 4022296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_FROM_DEFAULT): 4023296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndfdc, value); 4024296177Sjhibbits break; 4025296177Sjhibbits case(e_FM_PORT_COUNTERS_DEQ_CONFIRM): 4026296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndcc, value); 4027296177Sjhibbits break; 4028296177Sjhibbits default: 4029296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available")); 4030296177Sjhibbits } 4031296177Sjhibbits } 4032296177Sjhibbits 4033296177Sjhibbits return E_OK; 4034296177Sjhibbits} 4035296177Sjhibbits 4036296177Sjhibbitsuint32_t FM_PORT_GetAllocBufCounter(t_Handle h_FmPort, uint8_t poolId) 4037296177Sjhibbits{ 4038296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4039296177Sjhibbits uint32_t extPoolReg; 4040296177Sjhibbits uint8_t tmpPool; 4041296177Sjhibbits uint8_t i; 4042296177Sjhibbits 4043296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0); 4044296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4045296177Sjhibbits 4046296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX) && (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 4047296177Sjhibbits { 4048296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for non-Rx ports")); 4049296177Sjhibbits return 0; 4050296177Sjhibbits } 4051296177Sjhibbits 4052296177Sjhibbits for(i=0;i<FM_PORT_MAX_NUM_OF_EXT_POOLS;i++) 4053296177Sjhibbits { 4054296177Sjhibbits extPoolReg = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i]); 4055296177Sjhibbits if (extPoolReg & BMI_EXT_BUF_POOL_VALID) 4056296177Sjhibbits { 4057296177Sjhibbits tmpPool = (uint8_t)((extPoolReg & BMI_EXT_BUF_POOL_ID_MASK) >> BMI_EXT_BUF_POOL_ID_SHIFT); 4058296177Sjhibbits if(tmpPool == poolId) 4059296177Sjhibbits { 4060296177Sjhibbits if(extPoolReg & BMI_EXT_BUF_POOL_EN_COUNTER) 4061296177Sjhibbits return GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt[i]); 4062296177Sjhibbits else 4063296177Sjhibbits { 4064296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not enabled")); 4065296177Sjhibbits return 0; 4066296177Sjhibbits } 4067296177Sjhibbits } 4068296177Sjhibbits } 4069296177Sjhibbits } 4070296177Sjhibbits REPORT_ERROR(MINOR, E_INVALID_STATE, ("Pool %d is not used", poolId)); 4071296177Sjhibbits return 0; 4072296177Sjhibbits} 4073296177Sjhibbits 4074296177Sjhibbitst_Error FM_PORT_ModifyAllocBufCounter(t_Handle h_FmPort, uint8_t poolId, uint32_t value) 4075296177Sjhibbits{ 4076296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort *)h_FmPort; 4077296177Sjhibbits uint32_t extPoolReg; 4078296177Sjhibbits uint8_t tmpPool; 4079296177Sjhibbits uint8_t i; 4080296177Sjhibbits 4081296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4082296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4083296177Sjhibbits 4084296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX) && (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)) 4085296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not available for non-Rx ports")); 4086296177Sjhibbits 4087296177Sjhibbits 4088296177Sjhibbits for(i=0;i<FM_PORT_MAX_NUM_OF_EXT_POOLS;i++) 4089296177Sjhibbits { 4090296177Sjhibbits extPoolReg = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i]); 4091296177Sjhibbits if (extPoolReg & BMI_EXT_BUF_POOL_VALID) 4092296177Sjhibbits { 4093296177Sjhibbits tmpPool = (uint8_t)((extPoolReg & BMI_EXT_BUF_POOL_ID_MASK) >> BMI_EXT_BUF_POOL_ID_SHIFT); 4094296177Sjhibbits if(tmpPool == poolId) 4095296177Sjhibbits { 4096296177Sjhibbits if(extPoolReg & BMI_EXT_BUF_POOL_EN_COUNTER) 4097296177Sjhibbits { 4098296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt[i], value); 4099296177Sjhibbits return E_OK; 4100296177Sjhibbits } 4101296177Sjhibbits else 4102296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter is not enabled")); 4103296177Sjhibbits } 4104296177Sjhibbits } 4105296177Sjhibbits } 4106296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Pool %d is not used", poolId)); 4107296177Sjhibbits} 4108296177Sjhibbits 4109296177Sjhibbitsbool FM_PORT_IsStalled(t_Handle h_FmPort) 4110296177Sjhibbits{ 4111296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4112296177Sjhibbits t_Error err; 4113296177Sjhibbits bool isStalled; 4114296177Sjhibbits 4115296177Sjhibbits SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, FALSE); 4116296177Sjhibbits SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE, FALSE); 4117296177Sjhibbits 4118296177Sjhibbits err = FmIsPortStalled(p_FmPort->h_Fm, p_FmPort->hardwarePortId, &isStalled); 4119296177Sjhibbits if(err != E_OK) 4120296177Sjhibbits { 4121296177Sjhibbits REPORT_ERROR(MINOR, err, NO_MSG); 4122296177Sjhibbits return TRUE; 4123296177Sjhibbits } 4124296177Sjhibbits return isStalled; 4125296177Sjhibbits} 4126296177Sjhibbits 4127296177Sjhibbitst_Error FM_PORT_ReleaseStalled(t_Handle h_FmPort) 4128296177Sjhibbits{ 4129296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4130296177Sjhibbits 4131296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4132296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4133296177Sjhibbits 4134296177Sjhibbits return FmResumeStalledPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId); 4135296177Sjhibbits} 4136296177Sjhibbits 4137296177Sjhibbitst_Error FM_PORT_SetRxL4ChecksumVerify(t_Handle h_FmPort, bool l4Checksum) 4138296177Sjhibbits{ 4139296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4140296177Sjhibbits uint32_t tmpReg; 4141296177Sjhibbits 4142296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4143296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4144296177Sjhibbits 4145296177Sjhibbits if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 4146296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 4147296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx ports only")); 4148296177Sjhibbits 4149296177Sjhibbits tmpReg = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne); 4150296177Sjhibbits if (l4Checksum) 4151296177Sjhibbits tmpReg &= ~BMI_PORT_RFNE_FRWD_DCL4C; 4152296177Sjhibbits else 4153296177Sjhibbits tmpReg |= BMI_PORT_RFNE_FRWD_DCL4C; 4154296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne, tmpReg); 4155296177Sjhibbits 4156296177Sjhibbits return E_OK; 4157296177Sjhibbits} 4158296177Sjhibbits 4159296177Sjhibbits 4160296177Sjhibbits/* API Run-time PCD Control unit functions */ 4161296177Sjhibbits 4162296177Sjhibbitst_Error FM_PORT_PcdPlcrAllocProfiles(t_Handle h_FmPort, uint16_t numOfProfiles) 4163296177Sjhibbits{ 4164296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4165296177Sjhibbits t_Error err = E_OK; 4166296177Sjhibbits 4167296177Sjhibbits p_FmPort->h_FmPcd = FmGetPcdHandle(p_FmPort->h_Fm); 4168296177Sjhibbits ASSERT_COND(p_FmPort->h_FmPcd); 4169296177Sjhibbits 4170296177Sjhibbits if(numOfProfiles) 4171296177Sjhibbits { 4172296177Sjhibbits err = FmPcdPlcrAllocProfiles(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId, numOfProfiles); 4173296177Sjhibbits if(err) 4174296177Sjhibbits RETURN_ERROR(MAJOR, err,NO_MSG); 4175296177Sjhibbits } 4176296177Sjhibbits FmPcdPortRegister(p_FmPort->h_FmPcd, h_FmPort, p_FmPort->hardwarePortId); 4177296177Sjhibbits 4178296177Sjhibbits return E_OK; 4179296177Sjhibbits} 4180296177Sjhibbits 4181296177Sjhibbitst_Error FM_PORT_PcdPlcrFreeProfiles(t_Handle h_FmPort) 4182296177Sjhibbits{ 4183296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4184296177Sjhibbits t_Error err = E_OK; 4185296177Sjhibbits 4186296177Sjhibbits err = FmPcdPlcrFreeProfiles(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId); 4187296177Sjhibbits if(err) 4188296177Sjhibbits RETURN_ERROR(MAJOR, err,NO_MSG); 4189296177Sjhibbits return E_OK; 4190296177Sjhibbits} 4191296177Sjhibbits 4192296177Sjhibbitst_Error FM_PORT_PcdKgModifyInitialScheme (t_Handle h_FmPort, t_FmPcdKgSchemeSelect *p_FmPcdKgScheme) 4193296177Sjhibbits{ 4194296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4195296177Sjhibbits volatile uint32_t *p_BmiHpnia = NULL; 4196296177Sjhibbits uint32_t tmpReg; 4197296177Sjhibbits uint8_t relativeSchemeId; 4198296177Sjhibbits uint8_t physicalSchemeId; 4199296177Sjhibbits 4200296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4201296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4202296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG , E_INVALID_STATE); 4203296177Sjhibbits 4204296177Sjhibbits tmpReg = (uint32_t)((p_FmPort->pcdEngines & FM_PCD_CC)? NIA_KG_CC_EN:0); 4205296177Sjhibbits switch(p_FmPort->portType) 4206296177Sjhibbits { 4207296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4208296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4209296177Sjhibbits p_BmiHpnia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne; 4210296177Sjhibbits break; 4211296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4212296177Sjhibbits p_BmiHpnia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofpne; 4213296177Sjhibbits break; 4214296177Sjhibbits default: 4215296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 4216296177Sjhibbits } 4217296177Sjhibbits 4218296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4219296177Sjhibbits return ERROR_CODE(E_BUSY); 4220296177Sjhibbits /* if we want to change to direct scheme, we need to check that this scheme is valid */ 4221296177Sjhibbits if(p_FmPcdKgScheme->direct) 4222296177Sjhibbits { 4223296177Sjhibbits physicalSchemeId = (uint8_t)(PTR_TO_UINT(p_FmPcdKgScheme->h_DirectScheme)-1); 4224296177Sjhibbits /* check that this scheme is bound to this port */ 4225296177Sjhibbits if(!(p_FmPort->schemesPerPortVector & (uint32_t)(1 << (31 - (uint32_t)physicalSchemeId)))) 4226296177Sjhibbits { 4227296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4228296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("called with a scheme that is not bound to this port")); 4229296177Sjhibbits } 4230296177Sjhibbits 4231296177Sjhibbits relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmPort->h_FmPcd, physicalSchemeId); 4232296177Sjhibbits if(relativeSchemeId >= FM_PCD_KG_NUM_OF_SCHEMES) 4233296177Sjhibbits { 4234296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4235296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, ("called with invalid Scheme ")); 4236296177Sjhibbits } 4237296177Sjhibbits 4238296177Sjhibbits if(!FmPcdKgIsSchemeValidSw(p_FmPort->h_FmPcd, relativeSchemeId)) 4239296177Sjhibbits { 4240296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4241296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("called with uninitialized Scheme ")); 4242296177Sjhibbits } 4243296177Sjhibbits 4244296177Sjhibbits WRITE_UINT32(*p_BmiHpnia, NIA_ENG_KG | tmpReg | NIA_KG_DIRECT | (uint32_t)physicalSchemeId); 4245296177Sjhibbits } 4246296177Sjhibbits else /* change to indirect scheme */ 4247296177Sjhibbits WRITE_UINT32(*p_BmiHpnia, NIA_ENG_KG | tmpReg); 4248296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4249296177Sjhibbits 4250296177Sjhibbits return E_OK; 4251296177Sjhibbits} 4252296177Sjhibbits 4253296177Sjhibbitst_Error FM_PORT_PcdPlcrModifyInitialProfile (t_Handle h_FmPort, t_Handle h_Profile) 4254296177Sjhibbits{ 4255296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4256296177Sjhibbits volatile uint32_t *p_BmiNia; 4257296177Sjhibbits volatile uint32_t *p_BmiHpnia; 4258296177Sjhibbits uint32_t tmpReg; 4259296177Sjhibbits uint16_t absoluteProfileId = (uint16_t)(PTR_TO_UINT(h_Profile)-1); 4260296177Sjhibbits 4261296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4262296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4263296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_PLCR , E_INVALID_STATE); 4264296177Sjhibbits 4265296177Sjhibbits /* check relevancy of this routine - only when policer is used 4266296177Sjhibbits directly after BMI or Parser */ 4267296177Sjhibbits if((p_FmPort->pcdEngines & FM_PCD_KG) || (p_FmPort->pcdEngines & FM_PCD_CC)) 4268296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("relevant only when PCD support mode is e_FM_PCD_SUPPORT_PLCR_ONLY or e_FM_PCD_SUPPORT_PRS_AND_PLCR")); 4269296177Sjhibbits 4270296177Sjhibbits switch(p_FmPort->portType) 4271296177Sjhibbits { 4272296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4273296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4274296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 4275296177Sjhibbits p_BmiHpnia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne; 4276296177Sjhibbits tmpReg = GET_UINT32(*p_BmiNia) & BMI_RFNE_FDCS_MASK; 4277296177Sjhibbits break; 4278296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4279296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 4280296177Sjhibbits p_BmiHpnia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofpne; 4281296177Sjhibbits tmpReg = 0; 4282296177Sjhibbits break; 4283296177Sjhibbits default: 4284296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 4285296177Sjhibbits } 4286296177Sjhibbits 4287296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4288296177Sjhibbits return ERROR_CODE(E_BUSY); 4289296177Sjhibbits if(!FmPcdPlcrIsProfileValid(p_FmPort->h_FmPcd, absoluteProfileId)) 4290296177Sjhibbits { 4291296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4292296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("Invalid profile")); 4293296177Sjhibbits } 4294296177Sjhibbits 4295296177Sjhibbits tmpReg = (uint32_t)(NIA_ENG_PLCR | NIA_PLCR_ABSOLUTE | absoluteProfileId); 4296296177Sjhibbits 4297296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_PRS) /* e_FM_PCD_SUPPORT_PRS_AND_PLCR */ 4298296177Sjhibbits { 4299296177Sjhibbits /* update BMI HPNIA */ 4300296177Sjhibbits WRITE_UINT32(*p_BmiHpnia, tmpReg); 4301296177Sjhibbits } 4302296177Sjhibbits else /* e_FM_PCD_SUPPORT_PLCR_ONLY */ 4303296177Sjhibbits { 4304296177Sjhibbits /* rfne may contain FDCS bits, so first we read them. */ 4305296177Sjhibbits tmpReg |= (GET_UINT32(*p_BmiNia) & BMI_RFNE_FDCS_MASK); 4306296177Sjhibbits /* update BMI NIA */ 4307296177Sjhibbits WRITE_UINT32(*p_BmiNia, tmpReg); 4308296177Sjhibbits } 4309296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4310296177Sjhibbits 4311296177Sjhibbits return E_OK; 4312296177Sjhibbits} 4313296177Sjhibbits 4314296177Sjhibbits 4315296177Sjhibbitst_Error FM_PORT_PcdCcModifyTree (t_Handle h_FmPort, t_Handle h_CcTree) 4316296177Sjhibbits{ 4317296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4318296177Sjhibbits t_Error err = E_OK; 4319296177Sjhibbits volatile uint32_t *p_BmiCcBase=NULL; 4320296177Sjhibbits volatile uint32_t *p_BmiNia=NULL; 4321296177Sjhibbits uint32_t ccTreePhysOffset; 4322296177Sjhibbits 4323296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_VALUE); 4324296177Sjhibbits 4325296177Sjhibbits if (p_FmPort->imEn) 4326296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 4327296177Sjhibbits 4328296177Sjhibbits /* get PCD registers pointers */ 4329296177Sjhibbits switch(p_FmPort->portType) 4330296177Sjhibbits { 4331296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4332296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4333296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 4334296177Sjhibbits break; 4335296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4336296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 4337296177Sjhibbits break; 4338296177Sjhibbits default: 4339296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 4340296177Sjhibbits } 4341296177Sjhibbits 4342296177Sjhibbits /* check that current NIA is BMI to BMI */ 4343296177Sjhibbits if((GET_UINT32(*p_BmiNia) & ~BMI_RFNE_FDCS_MASK) != (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) 4344296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("may be called only for ports in BMI-to-BMI state.")); 4345296177Sjhibbits 4346296177Sjhibbits/*TODO - to take care of changes due to previous tree. Maybe in the previous tree where chnged pndn, pnen ... 4347296177Sjhibbits it has to be returned to the default state - initially*/ 4348296177Sjhibbits 4349296177Sjhibbits p_FmPort->requiredAction = 0; 4350296177Sjhibbits 4351296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_CC) 4352296177Sjhibbits { 4353296177Sjhibbits switch(p_FmPort->portType) 4354296177Sjhibbits { 4355296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4356296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4357296177Sjhibbits p_BmiCcBase = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rccb; 4358296177Sjhibbits break; 4359296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4360296177Sjhibbits p_BmiCcBase = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_occb; 4361296177Sjhibbits break; 4362296177Sjhibbits default: 4363296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid port type")); 4364296177Sjhibbits } 4365296177Sjhibbits 4366296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4367296177Sjhibbits return ERROR_CODE(E_BUSY); 4368296177Sjhibbits err = FmPcdCcBindTree(p_FmPort->h_FmPcd, h_CcTree, &ccTreePhysOffset, h_FmPort); 4369296177Sjhibbits if(err) 4370296177Sjhibbits { 4371296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4372296177Sjhibbits RETURN_ERROR(MINOR, err, NO_MSG); 4373296177Sjhibbits } 4374296177Sjhibbits WRITE_UINT32(*p_BmiCcBase, ccTreePhysOffset); 4375296177Sjhibbits 4376296177Sjhibbits p_FmPort->ccTreeId = h_CcTree; 4377296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4378296177Sjhibbits } 4379296177Sjhibbits else 4380296177Sjhibbits RETURN_ERROR(MINOR, E_INVALID_STATE, ("Coarse CLassification not defined for this port.")); 4381296177Sjhibbits 4382296177Sjhibbits return E_OK; 4383296177Sjhibbits} 4384296177Sjhibbits 4385296177Sjhibbitst_Error FM_PORT_AttachPCD(t_Handle h_FmPort) 4386296177Sjhibbits{ 4387296177Sjhibbits 4388296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4389296177Sjhibbits t_Error err = E_OK; 4390296177Sjhibbits 4391296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 4392296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4393296177Sjhibbits 4394296177Sjhibbits if (p_FmPort->imEn) 4395296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 4396296177Sjhibbits 4397296177Sjhibbits /* TODO - may add here checks for: 4398296177Sjhibbits SP (or in sw: schemes) 4399296177Sjhibbits CPP (or in sw clsPlan) 4400296177Sjhibbits Parser enabled and configured(?) 4401296177Sjhibbits Tree(?) 4402296177Sjhibbits Profile - only if direct. 4403296177Sjhibbits Scheme - only if direct 4404296177Sjhibbits */ 4405296177Sjhibbits 4406296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4407296177Sjhibbits return ERROR_CODE(E_BUSY); 4408296177Sjhibbits err = FmPortAttachPCD(h_FmPort); 4409296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4410296177Sjhibbits 4411296177Sjhibbits return err; 4412296177Sjhibbits} 4413296177Sjhibbits 4414296177Sjhibbitst_Error FM_PORT_DetachPCD(t_Handle h_FmPort) 4415296177Sjhibbits{ 4416296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4417296177Sjhibbits volatile uint32_t *p_BmiNia=NULL; 4418296177Sjhibbits 4419296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 4420296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4421296177Sjhibbits 4422296177Sjhibbits if (p_FmPort->imEn) 4423296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 4424296177Sjhibbits 4425296177Sjhibbits /* get PCD registers pointers */ 4426296177Sjhibbits switch(p_FmPort->portType) 4427296177Sjhibbits { 4428296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4429296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4430296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 4431296177Sjhibbits break; 4432296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4433296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 4434296177Sjhibbits break; 4435296177Sjhibbits default: 4436296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 4437296177Sjhibbits } 4438296177Sjhibbits 4439296177Sjhibbits WRITE_UINT32(*p_BmiNia, (p_FmPort->savedBmiNia & BMI_RFNE_FDCS_MASK) | (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)); 4440296177Sjhibbits 4441296177Sjhibbits/*TODO - not atomic - it seems that port has to be disabled*/ 4442296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_NIA_PNEN) 4443296177Sjhibbits { 4444296177Sjhibbits switch(p_FmPort->portType) 4445296177Sjhibbits { 4446296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 4447296177Sjhibbits case(e_FM_PORT_TYPE_TX): 4448296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, NIA_ENG_BMI | NIA_BMI_AC_TX_RELEASE); 4449296177Sjhibbits break; 4450296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 4451296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4452296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4453296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4454296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen, NIA_ENG_BMI | NIA_BMI_AC_RELEASE); 4455296177Sjhibbits break; 4456296177Sjhibbits default: 4457296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Can not reach this stage")); 4458296177Sjhibbits } 4459296177Sjhibbits } 4460296177Sjhibbits 4461296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_NIA_PNDN) 4462296177Sjhibbits { 4463296177Sjhibbits switch(p_FmPort->portType) 4464296177Sjhibbits { 4465296177Sjhibbits case(e_FM_PORT_TYPE_TX_10G): 4466296177Sjhibbits case(e_FM_PORT_TYPE_TX): 4467296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn, NIA_ENG_BMI | NIA_BMI_AC_TX); 4468296177Sjhibbits break; 4469296177Sjhibbits case(e_FM_PORT_TYPE_OH_HOST_COMMAND): 4470296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4471296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn, NIA_ENG_BMI | NIA_BMI_AC_FETCH); 4472296177Sjhibbits break; 4473296177Sjhibbits default: 4474296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Can not reach this stage")); 4475296177Sjhibbits } 4476296177Sjhibbits } 4477296177Sjhibbits 4478296177Sjhibbits 4479296177Sjhibbits if(p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY) 4480296177Sjhibbits if(FmSetNumOfRiscsPerPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId, 2)!= E_OK) 4481296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 4482296177Sjhibbits return E_OK; 4483296177Sjhibbits} 4484296177Sjhibbits 4485296177Sjhibbitst_Error FM_PORT_SetPCD(t_Handle h_FmPort, t_FmPortPcdParams *p_PcdParams) 4486296177Sjhibbits{ 4487296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4488296177Sjhibbits t_FmPcdKgInterModuleBindPortToSchemes schemeBind; 4489296177Sjhibbits t_Error err = E_OK; 4490296177Sjhibbits uint8_t i; 4491296177Sjhibbits 4492296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 4493296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4494296177Sjhibbits 4495296177Sjhibbits if (p_FmPort->imEn) 4496296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independent mode ports only")); 4497296177Sjhibbits 4498296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4499296177Sjhibbits return ERROR_CODE(E_BUSY); 4500296177Sjhibbits p_FmPort->h_FmPcd = FmGetPcdHandle(p_FmPort->h_Fm); 4501296177Sjhibbits ASSERT_COND(p_FmPort->h_FmPcd); 4502296177Sjhibbits 4503296177Sjhibbits err = SetPcd( h_FmPort, p_PcdParams); 4504296177Sjhibbits if(err) 4505296177Sjhibbits { 4506296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4507296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4508296177Sjhibbits } 4509296177Sjhibbits 4510296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_KG) 4511296177Sjhibbits { 4512296177Sjhibbits schemeBind.netEnvId = p_FmPort->netEnvId; 4513296177Sjhibbits schemeBind.hardwarePortId = p_FmPort->hardwarePortId; 4514296177Sjhibbits schemeBind.numOfSchemes = p_PcdParams->p_KgParams->numOfSchemes; 4515296177Sjhibbits schemeBind.useClsPlan = p_FmPort->useClsPlan; 4516296177Sjhibbits for(i = 0;i<schemeBind.numOfSchemes;i++) 4517296177Sjhibbits schemeBind.schemesIds[i] = (uint8_t)(PTR_TO_UINT(p_PcdParams->p_KgParams->h_Schemes[i])-1); 4518296177Sjhibbits 4519296177Sjhibbits err = FmPcdKgBindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind); 4520296177Sjhibbits if(err) 4521296177Sjhibbits { 4522296177Sjhibbits DeletePcd(p_FmPort); 4523296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4524296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4525296177Sjhibbits } 4526296177Sjhibbits } 4527296177Sjhibbits 4528296177Sjhibbits if ((p_FmPort->pcdEngines & FM_PCD_PRS) && (p_PcdParams->p_PrsParams->includeInPrsStatistics)) 4529296177Sjhibbits FmPcdPrsIncludePortInStatistics(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId, TRUE); 4530296177Sjhibbits 4531296177Sjhibbits FmPcdIncNetEnvOwners(p_FmPort->h_FmPcd, p_FmPort->netEnvId); 4532296177Sjhibbits 4533296177Sjhibbits err = FmPortAttachPCD(h_FmPort); 4534296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4535296177Sjhibbits 4536296177Sjhibbits return err; 4537296177Sjhibbits} 4538296177Sjhibbits 4539296177Sjhibbitst_Error FM_PORT_DeletePCD(t_Handle h_FmPort) 4540296177Sjhibbits{ 4541296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4542296177Sjhibbits t_FmPcdKgInterModuleBindPortToSchemes schemeBind; 4543296177Sjhibbits t_Error err = E_OK; 4544296177Sjhibbits 4545296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 4546296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4547296177Sjhibbits 4548296177Sjhibbits if (p_FmPort->imEn) 4549296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for non-independant mode ports only")); 4550296177Sjhibbits 4551296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4552296177Sjhibbits return ERROR_CODE(E_BUSY); 4553296177Sjhibbits 4554296177Sjhibbits err = FM_PORT_DetachPCD(h_FmPort); 4555296177Sjhibbits if(err) 4556296177Sjhibbits { 4557296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4558296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4559296177Sjhibbits } 4560296177Sjhibbits 4561296177Sjhibbits FmPcdDecNetEnvOwners(p_FmPort->h_FmPcd, p_FmPort->netEnvId); 4562296177Sjhibbits 4563296177Sjhibbits /* we do it anyway, instead of checking if included */ 4564296177Sjhibbits if (FmIsMaster(p_FmPort->h_Fm) && 4565296177Sjhibbits (p_FmPort->pcdEngines & FM_PCD_PRS)) 4566296177Sjhibbits FmPcdPrsIncludePortInStatistics(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId, FALSE); 4567296177Sjhibbits 4568296177Sjhibbits if(p_FmPort->pcdEngines & FM_PCD_KG) 4569296177Sjhibbits { 4570296177Sjhibbits /* unbind all schemes */ 4571296177Sjhibbits p_FmPort->schemesPerPortVector = GetPortSchemeBindParams(p_FmPort, &schemeBind); 4572296177Sjhibbits 4573296177Sjhibbits err = FmPcdKgUnbindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind); 4574296177Sjhibbits if(err) 4575296177Sjhibbits { 4576296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4577296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4578296177Sjhibbits } 4579296177Sjhibbits } 4580296177Sjhibbits 4581296177Sjhibbits err = DeletePcd(h_FmPort); 4582296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4583296177Sjhibbits 4584296177Sjhibbits return err; 4585296177Sjhibbits} 4586296177Sjhibbits 4587296177Sjhibbitst_Error FM_PORT_PcdKgBindSchemes (t_Handle h_FmPort, t_FmPcdPortSchemesParams *p_PortScheme) 4588296177Sjhibbits{ 4589296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4590296177Sjhibbits t_FmPcdKgInterModuleBindPortToSchemes schemeBind; 4591296177Sjhibbits t_Error err = E_OK; 4592296177Sjhibbits uint32_t tmpScmVec=0; 4593296177Sjhibbits int i; 4594296177Sjhibbits 4595296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4596296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4597296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG , E_INVALID_STATE); 4598296177Sjhibbits 4599296177Sjhibbits schemeBind.netEnvId = p_FmPort->netEnvId; 4600296177Sjhibbits schemeBind.hardwarePortId = p_FmPort->hardwarePortId; 4601296177Sjhibbits schemeBind.numOfSchemes = p_PortScheme->numOfSchemes; 4602296177Sjhibbits schemeBind.useClsPlan = p_FmPort->useClsPlan; 4603296177Sjhibbits for (i=0; i<schemeBind.numOfSchemes; i++) 4604296177Sjhibbits { 4605296177Sjhibbits schemeBind.schemesIds[i] = (uint8_t)(PTR_TO_UINT(p_PortScheme->h_Schemes[i])-1); 4606296177Sjhibbits /* build vector */ 4607296177Sjhibbits tmpScmVec |= 1 << (31 - (uint32_t)schemeBind.schemesIds[i]); 4608296177Sjhibbits } 4609296177Sjhibbits 4610296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4611296177Sjhibbits return ERROR_CODE(E_BUSY); 4612296177Sjhibbits err = FmPcdKgBindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind); 4613296177Sjhibbits if (err == E_OK) 4614296177Sjhibbits p_FmPort->schemesPerPortVector |= tmpScmVec; 4615296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4616296177Sjhibbits 4617296177Sjhibbits return err; 4618296177Sjhibbits} 4619296177Sjhibbits 4620296177Sjhibbitst_Error FM_PORT_PcdKgUnbindSchemes (t_Handle h_FmPort, t_FmPcdPortSchemesParams *p_PortScheme) 4621296177Sjhibbits{ 4622296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4623296177Sjhibbits t_FmPcdKgInterModuleBindPortToSchemes schemeBind; 4624296177Sjhibbits t_Error err = E_OK; 4625296177Sjhibbits uint32_t tmpScmVec=0; 4626296177Sjhibbits int i; 4627296177Sjhibbits 4628296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4629296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4630296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG , E_INVALID_STATE); 4631296177Sjhibbits 4632296177Sjhibbits schemeBind.netEnvId = p_FmPort->netEnvId; 4633296177Sjhibbits schemeBind.hardwarePortId = p_FmPort->hardwarePortId; 4634296177Sjhibbits schemeBind.numOfSchemes = p_PortScheme->numOfSchemes; 4635296177Sjhibbits for (i=0; i<schemeBind.numOfSchemes; i++) 4636296177Sjhibbits { 4637296177Sjhibbits schemeBind.schemesIds[i] = (uint8_t)(PTR_TO_UINT(p_PortScheme->h_Schemes[i])-1); 4638296177Sjhibbits /* build vector */ 4639296177Sjhibbits tmpScmVec |= 1 << (31 - (uint32_t)schemeBind.schemesIds[i]); 4640296177Sjhibbits } 4641296177Sjhibbits 4642296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4643296177Sjhibbits return ERROR_CODE(E_BUSY); 4644296177Sjhibbits err = FmPcdKgUnbindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind); 4645296177Sjhibbits if (err == E_OK) 4646296177Sjhibbits p_FmPort->schemesPerPortVector &= ~tmpScmVec; 4647296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4648296177Sjhibbits 4649296177Sjhibbits return err; 4650296177Sjhibbits} 4651296177Sjhibbits 4652296177Sjhibbitst_Error FM_PORT_PcdPrsModifyStartOffset (t_Handle h_FmPort, t_FmPcdPrsStart *p_FmPcdPrsStart) 4653296177Sjhibbits{ 4654296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4655296177Sjhibbits volatile uint32_t *p_BmiPrsStartOffset = NULL; 4656296177Sjhibbits volatile uint32_t *p_BmiNia = NULL; 4657296177Sjhibbits uint32_t tmpReg; 4658296177Sjhibbits uint8_t hdrNum; 4659296177Sjhibbits 4660296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4661296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4662296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_PRS , E_INVALID_STATE); 4663296177Sjhibbits 4664296177Sjhibbits switch(p_FmPort->portType) 4665296177Sjhibbits { 4666296177Sjhibbits case(e_FM_PORT_TYPE_RX_10G): 4667296177Sjhibbits case(e_FM_PORT_TYPE_RX): 4668296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpso; 4669296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne; 4670296177Sjhibbits tmpReg = GET_UINT32(*p_BmiNia) & BMI_RFNE_FDCS_MASK; 4671296177Sjhibbits break; 4672296177Sjhibbits case(e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4673296177Sjhibbits p_BmiPrsStartOffset = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opso; 4674296177Sjhibbits p_BmiNia = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofne; 4675296177Sjhibbits tmpReg = 0; 4676296177Sjhibbits break; 4677296177Sjhibbits default: 4678296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("available for Rx and offline parsing ports only")); 4679296177Sjhibbits } 4680296177Sjhibbits 4681296177Sjhibbits /* check that current NIA is BMI to BMI */ 4682296177Sjhibbits if((GET_UINT32(*p_BmiNia) & ~BMI_RFNE_FDCS_MASK) != (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) 4683296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_OPERATION, ("may be called only for ports in BMI-to-BMI state.")); 4684296177Sjhibbits 4685296177Sjhibbits if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock)) 4686296177Sjhibbits return ERROR_CODE(E_BUSY); 4687296177Sjhibbits /* set the first header */ 4688296177Sjhibbits GET_PRS_HDR_NUM(hdrNum, p_FmPcdPrsStart->firstPrsHdr); 4689296177Sjhibbits if ((hdrNum == ILLEGAL_HDR_NUM) || (hdrNum == NO_HDR_NUM)) 4690296177Sjhibbits { 4691296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4692296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Unsupported header.")); 4693296177Sjhibbits } 4694296177Sjhibbits WRITE_UINT32(*p_BmiNia, (uint32_t)(NIA_ENG_PRS | (uint32_t)hdrNum | tmpReg)); 4695296177Sjhibbits 4696296177Sjhibbits /* set start parsing offset */ 4697296177Sjhibbits WRITE_UINT32(*p_BmiPrsStartOffset, (uint32_t)(p_FmPcdPrsStart->parsingOffset + p_FmPort->internalBufferOffset)); 4698296177Sjhibbits RELEASE_LOCK(p_FmPort->lock); 4699296177Sjhibbits 4700296177Sjhibbits return E_OK; 4701296177Sjhibbits} 4702296177Sjhibbits 4703296177Sjhibbits#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) 4704296177Sjhibbitst_Error FM_PORT_DumpRegs(t_Handle h_FmPort) 4705296177Sjhibbits{ 4706296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4707296177Sjhibbits t_Error err = E_OK; 4708296177Sjhibbits char arr[30]; 4709296177Sjhibbits uint8_t flag; 4710296177Sjhibbits int i=0; 4711296177Sjhibbits 4712296177Sjhibbits DECLARE_DUMP; 4713296177Sjhibbits 4714296177Sjhibbits SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); 4715296177Sjhibbits SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE); 4716296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortQmiRegs, E_INVALID_HANDLE); 4717296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortBmiRegs, E_INVALID_HANDLE); 4718296177Sjhibbits 4719296177Sjhibbits switch (p_FmPort->portType) 4720296177Sjhibbits { 4721296177Sjhibbits case (e_FM_PORT_TYPE_OH_OFFLINE_PARSING): 4722296177Sjhibbits strcpy(arr, "PORT_TYPE_OFFLINE_PARSING"); 4723296177Sjhibbits flag = 0; 4724296177Sjhibbits break; 4725296177Sjhibbits case (e_FM_PORT_TYPE_OH_HOST_COMMAND): 4726296177Sjhibbits strcpy(arr, "PORT_TYPE_HOST_COMMAND"); 4727296177Sjhibbits flag = 0; 4728296177Sjhibbits break; 4729296177Sjhibbits case (e_FM_PORT_TYPE_RX): 4730296177Sjhibbits strcpy(arr, "PORT_TYPE_RX"); 4731296177Sjhibbits flag = 1; 4732296177Sjhibbits break; 4733296177Sjhibbits case (e_FM_PORT_TYPE_RX_10G): 4734296177Sjhibbits strcpy(arr, "PORT_TYPE_RX_10G"); 4735296177Sjhibbits flag = 1; 4736296177Sjhibbits break; 4737296177Sjhibbits case (e_FM_PORT_TYPE_TX): 4738296177Sjhibbits strcpy(arr, "PORT_TYPE_TX"); 4739296177Sjhibbits flag = 2; 4740296177Sjhibbits break; 4741296177Sjhibbits case (e_FM_PORT_TYPE_TX_10G): 4742296177Sjhibbits strcpy(arr, "PORT_TYPE_TX_10G"); 4743296177Sjhibbits flag = 2; 4744296177Sjhibbits break; 4745296177Sjhibbits default: 4746296177Sjhibbits return ERROR_CODE(E_INVALID_VALUE); 4747296177Sjhibbits } 4748296177Sjhibbits 4749296177Sjhibbits DUMP_TITLE(UINT_TO_PTR(p_FmPort->hardwarePortId), ("PortId for %s %d", arr, p_FmPort->portId )); 4750296177Sjhibbits DUMP_TITLE(p_FmPort->p_FmPortBmiRegs, ("Bmi Port Regs")); 4751296177Sjhibbits 4752296177Sjhibbits err = FmDumpPortRegs(p_FmPort->h_Fm, p_FmPort->hardwarePortId); 4753296177Sjhibbits if(err) 4754296177Sjhibbits RETURN_ERROR(MAJOR, err, NO_MSG); 4755296177Sjhibbits 4756296177Sjhibbits switch(flag) 4757296177Sjhibbits { 4758296177Sjhibbits case(0): 4759296177Sjhibbits 4760296177Sjhibbits DUMP_SUBTITLE(("\n")); 4761296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ocfg); 4762296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ost); 4763296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oda); 4764296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofdne); 4765296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofne); 4766296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofca); 4767296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofpne); 4768296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opso); 4769296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opp); 4770296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_occb); 4771296177Sjhibbits 4772296177Sjhibbits DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oprai), ("fmbm_oprai")); 4773296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_PRS_RESULT_NUM_OF_WORDS) 4774296177Sjhibbits { 4775296177Sjhibbits DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oprai[i]), sizeof(uint32_t)); 4776296177Sjhibbits } 4777296177Sjhibbits DUMP_SUBTITLE(("\n")); 4778296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofqid ); 4779296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oefqid); 4780296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofsdm ); 4781296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofsem ); 4782296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofene ); 4783296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_orlmts); 4784296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_orlmt); 4785296177Sjhibbits 4786296177Sjhibbits { 4787296177Sjhibbits#ifndef FM_NO_OP_OBSERVED_POOLS 4788296177Sjhibbits t_FmRevisionInfo revInfo; 4789296177Sjhibbits 4790296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 4791296177Sjhibbits if (revInfo.majorRev == 4) 4792296177Sjhibbits#endif /* !FM_NO_OP_OBSERVED_POOLS */ 4793296177Sjhibbits { 4794296177Sjhibbits DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oebmpi, ("fmbm_oebmpi")); 4795296177Sjhibbits 4796296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_OBSERVED_EXT_POOLS) 4797296177Sjhibbits { 4798296177Sjhibbits DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oebmpi[i], sizeof(uint32_t)); 4799296177Sjhibbits } 4800296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ocgm); 4801296177Sjhibbits } 4802296177Sjhibbits } 4803296177Sjhibbits 4804296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ostc); 4805296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofrc ); 4806296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofdc ); 4807296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofledc); 4808296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofufdc); 4809296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_offc); 4810296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofwdc); 4811296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofldec); 4812296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opc); 4813296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opcp); 4814296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_occn); 4815296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_otuc); 4816296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oduc); 4817296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofuc); 4818296177Sjhibbits break; 4819296177Sjhibbits case(1): 4820296177Sjhibbits DUMP_SUBTITLE(("\n")); 4821296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rcfg); 4822296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rst); 4823296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rda); 4824296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfp); 4825296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_reth); 4826296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfed); 4827296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_ricp); 4828296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rebm); 4829296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfne); 4830296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfca); 4831296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfpne); 4832296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpso); 4833296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpp); 4834296177Sjhibbits 4835296177Sjhibbits DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rprai), ("fmbm_rprai")); 4836296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_PRS_RESULT_NUM_OF_WORDS) 4837296177Sjhibbits { 4838296177Sjhibbits DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rprai[i]), sizeof(uint32_t)); 4839296177Sjhibbits } 4840296177Sjhibbits DUMP_SUBTITLE(("\n")); 4841296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfqid); 4842296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_refqid); 4843296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfsdm); 4844296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfsem); 4845296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfene); 4846296177Sjhibbits DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi, ("fmbm_ebmpi")); 4847296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_EXT_POOLS) 4848296177Sjhibbits { 4849296177Sjhibbits DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i], sizeof(uint32_t)); 4850296177Sjhibbits } 4851296177Sjhibbits DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt, ("fmbm_acnt")); 4852296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_EXT_POOLS) 4853296177Sjhibbits { 4854296177Sjhibbits DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt[i], sizeof(uint32_t)); 4855296177Sjhibbits } 4856296177Sjhibbits DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm, ("fmbm_cgm")); 4857296177Sjhibbits DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_NUM_OF_CONGESTION_GRPS/32) 4858296177Sjhibbits { 4859296177Sjhibbits DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm[i], sizeof(uint32_t)); 4860296177Sjhibbits } 4861296177Sjhibbits DUMP_SUBTITLE(("\n")); 4862296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_mpd); 4863296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rstc); 4864296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfrc); 4865296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfbc); 4866296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rlfc); 4867296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rffc); 4868296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfcd); 4869296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfldec); 4870296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rodc); 4871296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpc); 4872296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpcp); 4873296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rccn); 4874296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rtuc); 4875296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rrquc); 4876296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rduc); 4877296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfuc); 4878296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpac); 4879296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rdbg); 4880296177Sjhibbits break; 4881296177Sjhibbits case(2): 4882296177Sjhibbits 4883296177Sjhibbits DUMP_SUBTITLE(("\n")); 4884296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tcfg); 4885296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tst); 4886296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tda); 4887296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfp); 4888296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfed); 4889296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ticp); 4890296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfne); 4891296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfca); 4892296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tcfqid); 4893296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfeqid); 4894296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfene); 4895296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_trlmts); 4896296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_trlmt); 4897296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tstc); 4898296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfrc); 4899296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfdc); 4900296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfledc); 4901296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfufdc); 4902296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tpc); 4903296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tpcp); 4904296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tccn); 4905296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ttuc); 4906296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ttcquc); 4907296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tduc); 4908296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfuc); 4909296177Sjhibbits break; 4910296177Sjhibbits 4911296177Sjhibbits default: 4912296177Sjhibbits RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid flag")); 4913296177Sjhibbits } 4914296177Sjhibbits 4915296177Sjhibbits DUMP_TITLE(p_FmPort->p_FmPortQmiRegs, ("Qmi Port Regs")); 4916296177Sjhibbits 4917296177Sjhibbits DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnc); 4918296177Sjhibbits DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pns); 4919296177Sjhibbits DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnts); 4920296177Sjhibbits DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnen); 4921296177Sjhibbits DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnetfc); 4922296177Sjhibbits 4923296177Sjhibbits if(flag !=1) 4924296177Sjhibbits { 4925296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndn); 4926296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndc); 4927296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndtfc); 4928296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndfdc); 4929296177Sjhibbits DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndcc); 4930296177Sjhibbits } 4931296177Sjhibbits 4932296177Sjhibbits return E_OK; 4933296177Sjhibbits} 4934296177Sjhibbits#endif /* (defined(DEBUG_ERRORS) && ... */ 4935296177Sjhibbits 4936296177Sjhibbitst_Error FM_PORT_AddCongestionGrps(t_Handle h_FmPort, t_FmPortCongestionGrps *p_CongestionGrps) 4937296177Sjhibbits{ 4938296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 4939296177Sjhibbits bool tmpArray[FM_PORT_NUM_OF_CONGESTION_GRPS], opPort; 4940296177Sjhibbits int i; 4941296177Sjhibbits uint8_t mod; 4942296177Sjhibbits uint32_t tmpReg = 0; 4943296177Sjhibbits 4944296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 4945296177Sjhibbits 4946296177Sjhibbits { 4947296177Sjhibbits#ifdef FM_NO_OP_OBSERVED_CGS 4948296177Sjhibbits t_FmRevisionInfo revInfo; 4949296177Sjhibbits 4950296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 4951296177Sjhibbits if (revInfo.majorRev != 4) 4952296177Sjhibbits { 4953296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 4954296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 4955296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Available for Rx ports only")); 4956296177Sjhibbits } 4957296177Sjhibbits else 4958296177Sjhibbits#endif /* FM_NO_OP_OBSERVED_CGS */ 4959296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 4960296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX) && 4961296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 4962296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Available for Rx & OP ports only")); 4963296177Sjhibbits } 4964296177Sjhibbits 4965296177Sjhibbits opPort = (bool)((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) ? TRUE:FALSE); 4966296177Sjhibbits 4967296177Sjhibbits /* to minimize memory access (groups may belong to the same regsiter, and may 4968296177Sjhibbits be out of order), we first collect all information into a 256 booleans array, 4969296177Sjhibbits representing each possible group. */ 4970296177Sjhibbits 4971296177Sjhibbits memset(&tmpArray, 0, FM_PORT_NUM_OF_CONGESTION_GRPS*sizeof(bool)); 4972296177Sjhibbits for(i=0;i<p_CongestionGrps->numOfCongestionGrpsToConsider;i++) 4973296177Sjhibbits tmpArray[p_CongestionGrps->congestionGrpsToConsider[i]] = TRUE; 4974296177Sjhibbits 4975296177Sjhibbits for(i=0;i<FM_PORT_NUM_OF_CONGESTION_GRPS;i++) 4976296177Sjhibbits { 4977296177Sjhibbits mod = (uint8_t)(i%32); 4978296177Sjhibbits /* each 32 congestion groups are represented by a register */ 4979296177Sjhibbits if (mod == 0) /* first in a 32 bunch of congestion groups, get the currest register state */ 4980296177Sjhibbits tmpReg = opPort ? GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocgm): 4981296177Sjhibbits GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm[7-i/32]); 4982296177Sjhibbits 4983296177Sjhibbits /* set in the register, the bit representing the relevant congestion group. */ 4984296177Sjhibbits if(tmpArray[i]) 4985296177Sjhibbits tmpReg |= (0x00000001 << (uint32_t)mod); 4986296177Sjhibbits 4987296177Sjhibbits if (mod == 31) /* last in a 32 bunch of congestion groups - write the corresponding register */ 4988296177Sjhibbits { 4989296177Sjhibbits if(opPort) 4990296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocgm, tmpReg); 4991296177Sjhibbits else 4992296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm[7-i/32], tmpReg); 4993296177Sjhibbits } 4994296177Sjhibbits } 4995296177Sjhibbits 4996296177Sjhibbits return E_OK; 4997296177Sjhibbits} 4998296177Sjhibbits 4999296177Sjhibbitst_Error FM_PORT_RemoveCongestionGrps(t_Handle h_FmPort, t_FmPortCongestionGrps *p_CongestionGrps) 5000296177Sjhibbits{ 5001296177Sjhibbits t_FmPort *p_FmPort = (t_FmPort*)h_FmPort; 5002296177Sjhibbits bool tmpArray[FM_PORT_NUM_OF_CONGESTION_GRPS], opPort; 5003296177Sjhibbits int i; 5004296177Sjhibbits uint8_t mod; 5005296177Sjhibbits uint32_t tmpReg = 0; 5006296177Sjhibbits 5007296177Sjhibbits SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE); 5008296177Sjhibbits 5009296177Sjhibbits { 5010296177Sjhibbits#ifdef FM_NO_OP_OBSERVED_CGS 5011296177Sjhibbits t_FmRevisionInfo revInfo; 5012296177Sjhibbits 5013296177Sjhibbits FM_GetRevision(p_FmPort->h_Fm, &revInfo); 5014296177Sjhibbits if (revInfo.majorRev != 4) 5015296177Sjhibbits { 5016296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 5017296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX)) 5018296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Available for Rx ports only")); 5019296177Sjhibbits } 5020296177Sjhibbits else 5021296177Sjhibbits#endif /* FM_NO_OP_OBSERVED_CGS */ 5022296177Sjhibbits if((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) && 5023296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_RX) && 5024296177Sjhibbits (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)) 5025296177Sjhibbits RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Available for Rx & OP ports only")); 5026296177Sjhibbits } 5027296177Sjhibbits 5028296177Sjhibbits opPort = (bool)((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) ? TRUE:FALSE); 5029296177Sjhibbits 5030296177Sjhibbits /* to minimize memory access (groups may belong to the same regsiter, and may 5031296177Sjhibbits be out of order), we first collect all information into a 256 booleans array, 5032296177Sjhibbits representing each possible group. */ 5033296177Sjhibbits memset(&tmpArray, 0, FM_PORT_NUM_OF_CONGESTION_GRPS*sizeof(bool)); 5034296177Sjhibbits for(i=0;i<p_CongestionGrps->numOfCongestionGrpsToConsider;i++) 5035296177Sjhibbits tmpArray[p_CongestionGrps->congestionGrpsToConsider[i]] = TRUE; 5036296177Sjhibbits 5037296177Sjhibbits for(i=0;i<FM_PORT_NUM_OF_CONGESTION_GRPS;i++) 5038296177Sjhibbits { 5039296177Sjhibbits mod = (uint8_t)(i%32); 5040296177Sjhibbits /* each 32 congestion groups are represented by a register */ 5041296177Sjhibbits if (mod == 0) /* first in a 32 bunch of congestion groups, get the currest register state */ 5042296177Sjhibbits tmpReg = opPort ? GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocgm): 5043296177Sjhibbits GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm[7-i/32]); 5044296177Sjhibbits 5045296177Sjhibbits /* set in the register, the bit representing the relevant congestion group. */ 5046296177Sjhibbits if(tmpArray[i]) 5047296177Sjhibbits tmpReg &= ~(0x00000001 << (uint32_t)mod); 5048296177Sjhibbits 5049296177Sjhibbits if (mod == 31) /* last in a 32 bunch of congestion groups - write the corresponding register */ 5050296177Sjhibbits { 5051296177Sjhibbits if(opPort) 5052296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ocgm, tmpReg); 5053296177Sjhibbits else 5054296177Sjhibbits WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_cgm[7-i/32], tmpReg); 5055296177Sjhibbits } 5056296177Sjhibbits } 5057296177Sjhibbits 5058296177Sjhibbits return E_OK; 5059296177Sjhibbits} 5060296177Sjhibbits 5061