Functions

• void adc_init (void)

•  Initialise the ADC HW.
  

• static void adc_gpio_init (uint gpio)

•  Initialise the gpio for use as an ADC pin.
  

• static void adc_select_input (uint input)

•  ADC input select.
  

• static uint adc_get_selected_input (void)

•  Get the currently selected ADC input channel.
  

• static void adc_set_round_robin (uint input_mask)

•  Round Robin sampling selector.
  

• static void adc_set_temp_sensor_enabled (bool enable)

•  Enable the onboard temperature sensor.
  

• static uint16_t adc_read (void)

•  Perform a single conversion.
  

• static void adc_run (bool run)

•  Enable or disable free-running sampling mode.
  

• static void adc_set_clkdiv (float clkdiv)

•  Set the ADC Clock divisor.
  

• static void adc_fifo_setup (bool en, bool dreq_en, uint16_t dreq_thresh, bool err_in_fifo, bool byte_shift)

•  Setup the ADC FIFO.
  

• static bool adc_fifo_is_empty (void)

•  Check FIFO empty state.
  

• static uint8_t adc_fifo_get_level (void)

•  Get number of entries in the ADC FIFO.
  

• static uint16_t adc_fifo_get (void)

•  Get ADC result from FIFO.
  

• static uint16_t adc_fifo_get_blocking (void)

•  Wait for the ADC FIFO to have data.
  

• static void adc_fifo_drain (void)

•  Drain the ADC FIFO.
  

• static void adc_irq_set_enabled (bool enabled)

•  Enable/Disable ADC interrupts.
  

Detailed Description

Analog to Digital Converter (ADC) API

The RP2040 has an internal analogue-digital converter (ADC) with the following features:

Although there is only one ADC you can specify the input to it using the adc_select_input() function. In round robin mode (adc_set_round_robin()), the ADC will use that input and move to the next one after a read.

User ADC inputs are on 0-3 (GPIO 26-29), the temperature sensor is on input 4.

Temperature sensor values can be approximated in centigrade as:

T = 27 - (ADC_Voltage - 0.706)/0.001721

The FIFO, if used, can contain up to 4 entries.

Example

Function Documentation

Functions

• static __force_inline void hw_set_bits (io_rw_32 *addr, uint32_t mask)

•  Atomically set the specified bits to 1 in a HW register.
  

• static __force_inline void hw_clear_bits (io_rw_32 *addr, uint32_t mask)

•  Atomically clear the specified bits to 0 in a HW register.
  

• static __force_inline void hw_xor_bits (io_rw_32 *addr, uint32_t mask)

•  Atomically flip the specified bits in a HW register.
  

• static __force_inline void hw_write_masked (io_rw_32 *addr, uint32_t values, uint32_t write_mask)

•  Set new values for a sub-set of the bits in a HW register.
  

Detailed Description

Low-level types and (atomic) accessors for memory-mapped hardware registers

hardware_base defines the low level types and access functions for memory mapped hardware registers. It is included by default by all other hardware libraries.

The following register access typedefs codify the access type (read/write) and the bus size (8/16/32) of the hardware register. The register type names are formed by concatenating one from each of the 3 parts A, B, C

When dealing with these types, you will always use a pointer, i.e. io_rw_32 *some_reg is a pointer to a read/write 32 bit register that you can write with *some_reg = value, or read with value = *some_reg.

RP2040 hardware is also aliased to provide atomic setting, clear or flipping of a subset of the bits within a hardware register so that concurrent access by two cores is always consistent with one atomic operation being performed first, followed by the second.

See hw_set_bits(), hw_clear_bits() and hw_xor_bits() provide for atomic access via a pointer to a 32 bit register

Additionally given a pointer to a structure representing a piece of hardware (e.g. dma_hw_t *dma_hw for the DMA controller), you can get an alias to the entire structure such that writing any member (register) within the structure is equivalent to an atomic operation via hw_set_alias(), hw_clear_alias() or hw_xor_alias()...

For example hw_set_alias(dma_hw)->inte1 = 0x80; will set bit 7 of the INTE1 register of the DMA controller, leaving the other bits unchanged.

Function Documentation

Functions

• void hw_claim_or_assert (uint8_t *bits, uint bit_index, const char *message)

