pio.h

/*
 * SPDX-FileCopyrightText: 2025 Tom Hert <git@annsann.eu>
 * SPDX-FileCopyrightText: 2025 HAW Hamburg
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#include <stdint.h>

 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/* JMP Instruction - Section 11.4.2                                           */
/* ========================================================================== */

#define PIO_JMP_COND_ALWAYS     (0)     
#define PIO_JMP_COND_X_ZERO     (1)     
#define PIO_JMP_COND_X_DEC      (2)     
#define PIO_JMP_COND_Y_ZERO     (3)     
#define PIO_JMP_COND_Y_DEC      (4)     
#define PIO_JMP_COND_X_NE_Y     (5)     
#define PIO_JMP_COND_PIN        (6)     
#define PIO_JMP_COND_OSRE_NOT_EMPTY (7) 

#define PIO_JMP(cond, addr) \
    (0b0000000000000000 | (((cond) & 0b111) << 5) | ((addr) & 0b11111))

#define PIO_JMP_ALWAYS(addr)    PIO_JMP(PIO_JMP_COND_ALWAYS, (addr))

#define PIO_JMP_X_ZERO(addr)    PIO_JMP(PIO_JMP_COND_X_ZERO, (addr))

#define PIO_JMP_X_DEC(addr)     PIO_JMP(PIO_JMP_COND_X_DEC, (addr))

#define PIO_JMP_Y_ZERO(addr)    PIO_JMP(PIO_JMP_COND_Y_ZERO, (addr))

#define PIO_JMP_Y_DEC(addr)     PIO_JMP(PIO_JMP_COND_Y_DEC, (addr))

#define PIO_JMP_X_NE_Y(addr)    PIO_JMP(PIO_JMP_COND_X_NE_Y, (addr))

#define PIO_JMP_PIN(addr)       PIO_JMP(PIO_JMP_COND_PIN, (addr))

#define PIO_JMP_OSRE_NOT_EMPTY(addr) PIO_JMP(PIO_JMP_COND_OSRE_NOT_EMPTY, (addr))
 
/* ========================================================================== */
/* WAIT Instruction - Section 11.4.3                                          */
/* ========================================================================== */

#define PIO_WAIT_SRC_GPIO       (0)     
#define PIO_WAIT_SRC_PIN        (1)     
#define PIO_WAIT_SRC_IRQ        (2)     
#define PIO_WAIT_SRC_JMPPIN     (3)     

#define PIO_WAIT_IRQ_IDXMODE_DIRECT (0) 
#define PIO_WAIT_IRQ_IDXMODE_PREV   (1) 
#define PIO_WAIT_IRQ_IDXMODE_REL    (2) 
#define PIO_WAIT_IRQ_IDXMODE_NEXT   (3) 

#define PIO_WAIT(pol, src, index) \
    (0b0010000000000000 | ((pol) ? 0b0000000010000000 : 0) | \
     (((src) & 0b11) << 5) | ((index) & 0b11111))

#define PIO_WAIT_GPIO(pol, gpio) PIO_WAIT((pol), PIO_WAIT_SRC_GPIO, (gpio))

#define PIO_WAIT_PIN(pol, pin)   PIO_WAIT((pol), PIO_WAIT_SRC_PIN, (pin))

#define PIO_WAIT_IRQ(pol, idxmode, irq) \
    PIO_WAIT((pol), PIO_WAIT_SRC_IRQ, (((idxmode) & 0b11) << 3) | ((irq) & 0b111))

#define PIO_WAIT_IRQ_REL(pol, irq) \
    PIO_WAIT_IRQ((pol), PIO_WAIT_IRQ_IDXMODE_REL, (irq))

#define PIO_WAIT_IRQ_PREV(pol, irq) \
    PIO_WAIT_IRQ((pol), PIO_WAIT_IRQ_IDXMODE_PREV, (irq))

#define PIO_WAIT_IRQ_NEXT(pol, irq) \
    PIO_WAIT_IRQ((pol), PIO_WAIT_IRQ_IDXMODE_NEXT, (irq))

#define PIO_WAIT_JMPPIN(pol, offset) \
    PIO_WAIT((pol), PIO_WAIT_SRC_JMPPIN, (offset))
 
/* ========================================================================== */
/* IN Instruction - Section 11.4.4                                            */
/* ========================================================================== */

#define PIO_IN_SRC_PINS         (0)     
#define PIO_IN_SRC_X            (1)     
#define PIO_IN_SRC_Y            (2)     
#define PIO_IN_SRC_NULL         (3)     
#define PIO_IN_SRC_ISR          (6)     
#define PIO_IN_SRC_OSR          (7)     

