system/dev/ethernet/dwmac/pinned-buffer.cpp

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "pinned-buffer.h"

#include <climits>
#include <utility>

fbl::RefPtr<PinnedBuffer> PinnedBuffer::Create(size_t size, const zx::bti& bti,
                                               uint32_t cache_policy) {
    fbl::RefPtr<fzl::VmarManager> vmar_mgr;

    if (!bti.is_valid() || (size & (PAGE_SIZE - 1))) {
        return nullptr;
    }

    //create vmar large enough for rx,tx buffers, and rx,tx dma descriptors
    vmar_mgr = fzl::VmarManager::Create(size, nullptr);
    if (!vmar_mgr) {
        zxlogf(ERROR, "pinned-buffer: Creation of vmar manager failed\n");
        return nullptr;
    }

    fbl::AllocChecker ac;

    auto pbuf = fbl::AdoptRef(new (&ac) PinnedBuffer());
    if (!ac.check()) {
        return nullptr;
    }

    zx_status_t status = pbuf->vmo_mapper_.CreateAndMap(size,
                                                        ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
                                                        std::move(vmar_mgr), &pbuf->vmo_,
                                                        ZX_RIGHT_READ | ZX_RIGHT_MAP |
                                                            ZX_RIGHT_WRITE,
                                                        cache_policy);
    if (status != ZX_OK) {
        zxlogf(ERROR, "pinned-buffer: vmo creation failed %d\n", status);
        return nullptr;
    }

    uint32_t page_count = static_cast<uint32_t>(size / PAGE_SIZE);

    fbl::unique_ptr<zx_paddr_t[]> addrs(new (&ac) zx_paddr_t[page_count]);
    if (!ac.check()) {
        return nullptr;
    }

    // Now actually pin the region.

    status = bti.pin(ZX_BTI_PERM_READ | ZX_BTI_PERM_WRITE,
                     pbuf->vmo_, 0, size, addrs.get(),
                     page_count, &pbuf->pmt_);
    if (status != ZX_OK) {
        pbuf->UnPin();
        return nullptr;
    }

    pbuf->paddrs_.reset(addrs.release());
    return pbuf;
}

zx_status_t PinnedBuffer::UnPin() {
    if ((paddrs_ == nullptr) || !pmt_.is_valid()) {
        return ZX_ERR_BAD_STATE;
    }
    pmt_.unpin();
    paddrs_.reset();
    return ZX_OK;
}

// We need a status here since it is within the realm of possibility that
// the physical address returned could legitimately be 0x00000000, so
// returning a nullptr for a failure won't cut it.
zx_status_t PinnedBuffer::LookupPhys(zx_off_t offset, zx_paddr_t* out) {
    if (paddrs_ == nullptr) {
        return ZX_ERR_BAD_STATE;
    }
    if (offset >= GetSize()) {
        *out = 0;
        return ZX_ERR_INVALID_ARGS;
    }

    *out = paddrs_[offset / PAGE_SIZE] + (offset % PAGE_SIZE);

    return ZX_OK;
}