2019-05-27 14:55:06 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2014-07-16 23:46:42 +08:00
|
|
|
/*
|
|
|
|
* pwm-fan.c - Hwmon driver for fans connected to PWM lines.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
|
|
|
|
*
|
|
|
|
* Author: Kamil Debski <k.debski@samsung.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/hwmon.h>
|
|
|
|
#include <linux/hwmon-sysfs.h>
|
2019-04-11 21:30:11 +08:00
|
|
|
#include <linux/interrupt.h>
|
2014-07-16 23:46:42 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/pwm.h>
|
2019-02-22 21:45:24 +08:00
|
|
|
#include <linux/regulator/consumer.h>
|
2014-07-16 23:46:42 +08:00
|
|
|
#include <linux/sysfs.h>
|
2015-02-26 21:59:37 +08:00
|
|
|
#include <linux/thermal.h>
|
2019-04-11 21:30:11 +08:00
|
|
|
#include <linux/timer.h>
|
2014-07-16 23:46:42 +08:00
|
|
|
|
|
|
|
#define MAX_PWM 255
|
|
|
|
|
|
|
|
struct pwm_fan_ctx {
|
|
|
|
struct mutex lock;
|
|
|
|
struct pwm_device *pwm;
|
2019-02-22 21:45:24 +08:00
|
|
|
struct regulator *reg_en;
|
2019-04-11 21:30:11 +08:00
|
|
|
|
|
|
|
int irq;
|
|
|
|
atomic_t pulses;
|
|
|
|
unsigned int rpm;
|
|
|
|
u8 pulses_per_revolution;
|
|
|
|
ktime_t sample_start;
|
|
|
|
struct timer_list rpm_timer;
|
|
|
|
|
2015-02-26 21:59:36 +08:00
|
|
|
unsigned int pwm_value;
|
|
|
|
unsigned int pwm_fan_state;
|
|
|
|
unsigned int pwm_fan_max_state;
|
|
|
|
unsigned int *pwm_fan_cooling_levels;
|
2015-02-26 21:59:37 +08:00
|
|
|
struct thermal_cooling_device *cdev;
|
2014-07-16 23:46:42 +08:00
|
|
|
};
|
|
|
|
|
2019-04-11 21:30:11 +08:00
|
|
|
/* This handler assumes self resetting edge triggered interrupt. */
|
|
|
|
static irqreturn_t pulse_handler(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_id;
|
|
|
|
|
|
|
|
atomic_inc(&ctx->pulses);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sample_timer(struct timer_list *t)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = from_timer(ctx, t, rpm_timer);
|
|
|
|
int pulses;
|
|
|
|
u64 tmp;
|
|
|
|
|
|
|
|
pulses = atomic_read(&ctx->pulses);
|
|
|
|
atomic_sub(pulses, &ctx->pulses);
|
|
|
|
tmp = (u64)pulses * ktime_ms_delta(ktime_get(), ctx->sample_start) * 60;
|
|
|
|
do_div(tmp, ctx->pulses_per_revolution * 1000);
|
|
|
|
ctx->rpm = tmp;
|
|
|
|
|
|
|
|
ctx->sample_start = ktime_get();
|
|
|
|
mod_timer(&ctx->rpm_timer, jiffies + HZ);
|
|
|
|
}
|
|
|
|
|
2015-02-26 21:59:35 +08:00
|
|
|
static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
|
2014-07-16 23:46:42 +08:00
|
|
|
{
|
2017-04-24 21:13:17 +08:00
|
|
|
unsigned long period;
|
2015-02-26 21:59:35 +08:00
|
|
|
int ret = 0;
|
2017-04-24 21:13:17 +08:00
|
|
|
struct pwm_state state = { };
|
2016-04-15 03:17:24 +08:00
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
mutex_lock(&ctx->lock);
|
|
|
|
if (ctx->pwm_value == pwm)
|
2015-02-26 21:59:35 +08:00
|
|
|
goto exit_set_pwm_err;
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2017-04-24 21:13:17 +08:00
|
|
|
pwm_init_state(ctx->pwm, &state);
|
|
|
|
period = ctx->pwm->args.period;
|
|
|
|
state.duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);
|
|
|
|
state.enabled = pwm ? true : false;
|
2015-04-13 02:44:11 +08:00
|
|
|
|
2017-04-24 21:13:17 +08:00
|
|
|
ret = pwm_apply_state(ctx->pwm, &state);
|
|
|
|
if (!ret)
|
|
|
|
ctx->pwm_value = pwm;
|
2014-07-16 23:46:42 +08:00
|
|
|
exit_set_pwm_err:
|
|
|
|
mutex_unlock(&ctx->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-02-26 21:59:37 +08:00
|
|
|
static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ctx->pwm_fan_max_state; ++i)
|
|
|
|
if (pwm < ctx->pwm_fan_cooling_levels[i + 1])
|
|
|
|
break;
|
|
|
|
|
|
|
|
ctx->pwm_fan_state = i;
|
|
|
|
}
|
|
|
|
|
2018-12-07 02:48:56 +08:00
|
|
|
static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2015-02-26 21:59:35 +08:00
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
|
|
|
unsigned long pwm;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = __set_pwm(ctx, pwm);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2015-02-26 21:59:37 +08:00
|
|
|
pwm_fan_update_state(ctx, pwm);
|
2015-02-26 21:59:35 +08:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2018-12-07 02:48:56 +08:00
|
|
|
static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2014-07-16 23:46:42 +08:00
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%u\n", ctx->pwm_value);
|
|
|
|
}
|
|
|
|
|
2019-04-11 21:30:11 +08:00
|
|
|
static ssize_t rpm_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%u\n", ctx->rpm);
|
|
|
|
}
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2018-12-07 02:48:56 +08:00
|
|
|
static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
|
2019-04-11 21:30:11 +08:00
|
|
|
static SENSOR_DEVICE_ATTR_RO(fan1_input, rpm, 0);
|
2014-07-16 23:46:42 +08:00
|
|
|
|
|
|
|
static struct attribute *pwm_fan_attrs[] = {
|
|
|
|
&sensor_dev_attr_pwm1.dev_attr.attr,
|
2019-04-11 21:30:11 +08:00
|
|
|
&sensor_dev_attr_fan1_input.dev_attr.attr,
|
2014-07-16 23:46:42 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2019-04-11 21:30:11 +08:00
|
|
|
static umode_t pwm_fan_attrs_visible(struct kobject *kobj, struct attribute *a,
|
|
|
|
int n)
|
|
|
|
{
|
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
/* Hide fan_input in case no interrupt is available */
|
|
|
|
if (n == 1 && ctx->irq <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return a->mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct attribute_group pwm_fan_group = {
|
|
|
|
.attrs = pwm_fan_attrs,
|
|
|
|
.is_visible = pwm_fan_attrs_visible,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *pwm_fan_groups[] = {
|
|
|
|
&pwm_fan_group,
|
|
|
|
NULL,
|
|
|
|
};
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2015-02-26 21:59:37 +08:00
|
|
|
/* thermal cooling device callbacks */
|
|
|
|
static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev,
|
|
|
|
unsigned long *state)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = cdev->devdata;
|
|
|
|
|
|
|
|
if (!ctx)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
*state = ctx->pwm_fan_max_state;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev,
|
|
|
|
unsigned long *state)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = cdev->devdata;
|
|
|
|
|
|
|
|
if (!ctx)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
*state = ctx->pwm_fan_state;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = cdev->devdata;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!ctx || (state > ctx->pwm_fan_max_state))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (state == ctx->pwm_fan_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&cdev->device, "Cannot set pwm!\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->pwm_fan_state = state;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = {
|
|
|
|
.get_max_state = pwm_fan_get_max_state,
|
|
|
|
.get_cur_state = pwm_fan_get_cur_state,
|
|
|
|
.set_cur_state = pwm_fan_set_cur_state,
|
|
|
|
};
|
|
|
|
|
2015-03-05 01:51:05 +08:00
|
|
|
static int pwm_fan_of_get_cooling_data(struct device *dev,
|
|
|
|
struct pwm_fan_ctx *ctx)
|
2015-02-26 21:59:36 +08:00
|
|
|
{
|
|
|
|
struct device_node *np = dev->of_node;
|
|
|
|
int num, i, ret;
|
|
|
|
|
|
|
|
if (!of_find_property(np, "cooling-levels", NULL))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = of_property_count_u32_elems(np, "cooling-levels");
|
|
|
|
if (ret <= 0) {
|
|
|
|
dev_err(dev, "Wrong data!\n");
|
|
|
|
return ret ? : -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
num = ret;
|
treewide: devm_kzalloc() -> devm_kcalloc()
The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
This patch replaces cases of:
devm_kzalloc(handle, a * b, gfp)
with:
devm_kcalloc(handle, a * b, gfp)
as well as handling cases of:
devm_kzalloc(handle, a * b * c, gfp)
with:
devm_kzalloc(handle, array3_size(a, b, c), gfp)
as it's slightly less ugly than:
devm_kcalloc(handle, array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
devm_kzalloc(handle, 4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
Some manual whitespace fixes were needed in this patch, as Coccinelle
really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
expression HANDLE;
type TYPE;
expression THING, E;
@@
(
devm_kzalloc(HANDLE,
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
devm_kzalloc(HANDLE,
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression HANDLE;
expression COUNT;
typedef u8;
typedef __u8;
@@
(
devm_kzalloc(HANDLE,
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
expression HANDLE;
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
expression HANDLE;
identifier SIZE, COUNT;
@@
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression HANDLE;
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression HANDLE;
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
expression HANDLE;
identifier STRIDE, SIZE, COUNT;
@@
(
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression HANDLE;
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE,
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression HANDLE;
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
|
devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
|
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE, C1 * C2, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * E2
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * (E2)
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 05:07:58 +08:00
|
|
|
ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32),
|
2015-02-26 21:59:36 +08:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!ctx->pwm_fan_cooling_levels)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = of_property_read_u32_array(np, "cooling-levels",
|
|
|
|
ctx->pwm_fan_cooling_levels, num);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "Property 'cooling-levels' cannot be read!\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) {
|
|
|
|
dev_err(dev, "PWM fan state[%d]:%d > %d\n", i,
|
|
|
|
ctx->pwm_fan_cooling_levels[i], MAX_PWM);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx->pwm_fan_max_state = num - 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
static void pwm_fan_regulator_disable(void *data)
|
|
|
|
{
|
|
|
|
regulator_disable(data);
|
|
|
|
}
|
|
|
|
|
2019-05-16 22:56:57 +08:00
|
|
|
static void pwm_fan_pwm_disable(void *__ctx)
|
2019-04-19 03:58:20 +08:00
|
|
|
{
|
2019-05-16 22:56:57 +08:00
|
|
|
struct pwm_fan_ctx *ctx = __ctx;
|
|
|
|
pwm_disable(ctx->pwm);
|
|
|
|
del_timer_sync(&ctx->rpm_timer);
|
2019-04-19 03:58:20 +08:00
|
|
|
}
|
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
static int pwm_fan_probe(struct platform_device *pdev)
|
|
|
|
{
|
2015-02-26 21:59:37 +08:00
|
|
|
struct thermal_cooling_device *cdev;
|
2019-04-19 03:58:20 +08:00
|
|
|
struct device *dev = &pdev->dev;
|
2014-07-16 23:46:42 +08:00
|
|
|
struct pwm_fan_ctx *ctx;
|
2015-02-26 21:59:37 +08:00
|
|
|
struct device *hwmon;
|
2014-07-16 23:46:42 +08:00
|
|
|
int ret;
|
2017-04-24 21:13:17 +08:00
|
|
|
struct pwm_state state = { };
|
2019-04-11 21:30:11 +08:00
|
|
|
u32 ppr = 2;
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
|
2014-07-16 23:46:42 +08:00
|
|
|
if (!ctx)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mutex_init(&ctx->lock);
|
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
ctx->pwm = devm_of_pwm_get(dev, dev->of_node, NULL);
|
2014-07-16 23:46:42 +08:00
|
|
|
if (IS_ERR(ctx->pwm)) {
|
2018-09-21 18:10:47 +08:00
|
|
|
ret = PTR_ERR(ctx->pwm);
|
|
|
|
|
|
|
|
if (ret != -EPROBE_DEFER)
|
2019-04-19 03:58:20 +08:00
|
|
|
dev_err(dev, "Could not get PWM: %d\n", ret);
|
2018-09-21 18:10:47 +08:00
|
|
|
|
|
|
|
return ret;
|
2014-07-16 23:46:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, ctx);
|
|
|
|
|
2019-08-28 16:34:11 +08:00
|
|
|
ctx->irq = platform_get_irq_optional(pdev, 0);
|
2019-04-11 21:30:11 +08:00
|
|
|
if (ctx->irq == -EPROBE_DEFER)
|
|
|
|
return ctx->irq;
|
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
ctx->reg_en = devm_regulator_get_optional(dev, "fan");
|
2019-02-22 21:45:24 +08:00
|
|
|
if (IS_ERR(ctx->reg_en)) {
|
|
|
|
if (PTR_ERR(ctx->reg_en) != -ENODEV)
|
|
|
|
return PTR_ERR(ctx->reg_en);
|
|
|
|
|
|
|
|
ctx->reg_en = NULL;
|
|
|
|
} else {
|
|
|
|
ret = regulator_enable(ctx->reg_en);
|
|
|
|
if (ret) {
|
2019-04-19 03:58:20 +08:00
|
|
|
dev_err(dev, "Failed to enable fan supply: %d\n", ret);
|
2019-02-22 21:45:24 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2019-06-08 04:27:06 +08:00
|
|
|
ret = devm_add_action_or_reset(dev, pwm_fan_regulator_disable,
|
|
|
|
ctx->reg_en);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2019-02-22 21:45:24 +08:00
|
|
|
}
|
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
ctx->pwm_value = MAX_PWM;
|
|
|
|
|
2017-04-24 21:13:17 +08:00
|
|
|
/* Set duty cycle to maximum allowed and enable PWM output */
|
|
|
|
pwm_init_state(ctx->pwm, &state);
|
|
|
|
state.duty_cycle = ctx->pwm->args.period - 1;
|
|
|
|
state.enabled = true;
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2017-04-24 21:13:17 +08:00
|
|
|
ret = pwm_apply_state(ctx->pwm, &state);
|
2014-07-16 23:46:42 +08:00
|
|
|
if (ret) {
|
2019-05-16 22:56:57 +08:00
|
|
|
dev_err(dev, "Failed to configure PWM: %d\n", ret);
|
2019-04-19 03:58:20 +08:00
|
|
|
return ret;
|
2014-07-16 23:46:42 +08:00
|
|
|
}
|
2019-04-11 21:30:11 +08:00
|
|
|
timer_setup(&ctx->rpm_timer, sample_timer, 0);
|
2019-06-08 04:27:06 +08:00
|
|
|
ret = devm_add_action_or_reset(dev, pwm_fan_pwm_disable, ctx);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2019-04-11 21:30:11 +08:00
|
|
|
|
2019-05-16 22:56:57 +08:00
|
|
|
of_property_read_u32(dev->of_node, "pulses-per-revolution", &ppr);
|
2019-04-11 21:30:11 +08:00
|
|
|
ctx->pulses_per_revolution = ppr;
|
|
|
|
if (!ctx->pulses_per_revolution) {
|
2019-05-16 22:56:57 +08:00
|
|
|
dev_err(dev, "pulses-per-revolution can't be zero.\n");
|
|
|
|
return -EINVAL;
|
2019-04-11 21:30:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx->irq > 0) {
|
2019-05-16 22:56:57 +08:00
|
|
|
ret = devm_request_irq(dev, ctx->irq, pulse_handler, 0,
|
2019-04-11 21:30:11 +08:00
|
|
|
pdev->name, ctx);
|
|
|
|
if (ret) {
|
2019-05-16 22:56:57 +08:00
|
|
|
dev_err(dev, "Failed to request interrupt: %d\n", ret);
|
|
|
|
return ret;
|
2019-04-11 21:30:11 +08:00
|
|
|
}
|
|
|
|
ctx->sample_start = ktime_get();
|
|
|
|
mod_timer(&ctx->rpm_timer, jiffies + HZ);
|
|
|
|
}
|
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
hwmon = devm_hwmon_device_register_with_groups(dev, "pwmfan",
|
2014-07-16 23:46:42 +08:00
|
|
|
ctx, pwm_fan_groups);
|
|
|
|
if (IS_ERR(hwmon)) {
|
2019-04-19 03:58:20 +08:00
|
|
|
dev_err(dev, "Failed to register hwmon device\n");
|
|
|
|
return PTR_ERR(hwmon);
|
2014-07-16 23:46:42 +08:00
|
|
|
}
|
2015-02-26 21:59:36 +08:00
|
|
|
|
2019-04-19 03:58:20 +08:00
|
|
|
ret = pwm_fan_of_get_cooling_data(dev, ctx);
|
2015-02-26 21:59:36 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2015-02-26 21:59:37 +08:00
|
|
|
ctx->pwm_fan_state = ctx->pwm_fan_max_state;
|
|
|
|
if (IS_ENABLED(CONFIG_THERMAL)) {
|
2019-04-19 03:58:20 +08:00
|
|
|
cdev = devm_thermal_of_cooling_device_register(dev,
|
|
|
|
dev->of_node, "pwm-fan", ctx, &pwm_fan_cooling_ops);
|
2015-02-26 21:59:37 +08:00
|
|
|
if (IS_ERR(cdev)) {
|
2017-04-24 21:13:17 +08:00
|
|
|
ret = PTR_ERR(cdev);
|
2019-04-19 03:58:20 +08:00
|
|
|
dev_err(dev,
|
2019-04-12 22:05:23 +08:00
|
|
|
"Failed to register pwm-fan as cooling device: %d\n",
|
|
|
|
ret);
|
2019-05-16 22:56:57 +08:00
|
|
|
return ret;
|
2015-02-26 21:59:37 +08:00
|
|
|
}
|
|
|
|
ctx->cdev = cdev;
|
|
|
|
thermal_cdev_update(cdev);
|
|
|
|
}
|
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-20 23:32:24 +08:00
|
|
|
static int pwm_fan_disable(struct device *dev)
|
2014-07-16 23:46:42 +08:00
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
hwmon: (pwm-fan) Set fan speed to 0 on suspend
Technically this is not required because disabling the PWM should be
enough. However, when support for atomic operations was implemented in
the PWM subsystem, only actual changes to the PWM channel are applied
during pwm_config(), which means that during after resume from suspend
the old settings won't be applied.
One possible solution is for the PWM driver to implement its own PM
operations such that settings from before suspend get applied on resume.
This has the disadvantage of completely ignoring any particular ordering
requirements that PWM user drivers might have, so it is best to leave it
up to the user drivers to apply the settings that they want at the
appropriate time.
Another way to solve this would be to read back the current state of the
PWM at the time of resume. That way, in case the configuration was lost
during suspend, applying the old settings in PWM user drivers would
actually get them applied because they differ from the current settings.
However, not all PWM drivers support reading the hardware state, and not
all hardware may support it.
The best workaround at this point seems to be to let PWM user drivers
tell the PWM subsystem that the PWM is turned off by, in addition to
disabling it, also setting the duty cycle to 0. This causes the resume
operation to apply a configuration that is different from the current
configuration, resulting in the proper state from before suspend getting
restored.
Signed-off-by: Thierry Reding <treding@nvidia.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
2018-09-21 18:10:48 +08:00
|
|
|
struct pwm_args args;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
pwm_get_args(ctx->pwm, &args);
|
|
|
|
|
|
|
|
if (ctx->pwm_value) {
|
|
|
|
ret = pwm_config(ctx->pwm, 0, args.period);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2014-07-16 23:46:42 +08:00
|
|
|
|
|
|
|
pwm_disable(ctx->pwm);
|
hwmon: (pwm-fan) Set fan speed to 0 on suspend
Technically this is not required because disabling the PWM should be
enough. However, when support for atomic operations was implemented in
the PWM subsystem, only actual changes to the PWM channel are applied
during pwm_config(), which means that during after resume from suspend
the old settings won't be applied.
One possible solution is for the PWM driver to implement its own PM
operations such that settings from before suspend get applied on resume.
This has the disadvantage of completely ignoring any particular ordering
requirements that PWM user drivers might have, so it is best to leave it
up to the user drivers to apply the settings that they want at the
appropriate time.
Another way to solve this would be to read back the current state of the
PWM at the time of resume. That way, in case the configuration was lost
during suspend, applying the old settings in PWM user drivers would
actually get them applied because they differ from the current settings.
However, not all PWM drivers support reading the hardware state, and not
all hardware may support it.
The best workaround at this point seems to be to let PWM user drivers
tell the PWM subsystem that the PWM is turned off by, in addition to
disabling it, also setting the duty cycle to 0. This causes the resume
operation to apply a configuration that is different from the current
configuration, resulting in the proper state from before suspend getting
restored.
Signed-off-by: Thierry Reding <treding@nvidia.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
2018-09-21 18:10:48 +08:00
|
|
|
}
|
|
|
|
|
2019-02-22 21:45:24 +08:00
|
|
|
if (ctx->reg_en) {
|
|
|
|
ret = regulator_disable(ctx->reg_en);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "Failed to disable fan supply: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-20 23:32:24 +08:00
|
|
|
static void pwm_fan_shutdown(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
pwm_fan_disable(&pdev->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int pwm_fan_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
return pwm_fan_disable(dev);
|
|
|
|
}
|
|
|
|
|
2014-07-16 23:46:42 +08:00
|
|
|
static int pwm_fan_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
2016-04-15 03:17:24 +08:00
|
|
|
struct pwm_args pargs;
|
2014-11-03 22:42:55 +08:00
|
|
|
unsigned long duty;
|
|
|
|
int ret;
|
2014-07-16 23:46:42 +08:00
|
|
|
|
2019-02-22 21:45:24 +08:00
|
|
|
if (ctx->reg_en) {
|
|
|
|
ret = regulator_enable(ctx->reg_en);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "Failed to enable fan supply: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-03 22:42:55 +08:00
|
|
|
if (ctx->pwm_value == 0)
|
|
|
|
return 0;
|
|
|
|
|
2016-04-15 03:17:24 +08:00
|
|
|
pwm_get_args(ctx->pwm, &pargs);
|
2020-06-03 06:31:06 +08:00
|
|
|
duty = DIV_ROUND_UP_ULL(ctx->pwm_value * (pargs.period - 1), MAX_PWM);
|
2016-04-15 03:17:24 +08:00
|
|
|
ret = pwm_config(ctx->pwm, duty, pargs.period);
|
2014-11-03 22:42:55 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
return pwm_enable(ctx->pwm);
|
2014-07-16 23:46:42 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);
|
|
|
|
|
2015-03-17 03:54:36 +08:00
|
|
|
static const struct of_device_id of_pwm_fan_match[] = {
|
2014-07-16 23:46:42 +08:00
|
|
|
{ .compatible = "pwm-fan", },
|
|
|
|
{},
|
|
|
|
};
|
2015-09-18 00:09:55 +08:00
|
|
|
MODULE_DEVICE_TABLE(of, of_pwm_fan_match);
|
2014-07-16 23:46:42 +08:00
|
|
|
|
|
|
|
static struct platform_driver pwm_fan_driver = {
|
|
|
|
.probe = pwm_fan_probe,
|
2020-01-20 23:32:24 +08:00
|
|
|
.shutdown = pwm_fan_shutdown,
|
2014-07-16 23:46:42 +08:00
|
|
|
.driver = {
|
|
|
|
.name = "pwm-fan",
|
|
|
|
.pm = &pwm_fan_pm,
|
|
|
|
.of_match_table = of_pwm_fan_match,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
module_platform_driver(pwm_fan_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
|
|
|
|
MODULE_ALIAS("platform:pwm-fan");
|
|
|
|
MODULE_DESCRIPTION("PWM FAN driver");
|
|
|
|
MODULE_LICENSE("GPL");
|