drivers/net/ethernet/qlogic/qed/qed_selftest.c

   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 }