Mercurial > public > ostc4
annotate Discovery/Src/externLogbookFlash.c @ 459:7ac0e76dbd6a minor_improvments
Activated reset of sample information within header data at time of sector erasing:
After sample information have been erased the header are pointing to empty storage locations. To redefine the headers the sample addresses will be set to zero incating that no data is available. In that case the dummy functionality implemented by the last commits will be applied
| author | ideenmodellierer |
|---|---|
| date | Sun, 29 Mar 2020 21:39:57 +0200 |
| parents | b90ddf57f7f1 |
| children | 2effe85f1a9b |
| 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; |
|
459
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
790 ext_flash_invalidate_sample_index(preparedPageAddress); |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
791 ext_flash_erase64kB(); |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
792 actualAddress = actualAdressBackup; |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
793 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
794 } |
| 38 | 795 } |
| 796 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
797 static void ext_flash_overwrite_sample_without_erase(uint8_t *pSample, uint16_t length) |
| 38 | 798 { |
| 799 ef_write_block(pSample,length, EF_SAMPLE, 1); | |
| 800 } | |
| 801 | |
| 802 | |
| 803 uint8_t ext_flash_count_dive_headers(void) | |
| 804 { | |
| 805 uint8_t id = 0; | |
| 806 uint8_t counter = 0; | |
| 807 uint16_t headerStartData = 0x0000; | |
| 808 | |
| 809 id = settingsGetPointer()->lastDiveLogId; | |
| 810 | |
| 811 do | |
| 812 { | |
| 813 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 814 ext_flash_read_block_start(); | |
| 815 ext_flash_read_block_multi((uint8_t *)&headerStartData, 2, EF_HEADER); | |
| 816 ext_flash_read_block_stop(); | |
| 817 counter++; | |
| 818 id -=1; | |
| 819 } while((headerStartData == 0xFAFA) && (counter < 255)); | |
| 820 return (counter - 1); | |
| 821 } | |
| 822 | |
| 823 | |
| 824 void ext_flash_read_dive_header(uint8_t *pHeaderToFill, uint8_t StepBackwards) | |
| 825 { | |
| 826 SSettings *settings; | |
| 827 uint8_t id; | |
| 828 uint16_t i; | |
| 829 | |
| 830 settings = settingsGetPointer(); | |
| 831 id = settings->lastDiveLogId; | |
| 832 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 833 | |
| 834 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 835 ext_flash_read_block_start(); | |
| 836 for(i = 0; i < HEADERSIZE; i++) | |
| 837 ext_flash_read_block(&pHeaderToFill[i], EF_HEADER); | |
| 838 ext_flash_read_block_stop(); | |
| 839 | |
| 840 } | |
| 841 | |
| 842 void ext_flash_read_dive_header2(uint8_t *pHeaderToFill, uint8_t id, _Bool bOffset) | |
| 843 { | |
| 844 | |
| 845 uint16_t i; | |
| 846 actualAddress = HEADERSTART + (0x800 * id) ; | |
| 847 | |
| 848 if(bOffset) | |
| 849 actualAddress += HEADER2OFFSET; | |
| 850 ext_flash_read_block_start(); | |
| 851 for(i = 0; i < HEADERSIZE; i++) | |
| 852 ext_flash_read_block(&pHeaderToFill[i], EF_HEADER); | |
| 853 ext_flash_read_block_stop(); | |
| 854 } | |
| 855 | |
| 856 | |
| 857 uint32_t ext_flash_read_dive_raw_with_double_header_1K(uint8_t *data, uint32_t max_size, uint8_t StepBackwards) | |
| 858 { | |
| 859 if(max_size < 0x800) | |
| 860 return 0; | |
| 861 | |
| 862 uint8_t id; | |
| 863 convert_Type dataStart, dataEnd; | |
| 864 uint32_t LengthAll = 0; | |
| 865 | |
| 866 id = settingsGetPointer()->lastDiveLogId; | |
| 867 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 868 | |
| 869 // clear data | |
| 870 for(int i=0;i<0x800;i++) | |
| 871 data[i] = 0xFF; | |
| 872 | |
| 873 // copy primary/pre-dive | |
| 874 actualAddress = HEADERSTART + (0x800 * id); | |
| 875 ext_flash_read_block_start(); | |
| 876 for(int i = 0; i < HEADERSIZE; i++) | |
| 877 ext_flash_read_block(&data[i], EF_HEADER); | |
| 878 ext_flash_read_block_stop(); | |
| 879 | |
| 880 // copy main/secondary/post-dive | |
| 881 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 882 ext_flash_read_block_start(); | |
| 883 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 884 ext_flash_read_block(&data[i], EF_HEADER); | |
| 885 ext_flash_read_block_stop(); | |
| 886 | |
| 887 // data | |
| 888 | |
| 889 dataStart.u8bit.byteHigh = 0; | |
| 890 dataStart.u8bit.byteLow = data[0x402]; | |
| 891 dataStart.u8bit.byteMidLow = data[0x403]; | |
| 892 dataStart.u8bit.byteMidHigh = data[0x404]; | |
| 893 | |
| 894 dataEnd.u8bit.byteHigh = 0; | |
| 895 dataEnd.u8bit.byteLow = data[0x405]; | |
| 896 dataEnd.u8bit.byteMidLow = data[0x406]; | |
| 897 dataEnd.u8bit.byteMidHigh = data[0x407]; | |
| 898 | |
| 899 actualPointerSample = dataStart.u32bit; | |
| 900 if(dataEnd.u32bit >= dataStart.u32bit) | |
| 901 LengthAll = 1 + dataEnd.u32bit - dataStart.u32bit; | |
| 902 else | |
| 903 LengthAll = 2 + (dataStart.u32bit - SAMPLESTART) + (SAMPLESTOP - dataEnd.u32bit); | |
| 904 | |
| 905 LengthAll += 0x800; | |
| 906 | |
| 907 if(LengthAll > max_size) | |
| 908 return 0x800; | |
| 909 | |
| 910 actualAddress = actualPointerSample; | |
| 911 ext_flash_read_block_start(); | |
| 912 for(uint32_t i = 0x800; i < LengthAll; i++) | |
| 913 ext_flash_read_block(&data[i], EF_SAMPLE); | |
| 914 ext_flash_read_block_stop(); | |
| 915 return LengthAll; | |
| 916 } | |
| 917 | |
| 918 void ext_flash_write_dive_raw_with_double_header_1K(uint8_t *data, uint32_t length) | |
| 919 { | |
| 920 convert_Type dataStart, dataEnd; | |
| 921 SLogbookHeader headerTemp; | |
| 922 | |
| 923 // set actualPointerSample and get pointer to sample storage and disable flash write protect | |
| 924 ext_flash_start_new_dive_log_and_set_actualPointerSample((uint8_t *)&headerTemp); | |
| 925 | |
| 926 dataStart.u8bit.byteHigh = 0; | |
| 927 dataStart.u8bit.byteLow = headerTemp.pBeginProfileData[0]; | |
| 928 dataStart.u8bit.byteMidLow = headerTemp.pBeginProfileData[1]; | |
| 929 dataStart.u8bit.byteMidHigh = headerTemp.pBeginProfileData[2]; | |
| 930 | |
| 931 dataEnd.u32bit = dataStart.u32bit + length - 0x801; | |
| 932 if(dataEnd.u32bit > SAMPLESTOP) | |
| 933 dataEnd.u32bit -= SAMPLESTOP + SAMPLESTART - 1; | |
| 934 | |
| 935 data[0x002] = data[0x402] = dataStart.u8bit.byteLow; | |
| 936 data[0x003] = data[0x403] = dataStart.u8bit.byteMidLow; | |
| 937 data[0x004] = data[0x404] = dataStart.u8bit.byteMidHigh; | |
| 938 data[0x005] = data[0x405] = dataEnd.u8bit.byteLow; | |
| 939 data[0x006] = data[0x406] = dataEnd.u8bit.byteMidLow; | |
| 940 data[0x007] = data[0x407] = dataEnd.u8bit.byteMidHigh; | |
| 941 | |
| 942 // set actualPointerHeader to next free header and update lastDiveLogId | |
| 943 ext_flash_create_new_dive_log(0); | |
| 944 | |
| 945 // copy header data | |
| 946 ef_write_block(data,0x800,EF_HEADER, 1); | |
| 947 | |
| 948 // copy sample data | |
| 949 ef_write_block(&data[0x800], length-0x800, EF_SAMPLE, 1); | |
| 950 | |
| 951 // update logFlashNextSampleStartAddress | |
| 952 settingsGetPointer()->logFlashNextSampleStartAddress = actualPointerSample; | |
| 953 } | |
| 954 | |
| 955 | |
| 956 // =============================================================================== | |
| 957 // ext_flash_read_header_memory | |
| 958 /// @brief This function returns the entire header space 1:1 | |
| 959 /// @date 04-April-2016 | |
| 960 /// | |
| 961 /// @param *data 256KB output | |
| 962 // =============================================================================== | |
| 963 void ext_flash_read_header_memory(uint8_t *data) | |
| 964 { | |
| 965 actualAddress = HEADERSTART; | |
| 966 actualPointerHeader = actualAddress; | |
| 967 ext_flash_read_block_start(); | |
| 968 for(int i=0;i<8;i++) | |
| 969 ext_flash_read_block_multi(&data[0x8000 * i], 0x8000, EF_HEADER); | |
| 970 ext_flash_read_block_stop(); | |
| 971 } | |
| 972 | |
| 973 | |
| 974 // =============================================================================== | |
| 975 // ext_flash_read_header_memory | |
| 976 /// @brief This function erases and overwrites the entire logbook header block | |
| 977 /// @date 04-April-2016 | |
| 978 /// | |
| 979 /// @param *data 256KB input of header memory 1:1 | |
| 980 // =============================================================================== | |
| 981 void ext_flash_write_header_memory(uint8_t *data) | |
| 982 { | |
| 983 actualAddress = HEADERSTART; | |
| 984 actualPointerHeader = actualAddress; | |
| 985 ef_write_block(data, 0x40000, EF_HEADER, 0); | |
| 986 } | |
| 987 | |
| 988 | |
| 989 void ext_flash_open_read_sample(uint8_t StepBackwards, uint32_t *totalNumberOfBytes) | |
| 990 { | |
| 991 SSettings *settings = settingsGetPointer(); | |
| 992 uint8_t id; | |
| 993 convert_Type dataStart, dataEnd; | |
| 994 uint8_t header1, header2; | |
| 995 | |
| 996 id = settings->lastDiveLogId; | |
| 997 id -= StepBackwards; /* 0-255, auto rollover */ | |
| 998 # | |
| 999 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1000 actualPointerHeader = actualAddress; | |
| 1001 | |
| 1002 ext_flash_read_block_start(); | |
| 1003 /* little endian */ | |
| 1004 ext_flash_read_block(&header1, EF_HEADER); | |
| 1005 ext_flash_read_block(&header2, EF_HEADER); | |
| 1006 dataStart.u8bit.byteHigh = 0; | |
| 1007 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1008 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1009 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1010 dataEnd.u8bit.byteHigh = 0; | |
| 1011 ext_flash_read_block(&dataEnd.u8bit.byteLow, EF_HEADER); | |
| 1012 ext_flash_read_block(&dataEnd.u8bit.byteMidLow, EF_HEADER); | |
| 1013 ext_flash_read_block(&dataEnd.u8bit.byteMidHigh, EF_HEADER); | |
| 1014 ext_flash_read_block_stop(); | |
| 1015 | |
| 1016 actualPointerSample = dataStart.u32bit; | |
| 1017 if(dataEnd.u32bit >= dataStart.u32bit) | |
| 1018 LengthLeftSampleRead = 1 + dataEnd.u32bit - dataStart.u32bit; | |
| 1019 else | |
| 1020 LengthLeftSampleRead = 2 + (dataStart.u32bit - SAMPLESTART) + (SAMPLESTOP - dataEnd.u32bit); | |
| 1021 *totalNumberOfBytes = LengthLeftSampleRead; | |
| 1022 | |
| 1023 actualAddress = actualPointerSample; | |
| 1024 ext_flash_read_block_start(); | |
| 1025 } | |
| 1026 | |
| 1027 | |
| 1028 void ext_flash_read_next_sample_part(uint8_t *pSample, uint8_t length) | |
| 1029 { | |
| 1030 for(uint16_t i = 0; i < length; i++) | |
| 1031 ext_flash_read_block(&pSample[i], EF_SAMPLE); | |
| 1032 } | |
| 1033 | |
| 1034 | |
| 1035 void ext_flash_close_read_sample(void) | |
| 1036 { | |
| 1037 actualPointerSample = actualAddress; | |
| 1038 ext_flash_read_block_stop(); | |
| 1039 } | |
| 1040 | |
| 1041 | |
| 1042 void ext_flash_set_entry_point(void) | |
| 1043 { | |
| 1044 entryPoint = actualAddress; | |
| 1045 } | |
| 1046 | |
| 1047 | |
| 1048 void ext_flash_reopen_read_sample_at_entry_point(void) | |
| 1049 { | |
| 1050 error_led_on(); | |
| 1051 chip_unselect(); | |
| 1052 wait_chip_not_busy(); | |
| 1053 | |
| 1054 actualAddress = entryPoint; | |
| 1055 ext_flash_read_block_start(); | |
| 1056 error_led_off(); | |
| 1057 } | |
| 1058 | |
| 1059 /* | |
| 1060 uint8_t ext_flash_point_to_64k_block_in_headerSpace(uint8_t logId) | |
| 1061 { | |
| 1062 uint32_t pointerToData = logId * 0x800; | |
| 1063 | |
| 1064 return pointerToData / 0x10000; | |
| 1065 } | |
| 1066 */ | |
| 1067 | |
| 1068 | |
| 1069 // =============================================================================== | |
| 1070 // ext_flash_repair_dive_numbers_starting_count_helper | |
| 1071 /// @brief | |
| 1072 /// @date 22-June-2016 | |
| 1073 | |
| 1074 // =============================================================================== | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1075 static uint16_t ext_flash_repair_dive_numbers_starting_count_helper(uint8_t *data, uint8_t *change64k, uint16_t startNumber, uint8_t lastLogId) |
| 38 | 1076 { |
| 1077 const uint32_t headerStep = 0x800; | |
| 1078 uint8_t actualLogId = 0; | |
| 1079 uint16_t oldNumber = 0; | |
| 1080 uint16_t actualNumber = 0; | |
| 1081 SLogbookHeader *ptrLogbookHeader = 0; | |
| 1082 | |
| 1083 if(startNumber == 0) | |
| 1084 return 0; | |
| 1085 | |
| 1086 actualNumber = startNumber - 1; | |
| 1087 | |
| 282 | 1088 // where is the oldest dive (Which is now getting startNumber) |
| 38 | 1089 // use first header for ease (without HEADER2OFFSET for end of dive header) |
| 1090 // compare for lastLogId to prevent endless loop | |
| 1091 | |
| 1092 if(*(uint16_t*)&data[lastLogId * headerStep] != 0xFAFA) | |
| 1093 return 0; | |
| 1094 | |
| 1095 actualLogId = lastLogId - 1; | |
| 1096 while((*(uint16_t*)&data[actualLogId * headerStep] == 0xFAFA) && (actualLogId != lastLogId)) | |
| 1097 { | |
| 1098 actualLogId--; | |
| 1099 } | |
| 1100 | |
| 1101 // now pointing to one behind the last | |
| 1102 while(actualLogId != lastLogId) | |
| 1103 { | |
| 1104 actualLogId++; | |
| 1105 actualNumber++; | |
| 1106 ptrLogbookHeader = (SLogbookHeader *)&data[actualLogId * headerStep]; | |
| 1107 | |
| 1108 oldNumber = ptrLogbookHeader->diveNumber; | |
| 1109 if(oldNumber != actualNumber) | |
| 1110 { | |
| 1111 // change64k[ext_flash_point_to_64k_block_in_headerSpace(actualLogId )] = 1; | |
| 1112 change64k[(actualLogId * 0x800)/0x10000] = 1; | |
| 1113 ptrLogbookHeader->diveNumber = actualNumber; | |
| 1114 ptrLogbookHeader = (SLogbookHeader *)(&data[actualLogId * headerStep] + HEADER2OFFSET); | |
| 1115 ptrLogbookHeader->diveNumber = actualNumber; | |
| 1116 } | |
| 1117 } | |
| 1118 | |
| 1119 return actualNumber; | |
| 1120 } | |
| 1121 | |
| 1122 // =============================================================================== | |
| 1123 // ext_flash_repair_SPECIAL_dive_numbers_starting_count_with | |
| 1124 /// @brief This function | |
| 1125 /// @date 04-April-2016 | |
| 282 | 1126 /// problem (160621): 64K blocks (32 dives) in the new flash memory chip |
| 1127 /// This block needs to be deleted | |
| 1128 /// these where only 4KB block before | |
| 38 | 1129 /// @output endCount, last diveNumber |
| 1130 | |
| 1131 // =============================================================================== | |
| 1132 uint16_t ext_flash_repair_SPECIAL_dive_numbers_starting_count_with(uint16_t startCount) | |
| 1133 { | |
| 1134 uint32_t logCopyDataPtr = 0; | |
| 1135 uint8_t *data; | |
| 1136 uint16_t lastCount; | |
| 282 | 1137 uint8_t listOfChanged64kBlocks[8]; // 32 dives each 64K |
| 38 | 1138 |
| 1139 logCopyDataPtr = getFrame(97); | |
| 1140 data = (uint8_t *)logCopyDataPtr; | |
| 1141 | |
| 1142 for(int i=0;i<8;i++) | |
| 1143 listOfChanged64kBlocks[i] = 0; | |
| 1144 | |
| 1145 actualAddress = HEADERSTART; | |
| 1146 ext_flash_read_block_start(); | |
| 1147 ext_flash_read_block_multi(data,0x100000,EF_HEADER); | |
| 1148 ext_flash_read_block_stop(); | |
| 1149 | |
| 1150 lastCount = ext_flash_repair_dive_numbers_starting_count_helper(data, listOfChanged64kBlocks, startCount, settingsGetPointer()->lastDiveLogId); | |
| 1151 | |
| 1152 for(int i=0;i<8;i++) | |
| 1153 { | |
| 1154 if(listOfChanged64kBlocks[i] != 0) | |
| 1155 { | |
| 1156 actualPointerHeader = HEADERSTART + (i * 0x10000); | |
| 1157 ef_write_block(&data[i * 0x10000], 0x10000, EF_HEADER, 0); | |
| 1158 } | |
| 1159 } | |
| 1160 | |
| 1161 releaseFrame(97,logCopyDataPtr); | |
| 1162 if(settingsGetPointer()->totalDiveCounter < lastCount) | |
| 1163 { | |
| 1164 settingsGetPointer()->totalDiveCounter = lastCount; | |
| 1165 } | |
| 1166 return lastCount; | |
| 1167 } | |
| 1168 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1169 /* |
| 38 | 1170 void OLD_ext_flash_repair_SPECIAL_dive_numbers_starting_count_with(uint16_t startCount) |
| 1171 { | |
| 1172 uint16_t counterStorage[256]; | |
| 1173 uint8_t start = 0xFF; | |
| 1174 uint32_t logCopyDataPtr = 0; | |
| 1175 uint8_t *data; | |
| 1176 uint8_t startAbsolute = 0; | |
| 1177 int16_t count = 0; | |
| 1178 _Bool repair = 0; | |
| 1179 uint8_t startBackup = 0; | |
| 1180 | |
| 1181 SLogbookHeader tempLogbookHeader; | |
| 1182 SLogbookHeader *ptrHeaderInData1a; | |
| 1183 SLogbookHeader *ptrHeaderInData1b; | |
| 1184 SLogbookHeader *ptrHeaderInData2a; | |
| 1185 SLogbookHeader *ptrHeaderInData2b; | |
| 1186 | |
| 1187 logCopyDataPtr = getFrame(97); | |
| 1188 data = (uint8_t *)logCopyDataPtr; | |
| 1189 ptrHeaderInData1a = (SLogbookHeader *)logCopyDataPtr; | |
| 1190 ptrHeaderInData1b = (SLogbookHeader *)(logCopyDataPtr + HEADER2OFFSET); | |
| 1191 ptrHeaderInData2a = (SLogbookHeader *)(logCopyDataPtr + 0x800); | |
| 1192 ptrHeaderInData2b = (SLogbookHeader *)(logCopyDataPtr + 0x800 + HEADER2OFFSET); | |
| 1193 | |
| 1194 // get data | |
| 1195 for(int StepBackwards = 0; StepBackwards < 255; StepBackwards++) | |
| 1196 { | |
| 1197 logbook_getHeader(StepBackwards, &tempLogbookHeader); | |
| 1198 counterStorage[StepBackwards+1] = tempLogbookHeader.diveNumber; | |
| 1199 if(tempLogbookHeader.diveHeaderStart == 0xFAFA) | |
| 1200 start = StepBackwards; | |
| 1201 else | |
| 1202 break; | |
| 1203 } | |
| 1204 | |
| 1205 if(start == 0xFF) | |
| 1206 return; | |
| 1207 | |
| 1208 count = start + 1; | |
| 1209 startAbsolute = settingsGetPointer()->lastDiveLogId; | |
| 1210 | |
| 1211 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1212 |
| 38 | 1213 if(start%2) |
| 1214 { | |
| 1215 if(counterStorage[start] != startCount) | |
| 1216 { | |
| 1217 // clear data | |
| 1218 for(int i=0;i<0x800*2;i++) | |
| 1219 data[i] = 0xFF; | |
| 1220 | |
| 1221 uint8_t id = settingsGetPointer()->lastDiveLogId; | |
| 1222 id -= start; // 0-255, auto rollover | |
| 1223 | |
| 1224 // copy primary/pre-dive | |
| 1225 actualAddress = HEADERSTART + (0x800 * id); | |
| 1226 ext_flash_read_block_start(); | |
| 1227 for(int i = 0; i < HEADERSIZE; i++) | |
| 1228 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1229 ext_flash_read_block_stop(); | |
| 1230 | |
| 1231 // copy main/secondary/post-dive | |
| 1232 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1233 ext_flash_read_block_start(); | |
| 1234 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1235 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1236 ext_flash_read_block_stop(); | |
| 1237 | |
| 1238 // repair | |
| 1239 ptrHeaderInData2a->diveNumber = startCount; | |
| 1240 ptrHeaderInData2b->diveNumber = startCount; | |
| 1241 startCount++; | |
| 1242 | |
| 1243 // write | |
| 1244 actualAddress = HEADERSTART + (0x800 * (id-1)); | |
| 1245 ef_write_block(data,0x800*2,EF_HEADER, 0); | |
| 1246 } | |
| 1247 start--; | |
| 1248 } | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1249 |
| 38 | 1250 // for(int count = start; count > -1; count -= 2) |
| 1251 | |
| 1252 while(count > 0) | |
| 1253 { | |
| 1254 // clear data | |
| 1255 for(int i=0;i<0x1000;i++) | |
| 1256 data[i] = 0xFF; | |
| 1257 | |
| 1258 repair = 0; | |
| 1259 | |
| 1260 startBackup = startAbsolute; | |
| 1261 | |
| 1262 if(startAbsolute%2) // 0x800 to 0x1000 | |
| 1263 { | |
| 1264 // copy second pre-dive | |
| 1265 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1266 ext_flash_read_block_start(); | |
| 1267 for(int i = 0x800; i < HEADERSIZE+0x800; i++) | |
| 1268 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1269 ext_flash_read_block_stop(); | |
| 1270 | |
| 1271 // copy second post-dive | |
| 1272 actualAddress = HEADERSTART + HEADER2OFFSET + (0x800 * startAbsolute); | |
| 1273 ext_flash_read_block_start(); | |
| 1274 for(int i = 0xC00; i < HEADERSIZE+0xC00; i++) | |
| 1275 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1276 ext_flash_read_block_stop(); | |
| 1277 | |
| 1278 if(counterStorage[count] != startCount) | |
| 1279 { | |
| 1280 ptrHeaderInData2a->diveNumber = startCount; | |
| 1281 ptrHeaderInData2b->diveNumber = startCount; | |
| 1282 repair = 1; | |
| 1283 } | |
| 1284 startCount += 1; | |
| 1285 | |
| 1286 startAbsolute -= 1; | |
| 1287 count -= 1; | |
| 1288 | |
| 1289 if(count > 0) | |
| 1290 { | |
| 1291 // copy first pre-dive | |
| 1292 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1293 ext_flash_read_block_start(); | |
| 1294 for(int i = 0; i < HEADERSIZE; i++) | |
| 1295 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1296 ext_flash_read_block_stop(); | |
| 1297 | |
| 1298 // copy first post-dive | |
| 1299 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1300 ext_flash_read_block_start(); | |
| 1301 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1302 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1303 ext_flash_read_block_stop(); | |
| 1304 | |
| 1305 if(counterStorage[count] != startCount) | |
| 1306 { | |
| 1307 ptrHeaderInData1a->diveNumber = startCount; | |
| 1308 ptrHeaderInData1b->diveNumber = startCount; | |
| 1309 repair = 1; | |
| 1310 } | |
| 1311 startCount += 1; | |
| 1312 | |
| 1313 startAbsolute -= 1; | |
| 1314 count -= 1; | |
| 1315 } | |
| 1316 } | |
| 1317 else | |
| 1318 { | |
| 1319 // copy first pre-dive | |
| 1320 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1321 ext_flash_read_block_start(); | |
| 1322 for(int i = 0; i < HEADERSIZE; i++) | |
| 1323 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1324 ext_flash_read_block_stop(); | |
| 1325 | |
| 1326 // copy first post-dive | |
| 1327 actualAddress = HEADERSTART + (0x800 * startAbsolute); | |
| 1328 ext_flash_read_block_start(); | |
| 1329 for(int i = 0x400; i < HEADERSIZE+0x400; i++) | |
| 1330 ext_flash_read_block(&data[i], EF_HEADER); | |
| 1331 ext_flash_read_block_stop(); | |
| 1332 | |
| 1333 if(counterStorage[count] != startCount) | |
| 1334 { | |
| 1335 ptrHeaderInData1a->diveNumber = startCount; | |
| 1336 ptrHeaderInData1b->diveNumber = startCount; | |
| 1337 repair = 1; | |
| 1338 } | |
| 1339 startCount += 1; | |
| 1340 | |
| 1341 startAbsolute -= 1; | |
| 1342 count -= 1; | |
| 1343 } | |
| 1344 | |
| 1345 // write | |
| 1346 if(repair) | |
| 1347 { | |
| 1348 actualPointerHeader = HEADERSTART + (0x1000 * startBackup%2); | |
| 1349 ef_write_block(data,0x1000,EF_HEADER, 0); | |
| 1350 } | |
| 1351 } | |
| 1352 releaseFrame(97,logCopyDataPtr); | |
| 1353 settingsGetPointer()->totalDiveCounter = startCount; | |
| 1354 } | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1355 */ |
| 38 | 1356 |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1357 uint8_t ext_dive_log_consistent(void) |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1358 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1359 uint8_t ret = 0; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1360 uint8_t header1, header2; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1361 uint8_t id; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1362 convert_Type dataStart; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1363 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1364 SSettings *settings = settingsGetPointer(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1365 id = settings->lastDiveLogId; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1366 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1367 actualAddress = HEADERSTART + (0x800 * id); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1368 ext_flash_read_block_start(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1369 ext_flash_read_block(&header1, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1370 ext_flash_read_block(&header2, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1371 dataStart.u8bit.byteHigh = 0; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1372 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
|
1373 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
|
1374 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
|
1375 ext_flash_read_block_stop(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1376 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
|
1377 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1378 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1379 ext_flash_read_block_start(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1380 ext_flash_read_block(&header1, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1381 ext_flash_read_block(&header2, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1382 ext_flash_read_block_stop(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1383 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
|
1384 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1385 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
|
1386 } |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1387 } |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1388 return ret; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1389 } |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1390 |
| 38 | 1391 // =============================================================================== |
| 1392 // ext_flash_repair_dive_log | |
| 1393 /// @brief This function | |
| 1394 /// does set | |
| 1395 /// logFlashNextSampleStartAddress | |
| 1396 /// and | |
| 1397 /// lastDiveLogId | |
| 1398 /// | |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
1399 |
| 38 | 1400 void ext_flash_repair_dive_log(void) |
| 1401 { | |
| 1402 uint8_t header1, header2; | |
| 1403 convert_Type dataStart; | |
| 1404 | |
| 1405 for(int id = 0; id < 255;id++) | |
| 1406 { | |
| 1407 actualAddress = HEADERSTART + (0x800 * id); | |
| 1408 ext_flash_read_block_start(); | |
| 1409 ext_flash_read_block(&header1, EF_HEADER); | |
| 1410 ext_flash_read_block(&header2, EF_HEADER); | |
| 1411 dataStart.u8bit.byteHigh = 0; | |
| 1412 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1413 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1414 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1415 ext_flash_read_block_stop(); | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1416 if((header1 == 0xFA) && (header2 == 0xFA)) /* Header is indicating the start of a dive */ |
| 38 | 1417 { |
| 1418 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1419 ext_flash_read_block_start(); | |
| 1420 ext_flash_read_block(&header1, EF_HEADER); | |
| 1421 ext_flash_read_block(&header2, EF_HEADER); | |
| 1422 ext_flash_read_block_stop(); | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1423 if((header1 != 0xFA) || (header2 != 0xFA)) /* Secondary header was not written at the end of a dive */ |
| 38 | 1424 { |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
1425 actualPointerSample = dataStart.u32bit; /* Set datapointer to position stored in header written at beginning of dive */ |
| 38 | 1426 actualAddress = actualPointerSample; |
| 1427 logbook_recover_brokenlog(id); | |
| 1428 SSettings *settings = settingsGetPointer(); | |
| 1429 settings->logFlashNextSampleStartAddress = actualPointerSample; | |
| 1430 } | |
| 1431 } | |
| 1432 } | |
| 1433 ext_flash_find_start(); | |
| 1434 } | |
| 1435 | |
| 1436 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1437 static void ext_flash_find_start(void) |
| 38 | 1438 { |
| 1439 uint8_t id; | |
| 1440 uint8_t header1, header2; | |
| 1441 convert_Type dataStart, dataEnd; | |
| 1442 | |
|
429
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
1443 /* TODO Cleanup_Ref_1: cleanup logFlashNextSampleStartAddress and lastDiveLogId */ |
|
7f351c25608a
Marked possible code improvment for future activities:
ideenmodellierer
parents:
427
diff
changeset
|
1444 /* 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
|
1445 /* This is avoided by Cleanup_Ref2 */ |
| 38 | 1446 for(id = 0; id < 255;id++) |
| 1447 { | |
| 1448 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1449 ext_flash_read_block_start(); | |
| 1450 ext_flash_read_block(&header1, EF_HEADER); | |
| 1451 ext_flash_read_block(&header2, EF_HEADER); | |
| 1452 dataStart.u8bit.byteHigh = 0; | |
| 1453 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1454 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1455 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1456 ext_flash_read_block_stop(); | |
| 1457 if((header1 == 0xFF) && (header2 == 0xFF)) | |
| 1458 { | |
| 1459 break; | |
| 1460 } | |
| 1461 } | |
| 1462 id--; | |
| 1463 SSettings *settings = settingsGetPointer(); | |
| 1464 settings->lastDiveLogId = id; | |
| 1465 | |
| 1466 actualAddress = HEADERSTART + (0x800 * id) + HEADER2OFFSET; | |
| 1467 actualPointerHeader = actualAddress; | |
| 1468 | |
| 1469 ext_flash_read_block_start(); | |
| 1470 | |
| 1471 ext_flash_read_block(&header1, EF_HEADER); | |
| 1472 ext_flash_read_block(&header2, EF_HEADER); | |
| 1473 dataStart.u8bit.byteHigh = 0; | |
| 1474 ext_flash_read_block(&dataStart.u8bit.byteLow, EF_HEADER); | |
| 1475 ext_flash_read_block(&dataStart.u8bit.byteMidLow, EF_HEADER); | |
| 1476 ext_flash_read_block(&dataStart.u8bit.byteMidHigh, EF_HEADER); | |
| 1477 dataEnd.u8bit.byteHigh = 0; | |
| 1478 ext_flash_read_block(&dataEnd.u8bit.byteLow, EF_HEADER); | |
| 1479 ext_flash_read_block(&dataEnd.u8bit.byteMidLow, EF_HEADER); | |
| 1480 ext_flash_read_block(&dataEnd.u8bit.byteMidHigh, EF_HEADER); | |
| 1481 ext_flash_read_block_stop(); | |
| 1482 | |
| 1483 //Find free space | |
| 1484 if((header1 == 0xFA) && (header2 == 0xFA)) | |
| 1485 { | |
| 1486 uint8_t uiRead = 0; | |
| 1487 int countFF = 0; | |
| 1488 //End of last complete dive | |
| 1489 actualPointerSample = dataEnd.u32bit ; | |
| 1490 actualAddress = actualPointerSample; | |
| 1491 //Check if there are samples of dives with less than half a minute | |
| 1492 while(true) | |
| 1493 { | |
| 1494 ext_flash_read_block_start(); | |
| 1495 ext_flash_read_block(&uiRead, EF_SAMPLE); | |
| 1496 if(uiRead == 0xFF) | |
| 1497 countFF++; | |
| 1498 else | |
| 1499 countFF = 0; | |
| 1500 | |
| 1501 | |
| 1502 | |
| 1503 if(countFF == 10) | |
| 1504 { | |
| 1505 actualAddress -= 10; | |
| 1506 break; | |
| 1507 } | |
| 1508 | |
| 1509 //New page: clear | |
| 1510 if(ext_flash_erase_if_on_page_start()) | |
| 1511 break; | |
| 1512 } | |
| 1513 // Set new start address | |
| 1514 actualPointerSample = actualAddress; | |
| 1515 settings->logFlashNextSampleStartAddress = actualPointerSample; | |
| 1516 } | |
| 1517 else | |
| 1518 { | |
| 1519 settings->logFlashNextSampleStartAddress = SAMPLESTART; | |
| 1520 } | |
| 1521 } | |
| 1522 | |
| 1523 | |
| 1524 #endif | |
| 1525 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1526 static void ext_flash_disable_protection(void) |
| 38 | 1527 { |
| 1528 /* | |
| 1529 extFlashStatusBit8_Type status; | |
| 1530 | |
| 1531 status.uw = 0; | |
| 1532 | |
| 1533 wait_chip_not_busy(); | |
| 1534 write_spi(0x50,RELEASE); // EWSR | |
| 1535 write_spi(0x01,HOLDCS); // WRSR | |
| 1536 write_spi(status.uw,RELEASE); // new status | |
| 1537 */ | |
| 1538 } | |
| 1539 | |
| 1540 | |
| 1541 void ext_flash_disable_protection_for_logbook(void) | |
| 1542 { | |
| 1543 /* | |
| 1544 extFlashStatusBit8_Type status; | |
| 1545 | |
| 1546 status.uw = 0; | |
| 1547 status.ub.BlockProtect0 = 1; | |
| 1548 status.ub.BlockProtect1 = 0; | |
| 1549 status.ub.BlockProtect2 = 1; | |
| 1550 status.ub.BlockProtect3 = 0; // not set in OSTC3. Why? | |
| 1551 | |
| 1552 wait_chip_not_busy(); | |
| 1553 write_spi(0x50,RELEASE); // EWSR | |
| 1554 write_spi(0x01,HOLDCS); // WRSR | |
| 1555 write_spi(status.uw,RELEASE); // new status | |
| 1556 */ | |
| 1557 } | |
| 1558 | |
| 1559 | |
| 1560 void ext_flash_enable_protection(void) | |
| 1561 { | |
| 1562 /* | |
| 1563 extFlashStatusBit8_Type status; | |
| 1564 | |
| 1565 status.uw = 0; | |
| 1566 status.ub.BlockProtect0 = 1; | |
| 1567 status.ub.BlockProtect1 = 1; | |
| 1568 status.ub.BlockProtect2 = 1; | |
| 1569 status.ub.BlockProtect3 = 1; // not set in OSTC3. Why? | |
| 1570 | |
| 1571 wait_chip_not_busy(); | |
| 1572 write_spi(0x50,RELEASE); // EWSR | |
| 1573 write_spi(0x01,HOLDCS); // WRSR | |
| 1574 write_spi(status.uw,RELEASE); // new status | |
| 1575 */ | |
| 1576 } | |
| 1577 | |
| 1578 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1579 /*void ext_flash_erase_chip(void) |
| 38 | 1580 { |
| 1581 wait_chip_not_busy(); | |
| 1582 write_spi(0x06,RELEASE); | |
| 1583 write_spi(0x60,RELEASE); | |
| 1584 wait_chip_not_busy(); | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1585 }*/ |
| 38 | 1586 |
| 1587 void ext_flash_erase_firmware(void) | |
| 1588 { | |
| 1589 uint32_t size, blocks_64k; | |
| 1590 | |
| 1591 actualAddress = FWSTART; | |
| 1592 size = 1 + FWSTOP - FWSTART; | |
| 1593 blocks_64k = size / 0x10000; | |
| 1594 ef_erase_64K(blocks_64k); | |
| 1595 } | |
| 1596 | |
| 1597 void ext_flash_erase_firmware2(void) | |
| 1598 { | |
| 1599 uint32_t size, blocks_64k; | |
| 1600 | |
| 1601 actualAddress = FWSTART2; | |
| 1602 size = 1 + FWSTOP2 - FWSTART2; | |
| 1603 blocks_64k = size / 0x10000; | |
| 1604 ef_erase_64K(blocks_64k); | |
| 1605 } | |
| 1606 | |
| 1607 | |
| 1608 | |
| 1609 void ext_flash_erase_logbook(void) | |
| 1610 { | |
| 1611 uint32_t size, blocks_64k; | |
| 1612 | |
| 1613 ext_flash_disable_protection_for_logbook(); | |
| 1614 | |
| 1615 actualAddress = SAMPLESTART; | |
| 1616 size = 1 + SAMPLESTOP - SAMPLESTART; | |
| 1617 blocks_64k = size / 0x10000; | |
| 1618 ef_erase_64K(blocks_64k); | |
| 1619 | |
| 1620 actualAddress = HEADERSTART; | |
| 1621 size = 1 + HEADERSTOP - HEADERSTART; | |
| 1622 blocks_64k = size / 0x10000; | |
| 1623 ef_erase_64K(blocks_64k); | |
| 1624 | |
| 1625 ext_flash_enable_protection(); | |
| 1626 } | |
| 1627 | |
| 1628 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1629 static void ext_flash_erase4kB(void) |
| 38 | 1630 { |
| 1631 wait_chip_not_busy(); | |
| 1632 write_spi(0x06,RELEASE);/* WREN */ | |
| 1633 write_spi(0x20,HOLDCS);/* sector erase cmd */ | |
| 1634 write_address(RELEASE); | |
| 1635 } | |
| 1636 | |
| 282 | 1637 /* be careful - might not work with entire family and other products |
| 38 | 1638 * see page 14 of LOGBOOK_V3_S25FS-S_00-271247.pdf |
| 1639 */ | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1640 static void ext_flash_erase32kB(void) |
| 38 | 1641 { |
| 1642 uint32_t actualAddress_backup; | |
| 1643 | |
| 1644 actualAddress_backup = actualAddress; | |
| 1645 actualAddress = 0; | |
| 1646 wait_chip_not_busy(); | |
| 1647 write_spi(0x06,RELEASE);/* WREN */ | |
| 1648 write_spi(0xD8,HOLDCS);/* sector erase cmd */ | |
| 1649 write_address(RELEASE); | |
| 1650 actualAddress = actualAddress_backup; | |
| 1651 } | |
| 1652 | |
| 1653 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1654 static void ext_flash_erase64kB(void) |
| 38 | 1655 { |
| 1656 wait_chip_not_busy(); | |
| 1657 write_spi(0x06,RELEASE);/* WREN */ | |
| 1658 write_spi(0xD8,HOLDCS);/* sector erase cmd */ | |
| 1659 write_address(RELEASE); | |
| 1660 } | |
| 1661 | |
| 1662 | |
| 1663 void ext_flash_read_block_start(void) | |
| 1664 { | |
| 1665 wait_chip_not_busy(); | |
| 1666 write_spi(0x03,HOLDCS); /* WREN */ | |
| 1667 write_address(HOLDCS); | |
| 1668 } | |
| 1669 | |
| 1670 /* 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
|
1671 static uint8_t ext_flash_erase_if_on_page_start(void) |
| 38 | 1672 { |
| 1673 if(actualAddress < 0x00008000) | |
| 1674 { | |
| 1675 /* 4K Byte is 0x1000 */ | |
| 1676 if((actualAddress & 0xFFF) == 0) | |
| 1677 { | |
| 1678 ext_flash_erase4kB(); | |
| 1679 return 1; | |
| 1680 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1681 } |
| 38 | 1682 else |
| 1683 if(actualAddress < 0x00010000) | |
| 1684 { | |
| 1685 /* 32K Byte is only one page */ | |
| 1686 if(actualAddress == 0x00010000) | |
| 1687 { | |
| 1688 ext_flash_erase32kB(); | |
| 1689 return 1; | |
| 1690 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1691 } |
| 38 | 1692 else |
| 1693 { | |
| 1694 /* 64K Byte is 0x10000 */ | |
| 1695 if((actualAddress & 0xFFFF) == 0) | |
| 1696 { | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1697 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
|
1698 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1699 preparedPageAddress = 0; |
|
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 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1702 else |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1703 { |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1704 ext_flash_erase64kB(); |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1705 } |
| 38 | 1706 return 1; |
| 1707 } | |
|
423
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1708 } |
|
a560afdaadbf
ext_Flash_write_sample erase sector optimization:
ideenmodellierer
parents:
421
diff
changeset
|
1709 |
| 38 | 1710 return 0; |
| 1711 } | |
| 1712 | |
| 1713 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1714 static void ext_flash_read_block(uint8_t *getByte, uint8_t type) |
| 38 | 1715 { |
| 1716 *getByte = read_spi(HOLDCS);/* read data */ | |
| 1717 ext_flash_incf_address(type); | |
| 1718 } | |
| 1719 | |
| 1720 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1721 static void ext_flash_read_block_multi(void *getByte, uint32_t size, uint8_t type) |
| 38 | 1722 { |
| 1723 uint8_t *data; | |
| 1724 data = getByte; | |
| 1725 | |
| 1726 for(uint32_t i=0;i<size;i++) | |
| 1727 { | |
| 1728 data[i] = read_spi(HOLDCS);/* read data */ | |
| 1729 ext_flash_incf_address(type); | |
| 1730 } | |
| 1731 } | |
| 1732 | |
| 1733 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1734 static void ext_flash_read_block_stop(void) |
| 38 | 1735 { |
| 1736 chip_unselect(); | |
| 1737 } | |
| 1738 | |
| 1739 | |
| 1740 /* Private functions ---------------------------------------------------------*/ | |
| 1741 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1742 static void ef_write_block(uint8_t * sendByte, uint32_t length, uint8_t type, uint8_t do_not_erase) |
| 38 | 1743 { |
| 1744 uint32_t remaining_page_size, remaining_length, remaining_space_to_ring_end; | |
| 420 | 1745 uint32_t i=0; |
| 1746 | |
| 38 | 1747 if(!length) |
| 1748 return; | |
| 1749 | |
| 1750 uint32_t ringStart, ringStop; | |
| 1751 | |
| 1752 switch(type) | |
| 1753 { | |
| 1754 case EF_HEADER: | |
| 1755 actualAddress = actualPointerHeader; | |
| 1756 ringStart = HEADERSTART; | |
| 1757 ringStop = HEADERSTOP; | |
| 1758 break; | |
| 1759 case EF_SAMPLE: | |
| 1760 actualAddress = actualPointerSample; | |
| 1761 ringStart = SAMPLESTART; | |
| 1762 ringStop = SAMPLESTOP; | |
| 1763 break; | |
| 1764 case EF_DEVICEDATA: | |
| 1765 actualAddress = actualPointerDevicedata; | |
| 1766 ringStart = DDSTART; | |
| 1767 ringStop = DDSTOP; | |
| 1768 break; | |
| 1769 case EF_VPMDATA: | |
| 1770 actualAddress = actualPointerVPM; | |
| 1771 ringStart = VPMSTART; | |
| 1772 ringStop = VPMSTOP; | |
| 1773 break; | |
| 1774 case EF_SETTINGS: | |
| 1775 actualAddress = actualPointerSettings; | |
| 1776 ringStart = SETTINGSSTART; | |
| 1777 ringStop = SETTINGSSTOP; | |
| 1778 break; | |
| 1779 case EF_FIRMWARE: | |
| 1780 actualAddress = actualPointerFirmware; | |
| 1781 ringStart = FWSTART; | |
| 1782 ringStop = FWSTOP; | |
| 1783 break; | |
| 1784 case EF_FIRMWARE2: | |
| 1785 actualAddress = actualPointerFirmware2; | |
| 1786 ringStart = FWSTART2; | |
| 1787 ringStop = FWSTOP2; | |
| 1788 break; | |
| 1789 default: | |
| 1790 ringStart = FLASHSTART; | |
| 1791 ringStop = FLASHSTOP; | |
| 1792 break; | |
| 1793 } | |
| 1794 /* safety */ | |
| 1795 if(actualAddress < ringStart) | |
| 1796 actualAddress = ringStart; | |
| 1797 | |
| 1798 if(do_not_erase == 0) | |
|
459
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1799 { |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1800 if((ext_flash_erase_if_on_page_start()) && (type == EF_SAMPLE)) /* invalidate header sample information if needed */ |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1801 { |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1802 ext_flash_invalidate_sample_index(actualAddress); |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1803 } |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
1804 } |
| 38 | 1805 |
| 420 | 1806 while( i<length) |
| 38 | 1807 { |
| 1808 ef_hw_rough_delay_us(5); | |
| 1809 wait_chip_not_busy(); | |
| 1810 write_spi(0x06,RELEASE); /* WREN */ | |
| 1811 write_spi(0x02,HOLDCS); /* write cmd */ | |
| 1812 write_address(HOLDCS); | |
| 1813 | |
| 1814 remaining_length = length - i; | |
| 420 | 1815 remaining_page_size = 0xFF - (uint8_t)(actualAddress & 0xFF) +1; |
| 38 | 1816 remaining_space_to_ring_end = ringStop - actualAddress; |
| 1817 | |
| 420 | 1818 if(remaining_length >= 256) |
| 1819 { | |
| 1820 remaining_length = 255; /* up to 256 bytes may be written in one burst. Last byte is written with release */ | |
| 1821 } | |
| 1822 else | |
| 38 | 1823 { |
| 420 | 1824 remaining_length--; /* last byte needed for release */ |
| 1825 } | |
| 1826 if(remaining_length >= (remaining_page_size) ) /* use 256 byte page and calculate number of bytes left */ | |
| 1827 { | |
| 1828 remaining_length = remaining_page_size - 1; | |
| 1829 } | |
| 1830 if( (remaining_space_to_ring_end >= 256)) | |
| 1831 { | |
| 1832 for(int j=0; j<remaining_length; j++) | |
| 38 | 1833 { |
| 1834 write_spi(sendByte[i],HOLDCS);/* write data */ | |
| 1835 actualAddress++; | |
| 1836 i++; | |
| 1837 } | |
| 1838 } | |
| 1839 /* byte with RELEASE */ | |
| 1840 write_spi(sendByte[i],RELEASE);/* write data */ | |
| 1841 actualAddress++; | |
| 420 | 1842 i++; |
| 1843 | |
| 38 | 1844 if(actualAddress > ringStop) |
| 1845 actualAddress = ringStart; | |
| 420 | 1846 |
| 38 | 1847 if(do_not_erase == 0) |
| 1848 ext_flash_erase_if_on_page_start(); | |
| 1849 } | |
| 1850 switch(type) | |
| 1851 { | |
| 1852 case EF_HEADER: | |
| 1853 actualPointerHeader = actualAddress; | |
| 1854 break; | |
| 1855 case EF_SAMPLE: | |
| 1856 actualPointerSample = actualAddress; | |
| 1857 break; | |
| 1858 case EF_DEVICEDATA: | |
| 1859 actualPointerDevicedata = actualAddress; | |
| 1860 break; | |
| 1861 case EF_VPMDATA: | |
| 1862 actualPointerVPM = actualAddress; | |
| 1863 break; | |
| 1864 case EF_SETTINGS: | |
| 1865 actualPointerSettings = actualAddress; | |
| 1866 break; | |
| 1867 case EF_FIRMWARE: | |
| 1868 actualPointerFirmware = actualAddress; | |
| 1869 break; | |
| 1870 case EF_FIRMWARE2: | |
| 1871 actualPointerFirmware2 = actualAddress; | |
| 1872 break; | |
| 1873 default: | |
| 1874 break; | |
| 1875 } | |
| 1876 } | |
| 1877 | |
| 1878 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1879 static _Bool ext_flash_test_remaining_space_of_page_empty(uint32_t pointer, uint16_t length) |
| 38 | 1880 { |
| 1881 if((pointer & 0xFFF) == 0) | |
| 1882 return 1; | |
| 1883 | |
| 1884 uint32_t backup = actualAddress; | |
| 1885 uint8_t data; | |
| 1886 uint32_t size_to_page_end; | |
| 1887 | |
| 1888 size_to_page_end = 0x1000 - (pointer & 0xFFF); | |
| 1889 if(length > size_to_page_end) | |
| 1890 length = size_to_page_end; | |
| 1891 | |
| 1892 actualAddress = pointer; | |
| 1893 ext_flash_read_block_start(); | |
| 1894 | |
| 1895 for(uint16_t i = 0; i<length; i++) | |
| 1896 { | |
| 1897 ext_flash_read_block(&data, 255); // 255 = ENTIRE FLASH | |
| 1898 if(data != 0xFF) | |
| 1899 { | |
| 1900 ext_flash_read_block_stop(); | |
| 1901 actualAddress = backup; | |
| 1902 return 0; | |
| 1903 } | |
| 1904 } | |
| 1905 ext_flash_read_block_stop(); | |
| 1906 actualAddress = backup; | |
| 1907 return 1; | |
| 1908 } | |
| 1909 | |
| 1910 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1911 static void ext_flash_set_to_begin_of_next_page(uint32_t *pointer, uint8_t type) |
| 38 | 1912 { |
| 1913 uint32_t ringStart, ringStop; | |
| 1914 | |
| 1915 switch(type) | |
| 1916 { | |
| 1917 case EF_HEADER: | |
| 1918 ringStart = HEADERSTART; | |
| 1919 ringStop = HEADERSTOP; | |
| 1920 break; | |
| 1921 case EF_SAMPLE: | |
| 1922 ringStart = SAMPLESTART; | |
| 1923 ringStop = SAMPLESTOP; | |
| 1924 break; | |
| 1925 case EF_DEVICEDATA: | |
| 1926 ringStart = DDSTART; | |
| 1927 ringStop = DDSTOP; | |
| 1928 break; | |
| 1929 case EF_VPMDATA: | |
| 1930 ringStart = VPMSTART; | |
| 1931 ringStop = VPMSTOP; | |
| 1932 break; | |
| 1933 case EF_SETTINGS: | |
| 1934 ringStart = SETTINGSSTART; | |
| 1935 ringStop = SETTINGSSTOP; | |
| 1936 break; | |
| 1937 default: | |
| 1938 ringStart = FLASHSTART; | |
| 1939 ringStop = FLASHSTOP; | |
| 1940 break; | |
| 1941 } | |
| 1942 | |
| 1943 *pointer = (*pointer & 0xFFF) + 0x1000; | |
| 1944 | |
| 1945 if((*pointer < ringStart) || (*pointer >= ringStop)) | |
| 1946 *pointer = ringStart; | |
| 1947 } | |
| 1948 | |
| 1949 | |
| 1950 static void ef_erase_64K(uint32_t blocks) | |
| 1951 { | |
| 1952 for(uint32_t i = 0; i < blocks; i++) | |
| 1953 { | |
| 1954 wait_chip_not_busy(); | |
| 1955 write_spi(0x06,RELEASE);/* WREN */ | |
| 1956 write_spi(0xD8,HOLDCS);/* 64k erase cmd */ | |
| 1957 write_address(RELEASE); | |
| 1958 actualAddress += 0x10000; | |
| 1959 HAL_Delay(25); | |
| 1960 } | |
| 1961 } | |
| 1962 | |
| 1963 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1964 static void chip_unselect(void) |
| 38 | 1965 { |
| 1966 HAL_GPIO_WritePin(EXTFLASH_CSB_GPIO_PORT,EXTFLASH_CSB_PIN,GPIO_PIN_SET); // chip select | |
| 1967 } | |
| 1968 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1969 static void chip_select(void) |
| 38 | 1970 { |
| 1971 HAL_GPIO_WritePin(EXTFLASH_CSB_GPIO_PORT,EXTFLASH_CSB_PIN,GPIO_PIN_RESET); // chip select | |
| 1972 } | |
| 1973 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1974 static void error_led_on(void) |
| 38 | 1975 { |
| 1976 HAL_GPIO_WritePin(OSCILLOSCOPE_GPIO_PORT,OSCILLOSCOPE_PIN,GPIO_PIN_SET); | |
| 1977 } | |
| 1978 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1979 static void error_led_off(void) |
| 38 | 1980 { |
| 1981 HAL_GPIO_WritePin(OSCILLOSCOPE_GPIO_PORT,OSCILLOSCOPE_PIN,GPIO_PIN_RESET); | |
| 1982 } | |
| 1983 | |
| 1984 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
1985 static uint8_t read_spi(uint8_t unselect_CS_afterwards) |
| 38 | 1986 { |
| 1987 uint8_t byte; | |
| 1988 | |
| 1989 chip_select(); | |
| 1990 | |
| 1991 if(HAL_SPI_Receive(&hspiDisplay, &byte, 1, 10000) != HAL_OK) | |
| 1992 Error_Handler_extflash(); | |
| 1993 | |
| 1994 while (HAL_SPI_GetState(&hspiDisplay) != HAL_SPI_STATE_READY) | |
| 1995 { | |
| 1996 } | |
| 1997 if(unselect_CS_afterwards) | |
| 1998 chip_unselect(); | |
| 1999 | |
| 2000 return byte; | |
| 2001 } | |
| 2002 | |
| 2003 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2004 static void write_spi(uint8_t data, uint8_t unselect_CS_afterwards) |
| 38 | 2005 { |
| 2006 chip_select(); | |
| 2007 | |
| 2008 if(HAL_SPI_Transmit(&hspiDisplay, &data, 1, 10000) != HAL_OK) | |
| 2009 Error_Handler_extflash(); | |
| 2010 | |
| 2011 while (HAL_SPI_GetState(&hspiDisplay) != HAL_SPI_STATE_READY) | |
| 2012 { | |
| 2013 } | |
| 2014 if(unselect_CS_afterwards) | |
| 2015 chip_unselect(); | |
| 2016 } | |
| 2017 | |
| 2018 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2019 static void write_address(uint8_t unselect_CS_afterwards) |
| 38 | 2020 { |
| 2021 uint8_t hi, med ,lo; | |
| 2022 | |
| 2023 hi = (actualAddress >> 16) & 0xFF; | |
| 2024 med = (actualAddress >> 8) & 0xFF; | |
| 2025 lo = actualAddress & 0xFF; | |
| 2026 | |
| 2027 write_spi(hi, HOLDCS); | |
| 2028 write_spi(med, HOLDCS); | |
| 2029 write_spi(lo, unselect_CS_afterwards); | |
| 2030 } | |
| 2031 | |
| 2032 | |
| 2033 static void wait_chip_not_busy(void) | |
| 2034 { | |
| 2035 uint8_t status; | |
| 2036 | |
| 2037 chip_unselect(); | |
| 2038 | |
| 2039 write_spi(0x05,HOLDCS); /* RDSR */ | |
| 2040 status = read_spi(HOLDCS);/* read status */ | |
| 2041 while(status & 0x01) | |
| 2042 { | |
| 2043 HAL_Delay(1); | |
| 2044 status = read_spi(HOLDCS);/* read status */ | |
| 2045 } | |
| 2046 chip_unselect(); | |
| 2047 } | |
| 2048 | |
| 2049 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2050 static void ext_flash_incf_address(uint8_t type) |
| 38 | 2051 { |
| 2052 uint32_t ringStart, ringStop; | |
| 2053 | |
| 2054 actualAddress += 1; | |
| 2055 | |
| 2056 switch(type) | |
| 2057 { | |
| 2058 case EF_HEADER: | |
| 2059 ringStart = HEADERSTART; | |
| 2060 ringStop = HEADERSTOP; | |
| 2061 break; | |
| 2062 case EF_SAMPLE: | |
| 2063 ringStart = SAMPLESTART; | |
| 2064 ringStop = SAMPLESTOP; | |
| 2065 break; | |
| 2066 case EF_DEVICEDATA: | |
| 2067 ringStart = DDSTART; | |
| 2068 ringStop = DDSTOP; | |
| 2069 break; | |
| 2070 case EF_VPMDATA: | |
| 2071 ringStart = VPMSTART; | |
| 2072 ringStop = VPMSTOP; | |
| 2073 break; | |
| 2074 case EF_SETTINGS: | |
| 2075 ringStart = SETTINGSSTART; | |
| 2076 ringStop = SETTINGSSTOP; | |
| 2077 break; | |
| 2078 case EF_FIRMWARE: | |
| 2079 ringStart = FWSTART; | |
| 2080 ringStop = FWSTOP; | |
| 2081 break; | |
| 2082 case EF_FIRMWARE2: | |
| 2083 ringStart = FWSTART2; | |
| 2084 ringStop = FWSTOP2; | |
| 2085 break; | |
| 2086 default: | |
| 2087 ringStart = FLASHSTART; | |
| 2088 ringStop = FLASHSTOP; | |
| 2089 break; | |
| 2090 } | |
| 2091 | |
| 2092 if((actualAddress < ringStart) || (actualAddress > ringStop)) | |
| 2093 actualAddress = ringStart; | |
| 2094 } | |
| 2095 | |
| 2096 | |
|
268
1b9847d40e81
cleanup: make things static where possible.
Jan Mulder <jlmulder@xs4all.nl>
parents:
225
diff
changeset
|
2097 static void ext_flash_decf_address_ring(uint8_t type) |
| 38 | 2098 { |
| 2099 uint32_t ringStart, ringStop; | |
| 2100 | |
| 2101 switch(type) | |
| 2102 { | |
| 2103 case EF_HEADER: | |
| 2104 ringStart = HEADERSTART; | |
| 2105 ringStop = HEADERSTOP; | |
| 2106 break; | |
| 2107 case EF_SAMPLE: | |
| 2108 ringStart = SAMPLESTART; | |
| 2109 ringStop = SAMPLESTOP; | |
| 2110 break; | |
| 2111 case EF_DEVICEDATA: | |
| 2112 ringStart = DDSTART; | |
| 2113 ringStop = DDSTOP; | |
| 2114 break; | |
| 2115 case EF_VPMDATA: | |
| 2116 ringStart = VPMSTART; | |
| 2117 ringStop = VPMSTOP; | |
| 2118 break; | |
| 2119 case EF_SETTINGS: | |
| 2120 ringStart = SETTINGSSTART; | |
| 2121 ringStop = SETTINGSSTOP; | |
| 2122 break; | |
| 2123 case EF_FIRMWARE: | |
| 2124 ringStart = FWSTART; | |
| 2125 ringStop = FWSTOP; | |
| 2126 break; | |
| 2127 case EF_FIRMWARE2: | |
| 2128 ringStart = FWSTART2; | |
| 2129 ringStop = FWSTOP2; | |
| 2130 break; | |
| 2131 default: | |
| 2132 ringStart = FLASHSTART; | |
| 2133 ringStop = FLASHSTOP; | |
| 2134 break; | |
| 2135 } | |
| 2136 | |
| 2137 if((actualAddress <= ringStart) || (actualAddress > ringStop)) | |
| 2138 actualAddress = ringStop; | |
| 2139 else | |
| 2140 actualAddress -= 1; | |
| 2141 } | |
| 2142 | |
| 2143 | |
| 2144 static void ef_hw_rough_delay_us(uint32_t delayUs) | |
| 2145 { | |
| 2146 if(!delayUs) | |
| 2147 return; | |
| 2148 delayUs*= 12; | |
| 2149 while(delayUs--); | |
| 2150 return; | |
| 2151 } | |
| 2152 | |
| 2153 static void Error_Handler_extflash(void) | |
| 2154 { | |
| 2155 while(1) | |
| 2156 { | |
| 2157 } | |
| 2158 } | |
|
425
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2159 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2160 void ext_flash_CloseSector(void) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2161 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2162 uint32_t actualAddressBackup = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2163 int i=0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2164 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2165 if(closeSectorAddress != 0) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2166 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2167 /* 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
|
2168 actualAddress = closeSectorAddress; |
|
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 wait_chip_not_busy(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2171 write_spi(0x06,RELEASE); /* WREN */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2172 write_spi(0x02,HOLDCS); /* write cmd */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2173 write_address(HOLDCS); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2174 for(i = 0; i<8; i++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2175 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2176 write_spi(0xA5,HOLDCS);/* write data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2177 actualAddress++; |
|
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 /* byte with RELEASE */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2180 write_spi(0xA5,RELEASE);/* write data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2181 actualAddress = actualAddressBackup; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2182 closeSectorAddress = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2183 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2184 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2185 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2186 uint32_t ext_flash_AnalyseSampleBuffer(char *pstrResult) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2187 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2188 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
|
2189 uint32_t curAddress = SAMPLESTART; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2190 uint8_t curSector = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2191 uint8_t samplebuffer[10]; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2192 uint32_t actualAddressBackup = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2193 uint8_t emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2194 uint32_t i = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2195 uint8_t startedSectors = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2196 uint8_t lastSectorInuse = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2197 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2198 /* check if a sector is used till its end */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2199 for(curSector = 0; curSector < 16; curSector++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2200 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2201 sectorState[curSector] = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2202 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2203 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
|
2204 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2205 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2206 for(uint32_t i=0;i<10;i++) |
|
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 samplebuffer[i] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2209 if(samplebuffer[i] == 0xFF) |
|
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 emptyCellCnt++; |
|
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 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2214 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2215 if(emptyCellCnt == 10) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2216 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2217 sectorState[curSector] = SECTOR_NOTUSED; |
|
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 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2220 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
|
2221 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2222 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2223 for(i=0;i<10;i++) |
|
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 samplebuffer[i] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2226 if(samplebuffer[i] == 0xFF) |
|
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 emptyCellCnt++; |
|
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 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2232 if(emptyCellCnt == 10) |
|
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 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
|
2235 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2236 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2237 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2238 for(i=0;i<16;i++) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2239 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2240 if( sectorState[i] == SECTOR_INUSE) |
|
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 startedSectors++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2243 lastSectorInuse = i; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2244 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2245 *(pstrResult+i) = sectorState[i] + 48; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2246 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2247 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2248 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
|
2249 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2250 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
|
2251 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2252 /* 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
|
2253 curAddress = SAMPLESTART + (lastSectorInuse * 0x10000); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2254 emptyCellCnt = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2255 actualAddress = curAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2256 ext_flash_read_block_start(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2257 while((emptyCellCnt < 10) && (actualAddress < curAddress + 0x10000)) |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2258 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2259 samplebuffer[0] = read_spi(HOLDCS);/* read data */ |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2260 if(samplebuffer[0] == 0xFF) |
|
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 emptyCellCnt++; |
|
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 else |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2265 { |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2266 emptyCellCnt = 0; |
|
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 actualAddress++; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2269 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2270 ext_flash_read_block_stop(); |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2271 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
|
2272 actualPointerSample = actualAddress; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2273 |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2274 closeSectorAddress = settingsGetPointer()->logFlashNextSampleStartAddress & 0xFFFF0000; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2275 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
|
2276 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
|
2277 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2278 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2279 actualAddress = actualAddressBackup; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2280 *(pstrResult+i) = 0; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2281 return startedSectors; |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2282 } |
|
86fcac4cc43a
Added function to analyse the sampel ringbuffer:
ideenmodellierer
parents:
423
diff
changeset
|
2283 |
|
452
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2284 /* 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
|
2285 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
|
2286 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2287 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
|
2288 uint8_t diveidx; |
|
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 uint8_t header1, header2; |
|
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 SSettings *settings = settingsGetPointer(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2293 diveidx = settings->lastDiveLogId + 1; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2294 convert_Type dataStart, dataEnd; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2295 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2296 uint32_t HeaderAddrBackup = actualPointerHeader; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2297 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2298 while(diveidx != settings->lastDiveLogId) |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2299 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2300 actualAddress = HEADERSTART + (0x800 * diveidx) + HEADER2OFFSET; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2301 ext_flash_read_block_start(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2302 ext_flash_read_block(&header1, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2303 ext_flash_read_block(&header2, EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2304 dataStart.u8bit.byteHigh = 0; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2305 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
|
2306 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
|
2307 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
|
2308 dataEnd.u8bit.byteHigh = 0; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2309 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
|
2310 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
|
2311 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
|
2312 ext_flash_read_block_stop(); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2313 |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2314 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
|
2315 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2316 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
|
2317 || ((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
|
2318 { |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2319 actualAddress = HEADERSTART + (0x800 * diveidx) + HEADER2OFFSET; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2320 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
|
2321 ext_flash_incf_address(EF_HEADER); |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2322 actualPointerHeader = actualAddress; |
|
b90ddf57f7f1
Added compile variant enabling the reset of profile sample information:
ideenmodellierer
parents:
429
diff
changeset
|
2323 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
|
2324 actualPointerHeader = HeaderAddrBackup; |
|
459
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
2325 } |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
2326 } |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
2327 diveidx++; |
|
7ac0e76dbd6a
Activated reset of sample information within header data at time of sector erasing:
ideenmodellierer
parents:
452
diff
changeset
|
2328 } |
|
452
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 |
|
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 |
|
225
2bb1db22b5f5
cleanup: random set of cleanups
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
2333 /* |
| 38 | 2334 uint8_t ext_flash_erase_firmware_if_not_empty(void) |
| 2335 { | |
| 2336 const uint8_t TESTSIZE_FW = 4; | |
| 2337 | |
| 2338 uint8_t data[TESTSIZE_FW]; | |
| 2339 uint8_t notEmpty = 0; | |
| 2340 | |
| 2341 actualAddress = FWSTART; | |
| 2342 ext_flash_read_block_start(); | |
| 2343 for(int i = 0; i < TESTSIZE_FW; i++) | |
| 2344 { | |
| 2345 ext_flash_read_block(&data[i], EF_FIRMWARE); | |
| 2346 if(data[i] != 0xFF) | |
| 2347 notEmpty = 1; | |
| 2348 } | |
| 2349 ext_flash_read_block_stop(); | |
| 2350 | |
| 2351 if(notEmpty) | |
| 2352 { | |
| 2353 ext_flash_erase_firmware(); | |
| 2354 return 1; | |
| 2355 } | |
| 2356 else | |
| 2357 return 0; | |
| 2358 } | |
| 2359 | |
| 2360 uint8_t ext_flash_erase_firmware2_if_not_empty(void) | |
| 2361 { | |
| 2362 const uint8_t TESTSIZE_FW = 4; | |
| 2363 | |
| 2364 uint8_t data[TESTSIZE_FW]; | |
| 2365 uint8_t notEmpty = 0; | |
| 2366 | |
| 2367 actualAddress = FWSTART2; | |
| 2368 ext_flash_read_block_start(); | |
| 2369 for(int i = 0; i < TESTSIZE_FW; i++) | |
| 2370 { | |
| 2371 ext_flash_read_block(&data[i], EF_FIRMWARE2); | |
| 2372 if(data[i] != 0xFF) | |
| 2373 notEmpty = 1; | |
| 2374 } | |
| 2375 ext_flash_read_block_stop(); | |
| 2376 | |
| 2377 if(notEmpty) | |
| 2378 { | |
| 2379 ext_flash_erase_firmware2(); | |
| 2380 return 1; | |
| 2381 } | |
| 2382 else | |
| 2383 return 0; | |
|
225
2bb1db22b5f5
cleanup: random set of cleanups
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
2384 }*/ |