There are target systems where pwm controller is the lm63, but
temperature sensors aren't connected to the lm63 (sensors are
part of CPU and supported by own linux driver). Automatic fan
control by the lm63 chip doesn't work for that systems.
Thermal zone is much more convenient for embedded systems, than
fan-control, or any other userspace software, because It allow
to get smaller software footprint. Also with thermal zone we
can store all cooling settings in devicetree, which is easier
to maintain for embedded systems, than some userspace software.
Added support property "pwm-mode" (pwm-mode = "manual") for
devicetree to use a manual pwm mode in the lm63 driver.
Cc: Jean Delvare <jdelvare@xxxxxxxx>
Cc: Guenter Roeck <linux@xxxxxxxxxxxx>
Cc: Thierry Reding <thierry.reding@xxxxxxxxx>
Cc: Lee Jones <lee.jones@xxxxxxxxxx>
Cc: linux-hwmon@xxxxxxxxxxxxxxx
Signed-off-by: Azat Gismatov <gismatov.az@xxxxxxx>
---
drivers/hwmon/lm63.c | 133 ++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 132 insertions(+), 1 deletion(-)
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index 50f67265c71d..764bc528294f 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -34,7 +34,9 @@
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/of_device.h>
+#include <linux/pwm.h>
#include <linux/sysfs.h>
+#include <linux/thermal.h>
#include <linux/types.h>
/*
@@ -97,6 +99,8 @@ static const unsigned short normal_i2c[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END };
#define LM63_MAX_CONVRATE_HZ 32
#define LM96163_MAX_CONVRATE_HZ 26
+#define MAX_SENSORS 2
+
/*
* Conversions and various macros
* For tachometer counts, the LM63 uses 16-bit values.
@@ -173,8 +177,15 @@ struct lm63_data {
bool lut_temp_highres;
bool remote_unsigned; /* true if unsigned remote upper limits */
bool trutherm;
+ struct pwm_chip chip;
+ struct lm63_thermal_sensor thermal_sensor[MAX_SENSORS];
};
+static inline struct lm63_data *to_pwm(struct pwm_chip *chip)
+{
+ return container_of(chip, struct lm63_data, chip);
+}
+
static inline int temp8_from_reg(struct lm63_data *data, int nr)
{
if (data->remote_unsigned)
@@ -1015,9 +1026,15 @@ static void lm63_init_client(struct lm63_data *data)
{
struct i2c_client *client = data->client;
struct device *dev = &client->dev;
+ const char *pwm_mode;
u8 convrate;
data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
+ pwm_mode = of_get_property(dev->of_node, "pwm-mode", NULL);
+ if (pwm_mode) {
+ if (!strcmp(pwm_mode, "manual"))
+ i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN, 0x20);
+ }
data->config_fan = i2c_smbus_read_byte_data(client,
LM63_REG_CONFIG_FAN);
@@ -1087,6 +1104,108 @@ static void lm63_init_client(struct lm63_data *data)
(data->config_fan & 0x20) ? "manual" : "auto");
}
+static int lm63_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
+ const struct pwm_state *state)
+{
+ struct lm63_data *data = to_pwm(chip);
+ struct i2c_client *client = data->client;
+ int ret = -EINVAL;
+ u8 pwm_mode;
+ u8 val;
+
+ mutex_lock(&data->update_lock);
+ pwm_mode = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG_FAN);
+ if (!(pwm_mode >> 5)) {
+ mutex_unlock(&data->update_lock);
+ return -EPERM;
+ }
+
+ if (state->period > 1) {
+ val = state->duty_cycle * 255 / (state->period - 1);
+ val = clamp_val(val, 0, 255);
+ val = data->pwm_highres ? val :
+ (val * data->pwm1_freq * 2 + 127) / 255;
+ ret = i2c_smbus_write_byte_data(client, LM63_REG_PWM_VALUE, val);
+ }
+
+ mutex_unlock(&data->update_lock);
+ return ret;
+}
+
+static const struct pwm_ops lm63_pwm_ops = {
+ .apply = lm63_pwm_apply,
+ .owner = THIS_MODULE,
+};
+
+static void lm63_pwm_remove(void *arg)
+{
+ struct i2c_client *client = arg;
+ struct lm63_data *data = i2c_get_clientdata(client);
+
+ pwmchip_remove(&data->chip);
+}
+
+static int lm63_init_pwm(struct lm63_data *data)
+{
+ struct i2c_client *client = data->client;
+ int ret;
+
+ ret = devm_add_action(&client->dev, lm63_pwm_remove, client);
+ if (ret)
+ return ret;
+
+ /* Initialize chip */
+
+ data->chip.dev = &client->dev;
+ data->chip.ops = &lm63_pwm_ops;
+ data->chip.base = -1;
+ data->chip.npwm = 1;
+
+ ret = pwmchip_add(&data->chip);
+ if (ret < 0) {
+ dev_warn(&client->dev, "pwmchip_add() failed: %d\n", ret);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int lm63_get_temp(void *data, int *temp)
+{
+ struct lm63_thermal_sensor *thermal_sensor = data;
+
+ mutex_lock(&thermal_sensor->data->update_lock);
+ *temp = i2c_smbus_read_byte_data(thermal_sensor->data->client,
+ LM63_REG_LOCAL_TEMP + thermal_sensor->sensor_id) * 1000;
+ mutex_unlock(&thermal_sensor->data->update_lock);
+
+ return 0;
+}
+
+static const struct thermal_zone_of_device_ops lm63_tz_ops = {
+ .get_temp = lm63_get_temp,
+};
+
+static void lm63_init_thermal(struct lm63_data *data)
+{
+ struct i2c_client *client = data->client;
+ struct lm63_thermal_sensor *thermal_sensor;
+ unsigned int i;
+
+ thermal_sensor = data->thermal_sensor;
+ for (i = 0; i < MAX_SENSORS; i++, thermal_sensor++) {
+ thermal_sensor->data = data;
+ thermal_sensor->sensor_id = i;
+ thermal_sensor->tz = devm_thermal_zone_of_sensor_register(&client->dev,
+ i, thermal_sensor, &lm63_tz_ops);
+
+ if (IS_ERR(thermal_sensor->tz)) {
+ dev_warn(&client->dev, "unable to register thermal sensor %ld\n",
+ PTR_ERR(thermal_sensor->tz));
+ }
+ }
+}
+
static const struct i2c_device_id lm63_id[];
static int lm63_probe(struct i2c_client *client)
@@ -1095,6 +1214,7 @@ static int lm63_probe(struct i2c_client *client)
struct device *hwmon_dev;
struct lm63_data *data;
int groups = 0;
+ int ret;
data = devm_kzalloc(dev, sizeof(struct lm63_data), GFP_KERNEL);
if (!data)
@@ -1126,7 +1246,18 @@ static int lm63_probe(struct i2c_client *client)
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
data, data->groups);
- return PTR_ERR_OR_ZERO(hwmon_dev);
+ if (IS_ERR(hwmon_dev))
+ return PTR_ERR(hwmon_dev);
+
+ i2c_set_clientdata(client, data);
+ lm63_init_thermal(data);
+ if (IS_ENABLED(CONFIG_PWM)) {
+ ret = lm63_init_pwm(data);
+ if (ret)
+ lm63_pwm_remove(data);
+ }
+
+ return 0;
}
/*
--
2.20.1
