remove any gpio_pull_down in BP6 due to bug in rp2350. Cleanup for co…

…mpile.
DangerousPrototypes · Aug 26, 2024 · 3f4d9d0 · 3f4d9d0
1 parent d804b13
commit 3f4d9d0
Show file tree

Hide file tree

Showing 15 changed files with 34 additions and 23 deletions.
diff --git a/binmode/binmodes.c b/binmode/binmodes.c
@@ -44,7 +44,6 @@ const binmode_t binmodes[] = {
         .binmode_cleanup = falaio_cleanup,
     },
 };
-};
 
 inline void binmode_setup(void){
     if(binmodes[system_config.binmode_select].lock_terminal){

diff --git a/binmode/logicanalyzer.c b/binmode/logicanalyzer.c
@@ -167,7 +167,7 @@ void restart_dma() {
         dma_channel_configure(la_dma[i],
                               &la_dma_config,
                               (volatile uint8_t*)&la_buf[DMA_BYTES_PER_CHUNK * i],
-                              &pio->rxf[pio_config.sm],
+                              &pio_config.pio->rxf[pio_config.sm],
                               DMA_BYTES_PER_CHUNK,
                               false);
     }

diff --git a/commands/spi/sniff.c b/commands/spi/sniff.c
@@ -54,7 +54,7 @@ bool pio_read(uint32_t *raw){
         return false;
     }
     // 8-bit read from the uppermost byte of the FIFO, as data is left-justified
-    (*raw) = pio->rxf[pio_config.sm];
+    (*raw) = pio_config.pio->rxf[pio_config.sm];
     //TODO: change this based on UART settings
     //Detect parity error?
     return true;
@@ -65,7 +65,7 @@ bool pio_read_d1(uint32_t *raw){
         return false;
     }
     // 8-bit read from the uppermost byte of the FIFO, as data is left-justified
-    (*raw) = pio->rxf[pio_config_d1.sm];
+    (*raw) = pio_config_d1.pio->rxf[pio_config_d1.sm];
     //TODO: change this based on UART settings
     //Detect parity error?
     return true;
@@ -82,7 +82,7 @@ void sniff_handler(struct command_result *res){
     printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config.pio), pio_config.sm, pio_config.offset);
     spisnif_program_init(pio_config.pio, pio_config.sm, pio_config.offset, bio2bufiopin[BIO3], bio2bufiopin[BIO0], bio2bufiopin[BIO2]);
 
-    bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&spisnif_2_program, &pio_config_d1.pio, &pio_config_d1.sm, &pio_config_d1.offset, bio2bufiopin[BIO0], 3, true);
+    success = pio_claim_free_sm_and_add_program_for_gpio_range(&spisnif_2_program, &pio_config_d1.pio, &pio_config_d1.sm, &pio_config_d1.offset, bio2bufiopin[BIO0], 3, true);
     hard_assert(success);
     printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config_d1.pio), pio_config_d1.sm, pio_config_d1.offset);    
     spisnif_2_program_init(pio_config_d1.pio, pio_config_d1.sm, pio_config_d1.offset, bio2bufiopin[BIO3], bio2bufiopin[BIO1], bio2bufiopin[BIO2]);

diff --git a/lib/pico_ir_nec/nec_transmit.c b/lib/pico_ir_nec/nec_transmit.c
@@ -11,6 +11,7 @@
 #include "hardware/pio.h"
 #include "hardware/clocks.h"    // for clock_get_hz()
 #include "nec_transmit.h"
+#include "pirate.h"
 
 // import the assembled PIO state machine programs
 #include "nec_carrier_burst.pio.h"
@@ -44,7 +45,7 @@ int nec_tx_init(uint pin_num) {
                                    38.222e3);                   // 38.222 kHz carrier
 
     // install the carrier_control program in the PIO shared instruction space
