Merge "libcutils: reimplement system property functions with libbase." am: 95e79c63a4 am: 854b9898ae am: 10b59d4044 am: 6f75222685 am: 6d00a7dcd5
Change-Id: Ib1ce5b5fb61c4f7e01048af8b6d29efe0ef80335
diff --git a/adb/client/incremental.cpp b/adb/client/incremental.cpp
index e30f384..a8b0ab3 100644
--- a/adb/client/incremental.cpp
+++ b/adb/client/incremental.cpp
@@ -16,13 +16,13 @@
#include "incremental.h"
-#include <android-base/endian.h>
+#include "incremental_utils.h"
+
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <openssl/base64.h>
#include "adb_client.h"
-#include "adb_io.h"
#include "adb_utils.h"
#include "commandline.h"
#include "sysdeps.h"
@@ -31,65 +31,8 @@
namespace incremental {
-namespace {
-
-static constexpr auto IDSIG = ".idsig"sv;
-
using android::base::StringPrintf;
-using Size = int64_t;
-
-static inline int32_t read_int32(borrowed_fd fd) {
- int32_t result;
- return ReadFdExactly(fd, &result, sizeof(result)) ? result : -1;
-}
-
-static inline void append_int(borrowed_fd fd, std::vector<char>* bytes) {
- int32_t le_val = read_int32(fd);
- auto old_size = bytes->size();
- bytes->resize(old_size + sizeof(le_val));
- memcpy(bytes->data() + old_size, &le_val, sizeof(le_val));
-}
-
-static inline void append_bytes_with_size(borrowed_fd fd, std::vector<char>* bytes) {
- int32_t le_size = read_int32(fd);
- if (le_size < 0) {
- return;
- }
- int32_t size = int32_t(le32toh(le_size));
- auto old_size = bytes->size();
- bytes->resize(old_size + sizeof(le_size) + size);
- memcpy(bytes->data() + old_size, &le_size, sizeof(le_size));
- ReadFdExactly(fd, bytes->data() + old_size + sizeof(le_size), size);
-}
-
-static inline std::pair<std::vector<char>, int32_t> read_id_sig_headers(borrowed_fd fd) {
- std::vector<char> result;
- append_int(fd, &result); // version
- append_bytes_with_size(fd, &result); // hashingInfo
- append_bytes_with_size(fd, &result); // signingInfo
- auto le_tree_size = read_int32(fd);
- auto tree_size = int32_t(le32toh(le_tree_size)); // size of the verity tree
- return {std::move(result), tree_size};
-}
-
-static inline Size verity_tree_size_for_file(Size fileSize) {
- constexpr int INCFS_DATA_FILE_BLOCK_SIZE = 4096;
- constexpr int SHA256_DIGEST_SIZE = 32;
- constexpr int digest_size = SHA256_DIGEST_SIZE;
- constexpr int hash_per_block = INCFS_DATA_FILE_BLOCK_SIZE / digest_size;
-
- Size total_tree_block_count = 0;
-
- auto block_count = 1 + (fileSize - 1) / INCFS_DATA_FILE_BLOCK_SIZE;
- auto hash_block_count = block_count;
- for (auto i = 0; hash_block_count > 1; i++) {
- hash_block_count = (hash_block_count + hash_per_block - 1) / hash_per_block;
- total_tree_block_count += hash_block_count;
- }
- return total_tree_block_count * INCFS_DATA_FILE_BLOCK_SIZE;
-}
-
// Read, verify and return the signature bytes. Keeping fd at the position of start of verity tree.
static std::pair<unique_fd, std::vector<char>> read_signature(Size file_size,
std::string signature_file,
@@ -104,7 +47,7 @@
return {};
}
- unique_fd fd(adb_open(signature_file.c_str(), O_RDONLY | O_CLOEXEC));
+ unique_fd fd(adb_open(signature_file.c_str(), O_RDONLY));
if (fd < 0) {
if (!silent) {
fprintf(stderr, "Failed to open signature file: %s. Abort.\n", signature_file.c_str());
@@ -170,9 +113,8 @@
return {};
}
- auto file_desc =
- StringPrintf("%s:%lld:%s:%s", android::base::Basename(file).c_str(),
- (long long)st.st_size, std::to_string(i).c_str(), signature.c_str());
+ auto file_desc = StringPrintf("%s:%lld:%d:%s:1", android::base::Basename(file).c_str(),
+ (long long)st.st_size, i, signature.c_str());
command_args.push_back(std::move(file_desc));
}
@@ -186,21 +128,9 @@
return {};
}
- // Pushing verity trees for all installation files.
- for (auto&& local_fd : signature_fds) {
- if (!copy_to_file(local_fd.get(), connection_fd.get())) {
- if (!silent) {
- fprintf(stderr, "Failed to stream tree bytes: %s. Abort.\n", strerror(errno));
- }
- return {};
- }
- }
-
return connection_fd;
}
-} // namespace
-
bool can_install(const Files& files) {
for (const auto& file : files) {
struct stat st;
diff --git a/adb/client/incremental_server.cpp b/adb/client/incremental_server.cpp
index 4a131ce..bfe18c0 100644
--- a/adb/client/incremental_server.cpp
+++ b/adb/client/incremental_server.cpp
@@ -1,4 +1,4 @@
-/*
+/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -44,9 +44,10 @@
namespace incremental {
-static constexpr int kBlockSize = 4096;
+static constexpr int kHashesPerBlock = kBlockSize / kDigestSize;
static constexpr int kCompressedSizeMax = kBlockSize * 0.95;
static constexpr int8_t kTypeData = 0;
+static constexpr int8_t kTypeHash = 1;
static constexpr int8_t kCompressionNone = 0;
static constexpr int8_t kCompressionLZ4 = 1;
static constexpr int kCompressBound = std::max(kBlockSize, LZ4_COMPRESSBOUND(kBlockSize));
@@ -132,41 +133,64 @@
CompressionType compression_type; // 1 byte
BlockIdx block_idx; // 4 bytes
BlockSize block_size; // 2 bytes
+
+ static constexpr size_t responseSizeFor(size_t dataSize) {
+ return dataSize + sizeof(ResponseHeader);
+ }
+} __attribute__((packed));
+
+template <size_t Size = kBlockSize>
+struct BlockBuffer {
+ ResponseHeader header;
+ char data[Size];
} __attribute__((packed));
// Holds streaming state for a file
class File {
public:
// Plain file
- File(const char* filepath, FileId id, int64_t size, unique_fd fd) : File(filepath, id, size) {
+ File(const char* filepath, FileId id, int64_t size, unique_fd fd, int64_t tree_offset,
+ unique_fd tree_fd)
+ : File(filepath, id, size, tree_offset) {
this->fd_ = std::move(fd);
+ this->tree_fd_ = std::move(tree_fd);
priority_blocks_ = PriorityBlocksForFile(filepath, fd_.get(), size);
}
- int64_t ReadBlock(BlockIdx block_idx, void* buf, bool* is_zip_compressed,
- std::string* error) const {
- char* buf_ptr = static_cast<char*>(buf);
+ int64_t ReadDataBlock(BlockIdx block_idx, void* buf, bool* is_zip_compressed) const {
int64_t bytes_read = -1;
const off64_t offsetStart = blockIndexToOffset(block_idx);
- bytes_read = adb_pread(fd_, &buf_ptr[sizeof(ResponseHeader)], kBlockSize, offsetStart);
+ bytes_read = adb_pread(fd_, buf, kBlockSize, offsetStart);
+ return bytes_read;
+ }
+ int64_t ReadTreeBlock(BlockIdx block_idx, void* buf) const {
+ int64_t bytes_read = -1;
+ const off64_t offsetStart = tree_offset_ + blockIndexToOffset(block_idx);
+ bytes_read = adb_pread(tree_fd_, buf, kBlockSize, offsetStart);
return bytes_read;
}
- const unique_fd& RawFd() const { return fd_; }
const std::vector<BlockIdx>& PriorityBlocks() const { return priority_blocks_; }
std::vector<bool> sentBlocks;
NumBlocks sentBlocksCount = 0;
+ std::vector<bool> sentTreeBlocks;
+
const char* const filepath;
const FileId id;
const int64_t size;
private:
- File(const char* filepath, FileId id, int64_t size) : filepath(filepath), id(id), size(size) {
+ File(const char* filepath, FileId id, int64_t size, int64_t tree_offset)
+ : filepath(filepath), id(id), size(size), tree_offset_(tree_offset) {
sentBlocks.resize(numBytesToNumBlocks(size));
+ sentTreeBlocks.resize(verity_tree_blocks_for_file(size));
}
unique_fd fd_;
std::vector<BlockIdx> priority_blocks_;
+
+ unique_fd tree_fd_;
+ const int64_t tree_offset_;
};
class IncrementalServer {
@@ -174,6 +198,8 @@
IncrementalServer(unique_fd adb_fd, unique_fd output_fd, std::vector<File> files)
: adb_fd_(std::move(adb_fd)), output_fd_(std::move(output_fd)), files_(std::move(files)) {
buffer_.reserve(kReadBufferSize);
+ pendingBlocksBuffer_.resize(kChunkFlushSize + 2 * kBlockSize);
+ pendingBlocks_ = pendingBlocksBuffer_.data() + sizeof(ChunkHeader);
}
bool Serve();
@@ -208,7 +234,11 @@
void erase_buffer_head(int count) { buffer_.erase(buffer_.begin(), buffer_.begin() + count); }
enum class SendResult { Sent, Skipped, Error };
- SendResult SendBlock(FileId fileId, BlockIdx blockIdx, bool flush = false);
+ SendResult SendDataBlock(FileId fileId, BlockIdx blockIdx, bool flush = false);
+
+ bool SendTreeBlock(FileId fileId, int32_t fileBlockIdx, BlockIdx blockIdx);
+ bool SendTreeBlocksForDataBlock(FileId fileId, BlockIdx blockIdx);
+
bool SendDone();
void RunPrefetching();
@@ -228,7 +258,10 @@
int compressed_ = 0, uncompressed_ = 0;
long long sentSize_ = 0;
- std::vector<char> pendingBlocks_;
+ static constexpr auto kChunkFlushSize = 31 * kBlockSize;
+
+ std::vector<char> pendingBlocksBuffer_;
+ char* pendingBlocks_ = nullptr;
// True when client notifies that all the data has been received
bool servingComplete_ = false;
@@ -250,7 +283,7 @@
if (bcur > 0) {
// output the rest.
- WriteFdExactly(output_fd_, buffer_.data(), bcur);
+ (void)WriteFdExactly(output_fd_, buffer_.data(), bcur);
erase_buffer_head(bcur);
}
@@ -265,9 +298,10 @@
auto res = adb_poll(&pfd, 1, blocking ? kPollTimeoutMillis : 0);
if (res != 1) {
- WriteFdExactly(output_fd_, buffer_.data(), buffer_.size());
+ auto err = errno;
+ (void)WriteFdExactly(output_fd_, buffer_.data(), buffer_.size());
if (res < 0) {
- D("Failed to poll: %s\n", strerror(errno));
+ D("Failed to poll: %s", strerror(err));
return false;
}
if (blocking) {
@@ -289,7 +323,7 @@
continue;
}
- D("Failed to read from fd %d: %d. Exit\n", adb_fd_.get(), errno);
+ D("Failed to read from fd %d: %d. Exit", adb_fd_.get(), errno);
break;
}
// socket is closed. print remaining messages
@@ -313,56 +347,113 @@
return request;
}
-auto IncrementalServer::SendBlock(FileId fileId, BlockIdx blockIdx, bool flush) -> SendResult {
+bool IncrementalServer::SendTreeBlocksForDataBlock(const FileId fileId, const BlockIdx blockIdx) {
+ auto& file = files_[fileId];
+ const int32_t data_block_count = numBytesToNumBlocks(file.size);
+
+ const int32_t total_nodes_count(file.sentTreeBlocks.size());
+ const int32_t leaf_nodes_count = (data_block_count + kHashesPerBlock - 1) / kHashesPerBlock;
+
+ const int32_t leaf_nodes_offset = total_nodes_count - leaf_nodes_count;
+
+ // Leaf level, sending only 1 block.
+ const int32_t leaf_idx = leaf_nodes_offset + blockIdx / kHashesPerBlock;
+ if (file.sentTreeBlocks[leaf_idx]) {
+ return true;
+ }
+ if (!SendTreeBlock(fileId, blockIdx, leaf_idx)) {
+ return false;
+ }
+ file.sentTreeBlocks[leaf_idx] = true;
+
+ // Non-leaf, sending EVERYTHING. This should be done only once.
+ if (leaf_nodes_offset == 0 || file.sentTreeBlocks[0]) {
+ return true;
+ }
+
+ for (int32_t i = 0; i < leaf_nodes_offset; ++i) {
+ if (!SendTreeBlock(fileId, blockIdx, i)) {
+ return false;
+ }
+ file.sentTreeBlocks[i] = true;
+ }
+ return true;
+}
+
+bool IncrementalServer::SendTreeBlock(FileId fileId, int32_t fileBlockIdx, BlockIdx blockIdx) {
+ const auto& file = files_[fileId];
+
+ BlockBuffer buffer;
+ const int64_t bytesRead = file.ReadTreeBlock(blockIdx, buffer.data);
+ if (bytesRead <= 0) {
+ fprintf(stderr, "Failed to get data for %s.idsig at blockIdx=%d.\n", file.filepath,
+ blockIdx);
+ return false;
+ }
+
+ buffer.header.compression_type = kCompressionNone;
+ buffer.header.block_type = kTypeHash;
+ buffer.header.file_id = toBigEndian(fileId);
+ buffer.header.block_size = toBigEndian(int16_t(bytesRead));
+ buffer.header.block_idx = toBigEndian(blockIdx);
+
+ Send(&buffer, ResponseHeader::responseSizeFor(bytesRead), /*flush=*/false);
+
+ return true;
+}
+
+auto IncrementalServer::SendDataBlock(FileId fileId, BlockIdx blockIdx, bool flush) -> SendResult {
auto& file = files_[fileId];
if (blockIdx >= static_cast<long>(file.sentBlocks.size())) {
- fprintf(stderr, "Failed to read file %s at block %" PRId32 " (past end).\n", file.filepath,
- blockIdx);
- return SendResult::Error;
+ // may happen as we schedule some extra blocks for reported page misses
+ D("Skipped reading file %s at block %" PRId32 " (past end).", file.filepath, blockIdx);
+ return SendResult::Skipped;
}
if (file.sentBlocks[blockIdx]) {
return SendResult::Skipped;
}
- std::string error;
- char raw[sizeof(ResponseHeader) + kBlockSize];
- bool isZipCompressed = false;
- const int64_t bytesRead = file.ReadBlock(blockIdx, &raw, &isZipCompressed, &error);
- if (bytesRead < 0) {
- fprintf(stderr, "Failed to get data for %s at blockIdx=%d (%s).\n", file.filepath, blockIdx,
- error.c_str());
+
+ if (!SendTreeBlocksForDataBlock(fileId, blockIdx)) {
return SendResult::Error;
}
- ResponseHeader* header = nullptr;
- char data[sizeof(ResponseHeader) + kCompressBound];
- char* compressed = data + sizeof(*header);
+ BlockBuffer raw;
+ bool isZipCompressed = false;
+ const int64_t bytesRead = file.ReadDataBlock(blockIdx, raw.data, &isZipCompressed);
+ if (bytesRead < 0) {
+ fprintf(stderr, "Failed to get data for %s at blockIdx=%d (%d).\n", file.filepath, blockIdx,
+ errno);
+ return SendResult::Error;
+ }
+
+ BlockBuffer<kCompressBound> compressed;
int16_t compressedSize = 0;
if (!isZipCompressed) {
- compressedSize =
- LZ4_compress_default(raw + sizeof(*header), compressed, bytesRead, kCompressBound);
+ compressedSize = LZ4_compress_default(raw.data, compressed.data, bytesRead, kCompressBound);
}
int16_t blockSize;
+ ResponseHeader* header;
if (compressedSize > 0 && compressedSize < kCompressedSizeMax) {
++compressed_;
blockSize = compressedSize;
- header = reinterpret_cast<ResponseHeader*>(data);
+ header = &compressed.header;
header->compression_type = kCompressionLZ4;
} else {
++uncompressed_;
blockSize = bytesRead;
- header = reinterpret_cast<ResponseHeader*>(raw);
+ header = &raw.header;
header->compression_type = kCompressionNone;
}
header->block_type = kTypeData;
-
header->file_id = toBigEndian(fileId);
header->block_size = toBigEndian(blockSize);
header->block_idx = toBigEndian(blockIdx);
file.sentBlocks[blockIdx] = true;
file.sentBlocksCount += 1;
- Send(header, sizeof(*header) + blockSize, flush);
+ Send(header, ResponseHeader::responseSizeFor(blockSize), flush);
+
return SendResult::Sent;
}
@@ -388,7 +479,8 @@
if (!priority_blocks.empty()) {
for (auto& i = prefetch.priorityIndex;
blocksToSend > 0 && i < (BlockIdx)priority_blocks.size(); ++i) {
- if (auto res = SendBlock(file.id, priority_blocks[i]); res == SendResult::Sent) {
+ if (auto res = SendDataBlock(file.id, priority_blocks[i]);
+ res == SendResult::Sent) {
--blocksToSend;
} else if (res == SendResult::Error) {
fprintf(stderr, "Failed to send priority block %" PRId32 "\n", i);
@@ -396,7 +488,7 @@
}
}
for (auto& i = prefetch.overallIndex; blocksToSend > 0 && i < prefetch.overallEnd; ++i) {
- if (auto res = SendBlock(file.id, i); res == SendResult::Sent) {
+ if (auto res = SendDataBlock(file.id, i); res == SendResult::Sent) {
--blocksToSend;
} else if (res == SendResult::Error) {
fprintf(stderr, "Failed to send block %" PRId32 "\n", i);
@@ -409,30 +501,25 @@
}
void IncrementalServer::Send(const void* data, size_t size, bool flush) {
- constexpr auto kChunkFlushSize = 31 * kBlockSize;
-
- if (pendingBlocks_.empty()) {
- pendingBlocks_.resize(sizeof(ChunkHeader));
- }
- pendingBlocks_.insert(pendingBlocks_.end(), static_cast<const char*>(data),
- static_cast<const char*>(data) + size);
- if (flush || pendingBlocks_.size() > kChunkFlushSize) {
+ pendingBlocks_ = std::copy_n(static_cast<const char*>(data), size, pendingBlocks_);
+ if (flush || pendingBlocks_ - pendingBlocksBuffer_.data() > kChunkFlushSize) {
Flush();
}
}
void IncrementalServer::Flush() {
- if (pendingBlocks_.empty()) {
+ auto dataBytes = pendingBlocks_ - (pendingBlocksBuffer_.data() + sizeof(ChunkHeader));
+ if (dataBytes == 0) {
return;
}
- *(ChunkHeader*)pendingBlocks_.data() =
- toBigEndian<int32_t>(pendingBlocks_.size() - sizeof(ChunkHeader));
- if (!WriteFdExactly(adb_fd_, pendingBlocks_.data(), pendingBlocks_.size())) {
- fprintf(stderr, "Failed to write %d bytes\n", int(pendingBlocks_.size()));
+ *(ChunkHeader*)pendingBlocksBuffer_.data() = toBigEndian<int32_t>(dataBytes);
+ auto totalBytes = sizeof(ChunkHeader) + dataBytes;
+ if (!WriteFdExactly(adb_fd_, pendingBlocksBuffer_.data(), totalBytes)) {
+ fprintf(stderr, "Failed to write %d bytes\n", int(totalBytes));
}
- sentSize_ += pendingBlocks_.size();
- pendingBlocks_.clear();
+ sentSize_ += totalBytes;
+ pendingBlocks_ = pendingBlocksBuffer_.data() + sizeof(ChunkHeader);
}
bool IncrementalServer::ServingComplete(std::optional<TimePoint> startTime, int missesCount,
@@ -443,7 +530,7 @@
D("Streaming completed.\n"
"Misses: %d, of those unique: %d; sent compressed: %d, uncompressed: "
"%d, mb: %.3f\n"
- "Total time taken: %.3fms\n",
+ "Total time taken: %.3fms",
missesCount, missesSent, compressed_, uncompressed_, sentSize_ / 1024.0 / 1024.0,
duration_cast<microseconds>(endTime - (startTime ? *startTime : endTime)).count() / 1000.0);
return true;
@@ -510,9 +597,21 @@
fileId, blockIdx);
break;
}
- // fprintf(stderr, "\treading file %d block %04d\n", (int)fileId,
- // (int)blockIdx);
- if (auto res = SendBlock(fileId, blockIdx, true); res == SendResult::Error) {
+
+ if (VLOG_IS_ON(INCREMENTAL)) {
+ auto& file = files_[fileId];
+ auto posP = std::find(file.PriorityBlocks().begin(),
+ file.PriorityBlocks().end(), blockIdx);
+ D("\tMISSING BLOCK: reading file %d block %04d (in priority: %d of %d)",
+ (int)fileId, (int)blockIdx,
+ posP == file.PriorityBlocks().end()
+ ? -1
+ : int(posP - file.PriorityBlocks().begin()),
+ int(file.PriorityBlocks().size()));
+ }
+
+ if (auto res = SendDataBlock(fileId, blockIdx, true);
+ res == SendResult::Error) {
fprintf(stderr, "Failed to send block %" PRId32 ".\n", blockIdx);
} else if (res == SendResult::Sent) {
++missesSent;
@@ -536,7 +635,7 @@
fileId);
break;
}
- D("Received prefetch request for file_id %" PRId16 ".\n", fileId);
+ D("Received prefetch request for file_id %" PRId16 ".", fileId);
prefetches_.emplace_back(files_[fileId]);
break;
}
@@ -551,6 +650,43 @@
}
}
+static std::pair<unique_fd, int64_t> open_fd(const char* filepath) {
+ struct stat st;
+ if (stat(filepath, &st)) {
+ error_exit("inc-server: failed to stat input file '%s'.", filepath);
+ }
+
+ unique_fd fd(adb_open(filepath, O_RDONLY));
+ if (fd < 0) {
+ error_exit("inc-server: failed to open file '%s'.", filepath);
+ }
+
+ return {std::move(fd), st.st_size};
+}
+
+static std::pair<unique_fd, int64_t> open_signature(int64_t file_size, const char* filepath) {
+ std::string signature_file(filepath);
+ signature_file += IDSIG;
+
+ unique_fd fd(adb_open(signature_file.c_str(), O_RDONLY));
+ if (fd < 0) {
+ error_exit("inc-server: failed to open file '%s'.", signature_file.c_str());
+ }
+
+ auto [tree_offset, tree_size] = skip_id_sig_headers(fd);
+ if (auto expected = verity_tree_size_for_file(file_size); tree_size != expected) {
+ error_exit("Verity tree size mismatch in signature file: %s [was %lld, expected %lld].\n",
+ signature_file.c_str(), (long long)tree_size, (long long)expected);
+ }
+
+ int32_t data_block_count = numBytesToNumBlocks(file_size);
+ int32_t leaf_nodes_count = (data_block_count + kHashesPerBlock - 1) / kHashesPerBlock;
+ D("Verity tree loaded: %s, tree size: %d (%d blocks, %d leafs)", signature_file.c_str(),
+ int(tree_size), int(numBytesToNumBlocks(tree_size)), int(leaf_nodes_count));
+
+ return {std::move(fd), tree_offset};
+}
+
bool serve(int connection_fd, int output_fd, int argc, const char** argv) {
auto connection_ufd = unique_fd(connection_fd);
auto output_ufd = unique_fd(output_fd);
@@ -563,17 +699,11 @@
for (int i = 0; i < argc; ++i) {
auto filepath = argv[i];
- struct stat st;
- if (stat(filepath, &st)) {
- fprintf(stderr, "Failed to stat input file %s. Abort.\n", filepath);
- return {};
- }
+ auto [file_fd, file_size] = open_fd(filepath);
+ auto [sign_fd, sign_offset] = open_signature(file_size, filepath);
- unique_fd fd(adb_open(filepath, O_RDONLY));
- if (fd < 0) {
- error_exit("inc-server: failed to open file '%s'.", filepath);
- }
- files.emplace_back(filepath, i, st.st_size, std::move(fd));
+ files.emplace_back(filepath, i, file_size, std::move(file_fd), sign_offset,
+ std::move(sign_fd));
}
IncrementalServer server(std::move(connection_ufd), std::move(output_ufd), std::move(files));
diff --git a/adb/client/incremental_utils.cpp b/adb/client/incremental_utils.cpp
index fa501e4..dd117d2 100644
--- a/adb/client/incremental_utils.cpp
+++ b/adb/client/incremental_utils.cpp
@@ -18,6 +18,7 @@
#include "incremental_utils.h"
+#include <android-base/endian.h>
#include <android-base/mapped_file.h>
#include <android-base/strings.h>
#include <ziparchive/zip_archive.h>
@@ -28,19 +29,98 @@
#include <numeric>
#include <unordered_set>
+#include "adb_io.h"
#include "adb_trace.h"
#include "sysdeps.h"
using namespace std::literals;
-static constexpr int kBlockSize = 4096;
+namespace incremental {
static constexpr inline int32_t offsetToBlockIndex(int64_t offset) {
return (offset & ~(kBlockSize - 1)) >> 12;
}
+Size verity_tree_blocks_for_file(Size fileSize) {
+ if (fileSize == 0) {
+ return 0;
+ }
+
+ constexpr int hash_per_block = kBlockSize / kDigestSize;
+
+ Size total_tree_block_count = 0;
+
+ auto block_count = 1 + (fileSize - 1) / kBlockSize;
+ auto hash_block_count = block_count;
+ for (auto i = 0; hash_block_count > 1; i++) {
+ hash_block_count = (hash_block_count + hash_per_block - 1) / hash_per_block;
+ total_tree_block_count += hash_block_count;
+ }
+ return total_tree_block_count;
+}
+
+Size verity_tree_size_for_file(Size fileSize) {
+ return verity_tree_blocks_for_file(fileSize) * kBlockSize;
+}
+
+static inline int32_t read_int32(borrowed_fd fd) {
+ int32_t result;
+ return ReadFdExactly(fd, &result, sizeof(result)) ? result : -1;
+}
+
+static inline int32_t skip_int(borrowed_fd fd) {
+ return adb_lseek(fd, 4, SEEK_CUR);
+}
+
+static inline void append_int(borrowed_fd fd, std::vector<char>* bytes) {
+ int32_t le_val = read_int32(fd);
+ auto old_size = bytes->size();
+ bytes->resize(old_size + sizeof(le_val));
+ memcpy(bytes->data() + old_size, &le_val, sizeof(le_val));
+}
+
+static inline void append_bytes_with_size(borrowed_fd fd, std::vector<char>* bytes) {
+ int32_t le_size = read_int32(fd);
+ if (le_size < 0) {
+ return;
+ }
+ int32_t size = int32_t(le32toh(le_size));
+ auto old_size = bytes->size();
+ bytes->resize(old_size + sizeof(le_size) + size);
+ memcpy(bytes->data() + old_size, &le_size, sizeof(le_size));
+ ReadFdExactly(fd, bytes->data() + old_size + sizeof(le_size), size);
+}
+
+static inline int32_t skip_bytes_with_size(borrowed_fd fd) {
+ int32_t le_size = read_int32(fd);
+ if (le_size < 0) {
+ return -1;
+ }
+ int32_t size = int32_t(le32toh(le_size));
+ return (int32_t)adb_lseek(fd, size, SEEK_CUR);
+}
+
+std::pair<std::vector<char>, int32_t> read_id_sig_headers(borrowed_fd fd) {
+ std::vector<char> result;
+ append_int(fd, &result); // version
+ append_bytes_with_size(fd, &result); // hashingInfo
+ append_bytes_with_size(fd, &result); // signingInfo
+ auto le_tree_size = read_int32(fd);
+ auto tree_size = int32_t(le32toh(le_tree_size)); // size of the verity tree
+ return {std::move(result), tree_size};
+}
+
+std::pair<off64_t, ssize_t> skip_id_sig_headers(borrowed_fd fd) {
+ skip_int(fd); // version
+ skip_bytes_with_size(fd); // hashingInfo
+ auto offset = skip_bytes_with_size(fd); // signingInfo
+ auto le_tree_size = read_int32(fd);
+ auto tree_size = int32_t(le32toh(le_tree_size)); // size of the verity tree
+ return {offset + sizeof(le_tree_size), tree_size};
+}
+
template <class T>
-T valueAt(int fd, off64_t offset) {
+static T valueAt(borrowed_fd fd, off64_t offset) {
T t;
memset(&t, 0, sizeof(T));
if (adb_pread(fd, &t, sizeof(T), offset) != sizeof(T)) {
@@ -68,7 +148,7 @@
v.end());
}
-static off64_t CentralDirOffset(int fd, int64_t fileSize) {
+static off64_t CentralDirOffset(borrowed_fd fd, Size fileSize) {
static constexpr int kZipEocdRecMinSize = 22;
static constexpr int32_t kZipEocdRecSig = 0x06054b50;
static constexpr int kZipEocdCentralDirSizeFieldOffset = 12;
@@ -103,7 +183,7 @@
}
// Does not support APKs larger than 4GB
-static off64_t SignerBlockOffset(int fd, int64_t fileSize) {
+static off64_t SignerBlockOffset(borrowed_fd fd, Size fileSize) {
static constexpr int kApkSigBlockMinSize = 32;
static constexpr int kApkSigBlockFooterSize = 24;
static constexpr int64_t APK_SIG_BLOCK_MAGIC_HI = 0x3234206b636f6c42l;
@@ -132,7 +212,7 @@
return signerBlockOffset;
}
-static std::vector<int32_t> ZipPriorityBlocks(off64_t signerBlockOffset, int64_t fileSize) {
+static std::vector<int32_t> ZipPriorityBlocks(off64_t signerBlockOffset, Size fileSize) {
int32_t signerBlockIndex = offsetToBlockIndex(signerBlockOffset);
int32_t lastBlockIndex = offsetToBlockIndex(fileSize);
const auto numPriorityBlocks = lastBlockIndex - signerBlockIndex + 1;
@@ -160,7 +240,7 @@
return zipPriorityBlocks;
}
-[[maybe_unused]] static ZipArchiveHandle openZipArchiveFd(int fd) {
+[[maybe_unused]] static ZipArchiveHandle openZipArchiveFd(borrowed_fd fd) {
bool transferFdOwnership = false;
#ifdef _WIN32
//
@@ -179,20 +259,22 @@
D("%s failed at DuplicateHandle: %d", __func__, (int)::GetLastError());
return {};
}
- fd = _open_osfhandle((intptr_t)dupedHandle, _O_RDONLY | _O_BINARY);
- if (fd < 0) {
+ int osfd = _open_osfhandle((intptr_t)dupedHandle, _O_RDONLY | _O_BINARY);
+ if (osfd < 0) {
D("%s failed at _open_osfhandle: %d", __func__, errno);
::CloseHandle(handle);
return {};
}
transferFdOwnership = true;
+#else
+ int osfd = fd.get();
#endif
ZipArchiveHandle zip;
- if (OpenArchiveFd(fd, "apk_fd", &zip, transferFdOwnership) != 0) {
+ if (OpenArchiveFd(osfd, "apk_fd", &zip, transferFdOwnership) != 0) {
D("%s failed at OpenArchiveFd: %d", __func__, errno);
#ifdef _WIN32
// "_close()" is a secret WinCRT name for the regular close() function.
- _close(fd);
+ _close(osfd);
#endif
return {};
}
@@ -200,7 +282,7 @@
}
static std::pair<ZipArchiveHandle, std::unique_ptr<android::base::MappedFile>> openZipArchive(
- int fd, int64_t fileSize) {
+ borrowed_fd fd, Size fileSize) {
#ifndef __LP64__
if (fileSize >= INT_MAX) {
return {openZipArchiveFd(fd), nullptr};
@@ -220,7 +302,7 @@
return {zip, std::move(mapping)};
}
-static std::vector<int32_t> InstallationPriorityBlocks(int fd, int64_t fileSize) {
+static std::vector<int32_t> InstallationPriorityBlocks(borrowed_fd fd, Size fileSize) {
static constexpr std::array<std::string_view, 3> additional_matches = {
"resources.arsc"sv, "AndroidManifest.xml"sv, "classes.dex"sv};
auto [zip, _] = openZipArchive(fd, fileSize);
@@ -249,8 +331,9 @@
if (entryName == "classes.dex"sv) {
// Only the head is needed for installation
int32_t startBlockIndex = offsetToBlockIndex(entry.offset);
- appendBlocks(startBlockIndex, 1, &installationPriorityBlocks);
- D("\tadding to priority blocks: '%.*s' 1", (int)entryName.size(), entryName.data());
+ appendBlocks(startBlockIndex, 2, &installationPriorityBlocks);
+ D("\tadding to priority blocks: '%.*s' (%d)", (int)entryName.size(), entryName.data(),
+ 2);
} else {
// Full entries are needed for installation
off64_t entryStartOffset = entry.offset;
@@ -273,9 +356,9 @@
return installationPriorityBlocks;
}
-namespace incremental {
-std::vector<int32_t> PriorityBlocksForFile(const std::string& filepath, int fd, int64_t fileSize) {
- if (!android::base::EndsWithIgnoreCase(filepath, ".apk")) {
+std::vector<int32_t> PriorityBlocksForFile(const std::string& filepath, borrowed_fd fd,
+ Size fileSize) {
+ if (!android::base::EndsWithIgnoreCase(filepath, ".apk"sv)) {
return {};
}
off64_t signerOffset = SignerBlockOffset(fd, fileSize);
@@ -291,4 +374,5 @@
unduplicate(priorityBlocks);
return priorityBlocks;
}
+
} // namespace incremental
diff --git a/adb/client/incremental_utils.h b/adb/client/incremental_utils.h
index 8bcf6c0..fe2914d 100644
--- a/adb/client/incremental_utils.h
+++ b/adb/client/incremental_utils.h
@@ -16,11 +16,33 @@
#pragma once
-#include <stdint.h>
+#include "adb_unique_fd.h"
#include <string>
+#include <string_view>
+#include <utility>
#include <vector>
+#include <stdint.h>
+
+#include <android-base/off64_t.h>
+
namespace incremental {
-std::vector<int32_t> PriorityBlocksForFile(const std::string& filepath, int fd, int64_t fileSize);
-} // namespace incremental
\ No newline at end of file
+
+using Size = int64_t;
+constexpr int kBlockSize = 4096;
+constexpr int kSha256DigestSize = 32;
+constexpr int kDigestSize = kSha256DigestSize;
+
+constexpr std::string_view IDSIG = ".idsig";
+
+std::vector<int32_t> PriorityBlocksForFile(const std::string& filepath, borrowed_fd fd,
+ Size fileSize);
+
+Size verity_tree_blocks_for_file(Size fileSize);
+Size verity_tree_size_for_file(Size fileSize);
+
+std::pair<std::vector<char>, int32_t> read_id_sig_headers(borrowed_fd fd);
+std::pair<off64_t, ssize_t> skip_id_sig_headers(borrowed_fd fd);
+
+} // namespace incremental
diff --git a/deprecated-adf/OWNERS b/deprecated-adf/OWNERS
deleted file mode 100644
index 72b8b5a..0000000
--- a/deprecated-adf/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-ghackmann@google.com
-marissaw@google.com
diff --git a/deprecated-adf/libadf/Android.bp b/deprecated-adf/libadf/Android.bp
deleted file mode 100644
index 70f0a3b..0000000
--- a/deprecated-adf/libadf/Android.bp
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (C) 2013 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-cc_library {
- name: "libadf",
- recovery_available: true,
- vendor_available: true,
- vndk: {
- enabled: true,
- },
- srcs: ["adf.cpp"],
- cflags: ["-Werror"],
- local_include_dirs: ["include"],
- export_include_dirs: ["include"],
-}
diff --git a/deprecated-adf/libadf/adf.cpp b/deprecated-adf/libadf/adf.cpp
deleted file mode 100644
index fd9c208..0000000
--- a/deprecated-adf/libadf/adf.cpp
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include <linux/limits.h>
-
-#include <sys/ioctl.h>
-
-#include <adf/adf.h>
-
-#define ADF_BASE_PATH "/dev/"
-
-static ssize_t adf_id_vector_to_array(const std::vector<adf_id_t> &in,
- adf_id_t **out)
-{
- auto size = sizeof(in[0]) * in.size();
- // We can't use new[] since the existing API says the caller should free()
- // the returned array
- auto ret = static_cast<adf_id_t *>(malloc(size));
- if (!ret)
- return -ENOMEM;
-
- std::copy(in.begin(), in.end(), ret);
- *out = ret;
- return in.size();
-}
-
-static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids_out)
-{
- struct dirent *dirent;
- std::unique_ptr<DIR, decltype(&closedir)>
- dir{opendir(ADF_BASE_PATH), closedir};
- if (!dir)
- return -errno;
-
- std::vector<adf_id_t> ids;
- errno = 0;
- while ((dirent = readdir(dir.get()))) {
- adf_id_t id;
- int matched = sscanf(dirent->d_name, pattern, &id);
-
- if (matched < 0)
- return -errno;
- else if (matched == 1)
- ids.push_back(id);
- }
- if (errno)
- return -errno;
-
- return adf_id_vector_to_array(ids, ids_out);
-}
-
-ssize_t adf_devices(adf_id_t **ids)
-{
- return adf_find_nodes("adf%u", ids);
-}
-
-int adf_device_open(adf_id_t id, int flags, struct adf_device *dev)
-{
- char filename[64];
-
- dev->id = id;
-
- snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf%u", id);
- dev->fd = open(filename, flags);
- if (dev->fd < 0)
- return -errno;
-
- return 0;
-}
-
-void adf_device_close(struct adf_device *dev)
-{
- if (dev->fd >= 0)
- close(dev->fd);
-}
-
-int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data)
-{
- int err;
- int ret = 0;
-
- memset(data, 0, sizeof(*data));
-
- err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
- if (err < 0)
- return -ENOMEM;
-
- if (data->n_attachments)
- data->attachments = new adf_attachment_config[data->n_attachments];
-
- if (data->n_allowed_attachments)
- data->allowed_attachments =
- new adf_attachment_config[data->n_allowed_attachments];
-
- if (data->custom_data_size)
- data->custom_data = new char[data->custom_data_size];
-
- err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
- if (err < 0) {
- ret = -errno;
- adf_free_device_data(data);
- }
- return ret;
-}
-
-void adf_free_device_data(struct adf_device_data *data)
-{
- delete [] data->attachments;
- data->attachments = nullptr;
- delete [] data->allowed_attachments;
- data->allowed_attachments = nullptr;
- delete [] static_cast<char *>(data->custom_data);
- data->custom_data = nullptr;
-}
-
-int adf_device_post(struct adf_device *dev,
- adf_id_t *interfaces, size_t n_interfaces,
- struct adf_buffer_config *bufs, size_t n_bufs,
- void *custom_data, size_t custom_data_size)
-{
- int err;
- struct adf_post_config data;
-
- memset(&data, 0, sizeof(data));
- data.interfaces = interfaces;
- data.n_interfaces = n_interfaces;
- data.bufs = bufs;
- data.n_bufs = n_bufs;
- data.custom_data = custom_data;
- data.custom_data_size = custom_data_size;
-
- err = ioctl(dev->fd, ADF_POST_CONFIG, &data);
- if (err < 0)
- return -errno;
-
- return (int)data.complete_fence;
-}
-
-int adf_device_post_v2(struct adf_device *dev,
- adf_id_t *interfaces, __u32 n_interfaces,
- struct adf_buffer_config *bufs, __u32 n_bufs,
- void *custom_data, __u64 custom_data_size,
- enum adf_complete_fence_type complete_fence_type,
- int *complete_fence)
-{
- int err;
- struct adf_post_config_v2 data;
-
- memset(&data, 0, sizeof(data));
- data.interfaces = (uintptr_t)interfaces;
- data.n_interfaces = n_interfaces;
- data.bufs = (uintptr_t)bufs;
- data.n_bufs = n_bufs;
- data.custom_data = (uintptr_t)custom_data;
- data.custom_data_size = custom_data_size;
- data.complete_fence_type = complete_fence_type;
-
- err = ioctl(dev->fd, ADF_POST_CONFIG_V2, &data);
- if (err < 0)
- return -errno;
-
- if (complete_fence)
- *complete_fence = data.complete_fence;
- else if (data.complete_fence >= 0)
- close(data.complete_fence);
-
- return 0;
-}
-
-static int adf_device_attachment(struct adf_device *dev,
- adf_id_t overlay_engine, adf_id_t interface, bool attach)
-{
- int err;
- struct adf_attachment_config data;
-
- memset(&data, 0, sizeof(data));
- data.overlay_engine = overlay_engine;
- data.interface = interface;
-
- err = ioctl(dev->fd, attach ? ADF_ATTACH : ADF_DETACH, &data);
- if (err < 0)
- return -errno;
-
- return 0;
-}
-
-int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine,
- adf_id_t interface)
-{
- return adf_device_attachment(dev, overlay_engine, interface, true);
-}
-
-int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine,
- adf_id_t interface)
-{
- return adf_device_attachment(dev, overlay_engine, interface, false);
-}
-
-ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces)
-{
- char pattern[64];
-
- snprintf(pattern, sizeof(pattern), "adf-interface%u.%%u", dev->id);
- return adf_find_nodes(pattern, interfaces);
-}
-
-ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
- adf_id_t overlay_engine, adf_id_t **interfaces)
-{
- struct adf_device_data data;
- auto err = adf_get_device_data(dev, &data);
- if (err < 0)
- return err;
-
- std::vector<adf_id_t> ids;
- if (data.allowed_attachments != nullptr)
- for (size_t i = 0; i < data.n_allowed_attachments; i++)
- if (data.allowed_attachments[i].overlay_engine == overlay_engine)
- ids.push_back(data.allowed_attachments[i].interface);
-
- adf_free_device_data(&data);
- return adf_id_vector_to_array(ids, interfaces);
-}
-
-static ssize_t adf_interfaces_filter(struct adf_device *dev,
- adf_id_t *in, size_t n_in, adf_id_t **out,
- bool (*filter)(struct adf_interface_data *data, __u32 match),
- __u32 match)
-{
- std::vector<adf_id_t> ids;
- for (size_t i = 0; i < n_in; i++) {
- int fd = adf_interface_open(dev, in[i], O_RDONLY);
- if (fd < 0)
- return fd;
-
- struct adf_interface_data data;
- auto ret = adf_get_interface_data(fd, &data);
- close(fd);
- if (ret < 0)
- return ret;
-
- if (filter(&data, match))
- ids.push_back(in[i]);
- }
-
- return adf_id_vector_to_array(ids, out);
-}
-
-static bool adf_interface_type_filter(struct adf_interface_data *data,
- __u32 type)
-{
- return data->type == (enum adf_interface_type)type;
-}
-
-ssize_t adf_interfaces_filter_by_type(struct adf_device *dev,
- enum adf_interface_type type,
- adf_id_t *in, size_t n_in, adf_id_t **out)
-{
- return adf_interfaces_filter(dev, in, n_in, out, adf_interface_type_filter,
- type);
-}
-
-static bool adf_interface_flags_filter(struct adf_interface_data *data,
- __u32 flag)
-{
- return !!(data->flags & flag);
-}
-
-ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag,
- adf_id_t *in, size_t n_in, adf_id_t **out)
-{
- return adf_interfaces_filter(dev, in, n_in, out, adf_interface_flags_filter,
- flag);
-}
-
-int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags)
-{
- char filename[64];
-
- snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf-interface%u.%u",
- dev->id, id);
-
- int fd = open(filename, flags);
- if (fd < 0)
- return -errno;
- return fd;
-}
-
-int adf_get_interface_data(int fd, struct adf_interface_data *data)
-{
- int err;
- int ret = 0;
-
- memset(data, 0, sizeof(*data));
-
- err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
- if (err < 0)
- return -errno;
-
- if (data->n_available_modes)
- data->available_modes = new drm_mode_modeinfo[data->n_available_modes];
-
- if (data->custom_data_size)
- data->custom_data = new char[data->custom_data_size];
-
- err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
- if (err < 0) {
- ret = -errno;
- adf_free_interface_data(data);
- }
- return ret;
-}
-
-void adf_free_interface_data(struct adf_interface_data *data)
-{
- delete [] data->available_modes;
- delete [] static_cast<char *>(data->custom_data);
-}
-
-int adf_interface_blank(int fd, __u8 mode)
-{
- int err = ioctl(fd, ADF_BLANK, mode);
- if (err < 0)
- return -errno;
- return 0;
-}
-
-int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode)
-{
- int err = ioctl(fd, ADF_SET_MODE, mode);
- if (err < 0)
- return -errno;
- return 0;
-}
-
-int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h,
- __u32 format, __u32 *offset, __u32 *pitch)
-{
- int err;
- struct adf_simple_buffer_alloc data;
-
- memset(&data, 0, sizeof(data));
- data.w = w;
- data.h = h;
- data.format = format;
-
- err = ioctl(fd, ADF_SIMPLE_BUFFER_ALLOC, &data);
- if (err < 0)
- return -errno;
-
- *offset = data.offset;
- *pitch = data.pitch;
- return (int)data.fd;
-}
-
-static void adf_interface_simple_post_config_buf(struct adf_buffer_config *buf,
- __u32 overlay_engine, __u32 w, __u32 h, __u32 format, int buf_fd,
- __u32 offset, __u32 pitch, int acquire_fence)
-{
- buf->overlay_engine = overlay_engine;
- buf->w = w;
- buf->h = h;
- buf->format = format;
- buf->fd[0] = buf_fd;
- buf->offset[0] = offset;
- buf->pitch[0] = pitch;
- buf->n_planes = 1;
- buf->acquire_fence = acquire_fence;
-}
-
-int adf_interface_simple_post(int fd, __u32 overlay_engine,
- __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
- __u32 pitch, int acquire_fence)
-{
- int ret;
- struct adf_simple_post_config data;
-
- memset(&data, 0, sizeof(data));
- adf_interface_simple_post_config_buf(&data.buf, overlay_engine, w, h, format,
- buf_fd, offset, pitch, acquire_fence);
- ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG, &data);
- if (ret < 0)
- return -errno;
-
- return (int)data.complete_fence;
-}
-
-int adf_interface_simple_post_v2(int fd, adf_id_t overlay_engine,
- __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
- __u32 pitch, int acquire_fence,
- enum adf_complete_fence_type complete_fence_type,
- int *complete_fence)
-{
- int ret;
- struct adf_simple_post_config_v2 data;
-
- memset(&data, 0, sizeof(data));
- adf_interface_simple_post_config_buf(&data.buf, overlay_engine, w, h, format,
- buf_fd, offset, pitch, acquire_fence);
- data.complete_fence_type = complete_fence_type;
-
- ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG_V2, &data);
- if (ret < 0)
- return -errno;
-
- if (complete_fence)
- *complete_fence = data.complete_fence;
- else if (data.complete_fence >= 0)
- close(data.complete_fence);
-
- return 0;
-}
-
-ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines)
-{
- char pattern[64];
-
- snprintf(pattern, sizeof(pattern), "adf-overlay-engine%u.%%u", dev->id);
- return adf_find_nodes(pattern, overlay_engines);
-}
-
-ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
- adf_id_t interface, adf_id_t **overlay_engines)
-{
- struct adf_device_data data;
- auto err = adf_get_device_data(dev, &data);
- if (err < 0)
- return err;
-
- std::vector<adf_id_t> ids;
- if (data.allowed_attachments != nullptr)
- for (size_t i = 0; i < data.n_allowed_attachments; i++)
- if (data.allowed_attachments[i].interface == interface)
- ids.push_back(data.allowed_attachments[i].overlay_engine);
-
- return adf_id_vector_to_array(ids, overlay_engines);
-}
-
-static ssize_t adf_overlay_engines_filter(struct adf_device *dev,
- adf_id_t *in, size_t n_in, adf_id_t **out,
- bool (*filter)(struct adf_overlay_engine_data *data, void *cookie),
- void *cookie)
-{
- std::vector<adf_id_t> ids;
- size_t i;
- for (i = 0; i < n_in; i++) {
- int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY);
- if (fd < 0)
- return fd;
-
- struct adf_overlay_engine_data data;
- auto ret = adf_get_overlay_engine_data(fd, &data);
- close(fd);
- if (ret < 0)
- return ret;
-
- if (filter(&data, cookie))
- ids.push_back(in[i]);
- }
-
- return adf_id_vector_to_array(ids, out);
-}
-
-struct format_filter_cookie {
- const __u32 *formats;
- size_t n_formats;
-};
-
-static bool adf_overlay_engine_format_filter(
- struct adf_overlay_engine_data *data, void *cookie)
-{
- auto c = static_cast<format_filter_cookie *>(cookie);
- size_t i;
- for (i = 0; i < data->n_supported_formats; i++) {
- size_t j;
- for (j = 0; j < c->n_formats; j++)
- if (data->supported_formats[i] == c->formats[j])
- return true;
- }
- return false;
-}
-
-ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev,
- const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in,
- adf_id_t **out)
-{
- struct format_filter_cookie cookie = { formats, n_formats };
- return adf_overlay_engines_filter(dev, in, n_in, out,
- adf_overlay_engine_format_filter, &cookie);
-}
-
-int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags)
-{
- char filename[64];
-
- snprintf(filename, sizeof(filename),
- ADF_BASE_PATH "adf-overlay-engine%u.%u", dev->id, id);
-
- int fd = open(filename, flags);
- if (fd < 0)
- return -errno;
- return fd;
-}
-
-int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data)
-{
- int err;
- int ret = 0;
-
- memset(data, 0, sizeof(*data));
-
- err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
- if (err < 0)
- return -errno;
-
- if (data->n_supported_formats)
- data->supported_formats = new __u32[data->n_supported_formats];
-
- if (data->custom_data_size)
- data->custom_data = new char[data->custom_data_size];
-
- err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
- if (err < 0) {
- ret = -errno;
- adf_free_overlay_engine_data(data);
- }
- return ret;
-}
-
-void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data)
-{
- delete [] data->supported_formats;
- data->supported_formats = nullptr;
- delete [] static_cast<char *>(data->custom_data);
- data->custom_data = nullptr;
-}
-
-bool adf_overlay_engine_supports_format(int fd, __u32 format)
-{
- struct adf_overlay_engine_data data;
- bool ret = false;
- size_t i;
-
- int err = adf_get_overlay_engine_data(fd, &data);
- if (err < 0)
- return false;
-
- if (data.supported_formats != nullptr) {
- for (i = 0; i < data.n_supported_formats; i++) {
- if (data.supported_formats[i] == format) {
- ret = true;
- break;
- }
- }
- }
-
- adf_free_overlay_engine_data(&data);
- return ret;
-}
-
-int adf_set_event(int fd, enum adf_event_type type, bool enabled)
-{
- struct adf_set_event data;
-
- data.type = type;
- data.enabled = enabled;
-
- int err = ioctl(fd, ADF_SET_EVENT, &data);
- if (err < 0)
- return -errno;
- return 0;
-}
-
-int adf_read_event(int fd, struct adf_event **event)
-{
- struct adf_event header;
- struct event_with_data {
- struct adf_event base;
- uint8_t data[0];
- };
- using unique_event = std::unique_ptr<event_with_data, decltype(&free)>;
- size_t data_size;
-
- int err = read(fd, &header, sizeof(header));
- if (err < 0)
- return -errno;
- if ((size_t)err < sizeof(header))
- return -EIO;
- if (header.length < sizeof(header))
- return -EIO;
-
- // Again, we can't use new[] since the existing API says the caller should
- // free() the returned event
- auto event_ptr = static_cast<event_with_data *>(malloc(header.length));
- unique_event event_ret{event_ptr, free};
- if (!event_ret)
- return -ENOMEM;
- data_size = header.length - sizeof(header);
-
- memcpy(event_ret.get(), &header, sizeof(header));
- ssize_t read_size = read(fd, &event_ret->data, data_size);
- if (read_size < 0)
- return -errno;
- if ((size_t)read_size < data_size)
- return -EIO;
-
- *event = &event_ret.release()->base;
- return 0;
-}
-
-void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE])
-{
- buf[0] = format & 0xFF;
- buf[1] = (format >> 8) & 0xFF;
- buf[2] = (format >> 16) & 0xFF;
- buf[3] = (format >> 24) & 0xFF;
- buf[4] = '\0';
-}
-
-static bool adf_find_simple_post_overlay_engine(struct adf_device *dev,
- const __u32 *formats, size_t n_formats,
- adf_id_t interface, adf_id_t *overlay_engine)
-{
- adf_id_t *engs = nullptr;
- ssize_t n_engs = adf_overlay_engines_for_interface(dev, interface, &engs);
-
- if (engs == nullptr)
- return false;
-
- adf_id_t *filtered_engs = nullptr;
- ssize_t n_filtered_engs = adf_overlay_engines_filter_by_format(dev,
- formats, n_formats, engs, n_engs, &filtered_engs);
- free(engs);
-
- if (filtered_engs == nullptr)
- return false;
-
- *overlay_engine = filtered_engs[0];
- free(filtered_engs);
- return true;
-}
-
-static const __u32 any_rgb_format[] = {
- DRM_FORMAT_C8,
- DRM_FORMAT_RGB332,
- DRM_FORMAT_BGR233,
- DRM_FORMAT_XRGB1555,
- DRM_FORMAT_XBGR1555,
- DRM_FORMAT_RGBX5551,
- DRM_FORMAT_BGRX5551,
- DRM_FORMAT_ARGB1555,
- DRM_FORMAT_ABGR1555,
- DRM_FORMAT_RGBA5551,
- DRM_FORMAT_BGRA5551,
- DRM_FORMAT_RGB565,
- DRM_FORMAT_BGR565,
- DRM_FORMAT_RGB888,
- DRM_FORMAT_BGR888,
- DRM_FORMAT_XRGB8888,
- DRM_FORMAT_XBGR8888,
- DRM_FORMAT_RGBX8888,
- DRM_FORMAT_BGRX8888,
- DRM_FORMAT_XRGB2101010,
- DRM_FORMAT_XBGR2101010,
- DRM_FORMAT_RGBX1010102,
- DRM_FORMAT_BGRX1010102,
- DRM_FORMAT_ARGB2101010,
- DRM_FORMAT_ABGR2101010,
- DRM_FORMAT_RGBA1010102,
- DRM_FORMAT_BGRA1010102,
- DRM_FORMAT_ARGB8888,
- DRM_FORMAT_ABGR8888,
- DRM_FORMAT_RGBA8888,
- DRM_FORMAT_BGRA8888,
-};
-
-int adf_find_simple_post_configuration(struct adf_device *dev,
- const __u32 *formats, size_t n_formats,
- adf_id_t *interface, adf_id_t *overlay_engine)
-{
- adf_id_t *intfs = NULL;
- ssize_t n_intfs = adf_interfaces(dev, &intfs);
-
- if (n_intfs < 0)
- return n_intfs;
- else if (!intfs)
- return -ENODEV;
-
- adf_id_t *primary_intfs = nullptr;
- ssize_t n_primary_intfs = adf_interfaces_filter_by_flag(dev,
- ADF_INTF_FLAG_PRIMARY, intfs, n_intfs, &primary_intfs);
- free(intfs);
-
- if (n_primary_intfs < 0)
- return n_primary_intfs;
- else if (!primary_intfs)
- return -ENODEV;
-
- if (!formats) {
- formats = any_rgb_format;
- n_formats = sizeof(any_rgb_format) / sizeof(any_rgb_format[0]);
- }
-
- bool found = false;
- ssize_t i = 0;
- for (i = 0; i < n_primary_intfs; i++) {
- found = adf_find_simple_post_overlay_engine(dev, formats, n_formats,
- primary_intfs[i], overlay_engine);
- if (found) {
- *interface = primary_intfs[i];
- break;
- }
- }
- free(primary_intfs);
-
- if (!found)
- return -ENODEV;
-
- return 0;
-}
diff --git a/deprecated-adf/libadf/include/adf/adf.h b/deprecated-adf/libadf/include/adf/adf.h
deleted file mode 100644
index e4c7b28..0000000
--- a/deprecated-adf/libadf/include/adf/adf.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _LIBADF_ADF_H_
-#define _LIBADF_ADF_H_
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <sys/cdefs.h>
-#include <sys/types.h>
-#include <video/adf.h>
-
-typedef __u32 adf_id_t;
-
-struct adf_device {
- adf_id_t id;
- int fd;
-};
-
-__BEGIN_DECLS
-
-/**
- * Enumerates all ADF devices.
- *
- * Returns the number of ADF devices, and sets ids to a list of device IDs.
- * The caller must free() the returned list of device IDs.
- *
- * On error, returns -errno.
- */
-ssize_t adf_devices(adf_id_t **ids);
-
-/**
- * Opens an ADF device.
- *
- * On error, returns -errno.
- */
-int adf_device_open(adf_id_t id, int flags, struct adf_device *dev);
-/**
- * Closes an ADF device.
- */
-void adf_device_close(struct adf_device *dev);
-/**
- * Reads the ADF device data.
- *
- * adf_get_device_data() allocates buffers inside data, which the caller
- * must free by calling adf_free_device_data(). On error, returns -errno.
- */
-int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data);
-/**
- * Frees the device data returned by adf_get_device_data().
- */
-void adf_free_device_data(struct adf_device_data *data);
-
-/**
- * Atomically posts a new display configuration to the specified interfaces.
- *
- * Returns a sync fence fd that will fire when the configuration is removed
- * from the screen. On error, returns -errno.
- */
-int adf_device_post(struct adf_device *dev,
- adf_id_t *interfaces, size_t n_interfaces,
- struct adf_buffer_config *bufs, size_t n_bufs,
- void *custom_data, size_t custom_data_size);
-/**
- * Atomically posts a new display configuration to the specified interfaces.
- *
- * Compared to adf_device_post(), adf_device_post_v2():
- *
- * (*) allows the client to choose the kind of sync fence returned
- * (through complete_fence_type)
- *
- * (*) stores the returned sync fence fd in a provided buffer, so the client
- * can distinguish between a permission error (ret = -1) and a successful
- * call that returns no fence (*complete_fence = -1)
- *
- * On error, returns -errno.
- *
- * On devices without the corresponding kernel support, returns -ENOTTY.
- */
-int adf_device_post_v2(struct adf_device *dev,
- adf_id_t *interfaces, __u32 n_interfaces,
- struct adf_buffer_config *bufs, __u32 n_bufs,
- void *custom_data, __u64 custom_data_size,
- enum adf_complete_fence_type complete_fence_type,
- int *complete_fence);
-
-/**
- * Attaches the specified interface and overlay engine.
- */
-int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine,
- adf_id_t interface);
-/**
- * Detaches the specified interface and overlay engine.
- */
-int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine,
- adf_id_t interface);
-
-/**
- * Enumerates all interfaces belonging to an ADF device.
- *
- * The caller must free() the returned list of interface IDs.
- */
-ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces);
-
-/**
- * Enumerates all interfaces which can be attached to the specified overlay
- * engine.
- *
- * The caller must free() the returned list of interface IDs.
- */
-ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
- adf_id_t overlay_engine, adf_id_t **interfaces);
-/**
- * Filters a list of interfaces by type.
- *
- * Returns the number of matching interfaces, and sets out to a list of matching
- * interface IDs. The caller must free() the returned list of interface IDs.
- *
- * On error, returns -errno.
- */
-ssize_t adf_interfaces_filter_by_type(struct adf_device *dev,
- enum adf_interface_type type,
- adf_id_t *in, size_t n_in, adf_id_t **out);
-/**
- * Filters a list of interfaces by flag.
- *
- * The caller must free() the returned list of interface IDs.
- */
-ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag,
- adf_id_t *in, size_t n_in, adf_id_t **out);
-
-/**
- * Opens an ADF interface.
- *
- * Returns a file descriptor. The caller must close() the fd when done.
- * On error, returns -errno.
- */
-int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags);
-/**
- * Reads the interface data.
- *
- * adf_get_interface_data() allocates buffers inside data, which the caller
- * must free by calling adf_free_interface_data(). On error, returns -errno.
- */
-int adf_get_interface_data(int fd, struct adf_interface_data *data);
-/**
- * Frees the interface data returned by adf_get_interface_data().
- */
-void adf_free_interface_data(struct adf_interface_data *data);
-
-/**
- * Sets the interface's DPMS mode.
- */
-int adf_interface_blank(int fd, __u8 mode);
-/**
- * Sets the interface's display mode.
- */
-int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode);
-/**
- * Allocates a single-plane RGB buffer of the specified size and format.
- *
- * Returns a dma-buf fd. On error, returns -errno.
- */
-int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h,
- __u32 format, __u32 *offset, __u32 *pitch);
-/**
- * Posts a single-plane RGB buffer to the display using the specified
- * overlay engine.
- *
- * Returns a sync fence fd that will fire when the buffer is removed
- * from the screen. On error, returns -errno.
- */
-int adf_interface_simple_post(int fd, adf_id_t overlay_engine,
- __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
- __u32 pitch, int acquire_fence);
-/**
- * Posts a single-plane RGB buffer to the display using the specified
- * overlay engine.
- *
- * Compared to adf_interface_simple_post(), adf_interface_simple_post_v2():
- *
- * (*) allows the client to choose the kind of sync fence returned
- * (through complete_fence_type)
- *
- * (*) stores the returned sync fence fd in a provided buffer, so the client
- * can distinguish between a permission error (ret = -1) and a successful
- * call that returns no fence (*complete_fence = -1)
- *
- * On error, returns -errno.
- *
- * On devices without the corresponding kernel support, returns -ENOTTY.
- */
-int adf_interface_simple_post_v2(int fd, adf_id_t overlay_engine,
- __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
- __u32 pitch, int acquire_fence,
- enum adf_complete_fence_type complete_fence_type,
- int *complete_fence);
-
-/**
- * Enumerates all overlay engines belonging to an ADF device.
- *
- * The caller must free() the returned list of overlay engine IDs.
- */
-ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines);
-
-/**
- * Enumerates all overlay engines which can be attached to the specified
- * interface.
- *
- * The caller must free() the returned list of overlay engine IDs.
- */
-ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
- adf_id_t interface, adf_id_t **overlay_engines);
-/**
- * Filters a list of overlay engines by supported buffer format.
- *
- * Returns the overlay engines which support at least one of the specified
- * formats. The caller must free() the returned list of overlay engine IDs.
- */
-ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev,
- const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in,
- adf_id_t **out);
-
-/**
- * Opens an ADF overlay engine.
- *
- * Returns a file descriptor. The caller must close() the fd when done.
- * On error, returns -errno.
- */
-int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags);
-/**
- * Reads the overlay engine data.
- *
- * adf_get_overlay_engine_data() allocates buffers inside data, which the caller
- * must free by calling adf_free_overlay_engine_data(). On error, returns
- * -errno.
- */
-int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data);
-/**
- * Frees the overlay engine data returned by adf_get_overlay_engine_data().
- */
-void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data);
-
-/**
- * Returns whether the overlay engine supports the specified format.
- */
-bool adf_overlay_engine_supports_format(int fd, __u32 format);
-
-/**
- * Subscribes or unsubscribes from the specified hardware event.
- */
-int adf_set_event(int fd, enum adf_event_type type, bool enabled);
-/**
- * Reads one event from the fd, blocking if needed.
- *
- * The caller must free() the returned buffer. On error, returns -errno.
- */
-int adf_read_event(int fd, struct adf_event **event);
-
-#define ADF_FORMAT_STR_SIZE 5
-/**
- * Converts an ADF/DRM fourcc format to its string representation.
- */
-void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE]);
-
-/**
- * Finds an appropriate interface and overlay engine for a simple post.
- *
- * Specifically, finds the primary interface, and an overlay engine
- * that can be attached to the primary interface and supports one of the
- * specified formats. The caller may pass a NULL formats list, to indicate that
- * any RGB format is acceptable.
- *
- * On error, returns -errno.
- */
-int adf_find_simple_post_configuration(struct adf_device *dev,
- const __u32 *formats, size_t n_formats,
- adf_id_t *interface, adf_id_t *overlay_engine);
-
-__END_DECLS
-
-#endif /* _LIBADF_ADF_H_ */
diff --git a/deprecated-adf/libadf/include/video/adf.h b/deprecated-adf/libadf/include/video/adf.h
deleted file mode 100644
index 692a425..0000000
--- a/deprecated-adf/libadf/include/video/adf.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/****************************************************************************
- ****************************************************************************
- ***
- *** This header was automatically generated from a Linux kernel header
- *** of the same name, to make information necessary for userspace to
- *** call into the kernel available to libc. It contains only constants,
- *** structures, and macros generated from the original header, and thus,
- *** contains no copyrightable information.
- ***
- *** To edit the content of this header, modify the corresponding
- *** source file (e.g. under external/kernel-headers/original/) then
- *** run bionic/libc/kernel/tools/update_all.py
- ***
- *** Any manual change here will be lost the next time this script will
- *** be run. You've been warned!
- ***
- ****************************************************************************
- ****************************************************************************/
-#ifndef _UAPI_VIDEO_ADF_H_
-#define _UAPI_VIDEO_ADF_H_
-#include <linux/ioctl.h>
-#include <linux/types.h>
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#include <drm/drm_fourcc.h>
-#include <drm/drm_mode.h>
-#define ADF_NAME_LEN 32
-#define ADF_MAX_CUSTOM_DATA_SIZE 4096
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-enum adf_interface_type {
- ADF_INTF_DSI = 0,
- ADF_INTF_eDP = 1,
- ADF_INTF_DPI = 2,
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- ADF_INTF_VGA = 3,
- ADF_INTF_DVI = 4,
- ADF_INTF_HDMI = 5,
- ADF_INTF_MEMORY = 6,
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- ADF_INTF_TYPE_DEVICE_CUSTOM = 128,
- ADF_INTF_TYPE_MAX = (~(__u32) 0),
-};
-#define ADF_INTF_FLAG_PRIMARY (1 << 0)
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_INTF_FLAG_EXTERNAL (1 << 1)
-enum adf_event_type {
- ADF_EVENT_VSYNC = 0,
- ADF_EVENT_HOTPLUG = 1,
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- ADF_EVENT_DEVICE_CUSTOM = 128,
- ADF_EVENT_TYPE_MAX = 255,
-};
-enum adf_complete_fence_type {
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- ADF_COMPLETE_FENCE_NONE = 0,
- ADF_COMPLETE_FENCE_PRESENT = 1,
- ADF_COMPLETE_FENCE_RELEASE = 2,
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_set_event {
- __u8 type;
- __u8 enabled;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_event {
- __u8 type;
- __u32 length;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_vsync_event {
- struct adf_event base;
- __aligned_u64 timestamp;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_hotplug_event {
- struct adf_event base;
- __u8 connected;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_MAX_PLANES 4
-struct adf_buffer_config {
- __u32 overlay_engine;
- __u32 w;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u32 h;
- __u32 format;
- __s32 fd[ADF_MAX_PLANES];
- __u32 offset[ADF_MAX_PLANES];
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u32 pitch[ADF_MAX_PLANES];
- __u8 n_planes;
- __s32 acquire_fence;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_MAX_BUFFERS (4096 / sizeof(struct adf_buffer_config))
-struct adf_post_config {
- size_t n_interfaces;
- __u32 __user * interfaces;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- size_t n_bufs;
- struct adf_buffer_config __user * bufs;
- size_t custom_data_size;
- void __user * custom_data;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __s32 complete_fence;
-};
-struct adf_post_config_v2 {
- __u32 n_interfaces;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u64 interfaces;
- __u32 n_bufs;
- __u64 bufs;
- __u64 custom_data_size;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u64 custom_data;
- __s32 complete_fence;
- __u8 complete_fence_type;
-};
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_MAX_INTERFACES (4096 / sizeof(__u32))
-struct adf_simple_buffer_alloc {
- __u16 w;
- __u16 h;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u32 format;
- __s32 fd;
- __u32 offset;
- __u32 pitch;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-};
-struct adf_simple_post_config {
- struct adf_buffer_config buf;
- __s32 complete_fence;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-};
-struct adf_simple_post_config_v2 {
- struct adf_buffer_config buf;
- __s32 complete_fence;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u8 complete_fence_type;
-};
-struct adf_attachment_config {
- __u32 overlay_engine;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u32 interface;
-};
-struct adf_device_data {
- char name[ADF_NAME_LEN];
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- size_t n_attachments;
- struct adf_attachment_config __user * attachments;
- size_t n_allowed_attachments;
- struct adf_attachment_config __user * allowed_attachments;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- size_t custom_data_size;
- void __user * custom_data;
-};
-#define ADF_MAX_ATTACHMENTS (4096 / sizeof(struct adf_attachment_config))
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_interface_data {
- char name[ADF_NAME_LEN];
- __u32 type;
- __u32 id;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u32 flags;
- __u8 dpms_state;
- __u8 hotplug_detect;
- __u16 width_mm;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- __u16 height_mm;
- struct drm_mode_modeinfo current_mode;
- size_t n_available_modes;
- struct drm_mode_modeinfo __user * available_modes;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- size_t custom_data_size;
- void __user * custom_data;
-};
-#define ADF_MAX_MODES (4096 / sizeof(struct drm_mode_modeinfo))
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-struct adf_overlay_engine_data {
- char name[ADF_NAME_LEN];
- size_t n_supported_formats;
- __u32 __user * supported_formats;
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
- size_t custom_data_size;
- void __user * custom_data;
-};
-#define ADF_MAX_SUPPORTED_FORMATS (4096 / sizeof(__u32))
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_IOCTL_TYPE 'D'
-#define ADF_IOCTL_NR_CUSTOM 128
-#define ADF_SET_EVENT _IOW(ADF_IOCTL_TYPE, 0, struct adf_set_event)
-#define ADF_BLANK _IOW(ADF_IOCTL_TYPE, 1, __u8)
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 2, struct adf_post_config)
-#define ADF_SET_MODE _IOW(ADF_IOCTL_TYPE, 3, struct drm_mode_modeinfo)
-#define ADF_GET_DEVICE_DATA _IOR(ADF_IOCTL_TYPE, 4, struct adf_device_data)
-#define ADF_GET_INTERFACE_DATA _IOR(ADF_IOCTL_TYPE, 5, struct adf_interface_data)
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_GET_OVERLAY_ENGINE_DATA _IOR(ADF_IOCTL_TYPE, 6, struct adf_overlay_engine_data)
-#define ADF_SIMPLE_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 7, struct adf_simple_post_config)
-#define ADF_SIMPLE_BUFFER_ALLOC _IOW(ADF_IOCTL_TYPE, 8, struct adf_simple_buffer_alloc)
-#define ADF_ATTACH _IOW(ADF_IOCTL_TYPE, 9, struct adf_attachment_config)
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-#define ADF_DETACH _IOW(ADF_IOCTL_TYPE, 10, struct adf_attachment_config)
-#define ADF_POST_CONFIG_V2 _IOW(ADF_IOCTL_TYPE, 11, struct adf_post_config_v2)
-#define ADF_SIMPLE_POST_CONFIG_V2 _IOW(ADF_IOCTL_TYPE, 12, struct adf_simple_post_config_v2)
-#endif
-/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
-
diff --git a/deprecated-adf/libadf/original-kernel-headers/video/adf.h b/deprecated-adf/libadf/original-kernel-headers/video/adf.h
deleted file mode 100644
index 8293c1d..0000000
--- a/deprecated-adf/libadf/original-kernel-headers/video/adf.h
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
- * Copyright (C) 2013 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef _UAPI_VIDEO_ADF_H_
-#define _UAPI_VIDEO_ADF_H_
-
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
-#include <drm/drm_fourcc.h>
-#include <drm/drm_mode.h>
-
-#define ADF_NAME_LEN 32
-#define ADF_MAX_CUSTOM_DATA_SIZE 4096
-
-enum adf_interface_type {
- ADF_INTF_DSI = 0,
- ADF_INTF_eDP = 1,
- ADF_INTF_DPI = 2,
- ADF_INTF_VGA = 3,
- ADF_INTF_DVI = 4,
- ADF_INTF_HDMI = 5,
- ADF_INTF_MEMORY = 6,
- ADF_INTF_TYPE_DEVICE_CUSTOM = 128,
- ADF_INTF_TYPE_MAX = (~(__u32)0),
-};
-
-#define ADF_INTF_FLAG_PRIMARY (1 << 0)
-#define ADF_INTF_FLAG_EXTERNAL (1 << 1)
-
-enum adf_event_type {
- ADF_EVENT_VSYNC = 0,
- ADF_EVENT_HOTPLUG = 1,
- ADF_EVENT_DEVICE_CUSTOM = 128,
- ADF_EVENT_TYPE_MAX = 255,
-};
-
-enum adf_complete_fence_type {
- /* no fence */
- ADF_COMPLETE_FENCE_NONE = 0,
- /* fence fires when the configuration appears on the screen */
- ADF_COMPLETE_FENCE_PRESENT = 1,
- /* fence fires when the configuration leaves the screen */
- ADF_COMPLETE_FENCE_RELEASE = 2,
-};
-
-/**
- * struct adf_set_event - start or stop subscribing to ADF events
- *
- * @type: the type of event to (un)subscribe
- * @enabled: subscribe or unsubscribe
- *
- * After subscribing to an event, userspace may poll() the ADF object's fd
- * to wait for events or read() to consume the event's data.
- *
- * ADF reserves event types 0 to %ADF_EVENT_DEVICE_CUSTOM-1 for its own events.
- * Devices may use event types %ADF_EVENT_DEVICE_CUSTOM to %ADF_EVENT_TYPE_MAX-1
- * for driver-private events.
- */
-struct adf_set_event {
- __u8 type;
- __u8 enabled;
-};
-
-/**
- * struct adf_event - common header for ADF event data
- *
- * @type: event type
- * @length: total size of event data, header inclusive
- */
-struct adf_event {
- __u8 type;
- __u32 length;
-};
-
-/**
- * struct adf_vsync_event - ADF vsync event
- *
- * @base: event header (see &struct adf_event)
- * @timestamp: time of vsync event, in nanoseconds
- */
-struct adf_vsync_event {
- struct adf_event base;
- __aligned_u64 timestamp;
-};
-
-/**
- * struct adf_vsync_event - ADF display hotplug event
- *
- * @base: event header (see &struct adf_event)
- * @connected: whether a display is now connected to the interface
- */
-struct adf_hotplug_event {
- struct adf_event base;
- __u8 connected;
-};
-
-#define ADF_MAX_PLANES 4
-/**
- * struct adf_buffer_config - description of buffer displayed by adf_post_config
- *
- * @overlay_engine: id of the target overlay engine
- * @w: width of display region in pixels
- * @h: height of display region in pixels
- * @format: DRM-style fourcc, see drm_fourcc.h for standard formats
- * @fd: dma_buf fd for each plane
- * @offset: location of first pixel to scan out, in bytes
- * @pitch: stride (i.e. length of a scanline including padding) in bytes
- * @n_planes: number of planes in buffer
- * @acquire_fence: sync_fence fd which will clear when the buffer is
- * ready for display, or <0 if the buffer is already ready
- */
-struct adf_buffer_config {
- __u32 overlay_engine;
-
- __u32 w;
- __u32 h;
- __u32 format;
-
- __s32 fd[ADF_MAX_PLANES];
- __u32 offset[ADF_MAX_PLANES];
- __u32 pitch[ADF_MAX_PLANES];
- __u8 n_planes;
-
- __s32 acquire_fence;
-};
-#define ADF_MAX_BUFFERS (4096 / sizeof(struct adf_buffer_config))
-
-/**
- * struct adf_post_config - request to flip to a new set of buffers
- *
- * This request is equivalent to &struct adf_post_config_v2 with
- * @complete_fence_type = %ADF_COMPLETE_FENCE_RELEASE.
- *
- * @n_interfaces: number of interfaces targeted by the flip (input)
- * @interfaces: ids of interfaces targeted by the flip (input)
- * @n_bufs: number of buffers displayed (input)
- * @bufs: description of buffers displayed (input)
- * @custom_data_size: size of driver-private data (input)
- * @custom_data: driver-private data (input)
- * @complete_fence: sync_fence fd which will clear when this
- * configuration has left the screen (output)
- */
-struct adf_post_config {
- size_t n_interfaces;
- __u32 __user *interfaces;
-
- size_t n_bufs;
- struct adf_buffer_config __user *bufs;
-
- size_t custom_data_size;
- void __user *custom_data;
-
- __s32 complete_fence;
-};
-
-/**
- * struct adf_post_config_v2 - request to flip to a new set of buffers
- *
- * @n_interfaces: number of interfaces targeted by the flip (input)
- * @interfaces: ids of interfaces targeted by the flip (input)
- * @n_bufs: number of buffers displayed (input)
- * @bufs: description of buffers displayed (input)
- * @custom_data_size: size of driver-private data (input)
- * @custom_data: driver-private data (input)
- * @complete_fence_type: one of &enum adf_complete_fence_type describing what
- * fence to return (input)
- * @complete_fence: sync_fence fd which will fire at the time
- * requested by @complete_fence_type (output)
- */
-struct adf_post_config_v2 {
- __u32 n_interfaces;
- __u64 interfaces; /* __u32 * packed into __u64 */
-
- __u32 n_bufs;
- __u64 bufs; /* struct adf_buffer_config * packed into __u64 */
-
- __u64 custom_data_size;
- __u64 custom_data; /* void * packed into __u64 */
-
- __s32 complete_fence;
- __u8 complete_fence_type;
-};
-#define ADF_MAX_INTERFACES (4096 / sizeof(__u32))
-
-/**
- * struct adf_simple_buffer_allocate - request to allocate a "simple" buffer
- *
- * @w: width of buffer in pixels (input)
- * @h: height of buffer in pixels (input)
- * @format: DRM-style fourcc (input)
- *
- * @fd: dma_buf fd (output)
- * @offset: location of first pixel, in bytes (output)
- * @pitch: length of a scanline including padding, in bytes (output)
- *
- * Simple buffers are analogous to DRM's "dumb" buffers. They have a single
- * plane of linear RGB data which can be allocated and scanned out without
- * any driver-private ioctls or data.
- *
- * @format must be a standard RGB format defined in drm_fourcc.h.
- *
- * ADF clients must NOT assume that an interface can scan out a simple buffer
- * allocated by a different ADF interface, even if the two interfaces belong to
- * the same ADF device.
- */
-struct adf_simple_buffer_alloc {
- __u16 w;
- __u16 h;
- __u32 format;
-
- __s32 fd;
- __u32 offset;
- __u32 pitch;
-};
-
-/**
- * struct adf_simple_post_config - request to flip to a single buffer without
- * driver-private data
- *
- * This request is equivalent to &struct adf_simple_post_config_v2 with
- * @complete_fence_type = %ADF_COMPLETE_FENCE_RELEASE.
- *
- * @buf: description of buffer displayed (input)
- * @complete_fence: sync_fence fd which will clear when this buffer has left the
- * screen (output)
- */
-struct adf_simple_post_config {
- struct adf_buffer_config buf;
- __s32 complete_fence;
-};
-
-/**
- * struct adf_simple_post_config_v2 - request to flip to a single buffer without
- * driver-private data
- *
- * @buf: description of buffer displayed (input)
- * @complete_fence_type: one of &enum adf_complete_fence_type describing what
- * fence to return (input)
- * @complete_fence: sync_fence fd which will fire at the time
- * requested by @complete_fence_type (output)
- */
-struct adf_simple_post_config_v2 {
- struct adf_buffer_config buf;
- __s32 complete_fence;
- __u8 complete_fence_type;
-};
-
-/**
- * struct adf_attachment_config - description of attachment between an overlay
- * engine and an interface
- *
- * @overlay_engine: id of the overlay engine
- * @interface: id of the interface
- */
-struct adf_attachment_config {
- __u32 overlay_engine;
- __u32 interface;
-};
-
-/**
- * struct adf_device_data - describes a display device
- *
- * @name: display device's name
- * @n_attachments: the number of current attachments
- * @attachments: list of current attachments
- * @n_allowed_attachments: the number of allowed attachments
- * @allowed_attachments: list of allowed attachments
- * @custom_data_size: size of driver-private data
- * @custom_data: driver-private data
- */
-struct adf_device_data {
- char name[ADF_NAME_LEN];
-
- size_t n_attachments;
- struct adf_attachment_config __user *attachments;
-
- size_t n_allowed_attachments;
- struct adf_attachment_config __user *allowed_attachments;
-
- size_t custom_data_size;
- void __user *custom_data;
-};
-#define ADF_MAX_ATTACHMENTS (4096 / sizeof(struct adf_attachment_config))
-
-/**
- * struct adf_device_data - describes a display interface
- *
- * @name: display interface's name
- * @type: interface type (see enum @adf_interface_type)
- * @id: which interface of type @type;
- * e.g. interface DSI.1 -> @type=@ADF_INTF_TYPE_DSI, @id=1
- * @flags: informational flags (bitmask of %ADF_INTF_FLAG_* values)
- * @dpms_state: DPMS state (one of @DRM_MODE_DPMS_* defined in drm_mode.h)
- * @hotplug_detect: whether a display is plugged in
- * @width_mm: screen width in millimeters, or 0 if unknown
- * @height_mm: screen height in millimeters, or 0 if unknown
- * @current_mode: current display mode
- * @n_available_modes: the number of hardware display modes
- * @available_modes: list of hardware display modes
- * @custom_data_size: size of driver-private data
- * @custom_data: driver-private data
- */
-struct adf_interface_data {
- char name[ADF_NAME_LEN];
-
- __u32 type;
- __u32 id;
- /* e.g. type=ADF_INTF_TYPE_DSI, id=1 => DSI.1 */
- __u32 flags;
-
- __u8 dpms_state;
- __u8 hotplug_detect;
- __u16 width_mm;
- __u16 height_mm;
-
- struct drm_mode_modeinfo current_mode;
- size_t n_available_modes;
- struct drm_mode_modeinfo __user *available_modes;
-
- size_t custom_data_size;
- void __user *custom_data;
-};
-#define ADF_MAX_MODES (4096 / sizeof(struct drm_mode_modeinfo))
-
-/**
- * struct adf_overlay_engine_data - describes an overlay engine
- *
- * @name: overlay engine's name
- * @n_supported_formats: number of supported formats
- * @supported_formats: list of supported formats
- * @custom_data_size: size of driver-private data
- * @custom_data: driver-private data
- */
-struct adf_overlay_engine_data {
- char name[ADF_NAME_LEN];
-
- size_t n_supported_formats;
- __u32 __user *supported_formats;
-
- size_t custom_data_size;
- void __user *custom_data;
-};
-#define ADF_MAX_SUPPORTED_FORMATS (4096 / sizeof(__u32))
-
-#define ADF_IOCTL_TYPE 'D'
-#define ADF_IOCTL_NR_CUSTOM 128
-
-#define ADF_SET_EVENT _IOW(ADF_IOCTL_TYPE, 0, struct adf_set_event)
-#define ADF_BLANK _IOW(ADF_IOCTL_TYPE, 1, __u8)
-#define ADF_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 2, struct adf_post_config)
-#define ADF_SET_MODE _IOW(ADF_IOCTL_TYPE, 3, \
- struct drm_mode_modeinfo)
-#define ADF_GET_DEVICE_DATA _IOR(ADF_IOCTL_TYPE, 4, struct adf_device_data)
-#define ADF_GET_INTERFACE_DATA _IOR(ADF_IOCTL_TYPE, 5, \
- struct adf_interface_data)
-#define ADF_GET_OVERLAY_ENGINE_DATA \
- _IOR(ADF_IOCTL_TYPE, 6, \
- struct adf_overlay_engine_data)
-#define ADF_SIMPLE_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 7, \
- struct adf_simple_post_config)
-#define ADF_SIMPLE_BUFFER_ALLOC _IOW(ADF_IOCTL_TYPE, 8, \
- struct adf_simple_buffer_alloc)
-#define ADF_ATTACH _IOW(ADF_IOCTL_TYPE, 9, \
- struct adf_attachment_config)
-#define ADF_DETACH _IOW(ADF_IOCTL_TYPE, 10, \
- struct adf_attachment_config)
-
-#define ADF_POST_CONFIG_V2 _IOW(ADF_IOCTL_TYPE, 11, \
- struct adf_post_config_v2)
-#define ADF_SIMPLE_POST_CONFIG_V2 \
- _IOW(ADF_IOCTL_TYPE, 12, \
- struct adf_simple_post_config_v2)
-
-#endif /* _UAPI_VIDEO_ADF_H_ */
diff --git a/deprecated-adf/libadf/tests/Android.bp b/deprecated-adf/libadf/tests/Android.bp
deleted file mode 100644
index 9b3430e..0000000
--- a/deprecated-adf/libadf/tests/Android.bp
+++ /dev/null
@@ -1,23 +0,0 @@
-//
-// Copyright (C) 2013 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-cc_test {
- name: "adf-unit-tests",
- srcs: ["adf_test.cpp"],
- shared_libs: ["libsync"],
- static_libs: ["libadf"],
- cflags: ["-Werror"],
-}
diff --git a/deprecated-adf/libadf/tests/adf_test.cpp b/deprecated-adf/libadf/tests/adf_test.cpp
deleted file mode 100644
index 82a91f4..0000000
--- a/deprecated-adf/libadf/tests/adf_test.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-
-#include <adf/adf.h>
-#include <gtest/gtest.h>
-#include <sys/mman.h>
-#include <sync/sync.h>
-
-class AdfTest : public testing::Test {
-public:
- AdfTest() : intf_id(0), intf(-1), eng_id(0), eng(-1) { }
-
- virtual void SetUp() {
- int err = adf_device_open(dev_id, O_RDWR, &dev);
- ASSERT_GE(err, 0) << "opening ADF device " << dev_id <<
- " failed: " << strerror(-err);
-
- err = adf_find_simple_post_configuration(&dev, fmt8888, n_fmt8888,
- &intf_id, &eng_id);
- ASSERT_GE(err, 0) << "finding ADF configuration failed: " <<
- strerror(-err);
-
- intf = adf_interface_open(&dev, intf_id, O_RDWR);
- ASSERT_GE(intf, 0) << "opening ADF interface " << dev_id << "." <<
- intf_id << " failed: " << strerror(-intf);
-
- eng = adf_overlay_engine_open(&dev, eng_id, O_RDWR);
- ASSERT_GE(eng, 0) << "opening ADF overlay engine " << dev_id << "." <<
- eng_id << " failed: " << strerror(-eng);
- }
-
- virtual void TearDown() {
- if (eng >= 0)
- close(eng);
- if (intf >= 0)
- close(intf);
- adf_device_close(&dev);
- }
-
- void get8888Format(uint32_t &fmt, char fmt_str[ADF_FORMAT_STR_SIZE]) {
- adf_overlay_engine_data data;
- int err = adf_get_overlay_engine_data(eng, &data);
- ASSERT_GE(err, 0) << "getting ADF overlay engine data failed: " <<
- strerror(-err);
-
- for (size_t i = 0; i < data.n_supported_formats; i++) {
- for (size_t j = 0; j < n_fmt8888; j++) {
- if (data.supported_formats[i] == fmt8888[j]) {
- fmt = data.supported_formats[i];
- adf_format_str(fmt, fmt_str);
- adf_free_overlay_engine_data(&data);
- return;
- }
- }
- }
-
- adf_free_overlay_engine_data(&data);
- FAIL(); /* this should never happen */
- }
-
- /* various helpers to call ADF and die on failure */
-
- void getInterfaceData(adf_interface_data &data) {
- int err = adf_get_interface_data(intf, &data);
- ASSERT_GE(err, 0) << "getting ADF interface data failed: " <<
- strerror(-err);
- }
-
- void getCurrentMode(uint32_t &w, uint32_t &h) {
- adf_interface_data data;
- ASSERT_NO_FATAL_FAILURE(getInterfaceData(data));
- w = data.current_mode.hdisplay;
- h = data.current_mode.vdisplay;
- adf_free_interface_data(&data);
- }
-
- void blank(uint8_t mode) {
- int err = adf_interface_blank(intf, mode);
- ASSERT_FALSE(err < 0 && err != -EBUSY) <<
- "unblanking interface failed: " << strerror(-err);
- }
-
- void attach() {
- int err = adf_device_attach(&dev, eng_id, intf_id);
- ASSERT_FALSE(err < 0 && err != -EALREADY) <<
- "attaching overlay engine " << eng_id << " to interface " <<
- intf_id << " failed: " << strerror(-err);
- }
-
- void detach() {
- int err = adf_device_detach(&dev, eng_id, intf_id);
- ASSERT_FALSE(err < 0 && err != -EINVAL) <<
- "detaching overlay engine " << eng_id << " from interface " <<
- intf_id << " failed: " << strerror(-err);
- }
-
- void readVsyncTimestamp(uint64_t ×tamp) {
- adf_event *event;
- int err = adf_read_event(intf, &event);
- ASSERT_GE(err, 0) << "reading ADF event failed: " << strerror(-err);
-
- ASSERT_EQ(ADF_EVENT_VSYNC, event->type);
- ASSERT_EQ(sizeof(adf_vsync_event), event->length);
-
- adf_vsync_event *vsync_event =
- reinterpret_cast<adf_vsync_event *>(event);
- timestamp = vsync_event->timestamp;
- free(event);
- }
-
- void drawCheckerboard(uint32_t &w, uint32_t &h, uint32_t &format,
- char format_str[ADF_FORMAT_STR_SIZE], int &buf_fd, uint32_t &offset,
- uint32_t &pitch) {
- ASSERT_NO_FATAL_FAILURE(getCurrentMode(w, h));
- ASSERT_NO_FATAL_FAILURE(get8888Format(format, format_str));
-
- buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, format, &offset,
- &pitch);
- ASSERT_GE(buf_fd, 0) << "allocating " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-buf_fd);
- EXPECT_GE(pitch, w * 4);
-
- void *mapped = mmap(NULL, pitch * h, PROT_WRITE, MAP_SHARED, buf_fd,
- offset);
- ASSERT_NE(mapped, MAP_FAILED) << "mapping " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-errno);
-
- uint8_t *buf8 = static_cast<uint8_t *>(mapped);
- for (uint32_t y = 0; y < h / 2; y++) {
- uint32_t *scanline = reinterpret_cast<uint32_t *>(buf8 + y * pitch);
- for (uint32_t x = 0; x < w / 2; x++)
- scanline[x] = 0xFF0000FF;
- for (uint32_t x = w / 2; x < w; x++)
- scanline[x] = 0xFF00FFFF;
- }
- for (uint32_t y = h / 2; y < h; y++) {
- uint32_t *scanline = reinterpret_cast<uint32_t *>(buf8 + y * pitch);
- for (uint32_t x = 0; x < w / 2; x++)
- scanline[x] = 0xFFFF00FF;
- for (uint32_t x = w / 2; x < w; x++)
- scanline[x] = 0xFFFFFFFF;
- }
-
- munmap(mapped, pitch * h);
- }
-
-protected:
- adf_device dev;
- adf_id_t intf_id;
- int intf;
- adf_id_t eng_id;
- int eng;
-
-private:
- const static adf_id_t dev_id;
- const static __u32 fmt8888[];
- const static size_t n_fmt8888;
-};
-
-const adf_id_t AdfTest::dev_id = 0;
-
-const __u32 AdfTest::fmt8888[] = {
- DRM_FORMAT_XRGB8888,
- DRM_FORMAT_XBGR8888,
- DRM_FORMAT_RGBX8888,
- DRM_FORMAT_BGRX8888,
- DRM_FORMAT_ARGB8888,
- DRM_FORMAT_ABGR8888,
- DRM_FORMAT_RGBA8888,
- DRM_FORMAT_BGRA8888
-};
-const size_t AdfTest::n_fmt8888 = sizeof(fmt8888) / sizeof(fmt8888[0]);
-
-TEST(adf, devices) {
- adf_id_t *devs = nullptr;
- ssize_t n_devs = adf_devices(&devs);
- free(devs);
-
- ASSERT_GE(n_devs, 0) << "enumerating ADF devices failed: " <<
- strerror(-n_devs);
- ASSERT_TRUE(devs != NULL);
-}
-
-TEST_F(AdfTest, device_data) {
- adf_device_data data;
- int err = adf_get_device_data(&dev, &data);
- ASSERT_GE(err, 0) << "getting ADF device data failed: " << strerror(-err);
-
- EXPECT_LT(data.n_attachments, ADF_MAX_ATTACHMENTS);
- EXPECT_GT(data.n_allowed_attachments, 0U);
- EXPECT_LT(data.n_allowed_attachments, ADF_MAX_ATTACHMENTS);
- EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE);
- adf_free_device_data(&data);
-}
-
-TEST_F(AdfTest, interface_data) {
- adf_interface_data data;
- ASSERT_NO_FATAL_FAILURE(getInterfaceData(data));
-
- EXPECT_LT(data.type, ADF_INTF_TYPE_MAX);
- EXPECT_LE(data.dpms_state, DRM_MODE_DPMS_OFF);
- EXPECT_EQ(1, data.hotplug_detect);
- EXPECT_GT(data.n_available_modes, 0U);
- EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE);
- adf_free_interface_data(&data);
-}
-
-TEST_F(AdfTest, overlay_engine_data) {
- adf_overlay_engine_data data;
- int err = adf_get_overlay_engine_data(eng, &data);
- ASSERT_GE(err, 0) << "getting ADF overlay engine failed: " <<
- strerror(-err);
-
- EXPECT_GT(data.n_supported_formats, 0U);
- EXPECT_LT(data.n_supported_formats, ADF_MAX_SUPPORTED_FORMATS);
- EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE);
- adf_free_overlay_engine_data(&data);
-}
-
-TEST_F(AdfTest, blank) {
- int err = adf_interface_blank(intf, (uint8_t)-1);
- EXPECT_EQ(-EINVAL, err) << "setting bogus DPMS mode should have failed";
-
- err = adf_interface_blank(eng, DRM_MODE_DPMS_OFF);
- EXPECT_EQ(-EINVAL, err) << "blanking overlay engine should have failed";
-
- ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_OFF));
- err = adf_interface_blank(intf, DRM_MODE_DPMS_OFF);
- EXPECT_EQ(-EBUSY, err) << "blanking interface twice should have failed";
-
- ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON));
- err = adf_interface_blank(intf, DRM_MODE_DPMS_ON);
- EXPECT_EQ(-EBUSY, err) << "unblanking interface twice should have failed";
-
- adf_interface_data data;
- ASSERT_NO_FATAL_FAILURE(getInterfaceData(data));
- EXPECT_EQ(DRM_MODE_DPMS_ON, data.dpms_state);
- adf_free_interface_data(&data);
-}
-
-TEST_F(AdfTest, event) {
- int err = adf_set_event(intf, ADF_EVENT_TYPE_MAX, true);
- EXPECT_EQ(-EINVAL, err) << "enabling bogus ADF event should have failed";
-
- err = adf_set_event(intf, ADF_EVENT_TYPE_MAX, false);
- EXPECT_EQ(-EINVAL, err) << "disabling bogus ADF event should have failed";
-
- err = adf_set_event(intf, ADF_EVENT_VSYNC, true);
- ASSERT_GE(err, 0) << "enabling vsync event failed: " << strerror(-err);
-
- err = adf_set_event(intf, ADF_EVENT_VSYNC, true);
- EXPECT_EQ(-EALREADY, err) <<
- "enabling vsync event twice should have failed";
-
- ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON));
-
- uint64_t timestamp1, timestamp2;
- ASSERT_NO_FATAL_FAILURE(readVsyncTimestamp(timestamp1));
- ASSERT_NO_FATAL_FAILURE(readVsyncTimestamp(timestamp2));
- EXPECT_GT(timestamp2, timestamp1);
-
- err = adf_set_event(intf, ADF_EVENT_VSYNC, false);
- EXPECT_GE(err, 0) << "disabling vsync event failed: " << strerror(-err);
-
- err = adf_set_event(intf, ADF_EVENT_VSYNC, false);
- EXPECT_EQ(-EALREADY, err) <<
- "disabling vsync event twice should have failed";
-}
-
-TEST_F(AdfTest, attach) {
- ASSERT_NO_FATAL_FAILURE(attach());
- int err = adf_device_attach(&dev, eng_id, intf_id);
- EXPECT_EQ(-EALREADY, err) << "attaching overlay engine " << eng_id <<
- " to interface " << intf_id << " twice should have failed";
-
- ASSERT_NO_FATAL_FAILURE(detach());
- err = adf_device_detach(&dev, eng_id, intf_id);
- EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id <<
- " from interface " << intf_id << " twice should have failed";
-
- err = adf_device_attach(&dev, eng_id, ADF_MAX_INTERFACES);
- EXPECT_EQ(-EINVAL, err) << "attaching overlay engine " << eng_id <<
- " to bogus interface should have failed";
-
- err = adf_device_detach(&dev, eng_id, ADF_MAX_INTERFACES);
- EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id <<
- " from bogus interface should have failed";
-}
-
-TEST_F(AdfTest, simple_buffer_alloc) {
- uint32_t w = 0, h = 0;
- ASSERT_NO_FATAL_FAILURE(getCurrentMode(w, h));
-
- uint32_t format;
- char format_str[ADF_FORMAT_STR_SIZE];
- ASSERT_NO_FATAL_FAILURE(get8888Format(format, format_str));
-
- uint32_t offset;
- uint32_t pitch;
- int buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, format, &offset,
- &pitch);
- EXPECT_GE(buf_fd, 0) << "allocating " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-buf_fd);
- EXPECT_GE(pitch, w * 4);
- close(buf_fd);
-
- buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, 0xDEADBEEF, &offset,
- &pitch);
- /* n.b.: ADF only allows simple buffers with built-in RGB formats,
- so this should fail even if a driver supports custom format 0xDEADBEEF */
- EXPECT_EQ(-EINVAL, buf_fd) <<
- "allocating buffer with bogus format should have failed";
-}
-
-TEST_F(AdfTest, simple_buffer) {
- int buf_fd;
- uint32_t w, h, format, offset, pitch;
- char format_str[ADF_FORMAT_STR_SIZE];
- ASSERT_NO_FATAL_FAILURE(drawCheckerboard(w, h, format, format_str,
- buf_fd, offset, pitch));
-
- ASSERT_NO_FATAL_FAILURE(attach());
- ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON));
-
- int release_fence = adf_interface_simple_post(intf, eng_id, w, h, format,
- buf_fd, offset, pitch, -1);
- close(buf_fd);
- ASSERT_GE(release_fence, 0) << "posting " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-release_fence);
- close(release_fence);
-}
-
-TEST_F(AdfTest, simple_buffer_v2) {
- int buf_fd;
- uint32_t w, h, format, offset, pitch;
- char format_str[ADF_FORMAT_STR_SIZE];
- ASSERT_NO_FATAL_FAILURE(drawCheckerboard(w, h, format, format_str,
- buf_fd, offset, pitch));
-
- ASSERT_NO_FATAL_FAILURE(attach());
- ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON));
-
- int config_1_release;
- int err = adf_interface_simple_post_v2(intf, eng_id, w, h,
- format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_RELEASE,
- &config_1_release);
- if (err == -ENOTTY) {
- GTEST_LOG_(INFO) << "ADF_SIMPLE_POST_CONFIG_V2 not supported on this kernel";
- return;
- }
- ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-err);
-
- err = sync_wait(config_1_release, 1000);
- ASSERT_EQ(-1, err) <<
- "waiting for config 1's release fence should not have suceeded";
- ASSERT_EQ(ETIME, errno) <<
- "config 1's release fence should have timed out, but failed instead: " <<
- strerror(errno);
-
- int config_2_present;
- err = adf_interface_simple_post_v2(intf, eng_id, w, h,
- format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_PRESENT,
- &config_2_present);
- ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-err);
-
- err = sync_wait(config_2_present, 1000);
- ASSERT_EQ(0, err) <<
- "waiting for config 2's present fence failed: " << strerror(errno);
- err = sync_wait(config_1_release, 0);
- ASSERT_EQ(0, err) <<
- "waiting for config 1's release fence failed: " << strerror(errno);
- close(config_1_release);
- close(config_2_present);
-
- int config_3_no_fence;
- err = adf_interface_simple_post_v2(intf, eng_id, w, h,
- format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_NONE,
- &config_3_no_fence);
- ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " <<
- format_str << " buffer failed: " << strerror(-err);
- ASSERT_EQ(-1, config_3_no_fence) <<
- "fence returned even though the fence type was ADF_COMPLETE_FENCE_NONE";
-
- close(buf_fd);
-}
diff --git a/deprecated-adf/libadfhwc/Android.bp b/deprecated-adf/libadfhwc/Android.bp
deleted file mode 100644
index 57a8d76..0000000
--- a/deprecated-adf/libadfhwc/Android.bp
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (C) 2013 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-cc_library_static {
- name: "libadfhwc",
- srcs: ["adfhwc.cpp"],
- static_libs: [
- "libadf",
- "liblog",
- "libutils",
- ],
- cflags: [
- "-DLOG_TAG=\"adfhwc\"",
- "-Werror",
- ],
- local_include_dirs: ["include"],
- export_include_dirs: ["include"],
-}
diff --git a/deprecated-adf/libadfhwc/adfhwc.cpp b/deprecated-adf/libadfhwc/adfhwc.cpp
deleted file mode 100644
index 63c0f75..0000000
--- a/deprecated-adf/libadfhwc/adfhwc.cpp
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <fcntl.h>
-#include <malloc.h>
-#include <poll.h>
-#include <pthread.h>
-#include <sys/resource.h>
-
-#include <log/log.h>
-#include <utils/Vector.h>
-
-#include <adf/adf.h>
-#include <adfhwc/adfhwc.h>
-
-struct adf_hwc_helper {
- adf_hwc_event_callbacks const *event_cb;
- void *event_cb_data;
-
- pthread_t event_thread;
-
- android::Vector<int> intf_fds;
- android::Vector<drm_mode_modeinfo> display_configs;
-};
-
-template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
-
-int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
- int enabled)
-{
- if (enabled != !!enabled)
- return -EINVAL;
-
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- switch (event) {
- case HWC_EVENT_VSYNC:
- return adf_set_event(dev->intf_fds[disp], ADF_EVENT_VSYNC, enabled);
- }
-
- return -EINVAL;
-}
-
-static inline int32_t dpi(uint16_t res, uint16_t size_mm)
-{
- if (size_mm)
- return 1000 * (res * 25.4f) / size_mm;
- return 0;
-}
-
-int adf_blank(struct adf_hwc_helper *dev, int disp, int blank)
-{
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- uint8_t dpms_mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON;
- return adf_interface_blank(dev->intf_fds[disp], dpms_mode);
-}
-
-int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value)
-{
- *value = 0;
- if (dev->intf_fds.size() > 0)
- *value |= HWC_DISPLAY_PRIMARY_BIT;
- if (dev->intf_fds.size() > 1)
- *value |= HWC_DISPLAY_EXTERNAL_BIT;
-
- return 0;
-}
-
-int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
- uint32_t *configs, size_t *numConfigs)
-{
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- adf_interface_data data;
- int err = adf_get_interface_data(dev->intf_fds[disp], &data);
- if (err < 0) {
- ALOGE("failed to get ADF interface data: %s", strerror(err));
- return err;
- }
-
- if (!data.hotplug_detect)
- return -ENODEV;
-
- android::Vector<drm_mode_modeinfo *> unique_configs;
- unique_configs.push_back(&data.current_mode);
- for (size_t i = 0; i < data.n_available_modes; i++)
- if (memcmp(&data.available_modes[i], &data.current_mode,
- sizeof(data.current_mode)))
- unique_configs.push_back(&data.available_modes[i]);
-
- for (size_t i = 0; i < min(*numConfigs, unique_configs.size()); i++) {
- configs[i] = dev->display_configs.size();
- dev->display_configs.push_back(*unique_configs[i]);
- }
- *numConfigs = unique_configs.size();
-
- adf_free_interface_data(&data);
- return 0;
-}
-
-static int32_t adf_display_attribute(const adf_interface_data &data,
- const drm_mode_modeinfo &mode, const uint32_t attribute)
-{
- switch (attribute) {
- case HWC_DISPLAY_VSYNC_PERIOD:
- if (mode.vrefresh)
- return 1000000000 / mode.vrefresh;
- return 0;
-
- case HWC_DISPLAY_WIDTH:
- return mode.hdisplay;
-
- case HWC_DISPLAY_HEIGHT:
- return mode.vdisplay;
-
- case HWC_DISPLAY_DPI_X:
- return dpi(mode.hdisplay, data.width_mm);
-
- case HWC_DISPLAY_DPI_Y:
- return dpi(mode.vdisplay, data.height_mm);
-
- default:
- ALOGE("unknown display attribute %u", attribute);
- return -EINVAL;
- }
-}
-
-int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
- uint32_t config, const uint32_t *attributes, int32_t *values)
-{
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- if (config >= dev->display_configs.size())
- return -EINVAL;
-
- adf_interface_data data;
- int err = adf_get_interface_data(dev->intf_fds[disp], &data);
- if (err < 0) {
- ALOGE("failed to get ADF interface data: %s", strerror(err));
- return err;
- }
-
- for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++)
- values[i] = adf_display_attribute(data, dev->display_configs[config],
- attributes[i]);
-
- adf_free_interface_data(&data);
- return 0;
-}
-
-static int32_t adf_display_attribute_hwc2(const adf_interface_data &data,
- const drm_mode_modeinfo &mode, const uint32_t attribute)
-{
- switch (attribute) {
- case HWC2_ATTRIBUTE_VSYNC_PERIOD:
- if (mode.vrefresh)
- return 1000000000 / mode.vrefresh;
- return 0;
-
- case HWC2_ATTRIBUTE_WIDTH:
- return mode.hdisplay;
-
- case HWC2_ATTRIBUTE_HEIGHT:
- return mode.vdisplay;
-
- case HWC2_ATTRIBUTE_DPI_X:
- return dpi(mode.hdisplay, data.width_mm);
-
- case HWC2_ATTRIBUTE_DPI_Y:
- return dpi(mode.vdisplay, data.height_mm);
-
- default:
- ALOGE("unknown display attribute %u", attribute);
- return -EINVAL;
- }
-}
-
-int adf_getDisplayAttributes_hwc2(struct adf_hwc_helper *dev, int disp,
- uint32_t config, const uint32_t *attributes, int32_t *values)
-{
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- if (config >= dev->display_configs.size())
- return -EINVAL;
-
- adf_interface_data data;
- int err = adf_get_interface_data(dev->intf_fds[disp], &data);
- if (err < 0) {
- ALOGE("failed to get ADF interface data: %s", strerror(err));
- return err;
- }
-
- for (int i = 0; attributes[i] != HWC2_ATTRIBUTE_INVALID; i++)
- values[i] = adf_display_attribute_hwc2(data,
- dev->display_configs[config], attributes[i]);
-
- adf_free_interface_data(&data);
- return 0;
-}
-
-int adf_set_active_config_hwc2(struct adf_hwc_helper *dev, int disp,
- uint32_t config)
-{
- if ((size_t)disp >= dev->intf_fds.size())
- return -EINVAL;
-
- if (config >= dev->display_configs.size())
- return -EINVAL;
-
- struct drm_mode_modeinfo mode = dev->display_configs[config];
-
- return adf_interface_set_mode(dev->intf_fds[disp], &mode);
-}
-
-static void handle_adf_event(struct adf_hwc_helper *dev, int disp)
-{
- adf_event *event;
- int err = adf_read_event(dev->intf_fds[disp], &event);
- if (err < 0) {
- ALOGE("error reading event from display %d: %s", disp, strerror(err));
- return;
- }
-
- void *vsync_temp;
- adf_vsync_event *vsync;
- adf_hotplug_event *hotplug;
-
- switch (event->type) {
- case ADF_EVENT_VSYNC:
- vsync_temp = event;
- vsync = static_cast<adf_vsync_event *>(vsync_temp);
- // casting directly to adf_vsync_event * makes g++ warn about
- // potential alignment issues that don't apply here
- dev->event_cb->vsync(dev->event_cb_data, disp, vsync->timestamp);
- break;
- case ADF_EVENT_HOTPLUG:
- hotplug = reinterpret_cast<adf_hotplug_event *>(event);
- dev->event_cb->hotplug(dev->event_cb_data, disp, hotplug->connected);
- break;
- default:
- if (event->type < ADF_EVENT_DEVICE_CUSTOM)
- ALOGW("unrecognized event type %u", event->type);
- else if (!dev->event_cb || !dev->event_cb->custom_event)
- ALOGW("unhandled event type %u", event->type);
- else
- dev->event_cb->custom_event(dev->event_cb_data, disp, event);
- }
- free(event);
-}
-
-static void *adf_event_thread(void *data)
-{
- adf_hwc_helper *dev = static_cast<adf_hwc_helper *>(data);
-
- setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
-
- struct sigaction action = { };
- sigemptyset(&action.sa_mask);
- action.sa_flags = 0;
- action.sa_handler = [](int) { pthread_exit(0); };
-
- if (sigaction(SIGUSR2, &action, NULL) < 0) {
- ALOGE("failed to set thread exit action %s", strerror(errno));
- return NULL;
- }
-
- sigset_t signal_set;
- sigemptyset(&signal_set);
- sigaddset(&signal_set, SIGUSR2);
-
- pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL);
-
- pollfd fds[dev->intf_fds.size()];
- for (size_t i = 0; i < dev->intf_fds.size(); i++) {
- fds[i].fd = dev->intf_fds[i];
- fds[i].events = POLLIN | POLLPRI;
- }
-
- while (true) {
- if (TEMP_FAILURE_RETRY(poll(fds, dev->intf_fds.size(), -1)) < 0) {
- ALOGE("error in event thread: %s", strerror(errno));
- break;
- }
-
- for (size_t i = 0; i < dev->intf_fds.size(); i++)
- if (fds[i].revents & (POLLIN | POLLPRI))
- handle_adf_event(dev, i);
- }
-
- return NULL;
-}
-
-int adf_hwc_open(int *intf_fds, size_t n_intfs,
- const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
- struct adf_hwc_helper **dev)
-{
- if (!n_intfs)
- return -EINVAL;
-
- adf_hwc_helper *dev_ret = new adf_hwc_helper;
- dev_ret->event_cb = event_cb;
- dev_ret->event_cb_data = event_cb_data;
-
- int ret;
-
- for (size_t i = 0; i < n_intfs; i++) {
- int dup_intf_fd = dup(intf_fds[i]);
- if (dup_intf_fd < 0) {
- ALOGE("failed to dup interface fd: %s", strerror(errno));
- ret = -errno;
- goto err;
- }
-
- dev_ret->intf_fds.push_back(dup_intf_fd);
-
- ret = adf_set_event(dup_intf_fd, ADF_EVENT_HOTPLUG, 1);
- if (ret < 0 && ret != -EINVAL) {
- ALOGE("failed to enable hotplug event on display %zu: %s",
- i, strerror(errno));
- goto err;
- }
- }
-
- sigset_t signal_set;
- sigemptyset(&signal_set);
- sigaddset(&signal_set, SIGUSR2);
-
- pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
-
- ret = pthread_create(&dev_ret->event_thread, NULL, adf_event_thread,
- dev_ret);
- if (ret) {
- ALOGE("failed to create event thread: %s", strerror(ret));
- goto err;
- }
-
- *dev = dev_ret;
- return 0;
-
-err:
- for (size_t i = 0; i < dev_ret->intf_fds.size(); i++)
- close(dev_ret->intf_fds[i]);
-
- delete dev_ret;
- return ret;
-}
-
-void adf_hwc_close(struct adf_hwc_helper *dev)
-{
- pthread_kill(dev->event_thread, SIGUSR2);
- pthread_join(dev->event_thread, NULL);
-
- for (size_t i = 0; i < dev->intf_fds.size(); i++)
- close(dev->intf_fds[i]);
-
- delete dev;
-}
diff --git a/deprecated-adf/libadfhwc/include/adfhwc/adfhwc.h b/deprecated-adf/libadfhwc/include/adfhwc/adfhwc.h
deleted file mode 100644
index 4f70925..0000000
--- a/deprecated-adf/libadfhwc/include/adfhwc/adfhwc.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _LIBADFHWC_ADFHWC_H_
-#define _LIBADFHWC_ADFHWC_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <sys/cdefs.h>
-#include <video/adf.h>
-
-#include <hardware/hwcomposer.h>
-#include <hardware/hwcomposer2.h>
-
-struct adf_hwc_helper;
-
-struct adf_hwc_event_callbacks {
- /**
- * Called on vsync (required)
- */
- void (*vsync)(void *data, int disp, uint64_t timestamp);
- /**
- * Called on hotplug (required)
- */
- void (*hotplug)(void *data, int disp, bool connected);
- /**
- * Called on hardware-custom ADF events (optional)
- */
- void (*custom_event)(void *data, int disp, struct adf_event *event);
-};
-
-/**
- * Converts HAL pixel formats to equivalent ADF/DRM format FourCCs.
- */
-static inline uint32_t adf_fourcc_for_hal_pixel_format(int format)
-{
- switch (format) {
- case HAL_PIXEL_FORMAT_RGBA_8888:
- return DRM_FORMAT_RGBA8888;
- case HAL_PIXEL_FORMAT_RGBX_8888:
- return DRM_FORMAT_RGBX8888;
- case HAL_PIXEL_FORMAT_RGB_888:
- return DRM_FORMAT_RGB888;
- case HAL_PIXEL_FORMAT_RGB_565:
- return DRM_FORMAT_RGB565;
- case HAL_PIXEL_FORMAT_BGRA_8888:
- return DRM_FORMAT_BGRA8888;
- case HAL_PIXEL_FORMAT_YV12:
- return DRM_FORMAT_YVU420;
- case HAL_PIXEL_FORMAT_YCbCr_422_SP:
- return DRM_FORMAT_NV16;
- case HAL_PIXEL_FORMAT_YCrCb_420_SP:
- return DRM_FORMAT_NV21;
- case HAL_PIXEL_FORMAT_YCbCr_422_I:
- return DRM_FORMAT_YUYV;
- default:
- return 0;
- }
-}
-
-/**
- * Converts HAL display types to equivalent ADF interface flags.
- */
-static inline uint32_t adf_hwc_interface_flag_for_disp(int disp)
-{
- switch (disp) {
- case HWC_DISPLAY_PRIMARY:
- return ADF_INTF_FLAG_PRIMARY;
- case HWC_DISPLAY_EXTERNAL:
- return ADF_INTF_FLAG_EXTERNAL;
- default:
- return 0;
- }
-}
-
-__BEGIN_DECLS
-
-/**
- * Create a HWC helper for the specified ADF interfaces.
- *
- * intf_fds must be indexed by HWC display type: e.g.,
- * intf_fds[HWC_DISPLAY_PRIMARY] is the fd for the primary display
- * interface. n_intfs must be >= 1.
- *
- * The caller retains ownership of the fds in intf_fds and must close()
- * them when they are no longer needed.
- *
- * On error, returns -errno.
- */
-int adf_hwc_open(int *intf_fds, size_t n_intfs,
- const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
- struct adf_hwc_helper **dev);
-
-/**
- * Destroys a HWC helper.
- */
-void adf_hwc_close(struct adf_hwc_helper *dev);
-
-/**
- * Generic implementations of common HWC ops.
- *
- * The HWC should not point its ops directly at these helpers. Instead, the HWC
- * should provide stub ops which call these helpers after converting the
- * hwc_composer_device_1* to a struct adf_hwc_helper*.
- */
-int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
- int enabled);
-int adf_blank(struct adf_hwc_helper *dev, int disp, int blank);
-int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value);
-int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
- uint32_t *configs, size_t *numConfigs);
-int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
- uint32_t config, const uint32_t *attributes, int32_t *values);
-/**
- * Generic implementation of common HWC2 functions.
- *
- * The HWC2 should not return these functions directly through getFunction.
- * Instead, the HWC2 should return stub functions which call these helpers.
- */
-int adf_getDisplayAttributes_hwc2(struct adf_hwc_helper *dev, int disp,
- uint32_t config, const uint32_t *attributes, int32_t *values);
-int adf_set_active_config_hwc2(struct adf_hwc_helper *dev, int disp,
- uint32_t config);
-
-__END_DECLS
-
-#endif /* _LIBADFHWC_ADFHWC_H_ */