| 1 |
/* SPDX-License-Identifier: GPL-2.0 */ |
| 2 |
|
| 3 |
/* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved. |
| 4 |
* Copyright (C) 2018-2024 Linaro Ltd. |
| 5 |
*/ |
| 6 |
#ifndef _GSI_H_ |
| 7 |
#define _GSI_H_ |
| 8 |
|
| 9 |
#include <linux/completion.h> |
| 10 |
#include <linux/mutex.h> |
| 11 |
#include <linux/netdevice.h> |
| 12 |
#include <linux/types.h> |
| 13 |
|
| 14 |
#include "ipa_version.h" |
| 15 |
|
| 16 |
/* Maximum number of channels and event rings supported by the driver */ |
| 17 |
#define GSI_CHANNEL_COUNT_MAX 28 |
| 18 |
#define GSI_EVT_RING_COUNT_MAX 28 |
| 19 |
|
| 20 |
/* Maximum TLV FIFO size for a channel; 64 here is arbitrary (and high) */ |
| 21 |
#define GSI_TLV_MAX 64 |
| 22 |
|
| 23 |
struct device; |
| 24 |
struct platform_device; |
| 25 |
|
| 26 |
struct gsi; |
| 27 |
struct gsi_trans; |
| 28 |
struct ipa_gsi_endpoint_data; |
| 29 |
|
| 30 |
struct gsi_ring { |
| 31 |
void *virt; /* ring array base address */ |
| 32 |
dma_addr_t addr; /* primarily low 32 bits used */ |
| 33 |
u32 count; /* number of elements in ring */ |
| 34 |
|
| 35 |
/* The ring index value indicates the next "open" entry in the ring. |
| 36 |
* |
| 37 |
* A channel ring consists of TRE entries filled by the AP and passed |
| 38 |
* to the hardware for processing. For a channel ring, the ring index |
| 39 |
* identifies the next unused entry to be filled by the AP. In this |
| 40 |
* case the initial value is assumed by hardware to be 0. |
| 41 |
* |
| 42 |
* An event ring consists of event structures filled by the hardware |
| 43 |
* and passed to the AP. For event rings, the ring index identifies |
| 44 |
* the next ring entry that is not known to have been filled by the |
| 45 |
* hardware. The initial value used is arbitrary (so we use 0). |
| 46 |
*/ |
| 47 |
u32 index; |
| 48 |
}; |
| 49 |
|
| 50 |
/* Transactions use several resources that can be allocated dynamically |
| 51 |
* but taken from a fixed-size pool. The number of elements required for |
| 52 |
* the pool is limited by the total number of TREs that can be outstanding. |
| 53 |
* |
| 54 |
* If sufficient TREs are available to reserve for a transaction, |
| 55 |
* allocation from these pools is guaranteed to succeed. Furthermore, |
| 56 |
* these resources are implicitly freed whenever the TREs in the |
| 57 |
* transaction they're associated with are released. |
| 58 |
* |
| 59 |
* The result of a pool allocation of multiple elements is always |
| 60 |
* contiguous. |
| 61 |
*/ |
| 62 |
struct gsi_trans_pool { |
| 63 |
void *base; /* base address of element pool */ |
| 64 |
u32 count; /* # elements in the pool */ |
| 65 |
u32 free; /* next free element in pool (modulo) */ |
| 66 |
u32 size; /* size (bytes) of an element */ |
| 67 |
u32 max_alloc; /* max allocation request */ |
| 68 |
dma_addr_t addr; /* DMA address if DMA pool (or 0) */ |
| 69 |
}; |
| 70 |
|
| 71 |
struct gsi_trans_info { |
| 72 |
atomic_t tre_avail; /* TREs available for allocation */ |
| 73 |
|
| 74 |
u16 free_id; /* first free trans in array */ |
| 75 |
u16 allocated_id; /* first allocated transaction */ |
| 76 |
u16 committed_id; /* first committed transaction */ |
| 77 |
u16 pending_id; /* first pending transaction */ |
| 78 |
u16 completed_id; /* first completed transaction */ |
| 79 |
u16 polled_id; /* first polled transaction */ |
| 80 |
struct gsi_trans *trans; /* transaction array */ |
| 81 |
struct gsi_trans **map; /* TRE -> transaction map */ |
| 82 |
|
| 83 |
struct gsi_trans_pool sg_pool; /* scatterlist pool */ |
| 84 |
struct gsi_trans_pool cmd_pool; /* command payload DMA pool */ |
| 85 |
}; |
| 86 |
|
| 87 |
/* Hardware values signifying the state of a channel */ |
| 88 |
enum gsi_channel_state { |
| 89 |
GSI_CHANNEL_STATE_NOT_ALLOCATED = 0x0, |
| 90 |
GSI_CHANNEL_STATE_ALLOCATED = 0x1, |
| 91 |
GSI_CHANNEL_STATE_STARTED = 0x2, |
| 92 |
GSI_CHANNEL_STATE_STOPPED = 0x3, |
| 93 |
GSI_CHANNEL_STATE_STOP_IN_PROC = 0x4, |
| 94 |
GSI_CHANNEL_STATE_FLOW_CONTROLLED = 0x5, /* IPA v4.2-v4.9 */ |
| 95 |
GSI_CHANNEL_STATE_ERROR = 0xf, |
| 96 |
}; |
| 97 |
|
| 98 |
/* We only care about channels between IPA and AP */ |
| 99 |
struct gsi_channel { |
| 100 |
struct gsi *gsi; |
| 101 |
bool toward_ipa; |
| 102 |
bool command; /* AP command TX channel or not */ |
| 103 |
|
| 104 |
u8 trans_tre_max; /* max TREs in a transaction */ |
| 105 |
u16 tre_count; |
| 106 |
u16 event_count; |
| 107 |
|
| 108 |
struct gsi_ring tre_ring; |
| 109 |
u32 evt_ring_id; |
| 110 |
|
| 111 |
/* The following counts are used only for TX endpoints */ |
| 112 |
u64 byte_count; /* total # bytes transferred */ |
| 113 |
u64 trans_count; /* total # transactions */ |
| 114 |
u64 queued_byte_count; /* last reported queued byte count */ |
| 115 |
u64 queued_trans_count; /* ...and queued trans count */ |
| 116 |
u64 compl_byte_count; /* last reported completed byte count */ |
| 117 |
u64 compl_trans_count; /* ...and completed trans count */ |
| 118 |
|
| 119 |
struct gsi_trans_info trans_info; |
| 120 |
|
| 121 |
struct napi_struct napi; |
| 122 |
}; |
| 123 |
|
| 124 |
/* Hardware values signifying the state of an event ring */ |
| 125 |
enum gsi_evt_ring_state { |
| 126 |
GSI_EVT_RING_STATE_NOT_ALLOCATED = 0x0, |
| 127 |
GSI_EVT_RING_STATE_ALLOCATED = 0x1, |
| 128 |
GSI_EVT_RING_STATE_ERROR = 0xf, |
| 129 |
}; |
| 130 |
|
| 131 |
struct gsi_evt_ring { |
| 132 |
struct gsi_channel *channel; |
| 133 |
struct gsi_ring ring; |
| 134 |
}; |
| 135 |
|
| 136 |
struct gsi { |
| 137 |
struct device *dev; /* Same as IPA device */ |
| 138 |
enum ipa_version version; |
| 139 |
void __iomem *virt; /* I/O mapped registers */ |
| 140 |
const struct regs *regs; |
| 141 |
|
| 142 |
u32 irq; |
| 143 |
u32 channel_count; |
| 144 |
u32 evt_ring_count; |
| 145 |
u32 event_bitmap; /* allocated event rings */ |
| 146 |
u32 modem_channel_bitmap; /* modem channels to allocate */ |
| 147 |
u32 type_enabled_bitmap; /* GSI IRQ types enabled */ |
| 148 |
u32 ieob_enabled_bitmap; /* IEOB IRQ enabled (event rings) */ |
| 149 |
int result; /* Negative errno (generic commands) */ |
| 150 |
struct completion completion; /* Signals GSI command completion */ |
| 151 |
struct mutex mutex; /* protects commands, programming */ |
| 152 |
struct gsi_channel channel[GSI_CHANNEL_COUNT_MAX]; |
| 153 |
struct gsi_evt_ring evt_ring[GSI_EVT_RING_COUNT_MAX]; |
| 154 |
struct net_device *dummy_dev; /* needed for NAPI */ |
| 155 |
}; |
| 156 |
|
| 157 |
/** |
| 158 |
* gsi_setup() - Set up the GSI subsystem |
| 159 |
* @gsi: Address of GSI structure embedded in an IPA structure |
| 160 |
* |
| 161 |
* Return: 0 if successful, or a negative error code |
| 162 |
* |
| 163 |
* Performs initialization that must wait until the GSI hardware is |
| 164 |
* ready (including firmware loaded). |
| 165 |
*/ |
| 166 |
int gsi_setup(struct gsi *gsi); |
| 167 |
|
| 168 |
/** |
| 169 |
* gsi_teardown() - Tear down GSI subsystem |
| 170 |
* @gsi: GSI address previously passed to a successful gsi_setup() call |
| 171 |
*/ |
| 172 |
void gsi_teardown(struct gsi *gsi); |
| 173 |
|
| 174 |
/** |
| 175 |
* gsi_channel_tre_max() - Channel maximum number of in-flight TREs |
| 176 |
* @gsi: GSI pointer |
| 177 |
* @channel_id: Channel whose limit is to be returned |
| 178 |
* |
| 179 |
* Return: The maximum number of TREs outstanding on the channel |
| 180 |
*/ |
| 181 |
u32 gsi_channel_tre_max(struct gsi *gsi, u32 channel_id); |
| 182 |
|
| 183 |
/** |
| 184 |
* gsi_channel_start() - Start an allocated GSI channel |
| 185 |
* @gsi: GSI pointer |
| 186 |
* @channel_id: Channel to start |
| 187 |
* |
| 188 |
* Return: 0 if successful, or a negative error code |
| 189 |
*/ |
| 190 |
int gsi_channel_start(struct gsi *gsi, u32 channel_id); |
| 191 |
|
| 192 |
/** |
| 193 |
* gsi_channel_stop() - Stop a started GSI channel |
| 194 |
* @gsi: GSI pointer returned by gsi_setup() |
| 195 |
* @channel_id: Channel to stop |
| 196 |
* |
| 197 |
* Return: 0 if successful, or a negative error code |
| 198 |
*/ |
| 199 |
int gsi_channel_stop(struct gsi *gsi, u32 channel_id); |
| 200 |
|
| 201 |
/** |
| 202 |
* gsi_modem_channel_flow_control() - Set channel flow control state (IPA v4.2+) |
| 203 |
* @gsi: GSI pointer returned by gsi_setup() |
| 204 |
* @channel_id: Modem TX channel to control |
| 205 |
* @enable: Whether to enable flow control (i.e., prevent flow) |
| 206 |
*/ |
| 207 |
void gsi_modem_channel_flow_control(struct gsi *gsi, u32 channel_id, |
| 208 |
bool enable); |
| 209 |
|
| 210 |
/** |
| 211 |
* gsi_channel_reset() - Reset an allocated GSI channel |
| 212 |
* @gsi: GSI pointer |
| 213 |
* @channel_id: Channel to be reset |
| 214 |
* @doorbell: Whether to (possibly) enable the doorbell engine |
| 215 |
* |
| 216 |
* Reset a channel and reconfigure it. The @doorbell flag indicates |
| 217 |
* that the doorbell engine should be enabled if needed. |
| 218 |
* |
| 219 |
* GSI hardware relinquishes ownership of all pending receive buffer |
| 220 |
* transactions and they will complete with their cancelled flag set. |
| 221 |
*/ |
| 222 |
void gsi_channel_reset(struct gsi *gsi, u32 channel_id, bool doorbell); |
| 223 |
|
| 224 |
/** |
| 225 |
* gsi_suspend() - Prepare the GSI subsystem for suspend |
| 226 |
* @gsi: GSI pointer |
| 227 |
*/ |
| 228 |
void gsi_suspend(struct gsi *gsi); |
| 229 |
|
| 230 |
/** |
| 231 |
* gsi_resume() - Resume the GSI subsystem following suspend |
| 232 |
* @gsi: GSI pointer |
| 233 |
*/ |
| 234 |
void gsi_resume(struct gsi *gsi); |
| 235 |
|
| 236 |
/** |
| 237 |
* gsi_channel_suspend() - Suspend a GSI channel |
| 238 |
* @gsi: GSI pointer |
| 239 |
* @channel_id: Channel to suspend |
| 240 |
* |
| 241 |
* For IPA v4.0+, suspend is implemented by stopping the channel. |
| 242 |
*/ |
| 243 |
int gsi_channel_suspend(struct gsi *gsi, u32 channel_id); |
| 244 |
|
| 245 |
/** |
| 246 |
* gsi_channel_resume() - Resume a suspended GSI channel |
| 247 |
* @gsi: GSI pointer |
| 248 |
* @channel_id: Channel to resume |
| 249 |
* |
| 250 |
* For IPA v4.0+, the stopped channel is started again. |
| 251 |
*/ |
| 252 |
int gsi_channel_resume(struct gsi *gsi, u32 channel_id); |
| 253 |
|
| 254 |
/** |
| 255 |
* gsi_init() - Initialize the GSI subsystem |
| 256 |
* @gsi: Address of GSI structure embedded in an IPA structure |
| 257 |
* @pdev: IPA platform device |
| 258 |
* @version: IPA hardware version (implies GSI version) |
| 259 |
* @count: Number of entries in the configuration data array |
| 260 |
* @data: Endpoint and channel configuration data |
| 261 |
* |
| 262 |
* Return: 0 if successful, or a negative error code |
| 263 |
* |
| 264 |
* Early stage initialization of the GSI subsystem, performing tasks |
| 265 |
* that can be done before the GSI hardware is ready to use. |
| 266 |
*/ |
| 267 |
int gsi_init(struct gsi *gsi, struct platform_device *pdev, |
| 268 |
enum ipa_version version, u32 count, |
| 269 |
const struct ipa_gsi_endpoint_data *data); |
| 270 |
|
| 271 |
/** |
| 272 |
* gsi_exit() - Exit the GSI subsystem |
| 273 |
* @gsi: GSI address previously passed to a successful gsi_init() call |
| 274 |
*/ |
| 275 |
void gsi_exit(struct gsi *gsi); |
| 276 |
|
| 277 |
#endif /* _GSI_H_ */ |