shoe_mcu/hal/hal_minifds.c

#include "hal_minifds.h"
#include "cli.h"

#define MINIFDS_PRINTF 0
#if MINIFDS_PRINTF
#include "SEGGER_RTT.h"
#include "cli.h"
#define DEBUG_LOG_MINIFDS DEBUG_LOG
#else
#define DEBUG_LOG_MINIFDS(...) ;
#endif

#define ALIGN_WORD(x) ((x) % 4 == 0 ? (x) : (((x) / 4 + 1) * 4)) //例如 33->36
#define PARAMETER_CHECK(x) 

static char checkcec(uint32_t addr)
{
    uint8_t crc = 0;
    minfds_record_t *recordhend = (minfds_record_t *)addr;
    for (int i = 0; i < recordhend->length; i++)
    {
        crc += ((uint8_t *)(addr + sizeof(minfds_record_t)))[i];
    }
    if (crc == recordhend->crc8)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

static uint32_t jump(uint32_t addr)
{
    minfds_record_t *recordhend = (minfds_record_t *)addr;
    return addr + ALIGN_WORD(recordhend->length + sizeof(minfds_record_t));
}

void printctb(minfds_t *p_minifds)
{
    DEBUG_LOG_MINIFDS("   free_capacity  %6d bytes\r\n", p_minifds->free_capacity);
    DEBUG_LOG_MINIFDS("   duty_capacity  %6d bytes\r\n", p_minifds->duty_capacity);
    DEBUG_LOG_MINIFDS("   FFFFFFFF                                   %6d bytes\r\n", p_minifds->free_capacity - p_minifds->duty_capacity);
    DEBUG_LOG_MINIFDS("   record_count   %3d\r\n", p_minifds->record_count);
}

void print_record(uint8_t *data, length_t length)
{
    for (int i = 0; i < length; i++)
    {
        if (i % 16 == 0)
        {
            DEBUG_LOG_MINIFDS("\r\n %4d ", i);
            for (int k = 0; k < 0xffff; k++)
                ;
        }
        DEBUG_LOG_MINIFDS("%2x ", data[i]);
    }
    DEBUG_LOG_MINIFDS("\r\n");
}

char minfds_Scan(minfds_t *p_minifds)
{
    uint32_t hendaddress = p_minifds->start_addr;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
    p_minifds->duty_capacity = 0;
    p_minifds->free_capacity = p_minifds->end_addr - p_minifds->start_addr;
    p_minifds->record_count = 0;
    DEBUG_LOG_MINIFDS("   minfds_Scan  start !!!!!\r\n");
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (uint32_t)hendaddress == p_minifds->end_addr)
        {
            for (uint32_t addr = hendaddress; addr < p_minifds->end_addr; addr++)
            {
                if (*(uint8_t *)addr != 0xff)
                {
                    DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE 0XFFFF   0x%x !!!!!\r\n", addr);
                    return MINIFDS_ERR_HARDWARE;
                }
            }
            DEBUG_LOG_MINIFDS("   minfds_Scan  end !!!!!\r\n");
            return MINIFDS_SUCCESS;
        }
        else
        {
            recordhend = (minfds_record_t *)hendaddress;
            if (checkcec(hendaddress))
            {
                DEBUG_LOG_MINIFDS("Record addr %x  Key %3d  length %d  %d CRC OK\r\n", (uint32_t)recordhend, recordhend->record_key, recordhend->length, ALIGN_WORD(recordhend->length + sizeof(minfds_record_t)));
                if (recordhend->record_key == 0)
                {
                    p_minifds->duty_capacity += ALIGN_WORD(recordhend->length + sizeof(minfds_record_t));
                }
                else
                {
                    p_minifds->record_count++;
                    p_minifds->free_capacity -= ALIGN_WORD(recordhend->length + sizeof(minfds_record_t));
                }
            }
            else
            {
                DEBUG_LOG_MINIFDS("Record Key %3d : CRCERROR !!!!!\r\n", recordhend->record_key);
            }
            //                      print_record((uint8_t*)(hendaddress+sizeof(minfds_record_t)),recordhend->length);
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE    : 0x%x\r\n", hendaddress);
                return MINIFDS_ERR_HARDWARE;
            }
        }
    }
}

