lib/efi_loader/efi_device_path.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * EFI device path from u-boot device-model mapping
   4  *
   5  * (C) Copyright 2017 Rob Clark
   6  */
   7
   8 #define LOG_CATEGORY LOGC_EFI
   9
  10 #include <common.h>
  11 #include <blk.h>
  12 #include <dm.h>
  13 #include <log.h>
  14 #include <net.h>
  15 #include <usb.h>
  16 #include <mmc.h>
  17 #include <nvme.h>
  18 #include <efi_loader.h>
  19 #include <part.h>
  20 #include <uuid.h>
  21 #include <asm-generic/unaligned.h>
  22 #include <linux/compat.h> /* U16_MAX */
  23
  24 #ifdef CONFIG_BLKMAP
  25 const efi_guid_t efi_guid_blkmap_dev = U_BOOT_BLKMAP_DEV_GUID;
  26 #endif
  27 #ifdef CONFIG_SANDBOX
  28 const efi_guid_t efi_guid_host_dev = U_BOOT_HOST_DEV_GUID;
  29 #endif
  30 #ifdef CONFIG_VIRTIO_BLK
  31 const efi_guid_t efi_guid_virtio_dev = U_BOOT_VIRTIO_DEV_GUID;
  32 #endif
  33
  34 /* template END node: */
  35 const struct efi_device_path END = {
  36         .type     = DEVICE_PATH_TYPE_END,
  37         .sub_type = DEVICE_PATH_SUB_TYPE_END,
  38         .length   = sizeof(END),
  39 };
  40
  41 /* template ROOT node: */
  42 static const struct efi_device_path_vendor ROOT = {
  43         .dp = {
  44                 .type     = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
  45                 .sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
  46                 .length   = sizeof(ROOT),
  47         },
  48         .guid = U_BOOT_GUID,
  49 };
  50
  51 #if defined(CONFIG_MMC)
  52 /*
  53  * Determine if an MMC device is an SD card.
  54  *
  55  * @desc        block device descriptor
  56  * Return:      true if the device is an SD card
  57  */
  58 static bool is_sd(struct blk_desc *desc)
  59 {
  60         struct mmc *mmc = find_mmc_device(desc->devnum);
  61
  62         if (!mmc)
  63                 return false;
  64
  65         return IS_SD(mmc) != 0U;
  66 }
  67 #endif
  68
  69 /*
  70  * Iterate to next block in device-path, terminating (returning NULL)
  71  * at /End* node.
  72  */
  73 struct efi_device_path *efi_dp_next(const struct efi_device_path *dp)
  74 {
  75         if (dp == NULL)
  76                 return NULL;
  77         if (dp->type == DEVICE_PATH_TYPE_END)
  78                 return NULL;
  79         dp = ((void *)dp) + dp->length;
  80         if (dp->type == DEVICE_PATH_TYPE_END)
  81                 return NULL;
  82         return (struct efi_device_path *)dp;
  83 }
  84
  85 /*
  86  * Compare two device-paths, stopping when the shorter of the two hits
  87  * an End* node. This is useful to, for example, compare a device-path
  88  * representing a device with one representing a file on the device, or
  89  * a device with a parent device.
  90  */
  91 int efi_dp_match(const struct efi_device_path *a,
  92                  const struct efi_device_path *b)
  93 {
  94         while (1) {
  95                 int ret;
  96
  97                 ret = memcmp(&a->length, &b->length, sizeof(a->length));
  98                 if (ret)
  99                         return ret;
 100
 101                 ret = memcmp(a, b, a->length);
 102                 if (ret)
 103                         return ret;
 104
 105                 a = efi_dp_next(a);
 106                 b = efi_dp_next(b);
 107
 108                 if (!a || !b)
 109                         return 0;
 110         }
 111 }
 112
 113 /**
 114  * efi_dp_shorten() - shorten device-path
 115  *
 116  * When creating a short boot option we want to use a device-path that is
 117  * independent of the location where the block device is plugged in.
 118  *
 119  * UsbWwi() nodes contain a serial number, hard drive paths a partition
 120  * UUID. Both should be unique.
 121  *
 122  * See UEFI spec, section 3.1.2 for "short-form device path".
 123  *
 124  * @dp:         original device-path
 125  * @Return:     shortened device-path or NULL
 126  */
 127 struct efi_device_path *efi_dp_shorten(struct efi_device_path *dp)
 128 {
 129         while (dp) {
 130                 if (EFI_DP_TYPE(dp, MESSAGING_DEVICE, MSG_USB_WWI) ||
 131                     EFI_DP_TYPE(dp, MEDIA_DEVICE, HARD_DRIVE_PATH) ||
 132                     EFI_DP_TYPE(dp, MEDIA_DEVICE, FILE_PATH))
 133                         return dp;
 134
 135                 dp = efi_dp_next(dp);
 136         }
 137
 138         return dp;
 139 }
 140
 141 /**
 142  * find_handle() - find handle by device path and installed protocol
 143  *
 144  * If @rem is provided, the handle with the longest partial match is returned.
 145  *
 146  * @dp:         device path to search
 147  * @guid:       GUID of protocol that must be installed on path or NULL
 148  * @short_path: use short form device path for matching
 149  * @rem:        pointer to receive remaining device path
 150  * Return:      matching handle
 151  */
 152 static efi_handle_t find_handle(struct efi_device_path *dp,
 153                                 const efi_guid_t *guid, bool short_path,
 154                                 struct efi_device_path **rem)
 155 {
 156         efi_handle_t handle, best_handle = NULL;
 157         efi_uintn_t len, best_len = 0;
 158
 159         len = efi_dp_instance_size(dp);
 160
 161         list_for_each_entry(handle, &efi_obj_list, link) {
 162                 struct efi_handler *handler;
 163                 struct efi_device_path *dp_current;
 164                 efi_uintn_t len_current;
 165                 efi_status_t ret;
 166
 167                 if (guid) {
 168                         ret = efi_search_protocol(handle, guid, &handler);
 169                         if (ret != EFI_SUCCESS)
 170                                 continue;
 171                 }
 172                 ret = efi_search_protocol(handle, &efi_guid_device_path,
 173                                           &handler);
 174                 if (ret != EFI_SUCCESS)
 175                         continue;
 176                 dp_current = handler->protocol_interface;
 177                 if (short_path) {
 178                         dp_current = efi_dp_shorten(dp_current);
 179                         if (!dp_current)
 180                                 continue;
 181                 }
 182                 len_current = efi_dp_instance_size(dp_current);
 183                 if (rem) {
 184                         if (len_current > len)
 185                                 continue;
 186                 } else {
 187                         if (len_current != len)
 188                                 continue;
 189                 }
 190                 if (memcmp(dp_current, dp, len_current))
 191                         continue;
 192                 if (!rem)
 193                         return handle;
 194                 if (len_current > best_len) {
 195                         best_len = len_current;
 196                         best_handle = handle;
 197                         *rem = (void*)((u8 *)dp + len_current);
 198                 }
 199         }
 200         return best_handle;
 201 }
 202
 203 /**
 204  * efi_dp_find_obj() - find handle by device path
 205  *
 206  * If @rem is provided, the handle with the longest partial match is returned.
 207  *
 208  * @dp:         device path to search
 209  * @guid:       GUID of protocol that must be installed on path or NULL
 210  * @rem:        pointer to receive remaining device path
 211  * Return:      matching handle
 212  */
 213 efi_handle_t efi_dp_find_obj(struct efi_device_path *dp,
 214                              const efi_guid_t *guid,
 215                              struct efi_device_path **rem)
 216 {
 217         efi_handle_t handle;
 218
 219         handle = find_handle(dp, guid, false, rem);
 220         if (!handle)
 221                 /* Match short form device path */
 222                 handle = find_handle(dp, guid, true, rem);
 223
 224         return handle;
 225 }
 226
 227 /*
 228  * Determine the last device path node that is not the end node.
 229  *
 230  * @dp          device path
 231  * Return:      last node before the end node if it exists
 232  *              otherwise NULL
 233  */
 234 const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp)
 235 {
 236         struct efi_device_path *ret;
 237
 238         if (!dp || dp->type == DEVICE_PATH_TYPE_END)
 239                 return NULL;
 240         while (dp) {
 241                 ret = (struct efi_device_path *)dp;
 242                 dp = efi_dp_next(dp);
 243         }
 244         return ret;
 245 }
 246
 247 /* get size of the first device path instance excluding end node */
 248 efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp)
 249 {
 250         efi_uintn_t sz = 0;
 251
 252         if (!dp || dp->type == DEVICE_PATH_TYPE_END)
 253                 return 0;
 254         while (dp) {
 255                 sz += dp->length;
 256                 dp = efi_dp_next(dp);
 257         }
 258
 259         return sz;
 260 }
 261
 262 /* get size of multi-instance device path excluding end node */
 263 efi_uintn_t efi_dp_size(const struct efi_device_path *dp)
 264 {
 265         const struct efi_device_path *p = dp;
 266
 267         if (!p)
 268                 return 0;
 269         while (p->type != DEVICE_PATH_TYPE_END ||
 270                p->sub_type != DEVICE_PATH_SUB_TYPE_END)
 271                 p = (void *)p + p->length;
 272
 273         return (void *)p - (void *)dp;
 274 }
 275
 276 /* copy multi-instance device path */
 277 struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp)
 278 {
 279         struct efi_device_path *ndp;
 280         size_t sz = efi_dp_size(dp) + sizeof(END);
 281
 282         if (!dp)
 283                 return NULL;
 284
 285         ndp = efi_alloc(sz);
 286         if (!ndp)
 287                 return NULL;
 288         memcpy(ndp, dp, sz);
 289
 290         return ndp;
 291 }
 292
 293 /**
 294  * efi_dp_append_or_concatenate() - Append or concatenate two device paths.
 295  *                                  Concatenated device path will be separated
 296  *                                  by a sub-type 0xff end node
 297  *
 298  * @dp1:        First device path
 299  * @dp2:        Second device path
 300  * @concat:     If true the two device paths will be concatenated and separated
 301  *              by an end of entrire device path sub-type 0xff end node.
 302  *              If true the second device path will be appended to the first and
 303  *              terminated by an end node
 304  *
 305  * Return:
 306  * concatenated device path or NULL. Caller must free the returned value
 307  */
 308 static struct
 309 efi_device_path *efi_dp_append_or_concatenate(const struct efi_device_path *dp1,
 310                                               const struct efi_device_path *dp2,
 311                                               bool concat)
 312 {
 313         struct efi_device_path *ret;
 314         size_t end_size = sizeof(END);
 315
 316         if (concat)
 317                 end_size = 2 * sizeof(END);
 318         if (!dp1 && !dp2) {
 319                 /* return an end node */
 320                 ret = efi_dp_dup(&END);
 321         } else if (!dp1) {
 322                 ret = efi_dp_dup(dp2);
 323         } else if (!dp2) {
 324                 ret = efi_dp_dup(dp1);
 325         } else {
 326                 /* both dp1 and dp2 are non-null */
 327                 unsigned sz1 = efi_dp_size(dp1);
 328                 unsigned sz2 = efi_dp_size(dp2);
 329                 void *p = efi_alloc(sz1 + sz2 + end_size);
 330                 if (!p)
 331                         return NULL;
 332                 ret = p;
 333                 memcpy(p, dp1, sz1);
 334                 p += sz1;
 335
 336                 if (concat) {
 337                         memcpy(p, &END, sizeof(END));
 338                         p += sizeof(END);
 339                 }
 340
 341                 /* the end node of the second device path has to be retained */
 342                 memcpy(p, dp2, sz2);
 343                 p += sz2;
 344                 memcpy(p, &END, sizeof(END));
 345         }
 346
 347         return ret;
 348 }
 349
 350 /**
 351  * efi_dp_append() - Append a device to an existing device path.
 352  *
 353  * @dp1:        First device path
 354  * @dp2:        Second device path
 355  *
 356  * Return:
 357  * concatenated device path or NULL. Caller must free the returned value
 358  */
 359 struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1,
 360                                       const struct efi_device_path *dp2)
 361 {
 362         return efi_dp_append_or_concatenate(dp1, dp2, false);
 363 }
 364
 365 /**
 366  * efi_dp_concat() - Concatenate 2 device paths. The final device path will
 367  *                   contain two device paths separated by and end node (0xff).
 368  *
 369  * @dp1:        First device path
 370  * @dp2:        Second device path
 371  *
 372  * Return:
 373  * concatenated device path or NULL. Caller must free the returned value
 374  */
 375 struct efi_device_path *efi_dp_concat(const struct efi_device_path *dp1,
 376                                       const struct efi_device_path *dp2)
 377 {
 378         return efi_dp_append_or_concatenate(dp1, dp2, true);
 379 }
 380
 381 struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
 382                                            const struct efi_device_path *node)
 383 {
 384         struct efi_device_path *ret;
 385
 386         if (!node && !dp) {
 387                 ret = efi_dp_dup(&END);
 388         } else if (!node) {
 389                 ret = efi_dp_dup(dp);
 390         } else if (!dp) {
 391                 size_t sz = node->length;
 392                 void *p = efi_alloc(sz + sizeof(END));
 393                 if (!p)
 394                         return NULL;
 395                 memcpy(p, node, sz);
 396                 memcpy(p + sz, &END, sizeof(END));
 397                 ret = p;
 398         } else {
 399                 /* both dp and node are non-null */
 400                 size_t sz = efi_dp_size(dp);
 401                 void *p = efi_alloc(sz + node->length + sizeof(END));
 402                 if (!p)
 403                         return NULL;
 404                 memcpy(p, dp, sz);
 405                 memcpy(p + sz, node, node->length);
 406                 memcpy(p + sz + node->length, &END, sizeof(END));
 407                 ret = p;
 408         }
 409
 410         return ret;
 411 }
 412
 413 struct efi_device_path *efi_dp_create_device_node(const u8 type,
 414                                                   const u8 sub_type,
 415                                                   const u16 length)
 416 {
 417         struct efi_device_path *ret;
 418
 419         if (length < sizeof(struct efi_device_path))
 420                 return NULL;
 421
 422         ret = efi_alloc(length);
 423         if (!ret)
 424                 return ret;
 425         ret->type = type;
 426         ret->sub_type = sub_type;
 427         ret->length = length;
 428         return ret;
 429 }
 430
 431 struct efi_device_path *efi_dp_append_instance(
 432                 const struct efi_device_path *dp,
 433                 const struct efi_device_path *dpi)
 434 {
 435         size_t sz, szi;
 436         struct efi_device_path *p, *ret;
 437
 438         if (!dpi)
 439                 return NULL;
 440         if (!dp)
 441                 return efi_dp_dup(dpi);
 442         sz = efi_dp_size(dp);
 443         szi = efi_dp_instance_size(dpi);
 444         p = efi_alloc(sz + szi + 2 * sizeof(END));
 445         if (!p)
 446                 return NULL;
 447         ret = p;
 448         memcpy(p, dp, sz + sizeof(END));
 449         p = (void *)p + sz;
 450         p->sub_type = DEVICE_PATH_SUB_TYPE_INSTANCE_END;
 451         p = (void *)p + sizeof(END);
 452         memcpy(p, dpi, szi);
 453         p = (void *)p + szi;
 454         memcpy(p, &END, sizeof(END));
 455         return ret;
 456 }
 457
 458 struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp,
 459                                                  efi_uintn_t *size)
 460 {
 461         size_t sz;
 462         struct efi_device_path *p;
 463
 464         if (size)
 465                 *size = 0;
 466         if (!dp || !*dp)
 467                 return NULL;
 468         sz = efi_dp_instance_size(*dp);
 469         p = efi_alloc(sz + sizeof(END));
 470         if (!p)
 471                 return NULL;
 472         memcpy(p, *dp, sz + sizeof(END));
 473         *dp = (void *)*dp + sz;
 474         if ((*dp)->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END)
 475                 *dp = (void *)*dp + sizeof(END);
 476         else
 477                 *dp = NULL;
 478         if (size)
 479                 *size = sz + sizeof(END);
 480         return p;
 481 }
 482
 483 bool efi_dp_is_multi_instance(const struct efi_device_path *dp)
 484 {
 485         const struct efi_device_path *p = dp;
 486
 487         if (!p)
 488                 return false;
 489         while (p->type != DEVICE_PATH_TYPE_END)
 490                 p = (void *)p + p->length;
 491         return p->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END;
 492 }
 493
 494 /* size of device-path not including END node for device and all parents
 495  * up to the root device.
 496  */
 497 __maybe_unused static unsigned int dp_size(struct udevice *dev)
 498 {
 499         if (!dev || !dev->driver)
 500                 return sizeof(ROOT);
 501
 502         switch (device_get_uclass_id(dev)) {
 503         case UCLASS_ROOT:
 504         case UCLASS_SIMPLE_BUS:
 505                 /* stop traversing parents at this point: */
 506                 return sizeof(ROOT);
 507         case UCLASS_ETH:
 508                 return dp_size(dev->parent) +
 509                         sizeof(struct efi_device_path_mac_addr);
 510         case UCLASS_BLK:
 511                 switch (dev->parent->uclass->uc_drv->id) {
 512 #ifdef CONFIG_IDE
 513                 case UCLASS_IDE:
 514                         return dp_size(dev->parent) +
 515                                 sizeof(struct efi_device_path_atapi);
 516 #endif
 517 #if defined(CONFIG_SCSI)
 518                 case UCLASS_SCSI:
 519                         return dp_size(dev->parent) +
 520                                 sizeof(struct efi_device_path_scsi);
 521 #endif
 522 #if defined(CONFIG_MMC)
 523                 case UCLASS_MMC:
 524                         return dp_size(dev->parent) +
 525                                 sizeof(struct efi_device_path_sd_mmc_path);
 526 #endif
 527 #if defined(CONFIG_AHCI) || defined(CONFIG_SATA)
 528                 case UCLASS_AHCI:
 529                         return dp_size(dev->parent) +
 530                                 sizeof(struct efi_device_path_sata);
 531 #endif
 532 #if defined(CONFIG_NVME)
 533                 case UCLASS_NVME:
 534                         return dp_size(dev->parent) +
 535                                 sizeof(struct efi_device_path_nvme);
 536 #endif
 537 #ifdef CONFIG_SANDBOX
 538                 case UCLASS_HOST:
 539                          /*
 540                           * Sandbox's host device will be represented
 541                           * as vendor device with extra one byte for
 542                           * device number
 543                           */
 544                         return dp_size(dev->parent)
 545                                 + sizeof(struct efi_device_path_vendor) + 1;
 546 #endif
 547 #ifdef CONFIG_USB
 548                 case UCLASS_MASS_STORAGE:
 549                         return dp_size(dev->parent)
 550                                 + sizeof(struct efi_device_path_controller);
 551 #endif
 552 #ifdef CONFIG_VIRTIO_BLK
 553                 case UCLASS_VIRTIO:
 554                          /*
 555                           * Virtio devices will be represented as a vendor
 556                           * device node with an extra byte for the device
 557                           * number.
 558                           */
 559                         return dp_size(dev->parent)
 560                                 + sizeof(struct efi_device_path_vendor) + 1;
 561 #endif
 562 #ifdef CONFIG_BLKMAP
 563                 case UCLASS_BLKMAP:
 564                          /*
 565                           * blkmap devices will be represented as a vendor
 566                           * device node with an extra byte for the device
 567                           * number.
 568                           */
 569                         return dp_size(dev->parent)
 570                                 + sizeof(struct efi_device_path_vendor) + 1;
 571 #endif
 572                 default:
 573                         return dp_size(dev->parent);
 574                 }
 575 #if defined(CONFIG_MMC)
 576         case UCLASS_MMC:
 577                 return dp_size(dev->parent) +
 578                         sizeof(struct efi_device_path_sd_mmc_path);
 579 #endif
 580         case UCLASS_MASS_STORAGE:
 581         case UCLASS_USB_HUB:
 582                 return dp_size(dev->parent) +
 583                         sizeof(struct efi_device_path_usb);
 584         default:
 585                 /* just skip over unknown classes: */
 586                 return dp_size(dev->parent);
 587         }
 588 }
 589
 590 /*
 591  * Recursively build a device path.
 592  *
 593  * @buf         pointer to the end of the device path
 594  * @dev         device
 595  * Return:      pointer to the end of the device path
 596  */
 597 __maybe_unused static void *dp_fill(void *buf, struct udevice *dev)
 598 {
 599         if (!dev || !dev->driver)
 600                 return buf;
 601
 602         switch (device_get_uclass_id(dev)) {
 603         case UCLASS_ROOT:
 604         case UCLASS_SIMPLE_BUS: {
 605                 /* stop traversing parents at this point: */
 606                 struct efi_device_path_vendor *vdp = buf;
 607                 *vdp = ROOT;
 608                 return &vdp[1];
 609         }
 610 #ifdef CONFIG_NETDEVICES
 611         case UCLASS_ETH: {
 612                 struct efi_device_path_mac_addr *dp =
 613                         dp_fill(buf, dev->parent);
 614                 struct eth_pdata *pdata = dev_get_plat(dev);
 615
 616                 dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 617                 dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_MAC_ADDR;
 618                 dp->dp.length = sizeof(*dp);
 619                 memset(&dp->mac, 0, sizeof(dp->mac));
 620                 /* We only support IPv4 */
 621                 memcpy(&dp->mac, &pdata->enetaddr, ARP_HLEN);
 622                 /* Ethernet */
 623                 dp->if_type = 1;
 624                 return &dp[1];
 625         }
 626 #endif
 627         case UCLASS_BLK:
 628                 switch (dev->parent->uclass->uc_drv->id) {
 629 #ifdef CONFIG_BLKMAP
 630                 case UCLASS_BLKMAP: {
 631                         struct efi_device_path_vendor *dp;
 632                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 633
 634                         dp_fill(buf, dev->parent);
 635                         dp = buf;
 636                         ++dp;
 637                         dp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
 638                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
 639                         dp->dp.length = sizeof(*dp) + 1;
 640                         memcpy(&dp->guid, &efi_guid_blkmap_dev,
 641                                sizeof(efi_guid_t));
 642                         dp->vendor_data[0] = desc->devnum;
 643                         return &dp->vendor_data[1];
 644                         }
 645 #endif
 646 #ifdef CONFIG_SANDBOX
 647                 case UCLASS_HOST: {
 648                         /* stop traversing parents at this point: */
 649                         struct efi_device_path_vendor *dp;
 650                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 651
 652                         dp_fill(buf, dev->parent);
 653                         dp = buf;
 654                         ++dp;
 655                         dp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
 656                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
 657                         dp->dp.length = sizeof(*dp) + 1;
 658                         memcpy(&dp->guid, &efi_guid_host_dev,
 659                                sizeof(efi_guid_t));
 660                         dp->vendor_data[0] = desc->devnum;
 661                         return &dp->vendor_data[1];
 662                         }
 663 #endif
 664 #ifdef CONFIG_VIRTIO_BLK
 665                 case UCLASS_VIRTIO: {
 666                         struct efi_device_path_vendor *dp;
 667                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 668
 669                         dp_fill(buf, dev->parent);
 670                         dp = buf;
 671                         ++dp;
 672                         dp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
 673                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
 674                         dp->dp.length = sizeof(*dp) + 1;
 675                         memcpy(&dp->guid, &efi_guid_virtio_dev,
 676                                sizeof(efi_guid_t));
 677                         dp->vendor_data[0] = desc->devnum;
 678                         return &dp->vendor_data[1];
 679                         }
 680 #endif
 681 #ifdef CONFIG_IDE
 682                 case UCLASS_IDE: {
 683                         struct efi_device_path_atapi *dp =
 684                         dp_fill(buf, dev->parent);
 685                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 686
 687                         dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 688                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_ATAPI;
 689                         dp->dp.length = sizeof(*dp);
 690                         dp->logical_unit_number = desc->devnum;
 691                         dp->primary_secondary = IDE_BUS(desc->devnum);
 692                         dp->slave_master = desc->devnum %
 693                                 (CONFIG_SYS_IDE_MAXDEVICE /
 694                                  CONFIG_SYS_IDE_MAXBUS);
 695                         return &dp[1];
 696                         }
 697 #endif
 698 #if defined(CONFIG_SCSI)
 699                 case UCLASS_SCSI: {
 700                         struct efi_device_path_scsi *dp =
 701                                 dp_fill(buf, dev->parent);
 702                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 703
 704                         dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 705                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_SCSI;
 706                         dp->dp.length = sizeof(*dp);
 707                         dp->logical_unit_number = desc->lun;
 708                         dp->target_id = desc->target;
 709                         return &dp[1];
 710                         }
 711 #endif
 712 #if defined(CONFIG_MMC)
 713                 case UCLASS_MMC: {
 714                         struct efi_device_path_sd_mmc_path *sddp =
 715                                 dp_fill(buf, dev->parent);
 716                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 717
 718                         sddp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 719                         sddp->dp.sub_type = is_sd(desc) ?
 720                                 DEVICE_PATH_SUB_TYPE_MSG_SD :
 721                                 DEVICE_PATH_SUB_TYPE_MSG_MMC;
 722                         sddp->dp.length   = sizeof(*sddp);
 723                         sddp->slot_number = dev_seq(dev);
 724                         return &sddp[1];
 725                         }
 726 #endif
 727 #if defined(CONFIG_AHCI) || defined(CONFIG_SATA)
 728                 case UCLASS_AHCI: {
 729                         struct efi_device_path_sata *dp =
 730                                 dp_fill(buf, dev->parent);
 731                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 732
 733                         dp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 734                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_SATA;
 735                         dp->dp.length   = sizeof(*dp);
 736                         dp->hba_port = desc->devnum;
 737                         /* default 0xffff implies no port multiplier */
 738                         dp->port_multiplier_port = 0xffff;
 739                         dp->logical_unit_number = desc->lun;
 740                         return &dp[1];
 741                         }
 742 #endif
 743 #if defined(CONFIG_NVME)
 744                 case UCLASS_NVME: {
 745                         struct efi_device_path_nvme *dp =
 746                                 dp_fill(buf, dev->parent);
 747                         u32 ns_id;
 748
 749                         dp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 750                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_NVME;
 751                         dp->dp.length   = sizeof(*dp);
 752                         nvme_get_namespace_id(dev, &ns_id, dp->eui64);
 753                         memcpy(&dp->ns_id, &ns_id, sizeof(ns_id));
 754                         return &dp[1];
 755                         }
 756 #endif
 757 #if defined(CONFIG_USB)
 758                 case UCLASS_MASS_STORAGE: {
 759                         struct blk_desc *desc = dev_get_uclass_plat(dev);
 760                         struct efi_device_path_controller *dp =
 761                                 dp_fill(buf, dev->parent);
 762
 763                         dp->dp.type     = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
 764                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_CONTROLLER;
 765                         dp->dp.length   = sizeof(*dp);
 766                         dp->controller_number = desc->lun;
 767                         return &dp[1];
 768                 }
 769 #endif
 770                 default:
 771                         debug("%s(%u) %s: unhandled parent class: %s (%u)\n",
 772                               __FILE__, __LINE__, __func__,
 773                               dev->name, dev->parent->uclass->uc_drv->id);
 774                         return dp_fill(buf, dev->parent);
 775                 }
 776 #if defined(CONFIG_MMC)
 777         case UCLASS_MMC: {
 778                 struct efi_device_path_sd_mmc_path *sddp =
 779                         dp_fill(buf, dev->parent);
 780                 struct mmc *mmc = mmc_get_mmc_dev(dev);
 781                 struct blk_desc *desc = mmc_get_blk_desc(mmc);
 782
 783                 sddp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 784                 sddp->dp.sub_type = is_sd(desc) ?
 785                         DEVICE_PATH_SUB_TYPE_MSG_SD :
 786                         DEVICE_PATH_SUB_TYPE_MSG_MMC;
 787                 sddp->dp.length   = sizeof(*sddp);
 788                 sddp->slot_number = dev_seq(dev);
 789
 790                 return &sddp[1];
 791         }
 792 #endif
 793         case UCLASS_MASS_STORAGE:
 794         case UCLASS_USB_HUB: {
 795                 struct efi_device_path_usb *udp = dp_fill(buf, dev->parent);
 796
 797                 switch (device_get_uclass_id(dev->parent)) {
 798                 case UCLASS_USB_HUB: {
 799                         struct usb_device *udev = dev_get_parent_priv(dev);
 800
 801                         udp->parent_port_number = udev->portnr;
 802                         break;
 803                 }
 804                 default:
 805                         udp->parent_port_number = 0;
 806                 }
 807                 udp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 808                 udp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_USB;
 809                 udp->dp.length   = sizeof(*udp);
 810                 udp->usb_interface = 0;
 811
 812                 return &udp[1];
 813         }
 814         default:
 815                 /* If the uclass driver is missing, this will show NULL */
 816                 log_debug("unhandled device class: %s (%s)\n", dev->name,
 817                           dev_get_uclass_name(dev));
 818                 return dp_fill(buf, dev->parent);
 819         }
 820 }
 821
 822 static unsigned dp_part_size(struct blk_desc *desc, int part)
 823 {
 824         unsigned dpsize;
 825         struct udevice *dev = desc->bdev;
 826
 827         dpsize = dp_size(dev);
 828
 829         if (part == 0) /* the actual disk, not a partition */
 830                 return dpsize;
 831
 832         if (desc->part_type == PART_TYPE_ISO)
 833                 dpsize += sizeof(struct efi_device_path_cdrom_path);
 834         else
 835                 dpsize += sizeof(struct efi_device_path_hard_drive_path);
 836
 837         return dpsize;
 838 }
 839
 840 /*
 841  * Create a device node for a block device partition.
 842  *
 843  * @buf         buffer to which the device path is written
 844  * @desc        block device descriptor
 845  * @part        partition number, 0 identifies a block device
 846  *
 847  * Return:      pointer to position after the node
 848  */
 849 static void *dp_part_node(void *buf, struct blk_desc *desc, int part)
 850 {
 851         struct disk_partition info;
 852         int ret;
 853
 854         ret = part_get_info(desc, part, &info);
 855         if (ret < 0)
 856                 return buf;
 857
 858         if (desc->part_type == PART_TYPE_ISO) {
 859                 struct efi_device_path_cdrom_path *cddp = buf;
 860
 861                 cddp->boot_entry = part;
 862                 cddp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
 863                 cddp->dp.sub_type = DEVICE_PATH_SUB_TYPE_CDROM_PATH;
 864                 cddp->dp.length = sizeof(*cddp);
 865                 cddp->partition_start = info.start;
 866                 cddp->partition_size = info.size;
 867
 868                 buf = &cddp[1];
 869         } else {
 870                 struct efi_device_path_hard_drive_path *hddp = buf;
 871
 872                 hddp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
 873                 hddp->dp.sub_type = DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH;
 874                 hddp->dp.length = sizeof(*hddp);
 875                 hddp->partition_number = part;
 876                 hddp->partition_start = info.start;
 877                 hddp->partition_end = info.size;
 878                 if (desc->part_type == PART_TYPE_EFI)
 879                         hddp->partmap_type = 2;
 880                 else
 881                         hddp->partmap_type = 1;
 882
 883                 switch (desc->sig_type) {
 884                 case SIG_TYPE_NONE:
 885                 default:
 886                         hddp->signature_type = 0;
 887                         memset(hddp->partition_signature, 0,
 888                                sizeof(hddp->partition_signature));
 889                         break;
 890                 case SIG_TYPE_MBR:
 891                         hddp->signature_type = 1;
 892                         memset(hddp->partition_signature, 0,
 893                                sizeof(hddp->partition_signature));
 894                         memcpy(hddp->partition_signature, &desc->mbr_sig,
 895                                sizeof(desc->mbr_sig));
 896                         break;
 897                 case SIG_TYPE_GUID:
 898                         hddp->signature_type = 2;
 899 #if CONFIG_IS_ENABLED(PARTITION_UUIDS)
 900                         /* info.uuid exists only with PARTITION_UUIDS */
 901                         if (uuid_str_to_bin(info.uuid,
 902                                             hddp->partition_signature,
 903                                             UUID_STR_FORMAT_GUID)) {
 904                                 log_warning(
 905                                         "Partition %d: invalid GUID %s\n",
 906                                         part, info.uuid);
 907                         }
 908 #endif
 909                         break;
 910                 }
 911
 912                 buf = &hddp[1];
 913         }
 914
 915         return buf;
 916 }
 917
 918 /*
 919  * Create a device path for a block device or one of its partitions.
 920  *
 921  * @buf         buffer to which the device path is written
 922  * @desc        block device descriptor
 923  * @part        partition number, 0 identifies a block device
 924  */
 925 static void *dp_part_fill(void *buf, struct blk_desc *desc, int part)
 926 {
 927         struct udevice *dev = desc->bdev;
 928
 929         buf = dp_fill(buf, dev);
 930
 931         if (part == 0) /* the actual disk, not a partition */
 932                 return buf;
 933
 934         return dp_part_node(buf, desc, part);
 935 }
 936
 937 /* Construct a device-path from a partition on a block device: */
 938 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
 939 {
 940         void *buf, *start;
 941
 942         start = buf = efi_alloc(dp_part_size(desc, part) + sizeof(END));
 943         if (!buf)
 944                 return NULL;
 945
 946         buf = dp_part_fill(buf, desc, part);
 947
 948         *((struct efi_device_path *)buf) = END;
 949
 950         return start;
 951 }
 952
 953 /*
 954  * Create a device node for a block device partition.
 955  *
 956  * @buf         buffer to which the device path is written
 957  * @desc        block device descriptor
 958  * @part        partition number, 0 identifies a block device
 959  */
 960 struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part)
 961 {
 962         efi_uintn_t dpsize;
 963         void *buf;
 964
 965         if (desc->part_type == PART_TYPE_ISO)
 966                 dpsize = sizeof(struct efi_device_path_cdrom_path);
 967         else
 968                 dpsize = sizeof(struct efi_device_path_hard_drive_path);
 969         buf = efi_alloc(dpsize);
 970
 971         if (buf)
 972                 dp_part_node(buf, desc, part);
 973
 974         return buf;
 975 }
 976
 977 /**
 978  * path_to_uefi() - convert UTF-8 path to an UEFI style path
 979  *
 980  * Convert UTF-8 path to a UEFI style path (i.e. with backslashes as path
 981  * separators and UTF-16).
 982  *
 983  * @src:        source buffer
 984  * @uefi:       target buffer, possibly unaligned
 985  */
 986 static void path_to_uefi(void *uefi, const char *src)
 987 {
 988         u16 *pos = uefi;
 989
 990         /*
 991          * efi_set_bootdev() calls this routine indirectly before the UEFI
 992          * subsystem is initialized. So we cannot assume unaligned access to be
 993          * enabled.
 994          */
 995         allow_unaligned();
 996
 997         while (*src) {
 998                 s32 code = utf8_get(&src);
 999
1000                 if (code < 0)
1001                         code = '?';
1002                 else if (code == '/')
1003                         code = '\\';
1004                 utf16_put(code, &pos);
1005         }
1006         *pos = 0;
1007 }
1008
1009 /**
1010  * efi_dp_from_file() - append file path node to device path.
1011  *
1012  * @dp:         device path or NULL
1013  * @path:       file path or NULL
1014  * Return:      device path or NULL in case of an error
1015  */
1016 struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp,
1017                                          const char *path)
1018 {
1019         struct efi_device_path_file_path *fp;
1020         void *buf, *pos;
1021         size_t dpsize, fpsize;
1022
1023         dpsize = efi_dp_size(dp);
1024         fpsize = sizeof(struct efi_device_path) +
1025                  2 * (utf8_utf16_strlen(path) + 1);
1026         if (fpsize > U16_MAX)
1027                 return NULL;
1028
1029         buf = efi_alloc(dpsize + fpsize + sizeof(END));
1030         if (!buf)
1031                 return NULL;
1032
1033         memcpy(buf, dp, dpsize);
1034         pos = buf + dpsize;
1035
1036         /* add file-path: */
1037         if (*path) {
1038                 fp = pos;
1039                 fp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
1040                 fp->dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH;
1041                 fp->dp.length = (u16)fpsize;
1042                 path_to_uefi(fp->str, path);
1043                 pos += fpsize;
1044         }
1045
1046         memcpy(pos, &END, sizeof(END));
1047
1048         return buf;
1049 }
1050
1051 struct efi_device_path *efi_dp_from_uart(void)
1052 {
1053         void *buf, *pos;
1054         struct efi_device_path_uart *uart;
1055         size_t dpsize = sizeof(ROOT) + sizeof(*uart) + sizeof(END);
1056
1057         buf = efi_alloc(dpsize);
1058         if (!buf)
1059                 return NULL;
1060         pos = buf;
1061         memcpy(pos, &ROOT, sizeof(ROOT));
1062         pos += sizeof(ROOT);
1063         uart = pos;
1064         uart->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
1065         uart->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_UART;
1066         uart->dp.length = sizeof(*uart);
1067         pos += sizeof(*uart);
1068         memcpy(pos, &END, sizeof(END));
1069
1070         return buf;
1071 }
1072
1073 struct efi_device_path __maybe_unused *efi_dp_from_eth(void)
1074 {
1075         void *buf, *start;
1076         unsigned dpsize = 0;
1077
1078         assert(eth_get_dev());
1079
1080         dpsize += dp_size(eth_get_dev());
1081
1082         start = buf = efi_alloc(dpsize + sizeof(END));
1083         if (!buf)
1084                 return NULL;
1085
1086         buf = dp_fill(buf, eth_get_dev());
1087
1088         *((struct efi_device_path *)buf) = END;
1089
1090         return start;
1091 }
1092
1093 /* Construct a device-path for memory-mapped image */
1094 struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
1095                                         uint64_t start_address,
1096                                         uint64_t end_address)
1097 {
1098         struct efi_device_path_memory *mdp;
1099         void *buf, *start;
1100
1101         start = buf = efi_alloc(sizeof(*mdp) + sizeof(END));
1102         if (!buf)
1103                 return NULL;
1104
1105         mdp = buf;
1106         mdp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
1107         mdp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MEMORY;
1108         mdp->dp.length = sizeof(*mdp);
1109         mdp->memory_type = memory_type;
1110         mdp->start_address = start_address;
1111         mdp->end_address = end_address;
1112         buf = &mdp[1];
1113
1114         *((struct efi_device_path *)buf) = END;
1115
1116         return start;
1117 }
1118
1119 /**
1120  * efi_dp_split_file_path() - split of relative file path from device path
1121  *
1122  * Given a device path indicating a file on a device, separate the device
1123  * path in two: the device path of the actual device and the file path
1124  * relative to this device.
1125  *
1126  * @full_path:          device path including device and file path
1127  * @device_path:        path of the device
1128  * @file_path:          relative path of the file or NULL if there is none
1129  * Return:              status code
1130  */
1131 efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
1132                                     struct efi_device_path **device_path,
1133                                     struct efi_device_path **file_path)
1134 {
1135         struct efi_device_path *p, *dp, *fp = NULL;
1136
1137         *device_path = NULL;
1138         *file_path = NULL;
1139         dp = efi_dp_dup(full_path);
1140         if (!dp)
1141                 return EFI_OUT_OF_RESOURCES;
1142         p = dp;
1143         while (!EFI_DP_TYPE(p, MEDIA_DEVICE, FILE_PATH)) {
1144                 p = efi_dp_next(p);
1145                 if (!p)
1146                         goto out;
1147         }
1148         fp = efi_dp_dup(p);
1149         if (!fp)
1150                 return EFI_OUT_OF_RESOURCES;
1151         p->type = DEVICE_PATH_TYPE_END;
1152         p->sub_type = DEVICE_PATH_SUB_TYPE_END;
1153         p->length = sizeof(*p);
1154
1155 out:
1156         *device_path = dp;
1157         *file_path = fp;
1158         return EFI_SUCCESS;
1159 }
1160
1161 /**
1162  * efi_dp_from_name() - convert U-Boot device and file path to device path
1163  *
1164  * @dev:        U-Boot device, e.g. 'mmc'
1165  * @devnr:      U-Boot device number, e.g. 1 for 'mmc:1'
1166  * @path:       file path relative to U-Boot device, may be NULL
1167  * @device:     pointer to receive device path of the device
1168  * @file:       pointer to receive device path for the file
1169  * Return:      status code
1170  */
1171 efi_status_t efi_dp_from_name(const char *dev, const char *devnr,
1172                               const char *path,
1173                               struct efi_device_path **device,
1174                               struct efi_device_path **file)
1175 {
1176         struct blk_desc *desc = NULL;
1177         struct efi_device_path *dp;
1178         struct disk_partition fs_partition;
1179         size_t image_size;
1180         void *image_addr;
1181         int part = 0;
1182
1183         if (path && !file)
1184                 return EFI_INVALID_PARAMETER;
1185
1186         if (!strcmp(dev, "Mem") || !strcmp(dev, "hostfs"))  {
1187                 /* loadm command and semihosting */
1188                 efi_get_image_parameters(&image_addr, &image_size);
1189
1190                 dp = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
1191                                      (uintptr_t)image_addr, image_size);
1192         } else if (IS_ENABLED(CONFIG_NETDEVICES) && !strcmp(dev, "Net")) {
1193                 dp = efi_dp_from_eth();
1194         } else if (!strcmp(dev, "Uart")) {
1195                 dp = efi_dp_from_uart();
1196         } else {
1197                 part = blk_get_device_part_str(dev, devnr, &desc, &fs_partition,
1198                                                1);
1199                 if (part < 0 || !desc)
1200                         return EFI_INVALID_PARAMETER;
1201
1202                 dp = efi_dp_from_part(desc, part);
1203         }
1204         if (device)
1205                 *device = dp;
1206
1207         if (!path)
1208                 return EFI_SUCCESS;
1209
1210         *file = efi_dp_from_file(dp, path);
1211         if (!*file)
1212                 return EFI_OUT_OF_RESOURCES;
1213
1214         return EFI_SUCCESS;
1215 }
1216
1217 /**
1218  * efi_dp_check_length() - check length of a device path
1219  *
1220  * @dp:         pointer to device path
1221  * @maxlen:     maximum length of the device path
1222  * Return:
1223  * * length of the device path if it is less or equal @maxlen
1224  * * -1 if the device path is longer then @maxlen
1225  * * -1 if a device path node has a length of less than 4
1226  * * -EINVAL if maxlen exceeds SSIZE_MAX
1227  */
1228 ssize_t efi_dp_check_length(const struct efi_device_path *dp,
1229                             const size_t maxlen)
1230 {
1231         ssize_t ret = 0;
1232         u16 len;
1233
1234         if (maxlen > SSIZE_MAX)
1235                 return -EINVAL;
1236         for (;;) {
1237                 len = dp->length;
1238                 if (len < 4)
1239                         return -1;
1240                 ret += len;
1241                 if (ret > maxlen)
1242                         return -1;
1243                 if (dp->type == DEVICE_PATH_TYPE_END &&
1244                     dp->sub_type == DEVICE_PATH_SUB_TYPE_END)
1245                         return ret;
1246                 dp = (const struct efi_device_path *)((const u8 *)dp + len);
1247         }
1248 }
1249
1250 /**
1251  * efi_dp_from_lo() - Get the instance of a VenMedia node in a
1252  *                    multi-instance device path that matches
1253  *                    a specific GUID. This kind of device paths
1254  *                    is found in Boot#### options describing an
1255  *                    initrd location
1256  *
1257  * @lo:         EFI_LOAD_OPTION containing a valid device path
1258  * @guid:       guid to search for
1259  *
1260  * Return:
1261  * device path including the VenMedia node or NULL.
1262  * Caller must free the returned value.
1263  */
1264 struct
1265 efi_device_path *efi_dp_from_lo(struct efi_load_option *lo,
1266                                 const efi_guid_t *guid)
1267 {
1268         struct efi_device_path *fp = lo->file_path;
1269         struct efi_device_path_vendor *vendor;
1270         int lo_len = lo->file_path_length;
1271
1272         for (; lo_len >=  sizeof(struct efi_device_path);
1273              lo_len -= fp->length, fp = (void *)fp + fp->length) {
1274                 if (lo_len < 0 || efi_dp_check_length(fp, lo_len) < 0)
1275                         break;
1276                 if (fp->type != DEVICE_PATH_TYPE_MEDIA_DEVICE ||
1277                     fp->sub_type != DEVICE_PATH_SUB_TYPE_VENDOR_PATH)
1278                         continue;
1279
1280                 vendor = (struct efi_device_path_vendor *)fp;
1281                 if (!guidcmp(&vendor->guid, guid))
1282                         return efi_dp_dup(efi_dp_next(fp));
1283         }
1284         log_debug("VenMedia(%pUl) not found in %ls\n", &guid, lo->label);
1285
1286         return NULL;
1287 }
1288
1289 /**
1290  * search_gpt_dp_node() - search gpt device path node
1291  *
1292  * @device_path:        device path
1293  *
1294  * Return:      pointer to the gpt device path node
1295  */
1296 struct efi_device_path *search_gpt_dp_node(struct efi_device_path *device_path)
1297 {
1298         struct efi_device_path *dp = device_path;
1299
1300         while (dp) {
1301                 if (dp->type == DEVICE_PATH_TYPE_MEDIA_DEVICE &&
1302                     dp->sub_type == DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH) {
1303                         struct efi_device_path_hard_drive_path *hd_dp =
1304                                 (struct efi_device_path_hard_drive_path *)dp;
1305
1306                         if (hd_dp->partmap_type == PART_FORMAT_GPT &&
1307                             hd_dp->signature_type == SIG_TYPE_GUID)
1308                                 return dp;
1309                 }
1310                 dp = efi_dp_next(dp);
1311         }
1312
1313         return NULL;
1314 }