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