// SPDX-License-Identifier: MIT
/*
 * Copyright © 2025 Intel Corporation
 */

#include <linux/fault-inject.h>

#include "regs/xe_gsc_regs.h"
#include "regs/xe_hw_error_regs.h"
#include "regs/xe_irq_regs.h"

#include "xe_device.h"
#include "xe_hw_error.h"
#include "xe_mmio.h"
#include "xe_survivability_mode.h"

#define  HEC_UNCORR_FW_ERR_BITS 4
extern struct fault_attr inject_csc_hw_error;

/* Error categories reported by hardware */
enum hardware_error {
        HARDWARE_ERROR_CORRECTABLE = 0,
        HARDWARE_ERROR_NONFATAL = 1,
        HARDWARE_ERROR_FATAL = 2,
        HARDWARE_ERROR_MAX,
};

static const char * const hec_uncorrected_fw_errors[] = {
        "Fatal",
        "CSE Disabled",
        "FD Corruption",
        "Data Corruption"
};

static const char *hw_error_to_str(const enum hardware_error hw_err)
{
        switch (hw_err) {
        case HARDWARE_ERROR_CORRECTABLE:
                return "CORRECTABLE";
        case HARDWARE_ERROR_NONFATAL:
                return "NONFATAL";
        case HARDWARE_ERROR_FATAL:
                return "FATAL";
        default:
                return "UNKNOWN";
        }
}

static bool fault_inject_csc_hw_error(void)
{
        return IS_ENABLED(CONFIG_DEBUG_FS) && should_fail(&inject_csc_hw_error, 1);
}

static void csc_hw_error_work(struct work_struct *work)
{
        struct xe_tile *tile = container_of(work, typeof(*tile), csc_hw_error_work);
        struct xe_device *xe = tile_to_xe(tile);
        int ret;

        ret = xe_survivability_mode_runtime_enable(xe);
        if (ret)
                drm_err(&xe->drm, "Failed to enable runtime survivability mode\n");
}

static void csc_hw_error_handler(struct xe_tile *tile, const enum hardware_error hw_err)
{
        const char *hw_err_str = hw_error_to_str(hw_err);
        struct xe_device *xe = tile_to_xe(tile);
        struct xe_mmio *mmio = &tile->mmio;
        u32 base, err_bit, err_src;
        unsigned long fw_err;

        if (xe->info.platform != XE_BATTLEMAGE)
                return;

        base = BMG_GSC_HECI1_BASE;
        lockdep_assert_held(&xe->irq.lock);
        err_src = xe_mmio_read32(mmio, HEC_UNCORR_ERR_STATUS(base));
        if (!err_src) {
                drm_err_ratelimited(&xe->drm, HW_ERR "Tile%d reported HEC_ERR_STATUS_%s blank\n",
                                    tile->id, hw_err_str);
                return;
        }

        if (err_src & UNCORR_FW_REPORTED_ERR) {
                fw_err = xe_mmio_read32(mmio, HEC_UNCORR_FW_ERR_DW0(base));
                for_each_set_bit(err_bit, &fw_err, HEC_UNCORR_FW_ERR_BITS) {
                        drm_err_ratelimited(&xe->drm, HW_ERR
                                            "%s: HEC Uncorrected FW %s error reported, bit[%d] is set\n",
                                             hw_err_str, hec_uncorrected_fw_errors[err_bit],
                                             err_bit);

                        schedule_work(&tile->csc_hw_error_work);
                }
        }

        xe_mmio_write32(mmio, HEC_UNCORR_ERR_STATUS(base), err_src);
}

static void hw_error_source_handler(struct xe_tile *tile, const enum hardware_error hw_err)
{
        const char *hw_err_str = hw_error_to_str(hw_err);
        struct xe_device *xe = tile_to_xe(tile);
        unsigned long flags;
        u32 err_src;

        if (xe->info.platform != XE_BATTLEMAGE)
                return;

        spin_lock_irqsave(&xe->irq.lock, flags);
        err_src = xe_mmio_read32(&tile->mmio, DEV_ERR_STAT_REG(hw_err));
        if (!err_src) {
                drm_err_ratelimited(&xe->drm, HW_ERR "Tile%d reported DEV_ERR_STAT_%s blank!\n",
                                    tile->id, hw_err_str);
                goto unlock;
        }

        if (err_src & XE_CSC_ERROR)
                csc_hw_error_handler(tile, hw_err);

        xe_mmio_write32(&tile->mmio, DEV_ERR_STAT_REG(hw_err), err_src);

unlock:
        spin_unlock_irqrestore(&xe->irq.lock, flags);
}

/**
 * xe_hw_error_irq_handler - irq handling for hw errors
 * @tile: tile instance
 * @master_ctl: value read from master interrupt register
 *
 * Xe platforms add three error bits to the master interrupt register to support error handling.
 * These three bits are used to convey the class of error FATAL, NONFATAL, or CORRECTABLE.
 * To process the interrupt, determine the source of error by reading the Device Error Source
 * Register that corresponds to the class of error being serviced.
 */
void xe_hw_error_irq_handler(struct xe_tile *tile, const u32 master_ctl)
{
        enum hardware_error hw_err;

        if (fault_inject_csc_hw_error())
                schedule_work(&tile->csc_hw_error_work);

        for (hw_err = 0; hw_err < HARDWARE_ERROR_MAX; hw_err++)
                if (master_ctl & ERROR_IRQ(hw_err))
                        hw_error_source_handler(tile, hw_err);
}

/*
 * Process hardware errors during boot
 */
static void process_hw_errors(struct xe_device *xe)
{
        struct xe_tile *tile;
        u32 master_ctl;
        u8 id;

        for_each_tile(tile, xe, id) {
                master_ctl = xe_mmio_read32(&tile->mmio, GFX_MSTR_IRQ);
                xe_hw_error_irq_handler(tile, master_ctl);
                xe_mmio_write32(&tile->mmio, GFX_MSTR_IRQ, master_ctl);
        }
}

/**
 * xe_hw_error_init - Initialize hw errors
 * @xe: xe device instance
 *
 * Initialize and check for errors that occurred during boot
 * prior to driver load
 */
void xe_hw_error_init(struct xe_device *xe)
{
        struct xe_tile *tile = xe_device_get_root_tile(xe);

        if (!IS_DGFX(xe) || IS_SRIOV_VF(xe))
                return;

        INIT_WORK(&tile->csc_hw_error_work, csc_hw_error_work);

        process_hw_errors(xe);
}