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