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