hwmon: (peci) Rely on subsystem locking

Attribute access is now serialized in the hardware monitoring core,
so locking in the driver code is no longer necessary. Drop it.

Signed-off-by: Guenter Roeck <linux@roeck-us.net>

diff --git a/drivers/hwmon/peci/common.h b/drivers/hwmon/peci/common.h
index 734506b0eca26749ae85bec031447c7edf966d17..92a7ee1925bcf8e4c25f60051a3219707db65cad 100644 (file)
--- a/drivers/hwmon/peci/common.h
+++ b/drivers/hwmon/peci/common.h
@@ -1,7 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /* Copyright (c) 2021 Intel Corporation */
 
-#include <linux/mutex.h>
 #include <linux/types.h>
 
 #ifndef __PECI_HWMON_COMMON_H
@@ -13,12 +12,10 @@
  * struct peci_sensor_state - PECI state information
  * @valid: flag to indicate the sensor value is valid
  * @last_updated: time of the last update in jiffies
- * @lock: mutex to protect sensor access
  */
 struct peci_sensor_state {
        bool valid;
        unsigned long last_updated;
-       struct mutex lock; /* protect sensor access */
 };
 
 /**

diff --git a/drivers/hwmon/peci/cputemp.c b/drivers/hwmon/peci/cputemp.c
index b350c9a7689410b9cf6cfbcc9c4990a71c94df07..b2fc936851e14562cd4d99a70d236e62064d6dcf 100644 (file)
--- a/drivers/hwmon/peci/cputemp.c
+++ b/drivers/hwmon/peci/cputemp.c
@@ -116,11 +116,9 @@ static int get_temp_target(struct peci_cputemp *priv, enum peci_temp_target_type
 {
        int ret;
 
-       mutex_lock(&priv->temp.target.state.lock);
-
        ret = update_temp_target(priv);
        if (ret)
-               goto unlock;
+               return ret;
 
        switch (type) {
        case tcontrol_type:
@@ -139,9 +137,6 @@ static int get_temp_target(struct peci_cputemp *priv, enum peci_temp_target_type
                ret = -EOPNOTSUPP;
                break;
        }
-unlock:
-       mutex_unlock(&priv->temp.target.state.lock);
-
        return ret;
 }
 
@@ -177,26 +172,23 @@ static s32 dts_eight_dot_eight_to_millidegree(u16 val)
 
 static int get_die_temp(struct peci_cputemp *priv, long *val)
 {
-       int ret = 0;
        long tjmax;
        u16 temp;
+       int ret;
 
-       mutex_lock(&priv->temp.die.state.lock);
        if (!peci_sensor_need_update(&priv->temp.die.state))
                goto skip_update;
 
        ret = peci_temp_read(priv->peci_dev, &temp);
        if (ret)
-               goto err_unlock;
+               return ret;
 
-       if (!dts_valid(temp)) {
-               ret = -EIO;
-               goto err_unlock;
-       }
+       if (!dts_valid(temp))
+               return -EIO;
 
        ret = get_temp_target(priv, tjmax_type, &tjmax);
        if (ret)
-               goto err_unlock;
+               return ret;
 
        priv->temp.die.value = (s32)tjmax + dts_ten_dot_six_to_millidegree(temp);
 
@@ -204,35 +196,30 @@ static int get_die_temp(struct peci_cputemp *priv, long *val)
 
 skip_update:
        *val = priv->temp.die.value;
-err_unlock:
-       mutex_unlock(&priv->temp.die.state.lock);
-       return ret;
+       return 0;
 }
 
 static int get_dts(struct peci_cputemp *priv, long *val)
 {
-       int ret = 0;
        u16 thermal_margin;
        long tcontrol;
        u32 pcs;
+       int ret;
 
-       mutex_lock(&priv->temp.dts.state.lock);
        if (!peci_sensor_need_update(&priv->temp.dts.state))
                goto skip_update;
 
        ret = peci_pcs_read(priv->peci_dev, PECI_PCS_THERMAL_MARGIN, 0, &pcs);
        if (ret)
-               goto err_unlock;
+               return ret;
 
        thermal_margin = FIELD_GET(DTS_MARGIN_MASK, pcs);
-       if (!dts_valid(thermal_margin)) {
-               ret = -EIO;
-               goto err_unlock;
-       }
+       if (!dts_valid(thermal_margin))
+               return -EIO;
 
        ret = get_temp_target(priv, tcontrol_type, &tcontrol);
        if (ret)
-               goto err_unlock;
+               return ret;
 
        /* Note that the tcontrol should be available before calling it */
        priv->temp.dts.value =
@@ -242,35 +229,30 @@ static int get_dts(struct peci_cputemp *priv, long *val)
 
 skip_update:
        *val = priv->temp.dts.value;
