xref: /openbmc/u-boot/include/part.h (revision 3aa4b703)
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 #include <uuid.h>
13 #include <linux/list.h>
14 
15 struct block_drvr {
16 	char *name;
17 	int (*select_hwpart)(int dev_num, int hwpart);
18 };
19 
20 #define LOG2(x) (((x & 0xaaaaaaaa) ? 1 : 0) + ((x & 0xcccccccc) ? 2 : 0) + \
21 		 ((x & 0xf0f0f0f0) ? 4 : 0) + ((x & 0xff00ff00) ? 8 : 0) + \
22 		 ((x & 0xffff0000) ? 16 : 0))
23 #define LOG2_INVALID(type) ((type)((sizeof(type)<<3)-1))
24 
25 /* Part types */
26 #define PART_TYPE_UNKNOWN	0x00
27 #define PART_TYPE_MAC		0x01
28 #define PART_TYPE_DOS		0x02
29 #define PART_TYPE_ISO		0x03
30 #define PART_TYPE_AMIGA		0x04
31 #define PART_TYPE_EFI		0x05
32 
33 /* maximum number of partition entries supported by search */
34 #define DOS_ENTRY_NUMBERS	8
35 #define ISO_ENTRY_NUMBERS	64
36 #define MAC_ENTRY_NUMBERS	64
37 #define AMIGA_ENTRY_NUMBERS	8
38 /*
39  * Type string for U-Boot bootable partitions
40  */
41 #define BOOT_PART_TYPE	"U-Boot"	/* primary boot partition type	*/
42 #define BOOT_PART_COMP	"PPCBoot"	/* PPCBoot compatibility type	*/
43 
44 /* device types */
45 #define DEV_TYPE_UNKNOWN	0xff	/* not connected */
46 #define DEV_TYPE_HARDDISK	0x00	/* harddisk */
47 #define DEV_TYPE_TAPE		0x01	/* Tape */
48 #define DEV_TYPE_CDROM		0x05	/* CD-ROM */
49 #define DEV_TYPE_OPDISK		0x07	/* optical disk */
50 
51 #define PART_NAME_LEN 32
52 #define PART_TYPE_LEN 32
53 #define MAX_SEARCH_PARTITIONS 64
54 
55 typedef struct disk_partition {
56 	lbaint_t	start;	/* # of first block in partition	*/
57 	lbaint_t	size;	/* number of blocks in partition	*/
58 	ulong	blksz;		/* block size in bytes			*/
59 	uchar	name[PART_NAME_LEN];	/* partition name			*/
60 	uchar	type[PART_TYPE_LEN];	/* string type description		*/
61 	int	bootable;	/* Active/Bootable flag is set		*/
62 #if CONFIG_IS_ENABLED(PARTITION_UUIDS)
63 	char	uuid[UUID_STR_LEN + 1];	/* filesystem UUID as string, if exists	*/
64 #endif
65 #ifdef CONFIG_PARTITION_TYPE_GUID
66 	char	type_guid[UUID_STR_LEN + 1];	/* type GUID as string, if exists	*/
67 #endif
68 #ifdef CONFIG_DOS_PARTITION
69 	uchar	sys_ind;	/* partition type 			*/
70 #endif
71 } disk_partition_t;
72 
73 struct disk_part {
74 	int partnum;
75 	disk_partition_t gpt_part_info;
76 	struct list_head list;
77 };
78 
79 /* Misc _get_dev functions */
80 #ifdef CONFIG_PARTITIONS
81 /**
82  * blk_get_dev() - get a pointer to a block device given its type and number
83  *
84  * Each interface allocates its own devices and typically struct blk_desc is
85  * contained with the interface's data structure. There is no global
86  * numbering for block devices, so the interface name must be provided.
87  *
88  * @ifname:	Interface name (e.g. "ide", "scsi")
89  * @dev:	Device number (0 for first device on that interface, 1 for
90  *		second, etc.
91  * @return pointer to the block device, or NULL if not available, or an
92  *	   error occurred.
93  */
94 struct blk_desc *blk_get_dev(const char *ifname, int dev);
95 
96 struct blk_desc *mg_disk_get_dev(int dev);
97 int host_get_dev_err(int dev, struct blk_desc **blk_devp);
98 
99 /* disk/part.c */
100 int part_get_info(struct blk_desc *dev_desc, int part, disk_partition_t *info);
101 void part_print(struct blk_desc *dev_desc);
102 void part_init(struct blk_desc *dev_desc);
103 void dev_print(struct blk_desc *dev_desc);
104 
105 /**
106  * blk_get_device_by_str() - Get a block device given its interface/hw partition
107  *
108  * Each interface allocates its own devices and typically struct blk_desc is
109  * contained with the interface's data structure. There is no global
110  * numbering for block devices, so the interface name must be provided.
111  *
112  * The hardware parition is not related to the normal software partitioning
113  * of a device - each hardware partition is effectively a separately
114  * accessible block device. When a hardware parition is selected on MMC the
115  * other hardware partitions become inaccessible. The same block device is
116  * used to access all hardware partitions, but its capacity may change when a
117  * different hardware partition is selected.
118  *
119  * When a hardware partition number is given, the block device switches to
120  * that hardware partition.
121  *
122  * @ifname:	Interface name (e.g. "ide", "scsi")
123  * @dev_str:	Device and optional hw partition. This can either be a string
124  *		containing the device number (e.g. "2") or the device number
125  *		and hardware partition number (e.g. "2.4") for devices that
126  *		support it (currently only MMC).
127  * @dev_desc:	Returns a pointer to the block device on success
128  * @return block device number (local to the interface), or -1 on error
129  */
130 int blk_get_device_by_str(const char *ifname, const char *dev_str,
131 			  struct blk_desc **dev_desc);
132 
133 /**
134  * blk_get_device_part_str() - Get a block device and partition
135  *
136  * This calls blk_get_device_by_str() to look up a device. It also looks up
137  * a partition and returns information about it.
138  *
139  * @dev_part_str is in the format:
140  *	<dev>.<hw_part>:<part> where <dev> is the device number,
141  *	<hw_part> is the optional hardware partition number and
142  *	<part> is the partition number
143  *
144  * If ifname is "hostfs" then this function returns the sandbox host block
145  * device.
146  *
147  * If ifname is ubi, then this function returns 0, with @info set to a
148  * special UBI device.
149  *
150  * If @dev_part_str is NULL or empty or "-", then this function looks up
151  * the "bootdevice" environment variable and uses that string instead.
152  *
153  * If the partition string is empty then the first partition is used. If the
154  * partition string is "auto" then the first bootable partition is used.
155  *
156  * @ifname:	Interface name (e.g. "ide", "scsi")
157  * @dev_part_str:	Device and partition string
158  * @dev_desc:	Returns a pointer to the block device on success
159  * @info:	Returns partition information
160  * @allow_whole_dev:	true to allow the user to select partition 0
161  *		(which means the whole device), false to require a valid
162  *		partition number >= 1
163  * @return partition number, or -1 on error
164  *
165  */
166 int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
167 			    struct blk_desc **dev_desc,
168 			    disk_partition_t *info, int allow_whole_dev);
169 
170 /**
171  * part_get_info_by_name() - Search for a partition by name
172  *                           among all available registered partitions
173  *
174  * @param dev_desc - block device descriptor
175  * @param gpt_name - the specified table entry name
176  * @param info - returns the disk partition info
177  *
178  * @return - the partition number on match (starting on 1), -1 on no match,
179  * otherwise error
180  */
181 int part_get_info_by_name(struct blk_desc *dev_desc,
182 			      const char *name, disk_partition_t *info);
183 
184 /**
185  * part_set_generic_name() - create generic partition like hda1 or sdb2
186  *
187  * Helper function for partition tables, which don't hold partition names
188  * (DOS, ISO). Generates partition name out of the device type and partition
189  * number.
190  *
191  * @dev_desc:	pointer to the block device
192  * @part_num:	partition number for which the name is generated
193  * @name:	buffer where the name is written
194  */
195 void part_set_generic_name(const struct blk_desc *dev_desc,
196 	int part_num, char *name);
197 
198 extern const struct block_drvr block_drvr[];
199 #else
200 static inline struct blk_desc *blk_get_dev(const char *ifname, int dev)
201 { return NULL; }
202 static inline struct blk_desc *mg_disk_get_dev(int dev) { return NULL; }
203 
204 static inline int part_get_info(struct blk_desc *dev_desc, int part,
205 				disk_partition_t *info) { return -1; }
206 static inline void part_print(struct blk_desc *dev_desc) {}
207 static inline void part_init(struct blk_desc *dev_desc) {}
208 static inline void dev_print(struct blk_desc *dev_desc) {}
209 static inline int blk_get_device_by_str(const char *ifname, const char *dev_str,
210 					struct blk_desc **dev_desc)
211 { return -1; }
212 static inline int blk_get_device_part_str(const char *ifname,
213 					   const char *dev_part_str,
214 					   struct blk_desc **dev_desc,
215 					   disk_partition_t *info,
216 					   int allow_whole_dev)
217 { *dev_desc = NULL; return -1; }
218 #endif
219 
220 /*
221  * We don't support printing partition information in SPL and only support
222  * getting partition information in a few cases.
223  */
224 #ifdef CONFIG_SPL_BUILD
225 # define part_print_ptr(x)	NULL
226 # if defined(CONFIG_SPL_EXT_SUPPORT) || defined(CONFIG_SPL_FAT_SUPPORT) || \
227 	defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION)
228 #  define part_get_info_ptr(x)	x
229 # else
230 #  define part_get_info_ptr(x)	NULL
231 # endif
232 #else
233 #define part_print_ptr(x)	x
234 #define part_get_info_ptr(x)	x
235 #endif
236 
237 
238 struct part_driver {
239 	const char *name;
240 	int part_type;
241 	const int max_entries;	/* maximum number of entries to search */
242 
243 	/**
244 	 * get_info() - Get information about a partition
245 	 *
246 	 * @dev_desc:	Block device descriptor
247 	 * @part:	Partition number (1 = first)
248 	 * @info:	Returns partition information
249 	 */
250 	int (*get_info)(struct blk_desc *dev_desc, int part,
251 			disk_partition_t *info);
252 
253 	/**
254 	 * print() - Print partition information
255 	 *
256 	 * @dev_desc:	Block device descriptor
257 	 */
258 	void (*print)(struct blk_desc *dev_desc);
259 
260 	/**
261 	 * test() - Test if a device contains this partition type
262 	 *
263 	 * @dev_desc:	Block device descriptor
264 	 * @return 0 if the block device appears to contain this partition
265 	 *	   type, -ve if not
266 	 */
267 	int (*test)(struct blk_desc *dev_desc);
268 };
269 
270 /* Declare a new U-Boot partition 'driver' */
271 #define U_BOOT_PART_TYPE(__name)					\
272 	ll_entry_declare(struct part_driver, __name, part_driver)
273 
274 #if CONFIG_IS_ENABLED(EFI_PARTITION)
275 #include <part_efi.h>
276 /* disk/part_efi.c */
277 /**
278  * write_gpt_table() - Write the GUID Partition Table to disk
279  *
280  * @param dev_desc - block device descriptor
281  * @param gpt_h - pointer to GPT header representation
282  * @param gpt_e - pointer to GPT partition table entries
283  *
284  * @return - zero on success, otherwise error
285  */
286 int write_gpt_table(struct blk_desc *dev_desc,
287 		  gpt_header *gpt_h, gpt_entry *gpt_e);
288 
289 /**
290  * gpt_fill_pte(): Fill the GPT partition table entry
291  *
292  * @param gpt_h - GPT header representation
293  * @param gpt_e - GPT partition table entries
294  * @param partitions - list of partitions
295  * @param parts - number of partitions
296  *
297  * @return zero on success
298  */
299 int gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e,
300 		disk_partition_t *partitions, int parts);
301 
302 /**
303  * gpt_fill_header(): Fill the GPT header
304  *
305  * @param dev_desc - block device descriptor
306  * @param gpt_h - GPT header representation
307  * @param str_guid - disk guid string representation
308  * @param parts_count - number of partitions
309  *
310  * @return - error on str_guid conversion error
311  */
312 int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h,
313 		char *str_guid, int parts_count);
314 
315 /**
316  * gpt_restore(): Restore GPT partition table
317  *
318  * @param dev_desc - block device descriptor
319  * @param str_disk_guid - disk GUID
320  * @param partitions - list of partitions
321  * @param parts - number of partitions
322  *
323  * @return zero on success
324  */
325 int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
326 		disk_partition_t *partitions, const int parts_count);
327 
328 /**
329  * is_valid_gpt_buf() - Ensure that the Primary GPT information is valid
330  *
331  * @param dev_desc - block device descriptor
332  * @param buf - buffer which contains the MBR and Primary GPT info
333  *
334  * @return - '0' on success, otherwise error
335  */
336 int is_valid_gpt_buf(struct blk_desc *dev_desc, void *buf);
337 
338 /**
339  * write_mbr_and_gpt_partitions() - write MBR, Primary GPT and Backup GPT
340  *
341  * @param dev_desc - block device descriptor
342  * @param buf - buffer which contains the MBR and Primary GPT info
343  *
344  * @return - '0' on success, otherwise error
345  */
346 int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf);
347 
348 /**
349  * gpt_verify_headers() - Function to read and CRC32 check of the GPT's header
350  *                        and partition table entries (PTE)
351  *
352  * As a side effect if sets gpt_head and gpt_pte so they point to GPT data.
353  *
354  * @param dev_desc - block device descriptor
355  * @param gpt_head - pointer to GPT header data read from medium
356  * @param gpt_pte - pointer to GPT partition table enties read from medium
357  *
358  * @return - '0' on success, otherwise error
359  */
360 int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
361 		       gpt_entry **gpt_pte);
362 
363 /**
364  * gpt_verify_partitions() - Function to check if partitions' name, start and
365  *                           size correspond to '$partitions' env variable
366  *
367  * This function checks if on medium stored GPT data is in sync with information
368  * provided in '$partitions' environment variable. Specificially, name, start
369  * and size of the partition is checked.
370  *
371  * @param dev_desc - block device descriptor
372  * @param partitions - partition data read from '$partitions' env variable
373  * @param parts - number of partitions read from '$partitions' env variable
374  * @param gpt_head - pointer to GPT header data read from medium
375  * @param gpt_pte - pointer to GPT partition table enties read from medium
376  *
377  * @return - '0' on success, otherwise error
378  */
379 int gpt_verify_partitions(struct blk_desc *dev_desc,
380 			  disk_partition_t *partitions, int parts,
381 			  gpt_header *gpt_head, gpt_entry **gpt_pte);
382 
383 
384 /**
385  * get_disk_guid() - Function to read the GUID string from a device's GPT
386  *
387  * This function reads the GUID string from a block device whose descriptor
388  * is provided.
389  *
390  * @param dev_desc - block device descriptor
391  * @param guid - pre-allocated string in which to return the GUID
392  *
393  * @return - '0' on success, otherwise error
394  */
395 int get_disk_guid(struct blk_desc *dev_desc, char *guid);
396 
397 #endif
398 
399 #if CONFIG_IS_ENABLED(DOS_PARTITION)
400 /**
401  * is_valid_dos_buf() - Ensure that a DOS MBR image is valid
402  *
403  * @param buf - buffer which contains the MBR
404  *
405  * @return - '0' on success, otherwise error
406  */
407 int is_valid_dos_buf(void *buf);
408 
409 /**
410  * write_mbr_partition() - write DOS MBR
411  *
412  * @param dev_desc - block device descriptor
413  * @param buf - buffer which contains the MBR
414  *
415  * @return - '0' on success, otherwise error
416  */
417 int write_mbr_partition(struct blk_desc *dev_desc, void *buf);
418 
419 #endif
420 
421 
422 #endif /* _PART_H */
423