1
2
3
4
5
6
7#include <common.h>
8#include <env.h>
9#include <log.h>
10#include <asm/global_data.h>
11#include <asm/sections.h>
12#include <dm/uclass.h>
13#include <i2c.h>
14#include <linux/sizes.h>
15#include <malloc.h>
16#include "board.h"
17#include <dm.h>
18#include <i2c_eeprom.h>
19#include <net.h>
20#include <generated/dt.h>
21#include <soc.h>
22#include <linux/ctype.h>
23
24#include "fru.h"
25
26#if defined(CONFIG_ZYNQ_GEM_I2C_MAC_OFFSET)
27int zynq_board_read_rom_ethaddr(unsigned char *ethaddr)
28{
29 int ret = -EINVAL;
30 struct udevice *dev;
31 ofnode eeprom;
32
33 eeprom = ofnode_get_chosen_node("xlnx,eeprom");
34 if (!ofnode_valid(eeprom))
35 return -ENODEV;
36
37 debug("%s: Path to EEPROM %s\n", __func__,
38 ofnode_read_chosen_string("xlnx,eeprom"));
39
40 ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, eeprom, &dev);
41 if (ret)
42 return ret;
43
44 ret = dm_i2c_read(dev, CONFIG_ZYNQ_GEM_I2C_MAC_OFFSET, ethaddr, 6);
45 if (ret)
46 debug("%s: I2C EEPROM MAC address read failed\n", __func__);
47 else
48 debug("%s: I2C EEPROM MAC %pM\n", __func__, ethaddr);
49
50 return ret;
51}
52#endif
53
54#define EEPROM_HEADER_MAGIC 0xdaaddeed
55#define EEPROM_HDR_MANUFACTURER_LEN 16
56#define EEPROM_HDR_NAME_LEN 16
57#define EEPROM_HDR_REV_LEN 8
58#define EEPROM_HDR_SERIAL_LEN 20
59#define EEPROM_HDR_NO_OF_MAC_ADDR 4
60#define EEPROM_HDR_ETH_ALEN ETH_ALEN
61
62struct xilinx_board_description {
63 u32 header;
64 char manufacturer[EEPROM_HDR_MANUFACTURER_LEN + 1];
65 char name[EEPROM_HDR_NAME_LEN + 1];
66 char revision[EEPROM_HDR_REV_LEN + 1];
67 char serial[EEPROM_HDR_SERIAL_LEN + 1];
68 u8 mac_addr[EEPROM_HDR_NO_OF_MAC_ADDR][EEPROM_HDR_ETH_ALEN + 1];
69};
70
71static int highest_id = -1;
72static struct xilinx_board_description *board_info;
73
74#define XILINX_I2C_DETECTION_BITS sizeof(struct fru_common_hdr)
75
76
77struct xilinx_legacy_format {
78 char board_sn[18];
79 char unused0[14];
80 char eth_mac[6];
81 char unused1[170];
82 char board_name[11];
83 char unused2[5];
84 char board_revision[3];
85 char unused3[29];
86};
87
88static void xilinx_eeprom_legacy_cleanup(char *eeprom, int size)
89{
90 int i;
91 char byte;
92
93 for (i = 0; i < size; i++) {
94 byte = eeprom[i];
95
96
97 if (byte == 0xff || byte == ' ')
98 eeprom[i] = 0;
99
100
101 if (byte >= 'A' && byte <= 'Z')
102 eeprom[i] = byte + 'a' - 'A';
103 }
104}
105
106static int xilinx_read_eeprom_legacy(struct udevice *dev, char *name,
107 struct xilinx_board_description *desc)
108{
109 int ret, size;
110 struct xilinx_legacy_format *eeprom_content;
111 bool eth_valid = false;
112
113 size = sizeof(*eeprom_content);
114
115 eeprom_content = calloc(1, size);
116 if (!eeprom_content)
117 return -ENOMEM;
118
119 debug("%s: I2C EEPROM read pass data at %p\n", __func__,
120 eeprom_content);
121
122 ret = dm_i2c_read(dev, 0, (uchar *)eeprom_content, size);
123 if (ret) {
124 debug("%s: I2C EEPROM read failed\n", __func__);
125 free(eeprom_content);
126 return ret;
127 }
128
129 xilinx_eeprom_legacy_cleanup((char *)eeprom_content, size);
130
131 printf("Xilinx I2C Legacy format at %s:\n", name);
132 printf(" Board name:\t%s\n", eeprom_content->board_name);
133 printf(" Board rev:\t%s\n", eeprom_content->board_revision);
134 printf(" Board SN:\t%s\n", eeprom_content->board_sn);
135
136 eth_valid = is_valid_ethaddr((const u8 *)eeprom_content->eth_mac);
137 if (eth_valid)
138 printf(" Ethernet mac:\t%pM\n", eeprom_content->eth_mac);
139
140
141 strcpy(desc->name, eeprom_content->board_name);
142 strcpy(desc->revision, eeprom_content->board_revision);
143 strcpy(desc->serial, eeprom_content->board_sn);
144 if (eth_valid)
145 memcpy(desc->mac_addr[0], eeprom_content->eth_mac, ETH_ALEN);
146
147 desc->header = EEPROM_HEADER_MAGIC;
148
149 free(eeprom_content);
150
151 return ret;
152}
153
154static bool xilinx_detect_legacy(u8 *buffer)
155{
156 int i;
157 char c;
158
159 for (i = 0; i < XILINX_I2C_DETECTION_BITS; i++) {
160 c = buffer[i];
161
162 if (c < '0' || c > '9')
163 return false;
164 }
165
166 return true;
167}
168
169static int xilinx_read_eeprom_fru(struct udevice *dev, char *name,
170 struct xilinx_board_description *desc)
171{
172 int i, ret, eeprom_size;
173 u8 *fru_content;
174
175
176 eeprom_size = i2c_eeprom_size(dev);
177
178 fru_content = calloc(1, eeprom_size);
179 if (!fru_content)
180 return -ENOMEM;
181
182 debug("%s: I2C EEPROM read pass data at %p\n", __func__,
183 fru_content);
184
185 ret = dm_i2c_read(dev, 0, (uchar *)fru_content,
186 eeprom_size);
187 if (ret) {
188 debug("%s: I2C EEPROM read failed\n", __func__);
189 goto end;
190 }
191
192 fru_capture((unsigned long)fru_content);
193 if (gd->flags & GD_FLG_RELOC || (_DEBUG && CONFIG_IS_ENABLED(DTB_RESELECT))) {
194 printf("Xilinx I2C FRU format at %s:\n", name);
195 ret = fru_display(0);
196 if (ret) {
197 printf("FRU format decoding failed.\n");
198 goto end;
199 }
200 }
201
202 if (desc->header == EEPROM_HEADER_MAGIC) {
203 debug("Information already filled\n");
204 ret = -EINVAL;
205 goto end;
206 }
207
208
209 strncpy(desc->manufacturer, (char *)fru_data.brd.manufacturer_name,
210 sizeof(desc->manufacturer));
211 strncpy(desc->name, (char *)fru_data.brd.product_name,
212 sizeof(desc->name));
213 for (i = 0; i < sizeof(desc->name); i++) {
214 if (desc->name[i] == ' ')
215 desc->name[i] = '\0';
216 }
217 strncpy(desc->revision, (char *)fru_data.brd.rev,
218 sizeof(desc->revision));
219 strncpy(desc->serial, (char *)fru_data.brd.serial_number,
220 sizeof(desc->serial));
221 desc->header = EEPROM_HEADER_MAGIC;
222
223end:
224 free(fru_content);
225 return ret;
226}
227
228static bool xilinx_detect_fru(u8 *buffer)
229{
230 u8 checksum = 0;
231 int i;
232
233 checksum = fru_checksum((u8 *)buffer, sizeof(struct fru_common_hdr));
234 if (checksum) {
235 debug("%s Common header CRC FAIL\n", __func__);
236 return false;
237 }
238
239 bool all_zeros = true;
240
241 for (i = 0; i < sizeof(struct fru_common_hdr); i++) {
242 if (buffer[i] != 0)
243 all_zeros = false;
244 }
245
246 if (all_zeros)
247 return false;
248
249 debug("%s Common header CRC PASS\n", __func__);
250 return true;
251}
252
253static int xilinx_read_eeprom_single(char *name,
254 struct xilinx_board_description *desc)
255{
256 int ret;
257 struct udevice *dev;
258 ofnode eeprom;
259 u8 buffer[XILINX_I2C_DETECTION_BITS];
260
261 eeprom = ofnode_get_aliases_node(name);
262 if (!ofnode_valid(eeprom))
263 return -ENODEV;
264
265 ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, eeprom, &dev);
266 if (ret)
267 return ret;
268
269 ret = dm_i2c_read(dev, 0, buffer, sizeof(buffer));
270 if (ret) {
271 debug("%s: I2C EEPROM read failed\n", __func__);
272 return ret;
273 }
274
275 debug("%s: i2c memory detected: %s\n", __func__, name);
276
277 if (CONFIG_IS_ENABLED(CMD_FRU) && xilinx_detect_fru(buffer))
278 return xilinx_read_eeprom_fru(dev, name, desc);
279
280 if (xilinx_detect_legacy(buffer))
281 return xilinx_read_eeprom_legacy(dev, name, desc);
282
283 return -ENODEV;
284}
285
286__maybe_unused int xilinx_read_eeprom(void)
287{
288 int id;
289 char name_buf[8];
290 struct xilinx_board_description *desc;
291
292 highest_id = dev_read_alias_highest_id("nvmem");
293
294 if (highest_id < 0)
295 return -EINVAL;
296
297 board_info = calloc(1, sizeof(*desc) * (highest_id + 1));
298 if (!board_info)
299 return -ENOMEM;
300
301 debug("%s: Highest ID %d, board_info %p\n", __func__,
302 highest_id, board_info);
303
304 for (id = 0; id <= highest_id; id++) {
305 snprintf(name_buf, sizeof(name_buf), "nvmem%d", id);
306
307
308 desc = &board_info[id];
309
310
311 xilinx_read_eeprom_single(name_buf, desc);
312 }
313
314
315
316
317
318
319 return 0;
320}
321
322#if defined(CONFIG_OF_BOARD) || defined(CONFIG_OF_SEPARATE)
323void *board_fdt_blob_setup(int *err)
324{
325 void *fdt_blob;
326
327 *err = 0;
328 if (!IS_ENABLED(CONFIG_SPL_BUILD) &&
329 !IS_ENABLED(CONFIG_VERSAL_NO_DDR) &&
330 !IS_ENABLED(CONFIG_ZYNQMP_NO_DDR)) {
331 fdt_blob = (void *)CONFIG_XILINX_OF_BOARD_DTB_ADDR;
332
333 if (fdt_magic(fdt_blob) == FDT_MAGIC)
334 return fdt_blob;
335
336 debug("DTB is not passed via %p\n", fdt_blob);
337 }
338
339 if (IS_ENABLED(CONFIG_SPL_BUILD)) {
340
341
342
343
344 if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS))
345 fdt_blob = (ulong *)&_image_binary_end;
346 else
347 fdt_blob = (ulong *)&__bss_end;
348 } else {
349
350 fdt_blob = (ulong *)&_end;
351 }
352
353 if (fdt_magic(fdt_blob) == FDT_MAGIC)
354 return fdt_blob;
355
356 debug("DTB is also not passed via %p\n", fdt_blob);
357
358 return NULL;
359}
360#endif
361
362#if defined(CONFIG_BOARD_LATE_INIT)
363static int env_set_by_index(const char *name, int index, char *data)
364{
365 char var[32];
366
367 if (!index)
368 sprintf(var, "board_%s", name);
369 else
370 sprintf(var, "card%d_%s", index, name);
371
372 return env_set(var, data);
373}
374
375int board_late_init_xilinx(void)
376{
377 u32 ret = 0;
378 int i, id, macid = 0;
379 struct xilinx_board_description *desc;
380 phys_size_t bootm_size = gd->ram_size;
381
382 if (!CONFIG_IS_ENABLED(MICROBLAZE)) {
383 ulong scriptaddr;
384
385 scriptaddr = env_get_hex("scriptaddr", 0);
386 ret |= env_set_hex("scriptaddr", gd->ram_base + scriptaddr);
387 }
388
389 if (CONFIG_IS_ENABLED(ARCH_ZYNQ) || CONFIG_IS_ENABLED(MICROBLAZE))
390 bootm_size = min(bootm_size, (phys_size_t)(SZ_512M + SZ_256M));
391
392 ret |= env_set_hex("script_offset_f", CONFIG_BOOT_SCRIPT_OFFSET);
393
394 ret |= env_set_addr("bootm_low", (void *)gd->ram_base);
395 ret |= env_set_addr("bootm_size", (void *)bootm_size);
396
397 for (id = 0; id <= highest_id; id++) {
398 desc = &board_info[id];
399 if (desc && desc->header == EEPROM_HEADER_MAGIC) {
400 if (desc->manufacturer[0])
401 ret |= env_set_by_index("manufacturer", id,
402 desc->manufacturer);
403 if (desc->name[0])
404 ret |= env_set_by_index("name", id,
405 desc->name);
406 if (desc->revision[0])
407 ret |= env_set_by_index("rev", id,
408 desc->revision);
409 if (desc->serial[0])
410 ret |= env_set_by_index("serial", id,
411 desc->serial);
412
413 if (!CONFIG_IS_ENABLED(NET))
414 continue;
415
416 for (i = 0; i < EEPROM_HDR_NO_OF_MAC_ADDR; i++) {
417 if (!desc->mac_addr[i])
418 continue;
419
420 if (is_valid_ethaddr((const u8 *)desc->mac_addr[i]))
421 ret |= eth_env_set_enetaddr_by_index("eth",
422 macid++, desc->mac_addr[i]);
423 }
424 }
425 }
426
427 if (ret)
428 printf("%s: Saving run time variables FAILED\n", __func__);
429
430 return 0;
431}
432#endif
433
434static char *board_name = DEVICE_TREE;
435
436int __maybe_unused board_fit_config_name_match(const char *name)
437{
438 debug("%s: Check %s, default %s\n", __func__, name, board_name);
439
440 if (!strcmp(name, board_name))
441 return 0;
442
443 return -1;
444}
445
446#if defined(CONFIG_DISPLAY_CPUINFO) && !defined(CONFIG_ARCH_ZYNQ)
447int print_cpuinfo(void)
448{
449 struct udevice *soc;
450 char name[SOC_MAX_STR_SIZE];
451 int ret;
452
453 ret = soc_get(&soc);
454 if (ret) {
455 printf("CPU: UNKNOWN\n");
456 return 0;
457 }
458
459 ret = soc_get_family(soc, name, SOC_MAX_STR_SIZE);
460 if (ret)
461 printf("CPU: %s\n", name);
462
463 ret = soc_get_revision(soc, name, SOC_MAX_STR_SIZE);
464 if (ret)
465 printf("Silicon: %s\n", name);
466
467 return 0;
468}
469#endif
470
471#if CONFIG_IS_ENABLED(DTB_RESELECT)
472#define MAX_NAME_LENGTH 50
473
474char * __maybe_unused __weak board_name_decode(void)
475{
476 char *board_local_name;
477 struct xilinx_board_description *desc;
478 int i, id;
479
480 board_local_name = calloc(1, MAX_NAME_LENGTH);
481 if (!board_info)
482 return NULL;
483
484 for (id = 0; id <= highest_id; id++) {
485 desc = &board_info[id];
486
487
488 if (!desc)
489 goto error;
490
491
492 if (desc->header != EEPROM_HEADER_MAGIC)
493 continue;
494
495
496 if (!id)
497 strcat(board_local_name, CONFIG_SYS_BOARD);
498
499
500
501
502
503
504 strcat(board_local_name, "-");
505
506 if (desc->name[0]) {
507
508 for (i = 0; i < sizeof(desc->name); i++)
509 desc->name[i] = tolower(desc->name[i]);
510
511 strcat(board_local_name, desc->name);
512 }
513 if (desc->revision[0]) {
514 strcat(board_local_name, "-rev");
515
516
517 for (i = 0; i < sizeof(desc->revision); i++)
518 desc->revision[i] = toupper(desc->revision[i]);
519
520 strcat(board_local_name, desc->revision);
521 }
522 }
523
524
525
526
527
528 if (strlen(board_local_name) >= MAX_NAME_LENGTH)
529 panic("Board name can't be determined\n");
530
531 if (strlen(board_local_name))
532 return board_local_name;
533
534error:
535 free(board_local_name);
536 return NULL;
537}
538
539bool __maybe_unused __weak board_detection(void)
540{
541 if (CONFIG_IS_ENABLED(DM_I2C) && CONFIG_IS_ENABLED(I2C_EEPROM)) {
542 int ret;
543
544 ret = xilinx_read_eeprom();
545 return !ret ? true : false;
546 }
547
548 return false;
549}
550
551int embedded_dtb_select(void)
552{
553 if (board_detection()) {
554 char *board_local_name;
555
556 board_local_name = board_name_decode();
557 if (board_local_name) {
558 board_name = board_local_name;
559 printf("Detected name: %s\n", board_name);
560
561
562
563
564 fdtdec_setup();
565 }
566 }
567 return 0;
568}
569#endif
570
