[mirror_ubuntu-jammy-kernel.git] / drivers / hwmon / gpio-fan.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * gpio-fan.c - Hwmon driver for fans connected to GPIO lines.
 *
 * Copyright (C) 2010 LaCie
 *
 * Author: Simon Guinot <sguinot@lacie.com>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/hwmon.h>
#include <linux/gpio/consumer.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/thermal.h>

struct gpio_fan_speed {
	int rpm;
	int ctrl_val;
};

struct gpio_fan_data {
	struct device		*dev;
	struct device		*hwmon_dev;
	/* Cooling device if any */
	struct thermal_cooling_device *cdev;
	struct mutex		lock; /* lock GPIOs operations. */
	int			num_gpios;
	struct gpio_desc	**gpios;
	int			num_speed;
	struct gpio_fan_speed	*speed;
	int			speed_index;
#ifdef CONFIG_PM_SLEEP
	int			resume_speed;
#endif
	bool			pwm_enable;
	struct gpio_desc	*alarm_gpio;
	struct work_struct	alarm_work;
};

/*
 * Alarm GPIO.
 */

static void fan_alarm_notify(struct work_struct *ws)
{
	struct gpio_fan_data *fan_data =
		container_of(ws, struct gpio_fan_data, alarm_work);

	sysfs_notify(&fan_data->hwmon_dev->kobj, NULL, "fan1_alarm");
	kobject_uevent(&fan_data->hwmon_dev->kobj, KOBJ_CHANGE);
}

static irqreturn_t fan_alarm_irq_handler(int irq, void *dev_id)
{
	struct gpio_fan_data *fan_data = dev_id;

	schedule_work(&fan_data->alarm_work);

	return IRQ_NONE;
}

static ssize_t fan1_alarm_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n",
		       gpiod_get_value_cansleep(fan_data->alarm_gpio));
}

static DEVICE_ATTR_RO(fan1_alarm);

static int fan_alarm_init(struct gpio_fan_data *fan_data)
{
	int alarm_irq;
	struct device *dev = fan_data->dev;

	/*
	 * If the alarm GPIO don't support interrupts, just leave
	 * without initializing the fail notification support.
	 */
	alarm_irq = gpiod_to_irq(fan_data->alarm_gpio);
	if (alarm_irq <= 0)
		return 0;

	INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
	irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
	return devm_request_irq(dev, alarm_irq, fan_alarm_irq_handler,
				IRQF_SHARED, "GPIO fan alarm", fan_data);
}

/*
 * Control GPIOs.
 */

/* Must be called with fan_data->lock held, except during initialization. */
static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
{
	int i;

	for (i = 0; i < fan_data->num_gpios; i++)
		gpiod_set_value_cansleep(fan_data->gpios[i],
					 (ctrl_val >> i) & 1);
}

static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
{
	int i;
	int ctrl_val = 0;

	for (i = 0; i < fan_data->num_gpios; i++) {
		int value;

		value = gpiod_get_value_cansleep(fan_data->gpios[i]);
		ctrl_val |= (value << i);
	}
	return ctrl_val;
}

/* Must be called with fan_data->lock held, except during initialization. */
static void set_fan_speed(struct gpio_fan_data *fan_data, int speed_index)
{
	if (fan_data->speed_index == speed_index)
		return;

	__set_fan_ctrl(fan_data, fan_data->speed[speed_index].ctrl_val);
	fan_data->speed_index = speed_index;
}

static int get_fan_speed_index(struct gpio_fan_data *fan_data)
{
	int ctrl_val = __get_fan_ctrl(fan_data);
	int i;

	for (i = 0; i < fan_data->num_speed; i++)
		if (fan_data->speed[i].ctrl_val == ctrl_val)
			return i;

	dev_warn(fan_data->dev,
		 "missing speed array entry for GPIO value 0x%x\n", ctrl_val);

	return -ENODEV;
}

static int rpm_to_speed_index(struct gpio_fan_data *fan_data, unsigned long rpm)
{
	struct gpio_fan_speed *speed = fan_data->speed;
	int i;

	for (i = 0; i < fan_data->num_speed; i++)
		if (speed[i].rpm >= rpm)
			return i;

	return fan_data->num_speed - 1;
}

static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);

	return sprintf(buf, "%d\n", pwm);
}

static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	unsigned long pwm;
	int speed_index;
	int ret = count;

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

	mutex_lock(&fan_data->lock);

	if (!fan_data->pwm_enable) {
		ret = -EPERM;
		goto exit_unlock;
	}

	speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);
	set_fan_speed(fan_data, speed_index);

exit_unlock:
	mutex_unlock(&fan_data->lock);

	return ret;
}

static ssize_t pwm1_enable_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", fan_data->pwm_enable);
}

static ssize_t pwm1_enable_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	unsigned long val;

	if (kstrtoul(buf, 10, &val) || val > 1)
		return -EINVAL;

	if (fan_data->pwm_enable == val)
		return count;

	mutex_lock(&fan_data->lock);

	fan_data->pwm_enable = val;

	/* Disable manual control mode: set fan at full speed. */
	if (val == 0)
		set_fan_speed(fan_data, fan_data->num_speed - 1);

	mutex_unlock(&fan_data->lock);

	return count;
}

