Commit 72d1f234 authored by Jaechul Lee's avatar Jaechul Lee Committed by Dmitry Torokhov
Browse files

Input: tm2-touchkey - add touchkey driver support for TM2 



This patch adds support for the TM2 touch key and led functionality.

The driver interfaces with userspace through an input device and reports
KEY_PHONE and KEY_BACK event types. LED brightness can be controlled by
"/sys/class/leds/tm2-touchkey/brightness".

Signed-off-by: default avatarBeomho Seo <beomho.seo@samsung.com>
Signed-off-by: default avatarJaechul Lee <jcsing.lee@samsung.com>
Reviewed-by: default avatarJavier Martinez Canillas <javier@osg.samsung.com>
Reviewed-by: default avatarAndi Shyti <andi.shyti@samsung.com>
Reviewed-by: default avatarChanwoo Choi <cw00.choi@samsung.com>
Tested-by: default avatarChanwoo Choi <cw00.choi@samsung.com>
Acked-by: default avatarKrzysztof Kozlowski <krzk@kernel.org>
Acked-by: default avatarRob Herring <robh@kernel.org>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent aa6f9222

Documentation/devicetree/bindings/input/cypress,tm2-touchkey.txt

0 → 100644
+27 −0
Original line number Diff line number Diff line 
Samsung tm2-touchkey



Required properties:

- compatible: must be "cypress,tm2-touchkey"

- reg: I2C address of the chip.

- interrupt-parent: a phandle for the interrupt controller (see interrupt

	binding[0]).

- interrupts: interrupt to which the chip is connected (see interrupt

	binding[0]).

- vcc-supply : internal regulator output. 1.8V

- vdd-supply : power supply for IC 3.3V



[0]: Documentation/devicetree/bindings/interrupt-controller/interrupts.txt



Example:

	&i2c0 {

		/* ... */



		touchkey@20 {

			compatible = "cypress,tm2-touchkey";

			reg = <0x20>;

			interrupt-parent = <&gpa3>;

			interrupts = <2 IRQ_TYPE_EDGE_FALLING>;

			vcc-supply=<&ldo32_reg>;

			vdd-supply=<&ldo33_reg>;

		};

	};

drivers/input/keyboard/Kconfig

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

	  module will be called tc3589x-keypad.



config KEYBOARD_TM2_TOUCHKEY

	tristate "TM2 touchkey support"

	depends on I2C

	depends on LEDS_CLASS

	help

	  Say Y here to enable device driver for tm2-touchkey with

	  LED control for the Exynos5433 TM2 board.



	  To compile this driver as a module, choose M here.

	  module will be called tm2-touchkey.



config KEYBOARD_TWL4030

	tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"

	depends on TWL4030_CORE

drivers/input/keyboard/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ obj-$(CONFIG_KEYBOARD_SUN4I_LRADC) += sun4i-lradc-keys.o 
obj-$(CONFIG_KEYBOARD_SUNKBD)		+= sunkbd.o

obj-$(CONFIG_KEYBOARD_TC3589X)		+= tc3589x-keypad.o

obj-$(CONFIG_KEYBOARD_TEGRA)		+= tegra-kbc.o

obj-$(CONFIG_KEYBOARD_TM2_TOUCHKEY)	+= tm2-touchkey.o

obj-$(CONFIG_KEYBOARD_TWL4030)		+= twl4030_keypad.o

obj-$(CONFIG_KEYBOARD_XTKBD)		+= xtkbd.o

obj-$(CONFIG_KEYBOARD_W90P910)		+= w90p910_keypad.o

drivers/input/keyboard/tm2-touchkey.c

