1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2015 Robert Jordens <jordens@gmail.com> *
5 ***************************************************************************/
12 #include <jtag/jtag.h>
13 #include <flash/nor/spi.h>
14 #include <helper/time_support.h>
16 #define JTAGSPI_MAX_TIMEOUT 3000
19 struct jtagspi_flash_bank
{
21 struct flash_device dev
;
24 bool always_4byte
; /* use always 4-byte address except for basic read 0x03 */
26 unsigned int addr_len
; /* address length in bytes */
29 FLASH_BANK_COMMAND_HANDLER(jtagspi_flash_bank_command
)
31 struct jtagspi_flash_bank
*info
;
34 return ERROR_COMMAND_SYNTAX_ERROR
;
36 info
= malloc(sizeof(struct jtagspi_flash_bank
));
38 LOG_ERROR("no memory for flash bank info");
42 bank
->driver_priv
= info
;
44 if (!bank
->target
->tap
) {
45 LOG_ERROR("Target has no JTAG tap");
48 info
->tap
= bank
->target
->tap
;
50 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[6], info
->ir
);
55 static void jtagspi_set_ir(struct flash_bank
*bank
)
57 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
58 struct scan_field field
;
59 uint8_t buf
[4] = { 0 };
61 LOG_DEBUG("loading jtagspi ir");
62 buf_set_u32(buf
, 0, info
->tap
->ir_length
, info
->ir
);
63 field
.num_bits
= info
->tap
->ir_length
;
64 field
.out_value
= buf
;
65 field
.in_value
= NULL
;
66 jtag_add_ir_scan(info
->tap
, &field
, TAP_IDLE
);
69 static void flip_u8(const uint8_t *in
, uint8_t *out
, unsigned int len
)
71 for (unsigned int i
= 0; i
< len
; i
++)
72 out
[i
] = flip_u32(in
[i
], 8);
75 static int jtagspi_cmd(struct flash_bank
*bank
, uint8_t cmd
,
76 uint8_t *write_buffer
, unsigned int write_len
, uint8_t *data_buffer
, int data_len
)
78 assert(write_buffer
|| write_len
== 0);
79 assert(data_buffer
|| data_len
== 0);
81 struct scan_field fields
[6];
83 LOG_DEBUG("cmd=0x%02x write_len=%d data_len=%d", cmd
, write_len
, data_len
);
85 /* negative data_len == read operation */
86 const bool is_read
= (data_len
< 0);
91 const uint8_t marker
= 1;
92 fields
[n
].num_bits
= 1;
93 fields
[n
].out_value
= &marker
;
94 fields
[n
].in_value
= NULL
;
97 /* transfer length = cmd + address + read/write,
98 * -1 due to the counter implementation */
100 h_u32_to_be(xfer_bits
, ((sizeof(cmd
) + write_len
+ data_len
) * CHAR_BIT
) - 1);
101 flip_u8(xfer_bits
, xfer_bits
, sizeof(xfer_bits
));
102 fields
[n
].num_bits
= sizeof(xfer_bits
) * CHAR_BIT
;
103 fields
[n
].out_value
= xfer_bits
;
104 fields
[n
].in_value
= NULL
;
107 flip_u8(&cmd
, &cmd
, sizeof(cmd
));
108 fields
[n
].num_bits
= sizeof(cmd
) * CHAR_BIT
;
109 fields
[n
].out_value
= &cmd
;
110 fields
[n
].in_value
= NULL
;
114 flip_u8(write_buffer
, write_buffer
, write_len
);
115 fields
[n
].num_bits
= write_len
* CHAR_BIT
;
116 fields
[n
].out_value
= write_buffer
;
117 fields
[n
].in_value
= NULL
;
123 fields
[n
].num_bits
= jtag_tap_count_enabled();
124 fields
[n
].out_value
= NULL
;
125 fields
[n
].in_value
= NULL
;
128 fields
[n
].out_value
= NULL
;
129 fields
[n
].in_value
= data_buffer
;
131 flip_u8(data_buffer
, data_buffer
, data_len
);
132 fields
[n
].out_value
= data_buffer
;
133 fields
[n
].in_value
= NULL
;
135 fields
[n
].num_bits
= data_len
* CHAR_BIT
;
139 jtagspi_set_ir(bank
);
140 /* passing from an IR scan to SHIFT-DR clears BYPASS registers */
141 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
142 jtag_add_dr_scan(info
->tap
, n
, fields
, TAP_IDLE
);
143 int retval
= jtag_execute_queue();
146 flip_u8(data_buffer
, data_buffer
, data_len
);
150 COMMAND_HANDLER(jtagspi_handle_set
)
152 struct flash_bank
*bank
= NULL
;
153 struct jtagspi_flash_bank
*info
= NULL
;
154 struct flash_sector
*sectors
= NULL
;
156 unsigned int index
= 1;
159 LOG_DEBUG("%s", __func__
);
161 /* there are 6 mandatory arguments:
162 * devname, size_in_bytes, pagesize, read_cmd, unused, pprog_cmd */
163 if (index
+ 6 > CMD_ARGC
) {
164 command_print(CMD
, "jtagspi: not enough arguments");
165 return ERROR_COMMAND_SYNTAX_ERROR
;
168 /* calling flash_command_get_bank without probing because handle_set is used
169 to set device parameters if not autodetected. So probing would fail
172 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional
, 0,
174 if (ERROR_OK
!= retval
)
176 info
= bank
->driver_priv
;
178 /* invalidate all old info */
181 bank
->num_sectors
= 0;
184 bank
->sectors
= NULL
;
185 info
->always_4byte
= false;
186 info
->probed
= false;
188 memset(&info
->dev
, 0, sizeof(info
->dev
));
190 strncpy(info
->devname
, CMD_ARGV
[index
++], sizeof(info
->devname
) - 1);
191 info
->devname
[sizeof(info
->devname
) - 1] = '\0';
193 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
194 info
->dev
.size_in_bytes
= temp
;
195 if ((temp
& (temp
- 1)) || (temp
< (1UL << 8))) {
196 command_print(CMD
, "jtagspi: device size must be 2^n with n >= 8");
197 return ERROR_COMMAND_SYNTAX_ERROR
;
200 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
201 info
->dev
.pagesize
= temp
;
202 if (info
->dev
.pagesize
== 0)
203 info
->dev
.pagesize
= SPIFLASH_DEF_PAGESIZE
;
204 if ((temp
& (temp
- 1)) || (temp
> info
->dev
.size_in_bytes
)) {
205 command_print(CMD
, "jtagspi: page size must be 2^n and <= device size");
206 return ERROR_COMMAND_SYNTAX_ERROR
;
209 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.read_cmd
);
210 if ((info
->dev
.read_cmd
!= 0x03) &&
211 (info
->dev
.read_cmd
!= 0x13)) {
212 command_print(CMD
, "jtagspi: only 0x03/0x13 READ allowed");
213 return ERROR_COMMAND_SYNTAX_ERROR
;
216 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.qread_cmd
);
218 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.pprog_cmd
);
219 if ((info
->dev
.pprog_cmd
!= 0x02) &&
220 (info
->dev
.pprog_cmd
!= 0x12)) {
221 command_print(CMD
, "jtagspi: only 0x02/0x12 PPRG allowed");
222 return ERROR_COMMAND_SYNTAX_ERROR
;
225 /* remaining params are optional */
226 if (index
< CMD_ARGC
)
227 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.chip_erase_cmd
);
229 info
->dev
.chip_erase_cmd
= 0x00;
231 if (index
< CMD_ARGC
) {
232 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
233 info
->dev
.sectorsize
= temp
;
234 if ((info
->dev
.sectorsize
> info
->dev
.size_in_bytes
) ||
235 (info
->dev
.sectorsize
< info
->dev
.pagesize
) || (temp
& (temp
- 1))) {
236 command_print(CMD
, "jtagspi: sector size must be 2^n and <= device size");
237 return ERROR_COMMAND_SYNTAX_ERROR
;
240 if (index
< CMD_ARGC
)
241 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.erase_cmd
);
243 command_print(CMD
, "jtagspi: erase command missing");
244 return ERROR_COMMAND_SYNTAX_ERROR
;
247 /* no sector size / sector erase cmd given, treat whole bank as a single sector */
248 info
->dev
.erase_cmd
= 0x00;
249 info
->dev
.sectorsize
= info
->dev
.size_in_bytes
;
252 if (index
< CMD_ARGC
) {
253 command_print(CMD
, "jtagspi: extra arguments");
254 return ERROR_COMMAND_SYNTAX_ERROR
;
257 /* set correct size value */
258 bank
->size
= info
->dev
.size_in_bytes
;
260 /* calculate address length in bytes */
261 if (bank
->size
<= (1UL << 8))
263 else if (bank
->size
<= (1UL << 16))
265 else if (bank
->size
<= (1UL << 24))
269 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
272 /* create and fill sectors array */
274 info
->dev
.size_in_bytes
/ info
->dev
.sectorsize
;
275 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
277 LOG_ERROR("Not enough memory");
281 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
282 sectors
[sector
].offset
= sector
* (info
->dev
.sectorsize
);
283 sectors
[sector
].size
= info
->dev
.sectorsize
;
284 sectors
[sector
].is_erased
= -1;
285 sectors
[sector
].is_protected
= 0;
288 bank
->sectors
= sectors
;
289 info
->dev
.name
= info
->devname
;
290 if (info
->dev
.size_in_bytes
/ 4096)
291 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" kbytes",
292 info
->dev
.name
, info
->dev
.size_in_bytes
/ 1024);
294 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" bytes",
295 info
->dev
.name
, info
->dev
.size_in_bytes
);
301 COMMAND_HANDLER(jtagspi_handle_cmd
)
303 struct flash_bank
*bank
;
304 const unsigned int max
= 20;
305 uint8_t cmd_byte
, num_read
, write_buffer
[max
], read_buffer
[1 << CHAR_BIT
];
307 LOG_DEBUG("%s", __func__
);
310 return ERROR_COMMAND_SYNTAX_ERROR
;
312 uint8_t num_write
= CMD_ARGC
- 3;
313 if (num_write
> max
) {
314 command_print(CMD
, "at most %d bytes may be send", max
);
315 return ERROR_COMMAND_ARGUMENT_INVALID
;
318 /* calling flash_command_get_bank without probing because we like to be
319 able to send commands before auto-probing occurred. For example sending
320 "release from power down" is needed before probing when flash is in
323 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional
, 0,
325 if (retval
!= ERROR_OK
)
328 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[1], num_read
);
329 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[2], cmd_byte
);
331 for (unsigned int i
= 0; i
< num_write
; i
++)
332 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[i
+ 3], write_buffer
[i
]);
334 /* process command */
335 retval
= jtagspi_cmd(bank
, cmd_byte
, write_buffer
, num_write
, read_buffer
, -num_read
);
336 if (retval
!= ERROR_OK
)
339 command_print_sameline(CMD
, "spi: %02" PRIx8
, cmd_byte
);
341 for (unsigned int i
= 0; i
< num_write
; i
++)
342 command_print_sameline(CMD
, " %02" PRIx8
, write_buffer
[i
]);
344 command_print_sameline(CMD
, " ->");
346 for (unsigned int i
= 0; i
< num_read
; i
++)
347 command_print_sameline(CMD
, " %02" PRIx8
, read_buffer
[i
]);
352 COMMAND_HANDLER(jtagspi_handle_always_4byte
)
354 struct flash_bank
*bank
;
355 struct jtagspi_flash_bank
*jtagspi_info
;
358 LOG_DEBUG("%s", __func__
);
360 if ((CMD_ARGC
!= 1) && (CMD_ARGC
!= 2))
361 return ERROR_COMMAND_SYNTAX_ERROR
;
363 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
364 if (ERROR_OK
!= retval
)
367 jtagspi_info
= bank
->driver_priv
;
370 command_print(CMD
, jtagspi_info
->always_4byte
? "on" : "off");
372 COMMAND_PARSE_BOOL(CMD_ARGV
[1], jtagspi_info
->always_4byte
, "on", "off");
377 static int jtagspi_probe(struct flash_bank
*bank
)
379 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
380 struct flash_sector
*sectors
;
381 const struct flash_device
*p
;
383 uint32_t id
, sectorsize
;
387 bank
->sectors
= NULL
;
389 info
->probed
= false;
391 jtagspi_cmd(bank
, SPIFLASH_READ_ID
, NULL
, 0, in_buf
, -3);
392 /* the table in spi.c has the manufacturer byte (first) as the lsb */
393 id
= le_to_h_u24(in_buf
);
395 memset(&info
->dev
, 0, sizeof(info
->dev
));
396 for (p
= flash_devices
; p
->name
; p
++)
397 if (p
->device_id
== id
) {
398 memcpy(&info
->dev
, p
, sizeof(info
->dev
));
403 LOG_ERROR("Unknown flash device (ID 0x%06" PRIx32
")", id
& 0xFFFFFF);
407 LOG_INFO("Found flash device \'%s\' (ID 0x%06" PRIx32
")",
408 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF);
410 /* Set correct size value */
411 bank
->size
= info
->dev
.size_in_bytes
;
413 /* calculate address length in bytes */
414 if (bank
->size
<= (1UL << 8))
416 else if (bank
->size
<= (1UL << 16))
418 else if (bank
->size
<= (1UL << 24))
422 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
425 /* if no sectors, treat whole bank as single sector */
426 sectorsize
= info
->dev
.sectorsize
?
427 info
->dev
.sectorsize
: info
->dev
.size_in_bytes
;
429 /* create and fill sectors array */
430 bank
->num_sectors
= info
->dev
.size_in_bytes
/ sectorsize
;
431 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
433 LOG_ERROR("not enough memory");
437 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
438 sectors
[sector
].offset
= sector
* sectorsize
;
439 sectors
[sector
].size
= sectorsize
;
440 sectors
[sector
].is_erased
= -1;
441 sectors
[sector
].is_protected
= 0;
444 bank
->sectors
= sectors
;
449 static int jtagspi_auto_probe(struct flash_bank
*bank
)
451 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
455 return jtagspi_probe(bank
);
458 static int jtagspi_read_status(struct flash_bank
*bank
, uint32_t *status
)
461 int err
= jtagspi_cmd(bank
, SPIFLASH_READ_STATUS
, NULL
, 0, &buf
, -1);
462 if (err
== ERROR_OK
) {
464 LOG_DEBUG("status=0x%02" PRIx32
, *status
);
469 static int jtagspi_wait(struct flash_bank
*bank
, int timeout_ms
)
471 int64_t t0
= timeval_ms();
475 dt
= timeval_ms() - t0
;
477 uint32_t status
= (uint32_t)-1;
478 int retval
= jtagspi_read_status(bank
, &status
);
479 if (retval
!= ERROR_OK
)
482 if ((status
& SPIFLASH_BSY_BIT
) == 0) {
483 LOG_DEBUG("waited %" PRId64
" ms", dt
);
487 } while (dt
<= timeout_ms
);
489 LOG_ERROR("timeout, device still busy");
493 static int jtagspi_write_enable(struct flash_bank
*bank
)
495 jtagspi_cmd(bank
, SPIFLASH_WRITE_ENABLE
, NULL
, 0, NULL
, 0);
497 uint32_t status
= (uint32_t)-1;
498 int retval
= jtagspi_read_status(bank
, &status
);
499 if (retval
!= ERROR_OK
)
502 if ((status
& SPIFLASH_WE_BIT
) == 0) {
503 LOG_ERROR("Cannot enable write to flash. Status=0x%02" PRIx32
, status
);
509 static int jtagspi_bulk_erase(struct flash_bank
*bank
)
511 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
513 int64_t t0
= timeval_ms();
515 if (info
->dev
.chip_erase_cmd
== 0x00)
516 return ERROR_FLASH_OPER_UNSUPPORTED
;
518 retval
= jtagspi_write_enable(bank
);
519 if (retval
!= ERROR_OK
)
522 retval
= jtagspi_cmd(bank
, info
->dev
.chip_erase_cmd
, NULL
, 0, NULL
, 0);
523 if (retval
!= ERROR_OK
)
526 retval
= jtagspi_wait(bank
, bank
->num_sectors
* JTAGSPI_MAX_TIMEOUT
);
527 LOG_INFO("took %" PRId64
" ms", timeval_ms() - t0
);
531 static uint8_t *fill_addr(uint32_t addr
, unsigned int addr_len
, uint8_t *buffer
)
533 for (buffer
+= addr_len
; addr_len
> 0; --addr_len
) {
541 static int jtagspi_sector_erase(struct flash_bank
*bank
, unsigned int sector
)
543 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
545 uint8_t addr
[sizeof(uint32_t)];
546 int64_t t0
= timeval_ms();
548 retval
= jtagspi_write_enable(bank
);
549 if (retval
!= ERROR_OK
)
552 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
553 unsigned int addr_len
= info
->always_4byte
? 4 : info
->addr_len
;
555 retval
= jtagspi_cmd(bank
, info
->dev
.erase_cmd
, fill_addr(bank
->sectors
[sector
].offset
, addr_len
, addr
),
557 if (retval
!= ERROR_OK
)
560 retval
= jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
561 LOG_INFO("sector %u took %" PRId64
" ms", sector
, timeval_ms() - t0
);
565 static int jtagspi_erase(struct flash_bank
*bank
, unsigned int first
,
568 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
569 int retval
= ERROR_OK
;
571 LOG_DEBUG("erase from sector %u to sector %u", first
, last
);
573 if ((last
< first
) || (last
>= bank
->num_sectors
)) {
574 LOG_ERROR("Flash sector invalid");
575 return ERROR_FLASH_SECTOR_INVALID
;
578 if (!(info
->probed
)) {
579 LOG_ERROR("Flash bank not probed");
580 return ERROR_FLASH_BANK_NOT_PROBED
;
583 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
584 if (bank
->sectors
[sector
].is_protected
) {
585 LOG_ERROR("Flash sector %u protected", sector
);
590 if (first
== 0 && last
== (bank
->num_sectors
- 1) &&
591 info
->dev
.chip_erase_cmd
!= 0x00 &&
592 info
->dev
.chip_erase_cmd
!= info
->dev
.erase_cmd
) {
593 LOG_DEBUG("Trying bulk erase.");
594 retval
= jtagspi_bulk_erase(bank
);
595 if (retval
== ERROR_OK
)
598 LOG_WARNING("Bulk flash erase failed. Falling back to sector erase.");
601 if (info
->dev
.erase_cmd
== 0x00)
602 return ERROR_FLASH_OPER_UNSUPPORTED
;
604 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
605 retval
= jtagspi_sector_erase(bank
, sector
);
606 if (retval
!= ERROR_OK
) {
607 LOG_ERROR("Sector erase failed.");
615 static int jtagspi_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
618 for (unsigned int sector
= first
; sector
<= last
; sector
++)
619 bank
->sectors
[sector
].is_protected
= set
;
623 static int jtagspi_read(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
625 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
626 uint32_t pagesize
, currsize
;
627 uint8_t addr
[sizeof(uint32_t)];
630 if (!(info
->probed
)) {
631 LOG_ERROR("Flash bank not probed.");
632 return ERROR_FLASH_BANK_NOT_PROBED
;
635 /* if no sectorsize, use reasonable default */
636 pagesize
= info
->dev
.sectorsize
? info
->dev
.sectorsize
: info
->dev
.pagesize
;
638 pagesize
= (info
->dev
.size_in_bytes
<= SPIFLASH_DEF_PAGESIZE
) ?
639 info
->dev
.size_in_bytes
: SPIFLASH_DEF_PAGESIZE
;
641 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
642 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
645 /* length up to end of current page */
646 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
647 /* but no more than remaining size */
648 currsize
= (count
< currsize
) ? count
: currsize
;
650 retval
= jtagspi_cmd(bank
, info
->dev
.read_cmd
, fill_addr(offset
, addr_len
, addr
),
651 addr_len
, buffer
, -currsize
);
652 if (retval
!= ERROR_OK
) {
653 LOG_ERROR("page read error");
656 LOG_DEBUG("read page at 0x%08" PRIx32
, offset
);
664 static int jtagspi_page_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
666 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
667 uint8_t addr
[sizeof(uint32_t)];
670 retval
= jtagspi_write_enable(bank
);
671 if (retval
!= ERROR_OK
)
674 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
675 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
677 retval
= jtagspi_cmd(bank
, info
->dev
.pprog_cmd
, fill_addr(offset
, addr_len
, addr
),
678 addr_len
, (uint8_t *) buffer
, count
);
679 if (retval
!= ERROR_OK
)
681 return jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
684 static int jtagspi_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
686 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
687 uint32_t pagesize
, currsize
;
690 if (!(info
->probed
)) {
691 LOG_ERROR("Flash bank not probed.");
692 return ERROR_FLASH_BANK_NOT_PROBED
;
695 /* if no write pagesize, use reasonable default */
696 pagesize
= info
->dev
.pagesize
? info
->dev
.pagesize
: SPIFLASH_DEF_PAGESIZE
;
699 /* length up to end of current page */
700 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
701 /* but no more than remaining size */
702 currsize
= (count
< currsize
) ? count
: currsize
;
704 retval
= jtagspi_page_write(bank
, buffer
, offset
, currsize
);
705 if (retval
!= ERROR_OK
) {
706 LOG_ERROR("page write error");
709 LOG_DEBUG("wrote page at 0x%08" PRIx32
, offset
);
717 static int jtagspi_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
719 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
721 if (!(info
->probed
)) {
722 command_print_sameline(cmd
, "\nJTAGSPI flash bank not probed yet\n");
726 command_print_sameline(cmd
, "flash \'%s\', device id = 0x%06" PRIx32
727 ", flash size = %" PRIu32
" %sbytes\n(page size = %" PRIu32
728 ", read = 0x%02" PRIx8
", qread = 0x%02" PRIx8
729 ", pprog = 0x%02" PRIx8
", mass_erase = 0x%02" PRIx8
730 ", sector size = %" PRIu32
" %sbytes, sector_erase = 0x%02" PRIx8
")",
731 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF,
732 bank
->size
/ 4096 ? bank
->size
/ 1024 : bank
->size
,
733 bank
->size
/ 4096 ? "k" : "", info
->dev
.pagesize
,
734 info
->dev
.read_cmd
, info
->dev
.qread_cmd
,
735 info
->dev
.pprog_cmd
, info
->dev
.chip_erase_cmd
,
736 info
->dev
.sectorsize
/ 4096 ?
737 info
->dev
.sectorsize
/ 1024 : info
->dev
.sectorsize
,
738 info
->dev
.sectorsize
/ 4096 ? "k" : "",
739 info
->dev
.erase_cmd
);
744 static const struct command_registration jtagspi_exec_command_handlers
[] = {
747 .handler
= jtagspi_handle_set
,
748 .mode
= COMMAND_EXEC
,
749 .usage
= "bank_id name chip_size page_size read_cmd unused pprg_cmd "
750 "[ mass_erase_cmd ] [ sector_size sector_erase_cmd ]",
751 .help
= "Set device parameters if not autodetected.",
755 .handler
= jtagspi_handle_cmd
,
756 .mode
= COMMAND_EXEC
,
757 .usage
= "bank_id num_resp cmd_byte ...",
758 .help
= "Send low-level command cmd_byte and following bytes, read num_bytes.",
761 .name
= "always_4byte",
762 .handler
= jtagspi_handle_always_4byte
,
763 .mode
= COMMAND_EXEC
,
764 .usage
= "bank_id [ on | off ]",
765 .help
= "Use always 4-byte address except for basic 0x03.",
768 COMMAND_REGISTRATION_DONE
771 static const struct command_registration jtagspi_command_handlers
[] = {
775 .help
= "jtagspi command group",
777 .chain
= jtagspi_exec_command_handlers
,
779 COMMAND_REGISTRATION_DONE
782 const struct flash_driver jtagspi_flash
= {
784 .commands
= jtagspi_command_handlers
,
785 .flash_bank_command
= jtagspi_flash_bank_command
,
786 .erase
= jtagspi_erase
,
787 .protect
= jtagspi_protect
,
788 .write
= jtagspi_write
,
789 .read
= jtagspi_read
,
790 .probe
= jtagspi_probe
,
791 .auto_probe
= jtagspi_auto_probe
,
792 .erase_check
= default_flash_blank_check
,
793 .info
= jtagspi_info
,
794 .free_driver_priv
= default_flash_free_driver_priv
,
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)