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