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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright(c) 2023 Intel Corporation */
   3 #include "adf_common_drv.h"
   4 #include "adf_gen4_hw_data.h"
   5 #include "adf_gen4_ras.h"
   6 #include "adf_sysfs_ras_counters.h"
   7
   8 #define BITS_PER_REG(_n_) (sizeof(_n_) * BITS_PER_BYTE)
   9
  10 static void enable_errsou_reporting(void __iomem *csr)
  11 {
  12         /* Enable correctable error reporting in ERRSOU0 */
  13         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK0, 0);
  14
  15         /* Enable uncorrectable error reporting in ERRSOU1 */
  16         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK1, 0);
  17
  18         /*
  19          * Enable uncorrectable error reporting in ERRSOU2
  20          * but disable PM interrupt and CFC attention interrupt by default
  21          */
  22         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK2,
  23                    ADF_GEN4_ERRSOU2_PM_INT_BIT |
  24                    ADF_GEN4_ERRSOU2_CPP_CFC_ATT_INT_BITMASK);
  25
  26         /*
  27          * Enable uncorrectable error reporting in ERRSOU3
  28          * but disable RLT error interrupt and VFLR notify interrupt by default
  29          */
  30         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK3,
  31                    ADF_GEN4_ERRSOU3_RLTERROR_BIT |
  32                    ADF_GEN4_ERRSOU3_VFLRNOTIFY_BIT);
  33 }
  34
  35 static void disable_errsou_reporting(void __iomem *csr)
  36 {
  37         u32 val = 0;
  38
  39         /* Disable correctable error reporting in ERRSOU0 */
  40         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK0, ADF_GEN4_ERRSOU0_BIT);
  41
  42         /* Disable uncorrectable error reporting in ERRSOU1 */
  43         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK1, ADF_GEN4_ERRSOU1_BITMASK);
  44
  45         /* Disable uncorrectable error reporting in ERRSOU2 */
  46         val = ADF_CSR_RD(csr, ADF_GEN4_ERRMSK2);
  47         val |= ADF_GEN4_ERRSOU2_DIS_BITMASK;
  48         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK2, val);
  49
  50         /* Disable uncorrectable error reporting in ERRSOU3 */
  51         ADF_CSR_WR(csr, ADF_GEN4_ERRMSK3, ADF_GEN4_ERRSOU3_BITMASK);
  52 }
  53
  54 static void enable_ae_error_reporting(struct adf_accel_dev *accel_dev,
  55                                       void __iomem *csr)
  56 {
  57         u32 ae_mask = GET_HW_DATA(accel_dev)->ae_mask;
  58
  59         /* Enable Acceleration Engine correctable error reporting */
  60         ADF_CSR_WR(csr, ADF_GEN4_HIAECORERRLOGENABLE_CPP0, ae_mask);
  61
  62         /* Enable Acceleration Engine uncorrectable error reporting */
  63         ADF_CSR_WR(csr, ADF_GEN4_HIAEUNCERRLOGENABLE_CPP0, ae_mask);
  64 }
  65
  66 static void disable_ae_error_reporting(void __iomem *csr)
  67 {
  68         /* Disable Acceleration Engine correctable error reporting */
  69         ADF_CSR_WR(csr, ADF_GEN4_HIAECORERRLOGENABLE_CPP0, 0);
  70
  71         /* Disable Acceleration Engine uncorrectable error reporting */
  72         ADF_CSR_WR(csr, ADF_GEN4_HIAEUNCERRLOGENABLE_CPP0, 0);
  73 }
  74
  75 static void enable_cpp_error_reporting(struct adf_accel_dev *accel_dev,
  76                                        void __iomem *csr)
  77 {
  78         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
  79
  80         /* Enable HI CPP Agents Command Parity Error Reporting */
  81         ADF_CSR_WR(csr, ADF_GEN4_HICPPAGENTCMDPARERRLOGENABLE,
  82                    err_mask->cppagentcmdpar_mask);
  83
  84         ADF_CSR_WR(csr, ADF_GEN4_CPP_CFC_ERR_CTRL,
  85                    ADF_GEN4_CPP_CFC_ERR_CTRL_BITMASK);
  86 }
  87
  88 static void disable_cpp_error_reporting(void __iomem *csr)
  89 {
  90         /* Disable HI CPP Agents Command Parity Error Reporting */
  91         ADF_CSR_WR(csr, ADF_GEN4_HICPPAGENTCMDPARERRLOGENABLE, 0);
  92
  93         ADF_CSR_WR(csr, ADF_GEN4_CPP_CFC_ERR_CTRL,
  94                    ADF_GEN4_CPP_CFC_ERR_CTRL_DIS_BITMASK);
  95 }
  96
  97 static void enable_ti_ri_error_reporting(void __iomem *csr)
  98 {
  99         u32 reg;
 100
 101         /* Enable RI Memory error reporting */
 102         ADF_CSR_WR(csr, ADF_GEN4_RI_MEM_PAR_ERR_EN0,
 103                    ADF_GEN4_RIMEM_PARERR_STS_FATAL_BITMASK |
 104                    ADF_GEN4_RIMEM_PARERR_STS_UNCERR_BITMASK);
 105
 106         /* Enable IOSF Primary Command Parity error Reporting */
 107         ADF_CSR_WR(csr, ADF_GEN4_RIMISCCTL, ADF_GEN4_RIMISCSTS_BIT);
 108
 109         /* Enable TI Internal Memory Parity Error reporting */
 110         ADF_CSR_WR(csr, ADF_GEN4_TI_CI_PAR_ERR_MASK, 0);
 111         ADF_CSR_WR(csr, ADF_GEN4_TI_PULL0FUB_PAR_ERR_MASK, 0);
 112         ADF_CSR_WR(csr, ADF_GEN4_TI_PUSHFUB_PAR_ERR_MASK, 0);
 113         ADF_CSR_WR(csr, ADF_GEN4_TI_CD_PAR_ERR_MASK, 0);
 114         ADF_CSR_WR(csr, ADF_GEN4_TI_TRNSB_PAR_ERR_MASK, 0);
 115
 116         /* Enable error handling in RI, TI CPP interface control registers */
 117         ADF_CSR_WR(csr, ADF_GEN4_RICPPINTCTL, ADF_GEN4_RICPPINTCTL_BITMASK);
 118
 119         ADF_CSR_WR(csr, ADF_GEN4_TICPPINTCTL, ADF_GEN4_TICPPINTCTL_BITMASK);
 120
 121         /*
 122          * Enable error detection and reporting in TIMISCSTS
 123          * with bits 1, 2 and 30 value preserved
 124          */
 125         reg = ADF_CSR_RD(csr, ADF_GEN4_TIMISCCTL);
 126         reg &= ADF_GEN4_TIMSCCTL_RELAY_BITMASK;
 127         reg |= ADF_GEN4_TIMISCCTL_BIT;
 128         ADF_CSR_WR(csr, ADF_GEN4_TIMISCCTL, reg);
 129 }
 130
 131 static void disable_ti_ri_error_reporting(void __iomem *csr)
 132 {
 133         u32 reg;
 134
 135         /* Disable RI Memory error reporting */
 136         ADF_CSR_WR(csr, ADF_GEN4_RI_MEM_PAR_ERR_EN0, 0);
 137
 138         /* Disable IOSF Primary Command Parity error Reporting */
 139         ADF_CSR_WR(csr, ADF_GEN4_RIMISCCTL, 0);
 140
 141         /* Disable TI Internal Memory Parity Error reporting */
 142         ADF_CSR_WR(csr, ADF_GEN4_TI_CI_PAR_ERR_MASK,
 143                    ADF_GEN4_TI_CI_PAR_STS_BITMASK);
 144         ADF_CSR_WR(csr, ADF_GEN4_TI_PULL0FUB_PAR_ERR_MASK,
 145                    ADF_GEN4_TI_PULL0FUB_PAR_STS_BITMASK);
 146         ADF_CSR_WR(csr, ADF_GEN4_TI_PUSHFUB_PAR_ERR_MASK,
 147                    ADF_GEN4_TI_PUSHFUB_PAR_STS_BITMASK);
 148         ADF_CSR_WR(csr, ADF_GEN4_TI_CD_PAR_ERR_MASK,
 149                    ADF_GEN4_TI_CD_PAR_STS_BITMASK);
 150         ADF_CSR_WR(csr, ADF_GEN4_TI_TRNSB_PAR_ERR_MASK,
 151                    ADF_GEN4_TI_TRNSB_PAR_STS_BITMASK);
 152
 153         /* Disable error handling in RI, TI CPP interface control registers */
 154         ADF_CSR_WR(csr, ADF_GEN4_RICPPINTCTL, 0);
 155
 156         ADF_CSR_WR(csr, ADF_GEN4_TICPPINTCTL, 0);
 157
 158         /*
 159          * Disable error detection and reporting in TIMISCSTS
 160          * with bits 1, 2 and 30 value preserved
 161          */
 162         reg = ADF_CSR_RD(csr, ADF_GEN4_TIMISCCTL);
 163         reg &= ADF_GEN4_TIMSCCTL_RELAY_BITMASK;
 164         ADF_CSR_WR(csr, ADF_GEN4_TIMISCCTL, reg);
 165 }
 166
 167 static void enable_rf_error_reporting(struct adf_accel_dev *accel_dev,
 168                                       void __iomem *csr)
 169 {
 170         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 171
 172         /* Enable RF parity error in Shared RAM */
 173         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_SRC, 0);
 174         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_ATH_CPH, 0);
 175         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_CPR_XLT, 0);
 176         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_DCPR_UCS, 0);
 177         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_PKE, 0);
 178
 179         if (err_mask->parerr_wat_wcp_mask)
 180                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_WAT_WCP, 0);
 181 }
 182
 183 static void disable_rf_error_reporting(struct adf_accel_dev *accel_dev,
 184                                        void __iomem *csr)
 185 {
 186         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 187
 188         /* Disable RF Parity Error reporting in Shared RAM */
 189         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_SRC,
 190                    ADF_GEN4_SSMSOFTERRORPARITY_SRC_BIT);
 191
 192         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_ATH_CPH,
 193                    err_mask->parerr_ath_cph_mask);
 194
 195         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_CPR_XLT,
 196                    err_mask->parerr_cpr_xlt_mask);
 197
 198         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_DCPR_UCS,
 199                    err_mask->parerr_dcpr_ucs_mask);
 200
 201         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_PKE,
 202                    err_mask->parerr_pke_mask);
 203
 204         if (err_mask->parerr_wat_wcp_mask)
 205                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITYMASK_WAT_WCP,
 206                            err_mask->parerr_wat_wcp_mask);
 207 }
 208
 209 static void enable_ssm_error_reporting(struct adf_accel_dev *accel_dev,
 210                                        void __iomem *csr)
 211 {
 212         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 213         u32 val = 0;
 214
 215         /* Enable SSM interrupts */
 216         ADF_CSR_WR(csr, ADF_GEN4_INTMASKSSM, 0);
 217
 218         /* Enable shared memory error detection & correction */
 219         val = ADF_CSR_RD(csr, ADF_GEN4_SSMFEATREN);
 220         val |= err_mask->ssmfeatren_mask;
 221         ADF_CSR_WR(csr, ADF_GEN4_SSMFEATREN, val);
 222
 223         /* Enable SER detection in SER_err_ssmsh register */
 224         ADF_CSR_WR(csr, ADF_GEN4_SER_EN_SSMSH,
 225                    ADF_GEN4_SER_EN_SSMSH_BITMASK);
 226
 227         /* Enable SSM soft parity error */
 228         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_ATH_CPH, 0);
 229         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_CPR_XLT, 0);
 230         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_DCPR_UCS, 0);
 231         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_PKE, 0);
 232
 233         if (err_mask->parerr_wat_wcp_mask)
 234                 ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_WAT_WCP, 0);
 235
 236         /* Enable slice hang interrupt reporting */
 237         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_ATH_CPH, 0);
 238         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_CPR_XLT, 0);
 239         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_DCPR_UCS, 0);
 240         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_PKE, 0);
 241
 242         if (err_mask->parerr_wat_wcp_mask)
 243                 ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_WAT_WCP, 0);
 244 }
 245
 246 static void disable_ssm_error_reporting(struct adf_accel_dev *accel_dev,
 247                                         void __iomem *csr)
 248 {
 249         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 250         u32 val = 0;
 251
 252         /* Disable SSM interrupts */
 253         ADF_CSR_WR(csr, ADF_GEN4_INTMASKSSM,
 254                    ADF_GEN4_INTMASKSSM_BITMASK);
 255
 256         /* Disable shared memory error detection & correction */
 257         val = ADF_CSR_RD(csr, ADF_GEN4_SSMFEATREN);
 258         val &= ADF_GEN4_SSMFEATREN_DIS_BITMASK;
 259         ADF_CSR_WR(csr, ADF_GEN4_SSMFEATREN, val);
 260
 261         /* Disable SER detection in SER_err_ssmsh register */
 262         ADF_CSR_WR(csr, ADF_GEN4_SER_EN_SSMSH, 0);
 263
 264         /* Disable SSM soft parity error */
 265         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_ATH_CPH,
 266                    err_mask->parerr_ath_cph_mask);
 267
 268         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_CPR_XLT,
 269                    err_mask->parerr_cpr_xlt_mask);
 270
 271         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_DCPR_UCS,
 272                    err_mask->parerr_dcpr_ucs_mask);
 273
 274         ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_PKE,
 275                    err_mask->parerr_pke_mask);
 276
 277         if (err_mask->parerr_wat_wcp_mask)
 278                 ADF_CSR_WR(csr, ADF_GEN4_SPPPARERRMSK_WAT_WCP,
 279                            err_mask->parerr_wat_wcp_mask);
 280
 281         /* Disable slice hang interrupt reporting */
 282         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_ATH_CPH,
 283                    err_mask->parerr_ath_cph_mask);
 284
 285         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_CPR_XLT,
 286                    err_mask->parerr_cpr_xlt_mask);
 287
 288         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_DCPR_UCS,
 289                    err_mask->parerr_dcpr_ucs_mask);
 290
 291         ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_PKE,
 292                    err_mask->parerr_pke_mask);
 293
 294         if (err_mask->parerr_wat_wcp_mask)
 295                 ADF_CSR_WR(csr, ADF_GEN4_SHINTMASKSSM_WAT_WCP,
 296                            err_mask->parerr_wat_wcp_mask);
 297 }
 298
 299 static void enable_aram_error_reporting(void __iomem *csr)
 300 {
 301         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMCERRUERR_EN,
 302                    ADF_GEN4_REG_ARAMCERRUERR_EN_BITMASK);
 303
 304         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMCERR,
 305                    ADF_GEN4_REG_ARAMCERR_EN_BITMASK);
 306
 307         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMUERR,
 308                    ADF_GEN4_REG_ARAMUERR_EN_BITMASK);
 309
 310         ADF_CSR_WR(csr, ADF_GEN4_REG_CPPMEMTGTERR,
 311                    ADF_GEN4_REG_CPPMEMTGTERR_EN_BITMASK);
 312 }
 313
 314 static void disable_aram_error_reporting(void __iomem *csr)
 315 {
 316         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMCERRUERR_EN, 0);
 317         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMCERR, 0);
 318         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMUERR, 0);
 319         ADF_CSR_WR(csr, ADF_GEN4_REG_CPPMEMTGTERR, 0);
 320 }
 321
 322 static void adf_gen4_enable_ras(struct adf_accel_dev *accel_dev)
 323 {
 324         void __iomem *aram_csr = adf_get_aram_base(accel_dev);
 325         void __iomem *csr = adf_get_pmisc_base(accel_dev);
 326
 327         enable_errsou_reporting(csr);
 328         enable_ae_error_reporting(accel_dev, csr);
 329         enable_cpp_error_reporting(accel_dev, csr);
 330         enable_ti_ri_error_reporting(csr);
 331         enable_rf_error_reporting(accel_dev, csr);
 332         enable_ssm_error_reporting(accel_dev, csr);
 333         enable_aram_error_reporting(aram_csr);
 334 }
 335
 336 static void adf_gen4_disable_ras(struct adf_accel_dev *accel_dev)
 337 {
 338         void __iomem *aram_csr = adf_get_aram_base(accel_dev);
 339         void __iomem *csr = adf_get_pmisc_base(accel_dev);
 340
 341         disable_errsou_reporting(csr);
 342         disable_ae_error_reporting(csr);
 343         disable_cpp_error_reporting(csr);
 344         disable_ti_ri_error_reporting(csr);
 345         disable_rf_error_reporting(accel_dev, csr);
 346         disable_ssm_error_reporting(accel_dev, csr);
 347         disable_aram_error_reporting(aram_csr);
 348 }
 349
 350 static void adf_gen4_process_errsou0(struct adf_accel_dev *accel_dev,
 351                                      void __iomem *csr)
 352 {
 353         u32 aecorrerr = ADF_CSR_RD(csr, ADF_GEN4_HIAECORERRLOG_CPP0);
 354
 355         aecorrerr &= GET_HW_DATA(accel_dev)->ae_mask;
 356
 357         dev_warn(&GET_DEV(accel_dev),
 358                  "Correctable error detected in AE: 0x%x\n",
 359                  aecorrerr);
 360
 361         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
 362
 363         /* Clear interrupt from ERRSOU0 */
 364         ADF_CSR_WR(csr, ADF_GEN4_HIAECORERRLOG_CPP0, aecorrerr);
 365 }
 366
 367 static bool adf_handle_cpp_aeunc(struct adf_accel_dev *accel_dev,
 368                                  void __iomem *csr, u32 errsou)
 369 {
 370         u32 aeuncorerr;
 371
 372         if (!(errsou & ADF_GEN4_ERRSOU1_HIAEUNCERRLOG_CPP0_BIT))
 373                 return false;
 374
 375         aeuncorerr = ADF_CSR_RD(csr, ADF_GEN4_HIAEUNCERRLOG_CPP0);
 376         aeuncorerr &= GET_HW_DATA(accel_dev)->ae_mask;
 377
 378         dev_err(&GET_DEV(accel_dev),
 379                 "Uncorrectable error detected in AE: 0x%x\n",
 380                 aeuncorerr);
 381
 382         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 383
 384         ADF_CSR_WR(csr, ADF_GEN4_HIAEUNCERRLOG_CPP0, aeuncorerr);
 385
 386         return false;
 387 }
 388
 389 static bool adf_handle_cppcmdparerr(struct adf_accel_dev *accel_dev,
 390                                     void __iomem *csr, u32 errsou)
 391 {
 392         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 393         u32 cmdparerr;
 394
 395         if (!(errsou & ADF_GEN4_ERRSOU1_HICPPAGENTCMDPARERRLOG_BIT))
 396                 return false;
 397
 398         cmdparerr = ADF_CSR_RD(csr, ADF_GEN4_HICPPAGENTCMDPARERRLOG);
 399         cmdparerr &= err_mask->cppagentcmdpar_mask;
 400
 401         dev_err(&GET_DEV(accel_dev),
 402                 "HI CPP agent command parity error: 0x%x\n",
 403                 cmdparerr);
 404
 405         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 406
 407         ADF_CSR_WR(csr, ADF_GEN4_HICPPAGENTCMDPARERRLOG, cmdparerr);
 408
 409         return true;
 410 }
 411
 412 static bool adf_handle_ri_mem_par_err(struct adf_accel_dev *accel_dev,
 413                                       void __iomem *csr, u32 errsou)
 414 {
 415         bool reset_required = false;
 416         u32 rimem_parerr_sts;
 417
 418         if (!(errsou & ADF_GEN4_ERRSOU1_RIMEM_PARERR_STS_BIT))
 419                 return false;
 420
 421         rimem_parerr_sts = ADF_CSR_RD(csr, ADF_GEN4_RIMEM_PARERR_STS);
 422         rimem_parerr_sts &= ADF_GEN4_RIMEM_PARERR_STS_UNCERR_BITMASK |
 423                             ADF_GEN4_RIMEM_PARERR_STS_FATAL_BITMASK;
 424
 425         if (rimem_parerr_sts & ADF_GEN4_RIMEM_PARERR_STS_UNCERR_BITMASK) {
 426                 dev_err(&GET_DEV(accel_dev),
 427                         "RI Memory Parity uncorrectable error: 0x%x\n",
 428                         rimem_parerr_sts);
 429                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 430         }
 431
 432         if (rimem_parerr_sts & ADF_GEN4_RIMEM_PARERR_STS_FATAL_BITMASK) {
 433                 dev_err(&GET_DEV(accel_dev),
 434                         "RI Memory Parity fatal error: 0x%x\n",
 435                         rimem_parerr_sts);
 436                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 437                 reset_required = true;
 438         }
 439
 440         ADF_CSR_WR(csr, ADF_GEN4_RIMEM_PARERR_STS, rimem_parerr_sts);
 441
 442         return reset_required;
 443 }
 444
 445 static bool adf_handle_ti_ci_par_sts(struct adf_accel_dev *accel_dev,
 446                                      void __iomem *csr, u32 errsou)
 447 {
 448         u32 ti_ci_par_sts;
 449
 450         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 451                 return false;
 452
 453         ti_ci_par_sts = ADF_CSR_RD(csr, ADF_GEN4_TI_CI_PAR_STS);
 454         ti_ci_par_sts &= ADF_GEN4_TI_CI_PAR_STS_BITMASK;
 455
 456         if (ti_ci_par_sts) {
 457                 dev_err(&GET_DEV(accel_dev),
 458                         "TI Memory Parity Error: 0x%x\n", ti_ci_par_sts);
 459                 ADF_CSR_WR(csr, ADF_GEN4_TI_CI_PAR_STS, ti_ci_par_sts);
 460                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 461         }
 462
 463         return false;
 464 }
 465
 466 static bool adf_handle_ti_pullfub_par_sts(struct adf_accel_dev *accel_dev,
 467                                           void __iomem *csr, u32 errsou)
 468 {
 469         u32 ti_pullfub_par_sts;
 470
 471         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 472                 return false;
 473
 474         ti_pullfub_par_sts = ADF_CSR_RD(csr, ADF_GEN4_TI_PULL0FUB_PAR_STS);
 475         ti_pullfub_par_sts &= ADF_GEN4_TI_PULL0FUB_PAR_STS_BITMASK;
 476
 477         if (ti_pullfub_par_sts) {
 478                 dev_err(&GET_DEV(accel_dev),
 479                         "TI Pull Parity Error: 0x%x\n", ti_pullfub_par_sts);
 480
 481                 ADF_CSR_WR(csr, ADF_GEN4_TI_PULL0FUB_PAR_STS,
 482                            ti_pullfub_par_sts);
 483
 484                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 485         }
 486
 487         return false;
 488 }
 489
 490 static bool adf_handle_ti_pushfub_par_sts(struct adf_accel_dev *accel_dev,
 491                                           void __iomem *csr, u32 errsou)
 492 {
 493         u32 ti_pushfub_par_sts;
 494
 495         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 496                 return false;
 497
 498         ti_pushfub_par_sts = ADF_CSR_RD(csr, ADF_GEN4_TI_PUSHFUB_PAR_STS);
 499         ti_pushfub_par_sts &= ADF_GEN4_TI_PUSHFUB_PAR_STS_BITMASK;
 500
 501         if (ti_pushfub_par_sts) {
 502                 dev_err(&GET_DEV(accel_dev),
 503                         "TI Push Parity Error: 0x%x\n", ti_pushfub_par_sts);
 504
 505                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 506
 507                 ADF_CSR_WR(csr, ADF_GEN4_TI_PUSHFUB_PAR_STS,
 508                            ti_pushfub_par_sts);
 509         }
 510
 511         return false;
 512 }
 513
 514 static bool adf_handle_ti_cd_par_sts(struct adf_accel_dev *accel_dev,
 515                                      void __iomem *csr, u32 errsou)
 516 {
 517         u32 ti_cd_par_sts;
 518
 519         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 520                 return false;
 521
 522         ti_cd_par_sts = ADF_CSR_RD(csr, ADF_GEN4_TI_CD_PAR_STS);
 523         ti_cd_par_sts &= ADF_GEN4_TI_CD_PAR_STS_BITMASK;
 524
 525         if (ti_cd_par_sts) {
 526                 dev_err(&GET_DEV(accel_dev),
 527                         "TI CD Parity Error: 0x%x\n", ti_cd_par_sts);
 528
 529                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 530
 531                 ADF_CSR_WR(csr, ADF_GEN4_TI_CD_PAR_STS, ti_cd_par_sts);
 532         }
 533
 534         return false;
 535 }
 536
 537 static bool adf_handle_ti_trnsb_par_sts(struct adf_accel_dev *accel_dev,
 538                                         void __iomem *csr, u32 errsou)
 539 {
 540         u32 ti_trnsb_par_sts;
 541
 542         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 543                 return false;
 544
 545         ti_trnsb_par_sts = ADF_CSR_RD(csr, ADF_GEN4_TI_TRNSB_PAR_STS);
 546         ti_trnsb_par_sts &= ADF_GEN4_TI_TRNSB_PAR_STS_BITMASK;
 547
 548         if (ti_trnsb_par_sts) {
 549                 dev_err(&GET_DEV(accel_dev),
 550                         "TI TRNSB Parity Error: 0x%x\n", ti_trnsb_par_sts);
 551
 552                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 553
 554                 ADF_CSR_WR(csr, ADF_GEN4_TI_TRNSB_PAR_STS, ti_trnsb_par_sts);
 555         }
 556
 557         return false;
 558 }
 559
 560 static bool adf_handle_iosfp_cmd_parerr(struct adf_accel_dev *accel_dev,
 561                                         void __iomem *csr, u32 errsou)
 562 {
 563         u32 rimiscsts;
 564
 565         if (!(errsou & ADF_GEN4_ERRSOU1_TIMEM_PARERR_STS_BIT))
 566                 return false;
 567
 568         rimiscsts = ADF_CSR_RD(csr, ADF_GEN4_RIMISCSTS);
 569         rimiscsts &= ADF_GEN4_RIMISCSTS_BIT;
 570
 571         dev_err(&GET_DEV(accel_dev),
 572                 "Command Parity error detected on IOSFP: 0x%x\n",
 573                 rimiscsts);
 574
 575         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 576
 577         ADF_CSR_WR(csr, ADF_GEN4_RIMISCSTS, rimiscsts);
 578
 579         return true;
 580 }
 581
 582 static void adf_gen4_process_errsou1(struct adf_accel_dev *accel_dev,
 583                                      void __iomem *csr, u32 errsou,
 584                                      bool *reset_required)
 585 {
 586         *reset_required |= adf_handle_cpp_aeunc(accel_dev, csr, errsou);
 587         *reset_required |= adf_handle_cppcmdparerr(accel_dev, csr, errsou);
 588         *reset_required |= adf_handle_ri_mem_par_err(accel_dev, csr, errsou);
 589         *reset_required |= adf_handle_ti_ci_par_sts(accel_dev, csr, errsou);
 590         *reset_required |= adf_handle_ti_pullfub_par_sts(accel_dev, csr, errsou);
 591         *reset_required |= adf_handle_ti_pushfub_par_sts(accel_dev, csr, errsou);
 592         *reset_required |= adf_handle_ti_cd_par_sts(accel_dev, csr, errsou);
 593         *reset_required |= adf_handle_ti_trnsb_par_sts(accel_dev, csr, errsou);
 594         *reset_required |= adf_handle_iosfp_cmd_parerr(accel_dev, csr, errsou);
 595 }
 596
 597 static bool adf_handle_uerrssmsh(struct adf_accel_dev *accel_dev,
 598                                  void __iomem *csr, u32 iastatssm)
 599 {
 600         u32 reg;
 601
 602         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_UERRSSMSH_BIT))
 603                 return false;
 604
 605         reg = ADF_CSR_RD(csr, ADF_GEN4_UERRSSMSH);
 606         reg &= ADF_GEN4_UERRSSMSH_BITMASK;
 607
 608         dev_err(&GET_DEV(accel_dev),
 609                 "Uncorrectable error on ssm shared memory: 0x%x\n",
 610                 reg);
 611
 612         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 613
 614         ADF_CSR_WR(csr, ADF_GEN4_UERRSSMSH, reg);
 615
 616         return false;
 617 }
 618
 619 static bool adf_handle_cerrssmsh(struct adf_accel_dev *accel_dev,
 620                                  void __iomem *csr, u32 iastatssm)
 621 {
 622         u32 reg;
 623
 624         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_CERRSSMSH_BIT))
 625                 return false;
 626
 627         reg = ADF_CSR_RD(csr, ADF_GEN4_CERRSSMSH);
 628         reg &= ADF_GEN4_CERRSSMSH_ERROR_BIT;
 629
 630         dev_warn(&GET_DEV(accel_dev),
 631                  "Correctable error on ssm shared memory: 0x%x\n",
 632                  reg);
 633
 634         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
 635
 636         ADF_CSR_WR(csr, ADF_GEN4_CERRSSMSH, reg);
 637
 638         return false;
 639 }
 640
 641 static bool adf_handle_pperr_err(struct adf_accel_dev *accel_dev,
 642                                  void __iomem *csr, u32 iastatssm)
 643 {
 644         u32 reg;
 645
 646         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_PPERR_BIT))
 647                 return false;
 648
 649         reg = ADF_CSR_RD(csr, ADF_GEN4_PPERR);
 650         reg &= ADF_GEN4_PPERR_BITMASK;
 651
 652         dev_err(&GET_DEV(accel_dev),
 653                 "Uncorrectable error CPP transaction on memory target: 0x%x\n",
 654                 reg);
 655
 656         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 657
 658         ADF_CSR_WR(csr, ADF_GEN4_PPERR, reg);
 659
 660         return false;
 661 }
 662
 663 static void adf_poll_slicehang_csr(struct adf_accel_dev *accel_dev,
 664                                    void __iomem *csr, u32 slice_hang_offset,
 665                                    char *slice_name)
 666 {
 667         u32 slice_hang_reg = ADF_CSR_RD(csr, slice_hang_offset);
 668
 669         if (!slice_hang_reg)
 670                 return;
 671
 672         dev_err(&GET_DEV(accel_dev),
 673                 "Slice %s hang error encountered\n", slice_name);
 674
 675         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 676 }
 677
 678 static bool adf_handle_slice_hang_error(struct adf_accel_dev *accel_dev,
 679                                         void __iomem *csr, u32 iastatssm)
 680 {
 681         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 682
 683         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_SLICEHANG_ERR_BIT))
 684                 return false;
 685
 686         adf_poll_slicehang_csr(accel_dev, csr,
 687                                ADF_GEN4_SLICEHANGSTATUS_ATH_CPH, "ath_cph");
 688         adf_poll_slicehang_csr(accel_dev, csr,
 689                                ADF_GEN4_SLICEHANGSTATUS_CPR_XLT, "cpr_xlt");
 690         adf_poll_slicehang_csr(accel_dev, csr,
 691                                ADF_GEN4_SLICEHANGSTATUS_DCPR_UCS, "dcpr_ucs");
 692         adf_poll_slicehang_csr(accel_dev, csr,
 693                                ADF_GEN4_SLICEHANGSTATUS_PKE, "pke");
 694
 695         if (err_mask->parerr_wat_wcp_mask)
 696                 adf_poll_slicehang_csr(accel_dev, csr,
 697                                        ADF_GEN4_SLICEHANGSTATUS_WAT_WCP,
 698                                        "ath_cph");
 699
 700         return false;
 701 }
 702
 703 static bool adf_handle_spp_pullcmd_err(struct adf_accel_dev *accel_dev,
 704                                        void __iomem *csr)
 705 {
 706         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 707         bool reset_required = false;
 708         u32 reg;
 709
 710         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLCMDPARERR_ATH_CPH);
 711         reg &= err_mask->parerr_ath_cph_mask;
 712         if (reg) {
 713                 dev_err(&GET_DEV(accel_dev),
 714                         "SPP pull command fatal error ATH_CPH: 0x%x\n", reg);
 715
 716                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 717
 718                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLCMDPARERR_ATH_CPH, reg);
 719
 720                 reset_required = true;
 721         }
 722
 723         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLCMDPARERR_CPR_XLT);
 724         reg &= err_mask->parerr_cpr_xlt_mask;
 725         if (reg) {
 726                 dev_err(&GET_DEV(accel_dev),
 727                         "SPP pull command fatal error CPR_XLT: 0x%x\n", reg);
 728
 729                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 730
 731                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLCMDPARERR_CPR_XLT, reg);
 732
 733                 reset_required = true;
 734         }
 735
 736         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLCMDPARERR_DCPR_UCS);
 737         reg &= err_mask->parerr_dcpr_ucs_mask;
 738         if (reg) {
 739                 dev_err(&GET_DEV(accel_dev),
 740                         "SPP pull command fatal error DCPR_UCS: 0x%x\n", reg);
 741
 742                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 743
 744                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLCMDPARERR_DCPR_UCS, reg);
 745
 746                 reset_required = true;
 747         }
 748
 749         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLCMDPARERR_PKE);
 750         reg &= err_mask->parerr_pke_mask;
 751         if (reg) {
 752                 dev_err(&GET_DEV(accel_dev),
 753                         "SPP pull command fatal error PKE: 0x%x\n", reg);
 754
 755                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 756
 757                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLCMDPARERR_PKE, reg);
 758
 759                 reset_required = true;
 760         }
 761
 762         if (err_mask->parerr_wat_wcp_mask) {
 763                 reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLCMDPARERR_WAT_WCP);
 764                 reg &= err_mask->parerr_wat_wcp_mask;
 765                 if (reg) {
 766                         dev_err(&GET_DEV(accel_dev),
 767                                 "SPP pull command fatal error WAT_WCP: 0x%x\n", reg);
 768
 769                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 770
 771                         ADF_CSR_WR(csr, ADF_GEN4_SPPPULLCMDPARERR_WAT_WCP, reg);
 772
 773                         reset_required = true;
 774                 }
 775         }
 776
 777         return reset_required;
 778 }
 779
 780 static bool adf_handle_spp_pulldata_err(struct adf_accel_dev *accel_dev,
 781                                         void __iomem *csr)
 782 {
 783         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 784         u32 reg;
 785
 786         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLDATAPARERR_ATH_CPH);
 787         reg &= err_mask->parerr_ath_cph_mask;
 788         if (reg) {
 789                 dev_err(&GET_DEV(accel_dev),
 790                         "SPP pull data err ATH_CPH: 0x%x\n", reg);
 791
 792                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 793
 794                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLDATAPARERR_ATH_CPH, reg);
 795         }
 796
 797         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLDATAPARERR_CPR_XLT);
 798         reg &= err_mask->parerr_cpr_xlt_mask;
 799         if (reg) {
 800                 dev_err(&GET_DEV(accel_dev),
 801                         "SPP pull data err CPR_XLT: 0x%x\n", reg);
 802
 803                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 804
 805                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLDATAPARERR_CPR_XLT, reg);
 806         }
 807
 808         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLDATAPARERR_DCPR_UCS);
 809         reg &= err_mask->parerr_dcpr_ucs_mask;
 810         if (reg) {
 811                 dev_err(&GET_DEV(accel_dev),
 812                         "SPP pull data err DCPR_UCS: 0x%x\n", reg);
 813
 814                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 815
 816                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLDATAPARERR_DCPR_UCS, reg);
 817         }
 818
 819         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLDATAPARERR_PKE);
 820         reg &= err_mask->parerr_pke_mask;
 821         if (reg) {
 822                 dev_err(&GET_DEV(accel_dev),
 823                         "SPP pull data err PKE: 0x%x\n", reg);
 824
 825                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 826
 827                 ADF_CSR_WR(csr, ADF_GEN4_SPPPULLDATAPARERR_PKE, reg);
 828         }
 829
 830         if (err_mask->parerr_wat_wcp_mask) {
 831                 reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPULLDATAPARERR_WAT_WCP);
 832                 reg &= err_mask->parerr_wat_wcp_mask;
 833                 if (reg) {
 834                         dev_err(&GET_DEV(accel_dev),
 835                                 "SPP pull data err WAT_WCP: 0x%x\n", reg);
 836
 837                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 838
 839                         ADF_CSR_WR(csr, ADF_GEN4_SPPPULLDATAPARERR_WAT_WCP, reg);
 840                 }
 841         }
 842
 843         return false;
 844 }
 845
 846 static bool adf_handle_spp_pushcmd_err(struct adf_accel_dev *accel_dev,
 847                                        void __iomem *csr)
 848 {
 849         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 850         bool reset_required = false;
 851         u32 reg;
 852
 853         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHCMDPARERR_ATH_CPH);
 854         reg &= err_mask->parerr_ath_cph_mask;
 855         if (reg) {
 856                 dev_err(&GET_DEV(accel_dev),
 857                         "SPP push command fatal error ATH_CPH: 0x%x\n", reg);
 858
 859                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 860
 861                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHCMDPARERR_ATH_CPH, reg);
 862
 863                 reset_required = true;
 864         }
 865
 866         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHCMDPARERR_CPR_XLT);
 867         reg &= err_mask->parerr_cpr_xlt_mask;
 868         if (reg) {
 869                 dev_err(&GET_DEV(accel_dev),
 870                         "SPP push command fatal error CPR_XLT: 0x%x\n", reg);
 871
 872                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 873
 874                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHCMDPARERR_CPR_XLT, reg);
 875
 876                 reset_required = true;
 877         }
 878
 879         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHCMDPARERR_DCPR_UCS);
 880         reg &= err_mask->parerr_dcpr_ucs_mask;
 881         if (reg) {
 882                 dev_err(&GET_DEV(accel_dev),
 883                         "SPP push command fatal error DCPR_UCS: 0x%x\n", reg);
 884
 885                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 886
 887                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHCMDPARERR_DCPR_UCS, reg);
 888
 889                 reset_required = true;
 890         }
 891
 892         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHCMDPARERR_PKE);
 893         reg &= err_mask->parerr_pke_mask;
 894         if (reg) {
 895                 dev_err(&GET_DEV(accel_dev),
 896                         "SPP push command fatal error PKE: 0x%x\n",
 897                         reg);
 898
 899                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 900
 901                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHCMDPARERR_PKE, reg);
 902
 903                 reset_required = true;
 904         }
 905
 906         if (err_mask->parerr_wat_wcp_mask) {
 907                 reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHCMDPARERR_WAT_WCP);
 908                 reg &= err_mask->parerr_wat_wcp_mask;
 909                 if (reg) {
 910                         dev_err(&GET_DEV(accel_dev),
 911                                 "SPP push command fatal error WAT_WCP: 0x%x\n", reg);
 912
 913                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
 914
 915                         ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHCMDPARERR_WAT_WCP, reg);
 916
 917                         reset_required = true;
 918                 }
 919         }
 920
 921         return reset_required;
 922 }
 923
 924 static bool adf_handle_spp_pushdata_err(struct adf_accel_dev *accel_dev,
 925                                         void __iomem *csr)
 926 {
 927         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
 928         u32 reg;
 929
 930         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHDATAPARERR_ATH_CPH);
 931         reg &= err_mask->parerr_ath_cph_mask;
 932         if (reg) {
 933                 dev_err(&GET_DEV(accel_dev),
 934                         "SPP push data err ATH_CPH: 0x%x\n", reg);
 935
 936                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 937
 938                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHDATAPARERR_ATH_CPH, reg);
 939         }
 940
 941         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHDATAPARERR_CPR_XLT);
 942         reg &= err_mask->parerr_cpr_xlt_mask;
 943         if (reg) {
 944                 dev_err(&GET_DEV(accel_dev),
 945                         "SPP push data err CPR_XLT: 0x%x\n", reg);
 946
 947                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 948
 949                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHDATAPARERR_CPR_XLT, reg);
 950         }
 951
 952         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHDATAPARERR_DCPR_UCS);
 953         reg &= err_mask->parerr_dcpr_ucs_mask;
 954         if (reg) {
 955                 dev_err(&GET_DEV(accel_dev),
 956                         "SPP push data err DCPR_UCS: 0x%x\n", reg);
 957
 958                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 959
 960                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHDATAPARERR_DCPR_UCS, reg);
 961         }
 962
 963         reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHDATAPARERR_PKE);
 964         reg &= err_mask->parerr_pke_mask;
 965         if (reg) {
 966                 dev_err(&GET_DEV(accel_dev),
 967                         "SPP push data err PKE: 0x%x\n", reg);
 968
 969                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 970
 971                 ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHDATAPARERR_PKE, reg);
 972         }
 973
 974         if (err_mask->parerr_wat_wcp_mask) {
 975                 reg = ADF_CSR_RD(csr, ADF_GEN4_SPPPUSHDATAPARERR_WAT_WCP);
 976                 reg &= err_mask->parerr_wat_wcp_mask;
 977                 if (reg) {
 978                         dev_err(&GET_DEV(accel_dev),
 979                                 "SPP push data err WAT_WCP: 0x%x\n", reg);
 980
 981                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
 982
 983                         ADF_CSR_WR(csr, ADF_GEN4_SPPPUSHDATAPARERR_WAT_WCP,
 984                                    reg);
 985                 }
 986         }
 987
 988         return false;
 989 }
 990
 991 static bool adf_handle_spppar_err(struct adf_accel_dev *accel_dev,
 992                                   void __iomem *csr, u32 iastatssm)
 993 {
 994         bool reset_required;
 995
 996         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_SPPPARERR_BIT))
 997                 return false;
 998
 999         reset_required = adf_handle_spp_pullcmd_err(accel_dev, csr);
