Commit 40e40fdf authored by Jacky Bai's avatar Jacky Bai Committed by Dmitry Torokhov
Browse files

Input: bbnsm_pwrkey - add bbnsm power key support 



The ON/OFF logic inside the BBNSM allows for connecting directly
into a PMIC or other voltage regulator device. The module has an
button input signal and a wakeup request input signal. It also
has two interrupts (set_pwr_off_irq and set_pwr_on_irq) and an
active-low PMIC enable (pmic_en_b) output.

Add the power key support for the ON/OFF button function found in
BBNSM module.

Signed-off-by: default avatarJacky Bai <ping.bai@nxp.com>
Reviewed-by: default avatarPeng Fan <peng.fan@nxp.com>
Link: https://lore.kernel.org/r/20230215024117.3357341-2-ping.bai@nxp.com


Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent 9e69e845

drivers/input/misc/Kconfig

+11 −0
Original line number Original line Diff line number Diff line
@@ -119,6 +119,17 @@ config INPUT_ATMEL_CAPTOUCH 
	  To compile this driver as a module, choose M here: the

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

	  module will be called atmel_captouch.

	  module will be called atmel_captouch.





config INPUT_BBNSM_PWRKEY

	tristate "NXP BBNSM Power Key Driver"

	depends on ARCH_MXC || COMPILE_TEST

	depends on OF

	help

	  This is the bbnsm powerkey driver for the NXP i.MX application

	  processors.



	  To compile this driver as a module, choose M here; the

	  module will be called bbnsm_pwrkey.



config INPUT_BMA150

config INPUT_BMA150

	tristate "BMA150/SMB380 acceleration sensor support"

	tristate "BMA150/SMB380 acceleration sensor support"

	depends on I2C

	depends on I2C

drivers/input/misc/Makefile

+1 −0
Original line number Original line Diff line number Diff line
@@ -21,6 +21,7 @@ obj-$(CONFIG_INPUT_ATC260X_ONKEY) += atc260x-onkey.o 
obj-$(CONFIG_INPUT_ATI_REMOTE2)		+= ati_remote2.o

obj-$(CONFIG_INPUT_ATI_REMOTE2)		+= ati_remote2.o

obj-$(CONFIG_INPUT_ATLAS_BTNS)		+= atlas_btns.o

obj-$(CONFIG_INPUT_ATLAS_BTNS)		+= atlas_btns.o

obj-$(CONFIG_INPUT_ATMEL_CAPTOUCH)	+= atmel_captouch.o

obj-$(CONFIG_INPUT_ATMEL_CAPTOUCH)	+= atmel_captouch.o

obj-$(CONFIG_INPUT_BBNSM_PWRKEY)	+= nxp-bbnsm-pwrkey.o

obj-$(CONFIG_INPUT_BMA150)		+= bma150.o

obj-$(CONFIG_INPUT_BMA150)		+= bma150.o

obj-$(CONFIG_INPUT_CM109)		+= cm109.o

obj-$(CONFIG_INPUT_CM109)		+= cm109.o

obj-$(CONFIG_INPUT_CMA3000)		+= cma3000_d0x.o

obj-$(CONFIG_INPUT_CMA3000)		+= cma3000_d0x.o

drivers/input/misc/nxp-bbnsm-pwrkey.c

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

//

// Copyright 2022 NXP.



#include <linux/device.h>

#include <linux/err.h>

#include <linux/init.h>

#include <linux/input.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/jiffies.h>

#include <linux/kernel.h>

#include <linux/mfd/syscon.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/platform_device.h>

#include <linux/pm_wakeirq.h>

#include <linux/regmap.h>



#define BBNSM_CTRL		0x8

#define BBNSM_INT_EN		0x10

#define BBNSM_EVENTS		0x14

#define BBNSM_PAD_CTRL		0x24



#define BBNSM_BTN_PRESSED	BIT(7)

#define BBNSM_PWR_ON		BIT(6)

#define BBNSM_BTN_OFF		BIT(5)

#define BBNSM_EMG_OFF		BIT(4)

#define BBNSM_PWRKEY_EVENTS	(BBNSM_PWR_ON | BBNSM_BTN_OFF | BBNSM_EMG_OFF)

#define BBNSM_DP_EN		BIT(24)



#define DEBOUNCE_TIME		30

#define REPEAT_INTERVAL		60



struct bbnsm_pwrkey {

	struct regmap *regmap;

	int irq;

	int keycode;

	int keystate;  /* 1:pressed */

	struct timer_list check_timer;

	struct input_dev *input;

};



static void bbnsm_pwrkey_check_for_events(struct timer_list *t)

{

	struct bbnsm_pwrkey *bbnsm = from_timer(bbnsm, t, check_timer);

	struct input_dev *input = bbnsm->input;

	u32 state;



	regmap_read(bbnsm->regmap, BBNSM_EVENTS, &state);



	state = state & BBNSM_BTN_PRESSED ? 1 : 0;



	/* only report new event if status changed */

	if (state ^ bbnsm->keystate) {

		bbnsm->keystate = state;

		input_event(input, EV_KEY, bbnsm->keycode, state);

		input_sync(input);

		pm_relax(bbnsm->input->dev.parent);

	}



	/* repeat check if pressed long */

	if (state)

		mod_timer(&bbnsm->check_timer,

			  jiffies + msecs_to_jiffies(REPEAT_INTERVAL));

}