•  Atomically claim a resource, panicking if it is already in use.
  

• int hw_claim_unused_from_range (uint8_t *bits, bool required, uint bit_lsb, uint bit_msb, const char *message)

•  Atomically claim one resource out of a range of resources, optionally asserting if none are free.
  

• bool hw_is_claimed (const uint8_t *bits, uint bit_index)

•  Determine if a resource is claimed at the time of the call.
  

• void hw_claim_clear (uint8_t *bits, uint bit_index)

•  Atomically unclaim a resource.
  

• uint32_t hw_claim_lock (void)

•  Acquire the runtime mutual exclusion lock provided by the hardware_claim library.
  

• void hw_claim_unlock (uint32_t token)

•  Release the runtime mutual exclusion lock provided by the hardware_claim library.
  

Detailed Description

Lightweight hardware resource management

hardware_claim provides a simple API for management of hardware resources at runtime.

This API is usually called by other hardware specific claiming APIs and provides simple multi-core safe methods to manipulate compact bit-sets representing hardware resources.

This API allows any other library to cooperatively participate in a scheme by which both compile time and runtime allocation of resources can co-exist, and conflicts can be avoided or detected (depending on the use case) without the libraries having any other knowledge of each other.

Facilities are providing for:

1. Claiming resources (and asserting if they are already claimed)

2. Freeing (unclaiming) resources

3. Finding unused resources

Function Documentation

Typedefs

• typedef void(* resus_callback_t) (void)

•  Resus callback function type.
  

Enumerations

• enum  clock_index {
    clk_gpout0 = 0 , clk_gpout1 , clk_gpout2 , clk_gpout3 ,
    clk_ref , clk_sys , clk_peri , clk_usb ,
    clk_adc , clk_rtc , CLK_COUNT
  }

•  Enumeration identifying a hardware clock. More...
  

Functions

• void clocks_init (void)

•  Initialise the clock hardware.
  

• bool clock_configure (enum clock_index clk_index, uint32_t src, uint32_t auxsrc, uint32_t src_freq, uint32_t freq)

•  Configure the specified clock.
  

• void clock_stop (enum clock_index clk_index)

•  Stop the specified clock.
  

• uint32_t clock_get_hz (enum clock_index clk_index)

•  Get the current frequency of the specified clock.
  

• uint32_t frequency_count_khz (uint src)

•  Measure a clocks frequency using the Frequency counter.
  

• void clock_set_reported_hz (enum clock_index clk_index, uint hz)

•  Set the "current frequency" of the clock as reported by clock_get_hz without actually changing the clock.
  

• void clocks_enable_resus (resus_callback_t resus_callback)

•  Enable the resus function. Restarts clk_sys if it is accidentally stopped.
  

• void clock_gpio_init_int_frac (uint gpio, uint src, uint32_t div_int, uint8_t div_frac)

•  Output an optionally divided clock to the specified gpio pin.
  

• static void clock_gpio_init (uint gpio, uint src, float div)

•  Output an optionally divided clock to the specified gpio pin.
  

• bool clock_configure_gpin (enum clock_index clk_index, uint gpio, uint32_t src_freq, uint32_t freq)

•  Configure a clock to come from a gpio input.
  

Detailed Description

Clock Management API

This API provides a high level interface to the clock functions.

The clocks block provides independent clocks to on-chip and external components. It takes inputs from a variety of clock sources allowing the user to trade off performance against cost, board area and power consumption. From these sources it uses multiple clock generators to provide the required clocks. This architecture allows the user flexibility to start and stop clocks independently and to vary some clock frequencies whilst maintaining others at their optimum frequencies

Please refer to the datasheet for more details on the RP2040 clocks.

The clock source depends on which clock you are attempting to configure. The first table below shows main clock sources. If you are not setting the Reference clock or the System clock, or you are specifying that one of those two will be using an auxiliary clock source, then you will need to use one of the entries from the subsequent tables.

Main Clock Sources

Auxiliary Clock Sources

The auxiliary clock sources available for use in the configure function depend on which clock is being configured. The following table describes the available values that can be used. Note that for clk_gpout[x], x can be 0-3.

Example

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Functions

• static void hw_divider_divmod_s32_start (int32_t a, int32_t b)

