fan_control.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-only */
 
#include <arch/io.h>
#include <console/console.h>
#include "../common/fan_control.h"
#include "f81803a_hwm.h"
 
static const char msg_err_invalid[] = "Error: invalid";
static const char msg_err_wrong_order[] = "Error: wrong order,";
static const char msg_err_fan[] = "fan";
static const char msg_err_temp_source[] = "temperature source";
static const char msg_err_type[] = "type";
static const char msg_err_mode[] = "mode";
static const char msg_err_rate[] = "change rate";
static const char msg_err_frequency[] = "frequency";
static const char msg_err_temp_sensor[] = "temperature sensor";
static const char msg_err_bondary[] = "boundary";
static const char msg_err_section[] = "section";
static const char no_msg[] = "";
 
struct cross_ref {
        int selection;
        const char *message;
};
static struct cross_ref msg_table[] = {
        {HWM_STATUS_INVALID_FAN,                msg_err_fan},
        {HWM_STATUS_INVALID_TEMP_SOURCE,        msg_err_temp_source},
        {HWM_STATUS_INVALID_TYPE,               msg_err_type},
        {HWM_STATUS_INVALID_MODE,               msg_err_mode},
        {HWM_STATUS_INVALID_RATE,               msg_err_rate},
        {HWM_STATUS_INVALID_FREQUENCY,          msg_err_frequency},
        {HWM_STATUS_INVALID_TEMP_SENSOR,        msg_err_temp_sensor},
        {0, NULL},
};
 
static const char *get_msg(int err)
{
        int i = 0;
        while (msg_table[i].selection) {
                if (msg_table[i].selection == err)
                        return msg_table[i].message;
                i++;
        }
        return no_msg;
}
 
static int message_invalid_1(int err, u8 fan)
{
        if (err == HWM_STATUS_INVALID_FAN)
                printk(BIOS_ERR, "%s %s %d!\n", msg_err_invalid, get_msg(err), fan);
        else
                printk(BIOS_ERR, "%s Fan %d %s!\n", msg_err_invalid, fan, get_msg(err));
        return err;
}
 
static int message_invalid_2(int err, u8 fan)
{
        switch (err) {
        case HWM_STATUS_INVALID_BOUNDARY_VALUE:
                printk(BIOS_ERR, "%s fan %d %s value!\n", msg_err_invalid, fan,
                                        msg_err_bondary);
                break;
        case HWM_STATUS_INVALID_SECTION_VALUE:
                printk(BIOS_ERR, "%s fan %d %s value!\n", msg_err_invalid, fan,
                                        msg_err_section);
                break;
        case HWM_STATUS_BOUNDARY_WRONG_ORDER:
                printk(BIOS_ERR, "%s fan %d %s!\n", msg_err_wrong_order, fan, msg_err_bondary);
                break;
        case HWM_STATUS_SECTIONS_WRONG_ORDER:
                printk(BIOS_ERR, "%s fan %d %s!\n", msg_err_wrong_order, fan, msg_err_section);
                break;
        default:
                break;
        }
        return err;
}
 
static void write_hwm_reg(u16 address, u8 index, u8 value)
{
        u16 index_add, data_add;
        index_add = address | 0x0001;   /* force odd address */
        data_add = index_add + 1;
        outb(index, index_add);
        outb(value, data_add);
}
 
static u8 read_hwm_reg(u16 address, u8 index)
{
        u16 index_add, data_add;
        index_add = address | 0x0001;   /* force odd address */
        data_add = index_add + 1;
        outb(index, index_add);
        return inb(data_add);
}
 
static void hwm_reg_modify(u16 address, u8 index, u8 shift, u8 mask,
                                                                u8 value)
{
        u8 use_mask = mask << shift;
        u8 use_value = (value & mask) << shift;
        u8 temp = read_hwm_reg(address, index);
 
        temp &= ~use_mask;
        temp |= use_value;
        write_hwm_reg(address, index, temp);
}
 
/*
 * Registers 0x94,0x95, 0x96 and 0x9b have 2 versions (banks) selected through
 * bit 7 of register 0x9f.
 */
static inline void select_hwm_bank(u16 address, u8 value)
{
        hwm_reg_modify(address, FAN_FAULT_TIME_REG, FAN_FUNC_PROG_SEL_SHIFT,
                                FAN_BIT_MASK, value);
}
 
/*
 * Boundaries and sections must be presented in the same order as in the HWM
 * registers, that is, from highest value to lowest. This procedure checks for
 * the correct order.
 */
