[deliverable/linux.git] / drivers / hwmon / pwm-fan.c

/*
 * 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>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pwm.h>
#include <linux/sysfs.h>

#define MAX_PWM 255

struct pwm_fan_ctx {
	struct mutex lock;
	struct pwm_device *pwm;
	unsigned char pwm_value;
};

static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
	unsigned long pwm, duty;
	ssize_t ret;

	if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM)
		return -EINVAL;

	mutex_lock(&ctx->lock);

	if (ctx->pwm_value == pwm)
		goto exit_set_pwm_no_change;

	if (pwm == 0) {
		pwm_disable(ctx->pwm);
		goto exit_set_pwm;
	}

	duty = DIV_ROUND_UP(pwm * (ctx->pwm->period - 1), MAX_PWM);
	ret = pwm_config(ctx->pwm, duty, ctx->pwm->period);
	if (ret)
		goto exit_set_pwm_err;

	if (ctx->pwm_value == 0) {
		ret = pwm_enable(ctx->pwm);
		if (ret)
			goto exit_set_pwm_err;
	}

exit_set_pwm:
	ctx->pwm_value = pwm;
exit_set_pwm_no_change:
	ret = count;
exit_set_pwm_err:
	mutex_unlock(&ctx->lock);
	return ret;
}

static ssize_t show_pwm(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);

	return sprintf(buf, "%u\n", ctx->pwm_value);
}


static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);

static struct attribute *pwm_fan_attrs[] = {
	&sensor_dev_attr_pwm1.dev_attr.attr,
	NULL,
};

ATTRIBUTE_GROUPS(pwm_fan);

static int pwm_fan_probe(struct platform_device *pdev)
{
	struct device *hwmon;
	struct pwm_fan_ctx *ctx;
	int duty_cycle;
	int ret;

	ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return -ENOMEM;

	mutex_init(&ctx->lock);

	ctx->pwm = devm_of_pwm_get(&pdev->dev, pdev->dev.of_node, NULL);
	if (IS_ERR(ctx->pwm)) {
		dev_err(&pdev->dev, "Could not get PWM\n");
		return PTR_ERR(ctx->pwm);
	}

	platform_set_drvdata(pdev, ctx);

	/* Set duty cycle to maximum allowed */
	duty_cycle = ctx->pwm->period - 1;
	ctx->pwm_value = MAX_PWM;

	ret = pwm_config(ctx->pwm, duty_cycle, ctx->pwm->period);
	if (ret) {
		dev_err(&pdev->dev, "Failed to configure PWM\n");
		return ret;
	}

	/* Enbale PWM output */
	ret = pwm_enable(ctx->pwm);
	if (ret) {
		dev_err(&pdev->dev, "Failed to enable PWM\n");
		return ret;
	}

	hwmon = devm_hwmon_device_register_with_groups(&pdev->dev, "pwmfan",
						       ctx, pwm_fan_groups);
	if (IS_ERR(hwmon)) {
		dev_err(&pdev->dev, "Failed to register hwmon device\n");
		pwm_disable(ctx->pwm);
		return PTR_ERR(hwmon);
	}
	return 0;
}

static int pwm_fan_remove(struct platform_device *pdev)
{
	struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev);

	if (ctx->pwm_value)
		pwm_disable(ctx->pwm);
	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int pwm_fan_suspend(struct device *dev)
{
	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);

	if (ctx->pwm_value)
		pwm_disable(ctx->pwm);
	return 0;
}

static int pwm_fan_resume(struct device *dev)
{
	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);

	if (ctx->pwm_value)
		return pwm_enable(ctx->pwm);
	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);

static struct of_device_id of_pwm_fan_match[] = {
	{ .compatible = "pwm-fan", },
	{},
};

