1
2
3
4
5
6
7
8
9
10#include <common.h>
11#include <eeprom.h>
12#include <log.h>
13#include <net.h>
14#include <asm/arch/hardware.h>
15#include <asm/omap_common.h>
16#include <dm/uclass.h>
17#include <env.h>
18#include <i2c.h>
19#include <mmc.h>
20#include <errno.h>
21#include <malloc.h>
22
23#include "board_detect.h"
24
25#if !CONFIG_IS_ENABLED(DM_I2C)
26
27
28
29
30
31
32
33static int __maybe_unused ti_i2c_eeprom_init(int i2c_bus, int dev_addr)
34{
35 int rc;
36
37 if (i2c_bus >= 0) {
38 rc = i2c_set_bus_num(i2c_bus);
39 if (rc)
40 return rc;
41 }
42
43 return i2c_probe(dev_addr);
44}
45
46
47
48
49
50
51
52
53
54
55static int __maybe_unused ti_i2c_eeprom_read(int dev_addr, int offset,
56 uchar *ep, int epsize)
57{
58 return i2c_read(dev_addr, offset, 2, ep, epsize);
59}
60#endif
61
62
63
64
65
66
67
68
69
70static void __maybe_unused ti_eeprom_string_cleanup(char *s)
71{
72 int i, l;
73
74 l = strlen(s);
75 for (i = 0; i < l; i++, s++)
76 if (*s < ' ' || *s > '~') {
77 *s = 0;
78 break;
79 }
80}
81
82__weak void gpi2c_init(void)
83{
84}
85
86static int __maybe_unused ti_i2c_eeprom_get(int bus_addr, int dev_addr,
87 u32 header, u32 size, uint8_t *ep)
88{
89 int rc;
90
91#if CONFIG_IS_ENABLED(DM_I2C)
92 struct udevice *dev;
93 struct udevice *bus;
94
95 rc = uclass_get_device_by_seq(UCLASS_I2C, bus_addr, &bus);
96 if (rc)
97 return rc;
98 rc = dm_i2c_probe(bus, dev_addr, 0, &dev);
99 if (rc)
100 return rc;
101
102
103
104
105 rc = i2c_set_chip_offset_len(dev, 1);
106 if (rc)
107 return rc;
108
109
110
111
112
113
114
115 (void)dm_i2c_read(dev, 0, ep, size);
116
117
118 if (*((u32 *)ep) != header) {
119
120
121
122
123 rc = i2c_set_chip_offset_len(dev, 2);
124 if (rc)
125 return rc;
126
127 rc = dm_i2c_read(dev, 0, ep, size);
128 if (rc)
129 return rc;
130 }
131 if (*((u32 *)ep) != header)
132 return -1;
133#else
134 u32 byte;
135
136 gpi2c_init();
137 rc = ti_i2c_eeprom_init(bus_addr, dev_addr);
138 if (rc)
139 return rc;
140
141
142
143
144 byte = 1;
145
146
147
148
149
150
151
152 (void)i2c_read(dev_addr, 0x0, byte, ep, size);
153
154
155 if (*((u32 *)ep) != header) {
156
157
158
159
160 byte = 2;
161 rc = i2c_read(dev_addr, 0x0, byte, ep, size);
162 if (rc)
163 return rc;
164 }
165 if (*((u32 *)ep) != header)
166 return -1;
167#endif
168 return 0;
169}
170
171int __maybe_unused ti_emmc_boardid_get(void)
172{
173 int rc;
174 struct udevice *dev;
175 struct mmc *mmc;
176 struct ti_common_eeprom *ep;
177 struct ti_am_eeprom brdid;
178 struct blk_desc *bdesc;
179 uchar *buffer;
180
181 ep = TI_EEPROM_DATA;
182 if (ep->header == TI_EEPROM_HEADER_MAGIC)
183 return 0;
184
185
186 ep->header = TI_DEAD_EEPROM_MAGIC;
187 ep->name[0] = 0x0;
188 ep->version[0] = 0x0;
189 ep->serial[0] = 0x0;
190 ep->config[0] = 0x0;
191
192
193 rc = mmc_initialize(NULL);
194 if (rc)
195 return rc;
196
197
198 rc = uclass_get_device(UCLASS_MMC, 1, &dev);
199 if (rc)
200 return rc;
201
202
203 mmc = mmc_get_mmc_dev(dev);
204 if (!mmc)
205 return -ENODEV;
206
207
208 mmc_init(mmc);
209
210
211 rc = mmc_switch_part(mmc, 2);
212 if (rc)
213 return rc;
214
215 buffer = malloc(mmc->read_bl_len);
216 if (!buffer)
217 return -ENOMEM;
218
219 bdesc = mmc_get_blk_desc(mmc);
220
221
222 if (blk_dread(bdesc, 0L, 1, buffer) != 1) {
223 rc = -EIO;
224 goto cleanup;
225 }
226
227 memcpy(&brdid, buffer, sizeof(brdid));
228
229
230 ep->header = brdid.header;
231 strlcpy(ep->name, brdid.name, TI_EEPROM_HDR_NAME_LEN + 1);
232 ti_eeprom_string_cleanup(ep->name);
233 strlcpy(ep->version, brdid.version, TI_EEPROM_HDR_REV_LEN + 1);
234 ti_eeprom_string_cleanup(ep->version);
235 strlcpy(ep->serial, brdid.serial, TI_EEPROM_HDR_SERIAL_LEN + 1);
236 ti_eeprom_string_cleanup(ep->serial);
237
238cleanup:
239 free(buffer);
240
241 return rc;
242}
243
244int __maybe_unused ti_i2c_eeprom_am_set(const char *name, const char *rev)
245{
246 struct ti_common_eeprom *ep;
247
248 if (!name || !rev)
249 return -1;
250
251 ep = TI_EEPROM_DATA;
252 if (ep->header == TI_EEPROM_HEADER_MAGIC)
253 goto already_set;
254
255
256 memset(ep, 0, sizeof(*ep));
257 strncpy(ep->name, name, TI_EEPROM_HDR_NAME_LEN);
258 strncpy(ep->version, rev, TI_EEPROM_HDR_REV_LEN);
259
260 strncpy(ep->serial, "0000", TI_EEPROM_HDR_SERIAL_LEN);
261
262 ep->header = TI_EEPROM_HEADER_MAGIC;
263
264already_set:
265 return 0;
266}
267
268int __maybe_unused ti_i2c_eeprom_am_get(int bus_addr, int dev_addr)
269{
270 int rc;
271 struct ti_am_eeprom am_ep;
272 struct ti_common_eeprom *ep;
273
274 ep = TI_EEPROM_DATA;
275#ifndef CONFIG_SPL_BUILD
276 if (ep->header == TI_EEPROM_HEADER_MAGIC)
277 return 0;
278#endif
279
280
281 ep->header = TI_DEAD_EEPROM_MAGIC;
282 ep->name[0] = 0x0;
283 ep->version[0] = 0x0;
284 ep->serial[0] = 0x0;
285 ep->config[0] = 0x0;
286
287 rc = ti_i2c_eeprom_get(bus_addr, dev_addr, TI_EEPROM_HEADER_MAGIC,
288 sizeof(am_ep), (uint8_t *)&am_ep);
289 if (rc)
290 return rc;
291
292 ep->header = am_ep.header;
293 strlcpy(ep->name, am_ep.name, TI_EEPROM_HDR_NAME_LEN + 1);
294 ti_eeprom_string_cleanup(ep->name);
295
296
297 if (am_ep.version[0] == 0x1a && am_ep.version[1] == 0x00 &&
298 am_ep.version[2] == 0x00 && am_ep.version[3] == 0x00)
299 strlcpy(ep->version, "BBG1", TI_EEPROM_HDR_REV_LEN + 1);
300 else
301 strlcpy(ep->version, am_ep.version, TI_EEPROM_HDR_REV_LEN + 1);
302 ti_eeprom_string_cleanup(ep->version);
303 strlcpy(ep->serial, am_ep.serial, TI_EEPROM_HDR_SERIAL_LEN + 1);
304 ti_eeprom_string_cleanup(ep->serial);
305 strlcpy(ep->config, am_ep.config, TI_EEPROM_HDR_CONFIG_LEN + 1);
306 ti_eeprom_string_cleanup(ep->config);
307
308 memcpy(ep->mac_addr, am_ep.mac_addr,
309 TI_EEPROM_HDR_NO_OF_MAC_ADDR * TI_EEPROM_HDR_ETH_ALEN);
310
311 return 0;
312}
313
314int __maybe_unused ti_i2c_eeprom_dra7_get(int bus_addr, int dev_addr)
315{
316 int rc, offset = 0;
317 struct dra7_eeprom dra7_ep;
318 struct ti_common_eeprom *ep;
319
320 ep = TI_EEPROM_DATA;
321#ifndef CONFIG_SPL_BUILD
322 if (ep->header == DRA7_EEPROM_HEADER_MAGIC)
323 return 0;
324#endif
325
326
327 ep->header = TI_DEAD_EEPROM_MAGIC;
328 ep->name[0] = 0x0;
329 ep->version[0] = 0x0;
330 ep->serial[0] = 0x0;
331 ep->config[0] = 0x0;
332 ep->emif1_size = 0;
333 ep->emif2_size = 0;
334
335 rc = ti_i2c_eeprom_get(bus_addr, dev_addr, DRA7_EEPROM_HEADER_MAGIC,
336 sizeof(dra7_ep), (uint8_t *)&dra7_ep);
337 if (rc)
338 return rc;
339
340 ep->header = dra7_ep.header;
341 strlcpy(ep->name, dra7_ep.name, TI_EEPROM_HDR_NAME_LEN + 1);
342 ti_eeprom_string_cleanup(ep->name);
343
344 offset = dra7_ep.version_major - 1;
345
346
347 if (offset >= 5)
348 offset = offset + 1;
349 snprintf(ep->version, TI_EEPROM_HDR_REV_LEN + 1, "%c.%d",
350 'A' + offset, dra7_ep.version_minor);
351 ti_eeprom_string_cleanup(ep->version);
352 ep->emif1_size = (u64)dra7_ep.emif1_size;
353 ep->emif2_size = (u64)dra7_ep.emif2_size;
354 strlcpy(ep->config, dra7_ep.config, TI_EEPROM_HDR_CONFIG_LEN + 1);
355 ti_eeprom_string_cleanup(ep->config);
356
357 return 0;
358}
359
360static int ti_i2c_eeprom_am6_parse_record(struct ti_am6_eeprom_record *record,
361 struct ti_am6_eeprom *ep,
362 char **mac_addr,
363 u8 mac_addr_max_cnt,
364 u8 *mac_addr_cnt)
365{
366 switch (record->header.id) {
367 case TI_AM6_EEPROM_RECORD_BOARD_INFO:
368 if (record->header.len != sizeof(record->data.board_info))
369 return -EINVAL;
370
371 if (!ep)
372 break;
373
374
375 strlcpy(ep->name, record->data.board_info.name,
376 sizeof(ep->name));
377 ti_eeprom_string_cleanup(ep->name);
378
379
380 strlcpy(ep->version, record->data.board_info.version,
381 sizeof(ep->version));
382 strlcpy(ep->software_revision,
383 record->data.board_info.software_revision,
384 sizeof(ep->software_revision));
385 strlcpy(ep->serial, record->data.board_info.serial,
386 sizeof(ep->serial));
387 break;
388 case TI_AM6_EEPROM_RECORD_MAC_INFO:
389 if (record->header.len != sizeof(record->data.mac_info))
390 return -EINVAL;
391
392 if (!mac_addr || !mac_addr_max_cnt)
393 break;
394
395 *mac_addr_cnt = ((record->data.mac_info.mac_control &
396 TI_AM6_EEPROM_MAC_ADDR_COUNT_MASK) >>
397 TI_AM6_EEPROM_MAC_ADDR_COUNT_SHIFT) + 1;
398
399
400
401
402
403
404
405 *mac_addr_cnt = min(*mac_addr_cnt, mac_addr_max_cnt);
406
407 memcpy(mac_addr, record->data.mac_info.mac_addr,
408 *mac_addr_cnt * TI_EEPROM_HDR_ETH_ALEN);
409 break;
410 case 0x00:
411
412 case 0xFF:
413
414 return -EINVAL;
415 default:
416 pr_warn("%s: Ignoring record id %u\n", __func__,
417 record->header.id);
418 }
419
420 return 0;
421}
422
423int __maybe_unused ti_i2c_eeprom_am6_get(int bus_addr, int dev_addr,
424 struct ti_am6_eeprom *ep,
425 char **mac_addr,
426 u8 mac_addr_max_cnt,
427 u8 *mac_addr_cnt)
428{
429 struct udevice *dev;
430 struct udevice *bus;
431 unsigned int eeprom_addr;
432 struct ti_am6_eeprom_record_board_id board_id;
433 struct ti_am6_eeprom_record record;
434 int rc;
435 int consecutive_bad_records = 0;
436
437
438 memset(ep, 0, sizeof(*ep));
439 ep->header = TI_DEAD_EEPROM_MAGIC;
440
441
442 rc = ti_i2c_eeprom_get(bus_addr, dev_addr, TI_EEPROM_HEADER_MAGIC,
443 sizeof(board_id), (uint8_t *)&board_id);
444 if (rc)
445 return rc;
446
447
448
449
450
451
452 rc = ti_i2c_eeprom_get(bus_addr, dev_addr, TI_EEPROM_HEADER_MAGIC,
453 sizeof(board_id), (uint8_t *)&board_id);
454 if (rc)
455 return rc;
456
457 if (board_id.header.id != TI_AM6_EEPROM_RECORD_BOARD_ID) {
458 pr_err("%s: Invalid board ID record!\n", __func__);
459 return -EINVAL;
460 }
461
462
463 rc = uclass_get_device_by_seq(UCLASS_I2C, bus_addr, &bus);
464 if (rc)
465 return rc;
466 rc = i2c_get_chip(bus, dev_addr, 1, &dev);
467 if (rc)
468 return rc;
469
470 ep->header = TI_EEPROM_HEADER_MAGIC;
471
472
473 *mac_addr_cnt = 0;
474
475
476
477
478
479
480 eeprom_addr = sizeof(board_id);
481
482 while (consecutive_bad_records < 10) {
483 rc = dm_i2c_read(dev, eeprom_addr, (uint8_t *)&record.header,
484 sizeof(record.header));
485 if (rc)
486 return rc;
487
488
489
490
491
492 if (record.header.id == TI_AM6_EEPROM_RECORD_END_LIST)
493 break;
494
495 eeprom_addr += sizeof(record.header);
496
497 debug("%s: dev_addr=0x%02x header.id=%u header.len=%u\n",
498 __func__, dev_addr, record.header.id,
499 record.header.len);
500
501
502 if (record.header.len <= sizeof(record.data)) {
503 rc = dm_i2c_read(dev, eeprom_addr,
504 (uint8_t *)&record.data,
505 record.header.len);
506 if (rc)
507 return rc;
508
509
510 rc = ti_i2c_eeprom_am6_parse_record(&record, ep,
511 mac_addr,
512 mac_addr_max_cnt,
513 mac_addr_cnt);
514 if (rc) {
515 pr_err("%s: EEPROM parsing error!\n", __func__);
516 return rc;
517 }
518 consecutive_bad_records = 0;
519 } else {
520
521
522
523
524 pr_err("%s: Ignoring record id %u\n", __func__,
525 record.header.id);
526 consecutive_bad_records++;
527 }
528
529 eeprom_addr += record.header.len;
530 }
531
532 return 0;
533}
534
535int __maybe_unused ti_i2c_eeprom_am6_get_base(int bus_addr, int dev_addr)
536{
537 struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
538 int ret;
539
540
541
542
543
544#if !(defined(CONFIG_SPL_BUILD) && defined(CONFIG_CPU_V7R))
545 if (ep->header == TI_EEPROM_HEADER_MAGIC) {
546 debug("%s: EEPROM has already been read\n", __func__);
547 return 0;
548 }
549#endif
550
551 ret = ti_i2c_eeprom_am6_get(bus_addr, dev_addr, ep,
552 (char **)ep->mac_addr,
553 AM6_EEPROM_HDR_NO_OF_MAC_ADDR,
554 &ep->mac_addr_cnt);
555 return ret;
556}
557
558bool __maybe_unused board_ti_k3_is(char *name_tag)
559{
560 struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
561
562 if (ep->header == TI_DEAD_EEPROM_MAGIC)
563 return false;
564 return !strncmp(ep->name, name_tag, AM6_EEPROM_HDR_NAME_LEN);
565}
566
567bool __maybe_unused board_ti_is(char *name_tag)
568{
569 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
570
571 if (ep->header == TI_DEAD_EEPROM_MAGIC)
572 return false;
573 return !strncmp(ep->name, name_tag, TI_EEPROM_HDR_NAME_LEN);
574}
575
576bool __maybe_unused board_ti_rev_is(char *rev_tag, int cmp_len)
577{
578 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
579 int l;
580
581 if (ep->header == TI_DEAD_EEPROM_MAGIC)
582 return false;
583
584 l = cmp_len > TI_EEPROM_HDR_REV_LEN ? TI_EEPROM_HDR_REV_LEN : cmp_len;
585 return !strncmp(ep->version, rev_tag, l);
586}
587
588char * __maybe_unused board_ti_get_rev(void)
589{
590 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
591
592
593 return ep->version;
594}
595
596char * __maybe_unused board_ti_get_config(void)
597{
598 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
599
600
601 return ep->config;
602}
603
604char * __maybe_unused board_ti_get_name(void)
605{
606 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
607
608
609 return ep->name;
610}
611
612void __maybe_unused
613board_ti_get_eth_mac_addr(int index,
614 u8 mac_addr[TI_EEPROM_HDR_ETH_ALEN])
615{
616 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
617
618 if (ep->header == TI_DEAD_EEPROM_MAGIC)
619 goto fail;
620
621 if (index < 0 || index >= TI_EEPROM_HDR_NO_OF_MAC_ADDR)
622 goto fail;
623
624 memcpy(mac_addr, ep->mac_addr[index], TI_EEPROM_HDR_ETH_ALEN);
625 return;
626
627fail:
628 memset(mac_addr, 0, TI_EEPROM_HDR_ETH_ALEN);
629}
630
631void __maybe_unused
632board_ti_am6_get_eth_mac_addr(int index,
633 u8 mac_addr[TI_EEPROM_HDR_ETH_ALEN])
634{
635 struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
636
637 if (ep->header == TI_DEAD_EEPROM_MAGIC)
638 goto fail;
639
640 if (index < 0 || index >= ep->mac_addr_cnt)
641 goto fail;
642
643 memcpy(mac_addr, ep->mac_addr[index], TI_EEPROM_HDR_ETH_ALEN);
644 return;
645
646fail:
647 memset(mac_addr, 0, TI_EEPROM_HDR_ETH_ALEN);
648}
649
650u64 __maybe_unused board_ti_get_emif1_size(void)
651{
652 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
653
654 if (ep->header != DRA7_EEPROM_HEADER_MAGIC)
655 return 0;
656
657 return ep->emif1_size;
658}
659
660u64 __maybe_unused board_ti_get_emif2_size(void)
661{
662 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
663
664 if (ep->header != DRA7_EEPROM_HEADER_MAGIC)
665 return 0;
666
667 return ep->emif2_size;
668}
669
670void __maybe_unused set_board_info_env(char *name)
671{
672 char *unknown = "unknown";
673 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
674
675 if (name)
676 env_set("board_name", name);
677 else if (strlen(ep->name) != 0)
678 env_set("board_name", ep->name);
679 else
680 env_set("board_name", unknown);
681
682 if (strlen(ep->version) != 0)
683 env_set("board_rev", ep->version);
684 else
685 env_set("board_rev", unknown);
686
687 if (strlen(ep->serial) != 0)
688 env_set("board_serial", ep->serial);
689 else
690 env_set("board_serial", unknown);
691}
692
693void __maybe_unused set_board_info_env_am6(char *name)
694{
695 char *unknown = "unknown";
696 struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
697
698 if (name)
699 env_set("board_name", name);
700 else if (strlen(ep->name) != 0)
701 env_set("board_name", ep->name);
702 else
703 env_set("board_name", unknown);
704
705 if (strlen(ep->version) != 0)
706 env_set("board_rev", ep->version);
707 else
708 env_set("board_rev", unknown);
709
710 if (strlen(ep->software_revision) != 0)
711 env_set("board_software_revision", ep->software_revision);
712 else
713 env_set("board_software_revision", unknown);
714
715 if (strlen(ep->serial) != 0)
716 env_set("board_serial", ep->serial);
717 else
718 env_set("board_serial", unknown);
719}
720
721static u64 mac_to_u64(u8 mac[6])
722{
723 int i;
724 u64 addr = 0;
725
726 for (i = 0; i < 6; i++) {
727 addr <<= 8;
728 addr |= mac[i];
729 }
730
731 return addr;
732}
733
734static void u64_to_mac(u64 addr, u8 mac[6])
735{
736 mac[5] = addr;
737 mac[4] = addr >> 8;
738 mac[3] = addr >> 16;
739 mac[2] = addr >> 24;
740 mac[1] = addr >> 32;
741 mac[0] = addr >> 40;
742}
743
744void board_ti_set_ethaddr(int index)
745{
746 uint8_t mac_addr[6];
747 int i;
748 u64 mac1, mac2;
749 u8 mac_addr1[6], mac_addr2[6];
750 int num_macs;
751
752
753
754
755 board_ti_get_eth_mac_addr(0, mac_addr1);
756 board_ti_get_eth_mac_addr(1, mac_addr2);
757
758 if (is_valid_ethaddr(mac_addr1) && is_valid_ethaddr(mac_addr2)) {
759 mac1 = mac_to_u64(mac_addr1);
760 mac2 = mac_to_u64(mac_addr2);
761
762
763 num_macs = mac2 - mac1 + 1;
764 if (num_macs <= 0)
765 return;
766
767 if (num_macs > 50) {
768 printf("%s: Too many MAC addresses: %d. Limiting to 50\n",
769 __func__, num_macs);
770 num_macs = 50;
771 }
772
773 for (i = 0; i < num_macs; i++) {
774 u64_to_mac(mac1 + i, mac_addr);
775 if (is_valid_ethaddr(mac_addr)) {
776 eth_env_set_enetaddr_by_index("eth", i + index,
777 mac_addr);
778 }
779 }
780 }
781}
782
783void board_ti_am6_set_ethaddr(int index, int count)
784{
785 u8 mac_addr[6];
786 int i;
787
788 for (i = 0; i < count; i++) {
789 board_ti_am6_get_eth_mac_addr(i, mac_addr);
790 if (is_valid_ethaddr(mac_addr))
791 eth_env_set_enetaddr_by_index("eth", i + index,
792 mac_addr);
793 }
794}
795
796bool __maybe_unused board_ti_was_eeprom_read(void)
797{
798 struct ti_common_eeprom *ep = TI_EEPROM_DATA;
799
800 if (ep->header == TI_EEPROM_HEADER_MAGIC)
801 return true;
802 else
803 return false;
804}
805