drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c - manifest_repos/valens - Git at Google

 /*
  * drivers/net/ethernet/mellanox/mlxfw/mlxfw.c
  * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
  * Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the names of the copyright holders nor the names of its
  *    contributors may be used to endorse or promote products derived from
  *    this software without specific prior written permission.
  *
  * Alternatively, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") version 2 as published by the Free
  * Software Foundation.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */

 #define pr_fmt(fmt) "mlxfw: " fmt

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/delay.h>

 #include "mlxfw.h"
 #include "mlxfw_mfa2.h"

 #define MLXFW_FSM_STATE_WAIT_CYCLE_MS 200
 #define MLXFW_FSM_STATE_WAIT_TIMEOUT_MS 30000
 #define MLXFW_FSM_STATE_WAIT_ROUNDS \
 	(MLXFW_FSM_STATE_WAIT_TIMEOUT_MS / MLXFW_FSM_STATE_WAIT_CYCLE_MS)
 #define MLXFW_FSM_MAX_COMPONENT_SIZE (10 * (1 << 20))

 static const char * const mlxfw_fsm_state_err_str[] = {
 	[MLXFW_FSM_STATE_ERR_ERROR] =
 		"general error",
 	[MLXFW_FSM_STATE_ERR_REJECTED_DIGEST_ERR] =
 		"component hash mismatch",
 	[MLXFW_FSM_STATE_ERR_REJECTED_NOT_APPLICABLE] =
 		"component not applicable",
 	[MLXFW_FSM_STATE_ERR_REJECTED_UNKNOWN_KEY] =
 		"unknown key",
 	[MLXFW_FSM_STATE_ERR_REJECTED_AUTH_FAILED] =
 		"authentication failed",
 	[MLXFW_FSM_STATE_ERR_REJECTED_UNSIGNED] =
 		"component was not signed",
 	[MLXFW_FSM_STATE_ERR_REJECTED_KEY_NOT_APPLICABLE] =
 		"key not applicable",
 	[MLXFW_FSM_STATE_ERR_REJECTED_BAD_FORMAT] =
 		"bad format",
 	[MLXFW_FSM_STATE_ERR_BLOCKED_PENDING_RESET] =
 		"pending reset",
 	[MLXFW_FSM_STATE_ERR_MAX] =
 		"unknown error"
 };

 static int mlxfw_fsm_state_wait(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
 				enum mlxfw_fsm_state fsm_state)
 {
 	enum mlxfw_fsm_state_err fsm_state_err;
 	enum mlxfw_fsm_state curr_fsm_state;
 	int times;
 	int err;

 	times = MLXFW_FSM_STATE_WAIT_ROUNDS;
 retry:
 	err = mlxfw_dev->ops->fsm_query_state(mlxfw_dev, fwhandle,
 					      &curr_fsm_state, &fsm_state_err);
 	if (err)
 		return err;

 	if (fsm_state_err != MLXFW_FSM_STATE_ERR_OK) {
 		fsm_state_err = min_t(enum mlxfw_fsm_state_err,
 				      fsm_state_err, MLXFW_FSM_STATE_ERR_MAX);
 		pr_err("Firmware flash failed: %s\n",
 		       mlxfw_fsm_state_err_str[fsm_state_err]);
 		return -EINVAL;
 	}
 	if (curr_fsm_state != fsm_state) {
 		if (--times == 0) {
 			pr_err("Timeout reached on FSM state change");
 			return -ETIMEDOUT;
 		}
 		msleep(MLXFW_FSM_STATE_WAIT_CYCLE_MS);
 		goto retry;
 	}
 	return 0;
 }

 #define MLXFW_ALIGN_DOWN(x, align_bits) ((x) & ~((1 << (align_bits)) - 1))
 #define MLXFW_ALIGN_UP(x, align_bits) \
 		MLXFW_ALIGN_DOWN((x) + ((1 << (align_bits)) - 1), (align_bits))

 static int mlxfw_flash_component(struct mlxfw_dev *mlxfw_dev,
 				 u32 fwhandle,
 				 struct mlxfw_mfa2_component *comp)
 {
 	u16 comp_max_write_size;
 	u8 comp_align_bits;
 	u32 comp_max_size;
 	u16 block_size;
 	u8 *block_ptr;
 	u32 offset;
 	int err;

 	err = mlxfw_dev->ops->component_query(mlxfw_dev, comp->index,
 					      &comp_max_size, &comp_align_bits,
 					      &comp_max_write_size);
 	if (err)
 		return err;

 	comp_max_size = min_t(u32, comp_max_size, MLXFW_FSM_MAX_COMPONENT_SIZE);
 	if (comp->data_size > comp_max_size) {
 		pr_err("Component %d is of size %d which is bigger than limit %d\n",
 		       comp->index, comp->data_size, comp_max_size);
 		return -EINVAL;
 	}

 	comp_max_write_size = MLXFW_ALIGN_DOWN(comp_max_write_size,
 					       comp_align_bits);

 	pr_debug("Component update\n");
 	err = mlxfw_dev->ops->fsm_component_update(mlxfw_dev, fwhandle,
 						   comp->index,
 						   comp->data_size);
 	if (err)
 		return err;

 	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
 				   MLXFW_FSM_STATE_DOWNLOAD);
 	if (err)
 		goto err_out;

 	pr_debug("Component download\n");
 	for (offset = 0;
 	     offset < MLXFW_ALIGN_UP(comp->data_size, comp_align_bits);
 	     offset += comp_max_write_size) {
 		block_ptr = comp->data + offset;
 		block_size = (u16) min_t(u32, comp->data_size - offset,
 					 comp_max_write_size);
 		err = mlxfw_dev->ops->fsm_block_download(mlxfw_dev, fwhandle,
 							 block_ptr, block_size,
 							 offset);
 		if (err)
 			goto err_out;
 	}

 	pr_debug("Component verify\n");
 	err = mlxfw_dev->ops->fsm_component_verify(mlxfw_dev, fwhandle,
 						   comp->index);
 	if (err)
 		goto err_out;

 	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
 	if (err)
 		goto err_out;
 	return 0;

 err_out:
 	mlxfw_dev->ops->fsm_cancel(mlxfw_dev, fwhandle);
 	return err;
 }

 static int mlxfw_flash_components(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
 				  struct mlxfw_mfa2_file *mfa2_file)
 {
 	u32 component_count;
 	int err;
 	int i;

 	err = mlxfw_mfa2_file_component_count(mfa2_file, mlxfw_dev->psid,
 					      mlxfw_dev->psid_size,
 					      &component_count);
 	if (err) {
 		pr_err("Could not find device PSID in MFA2 file\n");
 		return err;
 	}

 	for (i = 0; i < component_count; i++) {
 		struct mlxfw_mfa2_component *comp;

 		comp = mlxfw_mfa2_file_component_get(mfa2_file, mlxfw_dev->psid,
 						     mlxfw_dev->psid_size, i);
 		if (IS_ERR(comp))
 			return PTR_ERR(comp);

 		pr_info("Flashing component type %d\n", comp->index);
 		err = mlxfw_flash_component(mlxfw_dev, fwhandle, comp);
 		mlxfw_mfa2_file_component_put(comp);
 		if (err)
 			return err;
 	}
 	return 0;
 }

 int mlxfw_firmware_flash(struct mlxfw_dev *mlxfw_dev,
 			 const struct firmware *firmware)
 {
 	struct mlxfw_mfa2_file *mfa2_file;
 	u32 fwhandle;
 	int err;

 	if (!mlxfw_mfa2_check(firmware)) {
 		pr_err("Firmware file is not MFA2\n");
 		return -EINVAL;
 	}

 	mfa2_file = mlxfw_mfa2_file_init(firmware);
 	if (IS_ERR(mfa2_file))
 		return PTR_ERR(mfa2_file);

 	pr_info("Initialize firmware flash process\n");
 	err = mlxfw_dev->ops->fsm_lock(mlxfw_dev, &fwhandle);
 	if (err) {
 		pr_err("Could not lock the firmware FSM\n");
 		goto err_fsm_lock;
 	}

 	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
 				   MLXFW_FSM_STATE_LOCKED);
 	if (err)
 		goto err_state_wait_idle_to_locked;

 	err = mlxfw_flash_components(mlxfw_dev, fwhandle, mfa2_file);
 	if (err)
 		goto err_flash_components;

 	pr_debug("Activate image\n");
 	err = mlxfw_dev->ops->fsm_activate(mlxfw_dev, fwhandle);
 	if (err) {
 		pr_err("Could not activate the downloaded image\n");
 		goto err_fsm_activate;
 	}

 	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
 	if (err)
 		goto err_state_wait_activate_to_locked;

 	pr_debug("Handle release\n");
 	mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);

 	pr_info("Firmware flash done.\n");
 	mlxfw_mfa2_file_fini(mfa2_file);
 	return 0;

 err_state_wait_activate_to_locked:
 err_fsm_activate:
 err_flash_components:
 err_state_wait_idle_to_locked:
 	mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);
 err_fsm_lock:
 	mlxfw_mfa2_file_fini(mfa2_file);
 	return err;
 }
 EXPORT_SYMBOL(mlxfw_firmware_flash);

 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Yotam Gigi <yotamg@mellanox.com>");
 MODULE_DESCRIPTION("Mellanox firmware flash lib");
	/*
	* drivers/net/ethernet/mellanox/mlxfw/mlxfw.c
	* Copyright (c) 2017 Mellanox Technologies. All rights reserved.
	* Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the names of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* Alternatively, this software may be distributed under the terms of the
	* GNU General Public License ("GPL") version 2 as published by the Free
	* Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*/

	#define pr_fmt(fmt) "mlxfw: " fmt

	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/delay.h>

	#include "mlxfw.h"
	#include "mlxfw_mfa2.h"

	#define MLXFW_FSM_STATE_WAIT_CYCLE_MS 200
	#define MLXFW_FSM_STATE_WAIT_TIMEOUT_MS 30000
	#define MLXFW_FSM_STATE_WAIT_ROUNDS \
	(MLXFW_FSM_STATE_WAIT_TIMEOUT_MS / MLXFW_FSM_STATE_WAIT_CYCLE_MS)
	#define MLXFW_FSM_MAX_COMPONENT_SIZE (10 * (1 << 20))

	static const char * const mlxfw_fsm_state_err_str[] = {
	[MLXFW_FSM_STATE_ERR_ERROR] =
	"general error",
	[MLXFW_FSM_STATE_ERR_REJECTED_DIGEST_ERR] =
	"component hash mismatch",
	[MLXFW_FSM_STATE_ERR_REJECTED_NOT_APPLICABLE] =
	"component not applicable",
	[MLXFW_FSM_STATE_ERR_REJECTED_UNKNOWN_KEY] =
	"unknown key",
	[MLXFW_FSM_STATE_ERR_REJECTED_AUTH_FAILED] =
	"authentication failed",
	[MLXFW_FSM_STATE_ERR_REJECTED_UNSIGNED] =
	"component was not signed",
	[MLXFW_FSM_STATE_ERR_REJECTED_KEY_NOT_APPLICABLE] =
	"key not applicable",
	[MLXFW_FSM_STATE_ERR_REJECTED_BAD_FORMAT] =
	"bad format",
	[MLXFW_FSM_STATE_ERR_BLOCKED_PENDING_RESET] =
	"pending reset",
	[MLXFW_FSM_STATE_ERR_MAX] =
	"unknown error"
	};

	static int mlxfw_fsm_state_wait(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
	enum mlxfw_fsm_state fsm_state)
	{
	enum mlxfw_fsm_state_err fsm_state_err;
	enum mlxfw_fsm_state curr_fsm_state;
	int times;
	int err;

	times = MLXFW_FSM_STATE_WAIT_ROUNDS;
	retry:
	err = mlxfw_dev->ops->fsm_query_state(mlxfw_dev, fwhandle,
	&curr_fsm_state, &fsm_state_err);
	if (err)
	return err;

	if (fsm_state_err != MLXFW_FSM_STATE_ERR_OK) {
	fsm_state_err = min_t(enum mlxfw_fsm_state_err,
	fsm_state_err, MLXFW_FSM_STATE_ERR_MAX);
	pr_err("Firmware flash failed: %s\n",
	mlxfw_fsm_state_err_str[fsm_state_err]);
	return -EINVAL;
	}
	if (curr_fsm_state != fsm_state) {
	if (--times == 0) {
	pr_err("Timeout reached on FSM state change");
	return -ETIMEDOUT;
	}
	msleep(MLXFW_FSM_STATE_WAIT_CYCLE_MS);
	goto retry;
	}
	return 0;
	}

	#define MLXFW_ALIGN_DOWN(x, align_bits) ((x) & ~((1 << (align_bits)) - 1))
	#define MLXFW_ALIGN_UP(x, align_bits) \
	MLXFW_ALIGN_DOWN((x) + ((1 << (align_bits)) - 1), (align_bits))

	static int mlxfw_flash_component(struct mlxfw_dev *mlxfw_dev,
	u32 fwhandle,
	struct mlxfw_mfa2_component *comp)
	{
	u16 comp_max_write_size;
	u8 comp_align_bits;
	u32 comp_max_size;
	u16 block_size;
	u8 *block_ptr;
	u32 offset;
	int err;

	err = mlxfw_dev->ops->component_query(mlxfw_dev, comp->index,
	&comp_max_size, &comp_align_bits,
	&comp_max_write_size);
	if (err)
	return err;

	comp_max_size = min_t(u32, comp_max_size, MLXFW_FSM_MAX_COMPONENT_SIZE);
	if (comp->data_size > comp_max_size) {
	pr_err("Component %d is of size %d which is bigger than limit %d\n",
	comp->index, comp->data_size, comp_max_size);
	return -EINVAL;
	}

	comp_max_write_size = MLXFW_ALIGN_DOWN(comp_max_write_size,
	comp_align_bits);

	pr_debug("Component update\n");
	err = mlxfw_dev->ops->fsm_component_update(mlxfw_dev, fwhandle,
	comp->index,
	comp->data_size);
	if (err)
	return err;

	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
	MLXFW_FSM_STATE_DOWNLOAD);
	if (err)
	goto err_out;

	pr_debug("Component download\n");
	for (offset = 0;
	offset < MLXFW_ALIGN_UP(comp->data_size, comp_align_bits);
	offset += comp_max_write_size) {
	block_ptr = comp->data + offset;
	block_size = (u16) min_t(u32, comp->data_size - offset,
	comp_max_write_size);
	err = mlxfw_dev->ops->fsm_block_download(mlxfw_dev, fwhandle,
	block_ptr, block_size,
	offset);
	if (err)
	goto err_out;
	}

	pr_debug("Component verify\n");
	err = mlxfw_dev->ops->fsm_component_verify(mlxfw_dev, fwhandle,
	comp->index);
	if (err)
	goto err_out;

	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
	if (err)
	goto err_out;
	return 0;

	err_out:
	mlxfw_dev->ops->fsm_cancel(mlxfw_dev, fwhandle);
	return err;
	}

	static int mlxfw_flash_components(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
	struct mlxfw_mfa2_file *mfa2_file)
	{
	u32 component_count;
	int err;
	int i;

	err = mlxfw_mfa2_file_component_count(mfa2_file, mlxfw_dev->psid,
	mlxfw_dev->psid_size,
	&component_count);
	if (err) {
	pr_err("Could not find device PSID in MFA2 file\n");
	return err;
	}

	for (i = 0; i < component_count; i++) {
	struct mlxfw_mfa2_component *comp;

	comp = mlxfw_mfa2_file_component_get(mfa2_file, mlxfw_dev->psid,
	mlxfw_dev->psid_size, i);
	if (IS_ERR(comp))
	return PTR_ERR(comp);

	pr_info("Flashing component type %d\n", comp->index);
	err = mlxfw_flash_component(mlxfw_dev, fwhandle, comp);
	mlxfw_mfa2_file_component_put(comp);
	if (err)
	return err;
	}
	return 0;
	}

	int mlxfw_firmware_flash(struct mlxfw_dev *mlxfw_dev,
	const struct firmware *firmware)
	{
	struct mlxfw_mfa2_file *mfa2_file;
	u32 fwhandle;
	int err;

	if (!mlxfw_mfa2_check(firmware)) {
	pr_err("Firmware file is not MFA2\n");
	return -EINVAL;
	}

	mfa2_file = mlxfw_mfa2_file_init(firmware);
	if (IS_ERR(mfa2_file))
	return PTR_ERR(mfa2_file);

	pr_info("Initialize firmware flash process\n");
	err = mlxfw_dev->ops->fsm_lock(mlxfw_dev, &fwhandle);
	if (err) {
	pr_err("Could not lock the firmware FSM\n");
	goto err_fsm_lock;
	}

	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
	MLXFW_FSM_STATE_LOCKED);
	if (err)
	goto err_state_wait_idle_to_locked;

	err = mlxfw_flash_components(mlxfw_dev, fwhandle, mfa2_file);
	if (err)
	goto err_flash_components;

	pr_debug("Activate image\n");
	err = mlxfw_dev->ops->fsm_activate(mlxfw_dev, fwhandle);
	if (err) {
	pr_err("Could not activate the downloaded image\n");
	goto err_fsm_activate;
	}

	err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
	if (err)
	goto err_state_wait_activate_to_locked;

	pr_debug("Handle release\n");
	mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);

	pr_info("Firmware flash done.\n");
	mlxfw_mfa2_file_fini(mfa2_file);
	return 0;

	err_state_wait_activate_to_locked:
	err_fsm_activate:
	err_flash_components:
	err_state_wait_idle_to_locked:
	mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);
	err_fsm_lock:
	mlxfw_mfa2_file_fini(mfa2_file);
	return err;
	}
	EXPORT_SYMBOL(mlxfw_firmware_flash);

	MODULE_LICENSE("Dual BSD/GPL");
	MODULE_AUTHOR("Yotam Gigi <yotamg@mellanox.com>");
	MODULE_DESCRIPTION("Mellanox firmware flash lib");