K1Guitar/driver/drv_nvm.c

#include "includes.h"

NvmData_Type mNvmData;
NvmData_Type mNvmDataShadow;

uint16_t drv_nvm_get_sum(uint8_t * pData, uint16_t len)
{
  uint16_t sum = 0;
  while (len > 0) {
    sum += *pData;
    pData++;
    len--;
  }
  return sum;
}

void drv_nvm_load_default_calibration_value(NvmParam_Type * pData,  uint8_t withDynamic)
{
  // NOT in this file
  //drv_nvm_load_default_calibration_static_value(pData);//gh,2024.1.3

  if (withDynamic) 
  {
  //  drv_nvm_load_default_calibration_dynamic_value(pData);
    drv_nvm_load_default_calibration_static_value(pData, 1);//gh,2024.1.3
  }
  else 
  {
    drv_nvm_load_default_calibration_static_value(pData, 0);//gh,2024.1.3
  }
}

void drv_nvm_load_default_value(NvmParam_Type * pData)
{
  pData->nvm_version = NVM_VERSION;

#if defined (FEAT_POWER_ON_NOT_ACTIVE)
  pData->lock_mcu_flash = 0;
  pData->lock_mcu_swd = 0;
#else
  pData->lock_mcu_flash = 0;
  pData->lock_mcu_swd = 0;
#endif

  drv_nvm_load_default_calibration_value(pData, 1);//gh,2024.1.3
}

void drv_nvm_init(void)
{
  uint8_t * p;
  uint16_t len;
  uint16_t dataSum0; 
  uint16_t dataSum1;
  uint32_t sn_32bits;
  //uint32_t *data_32bits_ptr;
  sn_32bits = *(__IO uint32_t*)(0x1FFFF7E8);
  sn_32bits += *(__IO uint32_t*)(0x1FFFF7EC);
  sn_32bits += *(__IO uint32_t*)(0x1FFFF7F0);
  // srand(sn_32bits);
  // uint16_t a = 0;
  // a = rand()%(9999-1000+1);
  // DreamSetBTAudioName[17] = a/1000%10 + 0x30;
  // DreamSetBTAudioName[18] = a/100%10 + 0x30;
  // DreamSetBTAudioName[19] = a/10%10 + 0x30;
  // DreamSetBTAudioName[20] = a%10 + 0x30;
  // DreamSetBLEName[16] = a/1000%10 + 0x30;
  // DreamSetBLEName[17] = a/100%10 + 0x30;
  // DreamSetBLEName[18] = a/10%10 + 0x30;
  // DreamSetBLEName[19] = a%10 + 0x30;
  len = sizeof(NvmData_Type);
  p = (uint8_t *)(INNER_FLASH_SAVE_ADDRESS);
  memcpy(&mNvmData, p, len);

  // 
  // TODO
  
  len = sizeof(NvmParam_Type);
  dataSum0 = drv_nvm_get_sum((uint8_t *)&mNvmData.data, len);
  dataSum1 = ~dataSum0;

  if ((dataSum0 != mNvmData.sum[0]) || (dataSum1 != mNvmData.sum[1]) || (mNvmData.data.nvm_version != NVM_VERSION)) {
    // load default value;  
    drv_nvm_load_default_value(&mNvmData.data);
    drv_nvm_save_to_flash();
  }else
  {
    drv_nvm_load_default_calibration_value(&mNvmData.data,0);
    drv_nvm_save_to_flash();
  }
  memcpy(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type));
}   

NvmParam_Type * drv_nvm_param_ptr(void)
{
  return &mNvmData.data;
}

//uint8_t drv_nvm_save_to_flash(void)
//{
//  uint16_t len;
//  uint16_t dataSum;
//  uint16_t * pData16;
//
//  uint32_t addr;
//  NvmData_Type * NvmDataToSave;
//
//  if (memcmp (&mNvmDataShadow, &mNvmData, sizeof (NvmData_Type)) == 0) {
//    return 0;
//  }
//
//  NvmDataToSave = &mNvmData;
//
//  len = sizeof(NvmParam_Type);
//  dataSum = drv_nvm_get_sum((uint8_t *)&NvmDataToSave->data, len);
//
//  // data valid check point
//  NvmDataToSave->sum[0] = dataSum;
//  NvmDataToSave->sum[1] = ~dataSum;
//
//  memcpy (&mNvmDataShadow, &mNvmData, sizeof (NvmData_Type));
//
//  NvmDataToSave = &mNvmDataShadow;
//  
//  len = sizeof(NvmData_Type);
//  len = (len+1)/2;  
//  pData16 = (uint16_t *)NvmDataToSave;
//  addr = INNER_FLASH_SAVE_ADDRESS; // nvm storage address
//	
//  HAL_FLASH_Unlock();  
//  FLASH_PageErase(INNER_FLASH_SAVE_ADDRESS);
//  while((FLASH->SR & FLASH_SR_BSY) != 0); 
//  flash_write_nocheck(addr,pData16,len);
//  //flash_lock();	
//  HAL_FLASH_Lock();
//
//  return 1;
//}
////

