From 56960758adaa5716cb97b2515cb69e6b65dc4de0 Mon Sep 17 00:00:00 2001 From: Peiyong Lin Date: Fri, 30 Sep 2022 21:52:52 +0000 Subject: [PATCH] Convert Thermal HIDL to AIDL. This patch converts Thermal HIDL to AIDL and adds an empty example implementation. Bug: b/205762943 Test: atest VtsHalThermalTargetTest Change-Id: I0c80ac400cc41f50916dbed58bb48f878dfae17f --- .../compatibility_matrix.current.xml | 4 +- thermal/OWNERS | 5 + thermal/aidl/Android.bp | 39 ++++ .../hardware/thermal/CoolingDevice.aidl | 40 ++++ .../android/hardware/thermal/CoolingType.aidl | 48 +++++ .../android/hardware/thermal/IThermal.aidl | 46 ++++ .../thermal/IThermalChangedCallback.aidl | 38 ++++ .../android/hardware/thermal/Temperature.aidl | 41 ++++ .../thermal/TemperatureThreshold.aidl | 41 ++++ .../hardware/thermal/TemperatureType.aidl | 52 +++++ .../hardware/thermal/ThrottlingSeverity.aidl | 44 ++++ .../hardware/thermal/CoolingDevice.aidl | 41 ++++ .../android/hardware/thermal/CoolingType.aidl | 36 ++++ .../android/hardware/thermal/IThermal.aidl | 202 ++++++++++++++++++ .../thermal/IThermalChangedCallback.aidl | 34 +++ .../android/hardware/thermal/Temperature.aidl | 46 ++++ .../thermal/TemperatureThreshold.aidl | 49 +++++ .../hardware/thermal/TemperatureType.aidl | 46 ++++ .../hardware/thermal/ThrottlingSeverity.aidl | 55 +++++ thermal/aidl/default/Android.bp | 49 +++++ thermal/aidl/default/Thermal.cpp | 101 +++++++++ thermal/aidl/default/Thermal.h | 65 ++++++ thermal/aidl/default/main.cpp | 36 ++++ thermal/aidl/default/thermal-example.rc | 4 + thermal/aidl/default/thermal-example.xml | 7 + thermal/aidl/vts/Android.bp | 40 ++++ thermal/aidl/vts/VtsHalThermalTargetTest.cpp | 144 +++++++++++++ 27 files changed, 1351 insertions(+), 2 deletions(-) create mode 100644 thermal/OWNERS create mode 100644 thermal/aidl/Android.bp create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingDevice.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingType.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermal.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermalChangedCallback.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/Temperature.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureThreshold.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureType.aidl create mode 100644 thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/ThrottlingSeverity.aidl create mode 100644 thermal/aidl/android/hardware/thermal/CoolingDevice.aidl create mode 100644 thermal/aidl/android/hardware/thermal/CoolingType.aidl create mode 100644 thermal/aidl/android/hardware/thermal/IThermal.aidl create mode 100644 thermal/aidl/android/hardware/thermal/IThermalChangedCallback.aidl create mode 100644 thermal/aidl/android/hardware/thermal/Temperature.aidl create mode 100644 thermal/aidl/android/hardware/thermal/TemperatureThreshold.aidl create mode 100644 thermal/aidl/android/hardware/thermal/TemperatureType.aidl create mode 100644 thermal/aidl/android/hardware/thermal/ThrottlingSeverity.aidl create mode 100644 thermal/aidl/default/Android.bp create mode 100644 thermal/aidl/default/Thermal.cpp create mode 100644 thermal/aidl/default/Thermal.h create mode 100644 thermal/aidl/default/main.cpp create mode 100644 thermal/aidl/default/thermal-example.rc create mode 100644 thermal/aidl/default/thermal-example.xml create mode 100644 thermal/aidl/vts/Android.bp create mode 100644 thermal/aidl/vts/VtsHalThermalTargetTest.cpp diff --git a/compatibility_matrices/compatibility_matrix.current.xml b/compatibility_matrices/compatibility_matrix.current.xml index 5f5f95db64..2e724da018 100644 --- a/compatibility_matrices/compatibility_matrix.current.xml +++ b/compatibility_matrices/compatibility_matrix.current.xml @@ -664,9 +664,9 @@ default - + android.hardware.thermal - 2.0 + 1 IThermal default diff --git a/thermal/OWNERS b/thermal/OWNERS new file mode 100644 index 0000000000..7229b224b8 --- /dev/null +++ b/thermal/OWNERS @@ -0,0 +1,5 @@ +# Bug component: 826709 + +# ADPF virtual team +lpy@google.com +wvw@google.com diff --git a/thermal/aidl/Android.bp b/thermal/aidl/Android.bp new file mode 100644 index 0000000000..b132746d81 --- /dev/null +++ b/thermal/aidl/Android.bp @@ -0,0 +1,39 @@ +// Copyright (C) 2022 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. + +package { + // See: http://go/android-license-faq + // A large-scale-change added 'default_applicable_licenses' to import + // all of the 'license_kinds' from "hardware_interfaces_license" + // to get the below license kinds: + // SPDX-license-identifier-Apache-2.0 + default_applicable_licenses: ["hardware_interfaces_license"], +} + +aidl_interface { + name: "android.hardware.thermal", + vendor_available: true, + srcs: [ + "android/hardware/thermal/*.aidl", + ], + stability: "vintf", + backend: { + cpp: { + enabled: true, + }, + java: { + platform_apis: true, + }, + }, +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingDevice.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingDevice.aidl new file mode 100644 index 0000000000..50be5088d1 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingDevice.aidl @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2022 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 + * +1 * 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@VintfStability +parcelable CoolingDevice { + android.hardware.thermal.CoolingType type; + String name; + long value; +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingType.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingType.aidl new file mode 100644 index 0000000000..57c89398f6 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/CoolingType.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@Backing(type="int") @VintfStability +enum CoolingType { + FAN = 0, + BATTERY = 1, + CPU = 2, + GPU = 3, + MODEM = 4, + NPU = 5, + COMPONENT = 6, + TPU = 7, + POWER_AMPLIFIER = 8, + DISPLAY = 9, + SPEAKER = 10, +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermal.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermal.aidl new file mode 100644 index 0000000000..0aed5ecc12 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermal.aidl @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@VintfStability +interface IThermal { + android.hardware.thermal.CoolingDevice[] getCoolingDevices(); + android.hardware.thermal.CoolingDevice[] getCoolingDevicesWithType(in android.hardware.thermal.CoolingType type); + android.hardware.thermal.Temperature[] getTemperatures(); + android.hardware.thermal.Temperature[] getTemperaturesWithType(in android.hardware.thermal.TemperatureType type); + android.hardware.thermal.TemperatureThreshold[] getTemperatureThresholds(); + android.hardware.thermal.TemperatureThreshold[] getTemperatureThresholdsWithType(in android.hardware.thermal.TemperatureType type); + void registerThermalChangedCallback(in android.hardware.thermal.IThermalChangedCallback callback); + void registerThermalChangedCallbackWithType(in android.hardware.thermal.IThermalChangedCallback callback, in android.hardware.thermal.TemperatureType type); + void unregisterThermalChangedCallback(in android.hardware.thermal.IThermalChangedCallback callback); +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermalChangedCallback.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermalChangedCallback.aidl new file mode 100644 index 0000000000..6b3f922566 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/IThermalChangedCallback.aidl @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@VintfStability +interface IThermalChangedCallback { + oneway void notifyThrottling(in android.hardware.thermal.Temperature temperature); +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/Temperature.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/Temperature.aidl new file mode 100644 index 0000000000..71564153a2 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/Temperature.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@VintfStability +parcelable Temperature { + android.hardware.thermal.TemperatureType type; + String name; + float value; + android.hardware.thermal.ThrottlingSeverity throttlingStatus; +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureThreshold.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureThreshold.aidl new file mode 100644 index 0000000000..6da561fc13 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureThreshold.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@VintfStability +parcelable TemperatureThreshold { + android.hardware.thermal.TemperatureType type; + String name; + float[] hotThrottlingThresholds; + float[] coldThrottlingThresholds; +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureType.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureType.aidl new file mode 100644 index 0000000000..c6a08c18d1 --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/TemperatureType.aidl @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@Backing(type="int") @VintfStability +enum TemperatureType { + UNKNOWN = -1, + CPU = 0, + GPU = 1, + BATTERY = 2, + SKIN = 3, + USB_PORT = 4, + POWER_AMPLIFIER = 5, + BCL_VOLTAGE = 6, + BCL_CURRENT = 7, + BCL_PERCENTAGE = 8, + NPU = 9, + TPU = 10, + DISPLAY = 11, + MODEM = 12, + SOC = 13, +} diff --git a/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/ThrottlingSeverity.aidl b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/ThrottlingSeverity.aidl new file mode 100644 index 0000000000..e86b58183a --- /dev/null +++ b/thermal/aidl/aidl_api/android.hardware.thermal/current/android/hardware/thermal/ThrottlingSeverity.aidl @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.thermal; +@Backing(type="int") @VintfStability +enum ThrottlingSeverity { + NONE = 0, + LIGHT = 1, + MODERATE = 2, + SEVERE = 3, + CRITICAL = 4, + EMERGENCY = 5, + SHUTDOWN = 6, +} diff --git a/thermal/aidl/android/hardware/thermal/CoolingDevice.aidl b/thermal/aidl/android/hardware/thermal/CoolingDevice.aidl new file mode 100644 index 0000000000..6d974a5e78 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/CoolingDevice.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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 + * +1 * 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. + */ + +package android.hardware.thermal; + +import android.hardware.thermal.CoolingType; + +@VintfStability +parcelable CoolingDevice { + /** + * This cooling device type, CPU, GPU, BATTERY, and etc. + */ + CoolingType type; + /** + * Name of this cooling device. + * All cooling devices of the same "type" must have a different "name". + * The name is usually defined in kernel device tree, and this is for client + * logging purpose. + */ + String name; + /** + * Current throttle state of the cooling device. The value can any unsigned integer + * numbers between 0 and max_state defined in its driver, usually representing the + * associated device's power state. 0 means device is not in throttling, higher value + * means deeper throttling. + */ + long value; +} diff --git a/thermal/aidl/android/hardware/thermal/CoolingType.aidl b/thermal/aidl/android/hardware/thermal/CoolingType.aidl new file mode 100644 index 0000000000..1b430d2c55 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/CoolingType.aidl @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +/** + * Device cooling device types + */ +@VintfStability +@Backing(type="int") +enum CoolingType { + FAN, + BATTERY, + CPU, + GPU, + MODEM, + NPU, + COMPONENT, + TPU, + POWER_AMPLIFIER, + DISPLAY, + SPEAKER, +} diff --git a/thermal/aidl/android/hardware/thermal/IThermal.aidl b/thermal/aidl/android/hardware/thermal/IThermal.aidl new file mode 100644 index 0000000000..8b79cb44a0 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/IThermal.aidl @@ -0,0 +1,202 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +import android.hardware.thermal.CoolingDevice; +import android.hardware.thermal.CoolingType; +import android.hardware.thermal.IThermalChangedCallback; +import android.hardware.thermal.Temperature; +import android.hardware.thermal.TemperatureThreshold; +import android.hardware.thermal.TemperatureType; + +@VintfStability +interface IThermal { + /** + * Retrieves the cooling devices information. + * + * @return devices If succeed, it's filled with the + * current cooling device information. The order of built-in cooling + * devices in the list must be kept the same regardless the number + * of calls to this method even if they go offline, if these devices + * exist on boot. The method always returns and never removes from + * the list such cooling devices. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, getMessage() must be populated with the human-readable + * error message. + */ + CoolingDevice[] getCoolingDevices(); + + /** + * Retrieves the cooling devices information of a given CoolingType. + * + * @param type the CoolingDevice such as CPU/GPU. + * + * @return devices If succeed, it's filled with the current + * cooling device information. The order of built-in cooling + * devices in the list must be kept the same regardless of the number + * of calls to this method even if they go offline, if these devices + * exist on boot. The method always returns and never removes from + * the list such cooling devices. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. + */ + CoolingDevice[] getCoolingDevicesWithType(in CoolingType type); + + /** + * Retrieves temperatures in Celsius. + * + * @return temperatures If succeed, it's filled with the + * current temperatures. The order of temperatures of built-in + * devices (such as CPUs, GPUs and etc.) in the list must be kept + * the same regardless the number of calls to this method even if + * they go offline, if these devices exist on boot. The method + * always returns and never removes such temperatures. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. + */ + Temperature[] getTemperatures(); + + /** + * Retrieves temperatures in Celsius with a given TemperatureType. + * + * @param type the TemperatureType such as battery or skin. + * + * @return temperatures If succeed, it's filled with the + * current temperatures. The order of temperatures of built-in + * devices (such as CPUs, GPUs and etc.) in the list must be kept + * the same regardless of the number of calls to this method even if + * they go offline, if these devices exist on boot. The method + * always returns and never removes such temperatures. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. + */ + Temperature[] getTemperaturesWithType(in TemperatureType type); + + /** + * Retrieves static temperature thresholds in Celsius. + * + * @return temperatureThresholds If succeed, it's filled with the + * temperatures thresholds. The order of temperatures of built-in + * devices (such as CPUs, GPUs and etc.) in the list must be kept + * the same regardless of the number of calls to this method even if + * they go offline, if these devices exist on boot. The method + * always returns and never removes such temperatures. The thresholds + * are returned as static values and must not change across calls. The actual + * throttling state is determined in device thermal mitigation policy/agorithm + * which might not be simple thresholds so these values Thermal HAL provided + * may not be accurate to detemin the throttling status. To get accurate + * throttling status, use getTemperatures or registerThermalChangedCallback + * and listen to the callback. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. + */ + TemperatureThreshold[] getTemperatureThresholds(); + + /** + * Retrieves static temperature thresholds in Celsius of a given temperature + * type. + * + * @param type the TemperatureType such as battery or skin. + * + * @return temperatureThresholds If succeed, it's filled with the + * temperatures thresholds. The order of temperatures of built-in + * devices (such as CPUs, GPUs and etc.) in the list must be kept + * the same regardless of the number of calls to this method even if + * they go offline, if these devices exist on boot. The method + * always returns and never removes such temperatures. The thresholds + * are returned as static values and must not change across calls. The actual + * throttling state is determined in device thermal mitigation policy/agorithm + * which might not be simple thresholds so these values Thermal HAL provided + * may not be accurate to detemin the throttling status. To get accurate + * throttling status, use getTemperatures or registerThermalChangedCallback + * and listen to the callback. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. + */ + TemperatureThreshold[] getTemperatureThresholdsWithType(in TemperatureType type); + + /** + * Register an IThermalChangedCallback, used by the Thermal HAL to receive + * thermal events when thermal mitigation status changed. + * Multiple registrations with different IThermalChangedCallback must be allowed. + * Multiple registrations with same IThermalChangedCallback is not allowed, client + * should unregister the given IThermalChangedCallback first. + * + * @param callback the IThermalChangedCallback to use for receiving + * thermal events. if nullptr callback is given, the status code will be + * STATUS_BAD_VALUE and the operation will fail. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. If callback is given nullptr, the returned status code + * will be STATUS_BAD_VALUE and the exception will be EX_ILLEGAL_ARGUMENT. + * if callback is already registered, the returned status code will be + * STATUS_INVALID_OPERATION, the exception will be EX_ILLEGAL_ARGUMENT. + */ + void registerThermalChangedCallback(in IThermalChangedCallback callback); + + /** + * Register an IThermalChangedCallback for a given TemperatureType, used by + * the Thermal HAL to receive thermal events when thermal mitigation status + * changed. + * Multiple registrations with different IThermalChangedCallback must be allowed. + * Multiple registrations with same IThermalChangedCallback is not allowed, client + * should unregister the given IThermalChangedCallback first. + * + * @param callback the IThermalChangedCallback to use for receiving + * thermal events. if nullptr callback is given, the status code will be + * STATUS_BAD_VALUE and the operation will fail. + * @param type the type to be filtered. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. If callback is given nullptr, the returned status code + * will be STATUS_BAD_VALUE and the exception will be EX_ILLEGAL_ARGUMENT. + * if callback is already registered, the returned status code will be + * STATUS_INVALID_OPERATION, the exception will be EX_ILLEGAL_ARGUMENT. + */ + void registerThermalChangedCallbackWithType( + in IThermalChangedCallback callback, in TemperatureType type); + + /** + * Unregister an IThermalChangedCallback, used by the Thermal HAL + * to receive thermal events when thermal mitigation status changed. + * + * @param callback the IThermalChangedCallback to use for receiving + * thermal events. if nullptr callback is given, the status code will be + * STATUS_BAD_VALUE and the operation will fail. + * + * @throws ScopedAStatus Status of the operation. If status code is not + * STATUS_OK, the getMessage() must be populated with the human-readable + * error message. If callback is given nullptr, the returned status code + * will be STATUS_BAD_VALUE and the exception will be EX_ILLEGAL_ARGUMENT. + * if callback is not registered, the returned status code will be + * STATUS_INVALID_OPERATION, the exception will be EX_ILLEGAL_ARGUMENT. + */ + void unregisterThermalChangedCallback(in IThermalChangedCallback callback); +} diff --git a/thermal/aidl/android/hardware/thermal/IThermalChangedCallback.aidl b/thermal/aidl/android/hardware/thermal/IThermalChangedCallback.aidl new file mode 100644 index 0000000000..6fe2dac686 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/IThermalChangedCallback.aidl @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +import android.hardware.thermal.Temperature; + +/** + * IThermalChangedCallback send throttling notification to clients. + */ +@VintfStability +interface IThermalChangedCallback { + /** + * Send a thermal throttling event to all ThermalHAL + * thermal event listeners. + * + * @param temperature The temperature associated with the + * throttling event. + */ + oneway void notifyThrottling(in Temperature temperature); +} diff --git a/thermal/aidl/android/hardware/thermal/Temperature.aidl b/thermal/aidl/android/hardware/thermal/Temperature.aidl new file mode 100644 index 0000000000..f0041ed7b5 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/Temperature.aidl @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +import android.hardware.thermal.TemperatureType; +import android.hardware.thermal.ThrottlingSeverity; + +@VintfStability +parcelable Temperature { + /** + * This temperature's type. + */ + TemperatureType type; + /** + * Name of this temperature matching the TemperatureThreshold. + * All temperatures of the same "type" must have a different "name", + * e.g., cpu0, battery. Clients use it to match with TemperatureThreshold + * struct. + */ + String name; + /** + * For BCL, this is the current reading of the virtual sensor and the unit is + * millivolt, milliamp, percentage for BCL_VOLTAGE, BCL_CURRENT and BCL_PERCENTAGE + * respectively. For everything else, this is the current temperature in Celsius. + * If not available set by HAL to NAN. + */ + float value; + /** + * The current throttling level of the sensor. + */ + ThrottlingSeverity throttlingStatus; +} diff --git a/thermal/aidl/android/hardware/thermal/TemperatureThreshold.aidl b/thermal/aidl/android/hardware/thermal/TemperatureThreshold.aidl new file mode 100644 index 0000000000..9ecdab3178 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/TemperatureThreshold.aidl @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +import android.hardware.thermal.TemperatureType; + +@VintfStability +parcelable TemperatureThreshold { + /** + * This temperature's type. + */ + TemperatureType type; + /** + * Name of this temperature matching the Temperature struct. + * All temperatures of the same "type" must have a different "name", + * e.g., cpu0, battery. Clients use it to match Temperature struct. + */ + String name; + /** + * Hot throttling temperature constant for this temperature sensor in + * level defined in ThrottlingSeverity including shutdown. Throttling + * happens when temperature >= threshold. If not available, set to NAN. + * Unit is same as Temperature's value. + * The number of thresholds must be the same as ThrottlingSeverity#len. + */ + float[] hotThrottlingThresholds; + /** + * Cold throttling temperature constant for this temperature sensor in + * level defined in ThrottlingSeverity including shutdown. Throttling + * happens when temperature <= threshold. If not available, set to NAN. + * Unit is same as Temperature's value. + * The number of theresholds must be the same as ThrottlingSeverity#len. + */ + float[] coldThrottlingThresholds; +} diff --git a/thermal/aidl/android/hardware/thermal/TemperatureType.aidl b/thermal/aidl/android/hardware/thermal/TemperatureType.aidl new file mode 100644 index 0000000000..aebe7ce087 --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/TemperatureType.aidl @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +/** + * Device temperature types + */ +@VintfStability +@Backing(type="int") +enum TemperatureType { + UNKNOWN = -1, + CPU = 0, + GPU = 1, + BATTERY = 2, + SKIN = 3, + USB_PORT = 4, + POWER_AMPLIFIER = 5, + /** + * Battery Current Limit - virtual sensors + */ + BCL_VOLTAGE = 6, + BCL_CURRENT = 7, + BCL_PERCENTAGE = 8, + /** + * Neural Processing Unit + */ + NPU = 9, + TPU = 10, + DISPLAY = 11, + MODEM = 12, + SOC = 13, +} diff --git a/thermal/aidl/android/hardware/thermal/ThrottlingSeverity.aidl b/thermal/aidl/android/hardware/thermal/ThrottlingSeverity.aidl new file mode 100644 index 0000000000..29f072434b --- /dev/null +++ b/thermal/aidl/android/hardware/thermal/ThrottlingSeverity.aidl @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.thermal; + +/** + * Device throttling severity + */ +@VintfStability +@Backing(type="int") +enum ThrottlingSeverity { + /** + * Not under throttling. + */ + NONE = 0, + /** + * Light throttling where UX is not impacted. + */ + LIGHT, + /** + * Moderate throttling where UX is not largely impacted. + */ + MODERATE, + /** + * Severe throttling where UX is largely impacted. + * Similar to 1.0 throttlingThreshold. + */ + SEVERE, + /** + * Platform has done everything to reduce power. + */ + CRITICAL, + /** + * Key components in platform are shutting down due to thermal condition. + * Device functionalities will be limited. + */ + EMERGENCY, + /** + * Need shutdown immediately. + */ + SHUTDOWN, +} diff --git a/thermal/aidl/default/Android.bp b/thermal/aidl/default/Android.bp new file mode 100644 index 0000000000..49a578b45e --- /dev/null +++ b/thermal/aidl/default/Android.bp @@ -0,0 +1,49 @@ +// Copyright (C) 2022 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. + +package { + // See: http://go/android-license-faq + // A large-scale-change added 'default_applicable_licenses' to import + // all of the 'license_kinds' from "hardware_interfaces_license" + // to get the below license kinds: + // SPDX-license-identifier-Apache-2.0 + default_applicable_licenses: ["hardware_interfaces_license"], +} + +cc_binary { + name: "android.hardware.thermal-service.example", + relative_install_path: "hw", + init_rc: [":android.hardware.thermal.example.rc"], + vintf_fragments: [":android.hardware.thermal.example.xml"], + vendor: true, + shared_libs: [ + "libbase", + "libbinder_ndk", + "android.hardware.thermal-V1-ndk", + ], + srcs: [ + "main.cpp", + "Thermal.cpp", + ], +} + +filegroup { + name: "android.hardware.thermal.example.xml", + srcs: ["thermal-example.xml"], +} + +filegroup { + name: "android.hardware.thermal.example.rc", + srcs: ["thermal-example.rc"], +} diff --git a/thermal/aidl/default/Thermal.cpp b/thermal/aidl/default/Thermal.cpp new file mode 100644 index 0000000000..5771e0edcd --- /dev/null +++ b/thermal/aidl/default/Thermal.cpp @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2022 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 "Thermal.h" + +#include + +namespace aidl::android::hardware::thermal::impl::example { + +using ndk::ScopedAStatus; + +ScopedAStatus Thermal::getCoolingDevices(std::vector* /* out_devices */) { + LOG(VERBOSE) << __func__; + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::getCoolingDevicesWithType(CoolingType in_type, + std::vector* /* out_devices */) { + LOG(VERBOSE) << __func__ << " CoolingType: " << static_cast(in_type); + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::getTemperatures(std::vector* /* out_temperatures */) { + LOG(VERBOSE) << __func__; + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::getTemperaturesWithType(TemperatureType in_type, + std::vector* /* out_temperatures */) { + LOG(VERBOSE) << __func__ << " TemperatureType: " << static_cast(in_type); + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::getTemperatureThresholds( + std::vector* /* out_temperatureThresholds */) { + LOG(VERBOSE) << __func__; + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::getTemperatureThresholdsWithType( + TemperatureType in_type, + std::vector* /* out_temperatureThresholds */) { + LOG(VERBOSE) << __func__ << " TemperatureType: " << static_cast(in_type); + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::registerThermalChangedCallback( + const std::shared_ptr& in_callback) { + LOG(VERBOSE) << __func__ << " IThermalChangedCallback: " << in_callback; + if (in_callback == nullptr) { + return ScopedAStatus::fromStatus(STATUS_BAD_VALUE); + } + if (mCallbacks.find(in_callback) != mCallbacks.end()) { + return ScopedAStatus::fromStatus(STATUS_INVALID_OPERATION); + } + mCallbacks.insert(in_callback); + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::registerThermalChangedCallbackWithType( + const std::shared_ptr& in_callback, TemperatureType in_type) { + LOG(VERBOSE) << __func__ << " IThermalChangedCallback: " << in_callback + << ", TemperatureType: " << static_cast(in_type); + if (in_callback == nullptr) { + return ScopedAStatus::fromStatus(STATUS_BAD_VALUE); + } + if (mCallbacks.find(in_callback) != mCallbacks.end()) { + return ScopedAStatus::fromStatus(STATUS_INVALID_OPERATION); + } + mCallbacks.insert(in_callback); + return ScopedAStatus::ok(); +} + +ScopedAStatus Thermal::unregisterThermalChangedCallback( + const std::shared_ptr& in_callback) { + LOG(VERBOSE) << __func__ << " IThermalChangedCallback: " << in_callback; + bool found = false; + if (in_callback == nullptr) { + return ScopedAStatus::fromStatus(STATUS_BAD_VALUE); + } + if (mCallbacks.find(in_callback) == mCallbacks.end()) { + return ScopedAStatus::fromStatus(STATUS_INVALID_OPERATION); + } + mCallbacks.erase(in_callback); + return ScopedAStatus::ok(); +} + +} // namespace aidl::android::hardware::thermal::impl::example diff --git a/thermal/aidl/default/Thermal.h b/thermal/aidl/default/Thermal.h new file mode 100644 index 0000000000..788af4aae1 --- /dev/null +++ b/thermal/aidl/default/Thermal.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2022 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. + */ + +#pragma once + +#include + +#include + +namespace aidl { +namespace android { +namespace hardware { +namespace thermal { +namespace impl { +namespace example { + +class Thermal : public BnThermal { + public: + ndk::ScopedAStatus getCoolingDevices(std::vector* out_devices) override; + ndk::ScopedAStatus getCoolingDevicesWithType(CoolingType in_type, + std::vector* out_devices) override; + + ndk::ScopedAStatus getTemperatures(std::vector* out_temperatures) override; + ndk::ScopedAStatus getTemperaturesWithType(TemperatureType in_type, + std::vector* out_temperatures) override; + + ndk::ScopedAStatus getTemperatureThresholds( + std::vector* out_temperatureThresholds) override; + + ndk::ScopedAStatus getTemperatureThresholdsWithType( + TemperatureType in_type, + std::vector* out_temperatureThresholds) override; + + ndk::ScopedAStatus registerThermalChangedCallback( + const std::shared_ptr& in_callback) override; + ndk::ScopedAStatus registerThermalChangedCallbackWithType( + const std::shared_ptr& in_callback, + TemperatureType in_type) override; + + ndk::ScopedAStatus unregisterThermalChangedCallback( + const std::shared_ptr& in_callback) override; + + private: + std::set> mCallbacks; +}; + +} // namespace example +} // namespace impl +} // namespace thermal +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/thermal/aidl/default/main.cpp b/thermal/aidl/default/main.cpp new file mode 100644 index 0000000000..61d8ad091c --- /dev/null +++ b/thermal/aidl/default/main.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 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 "Thermal.h" + +#include +#include +#include + +using aidl::android::hardware::thermal::impl::example::Thermal; + +int main() { + ABinderProcess_setThreadPoolMaxThreadCount(0); + std::shared_ptr thermal = ndk::SharedRefBase::make(); + + const std::string instance = std::string() + Thermal::descriptor + "/default"; + binder_status_t status = + AServiceManager_addService(thermal->asBinder().get(), instance.c_str()); + CHECK(status == STATUS_OK); + + ABinderProcess_joinThreadPool(); + return EXIT_FAILURE; // should not reach +} diff --git a/thermal/aidl/default/thermal-example.rc b/thermal/aidl/default/thermal-example.rc new file mode 100644 index 0000000000..591ca036bd --- /dev/null +++ b/thermal/aidl/default/thermal-example.rc @@ -0,0 +1,4 @@ +service vendor.thermal-example /vendor/bin/hw/android.hardware.thermal-service.example + class hal + user nobody + group system diff --git a/thermal/aidl/default/thermal-example.xml b/thermal/aidl/default/thermal-example.xml new file mode 100644 index 0000000000..bdee7446f0 --- /dev/null +++ b/thermal/aidl/default/thermal-example.xml @@ -0,0 +1,7 @@ + + + android.hardware.thermal + 1 + IThermal/default + + diff --git a/thermal/aidl/vts/Android.bp b/thermal/aidl/vts/Android.bp new file mode 100644 index 0000000000..b00eb33b1d --- /dev/null +++ b/thermal/aidl/vts/Android.bp @@ -0,0 +1,40 @@ +// Copyright (C) 2022 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. + +package { + // See: http://go/android-license-faq + // A large-scale-change added 'default_applicable_licenses' to import + // all of the 'license_kinds' from "hardware_interfaces_license" + // to get the below license kinds: + // SPDX-license-identifier-Apache-2.0 + default_applicable_licenses: ["hardware_interfaces_license"], +} + +cc_test { + name: "VtsHalThermalTargetTest", + defaults: [ + "VtsHalTargetTestDefaults", + "use_libaidlvintf_gtest_helper_static", + ], + srcs: ["VtsHalThermalTargetTest.cpp"], + shared_libs: [ + "libbinder_ndk", + ], + static_libs: [ + "android.hardware.thermal-V1-ndk", + ], + test_suites: [ + "vts", + ], +} diff --git a/thermal/aidl/vts/VtsHalThermalTargetTest.cpp b/thermal/aidl/vts/VtsHalThermalTargetTest.cpp new file mode 100644 index 0000000000..b93250e9d1 --- /dev/null +++ b/thermal/aidl/vts/VtsHalThermalTargetTest.cpp @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2022 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 +#include +#include +#include +#include +#include +#include + +#define LOG_TAG "thermal_aidl_hal_test" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace aidl::android::hardware::thermal { + +namespace { + +using ::android::sp; +using android::hardware::thermal::CoolingDevice; +using android::hardware::thermal::IThermal; +using android::hardware::thermal::Temperature; +using android::hardware::thermal::TemperatureType; + +using namespace std::string_literals; +using namespace std::chrono_literals; + +static const Temperature kThrottleTemp = { + .type = TemperatureType::SKIN, + .name = "test temperature sensor", + .value = 98.6, + .throttlingStatus = ThrottlingSeverity::CRITICAL, +}; + +// Callback class for receiving thermal event notifications from main class +class ThermalCallback : public BnThermalChangedCallback { + public: + ndk::ScopedAStatus notifyThrottling(const Temperature&) override { + { + std::lock_guard lock(mMutex); + mInvoke = true; + } + mNotifyThrottling.notify_all(); + return ndk::ScopedAStatus::ok(); + } + + template + [[nodiscard]] bool waitForCallback(std::chrono::duration duration) { + std::unique_lock lock(mMutex); + bool r = mNotifyThrottling.wait_for(lock, duration, [this] { return this->mInvoke; }); + mInvoke = false; + return r; + } + + private: + std::mutex mMutex; + std::condition_variable mNotifyThrottling; + bool mInvoke = false; +}; + +// The main test class for THERMAL HIDL HAL. +class ThermalAidlTest : public testing::TestWithParam { + public: + void SetUp() override { + AIBinder* binder = AServiceManager_waitForService(GetParam().c_str()); + ASSERT_NE(binder, nullptr); + mThermal = IThermal::fromBinder(ndk::SpAIBinder(binder)); + + mThermalCallback = ndk::SharedRefBase::make(); + ASSERT_NE(mThermalCallback, nullptr); + auto ret = mThermal->registerThermalChangedCallback(mThermalCallback); + ASSERT_TRUE(ret.isOk()); + // Expect to fail if register again + ret = mThermal->registerThermalChangedCallback(mThermalCallback); + ASSERT_FALSE(ret.isOk()); + ASSERT_TRUE(ret.getStatus() == STATUS_INVALID_OPERATION); + } + + void TearDown() override { + auto ret = mThermal->unregisterThermalChangedCallback(mThermalCallback); + ASSERT_TRUE(ret.isOk()); + // Expect to fail if unregister again + ret = mThermal->unregisterThermalChangedCallback(mThermalCallback); + ASSERT_FALSE(ret.isOk()); + ASSERT_TRUE(ret.getStatus() == STATUS_INVALID_OPERATION); + } + + protected: + std::shared_ptr mThermal; + std::shared_ptr mThermalCallback; +}; + +// Test ThermalChangedCallback::notifyThrottling(). +// This just calls into and back from our local ThermalChangedCallback impl. +TEST_P(ThermalAidlTest, NotifyThrottlingTest) { + std::shared_ptr thermalCallback = ndk::SharedRefBase::make(); + auto ret = thermalCallback->notifyThrottling(kThrottleTemp); + ASSERT_TRUE(ret.isOk()); + ASSERT_TRUE(thermalCallback->waitForCallback(200ms)); +} + +GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ThermalAidlTest); +INSTANTIATE_TEST_SUITE_P( + Thermal, ThermalAidlTest, + testing::ValuesIn(::android::getAidlHalInstanceNames(IThermal::descriptor)), + ::android::PrintInstanceNameToString); + +} // namespace + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + ABinderProcess_setThreadPoolMaxThreadCount(1); + ABinderProcess_startThreadPool(); + return RUN_ALL_TESTS(); +} + +} // namespace aidl::android::hardware::thermal