static ssize_t pwm1_mode_show(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "0\n");
}

static ssize_t fan1_min_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", fan_data->speed[0].rpm);
}

static ssize_t fan1_max_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n",
		       fan_data->speed[fan_data->num_speed - 1].rpm);
}

static ssize_t fan1_input_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", fan_data->speed[fan_data->speed_index].rpm);
}

static ssize_t set_rpm(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	unsigned long rpm;
	int ret = count;

	if (kstrtoul(buf, 10, &rpm))
		return -EINVAL;

	mutex_lock(&fan_data->lock);

	if (!fan_data->pwm_enable) {
		ret = -EPERM;
		goto exit_unlock;
	}

	set_fan_speed(fan_data, rpm_to_speed_index(fan_data, rpm));

exit_unlock:
	mutex_unlock(&fan_data->lock);

	return ret;
}

static DEVICE_ATTR_RW(pwm1);
static DEVICE_ATTR_RW(pwm1_enable);
static DEVICE_ATTR_RO(pwm1_mode);
static DEVICE_ATTR_RO(fan1_min);
static DEVICE_ATTR_RO(fan1_max);
static DEVICE_ATTR_RO(fan1_input);
static DEVICE_ATTR(fan1_target, 0644, fan1_input_show, set_rpm);

static umode_t gpio_fan_is_visible(struct kobject *kobj,
				   struct attribute *attr, int index)
{
	struct device *dev = kobj_to_dev(kobj);
	struct gpio_fan_data *data = dev_get_drvdata(dev);

	if (index == 0 && !data->alarm_gpio)
		return 0;
	if (index > 0 && !data->gpios)
		return 0;

	return attr->mode;
}

static struct attribute *gpio_fan_attributes[] = {
	&dev_attr_fan1_alarm.attr,		/* 0 */
	&dev_attr_pwm1.attr,			/* 1 */
	&dev_attr_pwm1_enable.attr,
	&dev_attr_pwm1_mode.attr,
	&dev_attr_fan1_input.attr,
	&dev_attr_fan1_target.attr,
	&dev_attr_fan1_min.attr,
	&dev_attr_fan1_max.attr,
	NULL
};

static const struct attribute_group gpio_fan_group = {
	.attrs = gpio_fan_attributes,
	.is_visible = gpio_fan_is_visible,
};

static const struct attribute_group *gpio_fan_groups[] = {
	&gpio_fan_group,
	NULL
};

static int fan_ctrl_init(struct gpio_fan_data *fan_data)
{
	int num_gpios = fan_data->num_gpios;
	struct gpio_desc **gpios = fan_data->gpios;
	int i, err;

	for (i = 0; i < num_gpios; i++) {
		/*
		 * The GPIO descriptors were retrieved with GPIOD_ASIS so here
		 * we set the GPIO into output mode, carefully preserving the
		 * current value by setting it to whatever it is already set
		 * (no surprise changes in default fan speed).
		 */
		err = gpiod_direction_output(gpios[i],
					gpiod_get_value_cansleep(gpios[i]));
		if (err)
			return err;
	}

	fan_data->pwm_enable = true; /* Enable manual fan speed control. */
	fan_data->speed_index = get_fan_speed_index(fan_data);
	if (fan_data->speed_index < 0)
		return fan_data->speed_index;

	return 0;
}

static int gpio_fan_get_max_state(struct thermal_cooling_device *cdev,
				  unsigned long *state)
{
	struct gpio_fan_data *fan_data = cdev->devdata;

	if (!fan_data)
		return -EINVAL;

	*state = fan_data->num_speed - 1;
	return 0;
}

static int gpio_fan_get_cur_state(struct thermal_cooling_device *cdev,
				  unsigned long *state)
{
	struct gpio_fan_data *fan_data = cdev->devdata;

	if (!fan_data)
		return -EINVAL;

	*state = fan_data->speed_index;
	return 0;
}

static int gpio_fan_set_cur_state(struct thermal_cooling_device *cdev,
				  unsigned long state)
{
	struct gpio_fan_data *fan_data = cdev->devdata;

	if (!fan_data)
		return -EINVAL;

	set_fan_speed(fan_data, state);
	return 0;
}

static const struct thermal_cooling_device_ops gpio_fan_cool_ops = {
	.get_max_state = gpio_fan_get_max_state,
	.get_cur_state = gpio_fan_get_cur_state,
	.set_cur_state = gpio_fan_set_cur_state,
};

/*
 * Translate OpenFirmware node properties into platform_data
 */