unsigned short minfds_record_count_get(minfds_t *p_minifds)
{
	return p_minifds->record_count;
}

char minfds_gc(minfds_t *p_minifds)
{
#define WRITE_TINES 8
    uint8_t gcbuffer[4096];
    uint32_t duty_recodecount = 0;
    uint32_t recodecount = 0;
    uint32_t gcbuffer_index = 0;
    uint32_t erase_page_addr = p_minifds->start_addr; //接下来要擦除的扇区地址
    uint32_t write_page_addr = p_minifds->start_addr; //接下来要的写地址
    flash_OPER_Result rev = FLASH_OP_SUCCESS;
    unsigned short length;
    minfds_record_t *next_recordhend;
    minfds_record_t *recordhend = (minfds_record_t *)p_minifds->start_addr;
    DEBUG_LOG_MINIFDS("----------------------------gc s-------------------------- \r\n");
    printctb(p_minifds);
    p_minifds->free_capacity = p_minifds->end_addr - p_minifds->start_addr;
    while (1)
    {
        if ((*(uint32_t *)recordhend == 0xffffffff) || (uint32_t)recordhend == p_minifds->end_addr)
        {
            if (duty_recodecount == 0)
            {
                break;
            }
            p_minifds->api.flash_page_erase(erase_page_addr);
            DEBUG_LOG_MINIFDS("flash_page_erase(1) %x  %x\r\n", erase_page_addr, write_page_addr);
            //---------write---------
						DEBUG_LOG_MINIFDS("write2 >= %x len =%d\r\n",write_page_addr,gcbuffer_index);
            for (int i = 0; i < gcbuffer_index / (4096 / WRITE_TINES); i++)
            {
                rev = p_minifds->api.flash_write(
                    (uint32_t *)(write_page_addr + i * (4096 / WRITE_TINES)),
                    (uint32_t *)(gcbuffer + i * (4096 / WRITE_TINES)),
                    4096 / 4 / WRITE_TINES);
            }
            if (gcbuffer_index % (4096 / WRITE_TINES) != 0)
            {
                rev = p_minifds->api.flash_write(
                    (uint32_t *)(write_page_addr + (gcbuffer_index / (4096 / WRITE_TINES)) * (4096 / WRITE_TINES)),
                    (uint32_t *)(gcbuffer + (gcbuffer_index / (4096 / WRITE_TINES)) * (4096 / WRITE_TINES)),
                    (gcbuffer_index % (4096 / WRITE_TINES)) % 4 == 0 ? (gcbuffer_index % (4096 / WRITE_TINES)) / 4 : (gcbuffer_index % (4096 / WRITE_TINES)) / 4 + 1);
            }
            break;
        }
        else if (recordhend->record_key == 0)
        {
            duty_recodecount++;
						DEBUG_LOG_MINIFDS(" %3d page %2d :key duty, length %5d addr: %x\r\n", duty_recodecount, (erase_page_addr - p_minifds->start_addr) / 4096, recordhend->length,(uint32_t )recordhend);
            p_minifds->duty_capacity -= ALIGN_WORD(recordhend->length + sizeof(minfds_record_t));
            next_recordhend = (minfds_record_t *)jump((uint32_t)recordhend);
            recordhend = next_recordhend;
            if ((uint32_t)recordhend > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE   0x%x\r\n", (uint32_t)recordhend);
                return MINIFDS_ERR_HARDWARE;
            }
            while ((uint32_t)recordhend >= erase_page_addr + 4096)
            {
                p_minifds->api.flash_page_erase(erase_page_addr);
                erase_page_addr += 4096;
                DEBUG_LOG_MINIFDS("flash_page_erase(2) %x  %x\r\n", erase_page_addr - 4096, write_page_addr);
            }
        }
        else
        {
            recodecount++;
            p_minifds->free_capacity -= ALIGN_WORD(recordhend->length + sizeof(minfds_record_t));
            DEBUG_LOG_MINIFDS(" %3d page %2d :key %3d , length %5d addr: %x\r\n", recodecount, (erase_page_addr - p_minifds->start_addr) / 4096, recordhend->record_key, recordhend->length,(uint32_t )recordhend);
            next_recordhend = (minfds_record_t *)jump((uint32_t)recordhend);
            if ((uint32_t)next_recordhend > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE 118   0x%x\r\n", (uint32_t)next_recordhend);
                return MINIFDS_ERR_HARDWARE;
            }
            length = (uint32_t)next_recordhend - (uint32_t)recordhend;
            for (uint32_t i = 0; i < length; i++)
            {
                gcbuffer[gcbuffer_index] = ((uint8_t *)recordhend)[i];
                gcbuffer_index++;
                if (gcbuffer_index >= 4096)
                {
                    gcbuffer_index = 0;
										DEBUG_LOG_MINIFDS("gcbuffer_index >= 4096\r\n");
                    while (erase_page_addr <= write_page_addr)
                    {
                        p_minifds->api.flash_page_erase(erase_page_addr);
                        erase_page_addr += 4096;
                        DEBUG_LOG_MINIFDS("flash_page_erase(3) %x  %x\r\n", erase_page_addr - 4096, write_page_addr);
                    }
                    //---------write---------
										DEBUG_LOG_MINIFDS("write >= %x len =%d\r\n",write_page_addr,4096);
                    for (int j = 0; j < WRITE_TINES; j++)
                    {
                        rev = p_minifds->api.flash_write(
                            (uint32_t *)(write_page_addr + j * (4096 / WRITE_TINES)),
                            (uint32_t *)(gcbuffer + j * (4096 / WRITE_TINES)),
                            4096 / 4 / WRITE_TINES);
                    }
                    write_page_addr += 4096;
                }
            }
						while ((uint32_t)next_recordhend >= erase_page_addr + 4096)
            {
                p_minifds->api.flash_page_erase(erase_page_addr);
                erase_page_addr += 4096;
                DEBUG_LOG_MINIFDS("flash_page_erase(4) %x  %x\r\n", erase_page_addr - 4096, write_page_addr);
            }
            recordhend = next_recordhend;
        }
				for (int k = 0; k < 0xffff; k++);
    }
    if (rev != FLASH_OP_SUCCESS)
    {
        DEBUG_LOG_MINIFDS("    MINIFDS_ERR_API_FAIL    0x%x\r\n", (uint32_t)p_minifds->duty_capacity);
        return MINIFDS_ERR_API_FAIL;
    }
    printctb(p_minifds);
    DEBUG_LOG_MINIFDS("----------------------------gc e-------------------------- \r\n");
    return 0;
}

