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
23struct device;
24struct platform_device;
25
26struct gsi;
27struct gsi_trans;
28struct ipa_gsi_endpoint_data;
29
30struct 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 */
62struct 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
71struct 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 */
88enum 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 */
99struct 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 */
125enum 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
131struct gsi_evt_ring {
132 struct gsi_channel *channel;
133 struct gsi_ring ring;
134};
135
136struct 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 */
166int 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 */
172void 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 */
181u32 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 */
190int 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 */
199int 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 */
207void 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 */
222void 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 */
228void gsi_suspend(struct gsi *gsi);
229
230/**
231 * gsi_resume() - Resume the GSI subsystem following suspend
232 * @gsi: GSI pointer
233 */
234void 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 */
243int 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 */
252int 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 */
267int 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 */
275void gsi_exit(struct gsi *gsi);
276
277#endif /* _GSI_H_ */
278

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