scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2026-01-09 09:01:35 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
7189a9762e1ec8a35dd27e6efc19cd54275eb855
OpenCellular/test/thermal.c
Randall Spangler 873e4425c5 Remove unneeded direct includes of board.h and config.h 
Both of these are included via common.h, which is in turn included by
most other header files.  Directly including board.h or config.h is
redundant and discouraged.

No code changes, just removing #includes.

This is in preparation for making a top-level config.h file, but that
change will be easier to review if it doesn't touch as many files.

BUG=chrome-os-partner:18343
BRANCH=none
TEST=build all platforms

Change-Id: I204bcebe5607c6e6808821eb071cfc31d2a93a7c
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/62121
Reviewed-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-by: Vincent Palatin <vpalatin@chromium.org>
2013-07-16 12:06:30 -07:00

427 lines
10 KiB
C
Raw Blame History

/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* Test thermal engine.
*/
#include "common.h"
#include "console.h"
#include "hooks.h"
#include "host_command.h"
#include "printf.h"
#include "temp_sensor.h"
#include "test_util.h"
#include "thermal.h"
#include "timer.h"
#include "util.h"
static int mock_temp[TEMP_SENSOR_COUNT];
static int fan_rpm;
static int fan_rpm_mode = 1;
static int cpu_throttled;
static int cpu_down;
extern struct thermal_config_t thermal_config[TEMP_SENSOR_TYPE_COUNT];
extern const int fan_speed[THERMAL_FAN_STEPS + 1];
/*****************************************************************************/
/* Mock functions */
int temp_sensor_read(enum temp_sensor_id id, int *temp_ptr)
{
if (mock_temp[id] >= 0) {
*temp_ptr = mock_temp[id];
return EC_SUCCESS;
} else {
return -mock_temp[id];
}
}
void pwm_set_fan_rpm_mode(int rpm_mode)
{
fan_rpm_mode = rpm_mode;
}
void pwm_set_fan_target_rpm(int rpm)
{
fan_rpm = rpm;
}
void chipset_force_shutdown(void)
{
cpu_down = 1;
}
void chipset_throttle_cpu(int throttled)
{
cpu_throttled = throttled;
}
/*****************************************************************************/
/* Test utilities */
/* Test shorthands */
#define T_CPU TEMP_SENSOR_CPU
#define T_BOARD TEMP_SENSOR_BOARD
#define T_CASE TEMP_SENSOR_CASE
#define THRESHOLD(x, y) (thermal_config[x].thresholds[y])
#define FAN_THRESHOLD(x, y) THRESHOLD(x, THRESHOLD_COUNT + (y))
static void reset_mock_temp(void)
{
int i;
enum temp_sensor_type type;
for (i = 0; i < TEMP_SENSOR_COUNT; ++i) {
type = temp_sensors[i].type;
mock_temp[i] = FAN_THRESHOLD(type, 0) - 1;
}
}
static int wait_fan_rpm(int rpm, int timeout_secs)
{
do {
if (fan_rpm == rpm)
return 1;
usleep(SECOND);
} while (timeout_secs--);
return 0;
}
static int wait_value(int *v, int target, int timeout_secs)
{
do {
if (*v == target)
return 1;
usleep(SECOND);
} while (timeout_secs--);
return 0;
}
static int wait_set(int *v, int timeout_secs)
{
return wait_value(v, 1, timeout_secs);
}
static int wait_clear(int *v, int timeout_secs)
{
return wait_value(v, 0, timeout_secs);
}
/*****************************************************************************/
/* Tests */
static int test_init_val(void)
{
/* Initial mock temperature values are all zero. */
TEST_ASSERT(cpu_throttled == 0);
TEST_ASSERT(cpu_down == 0);
TEST_ASSERT(!(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_OVERLOAD)));
TEST_ASSERT(!(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_SHUTDOWN)));
return EC_SUCCESS;
}
static int test_cpu_fan(void)
{
reset_mock_temp();
/*
* Increase CPU temperature to first fan step and check if
* the fan comes up.
*/
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 0);
TEST_ASSERT(wait_fan_rpm(fan_speed[1], 11));
/* Increase CPU temperature to second fan step */
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 1);
TEST_ASSERT(wait_fan_rpm(fan_speed[2], 11));
/* Test threshold hysteresis */
mock_temp[T_CPU]--;
usleep(15 * SECOND);
TEST_ASSERT(fan_rpm == fan_speed[2]);
/* Test action delay */
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 4);
usleep((temp_sensors[T_CPU].action_delay_sec - 1) * SECOND);
TEST_ASSERT(fan_rpm == fan_speed[2]);
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 0);
return EC_SUCCESS;
}
static int test_safety(void)
{
reset_mock_temp();
/* Trigger CPU throttling */
mock_temp[T_CPU] = THRESHOLD(T_CPU, THRESHOLD_WARNING);
TEST_ASSERT(wait_set(&cpu_throttled, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_OVERLOAD));
/* Lower temperature. CPU not throttled anymore. */
mock_temp[T_CPU] = THRESHOLD(T_CPU, THRESHOLD_WARNING) - 5;
TEST_ASSERT(wait_clear(&cpu_throttled, 2));
/* Thermal shutdown */
mock_temp[T_CPU] = THRESHOLD(T_CPU, THRESHOLD_CPU_DOWN);
TEST_ASSERT(wait_set(&cpu_down, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_SHUTDOWN));
mock_temp[T_CPU] = 0;
usleep(SECOND);
cpu_down = 0;
mock_temp[T_CPU] = THRESHOLD(T_CPU, THRESHOLD_POWER_DOWN);
TEST_ASSERT(wait_set(&cpu_down, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_SHUTDOWN));
mock_temp[T_CPU] = 0;
cpu_down = 0;
return EC_SUCCESS;
}
static int test_sensor_failure(void)
{
reset_mock_temp();
/* Failure due to sensor not powered should be ignored */
mock_temp[T_CPU] = -EC_ERROR_NOT_POWERED;
usleep(5 * SECOND);
TEST_ASSERT(!(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL)));
/* Other failure should be pumped up to host */
mock_temp[T_CPU] = -EC_ERROR_UNKNOWN;
usleep(5 * SECOND);
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL));
return EC_SUCCESS;
}
static int test_sensor_info(void)
{
struct ec_params_temp_sensor_get_info params;
struct ec_response_temp_sensor_get_info resp;
int i;
for (i = 0; i < TEMP_SENSOR_COUNT; ++i) {
params.id = i;
TEST_ASSERT(test_send_host_command(
EC_CMD_TEMP_SENSOR_GET_INFO,
0, &params, sizeof(params),
&resp, sizeof(resp)) == EC_RES_SUCCESS);
TEST_ASSERT_ARRAY_EQ(resp.sensor_name,
temp_sensors[i].name,
strlen(resp.sensor_name));
TEST_ASSERT(resp.sensor_type == temp_sensors[i].type);
}
params.id = TEMP_SENSOR_COUNT;
TEST_ASSERT(test_send_host_command(
EC_CMD_TEMP_SENSOR_GET_INFO,
0, &params, sizeof(params),
&resp, sizeof(resp)) != EC_RES_SUCCESS);
return EC_SUCCESS;
}
static int set_threshold(int type, int threshold_id, int val)
{
struct ec_params_thermal_set_threshold params;
params.sensor_type = type;
params.threshold_id = threshold_id;
params.value = val;
return test_send_host_command(EC_CMD_THERMAL_SET_THRESHOLD, 0, &params,
sizeof(params), NULL, 0);
}
static int get_threshold(int type, int threshold_id, int *val)
{
struct ec_params_thermal_get_threshold params;
struct ec_response_thermal_get_threshold resp;
int rv;
params.sensor_type = type;
params.threshold_id = threshold_id;
rv = test_send_host_command(EC_CMD_THERMAL_GET_THRESHOLD, 0, &params,
sizeof(params), &resp, sizeof(resp));
if (rv != EC_RES_SUCCESS)
return rv;
*val = resp.value;
return EC_RES_SUCCESS;
}
static int verify_threshold(int type, int threshold_id, int val)
{
int actual_val;
if (get_threshold(type, threshold_id, &actual_val) != EC_RES_SUCCESS)
return 0;
return val == actual_val;
}
static int test_threshold_hostcmd(void)
{
reset_mock_temp();
/* Verify thresholds */
TEST_ASSERT(verify_threshold(T_CPU, THRESHOLD_WARNING,
THRESHOLD(T_CPU, THRESHOLD_WARNING)));
TEST_ASSERT(verify_threshold(T_BOARD, THRESHOLD_WARNING,
THRESHOLD(T_BOARD, THRESHOLD_WARNING)));
TEST_ASSERT(verify_threshold(T_CPU, THRESHOLD_CPU_DOWN,
THRESHOLD(T_CPU, THRESHOLD_CPU_DOWN)));
/* Lower CPU throttling threshold and trigger */
TEST_ASSERT(set_threshold(T_CPU, THRESHOLD_WARNING, 350) ==
EC_RES_SUCCESS);
mock_temp[T_CPU] = 355;
TEST_ASSERT(wait_set(&cpu_throttled, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_OVERLOAD));
/* Lower thermal shutdown threshold */
TEST_ASSERT(set_threshold(T_CPU, THRESHOLD_CPU_DOWN, 353) ==
EC_RES_SUCCESS);
TEST_ASSERT(wait_set(&cpu_down, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_SHUTDOWN));
/* Clear */
mock_temp[T_CPU] = 0;
TEST_ASSERT(wait_clear(&cpu_throttled, 2));
cpu_down = 0;
return EC_SUCCESS;
}
static int test_threshold_console_cmd(void)
{
char buf[100];
reset_mock_temp();
/* Lower CPU threshold and trigger */
snprintf(buf, 100, "thermalconf %d %d 330\n", T_CPU, THRESHOLD_WARNING);
UART_INJECT(buf);
msleep(100);
mock_temp[T_CPU] = 335;
TEST_ASSERT(wait_set(&cpu_throttled, 11));
TEST_ASSERT(host_get_events() &
EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_OVERLOAD));
/* Set first fan step to 280 K */
snprintf(buf, 100, "thermalfan %d 0 280\n", T_CPU);
UART_INJECT(buf);
msleep(100);
mock_temp[T_CPU] = 280;
TEST_ASSERT(wait_fan_rpm(fan_speed[1], 11));
return EC_SUCCESS;
}
static int test_invalid_hostcmd(void)
{
int dummy;
TEST_ASSERT(set_threshold(TEMP_SENSOR_TYPE_COUNT, THRESHOLD_WARNING,
100) != EC_RES_SUCCESS);
TEST_ASSERT(set_threshold(T_CPU, THRESHOLD_COUNT + THERMAL_FAN_STEPS,
100) != EC_RES_SUCCESS);
TEST_ASSERT(get_threshold(TEMP_SENSOR_TYPE_COUNT, THRESHOLD_WARNING,
&dummy) != EC_RES_SUCCESS);
TEST_ASSERT(get_threshold(T_CPU, THRESHOLD_COUNT + THERMAL_FAN_STEPS,
&dummy) != EC_RES_SUCCESS);
return EC_SUCCESS;
}
static int test_auto_fan_ctrl(void)
{
reset_mock_temp();
/* Disable fan control */
pwm_set_fan_rpm_mode(0);
thermal_control_fan(0);
/*
* Increase CPU temperature to first fan step and check the fan
* doesn't come up.
*/
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 0);
TEST_ASSERT(!wait_fan_rpm(fan_speed[1], 11));
/* Enable fan control */
TEST_ASSERT(test_send_host_command(EC_CMD_THERMAL_AUTO_FAN_CTRL, 0,
NULL, 0, NULL, 0) == EC_RES_SUCCESS);
TEST_ASSERT(fan_rpm_mode == 1);
TEST_ASSERT(wait_fan_rpm(fan_speed[1], 11));
/* Disable fan control */
pwm_set_fan_rpm_mode(0);
thermal_control_fan(0);
/* Increase CPU temperature to second fan step */
mock_temp[T_CPU] = FAN_THRESHOLD(T_CPU, 1);
TEST_ASSERT(!wait_fan_rpm(fan_speed[2], 11));
/* Enable fan control by console command */
UART_INJECT("autofan\n");
msleep(100);
TEST_ASSERT(fan_rpm_mode == 1);
TEST_ASSERT(wait_fan_rpm(fan_speed[2], 11));
return EC_SUCCESS;
}
static int check_assumption(void)
{
TEST_ASSERT((int)TEMP_SENSOR_CPU == (int)TEMP_SENSOR_TYPE_CPU);
TEST_ASSERT((int)TEMP_SENSOR_BOARD == (int)TEMP_SENSOR_TYPE_BOARD);
TEST_ASSERT((int)TEMP_SENSOR_CASE == (int)TEMP_SENSOR_TYPE_CASE);
TEST_ASSERT(temp_sensors[T_CPU].action_delay_sec != 0);
TEST_ASSERT(thermal_config[T_CPU].config_flags &
THERMAL_CONFIG_WARNING_ON_FAIL);
return EC_SUCCESS;
}
void run_test(void)
{
test_reset();
/* Test assumptions */
RUN_TEST(check_assumption);
RUN_TEST(test_init_val);
RUN_TEST(test_cpu_fan);
/* No tests for board and case temp sensors as they are ignored. */
RUN_TEST(test_safety);
RUN_TEST(test_sensor_failure);
RUN_TEST(test_auto_fan_ctrl);
RUN_TEST(test_sensor_info);
RUN_TEST(test_threshold_hostcmd);
RUN_TEST(test_invalid_hostcmd);
RUN_TEST(test_threshold_console_cmd);
test_print_result();
}
Reference in New Issue View Git Blame Copy Permalink