| // Copyright 2020 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 <lib/dma-buffer/buffer.h> |
| #include <lib/zx/vmar.h> |
| |
| #include <fake-dma-buffer/fake-dma-buffer.h> |
| |
| class ContiguousBufferImpl : public dma_buffer::ContiguousBuffer { |
| public: |
| ContiguousBufferImpl(size_t size, zx::vmo vmo, void* virt, zx_paddr_t phys, zx::pmt pmt) |
| : size_(size), virt_(virt), phys_(phys), vmo_(std::move(vmo)), pmt_(std::move(pmt)) {} |
| size_t size() const { return size_; } |
| void* virt() const { return virt_; } |
| |
| zx_paddr_t phys() const { return phys_; } |
| ~ContiguousBufferImpl() { |
| if (vmo_.is_valid()) { |
| delete reinterpret_cast<ddk_fake::FakePage*>(phys_); |
| } |
| } |
| |
| private: |
| size_t size_; |
| void* virt_; |
| zx_paddr_t phys_; |
| zx::vmo vmo_; |
| zx::pmt pmt_; |
| }; |
| |
| class PagedBufferImpl : public dma_buffer::PagedBuffer { |
| public: |
| PagedBufferImpl(size_t size, zx::vmo vmo, void* virt, std::vector<zx_paddr_t> phys, zx::pmt pmt) |
| : size_(size), virt_(virt), phys_(phys), vmo_(std::move(vmo)), pmt_(std::move(pmt)) {} |
| |
| size_t size() const override { return size_; } |
| void* virt() const override { return virt_; } |
| |
| const zx_paddr_t* phys() const override { return phys_.data(); } |
| |
| ~PagedBufferImpl() override { |
| if (vmo_.is_valid()) { |
| static_assert(sizeof(phys_[0]) == sizeof(ddk_fake::FakePage*)); |
| for (auto paddr : phys_) { |
| delete reinterpret_cast<ddk_fake::FakePage*>(paddr); |
| } |
| } |
| } |
| |
| private: |
| size_t size_; |
| void* virt_; |
| std::vector<zx_paddr_t> phys_; |
| zx::vmo vmo_; |
| zx::pmt pmt_; |
| }; |
| |
| class BufferFactoryImpl : public dma_buffer::BufferFactory { |
| zx_status_t CreateContiguous(const zx::bti& bti, size_t size, uint32_t alignment_log2, |
| std::unique_ptr<dma_buffer::ContiguousBuffer>* out) const override { |
| if (size > ZX_PAGE_SIZE) { |
| // TODO(fxbug.dev/45011): We don't currently support contiguous buffers > 1 page. |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| zx::vmo real_vmo; |
| zx_status_t status = zx::vmo::create(size, 0, &real_vmo); |
| if (status != ZX_OK) { |
| return status; |
| } |
| void* virt; |
| status = zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, real_vmo, 0, size, |
| reinterpret_cast<zx_vaddr_t*>(&virt)); |
| if (status != ZX_OK) { |
| return status; |
| } |
| auto fake = new ddk_fake::FakePage(); |
| fake->alignment_log2 = alignment_log2; |
| fake->enable_cache = true; |
| fake->size = size; |
| status = real_vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &fake->backing_storage); |
| if (status != ZX_OK) { |
| return status; |
| } |
| fake->virt = virt; |
| fake->contiguous = true; |
| fake->bti = bti.get(); |
| |
| auto buffer = std::make_unique<ContiguousBufferImpl>(size, std::move(real_vmo), virt, |
| reinterpret_cast<zx_paddr_t>(fake), |
| zx::pmt(ZX_HANDLE_INVALID)); |
| *out = std::move(buffer); |
| return ZX_OK; |
| } |
| zx_status_t CreatePaged(const zx::bti& bti, size_t size, bool enable_cache, |
| std::unique_ptr<dma_buffer::PagedBuffer>* out) const override { |
| zx::vmo real_vmo; |
| zx_status_t status = zx::vmo::create(size, 0, &real_vmo); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| uint8_t* virt; |
| status = zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, real_vmo, 0, size, |
| reinterpret_cast<zx_vaddr_t*>(&virt)); |
| if (status != ZX_OK) { |
| return status; |
| } |
| size_t pages = fbl::round_up(size, ZX_PAGE_SIZE) / ZX_PAGE_SIZE; |
| std::vector<zx_paddr_t> physvec; |
| physvec.resize(pages); |
| for (size_t i = 0; i < pages; i++) { |
| auto phys = new ddk_fake::FakePage(); |
| phys->enable_cache = enable_cache; |
| phys->size = size; |
| status = real_vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &phys->backing_storage); |
| if (status != ZX_OK) { |
| return status; |
| } |
| phys->virt = virt + (ZX_PAGE_SIZE * i); |
| phys->bti = bti.get(); |
| phys->contiguous = false; |
| physvec[i] = reinterpret_cast<zx_paddr_t>(phys); |
| } |
| auto buffer = std::make_unique<PagedBufferImpl>(size, std::move(real_vmo), virt, |
| std::move(physvec), zx::pmt(ZX_HANDLE_INVALID)); |
| *out = std::move(buffer); |
| return ZX_OK; |
| } |
| }; |
| |
| namespace ddk_fake { |
| |
| void* PhysToVirt(zx_paddr_t phys) { return PhysToVirt<void*>(phys); } |
| |
| const FakePage& GetPage(zx_paddr_t phys) { |
| size_t start = fbl::round_down(phys, ZX_PAGE_SIZE); |
| return *reinterpret_cast<FakePage*>(start); |
| } |
| |
| std::unique_ptr<dma_buffer::BufferFactory> CreateBufferFactory() { |
| return std::make_unique<BufferFactoryImpl>(); |
| } |
| |
| } // namespace ddk_fake |