arch/avr8/arch_hugemem.c

Go to the documentation of this file.

#include <hugemem.h>
#include <assert.h>


#if defined(CONFIG_HAVE_HUGEMEM) || defined(__DOXYGEN__)
# if defined(__GNUC__) || defined(__DOXYGEN__)
uint_fast16_t hugemem_read16(const hugemem_ptr_t from)
{
        uint16_t value;

        asm(
                "movw r30, %A1 \n\t"
                "out %2, %C1 \n\t"
                "ld %A0, Z+ \n\t"
                "ld %B0, Z \n\t"
                "out %2, __zero_reg__ \n\t"
                : "=r"(value)
                : "r"(from), "i"(CPU_REG(RAMPZ))
                : "r30", "r31"
        );

        return value;
}

uint_fast32_t hugemem_read32(const hugemem_ptr_t from)
{
        uint32_t value;

        asm(
                "movw r30, %A1 \n\t"
                "out %2, %C1 \n\t"
                "ld %A0, Z+ \n\t"
                "ld %B0, Z+ \n\t"
                "ld %C0, Z+ \n\t"
                "ld %D0, Z \n\t"
                "out %2, __zero_reg__ \n\t"
                : "=r"(value)
                : "r"(from), "i"(CPU_REG(RAMPZ))
                : "r30", "r31"
        );

        return value;
}

void hugemem_read_block(void *to, const hugemem_ptr_t from, size_t size)
{
        // Ensure that the address range to copy to is within 64 kB boundary.
        assert(((uint32_t)to + size) <= 0x10000);

        if (size > 0) {
                asm volatile(
                        "movw r30, %A2 \n\t"
                        "out %3, %C2 \n\t"
                        "get_%=: \n\t"
                        "ld __tmp_reg__, Z+ \n\t"
                        "st X+, __tmp_reg__ \n\t"
                        "sbiw %A1, 1 \n\t"
                        "brne get_%= \n\t"
                        "out %3, __zero_reg__ \n\t"
                        : "+x"(to), "+w"(size)
                        : "r"(from), "i"(CPU_REG(RAMPZ))
                        : "r30", "r31"
                );
        }
}

void hugemem_write16(hugemem_ptr_t to, uint_fast16_t val)
{
        asm(
                "movw r30, %A0 \n\t"
                "out %2, %C0 \n\t"
                "st Z+, %A1 \n\t"
                "st Z, %B1 \n\t"
                "out %2, __zero_reg__ \n\t"
                :
                : "r"(to), "r"(val), "i"(CPU_REG(RAMPZ))
                : "r30", "r31"
        );
}

void hugemem_write32(hugemem_ptr_t to, uint_fast32_t val)
{
        asm(
                "movw r30, %A0 \n\t"
                "out %2, %C0 \n\t"
                "st Z+, %A1 \n\t"
                "st Z+, %B1 \n\t"
                "st Z+, %C1 \n\t"
                "st Z, %D1 \n\t"
                "out %2, __zero_reg__ \n\t"
                :
                : "r"(to), "r"(val), "i"(CPU_REG(RAMPZ))
                : "r30", "r31"
        );
}

void hugemem_write_block(hugemem_ptr_t to, const void *from, size_t size)
{
        // Ensure that the address range to copy from is within 64 kB boundary.
        assert(((uint32_t)from + size) <= 0x10000);

        if (size > 0) {
                asm volatile(
                        "movw r30, %A2 \n\t"
                        "out %3, %C2 \n\t"
                        "put_%=: \n\t"
                        "ld __tmp_reg__, X+ \n\t"
                        "st Z+, __tmp_reg__ \n\t"
                        "sbiw %A1, 1 \n\t"
                        "brne put_%= \n\t"
                        "out %3, __zero_reg__ \n\t"
                        : "+x"(from), "+w"(size)
                        : "r"(to), "i"(CPU_REG(RAMPZ))
                        : "r30", "r31"
                );
        }
}
# endif /* __GNUC__ */

# ifdef __ICCAVR__
void hugemem_read_block(void *to, const hugemem_ptr_t from, size_t size)
{
        uint8_t *to_ptr;
        uint8_t __huge *from_ptr;

        // Ensure that the address range to copy to is within 64 kB boundary.
        assert(((uint32_t)to + size) <= 0x10000);

        to_ptr = (uint8_t *)to;
        from_ptr = (uint8_t __huge *)from;

        for (; size > 0; size--) {
                *to_ptr++ = *from_ptr++;
        }
}

void hugemem_write_block(hugemem_ptr_t to, const void *from, size_t size)
{
        uint8_t __huge *to_ptr;
        uint8_t *from_ptr;

        // Ensure that the address range to copy from is within 64 kB boundary.
        assert(((uint32_t)from + size) <= 0x10000);

        to_ptr = (uint8_t __huge *)to;
        from_ptr = (uint8_t *)from;

        for (; size > 0; size--) {
                *to_ptr++ = *from_ptr++;
        }
}
# endif /* __ICCAVR__ */
#endif /* CONFIG_HAVE_HUGEMEM */

---