333 lines
9.9 KiB
C
Executable File
333 lines
9.9 KiB
C
Executable File
#include <linux/cdev.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/device.h>
|
|
#include <linux/compat.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/module.h>
|
|
#ifdef CONFIG_OF
|
|
#include <linux/of_irq.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/of_gpio.h>
|
|
#endif
|
|
#include <linux/gpio.h>
|
|
#include <linux/spi/spi.h>
|
|
//#include "mtk_spi.h"
|
|
#include "fingerprint.h"
|
|
|
|
#include <linux/cust_include/cust_project_all_config.h>
|
|
|
|
|
|
DECLARE_WAIT_QUEUE_HEAD(finger_init_waiter);
|
|
|
|
int up_finger_probe_isok = 0;
|
|
|
|
struct pinctrl *up_finger_pinctrl;
|
|
struct pinctrl_state *up_finger_reset_high,*up_finger_reset_low,*up_finger_spi0_mi_as_spi0_mi,*up_finger_spi0_mi_as_gpio,
|
|
*up_finger_spi0_mo_as_spi0_mo,*up_finger_spi0_mo_as_gpio,*up_finger_spi0_clk_as_spi0_clk,*up_finger_spi0_clk_as_gpio,
|
|
*up_finger_spi0_cs_as_spi0_cs,*up_finger_spi0_cs_as_gpio,*up_finger_eint_pull_down,*up_finger_eint_pull_up,*up_finger_eint_pull_dis;
|
|
|
|
int up_finger_get_gpio_info(struct platform_device *pdev)
|
|
{
|
|
struct device_node *node;
|
|
int ret;
|
|
node = of_find_compatible_node(NULL, NULL, "mediatek,up_finger");
|
|
printk("node.name <%s> full name <%s>\n",node->name,node->full_name);
|
|
|
|
wake_up_interruptible(&finger_init_waiter);
|
|
|
|
up_finger_pinctrl = devm_pinctrl_get(&pdev->dev);
|
|
if (IS_ERR(up_finger_pinctrl)) {
|
|
ret = PTR_ERR(up_finger_pinctrl);
|
|
dev_err(&pdev->dev, "up_finger cannot find pinctrl and ret = (%d)\n",ret);
|
|
return ret;
|
|
}
|
|
|
|
printk("[%s] up_finger_pinctrl+++++++++++++++++\n",pdev->name);
|
|
|
|
up_finger_reset_high = pinctrl_lookup_state(up_finger_pinctrl, "finger_reset_en1");
|
|
if (IS_ERR(up_finger_reset_high)) {
|
|
ret = PTR_ERR(up_finger_reset_high);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_reset_high!\n");
|
|
return ret;
|
|
}
|
|
up_finger_reset_low = pinctrl_lookup_state(up_finger_pinctrl, "finger_reset_en0");
|
|
if (IS_ERR(up_finger_reset_low)) {
|
|
ret = PTR_ERR(up_finger_reset_low);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_reset_low!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_mi_as_spi0_mi = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_mi_as_spi0_mi");
|
|
if (IS_ERR(up_finger_spi0_mi_as_spi0_mi)) {
|
|
ret = PTR_ERR(up_finger_spi0_mi_as_spi0_mi);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_mi_as_spi0_mi!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_mi_as_gpio = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_mi_as_gpio");
|
|
if (IS_ERR(up_finger_spi0_mi_as_gpio)) {
|
|
ret = PTR_ERR(up_finger_spi0_mi_as_gpio);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_mi_as_gpio!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_mo_as_spi0_mo = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_mo_as_spi0_mo");
|
|
if (IS_ERR(up_finger_spi0_mo_as_spi0_mo)) {
|
|
ret = PTR_ERR(up_finger_spi0_mo_as_spi0_mo);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_mo_as_spi0_mo!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_mo_as_gpio = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_mo_as_gpio");
|
|
if (IS_ERR(up_finger_spi0_mo_as_gpio)) {
|
|
ret = PTR_ERR(up_finger_spi0_mo_as_gpio);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_mo_as_gpio!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_clk_as_spi0_clk = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_clk_as_spi0_clk");
|
|
if (IS_ERR(up_finger_spi0_clk_as_spi0_clk)) {
|
|
ret = PTR_ERR(up_finger_spi0_clk_as_spi0_clk);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_clk_as_spi0_clk!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_clk_as_gpio = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_clk_as_gpio");
|
|
if (IS_ERR(up_finger_spi0_clk_as_gpio)) {
|
|
ret = PTR_ERR(up_finger_spi0_clk_as_gpio);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_clk_as_gpio!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_cs_as_spi0_cs = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_cs_as_spi0_cs");
|
|
if (IS_ERR(up_finger_spi0_cs_as_spi0_cs)) {
|
|
ret = PTR_ERR(up_finger_spi0_cs_as_spi0_cs);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_cs_as_spi0_cs!\n");
|
|
return ret;
|
|
}
|
|
up_finger_spi0_cs_as_gpio = pinctrl_lookup_state(up_finger_pinctrl, "finger_spi0_cs_as_gpio");
|
|
if (IS_ERR(up_finger_spi0_cs_as_gpio)) {
|
|
ret = PTR_ERR(up_finger_spi0_cs_as_gpio);
|
|
dev_err(&pdev->dev, " Cannot find up_finger pinctrl up_finger_spi0_cs_as_gpio!\n");
|
|
return ret;
|
|
}
|
|
|
|
up_finger_eint_pull_down = pinctrl_lookup_state(up_finger_pinctrl, "finger_eint_pull_down");
|
|
if (IS_ERR(up_finger_eint_pull_down)) {
|
|
ret = PTR_ERR(up_finger_eint_pull_down);
|
|
dev_err(&pdev->dev, " Cannot find fp pinctrl up_finger_eint_pull_down!\n");
|
|
return ret;
|
|
}
|
|
up_finger_eint_pull_up= pinctrl_lookup_state(up_finger_pinctrl, "finger_eint_pull_up");
|
|
if (IS_ERR(up_finger_eint_pull_up)) {
|
|
ret = PTR_ERR(up_finger_eint_pull_up);
|
|
dev_err(&pdev->dev, " Cannot find fp pinctrl up_finger_eint_pull_up!\n");
|
|
return ret;
|
|
}
|
|
|
|
up_finger_eint_pull_dis = pinctrl_lookup_state(up_finger_pinctrl, "finger_eint_pull_dis");
|
|
if (IS_ERR(up_finger_eint_pull_dis)) {
|
|
ret = PTR_ERR(up_finger_eint_pull_dis);
|
|
dev_err(&pdev->dev, " Cannot find fp pinctrl up_finger_eint_pull_dis!\n");
|
|
return ret;
|
|
}
|
|
|
|
printk("up_finger get gpio info ok--------\n");
|
|
return 0;
|
|
}
|
|
|
|
int up_finger_set_reset(int cmd)
|
|
{
|
|
|
|
if(IS_ERR(up_finger_reset_low)||IS_ERR(up_finger_reset_high))
|
|
{
|
|
pr_err( "err: up_finger_reset_low or up_finger_reset_high is error!!!");
|
|
return -1;
|
|
}
|
|
|
|
|
|
switch (cmd)
|
|
{
|
|
case 0 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_reset_low);
|
|
break;
|
|
case 1 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_reset_high);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int up_finger_set_irq(int cmd)
|
|
{
|
|
if(IS_ERR(up_finger_eint_pull_down)||IS_ERR(up_finger_eint_pull_up)||IS_ERR(up_finger_eint_pull_dis))
|
|
{
|
|
pr_err( "err: up_finger_int_as_gpio is error!!!!");
|
|
return -1;
|
|
}
|
|
|
|
switch (cmd)
|
|
{
|
|
case 0 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_eint_pull_down);
|
|
break;
|
|
case 1 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_eint_pull_up);
|
|
break;
|
|
case 2 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_eint_pull_dis);
|
|
break;
|
|
}
|
|
return 0;
|
|
|
|
|
|
}
|
|
|
|
/*********************blestech(start 2018-1-19)***********/
|
|
|
|
unsigned int up_finger_get_irqnum(void){
|
|
struct device_node *node = NULL;
|
|
//MALOGF("start");
|
|
node = of_find_compatible_node(NULL, NULL, "mediatek,up_finger");
|
|
return irq_of_parse_and_map(node, 0);
|
|
}
|
|
|
|
unsigned int up_finger_get_irq_gpio(void){
|
|
struct device_node *node = NULL;
|
|
//MALOGF("start");
|
|
node = of_find_compatible_node(NULL, NULL, "mediatek,up_finger");
|
|
return of_get_named_gpio(node, "int-gpio", 0);
|
|
}
|
|
|
|
unsigned int up_finger_get_reset_gpio(void){
|
|
struct device_node *node = NULL;
|
|
//MALOGF("start");
|
|
node = of_find_compatible_node(NULL, NULL, "mediatek,up_finger");
|
|
return of_get_named_gpio(node, "reset-gpio", 0);
|
|
}
|
|
|
|
int up_finger_set_spi_mode(int cmd)
|
|
{
|
|
|
|
if(IS_ERR(up_finger_spi0_clk_as_gpio)||IS_ERR(up_finger_spi0_cs_as_gpio)||IS_ERR(up_finger_spi0_mi_as_gpio) \
|
|
||IS_ERR(up_finger_spi0_mo_as_gpio)||IS_ERR(up_finger_spi0_clk_as_spi0_clk)||IS_ERR(up_finger_spi0_cs_as_spi0_cs) \
|
|
||IS_ERR(up_finger_spi0_mi_as_spi0_mi)||IS_ERR(up_finger_spi0_mo_as_spi0_mo))
|
|
{
|
|
pr_err( "err: up_finger_reset_low or up_finger_reset_high is error!!!");
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
switch (cmd)
|
|
{
|
|
case 0 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_clk_as_gpio);
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_cs_as_gpio);
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_mi_as_gpio);
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_mo_as_gpio);
|
|
break;
|
|
case 1 :
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_clk_as_spi0_clk);
|
|
#if defined(CONFIG_FINGERPRINT_CHIPONE_REE)
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_cs_as_gpio);
|
|
#else
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_cs_as_spi0_cs);
|
|
#endif
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_mi_as_spi0_mi);
|
|
pinctrl_select_state(up_finger_pinctrl, up_finger_spi0_mo_as_spi0_mo);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static struct of_device_id up_finger_match[] = {
|
|
{ .compatible = "mediatek,up_finger", },
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, up_finger_match);
|
|
#endif
|
|
|
|
static struct platform_device *up_finger_plat = NULL;
|
|
|
|
|
|
void up_waite_for_finger_dts_paser(void)
|
|
{
|
|
if(up_finger_plat==NULL)
|
|
{
|
|
wait_event_interruptible_timeout(finger_init_waiter, up_finger_plat != NULL, 3 * HZ);
|
|
}
|
|
else
|
|
return;
|
|
|
|
}
|
|
|
|
int up_get_max_finger_spi_cs_number(void)
|
|
{
|
|
return MAX_FINGER_CHIP_CS_NUMBER;
|
|
}
|
|
|
|
int up_finger_plat_probe(struct platform_device *pdev) {
|
|
up_finger_plat = pdev;
|
|
printk("up_finger_plat_probe entry\n");
|
|
up_finger_get_gpio_info(pdev);
|
|
return 0;
|
|
}
|
|
|
|
int up_finger_plat_remove(struct platform_device *pdev) {
|
|
up_finger_plat = NULL;
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifndef CONFIG_OF
|
|
static struct platform_device up_finger_dev = {
|
|
.name = "up_finger",
|
|
.id = -1,
|
|
};
|
|
#endif
|
|
|
|
|
|
static struct platform_driver up_finger_pdrv = {
|
|
.probe = up_finger_plat_probe,
|
|
.remove = up_finger_plat_remove,
|
|
.driver = {
|
|
.name = "up_finger",
|
|
.owner = THIS_MODULE,
|
|
#ifdef CONFIG_OF
|
|
.of_match_table = up_finger_match,
|
|
#endif
|
|
}
|
|
};
|
|
|
|
|
|
static int __init up_finger_init(void)
|
|
{
|
|
|
|
#ifndef CONFIG_OF
|
|
int retval=0;
|
|
retval = platform_device_register(&up_finger_dev);
|
|
if (retval != 0){
|
|
return retval;
|
|
}
|
|
#endif
|
|
if(platform_driver_register(&up_finger_pdrv))
|
|
{
|
|
printk("failed to register driver");
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
/*----------------------------------------------------------------------------*/
|
|
static void __exit up_finger_exit(void)
|
|
{
|
|
platform_driver_unregister(&up_finger_pdrv);
|
|
}
|
|
|
|
|
|
rootfs_initcall(up_finger_init);
|
|
module_exit(up_finger_exit);
|
|
|
|
MODULE_DESCRIPTION("for up fingerprint driver");
|
|
MODULE_LICENSE("GPL");
|