1000         reset_required |= adf_handle_spp_pulldata_err(accel_dev, csr);
1001         reset_required |= adf_handle_spp_pushcmd_err(accel_dev, csr);
1002         reset_required |= adf_handle_spp_pushdata_err(accel_dev, csr);
1003
1004         return reset_required;
1005 }
1006
1007 static bool adf_handle_ssmcpppar_err(struct adf_accel_dev *accel_dev,
1008                                      void __iomem *csr, u32 iastatssm)
1009 {
1010         u32 reg, bits_num = BITS_PER_REG(reg);
1011         bool reset_required = false;
1012         unsigned long errs_bits;
1013         u32 bit_iterator;
1014
1015         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_SSMCPPERR_BIT))
1016                 return false;
1017
1018         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMCPPERR);
1019         reg &= ADF_GEN4_SSMCPPERR_FATAL_BITMASK | ADF_GEN4_SSMCPPERR_UNCERR_BITMASK;
1020         if (reg & ADF_GEN4_SSMCPPERR_FATAL_BITMASK) {
1021                 dev_err(&GET_DEV(accel_dev),
1022                         "Fatal SSM CPP parity error: 0x%x\n", reg);
1023
1024                 errs_bits = reg & ADF_GEN4_SSMCPPERR_FATAL_BITMASK;
1025                 for_each_set_bit(bit_iterator, &errs_bits, bits_num) {
1026                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1027                 }
1028                 reset_required = true;
1029         }
1030
1031         if (reg & ADF_GEN4_SSMCPPERR_UNCERR_BITMASK) {
1032                 dev_err(&GET_DEV(accel_dev),
1033                         "non-Fatal SSM CPP parity error: 0x%x\n", reg);
1034                 errs_bits = reg & ADF_GEN4_SSMCPPERR_UNCERR_BITMASK;
1035
1036                 for_each_set_bit(bit_iterator, &errs_bits, bits_num) {
1037                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1038                 }
1039         }
1040
1041         ADF_CSR_WR(csr, ADF_GEN4_SSMCPPERR, reg);
1042
1043         return reset_required;
1044 }
1045
1046 static bool adf_handle_rf_parr_err(struct adf_accel_dev *accel_dev,
1047                                    void __iomem *csr, u32 iastatssm)
1048 {
1049         struct adf_dev_err_mask *err_mask = GET_ERR_MASK(accel_dev);
1050         u32 reg;
1051
1052         if (!(iastatssm & ADF_GEN4_IAINTSTATSSM_SSMSOFTERRORPARITY_BIT))
1053                 return false;
1054
1055         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_SRC);
1056         reg &= ADF_GEN4_SSMSOFTERRORPARITY_SRC_BIT;
1057         if (reg) {
1058                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1059                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_SRC, reg);
1060         }
1061
1062         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_ATH_CPH);
1063         reg &= err_mask->parerr_ath_cph_mask;
1064         if (reg) {
1065                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1066                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_ATH_CPH, reg);
1067         }
1068
1069         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_CPR_XLT);
1070         reg &= err_mask->parerr_cpr_xlt_mask;
1071         if (reg) {
1072                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1073                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_CPR_XLT, reg);
1074         }
1075
1076         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_DCPR_UCS);
1077         reg &= err_mask->parerr_dcpr_ucs_mask;
1078         if (reg) {
1079                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1080                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_DCPR_UCS, reg);
1081         }
1082
1083         reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_PKE);
1084         reg &= err_mask->parerr_pke_mask;
1085         if (reg) {
1086                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1087                 ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_PKE, reg);
1088         }
1089
1090         if (err_mask->parerr_wat_wcp_mask) {
1091                 reg = ADF_CSR_RD(csr, ADF_GEN4_SSMSOFTERRORPARITY_WAT_WCP);
1092                 reg &= err_mask->parerr_wat_wcp_mask;
1093                 if (reg) {
1094                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1095                         ADF_CSR_WR(csr, ADF_GEN4_SSMSOFTERRORPARITY_WAT_WCP,
1096                                    reg);
1097                 }
1098         }
1099
1100         dev_err(&GET_DEV(accel_dev), "Slice ssm soft parity error reported");
1101
1102         return false;
1103 }
1104
1105 static bool adf_handle_ser_err_ssmsh(struct adf_accel_dev *accel_dev,
1106                                      void __iomem *csr, u32 iastatssm)
1107 {
1108         u32 reg, bits_num = BITS_PER_REG(reg);
1109         bool reset_required = false;
1110         unsigned long errs_bits;
1111         u32 bit_iterator;
1112
1113         if (!(iastatssm & (ADF_GEN4_IAINTSTATSSM_SER_ERR_SSMSH_CERR_BIT |
1114                          ADF_GEN4_IAINTSTATSSM_SER_ERR_SSMSH_UNCERR_BIT)))
1115                 return false;
1116
1117         reg = ADF_CSR_RD(csr, ADF_GEN4_SER_ERR_SSMSH);
1118         reg &= ADF_GEN4_SER_ERR_SSMSH_FATAL_BITMASK |
1119                ADF_GEN4_SER_ERR_SSMSH_UNCERR_BITMASK |
1120                ADF_GEN4_SER_ERR_SSMSH_CERR_BITMASK;
1121         if (reg & ADF_GEN4_SER_ERR_SSMSH_FATAL_BITMASK) {
1122                 dev_err(&GET_DEV(accel_dev),
1123                         "Fatal SER_SSMSH_ERR: 0x%x\n", reg);
1124
1125                 errs_bits = reg & ADF_GEN4_SER_ERR_SSMSH_FATAL_BITMASK;
1126                 for_each_set_bit(bit_iterator, &errs_bits, bits_num) {
1127                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1128                 }
1129
1130                 reset_required = true;
1131         }
1132
1133         if (reg & ADF_GEN4_SER_ERR_SSMSH_UNCERR_BITMASK) {
1134                 dev_err(&GET_DEV(accel_dev),
1135                         "non-fatal SER_SSMSH_ERR: 0x%x\n", reg);
1136
1137                 errs_bits = reg & ADF_GEN4_SER_ERR_SSMSH_UNCERR_BITMASK;
1138                 for_each_set_bit(bit_iterator, &errs_bits, bits_num) {
1139                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1140                 }
1141         }
1142
1143         if (reg & ADF_GEN4_SER_ERR_SSMSH_CERR_BITMASK) {
1144                 dev_warn(&GET_DEV(accel_dev),
1145                          "Correctable SER_SSMSH_ERR: 0x%x\n", reg);
1146
1147                 errs_bits = reg & ADF_GEN4_SER_ERR_SSMSH_CERR_BITMASK;
1148                 for_each_set_bit(bit_iterator, &errs_bits, bits_num) {
1149                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
1150                 }
1151         }
1152
1153         ADF_CSR_WR(csr, ADF_GEN4_SER_ERR_SSMSH, reg);
1154
1155         return reset_required;
1156 }
1157
1158 static bool adf_handle_iaintstatssm(struct adf_accel_dev *accel_dev,
1159                                     void __iomem *csr)
1160 {
1161         u32 iastatssm = ADF_CSR_RD(csr, ADF_GEN4_IAINTSTATSSM);
1162         bool reset_required;
1163
1164         iastatssm &= ADF_GEN4_IAINTSTATSSM_BITMASK;
1165         if (!iastatssm)
1166                 return false;
1167
1168         reset_required = adf_handle_uerrssmsh(accel_dev, csr, iastatssm);
1169         reset_required |= adf_handle_cerrssmsh(accel_dev, csr, iastatssm);
1170         reset_required |= adf_handle_pperr_err(accel_dev, csr, iastatssm);
1171         reset_required |= adf_handle_slice_hang_error(accel_dev, csr, iastatssm);
1172         reset_required |= adf_handle_spppar_err(accel_dev, csr, iastatssm);
1173         reset_required |= adf_handle_ssmcpppar_err(accel_dev, csr, iastatssm);
1174         reset_required |= adf_handle_rf_parr_err(accel_dev, csr, iastatssm);
1175         reset_required |= adf_handle_ser_err_ssmsh(accel_dev, csr, iastatssm);
1176
1177         ADF_CSR_WR(csr, ADF_GEN4_IAINTSTATSSM, iastatssm);
1178
1179         return reset_required;
1180 }
1181
1182 static bool adf_handle_exprpssmcmpr(struct adf_accel_dev *accel_dev,
1183                                     void __iomem *csr)
1184 {
1185         u32 reg = ADF_CSR_RD(csr, ADF_GEN4_EXPRPSSMCPR);
1186
1187         reg &= ADF_GEN4_EXPRPSSMCPR_UNCERR_BITMASK;
1188         if (!reg)
1189                 return false;
1190
1191         dev_err(&GET_DEV(accel_dev),
1192                 "Uncorrectable error exception in SSM CMP: 0x%x", reg);
1193
1194         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1195
1196         ADF_CSR_WR(csr, ADF_GEN4_EXPRPSSMCPR, reg);
1197
1198         return false;
1199 }
1200
1201 static bool adf_handle_exprpssmxlt(struct adf_accel_dev *accel_dev,
1202                                    void __iomem *csr)
1203 {
1204         u32 reg = ADF_CSR_RD(csr, ADF_GEN4_EXPRPSSMXLT);
1205
1206         reg &= ADF_GEN4_EXPRPSSMXLT_UNCERR_BITMASK |
1207                ADF_GEN4_EXPRPSSMXLT_CERR_BIT;
1208         if (!reg)
1209                 return false;
1210
1211         if (reg & ADF_GEN4_EXPRPSSMXLT_UNCERR_BITMASK) {
1212                 dev_err(&GET_DEV(accel_dev),
1213                         "Uncorrectable error exception in SSM XLT: 0x%x", reg);
1214
1215                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1216         }
1217
1218         if (reg & ADF_GEN4_EXPRPSSMXLT_CERR_BIT) {
1219                 dev_warn(&GET_DEV(accel_dev),
1220                          "Correctable error exception in SSM XLT: 0x%x", reg);
1221
1222                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
1223         }
1224
1225         ADF_CSR_WR(csr, ADF_GEN4_EXPRPSSMXLT, reg);
1226
1227         return false;
1228 }
1229
1230 static bool adf_handle_exprpssmdcpr(struct adf_accel_dev *accel_dev,
1231                                     void __iomem *csr)
1232 {
1233         u32 reg;
1234         int i;
1235
1236         for (i = 0; i < ADF_GEN4_DCPR_SLICES_NUM; i++) {
1237                 reg = ADF_CSR_RD(csr, ADF_GEN4_EXPRPSSMDCPR(i));
1238                 reg &= ADF_GEN4_EXPRPSSMDCPR_UNCERR_BITMASK |
1239                        ADF_GEN4_EXPRPSSMDCPR_CERR_BITMASK;
1240                 if (!reg)
1241                         continue;
1242
1243                 if (reg & ADF_GEN4_EXPRPSSMDCPR_UNCERR_BITMASK) {
1244                         dev_err(&GET_DEV(accel_dev),
1245                                 "Uncorrectable error exception in SSM DCMP: 0x%x", reg);
1246
1247                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1248                 }
1249
1250                 if (reg & ADF_GEN4_EXPRPSSMDCPR_CERR_BITMASK) {
1251                         dev_warn(&GET_DEV(accel_dev),
1252                                  "Correctable error exception in SSM DCMP: 0x%x", reg);
1253
1254                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
1255                 }
1256
1257                 ADF_CSR_WR(csr, ADF_GEN4_EXPRPSSMDCPR(i), reg);
1258         }
1259
1260         return false;
1261 }
1262
1263 static bool adf_handle_ssm(struct adf_accel_dev *accel_dev, void __iomem *csr,
1264                            u32 errsou)
1265 {
1266         bool reset_required;
1267
1268         if (!(errsou & ADF_GEN4_ERRSOU2_SSM_ERR_BIT))
1269                 return false;
1270
1271         reset_required = adf_handle_iaintstatssm(accel_dev, csr);
1272         reset_required |= adf_handle_exprpssmcmpr(accel_dev, csr);
1273         reset_required |= adf_handle_exprpssmxlt(accel_dev, csr);
1274         reset_required |= adf_handle_exprpssmdcpr(accel_dev, csr);
1275
1276         return reset_required;
1277 }
1278
1279 static bool adf_handle_cpp_cfc_err(struct adf_accel_dev *accel_dev,
1280                                    void __iomem *csr, u32 errsou)
1281 {
1282         bool reset_required = false;
1283         u32 reg;
1284
1285         if (!(errsou & ADF_GEN4_ERRSOU2_CPP_CFC_ERR_STATUS_BIT))
1286                 return false;
1287
1288         reg = ADF_CSR_RD(csr, ADF_GEN4_CPP_CFC_ERR_STATUS);
1289         if (reg & ADF_GEN4_CPP_CFC_ERR_STATUS_DATAPAR_BIT) {
1290                 dev_err(&GET_DEV(accel_dev),
1291                         "CPP_CFC_ERR: data parity: 0x%x", reg);
1292                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1293         }
1294
1295         if (reg & ADF_GEN4_CPP_CFC_ERR_STATUS_CMDPAR_BIT) {
1296                 dev_err(&GET_DEV(accel_dev),
1297                         "CPP_CFC_ERR: command parity: 0x%x", reg);
1298                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1299
1300                 reset_required = true;
1301         }
1302
1303         if (reg & ADF_GEN4_CPP_CFC_ERR_STATUS_MERR_BIT) {
1304                 dev_err(&GET_DEV(accel_dev),
1305                         "CPP_CFC_ERR: multiple errors: 0x%x", reg);
1306                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1307
1308                 reset_required = true;
1309         }
1310
1311         ADF_CSR_WR(csr, ADF_GEN4_CPP_CFC_ERR_STATUS_CLR,
1312                    ADF_GEN4_CPP_CFC_ERR_STATUS_CLR_BITMASK);
1313
1314         return reset_required;
1315 }
1316
1317 static void adf_gen4_process_errsou2(struct adf_accel_dev *accel_dev,
1318                                      void __iomem *csr, u32 errsou,
1319                                      bool *reset_required)
1320 {
1321         *reset_required |= adf_handle_ssm(accel_dev, csr, errsou);
1322         *reset_required |= adf_handle_cpp_cfc_err(accel_dev, csr, errsou);
1323 }
1324
1325 static bool adf_handle_timiscsts(struct adf_accel_dev *accel_dev,
1326                                  void __iomem *csr, u32 errsou)
1327 {
1328         u32 timiscsts;
1329
1330         if (!(errsou & ADF_GEN4_ERRSOU3_TIMISCSTS_BIT))
1331                 return false;
1332
1333         timiscsts = ADF_CSR_RD(csr, ADF_GEN4_TIMISCSTS);
1334
1335         dev_err(&GET_DEV(accel_dev),
1336                 "Fatal error in Transmit Interface: 0x%x\n", timiscsts);
1337
1338         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1339
1340         return true;
1341 }
1342
1343 static bool adf_handle_ricppintsts(struct adf_accel_dev *accel_dev,
1344                                    void __iomem *csr, u32 errsou)
1345 {
1346         u32 ricppintsts;
1347
1348         if (!(errsou & ADF_GEN4_ERRSOU3_RICPPINTSTS_BITMASK))
1349                 return false;
1350
1351         ricppintsts = ADF_CSR_RD(csr, ADF_GEN4_RICPPINTSTS);
1352         ricppintsts &= ADF_GEN4_RICPPINTSTS_BITMASK;
1353
1354         dev_err(&GET_DEV(accel_dev),
1355                 "RI CPP Uncorrectable Error: 0x%x\n", ricppintsts);
1356
1357         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1358
1359         ADF_CSR_WR(csr, ADF_GEN4_RICPPINTSTS, ricppintsts);
1360
1361         return false;
1362 }
1363
1364 static bool adf_handle_ticppintsts(struct adf_accel_dev *accel_dev,
1365                                    void __iomem *csr, u32 errsou)
1366 {
1367         u32 ticppintsts;
1368
1369         if (!(errsou & ADF_GEN4_ERRSOU3_TICPPINTSTS_BITMASK))
1370                 return false;
1371
1372         ticppintsts = ADF_CSR_RD(csr, ADF_GEN4_TICPPINTSTS);
1373         ticppintsts &= ADF_GEN4_TICPPINTSTS_BITMASK;
1374
1375         dev_err(&GET_DEV(accel_dev),
1376                 "TI CPP Uncorrectable Error: 0x%x\n", ticppintsts);
1377
1378         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1379
1380         ADF_CSR_WR(csr, ADF_GEN4_TICPPINTSTS, ticppintsts);
1381
1382         return false;
1383 }
1384
1385 static bool adf_handle_aramcerr(struct adf_accel_dev *accel_dev,
1386                                 void __iomem *csr, u32 errsou)
1387 {
1388         u32 aram_cerr;
1389
1390         if (!(errsou & ADF_GEN4_ERRSOU3_REG_ARAMCERR_BIT))
1391                 return false;
1392
1393         aram_cerr = ADF_CSR_RD(csr, ADF_GEN4_REG_ARAMCERR);
1394         aram_cerr &= ADF_GEN4_REG_ARAMCERR_BIT;
1395
1396         dev_warn(&GET_DEV(accel_dev),
1397                  "ARAM correctable error : 0x%x\n", aram_cerr);
1398
1399         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_CORR);
1400
1401         aram_cerr |= ADF_GEN4_REG_ARAMCERR_EN_BITMASK;
1402
1403         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMCERR, aram_cerr);
1404
1405         return false;
1406 }
1407
1408 static bool adf_handle_aramuerr(struct adf_accel_dev *accel_dev,
1409                                 void __iomem *csr, u32 errsou)
1410 {
1411         bool reset_required = false;
1412         u32 aramuerr;
1413
1414         if (!(errsou & ADF_GEN4_ERRSOU3_REG_ARAMUERR_BIT))
1415                 return false;
1416
1417         aramuerr = ADF_CSR_RD(csr, ADF_GEN4_REG_ARAMUERR);
1418         aramuerr &= ADF_GEN4_REG_ARAMUERR_ERROR_BIT |
1419                     ADF_GEN4_REG_ARAMUERR_MULTI_ERRORS_BIT;
1420
1421         if (!aramuerr)
1422                 return false;
1423
1424         if (aramuerr & ADF_GEN4_REG_ARAMUERR_MULTI_ERRORS_BIT) {
1425                 dev_err(&GET_DEV(accel_dev),
1426                         "ARAM multiple uncorrectable errors: 0x%x\n", aramuerr);
1427
1428                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1429
1430                 reset_required = true;
1431         } else {
1432                 dev_err(&GET_DEV(accel_dev),
1433                         "ARAM uncorrectable error: 0x%x\n", aramuerr);
1434
1435                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1436         }
1437
1438         aramuerr |= ADF_GEN4_REG_ARAMUERR_EN_BITMASK;
1439
1440         ADF_CSR_WR(csr, ADF_GEN4_REG_ARAMUERR, aramuerr);
1441
1442         return reset_required;
1443 }
1444
1445 static bool adf_handle_reg_cppmemtgterr(struct adf_accel_dev *accel_dev,
1446                                         void __iomem *csr, u32 errsou)
1447 {
1448         bool reset_required = false;
1449         u32 cppmemtgterr;
1450
1451         if (!(errsou & ADF_GEN4_ERRSOU3_REG_ARAMUERR_BIT))
1452                 return false;
1453
1454         cppmemtgterr = ADF_CSR_RD(csr, ADF_GEN4_REG_CPPMEMTGTERR);
1455         cppmemtgterr &= ADF_GEN4_REG_CPPMEMTGTERR_BITMASK |
1456                         ADF_GEN4_REG_CPPMEMTGTERR_MULTI_ERRORS_BIT;
1457         if (!cppmemtgterr)
1458                 return false;
1459
1460         if (cppmemtgterr & ADF_GEN4_REG_CPPMEMTGTERR_MULTI_ERRORS_BIT) {
1461                 dev_err(&GET_DEV(accel_dev),
1462                         "Misc memory target multiple uncorrectable errors: 0x%x\n",
1463                         cppmemtgterr);
1464
1465                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_FATAL);
1466
1467                 reset_required = true;
1468         } else {
1469                 dev_err(&GET_DEV(accel_dev),
1470                         "Misc memory target uncorrectable error: 0x%x\n", cppmemtgterr);
1471                 ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1472         }
1473
1474         cppmemtgterr |= ADF_GEN4_REG_CPPMEMTGTERR_EN_BITMASK;
1475
1476         ADF_CSR_WR(csr, ADF_GEN4_REG_CPPMEMTGTERR, cppmemtgterr);
1477
1478         return reset_required;
1479 }
1480
1481 static bool adf_handle_atufaultstatus(struct adf_accel_dev *accel_dev,
1482                                       void __iomem *csr, u32 errsou)
1483 {
1484         u32 i;
1485         u32 max_rp_num = GET_HW_DATA(accel_dev)->num_banks;
1486
1487         if (!(errsou & ADF_GEN4_ERRSOU3_ATUFAULTSTATUS_BIT))
1488                 return false;
1489
1490         for (i = 0; i < max_rp_num; i++) {
1491                 u32 atufaultstatus = ADF_CSR_RD(csr, ADF_GEN4_ATUFAULTSTATUS(i));
1492
1493                 atufaultstatus &= ADF_GEN4_ATUFAULTSTATUS_BIT;
1494
1495                 if (atufaultstatus) {
1496                         dev_err(&GET_DEV(accel_dev),
1497                                 "Ring Pair (%u) ATU detected fault: 0x%x\n", i,
1498                                 atufaultstatus);
1499
1500                         ADF_RAS_ERR_CTR_INC(accel_dev->ras_errors, ADF_RAS_UNCORR);
1501
1502                         ADF_CSR_WR(csr, ADF_GEN4_ATUFAULTSTATUS(i), atufaultstatus);
1503                 }
1504         }
1505
1506         return false;
1507 }
1508
1509 static void adf_gen4_process_errsou3(struct adf_accel_dev *accel_dev,
1510                                      void __iomem *csr, void __iomem *aram_csr,
1511                                      u32 errsou, bool *reset_required)
1512 {
1513         *reset_required |= adf_handle_timiscsts(accel_dev, csr, errsou);
1514         *reset_required |= adf_handle_ricppintsts(accel_dev, csr, errsou);
1515         *reset_required |= adf_handle_ticppintsts(accel_dev, csr, errsou);
1516         *reset_required |= adf_handle_aramcerr(accel_dev, aram_csr, errsou);
1517         *reset_required |= adf_handle_aramuerr(accel_dev, aram_csr, errsou);
1518         *reset_required |= adf_handle_reg_cppmemtgterr(accel_dev, aram_csr, errsou);
1519         *reset_required |= adf_handle_atufaultstatus(accel_dev, csr, errsou);
1520 }
1521
1522 static bool adf_gen4_handle_interrupt(struct adf_accel_dev *accel_dev,
1523                                       bool *reset_required)
1524 {
1525         void __iomem *aram_csr = adf_get_aram_base(accel_dev);
1526         void __iomem *csr = adf_get_pmisc_base(accel_dev);
1527         u32 errsou = ADF_CSR_RD(csr, ADF_GEN4_ERRSOU0);
1528         bool handled = false;
1529
1530         *reset_required = false;
1531
1532         if (errsou & ADF_GEN4_ERRSOU0_BIT) {
1533                 adf_gen4_process_errsou0(accel_dev, csr);
1534                 handled = true;
1535         }
1536
1537         errsou = ADF_CSR_RD(csr, ADF_GEN4_ERRSOU1);
1538         if (errsou & ADF_GEN4_ERRSOU1_BITMASK) {
1539                 adf_gen4_process_errsou1(accel_dev, csr, errsou, reset_required);
1540                 handled = true;
1541         }
1542
1543         errsou = ADF_CSR_RD(csr, ADF_GEN4_ERRSOU2);
1544         if (errsou & ADF_GEN4_ERRSOU2_BITMASK) {
1545                 adf_gen4_process_errsou2(accel_dev, csr, errsou, reset_required);
1546                 handled = true;
1547         }
1548
1549         errsou = ADF_CSR_RD(csr, ADF_GEN4_ERRSOU3);
1550         if (errsou & ADF_GEN4_ERRSOU3_BITMASK) {
1551                 adf_gen4_process_errsou3(accel_dev, csr, aram_csr, errsou, reset_required);
1552                 handled = true;
1553         }
1554
1555         return handled;
1556 }
1557
1558 void adf_gen4_init_ras_ops(struct adf_ras_ops *ras_ops)
1559 {
1560         ras_ops->enable_ras_errors = adf_gen4_enable_ras;
1561         ras_ops->disable_ras_errors = adf_gen4_disable_ras;
1562         ras_ops->handle_interrupt = adf_gen4_handle_interrupt;
1563 }
1564 EXPORT_SYMBOL_GPL(adf_gen4_init_ras_ops);