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