Added raw QSPI functionality for the Arduino Giga

libraries/QSPI/CMakeLists.txt

@@ -0,0 +1,5 @@
+zephyr_library()
+
+zephyr_library_sources(QSPI.cpp)
+
+zephyr_library_include_directories(.)

libraries/QSPI/QSPI.cpp

@@ -0,0 +1,132 @@
+#include "QSPI.h"
+
+// Define the QSPI flash device - will be available when overlay is active
+#if DT_NODE_EXISTS(DT_NODELABEL(qspi_flash))
+#define QSPI_FLASH_NODE DT_NODELABEL(qspi_flash)
+#define QSPI_FLASH_DEVICE DEVICE_DT_GET(QSPI_FLASH_NODE)
+#else
+#define QSPI_FLASH_DEVICE NULL
+#warning "No QSPI flash available on this board"
+#endif
+
+QSPIClass::QSPIClass() : flash_dev(nullptr), initialized(false) {
+}
+
+bool QSPIClass::begin() {
+    if (QSPI_FLASH_DEVICE == NULL) {
+        return false;
+    }
+
+    flash_dev = QSPI_FLASH_DEVICE;
+
+    if (!device_is_ready(flash_dev)) {
+        flash_dev = nullptr;
+        return false;
+    }
+
+    initialized = true;
+    return true;
+}
+
+bool QSPIClass::read(uint32_t address, void* data, size_t size) {
+    if (!initialized || !flash_dev) {
+        return false;
+    }
+
+    int ret = flash_read(flash_dev, address, data, size);
+    return (ret == 0);
+}
+
+bool QSPIClass::write(uint32_t address, const void* data, size_t size) {
+    if (!initialized || !flash_dev) {
+        return false;
+    }
+
+    int ret = flash_write(flash_dev, address, data, size);
+    return (ret == 0);
+}
+
+bool QSPIClass::erase(uint32_t address, size_t size) {
+    if (!initialized || !flash_dev) {
+        return false;
+    }
+
+    int ret = flash_erase(flash_dev, address, size);
+    return (ret == 0);
+}
+
+size_t QSPIClass::getFlashSize() {
+    if (!initialized || !flash_dev) {
+        return 0;
+    }
+
+    uint64_t size = 0;
+    int ret = flash_get_size(flash_dev, &size);
+    if (ret != 0) {
+        return 0;
+    }
+
+    return (size_t)size;
+}
+
+size_t QSPIClass::getSectorSize() {
+    if (!initialized || !flash_dev) {
+        return 0;
+    }
+
+    struct flash_pages_info page_info;
+    int ret = flash_get_page_info_by_offs(flash_dev, 0, &page_info);
+    if (ret != 0) {
+        return 0;
+    }
+
+    return page_info.size;
+}
+
+size_t QSPIClass::getPageSize() {
+    if (!initialized || !flash_dev) {
+        return 0;
+    }
+
+    const struct flash_parameters *flash_params = flash_get_parameters(flash_dev);
+    if (!flash_params) {
+        return 0;
+    }
+
+    return flash_params->write_block_size;
+}
+
+bool QSPIClass::isReady() {
+    if (!flash_dev) {
+        return false;
+    }
+
+    return device_is_ready(flash_dev);
+}
+
+uint32_t QSPIClass::getFlashID() {
+    // This would require implementing JEDEC ID reading
+    // For now, return 0 as placeholder
+    return 0;
+}
+
+bool QSPIClass::isValidAddress(uint32_t address, size_t size) {
+    if (!initialized || !flash_dev) {
+        return false;
+    }
+
+    size_t flash_size = getFlashSize();
+    return (address + size <= flash_size);
+}
+
+const struct device* QSPIClass::getDevice() {
+    return flash_dev;
+}
+
+void QSPIClass::end() {
+    flash_dev = nullptr;
+    initialized = false;
+}
+
+// Create global instance
+QSPIClass QSPI;

libraries/QSPI/QSPI.h

