Lines Matching refs:p_FmPort
54 static t_Error FmPortConfigAutoResForDeepSleepSupport1(t_FmPort *p_FmPort);
56 static t_Error CheckInitParameters(t_FmPort *p_FmPort)
58 t_FmPortDriverParam *p_Params = p_FmPort->p_FmPortDriverParam;
63 if (p_FmPort->imEn)
65 if (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
66 if (p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
73 if ((ans = FmPortImCheckInitParameters(p_FmPort)) != E_OK)
81 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
82 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
112 if ((p_FmPort->fmRevInfo.majorRev != 4) && (p_FmPort->fmRevInfo.majorRev < 6))
113 if (p_FmPort->p_FmPortDriverParam->p_BackupBmPools)
138 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX)
139 || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
141 || (p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
145 if ((!p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth)
146 || (p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
158 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
159 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
160 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
166 if (p_FmPort->p_FmPortDriverParam->bufferPrefixContent.manipExtraSpace % 16)
187 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
188 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
225 && (p_FmPort->fifoBufs.extra % BMI_FIFO_UNITS))
238 if (p_FmPort->fmRevInfo.majorRev == 4)
252 if (p_FmPort->fifoBufs.extra)
259 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX)
260 || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G))
284 if (p_FmPort->portType == e_FM_PORT_TYPE_TX)
285 if (p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
306 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
307 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
308 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
310 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
325 if ((p_FmPort->fmRevInfo.majorRev >= 6)
326 && (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
328 && (p_FmPort->openDmas.num < MIN_NUM_OF_OP_DMAS))
338 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
339 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND))
342 if ((p_FmPort->fmRevInfo.majorRev < 6) &&
343 (p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore != DEFAULT_notSupported))
349 if ((!((p_FmPort->fmRevInfo.majorRev == 4) ||
350 (p_FmPort->fmRevInfo.majorRev >= 6))) &&
351 (p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth != DEFAULT_notSupported))
373 && ((!p_FmPort->tasks.num)
374 || (p_FmPort->tasks.num > MAX_NUM_OF_TASKS)))
378 && (p_FmPort->tasks.extra > MAX_NUM_OF_EXTRA_TASKS))
384 && ((!p_FmPort->openDmas.num)
385 || (p_FmPort->openDmas.num > MAX_NUM_OF_DMAS)))
389 && (p_FmPort->openDmas.extra > MAX_NUM_OF_EXTRA_DMAS))
395 && (!p_FmPort->fifoBufs.num
396 || (p_FmPort->fifoBufs.num > MAX_PORT_FIFO_SIZE)))
401 if (p_Params->setSizeOfFifo && (p_FmPort->fifoBufs.num % BMI_FIFO_UNITS))
407 if (p_FmPort->fmRevInfo.majorRev == 4)
408 if (p_FmPort->p_FmPortDriverParam->deqPrefetchOption != DEFAULT_notSupported)
416 static t_Error VerifySizeOfFifo(t_FmPort *p_FmPort)
423 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX)
424 || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G))
427 (uint32_t)(ROUND_UP(p_FmPort->maxFrameLength, BMI_FIFO_UNITS)
429 if (!p_FmPort->imEn)
431 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
439 if (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
449 if (((p_FmPort->portType == e_FM_PORT_TYPE_RX)
450 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
451 && p_FmPort->imEn)
455 (uint32_t)(ROUND_UP(p_FmPort->maxFrameLength, BMI_FIFO_UNITS)
463 if (((p_FmPort->portType == e_FM_PORT_TYPE_RX)
464 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
465 && !p_FmPort->imEn)
467 if (p_FmPort->fmRevInfo.majorRev == 4)
469 if (p_FmPort->rxPoolsParams.numOfPools == 1)
473 (uint32_t)(ROUND_UP(p_FmPort->rxPoolsParams.secondLargestBufSize, BMI_FIFO_UNITS)
480 (uint32_t)(ROUND_UP(p_FmPort->maxFrameLength, BMI_FIFO_UNITS)
485 (ROUND_UP(MIN(p_FmPort->maxFrameLength, p_FmPort->rxPoolsParams.largestBufSize), BMI_FIFO_UNITS)
495 if (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
503 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
504 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND))
509 (uint32_t)(ROUND_UP(p_FmPort->maxFrameLength, BMI_FIFO_UNITS)
510 + ((p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth
514 optFifoSizeForB2B = minFifoSizeRequired = (uint32_t)((p_FmPort->tasks.num + 2) * BMI_FIFO_UNITS);
522 if (p_FmPort->fifoBufs.num < minFifoSizeRequired)
524 ("FIFO size is %d and should be enlarged to %d bytes",p_FmPort->fifoBufs.num, minFifoSizeRequired));
525 else if (p_FmPort->fifoBufs.num < optFifoSizeForB2B)
527 ("For back-to-back frames processing, FIFO size is %d and needs to enlarge to %d bytes", p_FmPort->fifoBufs.num, optFifoSizeForB2B));
532 static void FmPortDriverParamFree(t_FmPort *p_FmPort)
534 if (p_FmPort->p_FmPortDriverParam)
536 XX_Free(p_FmPort->p_FmPortDriverParam);
537 p_FmPort->p_FmPortDriverParam = NULL;
541 static t_Error SetExtBufferPools(t_FmPort *p_FmPort)
543 t_FmExtPools *p_ExtBufPools = &p_FmPort->p_FmPortDriverParam->extBufPools;
545 &p_FmPort->p_FmPortDriverParam->bufPoolDepletion;
553 memcpy(&p_FmPort->extBufPools, p_ExtBufPools, sizeof(t_FmExtPools));
567 if (p_FmPort->p_FmPortDriverParam->p_BackupBmPools)
570 < p_FmPort->p_FmPortDriverParam->p_BackupBmPools->numOfBackupPools;
573 == p_FmPort->p_FmPortDriverParam->p_BackupBmPools->poolIds[j])
581 p_FmPort->rxPoolsParams.numOfPools = p_ExtBufPools->numOfPoolsUsed;
582 p_FmPort->rxPoolsParams.largestBufSize =
584 p_FmPort->rxPoolsParams.secondLargestBufSize =
641 err = fman_port_set_bpools(&p_FmPort->port, &bpools);
645 if (p_FmPort->p_FmPortDriverParam->p_BackupBmPools)
646 XX_Free(p_FmPort->p_FmPortDriverParam->p_BackupBmPools);
651 static t_Error ClearPerfCnts(t_FmPort *p_FmPort)
653 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
654 FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_QUEUE_UTIL, 0);
655 FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL, 0);
656 FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL, 0);
657 FM_PORT_ModifyCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL, 0);
661 static t_Error InitLowLevelDriver(t_FmPort *p_FmPort)
663 t_FmPortDriverParam *p_DriverParams = p_FmPort->p_FmPortDriverParam;
676 switch (p_FmPort->portType)
681 if (!p_FmPort->imEn)
700 (p_FmPort->internalBufferOffset % OFFSET_UNITS) ? (p_FmPort->internalBufferOffset
702 (p_FmPort->internalBufferOffset / OFFSET_UNITS));
703 p_FmPort->internalBufferOffset = (uint8_t)(tmpVal * OFFSET_UNITS);
705 p_FmPort->internalBufferOffset;
723 (uint8_t)p_FmPort->tasks.num;
724 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING ||
725 p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)p_DriverParams->dfltCfg.perf_cnt_params.queue_val = 0;
729 (uint8_t)p_FmPort->openDmas.num;
730 p_DriverParams->dfltCfg.perf_cnt_params.fifo_val = p_FmPort->fifoBufs.num;
733 != fman_port_init(&p_FmPort->port, &p_DriverParams->dfltCfg,
737 if (p_FmPort->imEn && ((err = FmPortImInit(p_FmPort)) != E_OK))
742 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
743 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
746 FmSetPortPreFetchConfiguration(p_FmPort->h_Fm, p_FmPort->portId,
749 FmSetPortPreFetchConfiguration(p_FmPort->h_Fm, p_FmPort->portId,
755 if (((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
756 || (p_FmPort->portType == e_FM_PORT_TYPE_TX)) && (!p_FmPort->imEn))
764 WRITE_UINT32(p_FmPort->port.bmi_regs->tx.fmbm_tcfqid, 0xFFFFFF);
765 WRITE_UINT32(p_FmPort->port.bmi_regs->tx.fmbm_tfene,
773 static bool CheckRxBmiCounter(t_FmPort *p_FmPort, e_FmPortCounters counter)
775 UNUSED(p_FmPort);
800 static bool CheckTxBmiCounter(t_FmPort *p_FmPort, e_FmPortCounters counter)
802 UNUSED(p_FmPort);
822 static bool CheckOhBmiCounter(t_FmPort *p_FmPort, e_FmPortCounters counter)
839 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)
849 t_FmPort *p_FmPort, e_FmPortCounters counter,
856 switch (p_FmPort->portType)
860 p_Reg = &p_FmPort->port.bmi_regs->rx.fmbm_rstc;
861 isValid = CheckRxBmiCounter(p_FmPort, counter);
865 p_Reg = &p_FmPort->port.bmi_regs->tx.fmbm_tstc;
866 isValid = CheckTxBmiCounter(p_FmPort, counter);
870 p_Reg = &p_FmPort->port.bmi_regs->oh.fmbm_ostc;
871 isValid = CheckOhBmiCounter(p_FmPort, counter);
974 static t_Error AdditionalPrsParams(t_FmPort *p_FmPort,
1038 tmpPrsOffset = FmPcdGetSwPrsOffset(p_FmPort->h_FmPcd, p_HdrParams->hdr,
1052 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
1056 p_SchemeBind->netEnvId = p_FmPort->netEnvId;
1057 p_SchemeBind->hardwarePortId = p_FmPort->hardwarePortId;
1058 p_SchemeBind->useClsPlan = p_FmPort->useClsPlan;
1060 tmp = p_FmPort->schemesPerPortVector;
1081 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
1087 ASSERT_COND(p_FmPort);
1088 ASSERT_COND(p_FmPort->h_FmPcd);
1089 ASSERT_COND(!p_FmPort->p_FmPortDriverParam);
1091 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
1092 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
1095 p_BmiCfgReg = &p_FmPort->port.bmi_regs->rx.fmbm_rcfg;
1097 if ((lcv = FmPcdGetMacsecLcv(p_FmPort->h_FmPcd, p_FmPort->netEnvId))
1111 static t_Error SetPcd(t_FmPort *p_FmPort, t_FmPortPcdParams *p_PcdParams)
1130 ASSERT_COND(p_FmPort);
1131 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
1133 if (p_FmPort->imEn)
1137 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
1138 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
1139 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
1143 p_FmPort->netEnvId = FmPcdGetNetEnvId(p_PcdParams->h_NetEnv);
1145 p_FmPort->pcdEngines = 0;
1147 /* initialize p_FmPort->pcdEngines field in port's structure */
1156 p_FmPort->pcdEngines |= FM_PCD_PRS;
1159 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1162 p_FmPort->pcdEngines |= FM_PCD_PRS;
1163 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1166 p_FmPort->pcdEngines |= FM_PCD_PRS;
1167 p_FmPort->pcdEngines |= FM_PCD_KG;
1170 p_FmPort->pcdEngines |= FM_PCD_PRS;
1171 p_FmPort->pcdEngines |= FM_PCD_CC;
1172 p_FmPort->pcdEngines |= FM_PCD_KG;
1175 p_FmPort->pcdEngines |= FM_PCD_PRS;
1176 p_FmPort->pcdEngines |= FM_PCD_KG;
1177 p_FmPort->pcdEngines |= FM_PCD_CC;
1178 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1181 p_FmPort->pcdEngines |= FM_PCD_PRS;
1182 p_FmPort->pcdEngines |= FM_PCD_CC;
1185 p_FmPort->pcdEngines |= FM_PCD_PRS;
1186 p_FmPort->pcdEngines |= FM_PCD_CC;
1187 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1190 p_FmPort->pcdEngines |= FM_PCD_PRS;
1191 p_FmPort->pcdEngines |= FM_PCD_KG;
1192 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1195 p_FmPort->pcdEngines |= FM_PCD_CC;
1199 p_FmPort->pcdEngines |= FM_PCD_CC;
1200 p_FmPort->pcdEngines |= FM_PCD_KG;
1203 p_FmPort->pcdEngines |= FM_PCD_CC;
1204 p_FmPort->pcdEngines |= FM_PCD_KG;
1205 p_FmPort->pcdEngines |= FM_PCD_PLCR;
1213 if ((p_FmPort->pcdEngines & FM_PCD_PRS)
1222 if ((!!(p_FmPort->pcdEngines & FM_PCD_PRS) != !!p_PcdParams->p_PrsParams)
1223 || (!!(p_FmPort->pcdEngines & FM_PCD_KG)
1225 || (!!(p_FmPort->pcdEngines & FM_PCD_CC)
1233 switch (p_FmPort->portType)
1237 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
1238 p_BmiPrsNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfpne;
1239 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->rx.fmbm_rpso;
1240 p_BmiInitPrsResult = &p_FmPort->port.bmi_regs->rx.fmbm_rprai[0];
1241 p_BmiCcBase = &p_FmPort->port.bmi_regs->rx.fmbm_rccb;
1244 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
1245 p_BmiPrsNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofpne;
1246 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->oh.fmbm_opso;
1247 p_BmiInitPrsResult = &p_FmPort->port.bmi_regs->oh.fmbm_oprai[0];
1248 p_BmiCcBase = &p_FmPort->port.bmi_regs->oh.fmbm_occb;
1255 if (p_FmPort->pcdEngines & FM_PCD_CC)
1257 err = FmPcdCcBindTree(p_FmPort->h_FmPcd, p_PcdParams,
1259 &ccTreePhysOffset, p_FmPort);
1264 p_FmPort->ccTreeId = p_PcdParams->p_CcParams->h_CcTree;
1267 if (p_FmPort->pcdEngines & FM_PCD_KG)
1275 err = FmPcdKgSetOrBindToClsPlanGrp(p_FmPort->h_FmPcd,
1276 p_FmPort->hardwarePortId,
1277 p_FmPort->netEnvId,
1278 p_FmPort->optArray,
1279 &p_FmPort->clsPlanGrpId,
1285 p_FmPort->useClsPlan = !isEmptyClsPlanGrp;
1287 schemeBind.netEnvId = p_FmPort->netEnvId;
1288 schemeBind.hardwarePortId = p_FmPort->hardwarePortId;
1290 schemeBind.useClsPlan = p_FmPort->useClsPlan;
1300 p_FmPort->schemesPerPortVector |= 1
1305 if (!p_FmPort->vspe
1312 err = FmPcdKgBindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind);
1321 p_FmPort->savedBmiNia = GET_UINT32(*p_BmiNia) & BMI_RFNE_FDCS_MASK;
1324 if ((p_FmPort->pcdEngines & FM_PCD_PLCR)
1336 if (!FmPcdPlcrIsProfileValid(p_FmPort->h_FmPcd, absoluteProfileId))
1342 if (p_FmPort->pcdEngines & FM_PCD_PRS) /* e_FM_PCD_SUPPORT_PRS_AND_PLCR */
1348 p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_PLCR);
1359 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1364 p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_FM_CTL | NIA_FM_CTL_AC_CC);
1368 if (p_FmPort->pcdEngines & FM_PCD_PRS)
1384 p_FmPort->savedBmiNia |= (uint32_t)(NIA_ENG_PRS | (uint32_t)(hdrNum));
1391 GET_NIA_BMI_AC_ENQ_FRAME(p_FmPort->h_FmPcd));
1435 WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, PRS_CAC_STOP);
1437 while (GET_UINT32(p_FmPort->p_FmPortPrsRegs->pcac) & PRS_CAC_ACTIVE)
1444 for (i = 0; p_FmPort->optArray[i]; i++)
1445 switch (p_FmPort->optArray[i])
1493 if (FmPcdNetEnvIsHdrExist(p_FmPort->h_FmPcd, p_FmPort->netEnvId,
1535 initialSwPrs = FmPcdGetSwPrsOffset(p_FmPort->h_FmPcd, HEADER_TYPE_NONE,
1541 p_FmPort->savedBmiNia &= ~BMI_RFNE_HXS_MASK; /* 0x000000FF */
1543 p_FmPort->savedBmiNia |= initialSwPrs;
1557 p_FmPort, &p_PcdParams->p_PrsParams->additionalParams[i],
1564 if (p_FmPort->h_IpReassemblyManip)
1574 if (FmPcdNetEnvIsHdrExist(p_FmPort->h_FmPcd, p_FmPort->netEnvId, HEADER_TYPE_UDP_LITE))
1579 } else if ((FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd)
1580 && (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)))
1589 if (FmPcdNetEnvIsHdrExist(p_FmPort->h_FmPcd, p_FmPort->netEnvId,
1602 p_FmPort->p_FmPortPrsRegs->hdrs[i].lcv,
1603 FmPcdGetLcv(p_FmPort->h_FmPcd, p_FmPort->netEnvId, (uint8_t)i));
1605 WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->hdrs[i].softSeqAttach,
1621 }WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pctpid, tmpReg);
1624 WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, 0);
1627 p_FmPort->privateInfo =
1632 if (FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd)
1633 && (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
1636 WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->hdrs[hdrNum].softSeqAttach,
1642 p_FmPort->privateInfo = 0;
1645 FmPortCheckNApplyMacsec(p_FmPort);
1649 GET_UINT32(*p_BmiPrsStartOffset) + p_FmPort->internalBufferOffset);
1657 (uint32_t)(((uint32_t)p_FmPort->privateInfo << BMI_PR_PORTID_SHIFT) | BMI_PRS_RESULT_HIGH));
1670 static t_Error DeletePcd(t_FmPort *p_FmPort)
1676 ASSERT_COND(p_FmPort);
1677 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
1679 if (p_FmPort->imEn)
1683 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
1684 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
1685 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
1689 if (!p_FmPort->pcdEngines)
1693 switch (p_FmPort->portType)
1697 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
1698 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->rx.fmbm_rpso;
1701 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
1702 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->oh.fmbm_opso;
1716 /* WRITE_UINT32(*p_BmiNia, (p_FmPort->savedBmiNia & BMI_RFNE_FDCS_MASK) | (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)); */
1718 if (p_FmPort->pcdEngines & FM_PCD_PRS)
1721 WRITE_UINT32(p_FmPort->p_FmPortPrsRegs->pcac, PRS_CAC_STOP);
1723 while (GET_UINT32(p_FmPort->p_FmPortPrsRegs->pcac) & PRS_CAC_ACTIVE)
1727 if (p_FmPort->pcdEngines & FM_PCD_KG)
1732 p_FmPort->schemesPerPortVector = GetPortSchemeBindParams(p_FmPort,
1735 err = FmPcdKgUnbindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind);
1739 err = FmPcdKgDeleteOrUnbindPortToClsPlanGrp(p_FmPort->h_FmPcd,
1740 p_FmPort->hardwarePortId,
1741 p_FmPort->clsPlanGrpId);
1744 p_FmPort->useClsPlan = FALSE;
1747 if (p_FmPort->pcdEngines & FM_PCD_CC)
1750 err = FmPcdCcUnbindTree(p_FmPort->h_FmPcd, p_FmPort->ccTreeId);
1755 p_FmPort->pcdEngines = 0;
1760 static t_Error AttachPCD(t_FmPort *p_FmPort)
1764 ASSERT_COND(p_FmPort);
1767 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1768 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
1770 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
1778 if (p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY)
1779 if (FmSetNumOfRiscsPerPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId, 1,
1780 p_FmPort->orFmanCtrl) != E_OK)
1783 if (p_FmPort->requiredAction & UPDATE_NIA_CMNE)
1785 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1786 WRITE_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ocmne,
1787 p_FmPort->savedBmiCmne);
1789 WRITE_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rcmne,
1790 p_FmPort->savedBmiCmne);
1793 if (p_FmPort->requiredAction & UPDATE_NIA_PNEN)
1794 WRITE_UINT32(p_FmPort->p_FmPortQmiRegs->fmqm_pnen,
1795 p_FmPort->savedQmiPnen);
1797 if (p_FmPort->requiredAction & UPDATE_NIA_FENE)
1799 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1800 WRITE_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofene,
1801 p_FmPort->savedBmiFene);
1803 WRITE_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rfene,
1804 p_FmPort->savedBmiFene);
1807 if (p_FmPort->requiredAction & UPDATE_NIA_FPNE)
1809 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1810 WRITE_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofpne,
1811 p_FmPort->savedBmiFpne);
1813 WRITE_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rfpne,
1814 p_FmPort->savedBmiFpne);
1817 if (p_FmPort->requiredAction & UPDATE_OFP_DPTE)
1819 ASSERT_COND(p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING);
1821 WRITE_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofp,
1822 p_FmPort->savedBmiOfp);
1825 WRITE_UINT32(*p_BmiNia, p_FmPort->savedBmiNia);
1827 if (p_FmPort->requiredAction & UPDATE_NIA_PNDN)
1829 p_FmPort->origNonRxQmiRegsPndn =
1830 GET_UINT32(p_FmPort->port.qmi_regs->fmqm_pndn);
1831 WRITE_UINT32(p_FmPort->port.qmi_regs->fmqm_pndn,
1832 p_FmPort->savedNonRxQmiRegsPndn);
1838 static t_Error DetachPCD(t_FmPort *p_FmPort)
1842 ASSERT_COND(p_FmPort);
1845 if (p_FmPort->requiredAction & UPDATE_NIA_PNDN)
1846 WRITE_UINT32(p_FmPort->port.qmi_regs->fmqm_pndn,
1847 p_FmPort->origNonRxQmiRegsPndn);
1849 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1850 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
1852 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
1856 (p_FmPort->savedBmiNia & BMI_RFNE_FDCS_MASK) | GET_NO_PCD_NIA_BMI_AC_ENQ_FRAME());
1858 if (FmPcdGetHcHandle(p_FmPort->h_FmPcd))
1859 FmPcdHcSync(p_FmPort->h_FmPcd);
1861 if (p_FmPort->requiredAction & UPDATE_NIA_FENE)
1863 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
1864 WRITE_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofene,
1867 WRITE_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rfene,
1871 if (p_FmPort->requiredAction & UPDATE_NIA_PNEN)
1872 WRITE_UINT32(p_FmPort->port.qmi_regs->fmqm_pnen,
1875 if (p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY)
1876 if (FmSetNumOfRiscsPerPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId, 2,
1877 p_FmPort->orFmanCtrl) != E_OK)
1880 p_FmPort->requiredAction = 0;
1890 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
1894 SANITY_CHECK_RETURN(p_FmPort, E_INVALID_HANDLE);
1895 SANITY_CHECK_RETURN(p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
1897 if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G)
1898 && (p_FmPort->portType != e_FM_PORT_TYPE_TX))
1904 p_BmiCfgReg = &p_FmPort->port.bmi_regs->tx.fmbm_tfca;
1932 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
1935 ASSERT_COND(p_FmPort);
1938 if (p_FmPort->gprFunc != e_FM_PORT_GPR_EMPTY)
1940 if (p_FmPort->gprFunc != gprFunc)
1949 p_FmPort->p_ParamsPage = FM_MURAM_AllocMem(p_FmPort->h_FmMuram,
1951 if (!p_FmPort->p_ParamsPage)
1954 IOMemSet32(p_FmPort->p_ParamsPage, 0, 256);
1956 (uint32_t)(XX_VirtToPhys(p_FmPort->p_ParamsPage)
1957 - p_FmPort->fmMuramPhysBaseAddr);
1958 switch (p_FmPort->portType)
1963 p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rgpr,
1968 p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ogpr,
1979 p_FmPort->gprFunc = gprFunc;
1982 switch (p_FmPort->gprFunc)
1985 *p_Value = p_FmPort->p_ParamsPage;
1998 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2005 && (p_FmPort->bufferOffsets.prsResultOffset != ILLEGAL_BASE))
2008 (uint8_t)p_FmPort->bufferOffsets.prsResultOffset;
2014 (uint8_t)p_FmPort->hardwarePortId;
2018 && (p_FmPort->bufferOffsets.dataOffset != ILLEGAL_BASE))
2021 (uint16_t)p_FmPort->bufferOffsets.dataOffset;
2026 p_CcParams->getCcParams.numOfTasks = (uint8_t)p_FmPort->tasks.num;
2032 (uint8_t)p_FmPort->tasks.extra;
2037 p_CcParams->getCcParams.revInfo.majorRev = p_FmPort->fmRevInfo.majorRev;
2038 p_CcParams->getCcParams.revInfo.minorRev = p_FmPort->fmRevInfo.minorRev;
2043 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2045 GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm);
2048 GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsdm);
2054 p_FmPort->internalBufferOffset;
2059 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2061 GET_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofpne);
2064 GET_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rfpne);
2069 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2072 GET_UINT32(p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn);
2077 && !(p_FmPort->requiredAction & UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY))
2079 p_FmPort->requiredAction |= UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY;
2080 p_FmPort->orFmanCtrl = p_CcParams->setCcParams.orFmanCtrl;
2084 && !(p_FmPort->requiredAction & UPDATE_NIA_PNEN))
2086 p_FmPort->savedQmiPnen = p_CcParams->setCcParams.nia;
2087 p_FmPort->requiredAction |= UPDATE_NIA_PNEN;
2092 if (p_FmPort->savedQmiPnen != p_CcParams->setCcParams.nia)
2098 && !(p_FmPort->requiredAction & UPDATE_NIA_PNDN))
2100 p_FmPort->savedNonRxQmiRegsPndn = p_CcParams->setCcParams.nia;
2101 p_FmPort->requiredAction |= UPDATE_NIA_PNDN;
2106 if (p_FmPort->savedNonRxQmiRegsPndn != p_CcParams->setCcParams.nia)
2113 || !(p_FmPort->requiredAction & UPDATE_NIA_FENE)))
2115 p_FmPort->savedBmiFene = p_CcParams->setCcParams.nia;
2116 p_FmPort->requiredAction |= UPDATE_NIA_FENE;
2121 if (p_FmPort->savedBmiFene != p_CcParams->setCcParams.nia)
2127 && !(p_FmPort->requiredAction & UPDATE_NIA_FPNE))
2129 p_FmPort->savedBmiFpne = p_CcParams->setCcParams.nia;
2130 p_FmPort->requiredAction |= UPDATE_NIA_FPNE;
2135 if (p_FmPort->savedBmiFpne != p_CcParams->setCcParams.nia)
2141 && !(p_FmPort->requiredAction & UPDATE_NIA_CMNE))
2143 p_FmPort->savedBmiCmne = p_CcParams->setCcParams.nia;
2144 p_FmPort->requiredAction |= UPDATE_NIA_CMNE;
2149 if (p_FmPort->savedBmiCmne != p_CcParams->setCcParams.nia)
2155 && !(p_FmPort->requiredAction & UPDATE_PSO))
2158 switch (p_FmPort->portType)
2162 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->rx.fmbm_rpso;
2165 p_BmiPrsStartOffset = &p_FmPort->port.bmi_regs->oh.fmbm_opso;
2177 p_FmPort->requiredAction |= UPDATE_PSO;
2178 p_FmPort->savedPrsStartOffset = p_CcParams->setCcParams.psoSize;
2183 if (p_FmPort->savedPrsStartOffset
2192 && !(p_FmPort->requiredAction & UPDATE_OFP_DPTE))
2194 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2196 p_FmPort->savedBmiOfp = GET_UINT32(p_FmPort->port.bmi_regs->oh.fmbm_ofp);
2197 p_FmPort->savedBmiOfp &= ~BMI_FIFO_PIPELINE_DEPTH_MASK;
2198 p_FmPort->savedBmiOfp |= p_CcParams->setCcParams.ofpDpde
2200 p_FmPort->requiredAction |= UPDATE_OFP_DPTE;
2213 t_FmPort *p_FmPort;
2218 p_FmPort = (t_FmPort *)XX_Malloc(sizeof(t_FmPort));
2219 if (!p_FmPort)
2224 memset(p_FmPort, 0, sizeof(t_FmPort));
2227 p_FmPort->p_FmPortDriverParam = (t_FmPortDriverParam *)XX_Malloc(
2229 if (!p_FmPort->p_FmPortDriverParam)
2231 XX_Free(p_FmPort);
2235 memset(p_FmPort->p_FmPortDriverParam, 0, sizeof(t_FmPortDriverParam));
2238 p_FmPort->portType = p_FmPortParams->portType;
2239 p_FmPort->portId = p_FmPortParams->portId;
2240 p_FmPort->pcdEngines = FM_PCD_NONE;
2241 p_FmPort->f_Exception = p_FmPortParams->f_Exception;
2242 p_FmPort->h_App = p_FmPortParams->h_App;
2243 p_FmPort->h_Fm = p_FmPortParams->h_Fm;
2246 FM_GetRevision(p_FmPort->h_Fm, &p_FmPort->fmRevInfo);
2249 p_FmPort->hardwarePortId = SwPortIdToHwPortId(p_FmPort->portType,
2251 p_FmPort->fmRevInfo.majorRev,
2252 p_FmPort->fmRevInfo.minorRev);
2254 if (p_FmPort->fmRevInfo.majorRev >= 6)
2256 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)
2262 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2270 fman_port_defconfig(&p_FmPort->p_FmPortDriverParam->dfltCfg,
2271 (enum fman_port_type)p_FmPort->portType);
2273 p_FmPort->p_FmPortDriverParam->dfltCfg.rx_pri_elevation =
2275 p_FmPort->p_FmPortDriverParam->dfltCfg.rx_fifo_thr =
2279 p_FmPort->p_FmPortDriverParam->dfltCfg.errata_A006675 = TRUE;
2281 p_FmPort->p_FmPortDriverParam->dfltCfg.errata_A006675 = FALSE;
2283 if ((p_FmPort->fmRevInfo.majorRev == 6)
2284 && (p_FmPort->fmRevInfo.minorRev == 0))
2285 p_FmPort->p_FmPortDriverParam->dfltCfg.errata_A006320 = TRUE;
2287 p_FmPort->p_FmPortDriverParam->dfltCfg.errata_A006320 = FALSE;
2290 if (p_FmPort->fmRevInfo.majorRev < 6)
2293 p_FmPort->p_FmPortDriverParam->dfltCfg.excessive_threshold_register =
2296 p_FmPort->p_FmPortDriverParam->dfltCfg.fmbm_rebm_has_sgd = FALSE;
2297 p_FmPort->p_FmPortDriverParam->dfltCfg.fmbm_tfne_has_features = FALSE;
2301 p_FmPort->p_FmPortDriverParam->dfltCfg.excessive_threshold_register =
2303 p_FmPort->p_FmPortDriverParam->dfltCfg.fmbm_rebm_has_sgd = TRUE;
2304 p_FmPort->p_FmPortDriverParam->dfltCfg.fmbm_tfne_has_features = TRUE;
2306 if (p_FmPort->fmRevInfo.majorRev == 4)
2307 p_FmPort->p_FmPortDriverParam->dfltCfg.qmi_deq_options_support = FALSE;
2309 p_FmPort->p_FmPortDriverParam->dfltCfg.qmi_deq_options_support = TRUE;
2312 p_FmPort->p_FmPortDriverParam->baseAddr = baseAddr;
2314 p_FmPort->p_FmPortQmiRegs =
2316 p_FmPort->p_FmPortBmiRegs =
2318 p_FmPort->p_FmPortPrsRegs =
2321 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.privDataSize =
2323 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passPrsResult =
2325 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passTimeStamp =
2327 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.passAllOtherPCDInfo =
2329 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign =
2331 /* p_FmPort->p_FmPortDriverParam->dmaSwapData = (e_FmDmaSwapOption)DEFAULT_PORT_dmaSwapData;
2332 p_FmPort->p_FmPortDriverParam->dmaIntContextCacheAttr = (e_FmDmaCacheOption)DEFAULT_PORT_dmaIntContextCacheAttr;
2333 p_FmPort->p_FmPortDriverParam->dmaHeaderCacheAttr = (e_FmDmaCacheOption)DEFAULT_PORT_dmaHeaderCacheAttr;
2334 p_FmPort->p_FmPortDriverParam->dmaScatterGatherCacheAttr = (e_FmDmaCacheOption)DEFAULT_PORT_dmaScatterGatherCacheAttr;
2335 p_FmPort->p_FmPortDriverParam->dmaWriteOptimize = DEFAULT_PORT_dmaWriteOptimize;
2337 p_FmPort->p_FmPortDriverParam->liodnBase = p_FmPortParams->liodnBase;
2338 p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore =
2341 p_FmPort->maxFrameLength = DEFAULT_PORT_maxFrameLength;
2343 p_FmPort->fifoBufs.num = DEFAULT_PORT_numOfFifoBufs(p_FmPort->portType)
2345 p_FmPort->fifoBufs.extra = DEFAULT_PORT_extraNumOfFifoBufs
2347 p_FmPort->openDmas.num = DEFAULT_PORT_numOfOpenDmas(p_FmPort->portType);
2348 p_FmPort->openDmas.extra =
2349 DEFAULT_PORT_extraNumOfOpenDmas(p_FmPort->portType);
2350 p_FmPort->tasks.num = DEFAULT_PORT_numOfTasks(p_FmPort->portType);
2351 p_FmPort->tasks.extra = DEFAULT_PORT_extraNumOfTasks(p_FmPort->portType);
2355 if ((p_FmPort->fmRevInfo.majorRev == 6)
2356 && (p_FmPort->fmRevInfo.minorRev == 0)
2357 && ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2358 || (p_FmPort->portType == e_FM_PORT_TYPE_TX)))
2360 p_FmPort->openDmas.num = 16;
2361 p_FmPort->openDmas.extra = 0;
2366 switch (p_FmPort->portType)
2371 p_FmPort->p_FmPortDriverParam->cutBytesFromEnd =
2373 p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = FALSE;
2374 p_FmPort->p_FmPortDriverParam->frmDiscardOverride =
2378 GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfp);
2379 p_FmPort->p_FmPortDriverParam->rxFifoPriElevationLevel =
2383 p_FmPort->p_FmPortDriverParam->rxFifoThreshold = (((tmpReg
2387 p_FmPort->p_FmPortDriverParam->bufMargins.endMargins =
2389 p_FmPort->p_FmPortDriverParam->errorsToDiscard =
2391 p_FmPort->p_FmPortDriverParam->forwardReuseIntContext =
2394 p_FmPort->p_FmPortDriverParam->noScatherGather =
2400 p_FmPort->p_FmPortDriverParam->dontReleaseBuf = FALSE;
2403 WRITE_UINT32( p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tfp,
2408 GET_UINT32(p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tfp);
2409 p_FmPort->p_FmPortDriverParam->txFifoMinFillLevel = ((tmpReg
2412 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth =
2415 p_FmPort->p_FmPortDriverParam->txFifoLowComfLevel = (((tmpReg
2419 p_FmPort->p_FmPortDriverParam->deqType = DEFAULT_PORT_deqType;
2420 p_FmPort->p_FmPortDriverParam->deqPrefetchOption =
2422 p_FmPort->p_FmPortDriverParam->deqHighPriority =
2423 (bool)((p_FmPort->portType == e_FM_PORT_TYPE_TX) ? DEFAULT_PORT_deqHighPriority_1G :
2425 p_FmPort->p_FmPortDriverParam->deqByteCnt =
2427 (p_FmPort->portType == e_FM_PORT_TYPE_TX) ? DEFAULT_PORT_deqByteCnt_1G :
2431 p_FmPort->p_FmPortDriverParam->errorsToDiscard =
2434 p_FmPort->p_FmPortDriverParam->noScatherGather =
2438 p_FmPort->p_FmPortDriverParam->deqPrefetchOption =
2440 p_FmPort->p_FmPortDriverParam->deqHighPriority =
2442 p_FmPort->p_FmPortDriverParam->deqType = DEFAULT_PORT_deqType;
2443 p_FmPort->p_FmPortDriverParam->deqByteCnt =
2447 GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofp);
2448 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth =
2451 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)
2455 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth =
2460 if (p_FmPort->fmRevInfo.majorRev < 6)
2461 p_FmPort->p_FmPortDriverParam->cheksumLastBytesIgnore = DEFAULT_notSupported;
2465 if (!((p_FmPort->fmRevInfo.majorRev == 4) ||
2466 (p_FmPort->fmRevInfo.majorRev >= 6)))
2467 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth = DEFAULT_notSupported;
2472 XX_Free(p_FmPort->p_FmPortDriverParam);
2473 XX_Free(p_FmPort);
2478 if (p_FmPort->fmRevInfo.majorRev == 4)
2479 p_FmPort->p_FmPortDriverParam->deqPrefetchOption = (e_FmPortDeqPrefetchOption)DEFAULT_notSupported;
2482 p_FmPort->imEn = p_FmPortParams->independentModeEnable;
2484 if (p_FmPort->imEn)
2486 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX)
2487 || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G))
2488 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth =
2490 FmPortConfigIM(p_FmPort, p_FmPortParams);
2494 switch (p_FmPort->portType)
2499 memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools,
2502 p_FmPort->p_FmPortDriverParam->errFqid =
2504 p_FmPort->p_FmPortDriverParam->dfltFqid =
2506 p_FmPort->p_FmPortDriverParam->liodnOffset =
2513 p_FmPort->p_FmPortDriverParam->errFqid =
2515 p_FmPort->p_FmPortDriverParam->deqSubPortal =
2518 p_FmPort->p_FmPortDriverParam->dfltFqid =
2522 XX_Free(p_FmPort->p_FmPortDriverParam);
2523 XX_Free(p_FmPort);
2529 memset(p_FmPort->name, 0, (sizeof(char)) * MODULE_NAME_SIZE);
2531 p_FmPort->name,
2533 FmGetId(p_FmPort->h_Fm),
2534 ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING
2535 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND)) ? "OH" :
2536 (p_FmPort->portType == e_FM_PORT_TYPE_RX ? "1g-RX" :
2537 (p_FmPort->portType == e_FM_PORT_TYPE_TX ? "1g-TX" :
2538 (p_FmPort->portType
2541 p_FmPort->portId) == 0)
2543 XX_Free(p_FmPort->p_FmPortDriverParam);
2544 XX_Free(p_FmPort);
2549 p_FmPort->h_Spinlock = XX_InitSpinlock();
2550 if (!p_FmPort->h_Spinlock)
2552 XX_Free(p_FmPort->p_FmPortDriverParam);
2553 XX_Free(p_FmPort);
2558 return p_FmPort;
2575 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2582 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2585 &p_FmPort->p_FmPortDriverParam->intContext,
2586 &p_FmPort->p_FmPortDriverParam->bufferPrefixContent,
2587 &p_FmPort->p_FmPortDriverParam->bufMargins,
2588 &p_FmPort->bufferOffsets, &p_FmPort->internalBufferOffset);
2592 if ((p_FmPort->p_FmPortDriverParam->bcbWorkaround) &&
2593 (p_FmPort->portType == e_FM_PORT_TYPE_RX))
2595 p_FmPort->p_FmPortDriverParam->errorsToDiscard |= FM_PORT_FRM_ERR_PHYSICAL;
2596 if (!p_FmPort->fifoBufs.num)
2597 p_FmPort->fifoBufs.num = DEFAULT_PORT_numOfFifoBufs(p_FmPort->portType)*BMI_FIFO_UNITS;
2598 p_FmPort->fifoBufs.num += 4*KILOBYTE;
2602 CHECK_INIT_PARAMETERS(p_FmPort, CheckInitParameters);
2604 p_DriverParams = p_FmPort->p_FmPortDriverParam;
2607 memset(&p_FmPort->port, 0, sizeof(struct fman_port));
2608 p_FmPort->port.type = (enum fman_port_type)p_FmPort->portType;
2609 FM_GetRevision(p_FmPort->h_Fm, &revInfo);
2610 p_FmPort->port.fm_rev_maj = revInfo.majorRev;
2611 p_FmPort->port.fm_rev_min = revInfo.minorRev;
2612 p_FmPort->port.bmi_regs =
2614 p_FmPort->port.qmi_regs =
2616 p_FmPort->port.ext_pools_num = (uint8_t)((revInfo.majorRev == 4) ? 4 : 8);
2617 p_FmPort->port.im_en = p_FmPort->imEn;
2618 p_FmPort->p_FmPortPrsRegs =
2621 if (((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2622 || (p_FmPort->portType == e_FM_PORT_TYPE_RX)) && !p_FmPort->imEn)
2627 errCode = SetExtBufferPools(p_FmPort);
2633 > p_FmPort->rxPoolsParams.largestBufSize)
2637 ("bufMargins.startMargins (%d) + minimum buf size (64) + bufMargins.endMargins (%d) is larger than maximum external buffer size (%d)", p_DriverParams->bufMargins.startMargins, p_DriverParams->bufMargins.endMargins, p_FmPort->rxPoolsParams.largestBufSize));
2639 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2645 FM_GetRevision(p_FmPort->h_Fm, &revInfo);
2650 errCode = SetExtBufferPools(p_FmPort);
2661 fmParams.hardwarePortId = p_FmPort->hardwarePortId;
2662 fmParams.portType = (e_FmPortType)p_FmPort->portType;
2663 fmParams.numOfTasks = (uint8_t)p_FmPort->tasks.num;
2664 fmParams.numOfExtraTasks = (uint8_t)p_FmPort->tasks.extra;
2665 fmParams.numOfOpenDmas = (uint8_t)p_FmPort->openDmas.num;
2666 fmParams.numOfExtraOpenDmas = (uint8_t)p_FmPort->openDmas.extra;
2668 if (p_FmPort->fifoBufs.num)
2670 errCode = VerifySizeOfFifo(p_FmPort);
2674 fmParams.sizeOfFifo = p_FmPort->fifoBufs.num;
2675 fmParams.extraSizeOfFifo = p_FmPort->fifoBufs.extra;
2676 fmParams.independentMode = p_FmPort->imEn;
2680 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth;
2681 fmParams.maxFrameLength = p_FmPort->maxFrameLength;
2683 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) ||
2684 (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND))
2686 if (!((p_FmPort->fmRevInfo.majorRev == 4) ||
2687 (p_FmPort->fmRevInfo.majorRev >= 6)))
2695 errCode = FmGetSetPortParams(p_FmPort->h_Fm, &fmParams);
2700 p_FmPort->fmMuramPhysBaseAddr =
2703 p_FmPort->h_FmMuram = FmGetMuramHandle(p_FmPort->h_Fm);
2705 errCode = InitLowLevelDriver(p_FmPort);
2709 FmPortDriverParamFree(p_FmPort);
2712 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2713 || (p_FmPort->portType == e_FM_PORT_TYPE_RX)
2714 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
2718 FmPortSetGprFunc(p_FmPort, e_FM_PORT_GPR_MURAM_PAGE,
2724 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2731 GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm));
2735 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
2738 (GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm) | GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsem)));
2742 (GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsdm) | GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsem)));
2747 if (p_FmPort->deepSleepVars.autoResMaxSizes)
2748 FmPortConfigAutoResForDeepSleepSupport1(p_FmPort);
2765 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2768 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2770 if (p_FmPort->pcdEngines)
2776 if (p_FmPort->enabled)
2778 if (FM_PORT_Disable(p_FmPort) != E_OK)
2782 if (p_FmPort->imEn)
2783 FmPortImFree(p_FmPort);
2785 FmPortDriverParamFree(p_FmPort);
2788 fmParams.hardwarePortId = p_FmPort->hardwarePortId;
2789 fmParams.portType = (e_FmPortType)p_FmPort->portType;
2791 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth;
2793 FmFreePortParams(p_FmPort->h_Fm, &fmParams);
2796 if (FmVSPFreeForPort(p_FmPort->h_Fm, p_FmPort->portType, p_FmPort->portId)
2800 if (p_FmPort->p_ParamsPage)
2801 FM_MURAM_FreeMem(p_FmPort->h_FmMuram, p_FmPort->p_ParamsPage);
2804 if (p_FmPort->h_Spinlock)
2805 XX_FreeSpinlock(p_FmPort->h_Spinlock);
2807 XX_Free(p_FmPort);
2818 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2820 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2821 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2823 p_FmPort->p_FmPortDriverParam->setNumOfOpenDmas = TRUE;
2824 memcpy(&p_FmPort->openDmas, p_OpenDmas, sizeof(t_FmPortRsrc));
2831 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2833 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2834 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2836 memcpy(&p_FmPort->tasks, p_NumOfTasks, sizeof(t_FmPortRsrc));
2837 p_FmPort->p_FmPortDriverParam->setNumOfTasks = TRUE;
2843 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2845 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2846 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2848 p_FmPort->p_FmPortDriverParam->setSizeOfFifo = TRUE;
2849 memcpy(&p_FmPort->fifoBufs, p_SizeOfFifo, sizeof(t_FmPortRsrc));
2856 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2858 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2859 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2860 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2861 || (p_FmPort->portType == e_FM_PORT_TYPE_RX))
2864 p_FmPort->p_FmPortDriverParam->dfltCfg.deq_high_pri = highPri;
2871 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2873 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2874 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2875 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2876 || (p_FmPort->portType == e_FM_PORT_TYPE_RX))
2880 p_FmPort->p_FmPortDriverParam->dfltCfg.deq_type =
2889 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2891 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2892 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2893 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2894 || (p_FmPort->portType == e_FM_PORT_TYPE_RX))
2897 p_FmPort->p_FmPortDriverParam->dfltCfg.deq_prefetch_opt =
2906 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2908 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2909 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2910 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
2911 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
2915 p_FmPort->p_FmPortDriverParam->p_BackupBmPools =
2917 if (!p_FmPort->p_FmPortDriverParam->p_BackupBmPools)
2919 memcpy(p_FmPort->p_FmPortDriverParam->p_BackupBmPools, p_BackupBmPools,
2927 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2929 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2930 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2931 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
2932 || (p_FmPort->portType == e_FM_PORT_TYPE_RX))
2936 p_FmPort->p_FmPortDriverParam->dfltCfg.deq_byte_cnt = deqByteCnt;
2944 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2946 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2947 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2949 memcpy(&p_FmPort->p_FmPortDriverParam->bufferPrefixContent,
2952 if (!p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign)
2953 p_FmPort->p_FmPortDriverParam->bufferPrefixContent.dataAlign =
2962 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2964 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2965 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2967 p_FmPort->p_FmPortDriverParam->dfltCfg.checksum_bytes_ignore =
2976 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2978 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2979 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2980 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
2981 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
2985 p_FmPort->p_FmPortDriverParam->dfltCfg.rx_cut_end_bytes = cutBytesFromEnd;
2993 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
2995 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
2996 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
2997 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
2998 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
3002 p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = TRUE;
3003 memcpy(&p_FmPort->p_FmPortDriverParam->bufPoolDepletion, p_BufPoolDepletion,
3013 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3015 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3016 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3017 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
3021 p_FmPort->p_FmPortDriverParam->enBufPoolDepletion = TRUE;
3022 memcpy(&p_FmPort->p_FmPortDriverParam->bufPoolDepletion,
3025 memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools,
3034 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3036 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3037 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3039 if (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
3043 memcpy(&p_FmPort->p_FmPortDriverParam->extBufPools, p_FmExtPools,
3051 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3053 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3054 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3055 if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G)
3056 && (p_FmPort->portType != e_FM_PORT_TYPE_TX))
3060 p_FmPort->p_FmPortDriverParam->dontReleaseBuf = TRUE;
3067 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3069 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3070 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3071 p_FmPort->p_FmPortDriverParam->dfltCfg.color = (enum fman_port_color)color;
3078 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3080 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3081 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3083 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
3084 || (p_FmPort->portType == e_FM_PORT_TYPE_TX))
3088 p_FmPort->p_FmPortDriverParam->dfltCfg.sync_req = syncReq;
3095 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3097 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3098 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3099 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
3100 || (p_FmPort->portType == e_FM_PORT_TYPE_TX))
3104 p_FmPort->p_FmPortDriverParam->dfltCfg.discard_override = override;
3112 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3114 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3115 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3116 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
3117 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
3118 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
3122 p_FmPort->p_FmPortDriverParam->errorsToDiscard = errs;
3129 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3131 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3132 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3134 p_FmPort->p_FmPortDriverParam->dfltCfg.dma_swap_data =
3143 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3145 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3146 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3148 p_FmPort->p_FmPortDriverParam->dfltCfg.dma_ic_stash_on =
3157 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3159 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3160 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3162 p_FmPort->p_FmPortDriverParam->dfltCfg.dma_header_stash_on =
3171 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3173 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3174 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3176 p_FmPort->p_FmPortDriverParam->dfltCfg.dma_sg_stash_on =
3184 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3186 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3187 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3189 if ((p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)
3190 || (p_FmPort->portType == e_FM_PORT_TYPE_TX))
3194 p_FmPort->p_FmPortDriverParam->dfltCfg.dma_write_optimize = optimize;
3202 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3205 UNUSED(p_FmPort);
3207 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3208 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3210 p_FmPort->p_FmPortDriverParam->noScatherGather = noScatherGather;
3219 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3221 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3222 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3224 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
3225 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
3229 p_FmPort->p_FmPortDriverParam->forwardReuseIntContext = forwardReuse;
3236 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3238 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3239 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3241 p_FmPort->maxFrameLength = length;
3249 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3251 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3252 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3254 p_FmPort->p_FmPortDriverParam->bcbWorkaround = TRUE;
3267 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3269 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3270 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3271 if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G)
3272 && (p_FmPort->portType != e_FM_PORT_TYPE_TX))
3276 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_min_level = minFillLevel;
3284 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3286 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3287 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3289 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
3290 || (p_FmPort->portType == e_FM_PORT_TYPE_RX))
3294 if (p_FmPort->imEn)
3298 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_deq_pipeline_depth =
3307 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3309 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3310 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3311 if ((p_FmPort->portType != e_FM_PORT_TYPE_TX_10G)
3312 && (p_FmPort->portType != e_FM_PORT_TYPE_TX))
3316 p_FmPort->p_FmPortDriverParam->dfltCfg.tx_fifo_low_comf_level =
3324 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3326 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3327 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3328 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
3329 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
3333 p_FmPort->p_FmPortDriverParam->dfltCfg.rx_fifo_thr = fifoThreshold;
3341 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3343 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3344 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3345 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
3346 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
3350 p_FmPort->p_FmPortDriverParam->dfltCfg.rx_pri_elevation = priElevationLevel;
3361 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3364 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3365 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3375 err = FmSetNumOfOpenDmas(p_FmPort->h_Fm, p_FmPort->hardwarePortId,
3381 memcpy(&p_FmPort->openDmas, p_NumOfOpenDmas, sizeof(t_FmPortRsrc));
3388 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3391 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3392 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3395 ASSERT_COND(p_FmPort->portType != e_FM_PORT_TYPE_OH_HOST_COMMAND);
3407 err = FmSetNumOfTasks(p_FmPort->h_Fm, p_FmPort->hardwarePortId,
3414 memcpy(&p_FmPort->tasks, p_NumOfTasks, sizeof(t_FmPortRsrc));
3420 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3423 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3424 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3435 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
3436 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
3450 memcpy(&p_FmPort->fifoBufs, p_SizeOfFifo, sizeof(t_FmPortRsrc));
3453 err = VerifySizeOfFifo(p_FmPort);
3457 err = FmSetSizeOfFifo(p_FmPort->h_Fm, p_FmPort->hardwarePortId,
3467 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3469 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0);
3470 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
3473 return p_FmPort->bufferOffsets.dataOffset;
3478 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3480 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL);
3481 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
3484 if (p_FmPort->bufferOffsets.pcdInfoOffset == ILLEGAL_BASE)
3487 return (uint8_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.pcdInfoOffset);
3492 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3494 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL);
3495 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
3498 if (p_FmPort->bufferOffsets.prsResultOffset == ILLEGAL_BASE)
3501 return (t_FmPrsResult *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.prsResultOffset);
3506 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3508 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL);
3509 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
3512 if (p_FmPort->bufferOffsets.timeStampOffset == ILLEGAL_BASE)
3515 return (uint64_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.timeStampOffset);
3520 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3522 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, NULL);
3523 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
3526 if (p_FmPort->bufferOffsets.hashResultOffset == ILLEGAL_BASE)
3529 return (uint8_t *)PTR_MOVE(p_Data, p_FmPort->bufferOffsets.hashResultOffset);
3534 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3537 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3538 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3540 if (p_FmPort->imEn)
3541 FmPortImDisable(p_FmPort);
3543 err = fman_port_disable(&p_FmPort->port);
3547 p_FmPort->name));
3555 p_FmPort->enabled = FALSE;
3562 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3565 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3566 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3575 p_FmPort->enabled = TRUE;
3577 if (p_FmPort->imEn)
3578 FmPortImEnable(p_FmPort);
3580 err = fman_port_enable(&p_FmPort->port);
3589 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3595 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3596 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3598 switch (p_FmPort->portType)
3612 countUnitBit = (uint8_t)FmGetTimeStampScale(p_FmPort->h_Fm); /* TimeStamp per nano seconds units */
3636 params.count_1micro_bit = (uint8_t)FmGetTimeStampScale(p_FmPort->h_Fm);
3642 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
3646 if ((p_FmPort->fmRevInfo.majorRev == 4)
3647 || (p_FmPort->fmRevInfo.majorRev >= 6))
3674 err = fman_port_set_rate_limiter(&p_FmPort->port, ¶ms);
3683 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3686 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3687 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_HANDLE);
3689 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)
3690 || (p_FmPort->portType == e_FM_PORT_TYPE_RX)
3691 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND))
3695 err = fman_port_delete_rate_limiter(&p_FmPort->port);
3704 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3708 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3709 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3711 if ((p_FmPort->portType != e_FM_PORT_TYPE_TX)
3712 && (p_FmPort->portType != e_FM_PORT_TYPE_TX_10G))
3723 tmpReg = GET_UINT32(p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tpfcm[0]);
3728 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tpfcm[0],
3736 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3738 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3739 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3741 fman_port_set_queue_cnt_mode(&p_FmPort->port, enable);
3748 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3751 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3752 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3754 err = fman_port_set_perf_cnt_mode(&p_FmPort->port, enable);
3763 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3767 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3771 || (p_FmPortPerformanceCnt->taskCompVal > p_FmPort->tasks.num))
3775 ("taskCompVal (%d) has to be in the range of 1 - %d (current value)!", p_FmPortPerformanceCnt->taskCompVal, p_FmPort->tasks.num));
3777 || (p_FmPortPerformanceCnt->dmaCompVal > p_FmPort->openDmas.num))
3781 ("dmaCompVal (%d) has to be in the range of 1 - %d (current value)!", p_FmPortPerformanceCnt->dmaCompVal, p_FmPort->openDmas.num));
3783 || (p_FmPortPerformanceCnt->fifoCompVal > p_FmPort->fifoBufs.num))
3787 ("fifoCompVal (%d) has to be in the range of 256 - %d (current value)!", p_FmPortPerformanceCnt->fifoCompVal, p_FmPort->fifoBufs.num));
3794 switch (p_FmPort->portType)
3833 err = fman_port_set_perf_cnt_params(&p_FmPort->port, ¶ms);
3842 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3847 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3850 p_FmPort->portType, p_FmPort->portId);
3852 currParams.taskCompVal = (uint8_t)p_FmPort->tasks.num;
3853 if ((p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
3854 || (p_FmPort->portType == e_FM_PORT_TYPE_OH_HOST_COMMAND))
3858 currParams.dmaCompVal = (uint8_t)p_FmPort->openDmas.num;
3859 currParams.fifoCompVal = p_FmPort->fifoBufs.num;
3861 FM_PORT_SetPerformanceCounters(p_FmPort, FALSE);
3862 ClearPerfCnts(p_FmPort);
3863 if ((err = FM_PORT_SetPerformanceCountersParams(p_FmPort, &currParams))
3866 FM_PORT_SetPerformanceCounters(p_FmPort, TRUE);
3868 FM_PORT_SetPerformanceCounters(p_FmPort, FALSE);
3869 if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL))
3873 p_FmPort->tasks.num);
3876 if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL))
3880 p_FmPort->openDmas.num);
3883 if (FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL))
3887 p_FmPort->fifoBufs.num);
3916 ClearPerfCnts(p_FmPort);
3917 if ((err = FM_PORT_SetPerformanceCountersParams(p_FmPort, &currParams))
3920 FM_PORT_SetPerformanceCounters(p_FmPort, TRUE);
3922 FM_PORT_SetPerformanceCounters(p_FmPort, FALSE);
3925 && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_TASK_UTIL))
3928 && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_DMA_UTIL))
3931 && FM_PORT_GetCounter(p_FmPort, e_FM_PORT_COUNTERS_FIFO_UTIL))
3944 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3947 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
3948 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
3950 err = fman_port_set_stats_cnt_mode(&p_FmPort->port, enable);
3958 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
3963 err = fman_port_set_err_mask(&p_FmPort->port, (uint32_t)errs);
3968 if (p_FmPort->fmRevInfo.majorRev >= 6)
3972 FmPortSetGprFunc(p_FmPort, e_FM_PORT_GPR_MURAM_PAGE,
3975 switch (p_FmPort->portType)
3980 &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsdm;
3984 &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm;
4002 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4005 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4007 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4009 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
4010 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
4014 err = fman_port_set_bpool_cnt_mode(&p_FmPort->port, poolId, enable);
4022 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4024 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
4025 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G)){
4072 else if ((p_FmPort->portType == e_FM_PORT_TYPE_TX)
4073 || (p_FmPort->portType == e_FM_PORT_TYPE_TX_10G)){
4112 else if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) {
4162 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4170 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0);
4171 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4179 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
4180 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
4198 errCode = BmiPortCheckAndGetCounterType(p_FmPort, counter, &statsType,
4206 return fman_port_get_stats_counter(&p_FmPort->port, statsType);
4208 return fman_port_get_perf_counter(&p_FmPort->port, perfType);
4213 if (!(GET_UINT32(p_FmPort->port.qmi_regs->fmqm_pnc)
4241 return fman_port_get_qmi_counter(&p_FmPort->port, queueType);
4250 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4258 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4259 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4267 if ((p_FmPort->portType == e_FM_PORT_TYPE_RX)
4268 || (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
4282 errCode = BmiPortCheckAndGetCounterType(p_FmPort, counter, &statsType,
4289 fman_port_set_stats_counter(&p_FmPort->port, statsType, value);
4291 fman_port_set_perf_counter(&p_FmPort->port, perfType, value);
4296 if (!(GET_UINT32(p_FmPort->port.qmi_regs->fmqm_pnc)
4323 fman_port_set_qmi_counter(&p_FmPort->port, queueType, value);
4331 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4333 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, 0);
4334 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4336 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX)
4337 && (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
4342 return fman_port_get_bpool_counter(&p_FmPort->port, poolId);
4348 t_FmPort *p_FmPort = (t_FmPort *)h_FmPort;
4350 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4351 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4353 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX)
4354 && (p_FmPort->portType == e_FM_PORT_TYPE_RX_10G))
4358 fman_port_set_bpool_counter(&p_FmPort->port, poolId, value);
4363 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4367 SANITY_CHECK_RETURN_VALUE(p_FmPort, E_INVALID_HANDLE, FALSE);
4368 SANITY_CHECK_RETURN_VALUE(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE,
4371 err = FmIsPortStalled(p_FmPort->h_Fm, p_FmPort->hardwarePortId, &isStalled);
4382 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4384 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4385 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4387 return FmResumeStalledPort(p_FmPort->h_Fm, p_FmPort->hardwarePortId);
4392 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4395 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4396 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4398 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
4399 && (p_FmPort->portType != e_FM_PORT_TYPE_RX))
4405 &p_FmPort->port, (uint8_t)(BMI_PORT_RFNE_FRWD_DCL4C >> 24),
4409 &p_FmPort->port, (uint8_t)(BMI_PORT_RFNE_FRWD_DCL4C >> 24),
4424 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4430 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4431 SANITY_CHECK_RETURN_ERROR(p_FmPort->h_Fm, E_INVALID_HANDLE);
4438 /*p_FmPort should be from Rx type or OP*/
4440 ((p_FmPort->portType == e_FM_PORT_TYPE_RX_10G) || (p_FmPort->portType == e_FM_PORT_TYPE_RX) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)),
4443 SANITY_CHECK_RETURN_ERROR(!p_FmPort->enabled, E_INVALID_STATE);
4446 ((p_VSPParams->h_FmTxPort && !((t_FmPort *)(p_VSPParams->h_FmTxPort))->enabled) || (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)),
4449 SANITY_CHECK_RETURN_ERROR(!p_FmPort->pcdEngines, E_INVALID_STATE);
4452 err = FmVSPAllocForPort(p_FmPort->h_Fm, p_FmPort->portType,
4453 p_FmPort->portId, p_VSPParams->numOfProfiles);
4458 err = FmVSPGetAbsoluteProfileId(p_FmPort->h_Fm, p_FmPort->portType,
4459 p_FmPort->portId,
4465 /*fill relevant registers for p_FmPort and relative TxPort in the case p_FmPort from Rx type*/
4466 switch (p_FmPort->portType)
4483 &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfqid;
4484 p_BmiVspe = &p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rpp;
4490 WRITE_UINT32( p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs.fmqm_pndn,
4494 &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofqid;
4495 p_BmiVspe = &p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_opp;
4504 p_FmPort->vspe = TRUE;
4505 p_FmPort->dfltRelativeId = p_VSPParams->dfltRelativeId;
4519 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4522 p_FmPort->h_FmPcd = FmGetPcdHandle(p_FmPort->h_Fm);
4523 ASSERT_COND(p_FmPort->h_FmPcd);
4525 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4533 err = FmPcdPlcrAllocProfiles(p_FmPort->h_FmPcd,
4534 p_FmPort->hardwarePortId, numOfProfiles);
4539 FmPcdPortRegister(p_FmPort->h_FmPcd, h_FmPort, p_FmPort->hardwarePortId);
4541 RELEASE_LOCK(p_FmPort->lock);
4548 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4551 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4557 err = FmPcdPlcrFreeProfiles(p_FmPort->h_FmPcd, p_FmPort->hardwarePortId);
4559 RELEASE_LOCK(p_FmPort->lock);
4570 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4576 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4577 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4578 SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG,
4581 tmpReg = (uint32_t)((p_FmPort->pcdEngines & FM_PCD_CC) ? NIA_KG_CC_EN : 0);
4582 switch (p_FmPort->portType)
4586 p_BmiHpnia = &p_FmPort->port.bmi_regs->rx.fmbm_rfpne;
4589 p_BmiHpnia = &p_FmPort->port.bmi_regs->oh.fmbm_ofpne;
4596 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4607 if (!(p_FmPort->schemesPerPortVector
4610 RELEASE_LOCK(p_FmPort->lock);
4616 relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmPort->h_FmPcd,
4620 RELEASE_LOCK(p_FmPort->lock);
4627 RELEASE_LOCK(p_FmPort->lock);
4639 RELEASE_LOCK(p_FmPort->lock);
4647 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4653 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
4654 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4655 SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_PLCR,
4660 if ((p_FmPort->pcdEngines & FM_PCD_KG)
4661 || (p_FmPort->pcdEngines & FM_PCD_CC))
4667 switch (p_FmPort->portType)
4671 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
4672 p_BmiHpnia = &p_FmPort->port.bmi_regs->rx.fmbm_rfpne;
4676 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
4677 p_BmiHpnia = &p_FmPort->port.bmi_regs->oh.fmbm_ofpne;
4685 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4691 if (!FmPcdPlcrIsProfileValid(p_FmPort->h_FmPcd, absoluteProfileId))
4693 RELEASE_LOCK(p_FmPort->lock);
4699 if (p_FmPort->pcdEngines & FM_PCD_PRS) /* e_FM_PCD_SUPPORT_PRS_AND_PLCR */
4710 }RELEASE_LOCK(p_FmPort->lock);
4717 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4726 if (p_FmPort->imEn)
4731 switch (p_FmPort->portType)
4735 p_BmiNia = &p_FmPort->port.bmi_regs->rx.fmbm_rfne;
4738 p_BmiNia = &p_FmPort->port.bmi_regs->oh.fmbm_ofne;
4747 != GET_NIA_BMI_AC_ENQ_FRAME(p_FmPort->h_FmPcd))
4751 if (p_FmPort->pcdEngines & FM_PCD_CC)
4753 if (p_FmPort->h_IpReassemblyManip)
4755 err = FmPcdCcTreeAddIPR(p_FmPort->h_FmPcd, h_CcTree, NULL,
4756 p_FmPort->h_IpReassemblyManip, FALSE);
4763 if (p_FmPort->h_CapwapReassemblyManip)
4765 err = FmPcdCcTreeAddCPR(p_FmPort->h_FmPcd, h_CcTree, NULL,
4766 p_FmPort->h_CapwapReassemblyManip,
4773 switch (p_FmPort->portType)
4777 p_BmiCcBase = &p_FmPort->port.bmi_regs->rx.fmbm_rccb;
4780 p_BmiCcBase = &p_FmPort->port.bmi_regs->oh.fmbm_occb;
4786 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4791 err = FmPcdCcBindTree(p_FmPort->h_FmPcd, NULL, h_CcTree,
4795 RELEASE_LOCK(p_FmPort->lock);
4799 p_FmPort->ccTreeId = h_CcTree;
4800 RELEASE_LOCK(p_FmPort->lock);
4811 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4815 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4817 if (p_FmPort->imEn)
4821 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
4822 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
4823 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
4827 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4833 if (p_FmPort->h_ReassemblyTree)
4834 p_FmPort->pcdEngines |= FM_PCD_CC;
4837 RELEASE_LOCK(p_FmPort->lock);
4844 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4848 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4850 if (p_FmPort->imEn)
4854 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
4855 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
4856 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
4860 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4869 RELEASE_LOCK(p_FmPort->lock);
4873 if (p_FmPort->h_ReassemblyTree)
4874 p_FmPort->pcdEngines &= ~FM_PCD_CC;
4875 RELEASE_LOCK(p_FmPort->lock);
4882 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
4891 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
4893 if (p_FmPort->imEn)
4897 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
4898 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
4899 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
4903 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
4909 p_FmPort->h_FmPcd = FmGetPcdHandle(p_FmPort->h_Fm);
4910 ASSERT_COND(p_FmPort->h_FmPcd);
4932 RELEASE_LOCK(p_FmPort->lock);
4936 p_FmPort->h_IpReassemblyManip = p_PcdParams->h_IpReassemblyManip;
4943 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
4947 p_FmPort->h_CapwapReassemblyManip =
4957 RELEASE_LOCK(p_FmPort->lock);
4971 p_FmPort->h_ReassemblyTree = FM_PCD_CcRootBuild(
4972 p_FmPort->h_FmPcd, p_FmPcdCcTreeParams);
4974 if (!p_FmPort->h_ReassemblyTree)
4976 RELEASE_LOCK(p_FmPort->lock);
4989 fmPortPcdCcParams.h_CcTree = p_FmPort->h_ReassemblyTree;
4994 if (p_FmPort->h_IpReassemblyManip)
4995 err = FmPcdCcTreeAddIPR(p_FmPort->h_FmPcd,
4998 p_FmPort->h_IpReassemblyManip, TRUE);
5001 if (p_FmPort->h_CapwapReassemblyManip)
5002 err = FmPcdCcTreeAddCPR(p_FmPort->h_FmPcd,
5005 p_FmPort->h_CapwapReassemblyManip,
5011 if (p_FmPort->h_ReassemblyTree)
5013 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5014 p_FmPort->h_ReassemblyTree = NULL;
5015 }RELEASE_LOCK(p_FmPort->lock);
5020 if (!FmPcdLockTryLockAll(p_FmPort->h_FmPcd))
5022 if (p_FmPort->h_ReassemblyTree)
5024 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5025 p_FmPort->h_ReassemblyTree = NULL;
5026 }RELEASE_LOCK(p_FmPort->lock);
5034 if (p_FmPort->h_ReassemblyTree)
5036 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5037 p_FmPort->h_ReassemblyTree = NULL;
5039 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5040 RELEASE_LOCK(p_FmPort->lock);
5044 if ((p_FmPort->pcdEngines & FM_PCD_PRS)
5047 err = FmPcdPrsIncludePortInStatistics(p_FmPort->h_FmPcd,
5048 p_FmPort->hardwarePortId, TRUE);
5051 DeletePcd(p_FmPort);
5052 if (p_FmPort->h_ReassemblyTree)
5054 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5055 p_FmPort->h_ReassemblyTree = NULL;
5057 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5058 RELEASE_LOCK(p_FmPort->lock);
5061 p_FmPort->includeInPrsStatistics = TRUE;
5064 FmPcdIncNetEnvOwners(p_FmPort->h_FmPcd, p_FmPort->netEnvId);
5066 if (FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd))
5070 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
5073 if ((p_FmPort->fmRevInfo.majorRev < 6) &&
5074 (p_FmPort->pcdEngines & FM_PCD_KG))
5079 FmPcdKgCcGetSetParams(p_FmPort->h_FmPcd,
5090 FmPortSetGprFunc(p_FmPort, e_FM_PORT_GPR_MURAM_PAGE,
5094 p_FmPort->savedBmiNia);
5099 p_FmPort->savedBmiNia &= BMI_RFNE_FDCS_MASK;
5100 p_FmPort->savedBmiNia |= (NIA_FM_CTL_AC_POST_BMI_FETCH
5111 if ((err = FmPortGetSetCcParams(p_FmPort, &fmPortGetSetCcParams))
5114 DeletePcd(p_FmPort);
5115 if (p_FmPort->h_ReassemblyTree)
5117 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5118 p_FmPort->h_ReassemblyTree = NULL;
5120 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5121 RELEASE_LOCK(p_FmPort->lock);
5126 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5130 if (p_FmPort->fmRevInfo.majorRev < 6)
5145 DeletePcd(p_FmPort);
5146 if (p_FmPort->h_ReassemblyTree)
5148 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5149 p_FmPort->h_ReassemblyTree = NULL;
5150 }RELEASE_LOCK(p_FmPort->lock);
5161 DeletePcd(p_FmPort);
5162 if (p_FmPort->h_ReassemblyTree)
5164 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5165 p_FmPort->h_ReassemblyTree = NULL;
5166 }RELEASE_LOCK(p_FmPort->lock);
5170 if ((p_FmPort->h_IpReassemblyManip)
5171 || (p_FmPort->h_CapwapReassemblyManip))
5174 if (p_FmPort->fmRevInfo.majorRev < 6)
5194 DeletePcd(p_FmPort);
5195 if (p_FmPort->h_ReassemblyTree)
5197 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5198 p_FmPort->h_ReassemblyTree = NULL;
5199 }RELEASE_LOCK(p_FmPort->lock);
5205 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5214 if (FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd))
5223 DeletePcd(p_FmPort);
5224 if (p_FmPort->h_ReassemblyTree)
5226 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5227 p_FmPort->h_ReassemblyTree = NULL;
5228 }RELEASE_LOCK(p_FmPort->lock);
5232 FmPortSetGprFunc(p_FmPort, e_FM_PORT_GPR_MURAM_PAGE,
5236 if (FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd))
5241 if ((p_FmPort->h_IpReassemblyManip)
5242 || (p_FmPort->h_CapwapReassemblyManip))
5244 if (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING)
5247 GET_UINT32(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_ofsdm));
5251 GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfsdm));
5254 if (p_FmPort->vspe)
5257 GET_UINT32(p_ParamsPage->misc) | (p_FmPort->dfltRelativeId & FM_CTL_PARAMS_PAGE_ERROR_VSP_MASK));
5265 DeletePcd(p_FmPort);
5266 if (p_FmPort->h_ReassemblyTree)
5268 FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5269 p_FmPort->h_ReassemblyTree = NULL;
5270 }RELEASE_LOCK(p_FmPort->lock);
5274 RELEASE_LOCK(p_FmPort->lock);
5281 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5285 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
5287 if (p_FmPort->imEn)
5291 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
5292 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
5293 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
5297 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
5306 RELEASE_LOCK(p_FmPort->lock);
5310 FmPcdDecNetEnvOwners(p_FmPort->h_FmPcd, p_FmPort->netEnvId);
5313 if ((p_FmPort->pcdEngines & FM_PCD_PRS) && p_FmPort->includeInPrsStatistics)
5315 FmPcdPrsIncludePortInStatistics(p_FmPort->h_FmPcd,
5316 p_FmPort->hardwarePortId, FALSE);
5317 p_FmPort->includeInPrsStatistics = FALSE;
5320 if (!FmPcdLockTryLockAll(p_FmPort->h_FmPcd))
5322 RELEASE_LOCK(p_FmPort->lock);
5328 FmPcdLockUnlockAll(p_FmPort->h_FmPcd);
5331 RELEASE_LOCK(p_FmPort->lock);
5335 if (p_FmPort->h_ReassemblyTree)
5337 err = FM_PCD_CcRootDelete(p_FmPort->h_ReassemblyTree);
5340 RELEASE_LOCK(p_FmPort->lock);
5343 p_FmPort->h_ReassemblyTree = NULL;
5344 }RELEASE_LOCK(p_FmPort->lock);
5352 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5358 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
5359 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
5360 SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG,
5363 schemeBind.netEnvId = p_FmPort->netEnvId;
5364 schemeBind.hardwarePortId = p_FmPort->hardwarePortId;
5366 schemeBind.useClsPlan = p_FmPort->useClsPlan;
5375 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
5381 err = FmPcdKgBindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind);
5383 p_FmPort->schemesPerPortVector |= tmpScmVec;
5386 if ((FmPcdIsAdvancedOffloadSupported(p_FmPort->h_FmPcd)) &&
5387 (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING) &&
5388 (p_FmPort->fmRevInfo.majorRev < 6))
5391 FmPcdKgCcGetSetParams(p_FmPort->h_FmPcd, p_PortScheme->h_Schemes[i], UPDATE_KG_NIA_CC_WA, 0);
5395 RELEASE_LOCK(p_FmPort->lock);
5403 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5409 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
5410 SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
5411 SANITY_CHECK_RETURN_ERROR(p_FmPort->pcdEngines & FM_PCD_KG,
5414 schemeBind.netEnvId = p_FmPort->netEnvId;
5415 schemeBind.hardwarePortId = p_FmPort->hardwarePortId;
5425 if (!TRY_LOCK(p_FmPort->h_Spinlock, &p_FmPort->lock))
5431 err = FmPcdKgUnbindPortToSchemes(p_FmPort->h_FmPcd, &schemeBind);
5433 p_FmPort->schemesPerPortVector &= ~tmpScmVec;
5434 RELEASE_LOCK(p_FmPort->lock);
5442 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5451 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
5461 if ((p_FmPort->fmRevInfo.majorRev != 4) &&
5462 (p_FmPort->fmRevInfo.majorRev < 6))
5464 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) &&
5465 (p_FmPort->portType != e_FM_PORT_TYPE_RX))
5470 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
5471 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
5472 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
5482 if (p_FmPort->fmRevInfo.majorRev != 4)
5504 err = FmSetCongestionGroupPFCpriority(p_FmPort->h_Fm, i,
5511 err = fman_port_add_congestion_grps(&p_FmPort->port, grpsMap);
5521 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5526 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
5532 FM_GetRevision(p_FmPort->h_Fm, &revInfo);
5535 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G) &&
5536 (p_FmPort->portType != e_FM_PORT_TYPE_RX))
5541 if ((p_FmPort->portType != e_FM_PORT_TYPE_RX_10G)
5542 && (p_FmPort->portType != e_FM_PORT_TYPE_RX)
5543 && (p_FmPort->portType != e_FM_PORT_TYPE_OH_OFFLINE_PARSING))
5554 if (p_FmPort->fmRevInfo.majorRev != 4)
5564 p_FmPort->h_Fm, p_CongestionGrps->congestionGrpsToConsider[i],
5571 err = fman_port_remove_congestion_grps(&p_FmPort->port, grpsMap);
5582 t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
5584 SANITY_CHECK_RETURN_ERROR(p_FmPort, E_INVALID_HANDLE);
5586 (p_FmPort->portType == e_FM_PORT_TYPE_OH_OFFLINE_PARSING),
5588 SANITY_CHECK_RETURN_ERROR(p_FmPort->p_ParamsPage, E_INVALID_STATE);
5591 *p_Ipv4OptionsCount = GET_UINT32(p_FmPort->p_ParamsPage->ipfOptionsCounter);
5600 t_FmPort *p_FmPort = (t_FmPort *)h_FmPortRx;
5601 p_FmPort->deepSleepVars.autoResMaxSizes = XX_Malloc(
5603 memcpy(p_FmPort->deepSleepVars.autoResMaxSizes, params,
5608 static t_Error FmPortConfigAutoResForDeepSleepSupport1(t_FmPort *p_FmPort)
5611 t_FmPortDsarTablesSizes *params = p_FmPort->deepSleepVars.autoResMaxSizes;
5659 ArCommonDescPtr = FM_MURAM_AllocMem(p_FmPort->h_FmMuram, size, 0x10);
5663 p_FmPort->fmMuramPhysBaseAddr
5664 + GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rgpr));
5667 (uint32_t)(XX_VirtToPhys(ArCommonDescPtr) - p_FmPort->fmMuramPhysBaseAddr));
5673 t_FmPort *p_FmPort = (t_FmPort *)h_FmPortRx;
5674 return p_FmPort->deepSleepVars.autoResMaxSizes;
5692 t_FmPort *p_FmPort)
5747 size += p_FmPort->deepSleepVars.autoResMaxSizes->maxNumOfSnmpOidChar;
5986 t_FmPort *p_FmPort = (t_FmPort *)h_FmPortRx;
5993 uint64_t fmMuramVirtBaseAddr = (uint64_t)PTR_TO_UINT(XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr));
5994 uint32_t *param_page = XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr + GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rgpr));
5995 t_ArCommonDesc *ArCommonDescPtr = (t_ArCommonDesc*)(XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr + GET_UINT32(*param_page)));
6003 err = DsarCheckParams(params, p_FmPort->deepSleepVars.autoResMaxSizes);
6007 p_FmPort->deepSleepVars.autoResOffsets = XX_Malloc(sizeof(struct arOffsets));
6008 of = (struct arOffsets *)p_FmPort->deepSleepVars.autoResOffsets;
6009 IOMemSet32(ArCommonDescPtr, 0, AR_ComputeOffsets(of, params, p_FmPort));
6013 nia = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne); // bmi nia
6015 WRITE_UINT32(ArCommonDescPtr->activeHPNIA, GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne));
6297 t_FmPort *p_FmPort = (t_FmPort *)h_DsarRxPort;
6299 t_Handle *h_FmPcd = FmGetPcd(p_FmPort->h_Fm);
6303 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6309 p_FmPort->deepSleepVars.fmbm_tcfg = GET_UINT32(p_FmPortTx->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcfg);
6312 p_FmPort->deepSleepVars.fmbm_tcmne = GET_UINT32(p_FmPortTx->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcmne);
6315 p_FmPort->deepSleepVars.fmbm_rfpne = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne);
6316 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne, 0x2E);
6319 p_FmPort->deepSleepVars.dsarEnabledParser = TRUE;
6323 p_FmPort->deepSleepVars.dsarEnabledParser = FALSE;
6325 p_FmPort->deepSleepVars.fmbm_rfne = GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne);
6326 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne, 0x440000);
6329 p_FmPort->deepSleepVars.fmbm_rcfg = GET_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rcfg);
6330 WRITE_UINT32(p_FmPort->port.bmi_regs->rx.fmbm_rcfg, p_FmPort->deepSleepVars.fmbm_rcfg | BMI_PORT_CFG_AM);
6334 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6339 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6343 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6349 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6356 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6364 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6366 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6369 // FM_ChangeClock(p_FmPort->h_Fm, p_FmPort->hardwarePortId);
6382 t_FmPort *p_FmPort = (t_FmPort *)h_FmPortRx;
6384 t_Handle *h_FmPcd = FmGetPcd(p_FmPort->h_Fm);
6390 if (p_FmPort->deepSleepVars.autoResOffsets)
6392 XX_Free(p_FmPort->deepSleepVars.autoResOffsets);
6393 p_FmPort->deepSleepVars.autoResOffsets = 0;
6396 if (p_FmPort->deepSleepVars.dsarEnabledParser)
6397 PrsDisable(FmGetPcd(p_FmPort->h_Fm));
6398 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfpne, p_FmPort->deepSleepVars.fmbm_rfpne);
6399 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rfne, p_FmPort->deepSleepVars.fmbm_rfne);
6400 WRITE_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcfg, p_FmPort->deepSleepVars.fmbm_rcfg);
6401 FmGetSetParams(p_FmPort->h_Fm, &fmGetSetParams);
6402 WRITE_UINT32(p_FmPortTx->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcmne, p_FmPort->deepSleepVars.fmbm_tcmne);
6403 WRITE_UINT32(p_FmPortTx->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tcfg, p_FmPort->deepSleepVars.fmbm_tcfg);
6409 t_FmPort *p_FmPort = (t_FmPort *)h_FmPort;
6410 return PTR_TO_UINT(p_FmPort->deepSleepVars.autoResOffsets);
6415 t_FmPort *p_FmPort = (t_FmPort *)h_FmPortRx;
6416 struct arOffsets *of = (struct arOffsets*)p_FmPort->deepSleepVars.autoResOffsets;
6417 uint8_t* fmMuramVirtBaseAddr = XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr);
6418 uint32_t *param_page = XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr + GET_UINT32(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rgpr));
6419 t_ArCommonDesc *ArCommonDescPtr = (t_ArCommonDesc*)(XX_PhysToVirt(p_FmPort->fmMuramPhysBaseAddr + GET_UINT32(*param_page)));