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