0 → 100644
+286 −0
Original line number Diff line number Diff line 
/*

 * TM2 touchkey device driver

 *

 * Copyright 2005 Phil Blundell

 * Copyright 2016 Samsung Electronics Co., Ltd.

 *

 * Author: Beomho Seo <beomho.seo@samsung.com>

 * Author: Jaechul Lee <jcsing.lee@samsung.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/bitops.h>

#include <linux/delay.h>

#include <linux/device.h>

#include <linux/i2c.h>

#include <linux/input.h>

#include <linux/interrupt.h>

#include <linux/irq.h>

#include <linux/leds.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/pm.h>

#include <linux/regulator/consumer.h>



#define TM2_TOUCHKEY_DEV_NAME		"tm2-touchkey"

#define TM2_TOUCHKEY_KEYCODE_REG	0x03

#define TM2_TOUCHKEY_BASE_REG		0x00

#define TM2_TOUCHKEY_CMD_LED_ON		0x10

#define TM2_TOUCHKEY_CMD_LED_OFF	0x20

#define TM2_TOUCHKEY_BIT_PRESS_EV	BIT(3)

#define TM2_TOUCHKEY_BIT_KEYCODE	GENMASK(2, 0)

#define TM2_TOUCHKEY_LED_VOLTAGE_MIN	2500000

#define TM2_TOUCHKEY_LED_VOLTAGE_MAX	3300000



enum {

	TM2_TOUCHKEY_KEY_MENU = 0x1,

	TM2_TOUCHKEY_KEY_BACK,

};



struct tm2_touchkey_data {

	struct i2c_client *client;

	struct input_dev *input_dev;

	struct led_classdev led_dev;

	struct regulator *vdd;

	struct regulator_bulk_data regulators[2];

};



static void tm2_touchkey_led_brightness_set(struct led_classdev *led_dev,

					    enum led_brightness brightness)

{

	struct tm2_touchkey_data *touchkey =

		container_of(led_dev, struct tm2_touchkey_data, led_dev);

	u32 volt;

	u8 data;



	if (brightness == LED_OFF) {

		volt = TM2_TOUCHKEY_LED_VOLTAGE_MIN;

		data = TM2_TOUCHKEY_CMD_LED_OFF;

	} else {

		volt = TM2_TOUCHKEY_LED_VOLTAGE_MAX;

		data = TM2_TOUCHKEY_CMD_LED_ON;

	}



	regulator_set_voltage(touchkey->vdd, volt, volt);

	i2c_smbus_write_byte_data(touchkey->client,

				  TM2_TOUCHKEY_BASE_REG, data);

}



static int tm2_touchkey_power_enable(struct tm2_touchkey_data *touchkey)

{

	int error;



	error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators),

				      touchkey->regulators);

	if (error)

		return error;



	/* waiting for device initialization, at least 150ms */

	msleep(150);



	return 0;

}



static void tm2_touchkey_power_disable(void *data)

{

	struct tm2_touchkey_data *touchkey = data;



	regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators),

			       touchkey->regulators);

}



static irqreturn_t tm2_touchkey_irq_handler(int irq, void *devid)

{

	struct tm2_touchkey_data *touchkey = devid;

	int data;

	int key;



	data = i2c_smbus_read_byte_data(touchkey->client,

					TM2_TOUCHKEY_KEYCODE_REG);

	if (data < 0) {

		dev_err(&touchkey->client->dev,

			"failed to read i2c data: %d\n", data);

		goto out;

	}



	switch (data & TM2_TOUCHKEY_BIT_KEYCODE) {

	case TM2_TOUCHKEY_KEY_MENU:

		key = KEY_PHONE;

		break;



	case TM2_TOUCHKEY_KEY_BACK:

		key = KEY_BACK;

		break;



	default:

		dev_warn(&touchkey->client->dev,

			 "unhandled keycode, data %#02x\n", data);

		goto out;

	}



	if (data & TM2_TOUCHKEY_BIT_PRESS_EV) {

		input_report_key(touchkey->input_dev, KEY_PHONE, 0);

		input_report_key(touchkey->input_dev, KEY_BACK, 0);

	} else {

		input_report_key(touchkey->input_dev, key, 1);

	}



	input_sync(touchkey->input_dev);



out:

	return IRQ_HANDLED;

}



static int tm2_touchkey_probe(struct i2c_client *client,

			      const struct i2c_device_id *id)

