Line data    Source code

       1              : /**
       2              :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3              :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4              :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5              :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6              :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7              :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8              :  * See LICENSE in the root of the software repository for the full text of the License.
       9              :  */
      10              : 
      11              : #include "hccp_tlv_hdc_mgr.h"
      12              : 
      13              : #include "hccl_common.h"
      14              : 
      15              : #include "hccp_tlv.h"
      16              : 
      17              : namespace hcomm {
      18              : 
      19           70 : HccpTlvHdcMgr& HccpTlvHdcMgr::GetInstance(const uint32_t devicePhyId)
      20              : {
      21           70 :     static HccpTlvHdcMgr hccpTlvHdcMgr[MAX_MODULE_DEVICE_NUM + 1];
      22              : 
      23           70 :     uint32_t devPhyId = devicePhyId;
      24           70 :     if (devPhyId >= MAX_MODULE_DEVICE_NUM) {
      25            0 :         HCCL_WARNING(
      26              :             "[HccpTlvHdcMgr][%s] use the backup device, devPhyId[%u] should be "
      27              :             "less than %u.",
      28              :             __func__, devPhyId, MAX_MODULE_DEVICE_NUM);
      29            0 :         devPhyId = MAX_MODULE_DEVICE_NUM; // 使用备份设备
      30              :     }
      31              : 
      32           70 :     hccpTlvHdcMgr[devPhyId].devPhyId_ = devPhyId;
      33           70 :     return hccpTlvHdcMgr[devPhyId];
      34              : }
      35              : 
      36           25 : inline TlvInitInfo GetCfgInfo(const uint32_t devPhyId)
      37              : {
      38           25 :     constexpr u32 tlvVersion = 1;
      39           25 :     struct TlvInitInfo tlvInfo {};
      40           25 :     tlvInfo.phyId = devPhyId;
      41           25 :     tlvInfo.nicPosition = NetworkMode::NETWORK_OFFLINE;
      42           25 :     tlvInfo.version = tlvVersion;
      43              : 
      44           25 :     return tlvInfo;
      45              : }
      46              : 
      47           25 : static HcclResult HccpTlvInit(const uint32_t devPhyId, TlvHandle& tlvHandle)
      48              : {
      49           25 :     TlvInitInfo cfgInfo = GetCfgInfo(devPhyId);
      50           25 :     unsigned int bufferSize{0}; // 当前未使用
      51              : 
      52           25 :     int32_t ret = RaTlvInit(&cfgInfo, &bufferSize, &tlvHandle);
      53           25 :     if (ret != 0 || tlvHandle == nullptr) {
      54            0 :         HCCL_ERROR(
      55              :             "[Init][RaTlv]errNo[0x%016llx] ra tlv init fail. params: mode[%u]. return: ret[%d]",
      56              :             static_cast<unsigned long long>(HCCL_ERROR_CODE(HcclResult::HCCL_E_NETWORK)), cfgInfo.nicPosition, ret);
      57            0 :         return HcclResult::HCCL_E_NETWORK;
      58              :     }
      59              : 
      60           25 :     HCCL_INFO("[%s] success, device id[%u] tlv handle[%p]", __func__, cfgInfo.phyId, tlvHandle);
      61           25 :     return HcclResult::HCCL_SUCCESS;
      62              : }
      63              : 
      64           69 : HcclResult HccpTlvHdcMgr::Init()
      65              : {
      66           69 :     std::unique_lock<std::mutex> lock(innerMutex_);
      67           69 :     if (initFlag_) {
      68           44 :         return HcclResult::HCCL_SUCCESS;
      69              :     }
      70              : 
      71           25 :     CHK_RET(HccpTlvInit(devPhyId_, tlvHandle_));
      72           25 :     initFlag_ = true;
      73           25 :     return HcclResult::HCCL_SUCCESS;
      74           69 : }
      75              : 
      76           69 : TlvHandle HccpTlvHdcMgr::GetHandle() { return tlvHandle_; }
      77              : 
      78           25 : static HcclResult HccpTlvDeinit(const TlvHandle tlvHandle)
      79              : {
      80           25 :     int32_t ret = RaTlvDeinit(tlvHandle);
      81           25 :     if (ret != 0) {
      82            0 :         HCCL_ERROR(
      83              :             "[DeInit][RaTlv]errNo[0x%016llx] ra tlv deinit fail. return: ret[%d]",
      84              :             static_cast<unsigned long long>(HCCL_ERROR_CODE(HcclResult::HCCL_E_NETWORK)), ret);
      85            0 :         return HcclResult::HCCL_E_NETWORK;
      86              :     }
      87              : 
      88           25 :     return HcclResult::HCCL_SUCCESS;
      89              : }
      90              : 
      91          132 : HcclResult HccpTlvHdcMgr::Deinit()
      92              : {
      93          132 :     std::unique_lock<std::mutex> lock(innerMutex_);
      94          132 :     if (!initFlag_) {
      95          107 :         return HcclResult::HCCL_SUCCESS;
      96              :     }
      97              : 
      98           25 :     CHK_RET(HccpTlvDeinit(tlvHandle_));
      99           25 :     tlvHandle_ = nullptr;
     100           25 :     initFlag_ = false;
     101           25 :     return HcclResult::HCCL_SUCCESS;
     102          132 : }
     103              : 
     104          132 : HccpTlvHdcMgr::~HccpTlvHdcMgr() { (void)Deinit(); }
     105              : 
     106              : } // namespace hcomm