ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6814 from lioncash/sd 

SDCardUtil: Minor changes
This commit is contained in:
Anthony 2018-05-11 12:39:17 -07:00 committed by GitHub
parent ee1a175205 cdeed038bd
commit 968779e623
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
Source/Core/Common/SDCardUtil.cpp
View File

@ -32,6 +32,9 @@
// A simple and portable piece of code used to generate a blank FAT32 image file. // A simple and portable piece of code used to generate a blank FAT32 image file.
// Modified for Dolphin. // Modified for Dolphin.
#include "Common/SDCardUtil.h"
#include <algorithm>
#include <cinttypes> #include <cinttypes>
#include <cstddef> #include <cstddef>
#include <cstdio> #include <cstdio>
@ -43,7 +46,6 @@
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/File.h" #include "Common/File.h"
#include "Common/Logging/Log.h" #include "Common/Logging/Log.h"
#include "Common/SDCardUtil.h"
#ifndef _WIN32 #ifndef _WIN32
#include <unistd.h> // for unlink() #include <unistd.h> // for unlink()
@ -54,33 +56,35 @@
#pragma warning(disable : 4310) #pragma warning(disable : 4310)
#endif #endif
/* Believe me, you *don't* want to change these constants !! */ namespace Common
#define BYTES_PER_SECTOR 512 {
#define RESERVED_SECTORS 32 // Believe me, you *don't* want to change these constants !!
#define BACKUP_BOOT_SECTOR 6 enum : u32
#define NUM_FATS 2 {
BYTES_PER_SECTOR = 512,
#define BYTE_(p, i) (((u8*)(p))[(i)]) RESERVED_SECTORS = 32,
BACKUP_BOOT_SECTOR = 6,
#define POKEB(p, v) BYTE_(p, 0) = (u8)(v) NUM_FATS = 2
#define POKES(p, v) (BYTE_(p, 0) = (u8)(v), BYTE_(p, 1) = (u8)((v) >> 8)) };
#define POKEW(p, v) \
(BYTE_(p, 0) = (u8)(v), BYTE_(p, 1) = (u8)((v) >> 8), BYTE_(p, 2) = (u8)((v) >> 16), \
BYTE_(p, 3) = (u8)((v) >> 24))
static u8 s_boot_sector[BYTES_PER_SECTOR]; /* Boot sector */ static u8 s_boot_sector[BYTES_PER_SECTOR]; /* Boot sector */
static u8 s_fsinfo_sector[BYTES_PER_SECTOR]; /* FS Info sector */ static u8 s_fsinfo_sector[BYTES_PER_SECTOR]; /* FS Info sector */
static u8 s_fat_head[BYTES_PER_SECTOR]; /* First FAT sector */ static u8 s_fat_head[BYTES_PER_SECTOR]; /* First FAT sector */
template <typename T>
static void WriteData(u8* out, T data)
{
std::memcpy(out, &data, sizeof(data));
}
/* This is the date and time when creating the disk */ /* This is the date and time when creating the disk */
static unsigned int get_serial_id() static unsigned int get_serial_id()
{ {
u16 lo, hi; const time_t now = std::time(nullptr);
time_t now = time(nullptr); const struct tm tm = std::gmtime(&now)[0];
struct tm tm = gmtime(&now)[0];
lo = (u16)(tm.tm_mday + ((tm.tm_mon + 1) << 8) + (tm.tm_sec << 8)); const u16 lo = static_cast<u16>(tm.tm_mday + ((tm.tm_mon + 1) << 8) + (tm.tm_sec << 8));
hi = (u16)(tm.tm_min + (tm.tm_hour << 8) + (tm.tm_year + 1900)); const u16 hi = static_cast<u16>(tm.tm_min + (tm.tm_hour << 8) + (tm.tm_year + 1900));
return lo + (hi << 16); return lo + (hi << 16);
} }
@ -106,106 +110,99 @@ static unsigned int get_sectors_per_cluster(u64 disk_size)
static unsigned int get_sectors_per_fat(u64 disk_size, u32 sectors_per_cluster) static unsigned int get_sectors_per_fat(u64 disk_size, u32 sectors_per_cluster)
{ {
u64 divider;
/* Weird computation from MS - see fatgen103.doc for details */ /* Weird computation from MS - see fatgen103.doc for details */
disk_size -= RESERVED_SECTORS * BYTES_PER_SECTOR; /* Don't count 32 reserved sectors */ disk_size -= RESERVED_SECTORS * BYTES_PER_SECTOR; /* Don't count 32 reserved sectors */
disk_size /= BYTES_PER_SECTOR; /* Disk size in sectors */ disk_size /= BYTES_PER_SECTOR; /* Disk size in sectors */
divider = ((256 * sectors_per_cluster) + NUM_FATS) / 2; const u64 divider = ((256 * sectors_per_cluster) + NUM_FATS) / 2;
return (u32)((disk_size + (divider - 1)) / divider); return static_cast<u32>((disk_size + (divider - 1)) / divider);
} }
static void boot_sector_init(u8* boot, u8* info, u64 disk_size, const char* label) static void boot_sector_init(u8* boot, u8* info, u64 disk_size, const char* label)
{ {
u32 sectors_per_cluster = get_sectors_per_cluster(disk_size); const u32 sectors_per_cluster = get_sectors_per_cluster(disk_size);
u32 sectors_per_fat = get_sectors_per_fat(disk_size, sectors_per_cluster); const u32 sectors_per_fat = get_sectors_per_fat(disk_size, sectors_per_cluster);
u32 sectors_per_disk = (u32)(disk_size / BYTES_PER_SECTOR); const u32 sectors_per_disk = static_cast<u32>(disk_size / BYTES_PER_SECTOR);
u32 serial_id = get_serial_id(); const u32 serial_id = get_serial_id();
u32 free_count;
if (label == nullptr) if (label == nullptr)
label = "DOLPHINSD"; label = "DOLPHINSD";
POKEB(boot, 0xeb); WriteData<u8>(boot, 0xeb);
POKEB(boot + 1, 0x5a); WriteData<u8>(boot + 1, 0x5a);
POKEB(boot + 2, 0x90); WriteData<u8>(boot + 2, 0x90);
strcpy((char*)boot + 3, "MSWIN4.1"); strcpy((char*)boot + 3, "MSWIN4.1");
POKES(boot + 0x0b, BYTES_PER_SECTOR); /* Sector size */ WriteData<u16>(boot + 0x0b, BYTES_PER_SECTOR); // Sector size
POKEB(boot + 0xd, sectors_per_cluster); /* Sectors per cluster */ WriteData<u8>(boot + 0xd, sectors_per_cluster); // Sectors per cluster
POKES(boot + 0xe, RESERVED_SECTORS); /* Reserved sectors before first FAT */ WriteData<u16>(boot + 0xe, RESERVED_SECTORS); // Reserved sectors before first FAT
POKEB(boot + 0x10, NUM_FATS); /* Number of FATs */ WriteData<u8>(boot + 0x10, NUM_FATS); // Number of FATs
POKES(boot + 0x11, 0); /* Max root directory entries for FAT12/FAT16, 0 for FAT32 */ WriteData<u16>(boot + 0x11, 0); // Max root directory entries for FAT12/FAT16, 0 for FAT32
POKES(boot + 0x13, 0); /* Total sectors, 0 to use 32-bit value at offset 0x20 */ WriteData<u16>(boot + 0x13, 0); // Total sectors, 0 to use 32-bit value at offset 0x20
POKEB(boot + 0x15, 0xF8); /* Media descriptor, 0xF8 == hard disk */ WriteData<u8>(boot + 0x15, 0xF8); // Media descriptor, 0xF8 == hard disk
POKES(boot + 0x16, 0); /* Sectors per FAT for FAT12/16, 0 for FAT32 */ WriteData<u16>(boot + 0x16, 0); // Sectors per FAT for FAT12/16, 0 for FAT32
POKES(boot + 0x18, 9); /* Sectors per track (whatever) */ WriteData<u16>(boot + 0x18, 9); // Sectors per track (whatever)
POKES(boot + 0x1a, 2); /* Number of heads (whatever) */ WriteData<u16>(boot + 0x1a, 2); // Number of heads (whatever)
POKEW(boot + 0x1c, 0); /* Hidden sectors */ WriteData<u32>(boot + 0x1c, 0); // Hidden sectors
POKEW(boot + 0x20, sectors_per_disk); /* Total sectors */ WriteData<u32>(boot + 0x20, sectors_per_disk); // Total sectors
/* Extension */ // Extension
POKEW(boot + 0x24, sectors_per_fat); /* Sectors per FAT */ WriteData<u32>(boot + 0x24, sectors_per_fat); // Sectors per FAT
POKES(boot + 0x28, 0); /* FAT flags */ WriteData<u16>(boot + 0x28, 0); // FAT flags
POKES(boot + 0x2a, 0); /* Version */ WriteData<u16>(boot + 0x2a, 0); // Version
POKEW(boot + 0x2c, 2); /* Cluster number of root directory start */ WriteData<u32>(boot + 0x2c, 2); // Cluster number of root directory start
POKES(boot + 0x30, 1); /* Sector number of FS information sector */ WriteData<u16>(boot + 0x30, 1); // Sector number of FS information sector
POKES(boot + 0x32, BACKUP_BOOT_SECTOR); /* Sector number of a copy of this boot sector */ WriteData<u16>(boot + 0x32, BACKUP_BOOT_SECTOR); // Sector number of a copy of this boot sector
POKEB(boot + 0x40, 0x80); /* Physical drive number */ WriteData<u8>(boot + 0x40, 0x80); // Physical drive number
POKEB(boot + 0x42, 0x29); /* Extended boot signature ?? */ WriteData<u8>(boot + 0x42, 0x29); // Extended boot signature ??
POKEW(boot + 0x43, serial_id); /* Serial ID */ WriteData<u32>(boot + 0x43, serial_id); // Serial ID
strncpy((char*)boot + 0x47, label, 11); /* Volume Label */ strncpy((char*)boot + 0x47, label, 11); // Volume Label
memcpy(boot + 0x52, "FAT32 ", 8); /* FAT system type, padded with 0x20 */ memcpy(boot + 0x52, "FAT32 ", 8); // FAT system type, padded with 0x20
POKEB(boot + BYTES_PER_SECTOR - 2, 0x55); /* Boot sector signature */ WriteData<u8>(boot + BYTES_PER_SECTOR - 2, 0x55); // Boot sector signature
POKEB(boot + BYTES_PER_SECTOR - 1, 0xAA); WriteData<u8>(boot + BYTES_PER_SECTOR - 1, 0xAA);
/* FSInfo sector */ /* FSInfo sector */
free_count = sectors_per_disk - 32 - 2 * sectors_per_fat; const u32 free_count = sectors_per_disk - 32 - 2 * sectors_per_fat;
POKEW(info + 0, 0x41615252); WriteData<u32>(info + 0, 0x41615252);
POKEW(info + 484, 0x61417272); WriteData<u32>(info + 484, 0x61417272);
POKEW(info + 488, free_count); /* Number of free clusters */ WriteData<u32>(info + 488, free_count); // Number of free clusters
POKEW(info + 492, 3); /* Next free clusters, 0-1 reserved, 2 is used for the root dir */ // Next free clusters, 0-1 reserved, 2 is used for the root dir
POKEW(info + 508, 0xAA550000); WriteData<u32>(info + 492, 3);
WriteData<u32>(info + 508, 0xAA550000);
} }
static void fat_init(u8* fat) static void fat_init(u8* fat)
{ {
POKEW(fat, 0x0ffffff8); /* Reserve cluster 1, media id in low byte */ WriteData<u32>(fat, 0x0ffffff8); // Reserve cluster 1, media id in low byte
POKEW(fat + 4, 0x0fffffff); /* Reserve cluster 2 */ WriteData<u32>(fat + 4, 0x0fffffff); // Reserve cluster 2
POKEW(fat + 8, 0x0fffffff); /* End of cluster chain for root dir */ WriteData<u32>(fat + 8, 0x0fffffff); // End of cluster chain for root dir
} }
static unsigned int write_sector(FILE* file, u8* sector) static bool write_sector(File::IOFile& file, const u8* sector)
{ {
return fwrite(sector, 1, 512, file) != 512; return file.WriteBytes(sector, BYTES_PER_SECTOR);
} }
static unsigned int write_empty(FILE* file, u64 count) static bool write_empty(File::IOFile& file, std::size_t count)
{ {
static u8 empty[64 * 1024]; static constexpr u8 empty[64 * 1024] = {};
count *= 512; count *= BYTES_PER_SECTOR;
while (count > 0) while (count > 0)
{ {
u64 len = sizeof(empty); const std::size_t len = std::min(sizeof(empty), count);
if (len > count)
len = count;
if (fwrite(empty, 1, (size_t)len, file) != (size_t)len) if (!file.WriteBytes(empty, len))
return 1; return false;
count -= len; count -= len;
} }
return 0; return true;
} }
bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename) bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename)
{ {
u32 sectors_per_fat;
u32 sectors_per_disk;
// Convert MB to bytes // Convert MB to bytes
disk_size *= 1024 * 1024; disk_size *= 1024 * 1024;
@ -218,15 +215,14 @@ bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename)
} }
// Pretty unlikely to overflow. // Pretty unlikely to overflow.
sectors_per_disk = (u32)(disk_size / 512); const u32 sectors_per_disk = static_cast<u32>(disk_size / BYTES_PER_SECTOR);
sectors_per_fat = get_sectors_per_fat(disk_size, get_sectors_per_cluster(disk_size)); const u32 sectors_per_fat = get_sectors_per_fat(disk_size, get_sectors_per_cluster(disk_size));
boot_sector_init(s_boot_sector, s_fsinfo_sector, disk_size, nullptr); boot_sector_init(s_boot_sector, s_fsinfo_sector, disk_size, nullptr);
fat_init(s_fat_head); fat_init(s_fat_head);
File::IOFile file(filename, "wb"); File::IOFile file(filename, "wb");
FILE* const f = file.GetHandle(); if (!file)
if (!f)
{ {
ERROR_LOG(COMMON, "Could not create file '%s', aborting...", filename.c_str()); ERROR_LOG(COMMON, "Could not create file '%s', aborting...", filename.c_str());
return false; return false;
@ -245,45 +241,45 @@ bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename)
* zero sectors * zero sectors
*/ */
if (write_sector(f, s_boot_sector)) if (!write_sector(file, s_boot_sector))
goto FailWrite; goto FailWrite;
if (write_sector(f, s_fsinfo_sector)) if (!write_sector(file, s_fsinfo_sector))
goto FailWrite; goto FailWrite;
if (BACKUP_BOOT_SECTOR > 0) if (BACKUP_BOOT_SECTOR > 0)
{ {
if (write_empty(f, BACKUP_BOOT_SECTOR - 2)) if (!write_empty(file, BACKUP_BOOT_SECTOR - 2))
goto FailWrite; goto FailWrite;
if (write_sector(f, s_boot_sector)) if (!write_sector(file, s_boot_sector))
goto FailWrite; goto FailWrite;
if (write_sector(f, s_fsinfo_sector)) if (!write_sector(file, s_fsinfo_sector))
goto FailWrite; goto FailWrite;
if (write_empty(f, RESERVED_SECTORS - 2 - BACKUP_BOOT_SECTOR)) if (!write_empty(file, RESERVED_SECTORS - 2 - BACKUP_BOOT_SECTOR))
goto FailWrite; goto FailWrite;
} }
else else
{ {
if (write_empty(f, RESERVED_SECTORS - 2)) if (!write_empty(file, RESERVED_SECTORS - 2))
goto FailWrite; goto FailWrite;
} }
if (write_sector(f, s_fat_head)) if (!write_sector(file, s_fat_head))
goto FailWrite; goto FailWrite;
if (write_empty(f, sectors_per_fat - 1)) if (!write_empty(file, sectors_per_fat - 1))
goto FailWrite; goto FailWrite;
if (write_sector(f, s_fat_head)) if (!write_sector(file, s_fat_head))
goto FailWrite; goto FailWrite;
if (write_empty(f, sectors_per_fat - 1)) if (!write_empty(file, sectors_per_fat - 1))
goto FailWrite; goto FailWrite;
if (write_empty(f, sectors_per_disk - RESERVED_SECTORS - 2 * sectors_per_fat)) if (!write_empty(file, sectors_per_disk - RESERVED_SECTORS - 2 * sectors_per_fat))
goto FailWrite; goto FailWrite;
return true; return true;
@ -294,6 +290,7 @@ FailWrite:
ERROR_LOG(COMMON, "unlink(%s) failed: %s", filename.c_str(), LastStrerrorString().c_str()); ERROR_LOG(COMMON, "unlink(%s) failed: %s", filename.c_str(), LastStrerrorString().c_str());
return false; return false;
} }
} // namespace Common
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(pop) #pragma warning(pop)

3
Source/Core/Common/SDCardUtil.h
View File

@ -7,4 +7,7 @@
#include <string> #include <string>
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
namespace Common
{
bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename); bool SDCardCreate(u64 disk_size /*in MB*/, const std::string& filename);
} // namespace Common

2
Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp
View File

@ -67,7 +67,7 @@ void SDIOSlot0::OpenInternal()
if (!m_card) if (!m_card)
{ {
WARN_LOG(IOS_SD, "Failed to open SD Card image, trying to create a new 128MB image..."); WARN_LOG(IOS_SD, "Failed to open SD Card image, trying to create a new 128MB image...");
if (SDCardCreate(128, filename)) if (Common::SDCardCreate(128, filename))
{ {
INFO_LOG(IOS_SD, "Successfully created %s", filename.c_str()); INFO_LOG(IOS_SD, "Successfully created %s", filename.c_str());
m_card.Open(filename, "r+b"); m_card.Open(filename, "r+b");