blob: 4153ba01cbe77d06a086b5f3dce5724ac9b3e8bb [file] [log] [blame]
/*
* Synaptics DSX touchscreen driver
*
* Copyright (C) 2012 Synaptics Incorporated
*
* Copyright (C) 2012 Alexandra Chin <alexandra.chin@tw.synaptics.com>
* Copyright (C) 2012 Scott Lin <scott.lin@tw.synaptics.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/hrtimer.h>
#include <linux/ktime.h>
#include <linux/regulator/consumer.h>
#include <linux/input/synaptics_dsx_new.h>
#include "synaptics_dsx_core.h"
#ifdef KERNEL_ABOVE_2_6_38
#include <linux/input/mt.h>
#endif
#define INPUT_PHYS_NAME "synaptics_dsx/touch_input"
#define VIRTUAL_KEY_MAP_FILE_NAME "virtualkeys." PLATFORM_DRIVER_NAME
#ifdef KERNEL_ABOVE_2_6_38
#define TYPE_B_PROTOCOL
#endif
#define WAKEUP_GESTURE false
#define NO_0D_WHILE_2D
#define REPORT_2D_Z
#define REPORT_2D_W
#define F12_DATA_15_WORKAROUND
/*
#define IGNORE_FN_INIT_FAILURE
*/
#define RPT_TYPE (1 << 0)
#define RPT_X_LSB (1 << 1)
#define RPT_X_MSB (1 << 2)
#define RPT_Y_LSB (1 << 3)
#define RPT_Y_MSB (1 << 4)
#define RPT_Z (1 << 5)
#define RPT_WX (1 << 6)
#define RPT_WY (1 << 7)
#define RPT_DEFAULT (RPT_TYPE | RPT_X_LSB | RPT_X_MSB | RPT_Y_LSB | RPT_Y_MSB)
#define EXP_FN_WORK_DELAY_MS 1000 /* ms */
#define MAX_F11_TOUCH_WIDTH 15
#define CHECK_STATUS_TIMEOUT_MS 100
#define F01_STD_QUERY_LEN 21
#define F01_BUID_ID_OFFSET 18
#define STATUS_NO_ERROR 0x00
#define STATUS_RESET_OCCURRED 0x01
#define STATUS_INVALID_CONFIG 0x02
#define STATUS_DEVICE_FAILURE 0x03
#define STATUS_CONFIG_CRC_FAILURE 0x04
#define STATUS_FIRMWARE_CRC_FAILURE 0x05
#define STATUS_CRC_IN_PROGRESS 0x06
#define NORMAL_OPERATION (0 << 0)
#define SENSOR_SLEEP (1 << 0)
#define NO_SLEEP_OFF (0 << 2)
#define NO_SLEEP_ON (1 << 2)
#define CONFIGURED (1 << 7)
#define F11_CONTINUOUS_MODE 0x00
#define F11_WAKEUP_GESTURE_MODE 0x04
#define F12_CONTINUOUS_MODE 0x00
#define F12_WAKEUP_GESTURE_MODE 0x02
static int synaptics_rmi4_f12_set_enables(struct synaptics_rmi4_data *rmi4_data,
unsigned short ctrl28);
static int synaptics_rmi4_free_fingers(struct synaptics_rmi4_data *rmi4_data);
static int synaptics_rmi4_reinit_device(struct synaptics_rmi4_data *rmi4_data);
static int synaptics_rmi4_reset_device(struct synaptics_rmi4_data *rmi4_data);
#ifdef CONFIG_HAS_EARLYSUSPEND
static ssize_t synaptics_rmi4_full_pm_cycle_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_full_pm_cycle_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static void synaptics_rmi4_early_suspend(struct early_suspend *h);
static void synaptics_rmi4_late_resume(struct early_suspend *h);
#endif
static int synaptics_rmi4_suspend(struct device *dev);
static int synaptics_rmi4_resume(struct device *dev);
static ssize_t synaptics_rmi4_f01_reset_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_rmi4_f01_productinfo_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_f01_buildid_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_f01_flashprog_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_0dbutton_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_0dbutton_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_rmi4_suspend_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_rmi4_wake_gesture_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_wake_gesture_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_rmi4_virtual_key_map_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf);
static ssize_t synaptics_rmi4_poll_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_palm_size_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_palm_size_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t synaptics_mode_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t synaptics_mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static void synaptics_rmi4_f11_wg(struct synaptics_rmi4_data *, bool);
static void synaptics_rmi4_f12_wg(struct synaptics_rmi4_data *, bool);
struct synaptics_rmi4_f01_device_status {
union {
struct {
unsigned char status_code:4;
unsigned char reserved:2;
unsigned char flash_prog:1;
unsigned char unconfigured:1;
} __packed;
unsigned char data[1];
};
};
struct synaptics_rmi4_f11_query_0_5 {
union {
struct {
/* query 0 */
unsigned char f11_query0_b0__2:3;
unsigned char has_query_9:1;
unsigned char has_query_11:1;
unsigned char has_query_12:1;
unsigned char has_query_27:1;
unsigned char has_query_28:1;
/* query 1 */
unsigned char num_of_fingers:3;
unsigned char has_rel:1;
unsigned char has_abs:1;
unsigned char has_gestures:1;
unsigned char has_sensitibity_adjust:1;
unsigned char f11_query1_b7:1;
/* query 2 */
unsigned char num_of_x_electrodes;
/* query 3 */
unsigned char num_of_y_electrodes;
/* query 4 */
unsigned char max_electrodes:7;
unsigned char f11_query4_b7:1;
/* query 5 */
unsigned char abs_data_size:2;
unsigned char has_anchored_finger:1;
unsigned char has_adj_hyst:1;
unsigned char has_dribble:1;
unsigned char has_bending_correction:1;
unsigned char has_large_object_suppression:1;
unsigned char has_jitter_filter:1;
} __packed;
unsigned char data[6];
};
};
struct synaptics_rmi4_f11_query_7_8 {
union {
struct {
/* query 7 */
unsigned char has_single_tap:1;
unsigned char has_tap_and_hold:1;
unsigned char has_double_tap:1;
unsigned char has_early_tap:1;
unsigned char has_flick:1;
unsigned char has_press:1;
unsigned char has_pinch:1;
unsigned char has_chiral_scroll:1;
/* query 8 */
unsigned char has_palm_detect:1;
unsigned char has_rotate:1;
unsigned char has_touch_shapes:1;
unsigned char has_scroll_zones:1;
unsigned char individual_scroll_zones:1;
unsigned char has_multi_finger_scroll:1;
unsigned char has_multi_finger_scroll_edge_motion:1;
unsigned char has_multi_finger_scroll_inertia:1;
} __packed;
unsigned char data[2];
};
};
struct synaptics_rmi4_f11_query_9 {
union {
struct {
unsigned char has_pen:1;
unsigned char has_proximity:1;
unsigned char has_large_object_sensitivity:1;
unsigned char has_suppress_on_large_object_detect:1;
unsigned char has_two_pen_thresholds:1;
unsigned char has_contact_geometry:1;
unsigned char has_pen_hover_discrimination:1;
unsigned char has_pen_hover_and_edge_filters:1;
} __packed;
unsigned char data[1];
};
};
struct synaptics_rmi4_f11_query_12 {
union {
struct {
unsigned char has_small_object_detection:1;
unsigned char has_small_object_detection_tuning:1;
unsigned char has_8bit_w:1;
unsigned char has_2d_adjustable_mapping:1;
unsigned char has_general_information_2:1;
unsigned char has_physical_properties:1;
unsigned char has_finger_limit:1;
unsigned char has_linear_cofficient_2:1;
} __packed;
unsigned char data[1];
};
};
struct synaptics_rmi4_f11_query_27 {
union {
struct {
unsigned char f11_query27_b0:1;
unsigned char has_pen_position_correction:1;
unsigned char has_pen_jitter_filter_coefficient:1;
unsigned char has_group_decomposition:1;
unsigned char has_wakeup_gesture:1;
unsigned char has_small_finger_correction:1;
unsigned char has_data_37:1;
unsigned char f11_query27_b7:1;
} __packed;
unsigned char data[1];
};
};
struct synaptics_rmi4_f11_ctrl_6_9 {
union {
struct {
unsigned char sensor_max_x_pos_7_0;
unsigned char sensor_max_x_pos_11_8:4;
unsigned char f11_ctrl7_b4__7:4;
unsigned char sensor_max_y_pos_7_0;
unsigned char sensor_max_y_pos_11_8:4;
unsigned char f11_ctrl9_b4__7:4;
} __packed;
unsigned char data[4];
};
};
struct synaptics_rmi4_f11_data_1_5 {
union {
struct {
unsigned char x_position_11_4;
unsigned char y_position_11_4;
unsigned char x_position_3_0:4;
unsigned char y_position_3_0:4;
unsigned char wx:4;
unsigned char wy:4;
unsigned char z;
} __packed;
unsigned char data[5];
};
};
struct synaptics_rmi4_f12_query_5 {
union {
struct {
unsigned char size_of_query6;
struct {
unsigned char ctrl0_is_present:1;
unsigned char ctrl1_is_present:1;
unsigned char ctrl2_is_present:1;
unsigned char ctrl3_is_present:1;
unsigned char ctrl4_is_present:1;
unsigned char ctrl5_is_present:1;
unsigned char ctrl6_is_present:1;
unsigned char ctrl7_is_present:1;
} __packed;
struct {
unsigned char ctrl8_is_present:1;
unsigned char ctrl9_is_present:1;
unsigned char ctrl10_is_present:1;
unsigned char ctrl11_is_present:1;
unsigned char ctrl12_is_present:1;
unsigned char ctrl13_is_present:1;
unsigned char ctrl14_is_present:1;
unsigned char ctrl15_is_present:1;
} __packed;
struct {
unsigned char ctrl16_is_present:1;
unsigned char ctrl17_is_present:1;
unsigned char ctrl18_is_present:1;
unsigned char ctrl19_is_present:1;
unsigned char ctrl20_is_present:1;
unsigned char ctrl21_is_present:1;
unsigned char ctrl22_is_present:1;
unsigned char ctrl23_is_present:1;
} __packed;
struct {
unsigned char ctrl24_is_present:1;
unsigned char ctrl25_is_present:1;
unsigned char ctrl26_is_present:1;
unsigned char ctrl27_is_present:1;
unsigned char ctrl28_is_present:1;
unsigned char ctrl29_is_present:1;
unsigned char ctrl30_is_present:1;
unsigned char ctrl31_is_present:1;
} __packed;
};
unsigned char data[5];
};
};
struct synaptics_rmi4_f12_query_8 {
union {
struct {
unsigned char size_of_query9;
struct {
unsigned char data0_is_present:1;
unsigned char data1_is_present:1;
unsigned char data2_is_present:1;
unsigned char data3_is_present:1;
unsigned char data4_is_present:1;
unsigned char data5_is_present:1;
unsigned char data6_is_present:1;
unsigned char data7_is_present:1;
} __packed;
struct {
unsigned char data8_is_present:1;
unsigned char data9_is_present:1;
unsigned char data10_is_present:1;
unsigned char data11_is_present:1;
unsigned char data12_is_present:1;
unsigned char data13_is_present:1;
unsigned char data14_is_present:1;
unsigned char data15_is_present:1;
} __packed;
};
unsigned char data[3];
};
};
struct synaptics_rmi4_f12_ctrl_8 {
union {
struct {
unsigned char max_x_coord_lsb;
unsigned char max_x_coord_msb;
unsigned char max_y_coord_lsb;
unsigned char max_y_coord_msb;
unsigned char rx_pitch_lsb;
unsigned char rx_pitch_msb;
unsigned char tx_pitch_lsb;
unsigned char tx_pitch_msb;
unsigned char low_rx_clip;
unsigned char high_rx_clip;
unsigned char low_tx_clip;
unsigned char high_tx_clip;
unsigned char num_of_rx;
unsigned char num_of_tx;
};
unsigned char data[14];
};
};
struct synaptics_rmi4_f12_ctrl_23 {
union {
struct {
unsigned char obj_type_enable;
unsigned char max_reported_objects;
};
unsigned char data[2];
};
};
struct synaptics_rmi4_f12_finger_data {
unsigned char object_type_and_status;
unsigned char x_lsb;
unsigned char x_msb;
unsigned char y_lsb;
unsigned char y_msb;
#ifdef REPORT_2D_Z
unsigned char z;
#endif
#ifdef REPORT_2D_W
unsigned char wx;
unsigned char wy;
#endif
};
struct synaptics_rmi4_f1a_query {
union {
struct {
unsigned char max_button_count:3;
unsigned char reserved:5;
unsigned char has_general_control:1;
unsigned char has_interrupt_enable:1;
unsigned char has_multibutton_select:1;
unsigned char has_tx_rx_map:1;
unsigned char has_perbutton_threshold:1;
unsigned char has_release_threshold:1;
unsigned char has_strongestbtn_hysteresis:1;
unsigned char has_filter_strength:1;
} __packed;
unsigned char data[2];
};
};
struct synaptics_rmi4_f1a_control_0 {
union {
struct {
unsigned char multibutton_report:2;
unsigned char filter_mode:2;
unsigned char reserved:4;
} __packed;
unsigned char data[1];
};
};
struct synaptics_rmi4_f1a_control {
struct synaptics_rmi4_f1a_control_0 general_control;
unsigned char button_int_enable;
unsigned char multi_button;
unsigned char *txrx_map;
unsigned char *button_threshold;
unsigned char button_release_threshold;
unsigned char strongest_button_hysteresis;
unsigned char filter_strength;
};
struct synaptics_rmi4_f1a_handle {
int button_bitmask_size;
unsigned char max_count;
unsigned char valid_button_count;
unsigned char *button_data_buffer;
unsigned char *button_map;
struct synaptics_rmi4_f1a_query button_query;
struct synaptics_rmi4_f1a_control button_control;
};
struct synaptics_rmi4_exp_fhandler {
struct synaptics_rmi4_exp_fn *exp_fn;
bool insert;
bool remove;
struct list_head link;
};
struct synaptics_rmi4_exp_fn_data {
bool initialized;
bool queue_work;
struct mutex mutex;
struct list_head list;
struct delayed_work work;
struct workqueue_struct *workqueue;
struct synaptics_rmi4_data *rmi4_data;
};
static struct synaptics_rmi4_exp_fn_data exp_data;
struct synaptics_dsx_button_map *vir_button_map;
static struct device_attribute attrs[] = {
#ifdef CONFIG_HAS_EARLYSUSPEND
__ATTR(full_pm_cycle, (S_IRUGO | S_IWUGO),
synaptics_rmi4_full_pm_cycle_show,
synaptics_rmi4_full_pm_cycle_store),
#endif
__ATTR(reset, S_IWUGO,
synaptics_rmi4_show_error,
synaptics_rmi4_f01_reset_store),
__ATTR(productinfo, S_IRUGO,
synaptics_rmi4_f01_productinfo_show,
synaptics_rmi4_store_error),
__ATTR(buildid, S_IRUGO,
synaptics_rmi4_f01_buildid_show,
synaptics_rmi4_store_error),
__ATTR(flashprog, S_IRUGO,
synaptics_rmi4_f01_flashprog_show,
synaptics_rmi4_store_error),
__ATTR(0dbutton, (S_IRUGO | S_IWUGO),
synaptics_rmi4_0dbutton_show,
synaptics_rmi4_0dbutton_store),
__ATTR(suspend, S_IWUGO,
synaptics_rmi4_show_error,
synaptics_rmi4_suspend_store),
__ATTR(wake_gesture, (S_IRUGO | S_IWUGO),
synaptics_rmi4_wake_gesture_show,
synaptics_rmi4_wake_gesture_store),
__ATTR(poll, S_IWUGO,
synaptics_rmi4_show_error,
synaptics_rmi4_poll_store),
__ATTR(palm_size, S_IRUGO | S_IWUSR | S_IWGRP,
synaptics_palm_size_show,
synaptics_palm_size_store),
__ATTR(mode, S_IRUGO | S_IWUSR | S_IWGRP,
synaptics_mode_show,
synaptics_mode_store),
};
static struct kobj_attribute virtual_key_map_attr = {
.attr = {
.name = VIRTUAL_KEY_MAP_FILE_NAME,
.mode = S_IRUGO,
},
.show = synaptics_rmi4_virtual_key_map_show,
};
static int extra_reg_addr(struct synaptics_rmi4_data *rmi4_data,
const char *reg_name)
{
int i;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
for (i = 0; i < bdata->extra_regs.size; i++)
if (!strncmp(bdata->extra_regs.info[i].name,
reg_name, strlen(reg_name)))
return bdata->extra_regs.info[i].addr;
return -EINVAL;
}
static ssize_t synaptics_palm_size_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_device_info *rmi;
int f11_ctrl_58;
if (!rmi4_data->has_large_obj_det)
return -EPERM;
rmi = &(rmi4_data->rmi4_mod_info);
if (list_empty(&rmi->support_fn_list))
return -ENODEV;
f11_ctrl_58 = extra_reg_addr(rmi4_data, "f11_ctrl_58");
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->fn_number == SYNAPTICS_RMI4_F11) {
unsigned char control58;
int retval = synaptics_rmi4_reg_read(rmi4_data,
f11_ctrl_58, &control58, sizeof(control58));
if (retval <= 0)
return -EIO;
return scnprintf(buf, PAGE_SIZE, "%u\n",
control58 & 0x7f);
}
}
return -ENODEV;
}
static int f11_set_large_obj_size(struct synaptics_rmi4_data *rmi4_data)
{
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_device_info *rmi;
int obj_size;
if (!rmi4_data->has_large_obj_det)
return -EPERM;
obj_size = rmi4_data->hw_if->board_data->large_obj_size;
dev_dbg(rmi4_data->pdev->dev.parent, "%s: obj_size=%u\n", __func__, obj_size);
if (obj_size < 0 || (unsigned)obj_size == rmi4_data->large_obj_size)
return 0;
rmi = &(rmi4_data->rmi4_mod_info);
if (list_empty(&rmi->support_fn_list))
return -ENODEV;
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->fn_number == SYNAPTICS_RMI4_F11) {
int retval;
unsigned char control58;
int f11_ctrl_58;
f11_ctrl_58 = extra_reg_addr(rmi4_data, "f11_ctrl_58");
retval = synaptics_rmi4_reg_read(rmi4_data,
f11_ctrl_58, &control58, sizeof(control58));
if (retval <= 0)
goto err;
control58 = (control58 & ~0x7f) | obj_size;
retval = synaptics_rmi4_reg_write(rmi4_data,
f11_ctrl_58, &control58, sizeof(control58));
if (retval <= 0)
goto err;
dev_dbg(rmi4_data->pdev->dev.parent,
"Large object size changed to %u\n",
obj_size);
return 0;
}
}
err:
return -EIO;
}
static ssize_t synaptics_palm_size_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned long obj_size;
int rc;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
if (kstrtoul(buf, 10, &obj_size) || obj_size > 0x7f)
return -EINVAL;
rmi4_data->hw_if->board_data->large_obj_size = obj_size;
rc = f11_set_large_obj_size(rmi4_data);
return rc ? rc : count;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static ssize_t synaptics_rmi4_full_pm_cycle_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n",
rmi4_data->full_pm_cycle);
}
static ssize_t synaptics_rmi4_full_pm_cycle_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int input;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
if (sscanf(buf, "%u", &input) != 1)
return -EINVAL;
rmi4_data->full_pm_cycle = input > 0 ? 1 : 0;
return count;
}
#endif
static ssize_t synaptics_rmi4_f01_reset_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int retval;
unsigned int reset;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
if (sscanf(buf, "%u", &reset) != 1)
return -EINVAL;
if (reset != 1)
return -EINVAL;
retval = synaptics_rmi4_reset_device(rmi4_data);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to issue reset command, error = %d\n",
__func__, retval);
return retval;
}
return count;
}
static ssize_t synaptics_rmi4_f01_productinfo_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "0x%02x 0x%02x\n",
(rmi4_data->rmi4_mod_info.product_info[0]),
(rmi4_data->rmi4_mod_info.product_info[1]));
}
static ssize_t synaptics_rmi4_f01_buildid_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n",
rmi4_data->firmware_id);
}
static ssize_t synaptics_rmi4_f01_flashprog_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int retval;
struct synaptics_rmi4_f01_device_status device_status;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_data_base_addr,
device_status.data,
sizeof(device_status.data));
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read device status, error = %d\n",
__func__, retval);
return retval;
}
return snprintf(buf, PAGE_SIZE, "%u\n",
device_status.flash_prog);
}
static ssize_t synaptics_rmi4_0dbutton_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n",
rmi4_data->button_0d_enabled);
}
static ssize_t synaptics_rmi4_0dbutton_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int retval;
unsigned int input;
unsigned char ii;
unsigned char intr_enable;
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
struct synaptics_rmi4_device_info *rmi;
rmi = &(rmi4_data->rmi4_mod_info);
if (sscanf(buf, "%u", &input) != 1)
return -EINVAL;
input = input > 0 ? 1 : 0;
if (rmi4_data->button_0d_enabled == input)
return count;
if (list_empty(&rmi->support_fn_list))
return -ENODEV;
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->fn_number == SYNAPTICS_RMI4_F1A) {
ii = fhandler->intr_reg_num;
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_ctrl_base_addr + 1 + ii,
&intr_enable,
sizeof(intr_enable));
if (retval < 0)
return retval;
if (input == 1)
intr_enable |= fhandler->intr_mask;
else
intr_enable &= ~fhandler->intr_mask;
retval = synaptics_rmi4_reg_write(rmi4_data,
rmi4_data->f01_ctrl_base_addr + 1 + ii,
&intr_enable,
sizeof(intr_enable));
if (retval < 0)
return retval;
}
}
rmi4_data->button_0d_enabled = input;
return count;
}
static ssize_t synaptics_rmi4_suspend_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int input;
if (sscanf(buf, "%u", &input) != 1)
return -EINVAL;
if (input == 1)
synaptics_rmi4_suspend(dev);
else if (input == 0)
synaptics_rmi4_resume(dev);
else
return -EINVAL;
return count;
}
static ssize_t synaptics_rmi4_wake_gesture_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n",
rmi4_data->enable_wakeup_gesture);
}
static ssize_t synaptics_rmi4_wake_gesture_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned int input;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
if (sscanf(buf, "%u", &input) != 1)
return -EINVAL;
input = input > 0 ? 1 : 0;
if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture)
rmi4_data->enable_wakeup_gesture = input;
return count;
}
static ssize_t synaptics_rmi4_virtual_key_map_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
int ii;
int cnt;
int count = 0;
for (ii = 0; ii < vir_button_map->nbuttons; ii++) {
cnt = snprintf(buf, PAGE_SIZE - count, "0x01:%d:%d:%d:%d:%d\n",
vir_button_map->map[ii * 5 + 0],
vir_button_map->map[ii * 5 + 1],
vir_button_map->map[ii * 5 + 2],
vir_button_map->map[ii * 5 + 3],
vir_button_map->map[ii * 5 + 4]);
buf += cnt;
count += cnt;
}
return count;
}
static ssize_t synaptics_rmi4_poll_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
unsigned long t;
struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
int rc;
rc = kstrtoul(buf, 10, &t);
if (rc)
return rc;
rmi4_data->poll = t;
rmi4_data->ktime = ktime_set(0, t * 1000000L);
return count;
}
static int synaptics_rmi4_f11_abs_report(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
int retval;
unsigned char touch_count = 0; /* number of touch points */
unsigned char reg_index;
unsigned char finger;
unsigned char fingers_supported;
unsigned char num_of_finger_status_regs;
unsigned char finger_shift;
unsigned char finger_status;
unsigned char finger_status_reg[3];
unsigned char detected_gestures;
unsigned char data28;
unsigned short data_addr;
unsigned short data_offset;
int x;
int y;
int wx;
int wy;
int temp;
struct synaptics_rmi4_f11_data_1_5 data;
struct synaptics_rmi4_f11_extra_data *extra_data;
/*
* The number of finger status registers is determined by the
* maximum number of fingers supported - 2 bits per finger. So
* the number of finger status registers to read is:
* register_count = ceil(max_num_of_fingers / 4)
*/
fingers_supported = fhandler->num_of_data_points;
num_of_finger_status_regs = (fingers_supported + 3) / 4;
data_addr = fhandler->full_addr.data_base;
extra_data = (struct synaptics_rmi4_f11_extra_data *)fhandler->extra;
if (rmi4_data->wakeup_gesture_active) {
if (rmi4_data->wg_sent) {
dev_dbg(rmi4_data->pdev->dev.parent,
"wg already sent\n");
return 0;
}
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr + extra_data->data38_offset,
&detected_gestures,
sizeof(detected_gestures));
if (retval < 0)
return 0;
if (detected_gestures) {
int key = rmi4_data->hw_if->board_data->wakeup_gest_key;
dev_info(rmi4_data->pdev->dev.parent, "detected_gestures %d\n",
detected_gestures);
input_report_key(rmi4_data->input_dev, key, 1);
input_sync(rmi4_data->input_dev);
input_report_key(rmi4_data->input_dev, key, 0);
input_sync(rmi4_data->input_dev);
rmi4_data->wg_sent = true;
rmi4_data->wg_ongoing = true;
rmi4_data->block_until_no_finger = true;
}
return 0;
}
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr,
finger_status_reg,
num_of_finger_status_regs);
if (retval < 0)
return 0;
if (rmi4_data->has_large_obj_det) {
if (!rmi4_data->wg_ongoing) {
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f11_data_28,
&data28, sizeof(data28));
if (retval >= 0) {
dev_dbg(rmi4_data->pdev->dev.parent,
"Large object present = %d",
!!(data28 & 0x02));
if (data28 & 0x02) {
input_report_key(rmi4_data->input_dev,
KEY_SLEEP, 1);
input_sync(rmi4_data->input_dev);
input_report_key(rmi4_data->input_dev,
KEY_SLEEP, 0);
input_sync(rmi4_data->input_dev);
}
}
}
}
if (rmi4_data->block_until_no_finger) {
finger = 0;
finger_status = 0;
while (finger < fingers_supported) {
reg_index = finger / 4;
finger_shift = (finger % 4) * 2;
if ((finger_status_reg[reg_index] >> finger_shift) &
MASK_2BIT)
return 0;
finger++;
}
rmi4_data->block_until_no_finger = false;
}
mutex_lock(&(rmi4_data->rmi4_report_mutex));
for (finger = 0; finger < fingers_supported; finger++) {
reg_index = finger / 4;
finger_shift = (finger % 4) * 2;
finger_status = (finger_status_reg[reg_index] >> finger_shift)
& MASK_2BIT;
/*
* Each 2-bit finger status field represents the following:
* 00 = finger not present
* 01 = finger present and data accurate
* 10 = finger present but data may be inaccurate
* 11 = reserved
*/
#ifdef TYPE_B_PROTOCOL
input_mt_slot(rmi4_data->input_dev, finger);
input_mt_report_slot_state(rmi4_data->input_dev,
MT_TOOL_FINGER, finger_status);
#endif
if (finger_status) {
data_offset = data_addr +
num_of_finger_status_regs +
(finger * sizeof(data.data));
retval = synaptics_rmi4_reg_read(rmi4_data,
data_offset,
data.data,
sizeof(data.data));
if (retval < 0) {
touch_count = 0;
goto exit;
}
x = (data.x_position_11_4 << 4) | data.x_position_3_0;
y = (data.y_position_11_4 << 4) | data.y_position_3_0;
wx = data.wx;
wy = data.wy;
if (rmi4_data->hw_if->board_data->swap_axes) {
temp = x;
x = y;
y = temp;
temp = wx;
wx = wy;
wy = temp;
}
if (rmi4_data->hw_if->board_data->x_flip)
x = rmi4_data->sensor_max_x - x;
if (rmi4_data->hw_if->board_data->y_flip)
y = rmi4_data->sensor_max_y - y;
input_report_key(rmi4_data->input_dev,
BTN_TOUCH, 1);
input_report_key(rmi4_data->input_dev,
BTN_TOOL_FINGER, 1);
input_report_abs(rmi4_data->input_dev,
ABS_MT_POSITION_X, x);
input_report_abs(rmi4_data->input_dev,
ABS_MT_POSITION_Y, y);
#ifdef REPORT_2D_W
input_report_abs(rmi4_data->input_dev,
ABS_MT_TOUCH_MAJOR, max(wx, wy));
input_report_abs(rmi4_data->input_dev,
ABS_MT_TOUCH_MINOR, min(wx, wy));
#endif
#ifndef TYPE_B_PROTOCOL
input_mt_sync(rmi4_data->input_dev);
#endif
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Finger %d:\n"
"status = 0x%02x\n"
"x = %d\n"
"y = %d\n"
"wx = %d\n"
"wy = %d\n",
__func__, finger,
finger_status,
x, y, wx, wy);
touch_count++;
}
}
if (touch_count == 0) {
if (rmi4_data->wg_ongoing)
rmi4_data->wg_ongoing = false;
input_report_key(rmi4_data->input_dev,
BTN_TOUCH, 0);
input_report_key(rmi4_data->input_dev,
BTN_TOOL_FINGER, 0);
#ifndef TYPE_B_PROTOCOL
input_mt_sync(rmi4_data->input_dev);
#endif
}
input_sync(rmi4_data->input_dev);
exit:
mutex_unlock(&(rmi4_data->rmi4_report_mutex));
return touch_count;
}
static int synaptics_rmi4_f12_abs_report(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
int retval;
unsigned char touch_count = 0; /* number of touch points */
unsigned char finger;
unsigned char fingers_to_process;
unsigned char finger_status;
unsigned char size_of_2d_data;
unsigned char detected_gestures;
unsigned short data_addr;
int x;
int y;
int wx;
int wy;
int temp;
struct synaptics_rmi4_f12_extra_data *extra_data;
struct synaptics_rmi4_f12_finger_data *data;
struct synaptics_rmi4_f12_finger_data *finger_data;
#ifdef F12_DATA_15_WORKAROUND
static unsigned char fingers_already_present;
#endif
fingers_to_process = fhandler->num_of_data_points;
data_addr = fhandler->full_addr.data_base;
extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra;
size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data);
if (rmi4_data->wakeup_gesture_active) {
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr + extra_data->data4_offset,
&detected_gestures,
sizeof(detected_gestures));
if (retval < 0)
return 0;
if (detected_gestures) {
int key = rmi4_data->hw_if->board_data->wakeup_gest_key;
input_report_key(rmi4_data->input_dev, key, 1);
input_sync(rmi4_data->input_dev);
input_report_key(rmi4_data->input_dev, key, 0);
input_sync(rmi4_data->input_dev);
synaptics_rmi4_f12_wg(rmi4_data, false);
}
return 0;
}
/* Determine the total number of fingers to process */
if (extra_data->data15_size) {
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr + extra_data->data15_offset,
extra_data->data15_data,
extra_data->data15_size);
if (retval < 0)
return 0;
/* Start checking from the highest bit */
temp = extra_data->data15_size - 1; /* Highest byte */
finger = (fingers_to_process - 1) % 8; /* Highest bit */
do {
if (extra_data->data15_data[temp] & (1 << finger))
break;
if (finger) {
finger--;
} else {
temp--; /* Move to the next lower byte */
finger = 7;
}
fingers_to_process--;
} while (fingers_to_process);
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Number of fingers to process = %d\n",
__func__, fingers_to_process);
}
#ifdef F12_DATA_15_WORKAROUND
fingers_to_process = max(fingers_to_process, fingers_already_present);
#endif
if (!fingers_to_process) {
synaptics_rmi4_free_fingers(rmi4_data);
return 0;
}
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr + extra_data->data1_offset,
(unsigned char *)fhandler->data,
fingers_to_process * size_of_2d_data);
if (retval < 0)
return 0;
data = (struct synaptics_rmi4_f12_finger_data *)fhandler->data;
mutex_lock(&(rmi4_data->rmi4_report_mutex));
for (finger = 0; finger < fingers_to_process; finger++) {
finger_data = data + finger;
finger_status = finger_data->object_type_and_status;
switch (finger_status) {
case F12_FINGER_STATUS:
case F12_GLOVED_FINGER_STATUS:
#ifdef TYPE_B_PROTOCOL
input_mt_slot(rmi4_data->input_dev, finger);
input_mt_report_slot_state(rmi4_data->input_dev,
MT_TOOL_FINGER, 1);
#endif
#ifdef F12_DATA_15_WORKAROUND
fingers_already_present = finger + 1;
#endif
x = (finger_data->x_msb << 8) | (finger_data->x_lsb);
y = (finger_data->y_msb << 8) | (finger_data->y_lsb);
#ifdef REPORT_2D_W
wx = finger_data->wx;
wy = finger_data->wy;
#endif
if (rmi4_data->hw_if->board_data->swap_axes) {
temp = x;
x = y;
y = temp;
temp = wx;
wx = wy;
wy = temp;
}
if (rmi4_data->hw_if->board_data->x_flip)
x = rmi4_data->sensor_max_x - x;
if (rmi4_data->hw_if->board_data->y_flip)
y = rmi4_data->sensor_max_y - y;
input_report_key(rmi4_data->input_dev,
BTN_TOUCH, 1);
input_report_key(rmi4_data->input_dev,
BTN_TOOL_FINGER, 1);
input_report_abs(rmi4_data->input_dev,
ABS_MT_POSITION_X, x);
input_report_abs(rmi4_data->input_dev,
ABS_MT_POSITION_Y, y);
#ifdef REPORT_2D_W
input_report_abs(rmi4_data->input_dev,
ABS_MT_TOUCH_MAJOR, max(wx, wy));
input_report_abs(rmi4_data->input_dev,
ABS_MT_TOUCH_MINOR, min(wx, wy));
#endif
#ifndef TYPE_B_PROTOCOL
input_mt_sync(rmi4_data->input_dev);
#endif
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Finger %d:\n"
"status = 0x%02x\n"
"x = %d\n"
"y = %d\n"
"wx = %d\n"
"wy = %d\n",
__func__, finger,
finger_status,
x, y, wx, wy);
touch_count++;
break;
default:
#ifdef TYPE_B_PROTOCOL
input_mt_slot(rmi4_data->input_dev, finger);
input_mt_report_slot_state(rmi4_data->input_dev,
MT_TOOL_FINGER, 0);
#endif
break;
}
}
if (touch_count == 0) {
#ifdef F12_DATA_15_WORKAROUND
fingers_already_present = 0;
#endif
input_report_key(rmi4_data->input_dev,
BTN_TOUCH, 0);
input_report_key(rmi4_data->input_dev,
BTN_TOOL_FINGER, 0);
#ifndef TYPE_B_PROTOCOL
input_mt_sync(rmi4_data->input_dev);
#endif
}
input_sync(rmi4_data->input_dev);
mutex_unlock(&(rmi4_data->rmi4_report_mutex));
return touch_count;
}
static void synaptics_rmi4_f1a_report(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
int retval;
unsigned char touch_count = 0;
unsigned char button;
unsigned char index;
unsigned char shift;
unsigned char status;
unsigned char *data;
unsigned short data_addr = fhandler->full_addr.data_base;
struct synaptics_rmi4_f1a_handle *f1a = fhandler->data;
static unsigned char do_once = 1;
static bool current_status[MAX_NUMBER_OF_BUTTONS];
#ifdef NO_0D_WHILE_2D
static bool before_2d_status[MAX_NUMBER_OF_BUTTONS];
static bool while_2d_status[MAX_NUMBER_OF_BUTTONS];
#endif
if (do_once) {
memset(current_status, 0, sizeof(current_status));
#ifdef NO_0D_WHILE_2D
memset(before_2d_status, 0, sizeof(before_2d_status));
memset(while_2d_status, 0, sizeof(while_2d_status));
#endif
do_once = 0;
}
retval = synaptics_rmi4_reg_read(rmi4_data,
data_addr,
f1a->button_data_buffer,
f1a->button_bitmask_size);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read button data registers\n",
__func__);
return;
}
data = f1a->button_data_buffer;
mutex_lock(&(rmi4_data->rmi4_report_mutex));
for (button = 0; button < f1a->valid_button_count; button++) {
index = button / 8;
shift = button % 8;
status = ((data[index] >> shift) & MASK_1BIT);
if (current_status[button] == status)
continue;
else
current_status[button] = status;
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Button %d (code %d) ->%d\n",
__func__, button,
f1a->button_map[button],
status);
#ifdef NO_0D_WHILE_2D
if (rmi4_data->fingers_on_2d == false) {
if (status == 1) {
before_2d_status[button] = 1;
} else {
if (while_2d_status[button] == 1) {
while_2d_status[button] = 0;
continue;
} else {
before_2d_status[button] = 0;
}
}
touch_count++;
input_report_key(rmi4_data->input_dev,
f1a->button_map[button],
status);
} else {
if (before_2d_status[button] == 1) {
before_2d_status[button] = 0;
touch_count++;
input_report_key(rmi4_data->input_dev,
f1a->button_map[button],
status);
} else {
if (status == 1)
while_2d_status[button] = 1;
else
while_2d_status[button] = 0;
}
}
#else
touch_count++;
input_report_key(rmi4_data->input_dev,
f1a->button_map[button],
status);
#endif
}
if (touch_count)
input_sync(rmi4_data->input_dev);
mutex_unlock(&(rmi4_data->rmi4_report_mutex));
return;
}
static void synaptics_rmi4_report_touch(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
unsigned char touch_count_2d;
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Function %02x reporting\n",
__func__, fhandler->fn_number);
switch (fhandler->fn_number) {
case SYNAPTICS_RMI4_F11:
touch_count_2d = synaptics_rmi4_f11_abs_report(rmi4_data,
fhandler);
if (touch_count_2d)
rmi4_data->fingers_on_2d = true;
else
rmi4_data->fingers_on_2d = false;
break;
case SYNAPTICS_RMI4_F12:
touch_count_2d = synaptics_rmi4_f12_abs_report(rmi4_data,
fhandler);
if (touch_count_2d)
rmi4_data->fingers_on_2d = true;
else
rmi4_data->fingers_on_2d = false;
break;
case SYNAPTICS_RMI4_F1A:
synaptics_rmi4_f1a_report(rmi4_data, fhandler);
break;
default:
break;
}
return;
}
static void synaptics_rmi4_sensor_report(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
unsigned char data[MAX_INTR_REGISTERS + 1];
unsigned char *intr = &data[1];
struct synaptics_rmi4_f01_device_status status;
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_exp_fhandler *exp_fhandler;
struct synaptics_rmi4_device_info *rmi;
rmi = &(rmi4_data->rmi4_mod_info);
/*
* Get interrupt status information from F01 Data1 register to
* determine the source(s) that are flagging the interrupt.
*/
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_data_base_addr,
data,
rmi4_data->num_of_intr_regs + 1);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read interrupt status\n",
__func__);
return;
}
status.data[0] = data[0];
if (status.unconfigured && !status.flash_prog) {
pr_notice("%s: spontaneous reset detected\n", __func__);
retval = synaptics_rmi4_reinit_device(rmi4_data);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to reinit device\n",
__func__);
}
}
/*
* Traverse the function handler list and service the source(s)
* of the interrupt accordingly.
*/
if (!list_empty(&rmi->support_fn_list)) {
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->num_of_data_sources) {
if (fhandler->intr_mask &
intr[fhandler->intr_reg_num]) {
synaptics_rmi4_report_touch(rmi4_data,
fhandler);
}
}
}
}
mutex_lock(&exp_data.mutex);
if (!list_empty(&exp_data.list)) {
list_for_each_entry(exp_fhandler, &exp_data.list, link) {
if (!exp_fhandler->insert &&
!exp_fhandler->remove &&
(exp_fhandler->exp_fn->attn != NULL))
exp_fhandler->exp_fn->attn(rmi4_data, intr[0]);
}
}
mutex_unlock(&exp_data.mutex);
return;
}
static irqreturn_t synaptics_rmi4_irq(int irq, void *data)
{
struct synaptics_rmi4_data *rmi4_data = data;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
if (gpio_get_value(bdata->irq_gpio) != bdata->irq_on_state)
goto exit;
if (!rmi4_data->poll)
synaptics_rmi4_sensor_report(rmi4_data);
exit:
return IRQ_HANDLED;
}
static enum hrtimer_restart synaptics_rmi4_hrtimer(struct hrtimer *timer)
{
struct synaptics_rmi4_data *rmi4_data =
container_of(timer, struct synaptics_rmi4_data, hr_timer);
if (rmi4_data->poll) {
schedule_work(&rmi4_data->poll_work);
hrtimer_start(&rmi4_data->hr_timer,
rmi4_data->ktime, HRTIMER_MODE_REL);
}
return HRTIMER_NORESTART;
}
static void synaptics_rmi4_data_poll(struct work_struct *work)
{
struct synaptics_rmi4_data *rmi4_data =
container_of(work, struct synaptics_rmi4_data, poll_work);
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_device_info *rmi = &(rmi4_data->rmi4_mod_info);
if (!list_empty(&rmi->support_fn_list)) {
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->num_of_data_sources) {
synaptics_rmi4_report_touch(rmi4_data,
fhandler);
}
}
}
}
static int synaptics_rmi4_int_enable(struct synaptics_rmi4_data *rmi4_data,
bool enable)
{
int retval = 0;
unsigned char ii;
unsigned char zero = 0x00;
unsigned char *intr_mask;
unsigned short intr_addr;
intr_mask = rmi4_data->intr_mask;
for (ii = 0; ii < rmi4_data->num_of_intr_regs; ii++) {
if (intr_mask[ii] != 0x00) {
intr_addr = rmi4_data->f01_ctrl_base_addr + 1 + ii;
if (enable) {
retval = synaptics_rmi4_reg_write(rmi4_data,
intr_addr,
&(intr_mask[ii]),
sizeof(intr_mask[ii]));
if (retval < 0)
return retval;
} else {
retval = synaptics_rmi4_reg_write(rmi4_data,
intr_addr,
&zero,
sizeof(zero));
if (retval < 0)
return retval;
}
}
}
return retval;
}
static int synaptics_rmi4_irq_enable(struct synaptics_rmi4_data *rmi4_data,
bool enable, bool attn_only)
{
int retval = 0;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
if (attn_only) {
retval = synaptics_rmi4_int_enable(rmi4_data, enable);
return retval;
}
if (enable) {
if (rmi4_data->irq_enabled)
return retval;
retval = synaptics_rmi4_int_enable(rmi4_data, false);
if (retval < 0)
return retval;
/* Process and clear interrupts */
synaptics_rmi4_sensor_report(rmi4_data);
if (rmi4_data->enable_wakeup_gesture) {
retval = request_threaded_irq(rmi4_data->irq, NULL,
synaptics_rmi4_irq, bdata->irq_flags |
IRQF_NO_SUSPEND,
PLATFORM_DRIVER_NAME, rmi4_data);
if (retval < 0)
irq_set_irq_wake(rmi4_data->irq, 1);
} else {
retval = request_threaded_irq(rmi4_data->irq, NULL,
synaptics_rmi4_irq, bdata->irq_flags,
PLATFORM_DRIVER_NAME, rmi4_data);
}
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to create irq thread\n",
__func__);
return retval;
}
retval = synaptics_rmi4_int_enable(rmi4_data, true);
if (retval < 0)
return retval;
rmi4_data->irq_enabled = true;
if (rmi4_data->poll)
hrtimer_start(&rmi4_data->hr_timer,
rmi4_data->ktime, HRTIMER_MODE_REL);
} else {
if (rmi4_data->irq_enabled) {
disable_irq(rmi4_data->irq);
free_irq(rmi4_data->irq, rmi4_data);
rmi4_data->irq_enabled = false;
if (rmi4_data->poll) {
hrtimer_cancel(&rmi4_data->hr_timer);
cancel_work_sync(&rmi4_data->poll_work);
}
}
}
return retval;
}
static void synaptics_rmi4_set_intr_mask(struct synaptics_rmi4_fn *fhandler,
struct synaptics_rmi4_fn_desc *fd,
unsigned int intr_count)
{
unsigned char ii;
unsigned char intr_offset;
fhandler->intr_reg_num = (intr_count + 7) / 8;
if (fhandler->intr_reg_num != 0)
fhandler->intr_reg_num -= 1;
/* Set an enable bit for each data source */
intr_offset = intr_count % 8;
fhandler->intr_mask = 0;
for (ii = intr_offset;
ii < ((fd->intr_src_count & MASK_3BIT) +
intr_offset);
ii++)
fhandler->intr_mask |= 1 << ii;
return;
}
static int synaptics_rmi4_f01_init(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler,
struct synaptics_rmi4_fn_desc *fd,
unsigned int intr_count)
{
fhandler->fn_number = fd->fn_number;
fhandler->num_of_data_sources = fd->intr_src_count;
fhandler->data = NULL;
fhandler->extra = NULL;
synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count);
rmi4_data->f01_query_base_addr = fd->query_base_addr;
rmi4_data->f01_ctrl_base_addr = fd->ctrl_base_addr;
rmi4_data->f01_data_base_addr = fd->data_base_addr;
rmi4_data->f01_cmd_base_addr = fd->cmd_base_addr;
return 0;
}
static int synaptics_rmi4_f11_init(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler,
struct synaptics_rmi4_fn_desc *fd,
unsigned int intr_count)
{
int retval;
unsigned char offset;
unsigned char fingers_supported;
struct synaptics_rmi4_f11_extra_data *extra_data;
struct synaptics_rmi4_f11_query_0_5 query_0_5;
struct synaptics_rmi4_f11_query_7_8 query_7_8;
struct synaptics_rmi4_f11_query_9 query_9;
struct synaptics_rmi4_f11_query_12 query_12;
struct synaptics_rmi4_f11_query_27 query_27;
struct synaptics_rmi4_f11_ctrl_6_9 control_6_9;
unsigned char control58;
int f11_ctrl_58;
int f11_data_28;
fhandler->fn_number = fd->fn_number;
fhandler->num_of_data_sources = fd->intr_src_count;
fhandler->extra = kmalloc(sizeof(*extra_data), GFP_KERNEL);
extra_data = (struct synaptics_rmi4_f11_extra_data *)fhandler->extra;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base,
query_0_5.data,
sizeof(query_0_5.data));
if (retval < 0)
return retval;
/* Maximum number of fingers supported */
if (query_0_5.num_of_fingers <= 4)
fhandler->num_of_data_points = query_0_5.num_of_fingers + 1;
else if (query_0_5.num_of_fingers == 5)
fhandler->num_of_data_points = 10;
f11_ctrl_58 = extra_reg_addr(rmi4_data, "f11_ctrl_58");
f11_data_28 = extra_reg_addr(rmi4_data, "f11_data_28");
rmi4_data->has_large_obj_det = f11_ctrl_58 != -EINVAL &&
f11_data_28 != -EINVAL &&
query_0_5.has_large_object_suppression;
rmi4_data->f11_data_28 = f11_data_28;
dev_dbg(rmi4_data->pdev->dev.parent,
"Large object supported = %d (data_28 %x, ctrl_58 %x)",
rmi4_data->has_large_obj_det,
f11_data_28, f11_ctrl_58);
rmi4_data->num_of_fingers = fhandler->num_of_data_points;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.ctrl_base + 6,
control_6_9.data,
sizeof(control_6_9.data));
if (retval < 0)
return retval;
/* Maximum x and y */
rmi4_data->sensor_max_x = control_6_9.sensor_max_x_pos_7_0 |
(control_6_9.sensor_max_x_pos_11_8 << 8);
rmi4_data->sensor_max_y = control_6_9.sensor_max_y_pos_7_0 |
(control_6_9.sensor_max_y_pos_11_8 << 8);
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Function %02x max x = %d max y = %d\n",
__func__, fhandler->fn_number,
rmi4_data->sensor_max_x,
rmi4_data->sensor_max_y);
if (rmi4_data->has_large_obj_det) {
retval = synaptics_rmi4_reg_read(rmi4_data, f11_ctrl_58,
&control58, sizeof(control58));
if (rmi4_data->hw_if->board_data->large_obj_size >= 0) {
int los = rmi4_data->hw_if->board_data->large_obj_size;
control58 = (control58 & ~0x7f) | los;
retval = synaptics_rmi4_reg_write(rmi4_data,
f11_ctrl_58, &control58, sizeof(control58));
}
rmi4_data->large_obj_size = control58 & 0x7f;
dev_dbg(rmi4_data->pdev->dev.parent,
"Large object size = %d\n",
rmi4_data->large_obj_size);
dev_dbg(rmi4_data->pdev->dev.parent,
"Suppress ATTN = %d\n", !!(control58 & 0x80));
}
rmi4_data->max_touch_width = MAX_F11_TOUCH_WIDTH;
synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count);
fhandler->data = NULL;
offset = sizeof(query_0_5.data);
/* query 6 */
if (query_0_5.has_rel)
offset += 1;
/* queries 7 8 */
if (query_0_5.has_gestures) {
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + offset,
query_7_8.data,
sizeof(query_7_8.data));
if (retval < 0)
return retval;
offset += sizeof(query_7_8.data);
}
/* query 9 */
if (query_0_5.has_query_9) {
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + offset,
query_9.data,
sizeof(query_9.data));
if (retval < 0)
return retval;
offset += sizeof(query_9.data);
}
/* query 10 */
if (query_0_5.has_gestures && query_7_8.has_touch_shapes)
offset += 1;
/* query 11 */
if (query_0_5.has_query_11)
offset += 1;
/* query 12 */
if (query_0_5.has_query_12) {
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + offset,
query_12.data,
sizeof(query_12.data));
if (retval < 0)
return retval;
offset += sizeof(query_12.data);
}
/* query 13 */
if (query_0_5.has_jitter_filter)
offset += 1;
/* query 14 */
if (query_0_5.has_query_12 && query_12.has_general_information_2)
offset += 1;
/* queries 15 16 17 18 19 20 21 22 23 24 25 26*/
if (query_0_5.has_query_12 && query_12.has_physical_properties)
offset += 12;
/* query 27 */
if (query_0_5.has_query_27) {
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + offset,
query_27.data,
sizeof(query_27.data));
if (retval < 0)
return retval;
rmi4_data->f11_wakeup_gesture = query_27.has_wakeup_gesture;
}
if (!rmi4_data->f11_wakeup_gesture)
return retval;
/* data 0 */
fingers_supported = fhandler->num_of_data_points;
offset = (fingers_supported + 3) / 4;
/* data 1 2 3 4 5 */
offset += 5 * fingers_supported;
/* data 6 7 */
if (query_0_5.has_rel)
offset += 2 * fingers_supported;
/* data 8 */
if (query_0_5.has_gestures && query_7_8.data[0])
offset += 1;
/* data 9 */
if (query_0_5.has_gestures && (query_7_8.data[0] || query_7_8.data[1]))
offset += 1;
/* data 10 */
if (query_0_5.has_gestures &&
(query_7_8.has_pinch || query_7_8.has_flick))
offset += 1;
/* data 11 12 */
if (query_0_5.has_gestures &&
(query_7_8.has_flick || query_7_8.has_rotate))
offset += 2;
/* data 13 */
if (query_0_5.has_gestures && query_7_8.has_touch_shapes)
offset += (fingers_supported + 3) / 4;
/* data 14 15 */
if (query_0_5.has_gestures &&
(query_7_8.has_scroll_zones ||
query_7_8.has_multi_finger_scroll ||
query_7_8.has_chiral_scroll))
offset += 2;
/* data 16 17 */
if (query_0_5.has_gestures &&
(query_7_8.has_scroll_zones &&
query_7_8.individual_scroll_zones))
offset += 2;
/* data 18 19 20 21 22 23 24 25 26 27 */
if (query_0_5.has_query_9 && query_9.has_contact_geometry)
offset += 10 * fingers_supported;
/* data 28 */
if (query_0_5.has_bending_correction ||
query_0_5.has_large_object_suppression)
offset += 1;
/* data 29 30 31 */
if (query_0_5.has_query_9 && query_9.has_pen_hover_discrimination)
offset += 3;
/* data 32 */
if (query_0_5.has_query_12 &&
query_12.has_small_object_detection_tuning)
offset += 1;
/* data 33 34 */
if (query_0_5.has_query_27 && query_27.f11_query27_b0)
offset += 2;
/* data 35 */
if (query_0_5.has_query_12 && query_12.has_8bit_w)
offset += fingers_supported;
/* data 36 */
if (query_0_5.has_bending_correction)
offset += 1;
/* data 37 */
if (query_0_5.has_query_27 && query_27.has_data_37)
offset += 1;
/* data 38 */
if (query_0_5.has_query_27 && query_27.has_wakeup_gesture)
extra_data->data38_offset = offset;
return retval;
}
static int synaptics_rmi4_f12_set_enables(struct synaptics_rmi4_data *rmi4_data,
unsigned short ctrl28)
{
int retval;
static unsigned short ctrl_28_address;
if (ctrl28)
ctrl_28_address = ctrl28;
retval = synaptics_rmi4_reg_write(rmi4_data,
ctrl_28_address,
&rmi4_data->report_enable,
sizeof(rmi4_data->report_enable));
if (retval < 0)
return retval;
return retval;
}
static int synaptics_rmi4_f12_init(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler,
struct synaptics_rmi4_fn_desc *fd,
unsigned int intr_count)
{
int retval;
unsigned char size_of_2d_data;
unsigned char size_of_query8;
unsigned char ctrl_8_offset;
unsigned char ctrl_20_offset;
unsigned char ctrl_23_offset;
unsigned char ctrl_28_offset;
unsigned char num_of_fingers;
struct synaptics_rmi4_f12_extra_data *extra_data;
struct synaptics_rmi4_f12_query_5 query_5;
struct synaptics_rmi4_f12_query_8 query_8;
struct synaptics_rmi4_f12_ctrl_8 ctrl_8;
struct synaptics_rmi4_f12_ctrl_23 ctrl_23;
fhandler->fn_number = fd->fn_number;
fhandler->num_of_data_sources = fd->intr_src_count;
fhandler->extra = kmalloc(sizeof(*extra_data), GFP_KERNEL);
extra_data = (struct synaptics_rmi4_f12_extra_data *)fhandler->extra;
size_of_2d_data = sizeof(struct synaptics_rmi4_f12_finger_data);
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + 5,
query_5.data,
sizeof(query_5.data));
if (retval < 0)
return retval;
ctrl_8_offset = query_5.ctrl0_is_present +
query_5.ctrl1_is_present +
query_5.ctrl2_is_present +
query_5.ctrl3_is_present +
query_5.ctrl4_is_present +
query_5.ctrl5_is_present +
query_5.ctrl6_is_present +
query_5.ctrl7_is_present;
ctrl_20_offset = ctrl_8_offset +
query_5.ctrl8_is_present +
query_5.ctrl9_is_present +
query_5.ctrl10_is_present +
query_5.ctrl11_is_present +
query_5.ctrl12_is_present +
query_5.ctrl13_is_present +
query_5.ctrl14_is_present +
query_5.ctrl15_is_present +
query_5.ctrl16_is_present +
query_5.ctrl17_is_present +
query_5.ctrl18_is_present +
query_5.ctrl19_is_present;
ctrl_23_offset = ctrl_20_offset +
query_5.ctrl20_is_present +
query_5.ctrl21_is_present +
query_5.ctrl22_is_present;
ctrl_28_offset = ctrl_23_offset +
query_5.ctrl23_is_present +
query_5.ctrl24_is_present +
query_5.ctrl25_is_present +
query_5.ctrl26_is_present +
query_5.ctrl27_is_present;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.ctrl_base + ctrl_23_offset,
ctrl_23.data,
sizeof(ctrl_23.data));
if (retval < 0)
return retval;
/* Maximum number of fingers supported */
fhandler->num_of_data_points = min(ctrl_23.max_reported_objects,
(unsigned char)F12_FINGERS_TO_SUPPORT);
num_of_fingers = fhandler->num_of_data_points;
rmi4_data->num_of_fingers = num_of_fingers;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + 7,
&size_of_query8,
sizeof(size_of_query8));
if (retval < 0)
return retval;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base + 8,
query_8.data,
size_of_query8);
if (retval < 0)
return retval;
/* Determine the presence of the Data0 register */
extra_data->data1_offset = query_8.data0_is_present;
if ((size_of_query8 >= 3) && (query_8.data15_is_present)) {
extra_data->data15_offset = query_8.data0_is_present +
query_8.data1_is_present +
query_8.data2_is_present +
query_8.data3_is_present +
query_8.data4_is_present +
query_8.data5_is_present +
query_8.data6_is_present +
query_8.data7_is_present +
query_8.data8_is_present +
query_8.data9_is_present +
query_8.data10_is_present +
query_8.data11_is_present +
query_8.data12_is_present +
query_8.data13_is_present +
query_8.data14_is_present;
extra_data->data15_size = (num_of_fingers + 7) / 8;
} else {
extra_data->data15_size = 0;
}
rmi4_data->report_enable = RPT_DEFAULT;
#ifdef REPORT_2D_Z
rmi4_data->report_enable |= RPT_Z;
#endif
#ifdef REPORT_2D_W
rmi4_data->report_enable |= (RPT_WX | RPT_WY);
#endif
retval = synaptics_rmi4_f12_set_enables(rmi4_data,
fhandler->full_addr.ctrl_base + ctrl_28_offset);
if (retval < 0)
return retval;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.ctrl_base + ctrl_8_offset,
ctrl_8.data,
sizeof(ctrl_8.data));
if (retval < 0)
return retval;
/* Maximum x and y */
rmi4_data->sensor_max_x =
((unsigned short)ctrl_8.max_x_coord_lsb << 0) |
((unsigned short)ctrl_8.max_x_coord_msb << 8);
rmi4_data->sensor_max_y =
((unsigned short)ctrl_8.max_y_coord_lsb << 0) |
((unsigned short)ctrl_8.max_y_coord_msb << 8);
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Function %02x max x = %d max y = %d\n",
__func__, fhandler->fn_number,
rmi4_data->sensor_max_x,
rmi4_data->sensor_max_y);
rmi4_data->num_of_rx = ctrl_8.num_of_rx;
rmi4_data->num_of_tx = ctrl_8.num_of_tx;
rmi4_data->max_touch_width = max(rmi4_data->num_of_rx,
rmi4_data->num_of_tx);
rmi4_data->f12_wakeup_gesture = query_5.ctrl27_is_present;
if (rmi4_data->f12_wakeup_gesture) {
extra_data->ctrl20_offset = ctrl_20_offset;
extra_data->data4_offset = query_8.data0_is_present +
query_8.data1_is_present +
query_8.data2_is_present +
query_8.data3_is_present;
}
synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count);
/* Allocate memory for finger data storage space */
fhandler->data_size = num_of_fingers * size_of_2d_data;
fhandler->data = kmalloc(fhandler->data_size, GFP_KERNEL);
return retval;
}
static int synaptics_rmi4_f1a_alloc_mem(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
int retval;
struct synaptics_rmi4_f1a_handle *f1a;
f1a = kzalloc(sizeof(*f1a), GFP_KERNEL);
if (!f1a) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for function handle\n",
__func__);
return -ENOMEM;
}
fhandler->data = (void *)f1a;
fhandler->extra = NULL;
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.query_base,
f1a->button_query.data,
sizeof(f1a->button_query.data));
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read query registers\n",
__func__);
return retval;
}
f1a->max_count = f1a->button_query.max_button_count + 1;
f1a->button_control.txrx_map = kzalloc(f1a->max_count * 2, GFP_KERNEL);
if (!f1a->button_control.txrx_map) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for tx rx mapping\n",
__func__);
return -ENOMEM;
}
f1a->button_bitmask_size = (f1a->max_count + 7) / 8;
f1a->button_data_buffer = kcalloc(f1a->button_bitmask_size,
sizeof(*(f1a->button_data_buffer)), GFP_KERNEL);
if (!f1a->button_data_buffer) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for data buffer\n",
__func__);
return -ENOMEM;
}
f1a->button_map = kcalloc(f1a->max_count,
sizeof(*(f1a->button_map)), GFP_KERNEL);
if (!f1a->button_map) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for button map\n",
__func__);
return -ENOMEM;
}
return 0;
}
static int synaptics_rmi4_f1a_button_map(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler)
{
int retval;
unsigned char ii;
unsigned char mapping_offset = 0;
struct synaptics_rmi4_f1a_handle *f1a = fhandler->data;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
mapping_offset = f1a->button_query.has_general_control +
f1a->button_query.has_interrupt_enable +
f1a->button_query.has_multibutton_select;
if (f1a->button_query.has_tx_rx_map) {
retval = synaptics_rmi4_reg_read(rmi4_data,
fhandler->full_addr.ctrl_base + mapping_offset,
f1a->button_control.txrx_map,
f1a->max_count * 2);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read tx rx mapping\n",
__func__);
return retval;
}
rmi4_data->button_txrx_mapping = f1a->button_control.txrx_map;
}
if (!bdata->cap_button_map) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: cap_button_map is NULL in board file\n",
__func__);
return -ENODEV;
} else if (!bdata->cap_button_map->map) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Button map is missing in board file\n",
__func__);
return -ENODEV;
} else {
if (bdata->cap_button_map->nbuttons != f1a->max_count) {
f1a->valid_button_count = min(f1a->max_count,
bdata->cap_button_map->nbuttons);
} else {
f1a->valid_button_count = f1a->max_count;
}
for (ii = 0; ii < f1a->valid_button_count; ii++)
f1a->button_map[ii] = bdata->cap_button_map->map[ii];
}
return 0;
}
static void synaptics_rmi4_f1a_kfree(struct synaptics_rmi4_fn *fhandler)
{
struct synaptics_rmi4_f1a_handle *f1a = fhandler->data;
if (f1a) {
kfree(f1a->button_control.txrx_map);
kfree(f1a->button_data_buffer);
kfree(f1a->button_map);
kfree(f1a);
fhandler->data = NULL;
}
return;
}
static int synaptics_rmi4_f1a_init(struct synaptics_rmi4_data *rmi4_data,
struct synaptics_rmi4_fn *fhandler,
struct synaptics_rmi4_fn_desc *fd,
unsigned int intr_count)
{
int retval;
fhandler->fn_number = fd->fn_number;
fhandler->num_of_data_sources = fd->intr_src_count;
synaptics_rmi4_set_intr_mask(fhandler, fd, intr_count);
retval = synaptics_rmi4_f1a_alloc_mem(rmi4_data, fhandler);
if (retval < 0)
goto error_exit;
retval = synaptics_rmi4_f1a_button_map(rmi4_data, fhandler);
if (retval < 0)
goto error_exit;
rmi4_data->button_0d_enabled = 1;
return 0;
error_exit:
synaptics_rmi4_f1a_kfree(fhandler);
return retval;
}
static void synaptics_rmi4_empty_fn_list(struct synaptics_rmi4_data *rmi4_data)
{
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_fn *fhandler_temp;
struct synaptics_rmi4_device_info *rmi;
rmi = &(rmi4_data->rmi4_mod_info);
if (!list_empty(&rmi->support_fn_list)) {
list_for_each_entry_safe(fhandler,
fhandler_temp,
&rmi->support_fn_list,
link) {
if (fhandler->fn_number == SYNAPTICS_RMI4_F1A) {
synaptics_rmi4_f1a_kfree(fhandler);
} else {
kfree(fhandler->extra);
kfree(fhandler->data);
}
list_del(&fhandler->link);
kfree(fhandler);
}
}
INIT_LIST_HEAD(&rmi->support_fn_list);
return;
}
static int synaptics_rmi4_check_status(struct synaptics_rmi4_data *rmi4_data,
bool *was_in_bl_mode)
{
int retval;
int timeout = CHECK_STATUS_TIMEOUT_MS;
unsigned char intr_status;
struct synaptics_rmi4_f01_device_status status;
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_data_base_addr,
status.data,
sizeof(status.data));
if (retval < 0)
return retval;
while (status.status_code == STATUS_CRC_IN_PROGRESS) {
if (timeout > 0)
msleep(20);
else
return -1;
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_data_base_addr,
status.data,
sizeof(status.data));
if (retval < 0)
return retval;
timeout -= 20;
}
if (timeout != CHECK_STATUS_TIMEOUT_MS)
*was_in_bl_mode = true;
if (status.flash_prog == 1) {
rmi4_data->flash_prog_mode = true;
pr_notice("%s: In flash prog mode, status = 0x%02x\n",
__func__,
status.status_code);
} else {
rmi4_data->flash_prog_mode = false;
}
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_data_base_addr + 1,
&intr_status,
sizeof(intr_status));
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to read interrupt status\n",
__func__);
return retval;
}
return 0;
}
static void synaptics_rmi4_set_configured(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
unsigned char device_ctrl;
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_ctrl_base_addr,
&device_ctrl,
sizeof(device_ctrl));
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to set configured\n",
__func__);
return;
}
rmi4_data->no_sleep_setting = device_ctrl & NO_SLEEP_ON;
device_ctrl |= CONFIGURED;
retval = synaptics_rmi4_reg_write(rmi4_data,
rmi4_data->f01_ctrl_base_addr,
&device_ctrl,
sizeof(device_ctrl));
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to set configured\n",
__func__);
}
return;
}
static int synaptics_rmi4_alloc_fh(struct synaptics_rmi4_fn **fhandler,
struct synaptics_rmi4_fn_desc *rmi_fd, int page_number)
{
*fhandler = kmalloc(sizeof(**fhandler), GFP_KERNEL);
if (!(*fhandler))
return -ENOMEM;
(*fhandler)->full_addr.data_base =
(rmi_fd->data_base_addr |
(page_number << 8));
(*fhandler)->full_addr.ctrl_base =
(rmi_fd->ctrl_base_addr |
(page_number << 8));
(*fhandler)->full_addr.cmd_base =
(rmi_fd->cmd_base_addr |
(page_number << 8));
(*fhandler)->full_addr.query_base =
(rmi_fd->query_base_addr |
(page_number << 8));
return 0;
}
static int synaptics_rmi4_query_device(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
unsigned char page_number;
unsigned char intr_count;
unsigned char f01_query[F01_STD_QUERY_LEN];
unsigned short pdt_entry_addr;
bool f01found;
bool was_in_bl_mode;
struct synaptics_rmi4_fn_desc rmi_fd;
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_device_info *rmi;
rmi = &(rmi4_data->rmi4_mod_info);
rescan_pdt:
f01found = false;
was_in_bl_mode = false;
intr_count = 0;
INIT_LIST_HEAD(&rmi->support_fn_list);
/* Scan the page description tables of the pages to service */
for (page_number = 0; page_number < PAGES_TO_SERVICE; page_number++) {
for (pdt_entry_addr = PDT_START; pdt_entry_addr > PDT_END;
pdt_entry_addr -= PDT_ENTRY_SIZE) {
pdt_entry_addr |= (page_number << 8);
retval = synaptics_rmi4_reg_read(rmi4_data,
pdt_entry_addr,
(unsigned char *)&rmi_fd,
sizeof(rmi_fd));
if (retval < 0)
return retval;
pdt_entry_addr &= ~(MASK_8BIT << 8);
fhandler = NULL;
if (rmi_fd.fn_number == 0) {
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Reached end of PDT\n",
__func__);
break;
}
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: F%02x found (page %d)\n",
__func__, rmi_fd.fn_number,
page_number);
switch (rmi_fd.fn_number) {
case SYNAPTICS_RMI4_F01:
if (rmi_fd.intr_src_count == 0)
break;
f01found = true;
retval = synaptics_rmi4_alloc_fh(&fhandler,
&rmi_fd, page_number);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc for F%d\n",
__func__,
rmi_fd.fn_number);
return retval;
}
retval = synaptics_rmi4_f01_init(rmi4_data,
fhandler, &rmi_fd, intr_count);
if (retval < 0)
return retval;
retval = synaptics_rmi4_check_status(rmi4_data,
&was_in_bl_mode);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to check status\n",
__func__);
return retval;
}
if (was_in_bl_mode) {
kfree(fhandler);
fhandler = NULL;
goto rescan_pdt;
}
if (rmi4_data->flash_prog_mode)
goto flash_prog_mode;
break;
case SYNAPTICS_RMI4_F11:
if (rmi_fd.intr_src_count == 0)
break;
retval = synaptics_rmi4_alloc_fh(&fhandler,
&rmi_fd, page_number);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc for F%d\n",
__func__,
rmi_fd.fn_number);
return retval;
}
retval = synaptics_rmi4_f11_init(rmi4_data,
fhandler, &rmi_fd, intr_count);
if (retval < 0)
return retval;
break;
case SYNAPTICS_RMI4_F12:
if (rmi_fd.intr_src_count == 0)
break;
retval = synaptics_rmi4_alloc_fh(&fhandler,
&rmi_fd, page_number);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc for F%d\n",
__func__,
rmi_fd.fn_number);
return retval;
}
retval = synaptics_rmi4_f12_init(rmi4_data,
fhandler, &rmi_fd, intr_count);
if (retval < 0)
return retval;
break;
case SYNAPTICS_RMI4_F1A:
if (rmi_fd.intr_src_count == 0)
break;
retval = synaptics_rmi4_alloc_fh(&fhandler,
&rmi_fd, page_number);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc for F%d\n",
__func__,
rmi_fd.fn_number);
return retval;
}
retval = synaptics_rmi4_f1a_init(rmi4_data,
fhandler, &rmi_fd, intr_count);
if (retval < 0) {
#ifdef IGNORE_FN_INIT_FAILURE
kfree(fhandler);
fhandler = NULL;
#else
return retval;
#endif
}
break;
}
/* Accumulate the interrupt count */
intr_count += (rmi_fd.intr_src_count & MASK_3BIT);
if (fhandler && rmi_fd.intr_src_count) {
list_add_tail(&fhandler->link,
&rmi->support_fn_list);
}
}
}
if (!f01found) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to find F01\n",
__func__);
return -EINVAL;
}
flash_prog_mode:
rmi4_data->num_of_intr_regs = (intr_count + 7) / 8;
dev_dbg(rmi4_data->pdev->dev.parent,
"%s: Number of interrupt registers = %d\n",
__func__, rmi4_data->num_of_intr_regs);
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_query_base_addr,
f01_query,
sizeof(f01_query));
if (retval < 0)
return retval;
/* RMI Version 4.0 currently supported */
rmi->version_major = 4;
rmi->version_minor = 0;
rmi->manufacturer_id = f01_query[0];
rmi->product_props = f01_query[1];
rmi->product_info[0] = f01_query[2];
rmi->product_info[1] = f01_query[3];
memcpy(rmi->product_id_string, &f01_query[11], 10);
if (rmi->manufacturer_id != 1) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Non-Synaptics device found, manufacturer ID = %d\n",
__func__, rmi->manufacturer_id);
}
retval = synaptics_rmi4_reg_read(rmi4_data,
rmi4_data->f01_query_base_addr + F01_BUID_ID_OFFSET,
rmi->build_id,
sizeof(rmi->build_id));
if (retval < 0)
return retval;
rmi4_data->firmware_id = (unsigned int)rmi->build_id[0] +
(unsigned int)rmi->build_id[1] * 0x100 +
(unsigned int)rmi->build_id[2] * 0x10000;
memset(rmi4_data->intr_mask, 0x00, sizeof(rmi4_data->intr_mask));
/*
* Map out the interrupt bit masks for the interrupt sources
* from the registered function handlers.
*/
if (!list_empty(&rmi->support_fn_list)) {
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->num_of_data_sources) {
rmi4_data->intr_mask[fhandler->intr_reg_num] |=
fhandler->intr_mask;
}
}
}
if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture) {
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
rmi4_data->enable_wakeup_gesture = bdata->wakeup_gest_key > 0;
} else {
rmi4_data->enable_wakeup_gesture = false;
}
if (rmi4_data->enable_wakeup_gesture)
device_init_wakeup(rmi4_data->pdev->dev.parent, 1);
synaptics_rmi4_set_configured(rmi4_data);
return 0;
}
static int synaptics_rmi4_gpio_setup(int gpio, bool config, int dir, int state)
{
int retval = 0;
unsigned char buf[16];
if (config) {
snprintf(buf, PAGE_SIZE, "dsx_gpio_%u\n", gpio);
retval = gpio_request(gpio, buf);
if (retval) {
pr_err("%s: Failed to get gpio %d (code: %d)",
__func__, gpio, retval);
return retval;
}
if (dir == 0)
retval = gpio_direction_input(gpio);
else
retval = gpio_direction_output(gpio, state);
if (retval) {
pr_err("%s: Failed to set gpio %d direction",
__func__, gpio);
return retval;
}
} else {
gpio_free(gpio);
}
return retval;
}
static void synaptics_rmi4_set_params(struct synaptics_rmi4_data *rmi4_data)
{
unsigned char ii;
struct synaptics_rmi4_f1a_handle *f1a;
struct synaptics_rmi4_fn *fhandler;
struct synaptics_rmi4_device_info *rmi;
rmi = &(rmi4_data->rmi4_mod_info);
input_set_abs_params(rmi4_data->input_dev,
ABS_MT_POSITION_X, 0,
rmi4_data->sensor_max_x, 0, 0);
input_set_abs_params(rmi4_data->input_dev,
ABS_MT_POSITION_Y, 0,
rmi4_data->sensor_max_y, 0, 0);
#ifdef REPORT_2D_W
input_set_abs_params(rmi4_data->input_dev,
ABS_MT_TOUCH_MAJOR, 0,
rmi4_data->max_touch_width, 0, 0);
input_set_abs_params(rmi4_data->input_dev,
ABS_MT_TOUCH_MINOR, 0,
rmi4_data->max_touch_width, 0, 0);
#endif
#ifdef TYPE_B_PROTOCOL
input_mt_init_slots(rmi4_data->input_dev,
rmi4_data->num_of_fingers, INPUT_MT_DIRECT);
#endif
f1a = NULL;
if (!list_empty(&rmi->support_fn_list)) {
list_for_each_entry(fhandler, &rmi->support_fn_list, link) {
if (fhandler->fn_number == SYNAPTICS_RMI4_F1A)
f1a = fhandler->data;
}
}
if (f1a) {
for (ii = 0; ii < f1a->valid_button_count; ii++) {
set_bit(f1a->button_map[ii],
rmi4_data->input_dev->keybit);
input_set_capability(rmi4_data->input_dev,
EV_KEY, f1a->button_map[ii]);
}
}
if (vir_button_map->nbuttons) {
for (ii = 0; ii < vir_button_map->nbuttons; ii++) {
set_bit(vir_button_map->map[ii * 5],
rmi4_data->input_dev->keybit);
input_set_capability(rmi4_data->input_dev,
EV_KEY, vir_button_map->map[ii * 5]);
}
}
if (rmi4_data->f11_wakeup_gesture || rmi4_data->f12_wakeup_gesture) {
int key = rmi4_data->hw_if->board_data->wakeup_gest_key;
if (key > 0)
input_set_capability(rmi4_data->input_dev, EV_KEY, key);
}
return;
}
static int synaptics_rmi4_set_input_dev(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
int temp;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
rmi4_data->input_dev = input_allocate_device();
if (rmi4_data->input_dev == NULL) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to allocate input device\n",
__func__);
retval = -ENOMEM;
goto err_input_device;
}
retval = synaptics_rmi4_query_device(rmi4_data);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to query device\n",
__func__);
goto err_query_device;
}
rmi4_data->input_dev->name = PLATFORM_DRIVER_NAME;
rmi4_data->input_dev->phys = INPUT_PHYS_NAME;
rmi4_data->input_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT;
rmi4_data->input_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION;
input_set_drvdata(rmi4_data->input_dev, rmi4_data);
set_bit(EV_SYN, rmi4_data->input_dev->evbit);
set_bit(EV_KEY, rmi4_data->input_dev->evbit);
set_bit(EV_ABS, rmi4_data->input_dev->evbit);
set_bit(BTN_TOUCH, rmi4_data->input_dev->keybit);
set_bit(BTN_TOOL_FINGER, rmi4_data->input_dev->keybit);
if (rmi4_data->has_large_obj_det)
set_bit(KEY_SLEEP, rmi4_data->input_dev->keybit);
#ifdef INPUT_PROP_DIRECT
set_bit(INPUT_PROP_DIRECT, rmi4_data->input_dev->propbit);
#endif
if (bdata->swap_axes) {
temp = rmi4_data->sensor_max_x;
rmi4_data->sensor_max_x = rmi4_data->sensor_max_y;
rmi4_data->sensor_max_y = temp;
}
if (bdata->max_y_for_2d >= 0)
rmi4_data->sensor_max_y = bdata->max_y_for_2d;
synaptics_rmi4_set_params(rmi4_data);
retval = input_register_device(rmi4_data->input_dev);
if (retval) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to register input device\n",
__func__);
goto err_register_input;
}
return 0;
err_register_input:
err_query_device:
synaptics_rmi4_empty_fn_list(rmi4_data);
input_free_device(rmi4_data->input_dev);
err_input_device:
return retval;
}
static int synaptics_rmi4_set_gpio(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
retval = synaptics_rmi4_gpio_setup(
bdata->irq_gpio,
true, 0, 0);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to configure attention GPIO\n",
__func__);
goto err_gpio_irq;
}
if (bdata->power_gpio >= 0) {
retval = synaptics_rmi4_gpio_setup(
bdata->power_gpio,
true, 1, !bdata->power_on_state);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to configure power GPIO\n",
__func__);
goto err_gpio_power;
}
}
if (bdata->reset_gpio >= 0) {
retval = synaptics_rmi4_gpio_setup(
bdata->reset_gpio,
true, 1, !bdata->reset_on_state);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to configure reset GPIO\n",
__func__);
goto err_gpio_reset;
}
}
if (bdata->power_gpio >= 0) {
gpio_set_value(bdata->power_gpio, bdata->power_on_state);
msleep(bdata->power_delay_ms);
}
if (bdata->reset_gpio >= 0) {
gpio_set_value(bdata->reset_gpio, bdata->reset_on_state);
msleep(bdata->reset_active_ms);
gpio_set_value(bdata->reset_gpio, !bdata->reset_on_state);
msleep(bdata->reset_delay_ms);
}
return 0;
err_gpio_reset:
if (bdata->power_gpio >= 0)
synaptics_rmi4_gpio_setup(bdata->power_gpio, false, 0, 0);
err_gpio_power:
synaptics_rmi4_gpio_setup(bdata->irq_gpio, false, 0, 0);
err_gpio_irq:
return retval;
}
static int synaptics_rmi4_get_reg(struct synaptics_rmi4_data *rmi4_data,
bool get)
{
int retval;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
if (!get) {
retval = 0;
goto regulator_put;
}
if ((bdata->pwr_reg_name != NULL) && (*bdata->pwr_reg_name != 0)) {
rmi4_data->pwr_reg = regulator_get(NULL,
bdata->pwr_reg_name);
if (IS_ERR(rmi4_data->pwr_reg)) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to get power regulator\n",
__func__);
retval = PTR_ERR(rmi4_data->pwr_reg);
goto regulator_put;
}
}
if ((bdata->bus_reg_name != NULL) && (*bdata->bus_reg_name != 0)) {
rmi4_data->bus_reg = regulator_get(NULL,
bdata->bus_reg_name);
if (IS_ERR(rmi4_data->bus_reg)) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to get bus pullup regulator\n",
__func__);
retval = PTR_ERR(rmi4_data->bus_reg);
goto regulator_put;
}
}
return 0;
regulator_put:
if (rmi4_data->pwr_reg) {
regulator_put(rmi4_data->pwr_reg);
rmi4_data->pwr_reg = NULL;
}
if (rmi4_data->bus_reg) {
regulator_put(rmi4_data->bus_reg);
rmi4_data->bus_reg = NULL;
}
return retval;
}
static int synaptics_rmi4_enable_reg(struct synaptics_rmi4_data *rmi4_data,
bool enable)
{
int retval;
const struct synaptics_dsx_board_data *bdata =
rmi4_data->hw_if->board_data;
if (!enable) {
retval = 0;
goto disable_pwr_reg;
}
if (rmi4_data->bus_reg) {
retval = regulator_enable(rmi4_data->bus_reg);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to enable bus pullup regulator\n",
__func__);
goto exit;
}
}
if (rmi4_data->pwr_reg) {
retval = regulator_enable(rmi4_data->pwr_reg);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to enable power regulator\n",
__func__);
goto disable_bus_reg;
}
msleep(bdata->power_delay_ms);
}
return 0;
disable_pwr_reg:
if (rmi4_data->pwr_reg)
regulator_disable(rmi4_data->pwr_reg);
disable_bus_reg:
if (rmi4_data->bus_reg)
regulator_disable(rmi4_data->bus_reg);
exit:
return retval;
}
static int synaptics_rmi4_free_fingers(struct synaptics_rmi4_data *rmi4_data)
{
unsigned char ii;
mutex_lock(&(rmi4_data->rmi4_report_mutex));
#ifdef TYPE_B_PROTOCOL
for (ii = 0; ii < rmi4_data->num_of_fingers; ii++) {
input_mt_slot(rmi4_data->input_dev, ii);
input_mt_report_slot_state(rmi4_data->input_dev,
MT_TOOL_FINGER, 0);
}
#endif