char minfds_record_add(minfds_t *p_minifds, key_t key, uint8_t *data, length_t length)
{
    uint32_t sizewords;
    uint32_t rev;
    uint32_t hendaddress = p_minifds->start_addr;
    DEBUG_LOG_MINIFDS("minfds_record_add  : \r\n");
    printctb(p_minifds);
    DEBUG_LOG_MINIFDS(" Key =  %d  length = %d ,  4klen:%d\r\n", key, length, ALIGN_WORD(length + sizeof(minfds_record_t)));
		if(length>MAX_RECORD_LENGTH)
		{
			  DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_LENGTH length=%d\r\n",length);
        return MINIFDS_ERR_REPEAT_LENGTH;
		}
    if (key == 0)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
    if (p_minifds->free_capacity < ALIGN_WORD(length + sizeof(minfds_record_t)))
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FREE_CAPACITY\r\n");
        return MINIFDS_ERR_NOT_FREE_CAPACITY;
    }
    if (p_minifds->free_capacity - p_minifds->duty_capacity < ALIGN_WORD(length + sizeof(minfds_record_t)))
    {
        DEBUG_LOG_MINIFDS(" minfds_record_add   minfds_gc(p_minifds);  %d,%d \r\n", p_minifds->duty_capacity, p_minifds->free_capacity);
        rev = minfds_gc(p_minifds);
        if (rev != 0)
        {
            DEBUG_LOG_MINIFDS(" minfds_record_add   minfds_gc ERROR ;  %d,%d \r\n", rev, p_minifds->free_capacity);
            return rev;
        }
    }
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (uint32_t)hendaddress == p_minifds->end_addr)
        {
            minfds_record_t hend;
            hend.record_key = key;
            hend.length = length;
            hend.crc8 = 0;
            for (int i = 0; i < length; i++)
            {
                hend.crc8 += data[i];
            }
            sizewords = length;
            if (sizewords % 4 != 0)
            {
                sizewords = sizewords / 4 + 1;
            }
            else
            {
                sizewords = sizewords / 4;
            }
            DEBUG_LOG_MINIFDS(" writaddr 0x%x ,nextaddr 0x%x             %d\r\n", hendaddress, hendaddress + ALIGN_WORD(hend.length + sizeof(minfds_record_t)), p_minifds->end_addr - hendaddress);
            p_minifds->free_capacity -= ALIGN_WORD(length + sizeof(minfds_record_t));

            for (int a = 0; a < ALIGN_WORD(hend.length + sizeof(minfds_record_t)); a++)
            {
                if (*(uint8_t *)(hendaddress + a) != 0xff)
                {
                    DEBUG_LOG_MINIFDS("flash data  :\r\n");
                    print_record((uint8_t *)(hendaddress + sizeof(minfds_record_t)), sizewords * 4);
                    DEBUG_LOG_MINIFDS("Ram data  :\r\n");
                    print_record(data, sizewords * 4);
                    DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE NOT 0xFF\r\n");
                    return MINIFDS_ERR_HARDWARE;
                }
            }

            rev = p_minifds->api.flash_write((uint32_t *)hendaddress, (uint32_t *)&hend, sizeof(minfds_record_t) / 4);
            if (rev != FLASH_OP_SUCCESS)
            {
                printctb(p_minifds);
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_API_FAIL flash_write 1 %d   0x%x  0x%x  0x%x\r\n", rev, (uint32_t *)hendaddress, (uint32_t *)&hend, sizeof(minfds_record_t) / 4);
                return MINIFDS_ERR_API_FAIL;
            }
            if (sizewords != 0)
            {
                rev = p_minifds->api.flash_write((uint32_t *)(hendaddress + sizeof(minfds_record_t)), (uint32_t *)data, sizewords);
            }
            if (rev == FLASH_OP_SUCCESS)
            {
                p_minifds->record_count++;
                if (checkcec(hendaddress) != 1)
                {
                    DEBUG_LOG_MINIFDS("flash data  :\r\n");
                    print_record((uint8_t *)(hendaddress + sizeof(minfds_record_t)), sizewords * 4);
                    DEBUG_LOG_MINIFDS("Ram data  :\r\n");
                    print_record(data, sizewords * 4);
                    DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE CRC\r\n");
                    return MINIFDS_ERR_HARDWARE;
                }
                DEBUG_LOG_MINIFDS("MINIFDS_SUCCESS\r\n");
                return MINIFDS_SUCCESS;
            }
            else
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_API_FAIL flash_write 2 %d   0x%x  0x%x  0x%x\r\n", rev, (uint32_t *)(hendaddress + sizeof(minfds_record_t)), (uint32_t *)data, sizewords);
                return MINIFDS_ERR_API_FAIL;
            }
        }
        else
        {
            minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
            if (recordhend->record_key == key)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY\r\n");
                return MINIFDS_ERR_REPEAT_KEY;
            }
            if (!checkcec(hendaddress))
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE CRC add   0x%x\r\n", hendaddress);
                return MINIFDS_ERR_HARDWARE;
            }
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE 426   0x%x\r\n", hendaddress);
                return MINIFDS_ERR_HARDWARE;
            }
        }
    }
}

