crypto: qat - reduce stack size with KASAN

Passing the register value by reference here leads a large amount of stack being
used when CONFIG_KASAN is enabled:

drivers/crypto/qat/qat_common/qat_hal.c: In function 'qat_hal_exec_micro_inst.constprop':
drivers/crypto/qat/qat_common/qat_hal.c:963:1: error: the frame size of 1792 bytes is larger than 1536 bytes [-Werror=frame-larger-than=]

Changing the register-read function to return the value instead reduces the stack
size to around 800 bytes, most of which is for the 'savuwords' array. The function
now no longer returns an error code, but nothing ever evaluated that anyway.

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/qat/qat_common/qat_hal.c b/drivers/crypto/qat/qat_common/qat_hal.c
index 8c4fd255a601b2d6c60e2300f5c878f8a512f57d..ff149e176f649344276e8fb91679d78b8368be11 100644 (file)
--- a/drivers/crypto/qat/qat_common/qat_hal.c
+++ b/drivers/crypto/qat/qat_common/qat_hal.c
@@ -117,19 +117,19 @@ void qat_hal_set_live_ctx(struct icp_qat_fw_loader_handle *handle,
 
 #define CSR_RETRY_TIMES 500
 static int qat_hal_rd_ae_csr(struct icp_qat_fw_loader_handle *handle,
-                            unsigned char ae, unsigned int csr,
-                            unsigned int *value)
+                            unsigned char ae, unsigned int csr)
 {
        unsigned int iterations = CSR_RETRY_TIMES;
+       int value;
 
        do {
-               *value = GET_AE_CSR(handle, ae, csr);
+               value = GET_AE_CSR(handle, ae, csr);
                if (!(GET_AE_CSR(handle, ae, LOCAL_CSR_STATUS) & LCS_STATUS))
-                       return 0;
+                       return value;
        } while (iterations--);
 
        pr_err("QAT: Read CSR timeout\n");
-       return -EFAULT;
+       return 0;
 }
 
 static int qat_hal_wr_ae_csr(struct icp_qat_fw_loader_handle *handle,
@@ -154,9 +154,9 @@ static void qat_hal_get_wakeup_event(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int cur_ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER, &cur_ctx);
+       cur_ctx = qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER);
        qat_hal_wr_ae_csr(handle, ae, CSR_CTX_POINTER, ctx);
-       qat_hal_rd_ae_csr(handle, ae, CTX_WAKEUP_EVENTS_INDIRECT, events);
+       *events = qat_hal_rd_ae_csr(handle, ae, CTX_WAKEUP_EVENTS_INDIRECT);
        qat_hal_wr_ae_csr(handle, ae, CSR_CTX_POINTER, cur_ctx);
 }
 
@@ -169,13 +169,13 @@ static int qat_hal_wait_cycles(struct icp_qat_fw_loader_handle *handle,
        int times = MAX_RETRY_TIMES;
        int elapsed_cycles = 0;
 
-       qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT, &base_cnt);
+       base_cnt = qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT);
        base_cnt &= 0xffff;
        while ((int)cycles > elapsed_cycles && times--) {
                if (chk_inactive)
-                       qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS, &csr);
+                       csr = qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS);
 
-               qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT, &cur_cnt);
+               cur_cnt = qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT);
                cur_cnt &= 0xffff;
                elapsed_cycles = cur_cnt - base_cnt;
 
@@ -207,7 +207,7 @@ int qat_hal_set_ae_ctx_mode(struct icp_qat_fw_loader_handle *handle,
        }
 
        /* Sets the accelaration engine context mode to either four or eight */
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &csr);
+       csr = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        csr = IGNORE_W1C_MASK & csr;
        new_csr = (mode == 4) ?
                SET_BIT(csr, CE_INUSE_CONTEXTS_BITPOS) :
@@ -221,7 +221,7 @@ int qat_hal_set_ae_nn_mode(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int csr, new_csr;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &csr);
+       csr = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        csr &= IGNORE_W1C_MASK;
 
        new_csr = (mode) ?
