mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-25 21:54:06 +08:00
db8952e709
In preparation of adding support for loading the initrd via a special device path, add the struct definition of a vendor GUIDed device path node to efi.h. Since we will be producing these data structures rather than just consumsing the ones instantiated by the firmware, refactor the various device path node definitions so we can take the size of each node using sizeof() rather than having to resort to opaque arithmetic in the static initializers. While at it, drop the #if IS_ENABLED() check for the declaration of efi_get_device_by_path(), which is unnecessary, and constify its first argument as well. Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
197 lines
5.7 KiB
C
197 lines
5.7 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* dev-path-parser.c - EFI Device Path parser
|
|
* Copyright (C) 2016 Lukas Wunner <lukas@wunner.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License (version 2) as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/efi.h>
|
|
#include <linux/pci.h>
|
|
|
|
struct acpi_hid_uid {
|
|
struct acpi_device_id hid[2];
|
|
char uid[11]; /* UINT_MAX + null byte */
|
|
};
|
|
|
|
static int __init match_acpi_dev(struct device *dev, const void *data)
|
|
{
|
|
struct acpi_hid_uid hid_uid = *(const struct acpi_hid_uid *)data;
|
|
struct acpi_device *adev = to_acpi_device(dev);
|
|
|
|
if (acpi_match_device_ids(adev, hid_uid.hid))
|
|
return 0;
|
|
|
|
if (adev->pnp.unique_id)
|
|
return !strcmp(adev->pnp.unique_id, hid_uid.uid);
|
|
else
|
|
return !strcmp("0", hid_uid.uid);
|
|
}
|
|
|
|
static long __init parse_acpi_path(const struct efi_dev_path *node,
|
|
struct device *parent, struct device **child)
|
|
{
|
|
struct acpi_hid_uid hid_uid = {};
|
|
struct device *phys_dev;
|
|
|
|
if (node->header.length != 12)
|
|
return -EINVAL;
|
|
|
|
sprintf(hid_uid.hid[0].id, "%c%c%c%04X",
|
|
'A' + ((node->acpi.hid >> 10) & 0x1f) - 1,
|
|
'A' + ((node->acpi.hid >> 5) & 0x1f) - 1,
|
|
'A' + ((node->acpi.hid >> 0) & 0x1f) - 1,
|
|
node->acpi.hid >> 16);
|
|
sprintf(hid_uid.uid, "%u", node->acpi.uid);
|
|
|
|
*child = bus_find_device(&acpi_bus_type, NULL, &hid_uid,
|
|
match_acpi_dev);
|
|
if (!*child)
|
|
return -ENODEV;
|
|
|
|
phys_dev = acpi_get_first_physical_node(to_acpi_device(*child));
|
|
if (phys_dev) {
|
|
get_device(phys_dev);
|
|
put_device(*child);
|
|
*child = phys_dev;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init match_pci_dev(struct device *dev, void *data)
|
|
{
|
|
unsigned int devfn = *(unsigned int *)data;
|
|
|
|
return dev_is_pci(dev) && to_pci_dev(dev)->devfn == devfn;
|
|
}
|
|
|
|
static long __init parse_pci_path(const struct efi_dev_path *node,
|
|
struct device *parent, struct device **child)
|
|
{
|
|
unsigned int devfn;
|
|
|
|
if (node->header.length != 6)
|
|
return -EINVAL;
|
|
if (!parent)
|
|
return -EINVAL;
|
|
|
|
devfn = PCI_DEVFN(node->pci.dev, node->pci.fn);
|
|
|
|
*child = device_find_child(parent, &devfn, match_pci_dev);
|
|
if (!*child)
|
|
return -ENODEV;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Insert parsers for further node types here.
|
|
*
|
|
* Each parser takes a pointer to the @node and to the @parent (will be NULL
|
|
* for the first device path node). If a device corresponding to @node was
|
|
* found below @parent, its reference count should be incremented and the
|
|
* device returned in @child.
|
|
*
|
|
* The return value should be 0 on success or a negative int on failure.
|
|
* The special return values 0x01 (EFI_DEV_END_INSTANCE) and 0xFF
|
|
* (EFI_DEV_END_ENTIRE) signal the end of the device path, only
|
|
* parse_end_path() is supposed to return this.
|
|
*
|
|
* Be sure to validate the node length and contents before commencing the
|
|
* search for a device.
|
|
*/
|
|
|
|
static long __init parse_end_path(const struct efi_dev_path *node,
|
|
struct device *parent, struct device **child)
|
|
{
|
|
if (node->header.length != 4)
|
|
return -EINVAL;
|
|
if (node->header.sub_type != EFI_DEV_END_INSTANCE &&
|
|
node->header.sub_type != EFI_DEV_END_ENTIRE)
|
|
return -EINVAL;
|
|
if (!parent)
|
|
return -ENODEV;
|
|
|
|
*child = get_device(parent);
|
|
return node->header.sub_type;
|
|
}
|
|
|
|
/**
|
|
* efi_get_device_by_path - find device by EFI Device Path
|
|
* @node: EFI Device Path
|
|
* @len: maximum length of EFI Device Path in bytes
|
|
*
|
|
* Parse a series of EFI Device Path nodes at @node and find the corresponding
|
|
* device. If the device was found, its reference count is incremented and a
|
|
* pointer to it is returned. The caller needs to drop the reference with
|
|
* put_device() after use. The @node pointer is updated to point to the
|
|
* location immediately after the "End of Hardware Device Path" node.
|
|
*
|
|
* If another Device Path instance follows, @len is decremented by the number
|
|
* of bytes consumed. Otherwise @len is set to %0.
|
|
*
|
|
* If a Device Path node is malformed or its corresponding device is not found,
|
|
* @node is updated to point to this offending node and an ERR_PTR is returned.
|
|
*
|
|
* If @len is initially %0, the function returns %NULL. Thus, to iterate over
|
|
* all instances in a path, the following idiom may be used:
|
|
*
|
|
* while (!IS_ERR_OR_NULL(dev = efi_get_device_by_path(&node, &len))) {
|
|
* // do something with dev
|
|
* put_device(dev);
|
|
* }
|
|
* if (IS_ERR(dev))
|
|
* // report error
|
|
*
|
|
* Devices can only be found if they're already instantiated. Most buses
|
|
* instantiate devices in the "subsys" initcall level, hence the earliest
|
|
* initcall level in which this function should be called is "fs".
|
|
*
|
|
* Returns the device on success or
|
|
* %ERR_PTR(-ENODEV) if no device was found,
|
|
* %ERR_PTR(-EINVAL) if a node is malformed or exceeds @len,
|
|
* %ERR_PTR(-ENOTSUPP) if support for a node type is not yet implemented.
|
|
*/
|
|
struct device * __init efi_get_device_by_path(const struct efi_dev_path **node,
|
|
size_t *len)
|
|
{
|
|
struct device *parent = NULL, *child;
|
|
long ret = 0;
|
|
|
|
if (!*len)
|
|
return NULL;
|
|
|
|
while (!ret) {
|
|
if (*len < 4 || *len < (*node)->header.length)
|
|
ret = -EINVAL;
|
|
else if ((*node)->header.type == EFI_DEV_ACPI &&
|
|
(*node)->header.sub_type == EFI_DEV_BASIC_ACPI)
|
|
ret = parse_acpi_path(*node, parent, &child);
|
|
else if ((*node)->header.type == EFI_DEV_HW &&
|
|
(*node)->header.sub_type == EFI_DEV_PCI)
|
|
ret = parse_pci_path(*node, parent, &child);
|
|
else if (((*node)->header.type == EFI_DEV_END_PATH ||
|
|
(*node)->header.type == EFI_DEV_END_PATH2))
|
|
ret = parse_end_path(*node, parent, &child);
|
|
else
|
|
ret = -ENOTSUPP;
|
|
|
|
put_device(parent);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
|
|
parent = child;
|
|
*node = (void *)*node + (*node)->header.length;
|
|
*len -= (*node)->header.length;
|
|
}
|
|
|
|
if (ret == EFI_DEV_END_ENTIRE)
|
|
*len = 0;
|
|
|
|
return child;
|
|
}
|