1 // SPDX-License-Identifier: GPL-2.0-only
2 /****************************************************************************
3  * Driver for AMD network controllers and boards
4  * Copyright (C) 2023, Advanced Micro Devices, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation, incorporated herein by reference.
9  */
10 
11 #include "net_driver.h"
12 #include "ef100_nic.h"
13 #include "efx_devlink.h"
14 #include <linux/rtc.h>
15 #include "mcdi.h"
16 #include "mcdi_functions.h"
17 #include "mcdi_pcol.h"
18 #ifdef CONFIG_SFC_SRIOV
19 #include "mae.h"
20 #include "ef100_rep.h"
21 #endif
22 
23 struct efx_devlink {
24 	struct efx_nic *efx;
25 };
26 
27 #ifdef CONFIG_SFC_SRIOV
28 
efx_devlink_port_addr_get(struct devlink_port * port,u8 * hw_addr,int * hw_addr_len,struct netlink_ext_ack * extack)29 static int efx_devlink_port_addr_get(struct devlink_port *port, u8 *hw_addr,
30 				     int *hw_addr_len,
31 				     struct netlink_ext_ack *extack)
32 {
33 	struct efx_devlink *devlink = devlink_priv(port->devlink);
34 	struct mae_mport_desc *mport_desc;
35 	efx_qword_t pciefn;
36 	u32 client_id;
37 	int rc = 0;
38 
39 	mport_desc = container_of(port, struct mae_mport_desc, dl_port);
40 
41 	if (!ef100_mport_on_local_intf(devlink->efx, mport_desc)) {
42 		rc = -EINVAL;
43 		NL_SET_ERR_MSG_FMT(extack,
44 				   "Port not on local interface (mport: %u)",
45 				   mport_desc->mport_id);
46 		goto out;
47 	}
48 
49 	if (ef100_mport_is_vf(mport_desc))
50 		EFX_POPULATE_QWORD_3(pciefn,
51 				     PCIE_FUNCTION_PF, PCIE_FUNCTION_PF_NULL,
52 				     PCIE_FUNCTION_VF, mport_desc->vf_idx,
53 				     PCIE_FUNCTION_INTF, PCIE_INTERFACE_CALLER);
54 	else
55 		EFX_POPULATE_QWORD_3(pciefn,
56 				     PCIE_FUNCTION_PF, mport_desc->pf_idx,
57 				     PCIE_FUNCTION_VF, PCIE_FUNCTION_VF_NULL,
58 				     PCIE_FUNCTION_INTF, PCIE_INTERFACE_CALLER);
59 
60 	rc = efx_ef100_lookup_client_id(devlink->efx, pciefn, &client_id);
61 	if (rc) {
62 		NL_SET_ERR_MSG_FMT(extack,
63 				   "No internal client_ID for port (mport: %u)",
64 				   mport_desc->mport_id);
65 		goto out;
66 	}
67 
68 	rc = ef100_get_mac_address(devlink->efx, hw_addr, client_id, true);
69 	if (rc != 0)
70 		NL_SET_ERR_MSG_FMT(extack,
71 				   "No available MAC for port (mport: %u)",
72 				   mport_desc->mport_id);
73 out:
74 	*hw_addr_len = ETH_ALEN;
75 	return rc;
76 }
77 
efx_devlink_port_addr_set(struct devlink_port * port,const u8 * hw_addr,int hw_addr_len,struct netlink_ext_ack * extack)78 static int efx_devlink_port_addr_set(struct devlink_port *port,
79 				     const u8 *hw_addr, int hw_addr_len,
80 				     struct netlink_ext_ack *extack)
81 {
82 	MCDI_DECLARE_BUF(inbuf, MC_CMD_SET_CLIENT_MAC_ADDRESSES_IN_LEN(1));
83 	struct efx_devlink *devlink = devlink_priv(port->devlink);
84 	struct mae_mport_desc *mport_desc;
85 	efx_qword_t pciefn;
86 	u32 client_id;
87 	int rc;
88 
89 	mport_desc = container_of(port, struct mae_mport_desc, dl_port);
90 
91 	if (!ef100_mport_is_vf(mport_desc)) {
92 		NL_SET_ERR_MSG_FMT(extack,
93 				   "port mac change not allowed (mport: %u)",
94 				   mport_desc->mport_id);
95 		return -EPERM;
96 	}
97 
98 	EFX_POPULATE_QWORD_3(pciefn,
99 			     PCIE_FUNCTION_PF, PCIE_FUNCTION_PF_NULL,
100 			     PCIE_FUNCTION_VF, mport_desc->vf_idx,
101 			     PCIE_FUNCTION_INTF, PCIE_INTERFACE_CALLER);
102 
103 	rc = efx_ef100_lookup_client_id(devlink->efx, pciefn, &client_id);
104 	if (rc) {
105 		NL_SET_ERR_MSG_FMT(extack,
106 				   "No internal client_ID for port (mport: %u)",
107 				   mport_desc->mport_id);
108 		return rc;
109 	}
110 
111 	MCDI_SET_DWORD(inbuf, SET_CLIENT_MAC_ADDRESSES_IN_CLIENT_HANDLE,
112 		       client_id);
113 
114 	ether_addr_copy(MCDI_PTR(inbuf, SET_CLIENT_MAC_ADDRESSES_IN_MAC_ADDRS),
115 			hw_addr);
116 
117 	rc = efx_mcdi_rpc(devlink->efx, MC_CMD_SET_CLIENT_MAC_ADDRESSES, inbuf,
118 			  sizeof(inbuf), NULL, 0, NULL);
119 	if (rc)
120 		NL_SET_ERR_MSG_FMT(extack,
121 				   "sfc MC_CMD_SET_CLIENT_MAC_ADDRESSES mcdi error (mport: %u)",
122 				   mport_desc->mport_id);
123 
124 	return rc;
125 }
126 
127 static const struct devlink_port_ops sfc_devlink_port_ops = {
128 	.port_fn_hw_addr_get = efx_devlink_port_addr_get,
129 	.port_fn_hw_addr_set = efx_devlink_port_addr_set,
130 };
131 
efx_devlink_del_port(struct devlink_port * dl_port)132 static void efx_devlink_del_port(struct devlink_port *dl_port)
133 {
134 	if (!dl_port)
135 		return;
136 	devl_port_unregister(dl_port);
137 }
138 
efx_devlink_add_port(struct efx_nic * efx,struct mae_mport_desc * mport)139 static int efx_devlink_add_port(struct efx_nic *efx,
140 				struct mae_mport_desc *mport)
141 {
142 	bool external = false;
143 
144 	if (!ef100_mport_on_local_intf(efx, mport))
145 		external = true;
146 
147 	switch (mport->mport_type) {
148 	case MAE_MPORT_DESC_MPORT_TYPE_VNIC:
149 		if (mport->vf_idx != MAE_MPORT_DESC_VF_IDX_NULL)
150 			devlink_port_attrs_pci_vf_set(&mport->dl_port, 0, mport->pf_idx,
151 						      mport->vf_idx,
152 						      external);
153 		else
154 			devlink_port_attrs_pci_pf_set(&mport->dl_port, 0, mport->pf_idx,
155 						      external);
156 		break;
157 	default:
158 		/* MAE_MPORT_DESC_MPORT_ALIAS and UNDEFINED */
159 		return 0;
160 	}
161 
162 	mport->dl_port.index = mport->mport_id;
163 
164 	return devl_port_register_with_ops(efx->devlink, &mport->dl_port,
165 					   mport->mport_id,
166 					   &sfc_devlink_port_ops);
167 }
168 
169 #endif
170 
efx_devlink_info_nvram_partition(struct efx_nic * efx,struct devlink_info_req * req,unsigned int partition_type,const char * version_name)171 static int efx_devlink_info_nvram_partition(struct efx_nic *efx,
172 					    struct devlink_info_req *req,
173 					    unsigned int partition_type,
174 					    const char *version_name)
175 {
176 	char buf[EFX_MAX_VERSION_INFO_LEN];
177 	u16 version[4];
178 	int rc;
179 
180 	rc = efx_mcdi_nvram_metadata(efx, partition_type, NULL, version, NULL,
181 				     0);
182 
183 	/* If the partition does not exist, that is not an error. */
184 	if (rc == -ENOENT)
185 		return 0;
186 
187 	if (rc) {
188 		netif_err(efx, drv, efx->net_dev, "mcdi nvram %s: failed (rc=%d)\n",
189 			  version_name, rc);
190 		return rc;
191 	}
192 
193 	snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u", version[0],
194 		 version[1], version[2], version[3]);
195 	devlink_info_version_stored_put(req, version_name, buf);
196 
197 	return 0;
198 }
199 
efx_devlink_info_stored_versions(struct efx_nic * efx,struct devlink_info_req * req)200 static int efx_devlink_info_stored_versions(struct efx_nic *efx,
201 					    struct devlink_info_req *req)
202 {
203 	int err;
204 
205 	/* We do not care here about the specific error but just if an error
206 	 * happened. The specific error will be reported inside the call
207 	 * through system messages, and if any error happened in any call
208 	 * below, we report it through extack.
209 	 */
210 	err = efx_devlink_info_nvram_partition(efx, req,
211 					       NVRAM_PARTITION_TYPE_BUNDLE,
212 					       DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID);
213 
214 	err |= efx_devlink_info_nvram_partition(efx, req,
215 						NVRAM_PARTITION_TYPE_MC_FIRMWARE,
216 						DEVLINK_INFO_VERSION_GENERIC_FW_MGMT);
217 
218 	err |= efx_devlink_info_nvram_partition(efx, req,
219 						NVRAM_PARTITION_TYPE_SUC_FIRMWARE,
220 						EFX_DEVLINK_INFO_VERSION_FW_MGMT_SUC);
221 
222 	err |= efx_devlink_info_nvram_partition(efx, req,
223 						NVRAM_PARTITION_TYPE_EXPANSION_ROM,
224 						EFX_DEVLINK_INFO_VERSION_FW_EXPROM);
225 
226 	err |= efx_devlink_info_nvram_partition(efx, req,
227 						NVRAM_PARTITION_TYPE_EXPANSION_UEFI,
228 						EFX_DEVLINK_INFO_VERSION_FW_UEFI);
229 	return err;
230 }
231 
232 #define EFX_VER_FLAG(_f)	\
233 	(MC_CMD_GET_VERSION_V5_OUT_ ## _f ## _PRESENT_LBN)
234 
efx_devlink_info_running_v2(struct efx_nic * efx,struct devlink_info_req * req,unsigned int flags,efx_dword_t * outbuf)235 static void efx_devlink_info_running_v2(struct efx_nic *efx,
236 					struct devlink_info_req *req,
237 					unsigned int flags, efx_dword_t *outbuf)
238 {
239 	char buf[EFX_MAX_VERSION_INFO_LEN];
240 	union {
241 		const __le32 *dwords;
242 		const __le16 *words;
243 		const char *str;
244 	} ver;
245 	struct rtc_time build_date;
246 	unsigned int build_id;
247 	size_t offset;
248 	__maybe_unused u64 tstamp;
249 
250 	if (flags & BIT(EFX_VER_FLAG(BOARD_EXT_INFO))) {
251 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%s",
252 			 MCDI_PTR(outbuf, GET_VERSION_V2_OUT_BOARD_NAME));
253 		devlink_info_version_fixed_put(req,
254 					       DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
255 					       buf);
256 
257 		/* Favour full board version if present (in V5 or later) */
258 		if (~flags & BIT(EFX_VER_FLAG(BOARD_VERSION))) {
259 			snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u",
260 				 MCDI_DWORD(outbuf,
261 					    GET_VERSION_V2_OUT_BOARD_REVISION));
262 			devlink_info_version_fixed_put(req,
263 						       DEVLINK_INFO_VERSION_GENERIC_BOARD_REV,
264 						       buf);
265 		}
266 
267 		ver.str = MCDI_PTR(outbuf, GET_VERSION_V2_OUT_BOARD_SERIAL);
268 		if (ver.str[0])
269 			devlink_info_board_serial_number_put(req, ver.str);
270 	}
271 
272 	if (flags & BIT(EFX_VER_FLAG(FPGA_EXT_INFO))) {
273 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
274 						GET_VERSION_V2_OUT_FPGA_VERSION);
275 		offset = snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u_%c%u",
276 				  le32_to_cpu(ver.dwords[0]),
277 				  'A' + le32_to_cpu(ver.dwords[1]),
278 				  le32_to_cpu(ver.dwords[2]));
279 
280 		ver.str = MCDI_PTR(outbuf, GET_VERSION_V2_OUT_FPGA_EXTRA);
281 		if (ver.str[0])
282 			snprintf(&buf[offset], EFX_MAX_VERSION_INFO_LEN - offset,
283 				 " (%s)", ver.str);
284 
285 		devlink_info_version_running_put(req,
286 						 EFX_DEVLINK_INFO_VERSION_FPGA_REV,
287 						 buf);
288 	}
289 
290 	if (flags & BIT(EFX_VER_FLAG(CMC_EXT_INFO))) {
291 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
292 						GET_VERSION_V2_OUT_CMCFW_VERSION);
293 		offset = snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
294 				  le32_to_cpu(ver.dwords[0]),
295 				  le32_to_cpu(ver.dwords[1]),
296 				  le32_to_cpu(ver.dwords[2]),
297 				  le32_to_cpu(ver.dwords[3]));
298 
299 #ifdef CONFIG_RTC_LIB
300 		tstamp = MCDI_QWORD(outbuf,
301 				    GET_VERSION_V2_OUT_CMCFW_BUILD_DATE);
302 		if (tstamp) {
303 			rtc_time64_to_tm(tstamp, &build_date);
304 			snprintf(&buf[offset], EFX_MAX_VERSION_INFO_LEN - offset,
305 				 " (%ptRd)", &build_date);
306 		}
307 #endif
308 
309 		devlink_info_version_running_put(req,
310 						 EFX_DEVLINK_INFO_VERSION_FW_MGMT_CMC,
311 						 buf);
312 	}
313 
314 	ver.words = (__le16 *)MCDI_PTR(outbuf, GET_VERSION_V2_OUT_VERSION);
315 	offset = snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
316 			  le16_to_cpu(ver.words[0]), le16_to_cpu(ver.words[1]),
317 			  le16_to_cpu(ver.words[2]), le16_to_cpu(ver.words[3]));
318 	if (flags & BIT(EFX_VER_FLAG(MCFW_EXT_INFO))) {
319 		build_id = MCDI_DWORD(outbuf, GET_VERSION_V2_OUT_MCFW_BUILD_ID);
320 		snprintf(&buf[offset], EFX_MAX_VERSION_INFO_LEN - offset,
321 			 " (%x) %s", build_id,
322 			 MCDI_PTR(outbuf, GET_VERSION_V2_OUT_MCFW_BUILD_NAME));
323 	}
324 	devlink_info_version_running_put(req,
325 					 DEVLINK_INFO_VERSION_GENERIC_FW_MGMT,
326 					 buf);
327 
328 	if (flags & BIT(EFX_VER_FLAG(SUCFW_EXT_INFO))) {
329 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
330 						GET_VERSION_V2_OUT_SUCFW_VERSION);
331 #ifdef CONFIG_RTC_LIB
332 		tstamp = MCDI_QWORD(outbuf,
333 				    GET_VERSION_V2_OUT_SUCFW_BUILD_DATE);
334 		rtc_time64_to_tm(tstamp, &build_date);
335 #else
336 		memset(&build_date, 0, sizeof(build_date));
337 #endif
338 		build_id = MCDI_DWORD(outbuf, GET_VERSION_V2_OUT_SUCFW_CHIP_ID);
339 
340 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN,
341 			 "%u.%u.%u.%u type %x (%ptRd)",
342 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
343 			 le32_to_cpu(ver.dwords[2]), le32_to_cpu(ver.dwords[3]),
344 			 build_id, &build_date);
345 
346 		devlink_info_version_running_put(req,
347 						 EFX_DEVLINK_INFO_VERSION_FW_MGMT_SUC,
348 						 buf);
349 	}
350 }
351 
efx_devlink_info_running_v3(struct efx_nic * efx,struct devlink_info_req * req,unsigned int flags,efx_dword_t * outbuf)352 static void efx_devlink_info_running_v3(struct efx_nic *efx,
353 					struct devlink_info_req *req,
354 					unsigned int flags, efx_dword_t *outbuf)
355 {
356 	char buf[EFX_MAX_VERSION_INFO_LEN];
357 	union {
358 		const __le32 *dwords;
359 		const __le16 *words;
360 		const char *str;
361 	} ver;
362 
363 	if (flags & BIT(EFX_VER_FLAG(DATAPATH_HW_VERSION))) {
364 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
365 						GET_VERSION_V3_OUT_DATAPATH_HW_VERSION);
366 
367 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u",
368 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
369 			 le32_to_cpu(ver.dwords[2]));
370 
371 		devlink_info_version_running_put(req,
372 						 EFX_DEVLINK_INFO_VERSION_DATAPATH_HW,
373 						 buf);
374 	}
375 
376 	if (flags & BIT(EFX_VER_FLAG(DATAPATH_FW_VERSION))) {
377 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
378 						GET_VERSION_V3_OUT_DATAPATH_FW_VERSION);
379 
380 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u",
381 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
382 			 le32_to_cpu(ver.dwords[2]));
383 
384 		devlink_info_version_running_put(req,
385 						 EFX_DEVLINK_INFO_VERSION_DATAPATH_FW,
386 						 buf);
387 	}
388 }
389 
efx_devlink_info_running_v4(struct efx_nic * efx,struct devlink_info_req * req,unsigned int flags,efx_dword_t * outbuf)390 static void efx_devlink_info_running_v4(struct efx_nic *efx,
391 					struct devlink_info_req *req,
392 					unsigned int flags, efx_dword_t *outbuf)
393 {
394 	char buf[EFX_MAX_VERSION_INFO_LEN];
395 	union {
396 		const __le32 *dwords;
397 		const __le16 *words;
398 		const char *str;
399 	} ver;
400 
401 	if (flags & BIT(EFX_VER_FLAG(SOC_BOOT_VERSION))) {
402 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
403 						GET_VERSION_V4_OUT_SOC_BOOT_VERSION);
404 
405 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
406 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
407 			 le32_to_cpu(ver.dwords[2]),
408 			 le32_to_cpu(ver.dwords[3]));
409 
410 		devlink_info_version_running_put(req,
411 						 EFX_DEVLINK_INFO_VERSION_SOC_BOOT,
412 						 buf);
413 	}
414 
415 	if (flags & BIT(EFX_VER_FLAG(SOC_UBOOT_VERSION))) {
416 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
417 						GET_VERSION_V4_OUT_SOC_UBOOT_VERSION);
418 
419 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
420 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
421 			 le32_to_cpu(ver.dwords[2]),
422 			 le32_to_cpu(ver.dwords[3]));
423 
424 		devlink_info_version_running_put(req,
425 						 EFX_DEVLINK_INFO_VERSION_SOC_UBOOT,
426 						 buf);
427 	}
428 
429 	if (flags & BIT(EFX_VER_FLAG(SOC_MAIN_ROOTFS_VERSION))) {
430 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
431 					GET_VERSION_V4_OUT_SOC_MAIN_ROOTFS_VERSION);
432 
433 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
434 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
435 			 le32_to_cpu(ver.dwords[2]),
436 			 le32_to_cpu(ver.dwords[3]));
437 
438 		devlink_info_version_running_put(req,
439 						 EFX_DEVLINK_INFO_VERSION_SOC_MAIN,
440 						 buf);
441 	}
442 
443 	if (flags & BIT(EFX_VER_FLAG(SOC_RECOVERY_BUILDROOT_VERSION))) {
444 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
445 						GET_VERSION_V4_OUT_SOC_RECOVERY_BUILDROOT_VERSION);
446 
447 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
448 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
449 			 le32_to_cpu(ver.dwords[2]),
450 			 le32_to_cpu(ver.dwords[3]));
451 
452 		devlink_info_version_running_put(req,
453 						 EFX_DEVLINK_INFO_VERSION_SOC_RECOVERY,
454 						 buf);
455 	}
456 
457 	if (flags & BIT(EFX_VER_FLAG(SUCFW_VERSION)) &&
458 	    ~flags & BIT(EFX_VER_FLAG(SUCFW_EXT_INFO))) {
459 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
460 						GET_VERSION_V4_OUT_SUCFW_VERSION);
461 
462 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
463 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
464 			 le32_to_cpu(ver.dwords[2]),
465 			 le32_to_cpu(ver.dwords[3]));
466 
467 		devlink_info_version_running_put(req,
468 						 EFX_DEVLINK_INFO_VERSION_FW_MGMT_SUC,
469 						 buf);
470 	}
471 }
472 
efx_devlink_info_running_v5(struct efx_nic * efx,struct devlink_info_req * req,unsigned int flags,efx_dword_t * outbuf)473 static void efx_devlink_info_running_v5(struct efx_nic *efx,
474 					struct devlink_info_req *req,
475 					unsigned int flags, efx_dword_t *outbuf)
476 {
477 	char buf[EFX_MAX_VERSION_INFO_LEN];
478 	union {
479 		const __le32 *dwords;
480 		const __le16 *words;
481 		const char *str;
482 	} ver;
483 
484 	if (flags & BIT(EFX_VER_FLAG(BOARD_VERSION))) {
485 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
486 						GET_VERSION_V5_OUT_BOARD_VERSION);
487 
488 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
489 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
490 			 le32_to_cpu(ver.dwords[2]),
491 			 le32_to_cpu(ver.dwords[3]));
492 
493 		devlink_info_version_running_put(req,
494 						 DEVLINK_INFO_VERSION_GENERIC_BOARD_REV,
495 						 buf);
496 	}
497 
498 	if (flags & BIT(EFX_VER_FLAG(BUNDLE_VERSION))) {
499 		ver.dwords = (__le32 *)MCDI_PTR(outbuf,
500 						GET_VERSION_V5_OUT_BUNDLE_VERSION);
501 
502 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
503 			 le32_to_cpu(ver.dwords[0]), le32_to_cpu(ver.dwords[1]),
504 			 le32_to_cpu(ver.dwords[2]),
505 			 le32_to_cpu(ver.dwords[3]));
506 
507 		devlink_info_version_running_put(req,
508 						 DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID,
509 						 buf);
510 	}
511 }
512 
efx_devlink_info_running_versions(struct efx_nic * efx,struct devlink_info_req * req)513 static int efx_devlink_info_running_versions(struct efx_nic *efx,
514 					     struct devlink_info_req *req)
515 {
516 	MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_VERSION_V5_OUT_LEN);
517 	MCDI_DECLARE_BUF(inbuf, MC_CMD_GET_VERSION_EXT_IN_LEN);
518 	char buf[EFX_MAX_VERSION_INFO_LEN];
519 	union {
520 		const __le32 *dwords;
521 		const __le16 *words;
522 		const char *str;
523 	} ver;
524 	size_t outlength;
525 	unsigned int flags;
526 	int rc;
527 
528 	rc = efx_mcdi_rpc(efx, MC_CMD_GET_VERSION, inbuf, sizeof(inbuf),
529 			  outbuf, sizeof(outbuf), &outlength);
530 	if (rc || outlength < MC_CMD_GET_VERSION_OUT_LEN) {
531 		netif_err(efx, drv, efx->net_dev,
532 			  "mcdi MC_CMD_GET_VERSION failed\n");
533 		return rc;
534 	}
535 
536 	/* Handle previous output */
537 	if (outlength < MC_CMD_GET_VERSION_V2_OUT_LEN) {
538 		ver.words = (__le16 *)MCDI_PTR(outbuf,
539 					       GET_VERSION_EXT_OUT_VERSION);
540 		snprintf(buf, EFX_MAX_VERSION_INFO_LEN, "%u.%u.%u.%u",
541 			 le16_to_cpu(ver.words[0]),
542 			 le16_to_cpu(ver.words[1]),
543 			 le16_to_cpu(ver.words[2]),
544 			 le16_to_cpu(ver.words[3]));
545 
546 		devlink_info_version_running_put(req,
547 						 DEVLINK_INFO_VERSION_GENERIC_FW_MGMT,
548 						 buf);
549 		return 0;
550 	}
551 
552 	/* Handle V2 additions */
553 	flags = MCDI_DWORD(outbuf, GET_VERSION_V2_OUT_FLAGS);
554 	efx_devlink_info_running_v2(efx, req, flags, outbuf);
555 
556 	if (outlength < MC_CMD_GET_VERSION_V3_OUT_LEN)
557 		return 0;
558 
559 	/* Handle V3 additions */
560 	efx_devlink_info_running_v3(efx, req, flags, outbuf);
561 
562 	if (outlength < MC_CMD_GET_VERSION_V4_OUT_LEN)
563 		return 0;
564 
565 	/* Handle V4 additions */
566 	efx_devlink_info_running_v4(efx, req, flags, outbuf);
567 
568 	if (outlength < MC_CMD_GET_VERSION_V5_OUT_LEN)
569 		return 0;
570 
571 	/* Handle V5 additions */
572 	efx_devlink_info_running_v5(efx, req, flags, outbuf);
573 
574 	return 0;
575 }
576 
577 #define EFX_MAX_SERIALNUM_LEN	(ETH_ALEN * 2 + 1)
578 
efx_devlink_info_board_cfg(struct efx_nic * efx,struct devlink_info_req * req)579 static int efx_devlink_info_board_cfg(struct efx_nic *efx,
580 				      struct devlink_info_req *req)
581 {
582 	char sn[EFX_MAX_SERIALNUM_LEN];
583 	u8 mac_address[ETH_ALEN];
584 	int rc;
585 
586 	rc = efx_mcdi_get_board_cfg(efx, (u8 *)mac_address, NULL, NULL);
587 	if (!rc) {
588 		snprintf(sn, EFX_MAX_SERIALNUM_LEN, "%pm", mac_address);
589 		devlink_info_serial_number_put(req, sn);
590 	}
591 	return rc;
592 }
593 
efx_devlink_info_get(struct devlink * devlink,struct devlink_info_req * req,struct netlink_ext_ack * extack)594 static int efx_devlink_info_get(struct devlink *devlink,
595 				struct devlink_info_req *req,
596 				struct netlink_ext_ack *extack)
597 {
598 	struct efx_devlink *devlink_private = devlink_priv(devlink);
599 	struct efx_nic *efx = devlink_private->efx;
600 	int err;
601 
602 	/* Several different MCDI commands are used. We report if errors
603 	 * happened through extack. Specific error information via system
604 	 * messages inside the calls.
605 	 */
606 	err = efx_devlink_info_board_cfg(efx, req);
607 
608 	err |= efx_devlink_info_stored_versions(efx, req);
609 
610 	err |= efx_devlink_info_running_versions(efx, req);
611 
612 	if (err)
613 		NL_SET_ERR_MSG_MOD(extack, "Errors when getting device info. Check system messages");
614 
615 	return 0;
616 }
617 
618 static const struct devlink_ops sfc_devlink_ops = {
619 	.info_get			= efx_devlink_info_get,
620 };
621 
622 #ifdef CONFIG_SFC_SRIOV
ef100_set_devlink_port(struct efx_nic * efx,u32 idx)623 static struct devlink_port *ef100_set_devlink_port(struct efx_nic *efx, u32 idx)
624 {
625 	struct mae_mport_desc *mport;
626 	u32 id;
627 	int rc;
628 
629 	if (!efx->mae)
630 		return NULL;
631 
632 	if (efx_mae_lookup_mport(efx, idx, &id)) {
633 		/* This should not happen. */
634 		if (idx == MAE_MPORT_DESC_VF_IDX_NULL)
635 			pci_warn_once(efx->pci_dev, "No mport ID found for PF.\n");
636 		else
637 			pci_warn_once(efx->pci_dev, "No mport ID found for VF %u.\n",
638 				      idx);
639 		return NULL;
640 	}
641 
642 	mport = efx_mae_get_mport(efx, id);
643 	if (!mport) {
644 		/* This should not happen. */
645 		if (idx == MAE_MPORT_DESC_VF_IDX_NULL)
646 			pci_warn_once(efx->pci_dev, "No mport found for PF.\n");
647 		else
648 			pci_warn_once(efx->pci_dev, "No mport found for VF %u.\n",
649 				      idx);
650 		return NULL;
651 	}
652 
653 	rc = efx_devlink_add_port(efx, mport);
654 	if (rc) {
655 		if (idx == MAE_MPORT_DESC_VF_IDX_NULL)
656 			pci_warn(efx->pci_dev,
657 				 "devlink port creation for PF failed.\n");
658 		else
659 			pci_warn(efx->pci_dev,
660 				 "devlink_port creation for VF %u failed.\n",
661 				 idx);
662 		return NULL;
663 	}
664 
665 	return &mport->dl_port;
666 }
667 
ef100_rep_set_devlink_port(struct efx_rep * efv)668 void ef100_rep_set_devlink_port(struct efx_rep *efv)
669 {
670 	efv->dl_port = ef100_set_devlink_port(efv->parent, efv->idx);
671 }
672 
ef100_pf_set_devlink_port(struct efx_nic * efx)673 void ef100_pf_set_devlink_port(struct efx_nic *efx)
674 {
675 	efx->dl_port = ef100_set_devlink_port(efx, MAE_MPORT_DESC_VF_IDX_NULL);
676 }
677 
ef100_rep_unset_devlink_port(struct efx_rep * efv)678 void ef100_rep_unset_devlink_port(struct efx_rep *efv)
679 {
680 	efx_devlink_del_port(efv->dl_port);
681 }
682 
ef100_pf_unset_devlink_port(struct efx_nic * efx)683 void ef100_pf_unset_devlink_port(struct efx_nic *efx)
684 {
685 	efx_devlink_del_port(efx->dl_port);
686 }
687 #endif
688 
efx_fini_devlink_lock(struct efx_nic * efx)689 void efx_fini_devlink_lock(struct efx_nic *efx)
690 {
691 	if (efx->devlink)
692 		devl_lock(efx->devlink);
693 }
694 
efx_fini_devlink_and_unlock(struct efx_nic * efx)695 void efx_fini_devlink_and_unlock(struct efx_nic *efx)
696 {
697 	if (efx->devlink) {
698 		devl_unregister(efx->devlink);
699 		devl_unlock(efx->devlink);
700 		devlink_free(efx->devlink);
701 		efx->devlink = NULL;
702 	}
703 }
704 
efx_probe_devlink_and_lock(struct efx_nic * efx)705 int efx_probe_devlink_and_lock(struct efx_nic *efx)
706 {
707 	struct efx_devlink *devlink_private;
708 
709 	if (efx->type->is_vf)
710 		return 0;
711 
712 	efx->devlink = devlink_alloc(&sfc_devlink_ops,
713 				     sizeof(struct efx_devlink),
714 				     &efx->pci_dev->dev);
715 	if (!efx->devlink)
716 		return -ENOMEM;
717 
718 	devl_lock(efx->devlink);
719 	devlink_private = devlink_priv(efx->devlink);
720 	devlink_private->efx = efx;
721 
722 	devl_register(efx->devlink);
723 
724 	return 0;
725 }
726 
efx_probe_devlink_unlock(struct efx_nic * efx)727 void efx_probe_devlink_unlock(struct efx_nic *efx)
728 {
729 	if (!efx->devlink)
730 		return;
731 
732 	devl_unlock(efx->devlink);
733 }
734