@@ -240,7 +240,7 @@ int qat_hal_set_ae_lm_mode(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int csr, new_csr;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &csr);
+       csr = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        csr &= IGNORE_W1C_MASK;
        switch (lm_type) {
        case ICP_LMEM0:
@@ -328,7 +328,7 @@ static void qat_hal_wr_indr_csr(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int ctx, cur_ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER, &cur_ctx);
+       cur_ctx = qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER);
 
        for (ctx = 0; ctx < ICP_QAT_UCLO_MAX_CTX; ctx++) {
                if (!(ctx_mask & (1 << ctx)))
@@ -340,16 +340,18 @@ static void qat_hal_wr_indr_csr(struct icp_qat_fw_loader_handle *handle,
        qat_hal_wr_ae_csr(handle, ae, CSR_CTX_POINTER, cur_ctx);
 }
 
-static void qat_hal_rd_indr_csr(struct icp_qat_fw_loader_handle *handle,
+static unsigned int qat_hal_rd_indr_csr(struct icp_qat_fw_loader_handle *handle,
                                unsigned char ae, unsigned char ctx,
-                               unsigned int ae_csr, unsigned int *csr_val)
+                               unsigned int ae_csr)
 {
-       unsigned int cur_ctx;
+       unsigned int cur_ctx, csr_val;
 
-       qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER, &cur_ctx);
+       cur_ctx = qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER);
        qat_hal_wr_ae_csr(handle, ae, CSR_CTX_POINTER, ctx);
-       qat_hal_rd_ae_csr(handle, ae, ae_csr, csr_val);
+       csr_val = qat_hal_rd_ae_csr(handle, ae, ae_csr);
        qat_hal_wr_ae_csr(handle, ae, CSR_CTX_POINTER, cur_ctx);
+
+       return csr_val;
 }
 
 static void qat_hal_put_sig_event(struct icp_qat_fw_loader_handle *handle,
@@ -358,7 +360,7 @@ static void qat_hal_put_sig_event(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int ctx, cur_ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER, &cur_ctx);
+       cur_ctx = qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER);
        for (ctx = 0; ctx < ICP_QAT_UCLO_MAX_CTX; ctx++) {
                if (!(ctx_mask & (1 << ctx)))
                        continue;
@@ -374,7 +376,7 @@ static void qat_hal_put_wakeup_event(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int ctx, cur_ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER, &cur_ctx);
+       cur_ctx = qat_hal_rd_ae_csr(handle, ae, CSR_CTX_POINTER);
        for (ctx = 0; ctx < ICP_QAT_UCLO_MAX_CTX; ctx++) {
                if (!(ctx_mask & (1 << ctx)))
                        continue;
@@ -392,13 +394,11 @@ static int qat_hal_check_ae_alive(struct icp_qat_fw_loader_handle *handle)
        int times = MAX_RETRY_TIMES;
 
        for (ae = 0; ae < handle->hal_handle->ae_max_num; ae++) {
-               qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT,
-                                 (unsigned int *)&base_cnt);
+               base_cnt = qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT);
                base_cnt &= 0xffff;
 
                do {
-                       qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT,
-                                         (unsigned int *)&cur_cnt);
+                       cur_cnt = qat_hal_rd_ae_csr(handle, ae, PROFILE_COUNT);
                        cur_cnt &= 0xffff;
                } while (times-- && (cur_cnt == base_cnt));
 
@@ -416,8 +416,8 @@ int qat_hal_check_ae_active(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int enable = 0, active = 0;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &enable);
-       qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS, &active);
+       enable = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
+       active = qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS);
        if ((enable & (0xff << CE_ENABLE_BITPOS)) ||
            (active & (1 << ACS_ABO_BITPOS)))
                return 1;
@@ -540,7 +540,7 @@ static void qat_hal_disable_ctx(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx);
+       ctx = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        ctx &= IGNORE_W1C_MASK &
                (~((ctx_mask & ICP_QAT_UCLO_AE_ALL_CTX) << CE_ENABLE_BITPOS));
        qat_hal_wr_ae_csr(handle, ae, CTX_ENABLES, ctx);
