// SPDX-License-Identifier: GPL-2.0+

#include <linux/io.h>
#include "ipmi_si.h"

static unsigned char intf_mem_inb(const struct si_sm_io *io,
                                  unsigned int offset)
{
        return readb((io->addr)+(offset * io->regspacing));
}

static void intf_mem_outb(const struct si_sm_io *io, unsigned int offset,
                          unsigned char b)
{
        writeb(b, (io->addr)+(offset * io->regspacing));
}

static unsigned char intf_mem_inw(const struct si_sm_io *io,
                                  unsigned int offset)
{
        return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
                & 0xff;
}

static void intf_mem_outw(const struct si_sm_io *io, unsigned int offset,
                          unsigned char b)
{
        writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
}

static unsigned char intf_mem_inl(const struct si_sm_io *io,
                                  unsigned int offset)
{
        return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
                & 0xff;
}

static void intf_mem_outl(const struct si_sm_io *io, unsigned int offset,
                          unsigned char b)
{
        writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
}

#ifdef readq
static unsigned char mem_inq(const struct si_sm_io *io, unsigned int offset)
{
        return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
                & 0xff;
}

static void mem_outq(const struct si_sm_io *io, unsigned int offset,
                     unsigned char b)
{
        writeq((u64)b << io->regshift, (io->addr)+(offset * io->regspacing));
}
#endif

static void mem_region_cleanup(struct si_sm_io *io, int num)
{
        unsigned long addr = io->addr_data;
        int idx;

        for (idx = 0; idx < num; idx++)
                release_mem_region(addr + idx * io->regspacing,
                                   io->regsize);
}

static void mem_cleanup(struct si_sm_io *io)
{
        if (io->addr) {
                iounmap(io->addr);
                mem_region_cleanup(io, io->io_size);
        }
}

int ipmi_si_mem_setup(struct si_sm_io *io)
{
        unsigned long addr = io->addr_data;
        int           mapsize, idx;

        if (!addr)
                return -ENODEV;

        /*
         * Figure out the actual readb/readw/readl/etc routine to use based
         * upon the register size.
         */
        switch (io->regsize) {
        case 1:
                io->inputb = intf_mem_inb;
                io->outputb = intf_mem_outb;
                break;
        case 2:
                io->inputb = intf_mem_inw;
                io->outputb = intf_mem_outw;
                break;
        case 4:
                io->inputb = intf_mem_inl;
                io->outputb = intf_mem_outl;
                break;
#ifdef readq
        case 8:
                io->inputb = mem_inq;
                io->outputb = mem_outq;
                break;
#endif
        default:
                dev_warn(io->dev, "Invalid register size: %d\n",
                         io->regsize);
                return -EINVAL;
        }

        /*
         * Some BIOSes reserve disjoint memory regions in their ACPI
         * tables.  This causes problems when trying to request the
         * entire region.  Therefore we must request each register
         * separately.
         */
        for (idx = 0; idx < io->io_size; idx++) {
                if (request_mem_region(addr + idx * io->regspacing,
                                       io->regsize, SI_DEVICE_NAME) == NULL) {
                        /* Undo allocations */
                        mem_region_cleanup(io, idx);
                        return -EIO;
                }
        }

        /*
         * Calculate the total amount of memory to claim.  This is an
         * unusual looking calculation, but it avoids claiming any
         * more memory than it has to.  It will claim everything
         * between the first address to the end of the last full
         * register.
         */
        mapsize = ((io->io_size * io->regspacing)
                   - (io->regspacing - io->regsize));
        io->addr = ioremap(addr, mapsize);
        if (io->addr == NULL) {
                mem_region_cleanup(io, io->io_size);
                return -EIO;
        }

        io->io_cleanup = mem_cleanup;

        return 0;
}