1/*******************************************************************************
2 *
3 * Module Name: hwpci - Obtain PCI bus, device, and function numbers
4 *
5 ******************************************************************************/
6
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2012, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************/
115
116#define __HWPCI_C__
117
118#include "acpi.h"
119#include "accommon.h"
120
121
122#define _COMPONENT          ACPI_NAMESPACE
123        ACPI_MODULE_NAME    ("hwpci")
124
125
126/* PCI configuration space values */
127
128#define PCI_CFG_HEADER_TYPE_REG             0x0E
129#define PCI_CFG_PRIMARY_BUS_NUMBER_REG      0x18
130#define PCI_CFG_SECONDARY_BUS_NUMBER_REG    0x19
131
132/* PCI header values */
133
134#define PCI_HEADER_TYPE_MASK                0x7F
135#define PCI_TYPE_BRIDGE                     0x01
136#define PCI_TYPE_CARDBUS_BRIDGE             0x02
137
138typedef struct acpi_pci_device
139{
140    ACPI_HANDLE             Device;
141    struct acpi_pci_device  *Next;
142
143} ACPI_PCI_DEVICE;
144
145
146/* Local prototypes */
147
148static ACPI_STATUS
149AcpiHwBuildPciList (
150    ACPI_HANDLE             RootPciDevice,
151    ACPI_HANDLE             PciRegion,
152    ACPI_PCI_DEVICE         **ReturnListHead);
153
154static ACPI_STATUS
155AcpiHwProcessPciList (
156    ACPI_PCI_ID             *PciId,
157    ACPI_PCI_DEVICE         *ListHead);
158
159static void
160AcpiHwDeletePciList (
161    ACPI_PCI_DEVICE         *ListHead);
162
163static ACPI_STATUS
164AcpiHwGetPciDeviceInfo (
165    ACPI_PCI_ID             *PciId,
166    ACPI_HANDLE             PciDevice,
167    UINT16                  *BusNumber,
168    BOOLEAN                 *IsBridge);
169
170
171/*******************************************************************************
172 *
173 * FUNCTION:    AcpiHwDerivePciId
174 *
175 * PARAMETERS:  PciId               - Initial values for the PCI ID. May be
176 *                                    modified by this function.
177 *              RootPciDevice       - A handle to a PCI device object. This
178 *                                    object must be a PCI Root Bridge having a
179 *                                    _HID value of either PNP0A03 or PNP0A08
180 *              PciRegion           - A handle to a PCI configuration space
181 *                                    Operation Region being initialized
182 *
183 * RETURN:      Status
184 *
185 * DESCRIPTION: This function derives a full PCI ID for a PCI device,
186 *              consisting of a Segment number, Bus number, Device number,
187 *              and function code.
188 *
189 *              The PCI hardware dynamically configures PCI bus numbers
190 *              depending on the bus topology discovered during system
191 *              initialization. This function is invoked during configuration
192 *              of a PCI_Config Operation Region in order to (possibly) update
193 *              the Bus/Device/Function numbers in the PciId with the actual
194 *              values as determined by the hardware and operating system
195 *              configuration.
196 *
197 *              The PciId parameter is initially populated during the Operation
198 *              Region initialization. This function is then called, and is
199 *              will make any necessary modifications to the Bus, Device, or
200 *              Function number PCI ID subfields as appropriate for the
201 *              current hardware and OS configuration.
202 *
203 * NOTE:        Created 08/2010. Replaces the previous OSL AcpiOsDerivePciId
204 *              interface since this feature is OS-independent. This module
205 *              specifically avoids any use of recursion by building a local
206 *              temporary device list.
207 *
208 ******************************************************************************/
209
210ACPI_STATUS
211AcpiHwDerivePciId (
212    ACPI_PCI_ID             *PciId,
213    ACPI_HANDLE             RootPciDevice,
214    ACPI_HANDLE             PciRegion)
215{
216    ACPI_STATUS             Status;
217    ACPI_PCI_DEVICE         *ListHead = NULL;
218
219
220    ACPI_FUNCTION_TRACE (HwDerivePciId);
221
222
223    if (!PciId)
224    {
225        return_ACPI_STATUS (AE_BAD_PARAMETER);
226    }
227
228    /* Build a list of PCI devices, from PciRegion up to RootPciDevice */
229
230    Status = AcpiHwBuildPciList (RootPciDevice, PciRegion, &ListHead);
231    if (ACPI_SUCCESS (Status))
232    {
233        /* Walk the list, updating the PCI device/function/bus numbers */
234
235        Status = AcpiHwProcessPciList (PciId, ListHead);
236    }
237
238    /* Always delete the list */
239
240    AcpiHwDeletePciList (ListHead);
241    return_ACPI_STATUS (Status);
242}
243
244
245/*******************************************************************************
246 *
247 * FUNCTION:    AcpiHwBuildPciList
248 *
249 * PARAMETERS:  RootPciDevice       - A handle to a PCI device object. This
250 *                                    object is guaranteed to be a PCI Root
251 *                                    Bridge having a _HID value of either
252 *                                    PNP0A03 or PNP0A08
253 *              PciRegion           - A handle to the PCI configuration space
254 *                                    Operation Region
255 *              ReturnListHead      - Where the PCI device list is returned
256 *
257 * RETURN:      Status
258 *
259 * DESCRIPTION: Builds a list of devices from the input PCI region up to the
260 *              Root PCI device for this namespace subtree.
261 *
262 ******************************************************************************/
263
264static ACPI_STATUS
265AcpiHwBuildPciList (
266    ACPI_HANDLE             RootPciDevice,
267    ACPI_HANDLE             PciRegion,
268    ACPI_PCI_DEVICE         **ReturnListHead)
269{
270    ACPI_HANDLE             CurrentDevice;
271    ACPI_HANDLE             ParentDevice;
272    ACPI_STATUS             Status;
273    ACPI_PCI_DEVICE         *ListElement;
274    ACPI_PCI_DEVICE         *ListHead = NULL;
275
276
277    /*
278     * Ascend namespace branch until the RootPciDevice is reached, building
279     * a list of device nodes. Loop will exit when either the PCI device is
280     * found, or the root of the namespace is reached.
281     */
282    CurrentDevice = PciRegion;
283    while (1)
284    {
285        Status = AcpiGetParent (CurrentDevice, &ParentDevice);
286        if (ACPI_FAILURE (Status))
287        {
288            return (Status);
289        }
290
291        /* Finished when we reach the PCI root device (PNP0A03 or PNP0A08) */
292
293        if (ParentDevice == RootPciDevice)
294        {
295            *ReturnListHead = ListHead;
296            return (AE_OK);
297        }
298
299        ListElement = ACPI_ALLOCATE (sizeof (ACPI_PCI_DEVICE));
300        if (!ListElement)
301        {
302            return (AE_NO_MEMORY);
303        }
304
305        /* Put new element at the head of the list */
306
307        ListElement->Next = ListHead;
308        ListElement->Device = ParentDevice;
309        ListHead = ListElement;
310
311        CurrentDevice = ParentDevice;
312    }
313}
314
315
316/*******************************************************************************
317 *
318 * FUNCTION:    AcpiHwProcessPciList
319 *
320 * PARAMETERS:  PciId               - Initial values for the PCI ID. May be
321 *                                    modified by this function.
322 *              ListHead            - Device list created by
323 *                                    AcpiHwBuildPciList
324 *
325 * RETURN:      Status
326 *
327 * DESCRIPTION: Walk downward through the PCI device list, getting the device
328 *              info for each, via the PCI configuration space and updating
329 *              the PCI ID as necessary. Deletes the list during traversal.
330 *
331 ******************************************************************************/
332
333static ACPI_STATUS
334AcpiHwProcessPciList (
335    ACPI_PCI_ID             *PciId,
336    ACPI_PCI_DEVICE         *ListHead)
337{
338    ACPI_STATUS             Status = AE_OK;
339    ACPI_PCI_DEVICE         *Info;
340    UINT16                  BusNumber;
341    BOOLEAN                 IsBridge = TRUE;
342
343
344    ACPI_FUNCTION_NAME (HwProcessPciList);
345
346
347    ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
348        "Input PciId:  Seg %4.4X Bus %4.4X Dev %4.4X Func %4.4X\n",
349        PciId->Segment, PciId->Bus, PciId->Device, PciId->Function));
350
351    BusNumber = PciId->Bus;
352
353    /*
354     * Descend down the namespace tree, collecting PCI device, function,
355     * and bus numbers. BusNumber is only important for PCI bridges.
356     * Algorithm: As we descend the tree, use the last valid PCI device,
357     * function, and bus numbers that are discovered, and assign them
358     * to the PCI ID for the target device.
359     */
360    Info = ListHead;
361    while (Info)
362    {
363        Status = AcpiHwGetPciDeviceInfo (PciId, Info->Device,
364            &BusNumber, &IsBridge);
365        if (ACPI_FAILURE (Status))
366        {
367            return (Status);
368        }
369
370        Info = Info->Next;
371    }
372
373    ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
374        "Output PciId: Seg %4.4X Bus %4.4X Dev %4.4X Func %4.4X "
375        "Status %X BusNumber %X IsBridge %X\n",
376        PciId->Segment, PciId->Bus, PciId->Device, PciId->Function,
377        Status, BusNumber, IsBridge));
378
379    return (AE_OK);
380}
381
382
383/*******************************************************************************
384 *
385 * FUNCTION:    AcpiHwDeletePciList
386 *
387 * PARAMETERS:  ListHead            - Device list created by
388 *                                    AcpiHwBuildPciList
389 *
390 * RETURN:      None
391 *
392 * DESCRIPTION: Free the entire PCI list.
393 *
394 ******************************************************************************/
395
396static void
397AcpiHwDeletePciList (
398    ACPI_PCI_DEVICE         *ListHead)
399{
400    ACPI_PCI_DEVICE         *Next;
401    ACPI_PCI_DEVICE         *Previous;
402
403
404    Next = ListHead;
405    while (Next)
406    {
407        Previous = Next;
408        Next = Previous->Next;
409        ACPI_FREE (Previous);
410    }
411}
412
413
414/*******************************************************************************
415 *
416 * FUNCTION:    AcpiHwGetPciDeviceInfo
417 *
418 * PARAMETERS:  PciId               - Initial values for the PCI ID. May be
419 *                                    modified by this function.
420 *              PciDevice           - Handle for the PCI device object
421 *              BusNumber           - Where a PCI bridge bus number is returned
422 *              IsBridge            - Return value, indicates if this PCI
423 *                                    device is a PCI bridge
424 *
425 * RETURN:      Status
426 *
427 * DESCRIPTION: Get the device info for a single PCI device object. Get the
428 *              _ADR (contains PCI device and function numbers), and for PCI
429 *              bridge devices, get the bus number from PCI configuration
430 *              space.
431 *
432 ******************************************************************************/
433
434static ACPI_STATUS
435AcpiHwGetPciDeviceInfo (
436    ACPI_PCI_ID             *PciId,
437    ACPI_HANDLE             PciDevice,
438    UINT16                  *BusNumber,
439    BOOLEAN                 *IsBridge)
440{
441    ACPI_STATUS             Status;
442    ACPI_OBJECT_TYPE        ObjectType;
443    UINT64                  ReturnValue;
444    UINT64                  PciValue;
445
446
447    /* We only care about objects of type Device */
448
449    Status = AcpiGetType (PciDevice, &ObjectType);
450    if (ACPI_FAILURE (Status))
451    {
452        return (Status);
453    }
454
455    if (ObjectType != ACPI_TYPE_DEVICE)
456    {
457        return (AE_OK);
458    }
459
460    /* We need an _ADR. Ignore device if not present */
461
462    Status = AcpiUtEvaluateNumericObject (METHOD_NAME__ADR,
463        PciDevice, &ReturnValue);
464    if (ACPI_FAILURE (Status))
465    {
466        return (AE_OK);
467    }
468
469    /*
470     * From _ADR, get the PCI Device and Function and
471     * update the PCI ID.
472     */
473    PciId->Device = ACPI_HIWORD (ACPI_LODWORD (ReturnValue));
474    PciId->Function = ACPI_LOWORD (ACPI_LODWORD (ReturnValue));
475
476    /*
477     * If the previous device was a bridge, use the previous
478     * device bus number
479     */
480    if (*IsBridge)
481    {
482        PciId->Bus = *BusNumber;
483    }
484
485    /*
486     * Get the bus numbers from PCI Config space:
487     *
488     * First, get the PCI HeaderType
489     */
490    *IsBridge = FALSE;
491    Status = AcpiOsReadPciConfiguration (PciId,
492        PCI_CFG_HEADER_TYPE_REG, &PciValue, 8);
493    if (ACPI_FAILURE (Status))
494    {
495        return (Status);
496    }
497
498    /* We only care about bridges (1=PciBridge, 2=CardBusBridge) */
499
500    PciValue &= PCI_HEADER_TYPE_MASK;
501
502    if ((PciValue != PCI_TYPE_BRIDGE) &&
503        (PciValue != PCI_TYPE_CARDBUS_BRIDGE))
504    {
505        return (AE_OK);
506    }
507
508    /* Bridge: Get the Primary BusNumber */
509
510    Status = AcpiOsReadPciConfiguration (PciId,
511        PCI_CFG_PRIMARY_BUS_NUMBER_REG, &PciValue, 8);
512    if (ACPI_FAILURE (Status))
513    {
514        return (Status);
515    }
516
517    *IsBridge = TRUE;
518    PciId->Bus = (UINT16) PciValue;
519
520    /* Bridge: Get the Secondary BusNumber */
521
522    Status = AcpiOsReadPciConfiguration (PciId,
523        PCI_CFG_SECONDARY_BUS_NUMBER_REG, &PciValue, 8);
524    if (ACPI_FAILURE (Status))
525    {
526        return (Status);
527    }
528
529    *BusNumber = (UINT16) PciValue;
530    return (AE_OK);
531}
532