drivers/crypto/marvell/octeontx/otx_cptpf_ucode.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Marvell OcteonTX CPT driver
   3  *
   4  * Copyright (C) 2019 Marvell International Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/ctype.h>
  12 #include <linux/firmware.h>
  13 #include "otx_cpt_common.h"
  14 #include "otx_cptpf_ucode.h"
  15 #include "otx_cptpf.h"
  16
  17 #define CSR_DELAY 30
  18 /* Tar archive defines */
  19 #define TAR_MAGIC               "ustar"
  20 #define TAR_MAGIC_LEN           6
  21 #define TAR_BLOCK_LEN           512
  22 #define REGTYPE                 '0'
  23 #define AREGTYPE                '\0'
  24
  25 /* tar header as defined in POSIX 1003.1-1990. */
  26 struct tar_hdr_t {
  27         char name[100];
  28         char mode[8];
  29         char uid[8];
  30         char gid[8];
  31         char size[12];
  32         char mtime[12];
  33         char chksum[8];
  34         char typeflag;
  35         char linkname[100];
  36         char magic[6];
  37         char version[2];
  38         char uname[32];
  39         char gname[32];
  40         char devmajor[8];
  41         char devminor[8];
  42         char prefix[155];
  43 };
  44
  45 struct tar_blk_t {
  46         union {
  47                 struct tar_hdr_t hdr;
  48                 char block[TAR_BLOCK_LEN];
  49         };
  50 };
  51
  52 struct tar_arch_info_t {
  53         struct list_head ucodes;
  54         const struct firmware *fw;
  55 };
  56
  57 static struct otx_cpt_bitmap get_cores_bmap(struct device *dev,
  58                                            struct otx_cpt_eng_grp_info *eng_grp)
  59 {
  60         struct otx_cpt_bitmap bmap = { {0} };
  61         bool found = false;
  62         int i;
  63
  64         if (eng_grp->g->engs_num > OTX_CPT_MAX_ENGINES) {
  65                 dev_err(dev, "unsupported number of engines %d on octeontx\n",
  66                         eng_grp->g->engs_num);
  67                 return bmap;
  68         }
  69
  70         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
  71                 if (eng_grp->engs[i].type) {
  72                         bitmap_or(bmap.bits, bmap.bits,
  73                                   eng_grp->engs[i].bmap,
  74                                   eng_grp->g->engs_num);
  75                         bmap.size = eng_grp->g->engs_num;
  76                         found = true;
  77                 }
  78         }
  79
  80         if (!found)
  81                 dev_err(dev, "No engines reserved for engine group %d\n",
  82                         eng_grp->idx);
  83         return bmap;
  84 }
  85
  86 static int is_eng_type(int val, int eng_type)
  87 {
  88         return val & (1 << eng_type);
  89 }
  90
  91 static int dev_supports_eng_type(struct otx_cpt_eng_grps *eng_grps,
  92                                  int eng_type)
  93 {
  94         return is_eng_type(eng_grps->eng_types_supported, eng_type);
  95 }
  96
  97 static void set_ucode_filename(struct otx_cpt_ucode *ucode,
  98                                const char *filename)
  99 {
 100         strscpy(ucode->filename, filename, OTX_CPT_UCODE_NAME_LENGTH);
 101 }
 102
 103 static char *get_eng_type_str(int eng_type)
 104 {
 105         char *str = "unknown";
 106
 107         switch (eng_type) {
 108         case OTX_CPT_SE_TYPES:
 109                 str = "SE";
 110                 break;
 111
 112         case OTX_CPT_AE_TYPES:
 113                 str = "AE";
 114                 break;
 115         }
 116         return str;
 117 }
 118
 119 static char *get_ucode_type_str(int ucode_type)
 120 {
 121         char *str = "unknown";
 122
 123         switch (ucode_type) {
 124         case (1 << OTX_CPT_SE_TYPES):
 125                 str = "SE";
 126                 break;
 127
 128         case (1 << OTX_CPT_AE_TYPES):
 129                 str = "AE";
 130                 break;
 131         }
 132         return str;
 133 }
 134
 135 static int get_ucode_type(struct otx_cpt_ucode_hdr *ucode_hdr, int *ucode_type)
 136 {
 137         char tmp_ver_str[OTX_CPT_UCODE_VER_STR_SZ];
 138         u32 i, val = 0;
 139         u8 nn;
 140
 141         strscpy(tmp_ver_str, ucode_hdr->ver_str, OTX_CPT_UCODE_VER_STR_SZ);
 142         for (i = 0; i < strlen(tmp_ver_str); i++)
 143                 tmp_ver_str[i] = tolower(tmp_ver_str[i]);
 144
 145         nn = ucode_hdr->ver_num.nn;
 146         if (strnstr(tmp_ver_str, "se-", OTX_CPT_UCODE_VER_STR_SZ) &&
 147             (nn == OTX_CPT_SE_UC_TYPE1 || nn == OTX_CPT_SE_UC_TYPE2 ||
 148              nn == OTX_CPT_SE_UC_TYPE3))
 149                 val |= 1 << OTX_CPT_SE_TYPES;
 150         if (strnstr(tmp_ver_str, "ae", OTX_CPT_UCODE_VER_STR_SZ) &&
 151             nn == OTX_CPT_AE_UC_TYPE)
 152                 val |= 1 << OTX_CPT_AE_TYPES;
 153
 154         *ucode_type = val;
 155
 156         if (!val)
 157                 return -EINVAL;
 158         if (is_eng_type(val, OTX_CPT_AE_TYPES) &&
 159             is_eng_type(val, OTX_CPT_SE_TYPES))
 160                 return -EINVAL;
 161         return 0;
 162 }
 163
 164 static int is_mem_zero(const char *ptr, int size)
 165 {
 166         int i;
 167
 168         for (i = 0; i < size; i++) {
 169                 if (ptr[i])
 170                         return 0;
 171         }
 172         return 1;
 173 }
 174
 175 static int cpt_set_ucode_base(struct otx_cpt_eng_grp_info *eng_grp, void *obj)
 176 {
 177         struct otx_cpt_device *cpt = (struct otx_cpt_device *) obj;
 178         dma_addr_t dma_addr;
 179         struct otx_cpt_bitmap bmap;
 180         int i;
 181
 182         bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
 183         if (!bmap.size)
 184                 return -EINVAL;
 185
 186         if (eng_grp->mirror.is_ena)
 187                 dma_addr =
 188                        eng_grp->g->grp[eng_grp->mirror.idx].ucode[0].align_dma;
 189         else
 190                 dma_addr = eng_grp->ucode[0].align_dma;
 191
 192         /*
 193          * Set UCODE_BASE only for the cores which are not used,
 194          * other cores should have already valid UCODE_BASE set
 195          */
 196         for_each_set_bit(i, bmap.bits, bmap.size)
 197                 if (!eng_grp->g->eng_ref_cnt[i])
 198                         writeq((u64) dma_addr, cpt->reg_base +
 199                                 OTX_CPT_PF_ENGX_UCODE_BASE(i));
 200         return 0;
 201 }
 202
 203 static int cpt_detach_and_disable_cores(struct otx_cpt_eng_grp_info *eng_grp,
 204                                         void *obj)
 205 {
 206         struct otx_cpt_device *cpt = (struct otx_cpt_device *) obj;
 207         struct otx_cpt_bitmap bmap = { {0} };
 208         int timeout = 10;
 209         int i, busy;
 210         u64 reg;
 211
 212         bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
 213         if (!bmap.size)
 214                 return -EINVAL;
 215
 216         /* Detach the cores from group */
 217         reg = readq(cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
 218         for_each_set_bit(i, bmap.bits, bmap.size) {
 219                 if (reg & (1ull << i)) {
 220                         eng_grp->g->eng_ref_cnt[i]--;
 221                         reg &= ~(1ull << i);
 222                 }
 223         }
 224         writeq(reg, cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
 225
 226         /* Wait for cores to become idle */
 227         do {
 228                 busy = 0;
 229                 usleep_range(10000, 20000);
 230                 if (timeout-- < 0)
 231                         return -EBUSY;
 232
 233                 reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
 234                 for_each_set_bit(i, bmap.bits, bmap.size)
 235                         if (reg & (1ull << i)) {
 236                                 busy = 1;
 237                                 break;
 238                         }
 239         } while (busy);
 240
 241         /* Disable the cores only if they are not used anymore */
 242         reg = readq(cpt->reg_base + OTX_CPT_PF_EXE_CTL);
 243         for_each_set_bit(i, bmap.bits, bmap.size)
 244                 if (!eng_grp->g->eng_ref_cnt[i])
 245                         reg &= ~(1ull << i);
 246         writeq(reg, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
 247
 248         return 0;
 249 }
 250
 251 static int cpt_attach_and_enable_cores(struct otx_cpt_eng_grp_info *eng_grp,
 252                                        void *obj)
 253 {
 254         struct otx_cpt_device *cpt = (struct otx_cpt_device *) obj;
 255         struct otx_cpt_bitmap bmap;
 256         u64 reg;
 257         int i;
 258
 259         bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
 260         if (!bmap.size)
 261                 return -EINVAL;
 262
 263         /* Attach the cores to the group */
 264         reg = readq(cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
 265         for_each_set_bit(i, bmap.bits, bmap.size) {
 266                 if (!(reg & (1ull << i))) {
 267                         eng_grp->g->eng_ref_cnt[i]++;
 268                         reg |= 1ull << i;
 269                 }
 270         }
 271         writeq(reg, cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
 272
 273         /* Enable the cores */
 274         reg = readq(cpt->reg_base + OTX_CPT_PF_EXE_CTL);
 275         for_each_set_bit(i, bmap.bits, bmap.size)
 276                 reg |= 1ull << i;
 277         writeq(reg, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
 278
 279         return 0;
 280 }
 281
 282 static int process_tar_file(struct device *dev,
 283                             struct tar_arch_info_t *tar_arch, char *filename,
 284                             const u8 *data, u32 size)
 285 {
 286         struct tar_ucode_info_t *tar_info;
 287         struct otx_cpt_ucode_hdr *ucode_hdr;
 288         int ucode_type, ucode_size;
 289         unsigned int code_length;
 290
 291         /*
 292          * If size is less than microcode header size then don't report
 293          * an error because it might not be microcode file, just process
 294          * next file from archive
 295          */
 296         if (size < sizeof(struct otx_cpt_ucode_hdr))
 297                 return 0;
 298
 299         ucode_hdr = (struct otx_cpt_ucode_hdr *) data;
 300         /*
 301          * If microcode version can't be found don't report an error
 302          * because it might not be microcode file, just process next file
 303          */
 304         if (get_ucode_type(ucode_hdr, &ucode_type))
 305                 return 0;
 306
 307         code_length = ntohl(ucode_hdr->code_length);
 308         if (code_length >= INT_MAX / 2) {
 309                 dev_err(dev, "Invalid code_length %u\n", code_length);
 310                 return -EINVAL;
 311         }
 312
 313         ucode_size = code_length * 2;
 314         if (!ucode_size || (size < round_up(ucode_size, 16) +
 315             sizeof(struct otx_cpt_ucode_hdr) + OTX_CPT_UCODE_SIGN_LEN)) {
 316                 dev_err(dev, "Ucode %s invalid size\n", filename);
 317                 return -EINVAL;
 318         }
 319
 320         tar_info = kzalloc(sizeof(struct tar_ucode_info_t), GFP_KERNEL);
 321         if (!tar_info)
 322                 return -ENOMEM;
 323
 324         tar_info->ucode_ptr = data;
 325         set_ucode_filename(&tar_info->ucode, filename);
 326         memcpy(tar_info->ucode.ver_str, ucode_hdr->ver_str,
 327                OTX_CPT_UCODE_VER_STR_SZ);
 328         tar_info->ucode.ver_num = ucode_hdr->ver_num;
 329         tar_info->ucode.type = ucode_type;
 330         tar_info->ucode.size = ucode_size;
 331         list_add_tail(&tar_info->list, &tar_arch->ucodes);
 332
 333         return 0;
 334 }
 335
 336 static void release_tar_archive(struct tar_arch_info_t *tar_arch)
 337 {
 338         struct tar_ucode_info_t *curr, *temp;
 339
 340         if (!tar_arch)
 341                 return;
 342
 343         list_for_each_entry_safe(curr, temp, &tar_arch->ucodes, list) {
 344                 list_del(&curr->list);
 345                 kfree(curr);
 346         }
 347
 348         release_firmware(tar_arch->fw);
 349         kfree(tar_arch);
 350 }
 351
 352 static struct tar_ucode_info_t *get_uc_from_tar_archive(
 353                                         struct tar_arch_info_t *tar_arch,
 354                                         int ucode_type)
 355 {
 356         struct tar_ucode_info_t *curr, *uc_found = NULL;
 357
 358         list_for_each_entry(curr, &tar_arch->ucodes, list) {
 359                 if (!is_eng_type(curr->ucode.type, ucode_type))
 360                         continue;
 361
 362                 if (!uc_found) {
 363                         uc_found = curr;
 364                         continue;
 365                 }
 366
 367                 switch (ucode_type) {
 368                 case OTX_CPT_AE_TYPES:
 369                         break;
 370
 371                 case OTX_CPT_SE_TYPES:
 372                         if (uc_found->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE2 ||
 373                             (uc_found->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE3
 374                              && curr->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE1))
 375                                 uc_found = curr;
 376                         break;
 377                 }
 378         }
 379
 380         return uc_found;
 381 }
 382
 383 static void print_tar_dbg_info(struct tar_arch_info_t *tar_arch,
 384                                char *tar_filename)
 385 {
 386         struct tar_ucode_info_t *curr;
 387
 388         pr_debug("Tar archive filename %s\n", tar_filename);
 389         pr_debug("Tar archive pointer %p, size %ld\n", tar_arch->fw->data,
 390                  tar_arch->fw->size);
 391         list_for_each_entry(curr, &tar_arch->ucodes, list) {
 392                 pr_debug("Ucode filename %s\n", curr->ucode.filename);
 393                 pr_debug("Ucode version string %s\n", curr->ucode.ver_str);
 394                 pr_debug("Ucode version %d.%d.%d.%d\n",
 395                          curr->ucode.ver_num.nn, curr->ucode.ver_num.xx,
 396                          curr->ucode.ver_num.yy, curr->ucode.ver_num.zz);
 397                 pr_debug("Ucode type (%d) %s\n", curr->ucode.type,
 398                          get_ucode_type_str(curr->ucode.type));
 399                 pr_debug("Ucode size %d\n", curr->ucode.size);
 400                 pr_debug("Ucode ptr %p\n", curr->ucode_ptr);
 401         }
 402 }
 403
 404 static struct tar_arch_info_t *load_tar_archive(struct device *dev,
 405                                                 char *tar_filename)
 406 {
 407         struct tar_arch_info_t *tar_arch = NULL;
 408         struct tar_blk_t *tar_blk;
 409         unsigned int cur_size;
 410         size_t tar_offs = 0;
 411         size_t tar_size;
 412         int ret;
 413
 414         tar_arch = kzalloc(sizeof(struct tar_arch_info_t), GFP_KERNEL);
 415         if (!tar_arch)
 416                 return NULL;
 417
 418         INIT_LIST_HEAD(&tar_arch->ucodes);
 419
 420         /* Load tar archive */
 421         ret = reject_firmware(&tar_arch->fw, tar_filename, dev);
 422         if (ret)
 423                 goto release_tar_arch;
 424
 425         if (tar_arch->fw->size < TAR_BLOCK_LEN) {
 426                 dev_err(dev, "Invalid tar archive %s\n", tar_filename);
 427                 goto release_tar_arch;
 428         }
 429
 430         tar_size = tar_arch->fw->size;
 431         tar_blk = (struct tar_blk_t *) tar_arch->fw->data;
 432         if (strncmp(tar_blk->hdr.magic, TAR_MAGIC, TAR_MAGIC_LEN - 1)) {
 433                 dev_err(dev, "Unsupported format of tar archive %s\n",
 434                         tar_filename);
 435                 goto release_tar_arch;
 436         }
 437
 438         while (1) {
 439                 /* Read current file size */
 440                 ret = kstrtouint(tar_blk->hdr.size, 8, &cur_size);
 441                 if (ret)
 442                         goto release_tar_arch;
 443
 444                 if (tar_offs + cur_size > tar_size ||
 445                     tar_offs + 2*TAR_BLOCK_LEN > tar_size) {
 446                         dev_err(dev, "Invalid tar archive %s\n", tar_filename);
 447                         goto release_tar_arch;
 448                 }
 449
 450                 tar_offs += TAR_BLOCK_LEN;
 451                 if (tar_blk->hdr.typeflag == REGTYPE ||
 452                     tar_blk->hdr.typeflag == AREGTYPE) {
 453                         ret = process_tar_file(dev, tar_arch,
 454                                                tar_blk->hdr.name,
 455                                                &tar_arch->fw->data[tar_offs],
 456                                                cur_size);
 457                         if (ret)
 458                                 goto release_tar_arch;
 459                 }
 460
 461                 tar_offs += (cur_size/TAR_BLOCK_LEN) * TAR_BLOCK_LEN;
 462                 if (cur_size % TAR_BLOCK_LEN)
 463                         tar_offs += TAR_BLOCK_LEN;
 464
 465                 /* Check for the end of the archive */
 466                 if (tar_offs + 2*TAR_BLOCK_LEN > tar_size) {
 467                         dev_err(dev, "Invalid tar archive %s\n", tar_filename);
 468                         goto release_tar_arch;
 469                 }
 470
 471                 if (is_mem_zero(&tar_arch->fw->data[tar_offs],
 472                     2*TAR_BLOCK_LEN))
 473                         break;
 474
 475                 /* Read next block from tar archive */
 476                 tar_blk = (struct tar_blk_t *) &tar_arch->fw->data[tar_offs];
 477         }
 478
 479         print_tar_dbg_info(tar_arch, tar_filename);
 480         return tar_arch;
 481 release_tar_arch:
 482         release_tar_archive(tar_arch);
 483         return NULL;
 484 }
 485
 486 static struct otx_cpt_engs_rsvd *find_engines_by_type(
 487                                         struct otx_cpt_eng_grp_info *eng_grp,
 488                                         int eng_type)
 489 {
 490         int i;
 491
 492         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
 493                 if (!eng_grp->engs[i].type)
 494                         continue;
 495
 496                 if (eng_grp->engs[i].type == eng_type)
 497                         return &eng_grp->engs[i];
 498         }
 499         return NULL;
 500 }
 501
 502 int otx_cpt_uc_supports_eng_type(struct otx_cpt_ucode *ucode, int eng_type)
 503 {
 504         return is_eng_type(ucode->type, eng_type);
 505 }
 506 EXPORT_SYMBOL_GPL(otx_cpt_uc_supports_eng_type);
 507
 508 int otx_cpt_eng_grp_has_eng_type(struct otx_cpt_eng_grp_info *eng_grp,
 509                                  int eng_type)
 510 {
 511         struct otx_cpt_engs_rsvd *engs;
 512
 513         engs = find_engines_by_type(eng_grp, eng_type);
 514
 515         return (engs != NULL ? 1 : 0);
 516 }
 517 EXPORT_SYMBOL_GPL(otx_cpt_eng_grp_has_eng_type);
 518
 519 static void print_ucode_info(struct otx_cpt_eng_grp_info *eng_grp,
 520                              char *buf, int size)
 521 {
 522         if (eng_grp->mirror.is_ena) {
 523                 scnprintf(buf, size, "%s (shared with engine_group%d)",
 524                           eng_grp->g->grp[eng_grp->mirror.idx].ucode[0].ver_str,
 525                           eng_grp->mirror.idx);
 526         } else {
 527                 scnprintf(buf, size, "%s", eng_grp->ucode[0].ver_str);
 528         }
 529 }
 530
 531 static void print_engs_info(struct otx_cpt_eng_grp_info *eng_grp,
 532                             char *buf, int size, int idx)
 533 {
 534         struct otx_cpt_engs_rsvd *mirrored_engs = NULL;
 535         struct otx_cpt_engs_rsvd *engs;
 536         int len, i;
 537
 538         buf[0] = '\0';
 539         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
 540                 engs = &eng_grp->engs[i];
 541                 if (!engs->type)
 542                         continue;
 543                 if (idx != -1 && idx != i)
 544                         continue;
 545
 546                 if (eng_grp->mirror.is_ena)
 547                         mirrored_engs = find_engines_by_type(
 548                                         &eng_grp->g->grp[eng_grp->mirror.idx],
 549                                         engs->type);
 550                 if (i > 0 && idx == -1) {
 551                         len = strlen(buf);
 552                         scnprintf(buf+len, size-len, ", ");
 553                 }
 554
 555                 len = strlen(buf);
 556                 scnprintf(buf+len, size-len, "%d %s ", mirrored_engs ?
 557                           engs->count + mirrored_engs->count : engs->count,
 558                           get_eng_type_str(engs->type));
 559                 if (mirrored_engs) {
 560                         len = strlen(buf);
 561                         scnprintf(buf+len, size-len,
 562                                   "(%d shared with engine_group%d) ",
 563                                   engs->count <= 0 ? engs->count +
 564                                   mirrored_engs->count : mirrored_engs->count,
 565                                   eng_grp->mirror.idx);
 566                 }
 567         }
 568 }
 569
 570 static void print_ucode_dbg_info(struct otx_cpt_ucode *ucode)
 571 {
 572         pr_debug("Ucode info\n");
 573         pr_debug("Ucode version string %s\n", ucode->ver_str);
 574         pr_debug("Ucode version %d.%d.%d.%d\n", ucode->ver_num.nn,
 575                  ucode->ver_num.xx, ucode->ver_num.yy, ucode->ver_num.zz);
 576         pr_debug("Ucode type %s\n", get_ucode_type_str(ucode->type));
 577         pr_debug("Ucode size %d\n", ucode->size);
 578         pr_debug("Ucode virt address %16.16llx\n", (u64)ucode->align_va);
 579         pr_debug("Ucode phys address %16.16llx\n", ucode->align_dma);
 580 }
 581
 582 static void cpt_print_engines_mask(struct otx_cpt_eng_grp_info *eng_grp,
 583                                    struct device *dev, char *buf, int size)
 584 {
 585         struct otx_cpt_bitmap bmap;
 586         u32 mask[2];
 587
 588         bmap = get_cores_bmap(dev, eng_grp);
 589         if (!bmap.size) {
 590                 scnprintf(buf, size, "unknown");
 591                 return;
 592         }
 593         bitmap_to_arr32(mask, bmap.bits, bmap.size);
 594         scnprintf(buf, size, "%8.8x %8.8x", mask[1], mask[0]);
 595 }
 596
 597
 598 static void print_dbg_info(struct device *dev,
 599                            struct otx_cpt_eng_grps *eng_grps)
 600 {
 601         char engs_info[2*OTX_CPT_UCODE_NAME_LENGTH];
 602         struct otx_cpt_eng_grp_info *mirrored_grp;
 603         char engs_mask[OTX_CPT_UCODE_NAME_LENGTH];
 604         struct otx_cpt_eng_grp_info *grp;
 605         struct otx_cpt_engs_rsvd *engs;
 606         u32 mask[4];
 607         int i, j;
 608
 609         pr_debug("Engine groups global info\n");
 610         pr_debug("max SE %d, max AE %d\n",
 611                  eng_grps->avail.max_se_cnt, eng_grps->avail.max_ae_cnt);
 612         pr_debug("free SE %d\n", eng_grps->avail.se_cnt);
 613         pr_debug("free AE %d\n", eng_grps->avail.ae_cnt);
 614
 615         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
 616                 grp = &eng_grps->grp[i];
 617                 pr_debug("engine_group%d, state %s\n", i, grp->is_enabled ?
 618                          "enabled" : "disabled");
 619                 if (grp->is_enabled) {
 620                         mirrored_grp = &eng_grps->grp[grp->mirror.idx];
 621                         pr_debug("Ucode0 filename %s, version %s\n",
 622                                  grp->mirror.is_ena ?
 623                                  mirrored_grp->ucode[0].filename :
 624                                  grp->ucode[0].filename,
 625                                  grp->mirror.is_ena ?
 626                                  mirrored_grp->ucode[0].ver_str :
 627                                  grp->ucode[0].ver_str);
 628                 }
 629
 630                 for (j = 0; j < OTX_CPT_MAX_ETYPES_PER_GRP; j++) {
 631                         engs = &grp->engs[j];
 632                         if (engs->type) {
 633                                 print_engs_info(grp, engs_info,
 634                                                 2*OTX_CPT_UCODE_NAME_LENGTH, j);
 635                                 pr_debug("Slot%d: %s\n", j, engs_info);
 636                                 bitmap_to_arr32(mask, engs->bmap,
 637                                                 eng_grps->engs_num);
 638                                 pr_debug("Mask: %8.8x %8.8x %8.8x %8.8x\n",
 639                                          mask[3], mask[2], mask[1], mask[0]);
 640                         } else
 641                                 pr_debug("Slot%d not used\n", j);
 642                 }
 643                 if (grp->is_enabled) {
 644                         cpt_print_engines_mask(grp, dev, engs_mask,
 645                                                OTX_CPT_UCODE_NAME_LENGTH);
 646                         pr_debug("Cmask: %s\n", engs_mask);
 647                 }
 648         }
 649 }
 650
 651 static int update_engines_avail_count(struct device *dev,
 652                                       struct otx_cpt_engs_available *avail,
 653                                       struct otx_cpt_engs_rsvd *engs, int val)
 654 {
 655         switch (engs->type) {
 656         case OTX_CPT_SE_TYPES:
 657                 avail->se_cnt += val;
 658                 break;
 659
 660         case OTX_CPT_AE_TYPES:
 661                 avail->ae_cnt += val;
 662                 break;
 663
 664         default:
 665                 dev_err(dev, "Invalid engine type %d\n", engs->type);
 666                 return -EINVAL;
 667         }
 668
 669         return 0;
 670 }
 671
 672 static int update_engines_offset(struct device *dev,
 673                                  struct otx_cpt_engs_available *avail,
 674                                  struct otx_cpt_engs_rsvd *engs)
 675 {
 676         switch (engs->type) {
 677         case OTX_CPT_SE_TYPES:
 678                 engs->offset = 0;
 679                 break;
 680
 681         case OTX_CPT_AE_TYPES:
 682                 engs->offset = avail->max_se_cnt;
 683                 break;
 684
 685         default:
 686                 dev_err(dev, "Invalid engine type %d\n", engs->type);
 687                 return -EINVAL;
 688         }
 689
 690         return 0;
 691 }
 692
 693 static int release_engines(struct device *dev, struct otx_cpt_eng_grp_info *grp)
 694 {
 695         int i, ret = 0;
 696
 697         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
 698                 if (!grp->engs[i].type)
 699                         continue;
 700
 701                 if (grp->engs[i].count > 0) {
 702                         ret = update_engines_avail_count(dev, &grp->g->avail,
 703                                                          &grp->engs[i],
 704                                                          grp->engs[i].count);
 705                         if (ret)
 706                                 return ret;
 707                 }
 708
 709                 grp->engs[i].type = 0;
 710                 grp->engs[i].count = 0;
 711                 grp->engs[i].offset = 0;
 712                 grp->engs[i].ucode = NULL;
 713                 bitmap_zero(grp->engs[i].bmap, grp->g->engs_num);
 714         }
 715
 716         return 0;
 717 }
 718
 719 static int do_reserve_engines(struct device *dev,
 720                               struct otx_cpt_eng_grp_info *grp,
 721                               struct otx_cpt_engines *req_engs)
 722 {
 723         struct otx_cpt_engs_rsvd *engs = NULL;
 724         int i, ret;
 725
 726         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
 727                 if (!grp->engs[i].type) {
 728                         engs = &grp->engs[i];
 729                         break;
 730                 }
 731         }
 732
 733         if (!engs)
 734                 return -ENOMEM;
 735
 736         engs->type = req_engs->type;
 737         engs->count = req_engs->count;
 738
 739         ret = update_engines_offset(dev, &grp->g->avail, engs);
 740         if (ret)
 741                 return ret;
 742
 743         if (engs->count > 0) {
 744                 ret = update_engines_avail_count(dev, &grp->g->avail, engs,
 745                                                  -engs->count);
 746                 if (ret)
 747                         return ret;
 748         }
 749
 750         return 0;
 751 }
 752
 753 static int check_engines_availability(struct device *dev,
 754                                       struct otx_cpt_eng_grp_info *grp,
 755                                       struct otx_cpt_engines *req_eng)
 756 {
 757         int avail_cnt = 0;
 758
 759         switch (req_eng->type) {
 760         case OTX_CPT_SE_TYPES:
 761                 avail_cnt = grp->g->avail.se_cnt;
 762                 break;
 763
 764         case OTX_CPT_AE_TYPES:
 765                 avail_cnt = grp->g->avail.ae_cnt;
 766                 break;
 767
 768         default:
 769                 dev_err(dev, "Invalid engine type %d\n", req_eng->type);
 770                 return -EINVAL;
 771         }
 772
 773         if (avail_cnt < req_eng->count) {
 774                 dev_err(dev,
 775                         "Error available %s engines %d < than requested %d\n",
 776                         get_eng_type_str(req_eng->type),
 777                         avail_cnt, req_eng->count);
 778                 return -EBUSY;
 779         }
 780
 781         return 0;
 782 }
 783
 784 static int reserve_engines(struct device *dev, struct otx_cpt_eng_grp_info *grp,
 785                            struct otx_cpt_engines *req_engs, int req_cnt)
 786 {
 787         int i, ret;
 788
 789         /* Validate if a number of requested engines is available */
 790         for (i = 0; i < req_cnt; i++) {
 791                 ret = check_engines_availability(dev, grp, &req_engs[i]);
 792                 if (ret)
 793                         return ret;
 794         }
 795
 796         /* Reserve requested engines for this engine group */
 797         for (i = 0; i < req_cnt; i++) {
 798                 ret = do_reserve_engines(dev, grp, &req_engs[i]);
 799                 if (ret)
 800                         return ret;
 801         }
 802         return 0;
 803 }
 804
 805 static ssize_t eng_grp_info_show(struct device *dev,
 806                                  struct device_attribute *attr,
 807                                  char *buf)
 808 {
 809         char ucode_info[2*OTX_CPT_UCODE_NAME_LENGTH];
 810         char engs_info[2*OTX_CPT_UCODE_NAME_LENGTH];
 811         char engs_mask[OTX_CPT_UCODE_NAME_LENGTH];
 812         struct otx_cpt_eng_grp_info *eng_grp;
 813         int ret;
 814
 815         eng_grp = container_of(attr, struct otx_cpt_eng_grp_info, info_attr);
 816         mutex_lock(&eng_grp->g->lock);
 817
 818         print_engs_info(eng_grp, engs_info, 2*OTX_CPT_UCODE_NAME_LENGTH, -1);
 819         print_ucode_info(eng_grp, ucode_info, 2*OTX_CPT_UCODE_NAME_LENGTH);
 820         cpt_print_engines_mask(eng_grp, dev, engs_mask,
 821                                OTX_CPT_UCODE_NAME_LENGTH);
 822         ret = scnprintf(buf, PAGE_SIZE,
 823                         "Microcode : %s\nEngines: %s\nEngines mask: %s\n",
 824                         ucode_info, engs_info, engs_mask);
 825
 826         mutex_unlock(&eng_grp->g->lock);
 827         return ret;
 828 }
 829
 830 static int create_sysfs_eng_grps_info(struct device *dev,
 831                                       struct otx_cpt_eng_grp_info *eng_grp)
 832 {
 833         eng_grp->info_attr.show = eng_grp_info_show;
 834         eng_grp->info_attr.store = NULL;
 835         eng_grp->info_attr.attr.name = eng_grp->sysfs_info_name;
 836         eng_grp->info_attr.attr.mode = 0440;
 837         sysfs_attr_init(&eng_grp->info_attr.attr);
 838         return device_create_file(dev, &eng_grp->info_attr);
 839 }
 840
 841 static void ucode_unload(struct device *dev, struct otx_cpt_ucode *ucode)
 842 {
 843         if (ucode->va) {
 844                 dma_free_coherent(dev, ucode->size + OTX_CPT_UCODE_ALIGNMENT,
 845                                   ucode->va, ucode->dma);
 846                 ucode->va = NULL;
 847                 ucode->align_va = NULL;
 848                 ucode->dma = 0;
 849                 ucode->align_dma = 0;
 850                 ucode->size = 0;
 851         }
 852
 853         memset(&ucode->ver_str, 0, OTX_CPT_UCODE_VER_STR_SZ);
 854         memset(&ucode->ver_num, 0, sizeof(struct otx_cpt_ucode_ver_num));
 855         set_ucode_filename(ucode, "");
 856         ucode->type = 0;
 857 }
 858
 859 static int copy_ucode_to_dma_mem(struct device *dev,
 860                                  struct otx_cpt_ucode *ucode,
 861                                  const u8 *ucode_data)
 862 {
 863         u32 i;
 864
 865         /*  Allocate DMAable space */
 866         ucode->va = dma_alloc_coherent(dev, ucode->size +
 867                                        OTX_CPT_UCODE_ALIGNMENT,
 868                                        &ucode->dma, GFP_KERNEL);
 869         if (!ucode->va) {
 870                 dev_err(dev, "Unable to allocate space for microcode\n");
 871                 return -ENOMEM;
 872         }
 873         ucode->align_va = PTR_ALIGN(ucode->va, OTX_CPT_UCODE_ALIGNMENT);
 874         ucode->align_dma = PTR_ALIGN(ucode->dma, OTX_CPT_UCODE_ALIGNMENT);
 875
 876         memcpy((void *) ucode->align_va, (void *) ucode_data +
 877                sizeof(struct otx_cpt_ucode_hdr), ucode->size);
 878
 879         /* Byte swap 64-bit */
 880         for (i = 0; i < (ucode->size / 8); i++)
 881                 ((__be64 *)ucode->align_va)[i] =
 882                                 cpu_to_be64(((u64 *)ucode->align_va)[i]);
 883         /*  Ucode needs 16-bit swap */
 884         for (i = 0; i < (ucode->size / 2); i++)
 885                 ((__be16 *)ucode->align_va)[i] =
 886                                 cpu_to_be16(((u16 *)ucode->align_va)[i]);
 887         return 0;
 888 }
 889
 890 static int ucode_load(struct device *dev, struct otx_cpt_ucode *ucode,
 891                       const char *ucode_filename)
 892 {
 893         struct otx_cpt_ucode_hdr *ucode_hdr;
 894         const struct firmware *fw;
 895         unsigned int code_length;
 896         int ret;
 897
 898         set_ucode_filename(ucode, ucode_filename);
 899         ret = reject_firmware(&fw, ucode->filename, dev);
 900         if (ret)
 901                 return ret;
 902
 903         ucode_hdr = (struct otx_cpt_ucode_hdr *) fw->data;
 904         memcpy(ucode->ver_str, ucode_hdr->ver_str, OTX_CPT_UCODE_VER_STR_SZ);
 905         ucode->ver_num = ucode_hdr->ver_num;
 906         code_length = ntohl(ucode_hdr->code_length);
 907         if (code_length >= INT_MAX / 2) {
 908                 dev_err(dev, "Ucode invalid code_length %u\n", code_length);
 909                 ret = -EINVAL;
 910                 goto release_fw;
 911         }
 912         ucode->size = code_length * 2;
 913         if (!ucode->size || (fw->size < round_up(ucode->size, 16)
 914             + sizeof(struct otx_cpt_ucode_hdr) + OTX_CPT_UCODE_SIGN_LEN)) {
 915                 dev_err(dev, "Ucode %s invalid size\n", ucode_filename);
 916                 ret = -EINVAL;
 917                 goto release_fw;
 918         }
 919
 920         ret = get_ucode_type(ucode_hdr, &ucode->type);
 921         if (ret) {
 922                 dev_err(dev, "Microcode %s unknown type 0x%x\n",
 923                         ucode->filename, ucode->type);
 924                 goto release_fw;
 925         }
 926
 927         ret = copy_ucode_to_dma_mem(dev, ucode, fw->data);
 928         if (ret)
 929                 goto release_fw;
 930
 931         print_ucode_dbg_info(ucode);
 932 release_fw:
 933         release_firmware(fw);
 934         return ret;
 935 }
 936
 937 static int enable_eng_grp(struct otx_cpt_eng_grp_info *eng_grp,
 938                           void *obj)
 939 {
 940         int ret;
 941
 942         ret = cpt_set_ucode_base(eng_grp, obj);
 943         if (ret)
 944                 return ret;
 945
 946         ret = cpt_attach_and_enable_cores(eng_grp, obj);
 947         return ret;
 948 }
 949
 950 static int disable_eng_grp(struct device *dev,
 951                            struct otx_cpt_eng_grp_info *eng_grp,
 952                            void *obj)
 953 {
 954         int i, ret;
 955
 956         ret = cpt_detach_and_disable_cores(eng_grp, obj);
 957         if (ret)
 958                 return ret;
 959
 960         /* Unload ucode used by this engine group */
 961         ucode_unload(dev, &eng_grp->ucode[0]);
 962
 963         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
 964                 if (!eng_grp->engs[i].type)
 965                         continue;
 966
 967                 eng_grp->engs[i].ucode = &eng_grp->ucode[0];
 968         }
 969
 970         ret = cpt_set_ucode_base(eng_grp, obj);
 971
 972         return ret;
 973 }
 974
 975 static void setup_eng_grp_mirroring(struct otx_cpt_eng_grp_info *dst_grp,
 976                                     struct otx_cpt_eng_grp_info *src_grp)
 977 {
 978         /* Setup fields for engine group which is mirrored */
 979         src_grp->mirror.is_ena = false;
 980         src_grp->mirror.idx = 0;
 981         src_grp->mirror.ref_count++;
 982
 983         /* Setup fields for mirroring engine group */
 984         dst_grp->mirror.is_ena = true;
 985         dst_grp->mirror.idx = src_grp->idx;
 986         dst_grp->mirror.ref_count = 0;
 987 }
 988
 989 static void remove_eng_grp_mirroring(struct otx_cpt_eng_grp_info *dst_grp)
 990 {
 991         struct otx_cpt_eng_grp_info *src_grp;
 992
 993         if (!dst_grp->mirror.is_ena)
 994                 return;
 995
 996         src_grp = &dst_grp->g->grp[dst_grp->mirror.idx];
 997
 998         src_grp->mirror.ref_count--;
 999         dst_grp->mirror.is_ena = false;
1000         dst_grp->mirror.idx = 0;
1001         dst_grp->mirror.ref_count = 0;
1002 }
1003
1004 static void update_requested_engs(struct otx_cpt_eng_grp_info *mirrored_eng_grp,
1005                                   struct otx_cpt_engines *engs, int engs_cnt)
1006 {
1007         struct otx_cpt_engs_rsvd *mirrored_engs;
1008         int i;
1009
1010         for (i = 0; i < engs_cnt; i++) {
1011                 mirrored_engs = find_engines_by_type(mirrored_eng_grp,
1012                                                      engs[i].type);
1013                 if (!mirrored_engs)
1014                         continue;
1015
1016                 /*
1017                  * If mirrored group has this type of engines attached then
1018                  * there are 3 scenarios possible:
1019                  * 1) mirrored_engs.count == engs[i].count then all engines
1020                  * from mirrored engine group will be shared with this engine
1021                  * group
1022                  * 2) mirrored_engs.count > engs[i].count then only a subset of
1023                  * engines from mirrored engine group will be shared with this
1024                  * engine group
1025                  * 3) mirrored_engs.count < engs[i].count then all engines
1026                  * from mirrored engine group will be shared with this group
1027                  * and additional engines will be reserved for exclusively use
1028                  * by this engine group
1029                  */
1030                 engs[i].count -= mirrored_engs->count;
1031         }
1032 }
1033
1034 static struct otx_cpt_eng_grp_info *find_mirrored_eng_grp(
1035                                         struct otx_cpt_eng_grp_info *grp)
1036 {
1037         struct otx_cpt_eng_grps *eng_grps = grp->g;
1038         int i;
1039
1040         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
1041                 if (!eng_grps->grp[i].is_enabled)
1042                         continue;
1043                 if (eng_grps->grp[i].ucode[0].type)
1044                         continue;
1045                 if (grp->idx == i)
1046                         continue;
1047                 if (!strncasecmp(eng_grps->grp[i].ucode[0].ver_str,
1048                                  grp->ucode[0].ver_str,
1049                                  OTX_CPT_UCODE_VER_STR_SZ))
1050                         return &eng_grps->grp[i];
1051         }
1052
1053         return NULL;
1054 }
1055
1056 static struct otx_cpt_eng_grp_info *find_unused_eng_grp(
1057                                         struct otx_cpt_eng_grps *eng_grps)
1058 {
1059         int i;
1060
1061         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
1062                 if (!eng_grps->grp[i].is_enabled)
1063                         return &eng_grps->grp[i];
1064         }
1065         return NULL;
1066 }
1067
1068 static int eng_grp_update_masks(struct device *dev,
1069                                 struct otx_cpt_eng_grp_info *eng_grp)
1070 {
1071         struct otx_cpt_engs_rsvd *engs, *mirrored_engs;
1072         struct otx_cpt_bitmap tmp_bmap = { {0} };
1073         int i, j, cnt, max_cnt;
1074         int bit;
1075
1076         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
1077                 engs = &eng_grp->engs[i];
1078                 if (!engs->type)
1079                         continue;
1080                 if (engs->count <= 0)
1081                         continue;
1082
1083                 switch (engs->type) {
1084                 case OTX_CPT_SE_TYPES:
1085                         max_cnt = eng_grp->g->avail.max_se_cnt;
1086                         break;
1087
1088                 case OTX_CPT_AE_TYPES:
1089                         max_cnt = eng_grp->g->avail.max_ae_cnt;
1090                         break;
1091
1092                 default:
1093                         dev_err(dev, "Invalid engine type %d\n", engs->type);
1094                         return -EINVAL;
1095                 }
1096
1097                 cnt = engs->count;
1098                 WARN_ON(engs->offset + max_cnt > OTX_CPT_MAX_ENGINES);
1099                 bitmap_zero(tmp_bmap.bits, eng_grp->g->engs_num);
1100                 for (j = engs->offset; j < engs->offset + max_cnt; j++) {
1101                         if (!eng_grp->g->eng_ref_cnt[j]) {
1102                                 bitmap_set(tmp_bmap.bits, j, 1);
1103                                 cnt--;
1104                                 if (!cnt)
1105                                         break;
1106                         }
1107                 }
1108
1109                 if (cnt)
1110                         return -ENOSPC;
1111
1112                 bitmap_copy(engs->bmap, tmp_bmap.bits, eng_grp->g->engs_num);
1113         }
1114
1115         if (!eng_grp->mirror.is_ena)
1116                 return 0;
1117
1118         for (i = 0; i < OTX_CPT_MAX_ETYPES_PER_GRP; i++) {
1119                 engs = &eng_grp->engs[i];
1120                 if (!engs->type)
1121                         continue;
1122
1123                 mirrored_engs = find_engines_by_type(
1124                                         &eng_grp->g->grp[eng_grp->mirror.idx],
1125                                         engs->type);
1126                 WARN_ON(!mirrored_engs && engs->count <= 0);
1127                 if (!mirrored_engs)
1128                         continue;
1129
1130                 bitmap_copy(tmp_bmap.bits, mirrored_engs->bmap,
1131                             eng_grp->g->engs_num);
1132                 if (engs->count < 0) {
1133                         bit = find_first_bit(mirrored_engs->bmap,
1134                                              eng_grp->g->engs_num);
1135                         bitmap_clear(tmp_bmap.bits, bit, -engs->count);
1136                 }
1137                 bitmap_or(engs->bmap, engs->bmap, tmp_bmap.bits,
1138                           eng_grp->g->engs_num);
1139         }
1140         return 0;
1141 }
1142
1143 static int delete_engine_group(struct device *dev,
1144                                struct otx_cpt_eng_grp_info *eng_grp)
1145 {
1146         int i, ret;
1147
1148         if (!eng_grp->is_enabled)
1149                 return -EINVAL;
1150
1151         if (eng_grp->mirror.ref_count) {
1152                 dev_err(dev, "Can't delete engine_group%d as it is used by engine_group(s):",
1153                         eng_grp->idx);
1154                 for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
1155                         if (eng_grp->g->grp[i].mirror.is_ena &&
1156                             eng_grp->g->grp[i].mirror.idx == eng_grp->idx)
1157                                 pr_cont(" %d", i);
1158                 }
1159                 pr_cont("\n");
1160                 return -EINVAL;
1161         }
1162
1163         /* Removing engine group mirroring if enabled */
1164         remove_eng_grp_mirroring(eng_grp);
1165
1166         /* Disable engine group */
1167         ret = disable_eng_grp(dev, eng_grp, eng_grp->g->obj);
1168         if (ret)
1169                 return ret;
1170
1171         /* Release all engines held by this engine group */
1172         ret = release_engines(dev, eng_grp);
1173         if (ret)
1174                 return ret;
1175
1176         device_remove_file(dev, &eng_grp->info_attr);
1177         eng_grp->is_enabled = false;
1178
1179         return 0;
1180 }
1181
1182 static int validate_1_ucode_scenario(struct device *dev,
1183                                      struct otx_cpt_eng_grp_info *eng_grp,
1184                                      struct otx_cpt_engines *engs, int engs_cnt)
1185 {
1186         int i;
1187
1188         /* Verify that ucode loaded supports requested engine types */
1189         for (i = 0; i < engs_cnt; i++) {
1190                 if (!otx_cpt_uc_supports_eng_type(&eng_grp->ucode[0],
1191                                                   engs[i].type)) {
1192                         dev_err(dev,
1193                                 "Microcode %s does not support %s engines\n",
1194                                 eng_grp->ucode[0].filename,
1195                                 get_eng_type_str(engs[i].type));
1196                         return -EINVAL;
1197                 }
1198         }
1199         return 0;
1200 }
1201
1202 static void update_ucode_ptrs(struct otx_cpt_eng_grp_info *eng_grp)
1203 {
1204         struct otx_cpt_ucode *ucode;
1205
1206         if (eng_grp->mirror.is_ena)
1207                 ucode = &eng_grp->g->grp[eng_grp->mirror.idx].ucode[0];
1208         else
1209                 ucode = &eng_grp->ucode[0];
1210         WARN_ON(!eng_grp->engs[0].type);
1211         eng_grp->engs[0].ucode = ucode;
1212 }
1213
1214 static int create_engine_group(struct device *dev,
1215                                struct otx_cpt_eng_grps *eng_grps,
1216                                struct otx_cpt_engines *engs, int engs_cnt,
1217                                void *ucode_data[], int ucodes_cnt,
1218                                bool use_uc_from_tar_arch)
1219 {
1220         struct otx_cpt_eng_grp_info *mirrored_eng_grp;
1221         struct tar_ucode_info_t *tar_info;
1222         struct otx_cpt_eng_grp_info *eng_grp;
1223         int i, ret = 0;
1224
1225         if (ucodes_cnt > OTX_CPT_MAX_ETYPES_PER_GRP)
1226                 return -EINVAL;
1227
1228         /* Validate if requested engine types are supported by this device */
1229         for (i = 0; i < engs_cnt; i++)
1230                 if (!dev_supports_eng_type(eng_grps, engs[i].type)) {
1231                         dev_err(dev, "Device does not support %s engines\n",
1232                                 get_eng_type_str(engs[i].type));
1233                         return -EPERM;
1234                 }
1235
1236         /* Find engine group which is not used */
1237         eng_grp = find_unused_eng_grp(eng_grps);
1238         if (!eng_grp) {
1239                 dev_err(dev, "Error all engine groups are being used\n");
1240                 return -ENOSPC;
1241         }
1242
1243         /* Load ucode */
1244         for (i = 0; i < ucodes_cnt; i++) {
1245                 if (use_uc_from_tar_arch) {
1246                         tar_info = (struct tar_ucode_info_t *) ucode_data[i];
1247                         eng_grp->ucode[i] = tar_info->ucode;
1248                         ret = copy_ucode_to_dma_mem(dev, &eng_grp->ucode[i],
1249                                                     tar_info->ucode_ptr);
1250                 } else
1251                         ret = ucode_load(dev, &eng_grp->ucode[i],
1252                                          (char *) ucode_data[i]);
1253                 if (ret)
1254                         goto err_ucode_unload;
1255         }
1256
1257         /* Validate scenario where 1 ucode is used */
1258         ret = validate_1_ucode_scenario(dev, eng_grp, engs, engs_cnt);
1259         if (ret)
1260                 goto err_ucode_unload;
1261
1262         /* Check if this group mirrors another existing engine group */
1263         mirrored_eng_grp = find_mirrored_eng_grp(eng_grp);
1264         if (mirrored_eng_grp) {
1265                 /* Setup mirroring */
1266                 setup_eng_grp_mirroring(eng_grp, mirrored_eng_grp);
1267
1268                 /*
1269                  * Update count of requested engines because some
1270                  * of them might be shared with mirrored group
1271                  */
1272                 update_requested_engs(mirrored_eng_grp, engs, engs_cnt);
1273         }
1274
1275         /* Reserve engines */
1276         ret = reserve_engines(dev, eng_grp, engs, engs_cnt);
1277         if (ret)
1278                 goto err_ucode_unload;
1279
1280         /* Update ucode pointers used by engines */
1281         update_ucode_ptrs(eng_grp);
1282
1283         /* Update engine masks used by this group */
1284         ret = eng_grp_update_masks(dev, eng_grp);
1285         if (ret)
1286                 goto err_release_engs;
1287
1288         /* Create sysfs entry for engine group info */
1289         ret = create_sysfs_eng_grps_info(dev, eng_grp);
1290         if (ret)
1291                 goto err_release_engs;
1292
1293         /* Enable engine group */
1294         ret = enable_eng_grp(eng_grp, eng_grps->obj);
1295         if (ret)
1296                 goto err_release_engs;
1297
1298         /*
1299          * If this engine group mirrors another engine group
1300          * then we need to unload ucode as we will use ucode
1301          * from mirrored engine group
1302          */
1303         if (eng_grp->mirror.is_ena)
1304                 ucode_unload(dev, &eng_grp->ucode[0]);
1305
1306         eng_grp->is_enabled = true;
1307         if (eng_grp->mirror.is_ena)
1308                 dev_info(dev,
1309                          "Engine_group%d: reuse microcode %s from group %d\n",
1310                          eng_grp->idx, mirrored_eng_grp->ucode[0].ver_str,
1311                          mirrored_eng_grp->idx);
1312         else
1313                 dev_info(dev, "Engine_group%d: microcode loaded %s\n",
1314                          eng_grp->idx, eng_grp->ucode[0].ver_str);
1315
1316         return 0;
1317
1318 err_release_engs:
1319         release_engines(dev, eng_grp);
1320 err_ucode_unload:
1321         ucode_unload(dev, &eng_grp->ucode[0]);
1322         return ret;
1323 }
1324
1325 static ssize_t ucode_load_store(struct device *dev,
1326                                 struct device_attribute *attr,
1327                                 const char *buf, size_t count)
1328 {
1329         struct otx_cpt_engines engs[OTX_CPT_MAX_ETYPES_PER_GRP] = { {0} };
1330         char *ucode_filename[OTX_CPT_MAX_ETYPES_PER_GRP];
1331         char tmp_buf[OTX_CPT_UCODE_NAME_LENGTH] = { 0 };
1332         char *start, *val, *err_msg, *tmp;
1333         struct otx_cpt_eng_grps *eng_grps;
1334         int grp_idx = 0, ret = -EINVAL;
1335         bool has_se, has_ie, has_ae;
1336         int del_grp_idx = -1;
1337         int ucode_idx = 0;
1338
1339         if (strlen(buf) > OTX_CPT_UCODE_NAME_LENGTH)
1340                 return -EINVAL;
1341
1342         eng_grps = container_of(attr, struct otx_cpt_eng_grps, ucode_load_attr);
1343         err_msg = "Invalid engine group format";
1344         strscpy(tmp_buf, buf, OTX_CPT_UCODE_NAME_LENGTH);
1345         start = tmp_buf;
1346
1347         has_se = has_ie = has_ae = false;
1348
1349         for (;;) {
1350                 val = strsep(&start, ";");
1351                 if (!val)
1352                         break;
1353                 val = strim(val);
1354                 if (!*val)
1355                         continue;
1356
1357                 if (!strncasecmp(val, "engine_group", 12)) {
1358                         if (del_grp_idx != -1)
1359                                 goto err_print;
1360                         tmp = strim(strsep(&val, ":"));
1361                         if (!val)
1362                                 goto err_print;
1363                         if (strlen(tmp) != 13)
1364                                 goto err_print;
1365                         if (kstrtoint((tmp + 12), 10, &del_grp_idx))
1366                                 goto err_print;
1367                         val = strim(val);
1368                         if (strncasecmp(val, "null", 4))
1369                                 goto err_print;
1370                         if (strlen(val) != 4)
1371                                 goto err_print;
1372                 } else if (!strncasecmp(val, "se", 2) && strchr(val, ':')) {
1373                         if (has_se || ucode_idx)
1374                                 goto err_print;
1375                         tmp = strim(strsep(&val, ":"));
1376                         if (!val)
1377                                 goto err_print;
1378                         if (strlen(tmp) != 2)
1379                                 goto err_print;
1380                         if (kstrtoint(strim(val), 10, &engs[grp_idx].count))
1381                                 goto err_print;
1382                         engs[grp_idx++].type = OTX_CPT_SE_TYPES;
1383                         has_se = true;
1384                 } else if (!strncasecmp(val, "ae", 2) && strchr(val, ':')) {
1385                         if (has_ae || ucode_idx)
1386                                 goto err_print;
1387                         tmp = strim(strsep(&val, ":"));
1388                         if (!val)
1389                                 goto err_print;
1390                         if (strlen(tmp) != 2)
1391                                 goto err_print;
1392                         if (kstrtoint(strim(val), 10, &engs[grp_idx].count))
1393                                 goto err_print;
1394                         engs[grp_idx++].type = OTX_CPT_AE_TYPES;
1395                         has_ae = true;
1396                 } else {
1397                         if (ucode_idx > 1)
1398                                 goto err_print;
1399                         if (!strlen(val))
1400                                 goto err_print;
1401                         if (strnstr(val, " ", strlen(val)))
1402                                 goto err_print;
1403                         ucode_filename[ucode_idx++] = val;
1404                 }
1405         }
1406
1407         /* Validate input parameters */
1408         if (del_grp_idx == -1) {
1409                 if (!(grp_idx && ucode_idx))
1410                         goto err_print;
1411
1412                 if (ucode_idx > 1 && grp_idx < 2)
1413                         goto err_print;
1414
1415                 if (grp_idx > OTX_CPT_MAX_ETYPES_PER_GRP) {
1416                         err_msg = "Error max 2 engine types can be attached";
1417                         goto err_print;
1418                 }
1419
1420         } else {
1421                 if (del_grp_idx < 0 ||
1422                     del_grp_idx >= OTX_CPT_MAX_ENGINE_GROUPS) {
1423                         dev_err(dev, "Invalid engine group index %d\n",
1424                                 del_grp_idx);
1425                         ret = -EINVAL;
1426                         return ret;
1427                 }
1428
1429                 if (!eng_grps->grp[del_grp_idx].is_enabled) {
1430                         dev_err(dev, "Error engine_group%d is not configured\n",
1431                                 del_grp_idx);
1432                         ret = -EINVAL;
1433                         return ret;
1434                 }
1435
1436                 if (grp_idx || ucode_idx)
1437                         goto err_print;
1438         }
1439
1440         mutex_lock(&eng_grps->lock);
1441
1442         if (eng_grps->is_rdonly) {
1443                 dev_err(dev, "Disable VFs before modifying engine groups\n");
1444                 ret = -EACCES;
1445                 goto err_unlock;
1446         }
1447
1448         if (del_grp_idx == -1)
1449                 /* create engine group */
1450                 ret = create_engine_group(dev, eng_grps, engs, grp_idx,
1451                                           (void **) ucode_filename,
1452                                           ucode_idx, false);
1453         else
1454                 /* delete engine group */
1455                 ret = delete_engine_group(dev, &eng_grps->grp[del_grp_idx]);
1456         if (ret)
1457                 goto err_unlock;
1458
1459         print_dbg_info(dev, eng_grps);
1460 err_unlock:
1461         mutex_unlock(&eng_grps->lock);
1462         return ret ? ret : count;
1463 err_print:
1464         dev_err(dev, "%s\n", err_msg);
1465
1466         return ret;
1467 }
1468
1469 int otx_cpt_try_create_default_eng_grps(struct pci_dev *pdev,
1470                                         struct otx_cpt_eng_grps *eng_grps,
1471                                         int pf_type)
1472 {
1473         struct tar_ucode_info_t *tar_info[OTX_CPT_MAX_ETYPES_PER_GRP] = {};
1474         struct otx_cpt_engines engs[OTX_CPT_MAX_ETYPES_PER_GRP] = {};
1475         struct tar_arch_info_t *tar_arch = NULL;
1476         char *tar_filename;
1477         int i, ret = 0;
1478
1479         mutex_lock(&eng_grps->lock);
1480
1481         /*
1482          * We don't create engine group for kernel crypto if attempt to create
1483          * it was already made (when user enabled VFs for the first time)
1484          */
1485         if (eng_grps->is_first_try)
1486                 goto unlock_mutex;
1487         eng_grps->is_first_try = true;
1488
1489         /* We create group for kcrypto only if no groups are configured */
1490         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++)
1491                 if (eng_grps->grp[i].is_enabled)
1492                         goto unlock_mutex;
1493
1494         switch (pf_type) {
1495         case OTX_CPT_AE:
1496         case OTX_CPT_SE:
1497                 tar_filename = OTX_CPT_UCODE_TAR_FILE_NAME;
1498                 break;
1499
1500         default:
1501                 dev_err(&pdev->dev, "Unknown PF type %d\n", pf_type);
1502                 ret = -EINVAL;
1503                 goto unlock_mutex;
1504         }
1505
1506         tar_arch = load_tar_archive(&pdev->dev, tar_filename);
1507         if (!tar_arch)
1508                 goto unlock_mutex;
1509
1510         /*
1511          * If device supports SE engines and there is SE microcode in tar
1512          * archive try to create engine group with SE engines for kernel
1513          * crypto functionality (symmetric crypto)
1514          */
1515         tar_info[0] = get_uc_from_tar_archive(tar_arch, OTX_CPT_SE_TYPES);
1516         if (tar_info[0] &&
1517             dev_supports_eng_type(eng_grps, OTX_CPT_SE_TYPES)) {
1518
1519                 engs[0].type = OTX_CPT_SE_TYPES;
1520                 engs[0].count = eng_grps->avail.max_se_cnt;
1521
1522                 ret = create_engine_group(&pdev->dev, eng_grps, engs, 1,
1523                                           (void **) tar_info, 1, true);
1524                 if (ret)
1525                         goto release_tar_arch;
1526         }
1527         /*
1528          * If device supports AE engines and there is AE microcode in tar
1529          * archive try to create engine group with AE engines for asymmetric
1530          * crypto functionality.
1531          */
1532         tar_info[0] = get_uc_from_tar_archive(tar_arch, OTX_CPT_AE_TYPES);
1533         if (tar_info[0] &&
1534             dev_supports_eng_type(eng_grps, OTX_CPT_AE_TYPES)) {
1535
1536                 engs[0].type = OTX_CPT_AE_TYPES;
1537                 engs[0].count = eng_grps->avail.max_ae_cnt;
1538
1539                 ret = create_engine_group(&pdev->dev, eng_grps, engs, 1,
1540                                           (void **) tar_info, 1, true);
1541                 if (ret)
1542                         goto release_tar_arch;
1543         }
1544
1545         print_dbg_info(&pdev->dev, eng_grps);
1546 release_tar_arch:
1547         release_tar_archive(tar_arch);
1548 unlock_mutex:
1549         mutex_unlock(&eng_grps->lock);
1550         return ret;
1551 }
1552
1553 void otx_cpt_set_eng_grps_is_rdonly(struct otx_cpt_eng_grps *eng_grps,
1554                                     bool is_rdonly)
1555 {
1556         mutex_lock(&eng_grps->lock);
1557
1558         eng_grps->is_rdonly = is_rdonly;
1559
1560         mutex_unlock(&eng_grps->lock);
1561 }
1562
1563 void otx_cpt_disable_all_cores(struct otx_cpt_device *cpt)
1564 {
1565         int grp, timeout = 100;
1566         u64 reg;
1567
1568         /* Disengage the cores from groups */
1569         for (grp = 0; grp < OTX_CPT_MAX_ENGINE_GROUPS; grp++) {
1570                 writeq(0, cpt->reg_base + OTX_CPT_PF_GX_EN(grp));
1571                 udelay(CSR_DELAY);
1572         }
1573
1574         reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
1575         while (reg) {
1576                 udelay(CSR_DELAY);
1577                 reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
1578                 if (timeout--) {
1579                         dev_warn(&cpt->pdev->dev, "Cores still busy\n");
1580                         break;
1581                 }
1582         }
1583
1584         /* Disable the cores */
1585         writeq(0, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
1586 }
1587
1588 void otx_cpt_cleanup_eng_grps(struct pci_dev *pdev,
1589                               struct otx_cpt_eng_grps *eng_grps)
1590 {
1591         struct otx_cpt_eng_grp_info *grp;
1592         int i, j;
1593
1594         mutex_lock(&eng_grps->lock);
1595         if (eng_grps->is_ucode_load_created) {
1596                 device_remove_file(&pdev->dev,
1597                                    &eng_grps->ucode_load_attr);
1598                 eng_grps->is_ucode_load_created = false;
1599         }
1600
1601         /* First delete all mirroring engine groups */
1602         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++)
1603                 if (eng_grps->grp[i].mirror.is_ena)
1604                         delete_engine_group(&pdev->dev, &eng_grps->grp[i]);
1605
1606         /* Delete remaining engine groups */
1607         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++)
1608                 delete_engine_group(&pdev->dev, &eng_grps->grp[i]);
1609
1610         /* Release memory */
1611         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
1612                 grp = &eng_grps->grp[i];
1613                 for (j = 0; j < OTX_CPT_MAX_ETYPES_PER_GRP; j++) {
1614                         kfree(grp->engs[j].bmap);
1615                         grp->engs[j].bmap = NULL;
1616                 }
1617         }
1618
1619         mutex_unlock(&eng_grps->lock);
1620 }
1621
1622 int otx_cpt_init_eng_grps(struct pci_dev *pdev,
1623                           struct otx_cpt_eng_grps *eng_grps, int pf_type)
1624 {
1625         struct otx_cpt_eng_grp_info *grp;
1626         int i, j, ret = 0;
1627
1628         mutex_init(&eng_grps->lock);
1629         eng_grps->obj = pci_get_drvdata(pdev);
1630         eng_grps->avail.se_cnt = eng_grps->avail.max_se_cnt;
1631         eng_grps->avail.ae_cnt = eng_grps->avail.max_ae_cnt;
1632
1633         eng_grps->engs_num = eng_grps->avail.max_se_cnt +
1634                              eng_grps->avail.max_ae_cnt;
1635         if (eng_grps->engs_num > OTX_CPT_MAX_ENGINES) {
1636                 dev_err(&pdev->dev,
1637                         "Number of engines %d > than max supported %d\n",
1638                         eng_grps->engs_num, OTX_CPT_MAX_ENGINES);
1639                 ret = -EINVAL;
1640                 goto err;
1641         }
1642
1643         for (i = 0; i < OTX_CPT_MAX_ENGINE_GROUPS; i++) {
1644                 grp = &eng_grps->grp[i];
1645                 grp->g = eng_grps;
1646                 grp->idx = i;
1647
1648                 snprintf(grp->sysfs_info_name, OTX_CPT_UCODE_NAME_LENGTH,
1649                          "engine_group%d", i);
1650                 for (j = 0; j < OTX_CPT_MAX_ETYPES_PER_GRP; j++) {
1651                         grp->engs[j].bmap =
1652                                 kcalloc(BITS_TO_LONGS(eng_grps->engs_num),
1653                                         sizeof(long), GFP_KERNEL);
1654                         if (!grp->engs[j].bmap) {
1655                                 ret = -ENOMEM;
1656                                 goto err;
1657                         }
1658                 }
1659         }
1660
1661         switch (pf_type) {
1662         case OTX_CPT_SE:
1663                 /* OcteonTX 83XX SE CPT PF has only SE engines attached */
1664                 eng_grps->eng_types_supported = 1 << OTX_CPT_SE_TYPES;
1665                 break;
1666
1667         case OTX_CPT_AE:
1668                 /* OcteonTX 83XX AE CPT PF has only AE engines attached */
1669                 eng_grps->eng_types_supported = 1 << OTX_CPT_AE_TYPES;
1670                 break;
1671
1672         default:
1673                 dev_err(&pdev->dev, "Unknown PF type %d\n", pf_type);
1674                 ret = -EINVAL;
1675                 goto err;
1676         }
1677
1678         eng_grps->ucode_load_attr.show = NULL;
1679         eng_grps->ucode_load_attr.store = ucode_load_store;
1680         eng_grps->ucode_load_attr.attr.name = "ucode_load";
1681         eng_grps->ucode_load_attr.attr.mode = 0220;
1682         sysfs_attr_init(&eng_grps->ucode_load_attr.attr);
1683         ret = device_create_file(&pdev->dev,
1684                                  &eng_grps->ucode_load_attr);
1685         if (ret)
1686                 goto err;
1687         eng_grps->is_ucode_load_created = true;
1688
1689         print_dbg_info(&pdev->dev, eng_grps);
1690         return ret;
1691 err:
1692         otx_cpt_cleanup_eng_grps(pdev, eng_grps);
1693         return ret;
1694 }