android13/u-boot/drivers/input/key-uclass.c

/*
 * (C) Copyright 2017 Rockchip Electronics Co., Ltd
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <adc.h>
#include <div64.h>
#include <dm.h>
#include <irq-generic.h>
#include <key.h>
#include <dm/lists.h>
#include <dm/uclass-internal.h>

#define KEY_WARN(fmt, args...)	printf("Key Warn: "fmt, ##args)
#define KEY_ERR(fmt, args...)	printf("Key Error: "fmt, ##args)
#define KEY_DBG(fmt, args...)	 debug("Key Debug: "fmt, ##args)

static inline uint64_t arch_counter_get_cntpct(void)
{
	uint64_t cval = 0;

	isb();
#ifdef CONFIG_ARM64
	asm volatile("mrs %0, cntpct_el0" : "=r" (cval));
#else
	asm volatile("mrrc p15, 0, %Q0, %R0, c14" : "=r" (cval));
#endif
	return cval;
}

uint64_t key_timer(uint64_t base)
{
	uint64_t cntpct;

	cntpct = arch_counter_get_cntpct() / 24000UL;
	return (cntpct > base) ? (cntpct - base) : 0;
}

#ifdef CONFIG_ADC
static int adc_raw_to_mV(struct udevice *dev, unsigned int raw, int *mV)
{
	unsigned int data_mask;
	int ret, vref = 1800000;
	u64 raw64 = raw;

	ret = adc_data_mask(dev, &data_mask);
	if (ret)
		return ret;

	raw64 *= vref;
	do_div(raw64, data_mask);
	*mV = raw64;

	return 0;
}

static int key_adc_event(struct udevice *dev,
			 struct dm_key_uclass_platdata *uc_key, int adcval)
{
	int val = adcval;

	if (uc_key->in_volt) {
		if (adc_raw_to_mV(dev, adcval, &val))
			return KEY_PRESS_NONE;
	}

	debug("[%s] <%d, %d, %d>: adcval=%d -> mV=%d\n",
	      uc_key->name, uc_key->min, uc_key->center, uc_key->max,
	      adcval, val);

	return (val <= uc_key->max && val >= uc_key->min) ?
		KEY_PRESS_DOWN : KEY_PRESS_NONE;
}
#endif

static int key_gpio_event(struct dm_key_uclass_platdata *uc_key)
{
	if (!dm_gpio_is_valid(&uc_key->gpio)) {
		KEY_ERR("'%s' Invalid gpio\n", uc_key->name);
		return KEY_PRESS_NONE;
	}

	return dm_gpio_get_value(&uc_key->gpio) ?
	       KEY_PRESS_DOWN : KEY_PRESS_NONE;
}

static int key_gpio_interrupt_event(struct dm_key_uclass_platdata *uc_key)
{
	int event;

	debug("%s: %s: up=%llu, down=%llu, delta=%llu\n",
	      __func__, uc_key->name, uc_key->rise_ms, uc_key->fall_ms,
	      uc_key->rise_ms - uc_key->fall_ms);

	/* Possible this is machine power-on long pressed, so ignore this */
	if (uc_key->fall_ms == 0 && uc_key->rise_ms != 0) {
		event = KEY_PRESS_NONE;
		goto out;
	}

	if ((uc_key->rise_ms > uc_key->fall_ms) &&
	    (uc_key->rise_ms - uc_key->fall_ms) >= KEY_LONG_DOWN_MS) {
		uc_key->rise_ms = 0;
		uc_key->fall_ms = 0;
		event = KEY_PRESS_LONG_DOWN;
		KEY_DBG("%s key long pressed..\n", uc_key->name);
	} else if (uc_key->fall_ms &&
		   key_timer(uc_key->fall_ms) >= KEY_LONG_DOWN_MS) {
		uc_key->rise_ms = 0;
		uc_key->fall_ms = 0;
		event = KEY_PRESS_LONG_DOWN;
		KEY_DBG("%s key long pressed(hold)..\n", uc_key->name);
	} else if ((uc_key->rise_ms > uc_key->fall_ms) &&
		   (uc_key->rise_ms - uc_key->fall_ms) < KEY_LONG_DOWN_MS) {
		uc_key->rise_ms = 0;
		uc_key->fall_ms = 0;
		event = KEY_PRESS_DOWN;
		KEY_DBG("%s key short pressed..\n", uc_key->name);
	/* Possible in charge animation, we enable irq after fuel gauge updated */
	} else if (uc_key->rise_ms && uc_key->fall_ms &&
		   (uc_key->rise_ms == uc_key->fall_ms)) {
		uc_key->rise_ms = 0;
		uc_key->fall_ms = 0;
		event = KEY_PRESS_DOWN;
		KEY_DBG("%s key short pressed..\n", uc_key->name);
	} else {
		event = KEY_PRESS_NONE;
	}

