Commit | Line | Data |
---|---|---|
95857638 | 1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
95abccb5 BM |
2 | /******************************************************************************* |
3 | * | |
4 | * Module Name: hwpci - Obtain PCI bus, device, and function numbers | |
5 | * | |
6 | ******************************************************************************/ | |
7 | ||
95abccb5 BM |
8 | #include <acpi/acpi.h> |
9 | #include "accommon.h" | |
10 | ||
11 | #define _COMPONENT ACPI_NAMESPACE | |
12 | ACPI_MODULE_NAME("hwpci") | |
13 | ||
14 | /* PCI configuration space values */ | |
15 | #define PCI_CFG_HEADER_TYPE_REG 0x0E | |
16 | #define PCI_CFG_PRIMARY_BUS_NUMBER_REG 0x18 | |
17 | #define PCI_CFG_SECONDARY_BUS_NUMBER_REG 0x19 | |
18 | /* PCI header values */ | |
19 | #define PCI_HEADER_TYPE_MASK 0x7F | |
20 | #define PCI_TYPE_BRIDGE 0x01 | |
21 | #define PCI_TYPE_CARDBUS_BRIDGE 0x02 | |
22 | typedef struct acpi_pci_device { | |
23 | acpi_handle device; | |
24 | struct acpi_pci_device *next; | |
25 | ||
26 | } acpi_pci_device; | |
27 | ||
28 | /* Local prototypes */ | |
29 | ||
30 | static acpi_status | |
31 | acpi_hw_build_pci_list(acpi_handle root_pci_device, | |
32 | acpi_handle pci_region, | |
33 | struct acpi_pci_device **return_list_head); | |
34 | ||
35 | static acpi_status | |
36 | acpi_hw_process_pci_list(struct acpi_pci_id *pci_id, | |
37 | struct acpi_pci_device *list_head); | |
38 | ||
39 | static void acpi_hw_delete_pci_list(struct acpi_pci_device *list_head); | |
40 | ||
41 | static acpi_status | |
42 | acpi_hw_get_pci_device_info(struct acpi_pci_id *pci_id, | |
43 | acpi_handle pci_device, | |
44 | u16 *bus_number, u8 *is_bridge); | |
45 | ||
46 | /******************************************************************************* | |
47 | * | |
48 | * FUNCTION: acpi_hw_derive_pci_id | |
49 | * | |
50 | * PARAMETERS: pci_id - Initial values for the PCI ID. May be | |
51 | * modified by this function. | |
52 | * root_pci_device - A handle to a PCI device object. This | |
53 | * object must be a PCI Root Bridge having a | |
54 | * _HID value of either PNP0A03 or PNP0A08 | |
55 | * pci_region - A handle to a PCI configuration space | |
56 | * Operation Region being initialized | |
57 | * | |
58 | * RETURN: Status | |
59 | * | |
60 | * DESCRIPTION: This function derives a full PCI ID for a PCI device, | |
61 | * consisting of a Segment number, Bus number, Device number, | |
62 | * and function code. | |
63 | * | |
64 | * The PCI hardware dynamically configures PCI bus numbers | |
65 | * depending on the bus topology discovered during system | |
66 | * initialization. This function is invoked during configuration | |
67 | * of a PCI_Config Operation Region in order to (possibly) update | |
68 | * the Bus/Device/Function numbers in the pci_id with the actual | |
69 | * values as determined by the hardware and operating system | |
70 | * configuration. | |
71 | * | |
72 | * The pci_id parameter is initially populated during the Operation | |
73 | * Region initialization. This function is then called, and is | |
74 | * will make any necessary modifications to the Bus, Device, or | |
75 | * Function number PCI ID subfields as appropriate for the | |
76 | * current hardware and OS configuration. | |
77 | * | |
78 | * NOTE: Created 08/2010. Replaces the previous OSL acpi_os_derive_pci_id | |
79 | * interface since this feature is OS-independent. This module | |
80 | * specifically avoids any use of recursion by building a local | |
81 | * temporary device list. | |
82 | * | |
83 | ******************************************************************************/ | |
84 | ||
85 | acpi_status | |
86 | acpi_hw_derive_pci_id(struct acpi_pci_id *pci_id, | |
87 | acpi_handle root_pci_device, acpi_handle pci_region) | |
88 | { | |
89 | acpi_status status; | |
2900d56f | 90 | struct acpi_pci_device *list_head; |
95abccb5 BM |
91 | |
92 | ACPI_FUNCTION_TRACE(hw_derive_pci_id); | |
93 | ||
94 | if (!pci_id) { | |
95 | return_ACPI_STATUS(AE_BAD_PARAMETER); | |
96 | } | |
97 | ||
98 | /* Build a list of PCI devices, from pci_region up to root_pci_device */ | |
99 | ||
100 | status = | |
101 | acpi_hw_build_pci_list(root_pci_device, pci_region, &list_head); | |
102 | if (ACPI_SUCCESS(status)) { | |
103 | ||
104 | /* Walk the list, updating the PCI device/function/bus numbers */ | |
105 | ||
106 | status = acpi_hw_process_pci_list(pci_id, list_head); | |
95abccb5 | 107 | |
c28fa24b DB |
108 | /* Delete the list */ |
109 | ||
110 | acpi_hw_delete_pci_list(list_head); | |
111 | } | |
95abccb5 | 112 | |
95abccb5 BM |
113 | return_ACPI_STATUS(status); |
114 | } | |
115 | ||
116 | /******************************************************************************* | |
117 | * | |
118 | * FUNCTION: acpi_hw_build_pci_list | |
119 | * | |
120 | * PARAMETERS: root_pci_device - A handle to a PCI device object. This | |
121 | * object is guaranteed to be a PCI Root | |
122 | * Bridge having a _HID value of either | |
123 | * PNP0A03 or PNP0A08 | |
124 | * pci_region - A handle to the PCI configuration space | |
125 | * Operation Region | |
126 | * return_list_head - Where the PCI device list is returned | |
127 | * | |
128 | * RETURN: Status | |
129 | * | |
130 | * DESCRIPTION: Builds a list of devices from the input PCI region up to the | |
131 | * Root PCI device for this namespace subtree. | |
132 | * | |
133 | ******************************************************************************/ | |
134 | ||
135 | static acpi_status | |
136 | acpi_hw_build_pci_list(acpi_handle root_pci_device, | |
137 | acpi_handle pci_region, | |
138 | struct acpi_pci_device **return_list_head) | |
139 | { | |
140 | acpi_handle current_device; | |
141 | acpi_handle parent_device; | |
142 | acpi_status status; | |
143 | struct acpi_pci_device *list_element; | |
95abccb5 BM |
144 | |
145 | /* | |
146 | * Ascend namespace branch until the root_pci_device is reached, building | |
147 | * a list of device nodes. Loop will exit when either the PCI device is | |
148 | * found, or the root of the namespace is reached. | |
149 | */ | |
2900d56f | 150 | *return_list_head = NULL; |
95abccb5 BM |
151 | current_device = pci_region; |
152 | while (1) { | |
153 | status = acpi_get_parent(current_device, &parent_device); | |
154 | if (ACPI_FAILURE(status)) { | |
c28fa24b DB |
155 | |
156 | /* Must delete the list before exit */ | |
157 | ||
158 | acpi_hw_delete_pci_list(*return_list_head); | |
95abccb5 BM |
159 | return (status); |
160 | } | |
161 | ||
162 | /* Finished when we reach the PCI root device (PNP0A03 or PNP0A08) */ | |
163 | ||
164 | if (parent_device == root_pci_device) { | |
95abccb5 BM |
165 | return (AE_OK); |
166 | } | |
167 | ||
168 | list_element = ACPI_ALLOCATE(sizeof(struct acpi_pci_device)); | |
169 | if (!list_element) { | |
c28fa24b DB |
170 | |
171 | /* Must delete the list before exit */ | |
172 | ||
173 | acpi_hw_delete_pci_list(*return_list_head); | |
95abccb5 BM |
174 | return (AE_NO_MEMORY); |
175 | } | |
176 | ||
177 | /* Put new element at the head of the list */ | |
178 | ||
2900d56f | 179 | list_element->next = *return_list_head; |
95abccb5 | 180 | list_element->device = parent_device; |
2900d56f | 181 | *return_list_head = list_element; |
95abccb5 BM |
182 | |
183 | current_device = parent_device; | |
184 | } | |
185 | } | |
186 | ||
187 | /******************************************************************************* | |
188 | * | |
189 | * FUNCTION: acpi_hw_process_pci_list | |
190 | * | |
191 | * PARAMETERS: pci_id - Initial values for the PCI ID. May be | |
192 | * modified by this function. | |
193 | * list_head - Device list created by | |
194 | * acpi_hw_build_pci_list | |
195 | * | |
196 | * RETURN: Status | |
197 | * | |
198 | * DESCRIPTION: Walk downward through the PCI device list, getting the device | |
199 | * info for each, via the PCI configuration space and updating | |
200 | * the PCI ID as necessary. Deletes the list during traversal. | |
201 | * | |
202 | ******************************************************************************/ | |
203 | ||
204 | static acpi_status | |
205 | acpi_hw_process_pci_list(struct acpi_pci_id *pci_id, | |
206 | struct acpi_pci_device *list_head) | |
207 | { | |
208 | acpi_status status = AE_OK; | |
209 | struct acpi_pci_device *info; | |
210 | u16 bus_number; | |
211 | u8 is_bridge = TRUE; | |
212 | ||
213 | ACPI_FUNCTION_NAME(hw_process_pci_list); | |
214 | ||
215 | ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, | |
216 | "Input PciId: Seg %4.4X Bus %4.4X Dev %4.4X Func %4.4X\n", | |
217 | pci_id->segment, pci_id->bus, pci_id->device, | |
218 | pci_id->function)); | |
219 | ||
220 | bus_number = pci_id->bus; | |
221 | ||
222 | /* | |
223 | * Descend down the namespace tree, collecting PCI device, function, | |
224 | * and bus numbers. bus_number is only important for PCI bridges. | |
225 | * Algorithm: As we descend the tree, use the last valid PCI device, | |
226 | * function, and bus numbers that are discovered, and assign them | |
227 | * to the PCI ID for the target device. | |
228 | */ | |
229 | info = list_head; | |
230 | while (info) { | |
231 | status = acpi_hw_get_pci_device_info(pci_id, info->device, | |
232 | &bus_number, &is_bridge); | |
233 | if (ACPI_FAILURE(status)) { | |
68aafc35 | 234 | return (status); |
95abccb5 BM |
235 | } |
236 | ||
237 | info = info->next; | |
238 | } | |
239 | ||
240 | ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, | |
241 | "Output PciId: Seg %4.4X Bus %4.4X Dev %4.4X Func %4.4X " | |
242 | "Status %X BusNumber %X IsBridge %X\n", | |
243 | pci_id->segment, pci_id->bus, pci_id->device, | |
244 | pci_id->function, status, bus_number, is_bridge)); | |
245 | ||
68aafc35 | 246 | return (AE_OK); |
95abccb5 BM |
247 | } |
248 | ||
249 | /******************************************************************************* | |
250 | * | |
251 | * FUNCTION: acpi_hw_delete_pci_list | |
252 | * | |
253 | * PARAMETERS: list_head - Device list created by | |
254 | * acpi_hw_build_pci_list | |
255 | * | |
256 | * RETURN: None | |
257 | * | |
258 | * DESCRIPTION: Free the entire PCI list. | |
259 | * | |
260 | ******************************************************************************/ | |
261 | ||
262 | static void acpi_hw_delete_pci_list(struct acpi_pci_device *list_head) | |
263 | { | |
264 | struct acpi_pci_device *next; | |
265 | struct acpi_pci_device *previous; | |
266 | ||
267 | next = list_head; | |
268 | while (next) { | |
269 | previous = next; | |
270 | next = previous->next; | |
271 | ACPI_FREE(previous); | |
272 | } | |
273 | } | |
274 | ||
275 | /******************************************************************************* | |
276 | * | |
277 | * FUNCTION: acpi_hw_get_pci_device_info | |
278 | * | |
279 | * PARAMETERS: pci_id - Initial values for the PCI ID. May be | |
280 | * modified by this function. | |
281 | * pci_device - Handle for the PCI device object | |
282 | * bus_number - Where a PCI bridge bus number is returned | |
283 | * is_bridge - Return value, indicates if this PCI | |
284 | * device is a PCI bridge | |
285 | * | |
286 | * RETURN: Status | |
287 | * | |
288 | * DESCRIPTION: Get the device info for a single PCI device object. Get the | |
289 | * _ADR (contains PCI device and function numbers), and for PCI | |
290 | * bridge devices, get the bus number from PCI configuration | |
291 | * space. | |
292 | * | |
293 | ******************************************************************************/ | |
294 | ||
295 | static acpi_status | |
296 | acpi_hw_get_pci_device_info(struct acpi_pci_id *pci_id, | |
297 | acpi_handle pci_device, | |
298 | u16 *bus_number, u8 *is_bridge) | |
299 | { | |
300 | acpi_status status; | |
301 | acpi_object_type object_type; | |
302 | u64 return_value; | |
303 | u64 pci_value; | |
304 | ||
305 | /* We only care about objects of type Device */ | |
306 | ||
307 | status = acpi_get_type(pci_device, &object_type); | |
308 | if (ACPI_FAILURE(status)) { | |
309 | return (status); | |
310 | } | |
311 | ||
312 | if (object_type != ACPI_TYPE_DEVICE) { | |
313 | return (AE_OK); | |
314 | } | |
315 | ||
316 | /* We need an _ADR. Ignore device if not present */ | |
317 | ||
318 | status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, | |
319 | pci_device, &return_value); | |
320 | if (ACPI_FAILURE(status)) { | |
321 | return (AE_OK); | |
322 | } | |
323 | ||
324 | /* | |
325 | * From _ADR, get the PCI Device and Function and | |
326 | * update the PCI ID. | |
327 | */ | |
328 | pci_id->device = ACPI_HIWORD(ACPI_LODWORD(return_value)); | |
329 | pci_id->function = ACPI_LOWORD(ACPI_LODWORD(return_value)); | |
330 | ||
331 | /* | |
332 | * If the previous device was a bridge, use the previous | |
333 | * device bus number | |
334 | */ | |
335 | if (*is_bridge) { | |
336 | pci_id->bus = *bus_number; | |
337 | } | |
338 | ||
339 | /* | |
340 | * Get the bus numbers from PCI Config space: | |
341 | * | |
342 | * First, get the PCI header_type | |
343 | */ | |
344 | *is_bridge = FALSE; | |
345 | status = acpi_os_read_pci_configuration(pci_id, | |
346 | PCI_CFG_HEADER_TYPE_REG, | |
347 | &pci_value, 8); | |
348 | if (ACPI_FAILURE(status)) { | |
349 | return (status); | |
350 | } | |
351 | ||
352 | /* We only care about bridges (1=pci_bridge, 2=card_bus_bridge) */ | |
353 | ||
354 | pci_value &= PCI_HEADER_TYPE_MASK; | |
355 | ||
356 | if ((pci_value != PCI_TYPE_BRIDGE) && | |
357 | (pci_value != PCI_TYPE_CARDBUS_BRIDGE)) { | |
358 | return (AE_OK); | |
359 | } | |
360 | ||
361 | /* Bridge: Get the Primary bus_number */ | |
362 | ||
363 | status = acpi_os_read_pci_configuration(pci_id, | |
364 | PCI_CFG_PRIMARY_BUS_NUMBER_REG, | |
365 | &pci_value, 8); | |
366 | if (ACPI_FAILURE(status)) { | |
367 | return (status); | |
368 | } | |
369 | ||
370 | *is_bridge = TRUE; | |
371 | pci_id->bus = (u16)pci_value; | |
372 | ||
373 | /* Bridge: Get the Secondary bus_number */ | |
374 | ||
375 | status = acpi_os_read_pci_configuration(pci_id, | |
376 | PCI_CFG_SECONDARY_BUS_NUMBER_REG, | |
377 | &pci_value, 8); | |
378 | if (ACPI_FAILURE(status)) { | |
379 | return (status); | |
380 | } | |
381 | ||
382 | *bus_number = (u16)pci_value; | |
383 | return (AE_OK); | |
384 | } |