void Ps2File::cacheReadAhead() {
if (_cacheOpRunning) {
// there's already some cache read running
if (fio.poll(_fd)) // did it finish?
cacheReadSync(); // yes.
}
if ((!_cacheOpRunning) && ((_readBytesBlock >= CACHE_READ_THRESHOLD) || _stream) && fio.fioAvail()) {
// the engine seems to do sequential reads and there are no other I/Os going on. read ahead.
uint32 cachePosEnd = _cachePos + _bytesInCache;
if (_cachePos > _filePos)
return; // there was a seek in the meantime, don't cache.
if (cachePosEnd - _filePos >= CACHE_FILL_MIN)
return; // cache is full enough.
if (cachePosEnd == _fileSize)
return; // can't read beyond EOF.
assert(cachePosEnd < _fileSize);
if (_cachePos + _bytesInCache <= _filePos) {
_cacheOfs = _bytesInCache = 0;
_cachePos = cachePosEnd = _filePos & ~READ_ALIGN_MASK;
assert(_filePos == _physFilePos);
} else {
uint32 cacheDiff = _filePos - _cachePos;
assert(_bytesInCache >= cacheDiff);
cacheDiff &= ~READ_ALIGN_MASK;
_bytesInCache -= cacheDiff;
_cachePos += cacheDiff;
_cacheOfs = (_cacheOfs + cacheDiff) % CACHE_SIZE;
}
if (_physFilePos != cachePosEnd) {
sioprintf("unexpected _physFilePos %d cache %d %d\n", _physFilePos, _cacheOfs, _bytesInCache);
// assert(!(cachePosEnd & READ_ALIGN_MASK)); // romeo
_physFilePos = fio.seek(_fd, cachePosEnd, SEEK_SET);
if (_physFilePos != cachePosEnd) {
sioprintf("cache seek error: seek to %d instead of %d, fs = %d\n", _physFilePos, cachePosEnd, _fileSize);
return;
}
}
uint32 cacheDest = (_cacheOfs + _bytesInCache) % CACHE_SIZE;
uint32 cacheRead = CACHE_SIZE - _bytesInCache;
if (cacheDest + cacheRead > CACHE_SIZE)
cacheRead = CACHE_SIZE - cacheDest;
if (cacheRead > MAX_READ_STEP)
cacheRead = MAX_READ_STEP;
assert((!(cacheRead & READ_ALIGN_MASK)) && cacheRead);
_cacheOpRunning = true;
fio.read(_fd, _cacheBuf + cacheDest, cacheRead);
}
}
PS2Device detectBootPath(const char *elfPath, char *bootPath) {
PS2Device device = _getDev(elfPath);
sioprintf("elf path: %s, device %d\n", elfPath, device);
strcpy(bootPath, elfPath);
char *pathPos = bootPath;
char seperator;
if (device == CD_DEV) {
// CDVD uses '\' as seperator
while (*pathPos) {
if (*pathPos == '/')
*pathPos = '\\';
pathPos++;
}
seperator = '\\';
} else {
// all the other devices use '/'
while (*pathPos) {
if (*pathPos == '\\')
*pathPos = '/';
pathPos++;
}
seperator = '/';
}
pathPos = strrchr(bootPath, seperator);
if (!pathPos)
pathPos = strchr(bootPath, ':');
if (pathPos) {
if ((pathPos[0] == ':') && (device == CD_DEV)) {
pathPos[1] = '\\';
pathPos[2] = '\0';
} else
pathPos[1] = '\0';
sioprintf("done. IRX path: \"%s\"\n", bootPath);
} else {
sioprintf("path not recognized, default to host.\n");
strcpy(bootPath, "host:");
device = HOST_DEV; // UNKNOWN;
}
return device;
}
void AsyncFio::close(int handle) {
WaitSema(_ioSema);
checkSync();
fileXioClose(handle);
int res;
fileXioWaitAsync(FXIO_WAIT, &res);
if (res != 0)
sioprintf("ERROR: fileXioClose failed, EC %d", res);
_ioSlots[handle] = 0;
SignalSema(_ioSema);
}
void AsyncFio::dclose(int fd) {
int res;
WaitSema(_ioSema);
checkSync();
fileXioDclose(fd);
fileXioWaitAsync(FXIO_WAIT, &res);
//assert(res == 0);
dbg_printf("FIO: dclose(%d) => %d\n", fd, res);
if (res != 0)
sioprintf("ERROR: fileXioDclose failed, EC %d\n", res);
SignalSema(_ioSema);
}
int ps2_fprintf(FILE *pOut, const char *zFormat, ...) {
va_list ap;
char resStr[2048];
va_start(ap,zFormat);
int res = vsnprintf(resStr, 2048, zFormat, ap);
va_end(ap);
if ((pOut == stderr) || (pOut == stdout)) {
printf("%s", resStr);
sioprintf("%s", resStr);
} else
res = ps2_fwrite(resStr, 1, res, pOut);
return res;
}
void OSystem_PS2::readRtcTime(void) {
struct CdClock cdClock;
readRTC(&cdClock);
g_lastTimeCheck = getMillis();
if (cdClock.stat) {
msgPrintf(5000, "Unable to read RTC time, EC: %d\n", cdClock.stat);
g_day = g_month = 1;
g_year = 0;
g_timeSecs = 0;
} else {
int gmtOfs = configGetTimezone();
if (configIsDaylightSavingEnabled())
gmtOfs += 60;
int timeSecs = (FROM_BCD(cdClock.hour) * 60 + FROM_BCD(cdClock.minute)) * 60 + FROM_BCD(cdClock.second);
timeSecs -= 9 * 60 * 60; // minus 9 hours, JST -> GMT conversion
timeSecs += gmtOfs * 60; // GMT -> timezone the user selected
g_day = FROM_BCD(cdClock.day);
g_month = FROM_BCD(cdClock.month);
g_year = FROM_BCD(cdClock.year);
if (timeSecs < 0) {
buildNewDate(-1);
timeSecs += SECONDS_PER_DAY;
} else if (timeSecs >= SECONDS_PER_DAY) {
buildNewDate(+1);
timeSecs -= SECONDS_PER_DAY;
}
g_timeSecs = (uint32)timeSecs;
}
sioprintf("Time: %d:%02d:%02d - %d.%d.%4d\n", g_timeSecs / (60 * 60), (g_timeSecs / 60) % 60, g_timeSecs % 60,
g_day, g_month, g_year + 2000);
}
int loadIrxModules(int device, const char *irxPath, IrxReference **modules) {
IrxReference *resModules = (IrxReference *)malloc(numIrxFiles * sizeof(IrxReference));
IrxReference *curModule = resModules;
for (int i = 0; i < numIrxFiles; i++) {
curModule->fileRef = irxFiles + i;
if ((device == HOST_DEV) && (irxFiles[i].flags & NOT_HOST))
continue;
if ((irxFiles[i].flags & TYPEMASK) == BIOS) {
curModule->loc = IRX_FILE;
curModule->path = (char *)malloc(32);
sprintf(curModule->path, "rom0:%s", irxFiles[i].name);
curModule->buffer = NULL;
curModule->size = 0;
curModule->argSize = 0;
curModule->args = NULL;
curModule->errorCode = 0;
} else {
curModule->loc = IRX_BUFFER;
curModule->path = (char *)malloc(256);
sprintf(curModule->path, "%s%s%s", irxPath, irxFiles[i].name, (device == CD_DEV) ? ";1" : "");
int fd = fioOpen(curModule->path, O_RDONLY);
if (fd < 0) {
// IRX not found
sioprintf("Can't open %s: %d\n", curModule->path, fd);
// we keep the error code of the path where we originally expected the file
curModule->errorCode = fd;
// try cdrom root directory
sprintf(curModule->path, "cdrom0:\\%s;1", irxFiles[i].name);
fd = fioOpen(curModule->path, O_RDONLY);
if (fd < 0) {
// still not found, try host:
sioprintf("Can't open %s: %d\n", curModule->path, fd);
sprintf(curModule->path, "host:%s", irxFiles[i].name);
fd = fioOpen(curModule->path, O_RDONLY);
if (fd < 0) {
// we simply can't find it.
sioprintf("Can't open %s: %d\n", curModule->path, fd);
// restore the path where we originally expected the file, for error message (later, after boot up)
sprintf(curModule->path, "%s%s%s", irxPath, irxFiles[i].name, (device == CD_DEV) ? ";1" : "");
}
}
}
if (fd >= 0) {
curModule->size = fioLseek(fd, 0, SEEK_END);
fioLseek(fd, 0, SEEK_SET);
curModule->buffer = (uint8 *)memalign(64, (curModule->size + 63) & ~63);
fioRead(fd, curModule->buffer, curModule->size);
curModule->argSize = irxFiles[i].argSize;
curModule->args = irxFiles[i].args;
curModule->errorCode = 0;
fioClose(fd);
} else {
if (irxFiles[i].flags & DEPENDANCY) {
// other modules depend on this one.
// kill the modules we already loaded, if they depend on the one that failed.
IrxReference *pos = resModules;
while (pos < curModule) {
if ((pos->fileRef->flags & TYPEMASK) == (irxFiles[i].flags & TYPEMASK)) {
free(pos->path);
free(pos->buffer);
IrxReference *copyPos = pos;
while (copyPos < curModule) {
copyPos[0] = copyPos[1];
copyPos++;
}
curModule--;
} else
pos++;
}
// and skip any remaining modules that depend on the missing one, too.
while ((i < numIrxFiles - 1) && ((irxFiles[i + 1].flags & TYPEMASK) == (curModule->fileRef->flags & TYPEMASK)))
i++;
// the module that actually failed (curModule) is kept in the array for displaying an error message
}
curModule->size = 0;
curModule->buffer = NULL;
curModule->argSize = 0;
curModule->args = NULL;
}
}
curModule++;
}
*modules = resModules;
sioprintf("List of %d modules:\n", curModule - resModules);
for (int i = 0; i < curModule - resModules; i++)
sioprintf("%s\n", resModules[i].path);
return curModule - resModules;
}
uint32 Ps2ReadFile::write(const void *src, uint32 len) {
sioprintf("write request on Ps2ReadFile!");
SleepThread();
return 0;
}