MSM8998(高通835处理器)外接指纹识别传感器linux驱动

/*
 * FPC1020 Fingerprint sensor device driver
 *
 * This driver will control the platform resources that the FPC fingerprint
 * sensor needs to operate. The major things are probing the sensor to check
 * that it is actually connected and let the Kernel know this and with that also
 * enabling and disabling of regulators, enabling and disabling of platform
 * clocks, controlling GPIOs such as SPI chip select, sensor reset line, sensor
 * IRQ line, MISO and MOSI lines.
 *
 * The driver will expose most of its available functionality in sysfs which
 * enables dynamic control of these features from eg. a user space process.
 *
 * The sensor's IRQ events will be pushed to Kernel's event handling system and
 * are exposed in the drivers event node. This makes it possible for a user
 * space process to poll the input node and receive IRQ events easily. Usually
 * this node is available under /dev/input/eventX where 'X' is a number given by
 * the event system. A user space process will need to traverse all the event
 * nodes and ask for its parent's name (through EVIOCGNAME) which should match
 * the value in device tree named input-device-name.
 *
 * This driver will NOT send any SPI commands to the sensor it only controls the
 * electrical parts.
 *
 *
 * Copyright (c) 2015 Fingerprint Cards AB <tech@fingerprints.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License Version 2
 * as published by the Free Software Foundation.
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/regulator/consumer.h>
#include <soc/qcom/scm.h>

#include <linux/wakelock.h>
#include <linux/input.h>

#ifdef CONFIG_FB
#include <linux/fb.h>
#include <linux/notifier.h>
#endif

#include <linux/project_info.h>

static unsigned int ignor_home_for_ESD = 0;
module_param(ignor_home_for_ESD, uint, S_IRUGO | S_IWUSR);

#define FPC1020_RESET_LOW_US 1000
#define FPC1020_RESET_HIGH1_US 100
#define FPC1020_RESET_HIGH2_US 1250
#define FPC_TTW_HOLD_TIME 1000

/* Unused key value to avoid interfering with active keys */
#define KEY_FINGERPRINT 0x2ee

#define ONEPLUS_EDIT  //Onplus modify for msm8996 platform and 15801 HW

struct fpc1020_data {
    struct device *dev;
    struct wake_lock ttw_wl;
    int irq_gpio;
    int rst_gpio;
    int irq_num;
    struct mutex lock;
    bool prepared;

    struct pinctrl         *ts_pinctrl;
    struct pinctrl_state   *gpio_state_active;
    struct pinctrl_state   *gpio_state_suspend;

    #ifdef ONEPLUS_EDIT
    int EN_VDD_gpio;
    int id0_gpio;
    int id1_gpio;
    int id2_gpio;
    struct input_dev    *input_dev;
    int screen_state;//1: on 0:off
    int sensor_version;//0x01:fpc1245 0x02:fpc1263
    #endif
    #if defined(CONFIG_FB)
    struct notifier_block fb_notif;
    #endif
    struct work_struct pm_work;
    int proximity_state; /* 0:far 1:near */
    bool irq_enabled;
    spinlock_t irq_lock;
    struct completion irq_sent;
};

