NVDLA系列之C-model：cvif＜97＞

业界资讯 2023-12-17 07:56:18 阅读次数: 0

NV_NVDLA_cvif.cpp

cdma_wt2cvif_rd_req_b_transport


void NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport(int ID, nvdla_dma_rd_req_t* payload, sc_time& delay) {
    
    
    // DMA request size unit is 32 bytes
    uint64_t base_addr;
    uint64_t first_base_addr;
    uint64_t last_base_addr;
    uint64_t cur_address;
    uint32_t size_in_byte;
    uint32_t total_axi_size;
    uint64_t payload_addr;
    uint32_t payload_size;
    uint8_t* axi_byte_enable_ptr;
    uint32_t byte_iter;
    bool     is_base_64byte_align;
    bool     is_rear_64byte_align;
    bool     is_read=true;
    nvdla_dbb_extension *nvdla_dbb_ext = NULL;
    dla_b_transport_payload *bt_payload;

    payload_addr = payload->pd.dma_read_cmd.addr;
    payload_size = (payload->pd.dma_read_cmd.size + 1) * DMA_TRANSACTION_ATOM_SIZE; //payload_size's max value is 2^13

    is_base_64byte_align = payload_addr%AXI_TRANSACTION_ATOM_SIZE == 0;
    first_base_addr = is_base_64byte_align? payload_addr: payload_addr - DMA_TRANSACTION_ATOM_SIZE; // Align to 64B
    cur_address = is_base_64byte_align? payload_addr: payload_addr - DMA_TRANSACTION_ATOM_SIZE; // Align to 64B

    is_rear_64byte_align = (payload_addr + payload_size) % AXI_TRANSACTION_ATOM_SIZE == 0;
    total_axi_size = payload_size + (is_base_64byte_align? 0: DMA_TRANSACTION_ATOM_SIZE) + (is_rear_64byte_align? 0: DMA_TRANSACTION_ATOM_SIZE);
    last_base_addr = first_base_addr + total_axi_size - AXI_TRANSACTION_ATOM_SIZE;
    cslDebug((30, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, first_base_addr=0x%lx last_base_addr=0x%lx total_axi_size is 0x%x payload_addr=0x%lx payload_size=0x%x\x0A", first_base_addr, last_base_addr, total_axi_size, payload_addr, payload_size));
    // if ( total_axi_size <= (first_base_addr % (CVIF_MAX_MEM_TRANSACTION_SIZE)) ) {
    
    
    //     last_base_addr = first_base_addr;
    // } else if ((first_base_addr + total_axi_size)%CVIF_MAX_MEM_TRANSACTION_SIZE != 0) {
    
    
    //     if (total_axi_size >= (first_base_addr + total_axi_size)%CVIF_MAX_MEM_TRANSACTION_SIZE) {
    
    
    //         last_base_addr = first_base_addr + total_axi_size - (first_base_addr + total_axi_size)%CVIF_MAX_MEM_TRANSACTION_SIZE;
    //     } else {
    
    
    //         last_base_addr = first_base_addr;
    //     }
    // } else {
    
    
    //     if (total_axi_size >= CVIF_MAX_MEM_TRANSACTION_SIZE) {
    
    
    //         last_base_addr = first_base_addr + total_axi_size - CVIF_MAX_MEM_TRANSACTION_SIZE;
    //     } else {
    
    
    //         last_base_addr = first_base_addr;
    //     }
    // }

    base_addr = first_base_addr;

这段代码是用于处理CVIF模块接收到的来自CDMA模块的权重读取请求。以下是主要步骤：

  1. 初始化变量：代码首先初始化了一些变量，包括base_addr（当前AXI请求的基地址）、first_base_addr（对齐到64字节的基地址）、last_base_addr（最后一个AXI请求的基地址）、cur_address（当前地址）、size_in_byte（AXI请求的数据大小）、total_axi_size（总的AXI请求大小，包括对齐的和未对齐的部分）、payload_addr（来自DMA请求的地址）、payload_size（来自DMA请求的数据大小）、axi_byte_enable_ptr（AXI原子的字节使能指针）、byte_iter（字节迭代器，用于处理字节使能）等。

  2. 计算对齐和大小：代码根据DMA请求的地址和数据大小计算了对齐到64字节边界的first_base_addr，并设置了cur_address为对齐的地址。然后，它确定了是否在AXI请求的起始和结束处对齐到64字节，以及计算了总的AXI请求大小total_axi_size。

  3. 主循环：代码进入一个主循环，用于处理AXI请求的拆分。

  4. 拆分AXI请求：在主循环中，代码不断拆分AXI请求。它首先设置base_addr为当前地址，然后设置size_in_byte为AXI事务原子的大小（通常是64字节）。然后，它检查下一个AXI请求是否需要对齐到64字节，并根据需要增加size_in_byte。接下来，它更新cur_address为下一个AXI请求的起始地址。

  5. 配置字节使能：代码根据每个字节是否需要在AXI请求中使能，配置了axi_byte_enable_ptr。这通常与地址对齐有关，以确保每个AXI请求正确地包含需要的数据。

  6. 创建和发送AXI请求：代码创建了一个dla_b_transport_payload对象bt_payload，用于表示AXI请求。然后，它设置了AXI请求的基地址、大小和读写标志。接下来，它获取了AXI请求的扩展字段nvdla_dbb_ext，并设置了ID、大小和长度。最后，它将AXI请求发送到cdma_wt_rd_req_fifo_中，以便后续处理。

  7. 更新地址和大小：代码在处理完一个AXI请求后，更新了base_addr和cur_address，以及减少了total_axi_size和payload_size，以便继续处理下一个AXI请求。

这段代码的主要作用是处理来自CDMA模块的权重读取请求，并将其拆分成多个AXI请求，然后发送给上层模块进行处理。这有助于确保CVIF模块能够按照AXI接口的要求有效地处理这些请求。


    // Push the number of atoms of the request
    // cdma_wt2cvif_rd_req_atom_num_fifo_->write(total_axi_size/DMA_TRANSACTION_ATOM_SIZE);
    cdma_wt2cvif_rd_req_atom_num_fifo_->write(payload_size/DMA_TRANSACTION_ATOM_SIZE);
    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write 0x%x to cdma_wt2cvif_rd_req_atom_num_fifo_.\x0A", payload_size/DMA_TRANSACTION_ATOM_SIZE));

    //Split dma request to axi requests
    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, before spliting DMA transaction\x0A"));
    while(cur_address <= last_base_addr) {
    
    
        base_addr    = cur_address;
        size_in_byte = AXI_TRANSACTION_ATOM_SIZE;
        cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, prepare AXI transaction for address: 0x%lx\x0A", base_addr));
        // base_addr should be aligned to 64B
        // size_in_byte should be multiple of 64
        // if the data size required by dma mster is 32B, MCIF will drop the extra 32B when AXI returns
        // size_in_byte = total_axi_size > (CVIF_MAX_MEM_TRANSACTION_SIZE) ? CVIF_MAX_MEM_TRANSACTION_SIZE : total_axi_size;
        // size_in_byte = (total_axi_size - base_addr % (CVIF_MAX_MEM_TRANSACTION_SIZE)) < (CVIF_MAX_MEM_TRANSACTION_SIZE) ? (total_axi_size - base_addr % (CVIF_MAX_MEM_TRANSACTION_SIZE)) : CVIF_MAX_MEM_TRANSACTION_SIZE;
        // if (base_addr % CVIF_MAX_MEM_TRANSACTION_SIZE == 0) {
    
    
        //     size_in_byte = total_axi_size > CVIF_MAX_MEM_TRANSACTION_SIZE?CVIF_MAX_MEM_TRANSACTION_SIZE:total_axi_size;
        // } else if ( total_axi_size > (base_addr % CVIF_MAX_MEM_TRANSACTION_SIZE)) {
    
    
        //     size_in_byte = base_addr % CVIF_MAX_MEM_TRANSACTION_SIZE;
        // } else {
    
    
        //     size_in_byte = total_axi_size;
        // }
        while (((cur_address + AXI_TRANSACTION_ATOM_SIZE) < (first_base_addr + total_axi_size)) && ((cur_address + AXI_TRANSACTION_ATOM_SIZE) % CVIF_MAX_MEM_TRANSACTION_SIZE != 0)) {
    
    
            size_in_byte += AXI_TRANSACTION_ATOM_SIZE;
            cur_address  += AXI_TRANSACTION_ATOM_SIZE;
        }
        // start address of next axi transaction
        cur_address += AXI_TRANSACTION_ATOM_SIZE;
        cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, cur_address=0x%lx base_addr=0x%lx size_in_byte=0x%x\x0A", cur_address, base_addr, size_in_byte));

这段代码执行以下操作：

  1. 将权重读取请求的原子数量写入cdma_wt2cvif_rd_req_atom_num_fifo_中。这个数量是payload_size除以DMA_TRANSACTION_ATOM_SIZE的结果，表示请求需要多少个AXI原子。

  2. 进入一个循环，循环条件是cur_address小于等于last_base_addr，即处理AXI请求的拆分过程。

  3. 在循环内部，首先设置base_addr为当前地址，size_in_byte为AXI事务原子的大小（通常是64字节）。

  4. 接下来，代码进入一个嵌套的循环，用于确定下一个AXI请求的大小。这个循环的目标是确保AXI请求的大小是64字节的整数倍，并且对齐到64字节的边界。在循环内部，代码不断增加size_in_byte，并将cur_address更新为下一个AXI请求的起始地址，直到满足上述条件。

  5. 在每个循环迭代中，都会打印出当前AXI请求的地址base_addr、大小size_in_byte以及下一个AXI事务的起始地址cur_address。

这段代码的目的是将权重读取请求拆分成多个AXI请求，以便按照AXI接口的要求逐个处理。AXI请求的大小和对齐是根据AXI接口的规范进行计算和调整的，以确保数据传输的正确性和效率。


        // Allocating memory for dla_b_transport_payload
        bt_payload = new dla_b_transport_payload(size_in_byte, dla_b_transport_payload::DLA_B_TRANSPORT_PAYLOAD_TYPE_MC);
        axi_byte_enable_ptr = bt_payload->gp.get_byte_enable_ptr();
        // Setup byte enable in payload. Always read 64B from cvif and cvif, but drop unneeded 32B
        // Write true to *_rd_atom_enable_fifo_ when the 32B atom is needed by dma client
        // Write false to *_rd_atom_enable_fifo_ when the 32B atom is not needed by dma client (dma's addr is not aligned to 64B
        // for (byte_iter=0; byte_iter < size_in_byte; byte_iter++) {
    
    
        //     if(base_addr == last_base_addr) {   // compare with last_base_addr before first_base_addr for the case of only one axi transaction
        //         if ( (((true == is_rear_64byte_align) || (byte_iter < (size_in_byte - DMA_TRANSACTION_ATOM_SIZE))) && (first_base_addr != base_addr)) || 
        //                 ( ( ( (true == is_base_64byte_align) && (byte_iter < DMA_TRANSACTION_ATOM_SIZE) ) || ( (true == is_rear_64byte_align) && (byte_iter >= DMA_TRANSACTION_ATOM_SIZE)) ) && (first_base_addr == base_addr)) ){
    
    
        //             axi_byte_enable_ptr[byte_iter] = TLM_BYTE_ENABLED;
        //             if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
        //                 cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
        //                 cdma_wt_rd_atom_enable_fifo_->write(true);
        //             }
        //         } else {
    
    
        //             axi_byte_enable_ptr[byte_iter] = TLM_BYTE_DISABLED;
        //             if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
        //                 cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write false to cdma_wt_rd_atom_enable_fifo_\x0A"));
        //                 cdma_wt_rd_atom_enable_fifo_->write(false);
        //             }
        //         }
        //     }
        //     else if(base_addr == first_base_addr) {
    
    
        //         if ( (true == is_base_64byte_align) || (byte_iter >= DMA_TRANSACTION_ATOM_SIZE) ){
    
    
        //             axi_byte_enable_ptr[byte_iter] = TLM_BYTE_ENABLED;
        //             if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
        //                 cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
        //                 cdma_wt_rd_atom_enable_fifo_->write(true);
        //             }
        //         } else {
    
    
        //             axi_byte_enable_ptr[byte_iter] = TLM_BYTE_DISABLED;
        //             if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
        //                 cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write false to cdma_wt_rd_atom_enable_fifo_\x0A"));
        //                 cdma_wt_rd_atom_enable_fifo_->write(false);
        //             }
        //         }
        //     }
        //     else {
    
    
        //         axi_byte_enable_ptr[byte_iter] = TLM_BYTE_ENABLED;
        //         if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
        //             cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
        //             cdma_wt_rd_atom_enable_fifo_->write(true);
        //         }
        //     }
        // }
        for (byte_iter=0; byte_iter < size_in_byte; byte_iter++) {
    
    
            if ( (base_addr == first_base_addr) && (false == is_base_64byte_align) && (byte_iter < DMA_TRANSACTION_ATOM_SIZE)) {
    
    
                // Diable 1st DMA atom of the unaligned first_base_addr
                axi_byte_enable_ptr[byte_iter] = TLM_BYTE_DISABLED;  // All bytes should be enabled
                if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
                    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
                    cdma_wt_rd_atom_enable_fifo_->write(false);
                }
            } else if (( (base_addr + size_in_byte) == (last_base_addr+AXI_TRANSACTION_ATOM_SIZE)) && (false == is_rear_64byte_align) && (byte_iter >= size_in_byte - DMA_TRANSACTION_ATOM_SIZE)) {
    
    
                // Diable 2nd DMA atom of the unaligned last_base_addr
                axi_byte_enable_ptr[byte_iter] = TLM_BYTE_DISABLED;  // All bytes should be enabled
                if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
                    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
                    cdma_wt_rd_atom_enable_fifo_->write(false);
                }
            } else {
    
    
                axi_byte_enable_ptr[byte_iter] = TLM_BYTE_ENABLED;  // All bytes should be enabled
                if (0 == byte_iter%DMA_TRANSACTION_ATOM_SIZE) {
    
    
                    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, write true to cdma_wt_rd_atom_enable_fifo_\x0A"));
                    cdma_wt_rd_atom_enable_fifo_->write(true);
                }
            }
        }
        cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, TLM_BYTE_ENABLE is done\x0A"));
        bt_payload->configure_gp(base_addr, size_in_byte, is_read);
        bt_payload->gp.get_extension(nvdla_dbb_ext);
        nvdla_dbb_ext->set_id(CDMA_WT_AXI_ID);
        nvdla_dbb_ext->set_size(64);
        nvdla_dbb_ext->set_length(size_in_byte/AXI_TRANSACTION_ATOM_SIZE);
#pragma CTC SKIP
        if(size_in_byte%AXI_TRANSACTION_ATOM_SIZE!=0) {
    
    
            FAIL(("NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, size_in_byte is not multiple of AXI_TRANSACTION_ATOM_SIZE. size_in_byte=0x%x", size_in_byte));
        }
#pragma CTC ENDSKIP
        cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, before sending data to cdma_wt_rd_req_fifo_ addr=0x%lx\x0A", base_addr));
        cdma_wt_rd_req_fifo_->write(bt_payload);
        cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, after sending data to cdma_wt_rd_req_fifo_ addr=0x%lx\x0A", base_addr));

        // total_axi_size -= size_in_byte;
        // base_addr      += size_in_byte;
    }
    cslDebug((50, "NV_NVDLA_cvif::cdma_wt2cvif_rd_req_b_transport, after spliting DMA transaction\x0A"));
}

