mlxsw: core: Implement fan control using hwmon

ASIC provides access to fans. Implement their exposure to userspace
using hwmon.

Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c b/drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c
index ec48c28ce0ca05c17e1262411c776f05e8e03136..ad8b27418a7f33f0aa9663c0c636ebb876714432 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c
@@ -42,7 +42,8 @@
 #include "core.h"
 
 #define MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT 127
-#define MLXSW_HWMON_ATTR_COUNT (MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT * 4)
+#define MLXSW_HWMON_ATTR_COUNT (MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT * 4 + \
+                               MLXSW_MFCR_TACHOS_MAX + MLXSW_MFCR_PWMS_MAX)
 
 struct mlxsw_hwmon_attr {
        struct device_attribute dev_attr;
@@ -106,9 +107,76 @@ static ssize_t mlxsw_hwmon_temp_max_show(struct device *dev,
        return sprintf(buf, "%u\n", temp_max);
 }
 
+static ssize_t mlxsw_hwmon_fan_rpm_show(struct device *dev,
+                                       struct device_attribute *attr,
+                                       char *buf)
+{
+       struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =
+                       container_of(attr, struct mlxsw_hwmon_attr, dev_attr);
+       struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;
+       char mfsm_pl[MLXSW_REG_MFSM_LEN];
+       int err;
+
+       mlxsw_reg_mfsm_pack(mfsm_pl, mlwsw_hwmon_attr->type_index);
+       err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfsm), mfsm_pl);
+       if (err) {
+               dev_err(mlxsw_hwmon->bus_info->dev, "Failed to query fan\n");
+               return err;
+       }
+       return sprintf(buf, "%u\n", mlxsw_reg_mfsm_rpm_get(mfsm_pl));
+}
+
+static ssize_t mlxsw_hwmon_pwm_show(struct device *dev,
+                                   struct device_attribute *attr,
+                                   char *buf)
+{
+       struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =
+                       container_of(attr, struct mlxsw_hwmon_attr, dev_attr);
+       struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;
+       char mfsc_pl[MLXSW_REG_MFSC_LEN];
+       int err;
+
+       mlxsw_reg_mfsc_pack(mfsc_pl, mlwsw_hwmon_attr->type_index, 0);
+       err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfsc), mfsc_pl);
+       if (err) {
+               dev_err(mlxsw_hwmon->bus_info->dev, "Failed to query PWM\n");
+               return err;
+       }
+       return sprintf(buf, "%u\n",
+                      mlxsw_reg_mfsc_pwm_duty_cycle_get(mfsc_pl));
+}
+
+static ssize_t mlxsw_hwmon_pwm_store(struct device *dev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t len)
+{
+       struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =
+                       container_of(attr, struct mlxsw_hwmon_attr, dev_attr);
+       struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;
+       char mfsc_pl[MLXSW_REG_MFSC_LEN];
+       unsigned long val;
+       int err;
+
+       err = kstrtoul(buf, 10, &val);
+       if (err)
+               return err;
+       if (val > 255)
+               return -EINVAL;
+
+       mlxsw_reg_mfsc_pack(mfsc_pl, mlwsw_hwmon_attr->type_index, val);
+       err = mlxsw_reg_write(mlxsw_hwmon->core, MLXSW_REG(mfsc), mfsc_pl);
+       if (err) {
+               dev_err(mlxsw_hwmon->bus_info->dev, "Failed to write PWM\n");
+               return err;
+       }
+       return err ? err : len;
+}
+
 enum mlxsw_hwmon_attr_type {
        MLXSW_HWMON_ATTR_TYPE_TEMP,
        MLXSW_HWMON_ATTR_TYPE_TEMP_MAX,
+       MLXSW_HWMON_ATTR_TYPE_FAN_RPM,
+       MLXSW_HWMON_ATTR_TYPE_PWM,
 };
 
 static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon,
@@ -133,6 +201,19 @@ static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon,
                snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),
                         "temp%u_highest", num + 1);
                break;
+       case MLXSW_HWMON_ATTR_TYPE_FAN_RPM:
+               mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_fan_rpm_show;
+               mlxsw_hwmon_attr->dev_attr.attr.mode = S_IRUGO;
+               snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),
+                        "fan%u_input", num + 1);
+               break;
+       case MLXSW_HWMON_ATTR_TYPE_PWM:
+               mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_pwm_show;
+               mlxsw_hwmon_attr->dev_attr.store = mlxsw_hwmon_pwm_store;
+               mlxsw_hwmon_attr->dev_attr.attr.mode = S_IWUSR | S_IRUGO;
+               snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),
+                        "pwm%u", num + 1);
+               break;
        default:
                BUG();
        }
@@ -177,6 +258,39 @@ static int mlxsw_hwmon_temp_init(struct mlxsw_hwmon *mlxsw_hwmon)
        return 0;
 }
 
+static int mlxsw_hwmon_fans_init(struct mlxsw_hwmon *mlxsw_hwmon)
+{
+       char mfcr_pl[MLXSW_REG_MFCR_LEN];
+       enum mlxsw_reg_mfcr_pwm_frequency freq;
+       unsigned int type_index;
+       unsigned int num;
+       u16 tacho_active;
+       u8 pwm_active;
+       int err;
+
+       err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfcr), mfcr_pl);
+       if (err) {
+               dev_err(mlxsw_hwmon->bus_info->dev, "Failed to get to probe PWMs and Tachometers\n");
+               return err;
+       }
+       mlxsw_reg_mfcr_unpack(mfcr_pl, &freq, &tacho_active, &pwm_active);
+       num = 0;
+       for (type_index = 0; type_index < MLXSW_MFCR_TACHOS_MAX; type_index++) {
+               if (tacho_active & BIT(type_index))
+                       mlxsw_hwmon_attr_add(mlxsw_hwmon,
+                                            MLXSW_HWMON_ATTR_TYPE_FAN_RPM,
+                                            type_index, num++);
+       }
+       num = 0;
+       for (type_index = 0; type_index < MLXSW_MFCR_PWMS_MAX; type_index++) {
+               if (pwm_active & BIT(type_index))
+                       mlxsw_hwmon_attr_add(mlxsw_hwmon,
+                                            MLXSW_HWMON_ATTR_TYPE_PWM,
+                                            type_index, num++);
+       }
+       return 0;
+}
+
 int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,
                     const struct mlxsw_bus_info *mlxsw_bus_info,
                     struct mlxsw_hwmon **p_hwmon)
@@ -195,6 +309,10 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,
        if (err)
                goto err_temp_init;
 
+       err = mlxsw_hwmon_fans_init(mlxsw_hwmon);
+       if (err)
+               goto err_fans_init;
+
        mlxsw_hwmon->groups[0] = &mlxsw_hwmon->group;
        mlxsw_hwmon->group.attrs = mlxsw_hwmon->attrs;
 
@@ -212,6 +330,7 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,
        return 0;
 
 err_hwmon_register:
+err_fans_init:
 err_temp_init:
        kfree(mlxsw_hwmon);
        return err;