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