1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2022 by Daniel Anselmi *
6 ***************************************************************************/
13 #include <jtag/jtag.h>
15 #include "lattice_bit.h"
25 struct lattice_devices_elem
{
27 size_t preload_length
;
28 enum lattice_family_e family
;
31 static const struct lattice_devices_elem lattice_devices
[] = {
32 {0x01270043, 654, LATTICE_ECP2
/* ecp2-6e */},
33 {0x01271043, 643, LATTICE_ECP2
/* ecp2-12e */},
34 {0x01272043, 827, LATTICE_ECP2
/* ecp2-20e */},
35 {0x01274043, 1011, LATTICE_ECP2
/* ecp2-35e */},
36 {0x01273043, 1219, LATTICE_ECP2
/* ecp2-50e */},
37 {0x01275043, 654, LATTICE_ECP2
/* ecp2-70e */},
38 {0x01279043, 680, LATTICE_ECP2
/* ecp2m20e */},
39 {0x0127A043, 936, LATTICE_ECP2
/* ecp2m35e */},
40 {0x0127B043, 1056, LATTICE_ECP2
/* ecp2m50e */},
41 {0x0127C043, 1039, LATTICE_ECP2
/* ecp2m70e */},
42 {0x0127D043, 1311, LATTICE_ECP2
/* ecp2m100e */},
43 {0x01010043, 467, LATTICE_ECP3
/* ecp3 lae3-17ea & lfe3-17ea*/},
44 {0x01012043, 675, LATTICE_ECP3
/* ecp3 lae3-35ea & lfe3-35ea*/},
45 {0x01014043, 1077, LATTICE_ECP3
/* ecp3 lfe3-70ea & lfe3-70e & lfe3-95ea && lfe3-95e*/},
46 {0x01015043, 1326, LATTICE_ECP3
/* ecp3 lfe3-150e*/},
47 {0x21111043, 409, LATTICE_ECP5
/* "LAE5U-12F & LFE5U-12F" */},
48 {0x41111043, 409, LATTICE_ECP5
/* "LFE5U-25F" */},
49 {0x41112043, 510, LATTICE_ECP5
/* "LFE5U-45F" */},
50 {0x41113043, 750, LATTICE_ECP5
/* "LFE5U-85F" */},
51 {0x81111043, 409, LATTICE_ECP5
/* "LFE5UM5G-25F" */},
52 {0x81112043, 510, LATTICE_ECP5
/* "LFE5UM5G-45F" */},
53 {0x81113043, 750, LATTICE_ECP5
/* "LFE5UM5G-85F" */},
54 {0x01111043, 409, LATTICE_ECP5
/* "LAE5UM-25F" */},
55 {0x01112043, 510, LATTICE_ECP5
/* "LAE5UM-45F" */},
56 {0x01113043, 750, LATTICE_ECP5
/* "LAE5UM-85F" */},
57 {0x310f0043, 362, LATTICE_CERTUS
/* LFD2NX-17 */},
58 {0x310f1043, 362, LATTICE_CERTUS
/* LFD2NX-40 */},
59 {0x010f4043, 362, LATTICE_CERTUS
/* LFCPNX-100 */},
62 int lattice_set_instr(struct jtag_tap
*tap
, uint8_t new_instr
, tap_state_t endstate
)
64 struct scan_field field
;
65 field
.num_bits
= tap
->ir_length
;
66 void *t
= calloc(DIV_ROUND_UP(field
.num_bits
, 8), 1);
68 LOG_ERROR("Out of memory");
72 buf_set_u32(t
, 0, field
.num_bits
, new_instr
);
73 field
.in_value
= NULL
;
74 jtag_add_ir_scan(tap
, &field
, endstate
);
79 static int lattice_check_device_family(struct lattice_pld_device
*lattice_device
)
81 if (lattice_device
->family
!= LATTICE_UNKNOWN
&& lattice_device
->preload_length
!= 0)
84 if (!lattice_device
->tap
|| !lattice_device
->tap
->hasidcode
)
87 for (size_t i
= 0; i
< ARRAY_SIZE(lattice_devices
); ++i
) {
88 if (lattice_devices
[i
].id
== lattice_device
->tap
->idcode
) {
89 if (lattice_device
->family
== LATTICE_UNKNOWN
)
90 lattice_device
->family
= lattice_devices
[i
].family
;
91 if (lattice_device
->preload_length
== 0)
92 lattice_device
->preload_length
= lattice_devices
[i
].preload_length
;
96 LOG_ERROR("Unknown id! Specify family and preload-length manually.");
100 int lattice_read_u32_register(struct jtag_tap
*tap
, uint8_t cmd
, uint32_t *in_val
,
101 uint32_t out_val
, bool do_idle
)
103 struct scan_field field
;
106 int retval
= lattice_set_instr(tap
, cmd
, TAP_IDLE
);
107 if (retval
!= ERROR_OK
)
110 jtag_add_runtest(2, TAP_IDLE
);
111 jtag_add_sleep(1000);
114 h_u32_to_le(buffer
, out_val
);
116 field
.out_value
= buffer
;
117 field
.in_value
= buffer
;
118 jtag_add_dr_scan(tap
, 1, &field
, TAP_IDLE
);
119 retval
= jtag_execute_queue();
120 if (retval
== ERROR_OK
)
121 *in_val
= le_to_h_u32(buffer
);
126 int lattice_read_u64_register(struct jtag_tap
*tap
, uint8_t cmd
, uint64_t *in_val
,
129 struct scan_field field
;
132 int retval
= lattice_set_instr(tap
, cmd
, TAP_IDLE
);
133 if (retval
!= ERROR_OK
)
135 h_u64_to_le(buffer
, out_val
);
137 field
.out_value
= buffer
;
138 field
.in_value
= buffer
;
139 jtag_add_dr_scan(tap
, 1, &field
, TAP_IDLE
);
140 retval
= jtag_execute_queue();
141 if (retval
== ERROR_OK
)
142 *in_val
= le_to_h_u64(buffer
);
147 int lattice_preload(struct lattice_pld_device
*lattice_device
)
149 struct scan_field field
;
150 size_t sz_bytes
= DIV_ROUND_UP(lattice_device
->preload_length
, 8);
152 int retval
= lattice_set_instr(lattice_device
->tap
, PRELOAD
, TAP_IDLE
);
153 if (retval
!= ERROR_OK
)
155 uint8_t *buffer
= malloc(sz_bytes
);
157 LOG_ERROR("Out of memory");
160 memset(buffer
, 0xff, sz_bytes
);
162 field
.num_bits
= lattice_device
->preload_length
;
163 field
.out_value
= buffer
;
164 field
.in_value
= NULL
;
165 jtag_add_dr_scan(lattice_device
->tap
, 1, &field
, TAP_IDLE
);
166 retval
= jtag_execute_queue();
171 static int lattice_read_usercode(struct lattice_pld_device
*lattice_device
, uint32_t *usercode
, uint32_t out
)
173 struct jtag_tap
*tap
= lattice_device
->tap
;
177 if (lattice_device
->family
== LATTICE_ECP2
|| lattice_device
->family
== LATTICE_ECP3
)
178 return lattice_ecp2_3_read_usercode(tap
, usercode
, out
);
179 else if (lattice_device
->family
== LATTICE_ECP5
)
180 return lattice_ecp5_read_usercode(tap
, usercode
, out
);
181 else if (lattice_device
->family
== LATTICE_CERTUS
)
182 return lattice_certus_read_usercode(tap
, usercode
, out
);
187 int lattice_verify_usercode(struct lattice_pld_device
*lattice_device
, uint32_t out
,
188 uint32_t expected
, uint32_t mask
)
192 int retval
= lattice_read_usercode(lattice_device
, &usercode
, out
);
193 if (retval
!= ERROR_OK
)
196 if ((usercode
& mask
) != expected
) {
197 LOG_ERROR("verifying user code register failed got: 0x%08" PRIx32
" expected: 0x%08" PRIx32
,
198 usercode
& mask
, expected
);
204 static int lattice_write_usercode(struct lattice_pld_device
*lattice_device
, uint32_t usercode
)
206 if (lattice_device
->family
== LATTICE_ECP2
|| lattice_device
->family
== LATTICE_ECP3
)
207 return lattice_ecp2_3_write_usercode(lattice_device
, usercode
);
208 else if (lattice_device
->family
== LATTICE_ECP5
)
209 return lattice_ecp5_write_usercode(lattice_device
, usercode
);
210 else if (lattice_device
->family
== LATTICE_CERTUS
)
211 return lattice_certus_write_usercode(lattice_device
, usercode
);
216 static int lattice_read_status_u32(struct lattice_pld_device
*lattice_device
, uint32_t *status
,
217 uint32_t out
, bool do_idle
)
219 if (!lattice_device
->tap
)
222 if (lattice_device
->family
== LATTICE_ECP2
|| lattice_device
->family
== LATTICE_ECP3
)
223 return lattice_ecp2_3_read_status(lattice_device
->tap
, status
, out
, do_idle
);
224 else if (lattice_device
->family
== LATTICE_ECP5
)
225 return lattice_ecp5_read_status(lattice_device
->tap
, status
, out
, do_idle
);
229 static int lattice_read_status_u64(struct lattice_pld_device
*lattice_device
, uint64_t *status
,
232 if (!lattice_device
->tap
)
235 if (lattice_device
->family
== LATTICE_CERTUS
)
236 return lattice_certus_read_status(lattice_device
->tap
, status
, out
);
241 int lattice_verify_status_register_u32(struct lattice_pld_device
*lattice_device
, uint32_t out
,
242 uint32_t expected
, uint32_t mask
, bool do_idle
)
245 int retval
= lattice_read_status_u32(lattice_device
, &status
, out
, do_idle
);
246 if (retval
!= ERROR_OK
)
249 if ((status
& mask
) != expected
) {
250 LOG_ERROR("verifying status register failed got: 0x%08" PRIx32
" expected: 0x%08" PRIx32
,
251 status
& mask
, expected
);
257 int lattice_verify_status_register_u64(struct lattice_pld_device
*lattice_device
, uint64_t out
,
258 uint64_t expected
, uint64_t mask
)
261 int retval
= lattice_read_status_u64(lattice_device
, &status
, out
);
262 if (retval
!= ERROR_OK
)
265 if ((status
& mask
) != expected
) {
266 LOG_ERROR("verifying status register failed got: 0x%08" PRIx64
" expected: 0x%08" PRIx64
,
267 status
& mask
, expected
);
273 static int lattice_load_command(struct pld_device
*pld_device
, const char *filename
)
278 struct lattice_pld_device
*lattice_device
= pld_device
->driver_priv
;
279 if (!lattice_device
|| !lattice_device
->tap
)
281 struct jtag_tap
*tap
= lattice_device
->tap
;
283 if (!tap
|| !tap
->hasidcode
)
286 int retval
= lattice_check_device_family(lattice_device
);
287 if (retval
!= ERROR_OK
)
290 struct lattice_bit_file bit_file
;
291 retval
= lattice_read_file(&bit_file
, filename
, lattice_device
->family
);
292 if (retval
!= ERROR_OK
)
295 uint32_t id
= tap
->idcode
;
297 switch (lattice_device
->family
) {
299 retval
= lattice_ecp2_load(lattice_device
, &bit_file
);
302 retval
= lattice_ecp3_load(lattice_device
, &bit_file
);
306 if (bit_file
.has_id
&& id
!= bit_file
.idcode
)
307 LOG_WARNING("Id on device (0x%8.8" PRIx32
") and id in bit-stream (0x%8.8" PRIx32
") don't match.",
308 id
, bit_file
.idcode
);
309 if (lattice_device
->family
== LATTICE_ECP5
)
310 retval
= lattice_ecp5_load(lattice_device
, &bit_file
);
312 retval
= lattice_certus_load(lattice_device
, &bit_file
);
315 LOG_ERROR("loading unknown device family");
318 free(bit_file
.raw_bit
.data
);
322 int lattice_get_ipdbg_hub(int user_num
, struct pld_device
*pld_device
, struct pld_ipdbg_hub
*hub
)
327 struct lattice_pld_device
*pld_device_info
= pld_device
->driver_priv
;
329 if (!pld_device_info
|| !pld_device_info
->tap
)
332 hub
->tap
= pld_device_info
->tap
;
335 hub
->user_ir_code
= USER1
;
336 } else if (user_num
== 2) {
337 hub
->user_ir_code
= USER2
;
339 LOG_ERROR("lattice devices only have user register 1 & 2");
345 PLD_CREATE_COMMAND_HANDLER(lattice_pld_create_command
)
347 if (CMD_ARGC
!= 4 && CMD_ARGC
!= 6)
348 return ERROR_COMMAND_SYNTAX_ERROR
;
350 if (strcmp(CMD_ARGV
[2], "-chain-position") != 0)
351 return ERROR_COMMAND_SYNTAX_ERROR
;
353 struct jtag_tap
*tap
= jtag_tap_by_string(CMD_ARGV
[3]);
355 command_print(CMD
, "Tap: %s does not exist", CMD_ARGV
[3]);
359 /* id is not known yet -> postpone lattice_check_device_family() */
360 enum lattice_family_e family
= LATTICE_UNKNOWN
;
362 if (strcmp(CMD_ARGV
[4], "-family") != 0)
363 return ERROR_COMMAND_SYNTAX_ERROR
;
365 if (strcasecmp(CMD_ARGV
[5], "ecp2") == 0) {
366 family
= LATTICE_ECP2
;
367 } else if (strcasecmp(CMD_ARGV
[5], "ecp3") == 0) {
368 family
= LATTICE_ECP3
;
369 } else if (strcasecmp(CMD_ARGV
[5], "ecp5") == 0) {
370 family
= LATTICE_ECP5
;
371 } else if (strcasecmp(CMD_ARGV
[5], "certus") == 0) {
372 family
= LATTICE_CERTUS
;
374 command_print(CMD
, "unknown family");
379 struct lattice_pld_device
*lattice_device
= malloc(sizeof(struct lattice_pld_device
));
380 if (!lattice_device
) {
381 LOG_ERROR("Out of memory");
385 lattice_device
->tap
= tap
;
386 lattice_device
->family
= family
;
387 lattice_device
->preload_length
= 0;
389 pld
->driver_priv
= lattice_device
;
394 COMMAND_HANDLER(lattice_read_usercode_register_command_handler
)
399 return ERROR_COMMAND_SYNTAX_ERROR
;
401 struct pld_device
*device
= get_pld_device_by_name_or_numstr(CMD_ARGV
[0]);
403 command_print(CMD
, "pld device '#%s' is out of bounds or unknown", CMD_ARGV
[0]);
407 struct lattice_pld_device
*lattice_device
= device
->driver_priv
;
411 int retval
= lattice_check_device_family(lattice_device
);
412 if (retval
!= ERROR_OK
)
415 retval
= lattice_read_usercode(lattice_device
, &usercode
, 0x0);
416 if (retval
== ERROR_OK
)
417 command_print(CMD
, "0x%8.8" PRIx32
, usercode
);
422 COMMAND_HANDLER(lattice_set_preload_command_handler
)
424 unsigned int preload_length
;
427 return ERROR_COMMAND_SYNTAX_ERROR
;
429 struct pld_device
*device
= get_pld_device_by_name_or_numstr(CMD_ARGV
[0]);
431 command_print(CMD
, "pld device '#%s' is out of bounds or unknown", CMD_ARGV
[0]);
435 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[1], preload_length
);
437 struct lattice_pld_device
*lattice_device
= device
->driver_priv
;
442 lattice_device
->preload_length
= preload_length
;
447 COMMAND_HANDLER(lattice_write_usercode_register_command_handler
)
452 return ERROR_COMMAND_SYNTAX_ERROR
;
454 struct pld_device
*device
= get_pld_device_by_name_or_numstr(CMD_ARGV
[0]);
456 command_print(CMD
, "pld device '#%s' is out of bounds or unknown", CMD_ARGV
[0]);
460 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], usercode
);
462 struct lattice_pld_device
*lattice_device
= device
->driver_priv
;
466 int retval
= lattice_check_device_family(lattice_device
);
467 if (retval
!= ERROR_OK
)
470 return lattice_write_usercode(lattice_device
, usercode
);
473 COMMAND_HANDLER(lattice_read_status_command_handler
)
476 return ERROR_COMMAND_SYNTAX_ERROR
;
478 struct pld_device
*device
= get_pld_device_by_name_or_numstr(CMD_ARGV
[0]);
480 command_print(CMD
, "pld device '#%s' is out of bounds or unknown", CMD_ARGV
[0]);
484 struct lattice_pld_device
*lattice_device
= device
->driver_priv
;
488 int retval
= lattice_check_device_family(lattice_device
);
489 if (retval
!= ERROR_OK
)
492 if (lattice_device
->family
== LATTICE_CERTUS
) {
494 retval
= lattice_read_status_u64(lattice_device
, &status
, 0x0);
495 if (retval
== ERROR_OK
)
496 command_print(CMD
, "0x%016" PRIx64
, status
);
499 const bool do_idle
= lattice_device
->family
== LATTICE_ECP5
;
500 retval
= lattice_read_status_u32(lattice_device
, &status
, 0x0, do_idle
);
501 if (retval
== ERROR_OK
)
502 command_print(CMD
, "0x%8.8" PRIx32
, status
);
508 static const struct command_registration lattice_exec_command_handlers
[] = {
510 .name
= "read_status",
511 .mode
= COMMAND_EXEC
,
512 .handler
= lattice_read_status_command_handler
,
513 .help
= "reading status register from FPGA",
517 .mode
= COMMAND_EXEC
,
518 .handler
= lattice_read_usercode_register_command_handler
,
519 .help
= "reading usercode register from FPGA",
522 .name
= "write_user",
523 .mode
= COMMAND_EXEC
,
524 .handler
= lattice_write_usercode_register_command_handler
,
525 .help
= "writing usercode register to FPGA",
526 .usage
= "pld_name value",
528 .name
= "set_preload",
529 .mode
= COMMAND_EXEC
,
530 .handler
= lattice_set_preload_command_handler
,
531 .help
= "set length for preload (device specific)",
532 .usage
= "pld_name value",
534 COMMAND_REGISTRATION_DONE
537 static const struct command_registration lattice_command_handler
[] = {
541 .help
= "lattice specific commands",
543 .chain
= lattice_exec_command_handlers
,
545 COMMAND_REGISTRATION_DONE
548 struct pld_driver lattice_pld
= {
550 .commands
= lattice_command_handler
,
551 .pld_create_command
= &lattice_pld_create_command
,
552 .load
= &lattice_load_command
,
553 .get_ipdbg_hub
= lattice_get_ipdbg_hub
,