Merge pull request arduino#82 from bcmi-labs/bd_default

QSPI flash default partitioning proposal

Author: facchinm

libraries/SSLClient/examples/CertificateUploader/CertificateUploader.ino

@@ -1,9 +1,20 @@
-#include "QSPIFlashBlockDevice.h"
+/*
+  Portenta C33 - Certificate uploader
+
+  The sketch uploads and saves network certificates on the system
+  partition of the QSPI flash
+
+  This example code is in the public domain.
+*/
+
+#include "BlockDevice.h"
+#include "MBRBlockDevice.h"
 #include "FATFileSystem.h"
 #include "certificates.h"
 
-QSPIFlashBlockDevice root(PIN_QSPI_CLK, PIN_QSPI_SS, PIN_QSPI_D0, PIN_QSPI_D1, PIN_QSPI_D2, PIN_QSPI_D3);
-FATFileSystem root_fs("wlan");
+BlockDevice* root = BlockDevice::get_default_instance();
+MBRBlockDevice sys_bd(root, 1);
+FATFileSystem sys_fs("sys");
 
 long getFileSize(FILE *fp) {
     fseek(fp, 0, SEEK_END);
@@ -32,33 +43,33 @@ void setup() {
   Serial.begin(115200);
   while (!Serial);
 
-  int err =  root_fs.mount(&root);
+  int err =  sys_fs.mount(&sys_bd);
   if (err) {
     // Reformat if we can't mount the filesystem
     // this should only happen on the first boot
     Serial.println("No filesystem containing the WiFi firmware was found.");
     Serial.println("Usually that means that the WiFi firmware has not been installed yet"
                   " or was overwritten with another firmware.\n");
     Serial.println("Formatting the filsystem to install the firmware and certificates...\n");
-    err = root_fs.reformat(&root);
+    err = sys_fs.reformat(&sys_bd);
   }
 
   DIR *dir;
   struct dirent *ent;
 
-  if ((dir = opendir("/wlan")) != NULL) {
+  if ((dir = opendir("/sys")) != NULL) {
     /* print all the files and directories within directory */
     while ((ent = readdir (dir)) != NULL) {
       Serial.println("Searching for WiFi firmware file " + String(ent->d_name) + " ...");
-      String fullname = "/wlan/" + String(ent->d_name);
-      if (fullname == "/wlan/cacert.pem") {
+      String fullname = "/sys/" + String(ent->d_name);
+      if (fullname == "/sys/cacert.pem") {
         Serial.println("A WiFi firmware is already installed. "
                        "Do you want to install the firmware anyway? Y/[n]");
         while (1) {
           if (Serial.available()) {
             int c = Serial.read();
             if (c == 'Y' || c == 'y') {
-              root_fs.reformat(&root);
+              sys_fs.reformat(&sys_bd);
               break;
             }
             if (c == 'N' || c == 'n') {
@@ -76,7 +87,7 @@ void setup() {
 
   int chunck_size = 128;
   int byte_count = 0;
-  FILE* fp = fopen("/wlan/cacert.pem", "wb");
+  FILE* fp = fopen("/sys/cacert.pem", "wb");
 
   Serial.println("Flashing certificates");
   printProgress(byte_count, cacert_pem_len, 10, true);
@@ -93,7 +104,7 @@ void setup() {
   }
   fclose(fp);
 
-  fp = fopen("/wlan/cacert.pem", "rb");
+  fp = fopen("/sys/cacert.pem", "rb");
   char buffer[128];
   int ret = fread(buffer, 1, 128, fp);
   Serial.write(buffer, ret);

libraries/Storage/examples/FatFsOnQSPIFlash/FatFsOnQSPIFlash.ino

@@ -15,6 +15,8 @@
 #include <vector>
 #include <string>
 #include "QSPIFlashBlockDevice.h"
+#include <BlockDevice.h>
+#include <MBRBlockDevice.h>
 #include "FATFileSystem.h"
 
 #define TEST_FS_NAME "qspi"
@@ -23,7 +25,8 @@
 #define DELETE_FILE_DIMENSION 150
 
 
-QSPIFlashBlockDevice block_device(PIN_QSPI_CLK, PIN_QSPI_SS, PIN_QSPI_D0, PIN_QSPI_D1, PIN_QSPI_D2, PIN_QSPI_D3); 
+BlockDevice* block_device = BlockDevice::get_default_instance();
+MBRBlockDevice mbr(block_device, 2);
 FATFileSystem fs(TEST_FS_NAME);
 
 std::string root_folder       = std::string("/") + std::string(TEST_FS_NAME);
@@ -51,12 +54,12 @@ void setup() {
    */
 
   Serial.println("Mounting QSPI FLASH...");
-  int err =  fs.mount(&block_device);
+  int err =  fs.mount(&mbr);
   if (err) {
     // Reformat if we can't mount the filesystem
     // this should only happen on the first boot
     Serial.println("No filesystem found, formatting... ");
-    err = fs.reformat(&block_device);
+    err = fs.reformat(&mbr);
   }
 
   if (err) {

libraries/Storage/examples/QSPIFReadPartitions/QSPIFReadPartitions.ino

@@ -0,0 +1,136 @@
+/*
+  Portenta C33 - QSPI Read partitions
+
+  The sketch reads the partition table of QSPI flash and prints the
+  results on the  serial monitor
+
+  This example code is in the public domain.
+*/
+
+#include <BlockDevice.h>
+
+struct __attribute__((packed)) mbrEntry {
+    uint8_t status;
+    uint8_t chsStart[3];
+    uint8_t type;
+    uint8_t chsStop[3];
+    uint32_t lbaOffset;
+    uint32_t lbaSize;
+};
+
+struct __attribute__((packed)) mbrTable {
+    mbrEntry entries[4];
+    uint8_t signature[2];
+};
+
+unsigned long allocatedSpace {};
+
+void setup()
+{
+    Serial.begin(9600);
+    for (const auto timeout = millis() + 2500; !Serial && millis() < timeout; delay(250))
+        ;
+
+    auto bd = BlockDevice::get_default_instance();
+    auto ret = bd->init();
+    if (ret) {
+        Serial.println("ERROR! Unable to read the Block Device.");
+        while (true)
+            ;
+    }
+
+    // Allocate smallest buffer necessary to write MBR
+    auto buffer_size = std::max<uint32_t>(bd->get_program_size(), sizeof(mbrTable));
+
+    // Prevent alignment issues
+    if (buffer_size % bd->get_program_size() != 0) {
+        buffer_size += bd->get_program_size() - (buffer_size % bd->get_program_size());
+    }
+
+    auto buffer = new uint8_t[buffer_size];
+
+    // Check for existing MBR
+    ret = bd->read(buffer, 512 - buffer_size, buffer_size);
+    if (ret) {
+        Serial.println("ERROR! Unable to read the Master Boot Record");
+
+        delete[] buffer;
+        while (true)
+            ;
+    }
+
+    auto table_start_offset = buffer_size - sizeof(mbrTable);
+    auto table = reinterpret_cast<mbrTable*>(&buffer[table_start_offset]);
+
+    Serial.println();
+    Serial.print("Looking for Partitions on the Flash Memory... ");
+
+    if (table->signature[0] != 0x55 || table->signature[1] != 0xAA) {
+        Serial.println("MBR Not Found");
+        Serial.println("Flash Memory doesn't have partitions.");
+    } else {
+
+        Serial.println("MBR Found");
+        Serial.print("Boot Signature: 0x");
+        Serial.print(table->signature[0], HEX);
+        Serial.println(table->signature[1], HEX);
+
+        Serial.println();
+        Serial.println("Printing Partitions Table and Info...");
+
+        auto part { 1u };
+        for (auto const& entry : table->entries) {
+            Serial.println("================================");
+            Serial.print("Partition: ");
+            Serial.println(part++);
+
+            Serial.print("Bootable: ");
+            Serial.println(entry.status == 0 ? "No" : "Yes");
+
+            Serial.print("Type: 0x");
+            if (entry.type < 0x10)
+                Serial.print(0);
+            Serial.println(entry.type, HEX);
+
+            if (entry.type == 0x00)
+                continue;
+
+            Serial.print("Size [KBytes]: ");
+            Serial.println((entry.lbaSize * 4096) >> 10);
+
+            allocatedSpace += entry.lbaSize * 4096;
+
+            Serial.print("Start [C/H/S]: ");
+            Serial.print(entry.chsStart[0]);
+            Serial.print("/");
+            Serial.print(entry.chsStart[1]);
+            Serial.print("/");
+            Serial.println(entry.chsStart[2]);
+
+            Serial.print("Stop [C/H/S]: ");
+            Serial.print(entry.chsStop[0]);
+            Serial.print("/");
+            Serial.print(entry.chsStop[1]);
+            Serial.print("/");
+            Serial.println(entry.chsStop[2]);
+
+            Serial.println();
+        }
+
+        Serial.println();
+        Serial.println("No more partitions are present.");
+    }
+
+    Serial.println();
+    Serial.print("Total Space [KBytes]:         ");
+    Serial.println(bd->size() >> 10);
+    Serial.print("Allocated Space [KBytes]:     ");
+    Serial.println(allocatedSpace >> 10);
+    Serial.print("Unallocated Space [KBytes]:   ");
+    Serial.println((bd->size() - allocatedSpace) >> 10);
+}
+
+void loop()
+{
+    delay(10000);
+}

libraries/Storage/examples/QSPIFormat/QSPIFormat.ino

@@ -0,0 +1,87 @@
+/*
+  Portenta C33 - QSPI Flash format
+
+  The sketch formats the board QSPI flash as follow:
+
+  * Partition 1  5MB: used for network certificates and OTA
+  * Partition 2 11MB: general purpose
+
+  This example code is in the public domain.
+*/
+
+#include "BlockDevice.h"
+#include "MBRBlockDevice.h"
+#include "LittleFileSystem.h"
+#include "FATFileSystem.h"
+
+BlockDevice* root = BlockDevice::get_default_instance();
+MBRBlockDevice sys_bd(root, 1);
+MBRBlockDevice user_bd(root, 2);
+FATFileSystem sys_fs("sys");
+FileSystem * user_data_fs;
+
+bool waitResponse() {
+  bool confirmation = false;
+  while (confirmation == false) {
+    if (Serial.available()) {
+      char choice = Serial.read();
+      switch (choice) {
+        case 'y':
+        case 'Y':
+          confirmation = true;
+          return true;
+          break;
+        case 'n':
+        case 'N':
+          confirmation = true;
+          return false;
+          break;
+        default:
+          continue;
+      }
+    }
+  }
+}
+
+void setup() {
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  Serial.println("\nWARNING! Running the sketch all the content of the QSPI flash will be erased.");
+  Serial.println("Do you want to proceed? Y/[n]");
+
+  if (true == waitResponse()) {
+    MBRBlockDevice::partition(root, 1, 0x0B, 0, 5 * 1024 * 1024);
+    MBRBlockDevice::partition(root, 2, 0x0B, 5 * 1024 * 1024, 16 * 1024 * 1024);
+
+    int err = sys_fs.reformat(&sys_bd);
+    if (err) {
+      Serial.println("Error formatting sys partition");
+    }
+
+    Serial.println("\nDo you want to use LittleFS to format user data partition? Y/[n]");
+    Serial.println("If No, FatFS will be used to format user partition.");
+
+    if (true == waitResponse()) {
+      Serial.println("Formatting user partition with LittleFS.");
+      user_data_fs = new LittleFileSystem("user");
+    } else {
+      Serial.println("Formatting user partition with FatFS.");
+      user_data_fs = new FATFileSystem("user");
+    }
+
+    err = user_data_fs->reformat(&user_bd);
+    if (err) {
+      Serial.println("Error formatting user partition");
+    }
+
+    Serial.println("\nQSPI Flash formatted!");
+  }
+
+  Serial.println("It's now safe to reboot or disconnect your board.");
+}
+
+void loop() {
+
+}