1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. 4 * Copyright (C) 2019-2020 Linaro Ltd. 5 */ 6 #ifndef _IPA_DATA_H_ 7 #define _IPA_DATA_H_ 8 9 #include <linux/types.h> 10 11 #include "ipa_version.h" 12 #include "ipa_endpoint.h" 13 #include "ipa_mem.h" 14 15 /** 16 * DOC: IPA/GSI Configuration Data 17 * 18 * Boot-time configuration data is used to define the configuration of the 19 * IPA and GSI resources to use for a given platform. This data is supplied 20 * via the Device Tree match table, associated with a particular compatible 21 * string. The data defines information about resources, endpoints, and 22 * channels. 23 * 24 * Resources are data structures used internally by the IPA hardware. The 25 * configuration data defines the number (or limits of the number) of various 26 * types of these resources. 27 * 28 * Endpoint configuration data defines properties of both IPA endpoints and 29 * GSI channels. A channel is a GSI construct, and represents a single 30 * communication path between the IPA and a particular execution environment 31 * (EE), such as the AP or Modem. Each EE has a set of channels associated 32 * with it, and each channel has an ID unique for that EE. For the most part 33 * the only GSI channels of concern to this driver belong to the AP 34 * 35 * An endpoint is an IPA construct representing a single channel anywhere 36 * in the system. An IPA endpoint ID maps directly to an (EE, channel_id) 37 * pair. Generally, this driver is concerned with only endpoints associated 38 * with the AP, however this will change when support for routing (etc.) is 39 * added. IPA endpoint and GSI channel configuration data are defined 40 * together, establishing the endpoint_id->(EE, channel_id) mapping. 41 * 42 * Endpoint configuration data consists of three parts: properties that 43 * are common to IPA and GSI (EE ID, channel ID, endpoint ID, and direction); 44 * properties associated with the GSI channel; and properties associated with 45 * the IPA endpoint. 46 */ 47 48 /* The maximum value returned by ipa_resource_group_{src,dst}_count() */ 49 #define IPA_RESOURCE_GROUP_SRC_MAX 5 50 #define IPA_RESOURCE_GROUP_DST_MAX 5 51 52 /** 53 * struct gsi_channel_data - GSI channel configuration data 54 * @tre_count: number of TREs in the channel ring 55 * @event_count: number of slots in the associated event ring 56 * @tlv_count: number of entries in channel's TLV FIFO 57 * 58 * A GSI channel is a unidirectional means of transferring data to or 59 * from (and through) the IPA. A GSI channel has a ring buffer made 60 * up of "transfer elements" (TREs) that specify individual data transfers 61 * or IPA immediate commands. TREs are filled by the AP, and control 62 * is passed to IPA hardware by writing the last written element 63 * into a doorbell register. 64 * 65 * When data transfer commands have completed the GSI generates an 66 * event (a structure of data) and optionally signals the AP with 67 * an interrupt. Event structures are implemented by another ring 68 * buffer, directed toward the AP from the IPA. 69 * 70 * The input to a GSI channel is a FIFO of type/length/value (TLV) 71 * elements, and the size of this FIFO limits the number of TREs 72 * that can be included in a single transaction. 73 */ 74 struct gsi_channel_data { 75 u16 tre_count; 76 u16 event_count; 77 u8 tlv_count; 78 }; 79 80 /** 81 * struct ipa_endpoint_tx_data - configuration data for TX endpoints 82 * @status_endpoint: endpoint to which status elements are sent 83 * 84 * The @status_endpoint is only valid if the endpoint's @status_enable 85 * flag is set. 86 */ 87 struct ipa_endpoint_tx_data { 88 enum ipa_endpoint_name status_endpoint; 89 }; 90 91 /** 92 * struct ipa_endpoint_rx_data - configuration data for RX endpoints 93 * @pad_align: power-of-2 boundary to which packet payload is aligned 94 * @aggr_close_eof: whether aggregation closes on end-of-frame 95 * 96 * With each packet it transfers, the IPA hardware can perform certain 97 * transformations of its packet data. One of these is adding pad bytes 98 * to the end of the packet data so the result ends on a power-of-2 boundary. 99 * 100 * It is also able to aggregate multiple packets into a single receive buffer. 101 * Aggregation is "open" while a buffer is being filled, and "closes" when 102 * certain criteria are met. One of those criteria is the sender indicating 103 * a "frame" consisting of several transfers has ended. 104 */ 105 struct ipa_endpoint_rx_data { 106 u32 pad_align; 107 bool aggr_close_eof; 108 }; 109 110 /** 111 * struct ipa_endpoint_config_data - IPA endpoint hardware configuration 112 * @resource_group: resource group to assign endpoint to 113 * @checksum: whether checksum offload is enabled 114 * @qmap: whether endpoint uses QMAP protocol 115 * @aggregation: whether endpoint supports aggregation 116 * @status_enable: whether endpoint uses status elements 117 * @dma_mode: whether endpoint operates in DMA mode 118 * @dma_endpoint: peer endpoint, if operating in DMA mode 119 * @tx: TX-specific endpoint information (see above) 120 * @rx: RX-specific endpoint information (see above) 121 */ 122 struct ipa_endpoint_config_data { 123 u32 resource_group; 124 bool checksum; 125 bool qmap; 126 bool aggregation; 127 bool status_enable; 128 bool dma_mode; 129 enum ipa_endpoint_name dma_endpoint; 130 union { 131 struct ipa_endpoint_tx_data tx; 132 struct ipa_endpoint_rx_data rx; 133 }; 134 }; 135 136 /** 137 * struct ipa_endpoint_data - IPA endpoint configuration data 138 * @filter_support: whether endpoint supports filtering 139 * @seq_type: hardware sequencer type used for endpoint 140 * @config: hardware configuration (see above) 141 * 142 * Not all endpoints support the IPA filtering capability. A filter table 143 * defines the filters to apply for those endpoints that support it. The 144 * AP is responsible for initializing this table, and it must include entries 145 * for non-AP endpoints. For this reason we define *all* endpoints used 146 * in the system, and indicate whether they support filtering. 147 * 148 * The remaining endpoint configuration data applies only to AP endpoints. 149 * The IPA hardware is implemented by sequencers, and the AP must program 150 * the type(s) of these sequencers at initialization time. The remaining 151 * endpoint configuration data is defined above. 152 */ 153 struct ipa_endpoint_data { 154 bool filter_support; 155 /* The next two are specified only for AP endpoints */ 156 enum ipa_seq_type seq_type; 157 struct ipa_endpoint_config_data config; 158 }; 159 160 /** 161 * struct ipa_gsi_endpoint_data - GSI channel/IPA endpoint data 162 * ee: GSI execution environment ID 163 * channel_id: GSI channel ID 164 * endpoint_id: IPA endpoint ID 165 * toward_ipa: direction of data transfer 166 * gsi: GSI channel configuration data (see above) 167 * ipa: IPA endpoint configuration data (see above) 168 */ 169 struct ipa_gsi_endpoint_data { 170 u8 ee_id; /* enum gsi_ee_id */ 171 u8 channel_id; 172 u8 endpoint_id; 173 bool toward_ipa; 174 175 struct gsi_channel_data channel; 176 struct ipa_endpoint_data endpoint; 177 }; 178 179 /** enum ipa_resource_type_src - source resource types */ 180 enum ipa_resource_type_src { 181 IPA_RESOURCE_TYPE_SRC_PKT_CONTEXTS, 182 IPA_RESOURCE_TYPE_SRC_DESCRIPTOR_LISTS, 183 IPA_RESOURCE_TYPE_SRC_DESCRIPTOR_BUFF, 184 IPA_RESOURCE_TYPE_SRC_HPS_DMARS, 185 IPA_RESOURCE_TYPE_SRC_ACK_ENTRIES, 186 }; 187 188 /** enum ipa_resource_type_dst - destination resource types */ 189 enum ipa_resource_type_dst { 190 IPA_RESOURCE_TYPE_DST_DATA_SECTORS, 191 IPA_RESOURCE_TYPE_DST_DPS_DMARS, 192 }; 193 194 /** 195 * struct ipa_resource_limits - minimum and maximum resource counts 196 * @min: minimum number of resources of a given type 197 * @max: maximum number of resources of a given type 198 */ 199 struct ipa_resource_limits { 200 u32 min; 201 u32 max; 202 }; 203 204 /** 205 * struct ipa_resource_src - source endpoint group resource usage 206 * @type: source group resource type 207 * @limits: array of limits to use for each resource group 208 */ 209 struct ipa_resource_src { 210 enum ipa_resource_type_src type; 211 struct ipa_resource_limits limits[IPA_RESOURCE_GROUP_SRC_MAX]; 212 }; 213 214 /** 215 * struct ipa_resource_dst - destination endpoint group resource usage 216 * @type: destination group resource type 217 * @limits: array of limits to use for each resource group 218 */ 219 struct ipa_resource_dst { 220 enum ipa_resource_type_dst type; 221 struct ipa_resource_limits limits[IPA_RESOURCE_GROUP_DST_MAX]; 222 }; 223 224 /** 225 * struct ipa_resource_data - IPA resource configuration data 226 * @resource_src_count: number of entries in the resource_src array 227 * @resource_src: source endpoint group resources 228 * @resource_dst_count: number of entries in the resource_dst array 229 * @resource_dst: destination endpoint group resources 230 * 231 * In order to manage quality of service between endpoints, certain resources 232 * required for operation are allocated to groups of endpoints. Generally 233 * this information is invisible to the AP, but the AP is responsible for 234 * programming it at initialization time, so we specify it here. 235 */ 236 struct ipa_resource_data { 237 u32 resource_src_count; 238 const struct ipa_resource_src *resource_src; 239 u32 resource_dst_count; 240 const struct ipa_resource_dst *resource_dst; 241 }; 242 243 /** 244 * struct ipa_mem_data - description of IPA memory regions 245 * @local_count: number of regions defined in the local[] array 246 * @local: array of IPA-local memory region descriptors 247 * @imem_addr: physical address of IPA region within IMEM 248 * @imem_size: size in bytes of IPA IMEM region 249 * @smem_id: item identifier for IPA region within SMEM memory 250 * @imem_size: size in bytes of the IPA SMEM region 251 */ 252 struct ipa_mem_data { 253 u32 local_count; 254 const struct ipa_mem *local; 255 u32 imem_addr; 256 u32 imem_size; 257 u32 smem_id; 258 u32 smem_size; 259 }; 260 261 /** 262 * struct ipa_interconnect_data - description of IPA interconnect bandwidths 263 * @name: Interconnect name (matches interconnect-name in DT) 264 * @peak_bandwidth: Peak interconnect bandwidth (in 1000 byte/sec units) 265 * @average_bandwidth: Average interconnect bandwidth (in 1000 byte/sec units) 266 */ 267 struct ipa_interconnect_data { 268 const char *name; 269 u32 peak_bandwidth; 270 u32 average_bandwidth; 271 }; 272 273 /** 274 * struct ipa_clock_data - description of IPA clock and interconnect rates 275 * @core_clock_rate: Core clock rate (Hz) 276 * @interconnect_count: Number of entries in the interconnect_data array 277 * @interconnect_data: IPA interconnect configuration data 278 */ 279 struct ipa_clock_data { 280 u32 core_clock_rate; 281 u32 interconnect_count; /* # entries in interconnect_data[] */ 282 const struct ipa_interconnect_data *interconnect_data; 283 }; 284 285 /** 286 * struct ipa_data - combined IPA/GSI configuration data 287 * @version: IPA hardware version 288 * @endpoint_count: number of entries in endpoint_data array 289 * @endpoint_data: IPA endpoint/GSI channel data 290 * @resource_data: IPA resource configuration data 291 * @mem_count: number of entries in mem_data array 292 * @mem_data: IPA-local shared memory region data 293 */ 294 struct ipa_data { 295 enum ipa_version version; 296 u32 endpoint_count; /* # entries in endpoint_data[] */ 297 const struct ipa_gsi_endpoint_data *endpoint_data; 298 const struct ipa_resource_data *resource_data; 299 const struct ipa_mem_data *mem_data; 300 const struct ipa_clock_data *clock_data; 301 }; 302 303 extern const struct ipa_data ipa_data_sdm845; 304 extern const struct ipa_data ipa_data_sc7180; 305 306 #endif /* _IPA_DATA_H_ */ 307