DEBUG("[FSHD] Patchflags: %d Type: %d\n", BE(fhb->fhb_PatchFlags), BE(fhb->fhb_Type));
DEBUG("[FSHD] Task: %d Lock: %d\n", BE(fhb->fhb_Task), BE(fhb->fhb_Lock));
DEBUG("[FSHD] Handler: %d StackSize: %d\n", BE(fhb->fhb_Handler), BE(fhb->fhb_StackSize));
- DEBUG("[FSHD] Prio: %d Startup: %d\n", BE(fhb->fhb_Priority), BE(fhb->fhb_Startup));
+ DEBUG("[FSHD] Prio: %d Startup: %d (%.8X)\n", BE(fhb->fhb_Priority), BE(fhb->fhb_Startup), BE(fhb->fhb_Startup));
DEBUG("[FSHD] SegListBlocks: %d GlobalVec: %d\n", BE(fhb->fhb_Priority), BE(fhb->fhb_Startup));
DEBUG("[FSHD] FileSysName: %s\n", fhb->fhb_FileSysName + 1);
#endif
}
}
- printf ("Loadseg begins.\n");
if (load_lseg(d->fd, &filesystems[piscsi_num_fs].binary_data, &filesystems[piscsi_num_fs].h_info, filesystems[piscsi_num_fs].relocs, d->block_size) != -1) {
filesystems[piscsi_num_fs].FS_ID = fhb->fhb_DosType;
filesystems[piscsi_num_fs].fhb = fhb;
printf("[FSHD] Loaded and set up file system %d: %c%c%c/%d\n", piscsi_num_fs + 1, dosID[0], dosID[1], dosID[2], dosID[3]);
+ {
+ char fs_save_filename[256];
+ memset(fs_save_filename, 0x00, 256);
+ sprintf(fs_save_filename, "./data/fs/%c%c%c.%d", dosID[0], dosID[1], dosID[2], dosID[3]);
+ FILE *save_fs = fopen(fs_save_filename, "rb");
+ if (save_fs == NULL) {
+ save_fs = fopen(fs_save_filename, "wb+");
+ if (save_fs != NULL) {
+ fwrite(filesystems[piscsi_num_fs].binary_data, filesystems[piscsi_num_fs].h_info.byte_size, 1, save_fs);
+ fclose(save_fs);
+ printf("[FSHD] File system %c%c%c/%d saved to fs storage.\n", dosID[0], dosID[1], dosID[2], dosID[3]);
+ } else {
+ printf("[FSHD] Failed to save file system to fs storage. (Permission issues?)\n");
+ }
+ } else {
+ fclose(save_fs);
+ }
+ }
piscsi_num_fs++;
}
void piscsi_debugme(uint32_t index) {
switch (index) {
DEBUGME_SIMPLE(1, "[PISCSI-DEBUGME] Arrived at DiagEntry.\n");
+ DEBUGME_SIMPLE(2, "[PISCSI-DEBUGME] Arrived at BootEntry, for some reason.\n");
DEBUGME_SIMPLE(3, "[PISCSI-DEBUGME] Init: Interrupt disable.\n");
DEBUGME_SIMPLE(4, "[PISCSI-DEBUGME] Init: Copy/reloc driver.\n");
DEBUGME_SIMPLE(5, "[PISCSI-DEBUGME] Init: InitResident.\n");
DEBUGME_SIMPLE(10, "[PISCSI-DEBUGME] Init: AllocMem for resident.\n");
DEBUGME_SIMPLE(11, "[PISCSI-DEBUGME] Init: Checking if resident is loaded.\n");
DEBUGME_SIMPLE(22, "[PISCSI-DEBUGME] Arrived at BootEntry.\n");
- DEBUGME_SIMPLE(30, "[PISCSI-DEBUGME] LoadFileSystems: Opening FileSystem.resource.\n");
+ case 30:
+ DEBUG("[PISCSI-DEBUGME] LoadFileSystems: Opening FileSystem.resource.\n");
+ rom_cur_fs = 0;
+ break;
DEBUGME_SIMPLE(33, "[PISCSI-DEBUGME] FileSystem.resource not available, creating.\n");
case 31:
DEBUG("[PISCSI-DEBUGME] OpenResource result: %d\n", piscsi_u32[0]);
case 32:
DEBUG("AAAAHH!\n");
break;
+ case 35:
+ DEBUG("[PISCSI-DEBUGME] stuff output\n");
+ break;
+ case 36:
+ DEBUG("[PISCSI-DEBUGME] Debug pointers: %.8X %.8X %.8X %.8X\n", piscsi_u32[0], piscsi_u32[1], piscsi_u32[2], piscsi_u32[3]);
+ break;
default:
DEBUG("[!!!PISCSI-DEBUGME] No debugme message for index %d!\n", index);
break;
void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
int32_t r;
+ uint8_t *map;
#ifndef PISCSI_DEBUG
if (type) {}
#endif
lseek64(d->fd, src, SEEK_SET);
}
- r = get_mapped_item_by_address(cfg, piscsi_u32[2]);
- if (r != -1 && cfg->map_type[r] == MAPTYPE_RAM) {
+ map = get_mapped_data_pointer_by_address(cfg, piscsi_u32[2]);
+ if (map) {
DEBUG_TRIVIAL("[PISCSI-%d] \"DMA\" Read goes to mapped range %d.\n", val, r);
- read(d->fd, cfg->map_data[r] + piscsi_u32[2] - cfg->map_offset[r], piscsi_u32[1]);
+ read(d->fd, map, piscsi_u32[1]);
}
else {
DEBUG_TRIVIAL("[PISCSI-%d] No mapped range found for read.\n", val);
lseek64(d->fd, src, SEEK_SET);
}
- r = get_mapped_item_by_address(cfg, piscsi_u32[2]);
- if (r != -1) {
+ map = get_mapped_data_pointer_by_address(cfg, piscsi_u32[2]);
+ if (map) {
DEBUG_TRIVIAL("[PISCSI-%d] \"DMA\" Write comes from mapped range %d.\n", val, r);
- write(d->fd, cfg->map_data[r] + piscsi_u32[2] - cfg->map_offset[r], piscsi_u32[1]);
+ write(d->fd, map, piscsi_u32[1]);
}
else {
DEBUG_TRIVIAL("[PISCSI-%d] No mapped range found for write.\n", val);
break;
}
case PISCSI_CMD_DRVNUM:
- //printf("%d ", val);
- if (val % 10 != 0)
+ if (val % 10 != 0) {
piscsi_cur_drive = 255;
+ }
else
piscsi_cur_drive = val / 10;
- if (piscsi_cur_drive > NUM_UNITS)
+ if (piscsi_cur_drive > NUM_UNITS) {
piscsi_cur_drive = 255;
-
+ }
if (piscsi_cur_drive != 255) {
DEBUG("[PISCSI] (%s) Drive number set to %d (%d)\n", op_type_names[type], piscsi_cur_drive, val);
}
break;
+ case PISCSI_CMD_DRVNUMX:
+ piscsi_cur_drive = val;
+ DEBUG("[PISCSI] DRVNUMX: %d.\n", val);
+ break;
case PISCSI_CMD_DEBUGME:
piscsi_debugme(val);
break;
- case PISCSI_CMD_DRIVER: {
+ case PISCSI_CMD_DRIVER:
DEBUG("[PISCSI] Driver copy/patch called, destination address %.8X.\n", val);
- int r = get_mapped_item_by_address(cfg, val);
+ r = get_mapped_item_by_address(cfg, val);
if (r != -1) {
uint32_t addr = val - cfg->map_offset[r];
uint8_t *dst_data = cfg->map_data[r];
}
break;
- }
case PISCSI_CMD_NEXTPART:
DEBUG("[PISCSI] Switch partition %d -> %d\n", rom_cur_partition, rom_cur_partition + 1);
rom_cur_partition++;
r = get_mapped_item_by_address(cfg, piscsi_u32[2]);
if (r != -1) {
uint32_t addr = piscsi_u32[2] - cfg->map_offset[r];
- memset(cfg->map_data[r] + addr, 0x00, filesystems[rom_cur_fs].h_info.alloc_size);
memcpy(cfg->map_data[r] + addr, filesystems[rom_cur_fs].binary_data, filesystems[rom_cur_fs].h_info.byte_size);
filesystems[rom_cur_fs].h_info.base_offset = piscsi_u32[2];
reloc_hunks(filesystems[rom_cur_fs].relocs, cfg->map_data[r] + addr, &filesystems[rom_cur_fs].h_info);
if (r != -1) {
uint32_t addr = val - cfg->map_offset[r];
struct DeviceNode *node = (struct DeviceNode *)(cfg->map_data[r] + addr);
-#ifdef PISCSI_DEBUG
char *dosID = (char *)&rom_partition_dostype[rom_cur_partition];
-#endif
+
DEBUG("[PISCSI] Partition DOSType is %c%c%c/%d\n", dosID[0], dosID[1], dosID[2], dosID[3]);
for (i = 0; i < piscsi_num_fs; i++) {
if (rom_partition_dostype[rom_cur_partition] == filesystems[i].FS_ID) {
- node->dn_SegList = htobe32((filesystems[i].handler >> 2));
+ node->dn_SegList = htobe32(((filesystems[i].handler) >> 2));
node->dn_GlobalVec = 0xFFFFFFFF;
goto fs_found;
}
}
- DEBUG("[!!!PISCSI] Found no handler for file system!\n");
+ node->dn_GlobalVec = 0xFFFFFFFF;
+ node->dn_SegList = 0;
+ printf("[!!!PISCSI] Found no handler for file system %c%c%c/%d\n", dosID[0], dosID[1], dosID[2], dosID[3]);
fs_found:;
DEBUG("[FS-HANDLER] Next: %d Type: %.8X\n", BE(node->dn_Next), BE(node->dn_Type));
DEBUG("[FS-HANDLER] Task: %d Lock: %d\n", BE(node->dn_Task), BE(node->dn_Lock));
DEBUG("[FS-HANDLER] Handler: %d Stacksize: %d\n", BE((uint32_t)node->dn_Handler), BE(node->dn_StackSize));
- DEBUG("[FS-HANDLER] Priority: %d Startup: %d\n", BE((uint32_t)node->dn_Priority), BE(node->dn_Startup));
+ DEBUG("[FS-HANDLER] Priority: %d Startup: %d (%.8X)\n", BE((uint32_t)node->dn_Priority), BE(node->dn_Startup), BE(node->dn_Startup));
DEBUG("[FS-HANDLER] SegList: %.8X GlobalVec: %d\n", BE((uint32_t)node->dn_SegList), BE(node->dn_GlobalVec));
DEBUG("[PISCSI] Handler for partition %.8X set to %.8X (%.8X).\n", BE((uint32_t)node->dn_Name), filesystems[i].FS_ID, filesystems[i].handler);
}
break;
}
+ case PISCSI_CMD_LOADFS: {
+ DEBUG("[PISCSI] Attempt to load file system for partition %d from disk.\n", rom_cur_partition);
+ r = get_mapped_item_by_address(cfg, val);
+ if (r != -1) {
+ char *dosID = (char *)&rom_partition_dostype[rom_cur_partition];
+ filesystems[piscsi_num_fs].binary_data = NULL;
+ filesystems[piscsi_num_fs].fhb = NULL;
+ filesystems[piscsi_num_fs].FS_ID = rom_partition_dostype[rom_cur_partition];
+ filesystems[piscsi_num_fs].handler = 0;
+ if (load_fs(&filesystems[piscsi_num_fs], dosID) != -1) {
+ printf("[FSHD-Late] Loaded file system %c%c%c/%d from fs storage.\n", dosID[0], dosID[1], dosID[2], dosID[3]);
+ piscsi_u32[3] = piscsi_num_fs;
+ rom_cur_fs = piscsi_num_fs;
+ piscsi_num_fs++;
+ } else {
+ printf("[FSHD-Late] Failed to load file system %c%c%c/%d from fs storage.\n", dosID[0], dosID[1], dosID[2], dosID[3]);
+ piscsi_u32[3] = 0xFFFFFFFF;
+ }
+ }
+ break;
+ }
case PISCSI_DBG_VAL1: case PISCSI_DBG_VAL2: case PISCSI_DBG_VAL3: case PISCSI_DBG_VAL4:
case PISCSI_DBG_VAL5: case PISCSI_DBG_VAL6: case PISCSI_DBG_VAL7: case PISCSI_DBG_VAL8: {
int i = ((addr & 0xFFFF) - PISCSI_DBG_VAL1) / 4;
case PISCSI_CMD_BLOCKSIZE:
DEBUG("[PISCSI] Get block size of drive %d: %d\n", piscsi_cur_drive, devs[piscsi_cur_drive].block_size);
return devs[piscsi_cur_drive].block_size;
+ case PISCSI_CMD_GET_FS_INFO: {
+ int i = 0;
+ uint32_t val = piscsi_u32[1];
+ int32_t r = get_mapped_item_by_address(cfg, val);
+ if (r != -1) {
+#ifdef DEBUG_PISCSI
+ uint32_t addr = val - cfg->map_offset[r];
+ char *dosID = (char *)&rom_partition_dostype[rom_cur_partition];
+ DEBUG("[PISCSI-GET-FS-INFO] Partition DOSType is %c%c%c/%d\n", dosID[0], dosID[1], dosID[2], dosID[3]);
+#endif
+ for (i = 0; i < piscsi_num_fs; i++) {
+ if (rom_partition_dostype[rom_cur_partition] == filesystems[i].FS_ID) {
+ return 0;
+ }
+ }
+ }
+ return 1;
+ }
default:
DEBUG("[!!!PISCSI] WARN: Unhandled %s register read from %.8X\n", op_type_names[type], addr);
break;
projects / pistorm / blobdiff