2 * Copyright (c) 2011-2016 Synaptics Incorporated
3 * Copyright (c) 2011 Unixphere
5 * This driver provides the core support for a single RMI4-based device.
7 * The RMI4 specification can be found here (URL split for line length):
9 * http://www.synaptics.com/sites/default/files/
10 * 511-000136-01-Rev-E-RMI4-Interfacing-Guide.pdf
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License version 2 as published by
14 * the Free Software Foundation.
17 #include <linux/bitmap.h>
18 #include <linux/delay.h>
20 #include <linux/irq.h>
22 #include <linux/slab.h>
24 #include <uapi/linux/input.h>
25 #include <linux/rmi.h>
27 #include "rmi_driver.h"
29 #define HAS_NONSTANDARD_PDT_MASK 0x40
30 #define RMI4_MAX_PAGE 0xff
31 #define RMI4_PAGE_SIZE 0x100
32 #define RMI4_PAGE_MASK 0xFF00
34 #define RMI_DEVICE_RESET_CMD 0x01
35 #define DEFAULT_RESET_DELAY_MS 100
37 void rmi_free_function_list(struct rmi_device
*rmi_dev
)
39 struct rmi_function
*fn
, *tmp
;
40 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
42 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Freeing function list\n");
44 devm_kfree(&rmi_dev
->dev
, data
->irq_memory
);
45 data
->irq_memory
= NULL
;
46 data
->irq_status
= NULL
;
47 data
->fn_irq_bits
= NULL
;
48 data
->current_irq_mask
= NULL
;
49 data
->new_irq_mask
= NULL
;
51 data
->f01_container
= NULL
;
52 data
->f34_container
= NULL
;
54 /* Doing it in the reverse order so F01 will be removed last */
55 list_for_each_entry_safe_reverse(fn
, tmp
,
56 &data
->function_list
, node
) {
58 rmi_unregister_function(fn
);
62 static int reset_one_function(struct rmi_function
*fn
)
64 struct rmi_function_handler
*fh
;
67 if (!fn
|| !fn
->dev
.driver
)
70 fh
= to_rmi_function_handler(fn
->dev
.driver
);
72 retval
= fh
->reset(fn
);
74 dev_err(&fn
->dev
, "Reset failed with code %d.\n",
81 static int configure_one_function(struct rmi_function
*fn
)
83 struct rmi_function_handler
*fh
;
86 if (!fn
|| !fn
->dev
.driver
)
89 fh
= to_rmi_function_handler(fn
->dev
.driver
);
91 retval
= fh
->config(fn
);
93 dev_err(&fn
->dev
, "Config failed with code %d.\n",
100 static int rmi_driver_process_reset_requests(struct rmi_device
*rmi_dev
)
102 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
103 struct rmi_function
*entry
;
106 list_for_each_entry(entry
, &data
->function_list
, node
) {
107 retval
= reset_one_function(entry
);
115 static int rmi_driver_process_config_requests(struct rmi_device
*rmi_dev
)
117 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
118 struct rmi_function
*entry
;
121 list_for_each_entry(entry
, &data
->function_list
, node
) {
122 retval
= configure_one_function(entry
);
130 static void process_one_interrupt(struct rmi_driver_data
*data
,
131 struct rmi_function
*fn
)
133 struct rmi_function_handler
*fh
;
135 if (!fn
|| !fn
->dev
.driver
)
138 fh
= to_rmi_function_handler(fn
->dev
.driver
);
140 bitmap_and(data
->fn_irq_bits
, data
->irq_status
, fn
->irq_mask
,
142 if (!bitmap_empty(data
->fn_irq_bits
, data
->irq_count
))
143 fh
->attention(fn
, data
->fn_irq_bits
);
147 static int rmi_process_interrupt_requests(struct rmi_device
*rmi_dev
)
149 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
150 struct device
*dev
= &rmi_dev
->dev
;
151 struct rmi_function
*entry
;
157 if (!data
->attn_data
.data
) {
158 error
= rmi_read_block(rmi_dev
,
159 data
->f01_container
->fd
.data_base_addr
+ 1,
160 data
->irq_status
, data
->num_of_irq_regs
);
162 dev_err(dev
, "Failed to read irqs, code=%d\n", error
);
167 mutex_lock(&data
->irq_mutex
);
168 bitmap_and(data
->irq_status
, data
->irq_status
, data
->current_irq_mask
,
171 * At this point, irq_status has all bits that are set in the
172 * interrupt status register and are enabled.
174 mutex_unlock(&data
->irq_mutex
);
177 * It would be nice to be able to use irq_chip to handle these
178 * nested IRQs. Unfortunately, most of the current customers for
179 * this driver are using older kernels (3.0.x) that don't support
180 * the features required for that. Once they've shifted to more
181 * recent kernels (say, 3.3 and higher), this should be switched to
184 list_for_each_entry(entry
, &data
->function_list
, node
)
185 process_one_interrupt(data
, entry
);
188 input_sync(data
->input
);
193 void rmi_set_attn_data(struct rmi_device
*rmi_dev
, unsigned long irq_status
,
194 void *data
, size_t size
)
196 struct rmi_driver_data
*drvdata
= dev_get_drvdata(&rmi_dev
->dev
);
197 struct rmi4_attn_data attn_data
;
200 if (!drvdata
->enabled
)
203 fifo_data
= kmemdup(data
, size
, GFP_ATOMIC
);
207 attn_data
.irq_status
= irq_status
;
208 attn_data
.size
= size
;
209 attn_data
.data
= fifo_data
;
211 kfifo_put(&drvdata
->attn_fifo
, attn_data
);
213 EXPORT_SYMBOL_GPL(rmi_set_attn_data
);
215 static irqreturn_t
rmi_irq_fn(int irq
, void *dev_id
)
217 struct rmi_device
*rmi_dev
= dev_id
;
218 struct rmi_driver_data
*drvdata
= dev_get_drvdata(&rmi_dev
->dev
);
219 struct rmi4_attn_data attn_data
= {0};
222 count
= kfifo_get(&drvdata
->attn_fifo
, &attn_data
);
224 *(drvdata
->irq_status
) = attn_data
.irq_status
;
225 drvdata
->attn_data
= attn_data
;
228 ret
= rmi_process_interrupt_requests(rmi_dev
);
230 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
,
231 "Failed to process interrupt request: %d\n", ret
);
234 kfree(attn_data
.data
);
236 if (!kfifo_is_empty(&drvdata
->attn_fifo
))
237 return rmi_irq_fn(irq
, dev_id
);
242 static int rmi_irq_init(struct rmi_device
*rmi_dev
)
244 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
245 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
246 int irq_flags
= irq_get_trigger_type(pdata
->irq
);
250 irq_flags
= IRQF_TRIGGER_LOW
;
252 ret
= devm_request_threaded_irq(&rmi_dev
->dev
, pdata
->irq
, NULL
,
253 rmi_irq_fn
, irq_flags
| IRQF_ONESHOT
,
254 dev_name(rmi_dev
->xport
->dev
),
257 dev_err(&rmi_dev
->dev
, "Failed to register interrupt %d\n",
263 data
->enabled
= true;
268 static int suspend_one_function(struct rmi_function
*fn
)
270 struct rmi_function_handler
*fh
;
273 if (!fn
|| !fn
->dev
.driver
)
276 fh
= to_rmi_function_handler(fn
->dev
.driver
);
278 retval
= fh
->suspend(fn
);
280 dev_err(&fn
->dev
, "Suspend failed with code %d.\n",
287 static int rmi_suspend_functions(struct rmi_device
*rmi_dev
)
289 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
290 struct rmi_function
*entry
;
293 list_for_each_entry(entry
, &data
->function_list
, node
) {
294 retval
= suspend_one_function(entry
);
302 static int resume_one_function(struct rmi_function
*fn
)
304 struct rmi_function_handler
*fh
;
307 if (!fn
|| !fn
->dev
.driver
)
310 fh
= to_rmi_function_handler(fn
->dev
.driver
);
312 retval
= fh
->resume(fn
);
314 dev_err(&fn
->dev
, "Resume failed with code %d.\n",
321 static int rmi_resume_functions(struct rmi_device
*rmi_dev
)
323 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
324 struct rmi_function
*entry
;
327 list_for_each_entry(entry
, &data
->function_list
, node
) {
328 retval
= resume_one_function(entry
);
336 int rmi_enable_sensor(struct rmi_device
*rmi_dev
)
340 retval
= rmi_driver_process_config_requests(rmi_dev
);
344 return rmi_process_interrupt_requests(rmi_dev
);
348 * rmi_driver_set_input_params - set input device id and other data.
350 * @rmi_dev: Pointer to an RMI device
351 * @input: Pointer to input device
354 static int rmi_driver_set_input_params(struct rmi_device
*rmi_dev
,
355 struct input_dev
*input
)
357 input
->name
= SYNAPTICS_INPUT_DEVICE_NAME
;
358 input
->id
.vendor
= SYNAPTICS_VENDOR_ID
;
359 input
->id
.bustype
= BUS_RMI
;
363 static void rmi_driver_set_input_name(struct rmi_device
*rmi_dev
,
364 struct input_dev
*input
)
366 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
367 char *device_name
= rmi_f01_get_product_ID(data
->f01_container
);
370 name
= devm_kasprintf(&rmi_dev
->dev
, GFP_KERNEL
,
371 "Synaptics %s", device_name
);
378 static int rmi_driver_set_irq_bits(struct rmi_device
*rmi_dev
,
382 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
383 struct device
*dev
= &rmi_dev
->dev
;
385 mutex_lock(&data
->irq_mutex
);
386 bitmap_or(data
->new_irq_mask
,
387 data
->current_irq_mask
, mask
, data
->irq_count
);
389 error
= rmi_write_block(rmi_dev
,
390 data
->f01_container
->fd
.control_base_addr
+ 1,
391 data
->new_irq_mask
, data
->num_of_irq_regs
);
393 dev_err(dev
, "%s: Failed to change enabled interrupts!",
397 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
398 data
->num_of_irq_regs
);
401 mutex_unlock(&data
->irq_mutex
);
405 static int rmi_driver_clear_irq_bits(struct rmi_device
*rmi_dev
,
409 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
410 struct device
*dev
= &rmi_dev
->dev
;
412 mutex_lock(&data
->irq_mutex
);
413 bitmap_andnot(data
->new_irq_mask
,
414 data
->current_irq_mask
, mask
, data
->irq_count
);
416 error
= rmi_write_block(rmi_dev
,
417 data
->f01_container
->fd
.control_base_addr
+ 1,
418 data
->new_irq_mask
, data
->num_of_irq_regs
);
420 dev_err(dev
, "%s: Failed to change enabled interrupts!",
424 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
425 data
->num_of_irq_regs
);
428 mutex_unlock(&data
->irq_mutex
);
432 static int rmi_driver_reset_handler(struct rmi_device
*rmi_dev
)
434 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
438 * Can get called before the driver is fully ready to deal with
441 if (!data
|| !data
->f01_container
) {
442 dev_warn(&rmi_dev
->dev
,
443 "Not ready to handle reset yet!\n");
447 error
= rmi_read_block(rmi_dev
,
448 data
->f01_container
->fd
.control_base_addr
+ 1,
449 data
->current_irq_mask
, data
->num_of_irq_regs
);
451 dev_err(&rmi_dev
->dev
, "%s: Failed to read current IRQ mask.\n",
456 error
= rmi_driver_process_reset_requests(rmi_dev
);
460 error
= rmi_driver_process_config_requests(rmi_dev
);
467 static int rmi_read_pdt_entry(struct rmi_device
*rmi_dev
,
468 struct pdt_entry
*entry
, u16 pdt_address
)
470 u8 buf
[RMI_PDT_ENTRY_SIZE
];
473 error
= rmi_read_block(rmi_dev
, pdt_address
, buf
, RMI_PDT_ENTRY_SIZE
);
475 dev_err(&rmi_dev
->dev
, "Read PDT entry at %#06x failed, code: %d.\n",
480 entry
->page_start
= pdt_address
& RMI4_PAGE_MASK
;
481 entry
->query_base_addr
= buf
[0];
482 entry
->command_base_addr
= buf
[1];
483 entry
->control_base_addr
= buf
[2];
484 entry
->data_base_addr
= buf
[3];
485 entry
->interrupt_source_count
= buf
[4] & RMI_PDT_INT_SOURCE_COUNT_MASK
;
486 entry
->function_version
= (buf
[4] & RMI_PDT_FUNCTION_VERSION_MASK
) >> 5;
487 entry
->function_number
= buf
[5];
492 static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry
*pdt
,
493 struct rmi_function_descriptor
*fd
)
495 fd
->query_base_addr
= pdt
->query_base_addr
+ pdt
->page_start
;
496 fd
->command_base_addr
= pdt
->command_base_addr
+ pdt
->page_start
;
497 fd
->control_base_addr
= pdt
->control_base_addr
+ pdt
->page_start
;
498 fd
->data_base_addr
= pdt
->data_base_addr
+ pdt
->page_start
;
499 fd
->function_number
= pdt
->function_number
;
500 fd
->interrupt_source_count
= pdt
->interrupt_source_count
;
501 fd
->function_version
= pdt
->function_version
;
504 #define RMI_SCAN_CONTINUE 0
505 #define RMI_SCAN_DONE 1
507 static int rmi_scan_pdt_page(struct rmi_device
*rmi_dev
,
511 int (*callback
)(struct rmi_device
*rmi_dev
,
513 const struct pdt_entry
*entry
))
515 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
516 struct pdt_entry pdt_entry
;
517 u16 page_start
= RMI4_PAGE_SIZE
* page
;
518 u16 pdt_start
= page_start
+ PDT_START_SCAN_LOCATION
;
519 u16 pdt_end
= page_start
+ PDT_END_SCAN_LOCATION
;
524 for (addr
= pdt_start
; addr
>= pdt_end
; addr
-= RMI_PDT_ENTRY_SIZE
) {
525 error
= rmi_read_pdt_entry(rmi_dev
, &pdt_entry
, addr
);
529 if (RMI4_END_OF_PDT(pdt_entry
.function_number
))
532 retval
= callback(rmi_dev
, ctx
, &pdt_entry
);
533 if (retval
!= RMI_SCAN_CONTINUE
)
538 * Count number of empty PDT pages. If a gap of two pages
539 * or more is found, stop scanning.
541 if (addr
== pdt_start
)
546 return (data
->bootloader_mode
|| *empty_pages
>= 2) ?
547 RMI_SCAN_DONE
: RMI_SCAN_CONTINUE
;
550 int rmi_scan_pdt(struct rmi_device
*rmi_dev
, void *ctx
,
551 int (*callback
)(struct rmi_device
*rmi_dev
,
552 void *ctx
, const struct pdt_entry
*entry
))
556 int retval
= RMI_SCAN_DONE
;
558 for (page
= 0; page
<= RMI4_MAX_PAGE
; page
++) {
559 retval
= rmi_scan_pdt_page(rmi_dev
, page
, &empty_pages
,
561 if (retval
!= RMI_SCAN_CONTINUE
)
565 return retval
< 0 ? retval
: 0;
568 int rmi_read_register_desc(struct rmi_device
*d
, u16 addr
,
569 struct rmi_register_descriptor
*rdesc
)
572 u8 size_presence_reg
;
574 int presense_offset
= 1;
583 * The first register of the register descriptor is the size of
584 * the register descriptor's presense register.
586 ret
= rmi_read(d
, addr
, &size_presence_reg
);
591 if (size_presence_reg
< 0 || size_presence_reg
> 35)
594 memset(buf
, 0, sizeof(buf
));
597 * The presence register contains the size of the register structure
598 * and a bitmap which identified which packet registers are present
599 * for this particular register type (ie query, control, or data).
601 ret
= rmi_read_block(d
, addr
, buf
, size_presence_reg
);
608 rdesc
->struct_size
= buf
[1] | (buf
[2] << 8);
610 rdesc
->struct_size
= buf
[0];
613 for (i
= presense_offset
; i
< size_presence_reg
; i
++) {
614 for (b
= 0; b
< 8; b
++) {
615 if (buf
[i
] & (0x1 << b
))
616 bitmap_set(rdesc
->presense_map
, map_offset
, 1);
621 rdesc
->num_registers
= bitmap_weight(rdesc
->presense_map
,
622 RMI_REG_DESC_PRESENSE_BITS
);
624 rdesc
->registers
= devm_kzalloc(&d
->dev
, rdesc
->num_registers
*
625 sizeof(struct rmi_register_desc_item
),
627 if (!rdesc
->registers
)
631 * Allocate a temporary buffer to hold the register structure.
632 * I'm not using devm_kzalloc here since it will not be retained
633 * after exiting this function
635 struct_buf
= kzalloc(rdesc
->struct_size
, GFP_KERNEL
);
640 * The register structure contains information about every packet
641 * register of this type. This includes the size of the packet
642 * register and a bitmap of all subpackets contained in the packet
645 ret
= rmi_read_block(d
, addr
, struct_buf
, rdesc
->struct_size
);
647 goto free_struct_buff
;
649 reg
= find_first_bit(rdesc
->presense_map
, RMI_REG_DESC_PRESENSE_BITS
);
650 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
651 struct rmi_register_desc_item
*item
= &rdesc
->registers
[i
];
652 int reg_size
= struct_buf
[offset
];
656 reg_size
= struct_buf
[offset
] |
657 (struct_buf
[offset
+ 1] << 8);
662 reg_size
= struct_buf
[offset
] |
663 (struct_buf
[offset
+ 1] << 8) |
664 (struct_buf
[offset
+ 2] << 16) |
665 (struct_buf
[offset
+ 3] << 24);
670 item
->reg_size
= reg_size
;
675 for (b
= 0; b
< 7; b
++) {
676 if (struct_buf
[offset
] & (0x1 << b
))
677 bitmap_set(item
->subpacket_map
,
681 } while (struct_buf
[offset
++] & 0x80);
683 item
->num_subpackets
= bitmap_weight(item
->subpacket_map
,
684 RMI_REG_DESC_SUBPACKET_BITS
);
686 rmi_dbg(RMI_DEBUG_CORE
, &d
->dev
,
687 "%s: reg: %d reg size: %ld subpackets: %d\n", __func__
,
688 item
->reg
, item
->reg_size
, item
->num_subpackets
);
690 reg
= find_next_bit(rdesc
->presense_map
,
691 RMI_REG_DESC_PRESENSE_BITS
, reg
+ 1);
699 const struct rmi_register_desc_item
*rmi_get_register_desc_item(
700 struct rmi_register_descriptor
*rdesc
, u16 reg
)
702 const struct rmi_register_desc_item
*item
;
705 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
706 item
= &rdesc
->registers
[i
];
707 if (item
->reg
== reg
)
714 size_t rmi_register_desc_calc_size(struct rmi_register_descriptor
*rdesc
)
716 const struct rmi_register_desc_item
*item
;
720 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
721 item
= &rdesc
->registers
[i
];
722 size
+= item
->reg_size
;
727 /* Compute the register offset relative to the base address */
728 int rmi_register_desc_calc_reg_offset(
729 struct rmi_register_descriptor
*rdesc
, u16 reg
)
731 const struct rmi_register_desc_item
*item
;
735 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
736 item
= &rdesc
->registers
[i
];
737 if (item
->reg
== reg
)
744 bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item
*item
,
747 return find_next_bit(item
->subpacket_map
, RMI_REG_DESC_PRESENSE_BITS
,
748 subpacket
) == subpacket
;
751 static int rmi_check_bootloader_mode(struct rmi_device
*rmi_dev
,
752 const struct pdt_entry
*pdt
)
754 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
758 if (pdt
->function_number
== 0x34 && pdt
->function_version
> 1) {
759 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
761 dev_err(&rmi_dev
->dev
,
762 "Failed to read F34 status: %d.\n", ret
);
767 data
->bootloader_mode
= true;
768 } else if (pdt
->function_number
== 0x01) {
769 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
771 dev_err(&rmi_dev
->dev
,
772 "Failed to read F01 status: %d.\n", ret
);
777 data
->bootloader_mode
= true;
783 static int rmi_count_irqs(struct rmi_device
*rmi_dev
,
784 void *ctx
, const struct pdt_entry
*pdt
)
786 int *irq_count
= ctx
;
789 *irq_count
+= pdt
->interrupt_source_count
;
791 ret
= rmi_check_bootloader_mode(rmi_dev
, pdt
);
795 return RMI_SCAN_CONTINUE
;
798 int rmi_initial_reset(struct rmi_device
*rmi_dev
, void *ctx
,
799 const struct pdt_entry
*pdt
)
803 if (pdt
->function_number
== 0x01) {
804 u16 cmd_addr
= pdt
->page_start
+ pdt
->command_base_addr
;
805 u8 cmd_buf
= RMI_DEVICE_RESET_CMD
;
806 const struct rmi_device_platform_data
*pdata
=
807 rmi_get_platform_data(rmi_dev
);
809 if (rmi_dev
->xport
->ops
->reset
) {
810 error
= rmi_dev
->xport
->ops
->reset(rmi_dev
->xport
,
815 return RMI_SCAN_DONE
;
818 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Sending reset\n");
819 error
= rmi_write_block(rmi_dev
, cmd_addr
, &cmd_buf
, 1);
821 dev_err(&rmi_dev
->dev
,
822 "Initial reset failed. Code = %d.\n", error
);
826 mdelay(pdata
->reset_delay_ms
?: DEFAULT_RESET_DELAY_MS
);
828 return RMI_SCAN_DONE
;
831 /* F01 should always be on page 0. If we don't find it there, fail. */
832 return pdt
->page_start
== 0 ? RMI_SCAN_CONTINUE
: -ENODEV
;
835 static int rmi_create_function(struct rmi_device
*rmi_dev
,
836 void *ctx
, const struct pdt_entry
*pdt
)
838 struct device
*dev
= &rmi_dev
->dev
;
839 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
840 int *current_irq_count
= ctx
;
841 struct rmi_function
*fn
;
845 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Initializing F%02X.\n",
846 pdt
->function_number
);
848 fn
= kzalloc(sizeof(struct rmi_function
) +
849 BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long),
852 dev_err(dev
, "Failed to allocate memory for F%02X\n",
853 pdt
->function_number
);
857 INIT_LIST_HEAD(&fn
->node
);
858 rmi_driver_copy_pdt_to_fd(pdt
, &fn
->fd
);
860 fn
->rmi_dev
= rmi_dev
;
862 fn
->num_of_irqs
= pdt
->interrupt_source_count
;
863 fn
->irq_pos
= *current_irq_count
;
864 *current_irq_count
+= fn
->num_of_irqs
;
866 for (i
= 0; i
< fn
->num_of_irqs
; i
++)
867 set_bit(fn
->irq_pos
+ i
, fn
->irq_mask
);
869 error
= rmi_register_function(fn
);
873 if (pdt
->function_number
== 0x01)
874 data
->f01_container
= fn
;
875 else if (pdt
->function_number
== 0x34)
876 data
->f34_container
= fn
;
878 list_add_tail(&fn
->node
, &data
->function_list
);
880 return RMI_SCAN_CONTINUE
;
883 put_device(&fn
->dev
);
887 void rmi_enable_irq(struct rmi_device
*rmi_dev
, bool clear_wake
)
889 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
890 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
891 int irq
= pdata
->irq
;
895 mutex_lock(&data
->enabled_mutex
);
901 data
->enabled
= true;
902 if (clear_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
903 retval
= disable_irq_wake(irq
);
905 dev_warn(&rmi_dev
->dev
,
906 "Failed to disable irq for wake: %d\n",
911 * Call rmi_process_interrupt_requests() after enabling irq,
912 * otherwise we may lose interrupt on edge-triggered systems.
914 irq_flags
= irq_get_trigger_type(pdata
->irq
);
915 if (irq_flags
& IRQ_TYPE_EDGE_BOTH
)
916 rmi_process_interrupt_requests(rmi_dev
);
919 mutex_unlock(&data
->enabled_mutex
);
922 void rmi_disable_irq(struct rmi_device
*rmi_dev
, bool enable_wake
)
924 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
925 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
926 struct rmi4_attn_data attn_data
= {0};
927 int irq
= pdata
->irq
;
930 mutex_lock(&data
->enabled_mutex
);
935 data
->enabled
= false;
937 if (enable_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
938 retval
= enable_irq_wake(irq
);
940 dev_warn(&rmi_dev
->dev
,
941 "Failed to enable irq for wake: %d\n",
945 /* make sure the fifo is clean */
946 while (!kfifo_is_empty(&data
->attn_fifo
)) {
947 count
= kfifo_get(&data
->attn_fifo
, &attn_data
);
949 kfree(attn_data
.data
);
953 mutex_unlock(&data
->enabled_mutex
);
956 int rmi_driver_suspend(struct rmi_device
*rmi_dev
, bool enable_wake
)
960 retval
= rmi_suspend_functions(rmi_dev
);
962 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
965 rmi_disable_irq(rmi_dev
, enable_wake
);
968 EXPORT_SYMBOL_GPL(rmi_driver_suspend
);
970 int rmi_driver_resume(struct rmi_device
*rmi_dev
, bool clear_wake
)
974 rmi_enable_irq(rmi_dev
, clear_wake
);
976 retval
= rmi_resume_functions(rmi_dev
);
978 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
983 EXPORT_SYMBOL_GPL(rmi_driver_resume
);
985 static int rmi_driver_remove(struct device
*dev
)
987 struct rmi_device
*rmi_dev
= to_rmi_device(dev
);
989 rmi_disable_irq(rmi_dev
, false);
991 rmi_f34_remove_sysfs(rmi_dev
);
992 rmi_free_function_list(rmi_dev
);
998 static int rmi_driver_of_probe(struct device
*dev
,
999 struct rmi_device_platform_data
*pdata
)
1003 retval
= rmi_of_property_read_u32(dev
, &pdata
->reset_delay_ms
,
1004 "syna,reset-delay-ms", 1);
1011 static inline int rmi_driver_of_probe(struct device
*dev
,
1012 struct rmi_device_platform_data
*pdata
)
1018 int rmi_probe_interrupts(struct rmi_driver_data
*data
)
1020 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1021 struct device
*dev
= &rmi_dev
->dev
;
1027 * We need to count the IRQs and allocate their storage before scanning
1028 * the PDT and creating the function entries, because adding a new
1029 * function can trigger events that result in the IRQ related storage
1032 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Counting IRQs.\n", __func__
);
1034 data
->bootloader_mode
= false;
1036 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_count_irqs
);
1038 dev_err(dev
, "IRQ counting failed with code %d.\n", retval
);
1042 if (data
->bootloader_mode
)
1043 dev_warn(&rmi_dev
->dev
, "Device in bootloader mode.\n");
1045 data
->irq_count
= irq_count
;
1046 data
->num_of_irq_regs
= (data
->irq_count
+ 7) / 8;
1048 size
= BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long);
1049 data
->irq_memory
= devm_kzalloc(dev
, size
* 4, GFP_KERNEL
);
1050 if (!data
->irq_memory
) {
1051 dev_err(dev
, "Failed to allocate memory for irq masks.\n");
1055 data
->irq_status
= data
->irq_memory
+ size
* 0;
1056 data
->fn_irq_bits
= data
->irq_memory
+ size
* 1;
1057 data
->current_irq_mask
= data
->irq_memory
+ size
* 2;
1058 data
->new_irq_mask
= data
->irq_memory
+ size
* 3;
1063 int rmi_init_functions(struct rmi_driver_data
*data
)
1065 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1066 struct device
*dev
= &rmi_dev
->dev
;
1071 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Creating functions.\n", __func__
);
1072 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_create_function
);
1074 dev_err(dev
, "Function creation failed with code %d.\n",
1076 goto err_destroy_functions
;
1079 if (!data
->f01_container
) {
1080 dev_err(dev
, "Missing F01 container!\n");
1082 goto err_destroy_functions
;
1085 retval
= rmi_read_block(rmi_dev
,
1086 data
->f01_container
->fd
.control_base_addr
+ 1,
1087 data
->current_irq_mask
, data
->num_of_irq_regs
);
1089 dev_err(dev
, "%s: Failed to read current IRQ mask.\n",
1091 goto err_destroy_functions
;
1096 err_destroy_functions
:
1097 rmi_free_function_list(rmi_dev
);
1101 static int rmi_driver_probe(struct device
*dev
)
1103 struct rmi_driver
*rmi_driver
;
1104 struct rmi_driver_data
*data
;
1105 struct rmi_device_platform_data
*pdata
;
1106 struct rmi_device
*rmi_dev
;
1109 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Starting probe.\n",
1112 if (!rmi_is_physical_device(dev
)) {
1113 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Not a physical device.\n");
1117 rmi_dev
= to_rmi_device(dev
);
1118 rmi_driver
= to_rmi_driver(dev
->driver
);
1119 rmi_dev
->driver
= rmi_driver
;
1121 pdata
= rmi_get_platform_data(rmi_dev
);
1123 if (rmi_dev
->xport
->dev
->of_node
) {
1124 retval
= rmi_driver_of_probe(rmi_dev
->xport
->dev
, pdata
);
1129 data
= devm_kzalloc(dev
, sizeof(struct rmi_driver_data
), GFP_KERNEL
);
1133 INIT_LIST_HEAD(&data
->function_list
);
1134 data
->rmi_dev
= rmi_dev
;
1135 dev_set_drvdata(&rmi_dev
->dev
, data
);
1138 * Right before a warm boot, the sensor might be in some unusual state,
1139 * such as F54 diagnostics, or F34 bootloader mode after a firmware
1140 * or configuration update. In order to clear the sensor to a known
1141 * state and/or apply any updates, we issue a initial reset to clear any
1142 * previous settings and force it into normal operation.
1144 * We have to do this before actually building the PDT because
1145 * the reflash updates (if any) might cause various registers to move
1148 * For a number of reasons, this initial reset may fail to return
1149 * within the specified time, but we'll still be able to bring up the
1150 * driver normally after that failure. This occurs most commonly in
1151 * a cold boot situation (where then firmware takes longer to come up
1152 * than from a warm boot) and the reset_delay_ms in the platform data
1153 * has been set too short to accommodate that. Since the sensor will
1154 * eventually come up and be usable, we don't want to just fail here
1155 * and leave the customer's device unusable. So we warn them, and
1156 * continue processing.
1158 retval
= rmi_scan_pdt(rmi_dev
, NULL
, rmi_initial_reset
);
1160 dev_warn(dev
, "RMI initial reset failed! Continuing in spite of this.\n");
1162 retval
= rmi_read(rmi_dev
, PDT_PROPERTIES_LOCATION
, &data
->pdt_props
);
1165 * we'll print out a warning and continue since
1166 * failure to get the PDT properties is not a cause to fail
1168 dev_warn(dev
, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n",
1169 PDT_PROPERTIES_LOCATION
, retval
);
1172 mutex_init(&data
->irq_mutex
);
1173 mutex_init(&data
->enabled_mutex
);
1175 retval
= rmi_probe_interrupts(data
);
1179 if (rmi_dev
->xport
->input
) {
1181 * The transport driver already has an input device.
1182 * In some cases it is preferable to reuse the transport
1183 * devices input device instead of creating a new one here.
1184 * One example is some HID touchpads report "pass-through"
1185 * button events are not reported by rmi registers.
1187 data
->input
= rmi_dev
->xport
->input
;
1189 data
->input
= devm_input_allocate_device(dev
);
1191 dev_err(dev
, "%s: Failed to allocate input device.\n",
1196 rmi_driver_set_input_params(rmi_dev
, data
->input
);
1197 data
->input
->phys
= devm_kasprintf(dev
, GFP_KERNEL
,
1198 "%s/input0", dev_name(dev
));
1201 retval
= rmi_init_functions(data
);
1205 retval
= rmi_f34_create_sysfs(rmi_dev
);
1210 rmi_driver_set_input_name(rmi_dev
, data
->input
);
1211 if (!rmi_dev
->xport
->input
) {
1212 if (input_register_device(data
->input
)) {
1213 dev_err(dev
, "%s: Failed to register input device.\n",
1215 goto err_destroy_functions
;
1220 retval
= rmi_irq_init(rmi_dev
);
1222 goto err_destroy_functions
;
1224 if (data
->f01_container
->dev
.driver
)
1225 /* Driver already bound, so enable ATTN now. */
1226 return rmi_enable_sensor(rmi_dev
);
1230 err_destroy_functions
:
1231 rmi_free_function_list(rmi_dev
);
1233 return retval
< 0 ? retval
: 0;
1236 static struct rmi_driver rmi_physical_driver
= {
1238 .owner
= THIS_MODULE
,
1239 .name
= "rmi4_physical",
1240 .bus
= &rmi_bus_type
,
1241 .probe
= rmi_driver_probe
,
1242 .remove
= rmi_driver_remove
,
1244 .reset_handler
= rmi_driver_reset_handler
,
1245 .clear_irq_bits
= rmi_driver_clear_irq_bits
,
1246 .set_irq_bits
= rmi_driver_set_irq_bits
,
1247 .set_input_params
= rmi_driver_set_input_params
,
1250 bool rmi_is_physical_driver(struct device_driver
*drv
)
1252 return drv
== &rmi_physical_driver
.driver
;
1255 int __init
rmi_register_physical_driver(void)
1259 error
= driver_register(&rmi_physical_driver
.driver
);
1261 pr_err("%s: driver register failed, code=%d.\n", __func__
,
1269 void __exit
rmi_unregister_physical_driver(void)
1271 driver_unregister(&rmi_physical_driver
.driver
);