static int gpio_fan_get_of_data(struct gpio_fan_data *fan_data)
{
	struct gpio_fan_speed *speed;
	struct device *dev = fan_data->dev;
	struct device_node *np = dev->of_node;
	struct gpio_desc **gpios;
	unsigned i;
	u32 u;
	struct property *prop;
	const __be32 *p;

	/* Alarm GPIO if one exists */
	fan_data->alarm_gpio = devm_gpiod_get_optional(dev, "alarm", GPIOD_IN);
	if (IS_ERR(fan_data->alarm_gpio))
		return PTR_ERR(fan_data->alarm_gpio);

	/* Fill GPIO pin array */
	fan_data->num_gpios = gpiod_count(dev, NULL);
	if (fan_data->num_gpios <= 0) {
		if (fan_data->alarm_gpio)
			return 0;
		dev_err(dev, "DT properties empty / missing");
		return -ENODEV;
	}
	gpios = devm_kcalloc(dev,
			     fan_data->num_gpios, sizeof(struct gpio_desc *),
			     GFP_KERNEL);
	if (!gpios)
		return -ENOMEM;
	for (i = 0; i < fan_data->num_gpios; i++) {
		gpios[i] = devm_gpiod_get_index(dev, NULL, i, GPIOD_ASIS);
		if (IS_ERR(gpios[i]))
			return PTR_ERR(gpios[i]);
	}
	fan_data->gpios = gpios;

	/* Get number of RPM/ctrl_val pairs in speed map */
	prop = of_find_property(np, "gpio-fan,speed-map", &i);
	if (!prop) {
		dev_err(dev, "gpio-fan,speed-map DT property missing");
		return -ENODEV;
	}
	i = i / sizeof(u32);
	if (i == 0 || i & 1) {
		dev_err(dev, "gpio-fan,speed-map contains zero/odd number of entries");
		return -ENODEV;
	}
	fan_data->num_speed = i / 2;

	/*
	 * Populate speed map
	 * Speed map is in the form <RPM ctrl_val RPM ctrl_val ...>
	 * this needs splitting into pairs to create gpio_fan_speed structs
	 */
	speed = devm_kcalloc(dev,
			fan_data->num_speed, sizeof(struct gpio_fan_speed),
			GFP_KERNEL);
	if (!speed)
		return -ENOMEM;
	p = NULL;
	for (i = 0; i < fan_data->num_speed; i++) {
		p = of_prop_next_u32(prop, p, &u);
		if (!p)
			return -ENODEV;
		speed[i].rpm = u;
		p = of_prop_next_u32(prop, p, &u);
		if (!p)
			return -ENODEV;
		speed[i].ctrl_val = u;
	}
	fan_data->speed = speed;

	return 0;
}

static const struct of_device_id of_gpio_fan_match[] = {
	{ .compatible = "gpio-fan", },
	{},
};
MODULE_DEVICE_TABLE(of, of_gpio_fan_match);

static void gpio_fan_stop(void *data)
{
	set_fan_speed(data, 0);
}

static int gpio_fan_probe(struct platform_device *pdev)
{
	int err;
	struct gpio_fan_data *fan_data;
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;

	fan_data = devm_kzalloc(dev, sizeof(struct gpio_fan_data),
				GFP_KERNEL);
	if (!fan_data)
		return -ENOMEM;

	fan_data->dev = dev;
	err = gpio_fan_get_of_data(fan_data);
	if (err)
		return err;

	platform_set_drvdata(pdev, fan_data);
	mutex_init(&fan_data->lock);

	/* Configure control GPIOs if available. */
	if (fan_data->gpios && fan_data->num_gpios > 0) {
		if (!fan_data->speed || fan_data->num_speed <= 1)
			return -EINVAL;
		err = fan_ctrl_init(fan_data);
		if (err)
			return err;
		err = devm_add_action_or_reset(dev, gpio_fan_stop, fan_data);
		if (err)
			return err;
	}

	/* Make this driver part of hwmon class. */
	fan_data->hwmon_dev =
		devm_hwmon_device_register_with_groups(dev,
						       "gpio_fan", fan_data,
						       gpio_fan_groups);
	if (IS_ERR(fan_data->hwmon_dev))
		return PTR_ERR(fan_data->hwmon_dev);

	/* Configure alarm GPIO if available. */
	if (fan_data->alarm_gpio) {
		err = fan_alarm_init(fan_data);
		if (err)
			return err;
	}

	/* Optional cooling device register for Device tree platforms */
	fan_data->cdev = devm_thermal_of_cooling_device_register(dev, np,
				"gpio-fan", fan_data, &gpio_fan_cool_ops);

	dev_info(dev, "GPIO fan initialized\n");

	return 0;
}

static void gpio_fan_shutdown(struct platform_device *pdev)
{
	struct gpio_fan_data *fan_data = platform_get_drvdata(pdev);

	if (fan_data->gpios)
		set_fan_speed(fan_data, 0);
}

#ifdef CONFIG_PM_SLEEP
static int gpio_fan_suspend(struct device *dev)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	if (fan_data->gpios) {
		fan_data->resume_speed = fan_data->speed_index;
		set_fan_speed(fan_data, 0);
	}

	return 0;
}

static int gpio_fan_resume(struct device *dev)
{
	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);

	if (fan_data->gpios)
		set_fan_speed(fan_data, fan_data->resume_speed);

	return 0;
}

static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
#define GPIO_FAN_PM	(&gpio_fan_pm)
#else
#define GPIO_FAN_PM	NULL
#endif

static struct platform_driver gpio_fan_driver = {
	.probe		= gpio_fan_probe,
	.shutdown	= gpio_fan_shutdown,
	.driver	= {
		.name	= "gpio-fan",
		.pm	= GPIO_FAN_PM,
		.of_match_table = of_match_ptr(of_gpio_fan_match),
	},
};

