/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, v.1,  (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://opensource.org/licenses/CDDL-1.0.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/

/*
* Copyright 2014-2017 Cavium, Inc. 
* The contents of this file are subject to the terms of the Common Development 
* and Distribution License, v.1,  (the "License").

* You may not use this file except in compliance with the License.

* You can obtain a copy of the License at available 
* at http://opensource.org/licenses/CDDL-1.0

* See the License for the specific language governing permissions and 
* limitations under the License.
*/

#include "bcm_osal.h"
#include "ecore.h"
#include "ecore_sp_commands.h"
#include "ecore_dev_api.h"
#include "ecore_mcp.h"
#include "nvm_map.h"
#include "ecore_selftest_api.h"

enum _ecore_status_t ecore_selftest_memory(struct ecore_dev *p_dev)
{
	enum _ecore_status_t rc = ECORE_SUCCESS;
	int i;

	for_each_hwfn(p_dev, i) {
		rc = ecore_sp_heartbeat_ramrod(&p_dev->hwfns[i]);
		if (rc != ECORE_SUCCESS)
			return rc;
	}

	return rc;
}

enum _ecore_status_t ecore_selftest_interrupt(struct ecore_dev *p_dev)
{
	enum _ecore_status_t rc = ECORE_SUCCESS;
	int i;

	for_each_hwfn(p_dev, i) {
		rc = ecore_sp_heartbeat_ramrod(&p_dev->hwfns[i]);
		if (rc != ECORE_SUCCESS)
			return rc;
	}

	return rc;
}

enum _ecore_status_t ecore_selftest_register(struct ecore_dev *p_dev)
{
	struct ecore_hwfn *p_hwfn;
	struct ecore_ptt *p_ptt;
	enum _ecore_status_t rc = ECORE_SUCCESS;
	int i;


	/* although performed by MCP, this test is per engine */
	for_each_hwfn(p_dev, i) {
		p_hwfn = &p_dev->hwfns[i];
		p_ptt = ecore_ptt_acquire(p_hwfn);
		if (!p_ptt) {
			DP_ERR(p_hwfn, "failed to acquire ptt\n");
			return ECORE_BUSY;
		}
		rc = ecore_mcp_bist_register_test(p_hwfn, p_ptt);
		ecore_ptt_release(p_hwfn, p_ptt);
		if (rc != ECORE_SUCCESS)
			break;
	}

	return rc;
}

enum _ecore_status_t ecore_selftest_clock(struct ecore_dev *p_dev)
{
	struct ecore_hwfn *p_hwfn;
	struct ecore_ptt *p_ptt;
	enum _ecore_status_t rc = ECORE_SUCCESS;
	int i;

	/* although performed by MCP, this test is per engine */
	for_each_hwfn(p_dev, i) {
		p_hwfn = &p_dev->hwfns[i];
		p_ptt = ecore_ptt_acquire(p_hwfn);
		if (!p_ptt) {
			DP_ERR(p_hwfn, "failed to acquire ptt\n");
			return ECORE_BUSY;
		}
		rc = ecore_mcp_bist_clock_test(p_hwfn, p_ptt);
		ecore_ptt_release(p_hwfn, p_ptt);
		if (rc != ECORE_SUCCESS)
			break;
	}

	return rc;
}

enum _ecore_status_t ecore_selftest_nvram(struct ecore_dev *p_dev)
{
	struct ecore_hwfn *p_hwfn = ECORE_LEADING_HWFN(p_dev);
	struct ecore_ptt *p_ptt = ecore_ptt_acquire(p_hwfn);
	u32 num_images, i, j, nvm_crc, calc_crc;
	struct bist_nvm_image_att image_att;
	u8 *buf = OSAL_NULL;
	OSAL_BE32 val;
	enum _ecore_status_t rc;

	if (!p_ptt) {
		DP_ERR(p_hwfn, "failed to acquire ptt\n");
		return ECORE_BUSY;
	}

	/* Acquire from MFW the amount of available images */
	rc = ecore_mcp_bist_nvm_test_get_num_images(p_hwfn, p_ptt, &num_images);
	if ((rc != ECORE_SUCCESS) || (num_images == 0)) {
		DP_ERR(p_hwfn, "Failed getting number of images\n");
		return ECORE_INVAL;
	}

	/* 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 = ecore_mcp_bist_nvm_test_get_image_att(p_hwfn, p_ptt,
							   &image_att, i);
		if (rc != ECORE_SUCCESS) {
			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, ECORE_MSG_SP, "image index %d, size %x\n", i,
			   image_att.len);

		/* Allocate a buffer for holding the nvram image */
		buf = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, image_att.len);
		if (!buf) {
			DP_ERR(p_hwfn,
			       "Failed allocating memory for image index %d.\n",
			       i);
			rc = ECORE_NOMEM;
			goto err0;
		}

		/* Read image into buffer */
		rc = ecore_mcp_nvm_read(p_hwfn->p_dev, image_att.nvm_start_addr,
					buf, image_att.len);
		if (rc != ECORE_SUCCESS) {
			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 = OSAL_CPU_TO_BE32(*(u32 *)&buf[j]);
			*(u32 *)&buf[j] = 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 = OSAL_CRC32(0xffffffff , buf, image_att.len - 4);
		calc_crc = ~OSAL_CPU_TO_BE32(calc_crc);
		DP_VERBOSE(p_hwfn, ECORE_MSG_SP,
			   "nvm crc 0x%x, calc_crc 0x%x\n", nvm_crc, calc_crc);

		if (calc_crc != nvm_crc) {
			rc = ECORE_UNKNOWN_ERROR;
			goto err1;
		}

		/* Done with this image */
		OSAL_FREE(p_hwfn->p_dev, buf);
		buf = OSAL_NULL;
	}

	ecore_ptt_release(p_hwfn, p_ptt);
	return ECORE_SUCCESS;

err1:
	OSAL_FREE(p_hwfn->p_dev, buf);
err0:
	ecore_ptt_release(p_hwfn, p_ptt);
	return rc;
}