uint8_t drv_nvm_save_to_flash(void)
{
  uint16_t len;
  uint16_t dataSum;
  uint16_t * pData16;

  uint32_t addr = INNER_FLASH_SAVE_ADDRESS;
  NvmData_Type * NvmDataToSave;

  // <20><><EFBFBD><EFBFBD>û<EFBFBD>仯<EFBFBD><E4BBAF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
  if (memcmp(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type)) == 0) {
    return 0;
  }

  NvmDataToSave = &mNvmData;
  len = sizeof(NvmParam_Type);
  dataSum = drv_nvm_get_sum((uint8_t *)&NvmDataToSave->data, len);

  // У<><D0A3><EFBFBD>
  NvmDataToSave->sum[0] = dataSum;
  NvmDataToSave->sum[1] = ~dataSum;

  // <20><><EFBFBD><EFBFBD>
  memcpy(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type));
  NvmDataToSave = &mNvmDataShadow;

  len = sizeof(NvmData_Type);
  len = (len + 1) / 2;
  pData16 = (uint16_t *)NvmDataToSave;
  
  flash_unlock();
  flash_sector_erase(INNER_FLASH_SAVE_ADDRESS);
  flash_write_nocheck(addr,pData16,len);
  flash_lock();	

  return 1;
}

extern GUI_SWITCH  mGuiData_SystemSETTING[];
extern GUI_SWITCH ParamGuiData[];
void drv_nvm_load_default_calibration_static_value(NvmParam_Type * pData,  uint8_t reset_open_status)  //gh,2023.12.30  增加了一<E4BA86>?参数用来判断<E588A4>?开机还<E69CBA>?恢<>?<3F>出厂<E587BA>?<3F>置
{
  pData->nvm_version = NVM_VERSION;
  pData->Signature[0] = 0x52;
  pData->Signature[1] = 0x79;
  pData->Signature[2] = 0x61;
  pData->Signature[3] = 0x6E;
  
  memset(pData->Name,0,12);
  memcpy(pData->Name,fwname,sizeof(fwname));
  
  memset(pData->Data,0,16);
  memcpy(pData->Data,fwdata,sizeof(fwdata));
  
  memset(pData->Time,0,16);
  memcpy(pData->Time,fwtime,sizeof(fwtime));
    
  if(reset_open_status)
  {
    pData->param.BPM = 100;
    pData->param.Timbre = 0;
    pData->param.BandVol = 7;
    pData->param.StringVol = 7;
    pData->param.MIcVol = 7;
    pData->param.MicRev = 7;
    pData->param.AutoCloseTime    = 0;
    pData->param.Transpose      = 0;
    pData->param.Param1      = 0;
    pData->param.Param2      = 0;
    pData->param.Param3      = 0;
    //pData->param.Language      = 0;
  }
  mGuiData[GUI_SPEED].Current           		= pData->param.BPM;
  mGuiData[GUI_TIMBRE_SELECT].Current   		= pData->param.Timbre;
  mGuiData[GUI_TRANSPOSE].Current       		= pData->param.Transpose;
  faders[0].val 								= pData->param.BandVol;
  faders[1].val 								= pData->param.StringVol;
  faders[2].val 								= pData->param.MIcVol;
  faders[3].val 								= pData->param.MicRev;
  //mGuiData_SystemSETTING[GUI_AUTOCLOSE].Current = pData->param.AutoCloseTime;
  ParamGuiData[SONG_MODE_PARAM].Current         = pData->param.Param1;
  ParamGuiData[EXPRESS_MODE_PARAM].Current      = pData->param.Param2;
  ParamGuiData[ALL_MODE_PARAM].Current          = pData->param.Param3;

//  mGuiData[GUI_SPEED].Current   = pData->param.ReverbVolume;
//  mGuiData[GUI_SPEED].Current   = pData->param.WirelessSW;
//  mGuiData[GUI_SPEED].Current   = pData->param.WirelessChannel;
//  mGuiData[GUI_SPEED].Current   = pData->param.glissandoMax;
//  mGuiData[GUI_SPEED].Current   = pData->param.DreamSW;
  
}

//void drv_nvm_load_default_calibration_dynamic_value(NvmParam_Type * pData)
//{
//  pData->GasBase = 0xFFFFFFFF;
//  pData->tpadGate[0] = 0xFFFF;
//  pData->RokerBase[0] = 0xFFFF;
//  pData->RokerBase[1] = 0xFFFF;
//}