[rp] Add SPI module

Author: andryblack

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

@@ -0,0 +1,60 @@
+#!/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/.
+# -----------------------------------------------------------------------------
+
+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):
+        return True
+
+    def build(self, env):
+        env.substitutions = {"id": self.instance}
+        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))
+
+        if env.has_module(":platform:dma"):
+            env.template("spi_master_dma.hpp.in", "spi_master_{}_dma.hpp".format(self.instance))
+            env.template("spi_master_dma_impl.hpp.in", "spi_master_{}_dma_impl.hpp".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:spi",
+        ":cmsis:device",
+        ":math:algorithm",
+        ":platform:gpio",
+        ":platform:clockgen")
+
+    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):
+    pass

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

@@ -0,0 +1,153 @@
+/*
+ * 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>
+
+// ----------------------------------------------------------------------------
+
+
+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 (txFifoFull())
+			return {modm::rf::Running};
+
+		// start transfer by copying data into register
+	    write(data);
+
+		// set LSB = Bit0
+		state |= Bit0;
+	}
+
+	if (rxFifoEmpty())
+		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(txFifoFull()) __NOP();
+		// Write next byte
+		write(tx ? tx[index] : 0);
+		index++;
+	}
+
+	drainRx();
+}
+