]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
012771d8 | 2 | /* |
42dfe7a1 | 3 | * (C) Copyright 2000-2004 |
012771d8 | 4 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
012771d8 WD |
5 | */ |
6 | #ifndef _PART_H | |
7 | #define _PART_H | |
735dd97b | 8 | |
1a73661b | 9 | #include <blk.h> |
6e592385 | 10 | #include <ide.h> |
db9b6200 | 11 | #include <uuid.h> |
12fc1f3b | 12 | #include <linker_lists.h> |
fd3654df | 13 | #include <linux/errno.h> |
09a49930 | 14 | #include <linux/list.h> |
012771d8 | 15 | |
d96a9804 AG |
16 | struct block_drvr { |
17 | char *name; | |
d96a9804 AG |
18 | int (*select_hwpart)(int dev_num, int hwpart); |
19 | }; | |
20 | ||
0472fbfd EE |
21 | #define LOG2(x) (((x & 0xaaaaaaaa) ? 1 : 0) + ((x & 0xcccccccc) ? 2 : 0) + \ |
22 | ((x & 0xf0f0f0f0) ? 4 : 0) + ((x & 0xff00ff00) ? 8 : 0) + \ | |
23 | ((x & 0xffff0000) ? 16 : 0)) | |
24 | #define LOG2_INVALID(type) ((type)((sizeof(type)<<3)-1)) | |
ae1768a7 | 25 | |
012771d8 | 26 | /* Part types */ |
42dfe7a1 | 27 | #define PART_TYPE_UNKNOWN 0x00 |
012771d8 WD |
28 | #define PART_TYPE_MAC 0x01 |
29 | #define PART_TYPE_DOS 0x02 | |
30 | #define PART_TYPE_ISO 0x03 | |
42dfe7a1 | 31 | #define PART_TYPE_AMIGA 0x04 |
07f3d789 | 32 | #define PART_TYPE_EFI 0x05 |
c7de829c | 33 | |
87b8530f PK |
34 | /* maximum number of partition entries supported by search */ |
35 | #define DOS_ENTRY_NUMBERS 8 | |
36 | #define ISO_ENTRY_NUMBERS 64 | |
37 | #define MAC_ENTRY_NUMBERS 64 | |
38 | #define AMIGA_ENTRY_NUMBERS 8 | |
b0fce99b WD |
39 | /* |
40 | * Type string for U-Boot bootable partitions | |
41 | */ | |
42 | #define BOOT_PART_TYPE "U-Boot" /* primary boot partition type */ | |
43 | #define BOOT_PART_COMP "PPCBoot" /* PPCBoot compatibility type */ | |
44 | ||
012771d8 | 45 | /* device types */ |
b0fce99b WD |
46 | #define DEV_TYPE_UNKNOWN 0xff /* not connected */ |
47 | #define DEV_TYPE_HARDDISK 0x00 /* harddisk */ | |
42dfe7a1 WD |
48 | #define DEV_TYPE_TAPE 0x01 /* Tape */ |
49 | #define DEV_TYPE_CDROM 0x05 /* CD-ROM */ | |
50 | #define DEV_TYPE_OPDISK 0x07 /* optical disk */ | |
012771d8 | 51 | |
92856b48 AC |
52 | #define PART_NAME_LEN 32 |
53 | #define PART_TYPE_LEN 32 | |
bc314f8e | 54 | #define MAX_SEARCH_PARTITIONS 128 |
92856b48 | 55 | |
25801acc HS |
56 | #define PART_BOOTABLE ((int)BIT(0)) |
57 | #define PART_EFI_SYSTEM_PARTITION ((int)BIT(1)) | |
58 | ||
0528979f | 59 | struct disk_partition { |
04735e9c FL |
60 | lbaint_t start; /* # of first block in partition */ |
61 | lbaint_t size; /* number of blocks in partition */ | |
012771d8 | 62 | ulong blksz; /* block size in bytes */ |
92856b48 AC |
63 | uchar name[PART_NAME_LEN]; /* partition name */ |
64 | uchar type[PART_TYPE_LEN]; /* string type description */ | |
25801acc HS |
65 | /* |
66 | * The bootable is a bitmask with the following fields: | |
67 | * | |
68 | * PART_BOOTABLE the MBR bootable flag is set | |
69 | * PART_EFI_SYSTEM_PARTITION the partition is an EFI system partition | |
70 | */ | |
71 | int bootable; | |
b331cd62 | 72 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) |
db9b6200 | 73 | char uuid[UUID_STR_LEN + 1]; /* filesystem UUID as string, if exists */ |
894bfbbf | 74 | #endif |
7561b258 | 75 | #ifdef CONFIG_PARTITION_TYPE_GUID |
db9b6200 | 76 | char type_guid[UUID_STR_LEN + 1]; /* type GUID as string, if exists */ |
7561b258 | 77 | #endif |
f0fb4fa7 | 78 | #ifdef CONFIG_DOS_PARTITION |
0cf207ec | 79 | uchar sys_ind; /* partition type */ |
f0fb4fa7 | 80 | #endif |
0528979f | 81 | }; |
012771d8 | 82 | |
c5f1d005 SG |
83 | /* Accessors for struct disk_partition field ->uuid */ |
84 | extern char *__invalid_use_of_disk_partition_uuid; | |
85 | ||
86 | static inline const char *disk_partition_uuid(const struct disk_partition *info) | |
87 | { | |
88 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) | |
89 | return info->uuid; | |
90 | #else | |
91 | return __invalid_use_of_disk_partition_uuid; | |
92 | #endif | |
93 | } | |
94 | ||
95 | static inline void disk_partition_set_uuid(struct disk_partition *info, | |
96 | const char *val) | |
97 | { | |
98 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) | |
99 | strlcpy(info->uuid, val, UUID_STR_LEN + 1); | |
100 | #endif | |
101 | } | |
102 | ||
103 | static inline void disk_partition_clr_uuid(struct disk_partition *info) | |
104 | { | |
105 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) | |
106 | *info->uuid = '\0'; | |
107 | #endif | |
108 | } | |
109 | ||
bcd64542 | 110 | /* Accessors for struct disk_partition field ->type_guid */ |
782c7f1b HS |
111 | extern char *__invalid_use_of_disk_partition_type_guid; |
112 | ||
113 | /** | |
114 | * disk_partition_type_guid() - get partition type GUID | |
115 | * | |
116 | * By using this function to get the partition type GUID we can use | |
117 | * 'if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID))' instead of | |
118 | * '#ifdef CONFIG_PARTITION_TYPE_GUID'. | |
119 | * | |
120 | * @info: partition information | |
121 | * Return: partition type GUID | |
122 | */ | |
bcd64542 | 123 | static inline const |
782c7f1b | 124 | char *disk_partition_type_guid(const struct disk_partition *info) |
bcd64542 SG |
125 | { |
126 | #ifdef CONFIG_PARTITION_TYPE_GUID | |
127 | return info->type_guid; | |
128 | #else | |
782c7f1b | 129 | return __invalid_use_of_disk_partition_type_guid; |
bcd64542 SG |
130 | #endif |
131 | } | |
132 | ||
782c7f1b HS |
133 | /** |
134 | * disk_partition_set_type_guid() - set partition type GUID | |
135 | * | |
136 | * By using this function to set the partition type GUID we can use | |
137 | * 'if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID))' instead of | |
138 | * '#ifdef CONFIG_PARTITION_TYPE_GUID'. | |
139 | * | |
140 | * @info: partition information | |
141 | * @val: partition type GUID as string | |
142 | */ | |
bcd64542 SG |
143 | static inline void disk_partition_set_type_guid(struct disk_partition *info, |
144 | const char *val) | |
145 | { | |
146 | #ifdef CONFIG_PARTITION_TYPE_GUID | |
147 | strlcpy(info->type_guid, val, UUID_STR_LEN + 1); | |
148 | #endif | |
149 | } | |
150 | ||
151 | static inline void disk_partition_clr_type_guid(struct disk_partition *info) | |
152 | { | |
153 | #ifdef CONFIG_PARTITION_TYPE_GUID | |
154 | *info->type_guid = '\0'; | |
155 | #endif | |
156 | } | |
157 | ||
b2b7e6c1 SG |
158 | /* Accessors for struct disk_partition field ->sys_ind */ |
159 | extern int __invalid_use_of_disk_partition_sys_ind; | |
160 | ||
161 | static inline uint disk_partition_sys_ind(const struct disk_partition *info) | |
162 | { | |
163 | #ifdef CONFIG_DOS_PARTITION | |
164 | return info->sys_ind; | |
165 | #else | |
166 | return __invalid_use_of_disk_partition_sys_ind; | |
167 | #endif | |
168 | } | |
169 | ||
09a49930 AC |
170 | struct disk_part { |
171 | int partnum; | |
0528979f | 172 | struct disk_partition gpt_part_info; |
09a49930 AC |
173 | struct list_head list; |
174 | }; | |
175 | ||
735dd97b | 176 | /* Misc _get_dev functions */ |
37168e39 | 177 | #if CONFIG_IS_ENABLED(PARTITIONS) |
fb1b7be9 | 178 | /** |
db1d9e78 | 179 | * blk_get_dev() - get a pointer to a block device given its type and number |
fb1b7be9 SG |
180 | * |
181 | * Each interface allocates its own devices and typically struct blk_desc is | |
182 | * contained with the interface's data structure. There is no global | |
183 | * numbering for block devices, so the interface name must be provided. | |
184 | * | |
185 | * @ifname: Interface name (e.g. "ide", "scsi") | |
186 | * @dev: Device number (0 for first device on that interface, 1 for | |
187 | * second, etc. | |
5aae021c HS |
188 | * Return: |
189 | * pointer to the block device, or NULL if not available, or an error occurred. | |
fb1b7be9 | 190 | */ |
db1d9e78 | 191 | struct blk_desc *blk_get_dev(const char *ifname, int dev); |
fb1b7be9 | 192 | |
4101f687 | 193 | struct blk_desc *mg_disk_get_dev(int dev); |
735dd97b | 194 | |
387f8be5 JW |
195 | /** |
196 | * part_get_info_by_type() - Get partitions from a block device using a specific | |
197 | * partition driver | |
198 | * | |
199 | * Each interface allocates its own devices and typically struct blk_desc is | |
200 | * contained with the interface's data structure. There is no global | |
201 | * numbering for block devices, so the interface name must be provided. | |
202 | * | |
5aab05d9 | 203 | * @desc: Block device descriptor |
387f8be5 JW |
204 | * @part: Partition number to read |
205 | * @part_type: Partition driver to use, or PART_TYPE_UNKNOWN to automatically | |
206 | * choose a driver | |
207 | * @info: Returned partition information | |
208 | * | |
209 | * Return: 0 on success, negative errno on failure | |
210 | */ | |
5aab05d9 | 211 | int part_get_info_by_type(struct blk_desc *desc, int part, int part_type, |
387f8be5 | 212 | struct disk_partition *info); |
5aab05d9 | 213 | int part_get_info(struct blk_desc *desc, int part, |
0528979f | 214 | struct disk_partition *info); |
4bbcc965 RC |
215 | /** |
216 | * part_get_info_whole_disk() - get partition info for the special case of | |
217 | * a partition occupying the entire disk. | |
5aae021c | 218 | * |
5aab05d9 | 219 | * @desc: block device descriptor |
5aae021c HS |
220 | * @info: returned partition information |
221 | * Return: 0 on success | |
4bbcc965 | 222 | */ |
5aab05d9 | 223 | int part_get_info_whole_disk(struct blk_desc *desc, |
0528979f | 224 | struct disk_partition *info); |
4bbcc965 | 225 | |
5aab05d9 SG |
226 | void part_print(struct blk_desc *desc); |
227 | void part_init(struct blk_desc *desc); | |
228 | void dev_print(struct blk_desc *desc); | |
ebac37cf SG |
229 | |
230 | /** | |
231 | * blk_get_device_by_str() - Get a block device given its interface/hw partition | |
232 | * | |
233 | * Each interface allocates its own devices and typically struct blk_desc is | |
234 | * contained with the interface's data structure. There is no global | |
235 | * numbering for block devices, so the interface name must be provided. | |
236 | * | |
237 | * The hardware parition is not related to the normal software partitioning | |
238 | * of a device - each hardware partition is effectively a separately | |
239 | * accessible block device. When a hardware parition is selected on MMC the | |
240 | * other hardware partitions become inaccessible. The same block device is | |
241 | * used to access all hardware partitions, but its capacity may change when a | |
242 | * different hardware partition is selected. | |
243 | * | |
244 | * When a hardware partition number is given, the block device switches to | |
245 | * that hardware partition. | |
246 | * | |
247 | * @ifname: Interface name (e.g. "ide", "scsi") | |
248 | * @dev_str: Device and optional hw partition. This can either be a string | |
249 | * containing the device number (e.g. "2") or the device number | |
250 | * and hardware partition number (e.g. "2.4") for devices that | |
251 | * support it (currently only MMC). | |
5aab05d9 | 252 | * @desc: Returns a pointer to the block device on success |
185f812c | 253 | * Return: block device number (local to the interface), or -1 on error |
ebac37cf SG |
254 | */ |
255 | int blk_get_device_by_str(const char *ifname, const char *dev_str, | |
5aab05d9 | 256 | struct blk_desc **desc); |
e35929e4 SG |
257 | |
258 | /** | |
259 | * blk_get_device_part_str() - Get a block device and partition | |
260 | * | |
261 | * This calls blk_get_device_by_str() to look up a device. It also looks up | |
262 | * a partition and returns information about it. | |
263 | * | |
5aae021c HS |
264 | * @dev_part_str is in the format <dev>.<hw_part>:<part> where |
265 | * | |
266 | * * <dev> is the device number, | |
267 | * | |
268 | * * <hw_part> is the optional hardware partition number and | |
e35929e4 | 269 | * |
5aae021c HS |
270 | * * <part> is the partition number. |
271 | * | |
272 | * If @ifname is "hostfs", then this function returns the sandbox host block | |
e35929e4 SG |
273 | * device. |
274 | * | |
5aae021c | 275 | * If @ifname is "ubi", then this function returns 0, with @info set to a |
e35929e4 SG |
276 | * special UBI device. |
277 | * | |
278 | * If @dev_part_str is NULL or empty or "-", then this function looks up | |
279 | * the "bootdevice" environment variable and uses that string instead. | |
280 | * | |
281 | * If the partition string is empty then the first partition is used. If the | |
282 | * partition string is "auto" then the first bootable partition is used. | |
283 | * | |
5aae021c | 284 | * @ifname: Interface name (e.g. "ide", "scsi") |
e35929e4 | 285 | * @dev_part_str: Device and partition string |
5aab05d9 | 286 | * @desc: Returns a pointer to the block device on success |
5aae021c | 287 | * @info: Returns partition information |
e35929e4 | 288 | * @allow_whole_dev: true to allow the user to select partition 0 |
5aae021c HS |
289 | * (which means the whole device), false to require a valid |
290 | * partition number >= 1 | |
185f812c | 291 | * Return: partition number, or -1 on error |
e35929e4 SG |
292 | * |
293 | */ | |
294 | int blk_get_device_part_str(const char *ifname, const char *dev_part_str, | |
5aab05d9 | 295 | struct blk_desc **desc, |
0528979f | 296 | struct disk_partition *info, int allow_whole_dev); |
87b8530f PK |
297 | |
298 | /** | |
299 | * part_get_info_by_name() - Search for a partition by name | |
300 | * among all available registered partitions | |
301 | * | |
5aab05d9 | 302 | * @desc: block device descriptor |
5aae021c HS |
303 | * @name: the specified table entry name |
304 | * @info: returns the disk partition info | |
87b8530f | 305 | * |
5aae021c | 306 | * Return: the partition number on match (starting on 1), -1 on no match, |
88b6329c | 307 | * otherwise error |
87b8530f | 308 | */ |
5aab05d9 SG |
309 | int part_get_info_by_name(struct blk_desc *desc, const char *name, |
310 | struct disk_partition *info); | |
87b8530f | 311 | |
6eccd1f7 | 312 | /** |
5aae021c HS |
313 | * part_get_info_by_dev_and_name_or_num() - Get partition info from dev number |
314 | * and part name, or dev number and | |
315 | * part number. | |
6eccd1f7 RT |
316 | * |
317 | * Parse a device number and partition description (either name or number) | |
318 | * in the form of device number plus partition name separated by a "#" | |
319 | * (like "device_num#partition_name") or a device number plus a partition number | |
320 | * separated by a ":". For example both "0#misc" and "0:1" can be valid | |
321 | * partition descriptions for a given interface. If the partition is found, sets | |
5aab05d9 | 322 | * desc and part_info accordingly with the information of the partition. |
6eccd1f7 | 323 | * |
5aae021c HS |
324 | * @dev_iface: Device interface |
325 | * @dev_part_str: Input partition description, like "0#misc" or "0:1" | |
5aab05d9 | 326 | * @desc: Place to store the device description pointer |
5aae021c HS |
327 | * @part_info: Place to store the partition information |
328 | * @allow_whole_dev: true to allow the user to select partition 0 | |
329 | * (which means the whole device), false to require a valid | |
330 | * partition number >= 1 | |
331 | * Return: the partition number on success, or negative errno on error | |
6eccd1f7 RT |
332 | */ |
333 | int part_get_info_by_dev_and_name_or_num(const char *dev_iface, | |
334 | const char *dev_part_str, | |
5aab05d9 | 335 | struct blk_desc **desc, |
9f7bb282 SA |
336 | struct disk_partition *part_info, |
337 | int allow_whole_dev); | |
6eccd1f7 | 338 | |
da2ee24d PK |
339 | /** |
340 | * part_set_generic_name() - create generic partition like hda1 or sdb2 | |
341 | * | |
342 | * Helper function for partition tables, which don't hold partition names | |
343 | * (DOS, ISO). Generates partition name out of the device type and partition | |
344 | * number. | |
345 | * | |
5aab05d9 | 346 | * @desc: pointer to the block device |
da2ee24d PK |
347 | * @part_num: partition number for which the name is generated |
348 | * @name: buffer where the name is written | |
349 | */ | |
5aab05d9 SG |
350 | void part_set_generic_name(const struct blk_desc *desc, int part_num, |
351 | char *name); | |
da2ee24d | 352 | |
d96a9804 | 353 | extern const struct block_drvr block_drvr[]; |
df3fc526 | 354 | #else |
db1d9e78 | 355 | static inline struct blk_desc *blk_get_dev(const char *ifname, int dev) |
99d2c205 | 356 | { return NULL; } |
4101f687 | 357 | static inline struct blk_desc *mg_disk_get_dev(int dev) { return NULL; } |
012771d8 | 358 | |
5aab05d9 | 359 | static inline int part_get_info(struct blk_desc *desc, int part, |
0528979f | 360 | struct disk_partition *info) { return -1; } |
5aab05d9 | 361 | static inline int part_get_info_whole_disk(struct blk_desc *desc, |
0528979f | 362 | struct disk_partition *info) |
4bbcc965 | 363 | { return -1; } |
5aab05d9 SG |
364 | static inline void part_print(struct blk_desc *desc) {} |
365 | static inline void part_init(struct blk_desc *desc) {} | |
366 | static inline void dev_print(struct blk_desc *desc) {} | |
ebac37cf | 367 | static inline int blk_get_device_by_str(const char *ifname, const char *dev_str, |
5aab05d9 | 368 | struct blk_desc **desc) |
2023e608 | 369 | { return -1; } |
e35929e4 | 370 | static inline int blk_get_device_part_str(const char *ifname, |
0528979f | 371 | const char *dev_part_str, |
5aab05d9 | 372 | struct blk_desc **desc, |
0528979f SG |
373 | struct disk_partition *info, |
374 | int allow_whole_dev) | |
5aab05d9 | 375 | { *desc = NULL; return -1; } |
2a0d1881 | 376 | |
5aab05d9 | 377 | static inline int part_get_info_by_name(struct blk_desc *desc, const char *name, |
2a0d1881 AT |
378 | struct disk_partition *info) |
379 | { | |
380 | return -ENOENT; | |
381 | } | |
382 | ||
7194527b SA |
383 | static inline int |
384 | part_get_info_by_dev_and_name_or_num(const char *dev_iface, | |
385 | const char *dev_part_str, | |
5aab05d9 | 386 | struct blk_desc **desc, |
7194527b SA |
387 | struct disk_partition *part_info, |
388 | int allow_whole_dev) | |
389 | { | |
5aab05d9 | 390 | *desc = NULL; |
7194527b SA |
391 | return -ENOSYS; |
392 | } | |
df3fc526 | 393 | #endif |
012771d8 | 394 | |
43855fdb | 395 | struct udevice; |
76c839fc SG |
396 | /** |
397 | * disk_blk_read() - read blocks from a disk partition | |
398 | * | |
399 | * @dev: Device to read from (UCLASS_PARTITION) | |
400 | * @start: Start block number to read in the partition (0=first) | |
401 | * @blkcnt: Number of blocks to read | |
402 | * @buffer: Destination buffer for data read | |
5aae021c | 403 | * Return: number of blocks read, or -ve error number (see the |
76c839fc SG |
404 | * IS_ERR_VALUE() macro |
405 | */ | |
406 | ulong disk_blk_read(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, | |
407 | void *buffer); | |
408 | ||
409 | /** | |
410 | * disk_blk_write() - write to a disk partition | |
411 | * | |
412 | * @dev: Device to write to (UCLASS_PARTITION) | |
413 | * @start: Start block number to write in the partition (0=first) | |
414 | * @blkcnt: Number of blocks to write | |
415 | * @buffer: Source buffer for data to write | |
5aae021c | 416 | * Return: number of blocks written, or -ve error number (see the |
76c839fc SG |
417 | * IS_ERR_VALUE() macro |
418 | */ | |
419 | ulong disk_blk_write(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, | |
420 | const void *buffer); | |
421 | ||
422 | /** | |
423 | * disk_blk_erase() - erase a section of a disk partition | |
424 | * | |
425 | * @dev: Device to (partially) erase (UCLASS_PARTITION) | |
426 | * @start: Start block number to erase in the partition (0=first) | |
427 | * @blkcnt: Number of blocks to erase | |
5aae021c | 428 | * Return: number of blocks erased, or -ve error number (see the |
76c839fc SG |
429 | * IS_ERR_VALUE() macro |
430 | */ | |
431 | ulong disk_blk_erase(struct udevice *dev, lbaint_t start, lbaint_t blkcnt); | |
59da9d47 | 432 | |
96e5b03c SG |
433 | /* |
434 | * We don't support printing partition information in SPL and only support | |
435 | * getting partition information in a few cases. | |
436 | */ | |
437 | #ifdef CONFIG_SPL_BUILD | |
438 | # define part_print_ptr(x) NULL | |
f4b40924 | 439 | # if defined(CONFIG_SPL_FS_EXT4) || defined(CONFIG_SPL_FS_FAT) || \ |
96e5b03c SG |
440 | defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION) |
441 | # define part_get_info_ptr(x) x | |
442 | # else | |
443 | # define part_get_info_ptr(x) NULL | |
444 | # endif | |
445 | #else | |
446 | #define part_print_ptr(x) x | |
447 | #define part_get_info_ptr(x) x | |
012771d8 WD |
448 | #endif |
449 | ||
5aae021c HS |
450 | /** |
451 | * struct part_driver - partition driver | |
452 | */ | |
96e5b03c | 453 | struct part_driver { |
5aae021c | 454 | /** @name: partition name */ |
96e5b03c | 455 | const char *name; |
5aae021c | 456 | /** @part_type: (MBR) partition type */ |
96e5b03c | 457 | int part_type; |
5aae021c HS |
458 | /** @max_entries: maximum number of partition table entries */ |
459 | const int max_entries; | |
96e5b03c | 460 | /** |
5aae021c | 461 | * @get_info: Get information about a partition |
96e5b03c | 462 | * |
5aab05d9 | 463 | * @get_info.desc: Block device descriptor |
5aae021c HS |
464 | * @get_info.part: Partition number (1 = first) |
465 | * @get_info.info: Returns partition information | |
96e5b03c | 466 | */ |
5aab05d9 | 467 | int (*get_info)(struct blk_desc *desc, int part, |
0528979f | 468 | struct disk_partition *info); |
96e5b03c SG |
469 | |
470 | /** | |
5aae021c | 471 | * @print: Print partition information |
96e5b03c | 472 | * |
5aab05d9 | 473 | * @print.desc: Block device descriptor |
96e5b03c | 474 | */ |
5aab05d9 | 475 | void (*print)(struct blk_desc *desc); |
96e5b03c SG |
476 | |
477 | /** | |
5aae021c | 478 | * @test: Test if a device contains this partition type |
96e5b03c | 479 | * |
5aab05d9 | 480 | * @test.desc: Block device descriptor |
5aae021c HS |
481 | * @test.Return: |
482 | * 0 if the block device appears to contain this partition type, | |
483 | * -ve if not | |
96e5b03c | 484 | */ |
5aab05d9 | 485 | int (*test)(struct blk_desc *desc); |
96e5b03c SG |
486 | }; |
487 | ||
488 | /* Declare a new U-Boot partition 'driver' */ | |
489 | #define U_BOOT_PART_TYPE(__name) \ | |
490 | ll_entry_declare(struct part_driver, __name, part_driver) | |
c7de829c | 491 | |
40684ddb | 492 | #include <part_efi.h> |
0d6ab32e RC |
493 | |
494 | #if CONFIG_IS_ENABLED(EFI_PARTITION) | |
07f3d789 | 495 | /* disk/part_efi.c */ |
40684ddb ŁM |
496 | /** |
497 | * write_gpt_table() - Write the GUID Partition Table to disk | |
498 | * | |
5aab05d9 | 499 | * @desc: block device descriptor |
5aae021c HS |
500 | * @gpt_h: pointer to GPT header representation |
501 | * @gpt_e: pointer to GPT partition table entries | |
40684ddb | 502 | * |
5aae021c | 503 | * Return: zero on success, otherwise error |
40684ddb | 504 | */ |
5aab05d9 | 505 | int write_gpt_table(struct blk_desc *desc, gpt_header *gpt_h, gpt_entry *gpt_e); |
40684ddb ŁM |
506 | |
507 | /** | |
5aae021c | 508 | * gpt_fill_pte() - Fill the GPT partition table entry |
40684ddb | 509 | * |
5aab05d9 | 510 | * @desc: block device descriptor |
5aae021c HS |
511 | * @gpt_h: GPT header representation |
512 | * @gpt_e: GPT partition table entries | |
513 | * @partitions: list of partitions | |
514 | * @parts: number of partitions | |
40684ddb | 515 | * |
5aae021c | 516 | * Return: zero on success |
40684ddb | 517 | */ |
5aab05d9 | 518 | int gpt_fill_pte(struct blk_desc *desc, gpt_header *gpt_h, gpt_entry *gpt_e, |
0528979f | 519 | struct disk_partition *partitions, int parts); |
40684ddb ŁM |
520 | |
521 | /** | |
5aae021c | 522 | * gpt_fill_header() - Fill the GPT header |
40684ddb | 523 | * |
5aab05d9 | 524 | * @desc: block device descriptor |
5aae021c HS |
525 | * @gpt_h: GPT header representation |
526 | * @str_guid: disk guid string representation | |
527 | * @parts_count: number of partitions | |
40684ddb | 528 | * |
5aae021c | 529 | * Return: error on str_guid conversion error |
40684ddb | 530 | */ |
5aab05d9 SG |
531 | int gpt_fill_header(struct blk_desc *desc, gpt_header *gpt_h, char *str_guid, |
532 | int parts_count); | |
40684ddb ŁM |
533 | |
534 | /** | |
5aae021c | 535 | * gpt_restore() - Restore GPT partition table |
40684ddb | 536 | * |
5aab05d9 | 537 | * @desc: block device descriptor |
5aae021c HS |
538 | * @str_disk_guid: disk GUID |
539 | * @partitions: list of partitions | |
540 | * @parts_count: number of partitions | |
40684ddb | 541 | * |
5aae021c | 542 | * Return: 0 on success |
40684ddb | 543 | */ |
5aab05d9 | 544 | int gpt_restore(struct blk_desc *desc, char *str_disk_guid, |
0528979f | 545 | struct disk_partition *partitions, const int parts_count); |
0ff7e585 SR |
546 | |
547 | /** | |
548 | * is_valid_gpt_buf() - Ensure that the Primary GPT information is valid | |
549 | * | |
5aab05d9 | 550 | * @desc: block device descriptor |
5aae021c | 551 | * @buf: buffer which contains the MBR and Primary GPT info |
0ff7e585 | 552 | * |
5aae021c | 553 | * Return: 0 on success, otherwise error |
0ff7e585 | 554 | */ |
5aab05d9 | 555 | int is_valid_gpt_buf(struct blk_desc *desc, void *buf); |
0ff7e585 SR |
556 | |
557 | /** | |
558 | * write_mbr_and_gpt_partitions() - write MBR, Primary GPT and Backup GPT | |
559 | * | |
5aab05d9 | 560 | * @desc: block device descriptor |
5aae021c | 561 | * @buf: buffer which contains the MBR and Primary GPT info |
0ff7e585 | 562 | * |
5aae021c | 563 | * Return: 0 on success, otherwise error |
0ff7e585 | 564 | */ |
5aab05d9 | 565 | int write_mbr_and_gpt_partitions(struct blk_desc *desc, void *buf); |
cef68bf9 LM |
566 | |
567 | /** | |
5aae021c | 568 | * gpt_verify_headers() - Read and check CRC32 of the GPT's header |
cef68bf9 LM |
569 | * and partition table entries (PTE) |
570 | * | |
571 | * As a side effect if sets gpt_head and gpt_pte so they point to GPT data. | |
572 | * | |
5aab05d9 | 573 | * @desc: block device descriptor |
5aae021c HS |
574 | * @gpt_head: pointer to GPT header data read from medium |
575 | * @gpt_pte: pointer to GPT partition table enties read from medium | |
cef68bf9 | 576 | * |
5aae021c | 577 | * Return: 0 on success, otherwise error |
cef68bf9 | 578 | */ |
5aab05d9 | 579 | int gpt_verify_headers(struct blk_desc *desc, gpt_header *gpt_head, |
cef68bf9 LM |
580 | gpt_entry **gpt_pte); |
581 | ||
5c783b54 PR |
582 | /** |
583 | * gpt_repair_headers() - Function to repair the GPT's header | |
584 | * and partition table entries (PTE) | |
585 | * | |
5aab05d9 | 586 | * @desc: block device descriptor |
5c783b54 | 587 | * |
5aae021c | 588 | * Return: 0 on success, otherwise error |
5c783b54 | 589 | */ |
5aab05d9 | 590 | int gpt_repair_headers(struct blk_desc *desc); |
5c783b54 | 591 | |
cef68bf9 LM |
592 | /** |
593 | * gpt_verify_partitions() - Function to check if partitions' name, start and | |
594 | * size correspond to '$partitions' env variable | |
595 | * | |
596 | * This function checks if on medium stored GPT data is in sync with information | |
597 | * provided in '$partitions' environment variable. Specificially, name, start | |
598 | * and size of the partition is checked. | |
599 | * | |
5aab05d9 | 600 | * @desc: block device descriptor |
5aae021c HS |
601 | * @partitions: partition data read from '$partitions' env variable |
602 | * @parts: number of partitions read from '$partitions' env variable | |
603 | * @gpt_head: pointer to GPT header data read from medium | |
604 | * @gpt_pte: pointer to GPT partition table enties read from medium | |
cef68bf9 | 605 | * |
5aae021c | 606 | * Return: 0 on success, otherwise error |
cef68bf9 | 607 | */ |
5aab05d9 | 608 | int gpt_verify_partitions(struct blk_desc *desc, |
0528979f | 609 | struct disk_partition *partitions, int parts, |
cef68bf9 | 610 | gpt_header *gpt_head, gpt_entry **gpt_pte); |
73d6d18b AC |
611 | |
612 | ||
613 | /** | |
5aae021c | 614 | * get_disk_guid() - Read the GUID string from a device's GPT |
73d6d18b AC |
615 | * |
616 | * This function reads the GUID string from a block device whose descriptor | |
617 | * is provided. | |
618 | * | |
5aab05d9 | 619 | * @desc: block device descriptor |
5aae021c | 620 | * @guid: pre-allocated string in which to return the GUID |
73d6d18b | 621 | * |
5aae021c | 622 | * Return: 0 on success, otherwise error |
73d6d18b | 623 | */ |
5aab05d9 | 624 | int get_disk_guid(struct blk_desc *desc, char *guid); |
73d6d18b | 625 | |
07f3d789 | 626 | #endif |
627 | ||
b0cf7339 | 628 | #if CONFIG_IS_ENABLED(DOS_PARTITION) |
b6dd69a4 PK |
629 | /** |
630 | * is_valid_dos_buf() - Ensure that a DOS MBR image is valid | |
631 | * | |
5aae021c | 632 | * @buf: buffer which contains the MBR |
b6dd69a4 | 633 | * |
5aae021c | 634 | * Return: 0 on success, otherwise error |
b6dd69a4 PK |
635 | */ |
636 | int is_valid_dos_buf(void *buf); | |
637 | ||
638 | /** | |
92f1c89d | 639 | * write_mbr_sector() - write DOS MBR |
b6dd69a4 | 640 | * |
5aab05d9 | 641 | * @desc: block device descriptor |
5aae021c | 642 | * @buf: buffer which contains the MBR |
b6dd69a4 | 643 | * |
5aae021c | 644 | * Return: 0 on success, otherwise error |
b6dd69a4 | 645 | */ |
5aab05d9 | 646 | int write_mbr_sector(struct blk_desc *desc, void *buf); |
b6dd69a4 | 647 | |
20bd5ac6 MS |
648 | int write_mbr_partitions(struct blk_desc *dev, |
649 | struct disk_partition *p, int count, unsigned int disksig); | |
650 | int layout_mbr_partitions(struct disk_partition *p, int count, | |
651 | lbaint_t total_sectors); | |
652 | ||
b6dd69a4 PK |
653 | #endif |
654 | ||
37168e39 | 655 | #if CONFIG_IS_ENABLED(PARTITIONS) |
12fc1f3b CD |
656 | /** |
657 | * part_driver_get_count() - get partition driver count | |
658 | * | |
5aae021c | 659 | * Return: number of partition drivers |
12fc1f3b CD |
660 | */ |
661 | static inline int part_driver_get_count(void) | |
662 | { | |
663 | return ll_entry_count(struct part_driver, part_driver); | |
664 | } | |
665 | ||
666 | /** | |
667 | * part_driver_get_first() - get first partition driver | |
668 | * | |
5aae021c | 669 | * Return: pointer to first partition driver on success, otherwise NULL |
12fc1f3b CD |
670 | */ |
671 | static inline struct part_driver *part_driver_get_first(void) | |
672 | { | |
673 | return ll_entry_start(struct part_driver, part_driver); | |
674 | } | |
675 | ||
125194e6 SG |
676 | /** |
677 | * part_get_type_by_name() - Get partition type by name | |
678 | * | |
5aae021c HS |
679 | * @name: Name of partition type to look up (not case-sensitive) |
680 | * Return: | |
681 | * Corresponding partition type (PART\_TYPE\_...) or PART\_TYPE\_UNKNOWN | |
125194e6 SG |
682 | */ |
683 | int part_get_type_by_name(const char *name); | |
684 | ||
f55aa445 SG |
685 | /** |
686 | * part_get_bootable() - Find the first bootable partition | |
687 | * | |
e75e4cf5 HS |
688 | * @desc: Block-device descriptor |
689 | * Return: first bootable partition, or 0 if there is none | |
f55aa445 SG |
690 | */ |
691 | int part_get_bootable(struct blk_desc *desc); | |
692 | ||
12fc1f3b CD |
693 | #else |
694 | static inline int part_driver_get_count(void) | |
695 | { return 0; } | |
696 | ||
697 | static inline struct part_driver *part_driver_get_first(void) | |
698 | { return NULL; } | |
f55aa445 SG |
699 | |
700 | static inline bool part_get_bootable(struct blk_desc *desc) | |
701 | { return false; } | |
702 | ||
12fc1f3b | 703 | #endif /* CONFIG_PARTITIONS */ |
b6dd69a4 | 704 | |
012771d8 | 705 | #endif /* _PART_H */ |