-err_unlock:
-       mutex_unlock(&priv->temp.dts.state.lock);
-       return ret;
+       return 0;
 }
 
 static int get_core_temp(struct peci_cputemp *priv, int core_index, long *val)
 {
-       int ret = 0;
        u16 core_dts_margin;
        long tjmax;
        u32 pcs;
+       int ret;
 
-       mutex_lock(&priv->temp.core[core_index].state.lock);
        if (!peci_sensor_need_update(&priv->temp.core[core_index].state))
                goto skip_update;
 
        ret = peci_pcs_read(priv->peci_dev, PECI_PCS_MODULE_TEMP, core_index, &pcs);
        if (ret)
-               goto err_unlock;
+               return ret;
 
        core_dts_margin = FIELD_GET(PCS_MODULE_TEMP_MASK, pcs);
-       if (!dts_valid(core_dts_margin)) {
-               ret = -EIO;
-               goto err_unlock;
-       }
+       if (!dts_valid(core_dts_margin))
+               return -EIO;
 
        ret = get_temp_target(priv, tjmax_type, &tjmax);
        if (ret)
-               goto err_unlock;
+               return ret;
 
        /* Note that the tjmax should be available before calling it */
        priv->temp.core[core_index].value =
@@ -280,9 +262,7 @@ static int get_core_temp(struct peci_cputemp *priv, int core_index, long *val)
 
 skip_update:
        *val = priv->temp.core[core_index].value;
-err_unlock:
-       mutex_unlock(&priv->temp.core[core_index].state.lock);
-       return ret;
+       return 0;
 }
 
 static int cputemp_read_string(struct device *dev, enum hwmon_sensor_types type,
@@ -431,18 +411,6 @@ static void check_resolved_cores(struct peci_cputemp *priv)
                bitmap_zero(priv->core_mask, CORE_NUMS_MAX);
 }
 
-static void sensor_init(struct peci_cputemp *priv)
-{
-       int i;
-
-       mutex_init(&priv->temp.target.state.lock);
-       mutex_init(&priv->temp.die.state.lock);
-       mutex_init(&priv->temp.dts.state.lock);
-
-       for_each_set_bit(i, priv->core_mask, CORE_NUMS_MAX)
-               mutex_init(&priv->temp.core[i].state.lock);
-}
-
 static const struct hwmon_ops peci_cputemp_ops = {
        .is_visible = cputemp_is_visible,
        .read_string = cputemp_read_string,
@@ -507,8 +475,6 @@ static int peci_cputemp_probe(struct auxiliary_device *adev,
 
        check_resolved_cores(priv);
 
-       sensor_init(priv);
-
        hwmon_dev = devm_hwmon_device_register_with_info(priv->dev, priv->name,
                                                         priv, &peci_cputemp_chip_info, NULL);
 

diff --git a/drivers/hwmon/peci/dimmtemp.c b/drivers/hwmon/peci/dimmtemp.c
index a281476c7a31f211b1838f2a92dd6bd660f7f337..bd3e8715dfece0ecd12b66f95e4f9f4f12e83e10 100644 (file)
--- a/drivers/hwmon/peci/dimmtemp.c
+++ b/drivers/hwmon/peci/dimmtemp.c
@@ -96,16 +96,15 @@ static int get_dimm_temp(struct peci_dimmtemp *priv, int dimm_no, long *val)
 {
        int dimm_order = dimm_no % priv->gen_info->dimm_idx_max;
        int chan_rank = dimm_no / priv->gen_info->dimm_idx_max;
-       int ret = 0;
        u32 data;
+       int ret;
 
-       mutex_lock(&priv->dimm[dimm_no].temp.state.lock);
        if (!peci_sensor_need_update(&priv->dimm[dimm_no].temp.state))
                goto skip_update;
 
        ret = peci_pcs_read(priv->peci_dev, PECI_PCS_DDR_DIMM_TEMP, chan_rank, &data);
        if (ret)
-               goto unlock;
+               return ret;
 
        priv->dimm[dimm_no].temp.value = __dimm_temp(data, dimm_order) * MILLIDEGREE_PER_DEGREE;
 
@@ -113,9 +112,7 @@ static int get_dimm_temp(struct peci_dimmtemp *priv, int dimm_no, long *val)
 
 skip_update:
        *val = priv->dimm[dimm_no].temp.value;
-unlock:
-       mutex_unlock(&priv->dimm[dimm_no].temp.state.lock);
-       return ret;
+       return 0;
 }
 
 static int update_thresholds(struct peci_dimmtemp *priv, int dimm_no)
@@ -145,10 +142,9 @@ static int get_dimm_thresholds(struct peci_dimmtemp *priv, enum peci_dimm_thresh
 {
        int ret;
 
-       mutex_lock(&priv->dimm[dimm_no].thresholds.state.lock);
        ret = update_thresholds(priv, dimm_no);
        if (ret)
-               goto unlock;
+               return ret;
 
        switch (type) {
        case temp_max_type:
@@ -161,9 +157,6 @@ static int get_dimm_thresholds(struct peci_dimmtemp *priv, enum peci_dimm_thresh
                ret = -EOPNOTSUPP;
                break;
        }
-unlock:
-       mutex_unlock(&priv->dimm[dimm_no].thresholds.state.lock);
-
        return ret;
 }
 
@@ -349,8 +342,6 @@ static int create_dimm_temp_info(struct peci_dimmtemp *priv)
                ret = create_dimm_temp_label(priv, i);
                if (ret)
                        return ret;
-               mutex_init(&priv->dimm[i].thresholds.state.lock);
-               mutex_init(&priv->dimm[i].temp.state.lock);
        }
 
        dev = devm_hwmon_device_register_with_info(priv->dev, priv->name, priv,