out:
	return event;
}

int key_is_pressed(int event)
{
	return (event == KEY_PRESS_DOWN || event == KEY_PRESS_LONG_DOWN);
}

static int key_core_read(struct dm_key_uclass_platdata *uc_key)
{
	if (uc_key->type == ADC_KEY) {
#ifdef CONFIG_ADC
		struct udevice *dev;
		unsigned int adcval;
		int ret;

		ret = uclass_get_device_by_name(UCLASS_ADC, "saradc", &dev);
		if (ret) {
			KEY_ERR("%s: No saradc\n", uc_key->name);
			return KEY_NOT_EXIST;
		}

		ret = adc_start_channel(dev, uc_key->channel);
		if (ret) {
			KEY_ERR("%s: Failed to start saradc\n", uc_key->name);
			return KEY_NOT_EXIST;
		}

		ret = adc_channel_data(dev, uc_key->channel, &adcval);
		if (ret) {
			KEY_ERR("%s: Failed to read saradc, %d\n", uc_key->name, ret);
			return KEY_NOT_EXIST;
		}

		return key_adc_event(dev, uc_key, adcval);
#else
		return KEY_NOT_EXIST;
#endif
	}

	return (uc_key->code == KEY_POWER) ?
		key_gpio_interrupt_event(uc_key) :
		key_gpio_event(uc_key);
}

int key_read(int code)
{
	struct dm_key_uclass_platdata *uc_key;
	struct udevice *dev;
	struct uclass *uc;
	bool allow_pre_reloc = false;
	int ret, event = KEY_NOT_EXIST;

	ret = uclass_get(UCLASS_KEY, &uc);
	if (ret)
		return ret;

try_again:
	for (uclass_first_device(UCLASS_KEY, &dev);
	     dev;
	     uclass_next_device(&dev)) {
		uc_key = dev_get_uclass_platdata(dev);

		if (!allow_pre_reloc && uc_key->pre_reloc)
			continue;

		if (uc_key->code != code)
			continue;

		event = key_core_read(uc_key);
		if (key_is_pressed(event))
			return event;
	}

	/* If not find valid key node from kernel, try from u-boot */
	if (event == KEY_NOT_EXIST && !allow_pre_reloc) {
		allow_pre_reloc = true;
		goto try_again;
	}

	return event;
}

int key_exist(int code)
{
	struct dm_key_uclass_platdata *uc_key;
	struct udevice *dev;

	for (uclass_find_first_device(UCLASS_KEY, &dev);
	     dev;
	     uclass_find_next_device(&dev)) {
		uc_key = dev_get_uclass_platdata(dev);

		if (uc_key->code == code)
			return 1;
	}

	return 0;
}

#if CONFIG_IS_ENABLED(IRQ)
#if defined(CONFIG_PWRKEY_DNL_TRIGGER_NUM) && \
		(CONFIG_PWRKEY_DNL_TRIGGER_NUM > 0)
static void power_key_download(struct dm_key_uclass_platdata *uc_key)
{
	int trig_cnt = CONFIG_PWRKEY_DNL_TRIGGER_NUM;
	static u64 old_rise_ms;

	if (uc_key->code == KEY_POWER && old_rise_ms != uc_key->rise_ms) {
		old_rise_ms = uc_key->rise_ms;
		uc_key->trig_cnt++;
		if (uc_key->trig_cnt >= trig_cnt) {
			printf("\nEnter download mode by pwrkey\n");
			irq_handler_disable(uc_key->irq);
			run_command("download", 0);
		}
	}
}

int pwrkey_download_init(void)
{
	return (KEY_NOT_EXIST == key_read(KEY_POWER));
}
#endif