module_platform_driver(gpio_fan_driver);

MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
MODULE_DESCRIPTION("GPIO FAN driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:gpio-fan");
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
d6fe1360 SG	2	/*
	3	* gpio-fan.c - Hwmon driver for fans connected to GPIO lines.
	4	*
	5	* Copyright (C) 2010 LaCie
	6	*
	7	* Author: Simon Guinot <sguinot@lacie.com>
d6fe1360 SG	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/slab.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/irq.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/err.h>
	17	#include <linux/mutex.h>
	18	#include <linux/hwmon.h>
9de382fd	19	#include <linux/gpio/consumer.h>
c50588ab	20	#include <linux/of.h>
55fb8b06	21	#include <linux/of_platform.h>
b5cf88e4	22	#include <linux/thermal.h>
d6fe1360	23
ef7a6124 LW	24	struct gpio_fan_speed {
	25	int rpm;
	26	int ctrl_val;
	27	};
	28
d6fe1360	29	struct gpio_fan_data {
8c0eb9bc	30	struct device *dev;
d6fe1360	31	struct device *hwmon_dev;
b5cf88e4 NM	32	/* Cooling device if any */
b5cf88e4 NM	33	struct thermal_cooling_device *cdev;
d6fe1360	34	struct mutex lock; /* lock GPIOs operations. */
e99c2e5d	35	int num_gpios;
9de382fd	36	struct gpio_desc **gpios;
d6fe1360 SG	37	int num_speed;
	38	struct gpio_fan_speed *speed;
	39	int speed_index;
6d20a6c0	40	#ifdef CONFIG_PM_SLEEP
d6fe1360 SG	41	int resume_speed;
	42	#endif
	43	bool pwm_enable;
9de382fd	44	struct gpio_desc *alarm_gpio;
d6fe1360 SG	45	struct work_struct alarm_work;
	46	};
	47
	48	/*
	49	* Alarm GPIO.
	50	*/
	51
	52	static void fan_alarm_notify(struct work_struct *ws)
	53	{
	54	struct gpio_fan_data *fan_data =
	55	container_of(ws, struct gpio_fan_data, alarm_work);
	56
277c628f CS	57	sysfs_notify(&fan_data->hwmon_dev->kobj, NULL, "fan1_alarm");
277c628f CS	58	kobject_uevent(&fan_data->hwmon_dev->kobj, KOBJ_CHANGE);
d6fe1360 SG	59	}
	60
	61	static irqreturn_t fan_alarm_irq_handler(int irq, void *dev_id)
	62	{
	63	struct gpio_fan_data *fan_data = dev_id;
	64
	65	schedule_work(&fan_data->alarm_work);
	66
	67	return IRQ_NONE;
	68	}
	69
c490c63e JL	70	static ssize_t fan1_alarm_show(struct device *dev,
c490c63e JL	71	struct device_attribute attr, char buf)
d6fe1360 SG	72	{
d6fe1360 SG	73	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
d6fe1360	74
9de382fd LW	75	return sprintf(buf, "%d\n",
9de382fd LW	76	gpiod_get_value_cansleep(fan_data->alarm_gpio));
d6fe1360 SG	77	}
d6fe1360 SG	78
c490c63e	79	static DEVICE_ATTR_RO(fan1_alarm);
d6fe1360	80
b5482f7e	81	static int fan_alarm_init(struct gpio_fan_data *fan_data)
d6fe1360	82	{
d6fe1360	83	int alarm_irq;
8c0eb9bc	84	struct device *dev = fan_data->dev;
d6fe1360	85
d6fe1360 SG	86	/*
	87	* If the alarm GPIO don't support interrupts, just leave
	88	* without initializing the fail notification support.
	89	*/
9de382fd LW	90	alarm_irq = gpiod_to_irq(fan_data->alarm_gpio);
9de382fd LW	91	if (alarm_irq <= 0)
d6fe1360 SG	92	return 0;
	93
	94	INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
dced35ae	95	irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
9de382fd LW	96	return devm_request_irq(dev, alarm_irq, fan_alarm_irq_handler,
9de382fd LW	97	IRQF_SHARED, "GPIO fan alarm", fan_data);
d6fe1360 SG	98	}
d6fe1360 SG	99
d6fe1360 SG	100	/*
	101	* Control GPIOs.
	102	*/
	103
	104	/* Must be called with fan_data->lock held, except during initialization. */
	105	static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
	106	{
	107	int i;
	108
e99c2e5d	109	for (i = 0; i < fan_data->num_gpios; i++)
9de382fd LW	110	gpiod_set_value_cansleep(fan_data->gpios[i],
9de382fd LW	111	(ctrl_val >> i) & 1);
d6fe1360 SG	112	}
	113
	114	static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
	115	{
	116	int i;
	117	int ctrl_val = 0;
	118
e99c2e5d	119	for (i = 0; i < fan_data->num_gpios; i++) {
d6fe1360 SG	120	int value;
d6fe1360 SG	121
9de382fd	122	value = gpiod_get_value_cansleep(fan_data->gpios[i]);
d6fe1360 SG	123	ctrl_val \|= (value << i);
	124	}
	125	return ctrl_val;
	126	}
	127
	128	/* Must be called with fan_data->lock held, except during initialization. */
	129	static void set_fan_speed(struct gpio_fan_data *fan_data, int speed_index)
	130	{
	131	if (fan_data->speed_index == speed_index)
	132	return;
	133
	134	__set_fan_ctrl(fan_data, fan_data->speed[speed_index].ctrl_val);
	135	fan_data->speed_index = speed_index;
	136	}
	137
	138	static int get_fan_speed_index(struct gpio_fan_data *fan_data)
	139	{
	140	int ctrl_val = __get_fan_ctrl(fan_data);
	141	int i;
	142
	143	for (i = 0; i < fan_data->num_speed; i++)
	144	if (fan_data->speed[i].ctrl_val == ctrl_val)
	145	return i;
	146
8c0eb9bc	147	dev_warn(fan_data->dev,
d6fe1360 SG	148	"missing speed array entry for GPIO value 0x%x\n", ctrl_val);
d6fe1360 SG	149
c52ae3d2	150	return -ENODEV;
d6fe1360 SG	151	}
d6fe1360 SG	152
2565fb05	153	static int rpm_to_speed_index(struct gpio_fan_data *fan_data, unsigned long rpm)
d6fe1360 SG	154	{
	155	struct gpio_fan_speed *speed = fan_data->speed;
	156	int i;
	157
	158	for (i = 0; i < fan_data->num_speed; i++)
	159	if (speed[i].rpm >= rpm)
	160	return i;
	161
	162	return fan_data->num_speed - 1;
	163	}
	164
