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 struct rmi_function
*rmi_find_function(struct rmi_device
*rmi_dev
, u8 number
)
270 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
271 struct rmi_function
*entry
;
273 list_for_each_entry(entry
, &data
->function_list
, node
) {
274 if (entry
->fd
.function_number
== number
)
281 static int suspend_one_function(struct rmi_function
*fn
)
283 struct rmi_function_handler
*fh
;
286 if (!fn
|| !fn
->dev
.driver
)
289 fh
= to_rmi_function_handler(fn
->dev
.driver
);
291 retval
= fh
->suspend(fn
);
293 dev_err(&fn
->dev
, "Suspend failed with code %d.\n",
300 static int rmi_suspend_functions(struct rmi_device
*rmi_dev
)
302 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
303 struct rmi_function
*entry
;
306 list_for_each_entry(entry
, &data
->function_list
, node
) {
307 retval
= suspend_one_function(entry
);
315 static int resume_one_function(struct rmi_function
*fn
)
317 struct rmi_function_handler
*fh
;
320 if (!fn
|| !fn
->dev
.driver
)
323 fh
= to_rmi_function_handler(fn
->dev
.driver
);
325 retval
= fh
->resume(fn
);
327 dev_err(&fn
->dev
, "Resume failed with code %d.\n",
334 static int rmi_resume_functions(struct rmi_device
*rmi_dev
)
336 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
337 struct rmi_function
*entry
;
340 list_for_each_entry(entry
, &data
->function_list
, node
) {
341 retval
= resume_one_function(entry
);
349 int rmi_enable_sensor(struct rmi_device
*rmi_dev
)
353 retval
= rmi_driver_process_config_requests(rmi_dev
);
357 return rmi_process_interrupt_requests(rmi_dev
);
361 * rmi_driver_set_input_params - set input device id and other data.
363 * @rmi_dev: Pointer to an RMI device
364 * @input: Pointer to input device
367 static int rmi_driver_set_input_params(struct rmi_device
*rmi_dev
,
368 struct input_dev
*input
)
370 input
->name
= SYNAPTICS_INPUT_DEVICE_NAME
;
371 input
->id
.vendor
= SYNAPTICS_VENDOR_ID
;
372 input
->id
.bustype
= BUS_RMI
;
376 static void rmi_driver_set_input_name(struct rmi_device
*rmi_dev
,
377 struct input_dev
*input
)
379 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
380 const char *device_name
= rmi_f01_get_product_ID(data
->f01_container
);
383 name
= devm_kasprintf(&rmi_dev
->dev
, GFP_KERNEL
,
384 "Synaptics %s", device_name
);
391 static int rmi_driver_set_irq_bits(struct rmi_device
*rmi_dev
,
395 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
396 struct device
*dev
= &rmi_dev
->dev
;
398 mutex_lock(&data
->irq_mutex
);
399 bitmap_or(data
->new_irq_mask
,
400 data
->current_irq_mask
, mask
, data
->irq_count
);
402 error
= rmi_write_block(rmi_dev
,
403 data
->f01_container
->fd
.control_base_addr
+ 1,
404 data
->new_irq_mask
, data
->num_of_irq_regs
);
406 dev_err(dev
, "%s: Failed to change enabled interrupts!",
410 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
411 data
->num_of_irq_regs
);
414 mutex_unlock(&data
->irq_mutex
);
418 static int rmi_driver_clear_irq_bits(struct rmi_device
*rmi_dev
,
422 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
423 struct device
*dev
= &rmi_dev
->dev
;
425 mutex_lock(&data
->irq_mutex
);
426 bitmap_andnot(data
->new_irq_mask
,
427 data
->current_irq_mask
, mask
, data
->irq_count
);
429 error
= rmi_write_block(rmi_dev
,
430 data
->f01_container
->fd
.control_base_addr
+ 1,
431 data
->new_irq_mask
, data
->num_of_irq_regs
);
433 dev_err(dev
, "%s: Failed to change enabled interrupts!",
437 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
438 data
->num_of_irq_regs
);
441 mutex_unlock(&data
->irq_mutex
);
445 static int rmi_driver_reset_handler(struct rmi_device
*rmi_dev
)
447 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
451 * Can get called before the driver is fully ready to deal with
454 if (!data
|| !data
->f01_container
) {
455 dev_warn(&rmi_dev
->dev
,
456 "Not ready to handle reset yet!\n");
460 error
= rmi_read_block(rmi_dev
,
461 data
->f01_container
->fd
.control_base_addr
+ 1,
462 data
->current_irq_mask
, data
->num_of_irq_regs
);
464 dev_err(&rmi_dev
->dev
, "%s: Failed to read current IRQ mask.\n",
469 error
= rmi_driver_process_reset_requests(rmi_dev
);
473 error
= rmi_driver_process_config_requests(rmi_dev
);
480 static int rmi_read_pdt_entry(struct rmi_device
*rmi_dev
,
481 struct pdt_entry
*entry
, u16 pdt_address
)
483 u8 buf
[RMI_PDT_ENTRY_SIZE
];
486 error
= rmi_read_block(rmi_dev
, pdt_address
, buf
, RMI_PDT_ENTRY_SIZE
);
488 dev_err(&rmi_dev
->dev
, "Read PDT entry at %#06x failed, code: %d.\n",
493 entry
->page_start
= pdt_address
& RMI4_PAGE_MASK
;
494 entry
->query_base_addr
= buf
[0];
495 entry
->command_base_addr
= buf
[1];
496 entry
->control_base_addr
= buf
[2];
497 entry
->data_base_addr
= buf
[3];
498 entry
->interrupt_source_count
= buf
[4] & RMI_PDT_INT_SOURCE_COUNT_MASK
;
499 entry
->function_version
= (buf
[4] & RMI_PDT_FUNCTION_VERSION_MASK
) >> 5;
500 entry
->function_number
= buf
[5];
505 static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry
*pdt
,
506 struct rmi_function_descriptor
*fd
)
508 fd
->query_base_addr
= pdt
->query_base_addr
+ pdt
->page_start
;
509 fd
->command_base_addr
= pdt
->command_base_addr
+ pdt
->page_start
;
510 fd
->control_base_addr
= pdt
->control_base_addr
+ pdt
->page_start
;
511 fd
->data_base_addr
= pdt
->data_base_addr
+ pdt
->page_start
;
512 fd
->function_number
= pdt
->function_number
;
513 fd
->interrupt_source_count
= pdt
->interrupt_source_count
;
514 fd
->function_version
= pdt
->function_version
;
517 #define RMI_SCAN_CONTINUE 0
518 #define RMI_SCAN_DONE 1
520 static int rmi_scan_pdt_page(struct rmi_device
*rmi_dev
,
524 int (*callback
)(struct rmi_device
*rmi_dev
,
526 const struct pdt_entry
*entry
))
528 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
529 struct pdt_entry pdt_entry
;
530 u16 page_start
= RMI4_PAGE_SIZE
* page
;
531 u16 pdt_start
= page_start
+ PDT_START_SCAN_LOCATION
;
532 u16 pdt_end
= page_start
+ PDT_END_SCAN_LOCATION
;
537 for (addr
= pdt_start
; addr
>= pdt_end
; addr
-= RMI_PDT_ENTRY_SIZE
) {
538 error
= rmi_read_pdt_entry(rmi_dev
, &pdt_entry
, addr
);
542 if (RMI4_END_OF_PDT(pdt_entry
.function_number
))
545 retval
= callback(rmi_dev
, ctx
, &pdt_entry
);
546 if (retval
!= RMI_SCAN_CONTINUE
)
551 * Count number of empty PDT pages. If a gap of two pages
552 * or more is found, stop scanning.
554 if (addr
== pdt_start
)
559 return (data
->bootloader_mode
|| *empty_pages
>= 2) ?
560 RMI_SCAN_DONE
: RMI_SCAN_CONTINUE
;
563 int rmi_scan_pdt(struct rmi_device
*rmi_dev
, void *ctx
,
564 int (*callback
)(struct rmi_device
*rmi_dev
,
565 void *ctx
, const struct pdt_entry
*entry
))
569 int retval
= RMI_SCAN_DONE
;
571 for (page
= 0; page
<= RMI4_MAX_PAGE
; page
++) {
572 retval
= rmi_scan_pdt_page(rmi_dev
, page
, &empty_pages
,
574 if (retval
!= RMI_SCAN_CONTINUE
)
578 return retval
< 0 ? retval
: 0;
581 int rmi_read_register_desc(struct rmi_device
*d
, u16 addr
,
582 struct rmi_register_descriptor
*rdesc
)
585 u8 size_presence_reg
;
587 int presense_offset
= 1;
596 * The first register of the register descriptor is the size of
597 * the register descriptor's presense register.
599 ret
= rmi_read(d
, addr
, &size_presence_reg
);
604 if (size_presence_reg
< 0 || size_presence_reg
> 35)
607 memset(buf
, 0, sizeof(buf
));
610 * The presence register contains the size of the register structure
611 * and a bitmap which identified which packet registers are present
612 * for this particular register type (ie query, control, or data).
614 ret
= rmi_read_block(d
, addr
, buf
, size_presence_reg
);
621 rdesc
->struct_size
= buf
[1] | (buf
[2] << 8);
623 rdesc
->struct_size
= buf
[0];
626 for (i
= presense_offset
; i
< size_presence_reg
; i
++) {
627 for (b
= 0; b
< 8; b
++) {
628 if (buf
[i
] & (0x1 << b
))
629 bitmap_set(rdesc
->presense_map
, map_offset
, 1);
634 rdesc
->num_registers
= bitmap_weight(rdesc
->presense_map
,
635 RMI_REG_DESC_PRESENSE_BITS
);
637 rdesc
->registers
= devm_kzalloc(&d
->dev
, rdesc
->num_registers
*
638 sizeof(struct rmi_register_desc_item
),
640 if (!rdesc
->registers
)
644 * Allocate a temporary buffer to hold the register structure.
645 * I'm not using devm_kzalloc here since it will not be retained
646 * after exiting this function
648 struct_buf
= kzalloc(rdesc
->struct_size
, GFP_KERNEL
);
653 * The register structure contains information about every packet
654 * register of this type. This includes the size of the packet
655 * register and a bitmap of all subpackets contained in the packet
658 ret
= rmi_read_block(d
, addr
, struct_buf
, rdesc
->struct_size
);
660 goto free_struct_buff
;
662 reg
= find_first_bit(rdesc
->presense_map
, RMI_REG_DESC_PRESENSE_BITS
);
663 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
664 struct rmi_register_desc_item
*item
= &rdesc
->registers
[i
];
665 int reg_size
= struct_buf
[offset
];
669 reg_size
= struct_buf
[offset
] |
670 (struct_buf
[offset
+ 1] << 8);
675 reg_size
= struct_buf
[offset
] |
676 (struct_buf
[offset
+ 1] << 8) |
677 (struct_buf
[offset
+ 2] << 16) |
678 (struct_buf
[offset
+ 3] << 24);
683 item
->reg_size
= reg_size
;
688 for (b
= 0; b
< 7; b
++) {
689 if (struct_buf
[offset
] & (0x1 << b
))
690 bitmap_set(item
->subpacket_map
,
694 } while (struct_buf
[offset
++] & 0x80);
696 item
->num_subpackets
= bitmap_weight(item
->subpacket_map
,
697 RMI_REG_DESC_SUBPACKET_BITS
);
699 rmi_dbg(RMI_DEBUG_CORE
, &d
->dev
,
700 "%s: reg: %d reg size: %ld subpackets: %d\n", __func__
,
701 item
->reg
, item
->reg_size
, item
->num_subpackets
);
703 reg
= find_next_bit(rdesc
->presense_map
,
704 RMI_REG_DESC_PRESENSE_BITS
, reg
+ 1);
712 const struct rmi_register_desc_item
*rmi_get_register_desc_item(
713 struct rmi_register_descriptor
*rdesc
, u16 reg
)
715 const struct rmi_register_desc_item
*item
;
718 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
719 item
= &rdesc
->registers
[i
];
720 if (item
->reg
== reg
)
727 size_t rmi_register_desc_calc_size(struct rmi_register_descriptor
*rdesc
)
729 const struct rmi_register_desc_item
*item
;
733 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
734 item
= &rdesc
->registers
[i
];
735 size
+= item
->reg_size
;
740 /* Compute the register offset relative to the base address */
741 int rmi_register_desc_calc_reg_offset(
742 struct rmi_register_descriptor
*rdesc
, u16 reg
)
744 const struct rmi_register_desc_item
*item
;
748 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
749 item
= &rdesc
->registers
[i
];
750 if (item
->reg
== reg
)
757 bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item
*item
,
760 return find_next_bit(item
->subpacket_map
, RMI_REG_DESC_PRESENSE_BITS
,
761 subpacket
) == subpacket
;
764 static int rmi_check_bootloader_mode(struct rmi_device
*rmi_dev
,
765 const struct pdt_entry
*pdt
)
767 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
771 if (pdt
->function_number
== 0x34 && pdt
->function_version
> 1) {
772 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
774 dev_err(&rmi_dev
->dev
,
775 "Failed to read F34 status: %d.\n", ret
);
780 data
->bootloader_mode
= true;
781 } else if (pdt
->function_number
== 0x01) {
782 ret
= rmi_read(rmi_dev
, pdt
->data_base_addr
, &status
);
784 dev_err(&rmi_dev
->dev
,
785 "Failed to read F01 status: %d.\n", ret
);
790 data
->bootloader_mode
= true;
796 static int rmi_count_irqs(struct rmi_device
*rmi_dev
,
797 void *ctx
, const struct pdt_entry
*pdt
)
799 int *irq_count
= ctx
;
802 *irq_count
+= pdt
->interrupt_source_count
;
804 ret
= rmi_check_bootloader_mode(rmi_dev
, pdt
);
808 return RMI_SCAN_CONTINUE
;
811 int rmi_initial_reset(struct rmi_device
*rmi_dev
, void *ctx
,
812 const struct pdt_entry
*pdt
)
816 if (pdt
->function_number
== 0x01) {
817 u16 cmd_addr
= pdt
->page_start
+ pdt
->command_base_addr
;
818 u8 cmd_buf
= RMI_DEVICE_RESET_CMD
;
819 const struct rmi_device_platform_data
*pdata
=
820 rmi_get_platform_data(rmi_dev
);
822 if (rmi_dev
->xport
->ops
->reset
) {
823 error
= rmi_dev
->xport
->ops
->reset(rmi_dev
->xport
,
828 return RMI_SCAN_DONE
;
831 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Sending reset\n");
832 error
= rmi_write_block(rmi_dev
, cmd_addr
, &cmd_buf
, 1);
834 dev_err(&rmi_dev
->dev
,
835 "Initial reset failed. Code = %d.\n", error
);
839 mdelay(pdata
->reset_delay_ms
?: DEFAULT_RESET_DELAY_MS
);
841 return RMI_SCAN_DONE
;
844 /* F01 should always be on page 0. If we don't find it there, fail. */
845 return pdt
->page_start
== 0 ? RMI_SCAN_CONTINUE
: -ENODEV
;
848 static int rmi_create_function(struct rmi_device
*rmi_dev
,
849 void *ctx
, const struct pdt_entry
*pdt
)
851 struct device
*dev
= &rmi_dev
->dev
;
852 struct rmi_driver_data
*data
= dev_get_drvdata(dev
);
853 int *current_irq_count
= ctx
;
854 struct rmi_function
*fn
;
858 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Initializing F%02X.\n",
859 pdt
->function_number
);
861 fn
= kzalloc(sizeof(struct rmi_function
) +
862 BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long),
865 dev_err(dev
, "Failed to allocate memory for F%02X\n",
866 pdt
->function_number
);
870 INIT_LIST_HEAD(&fn
->node
);
871 rmi_driver_copy_pdt_to_fd(pdt
, &fn
->fd
);
873 fn
->rmi_dev
= rmi_dev
;
875 fn
->num_of_irqs
= pdt
->interrupt_source_count
;
876 fn
->irq_pos
= *current_irq_count
;
877 *current_irq_count
+= fn
->num_of_irqs
;
879 for (i
= 0; i
< fn
->num_of_irqs
; i
++)
880 set_bit(fn
->irq_pos
+ i
, fn
->irq_mask
);
882 error
= rmi_register_function(fn
);
886 if (pdt
->function_number
== 0x01)
887 data
->f01_container
= fn
;
888 else if (pdt
->function_number
== 0x34)
889 data
->f34_container
= fn
;
891 list_add_tail(&fn
->node
, &data
->function_list
);
893 return RMI_SCAN_CONTINUE
;
896 put_device(&fn
->dev
);
900 void rmi_enable_irq(struct rmi_device
*rmi_dev
, bool clear_wake
)
902 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
903 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
904 int irq
= pdata
->irq
;
908 mutex_lock(&data
->enabled_mutex
);
914 data
->enabled
= true;
915 if (clear_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
916 retval
= disable_irq_wake(irq
);
918 dev_warn(&rmi_dev
->dev
,
919 "Failed to disable irq for wake: %d\n",
924 * Call rmi_process_interrupt_requests() after enabling irq,
925 * otherwise we may lose interrupt on edge-triggered systems.
927 irq_flags
= irq_get_trigger_type(pdata
->irq
);
928 if (irq_flags
& IRQ_TYPE_EDGE_BOTH
)
929 rmi_process_interrupt_requests(rmi_dev
);
932 mutex_unlock(&data
->enabled_mutex
);
935 void rmi_disable_irq(struct rmi_device
*rmi_dev
, bool enable_wake
)
937 struct rmi_device_platform_data
*pdata
= rmi_get_platform_data(rmi_dev
);
938 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
939 struct rmi4_attn_data attn_data
= {0};
940 int irq
= pdata
->irq
;
943 mutex_lock(&data
->enabled_mutex
);
948 data
->enabled
= false;
950 if (enable_wake
&& device_may_wakeup(rmi_dev
->xport
->dev
)) {
951 retval
= enable_irq_wake(irq
);
953 dev_warn(&rmi_dev
->dev
,
954 "Failed to enable irq for wake: %d\n",
958 /* make sure the fifo is clean */
959 while (!kfifo_is_empty(&data
->attn_fifo
)) {
960 count
= kfifo_get(&data
->attn_fifo
, &attn_data
);
962 kfree(attn_data
.data
);
966 mutex_unlock(&data
->enabled_mutex
);
969 int rmi_driver_suspend(struct rmi_device
*rmi_dev
, bool enable_wake
)
973 retval
= rmi_suspend_functions(rmi_dev
);
975 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
978 rmi_disable_irq(rmi_dev
, enable_wake
);
981 EXPORT_SYMBOL_GPL(rmi_driver_suspend
);
983 int rmi_driver_resume(struct rmi_device
*rmi_dev
, bool clear_wake
)
987 rmi_enable_irq(rmi_dev
, clear_wake
);
989 retval
= rmi_resume_functions(rmi_dev
);
991 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
996 EXPORT_SYMBOL_GPL(rmi_driver_resume
);
998 static int rmi_driver_remove(struct device
*dev
)
1000 struct rmi_device
*rmi_dev
= to_rmi_device(dev
);
1002 rmi_disable_irq(rmi_dev
, false);
1004 rmi_f34_remove_sysfs(rmi_dev
);
1005 rmi_free_function_list(rmi_dev
);
1011 static int rmi_driver_of_probe(struct device
*dev
,
1012 struct rmi_device_platform_data
*pdata
)
1016 retval
= rmi_of_property_read_u32(dev
, &pdata
->reset_delay_ms
,
1017 "syna,reset-delay-ms", 1);
1024 static inline int rmi_driver_of_probe(struct device
*dev
,
1025 struct rmi_device_platform_data
*pdata
)
1031 int rmi_probe_interrupts(struct rmi_driver_data
*data
)
1033 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1034 struct device
*dev
= &rmi_dev
->dev
;
1040 * We need to count the IRQs and allocate their storage before scanning
1041 * the PDT and creating the function entries, because adding a new
1042 * function can trigger events that result in the IRQ related storage
1045 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Counting IRQs.\n", __func__
);
1047 data
->bootloader_mode
= false;
1049 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_count_irqs
);
1051 dev_err(dev
, "IRQ counting failed with code %d.\n", retval
);
1055 if (data
->bootloader_mode
)
1056 dev_warn(dev
, "Device in bootloader mode.\n");
1058 data
->irq_count
= irq_count
;
1059 data
->num_of_irq_regs
= (data
->irq_count
+ 7) / 8;
1061 size
= BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long);
1062 data
->irq_memory
= devm_kzalloc(dev
, size
* 4, GFP_KERNEL
);
1063 if (!data
->irq_memory
) {
1064 dev_err(dev
, "Failed to allocate memory for irq masks.\n");
1068 data
->irq_status
= data
->irq_memory
+ size
* 0;
1069 data
->fn_irq_bits
= data
->irq_memory
+ size
* 1;
1070 data
->current_irq_mask
= data
->irq_memory
+ size
* 2;
1071 data
->new_irq_mask
= data
->irq_memory
+ size
* 3;
1076 int rmi_init_functions(struct rmi_driver_data
*data
)
1078 struct rmi_device
*rmi_dev
= data
->rmi_dev
;
1079 struct device
*dev
= &rmi_dev
->dev
;
1084 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Creating functions.\n", __func__
);
1085 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_create_function
);
1087 dev_err(dev
, "Function creation failed with code %d.\n",
1089 goto err_destroy_functions
;
1092 if (!data
->f01_container
) {
1093 dev_err(dev
, "Missing F01 container!\n");
1095 goto err_destroy_functions
;
1098 retval
= rmi_read_block(rmi_dev
,
1099 data
->f01_container
->fd
.control_base_addr
+ 1,
1100 data
->current_irq_mask
, data
->num_of_irq_regs
);
1102 dev_err(dev
, "%s: Failed to read current IRQ mask.\n",
1104 goto err_destroy_functions
;
1109 err_destroy_functions
:
1110 rmi_free_function_list(rmi_dev
);
1114 static int rmi_driver_probe(struct device
*dev
)
1116 struct rmi_driver
*rmi_driver
;
1117 struct rmi_driver_data
*data
;
1118 struct rmi_device_platform_data
*pdata
;
1119 struct rmi_device
*rmi_dev
;
1122 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Starting probe.\n",
1125 if (!rmi_is_physical_device(dev
)) {
1126 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Not a physical device.\n");
1130 rmi_dev
= to_rmi_device(dev
);
1131 rmi_driver
= to_rmi_driver(dev
->driver
);
1132 rmi_dev
->driver
= rmi_driver
;
1134 pdata
= rmi_get_platform_data(rmi_dev
);
1136 if (rmi_dev
->xport
->dev
->of_node
) {
1137 retval
= rmi_driver_of_probe(rmi_dev
->xport
->dev
, pdata
);
1142 data
= devm_kzalloc(dev
, sizeof(struct rmi_driver_data
), GFP_KERNEL
);
1146 INIT_LIST_HEAD(&data
->function_list
);
1147 data
->rmi_dev
= rmi_dev
;
1148 dev_set_drvdata(&rmi_dev
->dev
, data
);
1151 * Right before a warm boot, the sensor might be in some unusual state,
1152 * such as F54 diagnostics, or F34 bootloader mode after a firmware
1153 * or configuration update. In order to clear the sensor to a known
1154 * state and/or apply any updates, we issue a initial reset to clear any
1155 * previous settings and force it into normal operation.
1157 * We have to do this before actually building the PDT because
1158 * the reflash updates (if any) might cause various registers to move
1161 * For a number of reasons, this initial reset may fail to return
1162 * within the specified time, but we'll still be able to bring up the
1163 * driver normally after that failure. This occurs most commonly in
1164 * a cold boot situation (where then firmware takes longer to come up
1165 * than from a warm boot) and the reset_delay_ms in the platform data
1166 * has been set too short to accommodate that. Since the sensor will
1167 * eventually come up and be usable, we don't want to just fail here
1168 * and leave the customer's device unusable. So we warn them, and
1169 * continue processing.
1171 retval
= rmi_scan_pdt(rmi_dev
, NULL
, rmi_initial_reset
);
1173 dev_warn(dev
, "RMI initial reset failed! Continuing in spite of this.\n");
1175 retval
= rmi_read(rmi_dev
, PDT_PROPERTIES_LOCATION
, &data
->pdt_props
);
1178 * we'll print out a warning and continue since
1179 * failure to get the PDT properties is not a cause to fail
1181 dev_warn(dev
, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n",
1182 PDT_PROPERTIES_LOCATION
, retval
);
1185 mutex_init(&data
->irq_mutex
);
1186 mutex_init(&data
->enabled_mutex
);
1188 retval
= rmi_probe_interrupts(data
);
1192 if (rmi_dev
->xport
->input
) {
1194 * The transport driver already has an input device.
1195 * In some cases it is preferable to reuse the transport
1196 * devices input device instead of creating a new one here.
1197 * One example is some HID touchpads report "pass-through"
1198 * button events are not reported by rmi registers.
1200 data
->input
= rmi_dev
->xport
->input
;
1202 data
->input
= devm_input_allocate_device(dev
);
1204 dev_err(dev
, "%s: Failed to allocate input device.\n",
1209 rmi_driver_set_input_params(rmi_dev
, data
->input
);
1210 data
->input
->phys
= devm_kasprintf(dev
, GFP_KERNEL
,
1211 "%s/input0", dev_name(dev
));
1214 retval
= rmi_init_functions(data
);
1218 retval
= rmi_f34_create_sysfs(rmi_dev
);
1223 rmi_driver_set_input_name(rmi_dev
, data
->input
);
1224 if (!rmi_dev
->xport
->input
) {
1225 if (input_register_device(data
->input
)) {
1226 dev_err(dev
, "%s: Failed to register input device.\n",
1228 goto err_destroy_functions
;
1233 retval
= rmi_irq_init(rmi_dev
);
1235 goto err_destroy_functions
;
1237 if (data
->f01_container
->dev
.driver
)
1238 /* Driver already bound, so enable ATTN now. */
1239 return rmi_enable_sensor(rmi_dev
);
1243 err_destroy_functions
:
1244 rmi_free_function_list(rmi_dev
);
1246 return retval
< 0 ? retval
: 0;
1249 static struct rmi_driver rmi_physical_driver
= {
1251 .owner
= THIS_MODULE
,
1252 .name
= "rmi4_physical",
1253 .bus
= &rmi_bus_type
,
1254 .probe
= rmi_driver_probe
,
1255 .remove
= rmi_driver_remove
,
1257 .reset_handler
= rmi_driver_reset_handler
,
1258 .clear_irq_bits
= rmi_driver_clear_irq_bits
,
1259 .set_irq_bits
= rmi_driver_set_irq_bits
,
1260 .set_input_params
= rmi_driver_set_input_params
,
1263 bool rmi_is_physical_driver(struct device_driver
*drv
)
1265 return drv
== &rmi_physical_driver
.driver
;
1268 int __init
rmi_register_physical_driver(void)
1272 error
= driver_register(&rmi_physical_driver
.driver
);
1274 pr_err("%s: driver register failed, code=%d.\n", __func__
,
1282 void __exit
rmi_unregister_physical_driver(void)
1284 driver_unregister(&rmi_physical_driver
.driver
);