-    bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&nec_carrier_control_program, &pio_config_control.pio, &pio_config_control.sm, &pio_config_control.offset, pin_num, 1, true);
+    success = pio_claim_free_sm_and_add_program_for_gpio_range(&nec_carrier_control_program, &pio_config_control.pio, &pio_config_control.sm, &pio_config_control.offset, pin_num, 1, true);
     hard_assert(success);
     if(!success) {
         return -1;

diff --git a/lib/picorvd/picoswio.c b/lib/picorvd/picoswio.c
@@ -70,7 +70,9 @@ void ch32vswio_reset(int pin, int dirpin) {
   // 125 mhz / 12 = 96 nanoseconds per tick, close enough to 100 ns.
   sm_config_set_clkdiv      (&c, 12);
 
-  //gpio_pull_down(pin);
+  #if BP_VER==5
+  gpio_pull_down(pin);
+  #endif
   pio_sm_set_pindirs_with_mask(pio_config.pio, pio_config.sm, 0, (1u<<pin)); //read pins to input (0, mask)  
   pio_sm_set_pindirs_with_mask(pio_config.pio, pio_config.sm, (1u<<dirpin), (1u<<dirpin)); //buf pins to output (pins, mask)    
   pio_sm_set_pins_with_mask(pio_config.pio, pio_config.sm, 0, (1u<<dirpin)); //buf dir to 0, buffer input/HiZ on the bus

diff --git a/mode/hw2wire.c b/mode/hw2wire.c
@@ -79,7 +79,7 @@ uint32_t hw2wire_setup(void){
 }
 
 uint32_t hw2wire_setup_exc(void){
-	pio_hw2wire_init(M_2WIRE_PIO, M_2WIRE_PIO_SM, bio2bufiopin[M_2WIRE_SDA], bio2bufiopin[M_2WIRE_SCL], bio2bufdirpin[M_2WIRE_SDA], bio2bufdirpin[M_2WIRE_SCL], hw2wire_mode_config.baudrate);
+	pio_hw2wire_init(bio2bufiopin[M_2WIRE_SDA], bio2bufiopin[M_2WIRE_SCL], bio2bufdirpin[M_2WIRE_SDA], bio2bufdirpin[M_2WIRE_SCL], hw2wire_mode_config.baudrate);
 	system_bio_claim(true, M_2WIRE_SDA, BP_PIN_MODE, pin_labels[0]);
 	system_bio_claim(true, M_2WIRE_SCL, BP_PIN_MODE, pin_labels[1]);
 	system_bio_claim(true, M_2WIRE_RST, BP_PIN_MODE, pin_labels[2]);

diff --git a/mode/hwi2c.c b/mode/hwi2c.c
@@ -77,7 +77,7 @@ uint32_t hwi2c_setup(void){
 }
 
 uint32_t hwi2c_setup_exc(void){
-	pio_i2c_init(pio, pio_state_machine, bio2bufiopin[M_I2C_SDA], bio2bufiopin[M_I2C_SCL], bio2bufdirpin[M_I2C_SDA], bio2bufdirpin[M_I2C_SCL], mode_config.baudrate);
+	pio_i2c_init(bio2bufiopin[M_I2C_SDA], bio2bufiopin[M_I2C_SCL], bio2bufdirpin[M_I2C_SDA], bio2bufdirpin[M_I2C_SCL], mode_config.baudrate);
 	system_bio_claim(true, M_I2C_SDA, BP_PIN_MODE, pin_labels[0]);
 	system_bio_claim(true, M_I2C_SCL, BP_PIN_MODE, pin_labels[1]);
 	mode_config.start_sent=false;

diff --git a/mode/hwled.c b/mode/hwled.c
@@ -108,11 +108,12 @@ uint32_t hwled_setup(void)
 }
 
 uint32_t hwled_setup_exc(void){
+	bool success;
 	switch(mode_config.device){
 		case M_LED_WS2812:
 			mode_config.baudrate=800000;
 			bio_buf_output(M_LED_SDO);
-			bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&ws2812_program, &pio_config.pio, &pio_config.sm, &pio_config.offset, bio2bufiopin[M_LED_SDO], 1, true);
+			success = pio_claim_free_sm_and_add_program_for_gpio_range(&ws2812_program, &pio_config.pio, &pio_config.sm, &pio_config.offset, bio2bufiopin[M_LED_SDO], 1, true);
 			hard_assert(success);
 			printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config.pio), pio_config.sm, pio_config.offset);
     		ws2812_program_init(pio_config.pio, pio_config.sm, pio_config.offset, bio2bufiopin[M_LED_SDO], (float)mode_config.baudrate, false);
@@ -122,7 +123,7 @@ uint32_t hwled_setup_exc(void){
 			mode_config.baudrate=(5 * 1000 * 1000);
 			bio_buf_output(M_LED_SDO);
 			bio_buf_output(M_LED_SCL);		
-			bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&apa102_mini_program, &pio_config.pio, &pio_config.sm, &pio_config.offset, bio2bufiopin[M_LED_SDO], 1, true);
+			success = pio_claim_free_sm_and_add_program_for_gpio_range(&apa102_mini_program, &pio_config.pio, &pio_config.sm, &pio_config.offset, bio2bufiopin[M_LED_SDO], 1, true);
 			hard_assert(success);
 			printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config.pio), pio_config.sm, pio_config.offset);
     		apa102_mini_program_init(pio_config.pio, pio_config.sm, pio_config.offset, mode_config.baudrate, bio2bufiopin[M_LED_SCL], bio2bufiopin[M_LED_SDO]);

