mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
185 lines
4.0 KiB
185 lines
4.0 KiB
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) |
|
/* QLogic qed NIC Driver |
|
* Copyright (c) 2015-2016 QLogic Corporation |
|
* Copyright (c) 2019-2020 Marvell International Ltd. |
|
*/ |
|
|
|
#include <linux/crc32.h> |
|
#include "qed.h" |
|
#include "qed_dev_api.h" |
|
#include "qed_mcp.h" |
|
#include "qed_sp.h" |
|
#include "qed_selftest.h" |
|
|
|
int qed_selftest_memory(struct qed_dev *cdev) |
|
{ |
|
int rc = 0, i; |
|
|
|
for_each_hwfn(cdev, i) { |
|
rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]); |
|
if (rc) |
|
return rc; |
|
} |
|
|
|
return rc; |
|
} |
|
|
|
int qed_selftest_interrupt(struct qed_dev *cdev) |
|
{ |
|
int rc = 0, i; |
|
|
|
for_each_hwfn(cdev, i) { |
|
rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]); |
|
if (rc) |
|
return rc; |
|
} |
|
|
|
return rc; |
|
} |
|
|
|
int qed_selftest_register(struct qed_dev *cdev) |
|
{ |
|
struct qed_hwfn *p_hwfn; |
|
struct qed_ptt *p_ptt; |
|
int rc = 0, i; |
|
|
|
/* although performed by MCP, this test is per engine */ |
|
for_each_hwfn(cdev, i) { |
|
p_hwfn = &cdev->hwfns[i]; |
|
p_ptt = qed_ptt_acquire(p_hwfn); |
|
if (!p_ptt) { |
|
DP_ERR(p_hwfn, "failed to acquire ptt\n"); |
|
return -EBUSY; |
|
} |
|
rc = qed_mcp_bist_register_test(p_hwfn, p_ptt); |
|
qed_ptt_release(p_hwfn, p_ptt); |
|
if (rc) |
|
break; |
|
} |
|
|
|
return rc; |
|
} |
|
|
|
int qed_selftest_clock(struct qed_dev *cdev) |
|
{ |
|
struct qed_hwfn *p_hwfn; |
|
struct qed_ptt *p_ptt; |
|
int rc = 0, i; |
|
|
|
/* although performed by MCP, this test is per engine */ |
|
for_each_hwfn(cdev, i) { |
|
p_hwfn = &cdev->hwfns[i]; |
|
p_ptt = qed_ptt_acquire(p_hwfn); |
|
if (!p_ptt) { |
|
DP_ERR(p_hwfn, "failed to acquire ptt\n"); |
|
return -EBUSY; |
|
} |
|
rc = qed_mcp_bist_clock_test(p_hwfn, p_ptt); |
|
qed_ptt_release(p_hwfn, p_ptt); |
|
if (rc) |
|
break; |
|
} |
|
|
|
return rc; |
|
} |
|
|
|
int qed_selftest_nvram(struct qed_dev *cdev) |
|
{ |
|
struct qed_hwfn *p_hwfn = QED_LEADING_HWFN(cdev); |
|
struct qed_ptt *p_ptt = qed_ptt_acquire(p_hwfn); |
|
u32 num_images, i, j, nvm_crc, calc_crc; |
|
struct bist_nvm_image_att image_att; |
|
u8 *buf = NULL; |
|
__be32 val; |
|
int rc; |
|
|
|
if (!p_ptt) { |
|
DP_ERR(p_hwfn, "failed to acquire ptt\n"); |
|
return -EBUSY; |
|
} |
|
|
|
/* Acquire from MFW the amount of available images */ |
|
rc = qed_mcp_bist_nvm_get_num_images(p_hwfn, p_ptt, &num_images); |
|
if (rc || !num_images) { |
|
DP_ERR(p_hwfn, "Failed getting number of images\n"); |
|
rc = -EINVAL; |
|
goto err0; |
|
} |
|
|
|
/* Iterate over images and validate CRC */ |
|
for (i = 0; i < num_images; i++) { |
|
/* This mailbox returns information about the image required for |
|
* reading it. |
|
*/ |
|
rc = qed_mcp_bist_nvm_get_image_att(p_hwfn, p_ptt, |
|
&image_att, i); |
|
if (rc) { |
|
DP_ERR(p_hwfn, |
|
"Failed getting image index %d attributes\n", |
|
i); |
|
goto err0; |
|
} |
|
|
|
/* After MFW crash dump is collected - the image's CRC stops |
|
* being valid. |
|
*/ |
|
if (image_att.image_type == NVM_TYPE_MDUMP) |
|
continue; |
|
|
|
DP_VERBOSE(p_hwfn, QED_MSG_SP, "image index %d, size %x\n", |
|
i, image_att.len); |
|
|
|
/* Allocate a buffer for holding the nvram image */ |
|
buf = kzalloc(image_att.len, GFP_KERNEL); |
|
if (!buf) { |
|
rc = -ENOMEM; |
|
goto err0; |
|
} |
|
|
|
/* Read image into buffer */ |
|
rc = qed_mcp_nvm_read(p_hwfn->cdev, image_att.nvm_start_addr, |
|
buf, image_att.len); |
|
if (rc) { |
|
DP_ERR(p_hwfn, |
|
"Failed reading image index %d from nvm.\n", i); |
|
goto err1; |
|
} |
|
|
|
/* Convert the buffer into big-endian format (excluding the |
|
* closing 4 bytes of CRC). |
|
*/ |
|
for (j = 0; j < image_att.len - 4; j += 4) { |
|
val = cpu_to_be32(*(u32 *)&buf[j]); |
|
*(u32 *)&buf[j] = (__force u32)val; |
|
} |
|
|
|
/* Calc CRC for the "actual" image buffer, i.e. not including |
|
* the last 4 CRC bytes. |
|
*/ |
|
nvm_crc = *(u32 *)(buf + image_att.len - 4); |
|
calc_crc = crc32(0xffffffff, buf, image_att.len - 4); |
|
calc_crc = (__force u32)~cpu_to_be32(calc_crc); |
|
DP_VERBOSE(p_hwfn, QED_MSG_SP, |
|
"nvm crc 0x%x, calc_crc 0x%x\n", nvm_crc, calc_crc); |
|
|
|
if (calc_crc != nvm_crc) { |
|
rc = -EINVAL; |
|
goto err1; |
|
} |
|
|
|
/* Done with this image; Free to prevent double release |
|
* on subsequent failure. |
|
*/ |
|
kfree(buf); |
|
buf = NULL; |
|
} |
|
|
|
qed_ptt_release(p_hwfn, p_ptt); |
|
return 0; |
|
|
|
err1: |
|
kfree(buf); |
|
err0: |
|
qed_ptt_release(p_hwfn, p_ptt); |
|
return rc; |
|
}
|
|
|