c490c63e JL	165	static ssize_t pwm1_show(struct device dev, struct device_attribute attr,
c490c63e JL	166	char *buf)
d6fe1360 SG	167	{
	168	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	169	u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);
	170
	171	return sprintf(buf, "%d\n", pwm);
	172	}
	173
c490c63e JL	174	static ssize_t pwm1_store(struct device dev, struct device_attribute attr,
c490c63e JL	175	const char *buf, size_t count)
d6fe1360 SG	176	{
	177	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	178	unsigned long pwm;
	179	int speed_index;
	180	int ret = count;
	181
179c4fdb	182	if (kstrtoul(buf, 10, &pwm) \|\| pwm > 255)
d6fe1360 SG	183	return -EINVAL;
	184
	185	mutex_lock(&fan_data->lock);
	186
	187	if (!fan_data->pwm_enable) {
	188	ret = -EPERM;
	189	goto exit_unlock;
	190	}
	191
	192	speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);
	193	set_fan_speed(fan_data, speed_index);
	194
	195	exit_unlock:
	196	mutex_unlock(&fan_data->lock);
	197
	198	return ret;
	199	}
	200
c490c63e JL	201	static ssize_t pwm1_enable_show(struct device *dev,
c490c63e JL	202	struct device_attribute attr, char buf)
d6fe1360 SG	203	{
	204	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	205
	206	return sprintf(buf, "%d\n", fan_data->pwm_enable);
	207	}
	208
c490c63e JL	209	static ssize_t pwm1_enable_store(struct device *dev,
	210	struct device_attribute *attr,
	211	const char *buf, size_t count)
d6fe1360 SG	212	{
	213	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	214	unsigned long val;
	215
179c4fdb	216	if (kstrtoul(buf, 10, &val) \|\| val > 1)
d6fe1360 SG	217	return -EINVAL;
	218
	219	if (fan_data->pwm_enable == val)
	220	return count;
	221
	222	mutex_lock(&fan_data->lock);
	223
	224	fan_data->pwm_enable = val;
	225
	226	/* Disable manual control mode: set fan at full speed. */
	227	if (val == 0)
	228	set_fan_speed(fan_data, fan_data->num_speed - 1);
	229
	230	mutex_unlock(&fan_data->lock);
	231
	232	return count;
	233	}
	234
c490c63e JL	235	static ssize_t pwm1_mode_show(struct device *dev,
c490c63e JL	236	struct device_attribute attr, char buf)
d6fe1360 SG	237	{
	238	return sprintf(buf, "0\n");
	239	}
	240
c490c63e JL	241	static ssize_t fan1_min_show(struct device *dev,
c490c63e JL	242	struct device_attribute attr, char buf)
d6fe1360 SG	243	{
	244	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	245
	246	return sprintf(buf, "%d\n", fan_data->speed[0].rpm);
	247	}
	248
c490c63e JL	249	static ssize_t fan1_max_show(struct device *dev,
c490c63e JL	250	struct device_attribute attr, char buf)
d6fe1360 SG	251	{
	252	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	253
	254	return sprintf(buf, "%d\n",
	255	fan_data->speed[fan_data->num_speed - 1].rpm);
	256	}
	257