@@ -583,7 +583,7 @@ void qat_hal_wr_uwords(struct icp_qat_fw_loader_handle *handle,
        unsigned int ustore_addr;
        unsigned int i;
 
-       qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS, &ustore_addr);
+       ustore_addr = qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS);
        uaddr |= UA_ECS;
        qat_hal_wr_ae_csr(handle, ae, USTORE_ADDRESS, uaddr);
        for (i = 0; i < words_num; i++) {
@@ -604,7 +604,7 @@ static void qat_hal_enable_ctx(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int ctx;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx);
+       ctx = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        ctx &= IGNORE_W1C_MASK;
        ctx_mask &= (ctx & CE_INUSE_CONTEXTS) ? 0x55 : 0xFF;
        ctx |= (ctx_mask << CE_ENABLE_BITPOS);
@@ -636,10 +636,10 @@ static int qat_hal_clear_gpr(struct icp_qat_fw_loader_handle *handle)
        int ret = 0;
 
        for (ae = 0; ae < handle->hal_handle->ae_max_num; ae++) {
-               qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL, &csr_val);
+               csr_val = qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL);
                csr_val &= ~(1 << MMC_SHARE_CS_BITPOS);
                qat_hal_wr_ae_csr(handle, ae, AE_MISC_CONTROL, csr_val);
-               qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &csr_val);
+               csr_val = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
                csr_val &= IGNORE_W1C_MASK;
                csr_val |= CE_NN_MODE;
                qat_hal_wr_ae_csr(handle, ae, CTX_ENABLES, csr_val);
@@ -648,7 +648,7 @@ static int qat_hal_clear_gpr(struct icp_qat_fw_loader_handle *handle)
                qat_hal_wr_indr_csr(handle, ae, ctx_mask, CTX_STS_INDIRECT,
                                    handle->hal_handle->upc_mask &
                                    INIT_PC_VALUE);
-               qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS, &savctx);
+               savctx = qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS);
                qat_hal_wr_ae_csr(handle, ae, ACTIVE_CTX_STATUS, 0);
                qat_hal_put_wakeup_event(handle, ae, ctx_mask, XCWE_VOLUNTARY);
                qat_hal_wr_indr_csr(handle, ae, ctx_mask,
@@ -760,7 +760,7 @@ int qat_hal_init(struct adf_accel_dev *accel_dev)
        for (ae = 0; ae < handle->hal_handle->ae_max_num; ae++) {
                unsigned int csr_val = 0;
 
-               qat_hal_rd_ae_csr(handle, ae, SIGNATURE_ENABLE, &csr_val);
+               csr_val = qat_hal_rd_ae_csr(handle, ae, SIGNATURE_ENABLE);
                csr_val |= 0x1;
                qat_hal_wr_ae_csr(handle, ae, SIGNATURE_ENABLE, csr_val);
        }
@@ -826,16 +826,16 @@ static void qat_hal_get_uwords(struct icp_qat_fw_loader_handle *handle,
        unsigned int i, uwrd_lo, uwrd_hi;
        unsigned int ustore_addr, misc_control;
 
-       qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL, &misc_control);
+       misc_control = qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL);
        qat_hal_wr_ae_csr(handle, ae, AE_MISC_CONTROL,
                          misc_control & 0xfffffffb);
-       qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS, &ustore_addr);
+       ustore_addr = qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS);
        uaddr |= UA_ECS;
        for (i = 0; i < words_num; i++) {
                qat_hal_wr_ae_csr(handle, ae, USTORE_ADDRESS, uaddr);
                uaddr++;
-               qat_hal_rd_ae_csr(handle, ae, USTORE_DATA_LOWER, &uwrd_lo);
-               qat_hal_rd_ae_csr(handle, ae, USTORE_DATA_UPPER, &uwrd_hi);
+               uwrd_lo = qat_hal_rd_ae_csr(handle, ae, USTORE_DATA_LOWER);
+               uwrd_hi = qat_hal_rd_ae_csr(handle, ae, USTORE_DATA_UPPER);
                uword[i] = uwrd_hi;
                uword[i] = (uword[i] << 0x20) | uwrd_lo;
        }
