dm: ide: Drop the get_dev() function
[oweals/u-boot.git] / disk / part.c
1 /*
2  * (C) Copyright 2001
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <command.h>
10 #include <errno.h>
11 #include <ide.h>
12 #include <malloc.h>
13 #include <part.h>
14 #include <ubifs_uboot.h>
15
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
24 const struct block_drvr block_drvr[] = {
25 #if defined(CONFIG_CMD_IDE)
26         { .name = "ide", },
27 #endif
28 #if defined(CONFIG_CMD_SATA)
29         {.name = "sata", .get_dev = sata_get_dev, },
30 #endif
31 #if defined(CONFIG_SCSI)
32         { .name = "scsi", .get_dev = scsi_get_dev, },
33 #endif
34 #if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
35         { .name = "usb", },
36 #endif
37 #if defined(CONFIG_MMC)
38         {
39                 .name = "mmc",
40                 .get_dev = mmc_get_dev,
41                 .select_hwpart = mmc_select_hwpart,
42         },
43 #endif
44 #if defined(CONFIG_SYSTEMACE)
45         { .name = "ace", .get_dev = systemace_get_dev, },
46 #endif
47 #if defined(CONFIG_SANDBOX)
48         { .name = "host", .get_dev = host_get_dev, },
49 #endif
50         { },
51 };
52
53 DECLARE_GLOBAL_DATA_PTR;
54
55 #ifdef HAVE_BLOCK_DEVICE
56 static struct part_driver *part_driver_lookup_type(int part_type)
57 {
58         struct part_driver *drv =
59                 ll_entry_start(struct part_driver, part_driver);
60         const int n_ents = ll_entry_count(struct part_driver, part_driver);
61         struct part_driver *entry;
62
63         for (entry = drv; entry != drv + n_ents; entry++) {
64                 if (part_type == entry->part_type)
65                         return entry;
66         }
67
68         /* Not found */
69         return NULL;
70 }
71
72 static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
73 {
74         const struct block_drvr *drvr = block_drvr;
75         int (*select_hwpart)(int dev_num, int hwpart);
76         char *name;
77         int ret;
78
79         if (!ifname)
80                 return NULL;
81
82         name = drvr->name;
83 #ifdef CONFIG_NEEDS_MANUAL_RELOC
84         name += gd->reloc_off;
85 #endif
86         while (drvr->name) {
87                 name = drvr->name;
88                 select_hwpart = drvr->select_hwpart;
89 #ifdef CONFIG_NEEDS_MANUAL_RELOC
90                 name += gd->reloc_off;
91                 if (select_hwpart)
92                         select_hwpart += gd->reloc_off;
93 #endif
94                 if (strncmp(ifname, name, strlen(name)) == 0) {
95                         struct blk_desc *dev_desc;
96
97                         dev_desc = blk_get_devnum_by_typename(name, dev);
98                         if (!dev_desc)
99                                 return NULL;
100                         if (hwpart == 0 && !select_hwpart)
101                                 return dev_desc;
102                         if (!select_hwpart)
103                                 return NULL;
104                         ret = select_hwpart(dev_desc->devnum, hwpart);
105                         if (ret < 0)
106                                 return NULL;
107                         return dev_desc;
108                 }
109                 drvr++;
110         }
111         return NULL;
112 }
113
114 struct blk_desc *blk_get_dev(const char *ifname, int dev)
115 {
116         return get_dev_hwpart(ifname, dev, 0);
117 }
118 #else
119 struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
120 {
121         return NULL;
122 }
123
124 struct blk_desc *blk_get_dev(const char *ifname, int dev)
125 {
126         return NULL;
127 }
128 #endif
129
130 #ifdef HAVE_BLOCK_DEVICE
131
132 /* ------------------------------------------------------------------------- */
133 /*
134  * reports device info to the user
135  */
136
137 #ifdef CONFIG_LBA48
138 typedef uint64_t lba512_t;
139 #else
140 typedef lbaint_t lba512_t;
141 #endif
142
143 /*
144  * Overflowless variant of (block_count * mul_by / div_by)
145  * when div_by > mul_by
146  */
147 static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, lba512_t div_by)
148 {
149         lba512_t bc_quot, bc_rem;
150
151         /* x * m / d == x / d * m + (x % d) * m / d */
152         bc_quot = block_count / div_by;
153         bc_rem  = block_count - div_by * bc_quot;
154         return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
155 }
156
157 void dev_print (struct blk_desc *dev_desc)
158 {
159         lba512_t lba512; /* number of blocks if 512bytes block size */
160
161         if (dev_desc->type == DEV_TYPE_UNKNOWN) {
162                 puts ("not available\n");
163                 return;
164         }
165
166         switch (dev_desc->if_type) {
167         case IF_TYPE_SCSI:
168                 printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
169                         dev_desc->target,dev_desc->lun,
170                         dev_desc->vendor,
171                         dev_desc->product,
172                         dev_desc->revision);
173                 break;
174         case IF_TYPE_ATAPI:
175         case IF_TYPE_IDE:
176         case IF_TYPE_SATA:
177                 printf ("Model: %s Firm: %s Ser#: %s\n",
178                         dev_desc->vendor,
179                         dev_desc->revision,
180                         dev_desc->product);
181                 break;
182         case IF_TYPE_SD:
183         case IF_TYPE_MMC:
184         case IF_TYPE_USB:
185                 printf ("Vendor: %s Rev: %s Prod: %s\n",
186                         dev_desc->vendor,
187                         dev_desc->revision,
188                         dev_desc->product);
189                 break;
190         case IF_TYPE_DOC:
191                 puts("device type DOC\n");
192                 return;
193         case IF_TYPE_UNKNOWN:
194                 puts("device type unknown\n");
195                 return;
196         default:
197                 printf("Unhandled device type: %i\n", dev_desc->if_type);
198                 return;
199         }
200         puts ("            Type: ");
201         if (dev_desc->removable)
202                 puts ("Removable ");
203         switch (dev_desc->type & 0x1F) {
204         case DEV_TYPE_HARDDISK:
205                 puts ("Hard Disk");
206                 break;
207         case DEV_TYPE_CDROM:
208                 puts ("CD ROM");
209                 break;
210         case DEV_TYPE_OPDISK:
211                 puts ("Optical Device");
212                 break;
213         case DEV_TYPE_TAPE:
214                 puts ("Tape");
215                 break;
216         default:
217                 printf ("# %02X #", dev_desc->type & 0x1F);
218                 break;
219         }
220         puts ("\n");
221         if (dev_desc->lba > 0L && dev_desc->blksz > 0L) {
222                 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
223                 lbaint_t lba;
224
225                 lba = dev_desc->lba;
226
227                 lba512 = (lba * (dev_desc->blksz/512));
228                 /* round to 1 digit */
229                 /* 2048 = (1024 * 1024) / 512 MB */
230                 mb = lba512_muldiv(lba512, 10, 2048);
231
232                 mb_quot = mb / 10;
233                 mb_rem  = mb - (10 * mb_quot);
234
235                 gb = mb / 1024;
236                 gb_quot = gb / 10;
237                 gb_rem  = gb - (10 * gb_quot);
238 #ifdef CONFIG_LBA48
239                 if (dev_desc->lba48)
240                         printf ("            Supports 48-bit addressing\n");
241 #endif
242 #if defined(CONFIG_SYS_64BIT_LBA)
243                 printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n",
244                         mb_quot, mb_rem,
245                         gb_quot, gb_rem,
246                         lba,
247                         dev_desc->blksz);
248 #else
249                 printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n",
250                         mb_quot, mb_rem,
251                         gb_quot, gb_rem,
252                         (ulong)lba,
253                         dev_desc->blksz);
254 #endif
255         } else {
256                 puts ("            Capacity: not available\n");
257         }
258 }
259 #endif
260
261 #ifdef HAVE_BLOCK_DEVICE
262
263 void part_init(struct blk_desc *dev_desc)
264 {
265         struct part_driver *drv =
266                 ll_entry_start(struct part_driver, part_driver);
267         const int n_ents = ll_entry_count(struct part_driver, part_driver);
268         struct part_driver *entry;
269
270         blkcache_invalidate(dev_desc->if_type, dev_desc->devnum);
271
272         dev_desc->part_type = PART_TYPE_UNKNOWN;
273         for (entry = drv; entry != drv + n_ents; entry++) {
274                 int ret;
275
276                 ret = entry->test(dev_desc);
277                 debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
278                 if (!ret) {
279                         dev_desc->part_type = entry->part_type;
280                         break;
281                 }
282         }
283 }
284
285 static void print_part_header(const char *type, struct blk_desc *dev_desc)
286 {
287 #if defined(CONFIG_MAC_PARTITION) || \
288         defined(CONFIG_DOS_PARTITION) || \
289         defined(CONFIG_ISO_PARTITION) || \
290         defined(CONFIG_AMIGA_PARTITION) || \
291         defined(CONFIG_EFI_PARTITION)
292         puts ("\nPartition Map for ");
293         switch (dev_desc->if_type) {
294         case IF_TYPE_IDE:
295                 puts ("IDE");
296                 break;
297         case IF_TYPE_SATA:
298                 puts ("SATA");
299                 break;
300         case IF_TYPE_SCSI:
301                 puts ("SCSI");
302                 break;
303         case IF_TYPE_ATAPI:
304                 puts ("ATAPI");
305                 break;
306         case IF_TYPE_USB:
307                 puts ("USB");
308                 break;
309         case IF_TYPE_DOC:
310                 puts ("DOC");
311                 break;
312         case IF_TYPE_MMC:
313                 puts ("MMC");
314                 break;
315         case IF_TYPE_HOST:
316                 puts("HOST");
317                 break;
318         default:
319                 puts ("UNKNOWN");
320                 break;
321         }
322         printf (" device %d  --   Partition Type: %s\n\n",
323                         dev_desc->devnum, type);
324 #endif /* any CONFIG_..._PARTITION */
325 }
326
327 void part_print(struct blk_desc *dev_desc)
328 {
329         struct part_driver *drv;
330
331         drv = part_driver_lookup_type(dev_desc->part_type);
332         if (!drv) {
333                 printf("## Unknown partition table type %x\n",
334                        dev_desc->part_type);
335                 return;
336         }
337
338         PRINTF("## Testing for valid %s partition ##\n", drv->name);
339         print_part_header(drv->name, dev_desc);
340         if (drv->print)
341                 drv->print(dev_desc);
342 }
343
344 #endif /* HAVE_BLOCK_DEVICE */
345
346 int part_get_info(struct blk_desc *dev_desc, int part,
347                        disk_partition_t *info)
348 {
349 #ifdef HAVE_BLOCK_DEVICE
350         struct part_driver *drv;
351
352 #ifdef CONFIG_PARTITION_UUIDS
353         /* The common case is no UUID support */
354         info->uuid[0] = 0;
355 #endif
356 #ifdef CONFIG_PARTITION_TYPE_GUID
357         info->type_guid[0] = 0;
358 #endif
359
360         drv = part_driver_lookup_type(dev_desc->part_type);
361         if (!drv) {
362                 debug("## Unknown partition table type %x\n",
363                       dev_desc->part_type);
364                 return -EPROTONOSUPPORT;
365         }
366         if (!drv->get_info) {
367                 PRINTF("## Driver %s does not have the get_info() method\n",
368                        drv->name);
369                 return -ENOSYS;
370         }
371         if (drv->get_info(dev_desc, part, info) == 0) {
372                 PRINTF("## Valid %s partition found ##\n", drv->name);
373                 return 0;
374         }
375 #endif /* HAVE_BLOCK_DEVICE */
376
377         return -1;
378 }
379
380 int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
381                           struct blk_desc **dev_desc)
382 {
383         char *ep;
384         char *dup_str = NULL;
385         const char *dev_str, *hwpart_str;
386         int dev, hwpart;
387
388         hwpart_str = strchr(dev_hwpart_str, '.');
389         if (hwpart_str) {
390                 dup_str = strdup(dev_hwpart_str);
391                 dup_str[hwpart_str - dev_hwpart_str] = 0;
392                 dev_str = dup_str;
393                 hwpart_str++;
394         } else {
395                 dev_str = dev_hwpart_str;
396                 hwpart = 0;
397         }
398
399         dev = simple_strtoul(dev_str, &ep, 16);
400         if (*ep) {
401                 printf("** Bad device specification %s %s **\n",
402                        ifname, dev_str);
403                 dev = -1;
404                 goto cleanup;
405         }
406
407         if (hwpart_str) {
408                 hwpart = simple_strtoul(hwpart_str, &ep, 16);
409                 if (*ep) {
410                         printf("** Bad HW partition specification %s %s **\n",
411                             ifname, hwpart_str);
412                         dev = -1;
413                         goto cleanup;
414                 }
415         }
416
417         *dev_desc = get_dev_hwpart(ifname, dev, hwpart);
418         if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
419                 printf("** Bad device %s %s **\n", ifname, dev_hwpart_str);
420                 dev = -1;
421                 goto cleanup;
422         }
423
424 #ifdef HAVE_BLOCK_DEVICE
425         /*
426          * Updates the partition table for the specified hw partition.
427          * Does not need to be done for hwpart 0 since it is default and
428          * already loaded.
429          */
430         if(hwpart != 0)
431                 part_init(*dev_desc);
432 #endif
433
434 cleanup:
435         free(dup_str);
436         return dev;
437 }
438
439 #define PART_UNSPECIFIED -2
440 #define PART_AUTO -1
441 #define MAX_SEARCH_PARTITIONS 16
442 int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
443                              struct blk_desc **dev_desc,
444                              disk_partition_t *info, int allow_whole_dev)
445 {
446         int ret = -1;
447         const char *part_str;
448         char *dup_str = NULL;
449         const char *dev_str;
450         int dev;
451         char *ep;
452         int p;
453         int part;
454         disk_partition_t tmpinfo;
455
456 #ifdef CONFIG_SANDBOX
457         /*
458          * Special-case a pseudo block device "hostfs", to allow access to the
459          * host's own filesystem.
460          */
461         if (0 == strcmp(ifname, "hostfs")) {
462                 *dev_desc = NULL;
463                 info->start = 0;
464                 info->size = 0;
465                 info->blksz = 0;
466                 info->bootable = 0;
467                 strcpy((char *)info->type, BOOT_PART_TYPE);
468                 strcpy((char *)info->name, "Sandbox host");
469 #ifdef CONFIG_PARTITION_UUIDS
470                 info->uuid[0] = 0;
471 #endif
472 #ifdef CONFIG_PARTITION_TYPE_GUID
473                 info->type_guid[0] = 0;
474 #endif
475
476                 return 0;
477         }
478 #endif
479
480 #ifdef CONFIG_CMD_UBIFS
481         /*
482          * Special-case ubi, ubi goes through a mtd, rathen then through
483          * a regular block device.
484          */
485         if (0 == strcmp(ifname, "ubi")) {
486                 if (!ubifs_is_mounted()) {
487                         printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
488                         return -1;
489                 }
490
491                 *dev_desc = NULL;
492                 memset(info, 0, sizeof(*info));
493                 strcpy((char *)info->type, BOOT_PART_TYPE);
494                 strcpy((char *)info->name, "UBI");
495 #ifdef CONFIG_PARTITION_UUIDS
496                 info->uuid[0] = 0;
497 #endif
498                 return 0;
499         }
500 #endif
501
502         /* If no dev_part_str, use bootdevice environment variable */
503         if (!dev_part_str || !strlen(dev_part_str) ||
504             !strcmp(dev_part_str, "-"))
505                 dev_part_str = getenv("bootdevice");
506
507         /* If still no dev_part_str, it's an error */
508         if (!dev_part_str) {
509                 printf("** No device specified **\n");
510                 goto cleanup;
511         }
512
513         /* Separate device and partition ID specification */
514         part_str = strchr(dev_part_str, ':');
515         if (part_str) {
516                 dup_str = strdup(dev_part_str);
517                 dup_str[part_str - dev_part_str] = 0;
518                 dev_str = dup_str;
519                 part_str++;
520         } else {
521                 dev_str = dev_part_str;
522         }
523
524         /* Look up the device */
525         dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
526         if (dev < 0)
527                 goto cleanup;
528
529         /* Convert partition ID string to number */
530         if (!part_str || !*part_str) {
531                 part = PART_UNSPECIFIED;
532         } else if (!strcmp(part_str, "auto")) {
533                 part = PART_AUTO;
534         } else {
535                 /* Something specified -> use exactly that */
536                 part = (int)simple_strtoul(part_str, &ep, 16);
537                 /*
538                  * Less than whole string converted,
539                  * or request for whole device, but caller requires partition.
540                  */
541                 if (*ep || (part == 0 && !allow_whole_dev)) {
542                         printf("** Bad partition specification %s %s **\n",
543                             ifname, dev_part_str);
544                         goto cleanup;
545                 }
546         }
547
548         /*
549          * No partition table on device,
550          * or user requested partition 0 (entire device).
551          */
552         if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
553             (part == 0)) {
554                 if (!(*dev_desc)->lba) {
555                         printf("** Bad device size - %s %s **\n", ifname,
556                                dev_str);
557                         goto cleanup;
558                 }
559
560                 /*
561                  * If user specified a partition ID other than 0,
562                  * or the calling command only accepts partitions,
563                  * it's an error.
564                  */
565                 if ((part > 0) || (!allow_whole_dev)) {
566                         printf("** No partition table - %s %s **\n", ifname,
567                                dev_str);
568                         goto cleanup;
569                 }
570
571                 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
572
573                 info->start = 0;
574                 info->size = (*dev_desc)->lba;
575                 info->blksz = (*dev_desc)->blksz;
576                 info->bootable = 0;
577                 strcpy((char *)info->type, BOOT_PART_TYPE);
578                 strcpy((char *)info->name, "Whole Disk");
579 #ifdef CONFIG_PARTITION_UUIDS
580                 info->uuid[0] = 0;
581 #endif
582 #ifdef CONFIG_PARTITION_TYPE_GUID
583                 info->type_guid[0] = 0;
584 #endif
585
586                 ret = 0;
587                 goto cleanup;
588         }
589
590         /*
591          * Now there's known to be a partition table,
592          * not specifying a partition means to pick partition 1.
593          */
594         if (part == PART_UNSPECIFIED)
595                 part = 1;
596
597         /*
598          * If user didn't specify a partition number, or did specify something
599          * other than "auto", use that partition number directly.
600          */
601         if (part != PART_AUTO) {
602                 ret = part_get_info(*dev_desc, part, info);
603                 if (ret) {
604                         printf("** Invalid partition %d **\n", part);
605                         goto cleanup;
606                 }
607         } else {
608                 /*
609                  * Find the first bootable partition.
610                  * If none are bootable, fall back to the first valid partition.
611                  */
612                 part = 0;
613                 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
614                         ret = part_get_info(*dev_desc, p, info);
615                         if (ret)
616                                 continue;
617
618                         /*
619                          * First valid partition, or new better partition?
620                          * If so, save partition ID.
621                          */
622                         if (!part || info->bootable)
623                                 part = p;
624
625                         /* Best possible partition? Stop searching. */
626                         if (info->bootable)
627                                 break;
628
629                         /*
630                          * We now need to search further for best possible.
631                          * If we what we just queried was the best so far,
632                          * save the info since we over-write it next loop.
633                          */
634                         if (part == p)
635                                 tmpinfo = *info;
636                 }
637                 /* If we found any acceptable partition */
638                 if (part) {
639                         /*
640                          * If we searched all possible partition IDs,
641                          * return the first valid partition we found.
642                          */
643                         if (p == MAX_SEARCH_PARTITIONS + 1)
644                                 *info = tmpinfo;
645                 } else {
646                         printf("** No valid partitions found **\n");
647                         ret = -1;
648                         goto cleanup;
649                 }
650         }
651         if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
652                 printf("** Invalid partition type \"%.32s\""
653                         " (expect \"" BOOT_PART_TYPE "\")\n",
654                         info->type);
655                 ret  = -1;
656                 goto cleanup;
657         }
658
659         (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
660
661         ret = part;
662         goto cleanup;
663
664 cleanup:
665         free(dup_str);
666         return ret;
667 }