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