c490c63e JL	258	static ssize_t fan1_input_show(struct device *dev,
c490c63e JL	259	struct device_attribute attr, char buf)
d6fe1360 SG	260	{
	261	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	262
	263	return sprintf(buf, "%d\n", fan_data->speed[fan_data->speed_index].rpm);
	264	}
	265
	266	static ssize_t set_rpm(struct device dev, struct device_attribute attr,
	267	const char *buf, size_t count)
	268	{
	269	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
	270	unsigned long rpm;
	271	int ret = count;
	272
179c4fdb	273	if (kstrtoul(buf, 10, &rpm))
d6fe1360 SG	274	return -EINVAL;
	275
	276	mutex_lock(&fan_data->lock);
	277
	278	if (!fan_data->pwm_enable) {
	279	ret = -EPERM;
	280	goto exit_unlock;
	281	}
	282
	283	set_fan_speed(fan_data, rpm_to_speed_index(fan_data, rpm));
	284
	285	exit_unlock:
	286	mutex_unlock(&fan_data->lock);
	287
	288	return ret;
	289	}
	290
c490c63e JL	291	static DEVICE_ATTR_RW(pwm1);
	292	static DEVICE_ATTR_RW(pwm1_enable);
	293	static DEVICE_ATTR_RO(pwm1_mode);
	294	static DEVICE_ATTR_RO(fan1_min);
	295	static DEVICE_ATTR_RO(fan1_max);
	296	static DEVICE_ATTR_RO(fan1_input);
905bc0d4	297	static DEVICE_ATTR(fan1_target, 0644, fan1_input_show, set_rpm);
d6fe1360	298
c81cc5a4 GR	299	static umode_t gpio_fan_is_visible(struct kobject *kobj,
	300	struct attribute *attr, int index)
	301	{
8bfc731e	302	struct device *dev = kobj_to_dev(kobj);
c81cc5a4 GR	303	struct gpio_fan_data *data = dev_get_drvdata(dev);
c81cc5a4 GR	304
c9933cb1	305	if (index == 0 && !data->alarm_gpio)
c81cc5a4	306	return 0;
e99c2e5d	307	if (index > 0 && !data->gpios)
c81cc5a4 GR	308	return 0;
	309
	310	return attr->mode;
	311	}
	312
	313	static struct attribute *gpio_fan_attributes[] = {
7258a125 GR	314	&dev_attr_fan1_alarm.attr, /* 0 */
7258a125 GR	315	&dev_attr_pwm1.attr, /* 1 */
d6fe1360 SG	316	&dev_attr_pwm1_enable.attr,
	317	&dev_attr_pwm1_mode.attr,
	318	&dev_attr_fan1_input.attr,
	319	&dev_attr_fan1_target.attr,
	320	&dev_attr_fan1_min.attr,
	321	&dev_attr_fan1_max.attr,
	322	NULL
	323	};
	324
c81cc5a4 GR	325	static const struct attribute_group gpio_fan_group = {
	326	.attrs = gpio_fan_attributes,
	327	.is_visible = gpio_fan_is_visible,
d6fe1360 SG	328	};
d6fe1360 SG	329
7258a125 GR	330	static const struct attribute_group *gpio_fan_groups[] = {
	331	&gpio_fan_group,
	332	NULL
	333	};
	334
b5482f7e	335	static int fan_ctrl_init(struct gpio_fan_data *fan_data)
d6fe1360	336	{
e99c2e5d	337	int num_gpios = fan_data->num_gpios;
9de382fd	338	struct gpio_desc **gpios = fan_data->gpios;
d6fe1360 SG	339	int i, err;
d6fe1360 SG	340
e99c2e5d	341	for (i = 0; i < num_gpios; i++) {
9de382fd LW	342	/*
	343	* The GPIO descriptors were retrieved with GPIOD_ASIS so here
	344	* we set the GPIO into output mode, carefully preserving the
	345	* current value by setting it to whatever it is already set
	346	* (no surprise changes in default fan speed).
	347	*/
	348	err = gpiod_direction_output(gpios[i],
	349	gpiod_get_value_cansleep(gpios[i]));
d00985f3 GR	350	if (err)
d00985f3 GR	351	return err;
d6fe1360 SG	352	}
d6fe1360 SG	353
d6fe1360 SG	354	fan_data->pwm_enable = true; /* Enable manual fan speed control. */
d6fe1360 SG	355	fan_data->speed_index = get_fan_speed_index(fan_data);
d00985f3	356	if (fan_data->speed_index < 0)
c52ae3d2	357	return fan_data->speed_index;
d6fe1360	358
c81cc5a4	359	return 0;
d6fe1360 SG	360	}
d6fe1360 SG	361
b5cf88e4 NM	362	static int gpio_fan_get_max_state(struct thermal_cooling_device *cdev,
	363	unsigned long *state)
	364	{
	365	struct gpio_fan_data *fan_data = cdev->devdata;
	366
	367	if (!fan_data)
	368	return -EINVAL;
	369
	370	*state = fan_data->num_speed - 1;
	371	return 0;
	372	}
	373
	374	static int gpio_fan_get_cur_state(struct thermal_cooling_device *cdev,
	375	unsigned long *state)
	376	{
	377	struct gpio_fan_data *fan_data = cdev->devdata;
b5cf88e4 NM	378
	379	if (!fan_data)
	380	return -EINVAL;
	381
000e0949	382	*state = fan_data->speed_index;
b5cf88e4 NM	383	return 0;
	384	}
	385
	386	static int gpio_fan_set_cur_state(struct thermal_cooling_device *cdev,
	387	unsigned long state)
	388	{
	389	struct gpio_fan_data *fan_data = cdev->devdata;
	390
	391	if (!fan_data)
	392	return -EINVAL;
	393
	394	set_fan_speed(fan_data, state);
	395	return 0;
	396	}
	397
	398	static const struct thermal_cooling_device_ops gpio_fan_cool_ops = {
	399	.get_max_state = gpio_fan_get_max_state,
	400	.get_cur_state = gpio_fan_get_cur_state,
	401	.set_cur_state = gpio_fan_set_cur_state,
	402	};
	403