static int fpc1020_request_named_gpio(struct fpc1020_data *fpc1020,
        const char *label, int *gpio)
{
    struct device *dev = fpc1020->dev;
    struct device_node *np = dev->of_node;
    int rc = of_get_named_gpio(np, label, 0);
    if (rc < 0) {
        dev_err(dev, "failed to get '%s'\n", label);
        *gpio = rc;
        return rc;
    }
    *gpio = rc;
    rc = devm_gpio_request(dev, *gpio, label);
    if (rc) {
        dev_err(dev, "failed to request gpio %d\n", *gpio);
        return rc;
    }
    dev_info(dev, "%s - gpio: %d\n", label, *gpio);
    return 0;
}
#ifndef ONEPLUS_EDIT
/* -------------------------------------------------------------------- */
static int fpc1020_pinctrl_init(struct fpc1020_data *fpc1020)
{
    int ret = 0;
    struct device *dev = fpc1020->dev;

    fpc1020->ts_pinctrl = devm_pinctrl_get(dev);
    if (IS_ERR_OR_NULL(fpc1020->ts_pinctrl)) {
        dev_err(dev, "Target does not use pinctrl\n");
        ret = PTR_ERR(fpc1020->ts_pinctrl);
        goto err;
    }

    fpc1020->gpio_state_active =
        pinctrl_lookup_state(fpc1020->ts_pinctrl, "pmx_fp_active");
    if (IS_ERR_OR_NULL(fpc1020->gpio_state_active)) {
        dev_err(dev, "Cannot get active pinstate\n");
        ret = PTR_ERR(fpc1020->gpio_state_active);
        goto err;
    }

    fpc1020->gpio_state_suspend =
        pinctrl_lookup_state(fpc1020->ts_pinctrl, "pmx_fp_suspend");
    if (IS_ERR_OR_NULL(fpc1020->gpio_state_suspend)) {
        dev_err(dev, "Cannot get sleep pinstate\n");
        ret = PTR_ERR(fpc1020->gpio_state_suspend);
        goto err;
    }

    return 0;
err:
    fpc1020->ts_pinctrl = NULL;
    fpc1020->gpio_state_active = NULL;
    fpc1020->gpio_state_suspend = NULL;
    return ret;
}

/* -------------------------------------------------------------------- */
static int fpc1020_pinctrl_select(struct fpc1020_data *fpc1020, bool on)
{
    int ret = 0;
    struct pinctrl_state *pins_state;
    struct device *dev = fpc1020->dev;

    pins_state = on ? fpc1020->gpio_state_active : fpc1020->gpio_state_suspend;
    if (!IS_ERR_OR_NULL(pins_state)) {
        ret = pinctrl_select_state(fpc1020->ts_pinctrl, pins_state);
        if (ret) {
            dev_err(dev, "can not set %s pins\n",
                on ? "pmx_ts_active" : "pmx_ts_suspend");
            return ret;
        }
    } else {
        dev_err(dev, "not a valid '%s' pinstate\n",
            on ? "pmx_ts_active" : "pmx_ts_suspend");
    }

    return ret;
}
#endif
/*
static int hw_reset(struct  fpc1020_data *fpc1020)
{
    int irq_gpio;
    struct device *dev = fpc1020->dev;

    int rc = select_pin_ctl(fpc1020, "fpc1020_reset_active");
    if (rc)
        goto exit;
    usleep_range(FPC1020_RESET_HIGH1_US, FPC1020_RESET_HIGH1_US + 100);

    rc = select_pin_ctl(fpc1020, "fpc1020_reset_reset");
    if (rc)
        goto exit;
    usleep_range(FPC1020_RESET_LOW_US, FPC1020_RESET_LOW_US + 100);

    rc = select_pin_ctl(fpc1020, "fpc1020_reset_active");
    if (rc)
        goto exit;
    usleep_range(FPC1020_RESET_HIGH1_US, FPC1020_RESET_HIGH1_US + 100);

    irq_gpio = gpio_get_value(fpc1020->irq_gpio);
    dev_info(dev, "IRQ after reset %d\n", irq_gpio);
exit:
    return rc;
}

static int hw_reset(struct  fpc1020_data *fpc1020)
{
    int irq_gpio;
    struct device *dev = fpc1020->dev;
    int counter = 2;

    gpio_set_value(fpc1020->EN_VDD_gpio, 0);
    mdelay(3);
    gpio_set_value(fpc1020->EN_VDD_gpio, 1);
    mdelay(3);
    //gpio_direction_output(fpc1020->EN_VDD_gpio,1);

    while (counter) {
        counter--;

        gpio_set_value(fpc1020->rst_gpio, 1);
        udelay(FPC1020_RESET_HIGH1_US);

        gpio_set_value(fpc1020->rst_gpio, 0);
        udelay(FPC1020_RESET_LOW_US);

        gpio_set_value(fpc1020->rst_gpio, 1);
        udelay(FPC1020_RESET_HIGH2_US);

        irq_gpio = gpio_get_value(fpc1020->irq_gpio);
        dev_err(dev, "IRQ after reset %d\n", irq_gpio);
        if (irq_gpio) {
            //printk(KERN_INFO "%s OK !\n", __func__);
            counter = 0;
        } else {
            dev_err(dev, "%s timed out,retrying ...\n",
                __func__);

            udelay(1250);
        }
    }
    return 0;
}
static ssize_t hw_reset_set(struct device *dev,
    struct device_attribute *attr, const char *buf, size_t count)
{
    int rc;
    struct  fpc1020_data *fpc1020 = dev_get_drvdata(dev);

    if (!strncmp(buf, "reset", strlen("reset")))
        rc = hw_reset(fpc1020);
    else
        return -EINVAL;
    return rc ? rc : count;
}
static DEVICE_ATTR(hw_reset, S_IWUSR, NULL, hw_reset_set);

*/
/**
 * sysf node to check the interrupt status of the sensor, the interrupt
 * handler should perform sysf_notify to allow userland to poll the node.
 */
