// SPDX-License-Identifier: GPL-2.0
/*
 * PeeCeeI.c: The emerging standard...
 *
 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
 */

#include <linux/module.h>

#include <asm/io.h>
#include <asm/byteorder.h>

void outsb(unsigned long __addr, const void *src, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;
        const u8 *p = src;

        while (count--)
                __raw_writeb(*p++, addr);
}
EXPORT_SYMBOL(outsb);

void outsw(unsigned long __addr, const void *src, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;

        while (count--) {
                __raw_writew(*(u16 *)src, addr);
                src += sizeof(u16);
        }
}
EXPORT_SYMBOL(outsw);

void outsl(unsigned long __addr, const void *src, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;
        u32 l, l2;

        if (!count)
                return;

        switch (((unsigned long)src) & 0x3) {
        case 0x0:
                /* src is naturally aligned */
                while (count--) {
                        __raw_writel(*(u32 *)src, addr);
                        src += sizeof(u32);
                }
                break;
        case 0x2:
                /* 2-byte alignment */
                while (count--) {
                        l = (*(u16 *)src) << 16;
                        l |= *(u16 *)(src + sizeof(u16));
                        __raw_writel(l, addr);
                        src += sizeof(u32);
                }
                break;
        case 0x1:
                /* Hold three bytes in l each time, grab a byte from l2 */
                l = (*(u8 *)src) << 24;
                l |= (*(u16 *)(src + sizeof(u8))) << 8;
                src += sizeof(u8) + sizeof(u16);
                while (count--) {
                        l2 = *(u32 *)src;
                        l |= (l2 >> 24);
                        __raw_writel(l, addr);
                        l = l2 << 8;
                        src += sizeof(u32);
                }
                break;
        case 0x3:
                /* Hold a byte in l each time, grab 3 bytes from l2 */
                l = (*(u8 *)src) << 24;
                src += sizeof(u8);
                while (count--) {
                        l2 = *(u32 *)src;
                        l |= (l2 >> 8);
                        __raw_writel(l, addr);
                        l = l2 << 24;
                        src += sizeof(u32);
                }
                break;
        }
}
EXPORT_SYMBOL(outsl);

void insb(unsigned long __addr, void *dst, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;

        if (count) {
                u32 *pi;
                u8 *pb = dst;

                while ((((unsigned long)pb) & 0x3) && count--)
                        *pb++ = __raw_readb(addr);
                pi = (u32 *)pb;
                while (count >= 4) {
                        u32 w;

                        w  = (__raw_readb(addr) << 24);
                        w |= (__raw_readb(addr) << 16);
                        w |= (__raw_readb(addr) << 8);
                        w |= (__raw_readb(addr) << 0);
                        *pi++ = w;
                        count -= 4;
                }
                pb = (u8 *)pi;
                while (count--)
                        *pb++ = __raw_readb(addr);
        }
}
EXPORT_SYMBOL(insb);

void insw(unsigned long __addr, void *dst, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;

        if (count) {
                u16 *ps = dst;
                u32 *pi;

                if (((unsigned long)ps) & 0x2) {
                        *ps++ = __raw_readw(addr);
                        count--;
                }
                pi = (u32 *)ps;
                while (count >= 2) {
                        u32 w;

                        w  = __raw_readw(addr) << 16;
                        w |= __raw_readw(addr) << 0;
                        *pi++ = w;
                        count -= 2;
                }
                ps = (u16 *)pi;
                if (count)
                        *ps = __raw_readw(addr);
        }
}
EXPORT_SYMBOL(insw);

void insl(unsigned long __addr, void *dst, unsigned long count)
{
        void __iomem *addr = (void __iomem *) __addr;

        if (count) {
                if ((((unsigned long)dst) & 0x3) == 0) {
                        u32 *pi = dst;
                        while (count--)
                                *pi++ = __raw_readl(addr);
                } else {
                        u32 l = 0, l2, *pi;
                        u16 *ps;
                        u8 *pb;

                        switch (((unsigned long)dst) & 3) {
                        case 0x2:
                                ps = dst;
                                count -= 1;
                                l = __raw_readl(addr);
                                *ps++ = l;
                                pi = (u32 *)ps;
                                while (count--) {
                                        l2 = __raw_readl(addr);
                                        *pi++ = (l << 16) | (l2 >> 16);
                                        l = l2;
                                }
                                ps = (u16 *)pi;
                                *ps = l;
                                break;

                        case 0x1:
                                pb = dst;
                                count -= 1;
                                l = __raw_readl(addr);
                                *pb++ = l >> 24;
                                ps = (u16 *)pb;
                                *ps++ = ((l >> 8) & 0xffff);
                                pi = (u32 *)ps;
                                while (count--) {
                                        l2 = __raw_readl(addr);
                                        *pi++ = (l << 24) | (l2 >> 8);
                                        l = l2;
                                }
                                pb = (u8 *)pi;
                                *pb = l;
                                break;

                        case 0x3:
                                pb = (u8 *)dst;
                                count -= 1;
                                l = __raw_readl(addr);
                                *pb++ = l >> 24;
                                pi = (u32 *)pb;
                                while (count--) {
                                        l2 = __raw_readl(addr);
                                        *pi++ = (l << 8) | (l2 >> 24);
                                        l = l2;
                                }
                                ps = (u16 *)pi;
                                *ps++ = ((l >> 8) & 0xffff);
                                pb = (u8 *)ps;
                                *pb = l;
                                break;
                        }
                }
        }
}
EXPORT_SYMBOL(insl);