include/linux/rmi.h

   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_H
  11 #define _RMI_H
  12 #include <linux/kernel.h>
  13 #include <linux/device.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/input.h>
  16 #include <linux/list.h>
  17 #include <linux/module.h>
  18 #include <linux/types.h>
  19
  20 #define NAME_BUFFER_SIZE 256
  21
  22 /**
  23  * struct rmi_2d_axis_alignment - target axis alignment
  24  * @swap_axes: set to TRUE if desired to swap x- and y-axis
  25  * @flip_x: set to TRUE if desired to flip direction on x-axis
  26  * @flip_y: set to TRUE if desired to flip direction on y-axis
  27  * @clip_x_low - reported X coordinates below this setting will be clipped to
  28  *               the specified value
  29  * @clip_x_high - reported X coordinates above this setting will be clipped to
  30  *               the specified value
  31  * @clip_y_low - reported Y coordinates below this setting will be clipped to
  32  *               the specified value
  33  * @clip_y_high - reported Y coordinates above this setting will be clipped to
  34  *               the specified value
  35  * @offset_x - this value will be added to all reported X coordinates
  36  * @offset_y - this value will be added to all reported Y coordinates
  37  * @rel_report_enabled - if set to true, the relative reporting will be
  38  *               automatically enabled for this sensor.
  39  */
  40 struct rmi_2d_axis_alignment {
  41         bool swap_axes;
  42         bool flip_x;
  43         bool flip_y;
  44         u16 clip_x_low;
  45         u16 clip_y_low;
  46         u16 clip_x_high;
  47         u16 clip_y_high;
  48         u16 offset_x;
  49         u16 offset_y;
  50         u8 delta_x_threshold;
  51         u8 delta_y_threshold;
  52 };
  53
  54 /** This is used to override any hints an F11 2D sensor might have provided
  55  * as to what type of sensor it is.
  56  *
  57  * @rmi_f11_sensor_default - do not override, determine from F11_2D_QUERY14 if
  58  * available.
  59  * @rmi_f11_sensor_touchscreen - treat the sensor as a touchscreen (direct
  60  * pointing).
  61  * @rmi_f11_sensor_touchpad - thread the sensor as a touchpad (indirect
  62  * pointing).
  63  */
  64 enum rmi_sensor_type {
  65         rmi_sensor_default = 0,
  66         rmi_sensor_touchscreen,
  67         rmi_sensor_touchpad
  68 };
  69
  70 #define RMI_F11_DISABLE_ABS_REPORT      BIT(0)
  71
  72 /**
  73  * struct rmi_2d_sensor_data - overrides defaults for a 2D sensor.
  74  * @axis_align - provides axis alignment overrides (see above).
  75  * @sensor_type - Forces the driver to treat the sensor as an indirect
  76  * pointing device (touchpad) rather than a direct pointing device
  77  * (touchscreen).  This is useful when F11_2D_QUERY14 register is not
  78  * available.
  79  * @disable_report_mask - Force data to not be reported even if it is supported
  80  * by the firware.
  81  * @topbuttonpad - Used with the "5 buttons touchpads" found on the Lenovo 40
  82  * series
  83  * @kernel_tracking - most moderns RMI f11 firmwares implement Multifinger
  84  * Type B protocol. However, there are some corner cases where the user
  85  * triggers some jumps by tapping with two fingers on the touchpad.
  86  * Use this setting and dmax to filter out these jumps.
  87  * Also, when using an old sensor using MF Type A behavior, set to true to
  88  * report an actual MT protocol B.
  89  * @dmax - the maximum distance (in sensor units) the kernel tracking allows two
  90  * distincts fingers to be considered the same.
  91  */
  92 struct rmi_2d_sensor_platform_data {
  93         struct rmi_2d_axis_alignment axis_align;
  94         enum rmi_sensor_type sensor_type;
  95         int x_mm;
  96         int y_mm;
  97         int disable_report_mask;
  98         u16 rezero_wait;
  99         bool topbuttonpad;
 100         bool kernel_tracking;
 101         int dmax;
 102 };
 103
 104 /**
 105  * struct rmi_f30_data - overrides defaults for a single F30 GPIOs/LED chip.
 106  * @buttonpad - the touchpad is a buttonpad, so enable only the first actual
 107  * button that is found.
 108  * @trackstick_buttons - Set when the function 30 is handling the physical
 109  * buttons of the trackstick (as a PD/2 passthrough device.
 110  * @disable - the touchpad incorrectly reports F30 and it should be ignored.
 111  * This is a special case which is due to misconfigured firmware.
 112  */
 113 struct rmi_f30_data {
 114         bool buttonpad;
 115         bool trackstick_buttons;
 116         bool disable;
 117 };
 118
 119 /**
 120  * struct rmi_f01_power - override default power management settings.
 121  *
 122  */
 123 enum rmi_f01_nosleep {
 124         RMI_F01_NOSLEEP_DEFAULT = 0,
 125         RMI_F01_NOSLEEP_OFF = 1,
 126         RMI_F01_NOSLEEP_ON = 2
 127 };
 128
 129 /**
 130  * struct rmi_f01_power_management -When non-zero, these values will be written
 131  * to the touch sensor to override the default firmware settigns.  For a
 132  * detailed explanation of what each field does, see the corresponding
 133  * documention in the RMI4 specification.
 134  *
 135  * @nosleep - specifies whether the device is permitted to sleep or doze (that
 136  * is, enter a temporary low power state) when no fingers are touching the
 137  * sensor.
 138  * @wakeup_threshold - controls the capacitance threshold at which the touch
 139  * sensor will decide to wake up from that low power state.
 140  * @doze_holdoff - controls how long the touch sensor waits after the last
 141  * finger lifts before entering the doze state, in units of 100ms.
 142  * @doze_interval - controls the interval between checks for finger presence
 143  * when the touch sensor is in doze mode, in units of 10ms.
 144  */
 145 struct rmi_f01_power_management {
 146         enum rmi_f01_nosleep nosleep;
 147         u8 wakeup_threshold;
 148         u8 doze_holdoff;
 149         u8 doze_interval;
 150 };
 151
 152 /**
 153  * struct rmi_device_platform_data - system specific configuration info.
 154  *
 155  * @reset_delay_ms - after issuing a reset command to the touch sensor, the
 156  * driver waits a few milliseconds to give the firmware a chance to
 157  * to re-initialize.  You can override the default wait period here.
 158  */
 159 struct rmi_device_platform_data {
 160         int reset_delay_ms;
 161
 162         /* function handler pdata */
 163         struct rmi_2d_sensor_platform_data *sensor_pdata;
 164         struct rmi_f01_power_management power_management;
 165         struct rmi_f30_data *f30_data;
 166 };
 167
 168 /**
 169  * struct rmi_function_descriptor - RMI function base addresses
 170  *
 171  * @query_base_addr: The RMI Query base address
 172  * @command_base_addr: The RMI Command base address
 173  * @control_base_addr: The RMI Control base address
 174  * @data_base_addr: The RMI Data base address
 175  * @interrupt_source_count: The number of irqs this RMI function needs
 176  * @function_number: The RMI function number
 177  *
 178  * This struct is used when iterating the Page Description Table. The addresses
 179  * are 16-bit values to include the current page address.
 180  *
 181  */
 182 struct rmi_function_descriptor {
 183         u16 query_base_addr;
 184         u16 command_base_addr;
 185         u16 control_base_addr;
 186         u16 data_base_addr;
 187         u8 interrupt_source_count;
 188         u8 function_number;
 189         u8 function_version;
 190 };
 191
 192 struct rmi_device;
 193
 194 /**
 195  * struct rmi_transport_dev - represent an RMI transport device
 196  *
 197  * @dev: Pointer to the communication device, e.g. i2c or spi
 198  * @rmi_dev: Pointer to the RMI device
 199  * @proto_name: name of the transport protocol (SPI, i2c, etc)
 200  * @ops: pointer to transport operations implementation
 201  *
 202  * The RMI transport device implements the glue between different communication
 203  * buses such as I2C and SPI.
 204  *
 205  */
 206 struct rmi_transport_dev {
 207         struct device *dev;
 208         struct rmi_device *rmi_dev;
 209
 210         const char *proto_name;
 211         const struct rmi_transport_ops *ops;
 212
 213         struct rmi_device_platform_data pdata;
 214
 215         struct input_dev *input;
 216
 217         void *attn_data;
 218         int attn_size;
 219 };
 220
 221 /**
 222  * struct rmi_transport_ops - defines transport protocol operations.
 223  *
 224  * @write_block: Writing a block of data to the specified address
 225  * @read_block: Read a block of data from the specified address.
 226  */
 227 struct rmi_transport_ops {
 228         int (*write_block)(struct rmi_transport_dev *xport, u16 addr,
 229                            const void *buf, size_t len);
 230         int (*read_block)(struct rmi_transport_dev *xport, u16 addr,
 231                           void *buf, size_t len);
 232         int (*reset)(struct rmi_transport_dev *xport, u16 reset_addr);
 233 };
 234
 235 /**
 236  * struct rmi_driver - driver for an RMI4 sensor on the RMI bus.
 237  *
 238  * @driver: Device driver model driver
 239  * @reset_handler: Called when a reset is detected.
 240  * @clear_irq_bits: Clear the specified bits in the current interrupt mask.
 241  * @set_irq_bist: Set the specified bits in the current interrupt mask.
 242  * @store_productid: Callback for cache product id from function 01
 243  * @data: Private data pointer
 244  *
 245  */
 246 struct rmi_driver {
 247         struct device_driver driver;
 248
 249         int (*reset_handler)(struct rmi_device *rmi_dev);
 250         int (*clear_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
 251         int (*set_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
 252         int (*store_productid)(struct rmi_device *rmi_dev);
 253         int (*set_input_params)(struct rmi_device *rmi_dev,
 254                         struct input_dev *input);
 255         void *data;
 256 };
 257
 258 /**
 259  * struct rmi_device - represents an RMI4 sensor device on the RMI bus.
 260  *
 261  * @dev: The device created for the RMI bus
 262  * @number: Unique number for the device on the bus.
 263  * @driver: Pointer to associated driver
 264  * @xport: Pointer to the transport interface
 265  *
 266  */
 267 struct rmi_device {
 268         struct device dev;
 269         int number;
 270
 271         struct rmi_driver *driver;
 272         struct rmi_transport_dev *xport;
 273
 274 };
 275
 276 struct rmi_driver_data {
 277         struct list_head function_list;
 278
 279         struct rmi_device *rmi_dev;
 280
 281         struct rmi_function *f01_container;
 282         bool f01_bootloader_mode;
 283
 284         u32 attn_count;
 285         int num_of_irq_regs;
 286         int irq_count;
 287         unsigned long *irq_status;
 288         unsigned long *fn_irq_bits;
 289         unsigned long *current_irq_mask;
 290         unsigned long *new_irq_mask;
 291         struct mutex irq_mutex;
 292         struct input_dev *input;
 293
 294         u8 pdt_props;
 295         u8 bsr;
 296
 297         bool enabled;
 298
 299         void *data;
 300 };
 301
 302 int rmi_register_transport_device(struct rmi_transport_dev *xport);
 303 void rmi_unregister_transport_device(struct rmi_transport_dev *xport);
 304 int rmi_process_interrupt_requests(struct rmi_device *rmi_dev);
 305
 306 int rmi_driver_suspend(struct rmi_device *rmi_dev);
 307 int rmi_driver_resume(struct rmi_device *rmi_dev);
 308 #endif