{

	struct tm2_touchkey_data *touchkey;

	int error;



	if (!i2c_check_functionality(client->adapter,

			I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA)) {

		dev_err(&client->dev, "incompatible I2C adapter\n");

		return -EIO;

	}



	touchkey = devm_kzalloc(&client->dev, sizeof(*touchkey), GFP_KERNEL);

	if (!touchkey)

		return -ENOMEM;



	touchkey->client = client;

	i2c_set_clientdata(client, touchkey);



	touchkey->regulators[0].supply = "vcc";

	touchkey->regulators[1].supply = "vdd";

	error = devm_regulator_bulk_get(&client->dev,

					ARRAY_SIZE(touchkey->regulators),

					touchkey->regulators);

	if (error) {

		dev_err(&client->dev, "failed to get regulators: %d\n", error);

		return error;

	}



	/* Save VDD for easy access */

	touchkey->vdd = touchkey->regulators[1].consumer;



	error = tm2_touchkey_power_enable(touchkey);

	if (error) {

		dev_err(&client->dev, "failed to power up device: %d\n", error);

		return error;

	}



	error = devm_add_action_or_reset(&client->dev,

					 tm2_touchkey_power_disable, touchkey);

	if (error) {

		dev_err(&client->dev,

			"failed to install poweroff handler: %d\n", error);

		return error;

	}



	/* input device */

	touchkey->input_dev = devm_input_allocate_device(&client->dev);

	if (!touchkey->input_dev) {

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

		return -ENOMEM;

	}



	touchkey->input_dev->name = TM2_TOUCHKEY_DEV_NAME;

	touchkey->input_dev->id.bustype = BUS_I2C;



	input_set_capability(touchkey->input_dev, EV_KEY, KEY_PHONE);

	input_set_capability(touchkey->input_dev, EV_KEY, KEY_BACK);



	input_set_drvdata(touchkey->input_dev, touchkey);



	error = input_register_device(touchkey->input_dev);

	if (error) {

		dev_err(&client->dev,

			"failed to register input device: %d\n", error);

		return error;

	}



	error = devm_request_threaded_irq(&client->dev, client->irq,

					  NULL, tm2_touchkey_irq_handler,

					  IRQF_ONESHOT,

					  TM2_TOUCHKEY_DEV_NAME, touchkey);

	if (error) {

		dev_err(&client->dev,

			"failed to request threaded irq: %d\n", error);

		return error;

	}



	/* led device */

	touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME;

	touchkey->led_dev.brightness = LED_FULL;

	touchkey->led_dev.max_brightness = LED_FULL;

	touchkey->led_dev.brightness_set = tm2_touchkey_led_brightness_set;



	error = devm_led_classdev_register(&client->dev, &touchkey->led_dev);

	if (error) {

		dev_err(&client->dev,

			"failed to register touchkey led: %d\n", error);

		return error;

	}



	return 0;

}



static int __maybe_unused tm2_touchkey_suspend(struct device *dev)

{

	struct i2c_client *client = to_i2c_client(dev);

	struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);



	disable_irq(client->irq);

	tm2_touchkey_power_disable(touchkey);



	return 0;

}



static int __maybe_unused tm2_touchkey_resume(struct device *dev)

{

	struct i2c_client *client = to_i2c_client(dev);

	struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);

	int ret;



	enable_irq(client->irq);



	ret = tm2_touchkey_power_enable(touchkey);

	if (ret)

		dev_err(dev, "failed to enable power: %d\n", ret);



	return ret;

}



static SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops,

			 tm2_touchkey_suspend, tm2_touchkey_resume);



static const struct i2c_device_id tm2_touchkey_id_table[] = {

	{ TM2_TOUCHKEY_DEV_NAME, 0 },

	{ },

};

MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table);



static const struct of_device_id tm2_touchkey_of_match[] = {

	{ .compatible = "cypress,tm2-touchkey", },

	{ },

};

MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match);



static struct i2c_driver tm2_touchkey_driver = {

	.driver = {

		.name = TM2_TOUCHKEY_DEV_NAME,

		.pm = &tm2_touchkey_pm_ops,

		.of_match_table = of_match_ptr(tm2_touchkey_of_match),

	},

	.probe = tm2_touchkey_probe,

	.id_table = tm2_touchkey_id_table,

};

module_i2c_driver(tm2_touchkey_driver);



MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");

MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>");

MODULE_DESCRIPTION("Samsung touchkey driver");

MODULE_LICENSE("GPL v2");

CRA Git | Maintained and supported by SUSTech CRA and CCSE