Adding RP2350 SDK and target framework (#13988)

* Adding RP2350 SDK and target framework

* Spacing

* Removing board definitions

lib/main/pico-sdk/host/hardware_sync/include/hardware/sync.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef _HARDWARE_SYNC_H
+#define _HARDWARE_SYNC_H
+
+#include "pico.h"
+
+#ifndef __cplusplus
+
+#if (__STDC_VERSION__ >= 201112L)
+#include <stdatomic.h>
+#else
+enum {
+    memory_order_acquire, memory_order_release
+};
+static inline void atomic_thread_fence(uint x) {}
+#endif
+
+#else
+
+#include <atomic>
+
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_ATOMIC, Spinlock ID for atomics, min=0, max=31, default=8, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_ATOMIC
+#define PICO_SPINLOCK_ID_ATOMIC 8
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_IRQ, Spinlock ID for IRQ protection, min=0, max=31, default=9, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_IRQ
+#define PICO_SPINLOCK_ID_IRQ 9
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_TIMER, Spinlock ID for Timer protection, min=0, max=31, default=10, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_TIMER
+#define PICO_SPINLOCK_ID_TIMER 10
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_HARDWARE_CLAIM, Spinlock ID for Hardware claim protection, min=0, max=31, default=11, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_HARDWARE_CLAIM
+#define PICO_SPINLOCK_ID_HARDWARE_CLAIM 11
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_RAND, Spinlock ID for Random Number Generator, min=0, max=31, default=12, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_RAND
+#define PICO_SPINLOCK_ID_RAND 12
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_OS1, First Spinlock ID reserved for use by low level OS style software, min=0, max=31, default=14, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_OS1
+#define PICO_SPINLOCK_ID_OS1 14
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_OS2, Second Spinlock ID reserved for use by low level OS style software, min=0, max=31, default=15, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_OS2
+#define PICO_SPINLOCK_ID_OS2 15
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_STRIPED_FIRST, Lowest Spinlock ID in the 'striped' range, min=0, max=31, default=16, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_STRIPED_FIRST
+#define PICO_SPINLOCK_ID_STRIPED_FIRST 16
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_STRIPED_LAST, Highest Spinlock ID in the 'striped' range, min=0, max=31, default=23, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_STRIPED_LAST
+#define PICO_SPINLOCK_ID_STRIPED_LAST 23
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_CLAIM_FREE_FIRST, Lowest Spinlock ID in the 'claim free' range, min=0, max=31, default=24, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_CLAIM_FREE_FIRST
+#define PICO_SPINLOCK_ID_CLAIM_FREE_FIRST 24
+#endif
+
+#ifdef PICO_SPINLOCK_ID_CLAIM_FREE_END
+#warning PICO_SPINLOCK_ID_CLAIM_FREE_END has been renamed to PICO_SPINLOCK_ID_CLAIM_FREE_LAST
+#endif
+
+// PICO_CONFIG: PICO_SPINLOCK_ID_CLAIM_FREE_LAST, Highest Spinlock ID in the 'claim free' range, min=0, max=31, default=31, group=hardware_sync
+#ifndef PICO_SPINLOCK_ID_CLAIM_FREE_LAST
+#define PICO_SPINLOCK_ID_CLAIM_FREE_LAST 31
+#endif
+
+typedef struct _spin_lock_t spin_lock_t;
+
+inline static void __mem_fence_acquire() {
+#ifndef __cplusplus
+    atomic_thread_fence(memory_order_acquire);
+#else
+    std::atomic_thread_fence(std::memory_order_acquire);
+#endif
+}
+
+inline static void __mem_fence_release() {
+#ifndef __cplusplus
+    atomic_thread_fence(memory_order_release);
+#else
+    std::atomic_thread_fence(std::memory_order_release);
+#endif
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __sev();
+
+void __wev();
+
+void __wfi();
+
+void __wfe();
+
+uint32_t save_and_disable_interrupts();
+
+void restore_interrupts(uint32_t status);
+
+void restore_interrupts_from_disabled(uint32_t status);
+
+uint spin_lock_get_num(spin_lock_t *lock);
+
+spin_lock_t *spin_lock_instance(uint lock_num);
+
+void spin_lock_unsafe_blocking(spin_lock_t *lock);
+
+void spin_unlock_unsafe(spin_lock_t *lock);
+
+uint32_t spin_lock_blocking(spin_lock_t *lock);
+
+bool is_spin_locked(const spin_lock_t *lock);
+
+void spin_unlock(spin_lock_t *lock, uint32_t saved_irq);
+
+spin_lock_t *spin_lock_init(uint lock_num);
+
+void clear_spin_locks(void);
+#define spin_locks_reset() clear_spin_locks()
+
+uint next_striped_spin_lock_num();
+
+void spin_lock_claim(uint lock_num);
+void spin_lock_claim_mask(uint32_t lock_num_mask);
+void spin_lock_unclaim(uint lock_num);
+int spin_lock_claim_unused(bool required);
+uint spin_lock_num(spin_lock_t *lock);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

lib/main/pico-sdk/host/hardware_sync/sync_core0_only.c

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "hardware/sync.h"
+#include "hardware/platform_defs.h"
+
+// This is a dummy implementation that is single threaded
+
+static struct _spin_lock_t {
+    bool locked;
+} _spinlocks[NUM_SPIN_LOCKS];
+
+PICO_WEAK_FUNCTION_DEF(save_and_disable_interrupts)
+
+//static uint8_t striped_spin_lock_num;
+
+uint32_t PICO_WEAK_FUNCTION_IMPL_NAME(save_and_disable_interrupts)() {
+    return 0;
+}
+
+PICO_WEAK_FUNCTION_DEF(restore_interrupts)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(restore_interrupts)(uint32_t status) {
+}
+
+PICO_WEAK_FUNCTION_DEF(restore_interrupts_from_disabled)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(restore_interrupts_from_disabled)(uint32_t status) {
+}
+
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_instance)
+
+spin_lock_t *PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_instance)(uint lock_num) {
+    assert(lock_num < NUM_SPIN_LOCKS);
+    return &_spinlocks[lock_num];
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_get_num)
+
+uint PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_get_num)(spin_lock_t *lock) {
+    return lock - _spinlocks;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_init)
+
+spin_lock_t *PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_init)(uint lock_num) {
+    spin_lock_t *lock = spin_lock_instance(lock_num);
+    spin_unlock_unsafe(lock);
+    return lock;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_unsafe_blocking)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_unsafe_blocking)(spin_lock_t *lock) {
+    lock->locked = true;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_blocking)
+
+uint32_t PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_blocking)(spin_lock_t *lock) {
+    spin_lock_unsafe_blocking(lock);
+    return 1; // todo wrong value
+}
+
+PICO_WEAK_FUNCTION_DEF(is_spin_locked)
+
+bool PICO_WEAK_FUNCTION_IMPL_NAME(is_spin_locked)(const spin_lock_t *lock) {
+    return lock->locked;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_unlock_unsafe)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_unlock_unsafe)(spin_lock_t *lock) {
+    lock->locked = false;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_unlock)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_unlock)(spin_lock_t *lock, uint32_t saved_irq) {
+    spin_unlock_unsafe(lock);
+}
+
+PICO_WEAK_FUNCTION_DEF(__sev)
+
+volatile bool event_fired;
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(__sev)() {
+    event_fired = true;
+}
+
+PICO_WEAK_FUNCTION_DEF(__wfi)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(__wfi)() {
+    panic("Can't wait on irq for host core0 only implementation");
+}
+
+PICO_WEAK_FUNCTION_DEF(__wfe)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(__wfe)() {
+    while (!event_fired) tight_loop_contents();
+}
+
+PICO_WEAK_FUNCTION_DEF(clear_spin_locks)
+
+void PICO_WEAK_FUNCTION_IMPL_NAME(clear_spin_locks)(void) {
+    for (uint i = 0; i < NUM_SPIN_LOCKS; i++) {
+        spin_unlock_unsafe(spin_lock_instance(i));
+    }
+}
+
+PICO_WEAK_FUNCTION_DEF(next_striped_spin_lock_num)
+uint PICO_WEAK_FUNCTION_IMPL_NAME(next_striped_spin_lock_num)() {
+    return 0;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_claim)
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_claim)(uint lock_num) {
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_claim_mask)
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_claim_mask)(uint32_t mask) {
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_unclaim)
+void PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_unclaim)(uint lock_num) {
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_claim_unused)
+int PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_claim_unused)(bool required) {
+    return 0;
+}
+
+PICO_WEAK_FUNCTION_DEF(spin_lock_num)
+uint PICO_WEAK_FUNCTION_IMPL_NAME(spin_lock_num)(spin_lock_t *lock) {
+    return 0;
+}