char minfds_record_find(minfds_t *p_minifds, key_t key, uint8_t *data, length_t *length)
{
    uint32_t hendaddress = p_minifds->start_addr;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
		DEBUG_LOG_MINIFDS("minfds_record_find  : \r\n");
		DEBUG_LOG_MINIFDS(" Key =  %d \r\n", key);
    if (key == 0)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
		if(*length==0)
		{
				DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_LENGTH *length=0\r\n");
        return MINIFDS_ERR_REPEAT_LENGTH;
		}
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (hendaddress == p_minifds->end_addr))
        {
						DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FIND_RECORD \r\n");
            return MINIFDS_ERR_NOT_FIND_RECORD;
        }
				else if (recordhend->record_key == key)
        {
					if(*length < recordhend->length)
					{
						DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_LENGTH *length=%d\r\n",*length);
						return MINIFDS_ERR_REPEAT_LENGTH;
					}
					memcpy(data, (uint8_t *)(hendaddress + sizeof(minfds_record_t)), recordhend->length);
					*length = recordhend->length;
					DEBUG_LOG_MINIFDS(" length =  %d \r\n", recordhend->length);
					return MINIFDS_SUCCESS;
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE \r\n");
                return MINIFDS_ERR_HARDWARE;
            }
						recordhend = (minfds_record_t *)hendaddress;
        }
    }
}

