forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1384 lines
41 KiB
1384 lines
41 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (c) 2011-2015 Synaptics Incorporated |
|
* Copyright (c) 2011 Unixphere |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/delay.h> |
|
#include <linux/device.h> |
|
#include <linux/input.h> |
|
#include <linux/input/mt.h> |
|
#include <linux/rmi.h> |
|
#include <linux/slab.h> |
|
#include <linux/of.h> |
|
#include "rmi_driver.h" |
|
#include "rmi_2d_sensor.h" |
|
|
|
#define F11_MAX_NUM_OF_FINGERS 10 |
|
#define F11_MAX_NUM_OF_TOUCH_SHAPES 16 |
|
|
|
#define FINGER_STATE_MASK 0x03 |
|
|
|
#define F11_CTRL_SENSOR_MAX_X_POS_OFFSET 6 |
|
#define F11_CTRL_SENSOR_MAX_Y_POS_OFFSET 8 |
|
|
|
#define DEFAULT_XY_MAX 9999 |
|
#define DEFAULT_MAX_ABS_MT_PRESSURE 255 |
|
#define DEFAULT_MAX_ABS_MT_TOUCH 15 |
|
#define DEFAULT_MAX_ABS_MT_ORIENTATION 1 |
|
#define DEFAULT_MIN_ABS_MT_TRACKING_ID 1 |
|
#define DEFAULT_MAX_ABS_MT_TRACKING_ID 10 |
|
|
|
/* |
|
* A note about RMI4 F11 register structure. |
|
* |
|
* The properties for a given sensor are described by its query registers. The |
|
* number of query registers and the layout of their contents are described by |
|
* the F11 device queries as well as the sensor query information. |
|
* |
|
* Similarly, each sensor has control registers that govern its behavior. The |
|
* size and layout of the control registers for a given sensor can be determined |
|
* by parsing that sensors query registers. |
|
* |
|
* And in a likewise fashion, each sensor has data registers where it reports |
|
* its touch data and other interesting stuff. The size and layout of a |
|
* sensors data registers must be determined by parsing its query registers. |
|
* |
|
* The short story is that we need to read and parse a lot of query |
|
* registers in order to determine the attributes of a sensor. Then |
|
* we need to use that data to compute the size of the control and data |
|
* registers for sensor. |
|
* |
|
* The end result is that we have a number of structs that aren't used to |
|
* directly generate the input events, but their size, location and contents |
|
* are critical to determining where the data we are interested in lives. |
|
* |
|
* At this time, the driver does not yet comprehend all possible F11 |
|
* configuration options, but it should be sufficient to cover 99% of RMI4 F11 |
|
* devices currently in the field. |
|
*/ |
|
|
|
/* maximum ABS_MT_POSITION displacement (in mm) */ |
|
#define DMAX 10 |
|
|
|
/* |
|
* Writing this to the F11 command register will cause the sensor to |
|
* calibrate to the current capacitive state. |
|
*/ |
|
#define RMI_F11_REZERO 0x01 |
|
|
|
#define RMI_F11_HAS_QUERY9 (1 << 3) |
|
#define RMI_F11_HAS_QUERY11 (1 << 4) |
|
#define RMI_F11_HAS_QUERY12 (1 << 5) |
|
#define RMI_F11_HAS_QUERY27 (1 << 6) |
|
#define RMI_F11_HAS_QUERY28 (1 << 7) |
|
|
|
/** Defs for Query 1 */ |
|
|
|
#define RMI_F11_NR_FINGERS_MASK 0x07 |
|
#define RMI_F11_HAS_REL (1 << 3) |
|
#define RMI_F11_HAS_ABS (1 << 4) |
|
#define RMI_F11_HAS_GESTURES (1 << 5) |
|
#define RMI_F11_HAS_SENSITIVITY_ADJ (1 << 6) |
|
#define RMI_F11_CONFIGURABLE (1 << 7) |
|
|
|
/** Defs for Query 2, 3, and 4. */ |
|
#define RMI_F11_NR_ELECTRODES_MASK 0x7F |
|
|
|
/** Defs for Query 5 */ |
|
|
|
#define RMI_F11_ABS_DATA_SIZE_MASK 0x03 |
|
#define RMI_F11_HAS_ANCHORED_FINGER (1 << 2) |
|
#define RMI_F11_HAS_ADJ_HYST (1 << 3) |
|
#define RMI_F11_HAS_DRIBBLE (1 << 4) |
|
#define RMI_F11_HAS_BENDING_CORRECTION (1 << 5) |
|
#define RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION (1 << 6) |
|
#define RMI_F11_HAS_JITTER_FILTER (1 << 7) |
|
|
|
/** Defs for Query 7 */ |
|
#define RMI_F11_HAS_SINGLE_TAP (1 << 0) |
|
#define RMI_F11_HAS_TAP_AND_HOLD (1 << 1) |
|
#define RMI_F11_HAS_DOUBLE_TAP (1 << 2) |
|
#define RMI_F11_HAS_EARLY_TAP (1 << 3) |
|
#define RMI_F11_HAS_FLICK (1 << 4) |
|
#define RMI_F11_HAS_PRESS (1 << 5) |
|
#define RMI_F11_HAS_PINCH (1 << 6) |
|
#define RMI_F11_HAS_CHIRAL (1 << 7) |
|
|
|
/** Defs for Query 8 */ |
|
#define RMI_F11_HAS_PALM_DET (1 << 0) |
|
#define RMI_F11_HAS_ROTATE (1 << 1) |
|
#define RMI_F11_HAS_TOUCH_SHAPES (1 << 2) |
|
#define RMI_F11_HAS_SCROLL_ZONES (1 << 3) |
|
#define RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES (1 << 4) |
|
#define RMI_F11_HAS_MF_SCROLL (1 << 5) |
|
#define RMI_F11_HAS_MF_EDGE_MOTION (1 << 6) |
|
#define RMI_F11_HAS_MF_SCROLL_INERTIA (1 << 7) |
|
|
|
/** Defs for Query 9. */ |
|
#define RMI_F11_HAS_PEN (1 << 0) |
|
#define RMI_F11_HAS_PROXIMITY (1 << 1) |
|
#define RMI_F11_HAS_PALM_DET_SENSITIVITY (1 << 2) |
|
#define RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT (1 << 3) |
|
#define RMI_F11_HAS_TWO_PEN_THRESHOLDS (1 << 4) |
|
#define RMI_F11_HAS_CONTACT_GEOMETRY (1 << 5) |
|
#define RMI_F11_HAS_PEN_HOVER_DISCRIMINATION (1 << 6) |
|
#define RMI_F11_HAS_PEN_FILTERS (1 << 7) |
|
|
|
/** Defs for Query 10. */ |
|
#define RMI_F11_NR_TOUCH_SHAPES_MASK 0x1F |
|
|
|
/** Defs for Query 11 */ |
|
|
|
#define RMI_F11_HAS_Z_TUNING (1 << 0) |
|
#define RMI_F11_HAS_ALGORITHM_SELECTION (1 << 1) |
|
#define RMI_F11_HAS_W_TUNING (1 << 2) |
|
#define RMI_F11_HAS_PITCH_INFO (1 << 3) |
|
#define RMI_F11_HAS_FINGER_SIZE (1 << 4) |
|
#define RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS (1 << 5) |
|
#define RMI_F11_HAS_XY_CLIP (1 << 6) |
|
#define RMI_F11_HAS_DRUMMING_FILTER (1 << 7) |
|
|
|
/** Defs for Query 12. */ |
|
|
|
#define RMI_F11_HAS_GAPLESS_FINGER (1 << 0) |
|
#define RMI_F11_HAS_GAPLESS_FINGER_TUNING (1 << 1) |
|
#define RMI_F11_HAS_8BIT_W (1 << 2) |
|
#define RMI_F11_HAS_ADJUSTABLE_MAPPING (1 << 3) |
|
#define RMI_F11_HAS_INFO2 (1 << 4) |
|
#define RMI_F11_HAS_PHYSICAL_PROPS (1 << 5) |
|
#define RMI_F11_HAS_FINGER_LIMIT (1 << 6) |
|
#define RMI_F11_HAS_LINEAR_COEFF (1 << 7) |
|
|
|
/** Defs for Query 13. */ |
|
|
|
#define RMI_F11_JITTER_WINDOW_MASK 0x1F |
|
#define RMI_F11_JITTER_FILTER_MASK 0x60 |
|
#define RMI_F11_JITTER_FILTER_SHIFT 5 |
|
|
|
/** Defs for Query 14. */ |
|
#define RMI_F11_LIGHT_CONTROL_MASK 0x03 |
|
#define RMI_F11_IS_CLEAR (1 << 2) |
|
#define RMI_F11_CLICKPAD_PROPS_MASK 0x18 |
|
#define RMI_F11_CLICKPAD_PROPS_SHIFT 3 |
|
#define RMI_F11_MOUSE_BUTTONS_MASK 0x60 |
|
#define RMI_F11_MOUSE_BUTTONS_SHIFT 5 |
|
#define RMI_F11_HAS_ADVANCED_GESTURES (1 << 7) |
|
|
|
#define RMI_F11_QUERY_SIZE 4 |
|
#define RMI_F11_QUERY_GESTURE_SIZE 2 |
|
|
|
#define F11_LIGHT_CTL_NONE 0x00 |
|
#define F11_LUXPAD 0x01 |
|
#define F11_DUAL_MODE 0x02 |
|
|
|
#define F11_NOT_CLICKPAD 0x00 |
|
#define F11_HINGED_CLICKPAD 0x01 |
|
#define F11_UNIFORM_CLICKPAD 0x02 |
|
|
|
/** |
|
* struct f11_2d_sensor_queries - describes sensor capabilities |
|
* |
|
* Query registers 1 through 4 are always present. |
|
* |
|
* @nr_fingers: describes the maximum number of fingers the 2-D sensor |
|
* supports. |
|
* @has_rel: the sensor supports relative motion reporting. |
|
* @has_abs: the sensor supports absolute poition reporting. |
|
* @has_gestures: the sensor supports gesture reporting. |
|
* @has_sensitivity_adjust: the sensor supports a global sensitivity |
|
* adjustment. |
|
* @configurable: the sensor supports various configuration options. |
|
* @nr_x_electrodes: the maximum number of electrodes the 2-D sensor |
|
* supports on the X axis. |
|
* @nr_y_electrodes: the maximum number of electrodes the 2-D sensor |
|
* supports on the Y axis. |
|
* @max_electrodes: the total number of X and Y electrodes that may be |
|
* configured. |
|
* |
|
* Query 5 is present if the has_abs bit is set. |
|
* |
|
* @abs_data_size: describes the format of data reported by the absolute |
|
* data source. Only one format (the kind used here) is supported at this |
|
* time. |
|
* @has_anchored_finger: then the sensor supports the high-precision second |
|
* finger tracking provided by the manual tracking and motion sensitivity |
|
* options. |
|
* @has_adj_hyst: the difference between the finger release threshold and |
|
* the touch threshold. |
|
* @has_dribble: the sensor supports the generation of dribble interrupts, |
|
* which may be enabled or disabled with the dribble control bit. |
|
* @has_bending_correction: Bending related data registers 28 and 36, and |
|
* control register 52..57 are present. |
|
* @has_large_object_suppression: control register 58 and data register 28 |
|
* exist. |
|
* @has_jitter_filter: query 13 and control 73..76 exist. |
|
* |
|
* Query 6 is present if the has_rel it is set. |
|
* |
|
* @f11_2d_query6: this register is reserved. |
|
* |
|
* Gesture information queries 7 and 8 are present if has_gestures bit is set. |
|
* |
|
* @has_single_tap: a basic single-tap gesture is supported. |
|
* @has_tap_n_hold: tap-and-hold gesture is supported. |
|
* @has_double_tap: double-tap gesture is supported. |
|
* @has_early_tap: early tap is supported and reported as soon as the finger |
|
* lifts for any tap event that could be interpreted as either a single |
|
* tap or as the first tap of a double-tap or tap-and-hold gesture. |
|
* @has_flick: flick detection is supported. |
|
* @has_press: press gesture reporting is supported. |
|
* @has_pinch: pinch gesture detection is supported. |
|
* @has_chiral: chiral (circular) scrolling gesture detection is supported. |
|
* @has_palm_det: the 2-D sensor notifies the host whenever a large conductive |
|
* object such as a palm or a cheek touches the 2-D sensor. |
|
* @has_rotate: rotation gesture detection is supported. |
|
* @has_touch_shapes: TouchShapes are supported. A TouchShape is a fixed |
|
* rectangular area on the sensor that behaves like a capacitive button. |
|
* @has_scroll_zones: scrolling areas near the sensor edges are supported. |
|
* @has_individual_scroll_zones: if 1, then 4 scroll zones are supported; |
|
* if 0, then only two are supported. |
|
* @has_mf_scroll: the multifinger_scrolling bit will be set when |
|
* more than one finger is involved in a scrolling action. |
|
* @has_mf_edge_motion: indicates whether multi-finger edge motion gesture |
|
* is supported. |
|
* @has_mf_scroll_inertia: indicates whether multi-finger scroll inertia |
|
* feature is supported. |
|
* |
|
* Convenience for checking bytes in the gesture info registers. This is done |
|
* often enough that we put it here to declutter the conditionals |
|
* |
|
* @query7_nonzero: true if none of the query 7 bits are set |
|
* @query8_nonzero: true if none of the query 8 bits are set |
|
* |
|
* Query 9 is present if the has_query9 is set. |
|
* |
|
* @has_pen: detection of a stylus is supported and registers F11_2D_Ctrl20 |
|
* and F11_2D_Ctrl21 exist. |
|
* @has_proximity: detection of fingers near the sensor is supported and |
|
* registers F11_2D_Ctrl22 through F11_2D_Ctrl26 exist. |
|
* @has_palm_det_sensitivity: the sensor supports the palm detect sensitivity |
|
* feature and register F11_2D_Ctrl27 exists. |
|
* @has_suppress_on_palm_detect: the device supports the large object detect |
|
* suppression feature and register F11_2D_Ctrl27 exists. |
|
* @has_two_pen_thresholds: if has_pen is also set, then F11_2D_Ctrl35 exists. |
|
* @has_contact_geometry: the sensor supports the use of contact geometry to |
|
* map absolute X and Y target positions and registers F11_2D_Data18 |
|
* through F11_2D_Data27 exist. |
|
* @has_pen_hover_discrimination: if has_pen is also set, then registers |
|
* F11_2D_Data29 through F11_2D_Data31, F11_2D_Ctrl68.*, F11_2D_Ctrl69 |
|
* and F11_2D_Ctrl72 exist. |
|
* @has_pen_filters: if has_pen is also set, then registers F11_2D_Ctrl70 and |
|
* F11_2D_Ctrl71 exist. |
|
* |
|
* Touch shape info (query 10) is present if has_touch_shapes is set. |
|
* |
|
* @nr_touch_shapes: the total number of touch shapes supported. |
|
* |
|
* Query 11 is present if the has_query11 bit is set in query 0. |
|
* |
|
* @has_z_tuning: if set, the sensor supports Z tuning and registers |
|
* F11_2D_Ctrl29 through F11_2D_Ctrl33 exist. |
|
* @has_algorithm_selection: controls choice of noise suppression algorithm |
|
* @has_w_tuning: the sensor supports Wx and Wy scaling and registers |
|
* F11_2D_Ctrl36 through F11_2D_Ctrl39 exist. |
|
* @has_pitch_info: the X and Y pitches of the sensor electrodes can be |
|
* configured and registers F11_2D_Ctrl40 and F11_2D_Ctrl41 exist. |
|
* @has_finger_size: the default finger width settings for the sensor |
|
* can be configured and registers F11_2D_Ctrl42 through F11_2D_Ctrl44 |
|
* exist. |
|
* @has_segmentation_aggressiveness: the sensor’s ability to distinguish |
|
* multiple objects close together can be configured and register |
|
* F11_2D_Ctrl45 exists. |
|
* @has_XY_clip: the inactive outside borders of the sensor can be |
|
* configured and registers F11_2D_Ctrl46 through F11_2D_Ctrl49 exist. |
|
* @has_drumming_filter: the sensor can be configured to distinguish |
|
* between a fast flick and a quick drumming movement and registers |
|
* F11_2D_Ctrl50 and F11_2D_Ctrl51 exist. |
|
* |
|
* Query 12 is present if hasQuery12 bit is set. |
|
* |
|
* @has_gapless_finger: control registers relating to gapless finger are |
|
* present. |
|
* @has_gapless_finger_tuning: additional control and data registers relating |
|
* to gapless finger are present. |
|
* @has_8bit_w: larger W value reporting is supported. |
|
* @has_adjustable_mapping: TBD |
|
* @has_info2: the general info query14 is present |
|
* @has_physical_props: additional queries describing the physical properties |
|
* of the sensor are present. |
|
* @has_finger_limit: indicates that F11 Ctrl 80 exists. |
|
* @has_linear_coeff_2: indicates that F11 Ctrl 81 exists. |
|
* |
|
* Query 13 is present if Query 5's has_jitter_filter bit is set. |
|
* |
|
* @jitter_window_size: used by Design Studio 4. |
|
* @jitter_filter_type: used by Design Studio 4. |
|
* |
|
* Query 14 is present if query 12's has_general_info2 flag is set. |
|
* |
|
* @light_control: Indicates what light/led control features are present, |
|
* if any. |
|
* @is_clear: if set, this is a clear sensor (indicating direct pointing |
|
* application), otherwise it's opaque (indicating indirect pointing). |
|
* @clickpad_props: specifies if this is a clickpad, and if so what sort of |
|
* mechanism it uses |
|
* @mouse_buttons: specifies the number of mouse buttons present (if any). |
|
* @has_advanced_gestures: advanced driver gestures are supported. |
|
* |
|
* @x_sensor_size_mm: size of the sensor in millimeters on the X axis. |
|
* @y_sensor_size_mm: size of the sensor in millimeters on the Y axis. |
|
*/ |
|
struct f11_2d_sensor_queries { |
|
/* query1 */ |
|
u8 nr_fingers; |
|
bool has_rel; |
|
bool has_abs; |
|
bool has_gestures; |
|
bool has_sensitivity_adjust; |
|
bool configurable; |
|
|
|
/* query2 */ |
|
u8 nr_x_electrodes; |
|
|
|
/* query3 */ |
|
u8 nr_y_electrodes; |
|
|
|
/* query4 */ |
|
u8 max_electrodes; |
|
|
|
/* query5 */ |
|
u8 abs_data_size; |
|
bool has_anchored_finger; |
|
bool has_adj_hyst; |
|
bool has_dribble; |
|
bool has_bending_correction; |
|
bool has_large_object_suppression; |
|
bool has_jitter_filter; |
|
|
|
u8 f11_2d_query6; |
|
|
|
/* query 7 */ |
|
bool has_single_tap; |
|
bool has_tap_n_hold; |
|
bool has_double_tap; |
|
bool has_early_tap; |
|
bool has_flick; |
|
bool has_press; |
|
bool has_pinch; |
|
bool has_chiral; |
|
|
|
bool query7_nonzero; |
|
|
|
/* query 8 */ |
|
bool has_palm_det; |
|
bool has_rotate; |
|
bool has_touch_shapes; |
|
bool has_scroll_zones; |
|
bool has_individual_scroll_zones; |
|
bool has_mf_scroll; |
|
bool has_mf_edge_motion; |
|
bool has_mf_scroll_inertia; |
|
|
|
bool query8_nonzero; |
|
|
|
/* Query 9 */ |
|
bool has_pen; |
|
bool has_proximity; |
|
bool has_palm_det_sensitivity; |
|
bool has_suppress_on_palm_detect; |
|
bool has_two_pen_thresholds; |
|
bool has_contact_geometry; |
|
bool has_pen_hover_discrimination; |
|
bool has_pen_filters; |
|
|
|
/* Query 10 */ |
|
u8 nr_touch_shapes; |
|
|
|
/* Query 11. */ |
|
bool has_z_tuning; |
|
bool has_algorithm_selection; |
|
bool has_w_tuning; |
|
bool has_pitch_info; |
|
bool has_finger_size; |
|
bool has_segmentation_aggressiveness; |
|
bool has_XY_clip; |
|
bool has_drumming_filter; |
|
|
|
/* Query 12 */ |
|
bool has_gapless_finger; |
|
bool has_gapless_finger_tuning; |
|
bool has_8bit_w; |
|
bool has_adjustable_mapping; |
|
bool has_info2; |
|
bool has_physical_props; |
|
bool has_finger_limit; |
|
bool has_linear_coeff_2; |
|
|
|
/* Query 13 */ |
|
u8 jitter_window_size; |
|
u8 jitter_filter_type; |
|
|
|
/* Query 14 */ |
|
u8 light_control; |
|
bool is_clear; |
|
u8 clickpad_props; |
|
u8 mouse_buttons; |
|
bool has_advanced_gestures; |
|
|
|
/* Query 15 - 18 */ |
|
u16 x_sensor_size_mm; |
|
u16 y_sensor_size_mm; |
|
}; |
|
|
|
/* Defs for Ctrl0. */ |
|
#define RMI_F11_REPORT_MODE_MASK 0x07 |
|
#define RMI_F11_REPORT_MODE_CONTINUOUS (0 << 0) |
|
#define RMI_F11_REPORT_MODE_REDUCED (1 << 0) |
|
#define RMI_F11_REPORT_MODE_FS_CHANGE (2 << 0) |
|
#define RMI_F11_REPORT_MODE_FP_CHANGE (3 << 0) |
|
#define RMI_F11_ABS_POS_FILT (1 << 3) |
|
#define RMI_F11_REL_POS_FILT (1 << 4) |
|
#define RMI_F11_REL_BALLISTICS (1 << 5) |
|
#define RMI_F11_DRIBBLE (1 << 6) |
|
#define RMI_F11_REPORT_BEYOND_CLIP (1 << 7) |
|
|
|
/* Defs for Ctrl1. */ |
|
#define RMI_F11_PALM_DETECT_THRESH_MASK 0x0F |
|
#define RMI_F11_MOTION_SENSITIVITY_MASK 0x30 |
|
#define RMI_F11_MANUAL_TRACKING (1 << 6) |
|
#define RMI_F11_MANUAL_TRACKED_FINGER (1 << 7) |
|
|
|
#define RMI_F11_DELTA_X_THRESHOLD 2 |
|
#define RMI_F11_DELTA_Y_THRESHOLD 3 |
|
|
|
#define RMI_F11_CTRL_REG_COUNT 12 |
|
|
|
struct f11_2d_ctrl { |
|
u8 ctrl0_11[RMI_F11_CTRL_REG_COUNT]; |
|
u16 ctrl0_11_address; |
|
}; |
|
|
|
#define RMI_F11_ABS_BYTES 5 |
|
#define RMI_F11_REL_BYTES 2 |
|
|
|
/* Defs for Data 8 */ |
|
|
|
#define RMI_F11_SINGLE_TAP (1 << 0) |
|
#define RMI_F11_TAP_AND_HOLD (1 << 1) |
|
#define RMI_F11_DOUBLE_TAP (1 << 2) |
|
#define RMI_F11_EARLY_TAP (1 << 3) |
|
#define RMI_F11_FLICK (1 << 4) |
|
#define RMI_F11_PRESS (1 << 5) |
|
#define RMI_F11_PINCH (1 << 6) |
|
|
|
/* Defs for Data 9 */ |
|
|
|
#define RMI_F11_PALM_DETECT (1 << 0) |
|
#define RMI_F11_ROTATE (1 << 1) |
|
#define RMI_F11_SHAPE (1 << 2) |
|
#define RMI_F11_SCROLLZONE (1 << 3) |
|
#define RMI_F11_GESTURE_FINGER_COUNT_MASK 0x70 |
|
|
|
/** Handy pointers into our data buffer. |
|
* |
|
* @f_state - start of finger state registers. |
|
* @abs_pos - start of absolute position registers (if present). |
|
* @rel_pos - start of relative data registers (if present). |
|
* @gest_1 - gesture flags (if present). |
|
* @gest_2 - gesture flags & finger count (if present). |
|
* @pinch - pinch motion register (if present). |
|
* @flick - flick distance X & Y, flick time (if present). |
|
* @rotate - rotate motion and finger separation. |
|
* @multi_scroll - chiral deltas for X and Y (if present). |
|
* @scroll_zones - scroll deltas for 4 regions (if present). |
|
*/ |
|
struct f11_2d_data { |
|
u8 *f_state; |
|
u8 *abs_pos; |
|
s8 *rel_pos; |
|
u8 *gest_1; |
|
u8 *gest_2; |
|
s8 *pinch; |
|
u8 *flick; |
|
u8 *rotate; |
|
u8 *shapes; |
|
s8 *multi_scroll; |
|
s8 *scroll_zones; |
|
}; |
|
|
|
/** Data pertaining to F11 in general. For per-sensor data, see struct |
|
* f11_2d_sensor. |
|
* |
|
* @dev_query - F11 device specific query registers. |
|
* @dev_controls - F11 device specific control registers. |
|
* @dev_controls_mutex - lock for the control registers. |
|
* @rezero_wait_ms - if nonzero, upon resume we will wait this many |
|
* milliseconds before rezeroing the sensor(s). This is useful in systems with |
|
* poor electrical behavior on resume, where the initial calibration of the |
|
* sensor(s) coming out of sleep state may be bogus. |
|
* @sensors - per sensor data structures. |
|
*/ |
|
struct f11_data { |
|
bool has_query9; |
|
bool has_query11; |
|
bool has_query12; |
|
bool has_query27; |
|
bool has_query28; |
|
bool has_acm; |
|
struct f11_2d_ctrl dev_controls; |
|
struct mutex dev_controls_mutex; |
|
u16 rezero_wait_ms; |
|
struct rmi_2d_sensor sensor; |
|
struct f11_2d_sensor_queries sens_query; |
|
struct f11_2d_data data; |
|
struct rmi_2d_sensor_platform_data sensor_pdata; |
|
unsigned long *abs_mask; |
|
unsigned long *rel_mask; |
|
}; |
|
|
|
enum f11_finger_state { |
|
F11_NO_FINGER = 0x00, |
|
F11_PRESENT = 0x01, |
|
F11_INACCURATE = 0x02, |
|
F11_RESERVED = 0x03 |
|
}; |
|
|
|
static void rmi_f11_rel_pos_report(struct f11_data *f11, u8 n_finger) |
|
{ |
|
struct rmi_2d_sensor *sensor = &f11->sensor; |
|
struct f11_2d_data *data = &f11->data; |
|
s8 x, y; |
|
|
|
x = data->rel_pos[n_finger * RMI_F11_REL_BYTES]; |
|
y = data->rel_pos[n_finger * RMI_F11_REL_BYTES + 1]; |
|
|
|
rmi_2d_sensor_rel_report(sensor, x, y); |
|
} |
|
|
|
static void rmi_f11_abs_pos_process(struct f11_data *f11, |
|
struct rmi_2d_sensor *sensor, |
|
struct rmi_2d_sensor_abs_object *obj, |
|
enum f11_finger_state finger_state, |
|
u8 n_finger) |
|
{ |
|
struct f11_2d_data *data = &f11->data; |
|
u8 *pos_data = &data->abs_pos[n_finger * RMI_F11_ABS_BYTES]; |
|
int tool_type = MT_TOOL_FINGER; |
|
|
|
switch (finger_state) { |
|
case F11_PRESENT: |
|
obj->type = RMI_2D_OBJECT_FINGER; |
|
break; |
|
default: |
|
obj->type = RMI_2D_OBJECT_NONE; |
|
} |
|
|
|
obj->mt_tool = tool_type; |
|
obj->x = (pos_data[0] << 4) | (pos_data[2] & 0x0F); |
|
obj->y = (pos_data[1] << 4) | (pos_data[2] >> 4); |
|
obj->z = pos_data[4]; |
|
obj->wx = pos_data[3] & 0x0f; |
|
obj->wy = pos_data[3] >> 4; |
|
|
|
rmi_2d_sensor_abs_process(sensor, obj, n_finger); |
|
} |
|
|
|
static inline u8 rmi_f11_parse_finger_state(const u8 *f_state, u8 n_finger) |
|
{ |
|
return (f_state[n_finger / 4] >> (2 * (n_finger % 4))) & |
|
FINGER_STATE_MASK; |
|
} |
|
|
|
static void rmi_f11_finger_handler(struct f11_data *f11, |
|
struct rmi_2d_sensor *sensor, int size) |
|
{ |
|
const u8 *f_state = f11->data.f_state; |
|
u8 finger_state; |
|
u8 i; |
|
int abs_fingers; |
|
int rel_fingers; |
|
int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES; |
|
|
|
if (sensor->report_abs) { |
|
if (abs_size > size) |
|
abs_fingers = size / RMI_F11_ABS_BYTES; |
|
else |
|
abs_fingers = sensor->nbr_fingers; |
|
|
|
for (i = 0; i < abs_fingers; i++) { |
|
/* Possible of having 4 fingers per f_state register */ |
|
finger_state = rmi_f11_parse_finger_state(f_state, i); |
|
if (finger_state == F11_RESERVED) { |
|
pr_err("Invalid finger state[%d]: 0x%02x", i, |
|
finger_state); |
|
continue; |
|
} |
|
|
|
rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i], |
|
finger_state, i); |
|
} |
|
|
|
/* |
|
* the absolute part is made in 2 parts to allow the kernel |
|
* tracking to take place. |
|
*/ |
|
if (sensor->kernel_tracking) |
|
input_mt_assign_slots(sensor->input, |
|
sensor->tracking_slots, |
|
sensor->tracking_pos, |
|
sensor->nbr_fingers, |
|
sensor->dmax); |
|
|
|
for (i = 0; i < abs_fingers; i++) { |
|
finger_state = rmi_f11_parse_finger_state(f_state, i); |
|
if (finger_state == F11_RESERVED) |
|
/* no need to send twice the error */ |
|
continue; |
|
|
|
rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i); |
|
} |
|
|
|
input_mt_sync_frame(sensor->input); |
|
} else if (sensor->report_rel) { |
|
if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size) |
|
rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES; |
|
else |
|
rel_fingers = sensor->nbr_fingers; |
|
|
|
for (i = 0; i < rel_fingers; i++) |
|
rmi_f11_rel_pos_report(f11, i); |
|
} |
|
|
|
} |
|
|
|
static int f11_2d_construct_data(struct f11_data *f11) |
|
{ |
|
struct rmi_2d_sensor *sensor = &f11->sensor; |
|
struct f11_2d_sensor_queries *query = &f11->sens_query; |
|
struct f11_2d_data *data = &f11->data; |
|
int i; |
|
|
|
sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 : |
|
query->nr_fingers + 1); |
|
|
|
sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4); |
|
|
|
if (query->has_abs) { |
|
sensor->pkt_size += (sensor->nbr_fingers * 5); |
|
sensor->attn_size = sensor->pkt_size; |
|
} |
|
|
|
if (query->has_rel) |
|
sensor->pkt_size += (sensor->nbr_fingers * 2); |
|
|
|
/* Check if F11_2D_Query7 is non-zero */ |
|
if (query->query7_nonzero) |
|
sensor->pkt_size += sizeof(u8); |
|
|
|
/* Check if F11_2D_Query7 or F11_2D_Query8 is non-zero */ |
|
if (query->query7_nonzero || query->query8_nonzero) |
|
sensor->pkt_size += sizeof(u8); |
|
|
|
if (query->has_pinch || query->has_flick || query->has_rotate) { |
|
sensor->pkt_size += 3; |
|
if (!query->has_flick) |
|
sensor->pkt_size--; |
|
if (!query->has_rotate) |
|
sensor->pkt_size--; |
|
} |
|
|
|
if (query->has_touch_shapes) |
|
sensor->pkt_size += |
|
DIV_ROUND_UP(query->nr_touch_shapes + 1, 8); |
|
|
|
sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size, |
|
GFP_KERNEL); |
|
if (!sensor->data_pkt) |
|
return -ENOMEM; |
|
|
|
data->f_state = sensor->data_pkt; |
|
i = DIV_ROUND_UP(sensor->nbr_fingers, 4); |
|
|
|
if (query->has_abs) { |
|
data->abs_pos = &sensor->data_pkt[i]; |
|
i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES); |
|
} |
|
|
|
if (query->has_rel) { |
|
data->rel_pos = &sensor->data_pkt[i]; |
|
i += (sensor->nbr_fingers * RMI_F11_REL_BYTES); |
|
} |
|
|
|
if (query->query7_nonzero) { |
|
data->gest_1 = &sensor->data_pkt[i]; |
|
i++; |
|
} |
|
|
|
if (query->query7_nonzero || query->query8_nonzero) { |
|
data->gest_2 = &sensor->data_pkt[i]; |
|
i++; |
|
} |
|
|
|
if (query->has_pinch) { |
|
data->pinch = &sensor->data_pkt[i]; |
|
i++; |
|
} |
|
|
|
if (query->has_flick) { |
|
if (query->has_pinch) { |
|
data->flick = data->pinch; |
|
i += 2; |
|
} else { |
|
data->flick = &sensor->data_pkt[i]; |
|
i += 3; |
|
} |
|
} |
|
|
|
if (query->has_rotate) { |
|
if (query->has_flick) { |
|
data->rotate = data->flick + 1; |
|
} else { |
|
data->rotate = &sensor->data_pkt[i]; |
|
i += 2; |
|
} |
|
} |
|
|
|
if (query->has_touch_shapes) |
|
data->shapes = &sensor->data_pkt[i]; |
|
|
|
return 0; |
|
} |
|
|
|
static int f11_read_control_regs(struct rmi_function *fn, |
|
struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) { |
|
struct rmi_device *rmi_dev = fn->rmi_dev; |
|
int error = 0; |
|
|
|
ctrl->ctrl0_11_address = ctrl_base_addr; |
|
error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11, |
|
RMI_F11_CTRL_REG_COUNT); |
|
if (error < 0) { |
|
dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error); |
|
return error; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int f11_write_control_regs(struct rmi_function *fn, |
|
struct f11_2d_sensor_queries *query, |
|
struct f11_2d_ctrl *ctrl, |
|
u16 ctrl_base_addr) |
|
{ |
|
struct rmi_device *rmi_dev = fn->rmi_dev; |
|
int error; |
|
|
|
error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11, |
|
RMI_F11_CTRL_REG_COUNT); |
|
if (error < 0) |
|
return error; |
|
|
|
return 0; |
|
} |
|
|
|
static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev, |
|
struct f11_data *f11, |
|
struct f11_2d_sensor_queries *sensor_query, |
|
u16 query_base_addr) |
|
{ |
|
int query_size; |
|
int rc; |
|
u8 query_buf[RMI_F11_QUERY_SIZE]; |
|
bool has_query36 = false; |
|
|
|
rc = rmi_read_block(rmi_dev, query_base_addr, query_buf, |
|
RMI_F11_QUERY_SIZE); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK; |
|
sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL); |
|
sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS); |
|
sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES); |
|
sensor_query->has_sensitivity_adjust = |
|
!!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ); |
|
sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE); |
|
|
|
sensor_query->nr_x_electrodes = |
|
query_buf[1] & RMI_F11_NR_ELECTRODES_MASK; |
|
sensor_query->nr_y_electrodes = |
|
query_buf[2] & RMI_F11_NR_ELECTRODES_MASK; |
|
sensor_query->max_electrodes = |
|
query_buf[3] & RMI_F11_NR_ELECTRODES_MASK; |
|
|
|
query_size = RMI_F11_QUERY_SIZE; |
|
|
|
if (sensor_query->has_abs) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->abs_data_size = |
|
query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK; |
|
sensor_query->has_anchored_finger = |
|
!!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER); |
|
sensor_query->has_adj_hyst = |
|
!!(query_buf[0] & RMI_F11_HAS_ADJ_HYST); |
|
sensor_query->has_dribble = |
|
!!(query_buf[0] & RMI_F11_HAS_DRIBBLE); |
|
sensor_query->has_bending_correction = |
|
!!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION); |
|
sensor_query->has_large_object_suppression = |
|
!!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION); |
|
sensor_query->has_jitter_filter = |
|
!!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER); |
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_rel) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, |
|
&sensor_query->f11_2d_query6); |
|
if (rc < 0) |
|
return rc; |
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_gestures) { |
|
rc = rmi_read_block(rmi_dev, query_base_addr + query_size, |
|
query_buf, RMI_F11_QUERY_GESTURE_SIZE); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->has_single_tap = |
|
!!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP); |
|
sensor_query->has_tap_n_hold = |
|
!!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD); |
|
sensor_query->has_double_tap = |
|
!!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP); |
|
sensor_query->has_early_tap = |
|
!!(query_buf[0] & RMI_F11_HAS_EARLY_TAP); |
|
sensor_query->has_flick = |
|
!!(query_buf[0] & RMI_F11_HAS_FLICK); |
|
sensor_query->has_press = |
|
!!(query_buf[0] & RMI_F11_HAS_PRESS); |
|
sensor_query->has_pinch = |
|
!!(query_buf[0] & RMI_F11_HAS_PINCH); |
|
sensor_query->has_chiral = |
|
!!(query_buf[0] & RMI_F11_HAS_CHIRAL); |
|
|
|
/* query 8 */ |
|
sensor_query->has_palm_det = |
|
!!(query_buf[1] & RMI_F11_HAS_PALM_DET); |
|
sensor_query->has_rotate = |
|
!!(query_buf[1] & RMI_F11_HAS_ROTATE); |
|
sensor_query->has_touch_shapes = |
|
!!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES); |
|
sensor_query->has_scroll_zones = |
|
!!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES); |
|
sensor_query->has_individual_scroll_zones = |
|
!!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES); |
|
sensor_query->has_mf_scroll = |
|
!!(query_buf[1] & RMI_F11_HAS_MF_SCROLL); |
|
sensor_query->has_mf_edge_motion = |
|
!!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION); |
|
sensor_query->has_mf_scroll_inertia = |
|
!!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA); |
|
|
|
sensor_query->query7_nonzero = !!(query_buf[0]); |
|
sensor_query->query8_nonzero = !!(query_buf[1]); |
|
|
|
query_size += 2; |
|
} |
|
|
|
if (f11->has_query9) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->has_pen = |
|
!!(query_buf[0] & RMI_F11_HAS_PEN); |
|
sensor_query->has_proximity = |
|
!!(query_buf[0] & RMI_F11_HAS_PROXIMITY); |
|
sensor_query->has_palm_det_sensitivity = |
|
!!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY); |
|
sensor_query->has_suppress_on_palm_detect = |
|
!!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT); |
|
sensor_query->has_two_pen_thresholds = |
|
!!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS); |
|
sensor_query->has_contact_geometry = |
|
!!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY); |
|
sensor_query->has_pen_hover_discrimination = |
|
!!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION); |
|
sensor_query->has_pen_filters = |
|
!!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS); |
|
|
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_touch_shapes) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->nr_touch_shapes = query_buf[0] & |
|
RMI_F11_NR_TOUCH_SHAPES_MASK; |
|
|
|
query_size++; |
|
} |
|
|
|
if (f11->has_query11) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->has_z_tuning = |
|
!!(query_buf[0] & RMI_F11_HAS_Z_TUNING); |
|
sensor_query->has_algorithm_selection = |
|
!!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION); |
|
sensor_query->has_w_tuning = |
|
!!(query_buf[0] & RMI_F11_HAS_W_TUNING); |
|
sensor_query->has_pitch_info = |
|
!!(query_buf[0] & RMI_F11_HAS_PITCH_INFO); |
|
sensor_query->has_finger_size = |
|
!!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE); |
|
sensor_query->has_segmentation_aggressiveness = |
|
!!(query_buf[0] & |
|
RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS); |
|
sensor_query->has_XY_clip = |
|
!!(query_buf[0] & RMI_F11_HAS_XY_CLIP); |
|
sensor_query->has_drumming_filter = |
|
!!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER); |
|
|
|
query_size++; |
|
} |
|
|
|
if (f11->has_query12) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->has_gapless_finger = |
|
!!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER); |
|
sensor_query->has_gapless_finger_tuning = |
|
!!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING); |
|
sensor_query->has_8bit_w = |
|
!!(query_buf[0] & RMI_F11_HAS_8BIT_W); |
|
sensor_query->has_adjustable_mapping = |
|
!!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING); |
|
sensor_query->has_info2 = |
|
!!(query_buf[0] & RMI_F11_HAS_INFO2); |
|
sensor_query->has_physical_props = |
|
!!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS); |
|
sensor_query->has_finger_limit = |
|
!!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT); |
|
sensor_query->has_linear_coeff_2 = |
|
!!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF); |
|
|
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_jitter_filter) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->jitter_window_size = query_buf[0] & |
|
RMI_F11_JITTER_WINDOW_MASK; |
|
sensor_query->jitter_filter_type = (query_buf[0] & |
|
RMI_F11_JITTER_FILTER_MASK) >> |
|
RMI_F11_JITTER_FILTER_SHIFT; |
|
|
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_info2) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->light_control = |
|
query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK; |
|
sensor_query->is_clear = |
|
!!(query_buf[0] & RMI_F11_IS_CLEAR); |
|
sensor_query->clickpad_props = |
|
(query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >> |
|
RMI_F11_CLICKPAD_PROPS_SHIFT; |
|
sensor_query->mouse_buttons = |
|
(query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >> |
|
RMI_F11_MOUSE_BUTTONS_SHIFT; |
|
sensor_query->has_advanced_gestures = |
|
!!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES); |
|
|
|
query_size++; |
|
} |
|
|
|
if (sensor_query->has_physical_props) { |
|
rc = rmi_read_block(rmi_dev, query_base_addr |
|
+ query_size, query_buf, 4); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor_query->x_sensor_size_mm = |
|
(query_buf[0] | (query_buf[1] << 8)) / 10; |
|
sensor_query->y_sensor_size_mm = |
|
(query_buf[2] | (query_buf[3] << 8)) / 10; |
|
|
|
/* |
|
* query 15 - 18 contain the size of the sensor |
|
* and query 19 - 26 contain bezel dimensions |
|
*/ |
|
query_size += 12; |
|
} |
|
|
|
if (f11->has_query27) |
|
++query_size; |
|
|
|
if (f11->has_query28) { |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, |
|
query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
has_query36 = !!(query_buf[0] & BIT(6)); |
|
} |
|
|
|
if (has_query36) { |
|
query_size += 2; |
|
rc = rmi_read(rmi_dev, query_base_addr + query_size, |
|
query_buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
if (!!(query_buf[0] & BIT(5))) |
|
f11->has_acm = true; |
|
} |
|
|
|
return query_size; |
|
} |
|
|
|
static int rmi_f11_initialize(struct rmi_function *fn) |
|
{ |
|
struct rmi_device *rmi_dev = fn->rmi_dev; |
|
struct f11_data *f11; |
|
struct f11_2d_ctrl *ctrl; |
|
u8 query_offset; |
|
u16 query_base_addr; |
|
u16 control_base_addr; |
|
u16 max_x_pos, max_y_pos; |
|
int rc; |
|
const struct rmi_device_platform_data *pdata = |
|
rmi_get_platform_data(rmi_dev); |
|
struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); |
|
struct rmi_2d_sensor *sensor; |
|
u8 buf; |
|
int mask_size; |
|
|
|
rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n"); |
|
|
|
mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long); |
|
|
|
/* |
|
** init instance data, fill in values and create any sysfs files |
|
*/ |
|
f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 2, |
|
GFP_KERNEL); |
|
if (!f11) |
|
return -ENOMEM; |
|
|
|
if (fn->dev.of_node) { |
|
rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata); |
|
if (rc) |
|
return rc; |
|
} else { |
|
f11->sensor_pdata = pdata->sensor_pdata; |
|
} |
|
|
|
f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait; |
|
|
|
f11->abs_mask = (unsigned long *)((char *)f11 |
|
+ sizeof(struct f11_data)); |
|
f11->rel_mask = (unsigned long *)((char *)f11 |
|
+ sizeof(struct f11_data) + mask_size); |
|
|
|
set_bit(fn->irq_pos, f11->abs_mask); |
|
set_bit(fn->irq_pos + 1, f11->rel_mask); |
|
|
|
query_base_addr = fn->fd.query_base_addr; |
|
control_base_addr = fn->fd.control_base_addr; |
|
|
|
rc = rmi_read(rmi_dev, query_base_addr, &buf); |
|
if (rc < 0) |
|
return rc; |
|
|
|
f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9); |
|
f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11); |
|
f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12); |
|
f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27); |
|
f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28); |
|
|
|
query_offset = (query_base_addr + 1); |
|
sensor = &f11->sensor; |
|
sensor->fn = fn; |
|
|
|
rc = rmi_f11_get_query_parameters(rmi_dev, f11, |
|
&f11->sens_query, query_offset); |
|
if (rc < 0) |
|
return rc; |
|
query_offset += rc; |
|
|
|
rc = f11_read_control_regs(fn, &f11->dev_controls, |
|
control_base_addr); |
|
if (rc < 0) { |
|
dev_err(&fn->dev, |
|
"Failed to read F11 control params.\n"); |
|
return rc; |
|
} |
|
|
|
if (f11->sens_query.has_info2) { |
|
if (f11->sens_query.is_clear) |
|
f11->sensor.sensor_type = rmi_sensor_touchscreen; |
|
else |
|
f11->sensor.sensor_type = rmi_sensor_touchpad; |
|
} |
|
|
|
sensor->report_abs = f11->sens_query.has_abs; |
|
|
|
sensor->axis_align = |
|
f11->sensor_pdata.axis_align; |
|
|
|
sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad; |
|
sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking; |
|
sensor->dmax = f11->sensor_pdata.dmax; |
|
sensor->dribble = f11->sensor_pdata.dribble; |
|
sensor->palm_detect = f11->sensor_pdata.palm_detect; |
|
|
|
if (f11->sens_query.has_physical_props) { |
|
sensor->x_mm = f11->sens_query.x_sensor_size_mm; |
|
sensor->y_mm = f11->sens_query.y_sensor_size_mm; |
|
} else { |
|
sensor->x_mm = f11->sensor_pdata.x_mm; |
|
sensor->y_mm = f11->sensor_pdata.y_mm; |
|
} |
|
|
|
if (sensor->sensor_type == rmi_sensor_default) |
|
sensor->sensor_type = |
|
f11->sensor_pdata.sensor_type; |
|
|
|
sensor->report_abs = sensor->report_abs |
|
&& !(f11->sensor_pdata.disable_report_mask |
|
& RMI_F11_DISABLE_ABS_REPORT); |
|
|
|
if (!sensor->report_abs) |
|
/* |
|
* If device doesn't have abs or if it has been disables |
|
* fallback to reporting rel data. |
|
*/ |
|
sensor->report_rel = f11->sens_query.has_rel; |
|
|
|
rc = rmi_read_block(rmi_dev, |
|
control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET, |
|
(u8 *)&max_x_pos, sizeof(max_x_pos)); |
|
if (rc < 0) |
|
return rc; |
|
|
|
rc = rmi_read_block(rmi_dev, |
|
control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET, |
|
(u8 *)&max_y_pos, sizeof(max_y_pos)); |
|
if (rc < 0) |
|
return rc; |
|
|
|
sensor->max_x = max_x_pos; |
|
sensor->max_y = max_y_pos; |
|
|
|
rc = f11_2d_construct_data(f11); |
|
if (rc < 0) |
|
return rc; |
|
|
|
if (f11->has_acm) |
|
f11->sensor.attn_size += f11->sensor.nbr_fingers * 2; |
|
|
|
/* allocate the in-kernel tracking buffers */ |
|
sensor->tracking_pos = devm_kcalloc(&fn->dev, |
|
sensor->nbr_fingers, sizeof(struct input_mt_pos), |
|
GFP_KERNEL); |
|
sensor->tracking_slots = devm_kcalloc(&fn->dev, |
|
sensor->nbr_fingers, sizeof(int), GFP_KERNEL); |
|
sensor->objs = devm_kcalloc(&fn->dev, |
|
sensor->nbr_fingers, |
|
sizeof(struct rmi_2d_sensor_abs_object), |
|
GFP_KERNEL); |
|
if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs) |
|
return -ENOMEM; |
|
|
|
ctrl = &f11->dev_controls; |
|
if (sensor->axis_align.delta_x_threshold) |
|
ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] = |
|
sensor->axis_align.delta_x_threshold; |
|
|
|
if (sensor->axis_align.delta_y_threshold) |
|
ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] = |
|
sensor->axis_align.delta_y_threshold; |
|
|
|
/* |
|
* If distance threshold values are set, switch to reduced reporting |
|
* mode so they actually get used by the controller. |
|
*/ |
|
if (sensor->axis_align.delta_x_threshold || |
|
sensor->axis_align.delta_y_threshold) { |
|
ctrl->ctrl0_11[0] &= ~RMI_F11_REPORT_MODE_MASK; |
|
ctrl->ctrl0_11[0] |= RMI_F11_REPORT_MODE_REDUCED; |
|
} |
|
|
|
if (f11->sens_query.has_dribble) { |
|
switch (sensor->dribble) { |
|
case RMI_REG_STATE_OFF: |
|
ctrl->ctrl0_11[0] &= ~BIT(6); |
|
break; |
|
case RMI_REG_STATE_ON: |
|
ctrl->ctrl0_11[0] |= BIT(6); |
|
break; |
|
case RMI_REG_STATE_DEFAULT: |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
if (f11->sens_query.has_palm_det) { |
|
switch (sensor->palm_detect) { |
|
case RMI_REG_STATE_OFF: |
|
ctrl->ctrl0_11[11] &= ~BIT(0); |
|
break; |
|
case RMI_REG_STATE_ON: |
|
ctrl->ctrl0_11[11] |= BIT(0); |
|
break; |
|
case RMI_REG_STATE_DEFAULT: |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
rc = f11_write_control_regs(fn, &f11->sens_query, |
|
&f11->dev_controls, fn->fd.control_base_addr); |
|
if (rc) |
|
dev_warn(&fn->dev, "Failed to write control registers\n"); |
|
|
|
mutex_init(&f11->dev_controls_mutex); |
|
|
|
dev_set_drvdata(&fn->dev, f11); |
|
|
|
return 0; |
|
} |
|
|
|
static int rmi_f11_config(struct rmi_function *fn) |
|
{ |
|
struct f11_data *f11 = dev_get_drvdata(&fn->dev); |
|
struct rmi_driver *drv = fn->rmi_dev->driver; |
|
struct rmi_2d_sensor *sensor = &f11->sensor; |
|
int rc; |
|
|
|
if (!sensor->report_abs) |
|
drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask); |
|
else |
|
drv->set_irq_bits(fn->rmi_dev, f11->abs_mask); |
|
|
|
if (!sensor->report_rel) |
|
drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask); |
|
else |
|
drv->set_irq_bits(fn->rmi_dev, f11->rel_mask); |
|
|
|
rc = f11_write_control_regs(fn, &f11->sens_query, |
|
&f11->dev_controls, fn->fd.query_base_addr); |
|
if (rc < 0) |
|
return rc; |
|
|
|
return 0; |
|
} |
|
|
|
static irqreturn_t rmi_f11_attention(int irq, void *ctx) |
|
{ |
|
struct rmi_function *fn = ctx; |
|
struct rmi_device *rmi_dev = fn->rmi_dev; |
|
struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); |
|
struct f11_data *f11 = dev_get_drvdata(&fn->dev); |
|
u16 data_base_addr = fn->fd.data_base_addr; |
|
int error; |
|
int valid_bytes = f11->sensor.pkt_size; |
|
|
|
if (drvdata->attn_data.data) { |
|
/* |
|
* The valid data in the attention report is less then |
|
* expected. Only process the complete fingers. |
|
*/ |
|
if (f11->sensor.attn_size > drvdata->attn_data.size) |
|
valid_bytes = drvdata->attn_data.size; |
|
else |
|
valid_bytes = f11->sensor.attn_size; |
|
memcpy(f11->sensor.data_pkt, drvdata->attn_data.data, |
|
valid_bytes); |
|
drvdata->attn_data.data += valid_bytes; |
|
drvdata->attn_data.size -= valid_bytes; |
|
} else { |
|
error = rmi_read_block(rmi_dev, |
|
data_base_addr, f11->sensor.data_pkt, |
|
f11->sensor.pkt_size); |
|
if (error < 0) |
|
return IRQ_RETVAL(error); |
|
} |
|
|
|
rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static int rmi_f11_resume(struct rmi_function *fn) |
|
{ |
|
struct f11_data *f11 = dev_get_drvdata(&fn->dev); |
|
int error; |
|
|
|
rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n"); |
|
if (!f11->rezero_wait_ms) |
|
return 0; |
|
|
|
mdelay(f11->rezero_wait_ms); |
|
|
|
error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr, |
|
RMI_F11_REZERO); |
|
if (error) { |
|
dev_err(&fn->dev, |
|
"%s: failed to issue rezero command, error = %d.", |
|
__func__, error); |
|
return error; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int rmi_f11_probe(struct rmi_function *fn) |
|
{ |
|
int error; |
|
struct f11_data *f11; |
|
|
|
error = rmi_f11_initialize(fn); |
|
if (error) |
|
return error; |
|
|
|
f11 = dev_get_drvdata(&fn->dev); |
|
error = rmi_2d_sensor_configure_input(fn, &f11->sensor); |
|
if (error) |
|
return error; |
|
|
|
return 0; |
|
} |
|
|
|
struct rmi_function_handler rmi_f11_handler = { |
|
.driver = { |
|
.name = "rmi4_f11", |
|
}, |
|
.func = 0x11, |
|
.probe = rmi_f11_probe, |
|
.config = rmi_f11_config, |
|
.attention = rmi_f11_attention, |
|
.resume = rmi_f11_resume, |
|
};
|
|
|