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 #include <common.h>
   9 #include <blk.h>
  10 #include <dm.h>
  11 #include <usb.h>
  12 #include <mmc.h>
  13 #include <efi_loader.h>
  14 #include <part.h>
  15 #include <asm-generic/unaligned.h>
  16
  17 /* template END node: */
  18 static const struct efi_device_path END = {
  19         .type     = DEVICE_PATH_TYPE_END,
  20         .sub_type = DEVICE_PATH_SUB_TYPE_END,
  21         .length   = sizeof(END),
  22 };
  23
  24 /* template ROOT node: */
  25 static const struct efi_device_path_vendor ROOT = {
  26         .dp = {
  27                 .type     = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
  28                 .sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
  29                 .length   = sizeof(ROOT),
  30         },
  31         .guid = U_BOOT_GUID,
  32 };
  33
  34 #if defined(CONFIG_DM_MMC) && defined(CONFIG_MMC)
  35 /*
  36  * Determine if an MMC device is an SD card.
  37  *
  38  * @desc        block device descriptor
  39  * @return      true if the device is an SD card
  40  */
  41 static bool is_sd(struct blk_desc *desc)
  42 {
  43         struct mmc *mmc = find_mmc_device(desc->devnum);
  44
  45         if (!mmc)
  46                 return false;
  47
  48         return IS_SD(mmc) != 0U;
  49 }
  50 #endif
  51
  52 static void *dp_alloc(size_t sz)
  53 {
  54         void *buf;
  55
  56         if (efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, sz, &buf) !=
  57             EFI_SUCCESS) {
  58                 debug("EFI: ERROR: out of memory in %s\n", __func__);
  59                 return NULL;
  60         }
  61
  62         memset(buf, 0, sz);
  63         return buf;
  64 }
  65
  66 /*
  67  * Iterate to next block in device-path, terminating (returning NULL)
  68  * at /End* node.
  69  */
  70 struct efi_device_path *efi_dp_next(const struct efi_device_path *dp)
  71 {
  72         if (dp == NULL)
  73                 return NULL;
  74         if (dp->type == DEVICE_PATH_TYPE_END)
  75                 return NULL;
  76         dp = ((void *)dp) + dp->length;
  77         if (dp->type == DEVICE_PATH_TYPE_END)
  78                 return NULL;
  79         return (struct efi_device_path *)dp;
  80 }
  81
  82 /*
  83  * Compare two device-paths, stopping when the shorter of the two hits
  84  * an End* node. This is useful to, for example, compare a device-path
  85  * representing a device with one representing a file on the device, or
  86  * a device with a parent device.
  87  */
  88 int efi_dp_match(const struct efi_device_path *a,
  89                  const struct efi_device_path *b)
  90 {
  91         while (1) {
  92                 int ret;
  93
  94                 ret = memcmp(&a->length, &b->length, sizeof(a->length));
  95                 if (ret)
  96                         return ret;
  97
  98                 ret = memcmp(a, b, a->length);
  99                 if (ret)
 100                         return ret;
 101
 102                 a = efi_dp_next(a);
 103                 b = efi_dp_next(b);
 104
 105                 if (!a || !b)
 106                         return 0;
 107         }
 108 }
 109
 110 /*
 111  * We can have device paths that start with a USB WWID or a USB Class node,
 112  * and a few other cases which don't encode the full device path with bus
 113  * hierarchy:
 114  *
 115  *   - MESSAGING:USB_WWID
 116  *   - MESSAGING:USB_CLASS
 117  *   - MEDIA:FILE_PATH
 118  *   - MEDIA:HARD_DRIVE
 119  *   - MESSAGING:URI
 120  *
 121  * See UEFI spec (section 3.1.2, about short-form device-paths)
 122  */
 123 static struct efi_device_path *shorten_path(struct efi_device_path *dp)
 124 {
 125         while (dp) {
 126                 /*
 127                  * TODO: Add MESSAGING:USB_WWID and MESSAGING:URI..
 128                  * in practice fallback.efi just uses MEDIA:HARD_DRIVE
 129                  * so not sure when we would see these other cases.
 130                  */
 131                 if (EFI_DP_TYPE(dp, MESSAGING_DEVICE, MSG_USB_CLASS) ||
 132                     EFI_DP_TYPE(dp, MEDIA_DEVICE, HARD_DRIVE_PATH) ||
 133                     EFI_DP_TYPE(dp, MEDIA_DEVICE, FILE_PATH))
 134                         return dp;
 135
 136                 dp = efi_dp_next(dp);
 137         }
 138
 139         return dp;
 140 }
 141
 142 static struct efi_object *find_obj(struct efi_device_path *dp, bool short_path,
 143                                    struct efi_device_path **rem)
 144 {
 145         struct efi_object *efiobj;
 146         efi_uintn_t dp_size = efi_dp_instance_size(dp);
 147
 148         list_for_each_entry(efiobj, &efi_obj_list, link) {
 149                 struct efi_handler *handler;
 150                 struct efi_device_path *obj_dp;
 151                 efi_status_t ret;
 152
 153                 ret = efi_search_protocol(efiobj,
 154                                           &efi_guid_device_path, &handler);
 155                 if (ret != EFI_SUCCESS)
 156                         continue;
 157                 obj_dp = handler->protocol_interface;
 158
 159                 do {
 160                         if (efi_dp_match(dp, obj_dp) == 0) {
 161                                 if (rem) {
 162                                         /*
 163                                          * Allow partial matches, but inform
 164                                          * the caller.
 165                                          */
 166                                         *rem = ((void *)dp) +
 167                                                 efi_dp_instance_size(obj_dp);
 168                                         return efiobj;
 169                                 } else {
 170                                         /* Only return on exact matches */
 171                                         if (efi_dp_instance_size(obj_dp) ==
 172                                             dp_size)
 173                                                 return efiobj;
 174                                 }
 175                         }
 176
 177                         obj_dp = shorten_path(efi_dp_next(obj_dp));
 178                 } while (short_path && obj_dp);
 179         }
 180
 181         return NULL;
 182 }
 183
 184 /*
 185  * Find an efiobj from device-path, if 'rem' is not NULL, returns the
 186  * remaining part of the device path after the matched object.
 187  */
 188 struct efi_object *efi_dp_find_obj(struct efi_device_path *dp,
 189                                    struct efi_device_path **rem)
 190 {
 191         struct efi_object *efiobj;
 192
 193         /* Search for an exact match first */
 194         efiobj = find_obj(dp, false, NULL);
 195
 196         /* Then for a fuzzy match */
 197         if (!efiobj)
 198                 efiobj = find_obj(dp, false, rem);
 199
 200         /* And now for a fuzzy short match */
 201         if (!efiobj)
 202                 efiobj = find_obj(dp, true, rem);
 203
 204         return efiobj;
 205 }
 206
 207 /*
 208  * Determine the last device path node that is not the end node.
 209  *
 210  * @dp          device path
 211  * @return      last node before the end node if it exists
 212  *              otherwise NULL
 213  */
 214 const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp)
 215 {
 216         struct efi_device_path *ret;
 217
 218         if (!dp || dp->type == DEVICE_PATH_TYPE_END)
 219                 return NULL;
 220         while (dp) {
 221                 ret = (struct efi_device_path *)dp;
 222                 dp = efi_dp_next(dp);
 223         }
 224         return ret;
 225 }
 226
 227 /* get size of the first device path instance excluding end node */
 228 efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp)
 229 {
 230         efi_uintn_t sz = 0;
 231
 232         if (!dp || dp->type == DEVICE_PATH_TYPE_END)
 233                 return 0;
 234         while (dp) {
 235                 sz += dp->length;
 236                 dp = efi_dp_next(dp);
 237         }
 238
 239         return sz;
 240 }
 241
 242 /* get size of multi-instance device path excluding end node */
 243 efi_uintn_t efi_dp_size(const struct efi_device_path *dp)
 244 {
 245         const struct efi_device_path *p = dp;
 246
 247         if (!p)
 248                 return 0;
 249         while (p->type != DEVICE_PATH_TYPE_END ||
 250                p->sub_type != DEVICE_PATH_SUB_TYPE_END)
 251                 p = (void *)p + p->length;
 252
 253         return (void *)p - (void *)dp;
 254 }
 255
 256 /* copy multi-instance device path */
 257 struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp)
 258 {
 259         struct efi_device_path *ndp;
 260         size_t sz = efi_dp_size(dp) + sizeof(END);
 261
 262         if (!dp)
 263                 return NULL;
 264
 265         ndp = dp_alloc(sz);
 266         if (!ndp)
 267                 return NULL;
 268         memcpy(ndp, dp, sz);
 269
 270         return ndp;
 271 }
 272
 273 struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1,
 274                                       const struct efi_device_path *dp2)
 275 {
 276         struct efi_device_path *ret;
 277
 278         if (!dp1 && !dp2) {
 279                 /* return an end node */
 280                 ret = efi_dp_dup(&END);
 281         } else if (!dp1) {
 282                 ret = efi_dp_dup(dp2);
 283         } else if (!dp2) {
 284                 ret = efi_dp_dup(dp1);
 285         } else {
 286                 /* both dp1 and dp2 are non-null */
 287                 unsigned sz1 = efi_dp_size(dp1);
 288                 unsigned sz2 = efi_dp_size(dp2);
 289                 void *p = dp_alloc(sz1 + sz2 + sizeof(END));
 290                 if (!p)
 291                         return NULL;
 292                 memcpy(p, dp1, sz1);
 293                 /* the end node of the second device path has to be retained */
 294                 memcpy(p + sz1, dp2, sz2 + sizeof(END));
 295                 ret = p;
 296         }
 297
 298         return ret;
 299 }
 300
 301 struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
 302                                            const struct efi_device_path *node)
 303 {
 304         struct efi_device_path *ret;
 305
 306         if (!node && !dp) {
 307                 ret = efi_dp_dup(&END);
 308         } else if (!node) {
 309                 ret = efi_dp_dup(dp);
 310         } else if (!dp) {
 311                 size_t sz = node->length;
 312                 void *p = dp_alloc(sz + sizeof(END));
 313                 if (!p)
 314                         return NULL;
 315                 memcpy(p, node, sz);
 316                 memcpy(p + sz, &END, sizeof(END));
 317                 ret = p;
 318         } else {
 319                 /* both dp and node are non-null */
 320                 size_t sz = efi_dp_size(dp);
 321                 void *p = dp_alloc(sz + node->length + sizeof(END));
 322                 if (!p)
 323                         return NULL;
 324                 memcpy(p, dp, sz);
 325                 memcpy(p + sz, node, node->length);
 326                 memcpy(p + sz + node->length, &END, sizeof(END));
 327                 ret = p;
 328         }
 329
 330         return ret;
 331 }
 332
 333 struct efi_device_path *efi_dp_create_device_node(const u8 type,
 334                                                   const u8 sub_type,
 335                                                   const u16 length)
 336 {
 337         struct efi_device_path *ret;
 338
 339         if (length < sizeof(struct efi_device_path))
 340                 return NULL;
 341
 342         ret = dp_alloc(length);
 343         if (!ret)
 344                 return ret;
 345         ret->type = type;
 346         ret->sub_type = sub_type;
 347         ret->length = length;
 348         return ret;
 349 }
 350
 351 struct efi_device_path *efi_dp_append_instance(
 352                 const struct efi_device_path *dp,
 353                 const struct efi_device_path *dpi)
 354 {
 355         size_t sz, szi;
 356         struct efi_device_path *p, *ret;
 357
 358         if (!dpi)
 359                 return NULL;
 360         if (!dp)
 361                 return efi_dp_dup(dpi);
 362         sz = efi_dp_size(dp);
 363         szi = efi_dp_instance_size(dpi);
 364         p = dp_alloc(sz + szi + 2 * sizeof(END));
 365         if (!p)
 366                 return NULL;
 367         ret = p;
 368         memcpy(p, dp, sz + sizeof(END));
 369         p = (void *)p + sz;
 370         p->sub_type = DEVICE_PATH_SUB_TYPE_INSTANCE_END;
 371         p = (void *)p + sizeof(END);
 372         memcpy(p, dpi, szi);
 373         p = (void *)p + szi;
 374         memcpy(p, &END, sizeof(END));
 375         return ret;
 376 }
 377
 378 struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp,
 379                                                  efi_uintn_t *size)
 380 {
 381         size_t sz;
 382         struct efi_device_path *p;
 383
 384         if (size)
 385                 *size = 0;
 386         if (!dp || !*dp)
 387                 return NULL;
 388         sz = efi_dp_instance_size(*dp);
 389         p = dp_alloc(sz + sizeof(END));
 390         if (!p)
 391                 return NULL;
 392         memcpy(p, *dp, sz + sizeof(END));
 393         *dp = (void *)*dp + sz;
 394         if ((*dp)->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END)
 395                 *dp = (void *)*dp + sizeof(END);
 396         else
 397                 *dp = NULL;
 398         if (size)
 399                 *size = sz + sizeof(END);
 400         return p;
 401 }
 402
 403 bool efi_dp_is_multi_instance(const struct efi_device_path *dp)
 404 {
 405         const struct efi_device_path *p = dp;
 406
 407         if (!p)
 408                 return false;
 409         while (p->type != DEVICE_PATH_TYPE_END)
 410                 p = (void *)p + p->length;
 411         return p->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END;
 412 }
 413
 414 #ifdef CONFIG_DM
 415 /* size of device-path not including END node for device and all parents
 416  * up to the root device.
 417  */
 418 static unsigned dp_size(struct udevice *dev)
 419 {
 420         if (!dev || !dev->driver)
 421                 return sizeof(ROOT);
 422
 423         switch (dev->driver->id) {
 424         case UCLASS_ROOT:
 425         case UCLASS_SIMPLE_BUS:
 426                 /* stop traversing parents at this point: */
 427                 return sizeof(ROOT);
 428         case UCLASS_ETH:
 429                 return dp_size(dev->parent) +
 430                         sizeof(struct efi_device_path_mac_addr);
 431 #ifdef CONFIG_BLK
 432         case UCLASS_BLK:
 433                 switch (dev->parent->uclass->uc_drv->id) {
 434 #ifdef CONFIG_IDE
 435                 case UCLASS_IDE:
 436                         return dp_size(dev->parent) +
 437                                 sizeof(struct efi_device_path_atapi);
 438 #endif
 439 #if defined(CONFIG_SCSI) && defined(CONFIG_DM_SCSI)
 440                 case UCLASS_SCSI:
 441                         return dp_size(dev->parent) +
 442                                 sizeof(struct efi_device_path_scsi);
 443 #endif
 444 #if defined(CONFIG_DM_MMC) && defined(CONFIG_MMC)
 445                 case UCLASS_MMC:
 446                         return dp_size(dev->parent) +
 447                                 sizeof(struct efi_device_path_sd_mmc_path);
 448 #endif
 449                 default:
 450                         return dp_size(dev->parent);
 451                 }
 452 #endif
 453 #if defined(CONFIG_DM_MMC) && defined(CONFIG_MMC)
 454         case UCLASS_MMC:
 455                 return dp_size(dev->parent) +
 456                         sizeof(struct efi_device_path_sd_mmc_path);
 457 #endif
 458         case UCLASS_MASS_STORAGE:
 459         case UCLASS_USB_HUB:
 460                 return dp_size(dev->parent) +
 461                         sizeof(struct efi_device_path_usb_class);
 462         default:
 463                 /* just skip over unknown classes: */
 464                 return dp_size(dev->parent);
 465         }
 466 }
 467
 468 /*
 469  * Recursively build a device path.
 470  *
 471  * @buf         pointer to the end of the device path
 472  * @dev         device
 473  * @return      pointer to the end of the device path
 474  */
 475 static void *dp_fill(void *buf, struct udevice *dev)
 476 {
 477         if (!dev || !dev->driver)
 478                 return buf;
 479
 480         switch (dev->driver->id) {
 481         case UCLASS_ROOT:
 482         case UCLASS_SIMPLE_BUS: {
 483                 /* stop traversing parents at this point: */
 484                 struct efi_device_path_vendor *vdp = buf;
 485                 *vdp = ROOT;
 486                 return &vdp[1];
 487         }
 488 #ifdef CONFIG_DM_ETH
 489         case UCLASS_ETH: {
 490                 struct efi_device_path_mac_addr *dp =
 491                         dp_fill(buf, dev->parent);
 492                 struct eth_pdata *pdata = dev->platdata;
 493
 494                 dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 495                 dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_MAC_ADDR;
 496                 dp->dp.length = sizeof(*dp);
 497                 memset(&dp->mac, 0, sizeof(dp->mac));
 498                 /* We only support IPv4 */
 499                 memcpy(&dp->mac, &pdata->enetaddr, ARP_HLEN);
 500                 /* Ethernet */
 501                 dp->if_type = 1;
 502                 return &dp[1];
 503         }
 504 #endif
 505 #ifdef CONFIG_BLK
 506         case UCLASS_BLK:
 507                 switch (dev->parent->uclass->uc_drv->id) {
 508 #ifdef CONFIG_IDE
 509                 case UCLASS_IDE: {
 510                         struct efi_device_path_atapi *dp =
 511                         dp_fill(buf, dev->parent);
 512                         struct blk_desc *desc = dev_get_uclass_platdata(dev);
 513
 514                         dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 515                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_ATAPI;
 516                         dp->dp.length = sizeof(*dp);
 517                         dp->logical_unit_number = desc->devnum;
 518                         dp->primary_secondary = IDE_BUS(desc->devnum);
 519                         dp->slave_master = desc->devnum %
 520                                 (CONFIG_SYS_IDE_MAXDEVICE /
 521                                  CONFIG_SYS_IDE_MAXBUS);
 522                         return &dp[1];
 523                         }
 524 #endif
 525 #if defined(CONFIG_SCSI) && defined(CONFIG_DM_SCSI)
 526                 case UCLASS_SCSI: {
 527                         struct efi_device_path_scsi *dp =
 528                                 dp_fill(buf, dev->parent);
 529                         struct blk_desc *desc = dev_get_uclass_platdata(dev);
 530
 531                         dp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 532                         dp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_SCSI;
 533                         dp->dp.length = sizeof(*dp);
 534                         dp->logical_unit_number = desc->lun;
 535                         dp->target_id = desc->target;
 536                         return &dp[1];
 537                         }
 538 #endif
 539 #if defined(CONFIG_DM_MMC) && defined(CONFIG_MMC)
 540                 case UCLASS_MMC: {
 541                         struct efi_device_path_sd_mmc_path *sddp =
 542                                 dp_fill(buf, dev->parent);
 543                         struct blk_desc *desc = dev_get_uclass_platdata(dev);
 544
 545                         sddp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 546                         sddp->dp.sub_type = is_sd(desc) ?
 547                                 DEVICE_PATH_SUB_TYPE_MSG_SD :
 548                                 DEVICE_PATH_SUB_TYPE_MSG_MMC;
 549                         sddp->dp.length   = sizeof(*sddp);
 550                         sddp->slot_number = dev->seq;
 551                         return &sddp[1];
 552                         }
 553 #endif
 554                 default:
 555                         debug("%s(%u) %s: unhandled parent class: %s (%u)\n",
 556                               __FILE__, __LINE__, __func__,
 557                               dev->name, dev->parent->uclass->uc_drv->id);
 558                         return dp_fill(buf, dev->parent);
 559                 }
 560 #endif
 561 #if defined(CONFIG_DM_MMC) && defined(CONFIG_MMC)
 562         case UCLASS_MMC: {
 563                 struct efi_device_path_sd_mmc_path *sddp =
 564                         dp_fill(buf, dev->parent);
 565                 struct mmc *mmc = mmc_get_mmc_dev(dev);
 566                 struct blk_desc *desc = mmc_get_blk_desc(mmc);
 567
 568                 sddp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 569                 sddp->dp.sub_type = is_sd(desc) ?
 570                         DEVICE_PATH_SUB_TYPE_MSG_SD :
 571                         DEVICE_PATH_SUB_TYPE_MSG_MMC;
 572                 sddp->dp.length   = sizeof(*sddp);
 573                 sddp->slot_number = dev->seq;
 574
 575                 return &sddp[1];
 576         }
 577 #endif
 578         case UCLASS_MASS_STORAGE:
 579         case UCLASS_USB_HUB: {
 580                 struct efi_device_path_usb_class *udp =
 581                         dp_fill(buf, dev->parent);
 582                 struct usb_device *udev = dev_get_parent_priv(dev);
 583                 struct usb_device_descriptor *desc = &udev->descriptor;
 584
 585                 udp->dp.type     = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 586                 udp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_USB_CLASS;
 587                 udp->dp.length   = sizeof(*udp);
 588                 udp->vendor_id   = desc->idVendor;
 589                 udp->product_id  = desc->idProduct;
 590                 udp->device_class    = desc->bDeviceClass;
 591                 udp->device_subclass = desc->bDeviceSubClass;
 592                 udp->device_protocol = desc->bDeviceProtocol;
 593
 594                 return &udp[1];
 595         }
 596         default:
 597                 debug("%s(%u) %s: unhandled device class: %s (%u)\n",
 598                       __FILE__, __LINE__, __func__,
 599                       dev->name, dev->driver->id);
 600                 return dp_fill(buf, dev->parent);
 601         }
 602 }
 603
 604 /* Construct a device-path from a device: */
 605 struct efi_device_path *efi_dp_from_dev(struct udevice *dev)
 606 {
 607         void *buf, *start;
 608
 609         start = buf = dp_alloc(dp_size(dev) + sizeof(END));
 610         if (!buf)
 611                 return NULL;
 612         buf = dp_fill(buf, dev);
 613         *((struct efi_device_path *)buf) = END;
 614
 615         return start;
 616 }
 617 #endif
 618
 619 static unsigned dp_part_size(struct blk_desc *desc, int part)
 620 {
 621         unsigned dpsize;
 622
 623 #ifdef CONFIG_BLK
 624         {
 625                 struct udevice *dev;
 626                 int ret = blk_find_device(desc->if_type, desc->devnum, &dev);
 627
 628                 if (ret)
 629                         dev = desc->bdev->parent;
 630                 dpsize = dp_size(dev);
 631         }
 632 #else
 633         dpsize = sizeof(ROOT) + sizeof(struct efi_device_path_usb);
 634 #endif
 635
 636         if (part == 0) /* the actual disk, not a partition */
 637                 return dpsize;
 638
 639         if (desc->part_type == PART_TYPE_ISO)
 640                 dpsize += sizeof(struct efi_device_path_cdrom_path);
 641         else
 642                 dpsize += sizeof(struct efi_device_path_hard_drive_path);
 643
 644         return dpsize;
 645 }
 646
 647 /*
 648  * Create a device node for a block device partition.
 649  *
 650  * @buf         buffer to which the device path is written
 651  * @desc        block device descriptor
 652  * @part        partition number, 0 identifies a block device
 653  */
 654 static void *dp_part_node(void *buf, struct blk_desc *desc, int part)
 655 {
 656         disk_partition_t info;
 657
 658         part_get_info(desc, part, &info);
 659
 660         if (desc->part_type == PART_TYPE_ISO) {
 661                 struct efi_device_path_cdrom_path *cddp = buf;
 662
 663                 cddp->boot_entry = part;
 664                 cddp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
 665                 cddp->dp.sub_type = DEVICE_PATH_SUB_TYPE_CDROM_PATH;
 666                 cddp->dp.length = sizeof(*cddp);
 667                 cddp->partition_start = info.start;
 668                 cddp->partition_end = info.size;
 669
 670                 buf = &cddp[1];
 671         } else {
 672                 struct efi_device_path_hard_drive_path *hddp = buf;
 673
 674                 hddp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
 675                 hddp->dp.sub_type = DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH;
 676                 hddp->dp.length = sizeof(*hddp);
 677                 hddp->partition_number = part;
 678                 hddp->partition_start = info.start;
 679                 hddp->partition_end = info.size;
 680                 if (desc->part_type == PART_TYPE_EFI)
 681                         hddp->partmap_type = 2;
 682                 else
 683                         hddp->partmap_type = 1;
 684
 685                 switch (desc->sig_type) {
 686                 case SIG_TYPE_NONE:
 687                 default:
 688                         hddp->signature_type = 0;
 689                         memset(hddp->partition_signature, 0,
 690                                sizeof(hddp->partition_signature));
 691                         break;
 692                 case SIG_TYPE_MBR:
 693                         hddp->signature_type = 1;
 694                         memset(hddp->partition_signature, 0,
 695                                sizeof(hddp->partition_signature));
 696                         memcpy(hddp->partition_signature, &desc->mbr_sig,
 697                                sizeof(desc->mbr_sig));
 698                         break;
 699                 case SIG_TYPE_GUID:
 700                         hddp->signature_type = 2;
 701                         memcpy(hddp->partition_signature, &desc->guid_sig,
 702                                sizeof(hddp->partition_signature));
 703                         break;
 704                 }
 705
 706                 buf = &hddp[1];
 707         }
 708
 709         return buf;
 710 }
 711
 712 /*
 713  * Create a device path for a block device or one of its partitions.
 714  *
 715  * @buf         buffer to which the device path is written
 716  * @desc        block device descriptor
 717  * @part        partition number, 0 identifies a block device
 718  */
 719 static void *dp_part_fill(void *buf, struct blk_desc *desc, int part)
 720 {
 721 #ifdef CONFIG_BLK
 722         {
 723                 struct udevice *dev;
 724                 int ret = blk_find_device(desc->if_type, desc->devnum, &dev);
 725
 726                 if (ret)
 727                         dev = desc->bdev->parent;
 728                 buf = dp_fill(buf, dev);
 729         }
 730 #else
 731         /*
 732          * We *could* make a more accurate path, by looking at if_type
 733          * and handling all the different cases like we do for non-
 734          * legacy (i.e. CONFIG_BLK=y) case. But most important thing
 735          * is just to have a unique device-path for if_type+devnum.
 736          * So map things to a fictitious USB device.
 737          */
 738         struct efi_device_path_usb *udp;
 739
 740         memcpy(buf, &ROOT, sizeof(ROOT));
 741         buf += sizeof(ROOT);
 742
 743         udp = buf;
 744         udp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 745         udp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_USB;
 746         udp->dp.length = sizeof(*udp);
 747         udp->parent_port_number = desc->if_type;
 748         udp->usb_interface = desc->devnum;
 749         buf = &udp[1];
 750 #endif
 751
 752         if (part == 0) /* the actual disk, not a partition */
 753                 return buf;
 754
 755         return dp_part_node(buf, desc, part);
 756 }
 757
 758 /* Construct a device-path from a partition on a block device: */
 759 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
 760 {
 761         void *buf, *start;
 762
 763         start = buf = dp_alloc(dp_part_size(desc, part) + sizeof(END));
 764         if (!buf)
 765                 return NULL;
 766
 767         buf = dp_part_fill(buf, desc, part);
 768
 769         *((struct efi_device_path *)buf) = END;
 770
 771         return start;
 772 }
 773
 774 /*
 775  * Create a device node for a block device partition.
 776  *
 777  * @buf         buffer to which the device path is written
 778  * @desc        block device descriptor
 779  * @part        partition number, 0 identifies a block device
 780  */
 781 struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part)
 782 {
 783         efi_uintn_t dpsize;
 784         void *buf;
 785
 786         if (desc->part_type == PART_TYPE_ISO)
 787                 dpsize = sizeof(struct efi_device_path_cdrom_path);
 788         else
 789                 dpsize = sizeof(struct efi_device_path_hard_drive_path);
 790         buf = dp_alloc(dpsize);
 791
 792         dp_part_node(buf, desc, part);
 793
 794         return buf;
 795 }
 796
 797 /**
 798  * path_to_uefi() - convert UTF-8 path to an UEFI style path
 799  *
 800  * Convert UTF-8 path to a UEFI style path (i.e. with backslashes as path
 801  * separators and UTF-16).
 802  *
 803  * @src:        source buffer
 804  * @uefi:       target buffer, possibly unaligned
 805  */
 806 static void path_to_uefi(void *uefi, const char *src)
 807 {
 808         u16 *pos = uefi;
 809
 810         /*
 811          * efi_set_bootdev() calls this routine indirectly before the UEFI
 812          * subsystem is initialized. So we cannot assume unaligned access to be
 813          * enabled.
 814          */
 815         allow_unaligned();
 816
 817         while (*src) {
 818                 s32 code = utf8_get(&src);
 819
 820                 if (code < 0)
 821                         code = '?';
 822                 else if (code == '/')
 823                         code = '\\';
 824                 utf16_put(code, &pos);
 825         }
 826         *pos = 0;
 827 }
 828
 829 /*
 830  * If desc is NULL, this creates a path with only the file component,
 831  * otherwise it creates a full path with both device and file components
 832  */
 833 struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part,
 834                 const char *path)
 835 {
 836         struct efi_device_path_file_path *fp;
 837         void *buf, *start;
 838         unsigned dpsize = 0, fpsize;
 839
 840         if (desc)
 841                 dpsize = dp_part_size(desc, part);
 842
 843         fpsize = sizeof(struct efi_device_path) +
 844                  2 * (utf8_utf16_strlen(path) + 1);
 845         dpsize += fpsize;
 846
 847         start = buf = dp_alloc(dpsize + sizeof(END));
 848         if (!buf)
 849                 return NULL;
 850
 851         if (desc)
 852                 buf = dp_part_fill(buf, desc, part);
 853
 854         /* add file-path: */
 855         fp = buf;
 856         fp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE;
 857         fp->dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH;
 858         fp->dp.length = fpsize;
 859         path_to_uefi(fp->str, path);
 860         buf += fpsize;
 861
 862         *((struct efi_device_path *)buf) = END;
 863
 864         return start;
 865 }
 866
 867 #ifdef CONFIG_NET
 868 struct efi_device_path *efi_dp_from_eth(void)
 869 {
 870 #ifndef CONFIG_DM_ETH
 871         struct efi_device_path_mac_addr *ndp;
 872 #endif
 873         void *buf, *start;
 874         unsigned dpsize = 0;
 875
 876         assert(eth_get_dev());
 877
 878 #ifdef CONFIG_DM_ETH
 879         dpsize += dp_size(eth_get_dev());
 880 #else
 881         dpsize += sizeof(ROOT);
 882         dpsize += sizeof(*ndp);
 883 #endif
 884
 885         start = buf = dp_alloc(dpsize + sizeof(END));
 886         if (!buf)
 887                 return NULL;
 888
 889 #ifdef CONFIG_DM_ETH
 890         buf = dp_fill(buf, eth_get_dev());
 891 #else
 892         memcpy(buf, &ROOT, sizeof(ROOT));
 893         buf += sizeof(ROOT);
 894
 895         ndp = buf;
 896         ndp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
 897         ndp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_MAC_ADDR;
 898         ndp->dp.length = sizeof(*ndp);
 899         ndp->if_type = 1; /* Ethernet */
 900         memcpy(ndp->mac.addr, eth_get_ethaddr(), ARP_HLEN);
 901         buf = &ndp[1];
 902 #endif
 903
 904         *((struct efi_device_path *)buf) = END;
 905
 906         return start;
 907 }
 908 #endif
 909
 910 /* Construct a device-path for memory-mapped image */
 911 struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
 912                                         uint64_t start_address,
 913                                         uint64_t end_address)
 914 {
 915         struct efi_device_path_memory *mdp;
 916         void *buf, *start;
 917
 918         start = buf = dp_alloc(sizeof(*mdp) + sizeof(END));
 919         if (!buf)
 920                 return NULL;
 921
 922         mdp = buf;
 923         mdp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
 924         mdp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MEMORY;
 925         mdp->dp.length = sizeof(*mdp);
 926         mdp->memory_type = memory_type;
 927         mdp->start_address = start_address;
 928         mdp->end_address = end_address;
 929         buf = &mdp[1];
 930
 931         *((struct efi_device_path *)buf) = END;
 932
 933         return start;
 934 }
 935
 936 /**
 937  * efi_dp_split_file_path() - split of relative file path from device path
 938  *
 939  * Given a device path indicating a file on a device, separate the device
 940  * path in two: the device path of the actual device and the file path
 941  * relative to this device.
 942  *
 943  * @full_path:          device path including device and file path
 944  * @device_path:        path of the device
 945  * @file_path:          relative path of the file or NULL if there is none
 946  * Return:              status code
 947  */
 948 efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
 949                                     struct efi_device_path **device_path,
 950                                     struct efi_device_path **file_path)
 951 {
 952         struct efi_device_path *p, *dp, *fp = NULL;
 953
 954         *device_path = NULL;
 955         *file_path = NULL;
 956         dp = efi_dp_dup(full_path);
 957         if (!dp)
 958                 return EFI_OUT_OF_RESOURCES;
 959         p = dp;
 960         while (!EFI_DP_TYPE(p, MEDIA_DEVICE, FILE_PATH)) {
 961                 p = efi_dp_next(p);
 962                 if (!p)
 963                         goto out;
 964         }
 965         fp = efi_dp_dup(p);
 966         if (!fp)
 967                 return EFI_OUT_OF_RESOURCES;
 968         p->type = DEVICE_PATH_TYPE_END;
 969         p->sub_type = DEVICE_PATH_SUB_TYPE_END;
 970         p->length = sizeof(*p);
 971
 972 out:
 973         *device_path = dp;
 974         *file_path = fp;
 975         return EFI_SUCCESS;
 976 }
 977
 978 efi_status_t efi_dp_from_name(const char *dev, const char *devnr,
 979                               const char *path,
 980                               struct efi_device_path **device,
 981                               struct efi_device_path **file)
 982 {
 983         int is_net;
 984         struct blk_desc *desc = NULL;
 985         disk_partition_t fs_partition;
 986         int part = 0;
 987         char filename[32] = { 0 }; /* dp->str is u16[32] long */
 988         char *s;
 989
 990         if (path && !file)
 991                 return EFI_INVALID_PARAMETER;
 992
 993         is_net = !strcmp(dev, "Net");
 994         if (!is_net) {
 995                 part = blk_get_device_part_str(dev, devnr, &desc, &fs_partition,
 996                                                1);
 997                 if (part < 0 || !desc)
 998                         return EFI_INVALID_PARAMETER;
 999
1000                 if (device)
1001                         *device = efi_dp_from_part(desc, part);
1002         } else {
1003 #ifdef CONFIG_NET
1004                 if (device)
1005                         *device = efi_dp_from_eth();
1006 #endif
1007         }
1008
1009         if (!path)
1010                 return EFI_SUCCESS;
1011
1012         snprintf(filename, sizeof(filename), "%s", path);
1013         /* DOS style file path: */
1014         s = filename;
1015         while ((s = strchr(s, '/')))
1016                 *s++ = '\\';
1017         *file = efi_dp_from_file(((!is_net && device) ? desc : NULL),
1018                                  part, filename);
1019
1020         return EFI_SUCCESS;
1021 }