// SPDX-License-Identifier: MIT
/*
 * Copyright 2025 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 */
#include "ras.h"
#include "ras_core_status.h"
#include "ras_log_ring.h"
#include "ras_cper.h"

static const struct ras_cper_guid MCE   = CPER_NOTIFY__MCE;
static const struct ras_cper_guid CMC   = CPER_NOTIFY__CMC;
static const struct ras_cper_guid BOOT  = BOOT__TYPE;

static const struct ras_cper_guid CRASHDUMP = GPU__CRASHDUMP;
static const struct ras_cper_guid RUNTIME = GPU__NONSTANDARD_ERROR;

static void cper_get_timestamp(struct ras_core_context *ras_core,
                struct ras_cper_timestamp *timestamp, uint64_t utc_second_timestamp)
{
        struct ras_time tm = {0};

        ras_core_convert_timestamp_to_time(ras_core, utc_second_timestamp, &tm);
        timestamp->seconds = tm.tm_sec;
        timestamp->minutes = tm.tm_min;
        timestamp->hours = tm.tm_hour;
        timestamp->flag = 0;
        timestamp->day = tm.tm_mday;
        timestamp->month = tm.tm_mon;
        timestamp->year = tm.tm_year % 100;
        timestamp->century = tm.tm_year / 100;
}

static void fill_section_hdr(struct ras_core_context *ras_core,
                                struct cper_section_hdr *hdr, enum ras_cper_type type,
                                enum ras_cper_severity sev, struct ras_log_info *trace)
{
        struct device_system_info dev_info = {0};
        char record_id[32];

        hdr->signature[0]               = 'C';
        hdr->signature[1]               = 'P';
        hdr->signature[2]               = 'E';
        hdr->signature[3]               = 'R';
        hdr->revision                   = CPER_HDR__REV_1;
        hdr->signature_end              = 0xFFFFFFFF;
        hdr->error_severity             = (sev == RAS_CPER_SEV_RMA ? RAS_CPER_SEV_FATAL_UE : sev);

        hdr->valid_bits.platform_id     = 1;
        hdr->valid_bits.timestamp       = 1;

        ras_core_get_device_system_info(ras_core, &dev_info);

        cper_get_timestamp(ras_core, &hdr->timestamp, trace->timestamp);

        snprintf(record_id, sizeof(record_id), "%d:%llX", dev_info.socket_id,
                    RAS_LOG_SEQNO_TO_BATCH_IDX(trace->seqno));
        memcpy(hdr->record_id, record_id, 8);

        snprintf(hdr->platform_id, 16, "0x%04X:0x%04X",
                dev_info.vendor_id, dev_info.device_id);
        /* pmfw version should be part of creator_id according to CPER spec */
        snprintf(hdr->creator_id, 16, "%s", CPER_CREATOR_ID__AMDGPU);

        switch (type) {
        case RAS_CPER_TYPE_BOOT:
                hdr->notify_type = BOOT;
                break;
        case RAS_CPER_TYPE_FATAL:
        case RAS_CPER_TYPE_RMA:
                hdr->notify_type = MCE;
                break;
        case RAS_CPER_TYPE_RUNTIME:
                if (sev == RAS_CPER_SEV_NON_FATAL_CE)
                        hdr->notify_type = CMC;
                else
                        hdr->notify_type = MCE;
                break;
        default:
                RAS_DEV_ERR(ras_core->dev, "Unknown CPER Type\n");
                break;
        }
}

static int fill_section_descriptor(struct ras_core_context *ras_core,
                                        struct cper_section_descriptor *descriptor,
                                        enum ras_cper_severity sev,
                                        struct ras_cper_guid sec_type,
                                        uint32_t section_offset,
                                        uint32_t section_length)
{
        struct device_system_info dev_info = {0};

        descriptor->revision_minor              = CPER_SEC__MINOR_REV_1;
        descriptor->revision_major              = CPER_SEC__MAJOR_REV_22;
        descriptor->sec_offset          = section_offset;
        descriptor->sec_length          = section_length;
        descriptor->valid_bits.fru_text = 1;
        descriptor->flag_bits.primary   = 1;
        descriptor->severity = (sev == RAS_CPER_SEV_RMA ? RAS_CPER_SEV_FATAL_UE : sev);
        descriptor->sec_type                    = sec_type;

        ras_core_get_device_system_info(ras_core, &dev_info);

        snprintf(descriptor->fru_text, 20, "OAM%d", dev_info.socket_id);

        if (sev == RAS_CPER_SEV_RMA)
                descriptor->flag_bits.exceed_err_threshold = 1;

        if (sev == RAS_CPER_SEV_NON_FATAL_UE)
                descriptor->flag_bits.latent_err = 1;

        return 0;
}

