include/part.h

   1 /*
   2  * (C) Copyright 2000-2004
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7 #ifndef _PART_H
   8 #define _PART_H
   9
  10 #include <blk.h>
  11 #include <ide.h>
  12
  13 #define LOG2(x) (((x & 0xaaaaaaaa) ? 1 : 0) + ((x & 0xcccccccc) ? 2 : 0) + \
  14                  ((x & 0xf0f0f0f0) ? 4 : 0) + ((x & 0xff00ff00) ? 8 : 0) + \
  15                  ((x & 0xffff0000) ? 16 : 0))
  16 #define LOG2_INVALID(type) ((type)((sizeof(type)<<3)-1))
  17
  18 /* Part types */
  19 #define PART_TYPE_UNKNOWN       0x00
  20 #define PART_TYPE_MAC           0x01
  21 #define PART_TYPE_DOS           0x02
  22 #define PART_TYPE_ISO           0x03
  23 #define PART_TYPE_AMIGA         0x04
  24 #define PART_TYPE_EFI           0x05
  25
  26 /*
  27  * Type string for U-Boot bootable partitions
  28  */
  29 #define BOOT_PART_TYPE  "U-Boot"        /* primary boot partition type  */
  30 #define BOOT_PART_COMP  "PPCBoot"       /* PPCBoot compatibility type   */
  31
  32 /* device types */
  33 #define DEV_TYPE_UNKNOWN        0xff    /* not connected */
  34 #define DEV_TYPE_HARDDISK       0x00    /* harddisk */
  35 #define DEV_TYPE_TAPE           0x01    /* Tape */
  36 #define DEV_TYPE_CDROM          0x05    /* CD-ROM */
  37 #define DEV_TYPE_OPDISK         0x07    /* optical disk */
  38
  39 typedef struct disk_partition {
  40         lbaint_t        start;  /* # of first block in partition        */
  41         lbaint_t        size;   /* number of blocks in partition        */
  42         ulong   blksz;          /* block size in bytes                  */
  43         uchar   name[32];       /* partition name                       */
  44         uchar   type[32];       /* string type description              */
  45         int     bootable;       /* Active/Bootable flag is set          */
  46 #ifdef CONFIG_PARTITION_UUIDS
  47         char    uuid[37];       /* filesystem UUID as string, if exists */
  48 #endif
  49 #ifdef CONFIG_PARTITION_TYPE_GUID
  50         char    type_guid[37];  /* type GUID as string, if exists       */
  51 #endif
  52 } disk_partition_t;
  53
  54 /* Misc _get_dev functions */
  55 #ifdef CONFIG_PARTITIONS
  56 struct blk_desc *get_dev(const char *ifname, int dev);
  57 struct blk_desc *ide_get_dev(int dev);
  58 struct blk_desc *sata_get_dev(int dev);
  59 struct blk_desc *scsi_get_dev(int dev);
  60 struct blk_desc *usb_stor_get_dev(int dev);
  61 struct blk_desc *mmc_get_dev(int dev);
  62 int mmc_select_hwpart(int dev_num, int hwpart);
  63 struct blk_desc *systemace_get_dev(int dev);
  64 struct blk_desc *mg_disk_get_dev(int dev);
  65 struct blk_desc *host_get_dev(int dev);
  66 int host_get_dev_err(int dev, struct blk_desc **blk_devp);
  67
  68 /* disk/part.c */
  69 int get_partition_info(struct blk_desc *dev_desc, int part,
  70                        disk_partition_t *info);
  71 void print_part(struct blk_desc *dev_desc);
  72 void init_part(struct blk_desc *dev_desc);
  73 void dev_print(struct blk_desc *dev_desc);
  74 int get_device(const char *ifname, const char *dev_str,
  75                struct blk_desc **dev_desc);
  76 int get_device_and_partition(const char *ifname, const char *dev_part_str,
  77                              struct blk_desc **dev_desc,
  78                              disk_partition_t *info, int allow_whole_dev);
  79 #else
  80 static inline struct blk_desc *get_dev(const char *ifname, int dev)
  81 { return NULL; }
  82 static inline struct blk_desc *ide_get_dev(int dev) { return NULL; }
  83 static inline struct blk_desc *sata_get_dev(int dev) { return NULL; }
  84 static inline struct blk_desc *scsi_get_dev(int dev) { return NULL; }
  85 static inline struct blk_desc *usb_stor_get_dev(int dev) { return NULL; }
  86 static inline struct blk_desc *mmc_get_dev(int dev) { return NULL; }
  87 static inline int mmc_select_hwpart(int dev_num, int hwpart) { return -1; }
  88 static inline struct blk_desc *systemace_get_dev(int dev) { return NULL; }
  89 static inline struct blk_desc *mg_disk_get_dev(int dev) { return NULL; }
  90 static inline struct blk_desc *host_get_dev(int dev) { return NULL; }
  91
  92 static inline int get_partition_info(struct blk_desc *dev_desc, int part,
  93                                      disk_partition_t *info) { return -1; }
  94 static inline void print_part(struct blk_desc *dev_desc) {}
  95 static inline void init_part(struct blk_desc *dev_desc) {}
  96 static inline void dev_print(struct blk_desc *dev_desc) {}
  97 static inline int get_device(const char *ifname, const char *dev_str,
  98                              struct blk_desc **dev_desc)
  99 { return -1; }
 100 static inline int get_device_and_partition(const char *ifname,
 101                                            const char *dev_part_str,
 102                                            struct blk_desc **dev_desc,
 103                                            disk_partition_t *info,
 104                                            int allow_whole_dev)
 105 { *dev_desc = NULL; return -1; }
 106 #endif
 107
 108 #ifdef CONFIG_MAC_PARTITION
 109 /* disk/part_mac.c */
 110 int get_partition_info_mac(struct blk_desc *dev_desc, int part,
 111                            disk_partition_t *info);
 112 void print_part_mac(struct blk_desc *dev_desc);
 113 int test_part_mac(struct blk_desc *dev_desc);
 114 #endif
 115
 116 #ifdef CONFIG_DOS_PARTITION
 117 /* disk/part_dos.c */
 118 int get_partition_info_dos(struct blk_desc *dev_desc, int part,
 119                            disk_partition_t *info);
 120 void print_part_dos(struct blk_desc *dev_desc);
 121 int test_part_dos(struct blk_desc *dev_desc);
 122 #endif
 123
 124 #ifdef CONFIG_ISO_PARTITION
 125 /* disk/part_iso.c */
 126 int get_partition_info_iso(struct blk_desc *dev_desc, int part,
 127                            disk_partition_t *info);
 128 void print_part_iso(struct blk_desc *dev_desc);
 129 int test_part_iso(struct blk_desc *dev_desc);
 130 #endif
 131
 132 #ifdef CONFIG_AMIGA_PARTITION
 133 /* disk/part_amiga.c */
 134 int get_partition_info_amiga(struct blk_desc *dev_desc, int part,
 135                              disk_partition_t *info);
 136 void print_part_amiga(struct blk_desc *dev_desc);
 137 int test_part_amiga(struct blk_desc *dev_desc);
 138 #endif
 139
 140 #ifdef CONFIG_EFI_PARTITION
 141 #include <part_efi.h>
 142 /* disk/part_efi.c */
 143 int get_partition_info_efi(struct blk_desc *dev_desc, int part,
 144                            disk_partition_t *info);
 145 /**
 146  * get_partition_info_efi_by_name() - Find the specified GPT partition table entry
 147  *
 148  * @param dev_desc - block device descriptor
 149  * @param gpt_name - the specified table entry name
 150  * @param info - returns the disk partition info
 151  *
 152  * @return - '0' on match, '-1' on no match, otherwise error
 153  */
 154 int get_partition_info_efi_by_name(struct blk_desc *dev_desc,
 155         const char *name, disk_partition_t *info);
 156 void print_part_efi(struct blk_desc *dev_desc);
 157 int test_part_efi(struct blk_desc *dev_desc);
 158
 159 /**
 160  * write_gpt_table() - Write the GUID Partition Table to disk
 161  *
 162  * @param dev_desc - block device descriptor
 163  * @param gpt_h - pointer to GPT header representation
 164  * @param gpt_e - pointer to GPT partition table entries
 165  *
 166  * @return - zero on success, otherwise error
 167  */
 168 int write_gpt_table(struct blk_desc *dev_desc,
 169                   gpt_header *gpt_h, gpt_entry *gpt_e);
 170
 171 /**
 172  * gpt_fill_pte(): Fill the GPT partition table entry
 173  *
 174  * @param gpt_h - GPT header representation
 175  * @param gpt_e - GPT partition table entries
 176  * @param partitions - list of partitions
 177  * @param parts - number of partitions
 178  *
 179  * @return zero on success
 180  */
 181 int gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e,
 182                 disk_partition_t *partitions, int parts);
 183
 184 /**
 185  * gpt_fill_header(): Fill the GPT header
 186  *
 187  * @param dev_desc - block device descriptor
 188  * @param gpt_h - GPT header representation
 189  * @param str_guid - disk guid string representation
 190  * @param parts_count - number of partitions
 191  *
 192  * @return - error on str_guid conversion error
 193  */
 194 int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h,
 195                 char *str_guid, int parts_count);
 196
 197 /**
 198  * gpt_restore(): Restore GPT partition table
 199  *
 200  * @param dev_desc - block device descriptor
 201  * @param str_disk_guid - disk GUID
 202  * @param partitions - list of partitions
 203  * @param parts - number of partitions
 204  *
 205  * @return zero on success
 206  */
 207 int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
 208                 disk_partition_t *partitions, const int parts_count);
 209
 210 /**
 211  * is_valid_gpt_buf() - Ensure that the Primary GPT information is valid
 212  *
 213  * @param dev_desc - block device descriptor
 214  * @param buf - buffer which contains the MBR and Primary GPT info
 215  *
 216  * @return - '0' on success, otherwise error
 217  */
 218 int is_valid_gpt_buf(struct blk_desc *dev_desc, void *buf);
 219
 220 /**
 221  * write_mbr_and_gpt_partitions() - write MBR, Primary GPT and Backup GPT
 222  *
 223  * @param dev_desc - block device descriptor
 224  * @param buf - buffer which contains the MBR and Primary GPT info
 225  *
 226  * @return - '0' on success, otherwise error
 227  */
 228 int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf);
 229
 230 /**
 231  * gpt_verify_headers() - Function to read and CRC32 check of the GPT's header
 232  *                        and partition table entries (PTE)
 233  *
 234  * As a side effect if sets gpt_head and gpt_pte so they point to GPT data.
 235  *
 236  * @param dev_desc - block device descriptor
 237  * @param gpt_head - pointer to GPT header data read from medium
 238  * @param gpt_pte - pointer to GPT partition table enties read from medium
 239  *
 240  * @return - '0' on success, otherwise error
 241  */
 242 int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
 243                        gpt_entry **gpt_pte);
 244
 245 /**
 246  * gpt_verify_partitions() - Function to check if partitions' name, start and
 247  *                           size correspond to '$partitions' env variable
 248  *
 249  * This function checks if on medium stored GPT data is in sync with information
 250  * provided in '$partitions' environment variable. Specificially, name, start
 251  * and size of the partition is checked.
 252  *
 253  * @param dev_desc - block device descriptor
 254  * @param partitions - partition data read from '$partitions' env variable
 255  * @param parts - number of partitions read from '$partitions' env variable
 256  * @param gpt_head - pointer to GPT header data read from medium
 257  * @param gpt_pte - pointer to GPT partition table enties read from medium
 258  *
 259  * @return - '0' on success, otherwise error
 260  */
 261 int gpt_verify_partitions(struct blk_desc *dev_desc,
 262                           disk_partition_t *partitions, int parts,
 263                           gpt_header *gpt_head, gpt_entry **gpt_pte);
 264 #endif
 265
 266 #endif /* _PART_H */