mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
196 lines
5.7 KiB
196 lines
5.7 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* dev-path-parser.c - EFI Device Path parser |
|
* Copyright (C) 2016 Lukas Wunner <[email protected]> |
|
* |
|
* 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; |
|
}
|
|
|