1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright 2022 Marek Vasut <marex@denx.de>
4  * Copyright 2022 DENX Software Engineering GmbH, Philip Oberfichtner <pro@denx.de>
5  */
6 
7 #include <dm.h>
8 #include <env.h>
9 #include <i2c_eeprom.h>
10 #include <net.h>
11 #include <u-boot/crc.h>
12 
13 #include "dh_common.h"
14 
on_dh_som_serial_number(const char * name,const char * value,enum env_op op,int flags)15 static int on_dh_som_serial_number(const char *name, const char *value, enum env_op op,
16 				   int flags)
17 {
18 	env_set("SN", value);
19 	return 0;
20 }
21 
22 U_BOOT_ENV_CALLBACK(dh_som_serial_number, on_dh_som_serial_number);
23 
on_SN(const char * name,const char * value,enum env_op op,int flags)24 static int on_SN(const char *name, const char *value, enum env_op op, int flags)
25 {
26 	env_set("dh_som_serial_number", value);
27 	return 0;
28 }
29 
30 U_BOOT_ENV_CALLBACK(SN, on_SN);
31 
dh_mac_is_in_env(const char * env)32 bool dh_mac_is_in_env(const char *env)
33 {
34 	unsigned char enetaddr[6];
35 
36 	return eth_env_get_enetaddr(env, enetaddr);
37 }
38 
dh_get_mac_is_enabled(const char * alias)39 int dh_get_mac_is_enabled(const char *alias)
40 {
41 	ofnode node = ofnode_path(alias);
42 
43 	if (!ofnode_valid(node))
44 		return -EINVAL;
45 
46 	if (!ofnode_is_enabled(node))
47 		return -ENODEV;
48 
49 	return 0;
50 }
51 
dh_read_eeprom_id_page(u8 * eeprom_buffer,const char * alias)52 int dh_read_eeprom_id_page(u8 *eeprom_buffer, const char *alias)
53 {
54 	struct eeprom_id_page *eip = (struct eeprom_id_page *)eeprom_buffer;
55 	struct udevice *dev;
56 	size_t payload_len;
57 	int eeprom_size;
58 	u16 crc16_calc;
59 	u16 crc16_eip;
60 	u8 crc8_calc;
61 	ofnode node;
62 	int ret;
63 
64 	node = ofnode_path(alias);
65 
66 	ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, node, &dev);
67 	if (ret)
68 		return ret;
69 
70 	eeprom_size = i2c_eeprom_size(dev);
71 	if (eeprom_size < 0) {
72 		printf("%s: Error getting EEPROM ID page size! ret = %d\n", __func__, ret);
73 		return eeprom_size;
74 	}
75 
76 	if (eeprom_size == 0 || eeprom_size > DH_EEPROM_ID_PAGE_MAX_SIZE) {
77 		eeprom_size = DH_EEPROM_ID_PAGE_MAX_SIZE;
78 		printf("Get invalid EEPROM ID page size %d bytes! Try to read %d bytes.\n",
79 		       eeprom_size, DH_EEPROM_ID_PAGE_MAX_SIZE);
80 	}
81 
82 	ret = i2c_eeprom_read(dev, 0x0, eeprom_buffer, eeprom_size);
83 	if (ret) {
84 		printf("%s: Error reading EEPROM ID page! ret = %d\n", __func__, ret);
85 		return ret;
86 	}
87 
88 	/* Validate header ID */
89 	if (eip->hdr.id[0] != 'D' || eip->hdr.id[1] != 'H' || eip->hdr.id[2] != 'E') {
90 		printf("%s: Error validating header ID! (got %c%c%c (0x%02x 0x%02x 0x%02x) != expected DHE)\n",
91 		       __func__, isprint(eip->hdr.id[0]) ? eip->hdr.id[0] : '.',
92 		       isprint(eip->hdr.id[1]) ? eip->hdr.id[1] : '.',
93 		       isprint(eip->hdr.id[2]) ? eip->hdr.id[2] : '.',
94 		       eip->hdr.id[0], eip->hdr.id[1], eip->hdr.id[2]);
95 		return -EINVAL;
96 	}
97 
98 	/* Validate header checksum */
99 	crc8_calc = crc8(0xff, eeprom_buffer, offsetof(struct eeprom_id_page, hdr.crc8_hdr));
100 	if (eip->hdr.crc8_hdr != crc8_calc) {
101 		printf("%s: Error validating header checksum! (got 0x%02x != calc 0x%02x)\n",
102 		       __func__, eip->hdr.crc8_hdr, crc8_calc);
103 		return -EINVAL;
104 	}
105 
106 	/*
107 	 * Validate header version
108 	 * The payload is defined by the version specified in the header.
109 	 * Currently only version 0x10 is defined, so take the length of
110 	 * the only defined payload as the payload length.
111 	 */
112 	if (eip->hdr.version != DH_EEPROM_ID_PAGE_V1_0) {
113 		printf("%s: Error validating version! (0x%02X is not supported)\n",
114 		       __func__, eip->hdr.version);
115 		return -EINVAL;
116 	}
117 	payload_len = sizeof(eip->pl);
118 
119 	/* Validate payload checksum */
120 	crc16_eip = (eip->hdr.crc16_pl[1] << 8) | eip->hdr.crc16_pl[0];
121 	crc16_calc = crc16(0xffff, eeprom_buffer + sizeof(eip->hdr), payload_len);
122 	if (crc16_eip != crc16_calc) {
123 		printf("%s: Error validating data checksum! (got 0x%02x != calc 0x%02x)\n",
124 		       __func__, crc16_eip, crc16_calc);
125 		return -EINVAL;
126 	}
127 
128 	return 0;
129 }
130 
dh_get_value_from_eeprom_buffer(enum eip_request_values request,u8 * data,int data_len,struct eeprom_id_page * eip)131 int dh_get_value_from_eeprom_buffer(enum eip_request_values request, u8 *data, int data_len,
132 				    struct eeprom_id_page *eip)
133 {
134 	const char fin_chr = (eip->pl.item_prefix & DH_ITEM_PREFIX_FIN_BIT) ?
135 			     DH_ITEM_PREFIX_FIN_FLASHED_CHR : DH_ITEM_PREFIX_FIN_HALF_CHR;
136 	const u8 soc_coded = eip->pl.item_prefix & 0xf;
137 	char soc_chr;
138 
139 	if (!eip)
140 		return -EINVAL;
141 
142 	/* Copy requested data */
143 	switch (request) {
144 	case DH_MAC0:
145 		if (!is_valid_ethaddr(eip->pl.mac0))
146 			return -EINVAL;
147 
148 		if (data_len >= sizeof(eip->pl.mac0))
149 			memcpy(data, eip->pl.mac0, sizeof(eip->pl.mac0));
150 		else
151 			return -EINVAL;
152 		break;
153 	case DH_MAC1:
154 		if (!is_valid_ethaddr(eip->pl.mac1))
155 			return -EINVAL;
156 
157 		if (data_len >= sizeof(eip->pl.mac1))
158 			memcpy(data, eip->pl.mac1, sizeof(eip->pl.mac1));
159 		else
160 			return -EINVAL;
161 		break;
162 	case DH_ITEM_NUMBER:
163 		if (data_len < 8) /* String length must be 7 characters + string termination */
164 			return -EINVAL;
165 
166 		if (soc_coded == DH_ITEM_PREFIX_NXP)
167 			soc_chr = DH_ITEM_PREFIX_NXP_CHR;
168 		else if (soc_coded == DH_ITEM_PREFIX_ST)
169 			soc_chr = DH_ITEM_PREFIX_ST_CHR;
170 		else
171 			return -EINVAL;
172 
173 		snprintf(data, data_len, "%c%c%05d", fin_chr, soc_chr,
174 			 (eip->pl.item_num[0] << 16) | (eip->pl.item_num[1] << 8) |
175 			 eip->pl.item_num[2]);
176 		break;
177 	case DH_SERIAL_NUMBER:
178 		/*
179 		 * data_len must be greater than the size of eip->pl.serial,
180 		 * because there is a string termination needed.
181 		 */
182 		if (data_len <= sizeof(eip->pl.serial))
183 			return -EINVAL;
184 
185 		data[sizeof(eip->pl.serial)] = 0;
186 		memcpy(data, eip->pl.serial, sizeof(eip->pl.serial));
187 		break;
188 	default:
189 		return -EINVAL;
190 	}
191 
192 	return 0;
193 }
194 
dh_get_mac_from_eeprom(unsigned char * enetaddr,const char * alias)195 int dh_get_mac_from_eeprom(unsigned char *enetaddr, const char *alias)
196 {
197 	struct udevice *dev;
198 	int ret;
199 	ofnode node;
200 
201 	node = ofnode_path(alias);
202 	if (!ofnode_valid(node)) {
203 		printf("%s: ofnode for %s not found!", __func__, alias);
204 		return -ENOENT;
205 	}
206 
207 	ret = uclass_get_device_by_ofnode(UCLASS_I2C_EEPROM, node, &dev);
208 	if (ret) {
209 		printf("%s: Cannot find EEPROM! ret = %d\n", __func__, ret);
210 		return ret;
211 	}
212 
213 	ret = i2c_eeprom_read(dev, 0xfa, enetaddr, 0x6);
214 	if (ret) {
215 		printf("%s: Error reading EEPROM! ret = %d\n", __func__, ret);
216 		return ret;
217 	}
218 
219 	if (!is_valid_ethaddr(enetaddr)) {
220 		printf("%s: Address read from EEPROM is invalid!\n", __func__);
221 		return -EINVAL;
222 	}
223 
224 	return 0;
225 }
226 
dh_setup_mac_address(struct eeprom_id_page * eip)227 __weak int dh_setup_mac_address(struct eeprom_id_page *eip)
228 {
229 	unsigned char enetaddr[6];
230 
231 	if (dh_mac_is_in_env("ethaddr"))
232 		return 0;
233 
234 	if (dh_get_mac_is_enabled("ethernet0"))
235 		return 0;
236 
237 	if (!dh_get_value_from_eeprom_buffer(DH_MAC0, enetaddr, sizeof(enetaddr), eip))
238 		return eth_env_set_enetaddr("ethaddr", enetaddr);
239 
240 	if (!dh_get_mac_from_eeprom(enetaddr, "eeprom0"))
241 		return eth_env_set_enetaddr("ethaddr", enetaddr);
242 
243 	printf("%s: Unable to set mac address!\n", __func__);
244 	return -ENXIO;
245 }
246