Quelle  loongson_edac.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2024 Loongson Technology Corporation Limited.
 */

#include <linux/acpi.h>
#include <linux/edac.h>
#include <linux/init.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include "edac_module.h"

#define ECC_CS_COUNT_REG 0x18

struct loongson_edac_pvt {
 void __iomem *ecc_base;

 /*
 * The ECC register in this controller records the number of errors
 * encountered since reset and cannot be zeroed so in order to be able
 * to report the error count at each check, this records the previous
 * register state.
 */
 int last_ce_count;
};

static int read_ecc(struct mem_ctl_info *mci)
{
 struct loongson_edac_pvt *pvt = mci->pvt_info;
 u64 ecc;
 int cs;

 ecc = readq(pvt->ecc_base + ECC_CS_COUNT_REG);
 /* cs0 -- cs3 */
 cs = ecc & 0xff;
 cs += (ecc >> 8) & 0xff;
 cs += (ecc >> 16) & 0xff;
 cs += (ecc >> 24) & 0xff;

 return cs;
}

static void edac_check(struct mem_ctl_info *mci)
{
 struct loongson_edac_pvt *pvt = mci->pvt_info;
 int new, add;

 new = read_ecc(mci);
 add = new - pvt->last_ce_count;
 pvt->last_ce_count = new;
 if (add <= 0)
  return;

 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, add,
        0, 0, 0, 0, 0, -1, "error", "");
}

static void dimm_config_init(struct mem_ctl_info *mci)
{
 struct dimm_info *dimm;
 u32 size, npages;

 /* size not used */
 size = -1;
 npages = MiB_TO_PAGES(size);

 dimm = edac_get_dimm(mci, 0, 0, 0);
 dimm->nr_pages = npages;
 snprintf(dimm->label, sizeof(dimm->label),
   "MC#%uChannel#%u_DIMM#%u", mci->mc_idx, 0, 0);
 dimm->grain = 8;
}

static void pvt_init(struct mem_ctl_info *mci, void __iomem *vbase)
{
 struct loongson_edac_pvt *pvt = mci->pvt_info;

 pvt->ecc_base = vbase;
 pvt->last_ce_count = read_ecc(mci);
}

static int edac_probe(struct platform_device *pdev)
{
 struct edac_mc_layer layers[2];
 struct mem_ctl_info *mci;
 void __iomem *vbase;
 int ret;

 vbase = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(vbase))
  return PTR_ERR(vbase);

 layers[0].type = EDAC_MC_LAYER_CHANNEL;
 layers[0].size = 1;
 layers[0].is_virt_csrow = false;
 layers[1].type = EDAC_MC_LAYER_SLOT;
 layers[1].size = 1;
 layers[1].is_virt_csrow = true;
 mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers,
       sizeof(struct loongson_edac_pvt));
 if (mci == NULL)
  return -ENOMEM;

 mci->mc_idx = edac_device_alloc_index();
 mci->mtype_cap = MEM_FLAG_RDDR4;
 mci->edac_ctl_cap = EDAC_FLAG_NONE;
 mci->edac_cap = EDAC_FLAG_NONE;
 mci->mod_name = "loongson_edac.c";
 mci->ctl_name = "loongson_edac_ctl";
 mci->dev_name = "loongson_edac_dev";
 mci->ctl_page_to_phys = NULL;
 mci->pdev = &pdev->dev;
 mci->error_desc.grain = 8;
 mci->edac_check = edac_check;

 pvt_init(mci, vbase);
 dimm_config_init(mci);

 ret = edac_mc_add_mc(mci);
 if (ret) {
  edac_dbg(0, "MC: failed edac_mc_add_mc()\n");
  edac_mc_free(mci);
  return ret;
 }
 edac_op_state = EDAC_OPSTATE_POLL;

 return 0;
}

static void edac_remove(struct platform_device *pdev)
{
 struct mem_ctl_info *mci = edac_mc_del_mc(&pdev->dev);

 if (mci)
  edac_mc_free(mci);
}

static const struct acpi_device_id loongson_edac_acpi_match[] = {
 {"LOON0010", 0},
 {}
};
MODULE_DEVICE_TABLE(acpi, loongson_edac_acpi_match);

static struct platform_driver loongson_edac_driver = {
 .probe  = edac_probe,
 .remove  = edac_remove,
 .driver  = {
  .name = "loongson-mc-edac",
  .acpi_match_table = loongson_edac_acpi_match,
 },
};
module_platform_driver(loongson_edac_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Zhao Qunqin ");
MODULE_DESCRIPTION("EDAC driver for loongson memory controller");