ad5bc3c8624e5f02ea613ae05e8463e000a08eea
[platform/kernel/u-boot.git] / drivers / net / pfe_eth / pfe_firmware.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright 2015-2016 Freescale Semiconductor, Inc.
4  * Copyright 2017,2021 NXP
5  */
6
7 /*
8  * @file
9  *  Contains all the functions to handle parsing and loading of PE firmware
10  * files.
11  */
12
13 #include <dm.h>
14 #include <dm/device-internal.h>
15 #include <image.h>
16 #include <log.h>
17 #include <malloc.h>
18 #include <linux/bitops.h>
19 #include <net/pfe_eth/pfe_eth.h>
20 #include <net/pfe_eth/pfe_firmware.h>
21 #include <spi_flash.h>
22 #ifdef CONFIG_CHAIN_OF_TRUST
23 #include <fsl_validate.h>
24 #endif
25
26 #define PFE_FIRMWARE_FIT_CNF_NAME       "config@1"
27
28 static const void *pfe_fit_addr;
29 #ifdef CONFIG_CHAIN_OF_TRUST
30 static const void *pfe_esbc_hdr_addr;
31 #endif
32
33 /*
34  * PFE elf firmware loader.
35  * Loads an elf firmware image into a list of PE's (specified using a bitmask)
36  *
37  * @param pe_mask       Mask of PE id's to load firmware to
38  * @param pfe_firmware  Pointer to the firmware image
39  *
40  * @return              0 on success, a negative value on error
41  */
42 static int pfe_load_elf(int pe_mask, uint8_t *pfe_firmware)
43 {
44         Elf32_Ehdr *elf_hdr = (Elf32_Ehdr *)pfe_firmware;
45         Elf32_Half sections = be16_to_cpu(elf_hdr->e_shnum);
46         Elf32_Shdr *shdr = (Elf32_Shdr *)(pfe_firmware +
47                                                 be32_to_cpu(elf_hdr->e_shoff));
48         int id, section;
49         int ret;
50
51         debug("%s: no of sections: %d\n", __func__, sections);
52
53         /* Some sanity checks */
54         if (strncmp((char *)&elf_hdr->e_ident[EI_MAG0], ELFMAG, SELFMAG)) {
55                 printf("%s: incorrect elf magic number\n", __func__);
56                 return -1;
57         }
58
59         if (elf_hdr->e_ident[EI_CLASS] != ELFCLASS32) {
60                 printf("%s: incorrect elf class(%x)\n", __func__,
61                        elf_hdr->e_ident[EI_CLASS]);
62                 return -1;
63         }
64
65         if (elf_hdr->e_ident[EI_DATA] != ELFDATA2MSB) {
66                 printf("%s: incorrect elf data(%x)\n", __func__,
67                        elf_hdr->e_ident[EI_DATA]);
68                 return -1;
69         }
70
71         if (be16_to_cpu(elf_hdr->e_type) != ET_EXEC) {
72                 printf("%s: incorrect elf file type(%x)\n", __func__,
73                        be16_to_cpu(elf_hdr->e_type));
74                 return -1;
75         }
76
77         for (section = 0; section < sections; section++, shdr++) {
78                 if (!(be32_to_cpu(shdr->sh_flags) & (SHF_WRITE | SHF_ALLOC |
79                         SHF_EXECINSTR)))
80                         continue;
81                 for (id = 0; id < MAX_PE; id++)
82                         if (pe_mask & BIT(id)) {
83                                 ret = pe_load_elf_section(id,
84                                                           pfe_firmware, shdr);
85                                 if (ret < 0)
86                                         goto err;
87                         }
88         }
89         return 0;
90
91 err:
92         return ret;
93 }
94
95 /*
96  * Get PFE firmware from FIT image
97  *
98  * @param data pointer to PFE firmware
99  * @param size pointer to size of the firmware
100  * @param fw_name pfe firmware name, either class or tmu
101  *
102  * @return 0 on success, a negative value on error
103  */
104 static int pfe_get_fw(const void **data,
105                       size_t *size, char *fw_name)
106 {
107         int conf_node_off, fw_node_off;
108         char *conf_node_name = NULL;
109         char *desc;
110         int ret = 0;
111
112         conf_node_name = PFE_FIRMWARE_FIT_CNF_NAME;
113
114         conf_node_off = fit_conf_get_node(pfe_fit_addr, conf_node_name);
115         if (conf_node_off < 0) {
116                 printf("PFE Firmware: %s: no such config\n", conf_node_name);
117                 return -ENOENT;
118         }
119
120         fw_node_off = fit_conf_get_prop_node(pfe_fit_addr, conf_node_off,
121                                              fw_name);
122         if (fw_node_off < 0) {
123                 printf("PFE Firmware: No '%s' in config\n",
124                        fw_name);
125                 return -ENOLINK;
126         }
127
128         if (!(fit_image_verify(pfe_fit_addr, fw_node_off))) {
129                 printf("PFE Firmware: Bad firmware image (bad CRC)\n");
130                 return -EINVAL;
131         }
132
133         if (fit_image_get_data(pfe_fit_addr, fw_node_off, data, size)) {
134                 printf("PFE Firmware: Can't get %s subimage data/size",
135                        fw_name);
136                 return -ENOENT;
137         }
138
139         ret = fit_get_desc(pfe_fit_addr, fw_node_off, &desc);
140         if (ret)
141                 printf("PFE Firmware: Can't get description\n");
142         else
143                 printf("%s\n", desc);
144
145         return ret;
146 }
147
148 /*
149  * Check PFE FIT image
150  *
151  * @return 0 on success, a negative value on error
152  */
153 static int pfe_fit_check(void)
154 {
155         int ret = 0;
156
157         ret = fdt_check_header(pfe_fit_addr);
158         if (ret) {
159                 printf("PFE Firmware: Bad firmware image (not a FIT image)\n");
160                 return ret;
161         }
162
163         if (fit_check_format(pfe_fit_addr, IMAGE_SIZE_INVAL)) {
164                 printf("PFE Firmware: Bad firmware image (bad FIT header)\n");
165                 ret = -1;
166                 return ret;
167         }
168
169         return ret;
170 }
171
172 int pfe_spi_flash_init(void)
173 {
174         struct spi_flash *pfe_flash;
175         struct udevice *new;
176         int ret = 0;
177         void *addr = malloc(CONFIG_SYS_LS_PFE_FW_LENGTH);
178
179         if (!addr)
180                 return -ENOMEM;
181
182         ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS,
183                                      CONFIG_ENV_SPI_CS,
184                                      CONFIG_ENV_SPI_MAX_HZ,
185                                      CONFIG_ENV_SPI_MODE,
186                                      &new);
187         if (ret) {
188                 printf("SF: failed to probe spi\n");
189                 free(addr);
190                 device_remove(new, DM_REMOVE_NORMAL);
191                 return ret;
192         }
193
194
195         pfe_flash = dev_get_uclass_priv(new);
196         if (!pfe_flash) {
197                 printf("SF: probe for pfe failed\n");
198                 free(addr);
199                 device_remove(new, DM_REMOVE_NORMAL);
200                 return -ENODEV;
201         }
202
203         ret = spi_flash_read(pfe_flash,
204                              CONFIG_SYS_LS_PFE_FW_ADDR,
205                              CONFIG_SYS_LS_PFE_FW_LENGTH,
206                              addr);
207         if (ret) {
208                 printf("SF: read for pfe failed\n");
209                 free(addr);
210                 spi_flash_free(pfe_flash);
211                 return ret;
212         }
213
214 #ifdef CONFIG_CHAIN_OF_TRUST
215         void *hdr_addr = malloc(CONFIG_SYS_LS_PFE_ESBC_LENGTH);
216
217         if (!hdr_addr) {
218                 free(addr);
219                 spi_flash_free(pfe_flash);
220                 return -ENOMEM;
221         }
222
223         ret = spi_flash_read(pfe_flash,
224                              CONFIG_SYS_LS_PFE_ESBC_ADDR,
225                              CONFIG_SYS_LS_PFE_ESBC_LENGTH,
226                              hdr_addr);
227         if (ret) {
228                 printf("SF: failed to read pfe esbc header\n");
229                 free(addr);
230                 free(hdr_addr);
231                 spi_flash_free(pfe_flash);
232                 return ret;
233         }
234
235         pfe_esbc_hdr_addr = hdr_addr;
236 #endif
237         pfe_fit_addr = addr;
238         spi_flash_free(pfe_flash);
239
240         return ret;
241 }
242
243 /*
244  * PFE firmware initialization.
245  * Loads different firmware files from FIT image.
246  * Initializes PE IMEM/DMEM and UTIL-PE DDR
247  * Initializes control path symbol addresses (by looking them up in the elf
248  * firmware files
249  * Takes PE's out of reset
250  *
251  * @return 0 on success, a negative value on error
252  */
253 int pfe_firmware_init(void)
254 {
255 #define PFE_KEY_HASH    NULL
256         char *pfe_firmware_name;
257         const void *raw_image_addr;
258         size_t raw_image_size = 0;
259         u8 *pfe_firmware;
260 #ifdef CONFIG_CHAIN_OF_TRUST
261         uintptr_t pfe_esbc_hdr = 0;
262         uintptr_t pfe_img_addr = 0;
263 #endif
264         int ret = 0;
265         int fw_count, max_fw_count;
266         const char *p;
267
268         ret = pfe_spi_flash_init();
269         if (ret)
270                 goto err;
271
272         ret = pfe_fit_check();
273         if (ret)
274                 goto err;
275
276 #ifdef CONFIG_CHAIN_OF_TRUST
277         pfe_esbc_hdr = (uintptr_t)pfe_esbc_hdr_addr;
278         pfe_img_addr = (uintptr_t)pfe_fit_addr;
279         if (fsl_check_boot_mode_secure() != 0) {
280                 /*
281                  * In case of failure in validation, fsl_secboot_validate
282                  * would not return back in case of Production environment
283                  * with ITS=1. In Development environment (ITS=0 and
284                  * SB_EN=1), the function may return back in case of
285                  * non-fatal failures.
286                  */
287                 ret = fsl_secboot_validate(pfe_esbc_hdr,
288                                            PFE_KEY_HASH,
289                                            &pfe_img_addr);
290                 if (ret != 0)
291                         printf("PFE firmware(s) validation failed\n");
292                 else
293                         printf("PFE firmware(s) validation Successful\n");
294         }
295 #endif
296
297         p = env_get("load_util");
298         if (!p) {
299                 max_fw_count = 2;
300         } else {
301                 max_fw_count = dectoul(p, NULL);
302                 if (max_fw_count)
303                         max_fw_count = 3;
304                 else
305                         max_fw_count = 2;
306         }
307
308         for (fw_count = 0; fw_count < max_fw_count; fw_count++) {
309                 switch (fw_count) {
310                 case 0:
311                         pfe_firmware_name = "class_slowpath";
312                         break;
313                 case 1:
314                         pfe_firmware_name = "tmu_slowpath";
315                         break;
316                 case 2:
317                         pfe_firmware_name = "util_slowpath";
318                         break;
319                 }
320
321                 if (pfe_get_fw(&raw_image_addr, &raw_image_size,
322                                pfe_firmware_name)) {
323                         printf("%s firmware couldn't be found in FIT image\n",
324                                pfe_firmware_name);
325                         break;
326                 }
327                 pfe_firmware = malloc(raw_image_size);
328                 if (!pfe_firmware)
329                         return -ENOMEM;
330                 memcpy((void *)pfe_firmware, (void *)raw_image_addr,
331                        raw_image_size);
332
333                 switch (fw_count) {
334                 case 0:
335                         env_set_addr("class_elf_firmware", pfe_firmware);
336                         env_set_addr("class_elf_size", (void *)raw_image_size);
337                         break;
338                 case 1:
339                         env_set_addr("tmu_elf_firmware", pfe_firmware);
340                         env_set_addr("tmu_elf_size", (void *)raw_image_size);
341                         break;
342                 case 2:
343                         env_set_addr("util_elf_firmware", pfe_firmware);
344                         env_set_addr("util_elf_size", (void *)raw_image_size);
345                         break;
346                 }
347         }
348
349         raw_image_addr = NULL;
350         pfe_firmware = NULL;
351         raw_image_size = 0;
352         for (fw_count = 0; fw_count < 2; fw_count++) {
353                 if (fw_count == 0)
354                         pfe_firmware_name = "class";
355                 else if (fw_count == 1)
356                         pfe_firmware_name = "tmu";
357
358                 pfe_get_fw(&raw_image_addr, &raw_image_size, pfe_firmware_name);
359                 pfe_firmware = malloc(raw_image_size);
360                 if (!pfe_firmware)
361                         return -ENOMEM;
362                 memcpy((void *)pfe_firmware, (void *)raw_image_addr,
363                        raw_image_size);
364
365                 if (fw_count == 0)
366                         ret = pfe_load_elf(CLASS_MASK, pfe_firmware);
367                 else if (fw_count == 1)
368                         ret = pfe_load_elf(TMU_MASK, pfe_firmware);
369
370                 if (ret < 0) {
371                         printf("%s: %s firmware load failed\n", __func__,
372                                pfe_firmware_name);
373                         goto err;
374                 }
375                 debug("%s: %s firmware loaded\n", __func__, pfe_firmware_name);
376                 free(pfe_firmware);
377         }
378
379         tmu_enable(0xb);
380         class_enable();
381         gpi_enable(HGPI_BASE_ADDR);
382
383 err:
384         return ret;
385 }
386
387 /*
388  * PFE firmware cleanup
389  * Puts PE's in reset
390  */
391 void pfe_firmware_exit(void)
392 {
393         debug("%s\n", __func__);
394
395         class_disable();
396         tmu_disable(0xf);
397         hif_tx_disable();
398         hif_rx_disable();
399 }