static ssize_t irq_get(struct device* device,
                 struct device_attribute* attribute,
                 char* buffer)
{
    struct fpc1020_data* fpc1020 = dev_get_drvdata(device);
    bool irq_enabled;
    int irq;
    ssize_t count;

    spin_lock(&fpc1020->irq_lock);
    irq_enabled = fpc1020->irq_enabled;
    spin_unlock(&fpc1020->irq_lock);

    irq = irq_enabled && gpio_get_value(fpc1020->irq_gpio);
    count = scnprintf(buffer, PAGE_SIZE, "%i\n", irq);

    complete(&fpc1020->irq_sent);

    return count;
}


/**
 * writing to the irq node will just drop a printk message
 * and return success, used for latency measurement.
 */
static ssize_t irq_ack(struct device* device,
                 struct device_attribute* attribute,
                 const char* buffer, size_t count)
{
    struct fpc1020_data* fpc1020 = dev_get_drvdata(device);
    dev_dbg(fpc1020->dev, "%s\n", __func__);
    return count;
}
static DEVICE_ATTR(irq, S_IRUSR | S_IWUSR, irq_get, irq_ack);

//liuyan not merge now

/*#ifdef VENDOR_EDIT //WayneChang, 2015/12/02, add for key to abs, simulate key in abs through virtual key system
extern void int_touch(void);
extern struct completion key_cm;
extern bool virtual_key_enable;

bool key_home_pressed = false;
EXPORT_SYMBOL(key_home_pressed);
#endif*/

static void set_fpc_irq(struct fpc1020_data *fpc1020, bool enable)
{
    bool irq_enabled;

    spin_lock(&fpc1020->irq_lock);
    irq_enabled = fpc1020->irq_enabled;
    fpc1020->irq_enabled = enable;
    spin_unlock(&fpc1020->irq_lock);

    if (enable == irq_enabled)
        return;

    if (enable)
        enable_irq(gpio_to_irq(fpc1020->irq_gpio));
    else
        disable_irq(gpio_to_irq(fpc1020->irq_gpio));
}

static ssize_t report_home_set(struct device *dev,
    struct device_attribute *attr, const char *buf, size_t count)
{
    struct  fpc1020_data *fpc1020 = dev_get_drvdata(dev);
    //unsigned long time;