55fb8b06 JL	404	/*
	405	* Translate OpenFirmware node properties into platform_data
	406	*/
b5482f7e	407	static int gpio_fan_get_of_data(struct gpio_fan_data *fan_data)
55fb8b06	408	{
55fb8b06	409	struct gpio_fan_speed *speed;
b5482f7e LW	410	struct device *dev = fan_data->dev;
b5482f7e LW	411	struct device_node *np = dev->of_node;
9de382fd	412	struct gpio_desc **gpios;
55fb8b06 JL	413	unsigned i;
	414	u32 u;
	415	struct property *prop;
	416	const __be32 *p;
	417
73ef85f4	418	/* Alarm GPIO if one exists */
9de382fd LW	419	fan_data->alarm_gpio = devm_gpiod_get_optional(dev, "alarm", GPIOD_IN);
	420	if (IS_ERR(fan_data->alarm_gpio))
	421	return PTR_ERR(fan_data->alarm_gpio);
73ef85f4	422
55fb8b06	423	/* Fill GPIO pin array */
9de382fd	424	fan_data->num_gpios = gpiod_count(dev, NULL);
e99c2e5d	425	if (fan_data->num_gpios <= 0) {
c9933cb1	426	if (fan_data->alarm_gpio)
73ef85f4 SG	427	return 0;
73ef85f4 SG	428	dev_err(dev, "DT properties empty / missing");
55fb8b06 JL	429	return -ENODEV;
55fb8b06 JL	430	}
a86854d0 KC	431	gpios = devm_kcalloc(dev,
a86854d0 KC	432	fan_data->num_gpios, sizeof(struct gpio_desc *),
9de382fd	433	GFP_KERNEL);
e99c2e5d	434	if (!gpios)
55fb8b06	435	return -ENOMEM;
e99c2e5d	436	for (i = 0; i < fan_data->num_gpios; i++) {
9de382fd LW	437	gpios[i] = devm_gpiod_get_index(dev, NULL, i, GPIOD_ASIS);
	438	if (IS_ERR(gpios[i]))
	439	return PTR_ERR(gpios[i]);
55fb8b06	440	}
e99c2e5d	441	fan_data->gpios = gpios;
55fb8b06 JL	442
55fb8b06 JL	443	/* Get number of RPM/ctrl_val pairs in speed map */
b5482f7e	444	prop = of_find_property(np, "gpio-fan,speed-map", &i);
55fb8b06 JL	445	if (!prop) {
	446	dev_err(dev, "gpio-fan,speed-map DT property missing");
	447	return -ENODEV;
	448	}
	449	i = i / sizeof(u32);
	450	if (i == 0 \|\| i & 1) {
	451	dev_err(dev, "gpio-fan,speed-map contains zero/odd number of entries");
	452	return -ENODEV;
	453	}
b5482f7e	454	fan_data->num_speed = i / 2;
55fb8b06 JL	455
	456	/*
	457	* Populate speed map
	458	* Speed map is in the form <RPM ctrl_val RPM ctrl_val ...>
	459	* this needs splitting into pairs to create gpio_fan_speed structs
	460	*/
a86854d0 KC	461	speed = devm_kcalloc(dev,
a86854d0 KC	462	fan_data->num_speed, sizeof(struct gpio_fan_speed),
55fb8b06 JL	463	GFP_KERNEL);
	464	if (!speed)
	465	return -ENOMEM;
	466	p = NULL;
b5482f7e	467	for (i = 0; i < fan_data->num_speed; i++) {
55fb8b06 JL	468	p = of_prop_next_u32(prop, p, &u);
	469	if (!p)
	470	return -ENODEV;
	471	speed[i].rpm = u;
	472	p = of_prop_next_u32(prop, p, &u);
	473	if (!p)
	474	return -ENODEV;
	475	speed[i].ctrl_val = u;
	476	}
b5482f7e	477	fan_data->speed = speed;
55fb8b06	478
55fb8b06 JL	479	return 0;
	480	}
	481
6de709c5	482	static const struct of_device_id of_gpio_fan_match[] = {
55fb8b06 JL	483	{ .compatible = "gpio-fan", },
	484	{},
	485	};
fe515288	486	MODULE_DEVICE_TABLE(of, of_gpio_fan_match);
55fb8b06	487
95347845 GR	488	static void gpio_fan_stop(void *data)
	489	{
	490	set_fan_speed(data, 0);
	491	}
	492
