drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxfw/mlxfw.c
   3  * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the names of the copyright holders nor the names of its
  15  *    contributors may be used to endorse or promote products derived from
  16  *    this software without specific prior written permission.
  17  *
  18  * Alternatively, this software may be distributed under the terms of the
  19  * GNU General Public License ("GPL") version 2 as published by the Free
  20  * Software Foundation.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #define pr_fmt(fmt) "mlxfw: " fmt
  36
  37 #include <linux/kernel.h>
  38 #include <linux/module.h>
  39 #include <linux/delay.h>
  40
  41 #include "mlxfw.h"
  42 #include "mlxfw_mfa2.h"
  43
  44 #define MLXFW_FSM_STATE_WAIT_CYCLE_MS 200
  45 #define MLXFW_FSM_STATE_WAIT_TIMEOUT_MS 30000
  46 #define MLXFW_FSM_STATE_WAIT_ROUNDS \
  47         (MLXFW_FSM_STATE_WAIT_TIMEOUT_MS / MLXFW_FSM_STATE_WAIT_CYCLE_MS)
  48 #define MLXFW_FSM_MAX_COMPONENT_SIZE (10 * (1 << 20))
  49
  50 static const char * const mlxfw_fsm_state_err_str[] = {
  51         [MLXFW_FSM_STATE_ERR_ERROR] =
  52                 "general error",
  53         [MLXFW_FSM_STATE_ERR_REJECTED_DIGEST_ERR] =
  54                 "component hash mismatch",
  55         [MLXFW_FSM_STATE_ERR_REJECTED_NOT_APPLICABLE] =
  56                 "component not applicable",
  57         [MLXFW_FSM_STATE_ERR_REJECTED_UNKNOWN_KEY] =
  58                 "unknown key",
  59         [MLXFW_FSM_STATE_ERR_REJECTED_AUTH_FAILED] =
  60                 "authentication failed",
  61         [MLXFW_FSM_STATE_ERR_REJECTED_UNSIGNED] =
  62                 "component was not signed",
  63         [MLXFW_FSM_STATE_ERR_REJECTED_KEY_NOT_APPLICABLE] =
  64                 "key not applicable",
  65         [MLXFW_FSM_STATE_ERR_REJECTED_BAD_FORMAT] =
  66                 "bad format",
  67         [MLXFW_FSM_STATE_ERR_BLOCKED_PENDING_RESET] =
  68                 "pending reset",
  69         [MLXFW_FSM_STATE_ERR_MAX] =
  70                 "unknown error"
  71 };
  72
  73 static int mlxfw_fsm_state_wait(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
  74                                 enum mlxfw_fsm_state fsm_state)
  75 {
  76         enum mlxfw_fsm_state_err fsm_state_err;
  77         enum mlxfw_fsm_state curr_fsm_state;
  78         int times;
  79         int err;
  80
  81         times = MLXFW_FSM_STATE_WAIT_ROUNDS;
  82 retry:
  83         err = mlxfw_dev->ops->fsm_query_state(mlxfw_dev, fwhandle,
  84                                               &curr_fsm_state, &fsm_state_err);
  85         if (err)
  86                 return err;
  87
  88         if (fsm_state_err != MLXFW_FSM_STATE_ERR_OK) {
  89                 fsm_state_err = min_t(enum mlxfw_fsm_state_err,
  90                                       fsm_state_err, MLXFW_FSM_STATE_ERR_MAX);
  91                 pr_err("Firmware flash failed: %s\n",
  92                        mlxfw_fsm_state_err_str[fsm_state_err]);
  93                 return -EINVAL;
  94         }
  95         if (curr_fsm_state != fsm_state) {
  96                 if (--times == 0) {
  97                         pr_err("Timeout reached on FSM state change");
  98                         return -ETIMEDOUT;
  99                 }
 100                 msleep(MLXFW_FSM_STATE_WAIT_CYCLE_MS);
 101                 goto retry;
 102         }
 103         return 0;
 104 }
 105
 106 #define MLXFW_ALIGN_DOWN(x, align_bits) ((x) & ~((1 << (align_bits)) - 1))
 107 #define MLXFW_ALIGN_UP(x, align_bits) \
 108                 MLXFW_ALIGN_DOWN((x) + ((1 << (align_bits)) - 1), (align_bits))
 109
 110 static int mlxfw_flash_component(struct mlxfw_dev *mlxfw_dev,
 111                                  u32 fwhandle,
 112                                  struct mlxfw_mfa2_component *comp)
 113 {
 114         u16 comp_max_write_size;
 115         u8 comp_align_bits;
 116         u32 comp_max_size;
 117         u16 block_size;
 118         u8 *block_ptr;
 119         u32 offset;
 120         int err;
 121
 122         err = mlxfw_dev->ops->component_query(mlxfw_dev, comp->index,
 123                                               &comp_max_size, &comp_align_bits,
 124                                               &comp_max_write_size);
 125         if (err)
 126                 return err;
 127
 128         comp_max_size = min_t(u32, comp_max_size, MLXFW_FSM_MAX_COMPONENT_SIZE);
 129         if (comp->data_size > comp_max_size) {
 130                 pr_err("Component %d is of size %d which is bigger than limit %d\n",
 131                        comp->index, comp->data_size, comp_max_size);
 132                 return -EINVAL;
 133         }
 134
 135         comp_max_write_size = MLXFW_ALIGN_DOWN(comp_max_write_size,
 136                                                comp_align_bits);
 137
 138         pr_debug("Component update\n");
 139         err = mlxfw_dev->ops->fsm_component_update(mlxfw_dev, fwhandle,
 140                                                    comp->index,
 141                                                    comp->data_size);
 142         if (err)
 143                 return err;
 144
 145         err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
 146                                    MLXFW_FSM_STATE_DOWNLOAD);
 147         if (err)
 148                 goto err_out;
 149
 150         pr_debug("Component download\n");
 151         for (offset = 0;
 152              offset < MLXFW_ALIGN_UP(comp->data_size, comp_align_bits);
 153              offset += comp_max_write_size) {
 154                 block_ptr = comp->data + offset;
 155                 block_size = (u16) min_t(u32, comp->data_size - offset,
 156                                          comp_max_write_size);
 157                 err = mlxfw_dev->ops->fsm_block_download(mlxfw_dev, fwhandle,
 158                                                          block_ptr, block_size,
 159                                                          offset);
 160                 if (err)
 161                         goto err_out;
 162         }
 163
 164         pr_debug("Component verify\n");
 165         err = mlxfw_dev->ops->fsm_component_verify(mlxfw_dev, fwhandle,
 166                                                    comp->index);
 167         if (err)
 168                 goto err_out;
 169
 170         err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
 171         if (err)
 172                 goto err_out;
 173         return 0;
 174
 175 err_out:
 176         mlxfw_dev->ops->fsm_cancel(mlxfw_dev, fwhandle);
 177         return err;
 178 }
 179
 180 static int mlxfw_flash_components(struct mlxfw_dev *mlxfw_dev, u32 fwhandle,
 181                                   struct mlxfw_mfa2_file *mfa2_file)
 182 {
 183         u32 component_count;
 184         int err;
 185         int i;
 186
 187         err = mlxfw_mfa2_file_component_count(mfa2_file, mlxfw_dev->psid,
 188                                               mlxfw_dev->psid_size,
 189                                               &component_count);
 190         if (err) {
 191                 pr_err("Could not find device PSID in MFA2 file\n");
 192                 return err;
 193         }
 194
 195         for (i = 0; i < component_count; i++) {
 196                 struct mlxfw_mfa2_component *comp;
 197
 198                 comp = mlxfw_mfa2_file_component_get(mfa2_file, mlxfw_dev->psid,
 199                                                      mlxfw_dev->psid_size, i);
 200                 if (IS_ERR(comp))
 201                         return PTR_ERR(comp);
 202
 203                 pr_info("Flashing component type %d\n", comp->index);
 204                 err = mlxfw_flash_component(mlxfw_dev, fwhandle, comp);
 205                 mlxfw_mfa2_file_component_put(comp);
 206                 if (err)
 207                         return err;
 208         }
 209         return 0;
 210 }
 211
 212 int mlxfw_firmware_flash(struct mlxfw_dev *mlxfw_dev,
 213                          const struct firmware *firmware)
 214 {
 215         struct mlxfw_mfa2_file *mfa2_file;
 216         u32 fwhandle;
 217         int err;
 218
 219         if (!mlxfw_mfa2_check(firmware)) {
 220                 pr_err("Firmware file is not MFA2\n");
 221                 return -EINVAL;
 222         }
 223
 224         mfa2_file = mlxfw_mfa2_file_init(firmware);
 225         if (IS_ERR(mfa2_file))
 226                 return PTR_ERR(mfa2_file);
 227
 228         pr_info("Initialize firmware flash process\n");
 229         err = mlxfw_dev->ops->fsm_lock(mlxfw_dev, &fwhandle);
 230         if (err) {
 231                 pr_err("Could not lock the firmware FSM\n");
 232                 goto err_fsm_lock;
 233         }
 234
 235         err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle,
 236                                    MLXFW_FSM_STATE_LOCKED);
 237         if (err)
 238                 goto err_state_wait_idle_to_locked;
 239
 240         err = mlxfw_flash_components(mlxfw_dev, fwhandle, mfa2_file);
 241         if (err)
 242                 goto err_flash_components;
 243
 244         pr_debug("Activate image\n");
 245         err = mlxfw_dev->ops->fsm_activate(mlxfw_dev, fwhandle);
 246         if (err) {
 247                 pr_err("Could not activate the downloaded image\n");
 248                 goto err_fsm_activate;
 249         }
 250
 251         err = mlxfw_fsm_state_wait(mlxfw_dev, fwhandle, MLXFW_FSM_STATE_LOCKED);
 252         if (err)
 253                 goto err_state_wait_activate_to_locked;
 254
 255         pr_debug("Handle release\n");
 256         mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);
 257
 258         pr_info("Firmware flash done.\n");
 259         mlxfw_mfa2_file_fini(mfa2_file);
 260         return 0;
 261
 262 err_state_wait_activate_to_locked:
 263 err_fsm_activate:
 264 err_flash_components:
 265 err_state_wait_idle_to_locked:
 266         mlxfw_dev->ops->fsm_release(mlxfw_dev, fwhandle);
 267 err_fsm_lock:
 268         mlxfw_mfa2_file_fini(mfa2_file);
 269         return err;
 270 }
 271 EXPORT_SYMBOL(mlxfw_firmware_flash);
 272
 273 MODULE_LICENSE("Dual BSD/GPL");
 274 MODULE_AUTHOR("Yotam Gigi <yotamg@mellanox.com>");
 275 MODULE_DESCRIPTION("Mellanox firmware flash lib");