#define PIO_IN(src, bitcount) \
    (0b0100000000000000 | (((src) & 0b111) << 5) | ((bitcount) & 0b11111))

#define PIO_IN_PINS(bits)       PIO_IN(PIO_IN_SRC_PINS, (bits) & 0b11111)

#define PIO_IN_X(bits)          PIO_IN(PIO_IN_SRC_X, (bits) & 0b11111)

#define PIO_IN_Y(bits)          PIO_IN(PIO_IN_SRC_Y, (bits) & 0b11111)

#define PIO_IN_NULL(bits)       PIO_IN(PIO_IN_SRC_NULL, (bits) & 0b11111)

#define PIO_IN_ISR(bits)        PIO_IN(PIO_IN_SRC_ISR, (bits) & 0b11111)

#define PIO_IN_OSR(bits)        PIO_IN(PIO_IN_SRC_OSR, (bits) & 0b11111)
 
/* ========================================================================== */
/* OUT Instruction - Section 11.4.5                                           */
/* ========================================================================== */

#define PIO_OUT_DEST_PINS       (0)     
#define PIO_OUT_DEST_X          (1)     
#define PIO_OUT_DEST_Y          (2)     
#define PIO_OUT_DEST_NULL       (3)     
#define PIO_OUT_DEST_PINDIRS    (4)     
#define PIO_OUT_DEST_PC         (5)     
#define PIO_OUT_DEST_ISR        (6)     
#define PIO_OUT_DEST_EXEC       (7)     

#define PIO_OUT(dest, bitcount) \
    (0b0110000000000000 | (((dest) & 0b111) << 5) | ((bitcount) & 0b11111))

#define PIO_OUT_PINS(bits)      PIO_OUT(PIO_OUT_DEST_PINS, (bits) & 0b11111)

#define PIO_OUT_X(bits)         PIO_OUT(PIO_OUT_DEST_X, (bits) & 0b11111)

#define PIO_OUT_Y(bits)         PIO_OUT(PIO_OUT_DEST_Y, (bits) & 0b11111)

#define PIO_OUT_NULL(bits)      PIO_OUT(PIO_OUT_DEST_NULL, (bits) & 0b11111)

#define PIO_OUT_PINDIRS(bits)   PIO_OUT(PIO_OUT_DEST_PINDIRS, (bits) & 0b11111)

#define PIO_OUT_PC(bits)        PIO_OUT(PIO_OUT_DEST_PC, (bits) & 0b11111)

#define PIO_OUT_ISR(bits)       PIO_OUT(PIO_OUT_DEST_ISR, (bits) & 0b11111)

#define PIO_OUT_EXEC(bits)      PIO_OUT(PIO_OUT_DEST_EXEC, (bits) & 0b11111)
 
/* ========================================================================== */
/* PUSH Instruction - Section 11.4.6                                          */
/* ========================================================================== */

#define PIO_PUSH(iffull, block) \
    (0b1000000000000000 | ((iffull) ? 0b0000000001000000 : 0) | ((block) ? 0b0000000000100000 : 0))

#define PIO_PUSH_BLOCK()        PIO_PUSH(0, 1)

#define PIO_PUSH_NOBLOCK()      PIO_PUSH(0, 0)

#define PIO_PUSH_IFFULL()       PIO_PUSH(1, 1)

#define PIO_PUSH_IFFULL_NOBLOCK() PIO_PUSH(1, 0)
 
/* ========================================================================== */
/* PULL Instruction - Section 11.4.7                                          */
/* ========================================================================== */

#define PIO_PULL(ifempty, block) \
    (0b1000000010000000 | ((ifempty) ? 0b0000000001000000 : 0) | ((block) ? 0b0000000000100000 : 0))

#define PIO_PULL_BLOCK()        PIO_PULL(0, 1)

#define PIO_PULL_NOBLOCK()      PIO_PULL(0, 0)

#define PIO_PULL_IFEMPTY()      PIO_PULL(1, 1)

#define PIO_PULL_IFEMPTY_NOBLOCK() PIO_PULL(1, 0)
 
/* ========================================================================== */
/* MOV to RX FIFO - Section 11.4.8                                            */
/* ========================================================================== */

#define PIO_MOV_RXFIFO_ISR(idxi, index) \
    (0b1000000000010000 | ((idxi) ? 0b0000000000010000 : 0) | ((index) & 0b0000000000001111))

#define PIO_MOV_RXFIFO_Y_ISR()  PIO_MOV_RXFIFO_ISR(0, 0)

#define PIO_MOV_RXFIFO_IDX_ISR(idx) PIO_MOV_RXFIFO_ISR(1, (idx))
 
/* ========================================================================== */
/* MOV from RX FIFO - Section 11.4.9                                          */
/* ========================================================================== */

