drivers/input/rmi4/rmi_bus.h

   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 *
 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  */
 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  */
 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  */
 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  */
 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  */
 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