diff --git a/pirate/hw1wire.pio b/pirate/hw1wire.pio
@@ -123,6 +123,7 @@ public waiting:
 
 
 % c-sdk {
+#include "pirate.h"
 
 /* Configure a PIO/sm for onewire */
 /* Note on pinctlz: GPIO pins have pulldown after reset. This enables
@@ -156,7 +157,9 @@ void onewire_program_init(
 
     gpio_init(pin);
     gpio_set_dir(pin, 0);
+    #if BP_VER==5
     gpio_pull_down(pin);
+    #endif
 
     gpio_init(dir);
     gpio_put(dir, 1);

diff --git a/pirate/hw2wire.pio b/pirate/hw2wire.pio
@@ -60,6 +60,7 @@ do_exec:
 % c-sdk {
 #include "hardware/clocks.h"
 #include "hardware/gpio.h"
+#include "pirate.h"
 
 static inline void hw2wire_program_init(PIO pio, uint sm, uint offset, uint pin_sda, uint pin_scl, uint buf_sda, uint buf_scl, uint32_t freq) {
     assert(pin_scl == pin_sda + 1); //wait uses pin ordered inputs, need to be consecutive
@@ -84,8 +85,10 @@ static inline void hw2wire_program_init(PIO pio, uint sm, uint offset, uint pin_
     // Try to avoid glitching the bus while connecting the IOs. Get things set
     // up so that pin is driven down when PIO asserts OE low, and pulled up
     // otherwise.
+    #if BP_VER==5
     gpio_pull_down(pin_scl); //we pull down so we can output 0 when the buffer is an output without manipulating the actual scl/sda pin directions
     gpio_pull_down(pin_sda);
+    #endif
 
     uint32_t pin_pins = (1u << pin_sda) | (1u << pin_scl);
     uint32_t buf_pins = (1u << buf_sda) | (1u << buf_scl);

diff --git a/pirate/hw2wire_pio.h b/pirate/hw2wire_pio.h
@@ -8,7 +8,7 @@
 
 #include "hw2wire.pio.h"
 
-void pio_hw2wire_init(PIO pio, uint sm, uint sda, uint scl, uint dir_sda, uint dir_scl, uint baudrate);
+void pio_hw2wire_init(uint sda, uint scl, uint dir_sda, uint dir_scl, uint baudrate);
 void pio_hw2wire_cleanup(void);
 
 void pio_hw2wire_put16(uint16_t data);

diff --git a/pirate/hwi2c.pio b/pirate/hwi2c.pio
@@ -75,7 +75,7 @@ do_exec:
 
 #include "hardware/clocks.h"
 #include "hardware/gpio.h"
-
+#include "pirate.h"
 
 static inline void i2c_program_init(PIO pio, uint sm, uint offset, uint pin_sda, uint pin_scl, uint buf_sda, uint buf_scl, uint32_t freq) {
     assert(pin_scl == pin_sda + 1); //wait uses pin ordered inputs, need to be consecutive
@@ -103,8 +103,10 @@ static inline void i2c_program_init(PIO pio, uint sm, uint offset, uint pin_sda,
     // Try to avoid glitching the bus while connecting the IOs. Get things set
     // up so that pin is driven down when PIO asserts OE low, and pulled up
     // otherwise.
+    #if BP_VER==5
     gpio_pull_down(pin_scl); //we pull down so we can output 0 when the buffer is an output without manipulating the actual scl/sda pin directions
     gpio_pull_down(pin_sda);
+    #endif
 
     uint32_t pin_pins = (1u << pin_sda) | (1u << pin_scl);
     uint32_t buf_pins = (1u << buf_sda) | (1u << buf_scl);

diff --git a/pirate/hwi2c_pio.c b/pirate/hwi2c_pio.c
@@ -3,9 +3,11 @@
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
-
-#include "pio_config.pio.h"
+#include "pico/stdlib.h"
+#include "pirate.h"
+#include "hardware/pio.h"
 #include "pio_config.h"
+#include "hwi2c_pio.h"
 
 static struct _pio_config pio_config;
 
@@ -14,10 +16,6 @@ const int PIO_I2C_FINAL_LSB  = 9;
 const int PIO_I2C_DATA_LSB   = 1;
 const int PIO_I2C_NAK_LSB    = 0;
 
-//static PIO pio_config.pio;
-//static uint pio_config.sm;
-//static uint pio_config.pio_loaded_offset;
-
 void pio_i2c_init(uint sda, uint scl, uint dir_sda, uint dir_scl, uint baudrate){
     bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&i2c_program, &pio_config.pio, &pio_config.sm, &pio_config.offset, dir_sda, 10, true);
     hard_assert(success);

diff --git a/pirate/hwuart.pio b/pirate/hwuart.pio
@@ -30,11 +30,13 @@ good_stop:              ; No delay before returning to start; a little slack is
 % c-sdk {
 #include "hardware/clocks.h"
 #include "hardware/gpio.h"
+#include "pirate.h"
 static inline void uart_rx_program_init(PIO pio, uint sm, uint offset, uint pin, uint bits, uint baud) {
     pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
     pio_gpio_init(pio, pin);
+    #if BP_VER==5
     gpio_pull_down(pin);
-
+    #endif
     pio_sm_config c = uart_rx_program_get_default_config(offset);
     sm_config_set_in_pins(&c, pin); // for WAIT, IN
     sm_config_set_jmp_pin(&c, pin); // for JMP

diff --git a/pirate/hwuart_pio.c b/pirate/hwuart_pio.c
@@ -44,7 +44,7 @@ void hwuart_pio_init(uint8_t data_bits, uint8_t parity, uint8_t stop_bits, uint3
     printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config_rx.pio), pio_config_rx.sm, pio_config_rx.offset);
     uart_rx_program_init(pio_config_rx.pio, pio_config_rx.sm, pio_config_rx.offset, bio2bufiopin[M_UART_RXTX], bits, baud);
 
-    bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&uart_tx_program, &pio_config_tx.pio, &pio_config_tx.sm, &pio_config_tx.offset, bio2bufiopin[M_UART_RXTX], 1, true);
+    success = pio_claim_free_sm_and_add_program_for_gpio_range(&uart_tx_program, &pio_config_tx.pio, &pio_config_tx.sm, &pio_config_tx.offset, bio2bufiopin[M_UART_RXTX], 1, true);
     hard_assert(success);
     printf("PIO: pio=%d, sm=%d, offset=%d\r\n", PIO_NUM(pio_config_tx.pio), pio_config_tx.sm, pio_config_tx.offset);
     uart_tx_program_init(pio_config_tx.pio, pio_config_tx.sm, pio_config_tx.offset, bio2bufdirpin[M_UART_RXTX], bits, baud);
@@ -57,11 +57,11 @@ void hwuart_pio_deinit(void){
 }
 
 bool hwuart_pio_read(uint32_t *raw, uint8_t *cooked){
-    if(pio_sm_is_rx_fifo_empty(pio_config_rx.pio, pio_config_rx.pio)){
+    if(pio_sm_is_rx_fifo_empty(pio_config_rx.pio, pio_config_rx.sm)){
         return false;
     }
     // 8-bit read from the uppermost byte of the FIFO, as data is left-justified
-    (*raw) = pio->rxf[pio_config_rx.sm];
+    (*raw) = pio_config_rx.pio->rxf[pio_config_rx.sm];
     //TODO: change this based on UART settings
     //Detect parity error?
     (*cooked) = (uint8_t)((*raw) >> 22); //MSB is the parity bit...