make the updater firmware more dynamic for different devices
[pub/USBaspLoader.git] / updater / updater.c
1 #ifndef F_CPU
2 #define F_CPU 1000000UL /* 1 Mhz-Takt; hier richtigen Wert eintragen */
3 #endif
4
5 #include "../firmware/spminterface.h"
6 #include "usbasploader.h"
7
8 // activate updaters full set of features
9 #ifndef CONFIG_UPDATER_REDUCEWRITES
10 #define CONFIG_UPDATER_REDUCEWRITES
11 #endif
12
13 #ifndef CONFIG_UPDATER_CLEANMEMCLEAR
14 #define CONFIG_UPDATER_CLEANMEMCLEAR
15 #endif
16
17
18 #include <avr/io.h>
19 #include <avr/interrupt.h>
20 #include <avr/wdt.h>
21
22 #include <avr/pgmspace.h>
23
24 #include <stdint.h>
25
26 #include <util/delay.h>
27 #include <string.h>
28
29 #define updater_pagefillcode ((1<<SPMEN))
30 #define updater_pageerasecode ((1<<PGERS) | (1<<SPMEN))
31 #define updater_pagewritecode ((1<<PGWRT) | (1<<SPMEN))
32
33
34 #include "../firmware/bootloaderconfig.h"
35 #if !HAVE_SPMINTEREFACE
36 #error "bootloader does not support updating itself! (HAVE_SPMINTEREFACE)"
37 #endif
38
39 // helpful definitions and makros ////
40
41 #ifndef NEW_BOOTLOADER_ADDRESS
42 #error "where should the new bootloader be positioned?"
43 #endif
44
45
46
47 #if (NEW_BOOTLOADER_ADDRESS != (funcaddr___bootloader__do_spm-(funcaddr___bootloader__do_spm % SPM_PAGESIZE)))
48 #warning the new bootloader seems to be located elsewhere, than the current one!
49 #endif
50
51 #ifndef NEW_SPM_ADDRESS
52 #warning I do not know where new "bootloader__do_spm" is located - assuming "NEW_BOOTLOADER_ADDRESS+(funcaddr___bootloader__do_spm % SPM_PAGESIZE)"
53 #define NEW_SPM_ADDRESS (NEW_BOOTLOADER_ADDRESS+(funcaddr___bootloader__do_spm % SPM_PAGESIZE))
54 #endif
55
56 // TEMP_SPM supports up to 4 pages for "bootloader__do_spm"...
57 #define TEMP_SPM_NUMPAGE 4
58 #define TEMP_SPM_BLKSIZE (TEMP_SPM_NUMPAGE*SPM_PAGESIZE)
59 #ifndef TEMP_SPM_PAGEADR
60 #warning "TEMP_SPM_PAGEADR" is not defined explicitly - will choose END OF FLASH !
61 #define TEMP_SPM_PAGEADR ((FLASHEND+1) - TEMP_SPM_BLKSIZE)
62 #endif
63 #define TEMP_SPM_ADDRESS ((TEMP_SPM_PAGEADR) + (funcaddr___bootloader__do_spm % SPM_PAGESIZE))
64
65
66 #if (NEW_SPM_ADDRESS == funcaddr___bootloader__do_spm)
67 #define new_do_spm do_spm
68 #else
69 void new_do_spm(const uint32_t flash_byteaddress, const uint8_t spmcrval, const uint16_t dataword) {
70 __do_spm_Ex(flash_byteaddress, spmcrval, dataword, NEW_SPM_ADDRESS >> 1);
71 }
72 #endif
73
74 void temp_do_spm(const uint32_t flash_byteaddress, const uint8_t spmcrval, const uint16_t dataword) {
75 __do_spm_Ex(flash_byteaddress, spmcrval, dataword, TEMP_SPM_ADDRESS >> 1);
76 }
77
78
79
80 // some important consistency checks ////
81
82 //check if "NEW_BOOTLOADER_ADDRESS" is page-aligned
83 #if (NEW_BOOTLOADER_ADDRESS % SPM_PAGESIZE != 0)
84 #error "NEW_BOOTLOADER_ADDRESS" is not aligned to pages!
85 #endif
86
87 //check, if NEW_SPM_ADDRESS is an even address
88 #if ((NEW_SPM_ADDRESS % 2) != 0)
89 #error NEW_SPM_ADDRESS must be an even address, since it contains executable code!
90 #endif
91
92
93
94 //check, if TEMP_SPM somehow overlaps with old SPM
95 #if (((TEMP_SPM_ADDRESS + TEMP_SPM_BLKSIZE + SPM_PAGESIZE) >= funcaddr___bootloader__do_spm) && (TEMP_SPM_ADDRESS <= (funcaddr___bootloader__do_spm + TEMP_SPM_BLKSIZE + SPM_PAGESIZE)))
96 #error TEMP_SPM_ADDRESS overlaps "funcaddr___bootloader__do_spm"!
97 #endif
98
99 //check, if TEMP_SPM somehow overlaps with new SPM
100 #if (((TEMP_SPM_ADDRESS + TEMP_SPM_BLKSIZE + SPM_PAGESIZE) >= NEW_SPM_ADDRESS) && (TEMP_SPM_ADDRESS <= (NEW_SPM_ADDRESS + TEMP_SPM_BLKSIZE + SPM_PAGESIZE)))
101 #error TEMP_SPM_ADDRESS overlaps "NEW_SPM_ADDRESS"!
102 #endif
103
104 //check, if TEMP_SPM_ADDRESS is an even address
105 #if ((TEMP_SPM_ADDRESS % 2) != 0)
106 #error TEMP_SPM_ADDRESS must be an even address, since it contains executable code!
107 #endif
108
109 //check, if TEMP_SPM_ADDRESS fits into flash
110 #if ((TEMP_SPM_PAGEADR + TEMP_SPM_BLKSIZE) > (FLASHEND+1))
111 #error TEMP_SPM_ADDRESS exceeds flashend!
112 #endif
113
114 //check if size too low
115 #if (SIZEOF_new_firmware <= (TEMP_SPM_BLKSIZE + (NEW_SPM_ADDRESS - NEW_BOOTLOADER_ADDRESS)))
116 #error empty firmware!
117 #endif
118
119 //check if size too high
120 #if (SIZEOF_new_firmware > ((FLASHEND+1)-NEW_BOOTLOADER_ADDRESS))
121 #error firmware too big! firmware does not fit into flash memory!
122 #endif
123
124 // main code ////
125
126 /*
127 * in this case a near address
128 */
129 typedef uint32_t mypgm_addr_t;
130 typedef void (*mypgm_spminterface)(const uint32_t flash_byteaddress, const uint8_t spmcrval, const uint16_t dataword);
131
132
133 #if 0
134 size_t mypgm_readpage(const mypgm_addr_t byteaddress,const void* buffer, const size_t bufferbytesize) {
135 size_t result = (bufferbytesize < SPM_PAGESIZE)?bufferbytesize:SPM_PAGESIZE;
136 size_t pagesize = result >> 1;
137 uint16_t *pagedata = (void*)buffer;
138 mypgm_addr_t pageaddr = byteaddress - (byteaddress % SPM_PAGESIZE);
139 size_t i;
140
141 for (i=0;i<pagesize;i+=1) {
142 pagedata[i]=pgm_read_word(pageaddr);
143 pageaddr+=2;
144 }
145
146 return result;
147 }
148 #else
149 // replace it somehow with "memcpy_PF" in order to save some ops...
150 size_t mypgm_readpage(const mypgm_addr_t byteaddress,const void* buffer, const size_t bufferbytesize) {
151 size_t result = (bufferbytesize < SPM_PAGESIZE)?bufferbytesize:SPM_PAGESIZE;
152 mypgm_addr_t pageaddr = byteaddress - (byteaddress % SPM_PAGESIZE);
153
154 memcpy_PF((void*)buffer, (uint_farptr_t)pageaddr, result);
155
156 return result;
157 }
158 #endif
159
160 #ifdef CONFIG_UPDATER_REDUCEWRITES
161 size_t mypgm_WRITEpage(const mypgm_addr_t byteaddress,const void* buffer, const size_t bufferbytesize, mypgm_spminterface spmfunc) {
162 size_t result = (bufferbytesize < SPM_PAGESIZE)?bufferbytesize:SPM_PAGESIZE;
163 size_t pagesize = result >> 1;
164 uint16_t *pagedata = (void*)buffer;
165 mypgm_addr_t pageaddr_bakup = byteaddress - (byteaddress % SPM_PAGESIZE);
166 mypgm_addr_t pageaddr = pageaddr_bakup;
167
168 uint8_t changed=0, needs_erase=0;
169 uint16_t deeword;
170 size_t i;
171
172 // just check, if page needs a rewrite or an erase...
173 for (i=0;i<pagesize;i+=1) {
174 deeword=pgm_read_word(pageaddr);
175
176 if (deeword != pagedata[i]) changed=1;
177
178 /*
179 * deeword = x
180 * buffer = y
181 *
182 * 1 ? 1 ==> 1
183 * 1 ? 0 ==> 1
184 * 0 ? 1 ==> 0
185 * 0 ? 0 ==> 1
186 *
187 * ==> /(/x * y) ==> x + /y
188 */
189 deeword |= ~pagedata[i];
190 if ((~deeword) != 0) needs_erase=1;
191
192 pageaddr+=2;
193 }
194
195 if (changed) {
196
197 if (needs_erase) {
198 //do a page-erase, ATTANTION: flash only can be erased a limited number of times !
199 spmfunc(pageaddr_bakup, updater_pageerasecode, 0);
200 }
201
202 // from now on, the page is assumed empty !! (hopefully our code is located somewhere else!)
203 // now, fill the tempoary buffer
204 // ATTANTION: see comment on "do_spm" !
205 pageaddr = pageaddr_bakup;
206 for (i=0;i<pagesize;i+=1) {
207 spmfunc(pageaddr, updater_pagefillcode, pagedata[i]);
208 pageaddr+=2;
209 }
210
211 // so, now finally write the page to the FLASH
212 spmfunc(pageaddr_bakup, updater_pagewritecode, 0);
213 } else {
214 // no change - no write...
215 result = 0;
216 }
217
218
219 return result;
220 }
221 #else
222 size_t mypgm_WRITEpage(const mypgm_addr_t byteaddress,const void* buffer, const size_t bufferbytesize, mypgm_spminterface spmfunc) {
223 size_t result = (bufferbytesize < SPM_PAGESIZE)?bufferbytesize:SPM_PAGESIZE;
224 size_t pagesize = result >> 1;
225 uint16_t *pagedata = (void*)buffer;
226 mypgm_addr_t pageaddr_bakup = byteaddress - (byteaddress % SPM_PAGESIZE);
227 mypgm_addr_t pageaddr = pageaddr_bakup;
228
229 size_t i;
230
231 //do a page-erase, ATTANTION: flash only can be erased a limited number of times !
232 spmfunc(pageaddr_bakup, updater_pageerasecode, 0);
233
234 // from now on, the page is assumed empty !! (hopefully our code is located somewhere else!)
235 // now, fill the tempoary buffer
236 // ATTANTION: see comment on "do_spm" !
237 pageaddr = pageaddr_bakup;
238 for (i=0;i<pagesize;i+=1) {
239 spmfunc(pageaddr, updater_pagefillcode, pagedata[i]);
240 pageaddr+=2;
241 }
242
243 // so, now finally write the page to the FLASH
244 spmfunc(pageaddr_bakup, updater_pagewritecode, 0);
245
246 return result;
247 }
248 #endif
249
250 // #pragma GCC diagnostic ignored "-Wno-pointer-to-int-cast"
251 int main(void)
252 {
253 size_t i;
254 uint8_t buffer[SPM_PAGESIZE];
255
256 wdt_disable();
257 cli();
258
259 // check if firmware would change...
260 buffer[0]=0;
261 for (i=0;i<SIZEOF_new_firmware;i+=2) {
262 uint16_t a, b;
263 a=pgm_read_word((void*)&new_firmware[i]);
264 b=pgm_read_word(NEW_BOOTLOADER_ADDRESS+i);
265 if (a!=b) {
266 buffer[0]=1;
267 break;
268 }
269 }
270
271
272
273 // need to change the firmware...
274 if (buffer[0]) {
275
276
277 // A
278 // copy the current "bootloader__do_spm" to tempoary position via std. "bootloader__do_spm"
279 for (i=0;i<TEMP_SPM_BLKSIZE;i+=SPM_PAGESIZE) {
280 mypgm_WRITEpage(TEMP_SPM_PAGEADR+i, buffer, mypgm_readpage(funcaddr___bootloader__do_spm+i, buffer, sizeof(buffer)), do_spm);
281 }
282
283 // B
284 // start updating the firmware to "NEW_BOOTLOADER_ADDRESS" until at least "TEMP_SPM_BLKSIZE"-bytes after "NEW_SPM_ADDRESS" were written
285 // therefore use the tempoary "bootloader__do_spm" (since we most probably will overwrite the default do_spm)
286 for (i=0;;i+=SPM_PAGESIZE) {
287 #ifdef CONFIG_UPDATER_CLEANMEMCLEAR
288 memset((void*)buffer, 0xff, sizeof(buffer));
289 #endif
290 memcpy_PF((void*)buffer, (uint_farptr_t)((void*)&new_firmware[i]), ((SIZEOF_new_firmware-i)>sizeof(buffer))?sizeof(buffer):(SIZEOF_new_firmware-i));
291
292 mypgm_WRITEpage(NEW_BOOTLOADER_ADDRESS+i, buffer, sizeof(buffer), temp_do_spm);
293
294 if ((NEW_BOOTLOADER_ADDRESS+i) > (NEW_SPM_ADDRESS+TEMP_SPM_BLKSIZE)) break;
295 }
296
297 // C
298 // continue writeing the new_firmware after "NEW_SPM_ADDRESS+TEMP_SPM_BLKSIZE" this time use the "new_do_spm"
299 for (;i<SIZEOF_new_firmware;i+=SPM_PAGESIZE) {
300 #ifdef CONFIG_UPDATER_CLEANMEMCLEAR
301 memset((void*)buffer, 0xff, sizeof(buffer));
302 #endif
303 memcpy_PF((void*)buffer, (uint_farptr_t)((void*)&new_firmware[i]), ((SIZEOF_new_firmware-i)>sizeof(buffer))?sizeof(buffer):(SIZEOF_new_firmware-i));
304
305 mypgm_WRITEpage(NEW_BOOTLOADER_ADDRESS+i, buffer, sizeof(buffer), new_do_spm);
306
307 }
308
309
310
311 }
312
313 }