/*

//

// Copyright (C) 2009-2023 Jean-François DEL NERO

//

// This file is part of the HxCFloppyEmulator file selector.

//

// HxCFloppyEmulator file selector may be used and distributed without restriction

// provided that this copyright statement is not removed from the file and that any

// derivative work contains the original copyright notice and the associated

// disclaimer.

//

// HxCFloppyEmulator file selector is free software; you can redistribute it

// and/or modify it under the terms of the GNU General Public License

// as published by the Free Software Foundation; either version 2

// of the License, or (at your option) any later version.

//

// HxCFloppyEmulator file selector is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

// See the GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with HxCFloppyEmulator file selector; if not, write to the Free Software

// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

//

*/

#include <stdio.h>

#include <string.h>

#include <stdint.h>

#include "keysfunc_defs.h"

#include "cfg_file.h"

#include "conf.h"

#include "ui_context.h"

#include "gui_utils.h"

#include "hxcfeda.h"

#include "hardware.h"

#include "hal.h"

#include "fat_opts.h"

#include "fat_misc.h"

#include "fat_defs.h"

#include "fat_filelib.h"

#include "fectrl.h"

#include "media_access.h"

#include "errors_def.h"

static uint32_t last_setlbabase;

extern ui_context g_ui_ctx;

volatile unsigned short io_floppy_timeout;

static const char HXC_FW_ID[]="HxCFEDA";

#ifdef CORTEX_FW_SUPPORT

static const char CORTEX_FW_ID[]="CORTEXAD";

#endif

int setlbabase(unsigned long lba)

{

int ret;

unsigned char sector[512];

direct_access_cmd_sector * dacs;

#ifdef DEBUG

dbg_printf("setlbabase : 0x%.8X\n",lba);

#endif

dacs=(direct_access_cmd_sector *)sector;

memset(&sector,0,512);

#ifdef CORTEX_FW_SUPPORT

if(g_ui_ctx.firmware_type == CORTEX_FIRMWARE)

{

strcpy(dacs->DAHEADERSIGNATURE,CORTEX_FW_ID);

}

else

{

strcpy(dacs->DAHEADERSIGNATURE,HXC_FW_ID);

}

#else

strcpy(dacs->DAHEADERSIGNATURE,HXC_FW_ID);

#endif

dacs->cmd_code=1;

dacs->parameter_0 = (unsigned char)((lba>>0)&0xFF);

dacs->parameter_1 = (unsigned char)((lba>>8)&0xFF);

dacs->parameter_2 = (unsigned char)((lba>>16)&0xFF);

dacs->parameter_3 = (unsigned char)((lba>>24)&0xFF);

dacs->parameter_4 = 0xA5;

ret = writesector( 0,(unsigned char *)&sector);

return ret;

}

#if 0

int test_cmd(unsigned long lba)

{

int ret;

unsigned char sector[512];

direct_access_cmd_sector * dacs;

#ifdef DEBUG

dbg_printf("test_cmd\n");

#endif

dacs=(direct_access_cmd_sector *)sector;

memset(&sector,0,512);

setlbabase(0xFFFFFFFF);

readsector(1,sector,1);

hxc_printf_box(&g_ui_ctx,"<%s>",sector);

setlbabase(0);

memset(&sector,0,512);

#ifdef CORTEX_FW_SUPPORT

if(g_ui_ctx.firmware_type == CORTEX_FIRMWARE)

{

strcpy(dacs->DAHEADERSIGNATURE,CORTEX_FW_ID);

}

else

{

strcpy(dacs->DAHEADERSIGNATURE,HXC_FW_ID);

}

#else

strcpy(dacs->DAHEADERSIGNATURE,HXC_FW_ID);

#endif

dacs->cmd_code = 10;

strcpy((char*)&dacs->parameter_0,"WB-3_1.ADF");

ret = writesector( 0,(unsigned char *)&sector);

return ret;

}

#endif

int test_floppy_if()

{

int ret;

unsigned char sector[512];

direct_access_status_sector * dass;

dass=(direct_access_status_sector *)sector;

last_setlbabase = 2;

do

{

ret = setlbabase( last_setlbabase );

if( ret != ERR_NO_ERROR )

return ret;

ret = readsector(0,sector,1);

if( ret != ERR_NO_ERROR )

return ret;

#ifdef DEBUG

dbg_printf("test_floppy_if : %.8X = %.8X ?\n",last_setlbabase,L_INDIAN(dass->lba_base));

#endif

if(last_setlbabase!=L_INDIAN(dass->lba_base))

{

return -ERR_LBA_CHANGE_FAILURE;

}

last_setlbabase--;

}while(last_setlbabase);

return ERR_NO_ERROR;

}

int media_init()

