1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2011-2015 Synaptics Incorporated
   4 * Copyright (c) 2011 Unixphere
   5 */
   6
   7#include <linux/kernel.h>
   8#include <linux/delay.h>
   9#include <linux/device.h>
  10#include <linux/input.h>
  11#include <linux/input/mt.h>
  12#include <linux/rmi.h>
  13#include <linux/slab.h>
  14#include <linux/of.h>
  15#include "rmi_driver.h"
  16#include "rmi_2d_sensor.h"
  17
  18#define F11_MAX_NUM_OF_FINGERS		10
  19#define F11_MAX_NUM_OF_TOUCH_SHAPES	16
  20
  21#define FINGER_STATE_MASK	0x03
  22
  23#define F11_CTRL_SENSOR_MAX_X_POS_OFFSET	6
  24#define F11_CTRL_SENSOR_MAX_Y_POS_OFFSET	8
  25
  26#define DEFAULT_XY_MAX 9999
  27#define DEFAULT_MAX_ABS_MT_PRESSURE 255
  28#define DEFAULT_MAX_ABS_MT_TOUCH 15
  29#define DEFAULT_MAX_ABS_MT_ORIENTATION 1
  30#define DEFAULT_MIN_ABS_MT_TRACKING_ID 1
  31#define DEFAULT_MAX_ABS_MT_TRACKING_ID 10
  32
  33/*
  34 * A note about RMI4 F11 register structure.
  35 *
  36 * The properties for a given sensor are described by its query registers.  The
  37 * number of query registers and the layout of their contents are described by
  38 * the F11 device queries as well as the sensor query information.
  39 *
  40 * Similarly, each sensor has control registers that govern its behavior.  The
  41 * size and layout of the control registers for a given sensor can be determined
  42 * by parsing that sensors query registers.
  43 *
  44 * And in a likewise fashion, each sensor has data registers where it reports
  45 * its touch data and other interesting stuff.  The size and layout of a
  46 * sensors data registers must be determined by parsing its query registers.
  47 *
  48 * The short story is that we need to read and parse a lot of query
  49 * registers in order to determine the attributes of a sensor. Then
  50 * we need to use that data to compute the size of the control and data
  51 * registers for sensor.
  52 *
  53 * The end result is that we have a number of structs that aren't used to
  54 * directly generate the input events, but their size, location and contents
  55 * are critical to determining where the data we are interested in lives.
  56 *
  57 * At this time, the driver does not yet comprehend all possible F11
  58 * configuration options, but it should be sufficient to cover 99% of RMI4 F11
  59 * devices currently in the field.
  60 */
  61
  62/* maximum ABS_MT_POSITION displacement (in mm) */
  63#define DMAX 10
  64
  65/*
  66 * Writing this to the F11 command register will cause the sensor to
  67 * calibrate to the current capacitive state.
  68 */
  69#define RMI_F11_REZERO  0x01
  70
  71#define RMI_F11_HAS_QUERY9              (1 << 3)
  72#define RMI_F11_HAS_QUERY11             (1 << 4)
  73#define RMI_F11_HAS_QUERY12             (1 << 5)
  74#define RMI_F11_HAS_QUERY27             (1 << 6)
  75#define RMI_F11_HAS_QUERY28             (1 << 7)
  76
  77/** Defs for Query 1 */
  78
  79#define RMI_F11_NR_FINGERS_MASK 0x07
  80#define RMI_F11_HAS_REL                 (1 << 3)
  81#define RMI_F11_HAS_ABS                 (1 << 4)
  82#define RMI_F11_HAS_GESTURES            (1 << 5)
  83#define RMI_F11_HAS_SENSITIVITY_ADJ     (1 << 6)
  84#define RMI_F11_CONFIGURABLE            (1 << 7)
  85
  86/** Defs for Query 2, 3, and 4. */
  87#define RMI_F11_NR_ELECTRODES_MASK      0x7F
  88
  89/** Defs for Query 5 */
  90
  91#define RMI_F11_ABS_DATA_SIZE_MASK      0x03
  92#define RMI_F11_HAS_ANCHORED_FINGER     (1 << 2)
  93#define RMI_F11_HAS_ADJ_HYST            (1 << 3)
  94#define RMI_F11_HAS_DRIBBLE             (1 << 4)
  95#define RMI_F11_HAS_BENDING_CORRECTION  (1 << 5)
  96#define RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION    (1 << 6)
  97#define RMI_F11_HAS_JITTER_FILTER       (1 << 7)
  98
  99/** Defs for Query 7 */
 100#define RMI_F11_HAS_SINGLE_TAP                  (1 << 0)
 101#define RMI_F11_HAS_TAP_AND_HOLD                (1 << 1)
 102#define RMI_F11_HAS_DOUBLE_TAP                  (1 << 2)
 103#define RMI_F11_HAS_EARLY_TAP                   (1 << 3)
 104#define RMI_F11_HAS_FLICK                       (1 << 4)
 105#define RMI_F11_HAS_PRESS                       (1 << 5)
 106#define RMI_F11_HAS_PINCH                       (1 << 6)
 107#define RMI_F11_HAS_CHIRAL                      (1 << 7)
 108
 109/** Defs for Query 8 */
 110#define RMI_F11_HAS_PALM_DET                    (1 << 0)
 111#define RMI_F11_HAS_ROTATE                      (1 << 1)
 112#define RMI_F11_HAS_TOUCH_SHAPES                (1 << 2)
 113#define RMI_F11_HAS_SCROLL_ZONES                (1 << 3)
 114#define RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES     (1 << 4)
 115#define RMI_F11_HAS_MF_SCROLL                   (1 << 5)
 116#define RMI_F11_HAS_MF_EDGE_MOTION              (1 << 6)
 117#define RMI_F11_HAS_MF_SCROLL_INERTIA           (1 << 7)
 118
 119/** Defs for Query 9. */
 120#define RMI_F11_HAS_PEN                         (1 << 0)
 121#define RMI_F11_HAS_PROXIMITY                   (1 << 1)
 122#define RMI_F11_HAS_PALM_DET_SENSITIVITY        (1 << 2)
 123#define RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT     (1 << 3)
 124#define RMI_F11_HAS_TWO_PEN_THRESHOLDS          (1 << 4)
 125#define RMI_F11_HAS_CONTACT_GEOMETRY            (1 << 5)
 126#define RMI_F11_HAS_PEN_HOVER_DISCRIMINATION    (1 << 6)
 127#define RMI_F11_HAS_PEN_FILTERS                 (1 << 7)
 128
 129/** Defs for Query 10. */
 130#define RMI_F11_NR_TOUCH_SHAPES_MASK            0x1F
 131
 132/** Defs for Query 11 */
 133
 134#define RMI_F11_HAS_Z_TUNING                    (1 << 0)
 135#define RMI_F11_HAS_ALGORITHM_SELECTION         (1 << 1)
 136#define RMI_F11_HAS_W_TUNING                    (1 << 2)
 137#define RMI_F11_HAS_PITCH_INFO                  (1 << 3)
 138#define RMI_F11_HAS_FINGER_SIZE                 (1 << 4)
 139#define RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS (1 << 5)
 140#define RMI_F11_HAS_XY_CLIP                     (1 << 6)
 141#define RMI_F11_HAS_DRUMMING_FILTER             (1 << 7)
 142
 143/** Defs for Query 12. */
 144
 145#define RMI_F11_HAS_GAPLESS_FINGER              (1 << 0)
 146#define RMI_F11_HAS_GAPLESS_FINGER_TUNING       (1 << 1)
 147#define RMI_F11_HAS_8BIT_W                      (1 << 2)
 148#define RMI_F11_HAS_ADJUSTABLE_MAPPING          (1 << 3)
 149#define RMI_F11_HAS_INFO2                       (1 << 4)
 150#define RMI_F11_HAS_PHYSICAL_PROPS              (1 << 5)
 151#define RMI_F11_HAS_FINGER_LIMIT                (1 << 6)
 152#define RMI_F11_HAS_LINEAR_COEFF                (1 << 7)
 153
 154/** Defs for Query 13. */
 155
 156#define RMI_F11_JITTER_WINDOW_MASK              0x1F
 157#define RMI_F11_JITTER_FILTER_MASK              0x60
 158#define RMI_F11_JITTER_FILTER_SHIFT             5
 159
 160/** Defs for Query 14. */
 161#define RMI_F11_LIGHT_CONTROL_MASK              0x03
 162#define RMI_F11_IS_CLEAR                        (1 << 2)
 163#define RMI_F11_CLICKPAD_PROPS_MASK             0x18
 164#define RMI_F11_CLICKPAD_PROPS_SHIFT            3
 165#define RMI_F11_MOUSE_BUTTONS_MASK              0x60
 166#define RMI_F11_MOUSE_BUTTONS_SHIFT             5
 167#define RMI_F11_HAS_ADVANCED_GESTURES           (1 << 7)
 168
 169#define RMI_F11_QUERY_SIZE                      4
 170#define RMI_F11_QUERY_GESTURE_SIZE              2
 171
 172#define F11_LIGHT_CTL_NONE 0x00
 173#define F11_LUXPAD	   0x01
 174#define F11_DUAL_MODE      0x02
 175
 176#define F11_NOT_CLICKPAD     0x00
 177#define F11_HINGED_CLICKPAD  0x01
 178#define F11_UNIFORM_CLICKPAD 0x02
 179
 180/**
 181 * struct f11_2d_sensor_queries - describes sensor capabilities
 182 *
 183 * Query registers 1 through 4 are always present.
 184 *
 185 * @nr_fingers: describes the maximum number of fingers the 2-D sensor
 186 *	supports.
 187 * @has_rel: the sensor supports relative motion reporting.
 188 * @has_abs: the sensor supports absolute poition reporting.
 189 * @has_gestures: the sensor supports gesture reporting.
 190 * @has_sensitivity_adjust: the sensor supports a global sensitivity
 191 *	adjustment.
 192 * @configurable: the sensor supports various configuration options.
 193 * @nr_x_electrodes:  the maximum number of electrodes the 2-D sensor
 194 *	supports on the X axis.
 195 * @nr_y_electrodes:  the maximum number of electrodes the 2-D sensor
 196 *	supports on the Y axis.
 197 * @max_electrodes: the total number of X and Y electrodes that may be
 198 *	configured.
 199 *
 200 * Query 5 is present if the has_abs bit is set.
 201 *
 202 * @abs_data_size: describes the format of data reported by the absolute
 203 *	data source.  Only one format (the kind used here) is supported at this
 204 *	time.
 205 * @has_anchored_finger: then the sensor supports the high-precision second
 206 *	finger tracking provided by the manual tracking and motion sensitivity
 207 *	options.
 208 * @has_adj_hyst: the difference between the finger release threshold and
 209 *	the touch threshold.
 210 * @has_dribble: the sensor supports the generation of dribble interrupts,
 211 *	which may be enabled or disabled with the dribble control bit.
 212 * @has_bending_correction: Bending related data registers 28 and 36, and
 213 *	control register 52..57 are present.
 214 * @has_large_object_suppression: control register 58 and data register 28
 215 *	exist.
 216 * @has_jitter_filter: query 13 and control 73..76 exist.
 217 *
 218 * Query 6 is present if the has_rel it is set.
 219 *
 220 * @f11_2d_query6: this register is reserved.
 221 *
 222 * Gesture information queries 7 and 8 are present if has_gestures bit is set.
 223 *
 224 * @has_single_tap: a basic single-tap gesture is supported.
 225 * @has_tap_n_hold: tap-and-hold gesture is supported.
 226 * @has_double_tap: double-tap gesture is supported.
 227 * @has_early_tap: early tap is supported and reported as soon as the finger
 228 *	lifts for any tap event that could be interpreted as either a single
 229 *	tap or as the first tap of a double-tap or tap-and-hold gesture.
 230 * @has_flick: flick detection is supported.
 231 * @has_press: press gesture reporting is supported.
 232 * @has_pinch: pinch gesture detection is supported.
 233 * @has_chiral: chiral (circular) scrolling  gesture detection is supported.
 234 * @has_palm_det: the 2-D sensor notifies the host whenever a large conductive
 235 *	object such as a palm or a cheek touches the 2-D sensor.
 236 * @has_rotate: rotation gesture detection is supported.
 237 * @has_touch_shapes: TouchShapes are supported.  A TouchShape is a fixed
 238 *	rectangular area on the sensor that behaves like a capacitive button.
 239 * @has_scroll_zones: scrolling areas near the sensor edges are supported.
 240 * @has_individual_scroll_zones: if 1, then 4 scroll zones are supported;
 241 *	if 0, then only two are supported.
 242 * @has_mf_scroll: the multifinger_scrolling bit will be set when
 243 *	more than one finger is involved in a scrolling action.
 244 * @has_mf_edge_motion: indicates whether multi-finger edge motion gesture
 245 *	is supported.
 246 * @has_mf_scroll_inertia: indicates whether multi-finger scroll inertia
 247 *	feature is supported.
 248 *
 249 * Convenience for checking bytes in the gesture info registers.  This is done
 250 * often enough that we put it here to declutter the conditionals
 251 *
 252 * @query7_nonzero: true if none of the query 7 bits are set
 253 * @query8_nonzero: true if none of the query 8 bits are set
 254 *
 255 * Query 9 is present if the has_query9 is set.
 256 *
 257 * @has_pen: detection of a stylus is supported and registers F11_2D_Ctrl20
 258 *	and F11_2D_Ctrl21 exist.
 259 * @has_proximity: detection of fingers near the sensor is supported and
 260 *	registers F11_2D_Ctrl22 through F11_2D_Ctrl26 exist.
 261 * @has_palm_det_sensitivity:  the sensor supports the palm detect sensitivity
 262 *	feature and register F11_2D_Ctrl27 exists.
 263 * @has_suppress_on_palm_detect: the device supports the large object detect
 264 *	suppression feature and register F11_2D_Ctrl27 exists.
 265 * @has_two_pen_thresholds: if has_pen is also set, then F11_2D_Ctrl35 exists.
 266 * @has_contact_geometry: the sensor supports the use of contact geometry to
 267 *	map absolute X and Y target positions and registers F11_2D_Data18
 268 *	through F11_2D_Data27 exist.
 269 * @has_pen_hover_discrimination: if has_pen is also set, then registers
 270 *	F11_2D_Data29 through F11_2D_Data31, F11_2D_Ctrl68.*, F11_2D_Ctrl69
 271 *	and F11_2D_Ctrl72 exist.
 272 * @has_pen_filters: if has_pen is also set, then registers F11_2D_Ctrl70 and
 273 *	F11_2D_Ctrl71 exist.
 274 *
 275 * Touch shape info (query 10) is present if has_touch_shapes is set.
 276 *
 277 * @nr_touch_shapes: the total number of touch shapes supported.
 278 *
 279 * Query 11 is present if the has_query11 bit is set in query 0.
 280 *
 281 * @has_z_tuning: if set, the sensor supports Z tuning and registers
 282 *	F11_2D_Ctrl29 through F11_2D_Ctrl33 exist.
 283 * @has_algorithm_selection: controls choice of noise suppression algorithm
 284 * @has_w_tuning: the sensor supports Wx and Wy scaling and registers
 285 *	F11_2D_Ctrl36 through F11_2D_Ctrl39 exist.
 286 * @has_pitch_info: the X and Y pitches of the sensor electrodes can be
 287 *	configured and registers F11_2D_Ctrl40 and F11_2D_Ctrl41 exist.
 288 * @has_finger_size: the default finger width settings for the sensor
 289 *	can be configured and registers F11_2D_Ctrl42 through F11_2D_Ctrl44
 290 *	exist.
 291 * @has_segmentation_aggressiveness: the sensor’s ability to distinguish
 292 *	multiple objects close together can be configured and register
 293 *	F11_2D_Ctrl45 exists.
 294 * @has_XY_clip: the inactive outside borders of the sensor can be
 295 *	configured and registers F11_2D_Ctrl46 through F11_2D_Ctrl49 exist.
 296 * @has_drumming_filter: the sensor can be configured to distinguish
 297 *	between a fast flick and a quick drumming movement and registers
 298 *	F11_2D_Ctrl50 and F11_2D_Ctrl51 exist.
 299 *
 300 * Query 12 is present if hasQuery12 bit is set.
 301 *
 302 * @has_gapless_finger: control registers relating to gapless finger are
 303 *	present.
 304 * @has_gapless_finger_tuning: additional control and data registers relating
 305 *	to gapless finger are present.
 306 * @has_8bit_w: larger W value reporting is supported.
 307 * @has_adjustable_mapping: TBD
 308 * @has_info2: the general info query14 is present
 309 * @has_physical_props: additional queries describing the physical properties
 310 *	of the sensor are present.
 311 * @has_finger_limit: indicates that F11 Ctrl 80 exists.
 312 * @has_linear_coeff_2: indicates that F11 Ctrl 81 exists.
 313 *
 314 * Query 13 is present if Query 5's has_jitter_filter bit is set.
 315 *
 316 * @jitter_window_size: used by Design Studio 4.
 317 * @jitter_filter_type: used by Design Studio 4.
 318 *
 319 * Query 14 is present if query 12's has_general_info2 flag is set.
 320 *
 321 * @light_control: Indicates what light/led control features are present,
 322 *	if any.
 323 * @is_clear: if set, this is a clear sensor (indicating direct pointing
 324 *	application), otherwise it's opaque (indicating indirect pointing).
 325 * @clickpad_props: specifies if this is a clickpad, and if so what sort of
 326 *	mechanism it uses
 327 * @mouse_buttons: specifies the number of mouse buttons present (if any).
 328 * @has_advanced_gestures: advanced driver gestures are supported.
 329 *
 330 * @x_sensor_size_mm: size of the sensor in millimeters on the X axis.
 331 * @y_sensor_size_mm: size of the sensor in millimeters on the Y axis.
 332 */
 333struct f11_2d_sensor_queries {
 334	/* query1 */
 335	u8 nr_fingers;
 336	bool has_rel;
 337	bool has_abs;
 338	bool has_gestures;
 339	bool has_sensitivity_adjust;
 340	bool configurable;
 341
 342	/* query2 */
 343	u8 nr_x_electrodes;
 344
 345	/* query3 */
 346	u8 nr_y_electrodes;
 347
 348	/* query4 */
 349	u8 max_electrodes;
 350
 351	/* query5 */
 352	u8 abs_data_size;
 353	bool has_anchored_finger;
 354	bool has_adj_hyst;
 355	bool has_dribble;
 356	bool has_bending_correction;
 357	bool has_large_object_suppression;
 358	bool has_jitter_filter;
 359
 360	u8 f11_2d_query6;
 361
 362	/* query 7 */
 363	bool has_single_tap;
 364	bool has_tap_n_hold;
 365	bool has_double_tap;
 366	bool has_early_tap;
 367	bool has_flick;
 368	bool has_press;
 369	bool has_pinch;
 370	bool has_chiral;
 371
 372	bool query7_nonzero;
 373
 374	/* query 8 */
 375	bool has_palm_det;
 376	bool has_rotate;
 377	bool has_touch_shapes;
 378	bool has_scroll_zones;
 379	bool has_individual_scroll_zones;
 380	bool has_mf_scroll;
 381	bool has_mf_edge_motion;
 382	bool has_mf_scroll_inertia;
 383
 384	bool query8_nonzero;
 385
 386	/* Query 9 */
 387	bool has_pen;
 388	bool has_proximity;
 389	bool has_palm_det_sensitivity;
 390	bool has_suppress_on_palm_detect;
 391	bool has_two_pen_thresholds;
 392	bool has_contact_geometry;
 393	bool has_pen_hover_discrimination;
 394	bool has_pen_filters;
 395
 396	/* Query 10 */
 397	u8 nr_touch_shapes;
 398
 399	/* Query 11. */
 400	bool has_z_tuning;
 401	bool has_algorithm_selection;
 402	bool has_w_tuning;
 403	bool has_pitch_info;
 404	bool has_finger_size;
 405	bool has_segmentation_aggressiveness;
 406	bool has_XY_clip;
 407	bool has_drumming_filter;
 408
 409	/* Query 12 */
 410	bool has_gapless_finger;
 411	bool has_gapless_finger_tuning;
 412	bool has_8bit_w;
 413	bool has_adjustable_mapping;
 414	bool has_info2;
 415	bool has_physical_props;
 416	bool has_finger_limit;
 417	bool has_linear_coeff_2;
 418
 419	/* Query 13 */
 420	u8 jitter_window_size;
 421	u8 jitter_filter_type;
 422
 423	/* Query 14 */
 424	u8 light_control;
 425	bool is_clear;
 426	u8 clickpad_props;
 427	u8 mouse_buttons;
 428	bool has_advanced_gestures;
 429
 430	/* Query 15 - 18 */
 431	u16 x_sensor_size_mm;
 432	u16 y_sensor_size_mm;
 433};
 434
 435/* Defs for Ctrl0. */
 436#define RMI_F11_REPORT_MODE_MASK        0x07
 437#define RMI_F11_REPORT_MODE_CONTINUOUS  (0 << 0)
 438#define RMI_F11_REPORT_MODE_REDUCED     (1 << 0)
 439#define RMI_F11_REPORT_MODE_FS_CHANGE   (2 << 0)
 440#define RMI_F11_REPORT_MODE_FP_CHANGE   (3 << 0)
 441#define RMI_F11_ABS_POS_FILT            (1 << 3)
 442#define RMI_F11_REL_POS_FILT            (1 << 4)
 443#define RMI_F11_REL_BALLISTICS          (1 << 5)
 444#define RMI_F11_DRIBBLE                 (1 << 6)
 445#define RMI_F11_REPORT_BEYOND_CLIP      (1 << 7)
 446
 447/* Defs for Ctrl1. */
 448#define RMI_F11_PALM_DETECT_THRESH_MASK 0x0F
 449#define RMI_F11_MOTION_SENSITIVITY_MASK 0x30
 450#define RMI_F11_MANUAL_TRACKING         (1 << 6)
 451#define RMI_F11_MANUAL_TRACKED_FINGER   (1 << 7)
 452
 453#define RMI_F11_DELTA_X_THRESHOLD       2
 454#define RMI_F11_DELTA_Y_THRESHOLD       3
 455
 456#define RMI_F11_CTRL_REG_COUNT          12
 457
 458struct f11_2d_ctrl {
 459	u8              ctrl0_11[RMI_F11_CTRL_REG_COUNT];
 460	u16             ctrl0_11_address;
 461};
 462
 463#define RMI_F11_ABS_BYTES 5
 464#define RMI_F11_REL_BYTES 2
 465
 466/* Defs for Data 8 */
 467
 468#define RMI_F11_SINGLE_TAP              (1 << 0)
 469#define RMI_F11_TAP_AND_HOLD            (1 << 1)
 470#define RMI_F11_DOUBLE_TAP              (1 << 2)
 471#define RMI_F11_EARLY_TAP               (1 << 3)
 472#define RMI_F11_FLICK                   (1 << 4)
 473#define RMI_F11_PRESS                   (1 << 5)
 474#define RMI_F11_PINCH                   (1 << 6)
 475
 476/* Defs for Data 9 */
 477
 478#define RMI_F11_PALM_DETECT                     (1 << 0)
 479#define RMI_F11_ROTATE                          (1 << 1)
 480#define RMI_F11_SHAPE                           (1 << 2)
 481#define RMI_F11_SCROLLZONE                      (1 << 3)
 482#define RMI_F11_GESTURE_FINGER_COUNT_MASK       0x70
 483
 484/** Handy pointers into our data buffer.
 485 *
 486 * @f_state - start of finger state registers.
 487 * @abs_pos - start of absolute position registers (if present).
 488 * @rel_pos - start of relative data registers (if present).
 489 * @gest_1  - gesture flags (if present).
 490 * @gest_2  - gesture flags & finger count (if present).
 491 * @pinch   - pinch motion register (if present).
 492 * @flick   - flick distance X & Y, flick time (if present).
 493 * @rotate  - rotate motion and finger separation.
 494 * @multi_scroll - chiral deltas for X and Y (if present).
 495 * @scroll_zones - scroll deltas for 4 regions (if present).
 496 */
 497struct f11_2d_data {
 498	u8	*f_state;
 499	u8	*abs_pos;
 500	s8	*rel_pos;
 501	u8	*gest_1;
 502	u8	*gest_2;
 503	s8	*pinch;
 504	u8	*flick;
 505	u8	*rotate;
 506	u8	*shapes;
 507	s8	*multi_scroll;
 508	s8	*scroll_zones;
 509};
 510
 511/** Data pertaining to F11 in general.  For per-sensor data, see struct
 512 * f11_2d_sensor.
 513 *
 514 * @dev_query - F11 device specific query registers.
 515 * @dev_controls - F11 device specific control registers.
 516 * @dev_controls_mutex - lock for the control registers.
 517 * @rezero_wait_ms - if nonzero, upon resume we will wait this many
 518 * milliseconds before rezeroing the sensor(s).  This is useful in systems with
 519 * poor electrical behavior on resume, where the initial calibration of the
 520 * sensor(s) coming out of sleep state may be bogus.
 521 * @sensors - per sensor data structures.
 522 */
 523struct f11_data {
 524	bool has_query9;
 525	bool has_query11;
 526	bool has_query12;
 527	bool has_query27;
 528	bool has_query28;
 529	bool has_acm;
 530	struct f11_2d_ctrl dev_controls;
 531	struct mutex dev_controls_mutex;
 532	u16 rezero_wait_ms;
 533	struct rmi_2d_sensor sensor;
 534	struct f11_2d_sensor_queries sens_query;
 535	struct f11_2d_data data;
 536	struct rmi_2d_sensor_platform_data sensor_pdata;
 537	unsigned long *abs_mask;
 538	unsigned long *rel_mask;
 539};
 540
 541enum f11_finger_state {
 542	F11_NO_FINGER	= 0x00,
 543	F11_PRESENT	= 0x01,
 544	F11_INACCURATE	= 0x02,
 545	F11_RESERVED	= 0x03
 546};
 547
 548static void rmi_f11_rel_pos_report(struct f11_data *f11, u8 n_finger)
 549{
 550	struct rmi_2d_sensor *sensor = &f11->sensor;
 551	struct f11_2d_data *data = &f11->data;
 552	s8 x, y;
 553
 554	x = data->rel_pos[n_finger * RMI_F11_REL_BYTES];
 555	y = data->rel_pos[n_finger * RMI_F11_REL_BYTES + 1];
 556
 557	rmi_2d_sensor_rel_report(sensor, x, y);
 558}
 559
 560static void rmi_f11_abs_pos_process(struct f11_data *f11,
 561				   struct rmi_2d_sensor *sensor,
 562				   struct rmi_2d_sensor_abs_object *obj,
 563				   enum f11_finger_state finger_state,
 564				   u8 n_finger)
 565{
 566	struct f11_2d_data *data = &f11->data;
 567	u8 *pos_data = &data->abs_pos[n_finger * RMI_F11_ABS_BYTES];
 568	int tool_type = MT_TOOL_FINGER;
 569
 570	switch (finger_state) {
 571	case F11_PRESENT:
 572		obj->type = RMI_2D_OBJECT_FINGER;
 573		break;
 574	default:
 575		obj->type = RMI_2D_OBJECT_NONE;
 576	}
 577
 578	obj->mt_tool = tool_type;
 579	obj->x = (pos_data[0] << 4) | (pos_data[2] & 0x0F);
 580	obj->y = (pos_data[1] << 4) | (pos_data[2] >> 4);
 581	obj->z = pos_data[4];
 582	obj->wx = pos_data[3] & 0x0f;
 583	obj->wy = pos_data[3] >> 4;
 584
 585	rmi_2d_sensor_abs_process(sensor, obj, n_finger);
 586}
 587
 588static inline u8 rmi_f11_parse_finger_state(const u8 *f_state, u8 n_finger)
 589{
 590	return (f_state[n_finger / 4] >> (2 * (n_finger % 4))) &
 591							FINGER_STATE_MASK;
 592}
 593
 594static void rmi_f11_finger_handler(struct f11_data *f11,
 595				   struct rmi_2d_sensor *sensor, int size)
 596{
 597	const u8 *f_state = f11->data.f_state;
 598	u8 finger_state;
 599	u8 i;
 600	int abs_fingers;
 601	int rel_fingers;
 602	int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES;
 603
 604	if (sensor->report_abs) {
 605		if (abs_size > size)
 606			abs_fingers = size / RMI_F11_ABS_BYTES;
 607		else
 608			abs_fingers = sensor->nbr_fingers;
 609
 610		for (i = 0; i < abs_fingers; i++) {
 611			/* Possible of having 4 fingers per f_state register */
 612			finger_state = rmi_f11_parse_finger_state(f_state, i);
 613			if (finger_state == F11_RESERVED) {
 614				pr_err("Invalid finger state[%d]: 0x%02x", i,
 615					finger_state);
 616				continue;
 617			}
 618
 619			rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i],
 620							finger_state, i);
 621		}
 622
 623		/*
 624		 * the absolute part is made in 2 parts to allow the kernel
 625		 * tracking to take place.
 626		 */
 627		if (sensor->kernel_tracking)
 628			input_mt_assign_slots(sensor->input,
 629					      sensor->tracking_slots,
 630					      sensor->tracking_pos,
 631					      sensor->nbr_fingers,
 632					      sensor->dmax);
 633
 634		for (i = 0; i < abs_fingers; i++) {
 635			finger_state = rmi_f11_parse_finger_state(f_state, i);
 636			if (finger_state == F11_RESERVED)
 637				/* no need to send twice the error */
 638				continue;
 639
 640			rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
 641		}
 642
 643		input_mt_sync_frame(sensor->input);
 644	} else if (sensor->report_rel) {
 645		if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
 646			rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
 647		else
 648			rel_fingers = sensor->nbr_fingers;
 649
 650		for (i = 0; i < rel_fingers; i++)
 651			rmi_f11_rel_pos_report(f11, i);
 652	}
 653
 654}
 655
 656static int f11_2d_construct_data(struct f11_data *f11)
 657{
 658	struct rmi_2d_sensor *sensor = &f11->sensor;
 659	struct f11_2d_sensor_queries *query = &f11->sens_query;
 660	struct f11_2d_data *data = &f11->data;
 661	int i;
 662
 663	sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 :
 664				query->nr_fingers + 1);
 665
 666	sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4);
 667
 668	if (query->has_abs) {
 669		sensor->pkt_size += (sensor->nbr_fingers * 5);
 670		sensor->attn_size = sensor->pkt_size;
 671	}
 672
 673	if (query->has_rel)
 674		sensor->pkt_size +=  (sensor->nbr_fingers * 2);
 675
 676	/* Check if F11_2D_Query7 is non-zero */
 677	if (query->query7_nonzero)
 678		sensor->pkt_size += sizeof(u8);
 679
 680	/* Check if F11_2D_Query7 or F11_2D_Query8 is non-zero */
 681	if (query->query7_nonzero || query->query8_nonzero)
 682		sensor->pkt_size += sizeof(u8);
 683
 684	if (query->has_pinch || query->has_flick || query->has_rotate) {
 685		sensor->pkt_size += 3;
 686		if (!query->has_flick)
 687			sensor->pkt_size--;
 688		if (!query->has_rotate)
 689			sensor->pkt_size--;
 690	}
 691
 692	if (query->has_touch_shapes)
 693		sensor->pkt_size +=
 694			DIV_ROUND_UP(query->nr_touch_shapes + 1, 8);
 695
 696	sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size,
 697					GFP_KERNEL);
 698	if (!sensor->data_pkt)
 699		return -ENOMEM;
 700
 701	data->f_state = sensor->data_pkt;
 702	i = DIV_ROUND_UP(sensor->nbr_fingers, 4);
 703
 704	if (query->has_abs) {
 705		data->abs_pos = &sensor->data_pkt[i];
 706		i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES);
 707	}
 708
 709	if (query->has_rel) {
 710		data->rel_pos = &sensor->data_pkt[i];
 711		i += (sensor->nbr_fingers * RMI_F11_REL_BYTES);
 712	}
 713
 714	if (query->query7_nonzero) {
 715		data->gest_1 = &sensor->data_pkt[i];
 716		i++;
 717	}
 718
 719	if (query->query7_nonzero || query->query8_nonzero) {
 720		data->gest_2 = &sensor->data_pkt[i];
 721		i++;
 722	}
 723
 724	if (query->has_pinch) {
 725		data->pinch = &sensor->data_pkt[i];
 726		i++;
 727	}
 728
 729	if (query->has_flick) {
 730		if (query->has_pinch) {
 731			data->flick = data->pinch;
 732			i += 2;
 733		} else {
 734			data->flick = &sensor->data_pkt[i];
 735			i += 3;
 736		}
 737	}
 738
 739	if (query->has_rotate) {
 740		if (query->has_flick) {
 741			data->rotate = data->flick + 1;
 742		} else {
 743			data->rotate = &sensor->data_pkt[i];
 744			i += 2;
 745		}
 746	}
 747
 748	if (query->has_touch_shapes)
 749		data->shapes = &sensor->data_pkt[i];
 750
 751	return 0;
 752}
 753
 754static int f11_read_control_regs(struct rmi_function *fn,
 755				struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) {
 756	struct rmi_device *rmi_dev = fn->rmi_dev;
 757	int error = 0;
 758
 759	ctrl->ctrl0_11_address = ctrl_base_addr;
 760	error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
 761				RMI_F11_CTRL_REG_COUNT);
 762	if (error < 0) {
 763		dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error);
 764		return error;
 765	}
 766
 767	return 0;
 768}
 769
 770static int f11_write_control_regs(struct rmi_function *fn,
 771					struct f11_2d_sensor_queries *query,
 772					struct f11_2d_ctrl *ctrl,
 773					u16 ctrl_base_addr)
 774{
 775	struct rmi_device *rmi_dev = fn->rmi_dev;
 776	int error;
 777
 778	error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
 779				RMI_F11_CTRL_REG_COUNT);
 780	if (error < 0)
 781		return error;
 782
 783	return 0;
 784}
 785
 786static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev,
 787			struct f11_data *f11,
 788			struct f11_2d_sensor_queries *sensor_query,
 789			u16 query_base_addr)
 790{
 791	int query_size;
 792	int rc;
 793	u8 query_buf[RMI_F11_QUERY_SIZE];
 794	bool has_query36 = false;
 795
 796	rc = rmi_read_block(rmi_dev, query_base_addr, query_buf,
 797				RMI_F11_QUERY_SIZE);
 798	if (rc < 0)
 799		return rc;
 800
 801	sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK;
 802	sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL);
 803	sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS);
 804	sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES);
 805	sensor_query->has_sensitivity_adjust =
 806		!!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ);
 807	sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE);
 808
 809	sensor_query->nr_x_electrodes =
 810				query_buf[1] & RMI_F11_NR_ELECTRODES_MASK;
 811	sensor_query->nr_y_electrodes =
 812				query_buf[2] & RMI_F11_NR_ELECTRODES_MASK;
 813	sensor_query->max_electrodes =
 814				query_buf[3] & RMI_F11_NR_ELECTRODES_MASK;
 815
 816	query_size = RMI_F11_QUERY_SIZE;
 817
 818	if (sensor_query->has_abs) {
 819		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 820		if (rc < 0)
 821			return rc;
 822
 823		sensor_query->abs_data_size =
 824			query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK;
 825		sensor_query->has_anchored_finger =
 826			!!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER);
 827		sensor_query->has_adj_hyst =
 828			!!(query_buf[0] & RMI_F11_HAS_ADJ_HYST);
 829		sensor_query->has_dribble =
 830			!!(query_buf[0] & RMI_F11_HAS_DRIBBLE);
 831		sensor_query->has_bending_correction =
 832			!!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION);
 833		sensor_query->has_large_object_suppression =
 834			!!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION);
 835		sensor_query->has_jitter_filter =
 836			!!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER);
 837		query_size++;
 838	}
 839
 840	if (sensor_query->has_rel) {
 841		rc = rmi_read(rmi_dev, query_base_addr + query_size,
 842					&sensor_query->f11_2d_query6);
 843		if (rc < 0)
 844			return rc;
 845		query_size++;
 846	}
 847
 848	if (sensor_query->has_gestures) {
 849		rc = rmi_read_block(rmi_dev, query_base_addr + query_size,
 850					query_buf, RMI_F11_QUERY_GESTURE_SIZE);
 851		if (rc < 0)
 852			return rc;
 853
 854		sensor_query->has_single_tap =
 855			!!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP);
 856		sensor_query->has_tap_n_hold =
 857			!!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD);
 858		sensor_query->has_double_tap =
 859			!!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP);
 860		sensor_query->has_early_tap =
 861			!!(query_buf[0] & RMI_F11_HAS_EARLY_TAP);
 862		sensor_query->has_flick =
 863			!!(query_buf[0] & RMI_F11_HAS_FLICK);
 864		sensor_query->has_press =
 865			!!(query_buf[0] & RMI_F11_HAS_PRESS);
 866		sensor_query->has_pinch =
 867			!!(query_buf[0] & RMI_F11_HAS_PINCH);
 868		sensor_query->has_chiral =
 869			!!(query_buf[0] & RMI_F11_HAS_CHIRAL);
 870
 871		/* query 8 */
 872		sensor_query->has_palm_det =
 873			!!(query_buf[1] & RMI_F11_HAS_PALM_DET);
 874		sensor_query->has_rotate =
 875			!!(query_buf[1] & RMI_F11_HAS_ROTATE);
 876		sensor_query->has_touch_shapes =
 877			!!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES);
 878		sensor_query->has_scroll_zones =
 879			!!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES);
 880		sensor_query->has_individual_scroll_zones =
 881			!!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES);
 882		sensor_query->has_mf_scroll =
 883			!!(query_buf[1] & RMI_F11_HAS_MF_SCROLL);
 884		sensor_query->has_mf_edge_motion =
 885			!!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION);
 886		sensor_query->has_mf_scroll_inertia =
 887			!!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA);
 888
 889		sensor_query->query7_nonzero = !!(query_buf[0]);
 890		sensor_query->query8_nonzero = !!(query_buf[1]);
 891
 892		query_size += 2;
 893	}
 894
 895	if (f11->has_query9) {
 896		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 897		if (rc < 0)
 898			return rc;
 899
 900		sensor_query->has_pen =
 901			!!(query_buf[0] & RMI_F11_HAS_PEN);
 902		sensor_query->has_proximity =
 903			!!(query_buf[0] & RMI_F11_HAS_PROXIMITY);
 904		sensor_query->has_palm_det_sensitivity =
 905			!!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY);
 906		sensor_query->has_suppress_on_palm_detect =
 907			!!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT);
 908		sensor_query->has_two_pen_thresholds =
 909			!!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS);
 910		sensor_query->has_contact_geometry =
 911			!!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY);
 912		sensor_query->has_pen_hover_discrimination =
 913			!!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION);
 914		sensor_query->has_pen_filters =
 915			!!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS);
 916
 917		query_size++;
 918	}
 919
 920	if (sensor_query->has_touch_shapes) {
 921		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 922		if (rc < 0)
 923			return rc;
 924
 925		sensor_query->nr_touch_shapes = query_buf[0] &
 926				RMI_F11_NR_TOUCH_SHAPES_MASK;
 927
 928		query_size++;
 929	}
 930
 931	if (f11->has_query11) {
 932		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 933		if (rc < 0)
 934			return rc;
 935
 936		sensor_query->has_z_tuning =
 937			!!(query_buf[0] & RMI_F11_HAS_Z_TUNING);
 938		sensor_query->has_algorithm_selection =
 939			!!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION);
 940		sensor_query->has_w_tuning =
 941			!!(query_buf[0] & RMI_F11_HAS_W_TUNING);
 942		sensor_query->has_pitch_info =
 943			!!(query_buf[0] & RMI_F11_HAS_PITCH_INFO);
 944		sensor_query->has_finger_size =
 945			!!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE);
 946		sensor_query->has_segmentation_aggressiveness =
 947			!!(query_buf[0] &
 948				RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS);
 949		sensor_query->has_XY_clip =
 950			!!(query_buf[0] & RMI_F11_HAS_XY_CLIP);
 951		sensor_query->has_drumming_filter =
 952			!!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER);
 953
 954		query_size++;
 955	}
 956
 957	if (f11->has_query12) {
 958		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 959		if (rc < 0)
 960			return rc;
 961
 962		sensor_query->has_gapless_finger =
 963			!!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER);
 964		sensor_query->has_gapless_finger_tuning =
 965			!!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING);
 966		sensor_query->has_8bit_w =
 967			!!(query_buf[0] & RMI_F11_HAS_8BIT_W);
 968		sensor_query->has_adjustable_mapping =
 969			!!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING);
 970		sensor_query->has_info2 =
 971			!!(query_buf[0] & RMI_F11_HAS_INFO2);
 972		sensor_query->has_physical_props =
 973			!!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS);
 974		sensor_query->has_finger_limit =
 975			!!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT);
 976		sensor_query->has_linear_coeff_2 =
 977			!!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF);
 978
 979		query_size++;
 980	}
 981
 982	if (sensor_query->has_jitter_filter) {
 983		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 984		if (rc < 0)
 985			return rc;
 986
 987		sensor_query->jitter_window_size = query_buf[0] &
 988			RMI_F11_JITTER_WINDOW_MASK;
 989		sensor_query->jitter_filter_type = (query_buf[0] &
 990			RMI_F11_JITTER_FILTER_MASK) >>
 991			RMI_F11_JITTER_FILTER_SHIFT;
 992
 993		query_size++;
 994	}
 995
 996	if (sensor_query->has_info2) {
 997		rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
 998		if (rc < 0)
 999			return rc;
1000
1001		sensor_query->light_control =
1002			query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK;
1003		sensor_query->is_clear =
1004			!!(query_buf[0] & RMI_F11_IS_CLEAR);
1005		sensor_query->clickpad_props =
1006			(query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >>
1007			RMI_F11_CLICKPAD_PROPS_SHIFT;
1008		sensor_query->mouse_buttons =
1009			(query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >>
1010			RMI_F11_MOUSE_BUTTONS_SHIFT;
1011		sensor_query->has_advanced_gestures =
1012			!!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES);
1013
1014		query_size++;
1015	}
1016
1017	if (sensor_query->has_physical_props) {
1018		rc = rmi_read_block(rmi_dev, query_base_addr
1019			+ query_size, query_buf, 4);
1020		if (rc < 0)
1021			return rc;
1022
1023		sensor_query->x_sensor_size_mm =
1024			(query_buf[0] | (query_buf[1] << 8)) / 10;
1025		sensor_query->y_sensor_size_mm =
1026			(query_buf[2] | (query_buf[3] << 8)) / 10;
1027
1028		/*
1029		 * query 15 - 18 contain the size of the sensor
1030		 * and query 19 - 26 contain bezel dimensions
1031		 */
1032		query_size += 12;
1033	}
1034
1035	if (f11->has_query27)
1036		++query_size;
1037
1038	if (f11->has_query28) {
1039		rc = rmi_read(rmi_dev, query_base_addr + query_size,
1040				query_buf);
1041		if (rc < 0)
1042			return rc;
1043
1044		has_query36 = !!(query_buf[0] & BIT(6));
1045	}
1046
1047	if (has_query36) {
1048		query_size += 2;
1049		rc = rmi_read(rmi_dev, query_base_addr + query_size,
1050				query_buf);
1051		if (rc < 0)
1052			return rc;
1053
1054		if (!!(query_buf[0] & BIT(5)))
1055			f11->has_acm = true;
1056	}
1057
1058	return query_size;
1059}
1060
1061static int rmi_f11_initialize(struct rmi_function *fn)
1062{
1063	struct rmi_device *rmi_dev = fn->rmi_dev;
1064	struct f11_data *f11;
1065	struct f11_2d_ctrl *ctrl;
1066	u8 query_offset;
1067	u16 query_base_addr;
1068	u16 control_base_addr;
1069	u16 max_x_pos, max_y_pos;
1070	int rc;
1071	const struct rmi_device_platform_data *pdata =
1072				rmi_get_platform_data(rmi_dev);
1073	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1074	struct rmi_2d_sensor *sensor;
1075	u8 buf;
1076	int mask_size;
1077
1078	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n");
1079
1080	mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
1081
1082	/*
1083	** init instance data, fill in values and create any sysfs files
1084	*/
1085	f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 2,
1086			GFP_KERNEL);
1087	if (!f11)
1088		return -ENOMEM;
1089
1090	if (fn->dev.of_node) {
1091		rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata);
1092		if (rc)
1093			return rc;
1094	} else {
1095		f11->sensor_pdata = pdata->sensor_pdata;
1096	}
1097
1098	f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait;
1099
1100	f11->abs_mask = (unsigned long *)((char *)f11
1101			+ sizeof(struct f11_data));
1102	f11->rel_mask = (unsigned long *)((char *)f11
1103			+ sizeof(struct f11_data) + mask_size);
1104
1105	set_bit(fn->irq_pos, f11->abs_mask);
1106	set_bit(fn->irq_pos + 1, f11->rel_mask);
1107
1108	query_base_addr = fn->fd.query_base_addr;
1109	control_base_addr = fn->fd.control_base_addr;
1110
1111	rc = rmi_read(rmi_dev, query_base_addr, &buf);
1112	if (rc < 0)
1113		return rc;
1114
1115	f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9);
1116	f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11);
1117	f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12);
1118	f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27);
1119	f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28);
1120
1121	query_offset = (query_base_addr + 1);
1122	sensor = &f11->sensor;
1123	sensor->fn = fn;
1124
1125	rc = rmi_f11_get_query_parameters(rmi_dev, f11,
1126			&f11->sens_query, query_offset);
1127	if (rc < 0)
1128		return rc;
1129	query_offset += rc;
1130
1131	rc = f11_read_control_regs(fn, &f11->dev_controls,
1132			control_base_addr);
1133	if (rc < 0) {
1134		dev_err(&fn->dev,
1135			"Failed to read F11 control params.\n");
1136		return rc;
1137	}
1138
1139	if (f11->sens_query.has_info2) {
1140		if (f11->sens_query.is_clear)
1141			f11->sensor.sensor_type = rmi_sensor_touchscreen;
1142		else
1143			f11->sensor.sensor_type = rmi_sensor_touchpad;
1144	}
1145
1146	sensor->report_abs = f11->sens_query.has_abs;
1147
1148	sensor->axis_align =
1149		f11->sensor_pdata.axis_align;
1150
1151	sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad;
1152	sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking;
1153	sensor->dmax = f11->sensor_pdata.dmax;
1154	sensor->dribble = f11->sensor_pdata.dribble;
1155	sensor->palm_detect = f11->sensor_pdata.palm_detect;
1156
1157	if (f11->sens_query.has_physical_props) {
1158		sensor->x_mm = f11->sens_query.x_sensor_size_mm;
1159		sensor->y_mm = f11->sens_query.y_sensor_size_mm;
1160	} else {
1161		sensor->x_mm = f11->sensor_pdata.x_mm;
1162		sensor->y_mm = f11->sensor_pdata.y_mm;
1163	}
1164
1165	if (sensor->sensor_type == rmi_sensor_default)
1166		sensor->sensor_type =
1167			f11->sensor_pdata.sensor_type;
1168
1169	sensor->report_abs = sensor->report_abs
1170		&& !(f11->sensor_pdata.disable_report_mask
1171			& RMI_F11_DISABLE_ABS_REPORT);
1172
1173	if (!sensor->report_abs)
1174		/*
1175		 * If device doesn't have abs or if it has been disables
1176		 * fallback to reporting rel data.
1177		 */
1178		sensor->report_rel = f11->sens_query.has_rel;
1179
1180	rc = rmi_read_block(rmi_dev,
1181		control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET,
1182		(u8 *)&max_x_pos, sizeof(max_x_pos));
1183	if (rc < 0)
1184		return rc;
1185
1186	rc = rmi_read_block(rmi_dev,
1187		control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET,
1188		(u8 *)&max_y_pos, sizeof(max_y_pos));
1189	if (rc < 0)
1190		return rc;
1191
1192	sensor->max_x = max_x_pos;
1193	sensor->max_y = max_y_pos;
1194
1195	rc = f11_2d_construct_data(f11);
1196	if (rc < 0)
1197		return rc;
1198
1199	if (f11->has_acm)
1200		f11->sensor.attn_size += f11->sensor.nbr_fingers * 2;
1201
1202	/* allocate the in-kernel tracking buffers */
1203	sensor->tracking_pos = devm_kcalloc(&fn->dev,
1204			sensor->nbr_fingers, sizeof(struct input_mt_pos),
1205			GFP_KERNEL);
1206	sensor->tracking_slots = devm_kcalloc(&fn->dev,
1207			sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
1208	sensor->objs = devm_kcalloc(&fn->dev,
1209			sensor->nbr_fingers,
1210			sizeof(struct rmi_2d_sensor_abs_object),
1211			GFP_KERNEL);
1212	if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
1213		return -ENOMEM;
1214
1215	ctrl = &f11->dev_controls;
1216	if (sensor->axis_align.delta_x_threshold)
1217		ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] =
1218			sensor->axis_align.delta_x_threshold;
1219
1220	if (sensor->axis_align.delta_y_threshold)
1221		ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] =
1222			sensor->axis_align.delta_y_threshold;
1223
1224	/*
1225	 * If distance threshold values are set, switch to reduced reporting
1226	 * mode so they actually get used by the controller.
1227	 */
1228	if (sensor->axis_align.delta_x_threshold ||
1229	    sensor->axis_align.delta_y_threshold) {
1230		ctrl->ctrl0_11[0] &= ~RMI_F11_REPORT_MODE_MASK;
1231		ctrl->ctrl0_11[0] |= RMI_F11_REPORT_MODE_REDUCED;
1232	}
1233
1234	if (f11->sens_query.has_dribble) {
1235		switch (sensor->dribble) {
1236		case RMI_REG_STATE_OFF:
1237			ctrl->ctrl0_11[0] &= ~BIT(6);
1238			break;
1239		case RMI_REG_STATE_ON:
1240			ctrl->ctrl0_11[0] |= BIT(6);
1241			break;
1242		case RMI_REG_STATE_DEFAULT:
1243		default:
1244			break;
1245		}
1246	}
1247
1248	if (f11->sens_query.has_palm_det) {
1249		switch (sensor->palm_detect) {
1250		case RMI_REG_STATE_OFF:
1251			ctrl->ctrl0_11[11] &= ~BIT(0);
1252			break;
1253		case RMI_REG_STATE_ON:
1254			ctrl->ctrl0_11[11] |= BIT(0);
1255			break;
1256		case RMI_REG_STATE_DEFAULT:
1257		default:
1258			break;
1259		}
1260	}
1261
1262	rc = f11_write_control_regs(fn, &f11->sens_query,
1263			   &f11->dev_controls, fn->fd.control_base_addr);
1264	if (rc)
1265		dev_warn(&fn->dev, "Failed to write control registers\n");
1266
1267	mutex_init(&f11->dev_controls_mutex);
1268
1269	dev_set_drvdata(&fn->dev, f11);
1270
1271	return 0;
1272}
1273
1274static int rmi_f11_config(struct rmi_function *fn)
1275{
1276	struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1277	struct rmi_driver *drv = fn->rmi_dev->driver;
1278	struct rmi_2d_sensor *sensor = &f11->sensor;
1279	int rc;
1280
1281	if (!sensor->report_abs)
1282		drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask);
1283	else
1284		drv->set_irq_bits(fn->rmi_dev, f11->abs_mask);
1285
1286	if (!sensor->report_rel)
1287		drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask);
1288	else
1289		drv->set_irq_bits(fn->rmi_dev, f11->rel_mask);
1290
1291	rc = f11_write_control_regs(fn, &f11->sens_query,
1292			   &f11->dev_controls, fn->fd.query_base_addr);
1293	if (rc < 0)
1294		return rc;
1295
1296	return 0;
1297}
1298
1299static irqreturn_t rmi_f11_attention(int irq, void *ctx)
1300{
1301	struct rmi_function *fn = ctx;
1302	struct rmi_device *rmi_dev = fn->rmi_dev;
1303	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1304	struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1305	u16 data_base_addr = fn->fd.data_base_addr;
1306	int error;
1307	int valid_bytes = f11->sensor.pkt_size;
1308
1309	if (drvdata->attn_data.data) {
1310		/*
1311		 * The valid data in the attention report is less then
1312		 * expected. Only process the complete fingers.
1313		 */
1314		if (f11->sensor.attn_size > drvdata->attn_data.size)
1315			valid_bytes = drvdata->attn_data.size;
1316		else
1317			valid_bytes = f11->sensor.attn_size;
1318		memcpy(f11->sensor.data_pkt, drvdata->attn_data.data,
1319			valid_bytes);
1320		drvdata->attn_data.data += valid_bytes;
1321		drvdata->attn_data.size -= valid_bytes;
1322	} else {
1323		error = rmi_read_block(rmi_dev,
1324				data_base_addr, f11->sensor.data_pkt,
1325				f11->sensor.pkt_size);
1326		if (error < 0)
1327			return IRQ_RETVAL(error);
1328	}
1329
1330	rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes);
1331
1332	return IRQ_HANDLED;
1333}
1334
1335static int rmi_f11_resume(struct rmi_function *fn)
1336{
1337	struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1338	int error;
1339
1340	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n");
1341	if (!f11->rezero_wait_ms)
1342		return 0;
1343
1344	mdelay(f11->rezero_wait_ms);
1345
1346	error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr,
1347				RMI_F11_REZERO);
1348	if (error) {
1349		dev_err(&fn->dev,
1350			"%s: failed to issue rezero command, error = %d.",
1351			__func__, error);
1352		return error;
1353	}
1354
1355	return 0;
1356}
1357
1358static int rmi_f11_probe(struct rmi_function *fn)
1359{
1360	int error;
1361	struct f11_data *f11;
1362
1363	error = rmi_f11_initialize(fn);
1364	if (error)
1365		return error;
1366
1367	f11 = dev_get_drvdata(&fn->dev);
1368	error = rmi_2d_sensor_configure_input(fn, &f11->sensor);
1369	if (error)
1370		return error;
1371
1372	return 0;
1373}
1374
1375struct rmi_function_handler rmi_f11_handler = {
1376	.driver = {
1377		.name	= "rmi4_f11",
1378	},
1379	.func		= 0x11,
1380	.probe		= rmi_f11_probe,
1381	.config		= rmi_f11_config,
1382	.attention	= rmi_f11_attention,
1383	.resume		= rmi_f11_resume,
1384};