board_detect.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Library to support early TI EVM EEPROM handling
  4. *
  5. * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
  6. * Lokesh Vutla
  7. * Steve Kipisz
  8. */
  9. #include <common.h>
  10. #include <eeprom.h>
  11. #include <asm/arch/hardware.h>
  12. #include <asm/omap_common.h>
  13. #include <dm/uclass.h>
  14. #include <env.h>
  15. #include <i2c.h>
  16. #include "board_detect.h"
  17. #if !defined(CONFIG_DM_I2C)
  18. /**
  19. * ti_i2c_eeprom_init - Initialize an i2c bus and probe for a device
  20. * @i2c_bus: i2c bus number to initialize
  21. * @dev_addr: Device address to probe for
  22. *
  23. * Return: 0 on success or corresponding error on failure.
  24. */
  25. static int __maybe_unused ti_i2c_eeprom_init(int i2c_bus, int dev_addr)
  26. {
  27. int rc;
  28. if (i2c_bus >= 0) {
  29. rc = i2c_set_bus_num(i2c_bus);
  30. if (rc)
  31. return rc;
  32. }
  33. return i2c_probe(dev_addr);
  34. }
  35. /**
  36. * ti_i2c_eeprom_read - Read data from an EEPROM
  37. * @dev_addr: The device address of the EEPROM
  38. * @offset: Offset to start reading in the EEPROM
  39. * @ep: Pointer to a buffer to read into
  40. * @epsize: Size of buffer
  41. *
  42. * Return: 0 on success or corresponding result of i2c_read
  43. */
  44. static int __maybe_unused ti_i2c_eeprom_read(int dev_addr, int offset,
  45. uchar *ep, int epsize)
  46. {
  47. return i2c_read(dev_addr, offset, 2, ep, epsize);
  48. }
  49. #endif
  50. /**
  51. * ti_eeprom_string_cleanup() - Handle eeprom programming errors
  52. * @s: eeprom string (should be NULL terminated)
  53. *
  54. * Some Board manufacturers do not add a NULL termination at the
  55. * end of string, instead some binary information is kludged in, hence
  56. * convert the string to just printable characters of ASCII chart.
  57. */
  58. static void __maybe_unused ti_eeprom_string_cleanup(char *s)
  59. {
  60. int i, l;
  61. l = strlen(s);
  62. for (i = 0; i < l; i++, s++)
  63. if (*s < ' ' || *s > '~') {
  64. *s = 0;
  65. break;
  66. }
  67. }
  68. __weak void gpi2c_init(void)
  69. {
  70. }
  71. static int __maybe_unused ti_i2c_eeprom_get(int bus_addr, int dev_addr,
  72. u32 header, u32 size, uint8_t *ep)
  73. {
  74. u32 hdr_read;
  75. int rc;
  76. #if defined(CONFIG_DM_I2C)
  77. struct udevice *dev;
  78. struct udevice *bus;
  79. rc = uclass_get_device_by_seq(UCLASS_I2C, bus_addr, &bus);
  80. if (rc)
  81. return rc;
  82. rc = i2c_get_chip(bus, dev_addr, 1, &dev);
  83. if (rc)
  84. return rc;
  85. /*
  86. * Read the header first then only read the other contents.
  87. */
  88. rc = i2c_set_chip_offset_len(dev, 2);
  89. if (rc)
  90. return rc;
  91. rc = dm_i2c_read(dev, 0, (uint8_t *)&hdr_read, 4);
  92. if (rc)
  93. return rc;
  94. /* Corrupted data??? */
  95. if (hdr_read != header) {
  96. rc = dm_i2c_read(dev, 0, (uint8_t *)&hdr_read, 4);
  97. /*
  98. * read the eeprom header using i2c again, but use only a
  99. * 1 byte address (some legacy boards need this..)
  100. */
  101. if (rc) {
  102. rc = i2c_set_chip_offset_len(dev, 1);
  103. if (rc)
  104. return rc;
  105. rc = dm_i2c_read(dev, 0, (uint8_t *)&hdr_read, 4);
  106. }
  107. if (rc)
  108. return rc;
  109. }
  110. if (hdr_read != header)
  111. return -1;
  112. rc = dm_i2c_read(dev, 0, ep, size);
  113. if (rc)
  114. return rc;
  115. #else
  116. u32 byte;
  117. gpi2c_init();
  118. rc = ti_i2c_eeprom_init(bus_addr, dev_addr);
  119. if (rc)
  120. return rc;
  121. /*
  122. * Read the header first then only read the other contents.
  123. */
  124. byte = 2;
  125. rc = i2c_read(dev_addr, 0x0, byte, (uint8_t *)&hdr_read, 4);
  126. if (rc)
  127. return rc;
  128. /* Corrupted data??? */
  129. if (hdr_read != header) {
  130. rc = i2c_read(dev_addr, 0x0, byte, (uint8_t *)&hdr_read, 4);
  131. /*
  132. * read the eeprom header using i2c again, but use only a
  133. * 1 byte address (some legacy boards need this..)
  134. */
  135. byte = 1;
  136. if (rc) {
  137. rc = i2c_read(dev_addr, 0x0, byte, (uint8_t *)&hdr_read,
  138. 4);
  139. }
  140. if (rc)
  141. return rc;
  142. }
  143. if (hdr_read != header)
  144. return -1;
  145. rc = i2c_read(dev_addr, 0x0, byte, ep, size);
  146. if (rc)
  147. return rc;
  148. #endif
  149. return 0;
  150. }
  151. int __maybe_unused ti_i2c_eeprom_am_set(const char *name, const char *rev)
  152. {
  153. struct ti_common_eeprom *ep;
  154. if (!name || !rev)
  155. return -1;
  156. ep = TI_EEPROM_DATA;
  157. if (ep->header == TI_EEPROM_HEADER_MAGIC)
  158. goto already_set;
  159. /* Set to 0 all fields */
  160. memset(ep, 0, sizeof(*ep));
  161. strncpy(ep->name, name, TI_EEPROM_HDR_NAME_LEN);
  162. strncpy(ep->version, rev, TI_EEPROM_HDR_REV_LEN);
  163. /* Some dummy serial number to identify the platform */
  164. strncpy(ep->serial, "0000", TI_EEPROM_HDR_SERIAL_LEN);
  165. /* Mark it with a valid header */
  166. ep->header = TI_EEPROM_HEADER_MAGIC;
  167. already_set:
  168. return 0;
  169. }
  170. int __maybe_unused ti_i2c_eeprom_am_get(int bus_addr, int dev_addr)
  171. {
  172. int rc;
  173. struct ti_am_eeprom am_ep;
  174. struct ti_common_eeprom *ep;
  175. ep = TI_EEPROM_DATA;
  176. #ifndef CONFIG_SPL_BUILD
  177. if (ep->header == TI_EEPROM_HEADER_MAGIC)
  178. return 0; /* EEPROM has already been read */
  179. #endif
  180. /* Initialize with a known bad marker for i2c fails.. */
  181. ep->header = TI_DEAD_EEPROM_MAGIC;
  182. ep->name[0] = 0x0;
  183. ep->version[0] = 0x0;
  184. ep->serial[0] = 0x0;
  185. ep->config[0] = 0x0;
  186. rc = ti_i2c_eeprom_get(bus_addr, dev_addr, TI_EEPROM_HEADER_MAGIC,
  187. sizeof(am_ep), (uint8_t *)&am_ep);
  188. if (rc)
  189. return rc;
  190. ep->header = am_ep.header;
  191. strlcpy(ep->name, am_ep.name, TI_EEPROM_HDR_NAME_LEN + 1);
  192. ti_eeprom_string_cleanup(ep->name);
  193. /* BeagleBone Green '1' eeprom, board_rev: 0x1a 0x00 0x00 0x00 */
  194. if (am_ep.version[0] == 0x1a && am_ep.version[1] == 0x00 &&
  195. am_ep.version[2] == 0x00 && am_ep.version[3] == 0x00)
  196. strlcpy(ep->version, "BBG1", TI_EEPROM_HDR_REV_LEN + 1);
  197. else
  198. strlcpy(ep->version, am_ep.version, TI_EEPROM_HDR_REV_LEN + 1);
  199. ti_eeprom_string_cleanup(ep->version);
  200. strlcpy(ep->serial, am_ep.serial, TI_EEPROM_HDR_SERIAL_LEN + 1);
  201. ti_eeprom_string_cleanup(ep->serial);
  202. strlcpy(ep->config, am_ep.config, TI_EEPROM_HDR_CONFIG_LEN + 1);
  203. ti_eeprom_string_cleanup(ep->config);
  204. memcpy(ep->mac_addr, am_ep.mac_addr,
  205. TI_EEPROM_HDR_NO_OF_MAC_ADDR * TI_EEPROM_HDR_ETH_ALEN);
  206. return 0;
  207. }
  208. int __maybe_unused ti_i2c_eeprom_dra7_get(int bus_addr, int dev_addr)
  209. {
  210. int rc, offset = 0;
  211. struct dra7_eeprom dra7_ep;
  212. struct ti_common_eeprom *ep;
  213. ep = TI_EEPROM_DATA;
  214. #ifndef CONFIG_SPL_BUILD
  215. if (ep->header == DRA7_EEPROM_HEADER_MAGIC)
  216. return 0; /* EEPROM has already been read */
  217. #endif
  218. /* Initialize with a known bad marker for i2c fails.. */
  219. ep->header = TI_DEAD_EEPROM_MAGIC;
  220. ep->name[0] = 0x0;
  221. ep->version[0] = 0x0;
  222. ep->serial[0] = 0x0;
  223. ep->config[0] = 0x0;
  224. ep->emif1_size = 0;
  225. ep->emif2_size = 0;
  226. rc = ti_i2c_eeprom_get(bus_addr, dev_addr, DRA7_EEPROM_HEADER_MAGIC,
  227. sizeof(dra7_ep), (uint8_t *)&dra7_ep);
  228. if (rc)
  229. return rc;
  230. ep->header = dra7_ep.header;
  231. strlcpy(ep->name, dra7_ep.name, TI_EEPROM_HDR_NAME_LEN + 1);
  232. ti_eeprom_string_cleanup(ep->name);
  233. offset = dra7_ep.version_major - 1;
  234. /* Rev F is skipped */
  235. if (offset >= 5)
  236. offset = offset + 1;
  237. snprintf(ep->version, TI_EEPROM_HDR_REV_LEN + 1, "%c.%d",
  238. 'A' + offset, dra7_ep.version_minor);
  239. ti_eeprom_string_cleanup(ep->version);
  240. ep->emif1_size = (u64)dra7_ep.emif1_size;
  241. ep->emif2_size = (u64)dra7_ep.emif2_size;
  242. strlcpy(ep->config, dra7_ep.config, TI_EEPROM_HDR_CONFIG_LEN + 1);
  243. ti_eeprom_string_cleanup(ep->config);
  244. return 0;
  245. }
  246. static int ti_i2c_eeprom_am6_parse_record(struct ti_am6_eeprom_record *record,
  247. struct ti_am6_eeprom *ep,
  248. char **mac_addr,
  249. u8 mac_addr_max_cnt,
  250. u8 *mac_addr_cnt)
  251. {
  252. switch (record->header.id) {
  253. case TI_AM6_EEPROM_RECORD_BOARD_INFO:
  254. if (record->header.len != sizeof(record->data.board_info))
  255. return -EINVAL;
  256. if (!ep)
  257. break;
  258. /* Populate (and clean, if needed) the board name */
  259. strlcpy(ep->name, record->data.board_info.name,
  260. sizeof(ep->name));
  261. ti_eeprom_string_cleanup(ep->name);
  262. /* Populate selected other fields from the board info record */
  263. strlcpy(ep->version, record->data.board_info.version,
  264. sizeof(ep->version));
  265. strlcpy(ep->software_revision,
  266. record->data.board_info.software_revision,
  267. sizeof(ep->software_revision));
  268. strlcpy(ep->serial, record->data.board_info.serial,
  269. sizeof(ep->serial));
  270. break;
  271. case TI_AM6_EEPROM_RECORD_MAC_INFO:
  272. if (record->header.len != sizeof(record->data.mac_info))
  273. return -EINVAL;
  274. if (!mac_addr || !mac_addr_max_cnt)
  275. break;
  276. *mac_addr_cnt = ((record->data.mac_info.mac_control &
  277. TI_AM6_EEPROM_MAC_ADDR_COUNT_MASK) >>
  278. TI_AM6_EEPROM_MAC_ADDR_COUNT_SHIFT) + 1;
  279. /*
  280. * The EEPROM can (but may not) hold a very large amount
  281. * of MAC addresses, by far exceeding what we want/can store
  282. * in the common memory array, so only grab what we can fit.
  283. * Note that a value of 0 means 1 MAC address, and so on.
  284. */
  285. *mac_addr_cnt = min(*mac_addr_cnt, mac_addr_max_cnt);
  286. memcpy(mac_addr, record->data.mac_info.mac_addr,
  287. *mac_addr_cnt * TI_EEPROM_HDR_ETH_ALEN);
  288. break;
  289. case 0x00:
  290. /* Illegal value... Fall through... */
  291. case 0xFF:
  292. /* Illegal value... Something went horribly wrong... */
  293. return -EINVAL;
  294. default:
  295. pr_warn("%s: Ignoring record id %u\n", __func__,
  296. record->header.id);
  297. }
  298. return 0;
  299. }
  300. int __maybe_unused ti_i2c_eeprom_am6_get(int bus_addr, int dev_addr,
  301. struct ti_am6_eeprom *ep,
  302. char **mac_addr,
  303. u8 mac_addr_max_cnt,
  304. u8 *mac_addr_cnt)
  305. {
  306. struct udevice *dev;
  307. struct udevice *bus;
  308. unsigned int eeprom_addr;
  309. struct ti_am6_eeprom_record_board_id board_id;
  310. struct ti_am6_eeprom_record record;
  311. int rc;
  312. /* Initialize with a known bad marker for i2c fails.. */
  313. memset(ep, 0, sizeof(*ep));
  314. ep->header = TI_DEAD_EEPROM_MAGIC;
  315. /* Read the board ID record which is always the first EEPROM record */
  316. rc = ti_i2c_eeprom_get(bus_addr, dev_addr, TI_EEPROM_HEADER_MAGIC,
  317. sizeof(board_id), (uint8_t *)&board_id);
  318. if (rc)
  319. return rc;
  320. if (board_id.header.id != TI_AM6_EEPROM_RECORD_BOARD_ID) {
  321. pr_err("%s: Invalid board ID record!\n", __func__);
  322. return -EINVAL;
  323. }
  324. /* Establish DM handle to board config EEPROM */
  325. rc = uclass_get_device_by_seq(UCLASS_I2C, bus_addr, &bus);
  326. if (rc)
  327. return rc;
  328. rc = i2c_get_chip(bus, dev_addr, 1, &dev);
  329. if (rc)
  330. return rc;
  331. ep->header = TI_EEPROM_HEADER_MAGIC;
  332. /* Ready to parse TLV structure. Initialize variables... */
  333. *mac_addr_cnt = 0;
  334. /*
  335. * After the all-encompassing board ID record all other records follow
  336. * a TLV-type scheme. Point to the first such record and then start
  337. * parsing those one by one.
  338. */
  339. eeprom_addr = sizeof(board_id);
  340. while (true) {
  341. rc = dm_i2c_read(dev, eeprom_addr, (uint8_t *)&record.header,
  342. sizeof(record.header));
  343. if (rc)
  344. return rc;
  345. /*
  346. * Check for end of list marker. If we reached it don't go
  347. * any further and stop parsing right here.
  348. */
  349. if (record.header.id == TI_AM6_EEPROM_RECORD_END_LIST)
  350. break;
  351. eeprom_addr += sizeof(record.header);
  352. debug("%s: dev_addr=0x%02x header.id=%u header.len=%u\n",
  353. __func__, dev_addr, record.header.id,
  354. record.header.len);
  355. /* Read record into memory if it fits */
  356. if (record.header.len <= sizeof(record.data)) {
  357. rc = dm_i2c_read(dev, eeprom_addr,
  358. (uint8_t *)&record.data,
  359. record.header.len);
  360. if (rc)
  361. return rc;
  362. /* Process record */
  363. rc = ti_i2c_eeprom_am6_parse_record(&record, ep,
  364. mac_addr,
  365. mac_addr_max_cnt,
  366. mac_addr_cnt);
  367. if (rc) {
  368. pr_err("%s: EEPROM parsing error!\n", __func__);
  369. return rc;
  370. }
  371. } else {
  372. /*
  373. * We may get here in case of larger records which
  374. * are not yet understood.
  375. */
  376. pr_err("%s: Ignoring record id %u\n", __func__,
  377. record.header.id);
  378. }
  379. eeprom_addr += record.header.len;
  380. }
  381. return 0;
  382. }
  383. int __maybe_unused ti_i2c_eeprom_am6_get_base(int bus_addr, int dev_addr)
  384. {
  385. struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
  386. int ret;
  387. /*
  388. * Always execute EEPROM read by not allowing to bypass it during the
  389. * first invocation of SPL which happens on the R5 core.
  390. */
  391. #if !(defined(CONFIG_SPL_BUILD) && defined(CONFIG_CPU_V7R))
  392. if (ep->header == TI_EEPROM_HEADER_MAGIC) {
  393. debug("%s: EEPROM has already been read\n", __func__);
  394. return 0;
  395. }
  396. #endif
  397. ret = ti_i2c_eeprom_am6_get(bus_addr, dev_addr, ep,
  398. (char **)ep->mac_addr,
  399. AM6_EEPROM_HDR_NO_OF_MAC_ADDR,
  400. &ep->mac_addr_cnt);
  401. return ret;
  402. }
  403. bool __maybe_unused board_ti_is(char *name_tag)
  404. {
  405. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  406. if (ep->header == TI_DEAD_EEPROM_MAGIC)
  407. return false;
  408. return !strncmp(ep->name, name_tag, TI_EEPROM_HDR_NAME_LEN);
  409. }
  410. bool __maybe_unused board_ti_rev_is(char *rev_tag, int cmp_len)
  411. {
  412. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  413. int l;
  414. if (ep->header == TI_DEAD_EEPROM_MAGIC)
  415. return false;
  416. l = cmp_len > TI_EEPROM_HDR_REV_LEN ? TI_EEPROM_HDR_REV_LEN : cmp_len;
  417. return !strncmp(ep->version, rev_tag, l);
  418. }
  419. char * __maybe_unused board_ti_get_rev(void)
  420. {
  421. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  422. /* if ep->header == TI_DEAD_EEPROM_MAGIC, this is empty already */
  423. return ep->version;
  424. }
  425. char * __maybe_unused board_ti_get_config(void)
  426. {
  427. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  428. /* if ep->header == TI_DEAD_EEPROM_MAGIC, this is empty already */
  429. return ep->config;
  430. }
  431. char * __maybe_unused board_ti_get_name(void)
  432. {
  433. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  434. /* if ep->header == TI_DEAD_EEPROM_MAGIC, this is empty already */
  435. return ep->name;
  436. }
  437. void __maybe_unused
  438. board_ti_get_eth_mac_addr(int index,
  439. u8 mac_addr[TI_EEPROM_HDR_ETH_ALEN])
  440. {
  441. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  442. if (ep->header == TI_DEAD_EEPROM_MAGIC)
  443. goto fail;
  444. if (index < 0 || index >= TI_EEPROM_HDR_NO_OF_MAC_ADDR)
  445. goto fail;
  446. memcpy(mac_addr, ep->mac_addr[index], TI_EEPROM_HDR_ETH_ALEN);
  447. return;
  448. fail:
  449. memset(mac_addr, 0, TI_EEPROM_HDR_ETH_ALEN);
  450. }
  451. void __maybe_unused
  452. board_ti_am6_get_eth_mac_addr(int index,
  453. u8 mac_addr[TI_EEPROM_HDR_ETH_ALEN])
  454. {
  455. struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
  456. if (ep->header == TI_DEAD_EEPROM_MAGIC)
  457. goto fail;
  458. if (index < 0 || index >= ep->mac_addr_cnt)
  459. goto fail;
  460. memcpy(mac_addr, ep->mac_addr[index], TI_EEPROM_HDR_ETH_ALEN);
  461. return;
  462. fail:
  463. memset(mac_addr, 0, TI_EEPROM_HDR_ETH_ALEN);
  464. }
  465. u64 __maybe_unused board_ti_get_emif1_size(void)
  466. {
  467. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  468. if (ep->header != DRA7_EEPROM_HEADER_MAGIC)
  469. return 0;
  470. return ep->emif1_size;
  471. }
  472. u64 __maybe_unused board_ti_get_emif2_size(void)
  473. {
  474. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  475. if (ep->header != DRA7_EEPROM_HEADER_MAGIC)
  476. return 0;
  477. return ep->emif2_size;
  478. }
  479. void __maybe_unused set_board_info_env(char *name)
  480. {
  481. char *unknown = "unknown";
  482. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  483. if (name)
  484. env_set("board_name", name);
  485. else if (ep->name)
  486. env_set("board_name", ep->name);
  487. else
  488. env_set("board_name", unknown);
  489. if (ep->version)
  490. env_set("board_rev", ep->version);
  491. else
  492. env_set("board_rev", unknown);
  493. if (ep->serial)
  494. env_set("board_serial", ep->serial);
  495. else
  496. env_set("board_serial", unknown);
  497. }
  498. void __maybe_unused set_board_info_env_am6(char *name)
  499. {
  500. char *unknown = "unknown";
  501. struct ti_am6_eeprom *ep = TI_AM6_EEPROM_DATA;
  502. if (name)
  503. env_set("board_name", name);
  504. else if (ep->name)
  505. env_set("board_name", ep->name);
  506. else
  507. env_set("board_name", unknown);
  508. if (ep->version)
  509. env_set("board_rev", ep->version);
  510. else
  511. env_set("board_rev", unknown);
  512. if (ep->software_revision)
  513. env_set("board_software_revision", ep->software_revision);
  514. else
  515. env_set("board_software_revision", unknown);
  516. if (ep->serial)
  517. env_set("board_serial", ep->serial);
  518. else
  519. env_set("board_serial", unknown);
  520. }
  521. static u64 mac_to_u64(u8 mac[6])
  522. {
  523. int i;
  524. u64 addr = 0;
  525. for (i = 0; i < 6; i++) {
  526. addr <<= 8;
  527. addr |= mac[i];
  528. }
  529. return addr;
  530. }
  531. static void u64_to_mac(u64 addr, u8 mac[6])
  532. {
  533. mac[5] = addr;
  534. mac[4] = addr >> 8;
  535. mac[3] = addr >> 16;
  536. mac[2] = addr >> 24;
  537. mac[1] = addr >> 32;
  538. mac[0] = addr >> 40;
  539. }
  540. void board_ti_set_ethaddr(int index)
  541. {
  542. uint8_t mac_addr[6];
  543. int i;
  544. u64 mac1, mac2;
  545. u8 mac_addr1[6], mac_addr2[6];
  546. int num_macs;
  547. /*
  548. * Export any Ethernet MAC addresses from EEPROM.
  549. * The 2 MAC addresses in EEPROM define the address range.
  550. */
  551. board_ti_get_eth_mac_addr(0, mac_addr1);
  552. board_ti_get_eth_mac_addr(1, mac_addr2);
  553. if (is_valid_ethaddr(mac_addr1) && is_valid_ethaddr(mac_addr2)) {
  554. mac1 = mac_to_u64(mac_addr1);
  555. mac2 = mac_to_u64(mac_addr2);
  556. /* must contain an address range */
  557. num_macs = mac2 - mac1 + 1;
  558. if (num_macs <= 0)
  559. return;
  560. if (num_macs > 50) {
  561. printf("%s: Too many MAC addresses: %d. Limiting to 50\n",
  562. __func__, num_macs);
  563. num_macs = 50;
  564. }
  565. for (i = 0; i < num_macs; i++) {
  566. u64_to_mac(mac1 + i, mac_addr);
  567. if (is_valid_ethaddr(mac_addr)) {
  568. eth_env_set_enetaddr_by_index("eth", i + index,
  569. mac_addr);
  570. }
  571. }
  572. }
  573. }
  574. void board_ti_am6_set_ethaddr(int index, int count)
  575. {
  576. u8 mac_addr[6];
  577. int i;
  578. for (i = 0; i < count; i++) {
  579. board_ti_am6_get_eth_mac_addr(i, mac_addr);
  580. if (is_valid_ethaddr(mac_addr))
  581. eth_env_set_enetaddr_by_index("eth", i + index,
  582. mac_addr);
  583. }
  584. }
  585. bool __maybe_unused board_ti_was_eeprom_read(void)
  586. {
  587. struct ti_common_eeprom *ep = TI_EEPROM_DATA;
  588. if (ep->header == TI_EEPROM_HEADER_MAGIC)
  589. return true;
  590. else
  591. return false;
  592. }