/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2021, Ideas on Board Oy * * drm.h - DRM/KMS Helpers */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace libcamera { class FrameBuffer; class PixelFormat; class Size; } /* namespace libcamera */ namespace DRM { class Device; class Plane; class Property; class PropertyValue; class Object { public: enum Type { TypeCrtc = DRM_MODE_OBJECT_CRTC, TypeConnector = DRM_MODE_OBJECT_CONNECTOR, TypeEncoder = DRM_MODE_OBJECT_ENCODER, TypeMode = DRM_MODE_OBJECT_MODE, TypeProperty = DRM_MODE_OBJECT_PROPERTY, TypeFb = DRM_MODE_OBJECT_FB, TypeBlob = DRM_MODE_OBJECT_BLOB, TypePlane = DRM_MODE_OBJECT_PLANE, TypeAny = DRM_MODE_OBJECT_ANY, }; Object(Device *dev, uint32_t id, Type type); virtual ~Object(); Device *device() const { return dev_; } uint32_t id() const { return id_; } Type type() const { return type_; } const Property *property(const std::string &name) const; const PropertyValue *propertyValue(const std::string &name) const; const std::vector &properties() const { return properties_; } protected: virtual int setup() { return 0; } uint32_t id_; private: friend Device; Device *dev_; Type type_; std::vector properties_; }; class Property : public Object { public: enum Type { TypeUnknown = 0, TypeRange, TypeEnum, TypeBlob, TypeBitmask, TypeObject, TypeSignedRange, }; Property(Device *dev, drmModePropertyRes *property); Type type() const { return type_; } const std::string &name() const { return name_; } bool isImmutable() const { return flags_ & DRM_MODE_PROP_IMMUTABLE; } const std::vector values() const { return values_; } const std::map &enums() const { return enums_; } const std::vector blobs() const { return blobs_; } private: Type type_; std::string name_; uint32_t flags_; std::vector values_; std::map enums_; std::vector blobs_; }; class PropertyValue { public: PropertyValue(uint32_t id, uint64_t value) : id_(id), value_(value) { } uint32_t id() const { return id_; } uint32_t value() const { return value_; } private: uint32_t id_; uint64_t value_; }; class Blob : public Object { public: Blob(Device *dev, const libcamera::Span &data); ~Blob(); bool isValid() const { return id() != 0; } }; class Mode : public drmModeModeInfo { public: Mode(const drmModeModeInfo &mode); std::unique_ptr toBlob(Device *dev) const; }; class Crtc : public Object { public: Crtc(Device *dev, const drmModeCrtc *crtc, unsigned int index); unsigned int index() const { return index_; } const std::vector &planes() const { return planes_; } private: friend Device; unsigned int index_; std::vector planes_; }; class Encoder : public Object { public: Encoder(Device *dev, const drmModeEncoder *encoder); uint32_t type() const { return type_; } const std::vector &possibleCrtcs() const { return possibleCrtcs_; } private: uint32_t type_; std::vector possibleCrtcs_; }; class Connector : public Object { public: enum Status { Connected, Disconnected, Unknown, }; Connector(Device *dev, const drmModeConnector *connector); uint32_t type() const { return type_; } const std::string &name() const { return name_; } Status status() const { return status_; } const std::vector &encoders() const { return encoders_; } const std::vector &modes() const { return modes_; } private: uint32_t type_; std::string name_; Status status_; std::vector encoders_; std::vector modes_; }; class Plane : public Object { public: enum Type { TypeOverlay, TypePrimary, TypeCursor, }; Plane(Device *dev, const drmModePlane *plane); Type type() const { return type_; } const std::vector &formats() const { return formats_; } const std::vector &possibleCrtcs() const { return possibleCrtcs_; } bool supportsFormat(const libcamera::PixelFormat &format) const; protected: int setup() override; private: friend class Device; Type type_; std::vector formats_; std::vector possibleCrtcs_; uint32_t possibleCrtcsMask_; }; class FrameBuffer : public Object { public: struct Plane { uint32_t handle; }; ~FrameBuffer(); private: friend class Device; FrameBuffer(Device *dev); std::map planes_; }; class AtomicRequest { public: enum Flags { FlagAllowModeset = (1 << 0), FlagAsync = (1 << 1), FlagTestOnly = (1 << 2), }; AtomicRequest(Device *dev); ~AtomicRequest(); Device *device() const { return dev_; } bool isValid() const { return valid_; } int addProperty(const Object *object, const std::string &property, uint64_t value); int addProperty(const Object *object, const std::string &property, std::unique_ptr blob); int commit(unsigned int flags = 0); private: AtomicRequest(const AtomicRequest &) = delete; AtomicRequest(const AtomicRequest &&) = delete; AtomicRequest &operator=(const AtomicRequest &) = delete; AtomicRequest &operator=(const AtomicRequest &&) = delete; int addProperty(uint32_t object, uint32_t property, uint64_t value); Device *dev_; bool valid_; drmModeAtomicReq *request_; std::list> blobs_; }; class Device { public: Device(); ~Device(); int init(); int fd() const { return fd_; } const std::list &crtcs() const { return crtcs_; } const std::list &encoders() const { return encoders_; } const std::list &connectors() const { return connectors_; } const std::list &planes() const { return planes_; } const std::list &properties() const { return properties_; } const Object *object(uint32_t id); std::unique_ptr createFrameBuffer( const libcamera::FrameBuffer &buffer, const libcamera::PixelFormat &format, const libcamera::Size &size, const std::array &strides); libcamera::Signal requestComplete; private: Device(const Device &) = delete; Device(const Device &&) = delete; Device &operator=(const Device &) = delete; Device &operator=(const Device &&) = delete; int openCard(); int getResources(); void drmEvent(); static void pageFlipComplete(int fd, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data); int fd_; std::list crtcs_; std::list encoders_; std::list connectors_; std::list planes_; std::list properties_; std::map objects_; }; } /* namespace DRM */ >128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2021, Google Inc.
 *
 * fence.cpp - Fence test
 */

