/*
 * Copyright (c) 2026 Abdelkader Boudih <freebsd@seuros.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/*
 * /dev/cbmem — ioctl interface for CBMEM entry enumeration and read
 *
 * Provides structured access to coreboot's CBMEM entries without
 * requiring /dev/mem. Entries can be listed (CBMEM_IOC_LIST) or
 * read by ID (CBMEM_IOC_READ).
 */

#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/ioccom.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/uio.h>

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>

#include <dev/coreboot/coreboot.h>

static d_ioctl_t        coreboot_cbmem_ioctl;

static struct cdevsw coreboot_cbmem_cdevsw = {
        .d_version =    D_VERSION,
        .d_ioctl =      coreboot_cbmem_ioctl,
        .d_name =       "cbmem",
};

/*
 * Find a CBMEM entry by its ID.
 */
static struct cbmem_entry_info *
cbmem_find_entry(struct coreboot_softc *sc, uint32_t id)
{
        uint32_t i;

        for (i = 0; i < sc->cbmem_count; i++) {
                if (sc->cbmem_entries[i].id == id)
                        return (&sc->cbmem_entries[i]);
        }
        return (NULL);
}

static int
coreboot_cbmem_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
    struct thread *td)
{
        struct coreboot_softc *sc;
        int error;

        sc = dev->si_drv1;

        switch (cmd) {
        case CBMEM_IOC_LIST: {
                struct cbmem_list *list = (struct cbmem_list *)data;

                list->count = sc->cbmem_count;
                memcpy(list->entries, sc->cbmem_entries,
                    sc->cbmem_count * sizeof(struct cbmem_entry_info));
                error = 0;
                break;
        }

        case CBMEM_IOC_READ: {
                struct cbmem_read_req *req = (struct cbmem_read_req *)data;
                struct cbmem_entry_info *info;
                void *mapped;
                vm_size_t map_size;
                uint64_t paddr;

                info = cbmem_find_entry(sc, req->id);
                if (info == NULL) {
                        error = ENOENT;
                        break;
                }

                if (req->offset >= info->size) {
                        error = EINVAL;
                        break;
                }

                if (req->size > info->size - req->offset)
                        req->size = info->size - req->offset;

                if (req->size == 0) {
                        error = 0;
                        break;
                }

                if (info->address > UINT64_MAX - req->offset) {
                        error = EINVAL;
                        break;
                }
                paddr = info->address + req->offset;
                map_size = req->size;
                mapped = pmap_mapbios((vm_paddr_t)paddr, map_size);
                if (mapped == NULL) {
                        error = ENOMEM;
                        break;
                }

                error = copyout(mapped, req->buffer, req->size);

                pmap_unmapbios(mapped, map_size);
                break;
        }

        default:
                error = ENOTTY;
                break;
        }

        return (error);
}

int
coreboot_cbmem_create(struct coreboot_softc *sc)
{
        struct make_dev_args args;
        int error;

        if (sc->cbmem_count == 0)
                return (ENXIO);

        make_dev_args_init(&args);
        args.mda_devsw = &coreboot_cbmem_cdevsw;
        args.mda_uid = UID_ROOT;
        args.mda_gid = GID_WHEEL;
        args.mda_mode = 0440;
        args.mda_si_drv1 = sc;
        error = make_dev_s(&args, &sc->cbmem_cdev, "cbmem");
        if (error != 0)
                return (error);

        return (0);
}

void
coreboot_cbmem_destroy(struct coreboot_softc *sc)
{

        coreboot_cdev_destroy(&sc->cbmem_cdev);
}