PawletOS/external_libcamera
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

libcamera: dma_heaps: extend DmaHeap class to support system heap

Browse Source 
Add an argument to the constructor to specify dma heaps type(s)
to use. Can be DmaHeapFlag::Cma and/or DmaHeapFlag::System.
By default DmaHeapFlag::Cma is used. If both DmaHeapFlag::Cma and
DmaHeapFlag::System are set, CMA heap is tried first.

Tested-by: Bryan O'Donoghue <bryan.odonoghue@linaro.org> # sc8280xp Lenovo x13s
Tested-by: Pavel Machek <pavel@ucw.cz>
Reviewed-by: Milan Zamazal <mzamazal@redhat.com>
Reviewed-by: Pavel Machek <pavel@ucw.cz>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrey Konovalov <andrey.konovalov@linaro.org>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
This commit is contained in:
Andrey Konovalov
2024-04-16 11:13:39 +02:00
committed by Kieran Bingham
parent 6062ada2f5
commit 87ee158ec8
2 changed files with 69 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/libcamera/internal/dma_heaps.h
View File

@@ -9,6 +9,7 @@
#include <stddef.h>
#include <libcamera/base/flags.h>
#include <libcamera/base/unique_fd.h>
namespace libcamera {
@@ -16,7 +17,14 @@ namespace libcamera {
class DmaHeap
{
public:
DmaHeap();
enum class DmaHeapFlag {
Cma = 1 << 0,
System = 1 << 1,
};
using DmaHeapFlags = Flags<DmaHeapFlag>;
DmaHeap(DmaHeapFlags flags = DmaHeapFlag::Cma);
~DmaHeap();
bool isValid() const { return dmaHeapHandle_.isValid(); }
UniqueFD alloc(const char *name, std::size_t size);
@@ -25,4 +33,6 @@ private:
UniqueFD dmaHeapHandle_;
};
LIBCAMERA_FLAGS_ENABLE_OPERATORS(DmaHeap::DmaHeapFlag)
} /* namespace libcamera */

75
src/libcamera/dma_heaps.cpp
View File

@@ -19,9 +19,11 @@
/**
* \file dma_heaps.cpp
* \brief CMA dma-heap allocator
* \brief dma-heap allocator
*/
namespace libcamera {
/*
* /dev/dma_heap/linux,cma is the dma-heap allocator, which allows dmaheap-cma
* to only have to worry about importing.
@@ -29,40 +31,79 @@
* Annoyingly, should the cma heap size be specified on the kernel command line
* instead of DT, the heap gets named "reserved" instead.
*/
static constexpr std::array<const char *, 2> heapNames = {
"/dev/dma_heap/linux,cma",
"/dev/dma_heap/reserved"
};
namespace libcamera {
#ifndef __DOXYGEN__
struct DmaHeapInfo {
DmaHeap::DmaHeapFlag type;
const char *deviceNodeName;
};
#endif
static constexpr std::array<DmaHeapInfo, 3> heapInfos = { {
{ DmaHeap::DmaHeapFlag::Cma, "/dev/dma_heap/linux,cma" },
{ DmaHeap::DmaHeapFlag::Cma, "/dev/dma_heap/reserved" },
{ DmaHeap::DmaHeapFlag::System, "/dev/dma_heap/system" },
} };
LOG_DEFINE_CATEGORY(DmaHeap)
/**
* \class DmaHeap
* \brief Helper class for CMA dma-heap allocations
* \brief Helper class for dma-heap allocations
*
* DMA heaps are kernel devices that provide an API to allocate memory from
* different pools called "heaps", wrap each allocated piece of memory in a
* dmabuf object, and return the dmabuf file descriptor to userspace. Multiple
* heaps can be provided by the system, with different properties for the
* underlying memory.
*
* This class wraps a DMA heap selected at construction time, and exposes
* functions to manage memory allocation.
*/
/**
* \brief Construct a DmaHeap that owns a CMA dma-heap file descriptor
*
* Looks for a CMA dma-heap device to use. If it fails to open any dma-heap
* device, an invalid DmaHeap object is constructed.
*
* Check the new DmaHeap object with isValid before using it.
* \enum DmaHeap::DmaHeapFlag
* \brief Type of the dma-heap
* \var DmaHeap::Cma
* \brief Allocate from a CMA dma-heap, providing physically-contiguous memory
* \var DmaHeap::System
* \brief Allocate from the system dma-heap, using the page allocator
*/
DmaHeap::DmaHeap()
/**
* \typedef DmaHeap::DmaHeapFlags
* \brief A bitwise combination of DmaHeap::DmaHeapFlag values
*/
/**
* \brief Construct a DmaHeap of a given type
* \param[in] type The type(s) of the dma-heap(s) to allocate from
*
* The DMA heap type is selected with the \a type parameter, which defaults to
* the CMA heap. If no heap of the given type can be accessed, the constructed
* DmaHeap instance is invalid as indicated by the isValid() function.
*
* Multiple types can be selected by combining type flags, in which case the
* constructed DmaHeap will match one of the types. If the system provides
* multiple heaps that match the requested types, which heap is used is
* undefined.
*/
DmaHeap::DmaHeap(DmaHeapFlags type)
{
for (const char *name : heapNames) {
int ret = ::open(name, O_RDWR | O_CLOEXEC, 0);
for (const auto &info : heapInfos) {
if (!(type & info.type))
continue;
int ret = ::open(info.deviceNodeName, O_RDWR | O_CLOEXEC, 0);
if (ret < 0) {
ret = errno;
LOG(DmaHeap, Debug)
<< "Failed to open " << name << ": "
<< "Failed to open " << info.deviceNodeName << ": "
<< strerror(ret);
continue;
}
LOG(DmaHeap, Debug) << "Using " << info.deviceNodeName;
dmaHeapHandle_ = UniqueFD(ret);
break;
}