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>
17 #define JTAGSPI_MAX_TIMEOUT 3000
20 struct jtagspi_flash_bank
{
22 struct flash_device dev
;
25 bool always_4byte
; /* use always 4-byte address except for basic read 0x03 */
26 unsigned int addr_len
; /* address length in bytes */
27 struct pld_device
*pld_device
; /* if not NULL, the PLD has special instructions for JTAGSPI */
28 uint32_t ir
; /* when !pld_device, this instruction code is used in
29 jtagspi_set_user_ir to connect through a proxy bitstream */
32 FLASH_BANK_COMMAND_HANDLER(jtagspi_flash_bank_command
)
35 return ERROR_COMMAND_SYNTAX_ERROR
;
38 struct pld_device
*device
= NULL
;
39 if (strcmp(CMD_ARGV
[6], "-pld") == 0) {
41 return ERROR_COMMAND_SYNTAX_ERROR
;
42 device
= get_pld_device_by_name_or_numstr(CMD_ARGV
[7]);
44 bool has_jtagspi_instruction
= false;
45 int retval
= pld_has_jtagspi_instruction(device
, &has_jtagspi_instruction
);
46 if (retval
!= ERROR_OK
)
48 if (!has_jtagspi_instruction
) {
49 retval
= pld_get_jtagspi_userircode(device
, &ir
);
50 if (retval
!= ERROR_OK
)
55 LOG_ERROR("pld device '#%s' is out of bounds or unknown", CMD_ARGV
[7]);
59 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[6], ir
);
62 struct jtagspi_flash_bank
*info
= calloc(1, sizeof(struct jtagspi_flash_bank
));
64 LOG_ERROR("no memory for flash bank info");
68 bank
->driver_priv
= info
;
70 if (!bank
->target
->tap
) {
71 LOG_ERROR("Target has no JTAG tap");
74 info
->tap
= bank
->target
->tap
;
78 info
->pld_device
= device
;
83 static void jtagspi_set_user_ir(struct jtagspi_flash_bank
*info
)
85 struct scan_field field
;
86 uint8_t buf
[4] = { 0 };
88 LOG_DEBUG("loading jtagspi ir(0x%" PRIx32
")", info
->ir
);
89 buf_set_u32(buf
, 0, info
->tap
->ir_length
, info
->ir
);
90 field
.num_bits
= info
->tap
->ir_length
;
91 field
.out_value
= buf
;
92 field
.in_value
= NULL
;
93 jtag_add_ir_scan(info
->tap
, &field
, TAP_IDLE
);
96 static void flip_u8(const uint8_t *in
, uint8_t *out
, unsigned int len
)
98 for (unsigned int i
= 0; i
< len
; i
++)
99 out
[i
] = flip_u32(in
[i
], 8);
102 static int jtagspi_cmd(struct flash_bank
*bank
, uint8_t cmd
,
103 uint8_t *write_buffer
, unsigned int write_len
, uint8_t *data_buffer
, int data_len
)
105 assert(write_buffer
|| write_len
== 0);
106 assert(data_buffer
|| data_len
== 0);
108 struct scan_field fields
[6];
109 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
111 LOG_DEBUG("cmd=0x%02x write_len=%d data_len=%d", cmd
, write_len
, data_len
);
113 /* negative data_len == read operation */
114 const bool is_read
= (data_len
< 0);
116 data_len
= -data_len
;
118 unsigned int facing_read_bits
= 0;
119 unsigned int trailing_write_bits
= 0;
121 if (info
->pld_device
) {
122 int retval
= pld_get_jtagspi_stuff_bits(info
->pld_device
, &facing_read_bits
, &trailing_write_bits
);
123 if (retval
!= ERROR_OK
)
128 const uint8_t marker
= 1;
129 uint8_t xfer_bits
[4];
130 if (!info
->pld_device
) { /* mode == JTAGSPI_MODE_PROXY_BITSTREAM */
131 facing_read_bits
= jtag_tap_count_enabled();
132 fields
[n
].num_bits
= 1;
133 fields
[n
].out_value
= &marker
;
134 fields
[n
].in_value
= NULL
;
137 /* transfer length = cmd + address + read/write,
138 * -1 due to the counter implementation */
139 h_u32_to_be(xfer_bits
, ((sizeof(cmd
) + write_len
+ data_len
) * CHAR_BIT
) - 1);
140 flip_u8(xfer_bits
, xfer_bits
, sizeof(xfer_bits
));
141 fields
[n
].num_bits
= sizeof(xfer_bits
) * CHAR_BIT
;
142 fields
[n
].out_value
= xfer_bits
;
143 fields
[n
].in_value
= NULL
;
147 flip_u8(&cmd
, &cmd
, sizeof(cmd
));
148 fields
[n
].num_bits
= sizeof(cmd
) * CHAR_BIT
;
149 fields
[n
].out_value
= &cmd
;
150 fields
[n
].in_value
= NULL
;
154 flip_u8(write_buffer
, write_buffer
, write_len
);
155 fields
[n
].num_bits
= write_len
* CHAR_BIT
;
156 fields
[n
].out_value
= write_buffer
;
157 fields
[n
].in_value
= NULL
;
163 if (facing_read_bits
) {
164 fields
[n
].num_bits
= facing_read_bits
;
165 fields
[n
].out_value
= NULL
;
166 fields
[n
].in_value
= NULL
;
170 fields
[n
].out_value
= NULL
;
171 fields
[n
].in_value
= data_buffer
;
173 flip_u8(data_buffer
, data_buffer
, data_len
);
174 fields
[n
].out_value
= data_buffer
;
175 fields
[n
].in_value
= NULL
;
177 fields
[n
].num_bits
= data_len
* CHAR_BIT
;
180 if (!is_read
&& trailing_write_bits
) {
181 fields
[n
].num_bits
= trailing_write_bits
;
182 fields
[n
].out_value
= NULL
;
183 fields
[n
].in_value
= NULL
;
187 if (info
->pld_device
) {
188 int retval
= pld_connect_spi_to_jtag(info
->pld_device
);
189 if (retval
!= ERROR_OK
)
192 jtagspi_set_user_ir(info
);
195 /* passing from an IR scan to SHIFT-DR clears BYPASS registers */
196 jtag_add_dr_scan(info
->tap
, n
, fields
, TAP_IDLE
);
197 int retval
= jtag_execute_queue();
198 if (retval
!= ERROR_OK
)
202 flip_u8(data_buffer
, data_buffer
, data_len
);
204 if (info
->pld_device
)
205 return pld_disconnect_spi_from_jtag(info
->pld_device
);
209 COMMAND_HANDLER(jtagspi_handle_set
)
211 struct flash_bank
*bank
= NULL
;
212 struct jtagspi_flash_bank
*info
= NULL
;
213 struct flash_sector
*sectors
= NULL
;
215 unsigned int index
= 1;
218 LOG_DEBUG("%s", __func__
);
220 /* there are 6 mandatory arguments:
221 * devname, size_in_bytes, pagesize, read_cmd, unused, pprog_cmd */
222 if (index
+ 6 > CMD_ARGC
) {
223 command_print(CMD
, "jtagspi: not enough arguments");
224 return ERROR_COMMAND_SYNTAX_ERROR
;
227 /* calling flash_command_get_bank without probing because handle_set is used
228 to set device parameters if not autodetected. So probing would fail
231 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional
, 0,
233 if (ERROR_OK
!= retval
)
235 info
= bank
->driver_priv
;
237 /* invalidate all old info */
240 bank
->num_sectors
= 0;
243 bank
->sectors
= NULL
;
244 info
->always_4byte
= false;
245 info
->probed
= false;
247 memset(&info
->dev
, 0, sizeof(info
->dev
));
249 strncpy(info
->devname
, CMD_ARGV
[index
++], sizeof(info
->devname
) - 1);
250 info
->devname
[sizeof(info
->devname
) - 1] = '\0';
252 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
253 info
->dev
.size_in_bytes
= temp
;
254 if ((temp
& (temp
- 1)) || (temp
< (1UL << 8))) {
255 command_print(CMD
, "jtagspi: device size must be 2^n with n >= 8");
256 return ERROR_COMMAND_SYNTAX_ERROR
;
259 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
260 info
->dev
.pagesize
= temp
;
261 if (info
->dev
.pagesize
== 0)
262 info
->dev
.pagesize
= SPIFLASH_DEF_PAGESIZE
;
263 if ((temp
& (temp
- 1)) || (temp
> info
->dev
.size_in_bytes
)) {
264 command_print(CMD
, "jtagspi: page size must be 2^n and <= device size");
265 return ERROR_COMMAND_SYNTAX_ERROR
;
268 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.read_cmd
);
269 if ((info
->dev
.read_cmd
!= 0x03) &&
270 (info
->dev
.read_cmd
!= 0x13)) {
271 command_print(CMD
, "jtagspi: only 0x03/0x13 READ allowed");
272 return ERROR_COMMAND_SYNTAX_ERROR
;
275 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.qread_cmd
);
277 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.pprog_cmd
);
278 if ((info
->dev
.pprog_cmd
!= 0x02) &&
279 (info
->dev
.pprog_cmd
!= 0x12)) {
280 command_print(CMD
, "jtagspi: only 0x02/0x12 PPRG allowed");
281 return ERROR_COMMAND_SYNTAX_ERROR
;
284 /* remaining params are optional */
285 if (index
< CMD_ARGC
)
286 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.chip_erase_cmd
);
288 info
->dev
.chip_erase_cmd
= 0x00;
290 if (index
< CMD_ARGC
) {
291 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[index
++], temp
);
292 info
->dev
.sectorsize
= temp
;
293 if ((info
->dev
.sectorsize
> info
->dev
.size_in_bytes
) ||
294 (info
->dev
.sectorsize
< info
->dev
.pagesize
) || (temp
& (temp
- 1))) {
295 command_print(CMD
, "jtagspi: sector size must be 2^n and <= device size");
296 return ERROR_COMMAND_SYNTAX_ERROR
;
299 if (index
< CMD_ARGC
)
300 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[index
++], info
->dev
.erase_cmd
);
302 command_print(CMD
, "jtagspi: erase command missing");
303 return ERROR_COMMAND_SYNTAX_ERROR
;
306 /* no sector size / sector erase cmd given, treat whole bank as a single sector */
307 info
->dev
.erase_cmd
= 0x00;
308 info
->dev
.sectorsize
= info
->dev
.size_in_bytes
;
311 if (index
< CMD_ARGC
) {
312 command_print(CMD
, "jtagspi: extra arguments");
313 return ERROR_COMMAND_SYNTAX_ERROR
;
316 /* set correct size value */
317 bank
->size
= info
->dev
.size_in_bytes
;
319 /* calculate address length in bytes */
320 if (bank
->size
<= (1UL << 8))
322 else if (bank
->size
<= (1UL << 16))
324 else if (bank
->size
<= (1UL << 24))
328 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
331 /* create and fill sectors array */
333 info
->dev
.size_in_bytes
/ info
->dev
.sectorsize
;
334 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
336 LOG_ERROR("Not enough memory");
340 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
341 sectors
[sector
].offset
= sector
* (info
->dev
.sectorsize
);
342 sectors
[sector
].size
= info
->dev
.sectorsize
;
343 sectors
[sector
].is_erased
= -1;
344 sectors
[sector
].is_protected
= 0;
347 bank
->sectors
= sectors
;
348 info
->dev
.name
= info
->devname
;
349 if (info
->dev
.size_in_bytes
/ 4096)
350 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" kbytes",
351 info
->dev
.name
, info
->dev
.size_in_bytes
/ 1024);
353 LOG_INFO("flash \'%s\' id = unknown\nflash size = %" PRIu32
" bytes",
354 info
->dev
.name
, info
->dev
.size_in_bytes
);
360 COMMAND_HANDLER(jtagspi_handle_cmd
)
362 struct flash_bank
*bank
;
363 const unsigned int max
= 20;
364 uint8_t cmd_byte
, num_read
, write_buffer
[max
], read_buffer
[1 << CHAR_BIT
];
366 LOG_DEBUG("%s", __func__
);
369 return ERROR_COMMAND_SYNTAX_ERROR
;
371 uint8_t num_write
= CMD_ARGC
- 3;
372 if (num_write
> max
) {
373 command_print(CMD
, "at most %d bytes may be send", max
);
374 return ERROR_COMMAND_ARGUMENT_INVALID
;
377 /* calling flash_command_get_bank without probing because we like to be
378 able to send commands before auto-probing occurred. For example sending
379 "release from power down" is needed before probing when flash is in
382 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional
, 0,
384 if (retval
!= ERROR_OK
)
387 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[1], num_read
);
388 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[2], cmd_byte
);
390 for (unsigned int i
= 0; i
< num_write
; i
++)
391 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[i
+ 3], write_buffer
[i
]);
393 /* process command */
394 retval
= jtagspi_cmd(bank
, cmd_byte
, write_buffer
, num_write
, read_buffer
, -num_read
);
395 if (retval
!= ERROR_OK
)
398 command_print_sameline(CMD
, "spi: %02" PRIx8
, cmd_byte
);
400 for (unsigned int i
= 0; i
< num_write
; i
++)
401 command_print_sameline(CMD
, " %02" PRIx8
, write_buffer
[i
]);
403 command_print_sameline(CMD
, " ->");
405 for (unsigned int i
= 0; i
< num_read
; i
++)
406 command_print_sameline(CMD
, " %02" PRIx8
, read_buffer
[i
]);
411 COMMAND_HANDLER(jtagspi_handle_always_4byte
)
413 struct flash_bank
*bank
;
414 struct jtagspi_flash_bank
*jtagspi_info
;
417 LOG_DEBUG("%s", __func__
);
419 if ((CMD_ARGC
!= 1) && (CMD_ARGC
!= 2))
420 return ERROR_COMMAND_SYNTAX_ERROR
;
422 retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
423 if (ERROR_OK
!= retval
)
426 jtagspi_info
= bank
->driver_priv
;
429 command_print(CMD
, jtagspi_info
->always_4byte
? "on" : "off");
431 COMMAND_PARSE_BOOL(CMD_ARGV
[1], jtagspi_info
->always_4byte
, "on", "off");
436 static int jtagspi_probe(struct flash_bank
*bank
)
438 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
439 struct flash_sector
*sectors
;
440 const struct flash_device
*p
;
442 uint32_t id
, sectorsize
;
446 bank
->sectors
= NULL
;
448 info
->probed
= false;
450 jtagspi_cmd(bank
, SPIFLASH_READ_ID
, NULL
, 0, in_buf
, -3);
451 /* the table in spi.c has the manufacturer byte (first) as the lsb */
452 id
= le_to_h_u24(in_buf
);
454 memset(&info
->dev
, 0, sizeof(info
->dev
));
455 for (p
= flash_devices
; p
->name
; p
++)
456 if (p
->device_id
== id
) {
457 memcpy(&info
->dev
, p
, sizeof(info
->dev
));
462 LOG_ERROR("Unknown flash device (ID 0x%06" PRIx32
")", id
& 0xFFFFFF);
466 LOG_INFO("Found flash device \'%s\' (ID 0x%06" PRIx32
")",
467 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF);
469 /* Set correct size value */
470 bank
->size
= info
->dev
.size_in_bytes
;
472 /* calculate address length in bytes */
473 if (bank
->size
<= (1UL << 8))
475 else if (bank
->size
<= (1UL << 16))
477 else if (bank
->size
<= (1UL << 24))
481 LOG_WARNING("4-byte addresses needed, might need extra command to enable");
484 /* if no sectors, treat whole bank as single sector */
485 sectorsize
= info
->dev
.sectorsize
?
486 info
->dev
.sectorsize
: info
->dev
.size_in_bytes
;
488 /* create and fill sectors array */
489 bank
->num_sectors
= info
->dev
.size_in_bytes
/ sectorsize
;
490 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
492 LOG_ERROR("not enough memory");
496 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
497 sectors
[sector
].offset
= sector
* sectorsize
;
498 sectors
[sector
].size
= sectorsize
;
499 sectors
[sector
].is_erased
= -1;
500 sectors
[sector
].is_protected
= 0;
503 bank
->sectors
= sectors
;
508 static int jtagspi_auto_probe(struct flash_bank
*bank
)
510 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
514 return jtagspi_probe(bank
);
517 static int jtagspi_read_status(struct flash_bank
*bank
, uint32_t *status
)
520 int err
= jtagspi_cmd(bank
, SPIFLASH_READ_STATUS
, NULL
, 0, &buf
, -1);
521 if (err
== ERROR_OK
) {
523 LOG_DEBUG("status=0x%02" PRIx32
, *status
);
528 static int jtagspi_wait(struct flash_bank
*bank
, int timeout_ms
)
530 int64_t t0
= timeval_ms();
534 dt
= timeval_ms() - t0
;
536 uint32_t status
= (uint32_t)-1;
537 int retval
= jtagspi_read_status(bank
, &status
);
538 if (retval
!= ERROR_OK
)
541 if ((status
& SPIFLASH_BSY_BIT
) == 0) {
542 LOG_DEBUG("waited %" PRId64
" ms", dt
);
546 } while (dt
<= timeout_ms
);
548 LOG_ERROR("timeout, device still busy");
552 static int jtagspi_write_enable(struct flash_bank
*bank
)
554 jtagspi_cmd(bank
, SPIFLASH_WRITE_ENABLE
, NULL
, 0, NULL
, 0);
556 uint32_t status
= (uint32_t)-1;
557 int retval
= jtagspi_read_status(bank
, &status
);
558 if (retval
!= ERROR_OK
)
561 if ((status
& SPIFLASH_WE_BIT
) == 0) {
562 LOG_ERROR("Cannot enable write to flash. Status=0x%02" PRIx32
, status
);
568 static int jtagspi_bulk_erase(struct flash_bank
*bank
)
570 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
572 int64_t t0
= timeval_ms();
574 if (info
->dev
.chip_erase_cmd
== 0x00)
575 return ERROR_FLASH_OPER_UNSUPPORTED
;
577 retval
= jtagspi_write_enable(bank
);
578 if (retval
!= ERROR_OK
)
581 retval
= jtagspi_cmd(bank
, info
->dev
.chip_erase_cmd
, NULL
, 0, NULL
, 0);
582 if (retval
!= ERROR_OK
)
585 retval
= jtagspi_wait(bank
, bank
->num_sectors
* JTAGSPI_MAX_TIMEOUT
);
586 LOG_INFO("took %" PRId64
" ms", timeval_ms() - t0
);
590 static uint8_t *fill_addr(uint32_t addr
, unsigned int addr_len
, uint8_t *buffer
)
592 for (buffer
+= addr_len
; addr_len
> 0; --addr_len
) {
600 static int jtagspi_sector_erase(struct flash_bank
*bank
, unsigned int sector
)
602 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
604 uint8_t addr
[sizeof(uint32_t)];
605 int64_t t0
= timeval_ms();
607 retval
= jtagspi_write_enable(bank
);
608 if (retval
!= ERROR_OK
)
611 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
612 unsigned int addr_len
= info
->always_4byte
? 4 : info
->addr_len
;
614 retval
= jtagspi_cmd(bank
, info
->dev
.erase_cmd
, fill_addr(bank
->sectors
[sector
].offset
, addr_len
, addr
),
616 if (retval
!= ERROR_OK
)
619 retval
= jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
620 LOG_INFO("sector %u took %" PRId64
" ms", sector
, timeval_ms() - t0
);
624 static int jtagspi_erase(struct flash_bank
*bank
, unsigned int first
,
627 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
628 int retval
= ERROR_OK
;
630 LOG_DEBUG("erase from sector %u to sector %u", first
, last
);
632 if ((last
< first
) || (last
>= bank
->num_sectors
)) {
633 LOG_ERROR("Flash sector invalid");
634 return ERROR_FLASH_SECTOR_INVALID
;
637 if (!(info
->probed
)) {
638 LOG_ERROR("Flash bank not probed");
639 return ERROR_FLASH_BANK_NOT_PROBED
;
642 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
643 if (bank
->sectors
[sector
].is_protected
) {
644 LOG_ERROR("Flash sector %u protected", sector
);
649 if (first
== 0 && last
== (bank
->num_sectors
- 1) &&
650 info
->dev
.chip_erase_cmd
!= 0x00 &&
651 info
->dev
.chip_erase_cmd
!= info
->dev
.erase_cmd
) {
652 LOG_DEBUG("Trying bulk erase.");
653 retval
= jtagspi_bulk_erase(bank
);
654 if (retval
== ERROR_OK
)
657 LOG_WARNING("Bulk flash erase failed. Falling back to sector erase.");
660 if (info
->dev
.erase_cmd
== 0x00)
661 return ERROR_FLASH_OPER_UNSUPPORTED
;
663 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
664 retval
= jtagspi_sector_erase(bank
, sector
);
665 if (retval
!= ERROR_OK
) {
666 LOG_ERROR("Sector erase failed.");
674 static int jtagspi_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
677 for (unsigned int sector
= first
; sector
<= last
; sector
++)
678 bank
->sectors
[sector
].is_protected
= set
;
682 static int jtagspi_read(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
684 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
685 uint32_t pagesize
, currsize
;
686 uint8_t addr
[sizeof(uint32_t)];
689 if (!(info
->probed
)) {
690 LOG_ERROR("Flash bank not probed.");
691 return ERROR_FLASH_BANK_NOT_PROBED
;
694 /* if no sectorsize, use reasonable default */
695 pagesize
= info
->dev
.sectorsize
? info
->dev
.sectorsize
: info
->dev
.pagesize
;
697 pagesize
= (info
->dev
.size_in_bytes
<= SPIFLASH_DEF_PAGESIZE
) ?
698 info
->dev
.size_in_bytes
: SPIFLASH_DEF_PAGESIZE
;
700 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
701 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
704 /* length up to end of current page */
705 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
706 /* but no more than remaining size */
707 currsize
= (count
< currsize
) ? count
: currsize
;
709 retval
= jtagspi_cmd(bank
, info
->dev
.read_cmd
, fill_addr(offset
, addr_len
, addr
),
710 addr_len
, buffer
, -currsize
);
711 if (retval
!= ERROR_OK
) {
712 LOG_ERROR("page read error");
715 LOG_DEBUG("read page at 0x%08" PRIx32
, offset
);
723 static int jtagspi_page_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
725 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
726 uint8_t addr
[sizeof(uint32_t)];
729 retval
= jtagspi_write_enable(bank
);
730 if (retval
!= ERROR_OK
)
733 /* ATXP032/064/128 use always 4-byte addresses except for 0x03 read */
734 unsigned int addr_len
= ((info
->dev
.read_cmd
!= 0x03) && info
->always_4byte
) ? 4 : info
->addr_len
;
736 retval
= jtagspi_cmd(bank
, info
->dev
.pprog_cmd
, fill_addr(offset
, addr_len
, addr
),
737 addr_len
, (uint8_t *) buffer
, count
);
738 if (retval
!= ERROR_OK
)
740 return jtagspi_wait(bank
, JTAGSPI_MAX_TIMEOUT
);
743 static int jtagspi_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
745 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
746 uint32_t pagesize
, currsize
;
749 if (!(info
->probed
)) {
750 LOG_ERROR("Flash bank not probed.");
751 return ERROR_FLASH_BANK_NOT_PROBED
;
754 /* if no write pagesize, use reasonable default */
755 pagesize
= info
->dev
.pagesize
? info
->dev
.pagesize
: SPIFLASH_DEF_PAGESIZE
;
758 /* length up to end of current page */
759 currsize
= ((offset
+ pagesize
) & ~(pagesize
- 1)) - offset
;
760 /* but no more than remaining size */
761 currsize
= (count
< currsize
) ? count
: currsize
;
763 retval
= jtagspi_page_write(bank
, buffer
, offset
, currsize
);
764 if (retval
!= ERROR_OK
) {
765 LOG_ERROR("page write error");
768 LOG_DEBUG("wrote page at 0x%08" PRIx32
, offset
);
776 static int jtagspi_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
778 struct jtagspi_flash_bank
*info
= bank
->driver_priv
;
780 if (!(info
->probed
)) {
781 command_print_sameline(cmd
, "\nJTAGSPI flash bank not probed yet\n");
785 command_print_sameline(cmd
, "flash \'%s\', device id = 0x%06" PRIx32
786 ", flash size = %" PRIu32
" %sbytes\n(page size = %" PRIu32
787 ", read = 0x%02" PRIx8
", qread = 0x%02" PRIx8
788 ", pprog = 0x%02" PRIx8
", mass_erase = 0x%02" PRIx8
789 ", sector size = %" PRIu32
" %sbytes, sector_erase = 0x%02" PRIx8
")",
790 info
->dev
.name
, info
->dev
.device_id
& 0xFFFFFF,
791 bank
->size
/ 4096 ? bank
->size
/ 1024 : bank
->size
,
792 bank
->size
/ 4096 ? "k" : "", info
->dev
.pagesize
,
793 info
->dev
.read_cmd
, info
->dev
.qread_cmd
,
794 info
->dev
.pprog_cmd
, info
->dev
.chip_erase_cmd
,
795 info
->dev
.sectorsize
/ 4096 ?
796 info
->dev
.sectorsize
/ 1024 : info
->dev
.sectorsize
,
797 info
->dev
.sectorsize
/ 4096 ? "k" : "",
798 info
->dev
.erase_cmd
);
803 static const struct command_registration jtagspi_exec_command_handlers
[] = {
806 .handler
= jtagspi_handle_set
,
807 .mode
= COMMAND_EXEC
,
808 .usage
= "bank_id name chip_size page_size read_cmd unused pprg_cmd "
809 "[ mass_erase_cmd ] [ sector_size sector_erase_cmd ]",
810 .help
= "Set device parameters if not autodetected.",
814 .handler
= jtagspi_handle_cmd
,
815 .mode
= COMMAND_EXEC
,
816 .usage
= "bank_id num_resp cmd_byte ...",
817 .help
= "Send low-level command cmd_byte and following bytes, read num_bytes.",
820 .name
= "always_4byte",
821 .handler
= jtagspi_handle_always_4byte
,
822 .mode
= COMMAND_EXEC
,
823 .usage
= "bank_id [ on | off ]",
824 .help
= "Use always 4-byte address except for basic 0x03.",
827 COMMAND_REGISTRATION_DONE
830 static const struct command_registration jtagspi_command_handlers
[] = {
834 .help
= "jtagspi command group",
836 .chain
= jtagspi_exec_command_handlers
,
838 COMMAND_REGISTRATION_DONE
841 const struct flash_driver jtagspi_flash
= {
843 .commands
= jtagspi_command_handlers
,
844 .flash_bank_command
= jtagspi_flash_bank_command
,
845 .erase
= jtagspi_erase
,
846 .protect
= jtagspi_protect
,
847 .write
= jtagspi_write
,
848 .read
= jtagspi_read
,
849 .probe
= jtagspi_probe
,
850 .auto_probe
= jtagspi_auto_probe
,
851 .erase_check
= default_flash_blank_check
,
852 .info
= jtagspi_info
,
853 .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)