1 /***************************************************************************
2 * Copyright (C) 2008 by Spencer Oliver *
3 * spen@spen-soft.co.uk *
5 * Copyright (C) 2008 by David T.L. Wong *
7 * Copyright (C) 2009 by David N. Claffey <dnclaffey@gmail.com> *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
14 * This program is distributed in the hope that it will be useful, *
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17 * GNU General Public License for more details. *
19 * You should have received a copy of the GNU General Public License *
20 * along with this program; if not, write to the *
21 * Free Software Foundation, Inc., *
22 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
23 ***************************************************************************/
26 This version has optimized assembly routines for 32 bit operations:
29 - write array of words
31 One thing to be aware of is that the MIPS32 cpu will execute the
32 instruction after a branch instruction (one delay slot).
40 The LW $1, ($2 +100) instruction is also executed. If this is
41 not wanted a NOP can be inserted:
48 or the code can be changed to:
54 The original code contained NOPs. I have removed these and moved
57 I also moved the PRACC_STACK to 0xFF204000. This allows
58 the use of 16 bits offsets to get pointers to the input
59 and output area relative to the stack. Note that the stack
60 isn't really a stack (the stack pointer is not 'moving')
61 but a FIFO simulated in software.
63 These changes result in a 35% speed increase when programming an
66 More improvement could be gained if the registers do no need
67 to be preserved but in that case the routines should be aware
68 OpenOCD is used as a flash programmer or as a debug tool.
78 #include "mips32_pracc.h"
80 struct mips32_pracc_context
82 uint32_t *local_iparam;
84 uint32_t *local_oparam;
90 struct mips_ejtag *ejtag_info;
93 static int wait_for_pracc_rw(struct mips_ejtag *ejtag_info, uint32_t *ctrl)
99 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_CONTROL, NULL);
100 ejtag_ctrl = ejtag_info->ejtag_ctrl;
101 mips_ejtag_drscan_32(ejtag_info, &ejtag_ctrl);
102 if (ejtag_ctrl & EJTAG_CTRL_PRACC)
104 LOG_DEBUG("DEBUGMODULE: No memory access in progress!\n");
105 return ERROR_JTAG_DEVICE_ERROR;
112 static int mips32_pracc_exec_read(struct mips32_pracc_context *ctx, uint32_t address)
114 struct mips_ejtag *ejtag_info = ctx->ejtag_info;
116 uint32_t ejtag_ctrl, data;
118 if ((address >= MIPS32_PRACC_PARAM_IN)
119 && (address <= MIPS32_PRACC_PARAM_IN + ctx->num_iparam * 4))
121 offset = (address - MIPS32_PRACC_PARAM_IN) / 4;
122 data = ctx->local_iparam[offset];
124 else if ((address >= MIPS32_PRACC_PARAM_OUT)
125 && (address <= MIPS32_PRACC_PARAM_OUT + ctx->num_oparam * 4))
127 offset = (address - MIPS32_PRACC_PARAM_OUT) / 4;
128 data = ctx->local_oparam[offset];
130 else if ((address >= MIPS32_PRACC_TEXT)
131 && (address <= MIPS32_PRACC_TEXT + ctx->code_len * 4))
133 offset = (address - MIPS32_PRACC_TEXT) / 4;
134 data = ctx->code[offset];
136 else if (address == MIPS32_PRACC_STACK)
138 /* save to our debug stack */
139 data = ctx->stack[--ctx->stack_offset];
143 /* TODO: send JMP 0xFF200000 instruction. Hopefully processor jump back
144 * to start of debug vector */
147 LOG_ERROR("Error reading unexpected address 0x%8.8" PRIx32 "", address);
148 return ERROR_JTAG_DEVICE_ERROR;
151 /* Send the data out */
152 mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_DATA, NULL);
153 mips_ejtag_drscan_32(ctx->ejtag_info, &data);
155 /* Clear the access pending bit (let the processor eat!) */
156 ejtag_ctrl = ejtag_info->ejtag_ctrl & ~EJTAG_CTRL_PRACC;
157 mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_CONTROL, NULL);
158 mips_ejtag_drscan_32(ctx->ejtag_info, &ejtag_ctrl);
161 jtag_execute_queue();
166 static int mips32_pracc_exec_write(struct mips32_pracc_context *ctx, uint32_t address)
168 uint32_t ejtag_ctrl,data;
170 struct mips_ejtag *ejtag_info = ctx->ejtag_info;
172 mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_DATA, NULL);
173 mips_ejtag_drscan_32(ctx->ejtag_info, &data);
175 /* Clear access pending bit */
176 ejtag_ctrl = ejtag_info->ejtag_ctrl & ~EJTAG_CTRL_PRACC;
177 mips_ejtag_set_instr(ctx->ejtag_info, EJTAG_INST_CONTROL, NULL);
178 mips_ejtag_drscan_32(ctx->ejtag_info, &ejtag_ctrl);
181 jtag_execute_queue();
183 if ((address >= MIPS32_PRACC_PARAM_IN)
184 && (address <= MIPS32_PRACC_PARAM_IN + ctx->num_iparam * 4))
186 offset = (address - MIPS32_PRACC_PARAM_IN) / 4;
187 ctx->local_iparam[offset] = data;
189 else if ((address >= MIPS32_PRACC_PARAM_OUT)
190 && (address <= MIPS32_PRACC_PARAM_OUT + ctx->num_oparam * 4))
192 offset = (address - MIPS32_PRACC_PARAM_OUT) / 4;
193 ctx->local_oparam[offset] = data;
195 else if (address == MIPS32_PRACC_STACK)
197 /* save data onto our stack */
198 ctx->stack[ctx->stack_offset++] = data;
202 LOG_ERROR("Error writing unexpected address 0x%8.8" PRIx32 "", address);
203 return ERROR_JTAG_DEVICE_ERROR;
209 int mips32_pracc_exec(struct mips_ejtag *ejtag_info, int code_len, const uint32_t *code, int num_param_in, uint32_t *param_in, int num_param_out, uint32_t *param_out, int cycle)
212 uint32_t address, data;
213 struct mips32_pracc_context ctx;
217 ctx.local_iparam = param_in;
218 ctx.local_oparam = param_out;
219 ctx.num_iparam = num_param_in;
220 ctx.num_oparam = num_param_out;
222 ctx.code_len = code_len;
223 ctx.ejtag_info = ejtag_info;
224 ctx.stack_offset = 0;
228 if ((retval = wait_for_pracc_rw(ejtag_info, &ejtag_ctrl)) != ERROR_OK)
232 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_ADDRESS, NULL);
233 mips_ejtag_drscan_32(ejtag_info, &address);
235 /* Check for read or write */
236 if (ejtag_ctrl & EJTAG_CTRL_PRNW)
238 if ((retval = mips32_pracc_exec_write(&ctx, address)) != ERROR_OK)
243 /* Check to see if its reading at the debug vector. The first pass through
244 * the module is always read at the vector, so the first one we allow. When
245 * the second read from the vector occurs we are done and just exit. */
246 if ((address == MIPS32_PRACC_TEXT) && (pass++))
251 if ((retval = mips32_pracc_exec_read(&ctx, address)) != ERROR_OK)
259 /* stack sanity check */
260 if (ctx.stack_offset != 0)
262 LOG_DEBUG("Pracc Stack not zero");
268 int mips32_pracc_read_mem(struct mips_ejtag *ejtag_info, uint32_t addr, int size, int count, void *buf)
273 return mips32_pracc_read_mem8(ejtag_info, addr, count, (uint8_t*)buf);
275 return mips32_pracc_read_mem16(ejtag_info, addr, count, (uint16_t*)buf);
278 return mips32_pracc_read_u32(ejtag_info, addr, (uint32_t*)buf);
280 return mips32_pracc_read_mem32(ejtag_info, addr, count, (uint32_t*)buf);
286 int mips32_pracc_read_mem32(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint32_t *buf)
288 static const uint32_t code[] = {
290 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
291 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
292 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
293 MIPS32_SW(8,0,15), /* sw $8,($15) */
294 MIPS32_SW(9,0,15), /* sw $9,($15) */
295 MIPS32_SW(10,0,15), /* sw $10,($15) */
296 MIPS32_SW(11,0,15), /* sw $11,($15) */
298 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
299 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
300 MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
301 MIPS32_LW(10,4,8), /* $10 = mem[$8 + 4]; read count */
302 MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
303 MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
305 MIPS32_BEQ(0,10,8), /* beq 0, $10, end */
308 MIPS32_LW(8,0,9), /* lw $8,0($9), Load $8 with the word @mem[$9] */
309 MIPS32_SW(8,0,11), /* sw $8,0($11) */
311 MIPS32_ADDI(10,10,NEG16(1)), /* $10-- */
312 MIPS32_ADDI(9,9,4), /* $1 += 4 */
313 MIPS32_ADDI(11,11,4), /* $11 += 4 */
315 MIPS32_B(NEG16(8)), /* b loop */
318 MIPS32_LW(11,0,15), /* lw $11,($15) */
319 MIPS32_LW(10,0,15), /* lw $10,($15) */
320 MIPS32_LW(9,0,15), /* lw $9,($15) */
321 MIPS32_LW(8,0,15), /* lw $8,($15) */
322 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
323 MIPS32_B(NEG16(28)), /* b start */
327 int retval = ERROR_OK;
330 uint32_t param_in[2];
341 param_in[1] = blocksize;
343 if ((retval = mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code,
344 ARRAY_SIZE(param_in), param_in, blocksize, &buf[bytesread], 1)) != ERROR_OK)
351 bytesread += blocksize;
357 int mips32_pracc_read_u32(struct mips_ejtag *ejtag_info, uint32_t addr, uint32_t *buf)
359 static const uint32_t code[] = {
361 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
362 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
363 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
364 MIPS32_SW(8,0,15), /* sw $8,($15) */
366 MIPS32_LW(8,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN),15), /* load R8 @ param_in[0] = address */
368 MIPS32_LW(8,0,8), /* lw $8,0($8), Load $8 with the word @mem[$8] */
369 MIPS32_SW(8,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_OUT),15), /* store R8 @ param_out[0] */
371 MIPS32_LW(8,0,15), /* lw $8,($15) */
372 MIPS32_B(NEG16(9)), /* b start */
373 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
376 int retval = ERROR_OK;
377 uint32_t param_in[1];
381 if ((retval = mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code,
382 ARRAY_SIZE(param_in), param_in, 1, buf, 1)) != ERROR_OK)
390 int mips32_pracc_read_mem16(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint16_t *buf)
392 static const uint32_t code[] = {
394 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
395 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
396 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
397 MIPS32_SW(8,0,15), /* sw $8,($15) */
398 MIPS32_SW(9,0,15), /* sw $9,($15) */
399 MIPS32_SW(10,0,15), /* sw $10,($15) */
400 MIPS32_SW(11,0,15), /* sw $11,($15) */
402 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
403 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
404 MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
405 MIPS32_LW(10,4,8), /* $10 = mem[$8 + 4]; read count */
406 MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
407 MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
409 MIPS32_BEQ(0,10,8), /* beq 0, $10, end */
412 MIPS32_LHU(8,0,9), /* lw $8,0($9), Load $8 with the halfword @mem[$9] */
413 MIPS32_SW(8,0,11), /* sw $8,0($11) */
415 MIPS32_ADDI(10,10,NEG16(1)), /* $10-- */
416 MIPS32_ADDI(9,9,2), /* $9 += 2 */
417 MIPS32_ADDI(11,11,4), /* $11 += 4 */
418 MIPS32_B(NEG16(8)), /* b loop */
421 MIPS32_LW(11,0,15), /* lw $11,($15) */
422 MIPS32_LW(10,0,15), /* lw $10,($15) */
423 MIPS32_LW(9,0,15), /* lw $9,($15) */
424 MIPS32_LW(8,0,15), /* lw $8,($15) */
425 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
426 MIPS32_B(NEG16(28)), /* b start */
430 /* TODO remove array */
431 uint32_t *param_out = malloc(count * sizeof(uint32_t));
437 uint32_t param_in[2];
448 param_in[1] = blocksize;
450 mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
451 ARRAY_SIZE(param_in), param_in, count, param_out, 1);
453 // count -= blocksize;
454 // addr += blocksize;
455 // bytesread += blocksize;
458 for (i = 0; i < count; i++)
460 buf[i] = param_out[i];
468 int mips32_pracc_read_mem8(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint8_t *buf)
470 static const uint32_t code[] = {
472 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
473 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
474 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
475 MIPS32_SW(8,0,15), /* sw $8,($15) */
476 MIPS32_SW(9,0,15), /* sw $9,($15) */
477 MIPS32_SW(10,0,15), /* sw $10,($15) */
478 MIPS32_SW(11,0,15), /* sw $11,($15) */
480 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
481 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
482 MIPS32_LW(9,0,8), /* $9 = mem[$8]; read addr */
483 MIPS32_LW(10,4,8), /* $10 = mem[$8 + 4]; read count */
484 MIPS32_LUI(11,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $11 = MIPS32_PRACC_PARAM_OUT */
485 MIPS32_ORI(11,11,LOWER16(MIPS32_PRACC_PARAM_OUT)),
487 MIPS32_BEQ(0,10,8), /* beq 0, $10, end */
490 MIPS32_LBU(8,0,9), /* lw $8,0($9), Load t4 with the byte @mem[t1] */
491 MIPS32_SW(8,0,11), /* sw $8,0($11) */
493 MIPS32_ADDI(10,10,NEG16(1)), /* $10-- */
494 MIPS32_ADDI(9,9,1), /* $9 += 1 */
495 MIPS32_ADDI(11,11,4), /* $11 += 4 */
496 MIPS32_B(NEG16(8)), /* b loop */
499 MIPS32_LW(11,0,15), /* lw $11,($15) */
500 MIPS32_LW(10,0,15), /* lw $10,($15) */
501 MIPS32_LW(9,0,15), /* lw $9,($15) */
502 MIPS32_LW(8,0,15), /* lw $8,($15) */
503 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
504 MIPS32_B(NEG16(28)), /* b start */
508 /* TODO remove array */
509 uint32_t *param_out = malloc(count * sizeof(uint32_t));
515 uint32_t param_in[2];
526 param_in[1] = blocksize;
528 mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
529 ARRAY_SIZE(param_in), param_in, count, param_out, 1);
531 // count -= blocksize;
532 // addr += blocksize;
533 // bytesread += blocksize;
536 for (i = 0; i < count; i++)
538 buf[i] = param_out[i];
546 int mips32_pracc_write_mem(struct mips_ejtag *ejtag_info, uint32_t addr, int size, int count, void *buf)
551 return mips32_pracc_write_mem8(ejtag_info, addr, count, (uint8_t*)buf);
553 return mips32_pracc_write_mem16(ejtag_info, addr, count,(uint16_t*)buf);
556 return mips32_pracc_write_u32(ejtag_info, addr, (uint32_t*)buf);
558 return mips32_pracc_write_mem32(ejtag_info, addr, count, (uint32_t*)buf);
564 int mips32_pracc_write_mem32(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint32_t *buf)
566 static const uint32_t code[] = {
568 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
569 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
570 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
571 MIPS32_SW(8,0,15), /* sw $8,($15) */
572 MIPS32_SW(9,0,15), /* sw $9,($15) */
573 MIPS32_SW(10,0,15), /* sw $10,($15) */
574 MIPS32_SW(11,0,15), /* sw $11,($15) */
576 MIPS32_ADDI(8,15,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN)), /* $8= MIPS32_PRACC_PARAM_IN */
577 MIPS32_LW(9,0,8), /* Load write addr to $9 */
578 MIPS32_LW(10,4,8), /* Load write count to $10 */
579 MIPS32_ADDI(8,8,8), /* $8 += 8 beginning of data */
582 MIPS32_LW(11,0,8), /* lw $11,0($8), Load $11 with the word @mem[$8] */
583 MIPS32_SW(11,0,9), /* sw $11,0($9) */
585 MIPS32_ADDI(9,9,4), /* $9 += 4 */
586 MIPS32_BNE(10,9,NEG16(4)), /* bne $10, $9, loop */
587 MIPS32_ADDI(8,8,4), /* $8 += 4 */
590 MIPS32_LW(11,0,15), /* lw $11,($15) */
591 MIPS32_LW(10,0,15), /* lw $10,($15) */
592 MIPS32_LW(9,0,15), /* lw $9,($15) */
593 MIPS32_LW(8,0,15), /* lw $8,($15) */
594 MIPS32_B(NEG16(21)), /* b start */
595 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
598 /* TODO remove array */
599 uint32_t *param_in = malloc((count + 2) * sizeof(uint32_t));
601 param_in[1] = addr + (count * sizeof(uint32_t)); /* last address */
603 memcpy(¶m_in[2], buf, count * sizeof(uint32_t));
605 mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
606 count + 2, param_in, 0, NULL, 1);
613 int mips32_pracc_write_u32(struct mips_ejtag *ejtag_info, uint32_t addr, uint32_t *buf)
615 static const uint32_t code[] = {
617 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
618 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
619 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
620 MIPS32_SW(8,0,15), /* sw $8,($15) */
621 MIPS32_SW(9,0,15), /* sw $9,($15) */
623 MIPS32_LW(8,NEG16((MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN)-4), 15), /* load R8 @ param_in[1] = data */
624 MIPS32_LW(9,NEG16(MIPS32_PRACC_STACK-MIPS32_PRACC_PARAM_IN), 15), /* load R9 @ param_in[0] = address */
626 MIPS32_SW(8,0,9), /* sw $8,0($9) */
628 MIPS32_LW(9,0,15), /* lw $9,($15) */
629 MIPS32_LW(8,0,15), /* lw $8,($15) */
630 MIPS32_B(NEG16(11)), /* b start */
631 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
634 /* TODO remove array */
635 uint32_t param_in[1 + 1];
639 mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
640 ARRAY_SIZE(param_in), param_in, 0, NULL, 1);
645 int mips32_pracc_write_mem16(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint16_t *buf)
647 static const uint32_t code[] = {
649 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
650 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
651 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
652 MIPS32_SW(8,0,15), /* sw $8,($15) */
653 MIPS32_SW(9,0,15), /* sw $9,($15) */
654 MIPS32_SW(10,0,15), /* sw $10,($15) */
655 MIPS32_SW(11,0,15), /* sw $11,($15) */
657 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
658 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
659 MIPS32_LW(9,0,8), /* Load write addr to $9 */
660 MIPS32_LW(10,4,8), /* Load write count to $10 */
661 MIPS32_ADDI(8,8,8), /* $8 += 8 */
663 MIPS32_BEQ(0,10,8), /* beq $0, $10, end */
666 MIPS32_LW(11,0,8), /* lw $11,0($8), Load $11 with the word @mem[$8] */
667 MIPS32_SH(11,0,9), /* sh $11,0($9) */
669 MIPS32_ADDI(10,10,NEG16(1)), /* $10-- */
670 MIPS32_ADDI(9,9,2), /* $9 += 2 */
671 MIPS32_ADDI(8,8,4), /* $8 += 4 */
673 MIPS32_B(NEG16(8)), /* b loop */
676 MIPS32_LW(11,0,15), /* lw $11,($15) */
677 MIPS32_LW(10,0,15), /* lw $10,($15) */
678 MIPS32_LW(9,0,15), /* lw $9,($15) */
679 MIPS32_LW(8,0,15), /* lw $8,($15) */
680 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
681 MIPS32_B(NEG16(27)), /* b start */
685 /* TODO remove array */
686 uint32_t *param_in = malloc((count + 2) * sizeof(uint32_t));
691 for (i = 0; i < count; i++)
693 param_in[i + 2] = buf[i];
696 mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
697 count + 2, param_in, 0, NULL, 1);
704 int mips32_pracc_write_mem8(struct mips_ejtag *ejtag_info, uint32_t addr, int count, uint8_t *buf)
706 static const uint32_t code[] = {
708 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
709 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
710 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
711 MIPS32_SW(8,0,15), /* sw $8,($15) */
712 MIPS32_SW(9,0,15), /* sw $9,($15) */
713 MIPS32_SW(10,0,15), /* sw $10,($15) */
714 MIPS32_SW(11,0,15), /* sw $11,($15) */
716 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $8 = MIPS32_PRACC_PARAM_IN */
717 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_PARAM_IN)),
718 MIPS32_LW(9,0,8), /* Load write addr to $9 */
719 MIPS32_LW(10,4,8), /* Load write count to $10 */
720 MIPS32_ADDI(8,8,8), /* $8 += 8 */
722 MIPS32_BEQ(0,10,8), /* beq $0, $10, end */
725 MIPS32_LW(11,0,8), /* lw $11,0($8), Load $11 with the word @mem[$8] */
726 MIPS32_SB(11,0,9), /* sb $11,0($9) */
728 MIPS32_ADDI(10,10,NEG16(1)), /* $10-- */
729 MIPS32_ADDI(9,9,1), /* $9 += 1 */
730 MIPS32_ADDI(8,8,4), /* $8 += 4 */
732 MIPS32_B(NEG16(8)), /* b loop */
735 MIPS32_LW(11,0,15), /* lw $11,($15) */
736 MIPS32_LW(10,0,15), /* lw $10,($15) */
737 MIPS32_LW(9,0,15), /* lw $9,($15) */
738 MIPS32_LW(8,0,15), /* lw $8,($15) */
739 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
740 MIPS32_B(NEG16(27)), /* b start */
744 /* TODO remove array */
745 uint32_t *param_in = malloc((count + 2) * sizeof(uint32_t));
751 for (i = 0; i < count; i++)
753 param_in[i + 2] = buf[i];
756 retval = mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
757 count + 2, param_in, 0, NULL, 1);
764 int mips32_pracc_write_regs(struct mips_ejtag *ejtag_info, uint32_t *regs)
766 static const uint32_t code[] = {
768 MIPS32_LUI(2,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $2 = MIPS32_PRACC_PARAM_IN */
769 MIPS32_ORI(2,2,LOWER16(MIPS32_PRACC_PARAM_IN)),
770 MIPS32_LW(1,1*4,2), /* lw $1,1*4($2) */
771 MIPS32_LW(15,15*4,2), /* lw $15,15*4($2) */
772 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
773 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
774 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
775 MIPS32_SW(1,0,15), /* sw $1,($15) */
776 MIPS32_LUI(1,UPPER16(MIPS32_PRACC_PARAM_IN)), /* $1 = MIPS32_PRACC_PARAM_IN */
777 MIPS32_ORI(1,1,LOWER16(MIPS32_PRACC_PARAM_IN)),
778 MIPS32_LW(3,3*4,1), /* lw $3,3*4($1) */
779 MIPS32_LW(4,4*4,1), /* lw $4,4*4($1) */
780 MIPS32_LW(5,5*4,1), /* lw $5,5*4($1) */
781 MIPS32_LW(6,6*4,1), /* lw $6,6*4($1) */
782 MIPS32_LW(7,7*4,1), /* lw $7,7*4($1) */
783 MIPS32_LW(8,8*4,1), /* lw $8,8*4($1) */
784 MIPS32_LW(9,9*4,1), /* lw $9,9*4($1) */
785 MIPS32_LW(10,10*4,1), /* lw $10,10*4($1) */
786 MIPS32_LW(11,11*4,1), /* lw $11,11*4($1) */
787 MIPS32_LW(12,12*4,1), /* lw $12,12*4($1) */
788 MIPS32_LW(13,13*4,1), /* lw $13,13*4($1) */
789 MIPS32_LW(14,14*4,1), /* lw $14,14*4($1) */
790 MIPS32_LW(16,16*4,1), /* lw $16,16*4($1) */
791 MIPS32_LW(17,17*4,1), /* lw $17,17*4($1) */
792 MIPS32_LW(18,18*4,1), /* lw $18,18*4($1) */
793 MIPS32_LW(19,19*4,1), /* lw $19,19*4($1) */
794 MIPS32_LW(20,20*4,1), /* lw $20,20*4($1) */
795 MIPS32_LW(21,21*4,1), /* lw $21,21*4($1) */
796 MIPS32_LW(22,22*4,1), /* lw $22,22*4($1) */
797 MIPS32_LW(23,23*4,1), /* lw $23,23*4($1) */
798 MIPS32_LW(24,24*4,1), /* lw $24,24*4($1) */
799 MIPS32_LW(25,25*4,1), /* lw $25,25*4($1) */
800 MIPS32_LW(26,26*4,1), /* lw $26,26*4($1) */
801 MIPS32_LW(27,27*4,1), /* lw $27,27*4($1) */
802 MIPS32_LW(28,28*4,1), /* lw $28,28*4($1) */
803 MIPS32_LW(29,29*4,1), /* lw $29,29*4($1) */
804 MIPS32_LW(30,30*4,1), /* lw $30,30*4($1) */
805 MIPS32_LW(31,31*4,1), /* lw $31,31*4($1) */
807 MIPS32_LW(2,32*4,1), /* lw $2,32*4($1) */
808 MIPS32_MTC0(2,12,0), /* move $2 to status */
809 MIPS32_LW(2,33*4,1), /* lw $2,33*4($1) */
810 MIPS32_MTLO(2), /* move $2 to lo */
811 MIPS32_LW(2,34*4,1), /* lw $2,34*4($1) */
812 MIPS32_MTHI(2), /* move $2 to hi */
813 MIPS32_LW(2,35*4,1), /* lw $2,35*4($1) */
814 MIPS32_MTC0(2,8,0), /* move $2 to badvaddr */
815 MIPS32_LW(2,36*4,1), /* lw $2,36*4($1) */
816 MIPS32_MTC0(2,13,0), /* move $2 to cause*/
817 MIPS32_LW(2,37*4,1), /* lw $2,37*4($1) */
818 MIPS32_MTC0(2,24,0), /* move $2 to pc */
820 MIPS32_LW(2,2*4,1), /* lw $2,2*4($1) */
821 MIPS32_LW(1,0,15), /* lw $1,($15) */
822 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
823 MIPS32_B(NEG16(54)), /* b start */
829 retval = mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
830 MIPS32NUMCOREREGS, regs, 0, NULL, 1);
835 int mips32_pracc_read_regs(struct mips_ejtag *ejtag_info, uint32_t *regs)
837 static const uint32_t code[] = {
839 MIPS32_MTC0(2,31,0), /* move $2 to COP0 DeSave */
840 MIPS32_LUI(2,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $2 = MIPS32_PRACC_PARAM_OUT */
841 MIPS32_ORI(2,2,LOWER16(MIPS32_PRACC_PARAM_OUT)),
842 MIPS32_SW(0,0*4,2), /* sw $0,0*4($2) */
843 MIPS32_SW(1,1*4,2), /* sw $1,1*4($2) */
844 MIPS32_SW(15,15*4,2), /* sw $15,15*4($2) */
845 MIPS32_MFC0(2,31,0), /* move COP0 DeSave to $2 */
846 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
847 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_STACK)), /* $15 = MIPS32_PRACC_STACK */
848 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_STACK)),
849 MIPS32_SW(1,0,15), /* sw $1,($15) */
850 MIPS32_SW(2,0,15), /* sw $2,($15) */
851 MIPS32_LUI(1,UPPER16(MIPS32_PRACC_PARAM_OUT)), /* $1 = MIPS32_PRACC_PARAM_OUT */
852 MIPS32_ORI(1,1,LOWER16(MIPS32_PRACC_PARAM_OUT)),
853 MIPS32_SW(2,2*4,1), /* sw $2,2*4($1) */
854 MIPS32_SW(3,3*4,1), /* sw $3,3*4($1) */
855 MIPS32_SW(4,4*4,1), /* sw $4,4*4($1) */
856 MIPS32_SW(5,5*4,1), /* sw $5,5*4($1) */
857 MIPS32_SW(6,6*4,1), /* sw $6,6*4($1) */
858 MIPS32_SW(7,7*4,1), /* sw $7,7*4($1) */
859 MIPS32_SW(8,8*4,1), /* sw $8,8*4($1) */
860 MIPS32_SW(9,9*4,1), /* sw $9,9*4($1) */
861 MIPS32_SW(10,10*4,1), /* sw $10,10*4($1) */
862 MIPS32_SW(11,11*4,1), /* sw $11,11*4($1) */
863 MIPS32_SW(12,12*4,1), /* sw $12,12*4($1) */
864 MIPS32_SW(13,13*4,1), /* sw $13,13*4($1) */
865 MIPS32_SW(14,14*4,1), /* sw $14,14*4($1) */
866 MIPS32_SW(16,16*4,1), /* sw $16,16*4($1) */
867 MIPS32_SW(17,17*4,1), /* sw $17,17*4($1) */
868 MIPS32_SW(18,18*4,1), /* sw $18,18*4($1) */
869 MIPS32_SW(19,19*4,1), /* sw $19,19*4($1) */
870 MIPS32_SW(20,20*4,1), /* sw $20,20*4($1) */
871 MIPS32_SW(21,21*4,1), /* sw $21,21*4($1) */
872 MIPS32_SW(22,22*4,1), /* sw $22,22*4($1) */
873 MIPS32_SW(23,23*4,1), /* sw $23,23*4($1) */
874 MIPS32_SW(24,24*4,1), /* sw $24,24*4($1) */
875 MIPS32_SW(25,25*4,1), /* sw $25,25*4($1) */
876 MIPS32_SW(26,26*4,1), /* sw $26,26*4($1) */
877 MIPS32_SW(27,27*4,1), /* sw $27,27*4($1) */
878 MIPS32_SW(28,28*4,1), /* sw $28,28*4($1) */
879 MIPS32_SW(29,29*4,1), /* sw $29,29*4($1) */
880 MIPS32_SW(30,30*4,1), /* sw $30,30*4($1) */
881 MIPS32_SW(31,31*4,1), /* sw $31,31*4($1) */
883 MIPS32_MFC0(2,12,0), /* move status to $2 */
884 MIPS32_SW(2,32*4,1), /* sw $2,32*4($1) */
885 MIPS32_MFLO(2), /* move lo to $2 */
886 MIPS32_SW(2,33*4,1), /* sw $2,33*4($1) */
887 MIPS32_MFHI(2), /* move hi to $2 */
888 MIPS32_SW(2,34*4,1), /* sw $2,34*4($1) */
889 MIPS32_MFC0(2,8,0), /* move badvaddr to $2 */
890 MIPS32_SW(2,35*4,1), /* sw $2,35*4($1) */
891 MIPS32_MFC0(2,13,0), /* move cause to $2 */
892 MIPS32_SW(2,36*4,1), /* sw $2,36*4($1) */
893 MIPS32_MFC0(2,24,0), /* move pc to $2 */
894 MIPS32_SW(2,37*4,1), /* sw $2,37*4($1) */
896 MIPS32_LW(2,0,15), /* lw $2,($15) */
897 MIPS32_LW(1,0,15), /* lw $1,($15) */
898 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
899 MIPS32_B(NEG16(59)), /* b start */
905 retval = mips32_pracc_exec(ejtag_info, ARRAY_SIZE(code), code, \
906 0, NULL, MIPS32NUMCOREREGS, regs, 1);
911 /* fastdata upload/download requires an initialized working area
912 * to load the download code; it should not be called otherwise
913 * fetch order from the fastdata area
918 int mips32_pracc_fastdata_xfer(struct mips_ejtag *ejtag_info, struct working_area *source,
919 int write, uint32_t addr, int count, uint32_t *buf)
921 uint32_t handler_code[] = {
922 /* caution when editing, table is modified below */
923 /* r15 points to the start of this code */
924 MIPS32_SW(8,MIPS32_FASTDATA_HANDLER_SIZE - 4,15),
925 MIPS32_SW(9,MIPS32_FASTDATA_HANDLER_SIZE - 8,15),
926 MIPS32_SW(10,MIPS32_FASTDATA_HANDLER_SIZE - 12,15),
927 MIPS32_SW(11,MIPS32_FASTDATA_HANDLER_SIZE - 16,15),
928 /* start of fastdata area in t0 */
929 MIPS32_LUI(8,UPPER16(MIPS32_PRACC_FASTDATA_AREA)),
930 MIPS32_ORI(8,8,LOWER16(MIPS32_PRACC_FASTDATA_AREA)),
931 MIPS32_LW(9,0,8), /* start addr in t1 */
932 MIPS32_LW(10,0,8), /* end addr to t2 */
934 /* 8 */ MIPS32_LW(11,0,0), /* lw t3,[t8 | r9] */
935 /* 9 */ MIPS32_SW(11,0,0), /* sw t3,[r9 | r8] */
936 MIPS32_BNE(10,9,NEG16(3)), /* bne $t2,t1,loop */
937 MIPS32_ADDI(9,9,4), /* addi t1,t1,4 */
939 MIPS32_LW(8,MIPS32_FASTDATA_HANDLER_SIZE - 4,15),
940 MIPS32_LW(9,MIPS32_FASTDATA_HANDLER_SIZE - 8,15),
941 MIPS32_LW(10,MIPS32_FASTDATA_HANDLER_SIZE - 12,15),
942 MIPS32_LW(11,MIPS32_FASTDATA_HANDLER_SIZE - 16,15),
944 MIPS32_LUI(15,UPPER16(MIPS32_PRACC_TEXT)),
945 MIPS32_ORI(15,15,LOWER16(MIPS32_PRACC_TEXT)),
946 MIPS32_JR(15), /* jr start */
947 MIPS32_MFC0(15,31,0), /* move COP0 DeSave to $15 */
950 uint32_t jmp_code[] = {
951 MIPS32_MTC0(15,31,0), /* move $15 to COP0 DeSave */
952 /* 1 */ MIPS32_LUI(15,0), /* addr of working area added below */
953 /* 2 */ MIPS32_ORI(15,15,0), /* addr of working area added below */
954 MIPS32_JR(15), /* jump to ram program */
959 uint32_t val, ejtag_ctrl, address;
961 if (source->size < MIPS32_FASTDATA_HANDLER_SIZE)
962 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
966 handler_code[8] = MIPS32_LW(11,0,8); /* load data from probe at fastdata area */
967 handler_code[9] = MIPS32_SW(11,0,9); /* store data to RAM @ r9 */
971 handler_code[8] = MIPS32_LW(11,0,9); /* load data from RAM @ r9 */
972 handler_code[9] = MIPS32_SW(11,0,8); /* store data to probe at fastdata area */
975 /* write program into RAM */
976 mips32_pracc_write_mem32(ejtag_info, source->address, ARRAY_SIZE(handler_code), handler_code);
978 /* quick verify RAM is working */
979 mips32_pracc_read_u32(ejtag_info, source->address, &val);
980 if (val != handler_code[0])
982 LOG_ERROR("fastdata handler verify failed\n");
983 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
986 LOG_INFO("%s using 0x%.8x for write handler\n", __func__, source->address);
988 jmp_code[1] |= UPPER16(source->address);
989 jmp_code[2] |= LOWER16(source->address);
991 for (i = 0; i < (int) ARRAY_SIZE(jmp_code); i++)
993 if ((retval = wait_for_pracc_rw(ejtag_info, &ejtag_ctrl)) != ERROR_OK)
996 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_DATA, NULL);
997 mips_ejtag_drscan_32(ejtag_info, &jmp_code[i]);
999 /* Clear the access pending bit (let the processor eat!) */
1000 ejtag_ctrl = ejtag_info->ejtag_ctrl & ~EJTAG_CTRL_PRACC;
1001 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_CONTROL, NULL);
1002 mips_ejtag_drscan_32(ejtag_info, &ejtag_ctrl);
1005 if ((retval = wait_for_pracc_rw(ejtag_info, &ejtag_ctrl)) != ERROR_OK)
1008 /* next fetch to dmseg should be in FASTDATA_AREA, check */
1010 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_ADDRESS, NULL);
1011 mips_ejtag_drscan_32(ejtag_info, &address);
1013 if (address != MIPS32_PRACC_FASTDATA_AREA)
1016 /* Send the load start address */
1018 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_FASTDATA, NULL);
1019 mips_ejtag_fastdata_scan(ejtag_info, 1, &val);
1021 /* Send the load end address */
1022 val = addr + (count - 1) * 4;
1023 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_FASTDATA, NULL);
1024 mips_ejtag_fastdata_scan(ejtag_info, 1, &val);
1026 for (i = 0; i < count; i++)
1028 /* Send the data out using fastdata (clears the access pending bit) */
1029 if ((retval = mips_ejtag_fastdata_scan(ejtag_info, write, buf++)) != ERROR_OK)
1033 if ((retval = jtag_execute_queue()) != ERROR_OK)
1035 LOG_ERROR("fastdata load failed");
1039 if ((retval = wait_for_pracc_rw(ejtag_info, &ejtag_ctrl)) != ERROR_OK)
1043 mips_ejtag_set_instr(ejtag_info, EJTAG_INST_ADDRESS, NULL);
1044 mips_ejtag_drscan_32(ejtag_info, &address);
1046 if (address != MIPS32_PRACC_TEXT)
1047 LOG_ERROR("mini program did not return to start\n");