#include <iostream>
#include <memory>
#include <sys/eventfd.h>
#include <unistd.h>

#include <libcamera/base/event_dispatcher.h>
#include <libcamera/base/thread.h>
#include <libcamera/base/timer.h>
#include <libcamera/base/unique_fd.h>
#include <libcamera/base/utils.h>

#include <libcamera/fence.h>
#include <libcamera/framebuffer_allocator.h>

#include "camera_test.h"
#include "test.h"

using namespace libcamera;
using namespace std;
using namespace std::chrono_literals;

class FenceTest : public CameraTest, public Test
{
public:
	FenceTest();

protected:
	int init() override;
	int run() override;

private:
	int validateExpiredRequest(Request *request);
	int validateRequest(Request *request);
	void requestComplete(Request *request);
	void requestRequeue(Request *request);

	void signalFence();

	std::unique_ptr<Fence> fence_;
	EventDispatcher *dispatcher_;
	UniqueFD eventFd_;
	UniqueFD eventFd2_;
	Timer fenceTimer_;

	std::vector<std::unique_ptr<Request>> requests_;
	std::unique_ptr<CameraConfiguration> config_;
	std::unique_ptr<FrameBufferAllocator> allocator_;

	Stream *stream_;

	bool expectedCompletionResult_ = true;
	bool setFence_ = true;

	unsigned int completedRequest_;

	unsigned int signalledRequestId_;
	unsigned int expiredRequestId_;
	unsigned int nbuffers_;

	int efd2_;
	int efd_;
};

FenceTest::FenceTest()
	: CameraTest("platform/vimc.0 Sensor B")
{
}

