Add pico_low_power library

bazel/config/BUILD.bazel

@@ -217,10 +217,22 @@ string_flag(
     build_setting_default = "Debug",
 )
 
-# PICO_BAZEL_CONFIG: PICO_DEFAULT_LINKER_SCRIPT, [Bazel only] The library that provides a linker script to link into all binaries, default=//src/rp2_common/pico_crt0:default_linker_script, group=pico_standard_link
+# PICO_BAZEL_CONFIG: PICO_DEFAULT_BINARY_TYPE, The default binary type to use, type=string, default=default, group=build
+string_flag(
+    name = "PICO_DEFAULT_BINARY_TYPE",
+    build_setting_default = "default",
+    values = [
+        "default",
+        "no_flash",
+        "copy_to_ram",
+        "blocked_ram",
+    ],
+)
+
+# PICO_BAZEL_CONFIG: PICO_DEFAULT_LINKER_SCRIPT, [Bazel only] The library that provides a linker script to link into all binaries, default=//src/rp2_common/pico_standard_link:default_linker_script, group=pico_standard_link
 label_flag(
     name = "PICO_DEFAULT_LINKER_SCRIPT",
-    build_setting_default = "//src/rp2_common/pico_crt0:default_linker_script",
+    build_setting_default = "//src/rp2_common/pico_standard_link:default_linker_script",
 )
 
 # PICO_BAZEL_CONFIG: PICO_NO_TARGET_NAME, Don't define PICO_TARGET_NAME, type=bool, default=0, group=build

bazel/constraint/BUILD.bazel

@@ -273,3 +273,18 @@ config_setting(
     name = "pico_compilation_no_fastbuild_args_set",
     flag_values = {"//bazel/config:PICO_COMPILATION_NO_FASTBUILD_ARGS": "True"},
 )
+
+config_setting(
+    name = "pico_binary_type_no_flash",
+    flag_values = {"//bazel/config:PICO_DEFAULT_BINARY_TYPE": "no_flash"},
+)
+
+config_setting(
+    name = "pico_binary_type_copy_to_ram",
+    flag_values = {"//bazel/config:PICO_DEFAULT_BINARY_TYPE": "copy_to_ram"},
+)
+
+config_setting(
+    name = "pico_binary_type_blocked_ram",
+    flag_values = {"//bazel/config:PICO_DEFAULT_BINARY_TYPE": "blocked_ram"},
+)

bazel/util/pico_linker_scripts.bzl

@@ -0,0 +1,38 @@
+load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "use_cpp_toolchain")
+
+def _linker_scripts_impl(ctx):
+    link_flags = []
+    for script in ctx.attr.include_scripts:
+        link_include_dir = script.label.package
+        if ctx.label.workspace_root:
+            link_include_dir = "/".join((ctx.label.workspace_root, link_include_dir))
+        link_flag = "-L" + str(link_include_dir)
+        if not (link_flag in link_flags):
+            link_flags.append(link_flag)
+
+    for script in ctx.files.link_scripts:
+        link_flags.append("-T" + str(script.path))
+
+    all_scripts = ctx.files.link_scripts + ctx.files.include_scripts
+
+    linking_inputs = cc_common.create_linker_input(
+        owner = ctx.label,
+        user_link_flags = depset(
+            direct = link_flags,
+        ),
+        additional_inputs = depset(direct = all_scripts),
+    )
+    return [
+        DefaultInfo(files = depset(direct = all_scripts)),
+        CcInfo(linking_context = cc_common.create_linking_context(linker_inputs = depset(direct = [linking_inputs]))),
+    ]
+
+linker_scripts = rule(
+    implementation = _linker_scripts_impl,
+    attrs = {
+        "link_scripts": attr.label_list(allow_files = [".ld"], doc = "List of scripts to explicitly link"),
+        "include_scripts": attr.label_list(allow_files = [".incl"], doc = "List of scripts to include"),
+    },
+    toolchains = use_cpp_toolchain(),
+    fragments = ["cpp"],
+)

