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/kconfig.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 static 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 data
->f01_container
= NULL
;
44 /* Doing it in the reverse order so F01 will be removed last */
45 list_for_each_entry_safe_reverse(fn
, tmp
,
46 &data
->function_list
, node
) {
48 rmi_unregister_function(fn
);
52 static int reset_one_function(struct rmi_function
*fn
)
54 struct rmi_function_handler
*fh
;
57 if (!fn
|| !fn
->dev
.driver
)
60 fh
= to_rmi_function_handler(fn
->dev
.driver
);
62 retval
= fh
->reset(fn
);
64 dev_err(&fn
->dev
, "Reset failed with code %d.\n",
71 static int configure_one_function(struct rmi_function
*fn
)
73 struct rmi_function_handler
*fh
;
76 if (!fn
|| !fn
->dev
.driver
)
79 fh
= to_rmi_function_handler(fn
->dev
.driver
);
81 retval
= fh
->config(fn
);
83 dev_err(&fn
->dev
, "Config failed with code %d.\n",
90 static int rmi_driver_process_reset_requests(struct rmi_device
*rmi_dev
)
92 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
93 struct rmi_function
*entry
;
96 list_for_each_entry(entry
, &data
->function_list
, node
) {
97 retval
= reset_one_function(entry
);
105 static int rmi_driver_process_config_requests(struct rmi_device
*rmi_dev
)
107 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
108 struct rmi_function
*entry
;
111 list_for_each_entry(entry
, &data
->function_list
, node
) {
112 retval
= configure_one_function(entry
);
120 static void process_one_interrupt(struct rmi_driver_data
*data
,
121 struct rmi_function
*fn
)
123 struct rmi_function_handler
*fh
;
125 if (!fn
|| !fn
->dev
.driver
)
128 fh
= to_rmi_function_handler(fn
->dev
.driver
);
130 bitmap_and(data
->fn_irq_bits
, data
->irq_status
, fn
->irq_mask
,
132 if (!bitmap_empty(data
->fn_irq_bits
, data
->irq_count
))
133 fh
->attention(fn
, data
->fn_irq_bits
);
137 int rmi_process_interrupt_requests(struct rmi_device
*rmi_dev
)
139 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
140 struct device
*dev
= &rmi_dev
->dev
;
141 struct rmi_function
*entry
;
147 if (!rmi_dev
->xport
->attn_data
) {
148 error
= rmi_read_block(rmi_dev
,
149 data
->f01_container
->fd
.data_base_addr
+ 1,
150 data
->irq_status
, data
->num_of_irq_regs
);
152 dev_err(dev
, "Failed to read irqs, code=%d\n", error
);
157 mutex_lock(&data
->irq_mutex
);
158 bitmap_and(data
->irq_status
, data
->irq_status
, data
->current_irq_mask
,
161 * At this point, irq_status has all bits that are set in the
162 * interrupt status register and are enabled.
164 mutex_unlock(&data
->irq_mutex
);
167 * It would be nice to be able to use irq_chip to handle these
168 * nested IRQs. Unfortunately, most of the current customers for
169 * this driver are using older kernels (3.0.x) that don't support
170 * the features required for that. Once they've shifted to more
171 * recent kernels (say, 3.3 and higher), this should be switched to
174 list_for_each_entry(entry
, &data
->function_list
, node
)
175 process_one_interrupt(data
, entry
);
178 input_sync(data
->input
);
182 EXPORT_SYMBOL_GPL(rmi_process_interrupt_requests
);
184 static int suspend_one_function(struct rmi_function
*fn
)
186 struct rmi_function_handler
*fh
;
189 if (!fn
|| !fn
->dev
.driver
)
192 fh
= to_rmi_function_handler(fn
->dev
.driver
);
194 retval
= fh
->suspend(fn
);
196 dev_err(&fn
->dev
, "Suspend failed with code %d.\n",
203 static int rmi_suspend_functions(struct rmi_device
*rmi_dev
)
205 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
206 struct rmi_function
*entry
;
209 list_for_each_entry(entry
, &data
->function_list
, node
) {
210 retval
= suspend_one_function(entry
);
218 static int resume_one_function(struct rmi_function
*fn
)
220 struct rmi_function_handler
*fh
;
223 if (!fn
|| !fn
->dev
.driver
)
226 fh
= to_rmi_function_handler(fn
->dev
.driver
);
228 retval
= fh
->resume(fn
);
230 dev_err(&fn
->dev
, "Resume failed with code %d.\n",
237 static int rmi_resume_functions(struct rmi_device
*rmi_dev
)
239 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
240 struct rmi_function
*entry
;
243 list_for_each_entry(entry
, &data
->function_list
, node
) {
244 retval
= resume_one_function(entry
);
252 static int enable_sensor(struct rmi_device
*rmi_dev
)
256 retval
= rmi_driver_process_config_requests(rmi_dev
);
260 return rmi_process_interrupt_requests(rmi_dev
);
264 * rmi_driver_set_input_params - set input device id and other data.
266 * @rmi_dev: Pointer to an RMI device
267 * @input: Pointer to input device
270 static int rmi_driver_set_input_params(struct rmi_device
*rmi_dev
,
271 struct input_dev
*input
)
273 input
->name
= SYNAPTICS_INPUT_DEVICE_NAME
;
274 input
->id
.vendor
= SYNAPTICS_VENDOR_ID
;
275 input
->id
.bustype
= BUS_RMI
;
279 static void rmi_driver_set_input_name(struct rmi_device
*rmi_dev
,
280 struct input_dev
*input
)
282 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
283 char *device_name
= rmi_f01_get_product_ID(data
->f01_container
);
286 name
= devm_kasprintf(&rmi_dev
->dev
, GFP_KERNEL
,
287 "Synaptics %s", device_name
);
294 static int rmi_driver_set_irq_bits(struct rmi_device
*rmi_dev
,
298 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
299 struct device
*dev
= &rmi_dev
->dev
;
301 mutex_lock(&data
->irq_mutex
);
302 bitmap_or(data
->new_irq_mask
,
303 data
->current_irq_mask
, mask
, data
->irq_count
);
305 error
= rmi_write_block(rmi_dev
,
306 data
->f01_container
->fd
.control_base_addr
+ 1,
307 data
->new_irq_mask
, data
->num_of_irq_regs
);
309 dev_err(dev
, "%s: Failed to change enabled interrupts!",
313 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
314 data
->num_of_irq_regs
);
317 mutex_unlock(&data
->irq_mutex
);
321 static int rmi_driver_clear_irq_bits(struct rmi_device
*rmi_dev
,
325 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
326 struct device
*dev
= &rmi_dev
->dev
;
328 mutex_lock(&data
->irq_mutex
);
329 bitmap_andnot(data
->new_irq_mask
,
330 data
->current_irq_mask
, mask
, data
->irq_count
);
332 error
= rmi_write_block(rmi_dev
,
333 data
->f01_container
->fd
.control_base_addr
+ 1,
334 data
->new_irq_mask
, data
->num_of_irq_regs
);
336 dev_err(dev
, "%s: Failed to change enabled interrupts!",
340 bitmap_copy(data
->current_irq_mask
, data
->new_irq_mask
,
341 data
->num_of_irq_regs
);
344 mutex_unlock(&data
->irq_mutex
);
348 static int rmi_driver_reset_handler(struct rmi_device
*rmi_dev
)
350 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
354 * Can get called before the driver is fully ready to deal with
357 if (!data
|| !data
->f01_container
) {
358 dev_warn(&rmi_dev
->dev
,
359 "Not ready to handle reset yet!\n");
363 error
= rmi_read_block(rmi_dev
,
364 data
->f01_container
->fd
.control_base_addr
+ 1,
365 data
->current_irq_mask
, data
->num_of_irq_regs
);
367 dev_err(&rmi_dev
->dev
, "%s: Failed to read current IRQ mask.\n",
372 error
= rmi_driver_process_reset_requests(rmi_dev
);
376 error
= rmi_driver_process_config_requests(rmi_dev
);
383 int rmi_read_pdt_entry(struct rmi_device
*rmi_dev
, struct pdt_entry
*entry
,
386 u8 buf
[RMI_PDT_ENTRY_SIZE
];
389 error
= rmi_read_block(rmi_dev
, pdt_address
, buf
, RMI_PDT_ENTRY_SIZE
);
391 dev_err(&rmi_dev
->dev
, "Read PDT entry at %#06x failed, code: %d.\n",
396 entry
->page_start
= pdt_address
& RMI4_PAGE_MASK
;
397 entry
->query_base_addr
= buf
[0];
398 entry
->command_base_addr
= buf
[1];
399 entry
->control_base_addr
= buf
[2];
400 entry
->data_base_addr
= buf
[3];
401 entry
->interrupt_source_count
= buf
[4] & RMI_PDT_INT_SOURCE_COUNT_MASK
;
402 entry
->function_version
= (buf
[4] & RMI_PDT_FUNCTION_VERSION_MASK
) >> 5;
403 entry
->function_number
= buf
[5];
407 EXPORT_SYMBOL_GPL(rmi_read_pdt_entry
);
409 static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry
*pdt
,
410 struct rmi_function_descriptor
*fd
)
412 fd
->query_base_addr
= pdt
->query_base_addr
+ pdt
->page_start
;
413 fd
->command_base_addr
= pdt
->command_base_addr
+ pdt
->page_start
;
414 fd
->control_base_addr
= pdt
->control_base_addr
+ pdt
->page_start
;
415 fd
->data_base_addr
= pdt
->data_base_addr
+ pdt
->page_start
;
416 fd
->function_number
= pdt
->function_number
;
417 fd
->interrupt_source_count
= pdt
->interrupt_source_count
;
418 fd
->function_version
= pdt
->function_version
;
421 #define RMI_SCAN_CONTINUE 0
422 #define RMI_SCAN_DONE 1
424 static int rmi_scan_pdt_page(struct rmi_device
*rmi_dev
,
427 int (*callback
)(struct rmi_device
*rmi_dev
,
429 const struct pdt_entry
*entry
))
431 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
432 struct pdt_entry pdt_entry
;
433 u16 page_start
= RMI4_PAGE_SIZE
* page
;
434 u16 pdt_start
= page_start
+ PDT_START_SCAN_LOCATION
;
435 u16 pdt_end
= page_start
+ PDT_END_SCAN_LOCATION
;
440 for (addr
= pdt_start
; addr
>= pdt_end
; addr
-= RMI_PDT_ENTRY_SIZE
) {
441 error
= rmi_read_pdt_entry(rmi_dev
, &pdt_entry
, addr
);
445 if (RMI4_END_OF_PDT(pdt_entry
.function_number
))
448 retval
= callback(rmi_dev
, ctx
, &pdt_entry
);
449 if (retval
!= RMI_SCAN_CONTINUE
)
453 return (data
->f01_bootloader_mode
|| addr
== pdt_start
) ?
454 RMI_SCAN_DONE
: RMI_SCAN_CONTINUE
;
457 static int rmi_scan_pdt(struct rmi_device
*rmi_dev
, void *ctx
,
458 int (*callback
)(struct rmi_device
*rmi_dev
,
460 const struct pdt_entry
*entry
))
463 int retval
= RMI_SCAN_DONE
;
465 for (page
= 0; page
<= RMI4_MAX_PAGE
; page
++) {
466 retval
= rmi_scan_pdt_page(rmi_dev
, page
, ctx
, callback
);
467 if (retval
!= RMI_SCAN_CONTINUE
)
471 return retval
< 0 ? retval
: 0;
474 int rmi_read_register_desc(struct rmi_device
*d
, u16 addr
,
475 struct rmi_register_descriptor
*rdesc
)
478 u8 size_presence_reg
;
480 int presense_offset
= 1;
489 * The first register of the register descriptor is the size of
490 * the register descriptor's presense register.
492 ret
= rmi_read(d
, addr
, &size_presence_reg
);
497 if (size_presence_reg
< 0 || size_presence_reg
> 35)
500 memset(buf
, 0, sizeof(buf
));
503 * The presence register contains the size of the register structure
504 * and a bitmap which identified which packet registers are present
505 * for this particular register type (ie query, control, or data).
507 ret
= rmi_read_block(d
, addr
, buf
, size_presence_reg
);
514 rdesc
->struct_size
= buf
[1] | (buf
[2] << 8);
516 rdesc
->struct_size
= buf
[0];
519 for (i
= presense_offset
; i
< size_presence_reg
; i
++) {
520 for (b
= 0; b
< 8; b
++) {
521 if (buf
[i
] & (0x1 << b
))
522 bitmap_set(rdesc
->presense_map
, map_offset
, 1);
527 rdesc
->num_registers
= bitmap_weight(rdesc
->presense_map
,
528 RMI_REG_DESC_PRESENSE_BITS
);
530 rdesc
->registers
= devm_kzalloc(&d
->dev
, rdesc
->num_registers
*
531 sizeof(struct rmi_register_desc_item
),
533 if (!rdesc
->registers
)
537 * Allocate a temporary buffer to hold the register structure.
538 * I'm not using devm_kzalloc here since it will not be retained
539 * after exiting this function
541 struct_buf
= kzalloc(rdesc
->struct_size
, GFP_KERNEL
);
546 * The register structure contains information about every packet
547 * register of this type. This includes the size of the packet
548 * register and a bitmap of all subpackets contained in the packet
551 ret
= rmi_read_block(d
, addr
, struct_buf
, rdesc
->struct_size
);
553 goto free_struct_buff
;
555 reg
= find_first_bit(rdesc
->presense_map
, RMI_REG_DESC_PRESENSE_BITS
);
556 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
557 struct rmi_register_desc_item
*item
= &rdesc
->registers
[i
];
558 int reg_size
= struct_buf
[offset
];
562 reg_size
= struct_buf
[offset
] |
563 (struct_buf
[offset
+ 1] << 8);
568 reg_size
= struct_buf
[offset
] |
569 (struct_buf
[offset
+ 1] << 8) |
570 (struct_buf
[offset
+ 2] << 16) |
571 (struct_buf
[offset
+ 3] << 24);
576 item
->reg_size
= reg_size
;
581 for (b
= 0; b
< 7; b
++) {
582 if (struct_buf
[offset
] & (0x1 << b
))
583 bitmap_set(item
->subpacket_map
,
587 } while (struct_buf
[offset
++] & 0x80);
589 item
->num_subpackets
= bitmap_weight(item
->subpacket_map
,
590 RMI_REG_DESC_SUBPACKET_BITS
);
592 rmi_dbg(RMI_DEBUG_CORE
, &d
->dev
,
593 "%s: reg: %d reg size: %ld subpackets: %d\n", __func__
,
594 item
->reg
, item
->reg_size
, item
->num_subpackets
);
596 reg
= find_next_bit(rdesc
->presense_map
,
597 RMI_REG_DESC_PRESENSE_BITS
, reg
+ 1);
604 EXPORT_SYMBOL_GPL(rmi_read_register_desc
);
606 const struct rmi_register_desc_item
*rmi_get_register_desc_item(
607 struct rmi_register_descriptor
*rdesc
, u16 reg
)
609 const struct rmi_register_desc_item
*item
;
612 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
613 item
= &rdesc
->registers
[i
];
614 if (item
->reg
== reg
)
620 EXPORT_SYMBOL_GPL(rmi_get_register_desc_item
);
622 size_t rmi_register_desc_calc_size(struct rmi_register_descriptor
*rdesc
)
624 const struct rmi_register_desc_item
*item
;
628 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
629 item
= &rdesc
->registers
[i
];
630 size
+= item
->reg_size
;
634 EXPORT_SYMBOL_GPL(rmi_register_desc_calc_size
);
636 /* Compute the register offset relative to the base address */
637 int rmi_register_desc_calc_reg_offset(
638 struct rmi_register_descriptor
*rdesc
, u16 reg
)
640 const struct rmi_register_desc_item
*item
;
644 for (i
= 0; i
< rdesc
->num_registers
; i
++) {
645 item
= &rdesc
->registers
[i
];
646 if (item
->reg
== reg
)
652 EXPORT_SYMBOL_GPL(rmi_register_desc_calc_reg_offset
);
654 bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item
*item
,
657 return find_next_bit(item
->subpacket_map
, RMI_REG_DESC_PRESENSE_BITS
,
658 subpacket
) == subpacket
;
661 /* Indicates that flash programming is enabled (bootloader mode). */
662 #define RMI_F01_STATUS_BOOTLOADER(status) (!!((status) & 0x40))
665 * Given the PDT entry for F01, read the device status register to determine
666 * if we're stuck in bootloader mode or not.
669 static int rmi_check_bootloader_mode(struct rmi_device
*rmi_dev
,
670 const struct pdt_entry
*pdt
)
675 error
= rmi_read(rmi_dev
, pdt
->data_base_addr
+ pdt
->page_start
,
678 dev_err(&rmi_dev
->dev
,
679 "Failed to read device status: %d.\n", error
);
683 return RMI_F01_STATUS_BOOTLOADER(device_status
);
686 static int rmi_count_irqs(struct rmi_device
*rmi_dev
,
687 void *ctx
, const struct pdt_entry
*pdt
)
689 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
690 int *irq_count
= ctx
;
692 *irq_count
+= pdt
->interrupt_source_count
;
693 if (pdt
->function_number
== 0x01) {
694 data
->f01_bootloader_mode
=
695 rmi_check_bootloader_mode(rmi_dev
, pdt
);
696 if (data
->f01_bootloader_mode
)
697 dev_warn(&rmi_dev
->dev
,
698 "WARNING: RMI4 device is in bootloader mode!\n");
701 return RMI_SCAN_CONTINUE
;
704 static int rmi_initial_reset(struct rmi_device
*rmi_dev
,
705 void *ctx
, const struct pdt_entry
*pdt
)
709 if (pdt
->function_number
== 0x01) {
710 u16 cmd_addr
= pdt
->page_start
+ pdt
->command_base_addr
;
711 u8 cmd_buf
= RMI_DEVICE_RESET_CMD
;
712 const struct rmi_device_platform_data
*pdata
=
713 rmi_get_platform_data(rmi_dev
);
715 if (rmi_dev
->xport
->ops
->reset
) {
716 error
= rmi_dev
->xport
->ops
->reset(rmi_dev
->xport
,
721 return RMI_SCAN_DONE
;
724 error
= rmi_write_block(rmi_dev
, cmd_addr
, &cmd_buf
, 1);
726 dev_err(&rmi_dev
->dev
,
727 "Initial reset failed. Code = %d.\n", error
);
731 mdelay(pdata
->reset_delay_ms
?: DEFAULT_RESET_DELAY_MS
);
733 return RMI_SCAN_DONE
;
736 /* F01 should always be on page 0. If we don't find it there, fail. */
737 return pdt
->page_start
== 0 ? RMI_SCAN_CONTINUE
: -ENODEV
;
740 static int rmi_create_function(struct rmi_device
*rmi_dev
,
741 void *ctx
, const struct pdt_entry
*pdt
)
743 struct device
*dev
= &rmi_dev
->dev
;
744 struct rmi_driver_data
*data
= dev_get_drvdata(&rmi_dev
->dev
);
745 int *current_irq_count
= ctx
;
746 struct rmi_function
*fn
;
750 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Initializing F%02X.\n",
751 pdt
->function_number
);
753 fn
= kzalloc(sizeof(struct rmi_function
) +
754 BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long),
757 dev_err(dev
, "Failed to allocate memory for F%02X\n",
758 pdt
->function_number
);
762 INIT_LIST_HEAD(&fn
->node
);
763 rmi_driver_copy_pdt_to_fd(pdt
, &fn
->fd
);
765 fn
->rmi_dev
= rmi_dev
;
767 fn
->num_of_irqs
= pdt
->interrupt_source_count
;
768 fn
->irq_pos
= *current_irq_count
;
769 *current_irq_count
+= fn
->num_of_irqs
;
771 for (i
= 0; i
< fn
->num_of_irqs
; i
++)
772 set_bit(fn
->irq_pos
+ i
, fn
->irq_mask
);
774 error
= rmi_register_function(fn
);
778 if (pdt
->function_number
== 0x01)
779 data
->f01_container
= fn
;
781 list_add_tail(&fn
->node
, &data
->function_list
);
783 return RMI_SCAN_CONTINUE
;
786 put_device(&fn
->dev
);
790 int rmi_driver_suspend(struct rmi_device
*rmi_dev
)
794 retval
= rmi_suspend_functions(rmi_dev
);
796 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
801 EXPORT_SYMBOL_GPL(rmi_driver_suspend
);
803 int rmi_driver_resume(struct rmi_device
*rmi_dev
)
807 retval
= rmi_resume_functions(rmi_dev
);
809 dev_warn(&rmi_dev
->dev
, "Failed to suspend functions: %d\n",
814 EXPORT_SYMBOL_GPL(rmi_driver_resume
);
816 static int rmi_driver_remove(struct device
*dev
)
818 struct rmi_device
*rmi_dev
= to_rmi_device(dev
);
820 rmi_free_function_list(rmi_dev
);
826 static int rmi_driver_of_probe(struct device
*dev
,
827 struct rmi_device_platform_data
*pdata
)
831 retval
= rmi_of_property_read_u32(dev
, &pdata
->reset_delay_ms
,
832 "syna,reset-delay-ms", 1);
839 static inline int rmi_driver_of_probe(struct device
*dev
,
840 struct rmi_device_platform_data
*pdata
)
846 static int rmi_driver_probe(struct device
*dev
)
848 struct rmi_driver
*rmi_driver
;
849 struct rmi_driver_data
*data
;
850 struct rmi_device_platform_data
*pdata
;
851 struct rmi_device
*rmi_dev
;
857 rmi_dbg(RMI_DEBUG_CORE
, dev
, "%s: Starting probe.\n",
860 if (!rmi_is_physical_device(dev
)) {
861 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Not a physical device.\n");
865 rmi_dev
= to_rmi_device(dev
);
866 rmi_driver
= to_rmi_driver(dev
->driver
);
867 rmi_dev
->driver
= rmi_driver
;
869 pdata
= rmi_get_platform_data(rmi_dev
);
871 if (rmi_dev
->xport
->dev
->of_node
) {
872 retval
= rmi_driver_of_probe(rmi_dev
->xport
->dev
, pdata
);
877 data
= devm_kzalloc(dev
, sizeof(struct rmi_driver_data
), GFP_KERNEL
);
881 INIT_LIST_HEAD(&data
->function_list
);
882 data
->rmi_dev
= rmi_dev
;
883 dev_set_drvdata(&rmi_dev
->dev
, data
);
886 * Right before a warm boot, the sensor might be in some unusual state,
887 * such as F54 diagnostics, or F34 bootloader mode after a firmware
888 * or configuration update. In order to clear the sensor to a known
889 * state and/or apply any updates, we issue a initial reset to clear any
890 * previous settings and force it into normal operation.
892 * We have to do this before actually building the PDT because
893 * the reflash updates (if any) might cause various registers to move
896 * For a number of reasons, this initial reset may fail to return
897 * within the specified time, but we'll still be able to bring up the
898 * driver normally after that failure. This occurs most commonly in
899 * a cold boot situation (where then firmware takes longer to come up
900 * than from a warm boot) and the reset_delay_ms in the platform data
901 * has been set too short to accommodate that. Since the sensor will
902 * eventually come up and be usable, we don't want to just fail here
903 * and leave the customer's device unusable. So we warn them, and
904 * continue processing.
906 retval
= rmi_scan_pdt(rmi_dev
, NULL
, rmi_initial_reset
);
908 dev_warn(dev
, "RMI initial reset failed! Continuing in spite of this.\n");
910 retval
= rmi_read(rmi_dev
, PDT_PROPERTIES_LOCATION
, &data
->pdt_props
);
913 * we'll print out a warning and continue since
914 * failure to get the PDT properties is not a cause to fail
916 dev_warn(dev
, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n",
917 PDT_PROPERTIES_LOCATION
, retval
);
921 * We need to count the IRQs and allocate their storage before scanning
922 * the PDT and creating the function entries, because adding a new
923 * function can trigger events that result in the IRQ related storage
926 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Counting IRQs.\n");
928 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_count_irqs
);
930 dev_err(dev
, "IRQ counting failed with code %d.\n", retval
);
933 data
->irq_count
= irq_count
;
934 data
->num_of_irq_regs
= (data
->irq_count
+ 7) / 8;
936 mutex_init(&data
->irq_mutex
);
938 size
= BITS_TO_LONGS(data
->irq_count
) * sizeof(unsigned long);
939 irq_memory
= devm_kzalloc(dev
, size
* 4, GFP_KERNEL
);
941 dev_err(dev
, "Failed to allocate memory for irq masks.\n");
945 data
->irq_status
= irq_memory
+ size
* 0;
946 data
->fn_irq_bits
= irq_memory
+ size
* 1;
947 data
->current_irq_mask
= irq_memory
+ size
* 2;
948 data
->new_irq_mask
= irq_memory
+ size
* 3;
950 if (rmi_dev
->xport
->input
) {
952 * The transport driver already has an input device.
953 * In some cases it is preferable to reuse the transport
954 * devices input device instead of creating a new one here.
955 * One example is some HID touchpads report "pass-through"
956 * button events are not reported by rmi registers.
958 data
->input
= rmi_dev
->xport
->input
;
960 data
->input
= devm_input_allocate_device(dev
);
962 dev_err(dev
, "%s: Failed to allocate input device.\n",
965 goto err_destroy_functions
;
967 rmi_driver_set_input_params(rmi_dev
, data
->input
);
968 data
->input
->phys
= devm_kasprintf(dev
, GFP_KERNEL
,
969 "%s/input0", dev_name(dev
));
973 rmi_dbg(RMI_DEBUG_CORE
, dev
, "Creating functions.");
974 retval
= rmi_scan_pdt(rmi_dev
, &irq_count
, rmi_create_function
);
976 dev_err(dev
, "Function creation failed with code %d.\n",
978 goto err_destroy_functions
;
981 if (!data
->f01_container
) {
982 dev_err(dev
, "Missing F01 container!\n");
984 goto err_destroy_functions
;
987 retval
= rmi_read_block(rmi_dev
,
988 data
->f01_container
->fd
.control_base_addr
+ 1,
989 data
->current_irq_mask
, data
->num_of_irq_regs
);
991 dev_err(dev
, "%s: Failed to read current IRQ mask.\n",
993 goto err_destroy_functions
;
997 rmi_driver_set_input_name(rmi_dev
, data
->input
);
998 if (!rmi_dev
->xport
->input
) {
999 if (input_register_device(data
->input
)) {
1000 dev_err(dev
, "%s: Failed to register input device.\n",
1002 goto err_destroy_functions
;
1007 if (data
->f01_container
->dev
.driver
)
1008 /* Driver already bound, so enable ATTN now. */
1009 return enable_sensor(rmi_dev
);
1013 err_destroy_functions
:
1014 rmi_free_function_list(rmi_dev
);
1016 return retval
< 0 ? retval
: 0;
1019 static struct rmi_driver rmi_physical_driver
= {
1021 .owner
= THIS_MODULE
,
1022 .name
= "rmi4_physical",
1023 .bus
= &rmi_bus_type
,
1024 .probe
= rmi_driver_probe
,
1025 .remove
= rmi_driver_remove
,
1027 .reset_handler
= rmi_driver_reset_handler
,
1028 .clear_irq_bits
= rmi_driver_clear_irq_bits
,
1029 .set_irq_bits
= rmi_driver_set_irq_bits
,
1030 .set_input_params
= rmi_driver_set_input_params
,
1033 bool rmi_is_physical_driver(struct device_driver
*drv
)
1035 return drv
== &rmi_physical_driver
.driver
;
1038 int __init
rmi_register_physical_driver(void)
1042 error
= driver_register(&rmi_physical_driver
.driver
);
1044 pr_err("%s: driver register failed, code=%d.\n", __func__
,
1052 void __exit
rmi_unregister_physical_driver(void)
1054 driver_unregister(&rmi_physical_driver
.driver
);