Lines Matching +full:hdr +full:- +full:engine
1 // SPDX-License-Identifier: GPL-2.0
26 /* tar header as defined in POSIX 1003.1-1990. */
48 struct tar_hdr_t hdr;
65 if (eng_grp->g->engs_num > OTX_CPT_MAX_ENGINES) {
67 eng_grp->g->engs_num);
72 if (eng_grp->engs[i].type) {
74 eng_grp->engs[i].bmap,
75 eng_grp->g->engs_num);
76 bmap.size = eng_grp->g->engs_num;
82 dev_err(dev, "No engines reserved for engine group %d\n",
83 eng_grp->idx);
95 return is_eng_type(eng_grps->eng_types_supported, eng_type);
101 strscpy(ucode->filename, filename, OTX_CPT_UCODE_NAME_LENGTH);
142 strscpy(tmp_ver_str, ucode_hdr->ver_str, OTX_CPT_UCODE_VER_STR_SZ);
146 nn = ucode_hdr->ver_num.nn;
147 if (strnstr(tmp_ver_str, "se-", OTX_CPT_UCODE_VER_STR_SZ) &&
158 return -EINVAL;
161 return -EINVAL;
183 bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
185 return -EINVAL;
187 if (eng_grp->mirror.is_ena)
189 eng_grp->g->grp[eng_grp->mirror.idx].ucode[0].align_dma;
191 dma_addr = eng_grp->ucode[0].align_dma;
198 if (!eng_grp->g->eng_ref_cnt[i])
199 writeq((u64) dma_addr, cpt->reg_base +
213 bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
215 return -EINVAL;
218 reg = readq(cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
221 eng_grp->g->eng_ref_cnt[i]--;
225 writeq(reg, cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
231 if (timeout-- < 0)
232 return -EBUSY;
234 reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
243 reg = readq(cpt->reg_base + OTX_CPT_PF_EXE_CTL);
245 if (!eng_grp->g->eng_ref_cnt[i])
247 writeq(reg, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
260 bmap = get_cores_bmap(&cpt->pdev->dev, eng_grp);
262 return -EINVAL;
265 reg = readq(cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
268 eng_grp->g->eng_ref_cnt[i]++;
272 writeq(reg, cpt->reg_base + OTX_CPT_PF_GX_EN(eng_grp->idx));
275 reg = readq(cpt->reg_base + OTX_CPT_PF_EXE_CTL);
278 writeq(reg, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
308 code_length = ntohl(ucode_hdr->code_length);
311 return -EINVAL;
318 return -EINVAL;
323 return -ENOMEM;
325 tar_info->ucode_ptr = data;
326 set_ucode_filename(&tar_info->ucode, filename);
327 memcpy(tar_info->ucode.ver_str, ucode_hdr->ver_str,
329 tar_info->ucode.ver_num = ucode_hdr->ver_num;
330 tar_info->ucode.type = ucode_type;
331 tar_info->ucode.size = ucode_size;
332 list_add_tail(&tar_info->list, &tar_arch->ucodes);
344 list_for_each_entry_safe(curr, temp, &tar_arch->ucodes, list) {
345 list_del(&curr->list);
349 release_firmware(tar_arch->fw);
359 list_for_each_entry(curr, &tar_arch->ucodes, list) {
360 if (!is_eng_type(curr->ucode.type, ucode_type))
373 if (uc_found->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE2 ||
374 (uc_found->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE3
375 && curr->ucode.ver_num.nn == OTX_CPT_SE_UC_TYPE1))
390 pr_debug("Tar archive pointer %p, size %ld\n", tar_arch->fw->data,
391 tar_arch->fw->size);
392 list_for_each_entry(curr, &tar_arch->ucodes, list) {
393 pr_debug("Ucode filename %s\n", curr->ucode.filename);
394 pr_debug("Ucode version string %s\n", curr->ucode.ver_str);
396 curr->ucode.ver_num.nn, curr->ucode.ver_num.xx,
397 curr->ucode.ver_num.yy, curr->ucode.ver_num.zz);
398 pr_debug("Ucode type (%d) %s\n", curr->ucode.type,
399 get_ucode_type_str(curr->ucode.type));
400 pr_debug("Ucode size %d\n", curr->ucode.size);
401 pr_debug("Ucode ptr %p\n", curr->ucode_ptr);
419 INIT_LIST_HEAD(&tar_arch->ucodes);
422 ret = request_firmware(&tar_arch->fw, tar_filename, dev);
426 if (tar_arch->fw->size < TAR_BLOCK_LEN) {
431 tar_size = tar_arch->fw->size;
432 tar_blk = (struct tar_blk_t *) tar_arch->fw->data;
433 if (strncmp(tar_blk->hdr.magic, TAR_MAGIC, TAR_MAGIC_LEN - 1)) {
441 ret = kstrtouint(tar_blk->hdr.size, 8, &cur_size);
452 if (tar_blk->hdr.typeflag == REGTYPE ||
453 tar_blk->hdr.typeflag == AREGTYPE) {
455 tar_blk->hdr.name,
456 &tar_arch->fw->data[tar_offs],
472 if (is_mem_zero(&tar_arch->fw->data[tar_offs],
477 tar_blk = (struct tar_blk_t *) &tar_arch->fw->data[tar_offs];
494 if (!eng_grp->engs[i].type)
497 if (eng_grp->engs[i].type == eng_type)
498 return &eng_grp->engs[i];
505 return is_eng_type(ucode->type, eng_type);
512 if (eng_grp->mirror.is_ena) {
514 eng_grp->g->grp[eng_grp->mirror.idx].ucode[0].ver_str,
515 eng_grp->mirror.idx);
517 scnprintf(buf, size, "%s", eng_grp->ucode[0].ver_str);
530 engs = &eng_grp->engs[i];
531 if (!engs->type)
533 if (idx != -1 && idx != i)
536 if (eng_grp->mirror.is_ena)
538 &eng_grp->g->grp[eng_grp->mirror.idx],
539 engs->type);
540 if (i > 0 && idx == -1) {
542 scnprintf(buf+len, size-len, ", ");
546 scnprintf(buf+len, size-len, "%d %s ", mirrored_engs ?
547 engs->count + mirrored_engs->count : engs->count,
548 get_eng_type_str(engs->type));
551 scnprintf(buf+len, size-len,
553 engs->count <= 0 ? engs->count +
554 mirrored_engs->count : mirrored_engs->count,
555 eng_grp->mirror.idx);
563 pr_debug("Ucode version string %s\n", ucode->ver_str);
564 pr_debug("Ucode version %d.%d.%d.%d\n", ucode->ver_num.nn,
565 ucode->ver_num.xx, ucode->ver_num.yy, ucode->ver_num.zz);
566 pr_debug("Ucode type %s\n", get_ucode_type_str(ucode->type));
567 pr_debug("Ucode size %d\n", ucode->size);
568 pr_debug("Ucode virt address %16.16llx\n", (u64)ucode->align_va);
569 pr_debug("Ucode phys address %16.16llx\n", ucode->align_dma);
599 pr_debug("Engine groups global info\n");
601 eng_grps->avail.max_se_cnt, eng_grps->avail.max_ae_cnt);
602 pr_debug("free SE %d\n", eng_grps->avail.se_cnt);
603 pr_debug("free AE %d\n", eng_grps->avail.ae_cnt);
606 grp = &eng_grps->grp[i];
608 str_enabled_disabled(grp->is_enabled));
609 if (grp->is_enabled) {
610 mirrored_grp = &eng_grps->grp[grp->mirror.idx];
612 grp->mirror.is_ena ?
613 mirrored_grp->ucode[0].filename :
614 grp->ucode[0].filename,
615 grp->mirror.is_ena ?
616 mirrored_grp->ucode[0].ver_str :
617 grp->ucode[0].ver_str);
621 engs = &grp->engs[j];
622 if (engs->type) {
626 bitmap_to_arr32(mask, engs->bmap,
627 eng_grps->engs_num);
633 if (grp->is_enabled) {
645 switch (engs->type) {
647 avail->se_cnt += val;
651 avail->ae_cnt += val;
655 dev_err(dev, "Invalid engine type %d\n", engs->type);
656 return -EINVAL;
666 switch (engs->type) {
668 engs->offset = 0;
672 engs->offset = avail->max_se_cnt;
676 dev_err(dev, "Invalid engine type %d\n", engs->type);
677 return -EINVAL;
688 if (!grp->engs[i].type)
691 if (grp->engs[i].count > 0) {
692 ret = update_engines_avail_count(dev, &grp->g->avail,
693 &grp->engs[i],
694 grp->engs[i].count);
699 grp->engs[i].type = 0;
700 grp->engs[i].count = 0;
701 grp->engs[i].offset = 0;
702 grp->engs[i].ucode = NULL;
703 bitmap_zero(grp->engs[i].bmap, grp->g->engs_num);
717 if (!grp->engs[i].type) {
718 engs = &grp->engs[i];
724 return -ENOMEM;
726 engs->type = req_engs->type;
727 engs->count = req_engs->count;
729 ret = update_engines_offset(dev, &grp->g->avail, engs);
733 if (engs->count > 0) {
734 ret = update_engines_avail_count(dev, &grp->g->avail, engs,
735 -engs->count);
749 switch (req_eng->type) {
751 avail_cnt = grp->g->avail.se_cnt;
755 avail_cnt = grp->g->avail.ae_cnt;
759 dev_err(dev, "Invalid engine type %d\n", req_eng->type);
760 return -EINVAL;
763 if (avail_cnt < req_eng->count) {
766 get_eng_type_str(req_eng->type),
767 avail_cnt, req_eng->count);
768 return -EBUSY;
786 /* Reserve requested engines for this engine group */
806 mutex_lock(&eng_grp->g->lock);
808 print_engs_info(eng_grp, engs_info, 2*OTX_CPT_UCODE_NAME_LENGTH, -1);
816 mutex_unlock(&eng_grp->g->lock);
823 eng_grp->info_attr.show = eng_grp_info_show;
824 eng_grp->info_attr.store = NULL;
825 eng_grp->info_attr.attr.name = eng_grp->sysfs_info_name;
826 eng_grp->info_attr.attr.mode = 0440;
827 sysfs_attr_init(&eng_grp->info_attr.attr);
828 return device_create_file(dev, &eng_grp->info_attr);
833 if (ucode->va) {
834 dma_free_coherent(dev, ucode->size + OTX_CPT_UCODE_ALIGNMENT,
835 ucode->va, ucode->dma);
836 ucode->va = NULL;
837 ucode->align_va = NULL;
838 ucode->dma = 0;
839 ucode->align_dma = 0;
840 ucode->size = 0;
843 memset(&ucode->ver_str, 0, OTX_CPT_UCODE_VER_STR_SZ);
844 memset(&ucode->ver_num, 0, sizeof(struct otx_cpt_ucode_ver_num));
846 ucode->type = 0;
856 ucode->va = dma_alloc_coherent(dev, ucode->size +
858 &ucode->dma, GFP_KERNEL);
859 if (!ucode->va) {
861 return -ENOMEM;
863 ucode->align_va = PTR_ALIGN(ucode->va, OTX_CPT_UCODE_ALIGNMENT);
864 ucode->align_dma = PTR_ALIGN(ucode->dma, OTX_CPT_UCODE_ALIGNMENT);
866 memcpy((void *) ucode->align_va, (void *) ucode_data +
867 sizeof(struct otx_cpt_ucode_hdr), ucode->size);
869 /* Byte swap 64-bit */
870 for (i = 0; i < (ucode->size / 8); i++)
871 ((__be64 *)ucode->align_va)[i] =
872 cpu_to_be64(((u64 *)ucode->align_va)[i]);
873 /* Ucode needs 16-bit swap */
874 for (i = 0; i < (ucode->size / 2); i++)
875 ((__be16 *)ucode->align_va)[i] =
876 cpu_to_be16(((u16 *)ucode->align_va)[i]);
889 ret = request_firmware(&fw, ucode->filename, dev);
893 ucode_hdr = (struct otx_cpt_ucode_hdr *) fw->data;
894 memcpy(ucode->ver_str, ucode_hdr->ver_str, OTX_CPT_UCODE_VER_STR_SZ);
895 ucode->ver_num = ucode_hdr->ver_num;
896 code_length = ntohl(ucode_hdr->code_length);
899 ret = -EINVAL;
902 ucode->size = code_length * 2;
903 if (!ucode->size || (fw->size < round_up(ucode->size, 16)
906 ret = -EINVAL;
910 ret = get_ucode_type(ucode_hdr, &ucode->type);
913 ucode->filename, ucode->type);
917 ret = copy_ucode_to_dma_mem(dev, ucode, fw->data);
950 /* Unload ucode used by this engine group */
951 ucode_unload(dev, &eng_grp->ucode[0]);
954 if (!eng_grp->engs[i].type)
957 eng_grp->engs[i].ucode = &eng_grp->ucode[0];
968 /* Setup fields for engine group which is mirrored */
969 src_grp->mirror.is_ena = false;
970 src_grp->mirror.idx = 0;
971 src_grp->mirror.ref_count++;
973 /* Setup fields for mirroring engine group */
974 dst_grp->mirror.is_ena = true;
975 dst_grp->mirror.idx = src_grp->idx;
976 dst_grp->mirror.ref_count = 0;
983 if (!dst_grp->mirror.is_ena)
986 src_grp = &dst_grp->g->grp[dst_grp->mirror.idx];
988 src_grp->mirror.ref_count--;
989 dst_grp->mirror.is_ena = false;
990 dst_grp->mirror.idx = 0;
991 dst_grp->mirror.ref_count = 0;
1010 * from mirrored engine group will be shared with this engine
1013 * engines from mirrored engine group will be shared with this
1014 * engine group
1016 * from mirrored engine group will be shared with this group
1018 * by this engine group
1020 engs[i].count -= mirrored_engs->count;
1027 struct otx_cpt_eng_grps *eng_grps = grp->g;
1031 if (!eng_grps->grp[i].is_enabled)
1033 if (eng_grps->grp[i].ucode[0].type)
1035 if (grp->idx == i)
1037 if (!strncasecmp(eng_grps->grp[i].ucode[0].ver_str,
1038 grp->ucode[0].ver_str,
1040 return &eng_grps->grp[i];
1052 if (!eng_grps->grp[i].is_enabled)
1053 return &eng_grps->grp[i];
1067 engs = &eng_grp->engs[i];
1068 if (!engs->type)
1070 if (engs->count <= 0)
1073 switch (engs->type) {
1075 max_cnt = eng_grp->g->avail.max_se_cnt;
1079 max_cnt = eng_grp->g->avail.max_ae_cnt;
1083 dev_err(dev, "Invalid engine type %d\n", engs->type);
1084 return -EINVAL;
1087 cnt = engs->count;
1088 WARN_ON(engs->offset + max_cnt > OTX_CPT_MAX_ENGINES);
1089 bitmap_zero(tmp_bmap.bits, eng_grp->g->engs_num);
1090 for (j = engs->offset; j < engs->offset + max_cnt; j++) {
1091 if (!eng_grp->g->eng_ref_cnt[j]) {
1093 cnt--;
1100 return -ENOSPC;
1102 bitmap_copy(engs->bmap, tmp_bmap.bits, eng_grp->g->engs_num);
1105 if (!eng_grp->mirror.is_ena)
1109 engs = &eng_grp->engs[i];
1110 if (!engs->type)
1114 &eng_grp->g->grp[eng_grp->mirror.idx],
1115 engs->type);
1116 WARN_ON(!mirrored_engs && engs->count <= 0);
1120 bitmap_copy(tmp_bmap.bits, mirrored_engs->bmap,
1121 eng_grp->g->engs_num);
1122 if (engs->count < 0) {
1123 bit = find_first_bit(mirrored_engs->bmap,
1124 eng_grp->g->engs_num);
1125 bitmap_clear(tmp_bmap.bits, bit, -engs->count);
1127 bitmap_or(engs->bmap, engs->bmap, tmp_bmap.bits,
1128 eng_grp->g->engs_num);
1138 if (!eng_grp->is_enabled)
1139 return -EINVAL;
1141 if (eng_grp->mirror.ref_count) {
1143 eng_grp->idx);
1145 if (eng_grp->g->grp[i].mirror.is_ena &&
1146 eng_grp->g->grp[i].mirror.idx == eng_grp->idx)
1150 return -EINVAL;
1153 /* Removing engine group mirroring if enabled */
1156 /* Disable engine group */
1157 ret = disable_eng_grp(dev, eng_grp, eng_grp->g->obj);
1161 /* Release all engines held by this engine group */
1166 device_remove_file(dev, &eng_grp->info_attr);
1167 eng_grp->is_enabled = false;
1178 /* Verify that ucode loaded supports requested engine types */
1180 if (!otx_cpt_uc_supports_eng_type(&eng_grp->ucode[0],
1184 eng_grp->ucode[0].filename,
1186 return -EINVAL;
1196 if (eng_grp->mirror.is_ena)
1197 ucode = &eng_grp->g->grp[eng_grp->mirror.idx].ucode[0];
1199 ucode = &eng_grp->ucode[0];
1200 WARN_ON(!eng_grp->engs[0].type);
1201 eng_grp->engs[0].ucode = ucode;
1216 return -EINVAL;
1218 /* Validate if requested engine types are supported by this device */
1223 return -EPERM;
1226 /* Find engine group which is not used */
1229 dev_err(dev, "Error all engine groups are being used\n");
1230 return -ENOSPC;
1237 eng_grp->ucode[i] = tar_info->ucode;
1238 ret = copy_ucode_to_dma_mem(dev, &eng_grp->ucode[i],
1239 tar_info->ucode_ptr);
1241 ret = ucode_load(dev, &eng_grp->ucode[i],
1252 /* Check if this group mirrors another existing engine group */
1273 /* Update engine masks used by this group */
1278 /* Create sysfs entry for engine group info */
1283 /* Enable engine group */
1284 ret = enable_eng_grp(eng_grp, eng_grps->obj);
1289 * If this engine group mirrors another engine group
1291 * from mirrored engine group
1293 if (eng_grp->mirror.is_ena)
1294 ucode_unload(dev, &eng_grp->ucode[0]);
1296 eng_grp->is_enabled = true;
1297 if (eng_grp->mirror.is_ena)
1300 eng_grp->idx, mirrored_eng_grp->ucode[0].ver_str,
1301 mirrored_eng_grp->idx);
1304 eng_grp->idx, eng_grp->ucode[0].ver_str);
1311 ucode_unload(dev, &eng_grp->ucode[0]);
1324 int grp_idx = 0, ret = -EINVAL;
1326 int del_grp_idx = -1;
1330 return -EINVAL;
1333 err_msg = "Invalid engine group format";
1348 if (del_grp_idx != -1)
1398 if (del_grp_idx == -1) {
1406 err_msg = "Error max 2 engine types can be attached";
1413 dev_err(dev, "Invalid engine group index %d\n",
1415 ret = -EINVAL;
1419 if (!eng_grps->grp[del_grp_idx].is_enabled) {
1422 ret = -EINVAL;
1430 mutex_lock(&eng_grps->lock);
1432 if (eng_grps->is_rdonly) {
1433 dev_err(dev, "Disable VFs before modifying engine groups\n");
1434 ret = -EACCES;
1438 if (del_grp_idx == -1)
1439 /* create engine group */
1444 /* delete engine group */
1445 ret = delete_engine_group(dev, &eng_grps->grp[del_grp_idx]);
1451 mutex_unlock(&eng_grps->lock);
1469 mutex_lock(&eng_grps->lock);
1472 * We don't create engine group for kernel crypto if attempt to create
1475 if (eng_grps->is_first_try)
1477 eng_grps->is_first_try = true;
1481 if (eng_grps->grp[i].is_enabled)
1491 dev_err(&pdev->dev, "Unknown PF type %d\n", pf_type);
1492 ret = -EINVAL;
1496 tar_arch = load_tar_archive(&pdev->dev, tar_filename);
1502 * archive try to create engine group with SE engines for kernel
1510 engs[0].count = eng_grps->avail.max_se_cnt;
1512 ret = create_engine_group(&pdev->dev, eng_grps, engs, 1,
1519 * archive try to create engine group with AE engines for asymmetric
1527 engs[0].count = eng_grps->avail.max_ae_cnt;
1529 ret = create_engine_group(&pdev->dev, eng_grps, engs, 1,
1535 print_dbg_info(&pdev->dev, eng_grps);
1539 mutex_unlock(&eng_grps->lock);
1546 mutex_lock(&eng_grps->lock);
1548 eng_grps->is_rdonly = is_rdonly;
1550 mutex_unlock(&eng_grps->lock);
1560 writeq(0, cpt->reg_base + OTX_CPT_PF_GX_EN(grp));
1564 reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
1567 reg = readq(cpt->reg_base + OTX_CPT_PF_EXEC_BUSY);
1568 if (timeout--) {
1569 dev_warn(&cpt->pdev->dev, "Cores still busy\n");
1575 writeq(0, cpt->reg_base + OTX_CPT_PF_EXE_CTL);
1584 mutex_lock(&eng_grps->lock);
1585 if (eng_grps->is_ucode_load_created) {
1586 device_remove_file(&pdev->dev,
1587 &eng_grps->ucode_load_attr);
1588 eng_grps->is_ucode_load_created = false;
1591 /* First delete all mirroring engine groups */
1593 if (eng_grps->grp[i].mirror.is_ena)
1594 delete_engine_group(&pdev->dev, &eng_grps->grp[i]);
1596 /* Delete remaining engine groups */
1598 delete_engine_group(&pdev->dev, &eng_grps->grp[i]);
1602 grp = &eng_grps->grp[i];
1604 kfree(grp->engs[j].bmap);
1605 grp->engs[j].bmap = NULL;
1609 mutex_unlock(&eng_grps->lock);
1618 mutex_init(&eng_grps->lock);
1619 eng_grps->obj = pci_get_drvdata(pdev);
1620 eng_grps->avail.se_cnt = eng_grps->avail.max_se_cnt;
1621 eng_grps->avail.ae_cnt = eng_grps->avail.max_ae_cnt;
1623 eng_grps->engs_num = eng_grps->avail.max_se_cnt +
1624 eng_grps->avail.max_ae_cnt;
1625 if (eng_grps->engs_num > OTX_CPT_MAX_ENGINES) {
1626 dev_err(&pdev->dev,
1628 eng_grps->engs_num, OTX_CPT_MAX_ENGINES);
1629 ret = -EINVAL;
1634 grp = &eng_grps->grp[i];
1635 grp->g = eng_grps;
1636 grp->idx = i;
1638 snprintf(grp->sysfs_info_name, OTX_CPT_UCODE_NAME_LENGTH,
1641 grp->engs[j].bmap =
1642 kcalloc(BITS_TO_LONGS(eng_grps->engs_num),
1644 if (!grp->engs[j].bmap) {
1645 ret = -ENOMEM;
1654 eng_grps->eng_types_supported = 1 << OTX_CPT_SE_TYPES;
1659 eng_grps->eng_types_supported = 1 << OTX_CPT_AE_TYPES;
1663 dev_err(&pdev->dev, "Unknown PF type %d\n", pf_type);
1664 ret = -EINVAL;
1668 eng_grps->ucode_load_attr.show = NULL;
1669 eng_grps->ucode_load_attr.store = ucode_load_store;
1670 eng_grps->ucode_load_attr.attr.name = "ucode_load";
1671 eng_grps->ucode_load_attr.attr.mode = 0220;
1672 sysfs_attr_init(&eng_grps->ucode_load_attr.attr);
1673 ret = device_create_file(&pdev->dev,
1674 &eng_grps->ucode_load_attr);
1677 eng_grps->is_ucode_load_created = true;
1679 print_dbg_info(&pdev->dev, eng_grps);