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 int __must_check rmi_register_function(struct rmi_function *);
53 void rmi_unregister_function(struct rmi_function *);
54 
55 /**
56  * struct rmi_function_handler - driver routines for a particular RMI function.
57  *
58  * @func: The RMI function number
59  * @reset: Called when a reset of the touch sensor is detected.  The routine
60  * should perform any out-of-the-ordinary reset handling that might be
61  * necessary.  Restoring of touch sensor configuration registers should be
62  * handled in the config() callback, below.
63  * @config: Called when the function container is first initialized, and
64  * after a reset is detected.  This routine should write any necessary
65  * configuration settings to the device.
66  * @attention: Called when the IRQ(s) for the function are set by the touch
67  * sensor.
68  * @suspend: Should perform any required operations to suspend the particular
69  * function.
70  * @resume: Should perform any required operations to resume the particular
71  * function.
72  *
73  * All callbacks are expected to return 0 on success, error code on failure.
74  */
75 struct rmi_function_handler {
76 	struct device_driver driver;
77 
78 	u8 func;
79 
80 	int (*probe)(struct rmi_function *fn);
81 	void (*remove)(struct rmi_function *fn);
82 	int (*config)(struct rmi_function *fn);
83 	int (*reset)(struct rmi_function *fn);
84 	irqreturn_t (*attention)(int irq, void *ctx);
85 	int (*suspend)(struct rmi_function *fn);
86 	int (*resume)(struct rmi_function *fn);
87 };
88 
89 #define to_rmi_function_handler(d) \
90 		container_of(d, struct rmi_function_handler, driver)
91 
92 int __must_check __rmi_register_function_handler(struct rmi_function_handler *,
93 						 struct module *, const char *);
94 #define rmi_register_function_handler(handler) \
95 	__rmi_register_function_handler(handler, THIS_MODULE, KBUILD_MODNAME)
96 
97 void rmi_unregister_function_handler(struct rmi_function_handler *);
98 
99 #define to_rmi_driver(d) \
100 	container_of(d, struct rmi_driver, driver)
101 
102 #define to_rmi_device(d) container_of(d, struct rmi_device, dev)
103 
104 static inline struct rmi_device_platform_data *
rmi_get_platform_data(struct rmi_device * d)105 rmi_get_platform_data(struct rmi_device *d)
106 {
107 	return &d->xport->pdata;
108 }
109 
110 bool rmi_is_physical_device(struct device *dev);
111 
112 /**
113  * rmi_reset - reset a RMI4 device
114  * @d: Pointer to an RMI device
115  *
116  * Calls for a reset of each function implemented by a specific device.
117  * Returns 0 on success or a negative error code.
118  */
rmi_reset(struct rmi_device * d)119 static inline int rmi_reset(struct rmi_device *d)
120 {
121 	return d->driver->reset_handler(d);
122 }
123 
124 /**
125  * rmi_read - read a single byte
126  * @d: Pointer to an RMI device
127  * @addr: The address to read from
128  * @buf: The read buffer
129  *
130  * Reads a single byte of data using the underlying transport protocol
131  * into memory pointed by @buf. It returns 0 on success or a negative
132  * error code.
133  */
rmi_read(struct rmi_device * d,u16 addr,u8 * buf)134 static inline int rmi_read(struct rmi_device *d, u16 addr, u8 *buf)
135 {
136 	return d->xport->ops->read_block(d->xport, addr, buf, 1);
137 }
138 
139 /**
140  * rmi_read_block - read a block of bytes
141  * @d: Pointer to an RMI device
142  * @addr: The start address to read from
143  * @buf: The read buffer
144  * @len: Length of the read buffer
145  *
146  * Reads a block of byte data using the underlying transport protocol
147  * into memory pointed by @buf. It returns 0 on success or a negative
148  * error code.
149  */
rmi_read_block(struct rmi_device * d,u16 addr,void * buf,size_t len)150 static inline int rmi_read_block(struct rmi_device *d, u16 addr,
151 				 void *buf, size_t len)
152 {
153 	return d->xport->ops->read_block(d->xport, addr, buf, len);
154 }
155 
156 /**
157  * rmi_write - write a single byte
158  * @d: Pointer to an RMI device
159  * @addr: The address to write to
160  * @data: The data to write
161  *
162  * Writes a single byte using the underlying transport protocol. It
163  * returns zero on success or a negative error code.
164  */
rmi_write(struct rmi_device * d,u16 addr,u8 data)165 static inline int rmi_write(struct rmi_device *d, u16 addr, u8 data)
166 {
167 	return d->xport->ops->write_block(d->xport, addr, &data, 1);
168 }
169 
170 /**
171  * rmi_write_block - write a block of bytes
172  * @d: Pointer to an RMI device
173  * @addr: The start address to write to
174  * @buf: The write buffer
175  * @len: Length of the write buffer
176  *
177  * Writes a block of byte data from buf using the underlaying transport
178  * protocol.  It returns the amount of bytes written or a negative error code.
179  */
rmi_write_block(struct rmi_device * d,u16 addr,const void * buf,size_t len)180 static inline int rmi_write_block(struct rmi_device *d, u16 addr,
181 				  const void *buf, size_t len)
182 {
183 	return d->xport->ops->write_block(d->xport, addr, buf, len);
184 }
185 
186 int rmi_for_each_dev(void *data, int (*func)(struct device *dev, void *data));
187 
188 extern struct bus_type rmi_bus_type;
189 
190 int rmi_of_property_read_u32(struct device *dev, u32 *result,
191 				const char *prop, bool optional);
192 
193 #define RMI_DEBUG_CORE			BIT(0)
194 #define RMI_DEBUG_XPORT			BIT(1)
195 #define RMI_DEBUG_FN			BIT(2)
196 #define RMI_DEBUG_2D_SENSOR		BIT(3)
197 
198 void rmi_dbg(int flags, struct device *dev, const char *fmt, ...);
199 #endif
200