#define PIO_MOV_OSR_RXFIFO(idxi, index) \
    (0b1000000010010000 | ((idxi) ? 0b0000000000010000 : 0) | ((index) & 0b0000000000001111))

#define PIO_MOV_OSR_RXFIFO_Y()  PIO_MOV_OSR_RXFIFO(0, 0)

#define PIO_MOV_OSR_RXFIFO_IDX(idx) PIO_MOV_OSR_RXFIFO(1, (idx))
 
/* ========================================================================== */
/* MOV Instruction - Section 11.4.10                                          */
/* ========================================================================== */

#define PIO_MOV_DEST_PINS       (0)     
#define PIO_MOV_DEST_X          (1)     
#define PIO_MOV_DEST_Y          (2)     
#define PIO_MOV_DEST_PINDIRS    (3)     
#define PIO_MOV_DEST_EXEC       (4)     
#define PIO_MOV_DEST_PC         (5)     
#define PIO_MOV_DEST_ISR        (6)     
#define PIO_MOV_DEST_OSR        (7)     

#define PIO_MOV_OP_NONE         (0)     
#define PIO_MOV_OP_INVERT       (1)     
#define PIO_MOV_OP_BITREV       (2)     

#define PIO_MOV_SRC_PINS        (0)     
#define PIO_MOV_SRC_X           (1)     
#define PIO_MOV_SRC_Y           (2)     
#define PIO_MOV_SRC_NULL        (3)     
#define PIO_MOV_SRC_STATUS      (5)     
#define PIO_MOV_SRC_ISR         (6)     
#define PIO_MOV_SRC_OSR         (7)     

#define PIO_MOV(dest, op, src) \
    (0b1010000000000000 | (((dest) & 0b111) << 5) | (((op) & 0b11) << 3) | ((src) & 0b111))
 
/* ========================================================================== */
/* IRQ Instruction - Section 11.4.11                                          */
/* ========================================================================== */

#define PIO_IRQ_IDXMODE_DIRECT  (0)     
#define PIO_IRQ_IDXMODE_PREV    (1)     
#define PIO_IRQ_IDXMODE_REL     (2)     
#define PIO_IRQ_IDXMODE_NEXT    (3)     

#define PIO_IRQ(clr, wait, idxmode, index) \
    (0b1100000000000000 | ((clr) ? 0b0000000001000000 : 0) | ((wait) ? 0b0000000000100000 : 0) | \
     (((idxmode) & 0b11) << 3) | ((index) & 0b111))

#define PIO_IRQ_SET(num)        PIO_IRQ(0, 0, PIO_IRQ_IDXMODE_DIRECT, (num))

#define PIO_IRQ_NOWAIT(num)     PIO_IRQ(0, 0, PIO_IRQ_IDXMODE_DIRECT, (num))

#define PIO_IRQ_WAIT(num)       PIO_IRQ(0, 1, PIO_IRQ_IDXMODE_DIRECT, (num))

#define PIO_IRQ_CLEAR(num)      PIO_IRQ(1, 0, PIO_IRQ_IDXMODE_DIRECT, (num))

#define PIO_IRQ_SET_REL(num)    PIO_IRQ(0, 0, PIO_IRQ_IDXMODE_REL, (num))

#define PIO_IRQ_WAIT_REL(num)   PIO_IRQ(0, 1, PIO_IRQ_IDXMODE_REL, (num))

#define PIO_IRQ_SET_PREV(num)   PIO_IRQ(0, 0, PIO_IRQ_IDXMODE_PREV, (num))

#define PIO_IRQ_SET_NEXT(num)   PIO_IRQ(0, 0, PIO_IRQ_IDXMODE_NEXT, (num))
 
/* ========================================================================== */
/* SET Instruction - Section 11.4.12                                          */
/* ========================================================================== */

#define PIO_SET_DEST_PINS       (0)     
#define PIO_SET_DEST_X          (1)     
#define PIO_SET_DEST_Y          (2)     
#define PIO_SET_DEST_PINDIRS    (4)     

#define PIO_SET(dest, data) \
    (0b1110000000000000 | (((dest) & 0b111) << 5) | ((data) & 0b11111))

#define PIO_SET_PINS(val)       PIO_SET(PIO_SET_DEST_PINS, (val))

#define PIO_SET_X(val)          PIO_SET(PIO_SET_DEST_X, (val))

#define PIO_SET_Y(val)          PIO_SET(PIO_SET_DEST_Y, (val))

#define PIO_SET_PINDIRS(val)    PIO_SET(PIO_SET_DEST_PINDIRS, (val))
 
#ifdef __cplusplus
}
#endif