blob: 9641ed307b7527b757bb7cd7f863902625397489 [file] [log] [blame]
Michal Simek014d3042019-01-21 15:25:02 +01001// SPDX-License-Identifier: GPL-2.0+
2/*
Michal Simek53f44362023-01-06 09:38:52 +01003 * (C) Copyright 2014 - 2022, Xilinx, Inc.
4 * (C) Copyright 2022 - 2023, Advanced Micro Devices, Inc.
5 *
6 * Michal Simek <michal.simek@amd.com>
Michal Simek014d3042019-01-21 15:25:02 +01007 */
8
9#include <common.h>
Sughosh Ganuccb36462022-04-15 11:29:34 +053010#include <efi.h>
11#include <efi_loader.h>
Simon Glassed38aef2020-05-10 11:40:03 -060012#include <env.h>
Michal Simekaa975612022-08-25 14:23:10 +020013#include <image.h>
Algapally Santosh Sagard1c1b1e2023-01-19 22:36:14 -070014#include <init.h>
Michal Simekaa975612022-08-25 14:23:10 +020015#include <lmb.h>
Simon Glass0f2af882020-05-10 11:40:05 -060016#include <log.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060017#include <asm/global_data.h>
Michal Simek878ba362019-12-19 17:45:15 +010018#include <asm/sections.h>
Michal Simek014d3042019-01-21 15:25:02 +010019#include <dm/uclass.h>
20#include <i2c.h>
Michal Simekb90b97e2020-04-08 10:51:36 +020021#include <linux/sizes.h>
Michal Simek394ee242020-08-03 13:01:45 +020022#include <malloc.h>
Michal Simek705d44a2020-03-31 12:39:37 +020023#include "board.h"
Michal Simek394ee242020-08-03 13:01:45 +020024#include <dm.h>
25#include <i2c_eeprom.h>
26#include <net.h>
Michal Simekfe49df92020-10-26 12:26:13 +010027#include <generated/dt.h>
Venkatesh Yadav Abbarapue8e3c902024-01-17 08:50:13 +053028#include <rng.h>
Michal Simek53f44362023-01-06 09:38:52 +010029#include <slre.h>
T Karthik Reddyc8fa40a2021-08-10 06:50:20 -060030#include <soc.h>
Michal Simeke0453512021-08-11 14:23:54 +020031#include <linux/ctype.h>
Sughosh Ganuccb36462022-04-15 11:29:34 +053032#include <linux/kernel.h>
Michal Simek7459d4a2022-07-21 16:19:17 +020033#include <uuid.h>
Michal Simek014d3042019-01-21 15:25:02 +010034
Michal Simek207e0622020-08-03 16:14:23 +020035#include "fru.h"
36
Simon Glassb8196212023-02-05 15:39:42 -070037#if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT)
Sughosh Ganuccb36462022-04-15 11:29:34 +053038struct efi_fw_image fw_images[] = {
39#if defined(XILINX_BOOT_IMAGE_GUID)
40 {
41 .image_type_id = XILINX_BOOT_IMAGE_GUID,
42 .fw_name = u"XILINX-BOOT",
43 .image_index = 1,
44 },
45#endif
46#if defined(XILINX_UBOOT_IMAGE_GUID)
47 {
48 .image_type_id = XILINX_UBOOT_IMAGE_GUID,
49 .fw_name = u"XILINX-UBOOT",
50 .image_index = 2,
51 },
52#endif
53};
54
55struct efi_capsule_update_info update_info = {
Masahisa Kojima5d2438b2023-06-07 14:41:51 +090056 .num_images = ARRAY_SIZE(fw_images),
Sughosh Ganuccb36462022-04-15 11:29:34 +053057 .images = fw_images,
58};
59
Sughosh Ganuccb36462022-04-15 11:29:34 +053060#endif /* EFI_HAVE_CAPSULE_SUPPORT */
61
Michal Simek394ee242020-08-03 13:01:45 +020062#define EEPROM_HEADER_MAGIC 0xdaaddeed
63#define EEPROM_HDR_MANUFACTURER_LEN 16
64#define EEPROM_HDR_NAME_LEN 16
65#define EEPROM_HDR_REV_LEN 8
66#define EEPROM_HDR_SERIAL_LEN 20
67#define EEPROM_HDR_NO_OF_MAC_ADDR 4
68#define EEPROM_HDR_ETH_ALEN ETH_ALEN
Michal Simek7459d4a2022-07-21 16:19:17 +020069#define EEPROM_HDR_UUID_LEN 16
Michal Simek394ee242020-08-03 13:01:45 +020070
71struct xilinx_board_description {
72 u32 header;
73 char manufacturer[EEPROM_HDR_MANUFACTURER_LEN + 1];
74 char name[EEPROM_HDR_NAME_LEN + 1];
75 char revision[EEPROM_HDR_REV_LEN + 1];
76 char serial[EEPROM_HDR_SERIAL_LEN + 1];
77 u8 mac_addr[EEPROM_HDR_NO_OF_MAC_ADDR][EEPROM_HDR_ETH_ALEN + 1];
Michal Simek7459d4a2022-07-21 16:19:17 +020078 char uuid[EEPROM_HDR_UUID_LEN + 1];
Michal Simek394ee242020-08-03 13:01:45 +020079};
80
Michal Simek0bb24e12020-08-03 12:57:05 +020081static int highest_id = -1;
Michal Simeke98ae1d2021-08-12 12:30:36 +020082static struct xilinx_board_description *board_info;
Michal Simek394ee242020-08-03 13:01:45 +020083
Michal Simek207e0622020-08-03 16:14:23 +020084#define XILINX_I2C_DETECTION_BITS sizeof(struct fru_common_hdr)
Michal Simek394ee242020-08-03 13:01:45 +020085
86/* Variable which stores pointer to array which stores eeprom content */
87struct xilinx_legacy_format {
88 char board_sn[18]; /* 0x0 */
89 char unused0[14]; /* 0x12 */
Michal Simekb2df1df2023-01-24 16:19:26 +010090 char eth_mac[ETH_ALEN]; /* 0x20 */
Michal Simek394ee242020-08-03 13:01:45 +020091 char unused1[170]; /* 0x26 */
92 char board_name[11]; /* 0xd0 */
93 char unused2[5]; /* 0xdc */
94 char board_revision[3]; /* 0xe0 */
95 char unused3[29]; /* 0xe3 */
96};
97
98static void xilinx_eeprom_legacy_cleanup(char *eeprom, int size)
99{
100 int i;
Venkatesh Yadav Abbarapu3be370d2022-09-26 12:22:42 +0530101 unsigned char byte;
Michal Simek394ee242020-08-03 13:01:45 +0200102
103 for (i = 0; i < size; i++) {
104 byte = eeprom[i];
105
Michal Simekd432cbb2023-01-24 16:19:27 +0100106 /* Remove all non printable chars but ignore MAC address */
107 if ((i < offsetof(struct xilinx_legacy_format, eth_mac) ||
108 i >= offsetof(struct xilinx_legacy_format, unused1)) &&
109 (byte < '!' || byte > '~')) {
Michal Simek394ee242020-08-03 13:01:45 +0200110 eeprom[i] = 0;
Michal Simekd432cbb2023-01-24 16:19:27 +0100111 continue;
112 }
Michal Simek394ee242020-08-03 13:01:45 +0200113
114 /* Convert strings to lower case */
115 if (byte >= 'A' && byte <= 'Z')
116 eeprom[i] = byte + 'a' - 'A';
117 }
118}
119
120static int xilinx_read_eeprom_legacy(struct udevice *dev, char *name,
121 struct xilinx_board_description *desc)
122{
123 int ret, size;
124 struct xilinx_legacy_format *eeprom_content;
125 bool eth_valid = false;
126
127 size = sizeof(*eeprom_content);
128
129 eeprom_content = calloc(1, size);
130 if (!eeprom_content)
131 return -ENOMEM;
132
133 debug("%s: I2C EEPROM read pass data at %p\n", __func__,
134 eeprom_content);
135
136 ret = dm_i2c_read(dev, 0, (uchar *)eeprom_content, size);
137 if (ret) {
138 debug("%s: I2C EEPROM read failed\n", __func__);
139 free(eeprom_content);
140 return ret;
141 }
142
143 xilinx_eeprom_legacy_cleanup((char *)eeprom_content, size);
144
Michal Simekdaccab22023-01-24 16:19:28 +0100145 /* Terminating \0 chars are the part of desc fields already */
146 strlcpy(desc->name, eeprom_content->board_name,
147 sizeof(eeprom_content->board_name) + 1);
148 strlcpy(desc->revision, eeprom_content->board_revision,
149 sizeof(eeprom_content->board_revision) + 1);
150 strlcpy(desc->serial, eeprom_content->board_sn,
151 sizeof(eeprom_content->board_sn) + 1);
Michal Simek394ee242020-08-03 13:01:45 +0200152
153 eth_valid = is_valid_ethaddr((const u8 *)eeprom_content->eth_mac);
154 if (eth_valid)
Michal Simekdaccab22023-01-24 16:19:28 +0100155 memcpy(desc->mac_addr[0], eeprom_content->eth_mac, ETH_ALEN);
Michal Simek394ee242020-08-03 13:01:45 +0200156
Michal Simekdaccab22023-01-24 16:19:28 +0100157 printf("Xilinx I2C Legacy format at %s:\n", name);
158 printf(" Board name:\t%s\n", desc->name);
159 printf(" Board rev:\t%s\n", desc->revision);
160 printf(" Board SN:\t%s\n", desc->serial);
161
Michal Simek394ee242020-08-03 13:01:45 +0200162 if (eth_valid)
Michal Simekdaccab22023-01-24 16:19:28 +0100163 printf(" Ethernet mac:\t%pM\n", desc->mac_addr);
Michal Simek394ee242020-08-03 13:01:45 +0200164
165 desc->header = EEPROM_HEADER_MAGIC;
166
167 free(eeprom_content);
168
169 return ret;
170}
171
172static bool xilinx_detect_legacy(u8 *buffer)
173{
174 int i;
175 char c;
176
177 for (i = 0; i < XILINX_I2C_DETECTION_BITS; i++) {
178 c = buffer[i];
179
180 if (c < '0' || c > '9')
181 return false;
182 }
183
184 return true;
185}
186
Michal Simek207e0622020-08-03 16:14:23 +0200187static int xilinx_read_eeprom_fru(struct udevice *dev, char *name,
188 struct xilinx_board_description *desc)
189{
Michal Simekbe5f5722021-08-12 11:03:49 +0200190 int i, ret, eeprom_size;
Michal Simek207e0622020-08-03 16:14:23 +0200191 u8 *fru_content;
Ashok Reddy Soma9f60e442022-02-23 15:00:59 +0100192 u8 id = 0;
Michal Simek207e0622020-08-03 16:14:23 +0200193
194 /* FIXME this is shortcut - if eeprom type is wrong it will fail */
195 eeprom_size = i2c_eeprom_size(dev);
196
197 fru_content = calloc(1, eeprom_size);
198 if (!fru_content)
199 return -ENOMEM;
200
201 debug("%s: I2C EEPROM read pass data at %p\n", __func__,
202 fru_content);
203
204 ret = dm_i2c_read(dev, 0, (uchar *)fru_content,
205 eeprom_size);
206 if (ret) {
207 debug("%s: I2C EEPROM read failed\n", __func__);
Michal Simekaada8a62021-08-13 09:17:10 +0200208 goto end;
Michal Simek207e0622020-08-03 16:14:23 +0200209 }
210
Michal Simek207e0622020-08-03 16:14:23 +0200211 fru_capture((unsigned long)fru_content);
Simon Glassd2c5a3d2023-02-05 15:39:38 -0700212 if (gd->flags & GD_FLG_RELOC || (_DEBUG && IS_ENABLED(CONFIG_DTB_RESELECT))) {
Michal Simeke0453512021-08-11 14:23:54 +0200213 printf("Xilinx I2C FRU format at %s:\n", name);
214 ret = fru_display(0);
215 if (ret) {
216 printf("FRU format decoding failed.\n");
217 goto end;
218 }
Michal Simek207e0622020-08-03 16:14:23 +0200219 }
220
221 if (desc->header == EEPROM_HEADER_MAGIC) {
222 debug("Information already filled\n");
Michal Simekaada8a62021-08-13 09:17:10 +0200223 ret = -EINVAL;
224 goto end;
Michal Simek207e0622020-08-03 16:14:23 +0200225 }
226
227 /* It is clear that FRU was captured and structures were filled */
Michal Simekb5f206e2022-07-21 16:19:18 +0200228 strlcpy(desc->manufacturer, (char *)fru_data.brd.manufacturer_name,
Michal Simek207e0622020-08-03 16:14:23 +0200229 sizeof(desc->manufacturer));
Michal Simekb5f206e2022-07-21 16:19:18 +0200230 strlcpy(desc->uuid, (char *)fru_data.brd.uuid,
Michal Simek7459d4a2022-07-21 16:19:17 +0200231 sizeof(desc->uuid));
Michal Simekb5f206e2022-07-21 16:19:18 +0200232 strlcpy(desc->name, (char *)fru_data.brd.product_name,
Michal Simek207e0622020-08-03 16:14:23 +0200233 sizeof(desc->name));
Michal Simekbe5f5722021-08-12 11:03:49 +0200234 for (i = 0; i < sizeof(desc->name); i++) {
235 if (desc->name[i] == ' ')
236 desc->name[i] = '\0';
237 }
Michal Simekb5f206e2022-07-21 16:19:18 +0200238 strlcpy(desc->revision, (char *)fru_data.brd.rev,
Michal Simek207e0622020-08-03 16:14:23 +0200239 sizeof(desc->revision));
Michal Simek904fb972022-06-06 09:31:27 +0200240 for (i = 0; i < sizeof(desc->revision); i++) {
241 if (desc->revision[i] == ' ')
242 desc->revision[i] = '\0';
243 }
Michal Simekb5f206e2022-07-21 16:19:18 +0200244 strlcpy(desc->serial, (char *)fru_data.brd.serial_number,
Michal Simek207e0622020-08-03 16:14:23 +0200245 sizeof(desc->serial));
Ashok Reddy Soma9f60e442022-02-23 15:00:59 +0100246
247 while (id < EEPROM_HDR_NO_OF_MAC_ADDR) {
248 if (is_valid_ethaddr((const u8 *)fru_data.mac.macid[id]))
249 memcpy(&desc->mac_addr[id],
250 (char *)fru_data.mac.macid[id], ETH_ALEN);
251 id++;
252 }
253
Michal Simek207e0622020-08-03 16:14:23 +0200254 desc->header = EEPROM_HEADER_MAGIC;
255
Michal Simekaada8a62021-08-13 09:17:10 +0200256end:
257 free(fru_content);
258 return ret;
Michal Simek207e0622020-08-03 16:14:23 +0200259}
260
261static bool xilinx_detect_fru(u8 *buffer)
262{
263 u8 checksum = 0;
264 int i;
265
266 checksum = fru_checksum((u8 *)buffer, sizeof(struct fru_common_hdr));
267 if (checksum) {
268 debug("%s Common header CRC FAIL\n", __func__);
269 return false;
270 }
271
272 bool all_zeros = true;
273 /* Checksum over all zeros is also zero that's why detect this case */
274 for (i = 0; i < sizeof(struct fru_common_hdr); i++) {
275 if (buffer[i] != 0)
276 all_zeros = false;
277 }
278
279 if (all_zeros)
280 return false;
281
282 debug("%s Common header CRC PASS\n", __func__);
283 return true;
284}
285
Michal Simek394ee242020-08-03 13:01:45 +0200286static int xilinx_read_eeprom_single(char *name,
287 struct xilinx_board_description *desc)
288{
289 int ret;
290 struct udevice *dev;
291 ofnode eeprom;
292 u8 buffer[XILINX_I2C_DETECTION_BITS];
293
294 eeprom = ofnode_get_aliases_node(name);
295 if (!ofnode_valid(eeprom))
296 return -ENODEV;
297
298 ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, eeprom, &dev);
299 if (ret)
300 return ret;
301
302 ret = dm_i2c_read(dev, 0, buffer, sizeof(buffer));
303 if (ret) {
304 debug("%s: I2C EEPROM read failed\n", __func__);
305 return ret;
306 }
307
308 debug("%s: i2c memory detected: %s\n", __func__, name);
309
Simon Glass631bec22023-02-05 15:36:31 -0700310 if (IS_ENABLED(CONFIG_CMD_FRU) && xilinx_detect_fru(buffer))
Michal Simek207e0622020-08-03 16:14:23 +0200311 return xilinx_read_eeprom_fru(dev, name, desc);
312
Michal Simek394ee242020-08-03 13:01:45 +0200313 if (xilinx_detect_legacy(buffer))
314 return xilinx_read_eeprom_legacy(dev, name, desc);
315
316 return -ENODEV;
317}
318
319__maybe_unused int xilinx_read_eeprom(void)
320{
Michal Simeke98ae1d2021-08-12 12:30:36 +0200321 int id;
Michal Simek394ee242020-08-03 13:01:45 +0200322 char name_buf[8]; /* 8 bytes should be enough for nvmem+number */
Michal Simek0bb24e12020-08-03 12:57:05 +0200323 struct xilinx_board_description *desc;
Michal Simek394ee242020-08-03 13:01:45 +0200324
325 highest_id = dev_read_alias_highest_id("nvmem");
326 /* No nvmem aliases present */
327 if (highest_id < 0)
328 return -EINVAL;
329
Michal Simeke98ae1d2021-08-12 12:30:36 +0200330 board_info = calloc(1, sizeof(*desc) * (highest_id + 1));
Michal Simek394ee242020-08-03 13:01:45 +0200331 if (!board_info)
332 return -ENOMEM;
333
334 debug("%s: Highest ID %d, board_info %p\n", __func__,
335 highest_id, board_info);
336
337 for (id = 0; id <= highest_id; id++) {
338 snprintf(name_buf, sizeof(name_buf), "nvmem%d", id);
339
Michal Simek0bb24e12020-08-03 12:57:05 +0200340 /* Alloc structure */
Michal Simeke98ae1d2021-08-12 12:30:36 +0200341 desc = &board_info[id];
Michal Simek0bb24e12020-08-03 12:57:05 +0200342
Michal Simek394ee242020-08-03 13:01:45 +0200343 /* Ignoring return value for supporting multiple chips */
Michal Simeke98ae1d2021-08-12 12:30:36 +0200344 xilinx_read_eeprom_single(name_buf, desc);
Michal Simek394ee242020-08-03 13:01:45 +0200345 }
346
Michal Simek0bb24e12020-08-03 12:57:05 +0200347 /*
348 * Consider to clean board_info structure when board/cards are not
349 * detected.
350 */
Michal Simek394ee242020-08-03 13:01:45 +0200351
352 return 0;
353}
354
Michal Simek1a505292022-02-17 14:28:38 +0100355#if defined(CONFIG_OF_BOARD)
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300356void *board_fdt_blob_setup(int *err)
Ibai Erkiaga6f658202019-10-02 15:57:36 +0100357{
Michal Simekddf69ae2020-09-04 16:21:47 +0200358 void *fdt_blob;
Michal Simekc89f4292020-03-19 10:23:56 +0100359
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300360 *err = 0;
Michal Simek663c1622021-01-04 11:07:28 +0100361 if (!IS_ENABLED(CONFIG_SPL_BUILD) &&
362 !IS_ENABLED(CONFIG_VERSAL_NO_DDR) &&
Michal Simek6d4317b2021-02-02 13:33:22 +0100363 !IS_ENABLED(CONFIG_ZYNQMP_NO_DDR)) {
Michal Simek9b9d01e2021-01-04 11:03:36 +0100364 fdt_blob = (void *)CONFIG_XILINX_OF_BOARD_DTB_ADDR;
Ibai Erkiaga6f658202019-10-02 15:57:36 +0100365
Michal Simek9b9d01e2021-01-04 11:03:36 +0100366 if (fdt_magic(fdt_blob) == FDT_MAGIC)
367 return fdt_blob;
Michal Simek878ba362019-12-19 17:45:15 +0100368
Michal Simek9b9d01e2021-01-04 11:03:36 +0100369 debug("DTB is not passed via %p\n", fdt_blob);
370 }
Michal Simek878ba362019-12-19 17:45:15 +0100371
Michal Simek9b9d01e2021-01-04 11:03:36 +0100372 if (IS_ENABLED(CONFIG_SPL_BUILD)) {
373 /*
374 * FDT is at end of BSS unless it is in a different memory
375 * region
376 */
377 if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS))
Shiji Yangeff11fa2023-08-03 09:47:17 +0800378 fdt_blob = (ulong *)_image_binary_end;
Michal Simek9b9d01e2021-01-04 11:03:36 +0100379 else
Shiji Yangeff11fa2023-08-03 09:47:17 +0800380 fdt_blob = (ulong *)__bss_end;
Michal Simek9b9d01e2021-01-04 11:03:36 +0100381 } else {
382 /* FDT is at end of image */
Shiji Yangeff11fa2023-08-03 09:47:17 +0800383 fdt_blob = (ulong *)_end;
Michal Simek9b9d01e2021-01-04 11:03:36 +0100384 }
Michal Simek878ba362019-12-19 17:45:15 +0100385
386 if (fdt_magic(fdt_blob) == FDT_MAGIC)
387 return fdt_blob;
388
389 debug("DTB is also not passed via %p\n", fdt_blob);
Ibai Erkiaga6f658202019-10-02 15:57:36 +0100390
Michal Simek1a505292022-02-17 14:28:38 +0100391 *err = -EINVAL;
Michal Simek878ba362019-12-19 17:45:15 +0100392 return NULL;
Ibai Erkiaga6f658202019-10-02 15:57:36 +0100393}
394#endif
Michal Simek705d44a2020-03-31 12:39:37 +0200395
Michal Simek67ed85d2020-10-22 11:14:20 +0200396#if defined(CONFIG_BOARD_LATE_INIT)
Michal Simek0bb24e12020-08-03 12:57:05 +0200397static int env_set_by_index(const char *name, int index, char *data)
398{
399 char var[32];
400
401 if (!index)
402 sprintf(var, "board_%s", name);
403 else
404 sprintf(var, "card%d_%s", index, name);
405
406 return env_set(var, data);
407}
408
Michal Simek705d44a2020-03-31 12:39:37 +0200409int board_late_init_xilinx(void)
410{
Michal Simekbd07b5d2020-08-12 12:16:49 +0200411 u32 ret = 0;
Michal Simek0bb24e12020-08-03 12:57:05 +0200412 int i, id, macid = 0;
413 struct xilinx_board_description *desc;
Ricardo Salvetid35ccf22022-01-20 16:17:30 -0300414 phys_size_t bootm_size = gd->ram_top - gd->ram_base;
Michal Simekbb70b772023-08-31 09:04:28 +0200415 u64 bootscr_flash_offset, bootscr_flash_size;
T Karthik Reddy17b7f662020-04-01 06:01:21 -0600416
Simon Glass117038a2023-02-05 15:40:14 -0700417 if (!IS_ENABLED(CONFIG_MICROBLAZE)) {
T Karthik Reddy17b7f662020-04-01 06:01:21 -0600418 ulong scriptaddr;
Algapally Santosh Sagar473705e2023-08-31 08:59:06 +0200419 u64 bootscr_address;
420 u64 bootscr_offset;
T Karthik Reddy17b7f662020-04-01 06:01:21 -0600421
Algapally Santosh Sagar473705e2023-08-31 08:59:06 +0200422 /* Fetch bootscr_address/bootscr_offset from DT and update */
423 if (!ofnode_read_bootscript_address(&bootscr_address,
424 &bootscr_offset)) {
425 if (bootscr_offset)
426 ret |= env_set_hex("scriptaddr",
427 gd->ram_base +
428 bootscr_offset);
429 else
430 ret |= env_set_hex("scriptaddr",
431 bootscr_address);
432 } else {
433 /* Update scriptaddr(bootscr offset) from env */
434 scriptaddr = env_get_hex("scriptaddr", 0);
435 ret |= env_set_hex("scriptaddr",
436 gd->ram_base + scriptaddr);
437 }
T Karthik Reddy17b7f662020-04-01 06:01:21 -0600438 }
Michal Simekc86ce0c2020-08-12 12:17:53 +0200439
Michal Simekbb70b772023-08-31 09:04:28 +0200440 if (!ofnode_read_bootscript_flash(&bootscr_flash_offset,
441 &bootscr_flash_size)) {
442 ret |= env_set_hex("script_offset_f", bootscr_flash_offset);
443 ret |= env_set_hex("script_size_f", bootscr_flash_size);
444 } else {
445 debug("!!! Please define bootscr-flash-offset via DT !!!\n");
446 ret |= env_set_hex("script_offset_f",
447 CONFIG_BOOT_SCRIPT_OFFSET);
448 }
449
Simon Glass117038a2023-02-05 15:40:14 -0700450 if (IS_ENABLED(CONFIG_ARCH_ZYNQ) || IS_ENABLED(CONFIG_MICROBLAZE))
Michal Simekc86ce0c2020-08-12 12:17:53 +0200451 bootm_size = min(bootm_size, (phys_size_t)(SZ_512M + SZ_256M));
Michal Simekbd07b5d2020-08-12 12:16:49 +0200452
Michal Simekbd07b5d2020-08-12 12:16:49 +0200453 ret |= env_set_addr("bootm_low", (void *)gd->ram_base);
Michal Simekc86ce0c2020-08-12 12:17:53 +0200454 ret |= env_set_addr("bootm_size", (void *)bootm_size);
Michal Simek705d44a2020-03-31 12:39:37 +0200455
Michal Simek0bb24e12020-08-03 12:57:05 +0200456 for (id = 0; id <= highest_id; id++) {
Michal Simeke98ae1d2021-08-12 12:30:36 +0200457 desc = &board_info[id];
Michal Simek0bb24e12020-08-03 12:57:05 +0200458 if (desc && desc->header == EEPROM_HEADER_MAGIC) {
459 if (desc->manufacturer[0])
460 ret |= env_set_by_index("manufacturer", id,
461 desc->manufacturer);
462 if (desc->name[0])
463 ret |= env_set_by_index("name", id,
464 desc->name);
465 if (desc->revision[0])
466 ret |= env_set_by_index("rev", id,
467 desc->revision);
468 if (desc->serial[0])
469 ret |= env_set_by_index("serial", id,
470 desc->serial);
Michal Simek394ee242020-08-03 13:01:45 +0200471
Michal Simek7459d4a2022-07-21 16:19:17 +0200472 if (desc->uuid[0]) {
Venkatesh Yadav Abbarapu3be370d2022-09-26 12:22:42 +0530473 unsigned char uuid[UUID_STR_LEN + 1];
474 unsigned char *t = desc->uuid;
Michal Simek7459d4a2022-07-21 16:19:17 +0200475
476 memset(uuid, 0, UUID_STR_LEN + 1);
477
478 sprintf(uuid, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
479 t[0], t[1], t[2], t[3], t[4], t[5],
480 t[6], t[7], t[8], t[9], t[10], t[11],
481 t[12], t[13], t[14], t[15]);
482 ret |= env_set_by_index("uuid", id, uuid);
483 }
484
Michal Simek394ee242020-08-03 13:01:45 +0200485 if (!CONFIG_IS_ENABLED(NET))
486 continue;
487
Michal Simek0bb24e12020-08-03 12:57:05 +0200488 for (i = 0; i < EEPROM_HDR_NO_OF_MAC_ADDR; i++) {
Michal Simek0bb24e12020-08-03 12:57:05 +0200489 if (is_valid_ethaddr((const u8 *)desc->mac_addr[i]))
490 ret |= eth_env_set_enetaddr_by_index("eth",
491 macid++, desc->mac_addr[i]);
492 }
Michal Simek394ee242020-08-03 13:01:45 +0200493 }
494 }
495
Michal Simekbd07b5d2020-08-12 12:16:49 +0200496 if (ret)
497 printf("%s: Saving run time variables FAILED\n", __func__);
Michal Simek8ba62d22020-07-09 15:57:56 +0200498
Michal Simek705d44a2020-03-31 12:39:37 +0200499 return 0;
500}
Michal Simek67ed85d2020-10-22 11:14:20 +0200501#endif
Michal Simekfe49df92020-10-26 12:26:13 +0100502
Michal Simekc88975e2021-07-23 09:55:59 +0200503static char *board_name = DEVICE_TREE;
504
Michal Simekfe49df92020-10-26 12:26:13 +0100505int __maybe_unused board_fit_config_name_match(const char *name)
506{
Michal Simekc88975e2021-07-23 09:55:59 +0200507 debug("%s: Check %s, default %s\n", __func__, name, board_name);
Michal Simekfe49df92020-10-26 12:26:13 +0100508
Michal Simek53f44362023-01-06 09:38:52 +0100509#if !defined(CONFIG_SPL_BUILD)
Simon Glassf34ccae2023-02-05 15:40:37 -0700510 if (IS_ENABLED(CONFIG_REGEX)) {
Michal Simek53f44362023-01-06 09:38:52 +0100511 struct slre slre;
512 int ret;
513
514 ret = slre_compile(&slre, name);
515 if (ret) {
516 ret = slre_match(&slre, board_name, strlen(board_name),
517 NULL);
518 debug("%s: name match ret = %d\n", __func__, ret);
519 return !ret;
520 }
521 }
522#endif
523
Michal Simekc88975e2021-07-23 09:55:59 +0200524 if (!strcmp(name, board_name))
Michal Simekfe49df92020-10-26 12:26:13 +0100525 return 0;
526
527 return -1;
528}
T Karthik Reddyc8fa40a2021-08-10 06:50:20 -0600529
Simon Glassd2c5a3d2023-02-05 15:39:38 -0700530#if IS_ENABLED(CONFIG_DTB_RESELECT)
Michal Simeke0453512021-08-11 14:23:54 +0200531#define MAX_NAME_LENGTH 50
532
Michal Simekafb28572021-07-23 09:59:59 +0200533char * __maybe_unused __weak board_name_decode(void)
534{
Michal Simeke0453512021-08-11 14:23:54 +0200535 char *board_local_name;
536 struct xilinx_board_description *desc;
537 int i, id;
538
539 board_local_name = calloc(1, MAX_NAME_LENGTH);
540 if (!board_info)
541 return NULL;
542
543 for (id = 0; id <= highest_id; id++) {
544 desc = &board_info[id];
545
546 /* No board description */
547 if (!desc)
548 goto error;
549
550 /* Board is not detected */
551 if (desc->header != EEPROM_HEADER_MAGIC)
552 continue;
553
554 /* The first string should be soc name */
555 if (!id)
556 strcat(board_local_name, CONFIG_SYS_BOARD);
557
558 /*
559 * For two purpose here:
560 * soc_name- eg: zynqmp-
561 * and between base board and CC eg: ..revA-sck...
562 */
563 strcat(board_local_name, "-");
564
565 if (desc->name[0]) {
566 /* For DT composition name needs to be lowercase */
567 for (i = 0; i < sizeof(desc->name); i++)
568 desc->name[i] = tolower(desc->name[i]);
569
570 strcat(board_local_name, desc->name);
571 }
572 if (desc->revision[0]) {
573 strcat(board_local_name, "-rev");
574
575 /* And revision needs to be uppercase */
576 for (i = 0; i < sizeof(desc->revision); i++)
577 desc->revision[i] = toupper(desc->revision[i]);
578
579 strcat(board_local_name, desc->revision);
580 }
581 }
582
583 /*
584 * Longer strings will end up with buffer overflow and potential
585 * attacks that's why check it
586 */
587 if (strlen(board_local_name) >= MAX_NAME_LENGTH)
588 panic("Board name can't be determined\n");
589
590 if (strlen(board_local_name))
591 return board_local_name;
592
593error:
594 free(board_local_name);
Michal Simekafb28572021-07-23 09:59:59 +0200595 return NULL;
596}
597
598bool __maybe_unused __weak board_detection(void)
599{
Michal Simeke0453512021-08-11 14:23:54 +0200600 if (CONFIG_IS_ENABLED(DM_I2C) && CONFIG_IS_ENABLED(I2C_EEPROM)) {
601 int ret;
602
603 ret = xilinx_read_eeprom();
604 return !ret ? true : false;
605 }
606
Michal Simekafb28572021-07-23 09:59:59 +0200607 return false;
608}
609
Michal Simek4c8e4ee2022-09-06 12:40:41 +0200610bool __maybe_unused __weak soc_detection(void)
611{
612 return false;
613}
614
615char * __maybe_unused __weak soc_name_decode(void)
616{
617 return NULL;
618}
619
Michal Simekafb28572021-07-23 09:59:59 +0200620int embedded_dtb_select(void)
621{
Michal Simek4c8e4ee2022-09-06 12:40:41 +0200622 if (soc_detection()) {
623 char *soc_local_name;
624
625 soc_local_name = soc_name_decode();
626 if (soc_local_name) {
627 board_name = soc_local_name;
628 printf("Detected SOC name: %s\n", board_name);
629
630 /* Time to change DTB on fly */
631 /* Both ways should work here */
632 /* fdtdec_resetup(&rescan); */
633 return fdtdec_setup();
634 }
635 }
636
Michal Simekafb28572021-07-23 09:59:59 +0200637 if (board_detection()) {
638 char *board_local_name;
639
640 board_local_name = board_name_decode();
641 if (board_local_name) {
642 board_name = board_local_name;
Michal Simeke0453512021-08-11 14:23:54 +0200643 printf("Detected name: %s\n", board_name);
Michal Simekafb28572021-07-23 09:59:59 +0200644
645 /* Time to change DTB on fly */
646 /* Both ways should work here */
647 /* fdtdec_resetup(&rescan); */
648 fdtdec_setup();
649 }
650 }
651 return 0;
652}
653#endif
Michal Simekaa975612022-08-25 14:23:10 +0200654
655#if defined(CONFIG_LMB)
Michal Simek962c10a2023-11-06 12:56:47 +0100656
657#ifndef MMU_SECTION_SIZE
658#define MMU_SECTION_SIZE (1 * 1024 * 1024)
659#endif
660
Heinrich Schuchardt51a9aac2023-08-12 20:16:58 +0200661phys_addr_t board_get_usable_ram_top(phys_size_t total_size)
Michal Simekaa975612022-08-25 14:23:10 +0200662{
663 phys_size_t size;
664 phys_addr_t reg;
665 struct lmb lmb;
666
667 if (!total_size)
668 return gd->ram_top;
669
670 if (!IS_ALIGNED((ulong)gd->fdt_blob, 0x8))
671 panic("Not 64bit aligned DT location: %p\n", gd->fdt_blob);
672
673 /* found enough not-reserved memory to relocated U-Boot */
674 lmb_init(&lmb);
675 lmb_add(&lmb, gd->ram_base, gd->ram_size);
676 boot_fdt_add_mem_rsv_regions(&lmb, (void *)gd->fdt_blob);
677 size = ALIGN(CONFIG_SYS_MALLOC_LEN + total_size, MMU_SECTION_SIZE);
678 reg = lmb_alloc(&lmb, size, MMU_SECTION_SIZE);
679
680 if (!reg)
681 reg = gd->ram_top - size;
682
683 return reg + size;
684}
685#endif
Venkatesh Yadav Abbarapue8e3c902024-01-17 08:50:13 +0530686
687#ifdef CONFIG_OF_BOARD_SETUP
688#define MAX_RAND_SIZE 8
689int ft_board_setup(void *blob, struct bd_info *bd)
690{
691 size_t n = MAX_RAND_SIZE;
692 struct udevice *dev;
693 u8 buf[MAX_RAND_SIZE];
694 int nodeoffset, ret;
695
696 if (uclass_get_device(UCLASS_RNG, 0, &dev) || !dev) {
697 debug("No RNG device\n");
698 return 0;
699 }
700
701 if (dm_rng_read(dev, buf, n)) {
702 debug("Reading RNG failed\n");
703 return 0;
704 }
705
706 if (!blob) {
707 debug("No FDT memory address configured. Please configure\n"
708 "the FDT address via \"fdt addr <address>\" command.\n"
709 "Aborting!\n");
710 return 0;
711 }
712
713 ret = fdt_check_header(blob);
714 if (ret < 0) {
715 debug("fdt_chosen: %s\n", fdt_strerror(ret));
716 return ret;
717 }
718
719 nodeoffset = fdt_find_or_add_subnode(blob, 0, "chosen");
720 if (nodeoffset < 0) {
721 debug("Reading chosen node failed\n");
722 return nodeoffset;
723 }
724
725 ret = fdt_setprop(blob, nodeoffset, "kaslr-seed", buf, sizeof(buf));
726 if (ret < 0) {
727 debug("Unable to set kaslr-seed on chosen node: %s\n", fdt_strerror(ret));
728 return ret;
729 }
730
731 return 0;
732}
733#endif