1 /***************************************************************************
2 * Copyright (C) 2008 by Kevin McGuire *
3 * Copyright (C) 2008 by Marcel Wijlaars *
4 * Copyright (C) 2009 by Michael Ashton *
6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation; either version 2 of the License, or *
9 * (at your option) any later version. *
11 * This program is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 * GNU General Public License for more details. *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program; if not, write to the *
18 * Free Software Foundation, Inc., *
19 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
20 ***************************************************************************/
28 #include "binarybuffer.h"
29 #include "time_support.h"
32 static int aduc702x_build_sector_list(struct flash_bank_s
*bank
);
33 static int aduc702x_check_flash_completion(target_t
* target
, unsigned int timeout_ms
);
34 static int aduc702x_set_write_enable(target_t
*target
, int enable
);
36 #define ADUC702x_FLASH 0xfffff800
37 #define ADUC702x_FLASH_FEESTA (0*4)
38 #define ADUC702x_FLASH_FEEMOD (1*4)
39 #define ADUC702x_FLASH_FEECON (2*4)
40 #define ADUC702x_FLASH_FEEDAT (3*4)
41 #define ADUC702x_FLASH_FEEADR (4*4)
42 #define ADUC702x_FLASH_FEESIGN (5*4)
43 #define ADUC702x_FLASH_FEEPRO (6*4)
44 #define ADUC702x_FLASH_FEEHIDE (7*4)
55 } ADUC702x_FLASH_MMIO
;
59 working_area_t
*write_algorithm
;
60 } aduc702x_flash_bank_t
;
62 /* flash bank aduc702x 0 0 0 0 <target#>
63 * The ADC7019-28 devices all have the same flash layout */
64 FLASH_BANK_COMMAND_HANDLER(aduc702x_flash_bank_command
)
66 aduc702x_flash_bank_t
*nbank
;
68 nbank
= malloc(sizeof(aduc702x_flash_bank_t
));
71 bank
->size
= 0xF800; // top 4k not accessible
72 bank
->driver_priv
= nbank
;
74 aduc702x_build_sector_list(bank
);
79 static int aduc702x_build_sector_list(struct flash_bank_s
*bank
)
81 //aduc7026_flash_bank_t *aduc7026_info = bank->driver_priv;
87 bank
->num_sectors
= bank
->size
/ 512;
88 bank
->sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
89 for (i
= 0; i
< bank
->num_sectors
; ++i
)
91 bank
->sectors
[i
].offset
= offset
;
92 bank
->sectors
[i
].size
= 512;
93 offset
+= bank
->sectors
[i
].size
;
94 bank
->sectors
[i
].is_erased
= -1;
95 bank
->sectors
[i
].is_protected
= 0;
101 static int aduc702x_protect_check(struct flash_bank_s
*bank
)
103 printf("aduc702x_protect_check not implemented yet.\n");
107 static int aduc702x_erase(struct flash_bank_s
*bank
, int first
, int last
)
113 target_t
*target
= bank
->target
;
115 aduc702x_set_write_enable(target
, 1);
118 if (((first
| last
) == 0) || ((first
== 0) && (last
>= bank
->num_sectors
))) {
119 LOG_DEBUG("performing mass erase.\n");
120 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEDAT
, 0x3cff);
121 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, 0xffc3);
122 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x06);
124 if (aduc702x_check_flash_completion(target
, 3500) != ERROR_OK
)
126 LOG_ERROR("mass erase failed\n");
127 aduc702x_set_write_enable(target
, 0);
128 return ERROR_FLASH_OPERATION_FAILED
;
131 LOG_DEBUG("mass erase successful.\n");
136 count
= last
- first
+ 1;
137 for (x
= 0; x
< count
; ++x
)
139 adr
= bank
->base
+ ((first
+ x
) * 512);
141 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, adr
);
142 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x05);
144 if (aduc702x_check_flash_completion(target
, 50) != ERROR_OK
)
146 LOG_ERROR("failed to erase sector at address 0x%08lX\n", adr
);
147 aduc702x_set_write_enable(target
, 0);
148 return ERROR_FLASH_SECTOR_NOT_ERASED
;
151 LOG_DEBUG("erased sector at address 0x%08lX\n", adr
);
155 aduc702x_set_write_enable(target
, 0);
160 static int aduc702x_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
162 printf("aduc702x_protect not implemented yet.\n");
163 return ERROR_FLASH_OPERATION_FAILED
;
166 /* If this fn returns ERROR_TARGET_RESOURCE_NOT_AVAILABLE, then the caller can fall
167 * back to another mechanism that does not require onboard RAM
169 * Caller should not check for other return values specifically
171 static int aduc702x_write_block(struct flash_bank_s
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
173 aduc702x_flash_bank_t
*aduc702x_info
= bank
->driver_priv
;
174 target_t
*target
= bank
->target
;
175 uint32_t buffer_size
= 7000;
176 working_area_t
*source
;
177 uint32_t address
= bank
->base
+ offset
;
178 reg_param_t reg_params
[6];
179 armv4_5_algorithm_t armv4_5_info
;
180 int retval
= ERROR_OK
;
182 if (((count
%2)!=0)||((offset
%2)!=0))
184 LOG_ERROR("write block must be multiple of two bytes in offset & length");
190 r0 - address of source data (absolute)
191 r1 - number of halfwords to be copied
192 r2 - start address in flash (offset from beginning of flash memory)
194 r4 - base address of flash controller (0xFFFFF800)
199 r6 - set to 2, used to write flash command
202 uint32_t aduc702x_flash_write_code
[] = {
204 0xe3a05008, // mov r5, #8 ; 0x8
205 0xe5845004, // str r5, [r4, #4]
206 0xe3a06002, // mov r6, #2 ; 0x2
208 0xe1c421b0, // strh r2, [r4, #16]
209 0xe0d050b2, // ldrh r5, [r0], #2
210 0xe1c450bc, // strh r5, [r4, #12]
211 0xe5c46008, // strb r6, [r4, #8]
213 0xe1d430b0, // ldrh r3, [r4]
214 0xe3130004, // tst r3, #4 ; 0x4
215 0x1afffffc, // bne 1001c <wait_complete>
216 0xe2822002, // add r2, r2, #2 ; 0x2
217 0xe2511001, // subs r1, r1, #1 ; 0x1
218 0x0a000001, // beq 1003c <done>
219 0xe3130001, // tst r3, #1 ; 0x1
220 0x1afffff3, // bne 1000c <next>
222 0xeafffffe // b 1003c <done>
225 /* flash write code */
226 if (target_alloc_working_area(target
, sizeof(aduc702x_flash_write_code
),
227 &aduc702x_info
->write_algorithm
) != ERROR_OK
)
229 LOG_WARNING("no working area available, can't do block memory writes");
230 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
233 retval
=target_write_buffer(target
, aduc702x_info
->write_algorithm
->address
,
234 sizeof(aduc702x_flash_write_code
), (uint8_t*)aduc702x_flash_write_code
);
235 if (retval
!=ERROR_OK
)
241 while (target_alloc_working_area(target
, buffer_size
, &source
) != ERROR_OK
)
244 if (buffer_size
<= 256)
246 /* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
247 if (aduc702x_info
->write_algorithm
)
248 target_free_working_area(target
, aduc702x_info
->write_algorithm
);
250 LOG_WARNING("no large enough working area available, can't do block memory writes");
251 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
255 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
256 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
257 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
259 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
260 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
261 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
);
262 init_reg_param(®_params
[3], "r3", 32, PARAM_IN
);
263 init_reg_param(®_params
[4], "r4", 32, PARAM_OUT
);
267 uint32_t thisrun_count
= (count
> buffer_size
) ? buffer_size
: count
;
269 retval
=target_write_buffer(target
, source
->address
, thisrun_count
, buffer
);
270 if (retval
!=ERROR_OK
)
275 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
276 buf_set_u32(reg_params
[1].value
, 0, 32, thisrun_count
/2);
277 buf_set_u32(reg_params
[2].value
, 0, 32, address
);
278 buf_set_u32(reg_params
[4].value
, 0, 32, 0xFFFFF800);
280 if ((retval
= target_run_algorithm(target
, 0, NULL
, 5,
281 reg_params
, aduc702x_info
->write_algorithm
->address
,
282 aduc702x_info
->write_algorithm
->address
+ sizeof(aduc702x_flash_write_code
) - 4,
283 10000, &armv4_5_info
)) != ERROR_OK
)
285 LOG_ERROR("error executing aduc702x flash write algorithm");
289 if ((buf_get_u32(reg_params
[3].value
, 0, 32) & 1) != 1)
291 /* FIX!!!! what does this mean??? replace w/sensible error message */
292 LOG_ERROR("aduc702x detected error writing flash");
297 buffer
+= thisrun_count
;
298 address
+= thisrun_count
;
299 count
-= thisrun_count
;
302 target_free_working_area(target
, source
);
303 target_free_working_area(target
, aduc702x_info
->write_algorithm
);
305 destroy_reg_param(®_params
[0]);
306 destroy_reg_param(®_params
[1]);
307 destroy_reg_param(®_params
[2]);
308 destroy_reg_param(®_params
[3]);
309 destroy_reg_param(®_params
[4]);
314 /* All-JTAG, single-access method. Very slow. Used only if there is no
315 * working area available. */
316 static int aduc702x_write_single(struct flash_bank_s
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
320 target_t
*target
= bank
->target
;
322 aduc702x_set_write_enable(target
, 1);
324 for (x
= 0; x
< count
; x
+= 2) {
326 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, offset
+ x
);
329 if ((x
+ 1) == count
)
332 target_read_u8(target
, offset
+ x
+ 1, &b
);
337 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEDAT
, buffer
[x
] | (b
<< 8));
339 // do single-write command
340 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x02);
342 if (aduc702x_check_flash_completion(target
, 1) != ERROR_OK
)
344 LOG_ERROR("single write failed for address 0x%08lX\n", (unsigned long)(offset
+ x
));
345 aduc702x_set_write_enable(target
, 0);
346 return ERROR_FLASH_OPERATION_FAILED
;
350 LOG_DEBUG("wrote %d bytes at address 0x%08lX\n", (int)count
, (unsigned long)(offset
+ x
));
352 aduc702x_set_write_enable(target
, 0);
357 int aduc702x_write(struct flash_bank_s
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
361 /* try using a block write */
362 if ((retval
= aduc702x_write_block(bank
, buffer
, offset
, count
)) != ERROR_OK
)
364 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
366 /* if block write failed (no sufficient working area),
367 * use normal (slow) JTAG method */
368 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
370 if ((retval
= aduc702x_write_single(bank
, buffer
, offset
, count
)) != ERROR_OK
)
372 LOG_ERROR("slow write failed");
373 return ERROR_FLASH_OPERATION_FAILED
;
381 static int aduc702x_probe(struct flash_bank_s
*bank
)
386 static int aduc702x_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
)
388 snprintf(buf
, buf_size
, "aduc702x flash driver info");
393 * enable = 1 enables writes & erases, 0 disables them */
394 static int aduc702x_set_write_enable(target_t
*target
, int enable
)
396 // don't bother to preserve int enable bit here
397 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEMOD
, enable
? 8 : 0);
402 /* wait up to timeout_ms for controller to not be busy,
403 * then check whether the command passed or failed.
405 * this function sleeps 1ms between checks (after the first one),
406 * so in some cases may slow things down without a usleep after the first read */
407 static int aduc702x_check_flash_completion(target_t
* target
, unsigned int timeout_ms
)
411 long long endtime
= timeval_ms() + timeout_ms
;
413 target_read_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEESTA
, &v
);
414 if ((v
& 4) == 0) break;
416 if (timeval_ms() >= endtime
) break;
419 if (v
& 2) return ERROR_FAIL
;
420 // if a command is ignored, both the success and fail bits may be 0
421 else if ((v
& 3) == 0) return ERROR_FAIL
;
422 else return ERROR_OK
;
425 struct flash_driver aduc702x_flash
= {
427 .flash_bank_command
= &aduc702x_flash_bank_command
,
428 .erase
= &aduc702x_erase
,
429 .protect
= &aduc702x_protect
,
430 .write
= &aduc702x_write
,
431 .probe
= &aduc702x_probe
,
432 .auto_probe
= &aduc702x_probe
,
433 .erase_check
= &default_flash_blank_check
,
434 .protect_check
= &aduc702x_protect_check
,
435 .info
= &aduc702x_info
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)