xxx more working but stil broken, dumb coexistence

Author: ArcaneNibble

lib/pbio/drv/adc/adc_ev3.c

@@ -9,8 +9,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "../core.h"
-
 #include <pbdrv/adc.h>
 #include <pbdrv/clock.h>
 #include <pbdrv/gpio.h>
@@ -30,6 +28,8 @@
 #include "../drv/block_device/block_device_ev3.h"
 #include "../drv/gpio/gpio_ev3.h"
 
+#include "../sys/storage.h"
+
 #define PBDRV_CONFIG_ADC_EV3_NUM_DELAY_SAMPLES (2)
 
 /**
@@ -85,6 +85,9 @@ static const uint32_t channel_cmd[PBDRV_CONFIG_ADC_EV3_ADC_NUM_CHANNELS + PBDRV_
 static volatile uint16_t channel_data[PBDRV_CONFIG_ADC_EV3_ADC_NUM_CHANNELS + PBDRV_CONFIG_ADC_EV3_NUM_DELAY_SAMPLES];
 
 static int adc_soon;
+// Used to block ADC from interfering with flash upon shutdown
+static int shut_down_hack = 0;
+static int shut_down_hack_done = 0;
 
 static pbdrv_adc_callback_t pbdrv_adc_callbacks[1];
 static uint32_t pbdrv_adc_callback_count = 0;
@@ -121,16 +124,21 @@ pbio_error_t pbdrv_adc_ev3_process_thread(pbio_os_state_t *state, void *context)
 
     PBIO_OS_ASYNC_BEGIN(state);
 
-    PBIO_OS_AWAIT_UNTIL(state, pbdrv_block_device_ev3_init_is_done());
+    // HACK: This waits until storage is completely done with SPI flash before we start
+    PBIO_OS_AWAIT_UNTIL(state, pbsys_storage_settings_get_settings());
 
     // Once SPI flash init is finished, there is nothing further for us to do.
     // We are ready to start sampling.
-    pbdrv_init_busy_down();
 
     pbio_os_timer_set(&timer, ADC_SAMPLE_PERIOD);
 
     for (;;) {
-        PBIO_OS_AWAIT_UNTIL(state, adc_soon || pbio_os_timer_is_expired(&timer));
+        PBIO_OS_AWAIT_UNTIL(state, shut_down_hack || adc_soon || pbio_os_timer_is_expired(&timer));
+
+        if (shut_down_hack) {
+            shut_down_hack_done = 1;
+            break;
+        }
 
         if (adc_soon) {
             adc_soon = 0;
@@ -156,8 +164,9 @@ pbio_error_t pbdrv_adc_ev3_process_thread(pbio_os_state_t *state, void *context)
 }
 
 void pbdrv_adc_init(void) {
-    // Immediately go into async mode so that we can wait for the SPI flash driver
-    pbdrv_init_busy_up();
+    // Immediately go into async mode so that we can wait for the SPI flash driver.
+    // We *don't* want to block the initial init phase, or else things will deadlock.
+
     pbio_os_process_start(&pbdrv_adc_ev3_process, pbdrv_adc_ev3_process_thread, NULL);
 }
 
@@ -175,4 +184,12 @@ void pbdrv_adc_ev3_configure_data_format() {
     SPICharLengthSet(SOC_SPI_0_REGS, 16, SPI_DATA_FORMAT1);
 }
 
+void pbdrv_adc_ev3_shut_down_hack() {
+    shut_down_hack = 1;
+    pbio_os_request_poll();
+}
+int pbdrv_adc_ev3_is_shut_down_hack() {
+    return shut_down_hack_done;
+}
+
 #endif // PBDRV_CONFIG_ADC_EV3

lib/pbio/drv/block_device/block_device_ev3.c

@@ -65,9 +65,6 @@ static struct {
     /** HAL Transfer status */
     volatile spi_status_t spi_status;
 
-    // Used to sequence startup with ADC.
-    int init_done;
-
     // This is used when SPI only needs to receive. It should always stay as 0.
     uint8_t tx_dummy_byte;
     // This is used when received data is to be discarded. Its value should be ignored.
