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