/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */

#ifndef _TOUCH_OFFLOAD_H
#define _TOUCH_OFFLOAD_H

#define TOUCH_OFFLOAD_INTERFACE_MAJOR_VERSION 2
#define TOUCH_OFFLOAD_INTERFACE_MINOR_VERSION 0

#define TOUCH_OFFLOAD_MAGIC '7'

/* Bus interface type */
#define BUS_TYPE_I2C 0
#define BUS_TYPE_SPI 1
#define BUS_TYPE_I3C 2

/* Indicates full heatmap frame vs. partial */
#define HEATMAP_SIZE_PARTIAL  0
#define HEATMAP_SIZE_FULL     1

/* Touch channel data types */
#define TOUCH_DATA_TYPE_COORD	  0x0001
#define TOUCH_DATA_TYPE_RAW	  0x0002
#define TOUCH_DATA_TYPE_FILTERED  0x0004
#define TOUCH_DATA_TYPE_BASELINE  0x0008
#define TOUCH_DATA_TYPE_STRENGTH  0x0010

/* Touch channel scan types */
#define TOUCH_SCAN_TYPE_MUTUAL	  0x0040
#define TOUCH_SCAN_TYPE_SELF	  0x0080

/* "Context" channel types */
#define CONTEXT_CHANNEL_TYPE_DRIVER_STATUS  0x0100
#define CONTEXT_CHANNEL_TYPE_STYLUS_STATUS  0x0200
/* Inclusive range of valid context channels */
#define CONTEXT_CHANNEL_BIT_START 0x0100
#define CONTEXT_CHANNEL_BIT_END   0x0200

//////////////////////////////////////////////////////////////

/* TouchOffloadCaps
 *
 * touch_offload_major_version - Major version for breaking changes
 * touch_offload_minor_version - Minor version for small, compatible changes
 * device_id - device-specific identifier
 * display_width - width of device display in pixels
 * display_height - height of device display in pixels
 * tx_size - number of TX channels
 * rx_size - number of RX channels
 * bus_type - bus interface type
 * bus_speed_hz - bus frequency
 * heatmap_size - partial or full heatmap
 * touch_data_scan_types - channel data types available
 * touch_scan_types - channel scan types available
 * context_channel_types - bitfield of additional supported channels
 * continuous_reporting - driver supports continuous touch reports
 * noise_reporting - driver supports noise status messages
 * cancel_reporting - driver supports sending cancel events
 * size_reporting - driver supports size information
 * rotation_reporting - driver supports rotation information
 * filter_grip - driver supports disabling underlying grip suppression
 * filter_palm - driver supports disabling underlying palm rejection
 * num_sensitivity_settings - number of sensitivity options provided
 * auto_reporting - report heatmap when screen is not touched
 */
struct TouchOffloadCaps {
	/* Version info */
	__u32 touch_offload_major_version;
	__u32 touch_offload_minor_version;
	__u8 reserved1[8];

	/* Device info */
	__u32 device_id;
	__u16 display_width;
	__u16 display_height;
	__u16 tx_size;
	__u16 rx_size;
	__u8 bus_type;
	__u32 bus_speed_hz;
	__u8 reserved2[16];

	/* Algorithm info */
	__u8 heatmap_size;
	__u16 touch_data_types;
	__u16 touch_scan_types;
	__u16 context_channel_types;
	__u8 reserved3[16];

	/* Feature flags */
	__u8 continuous_reporting;
	__u8 noise_reporting;
	__u8 cancel_reporting;
	__u8 size_reporting;
	__u8 rotation_reporting;
	__u8 filter_grip;
	__u8 filter_palm;
	__u8 num_sensitivity_settings;
	__u8 auto_reporting;
	__u8 reserved4[32];
} __attribute__((packed));

/* TouchOffloadConfig
 *
 * continuous_reporting - enable continuous touch reports
 * noise_reporting - enable noise status messages
 * cancel_reporting - enable cancel events
 * filter_grip - enable underlying grip suppression
 * filter_palm - enable underlying palm rejection
 * sensitivity_setting - selected sensitivity
 * auto_reporting - enable reporting when screen is not touched
 * read_coords - allocate a channel to coordinate data
 * mutual_data_types - bitfield of mutual data types to collect
 * self_data_types - bitfield of self data types to collect
 * context_channel_types - bitfield of context channels to collect - overlays
 *                         on channel type bit mask
 */
struct TouchOffloadConfig {
	/* Feature flags */
	__u8 continuous_reporting;
	__u8 noise_reporting;
	__u8 cancel_reporting;
	__u8 filter_grip;
	__u8 filter_palm;
	__u8 sensitivity_setting;
	__u8 auto_reporting;
	__u8 reserved1[16];

	/* Data to read */
	__u8 read_coords;
	__u16 mutual_data_types;
	__u16 self_data_types;
	__u16 context_channel_types;
	__u8 reserved2[16];
} __attribute__((packed));

/* TouchOffloadFrameHeader
 *
 * frame_size - number of bytes in the frame
 * index - unique, sequential frame index
 * timestamp - frame timestamp in nanoseconds
 * num_channels - number of channels included in the frame
 */
struct TouchOffloadFrameHeader {
	__u32 frame_size;
	__u64 index;
	__u64 timestamp;
	__u8 num_channels;
} __attribute__((packed));

/* TouchOffloadChannelHeader
 *
 * channel_type - touch type stored in the channel
 * channel_size - size in bytes of the channel sample
 */
struct TouchOffloadChannelHeader {
	__u32 channel_type;
	__u32 channel_size;
} __attribute__((packed));

/* CoordStatus
 *
 * COORD_STATUS_INACTIVE - slot is unused
 * COORD_STATUS_FINGER - normal finger touch
 * COORD_STATUS_EDGE - edge touch
 * COORD_STATUS_PALM - palm touch
 * COORD_STATUS_CANCEL - canceled touch
 * COORD_STATUS_PEN - stylus pen touch
 */
enum CoordStatus {
	COORD_STATUS_INACTIVE = 0x00,
	COORD_STATUS_FINGER = 0x01,
	COORD_STATUS_EDGE = 0x02,
	COORD_STATUS_PALM = 0x03,
	COORD_STATUS_CANCEL = 0x04,
	COORD_STATUS_PEN = 0x05
};

/* Maximum number of touches that are tracked simultaneously */
#define MAX_COORDS 10

/* TouchOffloadCoord
 *
 * x - x component of touch location
 * y - y component of touch location
 * status - type of touch
 * major - size of the larger axis of the touch blob
 * minor - size of the smaller axis of the touch blob
 * pressure - z-axis or force exerted on touch touch point
 * rotation - signed rotation of major axis from y-axis, where -16384 is a
 *            full rotation to the left and 16384 is a rotation to the right.
 */
struct TouchOffloadCoord {
	__u16 x;
	__u16 y;
	enum CoordStatus status;
	__u32 major;
	__u32 minor;
	__u32 pressure;
	__s16 rotation;
	__u8 reserved1[16];
} __attribute__((packed));

/* TouchOffloadDataCoord
 *
 * header - header shared by all channels in a frame
 * coords - array of MAX_COORD coordinates
 */
struct TouchOffloadDataCoord {
	struct TouchOffloadChannelHeader header;
	struct TouchOffloadCoord coords[MAX_COORDS];
	__u8 reserved1[16];
} __attribute__((packed));
#define TOUCH_OFFLOAD_FRAME_SIZE_COORD (sizeof(struct TouchOffloadDataCoord))

/* TouchOffloadData2d
 *
 * header - header shared by all channels in a frame
 * tx_size - number of tx channels
 * rx_size - number of rx channels
 * data - pointer to raw touch data buffer
 */
struct TouchOffloadData2d {
	struct TouchOffloadChannelHeader header;
	__u16 tx_size;
	__u16 rx_size;
	__u8 reserved1[16];
	__u8 data[1];
} __attribute__((packed));
#define TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx) (sizeof(__u16)*(rx)*(tx))
#define TOUCH_OFFLOAD_FRAME_SIZE_2D(rx, tx) \
	(sizeof(struct TouchOffloadData2d) - 1 + \
	TOUCH_OFFLOAD_DATA_SIZE_2D((rx), (tx)))

/* TouchOffloadData1d
 *
 * header - header shared by all channels in a frame
 * tx_size - number of tx channels
 * rx_size - number of rx channels
 * data - pointer to raw touch data buffer
 */
struct TouchOffloadData1d {
	struct TouchOffloadChannelHeader header;
	__u16 tx_size;
	__u16 rx_size;
	__u8 reserved1[16];
	__u8 data[1];
} __attribute__((packed));
#define TOUCH_OFFLOAD_DATA_SIZE_1D(rx, tx) (sizeof(__u16)*((rx)+(tx)))
#define TOUCH_OFFLOAD_FRAME_SIZE_1D(rx, tx) \
	(sizeof(struct TouchOffloadData1d) - 1 + \
	TOUCH_OFFLOAD_DATA_SIZE_1D((rx), (tx)))