    if(ignor_home_for_ESD)
        return -EINVAL;
    if (!strncmp(buf, "down", strlen("down")))
    {
/*#ifdef VENDOR_EDIT //WayneChang, 2015/12/02, add for key to abs, simulate key in abs through virtual key system
        if(virtual_key_enable){
                key_home_pressed = true;
        }else{*/
            input_report_key(fpc1020->input_dev,
                            KEY_HOME, 1);
            input_sync(fpc1020->input_dev);
/*        }
#endif*/
    }
    else if (!strncmp(buf, "up", strlen("up")))
    {
/*#ifdef VENDOR_EDIT //WayneChang, 2015/12/02, add for key to abs, simulate key in abs through virtual key system
        if(virtual_key_enable){
                key_home_pressed = false;
        }else{*/
            input_report_key(fpc1020->input_dev,
                            KEY_HOME, 0);
            input_sync(fpc1020->input_dev);
/*        }
#endif*/
    }
    else if (!strncmp(buf, "timeout", strlen("timeout")))
    {
      input_report_key(fpc1020->input_dev,KEY_F2,1);
      input_sync(fpc1020->input_dev);
      input_report_key(fpc1020->input_dev,KEY_F2,0);
      input_sync(fpc1020->input_dev);
    }
    else
        return -EINVAL;
/*#ifdef VENDOR_EDIT //WayneChang, 2015/12/02, add for key to abs, simulate key in abs through virtual key system
    if(virtual_key_enable){
        if(!key_home_pressed){
            reinit_completion(&key_cm);
            time = wait_for_completion_timeout(&key_cm,msecs_to_jiffies(60));
            if (!time)
                int_touch();
        }else{
            int_touch();
        }
    }
#endif*/
    return count;
}
static DEVICE_ATTR(report_home, S_IWUSR, NULL, report_home_set);

static ssize_t update_info_set(struct device *dev,
    struct device_attribute *attr, const char *buf, size_t count)
{
    //struct  fpc1020_data *fpc1020 = dev_get_drvdata(dev);

    if (!strncmp(buf, "n", strlen("n")))
    {
        push_component_info(FINGERPRINTS,"N/A" , "N/A");
    }

    return count;
}
static DEVICE_ATTR(update_info, S_IWUSR, NULL, update_info_set);

static ssize_t screen_state_get(struct device* device,
                 struct device_attribute* attribute,
                 char* buffer)
{
    struct fpc1020_data* fpc1020 = dev_get_drvdata(device);
    return scnprintf(buffer, PAGE_SIZE, "%i\n", fpc1020->screen_state);
}

static DEVICE_ATTR(screen_state, S_IRUSR , screen_state_get, NULL);

static ssize_t sensor_version_get(struct device* device,
                 struct device_attribute* attribute,
                 char* buffer)
{
    struct fpc1020_data* fpc1020 = dev_get_drvdata(device);
    return scnprintf(buffer, PAGE_SIZE, "%i\n", fpc1020->sensor_version);
}

static DEVICE_ATTR(sensor_version, S_IRUSR , sensor_version_get, NULL);

static ssize_t proximity_state_set(struct device *dev,
    struct device_attribute *attr, const char *buf, size_t count)
{
    struct fpc1020_data *fpc1020 = dev_get_drvdata(dev);
    int rc, val;

    rc = kstrtoint(buf, 10, &val);
    if (rc)
        return -EINVAL;

    fpc1020->proximity_state = !!val;

    if (!fpc1020->screen_state)
        set_fpc_irq(fpc1020, !fpc1020->proximity_state);

    return count;
}

static DEVICE_ATTR(proximity_state, S_IWUSR, NULL, proximity_state_set);

static struct attribute *attributes[] = {
    //&dev_attr_hw_reset.attr,
    &dev_attr_irq.attr,
    &dev_attr_report_home.attr,
    &dev_attr_update_info.attr,
    &dev_attr_screen_state.attr,
    &dev_attr_sensor_version.attr,
    &dev_attr_proximity_state.attr,
    NULL
};

static const struct attribute_group attribute_group = {
    .attrs = attributes,
};

