1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3 * Copyright (c) 2011-2016 Synaptics Incorporated
4 * Copyright (c) 2011 Unixphere
5 */
6
7 #ifndef _RMI_BUS_H
8 #define _RMI_BUS_H
9
10 #include <linux/rmi.h>
11
12 struct rmi_device;
13
14 /*
15 * The interrupt source count in the function descriptor can represent up to
16 * 6 interrupt sources in the normal manner.
17 */
18 #define RMI_FN_MAX_IRQS 6
19
20 /**
21 * struct rmi_function - represents the implementation of an RMI4
22 * function for a particular device (basically, a driver for that RMI4 function)
23 *
24 * @fd: The function descriptor of the RMI function
25 * @rmi_dev: Pointer to the RMI device associated with this function container
26 * @dev: The device associated with this particular function.
27 *
28 * @num_of_irqs: The number of irqs needed by this function
29 * @irq_pos: The position in the irq bitfield this function holds
30 * @irq_mask: For convenience, can be used to mask IRQ bits off during ATTN
31 * interrupt handling.
32 * @irqs: assigned virq numbers (up to num_of_irqs)
33 *
34 * @node: entry in device's list of functions
35 */
36 struct rmi_function {
37 struct rmi_function_descriptor fd;
38 struct rmi_device *rmi_dev;
39 struct device dev;
40 struct list_head node;
41
42 unsigned int num_of_irqs;
43 int irq[RMI_FN_MAX_IRQS];
44 unsigned int irq_pos;
45 unsigned long irq_mask[];
46 };
47
48 #define to_rmi_function(d) container_of(d, struct rmi_function, dev)
49
50 bool rmi_is_function_device(struct device *dev);
51
52 struct rmi_function *rmi_alloc_function(struct rmi_device *rmi_dev, u8 id);
53 int __must_check rmi_register_function(struct rmi_function *);
54 void rmi_unregister_function(struct rmi_function *);
55
56 /**
57 * struct rmi_function_handler - driver routines for a particular RMI function.
58 *
59 * @func: The RMI function number
60 * @reset: Called when a reset of the touch sensor is detected. The routine
61 * should perform any out-of-the-ordinary reset handling that might be
62 * necessary. Restoring of touch sensor configuration registers should be
63 * handled in the config() callback, below.
64 * @config: Called when the function container is first initialized, and
65 * after a reset is detected. This routine should write any necessary
66 * configuration settings to the device.
67 * @attention: Called when the IRQ(s) for the function are set by the touch
68 * sensor.
69 * @suspend: Should perform any required operations to suspend the particular
70 * function.
71 * @resume: Should perform any required operations to resume the particular
72 * function.
73 *
74 * All callbacks are expected to return 0 on success, error code on failure.
75 */
76 struct rmi_function_handler {
77 struct device_driver driver;
78
79 u8 func;
80
81 int (*probe)(struct rmi_function *fn);
82 void (*remove)(struct rmi_function *fn);
83 int (*config)(struct rmi_function *fn);
84 int (*reset)(struct rmi_function *fn);
85 irqreturn_t (*attention)(int irq, void *ctx);
86 int (*suspend)(struct rmi_function *fn);
87 int (*resume)(struct rmi_function *fn);
88 };
89
90 #define to_rmi_function_handler(d) \
91 container_of_const(d, struct rmi_function_handler, driver)
92
93 int __must_check __rmi_register_function_handler(struct rmi_function_handler *,
94 struct module *, const char *);
95 #define rmi_register_function_handler(handler) \
96 __rmi_register_function_handler(handler, THIS_MODULE, KBUILD_MODNAME)
97
98 void rmi_unregister_function_handler(struct rmi_function_handler *);
99
100 #define to_rmi_driver(d) \
101 container_of(d, struct rmi_driver, driver)
102
103 #define to_rmi_device(d) container_of(d, struct rmi_device, dev)
104
105 static inline struct rmi_device_platform_data *
rmi_get_platform_data(struct rmi_device * d)106 rmi_get_platform_data(struct rmi_device *d)
107 {
108 return &d->xport->pdata;
109 }
110
111 bool rmi_is_physical_device(struct device *dev);
112
113 /**
114 * rmi_reset - reset a RMI4 device
115 * @d: Pointer to an RMI device
116 *
117 * Calls for a reset of each function implemented by a specific device.
118 * Returns 0 on success or a negative error code.
119 */
rmi_reset(struct rmi_device * d)120 static inline int rmi_reset(struct rmi_device *d)
121 {
122 return d->driver->reset_handler(d);
123 }
124
125 /**
126 * rmi_read - read a single byte
127 * @d: Pointer to an RMI device
128 * @addr: The address to read from
129 * @buf: The read buffer
130 *
131 * Reads a single byte of data using the underlying transport protocol
132 * into memory pointed by @buf. It returns 0 on success or a negative
133 * error code.
134 */
rmi_read(struct rmi_device * d,u16 addr,u8 * buf)135 static inline int rmi_read(struct rmi_device *d, u16 addr, u8 *buf)
136 {
137 return d->xport->ops->read_block(d->xport, addr, buf, 1);
138 }
139
140 /**
141 * rmi_read_block - read a block of bytes
142 * @d: Pointer to an RMI device
143 * @addr: The start address to read from
144 * @buf: The read buffer
145 * @len: Length of the read buffer
146 *
147 * Reads a block of byte data using the underlying transport protocol
148 * into memory pointed by @buf. It returns 0 on success or a negative
149 * error code.
150 */
rmi_read_block(struct rmi_device * d,u16 addr,void * buf,size_t len)151 static inline int rmi_read_block(struct rmi_device *d, u16 addr,
152 void *buf, size_t len)
153 {
154 return d->xport->ops->read_block(d->xport, addr, buf, len);
155 }
156
157 /**
158 * rmi_write - write a single byte
159 * @d: Pointer to an RMI device
160 * @addr: The address to write to
161 * @data: The data to write
162 *
163 * Writes a single byte using the underlying transport protocol. It
164 * returns zero on success or a negative error code.
165 */
rmi_write(struct rmi_device * d,u16 addr,u8 data)166 static inline int rmi_write(struct rmi_device *d, u16 addr, u8 data)
167 {
168 return d->xport->ops->write_block(d->xport, addr, &data, 1);
169 }
170
171 /**
172 * rmi_write_block - write a block of bytes
173 * @d: Pointer to an RMI device
174 * @addr: The start address to write to
175 * @buf: The write buffer
176 * @len: Length of the write buffer
177 *
178 * Writes a block of byte data from buf using the underlaying transport
179 * protocol. It returns the amount of bytes written or a negative error code.
180 */
rmi_write_block(struct rmi_device * d,u16 addr,const void * buf,size_t len)181 static inline int rmi_write_block(struct rmi_device *d, u16 addr,
182 const void *buf, size_t len)
183 {
184 return d->xport->ops->write_block(d->xport, addr, buf, len);
185 }
186
187 int rmi_for_each_dev(void *data, int (*func)(struct device *dev, void *data));
188
189 extern const struct bus_type rmi_bus_type;
190
191 int rmi_of_property_read_u32(struct device *dev, u32 *result,
192 const char *prop, bool optional);
193
194 #define RMI_DEBUG_CORE BIT(0)
195 #define RMI_DEBUG_XPORT BIT(1)
196 #define RMI_DEBUG_FN BIT(2)
197 #define RMI_DEBUG_2D_SENSOR BIT(3)
198
199 void rmi_dbg(int flags, struct device *dev, const char *fmt, ...);
200 #endif
201