[rp2040] spi

Author: andryblack

src/modm/platform/gpio/rp/config.hpp.in

@@ -33,8 +33,8 @@ enum class PeripheralPin
     Sda,
     Scl,
     /* spi */
-    Miso,
-    Mosi,
+    /* Miso - Rx for master, Tx for slave */
+    /* Mosi - Tx for master, Rx for slave */
     Sclk,
     /* pwm */
     A,

src/modm/platform/spi/rp/module.lb

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2022, Andrey Kunitsyn
+#
+# This file is part of the modm project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# -----------------------------------------------------------------------------
+
+def get_properties(env):
+    device = env[":target"]
+    driver = device.get_driver("spi")
+    properties = {}
+    properties["target"] = device.identifier
+    properties["features"] = driver["feature"] if "feature" in driver else []
+    return properties
+
+class Instance(Module):
+    def __init__(self, driver, instance):
+        self.instance = int(instance)
+        self.driver = driver
+
+    def init(self, module):
+        module.name = str(self.instance)
+        module.description = "Instance {}".format(self.instance)
+
+    def prepare(self, module, options):
+        module.depends(":platform:spi")
+        return True
+
+    def build(self, env):
+        properties = get_properties(env)
+        properties["id"] = self.instance
+
+        env.substitutions = properties
+        env.outbasepath = "modm/src/modm/platform/spi"
+
+        env.template("spi_master.hpp.in", "spi_master_{}.hpp".format(self.instance))
+        env.template("spi_master.cpp.in", "spi_master_{}.cpp".format(self.instance))
+
+def init(module):
+    module.name = ":platform:spi"
+    module.description = "Serial Peripheral Interface (SPI)"
+
+def prepare(module, options):
+    device = options[":target"]
+    if not device.has_driver("spi:rp20*"):
+        return False
+
+    module.depends(
+        ":architecture:register",
+        ":architecture:spi",
+        ":cmsis:device",
+        ":math:algorithm",
+        ":platform:gpio")
+
+    for driver in device.get_all_drivers("spi:rp20*"):
+        for instance in driver["instance"]:
+            module.add_submodule(Instance(driver, instance))
+
+    return True
+
+def build(env):
+    env.substitutions = get_properties(env)
+    env.outbasepath = "modm/src/modm/platform/spi"

src/modm/platform/spi/rp/spi_master.cpp.in

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2022, Andrey Kunitsyn
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#include "spi_master_{{id}}.hpp"
+#include <modm/platform/core/resets.hpp>
+
+// ----------------------------------------------------------------------------
+
+static inline bool tx_fifo_full() {
+	return (spi{{ id }}_hw->sr & SPI_SSPSR_TNF_BITS) == 0;
+}
+static inline bool is_busy() {
+	return (spi{{ id }}_hw->sr & SPI_SSPSR_BSY_BITS);
+}
+static inline bool rx_fifo_empty() {
+	return (spi{{ id }}_hw->sr & SPI_SSPSR_RNE_BITS) == 0;
+}
+
+void modm::platform::SpiMaster{{ id }}::reset()
+{
+	Resets::reset(RESETS_RESET_SPI{{ id }}_BITS);
+}
+
+void modm::platform::SpiMaster{{ id }}::unreset()
+{
+	Resets::unresetWait(RESETS_RESET_SPI{{ id }}_BITS);
+}
+
+uint8_t
+modm::platform::SpiMaster{{ id }}::acquire(void *ctx, ConfigurationHandler handler)
+{
+	if (context == nullptr)
+	{
+		context = ctx;
+		count = 1;
+		// if handler is not nullptr and is different from previous configuration
+		if (handler and configuration != handler) {
+			configuration = handler;
+			configuration();
+		}
+		return 1;
+	}
+
+	if (ctx == context)
+		return ++count;
+
+	return 0;
+}
+
+uint8_t
+modm::platform::SpiMaster{{ id }}::release(void *ctx)
+{
+	if (ctx == context)
+	{
+		if (--count == 0)
+			context = nullptr;
+	}
+	return count;
+}
+// ----------------------------------------------------------------------------
+
+modm::ResumableResult<uint8_t>
+modm::platform::SpiMaster{{ id }}::transfer(uint8_t data)
+{
+	// this is a manually implemented "fast resumable function"
+	// there is no context or nesting protection, since we don't need it.
+	// there are only two states encoded into 1 bit (LSB of state):
+	//   1. waiting to start, and
+	//   2. waiting to finish.
+
+	// LSB != Bit0 ?
+	if ( !(state & Bit0) )
+	{
+		// wait for previous transfer to finish
+		if (tx_fifo_full())
+			return {modm::rf::Running};
+
+		// start transfer by copying data into register
+	    write(data);
+
+		// set LSB = Bit0
+		state |= Bit0;
+	}
+
+	if (rx_fifo_empty())
+		return {modm::rf::Running};
+
+	// transfer finished
+	state &= ~Bit0;
+	return {modm::rf::Stop, read()};
+}
+
+modm::ResumableResult<void>
+modm::platform::SpiMaster{{ id }}::transfer(
+		const uint8_t * tx, uint8_t * rx, std::size_t length)
+{
+	// this is a manually implemented "fast resumable function"
+	// there is no context or nesting protection, since we don't need it.
+	// there are only two states encoded into 1 bit (Bit1 of state):
+	//   1. initialize index, and
+	//   2. wait for 1-byte transfer to finish.
+
+	// we need to globally remember which byte we are currently transferring
+	static std::size_t index = 0;
+
+	// we are only interested in Bit1
+	switch(state & Bit1)
+	{
+		case 0:
+			// we will only visit this state once
+			state |= Bit1;
+
+			// initialize index and check range
+			index = 0;
+			while (index < length)
+			{
+		default:
+		{
+				// if tx == 0, we use a dummy byte 0x00
+				// else we copy it from the array
+				// call the resumable function
+				modm::ResumableResult<uint8_t> result = transfer(tx ? tx[index] : 0);
+
+				// if the resumable function is still running, so are we
+				if (result.getState() > modm::rf::NestingError)
+					return {modm::rf::Running};
+
+				// if rx != 0, we copy the result into the array
+				if (rx) rx[index] = result.getResult();
+		}
+				index++;
+			}
+
+			// clear the state
+			state &= ~Bit1;
+			return {modm::rf::Stop};
+	}
+}
+
+void modm::platform::SpiMaster{{ id }}::transferBlocking(
+		const uint8_t *tx, std::size_t length)
+{
+	uint8_t index = 0;
+	while(index < length) {
+		// Wait for tx empty
+		while(tx_fifo_full()) __NOP();
+		// Write next byte
+		write(tx ? tx[index] : 0);
+		index++;
+	}
+
+	// Drain RX FIFO, then wait for shifting to finish (which may be *after*
+    // TX FIFO drains), then drain RX FIFO again
+    while (!rx_fifo_empty())
+        (void)read();
+    while (is_busy())
+        __NOP();
+    while (!rx_fifo_empty())
+        (void)read();;
+
+    // Don't leave overrun flag set
+    spi{{ id }}_hw->icr = SPI_SSPICR_RORIC_BITS;
+}
+