int fpc1020_input_init(struct fpc1020_data *fpc1020)
{
    int error = 0;


    dev_dbg(fpc1020->dev, "%s\n", __func__);

    fpc1020->input_dev = input_allocate_device();

    if (!fpc1020->input_dev) {
        dev_err(fpc1020->dev, "Input_allocate_device failed.\n");
        error  = -ENOMEM;
    }

    if (!error) {
        fpc1020->input_dev->name = "fpc1020";

        /* Set event bits according to what events we are generating */
        set_bit(EV_KEY, fpc1020->input_dev->evbit);

        set_bit(KEY_POWER, fpc1020->input_dev->keybit);
        set_bit(KEY_F2, fpc1020->input_dev->keybit);
        set_bit(KEY_HOME, fpc1020->input_dev->keybit);
    set_bit(KEY_FINGERPRINT, fpc1020->input_dev->keybit);

        /* Register the input device */
        error = input_register_device(fpc1020->input_dev);


        if (error) {
            dev_err(fpc1020->dev, "Input_register_device failed.\n");
            input_free_device(fpc1020->input_dev);
            fpc1020->input_dev = NULL;
        }
    }

    return error;
}

/* -------------------------------------------------------------------- */
void fpc1020_input_destroy(struct fpc1020_data *fpc1020)
{
    dev_dbg(fpc1020->dev, "%s\n", __func__);

    if (fpc1020->input_dev != NULL)
        input_free_device(fpc1020->input_dev);
}

static void set_fingerprintd_nice(int nice)
{
    struct task_struct *p;

    read_lock(&tasklist_lock);
    for_each_process(p) {
        if (!memcmp(p->comm, "fingerprintd", 13)) {
            set_user_nice(p, nice);
            break;
        }
    }
    read_unlock(&tasklist_lock);
}

static void fpc1020_suspend_resume(struct work_struct *work)
{
    struct fpc1020_data *fpc1020 =
        container_of(work, typeof(*fpc1020), pm_work);

    if (fpc1020->screen_state) {
        set_fpc_irq(fpc1020, true);
        set_fingerprintd_nice(0);
    } else {
        /*
         * Elevate fingerprintd priority when screen is off to ensure
         * the fingerprint sensor is responsive and that the haptic
         * response on successful verification always fires.
         */
        set_fingerprintd_nice(-1);
    }

    sysfs_notify(&fpc1020->dev->kobj, NULL,
                dev_attr_screen_state.attr.name);
}

#if defined(CONFIG_FB)
static int fb_notifier_callback(struct notifier_block *self, unsigned long event, void *data)
{
    struct fpc1020_data *fpc1020 = container_of(self, struct fpc1020_data, fb_notif);
    struct fb_event *evdata = data;
    int *blank = evdata->data;

    if (event != FB_EARLY_EVENT_BLANK)
        return 0;

    if (*blank == FB_BLANK_UNBLANK) {
        fpc1020->screen_state = 1;
        queue_work(system_highpri_wq, &fpc1020->pm_work);
    } else if (*blank == FB_BLANK_POWERDOWN) {
        fpc1020->screen_state = 0;
        queue_work(system_highpri_wq, &fpc1020->pm_work);
    }

    return 0;
}
#endif

static irqreturn_t fpc1020_irq_handler(int irq, void *handle)
{
    struct fpc1020_data *fpc1020 = handle;

    sysfs_notify(&fpc1020->dev->kobj, NULL, dev_attr_irq.attr.name);

    reinit_completion(&fpc1020->irq_sent);
    wait_for_completion_timeout(&fpc1020->irq_sent, msecs_to_jiffies(100));

    if (fpc1020->screen_state)
        return IRQ_HANDLED;

    wake_lock_timeout(&fpc1020->ttw_wl, msecs_to_jiffies(FPC_TTW_HOLD_TIME));

    /* Report button input to trigger CPU boost */
    input_report_key(fpc1020->input_dev, KEY_FINGERPRINT, 1);
    input_sync(fpc1020->input_dev);
    input_report_key(fpc1020->input_dev, KEY_FINGERPRINT, 0);
    input_sync(fpc1020->input_dev);

    return IRQ_HANDLED;
}

