Added SCI-SPI support for SD card.

Also added devices unmounting.

Author: DC-SWAT

fatfs/src/dc.c

@@ -1232,6 +1232,11 @@ int fs_fat_shutdown(void) {
     if (!initted) {
         return 0;
     }
+
+    /* Clean up SD and IDE resources */
+    fs_fat_unmount_sd();
+    fs_fat_unmount_ide();
+
     for (i = 0; i < MAX_FAT_MOUNTS; ++i) {
 
         if (fat_mnt[i].dev != NULL) {

fatfs/src/dc_bdev.c

@@ -30,6 +30,7 @@
 #include <stdio.h>
 #include <errno.h>
 #include <stdint.h>
+#include <stdbool.h>
 #include <string.h>
 #include <stdlib.h>
 #include <inttypes.h>
@@ -107,91 +108,131 @@ static int sd_blockdev_for_device(kos_blockdev_t *rv) {
     return 0;
 }
 
-int fs_fat_mount_sd() {
-
+static bool mount_sd_card(uint8_t *mbr_buf) {
     uint8_t partition_type;
     int part = 0, fat_part = 0;
     char path[8];
-    uint8_t buf[512];
     kos_blockdev_t *dev;
+    const char *prefix = "/sd";
 
-    dbglog(DBG_INFO, "Checking for SD card...\n");
-
-    if (sd_init()) {
-        scif_init();
-        dbglog(DBG_INFO, "\nSD card not found.\n");
-        return -1;
-    }
-
-    dbglog(DBG_INFO, "SD card initialized, capacity %" PRIu32 " MB\n",
-        (uint32)(sd_get_size() / 1024 / 1024));
+    if (sd_dev == NULL) {
+        sd_dev = malloc(sizeof(kos_blockdev_t) * MAX_PARTITIONS);
 
-    if (sd_read_blocks(0, 1, buf)) {
-        dbglog(DBG_ERROR, "Can't read MBR from SD card\n");
-        return -1;
-    }
+        if (sd_dev == NULL) {
+            dbglog(DBG_ERROR, "FATFS: Can't allocate memory for SD card partitions\n");
+            return false;
+        }
 
-    if (!sd_dev) {
-        sd_dev = malloc(sizeof(kos_blockdev_t) * MAX_PARTITIONS);
+        memset(sd_dev, 0, sizeof(kos_blockdev_t) * MAX_PARTITIONS);
     }
-    if (!sd_dev) {
-        dbglog(DBG_ERROR, "Can't allocate memory for SD card partitions\n");
-        return -1;
-    }
-
-    memset(&sd_dev[0], 0, sizeof(kos_blockdev_t) * MAX_PARTITIONS);
 
     for (part = 0; part < MAX_PARTITIONS; part++) {
-
         dev = &sd_dev[part];
-
-        if (check_partition(buf, part)) {
+        
+        if (check_partition(mbr_buf, part)) {
             continue;
         }
         if (sd_blockdev_for_partition(part, dev, &partition_type)) {
             continue;
         }
-
-        if (!part) {
-            strcpy(path, "/sd");
-            path[3] = '\0';
+        
+        if (part == 0) {
+            strcpy(path, prefix);
         }
         else {
-            sprintf(path, "sd%d", part);
+            sprintf(path, "%s%d", prefix, part);
         }
 
         /* Check to see if the MBR says that we have a FAT partition. */
         fat_part = is_fat_partition(partition_type);
 
         if (fat_part) {
 
-            dbglog(DBG_INFO, "Detected FAT%d filesystem on partition %d\n", fat_part, part);
-
+            dbglog(DBG_INFO, "FATFS: Detected FAT%d on partition %d\n", fat_part, part);
+            
             if (fs_fat_init()) {
-                dbglog(DBG_INFO, "Could not initialize fs_fat!\n");
+                dbglog(DBG_INFO, "FATFS: Could not initialize fatfs!\n");
                 dev->shutdown(dev);
             }
             else {
                 /* Need full disk block device for FAT */
                 dev->shutdown(dev);
+
                 if (sd_blockdev_for_device(dev)) {
                     continue;
                 }
 
-                dbglog(DBG_INFO, "Mounting filesystem...\n");
+                dbglog(DBG_INFO, "FATFS: Mounting filesystem to %s...\n", path);
 
                 if (fs_fat_mount(path, dev, NULL, part)) {
-                    dbglog(DBG_INFO, "Could not mount device as fatfs.\n");
+                    dbglog(DBG_INFO, "FATFS: Could not mount device as fatfs.\n");
                     dev->shutdown(dev);
                 }
+                else {
+                    return true;
+                }
             }
         }
         else {
-            dbglog(DBG_INFO, "Unknown filesystem: 0x%02x\n", partition_type);
+            dbglog(DBG_INFO, "FATFS: Unknown filesystem: 0x%02x\n", partition_type);
             dev->shutdown(dev);
         }
     }
-    return 0;
+
+    return false;
+}
+
+int fs_fat_mount_sd() {
+    uint8_t mbr_buffer[512];
+    sd_init_params_t params;
+
+    dbglog(DBG_INFO, "FATFS: Checking for SD cards...\n");
+
+    /* Try SCIF interface first */
+    params.interface = SD_IF_SCIF;
+#ifdef FATFS_SD_CHECK_CRC
+    params.check_crc = true;
+#else
+    params.check_crc = false;
+#endif
+
+    memset(mbr_buffer, 0, sizeof(mbr_buffer));
+
+    if (sd_init_ex(&params) == 0) {
+        dbglog(DBG_INFO, "FATFS: SD card found on SCIF-SPI: %"PRIu32" MB\n",
+            (uint32)(sd_get_size() / 1024 / 1024));
+            
+        if (sd_read_blocks(0, 1, mbr_buffer) == 0) {
+            if (mount_sd_card(mbr_buffer)) {
+                return 0;
+            }
+        }
+        else {
+            dbglog(DBG_ERROR, "FATFS: Can't read MBR from SCIF-SPI SD card\n");
+        }
+    }
+
+    /* Get back dbglog if they are used */
+    scif_init();
+
+    /* If no card found on SCIF, try SCI interface */
+    params.interface = SD_IF_SCI;
+
+    if (sd_init_ex(&params) == 0) {
+        dbglog(DBG_INFO, "FATFS: SD card found on SCI-SPI: %"PRIu32" MB\n",
+            (uint32)(sd_get_size() / 1024 / 1024));
+
+        if (sd_read_blocks(0, 1, mbr_buffer) == 0) {
+            if (mount_sd_card(mbr_buffer)) {
+                return 0;
+            }
+        }
+        else {
+            dbglog(DBG_ERROR, "FATFS: Can't read MBR from SCI-SPI SD card\n");
+        }
+    }
+    /* No cards found on any interface */
+    return -1;
 }
 
 int fs_fat_mount_ide() {
@@ -203,7 +244,7 @@ int fs_fat_mount_ide() {
     kos_blockdev_t *dev;
     kos_blockdev_t *dev_dma;
 
-    dbglog(DBG_INFO, "Checking for G1 ATA devices...\n");
+    dbglog(DBG_INFO, "FATFS: Checking for G1 ATA devices...\n");
 
     if (g1_ata_init()) {
         return -1;
@@ -212,13 +253,13 @@ int fs_fat_mount_ide() {
     /* Read the MBR from the disk */
     if (g1_ata_lba_mode()) {
         if (g1_ata_read_lba(0, 1, (uint16_t *)buf) < 0) {
-            dbglog(DBG_ERROR, "Can't read MBR from IDE by LBA\n");
+            dbglog(DBG_ERROR, "FATFS: Can't read MBR from IDE by LBA\n");
             return -1;
         }
     }
     else {
         if (g1_ata_read_chs(0, 0, 1, 1, (uint16_t *)buf) < 0) {
-            dbglog(DBG_ERROR, "Can't read MBR from IDE by CHS\n");
+            dbglog(DBG_ERROR, "FATFS: Can't read MBR from IDE by CHS\n");
             return -1;
         }
     }
@@ -228,7 +269,7 @@ int fs_fat_mount_ide() {
         g1_dev_dma = malloc(sizeof(kos_blockdev_t) * MAX_PARTITIONS);
     }
     if (!g1_dev || !g1_dev_dma) {
-        dbglog(DBG_ERROR, "Can't allocate memory for IDE partitions\n");
+        dbglog(DBG_ERROR, "FATFS: Can't allocate memory for IDE partitions\n");
         return -1;
     }
 
@@ -261,10 +302,10 @@ int fs_fat_mount_ide() {
 
         if (fat_part) {
 
-            dbglog(DBG_INFO, "Detected FAT%d filesystem on partition %d\n", fat_part, part);
+            dbglog(DBG_INFO, "FATFS: Detected FAT%d on partition %d\n", fat_part, part);
 
             if (fs_fat_init()) {
-                dbglog(DBG_INFO, "Could not initialize fs_fat!\n");
+                dbglog(DBG_INFO, "FATFS: Could not initialize fs_fat!\n");
                 dev->shutdown(dev);
             }
             else {
@@ -279,10 +320,10 @@ int fs_fat_mount_ide() {
                     dev_dma = NULL;
                 }
 
-                dbglog(DBG_INFO, "Mounting filesystem...\n");
+                dbglog(DBG_INFO, "FATFS: Mounting filesystem to %s...\n", path);
 
                 if (fs_fat_mount(path, dev, dev_dma, part)) {
-                    dbglog(DBG_INFO, "Could not mount device as fatfs.\n");
+                    dbglog(DBG_INFO, "FATFS: Could not mount device as fatfs.\n");
                     dev->shutdown(dev);
                     if (dev_dma) {
                         dev_dma->shutdown(dev_dma);
@@ -291,9 +332,61 @@ int fs_fat_mount_ide() {
             }
         }
         else {
-            dbglog(DBG_INFO, "Unknown filesystem: 0x%02x\n", partition_type);
+            dbglog(DBG_INFO, "FATFS: Unknown filesystem: 0x%02x\n", partition_type);
             dev->shutdown(dev);
         }
     }
     return 0;
 }
+
+/* Unmount and cleanup SD devices */
+void fs_fat_unmount_sd(void) {
+    if (sd_dev != NULL) {
+        for (int i = 0; i < MAX_PARTITIONS; i++) {
+            if (sd_dev[i].dev_data != NULL) {
+                char path[16];
+                if (i == 0) {
+                    strcpy(path, "/sd");
+                }
+                else {
+                    sprintf(path, "/sd%d", i);
+                }
+                fs_fat_unmount(path);
+                sd_dev[i].shutdown(&sd_dev[i]);
+            }
+        }
+        free(sd_dev);
+        sd_dev = NULL;
+    }
+}
+
+/* Unmount and cleanup IDE devices */
+void fs_fat_unmount_ide(void) {
+    if (g1_dev != NULL) {
+        for (int i = 0; i < MAX_PARTITIONS; i++) {
+            if (g1_dev[i].dev_data != NULL) {
+                char path[16];
+                if (i == 0) {
+                    strcpy(path, "/ide");
+                }
+                else {
+                    sprintf(path, "/ide%d", i);
+                }
+                fs_fat_unmount(path);
+                g1_dev[i].shutdown(&g1_dev[i]);
+            }
+        }
+        free(g1_dev);
+        g1_dev = NULL;
+    }
+
+    if (g1_dev_dma != NULL) {
+        for (int i = 0; i < MAX_PARTITIONS; i++) {
+            if (g1_dev_dma[i].dev_data != NULL) {
+                g1_dev_dma[i].shutdown(&g1_dev_dma[i]);
+            }
+        }
+        free(g1_dev_dma);
+        g1_dev_dma = NULL;
+    }
+}

include/fatfs.h

@@ -75,7 +75,8 @@ int fs_fat_shutdown(void);
  * \param partition Partition number (reset to 0 for start block).
  * \return 0 on success, or a negative value if an error occurred.
  */
-int fs_fat_mount(const char *mp, kos_blockdev_t *dev_pio, kos_blockdev_t *dev_dma, int partition);
+int fs_fat_mount(const char *mp, kos_blockdev_t *dev_pio,
+    kos_blockdev_t *dev_dma, int partition);
 
 /**
  * \brief Unmount the FAT filesystem.
@@ -95,16 +96,28 @@ int fs_fat_is_mounted(const char *mp);
 
 /**
  * \brief Initialize the FAT and SD card, then mount all partitions on it.
+ * This function will try to detect and mount both SCIF and SCI interfaces
+ * if they are available.
  *
  * \return 0 on success, or a negative value if an error occurred.
  */
 int fs_fat_mount_sd(void);
 
+/**
+ * \brief Unmount all SD card partitions and free resources.
+ */
+void fs_fat_unmount_sd(void);
+
 /**
  * \brief Initialize the FAT and IDE (G1-ATA), then mount all partitions on it.
  *
  * \return 0 on success, or a negative value if an error occurred.
  */
 int fs_fat_mount_ide(void);
 
+/**
+ * \brief Unmount all IDE partitions and free resources.
+ */
+void fs_fat_unmount_ide(void);
+
 #endif /* _FATFS_H */