这段代码执行以下操作：

  1. 分配了一个名为bt_payload的dla_b_transport_payload对象，该对象用于构建用于传输的事务。

  2. 获取bt_payload对象的字节使能指针axi_byte_enable_ptr。

  3. 进入一个循环，该循环遍历size_in_byte，为bt_payload对象的字节使能设置适当的值。在这里，代码通过检查地址是否对齐以及是否需要特定字节来确定哪些字节应启用。

    • 如果base_addr等于first_base_addr且不是64字节对齐，并且byte_iter小于DMA_TRANSACTION_ATOM_SIZE，则禁用第一个不对齐的DMA原子的字节，并向cdma_wt_rd_atom_enable_fifo_写入false。

    • 如果base_addr加上size_in_byte等于last_base_addr + AXI_TRANSACTION_ATOM_SIZE，并且last_base_addr不是64字节对齐，并且byte_iter大于或等于size_in_byte - DMA_TRANSACTION_ATOM_SIZE，则禁用最后一个不对齐的DMA原子的字节，并向cdma_wt_rd_atom_enable_fifo_写入false。

    • 对于其他情况，启用所有字节，并向cdma_wt_rd_atom_enable_fifo_写入true。

  4. 设置好字节使能后，代码将bt_payload对象的一些属性配置为当前AXI请求的信息，包括地址、大小、读写类型等。

  5. 创建一个名为nvdla_dbb_ext的nvdla_dbb_extension对象，将其附加到bt_payload对象上，并设置一些AXI事务的附加信息，如ID、大小和长度。

  6. 最后，代码检查size_in_byte是否是AXI_TRANSACTION_ATOM_SIZE的整数倍，如果不是，则会引发错误。

  7. 向cdma_wt_rd_req_fifo_写入bt_payload对象，将AXI请求发送到CDMA的权重读取请求队列中。

