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 */ 333 struct 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 458 struct 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 */ 497 struct 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 */ 523 struct 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 541 enum f11_finger_state { 542 F11_NO_FINGER = 0x00, 543 F11_PRESENT = 0x01, 544 F11_INACCURATE = 0x02, 545 F11_RESERVED = 0x03 546 }; 547 548 static 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 560 static 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 588 static 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 594 static 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 656 static 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 754 static 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 770 static 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 786 static 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 1061 static 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 1274 static 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 1299 static 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 1335 static 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 1358 static 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 1375 struct 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 }; 1385