@@ -849,7 +849,7 @@ void qat_hal_wr_umem(struct icp_qat_fw_loader_handle *handle,
 {
        unsigned int i, ustore_addr;
 
-       qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS, &ustore_addr);
+       ustore_addr = qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS);
        uaddr |= UA_ECS;
        qat_hal_wr_ae_csr(handle, ae, USTORE_ADDRESS, uaddr);
        for (i = 0; i < words_num; i++) {
@@ -890,26 +890,27 @@ static int qat_hal_exec_micro_inst(struct icp_qat_fw_loader_handle *handle,
                return -EINVAL;
        }
        /* save current context */
-       qat_hal_rd_indr_csr(handle, ae, ctx, LM_ADDR_0_INDIRECT, &ind_lm_addr0);
-       qat_hal_rd_indr_csr(handle, ae, ctx, LM_ADDR_1_INDIRECT, &ind_lm_addr1);
-       qat_hal_rd_indr_csr(handle, ae, ctx, INDIRECT_LM_ADDR_0_BYTE_INDEX,
-                           &ind_lm_addr_byte0);
-       qat_hal_rd_indr_csr(handle, ae, ctx, INDIRECT_LM_ADDR_1_BYTE_INDEX,
-                           &ind_lm_addr_byte1);
+       ind_lm_addr0 = qat_hal_rd_indr_csr(handle, ae, ctx, LM_ADDR_0_INDIRECT);
+       ind_lm_addr1 = qat_hal_rd_indr_csr(handle, ae, ctx, LM_ADDR_1_INDIRECT);
+       ind_lm_addr_byte0 = qat_hal_rd_indr_csr(handle, ae, ctx,
+                                               INDIRECT_LM_ADDR_0_BYTE_INDEX);
+       ind_lm_addr_byte1 = qat_hal_rd_indr_csr(handle, ae, ctx,
+                                               INDIRECT_LM_ADDR_1_BYTE_INDEX);
        if (inst_num <= MAX_EXEC_INST)
                qat_hal_get_uwords(handle, ae, 0, inst_num, savuwords);
        qat_hal_get_wakeup_event(handle, ae, ctx, &wakeup_events);
-       qat_hal_rd_indr_csr(handle, ae, ctx, CTX_STS_INDIRECT, &savpc);
+       savpc = qat_hal_rd_indr_csr(handle, ae, ctx, CTX_STS_INDIRECT);
        savpc = (savpc & handle->hal_handle->upc_mask) >> 0;
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        ctx_enables &= IGNORE_W1C_MASK;
-       qat_hal_rd_ae_csr(handle, ae, CC_ENABLE, &savcc);
-       qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS, &savctx);
-       qat_hal_rd_ae_csr(handle, ae, CTX_ARB_CNTL, &ctxarb_ctl);
-       qat_hal_rd_indr_csr(handle, ae, ctx, FUTURE_COUNT_SIGNAL_INDIRECT,
-                           &ind_cnt_sig);
-       qat_hal_rd_indr_csr(handle, ae, ctx, CTX_SIG_EVENTS_INDIRECT, &ind_sig);
-       qat_hal_rd_ae_csr(handle, ae, CTX_SIG_EVENTS_ACTIVE, &act_sig);
+       savcc = qat_hal_rd_ae_csr(handle, ae, CC_ENABLE);
+       savctx = qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS);
+       ctxarb_ctl = qat_hal_rd_ae_csr(handle, ae, CTX_ARB_CNTL);
+       ind_cnt_sig = qat_hal_rd_indr_csr(handle, ae, ctx,
+                                         FUTURE_COUNT_SIGNAL_INDIRECT);
+       ind_sig = qat_hal_rd_indr_csr(handle, ae, ctx,
+                                     CTX_SIG_EVENTS_INDIRECT);
+       act_sig = qat_hal_rd_ae_csr(handle, ae, CTX_SIG_EVENTS_ACTIVE);
        /* execute micro codes */
        qat_hal_wr_ae_csr(handle, ae, CTX_ENABLES, ctx_enables);
        qat_hal_wr_uwords(handle, ae, 0, inst_num, micro_inst);