•  Start a signed asynchronous divide.
  

• static void hw_divider_divmod_u32_start (uint32_t a, uint32_t b)

•  Start an unsigned asynchronous divide.
  

• static void hw_divider_wait_ready (void)

•  Wait for a divide to complete.
  

• static divmod_result_t hw_divider_result_nowait (void)

•  Return result of HW divide, nowait.
  

• static divmod_result_t hw_divider_result_wait (void)

•  Return result of last asynchronous HW divide.
  

• static uint32_t hw_divider_u32_quotient_wait (void)

•  Return result of last asynchronous HW divide, unsigned quotient only.
  

• static int32_t hw_divider_s32_quotient_wait (void)

•  Return result of last asynchronous HW divide, signed quotient only.
  

• static uint32_t hw_divider_u32_remainder_wait (void)

•  Return result of last asynchronous HW divide, unsigned remainder only.
  

• static int32_t hw_divider_s32_remainder_wait (void)

•  Return result of last asynchronous HW divide, signed remainder only.
  

• divmod_result_t hw_divider_divmod_s32 (int32_t a, int32_t b)

•  Do a signed HW divide and wait for result.
  

• divmod_result_t hw_divider_divmod_u32 (uint32_t a, uint32_t b)

•  Do an unsigned HW divide and wait for result.
  

• static uint32_t to_quotient_u32 (divmod_result_t r)

•  Efficient extraction of unsigned quotient from 32p32 fixed point.
  

• static int32_t to_quotient_s32 (divmod_result_t r)

•  Efficient extraction of signed quotient from 32p32 fixed point.
  

• static uint32_t to_remainder_u32 (divmod_result_t r)

•  Efficient extraction of unsigned remainder from 32p32 fixed point.
  

• static int32_t to_remainder_s32 (divmod_result_t r)

•  Efficient extraction of signed remainder from 32p32 fixed point.
  

• static uint32_t hw_divider_u32_quotient (uint32_t a, uint32_t b)

•  Do an unsigned HW divide, wait for result, return quotient.
  

• static uint32_t hw_divider_u32_remainder (uint32_t a, uint32_t b)

•  Do an unsigned HW divide, wait for result, return remainder.
  

• static int32_t hw_divider_quotient_s32 (int32_t a, int32_t b)

•  Do a signed HW divide, wait for result, return quotient.
  

• static int32_t hw_divider_remainder_s32 (int32_t a, int32_t b)

•  Do a signed HW divide, wait for result, return remainder.
  

• static void hw_divider_pause (void)

•  Pause for exact amount of time needed for a asynchronous divide to complete.
  

• static uint32_t hw_divider_u32_quotient_inlined (uint32_t a, uint32_t b)

•  Do a hardware unsigned HW divide, wait for result, return quotient.
  

• static uint32_t hw_divider_u32_remainder_inlined (uint32_t a, uint32_t b)

•  Do a hardware unsigned HW divide, wait for result, return remainder.
  

• static int32_t hw_divider_s32_quotient_inlined (int32_t a, int32_t b)

•  Do a hardware signed HW divide, wait for result, return quotient.
  

• static int32_t hw_divider_s32_remainder_inlined (int32_t a, int32_t b)

•  Do a hardware signed HW divide, wait for result, return remainder.
  

• void hw_divider_save_state (hw_divider_state_t *dest)

•  Save the calling cores hardware divider state.
  

• void hw_divider_restore_state (hw_divider_state_t *src)

•  Load a saved hardware divider state into the current core's hardware divider.
  

Detailed Description

Low-level hardware-divider access

The SIO contains an 8-cycle signed/unsigned divide/modulo circuit, per core. Calculation is started by writing a dividend and divisor to the two argument registers, DIVIDEND and DIVISOR. The divider calculates the quotient / and remainder % of this division over the next 8 cycles, and on the 9th cycle the results can be read from the two result registers DIV_QUOTIENT and DIV_REMAINDER. A 'ready' bit in register DIV_CSR can be polled to wait for the calculation to complete, or software can insert a fixed 8-cycle delay

This header provides low level macros and inline functions for accessing the hardware dividers directly, and perhaps most usefully performing asynchronous divides. These functions however do not follow the regular SDK conventions for saving/restoring the divider state, so are not generally safe to call from interrupt handlers

