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>
21 #include <linux/kconfig.h>
23 #include <linux/slab.h>
25 #include <uapi/linux/input.h>
26 #include <linux/rmi.h>
28 #include "rmi_driver.h"
30 #define HAS_NONSTANDARD_PDT_MASK 0x40
31 #define RMI4_MAX_PAGE 0xff
32 #define RMI4_PAGE_SIZE 0x100
33 #define RMI4_PAGE_MASK 0xFF00
35 #define RMI_DEVICE_RESET_CMD 0x01
36 #define DEFAULT_RESET_DELAY_MS 100
38 void rmi_free_function_list(struct rmi_device
*rmi_dev
)
40 struct rmi_function
*fn
, *tmp
;
41 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
43 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Freeing function list\n");
45 devm_kfree(&rmi_dev
->dev
, data
->irq_memory
);
46 data
->irq_memory
= NULL
;
47 data
->irq_status
= NULL
;
48 data
->fn_irq_bits
= NULL
;
49 data
->current_irq_mask
= NULL
;
50 data
->new_irq_mask
= NULL
;
52 data
->f01_container
= NULL
;
53 data
->f34_container
= NULL
;
55 /* Doing it in the reverse order so F01 will be removed last */
56 list_for_each_entry_safe_reverse(fn
, tmp
,
57 &data
->function_list
, node
) {
59 rmi_unregister_function(fn
);
63 static int reset_one_function(struct rmi_function
*fn
)
65 struct rmi_function_handler
*fh
;
68 if (!fn
|| !fn
->dev
.driver
)
71 fh
= to_rmi_function_handler(fn
->dev
.driver
);
73 retval
= fh
->reset(fn
);
75 dev_err(&fn
->dev
, "Reset failed with code %d.\n",
82 static int configure_one_function(struct rmi_function
*fn
)
84 struct rmi_function_handler
*fh
;
87 if (!fn
|| !fn
->dev
.driver
)
90 fh
= to_rmi_function_handler(fn
->dev
.driver
);
92 retval
= fh
->config(fn
);
94 dev_err(&fn
->dev
, "Config failed with code %d.\n",
101 static int rmi_driver_process_reset_requests(struct rmi_device
*rmi_dev
)
103 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
104 struct rmi_function
*entry
;
107 list_for_each_entry(entry
, &data
->function_list
, node
) {
108 retval
= reset_one_function(entry
);
116 static int rmi_driver_process_config_requests(struct rmi_device
*rmi_dev
)
118 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
119 struct rmi_function
*entry
;
122 list_for_each_entry(entry
, &data
->function_list
, node
) {
123 retval
= configure_one_function(entry
);
131 static void process_one_interrupt(struct rmi_driver_data
*data
,
132 struct rmi_function
*fn
)
134 struct rmi_function_handler
*fh
;
136 if (!fn
|| !fn
->dev
.driver
)
139 fh
= to_rmi_function_handler(fn
->dev
.driver
);
141 bitmap_and(data
->fn_irq_bits
, data
->irq_status
, fn
->irq_mask
,
143 if (!bitmap_empty(data
->fn_irq_bits
, data
->irq_count
))
144 fh
->attention(fn
, data
->fn_irq_bits
);
148 static int rmi_process_interrupt_requests(struct rmi_device
*rmi_dev
)
150 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
151 struct device
*dev
= &rmi_dev
->dev
;
152 struct rmi_function
*entry
;
158 if (!data
->attn_data
.data
) {
159 error
= rmi_read_block(rmi_dev
,
160 data
->f01_container
->fd
.data_base_addr
+ 1,
161 data
->irq_status
, data
->num_of_irq_regs
);
163 dev_err(dev
, "Failed to read irqs, code=%d\n", error
);
168 mutex_lock(&data
->irq_mutex
);
169 bitmap_and(data
->irq_status
, data
->irq_status
, data
->current_irq_mask
,
172 * At this point, irq_status has all bits that are set in the
173 * interrupt status register and are enabled.
175 mutex_unlock(&data
->irq_mutex
);
178 * It would be nice to be able to use irq_chip to handle these
179 * nested IRQs. Unfortunately, most of the current customers for
180 * this driver are using older kernels (3.0.x) that don't support
181 * the features required for that. Once they've shifted to more
182 * recent kernels (say, 3.3 and higher), this should be switched to
185 list_for_each_entry(entry
, &data
->function_list
, node
)
186 process_one_interrupt(data
, entry
);
189 input_sync(data
->input
);
194 void rmi_set_attn_data(struct rmi_device
*rmi_dev
, unsigned long irq_status
,
195 void *data
, size_t size
)
197 struct rmi_driver_data
*drvdata
= dev_get_drvdata(&rmi_dev
->dev
);
198 struct rmi4_attn_data attn_data
;
201 if (!drvdata
->enabled
)
204 fifo_data
= kmemdup(data
, size
, GFP_ATOMIC
);
208 attn_data
.irq_status
= irq_status
;
209 attn_data
.size
= size
;
210 attn_data
.data
= fifo_data
;
212 kfifo_put(&drvdata
->attn_fifo
, attn_data
);
214 EXPORT_SYMBOL_GPL(rmi_set_attn_data
);
216 static irqreturn_t
rmi_irq_fn(int irq
, void *dev_id
)
218 struct rmi_device
*rmi_dev
= dev_id
;
219 struct rmi_driver_data
*drvdata
= dev_get_drvdata(&rmi_dev
->dev
);
220 struct rmi4_attn_data attn_data
= {0};
223 count
= kfifo_get(&drvdata
->attn_fifo
, &attn_data
);
225 *(drvdata
->irq_status
) = attn_data
.irq_status
;
226 drvdata
->attn_data
= attn_data
;
229 ret
= rmi_process_interrupt_requests(rmi_dev
);
231 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
,
232 "Failed to process interrupt request: %d\n", ret
);
235 kfree(attn_data
.data
);
237 if (!kfifo_is_empty(&drvdata
->attn_fifo
))
238 return rmi_irq_fn(irq
, dev_id
);
243 static int rmi_irq_init(struct rmi_device
*rmi_dev
)
245 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
246 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
247 int irq_flags
= irq_get_trigger_type(pdata
->irq
);
251 irq_flags
= IRQF_TRIGGER_LOW
;
253 ret
= devm_request_threaded_irq(&rmi_dev
->dev
, pdata
->irq
, NULL
,
254 rmi_irq_fn
, irq_flags
| IRQF_ONESHOT
,
255 dev_name(rmi_dev
->xport
->dev
),
258 dev_err(&rmi_dev
->dev
, "Failed to register interrupt %d\n",
264 data
->enabled
= true;
269 struct rmi_function
*rmi_find_function(struct rmi_device
*rmi_dev
, u8 number
)
271 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
272 struct rmi_function
*entry
;
274 list_for_each_entry(entry
, &data
->function_list
, node
) {
275 if (entry
->fd
.function_number
== number
)
282 static int suspend_one_function(struct rmi_function
*fn
)
284 struct rmi_function_handler
*fh
;
287 if (!fn
|| !fn
->dev
.driver
)
290 fh
= to_rmi_function_handler(fn
->dev
.driver
);
292 retval
= fh
->suspend(fn
);
294 dev_err(&fn
->dev
, "Suspend failed with code %d.\n",
301 static int rmi_suspend_functions(struct rmi_device
*rmi_dev
)
303 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
304 struct rmi_function
*entry
;
307 list_for_each_entry(entry
, &data
->function_list
, node
) {
308 retval
= suspend_one_function(entry
);
316 static int resume_one_function(struct rmi_function
*fn
)
318 struct rmi_function_handler
*fh
;
321 if (!fn
|| !fn
->dev
.driver
)
324 fh
= to_rmi_function_handler(fn
->dev
.driver
);
326 retval
= fh
->resume(fn
);
328 dev_err(&fn
->dev
, "Resume failed with code %d.\n",
335 static int rmi_resume_functions(struct rmi_device
*rmi_dev
)
337 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
338 struct rmi_function
*entry
;
341 list_for_each_entry(entry
, &data
->function_list
, node
) {
342 retval
= resume_one_function(entry
);
350 int rmi_enable_sensor(struct rmi_device
*rmi_dev
)
354 retval
= rmi_driver_process_config_requests(rmi_dev
);
358 return rmi_process_interrupt_requests(rmi_dev
);
362 * rmi_driver_set_input_params - set input device id and other data.
364 * @rmi_dev: Pointer to an RMI device
365 * @input: Pointer to input device
368 static int rmi_driver_set_input_params(struct rmi_device
*rmi_dev
,
369 struct input_dev
*input
)
371 input
->name
= SYNAPTICS_INPUT_DEVICE_NAME
;
372 input
->id
.vendor
= SYNAPTICS_VENDOR_ID
;
373 input
->id
.bustype
= BUS_RMI
;
377 static void rmi_driver_set_input_name(struct rmi_device
*rmi_dev
,
378 struct input_dev
*input
)
380 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
381 const char *device_name
= rmi_f01_get_product_ID(data
->f01_container
);
384 name
= devm_kasprintf(&rmi_dev
->dev
, GFP_KERNEL
,
385 "Synaptics %s", device_name
);
392 static int rmi_driver_set_irq_bits(struct rmi_device
*rmi_dev
,
396 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
397 struct device
*dev
= &rmi_dev
->dev
;
399 mutex_lock(&data
->irq_mutex
);
400 bitmap_or(data
->new_irq_mask
,
401 data
->current_irq_mask
, mask
, data
->irq_count
);
403 error
= rmi_write_block(rmi_dev
,
404 data
->f01_container
->fd
.control_base_addr
+ 1,
405 data
->new_irq_mask
, data
->num_of_irq_regs
);
407 dev_err(dev
, "%s: Failed to change enabled interrupts!",
411 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
412 data
->num_of_irq_regs
);
415 mutex_unlock(&data
->irq_mutex
);
419 static int rmi_driver_clear_irq_bits(struct rmi_device
*rmi_dev
,
423 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
424 struct device
*dev
= &rmi_dev
->dev
;
426 mutex_lock(&data
->irq_mutex
);
427 bitmap_andnot(data
->new_irq_mask
,
428 data
->current_irq_mask
, mask
, data
->irq_count
);
430 error
= rmi_write_block(rmi_dev
,
431 data
->f01_container
->fd
.control_base_addr
+ 1,
432 data
->new_irq_mask
, data
->num_of_irq_regs
);
434 dev_err(dev
, "%s: Failed to change enabled interrupts!",
438 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
439 data
->num_of_irq_regs
);
442 mutex_unlock(&data
->irq_mutex
);
446 static int rmi_driver_reset_handler(struct rmi_device
*rmi_dev
)
448 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
452 * Can get called before the driver is fully ready to deal with
455 if (!data
|| !data
->f01_container
) {
456 dev_warn(&rmi_dev
->dev
,
457 "Not ready to handle reset yet!\n");
461 error
= rmi_read_block(rmi_dev
,
462 data
->f01_container
->fd
.control_base_addr
+ 1,
463 data
->current_irq_mask
, data
->num_of_irq_regs
);
465 dev_err(&rmi_dev
->dev
, "%s: Failed to read current IRQ mask.\n",
470 error
= rmi_driver_process_reset_requests(rmi_dev
);
474 error
= rmi_driver_process_config_requests(rmi_dev
);
481 static int rmi_read_pdt_entry(struct rmi_device
*rmi_dev
,
482 struct pdt_entry
*entry
, u16 pdt_address
)
484 u8 buf
[RMI_PDT_ENTRY_SIZE
];
487 error
= rmi_read_block(rmi_dev
, pdt_address
, buf
, RMI_PDT_ENTRY_SIZE
);
489 dev_err(&rmi_dev
->dev
, "Read PDT entry at %#06x failed, code: %d.\n",
494 entry
->page_start
= pdt_address
& RMI4_PAGE_MASK
;
495 entry
->query_base_addr
= buf
[0];
496 entry
->command_base_addr
= buf
[1];
497 entry
->control_base_addr
= buf
[2];
498 entry
->data_base_addr
= buf
[3];
499 entry
->interrupt_source_count
= buf
[4] & RMI_PDT_INT_SOURCE_COUNT_MASK
;
500 entry
->function_version
= (buf
[4] & RMI_PDT_FUNCTION_VERSION_MASK
) >> 5;
501 entry
->function_number
= buf
[5];
506 static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry
*pdt
,
507 struct rmi_function_descriptor
*fd
)
509 fd
->query_base_addr
= pdt
->query_base_addr
+ pdt
->page_start
;
510 fd
->command_base_addr
= pdt
->command_base_addr
+ pdt
->page_start
;
511 fd
->control_base_addr
= pdt
->control_base_addr
+ pdt
->page_start
;
512 fd
->data_base_addr
= pdt
->data_base_addr
+ pdt
->page_start
;
513 fd
->function_number
= pdt
->function_number
;
514 fd
->interrupt_source_count
= pdt
->interrupt_source_count
;
515 fd
->function_version
= pdt
->function_version
;
518 #define RMI_SCAN_CONTINUE 0
519 #define RMI_SCAN_DONE 1
521 static int rmi_scan_pdt_page(struct rmi_device
*rmi_dev
,
525 int (*callback
)(struct rmi_device
*rmi_dev
,
527 const struct pdt_entry
*entry
))
529 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
530 struct pdt_entry pdt_entry
;
531 u16 page_start
= RMI4_PAGE_SIZE
* page
;
532 u16 pdt_start
= page_start
+ PDT_START_SCAN_LOCATION
;
533 u16 pdt_end
= page_start
+ PDT_END_SCAN_LOCATION
;
538 for (addr
= pdt_start
; addr
>= pdt_end
; addr
-= RMI_PDT_ENTRY_SIZE
) {
539 error
= rmi_read_pdt_entry(rmi_dev
, &pdt_entry
, addr
);
543 if (RMI4_END_OF_PDT(pdt_entry
.function_number
))
546 retval
= callback(rmi_dev
, ctx
, &pdt_entry
);
547 if (retval
!= RMI_SCAN_CONTINUE
)
552 * Count number of empty PDT pages. If a gap of two pages
553 * or more is found, stop scanning.
555 if (addr
== pdt_start
)
560 return (data
->bootloader_mode
|| *empty_pages
>= 2) ?
561 RMI_SCAN_DONE
: RMI_SCAN_CONTINUE
;
564 int rmi_scan_pdt(struct rmi_device
*rmi_dev
, void *ctx
,
565 int (*callback
)(struct rmi_device
*rmi_dev
,
566 void *ctx
, const struct pdt_entry
*entry
))
570 int retval
= RMI_SCAN_DONE
;
572 for (page
= 0; page
<= RMI4_MAX_PAGE
; page
++) {
573 retval
= rmi_scan_pdt_page(rmi_dev
, page
, &empty_pages
,
575 if (retval
!= RMI_SCAN_CONTINUE
)
579 return retval
< 0 ? retval
: 0;
582 int rmi_read_register_desc(struct rmi_device
*d
, u16 addr
,
583 struct rmi_register_descriptor
*rdesc
)
586 u8 size_presence_reg
;
588 int presense_offset
= 1;
597 * The first register of the register descriptor is the size of
598 * the register descriptor's presense register.
600 ret
= rmi_read(d
, addr
, &size_presence_reg
);
605 if (size_presence_reg
< 0 || size_presence_reg
> 35)
608 memset(buf
, 0, sizeof(buf
));
611 * The presence register contains the size of the register structure
612 * and a bitmap which identified which packet registers are present
613 * for this particular register type (ie query, control, or data).
615 ret
= rmi_read_block(d
, addr
, buf
, size_presence_reg
);
622 rdesc
->struct_size
= buf
[1] | (buf
[2] << 8);
624 rdesc
->struct_size
= buf
[0];
627 for (i
= presense_offset
; i
< size_presence_reg
; i
++) {
628 for (b
= 0; b
< 8; b
++) {
629 if (buf
[i
] & (0x1 << b
))
630 bitmap_set(rdesc
->presense_map
, map_offset
, 1);
635 rdesc
->num_registers
= bitmap_weight(rdesc
->presense_map
,
636 RMI_REG_DESC_PRESENSE_BITS
);
638 rdesc
->registers
= devm_kzalloc(&d
->dev
, rdesc
->num_registers
*
639 sizeof(struct rmi_register_desc_item
),
641 if (!rdesc
->registers
)
645 * Allocate a temporary buffer to hold the register structure.
646 * I'm not using devm_kzalloc here since it will not be retained
647 * after exiting this function
649 struct_buf
= kzalloc(rdesc
->struct_size
, GFP_KERNEL
);
654 * The register structure contains information about every packet
655 * register of this type. This includes the size of the packet
656 * register and a bitmap of all subpackets contained in the packet
659 ret
= rmi_read_block(d
, addr
, struct_buf
, rdesc
->struct_size
);
661 goto free_struct_buff
;
663 reg
= find_first_bit(rdesc
->presense_map
, RMI_REG_DESC_PRESENSE_BITS
);
664 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
665 struct rmi_register_desc_item
*item
= &rdesc
->registers
[i
];
666 int reg_size
= struct_buf
[offset
];
670 reg_size
= struct_buf
[offset
] |
671 (struct_buf
[offset
+ 1] << 8);
676 reg_size
= struct_buf
[offset
] |
677 (struct_buf
[offset
+ 1] << 8) |
678 (struct_buf
[offset
+ 2] << 16) |
679 (struct_buf
[offset
+ 3] << 24);
684 item
->reg_size
= reg_size
;
689 for (b
= 0; b
< 7; b
++) {
690 if (struct_buf
[offset
] & (0x1 << b
))
691 bitmap_set(item
->subpacket_map
,
695 } while (struct_buf
[offset
++] & 0x80);
697 item
->num_subpackets
= bitmap_weight(item
->subpacket_map
,
698 RMI_REG_DESC_SUBPACKET_BITS
);
700 rmi_dbg(RMI_DEBUG_CORE
, &d
->dev
,
701 "%s: reg: %d reg size: %ld subpackets: %d\n", __func__
,
702 item
->reg
, item
->reg_size
, item
->num_subpackets
);
704 reg
= find_next_bit(rdesc
->presense_map
,
705 RMI_REG_DESC_PRESENSE_BITS
, reg
+ 1);
713 const struct rmi_register_desc_item
*rmi_get_register_desc_item(
714 struct rmi_register_descriptor
*rdesc
, u16 reg
)
716 const struct rmi_register_desc_item
*item
;
719 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
720 item
= &rdesc
->registers
[i
];
721 if (item
->reg
== reg
)
728 size_t rmi_register_desc_calc_size(struct rmi_register_descriptor
*rdesc
)
730 const struct rmi_register_desc_item
*item
;
734 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
735 item
= &rdesc
->registers
[i
];
736 size
+= item
->reg_size
;
741 /* Compute the register offset relative to the base address */
742 int rmi_register_desc_calc_reg_offset(
743 struct rmi_register_descriptor
*rdesc
, u16 reg
)
745 const struct rmi_register_desc_item
*item
;
749 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
750 item
= &rdesc
->registers
[i
];
751 if (item
->reg
== reg
)
758 bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item
*item
,
761 return find_next_bit(item
->subpacket_map
, RMI_REG_DESC_PRESENSE_BITS
,
762 subpacket
) == subpacket
;
765 static int rmi_check_bootloader_mode(struct rmi_device
*rmi_dev
,
766 const struct pdt_entry
*pdt
)
768 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
772 if (pdt
->function_number
== 0x34 && pdt
->function_version
> 1) {
773 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
775 dev_err(&rmi_dev
->dev
,
776 "Failed to read F34 status: %d.\n", ret
);
781 data
->bootloader_mode
= true;
782 } else if (pdt
->function_number
== 0x01) {
783 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
785 dev_err(&rmi_dev
->dev
,
786 "Failed to read F01 status: %d.\n", ret
);
791 data
->bootloader_mode
= true;
797 static int rmi_count_irqs(struct rmi_device
*rmi_dev
,
798 void *ctx
, const struct pdt_entry
*pdt
)
800 int *irq_count
= ctx
;
803 *irq_count
+= pdt
->interrupt_source_count
;
805 ret
= rmi_check_bootloader_mode(rmi_dev
, pdt
);
809 return RMI_SCAN_CONTINUE
;
812 int rmi_initial_reset(struct rmi_device
*rmi_dev
, void *ctx
,
813 const struct pdt_entry
*pdt
)
817 if (pdt
->function_number
== 0x01) {
818 u16 cmd_addr
= pdt
->page_start
+ pdt
->command_base_addr
;
819 u8 cmd_buf
= RMI_DEVICE_RESET_CMD
;
820 const struct rmi_device_platform_data
*pdata
=
821 rmi_get_platform_data(rmi_dev
);
823 if (rmi_dev
->xport
->ops
->reset
) {
824 error
= rmi_dev
->xport
->ops
->reset(rmi_dev
->xport
,
829 return RMI_SCAN_DONE
;
832 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Sending reset\n");
833 error
= rmi_write_block(rmi_dev
, cmd_addr
, &cmd_buf
, 1);
835 dev_err(&rmi_dev
->dev
,
836 "Initial reset failed. Code = %d.\n", error
);
840 mdelay(pdata
->reset_delay_ms
?: DEFAULT_RESET_DELAY_MS
);
842 return RMI_SCAN_DONE
;
845 /* F01 should always be on page 0. If we don't find it there, fail. */
846 return pdt
->page_start
== 0 ? RMI_SCAN_CONTINUE
: -ENODEV
;
849 static int rmi_create_function(struct rmi_device
*rmi_dev
,
850 void *ctx
, const struct pdt_entry
*pdt
)
852 struct device
*dev
= &rmi_dev
->dev
;
853 struct rmi_driver_data
*data
= dev_get_drvdata(dev
);
854 int *current_irq_count
= ctx
;
855 struct rmi_function
*fn
;
859 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Initializing F%02X.\n",
860 pdt
->function_number
);
862 fn
= kzalloc(sizeof(struct rmi_function
) +
863 BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long),
866 dev_err(dev
, "Failed to allocate memory for F%02X\n",
867 pdt
->function_number
);
871 INIT_LIST_HEAD(&fn
->node
);
872 rmi_driver_copy_pdt_to_fd(pdt
, &fn
->fd
);
874 fn
->rmi_dev
= rmi_dev
;
876 fn
->num_of_irqs
= pdt
->interrupt_source_count
;
877 fn
->irq_pos
= *current_irq_count
;
878 *current_irq_count
+= fn
->num_of_irqs
;
880 for (i
= 0; i
< fn
->num_of_irqs
; i
++)
881 set_bit(fn
->irq_pos
+ i
, fn
->irq_mask
);
883 error
= rmi_register_function(fn
);
887 if (pdt
->function_number
== 0x01)
888 data
->f01_container
= fn
;
889 else if (pdt
->function_number
== 0x34)
890 data
->f34_container
= fn
;
892 list_add_tail(&fn
->node
, &data
->function_list
);
894 return RMI_SCAN_CONTINUE
;
897 put_device(&fn
->dev
);
901 void rmi_enable_irq(struct rmi_device
*rmi_dev
, bool clear_wake
)
903 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
904 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
905 int irq
= pdata
->irq
;
909 mutex_lock(&data
->enabled_mutex
);
915 data
->enabled
= true;
916 if (clear_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
917 retval
= disable_irq_wake(irq
);
919 dev_warn(&rmi_dev
->dev
,
920 "Failed to disable irq for wake: %d\n",
925 * Call rmi_process_interrupt_requests() after enabling irq,
926 * otherwise we may lose interrupt on edge-triggered systems.
928 irq_flags
= irq_get_trigger_type(pdata
->irq
);
929 if (irq_flags
& IRQ_TYPE_EDGE_BOTH
)
930 rmi_process_interrupt_requests(rmi_dev
);
933 mutex_unlock(&data
->enabled_mutex
);
936 void rmi_disable_irq(struct rmi_device
*rmi_dev
, bool enable_wake
)
938 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
939 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
940 struct rmi4_attn_data attn_data
= {0};
941 int irq
= pdata
->irq
;
944 mutex_lock(&data
->enabled_mutex
);
949 data
->enabled
= false;
951 if (enable_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
952 retval
= enable_irq_wake(irq
);
954 dev_warn(&rmi_dev
->dev
,
955 "Failed to enable irq for wake: %d\n",
959 /* make sure the fifo is clean */
960 while (!kfifo_is_empty(&data
->attn_fifo
)) {
961 count
= kfifo_get(&data
->attn_fifo
, &attn_data
);
963 kfree(attn_data
.data
);
967 mutex_unlock(&data
->enabled_mutex
);
970 int rmi_driver_suspend(struct rmi_device
*rmi_dev
, bool enable_wake
)
974 retval
= rmi_suspend_functions(rmi_dev
);
976 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
979 rmi_disable_irq(rmi_dev
, enable_wake
);
982 EXPORT_SYMBOL_GPL(rmi_driver_suspend
);
984 int rmi_driver_resume(struct rmi_device
*rmi_dev
, bool clear_wake
)
988 rmi_enable_irq(rmi_dev
, clear_wake
);
990 retval
= rmi_resume_functions(rmi_dev
);
992 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
997 EXPORT_SYMBOL_GPL(rmi_driver_resume
);
999 static int rmi_driver_remove(struct device
*dev
)
1001 struct rmi_device
*rmi_dev
= to_rmi_device(dev
);
1003 rmi_disable_irq(rmi_dev
, false);
1005 rmi_f34_remove_sysfs(rmi_dev
);
1006 rmi_free_function_list(rmi_dev
);
1012 static int rmi_driver_of_probe(struct device
*dev
,
1013 struct rmi_device_platform_data
*pdata
)
1017 retval
= rmi_of_property_read_u32(dev
, &pdata
->reset_delay_ms
,
1018 "syna,reset-delay-ms", 1);
1025 static inline int rmi_driver_of_probe(struct device
*dev
,
1026 struct rmi_device_platform_data
*pdata
)
1032 int rmi_probe_interrupts(struct rmi_driver_data
*data
)
1034 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1035 struct device
*dev
= &rmi_dev
->dev
;
1041 * We need to count the IRQs and allocate their storage before scanning
1042 * the PDT and creating the function entries, because adding a new
1043 * function can trigger events that result in the IRQ related storage
1046 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Counting IRQs.\n", __func__
);
1048 data
->bootloader_mode
= false;
1050 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_count_irqs
);
1052 dev_err(dev
, "IRQ counting failed with code %d.\n", retval
);
1056 if (data
->bootloader_mode
)
1057 dev_warn(dev
, "Device in bootloader mode.\n");
1059 data
->irq_count
= irq_count
;
1060 data
->num_of_irq_regs
= (data
->irq_count
+ 7) / 8;
1062 size
= BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long);
1063 data
->irq_memory
= devm_kzalloc(dev
, size
* 4, GFP_KERNEL
);
1064 if (!data
->irq_memory
) {
1065 dev_err(dev
, "Failed to allocate memory for irq masks.\n");
1069 data
->irq_status
= data
->irq_memory
+ size
* 0;
1070 data
->fn_irq_bits
= data
->irq_memory
+ size
* 1;
1071 data
->current_irq_mask
= data
->irq_memory
+ size
* 2;
1072 data
->new_irq_mask
= data
->irq_memory
+ size
* 3;
1077 int rmi_init_functions(struct rmi_driver_data
*data
)
1079 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1080 struct device
*dev
= &rmi_dev
->dev
;
1085 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Creating functions.\n", __func__
);
1086 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_create_function
);
1088 dev_err(dev
, "Function creation failed with code %d.\n",
1090 goto err_destroy_functions
;
1093 if (!data
->f01_container
) {
1094 dev_err(dev
, "Missing F01 container!\n");
1096 goto err_destroy_functions
;
1099 retval
= rmi_read_block(rmi_dev
,
1100 data
->f01_container
->fd
.control_base_addr
+ 1,
1101 data
->current_irq_mask
, data
->num_of_irq_regs
);
1103 dev_err(dev
, "%s: Failed to read current IRQ mask.\n",
1105 goto err_destroy_functions
;
1110 err_destroy_functions
:
1111 rmi_free_function_list(rmi_dev
);
1115 static int rmi_driver_probe(struct device
*dev
)
1117 struct rmi_driver
*rmi_driver
;
1118 struct rmi_driver_data
*data
;
1119 struct rmi_device_platform_data
*pdata
;
1120 struct rmi_device
*rmi_dev
;
1123 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Starting probe.\n",
1126 if (!rmi_is_physical_device(dev
)) {
1127 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Not a physical device.\n");
1131 rmi_dev
= to_rmi_device(dev
);
1132 rmi_driver
= to_rmi_driver(dev
->driver
);
1133 rmi_dev
->driver
= rmi_driver
;
1135 pdata
= rmi_get_platform_data(rmi_dev
);
1137 if (rmi_dev
->xport
->dev
->of_node
) {
1138 retval
= rmi_driver_of_probe(rmi_dev
->xport
->dev
, pdata
);
1143 data
= devm_kzalloc(dev
, sizeof(struct rmi_driver_data
), GFP_KERNEL
);
1147 INIT_LIST_HEAD(&data
->function_list
);
1148 data
->rmi_dev
= rmi_dev
;
1149 dev_set_drvdata(&rmi_dev
->dev
, data
);
1152 * Right before a warm boot, the sensor might be in some unusual state,
1153 * such as F54 diagnostics, or F34 bootloader mode after a firmware
1154 * or configuration update. In order to clear the sensor to a known
1155 * state and/or apply any updates, we issue a initial reset to clear any
1156 * previous settings and force it into normal operation.
1158 * We have to do this before actually building the PDT because
1159 * the reflash updates (if any) might cause various registers to move
1162 * For a number of reasons, this initial reset may fail to return
1163 * within the specified time, but we'll still be able to bring up the
1164 * driver normally after that failure. This occurs most commonly in
1165 * a cold boot situation (where then firmware takes longer to come up
1166 * than from a warm boot) and the reset_delay_ms in the platform data
1167 * has been set too short to accommodate that. Since the sensor will
1168 * eventually come up and be usable, we don't want to just fail here
1169 * and leave the customer's device unusable. So we warn them, and
1170 * continue processing.
1172 retval
= rmi_scan_pdt(rmi_dev
, NULL
, rmi_initial_reset
);
1174 dev_warn(dev
, "RMI initial reset failed! Continuing in spite of this.\n");
1176 retval
= rmi_read(rmi_dev
, PDT_PROPERTIES_LOCATION
, &data
->pdt_props
);
1179 * we'll print out a warning and continue since
1180 * failure to get the PDT properties is not a cause to fail
1182 dev_warn(dev
, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n",
1183 PDT_PROPERTIES_LOCATION
, retval
);
1186 mutex_init(&data
->irq_mutex
);
1187 mutex_init(&data
->enabled_mutex
);
1189 retval
= rmi_probe_interrupts(data
);
1193 if (rmi_dev
->xport
->input
) {
1195 * The transport driver already has an input device.
1196 * In some cases it is preferable to reuse the transport
1197 * devices input device instead of creating a new one here.
1198 * One example is some HID touchpads report "pass-through"
1199 * button events are not reported by rmi registers.
1201 data
->input
= rmi_dev
->xport
->input
;
1203 data
->input
= devm_input_allocate_device(dev
);
1205 dev_err(dev
, "%s: Failed to allocate input device.\n",
1210 rmi_driver_set_input_params(rmi_dev
, data
->input
);
1211 data
->input
->phys
= devm_kasprintf(dev
, GFP_KERNEL
,
1212 "%s/input0", dev_name(dev
));
1215 retval
= rmi_init_functions(data
);
1219 retval
= rmi_f34_create_sysfs(rmi_dev
);
1224 rmi_driver_set_input_name(rmi_dev
, data
->input
);
1225 if (!rmi_dev
->xport
->input
) {
1226 if (input_register_device(data
->input
)) {
1227 dev_err(dev
, "%s: Failed to register input device.\n",
1229 goto err_destroy_functions
;
1234 retval
= rmi_irq_init(rmi_dev
);
1236 goto err_destroy_functions
;
1238 if (data
->f01_container
->dev
.driver
)
1239 /* Driver already bound, so enable ATTN now. */
1240 return rmi_enable_sensor(rmi_dev
);
1244 err_destroy_functions
:
1245 rmi_free_function_list(rmi_dev
);
1247 return retval
< 0 ? retval
: 0;
1250 static struct rmi_driver rmi_physical_driver
= {
1252 .owner
= THIS_MODULE
,
1253 .name
= "rmi4_physical",
1254 .bus
= &rmi_bus_type
,
1255 .probe
= rmi_driver_probe
,
1256 .remove
= rmi_driver_remove
,
1258 .reset_handler
= rmi_driver_reset_handler
,
1259 .clear_irq_bits
= rmi_driver_clear_irq_bits
,
1260 .set_irq_bits
= rmi_driver_set_irq_bits
,
1261 .set_input_params
= rmi_driver_set_input_params
,
1264 bool rmi_is_physical_driver(struct device_driver
*drv
)
1266 return drv
== &rmi_physical_driver
.driver
;
1269 int __init
rmi_register_physical_driver(void)
1273 error
= driver_register(&rmi_physical_driver
.driver
);
1275 pr_err("%s: driver register failed, code=%d.\n", __func__
,
1283 void __exit
rmi_unregister_physical_driver(void)
1285 driver_unregister(&rmi_physical_driver
.driver
);