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           28 : HccpTlvHdcMgr &HccpTlvHdcMgr::GetInstance(const uint32_t devicePhyId)
      20              : {
      21           28 :     static HccpTlvHdcMgr hccpTlvHdcMgr[MAX_MODULE_DEVICE_NUM + 1];
      22              :     
      23           28 :     uint32_t devPhyId = devicePhyId;
      24           28 :     if (devPhyId >= MAX_MODULE_DEVICE_NUM) {
      25            0 :         HCCL_WARNING("[HccpTlvHdcMgr][%s] use the backup device, devPhyId[%u] should be "
      26              :             "less than %u.", __func__, devPhyId, MAX_MODULE_DEVICE_NUM);
      27            0 :         devPhyId = MAX_MODULE_DEVICE_NUM; // 使用备份设备
      28              :     }
      29              : 
      30           28 :     hccpTlvHdcMgr[devPhyId].devPhyId_ = devPhyId;
      31           28 :     return hccpTlvHdcMgr[devPhyId];
      32              : }
      33              : 
      34           12 : inline TlvInitInfo GetCfgInfo(const uint32_t devPhyId)
      35              : {
      36           12 :     constexpr u32 tlvVersion = 1;
      37           12 :     struct TlvInitInfo tlvInfo{};
      38           12 :     tlvInfo.phyId = devPhyId;
      39           12 :     tlvInfo.nicPosition = NetworkMode::NETWORK_OFFLINE;
      40           12 :     tlvInfo.version = tlvVersion;
      41              : 
      42           12 :     return tlvInfo;
      43              : }
      44              : 
      45           12 : static HcclResult HccpTlvInit(const uint32_t devPhyId, TlvHandle &tlvHandle)
      46              : {
      47           12 :     TlvInitInfo cfgInfo = GetCfgInfo(devPhyId);
      48           12 :     unsigned int bufferSize{0}; // 当前未使用
      49              : 
      50           12 :     int32_t ret = RaTlvInit(&cfgInfo, &bufferSize, &tlvHandle);
      51           12 :     if (ret != 0 || tlvHandle == nullptr) {
      52            0 :         HCCL_ERROR("[Init][RaTlv]errNo[0x%016llx] ra tlv init fail. params: mode[%u]. return: ret[%d]", 
      53              :                    HCCL_ERROR_CODE(HcclResult::HCCL_E_NETWORK), cfgInfo.nicPosition, ret);
      54            0 :         return HcclResult::HCCL_E_NETWORK;
      55              :     }
      56              : 
      57           12 :     HCCL_INFO("[%s] success, device id[%u] tlv handle[%p]",
      58              :         __func__, cfgInfo.phyId, tlvHandle);
      59           12 :     return HcclResult::HCCL_SUCCESS;
      60              : }
      61              : 
      62           27 : HcclResult HccpTlvHdcMgr::Init()
      63              : {
      64           27 :     std::unique_lock<std::mutex> lock(innerMutex_);
      65           27 :     if (initFlag_) {
      66           15 :         return HcclResult::HCCL_SUCCESS;
      67              :     }
      68              : 
      69           12 :     CHK_RET(HccpTlvInit(devPhyId_, tlvHandle_));
      70           12 :     initFlag_ = true;
      71           12 :     return HcclResult::HCCL_SUCCESS;
      72           27 : }
      73              : 
      74           27 : TlvHandle HccpTlvHdcMgr::GetHandle()
      75              : {
      76           27 :     return tlvHandle_;
      77              : }
      78              : 
      79           12 : static HcclResult HccpTlvDeinit(const TlvHandle tlvHandle)
      80              : {
      81           12 :     int32_t ret = RaTlvDeinit(tlvHandle);
      82           12 :     if (ret != 0) {
      83            0 :         HCCL_ERROR("[DeInit][RaTlv]errNo[0x%016llx] ra tlv deinit fail. return: ret[%d]", 
      84              :                    HCCL_ERROR_CODE(HcclResult::HCCL_E_NETWORK), ret);
      85            0 :         return HcclResult::HCCL_E_NETWORK;
      86              :     }
      87              : 
      88           12 :     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          120 :         return HcclResult::HCCL_SUCCESS;
      96              :     }
      97              : 
      98           12 :     CHK_RET(HccpTlvDeinit(tlvHandle_));
      99           12 :     tlvHandle_ = nullptr;
     100           12 :     initFlag_ = false;
     101           12 :     return HcclResult::HCCL_SUCCESS;
     102          132 : }
     103              : 
     104          132 : HccpTlvHdcMgr::~HccpTlvHdcMgr()
     105              : {
     106          132 :     (void)Deinit();
     107          132 : }
     108              : 
     109              : } // namespace hcom