int FenceTest::init()
{
	/* Make sure the CameraTest constructor succeeded. */
	if (status_ != TestPass)
		return status_;

	dispatcher_ = Thread::current()->eventDispatcher();

	/*
	 * Create two eventfds to model the fences. This is enough to support the
	 * needs of libcamera which only needs to wait for read events through
	 * poll(). Once native support for fences will be available in the
	 * backend kernel APIs this will need to be replaced by a sw_sync fence,
	 * but that requires debugfs.
	 */
	eventFd_ = UniqueFD(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
	eventFd2_ = UniqueFD(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
	if (!eventFd_.isValid() || !eventFd2_.isValid()) {
		cerr << "Unable to create eventfd" << endl;
		return TestFail;
	}

	efd_ = eventFd_.get();
	efd2_ = eventFd2_.get();

	config_ = camera_->generateConfiguration({ StreamRole::Viewfinder });
	if (!config_ || config_->size() != 1) {
		cerr << "Failed to generate default configuration" << endl;
		return TestFail;
	}

	if (camera_->acquire()) {
		cerr << "Failed to acquire the camera" << endl;
		return TestFail;
	}

	if (camera_->configure(config_.get())) {
		cerr << "Failed to set default configuration" << endl;
		return TestFail;
	}

	StreamConfiguration &cfg = config_->at(0);
	stream_ = cfg.stream();

	allocator_ = std::make_unique<FrameBufferAllocator>(camera_);
	if (allocator_->allocate(stream_) < 0)
		return TestFail;

	nbuffers_ = allocator_->buffers(stream_).size();
	if (nbuffers_ < 2) {
		cerr << "Not enough buffers available" << endl;
		return TestFail;
	}

	signalledRequestId_ = nbuffers_ - 2;
	expiredRequestId_ = nbuffers_ - 1;

	return TestPass;
}

int FenceTest::validateExpiredRequest(Request *request)
{
	/* The last request is expected to fail. */
	if (request->status() != Request::RequestCancelled) {
		cerr << "The last request should have failed: " << endl;
		return TestFail;
	}

	FrameBuffer *buffer = request->buffers().begin()->second;
	std::unique_ptr<Fence> fence = buffer->releaseFence();
	if (!fence) {
		cerr << "The expired fence should be present" << endl;
		return TestFail;
	}

	if (!fence->isValid()) {
		cerr << "The expired fence should be valid" << endl;
		return TestFail;
	}

	UniqueFD fd = fence->release();
	if (fd.get() != efd_) {
		cerr << "The expired fence file descriptor should not change" << endl;
		return TestFail;
	}

	return TestPass;
}

int FenceTest::validateRequest(Request *request)
{
	uint64_t cookie = request->cookie();

	/* All requests but the last are expected to succeed. */
	if (request->status() != Request::RequestComplete) {
		cerr << "Unexpected request failure: " << cookie << endl;
		return TestFail;
	}

	/* A successfully completed request should have the Fence closed. */
	const Request::BufferMap &buffers = request->buffers();
	FrameBuffer *buffer = buffers.begin()->second;

	std::unique_ptr<Fence> bufferFence = buffer->releaseFence();
	if (bufferFence) {
		cerr << "Unexpected valid fence in completed request" << endl;
		return TestFail;
	}

	return TestPass;
}

void FenceTest::requestRequeue(Request *request)
{
	const Request::BufferMap &buffers = request->buffers();
	const Stream *stream = buffers.begin()->first;
	FrameBuffer *buffer = buffers.begin()->second;
	uint64_t cookie = request->cookie();

	request->reuse();

	if (cookie == signalledRequestId_ && setFence_) {
		/*
		 * The second time this request is queued add a fence to it.
		 *
		 * The main loop signals it by using a timer to write to the
		 * efd2_ file descriptor before the fence expires.
		 */
		std::unique_ptr<Fence> fence =
			std::make_unique<Fence>(std::move(eventFd2_));
		request->addBuffer(stream, buffer, std::move(fence));
	} else {
		/* All the other requests continue to operate without fences. */
		request->addBuffer(stream, buffer);
	}

	camera_->queueRequest(request);
}

void FenceTest::requestComplete(Request *request)
{
	uint64_t cookie = request->cookie();
	completedRequest_ = cookie;

	/*
	 * The last request is expected to fail as its fence has not been
	 * signaled.
	 *
	 * Validate the fence status but do not re-queue it.
	 */
	if (cookie == expiredRequestId_) {
		if (validateExpiredRequest(request) != TestPass)
			expectedCompletionResult_ = false;

		dispatcher_->interrupt();
		return;
	}

	/* Validate all requests but the last. */
	if (validateRequest(request) != TestPass) {
		expectedCompletionResult_ = false;

		dispatcher_->interrupt();
		return;
	}

	requestRequeue(request);

	/*
	 * Interrupt the dispatcher to return control to the main loop and
	 * activate the fenceTimer.
	 */
	dispatcher_->interrupt();
}

/* Callback to signal a fence waiting on the eventfd file descriptor. */
void FenceTest::signalFence()
{
	uint64_t value = 1;
	int ret;

	ret = write(efd2_, &value, sizeof(value));
	if (ret != sizeof(value))
		cerr << "Failed to signal fence" << endl;

	setFence_ = false;
	dispatcher_->processEvents();
}

int FenceTest::run()
{
	for (const auto &[i, buffer] : utils::enumerate(allocator_->buffers(stream_))) {
		std::unique_ptr<Request> request = camera_->createRequest(i);
		if (!request) {
			cerr << "Failed to create request" << endl;
			return TestFail;
		}

		int ret;
		if (i == expiredRequestId_) {
			/* This request will have a fence, and it will expire. */
			fence_ = std::make_unique<Fence>(std::move(eventFd_));
			if (!fence_->isValid()) {
				cerr << "Fence should be valid" << endl;
				return TestFail;
			}