static void gpio_irq_handler(int irq, void *data)
{
	struct udevice *dev = data;
	struct dm_key_uclass_platdata *uc_key = dev_get_uclass_platdata(dev);

	if (uc_key->irq != irq)
		return;

	if (uc_key->irq_thread) {
		uc_key->irq_thread(irq, data);
	} else {
		if (irq_get_gpio_level(irq)) {
			uc_key->rise_ms = key_timer(0);
			KEY_DBG("%s: key dn: %llu ms\n",
				uc_key->name, uc_key->fall_ms);
		} else {
			uc_key->fall_ms = key_timer(0);
			KEY_DBG("%s: key up: %llu ms\n",
				uc_key->name, uc_key->rise_ms);
		}

		/* Must delay */
		mdelay(10);
		irq_revert_irq_type(irq);
	}

	/* Hook event: enter download mode by pwrkey */
#if defined(CONFIG_PWRKEY_DNL_TRIGGER_NUM) && \
		(CONFIG_PWRKEY_DNL_TRIGGER_NUM > 0)
	power_key_download(uc_key);
#endif
}
#endif

int key_bind_children(struct udevice *dev, const char *drv_name)
{
	const char *name;
	ofnode node;
	int ret;

	dev_for_each_subnode(node, dev) {
		/*
		 * If this node has "compatible" property, this is not
		 * a amp subnode, but a normal device. skip.
		 */
		ofnode_get_property(node, "compatible", &ret);
		if (ret >= 0)
			continue;

		if (ret != -FDT_ERR_NOTFOUND)
			return ret;

		name = ofnode_get_name(node);
		if (!name)
			return -EINVAL;
		ret = device_bind_driver_to_node(dev, drv_name, name,
						 node, NULL);
		if (ret)
			return ret;
	}

	return 0;
}

static int key_post_probe(struct udevice *dev)
{
	struct dm_key_uclass_platdata *uc_key;
	int ret;

	uc_key = dev_get_uclass_platdata(dev);
	if (!uc_key)
		return -ENXIO;

	/* True from U-Boot key node */
	uc_key->pre_reloc = dev_read_bool(dev, "u-boot,dm-pre-reloc") ||
			    dev_read_bool(dev, "u-boot,dm-spl");

	if (uc_key->type != ADC_KEY) {
		if (uc_key->code == KEY_POWER) {
#if CONFIG_IS_ENABLED(IRQ)
			int irq;

			if (uc_key->skip_irq_init)
				return 0;

			irq = phandle_gpio_to_irq(uc_key->gpios[0],
						  uc_key->gpios[1]);
			if (irq < 0) {
				KEY_ERR("%s: failed to request irq, ret=%d\n",
					uc_key->name, irq);
				return irq;
			}

			if (uc_key->code != KEY_POWER && uc_key->irq_thread) {
				KEY_WARN("%s: only power key can request irq thread\n",
					 uc_key->name);
				return -EINVAL;
			}

			uc_key->irq = irq;
			irq_install_handler(irq, gpio_irq_handler, dev);
			irq_set_irq_type(irq, IRQ_TYPE_EDGE_FALLING);
			irq_handler_enable(irq);
#else
			KEY_WARN("%s: no IRQ framework available\n", uc_key->name);
#endif
		} else {
			ret = gpio_request_by_name(dev, "gpios", 0,
						   &uc_key->gpio, GPIOD_IS_IN);
			if (ret) {
				KEY_ERR("%s: failed to request gpio, ret=%d\n",
					uc_key->name, ret);
				return ret;
			}
		}
	}

#ifdef DEBUG
	printf("[%s] (%s, %s, %s):\n", uc_key->name,
	       uc_key->type == ADC_KEY ? "ADC" : "GPIO",
	       uc_key->pre_reloc ? "U-Boot" : "Kernel",
	       dev->parent->name);

	if (uc_key->type == ADC_KEY) {
		printf("      %s: %d (%d, %d)\n",
		       uc_key->in_volt ? "volt" : " adc",
		       uc_key->center, uc_key->min, uc_key->max);
		printf("   channel: %d\n\n", uc_key->channel);
	} else {
		const char *gpio_name =
		     ofnode_get_name(ofnode_get_by_phandle(uc_key->gpios[0]));

		printf("       irq: %d\n", uc_key->irq);
		printf("   gpio[0]: %s\n", gpio_name);
		printf("   gpio[1]: %d\n\n", uc_key->gpios[1]);
	}
#endif

	return 0;
}

UCLASS_DRIVER(key) = {
	.id		= UCLASS_KEY,
	.name		= "key",
	.post_probe	= key_post_probe,
	.per_device_platdata_auto_alloc_size =
			sizeof(struct dm_key_uclass_platdata),
};