1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 /* QLogic qed NIC Driver 3 * Copyright (c) 2015-2016 QLogic Corporation 4 * Copyright (c) 2019-2020 Marvell International Ltd. 5 */ 6 7 #include <linux/crc32.h> 8 #include "qed.h" 9 #include "qed_dev_api.h" 10 #include "qed_mcp.h" 11 #include "qed_sp.h" 12 #include "qed_selftest.h" 13 14 int qed_selftest_memory(struct qed_dev *cdev) 15 { 16 int rc = 0, i; 17 18 for_each_hwfn(cdev, i) { 19 rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]); 20 if (rc) 21 return rc; 22 } 23 24 return rc; 25 } 26 27 int qed_selftest_interrupt(struct qed_dev *cdev) 28 { 29 int rc = 0, i; 30 31 for_each_hwfn(cdev, i) { 32 rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]); 33 if (rc) 34 return rc; 35 } 36 37 return rc; 38 } 39 40 int qed_selftest_register(struct qed_dev *cdev) 41 { 42 struct qed_hwfn *p_hwfn; 43 struct qed_ptt *p_ptt; 44 int rc = 0, i; 45 46 /* although performed by MCP, this test is per engine */ 47 for_each_hwfn(cdev, i) { 48 p_hwfn = &cdev->hwfns[i]; 49 p_ptt = qed_ptt_acquire(p_hwfn); 50 if (!p_ptt) { 51 DP_ERR(p_hwfn, "failed to acquire ptt\n"); 52 return -EBUSY; 53 } 54 rc = qed_mcp_bist_register_test(p_hwfn, p_ptt); 55 qed_ptt_release(p_hwfn, p_ptt); 56 if (rc) 57 break; 58 } 59 60 return rc; 61 } 62 63 int qed_selftest_clock(struct qed_dev *cdev) 64 { 65 struct qed_hwfn *p_hwfn; 66 struct qed_ptt *p_ptt; 67 int rc = 0, i; 68 69 /* although performed by MCP, this test is per engine */ 70 for_each_hwfn(cdev, i) { 71 p_hwfn = &cdev->hwfns[i]; 72 p_ptt = qed_ptt_acquire(p_hwfn); 73 if (!p_ptt) { 74 DP_ERR(p_hwfn, "failed to acquire ptt\n"); 75 return -EBUSY; 76 } 77 rc = qed_mcp_bist_clock_test(p_hwfn, p_ptt); 78 qed_ptt_release(p_hwfn, p_ptt); 79 if (rc) 80 break; 81 } 82 83 return rc; 84 } 85 86 int qed_selftest_nvram(struct qed_dev *cdev) 87 { 88 struct qed_hwfn *p_hwfn = QED_LEADING_HWFN(cdev); 89 struct qed_ptt *p_ptt = qed_ptt_acquire(p_hwfn); 90 u32 num_images, i, j, nvm_crc, calc_crc; 91 struct bist_nvm_image_att image_att; 92 u8 *buf = NULL; 93 __be32 val; 94 int rc; 95 96 if (!p_ptt) { 97 DP_ERR(p_hwfn, "failed to acquire ptt\n"); 98 return -EBUSY; 99 } 100 101 /* Acquire from MFW the amount of available images */ 102 rc = qed_mcp_bist_nvm_get_num_images(p_hwfn, p_ptt, &num_images); 103 if (rc || !num_images) { 104 DP_ERR(p_hwfn, "Failed getting number of images\n"); 105 rc = -EINVAL; 106 goto err0; 107 } 108 109 /* Iterate over images and validate CRC */ 110 for (i = 0; i < num_images; i++) { 111 /* This mailbox returns information about the image required for 112 * reading it. 113 */ 114 rc = qed_mcp_bist_nvm_get_image_att(p_hwfn, p_ptt, 115 &image_att, i); 116 if (rc) { 117 DP_ERR(p_hwfn, 118 "Failed getting image index %d attributes\n", 119 i); 120 goto err0; 121 } 122 123 /* After MFW crash dump is collected - the image's CRC stops 124 * being valid. 125 */ 126 if (image_att.image_type == NVM_TYPE_MDUMP) 127 continue; 128 129 DP_VERBOSE(p_hwfn, QED_MSG_SP, "image index %d, size %x\n", 130 i, image_att.len); 131 132 /* Allocate a buffer for holding the nvram image */ 133 buf = kzalloc(image_att.len, GFP_KERNEL); 134 if (!buf) { 135 rc = -ENOMEM; 136 goto err0; 137 } 138 139 /* Read image into buffer */ 140 rc = qed_mcp_nvm_read(p_hwfn->cdev, image_att.nvm_start_addr, 141 buf, image_att.len); 142 if (rc) { 143 DP_ERR(p_hwfn, 144 "Failed reading image index %d from nvm.\n", i); 145 goto err1; 146 } 147 148 /* Convert the buffer into big-endian format (excluding the 149 * closing 4 bytes of CRC). 150 */ 151 for (j = 0; j < image_att.len - 4; j += 4) { 152 val = cpu_to_be32(*(u32 *)&buf[j]); 153 *(u32 *)&buf[j] = (__force u32)val; 154 } 155 156 /* Calc CRC for the "actual" image buffer, i.e. not including 157 * the last 4 CRC bytes. 158 */ 159 nvm_crc = *(u32 *)(buf + image_att.len - 4); 160 calc_crc = crc32(0xffffffff, buf, image_att.len - 4); 161 calc_crc = (__force u32)~cpu_to_be32(calc_crc); 162 DP_VERBOSE(p_hwfn, QED_MSG_SP, 163 "nvm crc 0x%x, calc_crc 0x%x\n", nvm_crc, calc_crc); 164 165 if (calc_crc != nvm_crc) { 166 rc = -EINVAL; 167 goto err1; 168 } 169 170 /* Done with this image; Free to prevent double release 171 * on subsequent failure. 172 */ 173 kfree(buf); 174 buf = NULL; 175 } 176 177 qed_ptt_release(p_hwfn, p_ptt); 178 return 0; 179 180 err1: 181 kfree(buf); 182 err0: 183 qed_ptt_release(p_hwfn, p_ptt); 184 return rc; 185 } 186