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