part.h 20 KB

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