crypto: qat - use pr_fmt() in qat uclo.c

+65 -70

1 changed file

expand all

drivers

crypto

intel

qat

qat_common

qat_uclo.c

+65 -70

drivers/crypto/intel/qat/qat_common/qat_uclo.c

··· 1 1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only) 2 2 /* Copyright(c) 2014 - 2020 Intel Corporation */ 3 + 4 + #define pr_fmt(fmt) "QAT: " fmt 5 + 3 6 #include <linux/align.h> 4 7 #include <linux/bitops.h> 5 8 #include <linux/slab.h> ··· 63 60 unsigned int i; 64 61 65 62 if (!ae_data) { 66 - pr_err("QAT: bad argument, ae_data is NULL\n"); 63 + pr_err("bad argument, ae_data is NULL\n"); 67 64 return -EINVAL; 68 65 } 69 66 ··· 90 87 int min = hdr->min_ver & 0xff; 91 88 92 89 if (hdr->file_id != ICP_QAT_UOF_FID) { 93 - pr_err("QAT: Invalid header 0x%x\n", hdr->file_id); 90 + pr_err("Invalid header 0x%x\n", hdr->file_id); 94 91 return -EINVAL; 95 92 } 96 93 if (min != ICP_QAT_UOF_MINVER || maj != ICP_QAT_UOF_MAJVER) { 97 - pr_err("QAT: bad UOF version, major 0x%x, minor 0x%x\n", 98 - maj, min); 94 + pr_err("bad UOF version, major 0x%x, minor 0x%x\n", maj, min); 99 95 return -EINVAL; 100 96 } 101 97 return 0; ··· 106 104 int min = suof_hdr->min_ver & 0xff; 107 105 108 106 if (suof_hdr->file_id != ICP_QAT_SUOF_FID) { 109 - pr_err("QAT: invalid header 0x%x\n", suof_hdr->file_id); 107 + pr_err("invalid header 0x%x\n", suof_hdr->file_id); 110 108 return -EINVAL; 111 109 } 112 110 if (suof_hdr->fw_type != 0) { 113 - pr_err("QAT: unsupported firmware type\n"); 111 + pr_err("unsupported firmware type\n"); 114 112 return -EINVAL; 115 113 } 116 114 if (suof_hdr->num_chunks <= 0x1) { 117 - pr_err("QAT: SUOF chunk amount is incorrect\n"); 115 + pr_err("SUOF chunk amount is incorrect\n"); 118 116 return -EINVAL; 119 117 } 120 118 if (maj != ICP_QAT_SUOF_MAJVER || min != ICP_QAT_SUOF_MINVER) { 121 - pr_err("QAT: bad SUOF version, major 0x%x, minor 0x%x\n", 122 - maj, min); 119 + pr_err("bad SUOF version, major 0x%x, minor 0x%x\n", maj, min); 123 120 return -EINVAL; 124 121 } 125 122 return 0; ··· 225 224 char *str; 226 225 227 226 if ((init_mem->addr + init_mem->num_in_bytes) > (size_range << 0x2)) { 228 - pr_err("QAT: initmem is out of range"); 227 + pr_err("initmem is out of range"); 229 228 return -EINVAL; 230 229 } 231 230 if (init_mem->scope != ICP_QAT_UOF_LOCAL_SCOPE) { 232 - pr_err("QAT: Memory scope for init_mem error\n"); 231 + pr_err("Memory scope for init_mem error\n"); 233 232 return -EINVAL; 234 233 } 235 234 str = qat_uclo_get_string(&obj_handle->str_table, init_mem->sym_name); 236 235 if (!str) { 237 - pr_err("QAT: AE name assigned in UOF init table is NULL\n"); 236 + pr_err("AE name assigned in UOF init table is NULL\n"); 238 237 return -EINVAL; 239 238 } 240 239 if (qat_uclo_parse_num(str, ae)) { 241 - pr_err("QAT: Parse num for AE number failed\n"); 240 + pr_err("Parse num for AE number failed\n"); 242 241 return -EINVAL; 243 242 } 244 243 if (*ae >= ICP_QAT_UCLO_MAX_AE) { 245 - pr_err("QAT: ae %d out of range\n", *ae); 244 + pr_err("ae %d out of range\n", *ae); 246 245 return -EINVAL; 247 246 } 248 247 return 0; ··· 358 357 return -EINVAL; 359 358 break; 360 359 default: 361 - pr_err("QAT: initmem region error. region type=0x%x\n", 362 - init_mem->region); 360 + pr_err("initmem region error. region type=0x%x\n", init_mem->region); 363 361 return -EINVAL; 364 362 } 365 363 return 0; ··· 432 432 for_each_set_bit(ae, &ae_mask, handle->hal_handle->ae_max_num) { 433 433 if (qat_hal_batch_wr_lm(handle, ae, 434 434 obj_handle->lm_init_tab[ae])) { 435 - pr_err("QAT: fail to batch init lmem for AE %d\n", ae); 435 + pr_err("fail to batch init lmem for AE %d\n", ae); 436 436 return -EINVAL; 437 437 } 438 438 qat_uclo_cleanup_batch_init_list(handle, ··· 540 540 code_page->imp_expr_tab_offset); 541 541 if (uc_var_tab->entry_num || imp_var_tab->entry_num || 542 542 imp_expr_tab->entry_num) { 543 - pr_err("QAT: UOF can't contain imported variable to be parsed\n"); 543 + pr_err("UOF can't contain imported variable to be parsed\n"); 544 544 return -EINVAL; 545 545 } 546 546 neigh_reg_tab = (struct icp_qat_uof_objtable *) 547 547 (encap_uof_obj->beg_uof + 548 548 code_page->neigh_reg_tab_offset); 549 549 if (neigh_reg_tab->entry_num) { 550 - pr_err("QAT: UOF can't contain neighbor register table\n"); 550 + pr_err("UOF can't contain neighbor register table\n"); 551 551 return -EINVAL; 552 552 } 553 553 if (image->numpages > 1) { 554 - pr_err("QAT: UOF can't contain multiple pages\n"); 554 + pr_err("UOF can't contain multiple pages\n"); 555 555 return -EINVAL; 556 556 } 557 557 if (ICP_QAT_SHARED_USTORE_MODE(image->ae_mode)) { 558 - pr_err("QAT: UOF can't use shared control store feature\n"); 558 + pr_err("UOF can't use shared control store feature\n"); 559 559 return -EFAULT; 560 560 } 561 561 if (RELOADABLE_CTX_SHARED_MODE(image->ae_mode)) { 562 - pr_err("QAT: UOF can't use reloadable feature\n"); 562 + pr_err("UOF can't use reloadable feature\n"); 563 563 return -EFAULT; 564 564 } 565 565 return 0; ··· 678 678 } 679 679 } 680 680 if (!mflag) { 681 - pr_err("QAT: uimage uses AE not set\n"); 681 + pr_err("uimage uses AE not set\n"); 682 682 return -EINVAL; 683 683 } 684 684 return 0; ··· 738 738 case PCI_DEVICE_ID_INTEL_QAT_420XX: 739 739 return ICP_QAT_AC_4XXX_A_DEV_TYPE; 740 740 default: 741 - pr_err("QAT: unsupported device 0x%x\n", 742 - handle->pci_dev->device); 741 + pr_err("unsupported device 0x%x\n", handle->pci_dev->device); 743 742 return 0; 744 743 } 745 744 } ··· 748 749 unsigned int maj_ver, prod_type = obj_handle->prod_type; 749 750 750 751 if (!(prod_type & obj_handle->encap_uof_obj.obj_hdr->ac_dev_type)) { 751 - pr_err("QAT: UOF type 0x%x doesn't match with platform 0x%x\n", 752 + pr_err("UOF type 0x%x doesn't match with platform 0x%x\n", 752 753 obj_handle->encap_uof_obj.obj_hdr->ac_dev_type, 753 754 prod_type); 754 755 return -EINVAL; ··· 756 757 maj_ver = obj_handle->prod_rev & 0xff; 757 758 if (obj_handle->encap_uof_obj.obj_hdr->max_cpu_ver < maj_ver || 758 759 obj_handle->encap_uof_obj.obj_hdr->min_cpu_ver > maj_ver) { 759 - pr_err("QAT: UOF majVer 0x%x out of range\n", maj_ver); 760 + pr_err("UOF majVer 0x%x out of range\n", maj_ver); 760 761 return -EINVAL; 761 762 } 762 763 return 0; ··· 799 800 case ICP_NEIGH_REL: 800 801 return qat_hal_init_nn(handle, ae, ctx_mask, reg_addr, value); 801 802 default: 802 - pr_err("QAT: UOF uses not supported reg type 0x%x\n", reg_type); 803 + pr_err("UOF uses not supported reg type 0x%x\n", reg_type); 803 804 return -EFAULT; 804 805 } 805 806 return 0; ··· 835 836 case ICP_QAT_UOF_INIT_REG_CTX: 836 837 /* check if ctx is appropriate for the ctxMode */ 837 838 if (!((1 << init_regsym->ctx) & ctx_mask)) { 838 - pr_err("QAT: invalid ctx num = 0x%x\n", 839 - init_regsym->ctx); 839 + pr_err("invalid ctx num = 0x%x\n", init_regsym->ctx); 840 840 return -EINVAL; 841 841 } 842 842 qat_uclo_init_reg(handle, ae, ··· 847 849 exp_res); 848 850 break; 849 851 case ICP_QAT_UOF_INIT_EXPR: 850 - pr_err("QAT: INIT_EXPR feature not supported\n"); 852 + pr_err("INIT_EXPR feature not supported\n"); 851 853 return -EINVAL; 852 854 case ICP_QAT_UOF_INIT_EXPR_ENDIAN_SWAP: 853 - pr_err("QAT: INIT_EXPR_ENDIAN_SWAP feature not supported\n"); 855 + pr_err("INIT_EXPR_ENDIAN_SWAP feature not supported\n"); 854 856 return -EINVAL; 855 857 default: 856 858 break; ··· 870 872 return 0; 871 873 if (obj_handle->init_mem_tab.entry_num) { 872 874 if (qat_uclo_init_memory(handle)) { 873 - pr_err("QAT: initialize memory failed\n"); 875 + pr_err("initialize memory failed\n"); 874 876 return -EINVAL; 875 877 } 876 878 } ··· 899 901 mode = ICP_QAT_CTX_MODE(uof_image->ae_mode); 900 902 ret = qat_hal_set_ae_ctx_mode(handle, ae, mode); 901 903 if (ret) { 902 - pr_err("QAT: qat_hal_set_ae_ctx_mode error\n"); 904 + pr_err("qat_hal_set_ae_ctx_mode error\n"); 903 905 return ret; 904 906 } 905 907 if (handle->chip_info->nn) { 906 908 mode = ICP_QAT_NN_MODE(uof_image->ae_mode); 907 909 ret = qat_hal_set_ae_nn_mode(handle, ae, mode); 908 910 if (ret) { 909 - pr_err("QAT: qat_hal_set_ae_nn_mode error\n"); 911 + pr_err("qat_hal_set_ae_nn_mode error\n"); 910 912 return ret; 911 913 } 912 914 } 913 915 mode = ICP_QAT_LOC_MEM0_MODE(uof_image->ae_mode); 914 916 ret = qat_hal_set_ae_lm_mode(handle, ae, ICP_LMEM0, mode); 915 917 if (ret) { 916 - pr_err("QAT: qat_hal_set_ae_lm_mode LMEM0 error\n"); 918 + pr_err("qat_hal_set_ae_lm_mode LMEM0 error\n"); 917 919 return ret; 918 920 } 919 921 mode = ICP_QAT_LOC_MEM1_MODE(uof_image->ae_mode); 920 922 ret = qat_hal_set_ae_lm_mode(handle, ae, ICP_LMEM1, mode); 921 923 if (ret) { 922 - pr_err("QAT: qat_hal_set_ae_lm_mode LMEM1 error\n"); 924 + pr_err("qat_hal_set_ae_lm_mode LMEM1 error\n"); 923 925 return ret; 924 926 } 925 927 if (handle->chip_info->lm2lm3) { 926 928 mode = ICP_QAT_LOC_MEM2_MODE(uof_image->ae_mode); 927 929 ret = qat_hal_set_ae_lm_mode(handle, ae, ICP_LMEM2, mode); 928 930 if (ret) { 929 - pr_err("QAT: qat_hal_set_ae_lm_mode LMEM2 error\n"); 931 + pr_err("qat_hal_set_ae_lm_mode LMEM2 error\n"); 930 932 return ret; 931 933 } 932 934 mode = ICP_QAT_LOC_MEM3_MODE(uof_image->ae_mode); 933 935 ret = qat_hal_set_ae_lm_mode(handle, ae, ICP_LMEM3, mode); 934 936 if (ret) { 935 - pr_err("QAT: qat_hal_set_ae_lm_mode LMEM3 error\n"); 937 + pr_err("qat_hal_set_ae_lm_mode LMEM3 error\n"); 936 938 return ret; 937 939 } 938 940 mode = ICP_QAT_LOC_TINDEX_MODE(uof_image->ae_mode); ··· 996 998 obj_handle->prod_rev = PID_MAJOR_REV | 997 999 (PID_MINOR_REV & handle->hal_handle->revision_id); 998 1000 if (qat_uclo_check_uof_compat(obj_handle)) { 999 - pr_err("QAT: UOF incompatible\n"); 1001 + pr_err("UOF incompatible\n"); 1000 1002 return -EINVAL; 1001 1003 } 1002 1004 obj_handle->uword_buf = kcalloc(UWORD_CPYBUF_SIZE, sizeof(u64), ··· 1007 1009 if (!obj_handle->obj_hdr->file_buff || 1008 1010 !qat_uclo_map_str_table(obj_handle->obj_hdr, ICP_QAT_UOF_STRT, 1009 1011 &obj_handle->str_table)) { 1010 - pr_err("QAT: UOF doesn't have effective images\n"); 1012 + pr_err("UOF doesn't have effective images\n"); 1011 1013 goto out_err; 1012 1014 } 1013 1015 obj_handle->uimage_num = ··· 1016 1018 if (!obj_handle->uimage_num) 1017 1019 goto out_err; 1018 1020 if (qat_uclo_map_ae(handle, handle->hal_handle->ae_max_num)) { 1019 - pr_err("QAT: Bad object\n"); 1021 + pr_err("Bad object\n"); 1020 1022 goto out_check_uof_aemask_err; 1021 1023 } 1022 1024 qat_uclo_init_uword_num(handle); ··· 1049 1051 check_sum = qat_uclo_calc_str_checksum((char *)&suof_ptr->min_ver, 1050 1052 min_ver_offset); 1051 1053 if (check_sum != suof_ptr->check_sum) { 1052 - pr_err("QAT: incorrect SUOF checksum\n"); 1054 + pr_err("incorrect SUOF checksum\n"); 1053 1055 return -EINVAL; 1054 1056 } 1055 1057 suof_handle->check_sum = suof_ptr->check_sum; ··· 1111 1113 prod_rev = PID_MAJOR_REV | 1112 1114 (PID_MINOR_REV & handle->hal_handle->revision_id); 1113 1115 if (img_ae_mode->dev_type != prod_type) { 1114 - pr_err("QAT: incompatible product type %x\n", 1115 - img_ae_mode->dev_type); 1116 + pr_err("incompatible product type %x\n", img_ae_mode->dev_type); 1116 1117 return -EINVAL; 1117 1118 } 1118 1119 maj_ver = prod_rev & 0xff; 1119 1120 if (maj_ver > img_ae_mode->devmax_ver || 1120 1121 maj_ver < img_ae_mode->devmin_ver) { 1121 - pr_err("QAT: incompatible device majver 0x%x\n", maj_ver); 1122 + pr_err("incompatible device majver 0x%x\n", maj_ver); 1122 1123 return -EINVAL; 1123 1124 } 1124 1125 return 0; ··· 1160 1163 struct icp_qat_suof_img_hdr img_header; 1161 1164 1162 1165 if (!suof_ptr || suof_size == 0) { 1163 - pr_err("QAT: input parameter SUOF pointer/size is NULL\n"); 1166 + pr_err("input parameter SUOF pointer/size is NULL\n"); 1164 1167 return -EINVAL; 1165 1168 } 1166 1169 if (qat_uclo_check_suof_format(suof_ptr)) ··· 1234 1237 return 0; 1235 1238 } while (retry++ < FW_AUTH_MAX_RETRY); 1236 1239 auth_fail: 1237 - pr_err("QAT: authentication error (FCU_STATUS = 0x%x),retry = %d\n", 1240 + pr_err("authentication error (FCU_STATUS = 0x%x),retry = %d\n", 1238 1241 fcu_sts & FCU_AUTH_STS_MASK, retry); 1239 1242 return -EINVAL; 1240 1243 } ··· 1270 1273 fcu_sts_csr = handle->chip_info->fcu_sts_csr; 1271 1274 fcu_loaded_csr = handle->chip_info->fcu_loaded_ae_csr; 1272 1275 } else { 1273 - pr_err("Chip 0x%x doesn't support broadcast load\n", 1274 - handle->pci_dev->device); 1276 + pr_err("Chip 0x%x doesn't support broadcast load\n", handle->pci_dev->device); 1275 1277 return -EINVAL; 1276 1278 } 1277 1279 1278 1280 for_each_set_bit(ae, &ae_mask, handle->hal_handle->ae_max_num) { 1279 1281 if (qat_hal_check_ae_active(handle, (unsigned char)ae)) { 1280 - pr_err("QAT: Broadcast load failed. AE is not enabled or active.\n"); 1282 + pr_err("Broadcast load failed. AE is not enabled or active.\n"); 1281 1283 return -EINVAL; 1282 1284 } 1283 1285 ··· 1308 1312 } while (retry++ < FW_AUTH_MAX_RETRY); 1309 1313 1310 1314 if (retry > FW_AUTH_MAX_RETRY) { 1311 - pr_err("QAT: broadcast load failed timeout %d\n", retry); 1315 + pr_err("broadcast load failed timeout %d\n", retry); 1312 1316 return -EINVAL; 1313 1317 } 1314 1318 } ··· 1393 1397 if (size > ICP_QAT_CSS_RSA3K_MAX_IMAGE_LEN) 1394 1398 goto err; 1395 1399 } else { 1396 - pr_err("QAT: Unsupported firmware type\n"); 1400 + pr_err("Unsupported firmware type\n"); 1397 1401 return -EINVAL; 1398 1402 } 1399 1403 return 0; 1400 1404 1401 1405 err: 1402 - pr_err("QAT: Invalid %s firmware image\n", fw_type_name); 1406 + pr_err("Invalid %s firmware image\n", fw_type_name); 1403 1407 return -EINVAL; 1404 1408 } 1405 1409 ··· 1418 1422 1419 1423 ret = qat_uclo_simg_alloc(handle, &img_desc, ICP_QAT_CSS_RSA4K_MAX_IMAGE_LEN); 1420 1424 if (ret) { 1421 - pr_err("QAT: error, allocate continuous dram fail\n"); 1425 + pr_err("error, allocate continuous dram fail\n"); 1422 1426 return ret; 1423 1427 } 1424 1428 1425 1429 if (!IS_ALIGNED(img_desc.dram_size, 8) || !img_desc.dram_bus_addr) { 1426 - pr_debug("QAT: invalid address\n"); 1430 + pr_debug("invalid address\n"); 1427 1431 qat_uclo_simg_free(handle, &img_desc); 1428 1432 return -EINVAL; 1429 1433 } ··· 1485 1489 auth_desc->img_len = size - ICP_QAT_AE_IMG_OFFSET(handle); 1486 1490 if (bus_addr + auth_desc->img_len > img_desc.dram_bus_addr + 1487 1491 ICP_QAT_CSS_RSA4K_MAX_IMAGE_LEN) { 1488 - pr_err("QAT: insufficient memory size for authentication data\n"); 1492 + pr_err("insufficient memory size for authentication data\n"); 1489 1493 qat_uclo_simg_free(handle, &img_desc); 1490 1494 return -ENOMEM; 1491 1495 } ··· 1542 1546 if (!((desc->ae_mask >> i) & 0x1)) 1543 1547 continue; 1544 1548 if (qat_hal_check_ae_active(handle, i)) { 1545 - pr_err("QAT: AE %d is active\n", i); 1549 + pr_err("AE %d is active\n", i); 1546 1550 return -EINVAL; 1547 1551 } 1548 1552 SET_CAP_CSR(handle, fcu_ctl_csr, ··· 1562 1566 } 1563 1567 } while (retry++ < FW_AUTH_MAX_RETRY); 1564 1568 if (retry > FW_AUTH_MAX_RETRY) { 1565 - pr_err("QAT: firmware load failed timeout %x\n", retry); 1569 + pr_err("firmware load failed timeout %x\n", retry); 1566 1570 return -EINVAL; 1567 1571 } 1568 1572 } ··· 1580 1584 handle->sobj_handle = suof_handle; 1581 1585 if (qat_uclo_map_suof(handle, addr_ptr, mem_size)) { 1582 1586 qat_uclo_del_suof(handle); 1583 - pr_err("QAT: map SUOF failed\n"); 1587 + pr_err("map SUOF failed\n"); 1584 1588 return -EINVAL; 1585 1589 } 1586 1590 return 0; ··· 1604 1608 qat_uclo_ummap_auth_fw(handle, &desc); 1605 1609 } else { 1606 1610 if (handle->chip_info->mmp_sram_size < mem_size) { 1607 - pr_err("QAT: MMP size is too large: 0x%x\n", mem_size); 1611 + pr_err("MMP size is too large: 0x%x\n", mem_size); 1608 1612 return -EFBIG; 1609 1613 } 1610 1614 qat_uclo_wr_sram_by_words(handle, 0, addr_ptr, mem_size); ··· 1630 1634 objhdl->obj_hdr = qat_uclo_map_chunk((char *)objhdl->obj_buf, filehdr, 1631 1635 ICP_QAT_UOF_OBJS); 1632 1636 if (!objhdl->obj_hdr) { 1633 - pr_err("QAT: object file chunk is null\n"); 1637 + pr_err("object file chunk is null\n"); 1634 1638 goto out_objhdr_err; 1635 1639 } 1636 1640 handle->obj_handle = objhdl; ··· 1665 1669 checksum = qat_uclo_calc_str_checksum(&mof_ptr->min_ver, 1666 1670 min_ver_offset); 1667 1671 if (checksum != mof_ptr->checksum) { 1668 - pr_err("QAT: incorrect MOF checksum\n"); 1672 + pr_err("incorrect MOF checksum\n"); 1669 1673 return -EINVAL; 1670 1674 } 1671 1675 ··· 1701 1705 } 1702 1706 } 1703 1707 1704 - pr_err("QAT: object %s is not found inside MOF\n", obj_name); 1708 + pr_err("object %s is not found inside MOF\n", obj_name); 1705 1709 return -EINVAL; 1706 1710 } 1707 1711 ··· 1718 1722 ICP_QAT_MOF_OBJ_CHUNKID_LEN)) { 1719 1723 obj = mobj_handle->sobjs_hdr + obj_chunkhdr->offset; 1720 1724 } else { 1721 - pr_err("QAT: unsupported chunk id\n"); 1725 + pr_err("unsupported chunk id\n"); 1722 1726 return -EINVAL; 1723 1727 } 1724 1728 mobj_hdr->obj_buf = obj; ··· 1779 1783 } 1780 1784 1781 1785 if ((uobj_chunk_num + sobj_chunk_num) != *valid_chunk) { 1782 - pr_err("QAT: inconsistent UOF/SUOF chunk amount\n"); 1786 + pr_err("inconsistent UOF/SUOF chunk amount\n"); 1783 1787 return -EINVAL; 1784 1788 } 1785 1789 return 0; ··· 1820 1824 int min = mof_hdr->min_ver & 0xff; 1821 1825 1822 1826 if (mof_hdr->file_id != ICP_QAT_MOF_FID) { 1823 - pr_err("QAT: invalid header 0x%x\n", mof_hdr->file_id); 1827 + pr_err("invalid header 0x%x\n", mof_hdr->file_id); 1824 1828 return -EINVAL; 1825 1829 } 1826 1830 1827 1831 if (mof_hdr->num_chunks <= 0x1) { 1828 - pr_err("QAT: MOF chunk amount is incorrect\n"); 1832 + pr_err("MOF chunk amount is incorrect\n"); 1829 1833 return -EINVAL; 1830 1834 } 1831 1835 if (maj != ICP_QAT_MOF_MAJVER || min != ICP_QAT_MOF_MINVER) { 1832 - pr_err("QAT: bad MOF version, major 0x%x, minor 0x%x\n", 1833 - maj, min); 1836 + pr_err("bad MOF version, major 0x%x, minor 0x%x\n", maj, min); 1834 1837 return -EINVAL; 1835 1838 } 1836 1839 return 0;

Configure Feed

Configure Feed