1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012-2016 Synaptics Incorporated 4 */ 5 #include <linux/input.h> 6 #include <linux/input/mt.h> 7 #include <linux/rmi.h> 8 #include "rmi_driver.h" 9 #include "rmi_2d_sensor.h" 10 11 enum rmi_f12_object_type { 12 RMI_F12_OBJECT_NONE = 0x00, 13 RMI_F12_OBJECT_FINGER = 0x01, 14 RMI_F12_OBJECT_STYLUS = 0x02, 15 RMI_F12_OBJECT_PALM = 0x03, 16 RMI_F12_OBJECT_UNCLASSIFIED = 0x04, 17 RMI_F12_OBJECT_GLOVED_FINGER = 0x06, 18 RMI_F12_OBJECT_NARROW_OBJECT = 0x07, 19 RMI_F12_OBJECT_HAND_EDGE = 0x08, 20 RMI_F12_OBJECT_COVER = 0x0A, 21 RMI_F12_OBJECT_STYLUS_2 = 0x0B, 22 RMI_F12_OBJECT_ERASER = 0x0C, 23 RMI_F12_OBJECT_SMALL_OBJECT = 0x0D, 24 }; 25 26 #define F12_DATA1_BYTES_PER_OBJ 8 27 #define RMI_F12_QUERY_RESOLUTION 29 28 29 struct f12_data { 30 struct rmi_2d_sensor sensor; 31 struct rmi_2d_sensor_platform_data sensor_pdata; 32 bool has_dribble; 33 34 u16 data_addr; 35 36 struct rmi_register_descriptor query_reg_desc; 37 struct rmi_register_descriptor control_reg_desc; 38 struct rmi_register_descriptor data_reg_desc; 39 40 /* F12 Data1 describes sensed objects */ 41 const struct rmi_register_desc_item *data1; 42 u16 data1_offset; 43 44 /* F12 Data5 describes finger ACM */ 45 const struct rmi_register_desc_item *data5; 46 u16 data5_offset; 47 48 /* F12 Data5 describes Pen */ 49 const struct rmi_register_desc_item *data6; 50 u16 data6_offset; 51 52 53 /* F12 Data9 reports relative data */ 54 const struct rmi_register_desc_item *data9; 55 u16 data9_offset; 56 57 const struct rmi_register_desc_item *data15; 58 u16 data15_offset; 59 60 unsigned long *abs_mask; 61 unsigned long *rel_mask; 62 }; 63 64 static int rmi_f12_read_sensor_tuning(struct f12_data *f12) 65 { 66 const struct rmi_register_desc_item *item; 67 struct rmi_2d_sensor *sensor = &f12->sensor; 68 struct rmi_function *fn = sensor->fn; 69 struct rmi_device *rmi_dev = fn->rmi_dev; 70 int ret; 71 int offset; 72 u8 buf[15]; 73 int pitch_x = 0; 74 int pitch_y = 0; 75 int rx_receivers = 0; 76 int tx_receivers = 0; 77 u16 query_dpm_addr = 0; 78 int dpm_resolution = 0; 79 80 item = rmi_get_register_desc_item(&f12->control_reg_desc, 8); 81 if (!item) { 82 dev_err(&fn->dev, 83 "F12 does not have the sensor tuning control register\n"); 84 return -ENODEV; 85 } 86 87 offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8); 88 89 if (item->reg_size > sizeof(buf)) { 90 dev_err(&fn->dev, 91 "F12 control8 should be no bigger than %zd bytes, not: %ld\n", 92 sizeof(buf), item->reg_size); 93 return -ENODEV; 94 } 95 96 ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf, 97 item->reg_size); 98 if (ret) 99 return ret; 100 101 offset = 0; 102 if (rmi_register_desc_has_subpacket(item, 0)) { 103 sensor->max_x = (buf[offset + 1] << 8) | buf[offset]; 104 sensor->max_y = (buf[offset + 3] << 8) | buf[offset + 2]; 105 offset += 4; 106 } 107 108 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__, 109 sensor->max_x, sensor->max_y); 110 111 if (rmi_register_desc_has_subpacket(item, 1)) { 112 pitch_x = (buf[offset + 1] << 8) | buf[offset]; 113 pitch_y = (buf[offset + 3] << 8) | buf[offset + 2]; 114 offset += 4; 115 } 116 117 if (rmi_register_desc_has_subpacket(item, 2)) { 118 /* Units 1/128 sensor pitch */ 119 rmi_dbg(RMI_DEBUG_FN, &fn->dev, 120 "%s: Inactive Border xlo:%d xhi:%d ylo:%d yhi:%d\n", 121 __func__, 122 buf[offset], buf[offset + 1], 123 buf[offset + 2], buf[offset + 3]); 124 125 offset += 4; 126 } 127 128 /* 129 * Use the Query DPM feature when the resolution query register 130 * exists. 131 */ 132 if (rmi_get_register_desc_item(&f12->query_reg_desc, 133 RMI_F12_QUERY_RESOLUTION)) { 134 offset = rmi_register_desc_calc_reg_offset(&f12->query_reg_desc, 135 RMI_F12_QUERY_RESOLUTION); 136 query_dpm_addr = fn->fd.query_base_addr + offset; 137 ret = rmi_read(fn->rmi_dev, query_dpm_addr, buf); 138 if (ret < 0) { 139 dev_err(&fn->dev, "Failed to read DPM value: %d\n", ret); 140 return -ENODEV; 141 } 142 dpm_resolution = buf[0]; 143 144 sensor->x_mm = sensor->max_x / dpm_resolution; 145 sensor->y_mm = sensor->max_y / dpm_resolution; 146 } else { 147 if (rmi_register_desc_has_subpacket(item, 3)) { 148 rx_receivers = buf[offset]; 149 tx_receivers = buf[offset + 1]; 150 offset += 2; 151 } 152 153 /* Skip over sensor flags */ 154 if (rmi_register_desc_has_subpacket(item, 4)) 155 offset += 1; 156 157 sensor->x_mm = (pitch_x * rx_receivers) >> 12; 158 sensor->y_mm = (pitch_y * tx_receivers) >> 12; 159 } 160 161 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__, 162 sensor->x_mm, sensor->y_mm); 163 164 return 0; 165 } 166 167 static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, int size) 168 { 169 int i; 170 struct rmi_2d_sensor *sensor = &f12->sensor; 171 int objects = f12->data1->num_subpackets; 172 173 if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size) 174 objects = size / F12_DATA1_BYTES_PER_OBJ; 175 176 for (i = 0; i < objects; i++) { 177 struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i]; 178 179 obj->type = RMI_2D_OBJECT_NONE; 180 obj->mt_tool = MT_TOOL_FINGER; 181 182 switch (data1[0]) { 183 case RMI_F12_OBJECT_FINGER: 184 obj->type = RMI_2D_OBJECT_FINGER; 185 break; 186 case RMI_F12_OBJECT_STYLUS: 187 obj->type = RMI_2D_OBJECT_STYLUS; 188 obj->mt_tool = MT_TOOL_PEN; 189 break; 190 case RMI_F12_OBJECT_PALM: 191 obj->type = RMI_2D_OBJECT_PALM; 192 obj->mt_tool = MT_TOOL_PALM; 193 break; 194 case RMI_F12_OBJECT_UNCLASSIFIED: 195 obj->type = RMI_2D_OBJECT_UNCLASSIFIED; 196 break; 197 } 198 199 obj->x = (data1[2] << 8) | data1[1]; 200 obj->y = (data1[4] << 8) | data1[3]; 201 obj->z = data1[5]; 202 obj->wx = data1[6]; 203 obj->wy = data1[7]; 204 205 rmi_2d_sensor_abs_process(sensor, obj, i); 206 207 data1 += F12_DATA1_BYTES_PER_OBJ; 208 } 209 210 if (sensor->kernel_tracking) 211 input_mt_assign_slots(sensor->input, 212 sensor->tracking_slots, 213 sensor->tracking_pos, 214 sensor->nbr_fingers, 215 sensor->dmax); 216 217 for (i = 0; i < objects; i++) 218 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i); 219 } 220 221 static irqreturn_t rmi_f12_attention(int irq, void *ctx) 222 { 223 int retval; 224 struct rmi_function *fn = ctx; 225 struct rmi_device *rmi_dev = fn->rmi_dev; 226 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); 227 struct f12_data *f12 = dev_get_drvdata(&fn->dev); 228 struct rmi_2d_sensor *sensor = &f12->sensor; 229 int valid_bytes = sensor->pkt_size; 230 231 if (drvdata->attn_data.data) { 232 if (sensor->attn_size > drvdata->attn_data.size) 233 valid_bytes = drvdata->attn_data.size; 234 else 235 valid_bytes = sensor->attn_size; 236 memcpy(sensor->data_pkt, drvdata->attn_data.data, 237 valid_bytes); 238 drvdata->attn_data.data += valid_bytes; 239 drvdata->attn_data.size -= valid_bytes; 240 } else { 241 retval = rmi_read_block(rmi_dev, f12->data_addr, 242 sensor->data_pkt, sensor->pkt_size); 243 if (retval < 0) { 244 dev_err(&fn->dev, "Failed to read object data. Code: %d.\n", 245 retval); 246 return IRQ_RETVAL(retval); 247 } 248 } 249 250 if (f12->data1) 251 rmi_f12_process_objects(f12, 252 &sensor->data_pkt[f12->data1_offset], valid_bytes); 253 254 input_mt_sync_frame(sensor->input); 255 256 return IRQ_HANDLED; 257 } 258 259 static int rmi_f12_write_control_regs(struct rmi_function *fn) 260 { 261 int ret; 262 const struct rmi_register_desc_item *item; 263 struct rmi_device *rmi_dev = fn->rmi_dev; 264 struct f12_data *f12 = dev_get_drvdata(&fn->dev); 265 int control_size; 266 char buf[3]; 267 u16 control_offset = 0; 268 u8 subpacket_offset = 0; 269 270 if (f12->has_dribble 271 && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) { 272 item = rmi_get_register_desc_item(&f12->control_reg_desc, 20); 273 if (item) { 274 control_offset = rmi_register_desc_calc_reg_offset( 275 &f12->control_reg_desc, 20); 276 277 /* 278 * The byte containing the EnableDribble bit will be 279 * in either byte 0 or byte 2 of control 20. Depending 280 * on the existence of subpacket 0. If control 20 is 281 * larger then 3 bytes, just read the first 3. 282 */ 283 control_size = min(item->reg_size, 3UL); 284 285 ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr 286 + control_offset, buf, control_size); 287 if (ret) 288 return ret; 289 290 if (rmi_register_desc_has_subpacket(item, 0)) 291 subpacket_offset += 1; 292 293 switch (f12->sensor.dribble) { 294 case RMI_REG_STATE_OFF: 295 buf[subpacket_offset] &= ~BIT(2); 296 break; 297 case RMI_REG_STATE_ON: 298 buf[subpacket_offset] |= BIT(2); 299 break; 300 case RMI_REG_STATE_DEFAULT: 301 default: 302 break; 303 } 304 305 ret = rmi_write_block(rmi_dev, 306 fn->fd.control_base_addr + control_offset, 307 buf, control_size); 308 if (ret) 309 return ret; 310 } 311 } 312 313 return 0; 314 315 } 316 317 static int rmi_f12_config(struct rmi_function *fn) 318 { 319 struct rmi_driver *drv = fn->rmi_dev->driver; 320 struct f12_data *f12 = dev_get_drvdata(&fn->dev); 321 struct rmi_2d_sensor *sensor; 322 int ret; 323 324 sensor = &f12->sensor; 325 326 if (!sensor->report_abs) 327 drv->clear_irq_bits(fn->rmi_dev, f12->abs_mask); 328 else 329 drv->set_irq_bits(fn->rmi_dev, f12->abs_mask); 330 331 drv->clear_irq_bits(fn->rmi_dev, f12->rel_mask); 332 333 ret = rmi_f12_write_control_regs(fn); 334 if (ret) 335 dev_warn(&fn->dev, 336 "Failed to write F12 control registers: %d\n", ret); 337 338 return 0; 339 } 340 341 static int rmi_f12_probe(struct rmi_function *fn) 342 { 343 struct f12_data *f12; 344 int ret; 345 struct rmi_device *rmi_dev = fn->rmi_dev; 346 char buf; 347 u16 query_addr = fn->fd.query_base_addr; 348 const struct rmi_register_desc_item *item; 349 struct rmi_2d_sensor *sensor; 350 struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev); 351 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); 352 u16 data_offset = 0; 353 int mask_size; 354 355 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__); 356 357 mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long); 358 359 ret = rmi_read(fn->rmi_dev, query_addr, &buf); 360 if (ret < 0) { 361 dev_err(&fn->dev, "Failed to read general info register: %d\n", 362 ret); 363 return -ENODEV; 364 } 365 ++query_addr; 366 367 if (!(buf & BIT(0))) { 368 dev_err(&fn->dev, 369 "Behavior of F12 without register descriptors is undefined.\n"); 370 return -ENODEV; 371 } 372 373 f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data) + mask_size * 2, 374 GFP_KERNEL); 375 if (!f12) 376 return -ENOMEM; 377 378 f12->abs_mask = (unsigned long *)((char *)f12 379 + sizeof(struct f12_data)); 380 f12->rel_mask = (unsigned long *)((char *)f12 381 + sizeof(struct f12_data) + mask_size); 382 383 set_bit(fn->irq_pos, f12->abs_mask); 384 set_bit(fn->irq_pos + 1, f12->rel_mask); 385 386 f12->has_dribble = !!(buf & BIT(3)); 387 388 if (fn->dev.of_node) { 389 ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata); 390 if (ret) 391 return ret; 392 } else { 393 f12->sensor_pdata = pdata->sensor_pdata; 394 } 395 396 ret = rmi_read_register_desc(rmi_dev, query_addr, 397 &f12->query_reg_desc); 398 if (ret) { 399 dev_err(&fn->dev, 400 "Failed to read the Query Register Descriptor: %d\n", 401 ret); 402 return ret; 403 } 404 query_addr += 3; 405 406 ret = rmi_read_register_desc(rmi_dev, query_addr, 407 &f12->control_reg_desc); 408 if (ret) { 409 dev_err(&fn->dev, 410 "Failed to read the Control Register Descriptor: %d\n", 411 ret); 412 return ret; 413 } 414 query_addr += 3; 415 416 ret = rmi_read_register_desc(rmi_dev, query_addr, 417 &f12->data_reg_desc); 418 if (ret) { 419 dev_err(&fn->dev, 420 "Failed to read the Data Register Descriptor: %d\n", 421 ret); 422 return ret; 423 } 424 query_addr += 3; 425 426 sensor = &f12->sensor; 427 sensor->fn = fn; 428 f12->data_addr = fn->fd.data_base_addr; 429 sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc); 430 431 sensor->axis_align = 432 f12->sensor_pdata.axis_align; 433 434 sensor->x_mm = f12->sensor_pdata.x_mm; 435 sensor->y_mm = f12->sensor_pdata.y_mm; 436 sensor->dribble = f12->sensor_pdata.dribble; 437 438 if (sensor->sensor_type == rmi_sensor_default) 439 sensor->sensor_type = 440 f12->sensor_pdata.sensor_type; 441 442 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__, 443 sensor->pkt_size); 444 sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL); 445 if (!sensor->data_pkt) 446 return -ENOMEM; 447 448 dev_set_drvdata(&fn->dev, f12); 449 450 ret = rmi_f12_read_sensor_tuning(f12); 451 if (ret) 452 return ret; 453 454 /* 455 * Figure out what data is contained in the data registers. HID devices 456 * may have registers defined, but their data is not reported in the 457 * HID attention report. Registers which are not reported in the HID 458 * attention report check to see if the device is receiving data from 459 * HID attention reports. 460 */ 461 item = rmi_get_register_desc_item(&f12->data_reg_desc, 0); 462 if (item && !drvdata->attn_data.data) 463 data_offset += item->reg_size; 464 465 item = rmi_get_register_desc_item(&f12->data_reg_desc, 1); 466 if (item) { 467 f12->data1 = item; 468 f12->data1_offset = data_offset; 469 data_offset += item->reg_size; 470 sensor->nbr_fingers = item->num_subpackets; 471 sensor->report_abs = 1; 472 sensor->attn_size += item->reg_size; 473 } 474 475 item = rmi_get_register_desc_item(&f12->data_reg_desc, 2); 476 if (item && !drvdata->attn_data.data) 477 data_offset += item->reg_size; 478 479 item = rmi_get_register_desc_item(&f12->data_reg_desc, 3); 480 if (item && !drvdata->attn_data.data) 481 data_offset += item->reg_size; 482 483 item = rmi_get_register_desc_item(&f12->data_reg_desc, 4); 484 if (item && !drvdata->attn_data.data) 485 data_offset += item->reg_size; 486 487 item = rmi_get_register_desc_item(&f12->data_reg_desc, 5); 488 if (item) { 489 f12->data5 = item; 490 f12->data5_offset = data_offset; 491 data_offset += item->reg_size; 492 sensor->attn_size += item->reg_size; 493 } 494 495 item = rmi_get_register_desc_item(&f12->data_reg_desc, 6); 496 if (item && !drvdata->attn_data.data) { 497 f12->data6 = item; 498 f12->data6_offset = data_offset; 499 data_offset += item->reg_size; 500 } 501 502 item = rmi_get_register_desc_item(&f12->data_reg_desc, 7); 503 if (item && !drvdata->attn_data.data) 504 data_offset += item->reg_size; 505 506 item = rmi_get_register_desc_item(&f12->data_reg_desc, 8); 507 if (item && !drvdata->attn_data.data) 508 data_offset += item->reg_size; 509 510 item = rmi_get_register_desc_item(&f12->data_reg_desc, 9); 511 if (item && !drvdata->attn_data.data) { 512 f12->data9 = item; 513 f12->data9_offset = data_offset; 514 data_offset += item->reg_size; 515 if (!sensor->report_abs) 516 sensor->report_rel = 1; 517 } 518 519 item = rmi_get_register_desc_item(&f12->data_reg_desc, 10); 520 if (item && !drvdata->attn_data.data) 521 data_offset += item->reg_size; 522 523 item = rmi_get_register_desc_item(&f12->data_reg_desc, 11); 524 if (item && !drvdata->attn_data.data) 525 data_offset += item->reg_size; 526 527 item = rmi_get_register_desc_item(&f12->data_reg_desc, 12); 528 if (item && !drvdata->attn_data.data) 529 data_offset += item->reg_size; 530 531 item = rmi_get_register_desc_item(&f12->data_reg_desc, 13); 532 if (item && !drvdata->attn_data.data) 533 data_offset += item->reg_size; 534 535 item = rmi_get_register_desc_item(&f12->data_reg_desc, 14); 536 if (item && !drvdata->attn_data.data) 537 data_offset += item->reg_size; 538 539 item = rmi_get_register_desc_item(&f12->data_reg_desc, 15); 540 if (item && !drvdata->attn_data.data) { 541 f12->data15 = item; 542 f12->data15_offset = data_offset; 543 data_offset += item->reg_size; 544 } 545 546 /* allocate the in-kernel tracking buffers */ 547 sensor->tracking_pos = devm_kcalloc(&fn->dev, 548 sensor->nbr_fingers, sizeof(struct input_mt_pos), 549 GFP_KERNEL); 550 sensor->tracking_slots = devm_kcalloc(&fn->dev, 551 sensor->nbr_fingers, sizeof(int), GFP_KERNEL); 552 sensor->objs = devm_kcalloc(&fn->dev, 553 sensor->nbr_fingers, 554 sizeof(struct rmi_2d_sensor_abs_object), 555 GFP_KERNEL); 556 if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs) 557 return -ENOMEM; 558 559 ret = rmi_2d_sensor_configure_input(fn, sensor); 560 if (ret) 561 return ret; 562 563 return 0; 564 } 565 566 struct rmi_function_handler rmi_f12_handler = { 567 .driver = { 568 .name = "rmi4_f12", 569 }, 570 .func = 0x12, 571 .probe = rmi_f12_probe, 572 .config = rmi_f12_config, 573 .attention = rmi_f12_attention, 574 }; 575