The pico_divider library provides a more user friendly set of APIs over the divider (and support for 64 bit divides), and of course by default regular C language integer divisions are redirected through that library, meaning you can just use C level / and % operators and gain the benefits of the fast hardware divider.

See alsopico_divider

Example

Function Documentation

Modules

•  channel_config

•  DMA channel configuration.
  

Enumerations

• enum  dma_channel_transfer_size { DMA_SIZE_8 = 0 , DMA_SIZE_16 = 1 , DMA_SIZE_32 = 2 }

•  Enumeration of available DMA channel transfer sizes. More...
  

Functions

• void dma_channel_claim (uint channel)

•  Mark a dma channel as used.
  

• void dma_claim_mask (uint32_t channel_mask)

•  Mark multiple dma channels as used.
  

• void dma_channel_unclaim (uint channel)

•  Mark a dma channel as no longer used.
  

• void dma_unclaim_mask (uint32_t channel_mask)

•  Mark multiple dma channels as no longer used.
  

• int dma_claim_unused_channel (bool required)

•  Claim a free dma channel.
  

• bool dma_channel_is_claimed (uint channel)

•  Determine if a dma channel is claimed.
  

• static void dma_channel_set_config (uint channel, const dma_channel_config *config, bool trigger)

•  Set a channel configuration.
  

• static void dma_channel_set_read_addr (uint channel, const volatile void *read_addr, bool trigger)

•  Set the DMA initial read address.
  

• static void dma_channel_set_write_addr (uint channel, volatile void *write_addr, bool trigger)

•  Set the DMA initial write address.
  

• static void dma_channel_set_trans_count (uint channel, uint32_t trans_count, bool trigger)

•  Set the number of bus transfers the channel will do.
  

• static void dma_channel_configure (uint channel, const dma_channel_config *config, volatile void *write_addr, const volatile void *read_addr, uint transfer_count, bool trigger)

•  Configure all DMA parameters and optionally start transfer.
  

• static void dma_channel_transfer_from_buffer_now (uint channel, const volatile void *read_addr, uint32_t transfer_count)

•  Start a DMA transfer from a buffer immediately.
  

• static void dma_channel_transfer_to_buffer_now (uint channel, volatile void *write_addr, uint32_t transfer_count)

•  Start a DMA transfer to a buffer immediately.
  

• static void dma_start_channel_mask (uint32_t chan_mask)

•  Start one or more channels simultaneously.
  

• static void dma_channel_start (uint channel)

•  Start a single DMA channel.
  

• static void dma_channel_abort (uint channel)

•  Stop a DMA transfer.
  

• static void dma_channel_set_irq0_enabled (uint channel, bool enabled)

•  Enable single DMA channel's interrupt via DMA_IRQ_0.
  

• static void dma_set_irq0_channel_mask_enabled (uint32_t channel_mask, bool enabled)

•  Enable multiple DMA channels' interrupts via DMA_IRQ_0.
  

• static void dma_channel_set_irq1_enabled (uint channel, bool enabled)

•  Enable single DMA channel's interrupt via DMA_IRQ_1.
  

• static void dma_set_irq1_channel_mask_enabled (uint32_t channel_mask, bool enabled)

•  Enable multiple DMA channels' interrupts via DMA_IRQ_1.
  

• static void dma_irqn_set_channel_enabled (uint irq_index, uint channel, bool enabled)

•  Enable single DMA channel interrupt on either DMA_IRQ_0 or DMA_IRQ_1.
  

• static void dma_irqn_set_channel_mask_enabled (uint irq_index, uint32_t channel_mask, bool enabled)

•  Enable multiple DMA channels' interrupt via either DMA_IRQ_0 or DMA_IRQ_1.
  

• static bool dma_channel_get_irq0_status (uint channel)

•  Determine if a particular channel is a cause of DMA_IRQ_0.
  

• static bool dma_channel_get_irq1_status (uint channel)

•  Determine if a particular channel is a cause of DMA_IRQ_1.
  

• static bool dma_irqn_get_channel_status (uint irq_index, uint channel)

•  Determine if a particular channel is a cause of DMA_IRQ_N.
  

