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
;
46 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[6], info
->ir
);
51 static void jtagspi_set_ir(struct flash_bank
*bank
)
53 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
54 struct scan_field field
;
55 uint8_t buf
[4] = { 0 };
57 LOG_DEBUG("loading jtagspi ir");
58 buf_set_u32(buf
, 0, info
->tap
->ir_length
, info
->ir
);
59 field
.num_bits
= info
->tap
->ir_length
;
60 field
.out_value
= buf
;
61 field
.in_value
= NULL
;
62 jtag_add_ir_scan(info
->tap
, &field
, TAP_IDLE
);
65 static void flip_u8(const uint8_t *in
, uint8_t *out
, unsigned int len
)
67 for (unsigned int i
= 0; i
< len
; i
++)
68 out
[i
] = flip_u32(in
[i
], 8);
71 static int jtagspi_cmd(struct flash_bank
*bank
, uint8_t cmd
,
72 uint8_t *write_buffer
, unsigned int write_len
, uint8_t *data_buffer
, int data_len
)
74 assert(write_buffer
|| write_len
== 0);
75 assert(data_buffer
|| data_len
== 0);
77 struct scan_field fields
[6];
79 LOG_DEBUG("cmd=0x%02x write_len=%d data_len=%d", cmd
, write_len
, data_len
);
81 /* negative data_len == read operation */
82 const bool is_read
= (data_len
< 0);
87 const uint8_t marker
= 1;
88 fields
[n
].num_bits
= 1;
89 fields
[n
].out_value
= &marker
;
90 fields
[n
].in_value
= NULL
;
93 /* transfer length = cmd + address + read/write,
94 * -1 due to the counter implementation */
96 h_u32_to_be(xfer_bits
, ((sizeof(cmd
) + write_len
+ data_len
) * CHAR_BIT
) - 1);
97 flip_u8(xfer_bits
, xfer_bits
, sizeof(xfer_bits
));
98 fields
[n
].num_bits
= sizeof(xfer_bits
) * CHAR_BIT
;
99 fields
[n
].out_value
= xfer_bits
;
100 fields
[n
].in_value
= NULL
;
103 flip_u8(&cmd
, &cmd
, sizeof(cmd
));
104 fields
[n
].num_bits
= sizeof(cmd
) * CHAR_BIT
;
105 fields
[n
].out_value
= &cmd
;
106 fields
[n
].in_value
= NULL
;
110 flip_u8(write_buffer
, write_buffer
, write_len
);
111 fields
[n
].num_bits
= write_len
* CHAR_BIT
;
112 fields
[n
].out_value
= write_buffer
;
113 fields
[n
].in_value
= NULL
;
119 fields
[n
].num_bits
= jtag_tap_count_enabled();
120 fields
[n
].out_value
= NULL
;
121 fields
[n
].in_value
= NULL
;
124 fields
[n
].out_value
= NULL
;
125 fields
[n
].in_value
= data_buffer
;
127 flip_u8(data_buffer
, data_buffer
, data_len
);
128 fields
[n
].out_value
= data_buffer
;
129 fields
[n
].in_value
= NULL
;
131 fields
[n
].num_bits
= data_len
* CHAR_BIT
;
135 jtagspi_set_ir(bank
);
136 /* passing from an IR scan to SHIFT-DR clears BYPASS registers */
137 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
138 jtag_add_dr_scan(info
->tap
, n
, fields
, TAP_IDLE
);
139 int retval
= jtag_execute_queue();
142 flip_u8(data_buffer
, data_buffer
, data_len
);
146 COMMAND_HANDLER(jtagspi_handle_set
)
148 struct flash_bank
*bank
= NULL
;
149 struct jtagspi_flash_bank
*info
= NULL
;
150 struct flash_sector
*sectors
= NULL
;
152 unsigned int index
= 1;
155 LOG_DEBUG("%s", __func__
);
157 /* there are 6 mandatory arguments:
158 * devname, size_in_bytes, pagesize, read_cmd, unused, pprog_cmd */
159 if (index
+ 6 > CMD_ARGC
) {
160 command_print(CMD
, "jtagspi: not enough arguments");
161 return ERROR_COMMAND_SYNTAX_ERROR
;
164 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
165 if (ERROR_OK
!= retval
)
167 info
= bank
->driver_priv
;
169 /* invalidate all old info */
172 bank
->num_sectors
= 0;
175 bank
->sectors
= NULL
;
176 info
->always_4byte
= false;
177 info
->probed
= false;
179 memset(&info
->dev
, 0, sizeof(info
->dev
));
181 strncpy(info
->devname
, CMD_ARGV
[index
++], sizeof(info
->devname
) - 1);
182 info
->devname
[sizeof(info
->devname
) - 1] = '\0';
184 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
185 info
->dev
.size_in_bytes
= temp
;
186 if ((temp
& (temp
- 1)) || (temp
< (1UL << 8))) {
187 command_print(CMD
, "jtagspi: device size must be 2^n with n >= 8");
188 return ERROR_COMMAND_SYNTAX_ERROR
;
191 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
192 info
->dev
.pagesize
= temp
;
193 if (info
->dev
.pagesize
== 0)
194 info
->dev
.pagesize
= SPIFLASH_DEF_PAGESIZE
;
195 if ((temp
& (temp
- 1)) || (temp
> info
->dev
.size_in_bytes
)) {
196 command_print(CMD
, "jtagspi: page size must be 2^n and <= device size");
197 return ERROR_COMMAND_SYNTAX_ERROR
;
200 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.read_cmd
);
201 if ((info
->dev
.read_cmd
!= 0x03) &&
202 (info
->dev
.read_cmd
!= 0x13)) {
203 command_print(CMD
, "jtagspi: only 0x03/0x13 READ allowed");
204 return ERROR_COMMAND_SYNTAX_ERROR
;
207 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.qread_cmd
);
209 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.pprog_cmd
);
210 if ((info
->dev
.pprog_cmd
!= 0x02) &&
211 (info
->dev
.pprog_cmd
!= 0x12)) {
212 command_print(CMD
, "jtagspi: only 0x02/0x12 PPRG allowed");
213 return ERROR_COMMAND_SYNTAX_ERROR
;
216 /* remaining params are optional */
217 if (index
< CMD_ARGC
)
218 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.chip_erase_cmd
);
220 info
->dev
.chip_erase_cmd
= 0x00;
222 if (index
< CMD_ARGC
) {
223 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
224 info
->dev
.sectorsize
= temp
;
225 if ((info
->dev
.sectorsize
> info
->dev
.size_in_bytes
) ||
226 (info
->dev
.sectorsize
< info
->dev
.pagesize
) || (temp
& (temp
- 1))) {
227 command_print(CMD
, "jtagspi: sector size must be 2^n and <= device size");
228 return ERROR_COMMAND_SYNTAX_ERROR
;
231 if (index
< CMD_ARGC
)
232 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.erase_cmd
);
234 command_print(CMD
, "jtagspi: erase command missing");
235 return ERROR_COMMAND_SYNTAX_ERROR
;
238 /* no sector size / sector erase cmd given, treat whole bank as a single sector */
239 info
->dev
.erase_cmd
= 0x00;
240 info
->dev
.sectorsize
= info
->dev
.size_in_bytes
;
243 if (index
< CMD_ARGC
) {
244 command_print(CMD
, "jtagspi: extra arguments");
245 return ERROR_COMMAND_SYNTAX_ERROR
;
248 /* set correct size value */
249 bank
->size
= info
->dev
.size_in_bytes
;
251 /* calculate address length in bytes */
252 if (bank
->size
<= (1UL << 8))
254 else if (bank
->size
<= (1UL << 16))
256 else if (bank
->size
<= (1UL << 24))
260 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
263 /* create and fill sectors array */
265 info
->dev
.size_in_bytes
/ info
->dev
.sectorsize
;
266 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
268 LOG_ERROR("Not enough memory");
272 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
273 sectors
[sector
].offset
= sector
* (info
->dev
.sectorsize
);
274 sectors
[sector
].size
= info
->dev
.sectorsize
;
275 sectors
[sector
].is_erased
= -1;
276 sectors
[sector
].is_protected
= 0;
279 bank
->sectors
= sectors
;
280 info
->dev
.name
= info
->devname
;
281 if (info
->dev
.size_in_bytes
/ 4096)
282 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" kbytes",
283 info
->dev
.name
, info
->dev
.size_in_bytes
/ 1024);
285 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" bytes",
286 info
->dev
.name
, info
->dev
.size_in_bytes
);
292 COMMAND_HANDLER(jtagspi_handle_cmd
)
294 struct flash_bank
*bank
;
295 unsigned int index
= 1;
297 uint8_t num_write
, num_read
, write_buffer
[max
], read_buffer
[1 << CHAR_BIT
];
299 char temp
[4], output
[(2 + max
+ (1 << CHAR_BIT
)) * 3 + 8];
302 LOG_DEBUG("%s", __func__
);
305 command_print(CMD
, "jtagspi: not enough arguments");
306 return ERROR_COMMAND_SYNTAX_ERROR
;
309 num_write
= CMD_ARGC
- 2;
310 if (num_write
> max
) {
311 LOG_ERROR("at most %d bytes may be send", max
);
312 return ERROR_COMMAND_SYNTAX_ERROR
;
315 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
316 if (ERROR_OK
!= retval
)
319 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], num_read
);
321 snprintf(output
, sizeof(output
), "spi: ");
322 for (ptr
= &write_buffer
[0] ; index
< CMD_ARGC
; index
++) {
323 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
], data
);
325 snprintf(temp
, sizeof(temp
), "%02" PRIx8
" ", data
);
326 strncat(output
, temp
, sizeof(output
) - strlen(output
) - 1);
328 strncat(output
, "-> ", sizeof(output
) - strlen(output
) - 1);
330 /* process command */
331 ptr
= &read_buffer
[0];
332 jtagspi_cmd(bank
, write_buffer
[0], &write_buffer
[1], num_write
- 1, ptr
, -num_read
);
333 if (retval
!= ERROR_OK
)
336 for ( ; num_read
> 0; num_read
--) {
337 snprintf(temp
, sizeof(temp
), "%02" PRIx8
" ", *ptr
++);
338 strncat(output
, temp
, sizeof(output
) - strlen(output
) - 1);
340 command_print(CMD
, "%s", output
);
345 COMMAND_HANDLER(jtagspi_handle_always_4byte
)
347 struct flash_bank
*bank
;
348 struct jtagspi_flash_bank
*jtagspi_info
;
351 LOG_DEBUG("%s", __func__
);
353 if ((CMD_ARGC
!= 1) && (CMD_ARGC
!= 2))
354 return ERROR_COMMAND_SYNTAX_ERROR
;
356 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
357 if (ERROR_OK
!= retval
)
360 jtagspi_info
= bank
->driver_priv
;
363 command_print(CMD
, jtagspi_info
->always_4byte
? "on" : "off");
365 COMMAND_PARSE_BOOL(CMD_ARGV
[1], jtagspi_info
->always_4byte
, "on", "off");
370 static int jtagspi_probe(struct flash_bank
*bank
)
372 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
373 struct flash_sector
*sectors
;
374 const struct flash_device
*p
;
376 uint32_t id
, sectorsize
;
380 bank
->sectors
= NULL
;
382 info
->probed
= false;
384 if (!bank
->target
->tap
) {
385 LOG_ERROR("Target has no JTAG tap");
388 info
->tap
= bank
->target
->tap
;
390 jtagspi_cmd(bank
, SPIFLASH_READ_ID
, NULL
, 0, in_buf
, -3);
391 /* the table in spi.c has the manufacturer byte (first) as the lsb */
392 id
= le_to_h_u24(in_buf
);
394 memset(&info
->dev
, 0, sizeof(info
->dev
));
395 for (p
= flash_devices
; p
->name
; p
++)
396 if (p
->device_id
== id
) {
397 memcpy(&info
->dev
, p
, sizeof(info
->dev
));
402 LOG_ERROR("Unknown flash device (ID 0x%06" PRIx32
")", id
& 0xFFFFFF);
406 LOG_INFO("Found flash device \'%s\' (ID 0x%06" PRIx32
")",
407 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF);
409 /* Set correct size value */
410 bank
->size
= info
->dev
.size_in_bytes
;
412 /* calculate address length in bytes */
413 if (bank
->size
<= (1UL << 8))
415 else if (bank
->size
<= (1UL << 16))
417 else if (bank
->size
<= (1UL << 24))
421 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
424 /* if no sectors, treat whole bank as single sector */
425 sectorsize
= info
->dev
.sectorsize
?
426 info
->dev
.sectorsize
: info
->dev
.size_in_bytes
;
428 /* create and fill sectors array */
429 bank
->num_sectors
= info
->dev
.size_in_bytes
/ sectorsize
;
430 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
432 LOG_ERROR("not enough memory");
436 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
437 sectors
[sector
].offset
= sector
* sectorsize
;
438 sectors
[sector
].size
= sectorsize
;
439 sectors
[sector
].is_erased
= -1;
440 sectors
[sector
].is_protected
= 0;
443 bank
->sectors
= sectors
;
448 static int jtagspi_auto_probe(struct flash_bank
*bank
)
450 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
454 return jtagspi_probe(bank
);
457 static int jtagspi_read_status(struct flash_bank
*bank
, uint32_t *status
)
460 int err
= jtagspi_cmd(bank
, SPIFLASH_READ_STATUS
, NULL
, 0, &buf
, -1);
461 if (err
== ERROR_OK
) {
463 LOG_DEBUG("status=0x%02" PRIx32
, *status
);
468 static int jtagspi_wait(struct flash_bank
*bank
, int timeout_ms
)
470 int64_t t0
= timeval_ms();
474 dt
= timeval_ms() - t0
;
476 uint32_t status
= (uint32_t)-1;
477 int retval
= jtagspi_read_status(bank
, &status
);
478 if (retval
!= ERROR_OK
)
481 if ((status
& SPIFLASH_BSY_BIT
) == 0) {
482 LOG_DEBUG("waited %" PRId64
" ms", dt
);
486 } while (dt
<= timeout_ms
);
488 LOG_ERROR("timeout, device still busy");
492 static int jtagspi_write_enable(struct flash_bank
*bank
)
494 jtagspi_cmd(bank
, SPIFLASH_WRITE_ENABLE
, NULL
, 0, NULL
, 0);
496 uint32_t status
= (uint32_t)-1;
497 int retval
= jtagspi_read_status(bank
, &status
);
498 if (retval
!= ERROR_OK
)
501 if ((status
& SPIFLASH_WE_BIT
) == 0) {
502 LOG_ERROR("Cannot enable write to flash. Status=0x%02" PRIx32
, status
);
508 static int jtagspi_bulk_erase(struct flash_bank
*bank
)
510 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
512 int64_t t0
= timeval_ms();
514 if (info
->dev
.chip_erase_cmd
== 0x00)
515 return ERROR_FLASH_OPER_UNSUPPORTED
;
517 retval
= jtagspi_write_enable(bank
);
518 if (retval
!= ERROR_OK
)
521 jtagspi_cmd(bank
, info
->dev
.chip_erase_cmd
, NULL
, 0, NULL
, 0);
522 if (retval
!= ERROR_OK
)
525 retval
= jtagspi_wait(bank
, bank
->num_sectors
* JTAGSPI_MAX_TIMEOUT
);
526 LOG_INFO("took %" PRId64
" ms", timeval_ms() - t0
);
530 static uint8_t *fill_addr(uint32_t addr
, unsigned int addr_len
, uint8_t *buffer
)
532 for (buffer
+= addr_len
; addr_len
> 0; --addr_len
) {
540 static int jtagspi_sector_erase(struct flash_bank
*bank
, unsigned int sector
)
542 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
544 uint8_t addr
[sizeof(uint32_t)];
545 int64_t t0
= timeval_ms();
547 retval
= jtagspi_write_enable(bank
);
548 if (retval
!= ERROR_OK
)
551 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
552 unsigned int addr_len
= info
->always_4byte
? 4 : info
->addr_len
;
554 retval
= jtagspi_cmd(bank
, info
->dev
.erase_cmd
, fill_addr(bank
->sectors
[sector
].offset
, addr_len
, addr
),
556 if (retval
!= ERROR_OK
)
559 retval
= jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
560 LOG_INFO("sector %u took %" PRId64
" ms", sector
, timeval_ms() - t0
);
564 static int jtagspi_erase(struct flash_bank
*bank
, unsigned int first
,
567 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
568 int retval
= ERROR_OK
;
570 LOG_DEBUG("erase from sector %u to sector %u", first
, last
);
572 if ((last
< first
) || (last
>= bank
->num_sectors
)) {
573 LOG_ERROR("Flash sector invalid");
574 return ERROR_FLASH_SECTOR_INVALID
;
577 if (!(info
->probed
)) {
578 LOG_ERROR("Flash bank not probed");
579 return ERROR_FLASH_BANK_NOT_PROBED
;
582 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
583 if (bank
->sectors
[sector
].is_protected
) {
584 LOG_ERROR("Flash sector %u protected", sector
);
589 if (first
== 0 && last
== (bank
->num_sectors
- 1) &&
590 info
->dev
.chip_erase_cmd
!= 0x00 &&
591 info
->dev
.chip_erase_cmd
!= info
->dev
.erase_cmd
) {
592 LOG_DEBUG("Trying bulk erase.");
593 retval
= jtagspi_bulk_erase(bank
);
594 if (retval
== ERROR_OK
)
597 LOG_WARNING("Bulk flash erase failed. Falling back to sector erase.");
600 if (info
->dev
.erase_cmd
== 0x00)
601 return ERROR_FLASH_OPER_UNSUPPORTED
;
603 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
604 retval
= jtagspi_sector_erase(bank
, sector
);
605 if (retval
!= ERROR_OK
) {
606 LOG_ERROR("Sector erase failed.");
614 static int jtagspi_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
617 for (unsigned int sector
= first
; sector
<= last
; sector
++)
618 bank
->sectors
[sector
].is_protected
= set
;
622 static int jtagspi_read(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
624 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
625 uint32_t pagesize
, currsize
;
626 uint8_t addr
[sizeof(uint32_t)];
629 if (!(info
->probed
)) {
630 LOG_ERROR("Flash bank not probed.");
631 return ERROR_FLASH_BANK_NOT_PROBED
;
634 /* if no sectorsize, use reasonable default */
635 pagesize
= info
->dev
.sectorsize
? info
->dev
.sectorsize
: info
->dev
.pagesize
;
637 pagesize
= (info
->dev
.size_in_bytes
<= SPIFLASH_DEF_PAGESIZE
) ?
638 info
->dev
.size_in_bytes
: SPIFLASH_DEF_PAGESIZE
;
640 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
641 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
644 /* length up to end of current page */
645 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
646 /* but no more than remaining size */
647 currsize
= (count
< currsize
) ? count
: currsize
;
649 retval
= jtagspi_cmd(bank
, info
->dev
.read_cmd
, fill_addr(offset
, addr_len
, addr
),
650 addr_len
, buffer
, -currsize
);
651 if (retval
!= ERROR_OK
) {
652 LOG_ERROR("page read error");
655 LOG_DEBUG("read page at 0x%08" PRIx32
, offset
);
663 static int jtagspi_page_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
665 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
666 uint8_t addr
[sizeof(uint32_t)];
669 retval
= jtagspi_write_enable(bank
);
670 if (retval
!= ERROR_OK
)
673 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
674 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
676 retval
= jtagspi_cmd(bank
, info
->dev
.pprog_cmd
, fill_addr(offset
, addr_len
, addr
),
677 addr_len
, (uint8_t *) buffer
, count
);
678 if (retval
!= ERROR_OK
)
680 return jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
683 static int jtagspi_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
685 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
686 uint32_t pagesize
, currsize
;
689 if (!(info
->probed
)) {
690 LOG_ERROR("Flash bank not probed.");
691 return ERROR_FLASH_BANK_NOT_PROBED
;
694 /* if no write pagesize, use reasonable default */
695 pagesize
= info
->dev
.pagesize
? info
->dev
.pagesize
: SPIFLASH_DEF_PAGESIZE
;
698 /* length up to end of current page */
699 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
700 /* but no more than remaining size */
701 currsize
= (count
< currsize
) ? count
: currsize
;
703 retval
= jtagspi_page_write(bank
, buffer
, offset
, currsize
);
704 if (retval
!= ERROR_OK
) {
705 LOG_ERROR("page write error");
708 LOG_DEBUG("wrote page at 0x%08" PRIx32
, offset
);
716 static int jtagspi_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
718 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
720 if (!(info
->probed
)) {
721 command_print_sameline(cmd
, "\nJTAGSPI flash bank not probed yet\n");
725 command_print_sameline(cmd
, "flash \'%s\', device id = 0x%06" PRIx32
726 ", flash size = %" PRIu32
" %sbytes\n(page size = %" PRIu32
727 ", read = 0x%02" PRIx8
", qread = 0x%02" PRIx8
728 ", pprog = 0x%02" PRIx8
", mass_erase = 0x%02" PRIx8
729 ", sector size = %" PRIu32
" %sbytes, sector_erase = 0x%02" PRIx8
")",
730 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF,
731 bank
->size
/ 4096 ? bank
->size
/ 1024 : bank
->size
,
732 bank
->size
/ 4096 ? "k" : "", info
->dev
.pagesize
,
733 info
->dev
.read_cmd
, info
->dev
.qread_cmd
,
734 info
->dev
.pprog_cmd
, info
->dev
.chip_erase_cmd
,
735 info
->dev
.sectorsize
/ 4096 ?
736 info
->dev
.sectorsize
/ 1024 : info
->dev
.sectorsize
,
737 info
->dev
.sectorsize
/ 4096 ? "k" : "",
738 info
->dev
.erase_cmd
);
743 static const struct command_registration jtagspi_exec_command_handlers
[] = {
746 .handler
= jtagspi_handle_set
,
747 .mode
= COMMAND_EXEC
,
748 .usage
= "bank_id name chip_size page_size read_cmd unused pprg_cmd "
749 "[ mass_erase_cmd ] [ sector_size sector_erase_cmd ]",
750 .help
= "Set device parameters if not autodetected.",
754 .handler
= jtagspi_handle_cmd
,
755 .mode
= COMMAND_EXEC
,
756 .usage
= "bank_id num_resp cmd_byte ...",
757 .help
= "Send low-level command cmd_byte and following bytes, read num_bytes.",
760 .name
= "always_4byte",
761 .handler
= jtagspi_handle_always_4byte
,
762 .mode
= COMMAND_EXEC
,
763 .usage
= "bank_id [ on | off ]",
764 .help
= "Use always 4-byte address except for basic 0x03.",
767 COMMAND_REGISTRATION_DONE
770 static const struct command_registration jtagspi_command_handlers
[] = {
774 .help
= "jtagspi command group",
776 .chain
= jtagspi_exec_command_handlers
,
778 COMMAND_REGISTRATION_DONE
781 const struct flash_driver jtagspi_flash
= {
783 .commands
= jtagspi_command_handlers
,
784 .flash_bank_command
= jtagspi_flash_bank_command
,
785 .erase
= jtagspi_erase
,
786 .protect
= jtagspi_protect
,
787 .write
= jtagspi_write
,
788 .read
= jtagspi_read
,
789 .probe
= jtagspi_probe
,
790 .auto_probe
= jtagspi_auto_probe
,
791 .erase_check
= default_flash_blank_check
,
792 .info
= jtagspi_info
,
793 .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)