@@ -927,8 +928,8 @@ static int qat_hal_exec_micro_inst(struct icp_qat_fw_loader_handle *handle,
        if (endpc) {
                unsigned int ctx_status;
 
-               qat_hal_rd_indr_csr(handle, ae, ctx, CTX_STS_INDIRECT,
-                                   &ctx_status);
+               ctx_status = qat_hal_rd_indr_csr(handle, ae, ctx,
+                                                CTX_STS_INDIRECT);
                *endpc = ctx_status & handle->hal_handle->upc_mask;
        }
        /* retore to saved context */
@@ -938,7 +939,7 @@ static int qat_hal_exec_micro_inst(struct icp_qat_fw_loader_handle *handle,
        qat_hal_put_wakeup_event(handle, ae, (1 << ctx), wakeup_events);
        qat_hal_wr_indr_csr(handle, ae, (1 << ctx), CTX_STS_INDIRECT,
                            handle->hal_handle->upc_mask & savpc);
-       qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL, &csr_val);
+       csr_val = qat_hal_rd_ae_csr(handle, ae, AE_MISC_CONTROL);
        newcsr_val = CLR_BIT(csr_val, MMC_SHARE_CS_BITPOS);
        qat_hal_wr_ae_csr(handle, ae, AE_MISC_CONTROL, newcsr_val);
        qat_hal_wr_ae_csr(handle, ae, CC_ENABLE, savcc);
@@ -986,16 +987,16 @@ static int qat_hal_rd_rel_reg(struct icp_qat_fw_loader_handle *handle,
                insts = (uint64_t)0xA030000000ull | ((reg_addr & 0x3ff) << 10);
                break;
        }
-       qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS, &savctx);
-       qat_hal_rd_ae_csr(handle, ae, CTX_ARB_CNTL, &ctxarb_cntl);
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       savctx = qat_hal_rd_ae_csr(handle, ae, ACTIVE_CTX_STATUS);
+       ctxarb_cntl = qat_hal_rd_ae_csr(handle, ae, CTX_ARB_CNTL);
+       ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        ctx_enables &= IGNORE_W1C_MASK;
        if (ctx != (savctx & ACS_ACNO))
                qat_hal_wr_ae_csr(handle, ae, ACTIVE_CTX_STATUS,
                                  ctx & ACS_ACNO);
        qat_hal_get_uwords(handle, ae, 0, 1, &savuword);
        qat_hal_wr_ae_csr(handle, ae, CTX_ENABLES, ctx_enables);
-       qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS, &ustore_addr);
+       ustore_addr = qat_hal_rd_ae_csr(handle, ae, USTORE_ADDRESS);
        uaddr = UA_ECS;
        qat_hal_wr_ae_csr(handle, ae, USTORE_ADDRESS, uaddr);
        insts = qat_hal_set_uword_ecc(insts);
@@ -1011,7 +1012,7 @@ static int qat_hal_rd_rel_reg(struct icp_qat_fw_loader_handle *handle,
         * the instruction should have been executed
         * prior to clearing the ECS in putUwords
         */
-       qat_hal_rd_ae_csr(handle, ae, ALU_OUT, data);
+       *data = qat_hal_rd_ae_csr(handle, ae, ALU_OUT);
        qat_hal_wr_ae_csr(handle, ae, USTORE_ADDRESS, ustore_addr);
        qat_hal_wr_uwords(handle, ae, 0, 1, &savuword);
        if (ctx != (savctx & ACS_ACNO))
@@ -1188,7 +1189,7 @@ static int qat_hal_put_rel_rd_xfer(struct icp_qat_fw_loader_handle *handle,
        unsigned short mask;
        unsigned short dr_offset = 0x10;
 
-       status = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       status = ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        if (CE_INUSE_CONTEXTS & ctx_enables) {
                if (ctx & 0x1) {
                        pr_err("QAT: bad 4-ctx mode,ctx=0x%x\n", ctx);
@@ -1238,7 +1239,7 @@ static int qat_hal_put_rel_wr_xfer(struct icp_qat_fw_loader_handle *handle,
        const int num_inst = ARRAY_SIZE(micro_inst), code_off = 1;
        const unsigned short gprnum = 0, dly = num_inst * 0x5;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        if (CE_INUSE_CONTEXTS & ctx_enables) {
                if (ctx & 0x1) {
                        pr_err("QAT: 4-ctx mode,ctx=0x%x\n", ctx);
@@ -1282,7 +1283,7 @@ static int qat_hal_put_rel_nn(struct icp_qat_fw_loader_handle *handle,
        unsigned int ctx_enables;
        int stat = 0;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        ctx_enables &= IGNORE_W1C_MASK;
        qat_hal_wr_ae_csr(handle, ae, CTX_ENABLES, ctx_enables | CE_NN_MODE);
 
@@ -1299,7 +1300,7 @@ static int qat_hal_convert_abs_to_rel(struct icp_qat_fw_loader_handle
 {
        unsigned int ctx_enables;
 
-       qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES, &ctx_enables);
+       ctx_enables = qat_hal_rd_ae_csr(handle, ae, CTX_ENABLES);
        if (ctx_enables & CE_INUSE_CONTEXTS) {
                /* 4-ctx mode */
                *relreg = absreg_num & 0x1F;