From 833043f7fd4684fc45ec8fbcd20ce7ced1b1b581 Mon Sep 17 00:00:00 2001 From: Jeff Epler Date: Thu, 12 Dec 2024 13:55:19 -0600 Subject: [PATCH] WIP --- .gitignore | 2 + Makefile | 5 + assemble.py | 27 + piolib/include/hardware/clocks.h | 24 + piolib/include/hardware/gpio.h | 65 + piolib/include/hardware/pio.h | 11 + piolib/include/hardware/pio_instructions.h | 511 ++++ piolib/include/hardware/regs/proc_pio.h | 3222 ++++++++++++++++++++ piolib/include/pico/stdlib.h | 16 + piolib/include/pio_platform.h | 53 + piolib/include/piolib.h | 829 +++++ piolib/include/piolib_priv.h | 16 + piolib/include/rp1_pio_if.h | 249 ++ piolib/pio_rp1.c | 946 ++++++ piolib/piolib.c | 164 + protodemo | Bin 0 -> 190168 bytes protodemo.c | 173 ++ protomatter.pio | 45 + 18 files changed, 6358 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 assemble.py create mode 100644 piolib/include/hardware/clocks.h create mode 100644 piolib/include/hardware/gpio.h create mode 100644 piolib/include/hardware/pio.h create mode 100644 piolib/include/hardware/pio_instructions.h create mode 100644 piolib/include/hardware/regs/proc_pio.h create mode 100644 piolib/include/pico/stdlib.h create mode 100644 piolib/include/pio_platform.h create mode 100644 piolib/include/piolib.h create mode 100644 piolib/include/piolib_priv.h create mode 100644 piolib/include/rp1_pio_if.h create mode 100644 piolib/pio_rp1.c create mode 100644 piolib/piolib.c create mode 100755 protodemo create mode 100644 protodemo.c create mode 100644 protomatter.pio diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3242f51 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.pio.h +prototest diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8f1e273 --- /dev/null +++ b/Makefile @@ -0,0 +1,5 @@ +protodemo: protodemo.c piolib/*.c | protomatter.pio.h + g++ -Og -ggdb -x c++ -Ipiolib/include -o $@ $^ -Wno-narrowing + +protomatter.pio.h: protomatter.pio assemble.py + python assemble.py $< $@ diff --git a/assemble.py b/assemble.py new file mode 100644 index 0000000..1073c96 --- /dev/null +++ b/assemble.py @@ -0,0 +1,27 @@ +import sys +from contextlib import contextmanager +import click +import adafruit_pioasm + +@contextmanager +def temporary_stdout(filename): + old_stdout = sys.stdout + try: + with open(filename, "w", encoding="utf-8") as sys.stdout: + yield sys.stdout + finally: + sys.stdout = old_stdout + +@click.command +@click.argument("infile") +@click.argument("outfile") +def main(infile, outfile): + program_name = infile.rpartition("/")[2].partition(".")[0] + print(program_name) + program = adafruit_pioasm.Program.from_file(infile, build_debuginfo=True) + + with temporary_stdout(outfile): + program.print_c_program(program_name) + +if __name__ == '__main__': + main() diff --git a/piolib/include/hardware/clocks.h b/piolib/include/hardware/clocks.h new file mode 100644 index 0000000..c9c6fc1 --- /dev/null +++ b/piolib/include/hardware/clocks.h @@ -0,0 +1,24 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 Raspberry Pi Ltd. + * All rights reserved. + */ + +#ifndef _HARDWARE_CLOCKS_H +#define _HARDWARE_CLOCKS_H + +enum clock_index { + clk_gpout0 = 0, ///< GPIO Muxing 0 + clk_gpout1, ///< GPIO Muxing 1 + clk_gpout2, ///< GPIO Muxing 2 + clk_gpout3, ///< GPIO Muxing 3 + clk_ref, ///< Watchdog and timers reference clock + clk_sys, ///< Processors, bus fabric, memory, memory mapped registers + clk_peri, ///< Peripheral clock for UART and SPI + clk_usb, ///< USB clock + clk_adc, ///< ADC clock + clk_rtc, ///< Real time clock + CLK_COUNT +}; + +#endif diff --git a/piolib/include/hardware/gpio.h b/piolib/include/hardware/gpio.h new file mode 100644 index 0000000..60282f7 --- /dev/null +++ b/piolib/include/hardware/gpio.h @@ -0,0 +1,65 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 Raspberry Pi Ltd. + * All rights reserved. + */ +#ifndef _HARDWARE_GPIO_H +#define _HARDWARE_GPIO_H + +#include "pio_platform.h" + +#ifndef PARAM_ASSERTIONS_ENABLED_GPIO +#define PARAM_ASSERTIONS_ENABLED_GPIO 0 +#endif + +#define NUM_BANK0_GPIOS 32 + +enum gpio_function { + GPIO_FUNC_XIP = 0, + GPIO_FUNC_SPI = 1, + GPIO_FUNC_UART = 2, + GPIO_FUNC_I2C = 3, + GPIO_FUNC_PWM = 4, + GPIO_FUNC_SIO = 5, + GPIO_FUNC_PIO0 = 6, + GPIO_FUNC_PIO1 = 7, + GPIO_FUNC_GPCK = 8, + GPIO_FUNC_USB = 9, + GPIO_FUNC_NULL = 0x1f, +}; + +#define GPIO_OUT 1 +#define GPIO_IN 0 + +enum gpio_irq_level { + GPIO_IRQ_LEVEL_LOW = 0x1u, + GPIO_IRQ_LEVEL_HIGH = 0x2u, + GPIO_IRQ_EDGE_FALL = 0x4u, + GPIO_IRQ_EDGE_RISE = 0x8u, +}; + +enum gpio_override { + GPIO_OVERRIDE_NORMAL = + 0, ///< peripheral signal selected via \ref gpio_set_function + GPIO_OVERRIDE_INVERT = + 1, ///< invert peripheral signal selected via \ref gpio_set_function + GPIO_OVERRIDE_LOW = 2, ///< drive low/disable output + GPIO_OVERRIDE_HIGH = 3, ///< drive high/enable output +}; +enum gpio_slew_rate { + GPIO_SLEW_RATE_SLOW = 0, ///< Slew rate limiting enabled + GPIO_SLEW_RATE_FAST = 1 ///< Slew rate limiting disabled +}; + +enum gpio_drive_strength { + GPIO_DRIVE_STRENGTH_2MA = 0, ///< 2 mA nominal drive strength + GPIO_DRIVE_STRENGTH_4MA = 1, ///< 4 mA nominal drive strength + GPIO_DRIVE_STRENGTH_8MA = 2, ///< 8 mA nominal drive strength + GPIO_DRIVE_STRENGTH_12MA = 3 ///< 12 mA nominal drive strength +}; + +static inline void check_gpio_param(__unused uint gpio) { + invalid_params_if(GPIO, gpio >= NUM_BANK0_GPIOS); +} + +#endif diff --git a/piolib/include/hardware/pio.h b/piolib/include/hardware/pio.h new file mode 100644 index 0000000..c96e015 --- /dev/null +++ b/piolib/include/hardware/pio.h @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 Raspberry Pi Ltd. + * All rights reserved. + */ +#ifndef _HARDWARE_PIO_H +#define _HARDWARE_PIO_H + +#include "piolib.h" + +#endif diff --git a/piolib/include/hardware/pio_instructions.h b/piolib/include/hardware/pio_instructions.h new file mode 100644 index 0000000..4887f28 --- /dev/null +++ b/piolib/include/hardware/pio_instructions.h @@ -0,0 +1,511 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _HARDWARE_PIO_INSTRUCTIONS_H +#define _HARDWARE_PIO_INSTRUCTIONS_H + +//#include "pico.h" + +/** \brief PIO instruction encoding + * \defgroup pio_instructions pio_instructions + * \ingroup hardware_pio + * + * Functions for generating PIO instruction encodings programmatically. In debug + *builds `PARAM_ASSERTIONS_ENABLED_PIO_INSTRUCTIONS` can be set to 1 to enable + *validation of encoding function parameters. + * + * For fuller descriptions of the instructions in question see the "RP2040 + *Datasheet" + */ + +// PICO_CONFIG: PARAM_ASSERTIONS_ENABLED_PIO_INSTRUCTIONS, Enable/disable +// assertions in the PIO instructions, type=bool, default=0, +// group=pio_instructions +#ifndef PARAM_ASSERTIONS_ENABLED_PIO_INSTRUCTIONS +#define PARAM_ASSERTIONS_ENABLED_PIO_INSTRUCTIONS 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +enum pio_instr_bits { + pio_instr_bits_jmp = 0x0000, + pio_instr_bits_wait = 0x2000, + pio_instr_bits_in = 0x4000, + pio_instr_bits_out = 0x6000, + pio_instr_bits_push = 0x8000, + pio_instr_bits_pull = 0x8080, + pio_instr_bits_mov = 0xa000, + pio_instr_bits_irq = 0xc000, + pio_instr_bits_set = 0xe000, +}; + +#ifndef NDEBUG +#define _PIO_INVALID_IN_SRC 0x08u +#define _PIO_INVALID_OUT_DEST 0x10u +#define _PIO_INVALID_SET_DEST 0x20u +#define _PIO_INVALID_MOV_SRC 0x40u +#define _PIO_INVALID_MOV_DEST 0x80u +#else +#define _PIO_INVALID_IN_SRC 0u +#define _PIO_INVALID_OUT_DEST 0u +#define _PIO_INVALID_SET_DEST 0u +#define _PIO_INVALID_MOV_SRC 0u +#define _PIO_INVALID_MOV_DEST 0u +#endif + +/*! \brief Enumeration of values to pass for source/destination args for + * instruction encoding functions \ingroup pio_instructions + * + * \note Not all values are suitable for all functions. Validity is only checked + * in debug mode when `PARAM_ASSERTIONS_ENABLED_PIO_INSTRUCTIONS` is 1 + */ +enum pio_src_dest { + pio_pins = 0u, + pio_x = 1u, + pio_y = 2u, + pio_null = 3u | _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_DEST, + pio_pindirs = + 4u | _PIO_INVALID_IN_SRC | _PIO_INVALID_MOV_SRC | _PIO_INVALID_MOV_DEST, + pio_exec_mov = 4u | _PIO_INVALID_IN_SRC | _PIO_INVALID_OUT_DEST | + _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_SRC, + pio_status = 5u | _PIO_INVALID_IN_SRC | _PIO_INVALID_OUT_DEST | + _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_DEST, + pio_pc = + 5u | _PIO_INVALID_IN_SRC | _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_SRC, + pio_isr = 6u | _PIO_INVALID_SET_DEST, + pio_osr = 7u | _PIO_INVALID_OUT_DEST | _PIO_INVALID_SET_DEST, + pio_exec_out = 7u | _PIO_INVALID_IN_SRC | _PIO_INVALID_SET_DEST | + _PIO_INVALID_MOV_SRC | _PIO_INVALID_MOV_DEST, +}; + +static inline uint _pio_major_instr_bits(uint instr) { return instr & 0xe000u; } + +static inline uint _pio_encode_instr_and_args(enum pio_instr_bits instr_bits, + uint arg1, uint arg2) { + valid_params_if(PIO_INSTRUCTIONS, arg1 <= 0x7); +#if PARAM_ASSERTIONS_ENABLED(PIO_INSTRUCTIONS) + uint32_t major = _pio_major_instr_bits(instr_bits); + if (major == pio_instr_bits_in || major == pio_instr_bits_out) { + assert(arg2 && arg2 <= 32); + } else { + assert(arg2 <= 31); + } +#endif + return instr_bits | (arg1 << 5u) | (arg2 & 0x1fu); +} + +static inline uint +_pio_encode_instr_and_src_dest(enum pio_instr_bits instr_bits, + enum pio_src_dest dest, uint value) { + return _pio_encode_instr_and_args(instr_bits, dest & 7u, value); +} + +/*! \brief Encode just the delay slot bits of an instruction + * \ingroup pio_instructions + * + * \note This function does not return a valid instruction encoding; instead it + * returns an encoding of the delay slot suitable for `OR`ing with the result of + * an encoding function for an actual instruction. Care should be taken when + * combining the results of this function with the results of \ref + * pio_encode_sideset and \ref pio_encode_sideset_opt as they share the same + * bits within the instruction encoding. + * + * \param cycles the number of cycles 0-31 (or less if side set is being used) + * \return the delay slot bits to be ORed with an instruction encoding + */ +static inline uint pio_encode_delay(uint cycles) { + // note that the maximum cycles will be smaller if sideset_bit_count > 0 + valid_params_if(PIO_INSTRUCTIONS, cycles <= 0x1f); + return cycles << 8u; +} + +/*! \brief Encode just the side set bits of an instruction (in non optional side + * set mode) \ingroup pio_instructions + * + * \note This function does not return a valid instruction encoding; instead it + * returns an encoding of the side set bits suitable for `OR`ing with the result + * of an encoding function for an actual instruction. Care should be taken when + * combining the results of this function with the results of \ref + * pio_encode_delay as they share the same bits within the instruction encoding. + * + * \param sideset_bit_count number of side set bits as would be specified via + * `.sideset` in pioasm \param value the value to sideset on the pins \return + * the side set bits to be ORed with an instruction encoding + */ +static inline uint pio_encode_sideset(uint sideset_bit_count, uint value) { + valid_params_if(PIO_INSTRUCTIONS, + sideset_bit_count >= 1 && sideset_bit_count <= 5); + valid_params_if(PIO_INSTRUCTIONS, value <= ((1u << sideset_bit_count) - 1)); + return value << (13u - sideset_bit_count); +} + +/*! \brief Encode just the side set bits of an instruction (in optional -`opt` + * side set mode) \ingroup pio_instructions + * + * \note This function does not return a valid instruction encoding; instead it + * returns an encoding of the side set bits suitable for `OR`ing with the result + * of an encoding function for an actual instruction. Care should be taken when + * combining the results of this function with the results of \ref + * pio_encode_delay as they share the same bits within the instruction encoding. + * + * \param sideset_bit_count number of side set bits as would be specified via + * `.sideset opt` in pioasm \param value the value to sideset on the pins + * \return the side set bits to be ORed with an instruction encoding + */ +static inline uint pio_encode_sideset_opt(uint sideset_bit_count, uint value) { + valid_params_if(PIO_INSTRUCTIONS, + sideset_bit_count >= 1 && sideset_bit_count <= 4); + valid_params_if(PIO_INSTRUCTIONS, value <= ((1u << sideset_bit_count) - 1)); + return 0x1000u | value << (12u - sideset_bit_count); +} + +/*! \brief Encode an unconditional JMP instruction + * \ingroup pio_instructions + * + * This is the equivalent of `JMP ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 0, addr); +} + +/*! \brief Encode a conditional JMP if scratch X zero instruction + * \ingroup pio_instructions + * + * This is the equivalent of `JMP !X ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_not_x(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 1, addr); +} + +/*! \brief Encode a conditional JMP if scratch X non-zero (and post-decrement X) + * instruction \ingroup pio_instructions + * + * This is the equivalent of `JMP X-- ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_x_dec(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 2, addr); +} + +/*! \brief Encode a conditional JMP if scratch Y zero instruction + * \ingroup pio_instructions + * + * This is the equivalent of `JMP !Y ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_not_y(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 3, addr); +} + +/*! \brief Encode a conditional JMP if scratch Y non-zero (and post-decrement Y) + * instruction \ingroup pio_instructions + * + * This is the equivalent of `JMP Y-- ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_y_dec(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 4, addr); +} + +/*! \brief Encode a conditional JMP if scratch X not equal scratch Y instruction + * \ingroup pio_instructions + * + * This is the equivalent of `JMP X!=Y ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_x_ne_y(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 5, addr); +} + +/*! \brief Encode a conditional JMP if input pin high instruction + * \ingroup pio_instructions + * + * This is the equivalent of `JMP PIN ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_pin(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 6, addr); +} + +/*! \brief Encode a conditional JMP if output shift register not empty + * instruction \ingroup pio_instructions + * + * This is the equivalent of `JMP !OSRE ` + * + * \param addr The target address 0-31 (an absolute address within the PIO + * instruction memory) \return The instruction encoding with 0 delay and no side + * set value \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_jmp_not_osre(uint addr) { + return _pio_encode_instr_and_args(pio_instr_bits_jmp, 7, addr); +} + +static inline uint _pio_encode_irq(bool relative, uint irq) { + valid_params_if(PIO_INSTRUCTIONS, irq <= 7); + return (relative ? 0x10u : 0x0u) | irq; +} + +/*! \brief Encode a WAIT for GPIO pin instruction + * \ingroup pio_instructions + * + * This is the equivalent of `WAIT GPIO ` + * + * \param polarity true for `WAIT 1`, false for `WAIT 0` + * \param gpio The real GPIO number 0-31 + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_wait_gpio(bool polarity, uint gpio) { + return _pio_encode_instr_and_args(pio_instr_bits_wait, + 0u | (polarity ? 4u : 0u), gpio); +} + +/*! \brief Encode a WAIT for pin instruction + * \ingroup pio_instructions + * + * This is the equivalent of `WAIT PIN ` + * + * \param polarity true for `WAIT 1`, false for `WAIT 0` + * \param pin The pin number 0-31 relative to the executing SM's input pin + * mapping \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_wait_pin(bool polarity, uint pin) { + return _pio_encode_instr_and_args(pio_instr_bits_wait, + 1u | (polarity ? 4u : 0u), pin); +} + +/*! \brief Encode a WAIT for IRQ instruction + * \ingroup pio_instructions + * + * This is the equivalent of `WAIT IRQ ` + * + * \param polarity true for `WAIT 1`, false for `WAIT 0` + * \param relative true for a `WAIT IRQ REL`, false for regular `WAIT IRQ + * ` \param irq the irq number 0-7 \return The instruction encoding with 0 + * delay and no side set value \see pio_encode_delay, pio_encode_sideset, + * pio_encode_sideset_opt + */ +static inline uint pio_encode_wait_irq(bool polarity, bool relative, uint irq) { + valid_params_if(PIO_INSTRUCTIONS, irq <= 7); + return _pio_encode_instr_and_args(pio_instr_bits_wait, + 2u | (polarity ? 4u : 0u), + _pio_encode_irq(relative, irq)); +} + +/*! \brief Encode an IN instruction + * \ingroup pio_instructions + * + * This is the equivalent of `IN , ` + * + * \param src The source to take data from + * \param count The number of bits 1-32 + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_in(enum pio_src_dest src, uint count) { + valid_params_if(PIO_INSTRUCTIONS, !(src & _PIO_INVALID_IN_SRC)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_in, src, count); +} + +/*! \brief Encode an OUT instruction + * \ingroup pio_instructions + * + * This is the equivalent of `OUT , ` + * + * \param dest The destination to write data to + * \param count The number of bits 1-32 + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_out(enum pio_src_dest dest, uint count) { + valid_params_if(PIO_INSTRUCTIONS, !(dest & _PIO_INVALID_OUT_DEST)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_out, dest, count); +} + +/*! \brief Encode a PUSH instruction + * \ingroup pio_instructions + * + * This is the equivalent of `PUSH , ` + * + * \param if_full true for `PUSH IF_FULL ...`, false for `PUSH ...` + * \param block true for `PUSH ... BLOCK`, false for `PUSH ...` + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_push(bool if_full, bool block) { + return _pio_encode_instr_and_args( + pio_instr_bits_push, (if_full ? 2u : 0u) | (block ? 1u : 0u), 0); +} + +/*! \brief Encode a PULL instruction + * \ingroup pio_instructions + * + * This is the equivalent of `PULL , ` + * + * \param if_empty true for `PULL IF_EMPTY ...`, false for `PULL ...` + * \param block true for `PULL ... BLOCK`, false for `PULL ...` + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_pull(bool if_empty, bool block) { + return _pio_encode_instr_and_args( + pio_instr_bits_pull, (if_empty ? 2u : 0u) | (block ? 1u : 0u), 0); +} + +/*! \brief Encode a MOV instruction + * \ingroup pio_instructions + * + * This is the equivalent of `MOV , ` + * + * \param dest The destination to write data to + * \param src The source to take data from + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_mov(enum pio_src_dest dest, + enum pio_src_dest src) { + valid_params_if(PIO_INSTRUCTIONS, !(dest & _PIO_INVALID_MOV_DEST)); + valid_params_if(PIO_INSTRUCTIONS, !(src & _PIO_INVALID_MOV_SRC)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_mov, dest, src & 7u); +} + +/*! \brief Encode a MOV instruction with bit invert + * \ingroup pio_instructions + * + * This is the equivalent of `MOV , ~` + * + * \param dest The destination to write inverted data to + * \param src The source to take data from + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_mov_not(enum pio_src_dest dest, + enum pio_src_dest src) { + valid_params_if(PIO_INSTRUCTIONS, !(dest & _PIO_INVALID_MOV_DEST)); + valid_params_if(PIO_INSTRUCTIONS, !(src & _PIO_INVALID_MOV_SRC)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_mov, dest, + (1u << 3u) | (src & 7u)); +} + +/*! \brief Encode a MOV instruction with bit reverse + * \ingroup pio_instructions + * + * This is the equivalent of `MOV , ::` + * + * \param dest The destination to write bit reversed data to + * \param src The source to take data from + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_mov_reverse(enum pio_src_dest dest, + enum pio_src_dest src) { + valid_params_if(PIO_INSTRUCTIONS, !(dest & _PIO_INVALID_MOV_DEST)); + valid_params_if(PIO_INSTRUCTIONS, !(src & _PIO_INVALID_MOV_SRC)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_mov, dest, + (2u << 3u) | (src & 7u)); +} + +/*! \brief Encode a IRQ SET instruction + * \ingroup pio_instructions + * + * This is the equivalent of `IRQ SET ` + * + * \param relative true for a `IRQ SET REL`, false for regular `IRQ SET + * ` \param irq the irq number 0-7 \return The instruction encoding with 0 + * delay and no side set value \see pio_encode_delay, pio_encode_sideset, + * pio_encode_sideset_opt + */ +static inline uint pio_encode_irq_set(bool relative, uint irq) { + return _pio_encode_instr_and_args(pio_instr_bits_irq, 0, + _pio_encode_irq(relative, irq)); +} + +/*! \brief Encode a IRQ WAIT instruction + * \ingroup pio_instructions + * + * This is the equivalent of `IRQ WAIT ` + * + * \param relative true for a `IRQ WAIT REL`, false for regular `IRQ WAIT + * ` \param irq the irq number 0-7 \return The instruction encoding with 0 + * delay and no side set value \see pio_encode_delay, pio_encode_sideset, + * pio_encode_sideset_opt + */ +static inline uint pio_encode_irq_wait(bool relative, uint irq) { + return _pio_encode_instr_and_args(pio_instr_bits_irq, 1, + _pio_encode_irq(relative, irq)); +} + +/*! \brief Encode a IRQ CLEAR instruction + * \ingroup pio_instructions + * + * This is the equivalent of `IRQ CLEAR ` + * + * \param relative true for a `IRQ CLEAR REL`, false for regular `IRQ + * CLEAR ` \param irq the irq number 0-7 \return The instruction encoding + * with 0 delay and no side set value \see pio_encode_delay, pio_encode_sideset, + * pio_encode_sideset_opt + */ +static inline uint pio_encode_irq_clear(bool relative, uint irq) { + return _pio_encode_instr_and_args(pio_instr_bits_irq, 2, + _pio_encode_irq(relative, irq)); +} + +/*! \brief Encode a SET instruction + * \ingroup pio_instructions + * + * This is the equivalent of `SET , ` + * + * \param dest The destination to apply the value to + * \param value The value 0-31 + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_set(enum pio_src_dest dest, uint value) { + valid_params_if(PIO_INSTRUCTIONS, !(dest & _PIO_INVALID_SET_DEST)); + return _pio_encode_instr_and_src_dest(pio_instr_bits_set, dest, value); +} + +/*! \brief Encode a NOP instruction + * \ingroup pio_instructions + * + * This is the equivalent of `NOP` which is itself encoded as `MOV y, y` + * + * \return The instruction encoding with 0 delay and no side set value + * \see pio_encode_delay, pio_encode_sideset, pio_encode_sideset_opt + */ +static inline uint pio_encode_nop(void) { return pio_encode_mov(pio_y, pio_y); } + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/piolib/include/hardware/regs/proc_pio.h b/piolib/include/hardware/regs/proc_pio.h new file mode 100644 index 0000000..9c4cb63 --- /dev/null +++ b/piolib/include/hardware/regs/proc_pio.h @@ -0,0 +1,3222 @@ +/** + * Copyright (c) 2023 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +// ============================================================================= +// Register block : PROC_PIO +// Version : 1 +// Bus type : ahbl +// Description : Programmable IO block +// ============================================================================= +#ifndef HARDWARE_REGS_PROC_PIO_DEFINED +#define HARDWARE_REGS_PROC_PIO_DEFINED +// ============================================================================= +// Register : PROC_PIO_CTRL +// Description : PIO control register +#define PROC_PIO_CTRL_OFFSET _u(0x00000000) +#define PROC_PIO_CTRL_BITS _u(0x00000fff) +#define PROC_PIO_CTRL_RESET _u(0x00000000) +#define PROC_PIO_CTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_CTRL_CLKDIV_RESTART +// Description : Force clock dividers to restart their count and clear +// fractional +// accumulators. Restart multiple dividers to synchronise them. +#define PROC_PIO_CTRL_CLKDIV_RESTART_RESET _u(0x0) +#define PROC_PIO_CTRL_CLKDIV_RESTART_BITS _u(0x00000f00) +#define PROC_PIO_CTRL_CLKDIV_RESTART_MSB _u(11) +#define PROC_PIO_CTRL_CLKDIV_RESTART_LSB _u(8) +#define PROC_PIO_CTRL_CLKDIV_RESTART_ACCESS "SC" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_CTRL_SM_RESTART +// Description : Clear internal SM state which is otherwise difficult to access +// (e.g. shift counters). Self-clearing. +#define PROC_PIO_CTRL_SM_RESTART_RESET _u(0x0) +#define PROC_PIO_CTRL_SM_RESTART_BITS _u(0x000000f0) +#define PROC_PIO_CTRL_SM_RESTART_MSB _u(7) +#define PROC_PIO_CTRL_SM_RESTART_LSB _u(4) +#define PROC_PIO_CTRL_SM_RESTART_ACCESS "SC" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_CTRL_SM_ENABLE +// Description : Enable state machine +#define PROC_PIO_CTRL_SM_ENABLE_RESET _u(0x0) +#define PROC_PIO_CTRL_SM_ENABLE_BITS _u(0x0000000f) +#define PROC_PIO_CTRL_SM_ENABLE_MSB _u(3) +#define PROC_PIO_CTRL_SM_ENABLE_LSB _u(0) +#define PROC_PIO_CTRL_SM_ENABLE_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_FSTAT +// Description : FIFO status register +#define PROC_PIO_FSTAT_OFFSET _u(0x00000004) +#define PROC_PIO_FSTAT_BITS _u(0x0f0f0f0f) +#define PROC_PIO_FSTAT_RESET _u(0x0f000f00) +#define PROC_PIO_FSTAT_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FSTAT_TXEMPTY +// Description : State machine TX FIFO is empty +#define PROC_PIO_FSTAT_TXEMPTY_RESET _u(0xf) +#define PROC_PIO_FSTAT_TXEMPTY_BITS _u(0x0f000000) +#define PROC_PIO_FSTAT_TXEMPTY_MSB _u(27) +#define PROC_PIO_FSTAT_TXEMPTY_LSB _u(24) +#define PROC_PIO_FSTAT_TXEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FSTAT_TXFULL +// Description : State machine TX FIFO is full +#define PROC_PIO_FSTAT_TXFULL_RESET _u(0x0) +#define PROC_PIO_FSTAT_TXFULL_BITS _u(0x000f0000) +#define PROC_PIO_FSTAT_TXFULL_MSB _u(19) +#define PROC_PIO_FSTAT_TXFULL_LSB _u(16) +#define PROC_PIO_FSTAT_TXFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FSTAT_RXEMPTY +// Description : State machine RX FIFO is empty +#define PROC_PIO_FSTAT_RXEMPTY_RESET _u(0xf) +#define PROC_PIO_FSTAT_RXEMPTY_BITS _u(0x00000f00) +#define PROC_PIO_FSTAT_RXEMPTY_MSB _u(11) +#define PROC_PIO_FSTAT_RXEMPTY_LSB _u(8) +#define PROC_PIO_FSTAT_RXEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FSTAT_RXFULL +// Description : State machine RX FIFO is full +#define PROC_PIO_FSTAT_RXFULL_RESET _u(0x0) +#define PROC_PIO_FSTAT_RXFULL_BITS _u(0x0000000f) +#define PROC_PIO_FSTAT_RXFULL_MSB _u(3) +#define PROC_PIO_FSTAT_RXFULL_LSB _u(0) +#define PROC_PIO_FSTAT_RXFULL_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_FDEBUG +// Description : FIFO debug register +#define PROC_PIO_FDEBUG_OFFSET _u(0x00000008) +#define PROC_PIO_FDEBUG_BITS _u(0x0f0f0f0f) +#define PROC_PIO_FDEBUG_RESET _u(0x00000000) +#define PROC_PIO_FDEBUG_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FDEBUG_TXSTALL +// Description : State machine has stalled on empty TX FIFO. Write 1 to clear. +#define PROC_PIO_FDEBUG_TXSTALL_RESET _u(0x0) +#define PROC_PIO_FDEBUG_TXSTALL_BITS _u(0x0f000000) +#define PROC_PIO_FDEBUG_TXSTALL_MSB _u(27) +#define PROC_PIO_FDEBUG_TXSTALL_LSB _u(24) +#define PROC_PIO_FDEBUG_TXSTALL_ACCESS "WC" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FDEBUG_TXOVER +// Description : TX FIFO overflow has occurred. Write 1 to clear. +#define PROC_PIO_FDEBUG_TXOVER_RESET _u(0x0) +#define PROC_PIO_FDEBUG_TXOVER_BITS _u(0x000f0000) +#define PROC_PIO_FDEBUG_TXOVER_MSB _u(19) +#define PROC_PIO_FDEBUG_TXOVER_LSB _u(16) +#define PROC_PIO_FDEBUG_TXOVER_ACCESS "WC" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FDEBUG_RXUNDER +// Description : RX FIFO underflow has occurred. Write 1 to clear. +#define PROC_PIO_FDEBUG_RXUNDER_RESET _u(0x0) +#define PROC_PIO_FDEBUG_RXUNDER_BITS _u(0x00000f00) +#define PROC_PIO_FDEBUG_RXUNDER_MSB _u(11) +#define PROC_PIO_FDEBUG_RXUNDER_LSB _u(8) +#define PROC_PIO_FDEBUG_RXUNDER_ACCESS "WC" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FDEBUG_RXSTALL +// Description : State machine has stalled on full RX FIFO. Write 1 to clear. +#define PROC_PIO_FDEBUG_RXSTALL_RESET _u(0x0) +#define PROC_PIO_FDEBUG_RXSTALL_BITS _u(0x0000000f) +#define PROC_PIO_FDEBUG_RXSTALL_MSB _u(3) +#define PROC_PIO_FDEBUG_RXSTALL_LSB _u(0) +#define PROC_PIO_FDEBUG_RXSTALL_ACCESS "WC" +// ============================================================================= +// Register : PROC_PIO_FLEVEL +// Description : FIFO levels +// These count up to 15 only. When counting higher the extra bit +// is set in flevel2 register and this value saturates +#define PROC_PIO_FLEVEL_OFFSET _u(0x0000000c) +#define PROC_PIO_FLEVEL_BITS _u(0xffffffff) +#define PROC_PIO_FLEVEL_RESET _u(0x00000000) +#define PROC_PIO_FLEVEL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_RX3 +// Description : None +#define PROC_PIO_FLEVEL_RX3_RESET _u(0x0) +#define PROC_PIO_FLEVEL_RX3_BITS _u(0xf0000000) +#define PROC_PIO_FLEVEL_RX3_MSB _u(31) +#define PROC_PIO_FLEVEL_RX3_LSB _u(28) +#define PROC_PIO_FLEVEL_RX3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_TX3 +// Description : None +#define PROC_PIO_FLEVEL_TX3_RESET _u(0x0) +#define PROC_PIO_FLEVEL_TX3_BITS _u(0x0f000000) +#define PROC_PIO_FLEVEL_TX3_MSB _u(27) +#define PROC_PIO_FLEVEL_TX3_LSB _u(24) +#define PROC_PIO_FLEVEL_TX3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_RX2 +// Description : None +#define PROC_PIO_FLEVEL_RX2_RESET _u(0x0) +#define PROC_PIO_FLEVEL_RX2_BITS _u(0x00f00000) +#define PROC_PIO_FLEVEL_RX2_MSB _u(23) +#define PROC_PIO_FLEVEL_RX2_LSB _u(20) +#define PROC_PIO_FLEVEL_RX2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_TX2 +// Description : None +#define PROC_PIO_FLEVEL_TX2_RESET _u(0x0) +#define PROC_PIO_FLEVEL_TX2_BITS _u(0x000f0000) +#define PROC_PIO_FLEVEL_TX2_MSB _u(19) +#define PROC_PIO_FLEVEL_TX2_LSB _u(16) +#define PROC_PIO_FLEVEL_TX2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_RX1 +// Description : None +#define PROC_PIO_FLEVEL_RX1_RESET _u(0x0) +#define PROC_PIO_FLEVEL_RX1_BITS _u(0x0000f000) +#define PROC_PIO_FLEVEL_RX1_MSB _u(15) +#define PROC_PIO_FLEVEL_RX1_LSB _u(12) +#define PROC_PIO_FLEVEL_RX1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_TX1 +// Description : None +#define PROC_PIO_FLEVEL_TX1_RESET _u(0x0) +#define PROC_PIO_FLEVEL_TX1_BITS _u(0x00000f00) +#define PROC_PIO_FLEVEL_TX1_MSB _u(11) +#define PROC_PIO_FLEVEL_TX1_LSB _u(8) +#define PROC_PIO_FLEVEL_TX1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_RX0 +// Description : None +#define PROC_PIO_FLEVEL_RX0_RESET _u(0x0) +#define PROC_PIO_FLEVEL_RX0_BITS _u(0x000000f0) +#define PROC_PIO_FLEVEL_RX0_MSB _u(7) +#define PROC_PIO_FLEVEL_RX0_LSB _u(4) +#define PROC_PIO_FLEVEL_RX0_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL_TX0 +// Description : None +#define PROC_PIO_FLEVEL_TX0_RESET _u(0x0) +#define PROC_PIO_FLEVEL_TX0_BITS _u(0x0000000f) +#define PROC_PIO_FLEVEL_TX0_MSB _u(3) +#define PROC_PIO_FLEVEL_TX0_LSB _u(0) +#define PROC_PIO_FLEVEL_TX0_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_FLEVEL2 +// Description : FIFO level extra bits +// These are only used in double fifo mode, and the fifo has more +// than 15 elements +#define PROC_PIO_FLEVEL2_OFFSET _u(0x00000010) +#define PROC_PIO_FLEVEL2_BITS _u(0x11111111) +#define PROC_PIO_FLEVEL2_RESET _u(0x00000000) +#define PROC_PIO_FLEVEL2_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_RX3 +// Description : None +#define PROC_PIO_FLEVEL2_RX3_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_RX3_BITS _u(0x10000000) +#define PROC_PIO_FLEVEL2_RX3_MSB _u(28) +#define PROC_PIO_FLEVEL2_RX3_LSB _u(28) +#define PROC_PIO_FLEVEL2_RX3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_TX3 +// Description : None +#define PROC_PIO_FLEVEL2_TX3_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_TX3_BITS _u(0x01000000) +#define PROC_PIO_FLEVEL2_TX3_MSB _u(24) +#define PROC_PIO_FLEVEL2_TX3_LSB _u(24) +#define PROC_PIO_FLEVEL2_TX3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_RX2 +// Description : None +#define PROC_PIO_FLEVEL2_RX2_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_RX2_BITS _u(0x00100000) +#define PROC_PIO_FLEVEL2_RX2_MSB _u(20) +#define PROC_PIO_FLEVEL2_RX2_LSB _u(20) +#define PROC_PIO_FLEVEL2_RX2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_TX2 +// Description : None +#define PROC_PIO_FLEVEL2_TX2_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_TX2_BITS _u(0x00010000) +#define PROC_PIO_FLEVEL2_TX2_MSB _u(16) +#define PROC_PIO_FLEVEL2_TX2_LSB _u(16) +#define PROC_PIO_FLEVEL2_TX2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_RX1 +// Description : None +#define PROC_PIO_FLEVEL2_RX1_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_RX1_BITS _u(0x00001000) +#define PROC_PIO_FLEVEL2_RX1_MSB _u(12) +#define PROC_PIO_FLEVEL2_RX1_LSB _u(12) +#define PROC_PIO_FLEVEL2_RX1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_TX1 +// Description : None +#define PROC_PIO_FLEVEL2_TX1_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_TX1_BITS _u(0x00000100) +#define PROC_PIO_FLEVEL2_TX1_MSB _u(8) +#define PROC_PIO_FLEVEL2_TX1_LSB _u(8) +#define PROC_PIO_FLEVEL2_TX1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_RX0 +// Description : None +#define PROC_PIO_FLEVEL2_RX0_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_RX0_BITS _u(0x00000010) +#define PROC_PIO_FLEVEL2_RX0_MSB _u(4) +#define PROC_PIO_FLEVEL2_RX0_LSB _u(4) +#define PROC_PIO_FLEVEL2_RX0_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_FLEVEL2_TX0 +// Description : None +#define PROC_PIO_FLEVEL2_TX0_RESET _u(0x0) +#define PROC_PIO_FLEVEL2_TX0_BITS _u(0x00000001) +#define PROC_PIO_FLEVEL2_TX0_MSB _u(0) +#define PROC_PIO_FLEVEL2_TX0_LSB _u(0) +#define PROC_PIO_FLEVEL2_TX0_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_TXF0 +// Description : Direct write access to the TX FIFO for this state machine. Each +// write pushes one word to the FIFO. +#define PROC_PIO_TXF0_OFFSET _u(0x00000014) +#define PROC_PIO_TXF0_BITS _u(0xffffffff) +#define PROC_PIO_TXF0_RESET _u(0x00000000) +#define PROC_PIO_TXF0_WIDTH _u(32) +#define PROC_PIO_TXF0_MSB _u(31) +#define PROC_PIO_TXF0_LSB _u(0) +#define PROC_PIO_TXF0_ACCESS "WF" +// ============================================================================= +// Register : PROC_PIO_TXF1 +// Description : Direct write access to the TX FIFO for this state machine. Each +// write pushes one word to the FIFO. +#define PROC_PIO_TXF1_OFFSET _u(0x00000018) +#define PROC_PIO_TXF1_BITS _u(0xffffffff) +#define PROC_PIO_TXF1_RESET _u(0x00000000) +#define PROC_PIO_TXF1_WIDTH _u(32) +#define PROC_PIO_TXF1_MSB _u(31) +#define PROC_PIO_TXF1_LSB _u(0) +#define PROC_PIO_TXF1_ACCESS "WF" +// ============================================================================= +// Register : PROC_PIO_TXF2 +// Description : Direct write access to the TX FIFO for this state machine. Each +// write pushes one word to the FIFO. +#define PROC_PIO_TXF2_OFFSET _u(0x0000001c) +#define PROC_PIO_TXF2_BITS _u(0xffffffff) +#define PROC_PIO_TXF2_RESET _u(0x00000000) +#define PROC_PIO_TXF2_WIDTH _u(32) +#define PROC_PIO_TXF2_MSB _u(31) +#define PROC_PIO_TXF2_LSB _u(0) +#define PROC_PIO_TXF2_ACCESS "WF" +// ============================================================================= +// Register : PROC_PIO_TXF3 +// Description : Direct write access to the TX FIFO for this state machine. Each +// write pushes one word to the FIFO. +#define PROC_PIO_TXF3_OFFSET _u(0x00000020) +#define PROC_PIO_TXF3_BITS _u(0xffffffff) +#define PROC_PIO_TXF3_RESET _u(0x00000000) +#define PROC_PIO_TXF3_WIDTH _u(32) +#define PROC_PIO_TXF3_MSB _u(31) +#define PROC_PIO_TXF3_LSB _u(0) +#define PROC_PIO_TXF3_ACCESS "WF" +// ============================================================================= +// Register : PROC_PIO_RXF0 +// Description : Direct read access to the RX FIFO for this state machine. Each +// read pops one word from the FIFO. +#define PROC_PIO_RXF0_OFFSET _u(0x00000024) +#define PROC_PIO_RXF0_BITS _u(0xffffffff) +#define PROC_PIO_RXF0_RESET "-" +#define PROC_PIO_RXF0_WIDTH _u(32) +#define PROC_PIO_RXF0_MSB _u(31) +#define PROC_PIO_RXF0_LSB _u(0) +#define PROC_PIO_RXF0_ACCESS "RF" +// ============================================================================= +// Register : PROC_PIO_RXF1 +// Description : Direct read access to the RX FIFO for this state machine. Each +// read pops one word from the FIFO. +#define PROC_PIO_RXF1_OFFSET _u(0x00000028) +#define PROC_PIO_RXF1_BITS _u(0xffffffff) +#define PROC_PIO_RXF1_RESET "-" +#define PROC_PIO_RXF1_WIDTH _u(32) +#define PROC_PIO_RXF1_MSB _u(31) +#define PROC_PIO_RXF1_LSB _u(0) +#define PROC_PIO_RXF1_ACCESS "RF" +// ============================================================================= +// Register : PROC_PIO_RXF2 +// Description : Direct read access to the RX FIFO for this state machine. Each +// read pops one word from the FIFO. +#define PROC_PIO_RXF2_OFFSET _u(0x0000002c) +#define PROC_PIO_RXF2_BITS _u(0xffffffff) +#define PROC_PIO_RXF2_RESET "-" +#define PROC_PIO_RXF2_WIDTH _u(32) +#define PROC_PIO_RXF2_MSB _u(31) +#define PROC_PIO_RXF2_LSB _u(0) +#define PROC_PIO_RXF2_ACCESS "RF" +// ============================================================================= +// Register : PROC_PIO_RXF3 +// Description : Direct read access to the RX FIFO for this state machine. Each +// read pops one word from the FIFO. +#define PROC_PIO_RXF3_OFFSET _u(0x00000030) +#define PROC_PIO_RXF3_BITS _u(0xffffffff) +#define PROC_PIO_RXF3_RESET "-" +#define PROC_PIO_RXF3_WIDTH _u(32) +#define PROC_PIO_RXF3_MSB _u(31) +#define PROC_PIO_RXF3_LSB _u(0) +#define PROC_PIO_RXF3_ACCESS "RF" +// ============================================================================= +// Register : PROC_PIO_IRQ +// Description : Interrupt request register. Write 1 to clear +#define PROC_PIO_IRQ_OFFSET _u(0x00000034) +#define PROC_PIO_IRQ_BITS _u(0x000000ff) +#define PROC_PIO_IRQ_RESET _u(0x00000000) +#define PROC_PIO_IRQ_WIDTH _u(32) +#define PROC_PIO_IRQ_MSB _u(7) +#define PROC_PIO_IRQ_LSB _u(0) +#define PROC_PIO_IRQ_ACCESS "WC" +// ============================================================================= +// Register : PROC_PIO_IRQ_FORCE +// Description : Writing a 1 to each of these bits will forcibly assert the +// corresponding IRQ. +// Note this is different to the INTF register: writing here +// affects PIO internal +// state. INTF just asserts the processor-facing IRQ signal for +// testing ISRs, +// and is not visible to the state machines. +#define PROC_PIO_IRQ_FORCE_OFFSET _u(0x00000038) +#define PROC_PIO_IRQ_FORCE_BITS _u(0x000000ff) +#define PROC_PIO_IRQ_FORCE_RESET _u(0x00000000) +#define PROC_PIO_IRQ_FORCE_WIDTH _u(32) +#define PROC_PIO_IRQ_FORCE_MSB _u(7) +#define PROC_PIO_IRQ_FORCE_LSB _u(0) +#define PROC_PIO_IRQ_FORCE_ACCESS "WF" +// ============================================================================= +// Register : PROC_PIO_INPUT_SYNC_BYPASS +// Description : There is a 2-flipflop synchronizer on each GPIO input, which +// protects +// PIO logic from metastabilities. This increases input delay, and +// for fast +// synchronous IO (e.g. SPI) these synchronizers may need to be +// bypassed. +// Each bit in this register corresponds to one GPIO. +// 0 -> input is synchronized (default) +// 1 -> synchronizer is bypassed +// If in doubt, leave this register as all zeroes. +#define PROC_PIO_INPUT_SYNC_BYPASS_OFFSET _u(0x0000003c) +#define PROC_PIO_INPUT_SYNC_BYPASS_BITS _u(0xffffffff) +#define PROC_PIO_INPUT_SYNC_BYPASS_RESET _u(0x00000000) +#define PROC_PIO_INPUT_SYNC_BYPASS_WIDTH _u(32) +#define PROC_PIO_INPUT_SYNC_BYPASS_MSB _u(31) +#define PROC_PIO_INPUT_SYNC_BYPASS_LSB _u(0) +#define PROC_PIO_INPUT_SYNC_BYPASS_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_DBG_PADOUT +// Description : Read to sample the pad output values PIO is currently driving +// to the GPIOs. +#define PROC_PIO_DBG_PADOUT_OFFSET _u(0x00000040) +#define PROC_PIO_DBG_PADOUT_BITS _u(0xffffffff) +#define PROC_PIO_DBG_PADOUT_RESET _u(0x00000000) +#define PROC_PIO_DBG_PADOUT_WIDTH _u(32) +#define PROC_PIO_DBG_PADOUT_MSB _u(31) +#define PROC_PIO_DBG_PADOUT_LSB _u(0) +#define PROC_PIO_DBG_PADOUT_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_DBG_PADOE +// Description : Read to sample the pad output enables (direction) PIO is +// currently driving to the GPIOs. +#define PROC_PIO_DBG_PADOE_OFFSET _u(0x00000044) +#define PROC_PIO_DBG_PADOE_BITS _u(0xffffffff) +#define PROC_PIO_DBG_PADOE_RESET _u(0x00000000) +#define PROC_PIO_DBG_PADOE_WIDTH _u(32) +#define PROC_PIO_DBG_PADOE_MSB _u(31) +#define PROC_PIO_DBG_PADOE_LSB _u(0) +#define PROC_PIO_DBG_PADOE_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_DBG_CFGINFO +// Description : The PIO hardware has some free parameters that may vary between +// chip products. +// These should be provided in the chip datasheet, but are also +// exposed here. +#define PROC_PIO_DBG_CFGINFO_OFFSET _u(0x00000048) +#define PROC_PIO_DBG_CFGINFO_BITS _u(0x003f0f3f) +#define PROC_PIO_DBG_CFGINFO_RESET _u(0x00000000) +#define PROC_PIO_DBG_CFGINFO_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_DBG_CFGINFO_IMEM_SIZE +// Description : The size of the instruction memory, measured in units of one +// instruction +#define PROC_PIO_DBG_CFGINFO_IMEM_SIZE_RESET "-" +#define PROC_PIO_DBG_CFGINFO_IMEM_SIZE_BITS _u(0x003f0000) +#define PROC_PIO_DBG_CFGINFO_IMEM_SIZE_MSB _u(21) +#define PROC_PIO_DBG_CFGINFO_IMEM_SIZE_LSB _u(16) +#define PROC_PIO_DBG_CFGINFO_IMEM_SIZE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_DBG_CFGINFO_SM_COUNT +// Description : The number of state machines this PIO instance is equipped +// with. +#define PROC_PIO_DBG_CFGINFO_SM_COUNT_RESET "-" +#define PROC_PIO_DBG_CFGINFO_SM_COUNT_BITS _u(0x00000f00) +#define PROC_PIO_DBG_CFGINFO_SM_COUNT_MSB _u(11) +#define PROC_PIO_DBG_CFGINFO_SM_COUNT_LSB _u(8) +#define PROC_PIO_DBG_CFGINFO_SM_COUNT_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_DBG_CFGINFO_FIFO_DEPTH +// Description : The depth of the state machine TX/RX FIFOs, measured in words. +// Joining fifos via SHIFTCTRL_FJOIN gives one FIFO with double +// this depth. +#define PROC_PIO_DBG_CFGINFO_FIFO_DEPTH_RESET "-" +#define PROC_PIO_DBG_CFGINFO_FIFO_DEPTH_BITS _u(0x0000003f) +#define PROC_PIO_DBG_CFGINFO_FIFO_DEPTH_MSB _u(5) +#define PROC_PIO_DBG_CFGINFO_FIFO_DEPTH_LSB _u(0) +#define PROC_PIO_DBG_CFGINFO_FIFO_DEPTH_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM0 +// Description : Write-only access to instruction memory location 0 +#define PROC_PIO_INSTR_MEM0_OFFSET _u(0x0000004c) +#define PROC_PIO_INSTR_MEM0_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM0_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM0_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM0_MSB _u(15) +#define PROC_PIO_INSTR_MEM0_LSB _u(0) +#define PROC_PIO_INSTR_MEM0_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM1 +// Description : Write-only access to instruction memory location 1 +#define PROC_PIO_INSTR_MEM1_OFFSET _u(0x00000050) +#define PROC_PIO_INSTR_MEM1_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM1_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM1_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM1_MSB _u(15) +#define PROC_PIO_INSTR_MEM1_LSB _u(0) +#define PROC_PIO_INSTR_MEM1_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM2 +// Description : Write-only access to instruction memory location 2 +#define PROC_PIO_INSTR_MEM2_OFFSET _u(0x00000054) +#define PROC_PIO_INSTR_MEM2_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM2_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM2_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM2_MSB _u(15) +#define PROC_PIO_INSTR_MEM2_LSB _u(0) +#define PROC_PIO_INSTR_MEM2_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM3 +// Description : Write-only access to instruction memory location 3 +#define PROC_PIO_INSTR_MEM3_OFFSET _u(0x00000058) +#define PROC_PIO_INSTR_MEM3_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM3_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM3_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM3_MSB _u(15) +#define PROC_PIO_INSTR_MEM3_LSB _u(0) +#define PROC_PIO_INSTR_MEM3_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM4 +// Description : Write-only access to instruction memory location 4 +#define PROC_PIO_INSTR_MEM4_OFFSET _u(0x0000005c) +#define PROC_PIO_INSTR_MEM4_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM4_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM4_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM4_MSB _u(15) +#define PROC_PIO_INSTR_MEM4_LSB _u(0) +#define PROC_PIO_INSTR_MEM4_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM5 +// Description : Write-only access to instruction memory location 5 +#define PROC_PIO_INSTR_MEM5_OFFSET _u(0x00000060) +#define PROC_PIO_INSTR_MEM5_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM5_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM5_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM5_MSB _u(15) +#define PROC_PIO_INSTR_MEM5_LSB _u(0) +#define PROC_PIO_INSTR_MEM5_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM6 +// Description : Write-only access to instruction memory location 6 +#define PROC_PIO_INSTR_MEM6_OFFSET _u(0x00000064) +#define PROC_PIO_INSTR_MEM6_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM6_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM6_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM6_MSB _u(15) +#define PROC_PIO_INSTR_MEM6_LSB _u(0) +#define PROC_PIO_INSTR_MEM6_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM7 +// Description : Write-only access to instruction memory location 7 +#define PROC_PIO_INSTR_MEM7_OFFSET _u(0x00000068) +#define PROC_PIO_INSTR_MEM7_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM7_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM7_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM7_MSB _u(15) +#define PROC_PIO_INSTR_MEM7_LSB _u(0) +#define PROC_PIO_INSTR_MEM7_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM8 +// Description : Write-only access to instruction memory location 8 +#define PROC_PIO_INSTR_MEM8_OFFSET _u(0x0000006c) +#define PROC_PIO_INSTR_MEM8_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM8_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM8_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM8_MSB _u(15) +#define PROC_PIO_INSTR_MEM8_LSB _u(0) +#define PROC_PIO_INSTR_MEM8_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM9 +// Description : Write-only access to instruction memory location 9 +#define PROC_PIO_INSTR_MEM9_OFFSET _u(0x00000070) +#define PROC_PIO_INSTR_MEM9_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM9_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM9_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM9_MSB _u(15) +#define PROC_PIO_INSTR_MEM9_LSB _u(0) +#define PROC_PIO_INSTR_MEM9_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM10 +// Description : Write-only access to instruction memory location 10 +#define PROC_PIO_INSTR_MEM10_OFFSET _u(0x00000074) +#define PROC_PIO_INSTR_MEM10_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM10_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM10_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM10_MSB _u(15) +#define PROC_PIO_INSTR_MEM10_LSB _u(0) +#define PROC_PIO_INSTR_MEM10_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM11 +// Description : Write-only access to instruction memory location 11 +#define PROC_PIO_INSTR_MEM11_OFFSET _u(0x00000078) +#define PROC_PIO_INSTR_MEM11_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM11_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM11_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM11_MSB _u(15) +#define PROC_PIO_INSTR_MEM11_LSB _u(0) +#define PROC_PIO_INSTR_MEM11_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM12 +// Description : Write-only access to instruction memory location 12 +#define PROC_PIO_INSTR_MEM12_OFFSET _u(0x0000007c) +#define PROC_PIO_INSTR_MEM12_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM12_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM12_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM12_MSB _u(15) +#define PROC_PIO_INSTR_MEM12_LSB _u(0) +#define PROC_PIO_INSTR_MEM12_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM13 +// Description : Write-only access to instruction memory location 13 +#define PROC_PIO_INSTR_MEM13_OFFSET _u(0x00000080) +#define PROC_PIO_INSTR_MEM13_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM13_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM13_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM13_MSB _u(15) +#define PROC_PIO_INSTR_MEM13_LSB _u(0) +#define PROC_PIO_INSTR_MEM13_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM14 +// Description : Write-only access to instruction memory location 14 +#define PROC_PIO_INSTR_MEM14_OFFSET _u(0x00000084) +#define PROC_PIO_INSTR_MEM14_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM14_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM14_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM14_MSB _u(15) +#define PROC_PIO_INSTR_MEM14_LSB _u(0) +#define PROC_PIO_INSTR_MEM14_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM15 +// Description : Write-only access to instruction memory location 15 +#define PROC_PIO_INSTR_MEM15_OFFSET _u(0x00000088) +#define PROC_PIO_INSTR_MEM15_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM15_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM15_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM15_MSB _u(15) +#define PROC_PIO_INSTR_MEM15_LSB _u(0) +#define PROC_PIO_INSTR_MEM15_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM16 +// Description : Write-only access to instruction memory location 16 +#define PROC_PIO_INSTR_MEM16_OFFSET _u(0x0000008c) +#define PROC_PIO_INSTR_MEM16_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM16_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM16_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM16_MSB _u(15) +#define PROC_PIO_INSTR_MEM16_LSB _u(0) +#define PROC_PIO_INSTR_MEM16_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM17 +// Description : Write-only access to instruction memory location 17 +#define PROC_PIO_INSTR_MEM17_OFFSET _u(0x00000090) +#define PROC_PIO_INSTR_MEM17_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM17_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM17_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM17_MSB _u(15) +#define PROC_PIO_INSTR_MEM17_LSB _u(0) +#define PROC_PIO_INSTR_MEM17_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM18 +// Description : Write-only access to instruction memory location 18 +#define PROC_PIO_INSTR_MEM18_OFFSET _u(0x00000094) +#define PROC_PIO_INSTR_MEM18_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM18_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM18_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM18_MSB _u(15) +#define PROC_PIO_INSTR_MEM18_LSB _u(0) +#define PROC_PIO_INSTR_MEM18_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM19 +// Description : Write-only access to instruction memory location 19 +#define PROC_PIO_INSTR_MEM19_OFFSET _u(0x00000098) +#define PROC_PIO_INSTR_MEM19_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM19_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM19_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM19_MSB _u(15) +#define PROC_PIO_INSTR_MEM19_LSB _u(0) +#define PROC_PIO_INSTR_MEM19_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM20 +// Description : Write-only access to instruction memory location 20 +#define PROC_PIO_INSTR_MEM20_OFFSET _u(0x0000009c) +#define PROC_PIO_INSTR_MEM20_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM20_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM20_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM20_MSB _u(15) +#define PROC_PIO_INSTR_MEM20_LSB _u(0) +#define PROC_PIO_INSTR_MEM20_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM21 +// Description : Write-only access to instruction memory location 21 +#define PROC_PIO_INSTR_MEM21_OFFSET _u(0x000000a0) +#define PROC_PIO_INSTR_MEM21_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM21_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM21_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM21_MSB _u(15) +#define PROC_PIO_INSTR_MEM21_LSB _u(0) +#define PROC_PIO_INSTR_MEM21_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM22 +// Description : Write-only access to instruction memory location 22 +#define PROC_PIO_INSTR_MEM22_OFFSET _u(0x000000a4) +#define PROC_PIO_INSTR_MEM22_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM22_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM22_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM22_MSB _u(15) +#define PROC_PIO_INSTR_MEM22_LSB _u(0) +#define PROC_PIO_INSTR_MEM22_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM23 +// Description : Write-only access to instruction memory location 23 +#define PROC_PIO_INSTR_MEM23_OFFSET _u(0x000000a8) +#define PROC_PIO_INSTR_MEM23_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM23_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM23_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM23_MSB _u(15) +#define PROC_PIO_INSTR_MEM23_LSB _u(0) +#define PROC_PIO_INSTR_MEM23_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM24 +// Description : Write-only access to instruction memory location 24 +#define PROC_PIO_INSTR_MEM24_OFFSET _u(0x000000ac) +#define PROC_PIO_INSTR_MEM24_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM24_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM24_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM24_MSB _u(15) +#define PROC_PIO_INSTR_MEM24_LSB _u(0) +#define PROC_PIO_INSTR_MEM24_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM25 +// Description : Write-only access to instruction memory location 25 +#define PROC_PIO_INSTR_MEM25_OFFSET _u(0x000000b0) +#define PROC_PIO_INSTR_MEM25_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM25_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM25_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM25_MSB _u(15) +#define PROC_PIO_INSTR_MEM25_LSB _u(0) +#define PROC_PIO_INSTR_MEM25_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM26 +// Description : Write-only access to instruction memory location 26 +#define PROC_PIO_INSTR_MEM26_OFFSET _u(0x000000b4) +#define PROC_PIO_INSTR_MEM26_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM26_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM26_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM26_MSB _u(15) +#define PROC_PIO_INSTR_MEM26_LSB _u(0) +#define PROC_PIO_INSTR_MEM26_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM27 +// Description : Write-only access to instruction memory location 27 +#define PROC_PIO_INSTR_MEM27_OFFSET _u(0x000000b8) +#define PROC_PIO_INSTR_MEM27_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM27_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM27_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM27_MSB _u(15) +#define PROC_PIO_INSTR_MEM27_LSB _u(0) +#define PROC_PIO_INSTR_MEM27_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM28 +// Description : Write-only access to instruction memory location 28 +#define PROC_PIO_INSTR_MEM28_OFFSET _u(0x000000bc) +#define PROC_PIO_INSTR_MEM28_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM28_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM28_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM28_MSB _u(15) +#define PROC_PIO_INSTR_MEM28_LSB _u(0) +#define PROC_PIO_INSTR_MEM28_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM29 +// Description : Write-only access to instruction memory location 29 +#define PROC_PIO_INSTR_MEM29_OFFSET _u(0x000000c0) +#define PROC_PIO_INSTR_MEM29_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM29_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM29_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM29_MSB _u(15) +#define PROC_PIO_INSTR_MEM29_LSB _u(0) +#define PROC_PIO_INSTR_MEM29_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM30 +// Description : Write-only access to instruction memory location 30 +#define PROC_PIO_INSTR_MEM30_OFFSET _u(0x000000c4) +#define PROC_PIO_INSTR_MEM30_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM30_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM30_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM30_MSB _u(15) +#define PROC_PIO_INSTR_MEM30_LSB _u(0) +#define PROC_PIO_INSTR_MEM30_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_INSTR_MEM31 +// Description : Write-only access to instruction memory location 31 +#define PROC_PIO_INSTR_MEM31_OFFSET _u(0x000000c8) +#define PROC_PIO_INSTR_MEM31_BITS _u(0x0000ffff) +#define PROC_PIO_INSTR_MEM31_RESET _u(0x00000000) +#define PROC_PIO_INSTR_MEM31_WIDTH _u(32) +#define PROC_PIO_INSTR_MEM31_MSB _u(15) +#define PROC_PIO_INSTR_MEM31_LSB _u(0) +#define PROC_PIO_INSTR_MEM31_ACCESS "WO" +// ============================================================================= +// Register : PROC_PIO_SM0_CLKDIV +// Description : Clock divider register for state machine 0 +// Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256) +#define PROC_PIO_SM0_CLKDIV_OFFSET _u(0x000000cc) +#define PROC_PIO_SM0_CLKDIV_BITS _u(0xffffff00) +#define PROC_PIO_SM0_CLKDIV_RESET _u(0x00010000) +#define PROC_PIO_SM0_CLKDIV_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_CLKDIV_INT +// Description : Effective frequency is sysclk/int. +// Value of 0 is interpreted as max possible value +#define PROC_PIO_SM0_CLKDIV_INT_RESET _u(0x0001) +#define PROC_PIO_SM0_CLKDIV_INT_BITS _u(0xffff0000) +#define PROC_PIO_SM0_CLKDIV_INT_MSB _u(31) +#define PROC_PIO_SM0_CLKDIV_INT_LSB _u(16) +#define PROC_PIO_SM0_CLKDIV_INT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_CLKDIV_FRAC +// Description : Fractional part of clock divider +#define PROC_PIO_SM0_CLKDIV_FRAC_RESET _u(0x00) +#define PROC_PIO_SM0_CLKDIV_FRAC_BITS _u(0x0000ff00) +#define PROC_PIO_SM0_CLKDIV_FRAC_MSB _u(15) +#define PROC_PIO_SM0_CLKDIV_FRAC_LSB _u(8) +#define PROC_PIO_SM0_CLKDIV_FRAC_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_EXECCTRL +// Description : Execution/behavioural settings for state machine 0 +#define PROC_PIO_SM0_EXECCTRL_OFFSET _u(0x000000d0) +#define PROC_PIO_SM0_EXECCTRL_BITS _u(0xffffffbf) +#define PROC_PIO_SM0_EXECCTRL_RESET _u(0x0001f000) +#define PROC_PIO_SM0_EXECCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_EXEC_STALLED +// Description : An instruction written to SMx_INSTR is stalled, and latched by +// the +// state machine. Will clear once the instruction completes. +#define PROC_PIO_SM0_EXECCTRL_EXEC_STALLED_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_EXEC_STALLED_BITS _u(0x80000000) +#define PROC_PIO_SM0_EXECCTRL_EXEC_STALLED_MSB _u(31) +#define PROC_PIO_SM0_EXECCTRL_EXEC_STALLED_LSB _u(31) +#define PROC_PIO_SM0_EXECCTRL_EXEC_STALLED_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_SIDE_EN +// Description : If 1, the delay MSB is used as side-set enable, rather than a +// side-set data bit. This allows instructions to perform side-set +// optionally, +// rather than on every instruction. +#define PROC_PIO_SM0_EXECCTRL_SIDE_EN_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_SIDE_EN_BITS _u(0x40000000) +#define PROC_PIO_SM0_EXECCTRL_SIDE_EN_MSB _u(30) +#define PROC_PIO_SM0_EXECCTRL_SIDE_EN_LSB _u(30) +#define PROC_PIO_SM0_EXECCTRL_SIDE_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR +// Description : Side-set data is asserted to pin OEs instead of pin values +#define PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_BITS _u(0x20000000) +#define PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_MSB _u(29) +#define PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_LSB _u(29) +#define PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_JMP_PIN +// Description : The GPIO number to use as condition for JMP PIN. Unaffected by +// input mapping. +#define PROC_PIO_SM0_EXECCTRL_JMP_PIN_RESET _u(0x00) +#define PROC_PIO_SM0_EXECCTRL_JMP_PIN_BITS _u(0x1f000000) +#define PROC_PIO_SM0_EXECCTRL_JMP_PIN_MSB _u(28) +#define PROC_PIO_SM0_EXECCTRL_JMP_PIN_LSB _u(24) +#define PROC_PIO_SM0_EXECCTRL_JMP_PIN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL +// Description : Which data bit to use for inline OUT enable +#define PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_RESET _u(0x00) +#define PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_BITS _u(0x00f80000) +#define PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_MSB _u(23) +#define PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_LSB _u(19) +#define PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN +// Description : If 1, use a bit of OUT data as an auxiliary write enable +// When used in conjunction with OUT_STICKY, writes with an enable +// of 0 will +// deassert the latest pin write. This can create useful +// masking/override behaviour +// due to the priority ordering of state machine pin writes (SM0 < +// SM1 < ...) +#define PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_BITS _u(0x00040000) +#define PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_MSB _u(18) +#define PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_LSB _u(18) +#define PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_OUT_STICKY +// Description : Continuously assert the most recent OUT/SET to the pins +#define PROC_PIO_SM0_EXECCTRL_OUT_STICKY_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_OUT_STICKY_BITS _u(0x00020000) +#define PROC_PIO_SM0_EXECCTRL_OUT_STICKY_MSB _u(17) +#define PROC_PIO_SM0_EXECCTRL_OUT_STICKY_LSB _u(17) +#define PROC_PIO_SM0_EXECCTRL_OUT_STICKY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_WRAP_TOP +// Description : After reaching this address, execution is wrapped to +// wrap_bottom. +// If the instruction is a jump, and the jump condition is true, +// the jump takes priority. +#define PROC_PIO_SM0_EXECCTRL_WRAP_TOP_RESET _u(0x1f) +#define PROC_PIO_SM0_EXECCTRL_WRAP_TOP_BITS _u(0x0001f000) +#define PROC_PIO_SM0_EXECCTRL_WRAP_TOP_MSB _u(16) +#define PROC_PIO_SM0_EXECCTRL_WRAP_TOP_LSB _u(12) +#define PROC_PIO_SM0_EXECCTRL_WRAP_TOP_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM +// Description : After reaching wrap_top, execution is wrapped to this address. +#define PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_RESET _u(0x00) +#define PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_BITS _u(0x00000f80) +#define PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_MSB _u(11) +#define PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_LSB _u(7) +#define PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_STATUS_SEL +// Description : Comparison used for the MOV x, STATUS instruction. +// 0x0 -> All-ones if TX FIFO level < N, otherwise all-zeroes +// 0x1 -> All-ones if RX FIFO level < N, otherwise all-zeroes +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_RESET _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_BITS _u(0x00000020) +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_MSB _u(5) +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_LSB _u(5) +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_ACCESS "RW" +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_VALUE_TXLEVEL _u(0x0) +#define PROC_PIO_SM0_EXECCTRL_STATUS_SEL_VALUE_RXLEVEL _u(0x1) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_EXECCTRL_STATUS_N +// Description : Comparison level for the MOV x, STATUS instruction +#define PROC_PIO_SM0_EXECCTRL_STATUS_N_RESET _u(0x00) +#define PROC_PIO_SM0_EXECCTRL_STATUS_N_BITS _u(0x0000001f) +#define PROC_PIO_SM0_EXECCTRL_STATUS_N_MSB _u(4) +#define PROC_PIO_SM0_EXECCTRL_STATUS_N_LSB _u(0) +#define PROC_PIO_SM0_EXECCTRL_STATUS_N_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_SHIFTCTRL +// Description : Control behaviour of the input/output shift registers for state +// machine 0 +#define PROC_PIO_SM0_SHIFTCTRL_OFFSET _u(0x000000d4) +#define PROC_PIO_SM0_SHIFTCTRL_BITS _u(0xffff0000) +#define PROC_PIO_SM0_SHIFTCTRL_RESET _u(0x000c0000) +#define PROC_PIO_SM0_SHIFTCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX +// Description : When 1, RX FIFO steals the TX FIFO's storage, and becomes twice +// as deep. +// TX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_RESET _u(0x0) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_BITS _u(0x80000000) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_MSB _u(31) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_LSB _u(31) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX +// Description : When 1, TX FIFO steals the RX FIFO's storage, and becomes twice +// as deep. +// RX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_RESET _u(0x0) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_BITS _u(0x40000000) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_MSB _u(30) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_LSB _u(30) +#define PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH +// Description : Number of bits shifted out of TXSR before autopull or +// conditional pull. +// Write 0 for value of 32. +#define PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_RESET _u(0x00) +#define PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_BITS _u(0x3e000000) +#define PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_MSB _u(29) +#define PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_LSB _u(25) +#define PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH +// Description : Number of bits shifted into RXSR before autopush or conditional +// push. +// Write 0 for value of 32. +#define PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_RESET _u(0x00) +#define PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_BITS _u(0x01f00000) +#define PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_MSB _u(24) +#define PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_LSB _u(20) +#define PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR +// Description : 1 = shift out of output shift register to right. 0 = to left. +#define PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_BITS _u(0x00080000) +#define PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_MSB _u(19) +#define PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_LSB _u(19) +#define PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR +// Description : 1 = shift input shift register to right (data enters from +// left). 0 = to left. +#define PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_BITS _u(0x00040000) +#define PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_MSB _u(18) +#define PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_LSB _u(18) +#define PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_AUTOPULL +// Description : Pull automatically when the output shift register is emptied +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_RESET _u(0x0) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_BITS _u(0x00020000) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_MSB _u(17) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_LSB _u(17) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH +// Description : Push automatically when the input shift register is filled +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_RESET _u(0x0) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_BITS _u(0x00010000) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_MSB _u(16) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_LSB _u(16) +#define PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_ADDR +// Description : Current instruction address of state machine 0 +#define PROC_PIO_SM0_ADDR_OFFSET _u(0x000000d8) +#define PROC_PIO_SM0_ADDR_BITS _u(0x0000001f) +#define PROC_PIO_SM0_ADDR_RESET _u(0x00000000) +#define PROC_PIO_SM0_ADDR_WIDTH _u(32) +#define PROC_PIO_SM0_ADDR_MSB _u(4) +#define PROC_PIO_SM0_ADDR_LSB _u(0) +#define PROC_PIO_SM0_ADDR_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_SM0_INSTR +// Description : Instruction currently being executed by state machine 0 +// Write to execute an instruction immediately (including jumps) +// and then resume execution. +#define PROC_PIO_SM0_INSTR_OFFSET _u(0x000000dc) +#define PROC_PIO_SM0_INSTR_BITS _u(0x0000ffff) +#define PROC_PIO_SM0_INSTR_RESET "-" +#define PROC_PIO_SM0_INSTR_WIDTH _u(32) +#define PROC_PIO_SM0_INSTR_MSB _u(15) +#define PROC_PIO_SM0_INSTR_LSB _u(0) +#define PROC_PIO_SM0_INSTR_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_PINCTRL +// Description : State machine pin control +#define PROC_PIO_SM0_PINCTRL_OFFSET _u(0x000000e0) +#define PROC_PIO_SM0_PINCTRL_BITS _u(0xffffffff) +#define PROC_PIO_SM0_PINCTRL_RESET _u(0x14000000) +#define PROC_PIO_SM0_PINCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_SIDESET_COUNT +// Description : The number of delay bits co-opted for side-set. Inclusive of +// the enable bit, if present. +#define PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_RESET _u(0x0) +#define PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_BITS _u(0xe0000000) +#define PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_MSB _u(31) +#define PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_LSB _u(29) +#define PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_SET_COUNT +// Description : The number of pins asserted by a SET. Max of 5 +#define PROC_PIO_SM0_PINCTRL_SET_COUNT_RESET _u(0x5) +#define PROC_PIO_SM0_PINCTRL_SET_COUNT_BITS _u(0x1c000000) +#define PROC_PIO_SM0_PINCTRL_SET_COUNT_MSB _u(28) +#define PROC_PIO_SM0_PINCTRL_SET_COUNT_LSB _u(26) +#define PROC_PIO_SM0_PINCTRL_SET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_OUT_COUNT +// Description : The number of pins asserted by an OUT. Value of 0 -> 32 pins +#define PROC_PIO_SM0_PINCTRL_OUT_COUNT_RESET _u(0x00) +#define PROC_PIO_SM0_PINCTRL_OUT_COUNT_BITS _u(0x03f00000) +#define PROC_PIO_SM0_PINCTRL_OUT_COUNT_MSB _u(25) +#define PROC_PIO_SM0_PINCTRL_OUT_COUNT_LSB _u(20) +#define PROC_PIO_SM0_PINCTRL_OUT_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_IN_BASE +// Description : The virtual pin corresponding to IN bit 0 +#define PROC_PIO_SM0_PINCTRL_IN_BASE_RESET _u(0x00) +#define PROC_PIO_SM0_PINCTRL_IN_BASE_BITS _u(0x000f8000) +#define PROC_PIO_SM0_PINCTRL_IN_BASE_MSB _u(19) +#define PROC_PIO_SM0_PINCTRL_IN_BASE_LSB _u(15) +#define PROC_PIO_SM0_PINCTRL_IN_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_SIDESET_BASE +// Description : The virtual pin corresponding to delay field bit 0 +#define PROC_PIO_SM0_PINCTRL_SIDESET_BASE_RESET _u(0x00) +#define PROC_PIO_SM0_PINCTRL_SIDESET_BASE_BITS _u(0x00007c00) +#define PROC_PIO_SM0_PINCTRL_SIDESET_BASE_MSB _u(14) +#define PROC_PIO_SM0_PINCTRL_SIDESET_BASE_LSB _u(10) +#define PROC_PIO_SM0_PINCTRL_SIDESET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_SET_BASE +// Description : The virtual pin corresponding to SET bit 0 +#define PROC_PIO_SM0_PINCTRL_SET_BASE_RESET _u(0x00) +#define PROC_PIO_SM0_PINCTRL_SET_BASE_BITS _u(0x000003e0) +#define PROC_PIO_SM0_PINCTRL_SET_BASE_MSB _u(9) +#define PROC_PIO_SM0_PINCTRL_SET_BASE_LSB _u(5) +#define PROC_PIO_SM0_PINCTRL_SET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_PINCTRL_OUT_BASE +// Description : The virtual pin corresponding to OUT bit 0 +#define PROC_PIO_SM0_PINCTRL_OUT_BASE_RESET _u(0x00) +#define PROC_PIO_SM0_PINCTRL_OUT_BASE_BITS _u(0x0000001f) +#define PROC_PIO_SM0_PINCTRL_OUT_BASE_MSB _u(4) +#define PROC_PIO_SM0_PINCTRL_OUT_BASE_LSB _u(0) +#define PROC_PIO_SM0_PINCTRL_OUT_BASE_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_DMACTRL_TX +// Description : State machine DMA control +#define PROC_PIO_SM0_DMACTRL_TX_OFFSET _u(0x000000e4) +#define PROC_PIO_SM0_DMACTRL_TX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM0_DMACTRL_TX_RESET _u(0x00000104) +#define PROC_PIO_SM0_DMACTRL_TX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_TX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM0_DMACTRL_TX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM0_DMACTRL_TX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM0_DMACTRL_TX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM0_DMACTRL_TX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM0_DMACTRL_TX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_TX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM0_DMACTRL_TX_ACTIVE_RESET "-" +#define PROC_PIO_SM0_DMACTRL_TX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM0_DMACTRL_TX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM0_DMACTRL_TX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM0_DMACTRL_TX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM0_DMACTRL_TX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD +// Description : Threshold control. If there are no more than THRESHOLD items in +// the TX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM0_DMACTRL_TX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM0_DMACTRL_RX +// Description : State machine DMA control +#define PROC_PIO_SM0_DMACTRL_RX_OFFSET _u(0x000000e8) +#define PROC_PIO_SM0_DMACTRL_RX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM0_DMACTRL_RX_RESET _u(0x00000104) +#define PROC_PIO_SM0_DMACTRL_RX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_RX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM0_DMACTRL_RX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM0_DMACTRL_RX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM0_DMACTRL_RX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM0_DMACTRL_RX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM0_DMACTRL_RX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_RX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM0_DMACTRL_RX_ACTIVE_RESET "-" +#define PROC_PIO_SM0_DMACTRL_RX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM0_DMACTRL_RX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM0_DMACTRL_RX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM0_DMACTRL_RX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM0_DMACTRL_RX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD +// Description : Threshold control. If there are at least THRESHOLD items in the +// RX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM0_DMACTRL_RX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_CLKDIV +// Description : Clock divider register for state machine 1 +// Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256) +#define PROC_PIO_SM1_CLKDIV_OFFSET _u(0x000000ec) +#define PROC_PIO_SM1_CLKDIV_BITS _u(0xffffff00) +#define PROC_PIO_SM1_CLKDIV_RESET _u(0x00010000) +#define PROC_PIO_SM1_CLKDIV_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_CLKDIV_INT +// Description : Effective frequency is sysclk/int. +// Value of 0 is interpreted as max possible value +#define PROC_PIO_SM1_CLKDIV_INT_RESET _u(0x0001) +#define PROC_PIO_SM1_CLKDIV_INT_BITS _u(0xffff0000) +#define PROC_PIO_SM1_CLKDIV_INT_MSB _u(31) +#define PROC_PIO_SM1_CLKDIV_INT_LSB _u(16) +#define PROC_PIO_SM1_CLKDIV_INT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_CLKDIV_FRAC +// Description : Fractional part of clock divider +#define PROC_PIO_SM1_CLKDIV_FRAC_RESET _u(0x00) +#define PROC_PIO_SM1_CLKDIV_FRAC_BITS _u(0x0000ff00) +#define PROC_PIO_SM1_CLKDIV_FRAC_MSB _u(15) +#define PROC_PIO_SM1_CLKDIV_FRAC_LSB _u(8) +#define PROC_PIO_SM1_CLKDIV_FRAC_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_EXECCTRL +// Description : Execution/behavioural settings for state machine 1 +#define PROC_PIO_SM1_EXECCTRL_OFFSET _u(0x000000f0) +#define PROC_PIO_SM1_EXECCTRL_BITS _u(0xffffffbf) +#define PROC_PIO_SM1_EXECCTRL_RESET _u(0x0001f000) +#define PROC_PIO_SM1_EXECCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_EXEC_STALLED +// Description : An instruction written to SMx_INSTR is stalled, and latched by +// the +// state machine. Will clear once the instruction completes. +#define PROC_PIO_SM1_EXECCTRL_EXEC_STALLED_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_EXEC_STALLED_BITS _u(0x80000000) +#define PROC_PIO_SM1_EXECCTRL_EXEC_STALLED_MSB _u(31) +#define PROC_PIO_SM1_EXECCTRL_EXEC_STALLED_LSB _u(31) +#define PROC_PIO_SM1_EXECCTRL_EXEC_STALLED_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_SIDE_EN +// Description : If 1, the delay MSB is used as side-set enable, rather than a +// side-set data bit. This allows instructions to perform side-set +// optionally, +// rather than on every instruction. +#define PROC_PIO_SM1_EXECCTRL_SIDE_EN_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_SIDE_EN_BITS _u(0x40000000) +#define PROC_PIO_SM1_EXECCTRL_SIDE_EN_MSB _u(30) +#define PROC_PIO_SM1_EXECCTRL_SIDE_EN_LSB _u(30) +#define PROC_PIO_SM1_EXECCTRL_SIDE_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR +// Description : Side-set data is asserted to pin OEs instead of pin values +#define PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR_BITS _u(0x20000000) +#define PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR_MSB _u(29) +#define PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR_LSB _u(29) +#define PROC_PIO_SM1_EXECCTRL_SIDE_PINDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_JMP_PIN +// Description : The GPIO number to use as condition for JMP PIN. Unaffected by +// input mapping. +#define PROC_PIO_SM1_EXECCTRL_JMP_PIN_RESET _u(0x00) +#define PROC_PIO_SM1_EXECCTRL_JMP_PIN_BITS _u(0x1f000000) +#define PROC_PIO_SM1_EXECCTRL_JMP_PIN_MSB _u(28) +#define PROC_PIO_SM1_EXECCTRL_JMP_PIN_LSB _u(24) +#define PROC_PIO_SM1_EXECCTRL_JMP_PIN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL +// Description : Which data bit to use for inline OUT enable +#define PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL_RESET _u(0x00) +#define PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL_BITS _u(0x00f80000) +#define PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL_MSB _u(23) +#define PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL_LSB _u(19) +#define PROC_PIO_SM1_EXECCTRL_OUT_EN_SEL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN +// Description : If 1, use a bit of OUT data as an auxiliary write enable +// When used in conjunction with OUT_STICKY, writes with an enable +// of 0 will +// deassert the latest pin write. This can create useful +// masking/override behaviour +// due to the priority ordering of state machine pin writes (SM0 < +// SM1 < ...) +#define PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN_BITS _u(0x00040000) +#define PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN_MSB _u(18) +#define PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN_LSB _u(18) +#define PROC_PIO_SM1_EXECCTRL_INLINE_OUT_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_OUT_STICKY +// Description : Continuously assert the most recent OUT/SET to the pins +#define PROC_PIO_SM1_EXECCTRL_OUT_STICKY_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_OUT_STICKY_BITS _u(0x00020000) +#define PROC_PIO_SM1_EXECCTRL_OUT_STICKY_MSB _u(17) +#define PROC_PIO_SM1_EXECCTRL_OUT_STICKY_LSB _u(17) +#define PROC_PIO_SM1_EXECCTRL_OUT_STICKY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_WRAP_TOP +// Description : After reaching this address, execution is wrapped to +// wrap_bottom. +// If the instruction is a jump, and the jump condition is true, +// the jump takes priority. +#define PROC_PIO_SM1_EXECCTRL_WRAP_TOP_RESET _u(0x1f) +#define PROC_PIO_SM1_EXECCTRL_WRAP_TOP_BITS _u(0x0001f000) +#define PROC_PIO_SM1_EXECCTRL_WRAP_TOP_MSB _u(16) +#define PROC_PIO_SM1_EXECCTRL_WRAP_TOP_LSB _u(12) +#define PROC_PIO_SM1_EXECCTRL_WRAP_TOP_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM +// Description : After reaching wrap_top, execution is wrapped to this address. +#define PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM_RESET _u(0x00) +#define PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM_BITS _u(0x00000f80) +#define PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM_MSB _u(11) +#define PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM_LSB _u(7) +#define PROC_PIO_SM1_EXECCTRL_WRAP_BOTTOM_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_STATUS_SEL +// Description : Comparison used for the MOV x, STATUS instruction. +// 0x0 -> All-ones if TX FIFO level < N, otherwise all-zeroes +// 0x1 -> All-ones if RX FIFO level < N, otherwise all-zeroes +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_RESET _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_BITS _u(0x00000020) +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_MSB _u(5) +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_LSB _u(5) +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_ACCESS "RW" +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_VALUE_TXLEVEL _u(0x0) +#define PROC_PIO_SM1_EXECCTRL_STATUS_SEL_VALUE_RXLEVEL _u(0x1) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_EXECCTRL_STATUS_N +// Description : Comparison level for the MOV x, STATUS instruction +#define PROC_PIO_SM1_EXECCTRL_STATUS_N_RESET _u(0x00) +#define PROC_PIO_SM1_EXECCTRL_STATUS_N_BITS _u(0x0000001f) +#define PROC_PIO_SM1_EXECCTRL_STATUS_N_MSB _u(4) +#define PROC_PIO_SM1_EXECCTRL_STATUS_N_LSB _u(0) +#define PROC_PIO_SM1_EXECCTRL_STATUS_N_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_SHIFTCTRL +// Description : Control behaviour of the input/output shift registers for state +// machine 1 +#define PROC_PIO_SM1_SHIFTCTRL_OFFSET _u(0x000000f4) +#define PROC_PIO_SM1_SHIFTCTRL_BITS _u(0xffff0000) +#define PROC_PIO_SM1_SHIFTCTRL_RESET _u(0x000c0000) +#define PROC_PIO_SM1_SHIFTCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX +// Description : When 1, RX FIFO steals the TX FIFO's storage, and becomes twice +// as deep. +// TX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX_RESET _u(0x0) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX_BITS _u(0x80000000) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX_MSB _u(31) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX_LSB _u(31) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_RX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX +// Description : When 1, TX FIFO steals the RX FIFO's storage, and becomes twice +// as deep. +// RX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX_RESET _u(0x0) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX_BITS _u(0x40000000) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX_MSB _u(30) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX_LSB _u(30) +#define PROC_PIO_SM1_SHIFTCTRL_FJOIN_TX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH +// Description : Number of bits shifted out of TXSR before autopull or +// conditional pull. +// Write 0 for value of 32. +#define PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH_RESET _u(0x00) +#define PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH_BITS _u(0x3e000000) +#define PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH_MSB _u(29) +#define PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH_LSB _u(25) +#define PROC_PIO_SM1_SHIFTCTRL_PULL_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH +// Description : Number of bits shifted into RXSR before autopush or conditional +// push. +// Write 0 for value of 32. +#define PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH_RESET _u(0x00) +#define PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH_BITS _u(0x01f00000) +#define PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH_MSB _u(24) +#define PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH_LSB _u(20) +#define PROC_PIO_SM1_SHIFTCTRL_PUSH_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR +// Description : 1 = shift out of output shift register to right. 0 = to left. +#define PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR_BITS _u(0x00080000) +#define PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR_MSB _u(19) +#define PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR_LSB _u(19) +#define PROC_PIO_SM1_SHIFTCTRL_OUT_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR +// Description : 1 = shift input shift register to right (data enters from +// left). 0 = to left. +#define PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR_BITS _u(0x00040000) +#define PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR_MSB _u(18) +#define PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR_LSB _u(18) +#define PROC_PIO_SM1_SHIFTCTRL_IN_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_AUTOPULL +// Description : Pull automatically when the output shift register is emptied +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPULL_RESET _u(0x0) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPULL_BITS _u(0x00020000) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPULL_MSB _u(17) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPULL_LSB _u(17) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH +// Description : Push automatically when the input shift register is filled +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH_RESET _u(0x0) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH_BITS _u(0x00010000) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH_MSB _u(16) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH_LSB _u(16) +#define PROC_PIO_SM1_SHIFTCTRL_AUTOPUSH_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_ADDR +// Description : Current instruction address of state machine 1 +#define PROC_PIO_SM1_ADDR_OFFSET _u(0x000000f8) +#define PROC_PIO_SM1_ADDR_BITS _u(0x0000001f) +#define PROC_PIO_SM1_ADDR_RESET _u(0x00000000) +#define PROC_PIO_SM1_ADDR_WIDTH _u(32) +#define PROC_PIO_SM1_ADDR_MSB _u(4) +#define PROC_PIO_SM1_ADDR_LSB _u(0) +#define PROC_PIO_SM1_ADDR_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_SM1_INSTR +// Description : Instruction currently being executed by state machine 1 +// Write to execute an instruction immediately (including jumps) +// and then resume execution. +#define PROC_PIO_SM1_INSTR_OFFSET _u(0x000000fc) +#define PROC_PIO_SM1_INSTR_BITS _u(0x0000ffff) +#define PROC_PIO_SM1_INSTR_RESET "-" +#define PROC_PIO_SM1_INSTR_WIDTH _u(32) +#define PROC_PIO_SM1_INSTR_MSB _u(15) +#define PROC_PIO_SM1_INSTR_LSB _u(0) +#define PROC_PIO_SM1_INSTR_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_PINCTRL +// Description : State machine pin control +#define PROC_PIO_SM1_PINCTRL_OFFSET _u(0x00000100) +#define PROC_PIO_SM1_PINCTRL_BITS _u(0xffffffff) +#define PROC_PIO_SM1_PINCTRL_RESET _u(0x14000000) +#define PROC_PIO_SM1_PINCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_SIDESET_COUNT +// Description : The number of delay bits co-opted for side-set. Inclusive of +// the enable bit, if present. +#define PROC_PIO_SM1_PINCTRL_SIDESET_COUNT_RESET _u(0x0) +#define PROC_PIO_SM1_PINCTRL_SIDESET_COUNT_BITS _u(0xe0000000) +#define PROC_PIO_SM1_PINCTRL_SIDESET_COUNT_MSB _u(31) +#define PROC_PIO_SM1_PINCTRL_SIDESET_COUNT_LSB _u(29) +#define PROC_PIO_SM1_PINCTRL_SIDESET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_SET_COUNT +// Description : The number of pins asserted by a SET. Max of 5 +#define PROC_PIO_SM1_PINCTRL_SET_COUNT_RESET _u(0x5) +#define PROC_PIO_SM1_PINCTRL_SET_COUNT_BITS _u(0x1c000000) +#define PROC_PIO_SM1_PINCTRL_SET_COUNT_MSB _u(28) +#define PROC_PIO_SM1_PINCTRL_SET_COUNT_LSB _u(26) +#define PROC_PIO_SM1_PINCTRL_SET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_OUT_COUNT +// Description : The number of pins asserted by an OUT. Value of 0 -> 32 pins +#define PROC_PIO_SM1_PINCTRL_OUT_COUNT_RESET _u(0x00) +#define PROC_PIO_SM1_PINCTRL_OUT_COUNT_BITS _u(0x03f00000) +#define PROC_PIO_SM1_PINCTRL_OUT_COUNT_MSB _u(25) +#define PROC_PIO_SM1_PINCTRL_OUT_COUNT_LSB _u(20) +#define PROC_PIO_SM1_PINCTRL_OUT_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_IN_BASE +// Description : The virtual pin corresponding to IN bit 0 +#define PROC_PIO_SM1_PINCTRL_IN_BASE_RESET _u(0x00) +#define PROC_PIO_SM1_PINCTRL_IN_BASE_BITS _u(0x000f8000) +#define PROC_PIO_SM1_PINCTRL_IN_BASE_MSB _u(19) +#define PROC_PIO_SM1_PINCTRL_IN_BASE_LSB _u(15) +#define PROC_PIO_SM1_PINCTRL_IN_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_SIDESET_BASE +// Description : The virtual pin corresponding to delay field bit 0 +#define PROC_PIO_SM1_PINCTRL_SIDESET_BASE_RESET _u(0x00) +#define PROC_PIO_SM1_PINCTRL_SIDESET_BASE_BITS _u(0x00007c00) +#define PROC_PIO_SM1_PINCTRL_SIDESET_BASE_MSB _u(14) +#define PROC_PIO_SM1_PINCTRL_SIDESET_BASE_LSB _u(10) +#define PROC_PIO_SM1_PINCTRL_SIDESET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_SET_BASE +// Description : The virtual pin corresponding to SET bit 0 +#define PROC_PIO_SM1_PINCTRL_SET_BASE_RESET _u(0x00) +#define PROC_PIO_SM1_PINCTRL_SET_BASE_BITS _u(0x000003e0) +#define PROC_PIO_SM1_PINCTRL_SET_BASE_MSB _u(9) +#define PROC_PIO_SM1_PINCTRL_SET_BASE_LSB _u(5) +#define PROC_PIO_SM1_PINCTRL_SET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_PINCTRL_OUT_BASE +// Description : The virtual pin corresponding to OUT bit 0 +#define PROC_PIO_SM1_PINCTRL_OUT_BASE_RESET _u(0x00) +#define PROC_PIO_SM1_PINCTRL_OUT_BASE_BITS _u(0x0000001f) +#define PROC_PIO_SM1_PINCTRL_OUT_BASE_MSB _u(4) +#define PROC_PIO_SM1_PINCTRL_OUT_BASE_LSB _u(0) +#define PROC_PIO_SM1_PINCTRL_OUT_BASE_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_DMACTRL_TX +// Description : State machine DMA control +#define PROC_PIO_SM1_DMACTRL_TX_OFFSET _u(0x00000104) +#define PROC_PIO_SM1_DMACTRL_TX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM1_DMACTRL_TX_RESET _u(0x00000104) +#define PROC_PIO_SM1_DMACTRL_TX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_TX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM1_DMACTRL_TX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM1_DMACTRL_TX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM1_DMACTRL_TX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM1_DMACTRL_TX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM1_DMACTRL_TX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_TX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM1_DMACTRL_TX_ACTIVE_RESET "-" +#define PROC_PIO_SM1_DMACTRL_TX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM1_DMACTRL_TX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM1_DMACTRL_TX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM1_DMACTRL_TX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM1_DMACTRL_TX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD +// Description : Threshold control. If there are no more than THRESHOLD items in +// the TX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM1_DMACTRL_TX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM1_DMACTRL_RX +// Description : State machine DMA control +#define PROC_PIO_SM1_DMACTRL_RX_OFFSET _u(0x00000108) +#define PROC_PIO_SM1_DMACTRL_RX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM1_DMACTRL_RX_RESET _u(0x00000104) +#define PROC_PIO_SM1_DMACTRL_RX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_RX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM1_DMACTRL_RX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM1_DMACTRL_RX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM1_DMACTRL_RX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM1_DMACTRL_RX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM1_DMACTRL_RX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_RX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM1_DMACTRL_RX_ACTIVE_RESET "-" +#define PROC_PIO_SM1_DMACTRL_RX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM1_DMACTRL_RX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM1_DMACTRL_RX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM1_DMACTRL_RX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM1_DMACTRL_RX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD +// Description : Threshold control. If there are at least THRESHOLD items in the +// RX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM1_DMACTRL_RX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_CLKDIV +// Description : Clock divider register for state machine 2 +// Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256) +#define PROC_PIO_SM2_CLKDIV_OFFSET _u(0x0000010c) +#define PROC_PIO_SM2_CLKDIV_BITS _u(0xffffff00) +#define PROC_PIO_SM2_CLKDIV_RESET _u(0x00010000) +#define PROC_PIO_SM2_CLKDIV_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_CLKDIV_INT +// Description : Effective frequency is sysclk/int. +// Value of 0 is interpreted as max possible value +#define PROC_PIO_SM2_CLKDIV_INT_RESET _u(0x0001) +#define PROC_PIO_SM2_CLKDIV_INT_BITS _u(0xffff0000) +#define PROC_PIO_SM2_CLKDIV_INT_MSB _u(31) +#define PROC_PIO_SM2_CLKDIV_INT_LSB _u(16) +#define PROC_PIO_SM2_CLKDIV_INT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_CLKDIV_FRAC +// Description : Fractional part of clock divider +#define PROC_PIO_SM2_CLKDIV_FRAC_RESET _u(0x00) +#define PROC_PIO_SM2_CLKDIV_FRAC_BITS _u(0x0000ff00) +#define PROC_PIO_SM2_CLKDIV_FRAC_MSB _u(15) +#define PROC_PIO_SM2_CLKDIV_FRAC_LSB _u(8) +#define PROC_PIO_SM2_CLKDIV_FRAC_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_EXECCTRL +// Description : Execution/behavioural settings for state machine 2 +#define PROC_PIO_SM2_EXECCTRL_OFFSET _u(0x00000110) +#define PROC_PIO_SM2_EXECCTRL_BITS _u(0xffffffbf) +#define PROC_PIO_SM2_EXECCTRL_RESET _u(0x0001f000) +#define PROC_PIO_SM2_EXECCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_EXEC_STALLED +// Description : An instruction written to SMx_INSTR is stalled, and latched by +// the +// state machine. Will clear once the instruction completes. +#define PROC_PIO_SM2_EXECCTRL_EXEC_STALLED_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_EXEC_STALLED_BITS _u(0x80000000) +#define PROC_PIO_SM2_EXECCTRL_EXEC_STALLED_MSB _u(31) +#define PROC_PIO_SM2_EXECCTRL_EXEC_STALLED_LSB _u(31) +#define PROC_PIO_SM2_EXECCTRL_EXEC_STALLED_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_SIDE_EN +// Description : If 1, the delay MSB is used as side-set enable, rather than a +// side-set data bit. This allows instructions to perform side-set +// optionally, +// rather than on every instruction. +#define PROC_PIO_SM2_EXECCTRL_SIDE_EN_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_SIDE_EN_BITS _u(0x40000000) +#define PROC_PIO_SM2_EXECCTRL_SIDE_EN_MSB _u(30) +#define PROC_PIO_SM2_EXECCTRL_SIDE_EN_LSB _u(30) +#define PROC_PIO_SM2_EXECCTRL_SIDE_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR +// Description : Side-set data is asserted to pin OEs instead of pin values +#define PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR_BITS _u(0x20000000) +#define PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR_MSB _u(29) +#define PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR_LSB _u(29) +#define PROC_PIO_SM2_EXECCTRL_SIDE_PINDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_JMP_PIN +// Description : The GPIO number to use as condition for JMP PIN. Unaffected by +// input mapping. +#define PROC_PIO_SM2_EXECCTRL_JMP_PIN_RESET _u(0x00) +#define PROC_PIO_SM2_EXECCTRL_JMP_PIN_BITS _u(0x1f000000) +#define PROC_PIO_SM2_EXECCTRL_JMP_PIN_MSB _u(28) +#define PROC_PIO_SM2_EXECCTRL_JMP_PIN_LSB _u(24) +#define PROC_PIO_SM2_EXECCTRL_JMP_PIN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL +// Description : Which data bit to use for inline OUT enable +#define PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL_RESET _u(0x00) +#define PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL_BITS _u(0x00f80000) +#define PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL_MSB _u(23) +#define PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL_LSB _u(19) +#define PROC_PIO_SM2_EXECCTRL_OUT_EN_SEL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN +// Description : If 1, use a bit of OUT data as an auxiliary write enable +// When used in conjunction with OUT_STICKY, writes with an enable +// of 0 will +// deassert the latest pin write. This can create useful +// masking/override behaviour +// due to the priority ordering of state machine pin writes (SM0 < +// SM1 < ...) +#define PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN_BITS _u(0x00040000) +#define PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN_MSB _u(18) +#define PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN_LSB _u(18) +#define PROC_PIO_SM2_EXECCTRL_INLINE_OUT_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_OUT_STICKY +// Description : Continuously assert the most recent OUT/SET to the pins +#define PROC_PIO_SM2_EXECCTRL_OUT_STICKY_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_OUT_STICKY_BITS _u(0x00020000) +#define PROC_PIO_SM2_EXECCTRL_OUT_STICKY_MSB _u(17) +#define PROC_PIO_SM2_EXECCTRL_OUT_STICKY_LSB _u(17) +#define PROC_PIO_SM2_EXECCTRL_OUT_STICKY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_WRAP_TOP +// Description : After reaching this address, execution is wrapped to +// wrap_bottom. +// If the instruction is a jump, and the jump condition is true, +// the jump takes priority. +#define PROC_PIO_SM2_EXECCTRL_WRAP_TOP_RESET _u(0x1f) +#define PROC_PIO_SM2_EXECCTRL_WRAP_TOP_BITS _u(0x0001f000) +#define PROC_PIO_SM2_EXECCTRL_WRAP_TOP_MSB _u(16) +#define PROC_PIO_SM2_EXECCTRL_WRAP_TOP_LSB _u(12) +#define PROC_PIO_SM2_EXECCTRL_WRAP_TOP_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM +// Description : After reaching wrap_top, execution is wrapped to this address. +#define PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM_RESET _u(0x00) +#define PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM_BITS _u(0x00000f80) +#define PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM_MSB _u(11) +#define PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM_LSB _u(7) +#define PROC_PIO_SM2_EXECCTRL_WRAP_BOTTOM_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_STATUS_SEL +// Description : Comparison used for the MOV x, STATUS instruction. +// 0x0 -> All-ones if TX FIFO level < N, otherwise all-zeroes +// 0x1 -> All-ones if RX FIFO level < N, otherwise all-zeroes +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_RESET _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_BITS _u(0x00000020) +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_MSB _u(5) +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_LSB _u(5) +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_ACCESS "RW" +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_VALUE_TXLEVEL _u(0x0) +#define PROC_PIO_SM2_EXECCTRL_STATUS_SEL_VALUE_RXLEVEL _u(0x1) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_EXECCTRL_STATUS_N +// Description : Comparison level for the MOV x, STATUS instruction +#define PROC_PIO_SM2_EXECCTRL_STATUS_N_RESET _u(0x00) +#define PROC_PIO_SM2_EXECCTRL_STATUS_N_BITS _u(0x0000001f) +#define PROC_PIO_SM2_EXECCTRL_STATUS_N_MSB _u(4) +#define PROC_PIO_SM2_EXECCTRL_STATUS_N_LSB _u(0) +#define PROC_PIO_SM2_EXECCTRL_STATUS_N_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_SHIFTCTRL +// Description : Control behaviour of the input/output shift registers for state +// machine 2 +#define PROC_PIO_SM2_SHIFTCTRL_OFFSET _u(0x00000114) +#define PROC_PIO_SM2_SHIFTCTRL_BITS _u(0xffff0000) +#define PROC_PIO_SM2_SHIFTCTRL_RESET _u(0x000c0000) +#define PROC_PIO_SM2_SHIFTCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX +// Description : When 1, RX FIFO steals the TX FIFO's storage, and becomes twice +// as deep. +// TX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX_RESET _u(0x0) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX_BITS _u(0x80000000) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX_MSB _u(31) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX_LSB _u(31) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_RX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX +// Description : When 1, TX FIFO steals the RX FIFO's storage, and becomes twice +// as deep. +// RX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX_RESET _u(0x0) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX_BITS _u(0x40000000) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX_MSB _u(30) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX_LSB _u(30) +#define PROC_PIO_SM2_SHIFTCTRL_FJOIN_TX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH +// Description : Number of bits shifted out of TXSR before autopull or +// conditional pull. +// Write 0 for value of 32. +#define PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH_RESET _u(0x00) +#define PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH_BITS _u(0x3e000000) +#define PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH_MSB _u(29) +#define PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH_LSB _u(25) +#define PROC_PIO_SM2_SHIFTCTRL_PULL_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH +// Description : Number of bits shifted into RXSR before autopush or conditional +// push. +// Write 0 for value of 32. +#define PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH_RESET _u(0x00) +#define PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH_BITS _u(0x01f00000) +#define PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH_MSB _u(24) +#define PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH_LSB _u(20) +#define PROC_PIO_SM2_SHIFTCTRL_PUSH_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR +// Description : 1 = shift out of output shift register to right. 0 = to left. +#define PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR_BITS _u(0x00080000) +#define PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR_MSB _u(19) +#define PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR_LSB _u(19) +#define PROC_PIO_SM2_SHIFTCTRL_OUT_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR +// Description : 1 = shift input shift register to right (data enters from +// left). 0 = to left. +#define PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR_BITS _u(0x00040000) +#define PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR_MSB _u(18) +#define PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR_LSB _u(18) +#define PROC_PIO_SM2_SHIFTCTRL_IN_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_AUTOPULL +// Description : Pull automatically when the output shift register is emptied +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPULL_RESET _u(0x0) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPULL_BITS _u(0x00020000) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPULL_MSB _u(17) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPULL_LSB _u(17) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH +// Description : Push automatically when the input shift register is filled +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH_RESET _u(0x0) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH_BITS _u(0x00010000) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH_MSB _u(16) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH_LSB _u(16) +#define PROC_PIO_SM2_SHIFTCTRL_AUTOPUSH_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_ADDR +// Description : Current instruction address of state machine 2 +#define PROC_PIO_SM2_ADDR_OFFSET _u(0x00000118) +#define PROC_PIO_SM2_ADDR_BITS _u(0x0000001f) +#define PROC_PIO_SM2_ADDR_RESET _u(0x00000000) +#define PROC_PIO_SM2_ADDR_WIDTH _u(32) +#define PROC_PIO_SM2_ADDR_MSB _u(4) +#define PROC_PIO_SM2_ADDR_LSB _u(0) +#define PROC_PIO_SM2_ADDR_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_SM2_INSTR +// Description : Instruction currently being executed by state machine 2 +// Write to execute an instruction immediately (including jumps) +// and then resume execution. +#define PROC_PIO_SM2_INSTR_OFFSET _u(0x0000011c) +#define PROC_PIO_SM2_INSTR_BITS _u(0x0000ffff) +#define PROC_PIO_SM2_INSTR_RESET "-" +#define PROC_PIO_SM2_INSTR_WIDTH _u(32) +#define PROC_PIO_SM2_INSTR_MSB _u(15) +#define PROC_PIO_SM2_INSTR_LSB _u(0) +#define PROC_PIO_SM2_INSTR_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_PINCTRL +// Description : State machine pin control +#define PROC_PIO_SM2_PINCTRL_OFFSET _u(0x00000120) +#define PROC_PIO_SM2_PINCTRL_BITS _u(0xffffffff) +#define PROC_PIO_SM2_PINCTRL_RESET _u(0x14000000) +#define PROC_PIO_SM2_PINCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_SIDESET_COUNT +// Description : The number of delay bits co-opted for side-set. Inclusive of +// the enable bit, if present. +#define PROC_PIO_SM2_PINCTRL_SIDESET_COUNT_RESET _u(0x0) +#define PROC_PIO_SM2_PINCTRL_SIDESET_COUNT_BITS _u(0xe0000000) +#define PROC_PIO_SM2_PINCTRL_SIDESET_COUNT_MSB _u(31) +#define PROC_PIO_SM2_PINCTRL_SIDESET_COUNT_LSB _u(29) +#define PROC_PIO_SM2_PINCTRL_SIDESET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_SET_COUNT +// Description : The number of pins asserted by a SET. Max of 5 +#define PROC_PIO_SM2_PINCTRL_SET_COUNT_RESET _u(0x5) +#define PROC_PIO_SM2_PINCTRL_SET_COUNT_BITS _u(0x1c000000) +#define PROC_PIO_SM2_PINCTRL_SET_COUNT_MSB _u(28) +#define PROC_PIO_SM2_PINCTRL_SET_COUNT_LSB _u(26) +#define PROC_PIO_SM2_PINCTRL_SET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_OUT_COUNT +// Description : The number of pins asserted by an OUT. Value of 0 -> 32 pins +#define PROC_PIO_SM2_PINCTRL_OUT_COUNT_RESET _u(0x00) +#define PROC_PIO_SM2_PINCTRL_OUT_COUNT_BITS _u(0x03f00000) +#define PROC_PIO_SM2_PINCTRL_OUT_COUNT_MSB _u(25) +#define PROC_PIO_SM2_PINCTRL_OUT_COUNT_LSB _u(20) +#define PROC_PIO_SM2_PINCTRL_OUT_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_IN_BASE +// Description : The virtual pin corresponding to IN bit 0 +#define PROC_PIO_SM2_PINCTRL_IN_BASE_RESET _u(0x00) +#define PROC_PIO_SM2_PINCTRL_IN_BASE_BITS _u(0x000f8000) +#define PROC_PIO_SM2_PINCTRL_IN_BASE_MSB _u(19) +#define PROC_PIO_SM2_PINCTRL_IN_BASE_LSB _u(15) +#define PROC_PIO_SM2_PINCTRL_IN_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_SIDESET_BASE +// Description : The virtual pin corresponding to delay field bit 0 +#define PROC_PIO_SM2_PINCTRL_SIDESET_BASE_RESET _u(0x00) +#define PROC_PIO_SM2_PINCTRL_SIDESET_BASE_BITS _u(0x00007c00) +#define PROC_PIO_SM2_PINCTRL_SIDESET_BASE_MSB _u(14) +#define PROC_PIO_SM2_PINCTRL_SIDESET_BASE_LSB _u(10) +#define PROC_PIO_SM2_PINCTRL_SIDESET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_SET_BASE +// Description : The virtual pin corresponding to SET bit 0 +#define PROC_PIO_SM2_PINCTRL_SET_BASE_RESET _u(0x00) +#define PROC_PIO_SM2_PINCTRL_SET_BASE_BITS _u(0x000003e0) +#define PROC_PIO_SM2_PINCTRL_SET_BASE_MSB _u(9) +#define PROC_PIO_SM2_PINCTRL_SET_BASE_LSB _u(5) +#define PROC_PIO_SM2_PINCTRL_SET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_PINCTRL_OUT_BASE +// Description : The virtual pin corresponding to OUT bit 0 +#define PROC_PIO_SM2_PINCTRL_OUT_BASE_RESET _u(0x00) +#define PROC_PIO_SM2_PINCTRL_OUT_BASE_BITS _u(0x0000001f) +#define PROC_PIO_SM2_PINCTRL_OUT_BASE_MSB _u(4) +#define PROC_PIO_SM2_PINCTRL_OUT_BASE_LSB _u(0) +#define PROC_PIO_SM2_PINCTRL_OUT_BASE_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_DMACTRL_TX +// Description : State machine DMA control +#define PROC_PIO_SM2_DMACTRL_TX_OFFSET _u(0x00000124) +#define PROC_PIO_SM2_DMACTRL_TX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM2_DMACTRL_TX_RESET _u(0x00000104) +#define PROC_PIO_SM2_DMACTRL_TX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_TX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM2_DMACTRL_TX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM2_DMACTRL_TX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM2_DMACTRL_TX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM2_DMACTRL_TX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM2_DMACTRL_TX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_TX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM2_DMACTRL_TX_ACTIVE_RESET "-" +#define PROC_PIO_SM2_DMACTRL_TX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM2_DMACTRL_TX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM2_DMACTRL_TX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM2_DMACTRL_TX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM2_DMACTRL_TX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD +// Description : Threshold control. If there are no more than THRESHOLD items in +// the TX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM2_DMACTRL_TX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM2_DMACTRL_RX +// Description : State machine DMA control +#define PROC_PIO_SM2_DMACTRL_RX_OFFSET _u(0x00000128) +#define PROC_PIO_SM2_DMACTRL_RX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM2_DMACTRL_RX_RESET _u(0x00000104) +#define PROC_PIO_SM2_DMACTRL_RX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_RX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM2_DMACTRL_RX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM2_DMACTRL_RX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM2_DMACTRL_RX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM2_DMACTRL_RX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM2_DMACTRL_RX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_RX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM2_DMACTRL_RX_ACTIVE_RESET "-" +#define PROC_PIO_SM2_DMACTRL_RX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM2_DMACTRL_RX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM2_DMACTRL_RX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM2_DMACTRL_RX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM2_DMACTRL_RX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD +// Description : Threshold control. If there are at least THRESHOLD items in the +// RX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM2_DMACTRL_RX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_CLKDIV +// Description : Clock divider register for state machine 3 +// Frequency = clock freq / (CLKDIV_INT + CLKDIV_FRAC / 256) +#define PROC_PIO_SM3_CLKDIV_OFFSET _u(0x0000012c) +#define PROC_PIO_SM3_CLKDIV_BITS _u(0xffffff00) +#define PROC_PIO_SM3_CLKDIV_RESET _u(0x00010000) +#define PROC_PIO_SM3_CLKDIV_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_CLKDIV_INT +// Description : Effective frequency is sysclk/int. +// Value of 0 is interpreted as max possible value +#define PROC_PIO_SM3_CLKDIV_INT_RESET _u(0x0001) +#define PROC_PIO_SM3_CLKDIV_INT_BITS _u(0xffff0000) +#define PROC_PIO_SM3_CLKDIV_INT_MSB _u(31) +#define PROC_PIO_SM3_CLKDIV_INT_LSB _u(16) +#define PROC_PIO_SM3_CLKDIV_INT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_CLKDIV_FRAC +// Description : Fractional part of clock divider +#define PROC_PIO_SM3_CLKDIV_FRAC_RESET _u(0x00) +#define PROC_PIO_SM3_CLKDIV_FRAC_BITS _u(0x0000ff00) +#define PROC_PIO_SM3_CLKDIV_FRAC_MSB _u(15) +#define PROC_PIO_SM3_CLKDIV_FRAC_LSB _u(8) +#define PROC_PIO_SM3_CLKDIV_FRAC_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_EXECCTRL +// Description : Execution/behavioural settings for state machine 3 +#define PROC_PIO_SM3_EXECCTRL_OFFSET _u(0x00000130) +#define PROC_PIO_SM3_EXECCTRL_BITS _u(0xffffffbf) +#define PROC_PIO_SM3_EXECCTRL_RESET _u(0x0001f000) +#define PROC_PIO_SM3_EXECCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_EXEC_STALLED +// Description : An instruction written to SMx_INSTR is stalled, and latched by +// the +// state machine. Will clear once the instruction completes. +#define PROC_PIO_SM3_EXECCTRL_EXEC_STALLED_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_EXEC_STALLED_BITS _u(0x80000000) +#define PROC_PIO_SM3_EXECCTRL_EXEC_STALLED_MSB _u(31) +#define PROC_PIO_SM3_EXECCTRL_EXEC_STALLED_LSB _u(31) +#define PROC_PIO_SM3_EXECCTRL_EXEC_STALLED_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_SIDE_EN +// Description : If 1, the delay MSB is used as side-set enable, rather than a +// side-set data bit. This allows instructions to perform side-set +// optionally, +// rather than on every instruction. +#define PROC_PIO_SM3_EXECCTRL_SIDE_EN_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_SIDE_EN_BITS _u(0x40000000) +#define PROC_PIO_SM3_EXECCTRL_SIDE_EN_MSB _u(30) +#define PROC_PIO_SM3_EXECCTRL_SIDE_EN_LSB _u(30) +#define PROC_PIO_SM3_EXECCTRL_SIDE_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR +// Description : Side-set data is asserted to pin OEs instead of pin values +#define PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR_BITS _u(0x20000000) +#define PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR_MSB _u(29) +#define PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR_LSB _u(29) +#define PROC_PIO_SM3_EXECCTRL_SIDE_PINDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_JMP_PIN +// Description : The GPIO number to use as condition for JMP PIN. Unaffected by +// input mapping. +#define PROC_PIO_SM3_EXECCTRL_JMP_PIN_RESET _u(0x00) +#define PROC_PIO_SM3_EXECCTRL_JMP_PIN_BITS _u(0x1f000000) +#define PROC_PIO_SM3_EXECCTRL_JMP_PIN_MSB _u(28) +#define PROC_PIO_SM3_EXECCTRL_JMP_PIN_LSB _u(24) +#define PROC_PIO_SM3_EXECCTRL_JMP_PIN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL +// Description : Which data bit to use for inline OUT enable +#define PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL_RESET _u(0x00) +#define PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL_BITS _u(0x00f80000) +#define PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL_MSB _u(23) +#define PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL_LSB _u(19) +#define PROC_PIO_SM3_EXECCTRL_OUT_EN_SEL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN +// Description : If 1, use a bit of OUT data as an auxiliary write enable +// When used in conjunction with OUT_STICKY, writes with an enable +// of 0 will +// deassert the latest pin write. This can create useful +// masking/override behaviour +// due to the priority ordering of state machine pin writes (SM0 < +// SM1 < ...) +#define PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN_BITS _u(0x00040000) +#define PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN_MSB _u(18) +#define PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN_LSB _u(18) +#define PROC_PIO_SM3_EXECCTRL_INLINE_OUT_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_OUT_STICKY +// Description : Continuously assert the most recent OUT/SET to the pins +#define PROC_PIO_SM3_EXECCTRL_OUT_STICKY_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_OUT_STICKY_BITS _u(0x00020000) +#define PROC_PIO_SM3_EXECCTRL_OUT_STICKY_MSB _u(17) +#define PROC_PIO_SM3_EXECCTRL_OUT_STICKY_LSB _u(17) +#define PROC_PIO_SM3_EXECCTRL_OUT_STICKY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_WRAP_TOP +// Description : After reaching this address, execution is wrapped to +// wrap_bottom. +// If the instruction is a jump, and the jump condition is true, +// the jump takes priority. +#define PROC_PIO_SM3_EXECCTRL_WRAP_TOP_RESET _u(0x1f) +#define PROC_PIO_SM3_EXECCTRL_WRAP_TOP_BITS _u(0x0001f000) +#define PROC_PIO_SM3_EXECCTRL_WRAP_TOP_MSB _u(16) +#define PROC_PIO_SM3_EXECCTRL_WRAP_TOP_LSB _u(12) +#define PROC_PIO_SM3_EXECCTRL_WRAP_TOP_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM +// Description : After reaching wrap_top, execution is wrapped to this address. +#define PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM_RESET _u(0x00) +#define PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM_BITS _u(0x00000f80) +#define PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM_MSB _u(11) +#define PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM_LSB _u(7) +#define PROC_PIO_SM3_EXECCTRL_WRAP_BOTTOM_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_STATUS_SEL +// Description : Comparison used for the MOV x, STATUS instruction. +// 0x0 -> All-ones if TX FIFO level < N, otherwise all-zeroes +// 0x1 -> All-ones if RX FIFO level < N, otherwise all-zeroes +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_RESET _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_BITS _u(0x00000020) +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_MSB _u(5) +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_LSB _u(5) +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_ACCESS "RW" +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_VALUE_TXLEVEL _u(0x0) +#define PROC_PIO_SM3_EXECCTRL_STATUS_SEL_VALUE_RXLEVEL _u(0x1) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_EXECCTRL_STATUS_N +// Description : Comparison level for the MOV x, STATUS instruction +#define PROC_PIO_SM3_EXECCTRL_STATUS_N_RESET _u(0x00) +#define PROC_PIO_SM3_EXECCTRL_STATUS_N_BITS _u(0x0000001f) +#define PROC_PIO_SM3_EXECCTRL_STATUS_N_MSB _u(4) +#define PROC_PIO_SM3_EXECCTRL_STATUS_N_LSB _u(0) +#define PROC_PIO_SM3_EXECCTRL_STATUS_N_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_SHIFTCTRL +// Description : Control behaviour of the input/output shift registers for state +// machine 3 +#define PROC_PIO_SM3_SHIFTCTRL_OFFSET _u(0x00000134) +#define PROC_PIO_SM3_SHIFTCTRL_BITS _u(0xffff0000) +#define PROC_PIO_SM3_SHIFTCTRL_RESET _u(0x000c0000) +#define PROC_PIO_SM3_SHIFTCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX +// Description : When 1, RX FIFO steals the TX FIFO's storage, and becomes twice +// as deep. +// TX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX_RESET _u(0x0) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX_BITS _u(0x80000000) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX_MSB _u(31) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX_LSB _u(31) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_RX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX +// Description : When 1, TX FIFO steals the RX FIFO's storage, and becomes twice +// as deep. +// RX FIFO is disabled as a result (always reads as both full and +// empty). +// FIFOs are flushed when this bit is changed. +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX_RESET _u(0x0) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX_BITS _u(0x40000000) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX_MSB _u(30) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX_LSB _u(30) +#define PROC_PIO_SM3_SHIFTCTRL_FJOIN_TX_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH +// Description : Number of bits shifted out of TXSR before autopull or +// conditional pull. +// Write 0 for value of 32. +#define PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH_RESET _u(0x00) +#define PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH_BITS _u(0x3e000000) +#define PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH_MSB _u(29) +#define PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH_LSB _u(25) +#define PROC_PIO_SM3_SHIFTCTRL_PULL_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH +// Description : Number of bits shifted into RXSR before autopush or conditional +// push. +// Write 0 for value of 32. +#define PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH_RESET _u(0x00) +#define PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH_BITS _u(0x01f00000) +#define PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH_MSB _u(24) +#define PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH_LSB _u(20) +#define PROC_PIO_SM3_SHIFTCTRL_PUSH_THRESH_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR +// Description : 1 = shift out of output shift register to right. 0 = to left. +#define PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR_BITS _u(0x00080000) +#define PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR_MSB _u(19) +#define PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR_LSB _u(19) +#define PROC_PIO_SM3_SHIFTCTRL_OUT_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR +// Description : 1 = shift input shift register to right (data enters from +// left). 0 = to left. +#define PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR_RESET _u(0x1) +#define PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR_BITS _u(0x00040000) +#define PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR_MSB _u(18) +#define PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR_LSB _u(18) +#define PROC_PIO_SM3_SHIFTCTRL_IN_SHIFTDIR_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_AUTOPULL +// Description : Pull automatically when the output shift register is emptied +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPULL_RESET _u(0x0) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPULL_BITS _u(0x00020000) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPULL_MSB _u(17) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPULL_LSB _u(17) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH +// Description : Push automatically when the input shift register is filled +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH_RESET _u(0x0) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH_BITS _u(0x00010000) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH_MSB _u(16) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH_LSB _u(16) +#define PROC_PIO_SM3_SHIFTCTRL_AUTOPUSH_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_ADDR +// Description : Current instruction address of state machine 3 +#define PROC_PIO_SM3_ADDR_OFFSET _u(0x00000138) +#define PROC_PIO_SM3_ADDR_BITS _u(0x0000001f) +#define PROC_PIO_SM3_ADDR_RESET _u(0x00000000) +#define PROC_PIO_SM3_ADDR_WIDTH _u(32) +#define PROC_PIO_SM3_ADDR_MSB _u(4) +#define PROC_PIO_SM3_ADDR_LSB _u(0) +#define PROC_PIO_SM3_ADDR_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_SM3_INSTR +// Description : Instruction currently being executed by state machine 3 +// Write to execute an instruction immediately (including jumps) +// and then resume execution. +#define PROC_PIO_SM3_INSTR_OFFSET _u(0x0000013c) +#define PROC_PIO_SM3_INSTR_BITS _u(0x0000ffff) +#define PROC_PIO_SM3_INSTR_RESET "-" +#define PROC_PIO_SM3_INSTR_WIDTH _u(32) +#define PROC_PIO_SM3_INSTR_MSB _u(15) +#define PROC_PIO_SM3_INSTR_LSB _u(0) +#define PROC_PIO_SM3_INSTR_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_PINCTRL +// Description : State machine pin control +#define PROC_PIO_SM3_PINCTRL_OFFSET _u(0x00000140) +#define PROC_PIO_SM3_PINCTRL_BITS _u(0xffffffff) +#define PROC_PIO_SM3_PINCTRL_RESET _u(0x14000000) +#define PROC_PIO_SM3_PINCTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_SIDESET_COUNT +// Description : The number of delay bits co-opted for side-set. Inclusive of +// the enable bit, if present. +#define PROC_PIO_SM3_PINCTRL_SIDESET_COUNT_RESET _u(0x0) +#define PROC_PIO_SM3_PINCTRL_SIDESET_COUNT_BITS _u(0xe0000000) +#define PROC_PIO_SM3_PINCTRL_SIDESET_COUNT_MSB _u(31) +#define PROC_PIO_SM3_PINCTRL_SIDESET_COUNT_LSB _u(29) +#define PROC_PIO_SM3_PINCTRL_SIDESET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_SET_COUNT +// Description : The number of pins asserted by a SET. Max of 5 +#define PROC_PIO_SM3_PINCTRL_SET_COUNT_RESET _u(0x5) +#define PROC_PIO_SM3_PINCTRL_SET_COUNT_BITS _u(0x1c000000) +#define PROC_PIO_SM3_PINCTRL_SET_COUNT_MSB _u(28) +#define PROC_PIO_SM3_PINCTRL_SET_COUNT_LSB _u(26) +#define PROC_PIO_SM3_PINCTRL_SET_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_OUT_COUNT +// Description : The number of pins asserted by an OUT. Value of 0 -> 32 pins +#define PROC_PIO_SM3_PINCTRL_OUT_COUNT_RESET _u(0x00) +#define PROC_PIO_SM3_PINCTRL_OUT_COUNT_BITS _u(0x03f00000) +#define PROC_PIO_SM3_PINCTRL_OUT_COUNT_MSB _u(25) +#define PROC_PIO_SM3_PINCTRL_OUT_COUNT_LSB _u(20) +#define PROC_PIO_SM3_PINCTRL_OUT_COUNT_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_IN_BASE +// Description : The virtual pin corresponding to IN bit 0 +#define PROC_PIO_SM3_PINCTRL_IN_BASE_RESET _u(0x00) +#define PROC_PIO_SM3_PINCTRL_IN_BASE_BITS _u(0x000f8000) +#define PROC_PIO_SM3_PINCTRL_IN_BASE_MSB _u(19) +#define PROC_PIO_SM3_PINCTRL_IN_BASE_LSB _u(15) +#define PROC_PIO_SM3_PINCTRL_IN_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_SIDESET_BASE +// Description : The virtual pin corresponding to delay field bit 0 +#define PROC_PIO_SM3_PINCTRL_SIDESET_BASE_RESET _u(0x00) +#define PROC_PIO_SM3_PINCTRL_SIDESET_BASE_BITS _u(0x00007c00) +#define PROC_PIO_SM3_PINCTRL_SIDESET_BASE_MSB _u(14) +#define PROC_PIO_SM3_PINCTRL_SIDESET_BASE_LSB _u(10) +#define PROC_PIO_SM3_PINCTRL_SIDESET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_SET_BASE +// Description : The virtual pin corresponding to SET bit 0 +#define PROC_PIO_SM3_PINCTRL_SET_BASE_RESET _u(0x00) +#define PROC_PIO_SM3_PINCTRL_SET_BASE_BITS _u(0x000003e0) +#define PROC_PIO_SM3_PINCTRL_SET_BASE_MSB _u(9) +#define PROC_PIO_SM3_PINCTRL_SET_BASE_LSB _u(5) +#define PROC_PIO_SM3_PINCTRL_SET_BASE_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_PINCTRL_OUT_BASE +// Description : The virtual pin corresponding to OUT bit 0 +#define PROC_PIO_SM3_PINCTRL_OUT_BASE_RESET _u(0x00) +#define PROC_PIO_SM3_PINCTRL_OUT_BASE_BITS _u(0x0000001f) +#define PROC_PIO_SM3_PINCTRL_OUT_BASE_MSB _u(4) +#define PROC_PIO_SM3_PINCTRL_OUT_BASE_LSB _u(0) +#define PROC_PIO_SM3_PINCTRL_OUT_BASE_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_DMACTRL_TX +// Description : State machine DMA control +#define PROC_PIO_SM3_DMACTRL_TX_OFFSET _u(0x00000144) +#define PROC_PIO_SM3_DMACTRL_TX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM3_DMACTRL_TX_RESET _u(0x00000104) +#define PROC_PIO_SM3_DMACTRL_TX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_TX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM3_DMACTRL_TX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM3_DMACTRL_TX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM3_DMACTRL_TX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM3_DMACTRL_TX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM3_DMACTRL_TX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_TX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM3_DMACTRL_TX_ACTIVE_RESET "-" +#define PROC_PIO_SM3_DMACTRL_TX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM3_DMACTRL_TX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM3_DMACTRL_TX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM3_DMACTRL_TX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM3_DMACTRL_TX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD +// Description : Threshold control. If there are no more than THRESHOLD items in +// the TX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM3_DMACTRL_TX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_SM3_DMACTRL_RX +// Description : State machine DMA control +#define PROC_PIO_SM3_DMACTRL_RX_OFFSET _u(0x00000148) +#define PROC_PIO_SM3_DMACTRL_RX_BITS _u(0xc0000f9f) +#define PROC_PIO_SM3_DMACTRL_RX_RESET _u(0x00000104) +#define PROC_PIO_SM3_DMACTRL_RX_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_RX_DREQ_EN +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM3_DMACTRL_RX_DREQ_EN_RESET _u(0x0) +#define PROC_PIO_SM3_DMACTRL_RX_DREQ_EN_BITS _u(0x80000000) +#define PROC_PIO_SM3_DMACTRL_RX_DREQ_EN_MSB _u(31) +#define PROC_PIO_SM3_DMACTRL_RX_DREQ_EN_LSB _u(31) +#define PROC_PIO_SM3_DMACTRL_RX_DREQ_EN_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_RX_ACTIVE +// Description : 1 - Assert DREQ to DMA when fewer than fifo_threshold spaces +// are available +// 0 - Don't assert DREQ +#define PROC_PIO_SM3_DMACTRL_RX_ACTIVE_RESET "-" +#define PROC_PIO_SM3_DMACTRL_RX_ACTIVE_BITS _u(0x40000000) +#define PROC_PIO_SM3_DMACTRL_RX_ACTIVE_MSB _u(30) +#define PROC_PIO_SM3_DMACTRL_RX_ACTIVE_LSB _u(30) +#define PROC_PIO_SM3_DMACTRL_RX_ACTIVE_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME +// Description : Delay in number of bus cycles before successive DREQs are +// generated. +// Used to account for system bus latency in write data arriving +// at the FIFO. +#define PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME_RESET _u(0x02) +#define PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME_BITS _u(0x00000f80) +#define PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME_MSB _u(11) +#define PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME_LSB _u(7) +#define PROC_PIO_SM3_DMACTRL_RX_DWELL_TIME_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD +// Description : Threshold control. If there are at least THRESHOLD items in the +// RX FIFO, DMA dreq and/or the interrupt line is asserted. +#define PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD_RESET _u(0x04) +#define PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD_BITS _u(0x0000001f) +#define PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD_MSB _u(4) +#define PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD_LSB _u(0) +#define PROC_PIO_SM3_DMACTRL_RX_FIFO_THRESHOLD_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_INTR +// Description : Raw Interrupts +#define PROC_PIO_INTR_OFFSET _u(0x0000014c) +#define PROC_PIO_INTR_BITS _u(0x00000fff) +#define PROC_PIO_INTR_RESET _u(0x00000000) +#define PROC_PIO_INTR_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM3 +// Description : None +#define PROC_PIO_INTR_SM3_RESET _u(0x0) +#define PROC_PIO_INTR_SM3_BITS _u(0x00000800) +#define PROC_PIO_INTR_SM3_MSB _u(11) +#define PROC_PIO_INTR_SM3_LSB _u(11) +#define PROC_PIO_INTR_SM3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM2 +// Description : None +#define PROC_PIO_INTR_SM2_RESET _u(0x0) +#define PROC_PIO_INTR_SM2_BITS _u(0x00000400) +#define PROC_PIO_INTR_SM2_MSB _u(10) +#define PROC_PIO_INTR_SM2_LSB _u(10) +#define PROC_PIO_INTR_SM2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM1 +// Description : None +#define PROC_PIO_INTR_SM1_RESET _u(0x0) +#define PROC_PIO_INTR_SM1_BITS _u(0x00000200) +#define PROC_PIO_INTR_SM1_MSB _u(9) +#define PROC_PIO_INTR_SM1_LSB _u(9) +#define PROC_PIO_INTR_SM1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM0 +// Description : None +#define PROC_PIO_INTR_SM0_RESET _u(0x0) +#define PROC_PIO_INTR_SM0_BITS _u(0x00000100) +#define PROC_PIO_INTR_SM0_MSB _u(8) +#define PROC_PIO_INTR_SM0_LSB _u(8) +#define PROC_PIO_INTR_SM0_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM3_TXNFULL +// Description : None +#define PROC_PIO_INTR_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_INTR_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_INTR_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_INTR_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_INTR_SM3_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM2_TXNFULL +// Description : None +#define PROC_PIO_INTR_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_INTR_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_INTR_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_INTR_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_INTR_SM2_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM1_TXNFULL +// Description : None +#define PROC_PIO_INTR_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_INTR_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_INTR_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_INTR_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_INTR_SM1_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM0_TXNFULL +// Description : None +#define PROC_PIO_INTR_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_INTR_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_INTR_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_INTR_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_INTR_SM0_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_INTR_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_INTR_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_INTR_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_INTR_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_INTR_SM3_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_INTR_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_INTR_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_INTR_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_INTR_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_INTR_SM2_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_INTR_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_INTR_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_INTR_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_INTR_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_INTR_SM1_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_INTR_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_INTR_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_INTR_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_INTR_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_INTR_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_INTR_SM0_RXNEMPTY_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_IRQ0_INTE +// Description : Interrupt Enable for irq0 +#define PROC_PIO_IRQ0_INTE_OFFSET _u(0x00000150) +#define PROC_PIO_IRQ0_INTE_BITS _u(0x00000fff) +#define PROC_PIO_IRQ0_INTE_RESET _u(0x00000000) +#define PROC_PIO_IRQ0_INTE_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM3 +// Description : None +#define PROC_PIO_IRQ0_INTE_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ0_INTE_SM3_MSB _u(11) +#define PROC_PIO_IRQ0_INTE_SM3_LSB _u(11) +#define PROC_PIO_IRQ0_INTE_SM3_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM2 +// Description : None +#define PROC_PIO_IRQ0_INTE_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ0_INTE_SM2_MSB _u(10) +#define PROC_PIO_IRQ0_INTE_SM2_LSB _u(10) +#define PROC_PIO_IRQ0_INTE_SM2_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM1 +// Description : None +#define PROC_PIO_IRQ0_INTE_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ0_INTE_SM1_MSB _u(9) +#define PROC_PIO_IRQ0_INTE_SM1_LSB _u(9) +#define PROC_PIO_IRQ0_INTE_SM1_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM0 +// Description : None +#define PROC_PIO_IRQ0_INTE_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ0_INTE_SM0_MSB _u(8) +#define PROC_PIO_IRQ0_INTE_SM0_LSB _u(8) +#define PROC_PIO_IRQ0_INTE_SM0_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTE_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ0_INTE_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ0_INTE_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ0_INTE_SM3_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTE_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ0_INTE_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ0_INTE_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ0_INTE_SM2_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTE_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ0_INTE_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ0_INTE_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ0_INTE_SM1_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTE_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ0_INTE_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ0_INTE_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ0_INTE_SM0_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ0_INTE_SM3_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ0_INTE_SM2_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ0_INTE_SM1_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ0_INTE_SM0_RXNEMPTY_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_IRQ0_INTF +// Description : Interrupt Force for irq0 +#define PROC_PIO_IRQ0_INTF_OFFSET _u(0x00000154) +#define PROC_PIO_IRQ0_INTF_BITS _u(0x00000fff) +#define PROC_PIO_IRQ0_INTF_RESET _u(0x00000000) +#define PROC_PIO_IRQ0_INTF_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM3 +// Description : None +#define PROC_PIO_IRQ0_INTF_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ0_INTF_SM3_MSB _u(11) +#define PROC_PIO_IRQ0_INTF_SM3_LSB _u(11) +#define PROC_PIO_IRQ0_INTF_SM3_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM2 +// Description : None +#define PROC_PIO_IRQ0_INTF_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ0_INTF_SM2_MSB _u(10) +#define PROC_PIO_IRQ0_INTF_SM2_LSB _u(10) +#define PROC_PIO_IRQ0_INTF_SM2_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM1 +// Description : None +#define PROC_PIO_IRQ0_INTF_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ0_INTF_SM1_MSB _u(9) +#define PROC_PIO_IRQ0_INTF_SM1_LSB _u(9) +#define PROC_PIO_IRQ0_INTF_SM1_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM0 +// Description : None +#define PROC_PIO_IRQ0_INTF_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ0_INTF_SM0_MSB _u(8) +#define PROC_PIO_IRQ0_INTF_SM0_LSB _u(8) +#define PROC_PIO_IRQ0_INTF_SM0_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTF_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ0_INTF_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ0_INTF_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ0_INTF_SM3_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTF_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ0_INTF_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ0_INTF_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ0_INTF_SM2_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTF_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ0_INTF_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ0_INTF_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ0_INTF_SM1_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTF_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ0_INTF_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ0_INTF_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ0_INTF_SM0_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ0_INTF_SM3_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ0_INTF_SM2_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ0_INTF_SM1_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ0_INTF_SM0_RXNEMPTY_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_IRQ0_INTS +// Description : Interrupt status after masking & forcing for irq0 +#define PROC_PIO_IRQ0_INTS_OFFSET _u(0x00000158) +#define PROC_PIO_IRQ0_INTS_BITS _u(0x00000fff) +#define PROC_PIO_IRQ0_INTS_RESET _u(0x00000000) +#define PROC_PIO_IRQ0_INTS_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM3 +// Description : None +#define PROC_PIO_IRQ0_INTS_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ0_INTS_SM3_MSB _u(11) +#define PROC_PIO_IRQ0_INTS_SM3_LSB _u(11) +#define PROC_PIO_IRQ0_INTS_SM3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM2 +// Description : None +#define PROC_PIO_IRQ0_INTS_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ0_INTS_SM2_MSB _u(10) +#define PROC_PIO_IRQ0_INTS_SM2_LSB _u(10) +#define PROC_PIO_IRQ0_INTS_SM2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM1 +// Description : None +#define PROC_PIO_IRQ0_INTS_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ0_INTS_SM1_MSB _u(9) +#define PROC_PIO_IRQ0_INTS_SM1_LSB _u(9) +#define PROC_PIO_IRQ0_INTS_SM1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM0 +// Description : None +#define PROC_PIO_IRQ0_INTS_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ0_INTS_SM0_MSB _u(8) +#define PROC_PIO_IRQ0_INTS_SM0_LSB _u(8) +#define PROC_PIO_IRQ0_INTS_SM0_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTS_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ0_INTS_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ0_INTS_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ0_INTS_SM3_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTS_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ0_INTS_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ0_INTS_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ0_INTS_SM2_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTS_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ0_INTS_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ0_INTS_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ0_INTS_SM1_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ0_INTS_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ0_INTS_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ0_INTS_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ0_INTS_SM0_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ0_INTS_SM3_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ0_INTS_SM2_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ0_INTS_SM1_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ0_INTS_SM0_RXNEMPTY_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_IRQ1_INTE +// Description : Interrupt Enable for irq1 +#define PROC_PIO_IRQ1_INTE_OFFSET _u(0x0000015c) +#define PROC_PIO_IRQ1_INTE_BITS _u(0x00000fff) +#define PROC_PIO_IRQ1_INTE_RESET _u(0x00000000) +#define PROC_PIO_IRQ1_INTE_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM3 +// Description : None +#define PROC_PIO_IRQ1_INTE_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ1_INTE_SM3_MSB _u(11) +#define PROC_PIO_IRQ1_INTE_SM3_LSB _u(11) +#define PROC_PIO_IRQ1_INTE_SM3_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM2 +// Description : None +#define PROC_PIO_IRQ1_INTE_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ1_INTE_SM2_MSB _u(10) +#define PROC_PIO_IRQ1_INTE_SM2_LSB _u(10) +#define PROC_PIO_IRQ1_INTE_SM2_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM1 +// Description : None +#define PROC_PIO_IRQ1_INTE_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ1_INTE_SM1_MSB _u(9) +#define PROC_PIO_IRQ1_INTE_SM1_LSB _u(9) +#define PROC_PIO_IRQ1_INTE_SM1_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM0 +// Description : None +#define PROC_PIO_IRQ1_INTE_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ1_INTE_SM0_MSB _u(8) +#define PROC_PIO_IRQ1_INTE_SM0_LSB _u(8) +#define PROC_PIO_IRQ1_INTE_SM0_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTE_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ1_INTE_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ1_INTE_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ1_INTE_SM3_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTE_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ1_INTE_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ1_INTE_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ1_INTE_SM2_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTE_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ1_INTE_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ1_INTE_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ1_INTE_SM1_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTE_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ1_INTE_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ1_INTE_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ1_INTE_SM0_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ1_INTE_SM3_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ1_INTE_SM2_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ1_INTE_SM1_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ1_INTE_SM0_RXNEMPTY_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_IRQ1_INTF +// Description : Interrupt Force for irq1 +#define PROC_PIO_IRQ1_INTF_OFFSET _u(0x00000160) +#define PROC_PIO_IRQ1_INTF_BITS _u(0x00000fff) +#define PROC_PIO_IRQ1_INTF_RESET _u(0x00000000) +#define PROC_PIO_IRQ1_INTF_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM3 +// Description : None +#define PROC_PIO_IRQ1_INTF_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ1_INTF_SM3_MSB _u(11) +#define PROC_PIO_IRQ1_INTF_SM3_LSB _u(11) +#define PROC_PIO_IRQ1_INTF_SM3_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM2 +// Description : None +#define PROC_PIO_IRQ1_INTF_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ1_INTF_SM2_MSB _u(10) +#define PROC_PIO_IRQ1_INTF_SM2_LSB _u(10) +#define PROC_PIO_IRQ1_INTF_SM2_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM1 +// Description : None +#define PROC_PIO_IRQ1_INTF_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ1_INTF_SM1_MSB _u(9) +#define PROC_PIO_IRQ1_INTF_SM1_LSB _u(9) +#define PROC_PIO_IRQ1_INTF_SM1_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM0 +// Description : None +#define PROC_PIO_IRQ1_INTF_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ1_INTF_SM0_MSB _u(8) +#define PROC_PIO_IRQ1_INTF_SM0_LSB _u(8) +#define PROC_PIO_IRQ1_INTF_SM0_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTF_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ1_INTF_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ1_INTF_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ1_INTF_SM3_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTF_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ1_INTF_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ1_INTF_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ1_INTF_SM2_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTF_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ1_INTF_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ1_INTF_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ1_INTF_SM1_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTF_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ1_INTF_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ1_INTF_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ1_INTF_SM0_TXNFULL_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ1_INTF_SM3_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ1_INTF_SM2_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ1_INTF_SM1_RXNEMPTY_ACCESS "RW" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ1_INTF_SM0_RXNEMPTY_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_IRQ1_INTS +// Description : Interrupt status after masking & forcing for irq1 +#define PROC_PIO_IRQ1_INTS_OFFSET _u(0x00000164) +#define PROC_PIO_IRQ1_INTS_BITS _u(0x00000fff) +#define PROC_PIO_IRQ1_INTS_RESET _u(0x00000000) +#define PROC_PIO_IRQ1_INTS_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM3 +// Description : None +#define PROC_PIO_IRQ1_INTS_SM3_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM3_BITS _u(0x00000800) +#define PROC_PIO_IRQ1_INTS_SM3_MSB _u(11) +#define PROC_PIO_IRQ1_INTS_SM3_LSB _u(11) +#define PROC_PIO_IRQ1_INTS_SM3_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM2 +// Description : None +#define PROC_PIO_IRQ1_INTS_SM2_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM2_BITS _u(0x00000400) +#define PROC_PIO_IRQ1_INTS_SM2_MSB _u(10) +#define PROC_PIO_IRQ1_INTS_SM2_LSB _u(10) +#define PROC_PIO_IRQ1_INTS_SM2_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM1 +// Description : None +#define PROC_PIO_IRQ1_INTS_SM1_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM1_BITS _u(0x00000200) +#define PROC_PIO_IRQ1_INTS_SM1_MSB _u(9) +#define PROC_PIO_IRQ1_INTS_SM1_LSB _u(9) +#define PROC_PIO_IRQ1_INTS_SM1_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM0 +// Description : None +#define PROC_PIO_IRQ1_INTS_SM0_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM0_BITS _u(0x00000100) +#define PROC_PIO_IRQ1_INTS_SM0_MSB _u(8) +#define PROC_PIO_IRQ1_INTS_SM0_LSB _u(8) +#define PROC_PIO_IRQ1_INTS_SM0_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM3_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTS_SM3_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM3_TXNFULL_BITS _u(0x00000080) +#define PROC_PIO_IRQ1_INTS_SM3_TXNFULL_MSB _u(7) +#define PROC_PIO_IRQ1_INTS_SM3_TXNFULL_LSB _u(7) +#define PROC_PIO_IRQ1_INTS_SM3_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM2_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTS_SM2_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM2_TXNFULL_BITS _u(0x00000040) +#define PROC_PIO_IRQ1_INTS_SM2_TXNFULL_MSB _u(6) +#define PROC_PIO_IRQ1_INTS_SM2_TXNFULL_LSB _u(6) +#define PROC_PIO_IRQ1_INTS_SM2_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM1_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTS_SM1_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM1_TXNFULL_BITS _u(0x00000020) +#define PROC_PIO_IRQ1_INTS_SM1_TXNFULL_MSB _u(5) +#define PROC_PIO_IRQ1_INTS_SM1_TXNFULL_LSB _u(5) +#define PROC_PIO_IRQ1_INTS_SM1_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM0_TXNFULL +// Description : None +#define PROC_PIO_IRQ1_INTS_SM0_TXNFULL_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM0_TXNFULL_BITS _u(0x00000010) +#define PROC_PIO_IRQ1_INTS_SM0_TXNFULL_MSB _u(4) +#define PROC_PIO_IRQ1_INTS_SM0_TXNFULL_LSB _u(4) +#define PROC_PIO_IRQ1_INTS_SM0_TXNFULL_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY_BITS _u(0x00000008) +#define PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY_MSB _u(3) +#define PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY_LSB _u(3) +#define PROC_PIO_IRQ1_INTS_SM3_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY_BITS _u(0x00000004) +#define PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY_MSB _u(2) +#define PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY_LSB _u(2) +#define PROC_PIO_IRQ1_INTS_SM2_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY_BITS _u(0x00000002) +#define PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY_MSB _u(1) +#define PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY_LSB _u(1) +#define PROC_PIO_IRQ1_INTS_SM1_RXNEMPTY_ACCESS "RO" +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY +// Description : None +#define PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY_RESET _u(0x0) +#define PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY_BITS _u(0x00000001) +#define PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY_MSB _u(0) +#define PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY_LSB _u(0) +#define PROC_PIO_IRQ1_INTS_SM0_RXNEMPTY_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_BLOCK_ID +// Description : Block Identifier +// Hexadecimal representation of "pio2" +#define PROC_PIO_BLOCK_ID_OFFSET _u(0x00000168) +#define PROC_PIO_BLOCK_ID_BITS _u(0xffffffff) +#define PROC_PIO_BLOCK_ID_RESET _u(0x70696f32) +#define PROC_PIO_BLOCK_ID_WIDTH _u(32) +#define PROC_PIO_BLOCK_ID_MSB _u(31) +#define PROC_PIO_BLOCK_ID_LSB _u(0) +#define PROC_PIO_BLOCK_ID_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_INSTANCE_ID +// Description : Block Instance Identifier +#define PROC_PIO_INSTANCE_ID_OFFSET _u(0x0000016c) +#define PROC_PIO_INSTANCE_ID_BITS _u(0x0000000f) +#define PROC_PIO_INSTANCE_ID_RESET _u(0x00000000) +#define PROC_PIO_INSTANCE_ID_WIDTH _u(32) +#define PROC_PIO_INSTANCE_ID_MSB _u(3) +#define PROC_PIO_INSTANCE_ID_LSB _u(0) +#define PROC_PIO_INSTANCE_ID_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_RSTSEQ_AUTO +// Description : None +#define PROC_PIO_RSTSEQ_AUTO_OFFSET _u(0x00000170) +#define PROC_PIO_RSTSEQ_AUTO_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_AUTO_RESET _u(0x00000001) +#define PROC_PIO_RSTSEQ_AUTO_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_RSTSEQ_AUTO_BUSADAPTER +// Description : 1 = reset is controlled by the sequencer +// 0 = reset is controlled by rstseq_ctrl +#define PROC_PIO_RSTSEQ_AUTO_BUSADAPTER_RESET _u(0x1) +#define PROC_PIO_RSTSEQ_AUTO_BUSADAPTER_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_AUTO_BUSADAPTER_MSB _u(0) +#define PROC_PIO_RSTSEQ_AUTO_BUSADAPTER_LSB _u(0) +#define PROC_PIO_RSTSEQ_AUTO_BUSADAPTER_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_RSTSEQ_PARALLEL +// Description : None +#define PROC_PIO_RSTSEQ_PARALLEL_OFFSET _u(0x00000174) +#define PROC_PIO_RSTSEQ_PARALLEL_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_PARALLEL_RESET _u(0x00000000) +#define PROC_PIO_RSTSEQ_PARALLEL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER +// Description : Is this reset parallel (i.e. not part of the sequence) +#define PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER_RESET _u(0x0) +#define PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER_MSB _u(0) +#define PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER_LSB _u(0) +#define PROC_PIO_RSTSEQ_PARALLEL_BUSADAPTER_ACCESS "RO" +// ============================================================================= +// Register : PROC_PIO_RSTSEQ_CTRL +// Description : None +#define PROC_PIO_RSTSEQ_CTRL_OFFSET _u(0x00000178) +#define PROC_PIO_RSTSEQ_CTRL_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_CTRL_RESET _u(0x00000000) +#define PROC_PIO_RSTSEQ_CTRL_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_RSTSEQ_CTRL_BUSADAPTER +// Description : 1 = keep the reset asserted +// 0 = keep the reset deasserted +// This is ignored if rstseq_auto=1 +#define PROC_PIO_RSTSEQ_CTRL_BUSADAPTER_RESET _u(0x0) +#define PROC_PIO_RSTSEQ_CTRL_BUSADAPTER_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_CTRL_BUSADAPTER_MSB _u(0) +#define PROC_PIO_RSTSEQ_CTRL_BUSADAPTER_LSB _u(0) +#define PROC_PIO_RSTSEQ_CTRL_BUSADAPTER_ACCESS "RW" +// ============================================================================= +// Register : PROC_PIO_RSTSEQ_TRIG +// Description : None +#define PROC_PIO_RSTSEQ_TRIG_OFFSET _u(0x0000017c) +#define PROC_PIO_RSTSEQ_TRIG_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_TRIG_RESET _u(0x00000000) +#define PROC_PIO_RSTSEQ_TRIG_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_RSTSEQ_TRIG_BUSADAPTER +// Description : Pulses the reset output +#define PROC_PIO_RSTSEQ_TRIG_BUSADAPTER_RESET _u(0x0) +#define PROC_PIO_RSTSEQ_TRIG_BUSADAPTER_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_TRIG_BUSADAPTER_MSB _u(0) +#define PROC_PIO_RSTSEQ_TRIG_BUSADAPTER_LSB _u(0) +#define PROC_PIO_RSTSEQ_TRIG_BUSADAPTER_ACCESS "SC" +// ============================================================================= +// Register : PROC_PIO_RSTSEQ_DONE +// Description : None +#define PROC_PIO_RSTSEQ_DONE_OFFSET _u(0x00000180) +#define PROC_PIO_RSTSEQ_DONE_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_DONE_RESET _u(0x00000000) +#define PROC_PIO_RSTSEQ_DONE_WIDTH _u(32) +// ----------------------------------------------------------------------------- +// Field : PROC_PIO_RSTSEQ_DONE_BUSADAPTER +// Description : Indicates the current state of the reset +#define PROC_PIO_RSTSEQ_DONE_BUSADAPTER_RESET _u(0x0) +#define PROC_PIO_RSTSEQ_DONE_BUSADAPTER_BITS _u(0x00000001) +#define PROC_PIO_RSTSEQ_DONE_BUSADAPTER_MSB _u(0) +#define PROC_PIO_RSTSEQ_DONE_BUSADAPTER_LSB _u(0) +#define PROC_PIO_RSTSEQ_DONE_BUSADAPTER_ACCESS "RO" +// ============================================================================= +#endif // HARDWARE_REGS_PROC_PIO_DEFINED diff --git a/piolib/include/pico/stdlib.h b/piolib/include/pico/stdlib.h new file mode 100644 index 0000000..dc8abcc --- /dev/null +++ b/piolib/include/pico/stdlib.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _PICO_STDLIB_H_ +#define _PICO_STDLIB_H_ + +#include +#include +#include + +#include "piolib.h" + +#endif diff --git a/piolib/include/pio_platform.h b/piolib/include/pio_platform.h new file mode 100644 index 0000000..f9ad303 --- /dev/null +++ b/piolib/include/pio_platform.h @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 Raspberry Pi Ltd. + * All rights reserved. + */ + +#ifndef _PIO_PLATFORM_H +#define _PIO_PLATFORM_H + +#include +#include +#include + +#ifndef __unused +#define __unused __attribute__((unused)) +#endif + +#define PICO_DEFAULT_LED_PIN 4 + +#ifndef PARAM_ASSERTIONS_ENABLE_ALL +#define PARAM_ASSERTIONS_ENABLE_ALL 0 +#endif + +#ifndef PARAM_ASSERTIONS_DISABLE_ALL +#define PARAM_ASSERTIONS_DISABLE_ALL 0 +#endif + +#define PARAM_ASSERTIONS_ENABLED(x) \ + ((PARAM_ASSERTIONS_ENABLED_##x || PARAM_ASSERTIONS_ENABLE_ALL) && \ + !PARAM_ASSERTIONS_DISABLE_ALL) +#define invalid_params_if(x, test) \ + ({ \ + if (PARAM_ASSERTIONS_ENABLED(x)) \ + assert(!(test)); \ + }) +#define valid_params_if(x, test) \ + ({ \ + if (PARAM_ASSERTIONS_ENABLED(x)) \ + assert(test); \ + }) + +#define STATIC_ASSERT(cond) static_assert(cond, #cond) + +#define _u(x) ((uint)(x)) +#define bool_to_bit(x) ((uint) !!(x)) + +#ifndef count_of +#define count_of(a) (sizeof(a) / sizeof((a)[0])) +#endif + +typedef unsigned int uint; + +#endif diff --git a/piolib/include/piolib.h b/piolib/include/piolib.h new file mode 100644 index 0000000..e03cb7a --- /dev/null +++ b/piolib/include/piolib.h @@ -0,0 +1,829 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023-24 Raspberry Pi Ltd. + * All rights reserved. + */ + +#ifndef _PIOLIB_H +#define _PIOLIB_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "hardware/clocks.h" +#include "hardware/gpio.h" +#include "pio_platform.h" + +#ifndef PARAM_ASSERTIONS_ENABLED_PIO +#define PARAM_ASSERTIONS_ENABLED_PIO 0 +#endif + +#define PIO_ERR(x) ((PIO)(uintptr_t)(x)) +#define PIO_IS_ERR(x) (((uintptr_t)(x) >= (uintptr_t)-200)) +#define PIO_ERR_VAL(x) ((int)(uintptr_t)(x)) + +#define PIO_ORIGIN_ANY ((uint)(~0)) +#define PIO_ORIGIN_INVALID PIO_ORIGIN_ANY + +#define pio0 pio_open_helper(0) + +enum pio_fifo_join { + PIO_FIFO_JOIN_NONE = 0, + PIO_FIFO_JOIN_TX = 1, + PIO_FIFO_JOIN_RX = 2, +}; + +enum pio_mov_status_type { STATUS_TX_LESSTHAN = 0, STATUS_RX_LESSTHAN = 1 }; + +enum pio_xfer_dir { PIO_DIR_TO_SM, PIO_DIR_FROM_SM, PIO_DIR_COUNT }; + +#ifndef PIOLIB_INTERNALS + +enum pio_instr_bits { + pio_instr_bits_jmp = 0x0000, + pio_instr_bits_wait = 0x2000, + pio_instr_bits_in = 0x4000, + pio_instr_bits_out = 0x6000, + pio_instr_bits_push = 0x8000, + pio_instr_bits_pull = 0x8080, + pio_instr_bits_mov = 0xa000, + pio_instr_bits_irq = 0xc000, + pio_instr_bits_set = 0xe000, +}; + +#ifndef NDEBUG +#define _PIO_INVALID_IN_SRC 0x08u +#define _PIO_INVALID_OUT_DEST 0x10u +#define _PIO_INVALID_SET_DEST 0x20u +#define _PIO_INVALID_MOV_SRC 0x40u +#define _PIO_INVALID_MOV_DEST 0x80u +#else +#define _PIO_INVALID_IN_SRC 0u +#define _PIO_INVALID_OUT_DEST 0u +#define _PIO_INVALID_SET_DEST 0u +#define _PIO_INVALID_MOV_SRC 0u +#define _PIO_INVALID_MOV_DEST 0u +#endif + +enum pio_src_dest { + pio_pins = 0u, + pio_x = 1u, + pio_y = 2u, + pio_null = 3u | _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_DEST, + pio_pindirs = + 4u | _PIO_INVALID_IN_SRC | _PIO_INVALID_MOV_SRC | _PIO_INVALID_MOV_DEST, + pio_exec_mov = 4u | _PIO_INVALID_IN_SRC | _PIO_INVALID_OUT_DEST | + _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_SRC, + pio_status = 5u | _PIO_INVALID_IN_SRC | _PIO_INVALID_OUT_DEST | + _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_DEST, + pio_pc = + 5u | _PIO_INVALID_IN_SRC | _PIO_INVALID_SET_DEST | _PIO_INVALID_MOV_SRC, + pio_isr = 6u | _PIO_INVALID_SET_DEST, + pio_osr = 7u | _PIO_INVALID_OUT_DEST | _PIO_INVALID_SET_DEST, + pio_exec_out = 7u | _PIO_INVALID_IN_SRC | _PIO_INVALID_SET_DEST | + _PIO_INVALID_MOV_SRC | _PIO_INVALID_MOV_DEST, +}; + +#endif + +typedef struct pio_program { + const uint16_t *instructions; + uint8_t length; + int8_t origin; // required instruction memory origin or -1 + uint8_t pio_version; +} pio_program_t; + +typedef struct { + uint32_t content[4]; +} pio_sm_config; + +typedef struct pio_instance *PIO; +typedef const struct pio_chip PIO_CHIP_T; + +struct pio_chip { + const char *name; + const char *compatible; + uint16_t instr_count; + uint16_t sm_count; + uint16_t fifo_depth; + void *hw_state; + + PIO (*create_instance)(PIO_CHIP_T *chip, uint index); + int (*open_instance)(PIO pio); + void (*close_instance)(PIO pio); + + int (*pio_sm_config_xfer)(PIO pio, uint sm, uint dir, uint buf_size, + uint buf_count); + int (*pio_sm_xfer_data)(PIO pio, uint sm, uint dir, uint data_bytes, + void *data); + + bool (*pio_can_add_program_at_offset)(PIO pio, const pio_program_t *program, + uint offset); + uint (*pio_add_program_at_offset)(PIO pio, const pio_program_t *program, + uint offset); + bool (*pio_remove_program)(PIO pio, const pio_program_t *program, + uint loaded_offset); + bool (*pio_clear_instruction_memory)(PIO pio); + uint (*pio_encode_delay)(PIO pio, uint cycles); + uint (*pio_encode_sideset)(PIO pio, uint sideset_bit_count, uint value); + uint (*pio_encode_sideset_opt)(PIO pio, uint sideset_bit_count, uint value); + uint (*pio_encode_jmp)(PIO pio, uint addr); + uint (*pio_encode_jmp_not_x)(PIO pio, uint addr); + uint (*pio_encode_jmp_x_dec)(PIO pio, uint addr); + uint (*pio_encode_jmp_not_y)(PIO pio, uint addr); + uint (*pio_encode_jmp_y_dec)(PIO pio, uint addr); + uint (*pio_encode_jmp_x_ne_y)(PIO pio, uint addr); + uint (*pio_encode_jmp_pin)(PIO pio, uint addr); + uint (*pio_encode_jmp_not_osre)(PIO pio, uint addr); + uint (*pio_encode_wait_gpio)(PIO pio, bool polarity, uint gpio); + uint (*pio_encode_wait_pin)(PIO pio, bool polarity, uint pin); + uint (*pio_encode_wait_irq)(PIO pio, bool polarity, bool relative, + uint irq); + uint (*pio_encode_in)(PIO pio, enum pio_src_dest src, uint count); + uint (*pio_encode_out)(PIO pio, enum pio_src_dest dest, uint count); + uint (*pio_encode_push)(PIO pio, bool if_full, bool block); + uint (*pio_encode_pull)(PIO pio, bool if_empty, bool block); + uint (*pio_encode_mov)(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src); + uint (*pio_encode_mov_not)(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src); + uint (*pio_encode_mov_reverse)(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src); + uint (*pio_encode_irq_set)(PIO pio, bool relative, uint irq); + uint (*pio_encode_irq_wait)(PIO pio, bool relative, uint irq); + uint (*pio_encode_irq_clear)(PIO pio, bool relative, uint irq); + uint (*pio_encode_set)(PIO pio, enum pio_src_dest dest, uint value); + uint (*pio_encode_nop)(PIO pio); + + bool (*pio_sm_claim)(PIO pio, uint sm); + bool (*pio_sm_claim_mask)(PIO pio, uint mask); + int (*pio_sm_claim_unused)(PIO pio, bool required); + bool (*pio_sm_unclaim)(PIO pio, uint sm); + bool (*pio_sm_is_claimed)(PIO pio, uint sm); + + void (*pio_sm_init)(PIO pio, uint sm, uint initial_pc, + const pio_sm_config *config); + void (*pio_sm_set_config)(PIO pio, uint sm, const pio_sm_config *config); + void (*pio_sm_exec)(PIO pio, uint sm, uint instr, bool blocking); + void (*pio_sm_clear_fifos)(PIO pio, uint sm); + void (*pio_sm_set_clkdiv_int_frac)(PIO pio, uint sm, uint16_t div_int, + uint8_t div_frac); + void (*pio_sm_set_clkdiv)(PIO pio, uint sm, float div); + void (*pio_sm_set_pins)(PIO pio, uint sm, uint32_t pin_values); + void (*pio_sm_set_pins_with_mask)(PIO pio, uint sm, uint32_t pin_values, + uint32_t pin_mask); + void (*pio_sm_set_pindirs_with_mask)(PIO pio, uint sm, uint32_t pin_dirs, + uint32_t pin_mask); + void (*pio_sm_set_consecutive_pindirs)(PIO pio, uint sm, uint pin_base, + uint pin_count, bool is_out); + void (*pio_sm_set_enabled)(PIO pio, uint sm, bool enabled); + void (*pio_sm_set_enabled_mask)(PIO pio, uint32_t mask, bool enabled); + void (*pio_sm_restart)(PIO pio, uint sm); + void (*pio_sm_restart_mask)(PIO pio, uint32_t mask); + void (*pio_sm_clkdiv_restart)(PIO pio, uint sm); + void (*pio_sm_clkdiv_restart_mask)(PIO pio, uint32_t mask); + void (*pio_sm_enable_sync)(PIO pio, uint32_t mask); + void (*pio_sm_put)(PIO pio, uint sm, uint32_t data, bool blocking); + uint32_t (*pio_sm_get)(PIO pio, uint sm, bool blocking); + void (*pio_sm_set_dmactrl)(PIO pio, uint sm, bool is_tx, uint32_t ctrl); + bool (*pio_sm_is_rx_fifo_empty)(PIO pio, uint sm); + bool (*pio_sm_is_rx_fifo_full)(PIO pio, uint sm); + uint (*pio_sm_get_rx_fifo_level)(PIO pio, uint sm); + bool (*pio_sm_is_tx_fifo_empty)(PIO pio, uint sm); + bool (*pio_sm_is_tx_fifo_full)(PIO pio, uint sm); + uint (*pio_sm_get_tx_fifo_level)(PIO pio, uint sm); + void (*pio_sm_drain_tx_fifo)(PIO pio, uint sm); + + pio_sm_config (*pio_get_default_sm_config)(PIO pio); + void (*smc_set_out_pins)(PIO pio, pio_sm_config *c, uint out_base, + uint out_count); + void (*smc_set_set_pins)(PIO pio, pio_sm_config *c, uint set_base, + uint set_count); + void (*smc_set_in_pins)(PIO pio, pio_sm_config *c, uint in_base); + void (*smc_set_sideset_pins)(PIO pio, pio_sm_config *c, uint sideset_base); + void (*smc_set_sideset)(PIO pio, pio_sm_config *c, uint bit_count, + bool optional, bool pindirs); + void (*smc_set_clkdiv_int_frac)(PIO pio, pio_sm_config *c, uint16_t div_int, + uint8_t div_frac); + void (*smc_set_clkdiv)(PIO pio, pio_sm_config *c, float div); + void (*smc_set_wrap)(PIO pio, pio_sm_config *c, uint wrap_target, + uint wrap); + void (*smc_set_jmp_pin)(PIO pio, pio_sm_config *c, uint pin); + void (*smc_set_in_shift)(PIO pio, pio_sm_config *c, bool shift_right, + bool autopush, uint push_threshold); + void (*smc_set_out_shift)(PIO pio, pio_sm_config *c, bool shift_right, + bool autopull, uint pull_threshold); + void (*smc_set_fifo_join)(PIO pio, pio_sm_config *c, + enum pio_fifo_join join); + void (*smc_set_out_special)(PIO pio, pio_sm_config *c, bool sticky, + bool has_enable_pin, uint enable_pin_index); + void (*smc_set_mov_status)(PIO pio, pio_sm_config *c, + enum pio_mov_status_type status_sel, + uint status_n); + + uint32_t (*clock_get_hz)(PIO pio, enum clock_index clk_index); + void (*pio_gpio_init)(PIO pio, uint pin); + void (*gpio_init)(PIO pio, uint gpio); + void (*gpio_set_function)(PIO pio, uint gpio, enum gpio_function fn); + void (*gpio_set_pulls)(PIO pio, uint gpio, bool up, bool down); + void (*gpio_set_outover)(PIO pio, uint gpio, uint value); + void (*gpio_set_inover)(PIO pio, uint gpio, uint value); + void (*gpio_set_oeover)(PIO pio, uint gpio, uint value); + void (*gpio_set_input_enabled)(PIO pio, uint gpio, bool enabled); + void (*gpio_set_drive_strength)(PIO pio, uint gpio, + enum gpio_drive_strength drive); +}; + +struct pio_instance { + const PIO_CHIP_T *chip; + int in_use; + bool errors_are_fatal; + bool error; +}; + +int pio_init(void); +PIO pio_open(uint idx); +PIO pio_open_by_name(const char *name); +PIO pio_open_helper(uint idx); +void pio_close(PIO pio); +void pio_panic(const char *msg); +int pio_get_index(PIO pio); +void pio_select(PIO pio); +PIO pio_get_current(void); + +static inline void pio_error(PIO pio, const char *msg) { + pio->error = true; + if (pio->errors_are_fatal) + pio_panic(msg); +} + +static inline bool pio_get_error(PIO pio) { return pio->error; } + +static inline void pio_clear_error(PIO pio) { pio->error = false; } + +static inline void pio_enable_fatal_errors(PIO pio, bool enable) { + pio->errors_are_fatal = enable; +} + +static inline uint pio_get_sm_count(PIO pio) { return pio->chip->sm_count; } + +static inline uint pio_get_instruction_count(PIO pio) { + return pio->chip->instr_count; +} + +static inline uint pio_get_fifo_depth(PIO pio) { return pio->chip->fifo_depth; } + +static inline void check_pio_param(__unused PIO pio) { + valid_params_if(PIO, pio_get_index(pio) >= 0); +} + +static inline int pio_sm_config_xfer(PIO pio, uint sm, uint dir, uint buf_size, + uint buf_count) { + check_pio_param(pio); + return pio->chip->pio_sm_config_xfer(pio, sm, dir, buf_size, buf_count); +} + +static inline int pio_sm_xfer_data(PIO pio, uint sm, uint dir, uint data_bytes, + void *data) { + check_pio_param(pio); + return pio->chip->pio_sm_xfer_data(pio, sm, dir, data_bytes, data); +} + +static inline bool pio_can_add_program(PIO pio, const pio_program_t *program) { + check_pio_param(pio); + return pio->chip->pio_can_add_program_at_offset(pio, program, + PIO_ORIGIN_ANY); +} + +static inline bool pio_can_add_program_at_offset(PIO pio, + const pio_program_t *program, + uint offset) { + check_pio_param(pio); + return pio->chip->pio_can_add_program_at_offset(pio, program, offset); +} + +static inline uint pio_add_program(PIO pio, const pio_program_t *program) { + uint offset; + check_pio_param(pio); + offset = pio->chip->pio_add_program_at_offset(pio, program, PIO_ORIGIN_ANY); + if (offset == PIO_ORIGIN_INVALID) + pio_error(pio, "No program space"); + return offset; +} + +static inline void +pio_add_program_at_offset(PIO pio, const pio_program_t *program, uint offset) { + check_pio_param(pio); + if (pio->chip->pio_add_program_at_offset(pio, program, offset) == + PIO_ORIGIN_INVALID) + pio_error(pio, "No program space"); +} + +static inline void pio_remove_program(PIO pio, const pio_program_t *program, + uint loaded_offset) { + check_pio_param(pio); + if (!pio->chip->pio_remove_program(pio, program, loaded_offset)) + pio_error(pio, "Failed to remove program"); +} + +static inline void pio_clear_instruction_memory(PIO pio) { + check_pio_param(pio); + if (!pio->chip->pio_clear_instruction_memory(pio)) + pio_error(pio, "Failed to clear instruction memory"); +} + +static inline uint pio_encode_delay(uint cycles) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_delay(pio, cycles); +} + +static inline uint pio_encode_sideset(uint sideset_bit_count, uint value) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_sideset(pio, sideset_bit_count, value); +} + +static inline uint pio_encode_sideset_opt(uint sideset_bit_count, uint value) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_sideset_opt(pio, sideset_bit_count, value); +} + +static inline uint pio_encode_jmp(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp(pio, addr); +} + +static inline uint pio_encode_jmp_not_x(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_not_x(pio, addr); +} + +static inline uint pio_encode_jmp_x_dec(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_x_dec(pio, addr); +} + +static inline uint pio_encode_jmp_not_y(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_not_y(pio, addr); +} + +static inline uint pio_encode_jmp_y_dec(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_y_dec(pio, addr); +} + +static inline uint pio_encode_jmp_x_ne_y(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_x_ne_y(pio, addr); +} + +static inline uint pio_encode_jmp_pin(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_pin(pio, addr); +} + +static inline uint pio_encode_jmp_not_osre(uint addr) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_jmp_not_osre(pio, addr); +} + +static inline uint pio_encode_wait_gpio(bool polarity, uint gpio) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_wait_gpio(pio, polarity, gpio); +} + +static inline uint pio_encode_wait_pin(bool polarity, uint pin) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_wait_pin(pio, polarity, pin); +} + +static inline uint pio_encode_wait_irq(bool polarity, bool relative, uint irq) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_wait_irq(pio, polarity, relative, irq); +} + +static inline uint pio_encode_in(enum pio_src_dest src, uint count) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_in(pio, src, count); +} + +static inline uint pio_encode_out(enum pio_src_dest dest, uint count) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_out(pio, dest, count); +} + +static inline uint pio_encode_push(bool if_full, bool block) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_push(pio, if_full, block); +} + +static inline uint pio_encode_pull(bool if_empty, bool block) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_pull(pio, if_empty, block); +} + +static inline uint pio_encode_mov(enum pio_src_dest dest, + enum pio_src_dest src) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_mov(pio, dest, src); +} + +static inline uint pio_encode_mov_not(enum pio_src_dest dest, + enum pio_src_dest src) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_mov_not(pio, dest, src); +} + +static inline uint pio_encode_mov_reverse(enum pio_src_dest dest, + enum pio_src_dest src) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_mov_reverse(pio, dest, src); +} + +static inline uint pio_encode_irq_set(bool relative, uint irq) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_irq_set(pio, relative, irq); +} + +static inline uint pio_encode_irq_wait(bool relative, uint irq) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_irq_wait(pio, relative, irq); +} + +static inline uint pio_encode_irq_clear(bool relative, uint irq) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_irq_clear(pio, relative, irq); +} + +static inline uint pio_encode_set(enum pio_src_dest dest, uint value) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_set(pio, dest, value); +} + +static inline uint pio_encode_nop(void) { + PIO pio = pio_get_current(); + return pio->chip->pio_encode_nop(pio); +} + +static inline void pio_sm_claim(PIO pio, uint sm) { + check_pio_param(pio); + if (!pio->chip->pio_sm_claim(pio, sm)) + pio_error(pio, "Failed to claim SM"); +} + +static inline void pio_claim_sm_mask(PIO pio, uint mask) { + check_pio_param(pio); + if (!pio->chip->pio_sm_claim_mask(pio, mask)) + pio_error(pio, "Failed to claim masked SMs"); +} + +static inline void pio_sm_unclaim(PIO pio, uint sm) { + check_pio_param(pio); + pio->chip->pio_sm_unclaim(pio, sm); +} + +static inline int pio_claim_unused_sm(PIO pio, bool required) { + check_pio_param(pio); + return pio->chip->pio_sm_claim_unused(pio, required); +} + +static inline bool pio_sm_is_claimed(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_is_claimed(pio, sm); +} + +static inline void pio_sm_init(PIO pio, uint sm, uint initial_pc, + const pio_sm_config *config) { + check_pio_param(pio); + pio->chip->pio_sm_init(pio, sm, initial_pc, config); +} + +static inline void pio_sm_set_config(PIO pio, uint sm, + const pio_sm_config *config) { + check_pio_param(pio); + pio->chip->pio_sm_set_config(pio, sm, config); +} + +static inline void pio_sm_exec(PIO pio, uint sm, uint instr) { + check_pio_param(pio); + pio->chip->pio_sm_exec(pio, sm, instr, false); +} + +static inline void pio_sm_exec_wait_blocking(PIO pio, uint sm, uint instr) { + check_pio_param(pio); + pio->chip->pio_sm_exec(pio, sm, instr, true); +} + +static inline void pio_sm_clear_fifos(PIO pio, uint sm) { + check_pio_param(pio); + pio->chip->pio_sm_clear_fifos(pio, sm); +} + +static inline void pio_sm_set_clkdiv_int_frac(PIO pio, uint sm, + uint16_t div_int, + uint8_t div_frac) { + check_pio_param(pio); + pio->chip->pio_sm_set_clkdiv_int_frac(pio, sm, div_int, div_frac); +} + +static inline void pio_sm_set_clkdiv(PIO pio, uint sm, float div) { + check_pio_param(pio); + pio->chip->pio_sm_set_clkdiv(pio, sm, div); +} + +static inline void pio_sm_set_pins(PIO pio, uint sm, uint32_t pin_values) { + check_pio_param(pio); + pio->chip->pio_sm_set_pins(pio, sm, pin_values); +} + +static inline void pio_sm_set_pins_with_mask(PIO pio, uint sm, + uint32_t pin_values, + uint32_t pin_mask) { + check_pio_param(pio); + pio->chip->pio_sm_set_pins_with_mask(pio, sm, pin_values, pin_mask); +} + +static inline void pio_sm_set_pindirs_with_mask(PIO pio, uint sm, + uint32_t pin_dirs, + uint32_t pin_mask) { + check_pio_param(pio); + pio->chip->pio_sm_set_pindirs_with_mask(pio, sm, pin_dirs, pin_mask); +} + +static inline void pio_sm_set_consecutive_pindirs(PIO pio, uint sm, + uint pin_base, uint pin_count, + bool is_out) { + check_pio_param(pio); + pio->chip->pio_sm_set_consecutive_pindirs(pio, sm, pin_base, pin_count, + is_out); +} + +static inline void pio_sm_set_enabled(PIO pio, uint sm, bool enabled) { + check_pio_param(pio); + pio->chip->pio_sm_set_enabled(pio, sm, enabled); +} + +static inline void pio_set_sm_mask_enabled(PIO pio, uint32_t mask, + bool enabled) { + check_pio_param(pio); + pio->chip->pio_sm_set_enabled_mask(pio, mask, enabled); +} + +static inline void pio_sm_restart(PIO pio, uint sm) { + check_pio_param(pio); + pio->chip->pio_sm_restart(pio, sm); +} + +static inline void pio_restart_sm_mask(PIO pio, uint32_t mask) { + check_pio_param(pio); + pio->chip->pio_sm_restart_mask(pio, mask); +} + +static inline void pio_sm_clkdiv_restart(PIO pio, uint sm) { + check_pio_param(pio); + pio->chip->pio_sm_clkdiv_restart(pio, sm); +} + +static inline void pio_clkdiv_restart_sm_mask(PIO pio, uint32_t mask) { + check_pio_param(pio); + pio->chip->pio_sm_clkdiv_restart_mask(pio, mask); +} + +static inline void pio_enable_sm_in_sync_mask(PIO pio, uint32_t mask) { + check_pio_param(pio); + pio->chip->pio_sm_enable_sync(pio, mask); +}; + +static inline void pio_sm_set_dmactrl(PIO pio, uint sm, bool is_tx, + uint32_t ctrl) { + check_pio_param(pio); + pio->chip->pio_sm_set_dmactrl(pio, sm, is_tx, ctrl); +}; + +static inline bool pio_sm_is_rx_fifo_empty(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_is_rx_fifo_empty(pio, sm); +} + +static inline bool pio_sm_is_rx_fifo_full(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_is_rx_fifo_full(pio, sm); +} + +static inline uint pio_sm_get_rx_fifo_level(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_get_rx_fifo_level(pio, sm); +} + +static inline bool pio_sm_is_tx_fifo_empty(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_is_tx_fifo_empty(pio, sm); +} + +static inline bool pio_sm_is_tx_fifo_full(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_is_tx_fifo_full(pio, sm); +} + +static inline uint pio_sm_get_tx_fifo_level(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_get_tx_fifo_level(pio, sm); +} + +static inline void pio_sm_drain_tx_fifo(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_drain_tx_fifo(pio, sm); +} + +static inline void pio_sm_put(PIO pio, uint sm, uint32_t data) { + check_pio_param(pio); + pio->chip->pio_sm_put(pio, sm, data, false); +} + +static inline void pio_sm_put_blocking(PIO pio, uint sm, uint32_t data) { + check_pio_param(pio); + pio->chip->pio_sm_put(pio, sm, data, true); +} + +static inline uint32_t pio_sm_get(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_get(pio, sm, false); +} + +static inline uint32_t pio_sm_get_blocking(PIO pio, uint sm) { + check_pio_param(pio); + return pio->chip->pio_sm_get(pio, sm, true); +} + +static inline pio_sm_config pio_get_default_sm_config_for_pio(PIO pio) { + check_pio_param(pio); + return pio->chip->pio_get_default_sm_config(pio); +} + +static inline pio_sm_config pio_get_default_sm_config(void) { + PIO pio = pio_get_current(); + return pio->chip->pio_get_default_sm_config(pio); +} + +static inline void sm_config_set_out_pins(pio_sm_config *c, uint out_base, + uint out_count) { + PIO pio = pio_get_current(); + pio->chip->smc_set_out_pins(pio, c, out_base, out_count); +} + +static inline void sm_config_set_set_pins(pio_sm_config *c, uint set_base, + uint set_count) { + PIO pio = pio_get_current(); + pio->chip->smc_set_set_pins(pio, c, set_base, set_count); +} + +static inline void sm_config_set_in_pins(pio_sm_config *c, uint in_base) { + PIO pio = pio_get_current(); + pio->chip->smc_set_in_pins(pio, c, in_base); +} + +static inline void sm_config_set_sideset_pins(pio_sm_config *c, + uint sideset_base) { + PIO pio = pio_get_current(); + pio->chip->smc_set_sideset_pins(pio, c, sideset_base); +} + +static inline void sm_config_set_sideset(pio_sm_config *c, uint bit_count, + bool optional, bool pindirs) { + PIO pio = pio_get_current(); + pio->chip->smc_set_sideset(pio, c, bit_count, optional, pindirs); +} + +static inline void sm_config_set_clkdiv_int_frac(pio_sm_config *c, + uint16_t div_int, + uint8_t div_frac) { + PIO pio = pio_get_current(); + pio->chip->smc_set_clkdiv_int_frac(pio, c, div_int, div_frac); +} + +static inline void sm_config_set_clkdiv(pio_sm_config *c, float div) { + PIO pio = pio_get_current(); + pio->chip->smc_set_clkdiv(pio, c, div); +} + +static inline void sm_config_set_wrap(pio_sm_config *c, uint wrap_target, + uint wrap) { + PIO pio = pio_get_current(); + pio->chip->smc_set_wrap(pio, c, wrap_target, wrap); +} + +static inline void sm_config_set_jmp_pin(pio_sm_config *c, uint pin) { + PIO pio = pio_get_current(); + pio->chip->smc_set_jmp_pin(pio, c, pin); +} + +static inline void sm_config_set_in_shift(pio_sm_config *c, bool shift_right, + bool autopush, uint push_threshold) { + PIO pio = pio_get_current(); + pio->chip->smc_set_in_shift(pio, c, shift_right, autopush, push_threshold); +} + +static inline void sm_config_set_out_shift(pio_sm_config *c, bool shift_right, + bool autopull, uint pull_threshold) { + PIO pio = pio_get_current(); + pio->chip->smc_set_out_shift(pio, c, shift_right, autopull, pull_threshold); +} + +static inline void sm_config_set_fifo_join(pio_sm_config *c, + enum pio_fifo_join join) { + PIO pio = pio_get_current(); + pio->chip->smc_set_fifo_join(pio, c, join); +} + +static inline void sm_config_set_out_special(pio_sm_config *c, bool sticky, + bool has_enable_pin, + uint enable_pin_index) { + PIO pio = pio_get_current(); + pio->chip->smc_set_out_special(pio, c, sticky, has_enable_pin, + enable_pin_index); +} + +static inline void sm_config_set_mov_status(pio_sm_config *c, + enum pio_mov_status_type status_sel, + uint status_n) { + PIO pio = pio_get_current(); + pio->chip->smc_set_mov_status(pio, c, status_sel, status_n); +} + +static inline void pio_gpio_init(PIO pio, uint pin) { + check_pio_param(pio); + pio->chip->pio_gpio_init(pio, pin); +} + +static inline uint32_t clock_get_hz(enum clock_index clk_index) { + PIO pio = pio_get_current(); + return pio->chip->clock_get_hz(pio, clk_index); +} + +static inline void gpio_init(uint gpio) { + PIO pio = pio_get_current(); + pio->chip->gpio_init(pio, gpio); +} + +static inline void gpio_set_function(uint gpio, enum gpio_function fn) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_function(pio, gpio, fn); +} + +static inline void gpio_set_pulls(uint gpio, bool up, bool down) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_pulls(pio, gpio, up, down); +} + +static inline void gpio_set_outover(uint gpio, uint value) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_outover(pio, gpio, value); +} + +static inline void gpio_set_inover(uint gpio, uint value) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_inover(pio, gpio, value); +} + +static inline void gpio_set_oeover(uint gpio, uint value) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_oeover(pio, gpio, value); +} + +static inline void gpio_set_input_enabled(uint gpio, bool enabled) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_input_enabled(pio, gpio, enabled); +} + +static inline void gpio_set_drive_strength(uint gpio, + enum gpio_drive_strength drive) { + PIO pio = pio_get_current(); + pio->chip->gpio_set_drive_strength(pio, gpio, drive); +} + +static inline void gpio_pull_up(uint gpio) { + gpio_set_pulls(gpio, true, false); +} + +static inline void gpio_pull_down(uint gpio) { + gpio_set_pulls(gpio, false, true); +} + +static inline void gpio_disable_pulls(uint gpio) { + gpio_set_pulls(gpio, false, false); +} + +static inline void stdio_init_all(void) {} + +void sleep_us(uint64_t us); + +static inline void sleep_ms(uint32_t ms) { + sleep_us((uint64_t)(ms * (uint64_t)1000)); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/piolib/include/piolib_priv.h b/piolib/include/piolib_priv.h new file mode 100644 index 0000000..45be81b --- /dev/null +++ b/piolib/include/piolib_priv.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023-24 Raspberry Pi Ltd. + * All rights reserved. + */ + +#ifndef _PIOLIB_PRIV_H +#define _PIOLIB_PRIV_H + +#include "pio_platform.h" + +#define DECLARE_PIO_CHIP(chip) \ + const PIO_CHIP_T *__ptr_##chip __attribute__((section("piochips"))) \ + __attribute__((used)) = &chip + +#endif diff --git a/piolib/include/rp1_pio_if.h b/piolib/include/rp1_pio_if.h new file mode 100644 index 0000000..eceb4ab --- /dev/null +++ b/piolib/include/rp1_pio_if.h @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023-24 Raspberry Pi Ltd. + * All rights reserved. + */ +#ifndef _RP1_PIO_IF_H +#define _RP1_PIO_IF_H + +#include + +#define RP1_PIO_INSTRUCTION_COUNT 32 +#define RP1_PIO_SM_COUNT 4 +#define RP1_PIO_GPIO_COUNT 28 +#define RP1_GPIO_FUNC_PIO 7 + +#define RP1_PIO_ORIGIN_ANY ((uint16_t)(~0)) + +#define RP1_PIO_DIR_TO_SM 0 +#define RP1_PIO_DIR_FROM_SM 1 +#define RP1_PIO_DIR_COUNT 2 + +typedef struct { + uint32_t clkdiv; + uint32_t execctrl; + uint32_t shiftctrl; + uint32_t pinctrl; +} rp1_pio_sm_config; + +struct rp1_pio_add_program_args { + uint16_t num_instrs; + uint16_t origin; + uint16_t instrs[RP1_PIO_INSTRUCTION_COUNT]; +}; + +struct rp1_pio_remove_program_args { + uint16_t num_instrs; + uint16_t origin; +}; + +struct rp1_pio_sm_claim_args { + uint16_t mask; +}; + +struct rp1_pio_sm_init_args { + uint16_t sm; + uint16_t initial_pc; + rp1_pio_sm_config config; +}; + +struct rp1_pio_sm_set_config_args { + uint16_t sm; + uint16_t rsvd; + rp1_pio_sm_config config; +}; + +struct rp1_pio_sm_exec_args { + uint16_t sm; + uint16_t instr; + uint8_t blocking; + uint8_t rsvd; +}; + +struct rp1_pio_sm_clear_fifos_args { + uint16_t sm; +}; + +struct rp1_pio_sm_set_clkdiv_args { + uint16_t sm; + uint16_t div_int; + uint8_t div_frac; + uint8_t rsvd; +}; + +struct rp1_pio_sm_set_pins_args { + uint16_t sm; + uint16_t rsvd; + uint32_t values; + uint32_t mask; +}; + +struct rp1_pio_sm_set_pindirs_args { + uint16_t sm; + uint16_t rsvd; + uint32_t dirs; + uint32_t mask; +}; + +struct rp1_pio_sm_set_enabled_args { + uint16_t mask; + uint8_t enable; + uint8_t rsvd; +}; + +struct rp1_pio_sm_restart_args { + uint16_t mask; +}; + +struct rp1_pio_sm_clkdiv_restart_args { + uint16_t mask; +}; + +struct rp1_pio_sm_enable_sync_args { + uint16_t mask; +}; + +struct rp1_pio_sm_put_args { + uint16_t sm; + uint8_t blocking; + uint8_t rsvd; + uint32_t data; +}; + +struct rp1_pio_sm_get_args { + uint16_t sm; + uint8_t blocking; + uint8_t rsvd; + uint32_t data; /* OUT */ +}; + +struct rp1_pio_sm_set_dmactrl_args { + uint16_t sm; + uint8_t is_tx; + uint8_t rsvd; + uint32_t ctrl; +}; + +struct rp1_pio_sm_fifo_state_args { + uint16_t sm; + uint8_t tx; + uint8_t rsvd; + uint16_t level; /* OUT */ + uint8_t empty; /* OUT */ + uint8_t full; /* OUT */ +}; + +struct rp1_gpio_init_args { + uint16_t gpio; +}; + +struct rp1_gpio_set_function_args { + uint16_t gpio; + uint16_t fn; +}; + +struct rp1_gpio_set_pulls_args { + uint16_t gpio; + uint8_t up; + uint8_t down; +}; + +struct rp1_gpio_set_args { + uint16_t gpio; + uint16_t value; +}; + +struct rp1_pio_sm_config_xfer_args { + uint16_t sm; + uint16_t dir; + uint16_t buf_size; + uint16_t buf_count; +}; + +struct rp1_pio_sm_xfer_data_args { + uint16_t sm; + uint16_t dir; + uint16_t data_bytes; + void *data; +}; + +struct rp1_access_hw_args { + uint32_t addr; + uint32_t len; + void *data; +}; + +#define PIO_IOC_MAGIC 102 + +#define PIO_IOC_SM_CONFIG_XFER \ + _IOW(PIO_IOC_MAGIC, 0, struct rp1_pio_sm_config_xfer_args) +#define PIO_IOC_SM_XFER_DATA \ + _IOW(PIO_IOC_MAGIC, 1, struct rp1_pio_sm_xfer_data_args) + +#ifdef CONFIG_COMPAT +// XXX #define PIO_IOC_SM_XFER_DATA32 _IOW(PIO_IOC_MAGIC, 2, struct +// pio_sm_xfer_data_args) +#endif + +#define PIO_IOC_READ_HW _IOW(PIO_IOC_MAGIC, 8, struct rp1_access_hw_args) +#define PIO_IOC_WRITE_HW _IOW(PIO_IOC_MAGIC, 9, struct rp1_access_hw_args) + +#define PIO_IOC_CAN_ADD_PROGRAM \ + _IOW(PIO_IOC_MAGIC, 10, struct rp1_pio_add_program_args) +#define PIO_IOC_ADD_PROGRAM \ + _IOW(PIO_IOC_MAGIC, 11, struct rp1_pio_add_program_args) +#define PIO_IOC_REMOVE_PROGRAM \ + _IOW(PIO_IOC_MAGIC, 12, struct rp1_pio_remove_program_args) +#define PIO_IOC_CLEAR_INSTR_MEM _IO(PIO_IOC_MAGIC, 13) + +#define PIO_IOC_SM_CLAIM _IOW(PIO_IOC_MAGIC, 20, struct rp1_pio_sm_claim_args) +#define PIO_IOC_SM_UNCLAIM _IOW(PIO_IOC_MAGIC, 21, struct rp1_pio_sm_claim_args) +#define PIO_IOC_SM_IS_CLAIMED \ + _IOW(PIO_IOC_MAGIC, 22, struct rp1_pio_sm_claim_args) + +#define PIO_IOC_SM_INIT _IOW(PIO_IOC_MAGIC, 30, struct rp1_pio_sm_init_args) +#define PIO_IOC_SM_SET_CONFIG \ + _IOW(PIO_IOC_MAGIC, 31, struct rp1_pio_sm_set_config_args) +#define PIO_IOC_SM_EXEC _IOW(PIO_IOC_MAGIC, 32, struct rp1_pio_sm_exec_args) +#define PIO_IOC_SM_CLEAR_FIFOS \ + _IOW(PIO_IOC_MAGIC, 33, struct rp1_pio_sm_clear_fifos_args) +#define PIO_IOC_SM_SET_CLKDIV \ + _IOW(PIO_IOC_MAGIC, 34, struct rp1_pio_sm_set_clkdiv_args) +#define PIO_IOC_SM_SET_PINS \ + _IOW(PIO_IOC_MAGIC, 35, struct rp1_pio_sm_set_pins_args) +#define PIO_IOC_SM_SET_PINDIRS \ + _IOW(PIO_IOC_MAGIC, 36, struct rp1_pio_sm_set_pindirs_args) +#define PIO_IOC_SM_SET_ENABLED \ + _IOW(PIO_IOC_MAGIC, 37, struct rp1_pio_sm_set_enabled_args) +#define PIO_IOC_SM_RESTART \ + _IOW(PIO_IOC_MAGIC, 38, struct rp1_pio_sm_restart_args) +#define PIO_IOC_SM_CLKDIV_RESTART \ + _IOW(PIO_IOC_MAGIC, 39, struct rp1_pio_sm_restart_args) +#define PIO_IOC_SM_ENABLE_SYNC \ + _IOW(PIO_IOC_MAGIC, 40, struct rp1_pio_sm_enable_sync_args) +#define PIO_IOC_SM_PUT _IOW(PIO_IOC_MAGIC, 41, struct rp1_pio_sm_put_args) +#define PIO_IOC_SM_GET _IOWR(PIO_IOC_MAGIC, 42, struct rp1_pio_sm_get_args) +#define PIO_IOC_SM_SET_DMACTRL \ + _IOW(PIO_IOC_MAGIC, 43, struct rp1_pio_sm_set_dmactrl_args) +#define PIO_IOC_SM_FIFO_STATE \ + _IOW(PIO_IOC_MAGIC, 44, struct rp1_pio_sm_fifo_state_args) +#define PIO_IOC_SM_DRAIN_TX \ + _IOW(PIO_IOC_MAGIC, 45, struct rp1_pio_sm_clear_fifos_args) + +#define PIO_IOC_GPIO_INIT _IOW(PIO_IOC_MAGIC, 50, struct rp1_gpio_init_args) +#define PIO_IOC_GPIO_SET_FUNCTION \ + _IOW(PIO_IOC_MAGIC, 51, struct rp1_gpio_set_function_args) +#define PIO_IOC_GPIO_SET_PULLS \ + _IOW(PIO_IOC_MAGIC, 52, struct rp1_gpio_set_pulls_args) +#define PIO_IOC_GPIO_SET_OUTOVER \ + _IOW(PIO_IOC_MAGIC, 53, struct rp1_gpio_set_args) +#define PIO_IOC_GPIO_SET_INOVER \ + _IOW(PIO_IOC_MAGIC, 54, struct rp1_gpio_set_args) +#define PIO_IOC_GPIO_SET_OEOVER \ + _IOW(PIO_IOC_MAGIC, 55, struct rp1_gpio_set_args) +#define PIO_IOC_GPIO_SET_INPUT_ENABLED \ + _IOW(PIO_IOC_MAGIC, 56, struct rp1_gpio_set_args) +#define PIO_IOC_GPIO_SET_DRIVE_STRENGTH \ + _IOW(PIO_IOC_MAGIC, 57, struct rp1_gpio_set_args) + +#endif diff --git a/piolib/pio_rp1.c b/piolib/pio_rp1.c new file mode 100644 index 0000000..0e7c24e --- /dev/null +++ b/piolib/pio_rp1.c @@ -0,0 +1,946 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 Raspberry Pi Ltd. + * All rights reserved. + */ + +#include +#include +#include +#include +#include +#include + +#define PIOLIB_INTERNALS + +#include "pio_platform.h" + +#define pio_encode_delay _pio_encode_delay +#define pio_encode_sideset _pio_encode_sideset +#define pio_encode_sideset_opt _pio_encode_sideset_opt +#define pio_encode_jmp _pio_encode_jmp +#define pio_encode_jmp_not_x _pio_encode_jmp_not_x +#define pio_encode_jmp_x_dec _pio_encode_jmp_x_dec +#define pio_encode_jmp_not_y _pio_encode_jmp_not_y +#define pio_encode_jmp_y_dec _pio_encode_jmp_y_dec +#define pio_encode_jmp_x_ne_y _pio_encode_jmp_x_ne_y +#define pio_encode_jmp_pin _pio_encode_jmp_pin +#define pio_encode_jmp_not_osre _pio_encode_jmp_not_osre +#define pio_encode_wait_gpio _pio_encode_wait_gpio +#define pio_encode_wait_pin _pio_encode_wait_pin +#define pio_encode_wait_irq _pio_encode_wait_irq +#define pio_encode_in _pio_encode_in +#define pio_encode_out _pio_encode_out +#define pio_encode_push _pio_encode_push +#define pio_encode_pull _pio_encode_pull +#define pio_encode_mov _pio_encode_mov +#define pio_encode_mov_not _pio_encode_mov_not +#define pio_encode_mov_reverse _pio_encode_mov_reverse +#define pio_encode_irq_set _pio_encode_irq_set +#define pio_encode_irq_wait _pio_encode_irq_wait +#define pio_encode_irq_clear _pio_encode_irq_clear +#define pio_encode_set _pio_encode_set +#define pio_encode_nop _pio_encode_nop +#include "hardware/pio_instructions.h" +#undef pio_encode_delay +#undef pio_encode_sideset +#undef pio_encode_sideset_opt +#undef pio_encode_jmp +#undef pio_encode_jmp_not_x +#undef pio_encode_jmp_x_dec +#undef pio_encode_jmp_not_y +#undef pio_encode_jmp_y_dec +#undef pio_encode_jmp_x_ne_y +#undef pio_encode_jmp_pin +#undef pio_encode_jmp_not_osre +#undef pio_encode_wait_gpio +#undef pio_encode_wait_pin +#undef pio_encode_wait_irq +#undef pio_encode_in +#undef pio_encode_out +#undef pio_encode_push +#undef pio_encode_pull +#undef pio_encode_mov +#undef pio_encode_mov_not +#undef pio_encode_mov_reverse +#undef pio_encode_irq_set +#undef pio_encode_irq_wait +#undef pio_encode_irq_clear +#undef pio_encode_set +#undef pio_encode_nop + +#include "hardware/gpio.h" +#include "hardware/pio.h" +#include "hardware/regs/proc_pio.h" +#include "piolib.h" +#include "piolib_priv.h" +#include "rp1_pio_if.h" + +typedef struct rp1_pio_handle { + struct pio_instance base; + const char *devname; + int fd; +} * RP1_PIO; + +#define smc_to_rp1(_config, _c) \ + rp1_pio_sm_config *_c = (rp1_pio_sm_config *)_config + +#define GPIOS_MASK ((1 << RP1_PIO_GPIO_COUNT) - 1) + +STATIC_ASSERT(sizeof(rp1_pio_sm_config) <= sizeof(pio_sm_config)); + +static inline void check_sm_param(__unused uint sm) { + valid_params_if(PIO, sm < RP1_PIO_SM_COUNT); +} + +static inline void check_sm_mask(__unused uint mask) { + valid_params_if(PIO, mask < (1u << RP1_PIO_SM_COUNT)); +} + +static pio_sm_config rp1_pio_get_default_sm_config(PIO pio) { + pio_sm_config c = {{0}}; + sm_config_set_clkdiv_int_frac(&c, 1, 0); + sm_config_set_wrap(&c, 0, 31); + sm_config_set_in_shift(&c, true, false, 32); + sm_config_set_out_shift(&c, true, false, 32); + return c; +} + +static uint rp1_pio_encode_delay(PIO pio, uint cycles) { + return _pio_encode_delay(cycles); +} + +static uint rp1_pio_encode_sideset(PIO pio, uint sideset_bit_count, + uint value) { + return _pio_encode_sideset(sideset_bit_count, value); +} + +static uint rp1_pio_encode_sideset_opt(PIO pio, uint sideset_bit_count, + uint value) { + return _pio_encode_sideset_opt(sideset_bit_count, value); +} + +static uint rp1_pio_encode_jmp(PIO pio, uint addr) { + return _pio_encode_jmp(addr); +} + +static uint rp1_pio_encode_jmp_not_x(PIO pio, uint addr) { + return _pio_encode_jmp_not_x(addr); +} + +static uint rp1_pio_encode_jmp_x_dec(PIO pio, uint addr) { + return _pio_encode_jmp_x_dec(addr); +} + +static uint rp1_pio_encode_jmp_not_y(PIO pio, uint addr) { + return _pio_encode_jmp_not_y(addr); +} + +static uint rp1_pio_encode_jmp_y_dec(PIO pio, uint addr) { + return _pio_encode_jmp_y_dec(addr); +} + +static uint rp1_pio_encode_jmp_x_ne_y(PIO pio, uint addr) { + return _pio_encode_jmp_x_ne_y(addr); +} + +static uint rp1_pio_encode_jmp_pin(PIO pio, uint addr) { + return _pio_encode_jmp_pin(addr); +} + +static uint rp1_pio_encode_jmp_not_osre(PIO pio, uint addr) { + return _pio_encode_jmp_not_osre(addr); +} + +static uint rp1_pio_encode_wait_gpio(PIO pio, bool polarity, uint gpio) { + return _pio_encode_wait_gpio(polarity, gpio); +} + +static uint rp1_pio_encode_wait_pin(PIO pio, bool polarity, uint pin) { + return _pio_encode_wait_pin(polarity, pin); +} + +static uint rp1_pio_encode_wait_irq(PIO pio, bool polarity, bool relative, + uint irq) { + return _pio_encode_wait_irq(polarity, relative, irq); +} + +static uint rp1_pio_encode_in(PIO pio, enum pio_src_dest src, uint count) { + return _pio_encode_in(src, count); +} + +static uint rp1_pio_encode_out(PIO pio, enum pio_src_dest dest, uint count) { + return _pio_encode_out(dest, count); +} + +static uint rp1_pio_encode_push(PIO pio, bool if_full, bool block) { + return _pio_encode_push(if_full, block); +} + +static uint rp1_pio_encode_pull(PIO pio, bool if_empty, bool block) { + return _pio_encode_pull(if_empty, block); +} + +static uint rp1_pio_encode_mov(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src) { + return _pio_encode_mov(dest, src); +} + +static uint rp1_pio_encode_mov_not(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src) { + return _pio_encode_mov_not(dest, src); +} + +static uint rp1_pio_encode_mov_reverse(PIO pio, enum pio_src_dest dest, + enum pio_src_dest src) { + return _pio_encode_mov_reverse(dest, src); +} + +static uint rp1_pio_encode_irq_set(PIO pio, bool relative, uint irq) { + return _pio_encode_irq_set(relative, irq); +} + +static uint rp1_pio_encode_irq_wait(PIO pio, bool relative, uint irq) { + return _pio_encode_irq_wait(relative, irq); +} + +static uint rp1_pio_encode_irq_clear(PIO pio, bool relative, uint irq) { + return _pio_encode_irq_clear(relative, irq); +} + +static uint rp1_pio_encode_set(PIO pio, enum pio_src_dest dest, uint value) { + return _pio_encode_set(dest, value); +} + +static uint rp1_pio_encode_nop(PIO pio) { return _pio_encode_nop(); } + +static int rp1_ioctl(PIO pio, int request, void *args) { + RP1_PIO rp = (RP1_PIO)pio; + int err = ioctl(rp->fd, request, args); + switch (err) { + case -EREMOTEIO: + case -ETIMEDOUT: + pio_panic("Error communicating with RP1"); + break; + default: + break; + } + return err; +} + +static int rp1_pio_sm_config_xfer(PIO pio, uint sm, uint dir, uint buf_size, + uint buf_count) { + struct rp1_pio_sm_config_xfer_args args = { + .sm = sm, .dir = dir, .buf_size = buf_size, .buf_count = buf_count}; + int err; + check_sm_param(sm); + err = rp1_ioctl(pio, PIO_IOC_SM_CONFIG_XFER, &args); + return (err > 0); +} + +static int rp1_pio_sm_xfer_data(PIO pio, uint sm, uint dir, uint data_bytes, + void *data) { + struct rp1_pio_sm_xfer_data_args args = { + .sm = sm, .dir = dir, .data_bytes = data_bytes, .data = data}; + int err; + check_sm_param(sm); + err = rp1_ioctl(pio, PIO_IOC_SM_XFER_DATA, &args); + return (err > 0); +} + +static bool rp1_pio_can_add_program_at_offset(PIO pio, + const pio_program_t *program, + uint offset) { + struct rp1_pio_add_program_args args = {.num_instrs = program->length, + .origin = program->origin}; + int err; + valid_params_if(PIO, offset < RP1_PIO_INSTRUCTION_COUNT || + offset == PIO_ORIGIN_ANY); + valid_params_if(PIO, program->length <= RP1_PIO_INSTRUCTION_COUNT); + valid_params_if(PIO, + offset + program->length <= RP1_PIO_INSTRUCTION_COUNT || + offset == PIO_ORIGIN_ANY); + if (program->origin >= 0 && (uint)program->origin != offset) + return false; + if (offset != PIO_ORIGIN_ANY) + args.origin = offset; + memcpy(args.instrs, program->instructions, + program->length * sizeof(uint16_t)); + err = rp1_ioctl(pio, PIO_IOC_CAN_ADD_PROGRAM, &args); + return (err > 0); +} + +static uint rp1_pio_add_program_at_offset(PIO pio, const pio_program_t *program, + uint offset) { + struct rp1_pio_add_program_args args = {.num_instrs = program->length, + .origin = program->origin}; + valid_params_if(PIO, offset < RP1_PIO_INSTRUCTION_COUNT || + offset == PIO_ORIGIN_ANY); + valid_params_if(PIO, program->length <= RP1_PIO_INSTRUCTION_COUNT); + valid_params_if(PIO, + offset + program->length <= RP1_PIO_INSTRUCTION_COUNT || + offset == PIO_ORIGIN_ANY); + if (offset != PIO_ORIGIN_ANY) + args.origin = offset; + memcpy(args.instrs, program->instructions, + program->length * sizeof(uint16_t)); + return rp1_ioctl(pio, PIO_IOC_ADD_PROGRAM, &args); +} + +static bool rp1_pio_remove_program(PIO pio, const pio_program_t *program, + uint offset) { + struct rp1_pio_remove_program_args args = {.num_instrs = program->length, + .origin = offset}; + valid_params_if(PIO, offset < RP1_PIO_INSTRUCTION_COUNT); + valid_params_if(PIO, offset + program->length <= RP1_PIO_INSTRUCTION_COUNT); + return !rp1_ioctl(pio, PIO_IOC_REMOVE_PROGRAM, &args); +} + +static bool rp1_pio_clear_instruction_memory(PIO pio) { + return !rp1_ioctl(pio, PIO_IOC_CLEAR_INSTR_MEM, NULL); +} + +static bool rp1_pio_sm_claim(PIO pio, uint sm) { + struct rp1_pio_sm_claim_args args = {.mask = (1 << sm)}; + check_sm_param(sm); + return (rp1_ioctl(pio, PIO_IOC_SM_CLAIM, &args) >= 0); +} + +static bool rp1_pio_sm_claim_mask(PIO pio, uint mask) { + struct rp1_pio_sm_claim_args args = {.mask = mask}; + valid_params_if(PIO, !!mask); + check_sm_mask(mask); + return (rp1_ioctl(pio, PIO_IOC_SM_CLAIM, &args) >= 0); +} + +static bool rp1_pio_sm_unclaim(PIO pio, uint sm) { + struct rp1_pio_sm_claim_args args = {.mask = (1 << sm)}; + check_sm_param(sm); + return !rp1_ioctl(pio, PIO_IOC_SM_UNCLAIM, &args); +} + +static int rp1_pio_sm_claim_unused(PIO pio, bool required) { + struct rp1_pio_sm_claim_args args = {.mask = 0}; + int sm = rp1_ioctl(pio, PIO_IOC_SM_CLAIM, &args); + if (sm < 0 && required) + pio_panic("No PIO state machines are available"); + return sm; +} + +static bool rp1_pio_sm_is_claimed(PIO pio, uint sm) { + struct rp1_pio_sm_claim_args args = {.mask = (1 << sm)}; + check_sm_param(sm); + int err = rp1_ioctl(pio, PIO_IOC_SM_IS_CLAIMED, &args); + return (err > 0); +} + +static void rp1_pio_sm_init(PIO pio, uint sm, uint initial_pc, + const pio_sm_config *config) { + smc_to_rp1(config, c); + struct rp1_pio_sm_init_args args = { + .sm = sm, .initial_pc = initial_pc, .config = *c}; + valid_params_if(PIO, initial_pc < RP1_PIO_INSTRUCTION_COUNT); + + (void)rp1_ioctl(pio, PIO_IOC_SM_INIT, &args); +} + +static void rp1_pio_sm_set_config(PIO pio, uint sm, + const pio_sm_config *config) { + smc_to_rp1(config, c); + struct rp1_pio_sm_init_args args = {.sm = sm, .config = *c}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_CONFIG, &args); +} + +static void rp1_pio_sm_exec(PIO pio, uint sm, uint instr, bool blocking) { + struct rp1_pio_sm_exec_args args = { + .sm = sm, .instr = instr, .blocking = blocking}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_EXEC, &args); +} + +static void rp1_pio_sm_clear_fifos(PIO pio, uint sm) { + struct rp1_pio_sm_clear_fifos_args args = {.sm = sm}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_CLEAR_FIFOS, &args); +} + +static void rp1_pio_calculate_clkdiv_from_float(float div, uint16_t *div_int, + uint8_t *div_frac) { + valid_params_if(PIO, div >= 1 && div <= 65536); + *div_int = (uint16_t)div; + if (*div_int == 0) { + *div_frac = 0; + } else { + *div_frac = (uint8_t)((div - (float)*div_int) * (1u << 8u)); + } +} + +static void rp1_pio_sm_set_clkdiv_int_frac(PIO pio, uint sm, uint16_t div_int, + uint8_t div_frac) { + struct rp1_pio_sm_set_clkdiv_args args = { + .sm = sm, .div_int = div_int, .div_frac = div_frac}; + + check_sm_param(sm); + invalid_params_if(PIO, div_int == 0 && div_frac != 0); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_CLKDIV, &args); +} + +static void rp1_pio_sm_set_clkdiv(PIO pio, uint sm, float div) { + uint16_t div_int; + uint8_t div_frac; + + check_sm_param(sm); + rp1_pio_calculate_clkdiv_from_float(div, &div_int, &div_frac); + rp1_pio_sm_set_clkdiv_int_frac(pio, sm, div_int, div_frac); +} + +static void rp1_pio_sm_set_pins(PIO pio, uint sm, uint32_t pin_values) { + struct rp1_pio_sm_set_pins_args args = { + .sm = sm, .values = pin_values, .mask = GPIOS_MASK}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_PINS, &args); +} + +static void rp1_pio_sm_set_pins_with_mask(PIO pio, uint sm, uint32_t pin_values, + uint32_t pin_mask) { + struct rp1_pio_sm_set_pins_args args = { + .sm = sm, .values = pin_values, .mask = pin_mask}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_PINS, &args); +} + +static void rp1_pio_sm_set_pindirs_with_mask(PIO pio, uint sm, + uint32_t pin_dirs, + uint32_t pin_mask) { + struct rp1_pio_sm_set_pindirs_args args = { + .sm = sm, .dirs = pin_dirs, .mask = pin_mask}; + + check_sm_param(sm); + valid_params_if(PIO, (pin_dirs & GPIOS_MASK) == pin_dirs); + valid_params_if(PIO, (pin_mask & pin_mask) == pin_mask); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_PINDIRS, &args); +} + +static void rp1_pio_sm_set_consecutive_pindirs(PIO pio, uint sm, uint pin_base, + uint pin_count, bool is_out) { + uint32_t mask = ((1 << pin_count) - 1) << pin_base; + struct rp1_pio_sm_set_pindirs_args args = { + .sm = sm, .dirs = is_out ? mask : 0, .mask = mask}; + + check_sm_param(sm); + valid_params_if(PIO, pin_base < RP1_PIO_GPIO_COUNT && + pin_count < RP1_PIO_GPIO_COUNT && + (pin_base + pin_count) < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_PINDIRS, &args); +} + +static void rp1_pio_sm_set_enabled(PIO pio, uint sm, bool enabled) { + struct rp1_pio_sm_set_enabled_args args = {.mask = (1 << sm), + .enable = enabled}; + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_ENABLED, &args); +} + +static void rp1_pio_sm_set_enabled_mask(PIO pio, uint32_t mask, bool enabled) { + struct rp1_pio_sm_set_enabled_args args = {.mask = (uint16_t)mask, + .enable = enabled}; + check_sm_mask(mask); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_ENABLED, &args); +} + +static void rp1_pio_sm_restart(PIO pio, uint sm) { + struct rp1_pio_sm_restart_args args = {.mask = (1 << sm)}; + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_RESTART, &args); +} + +static void rp1_pio_sm_restart_mask(PIO pio, uint32_t mask) { + struct rp1_pio_sm_restart_args args = {.mask = (uint16_t)mask}; + check_sm_mask(mask); + (void)rp1_ioctl(pio, PIO_IOC_SM_RESTART, &args); +} + +static void rp1_pio_sm_clkdiv_restart(PIO pio, uint sm) { + struct rp1_pio_sm_restart_args args = {.mask = (1 << sm)}; + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_CLKDIV_RESTART, &args); +} + +static void rp1_pio_sm_clkdiv_restart_mask(PIO pio, uint32_t mask) { + struct rp1_pio_sm_restart_args args = {.mask = (uint16_t)mask}; + + check_sm_mask(mask); + (void)rp1_ioctl(pio, PIO_IOC_SM_CLKDIV_RESTART, &args); +} + +static void rp1_pio_sm_enable_sync(PIO pio, uint32_t mask) { + struct rp1_pio_sm_enable_sync_args args = {.mask = (uint16_t)mask}; + + check_sm_mask(mask); + (void)rp1_ioctl(pio, PIO_IOC_SM_ENABLE_SYNC, &args); +} + +static void rp1_pio_sm_put(PIO pio, uint sm, uint32_t data, bool blocking) { + struct rp1_pio_sm_put_args args = { + .sm = (uint16_t)sm, .blocking = blocking, .data = data}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_PUT, &args); +} + +static uint32_t rp1_pio_sm_get(PIO pio, uint sm, bool blocking) { + struct rp1_pio_sm_get_args args = {.sm = (uint16_t)sm, + .blocking = blocking}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_GET, &args); + return args.data; +} + +static void rp1_pio_sm_set_dmactrl(PIO pio, uint sm, bool is_tx, + uint32_t ctrl) { + struct rp1_pio_sm_set_dmactrl_args args = { + .sm = sm, .is_tx = is_tx, .ctrl = ctrl}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_SET_DMACTRL, &args); +} + +static bool rp1_pio_sm_is_rx_fifo_empty(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = false}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.empty; +} + +static bool rp1_pio_sm_is_rx_fifo_full(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = false}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.full; +} + +static uint rp1_pio_sm_get_rx_fifo_level(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = false}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.level; +} + +static bool rp1_pio_sm_is_tx_fifo_empty(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = true}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.empty; +} + +static bool rp1_pio_sm_is_tx_fifo_full(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = true}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.full; +} + +static uint rp1_pio_sm_get_tx_fifo_level(PIO pio, uint sm) { + struct rp1_pio_sm_fifo_state_args args = {.sm = sm, .tx = true}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_FIFO_STATE, &args); + return args.level; +} + +static void rp1_pio_sm_drain_tx_fifo(PIO pio, uint sm) { + struct rp1_pio_sm_clear_fifos_args args = {.sm = sm}; + + check_sm_param(sm); + (void)rp1_ioctl(pio, PIO_IOC_SM_DRAIN_TX, &args); +} + +static void rp1_smc_set_out_pins(PIO pio, pio_sm_config *config, uint out_base, + uint out_count) { + smc_to_rp1(config, c); + valid_params_if(PIO, out_base < RP1_PIO_GPIO_COUNT); + valid_params_if(PIO, out_count <= RP1_PIO_GPIO_COUNT); + c->pinctrl = (c->pinctrl & ~(PROC_PIO_SM0_PINCTRL_OUT_BASE_BITS | + PROC_PIO_SM0_PINCTRL_OUT_COUNT_BITS)) | + (out_base << PROC_PIO_SM0_PINCTRL_OUT_BASE_LSB) | + (out_count << PROC_PIO_SM0_PINCTRL_OUT_COUNT_LSB); +} + +static void rp1_smc_set_set_pins(PIO pio, pio_sm_config *config, uint set_base, + uint set_count) { + smc_to_rp1(config, c); + valid_params_if(PIO, set_base < RP1_PIO_GPIO_COUNT); + valid_params_if(PIO, set_count <= 5); + c->pinctrl = (c->pinctrl & ~(PROC_PIO_SM0_PINCTRL_SET_BASE_BITS | + PROC_PIO_SM0_PINCTRL_SET_COUNT_BITS)) | + (set_base << PROC_PIO_SM0_PINCTRL_SET_BASE_LSB) | + (set_count << PROC_PIO_SM0_PINCTRL_SET_COUNT_LSB); +} + +static void rp1_smc_set_in_pins(PIO pio, pio_sm_config *config, uint in_base) { + smc_to_rp1(config, c); + valid_params_if(PIO, in_base < RP1_PIO_GPIO_COUNT); + c->pinctrl = (c->pinctrl & ~PROC_PIO_SM0_PINCTRL_IN_BASE_BITS) | + (in_base << PROC_PIO_SM0_PINCTRL_IN_BASE_LSB); +} + +static void rp1_smc_set_sideset_pins(PIO pio, pio_sm_config *config, + uint sideset_base) { + smc_to_rp1(config, c); + valid_params_if(PIO, sideset_base < RP1_PIO_GPIO_COUNT); + c->pinctrl = (c->pinctrl & ~PROC_PIO_SM0_PINCTRL_SIDESET_BASE_BITS) | + (sideset_base << PROC_PIO_SM0_PINCTRL_SIDESET_BASE_LSB); +} + +static void rp1_smc_set_sideset(PIO pio, pio_sm_config *config, uint bit_count, + bool optional, bool pindirs) { + smc_to_rp1(config, c); + valid_params_if(PIO, bit_count <= 5); + valid_params_if(PIO, !optional || bit_count >= 1); + c->pinctrl = (c->pinctrl & ~PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_BITS) | + (bit_count << PROC_PIO_SM0_PINCTRL_SIDESET_COUNT_LSB); + + c->execctrl = + (c->execctrl & ~(PROC_PIO_SM0_EXECCTRL_SIDE_EN_BITS | + PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_BITS)) | + (bool_to_bit(optional) << PROC_PIO_SM0_EXECCTRL_SIDE_EN_LSB) | + (bool_to_bit(pindirs) << PROC_PIO_SM0_EXECCTRL_SIDE_PINDIR_LSB); +} + +static void rp1_smc_set_clkdiv_int_frac(PIO pio, pio_sm_config *config, + uint16_t div_int, uint8_t div_frac) { + smc_to_rp1(config, c); + invalid_params_if(PIO, div_int == 0 && div_frac != 0); + c->clkdiv = (((uint)div_frac) << PROC_PIO_SM0_CLKDIV_FRAC_LSB) | + (((uint)div_int) << PROC_PIO_SM0_CLKDIV_INT_LSB); +} + +static void rp1_smc_set_clkdiv(PIO pio, pio_sm_config *config, float div) { + uint16_t div_int; + uint8_t div_frac; + rp1_pio_calculate_clkdiv_from_float(div, &div_int, &div_frac); + sm_config_set_clkdiv_int_frac(config, div_int, div_frac); +} + +static void rp1_smc_set_wrap(PIO pio, pio_sm_config *config, uint wrap_target, + uint wrap) { + smc_to_rp1(config, c); + valid_params_if(PIO, wrap < RP1_PIO_INSTRUCTION_COUNT); + valid_params_if(PIO, wrap_target < RP1_PIO_INSTRUCTION_COUNT); + c->execctrl = (c->execctrl & ~(PROC_PIO_SM0_EXECCTRL_WRAP_TOP_BITS | + PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_BITS)) | + (wrap_target << PROC_PIO_SM0_EXECCTRL_WRAP_BOTTOM_LSB) | + (wrap << PROC_PIO_SM0_EXECCTRL_WRAP_TOP_LSB); +} + +static void rp1_smc_set_jmp_pin(PIO pio, pio_sm_config *config, uint pin) { + smc_to_rp1(config, c); + valid_params_if(PIO, pin < RP1_PIO_GPIO_COUNT); + c->execctrl = (c->execctrl & ~PROC_PIO_SM0_EXECCTRL_JMP_PIN_BITS) | + (pin << PROC_PIO_SM0_EXECCTRL_JMP_PIN_LSB); +} + +static void rp1_smc_set_in_shift(PIO pio, pio_sm_config *config, + bool shift_right, bool autopush, + uint push_threshold) { + smc_to_rp1(config, c); + valid_params_if(PIO, push_threshold <= 32); + c->shiftctrl = + (c->shiftctrl & ~(PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_BITS | + PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_BITS | + PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_BITS)) | + (bool_to_bit(shift_right) << PROC_PIO_SM0_SHIFTCTRL_IN_SHIFTDIR_LSB) | + (bool_to_bit(autopush) << PROC_PIO_SM0_SHIFTCTRL_AUTOPUSH_LSB) | + ((push_threshold & 0x1fu) << PROC_PIO_SM0_SHIFTCTRL_PUSH_THRESH_LSB); +} + +static void rp1_smc_set_out_shift(PIO pio, pio_sm_config *config, + bool shift_right, bool autopull, + uint pull_threshold) { + smc_to_rp1(config, c); + valid_params_if(PIO, pull_threshold <= 32); + c->shiftctrl = + (c->shiftctrl & ~(PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_BITS | + PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_BITS | + PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_BITS)) | + (bool_to_bit(shift_right) << PROC_PIO_SM0_SHIFTCTRL_OUT_SHIFTDIR_LSB) | + (bool_to_bit(autopull) << PROC_PIO_SM0_SHIFTCTRL_AUTOPULL_LSB) | + ((pull_threshold & 0x1fu) << PROC_PIO_SM0_SHIFTCTRL_PULL_THRESH_LSB); +} + +static void rp1_smc_set_fifo_join(PIO pio, pio_sm_config *config, + enum pio_fifo_join join) { + smc_to_rp1(config, c); + valid_params_if(PIO, join == PIO_FIFO_JOIN_NONE || + join == PIO_FIFO_JOIN_TX || + join == PIO_FIFO_JOIN_RX); + c->shiftctrl = + (c->shiftctrl & (uint) ~(PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_BITS | + PROC_PIO_SM0_SHIFTCTRL_FJOIN_RX_BITS)) | + (((uint)join) << PROC_PIO_SM0_SHIFTCTRL_FJOIN_TX_LSB); +} + +static void rp1_smc_set_out_special(PIO pio, pio_sm_config *config, bool sticky, + bool has_enable_pin, + uint enable_pin_index) { + smc_to_rp1(config, c); + c->execctrl = + (c->execctrl & (uint) ~(PROC_PIO_SM0_EXECCTRL_OUT_STICKY_BITS | + PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_BITS | + PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_BITS)) | + (bool_to_bit(sticky) << PROC_PIO_SM0_EXECCTRL_OUT_STICKY_LSB) | + (bool_to_bit(has_enable_pin) + << PROC_PIO_SM0_EXECCTRL_INLINE_OUT_EN_LSB) | + ((enable_pin_index << PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_LSB) & + PROC_PIO_SM0_EXECCTRL_OUT_EN_SEL_BITS); +} + +static void rp1_smc_set_mov_status(PIO pio, pio_sm_config *config, + enum pio_mov_status_type status_sel, + uint status_n) { + smc_to_rp1(config, c); + valid_params_if(PIO, status_sel == STATUS_TX_LESSTHAN || + status_sel == STATUS_RX_LESSTHAN); + c->execctrl = + (c->execctrl & ~(PROC_PIO_SM0_EXECCTRL_STATUS_SEL_BITS | + PROC_PIO_SM0_EXECCTRL_STATUS_N_BITS)) | + ((((uint)status_sel) << PROC_PIO_SM0_EXECCTRL_STATUS_SEL_LSB) & + PROC_PIO_SM0_EXECCTRL_STATUS_SEL_BITS) | + ((status_n << PROC_PIO_SM0_EXECCTRL_STATUS_N_LSB) & + PROC_PIO_SM0_EXECCTRL_STATUS_N_BITS); +} + +static uint32_t rp1_clock_get_hz(PIO pio, enum clock_index clk_index) { + const uint32_t MHZ = 1000000; + + switch (clk_index) { + case clk_sys: + return 200 * MHZ; + default: + break; + } + return PIO_ORIGIN_ANY; +} + +static void rp1_gpio_init(PIO pio, uint gpio) { + struct rp1_gpio_init_args args = {.gpio = gpio}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_INIT, &args); +} + +static void rp1_gpio_set_function(PIO pio, uint gpio, enum gpio_function fn) { + struct rp1_gpio_set_function_args args = {.gpio = gpio, .fn = fn}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_FUNCTION, &args); +} + +static void rp1_gpio_set_pulls(PIO pio, uint gpio, bool up, bool down) { + struct rp1_gpio_set_pulls_args args = { + .gpio = gpio, .up = up, .down = down}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_PULLS, &args); +} + +static void rp1_gpio_set_outover(PIO pio, uint gpio, uint value) { + struct rp1_gpio_set_args args = {.gpio = gpio, .value = value}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_OUTOVER, &args); +} + +static void rp1_gpio_set_inover(PIO pio, uint gpio, uint value) { + struct rp1_gpio_set_args args = {.gpio = gpio, .value = value}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_INOVER, &args); +} + +static void rp1_gpio_set_oeover(PIO pio, uint gpio, uint value) { + struct rp1_gpio_set_args args = {.gpio = gpio, .value = value}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_OEOVER, &args); +} + +static void rp1_gpio_set_input_enabled(PIO pio, uint gpio, bool enabled) { + struct rp1_gpio_set_args args = {.gpio = gpio, .value = enabled}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_INPUT_ENABLED, &args); +} + +static void rp1_gpio_set_drive_strength(PIO pio, uint gpio, + enum gpio_drive_strength drive) { + struct rp1_gpio_set_args args = {.gpio = gpio, .value = drive}; + + valid_params_if(PIO, gpio < RP1_PIO_GPIO_COUNT); + (void)rp1_ioctl(pio, PIO_IOC_GPIO_SET_DRIVE_STRENGTH, &args); +} + +static void rp1_pio_gpio_init(PIO pio, uint pin) { + valid_params_if(PIO, pin < RP1_PIO_GPIO_COUNT); + rp1_gpio_set_function(pio, pin, (gpio_function)RP1_GPIO_FUNC_PIO); +} + +PIO rp1_create_instance(PIO_CHIP_T *chip, uint index) { + char pathbuf[20]; + RP1_PIO pio = NULL; + + sprintf(pathbuf, "/dev/pio%u", index); + + if (access(pathbuf, F_OK) != 0) + return NULL; + + pio = (RP1_PIO)calloc(1, sizeof(*pio)); + if (!pio) + return PIO_ERR(-ENOMEM); + + pio->base.chip = chip; + pio->fd = -1; + pio->devname = strdup(pathbuf); + + rp1_pio_clear_instruction_memory(&pio->base); + + return &pio->base; +} + +int rp1_open_instance(PIO pio) { + RP1_PIO rp = (RP1_PIO)pio; + int fd; + + fd = open(rp->devname, O_RDWR, O_CLOEXEC); + if (fd < 0) + return -errno; + rp->fd = fd; + return 0; +} + +void rp1_close_instance(PIO pio) { + RP1_PIO rp = (RP1_PIO)pio; + close(rp->fd); +} + +static const PIO_CHIP_T rp1_pio_chip = { + .name = "rp1", + .compatible = "raspberrypi,rp1-pio", + .instr_count = RP1_PIO_INSTRUCTION_COUNT, + .sm_count = RP1_PIO_SM_COUNT, + .fifo_depth = 8, + + .create_instance = rp1_create_instance, + .open_instance = rp1_open_instance, + .close_instance = rp1_close_instance, + + .pio_sm_config_xfer = rp1_pio_sm_config_xfer, + .pio_sm_xfer_data = rp1_pio_sm_xfer_data, + + .pio_can_add_program_at_offset = rp1_pio_can_add_program_at_offset, + .pio_add_program_at_offset = rp1_pio_add_program_at_offset, + .pio_remove_program = rp1_pio_remove_program, + .pio_clear_instruction_memory = rp1_pio_clear_instruction_memory, + .pio_encode_delay = rp1_pio_encode_delay, + .pio_encode_sideset = rp1_pio_encode_sideset, + .pio_encode_sideset_opt = rp1_pio_encode_sideset_opt, + .pio_encode_jmp = rp1_pio_encode_jmp, + .pio_encode_jmp_not_x = rp1_pio_encode_jmp_not_x, + .pio_encode_jmp_x_dec = rp1_pio_encode_jmp_x_dec, + .pio_encode_jmp_not_y = rp1_pio_encode_jmp_not_y, + .pio_encode_jmp_y_dec = rp1_pio_encode_jmp_y_dec, + .pio_encode_jmp_x_ne_y = rp1_pio_encode_jmp_x_ne_y, + .pio_encode_jmp_pin = rp1_pio_encode_jmp_pin, + .pio_encode_jmp_not_osre = rp1_pio_encode_jmp_not_osre, + .pio_encode_wait_gpio = rp1_pio_encode_wait_gpio, + .pio_encode_wait_pin = rp1_pio_encode_wait_pin, + .pio_encode_wait_irq = rp1_pio_encode_wait_irq, + .pio_encode_in = rp1_pio_encode_in, + .pio_encode_out = rp1_pio_encode_out, + .pio_encode_push = rp1_pio_encode_push, + .pio_encode_pull = rp1_pio_encode_pull, + .pio_encode_mov = rp1_pio_encode_mov, + .pio_encode_mov_not = rp1_pio_encode_mov_not, + .pio_encode_mov_reverse = rp1_pio_encode_mov_reverse, + .pio_encode_irq_set = rp1_pio_encode_irq_set, + .pio_encode_irq_wait = rp1_pio_encode_irq_wait, + .pio_encode_irq_clear = rp1_pio_encode_irq_clear, + .pio_encode_set = rp1_pio_encode_set, + .pio_encode_nop = rp1_pio_encode_nop, + + .pio_sm_claim = rp1_pio_sm_claim, + .pio_sm_claim_mask = rp1_pio_sm_claim_mask, + .pio_sm_claim_unused = rp1_pio_sm_claim_unused, + .pio_sm_unclaim = rp1_pio_sm_unclaim, + .pio_sm_is_claimed = rp1_pio_sm_is_claimed, + + .pio_sm_init = rp1_pio_sm_init, + .pio_sm_set_config = rp1_pio_sm_set_config, + .pio_sm_exec = rp1_pio_sm_exec, + .pio_sm_clear_fifos = rp1_pio_sm_clear_fifos, + .pio_sm_set_clkdiv_int_frac = &rp1_pio_sm_set_clkdiv_int_frac, + .pio_sm_set_clkdiv = rp1_pio_sm_set_clkdiv, + .pio_sm_set_pins = rp1_pio_sm_set_pins, + .pio_sm_set_pins_with_mask = rp1_pio_sm_set_pins_with_mask, + .pio_sm_set_pindirs_with_mask = rp1_pio_sm_set_pindirs_with_mask, + .pio_sm_set_consecutive_pindirs = rp1_pio_sm_set_consecutive_pindirs, + .pio_sm_set_enabled = rp1_pio_sm_set_enabled, + .pio_sm_set_enabled_mask = rp1_pio_sm_set_enabled_mask, + .pio_sm_restart = rp1_pio_sm_restart, + .pio_sm_restart_mask = rp1_pio_sm_restart_mask, + .pio_sm_clkdiv_restart = rp1_pio_sm_clkdiv_restart, + .pio_sm_clkdiv_restart_mask = rp1_pio_sm_clkdiv_restart_mask, + .pio_sm_enable_sync = rp1_pio_sm_enable_sync, + .pio_sm_put = rp1_pio_sm_put, + .pio_sm_get = rp1_pio_sm_get, + .pio_sm_set_dmactrl = rp1_pio_sm_set_dmactrl, + .pio_sm_is_rx_fifo_empty = rp1_pio_sm_is_rx_fifo_empty, + .pio_sm_is_rx_fifo_full = rp1_pio_sm_is_rx_fifo_full, + .pio_sm_get_rx_fifo_level = rp1_pio_sm_get_rx_fifo_level, + .pio_sm_is_tx_fifo_empty = rp1_pio_sm_is_tx_fifo_empty, + .pio_sm_is_tx_fifo_full = rp1_pio_sm_is_tx_fifo_full, + .pio_sm_get_tx_fifo_level = rp1_pio_sm_get_tx_fifo_level, + .pio_sm_drain_tx_fifo = rp1_pio_sm_drain_tx_fifo, + + .pio_get_default_sm_config = rp1_pio_get_default_sm_config, + .smc_set_out_pins = rp1_smc_set_out_pins, + .smc_set_set_pins = rp1_smc_set_set_pins, + .smc_set_in_pins = rp1_smc_set_in_pins, + .smc_set_sideset_pins = rp1_smc_set_sideset_pins, + .smc_set_sideset = rp1_smc_set_sideset, + .smc_set_clkdiv_int_frac = rp1_smc_set_clkdiv_int_frac, + .smc_set_clkdiv = rp1_smc_set_clkdiv, + .smc_set_wrap = rp1_smc_set_wrap, + .smc_set_jmp_pin = rp1_smc_set_jmp_pin, + .smc_set_in_shift = rp1_smc_set_in_shift, + .smc_set_out_shift = rp1_smc_set_out_shift, + .smc_set_fifo_join = rp1_smc_set_fifo_join, + .smc_set_out_special = rp1_smc_set_out_special, + .smc_set_mov_status = rp1_smc_set_mov_status, + + .clock_get_hz = rp1_clock_get_hz, + + .pio_gpio_init = rp1_pio_gpio_init, + .gpio_init = rp1_gpio_init, + .gpio_set_function = rp1_gpio_set_function, + .gpio_set_pulls = rp1_gpio_set_pulls, + .gpio_set_outover = rp1_gpio_set_outover, + .gpio_set_inover = rp1_gpio_set_inover, + .gpio_set_oeover = rp1_gpio_set_oeover, + .gpio_set_input_enabled = rp1_gpio_set_input_enabled, + .gpio_set_drive_strength = rp1_gpio_set_drive_strength, +}; + +DECLARE_PIO_CHIP(rp1_pio_chip); diff --git a/piolib/piolib.c b/piolib/piolib.c new file mode 100644 index 0000000..8047068 --- /dev/null +++ b/piolib/piolib.c @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2023-24 Raspberry Pi Ltd. + * All rights reserved. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "piolib.h" +#include "piolib_priv.h" + +#define PIO_MAX_INSTANCES 4 + +extern PIO_CHIP_T *__start_piochips; +extern PIO_CHIP_T *__stop_piochips; + +static __thread PIO __pio; + +static PIO pio_instances[PIO_MAX_INSTANCES]; +static uint num_instances; +static pthread_mutex_t pio_handle_lock; + +void pio_select(PIO pio) { __pio = pio; } + +PIO pio_get_current(void) { + PIO pio = __pio; + check_pio_param(pio); + return pio; +} + +int pio_get_index(PIO pio) { + int i; + for (i = 0; i < PIO_MAX_INSTANCES; i++) { + if (pio == pio_instances[i]) + return i; + } + return -1; +} + +int pio_init(void) { + static bool initialised; + const PIO_CHIP_T *const *p; + uint i = 0; + int err; + + if (initialised) + return 0; + num_instances = 0; + p = &__start_piochips; + while (p < &__stop_piochips && num_instances < PIO_MAX_INSTANCES) { + PIO_CHIP_T *chip = *p; + PIO pio = chip->create_instance(chip, i); + if (pio && !PIO_IS_ERR(pio)) { + pio_instances[num_instances++] = pio; + i++; + } else { + p++; + i = 0; + } + } + + err = pthread_mutex_init(&pio_handle_lock, NULL); + if (err) + return err; + + initialised = true; + return 0; +} + +PIO pio_open(uint idx) { + PIO pio = NULL; + int err; + + err = pio_init(); + if (err) + return PIO_ERR(err); + + if (idx >= num_instances) + return PIO_ERR(-EINVAL); + + pthread_mutex_lock(&pio_handle_lock); + + pio = pio_instances[idx]; + if (pio) { + if (pio->in_use) + err = -EBUSY; + else + pio->in_use = 1; + } + + pthread_mutex_unlock(&pio_handle_lock); + + if (err) + return PIO_ERR(err); + + err = pio->chip->open_instance(pio); + if (err) { + pio->in_use = 0; + return PIO_ERR(err); + } + + pio_select(pio); + + return pio; +} + +PIO pio_open_by_name(const char *name) { + int err = -ENOENT; + uint i; + + err = pio_init(); + if (err) + return PIO_ERR(err); + + for (i = 0; i < num_instances; i++) { + PIO p = pio_instances[i]; + if (!strcmp(name, p->chip->name)) + break; + } + + if (i == num_instances) + return PIO_ERR(-ENOENT); + + return pio_open(i); +} + +PIO pio_open_helper(uint idx) { + PIO pio = pio_instances[idx]; + if (!pio || !pio->in_use) { + pio = pio_open(idx); + if (PIO_IS_ERR(pio)) { + printf("* Failed to open PIO device %d (error %d)\n", idx, + PIO_ERR_VAL(pio)); + exit(1); + } + } + return pio; +} + +void pio_close(PIO pio) { + pio->chip->close_instance(pio); + pthread_mutex_lock(&pio_handle_lock); + pio->in_use = 0; + pthread_mutex_unlock(&pio_handle_lock); +} + +void pio_panic(const char *msg) { + fprintf(stderr, "PANIC: %s\n", msg); + exit(1); +} + +void sleep_us(uint64_t us) { + const struct timespec tv = {.tv_sec = (us / 1000000), + .tv_nsec = 1000ull * (us % 1000000)}; + nanosleep(&tv, NULL); +} diff --git a/protodemo b/protodemo new file mode 100755 index 0000000000000000000000000000000000000000..6e4f3b3ba8ce7b967532eba34ebf32d4a295c022 GIT binary patch literal 190168 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 Kk;#xrM*klR7=``- literal 0 HcmV?d00001 diff --git a/protodemo.c b/protodemo.c new file mode 100644 index 0000000..0e955d3 --- /dev/null +++ b/protodemo.c @@ -0,0 +1,173 @@ +#include +#include +#include +#include + +#include "hardware/pio.h" +#include "protomatter.pio.h" + +#define PIN_R0 (5) +#define PIN_G0 (13) +#define PIN_B0 (6) +#define PIN_R1 (12) +#define PIN_G1 (16) +#define PIN_B1 (23) +#define PIN_ADDR_A (22) +#define PIN_ADDR_B (26) +#define PIN_ADDR_C (27) +#define PIN_ADDR_D (20) +#define PIN_ADDR_E (24) +#define PIN_OE (4) // /OE: output enable when LOW +#define PIN_CLK (17) // SRCLK: clocks on RISING edge +#define PIN_LAT (21) // RCLK: latches on RISING edge + +const uint8_t all_pins[] = { + PIN_R0, + PIN_G0, + PIN_B0, + PIN_R1, + PIN_G1, + PIN_B1, + PIN_ADDR_A, + PIN_ADDR_B, + PIN_ADDR_C, + // PIN_ADDR_D, + // PIN_ADDR_E, + PIN_OE, + PIN_CLK, + PIN_LAT, +}; +#define DATA_OVERHEAD (5) +#define DELAY_OVERHEAD (3) +#define CLOCKS_PER_DELAY (1) +// so for example a DATA word with a delay of 3 will take DATA_OVERHEAD+3*CLOCKS_PER_DELAY + +static const struct pio_program protomatter_program = { + .instructions = protomatter, + .length = 32, + .origin = -1, +}; + +static inline pio_sm_config protomatter_program_get_default_config(uint offset) { + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_wrap(&c, offset + protomatter_wrap_target, offset + protomatter_wrap); + return c; +} + +static inline void protomatter_program_init(PIO pio, int sm, uint offset) { + for(int i=0; i test_pattern() { + std::vector result; + + auto add_data_word = [&](bool r0, bool g0, bool b0, bool r1, bool g1, bool b1) { + uint32_t data = data_bit; + if(r0) data |= (1 << PIN_R0); + if(g0) data |= (1 << PIN_G0); + if(b0) data |= (1 << PIN_B0); + if(r1) data |= (1 << PIN_R1); + if(g1) data |= (1 << PIN_G1); + if(b1) data |= (1 << PIN_B1); + data |= oe_inactive; + + result.push_back(data | data_delay); + result.push_back(data | clk_bit | clock_delay); + }; + + for(int addr = 0; addr < 8; addr++) { + for(int across = 0; across < ACROSS; across++) { + auto pixel0 = pixels[addr][across]; + auto r0 = pixel0 & r; + auto g0 = pixel0 & g; + auto b0 = pixel0 & b; + auto pixel1 = pixels[addr][across]; + auto r1 = pixel1 & r; + auto g1 = pixel1 & g; + auto b1 = pixel1 & b; + + add_data_word(r0, g0, b0, r1, g1, b1); + } + + result.push_back(delay_bit | oe_inactive | pre_latch_delay); + result.push_back(data_bit | oe_inactive | lat_bit | post_latch_delay); + } + + return result; +} + +int main() { + PIO pio = pio0; + int sm = pio_claim_unused_sm(pio, true); + pio_sm_config_xfer(pio, sm, PIO_DIR_TO_SM, 256, 1); + + uint offset = pio_add_program(pio, &protomatter_program); + printf("Loaded program at %d, using sm %d\n", offset, sm); + + pio_sm_clear_fifos(pio, sm); + pio_sm_set_clkdiv(pio, sm, 1.0); + + protomatter_program_init(pio, sm, offset); + + std::vector data = test_pattern(); + + uint32_t *databuf = &data[0]; + size_t datasize = data.size() * sizeof(uint32_t); + + assert(datasize < 65536); + + while(true) { + pio_sm_xfer_data(pio, sm, PIO_DIR_TO_SM, datasize, databuf); + } +} diff --git a/protomatter.pio b/protomatter.pio new file mode 100644 index 0000000..53b8b27 --- /dev/null +++ b/protomatter.pio @@ -0,0 +1,45 @@ +; data format (out-shift-right): +; MSB ... LSB +; 0 ddd........ddd: 31-bit delay +; 1 ppp....ppp ddd: 28 bit data + 3-bit delay + +.wrap_target +top: + ; pull ;; use auto-pull + out x, 1 + jmp !x do_delay + out pins, 27 + out x, 4 + jmp delay_loop + +do_delay: + out x, 31 +delay_loop: + jmp x--, delay_loop +.wrap + + ;; fill program out to 32 instructions + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop