mirror of
https://github.com/fastfetch-cli/fastfetch.git
synced 2026-10-27 23:30:47 +01:00
Carter Li
356 lines
13 KiB
C
356 lines
13 KiB
C
#include "brightness.h"
|
|
#include "common/arrutil.h"
|
|
#include "common/io.h"
|
|
#include "common/kmod.h"
|
|
#include "common/debug.h"
|
|
#include "common/time.h"
|
|
#include "common/edidHelper.h"
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#if __has_include(<dev/iicbus/iic.h>)
|
|
#include <dev/iicbus/iic.h>
|
|
|
|
// Try to load cache from file
|
|
static bool loadCacheFromFile(FFBrightnessDdcCache* cache) {
|
|
cache->count = 0;
|
|
FF_STRBUF_AUTO_DESTROY cacheDir = ffBrightnessDdcCachePath();
|
|
FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreate();
|
|
bool valid = false;
|
|
FF_DEBUG("Brightness DDC/CI: loading I2C cache from %s", cacheDir.chars);
|
|
if (ffReadFileBuffer(cacheDir.chars, &cacheContent)) {
|
|
// Parse cache: first number is count, rest are device numbers
|
|
char* ptr = cacheContent.chars;
|
|
char* end = ptr + cacheContent.length;
|
|
|
|
// Read count
|
|
char* next;
|
|
long count = strtol(ptr, &next, 10);
|
|
if (next != ptr && count > 0 && count <= FF_I2C_DEVICE_CACHE_MAX) {
|
|
ptr = next;
|
|
|
|
// Read device numbers and reject truncated or trailing data.
|
|
size_t parsedCount = 0;
|
|
for (; parsedCount < (size_t) count && ptr < end; ++parsedCount) {
|
|
long dev = strtol(ptr, &next, 10);
|
|
if (next == ptr || dev < 0 || dev >= 100) {
|
|
break;
|
|
}
|
|
cache->devices[parsedCount] = (int) dev;
|
|
ptr = next;
|
|
}
|
|
|
|
while (ptr < end && isspace((unsigned char) *ptr)) {
|
|
++ptr;
|
|
}
|
|
|
|
if (parsedCount == (size_t) count && ptr == end) {
|
|
cache->count = parsedCount;
|
|
valid = true;
|
|
for (size_t i = 0; i < cache->count; ++i) {
|
|
char path[32];
|
|
snprintf(path, sizeof(path), "/dev/iic%d", cache->devices[i]);
|
|
FF_AUTO_CLOSE_FD int fd = open(path, O_RDWR | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
int error = errno;
|
|
FF_DEBUG("Brightness DDC/CI: cached bus %d is unavailable (errno=%d: %s)", cache->devices[i], error, strerror(error));
|
|
valid = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!valid) {
|
|
FF_DEBUG("Brightness DDC/CI: I2C cache is missing or invalid");
|
|
cache->count = 0;
|
|
return false;
|
|
}
|
|
|
|
FF_DEBUG("Brightness DDC/CI: loaded %zu bus(es) from cache", cache->count);
|
|
return true;
|
|
}
|
|
|
|
// Save cache to file
|
|
static void saveCacheToFile(const FFBrightnessDdcCache* cache) {
|
|
if (cache->count == 0) {
|
|
return;
|
|
}
|
|
|
|
FF_STRBUF_AUTO_DESTROY cacheDir = ffBrightnessDdcCachePath();
|
|
FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreateF("%zu", cache->count);
|
|
for (size_t i = 0; i < cache->count; i++) {
|
|
ffStrbufAppendF(&cacheContent, " %d", cache->devices[i]);
|
|
}
|
|
|
|
if (ffWriteFileBuffer(cacheDir.chars, &cacheContent)) {
|
|
FF_DEBUG("Brightness DDC/CI: saved %zu bus(es) to %s", cache->count, cacheDir.chars);
|
|
} else {
|
|
FF_DEBUG("Brightness DDC/CI: failed to save cache to %s", cacheDir.chars);
|
|
}
|
|
}
|
|
|
|
static bool readDdcCiResponse(int fd, FFBrightnessOptions* options, uint8_t response[FF_DDC_CI_VCP_RESPONSE_BUFFER_SIZE]) {
|
|
uint8_t request[5];
|
|
ffDdcCiBuildGetVcpRequest(request);
|
|
|
|
struct iic_msg msg = {
|
|
.slave = FF_DDC_CI_WRITE_ADDR,
|
|
.flags = IIC_M_WR,
|
|
.len = sizeof(request),
|
|
.buf = request
|
|
};
|
|
|
|
struct iic_rdwr_data data = {
|
|
.msgs = &msg,
|
|
.nmsgs = 1
|
|
};
|
|
|
|
int ioctlResult = ioctl(fd, I2CRDWR, &data);
|
|
if (ioctlResult < 0) {
|
|
int error = errno;
|
|
FF_DEBUG("Brightness DDC/CI: write request failed (fd=%d, result=%d, errno=%d: %s)", fd, ioctlResult, error, strerror(error));
|
|
return false;
|
|
}
|
|
|
|
ffTimeSleep(options->ddcciSleep);
|
|
|
|
msg.slave = FF_DDC_CI_WRITE_ADDR;
|
|
msg.flags = IIC_M_RD;
|
|
msg.len = FF_DDC_CI_VCP_RESPONSE_BUFFER_SIZE;
|
|
msg.buf = response;
|
|
ioctlResult = ioctl(fd, I2CRDWR, &data);
|
|
if (ioctlResult < 0) {
|
|
int error = errno;
|
|
FF_DEBUG("Brightness DDC/CI: read response failed (fd=%d, result=%d, errno=%d: %s)", fd, ioctlResult, error, strerror(error));
|
|
return false;
|
|
}
|
|
|
|
if (!ffDdcCiValidateGetVcpResponse(response)) {
|
|
FF_DEBUG("Brightness DDC/CI: invalid response (addr=0x%02x, header=0x%02x, type=0x%02x, opcode=0x%02x, checksum=0x%02x)",
|
|
(unsigned) response[0], (unsigned) response[1], (unsigned) response[2], (unsigned) response[4], (unsigned) response[10]);
|
|
return false;
|
|
}
|
|
|
|
FF_DEBUG("Brightness DDC/CI: valid response (fd=%d, current=%u, max=%u)", fd,
|
|
((unsigned) response[8] << 8u) | (unsigned) response[9],
|
|
((unsigned) response[6] << 8u) | (unsigned) response[7]);
|
|
return true;
|
|
}
|
|
|
|
static bool scanI2cDevices(FFBrightnessOptions* options, FFBrightnessDdcCache* cache) {
|
|
FF_DEBUG("Brightness DDC/CI: scanning FreeBSD I2C buses");
|
|
cache->count = 0;
|
|
|
|
for (int i = 0; i < 100 && cache->count < FF_I2C_DEVICE_CACHE_MAX; i++) {
|
|
char path[32];
|
|
snprintf(path, sizeof(path), "/dev/iic%d", i);
|
|
|
|
FF_AUTO_CLOSE_FD int fd = open(path, O_RDWR | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
continue;
|
|
}
|
|
|
|
FF_DEBUG("Brightness DDC/CI: probing %s", path);
|
|
uint8_t response[FF_DDC_CI_VCP_RESPONSE_BUFFER_SIZE];
|
|
if (!readDdcCiResponse(fd, options, response)) {
|
|
continue;
|
|
}
|
|
|
|
cache->devices[cache->count++] = i;
|
|
FF_DEBUG("Brightness DDC/CI: found compatible display on %s", path);
|
|
}
|
|
|
|
FF_DEBUG("Brightness DDC/CI: scan finished with %zu compatible bus(es)", cache->count);
|
|
return cache->count > 0;
|
|
}
|
|
|
|
static bool readEdid(int fd, uint8_t* edidData) {
|
|
uint8_t offset = 0;
|
|
|
|
struct iic_msg msgs[2];
|
|
msgs[0].slave = FF_DDC_EDID_WRITE_ADDR;
|
|
msgs[0].flags = IIC_M_WR;
|
|
msgs[0].len = 1;
|
|
msgs[0].buf = &offset;
|
|
|
|
msgs[1].slave = FF_DDC_EDID_WRITE_ADDR;
|
|
msgs[1].flags = IIC_M_RD;
|
|
msgs[1].len = 128;
|
|
msgs[1].buf = edidData;
|
|
|
|
struct iic_rdwr_data data = {
|
|
.msgs = msgs,
|
|
.nmsgs = 2
|
|
};
|
|
|
|
return ioctl(fd, I2CRDWR, &data) >= 0;
|
|
}
|
|
|
|
static bool detectCachedDevices(FFBrightnessOptions* options, FFlist* result, FFBrightnessDdcCache* cache) {
|
|
const size_t cachedCount = cache->count;
|
|
const uint32_t resultLength = result->length;
|
|
size_t validCount = 0;
|
|
|
|
FF_DEBUG("Brightness DDC/CI: validating %zu cached bus(es)", cachedCount);
|
|
for (size_t i = 0; i < cachedCount; ++i) {
|
|
const int device = cache->devices[i];
|
|
char path[32];
|
|
snprintf(path, sizeof(path), "/dev/iic%d", device);
|
|
|
|
FF_AUTO_CLOSE_FD int fd = open(path, O_RDWR | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
int error = errno;
|
|
FF_DEBUG("Brightness DDC/CI: failed to open cached bus %d (errno=%d: %s)", device, error, strerror(error));
|
|
continue;
|
|
}
|
|
|
|
uint8_t response[FF_DDC_CI_VCP_RESPONSE_BUFFER_SIZE];
|
|
if (!readDdcCiResponse(fd, options, response)) {
|
|
continue;
|
|
}
|
|
|
|
uint32_t current = ((uint32_t) response[8] << 8u) + (uint32_t) response[9];
|
|
uint32_t max = ((uint32_t) response[6] << 8u) + (uint32_t) response[7];
|
|
if (max == 0 || current > max) {
|
|
FF_DEBUG("Brightness DDC/CI: ignoring bus %d with invalid brightness range %u/%u", device, current, max);
|
|
continue;
|
|
}
|
|
|
|
cache->devices[validCount++] = device;
|
|
|
|
// Try to read EDID for monitor name
|
|
uint8_t edidData[128];
|
|
FF_STRBUF_AUTO_DESTROY name = ffStrbufCreateA(32);
|
|
if (readEdid(fd, edidData)) {
|
|
ffEdidGetName(edidData, &name);
|
|
}
|
|
if (name.length == 0) {
|
|
ffStrbufSetF(&name, "I2C-%d", device);
|
|
}
|
|
|
|
FFBrightnessResult* brightness = FF_LIST_ADD(FFBrightnessResult, *result);
|
|
brightness->max = max;
|
|
brightness->min = 0;
|
|
brightness->current = current;
|
|
brightness->builtin = false;
|
|
ffStrbufInitMove(&brightness->name, &name);
|
|
FF_DEBUG("Brightness DDC/CI: added display '%s' from bus %d (%u/%u)", brightness->name.chars, device, current, max);
|
|
}
|
|
|
|
cache->count = validCount;
|
|
FF_DEBUG("Brightness DDC/CI: cache validation kept %zu bus(es), result count is %u", validCount, result->length);
|
|
return result->length > resultLength;
|
|
}
|
|
|
|
const char* detectWithDdcci(FFBrightnessOptions* options, FFlist* result) {
|
|
FFBrightnessDdcCache cache = {0};
|
|
FF_DEBUG("Brightness DDC/CI: detection started (result count=%u)", result->length);
|
|
if (!loadCacheFromFile(&cache)) {
|
|
if (!scanI2cDevices(options, &cache)) {
|
|
FF_DEBUG("Brightness DDC/CI: no compatible I2C device found during initial scan");
|
|
return "No I2C devices found";
|
|
}
|
|
}
|
|
|
|
if (!detectCachedDevices(options, result, &cache)) {
|
|
FF_DEBUG("Brightness DDC/CI: cached detection found no usable display; rescanning");
|
|
if (!scanI2cDevices(options, &cache) || !detectCachedDevices(options, result, &cache)) {
|
|
FF_DEBUG("Brightness DDC/CI: rescan found no compatible display");
|
|
return "No DDC/CI compatible displays found";
|
|
}
|
|
}
|
|
|
|
saveCacheToFile(&cache);
|
|
FF_DEBUG("Brightness DDC/CI: detection finished with %u result(s)", result->length);
|
|
return nullptr;
|
|
}
|
|
|
|
#else
|
|
|
|
const char* detectWithDdcci([[maybe_unused]] FFBrightnessOptions* options, [[maybe_unused]] FFlist* result) {
|
|
FF_DEBUG("DDC/CI support is not available on this system");
|
|
return "DDC/CI is supported only on FreeBSD";
|
|
}
|
|
|
|
#endif
|
|
|
|
#if __has_include(<sys/backlight.h>)
|
|
#include <sys/backlight.h>
|
|
|
|
const char* detectWithBacklight([[maybe_unused]] FFBrightnessOptions* options, FFlist* result) {
|
|
// https://man.freebsd.org/cgi/man.cgi?query=backlight&sektion=9
|
|
char path[] = "/dev/backlight/backlight0";
|
|
|
|
for (char i = '0'; i <= '9'; ++i) {
|
|
path[ARRAY_SIZE(path) - 2] = i;
|
|
|
|
FF_AUTO_CLOSE_FD int fd = open(path, O_RDONLY | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
int err = errno;
|
|
if (err == ENOENT) {
|
|
FF_DEBUG("No more backlight devices");
|
|
break;
|
|
} else if (i == '0' && !ffKmodLoaded("backlight")) {
|
|
FF_DEBUG("backlight module is not loaded");
|
|
return "No backlight devices found and backlight module is not loaded";
|
|
}
|
|
FF_DEBUG("open(/dev/backlight/backlight%c) failed: %s", i, strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
struct backlight_props status;
|
|
if (ioctl(fd, BACKLIGHTGETSTATUS, &status) < 0) {
|
|
continue;
|
|
}
|
|
|
|
FFBrightnessResult* brightness = FF_LIST_ADD(FFBrightnessResult, *result);
|
|
ffStrbufInit(&brightness->name);
|
|
|
|
brightness->max = BACKLIGHTMAXLEVELS;
|
|
brightness->min = 0;
|
|
brightness->current = status.brightness;
|
|
brightness->builtin = true;
|
|
|
|
struct backlight_info info;
|
|
if (ioctl(fd, BACKLIGHTGETINFO, &info) == 0) {
|
|
ffStrbufAppendS(&brightness->name, info.name);
|
|
} else {
|
|
ffStrbufAppendS(&brightness->name, path + strlen("/dev/backlight/"));
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
#else
|
|
|
|
const char* detectWithBacklight([[maybe_unused]] FFBrightnessOptions* options, [[maybe_unused]] FFlist* result) {
|
|
FF_DEBUG("Backlight support is not available on this system");
|
|
return "Backlight is supported only on FreeBSD 13 and newer";
|
|
}
|
|
|
|
#endif
|
|
|
|
const char* ffDetectBrightness([[maybe_unused]] FFBrightnessOptions* options, FFlist* result) {
|
|
FF_DEBUG("Brightness: detection started (result count=%u)", result->length);
|
|
detectWithBacklight(options, result);
|
|
FF_DEBUG("Brightness: backlight detection finished (result count=%u)", result->length);
|
|
|
|
if (options->ddcciSleep != FF_BRIGHTNESS_DDCCI_SLEEP_SKIP && result->length == 0) {
|
|
FF_DEBUG("Brightness: trying DDC/CI because no backlight result was found");
|
|
detectWithDdcci(options, result);
|
|
} else if (options->ddcciSleep == FF_BRIGHTNESS_DDCCI_SLEEP_SKIP) {
|
|
FF_DEBUG("Brightness: skipping DDC/CI because it is disabled");
|
|
} else {
|
|
FF_DEBUG("Brightness: skipping DDC/CI because backlight detection already found %u result(s)", result->length);
|
|
}
|
|
FF_DEBUG("Brightness: detection finished (result count=%u)", result->length);
|
|
return nullptr;
|
|
}
|