void Speedtest_Run(GUI_Widget *widget) {
uint8 *buff = (uint8*)0x8c400000;
size_t buff_size = 0x10000;
int size = 0x800000, cnt = 0, rs;
int64 time_before, time_after;
uint32 t;
double speed;
file_t fd;
int read_only = 0;
char name[64];
char result[128];
const char *wname = GUI_ObjectGetName((GUI_Object *)widget);
if(!strncasecmp(wname, "/cd", 3)) {
read_only = 1;
snprintf(name, sizeof(name), "%s/1DS_CORE.BIN", wname);
if(FileExists(name)) {
goto readtest;
} else {
snprintf(name, sizeof(name), "%s/1ST_READ.BIN", wname);
goto readtest;
}
}
show_status_ok("Testing WRITE speed...");
GUI_LabelSetText(self.speedwr, "...");
GUI_LabelSetText(self.speedrd, " ");
snprintf(name, sizeof(name), "%s/%s.tst", wname, lib_get_name());
if(FileExists(name)) {
fs_unlink(name);
}
/* WRITE TEST */
fd = fs_open(name, O_CREAT | O_WRONLY);
if (fd == FILEHND_INVALID) {
ds_printf("DS_ERROR: Can't open %s for write: %d\n", name, errno);
show_status_error("Can't open file for write");
return;
}
ShutdownVideoThread();
time_before = timer_ms_gettime64();
while(cnt < size) {
rs = fs_write(fd, buff, buff_size);
if(rs <= 0) {
fs_close(fd);
InitVideoThread();
ds_printf("DS_ERROR: Can't write to file: %d\n", errno);
show_status_error("Can't write to file");
return;
}
buff += rs;
cnt += rs;
}
time_after = timer_ms_gettime64();
InitVideoThread();
t = (uint32)(time_after - time_before);
speed = size / ((float)t / 1000);
fs_close(fd);
snprintf(result, sizeof(result),
"Write speed %.2f Kbytes/s (%.2f Mbit/s) Time: %ld ms",
speed / 1024, ((speed / 1024) / 1024) * 8, t);
GUI_LabelSetText(self.speedwr, result);
show_status_ok("Complete!");
ds_printf("DS_OK: Complete!\n"
" Test: write\n Time: %ld ms\n"
" Speed: %.2f Kbytes/s (%.2f Mbit/s)\n"
" Size: %d Kb\n Buff: %d Kb\n",
t, speed / 1024,
((speed / 1024) / 1024) * 8,
size / 1024, buff_size / 1024);
readtest:
show_status_ok("Testing READ speed...");
GUI_LabelSetText(self.speedrd, "...");
/* READ TEST */
fd = fs_open(name, O_RDONLY);
if (fd == FILEHND_INVALID) {
ds_printf("DS_ERROR: Can't open %s for read: %d\n", name, errno);
show_status_error("Can't open file for read");
return;
}
if(read_only) {
GUI_LabelSetText(self.speedwr, "Write test passed");
/* Reset ISO9660 filesystem cache */
fs_ioctl(fd, NULL, 0);
fs_close(fd);
fd = fs_open(name, O_RDONLY);
}
time_before = time_after = t = cnt = 0;
speed = 0.0f;
size = fs_total(fd);
buff = rd_buff;
ShutdownVideoThread();
time_before = timer_ms_gettime64();
while(cnt < size) {
rs = fs_read(fd, buff, buff_size);
if(rs <= 0) {
fs_close(fd);
InitVideoThread();
ds_printf("DS_ERROR: Can't read file: %d\n", errno);
show_status_error("Can't read file");
return;
}
cnt += rs;
}
time_after = timer_ms_gettime64();
t = (uint32)(time_after - time_before);
speed = size / ((float)t / 1000);
fs_close(fd);
if(!read_only) {
fs_unlink(name);
} else {
cdrom_spin_down();
}
snprintf(result, sizeof(result),
"Read speed %.2f Kbytes/s (%.2f Mbit/s) Time: %ld ms",
speed / 1024, ((speed / 1024) / 1024) * 8, t);
InitVideoThread();
ds_printf("DS_OK: Complete!\n"
" Test: read\n Time: %ld ms\n"
" Speed: %.2f Kbytes/s (%.2f Mbit/s)\n"
" Size: %d Kb\n Buff: %d Kb\n",
t, speed / 1024,
((speed / 1024) / 1024) * 8,
size / 1024, buff_size / 1024);
GUI_LabelSetText(self.speedrd, result);
show_status_ok("Complete!");
}
BOOL usb_remove_safely_by_hotkey()
{
int disk_num, tot_disk_num = 0;
char disk_name[8];
int ret;
UINT32 choice;
UINT8 disk_sel;
UINT8 back_saved;
POBJECT_HEAD topmenu;
ret = dm_ioctl(DM_CMD1_GET_DISK_NUM, DM_CMD_PARAM(MNT_TYPE_USB, 0, 0), &disk_num, sizeof(int));
if (ret == 0 && disk_num > 0)
tot_disk_num += disk_num;
ret = dm_ioctl(DM_CMD1_GET_DISK_NUM, DM_CMD_PARAM(MNT_TYPE_SD, 0, 0), &disk_num, sizeof(int));
if (ret == 0 && disk_num > 0)
tot_disk_num += disk_num;
ret = dm_ioctl(DM_CMD1_GET_DISK_NUM, DM_CMD_PARAM(MNT_TYPE_SATA, 0, 0), &disk_num, sizeof(int));
if (ret == 0 && disk_num > 0)
tot_disk_num += disk_num;
if (tot_disk_num <= 0)
{
return TRUE;
}
api_inc_wnd_count();
ID timer_id = win_compopup_start_send_key_timer(V_KEY_EXIT, 10000, TIMER_ALARM); // exit popup if no action in 5s
choice = win_disk_operate_open(OPERATE_TYPE_DISK_REMOVE, &disk_sel);
api_stop_timer(&timer_id);
if ((topmenu = menu_stack_get_top()) != NULL)
OSD_TrackObject(topmenu, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
if (!choice)
{
api_dec_wnd_count();
return TRUE;
}
else
{
win_removable_disk_get_name_str(disk_sel, disk_name);
}
#ifdef DVR_PVR_SUPPORT
enum PVR_DISKMODE pvr_mode;
char rec_vol[16], tms_vol[16];
struct statvfs buf;
pvr_mode = pvr_get_cur_mode(rec_vol, tms_vol);
if (api_pvr_is_record_active() && (STRLEN(rec_vol) == 9) &&
(strncmp(disk_name, &rec_vol[5], 3) == 0))
{
win_compopup_init(WIN_POPUP_TYPE_OK);
win_compopup_set_msg("USB safely remove error, please stop recording first!", NULL, 0);
win_compopup_open_ext(&back_saved);
api_dec_wnd_count();
return TRUE;
}
if (api_pvr_is_playing())
{
BOOL b_can_remove = TRUE;
if ((pvr_info.pvr_state == PVR_STATE_TMS_PLAY) &&
(STRLEN(tms_vol) == 9) && (strncmp(disk_name, &tms_vol[5], 3) == 0))
{
b_can_remove = FALSE;
}
else if ((pvr_info.pvr_state != PVR_STATE_TMS_PLAY) &&
(STRLEN(rec_vol) == 9) && (strncmp(disk_name, &rec_vol[5], 3) == 0))
{
b_can_remove = FALSE;
}
if (!b_can_remove)
{
win_compopup_init(WIN_POPUP_TYPE_OK);
win_compopup_set_msg("USB safely remove error, please stop playing first!", NULL, 0);
win_compopup_open_ext(&back_saved);
api_dec_wnd_count();
return TRUE;
}
}
if (pvr_info.pvr_state == PVR_STATE_TMS)
{
api_pvr_tms_proc(FALSE);
fs_sync(tms_vol);
}
#endif
#ifdef USB_SUPPORT_HUB
/* remove disk */
int disk_type = diskNamePrefix2Type(disk_name);
if (disk_type == MNT_TYPE_USB)
{
char dev_path[16];
int node_id, fd;
sprintf(dev_path, "/dev/%s", disk_name);
fd = fs_open(dev_path, O_RDONLY, 0);
ret = fs_ioctl(fd, IOCTL_GET_NODEID, &node_id, sizeof(int));
fs_close(fd);
if (ret == 0)
usbd_safely_remove_ex(node_id);
}
#ifdef SDIO_SUPPORT
else if (disk_type == MNT_TYPE_SD)
{
sd_notify(0);
}
#endif
#ifdef SATA_SUPPORT
else if (disk_type == MNT_TYPE_SATA)
{
sata_notify(0, 0);
}
#endif
#else
usbd_safely_remove();
#endif
api_dec_wnd_count();
return TRUE;
}
static int dm_update(UINT32 dev_type, UINT32 dev_id)
{
char disk_name[8];
char dev_path[16];
char vol_path[16];
DiskInfo *p_disk = NULL;
DiskInfo **pp_disk = NULL;
int ret = -1;
if (((dev_type == MNT_TYPE_USB) && (dev_id >= MAX_USB_DISK_NUM)) ||
((dev_type == MNT_TYPE_SD) && (dev_id >= MAX_SD_DISK_NUM)) ||
((dev_type == MNT_TYPE_SATA) && (dev_id >= MAX_SATA_DISK_NUM)) ||
((dev_type == MNT_TYPE_IDE) && (dev_id >= MAX_IDE_DISK_NUM)))
{
DM_ERROR("Unsupport device (%d, %d)\n", dev_type, dev_id);
return ret;
}
DM_DEBUG("DM update device (%d, %d)\n", dev_type, dev_id);
DMLock();
do {
switch (dev_type)
{
case MNT_TYPE_USB:
sprintf(disk_name, "ud%c", dev_id+'a');
pp_disk = &g_dm.UsbDisks[dev_id];
break;
case MNT_TYPE_SD:
sprintf(disk_name, "sd%c", dev_id+'a');
pp_disk = &g_dm.SdDisks[dev_id];
break;
case MNT_TYPE_IDE:
sprintf(disk_name, "hd%c", dev_id+'a');
pp_disk = &g_dm.IdeDisks[dev_id];
break;
case MNT_TYPE_SATA:
sprintf(disk_name, "sh%c", dev_id+'a');
pp_disk = &g_dm.SataDisks[dev_id];
break;
default:
disk_name[0] = 0;
break;
}
if (disk_name[0] == 0)
{
DM_DEBUG("Unknown device (%d, %d)\n", dev_type, dev_id);
break;
}
if (*pp_disk != NULL)
{
#if (DM_DEBUG_LEVEL & DM_DEBUG_MALLOC_FREE)
dm_malloc_cnt--;
#endif
FREE(*pp_disk);
*pp_disk = NULL;
}
if ((p_disk = (DiskInfo *)MALLOC(sizeof(DiskInfo))) == NULL)
{
#if (DM_DEBUG_LEVEL & DM_DEBUG_MALLOC_FREE)
dm_malloc_cnt++;
#endif
DM_DEBUG("Memory exhausted!\n", dev_type, dev_id);
break;
}
MEMSET(p_disk, 0, sizeof(DiskInfo));
sprintf(dev_path, "/dev/%s", disk_name);
int fd, fd_dir;
device_geometry geo;
char dirbuf[sizeof(struct dirent) + 32];
struct dirent *pdir = (struct dirent *)dirbuf;
/* get disk info */
fd = fs_open(dev_path, O_RDONLY, 0);
if (fd < 0)
{
DM_DEBUG("device %s not exist!\n", dev_path);
break;
}
if (fs_ioctl(fd, IOCTL_GET_DEVICE_GEOMETRY, &geo, sizeof(struct device_geometry)) < 0)
{
fs_close(fd);
break;
}
p_disk->DiskSize = geo.sector_count * geo.bytes_per_sector;
fs_close(fd);
if ((fd_dir = fs_opendir("/dev")) < 0)
{
DM_DEBUG("open /dev failed!\n");
break;
}
ret = 0; /* get necessary disk info successfully */
int part_idx;
while (fs_readdir(fd_dir, pdir) > 0)
{
/* find partitions */
if ((STRLEN(pdir->d_name) == 4) && (strncmp(pdir->d_name, disk_name, 3) == 0))
{
part_idx = pdir->d_name[3] - '1';
if ((part_idx < 0) || (part_idx >= MAX_PARTS_IN_DISK))
{
continue;
}
sprintf(dev_path, "/dev/%s", pdir->d_name);
sprintf(vol_path, "/mnt/%s", pdir->d_name);
/* get part info */
fd = fs_open(dev_path, O_RDONLY, 0);
if (fs_ioctl(fd, IOCTL_GET_DEVICE_GEOMETRY, &geo, sizeof(struct device_geometry)) < 0)
{
fs_close(fd);
continue;
}
fs_close(fd);
p_disk->parts[part_idx].PartExist = 1;
p_disk->parts[part_idx].FileSystemType = dm_get_fs_type(vol_path);
p_disk->parts[part_idx].PartSize = geo.sector_count * geo.bytes_per_sector;
p_disk->part_num++;
if (p_disk->parts[part_idx].FileSystemType != PED_FS_TYPE_NONE)
p_disk->vol_num++;
}
}
fs_closedir(fd_dir);
} while(0);
if (ret == 0)
{
*pp_disk = p_disk;
// p_disk = NULL;
}
else if (p_disk != NULL)
{
#if (DM_DEBUG_LEVEL & DM_DEBUG_MALLOC_FREE)
dm_malloc_cnt--;
#endif
FREE(p_disk);
}
DMUnlock();
return ret;
}
BOOL usb_remove_safely_by_hotkey()
{
UINT8 back_saved;
// if(!storage_usb_menu_item_ready())
// return FALSE;
#ifdef DVR_PVR_SUPPORT
if(api_pvr_is_record_active())
{
win_compopup_init(WIN_POPUP_TYPE_OK);
win_compopup_set_msg("USB safely remove error, please stop recording first!", NULL, 0);
win_compopup_open_ext(&back_saved);
return TRUE;
}
else if(api_pvr_is_playing())
{
win_compopup_init(WIN_POPUP_TYPE_OK);
win_compopup_set_msg("USB safely remove error, please stop playing first!", NULL, 0);
win_compopup_open_ext(&back_saved);
return TRUE;
}
else if(pvr_info.pvr_state == PVR_STATE_TMS)
{
api_pvr_tms_proc(FALSE);
}
#endif
win_compopup_init(WIN_POPUP_TYPE_OKNO);
win_compopup_set_msg("Are you sure to remove USB device safely!", NULL, 0);
win_compopup_set_default_choice(WIN_POP_CHOICE_NO);
win_popup_choice_t choice = win_compopup_open_ext(&back_saved);
if(choice == WIN_POP_CHOICE_YES)
{
//api_usb_device_safely_remove();
#ifdef USB_SUPPORT_HUB
/* remove disk */
char disk_name[8];
int ret;
int disk_type = diskNamePrefix2Type(disk_name);
if (disk_type == MNT_TYPE_USB)
{
char dev_path[16];
int node_id, fd;
sprintf(dev_path, "/dev/%s", disk_name);
fd = fs_open(dev_path, O_RDONLY, 0);
ret = fs_ioctl(fd, IOCTL_GET_NODEID, &node_id, sizeof(int));
fs_close(fd);
if (ret == 0)
usbd_safely_remove_ex(node_id);
}
#ifdef SDIO_SUPPORT
else if (disk_type == MNT_TYPE_SD)
{
sd_notify(0);
}
#endif
#ifdef SATA_SUPPORT
else if (disk_type == MNT_TYPE_SATA)
{
sata_notify(0, 0);
}
#endif
#else
usbd_safely_remove();
#endif
api_dec_wnd_count();
}
return TRUE;
}
int fs_iso_map2dev(const char *filename, kos_blockdev_t *dev) {
file_t fd, fdi;
uint8 *data;
uint32 image_type = 0;
uint32 image_hdr = 0;
uint32 total_length = 0;
uint32 lba = 150;
uint32 sector = lba;
const char mp[] = "/ifsm2d";
if(dev->init(dev) < 0) {
ds_printf("DS_ERROR: Can't initialize device\n");
return -1;
}
if(fs_iso_mount(mp, filename) < 0) {
return -1;
}
fd = fs_iso_first_file(mp);
if(fd == FILEHND_INVALID) {
ds_printf("DS_ERROR: Can't open first file\n");
fs_iso_unmount(mp);
return -1;
}
fs_ioctl(fd, &image_type, ISOFS_IOCTL_GET_IMAGE_TYPE);
fs_ioctl(fd, &image_hdr, ISOFS_IOCTL_GET_IMAGE_HEADER_PTR);
fs_ioctl(fd, &fdi, ISOFS_IOCTL_GET_IMAGE_FD);
fs_ioctl(fd, &lba, ISOFS_IOCTL_GET_DATA_TRACK_LBA);
fs_ioctl(fd, &total_length, ISOFS_IOCTL_GET_TRACK_SECTOR_COUNT);
fs_close(fd);
total_length += lba;
data = memalign(32, SECBUF_COUNT * 2048);
if(data == NULL) {
ds_printf("DS_ERROR: No free memory\n");
fs_iso_unmount(mp);
return -1;
}
memset_sh4(data, 0, SECBUF_COUNT * 2048);
for(sector = lba; sector < total_length; sector += SECBUF_COUNT) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: read from %ld\n", __func__, sector);
#endif
switch(image_type) {
case ISOFS_IMAGE_TYPE_CSO:
case ISOFS_IMAGE_TYPE_ZSO:
ciso_read_sectors((CISO_header_t*)image_hdr, fdi, data, sector, SECBUF_COUNT);
break;
case ISOFS_IMAGE_TYPE_CDI:
cdi_read_sectors((CDI_header_t*)image_hdr, fdi, data, sector, SECBUF_COUNT);
break;
case ISOFS_IMAGE_TYPE_GDI:
gdi_read_sectors((GDI_header_t*)image_hdr, data, sector, SECBUF_COUNT);
break;
case ISOFS_IMAGE_TYPE_ISO:
default:
fs_seek(fdi, ((sector - lba) * 2048), SEEK_SET);
fs_read(fdi, data, SECBUF_COUNT * 2048);
break;
}
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: write to %ld\n", __func__, (sector - lba) * 4);
#endif
if(dev->write_blocks(dev, (sector - lba) * 4, SECBUF_COUNT * 4, data) < 0) {
ds_printf("DS_ERROR: Can't write to device\n");
break;
}
}
dev->flush(dev);
fs_iso_unmount(mp);
return 0;
}
