1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * dev-path-parser.c - EFI Device Path parser |
4 | * Copyright (C) 2016 Lukas Wunner <lukas@wunner.de> |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify |
7 | * it under the terms of the GNU General Public License (version 2) as |
8 | * published by the Free Software Foundation. |
9 | */ |
10 | |
11 | #include <linux/acpi.h> |
12 | #include <linux/efi.h> |
13 | #include <linux/pci.h> |
14 | |
15 | static long __init parse_acpi_path(const struct efi_dev_path *node, |
16 | struct device *parent, struct device **child) |
17 | { |
18 | struct acpi_device *adev; |
19 | struct device *phys_dev; |
20 | char hid[ACPI_ID_LEN]; |
21 | |
22 | if (node->header.length != 12) |
23 | return -EINVAL; |
24 | |
25 | sprintf(buf: hid, fmt: "%c%c%c%04X" , |
26 | 'A' + ((node->acpi.hid >> 10) & 0x1f) - 1, |
27 | 'A' + ((node->acpi.hid >> 5) & 0x1f) - 1, |
28 | 'A' + ((node->acpi.hid >> 0) & 0x1f) - 1, |
29 | node->acpi.hid >> 16); |
30 | |
31 | for_each_acpi_dev_match(adev, hid, NULL, -1) { |
32 | if (acpi_dev_uid_match(adev, node->acpi.uid)) |
33 | break; |
34 | if (!acpi_device_uid(adev) && node->acpi.uid == 0) |
35 | break; |
36 | } |
37 | if (!adev) |
38 | return -ENODEV; |
39 | |
40 | phys_dev = acpi_get_first_physical_node(adev); |
41 | if (phys_dev) { |
42 | *child = get_device(dev: phys_dev); |
43 | acpi_dev_put(adev); |
44 | } else |
45 | *child = &adev->dev; |
46 | |
47 | return 0; |
48 | } |
49 | |
50 | static int __init match_pci_dev(struct device *dev, void *data) |
51 | { |
52 | unsigned int devfn = *(unsigned int *)data; |
53 | |
54 | return dev_is_pci(dev) && to_pci_dev(dev)->devfn == devfn; |
55 | } |
56 | |
57 | static long __init parse_pci_path(const struct efi_dev_path *node, |
58 | struct device *parent, struct device **child) |
59 | { |
60 | unsigned int devfn; |
61 | |
62 | if (node->header.length != 6) |
63 | return -EINVAL; |
64 | if (!parent) |
65 | return -EINVAL; |
66 | |
67 | devfn = PCI_DEVFN(node->pci.dev, node->pci.fn); |
68 | |
69 | *child = device_find_child(dev: parent, data: &devfn, match: match_pci_dev); |
70 | if (!*child) |
71 | return -ENODEV; |
72 | |
73 | return 0; |
74 | } |
75 | |
76 | /* |
77 | * Insert parsers for further node types here. |
78 | * |
79 | * Each parser takes a pointer to the @node and to the @parent (will be NULL |
80 | * for the first device path node). If a device corresponding to @node was |
81 | * found below @parent, its reference count should be incremented and the |
82 | * device returned in @child. |
83 | * |
84 | * The return value should be 0 on success or a negative int on failure. |
85 | * The special return values 0x01 (EFI_DEV_END_INSTANCE) and 0xFF |
86 | * (EFI_DEV_END_ENTIRE) signal the end of the device path, only |
87 | * parse_end_path() is supposed to return this. |
88 | * |
89 | * Be sure to validate the node length and contents before commencing the |
90 | * search for a device. |
91 | */ |
92 | |
93 | static long __init parse_end_path(const struct efi_dev_path *node, |
94 | struct device *parent, struct device **child) |
95 | { |
96 | if (node->header.length != 4) |
97 | return -EINVAL; |
98 | if (node->header.sub_type != EFI_DEV_END_INSTANCE && |
99 | node->header.sub_type != EFI_DEV_END_ENTIRE) |
100 | return -EINVAL; |
101 | if (!parent) |
102 | return -ENODEV; |
103 | |
104 | *child = get_device(dev: parent); |
105 | return node->header.sub_type; |
106 | } |
107 | |
108 | /** |
109 | * efi_get_device_by_path - find device by EFI Device Path |
110 | * @node: EFI Device Path |
111 | * @len: maximum length of EFI Device Path in bytes |
112 | * |
113 | * Parse a series of EFI Device Path nodes at @node and find the corresponding |
114 | * device. If the device was found, its reference count is incremented and a |
115 | * pointer to it is returned. The caller needs to drop the reference with |
116 | * put_device() after use. The @node pointer is updated to point to the |
117 | * location immediately after the "End of Hardware Device Path" node. |
118 | * |
119 | * If another Device Path instance follows, @len is decremented by the number |
120 | * of bytes consumed. Otherwise @len is set to %0. |
121 | * |
122 | * If a Device Path node is malformed or its corresponding device is not found, |
123 | * @node is updated to point to this offending node and an ERR_PTR is returned. |
124 | * |
125 | * If @len is initially %0, the function returns %NULL. Thus, to iterate over |
126 | * all instances in a path, the following idiom may be used: |
127 | * |
128 | * while (!IS_ERR_OR_NULL(dev = efi_get_device_by_path(&node, &len))) { |
129 | * // do something with dev |
130 | * put_device(dev); |
131 | * } |
132 | * if (IS_ERR(dev)) |
133 | * // report error |
134 | * |
135 | * Devices can only be found if they're already instantiated. Most buses |
136 | * instantiate devices in the "subsys" initcall level, hence the earliest |
137 | * initcall level in which this function should be called is "fs". |
138 | * |
139 | * Returns the device on success or |
140 | * %ERR_PTR(-ENODEV) if no device was found, |
141 | * %ERR_PTR(-EINVAL) if a node is malformed or exceeds @len, |
142 | * %ERR_PTR(-ENOTSUPP) if support for a node type is not yet implemented. |
143 | */ |
144 | struct device * __init efi_get_device_by_path(const struct efi_dev_path **node, |
145 | size_t *len) |
146 | { |
147 | struct device *parent = NULL, *child; |
148 | long ret = 0; |
149 | |
150 | if (!*len) |
151 | return NULL; |
152 | |
153 | while (!ret) { |
154 | if (*len < 4 || *len < (*node)->header.length) |
155 | ret = -EINVAL; |
156 | else if ((*node)->header.type == EFI_DEV_ACPI && |
157 | (*node)->header.sub_type == EFI_DEV_BASIC_ACPI) |
158 | ret = parse_acpi_path(node: *node, parent, child: &child); |
159 | else if ((*node)->header.type == EFI_DEV_HW && |
160 | (*node)->header.sub_type == EFI_DEV_PCI) |
161 | ret = parse_pci_path(node: *node, parent, child: &child); |
162 | else if (((*node)->header.type == EFI_DEV_END_PATH || |
163 | (*node)->header.type == EFI_DEV_END_PATH2)) |
164 | ret = parse_end_path(node: *node, parent, child: &child); |
165 | else |
166 | ret = -ENOTSUPP; |
167 | |
168 | put_device(dev: parent); |
169 | if (ret < 0) |
170 | return ERR_PTR(error: ret); |
171 | |
172 | parent = child; |
173 | *node = (void *)*node + (*node)->header.length; |
174 | *len -= (*node)->header.length; |
175 | } |
176 | |
177 | if (ret == EFI_DEV_END_ENTIRE) |
178 | *len = 0; |
179 | |
180 | return child; |
181 | } |
182 | |