📄 stm32+i
字号:
/******************** (C) COPYRIGHT 2009 STMicroelectronics ********************
* File Name : STBLLIB.cpp
* Author : MCD Application Team
* Version : v2.0.0
* Date : 03/07/2009
* Description : Implements the system memory boot loader protocol interface
********************************************************************************
* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
#include <malloc.h>
//#include <mem.h>
#include "stdafx.h"
#include "STBLLIB.h"
/************************************************************************************/
/* Generic BL API types
/*
/*
/************************************************************************************/
typedef BYTE virt_GetProgress(LPBYTE progress);
typedef BYTE virt_GetActivityTime(LPDWORD time);
typedef BYTE virt_SetActivityTime(DWORD time);
typedef BYTE virt_TARGET_GetFlashSize(DWORD Addr, LPWORD val);
typedef BYTE virt_TARGET_GetRAMSize(DWORD Addr, LPWORD val);
typedef BYTE virt_TARGET_GetRDPOptionByte(LPBYTE RDP);
typedef BYTE virt_TARGET_GetWRPOptionBytes(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
typedef BYTE virt_Send_RQ(LPSTBL_Request pRQ);
typedef BYTE virt_SetCOMSettings(int numPort, long speedInBaud, int nbBit, int parity, float nbStopBit);
typedef BYTE virt_COM_Open();
typedef BYTE virt_COM_Close();
typedef BYTE virt_STBL_SetSpeed(DWORD speed);
typedef BYTE virt_STBL_Init_BL();
typedef BYTE virt_STBL_GET(LPBYTE Version, LPCommands pCmds);
typedef BYTE virt_STBL_GET_VER_ROPS(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
typedef BYTE virt_STBL_GET_ID(LPBYTE size, LPBYTE pID);
typedef BYTE virt_STBL_READ(DWORD Address, BYTE Size, LPBYTE pData);
typedef BYTE virt_STBL_GO(DWORD Address);
typedef BYTE virt_STBL_WRITE(DWORD address, BYTE size, LPBYTE pData);
typedef BYTE virt_STBL_ERASE(BYTE NbSectors, LPBYTE pSectors);
typedef BYTE virt_STBL_WRITE_PROTECT(BYTE NbSectors, LPBYTE pSectors);
typedef BYTE virt_STBL_WRITE_TEMP_UNPROTECT();
typedef BYTE virt_STBL_WRITE_PERM_UNPROTECT();
typedef BYTE virt_STBL_READOUT_PROTECT();
typedef BYTE virt_STBL_READOUT_TEMP_UNPROTECT();
typedef BYTE virt_STBL_READOUT_PERM_UNPROTECT();
typedef BYTE virt_STBL_UPLOAD(DWORD Address, LPBYTE pData, DWORD Length);
typedef BYTE virt_STBL_VERIFY(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
typedef BYTE virt_STBL_DNLOAD(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
typedef BYTE virt_SetPaketSize(BYTE size);
typedef BYTE virt_GetPaketSize(LPBYTE size);
typedef ACKS virt_GetAckValue();
typedef BOOL virt_COM_is_Open();
typedef BYTE virt_SetTimeOut(DWORD vms);
typedef BYTE virt_TARGET_GetUserOptionByte(LPBYTE User);
typedef BYTE virt_TARGET_GetDataOptionByte(LPBYTE Data0, LPBYTE Data1);
typedef BYTE virt_TARGET_SetSIFData(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1, BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
typedef BYTE virt_TARGET_GetSIFData(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1, LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
typedef BYTE virt_STBL_SetRts(BOOL Val);
typedef BYTE virt_STBL_SetDtr(BOOL Val);
typedef BYTE virt_STBL_setTxd(BOOL val);
typedef BYTE virt_STBL_getCts(BOOL* pval);
typedef BYTE virt_STBL_getDtr(BOOL* pval);
typedef BYTE virt_STBL_getRi(BOOL* pval);
typedef BYTE virt_STBL_getCd(BOOL* pval);
/************************************************************************************/
/* Generic BL API references
/*
/*
/************************************************************************************/
virt_GetProgress *pt_GetProgress; //(LPBYTE progress);
virt_GetActivityTime *pt_GetActivityTime; //(LPDWORD time);
virt_SetActivityTime *pt_SetActivityTime; //(DWORD time);
virt_TARGET_GetFlashSize *pt_TARGET_GetFlashSize; //(DWORD Addr, LPWORD val);
virt_TARGET_GetRAMSize *pt_TARGET_GetRAMSize; //(DWORD Addr, LPWORD val);
virt_TARGET_GetRDPOptionByte *pt_TARGET_GetRDPOptionByte; //(LPBYTE RDP);
virt_TARGET_GetWRPOptionBytes *pt_TARGET_GetWRPOptionBytes; //(LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
virt_Send_RQ *pt_Send_RQ; //(LPSTBL_Request pRQ);
virt_SetCOMSettings *pt_SetCOMSettings; //(int numPort, long speedInBaud, int nbBit, int parity, float nbStopBit);
virt_COM_Open *pt_COM_Open; //();
virt_COM_Close *pt_COM_Close; //();
virt_STBL_SetSpeed *pt_STBL_SetSpeed; //(DWORD speed);
virt_STBL_Init_BL *pt_STBL_Init_BL; //();
virt_STBL_GET *pt_STBL_GET; //(LPBYTE Version, LPCommands pCmds);
virt_STBL_GET_VER_ROPS *pt_STBL_GET_VER_ROPS; //(LPBYTE Version, LPBYTE ROPEnabled, LPBYTE ROPDisabled);
virt_STBL_GET_ID *pt_STBL_GET_ID; //(LPBYTE size, LPBYTE pID);
virt_STBL_READ *pt_STBL_READ; //(DWORD Address, BYTE Size, LPBYTE pData);
virt_STBL_GO *pt_STBL_GO; //(DWORD Address);
virt_STBL_WRITE *pt_STBL_WRITE; //(DWORD address, BYTE size, LPBYTE pData);
virt_STBL_ERASE *pt_STBL_ERASE; //(BYTE NbSectors, LPBYTE pSectors);
virt_STBL_WRITE_PROTECT *pt_STBL_WRITE_PROTECT; //(BYTE NbSectors, LPBYTE pSectors);
virt_STBL_WRITE_TEMP_UNPROTECT *pt_STBL_WRITE_TEMP_UNPROTECT; //();
virt_STBL_WRITE_PERM_UNPROTECT *pt_STBL_WRITE_PERM_UNPROTECT; //();
virt_STBL_READOUT_PROTECT *pt_STBL_READOUT_PROTECT; //();
virt_STBL_READOUT_TEMP_UNPROTECT *pt_STBL_READOUT_TEMP_UNPROTECT; //();
virt_STBL_READOUT_PERM_UNPROTECT *pt_STBL_READOUT_PERM_UNPROTECT; //();
virt_STBL_UPLOAD *pt_STBL_UPLOAD; //(DWORD Address, LPBYTE pData, DWORD Length);
virt_STBL_VERIFY *pt_STBL_VERIFY; //(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
virt_STBL_DNLOAD *pt_STBL_DNLOAD; //(DWORD Address, LPBYTE pData, DWORD Length,BOOL bTruncateLeadFFForDnLoad);
virt_SetPaketSize *pt_SetPaketSize; //(BYTE size);
virt_GetPaketSize *pt_GetPaketSize; //(LPBYTE size);
virt_GetAckValue *pt_GetAckValue; //();
virt_COM_is_Open *pt_COM_is_Open; //();
virt_SetTimeOut *pt_SetTimeOut; //(DWORD vms);
virt_TARGET_GetUserOptionByte *pt_TARGET_GetUserOptionByte; //(LPBYTE User);
virt_TARGET_GetDataOptionByte *pt_TARGET_GetDataOptionByte; //(LPBYTE Data0, LPBYTE Data1);
virt_TARGET_SetSIFData *pt_TARGET_SetSIFData; //(BYTE User, BYTE RDP, BYTE Data0, BYTE Data1, BYTE WRP0, BYTE WRP1, BYTE WRP2, BYTE WRP3);
virt_TARGET_GetSIFData *pt_TARGET_GetSIFData; //(LPBYTE User, LPBYTE RDP, LPBYTE Data0, LPBYTE Data1, LPBYTE WRP0, LPBYTE WRP1, LPBYTE WRP2, LPBYTE WRP3);
virt_STBL_SetRts *pt_STBL_SetRts; //(BOOL Val);
virt_STBL_SetDtr *pt_STBL_SetDtr; //(BOOL Val);
virt_STBL_setTxd *pt_STBL_setTxd; //(BOOL val);
virt_STBL_getCts *pt_STBL_getCts; //(BOOL* pval);
virt_STBL_getDtr *pt_STBL_getDtr; //(BOOL* pval);
virt_STBL_getRi *pt_STBL_getRi; //(BOOL* pval);
virt_STBL_getCd *pt_STBL_getCd; //(BOOL* pval);
//STARM TSMC ENGI INFORMATION FLASH
//DWORD ADDR_RAM_SIZE = 0x1FFFF7E3;
//DWORD ADDR_RAM_SIZE = 0x1FFFF7E2;
//DWORD ADDR_FLASH_SIZE = 0x1FFFF7E1;
//DWORD ADDR_FLASH_SIZE = 0x1FFFF7E0;
//DWORD ADDR_HOT_TMP_SNSR = 0x1FFFF7E7;
DWORD ADDR_HOT_TMP_SNSR = 0x1FFFF7E6;
//DWORD ADDR_AMB_TMP_SNSR = 0x1FFFF7E5;
DWORD ADDR_AMB_TMP_SNSR = 0x1FFFF7E4;
//DWORD ADDR_VREF_INT = 0x1FFFF7EB;
DWORD ADDR_VREF_INT = 0x1FFFF7EA;
DWORD ADDR_LOT_ID_6 = 0x1FFFF7E9;
DWORD ADDR_LOT_ID_5 = 0x1FFFF7E8;
DWORD ADDR_LOT_ID_4 = 0x1FFFF7EF;
DWORD ADDR_LOT_ID_3 = 0x1FFFF7EE;
DWORD ADDR_LOT_ID_2 = 0x1FFFF7ED;
DWORD ADDR_LOT_ID_1 = 0x1FFFF7EC;
DWORD ADDR_LOT_ID_0 = 0x1FFFF7F3;
DWORD ADDR_WAFER_ID = 0x1FFFF7F2;
DWORD ADDR_Y = 0x1FFFF7F1;
DWORD ADDR_X = 0x1FFFF7F0;
DWORD ADDR_FREE = 0x1FFFF7F7;
DWORD ADDR_FLOW_ID_1 = 0x1FFFF7F6;
DWORD ADDR_FLOW_ID_0 = 0x1FFFF7F5;
DWORD ADDR_TEMP_RCTRIM = 0x1FFFF7F4;
DWORD ADDR_USER_OPB = 0x1FFFF800;
DWORD ADDR_DATA_OPB = 0x1FFFF804;
DWORD ADDR_RDP_OPB = 0x1FFFF800;
DWORD ADDR_WRP0_OPB = 0x1FFFF808;
DWORD ADDR_WRP2_OPB = 0x1FFFF80C;
DWORD MAX_DATA_SIZE = 0xFF; // Packet size(in byte)
BYTE ACK = 0x79 ;
BYTE NACK = 0x1F ;
ACKS ACK_VALUE = ST79;
LPTARGET_DESCRIPTOR Target;
CRS232 Cur_COM;
ACKS McuTarget;
DWORD Progress;
DWORD ActivityTime ;
HINSTANCE ST_BL_Lib_Hdle = NULL;
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH :{
McuTarget = UNDEFINED;
Target = (LPTARGET_DESCRIPTOR)malloc(sizeof(TARGET_DESCRIPTOR));
Target->Version = 0x00;
Target->CmdCount = 0x00;
Target->PIDLen = 0x00;
Target->PID = (LPBYTE)malloc(1);
Target->ROPE = 0x00;
Target->ROPD = 0x00;
Target->GET_CMD = FALSE ; //Get the version and the allowed commands supported by the current version of the boot loader
Target->GET_VER_ROPS_CMD = FALSE ; //Get the BL version and the Read Protection status of the NVM
Target->GET_ID_CMD = FALSE ; //Get the chip ID
Target->READ_CMD = FALSE ; //Read up to 256 bytes of memory starting from an address specified by the user
Target->GO_CMD = FALSE ; //Jump to an address specified by the user to execute (a loaded) code
Target->WRITE_CMD = FALSE ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
Target->ERASE_CMD = FALSE ; //Erase from one to all the NVM sectors
Target->WRITE_PROTECT_CMD = FALSE ; //Enable the write protection in a permanent way for some sectors
Target->WRITE_TEMP_UNPROTECT_CMD = FALSE ; //Disable the write protection in a temporary way for all NVM sectors
Target->WRITE_PERM_UNPROTECT_CMD = FALSE ; //Disable the write protection in a permanent way for all NVM sectors
Target->READOUT_PERM_PROTECT_CMD = FALSE ; //Enable the readout protection in a permanent way
Target->READOUT_TEMP_UNPROTECT_CMD = FALSE ; //Disable the readout protection in a temporary way
Target->READOUT_PERM_UNPROTECT_CMD = FALSE ; //Disable the readout protection in a permanent way
}break;
case DLL_THREAD_ATTACH :{
/*McuTarget = UNDEFINED;
Target = (LPTARGET_DESCRIPTOR)malloc(sizeof(TARGET_DESCRIPTOR));
Target->Version = 0x00;
Target->CmdCount = 0x00;
Target->PIDLen = 0x00;
Target->PID = (LPBYTE)malloc(1);
Target->ROPE = 0x00;
Target->ROPD = 0x00;
Target->GET_CMD = FALSE ; //Get the version and the allowed commands supported by the current version of the boot loader
Target->GET_VER_ROPS_CMD = FALSE ; //Get the BL version and the Read Protection status of the NVM
Target->GET_ID_CMD = FALSE ; //Get the chip ID
Target->READ_CMD = FALSE ; //Read up to 256 bytes of memory starting from an address specified by the user
Target->GO_CMD = FALSE ; //Jump to an address specified by the user to execute (a loaded) code
Target->WRITE_CMD = FALSE ; //Write maximum 256 bytes to the RAM or the NVM starting from an address specified by the user
Target->ERASE_CMD = FALSE ; //Erase from one to all the NVM sectors
Target->WRITE_PROTECT_CMD = FALSE ; //Enable the write protection in a permanent way for some sectors
Target->WRITE_TEMP_UNPROTECT_CMD = FALSE ; //Disable the write protection in a temporary way for all NVM sectors
Target->WRITE_PERM_UNPROTECT_CMD = FALSE ; //Disable the write protection in a permanent way for all NVM sectors
Target->READOUT_PERM_PROTECT_CMD = FALSE ; //Enable the readout protection in a permanent way
Target->READOUT_TEMP_UNPROTECT_CMD = FALSE ; //Disable the readout protection in a temporary way
Target->READOUT_PERM_UNPROTECT_CMD = FALSE ; //Disable the readout protection in a permanent way
*/}break;
case DLL_THREAD_DETACH :{}break;
case DLL_PROCESS_DETACH :{}break;
}
return TRUE;
}
/************************************************************************************/
/* SET COMMUNICATION INTERFACE TYPE
/* UART - CAN - ...
/*
/************************************************************************************/
STBLLIB_API BYTE TARGET_SetComIntType(BYTE com_int_type)
{
switch (com_int_type)
{
case 0:{
ST_BL_Lib_Hdle = GetModuleHandle("STUARTBLLIB");
if ( ST_BL_Lib_Hdle == NULL )
{
ST_BL_Lib_Hdle = LoadLibrary("STUARTBLLIB") ;
}
}break;
case 1:{
ST_BL_Lib_Hdle = GetModuleHandle("STCANBLLIB");
if ( ST_BL_Lib_Hdle == NULL )
{
ST_BL_Lib_Hdle = LoadLibrary("STCANBLLIB") ;
}
}break;
}
pt_GetProgress = (virt_GetProgress*)GetProcAddress(ST_BL_Lib_Hdle,"GetProgress");
pt_GetActivityTime = (virt_GetActivityTime*)GetProcAddress(ST_BL_Lib_Hdle,"GetActivityTime"); //(LPDWORD time);
pt_SetActivityTime = (virt_SetActivityTime*)GetProcAddress(ST_BL_Lib_Hdle,"SetActivityTime"); //(DWORD time);
pt_TARGET_GetFlashSize = (virt_TARGET_GetFlashSize*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetFlashSize");
pt_TARGET_GetRAMSize = (virt_TARGET_GetRAMSize*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetRAMSize");
pt_TARGET_GetRDPOptionByte = (virt_TARGET_GetRDPOptionByte*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetRDPOptionByte");
pt_TARGET_GetWRPOptionBytes = (virt_TARGET_GetWRPOptionBytes*)GetProcAddress(ST_BL_Lib_Hdle,"TARGET_GetWRPOptionBytes");
pt_Send_RQ = (virt_Send_RQ*)GetProcAddress(ST_BL_Lib_Hdle,"Send_RQ");
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -