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 unsigned int index
= 1;
306 uint8_t num_write
, num_read
, write_buffer
[max
], read_buffer
[1 << CHAR_BIT
];
308 char temp
[4], output
[(2 + max
+ (1 << CHAR_BIT
)) * 3 + 8];
311 LOG_DEBUG("%s", __func__
);
314 command_print(CMD
, "jtagspi: not enough arguments");
315 return ERROR_COMMAND_SYNTAX_ERROR
;
318 num_write
= CMD_ARGC
- 2;
319 if (num_write
> max
) {
320 LOG_ERROR("at most %d bytes may be send", max
);
321 return ERROR_COMMAND_SYNTAX_ERROR
;
324 /* calling flash_command_get_bank without probing because we like to be
325 able to send commands before auto-probing occurred. For example sending
326 "release from power down" is needed before probing when flash is in
329 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional
, 0,
331 if (ERROR_OK
!= retval
)
334 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], num_read
);
336 snprintf(output
, sizeof(output
), "spi: ");
337 for (ptr
= &write_buffer
[0] ; index
< CMD_ARGC
; index
++) {
338 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
], data
);
340 snprintf(temp
, sizeof(temp
), "%02" PRIx8
" ", data
);
341 strncat(output
, temp
, sizeof(output
) - strlen(output
) - 1);
343 strncat(output
, "-> ", sizeof(output
) - strlen(output
) - 1);
345 /* process command */
346 ptr
= &read_buffer
[0];
347 retval
= jtagspi_cmd(bank
, write_buffer
[0], &write_buffer
[1], num_write
- 1, ptr
, -num_read
);
348 if (retval
!= ERROR_OK
)
351 for ( ; num_read
> 0; num_read
--) {
352 snprintf(temp
, sizeof(temp
), "%02" PRIx8
" ", *ptr
++);
353 strncat(output
, temp
, sizeof(output
) - strlen(output
) - 1);
355 command_print(CMD
, "%s", output
);
360 COMMAND_HANDLER(jtagspi_handle_always_4byte
)
362 struct flash_bank
*bank
;
363 struct jtagspi_flash_bank
*jtagspi_info
;
366 LOG_DEBUG("%s", __func__
);
368 if ((CMD_ARGC
!= 1) && (CMD_ARGC
!= 2))
369 return ERROR_COMMAND_SYNTAX_ERROR
;
371 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
372 if (ERROR_OK
!= retval
)
375 jtagspi_info
= bank
->driver_priv
;
378 command_print(CMD
, jtagspi_info
->always_4byte
? "on" : "off");
380 COMMAND_PARSE_BOOL(CMD_ARGV
[1], jtagspi_info
->always_4byte
, "on", "off");
385 static int jtagspi_probe(struct flash_bank
*bank
)
387 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
388 struct flash_sector
*sectors
;
389 const struct flash_device
*p
;
391 uint32_t id
, sectorsize
;
395 bank
->sectors
= NULL
;
397 info
->probed
= false;
399 jtagspi_cmd(bank
, SPIFLASH_READ_ID
, NULL
, 0, in_buf
, -3);
400 /* the table in spi.c has the manufacturer byte (first) as the lsb */
401 id
= le_to_h_u24(in_buf
);
403 memset(&info
->dev
, 0, sizeof(info
->dev
));
404 for (p
= flash_devices
; p
->name
; p
++)
405 if (p
->device_id
== id
) {
406 memcpy(&info
->dev
, p
, sizeof(info
->dev
));
411 LOG_ERROR("Unknown flash device (ID 0x%06" PRIx32
")", id
& 0xFFFFFF);
415 LOG_INFO("Found flash device \'%s\' (ID 0x%06" PRIx32
")",
416 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF);
418 /* Set correct size value */
419 bank
->size
= info
->dev
.size_in_bytes
;
421 /* calculate address length in bytes */
422 if (bank
->size
<= (1UL << 8))
424 else if (bank
->size
<= (1UL << 16))
426 else if (bank
->size
<= (1UL << 24))
430 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
433 /* if no sectors, treat whole bank as single sector */
434 sectorsize
= info
->dev
.sectorsize
?
435 info
->dev
.sectorsize
: info
->dev
.size_in_bytes
;
437 /* create and fill sectors array */
438 bank
->num_sectors
= info
->dev
.size_in_bytes
/ sectorsize
;
439 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
441 LOG_ERROR("not enough memory");
445 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
446 sectors
[sector
].offset
= sector
* sectorsize
;
447 sectors
[sector
].size
= sectorsize
;
448 sectors
[sector
].is_erased
= -1;
449 sectors
[sector
].is_protected
= 0;
452 bank
->sectors
= sectors
;
457 static int jtagspi_auto_probe(struct flash_bank
*bank
)
459 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
463 return jtagspi_probe(bank
);
466 static int jtagspi_read_status(struct flash_bank
*bank
, uint32_t *status
)
469 int err
= jtagspi_cmd(bank
, SPIFLASH_READ_STATUS
, NULL
, 0, &buf
, -1);
470 if (err
== ERROR_OK
) {
472 LOG_DEBUG("status=0x%02" PRIx32
, *status
);
477 static int jtagspi_wait(struct flash_bank
*bank
, int timeout_ms
)
479 int64_t t0
= timeval_ms();
483 dt
= timeval_ms() - t0
;
485 uint32_t status
= (uint32_t)-1;
486 int retval
= jtagspi_read_status(bank
, &status
);
487 if (retval
!= ERROR_OK
)
490 if ((status
& SPIFLASH_BSY_BIT
) == 0) {
491 LOG_DEBUG("waited %" PRId64
" ms", dt
);
495 } while (dt
<= timeout_ms
);
497 LOG_ERROR("timeout, device still busy");
501 static int jtagspi_write_enable(struct flash_bank
*bank
)
503 jtagspi_cmd(bank
, SPIFLASH_WRITE_ENABLE
, NULL
, 0, NULL
, 0);
505 uint32_t status
= (uint32_t)-1;
506 int retval
= jtagspi_read_status(bank
, &status
);
507 if (retval
!= ERROR_OK
)
510 if ((status
& SPIFLASH_WE_BIT
) == 0) {
511 LOG_ERROR("Cannot enable write to flash. Status=0x%02" PRIx32
, status
);
517 static int jtagspi_bulk_erase(struct flash_bank
*bank
)
519 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
521 int64_t t0
= timeval_ms();
523 if (info
->dev
.chip_erase_cmd
== 0x00)
524 return ERROR_FLASH_OPER_UNSUPPORTED
;
526 retval
= jtagspi_write_enable(bank
);
527 if (retval
!= ERROR_OK
)
530 retval
= jtagspi_cmd(bank
, info
->dev
.chip_erase_cmd
, NULL
, 0, NULL
, 0);
531 if (retval
!= ERROR_OK
)
534 retval
= jtagspi_wait(bank
, bank
->num_sectors
* JTAGSPI_MAX_TIMEOUT
);
535 LOG_INFO("took %" PRId64
" ms", timeval_ms() - t0
);
539 static uint8_t *fill_addr(uint32_t addr
, unsigned int addr_len
, uint8_t *buffer
)
541 for (buffer
+= addr_len
; addr_len
> 0; --addr_len
) {
549 static int jtagspi_sector_erase(struct flash_bank
*bank
, unsigned int sector
)
551 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
553 uint8_t addr
[sizeof(uint32_t)];
554 int64_t t0
= timeval_ms();
556 retval
= jtagspi_write_enable(bank
);
557 if (retval
!= ERROR_OK
)
560 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
561 unsigned int addr_len
= info
->always_4byte
? 4 : info
->addr_len
;
563 retval
= jtagspi_cmd(bank
, info
->dev
.erase_cmd
, fill_addr(bank
->sectors
[sector
].offset
, addr_len
, addr
),
565 if (retval
!= ERROR_OK
)
568 retval
= jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
569 LOG_INFO("sector %u took %" PRId64
" ms", sector
, timeval_ms() - t0
);
573 static int jtagspi_erase(struct flash_bank
*bank
, unsigned int first
,
576 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
577 int retval
= ERROR_OK
;
579 LOG_DEBUG("erase from sector %u to sector %u", first
, last
);
581 if ((last
< first
) || (last
>= bank
->num_sectors
)) {
582 LOG_ERROR("Flash sector invalid");
583 return ERROR_FLASH_SECTOR_INVALID
;
586 if (!(info
->probed
)) {
587 LOG_ERROR("Flash bank not probed");
588 return ERROR_FLASH_BANK_NOT_PROBED
;
591 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
592 if (bank
->sectors
[sector
].is_protected
) {
593 LOG_ERROR("Flash sector %u protected", sector
);
598 if (first
== 0 && last
== (bank
->num_sectors
- 1) &&
599 info
->dev
.chip_erase_cmd
!= 0x00 &&
600 info
->dev
.chip_erase_cmd
!= info
->dev
.erase_cmd
) {
601 LOG_DEBUG("Trying bulk erase.");
602 retval
= jtagspi_bulk_erase(bank
);
603 if (retval
== ERROR_OK
)
606 LOG_WARNING("Bulk flash erase failed. Falling back to sector erase.");
609 if (info
->dev
.erase_cmd
== 0x00)
610 return ERROR_FLASH_OPER_UNSUPPORTED
;
612 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
613 retval
= jtagspi_sector_erase(bank
, sector
);
614 if (retval
!= ERROR_OK
) {
615 LOG_ERROR("Sector erase failed.");
623 static int jtagspi_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
626 for (unsigned int sector
= first
; sector
<= last
; sector
++)
627 bank
->sectors
[sector
].is_protected
= set
;
631 static int jtagspi_read(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
633 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
634 uint32_t pagesize
, currsize
;
635 uint8_t addr
[sizeof(uint32_t)];
638 if (!(info
->probed
)) {
639 LOG_ERROR("Flash bank not probed.");
640 return ERROR_FLASH_BANK_NOT_PROBED
;
643 /* if no sectorsize, use reasonable default */
644 pagesize
= info
->dev
.sectorsize
? info
->dev
.sectorsize
: info
->dev
.pagesize
;
646 pagesize
= (info
->dev
.size_in_bytes
<= SPIFLASH_DEF_PAGESIZE
) ?
647 info
->dev
.size_in_bytes
: SPIFLASH_DEF_PAGESIZE
;
649 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
650 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
653 /* length up to end of current page */
654 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
655 /* but no more than remaining size */
656 currsize
= (count
< currsize
) ? count
: currsize
;
658 retval
= jtagspi_cmd(bank
, info
->dev
.read_cmd
, fill_addr(offset
, addr_len
, addr
),
659 addr_len
, buffer
, -currsize
);
660 if (retval
!= ERROR_OK
) {
661 LOG_ERROR("page read error");
664 LOG_DEBUG("read page at 0x%08" PRIx32
, offset
);
672 static int jtagspi_page_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
674 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
675 uint8_t addr
[sizeof(uint32_t)];
678 retval
= jtagspi_write_enable(bank
);
679 if (retval
!= ERROR_OK
)
682 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
683 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
685 retval
= jtagspi_cmd(bank
, info
->dev
.pprog_cmd
, fill_addr(offset
, addr_len
, addr
),
686 addr_len
, (uint8_t *) buffer
, count
);
687 if (retval
!= ERROR_OK
)
689 return jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
692 static int jtagspi_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
694 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
695 uint32_t pagesize
, currsize
;
698 if (!(info
->probed
)) {
699 LOG_ERROR("Flash bank not probed.");
700 return ERROR_FLASH_BANK_NOT_PROBED
;
703 /* if no write pagesize, use reasonable default */
704 pagesize
= info
->dev
.pagesize
? info
->dev
.pagesize
: SPIFLASH_DEF_PAGESIZE
;
707 /* length up to end of current page */
708 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
709 /* but no more than remaining size */
710 currsize
= (count
< currsize
) ? count
: currsize
;
712 retval
= jtagspi_page_write(bank
, buffer
, offset
, currsize
);
713 if (retval
!= ERROR_OK
) {
714 LOG_ERROR("page write error");
717 LOG_DEBUG("wrote page at 0x%08" PRIx32
, offset
);
725 static int jtagspi_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
727 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
729 if (!(info
->probed
)) {
730 command_print_sameline(cmd
, "\nJTAGSPI flash bank not probed yet\n");
734 command_print_sameline(cmd
, "flash \'%s\', device id = 0x%06" PRIx32
735 ", flash size = %" PRIu32
" %sbytes\n(page size = %" PRIu32
736 ", read = 0x%02" PRIx8
", qread = 0x%02" PRIx8
737 ", pprog = 0x%02" PRIx8
", mass_erase = 0x%02" PRIx8
738 ", sector size = %" PRIu32
" %sbytes, sector_erase = 0x%02" PRIx8
")",
739 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF,
740 bank
->size
/ 4096 ? bank
->size
/ 1024 : bank
->size
,
741 bank
->size
/ 4096 ? "k" : "", info
->dev
.pagesize
,
742 info
->dev
.read_cmd
, info
->dev
.qread_cmd
,
743 info
->dev
.pprog_cmd
, info
->dev
.chip_erase_cmd
,
744 info
->dev
.sectorsize
/ 4096 ?
745 info
->dev
.sectorsize
/ 1024 : info
->dev
.sectorsize
,
746 info
->dev
.sectorsize
/ 4096 ? "k" : "",
747 info
->dev
.erase_cmd
);
752 static const struct command_registration jtagspi_exec_command_handlers
[] = {
755 .handler
= jtagspi_handle_set
,
756 .mode
= COMMAND_EXEC
,
757 .usage
= "bank_id name chip_size page_size read_cmd unused pprg_cmd "
758 "[ mass_erase_cmd ] [ sector_size sector_erase_cmd ]",
759 .help
= "Set device parameters if not autodetected.",
763 .handler
= jtagspi_handle_cmd
,
764 .mode
= COMMAND_EXEC
,
765 .usage
= "bank_id num_resp cmd_byte ...",
766 .help
= "Send low-level command cmd_byte and following bytes, read num_bytes.",
769 .name
= "always_4byte",
770 .handler
= jtagspi_handle_always_4byte
,
771 .mode
= COMMAND_EXEC
,
772 .usage
= "bank_id [ on | off ]",
773 .help
= "Use always 4-byte address except for basic 0x03.",
776 COMMAND_REGISTRATION_DONE
779 static const struct command_registration jtagspi_command_handlers
[] = {
783 .help
= "jtagspi command group",
785 .chain
= jtagspi_exec_command_handlers
,
787 COMMAND_REGISTRATION_DONE
790 const struct flash_driver jtagspi_flash
= {
792 .commands
= jtagspi_command_handlers
,
793 .flash_bank_command
= jtagspi_flash_bank_command
,
794 .erase
= jtagspi_erase
,
795 .protect
= jtagspi_protect
,
796 .write
= jtagspi_write
,
797 .read
= jtagspi_read
,
798 .probe
= jtagspi_probe
,
799 .auto_probe
= jtagspi_auto_probe
,
800 .erase_check
= default_flash_blank_check
,
801 .info
= jtagspi_info
,
802 .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)