• static void dma_channel_acknowledge_irq0 (uint channel)

•  Acknowledge a channel IRQ, resetting it as the cause of DMA_IRQ_0.
  

• static void dma_channel_acknowledge_irq1 (uint channel)

•  Acknowledge a channel IRQ, resetting it as the cause of DMA_IRQ_1.
  

• static void dma_irqn_acknowledge_channel (uint irq_index, uint channel)

•  Acknowledge a channel IRQ, resetting it as the cause of DMA_IRQ_N.
  

• static bool dma_channel_is_busy (uint channel)

•  Check if DMA channel is busy.
  

• static void dma_channel_wait_for_finish_blocking (uint channel)

•  Wait for a DMA channel transfer to complete.
  

• static void dma_sniffer_enable (uint channel, uint mode, bool force_channel_enable)

•  Enable the DMA sniffing targeting the specified channel.
  

• static void dma_sniffer_set_byte_swap_enabled (bool swap)

•  Enable the Sniffer byte swap function.
  

• static void dma_sniffer_set_output_invert_enabled (bool invert)

•  Enable the Sniffer output invert function.
  

• static void dma_sniffer_set_output_reverse_enabled (bool reverse)

•  Enable the Sniffer output bit reversal function.
  

• static void dma_sniffer_disable (void)

•  Disable the DMA sniffer.
  

• static void dma_sniffer_set_data_accumulator (uint32_t seed_value)

•  Set the sniffer's data accumulator with initial value.
  

• static uint32_t dma_sniffer_get_data_accumulator (void)

•  Get the sniffer's data accumulator value.
  

• void dma_timer_claim (uint timer)

•  Mark a dma timer as used.
  

• void dma_timer_unclaim (uint timer)

•  Mark a dma timer as no longer used.
  

• int dma_claim_unused_timer (bool required)

•  Claim a free dma timer.
  

• bool dma_timer_is_claimed (uint timer)

•  Determine if a dma timer is claimed.
  

• static void dma_timer_set_fraction (uint timer, uint16_t numerator, uint16_t denominator)

•  Set the divider for the given DMA timer.
  

• static uint dma_get_timer_dreq (uint timer_num)

•  Return the DREQ number for a given DMA timer.
  

Detailed Description

DMA Controller API

The RP2040 Direct Memory Access (DMA) master performs bulk data transfers on a processor’s behalf. This leaves processors free to attend to other tasks, or enter low-power sleep states. The data throughput of the DMA is also significantly higher than one of RP2040’s processors.

The DMA can perform one read access and one write access, up to 32 bits in size, every clock cycle. There are 12 independent channels, which each supervise a sequence of bus transfers, usually in one of the following scenarios:

Enumeration Type Documentation

Function Documentation

channel_config

DMA channel configuration. More...

Typedefs

• typedef void(* exception_handler_t) (void)

•  Exception handler function type.
  

Enumerations

• enum  exception_number {
    NMI_EXCEPTION = -14 , HARDFAULT_EXCEPTION = -13 , SVCALL_EXCEPTION = -5 , PENDSV_EXCEPTION = -2 ,
    SYSTICK_EXCEPTION = -1
  }

•  Exception number definitions. More...
  

Functions

• exception_handler_t exception_set_exclusive_handler (enum exception_number num, exception_handler_t handler)

•  Set the exception handler for an exception on the executing core.
  

• void exception_restore_handler (enum exception_number num, exception_handler_t original_handler)

•  Restore the original exception handler for an exception on this core.
  

• exception_handler_t exception_get_vtable_handler (enum exception_number num)

•  Get the current exception handler for the specified exception from the currently installed vector table of the execution core.
  

Detailed Description

Methods for setting processor exception handlers

Exceptions are identified by a exception_number which is a number from -15 to -1; these are the numbers relative to the index of the first IRQ vector in the vector table. (i.e. vector table index is exception_num plus 16)

There is one set of exception handlers per core, so the exception handlers for each core as set by these methods are independent.

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Functions

• void flash_range_erase (uint32_t flash_offs, size_t count)

•  Erase areas of flash.
  

• void flash_range_program (uint32_t flash_offs, const uint8_t *data, size_t count)

•  Program flash.
  

• void flash_get_unique_id (uint8_t *id_out)

