mirror of
https://github.com/nitraiolo/CfgUSBLoader.git
synced 2024-10-22 14:15:05 +02:00
1025 lines
20 KiB
C
1025 lines
20 KiB
C
|
|
// FAT support, banner sounds and alt.dol by oggzee
|
|
// Banner title for playlog by Clipper
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <malloc.h>
|
|
#include <ogcsys.h>
|
|
#include <dirent.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <sys/statvfs.h>
|
|
#include <ctype.h>
|
|
#include <sdcard/wiisd_io.h>
|
|
|
|
#include "libwbfs/libwbfs.h"
|
|
#include "sdhc.h"
|
|
#include "usbstorage.h"
|
|
#include "utils.h"
|
|
#include "video.h"
|
|
#include "wbfs.h"
|
|
#include "wdvd.h"
|
|
#include "subsystem.h"
|
|
#include "splits.h"
|
|
#include "fat.h"
|
|
#include "partition.h"
|
|
#include "cfg.h"
|
|
#include "wbfs_fat.h"
|
|
#include "util.h"
|
|
#include "gettext.h"
|
|
|
|
/* Constants */
|
|
#define MAX_NB_SECTORS 32
|
|
|
|
/* WBFS device */
|
|
s32 wbfsDev = WBFS_MIN_DEVICE;
|
|
|
|
// partition
|
|
int wbfs_part_fs = PART_FS_WBFS;
|
|
u32 wbfs_part_idx = 0;
|
|
u32 wbfs_part_lba = 0;
|
|
|
|
/* WBFS HDD */
|
|
wbfs_t *hdd = NULL;
|
|
|
|
/* WBFS callbacks */
|
|
static rw_sector_callback_t readCallback = NULL;
|
|
static rw_sector_callback_t writeCallback = NULL;
|
|
|
|
/* Variables */
|
|
static u32 nb_sectors;
|
|
u32 wbfs_dev_sector_size;
|
|
|
|
static mutex_t wbfs_disc_mutex = LWP_MUTEX_NULL;
|
|
|
|
void __WBFS_Spinner(s32 x, s32 max)
|
|
{
|
|
static time_t start;
|
|
static u32 expected;
|
|
|
|
f32 percent, size;
|
|
u32 d, h, m, s;
|
|
|
|
/* First time */
|
|
if (!x) {
|
|
start = time(0);
|
|
expected = 300;
|
|
}
|
|
|
|
/* Elapsed time */
|
|
d = time(0) - start;
|
|
|
|
if (x != max) {
|
|
/* Expected time */
|
|
if (d && x)
|
|
expected = (expected * 3 + d * max / x) / 4;
|
|
|
|
/* Remaining time */
|
|
d = (expected > d) ? (expected - d) : 1;
|
|
}
|
|
|
|
/* Calculate time values */
|
|
h = d / 3600;
|
|
m = (d / 60) % 60;
|
|
s = d % 60;
|
|
|
|
/* Calculate percentage/size */
|
|
percent = (x * 100.0) / max;
|
|
if (hdd) {
|
|
size = (hdd->wii_sec_sz / GB_SIZE) * max;
|
|
} else {
|
|
size = (0x8000 / GB_SIZE) * max;
|
|
}
|
|
|
|
Con_ClearLine();
|
|
|
|
/* Show progress */
|
|
if (x != max) {
|
|
printf_(gt("%.2f%% of %.2fGB (%c) ETA: %d:%02d:%02d"),
|
|
percent, size, "/-\\|"[(x / 10) % 4], h, m, s);
|
|
printf("\r");
|
|
fflush(stdout);
|
|
} else {
|
|
printf_(gt("%.2fGB copied in %d:%02d:%02d"), size, h, m, s);
|
|
printf(" \n");
|
|
}
|
|
|
|
__console_flush(1);
|
|
}
|
|
|
|
s32 __WBFS_ReadDVD(void *fp, u32 lba, u32 len, void *iobuf)
|
|
{
|
|
void *buffer = NULL;
|
|
|
|
u64 offset;
|
|
u32 mod, size;
|
|
s32 ret;
|
|
|
|
/* Calculate offset */
|
|
offset = ((u64)lba) << 2;
|
|
|
|
/* Calcualte sizes */
|
|
mod = len % 32;
|
|
size = len - mod;
|
|
|
|
/* Read aligned data */
|
|
if (size) {
|
|
ret = WDVD_UnencryptedRead(iobuf, size, offset);
|
|
if (ret < 0)
|
|
goto out;
|
|
}
|
|
|
|
/* Read non-aligned data */
|
|
if (mod) {
|
|
/* Allocate memory */
|
|
buffer = memalign(32, 0x20);
|
|
if (!buffer)
|
|
return -1;
|
|
|
|
/* Read data */
|
|
ret = WDVD_UnencryptedRead(buffer, 0x20, offset + size);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
/* Copy data */
|
|
memcpy(iobuf + size, buffer, mod);
|
|
}
|
|
|
|
/* Success */
|
|
ret = 0;
|
|
|
|
out:
|
|
/* Free memory */
|
|
if (buffer)
|
|
free(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
s32 __WBFS_ReadUSB(void *fp, u32 lba, u32 count, void *iobuf)
|
|
{
|
|
u32 cnt = 0;
|
|
s32 ret;
|
|
|
|
/* Do reads */
|
|
while (cnt < count) {
|
|
void *ptr = ((u8 *)iobuf) + (cnt * wbfs_dev_sector_size);
|
|
u32 sectors = (count - cnt);
|
|
|
|
/* Read sectors is too big */
|
|
if (sectors > MAX_NB_SECTORS)
|
|
sectors = MAX_NB_SECTORS;
|
|
|
|
/* USB read */
|
|
ret = USBStorage_ReadSectors(lba + cnt, sectors, ptr);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Increment counter */
|
|
cnt += sectors;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 __WBFS_WriteUSB(void *fp, u32 lba, u32 count, void *iobuf)
|
|
{
|
|
u32 cnt = 0;
|
|
s32 ret;
|
|
|
|
/* Do writes */
|
|
while (cnt < count) {
|
|
void *ptr = ((u8 *)iobuf) + (cnt * wbfs_dev_sector_size);
|
|
u32 sectors = (count - cnt);
|
|
|
|
/* Write sectors is too big */
|
|
if (sectors > MAX_NB_SECTORS)
|
|
sectors = MAX_NB_SECTORS;
|
|
|
|
/* USB write */
|
|
ret = USBStorage_WriteSectors(lba + cnt, sectors, ptr);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Increment counter */
|
|
cnt += sectors;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 __WBFS_ReadSDHC(void *fp, u32 lba, u32 count, void *iobuf)
|
|
{
|
|
u32 cnt = 0;
|
|
s32 ret;
|
|
|
|
/* Do reads */
|
|
while (cnt < count) {
|
|
void *ptr = ((u8 *)iobuf) + (cnt * wbfs_dev_sector_size);
|
|
u32 sectors = (count - cnt);
|
|
|
|
/* Read sectors is too big */
|
|
if (sectors > MAX_NB_SECTORS)
|
|
sectors = MAX_NB_SECTORS;
|
|
|
|
/* SDHC read */
|
|
ret = SDHC_ReadSectors(lba + cnt, sectors, ptr);
|
|
if (!ret)
|
|
return -1;
|
|
|
|
/* Increment counter */
|
|
cnt += sectors;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 __WBFS_WriteSDHC(void *fp, u32 lba, u32 count, void *iobuf)
|
|
{
|
|
u32 cnt = 0;
|
|
s32 ret;
|
|
|
|
/* Do writes */
|
|
while (cnt < count) {
|
|
void *ptr = ((u8 *)iobuf) + (cnt * wbfs_dev_sector_size);
|
|
u32 sectors = (count - cnt);
|
|
|
|
/* Write sectors is too big */
|
|
if (sectors > MAX_NB_SECTORS)
|
|
sectors = MAX_NB_SECTORS;
|
|
|
|
/* SDHC write */
|
|
ret = SDHC_WriteSectors(lba + cnt, sectors, ptr);
|
|
if (!ret)
|
|
return -1;
|
|
|
|
/* Increment counter */
|
|
cnt += sectors;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
s32 WBFS_Init_Dev(u32 device)
|
|
{
|
|
s32 ret = -1;
|
|
|
|
if (wbfs_disc_mutex == LWP_MUTEX_NULL) {
|
|
LWP_MutexInit(&wbfs_disc_mutex, true);
|
|
}
|
|
|
|
/* Try to mount device */
|
|
switch (device) {
|
|
case WBFS_DEVICE_USB:
|
|
{
|
|
long long t1 = TIME_D(usb_init);
|
|
long long t2;
|
|
get_time(&TIME.usb_retry1);
|
|
/* Initialize USB storage */
|
|
ret = USBStorage_Init();
|
|
|
|
if (ret >= 0) {
|
|
/* Setup callbacks */
|
|
readCallback = __WBFS_ReadUSB;
|
|
writeCallback = __WBFS_WriteUSB;
|
|
|
|
/* Device info */
|
|
nb_sectors = USBStorage_GetCapacity(&wbfs_dev_sector_size);
|
|
|
|
get_time(&TIME.usb_retry2);
|
|
t2 = TIME_D(usb_init);
|
|
TIME.usb_retry2 -= (t2 - t1);
|
|
goto out;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WBFS_DEVICE_SDHC:
|
|
{
|
|
/* Initialize SDHC */
|
|
ret = SDHC_Init();
|
|
// returns true=ok false=error
|
|
if (!ret && !sdhc_mode_sd) {
|
|
// try normal SD
|
|
sdhc_mode_sd = 1;
|
|
ret = SDHC_Init();
|
|
}
|
|
if (ret) {
|
|
/* Setup callbacks */
|
|
readCallback = __WBFS_ReadSDHC;
|
|
writeCallback = __WBFS_WriteSDHC;
|
|
|
|
/* Device info */
|
|
nb_sectors = 0;
|
|
wbfs_dev_sector_size = SDHC_SECTOR_SIZE;
|
|
|
|
goto out;
|
|
}
|
|
|
|
ret = -1;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
s32 WBFS_Init(u32 device, u32 timeout)
|
|
{
|
|
u32 cnt;
|
|
s32 ret = -1;
|
|
|
|
/* Wrong timeout */
|
|
if (!timeout)
|
|
return -1;
|
|
|
|
/* Try to mount device */
|
|
for (cnt = 0; cnt < timeout; cnt++) {
|
|
|
|
ret = WBFS_Init_Dev(device);
|
|
if (ret >= 0) break;
|
|
|
|
Gui_Console_Enable();
|
|
printf("%d ", cnt + 1);
|
|
|
|
/* Sleep 1 second */
|
|
sleep(1);
|
|
}
|
|
|
|
printf_("%s\n", ret < 0 ? gt("ERROR!") : gt("OK!"));
|
|
return ret;
|
|
}
|
|
|
|
bool WBFS_Close()
|
|
{
|
|
/* Close hard disk */
|
|
if (hdd) {
|
|
wbfs_close(hdd);
|
|
hdd = NULL;
|
|
}
|
|
UnmountFS(GAME_MOUNT);
|
|
wbfs_part_fs = 0;
|
|
wbfs_part_idx = 0;
|
|
wbfs_part_lba = 0;
|
|
strcpy(wbfs_fs_drive, "");
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool WBFS_Mounted()
|
|
{
|
|
return (hdd != NULL);
|
|
}
|
|
|
|
bool WBFS_Selected()
|
|
{
|
|
//if (wbfs_part_fs && wbfs_part_lba && *wbfs_fs_drive) return true;
|
|
// RAW device fs will have lba=0
|
|
if (wbfs_part_fs && *wbfs_fs_drive) return true;
|
|
return WBFS_Mounted();
|
|
}
|
|
|
|
s32 WBFS_Open(void)
|
|
{
|
|
/* Close hard disk */
|
|
if (hdd)
|
|
wbfs_close(hdd);
|
|
|
|
/* Open hard disk */
|
|
wbfs_part_fs = 0;
|
|
wbfs_part_idx = 0;
|
|
wbfs_part_lba = 0;
|
|
hdd = wbfs_open_hd(readCallback, writeCallback, NULL, wbfs_dev_sector_size, nb_sectors, 0);
|
|
if (!hdd)
|
|
return -1;
|
|
wbfs_part_idx = 1;
|
|
wbfs_part_lba = hdd->part_lba;
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_OpenPart(u32 part_fs, u32 part_idx, u32 part_lba, u32 part_size, char *partition)
|
|
{
|
|
// close
|
|
WBFS_Close();
|
|
|
|
dbg_printf("openpart(%d %d %d %d)\n", part_fs, part_idx, part_lba, part_size);
|
|
if (part_fs == PART_FS_UNK) return -1;
|
|
if (part_fs == PART_FS_WBFS) {
|
|
if (WBFS_OpenLBA(part_lba, part_size)) return -1;
|
|
} else {
|
|
MountPoint *mp = mount_find_part(wbfsDev, part_lba);
|
|
if (mp) {
|
|
mount_name2drive(mp->name, wbfs_fs_drive);
|
|
} else {
|
|
if (MountFS(GAME_MOUNT, wbfsDev, part_lba, part_fs, 1)) return -1;
|
|
mount_name2drive(GAME_MOUNT, wbfs_fs_drive);
|
|
}
|
|
}
|
|
|
|
// success
|
|
wbfs_part_fs = part_fs;
|
|
wbfs_part_idx = part_idx;
|
|
wbfs_part_lba = part_lba;
|
|
sprintf(partition, "%s%d", get_fs_name(part_fs), wbfs_part_idx);
|
|
dbg_printf("game part=%s\n", partition);
|
|
return 0;
|
|
}
|
|
|
|
bool is_game_fs(int device, sec_t sector)
|
|
{
|
|
char path[100];
|
|
struct stat st;
|
|
MountPoint *mp;
|
|
dbg_printf("is_game_fs(%d,%d)\n", device, sector);
|
|
mp = mount_find_part(device, sector);
|
|
if (mp) {
|
|
dbg_printf("check %s:%s\n", mp->name, CFG.wbfs_fat_dir);
|
|
sprintf(path, "%s:%s", mp->name, CFG.wbfs_fat_dir);
|
|
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
s32 WBFS_OpenNamed(char *partition)
|
|
{
|
|
int i = 0;
|
|
u32 part_fs = PART_FS_WBFS;
|
|
u32 part_idx = 0;
|
|
u32 part_lba = 0;
|
|
s32 ret = 0;
|
|
PartList plist;
|
|
int x, fs;
|
|
|
|
// close
|
|
WBFS_Close();
|
|
|
|
dbg_printf("open_part(%s)\n", partition);
|
|
|
|
// Get partition entries
|
|
ret = Partition_GetList(wbfsDev, &plist);
|
|
if (ret || plist.num == 0) return -1;
|
|
|
|
// parse partition option
|
|
if (strcasecmp(partition, "auto") == 0) {
|
|
int fs_list[] = { PART_FS_WBFS, PART_FS_FAT, PART_FS_NTFS }; // PART_FS_EXT
|
|
int n = sizeof(fs_list) / sizeof(int);
|
|
for (x=0; x<n; x++) {
|
|
fs = fs_list[x];
|
|
i = PartList_FindFS(&plist, fs, 1, NULL);
|
|
if (i < 0) continue;
|
|
if ((fs == PART_FS_WBFS) || is_game_fs(wbfsDev, plist.pentry[i].sector)) {
|
|
part_fs = fs;
|
|
part_idx = 1;
|
|
goto found;
|
|
}
|
|
}
|
|
} else {
|
|
for (x=0; x<PART_FS_NUM; x++) {
|
|
fs = PART_FS_FIRST + x;
|
|
char *fsname = get_fs_name(fs);
|
|
int len = strlen(fsname);
|
|
if (strncasecmp(partition, fsname, len) == 0) {
|
|
int idx = atoi(partition + len);
|
|
if (idx < 1 || idx > 9) goto err;
|
|
i = PartList_FindFS(&plist, fs, idx, NULL);
|
|
if (i >= 0) {
|
|
part_fs = fs;
|
|
part_idx = idx;
|
|
goto found;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// nothing found
|
|
goto err;
|
|
|
|
found:
|
|
if (i >= plist.num) goto err;
|
|
// set partition lba sector
|
|
part_lba = plist.pentry[i].sector;
|
|
|
|
if (WBFS_OpenPart(part_fs, part_idx, part_lba, plist.pentry[i].size, partition)) {
|
|
goto err;
|
|
}
|
|
// success
|
|
dbg_printf("OK! partition=%s\n", partition);
|
|
return 0;
|
|
|
|
err:
|
|
Gui_Console_Enable();
|
|
printf(gt("Invalid partition: '%s'"), partition);
|
|
printf("\n");
|
|
__console_flush(0);
|
|
sleep(2);
|
|
return -1;
|
|
}
|
|
|
|
|
|
s32 WBFS_OpenLBA(u32 lba, u32 size)
|
|
{
|
|
wbfs_t *part = NULL;
|
|
|
|
/* Open partition */
|
|
part = wbfs_open_partition(readCallback, writeCallback, NULL, wbfs_dev_sector_size, size, lba, 0);
|
|
if (!part) return -1;
|
|
|
|
/* Close current hard disk */
|
|
if (hdd) wbfs_close(hdd);
|
|
hdd = part;
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_Format(u32 lba, u32 size)
|
|
{
|
|
wbfs_t *partition = NULL;
|
|
|
|
/* Reset partition */
|
|
partition = wbfs_open_partition(readCallback, writeCallback, NULL, wbfs_dev_sector_size, size, lba, 1);
|
|
if (!partition)
|
|
return -1;
|
|
|
|
/* Free memory */
|
|
wbfs_close(partition);
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_GetCount(u32 *count)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_GetCount(count);
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
/* Get list length */
|
|
*count = wbfs_count_discs(hdd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_GetHeaders(void *outbuf, u32 cnt, u32 len)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_GetHeaders(outbuf, cnt, len);
|
|
|
|
u32 idx, size;
|
|
s32 ret;
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
for (idx = 0; idx < cnt; idx++) {
|
|
u8 *ptr = ((u8 *)outbuf) + (idx * len);
|
|
|
|
/* Get header */
|
|
ret = wbfs_get_disc_info(hdd, idx, ptr, len, &size);
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_CheckGame(u8 *discid)
|
|
{
|
|
wbfs_disc_t *disc = NULL;
|
|
|
|
/* Try to open game disc */
|
|
disc = WBFS_OpenDisc(discid);
|
|
if (disc) {
|
|
/* Close disc */
|
|
WBFS_CloseDisc(disc);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_AddGame(void)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_AddGame();
|
|
s32 ret;
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
/* Add game to device */
|
|
partition_selector_t part_sel = ALL_PARTITIONS;
|
|
int copy_1_1 = 0;
|
|
switch (CFG.install_partitions) {
|
|
default:
|
|
case CFG_INSTALL_GAME:
|
|
part_sel = ONLY_GAME_PARTITION;
|
|
break;
|
|
case CFG_INSTALL_ALL:
|
|
part_sel = ALL_PARTITIONS;
|
|
break;
|
|
case CFG_INSTALL_1_1:
|
|
case CFG_INSTALL_ISO:
|
|
part_sel = ALL_PARTITIONS;
|
|
copy_1_1 = 1;
|
|
break;
|
|
}
|
|
ret = wbfs_add_disc(hdd, __WBFS_ReadDVD, NULL, __WBFS_Spinner, part_sel, copy_1_1);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_RemoveGame(u8 *discid)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_RemoveGame(discid);
|
|
s32 ret;
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
/* Remove game from device */
|
|
ret = wbfs_rm_disc(hdd, discid);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_GameSize(u8 *discid, f32 *size)
|
|
{
|
|
wbfs_disc_t *disc = NULL;
|
|
|
|
u32 sectors;
|
|
|
|
/* Open disc */
|
|
disc = WBFS_OpenDisc(discid);
|
|
if (!disc)
|
|
return -2;
|
|
|
|
/* Get game size in sectors */
|
|
sectors = wbfs_disc_sector_used(disc, NULL);
|
|
|
|
/* Copy value */
|
|
*size = (disc->p->wbfs_sec_sz / GB_SIZE) * sectors;
|
|
|
|
/* Close disc */
|
|
WBFS_CloseDisc(disc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_GameSize2(u8 *discid, u64 *comp_size, u64 *real_size)
|
|
{
|
|
wbfs_disc_t *disc = NULL;
|
|
|
|
u32 sectors, real_sec;
|
|
|
|
/* Open disc */
|
|
disc = WBFS_OpenDisc(discid);
|
|
if (!disc)
|
|
return -2;
|
|
|
|
/* Get game size in sectors */
|
|
sectors = wbfs_disc_sector_used(disc, &real_sec);
|
|
|
|
/* Copy value */
|
|
*comp_size = ((u64)disc->p->wbfs_sec_sz) * sectors;
|
|
*real_size = ((u64)disc->p->wbfs_sec_sz) * real_sec;
|
|
|
|
/* Close disc */
|
|
WBFS_CloseDisc(disc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
s32 WBFS_DVD_Size(u64 *comp_size, u64 *real_size)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_DVD_Size(comp_size, real_size);
|
|
s32 ret;
|
|
u32 comp_sec = 0, last_sec = 0;
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
/* Add game to device */
|
|
partition_selector_t part_sel;
|
|
if (CFG.install_partitions) {
|
|
part_sel = ALL_PARTITIONS;
|
|
} else {
|
|
part_sel = ONLY_GAME_PARTITION;
|
|
}
|
|
ret = wbfs_size_disc(hdd, __WBFS_ReadDVD, NULL, part_sel, &comp_sec, &last_sec);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
*comp_size = ((u64)hdd->wii_sec_sz) * comp_sec;
|
|
*real_size = ((u64)hdd->wii_sec_sz) * (last_sec+1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
s32 WBFS_DiskSpace(f32 *used, f32 *free)
|
|
{
|
|
if (wbfs_part_fs) return WBFS_FAT_DiskSpace(used, free);
|
|
f32 ssize;
|
|
u32 cnt;
|
|
|
|
/* No device open */
|
|
if (!hdd)
|
|
return -1;
|
|
|
|
/* Count used blocks */
|
|
cnt = wbfs_count_usedblocks(hdd);
|
|
|
|
/* Sector size in GB */
|
|
ssize = hdd->wbfs_sec_sz / GB_SIZE;
|
|
|
|
/* Copy values */
|
|
*free = ssize * cnt;
|
|
*used = ssize * (hdd->n_wbfs_sec - cnt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
wbfs_disc_t* WBFS_OpenDisc(u8 *discid)
|
|
{
|
|
wbfs_disc_t *ret = NULL;
|
|
//dbg_printf("WBFS_OpenDisc(%.6s) %d\n", discid, wbfs_part_fs);
|
|
LWP_MutexLock(wbfs_disc_mutex);
|
|
if (wbfs_part_fs) {
|
|
ret = WBFS_FAT_OpenDisc(discid);
|
|
} else {
|
|
if (!hdd) {
|
|
/* No device open */
|
|
ret = NULL;
|
|
} else {
|
|
/* Open disc */
|
|
ret = wbfs_open_disc(hdd, discid);
|
|
}
|
|
}
|
|
if (ret == NULL) {
|
|
LWP_MutexUnlock(wbfs_disc_mutex);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void WBFS_CloseDisc(wbfs_disc_t *disc)
|
|
{
|
|
if (wbfs_part_fs) {
|
|
WBFS_FAT_CloseDisc(disc);
|
|
} else {
|
|
if (hdd && disc) {
|
|
/* Close disc */
|
|
wbfs_close_disc(disc);
|
|
}
|
|
}
|
|
if (disc) {
|
|
LWP_MutexUnlock(wbfs_disc_mutex);
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
u8 filetype;
|
|
char name_offset[3];
|
|
u32 fileoffset;
|
|
u32 filelen;
|
|
} __attribute__((packed)) FST_ENTRY;
|
|
|
|
|
|
char *fstfilename2(FST_ENTRY *fst, u32 index)
|
|
{
|
|
u32 count = _be32((u8*)&fst[0].filelen);
|
|
u32 stringoffset;
|
|
if (index < count)
|
|
{
|
|
//stringoffset = *(u32 *)&(fst[index]) % (256*256*256);
|
|
stringoffset = _be32((u8*)&(fst[index])) % (256*256*256);
|
|
return (char *)((u32)fst + count*12 + stringoffset);
|
|
} else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
int WBFS_GetDolList(u8 *discid, DOL_LIST *list)
|
|
{
|
|
FST_ENTRY *fst = NULL;
|
|
int fst_size;
|
|
|
|
list->num = 0;
|
|
|
|
wbfs_disc_t* d = WBFS_OpenDisc(discid);
|
|
if (!d) return -1;
|
|
fst_size = wbfs_extract_file(d, "", (void*)&fst);
|
|
WBFS_CloseDisc(d);
|
|
if (!fst || fst_size < 0) return -1;
|
|
|
|
u32 count = _be32((u8*)&fst[0].filelen);
|
|
u32 i;
|
|
|
|
for (i=1;i<count;i++) {
|
|
char * fname = fstfilename2(fst, i);
|
|
int len = strlen(fname);
|
|
if (len > 4 && stricmp(fname+len-4, ".dol") == 0) {
|
|
if (list->num >= DOL_LIST_MAX) break;
|
|
STRCOPY(list->name[list->num], fname);
|
|
list->num++;
|
|
}
|
|
}
|
|
|
|
free(fst);
|
|
return 0;
|
|
}
|
|
|
|
int WBFS_Banner(u8 *discid, SoundInfo *snd, u8 *title, u8 getSound, u8 getTitle)
|
|
{
|
|
void *banner = NULL;
|
|
int size;
|
|
//dbg_printf("WBFS_Banner(%.6s %d %d)\n", discid, getSound, getTitle);
|
|
|
|
if (!getSound && !getTitle) return 0;
|
|
|
|
snd->dsp_data = NULL;
|
|
wbfs_disc_t* d = WBFS_OpenDisc(discid);
|
|
if (!d) return -1;
|
|
size = wbfs_extract_file(d, "opening.bnr", &banner);
|
|
WBFS_CloseDisc(d);
|
|
if (!banner || size <= 0) return -1;
|
|
|
|
//printf("\nopening.bnr: %d\n", size);
|
|
if (getTitle)
|
|
{
|
|
s32 lang = getTitle - 2;
|
|
if (lang < 0)
|
|
lang = CFG_read_active_game_setting(discid).language - 1;
|
|
if (lang < 0)
|
|
lang = CONF_GetLanguage();
|
|
parse_banner_title(banner, title, lang);
|
|
// if title is empty revert to english
|
|
char z2[2] = {0,0}; // utf16: 2 bytes
|
|
if (getTitle == 1 && memcmp(title, z2, 2) == 0) {
|
|
parse_banner_title(banner, title, CONF_LANG_ENGLISH);
|
|
// if still empty, find first valid.
|
|
if (memcmp(title, z2, 2) == 0) {
|
|
for (lang=0; lang<10; lang++) {
|
|
parse_banner_title(banner, title, lang);
|
|
if (memcmp(title, z2, 2) != 0) break;
|
|
}
|
|
}
|
|
if (memcmp(title, z2, 2) == 0) {
|
|
// final check, if still empty, use english
|
|
// in case there is some text after the zeroes (unlikely)
|
|
parse_banner_title(banner, title, CONF_LANG_ENGLISH);
|
|
}
|
|
}
|
|
|
|
}
|
|
if (getSound) parse_banner_snd(banner, snd);
|
|
SAFE_FREE(banner);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef FAKE_GAME_LIST
|
|
|
|
#include <malloc.h>
|
|
#include "wbfs.h"
|
|
|
|
// initial/max game list size
|
|
int fake_games = 200;
|
|
//int fake_games = 0;
|
|
|
|
// current game list size
|
|
int fake_num = 0;
|
|
|
|
struct discHdr *fake_list = NULL;
|
|
|
|
int is_fake(char *id)
|
|
{
|
|
int i;
|
|
for (i=0; i<fake_num; i++) {
|
|
// ignore region, check only first 5
|
|
if (strncmp((char*)fake_list[i].id, (char*)id, 5) == 0) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
// WBFS_GetCount
|
|
s32 dbg_WBFS_GetCount(u32 *count)
|
|
{
|
|
DIR *dir;
|
|
struct dirent *dent;
|
|
char id[8], *p;
|
|
int ret, cnt, len;
|
|
|
|
fake_num = 0;
|
|
SAFE_FREE(fake_list);
|
|
if (fake_games < 0) fake_games = 0;
|
|
|
|
// first get the real list, then add fake entries
|
|
ret = WBFS_GetCount((u32*)&cnt);
|
|
if (ret >= 0) {
|
|
len = sizeof(struct discHdr) * cnt;
|
|
fake_list = (struct discHdr *)memalign(32, len);
|
|
if (!fake_list) return -1;
|
|
memset(fake_list, 0, len);
|
|
ret = WBFS_GetHeaders(fake_list, cnt, sizeof(struct discHdr));
|
|
if (ret >= 0) fake_num = cnt;
|
|
//printf("real games num: %d\n", fake_num); sleep(2);
|
|
}
|
|
if (fake_num > fake_games) fake_num = fake_games;
|
|
|
|
//printf("fake dir: %s\n", CFG.covers_path); sleep(1);
|
|
dir = opendir(CFG.covers_path);
|
|
if (!dir) {
|
|
printf("fake dir error! %s\n", CFG.covers_path); sleep(2);
|
|
return 0;
|
|
}
|
|
|
|
while ((dent = readdir(dir)) != NULL) {
|
|
if (fake_num >= fake_games) break;
|
|
if (dent->d_name[0] == '.') continue;
|
|
if (strstr(dent->d_name, ".png") == NULL
|
|
&& strstr(dent->d_name, ".PNG") == NULL) continue;
|
|
memset(id, 0, sizeof(id));
|
|
STRCOPY(id, dent->d_name);
|
|
p = strchr(id, '.');
|
|
if (p == NULL) continue;
|
|
*p = 0;
|
|
// check if already exists, do not ignore region, we want more games ;)
|
|
if (is_fake(id)) continue;
|
|
fake_list = realloc(fake_list, sizeof(struct discHdr) * (fake_num+1));
|
|
memset(fake_list+fake_num, 0, sizeof(struct discHdr));
|
|
memcpy(fake_list[fake_num].id, id, sizeof(fake_list[fake_num].id));
|
|
STRCOPY(fake_list[fake_num].title, dent->d_name);
|
|
//printf("fake %d %.6s %s\n", fake_num,
|
|
// fake_list[fake_num].id, fake_list[fake_num].title);
|
|
fake_num++;
|
|
|
|
}
|
|
closedir(dir);
|
|
//sleep(2);
|
|
*count = fake_num;
|
|
return 0;
|
|
}
|
|
#else
|
|
// WBFS_GetCount
|
|
|
|
void add_fake(char *name, char *val)
|
|
{
|
|
char id[8];
|
|
if (fake_num >= fake_games) return;
|
|
// is ID?
|
|
if (strlen(name) != 6) return;
|
|
memset(id, 0, sizeof(id));
|
|
STRCOPY(id, name);
|
|
// check if already exists, do not ignore region, we want more games
|
|
if (is_fake(id)) return;
|
|
fake_list = realloc(fake_list, sizeof(struct discHdr) * (fake_num+1));
|
|
memset(fake_list+fake_num, 0, sizeof(struct discHdr));
|
|
memcpy(fake_list[fake_num].id, id, sizeof(fake_list[fake_num].id));
|
|
STRCOPY(fake_list[fake_num].title, val);
|
|
//printf("fake %d %.6s %s\n", fake_num,
|
|
// fake_list[fake_num].id, fake_list[fake_num].title);
|
|
fake_num++;
|
|
}
|
|
|
|
s32 dbg_WBFS_GetCount(u32 *count)
|
|
{
|
|
char fname[100];
|
|
|
|
fake_num = 0;
|
|
SAFE_FREE(fake_list);
|
|
if (fake_games < 0) fake_games = 0;
|
|
sprintf(fname, "%s/%s", USBLOADER_PATH, "gamelist2.txt");
|
|
printf("fake list: %s\n", fname); sleep(1);
|
|
cfg_parsefile(fname, add_fake);
|
|
//add_fake("RHAP01", "wii play");
|
|
*count = fake_num;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
// WBFS_GetHeaders
|
|
s32 dbg_WBFS_GetHeaders(void *outbuf, u32 cnt, u32 len)
|
|
{
|
|
memcpy(outbuf, fake_list, cnt*len);
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|