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 ***************************************************************************/
26 #include "replacements.h"
27 #include "time_support.h"
32 #include "algorithm.h"
33 #include "binarybuffer.h"
39 int aduc702x_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
);
40 int aduc702x_register_commands(struct command_context_s
*cmd_ctx
);
41 int aduc702x_erase(struct flash_bank_s
*bank
, int first
, int last
);
42 int aduc702x_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
);
43 int aduc702x_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
);
44 int aduc702x_write_single(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
);
45 int aduc702x_write_block(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
);
46 int aduc702x_probe(struct flash_bank_s
*bank
);
47 int aduc702x_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
);
48 int aduc702x_protect_check(struct flash_bank_s
*bank
);
49 int aduc702x_build_sector_list(struct flash_bank_s
*bank
);
50 int aduc702x_check_flash_completion(target_t
* target
, unsigned int timeout_ms
);
51 int aduc702x_set_write_enable(target_t
*target
, int enable
);
53 #define ADUC702x_FLASH 0xfffff800
54 #define ADUC702x_FLASH_FEESTA (0*4)
55 #define ADUC702x_FLASH_FEEMOD (1*4)
56 #define ADUC702x_FLASH_FEECON (2*4)
57 #define ADUC702x_FLASH_FEEDAT (3*4)
58 #define ADUC702x_FLASH_FEEADR (4*4)
59 #define ADUC702x_FLASH_FEESIGN (5*4)
60 #define ADUC702x_FLASH_FEEPRO (6*4)
61 #define ADUC702x_FLASH_FEEHIDE (7*4)
72 } ADUC702x_FLASH_MMIO
;
76 working_area_t
*write_algorithm
;
77 } aduc702x_flash_bank_t
;
79 flash_driver_t aduc702x_flash
=
82 .register_commands
= aduc702x_register_commands
,
83 .flash_bank_command
= aduc702x_flash_bank_command
,
84 .erase
= aduc702x_erase
,
85 .protect
= aduc702x_protect
,
86 .write
= aduc702x_write
,
87 .probe
= aduc702x_probe
,
88 .auto_probe
= aduc702x_probe
,
89 .erase_check
= default_flash_blank_check
,
90 .protect_check
= aduc702x_protect_check
,
94 int aduc702x_register_commands(struct command_context_s
*cmd_ctx
)
99 /* flash bank aduc702x 0 0 0 0 <target#>
100 * The ADC7019-28 devices all have the same flash layout */
101 int aduc702x_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
)
103 aduc702x_flash_bank_t
*nbank
;
105 nbank
= malloc(sizeof(aduc702x_flash_bank_t
));
107 bank
->base
= 0x80000;
108 bank
->size
= 0xF800; // top 4k not accessible
109 bank
->driver_priv
= nbank
;
111 aduc702x_build_sector_list(bank
);
116 int aduc702x_build_sector_list(struct flash_bank_s
*bank
)
118 //aduc7026_flash_bank_t *aduc7026_info = bank->driver_priv;
123 // sector size is 512
124 bank
->num_sectors
= bank
->size
/ 512;
125 bank
->sectors
= malloc(sizeof(flash_sector_t
) * bank
->num_sectors
);
126 for (i
= 0; i
< bank
->num_sectors
; ++i
)
128 bank
->sectors
[i
].offset
= offset
;
129 bank
->sectors
[i
].size
= 512;
130 offset
+= bank
->sectors
[i
].size
;
131 bank
->sectors
[i
].is_erased
= -1;
132 bank
->sectors
[i
].is_protected
= 0;
138 int aduc702x_protect_check(struct flash_bank_s
*bank
)
140 printf("aduc702x_protect_check not implemented yet.\n");
144 int aduc702x_erase(struct flash_bank_s
*bank
, int first
, int last
)
150 target_t
*target
= bank
->target
;
152 aduc702x_set_write_enable(target
, 1);
155 if (((first
| last
) == 0) || ((first
== 0) && (last
>= bank
->num_sectors
))) {
156 LOG_DEBUG("performing mass erase.\n");
157 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEDAT
, 0x3cff);
158 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, 0xffc3);
159 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x06);
161 if (aduc702x_check_flash_completion(target
, 3500) != ERROR_OK
)
163 LOG_ERROR("mass erase failed\n");
164 aduc702x_set_write_enable(target
, 0);
165 return ERROR_FLASH_OPERATION_FAILED
;
168 LOG_DEBUG("mass erase successful.\n");
173 count
= last
- first
+ 1;
174 for (x
= 0; x
< count
; ++x
)
176 adr
= bank
->base
+ ((first
+ x
) * 512);
178 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, adr
);
179 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x05);
181 if (aduc702x_check_flash_completion(target
, 50) != ERROR_OK
)
183 LOG_ERROR("failed to erase sector at address 0x%08lX\n", adr
);
184 aduc702x_set_write_enable(target
, 0);
185 return ERROR_FLASH_SECTOR_NOT_ERASED
;
188 LOG_DEBUG("erased sector at address 0x%08lX\n", adr
);
192 aduc702x_set_write_enable(target
, 0);
197 int aduc702x_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
199 printf("aduc702x_protect not implemented yet.\n");
200 return ERROR_FLASH_OPERATION_FAILED
;
203 int aduc702x_write_block(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
205 aduc702x_flash_bank_t
*aduc702x_info
= bank
->driver_priv
;
206 target_t
*target
= bank
->target
;
207 u32 buffer_size
= 7000;
208 working_area_t
*source
;
209 u32 address
= bank
->base
+ offset
;
210 reg_param_t reg_params
[6];
211 armv4_5_algorithm_t armv4_5_info
;
212 int retval
= ERROR_OK
;
216 r0 - address of source data (absolute)
217 r1 - number of halfwords to be copied
218 r2 - start address in flash (offset from beginning of flash memory)
220 r4 - base address of flash controller (0xFFFFF800)
225 r6 - set to 2, used to write flash command
228 u32 aduc702x_flash_write_code
[] = {
230 0xe3a05008, // mov r5, #8 ; 0x8
231 0xe5845004, // str r5, [r4, #4]
232 0xe3a06002, // mov r6, #2 ; 0x2
234 0xe1c421b0, // strh r2, [r4, #16]
235 0xe0d050b2, // ldrh r5, [r0], #2
236 0xe1c450bc, // strh r5, [r4, #12]
237 0xe5c46008, // strb r6, [r4, #8]
239 0xe1d430b0, // ldrh r3, [r4]
240 0xe3130004, // tst r3, #4 ; 0x4
241 0x1afffffc, // bne 1001c <wait_complete>
242 0xe2822002, // add r2, r2, #2 ; 0x2
243 0xe2511001, // subs r1, r1, #1 ; 0x1
244 0x0a000001, // beq 1003c <done>
245 0xe3130001, // tst r3, #1 ; 0x1
246 0x1afffff3, // bne 1000c <next>
248 0xeafffffe // b 1003c <done>
251 /* flash write code */
252 if (target_alloc_working_area(target
, sizeof(aduc702x_flash_write_code
),
253 &aduc702x_info
->write_algorithm
) != ERROR_OK
)
255 LOG_WARNING("no working area available, can't do block memory writes");
256 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
259 target_write_buffer(target
, aduc702x_info
->write_algorithm
->address
,
260 sizeof(aduc702x_flash_write_code
), (u8
*)aduc702x_flash_write_code
);
263 while (target_alloc_working_area(target
, buffer_size
, &source
) != ERROR_OK
)
266 if (buffer_size
<= 256)
268 /* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
269 if (aduc702x_info
->write_algorithm
)
270 target_free_working_area(target
, aduc702x_info
->write_algorithm
);
272 LOG_WARNING("no large enough working area available, can't do block memory writes");
273 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
277 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
278 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
279 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
281 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
282 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
283 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
);
284 init_reg_param(®_params
[3], "r3", 32, PARAM_IN
);
285 init_reg_param(®_params
[4], "r4", 32, PARAM_OUT
);
289 u32 thisrun_count
= (count
> (buffer_size
/ 2)) ? (buffer_size
/ 2) : count
;
291 target_write_buffer(target
, source
->address
, thisrun_count
* 2, buffer
);
293 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
294 buf_set_u32(reg_params
[1].value
, 0, 32, thisrun_count
);
295 buf_set_u32(reg_params
[2].value
, 0, 32, address
);
296 buf_set_u32(reg_params
[4].value
, 0, 32, 0xFFFFF800);
298 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 5,
299 reg_params
, aduc702x_info
->write_algorithm
->address
,
300 aduc702x_info
->write_algorithm
->address
+ sizeof(aduc702x_flash_write_code
) - 4,
301 10000, &armv4_5_info
)) != ERROR_OK
)
303 LOG_ERROR("error executing aduc702x flash write algorithm");
304 retval
= ERROR_FLASH_OPERATION_FAILED
;
308 if ((buf_get_u32(reg_params
[3].value
, 0, 32) & 1) != 1) {
309 retval
= ERROR_FLASH_OPERATION_FAILED
;
313 buffer
+= thisrun_count
* 2;
314 address
+= thisrun_count
* 2;
315 count
-= thisrun_count
;
318 target_free_working_area(target
, source
);
319 target_free_working_area(target
, aduc702x_info
->write_algorithm
);
321 destroy_reg_param(®_params
[0]);
322 destroy_reg_param(®_params
[1]);
323 destroy_reg_param(®_params
[2]);
324 destroy_reg_param(®_params
[3]);
325 destroy_reg_param(®_params
[4]);
330 /* All-JTAG, single-access method. Very slow. Used only if there is no
331 * working area available. */
332 int aduc702x_write_single(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
336 target_t
*target
= bank
->target
;
338 aduc702x_set_write_enable(target
, 1);
340 for (x
= 0; x
< count
; x
+= 2) {
342 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEADR
, offset
+ x
);
345 if ((x
+ 1) == count
)
348 target_read_u8(target
, offset
+ x
+ 1, &b
);
353 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEDAT
, buffer
[x
] | (b
<< 8));
355 // do single-write command
356 target_write_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEECON
, 0x02);
358 if (aduc702x_check_flash_completion(target
, 1) != ERROR_OK
)
360 LOG_ERROR("single write failed for address 0x%08lX\n", (unsigned long)(offset
+ x
));
361 aduc702x_set_write_enable(target
, 0);
362 return ERROR_FLASH_OPERATION_FAILED
;
366 LOG_DEBUG("wrote %d bytes at address 0x%08lX\n", (int)count
, (unsigned long)(offset
+ x
));
368 aduc702x_set_write_enable(target
, 0);
373 int aduc702x_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
377 /* try using a block write */
378 if ((retval
= aduc702x_write_block(bank
, buffer
, offset
, count
)) != ERROR_OK
)
380 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
382 /* if block write failed (no sufficient working area),
383 * use normal (slow) JTAG method */
384 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
386 if ((retval
= aduc702x_write_single(bank
, buffer
, offset
, count
)) != ERROR_OK
)
388 LOG_ERROR("slow write failed");
389 return ERROR_FLASH_OPERATION_FAILED
;
392 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
394 LOG_ERROR("flash block writing failed");
395 return ERROR_FLASH_OPERATION_FAILED
;
402 int aduc702x_probe(struct flash_bank_s
*bank
)
407 int aduc702x_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
)
409 snprintf(buf
, buf_size
, "aduc702x flash driver info" );
414 * enable = 1 enables writes & erases, 0 disables them */
415 int aduc702x_set_write_enable(target_t
*target
, int enable
)
417 // don't bother to preserve int enable bit here
418 target_write_u16(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEEMOD
, enable
? 8 : 0);
423 /* wait up to timeout_ms for controller to not be busy,
424 * then check whether the command passed or failed.
426 * this function sleeps 1ms between checks (after the first one),
427 * so in some cases may slow things down without a usleep after the first read */
428 int aduc702x_check_flash_completion(target_t
* target
, unsigned int timeout_ms
)
432 long long endtime
= timeval_ms() + timeout_ms
;
434 target_read_u8(target
, ADUC702x_FLASH
+ ADUC702x_FLASH_FEESTA
, &v
);
435 if ((v
& 4) == 0) break;
437 if (timeval_ms() >= endtime
) break;
440 if (v
& 2) return ERROR_FAIL
;
441 // if a command is ignored, both the success and fail bits may be 0
442 else if ((v
& 3) == 0) return ERROR_FAIL
;
443 else return ERROR_OK
;