static int fill_section_fatal(struct ras_core_context *ras_core,
                struct cper_section_fatal *fatal, struct ras_log_info *trace)
{
        fatal->data.reg_ctx_type = CPER_CTX_TYPE__CRASH;
        fatal->data.reg_arr_size = sizeof(fatal->data.reg);

        fatal->data.reg.status = trace->aca_reg.regs[RAS_CPER_ACA_REG_STATUS];
        fatal->data.reg.addr   = trace->aca_reg.regs[RAS_CPER_ACA_REG_ADDR];
        fatal->data.reg.ipid   = trace->aca_reg.regs[RAS_CPER_ACA_REG_IPID];
        fatal->data.reg.synd   = trace->aca_reg.regs[RAS_CPER_ACA_REG_SYND];

        return 0;
}

static int fill_section_runtime(struct ras_core_context *ras_core,
                struct cper_section_runtime *runtime, struct ras_log_info *trace,
                enum ras_cper_severity sev)
{
        runtime->hdr.valid_bits.err_info_cnt = 1;
        runtime->hdr.valid_bits.err_context_cnt = 1;

        runtime->descriptor.error_type = RUNTIME;
        runtime->descriptor.ms_chk_bits.err_type_valid = 1;
        if (sev == RAS_CPER_SEV_RMA) {
                runtime->descriptor.valid_bits.ms_chk = 1;
                runtime->descriptor.ms_chk_bits.err_type = 1;
                runtime->descriptor.ms_chk_bits.pcc = 1;
        }

        runtime->reg.reg_ctx_type = CPER_CTX_TYPE__CRASH;
        runtime->reg.reg_arr_size = sizeof(runtime->reg.reg_dump);

        runtime->reg.reg_dump[RAS_CPER_ACA_REG_CTL]    = trace->aca_reg.regs[ACA_REG_IDX__CTL];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_STATUS] = trace->aca_reg.regs[ACA_REG_IDX__STATUS];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_ADDR]   = trace->aca_reg.regs[ACA_REG_IDX__ADDR];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_MISC0]  = trace->aca_reg.regs[ACA_REG_IDX__MISC0];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_CONFIG] = trace->aca_reg.regs[ACA_REG_IDX__CONFG];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_IPID]   = trace->aca_reg.regs[ACA_REG_IDX__IPID];
        runtime->reg.reg_dump[RAS_CPER_ACA_REG_SYND]   = trace->aca_reg.regs[ACA_REG_IDX__SYND];

        return 0;
}

static int cper_generate_runtime_record(struct ras_core_context *ras_core,
        struct cper_section_hdr *hdr, struct ras_log_info **trace_arr, uint32_t arr_num,
                enum ras_cper_severity sev)
{
        struct cper_section_descriptor *descriptor;
        struct cper_section_runtime *runtime;
        int i;

        fill_section_hdr(ras_core, hdr, RAS_CPER_TYPE_RUNTIME, sev, trace_arr[0]);
        hdr->record_length =  RAS_HDR_LEN + ((RAS_SEC_DESC_LEN + RAS_NONSTD_SEC_LEN) * arr_num);
        hdr->sec_cnt = arr_num;
        for (i = 0; i < arr_num; i++) {
                descriptor = (struct cper_section_descriptor *)((uint8_t *)hdr +
                             RAS_SEC_DESC_OFFSET(i));
                runtime = (struct cper_section_runtime *)((uint8_t *)hdr +
                          RAS_NONSTD_SEC_OFFSET(hdr->sec_cnt, i));

                fill_section_descriptor(ras_core, descriptor, sev, RUNTIME,
                        RAS_NONSTD_SEC_OFFSET(hdr->sec_cnt, i),
                        sizeof(struct cper_section_runtime));
                fill_section_runtime(ras_core, runtime, trace_arr[i], sev);
        }

        return 0;
}

