| /* |
| * |
| * FocalTech TouchScreen driver. |
| * |
| * Copyright (c) 2010-2016, FocalTech Systems, Ltd., all rights reserved. |
| * |
| * This software is licensed under the terms of the GNU General Public |
| * License version 2, as published by the Free Software Foundation, and |
| * may be copied, distributed, and modified under those terms. |
| * |
| * 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. |
| * |
| */ |
| |
| /***************************************************************************** |
| * |
| * File Name: focaltech_esdcheck.c |
| * |
| * Author: Focaltech Driver Team |
| * |
| * Created: 2016-08-03 |
| * |
| * Abstract: Sensor |
| * |
| * Version: v1.0 |
| * |
| * Revision History: |
| * v1.0: |
| * First release. By luougojin 2016-08-03 |
| *****************************************************************************/ |
| |
| /***************************************************************************** |
| * Included header files |
| *****************************************************************************/ |
| #include "focaltech_core.h" |
| |
| #if FTS_PSENSOR_EN |
| /***************************************************************************** |
| * Private constant and macro definitions using #define |
| *****************************************************************************/ |
| /* psensor register address*/ |
| #define FTS_REG_PSENSOR_ENABLE 0xB0 |
| #define FTS_REG_PSENSOR_STATUS 0x01 |
| |
| /* psensor register bits*/ |
| #define FTS_PSENSOR_ENABLE_MASK 0x01 |
| #define FTS_PSENSOR_STATUS_NEAR 0xC0 |
| #define FTS_PSENSOR_STATUS_FAR 0xE0 |
| #define FTS_PSENSOR_FAR_TO_NEAR 0 |
| #define FTS_PSENSOR_NEAR_TO_FAR 1 |
| #define FTS_PSENSOR_ORIGINAL_STATE_FAR 1 |
| #define FTS_PSENSOR_WAKEUP_TIMEOUT 500 |
| |
| /***************************************************************************** |
| * Static variables |
| *****************************************************************************/ |
| static struct sensors_classdev __maybe_unused sensors_proximity_cdev = { |
| .name = "fts-proximity", |
| .vendor = "FocalTech", |
| .version = 1, |
| .handle = SENSORS_PROXIMITY_HANDLE, |
| .type = SENSOR_TYPE_PROXIMITY, |
| .max_range = "5.0", |
| .resolution = "5.0", |
| .sensor_power = "0.1", |
| .min_delay = 0, |
| .fifo_reserved_event_count = 0, |
| .fifo_max_event_count = 0, |
| .enabled = 0, |
| .delay_msec = 200, |
| .sensors_enable = NULL, |
| .sensors_poll_delay = NULL, |
| }; |
| |
| /***************************************************************************** |
| * functions body |
| *****************************************************************************/ |
| /***************************************************************************** |
| * Name: fts_psensor_support_enabled |
| * Brief: |
| * Input: |
| * Output: |
| * Return: |
| *****************************************************************************/ |
| static inline bool fts_psensor_support_enabled(void) |
| { |
| /*return config_enabled(CONFIG_TOUCHSCREEN_FTS_PSENSOR); */ |
| return FTS_PSENSOR_EN; |
| } |
| |
| /***************************************************************************** |
| * Name: fts_psensor_enable |
| * Brief: |
| * Input: |
| * Output: |
| * Return: |
| *****************************************************************************/ |
| static void fts_psensor_enable(struct fts_ts_data *data, int enable) |
| { |
| u8 state; |
| int ret = -1; |
| |
| if (data->client == NULL) |
| return; |
| |
| fts_i2c_read_reg(data->client, FTS_REG_PSENSOR_ENABLE, &state); |
| if (enable) |
| state |= FTS_PSENSOR_ENABLE_MASK; |
| else |
| state &= ~FTS_PSENSOR_ENABLE_MASK; |
| |
| ret = fts_i2c_write_reg(data->client, FTS_REG_PSENSOR_ENABLE, state); |
| if (ret < 0) |
| FTS_ERROR("write psensor switch command failed"); |
| } |
| |
| /***************************************************************************** |
| * Name: fts_psensor_enable_set |
| * Brief: |
| * Input: |
| * Output: |
| * Return: |
| *****************************************************************************/ |
| static int fts_psensor_enable_set(struct sensors_classdev *sensors_cdev, |
| unsigned int enable) |
| { |
| struct fts_psensor_platform_data *psensor_pdata = |
| container_of(sensors_cdev, |
| struct fts_psensor_platform_data, ps_cdev); |
| struct fts_ts_data *data = psensor_pdata->data; |
| struct input_dev *input_dev = data->psensor_pdata->input_psensor_dev; |
| |
| mutex_lock(&input_dev->mutex); |
| fts_psensor_enable(data, enable); |
| psensor_pdata->tp_psensor_data = FTS_PSENSOR_ORIGINAL_STATE_FAR; |
| if (enable) |
| psensor_pdata->tp_psensor_opened = 1; |
| else |
| psensor_pdata->tp_psensor_opened = 0; |
| mutex_unlock(&input_dev->mutex); |
| return enable; |
| } |
| |
| /***************************************************************************** |
| * Name: fts_read_tp_psensor_data |
| * Brief: |
| * Input: |
| * Output: |
| * Return: |
| *****************************************************************************/ |
| static int fts_read_tp_psensor_data(struct fts_ts_data *data) |
| { |
| u8 psensor_status; |
| char tmp; |
| int ret = 1; |
| |
| fts_i2c_read_reg(data->client, FTS_REG_PSENSOR_STATUS, &psensor_status); |
| |
| tmp = data->psensor_pdata->tp_psensor_data; |
| if (psensor_status == FTS_PSENSOR_STATUS_NEAR) |
| data->psensor_pdata->tp_psensor_data = FTS_PSENSOR_FAR_TO_NEAR; |
| else if (psensor_status == FTS_PSENSOR_STATUS_FAR) |
| data->psensor_pdata->tp_psensor_data = FTS_PSENSOR_NEAR_TO_FAR; |
| |
| if (tmp != data->psensor_pdata->tp_psensor_data) { |
| FTS_ERROR("%s sensor data changed", __func__); |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| int fts_sensor_read_data(struct fts_ts_data *data) |
| { |
| int ret = 0; |
| |
| if (fts_psensor_support_enabled() |
| && data->psensor_pdata->tp_psensor_opened) { |
| ret = fts_read_tp_psensor_data(data); |
| if (!ret) { |
| if (data->suspended) { |
| pm_wakeup_event(&data->client->dev, |
| FTS_PSENSOR_WAKEUP_TIMEOUT); |
| } |
| input_report_abs(data->psensor_pdata->input_psensor_dev, |
| ABS_DISTANCE, |
| data->psensor_pdata->tp_psensor_data); |
| input_sync(data->psensor_pdata->input_psensor_dev); |
| } |
| return 1; |
| } |
| return 0; |
| } |
| |
| int fts_sensor_suspend(struct fts_ts_data *data) |
| { |
| int ret = 0; |
| |
| if (fts_psensor_support_enabled() |
| && device_may_wakeup(&data->client->dev) |
| && data->psensor_pdata->tp_psensor_opened) { |
| ret = enable_irq_wake(data->client->irq); |
| if (ret != 0) |
| FTS_ERROR("%s: set_irq_wake failed", __func__); |
| data->suspended = true; |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| int fts_sensor_resume(struct fts_ts_data *data) |
| { |
| int ret = 0; |
| |
| if (fts_psensor_support_enabled() |
| && device_may_wakeup(&data->client->dev) |
| && data->psensor_pdata->tp_psensor_opened) { |
| ret = disable_irq_wake(data->client->irq); |
| if (ret) |
| FTS_ERROR("%s: disable_irq_wake failed", __func__); |
| data->suspended = false; |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| int fts_sensor_init(struct fts_ts_data *data) |
| { |
| struct fts_psensor_platform_data *psensor_pdata; |
| struct input_dev *psensor_input_dev; |
| int err; |
| |
| if (fts_psensor_support_enabled()) { |
| device_init_wakeup(&data->client->dev, 1); |
| psensor_pdata = |
| devm_kzalloc(&data->client->dev, |
| sizeof(struct fts_psensor_platform_data), |
| GFP_KERNEL); |
| if (!psensor_pdata) { |
| FTS_ERROR("Failed to allocate memory"); |
| goto irq_free; |
| } |
| data->psensor_pdata = psensor_pdata; |
| |
| psensor_input_dev = input_allocate_device(); |
| if (!psensor_input_dev) { |
| FTS_ERROR("Failed to allocate device"); |
| goto free_psensor_pdata; |
| } |
| |
| __set_bit(EV_ABS, psensor_input_dev->evbit); |
| input_set_abs_params(psensor_input_dev, ABS_DISTANCE, 0, 1, 0, |
| 0); |
| psensor_input_dev->name = "proximity"; |
| psensor_input_dev->id.bustype = BUS_I2C; |
| psensor_input_dev->dev.parent = &data->client->dev; |
| data->psensor_pdata->input_psensor_dev = psensor_input_dev; |
| |
| err = input_register_device(psensor_input_dev); |
| if (err) { |
| FTS_ERROR("Unable to register device, err=%d", err); |
| goto free_psensor_input_dev; |
| } |
| |
| psensor_pdata->ps_cdev = sensors_proximity_cdev; |
| psensor_pdata->ps_cdev.sensors_enable = fts_psensor_enable_set; |
| psensor_pdata->data = data; |
| |
| err = |
| sensors_classdev_register(&data->client->dev, |
| &psensor_pdata->ps_cdev); |
| if (err) |
| goto unregister_psensor_input_device; |
| } |
| |
| return 0; |
| unregister_psensor_input_device: |
| if (fts_psensor_support_enabled()) |
| input_unregister_device(data->psensor_pdata->input_psensor_dev); |
| free_psensor_input_dev: |
| if (fts_psensor_support_enabled()) |
| input_free_device(data->psensor_pdata->input_psensor_dev); |
| free_psensor_pdata: |
| if (fts_psensor_support_enabled()) { |
| devm_kfree(&data->client->dev, psensor_pdata); |
| data->psensor_pdata = NULL; |
| } |
| irq_free: |
| if (fts_psensor_support_enabled()) |
| device_init_wakeup(&data->client->dev, 0); |
| free_irq(data->client->irq, data); |
| |
| return 1; |
| } |
| |
| int fts_sensor_remove(struct fts_ts_data *data) |
| { |
| if (fts_psensor_support_enabled()) { |
| device_init_wakeup(&data->client->dev, 0); |
| sensors_classdev_unregister(&data->psensor_pdata->ps_cdev); |
| input_unregister_device(data->psensor_pdata->input_psensor_dev); |
| devm_kfree(&data->client->dev, data->psensor_pdata); |
| data->psensor_pdata = NULL; |
| } |
| return 0; |
| } |
| #endif /* FTS_PSENSOR_EN */ |