•  Get flash unique 64 bit identifier.
  

• void flash_do_cmd (const uint8_t *txbuf, uint8_t *rxbuf, size_t count)

•  Execute bidirectional flash command.
  

Detailed Description

Low level flash programming and erase API

Note these functions are unsafe if you are using both cores, and the other is executing from flash concurrently with the operation. In this could be the case, you must perform your own synchronisation to make sure that no XIP accesses take place during flash programming. One option is to use the lockout functions.

Likewise they are unsafe if you have interrupt handlers or an interrupt vector table in flash, so you must disable interrupts before calling in this case.

If PICO_NO_FLASH=1 is not defined (i.e. if the program is built to run from flash) then these functions will make a static copy of the second stage bootloader in SRAM, and use this to reenter execute-in-place mode after programming or erasing flash, so that they can safely be called from flash-resident code.

Example

Function Documentation

Typedefs

• typedef void(* gpio_irq_callback_t) (uint gpio, uint32_t event_mask)

Enumerations

• 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
  }

•  GPIO function definitions for use with function select. More...
  

• enum  gpio_irq_level { GPIO_IRQ_LEVEL_LOW = 0x1u , GPIO_IRQ_LEVEL_HIGH = 0x2u , GPIO_IRQ_EDGE_FALL = 0x4u , GPIO_IRQ_EDGE_RISE = 0x8u }

•  GPIO Interrupt level definitions (GPIO events) More...
  

• enum  gpio_slew_rate { GPIO_SLEW_RATE_SLOW = 0 , GPIO_SLEW_RATE_FAST = 1 }

•  Slew rate limiting levels for GPIO outputs. More...
  

• enum  gpio_drive_strength { GPIO_DRIVE_STRENGTH_2MA = 0 , GPIO_DRIVE_STRENGTH_4MA = 1 , GPIO_DRIVE_STRENGTH_8MA = 2 , GPIO_DRIVE_STRENGTH_12MA = 3 }

•  Drive strength levels for GPIO outputs. More...
  

Functions

• void gpio_set_function (uint gpio, enum gpio_function fn)

•  Select GPIO function.
  

• enum gpio_function gpio_get_function (uint gpio)

•  Determine current GPIO function.
  

• void gpio_set_pulls (uint gpio, bool up, bool down)

•  Select up and down pulls on specific GPIO.
  

• static void gpio_pull_up (uint gpio)

•  Set specified GPIO to be pulled up.
  

• static bool gpio_is_pulled_up (uint gpio)

•  Determine if the specified GPIO is pulled up.
  

• static void gpio_pull_down (uint gpio)

•  Set specified GPIO to be pulled down.
  

• static bool gpio_is_pulled_down (uint gpio)

•  Determine if the specified GPIO is pulled down.
  

• static void gpio_disable_pulls (uint gpio)

•  Disable pulls on specified GPIO.
  

• void gpio_set_irqover (uint gpio, uint value)

•  Set GPIO IRQ override.
  

• void gpio_set_outover (uint gpio, uint value)

•  Set GPIO output override.
  

• void gpio_set_inover (uint gpio, uint value)

•  Select GPIO input override.
  

• void gpio_set_oeover (uint gpio, uint value)

•  Select GPIO output enable override.
  

• void gpio_set_input_enabled (uint gpio, bool enabled)

•  Enable GPIO input.
  

• void gpio_set_input_hysteresis_enabled (uint gpio, bool enabled)

•  Enable/disable GPIO input hysteresis (Schmitt trigger)
  

• bool gpio_is_input_hysteresis_enabled (uint gpio)

•  Determine whether input hysteresis is enabled on a specified GPIO.
  

• void gpio_set_slew_rate (uint gpio, enum gpio_slew_rate slew)

•  Set slew rate for a specified GPIO.
  

• enum gpio_slew_rate gpio_get_slew_rate (uint gpio)

•  Determine current slew rate for a specified GPIO.
  

• void gpio_set_drive_strength (uint gpio, enum gpio_drive_strength drive)

•  Set drive strength for a specified GPIO.
  

• enum gpio_drive_strength gpio_get_drive_strength (uint gpio)

•  Determine current slew rate for a specified GPIO.
  

