blob: e70bef5aabed0de6349d031e4a7f80cea7290d0f [file] [log] [blame]
wdenkaffae2b2002-08-17 09:36:01 +00001/*
2 * (C) Copyright 2001
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
Wolfgang Denkd79de1d2013-07-08 09:37:19 +02005 * SPDX-License-Identifier: GPL-2.0+
wdenkaffae2b2002-08-17 09:36:01 +00006 */
7
8#include <common.h>
9#include <command.h>
Simon Glass83ce5632016-02-29 15:25:47 -070010#include <errno.h>
wdenkaffae2b2002-08-17 09:36:01 +000011#include <ide.h>
Stephen Warrenc87ff222012-09-21 09:50:57 +000012#include <malloc.h>
Grant Likelyffc2dd72007-02-20 09:04:34 +010013#include <part.h>
Hans de Goede690c7962015-09-17 18:46:58 -040014#include <ubifs_uboot.h>
wdenkaffae2b2002-08-17 09:36:01 +000015
16#undef PART_DEBUG
17
18#ifdef PART_DEBUG
19#define PRINTF(fmt,args...) printf (fmt ,##args)
20#else
21#define PRINTF(fmt,args...)
22#endif
23
Alexander Graf3b3d9152016-03-04 01:09:56 +010024const struct block_drvr block_drvr[] = {
Jon Loeligerf7f54a82007-07-09 17:22:37 -050025#if defined(CONFIG_CMD_IDE)
Simon Glass844ef1d2016-05-01 11:36:14 -060026 { .name = "ide", },
Grant Likelyffc2dd72007-02-20 09:04:34 +010027#endif
Dave Liu76596ba2008-03-26 22:49:44 +080028#if defined(CONFIG_CMD_SATA)
29 {.name = "sata", .get_dev = sata_get_dev, },
30#endif
Simon Glass8706b812016-05-01 11:36:02 -060031#if defined(CONFIG_SCSI)
Grant Likelyffc2dd72007-02-20 09:04:34 +010032 { .name = "scsi", .get_dev = scsi_get_dev, },
33#endif
Jon Loeligerf7f54a82007-07-09 17:22:37 -050034#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
Simon Glasscf437782016-05-01 11:36:13 -060035 { .name = "usb", },
Grant Likelyffc2dd72007-02-20 09:04:34 +010036#endif
37#if defined(CONFIG_MMC)
Stephen Warren52c44e42014-05-07 12:19:02 -060038 {
39 .name = "mmc",
Stephen Warren52c44e42014-05-07 12:19:02 -060040 .select_hwpart = mmc_select_hwpart,
41 },
Grant Likelyffc2dd72007-02-20 09:04:34 +010042#endif
43#if defined(CONFIG_SYSTEMACE)
44 { .name = "ace", .get_dev = systemace_get_dev, },
45#endif
Henrik Nordström26f9a6c2013-11-10 10:26:56 -070046#if defined(CONFIG_SANDBOX)
47 { .name = "host", .get_dev = host_get_dev, },
48#endif
Grant Likelyffc2dd72007-02-20 09:04:34 +010049 { },
50};
51
Stefan Roese61ddee42007-02-20 13:21:57 +010052DECLARE_GLOBAL_DATA_PTR;
Stefan Roese61ddee42007-02-20 13:21:57 +010053
Gabe Black0fc71b52012-10-12 14:26:08 +000054#ifdef HAVE_BLOCK_DEVICE
Simon Glass83ce5632016-02-29 15:25:47 -070055static struct part_driver *part_driver_lookup_type(int part_type)
56{
57 struct part_driver *drv =
58 ll_entry_start(struct part_driver, part_driver);
59 const int n_ents = ll_entry_count(struct part_driver, part_driver);
60 struct part_driver *entry;
61
62 for (entry = drv; entry != drv + n_ents; entry++) {
63 if (part_type == entry->part_type)
64 return entry;
65 }
66
67 /* Not found */
68 return NULL;
69}
70
Simon Glasse3394752016-02-29 15:25:34 -070071static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
Grant Likelyffc2dd72007-02-20 09:04:34 +010072{
73 const struct block_drvr *drvr = block_drvr;
Stephen Warrenaeca52f2014-05-07 12:19:01 -060074 int (*select_hwpart)(int dev_num, int hwpart);
Heiko Schocher9b987232010-09-17 13:10:36 +020075 char *name;
Stephen Warrenaeca52f2014-05-07 12:19:01 -060076 int ret;
Grant Likelyffc2dd72007-02-20 09:04:34 +010077
Tim Kientzle47e444c2012-03-27 11:43:25 +020078 if (!ifname)
79 return NULL;
80
Heiko Schocher9b987232010-09-17 13:10:36 +020081 name = drvr->name;
Wolfgang Denkd0813e52010-10-28 20:00:11 +020082#ifdef CONFIG_NEEDS_MANUAL_RELOC
Heiko Schocher9b987232010-09-17 13:10:36 +020083 name += gd->reloc_off;
84#endif
Lei Wen2a010672011-02-15 16:56:40 +080085 while (drvr->name) {
Heiko Schocher9b987232010-09-17 13:10:36 +020086 name = drvr->name;
Stephen Warrenaeca52f2014-05-07 12:19:01 -060087 select_hwpart = drvr->select_hwpart;
Wolfgang Denkd0813e52010-10-28 20:00:11 +020088#ifdef CONFIG_NEEDS_MANUAL_RELOC
Heiko Schocher9b987232010-09-17 13:10:36 +020089 name += gd->reloc_off;
Stephen Warrenaeca52f2014-05-07 12:19:01 -060090 if (select_hwpart)
91 select_hwpart += gd->reloc_off;
Peter Tyser9057cbf2009-09-21 11:20:36 -050092#endif
Stephen Warrenaeca52f2014-05-07 12:19:01 -060093 if (strncmp(ifname, name, strlen(name)) == 0) {
Simon Glass61c74962016-05-01 11:36:12 -060094 struct blk_desc *dev_desc;
95
96 dev_desc = blk_get_devnum_by_typename(name, dev);
Stephen Warrenaeca52f2014-05-07 12:19:01 -060097 if (!dev_desc)
98 return NULL;
Stephen Warrenad17c0f2014-05-23 12:48:11 -060099 if (hwpart == 0 && !select_hwpart)
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600100 return dev_desc;
101 if (!select_hwpart)
102 return NULL;
Simon Glass2f26fff2016-02-29 15:25:51 -0700103 ret = select_hwpart(dev_desc->devnum, hwpart);
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600104 if (ret < 0)
105 return NULL;
106 return dev_desc;
107 }
Grant Likelyffc2dd72007-02-20 09:04:34 +0100108 drvr++;
109 }
110 return NULL;
111}
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600112
Simon Glassbe1e9bb2016-02-29 15:25:42 -0700113struct blk_desc *blk_get_dev(const char *ifname, int dev)
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600114{
Stephen Warrenad17c0f2014-05-23 12:48:11 -0600115 return get_dev_hwpart(ifname, dev, 0);
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600116}
Grant Likelyffc2dd72007-02-20 09:04:34 +0100117#else
Simon Glasse3394752016-02-29 15:25:34 -0700118struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600119{
120 return NULL;
121}
122
Simon Glassbe1e9bb2016-02-29 15:25:42 -0700123struct blk_desc *blk_get_dev(const char *ifname, int dev)
Grant Likelyffc2dd72007-02-20 09:04:34 +0100124{
125 return NULL;
126}
127#endif
128
Gabe Black0fc71b52012-10-12 14:26:08 +0000129#ifdef HAVE_BLOCK_DEVICE
Grant Likelyffc2dd72007-02-20 09:04:34 +0100130
wdenkaffae2b2002-08-17 09:36:01 +0000131/* ------------------------------------------------------------------------- */
132/*
133 * reports device info to the user
134 */
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300135
wdenkc35ba4e2004-03-14 22:25:36 +0000136#ifdef CONFIG_LBA48
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300137typedef uint64_t lba512_t;
wdenkf602aa02004-03-13 23:29:43 +0000138#else
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300139typedef lbaint_t lba512_t;
wdenkf602aa02004-03-13 23:29:43 +0000140#endif
wdenkaffae2b2002-08-17 09:36:01 +0000141
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300142/*
143 * Overflowless variant of (block_count * mul_by / div_by)
144 * when div_by > mul_by
145 */
Pavel Macheka4264e12014-09-09 15:19:42 +0200146static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, lba512_t div_by)
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300147{
148 lba512_t bc_quot, bc_rem;
149
150 /* x * m / d == x / d * m + (x % d) * m / d */
151 bc_quot = block_count / div_by;
152 bc_rem = block_count - div_by * bc_quot;
153 return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
154}
155
Simon Glasse3394752016-02-29 15:25:34 -0700156void dev_print (struct blk_desc *dev_desc)
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300157{
158 lba512_t lba512; /* number of blocks if 512bytes block size */
159
Wolfgang Denk8561e712009-05-15 09:27:58 +0200160 if (dev_desc->type == DEV_TYPE_UNKNOWN) {
161 puts ("not available\n");
162 return;
163 }
164
Tor Krill03ff3302008-05-29 11:10:30 +0200165 switch (dev_desc->if_type) {
Detlev Zundelbec6b322008-05-05 16:11:21 +0200166 case IF_TYPE_SCSI:
167 printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
168 dev_desc->target,dev_desc->lun,
wdenkaffae2b2002-08-17 09:36:01 +0000169 dev_desc->vendor,
Detlev Zundelbec6b322008-05-05 16:11:21 +0200170 dev_desc->product,
171 dev_desc->revision);
172 break;
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200173 case IF_TYPE_ATAPI:
Detlev Zundelbec6b322008-05-05 16:11:21 +0200174 case IF_TYPE_IDE:
175 case IF_TYPE_SATA:
Dave Liu76596ba2008-03-26 22:49:44 +0800176 printf ("Model: %s Firm: %s Ser#: %s\n",
177 dev_desc->vendor,
178 dev_desc->revision,
179 dev_desc->product);
Detlev Zundelbec6b322008-05-05 16:11:21 +0200180 break;
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200181 case IF_TYPE_SD:
182 case IF_TYPE_MMC:
Nícolas Carneiro Lebedencoef3edd42008-09-04 15:35:46 -0300183 case IF_TYPE_USB:
184 printf ("Vendor: %s Rev: %s Prod: %s\n",
185 dev_desc->vendor,
186 dev_desc->revision,
187 dev_desc->product);
188 break;
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200189 case IF_TYPE_DOC:
190 puts("device type DOC\n");
191 return;
Tor Krill03ff3302008-05-29 11:10:30 +0200192 case IF_TYPE_UNKNOWN:
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200193 puts("device type unknown\n");
194 return;
Detlev Zundelbec6b322008-05-05 16:11:21 +0200195 default:
Remy Bohmerf9f718b2008-09-19 13:30:06 +0200196 printf("Unhandled device type: %i\n", dev_desc->if_type);
Detlev Zundelbec6b322008-05-05 16:11:21 +0200197 return;
wdenkaffae2b2002-08-17 09:36:01 +0000198 }
199 puts (" Type: ");
200 if (dev_desc->removable)
201 puts ("Removable ");
202 switch (dev_desc->type & 0x1F) {
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200203 case DEV_TYPE_HARDDISK:
204 puts ("Hard Disk");
205 break;
206 case DEV_TYPE_CDROM:
207 puts ("CD ROM");
208 break;
209 case DEV_TYPE_OPDISK:
210 puts ("Optical Device");
211 break;
212 case DEV_TYPE_TAPE:
213 puts ("Tape");
214 break;
215 default:
216 printf ("# %02X #", dev_desc->type & 0x1F);
217 break;
wdenkaffae2b2002-08-17 09:36:01 +0000218 }
219 puts ("\n");
Jerry Huang6a4feb42012-11-06 15:33:12 +0000220 if (dev_desc->lba > 0L && dev_desc->blksz > 0L) {
wdenkaffae2b2002-08-17 09:36:01 +0000221 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
wdenkf602aa02004-03-13 23:29:43 +0000222 lbaint_t lba;
wdenk05939202004-04-18 17:39:38 +0000223
224 lba = dev_desc->lba;
wdenkaffae2b2002-08-17 09:36:01 +0000225
wdenkf602aa02004-03-13 23:29:43 +0000226 lba512 = (lba * (dev_desc->blksz/512));
wdenkaffae2b2002-08-17 09:36:01 +0000227 /* round to 1 digit */
Pavel Macheka4264e12014-09-09 15:19:42 +0200228 /* 2048 = (1024 * 1024) / 512 MB */
229 mb = lba512_muldiv(lba512, 10, 2048);
Sergei Trofimovich89d935b2010-08-08 15:05:39 +0300230
wdenkaffae2b2002-08-17 09:36:01 +0000231 mb_quot = mb / 10;
232 mb_rem = mb - (10 * mb_quot);
233
234 gb = mb / 1024;
235 gb_quot = gb / 10;
236 gb_rem = gb - (10 * gb_quot);
wdenkc35ba4e2004-03-14 22:25:36 +0000237#ifdef CONFIG_LBA48
wdenk05939202004-04-18 17:39:38 +0000238 if (dev_desc->lba48)
wdenkf602aa02004-03-13 23:29:43 +0000239 printf (" Supports 48-bit addressing\n");
240#endif
Heiko Schocher0f602e12009-12-03 11:21:21 +0100241#if defined(CONFIG_SYS_64BIT_LBA)
Mike Frysinger2b745dc2009-02-16 23:21:36 -0500242 printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n",
wdenkf602aa02004-03-13 23:29:43 +0000243 mb_quot, mb_rem,
244 gb_quot, gb_rem,
245 lba,
246 dev_desc->blksz);
247#else
wdenkaffae2b2002-08-17 09:36:01 +0000248 printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n",
249 mb_quot, mb_rem,
250 gb_quot, gb_rem,
wdenkf602aa02004-03-13 23:29:43 +0000251 (ulong)lba,
wdenkaffae2b2002-08-17 09:36:01 +0000252 dev_desc->blksz);
wdenkf602aa02004-03-13 23:29:43 +0000253#endif
wdenkaffae2b2002-08-17 09:36:01 +0000254 } else {
255 puts (" Capacity: not available\n");
256 }
257}
Jon Loeliger1670a5b2007-07-10 11:19:50 -0500258#endif
wdenkaffae2b2002-08-17 09:36:01 +0000259
Gabe Black0fc71b52012-10-12 14:26:08 +0000260#ifdef HAVE_BLOCK_DEVICE
wdenkaffae2b2002-08-17 09:36:01 +0000261
Simon Glassb89a8442016-02-29 15:25:48 -0700262void part_init(struct blk_desc *dev_desc)
wdenkaffae2b2002-08-17 09:36:01 +0000263{
Simon Glass83ce5632016-02-29 15:25:47 -0700264 struct part_driver *drv =
265 ll_entry_start(struct part_driver, part_driver);
266 const int n_ents = ll_entry_count(struct part_driver, part_driver);
267 struct part_driver *entry;
richardretanubune6745592008-09-26 11:13:22 -0400268
Eric Nelsonfaf4f052016-03-28 10:05:44 -0700269 blkcache_invalidate(dev_desc->if_type, dev_desc->devnum);
270
Simon Glass83ce5632016-02-29 15:25:47 -0700271 dev_desc->part_type = PART_TYPE_UNKNOWN;
272 for (entry = drv; entry != drv + n_ents; entry++) {
273 int ret;
wdenk452cfd62002-11-19 11:04:11 +0000274
Simon Glass83ce5632016-02-29 15:25:47 -0700275 ret = entry->test(dev_desc);
276 debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
277 if (!ret) {
278 dev_desc->part_type = entry->part_type;
279 break;
280 }
wdenk452cfd62002-11-19 11:04:11 +0000281 }
wdenkaffae2b2002-08-17 09:36:01 +0000282}
283
Simon Glass83ce5632016-02-29 15:25:47 -0700284static void print_part_header(const char *type, struct blk_desc *dev_desc)
285{
Gabe Black0fc71b52012-10-12 14:26:08 +0000286#if defined(CONFIG_MAC_PARTITION) || \
287 defined(CONFIG_DOS_PARTITION) || \
288 defined(CONFIG_ISO_PARTITION) || \
289 defined(CONFIG_AMIGA_PARTITION) || \
290 defined(CONFIG_EFI_PARTITION)
wdenkaffae2b2002-08-17 09:36:01 +0000291 puts ("\nPartition Map for ");
292 switch (dev_desc->if_type) {
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200293 case IF_TYPE_IDE:
294 puts ("IDE");
295 break;
296 case IF_TYPE_SATA:
297 puts ("SATA");
298 break;
299 case IF_TYPE_SCSI:
300 puts ("SCSI");
301 break;
302 case IF_TYPE_ATAPI:
303 puts ("ATAPI");
304 break;
305 case IF_TYPE_USB:
306 puts ("USB");
307 break;
308 case IF_TYPE_DOC:
309 puts ("DOC");
310 break;
Lei Wen61dba932010-09-13 22:07:28 +0800311 case IF_TYPE_MMC:
312 puts ("MMC");
313 break;
Henrik Nordström26f9a6c2013-11-10 10:26:56 -0700314 case IF_TYPE_HOST:
315 puts("HOST");
316 break;
Detlev Zundel0e11cc62008-05-05 16:11:22 +0200317 default:
318 puts ("UNKNOWN");
319 break;
wdenkaffae2b2002-08-17 09:36:01 +0000320 }
321 printf (" device %d -- Partition Type: %s\n\n",
Simon Glass2f26fff2016-02-29 15:25:51 -0700322 dev_desc->devnum, type);
Gabe Black0fc71b52012-10-12 14:26:08 +0000323#endif /* any CONFIG_..._PARTITION */
Simon Glass83ce5632016-02-29 15:25:47 -0700324}
Gabe Black0fc71b52012-10-12 14:26:08 +0000325
Simon Glassb89a8442016-02-29 15:25:48 -0700326void part_print(struct blk_desc *dev_desc)
wdenkaffae2b2002-08-17 09:36:01 +0000327{
Simon Glass83ce5632016-02-29 15:25:47 -0700328 struct part_driver *drv;
wdenkaffae2b2002-08-17 09:36:01 +0000329
Simon Glass83ce5632016-02-29 15:25:47 -0700330 drv = part_driver_lookup_type(dev_desc->part_type);
331 if (!drv) {
332 printf("## Unknown partition table type %x\n",
333 dev_desc->part_type);
wdenkaffae2b2002-08-17 09:36:01 +0000334 return;
wdenkaffae2b2002-08-17 09:36:01 +0000335 }
Simon Glass83ce5632016-02-29 15:25:47 -0700336
337 PRINTF("## Testing for valid %s partition ##\n", drv->name);
338 print_part_header(drv->name, dev_desc);
339 if (drv->print)
340 drv->print(dev_desc);
wdenkaffae2b2002-08-17 09:36:01 +0000341}
342
Gabe Black0fc71b52012-10-12 14:26:08 +0000343#endif /* HAVE_BLOCK_DEVICE */
Stephen Warren07c5bff2012-09-21 12:46:54 +0000344
Simon Glassb89a8442016-02-29 15:25:48 -0700345int part_get_info(struct blk_desc *dev_desc, int part,
Pavel Machek13334e72014-07-19 23:50:44 +0200346 disk_partition_t *info)
Stephen Warren07c5bff2012-09-21 12:46:54 +0000347{
Gabe Black0fc71b52012-10-12 14:26:08 +0000348#ifdef HAVE_BLOCK_DEVICE
Simon Glass83ce5632016-02-29 15:25:47 -0700349 struct part_driver *drv;
Stephen Warren07c5bff2012-09-21 12:46:54 +0000350
Stephen Warrenc6c7b7a2012-09-21 09:50:59 +0000351#ifdef CONFIG_PARTITION_UUIDS
352 /* The common case is no UUID support */
353 info->uuid[0] = 0;
354#endif
Patrick Delaunay8248c8d2015-10-27 11:00:27 +0100355#ifdef CONFIG_PARTITION_TYPE_GUID
356 info->type_guid[0] = 0;
357#endif
Stephen Warrenc6c7b7a2012-09-21 09:50:59 +0000358
Simon Glass83ce5632016-02-29 15:25:47 -0700359 drv = part_driver_lookup_type(dev_desc->part_type);
360 if (!drv) {
361 debug("## Unknown partition table type %x\n",
362 dev_desc->part_type);
363 return -EPROTONOSUPPORT;
364 }
365 if (!drv->get_info) {
Nishanth Menonef1851a2016-03-15 16:15:32 -0500366 PRINTF("## Driver %s does not have the get_info() method\n",
367 drv->name);
Simon Glass83ce5632016-02-29 15:25:47 -0700368 return -ENOSYS;
369 }
370 if (drv->get_info(dev_desc, part, info) == 0) {
371 PRINTF("## Valid %s partition found ##\n", drv->name);
372 return 0;
Stephen Warren07c5bff2012-09-21 12:46:54 +0000373 }
Gabe Black0fc71b52012-10-12 14:26:08 +0000374#endif /* HAVE_BLOCK_DEVICE */
Stephen Warren07c5bff2012-09-21 12:46:54 +0000375
376 return -1;
377}
Rob Herringd586cec2012-09-21 04:08:17 +0000378
Simon Glasse6649a62016-02-29 15:25:43 -0700379int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
380 struct blk_desc **dev_desc)
Stephen Warrenafd909c2012-09-21 09:50:56 +0000381{
382 char *ep;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600383 char *dup_str = NULL;
384 const char *dev_str, *hwpart_str;
385 int dev, hwpart;
386
387 hwpart_str = strchr(dev_hwpart_str, '.');
388 if (hwpart_str) {
389 dup_str = strdup(dev_hwpart_str);
390 dup_str[hwpart_str - dev_hwpart_str] = 0;
391 dev_str = dup_str;
392 hwpart_str++;
393 } else {
394 dev_str = dev_hwpart_str;
Stephen Warrenad17c0f2014-05-23 12:48:11 -0600395 hwpart = 0;
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600396 }
Stephen Warrenafd909c2012-09-21 09:50:56 +0000397
398 dev = simple_strtoul(dev_str, &ep, 16);
399 if (*ep) {
400 printf("** Bad device specification %s %s **\n",
401 ifname, dev_str);
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600402 dev = -1;
403 goto cleanup;
404 }
405
406 if (hwpart_str) {
407 hwpart = simple_strtoul(hwpart_str, &ep, 16);
408 if (*ep) {
409 printf("** Bad HW partition specification %s %s **\n",
410 ifname, hwpart_str);
411 dev = -1;
412 goto cleanup;
413 }
Stephen Warrenafd909c2012-09-21 09:50:56 +0000414 }
415
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600416 *dev_desc = get_dev_hwpart(ifname, dev, hwpart);
Stephen Warrenafd909c2012-09-21 09:50:56 +0000417 if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600418 printf("** Bad device %s %s **\n", ifname, dev_hwpart_str);
419 dev = -1;
420 goto cleanup;
Stephen Warrenafd909c2012-09-21 09:50:56 +0000421 }
422
Erik Tideman8d11b8e2016-01-11 13:39:07 +0000423#ifdef HAVE_BLOCK_DEVICE
424 /*
425 * Updates the partition table for the specified hw partition.
426 * Does not need to be done for hwpart 0 since it is default and
427 * already loaded.
428 */
429 if(hwpart != 0)
Simon Glassb89a8442016-02-29 15:25:48 -0700430 part_init(*dev_desc);
Erik Tideman8d11b8e2016-01-11 13:39:07 +0000431#endif
432
Stephen Warrenaeca52f2014-05-07 12:19:01 -0600433cleanup:
434 free(dup_str);
Stephen Warrenafd909c2012-09-21 09:50:56 +0000435 return dev;
436}
437
Stephen Warrenc87ff222012-09-21 09:50:57 +0000438#define PART_UNSPECIFIED -2
439#define PART_AUTO -1
440#define MAX_SEARCH_PARTITIONS 16
Simon Glasse76ee972016-02-29 15:25:44 -0700441int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
Simon Glasse3394752016-02-29 15:25:34 -0700442 struct blk_desc **dev_desc,
Stephen Warrenc87ff222012-09-21 09:50:57 +0000443 disk_partition_t *info, int allow_whole_dev)
Rob Herringd586cec2012-09-21 04:08:17 +0000444{
Stephen Warrenc87ff222012-09-21 09:50:57 +0000445 int ret = -1;
446 const char *part_str;
447 char *dup_str = NULL;
448 const char *dev_str;
Rob Herringd586cec2012-09-21 04:08:17 +0000449 int dev;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000450 char *ep;
451 int p;
452 int part;
453 disk_partition_t tmpinfo;
454
Hans de Goede4763ee32015-09-17 18:46:55 -0400455#ifdef CONFIG_SANDBOX
Stephen Warrenbff6c312014-06-12 10:28:32 -0600456 /*
Pavel Machek13334e72014-07-19 23:50:44 +0200457 * Special-case a pseudo block device "hostfs", to allow access to the
Stephen Warrenbff6c312014-06-12 10:28:32 -0600458 * host's own filesystem.
459 */
460 if (0 == strcmp(ifname, "hostfs")) {
461 *dev_desc = NULL;
462 info->start = 0;
463 info->size = 0;
464 info->blksz = 0;
465 info->bootable = 0;
466 strcpy((char *)info->type, BOOT_PART_TYPE);
467 strcpy((char *)info->name, "Sandbox host");
468#ifdef CONFIG_PARTITION_UUIDS
469 info->uuid[0] = 0;
470#endif
Patrick Delaunay8248c8d2015-10-27 11:00:27 +0100471#ifdef CONFIG_PARTITION_TYPE_GUID
472 info->type_guid[0] = 0;
473#endif
Stephen Warrenbff6c312014-06-12 10:28:32 -0600474
Hans de Goede690c7962015-09-17 18:46:58 -0400475 return 0;
476 }
477#endif
478
479#ifdef CONFIG_CMD_UBIFS
480 /*
481 * Special-case ubi, ubi goes through a mtd, rathen then through
482 * a regular block device.
483 */
484 if (0 == strcmp(ifname, "ubi")) {
485 if (!ubifs_is_mounted()) {
486 printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
487 return -1;
488 }
489
490 *dev_desc = NULL;
491 memset(info, 0, sizeof(*info));
492 strcpy((char *)info->type, BOOT_PART_TYPE);
493 strcpy((char *)info->name, "UBI");
494#ifdef CONFIG_PARTITION_UUIDS
495 info->uuid[0] = 0;
496#endif
Stephen Warrenbff6c312014-06-12 10:28:32 -0600497 return 0;
498 }
Hans de Goede4763ee32015-09-17 18:46:55 -0400499#endif
Stephen Warrenbff6c312014-06-12 10:28:32 -0600500
Stephen Warrenc87ff222012-09-21 09:50:57 +0000501 /* If no dev_part_str, use bootdevice environment variable */
Stephen Warrena95af942012-09-28 05:34:09 +0000502 if (!dev_part_str || !strlen(dev_part_str) ||
503 !strcmp(dev_part_str, "-"))
Stephen Warrenc87ff222012-09-21 09:50:57 +0000504 dev_part_str = getenv("bootdevice");
505
506 /* If still no dev_part_str, it's an error */
507 if (!dev_part_str) {
508 printf("** No device specified **\n");
509 goto cleanup;
510 }
511
512 /* Separate device and partition ID specification */
513 part_str = strchr(dev_part_str, ':');
514 if (part_str) {
515 dup_str = strdup(dev_part_str);
516 dup_str[part_str - dev_part_str] = 0;
517 dev_str = dup_str;
518 part_str++;
519 } else {
520 dev_str = dev_part_str;
521 }
Rob Herringd586cec2012-09-21 04:08:17 +0000522
Stephen Warrenc87ff222012-09-21 09:50:57 +0000523 /* Look up the device */
Simon Glasse6649a62016-02-29 15:25:43 -0700524 dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000525 if (dev < 0)
526 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000527
Stephen Warrenc87ff222012-09-21 09:50:57 +0000528 /* Convert partition ID string to number */
529 if (!part_str || !*part_str) {
530 part = PART_UNSPECIFIED;
531 } else if (!strcmp(part_str, "auto")) {
532 part = PART_AUTO;
533 } else {
534 /* Something specified -> use exactly that */
535 part = (int)simple_strtoul(part_str, &ep, 16);
536 /*
537 * Less than whole string converted,
538 * or request for whole device, but caller requires partition.
539 */
540 if (*ep || (part == 0 && !allow_whole_dev)) {
541 printf("** Bad partition specification %s %s **\n",
542 ifname, dev_part_str);
543 goto cleanup;
544 }
Rob Herringd586cec2012-09-21 04:08:17 +0000545 }
546
Stephen Warrenc87ff222012-09-21 09:50:57 +0000547 /*
548 * No partition table on device,
549 * or user requested partition 0 (entire device).
550 */
551 if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
552 (part == 0)) {
553 if (!(*dev_desc)->lba) {
554 printf("** Bad device size - %s %s **\n", ifname,
555 dev_str);
556 goto cleanup;
557 }
Rob Herringd586cec2012-09-21 04:08:17 +0000558
Stephen Warrenc87ff222012-09-21 09:50:57 +0000559 /*
560 * If user specified a partition ID other than 0,
561 * or the calling command only accepts partitions,
562 * it's an error.
563 */
564 if ((part > 0) || (!allow_whole_dev)) {
565 printf("** No partition table - %s %s **\n", ifname,
566 dev_str);
567 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000568 }
Stephen Warrenc87ff222012-09-21 09:50:57 +0000569
Lan Yixun (dlan)138914e2013-07-20 08:17:59 +0800570 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
571
Rob Herringd586cec2012-09-21 04:08:17 +0000572 info->start = 0;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000573 info->size = (*dev_desc)->lba;
574 info->blksz = (*dev_desc)->blksz;
575 info->bootable = 0;
Stephen Warren65be8492012-10-10 07:57:51 +0000576 strcpy((char *)info->type, BOOT_PART_TYPE);
577 strcpy((char *)info->name, "Whole Disk");
Stephen Warrenc87ff222012-09-21 09:50:57 +0000578#ifdef CONFIG_PARTITION_UUIDS
579 info->uuid[0] = 0;
580#endif
Patrick Delaunay8248c8d2015-10-27 11:00:27 +0100581#ifdef CONFIG_PARTITION_TYPE_GUID
582 info->type_guid[0] = 0;
583#endif
Rob Herringd586cec2012-09-21 04:08:17 +0000584
Stephen Warrenc87ff222012-09-21 09:50:57 +0000585 ret = 0;
586 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000587 }
588
Stephen Warrenc87ff222012-09-21 09:50:57 +0000589 /*
590 * Now there's known to be a partition table,
591 * not specifying a partition means to pick partition 1.
592 */
593 if (part == PART_UNSPECIFIED)
594 part = 1;
Rob Herringd586cec2012-09-21 04:08:17 +0000595
Stephen Warrenc87ff222012-09-21 09:50:57 +0000596 /*
597 * If user didn't specify a partition number, or did specify something
598 * other than "auto", use that partition number directly.
599 */
600 if (part != PART_AUTO) {
Simon Glassb89a8442016-02-29 15:25:48 -0700601 ret = part_get_info(*dev_desc, part, info);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000602 if (ret) {
603 printf("** Invalid partition %d **\n", part);
604 goto cleanup;
605 }
606 } else {
607 /*
608 * Find the first bootable partition.
609 * If none are bootable, fall back to the first valid partition.
610 */
611 part = 0;
612 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
Simon Glassb89a8442016-02-29 15:25:48 -0700613 ret = part_get_info(*dev_desc, p, info);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000614 if (ret)
615 continue;
616
617 /*
618 * First valid partition, or new better partition?
619 * If so, save partition ID.
620 */
621 if (!part || info->bootable)
622 part = p;
623
624 /* Best possible partition? Stop searching. */
625 if (info->bootable)
626 break;
627
628 /*
629 * We now need to search further for best possible.
630 * If we what we just queried was the best so far,
631 * save the info since we over-write it next loop.
632 */
633 if (part == p)
634 tmpinfo = *info;
635 }
636 /* If we found any acceptable partition */
637 if (part) {
638 /*
639 * If we searched all possible partition IDs,
640 * return the first valid partition we found.
641 */
642 if (p == MAX_SEARCH_PARTITIONS + 1)
643 *info = tmpinfo;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000644 } else {
645 printf("** No valid partitions found **\n");
Stephen Warren3c28be92012-10-08 07:45:54 +0000646 ret = -1;
Stephen Warrenc87ff222012-09-21 09:50:57 +0000647 goto cleanup;
648 }
Rob Herringd586cec2012-09-21 04:08:17 +0000649 }
650 if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
651 printf("** Invalid partition type \"%.32s\""
652 " (expect \"" BOOT_PART_TYPE "\")\n",
653 info->type);
Stephen Warrenc87ff222012-09-21 09:50:57 +0000654 ret = -1;
655 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000656 }
657
Lan Yixun (dlan)138914e2013-07-20 08:17:59 +0800658 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
659
Stephen Warrenc87ff222012-09-21 09:50:57 +0000660 ret = part;
661 goto cleanup;
Rob Herringd586cec2012-09-21 04:08:17 +0000662
Stephen Warrenc87ff222012-09-21 09:50:57 +0000663cleanup:
664 free(dup_str);
665 return ret;
Rob Herringd586cec2012-09-21 04:08:17 +0000666}