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