ubispl: add support for loading volumes by name
[oweals/u-boot.git] / cmd / cbfs.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
4  */
5
6 /*
7  * CBFS commands
8  */
9 #include <common.h>
10 #include <command.h>
11 #include <cbfs.h>
12
13 static int do_cbfs_init(cmd_tbl_t *cmdtp, int flag, int argc,
14                         char *const argv[])
15 {
16         uintptr_t end_of_rom = 0xffffffff;
17         char *ep;
18
19         if (argc > 2) {
20                 printf("usage: cbfsls [end of rom]>\n");
21                 return 0;
22         }
23         if (argc == 2) {
24                 end_of_rom = simple_strtoul(argv[1], &ep, 16);
25                 if (*ep) {
26                         puts("\n** Invalid end of ROM **\n");
27                         return 1;
28                 }
29         }
30         file_cbfs_init(end_of_rom);
31         if (file_cbfs_result != CBFS_SUCCESS) {
32                 printf("%s.\n", file_cbfs_error());
33                 return 1;
34         }
35         return 0;
36 }
37
38 U_BOOT_CMD(
39         cbfsinit,       2,      0,      do_cbfs_init,
40         "initialize the cbfs driver",
41         "[end of rom]\n"
42         "    - Initialize the cbfs driver. The optional 'end of rom'\n"
43         "      parameter specifies where the end of the ROM is that the\n"
44         "      CBFS is in. It defaults to 0xFFFFFFFF\n"
45 );
46
47 static int do_cbfs_fsload(cmd_tbl_t *cmdtp, int flag, int argc,
48                           char *const argv[])
49 {
50         const struct cbfs_cachenode *file;
51         unsigned long offset;
52         unsigned long count;
53         long size;
54
55         if (argc < 3) {
56                 printf("usage: cbfsload <addr> <filename> [bytes]\n");
57                 return 1;
58         }
59
60         /* parse offset and count */
61         offset = simple_strtoul(argv[1], NULL, 16);
62         if (argc == 4)
63                 count = simple_strtoul(argv[3], NULL, 16);
64         else
65                 count = 0;
66
67         file = file_cbfs_find(argv[2]);
68         if (!file) {
69                 if (file_cbfs_result == CBFS_FILE_NOT_FOUND)
70                         printf("%s: %s\n", file_cbfs_error(), argv[2]);
71                 else
72                         printf("%s.\n", file_cbfs_error());
73                 return 1;
74         }
75
76         printf("reading %s\n", file_cbfs_name(file));
77
78         size = file_cbfs_read(file, (void *)offset, count);
79
80         printf("\n%ld bytes read\n", size);
81
82         env_set_hex("filesize", size);
83
84         return 0;
85 }
86
87 U_BOOT_CMD(
88         cbfsload,       4,      0,      do_cbfs_fsload,
89         "load binary file from a cbfs filesystem",
90         "<addr> <filename> [bytes]\n"
91         "    - load binary file 'filename' from the cbfs to address 'addr'\n"
92 );
93
94 static int do_cbfs_ls(cmd_tbl_t *cmdtp, int flag, int argc,
95                       char *const argv[])
96 {
97         const struct cbfs_cachenode *file = file_cbfs_get_first();
98         int files = 0;
99
100         if (!file) {
101                 printf("%s.\n", file_cbfs_error());
102                 return 1;
103         }
104
105         printf("     size              type  name\n");
106         printf("------------------------------------------\n");
107         while (file) {
108                 int type = file_cbfs_type(file);
109                 char *type_name = NULL;
110                 const char *filename = file_cbfs_name(file);
111
112                 printf(" %8d", file_cbfs_size(file));
113
114                 switch (type) {
115                 case CBFS_TYPE_BOOTBLOCK:
116                         type_name = "bootblock";
117                         break;
118                 case CBFS_TYPE_CBFSHEADER:
119                         type_name = "cbfs header";
120                         break;
121                 case CBFS_TYPE_STAGE:
122                         type_name = "stage";
123                         break;
124                 case CBFS_TYPE_PAYLOAD:
125                         type_name = "payload";
126                         break;
127                 case CBFS_TYPE_FIT:
128                         type_name = "fit";
129                         break;
130                 case CBFS_TYPE_OPTIONROM:
131                         type_name = "option rom";
132                         break;
133                 case CBFS_TYPE_BOOTSPLASH:
134                         type_name = "boot splash";
135                         break;
136                 case CBFS_TYPE_RAW:
137                         type_name = "raw";
138                         break;
139                 case CBFS_TYPE_VSA:
140                         type_name = "vsa";
141                         break;
142                 case CBFS_TYPE_MBI:
143                         type_name = "mbi";
144                         break;
145                 case CBFS_TYPE_MICROCODE:
146                         type_name = "microcode";
147                         break;
148                 case CBFS_TYPE_FSP:
149                         type_name = "fsp";
150                         break;
151                 case CBFS_TYPE_MRC:
152                         type_name = "mrc";
153                         break;
154                 case CBFS_TYPE_MMA:
155                         type_name = "mma";
156                         break;
157                 case CBFS_TYPE_EFI:
158                         type_name = "efi";
159                         break;
160                 case CBFS_TYPE_STRUCT:
161                         type_name = "struct";
162                         break;
163                 case CBFS_TYPE_CMOS_DEFAULT:
164                         type_name = "cmos default";
165                         break;
166                 case CBFS_TYPE_SPD:
167                         type_name = "spd";
168                         break;
169                 case CBFS_TYPE_MRC_CACHE:
170                         type_name = "mrc cache";
171                         break;
172                 case CBFS_TYPE_CMOS_LAYOUT:
173                         type_name = "cmos layout";
174                         break;
175                 case -1:
176                 case 0:
177                         type_name = "null";
178                         break;
179                 }
180                 if (type_name)
181                         printf("  %16s", type_name);
182                 else
183                         printf("  %16d", type);
184
185                 if (filename[0])
186                         printf("  %s\n", filename);
187                 else
188                         printf("  %s\n", "(empty)");
189                 file_cbfs_get_next(&file);
190                 files++;
191         }
192
193         printf("\n%d file(s)\n\n", files);
194         return 0;
195 }
196
197 U_BOOT_CMD(
198         cbfsls, 1,      1,      do_cbfs_ls,
199         "list files",
200         "    - list the files in the cbfs\n"
201 );
202
203 static int do_cbfs_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
204                           char *const argv[])
205 {
206         const struct cbfs_header *header = file_cbfs_get_header();
207
208         if (!header) {
209                 printf("%s.\n", file_cbfs_error());
210                 return 1;
211         }
212
213         printf("\n");
214         printf("CBFS version: %#x\n", header->version);
215         printf("ROM size: %#x\n", header->rom_size);
216         printf("Boot block size: %#x\n", header->boot_block_size);
217         printf("CBFS size: %#x\n",
218                 header->rom_size - header->boot_block_size - header->offset);
219         printf("Alignment: %d\n", header->align);
220         printf("Offset: %#x\n", header->offset);
221         printf("\n");
222
223         return 0;
224 }
225
226 U_BOOT_CMD(
227         cbfsinfo,       1,      1,      do_cbfs_fsinfo,
228         "print information about filesystem",
229         "    - print information about the cbfs filesystem\n"
230 );