support for file based and sd partition based emusd

nyx/nyx_gui/frontend/fe_emusd_tools.c

@@ -5,11 +5,14 @@
 #include <libs/fatfs/ff.h>
 #include <storage/emmc.h>
 #include <storage/mbr_gpt.h>
+#include <storage/sd.h>
 #include <storage/sdmmc.h>
 #include <utils/list.h>
 #include <utils/ini.h>
 #include <string.h>
+#include "gfx_utils.h"
 #include <stdlib.h>
+#include <utils/sprintf.h>
 
 void load_emusd_cfg(emusd_cfg_t *emu_info){
 	memset(emu_info, 0, sizeof(emusd_cfg_t));
@@ -29,8 +32,10 @@ void load_emusd_cfg(emusd_cfg_t *emu_info){
 					emu_info->enabled = atoi(kv->val);
 				else if(!strcmp("sector", kv->key))
 					emu_info->sector = strtol(kv->val, NULL, 16);
-				/*else (!strcmp("id",     kv->key))
-					emu_info->id     = strtol(kv->val, NULL, 16);*/
+				else if(!strcmp("path", kv->key)){
+					emu_info->path =(char*)malloc(strlen(kv->val)+1);
+					strcpy(emu_info->path, kv->val);
+				}
 			}
 
 			break;
@@ -40,7 +45,7 @@ void load_emusd_cfg(emusd_cfg_t *emu_info){
 	ini_free(&ini_sections);
 }
 
-void save_emusd_cfg(u32 part_idx, u32 sector_start){
+void save_emusd_cfg(u32 part_idx, u32 sector_start, const char *path, u8 drive){
 	boot_storage_mount();
 
 	char lbuf[16];
@@ -53,7 +58,9 @@ void save_emusd_cfg(u32 part_idx, u32 sector_start){
 
 	// Add config entry.
 	f_puts("[emusd]\nenabled=", &fp);
-	if(sector_start){
+	if((sector_start || path) && drive == DRIVE_SD) {
+		f_puts("1", &fp);
+	} else if((sector_start || path) && drive == DRIVE_EMMC){
 		f_puts("4", &fp);
 	}else{
 		f_puts("0", &fp);
@@ -66,13 +73,142 @@ void save_emusd_cfg(u32 part_idx, u32 sector_start){
 		itoa(sector_start, lbuf, 16);
 		f_puts(lbuf, &fp);
 	}
-	f_puts("\n", &fp);
 
+	if(path){
+		f_puts("\npath=", &fp);
+		f_puts(path, &fp);
+	}
+
+	f_puts("\n", &fp);
 	f_close(&fp);
 }
 
-int create_emusd(int part_idx, u32 sector_mbr, u32 sector_start, u32 sector_size, const char *name){
-	sfd_init(&emmc_storage, sector_start, sector_size);
+static void update_base_path(char *path, int idx, int path_len) {
+	if(idx < 10){
+		path[path_len] = '0';
+		itoa(idx, path + path_len + 1, 10);
+	}else{
+		itoa(idx, path + path_len, 10);
+	}
+}
+
+int create_emusd_file(u32 size_sct, u8 drive) {
+	static const u32 file_max_scts = 0xfe000000 / 0x200;
+
+	char path[0x80];
+	if (drive == DRIVE_SD){
+		strcpy(path, "sd:emuSD/SD");
+		f_mkdir("sd:emuSD");
+	}else {
+		strcpy(path, "emmc:emuSD/EMMC");
+		f_mkdir("emmc:emuSD");
+	}
+	int path_len = strlen(path);
+
+	f_mkdir("emuSD");
+
+	for(int j = 0; j < 100; j++){
+		update_base_path(path, j, path_len);
+		if(f_stat(path, NULL) == FR_NO_FILE){
+			break;
+		}
+	}
+
+	f_mkdir(path);
+	f_mkdir(path + (drive == DRIVE_SD ? 3 : 5));
+
+	u32 base_path_len = strlen(path);
+
+	strcat(path, "/SD");
+	f_mkdir(path);
+
+	strcat(path, "/");
+	path_len = strlen(path);
+
+	// allocate files for emusd
+	u32 sct_left = size_sct;
+	u32 idx = 0;
+
+	gfx_printf("sct left 0x%x\n", sct_left);
+	while(sct_left) {
+		update_base_path(path, idx, path_len);
+
+		u32 scts = MIN(sct_left, file_max_scts);
+
+		FIL f;
+		int res = f_open(&f,  path, FA_CREATE_ALWAYS | FA_WRITE);
+		if(res != FR_OK) {
+			gfx_printf("open fail\n");
+			return 0;
+		}
+
+		FSIZE_t seek_bytes = (FSIZE_t)scts << 9;
+		res = f_lseek(&f, seek_bytes);
+		f_close(&f);
+
+		if(res != FR_OK){
+			f_unlink(path);
+			return 0;
+		}
+
+		sct_left -= scts;
+		idx++;
+	}
+
+
+	path[path_len] = '\0';
+
+	sfd_file_based_init(path);
+
+	u8 *buf = malloc(SZ_4M);
+	u32 cluster_size = 65536;
+
+	int res = f_mkfs("sfd:", FM_FAT32, cluster_size, buf, SZ_4M);
+
+	while (res != FR_OK && cluster_size > 4096){
+		cluster_size /= 2;
+		res = f_mkfs("sfd:", FM_FAT32, cluster_size, buf, SZ_4M);
+	}
+
+	if(res == FR_OK){
+		FATFS fs;
+		res = f_mount(&fs, "sfd:", 1);
+
+		if(res == FR_OK){
+			gfx_printf("mount fail %d\n", res);
+			char label[0x30];
+			strcpy(label, "sfd:emusd");
+			res = f_setlabel(label);
+		}
+
+		f_mount(NULL, "sfd:", 0);
+	}
+
+	sfd_end();
+
+	free(buf);
+
+	if(res != FR_OK) {
+		return 0;
+	}
+
+	path[base_path_len] = '\0';
+	s_printf(path + base_path_len, drive == DRIVE_SD ? "/file_based" : "/file_emmc_based");
+	FIL f;
+	res = f_open(&f, path + (drive == DRIVE_SD ? 3 : 5), FA_WRITE | FA_CREATE_ALWAYS);
+	f_close(&f);
+	gfx_printf("%s %d\n", path, res);
+
+	path[base_path_len] = '\0';
+	save_emusd_cfg(0, 0, path + (drive == DRIVE_SD ? 3 : 5), drive);
+
+	return 1;
+}
+
+int create_emusd(int part_idx, u32 sector_mbr, u32 sector_start, u32 sector_size, const char *name, u8 drive){
+	sdmmc_storage_t *storage = drive == DRIVE_SD ? &sd_storage : &emmc_storage;
+
+	sfd_init(storage, sector_start, sector_size);
 
 	u8 *buf = malloc(SZ_4M);
 	FIL f;
@@ -109,7 +245,7 @@ int create_emusd(int part_idx, u32 sector_mbr, u32 sector_start, u32 sector_size
 					mbr.partitions[0].size_sct = sector_size;
 					mbr.partitions[0].type = 0x0c;
 				
-					mkfs_error = sdmmc_storage_write(&emmc_storage, sector_mbr, 1, &mbr) ? FR_OK : FR_DISK_ERR;
+					mkfs_error = sdmmc_storage_write(storage, sector_mbr, 1, &mbr) ? FR_OK : FR_DISK_ERR;
 				}
 			}
 		}
@@ -119,5 +255,22 @@ int create_emusd(int part_idx, u32 sector_mbr, u32 sector_start, u32 sector_size
 
 	sfd_end();
 
-	return mkfs_error;
+	if(mkfs_error != FR_OK){
+		return mkfs_error;
+	}
+
+	char path[0x80];
+	strcpy(path, "emuSD");
+	f_mkdir(path);
+	s_printf(path + strlen(path), "/RAW_%s%d", drive == DRIVE_SD ? "SD" : "EMMC", part_idx);
+	f_mkdir(path);
+	strcat(path, "/raw_emmc_based");
+
+	f_open(&f, path, FA_CREATE_ALWAYS | FA_WRITE);
+	f_write(&f, &sector_mbr, 4, NULL);
+	f_close(&f);
+
+	save_emusd_cfg(part_idx, sector_mbr, NULL, drive); 
+
+	return FR_OK;
 }