Merge branch '2019-08-11-master-imports'
[platform/kernel/u-boot.git] / cmd / part.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
4  *
5  * made from cmd_ext2, which was:
6  *
7  * (C) Copyright 2004
8  * esd gmbh <www.esd-electronics.com>
9  * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
10  *
11  * made from cmd_reiserfs by
12  *
13  * (C) Copyright 2003 - 2004
14  * Sysgo Real-Time Solutions, AG <www.elinos.com>
15  * Pavel Bartusek <pba@sysgo.com>
16  */
17
18 #include <common.h>
19 #include <config.h>
20 #include <command.h>
21 #include <env.h>
22 #include <part.h>
23 #include <vsprintf.h>
24
25 enum cmd_part_info {
26         CMD_PART_INFO_START = 0,
27         CMD_PART_INFO_SIZE,
28         CMD_PART_INFO_NUMBER
29 };
30
31 static int do_part_uuid(int argc, char * const argv[])
32 {
33         int part;
34         struct blk_desc *dev_desc;
35         disk_partition_t info;
36
37         if (argc < 2)
38                 return CMD_RET_USAGE;
39         if (argc > 3)
40                 return CMD_RET_USAGE;
41
42         part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
43         if (part < 0)
44                 return 1;
45
46         if (argc > 2)
47                 env_set(argv[2], info.uuid);
48         else
49                 printf("%s\n", info.uuid);
50
51         return 0;
52 }
53
54 static int do_part_list(int argc, char * const argv[])
55 {
56         int ret;
57         struct blk_desc *desc;
58         char *var = NULL;
59         bool bootable = false;
60         int i;
61
62         if (argc < 2)
63                 return CMD_RET_USAGE;
64
65         if (argc > 2) {
66                 for (i = 2; i < argc ; i++) {
67                         if (argv[i][0] == '-') {
68                                 if (!strcmp(argv[i], "-bootable")) {
69                                         bootable = true;
70                                 } else {
71                                         printf("Unknown option %s\n", argv[i]);
72                                         return CMD_RET_USAGE;
73                                 }
74                         } else {
75                                 var = argv[i];
76                                 break;
77                         }
78                 }
79
80                 /* Loops should have been exited at the last argument, which
81                  * as it contained the variable */
82                 if (argc != i + 1)
83                         return CMD_RET_USAGE;
84         }
85
86         ret = blk_get_device_by_str(argv[0], argv[1], &desc);
87         if (ret < 0)
88                 return 1;
89
90         if (var != NULL) {
91                 int p;
92                 char str[512] = { '\0', };
93                 disk_partition_t info;
94
95                 for (p = 1; p < MAX_SEARCH_PARTITIONS; p++) {
96                         char t[5];
97                         int r = part_get_info(desc, p, &info);
98
99                         if (r != 0)
100                                 continue;
101
102                         if (bootable && !info.bootable)
103                                 continue;
104
105                         sprintf(t, "%s%x", str[0] ? " " : "", p);
106                         strcat(str, t);
107                 }
108                 env_set(var, str);
109                 return 0;
110         }
111
112         part_print(desc);
113
114         return 0;
115 }
116
117 static int do_part_info(int argc, char * const argv[], enum cmd_part_info param)
118 {
119         struct blk_desc *desc;
120         disk_partition_t info;
121         char buf[512] = { 0 };
122         char *endp;
123         int part;
124         int err;
125         int ret;
126
127         if (argc < 3)
128                 return CMD_RET_USAGE;
129         if (argc > 4)
130                 return CMD_RET_USAGE;
131
132         ret = blk_get_device_by_str(argv[0], argv[1], &desc);
133         if (ret < 0)
134                 return 1;
135
136         part = simple_strtoul(argv[2], &endp, 0);
137         if (*endp == '\0') {
138                 err = part_get_info(desc, part, &info);
139                 if (err)
140                         return 1;
141         } else {
142                 part = part_get_info_by_name(desc, argv[2], &info);
143                 if (part == -1)
144                         return 1;
145         }
146
147         switch (param) {
148         case CMD_PART_INFO_START:
149                 snprintf(buf, sizeof(buf), LBAF, info.start);
150                 break;
151         case CMD_PART_INFO_SIZE:
152                 snprintf(buf, sizeof(buf), LBAF, info.size);
153                 break;
154         case CMD_PART_INFO_NUMBER:
155                 snprintf(buf, sizeof(buf), "%d", part);
156                 break;
157         default:
158                 printf("** Unknown cmd_part_info value: %d\n", param);
159                 return 1;
160         }
161
162         if (argc > 3)
163                 env_set(argv[3], buf);
164         else
165                 printf("%s\n", buf);
166
167         return 0;
168 }
169
170 static int do_part_start(int argc, char * const argv[])
171 {
172         return do_part_info(argc, argv, CMD_PART_INFO_START);
173 }
174
175 static int do_part_size(int argc, char * const argv[])
176 {
177         return do_part_info(argc, argv, CMD_PART_INFO_SIZE);
178 }
179
180 static int do_part_number(int argc, char * const argv[])
181 {
182         return do_part_info(argc, argv, CMD_PART_INFO_NUMBER);
183 }
184
185 static int do_part(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
186 {
187         if (argc < 2)
188                 return CMD_RET_USAGE;
189
190         if (!strcmp(argv[1], "uuid"))
191                 return do_part_uuid(argc - 2, argv + 2);
192         else if (!strcmp(argv[1], "list"))
193                 return do_part_list(argc - 2, argv + 2);
194         else if (!strcmp(argv[1], "start"))
195                 return do_part_start(argc - 2, argv + 2);
196         else if (!strcmp(argv[1], "size"))
197                 return do_part_size(argc - 2, argv + 2);
198         else if (!strcmp(argv[1], "number"))
199                 return do_part_number(argc - 2, argv + 2);
200
201         return CMD_RET_USAGE;
202 }
203
204 U_BOOT_CMD(
205         part,   CONFIG_SYS_MAXARGS,     1,      do_part,
206         "disk partition related commands",
207         "uuid <interface> <dev>:<part>\n"
208         "    - print partition UUID\n"
209         "part uuid <interface> <dev>:<part> <varname>\n"
210         "    - set environment variable to partition UUID\n"
211         "part list <interface> <dev>\n"
212         "    - print a device's partition table\n"
213         "part list <interface> <dev> [flags] <varname>\n"
214         "    - set environment variable to the list of partitions\n"
215         "      flags can be -bootable (list only bootable partitions)\n"
216         "part start <interface> <dev> <part> <varname>\n"
217         "    - set environment variable to the start of the partition (in blocks)\n"
218         "      part can be either partition number or partition name\n"
219         "part size <interface> <dev> <part> <varname>\n"
220         "    - set environment variable to the size of the partition (in blocks)\n"
221         "      part can be either partition number or partition name\n"
222         "part number <interface> <dev> <part> <varname>\n"
223         "    - set environment variable to the partition number using the partition name\n"
224         "      part must be specified as partition name"
225 );