| // 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 <cpuid.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <fidl/fuchsia.hardware.thermal/cpp/wire.h> |
| #include <fidl/fuchsia.kernel/cpp/wire.h> |
| #include <inttypes.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/component/incoming/cpp/protocol.h> |
| #include <lib/fdio/cpp/caller.h> |
| #include <lib/fdio/watcher.h> |
| #include <lib/syslog/cpp/macros.h> |
| #include <lib/trace-provider/provider.h> |
| #include <lib/trace/event.h> |
| #include <lib/zx/channel.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/syscalls/system.h> |
| |
| #include <future> |
| |
| #include <fbl/unique_fd.h> |
| |
| // degrees Celsius below threshold before we adjust PL value |
| constexpr float kCoolThresholdCelsius = 5.0f; |
| |
| class PlatformConfiguration { |
| public: |
| static std::unique_ptr<PlatformConfiguration> Create(zx::resource); |
| |
| zx_status_t SetMinPL1() { return SetPL1Mw(pl1_min_mw_); } |
| zx_status_t SetMaxPL1() { return SetPL1Mw(pl1_max_mw_); } |
| |
| bool IsAtMax() { return current_pl1_mw_ == pl1_max_mw_; } |
| bool IsAtMin() { return current_pl1_mw_ == pl1_min_mw_; } |
| |
| private: |
| PlatformConfiguration(uint32_t pl1_min_mw, uint32_t pl1_max_mw, zx::resource power_resource) |
| : pl1_min_mw_(pl1_min_mw), |
| pl1_max_mw_(pl1_max_mw), |
| power_resource_(std::move(power_resource)) {} |
| |
| zx_status_t SetPL1Mw(uint32_t target_mw); |
| |
| const uint32_t pl1_min_mw_; |
| const uint32_t pl1_max_mw_; |
| const zx::resource power_resource_; |
| |
| static constexpr uint32_t kEvePL1MinMw = 2500; |
| static constexpr uint32_t kEvePL1MaxMw = 7000; |
| |
| static constexpr uint32_t kAtlasPL1MinMw = 3000; |
| static constexpr uint32_t kAtlasPL1MaxMw = 7000; |
| |
| uint32_t current_pl1_mw_; |
| }; |
| |
| zx::result<zx::resource> get_power_resource() { |
| zx::result client_end = component::Connect<fuchsia_kernel::PowerResource>(); |
| if (client_end.is_error()) { |
| FX_PLOGS(ERROR, client_end.status_value()) << "Failed to open fuchsia.kernel.PowerResource"; |
| return client_end.take_error(); |
| } |
| fidl::WireSyncClient client{std::move(client_end.value())}; |
| fidl::WireResult result = client->Get(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "FIDL error while trying to get power resource"; |
| return zx::error(result.status()); |
| } |
| return zx::ok(std::move(result.value().resource)); |
| } |
| |
| std::unique_ptr<PlatformConfiguration> PlatformConfiguration::Create(zx::resource power_resource) { |
| 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 nullptr; |
| } |
| 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 std::unique_ptr<PlatformConfiguration>( |
| new PlatformConfiguration(kEvePL1MinMw, kEvePL1MaxMw, std::move(power_resource))); |
| } else if (strstr(brand_string, "i5-8200Y") || strstr(brand_string, "i7-8500Y") || |
| strstr(brand_string, "m3-8100Y")) { |
| return std::unique_ptr<PlatformConfiguration>( |
| new PlatformConfiguration(kAtlasPL1MinMw, kAtlasPL1MaxMw, std::move(power_resource))); |
| } |
| return nullptr; |
| } |
| |
| zx_status_t PlatformConfiguration::SetPL1Mw(uint32_t target_mw) { |
| zx_system_powerctl_arg_t arg = { |
| .x86_power_limit = |
| { |
| .power_limit = target_mw, |
| .time_window = 0, |
| .clamp = 1, |
| .enable = 1, |
| }, |
| }; |
| zx_status_t status = |
| zx_system_powerctl(power_resource_.get(), ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1, &arg); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to set PL1 to " << target_mw; |
| return status; |
| } |
| current_pl1_mw_ = target_mw; |
| TRACE_COUNTER("thermal", "throttle", 0, "pl1", target_mw); |
| return ZX_OK; |
| } |
| |
| void start_trace() { |
| // Create a message loop |
| static async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread); |
| static trace::TraceProviderWithFdio trace_provider(loop.dispatcher()); |
| static bool started = false; |
| if (!started) { |
| loop.StartThread(); |
| started = true; |
| } |
| } |
| |
| // TODO(https://fxbug.dev/42059997): This code here needs an update, it's using some very old patterns. |
| zx_status_t RunThermd() { |
| zx::result power_resource = get_power_resource(); |
| if (power_resource.is_error()) { |
| FX_PLOGS(ERROR, power_resource.status_value()) << "Failed to get power resource"; |
| return power_resource.status_value(); |
| } |
| |
| auto config = PlatformConfiguration::Create(std::move(power_resource.value())); |
| if (!config) { |
| // If there is no platform configuration then we should warn since thermd should only be |
| // included on devices where we expect it to run. |
| FX_LOGS(WARNING) << "no platform configuration found"; |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| FX_LOGS(INFO) << "started"; |
| |
| start_trace(); |
| |
| zx_nanosleep(zx_deadline_after(ZX_SEC(3))); |
| |
| fbl::unique_fd dirfd; |
| if (dirfd.reset(open("/dev/class/thermal", O_DIRECTORY | O_RDONLY)) < 0) { |
| FX_LOGS(ERROR) << "Failed to open /dev/class/thermal: " << strerror(errno); |
| return ZX_ERR_IO; |
| } |
| |
| std::optional<zx::result<fidl::ClientEnd<fuchsia_hardware_thermal::Device>>> device; |
| if (zx_status_t status = fdio_watch_directory( |
| dirfd.get(), |
| [](int dirfd, int event, const char* name, void* cookie) { |
| if (event != WATCH_EVENT_ADD_FILE) { |
| return ZX_OK; |
| } |
| if (std::string_view{name} == ".") { |
| return ZX_OK; |
| } |
| // first sensor is ambient sensor |
| // TODO(https://fxbug.dev/42059997): come up with a way to detect this is the ambient sensor |
| auto& device = *static_cast< |
| std::optional<zx::result<fidl::ClientEnd<fuchsia_hardware_thermal::Device>>>*>( |
| cookie); |
| fdio_cpp::UnownedFdioCaller caller(dirfd); |
| device.emplace( |
| component::ConnectAt<fuchsia_hardware_thermal::Device>(caller.directory(), name)); |
| return ZX_ERR_STOP; |
| }, |
| ZX_TIME_INFINITE, &device); |
| status != ZX_ERR_STOP) { |
| FX_PLOGS(ERROR, status) << "watcher terminating without finding sensors, terminating thermd..."; |
| return status; |
| } |
| |
| if (!device.has_value()) { |
| FX_LOGS(ERROR) << "watcher did not find sensors, terminating thermd..."; |
| return ZX_ERR_NOT_FOUND; |
| } |
| if (device.value().is_error()) { |
| FX_PLOGS(ERROR, device.value().status_value()) << "failed to connect to sensor"; |
| return device.value().status_value(); |
| } |
| fidl::WireSyncClient client{std::move(device.value().value())}; |
| |
| float temp; |
| { |
| const fidl::WireResult result = client->GetTemperatureCelsius(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get temperature"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get temperature"; |
| return status; |
| } |
| temp = response.temp; |
| TRACE_COUNTER("thermal", "temp", 0, "ambient-c", temp); |
| } |
| fuchsia_hardware_thermal::wire::ThermalInfo info; |
| { |
| const fidl::WireResult result = client->GetInfo(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get info"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get info"; |
| return status; |
| } |
| info = *response.info; |
| TRACE_COUNTER("thermal", "trip-point", 0, "passive-c", info.passive_temp_celsius, "critical-c", |
| info.critical_temp_celsius); |
| if (info.max_trip_count == 0) { |
| FX_LOGS(ERROR) << "Trip points not supported, exiting"; |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| } |
| zx::event h; |
| { |
| fidl::WireResult result = client->GetStateChangeEvent(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get state change event"; |
| return result.status(); |
| } |
| auto& response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get state change event"; |
| return status; |
| } |
| h = std::move(response.handle); |
| } |
| // Set a trip point. |
| { |
| const fidl::WireResult result = client->SetTripCelsius(0, info.passive_temp_celsius); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to set trip point"; |
| return result.status(); |
| } |
| const auto& response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to set trip point"; |
| return status; |
| } |
| } |
| // Update info. |
| { |
| const fidl::WireResult result = client->GetInfo(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get info"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get info"; |
| return status; |
| } |
| info = *response.info; |
| TRACE_COUNTER("thermal", "trip-point", 0, "passive-c", info.passive_temp_celsius, "critical-c", |
| info.critical_temp_celsius, "active0-c", info.active_trip[0]); |
| } |
| |
| // Set PL1 to the platform maximum. |
| config->SetMaxPL1(); |
| |
| for (;;) { |
| zx_signals_t observed = 0; |
| zx_status_t status = h.wait_one(ZX_USER_SIGNAL_0, zx::deadline_after(zx::sec(1)), &observed); |
| if ((status != ZX_OK) && (status != ZX_ERR_TIMED_OUT)) { |
| FX_PLOGS(ERROR, status) << "Failed to wait on event"; |
| return status; |
| } |
| if (observed & ZX_USER_SIGNAL_0) { |
| const fidl::WireResult result = client->GetInfo(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get info"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get info"; |
| return status; |
| } |
| info = *response.info; |
| if (info.state) { |
| // Decrease power limit |
| config->SetMinPL1(); |
| |
| const fidl::WireResult result = client->GetTemperatureCelsius(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get temperature"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get temperature"; |
| return status; |
| } |
| temp = response.temp; |
| } else { |
| TRACE_COUNTER("thermal", "event", 0, "spurious", temp); |
| } |
| } |
| if (status == ZX_ERR_TIMED_OUT) { |
| const fidl::WireResult result = client->GetTemperatureCelsius(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get temperature"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get temperature"; |
| return status; |
| } |
| temp = response.temp; |
| TRACE_COUNTER("thermal", "temp", 0, "ambient-c", temp); |
| |
| // Increase power limit if the temperature dropped enough |
| if (temp < info.active_trip[0] - kCoolThresholdCelsius && !config->IsAtMax()) { |
| // Make sure the state is clear |
| const fidl::WireResult result = client->GetInfo(); |
| if (!result.ok()) { |
| FX_PLOGS(ERROR, result.status()) << "Failed to get info"; |
| return result.status(); |
| } |
| const fidl::WireResponse response = result.value(); |
| if (zx_status_t status = response.status; status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to get info"; |
| return status; |
| } |
| info = *response.info; |
| if (!info.state) { |
| config->SetMaxPL1(); |
| } |
| } |
| |
| if (temp > info.active_trip[0] && !config->IsAtMin()) { |
| // Decrease power limit |
| config->SetMinPL1(); |
| } |
| } |
| } |
| // Do not return so that the compiler will catch it if this becomes reachable. |
| } |
| |
| int main(int argc, char** argv) { |
| zx_status_t status = RunThermd(); |
| |
| // RunThermd never returns successfully, so always treat this as an error path. |
| FX_LOGS(ERROR) << "Exited with status: " << zx_status_get_string(status); |
| |
| // TODO(https://fxbug.dev/42179909): Hang around. If we exit before archivist has started, our logs |
| // will be lost, and it's important that we know that thermd is failing and why. |
| std::promise<void>().get_future().wait(); |
| |
| return -1; |
| } |
