1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/*
* FlashProgram.c
*
* Created on: Jan 22, 2019
* Author: shlomo
*/
//#include <stdint.h>
#include "include.h"
#include "driverlib/rom.h"
#include "driverlib/flash.h"
#include <DataDef.h>
#include "FlashProgram.h"
//#define FLASH_DEBUG
#ifdef FLASH_DEBUG
#define MAX_CONT_LOG 100
#define READ 1
#define DELETE 2
uint32_t Address[MAX_CONT_LOG+1] = {0};
uint32_t Size[MAX_CONT_LOG+1] = {0};
uint32_t EraseWrite[MAX_CONT_LOG+1] = {0};
byte RxIndex = 0;
#endif
//*****************************************************************************
//
// Read the application image from the file system and program it into flash.
//
// This function will attempt to open and read the firmware image file from
// the mass storage device. If the file is found it will be programmed into
// flash. The name of the file to be read is configured by the macro
// \b USB_UPDATE_FILENAME. It will be programmed into flash starting at the
// address specified by ui32FlashStart.
//
// \return Zero if successful or non-zero if the file cannot be read or
// programmed.
//
//*****************************************************************************
uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* buffer)
{
//uint32_t ui32FileSize;
uint32_t ui32DataSize;
uint32_t ui32Remaining;
uint32_t ui32ProgAddr;
uint32_t ui32BufferAddr;
volatile uint32_t ui32Idx;
uint32_t status = OK;
//uint32_t ui32FlashEnd;
#ifdef FLASH_DEBUG
Address[RxIndex] = ui32FlashStart;
Size[RxIndex] = ui32FileSize;
EraseWrite[RxIndex] = READ;
if (RxIndex++>=MAX_CONT_LOG)
RxIndex = 0;
#endif
//
// Get the size of flash. This is the ending address of the flash.
// If reserved space is configured, then the ending address is reduced
// by the amount of the reserved block.
//
//ui32FlashEnd = ui32FlashStart + ui32FileSize;
//
// Check to make sure the file size is not too large to fit in the flash.
// If it is too large, then return an error.
//
/*if((ui32FileSize + ui32FlashStart) > ui32FlashEnd)
{
return(1);
}*/
//
// Enter a loop to erase all the requested flash pages beginning at the
// application start address (above the USB stick updater).
//
/*for(ui32Idx = ui32FlashStart; ui32Idx < ui32FlashEnd; ui32Idx += 1024)
{
ROM_FlashErase(ui32Idx);
}*/
//
// Enter a loop to read sectors from the application image file and
// program into flash. Start at the user app start address (above the USB
// stick updater).
//
ui32ProgAddr = ui32FlashStart;
ui32BufferAddr = (uint32_t)buffer;
ui32Remaining = ui32FileSize;
while(ui32Remaining)
{
//
// Compute how much data was read from this sector and adjust the
// remaining amount.
//
ui32DataSize = ui32Remaining >= 512 ? 512 : ui32Remaining;
ui32Remaining -= ui32DataSize;
//
// Call the function to program a block of flash. The length of the
// block passed to the flash function must be divisible by 4.
//
ROM_IntMasterDisable();
status = ROM_FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,(ui32DataSize + 3) & ~3);
ROM_IntMasterEnable();
if (status)
Report("FlashProgram Error", __FILE__,status,ui32ProgAddr , RpMessage, (ui32DataSize + 3) & ~3, 0);
//
// If there is more image to program, then update the programming
// address. Progress will continue to the next iteration of
// the while loop.
//
if(ui32Remaining)
{
ui32ProgAddr += ui32DataSize;
ui32BufferAddr += ui32DataSize;
}
}
//
// If we make it here, that means that an attempt to read a sector of
// data from the device was not successful. That means that the complete
// user app has not been programmed into flash, so just return an error
// indication.
//
return(1);
}
int base_flashErased = false;
uint32_t EraseFlashSection(uint32_t ui32FlashStart)
{
volatile uint32_t ui32Idx = ui32FlashStart;
uint32_t status;
if (ui32FlashStart<GENHWCFG_SECTION_FLASH)
{
if (base_flashErased == true)
return ERROR;
else
base_flashErased = true; //once in a run
}
#ifdef FLASH_DEBUG
Address[RxIndex] = ui32FlashStart;
Size[RxIndex] = ui32FileSize;
EraseWrite[RxIndex] = DELETE;
if (RxIndex++>=MAX_CONT_LOG)
RxIndex = 0;
#endif
status = FlashErase(ui32Idx);
return status;
}
//Each word may not be subject to more than a specific number of programming cycles before an
//erase cycle is required. In other words, for any given word, FlashProgram can only be called
//twice before FlashErase is called.
void FlashInit(void)
{
volatile uint32_t ui32Idx;
//FlashUsecSet(120);
#ifdef FLASH_DEBUG
Address[RxIndex] = FLASH_RAM_BASE;
Size[RxIndex] = FLASH_SIZE;
EraseWrite[RxIndex] = DELETE;
if (RxIndex++>=MAX_CONT_LOG)
RxIndex = 0;
#endif
ROM_IntMasterDisable();
for(ui32Idx = FLASH_RAM_BASE; ui32Idx < FLASH_RAM_BASE+FLASH_SIZE; ui32Idx += 1024)
{
ROM_FlashErase(ui32Idx);
}
ROM_IntMasterEnable();
}
|
