/* SPDX-License-Identifier: GPL-2.0 */ /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * Copyright (C) 2019-2020 Linaro Ltd. */#ifndef _IPA_DATA_H_#define _IPA_DATA_H_ #include <linux/types.h> #include "ipa_version.h"#include "ipa_endpoint.h"#include "ipa_mem.h" /** * DOC: IPA/GSI Configuration Data * * Boot-time configuration data is used to define the configuration of the * IPA and GSI resources to use for a given platform.  This data is supplied * via the Device Tree match table, associated with a particular compatible * string.  The data defines information about resources, endpoints, and * channels. * * Resources are data structures used internally by the IPA hardware.  The * configuration data defines the number (or limits of the number) of various * types of these resources. * * Endpoint configuration data defines properties of both IPA endpoints and * GSI channels.  A channel is a GSI construct, and represents a single * communication path between the IPA and a particular execution environment * (EE), such as the AP or Modem.  Each EE has a set of channels associated * with it, and each channel has an ID unique for that EE.  For the most part * the only GSI channels of concern to this driver belong to the AP * * An endpoint is an IPA construct representing a single channel anywhere * in the system.  An IPA endpoint ID maps directly to an (EE, channel_id) * pair.  Generally, this driver is concerned with only endpoints associated * with the AP, however this will change when support for routing (etc.) is * added.  IPA endpoint and GSI channel configuration data are defined * together, establishing the endpoint_id->(EE, channel_id) mapping. * * Endpoint configuration data consists of three parts:  properties that * are common to IPA and GSI (EE ID, channel ID, endpoint ID, and direction); * properties associated with the GSI channel; and properties associated with * the IPA endpoint. */ /* The maximum value returned by ipa_resource_group_count() */#define IPA_RESOURCE_GROUP_COUNT	4 /** enum ipa_resource_type_src - source resource types *//** * struct gsi_channel_data - GSI channel configuration data * @tre_count:		number of TREs in the channel ring * @event_count:	number of slots in the associated event ring * @tlv_count:		number of entries in channel's TLV FIFO * * A GSI channel is a unidirectional means of transferring data to or * from (and through) the IPA.  A GSI channel has a ring buffer made * up of "transfer elements" (TREs) that specify individual data transfers * or IPA immediate commands.  TREs are filled by the AP, and control * is passed to IPA hardware by writing the last written element * into a doorbell register. * * When data transfer commands have completed the GSI generates an * event (a structure of data) and optionally signals the AP with * an interrupt.  Event structures are implemented by another ring * buffer, directed toward the AP from the IPA. * * The input to a GSI channel is a FIFO of type/length/value (TLV) * elements, and the size of this FIFO limits the number of TREs * that can be included in a single transaction. */struct gsi_channel_data {	u16 tre_count;	u16 event_count;	u8 tlv_count;}; /** * struct ipa_endpoint_tx_data - configuration data for TX endpoints * @status_endpoint:	endpoint to which status elements are sent * @delay:		whether endpoint starts in delay mode * * Delay mode prevents a TX endpoint from transmitting anything, even if * commands have been presented to the hardware.  Once the endpoint exits * delay mode, queued transfer commands are sent. * * The @status_endpoint is only valid if the endpoint's @status_enable * flag is set. */struct ipa_endpoint_tx_data {	enum ipa_endpoint_name status_endpoint;	bool delay;}; /** * struct ipa_endpoint_rx_data - configuration data for RX endpoints * @pad_align:	power-of-2 boundary to which packet payload is aligned * @aggr_close_eof: whether aggregation closes on end-of-frame * * With each packet it transfers, the IPA hardware can perform certain * transformations of its packet data.  One of these is adding pad bytes * to the end of the packet data so the result ends on a power-of-2 boundary. * * It is also able to aggregate multiple packets into a single receive buffer. * Aggregation is "open" while a buffer is being filled, and "closes" when * certain criteria are met.  One of those criteria is the sender indicating * a "frame" consisting of several transfers has ended. */struct ipa_endpoint_rx_data {	u32 pad_align;	bool aggr_close_eof;}; /** * struct ipa_endpoint_config_data - IPA endpoint hardware configuration * @checksum:		whether checksum offload is enabled * @qmap:		whether endpoint uses QMAP protocol * @aggregation:	whether endpoint supports aggregation * @status_enable:	whether endpoint uses status elements * @dma_mode:		whether endpoint operates in DMA mode * @dma_endpoint:	peer endpoint, if operating in DMA mode * @tx:			TX-specific endpoint information (see above) * @rx:			RX-specific endpoint information (see above) */struct ipa_endpoint_config_data {	bool checksum;	bool qmap;	bool aggregation;	bool status_enable;	bool dma_mode;	enum ipa_endpoint_name dma_endpoint;	union {		struct ipa_endpoint_tx_data tx;		struct ipa_endpoint_rx_data rx;	};}; /** * struct ipa_endpoint_data - IPA endpoint configuration data * @filter_support:	whether endpoint supports filtering * @seq_type:		hardware sequencer type used for endpoint * @config:		hardware configuration (see above) * * Not all endpoints support the IPA filtering capability.  A filter table * defines the filters to apply for those endpoints that support it.  The * AP is responsible for initializing this table, and it must include entries * for non-AP endpoints.  For this reason we define *all* endpoints used * in the system, and indicate whether they support filtering. * * The remaining endpoint configuration data applies only to AP endpoints. * The IPA hardware is implemented by sequencers, and the AP must program * the type(s) of these sequencers at initialization time.  The remaining * endpoint configuration data is defined above. */struct ipa_endpoint_data {	bool filter_support;	/* The next two are specified only for AP endpoints */	enum ipa_seq_type seq_type;	struct ipa_endpoint_config_data config;}; /** * struct ipa_gsi_endpoint_data - GSI channel/IPA endpoint data * ee:		GSI execution environment ID * channel_id:	GSI channel ID * endpoint_id:	IPA endpoint ID * toward_ipa:	direction of data transfer * gsi:		GSI channel configuration data (see above) * ipa:		IPA endpoint configuration data (see above) */struct ipa_gsi_endpoint_data {	u8 ee_id;		/* enum gsi_ee_id */	u8 channel_id;	u8 endpoint_id;	bool toward_ipa; 	struct gsi_channel_data channel;	struct ipa_endpoint_data endpoint;}; /** enum ipa_resource_type_src - source resource types */enum ipa_resource_type_src {	IPA_RESOURCE_TYPE_SRC_PKT_CONTEXTS,	IPA_RESOURCE_TYPE_SRC_DESCRIPTOR_LISTS,	IPA_RESOURCE_TYPE_SRC_DESCRIPTOR_BUFF,	IPA_RESOURCE_TYPE_SRC_HPS_DMARS,	IPA_RESOURCE_TYPE_SRC_ACK_ENTRIES,}; /** enum ipa_resource_type_dst - destination resource types */enum ipa_resource_type_dst {	IPA_RESOURCE_TYPE_DST_DATA_SECTORS,	IPA_RESOURCE_TYPE_DST_DPS_DMARS,}; /** * struct ipa_resource_limits - minimum and maximum resource counts * @min:	minimum number of resources of a given type * @max:	maximum number of resources of a given type */struct ipa_resource_limits {	u32 min;	u32 max;}; /** * struct ipa_resource_src - source endpoint group resource usage * @type:	source group resource type * @limits:	array of limits to use for each resource group */struct ipa_resource_src {	enum ipa_resource_type_src type;	struct ipa_resource_limits limits[IPA_RESOURCE_GROUP_COUNT];}; /** * struct ipa_resource_dst - destination endpoint group resource usage * @type:	destination group resource type * @limits:	array of limits to use for each resource group */struct ipa_resource_dst {	enum ipa_resource_type_dst type;	struct ipa_resource_limits limits[IPA_RESOURCE_GROUP_COUNT];}; /** * struct ipa_resource_data - IPA resource configuration data * @resource_src_count:	number of entries in the resource_src array * @resource_src:	source endpoint group resources * @resource_dst_count:	number of entries in the resource_dst array * @resource_dst:	destination endpoint group resources * * In order to manage quality of service between endpoints, certain resources * required for operation are allocated to groups of endpoints.  Generally * this information is invisible to the AP, but the AP is responsible for * programming it at initialization time, so we specify it here. */struct ipa_resource_data {	u32 resource_src_count;	const struct ipa_resource_src *resource_src;	u32 resource_dst_count;	const struct ipa_resource_dst *resource_dst;}; /** * struct ipa_mem - IPA-local memory region description * @offset:		offset in IPA memory space to base of the region * @size:		size in bytes base of the region * @canary_count:	number of 32-bit "canary" values that precede region */struct ipa_mem_data {	u32 offset;	u16 size;	u16 canary_count;}; /** * struct ipa_data - combined IPA/GSI configuration data * @version:		IPA hardware version * @endpoint_count:	number of entries in endpoint_data array * @endpoint_data:	IPA endpoint/GSI channel data * @resource_data:	IPA resource configuration data * @mem_count:		number of entries in mem_data array * @mem_data:		IPA-local shared memory region data */struct ipa_data {	enum ipa_version version;	u32 endpoint_count;	/* # entries in endpoint_data[] */	const struct ipa_gsi_endpoint_data *endpoint_data;	const struct ipa_resource_data *resource_data;	u32 mem_count;		/* # entries in mem_data[] */	const struct ipa_mem *mem_data;}; extern const struct ipa_data ipa_data_sdm845;extern const struct ipa_data ipa_data_sc7180; #endif /* _IPA_DATA_H_ */