xref: /openbmc/linux/drivers/net/ethernet/sfc/mcdi.h (revision 01ad088f)
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /****************************************************************************
3  * Driver for Solarflare network controllers and boards
4  * Copyright 2008-2013 Solarflare Communications Inc.
5  */
6 
7 #ifndef EFX_MCDI_H
8 #define EFX_MCDI_H
9 
10 /**
11  * enum efx_mcdi_state - MCDI request handling state
12  * @MCDI_STATE_QUIESCENT: No pending MCDI requests. If the caller holds the
13  *	mcdi @iface_lock then they are able to move to %MCDI_STATE_RUNNING
14  * @MCDI_STATE_RUNNING_SYNC: There is a synchronous MCDI request pending.
15  *	Only the thread that moved into this state is allowed to move out of it.
16  * @MCDI_STATE_RUNNING_ASYNC: There is an asynchronous MCDI request pending.
17  * @MCDI_STATE_PROXY_WAIT: An MCDI request has completed with a response that
18  *	indicates we must wait for a proxy try again message.
19  * @MCDI_STATE_COMPLETED: An MCDI request has completed, but the owning thread
20  *	has not yet consumed the result. For all other threads, equivalent to
21  *	%MCDI_STATE_RUNNING.
22  */
23 enum efx_mcdi_state {
24 	MCDI_STATE_QUIESCENT,
25 	MCDI_STATE_RUNNING_SYNC,
26 	MCDI_STATE_RUNNING_ASYNC,
27 	MCDI_STATE_PROXY_WAIT,
28 	MCDI_STATE_COMPLETED,
29 };
30 
31 /**
32  * enum efx_mcdi_mode - MCDI transaction mode
33  * @MCDI_MODE_POLL: poll for MCDI completion, until timeout
34  * @MCDI_MODE_EVENTS: wait for an mcdi_event.  On timeout, poll once
35  * @MCDI_MODE_FAIL: we think MCDI is dead, so fail-fast all calls
36  */
37 enum efx_mcdi_mode {
38 	MCDI_MODE_POLL,
39 	MCDI_MODE_EVENTS,
40 	MCDI_MODE_FAIL,
41 };
42 
43 /**
44  * struct efx_mcdi_iface - MCDI protocol context
45  * @efx: The associated NIC.
46  * @state: Request handling state. Waited for by @wq.
47  * @mode: Poll for mcdi completion, or wait for an mcdi_event.
48  * @wq: Wait queue for threads waiting for @state != %MCDI_STATE_RUNNING
49  * @new_epoch: Indicates start of day or start of MC reboot recovery
50  * @iface_lock: Serialises access to @seqno, @credits and response metadata
51  * @seqno: The next sequence number to use for mcdi requests.
52  * @credits: Number of spurious MCDI completion events allowed before we
53  *     trigger a fatal error
54  * @resprc: Response error/success code (Linux numbering)
55  * @resp_hdr_len: Response header length
56  * @resp_data_len: Response data (SDU or error) length
57  * @async_lock: Serialises access to @async_list while event processing is
58  *	enabled
59  * @async_list: Queue of asynchronous requests
60  * @async_timer: Timer for asynchronous request timeout
61  * @logging_buffer: buffer that may be used to build MCDI tracing messages
62  * @logging_enabled: whether to trace MCDI
63  * @proxy_rx_handle: Most recently received proxy authorisation handle
64  * @proxy_rx_status: Status of most recent proxy authorisation
65  * @proxy_rx_wq: Wait queue for updates to proxy_rx_handle
66  */
67 struct efx_mcdi_iface {
68 	struct efx_nic *efx;
69 	enum efx_mcdi_state state;
70 	enum efx_mcdi_mode mode;
71 	wait_queue_head_t wq;
72 	spinlock_t iface_lock;
73 	bool new_epoch;
74 	unsigned int credits;
75 	unsigned int seqno;
76 	int resprc;
77 	int resprc_raw;
78 	size_t resp_hdr_len;
79 	size_t resp_data_len;
80 	spinlock_t async_lock;
81 	struct list_head async_list;
82 	struct timer_list async_timer;
83 #ifdef CONFIG_SFC_MCDI_LOGGING
84 	char *logging_buffer;
85 	bool logging_enabled;
86 #endif
87 	unsigned int proxy_rx_handle;
88 	int proxy_rx_status;
89 	wait_queue_head_t proxy_rx_wq;
90 };
91 
92 struct efx_mcdi_mon {
93 	struct efx_buffer dma_buf;
94 	struct mutex update_lock;
95 	unsigned long last_update;
96 	struct device *device;
97 	struct efx_mcdi_mon_attribute *attrs;
98 	struct attribute_group group;
99 	const struct attribute_group *groups[2];
100 	unsigned int n_attrs;
101 };
102 
103 struct efx_mcdi_mtd_partition {
104 	struct efx_mtd_partition common;
105 	bool updating;
106 	u16 nvram_type;
107 	u16 fw_subtype;
108 };
109 
110 #define to_efx_mcdi_mtd_partition(mtd)				\
111 	container_of(mtd, struct efx_mcdi_mtd_partition, common.mtd)
112 
113 /**
114  * struct efx_mcdi_data - extra state for NICs that implement MCDI
115  * @iface: Interface/protocol state
116  * @hwmon: Hardware monitor state
117  * @fn_flags: Flags for this function, as returned by %MC_CMD_DRV_ATTACH.
118  */
119 struct efx_mcdi_data {
120 	struct efx_mcdi_iface iface;
121 #ifdef CONFIG_SFC_MCDI_MON
122 	struct efx_mcdi_mon hwmon;
123 #endif
124 	u32 fn_flags;
125 };
126 
efx_mcdi(struct efx_nic * efx)127 static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
128 {
129 	EFX_WARN_ON_PARANOID(!efx->mcdi);
130 	return &efx->mcdi->iface;
131 }
132 
133 #ifdef CONFIG_SFC_MCDI_MON
efx_mcdi_mon(struct efx_nic * efx)134 static inline struct efx_mcdi_mon *efx_mcdi_mon(struct efx_nic *efx)
135 {
136 	EFX_WARN_ON_PARANOID(!efx->mcdi);
137 	return &efx->mcdi->hwmon;
138 }
139 #endif
140 
141 int efx_mcdi_init(struct efx_nic *efx);
142 void efx_mcdi_detach(struct efx_nic *efx);
143 void efx_mcdi_fini(struct efx_nic *efx);
144 
145 int efx_mcdi_rpc(struct efx_nic *efx, unsigned cmd, const efx_dword_t *inbuf,
146 		 size_t inlen, efx_dword_t *outbuf, size_t outlen,
147 		 size_t *outlen_actual);
148 int efx_mcdi_rpc_quiet(struct efx_nic *efx, unsigned cmd,
149 		       const efx_dword_t *inbuf, size_t inlen,
150 		       efx_dword_t *outbuf, size_t outlen,
151 		       size_t *outlen_actual);
152 
153 int efx_mcdi_rpc_start(struct efx_nic *efx, unsigned cmd,
154 		       const efx_dword_t *inbuf, size_t inlen);
155 int efx_mcdi_rpc_finish(struct efx_nic *efx, unsigned cmd, size_t inlen,
156 			efx_dword_t *outbuf, size_t outlen,
157 			size_t *outlen_actual);
158 int efx_mcdi_rpc_finish_quiet(struct efx_nic *efx, unsigned cmd,
159 			      size_t inlen, efx_dword_t *outbuf,
160 			      size_t outlen, size_t *outlen_actual);
161 
162 typedef void efx_mcdi_async_completer(struct efx_nic *efx,
163 				      unsigned long cookie, int rc,
164 				      efx_dword_t *outbuf,
165 				      size_t outlen_actual);
166 int efx_mcdi_rpc_async(struct efx_nic *efx, unsigned int cmd,
167 		       const efx_dword_t *inbuf, size_t inlen, size_t outlen,
168 		       efx_mcdi_async_completer *complete,
169 		       unsigned long cookie);
170 int efx_mcdi_rpc_async_quiet(struct efx_nic *efx, unsigned int cmd,
171 			     const efx_dword_t *inbuf, size_t inlen,
172 			     size_t outlen,
173 			     efx_mcdi_async_completer *complete,
174 			     unsigned long cookie);
175 
176 void efx_mcdi_display_error(struct efx_nic *efx, unsigned cmd,
177 			    size_t inlen, efx_dword_t *outbuf,
178 			    size_t outlen, int rc);
179 
180 int efx_mcdi_poll_reboot(struct efx_nic *efx);
181 void efx_mcdi_mode_poll(struct efx_nic *efx);
182 void efx_mcdi_mode_event(struct efx_nic *efx);
183 void efx_mcdi_flush_async(struct efx_nic *efx);
184 
185 void efx_mcdi_process_event(struct efx_channel *channel, efx_qword_t *event);
186 void efx_mcdi_sensor_event(struct efx_nic *efx, efx_qword_t *ev);
187 
188 /* We expect that 16- and 32-bit fields in MCDI requests and responses
189  * are appropriately aligned, but 64-bit fields are only
190  * 32-bit-aligned.  Also, on Siena we must copy to the MC shared
191  * memory strictly 32 bits at a time, so add any necessary padding.
192  */
193 #define MCDI_TX_BUF_LEN(_len) DIV_ROUND_UP((_len), 4)
194 #define _MCDI_DECLARE_BUF(_name, _len)					\
195 	efx_dword_t _name[DIV_ROUND_UP(_len, 4)]
196 #define MCDI_DECLARE_BUF(_name, _len)					\
197 	_MCDI_DECLARE_BUF(_name, _len) = {{{0}}}
198 #define MCDI_DECLARE_BUF_ERR(_name)					\
199 	MCDI_DECLARE_BUF(_name, 8)
200 #define _MCDI_PTR(_buf, _offset)					\
201 	((u8 *)(_buf) + (_offset))
202 #define MCDI_PTR(_buf, _field)						\
203 	_MCDI_PTR(_buf, MC_CMD_ ## _field ## _OFST)
204 /* Use MCDI_STRUCT_ functions to access members of MCDI structuredefs.
205  * _buf should point to the start of the structure, typically obtained with
206  * MCDI_DECLARE_STRUCT_PTR(structure) = _MCDI_DWORD(mcdi_buf, FIELD_WHICH_IS_STRUCT);
207  */
208 #define MCDI_STRUCT_PTR(_buf, _field)					\
209 	_MCDI_PTR(_buf, _field ## _OFST)
210 #define _MCDI_CHECK_ALIGN(_ofst, _align)				\
211 	((_ofst) + BUILD_BUG_ON_ZERO((_ofst) & (_align - 1)))
212 #define _MCDI_DWORD(_buf, _field)					\
213 	((_buf) + (_MCDI_CHECK_ALIGN(MC_CMD_ ## _field ## _OFST, 4) >> 2))
214 #define _MCDI_STRUCT_DWORD(_buf, _field)				\
215 	((_buf) + (_MCDI_CHECK_ALIGN(_field ## _OFST, 4) >> 2))
216 
217 #define MCDI_STRUCT_SET_BYTE(_buf, _field, _value) do {			\
218 	BUILD_BUG_ON(_field ## _LEN != 1);				\
219 	*(u8 *)MCDI_STRUCT_PTR(_buf, _field) = _value;			\
220 	} while (0)
221 #define MCDI_STRUCT_POPULATE_BYTE_1(_buf, _field, _name, _value) do {	\
222 	efx_dword_t _temp;						\
223 	EFX_POPULATE_DWORD_1(_temp, _name, _value);			\
224 	MCDI_STRUCT_SET_BYTE(_buf, _field,				\
225 			     EFX_DWORD_FIELD(_temp, EFX_BYTE_0));	\
226 	} while (0)
227 #define MCDI_BYTE(_buf, _field)						\
228 	((void)BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 1),	\
229 	 *MCDI_PTR(_buf, _field))
230 #define MCDI_STRUCT_BYTE(_buf, _field)					\
231 	((void)BUILD_BUG_ON_ZERO(_field ## _LEN != 1),			\
232 	 *MCDI_STRUCT_PTR(_buf, _field))
233 #define MCDI_SET_WORD(_buf, _field, _value) do {			\
234 	BUILD_BUG_ON(MC_CMD_ ## _field ## _LEN != 2);			\
235 	BUILD_BUG_ON(MC_CMD_ ## _field ## _OFST & 1);			\
236 	*(__force __le16 *)MCDI_PTR(_buf, _field) = cpu_to_le16(_value);\
237 	} while (0)
238 #define MCDI_STRUCT_SET_WORD(_buf, _field, _value) do {			\
239 	BUILD_BUG_ON(_field ## _LEN != 2);				\
240 	BUILD_BUG_ON(_field ## _OFST & 1);				\
241 	*(__force __le16 *)MCDI_STRUCT_PTR(_buf, _field) = cpu_to_le16(_value);\
242 	} while (0)
243 #define MCDI_WORD(_buf, _field)						\
244 	((u16)BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 2) +	\
245 	 le16_to_cpu(*(__force const __le16 *)MCDI_PTR(_buf, _field)))
246 #define MCDI_STRUCT_WORD(_buf, _field)                                  \
247 	((void)BUILD_BUG_ON_ZERO(_field ## _LEN != 2),  \
248 	le16_to_cpu(*(__force const __le16 *)MCDI_STRUCT_PTR(_buf, _field)))
249 /* Write a 16-bit field defined in the protocol as being big-endian. */
250 #define MCDI_SET_WORD_BE(_buf, _field, _value) do {			\
251 	BUILD_BUG_ON(MC_CMD_ ## _field ## _LEN != 2);			\
252 	BUILD_BUG_ON(MC_CMD_ ## _field ## _OFST & 1);			\
253 	*(__force __be16 *)MCDI_PTR(_buf, _field) = (_value);		\
254 	} while (0)
255 #define MCDI_STRUCT_SET_WORD_BE(_buf, _field, _value) do {		\
256 	BUILD_BUG_ON(_field ## _LEN != 2);				\
257 	BUILD_BUG_ON(_field ## _OFST & 1);				\
258 	*(__force __be16 *)MCDI_STRUCT_PTR(_buf, _field) = (_value);	\
259 	} while (0)
260 #define MCDI_SET_DWORD(_buf, _field, _value)				\
261 	EFX_POPULATE_DWORD_1(*_MCDI_DWORD(_buf, _field), EFX_DWORD_0, _value)
262 #define MCDI_STRUCT_SET_DWORD(_buf, _field, _value)			\
263 	EFX_POPULATE_DWORD_1(*_MCDI_STRUCT_DWORD(_buf, _field), EFX_DWORD_0, _value)
264 #define MCDI_DWORD(_buf, _field)					\
265 	EFX_DWORD_FIELD(*_MCDI_DWORD(_buf, _field), EFX_DWORD_0)
266 #define MCDI_STRUCT_DWORD(_buf, _field)                                 \
267 	EFX_DWORD_FIELD(*_MCDI_STRUCT_DWORD(_buf, _field), EFX_DWORD_0)
268 /* Write a 32-bit field defined in the protocol as being big-endian. */
269 #define MCDI_STRUCT_SET_DWORD_BE(_buf, _field, _value) do {		\
270 	BUILD_BUG_ON(_field ## _LEN != 4);				\
271 	BUILD_BUG_ON(_field ## _OFST & 3);				\
272 	*(__force __be32 *)MCDI_STRUCT_PTR(_buf, _field) = (_value);	\
273 	} while (0)
274 #define MCDI_POPULATE_DWORD_1(_buf, _field, _name1, _value1)		\
275 	EFX_POPULATE_DWORD_1(*_MCDI_DWORD(_buf, _field),		\
276 			     MC_CMD_ ## _name1, _value1)
277 #define MCDI_POPULATE_DWORD_2(_buf, _field, _name1, _value1,		\
278 			      _name2, _value2)				\
279 	EFX_POPULATE_DWORD_2(*_MCDI_DWORD(_buf, _field),		\
280 			     MC_CMD_ ## _name1, _value1,		\
281 			     MC_CMD_ ## _name2, _value2)
282 #define MCDI_POPULATE_DWORD_3(_buf, _field, _name1, _value1,		\
283 			      _name2, _value2, _name3, _value3)		\
284 	EFX_POPULATE_DWORD_3(*_MCDI_DWORD(_buf, _field),		\
285 			     MC_CMD_ ## _name1, _value1,		\
286 			     MC_CMD_ ## _name2, _value2,		\
287 			     MC_CMD_ ## _name3, _value3)
288 #define MCDI_POPULATE_DWORD_4(_buf, _field, _name1, _value1,		\
289 			      _name2, _value2, _name3, _value3,		\
290 			      _name4, _value4)				\
291 	EFX_POPULATE_DWORD_4(*_MCDI_DWORD(_buf, _field),		\
292 			     MC_CMD_ ## _name1, _value1,		\
293 			     MC_CMD_ ## _name2, _value2,		\
294 			     MC_CMD_ ## _name3, _value3,		\
295 			     MC_CMD_ ## _name4, _value4)
296 #define MCDI_POPULATE_DWORD_5(_buf, _field, _name1, _value1,		\
297 			      _name2, _value2, _name3, _value3,		\
298 			      _name4, _value4, _name5, _value5)		\
299 	EFX_POPULATE_DWORD_5(*_MCDI_DWORD(_buf, _field),		\
300 			     MC_CMD_ ## _name1, _value1,		\
301 			     MC_CMD_ ## _name2, _value2,		\
302 			     MC_CMD_ ## _name3, _value3,		\
303 			     MC_CMD_ ## _name4, _value4,		\
304 			     MC_CMD_ ## _name5, _value5)
305 #define MCDI_POPULATE_DWORD_6(_buf, _field, _name1, _value1,		\
306 			      _name2, _value2, _name3, _value3,		\
307 			      _name4, _value4, _name5, _value5,		\
308 			      _name6, _value6)				\
309 	EFX_POPULATE_DWORD_6(*_MCDI_DWORD(_buf, _field),		\
310 			     MC_CMD_ ## _name1, _value1,		\
311 			     MC_CMD_ ## _name2, _value2,		\
312 			     MC_CMD_ ## _name3, _value3,		\
313 			     MC_CMD_ ## _name4, _value4,		\
314 			     MC_CMD_ ## _name5, _value5,		\
315 			     MC_CMD_ ## _name6, _value6)
316 #define MCDI_POPULATE_DWORD_7(_buf, _field, _name1, _value1,		\
317 			      _name2, _value2, _name3, _value3,		\
318 			      _name4, _value4, _name5, _value5,		\
319 			      _name6, _value6, _name7, _value7)		\
320 	EFX_POPULATE_DWORD_7(*_MCDI_DWORD(_buf, _field),		\
321 			     MC_CMD_ ## _name1, _value1,		\
322 			     MC_CMD_ ## _name2, _value2,		\
323 			     MC_CMD_ ## _name3, _value3,		\
324 			     MC_CMD_ ## _name4, _value4,		\
325 			     MC_CMD_ ## _name5, _value5,		\
326 			     MC_CMD_ ## _name6, _value6,		\
327 			     MC_CMD_ ## _name7, _value7)
328 #define MCDI_SET_QWORD(_buf, _field, _value)				\
329 	do {								\
330 		EFX_POPULATE_DWORD_1(_MCDI_DWORD(_buf, _field)[0],	\
331 				     EFX_DWORD_0, (u32)(_value));	\
332 		EFX_POPULATE_DWORD_1(_MCDI_DWORD(_buf, _field)[1],	\
333 				     EFX_DWORD_0, (u64)(_value) >> 32);	\
334 	} while (0)
335 #define MCDI_QWORD(_buf, _field)					\
336 	(EFX_DWORD_FIELD(_MCDI_DWORD(_buf, _field)[0], EFX_DWORD_0) |	\
337 	(u64)EFX_DWORD_FIELD(_MCDI_DWORD(_buf, _field)[1], EFX_DWORD_0) << 32)
338 #define MCDI_FIELD(_ptr, _type, _field)					\
339 	EFX_EXTRACT_DWORD(						\
340 		*(efx_dword_t *)					\
341 		_MCDI_PTR(_ptr, MC_CMD_ ## _type ## _ ## _field ## _OFST & ~3),\
342 		MC_CMD_ ## _type ## _ ## _field ## _LBN & 0x1f,	\
343 		(MC_CMD_ ## _type ## _ ## _field ## _LBN & 0x1f) +	\
344 		MC_CMD_ ## _type ## _ ## _field ## _WIDTH - 1)
345 
346 #define _MCDI_ARRAY_PTR(_buf, _field, _index, _align)			\
347 	(_MCDI_PTR(_buf, _MCDI_CHECK_ALIGN(MC_CMD_ ## _field ## _OFST, _align))\
348 	 + (_index) * _MCDI_CHECK_ALIGN(MC_CMD_ ## _field ## _LEN, _align))
349 #define MCDI_DECLARE_STRUCT_PTR(_name)					\
350 	efx_dword_t *_name
351 #define MCDI_ARRAY_STRUCT_PTR(_buf, _field, _index)			\
352 	((efx_dword_t *)_MCDI_ARRAY_PTR(_buf, _field, _index, 4))
353 #define MCDI_VAR_ARRAY_LEN(_len, _field)				\
354 	min_t(size_t, MC_CMD_ ## _field ## _MAXNUM,			\
355 	      ((_len) - MC_CMD_ ## _field ## _OFST) / MC_CMD_ ## _field ## _LEN)
356 #define MCDI_ARRAY_WORD(_buf, _field, _index)				\
357 	(BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 2) +		\
358 	 le16_to_cpu(*(__force const __le16 *)				\
359 		     _MCDI_ARRAY_PTR(_buf, _field, _index, 2)))
360 #define _MCDI_ARRAY_DWORD(_buf, _field, _index)				\
361 	(BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 4) +		\
362 	 (efx_dword_t *)_MCDI_ARRAY_PTR(_buf, _field, _index, 4))
363 #define MCDI_SET_ARRAY_DWORD(_buf, _field, _index, _value)		\
364 	EFX_SET_DWORD_FIELD(*_MCDI_ARRAY_DWORD(_buf, _field, _index),	\
365 			    EFX_DWORD_0, _value)
366 #define MCDI_ARRAY_DWORD(_buf, _field, _index)				\
367 	EFX_DWORD_FIELD(*_MCDI_ARRAY_DWORD(_buf, _field, _index), EFX_DWORD_0)
368 #define _MCDI_ARRAY_QWORD(_buf, _field, _index)				\
369 	(BUILD_BUG_ON_ZERO(MC_CMD_ ## _field ## _LEN != 8) +		\
370 	 (efx_dword_t *)_MCDI_ARRAY_PTR(_buf, _field, _index, 4))
371 #define MCDI_SET_ARRAY_QWORD(_buf, _field, _index, _value)		\
372 	do {								\
373 		EFX_SET_DWORD_FIELD(_MCDI_ARRAY_QWORD(_buf, _field, _index)[0],\
374 				    EFX_DWORD_0, (u32)(_value));	\
375 		EFX_SET_DWORD_FIELD(_MCDI_ARRAY_QWORD(_buf, _field, _index)[1],\
376 				    EFX_DWORD_0, (u64)(_value) >> 32);	\
377 	} while (0)
378 #define MCDI_ARRAY_FIELD(_buf, _field1, _type, _index, _field2)		\
379 	MCDI_FIELD(MCDI_ARRAY_STRUCT_PTR(_buf, _field1, _index),	\
380 		   _type ## _TYPEDEF, _field2)
381 
382 #define MCDI_EVENT_FIELD(_ev, _field)			\
383 	EFX_QWORD_FIELD(_ev, MCDI_EVENT_ ## _field)
384 
385 #define MCDI_CAPABILITY(field)						\
386 	MC_CMD_GET_CAPABILITIES_V8_OUT_ ## field ## _LBN
387 
388 #define MCDI_CAPABILITY_OFST(field) \
389 	MC_CMD_GET_CAPABILITIES_V8_OUT_ ## field ## _OFST
390 
391 #define efx_has_cap(efx, field) \
392 	efx->type->check_caps(efx, \
393 			      MCDI_CAPABILITY(field), \
394 			      MCDI_CAPABILITY_OFST(field))
395 
396 void efx_mcdi_print_fwver(struct efx_nic *efx, char *buf, size_t len);
397 int efx_mcdi_get_board_cfg(struct efx_nic *efx, u8 *mac_address,
398 			   u16 *fw_subtype_list, u32 *capabilities);
399 int efx_mcdi_log_ctrl(struct efx_nic *efx, bool evq, bool uart, u32 dest_evq);
400 int efx_mcdi_nvram_types(struct efx_nic *efx, u32 *nvram_types_out);
401 int efx_mcdi_nvram_info(struct efx_nic *efx, unsigned int type,
402 			size_t *size_out, size_t *erase_size_out,
403 			bool *protected_out);
404 int efx_new_mcdi_nvram_test_all(struct efx_nic *efx);
405 int efx_mcdi_nvram_metadata(struct efx_nic *efx, unsigned int type,
406 			    u32 *subtype, u16 version[4], char *desc,
407 			    size_t descsize);
408 int efx_mcdi_nvram_test_all(struct efx_nic *efx);
409 int efx_mcdi_handle_assertion(struct efx_nic *efx);
410 int efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode);
411 int efx_mcdi_wol_filter_set_magic(struct efx_nic *efx, const u8 *mac,
412 				  int *id_out);
413 int efx_mcdi_wol_filter_get_magic(struct efx_nic *efx, int *id_out);
414 int efx_mcdi_wol_filter_remove(struct efx_nic *efx, int id);
415 int efx_mcdi_wol_filter_reset(struct efx_nic *efx);
416 int efx_mcdi_flush_rxqs(struct efx_nic *efx);
417 void efx_mcdi_process_link_change(struct efx_nic *efx, efx_qword_t *ev);
418 void efx_mcdi_mac_start_stats(struct efx_nic *efx);
419 void efx_mcdi_mac_stop_stats(struct efx_nic *efx);
420 void efx_mcdi_mac_pull_stats(struct efx_nic *efx);
421 enum reset_type efx_mcdi_map_reset_reason(enum reset_type reason);
422 int efx_mcdi_reset(struct efx_nic *efx, enum reset_type method);
423 int efx_mcdi_set_workaround(struct efx_nic *efx, u32 type, bool enabled,
424 			    unsigned int *flags);
425 int efx_mcdi_get_workarounds(struct efx_nic *efx, unsigned int *impl_out,
426 			     unsigned int *enabled_out);
427 int efx_mcdi_get_privilege_mask(struct efx_nic *efx, u32 *mask);
428 
429 #ifdef CONFIG_SFC_MCDI_MON
430 int efx_mcdi_mon_probe(struct efx_nic *efx);
431 void efx_mcdi_mon_remove(struct efx_nic *efx);
432 #else
efx_mcdi_mon_probe(struct efx_nic * efx)433 static inline int efx_mcdi_mon_probe(struct efx_nic *efx) { return 0; }
efx_mcdi_mon_remove(struct efx_nic * efx)434 static inline void efx_mcdi_mon_remove(struct efx_nic *efx) {}
435 #endif
436 
437 #ifdef CONFIG_SFC_MTD
438 int efx_mcdi_mtd_read(struct mtd_info *mtd, loff_t start, size_t len,
439 		      size_t *retlen, u8 *buffer);
440 int efx_mcdi_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len);
441 int efx_mcdi_mtd_write(struct mtd_info *mtd, loff_t start, size_t len,
442 		       size_t *retlen, const u8 *buffer);
443 int efx_mcdi_mtd_sync(struct mtd_info *mtd);
444 void efx_mcdi_mtd_rename(struct efx_mtd_partition *part);
445 #endif
446 
447 #endif /* EFX_MCDI_H */
448