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