?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
flash: Fix flash write algorithm on pflash only devices.
[openocd.git] / src / flash / nor / kinetis.c
blob46d36bbb97d82d9eeb1db78d6118a29b09e0a64e
1 /***************************************************************************
2 * Copyright (C) 2011 by Mathias Kuester *
3 * kesmtp@freenet.de *
4 * *
5 * Copyright (C) 2011 sleep(5) ltd *
6 * tomas@sleepfive.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "imp.h"
29 #include "helper/binarybuffer.h"
30
31 struct kinetis_flash_bank {
32 uint32_t nvm_start;
33 };
34
35 static int kinetis_get_master_bank(struct flash_bank *bank,
36 struct flash_bank **master_bank)
37 {
38 *master_bank = get_flash_bank_by_name_noprobe(bank->name);
39 if (*master_bank == NULL) {
40 LOG_ERROR("master flash bank '%s' does not exist",
41 (char *)bank->driver_priv);
42 return ERROR_FLASH_OPERATION_FAILED;
43 }
44
45 return ERROR_OK;
46 }
47
48 static int kinetis_update_bank_info(struct flash_bank *bank)
49 {
50 int result;
51 struct flash_bank *master_bank;
52
53 result = kinetis_get_master_bank(bank, &master_bank);
54
55 if (result != ERROR_OK)
56 return result;
57
58 /* update the info we do not have */
59 bank->size = master_bank->size;
60 bank->chip_width = master_bank->chip_width;
61 bank->bus_width = master_bank->bus_width;
62 bank->num_sectors = master_bank->num_sectors;
63 bank->sectors = master_bank->sectors;
64
65 return ERROR_OK;
66 }
67
68 FLASH_BANK_COMMAND_HANDLER(kinetis_flash_bank_command)
69 {
70 struct kinetis_flash_bank *bank_info;
71
72 if (CMD_ARGC < 6)
73 return ERROR_COMMAND_SYNTAX_ERROR;
74
75 LOG_INFO("add flash_bank kinetis %s", bank->name);
76
77 bank_info = malloc(sizeof(struct kinetis_flash_bank));
78
79 memset(bank_info, 0, sizeof(struct kinetis_flash_bank));
80
81 bank->driver_priv = bank_info;
82
83 return ERROR_OK;
84 }
85
86 static int kinetis_protect(struct flash_bank *bank, int set, int first,
87 int last)
88 {
89 int result;
90 struct flash_bank *master_bank;
91
92 result = kinetis_get_master_bank(bank, &master_bank);
93
94 if (result != ERROR_OK)
95 return result;
96
97 LOG_WARNING("kinetis_protect not supported yet");
98
99 if (bank->target->state != TARGET_HALTED) {
100 LOG_ERROR("Target not halted");
101 return ERROR_TARGET_NOT_HALTED;
102 }
103
104 return ERROR_OK;
105 }
106
107 static int kinetis_protect_check(struct flash_bank *bank)
108 {
109 int result;
110 struct flash_bank *master_bank;
111 uint8_t buffer[4];
112 uint32_t fprot, psize, psec;
113 int i, b;
114
115 if (bank->target->state != TARGET_HALTED) {
116 LOG_ERROR("Target not halted");
117 return ERROR_TARGET_NOT_HALTED;
118 }
119
120 result = kinetis_get_master_bank(bank, &master_bank);
121
122 if (result != ERROR_OK)
123 return result;
124
125 /* read protection register FTFL_FPROT */
126 result = target_read_memory(bank->target, 0x40020010, 1, 4, buffer);
127
128 if (result != ERROR_OK)
129 return result;
130
131 fprot = target_buffer_get_u32(bank->target, buffer);
132
133 /* every bit protect 1/32 of the full flash */
134 psize = bank->size / 32;
135 psec = 0;
136 b = 0;
137
138 for (i = 0; i < bank->num_sectors; i++) {
139 if ((fprot >> b) & 1)
140 bank->sectors[i].is_protected = 0;
141 else
142 bank->sectors[i].is_protected = 1;
143
144 psec += bank->sectors[i].size;
145
146 if (psec >= psize) {
147 psec = 0;
148 b++;
149 }
150 }
151
152 return ERROR_OK;
153 }
154
155 static int kinetis_ftfl_command(struct flash_bank *bank, uint32_t w0,
156 uint32_t w1, uint32_t w2)
157 {
158 uint8_t buffer[12];
159 int result, i;
160
161 /* wait for done */
162 for (i = 0; i < 50; i++) {
163 result =
164 target_read_memory(bank->target, 0x40020000, 1, 1, buffer);
165
166 if (result != ERROR_OK)
167 return result;
168
169 if (buffer[0] & 0x80)
170 break;
171
172 buffer[0] = 0x00;
173 }
174
175 if (buffer[0] != 0x80) {
176 /* reset error flags */
177 buffer[0] = 0x30;
178 result =
179 target_write_memory(bank->target, 0x40020000, 1, 1, buffer);
180 if (result != ERROR_OK)
181 return result;
182 }
183
184 target_buffer_set_u32(bank->target, buffer, w0);
185 target_buffer_set_u32(bank->target, buffer + 4, w1);
186 target_buffer_set_u32(bank->target, buffer + 8, w2);
187
188 result = target_write_memory(bank->target, 0x40020004, 4, 3, buffer);
189
190 if (result != ERROR_OK)
191 return result;
192
193 /* start command */
194 buffer[0] = 0x80;
195 result = target_write_memory(bank->target, 0x40020000, 1, 1, buffer);
196 if (result != ERROR_OK)
197 return result;
198
199 /* wait for done */
200 for (i = 0; i < 50; i++) {
201 result =
202 target_read_memory(bank->target, 0x40020000, 1, 1, buffer);
203
204 if (result != ERROR_OK)
205 return result;
206
207 if (buffer[0] & 0x80)
208 break;
209
210 buffer[0] = 0x00;
211 }
212
213 if (buffer[0] != 0x80) {
214 LOG_ERROR
215 ("ftfl command failed FSTAT: %02X W0: %08X W1: %08X W2: %08X",
216 buffer[0], w0, w1, w2);
217
218 return ERROR_FLASH_OPERATION_FAILED;
219 }
220
221 return ERROR_OK;
222 }
223
224 static int kinetis_erase(struct flash_bank *bank, int first, int last)
225 {
226 struct flash_bank *master_bank;
227 int result, i;
228 uint32_t w0 = 0, w1 = 0, w2 = 0;
229
230 if (bank->target->state != TARGET_HALTED) {
231 LOG_ERROR("Target not halted");
232 return ERROR_TARGET_NOT_HALTED;
233 }
234
235 result = kinetis_get_master_bank(bank, &master_bank);
236
237 if (result != ERROR_OK)
238 return result;
239
240 if ((first > bank->num_sectors) || (last > bank->num_sectors))
241 return ERROR_FLASH_OPERATION_FAILED;
242
243 for (i = first; i <= last; i++) {
244 /* set command and sector address */
245 w0 = (0x09 << 24) | bank->sectors[i].offset;
246
247 result = kinetis_ftfl_command(bank, w0, w1, w2);
248
249 if (result != ERROR_OK) {
250 LOG_WARNING("erase sector %d failed", i);
251 return ERROR_FLASH_OPERATION_FAILED;
252 }
253
254 bank->sectors[i].is_erased = 1;
255 }
256
257 if (first == 0) {
258 LOG_WARNING
259 ("flash configuration field erased, please reset the device");
260 }
261
262 return ERROR_OK;
263 }
264
265 static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
266 uint32_t offset, uint32_t count)
267 {
268 struct flash_bank *master_bank;
269 unsigned int i, result, fallback = 0, nvm = 0;
270 uint8_t buf[8];
271 uint32_t wc, w0 = 0, w1 = 0, w2 = 0;
272 struct kinetis_flash_bank *kbank = (struct kinetis_flash_bank *)
273 bank->driver_priv;
274
275 if (bank->target->state != TARGET_HALTED) {
276 LOG_ERROR("Target not halted");
277 return ERROR_TARGET_NOT_HALTED;
278 }
279
280 result = kinetis_get_master_bank(bank, &master_bank);
281
282 if (result != ERROR_OK)
283 return result;
284
285 if (offset >= kbank->nvm_start)
286 nvm = 1;
287
288 if (!nvm && (offset + count) > kbank->nvm_start) {
289 /* we could flash this in two goes, but if the segment
290 spans across the pflash/nvm boundary, something is probably
291 not right.
292 */
293 LOG_ERROR("Segment spans NVM boundary");
294 return ERROR_FLASH_DST_OUT_OF_BANK;
295 }
296
297 if (nvm) {
298 LOG_DEBUG("flash write into NVM @%08X", offset);
299
300 /* make flex ram available */
301 w0 = (0x81 << 24) | 0x00ff0000;
302
303 result = kinetis_ftfl_command(bank, w0, w1, w2);
304
305 if (result != ERROR_OK)
306 return ERROR_FLASH_OPERATION_FAILED;
307
308 /* check if ram ready */
309 result = target_read_memory(bank->target, 0x40020001, 1, 1, buf);
310
311 if (result != ERROR_OK)
312 return result;
313
314 if (!(buf[0] & (1 << 1))) {
315 /* fallback to longword write */
316 fallback = 1;
317
318 LOG_WARNING("ram not ready, fallback to slow longword write (FCNFG: %02X)",
319 buf[0]);
320 }
321 } else {
322 LOG_DEBUG("flash write into PFLASH @08%X", offset);
323 }
324
325
326 /* program section command */
327 if (fallback == 0) {
328 for (i = 0; i < count; i += (2 * 1024)) {
329 wc = 512;
330
331 if ((count - i) < (2 * 1024)) {
332 wc = count - i;
333 wc /= 4;
334 }
335
336 LOG_DEBUG("write section @ %08X with length %d",
337 offset + i, wc * 4);
338
339 /* write data to flexram */
340 result =
341 target_write_memory(bank->target, 0x14000000, 4, wc,
342 buffer + i);
343
344 if (result != ERROR_OK) {
345 LOG_ERROR("target_write_memory failed");
346
347 return result;
348 }
349
350 /* execute section command */
351 w0 = (0x0b << 24) | (offset + i);
352 w1 = (256 << 16);
353
354 result = kinetis_ftfl_command(bank, w0, w1, w2);
355
356 if (result != ERROR_OK)
357 return ERROR_FLASH_OPERATION_FAILED;
358 }
359 }
360 /* program longword command */
361 else {
362 for (i = 0; i < count; i += 4) {
363 LOG_DEBUG("write longword @ %08X", offset + i);
364
365 w0 = (0x06 << 24) | (offset + i);
366 w1 = buf_get_u32(buffer + offset + i, 0, 32);
367
368 result = kinetis_ftfl_command(bank, w0, w1, w2);
369
370 if (result != ERROR_OK)
371 return ERROR_FLASH_OPERATION_FAILED;
372 }
373 }
374
375 return ERROR_OK;
376 }
377
378 static int kinetis_probe(struct flash_bank *bank)
379 {
380 struct flash_bank *master_bank;
381 int result, i;
382 uint8_t buf[4];
383 uint32_t sim_sdid, sim_fcfg1, sim_fcfg2, offset = 0;
384 uint32_t nvm_size, pf_size, ee_size;
385
386 if (bank->target->state != TARGET_HALTED) {
387 LOG_ERROR("Target not halted");
388 return ERROR_TARGET_NOT_HALTED;
389 }
390
391 result = kinetis_get_master_bank(bank, &master_bank);
392
393 if (result != ERROR_OK)
394 return result;
395
396 result = target_read_memory(bank->target, 0x40048024, 1, 4, buf);
397 if (result != ERROR_OK)
398 return result;
399 sim_sdid = target_buffer_get_u32(bank->target, buf);
400 result = target_read_memory(bank->target, 0x4004804c, 1, 4, buf);
401 if (result != ERROR_OK)
402 return result;
403 sim_fcfg1 = target_buffer_get_u32(bank->target, buf);
404 result = target_read_memory(bank->target, 0x40048050, 1, 4, buf);
405 if (result != ERROR_OK)
406 return result;
407 sim_fcfg2 = target_buffer_get_u32(bank->target, buf);
408
409 LOG_DEBUG("SDID: %08X FCFG1: %08X FCFG2: %08X", sim_sdid, sim_fcfg1,
410 sim_fcfg2);
411
412 switch ((sim_fcfg1 >> 28) & 0x0f) {
413 case 0x07:
414 nvm_size = 128 * 1024;
415 break;
416 case 0x09:
417 case 0x0f:
418 nvm_size = 256 * 1024;
419 break;
420 default:
421 nvm_size = 0;
422 break;
423 }
424
425 switch ((sim_fcfg1 >> 24) & 0x0f) {
426 case 0x07:
427 pf_size = 128 * 1024;
428 break;
429 case 0x09:
430 pf_size = 256 * 1024;
431 break;
432 case 0x0b:
433 case 0x0f:
434 pf_size = 512 * 1024;
435 break;
436 default:
437 pf_size = 0;
438 break;
439 }
440
441 switch ((sim_fcfg1 >> 16) & 0x0f) {
442 case 0x02:
443 ee_size = 4 * 1024;
444 break;
445 case 0x03:
446 ee_size = 2 * 1024;
447 break;
448 case 0x04:
449 ee_size = 1 * 1024;
450 break;
451 case 0x05:
452 ee_size = 512;
453 break;
454 case 0x06:
455 ee_size = 256;
456 break;
457 case 0x07:
458 ee_size = 128;
459 break;
460 case 0x08:
461 ee_size = 64;
462 break;
463 case 0x09:
464 ee_size = 32;
465 break;
466 default:
467 ee_size = 0;
468 break;
469 }
470
471 ((struct kinetis_flash_bank *) bank->driver_priv)->nvm_start =
472 pf_size - nvm_size;
473
474 LOG_DEBUG("NVM: %d PF: %d EE: %d BL1: %d", nvm_size, pf_size, ee_size,
475 (sim_fcfg2 >> 23) & 1);
476
477 if (pf_size != bank->size) {
478 LOG_WARNING("flash size is different %d != %d", pf_size,
479 bank->size);
480 }
481
482 bank->num_sectors = bank->size / (2 * 1024);
483 assert(bank->num_sectors > 0);
484 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
485
486 for (i = 0; i < bank->num_sectors; i++) {
487 bank->sectors[i].offset = offset;
488 bank->sectors[i].size = 2 * 1024;
489 offset += bank->sectors[i].size;
490 bank->sectors[i].is_erased = -1;
491 bank->sectors[i].is_protected = 1;
492 }
493
494 /* update the info we do not have */
495 return kinetis_update_bank_info(bank);
496 }
497
498 static int kinetis_auto_probe(struct flash_bank *bank)
499 {
500 return kinetis_probe(bank);
501 }
502
503 static int kinetis_info(struct flash_bank *bank, char *buf, int buf_size)
504 {
505 int result;
506 struct flash_bank *master_bank;
507
508 result = kinetis_get_master_bank(bank, &master_bank);
509
510 if (result != ERROR_OK)
511 return result;
512
513 snprintf(buf, buf_size,
514 "%s driver for flash bank %s at 0x%8.8" PRIx32 "",
515 bank->driver->name, master_bank->name, master_bank->base);
516
517 return ERROR_OK;
518 }
519
520 static int kinetis_blank_check(struct flash_bank *bank)
521 {
522 int result;
523 struct flash_bank *master_bank;
524
525 LOG_WARNING("kinetis_blank_check not supported yet");
526
527 if (bank->target->state != TARGET_HALTED) {
528 LOG_ERROR("Target not halted");
529 return ERROR_TARGET_NOT_HALTED;
530 }
531
532 result = kinetis_get_master_bank(bank, &master_bank);
533
534 if (result != ERROR_OK)
535 return result;
536
537 return ERROR_OK;
538 }
539
540 static int kinetis_flash_read(struct flash_bank *bank,
541 uint8_t *buffer, uint32_t offset, uint32_t count)
542 {
543 int result;
544 struct flash_bank *master_bank;
545
546 LOG_WARNING("kinetis_flash_read not supported yet");
547
548 if (bank->target->state != TARGET_HALTED) {
549 LOG_ERROR("Target not halted");
550 return ERROR_TARGET_NOT_HALTED;
551 }
552
553 result = kinetis_get_master_bank(bank, &master_bank);
554
555 if (result != ERROR_OK)
556 return result;
557
558 return ERROR_OK;
559 }
560
561 struct flash_driver kinetis_flash = {
562 .name = "kinetis",
563 .flash_bank_command = kinetis_flash_bank_command,
564 .erase = kinetis_erase,
565 .protect = kinetis_protect,
566 .write = kinetis_write,
567 .read = kinetis_flash_read,
568 .probe = kinetis_probe,
569 .auto_probe = kinetis_auto_probe,
570 .erase_check = kinetis_blank_check,
571 .protect_check = kinetis_protect_check,
572 .info = kinetis_info,
573 };
Official OpenOCD Mirror