Mercurial > public > ostc4
annotate Discovery/Src/externLogbookFlash.c @ 1040:74be24428049 GasConsumption
Bugfix Fontpack update for large blocks:
The update of a font pack with a size > 768000 byte was interrupted and a manuel switch to bootloader had to be performed to get the font pack flashed. Rootcause was a missing address adjustment during the block read back function which caused a false error detection. Blocks > 768000 are read in two step while only one buffer is used for comparation. To fill the correct data into this buffer a dummy read of the flash data was added to get the data pointers to the correct offset. Another bug was regardings the read back itself where only the first byte was checked. After array indexing the complete buffer is noch verified.
| author | Ideenmodellierer |
|---|---|
| date | Mon, 13 Oct 2025 20:54:25 +0200 |
| parents | 158100a84ebd |
| children |
| rev | line source |
|---|---|
| 38 | 1 /** |
| 2 ****************************************************************************** | |
| 3 * @copyright heinrichs weikamp | |
| 4 * @file externLogbookFlash.c | |
| 5 * @author heinrichs weikamp gmbh | |
| 6 * @date 07-Aug-2014 | |
| 7 * @version V0.0.4 | |
| 8 * @since 29-Sept-2015 | |
| 9 * @brief Main File to access the new 1.8 Volt Spansion S25FS256S 256 Mbit (32 Mbyte) | |
| 10 * @bug | |
| 11 * @warning | |
| 12 * | |
| 13 @verbatim | |
| 14 ============================================================================== | |
| 15 ##### Logbook Header (TOC) ##### | |
| 16 ============================================================================== | |
| 17 [..] Memory useage: | |
| 18 NEW: Spansion S25FS-S256S | |
| 19 | |
| 20 only 8x 4KB and 1x 32KB, remaining is 64KB or 256KB | |
| 21 Sector Size (kbyte) Sector Count Sector Range Address Range (Byte Address) Notes | |
| 22 4 8 SA00 00000000h-00000FFFh | |
| 23 : : | |
| 24 SA07 00007000h-00007FFFh | |
| 25 | |
| 26 32 1 SA08 00008000h-0000FFFFh | |
| 27 | |
| 28 64 511 SA09 00010000h-0001FFFFh | |
| 29 : : | |
| 30 SA519 01FF0000h-01FFFFFFh | |
| 31 OLD: | |
| 32 1kB each header | |
| 33 with predive header at beginning | |
| 34 and postdive header with 0x400 HEADER2OFFSET | |
| 35 4kB (one erase) has two dives with 4 headers total | |
| 36 total of 512 kB (with 256 header ids (8 bit)) | |
| 37 Size is 280 Byte (as of 25.Nov. 2014) | |
| 38 | |
| 39 [..] Output to PC / UART is postdive header | |
| 40 | |
| 41 [..] Block Protection Lock-Down is to erase logbook only | |
| 42 | |
| 43 [..] Timing (see page 137 of LOGBOOK_V3_S25FS-S_00-271247.pdf | |
| 44 bulk erase is 2 minutes typ., 6 minutes max. | |
| 45 | |
| 46 ============================================================================== | |
| 47 ##### DEMOMODE ##### | |
| 48 ============================================================================== | |
| 49 151215: ext_flash_write_settings() is DISABLED! | |
| 50 | |
| 51 ============================================================================== | |
| 52 ##### bug fixes ##### | |
| 53 ============================================================================== | |
| 54 150917: end in header and length of sample was one byte too long | |
| 55 as stated by Jef Driesen email 15.09.2015 | |
| 56 | |
| 57 @endverbatim | |
| 58 ****************************************************************************** | |
| 59 * @attention | |
| 60 * | |
| 61 * <h2><center>© COPYRIGHT(c) 2015 heinrichs weikamp</center></h2> | |
| 62 * | |
| 63 ****************************************************************************** | |
| 64 */ | |
| 65 | |
| 66 /* Includes ------------------------------------------------------------------*/ | |
| 67 #include "stm32f4xx_hal.h" | |
| 68 #include "externLogbookFlash.h" | |
| 69 #include "ostc.h" | |
| 70 #include "settings.h" | |
| 71 #include "gfx_engine.h" | |
| 72 | |
| 73 #ifndef BOOTLOADER_STANDALONE | |
| 74 #include "logbook.h" | |
| 75 #endif | |
| 76 | |
| 77 /* Private types -------------------------------------------------------------*/ | |
| 78 #define FLASHSTART 0x000000 | |
| 79 //#define FLASHSTOP 0x01FFFFFF all 32 MB with 4byte addressing | |
| 80 #define FLASHSTOP 0x00FFFFFF | |
| 81 //#define FLASHSTOP 0x3FFFFF | |
| 82 #define RELEASE 1 | |
| 83 #define HOLDCS 0 | |
| 84 | |
| 85 #define HEADER2OFFSET 0x400 | |
| 86 | |
| 87 typedef struct{ | |
| 88 uint8_t IsBusy:1; | |
| 89 uint8_t IsWriteEnabled:1; | |
| 90 uint8_t BlockProtect0:1; | |
| 91 uint8_t BlockProtect1:1; | |
| 92 uint8_t BlockProtect2:1; | |
| 93 uint8_t BlockProtect3:1; | |
| 94 uint8_t IsAutoAddressIncMode:1; | |
| 95 uint8_t BlockProtectL:1; | |
| 96 } extFlashStatusUbit8_t; | |
| 97 | |
| 98 typedef union{ | |
| 99 extFlashStatusUbit8_t ub; | |
| 100 uint8_t uw; | |
| 101 } extFlashStatusBit8_Type; | |
| 102 | |
| 103 | |
| 104 /* Exported variables --------------------------------------------------------*/ | |
| 105 | |
| 106 /* Private variables ---------------------------------------------------------*/ | |
| 870 | 107 |
| 108 #ifndef BOOTLOADER_STANDALONE | |
| 109 static uint32_t entryPoint = 0; | |
| 110 static uint32_t LengthLeftSampleRead = 0; | |
| 111 static uint32_t actualPointerDevicedata_Read = DDSTART; | |
| 112 #endif | |
| 113 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
114 static uint32_t actualAddress = 0; |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
115 static uint32_t preparedPageAddress = 0; |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
116 static uint32_t closeSectorAddress = 0; |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
117 static uint32_t actualPointerHeader = 0; |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
118 static uint32_t actualPointerSample = 0; |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
119 static uint32_t actualPointerDevicedata = DDSTART; |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
120 static uint32_t actualPointerVPM = 0; |
| 427 | 121 static uint32_t actualPointerSettings = SETTINGSSTART; |
| 1027 | 122 static uint32_t actualPointerProfile = PROFILE0_START; |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
123 static uint32_t actualPointerFirmware = 0; |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
124 static uint32_t actualPointerFirmware2 = 0; |
| 38 | 125 |
| 126 /* Private function prototypes -----------------------------------------------*/ | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
127 static void chip_unselect(void); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
128 static void chip_select(void); |
| 870 | 129 #ifndef BOOTLOADER_STANDALONE |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
130 static void error_led_on(void); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
131 static void error_led_off(void); |
| 870 | 132 static void ext_flash_decf_address_ring(uint8_t type); |
| 133 static void ext_flash_disable_protection(void); | |
| 134 static _Bool ext_flash_test_remaining_space_of_page_empty(uint32_t pointer, uint16_t length); | |
| 135 static void ext_flash_set_to_begin_of_next_page(uint32_t *pointer, uint8_t type); | |
| 136 #endif | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
137 static void write_spi(uint8_t data, uint8_t unselect_CS_afterwards); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
138 static uint8_t read_spi(uint8_t unselect_CS_afterwards); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
139 static void write_address(uint8_t unselect_CS_afterwards); |
| 38 | 140 static void Error_Handler_extflash(void); |
| 141 static void wait_chip_not_busy(void); | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
142 static void ext_flash_incf_address(uint8_t type); |
| 38 | 143 //void ext_flash_incf_address_ring(void); |
| 144 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
145 static void ext_flash_erase4kB(void); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
146 static void ext_flash_erase32kB(void); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
147 static void ext_flash_erase64kB(void); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
148 static uint8_t ext_flash_erase_if_on_page_start(void); |
| 38 | 149 |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
150 static void ef_write_block(uint8_t * sendByte, uint32_t length, uint8_t type, uint8_t do_not_erase); |
| 38 | 151 |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
152 static void ext_flash_read_block(uint8_t *getByte, uint8_t type); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
153 static void ext_flash_read_block_multi(void *getByte, uint32_t size, uint8_t type); |
|
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
154 static void ext_flash_read_block_stop(void); |
| 38 | 155 |
| 156 static void ef_hw_rough_delay_us(uint32_t delayUs); | |
| 157 static void ef_erase_64K(uint32_t blocks); | |
| 158 | |
| 870 | 159 #ifndef BOOTLOADER_STANDALONE |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
160 static void ext_flash_overwrite_sample_without_erase(uint8_t *pSample, uint16_t length); |
| 870 | 161 static void ext_flash_find_start(void); |
| 162 #endif | |
| 38 | 163 |
| 164 | |
| 165 | |
| 166 /* Exported functions --------------------------------------------------------*/ | |
| 167 | |
| 168 void ext_flash_write_firmware(uint8_t *pSample1, uint32_t length1)//, uint8_t *pSample2, uint32_t length2) | |
| 169 { | |
| 170 general32to8_Type lengthTransform; | |
| 171 | |
| 172 lengthTransform.u32 = length1; | |
| 173 | |
| 174 actualPointerFirmware = FWSTART; | |
| 175 ef_write_block(lengthTransform.u8,4, EF_FIRMWARE, 1); | |
| 176 ef_write_block(pSample1,length1, EF_FIRMWARE, 1); | |
| 177 | |
| 178 // if(length2) | |
| 179 // ef_write_block(pSample2,length2, EF_FIRMWARE, 1); | |
| 180 } | |
| 181 | |
| 182 uint8_t ext_flash_read_firmware_version(char *text) | |
| 183 { | |
| 184 uint32_t backup = actualAddress; | |
| 185 uint8_t buffer[4]; | |
| 186 | |
| 187 // + 4 for length data, see ext_flash_write_firmware | |
| 188 actualAddress = FWSTART + 4 + 0x10000; | |
| 189 ext_flash_read_block_start(); | |
| 190 ext_flash_read_block(&buffer[0], EF_FIRMWARE); | |
| 191 ext_flash_read_block(&buffer[1], EF_FIRMWARE); | |
| 192 ext_flash_read_block(&buffer[2], EF_FIRMWARE); | |
| 193 ext_flash_read_block(&buffer[3], EF_FIRMWARE); | |
| 194 | |
| 195 ext_flash_read_block_stop(); | |
| 196 actualAddress = backup; | |
| 197 | |
| 198 uint8_t ptr = 0; | |
| 199 text[ptr++] = 'V'; | |
| 200 ptr += gfx_number_to_string(2,0,&text[ptr],buffer[0] & 0x3F); | |
| 201 text[ptr++] = '.'; | |
| 202 ptr += gfx_number_to_string(2,0,&text[ptr],buffer[1] & 0x3F); | |
| 203 text[ptr++] = '.'; | |
| 204 ptr += gfx_number_to_string(2,0,&text[ptr],buffer[2] & 0x3F); | |
| 205 text[ptr++] = ' '; | |
| 206 if(buffer[3]) | |
| 207 { | |
| 208 text[ptr++] = 'b'; | |
| 209 text[ptr++] = 'e'; | |
| 210 text[ptr++] = 't'; | |
| 211 text[ptr++] = 'a'; | |
| 212 text[ptr++] = ' '; | |
| 213 } | |
| 214 return ptr; | |
| 215 } | |
| 216 | |
| 217 | |
| 218 uint32_t ext_flash_read_firmware(uint8_t *pSample1, uint32_t max_length, uint8_t *magicByte) | |
| 219 { | |
| 220 uint32_t backup = actualAddress; | |
| 221 general32to8_Type lengthTransform; | |
| 222 | |
| 223 actualAddress = FWSTART; | |
| 224 ext_flash_read_block_start(); | |
| 225 | |
| 226 ext_flash_read_block(&lengthTransform.u8[0], EF_FIRMWARE); | |
| 227 ext_flash_read_block(&lengthTransform.u8[1], EF_FIRMWARE); | |
| 228 ext_flash_read_block(&lengthTransform.u8[2], EF_FIRMWARE); | |
| 229 ext_flash_read_block(&lengthTransform.u8[3], EF_FIRMWARE); | |
| 230 | |
| 231 | |
| 232 if(lengthTransform.u32 == 0xFFFFFFFF) | |
| 233 { | |
| 234 lengthTransform.u32 = 0xFFFFFFFF; | |
| 235 } | |
| 236 else | |
| 237 if(lengthTransform.u32 > max_length) | |
| 238 { | |
| 239 lengthTransform.u32 = 0xFF000000; | |
| 240 } | |
| 241 else | |
| 242 { | |
| 243 for(uint32_t i = 0; i<lengthTransform.u32; i++) | |
| 244 { | |
| 245 ext_flash_read_block(&pSample1[i], EF_FIRMWARE); | |
| 246 } | |
| 247 | |
| 248 } | |
| 249 | |
| 250 ext_flash_read_block_stop(); | |
| 251 | |
| 252 if(magicByte) | |
| 253 { | |
| 254 *magicByte = pSample1[0x10000 + 0x3E]; // 0x3E == 62 | |
| 255 } | |
| 256 | |
| 257 actualAddress = backup; | |
| 258 return lengthTransform.u32; | |
| 259 } | |
| 260 | |
| 261 | |
| 262 void ext_flash_write_firmware2(uint32_t offset, uint8_t *pSample1, uint32_t length1, uint8_t *pSample2, uint32_t length2) | |
| 263 { | |
| 264 general32to8_Type lengthTransform, offsetTransform; | |
| 265 | |
| 266 lengthTransform.u32 = length1 + length2; | |
| 267 offsetTransform.u32 = offset; | |
| 268 | |
| 269 actualPointerFirmware2 = FWSTART2; | |
| 270 ef_write_block(lengthTransform.u8,4, EF_FIRMWARE2, 1); | |
| 271 ef_write_block(offsetTransform.u8,4, EF_FIRMWARE2, 1); | |
| 272 ef_write_block(pSample1,length1, EF_FIRMWARE2, 1); | |
| 273 if(length2) | |
| 274 ef_write_block(pSample2,length2, EF_FIRMWARE2, 1); | |
| 275 } | |
| 276 | |
| 277 | |
| 278 uint32_t ext_flash_read_firmware2(uint32_t *offset, uint8_t *pSample1, uint32_t max_length1, uint8_t *pSample2, uint32_t max_length2) | |
| 279 { | |
| 280 uint32_t backup = actualAddress; | |
| 281 uint32_t length1, length2; | |
| 282 general32to8_Type lengthTransform, offsetTransform; | |
| 283 | |
| 284 actualAddress = FWSTART2; | |
| 285 ext_flash_read_block_start(); | |
| 286 | |
| 287 ext_flash_read_block(&lengthTransform.u8[0], EF_FIRMWARE2); | |
| 288 ext_flash_read_block(&lengthTransform.u8[1], EF_FIRMWARE2); | |
| 289 ext_flash_read_block(&lengthTransform.u8[2], EF_FIRMWARE2); | |
| 290 ext_flash_read_block(&lengthTransform.u8[3], EF_FIRMWARE2); | |
| 291 | |
| 292 ext_flash_read_block(&offsetTransform.u8[0], EF_FIRMWARE2); | |
| 293 ext_flash_read_block(&offsetTransform.u8[1], EF_FIRMWARE2); | |
| 294 ext_flash_read_block(&offsetTransform.u8[2], EF_FIRMWARE2); | |
| 295 ext_flash_read_block(&offsetTransform.u8[3], EF_FIRMWARE2); | |
| 296 | |
| 297 *offset = offsetTransform.u32; | |
| 298 | |
| 299 if(lengthTransform.u32 == 0xFFFFFFFF) | |
| 300 { | |
| 301 lengthTransform.u32 = 0xFFFFFFFF; | |
| 302 } | |
| 303 else | |
| 304 if(lengthTransform.u32 > max_length1 + max_length2) | |
| 305 { | |
| 306 lengthTransform.u32 = 0xFF000000; | |
| 307 } | |
| 308 else | |
| 309 { | |
| 310 if(lengthTransform.u32 < max_length1) | |
| 311 { | |
| 312 length1 = lengthTransform.u32; | |
| 313 length2 = 0; | |
| 314 } | |
| 315 else | |
| 316 { | |
| 317 length1 = max_length1; | |
| 318 length2 = lengthTransform.u32 - max_length1; | |
| 319 } | |
| 320 | |
| 321 if(pSample1) | |
| 322 { | |
| 323 for(uint32_t i = 0; i<length1; i++) | |
| 324 { | |
| 325 ext_flash_read_block(&pSample1[i], EF_FIRMWARE2); | |
| 326 } | |
| 327 if(pSample2) | |
| 328 { | |
| 329 for(uint32_t i = 0; i<length2; i++) | |
| 330 { | |
| 331 ext_flash_read_block(&pSample2[i], EF_FIRMWARE2); | |
| 332 } | |
| 333 } | |
| 334 } | |
| 335 else if(pSample2) | |
| 336 { | |
| 1040 | 337 /* actualAddress += length1; do dummy read to get EEPROM to the correct address */ |
| 338 for(uint32_t i = 0; i<length1; i++) | |
| 339 { | |
| 340 ext_flash_read_block(&pSample2[0], EF_FIRMWARE2); | |
| 341 } | |
| 38 | 342 for(uint32_t i = 0; i<length2; i++) |
| 343 { | |
| 344 ext_flash_read_block(&pSample2[i], EF_FIRMWARE2); | |
| 345 } | |
| 346 } | |
| 347 } | |
| 348 ext_flash_read_block_stop(); | |
| 349 actualAddress = backup; | |
| 350 return lengthTransform.u32; | |
| 351 } | |
| 352 | |
| 353 | |
| 354 void ext_flash_read_fixed_16_devicedata_blocks_formated_128byte_total(uint8_t *buffer) | |
| 355 { | |
| 356 SDeviceLine data[16]; | |
| 357 uint8_t tempLengthIngnore; | |
| 358 uint16_t count; | |
| 359 uint8_t transfer; | |
| 360 | |
| 361 RTC_DateTypeDef Sdate; | |
| 362 RTC_TimeTypeDef Stime; | |
| 363 | |
| 364 actualAddress = DDSTART; | |
| 365 | |
| 366 ext_flash_read_block_start(); | |
| 367 ext_flash_read_block(&tempLengthIngnore, EF_DEVICEDATA); | |
| 368 ext_flash_read_block(&tempLengthIngnore, EF_DEVICEDATA); | |
| 369 | |
| 370 ext_flash_read_block_multi((uint8_t *)data,16*3*4, EF_DEVICEDATA); | |
| 371 ext_flash_read_block_stop(); | |
| 372 | |
| 373 count = 0; | |
| 374 for(int i=0;i<16;i++) | |
| 375 { | |
| 376 transfer = (data[i].value_int32 >> 24) & 0xFF; | |
| 377 buffer[count++] = transfer; | |
| 378 transfer = (data[i].value_int32 >> 16) & 0xFF; | |
| 379 buffer[count++] = transfer; | |
| 380 transfer = (data[i].value_int32 >> 8) & 0xFF; | |
| 381 buffer[count++] = transfer; | |
| 382 transfer = (data[i].value_int32) & 0xFF; | |
| 383 buffer[count++] = transfer; | |
| 384 | |
| 385 translateDate(data[i].date_rtc_dr, &Sdate); | |
| 386 translateTime(data[i].time_rtc_tr, &Stime); | |
| 387 buffer[count++] = Sdate.Year; | |
| 388 buffer[count++] = Sdate.Month; | |
| 389 buffer[count++] = Sdate.Date; | |
| 390 buffer[count++] = Stime.Hours; | |
| 391 } | |
| 392 } | |
| 393 | |
| 394 | |
| 395 #ifndef BOOTLOADER_STANDALONE | |
| 396 | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
397 void ext_flash_write_devicedata(uint8_t resetRing) |
| 38 | 398 { |
| 399 uint8_t *pData; | |
| 400 const uint16_t length = sizeof(SDevice); | |
| 401 uint8_t length_lo, length_hi; | |
| 402 uint8_t dataLength[2] = { 0 }; | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
403 uint32_t tmpBlockStart; |
| 38 | 404 |
| 405 ext_flash_disable_protection(); | |
| 406 | |
| 407 pData = (uint8_t *)stateDeviceGetPointer(); | |
| 408 | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
409 /* Reset the Ring to the start address if requested (e.g. because we write the default block during shutdown) */ |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
410 if((resetRing) || ((actualPointerDevicedata + length) >= DDSTOP)) |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
411 { |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
412 actualPointerDevicedata = DDSTART; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
413 } |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
414 tmpBlockStart = actualPointerDevicedata; |
| 38 | 415 |
| 416 length_lo = (uint8_t)(length & 0xFF); | |
| 417 length_hi = (uint8_t)(length >> 8); | |
| 418 dataLength[0] = length_lo; | |
| 419 dataLength[1] = length_hi; | |
| 420 | |
| 421 ef_write_block(dataLength,2, EF_DEVICEDATA, 0); | |
| 422 ef_write_block(pData,length, EF_DEVICEDATA, 0); | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
423 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
424 actualPointerDevicedata_Read = tmpBlockStart; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
425 |
| 38 | 426 } |
| 427 | |
| 428 | |
| 429 uint16_t ext_flash_read_devicedata(uint8_t *buffer, uint16_t max_length) | |
| 430 { | |
| 431 uint16_t length; | |
| 432 uint8_t length_lo, length_hi; | |
| 433 | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
434 actualAddress = actualPointerDevicedata_Read; |
| 38 | 435 |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
436 length = 0; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
437 length_lo = 0; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
438 length_hi = 0; |
| 38 | 439 ext_flash_read_block_start(); |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
440 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
441 |
| 38 | 442 ext_flash_read_block(&length_lo, EF_DEVICEDATA); |
| 443 ext_flash_read_block(&length_hi, EF_DEVICEDATA); | |
| 444 | |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
445 while ((length_lo != 0xFF) && (length_hi != 0xFF)) |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
446 { |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
447 length = (length_hi * 256) + length_lo; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
448 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
449 if(length > max_length) |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
450 return 0; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
451 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
452 ext_flash_read_block_multi(buffer,length,EF_DEVICEDATA); |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
453 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
454 ext_flash_read_block(&length_lo, EF_DEVICEDATA); /* check if another devicedata set is available */ |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
455 ext_flash_read_block(&length_hi, EF_DEVICEDATA); /* length will be 0xFFFF if a empty memory is read */ |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
456 } |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
457 ext_flash_decf_address_ring(EF_DEVICEDATA); /* set pointer back to empty address */ |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
458 ext_flash_decf_address_ring(EF_DEVICEDATA); |
| 38 | 459 ext_flash_read_block_stop(); |
|
421
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
460 |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
461 if(actualAddress > actualPointerDevicedata) /* the write pointer has not yet been set up probably */ |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
462 { |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
463 actualPointerDevicedata = actualAddress; |
|
3f7d80f37bfc
Enable sequentionel writing of device data:
ideenmodellierer
parents:
420
diff
changeset
|
464 } |
| 38 | 465 return length; |
| 466 } | |
| 467 | |
| 468 | |
| 469 void ext_flash_write_vpm(SVpm *vpmInput) | |
| 470 { | |
| 471 uint8_t *pData; | |
| 472 const uint16_t length = sizeof(SVpm); | |
| 473 | |
| 474 uint8_t length_lo, length_hi; | |
| 475 uint8_t dataLength[2] = { 0 }; | |
| 476 | |
| 477 pData = (uint8_t *)vpmInput; | |
| 478 | |
| 479 actualPointerVPM = VPMSTART; | |
| 480 | |
| 481 length_lo = (uint8_t)(length & 0xFF); | |
| 482 length_hi = (uint8_t)(length >> 8); | |
| 483 dataLength[0] = length_lo; | |
| 484 dataLength[1] = length_hi; | |
| 485 | |
| 486 ef_write_block(dataLength,2, EF_VPMDATA, 0); | |
| 487 ef_write_block(pData,length, EF_VPMDATA, 0); | |
| 488 } | |
| 489 | |
| 490 | |
| 491 int ext_flash_read_vpm(SVpm *vpmOutput) | |
| 492 { | |
| 493 uint8_t *pData; | |
| 494 const uint16_t length = sizeof(SVpm); | |
| 495 uint8_t length_lo, length_hi; | |
| 496 int output; | |
| 497 | |
| 498 actualAddress = VPMSTART; | |
| 499 | |
| 500 ext_flash_read_block_start(); | |
| 501 ext_flash_read_block(&length_lo, EF_VPMDATA); | |
| 502 ext_flash_read_block(&length_hi, EF_VPMDATA); | |
| 503 if((length_lo == (uint8_t)(length & 0xFF)) | |
| 504 &&(length_hi == (uint8_t)(length >> 8))) | |
| 505 { | |
| 506 pData = (uint8_t *)vpmOutput; | |
| 507 for(uint16_t i = 0; i < length; i++) | |
| 508 ext_flash_read_block(&pData[i], EF_VPMDATA); | |
| 509 output = length; | |
| 510 } | |
| 511 else | |
| 512 output = 0; | |
| 513 | |
| 514 ext_flash_read_block_stop(); | |
| 515 return output; | |
| 516 } | |
| 517 | |
| 518 #ifdef DEMOMODE | |
| 519 void ext_flash_write_settings(void) | |
| 520 { | |
| 521 return; | |
| 522 } | |
| 523 #else | |
| 1027 | 524 void ext_flash_write_settings(uint8_t whichSettings, uint8_t resetRing) |
| 38 | 525 { |
| 1027 | 526 SSettings *pSettings; |
| 38 | 527 const uint16_t length = sizeof(SSettings); |
| 528 uint8_t length_lo, length_hi; | |
| 529 uint8_t dataLength[2] = { 0 }; | |
| 530 | |
| 1027 | 531 pSettings = settingsGetPointer(); |
| 532 | |
| 38 | 533 ext_flash_disable_protection(); |
| 534 | |
| 1027 | 535 switch (whichSettings) |
| 38 | 536 { |
| 1027 | 537 default: |
| 538 case EF_SETTINGS: if(stateRealGetPointer()->lastKnownBatteryPercentage) | |
| 539 { | |
| 540 pSettings->lastKnownBatteryPercentage = stateRealGetPointer()->lastKnownBatteryPercentage; | |
| 541 } | |
| 542 pSettings->backup_localtime_rtc_tr = stateRealGetPointer()->lifeData.timeBinaryFormat; | |
| 543 pSettings->backup_localtime_rtc_dr = stateRealGetPointer()->lifeData.dateBinaryFormat; | |
| 544 /* Reset the Ring to the start address if requested (e.g. because we write the default block during shutdown) */ | |
| 545 if((resetRing) || ((actualPointerSettings + length) >= SETTINGSSTOP)) | |
| 546 { | |
| 547 actualPointerSettings = SETTINGSSTART; | |
| 548 } | |
| 549 break; | |
| 550 case EF_PROFILE0: actualPointerProfile = PROFILE0_START; | |
| 551 pSettings = profileGetPointer(0); | |
| 552 break; | |
| 553 case EF_PROFILE1: actualPointerProfile = PROFILE1_START; | |
| 554 pSettings = profileGetPointer(1); | |
| 555 break; | |
| 556 case EF_PROFILE2: actualPointerProfile = PROFILE2_START; | |
| 557 pSettings = profileGetPointer(2); | |
| 558 break; | |
| 559 case EF_PROFILE3: actualPointerProfile = PROFILE3_START; | |
| 560 pSettings = profileGetPointer(3); | |
| 561 break; | |
| 427 | 562 } |
| 38 | 563 |
| 564 length_lo = (uint8_t)(length & 0xFF); | |
| 565 length_hi = (uint8_t)(length >> 8); | |
| 566 dataLength[0] = length_lo; | |
| 567 dataLength[1] = length_hi; | |
| 568 | |
| 1027 | 569 ef_write_block(dataLength,2, whichSettings, 0); |
| 570 ef_write_block((uint8_t*)pSettings,length, whichSettings, 0); | |
| 38 | 571 // ext_flash_enable_protection(); |
| 572 } | |
| 573 #endif | |
| 574 | |
| 575 | |
| 576 /* CHANGES 150929 hw | |
| 577 * this now allows to read old settings too | |
| 578 * but make sure that everything is fixed in | |
| 579 * set_new_settings_missing_in_ext_flash | |
| 580 * new settings should be fine as they are added | |
| 581 * and loaded before calling this function | |
| 582 */ | |
| 1027 | 583 uint8_t ext_flash_read_settings(uint8_t whichSettings) |
| 38 | 584 { |
| 585 uint8_t returnValue = HAL_BUSY; | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
586 uint8_t exit = 0; |
| 38 | 587 uint8_t *pData; |
| 588 const uint16_t lengthStandardNow = sizeof(SSettings); | |
| 589 uint8_t length_lo, length_hi; | |
| 590 uint16_t lengthOnEEPROM; | |
| 591 uint32_t header; | |
| 1027 | 592 SSettings* pSettings = settingsGetPointer(); |
| 38 | 593 |
| 1027 | 594 switch(whichSettings) |
| 595 { | |
| 596 case EF_SETTINGS: pSettings = settingsGetPointer(); | |
| 597 actualAddress = SETTINGSSTART; | |
| 598 break; | |
| 599 case EF_PROFILE0: pSettings = profileGetPointer(0); | |
| 600 actualAddress = PROFILE0_START; | |
| 601 break; | |
| 602 case EF_PROFILE1: pSettings = profileGetPointer(1); | |
| 603 actualAddress = PROFILE1_START; | |
| 604 break; | |
| 605 case EF_PROFILE2: pSettings = profileGetPointer(2); | |
| 606 actualAddress = PROFILE2_START; | |
| 607 break; | |
| 608 case EF_PROFILE3: pSettings = profileGetPointer(3); | |
| 609 actualAddress = PROFILE3_START; | |
| 610 break; | |
| 611 default: returnValue = HAL_ERROR; | |
| 612 } | |
| 613 | |
| 614 if(returnValue != HAL_ERROR) | |
| 38 | 615 { |
| 1027 | 616 ext_flash_read_block_start(); |
| 617 ext_flash_read_block(&length_lo, whichSettings); | |
| 618 ext_flash_read_block(&length_hi, whichSettings); | |
| 619 | |
| 620 while ((length_lo != 0xFF) && (length_hi != 0xFF) && (exit == 0)) /* get the latest stored setting block */ | |
| 38 | 621 { |
| 1027 | 622 lengthOnEEPROM = length_hi * 256; |
| 623 lengthOnEEPROM += length_lo; | |
| 624 if(lengthOnEEPROM <= lengthStandardNow) /* EEPROM Header size equal or smaller => settings constant or upgraded */ | |
| 427 | 625 { |
| 1027 | 626 ext_flash_read_block_multi(&header, 4, whichSettings); |
| 627 if((header <= pSettings->header) && (header >= pSettings->updateSettingsAllowedFromHeader)) /* check to allow update of header */ | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
628 { |
| 1027 | 629 returnValue = HAL_OK; |
| 630 pSettings->header = header; | |
| 631 pData = (uint8_t *)pSettings + 4; /* header */ | |
| 632 for(uint16_t i = 0; i < (lengthOnEEPROM-4); i++) | |
| 633 ext_flash_read_block(&pData[i], whichSettings); | |
| 634 if(header != pSettings->header) /* setting layout changed => no additional setting sets expected */ | |
| 635 { | |
| 636 exit = 1; | |
| 637 } | |
| 638 } | |
| 639 else | |
| 640 { | |
| 641 returnValue = HAL_ERROR; | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
642 exit = 1; |
|
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
643 } |
|
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
644 } |
| 1027 | 645 else /* size of settings decreased => possible downgrade of firmware */ |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
646 { |
| 1027 | 647 ext_flash_read_block_multi(&header, 4, whichSettings); |
| 648 | |
| 649 if(header > 0xFFFF0014) /* verify that new (old) header should be compatible (only less bytes, no change in layout) */ | |
| 650 { | |
| 651 returnValue = HAL_OK; | |
| 652 pSettings->header = header; | |
| 653 pData = (uint8_t *)pSettings + 4; /* header */ | |
| 654 for(uint16_t i = 0; i < (lengthStandardNow-4); i++) /* only read the data fitting into the structure */ | |
| 655 ext_flash_read_block(&pData[i], whichSettings); | |
| 656 } | |
| 657 else | |
| 658 { | |
| 659 returnValue = HAL_ERROR; | |
| 660 } | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
661 exit = 1; |
|
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
662 } |
| 1027 | 663 ext_flash_read_block(&length_lo, whichSettings); |
| 664 ext_flash_read_block(&length_hi, whichSettings); | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
665 } |
| 1027 | 666 ext_flash_decf_address_ring(whichSettings); /* set pointer back to empty address */ |
| 667 ext_flash_decf_address_ring(whichSettings); | |
| 668 ext_flash_read_block_stop(); | |
|
538
b1eee27cd02b
BugFix firmware downgrade to version with less settings:
Ideenmodellierer
parents:
466
diff
changeset
|
669 |
| 1027 | 670 if(actualAddress > actualPointerSettings) /* the write pointer has not yet been set up probably */ |
| 671 { | |
| 672 actualPointerSettings = actualAddress; | |
| 38 | 673 } |
| 1027 | 674 ext_flash_read_block_stop(); |
| 427 | 675 } |
| 38 | 676 return returnValue; |
| 677 } | |
| 678 | |
| 679 | |
| 680 | |
| 681 | |
| 682 /* ext_flash_start_new_dive_log_and_set_actualPointerSample | |
| 683 * prepares the write sample pointer | |
| 684 * to be used by ext_flash_write_sample() | |
| 685 * to be set in the * pHeaderPreDive | |
| 686 * for write with ext_flash_create_new_dive_log() and ext_flash_close_new_dive_log() | |
| 687 */ | |
| 688 void ext_flash_start_new_dive_log_and_set_actualPointerSample(uint8_t *pHeaderPreDive) | |
| 689 { | |
| 690 convert_Type data; | |
| 691 SSettings *settings = settingsGetPointer(); | |
| 692 | |
| 693 /* new 5. Jan. 2015 */ | |
| 694 actualPointerSample = settings->logFlashNextSampleStartAddress; | |
| 695 | |
| 696 if(!ext_flash_test_remaining_space_of_page_empty(actualPointerSample, 4)) | |
| 697 ext_flash_set_to_begin_of_next_page(&actualPointerSample, EF_SAMPLE); | |
| 698 | |
| 699 if((actualPointerSample < SAMPLESTART) || (actualPointerSample > SAMPLESTOP)) | |
| 700 actualPointerSample = SAMPLESTART; | |
| 701 | |
| 702 data.u32bit = actualPointerSample; | |
| 703 pHeaderPreDive[2] = data.u8bit.byteLow; | |
| 704 pHeaderPreDive[3] = data.u8bit.byteMidLow; | |
| 705 pHeaderPreDive[4] = data.u8bit.byteMidHigh; | |
| 706 /* to start sample writing and header etc. pp. */ | |
| 707 ext_flash_disable_protection_for_logbook(); | |
| 708 } | |
| 709 | |
| 710 | |
| 711 /* ext_flash_create_new_dive_log | |
| 712 * uses the first header without HEADER2OFFSET | |
| 713 * for the header it is not important to be complete | |
| 714 * and can be reconstructed | |
| 715 * ext_flash_start_new_dive_log_and_set_actualPointerSample() | |
| 716 * has to be called before to set the actualPointerSample | |
| 717 * in the header | |
| 718 * the following func writes to header to the ext_flash | |
| 719 */ | |
| 720 void ext_flash_create_new_dive_log(uint8_t *pHeaderPreDive) | |
| 721 { | |
| 722 SSettings *settings; | |
|
429
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
723 uint8_t id; |
| 38 | 724 uint8_t header1, header2; |
| 725 | |
| 726 settings = settingsGetPointer(); | |
| 727 id = settings->lastDiveLogId; | |
| 728 | |
| 729 actualAddress = HEADERSTART + (0x800 * id); | |
| 730 ext_flash_read_block_start(); | |
|
429
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
731 ext_flash_read_block(&header1, EF_SAMPLE); /* the sample ring is increased instead of header... not sure if that is planned intention */ |
|
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
732 ext_flash_read_block(&header2, EF_SAMPLE); /* does not matter because actual address is reset in write_block call */ |
| 38 | 733 ext_flash_read_block_stop(); |
| 734 | |
|
429
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
735 /* TODO Cleanup_Ref_2: The code below should not be necessary in case of a proper shutdown and startup */ |
|
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
736 /* the implementation fixes an issue which might happen at Cleanup_Ref_1 (in case of more then 254 dives) */ |
| 38 | 737 if((header1 == 0xFA) && (header2 == 0xFA)) |
| 738 { | |
| 739 id += 1; /* 0-255, auto rollover */ | |
| 740 if(id & 1) | |
| 741 { | |
| 742 actualAddress = HEADERSTART + (0x800 * id); | |
| 743 ext_flash_read_block_start(); | |
| 744 ext_flash_read_block(&header1, EF_SAMPLE); | |
| 745 ext_flash_read_block(&header2, EF_SAMPLE); | |
| 746 ext_flash_read_block_stop(); | |
| 747 if((header1 == 0xFA) && (header2 == 0xFA)) | |
| 748 id += 1; | |
| 749 } | |
| 750 } | |
| 751 else | |
| 752 { | |
| 753 id = 0; | |
| 754 } | |
| 755 | |
| 756 settings->lastDiveLogId = id; | |
| 757 actualPointerHeader = HEADERSTART + (0x800 * id); | |
| 758 | |
| 759 if(pHeaderPreDive != 0) | |
| 760 ef_write_block(pHeaderPreDive,HEADERSIZE, EF_HEADER, 0); | |
| 761 } | |
| 762 | |
| 763 | |
| 764 void ext_flash_close_new_dive_log(uint8_t *pHeaderPostDive ) | |
| 765 { | |
| 766 SSettings * settings = settingsGetPointer(); | |
| 767 uint8_t id; | |
| 768 convert_Type startAddress; | |
| 769 convert_Type data; | |
| 770 uint32_t backup; | |
| 771 | |
| 772 uint8_t sampleData[3]; | |
| 773 actualAddress = actualPointerSample; | |
| 774 sampleData[0] = 0xFD; | |
| 775 sampleData[1] = 0xFD; | |
| 776 ext_flash_write_sample(sampleData, 2); | |
| 777 | |
| 778 /* end of sample data, pointing to the last sample 0xFD | |
| 779 */ | |
| 780 actualAddress = actualPointerSample; // change hw 17.09.2015 | |
| 781 ext_flash_decf_address_ring(EF_SAMPLE); // 17.09.2015: this decf actualAddress only!! | |
| 782 actualPointerSample = actualAddress; // change hw 17.09.2015 | |
| 783 data.u32bit = actualPointerSample; | |
| 784 | |
| 785 pHeaderPostDive[5] = data.u8bit.byteLow; | |
| 786 pHeaderPostDive[6] = data.u8bit.byteMidLow; | |
| 787 pHeaderPostDive[7] = data.u8bit.byteMidHigh; | |
| 788 | |
| 789 /* take data written before, calculate length and write | |
| 790 SLogbookHeader has different order: length (byte# 8,9,10) prior to profile version (byte# 11) | |
| 791 */ | |
| 792 startAddress.u8bit.byteLow = pHeaderPostDive[2]; | |
| 793 startAddress.u8bit.byteMidLow = pHeaderPostDive[3]; | |
| 794 startAddress.u8bit.byteMidHigh = pHeaderPostDive[4]; | |
| 795 startAddress.u8bit.byteHigh = 0; | |
| 796 | |
| 797 if(startAddress.u32bit < actualPointerSample) | |
| 798 data.u32bit = 1 + actualPointerSample - startAddress.u32bit; | |
| 799 else | |
| 800 data.u32bit = 2 + (actualPointerSample - SAMPLESTART) + (SAMPLESTOP - startAddress.u32bit); | |
| 801 | |
| 802 pHeaderPostDive[8] = data.u8bit.byteLow; | |
| 803 pHeaderPostDive[9] = data.u8bit.byteMidLow; | |
| 804 pHeaderPostDive[10] = data.u8bit.byteMidHigh; | |
| 805 | |
| 806 /* set id and write post-dive-header | |
| 807 */ | |
| 808 id = settings->lastDiveLogId; | |
| 809 actualPointerHeader = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 810 | |
| 811 ef_write_block(pHeaderPostDive,HEADERSIZE, EF_HEADER, 0); | |
| 812 | |
| 813 /* write length at beginning of sample | |
| 814 and write proper beginning for next dive to actualPointerSample | |
| 815 */ | |
| 816 backup = actualPointerSample; | |
| 817 actualPointerSample = startAddress.u32bit; // is still 0xFF | |
| 818 sampleData[0] = data.u8bit.byteLow; | |
| 819 sampleData[1] = data.u8bit.byteMidLow; | |
| 820 sampleData[2] = data.u8bit.byteMidHigh; | |
| 821 ext_flash_overwrite_sample_without_erase(sampleData, 3); | |
| 822 | |
| 823 actualAddress = backup; | |
| 824 ext_flash_incf_address(EF_SAMPLE); | |
| 825 actualPointerSample = actualAddress; | |
| 826 ext_flash_enable_protection(); | |
| 827 } | |
| 828 | |
| 829 | |
| 830 void ext_flash_write_sample(uint8_t *pSample, uint16_t length) | |
| 831 { | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
832 uint32_t actualAdressBackup = 0; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
833 |
| 38 | 834 ef_write_block(pSample,length, EF_SAMPLE, 0); |
| 835 | |
| 836 SSettings *settings = settingsGetPointer(); | |
| 837 settings->logFlashNextSampleStartAddress = actualPointerSample; | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
838 |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
839 if(0xFFFF - (actualAddress & 0x0000FFFF) < 255) /* are we close to a sector border? */ |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
840 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
841 if (((actualAddress & 0x0000FFFF) != 0) && (preparedPageAddress == 0)) /* only prepare if not already at start of sector */ |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
842 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
843 actualAdressBackup = actualAddress; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
844 actualAddress = (actualAddress & 0xFFFF0000) + 0x00010000; /* Set to start of next 64k sector */ |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
845 if(actualAddress >= SAMPLESTOP) |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
846 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
847 actualAddress = SAMPLESTART; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
848 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
849 preparedPageAddress = actualAddress; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
850 ext_flash_erase64kB(); |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
851 actualAddress = actualAdressBackup; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
852 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
853 } |
| 38 | 854 } |
| 855 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
856 static void ext_flash_overwrite_sample_without_erase(uint8_t *pSample, uint16_t length) |
| 38 | 857 { |
| 858 ef_write_block(pSample,length, EF_SAMPLE, 1); | |
| 859 } | |
| 860 | |
| 861 | |
| 862 uint8_t ext_flash_count_dive_headers(void) | |
| 863 { | |
| 864 uint8_t id = 0; | |
| 865 uint8_t counter = 0; | |
| 866 uint16_t headerStartData = 0x0000; | |
| 867 | |
| 868 id = settingsGetPointer()->lastDiveLogId; | |
| 869 | |
| 870 do | |
| 871 { | |
| 872 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 873 ext_flash_read_block_start(); | |
| 874 ext_flash_read_block_multi((uint8_t *)&headerStartData, 2, EF_HEADER); | |
| 875 ext_flash_read_block_stop(); | |
| 876 counter++; | |
| 877 id -=1; | |
| 878 } while((headerStartData == 0xFAFA) && (counter < 255)); | |
| 879 return (counter - 1); | |
| 880 } | |
| 881 | |
| 882 | |
| 883 void ext_flash_read_dive_header(uint8_t *pHeaderToFill, uint8_t StepBackwards) | |
| 884 { | |
| 885 SSettings *settings; | |
| 886 uint8_t id; | |
| 887 uint16_t i; | |
| 888 | |
| 889 settings = settingsGetPointer(); | |
| 890 id = settings->lastDiveLogId; | |
| 891 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 892 | |
| 893 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 894 ext_flash_read_block_start(); | |
| 895 for(i = 0; i < HEADERSIZE; i++) | |
| 896 ext_flash_read_block(&pHeaderToFill[i], EF_HEADER); | |
| 897 ext_flash_read_block_stop(); | |
| 898 | |
| 899 } | |
| 900 | |
| 901 void ext_flash_read_dive_header2(uint8_t *pHeaderToFill, uint8_t id, _Bool bOffset) | |
| 902 { | |
| 903 | |
| 904 uint16_t i; | |
| 905 actualAddress = HEADERSTART + (0x800 * id) ; | |
| 906 | |
| 907 if(bOffset) | |
| 908 actualAddress += HEADER2OFFSET; | |
| 909 ext_flash_read_block_start(); | |
| 910 for(i = 0; i < HEADERSIZE; i++) | |
| 911 ext_flash_read_block(&pHeaderToFill[i], EF_HEADER); | |
| 912 ext_flash_read_block_stop(); | |
| 913 } | |
| 914 | |
| 915 | |
| 916 uint32_t ext_flash_read_dive_raw_with_double_header_1K(uint8_t *data, uint32_t max_size, uint8_t StepBackwards) | |
| 917 { | |
| 918 if(max_size < 0x800) | |
| 919 return 0; | |
| 920 | |
| 921 uint8_t id; | |
| 922 convert_Type dataStart, dataEnd; | |
| 923 uint32_t LengthAll = 0; | |
| 924 | |
| 925 id = settingsGetPointer()->lastDiveLogId; | |
| 926 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 927 | |
| 928 // clear data | |
| 929 for(int i=0;i<0x800;i++) | |
| 930 data[i] = 0xFF; | |
| 931 | |
| 932 // copy primary/pre-dive | |
| 933 actualAddress = HEADERSTART + (0x800 * id); | |
| 934 ext_flash_read_block_start(); | |
| 935 for(int i = 0; i < HEADERSIZE; i++) | |
| 936 ext_flash_read_block(&data[i], EF_HEADER); | |
| 937 ext_flash_read_block_stop(); | |
| 938 | |
| 939 // copy main/secondary/post-dive | |
| 940 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 941 ext_flash_read_block_start(); | |
| 942 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 943 ext_flash_read_block(&data[i], EF_HEADER); | |
| 944 ext_flash_read_block_stop(); | |
| 945 | |
| 946 // data | |
| 947 | |
| 948 dataStart.u8bit.byteHigh = 0; | |
| 949 dataStart.u8bit.byteLow = data[0x402]; | |
| 950 dataStart.u8bit.byteMidLow = data[0x403]; | |
| 951 dataStart.u8bit.byteMidHigh = data[0x404]; | |
| 952 | |
| 953 dataEnd.u8bit.byteHigh = 0; | |
| 954 dataEnd.u8bit.byteLow = data[0x405]; | |
| 955 dataEnd.u8bit.byteMidLow = data[0x406]; | |
| 956 dataEnd.u8bit.byteMidHigh = data[0x407]; | |
| 957 | |
| 958 actualPointerSample = dataStart.u32bit; | |
| 959 if(dataEnd.u32bit >= dataStart.u32bit) | |
| 960 LengthAll = 1 + dataEnd.u32bit - dataStart.u32bit; | |
| 961 else | |
| 962 LengthAll = 2 + (dataStart.u32bit - SAMPLESTART) + (SAMPLESTOP - dataEnd.u32bit); | |
| 963 | |
| 964 LengthAll += 0x800; | |
| 965 | |
| 966 if(LengthAll > max_size) | |
| 967 return 0x800; | |
| 968 | |
| 969 actualAddress = actualPointerSample; | |
| 970 ext_flash_read_block_start(); | |
| 971 for(uint32_t i = 0x800; i < LengthAll; i++) | |
| 972 ext_flash_read_block(&data[i], EF_SAMPLE); | |
| 973 ext_flash_read_block_stop(); | |
| 974 return LengthAll; | |
| 975 } | |
| 976 | |
| 977 void ext_flash_write_dive_raw_with_double_header_1K(uint8_t *data, uint32_t length) | |
| 978 { | |
| 979 convert_Type dataStart, dataEnd; | |
| 980 SLogbookHeader headerTemp; | |
| 981 | |
| 982 // set actualPointerSample and get pointer to sample storage and disable flash write protect | |
| 983 ext_flash_start_new_dive_log_and_set_actualPointerSample((uint8_t *)&headerTemp); | |
| 984 | |
| 985 dataStart.u8bit.byteHigh = 0; | |
| 986 dataStart.u8bit.byteLow = headerTemp.pBeginProfileData[0]; | |
| 987 dataStart.u8bit.byteMidLow = headerTemp.pBeginProfileData[1]; | |
| 988 dataStart.u8bit.byteMidHigh = headerTemp.pBeginProfileData[2]; | |
| 989 | |
| 990 dataEnd.u32bit = dataStart.u32bit + length - 0x801; | |
| 991 if(dataEnd.u32bit > SAMPLESTOP) | |
| 992 dataEnd.u32bit -= SAMPLESTOP + SAMPLESTART - 1; | |
| 993 | |
| 994 data[0x002] = data[0x402] = dataStart.u8bit.byteLow; | |
| 995 data[0x003] = data[0x403] = dataStart.u8bit.byteMidLow; | |
| 996 data[0x004] = data[0x404] = dataStart.u8bit.byteMidHigh; | |
| 997 data[0x005] = data[0x405] = dataEnd.u8bit.byteLow; | |
| 998 data[0x006] = data[0x406] = dataEnd.u8bit.byteMidLow; | |
| 999 data[0x007] = data[0x407] = dataEnd.u8bit.byteMidHigh; | |
| 1000 | |
| 1001 // set actualPointerHeader to next free header and update lastDiveLogId | |
| 1002 ext_flash_create_new_dive_log(0); | |
| 1003 | |
| 1004 // copy header data | |
| 1005 ef_write_block(data,0x800,EF_HEADER, 1); | |
| 1006 | |
| 1007 // copy sample data | |
| 1008 ef_write_block(&data[0x800], length-0x800, EF_SAMPLE, 1); | |
| 1009 | |
| 1010 // update logFlashNextSampleStartAddress | |
| 1011 settingsGetPointer()->logFlashNextSampleStartAddress = actualPointerSample; | |
| 1012 } | |
| 1013 | |
| 1014 | |
| 1015 // =============================================================================== | |
| 1016 // ext_flash_read_header_memory | |
| 1017 /// @brief This function returns the entire header space 1:1 | |
| 1018 /// @date 04-April-2016 | |
| 1019 /// | |
| 1020 /// @param *data 256KB output | |
| 1021 // =============================================================================== | |
| 1022 void ext_flash_read_header_memory(uint8_t *data) | |
| 1023 { | |
| 1024 actualAddress = HEADERSTART; | |
| 1025 actualPointerHeader = actualAddress; | |
| 1026 ext_flash_read_block_start(); | |
| 1027 for(int i=0;i<8;i++) | |
| 1028 ext_flash_read_block_multi(&data[0x8000 * i], 0x8000, EF_HEADER); | |
| 1029 ext_flash_read_block_stop(); | |
| 1030 } | |
| 1031 | |
| 1032 | |
| 1033 // =============================================================================== | |
| 463 | 1034 // ext_flash_write_header_memory |
| 38 | 1035 /// @brief This function erases and overwrites the entire logbook header block |
| 1036 /// @date 04-April-2016 | |
| 1037 /// | |
| 1038 /// @param *data 256KB input of header memory 1:1 | |
| 1039 // =============================================================================== | |
| 1040 void ext_flash_write_header_memory(uint8_t *data) | |
| 1041 { | |
| 1042 actualAddress = HEADERSTART; | |
| 1043 actualPointerHeader = actualAddress; | |
| 1044 ef_write_block(data, 0x40000, EF_HEADER, 0); | |
| 1045 } | |
| 1046 | |
| 463 | 1047 void ext_flash_read_sample_memory(uint8_t *data,uint16_t blockId) |
| 1048 { | |
| 1049 actualAddress = SAMPLESTART; | |
| 1050 actualAddress += blockId * 0x8000; /* add 32k Block offset */ | |
| 1051 actualPointerSample = actualAddress; | |
| 1052 ext_flash_read_block_start(); | |
| 1053 ext_flash_read_block_multi(data, 0x8000, EF_SAMPLE); | |
| 1054 ext_flash_read_block_stop(); | |
| 1055 } | |
| 1056 | |
| 1057 void ext_flash_write_sample_memory(uint8_t *data,uint16_t blockId) | |
| 1058 { | |
| 1059 actualAddress = SAMPLESTART; | |
| 1060 actualAddress += blockId * 0x8000; /* add 32k Block offset */ | |
| 1061 actualPointerSample = actualAddress; | |
| 1062 ef_write_block(data, 0x8000, EF_SAMPLE,0); | |
| 1063 } | |
| 1064 | |
| 38 | 1065 |
| 1066 void ext_flash_open_read_sample(uint8_t StepBackwards, uint32_t *totalNumberOfBytes) | |
| 1067 { | |
| 1068 SSettings *settings = settingsGetPointer(); | |
| 1069 uint8_t id; | |
| 1070 convert_Type dataStart, dataEnd; | |
| 1071 uint8_t header1, header2; | |
| 1072 | |
| 1073 id = settings->lastDiveLogId; | |
| 1074 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 1075 # | |
| 1076 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1077 actualPointerHeader = actualAddress; | |
| 1078 | |
| 1079 ext_flash_read_block_start(); | |
| 1080 /* little endian */ | |
| 1081 ext_flash_read_block(&header1, EF_HEADER); | |
| 1082 ext_flash_read_block(&header2, EF_HEADER); | |
| 1083 dataStart.u8bit.byteHigh = 0; | |
| 1084 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1085 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1086 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1087 dataEnd.u8bit.byteHigh = 0; | |
| 1088 ext_flash_read_block(&dataEnd.u8bit.byteLow, EF_HEADER); | |
| 1089 ext_flash_read_block(&dataEnd.u8bit.byteMidLow, EF_HEADER); | |
| 1090 ext_flash_read_block(&dataEnd.u8bit.byteMidHigh, EF_HEADER); | |
| 1091 ext_flash_read_block_stop(); | |
| 1092 | |
| 1093 actualPointerSample = dataStart.u32bit; | |
| 1094 if(dataEnd.u32bit >= dataStart.u32bit) | |
| 1095 LengthLeftSampleRead = 1 + dataEnd.u32bit - dataStart.u32bit; | |
| 1096 else | |
| 1097 LengthLeftSampleRead = 2 + (dataStart.u32bit - SAMPLESTART) + (SAMPLESTOP - dataEnd.u32bit); | |
| 1098 *totalNumberOfBytes = LengthLeftSampleRead; | |
| 1099 | |
| 1100 actualAddress = actualPointerSample; | |
| 1101 ext_flash_read_block_start(); | |
| 1102 } | |
| 1103 | |
| 1104 | |
| 1105 void ext_flash_read_next_sample_part(uint8_t *pSample, uint8_t length) | |
| 1106 { | |
| 1107 for(uint16_t i = 0; i < length; i++) | |
| 1108 ext_flash_read_block(&pSample[i], EF_SAMPLE); | |
| 1109 } | |
| 1110 | |
| 1111 | |
| 1112 void ext_flash_close_read_sample(void) | |
| 1113 { | |
| 1114 actualPointerSample = actualAddress; | |
| 1115 ext_flash_read_block_stop(); | |
| 1116 } | |
| 1117 | |
| 1118 | |
| 1119 void ext_flash_set_entry_point(void) | |
| 1120 { | |
| 1121 entryPoint = actualAddress; | |
| 1122 } | |
| 1123 | |
| 1124 | |
| 1125 void ext_flash_reopen_read_sample_at_entry_point(void) | |
| 1126 { | |
| 1127 error_led_on(); | |
| 1128 chip_unselect(); | |
| 1129 wait_chip_not_busy(); | |
| 1130 | |
| 1131 actualAddress = entryPoint; | |
| 1132 ext_flash_read_block_start(); | |
| 1133 error_led_off(); | |
| 1134 } | |
| 1135 | |
| 1136 /* | |
| 1137 uint8_t ext_flash_point_to_64k_block_in_headerSpace(uint8_t logId) | |
| 1138 { | |
| 1139 uint32_t pointerToData = logId * 0x800; | |
| 1140 | |
| 1141 return pointerToData / 0x10000; | |
| 1142 } | |
| 1143 */ | |
| 1144 | |
| 1145 | |
| 1146 // =============================================================================== | |
| 1147 // ext_flash_repair_dive_numbers_starting_count_helper | |
| 1148 /// @brief | |
| 1149 /// @date 22-June-2016 | |
| 1150 | |
| 1151 // =============================================================================== | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1152 static uint16_t ext_flash_repair_dive_numbers_starting_count_helper(uint8_t *data, uint8_t *change64k, uint16_t startNumber, uint8_t lastLogId) |
| 38 | 1153 { |
| 1154 const uint32_t headerStep = 0x800; | |
| 1155 uint8_t actualLogId = 0; | |
| 1156 uint16_t oldNumber = 0; | |
| 1157 uint16_t actualNumber = 0; | |
| 1158 SLogbookHeader *ptrLogbookHeader = 0; | |
| 1159 | |
| 1160 if(startNumber == 0) | |
| 1161 return 0; | |
| 1162 | |
| 1163 actualNumber = startNumber - 1; | |
| 1164 | |
| 282 | 1165 // where is the oldest dive (Which is now getting startNumber) |
| 38 | 1166 // use first header for ease (without HEADER2OFFSET for end of dive header) |
| 1167 // compare for lastLogId to prevent endless loop | |
| 1168 | |
| 1169 if(*(uint16_t*)&data[lastLogId * headerStep] != 0xFAFA) | |
| 1170 return 0; | |
| 1171 | |
| 1172 actualLogId = lastLogId - 1; | |
| 1173 while((*(uint16_t*)&data[actualLogId * headerStep] == 0xFAFA) && (actualLogId != lastLogId)) | |
| 1174 { | |
| 1175 actualLogId--; | |
| 1176 } | |
| 1177 | |
| 1178 // now pointing to one behind the last | |
| 1179 while(actualLogId != lastLogId) | |
| 1180 { | |
| 1181 actualLogId++; | |
| 1182 actualNumber++; | |
| 1183 ptrLogbookHeader = (SLogbookHeader *)&data[actualLogId * headerStep]; | |
| 1184 | |
| 1185 oldNumber = ptrLogbookHeader->diveNumber; | |
| 1186 if(oldNumber != actualNumber) | |
| 1187 { | |
| 1188 // change64k[ext_flash_point_to_64k_block_in_headerSpace(actualLogId )] = 1; | |
| 1189 change64k[(actualLogId * 0x800)/0x10000] = 1; | |
| 1190 ptrLogbookHeader->diveNumber = actualNumber; | |
| 1191 ptrLogbookHeader = (SLogbookHeader *)(&data[actualLogId * headerStep] + HEADER2OFFSET); | |
| 1192 ptrLogbookHeader->diveNumber = actualNumber; | |
| 1193 } | |
| 1194 } | |
| 1195 | |
| 1196 return actualNumber; | |
| 1197 } | |
| 1198 | |
| 1199 // =============================================================================== | |
| 1200 // ext_flash_repair_SPECIAL_dive_numbers_starting_count_with | |
| 1201 /// @brief This function | |
| 1202 /// @date 04-April-2016 | |
| 282 | 1203 /// problem (160621): 64K blocks (32 dives) in the new flash memory chip |
| 1204 /// This block needs to be deleted | |
| 1205 /// these where only 4KB block before | |
| 38 | 1206 /// @output endCount, last diveNumber |
| 1207 | |
| 1208 // =============================================================================== | |
| 1209 uint16_t ext_flash_repair_SPECIAL_dive_numbers_starting_count_with(uint16_t startCount) | |
| 1210 { | |
| 1211 uint32_t logCopyDataPtr = 0; | |
| 1212 uint8_t *data; | |
| 1213 uint16_t lastCount; | |
| 282 | 1214 uint8_t listOfChanged64kBlocks[8]; // 32 dives each 64K |
| 38 | 1215 |
| 1216 logCopyDataPtr = getFrame(97); | |
| 1217 data = (uint8_t *)logCopyDataPtr; | |
| 1218 | |
| 1219 for(int i=0;i<8;i++) | |
| 1220 listOfChanged64kBlocks[i] = 0; | |
| 1221 | |
| 1222 actualAddress = HEADERSTART; | |
| 1223 ext_flash_read_block_start(); | |
| 1224 ext_flash_read_block_multi(data,0x100000,EF_HEADER); | |
| 1225 ext_flash_read_block_stop(); | |
| 1226 | |
| 1227 lastCount = ext_flash_repair_dive_numbers_starting_count_helper(data, listOfChanged64kBlocks, startCount, settingsGetPointer()->lastDiveLogId); | |
| 1228 | |
| 1229 for(int i=0;i<8;i++) | |
| 1230 { | |
| 1231 if(listOfChanged64kBlocks[i] != 0) | |
| 1232 { | |
| 1233 actualPointerHeader = HEADERSTART + (i * 0x10000); | |
| 1234 ef_write_block(&data[i * 0x10000], 0x10000, EF_HEADER, 0); | |
| 1235 } | |
| 1236 } | |
| 1237 | |
| 1238 releaseFrame(97,logCopyDataPtr); | |
| 1239 if(settingsGetPointer()->totalDiveCounter < lastCount) | |
| 1240 { | |
| 1241 settingsGetPointer()->totalDiveCounter = lastCount; | |
| 1242 } | |
| 1243 return lastCount; | |
| 1244 } | |
| 1245 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1246 /* |
| 38 | 1247 void OLD_ext_flash_repair_SPECIAL_dive_numbers_starting_count_with(uint16_t startCount) |
| 1248 { | |
| 1249 uint16_t counterStorage[256]; | |
| 1250 uint8_t start = 0xFF; | |
| 1251 uint32_t logCopyDataPtr = 0; | |
| 1252 uint8_t *data; | |
| 1253 uint8_t startAbsolute = 0; | |
| 1254 int16_t count = 0; | |
| 1255 _Bool repair = 0; | |
| 1256 uint8_t startBackup = 0; | |
| 1257 | |
| 1258 SLogbookHeader tempLogbookHeader; | |
| 1259 SLogbookHeader *ptrHeaderInData1a; | |
| 1260 SLogbookHeader *ptrHeaderInData1b; | |
| 1261 SLogbookHeader *ptrHeaderInData2a; | |
| 1262 SLogbookHeader *ptrHeaderInData2b; | |
| 1263 | |
| 1264 logCopyDataPtr = getFrame(97); | |
| 1265 data = (uint8_t *)logCopyDataPtr; | |
| 1266 ptrHeaderInData1a = (SLogbookHeader *)logCopyDataPtr; | |
| 1267 ptrHeaderInData1b = (SLogbookHeader *)(logCopyDataPtr + HEADER2OFFSET); | |
| 1268 ptrHeaderInData2a = (SLogbookHeader *)(logCopyDataPtr + 0x800); | |
| 1269 ptrHeaderInData2b = (SLogbookHeader *)(logCopyDataPtr + 0x800 + HEADER2OFFSET); | |
| 1270 | |
| 1271 // get data | |
| 1272 for(int StepBackwards = 0; StepBackwards < 255; StepBackwards++) | |
| 1273 { | |
| 1274 logbook_getHeader(StepBackwards, &tempLogbookHeader); | |
| 1275 counterStorage[StepBackwards+1] = tempLogbookHeader.diveNumber; | |
| 1276 if(tempLogbookHeader.diveHeaderStart == 0xFAFA) | |
| 1277 start = StepBackwards; | |
| 1278 else | |
| 1279 break; | |
| 1280 } | |
| 1281 | |
| 1282 if(start == 0xFF) | |
| 1283 return; | |
| 1284 | |
| 1285 count = start + 1; | |
| 1286 startAbsolute = settingsGetPointer()->lastDiveLogId; | |
| 1287 | |
| 1288 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1289 |
| 38 | 1290 if(start%2) |
| 1291 { | |
| 1292 if(counterStorage[start] != startCount) | |
| 1293 { | |
| 1294 // clear data | |
| 1295 for(int i=0;i<0x800*2;i++) | |
| 1296 data[i] = 0xFF; | |
| 1297 | |
| 1298 uint8_t id = settingsGetPointer()->lastDiveLogId; | |
| 1299 id -= start; // 0-255, auto rollover | |
| 1300 | |
| 1301 // copy primary/pre-dive | |
| 1302 actualAddress = HEADERSTART + (0x800 * id); | |
| 1303 ext_flash_read_block_start(); | |
| 1304 for(int i = 0; i < HEADERSIZE; i++) | |
| 1305 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1306 ext_flash_read_block_stop(); | |
| 1307 | |
| 1308 // copy main/secondary/post-dive | |
| 1309 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1310 ext_flash_read_block_start(); | |
| 1311 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1312 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1313 ext_flash_read_block_stop(); | |
| 1314 | |
| 1315 // repair | |
| 1316 ptrHeaderInData2a->diveNumber = startCount; | |
| 1317 ptrHeaderInData2b->diveNumber = startCount; | |
| 1318 startCount++; | |
| 1319 | |
| 1320 // write | |
| 1321 actualAddress = HEADERSTART + (0x800 * (id-1)); | |
| 1322 ef_write_block(data,0x800*2,EF_HEADER, 0); | |
| 1323 } | |
| 1324 start--; | |
| 1325 } | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1326 |
| 38 | 1327 // for(int count = start; count > -1; count -= 2) |
| 1328 | |
| 1329 while(count > 0) | |
| 1330 { | |
| 1331 // clear data | |
| 1332 for(int i=0;i<0x1000;i++) | |
| 1333 data[i] = 0xFF; | |
| 1334 | |
| 1335 repair = 0; | |
| 1336 | |
| 1337 startBackup = startAbsolute; | |
| 1338 | |
| 1339 if(startAbsolute%2) // 0x800 to 0x1000 | |
| 1340 { | |
| 1341 // copy second pre-dive | |
| 1342 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1343 ext_flash_read_block_start(); | |
| 1344 for(int i = 0x800; i < HEADERSIZE+0x800; i++) | |
| 1345 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1346 ext_flash_read_block_stop(); | |
| 1347 | |
| 1348 // copy second post-dive | |
| 1349 actualAddress = HEADERSTART + HEADER2OFFSET + (0x800 * startAbsolute); | |
| 1350 ext_flash_read_block_start(); | |
| 1351 for(int i = 0xC00; i < HEADERSIZE+0xC00; i++) | |
| 1352 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1353 ext_flash_read_block_stop(); | |
| 1354 | |
| 1355 if(counterStorage[count] != startCount) | |
| 1356 { | |
| 1357 ptrHeaderInData2a->diveNumber = startCount; | |
| 1358 ptrHeaderInData2b->diveNumber = startCount; | |
| 1359 repair = 1; | |
| 1360 } | |
| 1361 startCount += 1; | |
| 1362 | |
| 1363 startAbsolute -= 1; | |
| 1364 count -= 1; | |
| 1365 | |
| 1366 if(count > 0) | |
| 1367 { | |
| 1368 // copy first pre-dive | |
| 1369 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1370 ext_flash_read_block_start(); | |
| 1371 for(int i = 0; i < HEADERSIZE; i++) | |
| 1372 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1373 ext_flash_read_block_stop(); | |
| 1374 | |
| 1375 // copy first post-dive | |
| 1376 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1377 ext_flash_read_block_start(); | |
| 1378 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1379 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1380 ext_flash_read_block_stop(); | |
| 1381 | |
| 1382 if(counterStorage[count] != startCount) | |
| 1383 { | |
| 1384 ptrHeaderInData1a->diveNumber = startCount; | |
| 1385 ptrHeaderInData1b->diveNumber = startCount; | |
| 1386 repair = 1; | |
| 1387 } | |
| 1388 startCount += 1; | |
| 1389 | |
| 1390 startAbsolute -= 1; | |
| 1391 count -= 1; | |
| 1392 } | |
| 1393 } | |
| 1394 else | |
| 1395 { | |
| 1396 // copy first pre-dive | |
| 1397 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1398 ext_flash_read_block_start(); | |
| 1399 for(int i = 0; i < HEADERSIZE; i++) | |
| 1400 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1401 ext_flash_read_block_stop(); | |
| 1402 | |
| 1403 // copy first post-dive | |
| 1404 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1405 ext_flash_read_block_start(); | |
| 1406 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1407 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1408 ext_flash_read_block_stop(); | |
| 1409 | |
| 1410 if(counterStorage[count] != startCount) | |
| 1411 { | |
| 1412 ptrHeaderInData1a->diveNumber = startCount; | |
| 1413 ptrHeaderInData1b->diveNumber = startCount; | |
| 1414 repair = 1; | |
| 1415 } | |
| 1416 startCount += 1; | |
| 1417 | |
| 1418 startAbsolute -= 1; | |
| 1419 count -= 1; | |
| 1420 } | |
| 1421 | |
| 1422 // write | |
| 1423 if(repair) | |
| 1424 { | |
| 1425 actualPointerHeader = HEADERSTART + (0x1000 * startBackup%2); | |
| 1426 ef_write_block(data,0x1000,EF_HEADER, 0); | |
| 1427 } | |
| 1428 } | |
| 1429 releaseFrame(97,logCopyDataPtr); | |
| 1430 settingsGetPointer()->totalDiveCounter = startCount; | |
| 1431 } | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1432 */ |
| 38 | 1433 |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1434 uint8_t ext_dive_log_consistent(void) |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1435 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1436 uint8_t ret = 0; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1437 uint8_t header1, header2; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1438 uint8_t id; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1439 convert_Type dataStart; |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1440 convert_Type dataEnd; |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1441 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1442 SSettings *settings = settingsGetPointer(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1443 id = settings->lastDiveLogId; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1444 |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1445 if(settings->lastDiveLogId != 0) /* not trust LogID 0 which might be reset by a settings problem */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1446 { /* ==> Find function will be called restoring the Id belonging to the latest sample */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1447 actualAddress = HEADERSTART + (0x800 * id); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1448 ext_flash_read_block_start(); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1449 ext_flash_read_block(&header1, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1450 ext_flash_read_block(&header2, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1451 ext_flash_read_block_stop(); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1452 if((header1 == 0xFA) && (header2 == 0xFA)) /* Header is indicating the start of a dive */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1453 { |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1454 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1455 ext_flash_read_block_start(); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1456 ext_flash_read_block(&header1, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1457 ext_flash_read_block(&header2, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1458 dataStart.u8bit.byteHigh = 0; |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1459 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1460 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1461 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1462 dataEnd.u8bit.byteHigh = 0; |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1463 ext_flash_read_block(&dataEnd.u8bit.byteLow, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1464 ext_flash_read_block(&dataEnd.u8bit.byteMidLow, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1465 ext_flash_read_block(&dataEnd.u8bit.byteMidHigh, EF_HEADER); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1466 ext_flash_read_block_stop(); |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1467 |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1468 if((header1 == 0xFA) && (header2 == 0xFA)) /* Secondary header was written at the end of a dive */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1469 { |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1470 if(dataStart.u32bit < dataEnd.u32bit) |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1471 { |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1472 ret = 1; /* => lastDiveLogID points to a valid dive entry */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1473 } |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1474 else /* check if address wrap is valid */ |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1475 { |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1476 if(ext_flash_SampleOverrunValid()) |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1477 { |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1478 ret = 1; |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1479 } |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1480 } |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1481 } |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1482 } |
|
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
1483 } |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1484 return ret; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1485 } |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1486 |
| 38 | 1487 // =============================================================================== |
| 1488 // ext_flash_repair_dive_log | |
| 1489 /// @brief This function | |
| 1490 /// does set | |
| 1491 /// logFlashNextSampleStartAddress | |
| 1492 /// and | |
| 1493 /// lastDiveLogId | |
| 1494 /// | |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1495 |
| 38 | 1496 void ext_flash_repair_dive_log(void) |
| 1497 { | |
| 1498 uint8_t header1, header2; | |
| 1499 convert_Type dataStart; | |
| 1500 | |
| 1501 for(int id = 0; id < 255;id++) | |
| 1502 { | |
| 1503 actualAddress = HEADERSTART + (0x800 * id); | |
| 1504 ext_flash_read_block_start(); | |
| 1505 ext_flash_read_block(&header1, EF_HEADER); | |
| 1506 ext_flash_read_block(&header2, EF_HEADER); | |
| 1507 dataStart.u8bit.byteHigh = 0; | |
| 1508 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1509 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1510 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1511 ext_flash_read_block_stop(); | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1512 if((header1 == 0xFA) && (header2 == 0xFA)) /* Header is indicating the start of a dive */ |
| 38 | 1513 { |
| 1514 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1515 ext_flash_read_block_start(); | |
| 1516 ext_flash_read_block(&header1, EF_HEADER); | |
| 1517 ext_flash_read_block(&header2, EF_HEADER); | |
| 1518 ext_flash_read_block_stop(); | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1519 if((header1 != 0xFA) || (header2 != 0xFA)) /* Secondary header was not written at the end of a dive */ |
| 38 | 1520 { |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1521 actualPointerSample = dataStart.u32bit; /* Set datapointer to position stored in header written at beginning of dive */ |
| 38 | 1522 actualAddress = actualPointerSample; |
| 1523 logbook_recover_brokenlog(id); | |
| 1524 SSettings *settings = settingsGetPointer(); | |
| 1525 settings->logFlashNextSampleStartAddress = actualPointerSample; | |
| 1526 } | |
| 1527 } | |
| 1528 } | |
| 1529 ext_flash_find_start(); | |
| 1530 } | |
| 1531 | |
| 1532 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1533 static void ext_flash_find_start(void) |
| 38 | 1534 { |
| 1535 uint8_t id; | |
| 1536 uint8_t header1, header2; | |
| 1537 convert_Type dataStart, dataEnd; | |
| 1538 | |
|
429
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
1539 /* TODO Cleanup_Ref_1: cleanup logFlashNextSampleStartAddress and lastDiveLogId */ |
|
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
1540 /* The implementation below would cause problems in case more then 254 dives would be done. */ |
|
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
1541 /* This is avoided by Cleanup_Ref2 */ |
|
441
9a9e4908ce2e
fix potential issue with >255 dives in the logbook
heinrichsweikamp
parents:
429
diff
changeset
|
1542 for(id = 0; id <= 255;id++) |
| 38 | 1543 { |
| 1544 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1545 ext_flash_read_block_start(); | |
| 1546 ext_flash_read_block(&header1, EF_HEADER); | |
| 1547 ext_flash_read_block(&header2, EF_HEADER); | |
| 1548 dataStart.u8bit.byteHigh = 0; | |
| 1549 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1550 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1551 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1552 ext_flash_read_block_stop(); | |
| 1553 if((header1 == 0xFF) && (header2 == 0xFF)) | |
| 1554 { | |
| 1555 break; | |
| 1556 } | |
| 1557 } | |
| 1558 id--; | |
| 1559 SSettings *settings = settingsGetPointer(); | |
| 1560 settings->lastDiveLogId = id; | |
| 1561 | |
| 1562 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1563 actualPointerHeader = actualAddress; | |
| 1564 | |
| 1565 ext_flash_read_block_start(); | |
| 1566 | |
| 1567 ext_flash_read_block(&header1, EF_HEADER); | |
| 1568 ext_flash_read_block(&header2, EF_HEADER); | |
| 1569 dataStart.u8bit.byteHigh = 0; | |
| 1570 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1571 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1572 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1573 dataEnd.u8bit.byteHigh = 0; | |
| 1574 ext_flash_read_block(&dataEnd.u8bit.byteLow, EF_HEADER); | |
| 1575 ext_flash_read_block(&dataEnd.u8bit.byteMidLow, EF_HEADER); | |
| 1576 ext_flash_read_block(&dataEnd.u8bit.byteMidHigh, EF_HEADER); | |
| 1577 ext_flash_read_block_stop(); | |
| 1578 | |
| 1579 //Find free space | |
| 1580 if((header1 == 0xFA) && (header2 == 0xFA)) | |
| 1581 { | |
| 1582 uint8_t uiRead = 0; | |
| 1583 int countFF = 0; | |
| 1584 //End of last complete dive | |
| 1585 actualPointerSample = dataEnd.u32bit ; | |
| 1586 actualAddress = actualPointerSample; | |
| 1587 //Check if there are samples of dives with less than half a minute | |
| 1588 while(true) | |
| 1589 { | |
| 1590 ext_flash_read_block_start(); | |
| 1591 ext_flash_read_block(&uiRead, EF_SAMPLE); | |
| 1592 if(uiRead == 0xFF) | |
| 1593 countFF++; | |
| 1594 else | |
| 1595 countFF = 0; | |
| 1596 | |
| 1597 | |
| 1598 | |
| 1599 if(countFF == 10) | |
| 1600 { | |
| 1601 actualAddress -= 10; | |
| 1602 break; | |
| 1603 } | |
| 1604 | |
| 1605 //New page: clear | |
| 1606 if(ext_flash_erase_if_on_page_start()) | |
| 1607 break; | |
| 1608 } | |
| 1609 // Set new start address | |
| 1610 actualPointerSample = actualAddress; | |
| 1611 settings->logFlashNextSampleStartAddress = actualPointerSample; | |
| 1612 } | |
| 1613 else | |
| 1614 { | |
| 1615 settings->logFlashNextSampleStartAddress = SAMPLESTART; | |
| 1616 } | |
| 1617 } | |
| 1618 | |
| 1619 | |
| 870 | 1620 |
| 38 | 1621 |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1622 static void ext_flash_disable_protection(void) |
| 38 | 1623 { |
| 1624 /* | |
| 1625 extFlashStatusBit8_Type status; | |
| 1626 | |
| 1627 status.uw = 0; | |
| 1628 | |
| 1629 wait_chip_not_busy(); | |
| 1630 write_spi(0x50,RELEASE); // EWSR | |
| 1631 write_spi(0x01,HOLDCS); // WRSR | |
| 1632 write_spi(status.uw,RELEASE); // new status | |
| 1633 */ | |
| 1634 } | |
| 870 | 1635 #endif |
| 38 | 1636 |
| 1637 void ext_flash_disable_protection_for_logbook(void) | |
| 1638 { | |
| 1639 /* | |
| 1640 extFlashStatusBit8_Type status; | |
| 1641 | |
| 1642 status.uw = 0; | |
| 1643 status.ub.BlockProtect0 = 1; | |
| 1644 status.ub.BlockProtect1 = 0; | |
| 1645 status.ub.BlockProtect2 = 1; | |
| 1646 status.ub.BlockProtect3 = 0; // not set in OSTC3. Why? | |
| 1647 | |
| 1648 wait_chip_not_busy(); | |
| 1649 write_spi(0x50,RELEASE); // EWSR | |
| 1650 write_spi(0x01,HOLDCS); // WRSR | |
| 1651 write_spi(status.uw,RELEASE); // new status | |
| 1652 */ | |
| 1653 } | |
| 1654 | |
| 1655 | |
| 1656 void ext_flash_enable_protection(void) | |
| 1657 { | |
| 1658 /* | |
| 1659 extFlashStatusBit8_Type status; | |
| 1660 | |
| 1661 status.uw = 0; | |
| 1662 status.ub.BlockProtect0 = 1; | |
| 1663 status.ub.BlockProtect1 = 1; | |
| 1664 status.ub.BlockProtect2 = 1; | |
| 1665 status.ub.BlockProtect3 = 1; // not set in OSTC3. Why? | |
| 1666 | |
| 1667 wait_chip_not_busy(); | |
| 1668 write_spi(0x50,RELEASE); // EWSR | |
| 1669 write_spi(0x01,HOLDCS); // WRSR | |
| 1670 write_spi(status.uw,RELEASE); // new status | |
| 1671 */ | |
| 1672 } | |
| 1673 | |
| 1674 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1675 /*void ext_flash_erase_chip(void) |
| 38 | 1676 { |
| 1677 wait_chip_not_busy(); | |
| 1678 write_spi(0x06,RELEASE); | |
| 1679 write_spi(0x60,RELEASE); | |
| 1680 wait_chip_not_busy(); | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1681 }*/ |
| 38 | 1682 |
| 1683 void ext_flash_erase_firmware(void) | |
| 1684 { | |
| 1685 uint32_t size, blocks_64k; | |
| 1686 | |
| 1687 actualAddress = FWSTART; | |
| 1688 size = 1 + FWSTOP - FWSTART; | |
| 1689 blocks_64k = size / 0x10000; | |
| 1690 ef_erase_64K(blocks_64k); | |
| 1691 } | |
| 1692 | |
| 1693 void ext_flash_erase_firmware2(void) | |
| 1694 { | |
| 1695 uint32_t size, blocks_64k; | |
| 1696 | |
| 1697 actualAddress = FWSTART2; | |
| 1698 size = 1 + FWSTOP2 - FWSTART2; | |
| 1699 blocks_64k = size / 0x10000; | |
| 1700 ef_erase_64K(blocks_64k); | |
| 1701 } | |
| 1702 | |
| 1703 | |
| 1704 | |
| 1705 void ext_flash_erase_logbook(void) | |
| 1706 { | |
| 1707 uint32_t size, blocks_64k; | |
| 1708 | |
| 1709 ext_flash_disable_protection_for_logbook(); | |
| 1710 | |
| 1711 actualAddress = SAMPLESTART; | |
| 1712 size = 1 + SAMPLESTOP - SAMPLESTART; | |
| 1713 blocks_64k = size / 0x10000; | |
| 1714 ef_erase_64K(blocks_64k); | |
| 1715 | |
| 1716 actualAddress = HEADERSTART; | |
| 1717 size = 1 + HEADERSTOP - HEADERSTART; | |
| 1718 blocks_64k = size / 0x10000; | |
| 1719 ef_erase_64K(blocks_64k); | |
| 1720 | |
| 1721 ext_flash_enable_protection(); | |
| 1722 } | |
| 1723 | |
| 1724 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1725 static void ext_flash_erase4kB(void) |
| 38 | 1726 { |
| 1727 wait_chip_not_busy(); | |
| 1728 write_spi(0x06,RELEASE);/* WREN */ | |
| 1729 write_spi(0x20,HOLDCS);/* sector erase cmd */ | |
| 1730 write_address(RELEASE); | |
| 1731 } | |
| 1732 | |
| 282 | 1733 /* be careful - might not work with entire family and other products |
| 38 | 1734 * see page 14 of LOGBOOK_V3_S25FS-S_00-271247.pdf |
| 1735 */ | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1736 static void ext_flash_erase32kB(void) |
| 38 | 1737 { |
| 1738 uint32_t actualAddress_backup; | |
| 1739 | |
| 1740 actualAddress_backup = actualAddress; | |
| 1741 actualAddress = 0; | |
| 1742 wait_chip_not_busy(); | |
| 1743 write_spi(0x06,RELEASE);/* WREN */ | |
| 1744 write_spi(0xD8,HOLDCS);/* sector erase cmd */ | |
| 1745 write_address(RELEASE); | |
| 1746 actualAddress = actualAddress_backup; | |
| 1747 } | |
| 1748 | |
| 1749 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1750 static void ext_flash_erase64kB(void) |
| 38 | 1751 { |
| 1752 wait_chip_not_busy(); | |
| 1753 write_spi(0x06,RELEASE);/* WREN */ | |
| 1754 write_spi(0xD8,HOLDCS);/* sector erase cmd */ | |
| 1755 write_address(RELEASE); | |
| 1756 } | |
| 1757 | |
| 1758 | |
| 1759 void ext_flash_read_block_start(void) | |
| 1760 { | |
| 1761 wait_chip_not_busy(); | |
| 1762 write_spi(0x03,HOLDCS); /* WREN */ | |
| 1763 write_address(HOLDCS); | |
| 1764 } | |
| 1765 | |
| 1766 /* 4KB, 32KB, 64 KB, not the upper 16 MB with 4 Byte address at the moment */ | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1767 static uint8_t ext_flash_erase_if_on_page_start(void) |
| 38 | 1768 { |
| 1769 if(actualAddress < 0x00008000) | |
| 1770 { | |
| 1771 /* 4K Byte is 0x1000 */ | |
| 1772 if((actualAddress & 0xFFF) == 0) | |
| 1773 { | |
| 1774 ext_flash_erase4kB(); | |
| 1775 return 1; | |
| 1776 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1777 } |
| 38 | 1778 else |
| 1779 if(actualAddress < 0x00010000) | |
| 1780 { | |
| 1781 /* 32K Byte is only one page */ | |
| 1782 if(actualAddress == 0x00010000) | |
| 1783 { | |
| 1784 ext_flash_erase32kB(); | |
| 1785 return 1; | |
| 1786 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1787 } |
| 38 | 1788 else |
| 1789 { | |
| 1790 /* 64K Byte is 0x10000 */ | |
| 1791 if((actualAddress & 0xFFFF) == 0) | |
| 1792 { | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1793 if(preparedPageAddress == actualAddress) /* has page already been prepared before? (at the moment for samples only) */ |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1794 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1795 preparedPageAddress = 0; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1796 |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1797 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1798 else |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1799 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1800 ext_flash_erase64kB(); |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1801 } |
| 38 | 1802 return 1; |
| 1803 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1804 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1805 |
| 38 | 1806 return 0; |
| 1807 } | |
| 1808 | |
| 1809 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1810 static void ext_flash_read_block(uint8_t *getByte, uint8_t type) |
| 38 | 1811 { |
| 1812 *getByte = read_spi(HOLDCS);/* read data */ | |
| 1813 ext_flash_incf_address(type); | |
| 1814 } | |
| 1815 | |
| 1816 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1817 static void ext_flash_read_block_multi(void *getByte, uint32_t size, uint8_t type) |
| 38 | 1818 { |
| 1819 uint8_t *data; | |
| 1820 data = getByte; | |
| 1821 | |
| 1822 for(uint32_t i=0;i<size;i++) | |
| 1823 { | |
| 1824 data[i] = read_spi(HOLDCS);/* read data */ | |
| 1825 ext_flash_incf_address(type); | |
| 1826 } | |
| 1827 } | |
| 1828 | |
| 1829 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1830 static void ext_flash_read_block_stop(void) |
| 38 | 1831 { |
| 1832 chip_unselect(); | |
| 1833 } | |
| 1834 | |
| 1835 | |
| 1836 /* Private functions ---------------------------------------------------------*/ | |
| 1837 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1838 static void ef_write_block(uint8_t * sendByte, uint32_t length, uint8_t type, uint8_t do_not_erase) |
| 38 | 1839 { |
| 1840 uint32_t remaining_page_size, remaining_length, remaining_space_to_ring_end; | |
| 420 | 1841 uint32_t i=0; |
| 1842 | |
| 38 | 1843 if(!length) |
| 1844 return; | |
| 1845 | |
| 1846 uint32_t ringStart, ringStop; | |
| 1847 | |
| 1848 switch(type) | |
| 1849 { | |
| 1850 case EF_HEADER: | |
| 1851 actualAddress = actualPointerHeader; | |
| 1852 ringStart = HEADERSTART; | |
| 1853 ringStop = HEADERSTOP; | |
| 1854 break; | |
| 1855 case EF_SAMPLE: | |
| 1856 actualAddress = actualPointerSample; | |
| 1857 ringStart = SAMPLESTART; | |
| 1858 ringStop = SAMPLESTOP; | |
| 1859 break; | |
| 1860 case EF_DEVICEDATA: | |
| 1861 actualAddress = actualPointerDevicedata; | |
| 1862 ringStart = DDSTART; | |
| 1863 ringStop = DDSTOP; | |
| 1864 break; | |
| 1865 case EF_VPMDATA: | |
| 1866 actualAddress = actualPointerVPM; | |
| 1867 ringStart = VPMSTART; | |
| 1868 ringStop = VPMSTOP; | |
| 1869 break; | |
| 1870 case EF_SETTINGS: | |
| 1871 actualAddress = actualPointerSettings; | |
| 1872 ringStart = SETTINGSSTART; | |
| 1873 ringStop = SETTINGSSTOP; | |
| 1874 break; | |
| 1875 case EF_FIRMWARE: | |
| 1876 actualAddress = actualPointerFirmware; | |
| 1877 ringStart = FWSTART; | |
| 1878 ringStop = FWSTOP; | |
| 1879 break; | |
| 1880 case EF_FIRMWARE2: | |
| 1881 actualAddress = actualPointerFirmware2; | |
| 1882 ringStart = FWSTART2; | |
| 1883 ringStop = FWSTOP2; | |
| 1884 break; | |
| 1027 | 1885 case EF_PROFILE0: |
| 1886 case EF_PROFILE1: | |
| 1887 case EF_PROFILE2: | |
| 1888 case EF_PROFILE3: actualAddress = actualPointerProfile; | |
| 1889 ringStart = PROFILE0_START; | |
| 1890 ringStop = PROFILE3_STOP; | |
| 1891 break; | |
| 38 | 1892 default: |
| 1893 ringStart = FLASHSTART; | |
| 1894 ringStop = FLASHSTOP; | |
| 1895 break; | |
| 1896 } | |
| 1897 /* safety */ | |
| 1898 if(actualAddress < ringStart) | |
| 1899 actualAddress = ringStart; | |
| 1900 | |
| 1901 if(do_not_erase == 0) | |
|
459
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1902 { |
|
466
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
1903 ext_flash_erase_if_on_page_start(); |
|
459
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1904 } |
| 38 | 1905 |
| 420 | 1906 while( i<length) |
| 38 | 1907 { |
| 1908 ef_hw_rough_delay_us(5); | |
| 1909 wait_chip_not_busy(); | |
| 1910 write_spi(0x06,RELEASE); /* WREN */ | |
| 1911 write_spi(0x02,HOLDCS); /* write cmd */ | |
| 1912 write_address(HOLDCS); | |
| 1913 | |
| 1914 remaining_length = length - i; | |
| 420 | 1915 remaining_page_size = 0xFF - (uint8_t)(actualAddress & 0xFF) +1; |
| 38 | 1916 remaining_space_to_ring_end = ringStop - actualAddress; |
| 1917 | |
| 420 | 1918 if(remaining_length >= 256) |
| 1919 { | |
| 1920 remaining_length = 255; /* up to 256 bytes may be written in one burst. Last byte is written with release */ | |
| 1921 } | |
| 1922 else | |
| 38 | 1923 { |
| 420 | 1924 remaining_length--; /* last byte needed for release */ |
| 1925 } | |
| 1926 if(remaining_length >= (remaining_page_size) ) /* use 256 byte page and calculate number of bytes left */ | |
| 1927 { | |
| 1928 remaining_length = remaining_page_size - 1; | |
| 1929 } | |
| 1930 if( (remaining_space_to_ring_end >= 256)) | |
| 1931 { | |
| 1932 for(int j=0; j<remaining_length; j++) | |
| 38 | 1933 { |
| 1934 write_spi(sendByte[i],HOLDCS);/* write data */ | |
| 1935 actualAddress++; | |
| 1936 i++; | |
| 1937 } | |
| 1938 } | |
| 1939 /* byte with RELEASE */ | |
| 1940 write_spi(sendByte[i],RELEASE);/* write data */ | |
| 1941 actualAddress++; | |
| 420 | 1942 i++; |
| 1943 | |
| 38 | 1944 if(actualAddress > ringStop) |
| 1945 actualAddress = ringStart; | |
| 420 | 1946 |
| 38 | 1947 if(do_not_erase == 0) |
| 1948 ext_flash_erase_if_on_page_start(); | |
| 1949 } | |
| 1950 switch(type) | |
| 1951 { | |
| 1952 case EF_HEADER: | |
| 1953 actualPointerHeader = actualAddress; | |
| 1954 break; | |
| 1955 case EF_SAMPLE: | |
| 1956 actualPointerSample = actualAddress; | |
| 1957 break; | |
| 1958 case EF_DEVICEDATA: | |
| 1959 actualPointerDevicedata = actualAddress; | |
| 1960 break; | |
| 1961 case EF_VPMDATA: | |
| 1962 actualPointerVPM = actualAddress; | |
| 1963 break; | |
| 1964 case EF_SETTINGS: | |
| 1965 actualPointerSettings = actualAddress; | |
| 1966 break; | |
| 1967 case EF_FIRMWARE: | |
| 1968 actualPointerFirmware = actualAddress; | |
| 1969 break; | |
| 1970 case EF_FIRMWARE2: | |
| 1971 actualPointerFirmware2 = actualAddress; | |
| 1972 break; | |
| 1027 | 1973 case EF_PROFILE0: |
| 1974 case EF_PROFILE1: | |
| 1975 case EF_PROFILE2: | |
| 1976 case EF_PROFILE3: actualPointerProfile = actualAddress; | |
| 1977 break; | |
| 38 | 1978 default: |
| 1979 break; | |
| 1980 } | |
| 1981 } | |
| 1982 | |
| 870 | 1983 #ifndef BOOTLOADER_STANDALONE |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1984 static _Bool ext_flash_test_remaining_space_of_page_empty(uint32_t pointer, uint16_t length) |
| 38 | 1985 { |
| 1986 if((pointer & 0xFFF) == 0) | |
| 1987 return 1; | |
| 1988 | |
| 1989 uint32_t backup = actualAddress; | |
| 1990 uint8_t data; | |
| 1991 uint32_t size_to_page_end; | |
| 1992 | |
| 1993 size_to_page_end = 0x1000 - (pointer & 0xFFF); | |
| 1994 if(length > size_to_page_end) | |
| 1995 length = size_to_page_end; | |
| 1996 | |
| 1997 actualAddress = pointer; | |
| 1998 ext_flash_read_block_start(); | |
| 1999 | |
| 2000 for(uint16_t i = 0; i<length; i++) | |
| 2001 { | |
| 2002 ext_flash_read_block(&data, 255); // 255 = ENTIRE FLASH | |
| 2003 if(data != 0xFF) | |
| 2004 { | |
| 2005 ext_flash_read_block_stop(); | |
| 2006 actualAddress = backup; | |
| 2007 return 0; | |
| 2008 } | |
| 2009 } | |
| 2010 ext_flash_read_block_stop(); | |
| 2011 actualAddress = backup; | |
| 2012 return 1; | |
| 2013 } | |
| 2014 | |
| 2015 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2016 static void ext_flash_set_to_begin_of_next_page(uint32_t *pointer, uint8_t type) |
| 38 | 2017 { |
| 2018 uint32_t ringStart, ringStop; | |
| 2019 | |
| 2020 switch(type) | |
| 2021 { | |
| 2022 case EF_HEADER: | |
| 2023 ringStart = HEADERSTART; | |
| 2024 ringStop = HEADERSTOP; | |
| 2025 break; | |
| 2026 case EF_SAMPLE: | |
| 2027 ringStart = SAMPLESTART; | |
| 2028 ringStop = SAMPLESTOP; | |
| 2029 break; | |
| 2030 case EF_DEVICEDATA: | |
| 2031 ringStart = DDSTART; | |
| 2032 ringStop = DDSTOP; | |
| 2033 break; | |
| 2034 case EF_VPMDATA: | |
| 2035 ringStart = VPMSTART; | |
| 2036 ringStop = VPMSTOP; | |
| 2037 break; | |
| 2038 case EF_SETTINGS: | |
| 2039 ringStart = SETTINGSSTART; | |
| 2040 ringStop = SETTINGSSTOP; | |
| 2041 break; | |
| 1027 | 2042 case EF_PROFILE0: |
| 2043 case EF_PROFILE1: | |
| 2044 case EF_PROFILE2: | |
| 2045 case EF_PROFILE3: ringStart = PROFILE0_START; | |
| 2046 ringStop = PROFILE3_STOP; | |
| 2047 break; | |
| 2048 | |
| 38 | 2049 default: |
| 2050 ringStart = FLASHSTART; | |
| 2051 ringStop = FLASHSTOP; | |
| 2052 break; | |
| 2053 } | |
| 2054 | |
| 2055 *pointer = (*pointer & 0xFFF) + 0x1000; | |
| 2056 | |
| 2057 if((*pointer < ringStart) || (*pointer >= ringStop)) | |
| 2058 *pointer = ringStart; | |
| 2059 } | |
| 870 | 2060 #endif |
| 38 | 2061 |
| 2062 static void ef_erase_64K(uint32_t blocks) | |
| 2063 { | |
| 2064 for(uint32_t i = 0; i < blocks; i++) | |
| 2065 { | |
| 2066 wait_chip_not_busy(); | |
| 2067 write_spi(0x06,RELEASE);/* WREN */ | |
| 2068 write_spi(0xD8,HOLDCS);/* 64k erase cmd */ | |
| 2069 write_address(RELEASE); | |
| 2070 actualAddress += 0x10000; | |
| 2071 HAL_Delay(25); | |
| 2072 } | |
| 2073 } | |
| 2074 | |
| 2075 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2076 static void chip_unselect(void) |
| 38 | 2077 { |
| 2078 HAL_GPIO_WritePin(EXTFLASH_CSB_GPIO_PORT,EXTFLASH_CSB_PIN,GPIO_PIN_SET); // chip select | |
| 2079 } | |
| 2080 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2081 static void chip_select(void) |
| 38 | 2082 { |
| 2083 HAL_GPIO_WritePin(EXTFLASH_CSB_GPIO_PORT,EXTFLASH_CSB_PIN,GPIO_PIN_RESET); // chip select | |
| 2084 } | |
| 870 | 2085 #ifndef BOOTLOADER_STANDALONE |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2086 static void error_led_on(void) |
| 38 | 2087 { |
| 2088 HAL_GPIO_WritePin(OSCILLOSCOPE_GPIO_PORT,OSCILLOSCOPE_PIN,GPIO_PIN_SET); | |
| 2089 } | |
| 2090 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2091 static void error_led_off(void) |
| 38 | 2092 { |
| 2093 HAL_GPIO_WritePin(OSCILLOSCOPE_GPIO_PORT,OSCILLOSCOPE_PIN,GPIO_PIN_RESET); | |
| 2094 } | |
| 870 | 2095 #endif |
| 38 | 2096 |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2097 static uint8_t read_spi(uint8_t unselect_CS_afterwards) |
| 38 | 2098 { |
| 2099 uint8_t byte; | |
| 2100 | |
| 2101 chip_select(); | |
| 2102 | |
| 2103 if(HAL_SPI_Receive(&hspiDisplay, &byte, 1, 10000) != HAL_OK) | |
| 2104 Error_Handler_extflash(); | |
| 2105 | |
| 2106 while (HAL_SPI_GetState(&hspiDisplay) != HAL_SPI_STATE_READY) | |
| 2107 { | |
| 2108 } | |
| 2109 if(unselect_CS_afterwards) | |
| 2110 chip_unselect(); | |
| 2111 | |
| 2112 return byte; | |
| 2113 } | |
| 2114 | |
| 2115 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2116 static void write_spi(uint8_t data, uint8_t unselect_CS_afterwards) |
| 38 | 2117 { |
| 2118 chip_select(); | |
| 2119 | |
| 2120 if(HAL_SPI_Transmit(&hspiDisplay, &data, 1, 10000) != HAL_OK) | |
| 2121 Error_Handler_extflash(); | |
| 2122 | |
| 2123 while (HAL_SPI_GetState(&hspiDisplay) != HAL_SPI_STATE_READY) | |
| 2124 { | |
| 2125 } | |
| 2126 if(unselect_CS_afterwards) | |
| 2127 chip_unselect(); | |
| 2128 } | |
| 2129 | |
| 2130 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2131 static void write_address(uint8_t unselect_CS_afterwards) |
| 38 | 2132 { |
| 2133 uint8_t hi, med ,lo; | |
| 2134 | |
| 2135 hi = (actualAddress >> 16) & 0xFF; | |
| 2136 med = (actualAddress >> 8) & 0xFF; | |
| 2137 lo = actualAddress & 0xFF; | |
| 2138 | |
| 2139 write_spi(hi, HOLDCS); | |
| 2140 write_spi(med, HOLDCS); | |
| 2141 write_spi(lo, unselect_CS_afterwards); | |
| 2142 } | |
| 2143 | |
| 2144 | |
| 2145 static void wait_chip_not_busy(void) | |
| 2146 { | |
| 2147 uint8_t status; | |
| 2148 | |
| 2149 chip_unselect(); | |
| 2150 | |
| 2151 write_spi(0x05,HOLDCS); /* RDSR */ | |
| 2152 status = read_spi(HOLDCS);/* read status */ | |
| 2153 while(status & 0x01) | |
| 2154 { | |
| 2155 HAL_Delay(1); | |
| 2156 status = read_spi(HOLDCS);/* read status */ | |
| 2157 } | |
| 2158 chip_unselect(); | |
| 2159 } | |
| 2160 | |
| 2161 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2162 static void ext_flash_incf_address(uint8_t type) |
| 38 | 2163 { |
| 2164 uint32_t ringStart, ringStop; | |
| 2165 | |
| 2166 actualAddress += 1; | |
| 2167 | |
| 2168 switch(type) | |
| 2169 { | |
| 2170 case EF_HEADER: | |
| 2171 ringStart = HEADERSTART; | |
| 2172 ringStop = HEADERSTOP; | |
| 2173 break; | |
| 2174 case EF_SAMPLE: | |
| 2175 ringStart = SAMPLESTART; | |
| 2176 ringStop = SAMPLESTOP; | |
| 2177 break; | |
| 2178 case EF_DEVICEDATA: | |
| 2179 ringStart = DDSTART; | |
| 2180 ringStop = DDSTOP; | |
| 2181 break; | |
| 2182 case EF_VPMDATA: | |
| 2183 ringStart = VPMSTART; | |
| 2184 ringStop = VPMSTOP; | |
| 2185 break; | |
| 2186 case EF_SETTINGS: | |
| 2187 ringStart = SETTINGSSTART; | |
| 2188 ringStop = SETTINGSSTOP; | |
| 2189 break; | |
| 2190 case EF_FIRMWARE: | |
| 2191 ringStart = FWSTART; | |
| 2192 ringStop = FWSTOP; | |
| 2193 break; | |
| 2194 case EF_FIRMWARE2: | |
| 2195 ringStart = FWSTART2; | |
| 2196 ringStop = FWSTOP2; | |
| 2197 break; | |
| 1027 | 2198 case EF_PROFILE0: |
| 2199 case EF_PROFILE1: | |
| 2200 case EF_PROFILE2: | |
| 2201 case EF_PROFILE3: ringStart = PROFILE0_START; | |
| 2202 ringStop = PROFILE3_STOP; | |
| 2203 break; | |
| 38 | 2204 default: |
| 2205 ringStart = FLASHSTART; | |
| 2206 ringStop = FLASHSTOP; | |
| 2207 break; | |
| 2208 } | |
| 2209 | |
| 2210 if((actualAddress < ringStart) || (actualAddress > ringStop)) | |
| 2211 actualAddress = ringStart; | |
| 2212 } | |
| 2213 | |
| 870 | 2214 #ifndef BOOTLOADER_STANDALONE |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2215 static void ext_flash_decf_address_ring(uint8_t type) |
| 38 | 2216 { |
| 2217 uint32_t ringStart, ringStop; | |
| 2218 | |
| 2219 switch(type) | |
| 2220 { | |
| 2221 case EF_HEADER: | |
| 2222 ringStart = HEADERSTART; | |
| 2223 ringStop = HEADERSTOP; | |
| 2224 break; | |
| 2225 case EF_SAMPLE: | |
| 2226 ringStart = SAMPLESTART; | |
| 2227 ringStop = SAMPLESTOP; | |
| 2228 break; | |
| 2229 case EF_DEVICEDATA: | |
| 2230 ringStart = DDSTART; | |
| 2231 ringStop = DDSTOP; | |
| 2232 break; | |
| 2233 case EF_VPMDATA: | |
| 2234 ringStart = VPMSTART; | |
| 2235 ringStop = VPMSTOP; | |
| 2236 break; | |
| 2237 case EF_SETTINGS: | |
| 2238 ringStart = SETTINGSSTART; | |
| 2239 ringStop = SETTINGSSTOP; | |
| 2240 break; | |
| 2241 case EF_FIRMWARE: | |
| 2242 ringStart = FWSTART; | |
| 2243 ringStop = FWSTOP; | |
| 2244 break; | |
| 2245 case EF_FIRMWARE2: | |
| 2246 ringStart = FWSTART2; | |
| 2247 ringStop = FWSTOP2; | |
| 2248 break; | |
| 1027 | 2249 case EF_PROFILE0: |
| 2250 case EF_PROFILE1: | |
| 2251 case EF_PROFILE2: | |
| 2252 case EF_PROFILE3: ringStart = PROFILE0_START; | |
| 2253 ringStop = PROFILE3_STOP; | |
| 2254 break; | |
| 2255 | |
| 38 | 2256 default: |
| 2257 ringStart = FLASHSTART; | |
| 2258 ringStop = FLASHSTOP; | |
| 2259 break; | |
| 2260 } | |
| 2261 | |
| 2262 if((actualAddress <= ringStart) || (actualAddress > ringStop)) | |
| 2263 actualAddress = ringStop; | |
| 2264 else | |
| 2265 actualAddress -= 1; | |
| 2266 } | |
| 870 | 2267 #endif |
| 38 | 2268 |
| 2269 static void ef_hw_rough_delay_us(uint32_t delayUs) | |
| 2270 { | |
| 2271 if(!delayUs) | |
| 2272 return; | |
| 2273 delayUs*= 12; | |
| 2274 while(delayUs--); | |
| 2275 return; | |
| 2276 } | |
| 2277 | |
| 2278 static void Error_Handler_extflash(void) | |
| 2279 { | |
| 2280 while(1) | |
| 2281 { | |
| 2282 } | |
| 2283 } | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2284 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2285 void ext_flash_CloseSector(void) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2286 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2287 uint32_t actualAddressBackup = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2288 int i=0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2289 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2290 if(closeSectorAddress != 0) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2291 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2292 /* write some dummy bytes to the sector which is currently used for storing samples. This is done to "hide" problem if function is calles again */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2293 actualAddress = closeSectorAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2294 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2295 wait_chip_not_busy(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2296 write_spi(0x06,RELEASE); /* WREN */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2297 write_spi(0x02,HOLDCS); /* write cmd */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2298 write_address(HOLDCS); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2299 for(i = 0; i<8; i++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2300 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2301 write_spi(0xA5,HOLDCS);/* write data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2302 actualAddress++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2303 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2304 /* byte with RELEASE */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2305 write_spi(0xA5,RELEASE);/* write data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2306 actualAddress = actualAddressBackup; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2307 closeSectorAddress = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2308 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2309 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2310 |
|
466
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2311 /* This function validates a potential jump of sample address by checking the last sector for empty memory cells */ |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2312 uint8_t ext_flash_SampleOverrunValid(void) |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2313 { |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2314 uint8_t jumpvalid = 1; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2315 uint32_t curAddress, actualaddrbackup; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2316 uint8_t tmpBuffer; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2317 uint8_t emptyCellCnt = 0; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2318 |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2319 actualaddrbackup = actualAddress; |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2320 curAddress = SAMPLESTOP - 20; /* check the last 20 bytes of the last sample sector */ |
|
466
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2321 actualAddress = curAddress; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2322 ext_flash_read_block_start(); |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2323 while(actualAddress < SAMPLESTOP) |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2324 { |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2325 tmpBuffer = read_spi(HOLDCS);/* read data */ |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2326 if(tmpBuffer == 0xFF) |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2327 { |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2328 emptyCellCnt++; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2329 } |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2330 actualAddress++; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2331 } |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2332 ext_flash_read_block_stop(); |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2333 |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2334 if(emptyCellCnt == 20) |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2335 { |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2336 jumpvalid = 0; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2337 } |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2338 actualAddress = actualaddrbackup; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2339 return jumpvalid; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2340 } |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2341 |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2342 uint32_t ext_flash_AnalyseSampleBuffer() |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2343 { |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2344 uint8_t sectorState[192]; /* samples are stored in 192 sector / 64k each */ |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2345 uint32_t curAddress = SAMPLESTART; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2346 uint8_t curSector = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2347 uint8_t samplebuffer[10]; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2348 uint32_t actualAddressBackup = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2349 uint8_t emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2350 uint32_t i = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2351 uint8_t startedSectors = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2352 uint8_t lastSectorInuse = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2353 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2354 /* check if a sector is used till its end */ |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2355 for(curSector = 0; curSector < 192; curSector++) |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2356 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2357 sectorState[curSector] = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2358 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2359 curAddress = SAMPLESTART + (curSector * 0x10000); /* set address to begin of sector and check if it is used */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2360 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2361 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2362 for(uint32_t i=0;i<10;i++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2363 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2364 samplebuffer[i] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2365 if(samplebuffer[i] == 0xFF) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2366 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2367 emptyCellCnt++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2368 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2369 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2370 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2371 if(emptyCellCnt == 10) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2372 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2373 sectorState[curSector] = SECTOR_NOTUSED; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2374 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2375 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2376 curAddress = SAMPLESTART + (curSector * 0x10000) + 0xFFF5; /* set address to end of sector and check if it is used */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2377 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2378 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2379 for(i=0;i<10;i++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2380 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2381 samplebuffer[i] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2382 if(samplebuffer[i] == 0xFF) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2383 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2384 emptyCellCnt++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2385 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2386 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2387 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2388 if(emptyCellCnt == 10) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2389 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2390 sectorState[curSector] |= SECTOR_INUSE; /* will become SECTOR_EMPTY if start is NOTUSED */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2391 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2392 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2393 |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2394 for(i=0;i<192;i++) |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2395 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2396 if( sectorState[i] == SECTOR_INUSE) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2397 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2398 startedSectors++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2399 lastSectorInuse = i; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2400 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2401 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2402 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2403 if(startedSectors > 1) /* more than one sector is in used => ring buffer corrupted */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2404 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2405 if(startedSectors == 2) /* only fix issue if only two sectors are in used. Otherwise fixing will cause more worries than help */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2406 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2407 /* the logic behind healing of the problem is that the larger address is the oldest one => restore the largest address */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2408 curAddress = SAMPLESTART + (lastSectorInuse * 0x10000); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2409 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2410 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2411 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2412 while((emptyCellCnt < 10) && (actualAddress < curAddress + 0x10000)) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2413 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2414 samplebuffer[0] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2415 if(samplebuffer[0] == 0xFF) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2416 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2417 emptyCellCnt++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2418 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2419 else |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2420 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2421 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2422 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2423 actualAddress++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2424 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2425 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2426 actualAddress -= 10; /* step 10 bytes back to the start of free bytes */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2427 actualPointerSample = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2428 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2429 closeSectorAddress = settingsGetPointer()->logFlashNextSampleStartAddress & 0xFFFF0000; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2430 closeSectorAddress += 0xFFF5; /* to be used once next time a dive is logged. Needed because NextSampleID is derived at every startup */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2431 settingsGetPointer()->logFlashNextSampleStartAddress = actualPointerSample; /* store new position to be used for next dive */ |
|
557
2702bfa7b177
Stabilityfix: Do not trust lastDiveLogID == 0 at startup:
Ideenmodellierer
parents:
538
diff
changeset
|
2432 ext_flash_CloseSector(); |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2433 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2434 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2435 actualAddress = actualAddressBackup; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2436 return startedSectors; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2437 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2438 |
|
466
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2439 uint32_t ext_flash_read_profilelength_small_header(uint32_t smallHeaderAddr) |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2440 { |
|
466
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2441 uint32_t profileLength = 0; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2442 actualPointerSample = smallHeaderAddr; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2443 actualAddress = actualPointerSample; |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2444 ext_flash_read_block_start(); |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2445 ext_flash_read_next_sample_part((uint8_t*)&profileLength, 3); |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2446 ext_flash_close_read_sample(); |
|
538eb1c976e9
Removed invalidate header function because it is no lonnger needed
ideenmodellierer
parents:
463
diff
changeset
|
2447 return profileLength; |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2448 } |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2449 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2450 |
| 870 | 2451 |
| 38 | 2452 uint8_t ext_flash_erase_firmware_if_not_empty(void) |
| 2453 { | |
| 2454 const uint8_t TESTSIZE_FW = 4; | |
| 2455 | |
| 2456 uint8_t data[TESTSIZE_FW]; | |
| 2457 uint8_t notEmpty = 0; | |
| 2458 | |
| 2459 actualAddress = FWSTART; | |
| 2460 ext_flash_read_block_start(); | |
| 2461 for(int i = 0; i < TESTSIZE_FW; i++) | |
| 2462 { | |
| 2463 ext_flash_read_block(&data[i], EF_FIRMWARE); | |
| 2464 if(data[i] != 0xFF) | |
| 2465 notEmpty = 1; | |
| 2466 } | |
| 2467 ext_flash_read_block_stop(); | |
| 2468 | |
| 2469 if(notEmpty) | |
| 2470 { | |
| 2471 ext_flash_erase_firmware(); | |
| 2472 return 1; | |
| 2473 } | |
| 2474 else | |
| 2475 return 0; | |
| 2476 } | |
| 2477 | |
| 2478 uint8_t ext_flash_erase_firmware2_if_not_empty(void) | |
| 2479 { | |
| 2480 const uint8_t TESTSIZE_FW = 4; | |
| 2481 | |
| 2482 uint8_t data[TESTSIZE_FW]; | |
| 2483 uint8_t notEmpty = 0; | |
| 2484 | |
| 2485 actualAddress = FWSTART2; | |
| 2486 ext_flash_read_block_start(); | |
| 2487 for(int i = 0; i < TESTSIZE_FW; i++) | |
| 2488 { | |
| 2489 ext_flash_read_block(&data[i], EF_FIRMWARE2); | |
| 2490 if(data[i] != 0xFF) | |
| 2491 notEmpty = 1; | |
| 2492 } | |
| 2493 ext_flash_read_block_stop(); | |
| 2494 | |
| 2495 if(notEmpty) | |
| 2496 { | |
| 2497 ext_flash_erase_firmware2(); | |
| 2498 return 1; | |
| 2499 } | |
| 2500 else | |
| 2501 return 0; | |
| 870 | 2502 } |