| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fuchsia/hardware/thermal/c/fidl.h> |
| #include <fuchsia/sysinfo/c/fidl.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/syscalls/system.h> |
| |
| #include <lib/async-loop/cpp/loop.h> |
| |
| #include <lib/fdio/watcher.h> |
| #include <lib/fdio/fd.h> |
| #include <lib/fdio/fdio.h> |
| #include <lib/fdio/directory.h> |
| #include <lib/fzl/fdio.h> |
| #include <lib/zx/channel.h> |
| #include <trace-provider/provider.h> |
| #include <trace/event.h> |
| |
| #include <cpuid.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <inttypes.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| static zx_handle_t root_resource; |
| |
| static uint32_t pl1_mw; // current PL1 value |
| |
| #define PL1_MIN 2500 |
| #define PL1_MAX 7000 |
| |
| static constexpr uint32_t COOL_TEMP_THRESHOLD = |
| 50; // degrees in kelvins below threshold before |
| // we adjust PL value |
| |
| static zx_status_t get_root_resource(zx_handle_t* root_resource) { |
| int fd = open("/dev/misc/sysinfo", O_RDWR); |
| if (fd < 0) { |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| zx::channel channel; |
| zx_status_t status = |
| fdio_get_service_handle(fd, channel.reset_and_get_address()); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource( |
| channel.get(), &status, root_resource); |
| if (fidl_status != ZX_OK) { |
| return fidl_status; |
| } |
| return status; |
| } |
| |
| static zx_status_t set_pl1(uint32_t target) { |
| zx_system_powerctl_arg_t arg = { |
| .x86_power_limit = |
| { |
| .power_limit = target, |
| .time_window = 0, |
| .clamp = 1, |
| .enable = 1, |
| }, |
| }; |
| zx_status_t st = zx_system_powerctl(root_resource, |
| ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1, &arg); |
| if (st != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to set PL1 to %d: %d\n", target, st); |
| return st; |
| } |
| pl1_mw = target; |
| TRACE_COUNTER("thermal", "throttle", 0, "pl1", target); |
| return ZX_OK; |
| } |
| |
| static uint32_t to_celsius(uint32_t val) { |
| // input is 10th of a kelvin |
| return (val * 10 - 27315) / 100; |
| } |
| |
| static uint32_t to_kelvin(uint32_t celsius) __attribute__((unused)); |
| |
| static uint32_t to_kelvin(uint32_t celsius) { |
| // return in 10th of a kelvin |
| return (celsius * 100 + 27315) / 10; |
| } |
| |
| static zx_status_t thermal_device_added(int dirfd, int event, const char* name, |
| void* cookie) { |
| if (event != WATCH_EVENT_ADD_FILE) { |
| return ZX_OK; |
| } |
| if (!strcmp("000", name)) { |
| // Device found, terminate watcher |
| return ZX_ERR_STOP; |
| } else { |
| return ZX_OK; |
| } |
| } |
| |
| static void start_trace(void) { |
| // Create a message loop |
| static async::Loop loop(&kAsyncLoopConfigNoAttachToThread); |
| static trace::TraceProvider trace_provider(loop.dispatcher()); |
| static bool started = false; |
| if (!started) { |
| printf("thermd: start trace\n"); |
| loop.StartThread(); |
| started = true; |
| } |
| } |
| |
| static bool check_platform() { |
| unsigned int a, b, c, d; |
| unsigned int leaf_num = 0x80000002; |
| char brand_string[50]; |
| memset(brand_string, 0, sizeof(brand_string)); |
| for (int i = 0; i < 3; i++) { |
| if (!__get_cpuid(leaf_num + i, &a, &b, &c, &d)) { |
| return false; |
| } |
| memcpy(brand_string + (i * 16), &a, sizeof(uint32_t)); |
| memcpy(brand_string + (i * 16) + 4, &b, sizeof(uint32_t)); |
| memcpy(brand_string + (i * 16) + 8, &c, sizeof(uint32_t)); |
| memcpy(brand_string + (i * 16) + 12, &d, sizeof(uint32_t)); |
| } |
| // Only run thermd for processors used in Pixelbooks. The PL1 min/max settings |
| // are specified by the chipset. |
| if (strstr(brand_string, "i5-7Y57") || strstr(brand_string, "i7-7Y75")) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| int main(int argc, char** argv) { |
| if (!check_platform()) { |
| return 0; |
| } |
| |
| printf("thermd: started\n"); |
| |
| start_trace(); |
| |
| zx_status_t st = get_root_resource(&root_resource); |
| if (st != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get root resource: %d\n", st); |
| return -1; |
| } |
| |
| zx_nanosleep(zx_deadline_after(ZX_SEC(3))); |
| |
| int dirfd = open("/dev/class/thermal", O_DIRECTORY | O_RDONLY); |
| if (dirfd < 0) { |
| fprintf(stderr, "ERROR: Failed to open /dev/class/thermal: %d (errno %d)\n", |
| dirfd, errno); |
| return -1; |
| } |
| |
| st = |
| fdio_watch_directory(dirfd, thermal_device_added, ZX_TIME_INFINITE, NULL); |
| |
| if (st != ZX_ERR_STOP) { |
| fprintf(stderr, |
| "ERROR: watcher terminating without finding sensors, " |
| "terminating thermd...\n"); |
| return -1; |
| } |
| |
| // first sensor is ambient sensor |
| // TODO: come up with a way to detect this is the ambient sensor |
| fbl::unique_fd fd(open("/dev/class/thermal/000", O_RDWR)); |
| if (fd.get() < 0) { |
| fprintf(stderr, "ERROR: Failed to open sensor: %d\n", fd.get()); |
| return -1; |
| } |
| |
| uint32_t temp; |
| ssize_t rc = read(fd.get(), &temp, sizeof(temp)); |
| if (rc != sizeof(temp)) { |
| return rc; |
| } |
| TRACE_COUNTER("thermal", "temp", 0, "ambient-c", to_celsius(temp)); |
| |
| fzl::FdioCaller caller(std::move(fd)); |
| |
| zx_status_t status2; |
| fuchsia_hardware_thermal_ThermalInfo info; |
| st = fuchsia_hardware_thermal_DeviceGetInfo(caller.borrow_channel(), &status2, |
| &info); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get thermal info: %d %d\n", st, status2); |
| return -1; |
| } |
| |
| TRACE_COUNTER("thermal", "trip-point", 0, "passive-c", |
| to_celsius(info.passive_temp), "critical-c", |
| to_celsius(info.critical_temp)); |
| |
| zx_handle_t h = ZX_HANDLE_INVALID; |
| st = fuchsia_hardware_thermal_DeviceGetStateChangeEvent( |
| caller.borrow_channel(), &status2, &h); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get event: %d %d\n", st, status2); |
| return -1; |
| } |
| |
| if (info.max_trip_count == 0) { |
| fprintf(stderr, "Trip points not supported, exiting\n"); |
| return 0; |
| } |
| |
| // Set a trip point |
| st = fuchsia_hardware_thermal_DeviceSetTrip(caller.borrow_channel(), 0, |
| info.passive_temp, &status2); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to set trip point: %d %d\n", st, status2); |
| return -1; |
| } |
| |
| // Update info |
| st = fuchsia_hardware_thermal_DeviceGetInfo(caller.borrow_channel(), &status2, |
| &info); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get thermal info: %d %d\n", st, status2); |
| return -1; |
| } |
| TRACE_COUNTER("thermal", "trip-point", 0, "passive-c", |
| to_celsius(info.passive_temp), "critical-c", |
| to_celsius(info.critical_temp), "active0-c", |
| to_celsius(info.active_trip[0])); |
| |
| // set PL1 to 7 watts (EDP) |
| set_pl1(PL1_MAX); |
| |
| for (;;) { |
| zx_signals_t observed = 0; |
| st = zx_object_wait_one(h, ZX_USER_SIGNAL_0, zx_deadline_after(ZX_SEC(1)), |
| &observed); |
| if ((st != ZX_OK) && (st != ZX_ERR_TIMED_OUT)) { |
| fprintf(stderr, "ERROR: Failed to wait on event: %d\n", st); |
| return st; |
| } |
| if (observed & ZX_USER_SIGNAL_0) { |
| st = fuchsia_hardware_thermal_DeviceGetInfo(caller.borrow_channel(), |
| &status2, &info); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get thermal info: %d %d\n", st, |
| status2); |
| return -1; |
| } |
| if (info.state) { |
| set_pl1(PL1_MIN); // decrease power limit |
| |
| rc = read(caller.fd().get(), &temp, sizeof(temp)); |
| if (rc != sizeof(temp)) { |
| fprintf(stderr, "ERROR: Failed to read temperature: %zd\n", rc); |
| return rc; |
| } |
| } else { |
| TRACE_COUNTER("thermal", "event", 0, "spurious", to_celsius(temp)); |
| } |
| } |
| if (st == ZX_ERR_TIMED_OUT) { |
| rc = read(caller.fd().get(), &temp, sizeof(temp)); |
| if (rc != sizeof(temp)) { |
| fprintf(stderr, "ERROR: Failed to read temperature: %zd\n", rc); |
| return rc; |
| } |
| TRACE_COUNTER("thermal", "temp", 0, "ambient-c", to_celsius(temp)); |
| |
| // increase power limit if the temperature dropped enough |
| if ((temp < info.active_trip[0] - COOL_TEMP_THRESHOLD) && |
| (pl1_mw != PL1_MAX)) { |
| // make sure the state is clear |
| st = fuchsia_hardware_thermal_DeviceGetInfo(caller.borrow_channel(), |
| &status2, &info); |
| if (st != ZX_OK || status2 != ZX_OK) { |
| fprintf(stderr, "ERROR: Failed to get thermal info: %d %d\n", st, |
| status2); |
| return -1; |
| } |
| if (!info.state) { |
| set_pl1(PL1_MAX); |
| } |
| } |
| |
| if ((temp > info.active_trip[0]) && (pl1_mw != PL1_MIN)) { |
| set_pl1(PL1_MIN); // decrease power limit |
| } |
| } |
| } |
| |
| printf("thermd terminating: %d\n", st); |
| |
| return 0; |
| } |