bazel/util/transition.bzl

@@ -167,3 +167,33 @@ extra_copts_for_all_deps = declare_transtion(
         "//command_line_option:copt": "extra_copts",
     },
 )
+
+# This transition sets the binary type
+pico_set_binary_type = declare_transtion(
+    attrs = {
+        "binary_type": attr.string(),
+        # This could be shared, but we don't in order to make it clearer that
+        # a transition is in use.
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+    flag_overrides = {
+        "@pico-sdk//bazel/config:PICO_DEFAULT_BINARY_TYPE": "binary_type",
+    },
+)
+
+# This transition sets the binary type
+pico_set_linker_script = declare_transtion(
+    attrs = {
+        "linker_script": attr.string(),
+        # This could be shared, but we don't in order to make it clearer that
+        # a transition is in use.
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+    flag_overrides = {
+        "@pico-sdk//bazel/config:PICO_DEFAULT_LINKER_SCRIPT": "linker_script",
+    },
+)

src/cmake/rp2_common.cmake

@@ -49,6 +49,7 @@ pico_add_subdirectory(rp2_common/hardware_pio)
 pico_add_subdirectory(rp2_common/hardware_pll)
 pico_add_subdirectory(rp2_common/hardware_pwm)
 pico_add_subdirectory(rp2_common/hardware_resets)
+pico_add_subdirectory(rp2_common/hardware_rosc)
 if (PICO_RP2040 OR PICO_COMBINED_DOCS)
     pico_add_subdirectory(rp2_common/hardware_rtc)
 endif()
@@ -103,6 +104,7 @@ if (NOT PICO_BARE_METAL)
     pico_add_subdirectory(rp2_common/pico_int64_ops)
     pico_add_subdirectory(rp2_common/pico_flash)
     pico_add_subdirectory(rp2_common/pico_float)
+    pico_add_subdirectory(rp2_common/pico_low_power)
     pico_add_subdirectory(rp2_common/pico_mem_ops)
     pico_add_subdirectory(rp2_common/pico_malloc)
     pico_add_subdirectory(rp2_common/pico_printf)

src/common/pico_base_headers/BUILD.bazel

@@ -74,6 +74,11 @@ cc_library(
         "//bazel/constraint:rp2040": ["PICO_RP2040=1"],
         "//bazel/constraint:rp2350": ["PICO_RP2350=1"],
         "//conditions:default": [],
+    }) + select({
+        "//bazel/constraint:pico_binary_type_no_flash": ["PICO_NO_FLASH=1"],
+        "//bazel/constraint:pico_binary_type_copy_to_ram": ["PICO_COPY_TO_RAM=1"],
+        "//bazel/constraint:pico_binary_type_blocked_ram": ["PICO_USE_BLOCKED_RAM=1"],
+        "//conditions:default": [],
     }),
 )
 
