?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
change #include "algorithm.h" to <target/algorithm.h>
[openocd/ztw.git] / src / flash / nor / lpc2000.c
blob9479a9fe176ca61fa3f10c57f999eca24da13832
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * LPC1700 support Copyright (C) 2009 by Audrius Urmanavicius *
6 * didele.deze@gmail.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 "lpc2000.h"
29 #include "armv7m.h"
30 #include <helper/binarybuffer.h>
31 #include <target/algorithm.h>
32
33
34 /* flash programming support for NXP LPC17xx and LPC2xxx devices
35 * currently supported devices:
36 * variant 1 (lpc2000_v1):
37 * - 2104 | 5 | 6
38 * - 2114 | 9
39 * - 2124 | 9
40 * - 2194
41 * - 2212 | 4
42 * - 2292 | 4
43 *
44 * variant 2 (lpc2000_v2):
45 * - 213x
46 * - 214x
47 * - 2101 | 2 | 3
48 * - 2364 | 6 | 8
49 * - 2378
50 *
51 * lpc1700:
52 * - 175x
53 * - 176x (tested with LPC1768)
54 */
55
56 static int lpc2000_build_sector_list(struct flash_bank *bank)
57 {
58 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
59 int i;
60 uint32_t offset = 0;
61
62 /* default to a 4096 write buffer */
63 lpc2000_info->cmd51_max_buffer = 4096;
64
65 if (lpc2000_info->variant == lpc2000_v1)
66 {
67 /* variant 1 has different layout for 128kb and 256kb flashes */
68 if (bank->size == 128 * 1024)
69 {
70 bank->num_sectors = 16;
71 bank->sectors = malloc(sizeof(struct flash_sector) * 16);
72 for (i = 0; i < 16; i++)
73 {
74 bank->sectors[i].offset = offset;
75 bank->sectors[i].size = 8 * 1024;
76 offset += bank->sectors[i].size;
77 bank->sectors[i].is_erased = -1;
78 bank->sectors[i].is_protected = 1;
79 }
80 }
81 else if (bank->size == 256 * 1024)
82 {
83 bank->num_sectors = 18;
84 bank->sectors = malloc(sizeof(struct flash_sector) * 18);
85
86 for (i = 0; i < 8; i++)
87 {
88 bank->sectors[i].offset = offset;
89 bank->sectors[i].size = 8 * 1024;
90 offset += bank->sectors[i].size;
91 bank->sectors[i].is_erased = -1;
92 bank->sectors[i].is_protected = 1;
93 }
94 for (i = 8; i < 10; i++)
95 {
96 bank->sectors[i].offset = offset;
97 bank->sectors[i].size = 64 * 1024;
98 offset += bank->sectors[i].size;
99 bank->sectors[i].is_erased = -1;
100 bank->sectors[i].is_protected = 1;
101 }
102 for (i = 10; i < 18; i++)
103 {
104 bank->sectors[i].offset = offset;
105 bank->sectors[i].size = 8 * 1024;
106 offset += bank->sectors[i].size;
107 bank->sectors[i].is_erased = -1;
108 bank->sectors[i].is_protected = 1;
109 }
110 }
111 else
112 {
113 LOG_ERROR("BUG: unknown bank->size encountered");
114 exit(-1);
115 }
116 }
117 else if (lpc2000_info->variant == lpc2000_v2)
118 {
119 /* variant 2 has a uniform layout, only number of sectors differs */
120 switch (bank->size)
121 {
122 case 4 * 1024:
123 lpc2000_info->cmd51_max_buffer = 1024;
124 bank->num_sectors = 1;
125 break;
126 case 8 * 1024:
127 lpc2000_info->cmd51_max_buffer = 1024;
128 bank->num_sectors = 2;
129 break;
130 case 16 * 1024:
131 bank->num_sectors = 4;
132 break;
133 case 32 * 1024:
134 bank->num_sectors = 8;
135 break;
136 case 64 * 1024:
137 bank->num_sectors = 9;
138 break;
139 case 128 * 1024:
140 bank->num_sectors = 11;
141 break;
142 case 256 * 1024:
143 bank->num_sectors = 15;
144 break;
145 case 512 * 1024:
146 case 500 * 1024:
147 bank->num_sectors = 27;
148 break;
149 default:
150 LOG_ERROR("BUG: unknown bank->size encountered");
151 exit(-1);
152 break;
153 }
154
155 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
156
157 for (i = 0; i < bank->num_sectors; i++)
158 {
159 if ((i >= 0) && (i < 8))
160 {
161 bank->sectors[i].offset = offset;
162 bank->sectors[i].size = 4 * 1024;
163 offset += bank->sectors[i].size;
164 bank->sectors[i].is_erased = -1;
165 bank->sectors[i].is_protected = 1;
166 }
167 if ((i >= 8) && (i < 22))
168 {
169 bank->sectors[i].offset = offset;
170 bank->sectors[i].size = 32 * 1024;
171 offset += bank->sectors[i].size;
172 bank->sectors[i].is_erased = -1;
173 bank->sectors[i].is_protected = 1;
174 }
175 if ((i >= 22) && (i < 27))
176 {
177 bank->sectors[i].offset = offset;
178 bank->sectors[i].size = 4 * 1024;
179 offset += bank->sectors[i].size;
180 bank->sectors[i].is_erased = -1;
181 bank->sectors[i].is_protected = 1;
182 }
183 }
184 }
185 else if (lpc2000_info->variant == lpc1700)
186 {
187 switch(bank->size)
188 {
189 case 32 * 1024:
190 bank->num_sectors = 8;
191 break;
192 case 64 * 1024:
193 bank->num_sectors = 16;
194 break;
195 case 128 * 1024:
196 bank->num_sectors = 18;
197 break;
198 case 256 * 1024:
199 bank->num_sectors = 22;
200 break;
201 case 512 * 1024:
202 bank->num_sectors = 30;
203 break;
204 default:
205 LOG_ERROR("BUG: unknown bank->size encountered");
206 exit(-1);
207 }
208
209 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
210
211 for(i = 0; i < bank->num_sectors; i++)
212 {
213 bank->sectors[i].offset = offset;
214 /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx devices */
215 bank->sectors[i].size = (i < 16)? 4 * 1024 : 32 * 1024;
216 offset += bank->sectors[i].size;
217 bank->sectors[i].is_erased = -1;
218 bank->sectors[i].is_protected = 1;
219 }
220 }
221 else
222 {
223 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
224 exit(-1);
225 }
226
227 return ERROR_OK;
228 }
229
230 /* call LPC1700/LPC2000 IAP function
231 * uses 180 bytes working area
232 * 0x0 to 0x7: jump gate (BX to thumb state, b -2 to wait)
233 * 0x8 to 0x1f: command parameter table (1+5 words)
234 * 0x20 to 0x33: command result table (1+4 words)
235 * 0x34 to 0xb3: stack (only 128b needed)
236 */
237 static int lpc2000_iap_call(struct flash_bank *bank, int code, uint32_t param_table[5], uint32_t result_table[4])
238 {
239 int retval;
240 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
241 struct target *target = bank->target;
242 struct mem_param mem_params[2];
243 struct reg_param reg_params[5];
244 struct armv4_5_algorithm armv4_5_info; /* for LPC2000 */
245 struct armv7m_algorithm armv7m_info; /* for LPC1700 */
246 uint32_t status_code;
247 uint32_t iap_entry_point = 0; /* to make compiler happier */
248
249 /* regrab previously allocated working_area, or allocate a new one */
250 if (!lpc2000_info->iap_working_area)
251 {
252 uint8_t jump_gate[8];
253
254 /* make sure we have a working area */
255 if (target_alloc_working_area(target, 180, &lpc2000_info->iap_working_area) != ERROR_OK)
256 {
257 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
258 return ERROR_FLASH_OPERATION_FAILED;
259 }
260
261 /* write IAP code to working area */
262 switch(lpc2000_info->variant)
263 {
264 case lpc1700:
265 target_buffer_set_u32(target, jump_gate, ARMV7M_T_BX(12));
266 target_buffer_set_u32(target, jump_gate + 4, ARMV7M_T_B(0xfffffe));
267 break;
268 case lpc2000_v1:
269 case lpc2000_v2:
270 target_buffer_set_u32(target, jump_gate, ARMV4_5_BX(12));
271 target_buffer_set_u32(target, jump_gate + 4, ARMV4_5_B(0xfffffe, 0));
272 break;
273 default:
274 LOG_ERROR("BUG: unknown bank->size encountered");
275 exit(-1);
276 }
277
278 if ((retval = target_write_memory(target, lpc2000_info->iap_working_area->address, 4, 2, jump_gate)) != ERROR_OK)
279 {
280 LOG_ERROR("Write memory at address 0x%8.8" PRIx32 " failed (check work_area definition)", lpc2000_info->iap_working_area->address);
281 return retval;
282 }
283 }
284
285 switch(lpc2000_info->variant)
286 {
287 case lpc1700:
288 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
289 armv7m_info.core_mode = ARMV7M_MODE_ANY;
290 iap_entry_point = 0x1fff1ff1;
291 break;
292 case lpc2000_v1:
293 case lpc2000_v2:
294 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
295 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
296 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
297 iap_entry_point = 0x7ffffff1;
298 break;
299 default:
300 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
301 exit(-1);
302 }
303
304 /* command parameter table */
305 init_mem_param(&mem_params[0], lpc2000_info->iap_working_area->address + 8, 6 * 4, PARAM_OUT);
306 target_buffer_set_u32(target, mem_params[0].value, code);
307 target_buffer_set_u32(target, mem_params[0].value + 0x04, param_table[0]);
308 target_buffer_set_u32(target, mem_params[0].value + 0x08, param_table[1]);
309 target_buffer_set_u32(target, mem_params[0].value + 0x0c, param_table[2]);
310 target_buffer_set_u32(target, mem_params[0].value + 0x10, param_table[3]);
311 target_buffer_set_u32(target, mem_params[0].value + 0x14, param_table[4]);
312
313 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
314 buf_set_u32(reg_params[0].value, 0, 32, lpc2000_info->iap_working_area->address + 0x08);
315
316 /* command result table */
317 init_mem_param(&mem_params[1], lpc2000_info->iap_working_area->address + 0x20, 5 * 4, PARAM_IN);
318
319 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
320 buf_set_u32(reg_params[1].value, 0, 32, lpc2000_info->iap_working_area->address + 0x20);
321
322 /* IAP entry point */
323 init_reg_param(&reg_params[2], "r12", 32, PARAM_OUT);
324 buf_set_u32(reg_params[2].value, 0, 32, iap_entry_point);
325
326 switch(lpc2000_info->variant)
327 {
328 case lpc1700:
329 /* IAP stack */
330 init_reg_param(&reg_params[3], "sp", 32, PARAM_OUT);
331 buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4);
332
333 /* return address */
334 init_reg_param(&reg_params[4], "lr", 32, PARAM_OUT);
335 buf_set_u32(reg_params[4].value, 0, 32, (lpc2000_info->iap_working_area->address + 0x04) | 1); /* bit0 of LR = 1 to return in Thumb mode */
336
337 target_run_algorithm(target, 2, mem_params, 5, reg_params, lpc2000_info->iap_working_area->address, lpc2000_info->iap_working_area->address + 0x4, 10000, &armv7m_info);
338 break;
339 case lpc2000_v1:
340 case lpc2000_v2:
341 /* IAP stack */
342 init_reg_param(&reg_params[3], "r13_svc", 32, PARAM_OUT);
343 buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4);
344
345 /* return address */
346 init_reg_param(&reg_params[4], "lr_svc", 32, PARAM_OUT);
347 buf_set_u32(reg_params[4].value, 0, 32, lpc2000_info->iap_working_area->address + 0x04);
348
349 target_run_algorithm(target, 2, mem_params, 5, reg_params, lpc2000_info->iap_working_area->address, lpc2000_info->iap_working_area->address + 0x4, 10000, &armv4_5_info);
350 break;
351 default:
352 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
353 exit(-1);
354 }
355
356
357 status_code = target_buffer_get_u32(target, mem_params[1].value);
358 result_table[0] = target_buffer_get_u32(target, mem_params[1].value + 0x04);
359 result_table[1] = target_buffer_get_u32(target, mem_params[1].value + 0x08);
360 result_table[2] = target_buffer_get_u32(target, mem_params[1].value + 0x0c);
361 result_table[3] = target_buffer_get_u32(target, mem_params[1].value + 0x10);
362
363 LOG_DEBUG("IAP command = %i (0x%8.8" PRIx32", 0x%8.8" PRIx32", 0x%8.8" PRIx32", 0x%8.8" PRIx32", 0x%8.8" PRIx32") completed with result = %8.8" PRIx32,
364 code, param_table[0], param_table[1], param_table[2], param_table[3], param_table[4], status_code);
365
366 destroy_mem_param(&mem_params[0]);
367 destroy_mem_param(&mem_params[1]);
368
369 destroy_reg_param(&reg_params[0]);
370 destroy_reg_param(&reg_params[1]);
371 destroy_reg_param(&reg_params[2]);
372 destroy_reg_param(&reg_params[3]);
373 destroy_reg_param(&reg_params[4]);
374
375 return status_code;
376 }
377
378 static int lpc2000_iap_blank_check(struct flash_bank *bank, int first, int last)
379 {
380 uint32_t param_table[5];
381 uint32_t result_table[4];
382 int status_code;
383 int i;
384
385 if ((first < 0) || (last >= bank->num_sectors))
386 return ERROR_FLASH_SECTOR_INVALID;
387
388 for (i = first; i <= last; i++)
389 {
390 /* check single sector */
391 param_table[0] = param_table[1] = i;
392 status_code = lpc2000_iap_call(bank, 53, param_table, result_table);
393
394 switch (status_code)
395 {
396 case ERROR_FLASH_OPERATION_FAILED:
397 return ERROR_FLASH_OPERATION_FAILED;
398 case LPC2000_CMD_SUCCESS:
399 bank->sectors[i].is_erased = 1;
400 break;
401 case LPC2000_SECTOR_NOT_BLANK:
402 bank->sectors[i].is_erased = 0;
403 break;
404 case LPC2000_INVALID_SECTOR:
405 bank->sectors[i].is_erased = 0;
406 break;
407 case LPC2000_BUSY:
408 return ERROR_FLASH_BUSY;
409 break;
410 default:
411 LOG_ERROR("BUG: unknown LPC2000 status code %i", status_code);
412 exit(-1);
413 }
414 }
415
416 return ERROR_OK;
417 }
418
419 /*
420 * flash bank lpc2000 <base> <size> 0 0 <target#> <lpc_variant> <cclk> [calc_checksum]
421 */
422 FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
423 {
424 struct lpc2000_flash_bank *lpc2000_info;
425
426 if (CMD_ARGC < 8)
427 {
428 LOG_WARNING("incomplete flash_bank lpc2000 configuration");
429 return ERROR_FLASH_BANK_INVALID;
430 }
431
432 lpc2000_info = malloc(sizeof(struct lpc2000_flash_bank));
433 bank->driver_priv = lpc2000_info;
434
435 if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0)
436 {
437 lpc2000_info->variant = lpc2000_v1;
438 lpc2000_info->cmd51_dst_boundary = 512;
439 lpc2000_info->cmd51_can_256b = 0;
440 lpc2000_info->cmd51_can_8192b = 1;
441 lpc2000_info->checksum_vector = 5;
442 }
443 else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0)
444 {
445 lpc2000_info->variant = lpc2000_v2;
446 lpc2000_info->cmd51_dst_boundary = 256;
447 lpc2000_info->cmd51_can_256b = 1;
448 lpc2000_info->cmd51_can_8192b = 0;
449 lpc2000_info->checksum_vector = 5;
450 }
451 else if (strcmp(CMD_ARGV[6], "lpc1700") == 0)
452 {
453 lpc2000_info->variant = lpc1700;
454 lpc2000_info->cmd51_dst_boundary = 256;
455 lpc2000_info->cmd51_can_256b = 1;
456 lpc2000_info->cmd51_can_8192b = 0;
457 lpc2000_info->checksum_vector = 7;
458 }
459 else
460 {
461 LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
462 free(lpc2000_info);
463 return ERROR_FLASH_BANK_INVALID;
464 }
465
466 lpc2000_info->iap_working_area = NULL;
467 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[7], lpc2000_info->cclk);
468 lpc2000_info->calc_checksum = 0;
469 lpc2000_build_sector_list(bank);
470
471 if (CMD_ARGC >= 9)
472 {
473 if (strcmp(CMD_ARGV[8], "calc_checksum") == 0)
474 lpc2000_info->calc_checksum = 1;
475 }
476
477 return ERROR_OK;
478 }
479
480 static int lpc2000_erase(struct flash_bank *bank, int first, int last)
481 {
482 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
483 uint32_t param_table[5];
484 uint32_t result_table[4];
485 int status_code;
486
487 if (bank->target->state != TARGET_HALTED)
488 {
489 LOG_ERROR("Target not halted");
490 return ERROR_TARGET_NOT_HALTED;
491 }
492
493 param_table[0] = first;
494 param_table[1] = last;
495 param_table[2] = lpc2000_info->cclk;
496
497 /* Prepare sectors */
498 status_code = lpc2000_iap_call(bank, 50, param_table, result_table);
499 switch (status_code)
500 {
501 case ERROR_FLASH_OPERATION_FAILED:
502 return ERROR_FLASH_OPERATION_FAILED;
503 case LPC2000_CMD_SUCCESS:
504 break;
505 case LPC2000_INVALID_SECTOR:
506 return ERROR_FLASH_SECTOR_INVALID;
507 break;
508 default:
509 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
510 return ERROR_FLASH_OPERATION_FAILED;
511 }
512
513 /* Erase sectors */
514 status_code = lpc2000_iap_call(bank, 52, param_table, result_table);
515 switch (status_code)
516 {
517 case ERROR_FLASH_OPERATION_FAILED:
518 return ERROR_FLASH_OPERATION_FAILED;
519 case LPC2000_CMD_SUCCESS:
520 break;
521 case LPC2000_INVALID_SECTOR:
522 return ERROR_FLASH_SECTOR_INVALID;
523 break;
524 default:
525 LOG_WARNING("lpc2000 erase sectors returned %i", status_code);
526 return ERROR_FLASH_OPERATION_FAILED;
527 }
528
529 return ERROR_OK;
530 }
531
532 static int lpc2000_protect(struct flash_bank *bank, int set, int first, int last)
533 {
534 /* can't protect/unprotect on the lpc2000 */
535 return ERROR_OK;
536 }
537
538 static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
539 {
540 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
541 struct target *target = bank->target;
542 uint32_t dst_min_alignment;
543 uint32_t bytes_remaining = count;
544 uint32_t bytes_written = 0;
545 int first_sector = 0;
546 int last_sector = 0;
547 uint32_t param_table[5];
548 uint32_t result_table[4];
549 int status_code;
550 int i;
551 struct working_area *download_area;
552 int retval = ERROR_OK;
553
554 if (bank->target->state != TARGET_HALTED)
555 {
556 LOG_ERROR("Target not halted");
557 return ERROR_TARGET_NOT_HALTED;
558 }
559
560 if (offset + count > bank->size)
561 return ERROR_FLASH_DST_OUT_OF_BANK;
562
563 dst_min_alignment = lpc2000_info->cmd51_dst_boundary;
564
565 if (offset % dst_min_alignment)
566 {
567 LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, offset, dst_min_alignment);
568 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
569 }
570
571 for (i = 0; i < bank->num_sectors; i++)
572 {
573 if (offset >= bank->sectors[i].offset)
574 first_sector = i;
575 if (offset + DIV_ROUND_UP(count, dst_min_alignment) * dst_min_alignment > bank->sectors[i].offset)
576 last_sector = i;
577 }
578
579 LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
580
581 /* check if exception vectors should be flashed */
582 if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum)
583 {
584 uint32_t checksum = 0;
585 int i;
586 for (i = 0; i < 8; i++)
587 {
588 LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32, i * 4, buf_get_u32(buffer + (i * 4), 0, 32));
589 if (i != lpc2000_info->checksum_vector)
590 checksum += buf_get_u32(buffer + (i * 4), 0, 32);
591 }
592 checksum = 0 - checksum;
593 LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
594
595 uint32_t original_value = buf_get_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32);
596 if (original_value != checksum)
597 {
598 LOG_WARNING("Verification will fail since checksum in image (0x%8.8" PRIx32 ") to be written to flash is different from calculated vector checksum (0x%8.8" PRIx32 ").",
599 original_value, checksum);
600 LOG_WARNING("To remove this warning modify build tools on developer PC to inject correct LPC vector checksum.");
601 }
602
603 buf_set_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32, checksum);
604 }
605
606 /* allocate a working area */
607 if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK)
608 {
609 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
610 return ERROR_FLASH_OPERATION_FAILED;
611 }
612
613 while (bytes_remaining > 0)
614 {
615 uint32_t thisrun_bytes;
616 if (bytes_remaining >= lpc2000_info->cmd51_max_buffer)
617 thisrun_bytes = lpc2000_info->cmd51_max_buffer;
618 else if (bytes_remaining >= 1024)
619 thisrun_bytes = 1024;
620 else if ((bytes_remaining >= 512) || (!lpc2000_info->cmd51_can_256b))
621 thisrun_bytes = 512;
622 else
623 thisrun_bytes = 256;
624
625 /* Prepare sectors */
626 param_table[0] = first_sector;
627 param_table[1] = last_sector;
628 status_code = lpc2000_iap_call(bank, 50, param_table, result_table);
629 switch (status_code)
630 {
631 case ERROR_FLASH_OPERATION_FAILED:
632 retval = ERROR_FLASH_OPERATION_FAILED;
633 break;
634 case LPC2000_CMD_SUCCESS:
635 break;
636 case LPC2000_INVALID_SECTOR:
637 retval = ERROR_FLASH_SECTOR_INVALID;
638 break;
639 default:
640 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
641 retval = ERROR_FLASH_OPERATION_FAILED;
642 break;
643 }
644
645 /* Exit if error occured */
646 if (retval != ERROR_OK)
647 break;
648
649 if (bytes_remaining >= thisrun_bytes)
650 {
651 if ((retval = target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written)) != ERROR_OK)
652 {
653 retval = ERROR_FLASH_OPERATION_FAILED;
654 break;
655 }
656 }
657 else
658 {
659 uint8_t *last_buffer = malloc(thisrun_bytes);
660 memcpy(last_buffer, buffer + bytes_written, bytes_remaining);
661 memset(last_buffer + bytes_remaining, 0xff, thisrun_bytes - bytes_remaining);
662 target_write_buffer(bank->target, download_area->address, thisrun_bytes, last_buffer);
663 free(last_buffer);
664 }
665
666 LOG_DEBUG("writing 0x%" PRIx32 " bytes to address 0x%" PRIx32 , thisrun_bytes, bank->base + offset + bytes_written);
667
668 /* Write data */
669 param_table[0] = bank->base + offset + bytes_written;
670 param_table[1] = download_area->address;
671 param_table[2] = thisrun_bytes;
672 param_table[3] = lpc2000_info->cclk;
673 status_code = lpc2000_iap_call(bank, 51, param_table, result_table);
674 switch (status_code)
675 {
676 case ERROR_FLASH_OPERATION_FAILED:
677 retval = ERROR_FLASH_OPERATION_FAILED;
678 break;
679 case LPC2000_CMD_SUCCESS:
680 break;
681 case LPC2000_INVALID_SECTOR:
682 retval = ERROR_FLASH_SECTOR_INVALID;
683 break;
684 default:
685 LOG_WARNING("lpc2000 returned %i", status_code);
686 retval = ERROR_FLASH_OPERATION_FAILED;
687 break;
688 }
689
690 /* Exit if error occured */
691 if (retval != ERROR_OK)
692 break;
693
694 if (bytes_remaining > thisrun_bytes)
695 bytes_remaining -= thisrun_bytes;
696 else
697 bytes_remaining = 0;
698 bytes_written += thisrun_bytes;
699 }
700
701 target_free_working_area(target, download_area);
702
703 return retval;
704 }
705
706 static int lpc2000_probe(struct flash_bank *bank)
707 {
708 /* we can't probe on an lpc2000
709 * if this is an lpc2xxx, it has the configured flash
710 */
711 return ERROR_OK;
712 }
713
714 static int lpc2000_erase_check(struct flash_bank *bank)
715 {
716 if (bank->target->state != TARGET_HALTED)
717 {
718 LOG_ERROR("Target not halted");
719 return ERROR_TARGET_NOT_HALTED;
720 }
721
722 return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
723 }
724
725 static int lpc2000_protect_check(struct flash_bank *bank)
726 {
727 /* sectors are always protected */
728 return ERROR_OK;
729 }
730
731 static int lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
732 {
733 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
734
735 snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIi32 "kHz" , lpc2000_info->variant, lpc2000_info->cclk);
736
737 return ERROR_OK;
738 }
739
740 COMMAND_HANDLER(lpc2000_handle_part_id_command)
741 {
742 uint32_t param_table[5];
743 uint32_t result_table[4];
744 int status_code;
745
746 if (CMD_ARGC < 1)
747 {
748 return ERROR_COMMAND_SYNTAX_ERROR;
749 }
750
751 struct flash_bank *bank;
752 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
753 if (ERROR_OK != retval)
754 return retval;
755
756 if (bank->target->state != TARGET_HALTED)
757 {
758 LOG_ERROR("Target not halted");
759 return ERROR_TARGET_NOT_HALTED;
760 }
761
762 if ((status_code = lpc2000_iap_call(bank, 54, param_table, result_table)) != 0x0)
763 {
764 if (status_code == ERROR_FLASH_OPERATION_FAILED)
765 {
766 command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface");
767 return ERROR_OK;
768 }
769 command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
770 }
771 else
772 {
773 command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32 , result_table[0]);
774 }
775
776 return ERROR_OK;
777 }
778
779 static const struct command_registration lpc2000_exec_command_handlers[] = {
780 {
781 .name = "part_id",
782 .handler = &lpc2000_handle_part_id_command,
783 .mode = COMMAND_EXEC,
784 .help = "print part id of lpc2000 flash bank <num>",
785 },
786 COMMAND_REGISTRATION_DONE
787 };
788 static const struct command_registration lpc2000_command_handlers[] = {
789 {
790 .name = "lpc2000",
791 .mode = COMMAND_ANY,
792 .help = "lpc2000 flash command group",
793 .chain = lpc2000_exec_command_handlers,
794 },
795 COMMAND_REGISTRATION_DONE
796 };
797
798 struct flash_driver lpc2000_flash = {
799 .name = "lpc2000",
800 .commands = lpc2000_command_handlers,
801 .flash_bank_command = &lpc2000_flash_bank_command,
802 .erase = &lpc2000_erase,
803 .protect = &lpc2000_protect,
804 .write = &lpc2000_write,
805 .probe = &lpc2000_probe,
806 .auto_probe = &lpc2000_probe,
807 .erase_check = &lpc2000_erase_check,
808 .protect_check = &lpc2000_protect_check,
809 .info = &lpc2000_info,
810 };
811
812
Zach's Unofficial Testing Repository