static irqreturn_t bbnsm_pwrkey_interrupt(int irq, void *dev_id)

{

	struct platform_device *pdev = dev_id;

	struct bbnsm_pwrkey *bbnsm = platform_get_drvdata(pdev);

	u32 event;



	regmap_read(bbnsm->regmap, BBNSM_EVENTS, &event);

	if (!(event & BBNSM_BTN_OFF))

		return IRQ_NONE;



	pm_wakeup_event(bbnsm->input->dev.parent, 0);



	mod_timer(&bbnsm->check_timer,

		   jiffies + msecs_to_jiffies(DEBOUNCE_TIME));



	/* clear PWR OFF */

	regmap_write(bbnsm->regmap, BBNSM_EVENTS, BBNSM_BTN_OFF);



	return IRQ_HANDLED;

}



static void bbnsm_pwrkey_act(void *pdata)

{

	struct bbnsm_pwrkey *bbnsm = pdata;



	timer_shutdown_sync(&bbnsm->check_timer);

}



static int bbnsm_pwrkey_probe(struct platform_device *pdev)

{

	struct bbnsm_pwrkey *bbnsm;

	struct input_dev *input;

	struct device_node *np = pdev->dev.of_node;

	int error;



	bbnsm = devm_kzalloc(&pdev->dev, sizeof(*bbnsm), GFP_KERNEL);

	if (!bbnsm)

		return -ENOMEM;



	bbnsm->regmap = syscon_node_to_regmap(np->parent);

	if (IS_ERR(bbnsm->regmap)) {

		dev_err(&pdev->dev, "bbnsm pwerkey get regmap failed\n");

		return PTR_ERR(bbnsm->regmap);

	}



	if (device_property_read_u32(&pdev->dev, "linux,code",

				     &bbnsm->keycode)) {

		bbnsm->keycode = KEY_POWER;

		dev_warn(&pdev->dev, "key code is not specified, using default KEY_POWER\n");

	}



	bbnsm->irq = platform_get_irq(pdev, 0);

	if (bbnsm->irq < 0)

		return -EINVAL;



	/* config the BBNSM power related register */

	regmap_update_bits(bbnsm->regmap, BBNSM_CTRL, BBNSM_DP_EN, BBNSM_DP_EN);



	/* clear the unexpected interrupt before driver ready */

	regmap_write_bits(bbnsm->regmap, BBNSM_EVENTS, BBNSM_PWRKEY_EVENTS,

			  BBNSM_PWRKEY_EVENTS);



	timer_setup(&bbnsm->check_timer, bbnsm_pwrkey_check_for_events, 0);



	input = devm_input_allocate_device(&pdev->dev);

	if (!input) {

		dev_err(&pdev->dev, "failed to allocate the input device\n");

		return -ENOMEM;

	}



	input->name = pdev->name;

	input->phys = "bbnsm-pwrkey/input0";

	input->id.bustype = BUS_HOST;



	input_set_capability(input, EV_KEY, bbnsm->keycode);



	/* input customer action to cancel release timer */

	error = devm_add_action(&pdev->dev, bbnsm_pwrkey_act, bbnsm);

	if (error) {

		dev_err(&pdev->dev, "failed to register remove action\n");

		return error;

	}



	bbnsm->input = input;

	platform_set_drvdata(pdev, bbnsm);



	error = devm_request_irq(&pdev->dev, bbnsm->irq, bbnsm_pwrkey_interrupt,

				 IRQF_SHARED, pdev->name, pdev);

	if (error) {

		dev_err(&pdev->dev, "interrupt not available.\n");

		return error;

	}



	error = input_register_device(input);

	if (error) {

		dev_err(&pdev->dev, "failed to register input device\n");

		return error;

	}



	device_init_wakeup(&pdev->dev, true);

	error = dev_pm_set_wake_irq(&pdev->dev, bbnsm->irq);

	if (error)

		dev_warn(&pdev->dev, "irq wake enable failed.\n");



	return 0;

}



static const struct of_device_id bbnsm_pwrkey_ids[] = {

	{ .compatible = "nxp,imx93-bbnsm-pwrkey" },

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, bbnsm_pwrkey_ids);



static struct platform_driver bbnsm_pwrkey_driver = {

	.driver = {

		.name = "bbnsm_pwrkey",

		.of_match_table = bbnsm_pwrkey_ids,

	},

	.probe = bbnsm_pwrkey_probe,

};

module_platform_driver(bbnsm_pwrkey_driver);



MODULE_AUTHOR("Jacky Bai <ping.bai@nxp.com>");

MODULE_DESCRIPTION("NXP bbnsm power key Driver");

MODULE_LICENSE("GPL");