static int cper_generate_fatal_record(struct ras_core_context *ras_core,
        uint8_t *buffer, struct ras_log_info **trace_arr, uint32_t arr_num)
{
        struct ras_cper_fatal_record record = {0};
        int i = 0;

        for (i = 0; i < arr_num; i++) {
                fill_section_hdr(ras_core, &record.hdr, RAS_CPER_TYPE_FATAL,
                                 RAS_CPER_SEV_FATAL_UE, trace_arr[i]);
                record.hdr.record_length =  RAS_HDR_LEN + RAS_SEC_DESC_LEN + RAS_FATAL_SEC_LEN;
                record.hdr.sec_cnt = 1;

                fill_section_descriptor(ras_core, &record.descriptor, RAS_CPER_SEV_FATAL_UE,
                                        CRASHDUMP, offsetof(struct ras_cper_fatal_record, fatal),
                                        sizeof(struct cper_section_fatal));

                fill_section_fatal(ras_core, &record.fatal, trace_arr[i]);

                memcpy(buffer + (i * record.hdr.record_length),
                                &record, record.hdr.record_length);
        }

        return 0;
}

static int cper_get_record_size(enum ras_cper_type type, uint16_t section_count)
{
        int size = 0;

        size += RAS_HDR_LEN;
        size += (RAS_SEC_DESC_LEN * section_count);

        switch (type) {
        case RAS_CPER_TYPE_RUNTIME:
        case RAS_CPER_TYPE_RMA:
                size += (RAS_NONSTD_SEC_LEN * section_count);
                break;
        case RAS_CPER_TYPE_FATAL:
                size += (RAS_FATAL_SEC_LEN * section_count);
                size += (RAS_HDR_LEN * (section_count - 1));
                break;
        case RAS_CPER_TYPE_BOOT:
                size += (RAS_BOOT_SEC_LEN * section_count);
                break;
        default:
                /* should never reach here */
                break;
        }

        return size;
}

static enum ras_cper_type cper_ras_log_event_to_cper_type(enum ras_log_event event)
{
        switch (event) {
        case RAS_LOG_EVENT_UE:
                return RAS_CPER_TYPE_FATAL;
        case RAS_LOG_EVENT_DE:
        case RAS_LOG_EVENT_CE:
        case RAS_LOG_EVENT_POISON_CREATION:
        case RAS_LOG_EVENT_POISON_CONSUMPTION:
                return RAS_CPER_TYPE_RUNTIME;
        case RAS_LOG_EVENT_RMA:
                return RAS_CPER_TYPE_RMA;
        default:
                /* should never reach here */
                return RAS_CPER_TYPE_RUNTIME;
        }
}

int ras_cper_generate_cper(struct ras_core_context *ras_core,
                struct ras_log_info **trace_list, uint32_t count,
                uint8_t *buf, uint32_t buf_len, uint32_t *real_data_len)
{
        uint8_t *buffer = buf;
        uint64_t buf_size = buf_len;
        int record_size, saved_size = 0;
        struct cper_section_hdr *hdr;

        /* All the batch traces share the same event */
        record_size = cper_get_record_size(
                        cper_ras_log_event_to_cper_type(trace_list[0]->event), count);

        if ((record_size + saved_size) > buf_size)
                return -ENOMEM;

        hdr = (struct cper_section_hdr *)(buffer + saved_size);

        switch (trace_list[0]->event) {
        case RAS_LOG_EVENT_RMA:
                cper_generate_runtime_record(ras_core, hdr, trace_list, count, RAS_CPER_SEV_RMA);
                break;
        case RAS_LOG_EVENT_DE:
                cper_generate_runtime_record(ras_core,
                        hdr, trace_list, count, RAS_CPER_SEV_NON_FATAL_UE);
                break;
        case RAS_LOG_EVENT_CE:
                cper_generate_runtime_record(ras_core,
                        hdr, trace_list, count, RAS_CPER_SEV_NON_FATAL_CE);
                break;
        case RAS_LOG_EVENT_UE:
                cper_generate_fatal_record(ras_core, buffer + saved_size, trace_list, count);
                break;
        default:
                RAS_DEV_WARN(ras_core->dev, "Unprocessed trace event: %d\n", trace_list[0]->event);
                break;
        }

        saved_size += record_size;

        *real_data_len = saved_size;
        return 0;
}