sys/dev/mlxfw/mlxfw_mfa2.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2017-2019 Mellanox Technologies.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of Mellanox nor the names of contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD$
  32  */
  33
  34 #define pr_fmt(fmt) "mlxfw_mfa2: " fmt
  35
  36 #include <linux/kernel.h>
  37 #include <linux/module.h>
  38 #include <linux/printk.h>
  39 #include <contrib/xz-embedded/linux/include/linux/xz.h>
  40
  41 #include "mlxfw_mfa2.h"
  42 #include "mlxfw_mfa2_file.h"
  43 #include "mlxfw_mfa2_tlv.h"
  44 #include "mlxfw_mfa2_format.h"
  45 #include "mlxfw_mfa2_tlv_multi.h"
  46
  47 /*               MFA2 FILE
  48  *  +----------------------------------+
  49  *  |        MFA2 finger print         |
  50  *  +----------------------------------+
  51  *  |   package descriptor multi_tlv   |
  52  *  | +------------------------------+ |     +-----------------+
  53  *  | |    package descriptor tlv    +-----> |num_devices=n    |
  54  *  | +------------------------------+ |     |num_components=m |
  55  *  +----------------------------------+     |CB offset        |
  56  *  |    device descriptor multi_tlv   |     |...              |
  57  *  | +------------------------------+ |     |                 |
  58  *  | |           PSID tlv           | |     +-----------------+
  59  *  | +------------------------------+ |
  60  *  | |     component index tlv      | |
  61  *  | +------------------------------+ |
  62  *  +----------------------------------+
  63  *  |  component descriptor multi_tlv  |
  64  *  | +------------------------------+ |     +-----------------+
  65  *  | |  component descriptor tlv    +-----> |Among others:    |
  66  *  | +------------------------------+ |     |CB offset=o      |
  67  *  +----------------------------------+     |comp index=i     |
  68  *  |                                  |     |...              |
  69  *  |                                  |     |                 |
  70  *  |                                  |     +-----------------+
  71  *  |        COMPONENT BLOCK (CB)      |
  72  *  |                                  |
  73  *  |                                  |
  74  *  |                                  |
  75  *  +----------------------------------+
  76  *
  77  * On the top level, an MFA2 file contains:
  78  *  - Fingerprint
  79  *  - Several multi_tlvs (TLVs of type MLXFW_MFA2_TLV_MULTI, as defined in
  80  *    mlxfw_mfa2_format.h)
  81  *  - Compresses content block
  82  *
  83  * The first multi_tlv
  84  * -------------------
  85  * The first multi TLV is treated as package descriptor, and expected to have a
  86  * first TLV child of type MLXFW_MFA2_TLV_PACKAGE_DESCRIPTOR which contains all
  87  * the global information needed to parse the file. Among others, it contains
  88  * the number of device descriptors and component descriptor following this
  89  * multi TLV.
  90  *
  91  * The device descriptor multi_tlv
  92  * -------------------------------
  93  * The multi TLVs following the package descriptor are treated as device
  94  * descriptor, and are expected to have the following children:
  95  *  - PSID TLV child of type MLXFW_MFA2_TLV_PSID containing that device PSID.
  96  *  - Component index of type MLXFW_MFA2_TLV_COMPONENT_PTR that contains that
  97  *    device component index.
  98  *
  99  * The component descriptor multi_tlv
 100  * ----------------------------------
 101  * The multi TLVs following the device descriptor multi TLVs are treated as
 102  * component descriptor, and are expected to have a first child of type
 103  * MLXFW_MFA2_TLV_COMPONENT_DESCRIPTOR that contains mostly the component index,
 104  * needed for the flash process and the offset to the binary within the
 105  * component block.
 106  */
 107
 108 static const u8 mlxfw_mfa2_fingerprint[] = "MLNX.MFA2.XZ.00!";
 109 static const int mlxfw_mfa2_fingerprint_len =
 110                         sizeof(mlxfw_mfa2_fingerprint) - 1;
 111
 112 static const u8 mlxfw_mfa2_comp_magic[] = "#BIN.COMPONENT!#";
 113 static const int mlxfw_mfa2_comp_magic_len = sizeof(mlxfw_mfa2_comp_magic) - 1;
 114
 115 bool mlxfw_mfa2_check(const struct firmware *fw)
 116 {
 117         if (fw->datasize < sizeof(mlxfw_mfa2_fingerprint))
 118                 return false;
 119
 120         return memcmp(fw->data, mlxfw_mfa2_fingerprint,
 121                       mlxfw_mfa2_fingerprint_len) == 0;
 122 }
 123
 124 static bool
 125 mlxfw_mfa2_tlv_multi_validate(const struct mlxfw_mfa2_file *mfa2_file,
 126                               const struct mlxfw_mfa2_tlv_multi *multi)
 127 {
 128         const struct mlxfw_mfa2_tlv *tlv;
 129         u16 idx;
 130
 131         /* Check that all children are valid */
 132         mlxfw_mfa2_tlv_multi_foreach(mfa2_file, tlv, idx, multi) {
 133                 if (!tlv) {
 134                         pr_err("Multi has invalid child");
 135                         return false;
 136                 }
 137         }
 138         return true;
 139 }
 140
 141 static bool
 142 mlxfw_mfa2_file_dev_validate(const struct mlxfw_mfa2_file *mfa2_file,
 143                              const struct mlxfw_mfa2_tlv *dev_tlv,
 144                              u16 dev_idx)
 145 {
 146         const struct mlxfw_mfa2_tlv_component_ptr *cptr;
 147         const struct mlxfw_mfa2_tlv_multi *multi;
 148         const struct mlxfw_mfa2_tlv_psid *psid;
 149         const struct mlxfw_mfa2_tlv *tlv;
 150         u16 cptr_count;
 151         u16 cptr_idx;
 152         int err;
 153
 154         pr_debug("Device %d\n", dev_idx);
 155
 156         multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, dev_tlv);
 157         if (!multi) {
 158                 pr_err("Device %d is not a valid TLV error\n", dev_idx);
 159                 return false;
 160         }
 161
 162         if (!mlxfw_mfa2_tlv_multi_validate(mfa2_file, multi))
 163                 return false;
 164
 165         /* Validate the device has PSID tlv */
 166         tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, multi,
 167                                               MLXFW_MFA2_TLV_PSID, 0);
 168         if (!tlv) {
 169                 pr_err("Device %d does not have PSID\n", dev_idx);
 170                 return false;
 171         }
 172
 173         psid = mlxfw_mfa2_tlv_psid_get(mfa2_file, tlv);
 174         if (!psid) {
 175                 pr_err("Device %d PSID TLV is not valid\n", dev_idx);
 176                 return false;
 177         }
 178
 179         print_hex_dump_debug("  -- Device PSID ", DUMP_PREFIX_NONE, 16, 16,
 180                              psid->psid, be16_to_cpu(tlv->len), true);
 181
 182         /* Validate the device has COMPONENT_PTR */
 183         err = mlxfw_mfa2_tlv_multi_child_count(mfa2_file, multi,
 184                                                MLXFW_MFA2_TLV_COMPONENT_PTR,
 185                                                &cptr_count);
 186         if (err)
 187                 return false;
 188
 189         if (cptr_count == 0) {
 190                 pr_err("Device %d has no components\n", dev_idx);
 191                 return false;
 192         }
 193
 194         for (cptr_idx = 0; cptr_idx < cptr_count; cptr_idx++) {
 195                 tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, multi,
 196                                                       MLXFW_MFA2_TLV_COMPONENT_PTR,
 197                                                       cptr_idx);
 198                 if (!tlv)
 199                         return false;
 200
 201                 cptr = mlxfw_mfa2_tlv_component_ptr_get(mfa2_file, tlv);
 202                 if (!cptr) {
 203                         pr_err("Device %d COMPONENT_PTR TLV is not valid\n",
 204                                dev_idx);
 205                         return false;
 206                 }
 207
 208                 pr_debug("  -- Component index %d\n",
 209                          be16_to_cpu(cptr->component_index));
 210         }
 211         return true;
 212 }
 213
 214 static bool
 215 mlxfw_mfa2_file_comp_validate(const struct mlxfw_mfa2_file *mfa2_file,
 216                               const struct mlxfw_mfa2_tlv *comp_tlv,
 217                               u16 comp_idx)
 218 {
 219         const struct mlxfw_mfa2_tlv_component_descriptor *cdesc;
 220         const struct mlxfw_mfa2_tlv_multi *multi;
 221         const struct mlxfw_mfa2_tlv *tlv;
 222
 223         pr_debug("Component %d\n", comp_idx);
 224
 225         multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, comp_tlv);
 226         if (!multi) {
 227                 pr_err("Component %d is not a valid TLV error\n", comp_idx);
 228                 return false;
 229         }
 230
 231         if (!mlxfw_mfa2_tlv_multi_validate(mfa2_file, multi))
 232                 return false;
 233
 234         /* Check that component have COMPONENT_DESCRIPTOR as first child */
 235         tlv = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
 236         if (!tlv) {
 237                 pr_err("Component descriptor %d multi TLV error\n", comp_idx);
 238                 return false;
 239         }
 240
 241         cdesc = mlxfw_mfa2_tlv_component_descriptor_get(mfa2_file, tlv);
 242         if (!cdesc) {
 243                 pr_err("Component %d does not have a valid descriptor\n",
 244                        comp_idx);
 245                 return false;
 246         }
 247         pr_debug("  -- Component type %d\n", be16_to_cpu(cdesc->identifier));
 248         pr_debug("  -- Offset %#jx and size %d\n",
 249                  (uintmax_t)((u64) be32_to_cpu(cdesc->cb_offset_h) << 32)
 250                  | be32_to_cpu(cdesc->cb_offset_l), be32_to_cpu(cdesc->size));
 251
 252         return true;
 253 }
 254
 255 static bool mlxfw_mfa2_file_validate(const struct mlxfw_mfa2_file *mfa2_file)
 256 {
 257         const struct mlxfw_mfa2_tlv *tlv;
 258         u16 idx;
 259
 260         pr_debug("Validating file\n");
 261
 262         /* check that all the devices exist */
 263         mlxfw_mfa2_tlv_foreach(mfa2_file, tlv, idx, mfa2_file->first_dev,
 264                                mfa2_file->dev_count) {
 265                 if (!tlv) {
 266                         pr_err("Device TLV error\n");
 267                         return false;
 268                 }
 269
 270                 /* Check each device */
 271                 if (!mlxfw_mfa2_file_dev_validate(mfa2_file, tlv, idx))
 272                         return false;
 273         }
 274
 275         /* check that all the components exist */
 276         mlxfw_mfa2_tlv_foreach(mfa2_file, tlv, idx, mfa2_file->first_component,
 277                                mfa2_file->component_count) {
 278                 if (!tlv) {
 279                         pr_err("Device TLV error\n");
 280                         return false;
 281                 }
 282
 283                 /* Check each component */
 284                 if (!mlxfw_mfa2_file_comp_validate(mfa2_file, tlv, idx))
 285                         return false;
 286         }
 287         return true;
 288 }
 289
 290 struct mlxfw_mfa2_file *mlxfw_mfa2_file_init(const struct firmware *fw)
 291 {
 292         const struct mlxfw_mfa2_tlv_package_descriptor *pd;
 293         const struct mlxfw_mfa2_tlv_multi *multi;
 294         const struct mlxfw_mfa2_tlv *multi_child;
 295         const struct mlxfw_mfa2_tlv *first_tlv;
 296         struct mlxfw_mfa2_file *mfa2_file;
 297         const u8 *first_tlv_ptr;
 298         const u8 *cb_top_ptr;
 299
 300         mfa2_file = kcalloc(1, sizeof(*mfa2_file), GFP_KERNEL);
 301         if (!mfa2_file)
 302                 return ERR_PTR(-ENOMEM);
 303
 304         mfa2_file->fw = fw;
 305         first_tlv_ptr = (const u8 *) fw->data + NLA_ALIGN(mlxfw_mfa2_fingerprint_len);
 306         first_tlv = mlxfw_mfa2_tlv_get(mfa2_file, first_tlv_ptr);
 307         if (!first_tlv) {
 308                 pr_err("Could not parse package descriptor TLV\n");
 309                 goto err_out;
 310         }
 311
 312         multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, first_tlv);
 313         if (!multi) {
 314                 pr_err("First TLV is not of valid multi type\n");
 315                 goto err_out;
 316         }
 317
 318         multi_child = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
 319         if (!multi_child)
 320                 goto err_out;
 321
 322         pd = mlxfw_mfa2_tlv_package_descriptor_get(mfa2_file, multi_child);
 323         if (!pd) {
 324                 pr_err("Could not parse package descriptor TLV\n");
 325                 goto err_out;
 326         }
 327
 328         mfa2_file->first_dev = mlxfw_mfa2_tlv_next(mfa2_file, first_tlv);
 329         if (!mfa2_file->first_dev) {
 330                 pr_err("First device TLV is not valid\n");
 331                 goto err_out;
 332         }
 333
 334         mfa2_file->dev_count = be16_to_cpu(pd->num_devices);
 335         mfa2_file->first_component = mlxfw_mfa2_tlv_advance(mfa2_file,
 336                                                             mfa2_file->first_dev,
 337                                                             mfa2_file->dev_count);
 338         mfa2_file->component_count = be16_to_cpu(pd->num_components);
 339         mfa2_file->cb = (const u8 *) fw->data + NLA_ALIGN(be32_to_cpu(pd->cb_offset));
 340         if (!mlxfw_mfa2_valid_ptr(mfa2_file, mfa2_file->cb)) {
 341                 pr_err("Component block is out side the file\n");
 342                 goto err_out;
 343         }
 344         mfa2_file->cb_archive_size = be32_to_cpu(pd->cb_archive_size);
 345         cb_top_ptr = (const u8 *) mfa2_file->cb + mfa2_file->cb_archive_size - 1;
 346         if (!mlxfw_mfa2_valid_ptr(mfa2_file, cb_top_ptr)) {
 347                 pr_err("Component block size is too big\n");
 348                 goto err_out;
 349         }
 350
 351         if (!mlxfw_mfa2_file_validate(mfa2_file))
 352                 goto err_out;
 353         return mfa2_file;
 354 err_out:
 355         kfree(mfa2_file);
 356         return ERR_PTR(-EINVAL);
 357 }
 358
 359 static const struct mlxfw_mfa2_tlv_multi *
 360 mlxfw_mfa2_tlv_dev_get(const struct mlxfw_mfa2_file *mfa2_file,
 361                        const char *psid, u16 psid_size)
 362 {
 363         const struct mlxfw_mfa2_tlv_psid *tlv_psid;
 364         const struct mlxfw_mfa2_tlv_multi *dev_multi;
 365         const struct mlxfw_mfa2_tlv *dev_tlv;
 366         const struct mlxfw_mfa2_tlv *tlv;
 367         u32 idx;
 368
 369         /* for each device tlv */
 370         mlxfw_mfa2_tlv_foreach(mfa2_file, dev_tlv, idx, mfa2_file->first_dev,
 371                                mfa2_file->dev_count) {
 372                 if (!dev_tlv)
 373                         return NULL;
 374
 375                 dev_multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, dev_tlv);
 376                 if (!dev_multi)
 377                         return NULL;
 378
 379                 /* find psid child and compare */
 380                 tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, dev_multi,
 381                                                       MLXFW_MFA2_TLV_PSID, 0);
 382                 if (!tlv)
 383                         return NULL;
 384                 if (be16_to_cpu(tlv->len) != psid_size)
 385                         continue;
 386
 387                 tlv_psid = mlxfw_mfa2_tlv_psid_get(mfa2_file, tlv);
 388                 if (!tlv_psid)
 389                         return NULL;
 390
 391                 if (memcmp(psid, tlv_psid->psid, psid_size) == 0)
 392                         return dev_multi;
 393         }
 394
 395         return NULL;
 396 }
 397
 398 int mlxfw_mfa2_file_component_count(const struct mlxfw_mfa2_file *mfa2_file,
 399                                     const char *psid, u32 psid_size,
 400                                     u32 *p_count)
 401 {
 402         const struct mlxfw_mfa2_tlv_multi *dev_multi;
 403         u16 count;
 404         int err;
 405
 406         dev_multi = mlxfw_mfa2_tlv_dev_get(mfa2_file, psid, psid_size);
 407         if (!dev_multi)
 408                 return -EINVAL;
 409
 410         err = mlxfw_mfa2_tlv_multi_child_count(mfa2_file, dev_multi,
 411                                                MLXFW_MFA2_TLV_COMPONENT_PTR,
 412                                                &count);
 413         if (err)
 414                 return err;
 415
 416         *p_count = count;
 417         return 0;
 418 }
 419
 420 static int mlxfw_mfa2_xz_dec_run(struct xz_dec *xz_dec, struct xz_buf *xz_buf,
 421                                  bool *finished)
 422 {
 423         enum xz_ret xz_ret;
 424
 425         xz_ret = xz_dec_run(xz_dec, xz_buf);
 426
 427         switch (xz_ret) {
 428         case XZ_STREAM_END:
 429                 *finished = true;
 430                 return 0;
 431         case XZ_OK:
 432                 *finished = false;
 433                 return 0;
 434         case XZ_MEM_ERROR:
 435                 pr_err("xz no memory\n");
 436                 return -ENOMEM;
 437         case XZ_DATA_ERROR:
 438                 pr_err("xz file corrupted\n");
 439                 return -EINVAL;
 440         case XZ_FORMAT_ERROR:
 441                 pr_err("xz format not found\n");
 442                 return -EINVAL;
 443         case XZ_OPTIONS_ERROR:
 444                 pr_err("unsupported xz option\n");
 445                 return -EINVAL;
 446         case XZ_MEMLIMIT_ERROR:
 447                 pr_err("xz dictionary too small\n");
 448                 return -EINVAL;
 449         default:
 450                 pr_err("xz error %d\n", xz_ret);
 451                 return -EINVAL;
 452         }
 453 }
 454
 455 static int mlxfw_mfa2_file_cb_offset_xz(const struct mlxfw_mfa2_file *mfa2_file,
 456                                         off_t off, size_t size, u8 *buf)
 457 {
 458         struct xz_dec *xz_dec;
 459         struct xz_buf dec_buf;
 460         off_t curr_off = 0;
 461         bool finished;
 462         int err;
 463
 464         xz_dec = xz_dec_init(XZ_DYNALLOC, (u32) -1);
 465         if (!xz_dec)
 466                 return -EINVAL;
 467
 468         dec_buf.in_size = mfa2_file->cb_archive_size;
 469         dec_buf.in = mfa2_file->cb;
 470         dec_buf.in_pos = 0;
 471         dec_buf.out = buf;
 472
 473         /* decode up to the offset */
 474         do {
 475                 dec_buf.out_pos = 0;
 476                 dec_buf.out_size = min_t(size_t, size, off - curr_off);
 477                 if (dec_buf.out_size == 0)
 478                         break;
 479
 480                 err = mlxfw_mfa2_xz_dec_run(xz_dec, &dec_buf, &finished);
 481                 if (err)
 482                         goto out;
 483                 if (finished) {
 484                         pr_err("xz section too short\n");
 485                         err = -EINVAL;
 486                         goto out;
 487                 }
 488                 curr_off += dec_buf.out_pos;
 489         } while (curr_off != off);
 490
 491         /* decode the needed section */
 492         dec_buf.out_pos = 0;
 493         dec_buf.out_size = size;
 494         err = mlxfw_mfa2_xz_dec_run(xz_dec, &dec_buf, &finished);
 495 out:
 496         xz_dec_end(xz_dec);
 497         return err;
 498 }
 499
 500 static const struct mlxfw_mfa2_tlv_component_descriptor *
 501 mlxfw_mfa2_file_component_tlv_get(const struct mlxfw_mfa2_file *mfa2_file,
 502                                   u16 comp_index)
 503 {
 504         const struct mlxfw_mfa2_tlv_multi *multi;
 505         const struct mlxfw_mfa2_tlv *multi_child;
 506         const struct mlxfw_mfa2_tlv *comp_tlv;
 507
 508         if (comp_index > mfa2_file->component_count)
 509                 return NULL;
 510
 511         comp_tlv = mlxfw_mfa2_tlv_advance(mfa2_file, mfa2_file->first_component,
 512                                           comp_index);
 513         if (!comp_tlv)
 514                 return NULL;
 515
 516         multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, comp_tlv);
 517         if (!multi)
 518                 return NULL;
 519
 520         multi_child = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
 521         if (!multi_child)
 522                 return NULL;
 523
 524         return mlxfw_mfa2_tlv_component_descriptor_get(mfa2_file, multi_child);
 525 }
 526
 527 struct mlxfw_mfa2_comp_data {
 528         struct mlxfw_mfa2_component comp;
 529         u8 buff[0];
 530 };
 531
 532 static const struct mlxfw_mfa2_tlv_component_descriptor *
 533 mlxfw_mfa2_file_component_find(const struct mlxfw_mfa2_file *mfa2_file,
 534                                const char *psid, int psid_size,
 535                                int component_index)
 536 {
 537         const struct mlxfw_mfa2_tlv_component_ptr *cptr;
 538         const struct mlxfw_mfa2_tlv_multi *dev_multi;
 539         const struct mlxfw_mfa2_tlv *cptr_tlv;
 540         u16 comp_idx;
 541
 542         dev_multi = mlxfw_mfa2_tlv_dev_get(mfa2_file, psid, psid_size);
 543         if (!dev_multi)
 544                 return NULL;
 545
 546         cptr_tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, dev_multi,
 547                                                    MLXFW_MFA2_TLV_COMPONENT_PTR,
 548                                                    component_index);
 549         if (!cptr_tlv)
 550                 return NULL;
 551
 552         cptr = mlxfw_mfa2_tlv_component_ptr_get(mfa2_file, cptr_tlv);
 553         if (!cptr)
 554                 return NULL;
 555
 556         comp_idx = be16_to_cpu(cptr->component_index);
 557         return mlxfw_mfa2_file_component_tlv_get(mfa2_file, comp_idx);
 558 }
 559
 560 struct mlxfw_mfa2_component *
 561 mlxfw_mfa2_file_component_get(const struct mlxfw_mfa2_file *mfa2_file,
 562                               const char *psid, int psid_size,
 563                               int component_index)
 564 {
 565         const struct mlxfw_mfa2_tlv_component_descriptor *comp;
 566         struct mlxfw_mfa2_comp_data *comp_data;
 567         u32 comp_buf_size;
 568         off_t cb_offset;
 569         u32 comp_size;
 570         int err;
 571
 572         comp = mlxfw_mfa2_file_component_find(mfa2_file, psid, psid_size,
 573                                               component_index);
 574         if (!comp)
 575                 return ERR_PTR(-EINVAL);
 576
 577         cb_offset = (u64) be32_to_cpu(comp->cb_offset_h) << 32 |
 578                     be32_to_cpu(comp->cb_offset_l);
 579         comp_size = be32_to_cpu(comp->size);
 580         comp_buf_size = comp_size + mlxfw_mfa2_comp_magic_len;
 581
 582         comp_data = kmalloc(sizeof(*comp_data) + comp_buf_size, GFP_KERNEL);
 583         if (!comp_data)
 584                 return ERR_PTR(-ENOMEM);
 585         comp_data->comp.data_size = comp_size;
 586         comp_data->comp.index = be16_to_cpu(comp->identifier);
 587         err = mlxfw_mfa2_file_cb_offset_xz(mfa2_file, cb_offset, comp_buf_size,
 588                                            comp_data->buff);
 589         if (err) {
 590                 pr_err("Component could not be reached in CB\n");
 591                 goto err_out;
 592         }
 593
 594         if (memcmp(comp_data->buff, mlxfw_mfa2_comp_magic,
 595                    mlxfw_mfa2_comp_magic_len) != 0) {
 596                 pr_err("Component has wrong magic\n");
 597                 err = -EINVAL;
 598                 goto err_out;
 599         }
 600
 601         comp_data->comp.data = comp_data->buff + mlxfw_mfa2_comp_magic_len;
 602         return &comp_data->comp;
 603 err_out:
 604         kfree(comp_data);
 605         return ERR_PTR(err);
 606 }
 607
 608 void mlxfw_mfa2_file_component_put(struct mlxfw_mfa2_component *comp)
 609 {
 610         const struct mlxfw_mfa2_comp_data *comp_data;
 611
 612         comp_data = container_of(comp, struct mlxfw_mfa2_comp_data, comp);
 613         kfree(comp_data);
 614 }
 615
 616 void mlxfw_mfa2_file_fini(struct mlxfw_mfa2_file *mfa2_file)
 617 {
 618         kfree(mfa2_file);
 619 }