Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+95
View File
@@ -0,0 +1,95 @@
config KEYBOARD_MTK
tristate "MediaTek Keypad Support"
---help---
Say Y here if you want to use the keypad.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called mtk-kpd.
config ONEKEY_REBOOT_NORMAL_MODE
bool "Long press reboot by Powerkey only on normal mode"
default n
---help---
Say Y here if you want to use one key reboot normal mode.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called long_press_reboot_function_setting.
config TWOKEY_REBOOT_NORMAL_MODE
bool "Long press reboot by Powerkey + other key on normal mode"
default n
---help---
Say Y here if you want to use two key reboot noraml mode.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called long_press_reboot_function_setting.
config ONEKEY_REBOOT_OTHER_MODE
bool "Long press reboot by Powerkey only on other mode"
default n
---help---
Say Y here if you want to use one key reboot other mode.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called long_press_reboot_function_setting.
config TWOKEY_REBOOT_OTHER_MODE
bool "Long press reboot by Powerkey + other key on other mode"
default n
---help---
Say Y here if you want to use two key reboot other mode.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called long_press_reboot_function_setting.
config KPD_PMIC_LPRST_TD
int "Long press reboot timeout period"
depends on ONEKEY_REBOOT_NORMAL_MODE || TWOKEY_REBOOT_NORMAL_MODE
range 0 3
default "0"
---help---
0->8s, 1->11s, 2->14s, 3->5s
config KPD_PWRKEY_USE_PMIC
bool "power key use pmic key"
default n
---help---
Say Y here if you want to use pmic key as power key.
If unuse, say N.
To compile this driver as a module, choose M here: the
module will be called kpd_pmic_pwrkey_hal.
config MTK_MRDUMP_KEY
bool "MediaTek mrdump reset key support"
default n
help
Say Y if you want to enable mrdump key SMT item support.
If you don't know what to do here, say N.
The memory dump key is implemented via eint-rst-key,
and used for debug purpose. The circuit layout must
have phyiscal eint-rst-key key on the main board.
config LONG_PRESS_MODE_EN
bool "MediaTek dump reset key support"
default n
help
Say Y if you want to enable mrdump key SMT item support.
If you don't know what to do here, say N.
The memory dump key includes power key,homerst key and
volume down key,and used for debug purpose.
+32
View File
@@ -0,0 +1,32 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# 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.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ifeq (y, $(filter y, $(CONFIG_MACH_MT6761)))
MTK_KPD_PLATFORM:=mt6765
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6771)))
MTK_KPD_PLATFORM:=mt6771
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6779)))
MTK_KPD_PLATFORM:=mt6779
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6781)))
MTK_KPD_PLATFORM:=mt6781
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6893)))
MTK_KPD_PLATFORM:=mt6893
else
MTK_KPD_PLATFORM:=$(CONFIG_MTK_PLATFORM)
endif
subdir-ccflags-y += -Werror -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_KPD_PLATFORM)/include/
subdir-ccflags-y += -I$(srctree)/drivers/input/keyboard/mediatek/$(MTK_KPD_PLATFORM)/
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
obj-$(CONFIG_KEYBOARD_MTK) := kpd.o
obj-y += $(subst ",,$(MTK_KPD_PLATFORM))/
+508
View File
@@ -0,0 +1,508 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "kpd.h"
#ifdef CONFIG_PM_SLEEP
#include <linux/pm_wakeup.h>
#endif
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/clk.h>
#include <linux/debugfs.h>
#include <linux/pinctrl/consumer.h>
#define KPD_NAME "mtk-kpd"
#ifdef CONFIG_LONG_PRESS_MODE_EN
struct timer_list Long_press_key_timer;
atomic_t vol_down_long_press_flag = ATOMIC_INIT(0);
#endif
int kpd_klog_en;
void __iomem *kp_base;
static unsigned int kp_irqnr;
struct input_dev *kpd_input_dev;
static struct dentry *kpd_droot;
static struct dentry *kpd_dklog;
unsigned long call_status;
static bool kpd_suspend;
static unsigned int kp_irqnr;
static u32 kpd_keymap[KPD_NUM_KEYS];
static u16 kpd_keymap_state[KPD_NUM_MEMS];
struct input_dev *kpd_input_dev;
#ifdef CONFIG_PM_SLEEP
struct wakeup_source* kpd_suspend_lock;
#endif
struct keypad_dts_data kpd_dts_data;
/* for keymap handling */
static void kpd_keymap_handler(unsigned long data);
static DECLARE_TASKLET(kpd_keymap_tasklet, kpd_keymap_handler, 0);
static void kpd_memory_setting(void);
static int kpd_pdrv_probe(struct platform_device *pdev);
static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state);
static int kpd_pdrv_resume(struct platform_device *pdev);
static struct platform_driver kpd_pdrv;
static void kpd_memory_setting(void)
{
kpd_init_keymap(kpd_keymap);
kpd_init_keymap_state(kpd_keymap_state);
}
#if 1
static ssize_t kpd_call_state_store(struct device_driver *ddri,
const char *buf, size_t count)
{
int ret;
ret = kstrtoul(buf, 10, &call_status);
if (ret) {
kpd_print("kpd call state: Invalid values\n");
return -EINVAL;
}
switch (call_status) {
case 1:
kpd_print("kpd call state: Idle state!\n");
break;
case 2:
kpd_print("kpd call state: ringing state!\n");
break;
case 3:
kpd_print("kpd call state: active or hold state!\n");
break;
default:
kpd_print("kpd call state: Invalid values\n");
break;
}
return count;
}
static ssize_t kpd_call_state_show(struct device_driver *ddri, char *buf)
{
ssize_t res;
res = snprintf(buf, PAGE_SIZE, "%ld\n", call_status);
return res;
}
static DRIVER_ATTR_RW(kpd_call_state);
static struct driver_attribute *kpd_attr_list[] = {
&driver_attr_kpd_call_state,
};
static int kpd_create_attr(struct device_driver *driver)
{
int idx, err = 0;
int num = ARRAY_SIZE(kpd_attr_list);
if (driver == NULL)
return -EINVAL;
for (idx = 0; idx < num; idx++) {
err = driver_create_file(driver, kpd_attr_list[idx]);
if (err) {
kpd_info("driver_create_file (%s) = %d\n",
kpd_attr_list[idx]->attr.name, err);
break;
}
}
return err;
}
static int kpd_delete_attr(struct device_driver *driver)
{
int idx, err = 0;
int num = ARRAY_SIZE(kpd_attr_list);
if (!driver)
return -EINVAL;
for (idx = 0; idx < num; idx++)
driver_remove_file(driver, kpd_attr_list[idx]);
return err;
}
#endif
/****************************************/
#ifdef CONFIG_LONG_PRESS_MODE_EN
void vol_down_long_press(unsigned long pressed)
{
atomic_set(&vol_down_long_press_flag, 1);
}
#endif
/*****************************************/
#ifdef CONFIG_KPD_PWRKEY_USE_PMIC
void kpd_pwrkey_pmic_handler(unsigned long pressed)
{
kpd_print("Power Key generate, pressed=%ld\n", pressed);
if (!kpd_input_dev) {
kpd_print("KPD input device not ready\n");
return;
}
kpd_pmic_pwrkey_hal(pressed);
}
#endif
void kpd_pmic_rstkey_handler(unsigned long pressed)
{
kpd_print("PMIC reset Key generate, pressed=%ld\n", pressed);
if (!kpd_input_dev) {
kpd_print("KPD input device not ready\n");
return;
}
kpd_pmic_rstkey_hal(pressed);
}
static void kpd_keymap_handler(unsigned long data)
{
u16 i, j;
int32_t pressed;
u16 new_state[KPD_NUM_MEMS], change, mask;
u16 hw_keycode, linux_keycode;
kpd_get_keymap_state(new_state);
#ifdef CONFIG_PM_SLEEP
__pm_wakeup_event(kpd_suspend_lock, 500);
#endif
for (i = 0; i < KPD_NUM_MEMS; i++) {
change = new_state[i] ^ kpd_keymap_state[i];
if (change == 0U)
continue;
for (j = 0; j < 16U; j++) {
mask = (u16) 1 << j;
if ((change & mask) == 0U)
continue;
hw_keycode = (i << 4) + j;
if (hw_keycode >= KPD_NUM_KEYS)
continue;
/* bit is 1: not pressed, 0: pressed */
pressed = ((new_state[i] & mask) == 0U) ? 1 : 0;
kpd_print("(%s) HW keycode = %d\n",
(pressed == 1) ? "pressed" : "released",
hw_keycode);
linux_keycode = kpd_keymap[hw_keycode];
if (linux_keycode == 0U)
continue;
input_report_key(kpd_input_dev, linux_keycode, pressed);
input_sync(kpd_input_dev);
kpd_print("report Linux keycode = %d\n", linux_keycode);
#ifdef CONFIG_LONG_PRESS_MODE_EN
if (pressed) {
init_timer(&Long_press_key_timer);
Long_press_key_timer.expires = jiffies + 5*HZ;
Long_press_key_timer.data =
(unsigned long)pressed;
Long_press_key_timer.function =
vol_down_long_press;
add_timer(&Long_press_key_timer);
} else {
del_timer_sync(&Long_press_key_timer);
}
if (!pressed &&
atomic_read(&vol_down_long_press_flag)) {
atomic_set(&vol_down_long_press_flag, 0);
}
#endif
}
}
memcpy(kpd_keymap_state, new_state, sizeof(new_state));
enable_irq(kp_irqnr);
}
static irqreturn_t kpd_irq_handler(int irq, void *dev_id)
{
/* use _nosync to avoid deadlock */
disable_irq_nosync(kp_irqnr);
tasklet_schedule(&kpd_keymap_tasklet);
return IRQ_HANDLED;
}
static int kpd_open(struct input_dev *dev)
{
/* void __user *uarg = (void __user *)arg; */
return 0;
}
void kpd_get_dts_info(struct device_node *node)
{
int32_t ret;
of_property_read_u32(node, "mediatek,kpd-key-debounce",
&kpd_dts_data.kpd_key_debounce);
of_property_read_u32(node, "mediatek,kpd-sw-pwrkey",
&kpd_dts_data.kpd_sw_pwrkey);
of_property_read_u32(node, "mediatek,kpd-hw-pwrkey",
&kpd_dts_data.kpd_hw_pwrkey);
of_property_read_u32(node, "mediatek,kpd-sw-rstkey",
&kpd_dts_data.kpd_sw_rstkey);
of_property_read_u32(node, "mediatek,kpd-hw-rstkey",
&kpd_dts_data.kpd_hw_rstkey);
of_property_read_u32(node, "mediatek,kpd-use-extend-type",
&kpd_dts_data.kpd_use_extend_type);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key1",
&kpd_dts_data.kpd_hw_dl_key1);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key2",
&kpd_dts_data.kpd_hw_dl_key2);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key3",
&kpd_dts_data.kpd_hw_dl_key3);
of_property_read_u32(node, "mediatek,kpd-hw-recovery-key",
&kpd_dts_data.kpd_hw_recovery_key);
of_property_read_u32(node, "mediatek,kpd-hw-factory-key",
&kpd_dts_data.kpd_hw_factory_key);
of_property_read_u32(node, "mediatek,kpd-hw-map-num",
&kpd_dts_data.kpd_hw_map_num);
of_property_read_u32(node, "mediatek,boot_mode",
&kpd_dts_data.boot_mode);
ret = of_property_read_u32_array(node, "mediatek,kpd-hw-init-map",
kpd_dts_data.kpd_hw_init_map,
kpd_dts_data.kpd_hw_map_num);
if (ret) {
kpd_print("kpd-hw-init-map was not defined in dts.\n");
memset(kpd_dts_data.kpd_hw_init_map, 0,
sizeof(kpd_dts_data.kpd_hw_init_map));
}
kpd_print("deb= %d, sw-pwr= %d, hw-pwr= %d, hw-rst= %d, sw-rst= %d\n",
kpd_dts_data.kpd_key_debounce, kpd_dts_data.kpd_sw_pwrkey,
kpd_dts_data.kpd_hw_pwrkey, kpd_dts_data.kpd_hw_rstkey,
kpd_dts_data.kpd_sw_rstkey);
}
static int32_t kpd_gpio_init(struct device *dev)
{
struct pinctrl *keypad_pinctrl;
struct pinctrl_state *kpd_default;
int32_t ret;
if (dev == NULL) {
kpd_print("kpd device is NULL!\n");
ret = -1;
} else {
keypad_pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(keypad_pinctrl)) {
ret = -1;
kpd_print("Cannot find keypad_pinctrl!\n");
} else {
kpd_default = pinctrl_lookup_state(keypad_pinctrl,
"default");
if (IS_ERR(kpd_default)) {
ret = -1;
kpd_print("Cannot find ecall_state!\n");
} else
ret = pinctrl_select_state(keypad_pinctrl,
kpd_default);
}
}
return ret;
}
static int mt_kpd_debugfs(void)
{
#ifdef CONFIG_MTK_ENG_BUILD
kpd_klog_en = 1;
#else
kpd_klog_en = 0;
#endif
kpd_droot = debugfs_create_dir("keypad", NULL);
if (IS_ERR_OR_NULL(kpd_droot))
return PTR_ERR(kpd_droot);
kpd_dklog = debugfs_create_u32("debug", 0600, kpd_droot, &kpd_klog_en);
return 0;
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
struct clk *kpd_clk = NULL;
u32 i;
int32_t err = 0;
printk("kpd_pdrv_probe\n");
if (!pdev->dev.of_node) {
kpd_notice("no kpd dev node\n");
return -ENODEV;
}
kpd_clk = devm_clk_get(&pdev->dev, "kpd-clk");
if (!IS_ERR(kpd_clk)) {
err = clk_prepare_enable(kpd_clk);
if (err)
kpd_notice("get kpd-clk fail: %d\n", err);
} else {
kpd_notice("kpd-clk is default set by ccf.\n");
}
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
kpd_notice("KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
kpd_notice("KP get irqnr failed\n");
return -ENODEV;
}
kpd_info("kp base: 0x%p, addr:0x%p, kp irq: %d\n",
kp_base, &kp_base, kp_irqnr);
err = kpd_gpio_init(&pdev->dev);
if (err != 0)
kpd_print("gpio init failed\n");
kpd_get_dts_info(pdev->dev.of_node);
kpd_memory_setting();
kpd_input_dev = devm_input_allocate_device(&pdev->dev);
if (!kpd_input_dev) {
kpd_notice("input allocate device fail.\n");
return -ENOMEM;
}
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
kpd_input_dev->dev.parent = &pdev->dev;
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if defined(CONFIG_KPD_PWRKEY_USE_PMIC)
__set_bit(kpd_dts_data.kpd_sw_pwrkey, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
if (!kpd_dts_data.kpd_use_extend_type) {
for (i = 17; i < KPD_NUM_KEYS; i += 9)
kpd_keymap[i] = 0;
}
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
if (kpd_dts_data.kpd_sw_rstkey)
__set_bit(kpd_dts_data.kpd_sw_rstkey, kpd_input_dev->keybit);
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef CONFIG_MTK_MRDUMP_KEY
__set_bit(KEY_RESTART, kpd_input_dev->keybit);
#endif
err = input_register_device(kpd_input_dev);
if (err) {
kpd_notice("register input device failed (%d)\n", err);
return err;
}
#ifdef CONFIG_PM_SLEEP
kpd_suspend_lock = wakeup_source_register(NULL, "kpd wakelock");
#endif
/* register IRQ and EINT */
kpd_set_debounce(kpd_dts_data.kpd_key_debounce);
err = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE,
KPD_NAME, NULL);
if (err) {
kpd_notice("register IRQ failed (%d)\n", err);
input_unregister_device(kpd_input_dev);
return err;
}
if (enable_irq_wake(kp_irqnr) < 0)
kpd_notice("irq %d enable irq wake fail\n", kp_irqnr);
#ifdef CONFIG_MTK_MRDUMP_KEY
mt_eint_register();
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
long_press_reboot_function_setting();
#endif
err = kpd_create_attr(&kpd_pdrv.driver);
if (err) {
kpd_notice("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
/* Add kpd debug node */
mt_kpd_debugfs();
kpd_info("kpd_probe OK.\n");
return err;
}
static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state)
{
kpd_suspend = true;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n",
kpd_suspend);
} else {
kpd_wakeup_src_setting(0);
kpd_print("kpd_early_suspend wake up source disable!! (%d)\n",
kpd_suspend);
}
#endif
kpd_print("suspend!! (%d)\n", kpd_suspend);
return 0;
}
static int kpd_pdrv_resume(struct platform_device *pdev)
{
kpd_suspend = false;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n",
kpd_suspend);
} else {
kpd_print("kpd_early_suspend wake up source resume!! (%d)\n",
kpd_suspend);
kpd_wakeup_src_setting(1);
}
#endif
kpd_print("resume!! (%d)\n", kpd_suspend);
return 0;
}
static const struct of_device_id kpd_of_match[] = {
{.compatible = "mediatek,mt8167-keypad"},
{.compatible = "mediatek,kp"},
{},
};
static struct platform_driver kpd_pdrv = {
.probe = kpd_pdrv_probe,
.suspend = kpd_pdrv_suspend,
.resume = kpd_pdrv_resume,
.driver = {
.name = KPD_NAME,
.owner = THIS_MODULE,
.of_match_table = kpd_of_match,
},
};
module_platform_driver(kpd_pdrv);
MODULE_AUTHOR("Mediatek Corporation");
MODULE_DESCRIPTION("MTK Keypad (KPD) Driver");
MODULE_LICENSE("GPL");
+74
View File
@@ -0,0 +1,74 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __KPD_H__
#define __KPD_H__
#include <linux/ioctl.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/atomic.h>
#include <hal_kpd.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#ifdef CONFIG_LONG_PRESS_MODE_EN
#include <linux/jiffies.h>
#endif
struct keypad_dts_data {
u32 kpd_key_debounce;
u32 kpd_sw_pwrkey;
u32 kpd_hw_pwrkey;
u32 kpd_sw_rstkey;
u32 kpd_hw_rstkey;
u32 kpd_use_extend_type;
u32 kpd_hw_map_num;
u32 kpd_hw_init_map[KPD_NUM_KEYS];
u32 kpd_hw_dl_key1;
u32 kpd_hw_dl_key2;
u32 kpd_hw_dl_key3;
u32 kpd_hw_recovery_key;
u32 kpd_hw_factory_key;
u32 boot_mode;
};
extern struct keypad_dts_data kpd_dts_data;
extern int kpd_klog_en;
#ifdef CONFIG_LONG_PRESS_MODE_EN
extern atomic_t vol_down_long_press_flag;
#endif
#define KPD_DEBUG 1
#define SET_KPD_KCOL _IO('k', 29)
#define KPD_SAY "kpd: "
#if KPD_DEBUG
#define kpd_print(fmt, arg...) do { \
if (kpd_klog_en) \
pr_debug(KPD_SAY fmt, ##arg); \
} while (0)
#define kpd_info(fmt, arg...) do { \
if (kpd_klog_en) \
pr_info(KPD_SAY fmt, ##arg); \
} while (0)
#define kpd_notice(fmt, arg...) \
pr_notice(KPD_SAY fmt, ##arg)
#else
#define kpd_print(fmt, arg...) do {} while (0)
#define kpd_info(fmt, arg...) do {} while (0)
#endif
#endif /* __KPD_H__ */
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,438 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <kpd.h>
#include <mt-plat/aee.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#ifdef CONFIG_MT_SND_SOC_NEW_ARCH
#include <mt_soc_afe_control.h>
#endif
#ifdef CONFIG_KPD_PWRKEY_USE_EINT
static u8 kpd_pwrkey_state = !KPD_PWRKEY_POLARITY;
#endif
static int kpd_show_hw_keycode = 1;
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static bool kpd_sb_enable;
unsigned int get_boot_mode(void)
{
return 0;
}
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
static void sb_kpd_release_keys(struct input_dev *dev)
{
int code;
for (code = 0; code <= KEY_MAX; code++) {
if (test_bit(code, dev->keybit)) {
kpd_print("report release event for sb plug in! keycode:%d\n", code);
input_report_key(dev, code, 0);
input_sync(dev);
}
}
}
void sb_kpd_enable(void)
{
kpd_sb_enable = true;
kpd_print("sb_kpd_enable performed!\n");
mt_reg_sync_writew(0x0, KP_EN);
sb_kpd_release_keys(kpd_input_dev);
}
void sb_kpd_disable(void)
{
kpd_sb_enable = false;
kpd_print("sb_kpd_disable performed!\n");
mt_reg_sync_writew(0x1, KP_EN);
}
#else
void sb_kpd_enable(void)
{
kpd_print("sb_kpd_enable empty function for HAL!\n");
}
void sb_kpd_disable(void)
{
kpd_print("sb_kpd_disable empty function for HAL!\n");
}
#endif
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_slide_qwerty_init(void)
{
#if KPD_HAS_SLIDE_QWERTY
bool evdev_flag = false;
bool power_op = false;
struct input_handler *handler;
struct input_handle *handle;
handle = rcu_dereference(dev->grab);
if (handle) {
handler = handle->handler;
if (strcmp(handler->name, "evdev") == 0)
return -1;
} else {
list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
handler = handle->handler;
if (strcmp(handler->name, "evdev") == 0) {
evdev_flag = true;
break;
}
}
if (evdev_flag == false)
return -1;
}
power_op = powerOn_slidePin_interface();
if (!power_op)
kpd_print(KPD_SAY "Qwerty slide pin interface power on fail\n");
else
kpd_print("Qwerty slide pin interface power on success\n");
mt_eint_set_sens(KPD_SLIDE_EINT, KPD_SLIDE_SENSITIVE);
mt_eint_set_hw_debounce(KPD_SLIDE_EINT, KPD_SLIDE_DEBOUNCE);
mt_eint_registration(KPD_SLIDE_EINT, true, KPD_SLIDE_POLARITY, kpd_slide_eint_handler, false);
power_op = powerOff_slidePin_interface();
if (!power_op)
kpd_print(KPD_SAY "Qwerty slide pin interface power off fail\n");
else
kpd_print("Qwerty slide pin interface power off success\n");
#endif
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n", state[0], state[1], state[2], state[3], state[4]);
}
static void kpd_factory_mode_handler(void)
{
int i, j;
bool pressed;
u16 new_state[KPD_NUM_MEMS], change, mask;
u16 hw_keycode, linux_keycode;
for (i = 0; i < KPD_NUM_MEMS - 1; i++)
kpd_keymap_state[i] = 0xffff;
if (!kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[KPD_NUM_MEMS - 1] = 0x00ff;
else
kpd_keymap_state[KPD_NUM_MEMS - 1] = 0xffff;
kpd_get_keymap_state(new_state);
for (i = 0; i < KPD_NUM_MEMS; i++) {
change = new_state[i] ^ kpd_keymap_state[i];
if (!change)
continue;
for (j = 0; j < 16; j++) {
mask = 1U << j;
if (!(change & mask))
continue;
hw_keycode = (i << 4) + j;
if (hw_keycode >= KPD_NUM_KEYS)
continue;
/* bit is 1: not pressed, 0: pressed */
pressed = !(new_state[i] & mask);
if (kpd_show_hw_keycode) {
kpd_print(KPD_SAY "(%s) factory_mode HW keycode = %u\n",
pressed ? "pressed" : "released", hw_keycode);
}
linux_keycode = kpd_dts_data.kpd_hw_init_map[hw_keycode];
if (unlikely(linux_keycode == 0)) {
kpd_print("Linux keycode = 0\n");
continue;
}
input_report_key(kpd_input_dev, linux_keycode, pressed);
input_sync(kpd_input_dev);
kpd_print("factory_mode report Linux keycode = %u\n", linux_keycode);
}
}
memcpy(kpd_keymap_state, new_state, sizeof(new_state));
kpd_print("save new keymap state\n");
}
/********************************************************************/
void kpd_auto_test_for_factorymode(void)
{
kpd_print("Enter kpd_auto_test_for_factorymode!\n");
mdelay(1000);
kpd_factory_mode_handler();
kpd_print("begin kpd_auto_test_for_factorymode!\n");
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (pmic_get_register_value(PMIC_PWRKEY_DEB) == 1) {
kpd_print("power key release\n");
/*kpd_pwrkey_pmic_handler(1);*/
/*mdelay(time);*/
/*kpd_pwrkey_pmic_handler(0);}*/
} else {
kpd_print("power key press\n");
kpd_pwrkey_pmic_handler(1);
/*mdelay(time);*/
/*kpd_pwrkey_pmic_handler(0);*/
}
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
if (pmic_get_register_value(PMIC_HOMEKEY_DEB) == 1) {
/*kpd_print("home key release\n");*/
/*kpd_pmic_rstkey_handler(1);*/
/*mdelay(time);*/
/*kpd_pmic_rstkey_handler(0);*/
} else {
kpd_print("home key press\n");
kpd_pmic_rstkey_handler(1);
/*mdelay(time);*/
/*kpd_pmic_rstkey_handler(0);*/
}
#endif
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD, CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD, CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD, CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD, CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable other mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++) {
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
/*kpd_print(KPD_SAY "keymap[%d] = %d\n", i,keymap[i]);*/
}
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n", keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
if (!kpd_sb_enable) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey, pressed);
input_sync(kpd_input_dev);
if (kpd_show_hw_keycode) {
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_rstkey);
}
}
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
#ifdef CONFIG_KPD_PWRKEY_USE_PMIC
if (!kpd_sb_enable) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
if (kpd_show_hw_keycode) {
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
/* aee_powerkey_notify_press(pressed);*/
}
#endif
}
/***********************************************************************/
void kpd_pwrkey_handler_hal(unsigned long data)
{
#ifdef CONFIG_KPD_PWRKEY_USE_EINT
bool pressed;
u8 old_state = kpd_pwrkey_state;
kpd_pwrkey_state = !kpd_pwrkey_state;
pressed = (kpd_pwrkey_state == !!KPD_PWRKEY_POLARITY);
if (kpd_show_hw_keycode)
kpd_print(KPD_SAY "(%s) HW keycode = using EINT\n", pressed ? "pressed" : "released");
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
kpd_print("report Linux keycode = %u\n", kpd_dts_data.kpd_sw_pwrkey);
input_sync(kpd_input_dev);
/* for detecting the return to old_state */
mt_eint_set_polarity(KPD_PWRKEY_EINT, old_state);
mt_eint_unmask(KPD_PWRKEY_EINT);
#endif
}
#ifdef CONFIG_MTK_MRDUMP_KEY
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
#endif
/***********************************************************************/
void mt_eint_register(void)
{
#ifdef CONFIG_MTK_MRDUMP_KEY
int ints[2] = {0, 0};
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL, "mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
of_property_read_u32_array(node, "debounce", ints, ARRAY_SIZE(ints));
gpio_set_debounce(ints[0], ints[1]);
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint", NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
#endif
}
/************************************************************************/
@@ -0,0 +1,59 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
/*function define*/
void kpd_slide_qwerty_init(void);
void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
extern struct input_dev *kpd_input_dev;
#ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
void sb_kpd_enable(void);
void sb_kpd_disable(void);
#else
void sb_kpd_enable(void);
void sb_kpd_disable(void);
#endif
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#define KPD_HAS_SLIDE_QWERTY 0
#endif
@@ -0,0 +1,3 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,256 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
#ifdef CONFIG_LONG_PRESS_MODE_EN
struct timer_list Long_press_timer;
atomic_t vol_up_long_press_flag = ATOMIC_INIT(0);
atomic_t pow_key_long_press_flag = ATOMIC_INIT(0);
#endif
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable other mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
#ifdef CONFIG_LONG_PRESS_MODE_EN
void vol_up_long_press(unsigned long pressed)
{
atomic_set(&vol_up_long_press_flag, 1);
}
#endif
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
#ifdef CONFIG_LONG_PRESS_MODE_EN
if (pressed) {
init_timer(&Long_press_timer);
Long_press_timer.expires = jiffies + 5*HZ;
Long_press_timer.data = (unsigned long)pressed;
Long_press_timer.function = vol_up_long_press;
add_timer(&Long_press_timer);
} else {
del_timer_sync(&Long_press_timer);
}
if (!pressed && atomic_read(&vol_up_long_press_flag))
atomic_set(&vol_up_long_press_flag, 0);
#endif
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
#ifdef CONFIG_LONG_PRESS_MODE_EN
if (pressed && atomic_read(&vol_up_long_press_flag) &&
atomic_read(&vol_down_long_press_flag)) {
atomic_set(&pow_key_long_press_flag, 1);
} else if (!pressed && atomic_read(&pow_key_long_press_flag)) {
atomic_set(&pow_key_long_press_flag, 0);
BUG_ON(1);
}
#endif
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint", NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
@@ -0,0 +1,48 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
void long_press_reboot_function_setting(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,243 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
unsigned int get_boot_mode(void)
{
return 0;
}
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable other mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
if (mrdump_ext_rst_irq) {
ret = request_irq(mrdump_ext_rst_irq,
mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE,
"mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
ret = enable_irq_wake(mrdump_ext_rst_irq);
if (ret > 0)
kpd_print("%s: enable_irq_wake failed.\n",
__func__);
}
}
}
/**********************************************************************/
@@ -0,0 +1,53 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,3 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,223 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) mtk_audio_condition_enter_suspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (mtk_audio_condition_enter_suspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
if (mrdump_ext_rst_irq) {
ret = request_irq(mrdump_ext_rst_irq,
mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE,
"mrdump_ext_rst-eint", NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
ret = enable_irq_wake(mrdump_ext_rst_irq);
if (ret)
kpd_print("%s: enable_irq_wake failed.\n",
__func__);
}
}
}
@@ -0,0 +1,48 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
void long_press_reboot_function_setting(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#endif
@@ -0,0 +1,3 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,233 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
unsigned int get_boot_mode(void)
{
return 0;
}
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_NORMAL_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#ifdef CONFIG_TWOKEY_REBOOT_OTHER_MODE
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x01);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
#endif
#else
kpd_info("disable other mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
pmic_set_register_value(PMIC_RG_HOMEKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) mtk_audio_condition_enter_suspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (mtk_audio_condition_enter_suspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
if (mrdump_ext_rst_irq) {
ret = request_irq(mrdump_ext_rst_irq,
mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE,
"mrdump_ext_rst-eint", NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
ret = enable_irq_wake(mrdump_ext_rst_irq);
if (ret)
kpd_print("%s: enable_irq_wake failed.\n",
__func__);
}
}
}
@@ -0,0 +1,49 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
void long_press_reboot_function_setting(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#endif
@@ -0,0 +1,3 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,223 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) mtk_audio_condition_enter_suspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (mtk_audio_condition_enter_suspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
if (mrdump_ext_rst_irq) {
ret = request_irq(mrdump_ext_rst_irq,
mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE,
"mrdump_ext_rst-eint", NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
ret = enable_irq_wake(mrdump_ext_rst_irq);
if (ret)
kpd_print("%s: enable_irq_wake failed.\n",
__func__);
}
}
}
@@ -0,0 +1,48 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
void long_press_reboot_function_setting(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,229 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,53 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,235 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
unsigned int get_boot_mode(void)
{
return 0;
}
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,53 @@
/*
* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,297 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_LONG_POWERKEY_LOG_STORE
#include <log_store_kernel.h>
#include <linux/kthread.h>
#include <uapi/linux/sched/types.h>
struct timer_list long_press_dump_timer;
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
#ifdef CONFIG_LONG_POWERKEY_LOG_STORE
init_timer(&long_press_dump_timer);
#endif
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
#ifdef CONFIG_LONG_POWERKEY_LOG_STORE
DECLARE_WAIT_QUEUE_HEAD(dump_log_wait);
bool long_press_key;
bool dump_thread;
static int dump_last_log(void *arg)
{
int ret;
/* unsigned long flags; */
struct sched_param param = {
.sched_priority = 99
};
dump_thread = true;
sched_setscheduler(current, SCHED_FIFO, &param);
ret = wait_event_interruptible_timeout(dump_log_wait,
dump_thread == false, HZ*10);
if (ret > 0 && long_press_key)
log_store_to_emmc();
else
pr_notice("log_store timeout or powerkey release.\n");
return 0;
}
void long_press_dump(unsigned long pressed)
{
pr_notice("log_store long press power key.\n");
long_press_key = true;
dump_thread = false;
wake_up_interruptible(&dump_log_wait);
}
#endif
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
#ifdef CONFIG_LONG_POWERKEY_LOG_STORE
struct task_struct *hd_thread;
#endif
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
#ifdef CONFIG_LONG_POWERKEY_LOG_STORE
if (pressed) {
long_press_dump_timer.expires = jiffies + 6*HZ;
long_press_dump_timer.data = (unsigned long)pressed;
long_press_dump_timer.function = long_press_dump;
if (!timer_pending(&long_press_dump_timer)) {
add_timer(&long_press_dump_timer);
hd_thread = kthread_create(dump_last_log,
NULL, "dump_log");
if (hd_thread != NULL)
wake_up_process(hd_thread);
}
} else {
long_press_key = false;
dump_thread = false;
wake_up_interruptible(&dump_log_wait);
del_timer_sync(&long_press_dump_timer);
}
#endif
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,52 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,228 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0
*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,233 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
unsigned int get_boot_mode(void)
{
return 0;
}
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif
@@ -0,0 +1,7 @@
subdir-ccflags-y += -Werror -I$(srctree)/drivers/input/keyboard/mediatek/
ifeq ($(CONFIG_MT_SND_SOC_NEW_ARCH),y)
EXTRA_CFLAGS += -I$(srctree)/sound/soc/mediatek/common/
endif
obj-$(CONFIG_KEYBOARD_MTK) := hal_kpd.o
@@ -0,0 +1,228 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include <kpd.h>
#include <hal_kpd.h>
#include <mt-plat/mtk_boot_common.h>
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
static int kpd_enable_lprst = 1;
#endif
static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
};
static void enable_kpd(int enable)
{
if (enable == 1) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is enabled\n");
} else if (enable == 0) {
mt_reg_sync_writew((u16) (enable), KP_EN);
kpd_print("KEYPAD is disabled\n");
}
}
void kpd_get_keymap_state(u16 state[])
{
state[0] = readw(KP_MEM1);
state[1] = readw(KP_MEM2);
state[2] = readw(KP_MEM3);
state[3] = readw(KP_MEM4);
state[4] = readw(KP_MEM5);
kpd_print(KPD_SAY "register = %x %x %x %x %x\n",
state[0], state[1], state[2], state[3], state[4]);
}
/********************************************************************/
void long_press_reboot_function_setting(void)
{
#ifdef CONFIG_MTK_PMIC_NEW_ARCH /*for pmic not ready*/
/* unlock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0x4729);
if (kpd_enable_lprst && kpd_dts_data.boot_mode == NORMAL_BOOT) {
kpd_info("Normal Boot long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable normal mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
} else {
kpd_info("Other Boot Mode long press reboot selection\n");
#ifdef CONFIG_KPD_PMIC_LPRST_TD
kpd_info("Enable other mode LPRST\n");
#ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE
/*POWERKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x00);
#elif defined(CONFIG_TWOKEY_REBOOT_NORMAL_MODE)
/*PWRKEY + HOMEKEY*/
pmic_set_register_value(PMIC_RG_PWRKEY_KEY_MODE, 0x01);
#endif
pmic_set_register_value(PMIC_RG_PWRKEY_RST_TD,
CONFIG_KPD_PMIC_LPRST_TD);
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x01);
#else
kpd_info("disable normal mode LPRST\n");
pmic_set_register_value(PMIC_RG_PWRKEY_RST_EN, 0x00);
#endif
}
/* lock PMIC protect key */
pmic_set_register_value(PMIC_RG_CPS_W_KEY, 0);
#endif
}
/* FM@suspend */
bool __attribute__ ((weak)) ConditionEnterSuspend(void)
{
return true;
}
/********************************************************************/
void kpd_wakeup_src_setting(int enable)
{
int is_fm_radio_playing = 0;
/* If FM is playing, keep keypad as wakeup source */
if (ConditionEnterSuspend() == true)
is_fm_radio_playing = 0;
else
is_fm_radio_playing = 1;
if (is_fm_radio_playing == 0) {
if (enable == 1) {
kpd_print("enable kpd work!\n");
enable_kpd(1);
} else {
kpd_print("disable kpd work!\n");
enable_kpd(0);
}
}
}
/********************************************************************/
void kpd_init_keymap(u32 keymap[])
{
int i = 0;
if (kpd_dts_data.kpd_use_extend_type)
kpd_keymap_state[4] = 0xffff;
for (i = 0; i < KPD_NUM_KEYS; i++)
keymap[i] = kpd_dts_data.kpd_hw_init_map[i];
}
void kpd_init_keymap_state(u16 keymap_state[])
{
int i = 0;
for (i = 0; i < KPD_NUM_MEMS; i++)
keymap_state[i] = kpd_keymap_state[i];
kpd_info("init_keymap_state done: %x %x %x %x %x!\n",
keymap_state[0], keymap_state[1], keymap_state[2],
keymap_state[3], keymap_state[4]);
}
/********************************************************************/
void kpd_set_debounce(u16 val)
{
mt_reg_sync_writew((u16) (val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
}
void kpd_double_key_enable(int en)
{
u16 tmp;
tmp = *(u16 *)KP_SEL;
if (en != 0)
writew((u16) (tmp | KPD_DOUBLE_KEY_MASK), KP_SEL);
else
writew((u16) (tmp & ~KPD_DOUBLE_KEY_MASK), KP_SEL);
}
/********************************************************************/
void kpd_pmic_rstkey_hal(unsigned long pressed)
{
if (kpd_dts_data.kpd_sw_rstkey != 0) {
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_rstkey,
pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released",
kpd_dts_data.kpd_sw_rstkey);
}
}
void kpd_pmic_pwrkey_hal(unsigned long pressed)
{
input_report_key(kpd_input_dev, kpd_dts_data.kpd_sw_pwrkey, pressed);
input_sync(kpd_input_dev);
kpd_print(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
pressed ? "pressed" : "released", kpd_dts_data.kpd_sw_pwrkey);
}
static int mrdump_eint_state;
static int mrdump_ext_rst_irq;
static irqreturn_t mrdump_rst_eint_handler(int irq, void *data)
{
/* bool pressed; */
if (mrdump_eint_state == 0) {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_HIGH);
mrdump_eint_state = 1;
} else {
irq_set_irq_type(mrdump_ext_rst_irq, IRQ_TYPE_LEVEL_LOW);
mrdump_eint_state = 0;
}
input_report_key(kpd_input_dev, KEY_RESTART, mrdump_eint_state);
input_sync(kpd_input_dev);
return IRQ_HANDLED;
}
/**********************************************************************/
void mt_eint_register(void)
{
int ret;
struct device_node *node;
/* register EINT handler for MRDUMP_EXT_RST key */
node = of_find_compatible_node(NULL, NULL,
"mediatek, mrdump_ext_rst-eint");
if (!node)
kpd_print("can't find compatible node\n");
else {
mrdump_ext_rst_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(mrdump_ext_rst_irq, mrdump_rst_eint_handler,
IRQF_TRIGGER_NONE, "mrdump_ext_rst-eint",
NULL);
if (ret > 0)
kpd_print("EINT IRQ LINE NOT AVAILABLE\n");
}
}
/**********************************************************************/
@@ -0,0 +1,52 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef KPD_HAL_H
#define KPD_HAL_H
#include <mt-plat/sync_write.h>
/* Keypad registers */
extern void __iomem *kp_base;
extern struct input_dev *kpd_input_dev;
#define KP_STA (kp_base + 0x0000)
#define KP_MEM1 (kp_base + 0x0004)
#define KP_MEM2 (kp_base + 0x0008)
#define KP_MEM3 (kp_base + 0x000c)
#define KP_MEM4 (kp_base + 0x0010)
#define KP_MEM5 (kp_base + 0x0014)
#define KP_DEBOUNCE (kp_base + 0x0018)
#define KP_SCAN_TIMING (kp_base + 0x001C)
#define KP_SEL (kp_base + 0x0020)
#define KP_EN (kp_base + 0x0024)
#define KP_COL0_SEL (1 << 10)
#define KP_COL1_SEL (1 << 11)
#define KP_COL2_SEL (1 << 12)
#define KPD_DEBOUNCE_MASK ((1U << 14) - 1)
#define KPD_DOUBLE_KEY_MASK (1U << 0)
/*function define*/
//void kpd_slide_qwerty_init(void);
//void kpd_ldvt_test_init(void);
void long_press_reboot_function_setting(void);
//void kpd_auto_test_for_factorymode(void);
void kpd_wakeup_src_setting(int enable);
void kpd_get_keymap_state(u16 state[]);
void kpd_set_debounce(u16 val);
void kpd_init_keymap(u32 keymap[]);
void kpd_init_keymap_state(u16 keymap_state[]);
void kpd_pmic_rstkey_hal(unsigned long pressed);
void kpd_pmic_pwrkey_hal(unsigned long pressed);
void kpd_pwrkey_handler_hal(unsigned long data);
void mt_eint_register(void);
void kpd_enable(int enable);
void kpd_double_key_enable(int en);
#define KPD_NUM_MEMS 5
#define KPD_MEM5_BITS 8
#define KPD_NUM_KEYS 72 /* 4 * 16 + KPD_MEM5_BITS */
#endif