blob: 72241b7b232c11a4244bb0143ddd8e24261a2077 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenkaffae2b2002-08-17 09:36:01 +00002/*
3 * (C) Copyright 2001
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
wdenkaffae2b2002-08-17 09:36:01 +00005 */
6
7#include <common.h>
Simon Glass655306c2020-05-10 11:39:58 -06008#include <blk.h>
wdenkaffae2b2002-08-17 09:36:01 +00009#include <command.h>
Simon Glass0af6e2d2019-08-01 09:46:52 -060010#include <env.h>
Simon Glass83ce5632016-02-29 15:25:47 -070011#include <errno.h>
wdenkaffae2b2002-08-17 09:36:01 +000012#include <ide.h>
Simon Glass0f2af882020-05-10 11:40:05 -060013#include <log.h>
Stephen Warrenc87ff222012-09-21 09:50:57 +000014#include <malloc.h>
Grant Likelyffc2dd72007-02-20 09:04:34 +010015#include <part.h>
Hans de Goede690c7962015-09-17 18:46:58 -040016#include <ubifs_uboot.h>
wdenkaffae2b2002-08-17 09:36:01 +000017
18#undef PART_DEBUG
19
20#ifdef PART_DEBUG
21#define PRINTF(fmt,args...) printf (fmt ,##args)
22#else
23#define PRINTF(fmt,args...)
24#endif
25
Sam Protsenkodee80382017-09-22 01:51:58 +030026/* Check all partition types */
27#define PART_TYPE_ALL -1
28
Simon Glass224d73e2023-08-24 13:55:30 -060029/**
30 * part_driver_get_type() - Get a driver given its type
31 *
32 * @part_type: Partition type to find the driver for
33 * Return: Driver for that type, or NULL if none
34 */
Joshua Wattaa62d502023-07-03 08:39:54 -050035static struct part_driver *part_driver_get_type(int part_type)
36{
37 struct part_driver *drv =
38 ll_entry_start(struct part_driver, part_driver);
39 const int n_ents = ll_entry_count(struct part_driver, part_driver);
40 struct part_driver *entry;
41
42 for (entry = drv; entry != drv + n_ents; entry++) {
43 if (part_type == entry->part_type)
44 return entry;
45 }
46
47 /* Not found */
48 return NULL;
49}
50
Simon Glass224d73e2023-08-24 13:55:30 -060051/**
52 * part_driver_lookup_type() - Look up the partition driver for a blk device
53 *
54 * If @desc->part_type is PART_TYPE_UNKNOWN, this checks each parition driver
55 * against the blk device to see if there is a valid partition table acceptable
56 * to that driver.
57 *
58 * If @desc->part_type is already set, it just returns the driver for that
59 * type, without testing if the driver can find a valid partition on the
60 * descriptor.
61 *
62 * On success it updates @desc->part_type if set to PART_TYPE_UNKNOWN on entry
63 *
64 * @dev_desc: Device descriptor
65 * Return: Driver found, or NULL if none
66 */
Simon Glass54c709a2023-08-24 13:55:24 -060067static struct part_driver *part_driver_lookup_type(struct blk_desc *desc)
Simon Glass83ce5632016-02-29 15:25:47 -070068{
69 struct part_driver *drv =
70 ll_entry_start(struct part_driver, part_driver);
71 const int n_ents = ll_entry_count(struct part_driver, part_driver);
72 struct part_driver *entry;
73
Simon Glass54c709a2023-08-24 13:55:24 -060074 if (desc->part_type == PART_TYPE_UNKNOWN) {
Kever Yang1c636242018-02-10 17:55:37 +080075 for (entry = drv; entry != drv + n_ents; entry++) {
76 int ret;
77
Simon Glass54c709a2023-08-24 13:55:24 -060078 ret = entry->test(desc);
Kever Yang1c636242018-02-10 17:55:37 +080079 if (!ret) {
Simon Glass54c709a2023-08-24 13:55:24 -060080 desc->part_type = entry->part_type;
Kever Yang1c636242018-02-10 17:55:37 +080081 return entry;
82 }
83 }
84 } else {
Simon Glass54c709a2023-08-24 13:55:24 -060085 return part_driver_get_type(desc->part_type);
Simon Glass83ce5632016-02-29 15:25:47 -070086 }
87
88 /* Not found */
89 return NULL;
90}
91
Simon Glassed338b72023-07-15 21:38:47 -060092int part_get_type_by_name(const char *name)
93{
94 struct part_driver *drv =
95 ll_entry_start(struct part_driver, part_driver);
96 const int n_ents = ll_entry_count(struct part_driver, part_driver);
97 struct part_driver *entry;
98
99 for (entry = drv; entry != drv + n_ents; entry++) {
100 if (!strcasecmp(name, entry->name))
101 return entry->part_type;
102 }
103
104 /* Not found */
105 return PART_TYPE_UNKNOWN;
106}
107
Simon Glass224d73e2023-08-24 13:55:30 -0600108/**
109 * get_dev_hwpart() - Get the descriptor for a device with hardware partitions
110 *
111 * @ifname: Interface name (e.g. "ide", "scsi")
112 * @dev: Device number (0 for first device on that interface, 1 for
113 * second, etc.
114 * @hwpart: Hardware partition, or 0 if none (used for MMC)
115 * Return: pointer to the block device, or NULL if not available, or an
116 * error occurred.
117 */
Simon Glasse3394752016-02-29 15:25:34 -0700118static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
Grant Likelyffc2dd72007-02-20 09:04:34 +0100119{
Simon Glass54c709a2023-08-24 13:55:24 -0600120 struct blk_desc *desc;
Simon Glasse3dfa912016-05-01 13:52:32 -0600121 int ret;
Grant Likelyffc2dd72007-02-20 09:04:34 +0100122
Simon Glassf5ac3032022-08-11 19:34:45 -0600123 if (!blk_enabled())
124 return NULL;
Simon Glass54c709a2023-08-24 13:55:24 -0600125 desc = blk_get_devnum_by_uclass_idname(ifname, dev);
126 if (!desc) {
Simon Glasse3dfa912016-05-01 13:52:32 -0600127 debug("%s: No device for iface '%s', dev %d\n", __func__,
128 ifname, dev);
Tim Kientzle47e444c2012-03-27 11:43:25 +0200129 return NULL;
Grant Likelyffc2dd72007-02-20 09:04:34 +0100130 }
Simon Glass54c709a2023-08-24 13:55:24 -0600131 ret = blk_dselect_hwpart(desc, hwpart);
Simon Glasse3dfa912016-05-01 13:52:32 -0600132 if (ret) {
133 debug("%s: Failed to select h/w partition: err-%d\n", __func__,
134 ret);
135 return NULL;
136 }
137
Simon Glass54c709a2023-08-24 13:55:24 -0600138 return desc;
Grant Likelyffc2dd72007-02-20 09:04:34 +0100139}
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600140
Simon Glassbe1e9bb2016-02-29 15:25:42 -0700141struct blk_desc *blk_get_dev(const char *ifname, int dev)
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600142{
Simon Glassf5ac3032022-08-11 19:34:45 -0600143 if (!blk_enabled())
144 return NULL;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600145
Simon Glassf5ac3032022-08-11 19:34:45 -0600146 return get_dev_hwpart(ifname, dev, 0);
Grant Likelyffc2dd72007-02-20 09:04:34 +0100147}
Grant Likelyffc2dd72007-02-20 09:04:34 +0100148
wdenkaffae2b2002-08-17 09:36:01 +0000149/* ------------------------------------------------------------------------- */
150/*
151 * reports device info to the user
152 */
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300153
wdenkc35ba4e2004-03-14 22:25:36 +0000154#ifdef CONFIG_LBA48
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300155typedef uint64_t lba512_t;
wdenkf602aa02004-03-13 23:29:43 +0000156#else
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300157typedef lbaint_t lba512_t;
wdenkf602aa02004-03-13 23:29:43 +0000158#endif
wdenkaffae2b2002-08-17 09:36:01 +0000159
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300160/*
Heinrich Schuchardt296d4dc2020-01-16 20:36:58 +0100161 * Overflowless variant of (block_count * mul_by / 2**right_shift)
162 * when 2**right_shift > mul_by
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300163 */
Heinrich Schuchardt296d4dc2020-01-16 20:36:58 +0100164static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by,
165 int right_shift)
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300166{
167 lba512_t bc_quot, bc_rem;
168
169 /* x * m / d == x / d * m + (x % d) * m / d */
Heinrich Schuchardt296d4dc2020-01-16 20:36:58 +0100170 bc_quot = block_count >> right_shift;
171 bc_rem = block_count - (bc_quot << right_shift);
172 return bc_quot * mul_by + ((bc_rem * mul_by) >> right_shift);
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300173}
174
Simon Glass54c709a2023-08-24 13:55:24 -0600175void dev_print(struct blk_desc *desc)
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300176{
177 lba512_t lba512; /* number of blocks if 512bytes block size */
178
Simon Glass54c709a2023-08-24 13:55:24 -0600179 if (desc->type == DEV_TYPE_UNKNOWN) {
Wolfgang Denk8561e712009-05-15 09:27:58 +0200180 puts ("not available\n");
181 return;
182 }
183
Simon Glass54c709a2023-08-24 13:55:24 -0600184 switch (desc->uclass_id) {
Simon Glassdbfa32c2022-08-11 19:34:59 -0600185 case UCLASS_SCSI:
Simon Glass54c709a2023-08-24 13:55:24 -0600186 printf("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n", desc->target,
187 desc->lun, desc->vendor, desc->product, desc->revision);
Detlev Zundelbec6b322008-05-05 16:11:21 +0200188 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600189 case UCLASS_IDE:
190 case UCLASS_AHCI:
Simon Glass54c709a2023-08-24 13:55:24 -0600191 printf("Model: %s Firm: %s Ser#: %s\n", desc->vendor,
192 desc->revision, desc->product);
Detlev Zundelbec6b322008-05-05 16:11:21 +0200193 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600194 case UCLASS_MMC:
195 case UCLASS_USB:
196 case UCLASS_NVME:
197 case UCLASS_PVBLOCK:
Simon Glasse57f8d42022-10-29 19:47:17 -0600198 case UCLASS_HOST:
Tobias Waldekranz91ec2592023-02-16 16:33:52 +0100199 case UCLASS_BLKMAP:
Nícolas Carneiro Lebedencoef3edd42008-09-04 15:35:46 -0300200 printf ("Vendor: %s Rev: %s Prod: %s\n",
Simon Glass54c709a2023-08-24 13:55:24 -0600201 desc->vendor,
202 desc->revision,
203 desc->product);
Nícolas Carneiro Lebedencoef3edd42008-09-04 15:35:46 -0300204 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600205 case UCLASS_VIRTIO:
Simon Glass54c709a2023-08-24 13:55:24 -0600206 printf("%s VirtIO Block Device\n", desc->vendor);
Tuomas Tynkkynend4580062018-10-15 02:21:10 -0700207 break;
Simon Glass6a1b0d42022-08-11 19:35:00 -0600208 case UCLASS_EFI_MEDIA:
Simon Glass54c709a2023-08-24 13:55:24 -0600209 printf("EFI media Block Device %d\n", desc->devnum);
Simon Glass6a1b0d42022-08-11 19:35:00 -0600210 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600211 case UCLASS_INVALID:
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200212 puts("device type unknown\n");
213 return;
Detlev Zundelbec6b322008-05-05 16:11:21 +0200214 default:
Simon Glass54c709a2023-08-24 13:55:24 -0600215 printf("Unhandled device type: %i\n", desc->uclass_id);
Detlev Zundelbec6b322008-05-05 16:11:21 +0200216 return;
wdenkaffae2b2002-08-17 09:36:01 +0000217 }
218 puts (" Type: ");
Simon Glass54c709a2023-08-24 13:55:24 -0600219 if (desc->removable)
wdenkaffae2b2002-08-17 09:36:01 +0000220 puts ("Removable ");
Simon Glass54c709a2023-08-24 13:55:24 -0600221 switch (desc->type & 0x1F) {
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200222 case DEV_TYPE_HARDDISK:
223 puts ("Hard Disk");
224 break;
225 case DEV_TYPE_CDROM:
226 puts ("CD ROM");
227 break;
228 case DEV_TYPE_OPDISK:
229 puts ("Optical Device");
230 break;
231 case DEV_TYPE_TAPE:
232 puts ("Tape");
233 break;
234 default:
Simon Glass54c709a2023-08-24 13:55:24 -0600235 printf("# %02X #", desc->type & 0x1F);
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200236 break;
wdenkaffae2b2002-08-17 09:36:01 +0000237 }
238 puts ("\n");
Simon Glass54c709a2023-08-24 13:55:24 -0600239 if (desc->lba > 0L && desc->blksz > 0L) {
wdenkaffae2b2002-08-17 09:36:01 +0000240 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
wdenkf602aa02004-03-13 23:29:43 +0000241 lbaint_t lba;
wdenk05939202004-04-18 17:39:38 +0000242
Simon Glass54c709a2023-08-24 13:55:24 -0600243 lba = desc->lba;
wdenkaffae2b2002-08-17 09:36:01 +0000244
Simon Glass54c709a2023-08-24 13:55:24 -0600245 lba512 = lba * (desc->blksz / 512);
wdenkaffae2b2002-08-17 09:36:01 +0000246 /* round to 1 digit */
Pavel Macheka4264e12014-09-09 15:19:42 +0200247 /* 2048 = (1024 * 1024) / 512 MB */
Heinrich Schuchardt2cb615e2019-06-02 00:04:50 +0200248 mb = lba512_muldiv(lba512, 10, 11);
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300249
wdenkaffae2b2002-08-17 09:36:01 +0000250 mb_quot = mb / 10;
251 mb_rem = mb - (10 * mb_quot);
252
253 gb = mb / 1024;
254 gb_quot = gb / 10;
255 gb_rem = gb - (10 * gb_quot);
wdenkc35ba4e2004-03-14 22:25:36 +0000256#ifdef CONFIG_LBA48
Simon Glass54c709a2023-08-24 13:55:24 -0600257 if (desc->lba48)
wdenkf602aa02004-03-13 23:29:43 +0000258 printf (" Supports 48-bit addressing\n");
259#endif
Heiko Schocher0f602e12009-12-03 11:21:21 +0100260#if defined(CONFIG_SYS_64BIT_LBA)
Jean-Jacques Hiblotccbb9152016-12-23 10:45:43 +0100261 printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%llu x %lu)\n",
wdenkf602aa02004-03-13 23:29:43 +0000262 mb_quot, mb_rem,
263 gb_quot, gb_rem,
264 lba,
Simon Glass54c709a2023-08-24 13:55:24 -0600265 desc->blksz);
wdenkf602aa02004-03-13 23:29:43 +0000266#else
Jean-Jacques Hiblotccbb9152016-12-23 10:45:43 +0100267 printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%lu x %lu)\n",
wdenkaffae2b2002-08-17 09:36:01 +0000268 mb_quot, mb_rem,
269 gb_quot, gb_rem,
wdenkf602aa02004-03-13 23:29:43 +0000270 (ulong)lba,
Simon Glass54c709a2023-08-24 13:55:24 -0600271 desc->blksz);
wdenkf602aa02004-03-13 23:29:43 +0000272#endif
wdenkaffae2b2002-08-17 09:36:01 +0000273 } else {
274 puts (" Capacity: not available\n");
275 }
276}
wdenkaffae2b2002-08-17 09:36:01 +0000277
Simon Glass54c709a2023-08-24 13:55:24 -0600278void part_init(struct blk_desc *desc)
wdenkaffae2b2002-08-17 09:36:01 +0000279{
Simon Glass83ce5632016-02-29 15:25:47 -0700280 struct part_driver *drv =
281 ll_entry_start(struct part_driver, part_driver);
282 const int n_ents = ll_entry_count(struct part_driver, part_driver);
283 struct part_driver *entry;
richardretanubune6745592008-09-26 11:13:22 -0400284
Simon Glass54c709a2023-08-24 13:55:24 -0600285 blkcache_invalidate(desc->uclass_id, desc->devnum);
Eric Nelsonfaf4f052016-03-28 10:05:44 -0700286
Simon Glass54c709a2023-08-24 13:55:24 -0600287 desc->part_type = PART_TYPE_UNKNOWN;
Simon Glass83ce5632016-02-29 15:25:47 -0700288 for (entry = drv; entry != drv + n_ents; entry++) {
289 int ret;
wdenk452cfd62002-11-19 11:04:11 +0000290
Simon Glass54c709a2023-08-24 13:55:24 -0600291 ret = entry->test(desc);
Simon Glass83ce5632016-02-29 15:25:47 -0700292 debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
293 if (!ret) {
Simon Glass54c709a2023-08-24 13:55:24 -0600294 desc->part_type = entry->part_type;
Simon Glass83ce5632016-02-29 15:25:47 -0700295 break;
296 }
wdenk452cfd62002-11-19 11:04:11 +0000297 }
wdenkaffae2b2002-08-17 09:36:01 +0000298}
299
Simon Glass54c709a2023-08-24 13:55:24 -0600300static void print_part_header(const char *type, struct blk_desc *desc)
Simon Glass83ce5632016-02-29 15:25:47 -0700301{
Patrick Delaunayc4bbbec2017-01-27 11:00:36 +0100302#if CONFIG_IS_ENABLED(MAC_PARTITION) || \
Patrick Delaunayf7e07722017-01-27 11:00:37 +0100303 CONFIG_IS_ENABLED(DOS_PARTITION) || \
Patrick Delaunay21d3bce2017-01-27 11:00:38 +0100304 CONFIG_IS_ENABLED(ISO_PARTITION) || \
Patrick Delaunay1aa32a82017-01-27 11:00:39 +0100305 CONFIG_IS_ENABLED(AMIGA_PARTITION) || \
Patrick Delaunay8a4f2bd2017-01-27 11:00:41 +0100306 CONFIG_IS_ENABLED(EFI_PARTITION)
wdenkaffae2b2002-08-17 09:36:01 +0000307 puts ("\nPartition Map for ");
Simon Glass54c709a2023-08-24 13:55:24 -0600308 switch (desc->uclass_id) {
Simon Glassdbfa32c2022-08-11 19:34:59 -0600309 case UCLASS_IDE:
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200310 puts ("IDE");
311 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600312 case UCLASS_AHCI:
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200313 puts ("SATA");
314 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600315 case UCLASS_SCSI:
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200316 puts ("SCSI");
317 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600318 case UCLASS_USB:
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200319 puts ("USB");
320 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600321 case UCLASS_MMC:
Lei Wen61dba932010-09-13 22:07:28 +0800322 puts ("MMC");
323 break;
Simon Glasse57f8d42022-10-29 19:47:17 -0600324 case UCLASS_HOST:
Zhikang Zhang182fccd2017-08-03 02:30:56 -0700325 puts ("HOST");
326 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600327 case UCLASS_NVME:
Zhikang Zhang182fccd2017-08-03 02:30:56 -0700328 puts ("NVMe");
Henrik Nordström26f9a6c2013-11-10 10:26:56 -0700329 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600330 case UCLASS_PVBLOCK:
Anastasiia Lukianenko4fec7f82020-08-06 12:42:55 +0300331 puts("PV BLOCK");
332 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600333 case UCLASS_VIRTIO:
Tuomas Tynkkynend4580062018-10-15 02:21:10 -0700334 puts("VirtIO");
335 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600336 case UCLASS_EFI_MEDIA:
Simon Glass507ab962021-12-04 08:56:31 -0700337 puts("EFI");
338 break;
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200339 default:
Simon Glass507ab962021-12-04 08:56:31 -0700340 puts("UNKNOWN");
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200341 break;
wdenkaffae2b2002-08-17 09:36:01 +0000342 }
343 printf (" device %d -- Partition Type: %s\n\n",
Simon Glass54c709a2023-08-24 13:55:24 -0600344 desc->devnum, type);
Gabe Black0fc71b52012-10-12 14:26:08 +0000345#endif /* any CONFIG_..._PARTITION */
Simon Glass83ce5632016-02-29 15:25:47 -0700346}
Gabe Black0fc71b52012-10-12 14:26:08 +0000347
Simon Glass54c709a2023-08-24 13:55:24 -0600348void part_print(struct blk_desc *desc)
wdenkaffae2b2002-08-17 09:36:01 +0000349{
Simon Glass83ce5632016-02-29 15:25:47 -0700350 struct part_driver *drv;
wdenkaffae2b2002-08-17 09:36:01 +0000351
Simon Glass54c709a2023-08-24 13:55:24 -0600352 drv = part_driver_lookup_type(desc);
Simon Glass83ce5632016-02-29 15:25:47 -0700353 if (!drv) {
354 printf("## Unknown partition table type %x\n",
Simon Glass54c709a2023-08-24 13:55:24 -0600355 desc->part_type);
wdenkaffae2b2002-08-17 09:36:01 +0000356 return;
wdenkaffae2b2002-08-17 09:36:01 +0000357 }
Simon Glass83ce5632016-02-29 15:25:47 -0700358
359 PRINTF("## Testing for valid %s partition ##\n", drv->name);
Simon Glass54c709a2023-08-24 13:55:24 -0600360 print_part_header(drv->name, desc);
Simon Glass83ce5632016-02-29 15:25:47 -0700361 if (drv->print)
Simon Glass54c709a2023-08-24 13:55:24 -0600362 drv->print(desc);
wdenkaffae2b2002-08-17 09:36:01 +0000363}
364
Simon Glass54c709a2023-08-24 13:55:24 -0600365int part_get_info_by_type(struct blk_desc *desc, int part, int part_type,
Joshua Wattaa62d502023-07-03 08:39:54 -0500366 struct disk_partition *info)
Stephen Warren07c5bff2012-09-21 12:46:54 +0000367{
Simon Glass83ce5632016-02-29 15:25:47 -0700368 struct part_driver *drv;
Stephen Warren07c5bff2012-09-21 12:46:54 +0000369
Simon Glassf5ac3032022-08-11 19:34:45 -0600370 if (blk_enabled()) {
Simon Glassf5ac3032022-08-11 19:34:45 -0600371 /* The common case is no UUID support */
Simon Glass23e34532023-08-24 13:55:31 -0600372 disk_partition_clr_uuid(info);
Simon Glassb8d3a782023-08-24 13:55:32 -0600373 disk_partition_clr_type_guid(info);
Stephen Warrenc6c7b7a2012-09-21 09:50:59 +0000374
Joshua Wattaa62d502023-07-03 08:39:54 -0500375 if (part_type == PART_TYPE_UNKNOWN) {
Simon Glass54c709a2023-08-24 13:55:24 -0600376 drv = part_driver_lookup_type(desc);
Joshua Wattaa62d502023-07-03 08:39:54 -0500377 } else {
378 drv = part_driver_get_type(part_type);
379 }
380
Simon Glassf5ac3032022-08-11 19:34:45 -0600381 if (!drv) {
382 debug("## Unknown partition table type %x\n",
Simon Glass54c709a2023-08-24 13:55:24 -0600383 desc->part_type);
Simon Glassf5ac3032022-08-11 19:34:45 -0600384 return -EPROTONOSUPPORT;
385 }
386 if (!drv->get_info) {
387 PRINTF("## Driver %s does not have the get_info() method\n",
388 drv->name);
389 return -ENOSYS;
390 }
Simon Glass54c709a2023-08-24 13:55:24 -0600391 if (drv->get_info(desc, part, info) == 0) {
Simon Glassf5ac3032022-08-11 19:34:45 -0600392 PRINTF("## Valid %s partition found ##\n", drv->name);
393 return 0;
394 }
Stephen Warren07c5bff2012-09-21 12:46:54 +0000395 }
Stephen Warren07c5bff2012-09-21 12:46:54 +0000396
Sean Andersone7bddea2021-02-05 09:38:55 -0500397 return -ENOENT;
Stephen Warren07c5bff2012-09-21 12:46:54 +0000398}
Rob Herringd586cec2012-09-21 04:08:17 +0000399
Simon Glass54c709a2023-08-24 13:55:24 -0600400int part_get_info(struct blk_desc *desc, int part,
Joshua Wattaa62d502023-07-03 08:39:54 -0500401 struct disk_partition *info)
402{
Simon Glass54c709a2023-08-24 13:55:24 -0600403 return part_get_info_by_type(desc, part, PART_TYPE_UNKNOWN, info);
Joshua Wattaa62d502023-07-03 08:39:54 -0500404}
405
Simon Glass54c709a2023-08-24 13:55:24 -0600406int part_get_info_whole_disk(struct blk_desc *desc,
Simon Glassc1c4a8f2020-05-10 11:39:57 -0600407 struct disk_partition *info)
Rob Clark2b7bfd92017-09-09 13:15:55 -0400408{
409 info->start = 0;
Simon Glass54c709a2023-08-24 13:55:24 -0600410 info->size = desc->lba;
411 info->blksz = desc->blksz;
Rob Clark2b7bfd92017-09-09 13:15:55 -0400412 info->bootable = 0;
413 strcpy((char *)info->type, BOOT_PART_TYPE);
414 strcpy((char *)info->name, "Whole Disk");
Simon Glass23e34532023-08-24 13:55:31 -0600415 disk_partition_clr_uuid(info);
Simon Glassb8d3a782023-08-24 13:55:32 -0600416 disk_partition_clr_type_guid(info);
Rob Clark2b7bfd92017-09-09 13:15:55 -0400417
418 return 0;
419}
420
Simon Glasse6649a62016-02-29 15:25:43 -0700421int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
Simon Glass54c709a2023-08-24 13:55:24 -0600422 struct blk_desc **desc)
Stephen Warrenafd909c2012-09-21 09:50:56 +0000423{
424 char *ep;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600425 char *dup_str = NULL;
426 const char *dev_str, *hwpart_str;
427 int dev, hwpart;
428
429 hwpart_str = strchr(dev_hwpart_str, '.');
430 if (hwpart_str) {
431 dup_str = strdup(dev_hwpart_str);
432 dup_str[hwpart_str - dev_hwpart_str] = 0;
433 dev_str = dup_str;
434 hwpart_str++;
435 } else {
436 dev_str = dev_hwpart_str;
Stephen Warrenad17c0f2014-05-23 12:48:11 -0600437 hwpart = 0;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600438 }
Stephen Warrenafd909c2012-09-21 09:50:56 +0000439
Simon Glass3ff49ec2021-07-24 09:03:29 -0600440 dev = hextoul(dev_str, &ep);
Stephen Warrenafd909c2012-09-21 09:50:56 +0000441 if (*ep) {
442 printf("** Bad device specification %s %s **\n",
443 ifname, dev_str);
Simon Glass356e0e62016-05-01 13:52:36 -0600444 dev = -EINVAL;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600445 goto cleanup;
446 }
447
448 if (hwpart_str) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600449 hwpart = hextoul(hwpart_str, &ep);
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600450 if (*ep) {
451 printf("** Bad HW partition specification %s %s **\n",
452 ifname, hwpart_str);
Simon Glass356e0e62016-05-01 13:52:36 -0600453 dev = -EINVAL;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600454 goto cleanup;
455 }
Stephen Warrenafd909c2012-09-21 09:50:56 +0000456 }
457
Simon Glass54c709a2023-08-24 13:55:24 -0600458 *desc = get_dev_hwpart(ifname, dev, hwpart);
459 if (!(*desc) || ((*desc)->type == DEV_TYPE_UNKNOWN)) {
Sam Protsenko6839baf2018-07-30 19:19:27 +0300460 debug("** Bad device %s %s **\n", ifname, dev_hwpart_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500461 dev = -ENODEV;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600462 goto cleanup;
Stephen Warrenafd909c2012-09-21 09:50:56 +0000463 }
464
Simon Glassf5ac3032022-08-11 19:34:45 -0600465 if (blk_enabled()) {
466 /*
467 * Updates the partition table for the specified hw partition.
468 * Always should be done, otherwise hw partition 0 will return
469 * stale data after displaying a non-zero hw partition.
470 */
Simon Glass54c709a2023-08-24 13:55:24 -0600471 if ((*desc)->uclass_id == UCLASS_MMC)
472 part_init(*desc);
Simon Glassf5ac3032022-08-11 19:34:45 -0600473 }
Erik Tideman8d11b8e2016-01-11 13:39:07 +0000474
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600475cleanup:
476 free(dup_str);
Stephen Warrenafd909c2012-09-21 09:50:56 +0000477 return dev;
478}
479
Stephen Warrenc87ff222012-09-21 09:50:57 +0000480#define PART_UNSPECIFIED -2
481#define PART_AUTO -1
Simon Glasse76ee972016-02-29 15:25:44 -0700482int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
Simon Glass54c709a2023-08-24 13:55:24 -0600483 struct blk_desc **desc,
Simon Glassc1c4a8f2020-05-10 11:39:57 -0600484 struct disk_partition *info, int allow_whole_dev)
Rob Herringd586cec2012-09-21 04:08:17 +0000485{
Sean Andersone7bddea2021-02-05 09:38:55 -0500486 int ret;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000487 const char *part_str;
488 char *dup_str = NULL;
489 const char *dev_str;
Rob Herringd586cec2012-09-21 04:08:17 +0000490 int dev;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000491 char *ep;
492 int p;
493 int part;
Simon Glassc1c4a8f2020-05-10 11:39:57 -0600494 struct disk_partition tmpinfo;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000495
Simon Glass54c709a2023-08-24 13:55:24 -0600496 *desc = NULL;
Heinrich Schuchardtca3df482022-11-20 11:23:24 +0100497 memset(info, 0, sizeof(*info));
498
Sean Andersonc678b322022-03-22 16:59:20 -0400499#if IS_ENABLED(CONFIG_SANDBOX) || IS_ENABLED(CONFIG_SEMIHOSTING)
Stephen Warrenbff6c312014-06-12 10:28:32 -0600500 /*
Pavel Machek13334e72014-07-19 23:50:44 +0200501 * Special-case a pseudo block device "hostfs", to allow access to the
Stephen Warrenbff6c312014-06-12 10:28:32 -0600502 * host's own filesystem.
503 */
Heinrich Schuchardtca3df482022-11-20 11:23:24 +0100504 if (!strcmp(ifname, "hostfs")) {
Stephen Warrenbff6c312014-06-12 10:28:32 -0600505 strcpy((char *)info->type, BOOT_PART_TYPE);
Sean Andersonc678b322022-03-22 16:59:20 -0400506 strcpy((char *)info->name, "Host filesystem");
Stephen Warrenbff6c312014-06-12 10:28:32 -0600507
Hans de Goede690c7962015-09-17 18:46:58 -0400508 return 0;
509 }
510#endif
511
Stefan Herbrechtsmeier4f6968a2022-08-08 16:45:17 +0200512#if IS_ENABLED(CONFIG_CMD_UBIFS) && !IS_ENABLED(CONFIG_SPL_BUILD)
Hans de Goede690c7962015-09-17 18:46:58 -0400513 /*
Heinrich Schuchardta4388bb2019-04-10 18:59:26 +0200514 * Special-case ubi, ubi goes through a mtd, rather than through
Hans de Goede690c7962015-09-17 18:46:58 -0400515 * a regular block device.
516 */
Heinrich Schuchardtca3df482022-11-20 11:23:24 +0100517 if (!strcmp(ifname, "ubi")) {
Hans de Goede690c7962015-09-17 18:46:58 -0400518 if (!ubifs_is_mounted()) {
519 printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
Sean Andersone7bddea2021-02-05 09:38:55 -0500520 return -EINVAL;
Hans de Goede690c7962015-09-17 18:46:58 -0400521 }
522
Hans de Goede690c7962015-09-17 18:46:58 -0400523 strcpy((char *)info->type, BOOT_PART_TYPE);
524 strcpy((char *)info->name, "UBI");
Stephen Warrenbff6c312014-06-12 10:28:32 -0600525 return 0;
526 }
Hans de Goede4763ee32015-09-17 18:46:55 -0400527#endif
Stephen Warrenbff6c312014-06-12 10:28:32 -0600528
Stephen Warrenc87ff222012-09-21 09:50:57 +0000529 /* If no dev_part_str, use bootdevice environment variable */
Heinrich Schuchardt8c4279b2023-07-21 17:37:37 +0200530 if (CONFIG_IS_ENABLED(ENV_SUPPORT)) {
531 if (!dev_part_str || !strlen(dev_part_str) ||
532 !strcmp(dev_part_str, "-"))
533 dev_part_str = env_get("bootdevice");
534 }
Stephen Warrenc87ff222012-09-21 09:50:57 +0000535
536 /* If still no dev_part_str, it's an error */
537 if (!dev_part_str) {
538 printf("** No device specified **\n");
Sean Andersone7bddea2021-02-05 09:38:55 -0500539 ret = -ENODEV;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000540 goto cleanup;
541 }
542
543 /* Separate device and partition ID specification */
544 part_str = strchr(dev_part_str, ':');
545 if (part_str) {
546 dup_str = strdup(dev_part_str);
547 dup_str[part_str - dev_part_str] = 0;
548 dev_str = dup_str;
549 part_str++;
550 } else {
551 dev_str = dev_part_str;
552 }
Rob Herringd586cec2012-09-21 04:08:17 +0000553
Stephen Warrenc87ff222012-09-21 09:50:57 +0000554 /* Look up the device */
Simon Glass54c709a2023-08-24 13:55:24 -0600555 dev = blk_get_device_by_str(ifname, dev_str, desc);
Sean Andersone7bddea2021-02-05 09:38:55 -0500556 if (dev < 0) {
Oleksii Bidnichenko1c47ed22022-04-08 10:07:13 +0200557 printf("** Bad device specification %s %s **\n",
558 ifname, dev_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500559 ret = dev;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000560 goto cleanup;
Sean Andersone7bddea2021-02-05 09:38:55 -0500561 }
Rob Herringd586cec2012-09-21 04:08:17 +0000562
Stephen Warrenc87ff222012-09-21 09:50:57 +0000563 /* Convert partition ID string to number */
564 if (!part_str || !*part_str) {
565 part = PART_UNSPECIFIED;
566 } else if (!strcmp(part_str, "auto")) {
567 part = PART_AUTO;
568 } else {
569 /* Something specified -> use exactly that */
Simon Glass3ff49ec2021-07-24 09:03:29 -0600570 part = (int)hextoul(part_str, &ep);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000571 /*
572 * Less than whole string converted,
573 * or request for whole device, but caller requires partition.
574 */
575 if (*ep || (part == 0 && !allow_whole_dev)) {
576 printf("** Bad partition specification %s %s **\n",
577 ifname, dev_part_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500578 ret = -ENOENT;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000579 goto cleanup;
580 }
Rob Herringd586cec2012-09-21 04:08:17 +0000581 }
582
Stephen Warrenc87ff222012-09-21 09:50:57 +0000583 /*
584 * No partition table on device,
585 * or user requested partition 0 (entire device).
586 */
Simon Glass54c709a2023-08-24 13:55:24 -0600587 if (((*desc)->part_type == PART_TYPE_UNKNOWN) || !part) {
588 if (!(*desc)->lba) {
Stephen Warrenc87ff222012-09-21 09:50:57 +0000589 printf("** Bad device size - %s %s **\n", ifname,
590 dev_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500591 ret = -EINVAL;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000592 goto cleanup;
593 }
Rob Herringd586cec2012-09-21 04:08:17 +0000594
Stephen Warrenc87ff222012-09-21 09:50:57 +0000595 /*
596 * If user specified a partition ID other than 0,
597 * or the calling command only accepts partitions,
598 * it's an error.
599 */
600 if ((part > 0) || (!allow_whole_dev)) {
601 printf("** No partition table - %s %s **\n", ifname,
602 dev_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500603 ret = -EPROTONOSUPPORT;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000604 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000605 }
Stephen Warrenc87ff222012-09-21 09:50:57 +0000606
Simon Glass54c709a2023-08-24 13:55:24 -0600607 (*desc)->log2blksz = LOG2((*desc)->blksz);
Lan Yixun (dlan)138914e2013-07-20 08:17:59 +0800608
Simon Glass54c709a2023-08-24 13:55:24 -0600609 part_get_info_whole_disk(*desc, info);
Rob Herringd586cec2012-09-21 04:08:17 +0000610
Stephen Warrenc87ff222012-09-21 09:50:57 +0000611 ret = 0;
612 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000613 }
614
Stephen Warrenc87ff222012-09-21 09:50:57 +0000615 /*
616 * Now there's known to be a partition table,
617 * not specifying a partition means to pick partition 1.
618 */
619 if (part == PART_UNSPECIFIED)
620 part = 1;
Rob Herringd586cec2012-09-21 04:08:17 +0000621
Stephen Warrenc87ff222012-09-21 09:50:57 +0000622 /*
623 * If user didn't specify a partition number, or did specify something
624 * other than "auto", use that partition number directly.
625 */
626 if (part != PART_AUTO) {
Simon Glass54c709a2023-08-24 13:55:24 -0600627 ret = part_get_info(*desc, part, info);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000628 if (ret) {
629 printf("** Invalid partition %d **\n", part);
630 goto cleanup;
631 }
632 } else {
633 /*
634 * Find the first bootable partition.
635 * If none are bootable, fall back to the first valid partition.
636 */
637 part = 0;
638 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
Simon Glass54c709a2023-08-24 13:55:24 -0600639 ret = part_get_info(*desc, p, info);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000640 if (ret)
641 continue;
642
643 /*
644 * First valid partition, or new better partition?
645 * If so, save partition ID.
646 */
647 if (!part || info->bootable)
648 part = p;
649
650 /* Best possible partition? Stop searching. */
651 if (info->bootable)
652 break;
653
654 /*
655 * We now need to search further for best possible.
656 * If we what we just queried was the best so far,
657 * save the info since we over-write it next loop.
658 */
659 if (part == p)
660 tmpinfo = *info;
661 }
662 /* If we found any acceptable partition */
663 if (part) {
664 /*
665 * If we searched all possible partition IDs,
666 * return the first valid partition we found.
667 */
668 if (p == MAX_SEARCH_PARTITIONS + 1)
669 *info = tmpinfo;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000670 } else {
671 printf("** No valid partitions found **\n");
672 goto cleanup;
673 }
Rob Herringd586cec2012-09-21 04:08:17 +0000674 }
675 if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
676 printf("** Invalid partition type \"%.32s\""
677 " (expect \"" BOOT_PART_TYPE "\")\n",
678 info->type);
Sean Andersone7bddea2021-02-05 09:38:55 -0500679 ret = -EINVAL;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000680 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000681 }
682
Simon Glass54c709a2023-08-24 13:55:24 -0600683 (*desc)->log2blksz = LOG2((*desc)->blksz);
Lan Yixun (dlan)138914e2013-07-20 08:17:59 +0800684
Stephen Warrenc87ff222012-09-21 09:50:57 +0000685 ret = part;
686 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000687
Stephen Warrenc87ff222012-09-21 09:50:57 +0000688cleanup:
689 free(dup_str);
690 return ret;
Rob Herringd586cec2012-09-21 04:08:17 +0000691}
Petr Kulhavy712257e2016-09-09 10:27:15 +0200692
Simon Glass54c709a2023-08-24 13:55:24 -0600693int part_get_info_by_name(struct blk_desc *desc, const char *name,
Heinrich Schuchardt861cb612023-07-16 13:34:44 +0200694 struct disk_partition *info)
Petr Kulhavy712257e2016-09-09 10:27:15 +0200695{
Petr Kulhavy712257e2016-09-09 10:27:15 +0200696 struct part_driver *part_drv;
Kever Yang91829662018-02-10 17:55:38 +0800697 int ret;
698 int i;
Petr Kulhavy712257e2016-09-09 10:27:15 +0200699
Simon Glass54c709a2023-08-24 13:55:24 -0600700 part_drv = part_driver_lookup_type(desc);
Kever Yang91829662018-02-10 17:55:38 +0800701 if (!part_drv)
702 return -1;
schspa669030a2021-10-20 20:15:55 +0800703
704 if (!part_drv->get_info) {
705 log_debug("## Driver %s does not have the get_info() method\n",
706 part_drv->name);
707 return -ENOSYS;
708 }
709
Kever Yang91829662018-02-10 17:55:38 +0800710 for (i = 1; i < part_drv->max_entries; i++) {
Simon Glass54c709a2023-08-24 13:55:24 -0600711 ret = part_drv->get_info(desc, i, info);
Kever Yang91829662018-02-10 17:55:38 +0800712 if (ret != 0) {
713 /* no more entries in table */
714 break;
715 }
716 if (strcmp(name, (const char *)info->name) == 0) {
717 /* matched */
718 return i;
Petr Kulhavy712257e2016-09-09 10:27:15 +0200719 }
720 }
Kever Yang91829662018-02-10 17:55:38 +0800721
Sean Andersone7bddea2021-02-05 09:38:55 -0500722 return -ENOENT;
Petr Kulhavy712257e2016-09-09 10:27:15 +0200723}
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200724
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300725/**
726 * Get partition info from device number and partition name.
727 *
728 * Parse a device number and partition name string in the form of
Sean Anderson2a1ced72021-02-05 09:38:57 -0500729 * "devicenum.hwpartnum#partition_name", for example "0.1#misc". devicenum and
730 * hwpartnum are both optional, defaulting to 0. If the partition is found,
Simon Glass54c709a2023-08-24 13:55:24 -0600731 * sets desc and part_info accordingly with the information of the
Sean Anderson2a1ced72021-02-05 09:38:57 -0500732 * partition with the given partition_name.
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300733 *
734 * @param[in] dev_iface Device interface
Sean Anderson2a1ced72021-02-05 09:38:57 -0500735 * @param[in] dev_part_str Input string argument, like "0.1#misc"
Simon Glass54c709a2023-08-24 13:55:24 -0600736 * @param[out] desc Place to store the device description pointer
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300737 * @param[out] part_info Place to store the partition information
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100738 * Return: 0 on success, or a negative on error
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300739 */
740static int part_get_info_by_dev_and_name(const char *dev_iface,
741 const char *dev_part_str,
Simon Glass54c709a2023-08-24 13:55:24 -0600742 struct blk_desc **desc,
Simon Glassc1c4a8f2020-05-10 11:39:57 -0600743 struct disk_partition *part_info)
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300744{
Sean Anderson2a1ced72021-02-05 09:38:57 -0500745 char *dup_str = NULL;
746 const char *dev_str, *part_str;
747 int ret;
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300748
Sean Anderson2a1ced72021-02-05 09:38:57 -0500749 /* Separate device and partition name specification */
Sean Andersoncecd47c2021-05-15 14:13:54 -0400750 if (dev_part_str)
751 part_str = strchr(dev_part_str, '#');
752 else
753 part_str = NULL;
754
Sean Anderson2a1ced72021-02-05 09:38:57 -0500755 if (part_str) {
756 dup_str = strdup(dev_part_str);
757 dup_str[part_str - dev_part_str] = 0;
758 dev_str = dup_str;
759 part_str++;
760 } else {
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300761 return -EINVAL;
762 }
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300763
Simon Glass54c709a2023-08-24 13:55:24 -0600764 ret = blk_get_device_by_str(dev_iface, dev_str, desc);
Sean Andersoncb195232021-04-12 18:53:06 -0400765 if (ret < 0)
Sean Anderson2a1ced72021-02-05 09:38:57 -0500766 goto cleanup;
767
Simon Glass54c709a2023-08-24 13:55:24 -0600768 ret = part_get_info_by_name(*desc, part_str, part_info);
Sean Andersone7bddea2021-02-05 09:38:55 -0500769 if (ret < 0)
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300770 printf("Could not find \"%s\" partition\n", part_str);
Sean Anderson2a1ced72021-02-05 09:38:57 -0500771
772cleanup:
773 free(dup_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500774 return ret;
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300775}
776
777int part_get_info_by_dev_and_name_or_num(const char *dev_iface,
778 const char *dev_part_str,
Simon Glass54c709a2023-08-24 13:55:24 -0600779 struct blk_desc **desc,
Sean Andersonc81028d2021-02-05 09:38:56 -0500780 struct disk_partition *part_info,
781 int allow_whole_dev)
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300782{
Sean Andersone7bddea2021-02-05 09:38:55 -0500783 int ret;
784
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300785 /* Split the part_name if passed as "$dev_num#part_name". */
Simon Glass54c709a2023-08-24 13:55:24 -0600786 ret = part_get_info_by_dev_and_name(dev_iface, dev_part_str, desc,
787 part_info);
Sean Andersone7bddea2021-02-05 09:38:55 -0500788 if (ret >= 0)
789 return ret;
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300790 /*
791 * Couldn't lookup by name, try looking up the partition description
792 * directly.
793 */
Simon Glass54c709a2023-08-24 13:55:24 -0600794 ret = blk_get_device_part_str(dev_iface, dev_part_str, desc, part_info,
795 allow_whole_dev);
Sean Andersone7bddea2021-02-05 09:38:55 -0500796 if (ret < 0)
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300797 printf("Couldn't find partition %s %s\n",
798 dev_iface, dev_part_str);
Sean Andersone7bddea2021-02-05 09:38:55 -0500799 return ret;
Ruslan Trofymenko5e171ef2019-07-05 15:37:31 +0300800}
801
Simon Glass54c709a2023-08-24 13:55:24 -0600802void part_set_generic_name(const struct blk_desc *desc, int part_num,
803 char *name)
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200804{
805 char *devtype;
806
Simon Glass54c709a2023-08-24 13:55:24 -0600807 switch (desc->uclass_id) {
Simon Glassdbfa32c2022-08-11 19:34:59 -0600808 case UCLASS_IDE:
809 case UCLASS_AHCI:
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200810 devtype = "hd";
811 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600812 case UCLASS_SCSI:
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200813 devtype = "sd";
814 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600815 case UCLASS_USB:
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200816 devtype = "usbd";
817 break;
Simon Glassdbfa32c2022-08-11 19:34:59 -0600818 case UCLASS_MMC:
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200819 devtype = "mmcsd";
820 break;
821 default:
822 devtype = "xx";
823 break;
824 }
825
Simon Glass54c709a2023-08-24 13:55:24 -0600826 sprintf(name, "%s%c%d", devtype, 'a' + desc->devnum, part_num);
Petr Kulhavy2e790d52016-09-09 10:27:17 +0200827}
Simon Glassf5e2df02023-01-17 10:47:41 -0700828
829int part_get_bootable(struct blk_desc *desc)
830{
831 struct disk_partition info;
832 int p;
833
834 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
835 int ret;
836
837 ret = part_get_info(desc, p, &info);
838 if (!ret && info.bootable)
839 return p;
840 }
841
842 return 0;
843}