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

source code of linux/drivers/net/ipa/gsi.h