#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; } } for (int k = 0; k < 0xffff; k++) ; } } 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;ilength-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,uint8_t *data, const length_t length) { uint8_t 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]=':'; 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); */