static struct platform_driver pwm_fan_driver = {
	.probe		= pwm_fan_probe,
	.remove		= pwm_fan_remove,
	.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");
Commit	Line	Data
d82d5776 KD	1	/*
	2	* pwm-fan.c - Hwmon driver for fans connected to PWM lines.
	3	*
	4	* Copyright (c) 2014 Samsung Electronics Co., Ltd.
	5	*
	6	* Author: Kamil Debski <k.debski@samsung.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#include <linux/hwmon.h>
	20	#include <linux/hwmon-sysfs.h>
	21	#include <linux/module.h>
	22	#include <linux/mutex.h>
	23	#include <linux/of.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/pwm.h>
	26	#include <linux/sysfs.h>
	27
	28	#define MAX_PWM 255
	29
	30	struct pwm_fan_ctx {
	31	struct mutex lock;
	32	struct pwm_device *pwm;
	33	unsigned char pwm_value;
	34	};
	35
	36	static ssize_t set_pwm(struct device dev, struct device_attribute attr,
	37	const char *buf, size_t count)
	38	{
	39	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
	40	unsigned long pwm, duty;
	41	ssize_t ret;
	42
	43	if (kstrtoul(buf, 10, &pwm) \|\| pwm > MAX_PWM)
	44	return -EINVAL;
	45
	46	mutex_lock(&ctx->lock);
	47
	48	if (ctx->pwm_value == pwm)
	49	goto exit_set_pwm_no_change;
	50
	51	if (pwm == 0) {
	52	pwm_disable(ctx->pwm);
	53	goto exit_set_pwm;
	54	}
	55
	56	duty = DIV_ROUND_UP(pwm * (ctx->pwm->period - 1), MAX_PWM);
	57	ret = pwm_config(ctx->pwm, duty, ctx->pwm->period);
	58	if (ret)
	59	goto exit_set_pwm_err;
	60
	61	if (ctx->pwm_value == 0) {
	62	ret = pwm_enable(ctx->pwm);
	63	if (ret)
	64	goto exit_set_pwm_err;
65	}
66
67	exit_set_pwm:
68	ctx->pwm_value = pwm;
69	exit_set_pwm_no_change:
70	ret = count;
71	exit_set_pwm_err:
72	mutex_unlock(&ctx->lock);
73	return ret;
74	}
75
76	static ssize_t show_pwm(struct device *dev,
77	struct device_attribute attr, char buf)
78	{
79	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
80
81	return sprintf(buf, "%u\n", ctx->pwm_value);
82	}
83
84
85	static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO \| S_IWUSR, show_pwm, set_pwm, 0);
86
87	static struct attribute *pwm_fan_attrs[] = {
88	&sensor_dev_attr_pwm1.dev_attr.attr,
89	NULL,
90	};
91
92	ATTRIBUTE_GROUPS(pwm_fan);
93
94	static int pwm_fan_probe(struct platform_device *pdev)
95	{
96	struct device *hwmon;
97	struct pwm_fan_ctx *ctx;
98	int duty_cycle;
99	int ret;
100
101	ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
102	if (!ctx)
103	return -ENOMEM;
104
105	mutex_init(&ctx->lock);
106
107	ctx->pwm = devm_of_pwm_get(&pdev->dev, pdev->dev.of_node, NULL);
108	if (IS_ERR(ctx->pwm)) {
109	dev_err(&pdev->dev, "Could not get PWM\n");
110	return PTR_ERR(ctx->pwm);
111	}
112
d82d5776 KD	113	platform_set_drvdata(pdev, ctx);
	114
	115	/* Set duty cycle to maximum allowed */
	116	duty_cycle = ctx->pwm->period - 1;
	117	ctx->pwm_value = MAX_PWM;
	118
	119	ret = pwm_config(ctx->pwm, duty_cycle, ctx->pwm->period);
	120	if (ret) {
	121	dev_err(&pdev->dev, "Failed to configure PWM\n");
	122	return ret;
	123	}
	124
	125	/* Enbale PWM output */
	126	ret = pwm_enable(ctx->pwm);
	127	if (ret) {
	128	dev_err(&pdev->dev, "Failed to enable PWM\n");
	129	return ret;
	130	}
	131
	132	hwmon = devm_hwmon_device_register_with_groups(&pdev->dev, "pwmfan",
	133	ctx, pwm_fan_groups);
	134	if (IS_ERR(hwmon)) {
	135	dev_err(&pdev->dev, "Failed to register hwmon device\n");
	136	pwm_disable(ctx->pwm);
	137	return PTR_ERR(hwmon);
	138	}
	139	return 0;
	140	}
	141
	142	static int pwm_fan_remove(struct platform_device *pdev)
	143	{
	144	struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev);
	145
	146	if (ctx->pwm_value)
	147	pwm_disable(ctx->pwm);
	148	return 0;
	149	}
	150
	151	#ifdef CONFIG_PM_SLEEP
	152	static int pwm_fan_suspend(struct device *dev)
	153	{
	154	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
	155
	156	if (ctx->pwm_value)
	157	pwm_disable(ctx->pwm);
	158	return 0;
	159	}
	160
	161	static int pwm_fan_resume(struct device *dev)
	162	{
	163	struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
	164
	165	if (ctx->pwm_value)
	166	return pwm_enable(ctx->pwm);
	167	return 0;
	168	}
	169	#endif
	170
	171	static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);
	172
	173	static struct of_device_id of_pwm_fan_match[] = {
	174	{ .compatible = "pwm-fan", },
	175	{},
	176	};
177
178	static struct platform_driver pwm_fan_driver = {
179	.probe = pwm_fan_probe,
180	.remove = pwm_fan_remove,
181	.driver = {
182	.name = "pwm-fan",
183	.pm = &pwm_fan_pm,
184	.of_match_table = of_pwm_fan_match,
185	},
186	};
187
188	module_platform_driver(pwm_fan_driver);
189
190	MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
191	MODULE_ALIAS("platform:pwm-fan");
192	MODULE_DESCRIPTION("PWM FAN driver");
193	MODULE_LICENSE("GPL");