@@ -536,7 +533,6 @@ pbio_error_t pbdrv_block_device_read(pbio_os_state_t *state, uint32_t offset, ui
 
         // Set address for this read request and send it.
         set_address_be(&read_address[1], PBDRV_CONFIG_BLOCK_DEVICE_EV3_START_ADDRESS + offset + size_done);
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(read_address, sizeof(read_address), 0, buffer + size_done, size_now);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -557,7 +553,6 @@ static pbio_error_t flash_wait_write(pbio_os_state_t *state) {
     PBIO_OS_ASYNC_BEGIN(state);
 
     do {
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(cmd_status, sizeof(cmd_status), 0, 0, 0);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -585,10 +580,16 @@ pbio_error_t pbdrv_block_device_store(pbio_os_state_t *state, uint8_t *buffer, u
         return PBIO_ERROR_INVALID_ARG;
     }
 
+#if PBDRV_CONFIG_ADC_EV3
+    // HACK
+    // We only store on shutdown. Block ADC.
+    pbdrv_adc_ev3_shut_down_hack();
+    PBIO_OS_AWAIT_UNTIL(state, pbdrv_adc_ev3_is_shut_down_hack());
+#endif
+
     // Erase sector by sector.
     for (offset = 0; offset < size; offset += FLASH_SIZE_ERASE) {
         // Enable writing
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(cmd_write_enable, sizeof(cmd_write_enable), 0, 0, 0);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -597,7 +598,6 @@ pbio_error_t pbdrv_block_device_store(pbio_os_state_t *state, uint8_t *buffer, u
 
         // Erase this block
         set_address_be(&erase_address[1], PBDRV_CONFIG_BLOCK_DEVICE_EV3_START_ADDRESS + offset);
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(erase_address, sizeof(erase_address), 0, 0, 0);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -616,7 +616,6 @@ pbio_error_t pbdrv_block_device_store(pbio_os_state_t *state, uint8_t *buffer, u
         size_now = pbio_int_math_min(size - size_done, FLASH_SIZE_WRITE);
 
         // Enable writing
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(cmd_write_enable, sizeof(cmd_write_enable), 0, 0, 0);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -625,7 +624,6 @@ pbio_error_t pbdrv_block_device_store(pbio_os_state_t *state, uint8_t *buffer, u
 
         // Write this block
         set_address_be(&write_address[1], PBDRV_CONFIG_BLOCK_DEVICE_EV3_START_ADDRESS + size_done);
-        PBIO_OS_AWAIT_WHILE(state, bdev.spi_status & SPI_STATUS_WAIT_ANY);
         err = spi_begin_for_flash(write_address, sizeof(write_address), buffer + size_done, 0, size_now);
         if (err != PBIO_SUCCESS) {
             return err;
@@ -663,8 +661,6 @@ pbio_error_t pbdrv_block_device_ev3_init_process_thread(pbio_os_state_t *state,
 
     // Initialization done.
     pbdrv_init_busy_down();
-    bdev.init_done = 1;
-    pbio_os_request_poll();
 
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
@@ -720,11 +716,6 @@ void pbdrv_block_device_init(void) {
     pbio_os_process_start(&pbdrv_block_device_ev3_init_process, pbdrv_block_device_ev3_init_process_thread, NULL);
 }
 
-// ADC glue functions
-int pbdrv_block_device_ev3_init_is_done() {
-    return bdev.init_done;
-}
-
 int pbdrv_block_device_ev3_is_busy() {
     return bdev.spi_status & SPI_STATUS_WAIT_ANY;
 }

lib/pbio/drv/block_device/block_device_ev3.h

@@ -16,7 +16,6 @@ void pbdrv_block_device_ev3_spi_rx_complete();
 // these two drivers have tight dependencies on each other.
 // These functions orchestrate the connection.
 
-int pbdrv_block_device_ev3_init_is_done();
 int pbdrv_block_device_ev3_is_busy();
 pbio_error_t pbdrv_block_device_ev3_spi_begin_for_adc(const uint32_t *cmds, volatile uint16_t *data, unsigned int len);