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