char get_record_hendaddr(minfds_t *p_minifds, key_t key,uint32_t *addr)
{
    uint32_t hendaddress = p_minifds->start_addr;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
		DEBUG_LOG_MINIFDS("minfds_record_get_length  : \r\n");
		DEBUG_LOG_MINIFDS(" Key =  %d \r\n", key);
    if (key == 0)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (hendaddress == p_minifds->end_addr))
        {
						DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FIND_RECORD \r\n");
            return MINIFDS_ERR_NOT_FIND_RECORD;
        }
				else if (recordhend->record_key == key)
        {
            *addr = (uint32_t)recordhend;
						DEBUG_LOG_MINIFDS(" addr =  %x \r\n", *addr);
            return MINIFDS_SUCCESS;
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE \r\n");
                return MINIFDS_ERR_HARDWARE;
            }
						recordhend = (minfds_record_t *)hendaddress;
        }
    }
}

char minfds_record_get_length(minfds_t *p_minifds, key_t key, length_t *length)
{
	char rev = 0 ;
	uint32_t addr_hend=0;
	minfds_record_t *recordhend =NULL;
	rev=get_record_hendaddr(p_minifds,key,&addr_hend);
	if(rev!=MINIFDS_SUCCESS)return rev;
  recordhend = (minfds_record_t *)addr_hend;
	*length = recordhend->length;
	return MINIFDS_SUCCESS;
}

char minfds_record_find_mem(minfds_t *p_minifds, uint8_t *mem, int mem_len,key_t * key)
{
	  uint32_t hendaddress = p_minifds->start_addr;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
		DEBUG_LOG_MINIFDS("minfds_record_find_mem  : \r\n");
		DEBUG_LOG_MINIFDS(" mem_len =  %d \r\n", mem_len);
	DEBUG_LOG_MINIFDS(" mem_len254 =  %d \r\n", 100);
	DEBUG_LOG_MINIFDS("  [%s] \r\n", mem);
    if ((mem_len == 0)||(mem==NULL))
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (hendaddress == p_minifds->end_addr))
        {
						DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FIND_RECORD \r\n");
            return MINIFDS_ERR_NOT_FIND_RECORD;
        }
				else if (recordhend->record_key != 0 )
        {
					if(recordhend->length >= mem_len)
					{
						for(int i=0;i<recordhend->length-mem_len;i++)
						{
							if(memcmp(mem,(uint8_t *)(hendaddress+i+sizeof(minfds_record_t)),mem_len)==0)
							{
								*key=recordhend->record_key;
								DEBUG_LOG_MINIFDS("MINIFDS_SUCCESS -----\r\n");
								 return MINIFDS_SUCCESS;
							}
						}
					}
					            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE \r\n");
                return MINIFDS_ERR_HARDWARE;
            }
						recordhend = (minfds_record_t *)hendaddress;
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE \r\n");
                return MINIFDS_ERR_HARDWARE;
            }
						recordhend = (minfds_record_t *)hendaddress;
        }
    }
}

char minfds_record_update(minfds_t *p_minifds, key_t key, uint8_t *data, length_t length)
{
		uint32_t hendaddr=0;
    char rev = 0;
    if (key == 0)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
		DEBUG_LOG_MINIFDS("minfds_record_update key=%d\r\n",key);
		rev = get_record_hendaddr(p_minifds, key,&hendaddr);
		if (rev == MINIFDS_SUCCESS)
    {
      minfds_record_t *recordhend=(minfds_record_t*)hendaddr;
			if(recordhend->length==length)
			{
				if(memcmp((uint8_t*)(hendaddr+sizeof(minfds_record_t)),data,length)==0)
				{
					DEBUG_LOG_MINIFDS("MINIFDS_SUCCESS NOT NEED UPDATE\r\n");
					return MINIFDS_SUCCESS;
				}
			}
    }
		
    rev = minfds_record_delete(p_minifds, key);
    if (rev != 0)
    {
        return rev;
    }
    return minfds_record_add(p_minifds, key, data, length);
}