@@ -113,6 +118,7 @@ cc_library(
         "//src/rp2_common/hardware_ticks:__pkg__",
         "//src/rp2_common/hardware_timer:__pkg__",
         "//src/rp2_common/hardware_watchdog:__pkg__",
+        "//src/rp2_common/hardware_rosc:__pkg__",
         "//src/rp2_common/hardware_xosc:__pkg__",
         "//src/rp2_common/pico_crt0:__pkg__",
         "//src/rp2_common/pico_platform_common:__pkg__",

src/common/pico_util/BUILD.bazel

@@ -11,6 +11,7 @@ cc_library(
         "queue.c",
     ],
     hdrs = [
+        "include/pico/util/bitset.h",
         "include/pico/util/datetime.h",
         "include/pico/util/pheap.h",
         "include/pico/util/queue.h",

src/common/pico_util/include/pico/util/bitset.h

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2026 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef _PICO_UTIL_BITSET_H
+#define _PICO_UTIL_BITSET_H
+
+#include "pico.h"
+
+/** \file bitset.h
+ * \defgroup bitset bitset
+ * \brief Simple bitset implementation
+ *
+ * \ingroup pico_util
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    uint16_t size;           \
+    uint16_t word_size;     \
+    uint32_t words[];
+} generic_bitset_t;
+
+/*! \brief Macro used to define a bitset type
+ * \ingroup pico_util
+ * This macro is used to define a bitset type. It is used as follows:
+ * ```
+ * typedef bitset_type_t(32) my_bitset_t;
+ * ```
+ * will define a new bitset type called `my_bitset_t` that can hold 32 bits.
+ * 
+ * The type can be used as `my_bitset_t bitset;` to declare a new bitset.
+ * 
+ * \param N the number of bits in the bitset
+ */
+#define bitset_type_t(N) union { \
+    generic_bitset_t bitset;    \
+    struct {                    \
+        uint16_t size;          \
+        uint16_t word_size;     \
+        uint32_t words[((N) + 31) / 32]; \
+    } sized_bitset;             \
+}
+#define bitset_sizeof_for(N) ((((N) + 63u) / 32u) * 4u)
+
+/*! \brief Macro used to create a bitset with all bits set to a value
+ * \ingroup pico_util
+ * \param type the type of the bitset
+ * \param N the number of bits in the bitset
+ * \param value the value to set the bits to (0 or 1)
+ * \return the bitset
+ */
+#define bitset_with_value(type, N, value) ({ type bitset; bitset_init(&bitset, type, N, value); bitset; })
+
+// Quick test that the bitset macros give the correct size
+extern bitset_type_t(32) __not_real_bitset32;
+extern bitset_type_t(33) __not_real_bitset33;
+static_assert(sizeof(__not_real_bitset32) == bitset_sizeof_for(1),"");
+static_assert(sizeof(__not_real_bitset33) == bitset_sizeof_for(37), "");
+
+/*! \brief Initialize a bitset
+ * \ingroup pico_util
+ * \param ptr the bitset to initialize
+ * \param type the type of the bitset
+ * \param N the number of bits in the bitset
+ * \param fill the value to fill the bitset with (0 or 1)
+ */
+#define bitset_init(ptr, type, N, fill) ({ \
+    assert(sizeof(type) == bitset_sizeof_for(N)); \
+    __unused type *type_check = ptr;       \
+    __builtin_memset(ptr, (fill) ? 0xff : 0, sizeof(type));                  \
+    (ptr)->bitset.size = N;                        \
+    (ptr)->bitset.word_size = ((N) + 31u) / 32u;   \
+})
+
+/*! \brief Get the size of the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to get the size of
+ * \return the size of the bitset
+ */
+static inline uint bitset_size(const generic_bitset_t *bitset) {
+    return bitset->size;
+}
+
+/*! \brief Get the size of the bitset in words
+ * \ingroup pico_util
+ * \param bitset the bitset to get the size of
+ * \return the size of the bitset in words
+ */
+static inline uint bitset_word_size(const generic_bitset_t *bitset) {
+    return bitset->word_size;
+}
+
+/*! \brief Check that the bitset is valid
+ * \ingroup pico_util
+ * This function will assert if the bitset is not valid.
+ * \param bitset the bitset to check
+ */
+static inline void check_bitset(const generic_bitset_t *bitset) {
+    assert(bitset->word_size == (bitset->size + 31) / 32);
+}
+
+/*! \brief Write a word in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to write to
+ * \param word_num the word number to write to
+ * \param value the value to write to the word
+ * \return the bitset
+ */
+static inline generic_bitset_t *bitset_write_word(generic_bitset_t *bitset, uint word_num, uint32_t value) {
+    check_bitset(bitset);
+    if (word_num < bitset_word_size(bitset)) {
+        bitset->words[word_num] = value;
+    }
+    return bitset;
+}
+
+/*! \brief Read a word in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to read from
+ * \param word_num the word number to read from
+ * \return the value of the word
+ */
+static inline uint32_t bitset_read_word(const generic_bitset_t *bitset, uint word_num) {
+    check_bitset(bitset);
+    if (word_num < bitset_word_size(bitset)) {
+        return bitset->words[word_num];
+    }
+    return 0;
+}
+
+/*! \brief Clear all bits in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to clear
+ * \return the bitset
+ */
+static inline generic_bitset_t *bitset_clear(generic_bitset_t *bitset) {
+    check_bitset(bitset);
+    __builtin_memset(bitset->words, 0, bitset->word_size * sizeof(uint32_t));
+    return bitset;
+}
+
+/*! \brief Set all bits in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to set
+ * \return the bitset
+ */
+static inline generic_bitset_t *bitset_set_all(generic_bitset_t *bitset) {
+    check_bitset(bitset);
+    __builtin_memset(bitset->words, 0xff, bitset->word_size * sizeof(uint32_t));
+    return bitset;
+}
+
+/*! \brief Set a single bit in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to set
+ * \param bit the bit to set
+ * \return the bitset
+ */
+static inline generic_bitset_t *bitset_set_bit(generic_bitset_t *bitset, uint bit) {
+    check_bitset(bitset);
+    if (bit < bitset->size) {
+        bitset->words[bit / 32u] |= 1u << (bit % 32u);
+    }
+    return bitset;
+}
+
+/*! \brief Clear a single bit in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to clear
+ * \param bit the bit to clear
+ * \return the bitset
+ */
+static inline generic_bitset_t *bitset_clear_bit(generic_bitset_t *bitset, uint bit) {
+    check_bitset(bitset);
+    if (bit < bitset->size) {
+        bitset->words[bit / 32u] &= ~(1u << (bit % 32u));
+    }
+    return bitset;
+}
+
+/*! \brief Get the value of a single bit in the bitset
+ * \ingroup pico_util
+ * \param bitset the bitset to get the value of
+ * \param bit the bit to get the value of
+ * \return the value of the bit
+ */
+static inline bool bitset_get_bit(generic_bitset_t *bitset, uint bit) {
+    check_bitset(bitset);
+    assert(bit < bitset->size);
+//    if (bit < bitset->size) {
+        return bitset->words[bit / 32u] & (1u << (bit % 32u));
+//    }
+    return false;
+}
+
+/*! \brief Check if two bitsets are equal
+ * \ingroup pico_util
+ * \param bitset1 the first bitset to check
+ * \param bitset2 the second bitset to check
+ * \return true if the bitsets are equal, false otherwise
+ */
+static inline bool bitset_equal(const generic_bitset_t *bitset1, const generic_bitset_t *bitset2) {
+    check_bitset(bitset1);
+    check_bitset(bitset2);
+    assert(bitset1->size == bitset2->size);
+    return __builtin_memcmp(bitset1->words, bitset2->words, bitset1->word_size * sizeof(uint32_t)) == 0;
+}
+
+typedef uint32_t tiny_encoded_bitset_t;
+typedef uint64_t encoded_bitset_t;
+
+#define encoded_bitset_empty() 0
+#define encoded_bitset_of1(v) (1u | ((v) << 8))
+#define encoded_bitset_of2(v1, v2) (2u | ((v1) << 8) | ((v2) << 16))
+#define encoded_bitset_of3(v1, v2, v3) (3u | ((v1) << 8) | ((v2) << 16) | (((v3) << 24)))
+#define encoded_bitset_of4(v1, v2, v3, v4) (4u | ((v1) << 8) | ((v2) << 16) | (((v3) << 24)) | (((uint64_t)(v4)) << 32))
+#define encoded_bitset_of5(v1, v2, v3, v4, v5) (5u | ((v1) << 8) | ((v2) << 16) | (((v3) << 24)) | (((uint64_t)((v4) | ((v5)<<8u))) << 32))
+
+#define encoded_bitset_foreach(bitset, x) ({ \
+    for(uint _i=0;_i<((bitset)&0xffu);_i++) {  \
+        uint bit = (uint8_t)((bitset) >> (8 * _i)); \
+        x;                                   \
+    }                                        \
+})
+#ifdef __cplusplus
+}
+#endif
+#endif