1 /* SPDX-License-Identifier: GPL-2.0
2 *
3 * Copyright 2008-2013 Solarflare Communications Inc.
4 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
5 */
6
7 #ifndef CDX_MCDI_H
8 #define CDX_MCDI_H
9
10 #include <linux/mutex.h>
11 #include <linux/kref.h>
12 #include <linux/rpmsg.h>
13
14 #include "bitfield.h"
15 #include "mc_cdx_pcol.h"
16
17 #ifdef DEBUG
18 #define CDX_WARN_ON_ONCE_PARANOID(x) WARN_ON_ONCE(x)
19 #define CDX_WARN_ON_PARANOID(x) WARN_ON(x)
20 #else
21 #define CDX_WARN_ON_ONCE_PARANOID(x) do {} while (0)
22 #define CDX_WARN_ON_PARANOID(x) do {} while (0)
23 #endif
24
25 /**
26 * enum cdx_mcdi_mode - MCDI transaction mode
27 * @MCDI_MODE_EVENTS: wait for an mcdi response callback.
28 * @MCDI_MODE_FAIL: we think MCDI is dead, so fail-fast all calls
29 */
30 enum cdx_mcdi_mode {
31 MCDI_MODE_EVENTS,
32 MCDI_MODE_FAIL,
33 };
34
35 #define MCDI_RPC_TIMEOUT (10 * HZ)
36 #define MCDI_RPC_LONG_TIMEOU (60 * HZ)
37 #define MCDI_RPC_POST_RST_TIME (10 * HZ)
38
39 #define MCDI_BUF_LEN (8 + MCDI_CTL_SDU_LEN_MAX)
40
41 /**
42 * enum cdx_mcdi_cmd_state - State for an individual MCDI command
43 * @MCDI_STATE_QUEUED: Command not started and is waiting to run.
44 * @MCDI_STATE_RETRY: Command was submitted and MC rejected with no resources,
45 * as MC have too many outstanding commands. Command will be retried once
46 * another command returns.
47 * @MCDI_STATE_RUNNING: Command was accepted and is running.
48 * @MCDI_STATE_RUNNING_CANCELLED: Command is running but the issuer cancelled
49 * the command.
50 * @MCDI_STATE_FINISHED: Processing of this command has completed.
51 */
52
53 enum cdx_mcdi_cmd_state {
54 MCDI_STATE_QUEUED,
55 MCDI_STATE_RETRY,
56 MCDI_STATE_RUNNING,
57 MCDI_STATE_RUNNING_CANCELLED,
58 MCDI_STATE_FINISHED,
59 };
60
61 /**
62 * struct cdx_mcdi - CDX MCDI Firmware interface, to interact
63 * with CDX controller.
64 * @mcdi: MCDI interface
65 * @mcdi_ops: MCDI operations
66 * @r5_rproc : R5 Remoteproc device handle
67 * @rpdev: RPMsg device
68 * @ept: RPMsg endpoint
69 * @work: Post probe work
70 */
71 struct cdx_mcdi {
72 /* MCDI interface */
73 struct cdx_mcdi_data *mcdi;
74 const struct cdx_mcdi_ops *mcdi_ops;
75
76 struct rproc *r5_rproc;
77 struct rpmsg_device *rpdev;
78 struct rpmsg_endpoint *ept;
79 struct work_struct work;
80 };
81
82 struct cdx_mcdi_ops {
83 void (*mcdi_request)(struct cdx_mcdi *cdx,
84 const struct cdx_dword *hdr, size_t hdr_len,
85 const struct cdx_dword *sdu, size_t sdu_len);
86 unsigned int (*mcdi_rpc_timeout)(struct cdx_mcdi *cdx, unsigned int cmd);
87 };
88
89 typedef void cdx_mcdi_async_completer(struct cdx_mcdi *cdx,
90 unsigned long cookie, int rc,
91 struct cdx_dword *outbuf,
92 size_t outlen_actual);
93
94 /**
95 * struct cdx_mcdi_cmd - An outstanding MCDI command
96 * @ref: Reference count. There will be one reference if the command is
97 * in the mcdi_iface cmd_list, another if it's on a cleanup list,
98 * and a third if it's queued in the work queue.
99 * @list: The data for this entry in mcdi->cmd_list
100 * @cleanup_list: The data for this entry in a cleanup list
101 * @work: The work item for this command, queued in mcdi->workqueue
102 * @mcdi: The mcdi_iface for this command
103 * @state: The state of this command
104 * @inlen: inbuf length
105 * @inbuf: Input buffer
106 * @quiet: Whether to silence errors
107 * @reboot_seen: Whether a reboot has been seen during this command,
108 * to prevent duplicates
109 * @seq: Sequence number
110 * @started: Jiffies this command was started at
111 * @cookie: Context for completion function
112 * @completer: Completion function
113 * @handle: Command handle
114 * @cmd: Command number
115 * @rc: Return code
116 * @outlen: Length of output buffer
117 * @outbuf: Output buffer
118 */
119 struct cdx_mcdi_cmd {
120 struct kref ref;
121 struct list_head list;
122 struct list_head cleanup_list;
123 struct work_struct work;
124 struct cdx_mcdi_iface *mcdi;
125 enum cdx_mcdi_cmd_state state;
126 size_t inlen;
127 const struct cdx_dword *inbuf;
128 bool quiet;
129 bool reboot_seen;
130 u8 seq;
131 unsigned long started;
132 unsigned long cookie;
133 cdx_mcdi_async_completer *completer;
134 unsigned int handle;
135 unsigned int cmd;
136 int rc;
137 size_t outlen;
138 struct cdx_dword *outbuf;
139 /* followed by inbuf data if necessary */
140 };
141
142 /**
143 * struct cdx_mcdi_iface - MCDI protocol context
144 * @cdx: The associated NIC
145 * @iface_lock: Serialise access to this structure
146 * @outstanding_cleanups: Count of cleanups
147 * @cmd_list: List of outstanding and running commands
148 * @workqueue: Workqueue used for delayed processing
149 * @cmd_complete_wq: Waitqueue for command completion
150 * @db_held_by: Command the MC doorbell is in use by
151 * @seq_held_by: Command each sequence number is in use by
152 * @prev_handle: The last used command handle
153 * @mode: Poll for mcdi completion, or wait for an mcdi_event
154 * @prev_seq: The last used sequence number
155 * @new_epoch: Indicates start of day or start of MC reboot recovery
156 */
157 struct cdx_mcdi_iface {
158 struct cdx_mcdi *cdx;
159 /* Serialise access */
160 struct mutex iface_lock;
161 unsigned int outstanding_cleanups;
162 struct list_head cmd_list;
163 struct workqueue_struct *workqueue;
164 wait_queue_head_t cmd_complete_wq;
165 struct cdx_mcdi_cmd *db_held_by;
166 struct cdx_mcdi_cmd *seq_held_by[16];
167 unsigned int prev_handle;
168 enum cdx_mcdi_mode mode;
169 u8 prev_seq;
170 bool new_epoch;
171 };
172
173 /**
174 * struct cdx_mcdi_data - extra state for NICs that implement MCDI
175 * @iface: Interface/protocol state
176 * @fn_flags: Flags for this function, as returned by %MC_CMD_DRV_ATTACH.
177 */
178 struct cdx_mcdi_data {
179 struct cdx_mcdi_iface iface;
180 u32 fn_flags;
181 };
182
cdx_mcdi_if(struct cdx_mcdi * cdx)183 static inline struct cdx_mcdi_iface *cdx_mcdi_if(struct cdx_mcdi *cdx)
184 {
185 return cdx->mcdi ? &cdx->mcdi->iface : NULL;
186 }
187
188 int cdx_mcdi_init(struct cdx_mcdi *cdx);
189 void cdx_mcdi_finish(struct cdx_mcdi *cdx);
190
191 void cdx_mcdi_process_cmd(struct cdx_mcdi *cdx, struct cdx_dword *outbuf, int len);
192 int cdx_mcdi_rpc(struct cdx_mcdi *cdx, unsigned int cmd,
193 const struct cdx_dword *inbuf, size_t inlen,
194 struct cdx_dword *outbuf, size_t outlen, size_t *outlen_actual);
195 int cdx_mcdi_rpc_async(struct cdx_mcdi *cdx, unsigned int cmd,
196 const struct cdx_dword *inbuf, size_t inlen,
197 cdx_mcdi_async_completer *complete,
198 unsigned long cookie);
199 int cdx_mcdi_wait_for_quiescence(struct cdx_mcdi *cdx,
200 unsigned int timeout_jiffies);
201
202 /*
203 * We expect that 16- and 32-bit fields in MCDI requests and responses
204 * are appropriately aligned, but 64-bit fields are only
205 * 32-bit-aligned.
206 */
207 #define MCDI_DECLARE_BUF(_name, _len) struct cdx_dword _name[DIV_ROUND_UP(_len, 4)] = {{0}}
208 #define _MCDI_PTR(_buf, _offset) \
209 ((u8 *)(_buf) + (_offset))
210 #define MCDI_PTR(_buf, _field) \
211 _MCDI_PTR(_buf, MC_CMD_ ## _field ## _OFST)
212 #define _MCDI_CHECK_ALIGN(_ofst, _align) \
213 ((void)BUILD_BUG_ON_ZERO((_ofst) & ((_align) - 1)), \
214 (_ofst))
215 #define _MCDI_DWORD(_buf, _field) \
216 ((_buf) + (_MCDI_CHECK_ALIGN(MC_CMD_ ## _field ## _OFST, 4) >> 2))
217
218 #define MCDI_BYTE(_buf, _field) \
219 ((void)BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 1), \
220 *MCDI_PTR(_buf, _field))
221 #define MCDI_WORD(_buf, _field) \
222 ((void)BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 2), \
223 le16_to_cpu(*(__force const __le16 *)MCDI_PTR(_buf, _field)))
224 #define MCDI_SET_DWORD(_buf, _field, _value) \
225 CDX_POPULATE_DWORD_1(*_MCDI_DWORD(_buf, _field), CDX_DWORD, _value)
226 #define MCDI_DWORD(_buf, _field) \
227 CDX_DWORD_FIELD(*_MCDI_DWORD(_buf, _field), CDX_DWORD)
228 #define MCDI_POPULATE_DWORD_1(_buf, _field, _name1, _value1) \
229 CDX_POPULATE_DWORD_1(*_MCDI_DWORD(_buf, _field), \
230 MC_CMD_ ## _name1, _value1)
231 #define MCDI_SET_QWORD(_buf, _field, _value) \
232 do { \
233 CDX_POPULATE_DWORD_1(_MCDI_DWORD(_buf, _field)[0], \
234 CDX_DWORD, (u32)(_value)); \
235 CDX_POPULATE_DWORD_1(_MCDI_DWORD(_buf, _field)[1], \
236 CDX_DWORD, (u64)(_value) >> 32); \
237 } while (0)
238 #define MCDI_QWORD(_buf, _field) \
239 (CDX_DWORD_FIELD(_MCDI_DWORD(_buf, _field)[0], CDX_DWORD) | \
240 (u64)CDX_DWORD_FIELD(_MCDI_DWORD(_buf, _field)[1], CDX_DWORD) << 32)
241
242 #endif /* CDX_MCDI_H */
243