char minfds_record_delete(minfds_t *p_minifds, key_t key)
{
    uint32_t hendaddress = p_minifds->start_addr;
    flash_OPER_Result rev;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
    DEBUG_LOG_MINIFDS("minfds_record_delete  :  key %d  ", key);
    if (key == 0)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY key=0\r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (uint32_t)hendaddress == p_minifds->end_addr)
        {
            DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FIND_RECORD  record_count %d\r\n", p_minifds->record_count);
            return MINIFDS_ERR_NOT_FIND_RECORD;
        }
        if (recordhend->record_key == key)
        {
            minfds_record_t temp;
            memcpy(&temp, recordhend, sizeof(minfds_record_t));
            temp.record_key = 0x00;
            p_minifds->duty_capacity += ALIGN_WORD(temp.length + sizeof(minfds_record_t));
            p_minifds->free_capacity += ALIGN_WORD(temp.length + sizeof(minfds_record_t));
            rev = p_minifds->api.flash_write((uint32_t *)hendaddress, (uint32_t *)&temp, sizeof(minfds_record_t) / 4);
            if (rev == FLASH_OP_SUCCESS)
            {
                if (memcmp(&temp, (uint32_t *)hendaddress, sizeof(minfds_record_t)) != 0)
                {
                    DEBUG_LOG_MINIFDS("MINIFDS_ERR_API_FAIL1\r\n");
                    return MINIFDS_ERR_API_FAIL;
                }
                DEBUG_LOG_MINIFDS("MINIFDS_SUCCESS\r\n");
                p_minifds->record_count--;
                return MINIFDS_SUCCESS;
            }
            else
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_API_FAIL2\r\n");
                return MINIFDS_ERR_API_FAIL;
            }
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE   0x%x\r\n", hendaddress);
                return MINIFDS_ERR_HARDWARE;
            }
            recordhend = (minfds_record_t *)hendaddress;
        }
    }
}

char minfds_record_delete_all(minfds_t *p_minifds)
{
    uint32_t hendaddress = p_minifds->start_addr;
    uint32_t rev;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
    DEBUG_LOG_MINIFDS("minfds_record_delete_all  : ");
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (uint32_t)hendaddress == p_minifds->end_addr)
        {
            return MINIFDS_SUCCESS;
        }
        if (recordhend->record_key != 0)
        {
            minfds_record_t temp;
            memcpy(&temp, recordhend, sizeof(minfds_record_t));
            temp.record_key = 0x00;
            p_minifds->duty_capacity += ALIGN_WORD(temp.length + sizeof(minfds_record_t));
            p_minifds->free_capacity += ALIGN_WORD(temp.length + sizeof(minfds_record_t));
            DEBUG_LOG_MINIFDS(" delete record_key : %d\r\n", recordhend->record_key);
            rev = p_minifds->api.flash_write((uint32_t *)hendaddress, (uint32_t *)&temp, sizeof(minfds_record_t) / 4);
            if (rev == FLASH_OP_SUCCESS)
            {
                p_minifds->record_count--;
            }
            else
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_API_FAIL\r\n");
                return MINIFDS_ERR_API_FAIL;
            }
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("    MINIFDS_ERR_HARDWARE   0x%x\r\n", hendaddress);
                return MINIFDS_ERR_HARDWARE;
            }
            recordhend = (minfds_record_t *)hendaddress;
        }
    }
}

char minfds_format(minfds_t *p_minifds)
{
    for (int i = 0; i < (p_minifds->end_addr - p_minifds->start_addr) / 4096; i++)
    {
        p_minifds->api.flash_page_erase(p_minifds->start_addr + i * 4096);
    }
    p_minifds->duty_capacity = 0;
    p_minifds->record_count = 0;
    p_minifds->free_capacity = p_minifds->end_addr - p_minifds->start_addr;
    return MINIFDS_SUCCESS;
}

