LXR linux/drivers/input/rmi4/rmi

   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 * 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 */
  32struct 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
  45bool rmi_is_function_device(struct device *dev);
  46
  47int __must_check rmi_register_function(struct rmi_function *);
  48void 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 */
  70struct 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
  87int __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
  92void 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
  99static inline struct rmi_device_platform_data *
 100rmi_get_platform_data(struct rmi_device *d)
 101{
 102        return &d->xport->pdata;
 103}
 104
 105bool rmi_is_physical_device(struct device *dev);
 106
 107/**
 108 * rmi_reset - reset a RMI4 device
 109 * @d: Pointer to an RMI device
 110 *
 111 * Calls for a reset of each function implemented by a specific device.
 112 * Returns 0 on success or a negative error code.
 113 */
 114static inline int rmi_reset(struct rmi_device *d)
 115{
 116        return d->driver->reset_handler(d);
 117}
 118
 119/**
 120 * rmi_read - read a single byte
 121 * @d: Pointer to an RMI device
 122 * @addr: The address to read from
 123 * @buf: The read buffer
 124 *
 125 * Reads a single byte of data using the underlying transport protocol
 126 * into memory pointed by @buf. It returns 0 on success or a negative
 127 * error code.
 128 */
 129static inline int rmi_read(struct rmi_device *d, u16 addr, u8 *buf)
 130{
 131        return d->xport->ops->read_block(d->xport, addr, buf, 1);
 132}
 133
 134/**
 135 * rmi_read_block - read a block of bytes
 136 * @d: Pointer to an RMI device
 137 * @addr: The start address to read from
 138 * @buf: The read buffer
 139 * @len: Length of the read buffer
 140 *
 141 * Reads a block of byte data using the underlying transport protocol
 142 * into memory pointed by @buf. It returns 0 on success or a negative
 143 * error code.
 144 */
 145static inline int rmi_read_block(struct rmi_device *d, u16 addr,
 146                                 void *buf, size_t len)
 147{
 148        return d->xport->ops->read_block(d->xport, addr, buf, len);
 149}
 150
 151/**
 152 * rmi_write - write a single byte
 153 * @d: Pointer to an RMI device
 154 * @addr: The address to write to
 155 * @data: The data to write
 156 *
 157 * Writes a single byte using the underlying transport protocol. It
 158 * returns zero on success or a negative error code.
 159 */
 160static inline int rmi_write(struct rmi_device *d, u16 addr, u8 data)
 161{
 162        return d->xport->ops->write_block(d->xport, addr, &data, 1);
 163}
 164
 165/**
 166 * rmi_write_block - write a block of bytes
 167 * @d: Pointer to an RMI device
 168 * @addr: The start address to write to
 169 * @buf: The write buffer
 170 * @len: Length of the write buffer
 171 *
 172 * Writes a block of byte data from buf using the underlaying transport
 173 * protocol.  It returns the amount of bytes written or a negative error code.
 174 */
 175static inline int rmi_write_block(struct rmi_device *d, u16 addr,
 176                                  const void *buf, size_t len)
 177{
 178        return d->xport->ops->write_block(d->xport, addr, buf, len);
 179}
 180
 181int rmi_for_each_dev(void *data, int (*func)(struct device *dev, void *data));
 182
 183extern struct bus_type rmi_bus_type;
 184
 185int rmi_of_property_read_u32(struct device *dev, u32 *result,
 186                                const char *prop, bool optional);
 187
 188#define RMI_DEBUG_CORE                  BIT(0)
 189#define RMI_DEBUG_XPORT                 BIT(1)
 190#define RMI_DEBUG_FN                    BIT(2)
 191#define RMI_DEBUG_2D_SENSOR             BIT(3)
 192
 193void rmi_dbg(int flags, struct device *dev, const char *fmt, ...);
 194#endif
 195