6c931ae1	493	static int gpio_fan_probe(struct platform_device *pdev)
d6fe1360 SG	494	{
	495	int err;
	496	struct gpio_fan_data *fan_data;
f9013c16 LW	497	struct device *dev = &pdev->dev;
f9013c16 LW	498	struct device_node *np = dev->of_node;
d6fe1360	499
f9013c16	500	fan_data = devm_kzalloc(dev, sizeof(struct gpio_fan_data),
b5cf88e4 NM	501	GFP_KERNEL);
	502	if (!fan_data)
	503	return -ENOMEM;
	504
534e28d8	505	fan_data->dev = dev;
b5482f7e	506	err = gpio_fan_get_of_data(fan_data);
a9b4c8af LW	507	if (err)
a9b4c8af LW	508	return err;
d6fe1360	509
d6fe1360 SG	510	platform_set_drvdata(pdev, fan_data);
	511	mutex_init(&fan_data->lock);
	512
d6fe1360	513	/* Configure control GPIOs if available. */
e99c2e5d	514	if (fan_data->gpios && fan_data->num_gpios > 0) {
b5482f7e	515	if (!fan_data->speed \|\| fan_data->num_speed <= 1)
c81cc5a4	516	return -EINVAL;
b5482f7e	517	err = fan_ctrl_init(fan_data);
d6fe1360	518	if (err)
c81cc5a4	519	return err;
b9bb92e1 GR	520	err = devm_add_action_or_reset(dev, gpio_fan_stop, fan_data);
	521	if (err)
	522	return err;
d6fe1360 SG	523	}
d6fe1360 SG	524
d6fe1360	525	/* Make this driver part of hwmon class. */
49153b09	526	fan_data->hwmon_dev =
f9013c16	527	devm_hwmon_device_register_with_groups(dev,
49153b09 AL	528	"gpio_fan", fan_data,
49153b09 AL	529	gpio_fan_groups);
7258a125 GR	530	if (IS_ERR(fan_data->hwmon_dev))
7258a125 GR	531	return PTR_ERR(fan_data->hwmon_dev);
a9b4c8af	532
f2173fa2 CS	533	/* Configure alarm GPIO if available. */
	534	if (fan_data->alarm_gpio) {
	535	err = fan_alarm_init(fan_data);
	536	if (err)
	537	return err;
	538	}
	539
e76ea261	540	/* Optional cooling device register for Device tree platforms */
95347845 GR	541	fan_data->cdev = devm_thermal_of_cooling_device_register(dev, np,
95347845 GR	542	"gpio-fan", fan_data, &gpio_fan_cool_ops);
d6fe1360	543
f9013c16	544	dev_info(dev, "GPIO fan initialized\n");
d6fe1360 SG	545
d6fe1360 SG	546	return 0;
d6fe1360 SG	547	}
d6fe1360 SG	548
95347845	549	static void gpio_fan_shutdown(struct platform_device *pdev)
b95579cd	550	{
b5cf88e4 NM	551	struct gpio_fan_data *fan_data = platform_get_drvdata(pdev);
b5cf88e4 NM	552
e99c2e5d	553	if (fan_data->gpios)
b95579cd NM	554	set_fan_speed(fan_data, 0);
	555	}
	556
6d20a6c0 RW	557	#ifdef CONFIG_PM_SLEEP
6d20a6c0 RW	558	static int gpio_fan_suspend(struct device *dev)
d6fe1360	559	{
6d20a6c0	560	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
d6fe1360	561
e99c2e5d	562	if (fan_data->gpios) {
d6fe1360 SG	563	fan_data->resume_speed = fan_data->speed_index;
	564	set_fan_speed(fan_data, 0);
	565	}
	566
	567	return 0;
	568	}
	569
6d20a6c0	570	static int gpio_fan_resume(struct device *dev)
d6fe1360	571	{
6d20a6c0	572	struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
d6fe1360	573
e99c2e5d	574	if (fan_data->gpios)
d6fe1360 SG	575	set_fan_speed(fan_data, fan_data->resume_speed);
	576
	577	return 0;
	578	}
6d20a6c0 RW	579
6d20a6c0 RW	580	static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
24f9c539	581	#define GPIO_FAN_PM (&gpio_fan_pm)
d6fe1360	582	#else
6d20a6c0	583	#define GPIO_FAN_PM NULL
d6fe1360 SG	584	#endif
	585
	586	static struct platform_driver gpio_fan_driver = {
	587	.probe = gpio_fan_probe,
b95579cd	588	.shutdown = gpio_fan_shutdown,
d6fe1360 SG	589	.driver = {
d6fe1360 SG	590	.name = "gpio-fan",
6d20a6c0	591	.pm = GPIO_FAN_PM,
55fb8b06	592	.of_match_table = of_match_ptr(of_gpio_fan_match),
d6fe1360 SG	593	},
	594	};
	595
25a236a5	596	module_platform_driver(gpio_fan_driver);
d6fe1360 SG	597
	598	MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
	599	MODULE_DESCRIPTION("GPIO FAN driver");
	600	MODULE_LICENSE("GPL");
	601	MODULE_ALIAS("platform:gpio-fan");