char minfds_init(minfds_t *p_minifds)
{
    DEBUG_LOG_MINIFDS("----------------------------------\r\n");
    DEBUG_LOG_MINIFDS("   Minfds Start_addr : 0x%x\r\n", p_minifds->start_addr);
    DEBUG_LOG_MINIFDS("   Minfds End_addr   : 0x%x \r\n", p_minifds->end_addr);
    minfds_Scan(p_minifds);
    printctb(p_minifds);
    DEBUG_LOG_MINIFDS("----------------------------------\r\n");
	return 0;
}

char record_index(minfds_t *p_minifds,minfds_record_t *record,uint8_t * data,int index)
{
	  uint32_t hendaddress = p_minifds->start_addr;
		int i=0;
    minfds_record_t *recordhend = (minfds_record_t *)hendaddress;
		DEBUG_LOG_MINIFDS("record_index  : \r\n");
		DEBUG_LOG_MINIFDS(" index =  %d \r\n", index);
		if ((index >= p_minifds->record_count)||(record==NULL)||(data==NULL))
    {
//        DEBUG_LOG_MINIFDS("MINIFDS_ERR_PARAMETER \r\n");
        return MINIFDS_ERR_PARAMETER;
    }
    while (1)
    {
        if ((*(uint32_t *)hendaddress == 0xffffffff) || (hendaddress == p_minifds->end_addr))
        {
						DEBUG_LOG_MINIFDS("MINIFDS_ERR_NOT_FIND_RECORD \r\n");
            return MINIFDS_ERR_NOT_FIND_RECORD;
        }
				else if (recordhend->record_key !=0)
        {
					if(i==index)
					{
						data=(uint8_t *)(hendaddress+sizeof(minfds_record_t));
						record=recordhend;
						DEBUG_LOG_MINIFDS("MINIFDS_SUCCESS \r\n");
            return MINIFDS_SUCCESS;
					}
					i++;
        }
        else
        {
            hendaddress = jump(hendaddress);
            if (hendaddress > p_minifds->end_addr)
            {
                DEBUG_LOG_MINIFDS("MINIFDS_ERR_HARDWARE \r\n");
                return MINIFDS_ERR_HARDWARE;
            }
						recordhend = (minfds_record_t *)hendaddress;
        }
    }

}

char pm_add(minfds_t* p_minifds, const char* key, int key_len, unsigned char* data, length_t length)
{
    unsigned char buff[MAX_RECORD_LENGTH];
    key_t TEMP_KEY = 1;
    char rev = 0;
    if (key_len + length + 1 >= MAX_RECORD_LENGTH)
    {
        DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_LENGTH \r\n");
        return MINIFDS_ERR_REPEAT_LENGTH;
    }
    memcpy(buff, key, key_len);
    buff[key_len] = ':';
                rev = minfds_record_find_mem(p_minifds, buff, key_len + 1, &TEMP_KEY);
    if (rev == MINIFDS_SUCCESS)
    {
                          DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_KEY \r\n");
        return MINIFDS_ERR_REPEAT_KEY;
    }        
                memcpy(&buff[key_len + 1], data, length);
    while (1)
    {
        rev = minfds_record_add(p_minifds, TEMP_KEY, buff, key_len + length + 1);
        if (rev != MINIFDS_ERR_REPEAT_KEY)
        {
            return rev;
        }
        TEMP_KEY++;
        if (TEMP_KEY == 0)
        {
            return MINIFDS_ERR_REPEAT_KEY;
        }
    }
}

char pm_find(minfds_t *p_minifds, const char * key,int key_len, uint8_t *data, length_t *length)
{
	key_t TEMP_KEY=1;
	char rev=0;
	length_t temp_len=MAX_RECORD_LENGTH;
	uint8_t buff[MAX_RECORD_LENGTH];
	memcpy(buff,key,key_len);
	buff[key_len]=':';
	rev=minfds_record_find_mem(p_minifds,buff,key_len+1,&TEMP_KEY);
	if(rev!=MINIFDS_SUCCESS)return rev;
	rev=minfds_record_find(p_minifds, TEMP_KEY, buff, &temp_len);
	if(rev!=MINIFDS_SUCCESS)return rev;
	memcpy(data,&buff[key_len+1],temp_len-key_len-1);
	*length=temp_len-key_len-1;
	return MINIFDS_SUCCESS;
}