• void gpio_set_irq_enabled (uint gpio, uint32_t event_mask, bool enabled)

•  Enable or disable specific interrupt events for specified GPIO.
  

• void gpio_set_irq_callback (gpio_irq_callback_t callback)

•  Set the generic callback used for GPIO IRQ events for the current core.
  

• void gpio_set_irq_enabled_with_callback (uint gpio, uint32_t event_mask, bool enabled, gpio_irq_callback_t callback)

•  Convenience function which performs multiple GPIO IRQ related initializations.
  

• void gpio_set_dormant_irq_enabled (uint gpio, uint32_t event_mask, bool enabled)

•  Enable dormant wake up interrupt for specified GPIO and events.
  

• static uint32_t gpio_get_irq_event_mask (uint gpio)

•  Return the current interrupt status (pending events) for the given GPIO.
  

• void gpio_acknowledge_irq (uint gpio, uint32_t event_mask)

•  Acknowledge a GPIO interrupt for the specified events on the calling core.
  

• void gpio_add_raw_irq_handler_with_order_priority_masked (uint gpio_mask, irq_handler_t handler, uint8_t order_priority)

•  Adds a raw GPIO IRQ handler for the specified GPIOs on the current core.
  

• static void gpio_add_raw_irq_handler_with_order_priority (uint gpio, irq_handler_t handler, uint8_t order_priority)

•  Adds a raw GPIO IRQ handler for a specific GPIO on the current core.
  

• void gpio_add_raw_irq_handler_masked (uint gpio_mask, irq_handler_t handler)

•  Adds a raw GPIO IRQ handler for the specified GPIOs on the current core.
  

• static void gpio_add_raw_irq_handler (uint gpio, irq_handler_t handler)

•  Adds a raw GPIO IRQ handler for a specific GPIO on the current core.
  

• void gpio_remove_raw_irq_handler_masked (uint gpio_mask, irq_handler_t handler)

•  Removes a raw GPIO IRQ handler for the specified GPIOs on the current core.
  

• static void gpio_remove_raw_irq_handler (uint gpio, irq_handler_t handler)

•  Removes a raw GPIO IRQ handler for the specified GPIO on the current core.
  

• void gpio_init (uint gpio)

•  Initialise a GPIO for (enabled I/O and set func to GPIO_FUNC_SIO)
  

• void gpio_deinit (uint gpio)

•  Resets a GPIO back to the NULL function, i.e. disables it.
  

• void gpio_init_mask (uint gpio_mask)

•  Initialise multiple GPIOs (enabled I/O and set func to GPIO_FUNC_SIO)
  

• static bool gpio_get (uint gpio)

•  Get state of a single specified GPIO.
  

• static uint32_t gpio_get_all (void)

•  Get raw value of all GPIOs.
  

• static void gpio_set_mask (uint32_t mask)

•  Drive high every GPIO appearing in mask.
  

• static void gpio_clr_mask (uint32_t mask)

•  Drive low every GPIO appearing in mask.
  

• static void gpio_xor_mask (uint32_t mask)

•  Toggle every GPIO appearing in mask.
  

• static void gpio_put_masked (uint32_t mask, uint32_t value)

•  Drive GPIO high/low depending on parameters.
  

• static void gpio_put_all (uint32_t value)

•  Drive all pins simultaneously.
  

• static void gpio_put (uint gpio, bool value)

•  Drive a single GPIO high/low.
  

• static bool gpio_get_out_level (uint gpio)

•  Determine whether a GPIO is currently driven high or low.
  

• static void gpio_set_dir_out_masked (uint32_t mask)

•  Set a number of GPIOs to output.
  

• static void gpio_set_dir_in_masked (uint32_t mask)

•  Set a number of GPIOs to input.
  

• static void gpio_set_dir_masked (uint32_t mask, uint32_t value)

•  Set multiple GPIO directions.
  

• static void gpio_set_dir_all_bits (uint32_t values)

•  Set direction of all pins simultaneously.
  

• static void gpio_set_dir (uint gpio, bool out)

•  Set a single GPIO direction.
  

• static bool gpio_is_dir_out (uint gpio)

•  Check if a specific GPIO direction is OUT.
  

• static uint gpio_get_dir (uint gpio)

•  Get a specific GPIO direction.