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