char pm_get_length(minfds_t *p_minifds,const char * key,int key_len, length_t *length)
{
	key_t TEMP_KEY=1;
	char rev=0;
	length_t temp_len=0;
	uint8_t buff[MAX_RECORD_LENGTH];
	memcpy(buff,key,key_len);
	buff[key_len]=':';
	rev=minfds_record_find_mem(p_minifds,buff,key_len+1,&TEMP_KEY);
	if(rev!=MINIFDS_SUCCESS)return rev;
	rev=minfds_record_get_length(p_minifds, TEMP_KEY, &temp_len);
	*length=temp_len-key_len-1;
	return rev;
}

char pm_delete(minfds_t *p_minifds, const char * key,int key_len)
{
	key_t TEMP_KEY=1;
	char rev=0;
	uint8_t buff[MAX_RECORD_LENGTH];
	memcpy(buff,key,key_len);
	buff[key_len]=':';
	rev=minfds_record_find_mem(p_minifds,buff,key_len+1,&TEMP_KEY);
	if(rev!=MINIFDS_SUCCESS)return rev;
	rev=minfds_record_delete(p_minifds, TEMP_KEY);
	if(rev!=MINIFDS_SUCCESS)return rev;
	return MINIFDS_SUCCESS;
}

char pm_update(minfds_t *p_minifds, const char * key,int key_len, uint8_t *data, length_t length)
{
	key_t TEMP_KEY=1;
	char rev=0;
	uint8_t buff[MAX_RECORD_LENGTH];
	printctb(p_minifds);
	if(key_len+length+1>=MAX_RECORD_LENGTH)
	{
		 DEBUG_LOG_MINIFDS("MINIFDS_ERR_REPEAT_LENGTH \r\n");
     return MINIFDS_ERR_REPEAT_LENGTH; 
	}
	memcpy(buff,key,key_len);
	buff[key_len]=':';
	memcpy(&buff[key_len+1],data,length);
	rev=minfds_record_find_mem(p_minifds,buff,key_len+1,&TEMP_KEY);
	if(rev!=MINIFDS_SUCCESS)return rev;
	return minfds_record_update(p_minifds, TEMP_KEY,buff,key_len+length+1);
}

//-----------------------------------------------------------------------------------------------------
/*
extern minfds_t minifds;
void pma_pcs(cli_t *p_cli, unsigned short argc, char **argv)
{
	char keu[]="key1";
	uint8_t datat[]="testdata";
	pm_add(&minifds,keu,sizeof("key1"),datat,sizeof("testdata"));
    minfds_Scan(&minifds);
}
CLI_CMD_REGISTER(pma, "Cli cmd history", pma_pcs);

void pmf_pcs(cli_t *p_cli, unsigned short argc, char **argv)
{
	char keu[]="key1";
	uint8_t datat[50]="11111111111";
	uint8_t length=0;
	pm_find(&minifds,keu,sizeof("key1"),datat,&length);
	 DEBUG_LOG_MINIFDS("%s \r\n",datat);
}
CLI_CMD_REGISTER(pmf, "Cli cmd history", pmf_pcs);

void pmd_pcs(cli_t *p_cli, unsigned short argc, char **argv)
{
	char keu[]="key1";
	uint8_t datat[50]="11111111111";
	pm_delete(&minifds,keu,sizeof("key1"));
	 DEBUG_LOG_MINIFDS("%s \r\n",datat);
}
CLI_CMD_REGISTER(pmd, "Cli cmd history", pmd_pcs);

void pmu_pcs(cli_t *p_cli, unsigned short argc, char **argv)
{
	char keu[]="key1";
	uint8_t datat[50]="11111111111";
	pm_update(&minifds,keu,sizeof("key1"),datat,10);
	 DEBUG_LOG_MINIFDS("%s \r\n",datat);
}
CLI_CMD_REGISTER(pmu, "Cli cmd history", pmu_pcs);

*/