static int fpc1020_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    int rc = 0;
    unsigned long irqf;
    int id0, id1, id2;

    struct device_node *np = dev->of_node;

    struct fpc1020_data *fpc1020 = devm_kzalloc(dev, sizeof(*fpc1020),
            GFP_KERNEL);
    if (!fpc1020) {
        dev_err(dev,
            "failed to allocate memory for struct fpc1020_data\n");
        rc = -ENOMEM;
        goto exit;
    }

    printk(KERN_INFO "%s\n", __func__);

    fpc1020->dev = dev;
    dev_set_drvdata(dev, fpc1020);

    if (!np) {
        dev_err(dev, "no of node found\n");
        rc = -EINVAL;
        goto exit;
    }

    rc = fpc1020_request_named_gpio(fpc1020, "fpc,irq-gpio",
            &fpc1020->irq_gpio);
    if (rc)
        goto exit;

    rc = gpio_direction_input(fpc1020->irq_gpio);

    if (rc) {
        dev_err(fpc1020->dev,
            "gpio_direction_input (irq) failed.\n");
        goto exit;
    }
    /*  in tz
    rc = fpc1020_request_named_gpio(fpc1020, "fpc,reset-gpio",
            &fpc1020->rst_gpio);
    if (rc)
        goto exit;*/

    #ifdef ONEPLUS_EDIT
    rc = fpc1020_request_named_gpio(fpc1020, "fpc,gpio_id0",
            &fpc1020->id0_gpio);
    if(gpio_is_valid(fpc1020->id0_gpio))
    {
        dev_err(dev, "%s: gpio_is_valid(fpc1020->id0_gpio=%d)\n", __func__,fpc1020->id0_gpio);
        gpio_direction_input(fpc1020->id0_gpio);
    }

    rc = fpc1020_request_named_gpio(fpc1020, "fpc,gpio_id1",
            &fpc1020->id1_gpio);
    if(gpio_is_valid(fpc1020->id1_gpio))
    {
        dev_err(dev, "%s: gpio_is_valid(fpc1020->id1_gpio=%d)\n", __func__,fpc1020->id1_gpio);
        gpio_direction_input(fpc1020->id1_gpio);
    }

    rc = fpc1020_request_named_gpio(fpc1020, "fpc,gpio_id2",
            &fpc1020->id2_gpio);
    if(gpio_is_valid(fpc1020->id2_gpio))
    {
        dev_err(dev, "%s: gpio_is_valid(fpc1020->id2_gpio=%d)\n", __func__,fpc1020->id2_gpio);
        gpio_direction_input(fpc1020->id2_gpio);
    }
    /* in xbl
    rc = fpc1020_request_named_gpio(fpc1020, "fpc,gpio_1V8_EN",
            &fpc1020->EN_VDD_gpio);
    if (rc)
        goto exit;
    gpio_direction_output(fpc1020->EN_VDD_gpio,1);*/

    #else
    rc = fpc1020_pinctrl_init(fpc1020);
    if (rc)
        goto exit;

    rc = fpc1020_pinctrl_select(fpc1020, true);
    if (rc)
        goto exit;

    #endif
    rc = fpc1020_input_init(fpc1020);
    if (rc)
        goto exit;

    INIT_WORK(&fpc1020->pm_work, fpc1020_suspend_resume);

    #if defined(CONFIG_FB)
    fpc1020->fb_notif.notifier_call = fb_notifier_callback;
    rc = fb_register_client(&fpc1020->fb_notif);
    if(rc)
        dev_err(fpc1020->dev, "Unable to register fb_notifier: %d\n", rc);
    fpc1020->screen_state = 1;
    #endif

    spin_lock_init(&fpc1020->irq_lock);
    fpc1020->irq_enabled = true;

    irqf = IRQF_TRIGGER_RISING | IRQF_ONESHOT;
    mutex_init(&fpc1020->lock);
    init_completion(&fpc1020->irq_sent);
    rc = devm_request_threaded_irq(dev, gpio_to_irq(fpc1020->irq_gpio),
            NULL, fpc1020_irq_handler, irqf,
            dev_name(dev), fpc1020);
    if (rc) {
        dev_err(dev, "could not request irq %d\n",
                gpio_to_irq(fpc1020->irq_gpio));
        goto exit;
    }
    dev_info(dev, "requested irq %d\n", gpio_to_irq(fpc1020->irq_gpio));

    /* Request that the interrupt should not be wakeable */
    //disable_irq_wake( gpio_to_irq( fpc1020->irq_gpio ) );

    enable_irq_wake( gpio_to_irq( fpc1020->irq_gpio ) );
    wake_lock_init(&fpc1020->ttw_wl, WAKE_LOCK_SUSPEND, "fpc_ttw_wl");
    device_init_wakeup(fpc1020->dev, 1);

    rc = sysfs_create_group(&dev->kobj, &attribute_group);
    if (rc) {
        dev_err(dev, "could not create sysfs\n");
        goto exit;
    }

    #if 0 //changhua remove HW reset here,move to HAL,after spi cs pin become high
    rc = gpio_direction_output(fpc1020->rst_gpio, 1);

    if (rc) {
        dev_err(fpc1020->dev,
            "gpio_direction_output (reset) failed.\n");
        goto exit;
    }

    gpio_set_value(fpc1020->rst_gpio, 1);
    udelay(FPC1020_RESET_HIGH1_US);

    gpio_set_value(fpc1020->rst_gpio, 0);
    udelay(FPC1020_RESET_LOW_US);

    gpio_set_value(fpc1020->rst_gpio, 1);
    udelay(FPC1020_RESET_HIGH2_US);
    #endif
    /**
    *           ID0(GPIO39)   ID1(GPIO41)   ID1(GPIO63)
    *   fpc1245
    *   O-film   1            1             1
    *   Primax   1            0             0
    *   truly    0            0             1
    *
    *   fpc1263
    *   O-film   1            1             0
    *   Primax   0            0             0
    *   truly    0            1             1
    *fingerchip/
    *   qtech    0            1             0
    *   Goodix   1            0             1
    *   
    */
    fpc1020->sensor_version = 0x02;
    id0 = gpio_get_value(fpc1020->id0_gpio);
    id1 = gpio_get_value(fpc1020->id1_gpio);
    id2 = gpio_get_value(fpc1020->id2_gpio);
    if (id0 && id1 && id2) {
        push_component_info(FINGERPRINTS, "fpc1245", "FPC(OF)");
        fpc1020->sensor_version = 0x01;
    } else if (id0 && !id1 && !id2) {
        push_component_info(FINGERPRINTS, "fpc1245", "FPC(Primax)");
        fpc1020->sensor_version = 0x01;
    } else if (!id0 && !id1 && id2) {
        push_component_info(FINGERPRINTS, "fpc1245", "FPC(truly)");
        fpc1020->sensor_version = 0x01;
    } else if (id0 && id1 && !id2) {
        push_component_info(FINGERPRINTS, "fpc1263", "FPC(OF)");
    } else if (!id0 && !id1 && !id2) {
        push_component_info(FINGERPRINTS, "fpc1263", "FPC(Primax)");
    } else if (!id0 && id1 && id2) {
        push_component_info(FINGERPRINTS, "fpc1263", "FPC(truly)");
    } else if (!id0 && id1 && !id2) {
        push_component_info(FINGERPRINTS, "fpc1263", "FPC(f/p)");
    } else if (id0 && !id1 && id2) {
        push_component_info(FINGERPRINTS, "fpc1263", "FPC(Goodix)");
    } else {
        push_component_info(FINGERPRINTS, "fpc", "PC");
    }

    dev_info(dev, "%s: ok\n", __func__);
exit:
    return rc;
}


static struct of_device_id fpc1020_of_match[] = {
    { .compatible = "fpc,fpc1020", },
    {}
};
MODULE_DEVICE_TABLE(of, fpc1020_of_match);

static struct platform_driver fpc1020_driver = {
    .driver = {
        .name       = "fpc1020",
        .owner      = THIS_MODULE,
        .of_match_table = fpc1020_of_match,
    },
    .probe = fpc1020_probe,
};
module_platform_driver(fpc1020_driver);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Aleksej Makarov");
MODULE_AUTHOR("Henrik Tillman <henrik.tillman@fingerprints.com>");
MODULE_DESCRIPTION("FPC1020 Fingerprint sensor device driver.");