// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2025, Mike Rapoport, Microsoft * * Based on e820 pmem driver: * Copyright (c) 2015, Christoph Hellwig. * Copyright (c) 2015, Intel Corporation. */ #include #include #include #include #include #include #include #include #include #define LABEL_AREA_SIZE SZ_128K struct ramdax_dimm { struct nvdimm *nvdimm; void *label_area; }; static void ramdax_remove(struct platform_device *pdev) { struct nvdimm_bus *nvdimm_bus = platform_get_drvdata(pdev); nvdimm_bus_unregister(nvdimm_bus); } static int ramdax_register_region(struct resource *res, struct nvdimm *nvdimm, struct nvdimm_bus *nvdimm_bus) { struct nd_mapping_desc mapping; struct nd_region_desc ndr_desc; struct nd_interleave_set *nd_set; int nid = phys_to_target_node(res->start); nd_set = kzalloc(sizeof(*nd_set), GFP_KERNEL); if (!nd_set) return -ENOMEM; nd_set->cookie1 = 0xcafebeefcafebeef; nd_set->cookie2 = nd_set->cookie1; nd_set->altcookie = nd_set->cookie1; memset(&mapping, 0, sizeof(mapping)); mapping.nvdimm = nvdimm; mapping.start = 0; mapping.size = resource_size(res) - LABEL_AREA_SIZE; memset(&ndr_desc, 0, sizeof(ndr_desc)); ndr_desc.res = res; ndr_desc.numa_node = numa_map_to_online_node(nid); ndr_desc.target_node = nid; ndr_desc.num_mappings = 1; ndr_desc.mapping = &mapping; ndr_desc.nd_set = nd_set; if (!nvdimm_pmem_region_create(nvdimm_bus, &ndr_desc)) goto err_free_nd_set; return 0; err_free_nd_set: kfree(nd_set); return -ENXIO; } static int ramdax_register_dimm(struct resource *res, void *data) { resource_size_t start = res->start; resource_size_t size = resource_size(res); unsigned long flags = 0, cmd_mask = 0; struct nvdimm_bus *nvdimm_bus = data; struct ramdax_dimm *dimm; int err; dimm = kzalloc(sizeof(*dimm), GFP_KERNEL); if (!dimm) return -ENOMEM; dimm->label_area = memremap(start + size - LABEL_AREA_SIZE, LABEL_AREA_SIZE, MEMREMAP_WB); if (!dimm->label_area) { err = -ENOMEM; goto err_free_dimm; } set_bit(NDD_LABELING, &flags); set_bit(NDD_REGISTER_SYNC, &flags); set_bit(ND_CMD_GET_CONFIG_SIZE, &cmd_mask); set_bit(ND_CMD_GET_CONFIG_DATA, &cmd_mask); set_bit(ND_CMD_SET_CONFIG_DATA, &cmd_mask); dimm->nvdimm = nvdimm_create(nvdimm_bus, dimm, /* dimm_attribute_groups */ NULL, flags, cmd_mask, 0, NULL); if (!dimm->nvdimm) { err = -ENOMEM; goto err_unmap_label; } err = ramdax_register_region(res, dimm->nvdimm, nvdimm_bus); if (err) goto err_remove_nvdimm; return 0; err_remove_nvdimm: nvdimm_delete(dimm->nvdimm); err_unmap_label: memunmap(dimm->label_area); err_free_dimm: kfree(dimm); return err; } static int ramdax_get_config_size(struct nvdimm *nvdimm, int buf_len, struct nd_cmd_get_config_size *cmd) { if (sizeof(*cmd) > buf_len) return -EINVAL; *cmd = (struct nd_cmd_get_config_size){ .status = 0, .config_size = LABEL_AREA_SIZE, .max_xfer = 8, }; return 0; } static int ramdax_get_config_data(struct nvdimm *nvdimm, int buf_len, struct nd_cmd_get_config_data_hdr *cmd) { struct ramdax_dimm *dimm = nvdimm_provider_data(nvdimm); if (sizeof(*cmd) > buf_len) return -EINVAL; if (struct_size(cmd, out_buf, cmd->in_length) > buf_len) return -EINVAL; if (size_add(cmd->in_offset, cmd->in_length) > LABEL_AREA_SIZE) return -EINVAL; memcpy(cmd->out_buf, dimm->label_area + cmd->in_offset, cmd->in_length); return 0; } static int ramdax_set_config_data(struct nvdimm *nvdimm, int buf_len, struct nd_cmd_set_config_hdr *cmd) { struct ramdax_dimm *dimm = nvdimm_provider_data(nvdimm); if (sizeof(*cmd) > buf_len) return -EINVAL; if (struct_size(cmd, in_buf, cmd->in_length) > buf_len) return -EINVAL; if (size_add(cmd->in_offset, cmd->in_length) > LABEL_AREA_SIZE) return -EINVAL; memcpy(dimm->label_area + cmd->in_offset, cmd->in_buf, cmd->in_length); return 0; } static int ramdax_nvdimm_ctl(struct nvdimm *nvdimm, unsigned int cmd, void *buf, unsigned int buf_len) { unsigned long cmd_mask = nvdimm_cmd_mask(nvdimm); if (!test_bit(cmd, &cmd_mask)) return -ENOTTY; switch (cmd) { case ND_CMD_GET_CONFIG_SIZE: return ramdax_get_config_size(nvdimm, buf_len, buf); case ND_CMD_GET_CONFIG_DATA: return ramdax_get_config_data(nvdimm, buf_len, buf); case ND_CMD_SET_CONFIG_DATA: return ramdax_set_config_data(nvdimm, buf_len, buf); default: return -ENOTTY; } } static int ramdax_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm, unsigned int cmd, void *buf, unsigned int buf_len, int *cmd_rc) { /* * No firmware response to translate, let the transport error * code take precedence. */ *cmd_rc = 0; if (!nvdimm) return -ENOTTY; return ramdax_nvdimm_ctl(nvdimm, cmd, buf, buf_len); } #ifdef CONFIG_OF static const struct of_device_id ramdax_of_matches[] = { { .compatible = "pmem-region", }, { }, }; #endif static int ramdax_probe_of(struct platform_device *pdev, struct nvdimm_bus *bus, struct device_node *np) { int err; if (!of_match_node(ramdax_of_matches, np)) return -ENODEV; for (int i = 0; i < pdev->num_resources; i++) { err = ramdax_register_dimm(&pdev->resource[i], bus); if (err) goto err_unregister; } return 0; err_unregister: /* * FIXME: should we unregister the dimms that were registered * successfully */ return err; } static int ramdax_probe(struct platform_device *pdev) { static struct nvdimm_bus_descriptor nd_desc; struct device *dev = &pdev->dev; struct nvdimm_bus *nvdimm_bus; struct device_node *np; int rc = -ENXIO; nd_desc.provider_name = "ramdax"; nd_desc.module = THIS_MODULE; nd_desc.ndctl = ramdax_ctl; nvdimm_bus = nvdimm_bus_register(dev, &nd_desc); if (!nvdimm_bus) goto err; np = dev_of_node(&pdev->dev); if (np) rc = ramdax_probe_of(pdev, nvdimm_bus, np); else rc = walk_iomem_res_desc(IORES_DESC_PERSISTENT_MEMORY_LEGACY, IORESOURCE_MEM, 0, -1, nvdimm_bus, ramdax_register_dimm); if (rc) goto err; platform_set_drvdata(pdev, nvdimm_bus); return 0; err: nvdimm_bus_unregister(nvdimm_bus); return rc; } static struct platform_driver ramdax_driver = { .probe = ramdax_probe, .remove = ramdax_remove, .driver = { .name = "ramdax", }, }; module_platform_driver(ramdax_driver); MODULE_DESCRIPTION("NVDIMM support for e820 type-12 memory and OF pmem-region"); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Microsoft Corporation");