总之，这段代码的主要目的是创建AXI请求事务，并在其中设置适当的字节使能，然后将这些事务发送到CDMA的权重读取请求队列中，以满足CDMA对权重数据的读取需求。在这个过程中，代码确保AXI请求的大小和对齐方式满足AXI接口的要求。

ReadResp_cvif2cdma_wt


void NV_NVDLA_cvif::ReadResp_cvif2cdma_wt() {
    
    
    uint8_t    *axi_atom_ptr;
    uint32_t    atom_num_left;
    nvdla_dma_rd_rsp_t* dma_rd_rsp_payload = NULL;
    uint8_t           * dma_payload_data_ptr;
    uint32_t    idx;

    atom_num_left = 0;
    while(true) {
    
    
        if(0 == atom_num_left) {
    
    
            atom_num_left = cdma_wt2cvif_rd_req_atom_num_fifo_->read();
            cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, update atom_num_left from cdma_wt2cvif_rd_req_atom_num_fifo_, atom_num_left is 0x%x\x0A", atom_num_left));
        }
        cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, atom_num_left is 0x%x\x0A", atom_num_left));

        dma_rd_rsp_payload      = new nvdla_dma_rd_rsp_t;
        dma_payload_data_ptr    = reinterpret_cast <uint8_t *> (dma_rd_rsp_payload->pd.dma_read_data.data);
        dma_rd_rsp_payload->pd.dma_read_data.mask = 0x00;

        // 1st atom of the 64B
        // Aligen to 32B
        axi_atom_ptr = cvif2cdma_wt_rd_rsp_fifo_->read();
        credit_cvif2cdma_wt_rd_rsp_fifo_ ++;
        cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, read 1st atom of the 64B from cvif2cdma_wt_rd_rsp_fifo_\x0A"));
        atom_num_left--;

        dma_rd_rsp_payload->pd.dma_read_data.mask = 0x1;
        memcpy (&dma_payload_data_ptr[0], axi_atom_ptr, DMA_TRANSACTION_ATOM_SIZE);
        delete[] axi_atom_ptr;

        if(atom_num_left>0) {
    
    
            // 2nd atom of the 64B
            axi_atom_ptr = cvif2cdma_wt_rd_rsp_fifo_->read();
            credit_cvif2cdma_wt_rd_rsp_fifo_ ++;
            cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, read 2nd atom of the 64B from cvif2cdma_wt_rd_rsp_fifo_\x0A"));
            atom_num_left--;
            dma_rd_rsp_payload->pd.dma_read_data.mask = (dma_rd_rsp_payload->pd.dma_read_data.mask << 0x1) + 0x1;
            memcpy (&dma_payload_data_ptr[DMA_TRANSACTION_ATOM_SIZE], axi_atom_ptr, DMA_TRANSACTION_ATOM_SIZE);
            delete[] axi_atom_ptr;
        }

        cslDebug((70, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, dma_rd_rsp_payload->pd.dma_read_data.mask is 0x%x\x0A", uint32_t(dma_rd_rsp_payload->pd.dma_read_data.mask)));
        cslDebug((70, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, dma_rd_rsp_payload->pd.dma_read_data.data are :\x0A"));
        for (idx = 0; idx < sizeof(dma_rd_rsp_payload->pd.dma_read_data.data)/sizeof(dma_rd_rsp_payload->pd.dma_read_data.data[0]); idx++) {
    
    
            cslDebug((70, "    0x%lx\x0A", uint64_t (dma_rd_rsp_payload->pd.dma_read_data.data[idx])));   // The size of data[idx] is 8bytes and its type is "unsigned long"
        }
        cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, before NV_NVDLA_cvif_base::cvif2cdma_wt_rd_rsp_b_transport(dma_rd_rsp_payload, dma_delay_)\x0A"));
        NV_NVDLA_cvif_base::cvif2cdma_wt_rd_rsp_b_transport(dma_rd_rsp_payload, dma_delay_);
        cslDebug((50, "NV_NVDLA_cvif::ReadResp_cvif2cdma_wt, after NV_NVDLA_cvif_base::cvif2cdma_wt_rd_rsp_b_transport(dma_rd_rsp_payload, dma_delay_)\x0A"));
        delete dma_rd_rsp_payload;
    }
}

这段代码是用于读取从CVIF到CDMA权重读取请求的响应数据的函数。以下是代码的主要步骤：

  1. 初始化变量：

    • atom_num_left：表示还需要读取的数据原子数量，初始化为0。
    • dma_rd_rsp_payload：用于存储DMA读取响应数据的结构体指针，初始化为NULL。
    • dma_payload_data_ptr：指向DMA读取响应数据的指针。
    • idx：循环迭代索引。

  2. 进入一个无限循环（while(true)），该循环用于不断读取响应数据。

  3. 在循环中，首先检查atom_num_left的值，如果为0，表示需要从cdma_wt2cvif_rd_req_atom_num_fifo_读取下一个数据原子的数量，并更新atom_num_left的值。

  4. 然后，创建一个新的dma_rd_rsp_payload对象来存储即将到来的DMA读取响应数据，并初始化数据掩码为0。

  5. 接着，从cvif2cdma_wt_rd_rsp_fifo_中读取64B数据的第一个原子（32B），并递减atom_num_left的值。

  6. 设置数据掩码的相应位为1，表示已经读取了一个原子的数据，并将该数据复制到dma_payload_data_ptr中。

  7. 如果atom_num_left仍然大于0，表示还有更多的原子需要读取，那么继续读取下一个64B数据的原子，并更新数据掩码和dma_payload_data_ptr。

  8. 输出一些调试信息，包括数据掩码和已读取的数据。

  9. 最后，调用NV_NVDLA_cvif_base::cvif2cdma_wt_rd_rsp_b_transport函数，将dma_rd_rsp_payload传递给CDMA模块的权重读取响应处理逻辑，然后删除dma_rd_rsp_payload以释放内存。

总之，这段代码负责不断读取CVIF到CDMA权重读取请求的响应数据，并将其传递给CDMA模块进行处理。这样可以确保权重读取请求得到了响应，并可以继续处理下一个请求。

猜你喜欢

转载自blog.csdn.net/lincolnjunior_lj/article/details/132835227
97
今日推荐
周排行
AIZU 2224 Save your cats(并查集)
HTTP响应头状态码详解
Python socket编程（2）
MaxCompute Studio使用心得系列7—作业对比
Supervisor安装使用
LeetCode 164. Maximum Gap
mysql面试题: 一张表里面有ID自增主键，当insert了17条记录之后，删除了第15,16,17条记录，再把mysql重启，再insert一条记录，这条记录的ID是18还是15
nutch1.2 DeleteDuplicates IndexMerger 详解
OC - @property与setter,getter方法
SpringBoot @Transactional的rollbackFor属性
每日归档
更多
2024-09-19(0)
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022