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