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