Commit 229c15e9 authored by Mathieu Dubois-Briand's avatar Mathieu Dubois-Briand Committed by Lee Jones
Browse files

input: misc: Add support for MAX7360 rotary 



Add driver for Maxim Integrated MAX7360 rotary encoder controller,
supporting a single rotary switch.

Acked-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: default avatarMathieu Dubois-Briand <mathieu.dubois-briand@bootlin.com>
Link: https://lore.kernel.org/r/20250824-mdb-max7360-support-v14-9-435cfda2b1ea@bootlin.com


Signed-off-by: default avatarLee Jones <lee@kernel.org>
parent fa6a23f1

drivers/input/misc/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -230,6 +230,16 @@ config INPUT_M68K_BEEP 
	tristate "M68k Beeper support"

	depends on M68K



config INPUT_MAX7360_ROTARY

	tristate "Maxim MAX7360 Rotary Encoder"

	depends on MFD_MAX7360

	help

	  If you say yes here you get support for the rotary encoder on the

	  Maxim MAX7360 I/O Expander.



	  To compile this driver as a module, choose M here: the module will be

	  called max7360_rotary.



config INPUT_MAX77650_ONKEY

	tristate "Maxim MAX77650 ONKEY support"

	depends on MFD_MAX77650

drivers/input/misc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ obj-$(CONFIG_INPUT_IQS7222) += iqs7222.o 
obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)	+= keyspan_remote.o

obj-$(CONFIG_INPUT_KXTJ9)		+= kxtj9.o

obj-$(CONFIG_INPUT_M68K_BEEP)		+= m68kspkr.o

obj-$(CONFIG_INPUT_MAX7360_ROTARY)	+= max7360-rotary.o

obj-$(CONFIG_INPUT_MAX77650_ONKEY)	+= max77650-onkey.o

obj-$(CONFIG_INPUT_MAX77693_HAPTIC)	+= max77693-haptic.o

obj-$(CONFIG_INPUT_MAX8925_ONKEY)	+= max8925_onkey.o

drivers/input/misc/max7360-rotary.c

0 → 100644
+192 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright 2025 Bootlin

 *

 * Author: Mathieu Dubois-Briand <mathieu.dubois-briand@bootlin.com>

 */



#include <linux/bitfield.h>

#include <linux/device/devres.h>

#include <linux/dev_printk.h>

#include <linux/init.h>

#include <linux/input.h>

#include <linux/interrupt.h>

#include <linux/mfd/max7360.h>

#include <linux/property.h>

#include <linux/platform_device.h>

#include <linux/pm_wakeirq.h>

#include <linux/regmap.h>

#include <linux/types.h>



#define MAX7360_ROTARY_DEFAULT_STEPS 24



struct max7360_rotary {

	struct input_dev *input;

	struct regmap *regmap;

	unsigned int debounce_ms;



	unsigned int pos;



	u32 steps;

	u32 axis;

	bool relative_axis;

	bool rollover;

};



static void max7360_rotary_report_event(struct max7360_rotary *max7360_rotary, int steps)

{

	if (max7360_rotary->relative_axis) {

		input_report_rel(max7360_rotary->input, max7360_rotary->axis, steps);

	} else {

		int pos = max7360_rotary->pos;

		int maxval = max7360_rotary->steps;



		/*

		 * Add steps to the position.

		 * Make sure added steps are always in ]-maxval; maxval[

		 * interval, so (pos + maxval) is always >= 0.

		 * Then set back pos to the [0; maxval[ interval.

		 */

		pos += steps % maxval;

		if (max7360_rotary->rollover)

			pos = (pos + maxval) % maxval;

		else

			pos = clamp(pos, 0, maxval - 1);



		max7360_rotary->pos = pos;

		input_report_abs(max7360_rotary->input, max7360_rotary->axis, max7360_rotary->pos);

	}



	input_sync(max7360_rotary->input);

}



static irqreturn_t max7360_rotary_irq(int irq, void *data)

{

	struct max7360_rotary *max7360_rotary = data;

	struct device *dev = max7360_rotary->input->dev.parent;

	unsigned int val;

	int error;



	error = regmap_read(max7360_rotary->regmap, MAX7360_REG_RTR_CNT, &val);

	if (error < 0) {

		dev_err(dev, "Failed to read rotary counter\n");

		return IRQ_NONE;

	}



	if (val == 0)

		return IRQ_NONE;



	max7360_rotary_report_event(max7360_rotary, sign_extend32(val, 7));



	return IRQ_HANDLED;

}



