1 /* QLogic qed NIC Driver
2 * Copyright (c) 2015-2016 QLogic Corporation
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and /or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33 #include <linux/crc32.h>
34 #include "qed.h"
35 #include "qed_dev_api.h"
36 #include "qed_mcp.h"
37 #include "qed_sp.h"
38 #include "qed_selftest.h"
39
40 int qed_selftest_memory(struct qed_dev *cdev)
41 {
42 int rc = 0, i;
43
44 for_each_hwfn(cdev, i) {
45 rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]);
46 if (rc)
47 return rc;
48 }
49
50 return rc;
51 }
52
53 int qed_selftest_interrupt(struct qed_dev *cdev)
54 {
55 int rc = 0, i;
56
57 for_each_hwfn(cdev, i) {
58 rc = qed_sp_heartbeat_ramrod(&cdev->hwfns[i]);
59 if (rc)
60 return rc;
61 }
62
63 return rc;
64 }
65
66 int qed_selftest_register(struct qed_dev *cdev)
67 {
68 struct qed_hwfn *p_hwfn;
69 struct qed_ptt *p_ptt;
70 int rc = 0, i;
71
72 /* although performed by MCP, this test is per engine */
73 for_each_hwfn(cdev, i) {
74 p_hwfn = &cdev->hwfns[i];
75 p_ptt = qed_ptt_acquire(p_hwfn);
76 if (!p_ptt) {
77 DP_ERR(p_hwfn, "failed to acquire ptt\n");
78 return -EBUSY;
79 }
80 rc = qed_mcp_bist_register_test(p_hwfn, p_ptt);
81 qed_ptt_release(p_hwfn, p_ptt);
82 if (rc)
83 break;
84 }
85
86 return rc;
87 }
88
89 int qed_selftest_clock(struct qed_dev *cdev)
90 {
91 struct qed_hwfn *p_hwfn;
92 struct qed_ptt *p_ptt;
93 int rc = 0, i;
94
95 /* although performed by MCP, this test is per engine */
96 for_each_hwfn(cdev, i) {
97 p_hwfn = &cdev->hwfns[i];
98 p_ptt = qed_ptt_acquire(p_hwfn);
99 if (!p_ptt) {
100 DP_ERR(p_hwfn, "failed to acquire ptt\n");
101 return -EBUSY;
102 }
103 rc = qed_mcp_bist_clock_test(p_hwfn, p_ptt);
104 qed_ptt_release(p_hwfn, p_ptt);
105 if (rc)
106 break;
107 }
108
109 return rc;
110 }
111
112 int qed_selftest_nvram(struct qed_dev *cdev)
113 {
114 struct qed_hwfn *p_hwfn = QED_LEADING_HWFN(cdev);
115 struct qed_ptt *p_ptt = qed_ptt_acquire(p_hwfn);
116 u32 num_images, i, j, nvm_crc, calc_crc;
117 struct bist_nvm_image_att image_att;
118 u8 *buf = NULL;
119 __be32 val;
120 int rc;
121
122 if (!p_ptt) {
123 DP_ERR(p_hwfn, "failed to acquire ptt\n");
124 return -EBUSY;
125 }
126
127 /* Acquire from MFW the amount of available images */
128 rc = qed_mcp_bist_nvm_get_num_images(p_hwfn, p_ptt, &num_images);
129 if (rc || !num_images) {
130 DP_ERR(p_hwfn, "Failed getting number of images\n");
131 rc = -EINVAL;
132 goto err0;
133 }
134
135 /* Iterate over images and validate CRC */
136 for (i = 0; i < num_images; i++) {
137 /* This mailbox returns information about the image required for
138 * reading it.
139 */
140 rc = qed_mcp_bist_nvm_get_image_att(p_hwfn, p_ptt,
141 &image_att, i);
142 if (rc) {
143 DP_ERR(p_hwfn,
144 "Failed getting image index %d attributes\n",
145 i);
146 goto err0;
147 }
148
149 /* After MFW crash dump is collected - the image's CRC stops
150 * being valid.
151 */
152 if (image_att.image_type == NVM_TYPE_MDUMP)
153 continue;
154
155 DP_VERBOSE(p_hwfn, QED_MSG_SP, "image index %d, size %x\n",
156 i, image_att.len);
157
158 /* Allocate a buffer for holding the nvram image */
159 buf = kzalloc(image_att.len, GFP_KERNEL);
160 if (!buf) {
161 rc = -ENOMEM;
162 goto err0;
163 }
164
165 /* Read image into buffer */
166 rc = qed_mcp_nvm_read(p_hwfn->cdev, image_att.nvm_start_addr,
167 buf, image_att.len);
168 if (rc) {
169 DP_ERR(p_hwfn,
170 "Failed reading image index %d from nvm.\n", i);
171 goto err1;
172 }
173
174 /* Convert the buffer into big-endian format (excluding the
175 * closing 4 bytes of CRC).
176 */
177 for (j = 0; j < image_att.len - 4; j += 4) {
178 val = cpu_to_be32(*(u32 *)&buf[j]);
179 *(u32 *)&buf[j] = (__force u32)val;
180 }
181
182 /* Calc CRC for the "actual" image buffer, i.e. not including
183 * the last 4 CRC bytes.
184 */
185 nvm_crc = *(u32 *)(buf + image_att.len - 4);
186 calc_crc = crc32(0xffffffff, buf, image_att.len - 4);
187 calc_crc = (__force u32)~cpu_to_be32(calc_crc);
188 DP_VERBOSE(p_hwfn, QED_MSG_SP,
189 "nvm crc 0x%x, calc_crc 0x%x\n", nvm_crc, calc_crc);
190
191 if (calc_crc != nvm_crc) {
192 rc = -EINVAL;
193 goto err1;
194 }
195
196 /* Done with this image; Free to prevent double release
197 * on subsequent failure.
198 */
199 kfree(buf);
200 buf = NULL;
201 }
202
203 qed_ptt_release(p_hwfn, p_ptt);
204 return 0;
205
206 err1:
207 kfree(buf);
208 err0:
209 qed_ptt_release(p_hwfn, p_ptt);
210 return rc;
211 }