Fix hw_is_claimed, and add xxx_is_claimed APIs

Author: kilograham

src/rp2_common/hardware_claim/claim.c

@@ -14,22 +14,13 @@ void hw_claim_unlock(uint32_t save) {
     spin_unlock(spin_lock_instance(PICO_SPINLOCK_ID_HARDWARE_CLAIM), save);
 }
 
-bool hw_is_claimed(uint8_t *bits, uint bit_index) {
-    bool rc;
-    uint32_t save = hw_claim_lock();
-    if (bits[bit_index >> 3u] & (1u << (bit_index & 7u))) {
-        rc = false;
-    } else {
-        bits[bit_index >> 3u] |= (uint8_t)(1u << (bit_index & 7u));
-        rc = true;
-    }
-    hw_claim_unlock(save);
-    return rc;
+inline bool hw_is_claimed(const uint8_t *bits, uint bit_index) {
+    return (bits[bit_index >> 3u] & (1u << (bit_index & 7u)));
 }
 
 void hw_claim_or_assert(uint8_t *bits, uint bit_index, const char *message) {
     uint32_t save = hw_claim_lock();
-    if (bits[bit_index >> 3u] & (1u << (bit_index & 7u))) {
+    if (hw_is_claimed(bits, bit_index)) {
         panic(message, bit_index);
     } else {
         bits[bit_index >> 3u] |= (uint8_t)(1u << (bit_index & 7u));
@@ -42,7 +33,7 @@ int hw_claim_unused_from_range(uint8_t *bits, bool required, uint bit_lsb, uint
     uint32_t save = hw_claim_lock();
     int found_bit = -1;
     for(uint bit=bit_lsb; bit <= bit_msb; bit++) {
-        if (!(bits[bit >> 3u] & (1u << (bit & 7u)))) {
+        if (!hw_is_claimed(bits, bit)) {
             bits[bit >> 3u] |= (uint8_t)(1u << (bit & 7u));
             found_bit = (int)bit;
             break;
@@ -57,7 +48,7 @@ int hw_claim_unused_from_range(uint8_t *bits, bool required, uint bit_lsb, uint
 
 void hw_claim_clear(uint8_t *bits, uint bit_index) {
     uint32_t save = hw_claim_lock();
-    assert(bits[bit_index >> 3u] & (1u << (bit_index & 7u)));
+    assert(hw_is_claimed(bits, bit_index));
     bits[bit_index >> 3u] &= (uint8_t) ~(1u << (bit_index & 7u));
     hw_claim_unlock(save);
 }

src/rp2_common/hardware_claim/include/hardware/claim.h

@@ -68,7 +68,7 @@ int hw_claim_unused_from_range(uint8_t *bits, bool required, uint bit_lsb, uint
  * \param bit_index resource to unclaim (bit index into array of bits)
  * \return true if the resource is claimed
  */
-bool hw_is_claimed(uint8_t *bits, uint bit_index);
+bool hw_is_claimed(const uint8_t *bits, uint bit_index);
 
 /*! \brief Atomically unclaim a resource
  *  \ingroup hardware_claim

src/rp2_common/hardware_dma/dma.c

@@ -39,6 +39,11 @@ int dma_claim_unused_channel(bool required) {
     return hw_claim_unused_from_range((uint8_t*)&_claimed, required, 0, NUM_DMA_CHANNELS-1, "No DMA channels are available");
 }
 
+bool dma_channel_is_claimed(uint channel) {
+    check_dma_channel_param(channel);
+    return hw_is_claimed((uint8_t *) &_claimed, channel);
+}
+
 #ifndef NDEBUG
 
 void print_dma_ctrl(dma_channel_hw_t *channel) {

src/rp2_common/hardware_dma/include/hardware/dma.h

@@ -98,6 +98,15 @@ void dma_channel_unclaim(uint channel);
  */
 int dma_claim_unused_channel(bool required);
 
+/*! \brief Determine if a dma channel is claimed
+ *  \ingroup hardware_dma
+ *
+ * \param channel the dma channel
+ * \see dma_channel_claim
+ * \see dma_channel_claim_mask
+ */
+bool dma_channel_is_claimed(uint channel);
+
 /** \brief DMA channel configuration
  *  \defgroup channel_config channel_config
  *  \ingroup hardware_dma

src/rp2_common/hardware_interp/include/hardware/interp.h

@@ -55,7 +55,7 @@ typedef struct {
 } interp_config;
 
 static inline uint interp_index(interp_hw_t *interp) {
-    assert(interp == interp0 || interp == interp1);
+    valid_params_if(INTERP, interp == interp0 || interp == interp1);
     return interp == interp1 ? 1 : 0;
 }
 
@@ -70,6 +70,8 @@ static inline uint interp_index(interp_hw_t *interp) {
  * \param lane The lane number, 0 or 1.
  */
 void interp_claim_lane(interp_hw_t *interp, uint lane);
+// The above really should be called this for consistency
+#define interp_lane_claim interp_claim_lane
 
 /*! \brief Claim the interpolator lanes specified in the mask
  *  \ingroup hardware_interp
@@ -86,6 +88,19 @@ void interp_claim_lane_mask(interp_hw_t *interp, uint lane_mask);
  * \param lane The lane number, 0 or 1
  */
 void interp_unclaim_lane(interp_hw_t *interp, uint lane);
+// The above really should be called this for consistency
+#define interp_lane_unclaim interp_unclaim_lane
+
+/*! \brief Determine if an interpolator lane is claimed
+ *  \ingroup hardware_interp
+ *
+ * \param interp Interpolator whose lane to check
+ * \param lane The lane number, 0 or 1
+ * \return true if claimed, false otherwise
+ * \see interp_claim_lane
+ * \see interp_claim_lane_mask
+ */
+bool interp_lane_is_claimed(interp_hw_t *interp, uint lane);
 
 /*! \brief Set the interpolator shift value
  *  \ingroup interp_config

src/rp2_common/hardware_interp/interp.c

@@ -16,10 +16,13 @@ static_assert(NUM_DMA_CHANNELS <= 16, "");
 
 static uint8_t _claimed;
 
+static inline uint interp_lane_bit(interp_hw_t * interp, uint lane) {
+    return (interp_index(interp) << 1u) | lane;
+}
+
 void interp_claim_lane(interp_hw_t *interp, uint lane) {
     valid_params_if(INTERP, lane < 2);
-    uint bit = (interp_index(interp) << 1u) | lane;
-    hw_claim_or_assert((uint8_t *) &_claimed, bit, "Lane is already claimed");
+    hw_claim_or_assert((uint8_t *) &_claimed, interp_lane_bit(interp, lane), "Lane is already claimed");
 }
 
 void interp_claim_lane_mask(interp_hw_t *interp, uint lane_mask) {
@@ -30,8 +33,12 @@ void interp_claim_lane_mask(interp_hw_t *interp, uint lane_mask) {
 
 void interp_unclaim_lane(interp_hw_t *interp, uint lane) {
     valid_params_if(INTERP, lane < 2);
-    uint bit = (interp_index(interp) << 1u) | lane;
-    hw_claim_clear((uint8_t *) &_claimed, bit);
+    hw_claim_clear((uint8_t *) &_claimed, interp_lane_bit(interp, lane));
+}
+
+bool interp_lane_is_claimed(interp_hw_t *interp, uint lane) {
+    valid_params_if(INTERP, lane < 2);
+    return hw_is_claimed((uint8_t *) &_claimed, interp_lane_bit(interp, lane));
 }
 
 void interp_save(interp_hw_t *interp, interp_hw_save_t *saver) {

src/rp2_common/hardware_pio/include/hardware/pio.h

@@ -1136,6 +1136,17 @@ void pio_sm_unclaim(PIO pio, uint sm);
  */
 int pio_claim_unused_sm(PIO pio, bool required);
 
+/*! \brief Determine if a PIO state machine is claimed
+ *  \ingroup hardware_pio
+ *
+ * \param pio The PIO instance; either \ref pio0 or \ref pio1
+ * \param sm State machine index (0..3)
+ * \return true if claimed, false otherwise
+ * \see pio_sm_claim
+ * \see pio_claim_sm_mask
+ */
+bool pio_sm_is_claimed(PIO pio, uint sm);
+
 #ifdef __cplusplus
 }
 #endif

src/rp2_common/hardware_pio/pio.c

@@ -35,6 +35,7 @@ void pio_claim_sm_mask(PIO pio, uint sm_mask) {
         if (sm_mask & 1u) pio_sm_claim(pio, i);
     }
 }
+
 void pio_sm_unclaim(PIO pio, uint sm) {
     check_sm_param(sm);
     uint which = pio_get_index(pio);
@@ -50,6 +51,12 @@ int pio_claim_unused_sm(PIO pio, bool required) {
     return index >= (int)base ? index - (int)base : -1;
 }
 
+bool pio_sm_is_claimed(PIO pio, uint sm) {
+    check_sm_param(sm);
+    uint which = pio_get_index(pio);
+    return hw_is_claimed(&claimed, which * NUM_PIO_STATE_MACHINES + sm);
+}
+
 static_assert(PIO_INSTRUCTION_COUNT <= 32, "");
 static uint32_t _used_instruction_space[2];
 

src/rp2_common/hardware_sync/include/hardware/sync.h

@@ -341,6 +341,16 @@ void spin_lock_unclaim(uint lock_num);
  */
 int spin_lock_claim_unused(bool required);
 
+/*! \brief Determine if a spin lock is claimed
+ *  \ingroup hardware_sync
+ *
+ * \param lock_num the spin lock number
+ * \return true if claimed, false otherwise
+ * \see spin_lock_claim
+ * \see spin_lock_claim_mask
+ */
+bool spin_lock_is_claimed(uint lock_num);
+
 #define remove_volatile_cast(t, x) ({__mem_fence_acquire(); (t)(x); })
 
 #ifdef __cplusplus

src/rp2_common/hardware_sync/sync.c

@@ -57,3 +57,8 @@ int spin_lock_claim_unused(bool required) {
     return hw_claim_unused_from_range((uint8_t*)&claimed, required, PICO_SPINLOCK_ID_CLAIM_FREE_FIRST, PICO_SPINLOCK_ID_CLAIM_FREE_END, "No spinlocks are available");
 }
 
+bool spin_lock_is_claimed(uint lock_num) {
+    check_lock_num(lock_num);
+    return hw_is_claimed((uint8_t *) &claimed, lock_num);
+}
+