static int check_value_seq(u8 *values, u8 count)
{
        u8 last_value = CPU_DAMAGE_TEMP;
        u8 current_value, i;
        for (i = 0; i < count; i++) {
                current_value = values[i];
                if (current_value > CPU_DAMAGE_TEMP)
                        return STATUS_INVALID_VALUE;
                if (current_value >= last_value)
                        return STATUS_INVALID_ORDER;
                last_value = current_value;
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_sensor_type(u16 base_address, external_sensor sensor,
                                                temp_sensor_type type)
{
        u8 sensor_status = read_hwm_reg(base_address, TP_DIODE_STATUS);
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        switch (sensor) {
        case EXTERNAL_SENSOR1:
                if (sensor_status & TP_EXTERNAL_SENSOR1_OPEN) {
                        printk(BIOS_WARNING, "Sensor 1 disconnected!\n");
                        return HWM_STATUS_WARNING_SENSOR_DISCONNECTED;
                }
                hwm_reg_modify(base_address, TP_SENSOR_TYPE,
                        TP_SENSOR1_TYPE_SHIFT, TP_SENSOR_TYPE_MASK, type);
                break;
        case EXTERNAL_SENSOR2:
                if (sensor_status & TP_EXTERNAL_SENSOR2_OPEN) {
                        printk(BIOS_WARNING, "Sensor 2 disconnected!\n");
                        return HWM_STATUS_WARNING_SENSOR_DISCONNECTED;
                }
                hwm_reg_modify(base_address, TP_SENSOR_TYPE,
                        TP_SENSOR2_TYPE_SHIFT, TP_SENSOR_TYPE_MASK, type);
                break;
        case IGNORE_SENSOR:
                break;
        default:
                return message_invalid_1(HWM_STATUS_INVALID_TEMP_SENSOR, 0);
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_fan_temperature_source(u16 base_address, u8 fan,
                                                fan_temp_source source)
{
        u8 index, high_value, low_value;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
        index = FAN_ADJUST(fan, FAN_TMP_MAPPING);
        high_value = (source >> 2) & FAN_BIT_MASK;
        low_value = source & FAN_TEMP_SEL_LOW_MASK;
        hwm_reg_modify(base_address, index, FAN_TEMP_SEL_HIGH_SHIFT,
                                FAN_BIT_MASK, high_value);
        hwm_reg_modify(base_address, index, FAN_TEMP_SEL_LOW_SHIFT,
                                FAN_TEMP_SEL_LOW_MASK, low_value);
        /*
         * Fan 1 has a weight mechanism for adjusting for next fan speed. Basically the idea is
         * to react more aggressively (normally CPU fan) based on how high another temperature
         * (system, thermistor near the CPU, anything) is. This would be highly platform
         * dependent, and by setting the weight temperature same as the control temperature.
         * This code cancels the weight mechanism and make it work with any board. If a board
         * wants to use the weight mechanism, OEM should implement it after calling the main
         * HWM programming.
         */
        if (fan == FIRST_FAN) {
                select_hwm_bank(base_address, 1);
                hwm_reg_modify(base_address, FAN_MODE_REG,
                                FAN1_ADJ_SEL_SHIFT, FAN1_ADJ_SEL_MASK, source);
                select_hwm_bank(base_address, 0);
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_fan_type_mode(u16 base_address, u8 fan, fan_type type, fan_mode mode)
{
        u8 shift;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
        select_hwm_bank(base_address, 0);
        if (type < FAN_TYPE_RESERVED) {
                shift = FAN_TYPE_SHIFT(fan);
                hwm_reg_modify(base_address, FAN_TYPE_REG, shift,
                                                FAN_TYPE_MASK, type);
        }
        if (mode < FAN_MODE_DEFAULT) {
                shift = FAN_MODE_SHIFT(fan);
                hwm_reg_modify(base_address, FAN_MODE_REG, shift,
                                                FAN_MODE_MASK, mode);
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_pwm_frequency(u16 base_address, u8 fan, fan_pwm_freq frequency)
{
        u8 shift, index, byte;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
        byte = read_hwm_reg(base_address, FAN_TYPE_REG);
        shift = FAN_TYPE_SHIFT(fan);
        if (((byte >> shift) & FAN_TYPE_PWM_CHECK) == FAN_TYPE_PWM_CHECK) {
                printk(BIOS_WARNING, "Fan %d not programmed as PWM!\n", fan);
                return HWM_STATUS_WARNING_FAN_NOT_PWM;
        }
        select_hwm_bank(base_address, 1);
        shift = FAN_FREQ_SEL_ADD_SHIFT(fan);
        byte = (frequency >> 1) & FAN_BIT_MASK;
        hwm_reg_modify(base_address, FAN_MODE_REG, shift, FAN_BIT_MASK,
                                                                        byte);
        select_hwm_bank(base_address, 0);
        index = FAN_ADJUST(fan, FAN_TMP_MAPPING);
        byte = frequency & FAN_BIT_MASK;
        hwm_reg_modify(base_address, index, FAN_PWM_FREQ_SEL_SHIFT,
                                                        FAN_BIT_MASK, byte);
        return HWM_STATUS_SUCCESS;
}
 
int set_sections(u16 base_address, u8 fan, u8 *boundaries, u8 *sections)
{
        int status, temp;
        u8 i, index, value;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
        status = check_value_seq(boundaries,
                                FINTEK_BOUNDARIES_SIZE);
        if (status != HWM_STATUS_SUCCESS) {
                if (status == STATUS_INVALID_VALUE)
                        return message_invalid_2(HWM_STATUS_INVALID_BOUNDARY_VALUE, fan);
                return message_invalid_2(HWM_STATUS_BOUNDARY_WRONG_ORDER, fan);
        }
        status = check_value_seq(sections,
                                FINTEK_SECTIONS_SIZE);
        if (status != HWM_STATUS_SUCCESS) {
                if (status == STATUS_INVALID_VALUE)
                        return message_invalid_2(HWM_STATUS_INVALID_SECTION_VALUE, fan);
                return message_invalid_2(HWM_STATUS_SECTIONS_WRONG_ORDER, fan);
        }
        index = FAN_ADJUST(fan, FAN_BOUND_TEMP);
        for (i = 0; i < FINTEK_BOUNDARIES_SIZE; i++) {
                value = boundaries[i];
                write_hwm_reg(base_address, index, value);
                index++;
        }
        index = FAN_ADJUST(fan, FAN_SECTION_SPEED);
        for (i = 0; i < FINTEK_SECTIONS_SIZE; i++) {
                value = sections[i];
                if (value > 100)
                        return message_invalid_2(HWM_STATUS_INVALID_SECTION_VALUE, fan);
                temp = (255 * value) / 100;
                value = (u8) (temp & 0x00ff);
                write_hwm_reg(base_address, index, value);
                index++;
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_fan_speed_change_rate(u16 base_address, u8 fan, fan_rate_up rate_up,
                                                fan_rate_down rate_down)
{
        u8 shift, index;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
 
        index = FAN_ADJUST(fan, FAN_TMP_MAPPING);
        shift = FAN_RATE_SHIFT(fan);
 
        if (rate_up == FAN_UP_RATE_JUMP) {
                hwm_reg_modify(base_address, index, FAN_JUMP_UP_SHIFT,
                                                        FAN_BIT_MASK, 1);
        } else {
                hwm_reg_modify(base_address, index, FAN_JUMP_UP_SHIFT,
                                                        FAN_BIT_MASK, 0);
                if (rate_up < FAN_UP_RATE_DEFAULT) {
                        hwm_reg_modify(base_address,    FAN_UP_RATE_REG,
                                        shift, FAN_RATE_MASK, rate_up);
                }
        }
 
        if (rate_down == FAN_DOWN_RATE_JUMP) {
                hwm_reg_modify(base_address, index, FAN_JUMP_DOWN_SHIFT,
                                                        FAN_BIT_MASK, 1);
        } else {
                hwm_reg_modify(base_address, index, FAN_JUMP_UP_SHIFT,
                                                        FAN_BIT_MASK, 0);
                select_hwm_bank(base_address, 0);
                if (rate_down < FAN_DOWN_RATE_DEFAULT) {
                        hwm_reg_modify(base_address,    FAN_DOWN_RATE_REG,
                                        shift, FAN_RATE_MASK, rate_down);
                        hwm_reg_modify(base_address, FAN_DOWN_RATE_REG,
                                        FAN_DOWN_RATE_DIFF_FROM_UP_SHIFT,
                                        FAN_BIT_MASK, 0);
                }
                if (rate_down == FAN_DOWN_RATE_SAME_AS_UP) {
                        hwm_reg_modify(base_address, FAN_DOWN_RATE_REG,
                                        FAN_DOWN_RATE_DIFF_FROM_UP_SHIFT,
                                        FAN_BIT_MASK, 1);
                }
        }
        return HWM_STATUS_SUCCESS;
}
 
int set_fan_follow(u16 base_address, u8 fan, fan_follow follow)
{
        u8 index;
 
        printk(BIOS_DEBUG, "%s\n", __func__);
        if ((fan < FIRST_FAN) || (fan > LAST_FAN))
                return message_invalid_1(HWM_STATUS_INVALID_FAN, fan);
        index = FAN_ADJUST(fan, FAN_TMP_MAPPING);
        hwm_reg_modify(base_address, index, FAN_INTERPOLATION_SHIFT,
                                FAN_BIT_MASK, follow);
        return HWM_STATUS_SUCCESS;
}