{

int ret;

unsigned char sector[512];

direct_access_status_sector * dass;

int i,count;

#ifdef DEBUG

dbg_printf("media_init\n");

#endif

last_setlbabase=0xFFFFF000;

ret = readsector(0,(unsigned char*)&sector,1);

g_ui_ctx.firmware_type = INVALID_FIRMWARE;

if(ret == ERR_NO_ERROR)

{

dass = (direct_access_status_sector *)sector;

if(!strcmp(dass->DAHEADERSIGNATURE,HXC_FW_ID))

{

g_ui_ctx.firmware_type = HXC_LEGACY_FIRMWARE;

i = 0;

count = 0;

if(dass->FIRMWAREVERSION[0] != 'v' && dass->FIRMWAREVERSION[0] != 'V')

{

g_ui_ctx.firmware_type = HXC_CLONE_FIRMWARE;

}

while(dass->FIRMWAREVERSION[i] && i < sizeof(dass->FIRMWAREVERSION))

{

if(dass->FIRMWAREVERSION[i] == '.')

count++;

i++;

}

if(count != 3)

g_ui_ctx.firmware_type = HXC_CLONE_FIRMWARE;

}

#ifdef CORTEX_FW_SUPPORT

if(!strncmp(dass->DAHEADERSIGNATURE,CORTEX_FW_ID,strlen(CORTEX_FW_ID)))

{

g_ui_ctx.firmware_type = CORTEX_FIRMWARE;

}

#endif

if( g_ui_ctx.firmware_type != INVALID_FIRMWARE )

{

strncpy(g_ui_ctx.FIRMWAREVERSION,dass->FIRMWAREVERSION,sizeof(g_ui_ctx.FIRMWAREVERSION));

hxc_printf(&g_ui_ctx,LEFT_ALIGNED|INVERTED,0, g_ui_ctx.screen_txt_ysize - 1,"FW %s",g_ui_ctx.FIRMWAREVERSION);

ret = test_floppy_if();

if( ret != ERR_NO_ERROR)

return ret;

dass = (direct_access_status_sector *)sector;

last_setlbabase=0;

ret = setlbabase(last_setlbabase);

if( ret != ERR_NO_ERROR )

return ret;

#ifdef DEBUG

dbg_printf("media_init : HxC FE Found\n");

#endif

return ERR_NO_ERROR;

}

#ifdef DEBUG

dbg_printf("media_init : HxC FE not detected\n");

#endif

return -ERR_BAD_DRIVE_ID;

}

#ifdef DEBUG

dbg_printf("media_init : Media access error\n");

#endif

return ret;

}

int media_access_init(int drive)

{

int ret;

io_floppy_timeout = 0;

ret = init_fdc(drive);

if( ret != ERR_NO_ERROR )

return ret;

#ifdef DEBUG

dbg_printf("init_fdc Done\n");

#endif

ret = media_init();

if( ret == ERR_NO_ERROR )

{

#ifdef DEBUG

dbg_printf("media_init done\n");

#endif

// Initialise File IO Library

fl_init();

#ifdef DEBUG

dbg_printf("fl_init done\n");

#endif

/* Attach media access functions to library*/

if (fl_attach_media(media_read, media_write) != FAT_INIT_OK)

{

return -ERR_MEDIA_ATTACH;

}

#ifdef DEBUG

dbg_printf("fl_attach_media done\n");

#endif

return ERR_NO_ERROR;

}

return ret;

}

int media_read(uint32 sector, uint8 *buffer, uint32 sector_count)

{

int ret;

uint32 i;

direct_access_status_sector * dass;

dass = (direct_access_status_sector *)buffer;

#ifdef DEBUG

dbg_printf("media_read sector : 0x%.8X, cnt : %d \n",sector,sector_count);

#endif

set_char_pos(&g_ui_ctx,g_ui_ctx.screen_txt_xsize - 1, 0);

print_char(&g_ui_ctx, 10, INVERTED);

for(i=0;i<sector_count;i++)

{

do

{

if((sector-last_setlbabase)>=8)

{

ret = setlbabase(sector);

if( ret != ERR_NO_ERROR )

return 0;

}

ret = readsector(0,buffer,0);

if( ret != ERR_NO_ERROR )

{

hxc_printf_box(&g_ui_ctx,"ERROR: Read ERROR ! fsector %d [Err %d]",(sector-last_setlbabase)+1,ret);

return 0;

}

last_setlbabase = L_INDIAN(dass->lba_base);

}while((sector-L_INDIAN(dass->lba_base))>=8);

ret = readsector((unsigned char)((sector-last_setlbabase)+1),&buffer[i*512],0);

if( ret != ERR_NO_ERROR )

{

hxc_printf_box(&g_ui_ctx,"ERROR: Read ERROR ! fsector %d [Err %d]",(sector-last_setlbabase)+1,ret);

return 0;

}

sector++;

#ifdef DEBUG

print_hex_array(buffer,512);

#endif

}

set_char_pos(&g_ui_ctx,g_ui_ctx.screen_txt_xsize - 1, 0);

print_char(&g_ui_ctx, ' ', INVERTED);

return 1;

}

int media_write(uint32 sector, uint8 *buffer, uint32 sector_count)

{

int ret;

uint32 i;

#ifdef DEBUG

dbg_printf("media_write : 0x%.8X\n",sector);

#endif

set_char_pos(&g_ui_ctx,g_ui_ctx.screen_txt_xsize - 1, 0);

print_char(&g_ui_ctx, 1, INVERTED);

for(i=0;i<sector_count;i++)

{

if( sector - last_setlbabase >=8)

{

last_setlbabase=sector;

ret = setlbabase(sector);

if( ret != ERR_NO_ERROR )

return 0;

}

ret = writesector((unsigned char)((sector-last_setlbabase)+1),buffer);

if( ret != ERR_NO_ERROR )

{

hxc_printf_box(&g_ui_ctx,"ERROR: Write sector ERROR !");

return 0;

}

sector++;

}

set_char_pos(&g_ui_ctx,g_ui_ctx.screen_txt_xsize - 1, 0);

print_char(&g_ui_ctx, ' ', INVERTED);

#ifdef DEBUG

print_hex_array(buffer,512);

#endif

return 1;

}