aboutsummaryrefslogtreecommitdiff
path: root/tmk_core/common
diff options
context:
space:
mode:
authoryiancar <yiangosyiangou@cytanet.com.cy>2019-01-07 01:22:19 +0000
committerMechMerlin <30334081+mechmerlin@users.noreply.github.com>2019-01-06 17:22:19 -0800
commit2bfac351edebc6e141d3291448512b0e228e5c47 (patch)
treedd8f9ed31f1a3ddabe59f26a9fdfb85b1570d0ae /tmk_core/common
parent2c0bc5ed6be737e98377fa2299102f6737bbea72 (diff)
downloadqmk_firmware-2bfac351edebc6e141d3291448512b0e228e5c47.tar.gz
qmk_firmware-2bfac351edebc6e141d3291448512b0e228e5c47.zip
Final HS60v2 changes. (#4790)
* initial commit, this now mostly works - RGB controls work - Dynamic keymap still broken due to eeprom - Via works * STM32 eeprom update - Update EEPROM emulation library to handle 8bit data like AVR. - This library also allows for multiple page pairs resulting in greater EEPROM size flexibility * hs60 changes * HS60 hhkb added * Update keyboards/hs60/v2/config.h Co-Authored-By: yiancar <yiangosyiangou@cytanet.com.cy>
Diffstat (limited to 'tmk_core/common')
-rwxr-xr-xtmk_core/common/chibios/eeprom_stm32.c710
-rwxr-xr-xtmk_core/common/chibios/eeprom_stm32.h68
-rwxr-xr-xtmk_core/common/chibios/flash_stm32.c15
-rwxr-xr-xtmk_core/common/chibios/flash_stm32.h1
-rw-r--r--tmk_core/common/eeconfig.c4
-rw-r--r--tmk_core/common/eeconfig.h21
-rw-r--r--tmk_core/common/eeprom.h1
7 files changed, 172 insertions, 648 deletions
diff --git a/tmk_core/common/chibios/eeprom_stm32.c b/tmk_core/common/chibios/eeprom_stm32.c
index a86998550..a15430d67 100755
--- a/tmk_core/common/chibios/eeprom_stm32.c
+++ b/tmk_core/common/chibios/eeprom_stm32.c
@@ -10,664 +10,206 @@
10 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 10 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
11 * DEALINGS IN THE SOFTWARE. 11 * DEALINGS IN THE SOFTWARE.
12 * 12 *
13 * This files are free to use from https://github.com/rogerclarkmelbourne/Arduino_STM32 and 13 * This files are free to use from http://engsta.com/stm32-flash-memory-eeprom-emulator/ by
14 * https://github.com/leaflabs/libmaple 14 * Artur F.
15 * 15 *
16 * Modifications for QMK and STM32F303 by Yiancar 16 * Modifications for QMK and STM32F303 by Yiancar
17 */ 17 */
18 18
19#include <stdio.h>
20#include <string.h>
19#include "eeprom_stm32.h" 21#include "eeprom_stm32.h"
22/*****************************************************************************
23 * Allows to use the internal flash to store non volatile data. To initialize
24 * the functionality use the EEPROM_Init() function. Be sure that by reprogramming
25 * of the controller just affected pages will be deleted. In other case the non
26 * volatile data will be lost.
27******************************************************************************/
28
29/* Private macro -------------------------------------------------------------*/
30/* Private variables ---------------------------------------------------------*/
31/* Functions -----------------------------------------------------------------*/
32
33uint8_t DataBuf[FEE_PAGE_SIZE];
34/*****************************************************************************
35* Delete Flash Space used for user Data, deletes the whole space between
36* RW_PAGE_BASE_ADDRESS and the last uC Flash Page
37******************************************************************************/
38uint16_t EEPROM_Init(void) {
39 // unlock flash
40 FLASH_Unlock();
20 41
21 FLASH_Status EE_ErasePage(uint32_t); 42 // Clear Flags
22 43 //FLASH_ClearFlag(FLASH_SR_EOP|FLASH_SR_PGERR|FLASH_SR_WRPERR);
23 uint16_t EE_CheckPage(uint32_t, uint16_t);
24 uint16_t EE_CheckErasePage(uint32_t, uint16_t);
25 uint16_t EE_Format(void);
26 uint32_t EE_FindValidPage(void);
27 uint16_t EE_GetVariablesCount(uint32_t, uint16_t);
28 uint16_t EE_PageTransfer(uint32_t, uint32_t, uint16_t);
29 uint16_t EE_VerifyPageFullWriteVariable(uint16_t, uint16_t);
30
31 uint32_t PageBase0 = EEPROM_PAGE0_BASE;
32 uint32_t PageBase1 = EEPROM_PAGE1_BASE;
33 uint32_t PageSize = EEPROM_PAGE_SIZE;
34 uint16_t Status = EEPROM_NOT_INIT;
35
36// See http://www.st.com/web/en/resource/technical/document/application_note/CD00165693.pdf
37
38/**
39 * @brief Check page for blank
40 * @param page base address
41 * @retval Success or error
42 * EEPROM_BAD_FLASH: page not empty after erase
43 * EEPROM_OK: page blank
44 */
45uint16_t EE_CheckPage(uint32_t pageBase, uint16_t status)
46{
47 uint32_t pageEnd = pageBase + (uint32_t)PageSize;
48
49 // Page Status not EEPROM_ERASED and not a "state"
50 if ((*(__IO uint16_t*)pageBase) != EEPROM_ERASED && (*(__IO uint16_t*)pageBase) != status)
51 return EEPROM_BAD_FLASH;
52 for(pageBase += 4; pageBase < pageEnd; pageBase += 4)
53 if ((*(__IO uint32_t*)pageBase) != 0xFFFFFFFF) // Verify if slot is empty
54 return EEPROM_BAD_FLASH;
55 return EEPROM_OK;
56}
57
58/**
59 * @brief Erase page with increment erase counter (page + 2)
60 * @param page base address
61 * @retval Success or error
62 * FLASH_COMPLETE: success erase
63 * - Flash error code: on write Flash error
64 */
65FLASH_Status EE_ErasePage(uint32_t pageBase)
66{
67 FLASH_Status FlashStatus;
68 uint16_t data = (*(__IO uint16_t*)(pageBase));
69 if ((data == EEPROM_ERASED) || (data == EEPROM_VALID_PAGE) || (data == EEPROM_RECEIVE_DATA))
70 data = (*(__IO uint16_t*)(pageBase + 2)) + 1;
71 else
72 data = 0;
73
74 FlashStatus = FLASH_ErasePage(pageBase);
75 if (FlashStatus == FLASH_COMPLETE)
76 FlashStatus = FLASH_ProgramHalfWord(pageBase + 2, data);
77
78 return FlashStatus;
79}
80 44
81/** 45 return FEE_DENSITY_BYTES;
82 * @brief Check page for blank and erase it
83 * @param page base address
84 * @retval Success or error
85 * - Flash error code: on write Flash error
86 * - EEPROM_BAD_FLASH: page not empty after erase
87 * - EEPROM_OK: page blank
88 */
89uint16_t EE_CheckErasePage(uint32_t pageBase, uint16_t status)
90{
91 uint16_t FlashStatus;
92 if (EE_CheckPage(pageBase, status) != EEPROM_OK)
93 {
94 FlashStatus = EE_ErasePage(pageBase);
95 if (FlashStatus != FLASH_COMPLETE)
96 return FlashStatus;
97 return EE_CheckPage(pageBase, status);
98 }
99 return EEPROM_OK;
100} 46}
47/*****************************************************************************
48* Erase the whole reserved Flash Space used for user Data
49******************************************************************************/
50void EEPROM_Erase (void) {
101 51
102/** 52 int page_num = 0;
103 * @brief Find valid Page for write or read operation
104 * @param Page0: Page0 base address
105 * Page1: Page1 base address
106 * @retval Valid page address (PAGE0 or PAGE1) or NULL in case of no valid page was found
107 */
108uint32_t EE_FindValidPage(void)
109{
110 uint16_t status0 = (*(__IO uint16_t*)PageBase0); // Get Page0 actual status
111 uint16_t status1 = (*(__IO uint16_t*)PageBase1); // Get Page1 actual status
112
113 if (status0 == EEPROM_VALID_PAGE && status1 == EEPROM_ERASED)
114 return PageBase0;
115 if (status1 == EEPROM_VALID_PAGE && status0 == EEPROM_ERASED)
116 return PageBase1;
117
118 return 0;
119}
120 53
121/** 54 // delete all pages from specified start page to the last page
122 * @brief Calculate unique variables in EEPROM 55 do {
123 * @param start: address of first slot to check (page + 4) 56 FLASH_ErasePage(FEE_PAGE_BASE_ADDRESS + (page_num * FEE_PAGE_SIZE));
124 * @param end: page end address 57 page_num++;
125 * @param address: 16 bit virtual address of the variable to excluse (or 0XFFFF) 58 } while (page_num < FEE_DENSITY_PAGES);
126 * @retval count of variables
127 */
128uint16_t EE_GetVariablesCount(uint32_t pageBase, uint16_t skipAddress)
129{
130 uint16_t varAddress, nextAddress;
131 uint32_t idx;
132 uint32_t pageEnd = pageBase + (uint32_t)PageSize;
133 uint16_t count = 0;
134
135 for (pageBase += 6; pageBase < pageEnd; pageBase += 4)
136 {
137 varAddress = (*(__IO uint16_t*)pageBase);
138 if (varAddress == 0xFFFF || varAddress == skipAddress)
139 continue;
140
141 count++;
142 for(idx = pageBase + 4; idx < pageEnd; idx += 4)
143 {
144 nextAddress = (*(__IO uint16_t*)idx);
145 if (nextAddress == varAddress)
146 {
147 count--;
148 break;
149 }
150 }
151 }
152 return count;
153} 59}
60/*****************************************************************************
61* Writes once data byte to flash on specified address. If a byte is already
62* written, the whole page must be copied to a buffer, the byte changed and
63* the manipulated buffer written after PageErase.
64*******************************************************************************/
65uint16_t EEPROM_WriteDataByte (uint16_t Address, uint8_t DataByte) {
154 66
155/** 67 FLASH_Status FlashStatus = FLASH_COMPLETE;
156 * @brief Transfers last updated variables data from the full Page to an empty one.
157 * @param newPage: new page base address
158 * @param oldPage: old page base address
159 * @param SkipAddress: 16 bit virtual address of the variable (or 0xFFFF)
160 * @retval Success or error status:
161 * - FLASH_COMPLETE: on success
162 * - EEPROM_OUT_SIZE: if valid new page is full
163 * - Flash error code: on write Flash error
164 */
165uint16_t EE_PageTransfer(uint32_t newPage, uint32_t oldPage, uint16_t SkipAddress)
166{
167 uint32_t oldEnd, newEnd;
168 uint32_t oldIdx, newIdx, idx;
169 uint16_t address, data, found;
170 FLASH_Status FlashStatus;
171
172 // Transfer process: transfer variables from old to the new active page
173 newEnd = newPage + ((uint32_t)PageSize);
174
175 // Find first free element in new page
176 for (newIdx = newPage + 4; newIdx < newEnd; newIdx += 4)
177 if ((*(__IO uint32_t*)newIdx) == 0xFFFFFFFF) // Verify if element
178 break; // contents are 0xFFFFFFFF
179 if (newIdx >= newEnd)
180 return EEPROM_OUT_SIZE;
181
182 oldEnd = oldPage + 4;
183 oldIdx = oldPage + (uint32_t)(PageSize - 2);
184
185 for (; oldIdx > oldEnd; oldIdx -= 4)
186 {
187 address = *(__IO uint16_t*)oldIdx;
188 if (address == 0xFFFF || address == SkipAddress)
189 continue; // it's means that power off after write data
190
191 found = 0;
192 for (idx = newPage + 6; idx < newIdx; idx += 4)
193 if ((*(__IO uint16_t*)(idx)) == address)
194 {
195 found = 1;
196 break;
197 }
198
199 if (found)
200 continue;
201
202 if (newIdx < newEnd)
203 {
204 data = (*(__IO uint16_t*)(oldIdx - 2));
205
206 FlashStatus = FLASH_ProgramHalfWord(newIdx, data);
207 if (FlashStatus != FLASH_COMPLETE)
208 return FlashStatus;
209 68
210 FlashStatus = FLASH_ProgramHalfWord(newIdx + 2, address); 69 uint32_t page;
211 if (FlashStatus != FLASH_COMPLETE) 70 int i;
212 return FlashStatus;
213 71
214 newIdx += 4; 72 // exit if desired address is above the limit (e.G. under 2048 Bytes for 4 pages)
215 } 73 if (Address > FEE_DENSITY_BYTES) {
216 else 74 return 0;
217 return EEPROM_OUT_SIZE;
218 } 75 }
219 76
220 // Erase the old Page: Set old Page status to EEPROM_EEPROM_ERASED status 77 // calculate which page is affected (Pagenum1/Pagenum2...PagenumN)
221 data = EE_CheckErasePage(oldPage, EEPROM_ERASED); 78 page = (FEE_PAGE_BASE_ADDRESS + FEE_ADDR_OFFSET(Address)) & 0x00000FFF;
222 if (data != EEPROM_OK)
223 return data;
224 79
225 // Set new Page status 80 if (page % FEE_PAGE_SIZE) page = page + FEE_PAGE_SIZE;
226 FlashStatus = FLASH_ProgramHalfWord(newPage, EEPROM_VALID_PAGE); 81 page = (page / FEE_PAGE_SIZE) - 1;
227 if (FlashStatus != FLASH_COMPLETE)
228 return FlashStatus;
229 82
230 return EEPROM_OK; 83 // if current data is 0xFF, the byte is empty, just overwrite with the new one
231} 84 if ((*(__IO uint16_t*)(FEE_PAGE_BASE_ADDRESS + FEE_ADDR_OFFSET(Address))) == FEE_EMPTY_WORD) {
232 85
233/** 86 FlashStatus = FLASH_ProgramHalfWord(FEE_PAGE_BASE_ADDRESS + FEE_ADDR_OFFSET(Address), (uint16_t)(0x00FF & DataByte));
234 * @brief Verify if active page is full and Writes variable in EEPROM.
235 * @param Address: 16 bit virtual address of the variable
236 * @param Data: 16 bit data to be written as variable value
237 * @retval Success or error status:
238 * - FLASH_COMPLETE: on success
239 * - EEPROM_PAGE_FULL: if valid page is full (need page transfer)
240 * - EEPROM_NO_VALID_PAGE: if no valid page was found
241 * - EEPROM_OUT_SIZE: if EEPROM size exceeded
242 * - Flash error code: on write Flash error
243 */
244uint16_t EE_VerifyPageFullWriteVariable(uint16_t Address, uint16_t Data)
245{
246 FLASH_Status FlashStatus;
247 uint32_t idx, pageBase, pageEnd, newPage;
248 uint16_t count;
249
250 // Get valid Page for write operation
251 pageBase = EE_FindValidPage();
252 if (pageBase == 0)
253 return EEPROM_NO_VALID_PAGE;
254
255 // Get the valid Page end Address
256 pageEnd = pageBase + PageSize; // Set end of page
257
258 for (idx = pageEnd - 2; idx > pageBase; idx -= 4)
259 {
260 if ((*(__IO uint16_t*)idx) == Address) // Find last value for address
261 {
262 count = (*(__IO uint16_t*)(idx - 2)); // Read last data
263 if (count == Data)
264 return EEPROM_OK;
265 if (count == 0xFFFF)
266 {
267 FlashStatus = FLASH_ProgramHalfWord(idx - 2, Data); // Set variable data
268 if (FlashStatus == FLASH_COMPLETE)
269 return EEPROM_OK;
270 }
271 break;
272 }
273 } 87 }
88 else {
274 89
275 // Check each active page address starting from begining 90 // Copy Page to a buffer
276 for (idx = pageBase + 4; idx < pageEnd; idx += 4) 91 memcpy(DataBuf, (uint8_t*)FEE_PAGE_BASE_ADDRESS + (page * FEE_PAGE_SIZE), FEE_PAGE_SIZE); // !!! Calculate base address for the desired page
277 if ((*(__IO uint32_t*)idx) == 0xFFFFFFFF) // Verify if element
278 { // contents are 0xFFFFFFFF
279 FlashStatus = FLASH_ProgramHalfWord(idx, Data); // Set variable data
280 if (FlashStatus != FLASH_COMPLETE)
281 return FlashStatus;
282 FlashStatus = FLASH_ProgramHalfWord(idx + 2, Address); // Set variable virtual address
283 if (FlashStatus != FLASH_COMPLETE)
284 return FlashStatus;
285 return EEPROM_OK;
286 }
287
288 // Empty slot not found, need page transfer
289 // Calculate unique variables in page
290 count = EE_GetVariablesCount(pageBase, Address) + 1;
291 if (count >= (PageSize / 4 - 1))
292 return EEPROM_OUT_SIZE;
293
294 if (pageBase == PageBase1)
295 newPage = PageBase0; // New page address where variable will be moved to
296 else
297 newPage = PageBase1;
298
299 // Set the new Page status to RECEIVE_DATA status
300 FlashStatus = FLASH_ProgramHalfWord(newPage, EEPROM_RECEIVE_DATA);
301 if (FlashStatus != FLASH_COMPLETE)
302 return FlashStatus;
303
304 // Write the variable passed as parameter in the new active page
305 FlashStatus = FLASH_ProgramHalfWord(newPage + 4, Data);
306 if (FlashStatus != FLASH_COMPLETE)
307 return FlashStatus;
308
309 FlashStatus = FLASH_ProgramHalfWord(newPage + 6, Address);
310 if (FlashStatus != FLASH_COMPLETE)
311 return FlashStatus;
312
313 return EE_PageTransfer(newPage, pageBase, Address);
314}
315
316/*EEPROMClass::EEPROMClass(void)
317{
318 PageBase0 = EEPROM_PAGE0_BASE;
319 PageBase1 = EEPROM_PAGE1_BASE;
320 PageSize = EEPROM_PAGE_SIZE;
321 Status = EEPROM_NOT_INIT;
322}*/
323/*
324uint16_t EEPROM_init(uint32_t pageBase0, uint32_t pageBase1, uint32_t pageSize)
325{
326 PageBase0 = pageBase0;
327 PageBase1 = pageBase1;
328 PageSize = pageSize;
329 return EEPROM_init();
330}*/
331 92
332uint16_t EEPROM_init(void) 93 // check if new data is differ to current data, return if not, proceed if yes
333{ 94 if (DataByte == *(__IO uint8_t*)(FEE_PAGE_BASE_ADDRESS + FEE_ADDR_OFFSET(Address))) {
334 uint16_t status0 = 6, status1 = 6; 95 return 0;
335 FLASH_Status FlashStatus; 96 }
336 97
337 FLASH_Unlock(); 98 // manipulate desired data byte in temp data array if new byte is differ to the current
338 Status = EEPROM_NO_VALID_PAGE; 99 DataBuf[FEE_ADDR_OFFSET(Address)] = DataByte;
339 100
340 status0 = (*(__IO uint16_t *)PageBase0); 101 //Erase Page
341 status1 = (*(__IO uint16_t *)PageBase1); 102 FlashStatus = FLASH_ErasePage(FEE_PAGE_BASE_ADDRESS + page);
342 103
343 switch (status0) 104 // Write new data (whole page) to flash if data has beed changed
344 { 105 for(i = 0; i < (FEE_PAGE_SIZE / 2); i++) {
345/* 106 if ((__IO uint16_t)(0xFF00 | DataBuf[FEE_ADDR_OFFSET(i)]) != 0xFFFF) {
346 Page0 Page1 107 FlashStatus = FLASH_ProgramHalfWord((FEE_PAGE_BASE_ADDRESS + (page * FEE_PAGE_SIZE)) + (i * 2), (uint16_t)(0xFF00 | DataBuf[FEE_ADDR_OFFSET(i)]));
347 ----- -----
348 EEPROM_ERASED EEPROM_VALID_PAGE Page1 valid, Page0 erased
349 EEPROM_RECEIVE_DATA Page1 need set to valid, Page0 erased
350 EEPROM_ERASED make EE_Format
351 any Error: EEPROM_NO_VALID_PAGE
352*/
353 case EEPROM_ERASED:
354 if (status1 == EEPROM_VALID_PAGE) // Page0 erased, Page1 valid
355 Status = EE_CheckErasePage(PageBase0, EEPROM_ERASED);
356 else if (status1 == EEPROM_RECEIVE_DATA) // Page0 erased, Page1 receive
357 {
358 FlashStatus = FLASH_ProgramHalfWord(PageBase1, EEPROM_VALID_PAGE);
359 if (FlashStatus != FLASH_COMPLETE)
360 Status = FlashStatus;
361 else
362 Status = EE_CheckErasePage(PageBase0, EEPROM_ERASED);
363 }
364 else if (status1 == EEPROM_ERASED) // Both in erased state so format EEPROM
365 Status = EEPROM_format();
366 break;
367/*
368 Page0 Page1
369 ----- -----
370 EEPROM_RECEIVE_DATA EEPROM_VALID_PAGE Transfer Page1 to Page0
371 EEPROM_ERASED Page0 need set to valid, Page1 erased
372 any EEPROM_NO_VALID_PAGE
373*/
374 case EEPROM_RECEIVE_DATA:
375 if (status1 == EEPROM_VALID_PAGE) // Page0 receive, Page1 valid
376 Status = EE_PageTransfer(PageBase0, PageBase1, 0xFFFF);
377 else if (status1 == EEPROM_ERASED) // Page0 receive, Page1 erased
378 {
379 Status = EE_CheckErasePage(PageBase1, EEPROM_ERASED);
380 if (Status == EEPROM_OK)
381 {
382 FlashStatus = FLASH_ProgramHalfWord(PageBase0, EEPROM_VALID_PAGE);
383 if (FlashStatus != FLASH_COMPLETE)
384 Status = FlashStatus;
385 else
386 Status = EEPROM_OK;
387 } 108 }
388 } 109 }
389 break;
390/*
391 Page0 Page1
392 ----- -----
393 EEPROM_VALID_PAGE EEPROM_VALID_PAGE Error: EEPROM_NO_VALID_PAGE
394 EEPROM_RECEIVE_DATA Transfer Page0 to Page1
395 any Page0 valid, Page1 erased
396*/
397 case EEPROM_VALID_PAGE:
398 if (status1 == EEPROM_VALID_PAGE) // Both pages valid
399 Status = EEPROM_NO_VALID_PAGE;
400 else if (status1 == EEPROM_RECEIVE_DATA)
401 Status = EE_PageTransfer(PageBase1, PageBase0, 0xFFFF);
402 else
403 Status = EE_CheckErasePage(PageBase1, EEPROM_ERASED);
404 break;
405/*
406 Page0 Page1
407 ----- -----
408 any EEPROM_VALID_PAGE Page1 valid, Page0 erased
409 EEPROM_RECEIVE_DATA Page1 valid, Page0 erased
410 any EEPROM_NO_VALID_PAGE
411*/
412 default:
413 if (status1 == EEPROM_VALID_PAGE)
414 Status = EE_CheckErasePage(PageBase0, EEPROM_ERASED); // Check/Erase Page0
415 else if (status1 == EEPROM_RECEIVE_DATA)
416 {
417 FlashStatus = FLASH_ProgramHalfWord(PageBase1, EEPROM_VALID_PAGE);
418 if (FlashStatus != FLASH_COMPLETE)
419 Status = FlashStatus;
420 else
421 Status = EE_CheckErasePage(PageBase0, EEPROM_ERASED);
422 }
423 break;
424 }
425 return Status;
426}
427
428/**
429 * @brief Erases PAGE0 and PAGE1 and writes EEPROM_VALID_PAGE / 0 header to PAGE0
430 * @param PAGE0 and PAGE1 base addresses
431 * @retval Status of the last operation (Flash write or erase) done during EEPROM formating
432 */
433uint16_t EEPROM_format(void)
434{
435 uint16_t status;
436 FLASH_Status FlashStatus;
437 110
438 FLASH_Unlock();
439
440 // Erase Page0
441 status = EE_CheckErasePage(PageBase0, EEPROM_VALID_PAGE);
442 if (status != EEPROM_OK)
443 return status;
444 if ((*(__IO uint16_t*)PageBase0) == EEPROM_ERASED)
445 {
446 // Set Page0 as valid page: Write VALID_PAGE at Page0 base address
447 FlashStatus = FLASH_ProgramHalfWord(PageBase0, EEPROM_VALID_PAGE);
448 if (FlashStatus != FLASH_COMPLETE)
449 return FlashStatus;
450 } 111 }
451 // Erase Page1 112 return FlashStatus;
452 return EE_CheckErasePage(PageBase1, EEPROM_ERASED);
453}
454
455/**
456 * @brief Returns the erase counter for current page
457 * @param Data: Global variable contains the read variable value
458 * @retval Success or error status:
459 * - EEPROM_OK: if erases counter return.
460 * - EEPROM_NO_VALID_PAGE: if no valid page was found.
461 */
462uint16_t EEPROM_erases(uint16_t *Erases)
463{
464 uint32_t pageBase;
465 if (Status != EEPROM_OK)
466 if (EEPROM_init() != EEPROM_OK)
467 return Status;
468
469 // Get active Page for read operation
470 pageBase = EE_FindValidPage();
471 if (pageBase == 0)
472 return EEPROM_NO_VALID_PAGE;
473
474 *Erases = (*(__IO uint16_t*)pageBase+2);
475 return EEPROM_OK;
476}
477
478/**
479 * @brief Returns the last stored variable data, if found,
480 * which correspond to the passed virtual address
481 * @param Address: Variable virtual address
482 * @retval Data for variable or EEPROM_DEFAULT_DATA, if any errors
483 */
484/*
485uint16_t EEPROM_read (uint16_t Address)
486{
487 uint16_t data;
488 EEPROM_read(Address, &data);
489 return data;
490}*/
491
492/**
493 * @brief Returns the last stored variable data, if found,
494 * which correspond to the passed virtual address
495 * @param Address: Variable virtual address
496 * @param Data: Pointer to data variable
497 * @retval Success or error status:
498 * - EEPROM_OK: if variable was found
499 * - EEPROM_BAD_ADDRESS: if the variable was not found
500 * - EEPROM_NO_VALID_PAGE: if no valid page was found.
501 */
502uint16_t EEPROM_read(uint16_t Address, uint16_t *Data)
503{
504 uint32_t pageBase, pageEnd;
505
506 // Set default data (empty EEPROM)
507 *Data = EEPROM_DEFAULT_DATA;
508
509 if (Status == EEPROM_NOT_INIT)
510 if (EEPROM_init() != EEPROM_OK)
511 return Status;
512
513 // Get active Page for read operation
514 pageBase = EE_FindValidPage();
515 if (pageBase == 0)
516 return EEPROM_NO_VALID_PAGE;
517
518 // Get the valid Page end Address
519 pageEnd = pageBase + ((uint32_t)(PageSize - 2));
520
521 // Check each active page address starting from end
522 for (pageBase += 6; pageEnd >= pageBase; pageEnd -= 4)
523 if ((*(__IO uint16_t*)pageEnd) == Address) // Compare the read address with the virtual address
524 {
525 *Data = (*(__IO uint16_t*)(pageEnd - 2)); // Get content of Address-2 which is variable value
526 return EEPROM_OK;
527 }
528
529 // Return ReadStatus value: (0: variable exist, 1: variable doesn't exist)
530 return EEPROM_BAD_ADDRESS;
531}
532
533/**
534 * @brief Writes/upadtes variable data in EEPROM.
535 * @param VirtAddress: Variable virtual address
536 * @param Data: 16 bit data to be written
537 * @retval Success or error status:
538 * - FLASH_COMPLETE: on success
539 * - EEPROM_BAD_ADDRESS: if address = 0xFFFF
540 * - EEPROM_PAGE_FULL: if valid page is full
541 * - EEPROM_NO_VALID_PAGE: if no valid page was found
542 * - EEPROM_OUT_SIZE: if no empty EEPROM variables
543 * - Flash error code: on write Flash error
544 */
545uint16_t EEPROM_write(uint16_t Address, uint16_t Data)
546{
547 if (Status == EEPROM_NOT_INIT)
548 if (EEPROM_init() != EEPROM_OK)
549 return Status;
550
551 if (Address == 0xFFFF)
552 return EEPROM_BAD_ADDRESS;
553
554 // Write the variable virtual address and value in the EEPROM
555 uint16_t status = EE_VerifyPageFullWriteVariable(Address, Data);
556 return status;
557}
558
559/**
560 * @brief Writes/upadtes variable data in EEPROM.
561 The value is written only if differs from the one already saved at the same address.
562 * @param VirtAddress: Variable virtual address
563 * @param Data: 16 bit data to be written
564 * @retval Success or error status:
565 * - EEPROM_SAME_VALUE: If new Data matches existing EEPROM Data
566 * - FLASH_COMPLETE: on success
567 * - EEPROM_BAD_ADDRESS: if address = 0xFFFF
568 * - EEPROM_PAGE_FULL: if valid page is full
569 * - EEPROM_NO_VALID_PAGE: if no valid page was found
570 * - EEPROM_OUT_SIZE: if no empty EEPROM variables
571 * - Flash error code: on write Flash error
572 */
573uint16_t EEPROM_update(uint16_t Address, uint16_t Data)
574{
575 uint16_t temp;
576 EEPROM_read(Address, &temp);
577 if (temp == Data)
578 return EEPROM_SAME_VALUE;
579 else
580 return EEPROM_write(Address, Data);
581} 113}
114/*****************************************************************************
115* Read once data byte from a specified address.
116*******************************************************************************/
117uint8_t EEPROM_ReadDataByte (uint16_t Address) {
582 118
583/** 119 uint8_t DataByte = 0xFF;
584 * @brief Return number of variable
585 * @retval Number of variables
586 */
587uint16_t EEPROM_count(uint16_t *Count)
588{
589 if (Status == EEPROM_NOT_INIT)
590 if (EEPROM_init() != EEPROM_OK)
591 return Status;
592
593 // Get valid Page for write operation
594 uint32_t pageBase = EE_FindValidPage();
595 if (pageBase == 0)
596 return EEPROM_NO_VALID_PAGE; // No valid page, return max. numbers
597 120
598 *Count = EE_GetVariablesCount(pageBase, 0xFFFF); 121 // Get Byte from specified address
599 return EEPROM_OK; 122 DataByte = (*(__IO uint8_t*)(FEE_PAGE_BASE_ADDRESS + FEE_ADDR_OFFSET(Address)));
600}
601 123
602uint16_t EEPROM_maxcount(void) 124 return DataByte;
603{
604 return ((PageSize / 4)-1);
605} 125}
606 126
607 127/*****************************************************************************
128* Wrap library in AVR style functions.
129*******************************************************************************/
608uint8_t eeprom_read_byte (const uint8_t *Address) 130uint8_t eeprom_read_byte (const uint8_t *Address)
609{ 131{
610 const uint16_t p = (const uint32_t) Address; 132 const uint16_t p = (const uint32_t) Address;
611 uint16_t temp; 133 return EEPROM_ReadDataByte(p);
612 EEPROM_read(p, &temp);
613 return (uint8_t) temp;
614} 134}
615 135
616void eeprom_write_byte (uint8_t *Address, uint8_t Value) 136void eeprom_write_byte (uint8_t *Address, uint8_t Value)
617{ 137{
618 uint16_t p = (uint32_t) Address; 138 uint16_t p = (uint32_t) Address;
619 EEPROM_write(p, (uint16_t) Value); 139 EEPROM_WriteDataByte(p, Value);
620} 140}
621 141
622void eeprom_update_byte (uint8_t *Address, uint8_t Value) 142void eeprom_update_byte (uint8_t *Address, uint8_t Value)
623{ 143{
624 uint16_t p = (uint32_t) Address; 144 uint16_t p = (uint32_t) Address;
625 EEPROM_update(p, (uint16_t) Value); 145 EEPROM_WriteDataByte(p, Value);
626} 146}
627 147
628uint16_t eeprom_read_word (const uint16_t *Address) 148uint16_t eeprom_read_word (const uint16_t *Address)
629{ 149{
630 const uint16_t p = (const uint32_t) Address; 150 const uint16_t p = (const uint32_t) Address;
631 uint16_t temp; 151 return EEPROM_ReadDataByte(p) | (EEPROM_ReadDataByte(p+1) << 8);
632 EEPROM_read(p, &temp);
633 return temp;
634} 152}
635 153
636void eeprom_write_word (uint16_t *Address, uint16_t Value) 154void eeprom_write_word (uint16_t *Address, uint16_t Value)
637{ 155{
638 uint16_t p = (uint32_t) Address; 156 uint16_t p = (uint32_t) Address;
639 EEPROM_write(p, Value); 157 EEPROM_WriteDataByte(p, (uint8_t) Value);
158 EEPROM_WriteDataByte(p + 1, (uint8_t) (Value >> 8));
640} 159}
641 160
642void eeprom_update_word (uint16_t *Address, uint16_t Value) 161void eeprom_update_word (uint16_t *Address, uint16_t Value)
643{ 162{
644 uint16_t p = (uint32_t) Address; 163 uint16_t p = (uint32_t) Address;
645 EEPROM_update(p, Value); 164 EEPROM_WriteDataByte(p, (uint8_t) Value);
165 EEPROM_WriteDataByte(p + 1, (uint8_t) (Value >> 8));
646} 166}
647 167
648uint32_t eeprom_read_dword (const uint32_t *Address) 168uint32_t eeprom_read_dword (const uint32_t *Address)
649{ 169{
650 const uint16_t p = (const uint32_t) Address; 170 const uint16_t p = (const uint32_t) Address;
651 uint16_t temp1, temp2; 171 return EEPROM_ReadDataByte(p) | (EEPROM_ReadDataByte(p+1) << 8)
652 EEPROM_read(p, &temp1); 172 | (EEPROM_ReadDataByte(p+2) << 16) | (EEPROM_ReadDataByte(p+3) << 24);
653 EEPROM_read(p + 1, &temp2);
654 return temp1 | (temp2 << 16);
655} 173}
656 174
657void eeprom_write_dword (uint32_t *Address, uint32_t Value) 175void eeprom_write_dword (uint32_t *Address, uint32_t Value)
658{ 176{
659 uint16_t temp = (uint16_t) Value; 177 uint16_t p = (const uint32_t) Address;
660 uint16_t p = (uint32_t) Address; 178 EEPROM_WriteDataByte(p, (uint8_t) Value);
661 EEPROM_write(p, temp); 179 EEPROM_WriteDataByte(p+1, (uint8_t) (Value >> 8));
662 temp = (uint16_t) (Value >> 16); 180 EEPROM_WriteDataByte(p+2, (uint8_t) (Value >> 16));
663 EEPROM_write(p + 1, temp); 181 EEPROM_WriteDataByte(p+3, (uint8_t) (Value >> 24));
664} 182}
665 183
666void eeprom_update_dword (uint32_t *Address, uint32_t Value) 184void eeprom_update_dword (uint32_t *Address, uint32_t Value)
667{ 185{
668 uint16_t temp = (uint16_t) Value; 186 uint16_t p = (const uint32_t) Address;
669 uint16_t p = (uint32_t) Address; 187 EEPROM_WriteDataByte(p, (uint8_t) Value);
670 EEPROM_update(p, temp); 188 EEPROM_WriteDataByte(p+1, (uint8_t) (Value >> 8));
671 temp = (uint16_t) (Value >> 16); 189 EEPROM_WriteDataByte(p+2, (uint8_t) (Value >> 16));
672 EEPROM_update(p + 1, temp); 190 EEPROM_WriteDataByte(p+3, (uint8_t) (Value >> 24));
191}
192
193void eeprom_read_block(void *buf, const void *addr, uint32_t len) {
194 const uint8_t *p = (const uint8_t *)addr;
195 uint8_t *dest = (uint8_t *)buf;
196 while (len--) {
197 *dest++ = eeprom_read_byte(p++);
198 }
199}
200
201void eeprom_write_block(const void *buf, void *addr, uint32_t len) {
202 uint8_t *p = (uint8_t *)addr;
203 const uint8_t *src = (const uint8_t *)buf;
204 while (len--) {
205 eeprom_write_byte(p++, *src++);
206 }
207}
208
209void eeprom_update_block(const void *buf, void *addr, uint32_t len) {
210 uint8_t *p = (uint8_t *)addr;
211 const uint8_t *src = (const uint8_t *)buf;
212 while (len--) {
213 eeprom_write_byte(p++, *src++);
214 }
673} 215}
diff --git a/tmk_core/common/chibios/eeprom_stm32.h b/tmk_core/common/chibios/eeprom_stm32.h
index 09229530c..892e417b7 100755
--- a/tmk_core/common/chibios/eeprom_stm32.h
+++ b/tmk_core/common/chibios/eeprom_stm32.h
@@ -10,15 +10,17 @@
10 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 10 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
11 * DEALINGS IN THE SOFTWARE. 11 * DEALINGS IN THE SOFTWARE.
12 * 12 *
13 * This files are free to use from https://github.com/rogerclarkmelbourne/Arduino_STM32 and 13 * This files are free to use from http://engsta.com/stm32-flash-memory-eeprom-emulator/ by
14 * https://github.com/leaflabs/libmaple 14 * Artur F.
15 * 15 *
16 * Modifications for QMK and STM32F303 by Yiancar 16 * Modifications for QMK and STM32F303 by Yiancar
17 *
18 * This library assumes 8-bit data locations. To add a new MCU, please provide the flash
19 * page size and the total flash size in Kb. The number of available pages must be a multiple
20 * of 2. Only half of the pages account for the total EEPROM size.
21 * This library also assumes that the pages are not used by the firmware.
17 */ 22 */
18 23
19// This file must be modified if the MCU is not defined below.
20// This library also assumes that the pages are not used by the firmware.
21
22#ifndef __EEPROM_H 24#ifndef __EEPROM_H
23#define __EEPROM_H 25#define __EEPROM_H
24 26
@@ -38,9 +40,11 @@
38 40
39#ifndef EEPROM_PAGE_SIZE 41#ifndef EEPROM_PAGE_SIZE
40 #if defined (MCU_STM32F103RB) 42 #if defined (MCU_STM32F103RB)
41 #define EEPROM_PAGE_SIZE (uint16_t)0x400 /* Page size = 1KByte */ 43 #define FEE_PAGE_SIZE (uint16_t)0x400 // Page size = 1KByte
44 #define FEE_DENSITY_PAGES 2 // How many pages are used
42 #elif defined (MCU_STM32F103ZE) || defined (MCU_STM32F103RE) || defined (MCU_STM32F103RD) || defined (MCU_STM32F303CC) 45 #elif defined (MCU_STM32F103ZE) || defined (MCU_STM32F103RE) || defined (MCU_STM32F103RD) || defined (MCU_STM32F303CC)
43 #define EEPROM_PAGE_SIZE (uint16_t)0x800 /* Page size = 2KByte */ 46 #define FEE_PAGE_SIZE (uint16_t)0x800 // Page size = 2KByte
47 #define FEE_DENSITY_PAGES 4 // How many pages are used
44 #else 48 #else
45 #error "No MCU type specified. Add something like -DMCU_STM32F103RB to your compiler arguments (probably in a Makefile)." 49 #error "No MCU type specified. Add something like -DMCU_STM32F103RB to your compiler arguments (probably in a Makefile)."
46 #endif 50 #endif
@@ -48,48 +52,30 @@
48 52
49#ifndef EEPROM_START_ADDRESS 53#ifndef EEPROM_START_ADDRESS
50 #if defined (MCU_STM32F103RB) 54 #if defined (MCU_STM32F103RB)
51 #define EEPROM_START_ADDRESS ((uint32_t)(0x8000000 + 128 * 1024 - 2 * EEPROM_PAGE_SIZE)) 55 #define FEE_MCU_FLASH_SIZE 128 // Size in Kb
52 #elif defined (MCU_STM32F103ZE) || defined (MCU_STM32F103RE) 56 #elif defined (MCU_STM32F103ZE) || defined (MCU_STM32F103RE)
53 #define EEPROM_START_ADDRESS ((uint32_t)(0x8000000 + 512 * 1024 - 2 * EEPROM_PAGE_SIZE)) 57 #define FEE_MCU_FLASH_SIZE 512 // Size in Kb
54 #elif defined (MCU_STM32F103RD) 58 #elif defined (MCU_STM32F103RD)
55 #define EEPROM_START_ADDRESS ((uint32_t)(0x8000000 + 384 * 1024 - 2 * EEPROM_PAGE_SIZE)) 59 #define FEE_MCU_FLASH_SIZE 384 // Size in Kb
56 #elif defined (MCU_STM32F303CC) 60 #elif defined (MCU_STM32F303CC)
57 #define EEPROM_START_ADDRESS ((uint32_t)(0x8000000 + 256 * 1024 - 2 * EEPROM_PAGE_SIZE)) 61 #define FEE_MCU_FLASH_SIZE 256 // Size in Kb
58 #else 62 #else
59 #error "No MCU type specified. Add something like -DMCU_STM32F103RB to your compiler arguments (probably in a Makefile)." 63 #error "No MCU type specified. Add something like -DMCU_STM32F103RB to your compiler arguments (probably in a Makefile)."
60 #endif 64 #endif
61#endif 65#endif
62 66
63/* Pages 0 and 1 base and end addresses */ 67// DONT CHANGE
64#define EEPROM_PAGE0_BASE ((uint32_t)(EEPROM_START_ADDRESS + 0x000)) 68// Choose location for the first EEPROM Page address on the top of flash
65#define EEPROM_PAGE1_BASE ((uint32_t)(EEPROM_START_ADDRESS + EEPROM_PAGE_SIZE)) 69#define FEE_PAGE_BASE_ADDRESS ((uint32_t)(0x8000000 + FEE_MCU_FLASH_SIZE * 1024 - FEE_DENSITY_PAGES * FEE_PAGE_SIZE))
66 70#define FEE_DENSITY_BYTES ((FEE_PAGE_SIZE / 2) * FEE_DENSITY_PAGES - 1)
67/* Page status definitions */ 71#define FEE_LAST_PAGE_ADDRESS (FEE_PAGE_BASE_ADDRESS + (FEE_PAGE_SIZE * FEE_DENSITY_PAGES))
68#define EEPROM_ERASED ((uint16_t)0xFFFF) /* PAGE is empty */ 72#define FEE_EMPTY_WORD ((uint16_t)0xFFFF)
69#define EEPROM_RECEIVE_DATA ((uint16_t)0xEEEE) /* PAGE is marked to receive data */ 73#define FEE_ADDR_OFFSET(Address)(Address * 2) // 1Byte per Word will be saved to preserve Flash
70#define EEPROM_VALID_PAGE ((uint16_t)0x0000) /* PAGE containing valid data */
71
72/* Page full define */
73enum uint16_t
74 {
75 EEPROM_OK = ((uint16_t)0x0000),
76 EEPROM_OUT_SIZE = ((uint16_t)0x0081),
77 EEPROM_BAD_ADDRESS = ((uint16_t)0x0082),
78 EEPROM_BAD_FLASH = ((uint16_t)0x0083),
79 EEPROM_NOT_INIT = ((uint16_t)0x0084),
80 EEPROM_SAME_VALUE = ((uint16_t)0x0085),
81 EEPROM_NO_VALID_PAGE = ((uint16_t)0x00AB)
82 };
83
84#define EEPROM_DEFAULT_DATA 0xFFFF
85 74
86 uint16_t EEPROM_init(void); 75// Use this function to initialize the functionality
87 uint16_t EEPROM_format(void); 76uint16_t EEPROM_Init(void);
88 uint16_t EEPROM_erases(uint16_t *); 77void EEPROM_Erase (void);
89 uint16_t EEPROM_read (uint16_t address, uint16_t *data); 78uint16_t EEPROM_WriteDataByte (uint16_t Address, uint8_t DataByte);
90 uint16_t EEPROM_write(uint16_t address, uint16_t data); 79uint8_t EEPROM_ReadDataByte (uint16_t Address);
91 uint16_t EEPROM_update(uint16_t address, uint16_t data);
92 uint16_t EEPROM_count(uint16_t *);
93 uint16_t EEPROM_maxcount(void);
94 80
95#endif /* __EEPROM_H */ 81#endif /* __EEPROM_H */
diff --git a/tmk_core/common/chibios/flash_stm32.c b/tmk_core/common/chibios/flash_stm32.c
index 273593484..164654a15 100755
--- a/tmk_core/common/chibios/flash_stm32.c
+++ b/tmk_core/common/chibios/flash_stm32.c
@@ -186,3 +186,18 @@ void FLASH_Lock(void)
186 /* Set the Lock Bit to lock the FPEC and the FCR */ 186 /* Set the Lock Bit to lock the FPEC and the FCR */
187 FLASH->CR |= FLASH_CR_LOCK; 187 FLASH->CR |= FLASH_CR_LOCK;
188} 188}
189
190/**
191 * @brief Clears the FLASH's pending flags.
192 * @param FLASH_FLAG: specifies the FLASH flags to clear.
193 * This parameter can be any combination of the following values:
194 * @arg FLASH_FLAG_PGERR: FLASH Programming error flag flag
195 * @arg FLASH_FLAG_WRPERR: FLASH Write protected error flag
196 * @arg FLASH_FLAG_EOP: FLASH End of Programming flag
197 * @retval None
198 */
199void FLASH_ClearFlag(uint32_t FLASH_FLAG)
200{
201 /* Clear the flags */
202 FLASH->SR = FLASH_FLAG;
203}
diff --git a/tmk_core/common/chibios/flash_stm32.h b/tmk_core/common/chibios/flash_stm32.h
index cc065cbca..3c99cc566 100755
--- a/tmk_core/common/chibios/flash_stm32.h
+++ b/tmk_core/common/chibios/flash_stm32.h
@@ -45,6 +45,7 @@ FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
45 45
46void FLASH_Unlock(void); 46void FLASH_Unlock(void);
47void FLASH_Lock(void); 47void FLASH_Lock(void);
48void FLASH_ClearFlag(uint32_t FLASH_FLAG);
48 49
49#ifdef __cplusplus 50#ifdef __cplusplus
50} 51}
diff --git a/tmk_core/common/eeconfig.c b/tmk_core/common/eeconfig.c
index d8bab7d2e..59b2bffbc 100644
--- a/tmk_core/common/eeconfig.c
+++ b/tmk_core/common/eeconfig.c
@@ -33,7 +33,7 @@ void eeconfig_init_kb(void) {
33 */ 33 */
34void eeconfig_init_quantum(void) { 34void eeconfig_init_quantum(void) {
35#ifdef STM32_EEPROM_ENABLE 35#ifdef STM32_EEPROM_ENABLE
36 EEPROM_format(); 36 EEPROM_Erase();
37#endif 37#endif
38 eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER); 38 eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER);
39 eeprom_update_byte(EECONFIG_DEBUG, 0); 39 eeprom_update_byte(EECONFIG_DEBUG, 0);
@@ -74,7 +74,7 @@ void eeconfig_enable(void)
74void eeconfig_disable(void) 74void eeconfig_disable(void)
75{ 75{
76#ifdef STM32_EEPROM_ENABLE 76#ifdef STM32_EEPROM_ENABLE
77 EEPROM_format(); 77 EEPROM_Erase();
78#endif 78#endif
79 eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER_OFF); 79 eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER_OFF);
80} 80}
diff --git a/tmk_core/common/eeconfig.h b/tmk_core/common/eeconfig.h
index 8d4e1d4d0..eedd67602 100644
--- a/tmk_core/common/eeconfig.h
+++ b/tmk_core/common/eeconfig.h
@@ -25,8 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
25#define EECONFIG_MAGIC_NUMBER (uint16_t)0xFEED 25#define EECONFIG_MAGIC_NUMBER (uint16_t)0xFEED
26#define EECONFIG_MAGIC_NUMBER_OFF (uint16_t)0xFFFF 26#define EECONFIG_MAGIC_NUMBER_OFF (uint16_t)0xFFFF
27 27
28/* eeprom parameteter address */ 28/* EEPROM parameter address */
29#if !defined(STM32_EEPROM_ENABLE)
30#define EECONFIG_MAGIC (uint16_t *)0 29#define EECONFIG_MAGIC (uint16_t *)0
31#define EECONFIG_DEBUG (uint8_t *)2 30#define EECONFIG_DEBUG (uint8_t *)2
32#define EECONFIG_DEFAULT_LAYER (uint8_t *)3 31#define EECONFIG_DEFAULT_LAYER (uint8_t *)3
@@ -42,24 +41,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
42#define EECONFIG_KEYBOARD (uint32_t *)15 41#define EECONFIG_KEYBOARD (uint32_t *)15
43#define EECONFIG_USER (uint32_t *)19 42#define EECONFIG_USER (uint32_t *)19
44 43
45#else
46/* STM32F3 uses 16byte block. Reconfigure memory map */
47#define EECONFIG_MAGIC (uint16_t *)0
48#define EECONFIG_DEBUG (uint8_t *)1
49#define EECONFIG_DEFAULT_LAYER (uint8_t *)2
50#define EECONFIG_KEYMAP (uint8_t *)3
51#define EECONFIG_MOUSEKEY_ACCEL (uint8_t *)4
52#define EECONFIG_BACKLIGHT (uint8_t *)5
53#define EECONFIG_AUDIO (uint8_t *)6
54#define EECONFIG_RGBLIGHT (uint32_t *)7
55#define EECONFIG_UNICODEMODE (uint8_t *)9
56#define EECONFIG_STENOMODE (uint8_t *)10
57// EEHANDS for two handed boards
58#define EECONFIG_HANDEDNESS (uint8_t *)11
59#define EECONFIG_KEYBOARD (uint32_t *)12
60#define EECONFIG_USER (uint32_t *)14
61#endif
62
63/* debug bit */ 44/* debug bit */
64#define EECONFIG_DEBUG_ENABLE (1<<0) 45#define EECONFIG_DEBUG_ENABLE (1<<0)
65#define EECONFIG_DEBUG_MATRIX (1<<1) 46#define EECONFIG_DEBUG_MATRIX (1<<1)
diff --git a/tmk_core/common/eeprom.h b/tmk_core/common/eeprom.h
index 3696d0df3..5ae0f6eeb 100644
--- a/tmk_core/common/eeprom.h
+++ b/tmk_core/common/eeprom.h
@@ -20,5 +20,4 @@ void eeprom_update_dword (uint32_t *__p, uint32_t __value);
20void eeprom_update_block (const void *__src, void *__dst, uint32_t __n); 20void eeprom_update_block (const void *__src, void *__dst, uint32_t __n);
21#endif 21#endif
22 22
23
24#endif /* TMK_CORE_COMMON_EEPROM_H_ */ 23#endif /* TMK_CORE_COMMON_EEPROM_H_ */
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-13 06:07:17 +0000