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