/* TouchOffloadDriverStatus
 *
 * header - header shared by all channels in a frame
 * contents - bitfield indicating the corresponding data field is valid
 * screen_state - 0 = off, 1 = on
 * display_refresh_rate - display refresh rate in hz
 * touch_report_rate - touch report rate in hz
 * noise_state - 0 = no noise, 1 = noise present
 * water_mode - 0 = normal mode, 1 = water mode
 * charger_state - 0 = no charger, 1 = charger connected
 * hinge_angle - angle in range [0=closed, 32767=open 360 degrees]
 * offload_timestamp - recorded when touch offload frame was generated
 */
struct TouchOffloadDriverStatus {
	struct TouchOffloadChannelHeader header;

	struct {
		__u32 screen_state : 1;
		__u32 display_refresh_rate : 1;
		__u32 touch_report_rate : 1;
		__u32 noise_state : 1;
		__u32 water_mode : 1;
		__u32 charger_state : 1;
		__u32 hinge_angle : 1;
		__u32 offload_timestamp : 1;
	} contents;
	__u8 reserved1[8];

	__u8 screen_state;
	__u8 display_refresh_rate;
	__u8 touch_report_rate;
	__u8 noise_state;
	__u8 water_mode;
	__u8 charger_state;
	__s16 hinge_angle;

	__u64 offload_timestamp;

	__u8 reserved2[32];
} __attribute__((packed));
#define TOUCH_OFFLOAD_FRAME_SIZE_DRIVER_STATUS \
		(sizeof(struct TouchOffloadDriverStatus))

/* TouchOffloadStylusStatus
 *
 * header - header shared by all channels in a frame
 * contents - bitfield indicating the corresponding data field is valid
 * coords - Up to MAX_COORDS active stylus touch points
 * coords_timestamp - timestamp at which stylus coordinates were received
 * pen_paired - 0 = no pen paired, 1 = a pen paired
 * pen_active - 0 = no activity, 1 = a pen is actively communicating
 */
struct TouchOffloadStylusStatus {
	struct TouchOffloadChannelHeader header;

	struct {
		__u32 coords : 1;
		__u32 coords_timestamp : 1;
		__u32 pen_paired : 1;
		__u32 pen_active : 1;
	} contents;
	__u8 reserved1[8];

	struct TouchOffloadCoord coords[MAX_COORDS];
	__u64 coords_timestamp;
	__u8 reserved2[16];

	__u8 pen_paired;
	__u8 pen_active;
	__u8 reserved3[16];
} __attribute__((packed));
#define TOUCH_OFFLOAD_FRAME_SIZE_STYLUS_STATUS \
		(sizeof(struct TouchOffloadStylusStatus))

////////////////////////////////////////////////////////////

/* TouchOffloadIocGetCaps
 *
 * caps - capabilities provided by the touch driver
 */
struct TouchOffloadIocGetCaps {
	struct TouchOffloadCaps caps;
	__u8 reserved1[16];
} __attribute__((packed));

/* TouchOffloadIocConfigure
 *
 * config - features to be used by the touch_offload client
 */
struct TouchOffloadIocConfigure {
	struct TouchOffloadConfig config;
	__u8 reserved1[16];
} __attribute__((packed));

/* TouchOffloadIocReport
 *
 * index - unique, sequential frame index
 * timestamp - frame timestamp in nanoseconds
 * num_coords - number of coordinates contained in "coords"
 * coords - array of coordinates to be reported to the driver
 */
struct TouchOffloadIocReport {
	__u64 index;
	__u64 timestamp;
	__u8 num_coords;
	__u8 reserved1[16];
	struct TouchOffloadCoord coords[MAX_COORDS];
} __attribute__((packed));

/* Ioctl to retrieve the capabilities of the touch driver */
#define TOUCH_OFFLOAD_IOC_RD_GETCAPS \
	_IOR(TOUCH_OFFLOAD_MAGIC, 0, struct TouchOffloadIocGetCaps)

/* Ioctl to set the configuration of the touch driver */
#define TOUCH_OFFLOAD_IOC_WR_CONFIGURE \
	_IOW(TOUCH_OFFLOAD_MAGIC, 1, struct TouchOffloadIocConfigure)

/* Ioctl to start the touch_offload pipeline */
#define TOUCH_OFFLOAD_IOC_START _IOC(TOUCH_OFFLOAD_MAGIC, 2)

/* Ioctl to report coordinates to the driver */
#define TOUCH_OFFLOAD_IOC_WR_REPORT \
	_IOW(TOUCH_OFFLOAD_MAGIC, 3, struct TouchOffloadIocReport)

/* Ioctl to stop the touch_offload pipeline */
#define TOUCH_OFFLOAD_IOC_STOP _IOC(TOUCH_OFFLOAD_MAGIC, 4)

#endif /* _TOUCH_OFFLOAD_H */