Merge pull request #50 from Neotron-Compute/set_irq_pin

Add interrupt support

Author: jonathanpallant

neotron-bmc-pico/src/main.rs

@@ -16,7 +16,7 @@ use core::convert::TryFrom;
 use heapless::spsc::{Consumer, Producer, Queue};
 use rtic::app;
 use stm32f0xx_hal::{
-	gpio::gpioa::{PA10, PA11, PA12, PA15, PA2, PA3, PA4, PA9},
+	gpio::gpioa::{PA10, PA11, PA12, PA15, PA2, PA3, PA4, PA8, PA9},
 	gpio::gpiob::{PB0, PB1, PB3, PB4, PB5},
 	gpio::gpiof::{PF0, PF1},
 	gpio::{Alternate, Floating, Input, Output, PullDown, PullUp, PushPull, AF1},
@@ -165,6 +165,8 @@ mod app {
 		press_button_reset_short: debouncr::Debouncer<u8, debouncr::Repeat2>,
 		/// Run-time Clock Control (required for resetting peripheral blocks)
 		rcc: Option<rcc::Rcc>,
+		/// IRQ pin
+		pin_irq: PA8<Output<PushPull>>,
 	}
 
 	#[monotonic(binds = SysTick, default = true)]
@@ -230,6 +232,7 @@ mod app {
 			pin_sck,
 			pin_cipo,
 			pin_copi,
+			mut pin_irq,
 		) = cortex_m::interrupt::free(|cs| {
 			(
 				// uart_tx,
@@ -273,11 +276,21 @@ mod app {
 				},
 				// pin_copi,
 				gpioa.pa7.into_alternate_af0(cs),
+				// pin_irq
+				gpioa.pa8.into_push_pull_output(cs),
 			)
 		});
 
+		// Put host in reset
 		pin_sys_reset.set_low().unwrap();
+		// Turn the PSU off
 		pin_dc_on.set_low().unwrap();
+		// IRQ is active low; we have no need for service.
+		pin_irq.set_high().unwrap();
+		// Power LED is off
+		led_power.set_low().unwrap();
+		// Buzzer is off
+		_buzzer_pwm.set_low().unwrap();
 
 		defmt::info!("Creating UART...");
 
@@ -293,9 +306,6 @@ mod app {
 			&mut rcc,
 		);
 
-		led_power.set_low().unwrap();
-		_buzzer_pwm.set_low().unwrap();
-
 		// Set EXTI15 to use PORT A (PA15) - button input
 		dp.SYSCFG.exticr4.modify(|_r, w| w.exti15().pa15());
 
@@ -348,6 +358,7 @@ mod app {
 			press_button_power_long: debouncr::debounce_16(false),
 			press_button_reset_short: debouncr::debounce_2(false),
 			rcc: Some(rcc),
+			pin_irq,
 		};
 		let init = init::Monotonics(mono);
 		(shared_resources, local_resources, init)
@@ -356,7 +367,7 @@ mod app {
 	/// Our idle task.
 	///
 	/// This task is called when there is nothing else to do.
-	#[idle(shared = [msg_q_out, msg_q_in, spi, state_dc_power_enabled, pin_dc_on, pin_sys_reset], local = [rcc])]
+	#[idle(shared = [msg_q_out, msg_q_in, spi, state_dc_power_enabled, pin_dc_on, pin_sys_reset], local = [rcc, pin_irq])]
 	fn idle(mut ctx: idle::Context) -> ! {
 		// TODO: Get this from the VERSION static variable or from PKG_VERSION
 		let mut register_state = RegisterState {
@@ -366,7 +377,25 @@ mod app {
 		// Take this out of the `local` object to avoid sharing issues.
 		let mut rcc = ctx.local.rcc.take().unwrap();
 		defmt::info!("Idle is running...");
+		let mut irq_masked = true;
+		let mut is_high = false;
 		loop {
+			if !irq_masked && !register_state.ps2_kb_bytes.is_empty() {
+				// We need service
+				ctx.local.pin_irq.set_low().unwrap();
+				if is_high {
+					defmt::trace!("irq set");
+					is_high = false;
+				}
+			} else {
+				// We do not need service
+				ctx.local.pin_irq.set_high().unwrap();
+				if !is_high {
+					defmt::trace!("irq clear");
+					is_high = true;
+				}
+			}
+
 			match ctx.shared.msg_q_out.dequeue() {
 				Some(Message::Ps2Data0(word)) => {
 					if let Some(byte) = neotron_bmc_pico::ps2::Ps2Decoder::check_word(word) {
@@ -392,11 +421,13 @@ mod app {
 							.state_dc_power_enabled
 							.lock(|r| *r = DcPowerState::Off);
 						// Stop any SPI stuff that's currently going on (the host is about to be powered off)
-						ctx.shared.spi.lock(|s| s.stop());
+						ctx.shared.spi.lock(|s| s.reset(&mut rcc));
 						// Put the host into reset
 						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
 						// Shut off the 5V power
 						ctx.shared.pin_dc_on.set_low().unwrap();
+						// Mask the IRQ to avoid back-powering the host
+						irq_masked = true;
 						// Start LED blinking again
 						led_power_blink::spawn().unwrap();
 					}
@@ -418,6 +449,8 @@ mod app {
 						// TODO: Take system out of reset when 3.3V and 5.0V are good
 						// Returns an error if it's already scheduled (but we don't care)
 						let _ = exit_reset::spawn_after(RESET_DURATION_MS.millis());
+						// Set 5 - unmask the IRQ
+						irq_masked = false;
 					}
 				}
 				Some(Message::PowerButtonRelease) => {
@@ -436,8 +469,11 @@ mod app {
 					// Is the board powered on? Don't do a reset if it's powered off.
 					if ctx.shared.state_dc_power_enabled.lock(|r| *r) == DcPowerState::On {
 						defmt::info!("Reset!");
-						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
+						// Step 1 - Stop any SPI stuff that's currently going on (the host is about to be reset)
 						ctx.shared.spi.lock(|s| s.reset(&mut rcc));
+						// Step 2 - Hold reset line (active) low
+						ctx.shared.pin_sys_reset.lock(|pin| pin.set_low().unwrap());
+						// Step 3 - Take it out of reset in a short while
 						// Returns an error if it's already scheduled (but we don't care)
 						let _ = exit_reset::spawn_after(RESET_DURATION_MS.millis());
 					}
@@ -466,7 +502,7 @@ mod app {
 							use proto::Receivable;
 							match proto::Request::from_bytes_with_crc(data, crc) {
 								Ok(inner_req) => {
-									defmt::debug!("Got packet");
+									defmt::trace!("Got packet");
 									req = Some(inner_req);
 								}
 								Err(proto::Error::BadLength) => {
@@ -708,7 +744,7 @@ where
 		// A duplicate! Resend what we sent last time (so we don't affect FIFOs with a duplicate read).
 		let length = req.length_or_data as usize;
 		let rsp = proto::Response::new_ok_with_data(&register_state.scratch[0..length]);
-		defmt::warn!("Retry");
+		defmt::debug!("Detected a retry");
 		rsp_handler(&rsp);
 		return;
 	}
@@ -776,11 +812,4 @@ where
 	// defmt::debug!("Sent {:?}", rsp);
 }
 
-// TODO: Pins we haven't used yet
-// SPI pins
-// spi_clk: gpioa.pa5.into_alternate_af0(cs),
-// spi_cipo: gpioa.pa6.into_alternate_af0(cs),
-// spi_copi: gpioa.pa7.into_alternate_af0(cs),
-// I²C pins
-// i2c_scl: gpiob.pb6.into_alternate_af4(cs),
-// i2c_sda: gpiob.pb7.into_alternate_af4(cs),
+// End of file

neotron-bmc-pico/src/spi.rs

@@ -67,11 +67,6 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 
 		// Enable the SPI device
 		spi.stop();
-		spi.dev.cr1.write(|w| {
-			// Enable the peripheral
-			w.spe().enabled();
-			w
-		});
 
 		spi
 	}
@@ -171,6 +166,7 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 		// Tell the SPI engine it has a chip-select
 		self.dev.cr1.modify(|_r, w| {
 			w.ssi().slave_selected();
+			w.spe().enabled();
 			w
 		});
 	}
@@ -179,11 +175,15 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 	pub fn stop(&mut self) {
 		self.dev.cr1.modify(|_r, w| {
 			w.ssi().slave_not_selected();
+			w.spe().disabled();
 			w
 		});
 	}
 
 	/// Fully reset the SPI peripheral
+	///
+	/// This is like calling [`Self::stop()`] but it reboots the IP block to clear any
+	/// partial words from the RX FIFO.
 	pub fn reset(&mut self, _rcc: &mut stm32f0xx_hal::rcc::Rcc) {
 		self.dev.cr1.write(|w| {
 			// Disable the peripheral
@@ -209,13 +209,8 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 			let _ = self.raw_read();
 		}
 
-		// Enable the SPI device and leave it idle
+		// Leave the SPI device turned off
 		self.stop();
-		self.dev.cr1.write(|w| {
-			// Enable the peripheral
-			w.spe().enabled();
-			w
-		});
 	}
 
 	/// Does the RX FIFO have any data in it?
@@ -293,31 +288,6 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 		}
 	}
 
-	/// Load some data into the TX buffer.
-	///
-	/// You get an error if you try to load too much.
-	pub fn set_transmit(&mut self, data: &[u8]) -> Result<(), usize> {
-		self.tx_ready = 0;
-		self.tx_idx = 0;
-		if data.len() > TXC {
-			// Too much data. This check is important for safety in
-			// [`Self::tx_isr`].
-			return Err(TXC);
-		}
-		for (inc, space) in data.iter().zip(self.tx_buffer.iter_mut()) {
-			*space = *inc;
-		}
-		// We must never set this to be longer than `TXC` as we do an unchecked
-		// read from `self.tx_buffer` in [`Self::tx_isr`].
-		self.tx_ready = data.len();
-		// Turn on the TX interrupt
-		self.dev.cr2.write(|w| {
-			w.txeie().not_masked();
-			w
-		});
-		Ok(())
-	}
-
 	/// Render some message into the TX buffer.
 	///
 	/// You get an error if you try to load too much.
@@ -328,11 +298,14 @@ impl<const RXC: usize, const TXC: usize> SpiPeripheral<RXC, TXC> {
 		self.tx_ready = 0;
 		self.tx_idx = 0;
 
-		match message.render_to_buffer(&mut self.tx_buffer) {
+		// SPI FIFO seems to corrupt the first byte we load. So load a dummy one
+		// we don't care about.
+		self.tx_buffer[0] = 0xFF;
+		match message.render_to_buffer(&mut self.tx_buffer[1..]) {
 			Ok(n) => {
 				// We must never set this to be longer than `TXC` as we do an
 				// unchecked read from `self.tx_buffer` in [`Self::tx_isr`].
-				self.tx_ready = n.min(TXC);
+				self.tx_ready = (n + 1).min(TXC);
 				// Turn on the TX interrupt
 				self.dev.cr2.write(|w| {
 					w.txeie().not_masked();