@@ -0,0 +1,54 @@
+#ifndef QSPI_H
+#define QSPI_H
+
+#include <Arduino.h>
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/drivers/flash.h>
+#include <zephyr/devicetree.h>
+
+class QSPIClass {
+
+public:
+    QSPIClass();
+
+    // Initialize QSPI flash
+    bool begin();
+
+    // Read data from QSPI flash
+    bool read(uint32_t address, void* data, size_t size);
+
+    // Write data to QSPI flash
+    bool write(uint32_t address, const void* data, size_t size);
+
+    // Erase sector/block
+    bool erase(uint32_t address, size_t size);
+
+    // Get flash information
+    size_t getFlashSize();
+    size_t getSectorSize();
+    size_t getPageSize();
+
+    // Check if flash is ready
+    bool isReady();
+
+    // Get flash ID
+    uint32_t getFlashID();
+
+    // Utility functions
+    bool isValidAddress(uint32_t address, size_t size = 1);
+
+    // Get the underlying Zephyr device (for filesystem/advanced usage)
+    const struct device* getDevice();
+
+    // End/deinitialize
+    void end();
+
+private:
+    const struct device *flash_dev;
+    bool initialized;
+};
+
+extern QSPIClass QSPI;
+
+#endif

libraries/QSPI/examples/BasicQSPI.ino

@@ -0,0 +1,101 @@
+/*
+  Basic QSPI Flash Example
+
+  This example demonstrates how to use the QSPI library to read and write
+  data to external QSPI flash memory on Arduino boards with QSPI support.
+
+  Note: QSPI flash must be configured in the board's device tree overlay.
+*/
+
+#include <QSPI.h>
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) {
+    delay(10);
+  }
+
+  Serial.println("QSPI Flash Test");
+
+  // Initialize QSPI flash
+  if (!QSPI.begin()) {
+    Serial.println("Failed to initialize QSPI flash!");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  Serial.println("QSPI flash initialized successfully");
+
+  // Get flash information
+  Serial.print("Flash size: ");
+  Serial.print(QSPI.getFlashSize());
+  Serial.println(" bytes");
+
+  Serial.print("Sector size: ");
+  Serial.print(QSPI.getSectorSize());
+  Serial.println(" bytes");
+
+  Serial.print("Page size: ");
+  Serial.print(QSPI.getPageSize());
+  Serial.println(" bytes");
+
+  // Test write and read
+  testWriteRead();
+}
+
+void loop() {
+  // Nothing to do in loop
+  delay(5000);
+
+  Serial.println("Running periodic test...");
+  testWriteRead();
+}
+
+void testWriteRead() {
+  const uint32_t test_address = 0x1000;  // Test address (4KB offset)
+  const char test_data[] = "Hello QSPI Flash!";
+  char read_buffer[32];
+
+  Serial.println("\n--- Testing Write/Read ---");
+
+  // Erase sector first
+  Serial.print("Erasing sector at 0x");
+  Serial.print(test_address, HEX);
+  Serial.print("... ");
+
+  if (QSPI.erase(test_address, QSPI.getSectorSize())) {
+    Serial.println("OK");
+  } else {
+    Serial.println("FAILED");
+    return;
+  }
+
+  // Write test data
+  Serial.print("Writing data... ");
+  if (QSPI.write(test_address, test_data, strlen(test_data) + 1)) {
+    Serial.println("OK");
+  } else {
+    Serial.println("FAILED");
+    return;
+  }
+
+  // Read back data
+  Serial.print("Reading data... ");
+  memset(read_buffer, 0, sizeof(read_buffer));
+  if (QSPI.read(test_address, read_buffer, sizeof(read_buffer))) {
+    Serial.println("OK");
+
+    Serial.print("Read data: ");
+    Serial.println(read_buffer);
+
+    // Verify data
+    if (strcmp(test_data, read_buffer) == 0) {
+      Serial.println("Data verification: PASSED");
+    } else {
+      Serial.println("Data verification: FAILED");
+    }
+  } else {
+    Serial.println("FAILED");
+  }
+}