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 | |
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(d: rmi_dev, addr: query_offset, |
153 | buf: 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(buf: props->dom, size: sizeof(props->dom), fmt: "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(d: rmi_dev, addr: query_offset, buf: 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(d: rmi_dev, addr: query_offset, buf: &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(d: rmi_dev, addr: query_offset, buf: 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(d: rmi_dev, addr: prod_info_addr, |
226 | buf: queries, len: 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(p: queries); |
235 | prod_info_addr++; |
236 | } |
237 | |
238 | if (has_build_id_query) { |
239 | ret = rmi_read_block(d: rmi_dev, addr: prod_info_addr, buf: queries, |
240 | len: 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 | |
256 | const char *rmi_f01_get_product_ID(struct rmi_function *fn) |
257 | { |
258 | struct f01_data *f01 = dev_get_drvdata(dev: &fn->dev); |
259 | |
260 | return f01->properties.product_id; |
261 | } |
262 | |
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(dev: &data->f01_container->dev); |
269 | |
270 | return scnprintf(buf, PAGE_SIZE, fmt: "%d\n" , |
271 | f01->properties.manufacturer_id); |
272 | } |
273 | |
274 | static DEVICE_ATTR(manufacturer_id, 0444, |
275 | rmi_driver_manufacturer_id_show, NULL); |
276 | |
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(dev: &data->f01_container->dev); |
282 | |
283 | return scnprintf(buf, PAGE_SIZE, fmt: "%s\n" , f01->properties.dom); |
284 | } |
285 | |
286 | static DEVICE_ATTR(date_of_manufacture, 0444, rmi_driver_dom_show, NULL); |
287 | |
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(dev: &data->f01_container->dev); |
294 | |
295 | return scnprintf(buf, PAGE_SIZE, fmt: "%s\n" , f01->properties.product_id); |
296 | } |
297 | |
298 | static DEVICE_ATTR(product_id, 0444, rmi_driver_product_id_show, NULL); |
299 | |
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(dev: &data->f01_container->dev); |
306 | |
307 | return scnprintf(buf, PAGE_SIZE, fmt: "%d\n" , f01->properties.firmware_id); |
308 | } |
309 | |
310 | static DEVICE_ATTR(firmware_id, 0444, rmi_driver_firmware_id_show, NULL); |
311 | |
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(dev: &data->f01_container->dev); |
318 | |
319 | u32 package_id = f01->properties.package_id; |
320 | |
321 | return scnprintf(buf, PAGE_SIZE, fmt: "%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 |
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 | result: (u32 *)&pdata->power_management.nosleep, |
349 | prop: "syna,nosleep-mode" , optional: 1); |
350 | if (retval) |
351 | return retval; |
352 | |
353 | retval = rmi_of_property_read_u32(dev, result: &val, |
354 | prop: "syna,wakeup-threshold" , optional: 1); |
355 | if (retval) |
356 | return retval; |
357 | |
358 | pdata->power_management.wakeup_threshold = val; |
359 | |
360 | retval = rmi_of_property_read_u32(dev, result: &val, |
361 | prop: "syna,doze-holdoff-ms" , optional: 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, result: &val, |
368 | prop: "syna,doze-interval-ms" , optional: 1); |
369 | if (retval) |
370 | return retval; |
371 | |
372 | pdata->power_management.doze_interval = val / 10; |
373 | |
374 | return 0; |
375 | } |
376 | #else |
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 | |
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(dev: &rmi_dev->dev); |
388 | struct rmi_device_platform_data *pdata = rmi_get_platform_data(d: 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(dev: &fn->dev, pdata); |
397 | if (error) |
398 | return error; |
399 | } |
400 | |
401 | f01 = devm_kzalloc(dev: &fn->dev, size: 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(d: rmi_dev, addr: fn->fd.control_base_addr, |
413 | buf: &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(d: rmi_dev, addr: fn->fd.control_base_addr, |
445 | data: 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(d: rmi_dev, addr: fn->fd.data_base_addr + 1, buf: &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, query_base_addr: fn->fd.query_base_addr, |
459 | props: &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(d: rmi_dev, addr: f01->doze_interval_addr, |
482 | data: 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(d: rmi_dev, addr: f01->doze_interval_addr, |
491 | buf: &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(d: rmi_dev, addr: f01->wakeup_threshold_addr, |
507 | data: 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(d: rmi_dev, addr: f01->wakeup_threshold_addr, |
516 | buf: &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(d: rmi_dev, addr: f01->doze_holdoff_addr, |
537 | data: 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(d: rmi_dev, addr: f01->doze_holdoff_addr, |
546 | buf: &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(d: rmi_dev, addr: fn->fd.data_base_addr, buf: &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(dev: &fn->dev, data: f01); |
571 | |
572 | error = sysfs_create_group(kobj: &fn->rmi_dev->dev.kobj, grp: &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 | |
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(kobj: &fn->rmi_dev->dev.kobj, grp: &rmi_f01_attr_group); |
583 | } |
584 | |
585 | static int rmi_f01_config(struct rmi_function *fn) |
586 | { |
587 | struct f01_data *f01 = dev_get_drvdata(dev: &fn->dev); |
588 | int error; |
589 | |
590 | error = rmi_write(d: fn->rmi_dev, addr: fn->fd.control_base_addr, |
591 | data: 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(d: fn->rmi_dev, addr: f01->doze_interval_addr, |
600 | data: 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(d: fn->rmi_dev, |
608 | addr: f01->wakeup_threshold_addr, |
609 | buf: &f01->device_control.wakeup_threshold, |
610 | len: 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(d: fn->rmi_dev, addr: f01->doze_holdoff_addr, |
621 | data: 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 | |
632 | static int rmi_f01_suspend(struct rmi_function *fn) |
633 | { |
634 | struct f01_data *f01 = dev_get_drvdata(dev: &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(dev: 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(d: fn->rmi_dev, addr: fn->fd.control_base_addr, |
648 | data: 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 | |
661 | static int rmi_f01_resume(struct rmi_function *fn) |
662 | { |
663 | struct f01_data *f01 = dev_get_drvdata(dev: &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(d: fn->rmi_dev, addr: fn->fd.control_base_addr, |
673 | data: 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 | |
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(d: rmi_dev, addr: fn->fd.data_base_addr, buf: &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 | |