static int max7360_rotary_hw_init(struct max7360_rotary *max7360_rotary)

{

	struct device *dev = max7360_rotary->input->dev.parent;

	int val;

	int error;



	val = FIELD_PREP(MAX7360_ROT_DEBOUNCE, max7360_rotary->debounce_ms) |

	      FIELD_PREP(MAX7360_ROT_INTCNT, 1) | MAX7360_ROT_INTCNT_DLY;

	error = regmap_write(max7360_rotary->regmap, MAX7360_REG_RTRCFG, val);

	if (error)

		dev_err(dev, "Failed to set max7360 rotary encoder configuration\n");



	return error;

}



static int max7360_rotary_probe(struct platform_device *pdev)

{

	struct max7360_rotary *max7360_rotary;

	struct device *dev = &pdev->dev;

	struct input_dev *input;

	struct regmap *regmap;

	int irq;

	int error;



	regmap = dev_get_regmap(dev->parent, NULL);

	if (!regmap)

		return dev_err_probe(dev, -ENODEV, "Could not get parent regmap\n");



	irq = fwnode_irq_get_byname(dev_fwnode(dev->parent), "inti");

	if (irq < 0)

		return dev_err_probe(dev, irq, "Failed to get IRQ\n");



	max7360_rotary = devm_kzalloc(dev, sizeof(*max7360_rotary), GFP_KERNEL);

	if (!max7360_rotary)

		return -ENOMEM;



	max7360_rotary->regmap = regmap;



	device_property_read_u32(dev->parent, "linux,axis", &max7360_rotary->axis);

	max7360_rotary->rollover = device_property_read_bool(dev->parent,

							     "rotary-encoder,rollover");

	max7360_rotary->relative_axis =

		device_property_read_bool(dev->parent, "rotary-encoder,relative-axis");



	error = device_property_read_u32(dev->parent, "rotary-encoder,steps",

					 &max7360_rotary->steps);

	if (error)

		max7360_rotary->steps = MAX7360_ROTARY_DEFAULT_STEPS;



	device_property_read_u32(dev->parent, "rotary-debounce-delay-ms",

				 &max7360_rotary->debounce_ms);

	if (max7360_rotary->debounce_ms > MAX7360_ROT_DEBOUNCE_MAX)

		return dev_err_probe(dev, -EINVAL, "Invalid debounce timing: %u\n",

				     max7360_rotary->debounce_ms);



	input = devm_input_allocate_device(dev);

	if (!input)

		return -ENOMEM;



	max7360_rotary->input = input;



	input->id.bustype = BUS_I2C;

	input->name = pdev->name;



	if (max7360_rotary->relative_axis)

		input_set_capability(input, EV_REL, max7360_rotary->axis);

	else

		input_set_abs_params(input, max7360_rotary->axis, 0, max7360_rotary->steps, 0, 1);



	error = devm_request_threaded_irq(dev, irq, NULL, max7360_rotary_irq,

					  IRQF_ONESHOT | IRQF_SHARED,

					  "max7360-rotary", max7360_rotary);

	if (error)

		return dev_err_probe(dev, error, "Failed to register interrupt\n");



	error = input_register_device(input);

	if (error)

		return dev_err_probe(dev, error, "Could not register input device\n");



	error = max7360_rotary_hw_init(max7360_rotary);

	if (error)

		return dev_err_probe(dev, error, "Failed to initialize max7360 rotary\n");



	device_init_wakeup(dev, true);

	error = dev_pm_set_wake_irq(dev, irq);

	if (error)

		dev_warn(dev, "Failed to set up wakeup irq: %d\n", error);



	return 0;

}



static void max7360_rotary_remove(struct platform_device *pdev)

{

	dev_pm_clear_wake_irq(&pdev->dev);

	device_init_wakeup(&pdev->dev, false);

}



static struct platform_driver max7360_rotary_driver = {

	.driver = {

		.name	= "max7360-rotary",

	},

	.probe		= max7360_rotary_probe,

	.remove		= max7360_rotary_remove,

};

module_platform_driver(max7360_rotary_driver);



MODULE_DESCRIPTION("MAX7360 Rotary driver");

MODULE_AUTHOR("Mathieu Dubois-Briand <mathieu.dubois-briand@bootlin.com>");

MODULE_LICENSE("GPL");