xref: /openbmc/linux/drivers/input/rmi4/rmi_f01.c (revision 7e909891)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2011-2016 Synaptics Incorporated
4  * Copyright (c) 2011 Unixphere
5  */
6 
7 #include <linux/kernel.h>
8 #include <linux/rmi.h>
9 #include <linux/slab.h>
10 #include <linux/uaccess.h>
11 #include <linux/of.h>
12 #include <asm/unaligned.h>
13 #include "rmi_driver.h"
14 
15 #define RMI_PRODUCT_ID_LENGTH    10
16 #define RMI_PRODUCT_INFO_LENGTH   2
17 
18 #define RMI_DATE_CODE_LENGTH      3
19 
20 #define PRODUCT_ID_OFFSET 0x10
21 #define PRODUCT_INFO_OFFSET 0x1E
22 
23 
24 /* Force a firmware reset of the sensor */
25 #define RMI_F01_CMD_DEVICE_RESET	1
26 
27 /* Various F01_RMI_QueryX bits */
28 
29 #define RMI_F01_QRY1_CUSTOM_MAP		BIT(0)
30 #define RMI_F01_QRY1_NON_COMPLIANT	BIT(1)
31 #define RMI_F01_QRY1_HAS_LTS		BIT(2)
32 #define RMI_F01_QRY1_HAS_SENSOR_ID	BIT(3)
33 #define RMI_F01_QRY1_HAS_CHARGER_INP	BIT(4)
34 #define RMI_F01_QRY1_HAS_ADJ_DOZE	BIT(5)
35 #define RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF	BIT(6)
36 #define RMI_F01_QRY1_HAS_QUERY42	BIT(7)
37 
38 #define RMI_F01_QRY5_YEAR_MASK		0x1f
39 #define RMI_F01_QRY6_MONTH_MASK		0x0f
40 #define RMI_F01_QRY7_DAY_MASK		0x1f
41 
42 #define RMI_F01_QRY2_PRODINFO_MASK	0x7f
43 
44 #define RMI_F01_BASIC_QUERY_LEN		21 /* From Query 00 through 20 */
45 
46 struct f01_basic_properties {
47 	u8 manufacturer_id;
48 	bool has_lts;
49 	bool has_adjustable_doze;
50 	bool has_adjustable_doze_holdoff;
51 	char dom[11]; /* YYYY/MM/DD + '\0' */
52 	u8 product_id[RMI_PRODUCT_ID_LENGTH + 1];
53 	u16 productinfo;
54 	u32 firmware_id;
55 	u32 package_id;
56 };
57 
58 /* F01 device status bits */
59 
60 /* Most recent device status event */
61 #define RMI_F01_STATUS_CODE(status)		((status) & 0x0f)
62 /* The device has lost its configuration for some reason. */
63 #define RMI_F01_STATUS_UNCONFIGURED(status)	(!!((status) & 0x80))
64 /* The device is in bootloader mode */
65 #define RMI_F01_STATUS_BOOTLOADER(status)	((status) & 0x40)
66 
67 /* Control register bits */
68 
69 /*
70  * Sleep mode controls power management on the device and affects all
71  * functions of the device.
72  */
73 #define RMI_F01_CTRL0_SLEEP_MODE_MASK	0x03
74 
75 #define RMI_SLEEP_MODE_NORMAL		0x00
76 #define RMI_SLEEP_MODE_SENSOR_SLEEP	0x01
77 #define RMI_SLEEP_MODE_RESERVED0	0x02
78 #define RMI_SLEEP_MODE_RESERVED1	0x03
79 
80 /*
81  * This bit disables whatever sleep mode may be selected by the sleep_mode
82  * field and forces the device to run at full power without sleeping.
83  */
84 #define RMI_F01_CTRL0_NOSLEEP_BIT	BIT(2)
85 
86 /*
87  * When this bit is set, the touch controller employs a noise-filtering
88  * algorithm designed for use with a connected battery charger.
89  */
90 #define RMI_F01_CTRL0_CHARGER_BIT	BIT(5)
91 
92 /*
93  * Sets the report rate for the device. The effect of this setting is
94  * highly product dependent. Check the spec sheet for your particular
95  * touch sensor.
96  */
97 #define RMI_F01_CTRL0_REPORTRATE_BIT	BIT(6)
98 
99 /*
100  * Written by the host as an indicator that the device has been
101  * successfully configured.
102  */
103 #define RMI_F01_CTRL0_CONFIGURED_BIT	BIT(7)
104 
105 /**
106  * struct f01_device_control - controls basic sensor functions
107  *
108  * @ctrl0: see the bit definitions above.
109  * @doze_interval: controls the interval between checks for finger presence
110  *	when the touch sensor is in doze mode, in units of 10ms.
111  * @wakeup_threshold: controls the capacitance threshold at which the touch
112  *	sensor will decide to wake up from that low power state.
113  * @doze_holdoff: controls how long the touch sensor waits after the last
114  *	finger lifts before entering the doze state, in units of 100ms.
115  */
116 struct f01_device_control {
117 	u8 ctrl0;
118 	u8 doze_interval;
119 	u8 wakeup_threshold;
120 	u8 doze_holdoff;
121 };
122 
123 struct f01_data {
124 	struct f01_basic_properties properties;
125 	struct f01_device_control device_control;
126 
127 	u16 doze_interval_addr;
128 	u16 wakeup_threshold_addr;
129 	u16 doze_holdoff_addr;
130 
131 	bool suspended;
132 	bool old_nosleep;
133 
134 	unsigned int num_of_irq_regs;
135 };
136 
rmi_f01_read_properties(struct rmi_device * rmi_dev,u16 query_base_addr,struct f01_basic_properties * props)137 static int rmi_f01_read_properties(struct rmi_device *rmi_dev,
138 				   u16 query_base_addr,
139 				   struct f01_basic_properties *props)
140 {
141 	u8 queries[RMI_F01_BASIC_QUERY_LEN];
142 	int ret;
143 	int query_offset = query_base_addr;
144 	bool has_ds4_queries = false;
145 	bool has_query42 = false;
146 	bool has_sensor_id = false;
147 	bool has_package_id_query = false;
148 	bool has_build_id_query = false;
149 	u16 prod_info_addr;
150 	u8 ds4_query_len;
151 
152 	ret = rmi_read_block(rmi_dev, query_offset,
153 			       queries, RMI_F01_BASIC_QUERY_LEN);
154 	if (ret) {
155 		dev_err(&rmi_dev->dev,
156 			"Failed to read device query registers: %d\n", ret);
157 		return ret;
158 	}
159 
160 	prod_info_addr = query_offset + 17;
161 	query_offset += RMI_F01_BASIC_QUERY_LEN;
162 
163 	/* Now parse what we got */
164 	props->manufacturer_id = queries[0];
165 
166 	props->has_lts = queries[1] & RMI_F01_QRY1_HAS_LTS;
167 	props->has_adjustable_doze =
168 			queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE;
169 	props->has_adjustable_doze_holdoff =
170 			queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF;
171 	has_query42 = queries[1] & RMI_F01_QRY1_HAS_QUERY42;
172 	has_sensor_id = queries[1] & RMI_F01_QRY1_HAS_SENSOR_ID;
173 
174 	snprintf(props->dom, sizeof(props->dom), "20%02d/%02d/%02d",
175 		 queries[5] & RMI_F01_QRY5_YEAR_MASK,
176 		 queries[6] & RMI_F01_QRY6_MONTH_MASK,
177 		 queries[7] & RMI_F01_QRY7_DAY_MASK);
178 
179 	memcpy(props->product_id, &queries[11],
180 		RMI_PRODUCT_ID_LENGTH);
181 	props->product_id[RMI_PRODUCT_ID_LENGTH] = '\0';
182 
183 	props->productinfo =
184 			((queries[2] & RMI_F01_QRY2_PRODINFO_MASK) << 7) |
185 			(queries[3] & RMI_F01_QRY2_PRODINFO_MASK);
186 
187 	if (has_sensor_id)
188 		query_offset++;
189 
190 	if (has_query42) {
191 		ret = rmi_read(rmi_dev, query_offset, queries);
192 		if (ret) {
193 			dev_err(&rmi_dev->dev,
194 				"Failed to read query 42 register: %d\n", ret);
195 			return ret;
196 		}
197 
198 		has_ds4_queries = !!(queries[0] & BIT(0));
199 		query_offset++;
200 	}
201 
202 	if (has_ds4_queries) {
203 		ret = rmi_read(rmi_dev, query_offset, &ds4_query_len);
204 		if (ret) {
205 			dev_err(&rmi_dev->dev,
206 				"Failed to read DS4 queries length: %d\n", ret);
207 			return ret;
208 		}
209 		query_offset++;
210 
211 		if (ds4_query_len > 0) {
212 			ret = rmi_read(rmi_dev, query_offset, queries);
213 			if (ret) {
214 				dev_err(&rmi_dev->dev,
215 					"Failed to read DS4 queries: %d\n",
216 					ret);
217 				return ret;
218 			}
219 
220 			has_package_id_query = !!(queries[0] & BIT(0));
221 			has_build_id_query = !!(queries[0] & BIT(1));
222 		}
223 
224 		if (has_package_id_query) {
225 			ret = rmi_read_block(rmi_dev, prod_info_addr,
226 					     queries, sizeof(__le64));
227 			if (ret) {
228 				dev_err(&rmi_dev->dev,
229 					"Failed to read package info: %d\n",
230 					ret);
231 				return ret;
232 			}
233 
234 			props->package_id = get_unaligned_le64(queries);
235 			prod_info_addr++;
236 		}
237 
238 		if (has_build_id_query) {
239 			ret = rmi_read_block(rmi_dev, prod_info_addr, queries,
240 					    3);
241 			if (ret) {
242 				dev_err(&rmi_dev->dev,
243 					"Failed to read product info: %d\n",
244 					ret);
245 				return ret;
246 			}
247 
248 			props->firmware_id = queries[1] << 8 | queries[0];
249 			props->firmware_id += queries[2] * 65536;
250 		}
251 	}
252 
253 	return 0;
254 }
255 
rmi_f01_get_product_ID(struct rmi_function * fn)256 const char *rmi_f01_get_product_ID(struct rmi_function *fn)
257 {
258 	struct f01_data *f01 = dev_get_drvdata(&fn->dev);
259 
260 	return f01->properties.product_id;
261 }
262 
rmi_driver_manufacturer_id_show(struct device * dev,struct device_attribute * dattr,char * buf)263 static ssize_t rmi_driver_manufacturer_id_show(struct device *dev,
264 					       struct device_attribute *dattr,
265 					       char *buf)
266 {
267 	struct rmi_driver_data *data = dev_get_drvdata(dev);
268 	struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
269 
270 	return scnprintf(buf, PAGE_SIZE, "%d\n",
271 			 f01->properties.manufacturer_id);
272 }
273 
274 static DEVICE_ATTR(manufacturer_id, 0444,
275 		   rmi_driver_manufacturer_id_show, NULL);
276 
rmi_driver_dom_show(struct device * dev,struct device_attribute * dattr,char * buf)277 static ssize_t rmi_driver_dom_show(struct device *dev,
278 				   struct device_attribute *dattr, char *buf)
279 {
280 	struct rmi_driver_data *data = dev_get_drvdata(dev);
281 	struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
282 
283 	return scnprintf(buf, PAGE_SIZE, "%s\n", f01->properties.dom);
284 }
285 
286 static DEVICE_ATTR(date_of_manufacture, 0444, rmi_driver_dom_show, NULL);
287 
rmi_driver_product_id_show(struct device * dev,struct device_attribute * dattr,char * buf)288 static ssize_t rmi_driver_product_id_show(struct device *dev,
289 					  struct device_attribute *dattr,
290 					  char *buf)
291 {
292 	struct rmi_driver_data *data = dev_get_drvdata(dev);
293 	struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
294 
295 	return scnprintf(buf, PAGE_SIZE, "%s\n", f01->properties.product_id);
296 }
297 
298 static DEVICE_ATTR(product_id, 0444, rmi_driver_product_id_show, NULL);
299 
rmi_driver_firmware_id_show(struct device * dev,struct device_attribute * dattr,char * buf)300 static ssize_t rmi_driver_firmware_id_show(struct device *dev,
301 					   struct device_attribute *dattr,
302 					   char *buf)
303 {
304 	struct rmi_driver_data *data = dev_get_drvdata(dev);
305 	struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
306 
307 	return scnprintf(buf, PAGE_SIZE, "%d\n", f01->properties.firmware_id);
308 }
309 
310 static DEVICE_ATTR(firmware_id, 0444, rmi_driver_firmware_id_show, NULL);
311 
rmi_driver_package_id_show(struct device * dev,struct device_attribute * dattr,char * buf)312 static ssize_t rmi_driver_package_id_show(struct device *dev,
313 					  struct device_attribute *dattr,
314 					  char *buf)
315 {
316 	struct rmi_driver_data *data = dev_get_drvdata(dev);
317 	struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
318 
319 	u32 package_id = f01->properties.package_id;
320 
321 	return scnprintf(buf, PAGE_SIZE, "%04x.%04x\n",
322 			 package_id & 0xffff, (package_id >> 16) & 0xffff);
323 }
324 
325 static DEVICE_ATTR(package_id, 0444, rmi_driver_package_id_show, NULL);
326 
327 static struct attribute *rmi_f01_attrs[] = {
328 	&dev_attr_manufacturer_id.attr,
329 	&dev_attr_date_of_manufacture.attr,
330 	&dev_attr_product_id.attr,
331 	&dev_attr_firmware_id.attr,
332 	&dev_attr_package_id.attr,
333 	NULL
334 };
335 
336 static const struct attribute_group rmi_f01_attr_group = {
337 	.attrs = rmi_f01_attrs,
338 };
339 
340 #ifdef CONFIG_OF
rmi_f01_of_probe(struct device * dev,struct rmi_device_platform_data * pdata)341 static int rmi_f01_of_probe(struct device *dev,
342 				struct rmi_device_platform_data *pdata)
343 {
344 	int retval;
345 	u32 val;
346 
347 	retval = rmi_of_property_read_u32(dev,
348 			(u32 *)&pdata->power_management.nosleep,
349 			"syna,nosleep-mode", 1);
350 	if (retval)
351 		return retval;
352 
353 	retval = rmi_of_property_read_u32(dev, &val,
354 			"syna,wakeup-threshold", 1);
355 	if (retval)
356 		return retval;
357 
358 	pdata->power_management.wakeup_threshold = val;
359 
360 	retval = rmi_of_property_read_u32(dev, &val,
361 			"syna,doze-holdoff-ms", 1);
362 	if (retval)
363 		return retval;
364 
365 	pdata->power_management.doze_holdoff = val * 100;
366 
367 	retval = rmi_of_property_read_u32(dev, &val,
368 			"syna,doze-interval-ms", 1);
369 	if (retval)
370 		return retval;
371 
372 	pdata->power_management.doze_interval = val / 10;
373 
374 	return 0;
375 }
376 #else
rmi_f01_of_probe(struct device * dev,struct rmi_device_platform_data * pdata)377 static inline int rmi_f01_of_probe(struct device *dev,
378 					struct rmi_device_platform_data *pdata)
379 {
380 	return -ENODEV;
381 }
382 #endif
383 
rmi_f01_probe(struct rmi_function * fn)384 static int rmi_f01_probe(struct rmi_function *fn)
385 {
386 	struct rmi_device *rmi_dev = fn->rmi_dev;
387 	struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
388 	struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
389 	struct f01_data *f01;
390 	int error;
391 	u16 ctrl_base_addr = fn->fd.control_base_addr;
392 	u8 device_status;
393 	u8 temp;
394 
395 	if (fn->dev.of_node) {
396 		error = rmi_f01_of_probe(&fn->dev, pdata);
397 		if (error)
398 			return error;
399 	}
400 
401 	f01 = devm_kzalloc(&fn->dev, sizeof(struct f01_data), GFP_KERNEL);
402 	if (!f01)
403 		return -ENOMEM;
404 
405 	f01->num_of_irq_regs = driver_data->num_of_irq_regs;
406 
407 	/*
408 	 * Set the configured bit and (optionally) other important stuff
409 	 * in the device control register.
410 	 */
411 
412 	error = rmi_read(rmi_dev, fn->fd.control_base_addr,
413 			 &f01->device_control.ctrl0);
414 	if (error) {
415 		dev_err(&fn->dev, "Failed to read F01 control: %d\n", error);
416 		return error;
417 	}
418 
419 	switch (pdata->power_management.nosleep) {
420 	case RMI_REG_STATE_DEFAULT:
421 		break;
422 	case RMI_REG_STATE_OFF:
423 		f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT;
424 		break;
425 	case RMI_REG_STATE_ON:
426 		f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
427 		break;
428 	}
429 
430 	/*
431 	 * Sleep mode might be set as a hangover from a system crash or
432 	 * reboot without power cycle.  If so, clear it so the sensor
433 	 * is certain to function.
434 	 */
435 	if ((f01->device_control.ctrl0 & RMI_F01_CTRL0_SLEEP_MODE_MASK) !=
436 			RMI_SLEEP_MODE_NORMAL) {
437 		dev_warn(&fn->dev,
438 			 "WARNING: Non-zero sleep mode found. Clearing...\n");
439 		f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
440 	}
441 
442 	f01->device_control.ctrl0 |= RMI_F01_CTRL0_CONFIGURED_BIT;
443 
444 	error = rmi_write(rmi_dev, fn->fd.control_base_addr,
445 			  f01->device_control.ctrl0);
446 	if (error) {
447 		dev_err(&fn->dev, "Failed to write F01 control: %d\n", error);
448 		return error;
449 	}
450 
451 	/* Dummy read in order to clear irqs */
452 	error = rmi_read(rmi_dev, fn->fd.data_base_addr + 1, &temp);
453 	if (error < 0) {
454 		dev_err(&fn->dev, "Failed to read Interrupt Status.\n");
455 		return error;
456 	}
457 
458 	error = rmi_f01_read_properties(rmi_dev, fn->fd.query_base_addr,
459 					&f01->properties);
460 	if (error < 0) {
461 		dev_err(&fn->dev, "Failed to read F01 properties.\n");
462 		return error;
463 	}
464 
465 	dev_info(&fn->dev, "found RMI device, manufacturer: %s, product: %s, fw id: %d\n",
466 		 f01->properties.manufacturer_id == 1 ? "Synaptics" : "unknown",
467 		 f01->properties.product_id, f01->properties.firmware_id);
468 
469 	/* Advance to interrupt control registers, then skip over them. */
470 	ctrl_base_addr++;
471 	ctrl_base_addr += f01->num_of_irq_regs;
472 
473 	/* read control register */
474 	if (f01->properties.has_adjustable_doze) {
475 		f01->doze_interval_addr = ctrl_base_addr;
476 		ctrl_base_addr++;
477 
478 		if (pdata->power_management.doze_interval) {
479 			f01->device_control.doze_interval =
480 				pdata->power_management.doze_interval;
481 			error = rmi_write(rmi_dev, f01->doze_interval_addr,
482 					  f01->device_control.doze_interval);
483 			if (error) {
484 				dev_err(&fn->dev,
485 					"Failed to configure F01 doze interval register: %d\n",
486 					error);
487 				return error;
488 			}
489 		} else {
490 			error = rmi_read(rmi_dev, f01->doze_interval_addr,
491 					 &f01->device_control.doze_interval);
492 			if (error) {
493 				dev_err(&fn->dev,
494 					"Failed to read F01 doze interval register: %d\n",
495 					error);
496 				return error;
497 			}
498 		}
499 
500 		f01->wakeup_threshold_addr = ctrl_base_addr;
501 		ctrl_base_addr++;
502 
503 		if (pdata->power_management.wakeup_threshold) {
504 			f01->device_control.wakeup_threshold =
505 				pdata->power_management.wakeup_threshold;
506 			error = rmi_write(rmi_dev, f01->wakeup_threshold_addr,
507 					  f01->device_control.wakeup_threshold);
508 			if (error) {
509 				dev_err(&fn->dev,
510 					"Failed to configure F01 wakeup threshold register: %d\n",
511 					error);
512 				return error;
513 			}
514 		} else {
515 			error = rmi_read(rmi_dev, f01->wakeup_threshold_addr,
516 					 &f01->device_control.wakeup_threshold);
517 			if (error < 0) {
518 				dev_err(&fn->dev,
519 					"Failed to read F01 wakeup threshold register: %d\n",
520 					error);
521 				return error;
522 			}
523 		}
524 	}
525 
526 	if (f01->properties.has_lts)
527 		ctrl_base_addr++;
528 
529 	if (f01->properties.has_adjustable_doze_holdoff) {
530 		f01->doze_holdoff_addr = ctrl_base_addr;
531 		ctrl_base_addr++;
532 
533 		if (pdata->power_management.doze_holdoff) {
534 			f01->device_control.doze_holdoff =
535 				pdata->power_management.doze_holdoff;
536 			error = rmi_write(rmi_dev, f01->doze_holdoff_addr,
537 					  f01->device_control.doze_holdoff);
538 			if (error) {
539 				dev_err(&fn->dev,
540 					"Failed to configure F01 doze holdoff register: %d\n",
541 					error);
542 				return error;
543 			}
544 		} else {
545 			error = rmi_read(rmi_dev, f01->doze_holdoff_addr,
546 					 &f01->device_control.doze_holdoff);
547 			if (error) {
548 				dev_err(&fn->dev,
549 					"Failed to read F01 doze holdoff register: %d\n",
550 					error);
551 				return error;
552 			}
553 		}
554 	}
555 
556 	error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
557 	if (error < 0) {
558 		dev_err(&fn->dev,
559 			"Failed to read device status: %d\n", error);
560 		return error;
561 	}
562 
563 	if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
564 		dev_err(&fn->dev,
565 			"Device was reset during configuration process, status: %#02x!\n",
566 			RMI_F01_STATUS_CODE(device_status));
567 		return -EINVAL;
568 	}
569 
570 	dev_set_drvdata(&fn->dev, f01);
571 
572 	error = sysfs_create_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group);
573 	if (error)
574 		dev_warn(&fn->dev, "Failed to create sysfs group: %d\n", error);
575 
576 	return 0;
577 }
578 
rmi_f01_remove(struct rmi_function * fn)579 static void rmi_f01_remove(struct rmi_function *fn)
580 {
581 	/* Note that the bus device is used, not the F01 device */
582 	sysfs_remove_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group);
583 }
584 
rmi_f01_config(struct rmi_function * fn)585 static int rmi_f01_config(struct rmi_function *fn)
586 {
587 	struct f01_data *f01 = dev_get_drvdata(&fn->dev);
588 	int error;
589 
590 	error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
591 			  f01->device_control.ctrl0);
592 	if (error) {
593 		dev_err(&fn->dev,
594 			"Failed to write device_control register: %d\n", error);
595 		return error;
596 	}
597 
598 	if (f01->properties.has_adjustable_doze) {
599 		error = rmi_write(fn->rmi_dev, f01->doze_interval_addr,
600 				  f01->device_control.doze_interval);
601 		if (error) {
602 			dev_err(&fn->dev,
603 				"Failed to write doze interval: %d\n", error);
604 			return error;
605 		}
606 
607 		error = rmi_write_block(fn->rmi_dev,
608 					 f01->wakeup_threshold_addr,
609 					 &f01->device_control.wakeup_threshold,
610 					 sizeof(u8));
611 		if (error) {
612 			dev_err(&fn->dev,
613 				"Failed to write wakeup threshold: %d\n",
614 				error);
615 			return error;
616 		}
617 	}
618 
619 	if (f01->properties.has_adjustable_doze_holdoff) {
620 		error = rmi_write(fn->rmi_dev, f01->doze_holdoff_addr,
621 				  f01->device_control.doze_holdoff);
622 		if (error) {
623 			dev_err(&fn->dev,
624 				"Failed to write doze holdoff: %d\n", error);
625 			return error;
626 		}
627 	}
628 
629 	return 0;
630 }
631 
rmi_f01_suspend(struct rmi_function * fn)632 static int rmi_f01_suspend(struct rmi_function *fn)
633 {
634 	struct f01_data *f01 = dev_get_drvdata(&fn->dev);
635 	int error;
636 
637 	f01->old_nosleep =
638 		f01->device_control.ctrl0 & RMI_F01_CTRL0_NOSLEEP_BIT;
639 	f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT;
640 
641 	f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
642 	if (device_may_wakeup(fn->rmi_dev->xport->dev))
643 		f01->device_control.ctrl0 |= RMI_SLEEP_MODE_RESERVED1;
644 	else
645 		f01->device_control.ctrl0 |= RMI_SLEEP_MODE_SENSOR_SLEEP;
646 
647 	error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
648 			  f01->device_control.ctrl0);
649 	if (error) {
650 		dev_err(&fn->dev, "Failed to write sleep mode: %d.\n", error);
651 		if (f01->old_nosleep)
652 			f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
653 		f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
654 		f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
655 		return error;
656 	}
657 
658 	return 0;
659 }
660 
rmi_f01_resume(struct rmi_function * fn)661 static int rmi_f01_resume(struct rmi_function *fn)
662 {
663 	struct f01_data *f01 = dev_get_drvdata(&fn->dev);
664 	int error;
665 
666 	if (f01->old_nosleep)
667 		f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
668 
669 	f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
670 	f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
671 
672 	error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
673 			  f01->device_control.ctrl0);
674 	if (error) {
675 		dev_err(&fn->dev,
676 			"Failed to restore normal operation: %d.\n", error);
677 		return error;
678 	}
679 
680 	return 0;
681 }
682 
rmi_f01_attention(int irq,void * ctx)683 static irqreturn_t rmi_f01_attention(int irq, void *ctx)
684 {
685 	struct rmi_function *fn = ctx;
686 	struct rmi_device *rmi_dev = fn->rmi_dev;
687 	int error;
688 	u8 device_status;
689 
690 	error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
691 	if (error) {
692 		dev_err(&fn->dev,
693 			"Failed to read device status: %d.\n", error);
694 		return IRQ_RETVAL(error);
695 	}
696 
697 	if (RMI_F01_STATUS_BOOTLOADER(device_status))
698 		dev_warn(&fn->dev,
699 			 "Device in bootloader mode, please update firmware\n");
700 
701 	if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
702 		dev_warn(&fn->dev, "Device reset detected.\n");
703 		error = rmi_dev->driver->reset_handler(rmi_dev);
704 		if (error) {
705 			dev_err(&fn->dev, "Device reset failed: %d\n", error);
706 			return IRQ_RETVAL(error);
707 		}
708 	}
709 
710 	return IRQ_HANDLED;
711 }
712 
713 struct rmi_function_handler rmi_f01_handler = {
714 	.driver = {
715 		.name	= "rmi4_f01",
716 		/*
717 		 * Do not allow user unbinding F01 as it is critical
718 		 * function.
719 		 */
720 		.suppress_bind_attrs = true,
721 	},
722 	.func		= 0x01,
723 	.probe		= rmi_f01_probe,
724 	.remove		= rmi_f01_remove,
725 	.config		= rmi_f01_config,
726 	.attention	= rmi_f01_attention,
727 	.suspend	= rmi_f01_suspend,
728 	.resume		= rmi_f01_resume,
729 };
730